= 5):\n cc_flags += ['-std=c++11']\n if CAD_DEBUG:\n cc_flags += ['-O0']\n else:\n cc_flags += ['-O3']\n if (find_in_path(['g++']) is not None):\n cc_flags += ['-ffast-math'] # essential to get vectorization and performance\n cc_flags += ['-funroll-loops']\n cc_flags += ['-mtune=native'] # optimize for the current CPU but preserve portability\n if platform.processor() == 'x86_64':\n if CAD_GCC_NATIVE:\n # flag does not work e.g. on IBM Minsky systems\n cc_flags += ['-march=native']\n # cc_flags += ['-march=skylake-avx512']\n else:\n cc_flags += ['-msse4.2'] # required for fast round() instruction\n if not on_mac():\n if CAD_OPENMP:\n cc_flags += ['-fopenmp']\n cc_flags += ['-lgomp']\n # avoid flag during GitLab continuous integration to keep the log slim\n if 'CI' not in os.environ:\n cc_flags += ['-fopt-info']\n # cc_flags += ['-ftree-vectorize']\n # cc_flags += ['-fopt-info-vec-missed']\n cc_flags += ['-Wno-unknown-pragmas']\n else:\n # non-gcc branch\n cc_flags += ['-O2']\n print(\"GCC flags: {}\".format(\" \".join(cc_flags)))\n return cc_flags","def select_proposals(proposals_list):\r\n \r\n return []","def get_violations(self,\n env,\n only_state=False\n ):\n if only_state:\n flags = [con.is_violated(env) for con in self.state_constraints]\n else:\n flags = [con.is_violated(env) for con in self.constraints]\n return flags","def forbidden_processes(self):\n return {name for name, flag in self._required_processes.items() if not flag}","def expand(formula,var,val):\n return [clause - {(var, not val)} # group 2 modified here\n for clause in formula \n if (var,val) not in clause] # group 1 removed here"],"string":"[\n \"def bool_attr_list_1(gdbval, candidates):\\n\\n r = []\\n for i in candidates:\\n if long (gdbval[i[0]]) != 0:\\n r.append(i[1])\\n pass\\n pass\\n return r\",\n \"def flags(self):\\n flags = self.Flags\\n return [x for x in self.FLAGS_VALUES if flags & x]\",\n \"def checkallflags(flags_with_values,flags_withoutvalues,cldic):\\r\\n if len(set(flags_with_values).intersection(set(flags_without_values))) > 0:\\r\\n print ( \\\"error some flags appear in two lists of flags, with and without required values:\\\",set(flags_with_values).intersection(set(flags_without_values)))\\r\\n printcommandset()\\r\\n sys.exit(1)\\r\\n for flag in set(flags_with_values).union(set(flags_withoutvalues)):\\r\\n if flag not in cldic:\\r\\n print ( \\\"error some flag mismatch between strings of flags and dictionary of flags:\\\",flag)\\r\\n printcommandset()\\r\\n sys.exit(1)\\r\\n return\",\n \"def process_flags(self):\\n\\t\\tsflags = []\\n\\t\\tfor attr in dir(self):\\n\\t\\t\\tif attr[:3] != \\\"PF_\\\":\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\tvalue = getattr(self, attr)\\n\\t\\t\\tif value & self.fields[\\\"flags\\\"]:\\n\\t\\t\\t\\tsflags.append(attr)\\n\\n\\t\\treturn sflags\",\n \"def gn_files(self):\\n return set(self._gn_flags.keys())\",\n \"def unused_featurevalues():\\n\\n fvs = FeatureValue.objects.filter(feature__active=True)\\n unused_fvs = fvs.filter(languages__isnull=True)\\n natlang_only_fvs = fvs.filter(languages__language__natlang=True).exclude(languages__language__natlang=False)\\n\\n if not natlang_only_fvs:\\n # Natlangs had no unique features so return early\\n return unused_fvs\\n\\n # dsd\\n decorate = ((fv.id, fv) for fv in set(unused_fvs) | set(natlang_only_fvs))\\n sort = sorted(decorate)\\n return [fv for (_, fv) in sort]\",\n \"def flagSet():\\r\\n for flag in flags:\\r\\n if flags[flag]:\\r\\n return True\\r\\n return False\",\n \"def list_set_flags(self, include=frozenset(), exclude=frozenset()):\\n for (name, desc) in self.list_flags():\\n if name in exclude:\\n continue\\n if (name in include) or (desc.value is not desc.default):\\n yield (name, desc)\",\n \"def box_flags(self, box):\\n return [flag for flag in self.flags if flag.box == box]\",\n \"def _RemoveUnusedFlags( flags, filename ):\\n\\n new_flags = []\\n\\n # When flags come from the compile_commands.json file, the first flag is\\n # usually the path to the compiler that should be invoked. We want to strip\\n # that.\\n if not flags[ 0 ].startswith( '-' ):\\n flags = flags[ 1: ]\\n\\n skip = False\\n for flag in flags:\\n if skip:\\n skip = False\\n continue\\n\\n if flag == '-c':\\n continue\\n\\n if flag == '-o':\\n skip = True;\\n continue\\n\\n if flag == filename or os.path.realpath( flag ) == filename:\\n continue\\n\\n new_flags.append( flag )\\n return new_flags\",\n \"def no_flags_set(self):\\n # TODO: unit test me\\n return not any(\\n (\\n self.flag_bookmarked,\\n self.flag_candidate,\\n self.flag_final_causative,\\n self.flag_for_validation,\\n self.flag_molecular != \\\"empty\\\",\\n self.flag_visual != \\\"empty\\\",\\n self.flag_validation != \\\"empty\\\",\\n self.flag_phenotype_match != \\\"empty\\\",\\n self.flag_summary != \\\"empty\\\",\\n )\\n )\",\n \"def _not_matching(values, sieve):\\n return [val for val in values if val not in sieve]\",\n \"def prune_gbm_features(schema: Dict):\\n gbm_feature_types = ['binary', 'category', 'number']\\n pruned_all_of = []\\n for cond in schema['items']['allOf']:\\n if_type = cond['if']['properties']['type']['const']\\n if if_type in gbm_feature_types:\\n pruned_all_of += [cond]\\n schema['items']['allOf'] = pruned_all_of\",\n \"def get_flags(self):\\n\\n if self.raw.flags not in [0, 1, 2, 3]:\\n raise ValueError(\\\"Invalid raw flags: {}\\\".format(self.raw.flags))\\n\\n flags = set()\\n\\n if (self.raw.flags & 0b010) > 0:\\n flags.add(\\\"DF\\\")\\n\\n if (self.raw.flags & 0b001) > 0:\\n flags.add(\\\"MF\\\")\\n\\n return frozenset(flags)\",\n \"def get_source_candidates(all_data_epigen):\\n candids = {s:\\n [np.where(np.array(c[1])!=0)[0] for c in mdata[\\\"test\\\"] ]\\n for s, mdata in all_data_epigen.items()}\\n return candids\",\n \"def test_removeFlags(self):\\n self._flagsTest('removeFlags', b'-FLAGS')\",\n \"def flags(self):\\n return list(self._flags_generator())\",\n \"def resetFlags():\\r\\n for flag in flags:\\r\\n flags[flag] = False\",\n \"def compute_filtered_features(self, features):\\n return [\\n feature\\n for feature in features\\n if \\\"\\\".join(feature.qualifiers.get(\\\"is_edit\\\", \\\"false\\\")) != \\\"true\\\"\\n ]\",\n \"def list_flags(self):\\n return self._defs.items()\",\n \"def _computesuspendedset(repo):\\n suspended = repo.changelog.ancestors(getrevs(repo, 'unstable'))\\n return set(r for r in getrevs(repo, 'obsolete') if r in suspended)\",\n \"def remove_invalid_flags(flags):\\n\\n # Validate flag format\\n filtered_flags = [flag for flag in flags if is_valid_flag(flag)]\\n\\n number_of_removed_flags = len(flags) - len(filtered_flags)\\n\\n if number_of_removed_flags:\\n log.failure(\\\"Removed {} flags with incorrect format.\\\".format(number_of_removed_flags))\\n\\n return filtered_flags\",\n \"def get_mutations_we_miss(quality_cutoff):\\n\\n murim_mutations = get_murim_mutations(quality_cutoff)\\n my_mutations = get_my_mutations(quality_cutoff)\\n\\n missing = {}\\n for chrpos in murim_mutations:\\n if chrpos not in my_mutations:\\n missing[chrpos] = True\\n return missing\",\n \"def get_all_flags(options):\\n flags = []\\n if options.inputFlag:\\n flags.append(try_to_int(options.inputFlag))\\n if options.outputFlags:\\n for flag in options.outputFlags:\\n flags.append(try_to_int(flag))\\n return flags\",\n \"def prune_option_list(opts, keys):\\n opt_d = opt_to_dict(opts)\\n for k in keys:\\n if k in opt_d:\\n del opt_d[k]\\n return [k for item in opt_d.iteritems() for k in item]\",\n \"def get_flagged(self):\\n self.cur.execute(\\\"SELECT video_ID FROM flags\\\")\\n flagged_IDs = []\\n for ID in self.cur.fetchall():\\n flagged_IDs.append(ID[0])\\n return flagged_IDs\",\n \"def core_mask(self):\\n mask = []\\n for atom in self.atoms:\\n if \\\"shell\\\" not in atom.atom_type.label:\\n mask.append(True)\\n else:\\n mask.append(False)\\n return mask\",\n \"def get_eval_flag_dict(eval_mode):\\n\\n # Base dictionary with all flags set to True.\\n dict = {}\\n for key in EVAL_FLAGS:\\n dict[key] = True\\n\\n # Auto-annotations.\\n if eval_mode == \\\"draft\\\":\\n dict[\\\"check_locus_tag\\\"] = False\\n dict[\\\"check_trna\\\"] = False\\n dict[\\\"import_locus_tag\\\"] = False\\n dict[\\\"check_id_typo\\\"] = False\\n dict[\\\"check_host_typo\\\"] = False\\n dict[\\\"check_author\\\"] = False\\n dict[\\\"check_description\\\"] = False\\n dict[\\\"check_coords\\\"] = False\\n\\n # Manual annotations.\\n elif eval_mode == \\\"final\\\":\\n dict[\\\"import_locus_tag\\\"] = False\\n\\n # SEA-PHAGES GenBank records.\\n elif eval_mode == \\\"auto\\\":\\n dict[\\\"check_locus_tag\\\"] = False\\n dict[\\\"check_description_field\\\"] = False\\n dict[\\\"check_replace\\\"] = False\\n dict[\\\"check_trna\\\"] = False\\n dict[\\\"check_id_typo\\\"] = False\\n dict[\\\"check_host_typo\\\"] = False\\n dict[\\\"check_author\\\"] = False\\n dict[\\\"check_description\\\"] = False\\n dict[\\\"check_description_tally\\\"] = False\\n dict[\\\"check_gene\\\"] = False\\n dict[\\\"check_coords\\\"] = False\\n\\n # Non-SEA-PHAGES GenBank records.\\n elif eval_mode == \\\"misc\\\":\\n dict[\\\"check_locus_tag\\\"] = False\\n # TODO below should probably be True, but it causes problems\\n # when checking the current genome, GNM2_001, since these are not 'draft'\\n # genomes.\\n dict[\\\"check_replace\\\"] = False\\n dict[\\\"check_trna\\\"] = False\\n dict[\\\"check_id_typo\\\"] = False\\n dict[\\\"check_host_typo\\\"] = False\\n dict[\\\"check_author\\\"] = False\\n dict[\\\"check_description\\\"] = False\\n dict[\\\"check_description_tally\\\"] = False\\n dict[\\\"check_gene\\\"] = False\\n\\n # Custom QC settings. User can select the settings, so it is initialized as\\n # a copy of the base eval_mode. The user can provide the\\n # customized combination of options.\\n elif eval_mode == \\\"custom\\\":\\n for key in dict.keys():\\n prompt = f\\\"Eval_flag: {key}. {EVAL_FLAGS[key]}\\\"\\n response = basic.ask_yes_no(prompt=prompt, response_attempt=3)\\n if response is None:\\n print(\\\"The default setting for this eval_flag will be used.\\\")\\n else:\\n dict[key] = response\\n\\n elif eval_mode == \\\"base\\\":\\n pass\\n else:\\n print(\\\"A valid eval_mode has not been selected.\\\")\\n return dict\",\n \"def generateCandidates(self):\\n\\t\\tprint(\\\"Candidate list:\\\\n\\\")\\n\\t\\tkeys = list(self.prune_list.keys())\\n\\t\\ttuple_count = len(keys[0])\\n\\t\\tprune_list = {}\\n\\t\\ttup = []\\n\\t\\tfor v in comb(keys, 2):\\n\\t\\t\\ta = set(v[0])\\n\\t\\t\\tb = set(v[1])\\n\\t\\t\\t\\n\\t\\t\\t# If there's as many common element in a & b as one less than tuple_count\\n\\t\\t\\tif((len(a & b) == (tuple_count - 1)) and (tuple(a | b) not in tup)):\\n\\t\\t\\t\\ttup.append(tuple(a | b))\\n\\t\\t\\t\\tprint(tup[-1])\\n\\t\\t\\t\\t# Update prune list\\n\\t\\t\\t\\tcount = self.getSupport(tup[-1])\\n\\t\\t\\t\\tif(count >= self.support):\\n\\t\\t\\t\\t\\tprune_list[tup[-1]] = count\\n\\t\\treturn prune_list\",\n \"def get_our_extra_mutations(quality_cutoff):\\n\\n murim_mutations = get_murim_mutations(quality_cutoff)\\n my_mutations = get_my_mutations(quality_cutoff)\\n\\n missing = {}\\n for chrpos in my_mutations:\\n if chrpos not in murim_mutations:\\n missing[chrpos] = True\\n return missing\",\n \"def _SanitizeFlags( flags ):\\n\\n sanitized_flags = []\\n saw_arch = False\\n for i, flag in enumerate( flags ):\\n if flag == '-arch':\\n saw_arch = True\\n continue\\n elif flag.startswith( '-arch' ):\\n continue\\n elif saw_arch:\\n saw_arch = False\\n continue\\n\\n sanitized_flags.append( flag )\\n\\n vector = ycm_core.StringVec()\\n for flag in sanitized_flags:\\n vector.append( flag )\\n return vector\",\n \"def all(c):\\n states(c)\\n etc(c)\\n prune(c)\",\n \"def remove_old_flags():\\n # N.B. We remove only those features we know absolutely nothing about,\\n # which means that FEATURES_PENDING_REMOVAL are left alone.\\n known = set(FEATURES) | set(FEATURES_PENDING_REMOVAL)\\n unknown_flags = Feature.query.filter(sa.not_(Feature.name.in_(known)))\\n count = unknown_flags.delete(synchronize_session=False)\\n if count > 0:\\n log.info('removed %d old/unknown feature flags from database', count)\",\n \"def filter_depend( self, atoms ):\\n\\n def dep_string_reduce(dep_string,enabled_useflags):\\n dest = []\\n tokens = iter(dep_string.split())\\n useflags = enabled_useflags.split()\\n\\n for token in tokens:\\n if token[-1] == \\\"?\\\":\\n if token.startswith(\\\"!\\\"):\\n skip = token[1:-1] in useflags\\n else:\\n skip = token[:-1] not in useflags\\n if skip:\\n level = 0\\n while 1:\\n token = next(tokens)\\n if token == \\\"(\\\":\\n level+=1\\n if token == \\\")\\\":\\n level-=1\\n if level < 1:\\n break\\n continue\\n elif token == \\\"(\\\" or token == \\\")\\\":\\n continue\\n else:\\n dest.append(token)\\n\\n return \\\" \\\".join(dest)\\n\\n # gjl does not use use flags\\n try:\\n use = os.environ[\\\"USE\\\"]\\n atoms = dep_string_reduce(atoms, use)\\n except KeyError:\\n pass\\n return atoms\",\n \"def missing_in_gn(self):\\n return self._missing_gn_flags\",\n \"def get_user_vars(cnf):\\n U = set(abs(l) for lst in cnf.clauses for l in lst)\\n return U\",\n \"def Clean(pmf):\\n vals = [val for val in pmf.Values() if val < thresh]\\n [pmf.Remove(val) for val in vals]\",\n \"def flags(self):\\n return self.__flag_set\",\n \"def _get_flags(args: Sequence[str]) -> Dict[str, bool]:\\n flags = {}\\n for arg in args:\\n if arg.startswith(FLAG_MARKER):\\n flag_name = arg[len(FLAG_MARKER):]\\n if flag_name and flag_name not in OMIT_FLAGS:\\n flags[flag_name] = True\\n else:\\n break # Ignore flags after initial CLI call\\n return flags\",\n \"def subset_pass_constraints(df):\\n # All the constraints strings to test against. Must follow regex.\\n # Keys: user-firendly constraint name, used for pass/fail bool column\\n # Values: strings to test against\\n accept_constraints = {\\n \\\"pass_del_a_mu\\\": r\\\"Muon magn\\\\. mom\\\\. more than 2 sigma away\\\",\\n \\\"pass_relic\\\": r\\\"Relic density too small \\\\(Planck\\\\)\\\",\\n \\\"pass_bctaunu\\\": r\\\"b \\\\-> c tau nu more than 2 sigma away \\\\(as SM\\\\)\\\",\\n \\\"pass_chi2zz\\\": r\\\"chi2\\\\(H\\\\->ZZ\\\\) > 6\\\\.18\\\",\\n \\\"pass_chi2bb\\\": r\\\"chi2\\\\(H\\\\->bb\\\\) > 6\\\\.18\\\",\\n \\\"pass_chi2gg\\\": r\\\"chi2\\\\(H\\\\->gg\\\\) > 6\\\\.18\\\",\\n \\\"pass_cms4mu\\\": r\\\"Excluded H_125\\\\->AA\\\\->4mu \\\\(CMS\\\\)\\\"\\n }\\n for k, v in accept_constraints.iteritems():\\n df[k] = ~df.constraints.str.contains(v)\\n\\n # We want a bitmask, so for each entry we simply want a True or False\\n # First make a copy of the constraints Series\\n con_series = df.constraints.copy(deep=True)\\n # Now for each entry we remove the constraints we don't mind failing\\n for c in accept_constraints.values():\\n con_series = con_series.str.replace(c, \\\"\\\")\\n # con_series = con_series.str.replace(r\\\"^\\\\|+$\\\", \\\"\\\") # Any leftover separators\\n con_series = con_series.apply(lambda x: x.strip('|'))\\n con_series = con_series.str.replace(r\\\"\\\\|\\\\|+\\\", r\\\"|\\\") # Any multiple separators\\n # Now figure out which ones are empty\\n mask = con_series.str.match(\\\"^$\\\")\\n # Return those entries, allowing for a +ve muon mag moment contribution\\n return df[mask & (df.Del_a_mu > 0)]\",\n \"def filter_non_viable(pairs, grammar):\\n viable_dict = dict()\\n pairs = list(pairs)\\n unsure = defaultdict(int)\\n\\n while pairs:\\n for i, pair in reversed(list(enumerate(pairs))):\\n if is_viable(pair, viable_dict, grammar) is None:\\n unsure[pair] += 1\\n if unsure[pair] < THRESHOLD:\\n continue\\n viable_dict[pair] = True\\n del pairs[i]\\n return [pair for pair in viable_dict if viable_dict[pair]]\",\n \"def collect_primed_vars(t):\\n g = Tree.from_recursive_ast(t)\\n # (node, context)\\n Q = [(t, False)]\\n primed = set()\\n while Q:\\n u, c = Q.pop()\\n if u.type == 'var' and c:\\n primed.add(u.value)\\n try:\\n c = (u.operator == 'X') or c\\n except AttributeError:\\n pass\\n Q.extend((v, c) for v in g.successors(u))\\n return primed\",\n \"def __eliminate_unused_constraits (self, objects):\\n result = []\\n for c in self.constraints_:\\n if c [0] in objects and c [1] in objects:\\n result.append (c)\\n\\n return result\",\n \"def test_getlist(self):\\n flags = flag_lists(appversions={\\\"code\\\": \\\"fx1.0\\\"})\\n eq_(flags, {(\\\"fx\\\", \\\"pl\\\"): [0],\\n (\\\"fx\\\", \\\"de\\\"): [1],\\n (\\\"fx\\\", \\\"fr\\\"): [2],\\n (\\\"fx\\\", \\\"da\\\"): [1, 0]})\",\n \"def _flags_to_try(source, flags, auto_flags, mode):\\n flags = CompilerFlags(flags)\\n if sys.version_info >= (3, 8):\\n if re.search(r\\\"# *type:\\\", source):\\n flags = flags | CompilerFlags('type_comments')\\n yield flags\\n return\\n if not auto_flags:\\n yield flags\\n return\\n if PY3:\\n yield flags\\n return\\n if mode == \\\"eval\\\":\\n if re.search(r\\\"\\\\bprint\\\\b\\\", source):\\n flags = flags | CompilerFlags(\\\"print_function\\\")\\n yield flags\\n return\\n yield flags\\n if re.search(r\\\"\\\\bprint\\\\b\\\", source):\\n yield flags ^ CompilerFlags(\\\"print_function\\\")\",\n \"def list_scrubber_opts():\\n return [(g, copy.deepcopy(o)) for g, o in _scrubber_opts]\",\n \"def _list_usage_flags():\\n yield from sorted(self._defs.items())\\n if self._parent is None:\\n if self._CONFIG_FLAG.name not in self._defs:\\n yield (self._CONFIG_FLAG.name, self._CONFIG_FLAG)\",\n \"def parseFlags(self):\\n # Blank return value.\\n retVal = \\\"\\\"\\n \\n try:\\n # Store flags as we parse them.\\n allFlags = []\\n \\n # Get the accumulator flag.\\n accFlag = self.__flags & self.f_accum\\n trendFlag = self.__flags & self.f_trend\\n modeFlag = self.__flags & self.f_mode\\n \\n # Complete set of readings?\\n if accFlag == self.f_accum_complete:\\n # Completed loading values into the accumulator.\\n allFlags.append('C')\\n elif accFlag == self.f_accum_accum:\\n # Still accumulating.\\n allFlags.append('A')\\n elif accFlag == self.f_accum_unk:\\n # Unknown.\\n allFlags.append('?')\\n else:\\n # Bad value.\\n allFlags.append('!')\\n \\n # Trend?\\n if (trendFlag) == self.f_trend_stable:\\n # Readings stable.\\n allFlags.append('S')\\n elif (trendFlag) == self.f_trend_up:\\n # Still accumulating.\\n allFlags.append('U')\\n elif (trendFlag) == self.f_trend_dn:\\n # Still accumulating.\\n allFlags.append('D')\\n elif (trendFlag) == self.f_trend_unk:\\n # Still accumulating.\\n allFlags.append('?')\\n else:\\n # Bad value.\\n allFlags.append('!')\\n \\n # Mode?\\n if modeFlag == self.f_mode_fast:\\n # Fast\\n allFlags.append('F')\\n elif modeFlag == self.f_mode_slow:\\n # Slow\\n allFlags.append('S')\\n elif modeFlag == self.f_mode_counter:\\n # Stream\\n allFlags.append('C')\\n elif modeFlag == self.f_mode_scaler:\\n # Roll\\n allFlags.append('L')\\n else:\\n # Bad value.\\n allFlags.append('!')\\n \\n # Build a nice string.\\n retVal = ''.join(allFlags)\\n \\n \\n except:\\n raise\\n \\n # Return value.\\n return retVal\",\n \"def flags(self):\\r\\n return flags.SuggestionFlags(self)\",\n \"def flags(self) -> list[\\\"ProjectCommandFlag\\\"]:\\n _args: list[Arg] = []\\n _ctx = self._select(\\\"flags\\\", _args)\\n _ctx = ProjectCommandFlag(_ctx)._select_multiple(\\n _description=\\\"description\\\",\\n _name=\\\"name\\\",\\n )\\n return _ctx.execute_sync(list[ProjectCommandFlag])\",\n \"def all_bees_lowered_flag(self):\\n pos, com, success = self.perception\\n return all(map(lambda x: x[1][\\\"flag\\\"] == 0, com))\",\n \"def get_flags(args):\\r\\n\\r\\n flags = 0\\r\\n\\r\\n if args.regexfilepattern is not None:\\r\\n flags |= pygrep.FILE_REGEX_MATCH\\r\\n\\r\\n if not args.regexp:\\r\\n flags |= pygrep.LITERAL\\r\\n elif args.dotall:\\r\\n flags |= pygrep.DOTALL\\r\\n\\r\\n if args.ignore_case:\\r\\n flags |= pygrep.IGNORECASE\\r\\n\\r\\n if args.recursive:\\r\\n flags |= pygrep.RECURSIVE\\r\\n\\r\\n if args.regexdirpattern:\\r\\n flags |= pygrep.DIR_REGEX_MATCH\\r\\n\\r\\n return flags\",\n \"def complete_opt_allow_select_scan(self, text, *_):\\n return [t for t in (\\\"true\\\", \\\"false\\\", \\\"yes\\\", \\\"no\\\") if t.startswith(text.lower())]\",\n \"def test_get_all_flags(self):\\n include_prefixes = ['-I']\\n db = CppProperties(include_prefixes)\\n\\n expected = [\\n Flag('-I', path.normpath('/folder/include/path')),\\n Flag('-I', path.normpath('/another/file/path')),\\n ]\\n\\n scope = SearchScope(from_folder=_get_test_folder('simple'))\\n self.assertEqual(expected, db.get_flags(search_scope=scope))\",\n \"def memb_residues(pdb: MyPDB) -> list():\\n result = []\\n for ch in pdb.chains.values():\\n for res in ch.values():\\n if res.memb_z is not None:\\n result.append(res)\\n return result\",\n \"def used_xvals(self):\\n return [x for x in self.xvals() if any([len(self.get_plaquette(x, y)) > 0\\n for y in self.yvals()])]\",\n \"def EvaluateFlags(flags: int) -> Dict[str, bool]:\\n results = {}\\n sumFlags = 0\\n for flagName, flagMaskVal in RSEGeometryFlags.FLAG_MASKS.items():\\n sumFlags += flagMaskVal\\n if flagMaskVal & flags > 0:\\n results[flagName] = True\\n else:\\n results[flagName] = False\\n\\n if flags > sumFlags:\\n results[\\\"UnevaluatedFlags\\\"] = True\\n else:\\n results[\\\"UnevaluatedFlags\\\"] = False\\n\\n return results\",\n \"def materialize_run_flags(self, gpu_id: str = \\\"0\\\"):\\n return utils.substitute_flag_vars(flags=self.run_flags, GPU_ID=gpu_id)\",\n \"def give_deactivated_snp(self):\\r\\n genome_features = set()\\r\\n for key,value in self.features_id.items():\\r\\n if value.type == \\\"SNP\\\" and not value.attributes.active:\\r\\n ref_seq = value.attributes.allele[0]\\r\\n if all(len(ref_seq) == len(x) for x in value.attributes.allele):\\r\\n genome_features.add(value.attributes.id + '_' + ref_seq)\\r\\n else:\\r\\n genome_features.add(value.attributes.id + '_' + ref_seq + '_indel')\\r\\n return genome_features\",\n \"def get_parsed_flags():\\n return Flags.parsed_args\",\n \"def fixed_map(self, option):\\r\\n return [elm for elm in self.style.map(\\\"Treeview\\\", query_opt=option) if elm[:2] != (\\\"!disabled\\\", \\\"!selected\\\")]\",\n \"def prune(bushy: dict) -> dict:\\n pruned = dict()\\n for key in bushy:\\n if bushy[key]:\\n pruned[key] = bushy[key]\\n return pruned\",\n \"def not_processed(self) -> Set[str]:\\n return set(self._source.find(rf'.*')) - self._processed\",\n \"def reduce_puzzle(values):\\n\\tstalled = False\\n\\n\\twhile not stalled:\\n\\n\\t\\tstart_values = dict(values)\\n\\n\\t\\treduced_values = eliminate(values)\\n\\t\\treduced_values = only_choice(reduced_values)\\n\\t\\t\\n\\t\\tstalled = start_values == reduced_values\\n\\n\\t\\tempties = [box for box in boxes if len(values[box]) == 0]\\n\\n\\t\\tif empties:\\n\\t\\t\\treturn False\\n\\t\\n\\treturn values\",\n \"def or_cpp_flags(self, flags):\\n flags_dict = {\\\"deprecated\\\": \\\"vtable::common_::deprecated\\\",\\n \\\"hidden\\\": \\\"vtable::common_::hidden\\\",\\n \\\"unprivileged\\\": \\\"vtable::common_::unprivileged\\\",\\n \\\"no_reply\\\": \\\"vtable::method_::no_reply\\\"}\\n\\n cpp_flags = []\\n for flag in flags:\\n try:\\n cpp_flags.append(flags_dict[flag])\\n except KeyError:\\n raise ValueError(\\\"Invalid flag \\\\\\\"{}\\\\\\\"\\\".format(flag))\\n\\n return \\\" | \\\".join(cpp_flags)\",\n \"def test_flags(self):\\n self.check_search(\\n dict(flag_contact=u'yes'),\\n [u'Tackle', u'DoubleSlap', u'Ice Punch', u'Bite', u'Fly'],\\n 'flimsy search by flag',\\n )\\n\\n self.check_search(\\n dict(flag_mirror=u'no'),\\n [u'Counter', u'Curse', u'Focus Punch', u'Sunny Day'],\\n 'better search by flag',\\n )\\n\\n self.check_search(\\n dict(flag_contact=u'no', name=u'punch'),\\n [],\\n 'searching by nega-flag',\\n exact=True,\\n )\",\n \"def checkAllFlags(self, latest_player):\\n unclaimedFlags = (\\n (index, flag) for index, flag in enumerate(self.board.flags) if not flag.is_claimed())\\n for indexed_flag in unclaimedFlags:\\n self.__check_individual_flag(indexed_flag, latest_player)\\n self.__check_winning_conditions()\",\n \"def print_all():\\n for i in flags:\\n print(i)\",\n \"def __get_ids_of_all_unrelaxed_candidates__(self):\\n\\n all_unrelaxed_ids = set([t.gaid for t in self.c.select(relaxed=0)])\\n all_relaxed_ids = set([t.gaid for t in self.c.select(relaxed=1)])\\n all_queued_ids = set([t.gaid for t in self.c.select(queued=1)])\\n\\n actually_unrelaxed = [gaid for gaid in all_unrelaxed_ids\\n if (gaid not in all_relaxed_ids and\\n gaid not in all_queued_ids)]\\n\\n return actually_unrelaxed\",\n \"def test_removeFlagsSilently(self):\\n self._flagsSilentlyTest('removeFlags', b'-FLAGS.SILENT')\",\n \"def get_unpinned_params(opts, params):\\n return params - set([p for p, v in opts.__dict__.items() if p in LIKELIHOOD_PINNABLE_PARAMS and v is not None])\",\n \"def settable(self):\\r\\n return Options([i for i in list(self.items())\\r\\n if i[0] in Options.versatileOptions()])\",\n \"def __process_flags(self, flags: int) -> Dict[str, bool]:\\n return {\\n 'ns': True if flags & 0x100 else False,\\n 'cwr': True if flags & 0x080 else False,\\n 'ece': True if flags & 0x040 else False,\\n 'urg': True if flags & 0x020 else False,\\n 'ack': True if flags & 0x010 else False,\\n 'psh': True if flags & 0x008 else False,\\n 'rst': True if flags & 0x004 else False,\\n 'syn': True if flags & 0x002 else False,\\n 'fin': True if flags & 0x001 else False,\\n }\",\n \"def GetEntireAddOrRemoveSources(self):\\n source_flags = collections.defaultdict(int)\\n for sym in self:\\n source_flags[sym.source_path] |= 1 << sym.diff_status\\n add_flag = 1 << DIFF_STATUS_ADDED\\n remove_flag = 1 << DIFF_STATUS_REMOVED\\n return (sorted(k for k, v in source_flags.items() if v == remove_flag),\\n sorted(k for k, v in source_flags.items() if v == add_flag))\",\n \"def _compactness_pruning(self):\\n feature_phrases = [phrase for phrase in self.frequent_features if self._is_compact(phrase)]\\n self.features_phrases = feature_phrases\",\n \"def exclude_non_cpp(benchmarks):\\n return [benchmark for benchmark in benchmarks if is_cpp(benchmark)]\",\n \"def flags(self) -> UserFlag:\",\n \"def free_symbols(self) -> set[Basic]:\\n empty: set[Basic] = set()\\n return empty.union(*(a.free_symbols for a in self.args))\",\n \"def get_productions(self, non_terminal):\\r\\n return set(filter(lambda x: x.non_terminal == non_terminal, self.productions))\",\n \"def test_flags(self):\\n d = self._examineOrSelect()\\n self._response(\\n b'* FLAGS (\\\\\\\\Answered \\\\\\\\Flagged \\\\\\\\Deleted \\\\\\\\Seen \\\\\\\\Draft)')\\n self.assertEqual(\\n self.successResultOf(d), {\\n 'READ-WRITE': False,\\n 'FLAGS': ('\\\\\\\\Answered', '\\\\\\\\Flagged', '\\\\\\\\Deleted', '\\\\\\\\Seen',\\n '\\\\\\\\Draft')})\",\n \"def flags(self, query):\\n flag_list = []\\n\\n # add the help flag if it is requested\\n if '--help' in query:\\n flag_list.append('help')\\n query = query.replace('--help', '').replace('-h', '')\\n\\n return query, flag_list\",\n \"def level_flags(self, lvl):\\n return [flag for flag in self.flags if flag.game_level.number == lvl]\",\n \"def remove_filler(dgm, val=np.inf):\\r\\n inds = (dgm[:,0] != val)\\r\\n return dgm[inds,:]\",\n \"def _find_relevant_categories(value):\\n if value is None:\\n if KEEP_UNKOWN_PURPOSE:\\n return True\\n else:\\n return False\\n return True if sum([x in value for x in PURPOSES_TO_KEEP]) else False\",\n \"def sat_generate_candidate_assignments(self):\\n # YOUR CODE HERE\\n short = min(len(c) for c in self.clauses)\\n for c in self.clauses:\\n if len(c) == short:\\n return set(c.literals)\\n # return (set(x.literals) for x in self.clauses if len(x) == min(len(c) for c in self.clauses))\",\n \"def versatileOptions():\\r\\n return tuple(sorted(i[0] for i in list(Options.defaults().items()) if i[1].find(' #v ') > 0))\",\n \"def update_flags(self, scansion):\\n for i, macrons in enumerate(scansion.scansion.lstrip(\\\" \\\").rstrip(\\\" \\\").split(\\\" \\\")):\\n if self.words[i].is_mqdq_only(Scansion(macrons)):\\n self.flags.append(\\\"Mqdq only scansion: \\\" + macrons)\\n elif self.words[i].is_morpheus_only(Scansion(macrons)):\\n self.flags.append(\\\"Morpheus only scansion: \\\" + macrons)\\n if self.words[i].is_new:\\n self.flags.append(\\\"A previuosly unencountered word: \\\" + macrons)\",\n \"def build_mask(mask, unused_features_positions):\\n\\tfinal_mask = mask.tolist()\\n\\n\\tfor i in range(len(unused_features_positions)):\\n\\t\\tif not unused_features_positions[i]:\\n\\t\\t\\tfinal_mask.insert(i, False)\\n\\n\\treturn final_mask\",\n \"def unprocessed(self):\\n for v in self.iter():\\n if v.intersect and not v.checked:\\n yield True\",\n \"def test_options_listed_in_build_options(self) -> None:\\n testdir = os.path.join(self.unit_test_dir, '112 list build options')\\n\\n out = self.init(testdir)\\n for line in out.splitlines():\\n if line.startswith('Message: Build options:'):\\n self.assertNotIn('-Dauto_features=auto', line)\\n self.assertNotIn('-Doptional=auto', line)\\n\\n self.wipe()\\n self.mac_ci_delay()\\n\\n out = self.init(testdir, extra_args=['-Dauto_features=disabled', '-Doptional=enabled'])\\n for line in out.splitlines():\\n if line.startswith('Message: Build options:'):\\n self.assertIn('-Dauto_features=disabled', line)\\n self.assertIn('-Doptional=enabled', line)\\n\\n self.setconf('-Doptional=disabled')\\n out = self.build()\\n for line in out.splitlines():\\n if line.startswith('Message: Build options:'):\\n self.assertIn('-Dauto_features=disabled', line)\\n self.assertNotIn('-Doptional=enabled', line)\\n self.assertIn('-Doptional=disabled', line)\",\n \"def _clean_ignored(self, tokens):\\n return list(filter(lambda t : t.token_value not in self._ignored, tokens))\",\n \"def optimization_mask(self) -> Sequence[bool]:\\n return self._optimization_mask\",\n \"def gyp_files(self):\\n return set(self._gyp_flags.keys())\",\n \"def get_local_opt_bits(self, row):\\n \\n opt_bits = []\\n for fld in self.local_fields:\\n if not fld.opt: continue\\n \\n opt_bits.append('(%s._opt[%d] & %d)' % (\\n row, fld.opt[0], 1 << fld.opt[1]))\\n \\n return ' && '.join(opt_bits)\",\n \"def find_options(self, current_row, current_column, subgrid_number)->list:\\n row = self.number_for_row\\n column = self.number_for_column\\n subgrid = self.subgrid[subgrid_number].avaliable_numbers\\n options = list(set(row[current_row]) & set(column[current_column]) & set(subgrid))\\n options = [x for x in options if x != 0]\\n return options\",\n \"def get_gcc_flags(exe=\\\"gcc\\\"):\\n gcc_ver = get_gcc_ver(exe=exe)\\n cc_flags = ['-g']\\n cc_flags += ['-D_GLIBCXX_USE_CXX11_ABI=0']\\n if (gcc_ver[0] > 0):\\n # yes, we use GCC\\n # avoid the error \\\"undefined symbol: _ZdlPvm\\\" with newer GCCs\\n if ((gcc_ver[0] == 4) and (gcc_ver[1] == 9)) or (gcc_ver[0] >= 5):\\n cc_flags += ['-std=c++11']\\n if CAD_DEBUG:\\n cc_flags += ['-O0']\\n else:\\n cc_flags += ['-O3']\\n if (find_in_path(['g++']) is not None):\\n cc_flags += ['-ffast-math'] # essential to get vectorization and performance\\n cc_flags += ['-funroll-loops']\\n cc_flags += ['-mtune=native'] # optimize for the current CPU but preserve portability\\n if platform.processor() == 'x86_64':\\n if CAD_GCC_NATIVE:\\n # flag does not work e.g. on IBM Minsky systems\\n cc_flags += ['-march=native']\\n # cc_flags += ['-march=skylake-avx512']\\n else:\\n cc_flags += ['-msse4.2'] # required for fast round() instruction\\n if not on_mac():\\n if CAD_OPENMP:\\n cc_flags += ['-fopenmp']\\n cc_flags += ['-lgomp']\\n # avoid flag during GitLab continuous integration to keep the log slim\\n if 'CI' not in os.environ:\\n cc_flags += ['-fopt-info']\\n # cc_flags += ['-ftree-vectorize']\\n # cc_flags += ['-fopt-info-vec-missed']\\n cc_flags += ['-Wno-unknown-pragmas']\\n else:\\n # non-gcc branch\\n cc_flags += ['-O2']\\n print(\\\"GCC flags: {}\\\".format(\\\" \\\".join(cc_flags)))\\n return cc_flags\",\n \"def select_proposals(proposals_list):\\r\\n \\r\\n return []\",\n \"def get_violations(self,\\n env,\\n only_state=False\\n ):\\n if only_state:\\n flags = [con.is_violated(env) for con in self.state_constraints]\\n else:\\n flags = [con.is_violated(env) for con in self.constraints]\\n return flags\",\n \"def forbidden_processes(self):\\n return {name for name, flag in self._required_processes.items() if not flag}\",\n \"def expand(formula,var,val):\\n return [clause - {(var, not val)} # group 2 modified here\\n for clause in formula \\n if (var,val) not in clause] # group 1 removed here\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62069196","0.58500195","0.5761298","0.56516194","0.54694813","0.54386127","0.5421935","0.5417712","0.54035455","0.53730446","0.53225636","0.53167844","0.5297252","0.529056","0.528956","0.5206268","0.5202388","0.5171703","0.51404","0.51187575","0.50934035","0.5082096","0.5072761","0.50598204","0.5057428","0.50534576","0.50418806","0.5031735","0.5023706","0.4994039","0.49937406","0.4989558","0.4988202","0.49861982","0.49859932","0.49813884","0.49537143","0.4953119","0.49406496","0.49396315","0.4937726","0.49363074","0.49272043","0.492116","0.4918345","0.49156466","0.4914654","0.4911043","0.49103585","0.49055693","0.48955464","0.4895398","0.489474","0.48825544","0.48823315","0.48680267","0.4861001","0.48421258","0.48352537","0.4833724","0.4831435","0.48288545","0.4817101","0.48137715","0.48121962","0.48119602","0.48032537","0.47979555","0.47925133","0.4789238","0.47860223","0.47674698","0.4767154","0.47661445","0.47651044","0.4743959","0.47376642","0.47304958","0.47296923","0.4728263","0.47249112","0.4710095","0.47097963","0.4709328","0.4707319","0.4705376","0.4704084","0.46972457","0.4694039","0.4693286","0.46828014","0.4670752","0.46701092","0.46636105","0.4661125","0.46603674","0.46447188","0.46428198","0.46298525","0.4626541"],"string":"[\n \"0.62069196\",\n \"0.58500195\",\n \"0.5761298\",\n \"0.56516194\",\n \"0.54694813\",\n \"0.54386127\",\n \"0.5421935\",\n \"0.5417712\",\n \"0.54035455\",\n \"0.53730446\",\n \"0.53225636\",\n \"0.53167844\",\n \"0.5297252\",\n \"0.529056\",\n \"0.528956\",\n \"0.5206268\",\n \"0.5202388\",\n \"0.5171703\",\n \"0.51404\",\n \"0.51187575\",\n \"0.50934035\",\n \"0.5082096\",\n \"0.5072761\",\n \"0.50598204\",\n \"0.5057428\",\n \"0.50534576\",\n \"0.50418806\",\n \"0.5031735\",\n \"0.5023706\",\n \"0.4994039\",\n \"0.49937406\",\n \"0.4989558\",\n \"0.4988202\",\n \"0.49861982\",\n \"0.49859932\",\n \"0.49813884\",\n \"0.49537143\",\n \"0.4953119\",\n \"0.49406496\",\n \"0.49396315\",\n \"0.4937726\",\n \"0.49363074\",\n \"0.49272043\",\n \"0.492116\",\n \"0.4918345\",\n \"0.49156466\",\n \"0.4914654\",\n \"0.4911043\",\n \"0.49103585\",\n \"0.49055693\",\n \"0.48955464\",\n \"0.4895398\",\n \"0.489474\",\n \"0.48825544\",\n \"0.48823315\",\n \"0.48680267\",\n \"0.4861001\",\n \"0.48421258\",\n \"0.48352537\",\n \"0.4833724\",\n \"0.4831435\",\n \"0.48288545\",\n \"0.4817101\",\n \"0.48137715\",\n \"0.48121962\",\n \"0.48119602\",\n \"0.48032537\",\n \"0.47979555\",\n \"0.47925133\",\n \"0.4789238\",\n \"0.47860223\",\n \"0.47674698\",\n \"0.4767154\",\n \"0.47661445\",\n \"0.47651044\",\n \"0.4743959\",\n \"0.47376642\",\n \"0.47304958\",\n \"0.47296923\",\n \"0.4728263\",\n \"0.47249112\",\n \"0.4710095\",\n \"0.47097963\",\n \"0.4709328\",\n \"0.4707319\",\n \"0.4705376\",\n \"0.4704084\",\n \"0.46972457\",\n \"0.4694039\",\n \"0.4693286\",\n \"0.46828014\",\n \"0.4670752\",\n \"0.46701092\",\n \"0.46636105\",\n \"0.4661125\",\n \"0.46603674\",\n \"0.46447188\",\n \"0.46428198\",\n \"0.46298525\",\n \"0.4626541\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62399405"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":15192,"cells":{"query":{"kind":"string","value":"Like above but now candidates are tuples of real flag and user visible name"},"document":{"kind":"string","value":"def bool_attr_list_1(gdbval, candidates):\n\n r = []\n for i in candidates:\n if long (gdbval[i[0]]) != 0:\n r.append(i[1])\n pass\n pass\n return r"},"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 view_candidates(self):\n items = ['id', self.filter, 'half_light', 'separation', 'P_c']\n for add_on in ['P_O', 'P_Ox']:\n if add_on in self.candidates.keys():\n items += [add_on]\n print(self.candidates[items])","def flags(self) -> UserFlag:","def candidates(word):\r\n return (known([word]) or known(edits1(word)) or known(edits2(word)) or [word])","def get_all_candidates(self) -> list:","def _candidates(self, token):","def candidates(self, word):\n return (self.known([word]) or \\\n self.known(self.edits1(word)) or \\\n self.known(self.edits2(word)) or \\\n set([word]))","def candidates(self, word):\n return (self.known([word]) or self.known(self.edits1(word)) or self.known(self.edits2(word)) or [word])","def bool_attr_list(gdbval, candidates):\n\n r = []\n for i in candidates:\n if long (gdbval[i]) != 0:\n r.append(i)\n pass\n pass\n return r","def flag_names(self) -> Tuple[str, ...]:\n # Regular flag names\n flags = sorted(self.flags.values(), key=flag_key)\n names = [self.names_for(to_flag(x.name)) for x in flags]\n # Inverse flag names sold separately\n names.append(list(self.inverse_flags.keys()))\n return tuple(itertools.chain.from_iterable(names))","def generateCandidates(self):\n\t\tprint(\"Candidate list:\\n\")\n\t\tkeys = list(self.prune_list.keys())\n\t\ttuple_count = len(keys[0])\n\t\tprune_list = {}\n\t\ttup = []\n\t\tfor v in comb(keys, 2):\n\t\t\ta = set(v[0])\n\t\t\tb = set(v[1])\n\t\t\t\n\t\t\t# If there's as many common element in a & b as one less than tuple_count\n\t\t\tif((len(a & b) == (tuple_count - 1)) and (tuple(a | b) not in tup)):\n\t\t\t\ttup.append(tuple(a | b))\n\t\t\t\tprint(tup[-1])\n\t\t\t\t# Update prune list\n\t\t\t\tcount = self.getSupport(tup[-1])\n\t\t\t\tif(count >= self.support):\n\t\t\t\t\tprune_list[tup[-1]] = count\n\t\treturn prune_list","def flags(self) -> undefined.UndefinedOr[UserFlag]:","def human_readable(self):\n if self.no_flags_set():\n return \"no flags set\"\n else:\n flag_desc = []\n for name in (\"bookmarked\", \"for_validation\", \"candidate\", \"final causative\"):\n if getattr(self, \"flag_%s\" % name.replace(\" \", \"_\")):\n flag_desc.append(name)\n for name in (\"visual\", \"validation\", \"molecular\", \"phenotype_match\", \"summary\"):\n field = getattr(self, \"flag_%s\" % name)\n if field and field != \"empty\":\n flag_desc.append(\"%s rating is %s\" % (name.split(\"_\")[0], field))\n return \", \".join(flag_desc)","def getFlagLabels(self, which=None):\n\n which = str(which)\n if which.startswith('a'): # all possible\n labels = set(self._flags or [])\n labels.update(FLAG_PLANTERS)\n labels = list(labels)\n elif which.startswith('u'): # user\n labels = [key for key in (self._flags or {})\n if not key in FLAG_PLANTERS]\n else:\n labels = list(self._flags or [])\n labels.sort()\n return labels","def flag_key(arg: Argument) -> List[Union[int, str]]:\n # Setup\n ret: List[Union[int, str]] = []\n x = sort_candidate(arg)\n # Long-style flags win over short-style ones, so the first item of\n # comparison is simply whether the flag is a single character long (with\n # non-length-1 flags coming \"first\" [lower number])\n ret.append(1 if len(x) == 1 else 0)\n # Next item of comparison is simply the strings themselves,\n # case-insensitive. They will compare alphabetically if compared at this\n # stage.\n ret.append(x.lower())\n # Finally, if the case-insensitive test also matched, compare\n # case-sensitive, but inverse (with lowercase letters coming first)\n inversed = \"\"\n for char in x:\n inversed += char.lower() if char.isupper() else char.upper()\n ret.append(inversed)\n return ret","def test_flags(self):\n self.check_search(\n dict(flag_contact=u'yes'),\n [u'Tackle', u'DoubleSlap', u'Ice Punch', u'Bite', u'Fly'],\n 'flimsy search by flag',\n )\n\n self.check_search(\n dict(flag_mirror=u'no'),\n [u'Counter', u'Curse', u'Focus Punch', u'Sunny Day'],\n 'better search by flag',\n )\n\n self.check_search(\n dict(flag_contact=u'no', name=u'punch'),\n [],\n 'searching by nega-flag',\n exact=True,\n )","def test_candidates_list(self):\n pass","def lookups(self, request, model_admin):\n return (\n ('1', 'oui'),\n ('0', 'non')\n )","def lookup(self,user_preferences):\n res = list()\n \n fit_area = set()\n fit_price = set()\n fit_food = set()\n \n if user_preferences[0] == \"any\" or user_preferences[0] == 0:\n fit_area = set(range(len(self.area)))\n else:\n for i,a in enumerate(self.area):\n if a == user_preferences[0]:\n fit_area.add(i)\n if user_preferences[1] == \"any\" or user_preferences[1] == 0:\n fit_price = set(range(len(self.price_range)))\n else:\n for j,p in enumerate(self.price_range):\n if p == user_preferences[1]:\n fit_price.add(j)\n if user_preferences[2] == \"any\" or user_preferences[2] == 0:\n fit_food = set(range(len(self.food_types)))\n else:\n for k,f in enumerate(self.food_types):\n if f == user_preferences[2]:\n fit_food.add(k)\n option_numbers = fit_area.intersection(fit_price, fit_food)\n if option_numbers:\n for i in option_numbers:\n res.append(self.restaurant_names[i])\n \n return res","def flags(self):\r\n return flags.SuggestionFlags(self)","def complete_opt_allow_select_scan(self, text, *_):\n return [t for t in (\"true\", \"false\", \"yes\", \"no\") if t.startswith(text.lower())]","def lazy_match(name, key_value_tuples):\r\n result = []\r\n for (k, v) in key_value_tuples:\r\n if k.lower().find(name.lower()) == 0:\r\n result.append((k, v))\r\n if len(result) == 0:\r\n print \"%s does not match any options:\" % name\r\n for k, _v in key_value_tuples:\r\n print \"\\t%s\" % k\r\n sys.exit(2)\r\n if len(result) > 1:\r\n print \"%s matched multiple options:\" % name\r\n for k, _v in result:\r\n print \"\\t%s\" % k\r\n sys.exit(2)\r\n return result","def getVisibilities(self):\n if self.__layout in [\"Toolboxes\", \"Sidebars\"]:\n return (\n # edit profile\n [\n self.ui.epltCheckBox.isChecked(),\n self.ui.ephtCheckBox.isChecked(),\n self.ui.eprtCheckBox.isChecked(),\n ],\n # debug profile\n [\n self.ui.dpltCheckBox.isChecked(),\n self.ui.dphtCheckBox.isChecked(),\n self.ui.dprtCheckBox.isChecked(),\n ]\n )\n \n return (\n [True, True, True], # edit profile\n [True, True, True], # debug profile\n )","def sift_candidates(\n candidates: List[Union[PrecoveryCandidate, FrameCandidate]]\n) -> Tuple[List[PrecoveryCandidate], List[FrameCandidate]]:\n precovery_candidates = []\n frame_candidates = []\n for candidate in candidates:\n if isinstance(candidate, PrecoveryCandidate):\n precovery_candidates.append(candidate)\n elif isinstance(candidate, FrameCandidate):\n frame_candidates.append(candidate)\n else:\n raise TypeError(f\"Unexpected candidate type: {type(candidate)}\")\n\n precovery_candidates = sorted(\n precovery_candidates, key=lambda c: (c.mjd, c.observation_id)\n )\n frame_candidates = sorted(frame_candidates, key=lambda c: c.exposure_mjd_mid)\n\n return precovery_candidates, frame_candidates","def candidates(self):\n return self.related_users.all()","def get_two_way_flags(cls, user1, user2):\n two_way_choices = [y[0] for y in USERFLAG_TYPES if y[2]]\n return UserFlag.all_between_users(user1, user2)\\\n .filter(flag_type__in=two_way_choices)","def seesSuggestions(self):\n return self.floor.owner == self.user and self.floor.permissiveness == \"permissive\"","def findFieldByHint(self, candidates, hints):\n if not isinstance(hints, (list, tuple)):\n hints = (hints,)\n for hint in hints:\n for candidate in candidates:\n if hint in candidate.lower():\n return candidate\n # None of the hints were found in either of the options.\n return None","def get_one_way_flags(cls, user1, user2):\n one_way_choices = [y[0] for y in USERFLAG_TYPES if not y[2]]\n return UserFlag.all_between_users(user1, user2)\\\n .filter(flag_type__in=one_way_choices)","def visible_for(ba):\n if ba is None:\n return \"N/A\"\n if isinstance(ba, type) and issubclass(ba, actors.Actor):\n ba = ba.default_action\n visible = []\n hidden = []\n for p in UserTypes.objects():\n name = p.name or p.value\n if ba.get_view_permission(p):\n visible.append(name)\n else:\n hidden.append(name)\n if len(hidden) == 0:\n return \"all\"\n if len(visible) == 0:\n return \"nobody\"\n # if len(hidden) < len(visible):\n # if len(hidden) <= 3:\n # return \"all except %s\" % ', '.join(hidden)\n return ' '.join(visible)","def findSuggestions():\n users = None\n if current_user.genderPreferences == \"any\":\n users = User.query.filter(or_(User.genderPreferences==current_user.gender, User.genderPreferences=='any'), User.state==current_user.state, User.city==current_user.city, User.id!=current_user.id).all()\n elif current_user.genderPreferences == \"male\":\n users = User.query.filter(or_(User.gender==\"male\", User.gender==\"other\"), or_(User.genderPreferences==current_user.gender, User.genderPreferences==\"any\"), User.state==current_user.state, User.city==current_user.city, User.id!=current_user.id).all()\n elif current_user.genderPreferences == \"female\":\n users = User.query.filter(or_(User.gender==\"female\", User.gender==\"other\"), or_(User.genderPreferences==current_user.gender, User.genderPreferences==\"any\"), User.state==current_user.state, User.city==current_user.city, User.id!=current_user.id).all()\n show_users = []\n print(users)\n for user in users:\n if (not user in current_user.likes) and (not user in current_user.dislikes):\n show_users.append(user)\n print(show_users)\n return show_users","def lookups(self, request, model_admin):\n return (\n ('examine', 'May Need Coordinates'),\n ('done', 'Has Coordinates'),\n ('ignore', 'Ignore'),\n )","def exact_match_candidates(self) -> List[List[TokenType]]:\n return [\n [TokenType.GENE, TokenType.AMPLIFICATION]\n ]","def get_source_candidates(all_data_epigen):\n candids = {s:\n [np.where(np.array(c[1])!=0)[0] for c in mdata[\"test\"] ]\n for s, mdata in all_data_epigen.items()}\n return candids","def candidates(self) -> dict[str, Candidate]:\n candidates = self.requested_candidates.copy()\n if isinstance(self.no_editable, Collection):\n keys = self.no_editable\n elif self.no_editable:\n keys = candidates.keys()\n else:\n keys = []\n if self.should_install_editables():\n # Install `editables` as well as required by self project\n editables = editables_candidate(self.environment)\n if editables is not None:\n candidates[\"editables\"] = editables\n for key in keys:\n if key in candidates and candidates[key].req.editable:\n candidate = candidates[key]\n # Create a new candidate with editable=False\n req = dataclasses.replace(candidate.req, editable=False)\n candidates[key] = make_candidate(req, candidate.name, candidate.version, candidate.link)\n return candidates","def get_candidates(self):\n return u', '.join([c.identifier for c in self.candidates.all()])","def get_challenge_suggestions(self, cr, uid, context=None):\n plan_info = []\n goal_plan_obj = self.pool.get('gamification.goal.plan')\n plan_ids = goal_plan_obj.search(cr, uid, [('proposed_user_ids', 'in', uid), ('state', '=', 'inprogress')], context=context)\n for plan in goal_plan_obj.browse(cr, uid, plan_ids, context=context):\n values = {\n 'id': plan.id,\n 'name': plan.name,\n 'description': plan.description,\n }\n plan_info.append(values)\n return plan_info","def as_choices():\n return (\n # Live is currently disabled as a choice\n # pending implementation\n (\"live\", \"Use working directory\"),\n (\"latest\", \"Use latest snapshot\"),\n (\"pinned\", \"Pinned to snapshot\"),\n )","def lookups(self, request, model_admin):\n return (\n (None, _('Current member')), #default, see https://stackoverflow.com/a/16556771\n ('past_member', _('Past member')),\n ('current_collaborator', _('Current collaborator')),\n ('past_collaborator', _('Past collaborator')),\n ('other', _('Other')),\n ('all', _('All'))\n )","def lookups(self, request, model_admin):\n return (\n ('yes', 'yes'),\n ('no', 'no'),\n )","def _known(self, what, index):\n if what == 'user':\n known = 0 <= index < self.n_users\n else: # what == 'item'\n known = 0 <= index < self.n_items\n return known","def _generateAvailability(self, obj, **args):\n result = []\n if not args.get('mode', None):\n args['mode'] = self._mode\n args['stringType'] = 'insensitive'\n if not obj.getState().contains(pyatspi.STATE_SENSITIVE):\n result.append(self._script.formatting.getString(**args))\n return result","def search(search, candidates):\n choicer = choices.Choice()\n for candidate in candidates:\n choicer.add(candidate)\n return choicer.search(search)","def get_matching_answers(self, answer):\r\n return [key for key in self.hints if self.compare_answer(key, answer)]","def _search_allowed_partners(self, operator, user_id):\n cr = self.env.cr\n # list of partners corresponding to users\n # which are assigned to the same tickets than the provided user\n cr.execute(\n 'SELECT distinct u.partner_id FROM res_users u, '\n 'anytracker_ticket_assignment_rel m, '\n 'anytracker_ticket_assignment_rel n '\n 'WHERE m.user_id=%s AND u.id=n.user_id '\n 'AND n.ticket_id=m.ticket_id;',\n (user_id,))\n return [('id', operator, tuple(a[0] for a in cr.fetchall()))]","def is_candidate(self, user):\n return self.candidates.filter(pk=user.pk).exists()","def choices(self, cl):\n # TODO: Determine if non-static choices would be cleaner here.\n # Honestly, I tried a more generic version and it was even harder to\n # follow than this version.\n yield {\n 'selected': not (self.lookup_val_gte or self.lookup_val_lt),\n 'query_string': cl.get_query_string({}, [self.lookup_kwarg_gte,\n self.lookup_kwarg_lt]),\n 'display': 'All'\n }\n\n goal = settings.FACEBOOK_CLICK_GOAL\n yield {\n 'selected': self.lookup_val_gte and not self.lookup_val_lt,\n 'query_string': cl.get_query_string({self.lookup_kwarg_gte: goal},\n [self.lookup_kwarg_lt]),\n 'display': 'Yes'\n }\n yield {\n 'selected': self.lookup_val_lt and not self.lookup_val_gte,\n 'query_string': cl.get_query_string({self.lookup_kwarg_lt: goal},\n [self.lookup_kwarg_gte]),\n 'display': 'No'\n }","def help_tuples(self) -> List[Tuple[str, Optional[str]]]:\n # TODO: argument/flag API must change :(\n # having to call to_flag on 1st name of an Argument is just dumb.\n # To pass in an Argument object to help_for may require moderate\n # changes?\n return list(\n map(\n lambda x: self.help_for(to_flag(x.name)),\n sorted(self.flags.values(), key=flag_key),\n )\n )","def known_organisms():\n return [\"rat\"]","def _instance_complete(self, text, line, begidx, endidx, notstates):\n choices = []\n for x in self._instancelist():\n if x[1] not in notstates:\n choices.append(x[0])\n\n matches = []\n for x in choices:\n if x.startswith(text):\n matches.append(x)\n return matches","def lookups(self, request, model_admin):\n return (\n ('active', 'OK to contact'),\n ('ignore', 'DO NOT contact'),\n )","def filter_to_candidate(self):\n filtered = { k: [] for k in self.annsets }\n for key, annset in self.annsets.items():\n for a in annset:\n if a.overlaps(self.candidate):\n filtered[key].append(a)\n self.annsets = filtered","def q_is_candidate(cls, user_obj):\n return Q(candidates__student=user_obj)","def candidates(self, items, artist, album, va_likely):\n candidate_list = []\n candidate_list.append(WikiAlbum(artist, album))\n\n return candidate_list","def flags(self, query):\n flag_list = []\n\n # add the help flag if it is requested\n if '--help' in query:\n flag_list.append('help')\n query = query.replace('--help', '').replace('-h', '')\n\n return query, flag_list","def get_possible_preferences():\n df = pd.read_csv(\"../data/restaurant_info.csv\")\n foods = set(list(df[\"food\"]))\n areas = set(list(df[\"area\"].dropna()))\n price_ranges = set(list(df[\"pricerange\"]))\n\n return foods, areas, price_ranges","def lookups(self, request, model_admin):\n return (\n ('none', 'No Credentials'),\n ('some', 'Some Credentials'),\n ('some_valid', 'Some Valid Credentials'),\n ('some_invalid', 'Some Invalid Credentials'),\n )","def filter_task_assigned_users(group):\n return voc_selected_org_suffix_users(group, ['editeur', 'validateur'])","def suggest_completions(cls, text):\n USER_SUGGEST = 'user-suggest'\n es = UserMappingType.search().get_es()\n\n results = es.suggest(index=cls.get_index(), body={\n USER_SUGGEST: {\n 'text': text.lower(),\n 'completion': {\n 'field': 'suggest'\n }\n }\n })\n\n if results[USER_SUGGEST][0]['length'] > 0:\n return results[USER_SUGGEST][0]['options']\n\n return []","def _find_sections(self, hint):\n userid = hint[self.identity_param]\n answer = set()\n for section in self.info.keys():\n if userid in self.info[section]:\n answer.add(section)\n return answer","def get_allowed_positions(user):\n try:\n up = user.get_profile()\n except AttributeError:\n return []\n\n r = []\n for (pk,perm) in db.UserProfile.PERMISSIONS.iteritems():\n if user.has_perm(perm):\n r.append( (pk, dict(db.UserProfile.POSITIONS)[pk]) )\n return r","def get_flag(cls, flag_name, user1, user2):\n try:\n # Find the flag name in the USERFLAG_TYPES list.\n flag_type, two_way_flag = [(y[0], y[2]) for y in\n USERFLAG_TYPES if y[1] == flag_name][0]\n except IndexError:\n raise AttributeError('No flag by this name.')\n # Fetch exactly one object, anything else would be an exception.\n return UserFlag.objects.get(Q(sender=user1, receiver=user2) |\n Q(sender=user2, receiver=user1),\n flag_type=flag_type)","async def parse_input_args_filters(ctx, commands, args) -> (discord.Member, bool, str, list, list, list):\n user = None\n has_all = False\n group_by_key = 'set_code'\n affiliation_names = []\n rarity_codes = []\n card_codes = []\n\n # Parse all the arguments\n for arg in args:\n # Check if the argument is a user\n try:\n converter = commands.MemberConverter()\n user = await converter.convert(ctx=ctx, argument=arg)\n # Check if the argument is an affiliation\n except commands.errors.MemberNotFound:\n argLowerCase = arg.lower()\n if argLowerCase == 'all':\n has_all = True\n elif argLowerCase in ['a', 'affiliation', 'affiliations']:\n group_by_key = 'affiliation_name'\n elif argLowerCase in ['f', 'faction', 'factions']:\n group_by_key = 'faction_name'\n elif argLowerCase in ['rar', 'rarity']:\n group_by_key = 'rarity_code'\n elif argLowerCase in ['nogroup', 'nogroups']:\n group_by_key = ''\n elif argLowerCase in ['v', 'villain', 'villains']:\n affiliation_names.append('Villain')\n elif argLowerCase in ['h', 'hero', 'heroes']:\n affiliation_names.append('Hero')\n elif argLowerCase in ['n', 'neutral', 'neutrals']:\n affiliation_names.append('Neutral')\n elif argLowerCase in ['s', 'starter', 'starters']:\n rarity_codes.append('S')\n elif argLowerCase in ['c', 'common']:\n rarity_codes.append('C')\n elif argLowerCase in ['u', 'uncommon']:\n rarity_codes.append('U')\n elif argLowerCase in ['r', 'rare']:\n rarity_codes.append('R')\n elif argLowerCase in ['l', 'legendary']:\n rarity_codes.append('L')\n elif is_valid_card_number_format(arg):\n card_codes.append(arg)\n else:\n raise ValueError('Invalid argument: {}'.format(arg))\n\n if card_codes and (has_all or affiliation_names or rarity_codes):\n raise ValueError('Invalid arguments. You can\\'t mix card numbers and batch.')\n elif has_all and (affiliation_names or rarity_codes):\n raise ValueError('Invalid arguments. Use either \\\"all\\\" or affiliation/rarity name but not both.')\n\n return user, has_all, group_by_key, affiliation_names, rarity_codes, card_codes","def test_getlist(self):\n flags = flag_lists(appversions={\"code\": \"fx1.0\"})\n eq_(flags, {(\"fx\", \"pl\"): [0],\n (\"fx\", \"de\"): [1],\n (\"fx\", \"fr\"): [2],\n (\"fx\", \"da\"): [1, 0]})","def where_is_candidate(cls, user_obj):\n return AssignmentGroup.objects.filter(cls.q_is_candidate(user_obj))","def where_is_candidate(cls, user_obj):\n return AssignmentGroup.objects.filter(cls.q_is_candidate(user_obj))","def _get_completion(self, original_text, remaining_text, options):\n if self.should_hide_completions(original_text=original_text,\n remaining_text=remaining_text,\n allowed_suffixes=(\" \", \".\")):\n return []\n\n return [(option, len(remaining_text)) for option in options\n if option.startswith(remaining_text) and not option.startswith(\"_\")]","def choices(cls):\n # return list(map(tuple, cls.__members__.items()))\n return [(int(code), name) for name, code in cls.__members__.items()]","def get_known_users_optout(env, cnx=None):\n\n if not cnx:\n cnx = env.get_db_cnx()\n cursor = cnx.cursor()\n cursor.execute(\"SELECT DISTINCT s.sid, n.value, e.value, o.value \"\n \"FROM session AS s \"\n \" LEFT JOIN session_attribute AS n ON (n.sid=s.sid \"\n \" and n.authenticated=1 AND n.name = 'name') \"\n \" LEFT JOIN session_attribute AS e ON (e.sid=s.sid \"\n \" AND e.authenticated=1 AND e.name = 'email') \"\n \" LEFT JOIN session_attribute AS o ON (o.sid=s.sid \"\n \" AND o.authenticated=1 AND o.name = 'ticket-notification-optout') \"\n \"WHERE s.authenticated=1 ORDER BY s.sid\")\n for username, name, email, optout in cursor:\n yield username, name, email, optout","def validate(candidates: List[str], choices: List[str]) -> List[str]:\n for candidate in candidates:\n assert candidate in choices, f\"Specified {candidate}, but not in available list: {choices}.\"\n return candidates","def _get_candidates():\n cache_str = \"candidate_map_contentful_update\"\n status = cache.get(cache_str)\n if not status:\n status_app = content_utils.Feature(_CONTENTFUL_FEATURE_ID)\n status = status_app.context[\"candidates\"]\n cache.set(cache_str, status, 120)\n return status","def __getFlaglist( self , keyinfo ):\n\t\tflaglist = []\n\t\tif( getBit( keyinfo , 0 ) == 1 ):\n\t\t\tflaglist.append( 'HMAC_MD5_RC4' )\n\t\tif( getBit( keyinfo , 1 ) == 1 ):\n\t\t\tflaglist.append( 'HMAC_SHA1_AES' )\n\t\tif( getBit( keyinfo , 3 ) == 0 ):\n\t\t\tflaglist.append( 'group' )\n\t\tif( getBit( keyinfo , 3 ) == 1 ):\n\t\t\tflaglist.append( 'pairwise' )\n\t\tif( getBit( keyinfo , 4 ) == 0 and getBit( keyinfo , 5 ) == 0 ):\n\t\t\tflaglist.append( 'idx0' )\n\t\tif( getBit( keyinfo , 4 ) == 1 ):\n\t\t\tflaglist.append( 'idx1' )\n\t\tif( getBit( keyinfo , 5 ) == 1 ):\n\t\t\tflaglist.append( 'idx2' )\n\t\tif( getBit( keyinfo , 6 ) == 1 ):\n\t\t\tflaglist.append( 'install' )\n\t\tif( getBit( keyinfo , 7 ) == 1 ):\n\t\t\tflaglist.append( 'ack' )\n\t\tif( getBit( keyinfo , 8 ) == 1 ):\n\t\t\tflaglist.append( 'mic' )\n\t\tif( getBit( keyinfo , 9 ) == 1 ):\n\t\t\tflaglist.append( 'secure' )\n\t\tif( getBit( keyinfo , 10 ) == 1 ):\n\t\t\tflaglist.append( 'error' )\n\t\tif( getBit( keyinfo , 11 ) == 1 ):\n\t\t\tflaglist.append( 'request' )\n\t\tif( getBit( keyinfo , 12 ) == 1 ):\n\t\t\tflaglist.append( 'encrypted' )\n\t\treturn flaglist","def display_scan_options(bit_mask):\n options = []\n if bit_mask == ScanOption.DEFAULTIO:\n options.append(ScanOption.DEFAULTIO.name)\n for option in ScanOption:\n if option & bit_mask:\n options.append(option.name)\n return ', '.join(options)","def sat_generate_candidate_assignments(self):\n # YOUR CODE HERE\n short = min(len(c) for c in self.clauses)\n for c in self.clauses:\n if len(c) == short:\n return set(c.literals)\n # return (set(x.literals) for x in self.clauses if len(x) == min(len(c) for c in self.clauses))","def get_candidate_list(self):\n return self.candidate_list","def _candidates(self, token):\n token_as_list = [token]\n token_1_edits = NorvigCorrector._one_edit_token_distances(token)\n token_2_edits = NorvigCorrector._two_edits_token_distances(token)\n return (\n self._known_in(token_as_list) or self._known_in(token_1_edits) or self._known_in(token_2_edits) or\n token_as_list)","def searchFlag(self, text):\n for row in range(self.flagList.count()):\n flag = self.flagList.item(row)\n if text:\n flag.setHidden(not text in flag.text())\n else:\n flag.setHidden(False)","def GetActuatorsWithStatus(status_flags, status_helper, status_to_check):\n\n flag = 0\n for status in status_to_check:\n flag |= status_helper.Value(status)\n return [key for key, value in status_flags.iteritems() if value & flag]","def get_known(self):\n pool = set()\n\n # Add neighbours:\n pool.update(self.neighbours)\n\n # Add fingers:\n for f in SUCC_FINGERS:\n pool.update(self.best_finger_succ[f])\n for f in PRED_FINGERS:\n pool.update(self.best_finger_pred[f])\n return list(pool)","def get_list_of_bool2(self):\n pass","def _generate_base_candidates(self, target_text):\n\n result_list = []\n tagged_text = tag(target_text)\n\n for i in range(1, 5):\n temp = []\n grams = find_ngrams(tagged_text, i)\n\n for gram in grams:\n phrase = \" \".join(list(map(lambda x: x[0], gram)))\n pos = \" \".join(list(map(lambda x: x[1], gram)))\n\n if pos in self.candidate_pattern:\n temp.append(phrase)\n\n result_list.append(temp)\n\n return result_list","def speaking_pairs(self, selector: Optional[Callable[[User, User], bool]]=None,\n user_names_only: bool=False) -> Set[Tuple]:\n pairs = set()\n for u2 in self.utterances.values():\n if u2.user is not None and u2.reply_to is not None and u2.reply_to in self.utterances:\n u1 = self.utterances[u2.reply_to]\n if u1.user is not None:\n if selector is None or selector(u2.user, u1.user):\n pairs.add((u2.user.name, u1.user.name) if\n user_names_only else (u2.user, u1.user))\n return pairs","def getChoices(self, grid):\n return [(x, y) for x in range(3) for y in range(3) if grid[x][y] == 0]","def search_users_by_options_queryset(user, include_flagged=False):\n # 1\n li = User.objects.all().prefetch_related('profile')\n if settings.DEBUG:\n print('search_users_by_options_queryset --> all: ', li.count())\n\n # 2 search option: sex\n if user.profile.f_sex > 0:\n li = li.filter(profile__sex=user.profile.f_sex)\n if settings.DEBUG:\n print('search_users_by_options_queryset --> f_sex: ', li.count())\n\n # 3 search option: age\n dob_earliest, dob_latest = get_dob_range(user.profile.f_minage,\n user.profile.f_maxage)\n li = li.filter(profile__dob__gt=dob_earliest, profile__dob__lt=dob_latest)\n if settings.DEBUG:\n print('search_users_by_options_queryset --> dob: ', li.count())\n\n # 4 search option: distance\n #\n # Values too close are inaccurate because of location fuzzying. Also,\n # f_distance must be at least 1, so that the signup flow doesn't intercept\n # it because it has no value set! Leave this to only search distances\n # above 5 km or so, and return \"worldwide\" for any value below 5 km.\n #\n if user.profile.f_distance > 5:\n lat_min, lng_min, lat_max, lng_max = get_latlng_bounderies(\n user.profile.lat, user.profile.lng,\n user.profile.f_distance)\n li = li.filter(profile__lat__gte=lat_min, profile__lat__lte=lat_max,\n profile__lng__gte=lng_min, profile__lng__lte=lng_max)\n if settings.DEBUG:\n print('search_users_by_options_queryset --> distance: ', li.count())\n\n # x only show SFW profiles?\n if user.profile.f_over_18: # unused\n pass\n # li = li.filter(profile__over_18=True)\n\n # x only users with a verified email on reddit?\n if user.profile.f_has_verified_email: # unused\n pass\n # li = li.filter(profile__has_verified_email=True)\n\n # 5 exclude auth user themself.\n li = li.exclude(pk=user.pk)\n if settings.DEBUG:\n print('search_users_by_options_queryset --> user.pk: ', li.count())\n\n # 5a. exclude banned users\n li = li.exclude(is_active=False)\n if settings.DEBUG:\n print('search_users_by_options_queryset --> is_active: ', li.count())\n\n # 5b. exclude users who deleted their account (deleted last_login)\n li = li.exclude(last_login=None)\n if settings.DEBUG:\n print('search_users_by_options_queryset --> last_login: ', li.count())\n\n # 5c. exclude users with low karma\n li = li.exclude(\n profile__link_karma__lte=settings.USER_MIN_LINK_KARMA,\n profile__comment_karma__lte=settings.USER_MIN_COMMENT_KARMA)\n if settings.DEBUG:\n print('search_users_by_options_queryset --> karma: ', li.count())\n\n # 6 are not already flagged by auth user ('like', 'nope', 'block')\n if not include_flagged:\n li = li.exclude(flags_received__sender=user)\n if settings.DEBUG:\n print('search_users_by_options_queryset --> flagged: ', li.count())\n\n # 7 are not blocked by admin via username blocklist,\n li = li.exclude(username__in=get_blocked_usernames_list())\n if settings.DEBUG:\n print('search_users_by_options_queryset --> blocklist: ', li.count())\n\n # 8 have at least one picture URL,\n if getattr(settings, 'REQUIRE_PROFILE_PIC', False):\n li = li.exclude(profile___pics='')\n if settings.DEBUG:\n print('search_users_by_options_queryset --> pics: ', li.count())\n\n if settings.DEBUG:\n print('--> li.query', li.query)\n\n return li","def fingers(self):\n\n return Finger.name_choices","def _list_usage_flags():\n yield from sorted(self._defs.items())\n if self._parent is None:\n if self._CONFIG_FLAG.name not in self._defs:\n yield (self._CONFIG_FLAG.name, self._CONFIG_FLAG)","def _collect_candidate_matches(reference_name_or_path):\n normalized_reference_name_or_path = \\\n normalize_reference_name(reference_name_or_path)\n\n # if reference_name_or_path is an actual genome name, like GRCh37 then\n # reference_filename_lower will just be the lowercase of the genome name\n # (\"grch37) but if it was a full path to a reference file, such as\n # '/path/to/GRCh37.fasta' then reference_filename_lower will be\n # 'grch37.fasta'\n normalized_reference_filename = os.path.basename(normalized_reference_name_or_path)\n\n file_name_matches = []\n full_path_matches = []\n for assembly_name in canonical_reference_names:\n candidate_list = [assembly_name] + alias_dict_with_ucsc.get(assembly_name, [])\n for candidate in candidate_list:\n normalized_candidate = normalize_reference_name(candidate)\n name_to_add = (\n candidate\n if is_ucsc_reference_name(candidate)\n else assembly_name)\n if normalized_candidate in normalized_reference_filename:\n file_name_matches.append(name_to_add)\n\n elif normalized_candidate in normalized_reference_name_or_path:\n full_path_matches.append(name_to_add)\n\n # remove duplicate matches (happens due to overlapping aliases)\n file_name_matches = list(set(file_name_matches))\n full_path_matches = list(set(full_path_matches))\n return file_name_matches, full_path_matches","def get_substitute_for(userid):","def complete_opt_display(self, text, *_):\n return [t + \" \" for t in DISPLAYS if t.startswith(text)]","def userSuggestions(database):\n firstname=str(input(\"who do you want to have follow suggestions for :\"))\n usr,find=getByName(database,firstname)\n if not find:\n print(\"the User could not be found\")\n return\n else:\n following=[]\n followers=[]\n for folower in usr.folowed:\n followers.append(folower)\n for folowed in usr.folow:\n following.append(folowed)\n results=[]\n print(\"On what do you want your suggestions to be based on?\\n1. Mutual Interests\\n2. Mutual Connections\\n3. Both\")\n choice=int(input(\"Your choice :\"))\n for key ,usrs in database.items():\n if key not in following: \n correspondant=0\n if choice == 1 or choice == 3:\n for interest in usr.interest:\n if interest in usrs.interest:\n correspondant+=1\n if choice == 2 or choice == 3:\n for folower in followers:\n for folows in usrs.folowed:\n if key == folows:\n correspondant+=1\n results.append([key,correspondant])\n for i in range(len(results)):\n for j in range(0, len(results)-i-1):\n if results[j][1] > results[j+1][1] :\n results[j], results[j+1] = results[j+1], results[j]\n for k in range(5):\n print(results[k][0])","def profesionalRecommendation(user_preferences: dict, matcher: NodeMatcher):\r\n profesional = user_preferences[\"vida_profesional\"]\r\n equal_styles = list(matcher.match(\"User\", prof = profesional))\r\n return equal_styles","def check_faceted_search_users(integrated_ff):\n key, ff_env = integrated_ff['ff_key'], integrated_ff['ff_env']\n all_facets = ff_utils.get_item_facets('user', key=key, ff_env=ff_env)\n any_affiliation = {'item_type': 'user',\n 'key': key,\n 'ff_env': ff_env,\n 'item_facets': all_facets}\n resp = ff_utils.faceted_search(**any_affiliation)\n total = len(resp)\n print(\"total=\", total) # Probably a number somewhere near 30\n assert 10 < total < 50\n affiliation = {'item_type': 'user',\n 'Affiliation': '4DN Testing Lab',\n 'key': key,\n 'ff_env': ff_env,\n 'item_facets': all_facets}\n resp = ff_utils.faceted_search(**affiliation)\n affiliated = len(resp)\n print(\"affiliated=\", affiliated) # Probably a number near 5\n assert affiliated < 10\n neg_affiliation = {'item_type': 'user',\n 'Affiliation': '-4DN Testing Lab',\n 'key': key,\n 'ff_env': ff_env,\n 'item_facets': all_facets}\n resp = ff_utils.faceted_search(**neg_affiliation)\n unaffiliated = len(resp) # Probably a number near 25, but in any case the length of the complement set\n assert unaffiliated == total - affiliated\n neg_affiliation = {'item_type': 'user',\n 'Affiliation': '-4DN Testing Lab',\n 'key': key,\n 'ff_env': ff_env,\n 'item_facets': all_facets,\n 'Limit': '10'} # test limit\n resp = ff_utils.faceted_search(**neg_affiliation)\n assert len(resp) == 10","def names(filter=None):","def flagged(self) -> Sequence[str]:\r\n return self._flagged","def test_candidates_retrieve(self):\n pass","def get_flags(cls):\n return cls.get_short_flag(), cls.get_flag()","def get_flags(self):\n return self.short_flag, self.long_flag","def find_info(self, *args):\n return _ida_hexrays.lvar_uservec_t_find_info(self, *args)","def find_options(self, current_row, current_column, subgrid_number)->list:\n row = self.number_for_row\n column = self.number_for_column\n subgrid = self.subgrid[subgrid_number].avaliable_numbers\n options = list(set(row[current_row]) & set(column[current_column]) & set(subgrid))\n options = [x for x in options if x != 0]\n return options","def get_candidates(\n self,\n word: Dict[str, torch.LongTensor]\n ) -> Tuple[torch.Tensor, torch.Tensor, Optional[torch.Tensor]]:\n\n # shape: [batch_size, 1]\n original_target_ids = word['target'].squeeze()\n\n # shape: [batch_size, num_variants]\n candidate_ids = self.mapping_ids[original_target_ids]\n\n # shape: [batch_size, num_variants]\n mask = self.mapping_mask[original_target_ids]\n\n # shape: [batch_size, num_variants]\n mask = mask & (candidate_ids != original_target_ids.unsqueeze(-1)).long()\n\n # shape: [batch_size, num_variants, emb_size]\n candidate_vectors = self.target_w2v(candidate_ids)\n\n return (\n candidate_ids,\n candidate_vectors,\n mask\n )","def createFlagList(self):\n flag_list = QListWidget()\n for key in self.flags.keys():\n flag_item = QListWidgetItem()\n flag_item.setText(key)\n flag_item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)\n flag_item.setCheckState(Qt.Unchecked)\n flag_list.addItem(flag_item)\n\n flag_list.itemClicked.connect(self.flagEnable)\n return flag_list"],"string":"[\n \"def view_candidates(self):\\n items = ['id', self.filter, 'half_light', 'separation', 'P_c']\\n for add_on in ['P_O', 'P_Ox']:\\n if add_on in self.candidates.keys():\\n items += [add_on]\\n print(self.candidates[items])\",\n \"def flags(self) -> UserFlag:\",\n \"def candidates(word):\\r\\n return (known([word]) or known(edits1(word)) or known(edits2(word)) or [word])\",\n \"def get_all_candidates(self) -> list:\",\n \"def _candidates(self, token):\",\n \"def candidates(self, word):\\n return (self.known([word]) or \\\\\\n self.known(self.edits1(word)) or \\\\\\n self.known(self.edits2(word)) or \\\\\\n set([word]))\",\n \"def candidates(self, word):\\n return (self.known([word]) or self.known(self.edits1(word)) or self.known(self.edits2(word)) or [word])\",\n \"def bool_attr_list(gdbval, candidates):\\n\\n r = []\\n for i in candidates:\\n if long (gdbval[i]) != 0:\\n r.append(i)\\n pass\\n pass\\n return r\",\n \"def flag_names(self) -> Tuple[str, ...]:\\n # Regular flag names\\n flags = sorted(self.flags.values(), key=flag_key)\\n names = [self.names_for(to_flag(x.name)) for x in flags]\\n # Inverse flag names sold separately\\n names.append(list(self.inverse_flags.keys()))\\n return tuple(itertools.chain.from_iterable(names))\",\n \"def generateCandidates(self):\\n\\t\\tprint(\\\"Candidate list:\\\\n\\\")\\n\\t\\tkeys = list(self.prune_list.keys())\\n\\t\\ttuple_count = len(keys[0])\\n\\t\\tprune_list = {}\\n\\t\\ttup = []\\n\\t\\tfor v in comb(keys, 2):\\n\\t\\t\\ta = set(v[0])\\n\\t\\t\\tb = set(v[1])\\n\\t\\t\\t\\n\\t\\t\\t# If there's as many common element in a & b as one less than tuple_count\\n\\t\\t\\tif((len(a & b) == (tuple_count - 1)) and (tuple(a | b) not in tup)):\\n\\t\\t\\t\\ttup.append(tuple(a | b))\\n\\t\\t\\t\\tprint(tup[-1])\\n\\t\\t\\t\\t# Update prune list\\n\\t\\t\\t\\tcount = self.getSupport(tup[-1])\\n\\t\\t\\t\\tif(count >= self.support):\\n\\t\\t\\t\\t\\tprune_list[tup[-1]] = count\\n\\t\\treturn prune_list\",\n \"def flags(self) -> undefined.UndefinedOr[UserFlag]:\",\n \"def human_readable(self):\\n if self.no_flags_set():\\n return \\\"no flags set\\\"\\n else:\\n flag_desc = []\\n for name in (\\\"bookmarked\\\", \\\"for_validation\\\", \\\"candidate\\\", \\\"final causative\\\"):\\n if getattr(self, \\\"flag_%s\\\" % name.replace(\\\" \\\", \\\"_\\\")):\\n flag_desc.append(name)\\n for name in (\\\"visual\\\", \\\"validation\\\", \\\"molecular\\\", \\\"phenotype_match\\\", \\\"summary\\\"):\\n field = getattr(self, \\\"flag_%s\\\" % name)\\n if field and field != \\\"empty\\\":\\n flag_desc.append(\\\"%s rating is %s\\\" % (name.split(\\\"_\\\")[0], field))\\n return \\\", \\\".join(flag_desc)\",\n \"def getFlagLabels(self, which=None):\\n\\n which = str(which)\\n if which.startswith('a'): # all possible\\n labels = set(self._flags or [])\\n labels.update(FLAG_PLANTERS)\\n labels = list(labels)\\n elif which.startswith('u'): # user\\n labels = [key for key in (self._flags or {})\\n if not key in FLAG_PLANTERS]\\n else:\\n labels = list(self._flags or [])\\n labels.sort()\\n return labels\",\n \"def flag_key(arg: Argument) -> List[Union[int, str]]:\\n # Setup\\n ret: List[Union[int, str]] = []\\n x = sort_candidate(arg)\\n # Long-style flags win over short-style ones, so the first item of\\n # comparison is simply whether the flag is a single character long (with\\n # non-length-1 flags coming \\\"first\\\" [lower number])\\n ret.append(1 if len(x) == 1 else 0)\\n # Next item of comparison is simply the strings themselves,\\n # case-insensitive. They will compare alphabetically if compared at this\\n # stage.\\n ret.append(x.lower())\\n # Finally, if the case-insensitive test also matched, compare\\n # case-sensitive, but inverse (with lowercase letters coming first)\\n inversed = \\\"\\\"\\n for char in x:\\n inversed += char.lower() if char.isupper() else char.upper()\\n ret.append(inversed)\\n return ret\",\n \"def test_flags(self):\\n self.check_search(\\n dict(flag_contact=u'yes'),\\n [u'Tackle', u'DoubleSlap', u'Ice Punch', u'Bite', u'Fly'],\\n 'flimsy search by flag',\\n )\\n\\n self.check_search(\\n dict(flag_mirror=u'no'),\\n [u'Counter', u'Curse', u'Focus Punch', u'Sunny Day'],\\n 'better search by flag',\\n )\\n\\n self.check_search(\\n dict(flag_contact=u'no', name=u'punch'),\\n [],\\n 'searching by nega-flag',\\n exact=True,\\n )\",\n \"def test_candidates_list(self):\\n pass\",\n \"def lookups(self, request, model_admin):\\n return (\\n ('1', 'oui'),\\n ('0', 'non')\\n )\",\n \"def lookup(self,user_preferences):\\n res = list()\\n \\n fit_area = set()\\n fit_price = set()\\n fit_food = set()\\n \\n if user_preferences[0] == \\\"any\\\" or user_preferences[0] == 0:\\n fit_area = set(range(len(self.area)))\\n else:\\n for i,a in enumerate(self.area):\\n if a == user_preferences[0]:\\n fit_area.add(i)\\n if user_preferences[1] == \\\"any\\\" or user_preferences[1] == 0:\\n fit_price = set(range(len(self.price_range)))\\n else:\\n for j,p in enumerate(self.price_range):\\n if p == user_preferences[1]:\\n fit_price.add(j)\\n if user_preferences[2] == \\\"any\\\" or user_preferences[2] == 0:\\n fit_food = set(range(len(self.food_types)))\\n else:\\n for k,f in enumerate(self.food_types):\\n if f == user_preferences[2]:\\n fit_food.add(k)\\n option_numbers = fit_area.intersection(fit_price, fit_food)\\n if option_numbers:\\n for i in option_numbers:\\n res.append(self.restaurant_names[i])\\n \\n return res\",\n \"def flags(self):\\r\\n return flags.SuggestionFlags(self)\",\n \"def complete_opt_allow_select_scan(self, text, *_):\\n return [t for t in (\\\"true\\\", \\\"false\\\", \\\"yes\\\", \\\"no\\\") if t.startswith(text.lower())]\",\n \"def lazy_match(name, key_value_tuples):\\r\\n result = []\\r\\n for (k, v) in key_value_tuples:\\r\\n if k.lower().find(name.lower()) == 0:\\r\\n result.append((k, v))\\r\\n if len(result) == 0:\\r\\n print \\\"%s does not match any options:\\\" % name\\r\\n for k, _v in key_value_tuples:\\r\\n print \\\"\\\\t%s\\\" % k\\r\\n sys.exit(2)\\r\\n if len(result) > 1:\\r\\n print \\\"%s matched multiple options:\\\" % name\\r\\n for k, _v in result:\\r\\n print \\\"\\\\t%s\\\" % k\\r\\n sys.exit(2)\\r\\n return result\",\n \"def getVisibilities(self):\\n if self.__layout in [\\\"Toolboxes\\\", \\\"Sidebars\\\"]:\\n return (\\n # edit profile\\n [\\n self.ui.epltCheckBox.isChecked(),\\n self.ui.ephtCheckBox.isChecked(),\\n self.ui.eprtCheckBox.isChecked(),\\n ],\\n # debug profile\\n [\\n self.ui.dpltCheckBox.isChecked(),\\n self.ui.dphtCheckBox.isChecked(),\\n self.ui.dprtCheckBox.isChecked(),\\n ]\\n )\\n \\n return (\\n [True, True, True], # edit profile\\n [True, True, True], # debug profile\\n )\",\n \"def sift_candidates(\\n candidates: List[Union[PrecoveryCandidate, FrameCandidate]]\\n) -> Tuple[List[PrecoveryCandidate], List[FrameCandidate]]:\\n precovery_candidates = []\\n frame_candidates = []\\n for candidate in candidates:\\n if isinstance(candidate, PrecoveryCandidate):\\n precovery_candidates.append(candidate)\\n elif isinstance(candidate, FrameCandidate):\\n frame_candidates.append(candidate)\\n else:\\n raise TypeError(f\\\"Unexpected candidate type: {type(candidate)}\\\")\\n\\n precovery_candidates = sorted(\\n precovery_candidates, key=lambda c: (c.mjd, c.observation_id)\\n )\\n frame_candidates = sorted(frame_candidates, key=lambda c: c.exposure_mjd_mid)\\n\\n return precovery_candidates, frame_candidates\",\n \"def candidates(self):\\n return self.related_users.all()\",\n \"def get_two_way_flags(cls, user1, user2):\\n two_way_choices = [y[0] for y in USERFLAG_TYPES if y[2]]\\n return UserFlag.all_between_users(user1, user2)\\\\\\n .filter(flag_type__in=two_way_choices)\",\n \"def seesSuggestions(self):\\n return self.floor.owner == self.user and self.floor.permissiveness == \\\"permissive\\\"\",\n \"def findFieldByHint(self, candidates, hints):\\n if not isinstance(hints, (list, tuple)):\\n hints = (hints,)\\n for hint in hints:\\n for candidate in candidates:\\n if hint in candidate.lower():\\n return candidate\\n # None of the hints were found in either of the options.\\n return None\",\n \"def get_one_way_flags(cls, user1, user2):\\n one_way_choices = [y[0] for y in USERFLAG_TYPES if not y[2]]\\n return UserFlag.all_between_users(user1, user2)\\\\\\n .filter(flag_type__in=one_way_choices)\",\n \"def visible_for(ba):\\n if ba is None:\\n return \\\"N/A\\\"\\n if isinstance(ba, type) and issubclass(ba, actors.Actor):\\n ba = ba.default_action\\n visible = []\\n hidden = []\\n for p in UserTypes.objects():\\n name = p.name or p.value\\n if ba.get_view_permission(p):\\n visible.append(name)\\n else:\\n hidden.append(name)\\n if len(hidden) == 0:\\n return \\\"all\\\"\\n if len(visible) == 0:\\n return \\\"nobody\\\"\\n # if len(hidden) < len(visible):\\n # if len(hidden) <= 3:\\n # return \\\"all except %s\\\" % ', '.join(hidden)\\n return ' '.join(visible)\",\n \"def findSuggestions():\\n users = None\\n if current_user.genderPreferences == \\\"any\\\":\\n users = User.query.filter(or_(User.genderPreferences==current_user.gender, User.genderPreferences=='any'), User.state==current_user.state, User.city==current_user.city, User.id!=current_user.id).all()\\n elif current_user.genderPreferences == \\\"male\\\":\\n users = User.query.filter(or_(User.gender==\\\"male\\\", User.gender==\\\"other\\\"), or_(User.genderPreferences==current_user.gender, User.genderPreferences==\\\"any\\\"), User.state==current_user.state, User.city==current_user.city, User.id!=current_user.id).all()\\n elif current_user.genderPreferences == \\\"female\\\":\\n users = User.query.filter(or_(User.gender==\\\"female\\\", User.gender==\\\"other\\\"), or_(User.genderPreferences==current_user.gender, User.genderPreferences==\\\"any\\\"), User.state==current_user.state, User.city==current_user.city, User.id!=current_user.id).all()\\n show_users = []\\n print(users)\\n for user in users:\\n if (not user in current_user.likes) and (not user in current_user.dislikes):\\n show_users.append(user)\\n print(show_users)\\n return show_users\",\n \"def lookups(self, request, model_admin):\\n return (\\n ('examine', 'May Need Coordinates'),\\n ('done', 'Has Coordinates'),\\n ('ignore', 'Ignore'),\\n )\",\n \"def exact_match_candidates(self) -> List[List[TokenType]]:\\n return [\\n [TokenType.GENE, TokenType.AMPLIFICATION]\\n ]\",\n \"def get_source_candidates(all_data_epigen):\\n candids = {s:\\n [np.where(np.array(c[1])!=0)[0] for c in mdata[\\\"test\\\"] ]\\n for s, mdata in all_data_epigen.items()}\\n return candids\",\n \"def candidates(self) -> dict[str, Candidate]:\\n candidates = self.requested_candidates.copy()\\n if isinstance(self.no_editable, Collection):\\n keys = self.no_editable\\n elif self.no_editable:\\n keys = candidates.keys()\\n else:\\n keys = []\\n if self.should_install_editables():\\n # Install `editables` as well as required by self project\\n editables = editables_candidate(self.environment)\\n if editables is not None:\\n candidates[\\\"editables\\\"] = editables\\n for key in keys:\\n if key in candidates and candidates[key].req.editable:\\n candidate = candidates[key]\\n # Create a new candidate with editable=False\\n req = dataclasses.replace(candidate.req, editable=False)\\n candidates[key] = make_candidate(req, candidate.name, candidate.version, candidate.link)\\n return candidates\",\n \"def get_candidates(self):\\n return u', '.join([c.identifier for c in self.candidates.all()])\",\n \"def get_challenge_suggestions(self, cr, uid, context=None):\\n plan_info = []\\n goal_plan_obj = self.pool.get('gamification.goal.plan')\\n plan_ids = goal_plan_obj.search(cr, uid, [('proposed_user_ids', 'in', uid), ('state', '=', 'inprogress')], context=context)\\n for plan in goal_plan_obj.browse(cr, uid, plan_ids, context=context):\\n values = {\\n 'id': plan.id,\\n 'name': plan.name,\\n 'description': plan.description,\\n }\\n plan_info.append(values)\\n return plan_info\",\n \"def as_choices():\\n return (\\n # Live is currently disabled as a choice\\n # pending implementation\\n (\\\"live\\\", \\\"Use working directory\\\"),\\n (\\\"latest\\\", \\\"Use latest snapshot\\\"),\\n (\\\"pinned\\\", \\\"Pinned to snapshot\\\"),\\n )\",\n \"def lookups(self, request, model_admin):\\n return (\\n (None, _('Current member')), #default, see https://stackoverflow.com/a/16556771\\n ('past_member', _('Past member')),\\n ('current_collaborator', _('Current collaborator')),\\n ('past_collaborator', _('Past collaborator')),\\n ('other', _('Other')),\\n ('all', _('All'))\\n )\",\n \"def lookups(self, request, model_admin):\\n return (\\n ('yes', 'yes'),\\n ('no', 'no'),\\n )\",\n \"def _known(self, what, index):\\n if what == 'user':\\n known = 0 <= index < self.n_users\\n else: # what == 'item'\\n known = 0 <= index < self.n_items\\n return known\",\n \"def _generateAvailability(self, obj, **args):\\n result = []\\n if not args.get('mode', None):\\n args['mode'] = self._mode\\n args['stringType'] = 'insensitive'\\n if not obj.getState().contains(pyatspi.STATE_SENSITIVE):\\n result.append(self._script.formatting.getString(**args))\\n return result\",\n \"def search(search, candidates):\\n choicer = choices.Choice()\\n for candidate in candidates:\\n choicer.add(candidate)\\n return choicer.search(search)\",\n \"def get_matching_answers(self, answer):\\r\\n return [key for key in self.hints if self.compare_answer(key, answer)]\",\n \"def _search_allowed_partners(self, operator, user_id):\\n cr = self.env.cr\\n # list of partners corresponding to users\\n # which are assigned to the same tickets than the provided user\\n cr.execute(\\n 'SELECT distinct u.partner_id FROM res_users u, '\\n 'anytracker_ticket_assignment_rel m, '\\n 'anytracker_ticket_assignment_rel n '\\n 'WHERE m.user_id=%s AND u.id=n.user_id '\\n 'AND n.ticket_id=m.ticket_id;',\\n (user_id,))\\n return [('id', operator, tuple(a[0] for a in cr.fetchall()))]\",\n \"def is_candidate(self, user):\\n return self.candidates.filter(pk=user.pk).exists()\",\n \"def choices(self, cl):\\n # TODO: Determine if non-static choices would be cleaner here.\\n # Honestly, I tried a more generic version and it was even harder to\\n # follow than this version.\\n yield {\\n 'selected': not (self.lookup_val_gte or self.lookup_val_lt),\\n 'query_string': cl.get_query_string({}, [self.lookup_kwarg_gte,\\n self.lookup_kwarg_lt]),\\n 'display': 'All'\\n }\\n\\n goal = settings.FACEBOOK_CLICK_GOAL\\n yield {\\n 'selected': self.lookup_val_gte and not self.lookup_val_lt,\\n 'query_string': cl.get_query_string({self.lookup_kwarg_gte: goal},\\n [self.lookup_kwarg_lt]),\\n 'display': 'Yes'\\n }\\n yield {\\n 'selected': self.lookup_val_lt and not self.lookup_val_gte,\\n 'query_string': cl.get_query_string({self.lookup_kwarg_lt: goal},\\n [self.lookup_kwarg_gte]),\\n 'display': 'No'\\n }\",\n \"def help_tuples(self) -> List[Tuple[str, Optional[str]]]:\\n # TODO: argument/flag API must change :(\\n # having to call to_flag on 1st name of an Argument is just dumb.\\n # To pass in an Argument object to help_for may require moderate\\n # changes?\\n return list(\\n map(\\n lambda x: self.help_for(to_flag(x.name)),\\n sorted(self.flags.values(), key=flag_key),\\n )\\n )\",\n \"def known_organisms():\\n return [\\\"rat\\\"]\",\n \"def _instance_complete(self, text, line, begidx, endidx, notstates):\\n choices = []\\n for x in self._instancelist():\\n if x[1] not in notstates:\\n choices.append(x[0])\\n\\n matches = []\\n for x in choices:\\n if x.startswith(text):\\n matches.append(x)\\n return matches\",\n \"def lookups(self, request, model_admin):\\n return (\\n ('active', 'OK to contact'),\\n ('ignore', 'DO NOT contact'),\\n )\",\n \"def filter_to_candidate(self):\\n filtered = { k: [] for k in self.annsets }\\n for key, annset in self.annsets.items():\\n for a in annset:\\n if a.overlaps(self.candidate):\\n filtered[key].append(a)\\n self.annsets = filtered\",\n \"def q_is_candidate(cls, user_obj):\\n return Q(candidates__student=user_obj)\",\n \"def candidates(self, items, artist, album, va_likely):\\n candidate_list = []\\n candidate_list.append(WikiAlbum(artist, album))\\n\\n return candidate_list\",\n \"def flags(self, query):\\n flag_list = []\\n\\n # add the help flag if it is requested\\n if '--help' in query:\\n flag_list.append('help')\\n query = query.replace('--help', '').replace('-h', '')\\n\\n return query, flag_list\",\n \"def get_possible_preferences():\\n df = pd.read_csv(\\\"../data/restaurant_info.csv\\\")\\n foods = set(list(df[\\\"food\\\"]))\\n areas = set(list(df[\\\"area\\\"].dropna()))\\n price_ranges = set(list(df[\\\"pricerange\\\"]))\\n\\n return foods, areas, price_ranges\",\n \"def lookups(self, request, model_admin):\\n return (\\n ('none', 'No Credentials'),\\n ('some', 'Some Credentials'),\\n ('some_valid', 'Some Valid Credentials'),\\n ('some_invalid', 'Some Invalid Credentials'),\\n )\",\n \"def filter_task_assigned_users(group):\\n return voc_selected_org_suffix_users(group, ['editeur', 'validateur'])\",\n \"def suggest_completions(cls, text):\\n USER_SUGGEST = 'user-suggest'\\n es = UserMappingType.search().get_es()\\n\\n results = es.suggest(index=cls.get_index(), body={\\n USER_SUGGEST: {\\n 'text': text.lower(),\\n 'completion': {\\n 'field': 'suggest'\\n }\\n }\\n })\\n\\n if results[USER_SUGGEST][0]['length'] > 0:\\n return results[USER_SUGGEST][0]['options']\\n\\n return []\",\n \"def _find_sections(self, hint):\\n userid = hint[self.identity_param]\\n answer = set()\\n for section in self.info.keys():\\n if userid in self.info[section]:\\n answer.add(section)\\n return answer\",\n \"def get_allowed_positions(user):\\n try:\\n up = user.get_profile()\\n except AttributeError:\\n return []\\n\\n r = []\\n for (pk,perm) in db.UserProfile.PERMISSIONS.iteritems():\\n if user.has_perm(perm):\\n r.append( (pk, dict(db.UserProfile.POSITIONS)[pk]) )\\n return r\",\n \"def get_flag(cls, flag_name, user1, user2):\\n try:\\n # Find the flag name in the USERFLAG_TYPES list.\\n flag_type, two_way_flag = [(y[0], y[2]) for y in\\n USERFLAG_TYPES if y[1] == flag_name][0]\\n except IndexError:\\n raise AttributeError('No flag by this name.')\\n # Fetch exactly one object, anything else would be an exception.\\n return UserFlag.objects.get(Q(sender=user1, receiver=user2) |\\n Q(sender=user2, receiver=user1),\\n flag_type=flag_type)\",\n \"async def parse_input_args_filters(ctx, commands, args) -> (discord.Member, bool, str, list, list, list):\\n user = None\\n has_all = False\\n group_by_key = 'set_code'\\n affiliation_names = []\\n rarity_codes = []\\n card_codes = []\\n\\n # Parse all the arguments\\n for arg in args:\\n # Check if the argument is a user\\n try:\\n converter = commands.MemberConverter()\\n user = await converter.convert(ctx=ctx, argument=arg)\\n # Check if the argument is an affiliation\\n except commands.errors.MemberNotFound:\\n argLowerCase = arg.lower()\\n if argLowerCase == 'all':\\n has_all = True\\n elif argLowerCase in ['a', 'affiliation', 'affiliations']:\\n group_by_key = 'affiliation_name'\\n elif argLowerCase in ['f', 'faction', 'factions']:\\n group_by_key = 'faction_name'\\n elif argLowerCase in ['rar', 'rarity']:\\n group_by_key = 'rarity_code'\\n elif argLowerCase in ['nogroup', 'nogroups']:\\n group_by_key = ''\\n elif argLowerCase in ['v', 'villain', 'villains']:\\n affiliation_names.append('Villain')\\n elif argLowerCase in ['h', 'hero', 'heroes']:\\n affiliation_names.append('Hero')\\n elif argLowerCase in ['n', 'neutral', 'neutrals']:\\n affiliation_names.append('Neutral')\\n elif argLowerCase in ['s', 'starter', 'starters']:\\n rarity_codes.append('S')\\n elif argLowerCase in ['c', 'common']:\\n rarity_codes.append('C')\\n elif argLowerCase in ['u', 'uncommon']:\\n rarity_codes.append('U')\\n elif argLowerCase in ['r', 'rare']:\\n rarity_codes.append('R')\\n elif argLowerCase in ['l', 'legendary']:\\n rarity_codes.append('L')\\n elif is_valid_card_number_format(arg):\\n card_codes.append(arg)\\n else:\\n raise ValueError('Invalid argument: {}'.format(arg))\\n\\n if card_codes and (has_all or affiliation_names or rarity_codes):\\n raise ValueError('Invalid arguments. You can\\\\'t mix card numbers and batch.')\\n elif has_all and (affiliation_names or rarity_codes):\\n raise ValueError('Invalid arguments. Use either \\\\\\\"all\\\\\\\" or affiliation/rarity name but not both.')\\n\\n return user, has_all, group_by_key, affiliation_names, rarity_codes, card_codes\",\n \"def test_getlist(self):\\n flags = flag_lists(appversions={\\\"code\\\": \\\"fx1.0\\\"})\\n eq_(flags, {(\\\"fx\\\", \\\"pl\\\"): [0],\\n (\\\"fx\\\", \\\"de\\\"): [1],\\n (\\\"fx\\\", \\\"fr\\\"): [2],\\n (\\\"fx\\\", \\\"da\\\"): [1, 0]})\",\n \"def where_is_candidate(cls, user_obj):\\n return AssignmentGroup.objects.filter(cls.q_is_candidate(user_obj))\",\n \"def where_is_candidate(cls, user_obj):\\n return AssignmentGroup.objects.filter(cls.q_is_candidate(user_obj))\",\n \"def _get_completion(self, original_text, remaining_text, options):\\n if self.should_hide_completions(original_text=original_text,\\n remaining_text=remaining_text,\\n allowed_suffixes=(\\\" \\\", \\\".\\\")):\\n return []\\n\\n return [(option, len(remaining_text)) for option in options\\n if option.startswith(remaining_text) and not option.startswith(\\\"_\\\")]\",\n \"def choices(cls):\\n # return list(map(tuple, cls.__members__.items()))\\n return [(int(code), name) for name, code in cls.__members__.items()]\",\n \"def get_known_users_optout(env, cnx=None):\\n\\n if not cnx:\\n cnx = env.get_db_cnx()\\n cursor = cnx.cursor()\\n cursor.execute(\\\"SELECT DISTINCT s.sid, n.value, e.value, o.value \\\"\\n \\\"FROM session AS s \\\"\\n \\\" LEFT JOIN session_attribute AS n ON (n.sid=s.sid \\\"\\n \\\" and n.authenticated=1 AND n.name = 'name') \\\"\\n \\\" LEFT JOIN session_attribute AS e ON (e.sid=s.sid \\\"\\n \\\" AND e.authenticated=1 AND e.name = 'email') \\\"\\n \\\" LEFT JOIN session_attribute AS o ON (o.sid=s.sid \\\"\\n \\\" AND o.authenticated=1 AND o.name = 'ticket-notification-optout') \\\"\\n \\\"WHERE s.authenticated=1 ORDER BY s.sid\\\")\\n for username, name, email, optout in cursor:\\n yield username, name, email, optout\",\n \"def validate(candidates: List[str], choices: List[str]) -> List[str]:\\n for candidate in candidates:\\n assert candidate in choices, f\\\"Specified {candidate}, but not in available list: {choices}.\\\"\\n return candidates\",\n \"def _get_candidates():\\n cache_str = \\\"candidate_map_contentful_update\\\"\\n status = cache.get(cache_str)\\n if not status:\\n status_app = content_utils.Feature(_CONTENTFUL_FEATURE_ID)\\n status = status_app.context[\\\"candidates\\\"]\\n cache.set(cache_str, status, 120)\\n return status\",\n \"def __getFlaglist( self , keyinfo ):\\n\\t\\tflaglist = []\\n\\t\\tif( getBit( keyinfo , 0 ) == 1 ):\\n\\t\\t\\tflaglist.append( 'HMAC_MD5_RC4' )\\n\\t\\tif( getBit( keyinfo , 1 ) == 1 ):\\n\\t\\t\\tflaglist.append( 'HMAC_SHA1_AES' )\\n\\t\\tif( getBit( keyinfo , 3 ) == 0 ):\\n\\t\\t\\tflaglist.append( 'group' )\\n\\t\\tif( getBit( keyinfo , 3 ) == 1 ):\\n\\t\\t\\tflaglist.append( 'pairwise' )\\n\\t\\tif( getBit( keyinfo , 4 ) == 0 and getBit( keyinfo , 5 ) == 0 ):\\n\\t\\t\\tflaglist.append( 'idx0' )\\n\\t\\tif( getBit( keyinfo , 4 ) == 1 ):\\n\\t\\t\\tflaglist.append( 'idx1' )\\n\\t\\tif( getBit( keyinfo , 5 ) == 1 ):\\n\\t\\t\\tflaglist.append( 'idx2' )\\n\\t\\tif( getBit( keyinfo , 6 ) == 1 ):\\n\\t\\t\\tflaglist.append( 'install' )\\n\\t\\tif( getBit( keyinfo , 7 ) == 1 ):\\n\\t\\t\\tflaglist.append( 'ack' )\\n\\t\\tif( getBit( keyinfo , 8 ) == 1 ):\\n\\t\\t\\tflaglist.append( 'mic' )\\n\\t\\tif( getBit( keyinfo , 9 ) == 1 ):\\n\\t\\t\\tflaglist.append( 'secure' )\\n\\t\\tif( getBit( keyinfo , 10 ) == 1 ):\\n\\t\\t\\tflaglist.append( 'error' )\\n\\t\\tif( getBit( keyinfo , 11 ) == 1 ):\\n\\t\\t\\tflaglist.append( 'request' )\\n\\t\\tif( getBit( keyinfo , 12 ) == 1 ):\\n\\t\\t\\tflaglist.append( 'encrypted' )\\n\\t\\treturn flaglist\",\n \"def display_scan_options(bit_mask):\\n options = []\\n if bit_mask == ScanOption.DEFAULTIO:\\n options.append(ScanOption.DEFAULTIO.name)\\n for option in ScanOption:\\n if option & bit_mask:\\n options.append(option.name)\\n return ', '.join(options)\",\n \"def sat_generate_candidate_assignments(self):\\n # YOUR CODE HERE\\n short = min(len(c) for c in self.clauses)\\n for c in self.clauses:\\n if len(c) == short:\\n return set(c.literals)\\n # return (set(x.literals) for x in self.clauses if len(x) == min(len(c) for c in self.clauses))\",\n \"def get_candidate_list(self):\\n return self.candidate_list\",\n \"def _candidates(self, token):\\n token_as_list = [token]\\n token_1_edits = NorvigCorrector._one_edit_token_distances(token)\\n token_2_edits = NorvigCorrector._two_edits_token_distances(token)\\n return (\\n self._known_in(token_as_list) or self._known_in(token_1_edits) or self._known_in(token_2_edits) or\\n token_as_list)\",\n \"def searchFlag(self, text):\\n for row in range(self.flagList.count()):\\n flag = self.flagList.item(row)\\n if text:\\n flag.setHidden(not text in flag.text())\\n else:\\n flag.setHidden(False)\",\n \"def GetActuatorsWithStatus(status_flags, status_helper, status_to_check):\\n\\n flag = 0\\n for status in status_to_check:\\n flag |= status_helper.Value(status)\\n return [key for key, value in status_flags.iteritems() if value & flag]\",\n \"def get_known(self):\\n pool = set()\\n\\n # Add neighbours:\\n pool.update(self.neighbours)\\n\\n # Add fingers:\\n for f in SUCC_FINGERS:\\n pool.update(self.best_finger_succ[f])\\n for f in PRED_FINGERS:\\n pool.update(self.best_finger_pred[f])\\n return list(pool)\",\n \"def get_list_of_bool2(self):\\n pass\",\n \"def _generate_base_candidates(self, target_text):\\n\\n result_list = []\\n tagged_text = tag(target_text)\\n\\n for i in range(1, 5):\\n temp = []\\n grams = find_ngrams(tagged_text, i)\\n\\n for gram in grams:\\n phrase = \\\" \\\".join(list(map(lambda x: x[0], gram)))\\n pos = \\\" \\\".join(list(map(lambda x: x[1], gram)))\\n\\n if pos in self.candidate_pattern:\\n temp.append(phrase)\\n\\n result_list.append(temp)\\n\\n return result_list\",\n \"def speaking_pairs(self, selector: Optional[Callable[[User, User], bool]]=None,\\n user_names_only: bool=False) -> Set[Tuple]:\\n pairs = set()\\n for u2 in self.utterances.values():\\n if u2.user is not None and u2.reply_to is not None and u2.reply_to in self.utterances:\\n u1 = self.utterances[u2.reply_to]\\n if u1.user is not None:\\n if selector is None or selector(u2.user, u1.user):\\n pairs.add((u2.user.name, u1.user.name) if\\n user_names_only else (u2.user, u1.user))\\n return pairs\",\n \"def getChoices(self, grid):\\n return [(x, y) for x in range(3) for y in range(3) if grid[x][y] == 0]\",\n \"def search_users_by_options_queryset(user, include_flagged=False):\\n # 1\\n li = User.objects.all().prefetch_related('profile')\\n if settings.DEBUG:\\n print('search_users_by_options_queryset --> all: ', li.count())\\n\\n # 2 search option: sex\\n if user.profile.f_sex > 0:\\n li = li.filter(profile__sex=user.profile.f_sex)\\n if settings.DEBUG:\\n print('search_users_by_options_queryset --> f_sex: ', li.count())\\n\\n # 3 search option: age\\n dob_earliest, dob_latest = get_dob_range(user.profile.f_minage,\\n user.profile.f_maxage)\\n li = li.filter(profile__dob__gt=dob_earliest, profile__dob__lt=dob_latest)\\n if settings.DEBUG:\\n print('search_users_by_options_queryset --> dob: ', li.count())\\n\\n # 4 search option: distance\\n #\\n # Values too close are inaccurate because of location fuzzying. Also,\\n # f_distance must be at least 1, so that the signup flow doesn't intercept\\n # it because it has no value set! Leave this to only search distances\\n # above 5 km or so, and return \\\"worldwide\\\" for any value below 5 km.\\n #\\n if user.profile.f_distance > 5:\\n lat_min, lng_min, lat_max, lng_max = get_latlng_bounderies(\\n user.profile.lat, user.profile.lng,\\n user.profile.f_distance)\\n li = li.filter(profile__lat__gte=lat_min, profile__lat__lte=lat_max,\\n profile__lng__gte=lng_min, profile__lng__lte=lng_max)\\n if settings.DEBUG:\\n print('search_users_by_options_queryset --> distance: ', li.count())\\n\\n # x only show SFW profiles?\\n if user.profile.f_over_18: # unused\\n pass\\n # li = li.filter(profile__over_18=True)\\n\\n # x only users with a verified email on reddit?\\n if user.profile.f_has_verified_email: # unused\\n pass\\n # li = li.filter(profile__has_verified_email=True)\\n\\n # 5 exclude auth user themself.\\n li = li.exclude(pk=user.pk)\\n if settings.DEBUG:\\n print('search_users_by_options_queryset --> user.pk: ', li.count())\\n\\n # 5a. exclude banned users\\n li = li.exclude(is_active=False)\\n if settings.DEBUG:\\n print('search_users_by_options_queryset --> is_active: ', li.count())\\n\\n # 5b. exclude users who deleted their account (deleted last_login)\\n li = li.exclude(last_login=None)\\n if settings.DEBUG:\\n print('search_users_by_options_queryset --> last_login: ', li.count())\\n\\n # 5c. exclude users with low karma\\n li = li.exclude(\\n profile__link_karma__lte=settings.USER_MIN_LINK_KARMA,\\n profile__comment_karma__lte=settings.USER_MIN_COMMENT_KARMA)\\n if settings.DEBUG:\\n print('search_users_by_options_queryset --> karma: ', li.count())\\n\\n # 6 are not already flagged by auth user ('like', 'nope', 'block')\\n if not include_flagged:\\n li = li.exclude(flags_received__sender=user)\\n if settings.DEBUG:\\n print('search_users_by_options_queryset --> flagged: ', li.count())\\n\\n # 7 are not blocked by admin via username blocklist,\\n li = li.exclude(username__in=get_blocked_usernames_list())\\n if settings.DEBUG:\\n print('search_users_by_options_queryset --> blocklist: ', li.count())\\n\\n # 8 have at least one picture URL,\\n if getattr(settings, 'REQUIRE_PROFILE_PIC', False):\\n li = li.exclude(profile___pics='')\\n if settings.DEBUG:\\n print('search_users_by_options_queryset --> pics: ', li.count())\\n\\n if settings.DEBUG:\\n print('--> li.query', li.query)\\n\\n return li\",\n \"def fingers(self):\\n\\n return Finger.name_choices\",\n \"def _list_usage_flags():\\n yield from sorted(self._defs.items())\\n if self._parent is None:\\n if self._CONFIG_FLAG.name not in self._defs:\\n yield (self._CONFIG_FLAG.name, self._CONFIG_FLAG)\",\n \"def _collect_candidate_matches(reference_name_or_path):\\n normalized_reference_name_or_path = \\\\\\n normalize_reference_name(reference_name_or_path)\\n\\n # if reference_name_or_path is an actual genome name, like GRCh37 then\\n # reference_filename_lower will just be the lowercase of the genome name\\n # (\\\"grch37) but if it was a full path to a reference file, such as\\n # '/path/to/GRCh37.fasta' then reference_filename_lower will be\\n # 'grch37.fasta'\\n normalized_reference_filename = os.path.basename(normalized_reference_name_or_path)\\n\\n file_name_matches = []\\n full_path_matches = []\\n for assembly_name in canonical_reference_names:\\n candidate_list = [assembly_name] + alias_dict_with_ucsc.get(assembly_name, [])\\n for candidate in candidate_list:\\n normalized_candidate = normalize_reference_name(candidate)\\n name_to_add = (\\n candidate\\n if is_ucsc_reference_name(candidate)\\n else assembly_name)\\n if normalized_candidate in normalized_reference_filename:\\n file_name_matches.append(name_to_add)\\n\\n elif normalized_candidate in normalized_reference_name_or_path:\\n full_path_matches.append(name_to_add)\\n\\n # remove duplicate matches (happens due to overlapping aliases)\\n file_name_matches = list(set(file_name_matches))\\n full_path_matches = list(set(full_path_matches))\\n return file_name_matches, full_path_matches\",\n \"def get_substitute_for(userid):\",\n \"def complete_opt_display(self, text, *_):\\n return [t + \\\" \\\" for t in DISPLAYS if t.startswith(text)]\",\n \"def userSuggestions(database):\\n firstname=str(input(\\\"who do you want to have follow suggestions for :\\\"))\\n usr,find=getByName(database,firstname)\\n if not find:\\n print(\\\"the User could not be found\\\")\\n return\\n else:\\n following=[]\\n followers=[]\\n for folower in usr.folowed:\\n followers.append(folower)\\n for folowed in usr.folow:\\n following.append(folowed)\\n results=[]\\n print(\\\"On what do you want your suggestions to be based on?\\\\n1. Mutual Interests\\\\n2. Mutual Connections\\\\n3. Both\\\")\\n choice=int(input(\\\"Your choice :\\\"))\\n for key ,usrs in database.items():\\n if key not in following: \\n correspondant=0\\n if choice == 1 or choice == 3:\\n for interest in usr.interest:\\n if interest in usrs.interest:\\n correspondant+=1\\n if choice == 2 or choice == 3:\\n for folower in followers:\\n for folows in usrs.folowed:\\n if key == folows:\\n correspondant+=1\\n results.append([key,correspondant])\\n for i in range(len(results)):\\n for j in range(0, len(results)-i-1):\\n if results[j][1] > results[j+1][1] :\\n results[j], results[j+1] = results[j+1], results[j]\\n for k in range(5):\\n print(results[k][0])\",\n \"def profesionalRecommendation(user_preferences: dict, matcher: NodeMatcher):\\r\\n profesional = user_preferences[\\\"vida_profesional\\\"]\\r\\n equal_styles = list(matcher.match(\\\"User\\\", prof = profesional))\\r\\n return equal_styles\",\n \"def check_faceted_search_users(integrated_ff):\\n key, ff_env = integrated_ff['ff_key'], integrated_ff['ff_env']\\n all_facets = ff_utils.get_item_facets('user', key=key, ff_env=ff_env)\\n any_affiliation = {'item_type': 'user',\\n 'key': key,\\n 'ff_env': ff_env,\\n 'item_facets': all_facets}\\n resp = ff_utils.faceted_search(**any_affiliation)\\n total = len(resp)\\n print(\\\"total=\\\", total) # Probably a number somewhere near 30\\n assert 10 < total < 50\\n affiliation = {'item_type': 'user',\\n 'Affiliation': '4DN Testing Lab',\\n 'key': key,\\n 'ff_env': ff_env,\\n 'item_facets': all_facets}\\n resp = ff_utils.faceted_search(**affiliation)\\n affiliated = len(resp)\\n print(\\\"affiliated=\\\", affiliated) # Probably a number near 5\\n assert affiliated < 10\\n neg_affiliation = {'item_type': 'user',\\n 'Affiliation': '-4DN Testing Lab',\\n 'key': key,\\n 'ff_env': ff_env,\\n 'item_facets': all_facets}\\n resp = ff_utils.faceted_search(**neg_affiliation)\\n unaffiliated = len(resp) # Probably a number near 25, but in any case the length of the complement set\\n assert unaffiliated == total - affiliated\\n neg_affiliation = {'item_type': 'user',\\n 'Affiliation': '-4DN Testing Lab',\\n 'key': key,\\n 'ff_env': ff_env,\\n 'item_facets': all_facets,\\n 'Limit': '10'} # test limit\\n resp = ff_utils.faceted_search(**neg_affiliation)\\n assert len(resp) == 10\",\n \"def names(filter=None):\",\n \"def flagged(self) -> Sequence[str]:\\r\\n return self._flagged\",\n \"def test_candidates_retrieve(self):\\n pass\",\n \"def get_flags(cls):\\n return cls.get_short_flag(), cls.get_flag()\",\n \"def get_flags(self):\\n return self.short_flag, self.long_flag\",\n \"def find_info(self, *args):\\n return _ida_hexrays.lvar_uservec_t_find_info(self, *args)\",\n \"def find_options(self, current_row, current_column, subgrid_number)->list:\\n row = self.number_for_row\\n column = self.number_for_column\\n subgrid = self.subgrid[subgrid_number].avaliable_numbers\\n options = list(set(row[current_row]) & set(column[current_column]) & set(subgrid))\\n options = [x for x in options if x != 0]\\n return options\",\n \"def get_candidates(\\n self,\\n word: Dict[str, torch.LongTensor]\\n ) -> Tuple[torch.Tensor, torch.Tensor, Optional[torch.Tensor]]:\\n\\n # shape: [batch_size, 1]\\n original_target_ids = word['target'].squeeze()\\n\\n # shape: [batch_size, num_variants]\\n candidate_ids = self.mapping_ids[original_target_ids]\\n\\n # shape: [batch_size, num_variants]\\n mask = self.mapping_mask[original_target_ids]\\n\\n # shape: [batch_size, num_variants]\\n mask = mask & (candidate_ids != original_target_ids.unsqueeze(-1)).long()\\n\\n # shape: [batch_size, num_variants, emb_size]\\n candidate_vectors = self.target_w2v(candidate_ids)\\n\\n return (\\n candidate_ids,\\n candidate_vectors,\\n mask\\n )\",\n \"def createFlagList(self):\\n flag_list = QListWidget()\\n for key in self.flags.keys():\\n flag_item = QListWidgetItem()\\n flag_item.setText(key)\\n flag_item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)\\n flag_item.setCheckState(Qt.Unchecked)\\n flag_list.addItem(flag_item)\\n\\n flag_list.itemClicked.connect(self.flagEnable)\\n return flag_list\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62182224","0.608126","0.60353684","0.5863966","0.5694711","0.5597789","0.5595839","0.55818534","0.55225366","0.55154634","0.5509682","0.5467662","0.5419843","0.5375041","0.53720033","0.5312513","0.5310887","0.5301905","0.5269061","0.5194035","0.5187451","0.5167835","0.5144015","0.51247185","0.5113422","0.5087389","0.50866425","0.5067536","0.5063896","0.5052307","0.5033623","0.5011872","0.5008403","0.50066346","0.4981495","0.49697205","0.49568528","0.4953026","0.49444678","0.49428022","0.49259898","0.49259233","0.4910593","0.4906573","0.4881362","0.48690748","0.4863758","0.48603216","0.4854346","0.48416623","0.4838632","0.48328874","0.48145038","0.48029786","0.4801145","0.4800897","0.47979102","0.47951284","0.47899067","0.47870782","0.47803962","0.4774031","0.47695825","0.47691172","0.47691172","0.47655797","0.47632882","0.47596428","0.47574416","0.4752931","0.47521734","0.47507817","0.4747302","0.47447318","0.47415534","0.47324947","0.4731811","0.47230783","0.47064084","0.46986926","0.4694622","0.46903262","0.468699","0.4685824","0.46828902","0.4682814","0.46803698","0.46683216","0.46648797","0.4663154","0.46595824","0.46588087","0.4653833","0.46397567","0.4630256","0.4621105","0.4617682","0.46173194","0.46107295","0.46098655"],"string":"[\n \"0.62182224\",\n \"0.608126\",\n \"0.60353684\",\n \"0.5863966\",\n \"0.5694711\",\n \"0.5597789\",\n \"0.5595839\",\n \"0.55818534\",\n \"0.55225366\",\n \"0.55154634\",\n \"0.5509682\",\n \"0.5467662\",\n \"0.5419843\",\n \"0.5375041\",\n \"0.53720033\",\n \"0.5312513\",\n \"0.5310887\",\n \"0.5301905\",\n \"0.5269061\",\n \"0.5194035\",\n \"0.5187451\",\n \"0.5167835\",\n \"0.5144015\",\n \"0.51247185\",\n \"0.5113422\",\n \"0.5087389\",\n \"0.50866425\",\n \"0.5067536\",\n \"0.5063896\",\n \"0.5052307\",\n \"0.5033623\",\n \"0.5011872\",\n \"0.5008403\",\n \"0.50066346\",\n \"0.4981495\",\n \"0.49697205\",\n \"0.49568528\",\n \"0.4953026\",\n \"0.49444678\",\n \"0.49428022\",\n \"0.49259898\",\n \"0.49259233\",\n \"0.4910593\",\n \"0.4906573\",\n \"0.4881362\",\n \"0.48690748\",\n \"0.4863758\",\n \"0.48603216\",\n \"0.4854346\",\n \"0.48416623\",\n \"0.4838632\",\n \"0.48328874\",\n \"0.48145038\",\n \"0.48029786\",\n \"0.4801145\",\n \"0.4800897\",\n \"0.47979102\",\n \"0.47951284\",\n \"0.47899067\",\n \"0.47870782\",\n \"0.47803962\",\n \"0.4774031\",\n \"0.47695825\",\n \"0.47691172\",\n \"0.47691172\",\n \"0.47655797\",\n \"0.47632882\",\n \"0.47596428\",\n \"0.47574416\",\n \"0.4752931\",\n \"0.47521734\",\n \"0.47507817\",\n \"0.4747302\",\n \"0.47447318\",\n \"0.47415534\",\n \"0.47324947\",\n \"0.4731811\",\n \"0.47230783\",\n \"0.47064084\",\n \"0.46986926\",\n \"0.4694622\",\n \"0.46903262\",\n \"0.468699\",\n \"0.4685824\",\n \"0.46828902\",\n \"0.4682814\",\n \"0.46803698\",\n \"0.46683216\",\n \"0.46648797\",\n \"0.4663154\",\n \"0.46595824\",\n \"0.46588087\",\n \"0.4653833\",\n \"0.46397567\",\n \"0.4630256\",\n \"0.4621105\",\n \"0.4617682\",\n \"0.46173194\",\n \"0.46107295\",\n \"0.46098655\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5899639"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":15193,"cells":{"query":{"kind":"string","value":"To be made method. Loads common attributes from symbol base"},"document":{"kind":"string","value":"def load_symtab_base_attrs(self):\n sym = self.gdbval\n vis = bool_attr_list (sym, [\"in_other_partition\",\n \"used_from_other_partition\", \"force_output\",\n \"forced_by_abi\", \"externally_visible\"])\n\n vis.extend(bool_attr_list_1(sym[\"decl\"][\"base\"],\n [(\"asm_written_flag\", \"asm_written\"),\n (\"public_flag\", \"public\")]))\n vis.extend(bool_attr_list_1(sym[\"decl\"][\"decl_common\"],\n [(\"decl_flag_1\", \"external\"),\n (\"virtual_flag\", \"virtual\"),\n (\"artificial_flag\", \"artificial\")]))\n vis.extend(bool_attr_list_1(sym[\"decl\"][\"decl_with_vis\"],\n [(\"common_flag\", \"common\"),\n (\"weak_flag\", \"weak\"),\n (\"dllimport_flag\", \"dll_import\"),\n (\"comdat_flag\", \"comdat\"),\n# (\"x_comdat_group\", \"one_only\"),\n (\"visibility_specified\",\n \"visibility_specified\")]))\n# cg = sym[\"decl\"][\"decl_with_vis\"][\"comdat_group\"]\n# if (long(cg) != 0):\n# vis.append(\"comdat_group:%s\" % tree_get_identifier_str (cg))\n# pass\n# sn = sym[\"decl\"][\"decl_with_vis\"][\"section_name\"]\n# if (long(sn) != 0):\n# vis.append(\"section_name:%s\" & sn[\"string\"][\"str\"].string())\n# pass\n visnum = long(sym[\"decl\"][\"decl_with_vis\"][\"visibility\"])\n if visnum != 0:\n visnames = gdb.parse_and_eval(\"visibility_types\")\n vistype_str = visnames[visnum].string()\n vis.append(\"visibility:%s\" % vistype_str)\n pass\n resnum = int(sym[\"resolution\"])\n if resnum != 0:\n resnames = gdb.parse_and_eval(\"ld_plugin_symbol_resolution_names\")\n res_str = resnames[resnum].string()\n vis.append(res_str)\n pass\n\n self.visibility = vis\n\n if sym[\"address_taken\"]:\n self.address_taken = True\n pass\n \n return"},"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 _base_attrs(self, service):\n keys = ['name', 'desc', 'url']\n return {name:getattr(service, name, None) for name in keys}","def __extract_common_attrs(self, raw_data: Dict) -> None:\n for attr in self.COMMON_ATTRS:\n if attr not in self.ATTRS and attr in raw_data:\n setattr(self, attr, raw_data[attr])","def load_attribute_data():\n global attr_value_counts, attr_counts, value_counts, \\\n attr_value_ratios, attrs\n\n print \"Loading extraction data...\"\n with open('./data/common_extractions.json') as f:\n place_data = json.loads(f.read())\n for place in place_data:\n for attr in place_data[place]:\n if attr not in attr_value_counts:\n attrs.add(attr)\n attr_value_counts[attr] = {}\n attr_counts[attr] = 0\n for value in place_data[place][attr]:\n c = place_data[place][attr][value]\n value_counts[value] = value_counts.get(value, 0) + c\n attr_counts[attr] += c\n attr_value_counts[attr][value] = \\\n attr_value_counts[attr].get(value, 0) + c\n \n for attr in attrs:\n attr_value_ratios[attr] = {}\n for value in attr_value_counts[attr]:\n attr_value_ratios[attr][value] = float(attr_value_counts[attr][value]) \\\n / attr_counts[attr]","def inherit_attributes(self, attr_table, base_ext_type):\n base_attrs = base_ext_type.attribute_table.attributedict\n attr_table.inherited.update(base_attrs) # { attr_name }\n attr_table.attributedict.update(base_attrs) # { attr_name : attr_type }","def _load_attributes(self, force=False):\n # All attributes to be loaded, except _namespaces, which is a special\n # case because it requires additional params in the API query:\n attrs = [self._name, self._project, self._lang, self._base_url,\n self._article_path, self._script_path]\n\n params = {\"action\": \"query\", \"meta\": \"siteinfo\", \"siprop\": \"general\"}\n\n if not self._namespaces or force:\n params[\"siprop\"] += \"|namespaces|namespacealiases\"\n with self._api_lock:\n result = self._api_query(params, no_assert=True)\n self._load_namespaces(result)\n elif all(attrs): # Everything is already specified and we're not told\n return # to force a reload, so do nothing\n else: # We're only loading attributes other than _namespaces\n with self._api_lock:\n result = self._api_query(params, no_assert=True)\n\n res = result[\"query\"][\"general\"]\n self._name = res[\"wikiid\"]\n self._project = res[\"sitename\"].lower()\n self._lang = res[\"lang\"]\n self._base_url = res[\"server\"]\n self._article_path = res[\"articlepath\"]\n self._script_path = res[\"scriptpath\"]","def load_attrs(self):\n return loads(self.get_attr().GetObject()) or {}","def load_vso_values():\n from sunpy.net import attrs as a\n\n here = os.path.dirname(os.path.realpath(__file__))\n with open(os.path.join(here, 'data', 'attrs.json')) as attrs_file:\n keyword_info = json.load(attrs_file)\n\n # Now to traverse the saved dict and give them attr keys.\n attrs = {}\n for key, value in keyword_info.items():\n attr = getattr(a, key.capitalize(), None)\n if attr is None:\n attr = getattr(a.vso, key.capitalize())\n attrs[attr] = value\n return attrs","def read_extras(self, f):\n\n gb = f[\"base state\"]\n for name in gb:\n self.base[name] = Basestate(self.cc_data.grid.ny, ng=self.cc_data.grid.ng)\n self.base[name].d[:] = gb[name]","def get_implementation_specific_attrs(cls):\n ctypes_version = cls.get_drmaa2_library().drmaa2_get_drmaa_version();\n if cls.implementation_specific_attrs is None:\n cls.implementation_specific_attrs = cls.to_py_dict(\n cls.get_drmaa2_library().uge_vi_impl_spec_get(ctypes_version))\n return cls.implementation_specific_attrs","def _load_symbol_data(self, name):\n if self._state[name] in (True, None): # Skip Symbols already loaded\n return\n\n # Unpack attributes\n attrs = self._state[name]['attrs']\n index, dim, domain, records = [attrs[k] for k in ('index', 'dim',\n 'domain', 'records')]\n\n # Read the data\n self._cache_data(name, index, dim, records)\n\n # If the GAMS method 'sameas' is invoked in a program, the resulting\n # GDX file contains an empty Set named 'SameAs' with domain (*,*). Do\n # not read this\n if name == 'SameAs' and domain == ['*', '*']:\n self._state[name] = None\n self._index[index] = None\n return\n\n domain = self._infer_domain(name, domain,\n self._state[name]['elements'])\n\n # Create an xr.DataArray with the Symbol's data\n self._add_symbol(name, dim, domain, attrs)","def __getattribute__(self, name):\n if name == \"_update_header\":\n return object.__getattribute__(self, \"_update_header\")\n\n elif name == \"_get_lib\":\n return object.__getattribute__(self, \"_get_lib\")\n\n else:\n # Load symbols from the current process (Python).\n return getattr(self._get_lib(), name)","def attributes(self):\n ...","def init_meta(self):\n self.meta = {}\n # Required (core)\n self.meta['ra'] = dict(ext=0, card='RA')\n self.meta['dec'] = dict(ext=0, card='DEC')\n self.meta['target'] = dict(ext=0, card='object')\n self.meta['idname'] = dict(ext=0, card='obsmode')\n self.meta['decker'] = dict(ext=0, card='MASKNAME')\n self.meta['binning'] = dict(card=None, compound=True) # Uses CCDSUM\n self.meta['detector']=dict(ext=0,card='detector')\n self.meta['mjd'] = dict(ext=0, card='MJD-OBS')\n self.meta['exptime'] = dict(ext=0, card='EXPTIME')\n self.meta['airmass'] = dict(ext=0, card='AIRMASS')\n self.meta['dispname'] = dict(ext=0, card='GRISM')\n self.meta['datasec'] = dict(ext=1, card='DATASEC')\n self.meta['dichroic'] = dict(ext=0, card='FILTER1')\n self.meta['instrument'] = dict(ext=0, card='INSTRUME')","def attributes(self):","def _init_attributes(self):\n if os.name == \"nt\":\n if \"64\" in platform.architecture()[0]:\n platform_arch = \"x86_64\"\n elif \"32\" in platform.architecture()[0]:\n platform_arch = \"i386\"\n else:\n platform_arch = platform.architecture()\n os_ver = f\"Windows-{platform.win32_ver()[1]}\"\n else:\n platform_arch = platform.machine()\n if platform.system() == \"Darwin\":\n os_ver = f\"macOS-{platform.mac_ver()[0]}\"\n else:\n os_ver = \"-\".join(linux_distribution()[0:2])\n\n license_chunks = LICENSE.split(\" \")\n if license_chunks[0] == \"GPLv2\":\n client_license = \"GPL-2.0\"\n else:\n client_license = \"Commercial\"\n\n default_attributes = {\n # Process id\n \"_pid\": str(os.getpid()),\n # Platform architecture\n \"_platform\": platform_arch,\n # OS version\n \"_os\": os_ver,\n # Hostname of the local machine\n \"_source_host\": socket.gethostname(),\n # Client's name\n \"_client_name\": \"mysql-connector-python\",\n # Client's version\n \"_client_version\": \".\".join([str(x) for x in VERSION[0:3]]),\n # Client's License identifier\n \"_client_license\": client_license,\n }\n self._settings[\"attributes\"].update(default_attributes)\n\n if \"connection-attributes\" in self._settings:\n for attr_name in self._settings[\"connection-attributes\"]:\n attr_value = self._settings[\"connection-attributes\"][attr_name]\n # Validate name type\n if not isinstance(attr_name, str):\n raise InterfaceError(\n f\"Attribute name '{attr_name}' must be a string type\"\n )\n # Validate attribute name limit 32 characters\n if len(attr_name) > 32:\n raise InterfaceError(\n f\"Attribute name '{attr_name}' exceeds 32 characters \"\n \"limit size\"\n )\n # Validate names in connection-attributes cannot start with \"_\"\n if attr_name.startswith(\"_\"):\n raise InterfaceError(\n \"Key names in 'session-connect-attributes' cannot \"\n f\"start with '_', found: {attr_name}\"\n )\n # Validate value type\n if not isinstance(attr_value, str):\n raise InterfaceError(\n f\"Attribute name '{attr_name}' value '{attr_value}' \"\n \" must be a string type\"\n )\n\n # Validate attribute value limit 1024 characters\n if len(attr_value) > 1024:\n raise InterfaceError(\n f\"Attribute name '{attr_name}' value: '{attr_value}' \"\n \"exceeds 1024 characters limit size\"\n )\n\n self._settings[\"attributes\"][attr_name] = attr_value","def init_attrs(self):\n raise NotImplementedError","def load(self):\r\n self.domain.get_attributes(self.name, item=self)","def init_meta(self):\n self.meta = {}\n # Required (core)\n self.meta['ra'] = dict(ext=0, card='RA')\n self.meta['dec'] = dict(ext=0, card='DEC')\n self.meta['target'] = dict(ext=0, card='object')\n self.meta['idname'] = dict(ext=0, card='obsmode')\n self.meta['decker'] = dict(ext=0, card='MASKNAME')\n self.meta['binning'] = dict(card=None, compound=True)\n self.meta['detector'] = dict(ext=0, card='detector')\n self.meta['mjd'] = dict(ext=0, card='MJD-OBS')\n self.meta['exptime'] = dict(ext=0, card='EXPTIME')\n self.meta['airmass'] = dict(ext=0, card='AIRMASS')\n self.meta['dispname'] = dict(ext=0, card='GRISM')\n self.meta['datasec'] = dict(ext=0, card='DETSIZE')\n self.meta['dichroic'] = dict(ext=0, card='FILTER1')\n self.meta['instrument'] = dict(ext=0, card='INSTRUME')\n self.meta['slitwid'] = dict(card=None, compound=True)","def _load(self) -> dict:\n raise NotImplementedError()","def test_all_attributes_in_base_metadata(self):\n\n name = 'idsvc.basemeta'\n uuid = 'ABC'\n value = { 'color': 'blue' }\n owner = 'bob'\n schemaId = None\n internalUsername = None\n associationIds = ['CDE', 'EFG']\n lastUpdated = '2016-06-15T17:09:06.137-05:00'\n name = 'idsvc.basemeta'\n created = '2016-06-15T17:09:06.137-05:00'\n _links = ''\n\n meta = {\n 'name': name,\n 'uuid': uuid,\n 'value': value,\n 'owner': owner,\n 'schemaId': schemaId,\n 'internalUsername': internalUsername,\n 'associationIds': associationIds,\n 'lastUpdated': lastUpdated,\n 'name': name,\n 'created': created,\n '_links': _links\n }\n\n base_meta = BaseMetadata(api_client=self.IDS_SYS_CLIENT, meta=meta)\n self.assertDictEqual(base_meta.meta, meta)","def init_meta(self):\n self.meta = {}\n # Required (core)\n self.meta['ra'] = dict(ext=0, card='RA')\n self.meta['dec'] = dict(ext=0, card='DEC')\n self.meta['target'] = dict(ext=0, card='OBJECT')\n self.meta['decker'] = dict(ext=0, card=None, default='default')\n self.meta['dichroic'] = dict(ext=0, card=None, default='default')\n self.meta['binning'] = dict(ext=0, card=None, default='1,1')\n\n self.meta['mjd'] = dict(ext=0, card='ACQTIME')\n self.meta['exptime'] = dict(ext=0, card='EXPTIME')\n self.meta['airmass'] = dict(ext=0, card='AIRMASS')\n # Extras for config and frametyping\n self.meta['dispname'] = dict(ext=0, card='GRISM')\n self.meta['idname'] = dict(ext=0, card='OBSTYPE')\n self.meta['instrument'] = dict(ext=0, card='INSTRUME')","def get_attributes(self) -> Dict[str, str]:\n pass","def _get_attrs_symbols():\n return {\n 'True', 'False', 'None', # those are identifiers in Python 2.7\n 'self',\n 'parent',\n 'id',\n 'uid',\n 'context',\n 'context_today',\n 'active_id',\n 'active_ids',\n 'allowed_company_ids',\n 'current_company_id',\n 'active_model',\n 'time',\n 'datetime',\n 'relativedelta',\n 'current_date',\n 'abs',\n 'len',\n 'bool',\n 'float',\n 'str',\n 'unicode',\n }","def load_attributes():\n\n # <attribute_id> <attribute_name>\n attributes_file = open(PROJECT_ROOT +'/data/attributes.txt').readlines()\n attributes_file = [i.strip().split() for i in attributes_file]\n\n # <certainty_id> <certainty_name>\n certainties_file = open(PROJECT_ROOT +'/data/CUB_200_2011/attributes/certainties.txt').readlines()\n certainties_file = [i.strip().split() for i in certainties_file]\n\n # <image_id> <attribute_id> <is_present> <certainty_id> <time>\n labels_file = open(PROJECT_ROOT +'/data/CUB_200_2011/attributes/image_attribute_labels.txt').readlines()\n labels_file = [i.strip().split() for i in labels_file]\n\n attribute_ids = {}\n for i in attributes_file:\n attribute_ids[i[1]] = int(i[0])\n\n certainty_ids = {}\n for i in certainties_file:\n certainty_ids[i[1]] = int(i[0])\n\n label_ids = {}\n for i in labels_file:\n label_ids[(int(i[0]), int(i[1]))] = list(map(lambda x:int(float(x)), i[2:]))\n\n return attribute_ids, certainty_ids, labels_file, label_ids","def load_constants():\r\n marker_dictionary = dict()\r\n marker_dictionary[\"SP\"] = SP\r\n marker_dictionary[\"LCL\"] = LCL\r\n marker_dictionary[\"ARG\"] = ARG\r\n marker_dictionary[\"THIS\"] = THIS\r\n marker_dictionary[\"THAT\"] = THAT\r\n marker_dictionary[\"SCREEN\"] = SCREEN\r\n marker_dictionary[\"KBD\"] = KBD\r\n for i in range(0, RAM_RESERVE_END):\r\n marker_dictionary[\"R\"+str(i)] = i\r\n return marker_dictionary","def build_attrs(self, base_attrs, extra_attrs=None, **kwargs):\n attrs = dict(base_attrs, **kwargs)\n if extra_attrs:\n attrs.update(extra_attrs)\n return attrs","def getInitParams(self):\n paramDict = super().getInitParams()\n paramDict['base'] = self.base\n return paramDict","def _extract_attributes(modpath, respect_all=True):\r\n try:\r\n if six.PY2:\r\n with open(modpath, 'r') as file:\r\n source = file.read()\r\n else:\r\n with open(modpath, 'r', encoding='utf8') as file:\r\n source = file.read()\r\n except Exception as ex: # nocover\r\n raise IOError('Error reading {}, caused by {}'.format(modpath, repr(ex)))\r\n valid_attrs = None\r\n if respect_all: # pragma: nobranch\r\n try:\r\n valid_attrs = static.parse_static_value('__all__', source)\r\n except NameError:\r\n pass\r\n if valid_attrs is None:\r\n # The __all__ variable is not specified or we dont care\r\n try:\r\n top_level = TopLevelVisitor.parse(source)\r\n except SyntaxError as ex:\r\n msg = 'modpath={} has bad syntax: {}'.format(modpath, ex)\r\n raise SyntaxError(msg)\r\n attrnames = top_level.attrnames\r\n # list of names we wont export by default\r\n invalid_callnames = dir(builtins)\r\n valid_attrs = []\r\n for attr in attrnames:\r\n if attr.startswith('_'):\r\n continue\r\n if attr in invalid_callnames: # nocover\r\n continue\r\n valid_attrs.append(attr)\r\n return valid_attrs","def _load_symbol(self, index):\n # Load basic information\n name, dim, type_code = self._api.symbol_info(index)\n n_records, vartype, desc = self._api.symbol_info_x(index)\n\n self._index[index] = name # Record the name\n\n attrs = {\n 'index': index,\n 'name': name,\n 'dim': dim,\n 'type_code': type_code,\n 'records': n_records,\n 'vartype': vartype,\n 'description': desc,\n }\n\n # Assemble a string description of the Symbol's type\n type_str_ = type_str[type_code]\n if type_code == gdxcc.GMS_DT_PAR and dim == 0:\n type_str_ = 'scalar'\n try:\n vartype_str_ = vartype_str[vartype]\n except KeyError: # pragma: no cover\n # Some other vartype is returned that's not described by the GDX\n # API docs\n vartype_str_ = ''\n attrs['type_str'] = '{} {}'.format(vartype_str_, type_str_)\n\n debug(str('Loading #{index} {name}: {dim}-D, {records} records, '\n u'\"{description}\"').format(**attrs))\n\n # Equations and Aliases require limited processing\n if type_code == gdxcc.GMS_DT_EQU:\n info('Loading of GMS_DT_EQU not implemented: {} {} not loaded.'.\n format(index, name))\n self._state[name] = None\n return name, type_code\n elif type_code == gdxcc.GMS_DT_ALIAS:\n parent = desc.replace('Aliased with ', '')\n self._alias[name] = parent\n assert self[parent].attrs['_gdx_type_code'] == gdxcc.GMS_DT_SET\n # Duplicate the variable\n self._variables[name] = self._variables[parent]\n self._state[name] = True\n super(File, self).set_coords(name, inplace=True)\n return name, type_code\n\n # The Symbol is either a Set, Parameter or Variable\n try: # Read the domain, as a list of names\n domain = self._api.symbol_get_domain_x(index)\n debug('domain: {}'.format(domain))\n except Exception: # gdxSymbolGetDomainX fails for the universal set\n assert name == '*'\n domain = []\n\n # Cache the attributes\n attrs['domain'] = domain\n self._state[name] = {'attrs': attrs}\n\n return name, type_code","def __init__(self, node, declare):\n symbol.__init__(self, node, declare, \"general\", \"General\")\n # get the stuff that must be present\n self.subtype = getTag(node, \"subtype\")\n # check if this is a symbol we already know of\n self.subsym = declare.checkLookup(self.subtype)\n # is there a size\n self.size = getOptionalTag(node, \"size\", \"0\")\n self.size = int(self.size)\n if self.size != 0:\n self.subsym = None","def attributes(self):\n raise NotImplementedError","def init_meta(self):\n self.meta = {}\n # Required (core)\n self.meta['ra'] = dict(ext=0, card='RA', required_ftypes=['science', 'standard'])\n self.meta['dec'] = dict(ext=0, card='DEC', required_ftypes=['science', 'standard'])\n self.meta['target'] = dict(ext=0, card='OBJECT')\n self.meta['decker'] = dict(ext=0, card='DECKNAME')\n self.meta['binning'] = dict(card=None, compound=True)\n self.meta['mjd'] = dict(ext=0, card='MJD')\n # This may depend on the old/new detector\n self.meta['exptime'] = dict(ext=0, card='ELAPTIME')\n self.meta['airmass'] = dict(ext=0, card='AIRMASS')\n #self.meta['dispname'] = dict(ext=0, card='ECHNAME')\n # Extras for config and frametyping\n self.meta['hatch'] = dict(ext=0, card='HATOPEN')\n self.meta['dispname'] = dict(ext=0, card='XDISPERS')\n self.meta['filter1'] = dict(ext=0, card='FIL1NAME')\n self.meta['echangle'] = dict(ext=0, card='ECHANGL', rtol=1e-3)\n self.meta['xdangle'] = dict(ext=0, card='XDANGL', rtol=1e-3)\n# self.meta['idname'] = dict(ext=0, card='IMAGETYP')\n # NOTE: This is the native keyword. IMAGETYP is from KOA.\n self.meta['idname'] = dict(ext=0, card='OBSTYPE')\n self.meta['frameno'] = dict(ext=0, card='FRAMENO')\n self.meta['instrument'] = dict(ext=0, card='INSTRUME')","def extra_state_attributes(self) -> dict[str, Any]:\n state_attr = super().extra_state_attributes\n state_attr[ATTR_SOURCE_ENTITY] = self._powercalc_source_entity\n state_attr[ATTR_SOURCE_DOMAIN] = self._powercalc_source_domain\n return state_attr","def _import_basekey(self, page_module, basekey):\n\n basepage_obj = getattr(page_module, basekey.lower())\n raw_dict = util._getErrmsgData(basepage_obj)\n\n attr, lcl_keys = raw_dict['attributes'], raw_dict['local_keys']\n\n basekey_dict = dict([(k, v) for k, v in attr] + # Load all Attributes\n zip(['_keys', '_comps'],\n [[core_utils.convertAllCaps(x[0]) for x in lcl_keys] or [], # local_keys\n [basekey]])) # components\n\n Basekey = self._BaseKey__class() # Dynamically created in _createErrorMsgKeys()\n\n Basekey._load(basekey_dict)\n\n # Assign BaseKey object to ErrMsg (self)\n setattr(self, basekey, Basekey)\n\n return Basekey, lcl_keys","def newGameLoad():\n import new_game\n global attributes\n attributes = {\"heroName\": new_game.heroName, \"hp\": new_game.hp, \"exp\": new_game.exp, \"lvl\": new_game.lvl,\n \"strength\": new_game.strength, \"mana\": new_game.mana,\n \"hpPotions\": new_game.hpPotions, \"manaPotions\": new_game.manaPotions,\n \"weapon\": new_game.weapon, \"weaponAtt\": new_game.weaponAtt}\n return(attributes)","def _init_attributes(self):\n self.attr = {\n 'name': None,\n 'tags': [],\n 'openHours': None,\n 'type': None,\n 'parent': None,\n 'locationId': None,\n 'bannerAbbreviation': None,\n 'arcGisAbbreviation': None,\n 'geoLocation': None,\n 'geometry': None,\n 'summary': None,\n 'description': None,\n 'descriptionHtml': None,\n 'address': None,\n 'city': None,\n 'state': None,\n 'zip': None,\n 'county': None,\n 'telephone': None,\n 'fax': None,\n 'thumbnails': [],\n 'images': [],\n 'departments': [],\n 'website': None,\n 'sqft': None,\n 'calendar': None,\n 'campus': None,\n 'girCount': None,\n 'girLimit': False,\n 'girLocations': None,\n 'synonyms': [],\n 'bldgId': None,\n 'parkingZoneGroup': None,\n 'propId': None,\n 'adaParkingSpaceCount': None,\n 'motorcycleParkingSpaceCount': None,\n 'evParkingSpaceCount': None,\n 'weeklyMenu': None,\n 'notes': None,\n 'labels': {},\n 'steward': None,\n 'shape': {}\n }","def _load(self):\n graph = self.context.parent.graph.get_context(self.context.identifier)\n data = {}\n for (_, p, o) in graph.triples((self.context.identifier, None, None)):\n if not p.startswith(META):\n continue\n name = p[len(META):]\n data[name] = o.toPython()\n return data","def base_dict():\n out = OrderedDict()\n ao(out, 'name', 'String', 'Name', name='Name')\n ao(out, 'mro', 'List', name='mro', attr=['Hidden'])\n ao(out, 'comment', 'String', '')\n ao(out, 'preset', 'Preset', '', attr=['Hidden'])\n ao(out, 'dev', 'String', attr=['Hidden'])\n ao(out, 'devpath', 'String', attr=['Hidden'])\n ao(out, 'fullpath', 'String', attr=['Hidden'])\n ao(out, 'zerotime', 'Float', name='Start time', attr=['Hidden'])\n ao(out, 'initInstrument', 'Progress', attr=['Hidden'])\n return out","def __init__(self, owner, name, addr, size, binding, sym_type, sh_info):\n super(Symbol, self).__init__()\n self.owner_obj = owner\n self.name = name\n self.addr = addr\n self.size = size\n self.binding = binding\n self.type = sym_type\n self.sh_info = sh_info if sh_info != 'SHN_UNDEF' else None\n self.resolved = False\n self.resolvedby = None\n if (claripy and isinstance(self.addr, claripy.ast.Base)) or self.addr != 0:\n self.owner_obj.symbols_by_addr[self.addr] = self\n # would be nice if we could populate demangled_names here...\n\n #demangled = self.demangled_name\n #if demangled is not None:\n # self.owner_obj.demangled_names[self.name] = demangled","def get_base_symbol_set(self):\n return self.__symbol_set[\"base\"]","def __init__(self):\n self.__dict__ = dict()\n self.load()","def _build_attributes(self):\n\n # We might rebuild the program because of snippets but we must\n # keep already bound attributes\n\n dtype = []\n for (name,gtype) in self.all_attributes:\n if name not in self._attributes.keys():\n attribute = Attribute(self, name, gtype)\n else:\n attribute = self._attributes[name]\n\n self._attributes[name] = attribute\n dtype.append(attribute.dtype)","def __init__(self, id, name, stat, base, boost):\n super(BaseStation, self).__init__(id, name)\n self.__stat = stat\n self.__base = base\n self.__boost = boost","def __init__(self, *, base=None):\n self._base = base\n\n self._map = {}","def __init__(self, base_comp = None):\n self._base_comp = base_comp\n self._pragmas = set()\n self._package_imports = set()\n self._package_locations = set()\n self._extra_deps = set()\n self._module_imports = set()\n self._actions = []\n self._sources = []\n self._var_names = set()\n self._lazy_var_names = set()\n self._ports = set()\n self._transact_types = set()\n self._add_defaults()","def dottify(self, base_name):\n obj_dict = vars(self)\n dotted_dict = {}\n for k, v in obj_dict.items():\n if v is not None:\n dotted_dict[base_name + '.' + k] = v\n return dotted_dict","def baseframe_context() -> t.Dict[str, t.Any]:\n return {\n 'networkbar_links': networkbar_links,\n 'asset_path': asset_path,\n }","def common(self):","def _add_attributes(self, this): # noqa: C901\n for v in this.data_vars:\n if \"TEMP\" in v and \"_QC\" not in v:\n this[v].attrs = {\n \"long_name\": \"SEA TEMPERATURE IN SITU ITS-90 SCALE\",\n \"standard_name\": \"sea_water_temperature\",\n \"units\": \"degree_Celsius\",\n \"valid_min\": -2.0,\n \"valid_max\": 40.0,\n \"resolution\": 0.001,\n }\n if \"ERROR\" in v:\n this[v].attrs[\"long_name\"] = (\n \"ERROR IN %s\" % this[v].attrs[\"long_name\"]\n )\n\n for v in this.data_vars:\n if \"PSAL\" in v and \"_QC\" not in v:\n this[v].attrs = {\n \"long_name\": \"PRACTICAL SALINITY\",\n \"standard_name\": \"sea_water_salinity\",\n \"units\": \"psu\",\n \"valid_min\": 0.0,\n \"valid_max\": 43.0,\n \"resolution\": 0.001,\n }\n if \"ERROR\" in v:\n this[v].attrs[\"long_name\"] = (\n \"ERROR IN %s\" % this[v].attrs[\"long_name\"]\n )\n\n for v in this.data_vars:\n if \"PRES\" in v and \"_QC\" not in v:\n this[v].attrs = {\n \"long_name\": \"Sea Pressure\",\n \"standard_name\": \"sea_water_pressure\",\n \"units\": \"decibar\",\n \"valid_min\": 0.0,\n \"valid_max\": 12000.0,\n \"resolution\": 0.1,\n \"axis\": \"Z\",\n }\n if \"ERROR\" in v:\n this[v].attrs[\"long_name\"] = (\n \"ERROR IN %s\" % this[v].attrs[\"long_name\"]\n )\n\n for v in this.data_vars:\n if \"DOXY\" in v and \"_QC\" not in v:\n this[v].attrs = {\n \"long_name\": \"Dissolved oxygen\",\n \"standard_name\": \"moles_of_oxygen_per_unit_mass_in_sea_water\",\n \"units\": \"micromole/kg\",\n \"valid_min\": -5.0,\n \"valid_max\": 600.0,\n \"resolution\": 0.001,\n }\n if \"ERROR\" in v:\n this[v].attrs[\"long_name\"] = (\n \"ERROR IN %s\" % this[v].attrs[\"long_name\"]\n )\n\n for v in this.data_vars:\n if \"_QC\" in v:\n attrs = {\n \"long_name\": \"Global quality flag of %s profile\" % v,\n \"convention\": \"Argo reference table 2a\",\n }\n this[v].attrs = attrs\n\n if \"CYCLE_NUMBER\" in this.data_vars:\n this[\"CYCLE_NUMBER\"].attrs = {\n \"long_name\": \"Float cycle number\",\n \"convention\": \"0..N, 0 : launch cycle (if exists), 1 : first complete cycle\",\n }\n\n if \"DATA_MODE\" in this.data_vars:\n this[\"DATA_MODE\"].attrs = {\n \"long_name\": \"Delayed mode or real time data\",\n \"convention\": \"R : real time; D : delayed mode; A : real time with adjustment\",\n }\n\n if \"DIRECTION\" in this.data_vars:\n this[\"DIRECTION\"].attrs = {\n \"long_name\": \"Direction of the station profiles\",\n \"convention\": \"A: ascending profiles, D: descending profiles\",\n }\n\n if \"PLATFORM_NUMBER\" in this.data_vars:\n this[\"PLATFORM_NUMBER\"].attrs = {\n \"long_name\": \"Float unique identifier\",\n \"convention\": \"WMO float identifier : A9IIIII\",\n }\n\n return this","def initAttributes(self):\n Packet.initAttributes(self)\n self.packetType = TM_PACKET_TYPE","def get_extra_attributes(self, device: str) -> dict:\n raise NotImplementedError()","def check_common_attrs(self, ast):\n declarator = ast.declarator\n attrs = declarator.attrs\n meta = declarator.metaattrs\n ntypemap = ast.typemap\n is_ptr = declarator.is_indirect()\n\n # api\n api = attrs[\"api\"]\n if api is None:\n pass\n elif api not in [\"capi\", \"buf\", \"cfi\"]:\n raise RuntimeError(\n \"'api' attribute must 'capi', 'buf', or 'cfi'\"\n )\n else:\n meta[\"api\"] = api\n\n # dimension\n dimension = attrs[\"dimension\"]\n rank = attrs[\"rank\"]\n if rank:\n if rank is True:\n raise RuntimeError(\n \"'rank' attribute must have an integer value\"\n )\n try:\n attrs[\"rank\"] = int(attrs[\"rank\"])\n except ValueError:\n raise RuntimeError(\n \"'rank' attribute must have an integer value, not '{}'\"\n .format(attrs[\"rank\"])\n )\n if attrs[\"rank\"] > 7:\n raise RuntimeError(\n \"'rank' attribute must be 0-7, not '{}'\"\n .format(attrs[\"rank\"])\n )\n if not is_ptr:\n raise RuntimeError(\n \"rank attribute can only be \"\n \"used on pointer and references\"\n )\n if dimension:\n if dimension is True:\n raise RuntimeError(\n \"dimension attribute must have a value.\"\n )\n if attrs[\"value\"]:\n raise RuntimeError(\n \"argument may not have 'value' and 'dimension' attribute.\"\n )\n if rank:\n raise RuntimeError(\n \"argument may not have 'rank' and 'dimension' attribute.\"\n )\n if not is_ptr:\n raise RuntimeError(\n \"dimension attribute can only be \"\n \"used on pointer and references\"\n )\n elif ntypemap:\n if ntypemap.base == \"vector\":\n # default to 1-d assumed shape\n attrs[\"rank\"] = 1\n elif ntypemap.name == 'char' and is_ptr == 2:\n # 'char **' -> CHARACTER(*) s(:)\n attrs[\"rank\"] = 1\n\n owner = attrs[\"owner\"]\n if owner is not None:\n if owner not in [\"caller\", \"library\"]:\n raise RuntimeError(\n \"Illegal value '{}' for owner attribute. \"\n \"Must be 'caller' or 'library'.\".format(owner)\n )\n\n free_pattern = attrs[\"free_pattern\"]\n if free_pattern is not None:\n if free_pattern not in self.newlibrary.patterns:\n raise RuntimeError(\n \"Illegal value '{}' for free_pattern attribute. \"\n \"Must be defined in patterns section.\".format(free_pattern)\n )","def extra_state_attributes(self):\n return {attr: getattr(self, '_' + prop)\n for attr, prop in ATTRIBUTES_IRHVAC.items()}","def get_attr(self, key: str) -> Any:\n raise NotImplementedError(\"This method should be implemented by \"\n \"subclasses.\")","def SavedGameLoad():\n import saved_game\n global attributes\n attributes = {\"heroName\": saved_game.heroName, \"hp\": saved_game.hp, \"exp\": saved_game.exp, \"lvl\": saved_game.lvl,\n \"strength\": saved_game.strength, \"mana\": saved_game.mana,\n \"hpPotions\": saved_game.hpPotions, \"manaPotions\": saved_game.manaPotions,\n \"weapon\": saved_game.weapon, \"weaponAtt\": saved_game.weaponAtt}\n return(attributes)","def _Attribute(self,t):\n # Only a limited set of globals supported\n func_dict = None\n \n # pyflamegpu singleton\n if isinstance(t.value, ast.Name):\n if t.value.id == \"pyflamegpu\":\n if t.attr in self.fgpu_attrs:\n # proceed\n self.write(\"flamegpu::\")\n self.write(t.attr)\n else:\n self.RaiseError(t, f\"Attribute '{t.attr}' does not exist in pyflamegpu object\")\n # math functions (try them in raw function call format) or constants\n elif t.value.id == \"math\":\n if t.attr in self.mathconsts:\n self.write(self.mathconsts[t.attr])\n else:\n self.RaiseError(t, f\"Unsupported math constant '{t.attr}'\")\n # numpy types\n elif t.value.id == \"numpy\" or t.value.id == \"np\":\n # not sure how a numpy attribute would be used without function call or type hint but translate anyway \n if t.attr in self.numpytypes:\n self.write(self.numpytypes[t.attr])\n else: \n self.RaiseError(t, f\"Unsupported numpy type {t.attr}\")\n else:\n self.RaiseError(t, f\"Global '{t.value.id}' identifiers not supported\")\n else:\n self.RaiseError(t, \"Unsupported attribute\")","def init_meta(self):\n meta = {}\n # Required (core)\n meta['ra'] = dict(ext=0, card='OBJRA')\n meta['dec'] = dict(ext=0, card='OBJDEC')\n meta['target'] = dict(ext=0, card='OBJECT')\n meta['decker'] = dict(ext=0, card='ALAPRTNM')\n meta['binning'] = dict(card=None, compound=True)\n\n meta['mjd'] = dict(ext=0, card=None, compound=True)\n meta['exptime'] = dict(ext=0, card='EXPTIME')\n meta['airmass'] = dict(ext=0, card='AIRMASS')\n # Extras for config and frametyping\n meta['dispname'] = dict(ext=0, card='ALGRNM')\n meta['idname'] = dict(ext=0, card='IMAGETYP')\n # Lamps\n # Use Keck/LRIS approach\n\n # Ingest\n self.meta = meta","def __get_common(attribute):\n return common.API_COMMON_CONFIG[attribute]","def __init__(self, cfg, tops_type=[3, 5, 10]):\n\n attr_cloth_file = open(cfg.attr_cloth_file).readlines()\n self.attr_idx2name = {}\n for i, line in enumerate(attr_cloth_file[2:]):\n self.attr_idx2name[i] = line.strip('\\n').split()[0]","def test_adding_attributes(self):\n self.assertEqual(self.compound.get_attribute(\"What\"), \"Everything\")","def get_attributes(self):\n \n retdict = {}\n retdict['s'] = str(self.s)\n if self.t != None:\n retdict['t'] = str(self.t)\n retdict['a'] = str(self.a)\n retdict['b'] = str(self.b)\n retdict['c'] = str(self.c)\n retdict['d'] = str(self.d)\n return retdict","def __getattribute__(self, name: str) -> Any:\n if name in (FLD_TITLE, FLD_ABSTRACT, FLD_FEES, FLD_ACCESS_CONSTRAINTS, FLD_CONTACT_POSITION, FLD_CONTACT_ORGANISATION):\n return self.read_local_metadata(name)\n elif name == FLD_KEYWORDS:\n kw = self.read_local_metadata(FLD_KEYWORDS)\n if kw:\n return set(kw.split(\",\"))\n else:\n return set()\n elif name == FLD_ATTRIBUTION:\n return self.read_local_metadata(FLD_ATTRIBUTION)\n else:\n return super().__getattribute__(name)","def load_data(self,do_print=True,keys_to_load=[]):\n \n if do_print:\n print\n print 'Loading corr_space data, Id = %s'%self.id\n\n\n data= np.load(self.dataPath,mmap_mode='r')\n \n loaded_keys=[]\n \n if len(keys_to_load)==0:\n for k,v in data.items():\n setattr(self,k,v)\n loaded_keys.append(k)\n else: \n for k in keys_to_load:\n setattr(self,k,data[k])\n loaded_keys.append(k)\n\n \n if do_print:\n print 'Loaded variables: '+' '.join(loaded_keys)","def load_resource_map():\n # to avoid a circular dependency\n from coinbase_commerce.api_resources.base import APIResource\n global RESOURCE_MAP\n RESOURCE_MAP = {k.RESOURCE_NAME: k for k in APIResource.get_subclasses()\n if getattr(k, \"RESOURCE_NAME\", None)}","def test_attributes(self):\n attributes = {}\n header = BDFHeader.from_path(TestData.bdf_256)\n\n for key in BDFHeader.MAPPING.keys():\n attributes[key] = getattr(header, key)\n assert attributes == {\n \"identification_code\": b\"\\xffBIOSEMI\",\n \"subject_identification\": \"\",\n \"local_recording_identification\": \"\",\n \"start_date\": datetime.date(year=2001, month=11, day=5),\n \"start_time\": time.strptime(\n \"19:38:42\",\n \"%H:%M:%S\",\n ),\n \"bytes_in_header\": 4608,\n \"data_format_version\": \"24BIT\",\n \"nb_data_records\": 60,\n \"data_duration\": 1,\n \"nb_channels\": 17,\n \"channel_labels\": [\n \"A1\",\n \"A2\",\n \"A3\",\n \"A4\",\n \"A5\",\n \"A6\",\n \"A7\",\n \"A8\",\n \"A9\",\n \"A10\",\n \"A11\",\n \"A12\",\n \"A13\",\n \"A14\",\n \"A15\",\n \"A16\",\n \"Status\",\n ],\n \"transducer_types\": [\n \"ActiveElectrode,pintype\",\n \"ActiveElectrode,pintype\",\n \"ActiveElectrode,pintype\",\n \"ActiveElectrode,pintype\",\n \"ActiveElectrode,pintype\",\n \"ActiveElectrode,pintype\",\n \"ActiveElectrode,pintype\",\n \"ActiveElectrode,pintype\",\n \"ActiveElectrode,pintype\",\n \"ActiveElectrode,pintype\",\n \"ActiveElectrode,pintype\",\n \"ActiveElectrode,pintype\",\n \"ActiveElectrode,pintype\",\n \"ActiveElectrode,pintype\",\n \"ActiveElectrode,pintype\",\n \"ActiveElectrode,pintype\",\n \"TriggersandStatus\",\n ],\n \"dimensions\": [\n \"uV\",\n \"uV\",\n \"uV\",\n \"uV\",\n \"uV\",\n \"uV\",\n \"uV\",\n \"uV\",\n \"uV\",\n \"uV\",\n \"uV\",\n \"uV\",\n \"uV\",\n \"uV\",\n \"uV\",\n \"uV\",\n \"Boolean\",\n ],\n \"min_dimensions\": [\n -262144,\n -262144,\n -262144,\n -262144,\n -262144,\n -262144,\n -262144,\n -262144,\n -262144,\n -262144,\n -262144,\n -262144,\n -262144,\n -262144,\n -262144,\n -262144,\n -8388608,\n ],\n \"max_dimensions\": [\n 262144,\n 262144,\n 262144,\n 262144,\n 262144,\n 262144,\n 262144,\n 262144,\n 262144,\n 262144,\n 262144,\n 262144,\n 262144,\n 262144,\n 262144,\n 262144,\n 8388607,\n ],\n \"min_digital\": [\n -8388608,\n -8388608,\n -8388608,\n -8388608,\n -8388608,\n -8388608,\n -8388608,\n -8388608,\n -8388608,\n -8388608,\n -8388608,\n -8388608,\n -8388608,\n -8388608,\n -8388608,\n -8388608,\n -8388608,\n ],\n \"max_digital\": [\n 8388607,\n 8388607,\n 8388607,\n 8388607,\n 8388607,\n 8388607,\n 8388607,\n 8388607,\n 8388607,\n 8388607,\n 8388607,\n 8388607,\n 8388607,\n 8388607,\n 8388607,\n 8388607,\n 8388607,\n ],\n \"prefiltering\": [\n \"HP:DC;LP:113Hz\",\n \"HP:DC;LP:113Hz\",\n \"HP:DC;LP:113Hz\",\n \"HP:DC;LP:113Hz\",\n \"HP:DC;LP:113Hz\",\n \"HP:DC;LP:113Hz\",\n \"HP:DC;LP:113Hz\",\n \"HP:DC;LP:113Hz\",\n \"HP:DC;LP:113Hz\",\n \"HP:DC;LP:113Hz\",\n \"HP:DC;LP:113Hz\",\n \"HP:DC;LP:113Hz\",\n \"HP:DC;LP:113Hz\",\n \"HP:DC;LP:113Hz\",\n \"HP:DC;LP:113Hz\",\n \"HP:DC;LP:113Hz\",\n \"Nofiltering\",\n ],\n \"samples_per_record\": [\n 256,\n 256,\n 256,\n 256,\n 256,\n 256,\n 256,\n 256,\n 256,\n 256,\n 256,\n 256,\n 256,\n 256,\n 256,\n 256,\n 256,\n ],\n \"reserved\": [\n \"Reserved\",\n \"Reserved\",\n \"Reserved\",\n \"Reserved\",\n \"Reserved\",\n \"Reserved\",\n \"Reserved\",\n \"Reserved\",\n \"Reserved\",\n \"Reserved\",\n \"Reserved\",\n \"Reserved\",\n \"Reserved\",\n \"Reserved\",\n \"Reserved\",\n \"Reserved\",\n \"Reserved\",\n ],\n }","def setSymbolProps(self, name, symbol):\r\n self.symbolProps = autosar.base.SymbolProps( str(name), str(symbol))","def initSlotObjectDict(cls):\n restslotattributedict.update(dict({extension_tunnel: \"name\"}))\n restslotattributedict.update(dict({extension_circuit: \"name\"}))\n restslotattributedict.update(dict({extension_ip_interface: \"name\"}))\n restslotattributedict.update(dict({extension_ip_route: \"name\"}))\n restslotattributedict.update(dict({gigabitethernet: \"name\"}))\n restslotattributedict.update(dict({blade: \"slot_number\"}))","def __getattribute__(self, name):\n if name in ('_special_names', '__dict__'):\n return super().__getattribute__(name)\n if hasattr(self, '_special_names'):\n if name in self._special_names:\n raise AttributeError(\n f\"{name} is a reserved variable name and it cannot be read\")\n return super().__getattribute__(name)","def _defineNAGlobals(self):\n # Check if we should add to it with locally set rules\n local_attributes = nappy.utils.getLocalAttributesConfigDict()\n local_nc_atts = local_attributes[\"nc_attributes\"]\n local_nc_to_na_map = nc_to_na_map.copy()\n\n for att, value in local_nc_atts.items():\n if att not in local_nc_to_na_map:\n local_nc_to_na_map[key] = value\n\n self.extra_comments = [[], [], []] # Normal comments, special comments, other comments\n\n for key, value in self.globals.items():\n if key != \"first_valid_date_of_data\" and \\\n type(value) not in (str, int, float):\n continue\n\n # Loop through keys of header/comment items to map\n if key in local_nc_to_na_map:\n if key == \"history\":\n time_string = time.strftime(\"%Y-%m-%d %H:%M:%S\", time.localtime(time.time()))\n history = \"History: %s - Converted to NASA Ames format using nappy-%s.\\n %s\" % \\\n (time_string, version, value)\n history = history.split(\"\\n\") \n self.history = []\n\n for h in history:\n if h[:8] != \"History:\" and h[:1] != \" \": \n h = \" \" + h\n self.history.append(h) \n \n elif key == \"institution\":\n # If fields came from NA then extract appropriate fields.\n match = re.match(r\"(.*)\\s+\\(ONAME from NASA Ames file\\);\\s+(.*)\\s+\\(ORG from NASA Ames file\\)\\.\", \n value)\n if match:\n self.na_dict[\"ONAME\"] = match.groups()[0]\n self.na_dict[\"ORG\"] = match.groups()[1]\n else:\n self.na_dict[\"ONAME\"] = value\n self.na_dict[\"ORG\"] = value\n\n # NOTE: should probably do the following search and replace on all string lines\n self.na_dict[\"ONAME\"] = self.na_dict[\"ONAME\"].replace(\"\\n\", \" \")\n self.na_dict[\"ORG\"] = self.na_dict[\"ORG\"].replace(\"\\n\", \" \")\n\n elif key == \"comment\":\n # Need to work out if they are actually comments from NASA Ames in the first place\n comment_lines = value.split(\"\\n\")\n normal_comments = []\n normal_comm_flag = None\n\n special_comments = []\n special_comm_flag = None\n\n for line in comment_lines:\n\n if line.find(hp[\"sc_start\"]) > -1:\n special_comm_flag = 1\n elif line.find(hp[\"sc_end\"]) > -1:\n special_comm_flag = None\n elif line.find(hp[\"nc_start\"]) > -1:\n normal_comm_flag = 1\n elif line.find(hp[\"nc_end\"]) > -1:\n normal_comm_flag = None\n elif special_comm_flag == 1:\n special_comments.append(line)\n elif normal_comm_flag == 1:\n normal_comments.append(line)\n elif line.find(hp[\"data_next\"]) > -1:\n pass\n else:\n normal_comments.append(line)\n\n # Carefully merge any comments with other metadata found.\n other_special_comments, other_normal_comments, other_extra_comments = \\\n [comms[:] for comms in self.extra_comments]\n\n self.extra_comments = [\n other_special_comments + special_comments, \n other_normal_comments + normal_comments, \n other_extra_comments\n ] \n\n elif key == \"first_valid_date_of_data\":\n self.na_dict[\"DATE\"] = value\n\n elif key in (\"Conventions\", \"references\"):\n self.extra_comments[2].append(f\"{key}: {value}\")\n else:\n self.na_dict[local_nc_to_na_map[key]] = value\n else:\n self.extra_comments[2].append(f\"{key}: {value}\")","def _load_attrs(self) -> None:\n self.attr_ids.clear()\n for attr_label, attr_value in self.element.attr.items():\n self.add_attr(None, attr_label, attr_value)\n self._update_attr_list()","def extract_request(self, attrs):\n try:\n _base = self.attributes()\n _new_dict = {}\n for key in attrs:\n if key in _base:\n _new_dict[key] = attrs[key]\n return _new_dict\n except Exception as e:\n print(e)","def test_get_attributes(self):\n pass","def __resolve_attribute(self, attr_dict):\n result = dict()\n for key in attr_dict:\n attr = attr_dict[key]\n if type(attr) is dict:\n result[key] = self.__resolve_attribute(attr)\n else:\n result[key] = self._resolve_curly_braces(attr)\n # resolve null key in curly brace values, such as \"${__NULL__,Online}\"\n if key in NULL_VALUE_KEY_FIELDS and result[key] == NULL_VALUE_KEY:\n result[key] = None\n\n for key in [GET_METHOD, SET_METHOD, GET_MBEAN_TYPE, SET_MBEAN_TYPE]:\n if key in result and len(result[key]) == 0:\n del result[key]\n return result","def __init__(self):\n super(sppasSymbolSettings, self).__init__()\n\n self.__dict__ = dict(\n unk=\"<UNK>\",\n phone=sppasSymbolSettings.__phone_symbols(),\n ortho=sppasSymbolSettings.__ortho_symbols(),\n all=sppasSymbolSettings.__all_symbols()\n )","def _get_all_attributes(self) -> Dict[str, Any]:\n all_attributes = self.__dict__.copy()\n all_attributes.update(self.class_attributes)\n return all_attributes","def _convert_ext_attrs(self, ast):\n self.ext_attrs = IDLExtAttrs(ast)","def __symbolsHeader(self):\n print \"Reading symbols header...\"\n \tif self.hdr.Version <= 8:\n self.ocad.seek(48)\n self.syhdr = Structure.read('TSymHeader', self.ocad)\n #print \"TSymHeader: \", self.syhdr","def test_get_attributes(test_common_dao):\n _session = test_common_dao.RAMSTK_SESSION(\n bind=test_common_dao.engine, autoflush=False, expire_on_commit=False)\n DUT = _session.query(RAMSTKSiteInfo).first()\n\n assert DUT.get_attributes() == ATTRIBUTES","def __init__(self):\n super().__init__(self.__class__.__name__, 'BBEX3.D.XAU.USD.EA.AC.C04')","def __init__(self):\n super().__init__()\n self.name = '' # name of this istance (alias)\n self.type = type(self).__name__ # specific type within this class\n self.verbosity = None # verbosity level (see message handler)\n self.globalAttributes = {} # this is a dictionary that contains parameters that are set at the level of the base classes defining the types\n self._knownAttribute = [] # this is a list of strings representing the allowed attribute in the xml input for the class\n self._knownAttribute += ['name','verbosity'] # attributes that are known\n self.printTag = 'BaseType' # the tag that refers to this class in all the specific printing\n self.variableGroups = {} # the variables this class needs to be aware of\n self.metadataKeys = set() # list of registered metadata keys to expect from this entity\n self.metadataParams = {} # dictionary of registered metadata keys with repect to their indexes","def fill_attributes(ml_file, other_file):\n with xr.load_dataset(other_file) as other:\n with xr.open_dataset(ml_file) as ml:\n for variable in other.variables:\n if variable in ml.variables:\n other[variable].attrs = ml[variable].attrs\n other.to_netcdf(other_file)","def loadKeysAttributes(self):\n\t\tif os.name == \"nt\" :\n\t\t\tself.keys_nb = [273,276,274,275,13,271,27,32,303,304,9,305,306,301,8,\n\t\t\t\t49,50,51,52,53,54,55,56,57,48,45,61,\n\t\t\t\t113,98,99,100,101,102,103,104,105,106,107,108,59,110,111,112,97,114,115,116,117,118,122,120,121,119]\n\t\telse :\n\t\t\twarnings.warn(\"{} OS ins't supported for pygame kernel {}\".format(os.name, __version__),Warning)\n\t\t\tself.keys_nb = []\n\t\tself.keys_name = [\"UpARR\",\"LeftARR\",\"DownARR\",\"RightARR\",\"Enter\",\"ENTER\",\"esc\",\" \",\"Maj\",\"Maj\",\"Tab\",\"ctrl\",\"ctrl\",\"VerrMaj\",\"Backspace\",\n\t\t\t\"&\",\"é\",\"\\\"\",\"\\'\",\"(\",\"-\",\"è\",\"_\",\"ç\",\"à\",\")\",\"=\",\n\t\t\t\"a\",\"b\",\"c\",\"d\",\"e\",\"f\",\"g\",\"h\",\"i\",\"j\",\"k\",\"l\",\"m\",\"n\",\"o\",\"p\",\"q\",\"r\",\"s\",\"t\",\"u\",\"v\",\"w\",\"x\",\"y\",\"z\"]","def __config_attributes(self):\n self.__name = self.__data[self.__code][\"airportName\"]\n self.__country = Country(name=self.__data[self.__code][\"countryName\"],\n code=self.__data[self.__code][\"countryCode\"])\n try:\n self.__city = self.__data[self.__code][\"city\"]\n except Exception:\n self.__city = ''","def init_meta(self):\n meta = {}\n # Required (core)\n meta['ra'] = dict(ext=1, card='RA')\n meta['dec'] = dict(ext=1, card='DEC')\n meta['target'] = dict(ext=1, card='OBJECT')\n meta['decker'] = dict(ext=1, card='APERTURE')\n meta['dichroic'] = dict(ext=1, card='FILTER')\n meta['binning'] = dict(ext=1, card=None, default='1,1')\n\n meta['mjd'] = dict(ext=0, card=None, compound=True)\n meta['exptime'] = dict(ext=1, card='EXPTIME')\n meta['airmass'] = dict(ext=1, card='AIRMASS')\n # Extras for config and frametyping\n meta['dispname'] = dict(ext=1, card='DISPERSE')\n meta['idname'] = dict(ext=1, card='IMAGETYP')\n\n # Ingest\n self.meta = meta","def _derive_extra_metadata(self, extra_metadata):\n extra_metadata['platform']['Family'] = extra_metadata['platform']['Platform Family Name']\n\n # Add platform number if derivable from file\n if self.__class__ is not SAFESentinel1:\n extra_metadata['platform']['Family'] += \"-%s\" % extra_metadata['platform']['Platform Number']","def __init__(self):\r\n self.s_table = SymbolTable.preSymbols","def extra_state_attributes(self) -> dict[str, Any]:\n ret = {\n ATTR_SOURCE: self._source_entity_id,\n ATTR_COEFFICIENTS: self._coefficients,\n }\n if self._source_attribute:\n ret[ATTR_SOURCE_ATTRIBUTE] = self._source_attribute\n return ret","def rawbase_meta(self, rawbase_name):\n url = \"%s/rawbase/%s\" % (self.api, rawbase_name)\n return self.__get_request(url, 5)","def _get_asset(self, symbol):\n if symbol == \"BEX\":\n return {\"symbol\": \"BEX\",\n \"precision\": 3\n }\n elif symbol == \"BBD\":\n return {\"symbol\": \"BBD\",\n \"precision\": 3\n }\n elif symbol == \"VESTS\":\n return {\"symbol\": \"VESTS\",\n \"precision\": 6\n }\n else:\n return None","def dict(self) -> dict():\n\n dict_reg_hive = {}\n\n for _attribute in self.attributes.__dict__.items():\n if isinstance(_attribute[1], str):\n if not True in [_attribute[1].startswith(prefix) for prefix in ['<', 'providers.', 'None']]:\n _attribute_value = getattr(self, _attribute[1])\n dict_reg_hive.update({_attribute[1]: _attribute_value})\n\n return dict_reg_hive","def test_baseclass_attrs_type(self):\n\n base_class = BaseModel()\n cn = base_class.__class__.__name__\n idn = base_class.id\n attrs = base_class.__dict__\n\n self.assertTrue(type(cn), str)\n self.assertTrue(type(id), str)\n self.assertDictEqual(attrs, base_class.__dict__)","def initAttributes(self):\n Packet.initAttributes(self)\n self.packetType = TC_PACKET_TYPE","def extra_state_attributes(self):\n state_attr = {}\n if self.vendor_id is not None:\n state_attr[ATTR_VENDOR_ID] = self.vendor_id\n state_attr[ATTR_VENDOR_NAME] = self.vendor_name\n if self.type_id is not None:\n state_attr[ATTR_TYPE_ID] = self.type_id\n state_attr[ATTR_TYPE] = self.type\n if self.physical_address is not None:\n state_attr[ATTR_PHYSICAL_ADDRESS] = self.physical_address\n return state_attr","def load_general_props(self):\n\n # load general and shared header.properties file from zipfile\n root = ForceArchive(self.file_path).read_properties('header.properties')\n shared = ForceArchive(self.file_path).read_properties('shared-data/header.properties')\n full = {}\n full.update(root)\n full.update(shared)\n return full","def build_base(self):\n\n # start- and endpoints of lines are nodes, but they do not need to have a point object associated to them\n # in this case, self.geo is None and the no, prop and name attributes stay as the default values set in the constructor\n if (self.geo):\n\n attr = ri.RhinoInput(rs.ObjectName(self.geo))\n\n self.no = attr.get_no()\n if (self.no != -1):\n self.strict_naming = True\n\n self.name = attr.get_name()\n self.prop = attr.get_prop()","def load(self, key):\n return self.load_attrs().get(key)","def extra_state_attributes(self):\n attr = {}\n #attr[\"name\"] = self._visonic_device.getDeviceName()\n attr[PANEL_ATTRIBUTE_NAME] = self._panel\n attr[DEVICE_ATTRIBUTE_NAME] = self._visonic_device.getDeviceID()\n return attr","def extra_state_attributes(self) -> dict[str, Any] | None:\n # Different measuring stations have different sets of sensors. We don't know\n # what data we will get.\n for sensor in SENSOR_MAP:\n if sensor in self.coordinator.data:\n self._attrs[f\"{SENSOR_MAP[sensor]}_index\"] = self.coordinator.data[\n sensor\n ][\"index\"]\n self._attrs[ATTR_STATION] = self.coordinator.gios.station_name\n return self._attrs","def __getattribute__(self, name):\n try:\n return self.gps.__getattribute__(name) \n except:\n return super().__getattribute__(name)","def get_label_dict(base):\n label_dict = copy.deepcopy(labelDict)\n symbol = None\n if base.rendererType == \"gdb\":\n symbol = LabelRenderer.get_gdb_symbol(base.arcLayer)\n annotation_class_id = LabelRenderer.get_annotation_class_id(base.arcLayer)\n\n label_dict['labelValues']['type'] = 'rule-based'\n label_dict['labelValues']['classId'] = str(annotation_class_id)\n label_dict['labelValues']['text-style']['fieldName'] = 'TextString'\n elif base.rendererType == \"feature\":\n symbol = LabelRenderer.specify_feature_content(base.arcLayer, label_dict)\n\n formatted_symbol = change_interface(symbol, ArcGisModules.module_display.IFormattedTextSymbol)\n\n LabelRenderer.get_text_style(formatted_symbol, label_dict)\n LabelRenderer.get_background(formatted_symbol, label_dict)\n\n return label_dict"],"string":"[\n \"def _base_attrs(self, service):\\n keys = ['name', 'desc', 'url']\\n return {name:getattr(service, name, None) for name in keys}\",\n \"def __extract_common_attrs(self, raw_data: Dict) -> None:\\n for attr in self.COMMON_ATTRS:\\n if attr not in self.ATTRS and attr in raw_data:\\n setattr(self, attr, raw_data[attr])\",\n \"def load_attribute_data():\\n global attr_value_counts, attr_counts, value_counts, \\\\\\n attr_value_ratios, attrs\\n\\n print \\\"Loading extraction data...\\\"\\n with open('./data/common_extractions.json') as f:\\n place_data = json.loads(f.read())\\n for place in place_data:\\n for attr in place_data[place]:\\n if attr not in attr_value_counts:\\n attrs.add(attr)\\n attr_value_counts[attr] = {}\\n attr_counts[attr] = 0\\n for value in place_data[place][attr]:\\n c = place_data[place][attr][value]\\n value_counts[value] = value_counts.get(value, 0) + c\\n attr_counts[attr] += c\\n attr_value_counts[attr][value] = \\\\\\n attr_value_counts[attr].get(value, 0) + c\\n \\n for attr in attrs:\\n attr_value_ratios[attr] = {}\\n for value in attr_value_counts[attr]:\\n attr_value_ratios[attr][value] = float(attr_value_counts[attr][value]) \\\\\\n / attr_counts[attr]\",\n \"def inherit_attributes(self, attr_table, base_ext_type):\\n base_attrs = base_ext_type.attribute_table.attributedict\\n attr_table.inherited.update(base_attrs) # { attr_name }\\n attr_table.attributedict.update(base_attrs) # { attr_name : attr_type }\",\n \"def _load_attributes(self, force=False):\\n # All attributes to be loaded, except _namespaces, which is a special\\n # case because it requires additional params in the API query:\\n attrs = [self._name, self._project, self._lang, self._base_url,\\n self._article_path, self._script_path]\\n\\n params = {\\\"action\\\": \\\"query\\\", \\\"meta\\\": \\\"siteinfo\\\", \\\"siprop\\\": \\\"general\\\"}\\n\\n if not self._namespaces or force:\\n params[\\\"siprop\\\"] += \\\"|namespaces|namespacealiases\\\"\\n with self._api_lock:\\n result = self._api_query(params, no_assert=True)\\n self._load_namespaces(result)\\n elif all(attrs): # Everything is already specified and we're not told\\n return # to force a reload, so do nothing\\n else: # We're only loading attributes other than _namespaces\\n with self._api_lock:\\n result = self._api_query(params, no_assert=True)\\n\\n res = result[\\\"query\\\"][\\\"general\\\"]\\n self._name = res[\\\"wikiid\\\"]\\n self._project = res[\\\"sitename\\\"].lower()\\n self._lang = res[\\\"lang\\\"]\\n self._base_url = res[\\\"server\\\"]\\n self._article_path = res[\\\"articlepath\\\"]\\n self._script_path = res[\\\"scriptpath\\\"]\",\n \"def load_attrs(self):\\n return loads(self.get_attr().GetObject()) or {}\",\n \"def load_vso_values():\\n from sunpy.net import attrs as a\\n\\n here = os.path.dirname(os.path.realpath(__file__))\\n with open(os.path.join(here, 'data', 'attrs.json')) as attrs_file:\\n keyword_info = json.load(attrs_file)\\n\\n # Now to traverse the saved dict and give them attr keys.\\n attrs = {}\\n for key, value in keyword_info.items():\\n attr = getattr(a, key.capitalize(), None)\\n if attr is None:\\n attr = getattr(a.vso, key.capitalize())\\n attrs[attr] = value\\n return attrs\",\n \"def read_extras(self, f):\\n\\n gb = f[\\\"base state\\\"]\\n for name in gb:\\n self.base[name] = Basestate(self.cc_data.grid.ny, ng=self.cc_data.grid.ng)\\n self.base[name].d[:] = gb[name]\",\n \"def get_implementation_specific_attrs(cls):\\n ctypes_version = cls.get_drmaa2_library().drmaa2_get_drmaa_version();\\n if cls.implementation_specific_attrs is None:\\n cls.implementation_specific_attrs = cls.to_py_dict(\\n cls.get_drmaa2_library().uge_vi_impl_spec_get(ctypes_version))\\n return cls.implementation_specific_attrs\",\n \"def _load_symbol_data(self, name):\\n if self._state[name] in (True, None): # Skip Symbols already loaded\\n return\\n\\n # Unpack attributes\\n attrs = self._state[name]['attrs']\\n index, dim, domain, records = [attrs[k] for k in ('index', 'dim',\\n 'domain', 'records')]\\n\\n # Read the data\\n self._cache_data(name, index, dim, records)\\n\\n # If the GAMS method 'sameas' is invoked in a program, the resulting\\n # GDX file contains an empty Set named 'SameAs' with domain (*,*). Do\\n # not read this\\n if name == 'SameAs' and domain == ['*', '*']:\\n self._state[name] = None\\n self._index[index] = None\\n return\\n\\n domain = self._infer_domain(name, domain,\\n self._state[name]['elements'])\\n\\n # Create an xr.DataArray with the Symbol's data\\n self._add_symbol(name, dim, domain, attrs)\",\n \"def __getattribute__(self, name):\\n if name == \\\"_update_header\\\":\\n return object.__getattribute__(self, \\\"_update_header\\\")\\n\\n elif name == \\\"_get_lib\\\":\\n return object.__getattribute__(self, \\\"_get_lib\\\")\\n\\n else:\\n # Load symbols from the current process (Python).\\n return getattr(self._get_lib(), name)\",\n \"def attributes(self):\\n ...\",\n \"def init_meta(self):\\n self.meta = {}\\n # Required (core)\\n self.meta['ra'] = dict(ext=0, card='RA')\\n self.meta['dec'] = dict(ext=0, card='DEC')\\n self.meta['target'] = dict(ext=0, card='object')\\n self.meta['idname'] = dict(ext=0, card='obsmode')\\n self.meta['decker'] = dict(ext=0, card='MASKNAME')\\n self.meta['binning'] = dict(card=None, compound=True) # Uses CCDSUM\\n self.meta['detector']=dict(ext=0,card='detector')\\n self.meta['mjd'] = dict(ext=0, card='MJD-OBS')\\n self.meta['exptime'] = dict(ext=0, card='EXPTIME')\\n self.meta['airmass'] = dict(ext=0, card='AIRMASS')\\n self.meta['dispname'] = dict(ext=0, card='GRISM')\\n self.meta['datasec'] = dict(ext=1, card='DATASEC')\\n self.meta['dichroic'] = dict(ext=0, card='FILTER1')\\n self.meta['instrument'] = dict(ext=0, card='INSTRUME')\",\n \"def attributes(self):\",\n \"def _init_attributes(self):\\n if os.name == \\\"nt\\\":\\n if \\\"64\\\" in platform.architecture()[0]:\\n platform_arch = \\\"x86_64\\\"\\n elif \\\"32\\\" in platform.architecture()[0]:\\n platform_arch = \\\"i386\\\"\\n else:\\n platform_arch = platform.architecture()\\n os_ver = f\\\"Windows-{platform.win32_ver()[1]}\\\"\\n else:\\n platform_arch = platform.machine()\\n if platform.system() == \\\"Darwin\\\":\\n os_ver = f\\\"macOS-{platform.mac_ver()[0]}\\\"\\n else:\\n os_ver = \\\"-\\\".join(linux_distribution()[0:2])\\n\\n license_chunks = LICENSE.split(\\\" \\\")\\n if license_chunks[0] == \\\"GPLv2\\\":\\n client_license = \\\"GPL-2.0\\\"\\n else:\\n client_license = \\\"Commercial\\\"\\n\\n default_attributes = {\\n # Process id\\n \\\"_pid\\\": str(os.getpid()),\\n # Platform architecture\\n \\\"_platform\\\": platform_arch,\\n # OS version\\n \\\"_os\\\": os_ver,\\n # Hostname of the local machine\\n \\\"_source_host\\\": socket.gethostname(),\\n # Client's name\\n \\\"_client_name\\\": \\\"mysql-connector-python\\\",\\n # Client's version\\n \\\"_client_version\\\": \\\".\\\".join([str(x) for x in VERSION[0:3]]),\\n # Client's License identifier\\n \\\"_client_license\\\": client_license,\\n }\\n self._settings[\\\"attributes\\\"].update(default_attributes)\\n\\n if \\\"connection-attributes\\\" in self._settings:\\n for attr_name in self._settings[\\\"connection-attributes\\\"]:\\n attr_value = self._settings[\\\"connection-attributes\\\"][attr_name]\\n # Validate name type\\n if not isinstance(attr_name, str):\\n raise InterfaceError(\\n f\\\"Attribute name '{attr_name}' must be a string type\\\"\\n )\\n # Validate attribute name limit 32 characters\\n if len(attr_name) > 32:\\n raise InterfaceError(\\n f\\\"Attribute name '{attr_name}' exceeds 32 characters \\\"\\n \\\"limit size\\\"\\n )\\n # Validate names in connection-attributes cannot start with \\\"_\\\"\\n if attr_name.startswith(\\\"_\\\"):\\n raise InterfaceError(\\n \\\"Key names in 'session-connect-attributes' cannot \\\"\\n f\\\"start with '_', found: {attr_name}\\\"\\n )\\n # Validate value type\\n if not isinstance(attr_value, str):\\n raise InterfaceError(\\n f\\\"Attribute name '{attr_name}' value '{attr_value}' \\\"\\n \\\" must be a string type\\\"\\n )\\n\\n # Validate attribute value limit 1024 characters\\n if len(attr_value) > 1024:\\n raise InterfaceError(\\n f\\\"Attribute name '{attr_name}' value: '{attr_value}' \\\"\\n \\\"exceeds 1024 characters limit size\\\"\\n )\\n\\n self._settings[\\\"attributes\\\"][attr_name] = attr_value\",\n \"def init_attrs(self):\\n raise NotImplementedError\",\n \"def load(self):\\r\\n self.domain.get_attributes(self.name, item=self)\",\n \"def init_meta(self):\\n self.meta = {}\\n # Required (core)\\n self.meta['ra'] = dict(ext=0, card='RA')\\n self.meta['dec'] = dict(ext=0, card='DEC')\\n self.meta['target'] = dict(ext=0, card='object')\\n self.meta['idname'] = dict(ext=0, card='obsmode')\\n self.meta['decker'] = dict(ext=0, card='MASKNAME')\\n self.meta['binning'] = dict(card=None, compound=True)\\n self.meta['detector'] = dict(ext=0, card='detector')\\n self.meta['mjd'] = dict(ext=0, card='MJD-OBS')\\n self.meta['exptime'] = dict(ext=0, card='EXPTIME')\\n self.meta['airmass'] = dict(ext=0, card='AIRMASS')\\n self.meta['dispname'] = dict(ext=0, card='GRISM')\\n self.meta['datasec'] = dict(ext=0, card='DETSIZE')\\n self.meta['dichroic'] = dict(ext=0, card='FILTER1')\\n self.meta['instrument'] = dict(ext=0, card='INSTRUME')\\n self.meta['slitwid'] = dict(card=None, compound=True)\",\n \"def _load(self) -> dict:\\n raise NotImplementedError()\",\n \"def test_all_attributes_in_base_metadata(self):\\n\\n name = 'idsvc.basemeta'\\n uuid = 'ABC'\\n value = { 'color': 'blue' }\\n owner = 'bob'\\n schemaId = None\\n internalUsername = None\\n associationIds = ['CDE', 'EFG']\\n lastUpdated = '2016-06-15T17:09:06.137-05:00'\\n name = 'idsvc.basemeta'\\n created = '2016-06-15T17:09:06.137-05:00'\\n _links = ''\\n\\n meta = {\\n 'name': name,\\n 'uuid': uuid,\\n 'value': value,\\n 'owner': owner,\\n 'schemaId': schemaId,\\n 'internalUsername': internalUsername,\\n 'associationIds': associationIds,\\n 'lastUpdated': lastUpdated,\\n 'name': name,\\n 'created': created,\\n '_links': _links\\n }\\n\\n base_meta = BaseMetadata(api_client=self.IDS_SYS_CLIENT, meta=meta)\\n self.assertDictEqual(base_meta.meta, meta)\",\n \"def init_meta(self):\\n self.meta = {}\\n # Required (core)\\n self.meta['ra'] = dict(ext=0, card='RA')\\n self.meta['dec'] = dict(ext=0, card='DEC')\\n self.meta['target'] = dict(ext=0, card='OBJECT')\\n self.meta['decker'] = dict(ext=0, card=None, default='default')\\n self.meta['dichroic'] = dict(ext=0, card=None, default='default')\\n self.meta['binning'] = dict(ext=0, card=None, default='1,1')\\n\\n self.meta['mjd'] = dict(ext=0, card='ACQTIME')\\n self.meta['exptime'] = dict(ext=0, card='EXPTIME')\\n self.meta['airmass'] = dict(ext=0, card='AIRMASS')\\n # Extras for config and frametyping\\n self.meta['dispname'] = dict(ext=0, card='GRISM')\\n self.meta['idname'] = dict(ext=0, card='OBSTYPE')\\n self.meta['instrument'] = dict(ext=0, card='INSTRUME')\",\n \"def get_attributes(self) -> Dict[str, str]:\\n pass\",\n \"def _get_attrs_symbols():\\n return {\\n 'True', 'False', 'None', # those are identifiers in Python 2.7\\n 'self',\\n 'parent',\\n 'id',\\n 'uid',\\n 'context',\\n 'context_today',\\n 'active_id',\\n 'active_ids',\\n 'allowed_company_ids',\\n 'current_company_id',\\n 'active_model',\\n 'time',\\n 'datetime',\\n 'relativedelta',\\n 'current_date',\\n 'abs',\\n 'len',\\n 'bool',\\n 'float',\\n 'str',\\n 'unicode',\\n }\",\n \"def load_attributes():\\n\\n # <attribute_id> <attribute_name>\\n attributes_file = open(PROJECT_ROOT +'/data/attributes.txt').readlines()\\n attributes_file = [i.strip().split() for i in attributes_file]\\n\\n # <certainty_id> <certainty_name>\\n certainties_file = open(PROJECT_ROOT +'/data/CUB_200_2011/attributes/certainties.txt').readlines()\\n certainties_file = [i.strip().split() for i in certainties_file]\\n\\n # <image_id> <attribute_id> <is_present> <certainty_id> <time>\\n labels_file = open(PROJECT_ROOT +'/data/CUB_200_2011/attributes/image_attribute_labels.txt').readlines()\\n labels_file = [i.strip().split() for i in labels_file]\\n\\n attribute_ids = {}\\n for i in attributes_file:\\n attribute_ids[i[1]] = int(i[0])\\n\\n certainty_ids = {}\\n for i in certainties_file:\\n certainty_ids[i[1]] = int(i[0])\\n\\n label_ids = {}\\n for i in labels_file:\\n label_ids[(int(i[0]), int(i[1]))] = list(map(lambda x:int(float(x)), i[2:]))\\n\\n return attribute_ids, certainty_ids, labels_file, label_ids\",\n \"def load_constants():\\r\\n marker_dictionary = dict()\\r\\n marker_dictionary[\\\"SP\\\"] = SP\\r\\n marker_dictionary[\\\"LCL\\\"] = LCL\\r\\n marker_dictionary[\\\"ARG\\\"] = ARG\\r\\n marker_dictionary[\\\"THIS\\\"] = THIS\\r\\n marker_dictionary[\\\"THAT\\\"] = THAT\\r\\n marker_dictionary[\\\"SCREEN\\\"] = SCREEN\\r\\n marker_dictionary[\\\"KBD\\\"] = KBD\\r\\n for i in range(0, RAM_RESERVE_END):\\r\\n marker_dictionary[\\\"R\\\"+str(i)] = i\\r\\n return marker_dictionary\",\n \"def build_attrs(self, base_attrs, extra_attrs=None, **kwargs):\\n attrs = dict(base_attrs, **kwargs)\\n if extra_attrs:\\n attrs.update(extra_attrs)\\n return attrs\",\n \"def getInitParams(self):\\n paramDict = super().getInitParams()\\n paramDict['base'] = self.base\\n return paramDict\",\n \"def _extract_attributes(modpath, respect_all=True):\\r\\n try:\\r\\n if six.PY2:\\r\\n with open(modpath, 'r') as file:\\r\\n source = file.read()\\r\\n else:\\r\\n with open(modpath, 'r', encoding='utf8') as file:\\r\\n source = file.read()\\r\\n except Exception as ex: # nocover\\r\\n raise IOError('Error reading {}, caused by {}'.format(modpath, repr(ex)))\\r\\n valid_attrs = None\\r\\n if respect_all: # pragma: nobranch\\r\\n try:\\r\\n valid_attrs = static.parse_static_value('__all__', source)\\r\\n except NameError:\\r\\n pass\\r\\n if valid_attrs is None:\\r\\n # The __all__ variable is not specified or we dont care\\r\\n try:\\r\\n top_level = TopLevelVisitor.parse(source)\\r\\n except SyntaxError as ex:\\r\\n msg = 'modpath={} has bad syntax: {}'.format(modpath, ex)\\r\\n raise SyntaxError(msg)\\r\\n attrnames = top_level.attrnames\\r\\n # list of names we wont export by default\\r\\n invalid_callnames = dir(builtins)\\r\\n valid_attrs = []\\r\\n for attr in attrnames:\\r\\n if attr.startswith('_'):\\r\\n continue\\r\\n if attr in invalid_callnames: # nocover\\r\\n continue\\r\\n valid_attrs.append(attr)\\r\\n return valid_attrs\",\n \"def _load_symbol(self, index):\\n # Load basic information\\n name, dim, type_code = self._api.symbol_info(index)\\n n_records, vartype, desc = self._api.symbol_info_x(index)\\n\\n self._index[index] = name # Record the name\\n\\n attrs = {\\n 'index': index,\\n 'name': name,\\n 'dim': dim,\\n 'type_code': type_code,\\n 'records': n_records,\\n 'vartype': vartype,\\n 'description': desc,\\n }\\n\\n # Assemble a string description of the Symbol's type\\n type_str_ = type_str[type_code]\\n if type_code == gdxcc.GMS_DT_PAR and dim == 0:\\n type_str_ = 'scalar'\\n try:\\n vartype_str_ = vartype_str[vartype]\\n except KeyError: # pragma: no cover\\n # Some other vartype is returned that's not described by the GDX\\n # API docs\\n vartype_str_ = ''\\n attrs['type_str'] = '{} {}'.format(vartype_str_, type_str_)\\n\\n debug(str('Loading #{index} {name}: {dim}-D, {records} records, '\\n u'\\\"{description}\\\"').format(**attrs))\\n\\n # Equations and Aliases require limited processing\\n if type_code == gdxcc.GMS_DT_EQU:\\n info('Loading of GMS_DT_EQU not implemented: {} {} not loaded.'.\\n format(index, name))\\n self._state[name] = None\\n return name, type_code\\n elif type_code == gdxcc.GMS_DT_ALIAS:\\n parent = desc.replace('Aliased with ', '')\\n self._alias[name] = parent\\n assert self[parent].attrs['_gdx_type_code'] == gdxcc.GMS_DT_SET\\n # Duplicate the variable\\n self._variables[name] = self._variables[parent]\\n self._state[name] = True\\n super(File, self).set_coords(name, inplace=True)\\n return name, type_code\\n\\n # The Symbol is either a Set, Parameter or Variable\\n try: # Read the domain, as a list of names\\n domain = self._api.symbol_get_domain_x(index)\\n debug('domain: {}'.format(domain))\\n except Exception: # gdxSymbolGetDomainX fails for the universal set\\n assert name == '*'\\n domain = []\\n\\n # Cache the attributes\\n attrs['domain'] = domain\\n self._state[name] = {'attrs': attrs}\\n\\n return name, type_code\",\n \"def __init__(self, node, declare):\\n symbol.__init__(self, node, declare, \\\"general\\\", \\\"General\\\")\\n # get the stuff that must be present\\n self.subtype = getTag(node, \\\"subtype\\\")\\n # check if this is a symbol we already know of\\n self.subsym = declare.checkLookup(self.subtype)\\n # is there a size\\n self.size = getOptionalTag(node, \\\"size\\\", \\\"0\\\")\\n self.size = int(self.size)\\n if self.size != 0:\\n self.subsym = None\",\n \"def attributes(self):\\n raise NotImplementedError\",\n \"def init_meta(self):\\n self.meta = {}\\n # Required (core)\\n self.meta['ra'] = dict(ext=0, card='RA', required_ftypes=['science', 'standard'])\\n self.meta['dec'] = dict(ext=0, card='DEC', required_ftypes=['science', 'standard'])\\n self.meta['target'] = dict(ext=0, card='OBJECT')\\n self.meta['decker'] = dict(ext=0, card='DECKNAME')\\n self.meta['binning'] = dict(card=None, compound=True)\\n self.meta['mjd'] = dict(ext=0, card='MJD')\\n # This may depend on the old/new detector\\n self.meta['exptime'] = dict(ext=0, card='ELAPTIME')\\n self.meta['airmass'] = dict(ext=0, card='AIRMASS')\\n #self.meta['dispname'] = dict(ext=0, card='ECHNAME')\\n # Extras for config and frametyping\\n self.meta['hatch'] = dict(ext=0, card='HATOPEN')\\n self.meta['dispname'] = dict(ext=0, card='XDISPERS')\\n self.meta['filter1'] = dict(ext=0, card='FIL1NAME')\\n self.meta['echangle'] = dict(ext=0, card='ECHANGL', rtol=1e-3)\\n self.meta['xdangle'] = dict(ext=0, card='XDANGL', rtol=1e-3)\\n# self.meta['idname'] = dict(ext=0, card='IMAGETYP')\\n # NOTE: This is the native keyword. IMAGETYP is from KOA.\\n self.meta['idname'] = dict(ext=0, card='OBSTYPE')\\n self.meta['frameno'] = dict(ext=0, card='FRAMENO')\\n self.meta['instrument'] = dict(ext=0, card='INSTRUME')\",\n \"def extra_state_attributes(self) -> dict[str, Any]:\\n state_attr = super().extra_state_attributes\\n state_attr[ATTR_SOURCE_ENTITY] = self._powercalc_source_entity\\n state_attr[ATTR_SOURCE_DOMAIN] = self._powercalc_source_domain\\n return state_attr\",\n \"def _import_basekey(self, page_module, basekey):\\n\\n basepage_obj = getattr(page_module, basekey.lower())\\n raw_dict = util._getErrmsgData(basepage_obj)\\n\\n attr, lcl_keys = raw_dict['attributes'], raw_dict['local_keys']\\n\\n basekey_dict = dict([(k, v) for k, v in attr] + # Load all Attributes\\n zip(['_keys', '_comps'],\\n [[core_utils.convertAllCaps(x[0]) for x in lcl_keys] or [], # local_keys\\n [basekey]])) # components\\n\\n Basekey = self._BaseKey__class() # Dynamically created in _createErrorMsgKeys()\\n\\n Basekey._load(basekey_dict)\\n\\n # Assign BaseKey object to ErrMsg (self)\\n setattr(self, basekey, Basekey)\\n\\n return Basekey, lcl_keys\",\n \"def newGameLoad():\\n import new_game\\n global attributes\\n attributes = {\\\"heroName\\\": new_game.heroName, \\\"hp\\\": new_game.hp, \\\"exp\\\": new_game.exp, \\\"lvl\\\": new_game.lvl,\\n \\\"strength\\\": new_game.strength, \\\"mana\\\": new_game.mana,\\n \\\"hpPotions\\\": new_game.hpPotions, \\\"manaPotions\\\": new_game.manaPotions,\\n \\\"weapon\\\": new_game.weapon, \\\"weaponAtt\\\": new_game.weaponAtt}\\n return(attributes)\",\n \"def _init_attributes(self):\\n self.attr = {\\n 'name': None,\\n 'tags': [],\\n 'openHours': None,\\n 'type': None,\\n 'parent': None,\\n 'locationId': None,\\n 'bannerAbbreviation': None,\\n 'arcGisAbbreviation': None,\\n 'geoLocation': None,\\n 'geometry': None,\\n 'summary': None,\\n 'description': None,\\n 'descriptionHtml': None,\\n 'address': None,\\n 'city': None,\\n 'state': None,\\n 'zip': None,\\n 'county': None,\\n 'telephone': None,\\n 'fax': None,\\n 'thumbnails': [],\\n 'images': [],\\n 'departments': [],\\n 'website': None,\\n 'sqft': None,\\n 'calendar': None,\\n 'campus': None,\\n 'girCount': None,\\n 'girLimit': False,\\n 'girLocations': None,\\n 'synonyms': [],\\n 'bldgId': None,\\n 'parkingZoneGroup': None,\\n 'propId': None,\\n 'adaParkingSpaceCount': None,\\n 'motorcycleParkingSpaceCount': None,\\n 'evParkingSpaceCount': None,\\n 'weeklyMenu': None,\\n 'notes': None,\\n 'labels': {},\\n 'steward': None,\\n 'shape': {}\\n }\",\n \"def _load(self):\\n graph = self.context.parent.graph.get_context(self.context.identifier)\\n data = {}\\n for (_, p, o) in graph.triples((self.context.identifier, None, None)):\\n if not p.startswith(META):\\n continue\\n name = p[len(META):]\\n data[name] = o.toPython()\\n return data\",\n \"def base_dict():\\n out = OrderedDict()\\n ao(out, 'name', 'String', 'Name', name='Name')\\n ao(out, 'mro', 'List', name='mro', attr=['Hidden'])\\n ao(out, 'comment', 'String', '')\\n ao(out, 'preset', 'Preset', '', attr=['Hidden'])\\n ao(out, 'dev', 'String', attr=['Hidden'])\\n ao(out, 'devpath', 'String', attr=['Hidden'])\\n ao(out, 'fullpath', 'String', attr=['Hidden'])\\n ao(out, 'zerotime', 'Float', name='Start time', attr=['Hidden'])\\n ao(out, 'initInstrument', 'Progress', attr=['Hidden'])\\n return out\",\n \"def __init__(self, owner, name, addr, size, binding, sym_type, sh_info):\\n super(Symbol, self).__init__()\\n self.owner_obj = owner\\n self.name = name\\n self.addr = addr\\n self.size = size\\n self.binding = binding\\n self.type = sym_type\\n self.sh_info = sh_info if sh_info != 'SHN_UNDEF' else None\\n self.resolved = False\\n self.resolvedby = None\\n if (claripy and isinstance(self.addr, claripy.ast.Base)) or self.addr != 0:\\n self.owner_obj.symbols_by_addr[self.addr] = self\\n # would be nice if we could populate demangled_names here...\\n\\n #demangled = self.demangled_name\\n #if demangled is not None:\\n # self.owner_obj.demangled_names[self.name] = demangled\",\n \"def get_base_symbol_set(self):\\n return self.__symbol_set[\\\"base\\\"]\",\n \"def __init__(self):\\n self.__dict__ = dict()\\n self.load()\",\n \"def _build_attributes(self):\\n\\n # We might rebuild the program because of snippets but we must\\n # keep already bound attributes\\n\\n dtype = []\\n for (name,gtype) in self.all_attributes:\\n if name not in self._attributes.keys():\\n attribute = Attribute(self, name, gtype)\\n else:\\n attribute = self._attributes[name]\\n\\n self._attributes[name] = attribute\\n dtype.append(attribute.dtype)\",\n \"def __init__(self, id, name, stat, base, boost):\\n super(BaseStation, self).__init__(id, name)\\n self.__stat = stat\\n self.__base = base\\n self.__boost = boost\",\n \"def __init__(self, *, base=None):\\n self._base = base\\n\\n self._map = {}\",\n \"def __init__(self, base_comp = None):\\n self._base_comp = base_comp\\n self._pragmas = set()\\n self._package_imports = set()\\n self._package_locations = set()\\n self._extra_deps = set()\\n self._module_imports = set()\\n self._actions = []\\n self._sources = []\\n self._var_names = set()\\n self._lazy_var_names = set()\\n self._ports = set()\\n self._transact_types = set()\\n self._add_defaults()\",\n \"def dottify(self, base_name):\\n obj_dict = vars(self)\\n dotted_dict = {}\\n for k, v in obj_dict.items():\\n if v is not None:\\n dotted_dict[base_name + '.' + k] = v\\n return dotted_dict\",\n \"def baseframe_context() -> t.Dict[str, t.Any]:\\n return {\\n 'networkbar_links': networkbar_links,\\n 'asset_path': asset_path,\\n }\",\n \"def common(self):\",\n \"def _add_attributes(self, this): # noqa: C901\\n for v in this.data_vars:\\n if \\\"TEMP\\\" in v and \\\"_QC\\\" not in v:\\n this[v].attrs = {\\n \\\"long_name\\\": \\\"SEA TEMPERATURE IN SITU ITS-90 SCALE\\\",\\n \\\"standard_name\\\": \\\"sea_water_temperature\\\",\\n \\\"units\\\": \\\"degree_Celsius\\\",\\n \\\"valid_min\\\": -2.0,\\n \\\"valid_max\\\": 40.0,\\n \\\"resolution\\\": 0.001,\\n }\\n if \\\"ERROR\\\" in v:\\n this[v].attrs[\\\"long_name\\\"] = (\\n \\\"ERROR IN %s\\\" % this[v].attrs[\\\"long_name\\\"]\\n )\\n\\n for v in this.data_vars:\\n if \\\"PSAL\\\" in v and \\\"_QC\\\" not in v:\\n this[v].attrs = {\\n \\\"long_name\\\": \\\"PRACTICAL SALINITY\\\",\\n \\\"standard_name\\\": \\\"sea_water_salinity\\\",\\n \\\"units\\\": \\\"psu\\\",\\n \\\"valid_min\\\": 0.0,\\n \\\"valid_max\\\": 43.0,\\n \\\"resolution\\\": 0.001,\\n }\\n if \\\"ERROR\\\" in v:\\n this[v].attrs[\\\"long_name\\\"] = (\\n \\\"ERROR IN %s\\\" % this[v].attrs[\\\"long_name\\\"]\\n )\\n\\n for v in this.data_vars:\\n if \\\"PRES\\\" in v and \\\"_QC\\\" not in v:\\n this[v].attrs = {\\n \\\"long_name\\\": \\\"Sea Pressure\\\",\\n \\\"standard_name\\\": \\\"sea_water_pressure\\\",\\n \\\"units\\\": \\\"decibar\\\",\\n \\\"valid_min\\\": 0.0,\\n \\\"valid_max\\\": 12000.0,\\n \\\"resolution\\\": 0.1,\\n \\\"axis\\\": \\\"Z\\\",\\n }\\n if \\\"ERROR\\\" in v:\\n this[v].attrs[\\\"long_name\\\"] = (\\n \\\"ERROR IN %s\\\" % this[v].attrs[\\\"long_name\\\"]\\n )\\n\\n for v in this.data_vars:\\n if \\\"DOXY\\\" in v and \\\"_QC\\\" not in v:\\n this[v].attrs = {\\n \\\"long_name\\\": \\\"Dissolved oxygen\\\",\\n \\\"standard_name\\\": \\\"moles_of_oxygen_per_unit_mass_in_sea_water\\\",\\n \\\"units\\\": \\\"micromole/kg\\\",\\n \\\"valid_min\\\": -5.0,\\n \\\"valid_max\\\": 600.0,\\n \\\"resolution\\\": 0.001,\\n }\\n if \\\"ERROR\\\" in v:\\n this[v].attrs[\\\"long_name\\\"] = (\\n \\\"ERROR IN %s\\\" % this[v].attrs[\\\"long_name\\\"]\\n )\\n\\n for v in this.data_vars:\\n if \\\"_QC\\\" in v:\\n attrs = {\\n \\\"long_name\\\": \\\"Global quality flag of %s profile\\\" % v,\\n \\\"convention\\\": \\\"Argo reference table 2a\\\",\\n }\\n this[v].attrs = attrs\\n\\n if \\\"CYCLE_NUMBER\\\" in this.data_vars:\\n this[\\\"CYCLE_NUMBER\\\"].attrs = {\\n \\\"long_name\\\": \\\"Float cycle number\\\",\\n \\\"convention\\\": \\\"0..N, 0 : launch cycle (if exists), 1 : first complete cycle\\\",\\n }\\n\\n if \\\"DATA_MODE\\\" in this.data_vars:\\n this[\\\"DATA_MODE\\\"].attrs = {\\n \\\"long_name\\\": \\\"Delayed mode or real time data\\\",\\n \\\"convention\\\": \\\"R : real time; D : delayed mode; A : real time with adjustment\\\",\\n }\\n\\n if \\\"DIRECTION\\\" in this.data_vars:\\n this[\\\"DIRECTION\\\"].attrs = {\\n \\\"long_name\\\": \\\"Direction of the station profiles\\\",\\n \\\"convention\\\": \\\"A: ascending profiles, D: descending profiles\\\",\\n }\\n\\n if \\\"PLATFORM_NUMBER\\\" in this.data_vars:\\n this[\\\"PLATFORM_NUMBER\\\"].attrs = {\\n \\\"long_name\\\": \\\"Float unique identifier\\\",\\n \\\"convention\\\": \\\"WMO float identifier : A9IIIII\\\",\\n }\\n\\n return this\",\n \"def initAttributes(self):\\n Packet.initAttributes(self)\\n self.packetType = TM_PACKET_TYPE\",\n \"def get_extra_attributes(self, device: str) -> dict:\\n raise NotImplementedError()\",\n \"def check_common_attrs(self, ast):\\n declarator = ast.declarator\\n attrs = declarator.attrs\\n meta = declarator.metaattrs\\n ntypemap = ast.typemap\\n is_ptr = declarator.is_indirect()\\n\\n # api\\n api = attrs[\\\"api\\\"]\\n if api is None:\\n pass\\n elif api not in [\\\"capi\\\", \\\"buf\\\", \\\"cfi\\\"]:\\n raise RuntimeError(\\n \\\"'api' attribute must 'capi', 'buf', or 'cfi'\\\"\\n )\\n else:\\n meta[\\\"api\\\"] = api\\n\\n # dimension\\n dimension = attrs[\\\"dimension\\\"]\\n rank = attrs[\\\"rank\\\"]\\n if rank:\\n if rank is True:\\n raise RuntimeError(\\n \\\"'rank' attribute must have an integer value\\\"\\n )\\n try:\\n attrs[\\\"rank\\\"] = int(attrs[\\\"rank\\\"])\\n except ValueError:\\n raise RuntimeError(\\n \\\"'rank' attribute must have an integer value, not '{}'\\\"\\n .format(attrs[\\\"rank\\\"])\\n )\\n if attrs[\\\"rank\\\"] > 7:\\n raise RuntimeError(\\n \\\"'rank' attribute must be 0-7, not '{}'\\\"\\n .format(attrs[\\\"rank\\\"])\\n )\\n if not is_ptr:\\n raise RuntimeError(\\n \\\"rank attribute can only be \\\"\\n \\\"used on pointer and references\\\"\\n )\\n if dimension:\\n if dimension is True:\\n raise RuntimeError(\\n \\\"dimension attribute must have a value.\\\"\\n )\\n if attrs[\\\"value\\\"]:\\n raise RuntimeError(\\n \\\"argument may not have 'value' and 'dimension' attribute.\\\"\\n )\\n if rank:\\n raise RuntimeError(\\n \\\"argument may not have 'rank' and 'dimension' attribute.\\\"\\n )\\n if not is_ptr:\\n raise RuntimeError(\\n \\\"dimension attribute can only be \\\"\\n \\\"used on pointer and references\\\"\\n )\\n elif ntypemap:\\n if ntypemap.base == \\\"vector\\\":\\n # default to 1-d assumed shape\\n attrs[\\\"rank\\\"] = 1\\n elif ntypemap.name == 'char' and is_ptr == 2:\\n # 'char **' -> CHARACTER(*) s(:)\\n attrs[\\\"rank\\\"] = 1\\n\\n owner = attrs[\\\"owner\\\"]\\n if owner is not None:\\n if owner not in [\\\"caller\\\", \\\"library\\\"]:\\n raise RuntimeError(\\n \\\"Illegal value '{}' for owner attribute. \\\"\\n \\\"Must be 'caller' or 'library'.\\\".format(owner)\\n )\\n\\n free_pattern = attrs[\\\"free_pattern\\\"]\\n if free_pattern is not None:\\n if free_pattern not in self.newlibrary.patterns:\\n raise RuntimeError(\\n \\\"Illegal value '{}' for free_pattern attribute. \\\"\\n \\\"Must be defined in patterns section.\\\".format(free_pattern)\\n )\",\n \"def extra_state_attributes(self):\\n return {attr: getattr(self, '_' + prop)\\n for attr, prop in ATTRIBUTES_IRHVAC.items()}\",\n \"def get_attr(self, key: str) -> Any:\\n raise NotImplementedError(\\\"This method should be implemented by \\\"\\n \\\"subclasses.\\\")\",\n \"def SavedGameLoad():\\n import saved_game\\n global attributes\\n attributes = {\\\"heroName\\\": saved_game.heroName, \\\"hp\\\": saved_game.hp, \\\"exp\\\": saved_game.exp, \\\"lvl\\\": saved_game.lvl,\\n \\\"strength\\\": saved_game.strength, \\\"mana\\\": saved_game.mana,\\n \\\"hpPotions\\\": saved_game.hpPotions, \\\"manaPotions\\\": saved_game.manaPotions,\\n \\\"weapon\\\": saved_game.weapon, \\\"weaponAtt\\\": saved_game.weaponAtt}\\n return(attributes)\",\n \"def _Attribute(self,t):\\n # Only a limited set of globals supported\\n func_dict = None\\n \\n # pyflamegpu singleton\\n if isinstance(t.value, ast.Name):\\n if t.value.id == \\\"pyflamegpu\\\":\\n if t.attr in self.fgpu_attrs:\\n # proceed\\n self.write(\\\"flamegpu::\\\")\\n self.write(t.attr)\\n else:\\n self.RaiseError(t, f\\\"Attribute '{t.attr}' does not exist in pyflamegpu object\\\")\\n # math functions (try them in raw function call format) or constants\\n elif t.value.id == \\\"math\\\":\\n if t.attr in self.mathconsts:\\n self.write(self.mathconsts[t.attr])\\n else:\\n self.RaiseError(t, f\\\"Unsupported math constant '{t.attr}'\\\")\\n # numpy types\\n elif t.value.id == \\\"numpy\\\" or t.value.id == \\\"np\\\":\\n # not sure how a numpy attribute would be used without function call or type hint but translate anyway \\n if t.attr in self.numpytypes:\\n self.write(self.numpytypes[t.attr])\\n else: \\n self.RaiseError(t, f\\\"Unsupported numpy type {t.attr}\\\")\\n else:\\n self.RaiseError(t, f\\\"Global '{t.value.id}' identifiers not supported\\\")\\n else:\\n self.RaiseError(t, \\\"Unsupported attribute\\\")\",\n \"def init_meta(self):\\n meta = {}\\n # Required (core)\\n meta['ra'] = dict(ext=0, card='OBJRA')\\n meta['dec'] = dict(ext=0, card='OBJDEC')\\n meta['target'] = dict(ext=0, card='OBJECT')\\n meta['decker'] = dict(ext=0, card='ALAPRTNM')\\n meta['binning'] = dict(card=None, compound=True)\\n\\n meta['mjd'] = dict(ext=0, card=None, compound=True)\\n meta['exptime'] = dict(ext=0, card='EXPTIME')\\n meta['airmass'] = dict(ext=0, card='AIRMASS')\\n # Extras for config and frametyping\\n meta['dispname'] = dict(ext=0, card='ALGRNM')\\n meta['idname'] = dict(ext=0, card='IMAGETYP')\\n # Lamps\\n # Use Keck/LRIS approach\\n\\n # Ingest\\n self.meta = meta\",\n \"def __get_common(attribute):\\n return common.API_COMMON_CONFIG[attribute]\",\n \"def __init__(self, cfg, tops_type=[3, 5, 10]):\\n\\n attr_cloth_file = open(cfg.attr_cloth_file).readlines()\\n self.attr_idx2name = {}\\n for i, line in enumerate(attr_cloth_file[2:]):\\n self.attr_idx2name[i] = line.strip('\\\\n').split()[0]\",\n \"def test_adding_attributes(self):\\n self.assertEqual(self.compound.get_attribute(\\\"What\\\"), \\\"Everything\\\")\",\n \"def get_attributes(self):\\n \\n retdict = {}\\n retdict['s'] = str(self.s)\\n if self.t != None:\\n retdict['t'] = str(self.t)\\n retdict['a'] = str(self.a)\\n retdict['b'] = str(self.b)\\n retdict['c'] = str(self.c)\\n retdict['d'] = str(self.d)\\n return retdict\",\n \"def __getattribute__(self, name: str) -> Any:\\n if name in (FLD_TITLE, FLD_ABSTRACT, FLD_FEES, FLD_ACCESS_CONSTRAINTS, FLD_CONTACT_POSITION, FLD_CONTACT_ORGANISATION):\\n return self.read_local_metadata(name)\\n elif name == FLD_KEYWORDS:\\n kw = self.read_local_metadata(FLD_KEYWORDS)\\n if kw:\\n return set(kw.split(\\\",\\\"))\\n else:\\n return set()\\n elif name == FLD_ATTRIBUTION:\\n return self.read_local_metadata(FLD_ATTRIBUTION)\\n else:\\n return super().__getattribute__(name)\",\n \"def load_data(self,do_print=True,keys_to_load=[]):\\n \\n if do_print:\\n print\\n print 'Loading corr_space data, Id = %s'%self.id\\n\\n\\n data= np.load(self.dataPath,mmap_mode='r')\\n \\n loaded_keys=[]\\n \\n if len(keys_to_load)==0:\\n for k,v in data.items():\\n setattr(self,k,v)\\n loaded_keys.append(k)\\n else: \\n for k in keys_to_load:\\n setattr(self,k,data[k])\\n loaded_keys.append(k)\\n\\n \\n if do_print:\\n print 'Loaded variables: '+' '.join(loaded_keys)\",\n \"def load_resource_map():\\n # to avoid a circular dependency\\n from coinbase_commerce.api_resources.base import APIResource\\n global RESOURCE_MAP\\n RESOURCE_MAP = {k.RESOURCE_NAME: k for k in APIResource.get_subclasses()\\n if getattr(k, \\\"RESOURCE_NAME\\\", None)}\",\n \"def test_attributes(self):\\n attributes = {}\\n header = BDFHeader.from_path(TestData.bdf_256)\\n\\n for key in BDFHeader.MAPPING.keys():\\n attributes[key] = getattr(header, key)\\n assert attributes == {\\n \\\"identification_code\\\": b\\\"\\\\xffBIOSEMI\\\",\\n \\\"subject_identification\\\": \\\"\\\",\\n \\\"local_recording_identification\\\": \\\"\\\",\\n \\\"start_date\\\": datetime.date(year=2001, month=11, day=5),\\n \\\"start_time\\\": time.strptime(\\n \\\"19:38:42\\\",\\n \\\"%H:%M:%S\\\",\\n ),\\n \\\"bytes_in_header\\\": 4608,\\n \\\"data_format_version\\\": \\\"24BIT\\\",\\n \\\"nb_data_records\\\": 60,\\n \\\"data_duration\\\": 1,\\n \\\"nb_channels\\\": 17,\\n \\\"channel_labels\\\": [\\n \\\"A1\\\",\\n \\\"A2\\\",\\n \\\"A3\\\",\\n \\\"A4\\\",\\n \\\"A5\\\",\\n \\\"A6\\\",\\n \\\"A7\\\",\\n \\\"A8\\\",\\n \\\"A9\\\",\\n \\\"A10\\\",\\n \\\"A11\\\",\\n \\\"A12\\\",\\n \\\"A13\\\",\\n \\\"A14\\\",\\n \\\"A15\\\",\\n \\\"A16\\\",\\n \\\"Status\\\",\\n ],\\n \\\"transducer_types\\\": [\\n \\\"ActiveElectrode,pintype\\\",\\n \\\"ActiveElectrode,pintype\\\",\\n \\\"ActiveElectrode,pintype\\\",\\n \\\"ActiveElectrode,pintype\\\",\\n \\\"ActiveElectrode,pintype\\\",\\n \\\"ActiveElectrode,pintype\\\",\\n \\\"ActiveElectrode,pintype\\\",\\n \\\"ActiveElectrode,pintype\\\",\\n \\\"ActiveElectrode,pintype\\\",\\n \\\"ActiveElectrode,pintype\\\",\\n \\\"ActiveElectrode,pintype\\\",\\n \\\"ActiveElectrode,pintype\\\",\\n \\\"ActiveElectrode,pintype\\\",\\n \\\"ActiveElectrode,pintype\\\",\\n \\\"ActiveElectrode,pintype\\\",\\n \\\"ActiveElectrode,pintype\\\",\\n \\\"TriggersandStatus\\\",\\n ],\\n \\\"dimensions\\\": [\\n \\\"uV\\\",\\n \\\"uV\\\",\\n \\\"uV\\\",\\n \\\"uV\\\",\\n \\\"uV\\\",\\n \\\"uV\\\",\\n \\\"uV\\\",\\n \\\"uV\\\",\\n \\\"uV\\\",\\n \\\"uV\\\",\\n \\\"uV\\\",\\n \\\"uV\\\",\\n \\\"uV\\\",\\n \\\"uV\\\",\\n \\\"uV\\\",\\n \\\"uV\\\",\\n \\\"Boolean\\\",\\n ],\\n \\\"min_dimensions\\\": [\\n -262144,\\n -262144,\\n -262144,\\n -262144,\\n -262144,\\n -262144,\\n -262144,\\n -262144,\\n -262144,\\n -262144,\\n -262144,\\n -262144,\\n -262144,\\n -262144,\\n -262144,\\n -262144,\\n -8388608,\\n ],\\n \\\"max_dimensions\\\": [\\n 262144,\\n 262144,\\n 262144,\\n 262144,\\n 262144,\\n 262144,\\n 262144,\\n 262144,\\n 262144,\\n 262144,\\n 262144,\\n 262144,\\n 262144,\\n 262144,\\n 262144,\\n 262144,\\n 8388607,\\n ],\\n \\\"min_digital\\\": [\\n -8388608,\\n -8388608,\\n -8388608,\\n -8388608,\\n -8388608,\\n -8388608,\\n -8388608,\\n -8388608,\\n -8388608,\\n -8388608,\\n -8388608,\\n -8388608,\\n -8388608,\\n -8388608,\\n -8388608,\\n -8388608,\\n -8388608,\\n ],\\n \\\"max_digital\\\": [\\n 8388607,\\n 8388607,\\n 8388607,\\n 8388607,\\n 8388607,\\n 8388607,\\n 8388607,\\n 8388607,\\n 8388607,\\n 8388607,\\n 8388607,\\n 8388607,\\n 8388607,\\n 8388607,\\n 8388607,\\n 8388607,\\n 8388607,\\n ],\\n \\\"prefiltering\\\": [\\n \\\"HP:DC;LP:113Hz\\\",\\n \\\"HP:DC;LP:113Hz\\\",\\n \\\"HP:DC;LP:113Hz\\\",\\n \\\"HP:DC;LP:113Hz\\\",\\n \\\"HP:DC;LP:113Hz\\\",\\n \\\"HP:DC;LP:113Hz\\\",\\n \\\"HP:DC;LP:113Hz\\\",\\n \\\"HP:DC;LP:113Hz\\\",\\n \\\"HP:DC;LP:113Hz\\\",\\n \\\"HP:DC;LP:113Hz\\\",\\n \\\"HP:DC;LP:113Hz\\\",\\n \\\"HP:DC;LP:113Hz\\\",\\n \\\"HP:DC;LP:113Hz\\\",\\n \\\"HP:DC;LP:113Hz\\\",\\n \\\"HP:DC;LP:113Hz\\\",\\n \\\"HP:DC;LP:113Hz\\\",\\n \\\"Nofiltering\\\",\\n ],\\n \\\"samples_per_record\\\": [\\n 256,\\n 256,\\n 256,\\n 256,\\n 256,\\n 256,\\n 256,\\n 256,\\n 256,\\n 256,\\n 256,\\n 256,\\n 256,\\n 256,\\n 256,\\n 256,\\n 256,\\n ],\\n \\\"reserved\\\": [\\n \\\"Reserved\\\",\\n \\\"Reserved\\\",\\n \\\"Reserved\\\",\\n \\\"Reserved\\\",\\n \\\"Reserved\\\",\\n \\\"Reserved\\\",\\n \\\"Reserved\\\",\\n \\\"Reserved\\\",\\n \\\"Reserved\\\",\\n \\\"Reserved\\\",\\n \\\"Reserved\\\",\\n \\\"Reserved\\\",\\n \\\"Reserved\\\",\\n \\\"Reserved\\\",\\n \\\"Reserved\\\",\\n \\\"Reserved\\\",\\n \\\"Reserved\\\",\\n ],\\n }\",\n \"def setSymbolProps(self, name, symbol):\\r\\n self.symbolProps = autosar.base.SymbolProps( str(name), str(symbol))\",\n \"def initSlotObjectDict(cls):\\n restslotattributedict.update(dict({extension_tunnel: \\\"name\\\"}))\\n restslotattributedict.update(dict({extension_circuit: \\\"name\\\"}))\\n restslotattributedict.update(dict({extension_ip_interface: \\\"name\\\"}))\\n restslotattributedict.update(dict({extension_ip_route: \\\"name\\\"}))\\n restslotattributedict.update(dict({gigabitethernet: \\\"name\\\"}))\\n restslotattributedict.update(dict({blade: \\\"slot_number\\\"}))\",\n \"def __getattribute__(self, name):\\n if name in ('_special_names', '__dict__'):\\n return super().__getattribute__(name)\\n if hasattr(self, '_special_names'):\\n if name in self._special_names:\\n raise AttributeError(\\n f\\\"{name} is a reserved variable name and it cannot be read\\\")\\n return super().__getattribute__(name)\",\n \"def _defineNAGlobals(self):\\n # Check if we should add to it with locally set rules\\n local_attributes = nappy.utils.getLocalAttributesConfigDict()\\n local_nc_atts = local_attributes[\\\"nc_attributes\\\"]\\n local_nc_to_na_map = nc_to_na_map.copy()\\n\\n for att, value in local_nc_atts.items():\\n if att not in local_nc_to_na_map:\\n local_nc_to_na_map[key] = value\\n\\n self.extra_comments = [[], [], []] # Normal comments, special comments, other comments\\n\\n for key, value in self.globals.items():\\n if key != \\\"first_valid_date_of_data\\\" and \\\\\\n type(value) not in (str, int, float):\\n continue\\n\\n # Loop through keys of header/comment items to map\\n if key in local_nc_to_na_map:\\n if key == \\\"history\\\":\\n time_string = time.strftime(\\\"%Y-%m-%d %H:%M:%S\\\", time.localtime(time.time()))\\n history = \\\"History: %s - Converted to NASA Ames format using nappy-%s.\\\\n %s\\\" % \\\\\\n (time_string, version, value)\\n history = history.split(\\\"\\\\n\\\") \\n self.history = []\\n\\n for h in history:\\n if h[:8] != \\\"History:\\\" and h[:1] != \\\" \\\": \\n h = \\\" \\\" + h\\n self.history.append(h) \\n \\n elif key == \\\"institution\\\":\\n # If fields came from NA then extract appropriate fields.\\n match = re.match(r\\\"(.*)\\\\s+\\\\(ONAME from NASA Ames file\\\\);\\\\s+(.*)\\\\s+\\\\(ORG from NASA Ames file\\\\)\\\\.\\\", \\n value)\\n if match:\\n self.na_dict[\\\"ONAME\\\"] = match.groups()[0]\\n self.na_dict[\\\"ORG\\\"] = match.groups()[1]\\n else:\\n self.na_dict[\\\"ONAME\\\"] = value\\n self.na_dict[\\\"ORG\\\"] = value\\n\\n # NOTE: should probably do the following search and replace on all string lines\\n self.na_dict[\\\"ONAME\\\"] = self.na_dict[\\\"ONAME\\\"].replace(\\\"\\\\n\\\", \\\" \\\")\\n self.na_dict[\\\"ORG\\\"] = self.na_dict[\\\"ORG\\\"].replace(\\\"\\\\n\\\", \\\" \\\")\\n\\n elif key == \\\"comment\\\":\\n # Need to work out if they are actually comments from NASA Ames in the first place\\n comment_lines = value.split(\\\"\\\\n\\\")\\n normal_comments = []\\n normal_comm_flag = None\\n\\n special_comments = []\\n special_comm_flag = None\\n\\n for line in comment_lines:\\n\\n if line.find(hp[\\\"sc_start\\\"]) > -1:\\n special_comm_flag = 1\\n elif line.find(hp[\\\"sc_end\\\"]) > -1:\\n special_comm_flag = None\\n elif line.find(hp[\\\"nc_start\\\"]) > -1:\\n normal_comm_flag = 1\\n elif line.find(hp[\\\"nc_end\\\"]) > -1:\\n normal_comm_flag = None\\n elif special_comm_flag == 1:\\n special_comments.append(line)\\n elif normal_comm_flag == 1:\\n normal_comments.append(line)\\n elif line.find(hp[\\\"data_next\\\"]) > -1:\\n pass\\n else:\\n normal_comments.append(line)\\n\\n # Carefully merge any comments with other metadata found.\\n other_special_comments, other_normal_comments, other_extra_comments = \\\\\\n [comms[:] for comms in self.extra_comments]\\n\\n self.extra_comments = [\\n other_special_comments + special_comments, \\n other_normal_comments + normal_comments, \\n other_extra_comments\\n ] \\n\\n elif key == \\\"first_valid_date_of_data\\\":\\n self.na_dict[\\\"DATE\\\"] = value\\n\\n elif key in (\\\"Conventions\\\", \\\"references\\\"):\\n self.extra_comments[2].append(f\\\"{key}: {value}\\\")\\n else:\\n self.na_dict[local_nc_to_na_map[key]] = value\\n else:\\n self.extra_comments[2].append(f\\\"{key}: {value}\\\")\",\n \"def _load_attrs(self) -> None:\\n self.attr_ids.clear()\\n for attr_label, attr_value in self.element.attr.items():\\n self.add_attr(None, attr_label, attr_value)\\n self._update_attr_list()\",\n \"def extract_request(self, attrs):\\n try:\\n _base = self.attributes()\\n _new_dict = {}\\n for key in attrs:\\n if key in _base:\\n _new_dict[key] = attrs[key]\\n return _new_dict\\n except Exception as e:\\n print(e)\",\n \"def test_get_attributes(self):\\n pass\",\n \"def __resolve_attribute(self, attr_dict):\\n result = dict()\\n for key in attr_dict:\\n attr = attr_dict[key]\\n if type(attr) is dict:\\n result[key] = self.__resolve_attribute(attr)\\n else:\\n result[key] = self._resolve_curly_braces(attr)\\n # resolve null key in curly brace values, such as \\\"${__NULL__,Online}\\\"\\n if key in NULL_VALUE_KEY_FIELDS and result[key] == NULL_VALUE_KEY:\\n result[key] = None\\n\\n for key in [GET_METHOD, SET_METHOD, GET_MBEAN_TYPE, SET_MBEAN_TYPE]:\\n if key in result and len(result[key]) == 0:\\n del result[key]\\n return result\",\n \"def __init__(self):\\n super(sppasSymbolSettings, self).__init__()\\n\\n self.__dict__ = dict(\\n unk=\\\"<UNK>\\\",\\n phone=sppasSymbolSettings.__phone_symbols(),\\n ortho=sppasSymbolSettings.__ortho_symbols(),\\n all=sppasSymbolSettings.__all_symbols()\\n )\",\n \"def _get_all_attributes(self) -> Dict[str, Any]:\\n all_attributes = self.__dict__.copy()\\n all_attributes.update(self.class_attributes)\\n return all_attributes\",\n \"def _convert_ext_attrs(self, ast):\\n self.ext_attrs = IDLExtAttrs(ast)\",\n \"def __symbolsHeader(self):\\n print \\\"Reading symbols header...\\\"\\n \\tif self.hdr.Version <= 8:\\n self.ocad.seek(48)\\n self.syhdr = Structure.read('TSymHeader', self.ocad)\\n #print \\\"TSymHeader: \\\", self.syhdr\",\n \"def test_get_attributes(test_common_dao):\\n _session = test_common_dao.RAMSTK_SESSION(\\n bind=test_common_dao.engine, autoflush=False, expire_on_commit=False)\\n DUT = _session.query(RAMSTKSiteInfo).first()\\n\\n assert DUT.get_attributes() == ATTRIBUTES\",\n \"def __init__(self):\\n super().__init__(self.__class__.__name__, 'BBEX3.D.XAU.USD.EA.AC.C04')\",\n \"def __init__(self):\\n super().__init__()\\n self.name = '' # name of this istance (alias)\\n self.type = type(self).__name__ # specific type within this class\\n self.verbosity = None # verbosity level (see message handler)\\n self.globalAttributes = {} # this is a dictionary that contains parameters that are set at the level of the base classes defining the types\\n self._knownAttribute = [] # this is a list of strings representing the allowed attribute in the xml input for the class\\n self._knownAttribute += ['name','verbosity'] # attributes that are known\\n self.printTag = 'BaseType' # the tag that refers to this class in all the specific printing\\n self.variableGroups = {} # the variables this class needs to be aware of\\n self.metadataKeys = set() # list of registered metadata keys to expect from this entity\\n self.metadataParams = {} # dictionary of registered metadata keys with repect to their indexes\",\n \"def fill_attributes(ml_file, other_file):\\n with xr.load_dataset(other_file) as other:\\n with xr.open_dataset(ml_file) as ml:\\n for variable in other.variables:\\n if variable in ml.variables:\\n other[variable].attrs = ml[variable].attrs\\n other.to_netcdf(other_file)\",\n \"def loadKeysAttributes(self):\\n\\t\\tif os.name == \\\"nt\\\" :\\n\\t\\t\\tself.keys_nb = [273,276,274,275,13,271,27,32,303,304,9,305,306,301,8,\\n\\t\\t\\t\\t49,50,51,52,53,54,55,56,57,48,45,61,\\n\\t\\t\\t\\t113,98,99,100,101,102,103,104,105,106,107,108,59,110,111,112,97,114,115,116,117,118,122,120,121,119]\\n\\t\\telse :\\n\\t\\t\\twarnings.warn(\\\"{} OS ins't supported for pygame kernel {}\\\".format(os.name, __version__),Warning)\\n\\t\\t\\tself.keys_nb = []\\n\\t\\tself.keys_name = [\\\"UpARR\\\",\\\"LeftARR\\\",\\\"DownARR\\\",\\\"RightARR\\\",\\\"Enter\\\",\\\"ENTER\\\",\\\"esc\\\",\\\" \\\",\\\"Maj\\\",\\\"Maj\\\",\\\"Tab\\\",\\\"ctrl\\\",\\\"ctrl\\\",\\\"VerrMaj\\\",\\\"Backspace\\\",\\n\\t\\t\\t\\\"&\\\",\\\"é\\\",\\\"\\\\\\\"\\\",\\\"\\\\'\\\",\\\"(\\\",\\\"-\\\",\\\"è\\\",\\\"_\\\",\\\"ç\\\",\\\"à\\\",\\\")\\\",\\\"=\\\",\\n\\t\\t\\t\\\"a\\\",\\\"b\\\",\\\"c\\\",\\\"d\\\",\\\"e\\\",\\\"f\\\",\\\"g\\\",\\\"h\\\",\\\"i\\\",\\\"j\\\",\\\"k\\\",\\\"l\\\",\\\"m\\\",\\\"n\\\",\\\"o\\\",\\\"p\\\",\\\"q\\\",\\\"r\\\",\\\"s\\\",\\\"t\\\",\\\"u\\\",\\\"v\\\",\\\"w\\\",\\\"x\\\",\\\"y\\\",\\\"z\\\"]\",\n \"def __config_attributes(self):\\n self.__name = self.__data[self.__code][\\\"airportName\\\"]\\n self.__country = Country(name=self.__data[self.__code][\\\"countryName\\\"],\\n code=self.__data[self.__code][\\\"countryCode\\\"])\\n try:\\n self.__city = self.__data[self.__code][\\\"city\\\"]\\n except Exception:\\n self.__city = ''\",\n \"def init_meta(self):\\n meta = {}\\n # Required (core)\\n meta['ra'] = dict(ext=1, card='RA')\\n meta['dec'] = dict(ext=1, card='DEC')\\n meta['target'] = dict(ext=1, card='OBJECT')\\n meta['decker'] = dict(ext=1, card='APERTURE')\\n meta['dichroic'] = dict(ext=1, card='FILTER')\\n meta['binning'] = dict(ext=1, card=None, default='1,1')\\n\\n meta['mjd'] = dict(ext=0, card=None, compound=True)\\n meta['exptime'] = dict(ext=1, card='EXPTIME')\\n meta['airmass'] = dict(ext=1, card='AIRMASS')\\n # Extras for config and frametyping\\n meta['dispname'] = dict(ext=1, card='DISPERSE')\\n meta['idname'] = dict(ext=1, card='IMAGETYP')\\n\\n # Ingest\\n self.meta = meta\",\n \"def _derive_extra_metadata(self, extra_metadata):\\n extra_metadata['platform']['Family'] = extra_metadata['platform']['Platform Family Name']\\n\\n # Add platform number if derivable from file\\n if self.__class__ is not SAFESentinel1:\\n extra_metadata['platform']['Family'] += \\\"-%s\\\" % extra_metadata['platform']['Platform Number']\",\n \"def __init__(self):\\r\\n self.s_table = SymbolTable.preSymbols\",\n \"def extra_state_attributes(self) -> dict[str, Any]:\\n ret = {\\n ATTR_SOURCE: self._source_entity_id,\\n ATTR_COEFFICIENTS: self._coefficients,\\n }\\n if self._source_attribute:\\n ret[ATTR_SOURCE_ATTRIBUTE] = self._source_attribute\\n return ret\",\n \"def rawbase_meta(self, rawbase_name):\\n url = \\\"%s/rawbase/%s\\\" % (self.api, rawbase_name)\\n return self.__get_request(url, 5)\",\n \"def _get_asset(self, symbol):\\n if symbol == \\\"BEX\\\":\\n return {\\\"symbol\\\": \\\"BEX\\\",\\n \\\"precision\\\": 3\\n }\\n elif symbol == \\\"BBD\\\":\\n return {\\\"symbol\\\": \\\"BBD\\\",\\n \\\"precision\\\": 3\\n }\\n elif symbol == \\\"VESTS\\\":\\n return {\\\"symbol\\\": \\\"VESTS\\\",\\n \\\"precision\\\": 6\\n }\\n else:\\n return None\",\n \"def dict(self) -> dict():\\n\\n dict_reg_hive = {}\\n\\n for _attribute in self.attributes.__dict__.items():\\n if isinstance(_attribute[1], str):\\n if not True in [_attribute[1].startswith(prefix) for prefix in ['<', 'providers.', 'None']]:\\n _attribute_value = getattr(self, _attribute[1])\\n dict_reg_hive.update({_attribute[1]: _attribute_value})\\n\\n return dict_reg_hive\",\n \"def test_baseclass_attrs_type(self):\\n\\n base_class = BaseModel()\\n cn = base_class.__class__.__name__\\n idn = base_class.id\\n attrs = base_class.__dict__\\n\\n self.assertTrue(type(cn), str)\\n self.assertTrue(type(id), str)\\n self.assertDictEqual(attrs, base_class.__dict__)\",\n \"def initAttributes(self):\\n Packet.initAttributes(self)\\n self.packetType = TC_PACKET_TYPE\",\n \"def extra_state_attributes(self):\\n state_attr = {}\\n if self.vendor_id is not None:\\n state_attr[ATTR_VENDOR_ID] = self.vendor_id\\n state_attr[ATTR_VENDOR_NAME] = self.vendor_name\\n if self.type_id is not None:\\n state_attr[ATTR_TYPE_ID] = self.type_id\\n state_attr[ATTR_TYPE] = self.type\\n if self.physical_address is not None:\\n state_attr[ATTR_PHYSICAL_ADDRESS] = self.physical_address\\n return state_attr\",\n \"def load_general_props(self):\\n\\n # load general and shared header.properties file from zipfile\\n root = ForceArchive(self.file_path).read_properties('header.properties')\\n shared = ForceArchive(self.file_path).read_properties('shared-data/header.properties')\\n full = {}\\n full.update(root)\\n full.update(shared)\\n return full\",\n \"def build_base(self):\\n\\n # start- and endpoints of lines are nodes, but they do not need to have a point object associated to them\\n # in this case, self.geo is None and the no, prop and name attributes stay as the default values set in the constructor\\n if (self.geo):\\n\\n attr = ri.RhinoInput(rs.ObjectName(self.geo))\\n\\n self.no = attr.get_no()\\n if (self.no != -1):\\n self.strict_naming = True\\n\\n self.name = attr.get_name()\\n self.prop = attr.get_prop()\",\n \"def load(self, key):\\n return self.load_attrs().get(key)\",\n \"def extra_state_attributes(self):\\n attr = {}\\n #attr[\\\"name\\\"] = self._visonic_device.getDeviceName()\\n attr[PANEL_ATTRIBUTE_NAME] = self._panel\\n attr[DEVICE_ATTRIBUTE_NAME] = self._visonic_device.getDeviceID()\\n return attr\",\n \"def extra_state_attributes(self) -> dict[str, Any] | None:\\n # Different measuring stations have different sets of sensors. We don't know\\n # what data we will get.\\n for sensor in SENSOR_MAP:\\n if sensor in self.coordinator.data:\\n self._attrs[f\\\"{SENSOR_MAP[sensor]}_index\\\"] = self.coordinator.data[\\n sensor\\n ][\\\"index\\\"]\\n self._attrs[ATTR_STATION] = self.coordinator.gios.station_name\\n return self._attrs\",\n \"def __getattribute__(self, name):\\n try:\\n return self.gps.__getattribute__(name) \\n except:\\n return super().__getattribute__(name)\",\n \"def get_label_dict(base):\\n label_dict = copy.deepcopy(labelDict)\\n symbol = None\\n if base.rendererType == \\\"gdb\\\":\\n symbol = LabelRenderer.get_gdb_symbol(base.arcLayer)\\n annotation_class_id = LabelRenderer.get_annotation_class_id(base.arcLayer)\\n\\n label_dict['labelValues']['type'] = 'rule-based'\\n label_dict['labelValues']['classId'] = str(annotation_class_id)\\n label_dict['labelValues']['text-style']['fieldName'] = 'TextString'\\n elif base.rendererType == \\\"feature\\\":\\n symbol = LabelRenderer.specify_feature_content(base.arcLayer, label_dict)\\n\\n formatted_symbol = change_interface(symbol, ArcGisModules.module_display.IFormattedTextSymbol)\\n\\n LabelRenderer.get_text_style(formatted_symbol, label_dict)\\n LabelRenderer.get_background(formatted_symbol, label_dict)\\n\\n return label_dict\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61585546","0.6084663","0.6044661","0.5943379","0.5886491","0.5802792","0.57020926","0.5637599","0.56372637","0.56197745","0.56000906","0.55648845","0.5503462","0.5496226","0.5459958","0.5452533","0.54436445","0.5441584","0.54250926","0.540444","0.5394743","0.53632957","0.5361788","0.5352002","0.5349226","0.5338503","0.53308356","0.53302443","0.5311954","0.5304827","0.5299757","0.52975476","0.5253236","0.5223787","0.5216127","0.51820844","0.5163946","0.5158469","0.51574177","0.5155203","0.5143112","0.51428705","0.51345724","0.51296663","0.51269925","0.5109635","0.5108941","0.5081862","0.507556","0.50570667","0.5052723","0.5042283","0.50420356","0.5041691","0.5037655","0.50374234","0.5033925","0.5027062","0.50264186","0.5023731","0.50223416","0.50116026","0.50041157","0.49967855","0.49902746","0.49868613","0.49836025","0.4979468","0.49785593","0.49705532","0.49684483","0.496573","0.49639264","0.49621785","0.49531516","0.49501532","0.4942304","0.49415627","0.49405673","0.49403742","0.4938263","0.49309453","0.4926857","0.4925054","0.4921282","0.49200884","0.4903715","0.49032372","0.4899629","0.48963678","0.48961708","0.48891357","0.48857155","0.48838347","0.4882688","0.48805314","0.4871301","0.48710132","0.4869443","0.48644173"],"string":"[\n \"0.61585546\",\n \"0.6084663\",\n \"0.6044661\",\n \"0.5943379\",\n \"0.5886491\",\n \"0.5802792\",\n \"0.57020926\",\n \"0.5637599\",\n \"0.56372637\",\n \"0.56197745\",\n \"0.56000906\",\n \"0.55648845\",\n \"0.5503462\",\n \"0.5496226\",\n \"0.5459958\",\n \"0.5452533\",\n \"0.54436445\",\n \"0.5441584\",\n \"0.54250926\",\n \"0.540444\",\n \"0.5394743\",\n \"0.53632957\",\n \"0.5361788\",\n \"0.5352002\",\n \"0.5349226\",\n \"0.5338503\",\n \"0.53308356\",\n \"0.53302443\",\n \"0.5311954\",\n \"0.5304827\",\n \"0.5299757\",\n \"0.52975476\",\n \"0.5253236\",\n \"0.5223787\",\n \"0.5216127\",\n \"0.51820844\",\n \"0.5163946\",\n \"0.5158469\",\n \"0.51574177\",\n \"0.5155203\",\n \"0.5143112\",\n \"0.51428705\",\n \"0.51345724\",\n \"0.51296663\",\n \"0.51269925\",\n \"0.5109635\",\n \"0.5108941\",\n \"0.5081862\",\n \"0.507556\",\n \"0.50570667\",\n \"0.5052723\",\n \"0.5042283\",\n \"0.50420356\",\n \"0.5041691\",\n \"0.5037655\",\n \"0.50374234\",\n \"0.5033925\",\n \"0.5027062\",\n \"0.50264186\",\n \"0.5023731\",\n \"0.50223416\",\n \"0.50116026\",\n \"0.50041157\",\n \"0.49967855\",\n \"0.49902746\",\n \"0.49868613\",\n \"0.49836025\",\n \"0.4979468\",\n \"0.49785593\",\n \"0.49705532\",\n \"0.49684483\",\n \"0.496573\",\n \"0.49639264\",\n \"0.49621785\",\n \"0.49531516\",\n \"0.49501532\",\n \"0.4942304\",\n \"0.49415627\",\n \"0.49405673\",\n \"0.49403742\",\n \"0.4938263\",\n \"0.49309453\",\n \"0.4926857\",\n \"0.4925054\",\n \"0.4921282\",\n \"0.49200884\",\n \"0.4903715\",\n \"0.49032372\",\n \"0.4899629\",\n \"0.48963678\",\n \"0.48961708\",\n \"0.48891357\",\n \"0.48857155\",\n \"0.48838347\",\n \"0.4882688\",\n \"0.48805314\",\n \"0.4871301\",\n \"0.48710132\",\n \"0.4869443\",\n \"0.48644173\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6953629"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":15194,"cells":{"query":{"kind":"string","value":"Return orders of nodes ipa_ref_list references"},"document":{"kind":"string","value":"def gather_references_orders (gdbval):\n# TODO: Somehow also note speculative references and attributes in\n# general\n vec = gdbval[\"references\"]\n return [int(i[\"referred\"][\"order\"]) for i in vec_iter(vec)]"},"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 gather_referring_orders (gdbval):\n# TODO: Somehow also note speculative references and attributes in\n# general\n vec = gdbval[\"referring\"]\n return [int(i[\"referring\"][\"order\"]) for i in vec_iter(vec)]","def angle_sort_adjacent_nodes(self,n,ref_nbr=None):\n nbrs=self.node_to_nodes(n)\n if len(nbrs)==0:\n return []\n diffs=self.nodes['x'][nbrs] - self.nodes['x'][n]\n angles=np.arctan2(diffs[:,1],diffs[:,0])\n nbrs=nbrs[np.argsort(angles)]\n if ref_nbr is not None: \n i=list(nbrs).index(ref_nbr)\n nbrs=np.roll(nbrs,-i)\n return nbrs","def _sorting(self, notsorted_list, predecessors):\n remaining_nodes = []\n sorted_part = []\n for nd in notsorted_list:\n if not predecessors[nd.name]:\n sorted_part.append(nd)\n else:\n remaining_nodes.append(nd)\n return sorted_part, remaining_nodes","def dmc_order(self):\n return sorted(self.lookup_table, key=lambda clr: int(clr.id) if clr.id.isdigit() else 0)","def reference_nodes_idx(self) -> Dict[str, torch.Tensor]:\n return self.node_idx_references","def nodes_in_topological_order(self):\n if not self.sorted:\n self._topological_sort()\n return self._topological_order","def _sort_ns(self):\n n = []\n for layer in self.structure:\n n.append(layer.get_index())\n n = np.asarray(n)\n return n","def rootSetOrder (self):\n order = []\n nodes = set(self.__nodes)\n edge_map = {}\n for (d, srcs) in six.iteritems(self.__edgeMap):\n edge_map[d] = srcs.copy()\n while nodes:\n freeset = set()\n for n in nodes:\n if not (n in edge_map):\n freeset.add(n)\n if 0 == len(freeset):\n _log.error('dependency cycle in named components')\n return None\n order.append(freeset)\n nodes.difference_update(freeset)\n new_edge_map = {}\n for (d, srcs) in six.iteritems(edge_map):\n srcs.difference_update(freeset)\n if 0 != len(srcs):\n new_edge_map[d] = srcs\n edge_map = new_edge_map\n return order","def toposorted(self):\n order = []\n colors = {node: \"white\" for node in self._neighbors}\n\n def visit(node):\n assert colors[node] == \"white\"\n colors[node] = \"gray\"\n for neighbor in self._neighbors[node]:\n if colors[neighbor] == \"white\":\n visit(neighbor)\n elif colors[neighbor] == \"gray\":\n raise CyclicGraphError(\n \"Cycle involving {!r} and {!r} detected\".format(node, neighbor)\n )\n order.append(node)\n colors[node] = \"black\"\n\n for node in self._neighbors:\n if colors[node] == \"white\":\n visit(node)\n return order","def references(self):\n ref_nodes = self.root.xpath(\".//bib-reference\")\n return list(\n itertools.chain.from_iterable(\n self.get_reference_iter(node) for node in ref_nodes\n )\n )","def referencing_nodes(self):\n\n return self._referencing_nodes","def _refind_nodes(self, reSearchItems, root=None, sortByDepth=False):\n\n reListOfSearchItems = list(reSearchItems)\n\n if root == None:\n ReParent = reListOfSearchItems.pop(0)\n Out = [x for x in self.ParentMap.keys() if ReParent.match(x.tag)]\n\n else:\n Out = [root]\n\n\n while len(reListOfSearchItems) > 0:\n ReParent = reListOfSearchItems.pop(0)\n Out = [x for root in Out for x in root.iter() if ReParent.match(x.tag)]\n\n if sortByDepth == False: return Out\n\n TDict = dict((x, len(self.get_path_to_node(x))) for x in Out)\n return [o[0] for o in sorted(TDict.items(),key=lambda x:x[1])]","def sorted_nodes_list(self):\r\n full_sorted_node_list = map(lambda k: k[0], sorted(self.graph.degree(),\r\n key=lambda k: k[1], reverse=True))\r\n return full_sorted_node_list","def list_of_all_nodes_pointing_to_ref( s, ref ):\n results = []\n for node in s.nodes.values():\n nodetype = sortof_type_str_of(node) \n if nodetype == \"LIST\":\n if ref in node:\n results.append(node)\n elif nodetype == \"DICT\":\n if ref in node.values():\n results.append(node)\n return results","def order(self):\n return len(self._nodes)","def order(self, searcher, docnums, reverse = False):\n return docnums","def reorder(name_list, ref_list):\n result = []\n # Use the ordering in ref_list, to reassemble the name list:\n for name in ref_list:\n # These always come at the end\n if name in ['FTP', 'RSYNC']:\n continue\n if name in name_list:\n result.append(name)\n # For any that were not in the reference list and are left over, tack\n # them on to the end:\n for name in name_list:\n if name not in ref_list:\n result.append(name)\n # Finally, add these, so they are at the very end\n for name in ref_list:\n if name in name_list and name in ['FTP', 'RSYNC']:\n result.append(name)\n \n # Make sure I have the same number I started with\n assert(len(name_list) == len(result))\n return result","def list_refs(self):\n pass","def get_ordered_ids(tree):\n ordered_ids = []\n ordered_ids.extend(id(node) for node in tree.gen_tips())\n ordered_ids.extend(id(node) for node in tree.gen_internal_nodes())\n return ordered_ids","def get_reference_node_parents(ref):\n parents = []\n return parents","def sequence_elements(self):\n seq_model = self.opt_model.seq_model\n self.elements.sort(key=lambda e:\n seq_model.ifcs.index(e.reference_interface()))","def list_ref_keys(self):\n print('=======')\n print('REFs')\n print('=======')\n for key in self.refs:\n print(key)","def dependents(sent,head): # head: node address\n return sorted(chain.from_iterable(sent.nodes[head]\\\n ['deps'].values()))","def reorder_links(self, previous_node, links): # pragma: no cover\n\t\treturn links","def find_topo_sort(node_list):\r\n visited = set()\r\n topo_order = []\r\n #print(node_list)\r\n for node in node_list:\r\n topo_sort_dfs(node, visited, topo_order)\r\n return topo_order","def degeneracy_ordering(self):\n return sorted(self._adjacency_map, key=self.degree)","def depends_on(self, node):\n return sorted(self.__edge_map[node], key=node_key)","def get_ordered_nodes(self):\n nodes = []\n self.build_nodes_list(self.root, nodes)\n return nodes","def sorted_nodes(self):\n if self._sorted_nodes is None:\n self.sorting()\n return self._sorted_nodes","def toposort(adj):\n # Memoize for visited vertex\n used = [0] * len(adj)\n order = []\n # write your code here\n # Traverse through each vertex\n for i in range(len(adj)):\n if not used[i]:\n # If not visited, run dfs\n dfs(adj, used, order, i)\n\n # Reverse the order list to show in descending order\n order.reverse()\n return order","def list_refs(self):\n print('----\\nREFs\\n----')\n self._print_dict(self.refs)","def references(self):\n return tuple(self.__references)","def nodes(self):\n data = list(self._nodes.values())\n data.sort()\n return data","def _topological_sort(self):\n\n visited = defaultdict(bool)\n stack = []\n\n for pod in self.pods:\n if not visited[pod]:\n self._topological_sort_pod(pod, visited, stack)\n\n return stack[::-1]","def sort_nodes(center_node, nodes):\n def cmp(n1, n2):\n angle1 = (math.degrees(center_node.angle_to(n1)) + 360.) % 360\n angle2 = (math.degrees(center_node.angle_to(n2)) + 360.) % 360\n\n if angle1 < angle2:\n return -1\n elif angle1 == angle2:\n return 0\n else:\n return 1\n return sorted(nodes, cmp=cmp)","def references(self):\n return self.header('References', '').split()","def sorted_nodes_names(self):\n return [nd.name for nd in self._sorted_nodes]","def order(self):\n pairs = [(w['source'][0], w['target'][0]) for w in self.wires]\n return processing_order(len(self.modules), pairs)","def getSortedCyclicDependencies(self):\n res = []\n if self.isCircular():\n res = [self.identifier if self.originalId is None else self.originalId]\n # fill node inputs\n nn = 0\n while nn < len(res):\n _node = res[nn]\n for _inputId in self.model.getNode(_node).ioEngine.inputs:\n input_node = self.model.getNode(_inputId)\n if not _inputId in res and input_node.isCircular():\n # check if node is in circle of _inputId\n if _node in input_node.getFullInputs():\n res.append(_inputId)\n nn += 1\n return res","def toposorted(resources):\n # sort resources first so we have a deterministic order of nodes with the same partial order\n resources = sorted(\n resources,\n key=lambda resource: (resource.type, resource.id),\n )\n\n # build incoming and outgoing edges\n nodes = {\n resource.uri\n for resource in resources\n }\n\n incoming = defaultdict(set)\n outgoing = defaultdict(set)\n for resource in resources:\n for parent in resource.parents:\n if parent not in nodes:\n # ignore references that lead outside of the current graph\n continue\n incoming[resource.uri].add(parent)\n outgoing[parent].add(resource.uri)\n\n results = []\n while resources:\n remaining = []\n for resource in resources:\n if incoming[resource.uri]:\n # node still has incoming edges\n remaining.append(resource)\n continue\n\n results.append(resource)\n for child in outgoing[resource.uri]:\n incoming[child].remove(resource.uri)\n\n if len(resources) == len(remaining):\n raise Exception(\"Cycle detected\")\n resources = remaining\n\n return results","def referenced_nodes(self):\n return self._referenced_nodes","def find_topo_sort(node_list):\n visited = set()\n topo_order = []\n for node in node_list:\n topo_sort_dfs(node, visited, topo_order)\n return topo_order","def find_topo_sort(node_list):\n visited = set()\n topo_order = []\n for node in node_list:\n topo_sort_dfs(node, visited, topo_order)\n return topo_order","def get_compute_order(graph_def, input_node_name='', input_node_size=None):\n name_to_node = parse_graph_nodes(graph_def)\n node_info = collections.defaultdict(_node_info)\n for each in graph_def.node:\n _get_computed_nodes(name_to_node, each.name, node_info, input_node_name,\n input_node_size)\n return node_info, name_to_node","def ordering(self):\n value = []\n for i in self:\n if isinstance(i, PQ):\n value.extend(i.ordering())\n else:\n value.append(i)\n\n return value","def references_list( self, theWeaver ):\n return [ (c.name, c.seq) \n for c in theWeaver.reference_style.chunkReferencedBy( self ) ]","def findTopologicalOrder(self):\n # This implementation temporarily messes with reverse stars, must fix at end\n numOrderedNodes = 0\n while numOrderedNodes < self.numNodes:\n nextNode = self.findLeastEnteringLinks()\n if len(self.node[nextNode].reverseStar) > 0:\n print(\"Error: Network given to findTopologicalOrder contains a cycle.\")\n raise BadNetworkOperationException\n numOrderedNodes += 1\n self.node[nextNode].order = numOrderedNodes\n self.node[nextNode].reverseStar = [0] * self.numLinks\n for ij in self.node[nextNode].forwardStar:\n self.node[self.link[ij].head].reverseStar.remove(ij)\n \n # Repopulate reverse star list\n for i in self.node:\n self.node[i].reverseStar = list()\n for ij in self.link:\n self.node[self.link[ij].head].reverseStar.append(ij)","def _update_ordering(self):\n self._descendants = sorted(self.unordered_descendants(), key=lambda node: node.ord)\n for (new_ord, node) in enumerate(self._descendants, 1):\n node.ord = new_ord","def nreferences(self):\n return self.__nreferences","def calc_ply_order(constraints, targets):\r\n if constraints.sym:\r\n ply_order = np.arange(targets.n_plies // 2 + targets.n_plies % 2)\r\n return ply_order\r\n\r\n order_before_sorting = np.arange(targets.n_plies)\r\n ply_order = np.zeros((targets.n_plies,), int)\r\n ply_order[0::2] = order_before_sorting[\r\n :targets.n_plies // 2 + targets.n_plies % 2]\r\n ply_order[1::2] = order_before_sorting[\r\n targets.n_plies // 2 + targets.n_plies % 2:][::-1]\r\n return ply_order","def order_bfs(self) -> List[Nodo]:\n\n # Nodos por buscar, es una cola\n pending: List[Nodo] = [self.root]\n # Nodos ya visitados\n visited: List[Nodo] = []\n\n # Mientras la cola tenga items\n while len(pending) > 0:\n # Procesar el primer elemento\n curr = pending.pop(0)\n visited.append(curr)\n\n # Agregar los hijos no visitados del nodo a la cola\n for child in curr.children:\n if child in visited:\n continue\n pending.append(child)\n\n return visited","def orderings(self, function_graph):\r\n return OrderedDict()","def depth_node_ordering(start_node, end_nodes):\n ordered_list = []\n ordered_set = set()\n working_list = [start_node]\n while working_list != []:\n node = working_list.pop(0)\n if not node in ordered_set:\n ordered_set.add(node)\n ordered_list.append(node)\n if not is_leaf_node(node) and not node in end_nodes:\n for node_op in node.get_inputs():\n working_list.append(node_op)\n return ordered_list","def _reltype_ordering(self):\n return self.__reltype_ordering","def _order_entities(self):\n entity_deps = defaultdict(set)\n for e, features in self.top_level_features.items():\n # iterate over all dependency features of the top-level features on\n # this entity. If any of these are themselves top-level features, add\n # their entities as dependencies of the current entity.\n deps = {g.hash(): g for f in features\n for g in self.feature_dependencies[f.hash()]}\n for d in deps.values():\n _, num_forward = self.entityset.find_path(e, d.entity.id,\n include_num_forward=True)\n if num_forward > 0:\n entity_deps[e].add(d.entity.id)\n\n # Do a top-sort on the new entity DAG\n self.ordered_entities = utils.topsort([self.target_eid],\n lambda e: entity_deps[e])","def order_dfs(self) -> List[Nodo]:\n # Nodos por buscar, es una pila\n pending: List[Nodo] = [self.root]\n # Nodos ya visitados\n visited: List[Nodo] = []\n\n # Mientras la pila tenga items\n while len(pending) > 0:\n # Procesar el primer elemento\n curr = pending.pop()\n visited.append(curr)\n\n # Agregar los hijos no visitados del nodo a la pila\n for child in reversed(curr.children):\n if child in visited:\n continue\n pending.append(child)\n\n return visited","def listOrdering(self):\r\n index = 0\r\n while( index < len(self.sortedList)-1):\r\n if(self.sortedList[index][2] > self.sortedList[index+1][2]): # positions in wrong order\r\n self.sortedList[index], self.sortedList[index+1] = self.sortedList[index+1], self.sortedList[index] # switch\r\n if(self.sortedList[index][2] == self.sortedList[index+1][2]): # Position conflict\r\n if(self.sortedList[index][1] <= self.sortedList[index+1][1]): # Already ordered by id\r\n self.sortedList[index+1][2] += 1 # position altered for second rule\r\n else:\r\n self.sortedList[index][2] += 1\r\n self.sortedList[index], self.sortedList[index+1] = self.sortedList[index+1], self.sortedList[index] # switch\r\n index += 1","def sort_decls(self):\n\n #import simplecssbuilder\n #SHORTHAND_REL = simplecssbuilder.SHORTHAND_REL\n\n def decl_key(decl):\n \"\"\"key for sorting declarations\"\"\"\n prop = decl.split(':')[0] # get property name\n if str(prop) in SHORTHAND_REL_inv:\n return SHORTHAND_REL_inv[str(prop)]\n else:\n return str(prop)\n\n def sort_decls_clique(clique):\n \"\"\"Sort the declarations in clique\"\"\"\n (_,ps) = clique\n ps.sort(key=decl_key)\n\n # compute the inverse of SHORTHAND_REL\n SHORTHAND_REL_inv = dict()\n for k,vs in SHORTHAND_REL.iteritems():\n for v in vs:\n SHORTHAND_REL_inv[v] = k\n\n #print 'PRINTING CLIQUES'\n for clique in self.cliques:\n #print clique\n sort_decls_clique(clique)\n #print clique","def toposorted(infos):\n key_to_info = {}\n depends = {}\n for info in infos:\n key_to_info[info.key] = info\n depends[info.key] = []\n for info in infos:\n for after in info.after:\n after_info = key_to_info[after]\n depends[info.key].append(after_info)\n for before in info.before:\n before_info = key_to_info[before]\n depends[before_info.key].append(info)\n return topological_sort(infos, lambda info: depends[info.key])","def enlist(self):\r\n list = self.enlist_helper(self.top_node)\r\n list.sort()\r\n return list","def order_nodes(tree, increase=True):\n res = tree.copy()\n for node in res.postorder():\n if node.is_tip():\n node.n = 1\n else:\n node.n = sum(x.n for x in node.children)\n for node in res.postorder():\n if not node.is_tip():\n children = node.children\n node.children = []\n for child in sorted(children, key=lambda x: x.n, reverse=increase):\n node.append(child)\n for node in res.postorder():\n delattr(node, 'n')\n return res","def get_order_from_tree(ids, tree_text):\r\n tree = parse_newick(tree_text, PhyloNode)\r\n ordered_ids = []\r\n for tip in tree.iterTips():\r\n if tip.Name in ids:\r\n ordered_ids.append(tip.Name)\r\n return names_to_indices(ids, ordered_ids)","def sort_nodes_by_n_reachable(graph):\n list_of_node_and_reachables_tups = [] # stores the number of reachable nodes per node\n # The following for loop finds the number of reachable nodes per node\n for node_to_test in graph.nodes:\n n_reachable = 0\n # The following for loop checks each node if it is reachable from node_to_test. If so, adds to the counter\n for node_is_reachable in graph.nodes:\n if graph.is_reachable(node_to_test, node_is_reachable) and node_to_test != node_is_reachable:\n n_reachable += 1\n # Adds a tuple with the node_to_test and the counter of reachable nodes\n list_of_node_and_reachables_tups.append((node_to_test, n_reachable))\n # At this point we have a list with tuples including the node name and its reachables. Now need to sort them\n sorted_nodes_by_reachable = sorted(list_of_node_and_reachables_tups, key=lambda tup: tup[1], reverse=True)\n return sorted_nodes_by_reachable","def part_build_order(self):\n priority = []\n for geo_item in self.build_order:\n if geo_item in self.parts:\n priority += [geo_item]\n return priority","def test_get_adjacency_list(self):\n atom_features = np.array([[40, 41, 42, 43], [44, 45, 46, 47],\n [48, 49, 50, 51], [52, 53, 54, 55],\n [56, 57, 58, 59]])\n canon_adj_list = [[1, 2], [0, 3], [0, 3], [1, 2, 4], [3]]\n mol = ConvMol(atom_features, canon_adj_list)\n # Sorting is done by atom degree as before. So the ordering goes\n # 4, 0, 1, 2, 3 now in terms of the original ordering. The mapping\n # from new position to old position is\n # {(4, 0), (0, 1), (1, 2), (2, 3), (3, 4)}. Check that adjacency\n # list respects this reordering and returns correct adjacency list.\n assert (mol.get_adjacency_list() == [[4], [2, 3], [1, 4], [1, 4],\n [2, 3, 0]])","def get_crefs_to( ea ):\r\n\tret = []\r\n\txrf = get_first_cref_to( ea )\r\n\tif xrf != BADADDR:\r\n\t\tret.append( xrf )\r\n\txrf = get_next_cref_to( ea, xrf )\r\n\twhile xrf != BADADDR:\r\n\t\tret.append( xrf )\r\n\t\txrf = get_next_cref_to( ea, xrf )\r\n\treturn ret","def walk_sort(edges):\n g = nx.Graph()\n g.add_edges_from(edges)\n connected = set()\n degree = nx.degree(g)\n ordering = []\n while degree:\n next = max_degree_node(g, degree, connected)\n if next is not None:\n ordering.append(next)\n else:\n break\n return ordering","def reference_nodes_graph_idx(self) -> Dict[str, torch.Tensor]:\n return self.node_graph_idx_reference","def nodes(self):\n return self.sort_dict(self.trajectory_data)","def refs(self):\n return self._refs","def osnc(pl, refnd):\n return [refnd[i] for i in pl]","def inorder(self):\n if len(self.children) == 0:\n return ['%s' % self.val]\n params = (' , ').join([' <N> '] * len(self.children))\n inorder = ['%s ( %s ) ' % (self.val, params)]\n for child in self.children:\n inorder += child.inorder()\n\n return inorder","def make_order(self, root):\n order = []\n if root and isinstance(root[0], dict):\n keys = set()\n for item in root:\n for key in item.keys():\n keys.add(key)\n for key in args.order or []:\n key = self.get_key(key, keys)\n keys.remove(key)\n order.append(key)\n order += sorted(list(keys))\n return order","def dependency_order(self):\n seen = set()\n\n def _prune_visited(node):\n if node in seen:\n return True\n seen.add(node)\n return False\n\n for target in self.targets:\n if target in seen:\n continue\n for node in target.postorder(prune_fn=_prune_visited):\n yield node.data","def order(self, searcher, docnums, reverse = False):\n raise NotImplementedError","def order_vertices(self):\r\n \r\n ordered = False\r\n while ordered == False:\r\n for i in range(len(self.vertices)):\r\n ordered = True\r\n for parent in self.vertices[i].parents:\r\n if parent>i:\r\n ordered = False\r\n self.swap_vertices(i, parent)","def topo_sort(self):\n # TODO: detect cycles\n self.find_reachable_nodes()\n # save list of nodes in topo order\n self.nodes = []\n # assign each node an id field incrementally\n cur_id = 0\n # count visited outgoing edges for each node\n unvisited = {}\n for nid, node in list(self.found.items()):\n unvisited[nid] = node.nout\n queue = [self.root]\n #print >>sys.stderr, '+++'\n while queue:\n # take off nodes whose all outgoing edges are visited from\n # queue head\n node = queue.pop(0)\n self.nodes.append(node)\n node.hg = self\n node.id = cur_id\n cur_id += 1\n for edge in node.incoming:\n edge.hg = self\n for tailnode in edge.tail:\n #print >>sys.stderr, tailnode\n unvisited[id(tailnode)] -= 1\n if unvisited[id(tailnode)] == 0:\n queue.append(tailnode)\n self.sanity_check()\n self.tasks_done.add('topo_sort')","def xpathOrderDocElems(self):\n ret = libxml2mod.xmlXPathOrderDocElems(self._o)\n return ret","def indexes_edge_insertion_order(self):\n return self._indexes_edge_insertion_order","def sorting(self, presorted=None):\n self._sorted_nodes = []\n if presorted:\n notsorted_nodes = copy(presorted)\n else:\n notsorted_nodes = copy(self.nodes)\n predecessors = {key: copy(val) for (key, val) in self.predecessors.items()}\n\n # nodes that depends only on the self._nodes_wip should go first\n # soe remove them from the connections\n for nd_out in self._node_wip:\n for nd_in in self.successors[nd_out.name]:\n predecessors[nd_in.name].remove(nd_out)\n\n while notsorted_nodes:\n sorted_part, notsorted_nodes = self._sorting(notsorted_nodes, predecessors)\n self._sorted_nodes += sorted_part\n for nd_out in sorted_part:\n for nd_in in self.successors[nd_out.name]:\n predecessors[nd_in.name].remove(nd_out)","def order(self):\n return self.n","def list_defect_ref_keys(self):\n print('=======')\n print('DEFECT_REFs')\n print('=======')\n for key in self.defect_refs:\n print(key)","def __resequence(self):\n if self.__reltype_ordering:\n def reltype_key(rel):\n reltype = rel._reltype\n if reltype in self.__reltype_ordering:\n return self.__reltype_ordering.index(reltype)\n return len(self.__reltype_ordering)\n\n def partname_idx_key(rel):\n partname = util.Partname(rel._target.partname)\n if partname.idx is None:\n return 0\n return partname.idx\n self._values.sort(key=lambda rel: partname_idx_key(rel))\n self._values.sort(key=lambda rel: reltype_key(rel))\n # renumber consistent with new sort order\n for idx, relationship in enumerate(self._values):\n relationship._rId = 'rId%d' % (idx+1)\n else:\n self._values.sort(key=lambda rel: rel._num)","def sort_nodes(self):\n nodes = self._chain.root_node.ordered_subnodes_hierarchy()\n self._chain.nodes = nodes","def get_tagged_corefs(xml, ordered=False):\n nps = {}\n if ordered:\n nps = []\n\n xml = _normalize_malformed_xml(xml)\n\n try:\n corefs = parseString(xml).getElementsByTagName('COREF')\n except ExpatError:\n return nps\n\n for coref in corefs:\n try:\n cid = coref.attributes['ID'].value\n if ordered:\n data = {}\n for npid, np in nps:\n if npid == cid:\n data = np\n break\n else:\n data = nps.get(cid, {})\n except KeyError:\n continue\n\n try:\n data['ref'] = coref.attributes['REF'].value\n except KeyError:\n data['ref'] = None\n\n data['text'] = coref.firstChild.data\n if ordered:\n nps.append((cid, data))\n else:\n nps[cid] = data\n\n\n return nps","def sort_indices(self, list_of_indexes):\n return sorted(list_of_indexes, key=lambda index: tuple(int(i) for i in index.split(\".\")))","def getOrderedPartitionList(whichTables):\n if not whichTables:\n return []\n order = socorro_pri.dependencyOrder(databaseDependenciesForPartition,whichTables)\n return order","def _addReferees(self):\n a_ranks = self.division.GetGroupsRanks(['A'])\n b_ranks = self.division.GetGroupsRanks(['B'])\n c_ranks = self.division.GetGroupsRanks(['C'])\n d_ranks = self.division.GetGroupsRanks(['D'])\n\n self._GroupAddReferees('7th', [d_ranks[1]])\n self._GroupAddReferees('5th', [d_ranks[2]])\n\n self._GroupAddReferees('3rd',[d_ranks[0]])\n self._GroupAddReferees('final',[c_ranks[2]])","def get_short_crefs_to( ea ):\r\n\tret = []\r\n\txrf = get_first_cref_to( ea )\r\n\txrf2 = get_first_fcref_to( ea )\r\n\tif xrf != BADADDR and xrf != xrf2:\r\n\t\tret.append( xrf )\r\n\txrf = get_next_cref_to( ea, xrf )\r\n\twhile xrf != BADADDR and xrf != xrf2:\r\n\t\tret.append( xrf )\r\n\t\txrf = get_next_cref_to( ea, xrf )\r\n\treturn ret","def in_order(self, verbose=False):\n if not self.root:\n return []\n alist = []\n self.in_order_helper(self.root, alist, verbose)\n return alist","def topological_sort(self):\n\t\t#detect leaves\n\t\tnumChildren = dict((n.name,0) for n in self.variables.values())\n\t\tfor n in self.variables.itervalues():\n\t\t\tfor p in n.parents:\n\t\t\t numChildren[p]+=1\n\t\t#do a BFS from leaves to get the reverse topological sort\n\t\ttopo = []\n\t\tqueue = [n for (n,c) in numChildren.iteritems() if c==0]\n\t\tif len(queue)==0:\n\t\t\traise ValueError(\"Bayes net is not acyclic?\")\n\t\twhile len(queue)>0:\n\t\t\tn = self.variables[queue.pop(0)]\n\t\t\ttopo.append(n)\n\t\t\tfor p in n.parents:\n assert numChildren[p]>0\n numChildren[p] -= 1\n if numChildren[p]==0:\n queue.append(p)\n\t\t#now reverse it to get the top down ordering\n assert len(topo)==len(self.variables)\n\t\treturn reversed(topo)","def compute_node_positions(self):\n pass","def scc_order(self):\n if not self.__scc_order:\n self._tarjan()\n return self.__scc_order","def post_order(self, verbose=False):\n if not self.root:\n return []\n alist = []\n self.pre_order_helper(self.root, alist, verbose)\n return alist","def getNodes(self):\n return [ node for node in sorted(self._nodes.values()) ]","def test_order_atoms_in_mol_list(self):\n ref_mol = Molecule(smiles='[CH](CC[CH]c1ccccc1)c1ccccc1')\n mol_list = ref_mol.copy(deep=True).generate_resonance_structures(keep_isomorphic=False, filter_structures=True)\n success = converter.order_atoms_in_mol_list(ref_mol=ref_mol, mol_list=mol_list)\n self.assertTrue(success)\n bond_dict = dict()\n for index1, atom1 in enumerate(ref_mol.atoms):\n for atom2 in atom1.edges.keys():\n index2 = ref_mol.atoms.index(atom2)\n if index1 < index2:\n if index1 not in bond_dict:\n bond_dict[index1] = [index2]\n else:\n bond_dict[index1].append(index2)\n for mol in mol_list:\n for index1, atom1 in enumerate(mol.atoms):\n for atom2 in atom1.edges.keys():\n index2 = mol.atoms.index(atom2)\n if index1 < index2:\n self.assertIn(index2, bond_dict[index1]) # check that these atoms are connected in all mols","def n_refs(self):\n return self._n_refs","def getPriorityList(self):","def _sort_dependencies(self):\n def sort_hier(node):\n if node is None:\n return None\n task = self.get_task_by_mapper(node.item)\n if node.cycles is not None:\n tasks = []\n for n in node.cycles:\n tasks.append(self.get_task_by_mapper(n.item))\n task.circular = task._sort_circular_dependencies(self, tasks)\n for child in node.children:\n t = sort_hier(child)\n if t is not None:\n task.childtasks.append(t)\n return task\n \n mappers = self._get_noninheriting_mappers()\n head = DependencySorter(self.dependencies, list(mappers)).sort(allow_all_cycles=True)\n #print \"-------------------------\"\n #print str(head)\n #print \"---------------------------\"\n task = sort_hier(head)\n return task","def test_circular_reference() -> None:\n\n t = generate_graph_resources(3)\n field(t, (\"dr_1\", \"ds_1\", \"f1\")).references.append(\n (FieldAddress(\"dr_2\", \"ds_2\", \"f1\"), \"to\")\n )\n field(t, (\"dr_2\", \"ds_2\", \"f2\")).references.append(\n (FieldAddress(\"dr_3\", \"ds_3\", \"f2\"), \"to\")\n )\n field(t, (\"dr_3\", \"ds_3\", \"f3\")).references.append(\n (FieldAddress(\"dr_1\", \"ds_1\", \"f3\"), \"to\")\n )\n field(t, (\"dr_1\", \"ds_1\", \"f2\")).identity = \"email\"\n traversal = Traversal(DatasetGraph(*t), {\"email\": \"X\"})\n traversal_map, terminators = traversal.traversal_map()\n assert traversal_map == {\n \"__ROOT__:__ROOT__\": {\"from\": {}, \"to\": {\"dr_1:ds_1\": {\"email -> f2\"}}},\n \"dr_1:ds_1\": {\n \"from\": {\"__ROOT__:__ROOT__\": {\"email -> f2\"}, \"dr_3:ds_3\": {\"f3 -> f3\"}},\n \"to\": {\"dr_2:ds_2\": {\"f1 -> f1\"}},\n },\n \"dr_2:ds_2\": {\n \"from\": {\"dr_1:ds_1\": {\"f1 -> f1\"}},\n \"to\": {\"dr_3:ds_3\": {\"f2 -> f2\"}},\n },\n \"dr_3:ds_3\": {\n \"from\": {\"dr_2:ds_2\": {\"f2 -> f2\"}},\n \"to\": {\"dr_1:ds_1\": {\"f3 -> f3\"}},\n },\n }\n\n assert terminators == [CollectionAddress(\"dr_1\", \"ds_1\")]\n # this visits (root -> 1,1 -> 2,2 -> 3,3 -> 1,1) and then terminates.\n assert generate_traversal_order(traversal) == {\n CollectionAddress(\"__ROOT__\", \"__ROOT__\"): [0],\n CollectionAddress(\"dr_1\", \"ds_1\"): [1, 4],\n CollectionAddress(\"dr_2\", \"ds_2\"): [2],\n CollectionAddress(\"dr_3\", \"ds_3\"): [3],\n }"],"string":"[\n \"def gather_referring_orders (gdbval):\\n# TODO: Somehow also note speculative references and attributes in\\n# general\\n vec = gdbval[\\\"referring\\\"]\\n return [int(i[\\\"referring\\\"][\\\"order\\\"]) for i in vec_iter(vec)]\",\n \"def angle_sort_adjacent_nodes(self,n,ref_nbr=None):\\n nbrs=self.node_to_nodes(n)\\n if len(nbrs)==0:\\n return []\\n diffs=self.nodes['x'][nbrs] - self.nodes['x'][n]\\n angles=np.arctan2(diffs[:,1],diffs[:,0])\\n nbrs=nbrs[np.argsort(angles)]\\n if ref_nbr is not None: \\n i=list(nbrs).index(ref_nbr)\\n nbrs=np.roll(nbrs,-i)\\n return nbrs\",\n \"def _sorting(self, notsorted_list, predecessors):\\n remaining_nodes = []\\n sorted_part = []\\n for nd in notsorted_list:\\n if not predecessors[nd.name]:\\n sorted_part.append(nd)\\n else:\\n remaining_nodes.append(nd)\\n return sorted_part, remaining_nodes\",\n \"def dmc_order(self):\\n return sorted(self.lookup_table, key=lambda clr: int(clr.id) if clr.id.isdigit() else 0)\",\n \"def reference_nodes_idx(self) -> Dict[str, torch.Tensor]:\\n return self.node_idx_references\",\n \"def nodes_in_topological_order(self):\\n if not self.sorted:\\n self._topological_sort()\\n return self._topological_order\",\n \"def _sort_ns(self):\\n n = []\\n for layer in self.structure:\\n n.append(layer.get_index())\\n n = np.asarray(n)\\n return n\",\n \"def rootSetOrder (self):\\n order = []\\n nodes = set(self.__nodes)\\n edge_map = {}\\n for (d, srcs) in six.iteritems(self.__edgeMap):\\n edge_map[d] = srcs.copy()\\n while nodes:\\n freeset = set()\\n for n in nodes:\\n if not (n in edge_map):\\n freeset.add(n)\\n if 0 == len(freeset):\\n _log.error('dependency cycle in named components')\\n return None\\n order.append(freeset)\\n nodes.difference_update(freeset)\\n new_edge_map = {}\\n for (d, srcs) in six.iteritems(edge_map):\\n srcs.difference_update(freeset)\\n if 0 != len(srcs):\\n new_edge_map[d] = srcs\\n edge_map = new_edge_map\\n return order\",\n \"def toposorted(self):\\n order = []\\n colors = {node: \\\"white\\\" for node in self._neighbors}\\n\\n def visit(node):\\n assert colors[node] == \\\"white\\\"\\n colors[node] = \\\"gray\\\"\\n for neighbor in self._neighbors[node]:\\n if colors[neighbor] == \\\"white\\\":\\n visit(neighbor)\\n elif colors[neighbor] == \\\"gray\\\":\\n raise CyclicGraphError(\\n \\\"Cycle involving {!r} and {!r} detected\\\".format(node, neighbor)\\n )\\n order.append(node)\\n colors[node] = \\\"black\\\"\\n\\n for node in self._neighbors:\\n if colors[node] == \\\"white\\\":\\n visit(node)\\n return order\",\n \"def references(self):\\n ref_nodes = self.root.xpath(\\\".//bib-reference\\\")\\n return list(\\n itertools.chain.from_iterable(\\n self.get_reference_iter(node) for node in ref_nodes\\n )\\n )\",\n \"def referencing_nodes(self):\\n\\n return self._referencing_nodes\",\n \"def _refind_nodes(self, reSearchItems, root=None, sortByDepth=False):\\n\\n reListOfSearchItems = list(reSearchItems)\\n\\n if root == None:\\n ReParent = reListOfSearchItems.pop(0)\\n Out = [x for x in self.ParentMap.keys() if ReParent.match(x.tag)]\\n\\n else:\\n Out = [root]\\n\\n\\n while len(reListOfSearchItems) > 0:\\n ReParent = reListOfSearchItems.pop(0)\\n Out = [x for root in Out for x in root.iter() if ReParent.match(x.tag)]\\n\\n if sortByDepth == False: return Out\\n\\n TDict = dict((x, len(self.get_path_to_node(x))) for x in Out)\\n return [o[0] for o in sorted(TDict.items(),key=lambda x:x[1])]\",\n \"def sorted_nodes_list(self):\\r\\n full_sorted_node_list = map(lambda k: k[0], sorted(self.graph.degree(),\\r\\n key=lambda k: k[1], reverse=True))\\r\\n return full_sorted_node_list\",\n \"def list_of_all_nodes_pointing_to_ref( s, ref ):\\n results = []\\n for node in s.nodes.values():\\n nodetype = sortof_type_str_of(node) \\n if nodetype == \\\"LIST\\\":\\n if ref in node:\\n results.append(node)\\n elif nodetype == \\\"DICT\\\":\\n if ref in node.values():\\n results.append(node)\\n return results\",\n \"def order(self):\\n return len(self._nodes)\",\n \"def order(self, searcher, docnums, reverse = False):\\n return docnums\",\n \"def reorder(name_list, ref_list):\\n result = []\\n # Use the ordering in ref_list, to reassemble the name list:\\n for name in ref_list:\\n # These always come at the end\\n if name in ['FTP', 'RSYNC']:\\n continue\\n if name in name_list:\\n result.append(name)\\n # For any that were not in the reference list and are left over, tack\\n # them on to the end:\\n for name in name_list:\\n if name not in ref_list:\\n result.append(name)\\n # Finally, add these, so they are at the very end\\n for name in ref_list:\\n if name in name_list and name in ['FTP', 'RSYNC']:\\n result.append(name)\\n \\n # Make sure I have the same number I started with\\n assert(len(name_list) == len(result))\\n return result\",\n \"def list_refs(self):\\n pass\",\n \"def get_ordered_ids(tree):\\n ordered_ids = []\\n ordered_ids.extend(id(node) for node in tree.gen_tips())\\n ordered_ids.extend(id(node) for node in tree.gen_internal_nodes())\\n return ordered_ids\",\n \"def get_reference_node_parents(ref):\\n parents = []\\n return parents\",\n \"def sequence_elements(self):\\n seq_model = self.opt_model.seq_model\\n self.elements.sort(key=lambda e:\\n seq_model.ifcs.index(e.reference_interface()))\",\n \"def list_ref_keys(self):\\n print('=======')\\n print('REFs')\\n print('=======')\\n for key in self.refs:\\n print(key)\",\n \"def dependents(sent,head): # head: node address\\n return sorted(chain.from_iterable(sent.nodes[head]\\\\\\n ['deps'].values()))\",\n \"def reorder_links(self, previous_node, links): # pragma: no cover\\n\\t\\treturn links\",\n \"def find_topo_sort(node_list):\\r\\n visited = set()\\r\\n topo_order = []\\r\\n #print(node_list)\\r\\n for node in node_list:\\r\\n topo_sort_dfs(node, visited, topo_order)\\r\\n return topo_order\",\n \"def degeneracy_ordering(self):\\n return sorted(self._adjacency_map, key=self.degree)\",\n \"def depends_on(self, node):\\n return sorted(self.__edge_map[node], key=node_key)\",\n \"def get_ordered_nodes(self):\\n nodes = []\\n self.build_nodes_list(self.root, nodes)\\n return nodes\",\n \"def sorted_nodes(self):\\n if self._sorted_nodes is None:\\n self.sorting()\\n return self._sorted_nodes\",\n \"def toposort(adj):\\n # Memoize for visited vertex\\n used = [0] * len(adj)\\n order = []\\n # write your code here\\n # Traverse through each vertex\\n for i in range(len(adj)):\\n if not used[i]:\\n # If not visited, run dfs\\n dfs(adj, used, order, i)\\n\\n # Reverse the order list to show in descending order\\n order.reverse()\\n return order\",\n \"def list_refs(self):\\n print('----\\\\nREFs\\\\n----')\\n self._print_dict(self.refs)\",\n \"def references(self):\\n return tuple(self.__references)\",\n \"def nodes(self):\\n data = list(self._nodes.values())\\n data.sort()\\n return data\",\n \"def _topological_sort(self):\\n\\n visited = defaultdict(bool)\\n stack = []\\n\\n for pod in self.pods:\\n if not visited[pod]:\\n self._topological_sort_pod(pod, visited, stack)\\n\\n return stack[::-1]\",\n \"def sort_nodes(center_node, nodes):\\n def cmp(n1, n2):\\n angle1 = (math.degrees(center_node.angle_to(n1)) + 360.) % 360\\n angle2 = (math.degrees(center_node.angle_to(n2)) + 360.) % 360\\n\\n if angle1 < angle2:\\n return -1\\n elif angle1 == angle2:\\n return 0\\n else:\\n return 1\\n return sorted(nodes, cmp=cmp)\",\n \"def references(self):\\n return self.header('References', '').split()\",\n \"def sorted_nodes_names(self):\\n return [nd.name for nd in self._sorted_nodes]\",\n \"def order(self):\\n pairs = [(w['source'][0], w['target'][0]) for w in self.wires]\\n return processing_order(len(self.modules), pairs)\",\n \"def getSortedCyclicDependencies(self):\\n res = []\\n if self.isCircular():\\n res = [self.identifier if self.originalId is None else self.originalId]\\n # fill node inputs\\n nn = 0\\n while nn < len(res):\\n _node = res[nn]\\n for _inputId in self.model.getNode(_node).ioEngine.inputs:\\n input_node = self.model.getNode(_inputId)\\n if not _inputId in res and input_node.isCircular():\\n # check if node is in circle of _inputId\\n if _node in input_node.getFullInputs():\\n res.append(_inputId)\\n nn += 1\\n return res\",\n \"def toposorted(resources):\\n # sort resources first so we have a deterministic order of nodes with the same partial order\\n resources = sorted(\\n resources,\\n key=lambda resource: (resource.type, resource.id),\\n )\\n\\n # build incoming and outgoing edges\\n nodes = {\\n resource.uri\\n for resource in resources\\n }\\n\\n incoming = defaultdict(set)\\n outgoing = defaultdict(set)\\n for resource in resources:\\n for parent in resource.parents:\\n if parent not in nodes:\\n # ignore references that lead outside of the current graph\\n continue\\n incoming[resource.uri].add(parent)\\n outgoing[parent].add(resource.uri)\\n\\n results = []\\n while resources:\\n remaining = []\\n for resource in resources:\\n if incoming[resource.uri]:\\n # node still has incoming edges\\n remaining.append(resource)\\n continue\\n\\n results.append(resource)\\n for child in outgoing[resource.uri]:\\n incoming[child].remove(resource.uri)\\n\\n if len(resources) == len(remaining):\\n raise Exception(\\\"Cycle detected\\\")\\n resources = remaining\\n\\n return results\",\n \"def referenced_nodes(self):\\n return self._referenced_nodes\",\n \"def find_topo_sort(node_list):\\n visited = set()\\n topo_order = []\\n for node in node_list:\\n topo_sort_dfs(node, visited, topo_order)\\n return topo_order\",\n \"def find_topo_sort(node_list):\\n visited = set()\\n topo_order = []\\n for node in node_list:\\n topo_sort_dfs(node, visited, topo_order)\\n return topo_order\",\n \"def get_compute_order(graph_def, input_node_name='', input_node_size=None):\\n name_to_node = parse_graph_nodes(graph_def)\\n node_info = collections.defaultdict(_node_info)\\n for each in graph_def.node:\\n _get_computed_nodes(name_to_node, each.name, node_info, input_node_name,\\n input_node_size)\\n return node_info, name_to_node\",\n \"def ordering(self):\\n value = []\\n for i in self:\\n if isinstance(i, PQ):\\n value.extend(i.ordering())\\n else:\\n value.append(i)\\n\\n return value\",\n \"def references_list( self, theWeaver ):\\n return [ (c.name, c.seq) \\n for c in theWeaver.reference_style.chunkReferencedBy( self ) ]\",\n \"def findTopologicalOrder(self):\\n # This implementation temporarily messes with reverse stars, must fix at end\\n numOrderedNodes = 0\\n while numOrderedNodes < self.numNodes:\\n nextNode = self.findLeastEnteringLinks()\\n if len(self.node[nextNode].reverseStar) > 0:\\n print(\\\"Error: Network given to findTopologicalOrder contains a cycle.\\\")\\n raise BadNetworkOperationException\\n numOrderedNodes += 1\\n self.node[nextNode].order = numOrderedNodes\\n self.node[nextNode].reverseStar = [0] * self.numLinks\\n for ij in self.node[nextNode].forwardStar:\\n self.node[self.link[ij].head].reverseStar.remove(ij)\\n \\n # Repopulate reverse star list\\n for i in self.node:\\n self.node[i].reverseStar = list()\\n for ij in self.link:\\n self.node[self.link[ij].head].reverseStar.append(ij)\",\n \"def _update_ordering(self):\\n self._descendants = sorted(self.unordered_descendants(), key=lambda node: node.ord)\\n for (new_ord, node) in enumerate(self._descendants, 1):\\n node.ord = new_ord\",\n \"def nreferences(self):\\n return self.__nreferences\",\n \"def calc_ply_order(constraints, targets):\\r\\n if constraints.sym:\\r\\n ply_order = np.arange(targets.n_plies // 2 + targets.n_plies % 2)\\r\\n return ply_order\\r\\n\\r\\n order_before_sorting = np.arange(targets.n_plies)\\r\\n ply_order = np.zeros((targets.n_plies,), int)\\r\\n ply_order[0::2] = order_before_sorting[\\r\\n :targets.n_plies // 2 + targets.n_plies % 2]\\r\\n ply_order[1::2] = order_before_sorting[\\r\\n targets.n_plies // 2 + targets.n_plies % 2:][::-1]\\r\\n return ply_order\",\n \"def order_bfs(self) -> List[Nodo]:\\n\\n # Nodos por buscar, es una cola\\n pending: List[Nodo] = [self.root]\\n # Nodos ya visitados\\n visited: List[Nodo] = []\\n\\n # Mientras la cola tenga items\\n while len(pending) > 0:\\n # Procesar el primer elemento\\n curr = pending.pop(0)\\n visited.append(curr)\\n\\n # Agregar los hijos no visitados del nodo a la cola\\n for child in curr.children:\\n if child in visited:\\n continue\\n pending.append(child)\\n\\n return visited\",\n \"def orderings(self, function_graph):\\r\\n return OrderedDict()\",\n \"def depth_node_ordering(start_node, end_nodes):\\n ordered_list = []\\n ordered_set = set()\\n working_list = [start_node]\\n while working_list != []:\\n node = working_list.pop(0)\\n if not node in ordered_set:\\n ordered_set.add(node)\\n ordered_list.append(node)\\n if not is_leaf_node(node) and not node in end_nodes:\\n for node_op in node.get_inputs():\\n working_list.append(node_op)\\n return ordered_list\",\n \"def _reltype_ordering(self):\\n return self.__reltype_ordering\",\n \"def _order_entities(self):\\n entity_deps = defaultdict(set)\\n for e, features in self.top_level_features.items():\\n # iterate over all dependency features of the top-level features on\\n # this entity. If any of these are themselves top-level features, add\\n # their entities as dependencies of the current entity.\\n deps = {g.hash(): g for f in features\\n for g in self.feature_dependencies[f.hash()]}\\n for d in deps.values():\\n _, num_forward = self.entityset.find_path(e, d.entity.id,\\n include_num_forward=True)\\n if num_forward > 0:\\n entity_deps[e].add(d.entity.id)\\n\\n # Do a top-sort on the new entity DAG\\n self.ordered_entities = utils.topsort([self.target_eid],\\n lambda e: entity_deps[e])\",\n \"def order_dfs(self) -> List[Nodo]:\\n # Nodos por buscar, es una pila\\n pending: List[Nodo] = [self.root]\\n # Nodos ya visitados\\n visited: List[Nodo] = []\\n\\n # Mientras la pila tenga items\\n while len(pending) > 0:\\n # Procesar el primer elemento\\n curr = pending.pop()\\n visited.append(curr)\\n\\n # Agregar los hijos no visitados del nodo a la pila\\n for child in reversed(curr.children):\\n if child in visited:\\n continue\\n pending.append(child)\\n\\n return visited\",\n \"def listOrdering(self):\\r\\n index = 0\\r\\n while( index < len(self.sortedList)-1):\\r\\n if(self.sortedList[index][2] > self.sortedList[index+1][2]): # positions in wrong order\\r\\n self.sortedList[index], self.sortedList[index+1] = self.sortedList[index+1], self.sortedList[index] # switch\\r\\n if(self.sortedList[index][2] == self.sortedList[index+1][2]): # Position conflict\\r\\n if(self.sortedList[index][1] <= self.sortedList[index+1][1]): # Already ordered by id\\r\\n self.sortedList[index+1][2] += 1 # position altered for second rule\\r\\n else:\\r\\n self.sortedList[index][2] += 1\\r\\n self.sortedList[index], self.sortedList[index+1] = self.sortedList[index+1], self.sortedList[index] # switch\\r\\n index += 1\",\n \"def sort_decls(self):\\n\\n #import simplecssbuilder\\n #SHORTHAND_REL = simplecssbuilder.SHORTHAND_REL\\n\\n def decl_key(decl):\\n \\\"\\\"\\\"key for sorting declarations\\\"\\\"\\\"\\n prop = decl.split(':')[0] # get property name\\n if str(prop) in SHORTHAND_REL_inv:\\n return SHORTHAND_REL_inv[str(prop)]\\n else:\\n return str(prop)\\n\\n def sort_decls_clique(clique):\\n \\\"\\\"\\\"Sort the declarations in clique\\\"\\\"\\\"\\n (_,ps) = clique\\n ps.sort(key=decl_key)\\n\\n # compute the inverse of SHORTHAND_REL\\n SHORTHAND_REL_inv = dict()\\n for k,vs in SHORTHAND_REL.iteritems():\\n for v in vs:\\n SHORTHAND_REL_inv[v] = k\\n\\n #print 'PRINTING CLIQUES'\\n for clique in self.cliques:\\n #print clique\\n sort_decls_clique(clique)\\n #print clique\",\n \"def toposorted(infos):\\n key_to_info = {}\\n depends = {}\\n for info in infos:\\n key_to_info[info.key] = info\\n depends[info.key] = []\\n for info in infos:\\n for after in info.after:\\n after_info = key_to_info[after]\\n depends[info.key].append(after_info)\\n for before in info.before:\\n before_info = key_to_info[before]\\n depends[before_info.key].append(info)\\n return topological_sort(infos, lambda info: depends[info.key])\",\n \"def enlist(self):\\r\\n list = self.enlist_helper(self.top_node)\\r\\n list.sort()\\r\\n return list\",\n \"def order_nodes(tree, increase=True):\\n res = tree.copy()\\n for node in res.postorder():\\n if node.is_tip():\\n node.n = 1\\n else:\\n node.n = sum(x.n for x in node.children)\\n for node in res.postorder():\\n if not node.is_tip():\\n children = node.children\\n node.children = []\\n for child in sorted(children, key=lambda x: x.n, reverse=increase):\\n node.append(child)\\n for node in res.postorder():\\n delattr(node, 'n')\\n return res\",\n \"def get_order_from_tree(ids, tree_text):\\r\\n tree = parse_newick(tree_text, PhyloNode)\\r\\n ordered_ids = []\\r\\n for tip in tree.iterTips():\\r\\n if tip.Name in ids:\\r\\n ordered_ids.append(tip.Name)\\r\\n return names_to_indices(ids, ordered_ids)\",\n \"def sort_nodes_by_n_reachable(graph):\\n list_of_node_and_reachables_tups = [] # stores the number of reachable nodes per node\\n # The following for loop finds the number of reachable nodes per node\\n for node_to_test in graph.nodes:\\n n_reachable = 0\\n # The following for loop checks each node if it is reachable from node_to_test. If so, adds to the counter\\n for node_is_reachable in graph.nodes:\\n if graph.is_reachable(node_to_test, node_is_reachable) and node_to_test != node_is_reachable:\\n n_reachable += 1\\n # Adds a tuple with the node_to_test and the counter of reachable nodes\\n list_of_node_and_reachables_tups.append((node_to_test, n_reachable))\\n # At this point we have a list with tuples including the node name and its reachables. Now need to sort them\\n sorted_nodes_by_reachable = sorted(list_of_node_and_reachables_tups, key=lambda tup: tup[1], reverse=True)\\n return sorted_nodes_by_reachable\",\n \"def part_build_order(self):\\n priority = []\\n for geo_item in self.build_order:\\n if geo_item in self.parts:\\n priority += [geo_item]\\n return priority\",\n \"def test_get_adjacency_list(self):\\n atom_features = np.array([[40, 41, 42, 43], [44, 45, 46, 47],\\n [48, 49, 50, 51], [52, 53, 54, 55],\\n [56, 57, 58, 59]])\\n canon_adj_list = [[1, 2], [0, 3], [0, 3], [1, 2, 4], [3]]\\n mol = ConvMol(atom_features, canon_adj_list)\\n # Sorting is done by atom degree as before. So the ordering goes\\n # 4, 0, 1, 2, 3 now in terms of the original ordering. The mapping\\n # from new position to old position is\\n # {(4, 0), (0, 1), (1, 2), (2, 3), (3, 4)}. Check that adjacency\\n # list respects this reordering and returns correct adjacency list.\\n assert (mol.get_adjacency_list() == [[4], [2, 3], [1, 4], [1, 4],\\n [2, 3, 0]])\",\n \"def get_crefs_to( ea ):\\r\\n\\tret = []\\r\\n\\txrf = get_first_cref_to( ea )\\r\\n\\tif xrf != BADADDR:\\r\\n\\t\\tret.append( xrf )\\r\\n\\txrf = get_next_cref_to( ea, xrf )\\r\\n\\twhile xrf != BADADDR:\\r\\n\\t\\tret.append( xrf )\\r\\n\\t\\txrf = get_next_cref_to( ea, xrf )\\r\\n\\treturn ret\",\n \"def walk_sort(edges):\\n g = nx.Graph()\\n g.add_edges_from(edges)\\n connected = set()\\n degree = nx.degree(g)\\n ordering = []\\n while degree:\\n next = max_degree_node(g, degree, connected)\\n if next is not None:\\n ordering.append(next)\\n else:\\n break\\n return ordering\",\n \"def reference_nodes_graph_idx(self) -> Dict[str, torch.Tensor]:\\n return self.node_graph_idx_reference\",\n \"def nodes(self):\\n return self.sort_dict(self.trajectory_data)\",\n \"def refs(self):\\n return self._refs\",\n \"def osnc(pl, refnd):\\n return [refnd[i] for i in pl]\",\n \"def inorder(self):\\n if len(self.children) == 0:\\n return ['%s' % self.val]\\n params = (' , ').join([' <N> '] * len(self.children))\\n inorder = ['%s ( %s ) ' % (self.val, params)]\\n for child in self.children:\\n inorder += child.inorder()\\n\\n return inorder\",\n \"def make_order(self, root):\\n order = []\\n if root and isinstance(root[0], dict):\\n keys = set()\\n for item in root:\\n for key in item.keys():\\n keys.add(key)\\n for key in args.order or []:\\n key = self.get_key(key, keys)\\n keys.remove(key)\\n order.append(key)\\n order += sorted(list(keys))\\n return order\",\n \"def dependency_order(self):\\n seen = set()\\n\\n def _prune_visited(node):\\n if node in seen:\\n return True\\n seen.add(node)\\n return False\\n\\n for target in self.targets:\\n if target in seen:\\n continue\\n for node in target.postorder(prune_fn=_prune_visited):\\n yield node.data\",\n \"def order(self, searcher, docnums, reverse = False):\\n raise NotImplementedError\",\n \"def order_vertices(self):\\r\\n \\r\\n ordered = False\\r\\n while ordered == False:\\r\\n for i in range(len(self.vertices)):\\r\\n ordered = True\\r\\n for parent in self.vertices[i].parents:\\r\\n if parent>i:\\r\\n ordered = False\\r\\n self.swap_vertices(i, parent)\",\n \"def topo_sort(self):\\n # TODO: detect cycles\\n self.find_reachable_nodes()\\n # save list of nodes in topo order\\n self.nodes = []\\n # assign each node an id field incrementally\\n cur_id = 0\\n # count visited outgoing edges for each node\\n unvisited = {}\\n for nid, node in list(self.found.items()):\\n unvisited[nid] = node.nout\\n queue = [self.root]\\n #print >>sys.stderr, '+++'\\n while queue:\\n # take off nodes whose all outgoing edges are visited from\\n # queue head\\n node = queue.pop(0)\\n self.nodes.append(node)\\n node.hg = self\\n node.id = cur_id\\n cur_id += 1\\n for edge in node.incoming:\\n edge.hg = self\\n for tailnode in edge.tail:\\n #print >>sys.stderr, tailnode\\n unvisited[id(tailnode)] -= 1\\n if unvisited[id(tailnode)] == 0:\\n queue.append(tailnode)\\n self.sanity_check()\\n self.tasks_done.add('topo_sort')\",\n \"def xpathOrderDocElems(self):\\n ret = libxml2mod.xmlXPathOrderDocElems(self._o)\\n return ret\",\n \"def indexes_edge_insertion_order(self):\\n return self._indexes_edge_insertion_order\",\n \"def sorting(self, presorted=None):\\n self._sorted_nodes = []\\n if presorted:\\n notsorted_nodes = copy(presorted)\\n else:\\n notsorted_nodes = copy(self.nodes)\\n predecessors = {key: copy(val) for (key, val) in self.predecessors.items()}\\n\\n # nodes that depends only on the self._nodes_wip should go first\\n # soe remove them from the connections\\n for nd_out in self._node_wip:\\n for nd_in in self.successors[nd_out.name]:\\n predecessors[nd_in.name].remove(nd_out)\\n\\n while notsorted_nodes:\\n sorted_part, notsorted_nodes = self._sorting(notsorted_nodes, predecessors)\\n self._sorted_nodes += sorted_part\\n for nd_out in sorted_part:\\n for nd_in in self.successors[nd_out.name]:\\n predecessors[nd_in.name].remove(nd_out)\",\n \"def order(self):\\n return self.n\",\n \"def list_defect_ref_keys(self):\\n print('=======')\\n print('DEFECT_REFs')\\n print('=======')\\n for key in self.defect_refs:\\n print(key)\",\n \"def __resequence(self):\\n if self.__reltype_ordering:\\n def reltype_key(rel):\\n reltype = rel._reltype\\n if reltype in self.__reltype_ordering:\\n return self.__reltype_ordering.index(reltype)\\n return len(self.__reltype_ordering)\\n\\n def partname_idx_key(rel):\\n partname = util.Partname(rel._target.partname)\\n if partname.idx is None:\\n return 0\\n return partname.idx\\n self._values.sort(key=lambda rel: partname_idx_key(rel))\\n self._values.sort(key=lambda rel: reltype_key(rel))\\n # renumber consistent with new sort order\\n for idx, relationship in enumerate(self._values):\\n relationship._rId = 'rId%d' % (idx+1)\\n else:\\n self._values.sort(key=lambda rel: rel._num)\",\n \"def sort_nodes(self):\\n nodes = self._chain.root_node.ordered_subnodes_hierarchy()\\n self._chain.nodes = nodes\",\n \"def get_tagged_corefs(xml, ordered=False):\\n nps = {}\\n if ordered:\\n nps = []\\n\\n xml = _normalize_malformed_xml(xml)\\n\\n try:\\n corefs = parseString(xml).getElementsByTagName('COREF')\\n except ExpatError:\\n return nps\\n\\n for coref in corefs:\\n try:\\n cid = coref.attributes['ID'].value\\n if ordered:\\n data = {}\\n for npid, np in nps:\\n if npid == cid:\\n data = np\\n break\\n else:\\n data = nps.get(cid, {})\\n except KeyError:\\n continue\\n\\n try:\\n data['ref'] = coref.attributes['REF'].value\\n except KeyError:\\n data['ref'] = None\\n\\n data['text'] = coref.firstChild.data\\n if ordered:\\n nps.append((cid, data))\\n else:\\n nps[cid] = data\\n\\n\\n return nps\",\n \"def sort_indices(self, list_of_indexes):\\n return sorted(list_of_indexes, key=lambda index: tuple(int(i) for i in index.split(\\\".\\\")))\",\n \"def getOrderedPartitionList(whichTables):\\n if not whichTables:\\n return []\\n order = socorro_pri.dependencyOrder(databaseDependenciesForPartition,whichTables)\\n return order\",\n \"def _addReferees(self):\\n a_ranks = self.division.GetGroupsRanks(['A'])\\n b_ranks = self.division.GetGroupsRanks(['B'])\\n c_ranks = self.division.GetGroupsRanks(['C'])\\n d_ranks = self.division.GetGroupsRanks(['D'])\\n\\n self._GroupAddReferees('7th', [d_ranks[1]])\\n self._GroupAddReferees('5th', [d_ranks[2]])\\n\\n self._GroupAddReferees('3rd',[d_ranks[0]])\\n self._GroupAddReferees('final',[c_ranks[2]])\",\n \"def get_short_crefs_to( ea ):\\r\\n\\tret = []\\r\\n\\txrf = get_first_cref_to( ea )\\r\\n\\txrf2 = get_first_fcref_to( ea )\\r\\n\\tif xrf != BADADDR and xrf != xrf2:\\r\\n\\t\\tret.append( xrf )\\r\\n\\txrf = get_next_cref_to( ea, xrf )\\r\\n\\twhile xrf != BADADDR and xrf != xrf2:\\r\\n\\t\\tret.append( xrf )\\r\\n\\t\\txrf = get_next_cref_to( ea, xrf )\\r\\n\\treturn ret\",\n \"def in_order(self, verbose=False):\\n if not self.root:\\n return []\\n alist = []\\n self.in_order_helper(self.root, alist, verbose)\\n return alist\",\n \"def topological_sort(self):\\n\\t\\t#detect leaves\\n\\t\\tnumChildren = dict((n.name,0) for n in self.variables.values())\\n\\t\\tfor n in self.variables.itervalues():\\n\\t\\t\\tfor p in n.parents:\\n\\t\\t\\t numChildren[p]+=1\\n\\t\\t#do a BFS from leaves to get the reverse topological sort\\n\\t\\ttopo = []\\n\\t\\tqueue = [n for (n,c) in numChildren.iteritems() if c==0]\\n\\t\\tif len(queue)==0:\\n\\t\\t\\traise ValueError(\\\"Bayes net is not acyclic?\\\")\\n\\t\\twhile len(queue)>0:\\n\\t\\t\\tn = self.variables[queue.pop(0)]\\n\\t\\t\\ttopo.append(n)\\n\\t\\t\\tfor p in n.parents:\\n assert numChildren[p]>0\\n numChildren[p] -= 1\\n if numChildren[p]==0:\\n queue.append(p)\\n\\t\\t#now reverse it to get the top down ordering\\n assert len(topo)==len(self.variables)\\n\\t\\treturn reversed(topo)\",\n \"def compute_node_positions(self):\\n pass\",\n \"def scc_order(self):\\n if not self.__scc_order:\\n self._tarjan()\\n return self.__scc_order\",\n \"def post_order(self, verbose=False):\\n if not self.root:\\n return []\\n alist = []\\n self.pre_order_helper(self.root, alist, verbose)\\n return alist\",\n \"def getNodes(self):\\n return [ node for node in sorted(self._nodes.values()) ]\",\n \"def test_order_atoms_in_mol_list(self):\\n ref_mol = Molecule(smiles='[CH](CC[CH]c1ccccc1)c1ccccc1')\\n mol_list = ref_mol.copy(deep=True).generate_resonance_structures(keep_isomorphic=False, filter_structures=True)\\n success = converter.order_atoms_in_mol_list(ref_mol=ref_mol, mol_list=mol_list)\\n self.assertTrue(success)\\n bond_dict = dict()\\n for index1, atom1 in enumerate(ref_mol.atoms):\\n for atom2 in atom1.edges.keys():\\n index2 = ref_mol.atoms.index(atom2)\\n if index1 < index2:\\n if index1 not in bond_dict:\\n bond_dict[index1] = [index2]\\n else:\\n bond_dict[index1].append(index2)\\n for mol in mol_list:\\n for index1, atom1 in enumerate(mol.atoms):\\n for atom2 in atom1.edges.keys():\\n index2 = mol.atoms.index(atom2)\\n if index1 < index2:\\n self.assertIn(index2, bond_dict[index1]) # check that these atoms are connected in all mols\",\n \"def n_refs(self):\\n return self._n_refs\",\n \"def getPriorityList(self):\",\n \"def _sort_dependencies(self):\\n def sort_hier(node):\\n if node is None:\\n return None\\n task = self.get_task_by_mapper(node.item)\\n if node.cycles is not None:\\n tasks = []\\n for n in node.cycles:\\n tasks.append(self.get_task_by_mapper(n.item))\\n task.circular = task._sort_circular_dependencies(self, tasks)\\n for child in node.children:\\n t = sort_hier(child)\\n if t is not None:\\n task.childtasks.append(t)\\n return task\\n \\n mappers = self._get_noninheriting_mappers()\\n head = DependencySorter(self.dependencies, list(mappers)).sort(allow_all_cycles=True)\\n #print \\\"-------------------------\\\"\\n #print str(head)\\n #print \\\"---------------------------\\\"\\n task = sort_hier(head)\\n return task\",\n \"def test_circular_reference() -> None:\\n\\n t = generate_graph_resources(3)\\n field(t, (\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\")).references.append(\\n (FieldAddress(\\\"dr_2\\\", \\\"ds_2\\\", \\\"f1\\\"), \\\"to\\\")\\n )\\n field(t, (\\\"dr_2\\\", \\\"ds_2\\\", \\\"f2\\\")).references.append(\\n (FieldAddress(\\\"dr_3\\\", \\\"ds_3\\\", \\\"f2\\\"), \\\"to\\\")\\n )\\n field(t, (\\\"dr_3\\\", \\\"ds_3\\\", \\\"f3\\\")).references.append(\\n (FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f3\\\"), \\\"to\\\")\\n )\\n field(t, (\\\"dr_1\\\", \\\"ds_1\\\", \\\"f2\\\")).identity = \\\"email\\\"\\n traversal = Traversal(DatasetGraph(*t), {\\\"email\\\": \\\"X\\\"})\\n traversal_map, terminators = traversal.traversal_map()\\n assert traversal_map == {\\n \\\"__ROOT__:__ROOT__\\\": {\\\"from\\\": {}, \\\"to\\\": {\\\"dr_1:ds_1\\\": {\\\"email -> f2\\\"}}},\\n \\\"dr_1:ds_1\\\": {\\n \\\"from\\\": {\\\"__ROOT__:__ROOT__\\\": {\\\"email -> f2\\\"}, \\\"dr_3:ds_3\\\": {\\\"f3 -> f3\\\"}},\\n \\\"to\\\": {\\\"dr_2:ds_2\\\": {\\\"f1 -> f1\\\"}},\\n },\\n \\\"dr_2:ds_2\\\": {\\n \\\"from\\\": {\\\"dr_1:ds_1\\\": {\\\"f1 -> f1\\\"}},\\n \\\"to\\\": {\\\"dr_3:ds_3\\\": {\\\"f2 -> f2\\\"}},\\n },\\n \\\"dr_3:ds_3\\\": {\\n \\\"from\\\": {\\\"dr_2:ds_2\\\": {\\\"f2 -> f2\\\"}},\\n \\\"to\\\": {\\\"dr_1:ds_1\\\": {\\\"f3 -> f3\\\"}},\\n },\\n }\\n\\n assert terminators == [CollectionAddress(\\\"dr_1\\\", \\\"ds_1\\\")]\\n # this visits (root -> 1,1 -> 2,2 -> 3,3 -> 1,1) and then terminates.\\n assert generate_traversal_order(traversal) == {\\n CollectionAddress(\\\"__ROOT__\\\", \\\"__ROOT__\\\"): [0],\\n CollectionAddress(\\\"dr_1\\\", \\\"ds_1\\\"): [1, 4],\\n CollectionAddress(\\\"dr_2\\\", \\\"ds_2\\\"): [2],\\n CollectionAddress(\\\"dr_3\\\", \\\"ds_3\\\"): [3],\\n }\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.731949","0.6546845","0.6098026","0.6095413","0.6079038","0.5992602","0.5936781","0.59094507","0.58531016","0.58507776","0.58364546","0.58358586","0.58252954","0.58145785","0.5806854","0.5802949","0.5786999","0.5780388","0.5758174","0.5740272","0.57386464","0.5736634","0.5711007","0.5710025","0.568748","0.56833094","0.56813157","0.5680931","0.56746274","0.5652924","0.56365585","0.56354904","0.5632261","0.5616651","0.56126946","0.5604891","0.5599711","0.5592472","0.55672675","0.553561","0.55340636","0.5524503","0.5524503","0.55187386","0.55127645","0.55070734","0.5501517","0.54888874","0.54867035","0.5484347","0.54835534","0.548326","0.5482074","0.54813033","0.5475585","0.5455229","0.54513156","0.543258","0.5428622","0.5406537","0.54000103","0.53937423","0.5371916","0.5370054","0.5365838","0.53522646","0.5351422","0.5349518","0.5348714","0.5346665","0.53465","0.5340315","0.53396654","0.5336445","0.53345615","0.5329645","0.53271806","0.5317159","0.5305934","0.53036696","0.5299165","0.5290899","0.5290754","0.5288983","0.5267978","0.52663404","0.52645844","0.5259767","0.5256294","0.52493316","0.52477807","0.52370304","0.52349925","0.5228731","0.52220124","0.5220924","0.52190185","0.52137804","0.5206766","0.5203298"],"string":"[\n \"0.731949\",\n \"0.6546845\",\n \"0.6098026\",\n \"0.6095413\",\n \"0.6079038\",\n \"0.5992602\",\n \"0.5936781\",\n \"0.59094507\",\n \"0.58531016\",\n \"0.58507776\",\n \"0.58364546\",\n \"0.58358586\",\n \"0.58252954\",\n \"0.58145785\",\n \"0.5806854\",\n \"0.5802949\",\n \"0.5786999\",\n \"0.5780388\",\n \"0.5758174\",\n \"0.5740272\",\n \"0.57386464\",\n \"0.5736634\",\n \"0.5711007\",\n \"0.5710025\",\n \"0.568748\",\n \"0.56833094\",\n \"0.56813157\",\n \"0.5680931\",\n \"0.56746274\",\n \"0.5652924\",\n \"0.56365585\",\n \"0.56354904\",\n \"0.5632261\",\n \"0.5616651\",\n \"0.56126946\",\n \"0.5604891\",\n \"0.5599711\",\n \"0.5592472\",\n \"0.55672675\",\n \"0.553561\",\n \"0.55340636\",\n \"0.5524503\",\n \"0.5524503\",\n \"0.55187386\",\n \"0.55127645\",\n \"0.55070734\",\n \"0.5501517\",\n \"0.54888874\",\n \"0.54867035\",\n \"0.5484347\",\n \"0.54835534\",\n \"0.548326\",\n \"0.5482074\",\n \"0.54813033\",\n \"0.5475585\",\n \"0.5455229\",\n \"0.54513156\",\n \"0.543258\",\n \"0.5428622\",\n \"0.5406537\",\n \"0.54000103\",\n \"0.53937423\",\n \"0.5371916\",\n \"0.5370054\",\n \"0.5365838\",\n \"0.53522646\",\n \"0.5351422\",\n \"0.5349518\",\n \"0.5348714\",\n \"0.5346665\",\n \"0.53465\",\n \"0.5340315\",\n \"0.53396654\",\n \"0.5336445\",\n \"0.53345615\",\n \"0.5329645\",\n \"0.53271806\",\n \"0.5317159\",\n \"0.5305934\",\n \"0.53036696\",\n \"0.5299165\",\n \"0.5290899\",\n \"0.5290754\",\n \"0.5288983\",\n \"0.5267978\",\n \"0.52663404\",\n \"0.52645844\",\n \"0.5259767\",\n \"0.5256294\",\n \"0.52493316\",\n \"0.52477807\",\n \"0.52370304\",\n \"0.52349925\",\n \"0.5228731\",\n \"0.52220124\",\n \"0.5220924\",\n \"0.52190185\",\n \"0.52137804\",\n \"0.5206766\",\n \"0.5203298\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.79086727"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":15195,"cells":{"query":{"kind":"string","value":"Return orders of nodes referring node associated with ipa_ref_list"},"document":{"kind":"string","value":"def gather_referring_orders (gdbval):\n# TODO: Somehow also note speculative references and attributes in\n# general\n vec = gdbval[\"referring\"]\n return [int(i[\"referring\"][\"order\"]) for i in vec_iter(vec)]"},"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 gather_references_orders (gdbval):\n# TODO: Somehow also note speculative references and attributes in\n# general\n vec = gdbval[\"references\"]\n return [int(i[\"referred\"][\"order\"]) for i in vec_iter(vec)]","def angle_sort_adjacent_nodes(self,n,ref_nbr=None):\n nbrs=self.node_to_nodes(n)\n if len(nbrs)==0:\n return []\n diffs=self.nodes['x'][nbrs] - self.nodes['x'][n]\n angles=np.arctan2(diffs[:,1],diffs[:,0])\n nbrs=nbrs[np.argsort(angles)]\n if ref_nbr is not None: \n i=list(nbrs).index(ref_nbr)\n nbrs=np.roll(nbrs,-i)\n return nbrs","def reference_nodes_idx(self) -> Dict[str, torch.Tensor]:\n return self.node_idx_references","def referencing_nodes(self):\n\n return self._referencing_nodes","def get_reference_node_parents(ref):\n parents = []\n return parents","def nodes_in_topological_order(self):\n if not self.sorted:\n self._topological_sort()\n return self._topological_order","def list_of_all_nodes_pointing_to_ref( s, ref ):\n results = []\n for node in s.nodes.values():\n nodetype = sortof_type_str_of(node) \n if nodetype == \"LIST\":\n if ref in node:\n results.append(node)\n elif nodetype == \"DICT\":\n if ref in node.values():\n results.append(node)\n return results","def _sorting(self, notsorted_list, predecessors):\n remaining_nodes = []\n sorted_part = []\n for nd in notsorted_list:\n if not predecessors[nd.name]:\n sorted_part.append(nd)\n else:\n remaining_nodes.append(nd)\n return sorted_part, remaining_nodes","def find_topo_sort(node_list):\r\n visited = set()\r\n topo_order = []\r\n #print(node_list)\r\n for node in node_list:\r\n topo_sort_dfs(node, visited, topo_order)\r\n return topo_order","def _refind_nodes(self, reSearchItems, root=None, sortByDepth=False):\n\n reListOfSearchItems = list(reSearchItems)\n\n if root == None:\n ReParent = reListOfSearchItems.pop(0)\n Out = [x for x in self.ParentMap.keys() if ReParent.match(x.tag)]\n\n else:\n Out = [root]\n\n\n while len(reListOfSearchItems) > 0:\n ReParent = reListOfSearchItems.pop(0)\n Out = [x for root in Out for x in root.iter() if ReParent.match(x.tag)]\n\n if sortByDepth == False: return Out\n\n TDict = dict((x, len(self.get_path_to_node(x))) for x in Out)\n return [o[0] for o in sorted(TDict.items(),key=lambda x:x[1])]","def order(self):\n return len(self._nodes)","def get_compute_order(graph_def, input_node_name='', input_node_size=None):\n name_to_node = parse_graph_nodes(graph_def)\n node_info = collections.defaultdict(_node_info)\n for each in graph_def.node:\n _get_computed_nodes(name_to_node, each.name, node_info, input_node_name,\n input_node_size)\n return node_info, name_to_node","def find_topo_sort(node_list):\n visited = set()\n topo_order = []\n for node in node_list:\n topo_sort_dfs(node, visited, topo_order)\n return topo_order","def find_topo_sort(node_list):\n visited = set()\n topo_order = []\n for node in node_list:\n topo_sort_dfs(node, visited, topo_order)\n return topo_order","def sort_nodes_by_n_reachable(graph):\n list_of_node_and_reachables_tups = [] # stores the number of reachable nodes per node\n # The following for loop finds the number of reachable nodes per node\n for node_to_test in graph.nodes:\n n_reachable = 0\n # The following for loop checks each node if it is reachable from node_to_test. If so, adds to the counter\n for node_is_reachable in graph.nodes:\n if graph.is_reachable(node_to_test, node_is_reachable) and node_to_test != node_is_reachable:\n n_reachable += 1\n # Adds a tuple with the node_to_test and the counter of reachable nodes\n list_of_node_and_reachables_tups.append((node_to_test, n_reachable))\n # At this point we have a list with tuples including the node name and its reachables. Now need to sort them\n sorted_nodes_by_reachable = sorted(list_of_node_and_reachables_tups, key=lambda tup: tup[1], reverse=True)\n return sorted_nodes_by_reachable","def toposort(adj):\n # Memoize for visited vertex\n used = [0] * len(adj)\n order = []\n # write your code here\n # Traverse through each vertex\n for i in range(len(adj)):\n if not used[i]:\n # If not visited, run dfs\n dfs(adj, used, order, i)\n\n # Reverse the order list to show in descending order\n order.reverse()\n return order","def findTopologicalOrder(self):\n # This implementation temporarily messes with reverse stars, must fix at end\n numOrderedNodes = 0\n while numOrderedNodes < self.numNodes:\n nextNode = self.findLeastEnteringLinks()\n if len(self.node[nextNode].reverseStar) > 0:\n print(\"Error: Network given to findTopologicalOrder contains a cycle.\")\n raise BadNetworkOperationException\n numOrderedNodes += 1\n self.node[nextNode].order = numOrderedNodes\n self.node[nextNode].reverseStar = [0] * self.numLinks\n for ij in self.node[nextNode].forwardStar:\n self.node[self.link[ij].head].reverseStar.remove(ij)\n \n # Repopulate reverse star list\n for i in self.node:\n self.node[i].reverseStar = list()\n for ij in self.link:\n self.node[self.link[ij].head].reverseStar.append(ij)","def depends_on(self, node):\n return sorted(self.__edge_map[node], key=node_key)","def dmc_order(self):\n return sorted(self.lookup_table, key=lambda clr: int(clr.id) if clr.id.isdigit() else 0)","def reference_nodes_graph_idx(self) -> Dict[str, torch.Tensor]:\n return self.node_graph_idx_reference","def toposorted(self):\n order = []\n colors = {node: \"white\" for node in self._neighbors}\n\n def visit(node):\n assert colors[node] == \"white\"\n colors[node] = \"gray\"\n for neighbor in self._neighbors[node]:\n if colors[neighbor] == \"white\":\n visit(neighbor)\n elif colors[neighbor] == \"gray\":\n raise CyclicGraphError(\n \"Cycle involving {!r} and {!r} detected\".format(node, neighbor)\n )\n order.append(node)\n colors[node] = \"black\"\n\n for node in self._neighbors:\n if colors[node] == \"white\":\n visit(node)\n return order","def referenced_nodes(self):\n return self._referenced_nodes","def rootSetOrder (self):\n order = []\n nodes = set(self.__nodes)\n edge_map = {}\n for (d, srcs) in six.iteritems(self.__edgeMap):\n edge_map[d] = srcs.copy()\n while nodes:\n freeset = set()\n for n in nodes:\n if not (n in edge_map):\n freeset.add(n)\n if 0 == len(freeset):\n _log.error('dependency cycle in named components')\n return None\n order.append(freeset)\n nodes.difference_update(freeset)\n new_edge_map = {}\n for (d, srcs) in six.iteritems(edge_map):\n srcs.difference_update(freeset)\n if 0 != len(srcs):\n new_edge_map[d] = srcs\n edge_map = new_edge_map\n return order","def sorted_nodes_list(self):\r\n full_sorted_node_list = map(lambda k: k[0], sorted(self.graph.degree(),\r\n key=lambda k: k[1], reverse=True))\r\n return full_sorted_node_list","def references(self):\n ref_nodes = self.root.xpath(\".//bib-reference\")\n return list(\n itertools.chain.from_iterable(\n self.get_reference_iter(node) for node in ref_nodes\n )\n )","def targeted_order(ugraph):\n # copy the graph\n new_graph = copy_graph(ugraph)\n \n counter = 0\n order = [] \n while len(new_graph) > 0:\n max_degree = -1\n for node in new_graph:\n counter += 1\n if len(new_graph[node]) > max_degree:\n max_degree = len(new_graph[node])\n max_degree_node = node\n \n \n neighbors = new_graph[max_degree_node]\n new_graph.pop(max_degree_node)\n for neighbor in neighbors:\n counter += 1\n new_graph[neighbor].remove(max_degree_node)\n\n order.append(max_degree_node)\n return order # uncomment to use graph_resilience_targeted_order","def list_ref_keys(self):\n print('=======')\n print('REFs')\n print('=======')\n for key in self.refs:\n print(key)","def _topological_sort(self):\n\n visited = defaultdict(bool)\n stack = []\n\n for pod in self.pods:\n if not visited[pod]:\n self._topological_sort_pod(pod, visited, stack)\n\n return stack[::-1]","def reorder(name_list, ref_list):\n result = []\n # Use the ordering in ref_list, to reassemble the name list:\n for name in ref_list:\n # These always come at the end\n if name in ['FTP', 'RSYNC']:\n continue\n if name in name_list:\n result.append(name)\n # For any that were not in the reference list and are left over, tack\n # them on to the end:\n for name in name_list:\n if name not in ref_list:\n result.append(name)\n # Finally, add these, so they are at the very end\n for name in ref_list:\n if name in name_list and name in ['FTP', 'RSYNC']:\n result.append(name)\n \n # Make sure I have the same number I started with\n assert(len(name_list) == len(result))\n return result","def dependents(sent,head): # head: node address\n return sorted(chain.from_iterable(sent.nodes[head]\\\n ['deps'].values()))","def depth_node_ordering(start_node, end_nodes):\n ordered_list = []\n ordered_set = set()\n working_list = [start_node]\n while working_list != []:\n node = working_list.pop(0)\n if not node in ordered_set:\n ordered_set.add(node)\n ordered_list.append(node)\n if not is_leaf_node(node) and not node in end_nodes:\n for node_op in node.get_inputs():\n working_list.append(node_op)\n return ordered_list","def order_bfs(self) -> List[Nodo]:\n\n # Nodos por buscar, es una cola\n pending: List[Nodo] = [self.root]\n # Nodos ya visitados\n visited: List[Nodo] = []\n\n # Mientras la cola tenga items\n while len(pending) > 0:\n # Procesar el primer elemento\n curr = pending.pop(0)\n visited.append(curr)\n\n # Agregar los hijos no visitados del nodo a la cola\n for child in curr.children:\n if child in visited:\n continue\n pending.append(child)\n\n return visited","def order_dfs(self) -> List[Nodo]:\n # Nodos por buscar, es una pila\n pending: List[Nodo] = [self.root]\n # Nodos ya visitados\n visited: List[Nodo] = []\n\n # Mientras la pila tenga items\n while len(pending) > 0:\n # Procesar el primer elemento\n curr = pending.pop()\n visited.append(curr)\n\n # Agregar los hijos no visitados del nodo a la pila\n for child in reversed(curr.children):\n if child in visited:\n continue\n pending.append(child)\n\n return visited","def order_nodes(tree, increase=True):\n res = tree.copy()\n for node in res.postorder():\n if node.is_tip():\n node.n = 1\n else:\n node.n = sum(x.n for x in node.children)\n for node in res.postorder():\n if not node.is_tip():\n children = node.children\n node.children = []\n for child in sorted(children, key=lambda x: x.n, reverse=increase):\n node.append(child)\n for node in res.postorder():\n delattr(node, 'n')\n return res","def get_ordered_ids(tree):\n ordered_ids = []\n ordered_ids.extend(id(node) for node in tree.gen_tips())\n ordered_ids.extend(id(node) for node in tree.gen_internal_nodes())\n return ordered_ids","def reorder_links(self, previous_node, links): # pragma: no cover\n\t\treturn links","def sorted_nodes(self):\n if self._sorted_nodes is None:\n self.sorting()\n return self._sorted_nodes","def get_ordered_nodes(self):\n nodes = []\n self.build_nodes_list(self.root, nodes)\n return nodes","def nreferences(self):\n return self.__nreferences","def number_nodes(tree):\n def list_of_nodes(tree):\n \"\"\"Return a list of internal nodes in postorder traversal\n\n @param HuffmanNode tree: a tree to traverse\n @rtype: list\n\n >>> t = HuffmanNode(None, HuffmanNode(6), HuffmanNode(7))\n >>> list_of_nodes(t) == [t]\n True\n >>> t = HuffmanNode(None, HuffmanNode(8), HuffmanNode(None, HuffmanNode(5), HuffmanNode(6)))\n >>> list_of_nodes(t) == [HuffmanNode(None, HuffmanNode(5), HuffmanNode(6)), HuffmanNode(None, HuffmanNode(8), HuffmanNode(None, HuffmanNode(5), HuffmanNode(6)))]\n True\n \"\"\"\n list_ = []\n if tree.left.is_leaf() and tree.right.is_leaf():\n list_.append(tree)\n return list_\n elif tree.left.is_leaf():\n list_.extend(list_of_nodes(tree.right))\n list_.append(tree)\n return list_\n elif tree.right.is_leaf():\n list_.extend(list_of_nodes(tree.left))\n list_.append(tree)\n return list_\n else:\n list_.extend(list_of_nodes(tree.left))\n list_.extend(list_of_nodes(tree.right))\n list_.append(tree)\n return list_\n\n internal_nodes = list_of_nodes(tree)\n for i in range(len(internal_nodes)):\n node = internal_nodes[i]\n node.number = i","def compute_node_positions(self):\n pass","def nodes(self):\n data = list(self._nodes.values())\n data.sort()\n return data","def list_refs(self):\n pass","def test_get_adjacency_list(self):\n atom_features = np.array([[40, 41, 42, 43], [44, 45, 46, 47],\n [48, 49, 50, 51], [52, 53, 54, 55],\n [56, 57, 58, 59]])\n canon_adj_list = [[1, 2], [0, 3], [0, 3], [1, 2, 4], [3]]\n mol = ConvMol(atom_features, canon_adj_list)\n # Sorting is done by atom degree as before. So the ordering goes\n # 4, 0, 1, 2, 3 now in terms of the original ordering. The mapping\n # from new position to old position is\n # {(4, 0), (0, 1), (1, 2), (2, 3), (3, 4)}. Check that adjacency\n # list respects this reordering and returns correct adjacency list.\n assert (mol.get_adjacency_list() == [[4], [2, 3], [1, 4], [1, 4],\n [2, 3, 0]])","def sort_nodes(center_node, nodes):\n def cmp(n1, n2):\n angle1 = (math.degrees(center_node.angle_to(n1)) + 360.) % 360\n angle2 = (math.degrees(center_node.angle_to(n2)) + 360.) % 360\n\n if angle1 < angle2:\n return -1\n elif angle1 == angle2:\n return 0\n else:\n return 1\n return sorted(nodes, cmp=cmp)","def _sort_ns(self):\n n = []\n for layer in self.structure:\n n.append(layer.get_index())\n n = np.asarray(n)\n return n","def fast_target_order(ugraph):\n result_order = []\n num_nodes = len(ugraph.keys())\n degrees = [set([]) for _ in range(num_nodes)]\n for node in ugraph.keys():\n node_degree = len(ugraph[node])\n degrees[node_degree].add(node)\n for degree in range(num_nodes - 1, -1, -1):\n while degrees[degree] != set([]):\n elem = degrees[degree].pop()\n for neighbor in ugraph[elem]:\n n_degree = len(ugraph[neighbor])\n degrees[n_degree].remove(neighbor)\n degrees[n_degree - 1].add(neighbor)\n result_order.append(elem)\n delete_node(ugraph, elem)\n return result_order","def order(self, searcher, docnums, reverse = False):\n return docnums","def test_circular_reference() -> None:\n\n t = generate_graph_resources(3)\n field(t, (\"dr_1\", \"ds_1\", \"f1\")).references.append(\n (FieldAddress(\"dr_2\", \"ds_2\", \"f1\"), \"to\")\n )\n field(t, (\"dr_2\", \"ds_2\", \"f2\")).references.append(\n (FieldAddress(\"dr_3\", \"ds_3\", \"f2\"), \"to\")\n )\n field(t, (\"dr_3\", \"ds_3\", \"f3\")).references.append(\n (FieldAddress(\"dr_1\", \"ds_1\", \"f3\"), \"to\")\n )\n field(t, (\"dr_1\", \"ds_1\", \"f2\")).identity = \"email\"\n traversal = Traversal(DatasetGraph(*t), {\"email\": \"X\"})\n traversal_map, terminators = traversal.traversal_map()\n assert traversal_map == {\n \"__ROOT__:__ROOT__\": {\"from\": {}, \"to\": {\"dr_1:ds_1\": {\"email -> f2\"}}},\n \"dr_1:ds_1\": {\n \"from\": {\"__ROOT__:__ROOT__\": {\"email -> f2\"}, \"dr_3:ds_3\": {\"f3 -> f3\"}},\n \"to\": {\"dr_2:ds_2\": {\"f1 -> f1\"}},\n },\n \"dr_2:ds_2\": {\n \"from\": {\"dr_1:ds_1\": {\"f1 -> f1\"}},\n \"to\": {\"dr_3:ds_3\": {\"f2 -> f2\"}},\n },\n \"dr_3:ds_3\": {\n \"from\": {\"dr_2:ds_2\": {\"f2 -> f2\"}},\n \"to\": {\"dr_1:ds_1\": {\"f3 -> f3\"}},\n },\n }\n\n assert terminators == [CollectionAddress(\"dr_1\", \"ds_1\")]\n # this visits (root -> 1,1 -> 2,2 -> 3,3 -> 1,1) and then terminates.\n assert generate_traversal_order(traversal) == {\n CollectionAddress(\"__ROOT__\", \"__ROOT__\"): [0],\n CollectionAddress(\"dr_1\", \"ds_1\"): [1, 4],\n CollectionAddress(\"dr_2\", \"ds_2\"): [2],\n CollectionAddress(\"dr_3\", \"ds_3\"): [3],\n }","def list_refs(self):\n print('----\\nREFs\\n----')\n self._print_dict(self.refs)","def getSortedCyclicDependencies(self):\n res = []\n if self.isCircular():\n res = [self.identifier if self.originalId is None else self.originalId]\n # fill node inputs\n nn = 0\n while nn < len(res):\n _node = res[nn]\n for _inputId in self.model.getNode(_node).ioEngine.inputs:\n input_node = self.model.getNode(_inputId)\n if not _inputId in res and input_node.isCircular():\n # check if node is in circle of _inputId\n if _node in input_node.getFullInputs():\n res.append(_inputId)\n nn += 1\n return res","def get_adj_nodes(self):\n return [\n self.nearest_node + PVector(1, 0),\n self.nearest_node + PVector(0, 1),\n self.nearest_node + PVector(-1, 0),\n self.nearest_node + PVector(0, -1)]","def toposorted(resources):\n # sort resources first so we have a deterministic order of nodes with the same partial order\n resources = sorted(\n resources,\n key=lambda resource: (resource.type, resource.id),\n )\n\n # build incoming and outgoing edges\n nodes = {\n resource.uri\n for resource in resources\n }\n\n incoming = defaultdict(set)\n outgoing = defaultdict(set)\n for resource in resources:\n for parent in resource.parents:\n if parent not in nodes:\n # ignore references that lead outside of the current graph\n continue\n incoming[resource.uri].add(parent)\n outgoing[parent].add(resource.uri)\n\n results = []\n while resources:\n remaining = []\n for resource in resources:\n if incoming[resource.uri]:\n # node still has incoming edges\n remaining.append(resource)\n continue\n\n results.append(resource)\n for child in outgoing[resource.uri]:\n incoming[child].remove(resource.uri)\n\n if len(resources) == len(remaining):\n raise Exception(\"Cycle detected\")\n resources = remaining\n\n return results","def nodes(self):\n return self.sort_dict(self.trajectory_data)","def topological_sort(self):\n in_degree = {}\n for node in self.graph:\n in_degree[node] = 0\n\n for from_node in self.graph:\n for to_node in self.graph[from_node]:\n in_degree[to_node] += 1\n\n queue = deque()\n for node in in_degree:\n if in_degree[node] == 0:\n queue.appendleft(node)\n\n sorted_nodes = []\n while queue:\n independent_node = queue.pop()\n sorted_nodes.append(independent_node)\n for next_node in self.graph[independent_node]:\n in_degree[next_node] -= 1\n if in_degree[next_node] == 0:\n queue.appendleft(next_node)\n\n if len(sorted_nodes) == len(self.graph):\n return sorted_nodes\n else:\n raise ValueError('graph is not acyclic')","def targeted_order(ugraph):\r\n # copy the graph\r\n new_graph = copy_graph(ugraph)\r\n \r\n order = [] \r\n while len(new_graph) > 0:\r\n max_degree = -1\r\n for node in new_graph:\r\n if len(new_graph[node]) > max_degree:\r\n max_degree = len(new_graph[node])\r\n max_degree_node = node\r\n \r\n neighbors = new_graph[max_degree_node]\r\n new_graph.pop(max_degree_node)\r\n for neighbor in neighbors:\r\n new_graph[neighbor].remove(max_degree_node)\r\n\r\n order.append(max_degree_node)\r\n return order","def degeneracy_ordering(self):\n return sorted(self._adjacency_map, key=self.degree)","def fast_targeted_order(ugraph):\n\n graph = copy_graph(ugraph)\n# print graph\n size = len(ugraph) #- 1\n degree_sets = [set() for _ in range(size)]\n order = []\n\n for node, edges in ugraph.iteritems():\n degree = len(edges)\n degree_sets[degree].add(node)\n# print degree_sets\n\n for k in range(size - 1, -1, -1):\n while degree_sets[k]:\n node = degree_sets[k].pop()\n neighbors = graph[node]\n for neighbor in neighbors:\n degree = len(graph[neighbor])\n degree_sets[degree].remove(neighbor)\n degree_sets[degree - 1].add(neighbor)\n order.append(node)\n delete_node(graph, node)\n return order","def targeted_order(ugraph):\n # copy the graph\n new_graph = copy_graph(ugraph)\n\n order = []\n while len(new_graph) > 0:\n max_degree = -1\n for node in new_graph:\n if len(new_graph[node]) > max_degree:\n max_degree = len(new_graph[node])\n max_degree_node = node\n\n neighbors = new_graph[max_degree_node]\n new_graph.pop(max_degree_node)\n for neighbor in neighbors:\n new_graph[neighbor].remove(max_degree_node)\n\n order.append(max_degree_node)\n return order","def targeted_order(ugraph):\n # copy the graph\n new_graph = copy_graph(ugraph)\n\n order = []\n while len(new_graph) > 0:\n max_degree = -1\n for node in new_graph:\n if len(new_graph[node]) > max_degree:\n max_degree = len(new_graph[node])\n max_degree_node = node\n\n neighbors = new_graph[max_degree_node]\n new_graph.pop(max_degree_node)\n for neighbor in neighbors:\n new_graph[neighbor].remove(max_degree_node)\n\n order.append(max_degree_node)\n return order","def dependency_order(self):\n seen = set()\n\n def _prune_visited(node):\n if node in seen:\n return True\n seen.add(node)\n return False\n\n for target in self.targets:\n if target in seen:\n continue\n for node in target.postorder(prune_fn=_prune_visited):\n yield node.data","def targeted_order(ugraph):\n # copy the graph\n new_graph = copy_graph(ugraph)\n \n order = []\n while len(new_graph) > 0:\n max_degree = -1\n for node in new_graph:\n if len(new_graph[node]) > max_degree:\n max_degree = len(new_graph[node])\n max_degree_node = node\n \n neighbors = new_graph[max_degree_node]\n new_graph.pop(max_degree_node)\n for neighbor in neighbors:\n new_graph[neighbor].remove(max_degree_node)\n \n order.append(max_degree_node)\n return order","def topo_sort(self):\n # TODO: detect cycles\n self.find_reachable_nodes()\n # save list of nodes in topo order\n self.nodes = []\n # assign each node an id field incrementally\n cur_id = 0\n # count visited outgoing edges for each node\n unvisited = {}\n for nid, node in list(self.found.items()):\n unvisited[nid] = node.nout\n queue = [self.root]\n #print >>sys.stderr, '+++'\n while queue:\n # take off nodes whose all outgoing edges are visited from\n # queue head\n node = queue.pop(0)\n self.nodes.append(node)\n node.hg = self\n node.id = cur_id\n cur_id += 1\n for edge in node.incoming:\n edge.hg = self\n for tailnode in edge.tail:\n #print >>sys.stderr, tailnode\n unvisited[id(tailnode)] -= 1\n if unvisited[id(tailnode)] == 0:\n queue.append(tailnode)\n self.sanity_check()\n self.tasks_done.add('topo_sort')","def _addReferees(self):\n a_ranks = self.division.GetGroupsRanks(['A'])\n b_ranks = self.division.GetGroupsRanks(['B'])\n c_ranks = self.division.GetGroupsRanks(['C'])\n d_ranks = self.division.GetGroupsRanks(['D'])\n\n self._GroupAddReferees('7th', [d_ranks[1]])\n self._GroupAddReferees('5th', [d_ranks[2]])\n\n self._GroupAddReferees('3rd',[d_ranks[0]])\n self._GroupAddReferees('final',[c_ranks[2]])","def get_order_from_tree(ids, tree_text):\r\n tree = parse_newick(tree_text, PhyloNode)\r\n ordered_ids = []\r\n for tip in tree.iterTips():\r\n if tip.Name in ids:\r\n ordered_ids.append(tip.Name)\r\n return names_to_indices(ids, ordered_ids)","def generate_tree_postorder(node_lst, root_index):","def get_nodes(self):\n if self.inode_ref is None or self.jnode_ref is None:\n raise ValueError('Node references have not been set.')\n return self.inode_ref, self.jnode_ref","def allParentsOf( self, chunkList, depth=0 ):\n final = []\n for c in chunkList:\n final.append( c )\n final.extend( self.allParentsOf( c.referencedBy, depth+1 ) )\n self.logger.debug( \"References: {0:>{indent}s} {1!s}\".format('--', final, indent=2*depth) )\n return final","def order(self):\n return self.n","def _reltype_ordering(self):\n return self.__reltype_ordering","def getReferences(self, fromnode):\n\n node = self.findNode(fromnode)\n out_edges, _ = self.get_edges(node)\n return out_edges","def orderings(self, function_graph):\r\n return OrderedDict()","def test_order_atoms_in_mol_list(self):\n ref_mol = Molecule(smiles='[CH](CC[CH]c1ccccc1)c1ccccc1')\n mol_list = ref_mol.copy(deep=True).generate_resonance_structures(keep_isomorphic=False, filter_structures=True)\n success = converter.order_atoms_in_mol_list(ref_mol=ref_mol, mol_list=mol_list)\n self.assertTrue(success)\n bond_dict = dict()\n for index1, atom1 in enumerate(ref_mol.atoms):\n for atom2 in atom1.edges.keys():\n index2 = ref_mol.atoms.index(atom2)\n if index1 < index2:\n if index1 not in bond_dict:\n bond_dict[index1] = [index2]\n else:\n bond_dict[index1].append(index2)\n for mol in mol_list:\n for index1, atom1 in enumerate(mol.atoms):\n for atom2 in atom1.edges.keys():\n index2 = mol.atoms.index(atom2)\n if index1 < index2:\n self.assertIn(index2, bond_dict[index1]) # check that these atoms are connected in all mols","def references(self):\n return self.header('References', '').split()","def createTopologicalList(self):\n sortedList = list(self.node.items())\n sortedList.sort(key=lambda item : item[1].order)\n self.topologicalList = [i[0] for i in sortedList]\n \n # Add dummy element, since topological order starts at 1.\n self.topologicalList = [utils.NO_PATH_EXISTS] + self.topologicalList","def sorting(self, presorted=None):\n self._sorted_nodes = []\n if presorted:\n notsorted_nodes = copy(presorted)\n else:\n notsorted_nodes = copy(self.nodes)\n predecessors = {key: copy(val) for (key, val) in self.predecessors.items()}\n\n # nodes that depends only on the self._nodes_wip should go first\n # soe remove them from the connections\n for nd_out in self._node_wip:\n for nd_in in self.successors[nd_out.name]:\n predecessors[nd_in.name].remove(nd_out)\n\n while notsorted_nodes:\n sorted_part, notsorted_nodes = self._sorting(notsorted_nodes, predecessors)\n self._sorted_nodes += sorted_part\n for nd_out in sorted_part:\n for nd_in in self.successors[nd_out.name]:\n predecessors[nd_in.name].remove(nd_out)","def n_refs(self):\n return self._n_refs","def sorted_nodes_names(self):\n return [nd.name for nd in self._sorted_nodes]","def order(self):\n pairs = [(w['source'][0], w['target'][0]) for w in self.wires]\n return processing_order(len(self.modules), pairs)","def topological_sort(self):\n\t\t#detect leaves\n\t\tnumChildren = dict((n.name,0) for n in self.variables.values())\n\t\tfor n in self.variables.itervalues():\n\t\t\tfor p in n.parents:\n\t\t\t numChildren[p]+=1\n\t\t#do a BFS from leaves to get the reverse topological sort\n\t\ttopo = []\n\t\tqueue = [n for (n,c) in numChildren.iteritems() if c==0]\n\t\tif len(queue)==0:\n\t\t\traise ValueError(\"Bayes net is not acyclic?\")\n\t\twhile len(queue)>0:\n\t\t\tn = self.variables[queue.pop(0)]\n\t\t\ttopo.append(n)\n\t\t\tfor p in n.parents:\n assert numChildren[p]>0\n numChildren[p] -= 1\n if numChildren[p]==0:\n queue.append(p)\n\t\t#now reverse it to get the top down ordering\n assert len(topo)==len(self.variables)\n\t\treturn reversed(topo)","def _order_entities(self):\n entity_deps = defaultdict(set)\n for e, features in self.top_level_features.items():\n # iterate over all dependency features of the top-level features on\n # this entity. If any of these are themselves top-level features, add\n # their entities as dependencies of the current entity.\n deps = {g.hash(): g for f in features\n for g in self.feature_dependencies[f.hash()]}\n for d in deps.values():\n _, num_forward = self.entityset.find_path(e, d.entity.id,\n include_num_forward=True)\n if num_forward > 0:\n entity_deps[e].add(d.entity.id)\n\n # Do a top-sort on the new entity DAG\n self.ordered_entities = utils.topsort([self.target_eid],\n lambda e: entity_deps[e])","def task1(graph, n):\r\n alreadyProcessed = set()\r\n B = [j for j in range(1,n+1)]\r\n position = {B[i]:i for i in range(len(B))}\r\n leftNeighbors = {}\r\n parent = {}\r\n \r\n for v in B:\r\n # nodes processed before the current that have an edge in common are left neighbors\r\n leftNeighbors[v] = set(graph._graph[v]) & alreadyProcessed\r\n alreadyProcessed.add(v)\r\n if leftNeighbors[v]:\r\n # the parent is the closest left neighbor \r\n parent[v] = B[max([position[w] for w in leftNeighbors[v]])]\r\n # if this node's neighbors (other then the parent itself) are not a subset of the parent's neighbors \r\n # it means that it's not a lexOrder\r\n if not leftNeighbors[v] - {parent[v]} <= leftNeighbors[parent[v]]:\r\n return []\r\n return B","def _partitioned_node_paths(self, node_refs):\n workflows = self._build_keyed_workflow_map()\n node_paths = self._all_node_paths()\n\n nodes = set()\n for node_ref in node_refs:\n path = node_ref.split('.')\n if len(path) > 2:\n raise Exception(\n 'Invalid node specification for nodes: {} (expected '\n 'a node spec of the form <workflow_name>.<node_name>, '\n 'or <node_name> for nodes in the primary workflow.'.format(\n node_ref))\n\n workflow_name = None if len(path) == 1 else path[0]\n node_name = path[0 if len(path) == 1 else 1]\n\n node = (workflow_name, node_name)\n nodes.add(node)\n\n if workflow_name not in workflows:\n raise InvalidWorkflowReference(\n 'Workflow {} not found in the dag!'.format(workflow_name))\n\n if node not in node_paths:\n raise InvalidNodeReference(\n 'Node {} not found in workflow {}!'.format(\n node_name,\n workflow_name))\n\n referenced_paths = list(map(node_paths.__getitem__, nodes))\n complement_paths = [path for (node, path) in six.iteritems(\n node_paths) if node not in nodes]\n\n return (referenced_paths, complement_paths)","def refCount(self, node):\n return self._references.get(node, 0)","def _update_ordering(self):\n self._descendants = sorted(self.unordered_descendants(), key=lambda node: node.ord)\n for (new_ord, node) in enumerate(self._descendants, 1):\n node.ord = new_ord","def node_link_num_data(th_object, start, end, file_name):\n # close\n node_link_num(th_object, start, end, file_name, \"20\", \"10\", \"extracted_data/Link_number/\")\n node_link_num(th_object, start, end, file_name, \"20\", \"30\", \"extracted_data/Link_number/\")\n node_link_num(th_object, start, end, file_name, \"22\", \"11\", \"extracted_data/Link_number/\")\n node_link_num(th_object, start, end, file_name, \"22\", \"31\", \"extracted_data/Link_number/\")\n node_link_num(th_object, start, end, file_name, \"22\", \"10\", \"extracted_data/Link_number/\")\n node_link_num(th_object, start, end, file_name, \"20\", \"31\", \"extracted_data/Link_number/\")\n node_link_num(th_object, start, end, file_name, \"20\", \"31\", \"extracted_data/Link_number/\")\n\n # far side\n node_link_num(th_object, start, end, file_name, \"20\", \"70\", \"extracted_data/Link_number/\")\n node_link_num(th_object, start, end, file_name, \"20\", \"90\", \"extracted_data/Link_number/\")\n node_link_num(th_object, start, end, file_name, \"22\", \"71\", \"extracted_data/Link_number/\")\n node_link_num(th_object, start, end, file_name, \"20\", \"91\", \"extracted_data/Link_number/\")\n node_link_num(th_object, start, end, file_name, \"22\", \"70\", \"extracted_data/Link_number/\")\n node_link_num(th_object, start, end, file_name, \"20\", \"91s\", \"extracted_data/Link_number/\")","def sort_apply_nodes(inputs, outputs, cmps):\r\n\r\n return posort(list_of_nodes(inputs, outputs), *cmps)","def _calc_refs(counts):\n refs = 0\n for allele in counts.keys():\n refs += counts[allele]\n return refs","def constructInteractions(nodeList, refNodes, refInteractions):\n outPathway = Pathway({}, {})\n for i in nodeList:\n outPathway.nodes[i] = refNodes[i]\n if i in refInteractions:\n for j in refInteractions[i].keys():\n if j in nodeList:\n if i not in outPathway.interactions:\n outPathway.interactions[i] = dict()\n outPathway.interactions[i][j] = refInteractions[i][j]\n return(outPathway.nodes, outPathway.interactions)","def enlist(self):\r\n list = self.enlist_helper(self.top_node)\r\n list.sort()\r\n return list","def get_refnodes(\n self, doctree: Node, result: list[dict[str, Any]],\n ) -> list[dict[str, Any]]:\n # XXX: is there a better way than checking the attribute\n # toctree-l[1-8] on the parent node?\n if isinstance(doctree, nodes.reference) and doctree.get('refuri'):\n refuri = doctree['refuri']\n if refuri.startswith(('http://', 'https://', 'irc:', 'mailto:')):\n return result\n classes = doctree.parent.attributes['classes']\n for level in range(8, 0, -1): # or range(1, 8)?\n if (self.toctree_template % level) in classes:\n result.append({\n 'level': level,\n 'refuri': html.escape(refuri),\n 'text': ssp(html.escape(doctree.astext())),\n })\n break\n elif isinstance(doctree, nodes.Element):\n for elem in doctree:\n result = self.get_refnodes(elem, result)\n return result","def walk_sort(edges):\n g = nx.Graph()\n g.add_edges_from(edges)\n connected = set()\n degree = nx.degree(g)\n ordering = []\n while degree:\n next = max_degree_node(g, degree, connected)\n if next is not None:\n ordering.append(next)\n else:\n break\n return ordering","def scc_order(self):\n if not self.__scc_order:\n self._tarjan()\n return self.__scc_order","def listOrdering(self):\r\n index = 0\r\n while( index < len(self.sortedList)-1):\r\n if(self.sortedList[index][2] > self.sortedList[index+1][2]): # positions in wrong order\r\n self.sortedList[index], self.sortedList[index+1] = self.sortedList[index+1], self.sortedList[index] # switch\r\n if(self.sortedList[index][2] == self.sortedList[index+1][2]): # Position conflict\r\n if(self.sortedList[index][1] <= self.sortedList[index+1][1]): # Already ordered by id\r\n self.sortedList[index+1][2] += 1 # position altered for second rule\r\n else:\r\n self.sortedList[index][2] += 1\r\n self.sortedList[index], self.sortedList[index+1] = self.sortedList[index+1], self.sortedList[index] # switch\r\n index += 1","def inorder(self):\n if len(self.children) == 0:\n return ['%s' % self.val]\n params = (' , ').join([' <N> '] * len(self.children))\n inorder = ['%s ( %s ) ' % (self.val, params)]\n for child in self.children:\n inorder += child.inorder()\n\n return inorder","def get_tagged_corefs(xml, ordered=False):\n nps = {}\n if ordered:\n nps = []\n\n xml = _normalize_malformed_xml(xml)\n\n try:\n corefs = parseString(xml).getElementsByTagName('COREF')\n except ExpatError:\n return nps\n\n for coref in corefs:\n try:\n cid = coref.attributes['ID'].value\n if ordered:\n data = {}\n for npid, np in nps:\n if npid == cid:\n data = np\n break\n else:\n data = nps.get(cid, {})\n except KeyError:\n continue\n\n try:\n data['ref'] = coref.attributes['REF'].value\n except KeyError:\n data['ref'] = None\n\n data['text'] = coref.firstChild.data\n if ordered:\n nps.append((cid, data))\n else:\n nps[cid] = data\n\n\n return nps","def toposorted(infos):\n key_to_info = {}\n depends = {}\n for info in infos:\n key_to_info[info.key] = info\n depends[info.key] = []\n for info in infos:\n for after in info.after:\n after_info = key_to_info[after]\n depends[info.key].append(after_info)\n for before in info.before:\n before_info = key_to_info[before]\n depends[before_info.key].append(info)\n return topological_sort(infos, lambda info: depends[info.key])","def references(self):\n return tuple(self.__references)","def references_list( self, theWeaver ):\n return [ (c.name, c.seq) \n for c in theWeaver.reference_style.chunkReferencedBy( self ) ]","def required_by(self, node):\n return sorted(self.__reverse_map[node], key=node_key)"],"string":"[\n \"def gather_references_orders (gdbval):\\n# TODO: Somehow also note speculative references and attributes in\\n# general\\n vec = gdbval[\\\"references\\\"]\\n return [int(i[\\\"referred\\\"][\\\"order\\\"]) for i in vec_iter(vec)]\",\n \"def angle_sort_adjacent_nodes(self,n,ref_nbr=None):\\n nbrs=self.node_to_nodes(n)\\n if len(nbrs)==0:\\n return []\\n diffs=self.nodes['x'][nbrs] - self.nodes['x'][n]\\n angles=np.arctan2(diffs[:,1],diffs[:,0])\\n nbrs=nbrs[np.argsort(angles)]\\n if ref_nbr is not None: \\n i=list(nbrs).index(ref_nbr)\\n nbrs=np.roll(nbrs,-i)\\n return nbrs\",\n \"def reference_nodes_idx(self) -> Dict[str, torch.Tensor]:\\n return self.node_idx_references\",\n \"def referencing_nodes(self):\\n\\n return self._referencing_nodes\",\n \"def get_reference_node_parents(ref):\\n parents = []\\n return parents\",\n \"def nodes_in_topological_order(self):\\n if not self.sorted:\\n self._topological_sort()\\n return self._topological_order\",\n \"def list_of_all_nodes_pointing_to_ref( s, ref ):\\n results = []\\n for node in s.nodes.values():\\n nodetype = sortof_type_str_of(node) \\n if nodetype == \\\"LIST\\\":\\n if ref in node:\\n results.append(node)\\n elif nodetype == \\\"DICT\\\":\\n if ref in node.values():\\n results.append(node)\\n return results\",\n \"def _sorting(self, notsorted_list, predecessors):\\n remaining_nodes = []\\n sorted_part = []\\n for nd in notsorted_list:\\n if not predecessors[nd.name]:\\n sorted_part.append(nd)\\n else:\\n remaining_nodes.append(nd)\\n return sorted_part, remaining_nodes\",\n \"def find_topo_sort(node_list):\\r\\n visited = set()\\r\\n topo_order = []\\r\\n #print(node_list)\\r\\n for node in node_list:\\r\\n topo_sort_dfs(node, visited, topo_order)\\r\\n return topo_order\",\n \"def _refind_nodes(self, reSearchItems, root=None, sortByDepth=False):\\n\\n reListOfSearchItems = list(reSearchItems)\\n\\n if root == None:\\n ReParent = reListOfSearchItems.pop(0)\\n Out = [x for x in self.ParentMap.keys() if ReParent.match(x.tag)]\\n\\n else:\\n Out = [root]\\n\\n\\n while len(reListOfSearchItems) > 0:\\n ReParent = reListOfSearchItems.pop(0)\\n Out = [x for root in Out for x in root.iter() if ReParent.match(x.tag)]\\n\\n if sortByDepth == False: return Out\\n\\n TDict = dict((x, len(self.get_path_to_node(x))) for x in Out)\\n return [o[0] for o in sorted(TDict.items(),key=lambda x:x[1])]\",\n \"def order(self):\\n return len(self._nodes)\",\n \"def get_compute_order(graph_def, input_node_name='', input_node_size=None):\\n name_to_node = parse_graph_nodes(graph_def)\\n node_info = collections.defaultdict(_node_info)\\n for each in graph_def.node:\\n _get_computed_nodes(name_to_node, each.name, node_info, input_node_name,\\n input_node_size)\\n return node_info, name_to_node\",\n \"def find_topo_sort(node_list):\\n visited = set()\\n topo_order = []\\n for node in node_list:\\n topo_sort_dfs(node, visited, topo_order)\\n return topo_order\",\n \"def find_topo_sort(node_list):\\n visited = set()\\n topo_order = []\\n for node in node_list:\\n topo_sort_dfs(node, visited, topo_order)\\n return topo_order\",\n \"def sort_nodes_by_n_reachable(graph):\\n list_of_node_and_reachables_tups = [] # stores the number of reachable nodes per node\\n # The following for loop finds the number of reachable nodes per node\\n for node_to_test in graph.nodes:\\n n_reachable = 0\\n # The following for loop checks each node if it is reachable from node_to_test. If so, adds to the counter\\n for node_is_reachable in graph.nodes:\\n if graph.is_reachable(node_to_test, node_is_reachable) and node_to_test != node_is_reachable:\\n n_reachable += 1\\n # Adds a tuple with the node_to_test and the counter of reachable nodes\\n list_of_node_and_reachables_tups.append((node_to_test, n_reachable))\\n # At this point we have a list with tuples including the node name and its reachables. Now need to sort them\\n sorted_nodes_by_reachable = sorted(list_of_node_and_reachables_tups, key=lambda tup: tup[1], reverse=True)\\n return sorted_nodes_by_reachable\",\n \"def toposort(adj):\\n # Memoize for visited vertex\\n used = [0] * len(adj)\\n order = []\\n # write your code here\\n # Traverse through each vertex\\n for i in range(len(adj)):\\n if not used[i]:\\n # If not visited, run dfs\\n dfs(adj, used, order, i)\\n\\n # Reverse the order list to show in descending order\\n order.reverse()\\n return order\",\n \"def findTopologicalOrder(self):\\n # This implementation temporarily messes with reverse stars, must fix at end\\n numOrderedNodes = 0\\n while numOrderedNodes < self.numNodes:\\n nextNode = self.findLeastEnteringLinks()\\n if len(self.node[nextNode].reverseStar) > 0:\\n print(\\\"Error: Network given to findTopologicalOrder contains a cycle.\\\")\\n raise BadNetworkOperationException\\n numOrderedNodes += 1\\n self.node[nextNode].order = numOrderedNodes\\n self.node[nextNode].reverseStar = [0] * self.numLinks\\n for ij in self.node[nextNode].forwardStar:\\n self.node[self.link[ij].head].reverseStar.remove(ij)\\n \\n # Repopulate reverse star list\\n for i in self.node:\\n self.node[i].reverseStar = list()\\n for ij in self.link:\\n self.node[self.link[ij].head].reverseStar.append(ij)\",\n \"def depends_on(self, node):\\n return sorted(self.__edge_map[node], key=node_key)\",\n \"def dmc_order(self):\\n return sorted(self.lookup_table, key=lambda clr: int(clr.id) if clr.id.isdigit() else 0)\",\n \"def reference_nodes_graph_idx(self) -> Dict[str, torch.Tensor]:\\n return self.node_graph_idx_reference\",\n \"def toposorted(self):\\n order = []\\n colors = {node: \\\"white\\\" for node in self._neighbors}\\n\\n def visit(node):\\n assert colors[node] == \\\"white\\\"\\n colors[node] = \\\"gray\\\"\\n for neighbor in self._neighbors[node]:\\n if colors[neighbor] == \\\"white\\\":\\n visit(neighbor)\\n elif colors[neighbor] == \\\"gray\\\":\\n raise CyclicGraphError(\\n \\\"Cycle involving {!r} and {!r} detected\\\".format(node, neighbor)\\n )\\n order.append(node)\\n colors[node] = \\\"black\\\"\\n\\n for node in self._neighbors:\\n if colors[node] == \\\"white\\\":\\n visit(node)\\n return order\",\n \"def referenced_nodes(self):\\n return self._referenced_nodes\",\n \"def rootSetOrder (self):\\n order = []\\n nodes = set(self.__nodes)\\n edge_map = {}\\n for (d, srcs) in six.iteritems(self.__edgeMap):\\n edge_map[d] = srcs.copy()\\n while nodes:\\n freeset = set()\\n for n in nodes:\\n if not (n in edge_map):\\n freeset.add(n)\\n if 0 == len(freeset):\\n _log.error('dependency cycle in named components')\\n return None\\n order.append(freeset)\\n nodes.difference_update(freeset)\\n new_edge_map = {}\\n for (d, srcs) in six.iteritems(edge_map):\\n srcs.difference_update(freeset)\\n if 0 != len(srcs):\\n new_edge_map[d] = srcs\\n edge_map = new_edge_map\\n return order\",\n \"def sorted_nodes_list(self):\\r\\n full_sorted_node_list = map(lambda k: k[0], sorted(self.graph.degree(),\\r\\n key=lambda k: k[1], reverse=True))\\r\\n return full_sorted_node_list\",\n \"def references(self):\\n ref_nodes = self.root.xpath(\\\".//bib-reference\\\")\\n return list(\\n itertools.chain.from_iterable(\\n self.get_reference_iter(node) for node in ref_nodes\\n )\\n )\",\n \"def targeted_order(ugraph):\\n # copy the graph\\n new_graph = copy_graph(ugraph)\\n \\n counter = 0\\n order = [] \\n while len(new_graph) > 0:\\n max_degree = -1\\n for node in new_graph:\\n counter += 1\\n if len(new_graph[node]) > max_degree:\\n max_degree = len(new_graph[node])\\n max_degree_node = node\\n \\n \\n neighbors = new_graph[max_degree_node]\\n new_graph.pop(max_degree_node)\\n for neighbor in neighbors:\\n counter += 1\\n new_graph[neighbor].remove(max_degree_node)\\n\\n order.append(max_degree_node)\\n return order # uncomment to use graph_resilience_targeted_order\",\n \"def list_ref_keys(self):\\n print('=======')\\n print('REFs')\\n print('=======')\\n for key in self.refs:\\n print(key)\",\n \"def _topological_sort(self):\\n\\n visited = defaultdict(bool)\\n stack = []\\n\\n for pod in self.pods:\\n if not visited[pod]:\\n self._topological_sort_pod(pod, visited, stack)\\n\\n return stack[::-1]\",\n \"def reorder(name_list, ref_list):\\n result = []\\n # Use the ordering in ref_list, to reassemble the name list:\\n for name in ref_list:\\n # These always come at the end\\n if name in ['FTP', 'RSYNC']:\\n continue\\n if name in name_list:\\n result.append(name)\\n # For any that were not in the reference list and are left over, tack\\n # them on to the end:\\n for name in name_list:\\n if name not in ref_list:\\n result.append(name)\\n # Finally, add these, so they are at the very end\\n for name in ref_list:\\n if name in name_list and name in ['FTP', 'RSYNC']:\\n result.append(name)\\n \\n # Make sure I have the same number I started with\\n assert(len(name_list) == len(result))\\n return result\",\n \"def dependents(sent,head): # head: node address\\n return sorted(chain.from_iterable(sent.nodes[head]\\\\\\n ['deps'].values()))\",\n \"def depth_node_ordering(start_node, end_nodes):\\n ordered_list = []\\n ordered_set = set()\\n working_list = [start_node]\\n while working_list != []:\\n node = working_list.pop(0)\\n if not node in ordered_set:\\n ordered_set.add(node)\\n ordered_list.append(node)\\n if not is_leaf_node(node) and not node in end_nodes:\\n for node_op in node.get_inputs():\\n working_list.append(node_op)\\n return ordered_list\",\n \"def order_bfs(self) -> List[Nodo]:\\n\\n # Nodos por buscar, es una cola\\n pending: List[Nodo] = [self.root]\\n # Nodos ya visitados\\n visited: List[Nodo] = []\\n\\n # Mientras la cola tenga items\\n while len(pending) > 0:\\n # Procesar el primer elemento\\n curr = pending.pop(0)\\n visited.append(curr)\\n\\n # Agregar los hijos no visitados del nodo a la cola\\n for child in curr.children:\\n if child in visited:\\n continue\\n pending.append(child)\\n\\n return visited\",\n \"def order_dfs(self) -> List[Nodo]:\\n # Nodos por buscar, es una pila\\n pending: List[Nodo] = [self.root]\\n # Nodos ya visitados\\n visited: List[Nodo] = []\\n\\n # Mientras la pila tenga items\\n while len(pending) > 0:\\n # Procesar el primer elemento\\n curr = pending.pop()\\n visited.append(curr)\\n\\n # Agregar los hijos no visitados del nodo a la pila\\n for child in reversed(curr.children):\\n if child in visited:\\n continue\\n pending.append(child)\\n\\n return visited\",\n \"def order_nodes(tree, increase=True):\\n res = tree.copy()\\n for node in res.postorder():\\n if node.is_tip():\\n node.n = 1\\n else:\\n node.n = sum(x.n for x in node.children)\\n for node in res.postorder():\\n if not node.is_tip():\\n children = node.children\\n node.children = []\\n for child in sorted(children, key=lambda x: x.n, reverse=increase):\\n node.append(child)\\n for node in res.postorder():\\n delattr(node, 'n')\\n return res\",\n \"def get_ordered_ids(tree):\\n ordered_ids = []\\n ordered_ids.extend(id(node) for node in tree.gen_tips())\\n ordered_ids.extend(id(node) for node in tree.gen_internal_nodes())\\n return ordered_ids\",\n \"def reorder_links(self, previous_node, links): # pragma: no cover\\n\\t\\treturn links\",\n \"def sorted_nodes(self):\\n if self._sorted_nodes is None:\\n self.sorting()\\n return self._sorted_nodes\",\n \"def get_ordered_nodes(self):\\n nodes = []\\n self.build_nodes_list(self.root, nodes)\\n return nodes\",\n \"def nreferences(self):\\n return self.__nreferences\",\n \"def number_nodes(tree):\\n def list_of_nodes(tree):\\n \\\"\\\"\\\"Return a list of internal nodes in postorder traversal\\n\\n @param HuffmanNode tree: a tree to traverse\\n @rtype: list\\n\\n >>> t = HuffmanNode(None, HuffmanNode(6), HuffmanNode(7))\\n >>> list_of_nodes(t) == [t]\\n True\\n >>> t = HuffmanNode(None, HuffmanNode(8), HuffmanNode(None, HuffmanNode(5), HuffmanNode(6)))\\n >>> list_of_nodes(t) == [HuffmanNode(None, HuffmanNode(5), HuffmanNode(6)), HuffmanNode(None, HuffmanNode(8), HuffmanNode(None, HuffmanNode(5), HuffmanNode(6)))]\\n True\\n \\\"\\\"\\\"\\n list_ = []\\n if tree.left.is_leaf() and tree.right.is_leaf():\\n list_.append(tree)\\n return list_\\n elif tree.left.is_leaf():\\n list_.extend(list_of_nodes(tree.right))\\n list_.append(tree)\\n return list_\\n elif tree.right.is_leaf():\\n list_.extend(list_of_nodes(tree.left))\\n list_.append(tree)\\n return list_\\n else:\\n list_.extend(list_of_nodes(tree.left))\\n list_.extend(list_of_nodes(tree.right))\\n list_.append(tree)\\n return list_\\n\\n internal_nodes = list_of_nodes(tree)\\n for i in range(len(internal_nodes)):\\n node = internal_nodes[i]\\n node.number = i\",\n \"def compute_node_positions(self):\\n pass\",\n \"def nodes(self):\\n data = list(self._nodes.values())\\n data.sort()\\n return data\",\n \"def list_refs(self):\\n pass\",\n \"def test_get_adjacency_list(self):\\n atom_features = np.array([[40, 41, 42, 43], [44, 45, 46, 47],\\n [48, 49, 50, 51], [52, 53, 54, 55],\\n [56, 57, 58, 59]])\\n canon_adj_list = [[1, 2], [0, 3], [0, 3], [1, 2, 4], [3]]\\n mol = ConvMol(atom_features, canon_adj_list)\\n # Sorting is done by atom degree as before. So the ordering goes\\n # 4, 0, 1, 2, 3 now in terms of the original ordering. The mapping\\n # from new position to old position is\\n # {(4, 0), (0, 1), (1, 2), (2, 3), (3, 4)}. Check that adjacency\\n # list respects this reordering and returns correct adjacency list.\\n assert (mol.get_adjacency_list() == [[4], [2, 3], [1, 4], [1, 4],\\n [2, 3, 0]])\",\n \"def sort_nodes(center_node, nodes):\\n def cmp(n1, n2):\\n angle1 = (math.degrees(center_node.angle_to(n1)) + 360.) % 360\\n angle2 = (math.degrees(center_node.angle_to(n2)) + 360.) % 360\\n\\n if angle1 < angle2:\\n return -1\\n elif angle1 == angle2:\\n return 0\\n else:\\n return 1\\n return sorted(nodes, cmp=cmp)\",\n \"def _sort_ns(self):\\n n = []\\n for layer in self.structure:\\n n.append(layer.get_index())\\n n = np.asarray(n)\\n return n\",\n \"def fast_target_order(ugraph):\\n result_order = []\\n num_nodes = len(ugraph.keys())\\n degrees = [set([]) for _ in range(num_nodes)]\\n for node in ugraph.keys():\\n node_degree = len(ugraph[node])\\n degrees[node_degree].add(node)\\n for degree in range(num_nodes - 1, -1, -1):\\n while degrees[degree] != set([]):\\n elem = degrees[degree].pop()\\n for neighbor in ugraph[elem]:\\n n_degree = len(ugraph[neighbor])\\n degrees[n_degree].remove(neighbor)\\n degrees[n_degree - 1].add(neighbor)\\n result_order.append(elem)\\n delete_node(ugraph, elem)\\n return result_order\",\n \"def order(self, searcher, docnums, reverse = False):\\n return docnums\",\n \"def test_circular_reference() -> None:\\n\\n t = generate_graph_resources(3)\\n field(t, (\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\")).references.append(\\n (FieldAddress(\\\"dr_2\\\", \\\"ds_2\\\", \\\"f1\\\"), \\\"to\\\")\\n )\\n field(t, (\\\"dr_2\\\", \\\"ds_2\\\", \\\"f2\\\")).references.append(\\n (FieldAddress(\\\"dr_3\\\", \\\"ds_3\\\", \\\"f2\\\"), \\\"to\\\")\\n )\\n field(t, (\\\"dr_3\\\", \\\"ds_3\\\", \\\"f3\\\")).references.append(\\n (FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f3\\\"), \\\"to\\\")\\n )\\n field(t, (\\\"dr_1\\\", \\\"ds_1\\\", \\\"f2\\\")).identity = \\\"email\\\"\\n traversal = Traversal(DatasetGraph(*t), {\\\"email\\\": \\\"X\\\"})\\n traversal_map, terminators = traversal.traversal_map()\\n assert traversal_map == {\\n \\\"__ROOT__:__ROOT__\\\": {\\\"from\\\": {}, \\\"to\\\": {\\\"dr_1:ds_1\\\": {\\\"email -> f2\\\"}}},\\n \\\"dr_1:ds_1\\\": {\\n \\\"from\\\": {\\\"__ROOT__:__ROOT__\\\": {\\\"email -> f2\\\"}, \\\"dr_3:ds_3\\\": {\\\"f3 -> f3\\\"}},\\n \\\"to\\\": {\\\"dr_2:ds_2\\\": {\\\"f1 -> f1\\\"}},\\n },\\n \\\"dr_2:ds_2\\\": {\\n \\\"from\\\": {\\\"dr_1:ds_1\\\": {\\\"f1 -> f1\\\"}},\\n \\\"to\\\": {\\\"dr_3:ds_3\\\": {\\\"f2 -> f2\\\"}},\\n },\\n \\\"dr_3:ds_3\\\": {\\n \\\"from\\\": {\\\"dr_2:ds_2\\\": {\\\"f2 -> f2\\\"}},\\n \\\"to\\\": {\\\"dr_1:ds_1\\\": {\\\"f3 -> f3\\\"}},\\n },\\n }\\n\\n assert terminators == [CollectionAddress(\\\"dr_1\\\", \\\"ds_1\\\")]\\n # this visits (root -> 1,1 -> 2,2 -> 3,3 -> 1,1) and then terminates.\\n assert generate_traversal_order(traversal) == {\\n CollectionAddress(\\\"__ROOT__\\\", \\\"__ROOT__\\\"): [0],\\n CollectionAddress(\\\"dr_1\\\", \\\"ds_1\\\"): [1, 4],\\n CollectionAddress(\\\"dr_2\\\", \\\"ds_2\\\"): [2],\\n CollectionAddress(\\\"dr_3\\\", \\\"ds_3\\\"): [3],\\n }\",\n \"def list_refs(self):\\n print('----\\\\nREFs\\\\n----')\\n self._print_dict(self.refs)\",\n \"def getSortedCyclicDependencies(self):\\n res = []\\n if self.isCircular():\\n res = [self.identifier if self.originalId is None else self.originalId]\\n # fill node inputs\\n nn = 0\\n while nn < len(res):\\n _node = res[nn]\\n for _inputId in self.model.getNode(_node).ioEngine.inputs:\\n input_node = self.model.getNode(_inputId)\\n if not _inputId in res and input_node.isCircular():\\n # check if node is in circle of _inputId\\n if _node in input_node.getFullInputs():\\n res.append(_inputId)\\n nn += 1\\n return res\",\n \"def get_adj_nodes(self):\\n return [\\n self.nearest_node + PVector(1, 0),\\n self.nearest_node + PVector(0, 1),\\n self.nearest_node + PVector(-1, 0),\\n self.nearest_node + PVector(0, -1)]\",\n \"def toposorted(resources):\\n # sort resources first so we have a deterministic order of nodes with the same partial order\\n resources = sorted(\\n resources,\\n key=lambda resource: (resource.type, resource.id),\\n )\\n\\n # build incoming and outgoing edges\\n nodes = {\\n resource.uri\\n for resource in resources\\n }\\n\\n incoming = defaultdict(set)\\n outgoing = defaultdict(set)\\n for resource in resources:\\n for parent in resource.parents:\\n if parent not in nodes:\\n # ignore references that lead outside of the current graph\\n continue\\n incoming[resource.uri].add(parent)\\n outgoing[parent].add(resource.uri)\\n\\n results = []\\n while resources:\\n remaining = []\\n for resource in resources:\\n if incoming[resource.uri]:\\n # node still has incoming edges\\n remaining.append(resource)\\n continue\\n\\n results.append(resource)\\n for child in outgoing[resource.uri]:\\n incoming[child].remove(resource.uri)\\n\\n if len(resources) == len(remaining):\\n raise Exception(\\\"Cycle detected\\\")\\n resources = remaining\\n\\n return results\",\n \"def nodes(self):\\n return self.sort_dict(self.trajectory_data)\",\n \"def topological_sort(self):\\n in_degree = {}\\n for node in self.graph:\\n in_degree[node] = 0\\n\\n for from_node in self.graph:\\n for to_node in self.graph[from_node]:\\n in_degree[to_node] += 1\\n\\n queue = deque()\\n for node in in_degree:\\n if in_degree[node] == 0:\\n queue.appendleft(node)\\n\\n sorted_nodes = []\\n while queue:\\n independent_node = queue.pop()\\n sorted_nodes.append(independent_node)\\n for next_node in self.graph[independent_node]:\\n in_degree[next_node] -= 1\\n if in_degree[next_node] == 0:\\n queue.appendleft(next_node)\\n\\n if len(sorted_nodes) == len(self.graph):\\n return sorted_nodes\\n else:\\n raise ValueError('graph is not acyclic')\",\n \"def targeted_order(ugraph):\\r\\n # copy the graph\\r\\n new_graph = copy_graph(ugraph)\\r\\n \\r\\n order = [] \\r\\n while len(new_graph) > 0:\\r\\n max_degree = -1\\r\\n for node in new_graph:\\r\\n if len(new_graph[node]) > max_degree:\\r\\n max_degree = len(new_graph[node])\\r\\n max_degree_node = node\\r\\n \\r\\n neighbors = new_graph[max_degree_node]\\r\\n new_graph.pop(max_degree_node)\\r\\n for neighbor in neighbors:\\r\\n new_graph[neighbor].remove(max_degree_node)\\r\\n\\r\\n order.append(max_degree_node)\\r\\n return order\",\n \"def degeneracy_ordering(self):\\n return sorted(self._adjacency_map, key=self.degree)\",\n \"def fast_targeted_order(ugraph):\\n\\n graph = copy_graph(ugraph)\\n# print graph\\n size = len(ugraph) #- 1\\n degree_sets = [set() for _ in range(size)]\\n order = []\\n\\n for node, edges in ugraph.iteritems():\\n degree = len(edges)\\n degree_sets[degree].add(node)\\n# print degree_sets\\n\\n for k in range(size - 1, -1, -1):\\n while degree_sets[k]:\\n node = degree_sets[k].pop()\\n neighbors = graph[node]\\n for neighbor in neighbors:\\n degree = len(graph[neighbor])\\n degree_sets[degree].remove(neighbor)\\n degree_sets[degree - 1].add(neighbor)\\n order.append(node)\\n delete_node(graph, node)\\n return order\",\n \"def targeted_order(ugraph):\\n # copy the graph\\n new_graph = copy_graph(ugraph)\\n\\n order = []\\n while len(new_graph) > 0:\\n max_degree = -1\\n for node in new_graph:\\n if len(new_graph[node]) > max_degree:\\n max_degree = len(new_graph[node])\\n max_degree_node = node\\n\\n neighbors = new_graph[max_degree_node]\\n new_graph.pop(max_degree_node)\\n for neighbor in neighbors:\\n new_graph[neighbor].remove(max_degree_node)\\n\\n order.append(max_degree_node)\\n return order\",\n \"def targeted_order(ugraph):\\n # copy the graph\\n new_graph = copy_graph(ugraph)\\n\\n order = []\\n while len(new_graph) > 0:\\n max_degree = -1\\n for node in new_graph:\\n if len(new_graph[node]) > max_degree:\\n max_degree = len(new_graph[node])\\n max_degree_node = node\\n\\n neighbors = new_graph[max_degree_node]\\n new_graph.pop(max_degree_node)\\n for neighbor in neighbors:\\n new_graph[neighbor].remove(max_degree_node)\\n\\n order.append(max_degree_node)\\n return order\",\n \"def dependency_order(self):\\n seen = set()\\n\\n def _prune_visited(node):\\n if node in seen:\\n return True\\n seen.add(node)\\n return False\\n\\n for target in self.targets:\\n if target in seen:\\n continue\\n for node in target.postorder(prune_fn=_prune_visited):\\n yield node.data\",\n \"def targeted_order(ugraph):\\n # copy the graph\\n new_graph = copy_graph(ugraph)\\n \\n order = []\\n while len(new_graph) > 0:\\n max_degree = -1\\n for node in new_graph:\\n if len(new_graph[node]) > max_degree:\\n max_degree = len(new_graph[node])\\n max_degree_node = node\\n \\n neighbors = new_graph[max_degree_node]\\n new_graph.pop(max_degree_node)\\n for neighbor in neighbors:\\n new_graph[neighbor].remove(max_degree_node)\\n \\n order.append(max_degree_node)\\n return order\",\n \"def topo_sort(self):\\n # TODO: detect cycles\\n self.find_reachable_nodes()\\n # save list of nodes in topo order\\n self.nodes = []\\n # assign each node an id field incrementally\\n cur_id = 0\\n # count visited outgoing edges for each node\\n unvisited = {}\\n for nid, node in list(self.found.items()):\\n unvisited[nid] = node.nout\\n queue = [self.root]\\n #print >>sys.stderr, '+++'\\n while queue:\\n # take off nodes whose all outgoing edges are visited from\\n # queue head\\n node = queue.pop(0)\\n self.nodes.append(node)\\n node.hg = self\\n node.id = cur_id\\n cur_id += 1\\n for edge in node.incoming:\\n edge.hg = self\\n for tailnode in edge.tail:\\n #print >>sys.stderr, tailnode\\n unvisited[id(tailnode)] -= 1\\n if unvisited[id(tailnode)] == 0:\\n queue.append(tailnode)\\n self.sanity_check()\\n self.tasks_done.add('topo_sort')\",\n \"def _addReferees(self):\\n a_ranks = self.division.GetGroupsRanks(['A'])\\n b_ranks = self.division.GetGroupsRanks(['B'])\\n c_ranks = self.division.GetGroupsRanks(['C'])\\n d_ranks = self.division.GetGroupsRanks(['D'])\\n\\n self._GroupAddReferees('7th', [d_ranks[1]])\\n self._GroupAddReferees('5th', [d_ranks[2]])\\n\\n self._GroupAddReferees('3rd',[d_ranks[0]])\\n self._GroupAddReferees('final',[c_ranks[2]])\",\n \"def get_order_from_tree(ids, tree_text):\\r\\n tree = parse_newick(tree_text, PhyloNode)\\r\\n ordered_ids = []\\r\\n for tip in tree.iterTips():\\r\\n if tip.Name in ids:\\r\\n ordered_ids.append(tip.Name)\\r\\n return names_to_indices(ids, ordered_ids)\",\n \"def generate_tree_postorder(node_lst, root_index):\",\n \"def get_nodes(self):\\n if self.inode_ref is None or self.jnode_ref is None:\\n raise ValueError('Node references have not been set.')\\n return self.inode_ref, self.jnode_ref\",\n \"def allParentsOf( self, chunkList, depth=0 ):\\n final = []\\n for c in chunkList:\\n final.append( c )\\n final.extend( self.allParentsOf( c.referencedBy, depth+1 ) )\\n self.logger.debug( \\\"References: {0:>{indent}s} {1!s}\\\".format('--', final, indent=2*depth) )\\n return final\",\n \"def order(self):\\n return self.n\",\n \"def _reltype_ordering(self):\\n return self.__reltype_ordering\",\n \"def getReferences(self, fromnode):\\n\\n node = self.findNode(fromnode)\\n out_edges, _ = self.get_edges(node)\\n return out_edges\",\n \"def orderings(self, function_graph):\\r\\n return OrderedDict()\",\n \"def test_order_atoms_in_mol_list(self):\\n ref_mol = Molecule(smiles='[CH](CC[CH]c1ccccc1)c1ccccc1')\\n mol_list = ref_mol.copy(deep=True).generate_resonance_structures(keep_isomorphic=False, filter_structures=True)\\n success = converter.order_atoms_in_mol_list(ref_mol=ref_mol, mol_list=mol_list)\\n self.assertTrue(success)\\n bond_dict = dict()\\n for index1, atom1 in enumerate(ref_mol.atoms):\\n for atom2 in atom1.edges.keys():\\n index2 = ref_mol.atoms.index(atom2)\\n if index1 < index2:\\n if index1 not in bond_dict:\\n bond_dict[index1] = [index2]\\n else:\\n bond_dict[index1].append(index2)\\n for mol in mol_list:\\n for index1, atom1 in enumerate(mol.atoms):\\n for atom2 in atom1.edges.keys():\\n index2 = mol.atoms.index(atom2)\\n if index1 < index2:\\n self.assertIn(index2, bond_dict[index1]) # check that these atoms are connected in all mols\",\n \"def references(self):\\n return self.header('References', '').split()\",\n \"def createTopologicalList(self):\\n sortedList = list(self.node.items())\\n sortedList.sort(key=lambda item : item[1].order)\\n self.topologicalList = [i[0] for i in sortedList]\\n \\n # Add dummy element, since topological order starts at 1.\\n self.topologicalList = [utils.NO_PATH_EXISTS] + self.topologicalList\",\n \"def sorting(self, presorted=None):\\n self._sorted_nodes = []\\n if presorted:\\n notsorted_nodes = copy(presorted)\\n else:\\n notsorted_nodes = copy(self.nodes)\\n predecessors = {key: copy(val) for (key, val) in self.predecessors.items()}\\n\\n # nodes that depends only on the self._nodes_wip should go first\\n # soe remove them from the connections\\n for nd_out in self._node_wip:\\n for nd_in in self.successors[nd_out.name]:\\n predecessors[nd_in.name].remove(nd_out)\\n\\n while notsorted_nodes:\\n sorted_part, notsorted_nodes = self._sorting(notsorted_nodes, predecessors)\\n self._sorted_nodes += sorted_part\\n for nd_out in sorted_part:\\n for nd_in in self.successors[nd_out.name]:\\n predecessors[nd_in.name].remove(nd_out)\",\n \"def n_refs(self):\\n return self._n_refs\",\n \"def sorted_nodes_names(self):\\n return [nd.name for nd in self._sorted_nodes]\",\n \"def order(self):\\n pairs = [(w['source'][0], w['target'][0]) for w in self.wires]\\n return processing_order(len(self.modules), pairs)\",\n \"def topological_sort(self):\\n\\t\\t#detect leaves\\n\\t\\tnumChildren = dict((n.name,0) for n in self.variables.values())\\n\\t\\tfor n in self.variables.itervalues():\\n\\t\\t\\tfor p in n.parents:\\n\\t\\t\\t numChildren[p]+=1\\n\\t\\t#do a BFS from leaves to get the reverse topological sort\\n\\t\\ttopo = []\\n\\t\\tqueue = [n for (n,c) in numChildren.iteritems() if c==0]\\n\\t\\tif len(queue)==0:\\n\\t\\t\\traise ValueError(\\\"Bayes net is not acyclic?\\\")\\n\\t\\twhile len(queue)>0:\\n\\t\\t\\tn = self.variables[queue.pop(0)]\\n\\t\\t\\ttopo.append(n)\\n\\t\\t\\tfor p in n.parents:\\n assert numChildren[p]>0\\n numChildren[p] -= 1\\n if numChildren[p]==0:\\n queue.append(p)\\n\\t\\t#now reverse it to get the top down ordering\\n assert len(topo)==len(self.variables)\\n\\t\\treturn reversed(topo)\",\n \"def _order_entities(self):\\n entity_deps = defaultdict(set)\\n for e, features in self.top_level_features.items():\\n # iterate over all dependency features of the top-level features on\\n # this entity. If any of these are themselves top-level features, add\\n # their entities as dependencies of the current entity.\\n deps = {g.hash(): g for f in features\\n for g in self.feature_dependencies[f.hash()]}\\n for d in deps.values():\\n _, num_forward = self.entityset.find_path(e, d.entity.id,\\n include_num_forward=True)\\n if num_forward > 0:\\n entity_deps[e].add(d.entity.id)\\n\\n # Do a top-sort on the new entity DAG\\n self.ordered_entities = utils.topsort([self.target_eid],\\n lambda e: entity_deps[e])\",\n \"def task1(graph, n):\\r\\n alreadyProcessed = set()\\r\\n B = [j for j in range(1,n+1)]\\r\\n position = {B[i]:i for i in range(len(B))}\\r\\n leftNeighbors = {}\\r\\n parent = {}\\r\\n \\r\\n for v in B:\\r\\n # nodes processed before the current that have an edge in common are left neighbors\\r\\n leftNeighbors[v] = set(graph._graph[v]) & alreadyProcessed\\r\\n alreadyProcessed.add(v)\\r\\n if leftNeighbors[v]:\\r\\n # the parent is the closest left neighbor \\r\\n parent[v] = B[max([position[w] for w in leftNeighbors[v]])]\\r\\n # if this node's neighbors (other then the parent itself) are not a subset of the parent's neighbors \\r\\n # it means that it's not a lexOrder\\r\\n if not leftNeighbors[v] - {parent[v]} <= leftNeighbors[parent[v]]:\\r\\n return []\\r\\n return B\",\n \"def _partitioned_node_paths(self, node_refs):\\n workflows = self._build_keyed_workflow_map()\\n node_paths = self._all_node_paths()\\n\\n nodes = set()\\n for node_ref in node_refs:\\n path = node_ref.split('.')\\n if len(path) > 2:\\n raise Exception(\\n 'Invalid node specification for nodes: {} (expected '\\n 'a node spec of the form <workflow_name>.<node_name>, '\\n 'or <node_name> for nodes in the primary workflow.'.format(\\n node_ref))\\n\\n workflow_name = None if len(path) == 1 else path[0]\\n node_name = path[0 if len(path) == 1 else 1]\\n\\n node = (workflow_name, node_name)\\n nodes.add(node)\\n\\n if workflow_name not in workflows:\\n raise InvalidWorkflowReference(\\n 'Workflow {} not found in the dag!'.format(workflow_name))\\n\\n if node not in node_paths:\\n raise InvalidNodeReference(\\n 'Node {} not found in workflow {}!'.format(\\n node_name,\\n workflow_name))\\n\\n referenced_paths = list(map(node_paths.__getitem__, nodes))\\n complement_paths = [path for (node, path) in six.iteritems(\\n node_paths) if node not in nodes]\\n\\n return (referenced_paths, complement_paths)\",\n \"def refCount(self, node):\\n return self._references.get(node, 0)\",\n \"def _update_ordering(self):\\n self._descendants = sorted(self.unordered_descendants(), key=lambda node: node.ord)\\n for (new_ord, node) in enumerate(self._descendants, 1):\\n node.ord = new_ord\",\n \"def node_link_num_data(th_object, start, end, file_name):\\n # close\\n node_link_num(th_object, start, end, file_name, \\\"20\\\", \\\"10\\\", \\\"extracted_data/Link_number/\\\")\\n node_link_num(th_object, start, end, file_name, \\\"20\\\", \\\"30\\\", \\\"extracted_data/Link_number/\\\")\\n node_link_num(th_object, start, end, file_name, \\\"22\\\", \\\"11\\\", \\\"extracted_data/Link_number/\\\")\\n node_link_num(th_object, start, end, file_name, \\\"22\\\", \\\"31\\\", \\\"extracted_data/Link_number/\\\")\\n node_link_num(th_object, start, end, file_name, \\\"22\\\", \\\"10\\\", \\\"extracted_data/Link_number/\\\")\\n node_link_num(th_object, start, end, file_name, \\\"20\\\", \\\"31\\\", \\\"extracted_data/Link_number/\\\")\\n node_link_num(th_object, start, end, file_name, \\\"20\\\", \\\"31\\\", \\\"extracted_data/Link_number/\\\")\\n\\n # far side\\n node_link_num(th_object, start, end, file_name, \\\"20\\\", \\\"70\\\", \\\"extracted_data/Link_number/\\\")\\n node_link_num(th_object, start, end, file_name, \\\"20\\\", \\\"90\\\", \\\"extracted_data/Link_number/\\\")\\n node_link_num(th_object, start, end, file_name, \\\"22\\\", \\\"71\\\", \\\"extracted_data/Link_number/\\\")\\n node_link_num(th_object, start, end, file_name, \\\"20\\\", \\\"91\\\", \\\"extracted_data/Link_number/\\\")\\n node_link_num(th_object, start, end, file_name, \\\"22\\\", \\\"70\\\", \\\"extracted_data/Link_number/\\\")\\n node_link_num(th_object, start, end, file_name, \\\"20\\\", \\\"91s\\\", \\\"extracted_data/Link_number/\\\")\",\n \"def sort_apply_nodes(inputs, outputs, cmps):\\r\\n\\r\\n return posort(list_of_nodes(inputs, outputs), *cmps)\",\n \"def _calc_refs(counts):\\n refs = 0\\n for allele in counts.keys():\\n refs += counts[allele]\\n return refs\",\n \"def constructInteractions(nodeList, refNodes, refInteractions):\\n outPathway = Pathway({}, {})\\n for i in nodeList:\\n outPathway.nodes[i] = refNodes[i]\\n if i in refInteractions:\\n for j in refInteractions[i].keys():\\n if j in nodeList:\\n if i not in outPathway.interactions:\\n outPathway.interactions[i] = dict()\\n outPathway.interactions[i][j] = refInteractions[i][j]\\n return(outPathway.nodes, outPathway.interactions)\",\n \"def enlist(self):\\r\\n list = self.enlist_helper(self.top_node)\\r\\n list.sort()\\r\\n return list\",\n \"def get_refnodes(\\n self, doctree: Node, result: list[dict[str, Any]],\\n ) -> list[dict[str, Any]]:\\n # XXX: is there a better way than checking the attribute\\n # toctree-l[1-8] on the parent node?\\n if isinstance(doctree, nodes.reference) and doctree.get('refuri'):\\n refuri = doctree['refuri']\\n if refuri.startswith(('http://', 'https://', 'irc:', 'mailto:')):\\n return result\\n classes = doctree.parent.attributes['classes']\\n for level in range(8, 0, -1): # or range(1, 8)?\\n if (self.toctree_template % level) in classes:\\n result.append({\\n 'level': level,\\n 'refuri': html.escape(refuri),\\n 'text': ssp(html.escape(doctree.astext())),\\n })\\n break\\n elif isinstance(doctree, nodes.Element):\\n for elem in doctree:\\n result = self.get_refnodes(elem, result)\\n return result\",\n \"def walk_sort(edges):\\n g = nx.Graph()\\n g.add_edges_from(edges)\\n connected = set()\\n degree = nx.degree(g)\\n ordering = []\\n while degree:\\n next = max_degree_node(g, degree, connected)\\n if next is not None:\\n ordering.append(next)\\n else:\\n break\\n return ordering\",\n \"def scc_order(self):\\n if not self.__scc_order:\\n self._tarjan()\\n return self.__scc_order\",\n \"def listOrdering(self):\\r\\n index = 0\\r\\n while( index < len(self.sortedList)-1):\\r\\n if(self.sortedList[index][2] > self.sortedList[index+1][2]): # positions in wrong order\\r\\n self.sortedList[index], self.sortedList[index+1] = self.sortedList[index+1], self.sortedList[index] # switch\\r\\n if(self.sortedList[index][2] == self.sortedList[index+1][2]): # Position conflict\\r\\n if(self.sortedList[index][1] <= self.sortedList[index+1][1]): # Already ordered by id\\r\\n self.sortedList[index+1][2] += 1 # position altered for second rule\\r\\n else:\\r\\n self.sortedList[index][2] += 1\\r\\n self.sortedList[index], self.sortedList[index+1] = self.sortedList[index+1], self.sortedList[index] # switch\\r\\n index += 1\",\n \"def inorder(self):\\n if len(self.children) == 0:\\n return ['%s' % self.val]\\n params = (' , ').join([' <N> '] * len(self.children))\\n inorder = ['%s ( %s ) ' % (self.val, params)]\\n for child in self.children:\\n inorder += child.inorder()\\n\\n return inorder\",\n \"def get_tagged_corefs(xml, ordered=False):\\n nps = {}\\n if ordered:\\n nps = []\\n\\n xml = _normalize_malformed_xml(xml)\\n\\n try:\\n corefs = parseString(xml).getElementsByTagName('COREF')\\n except ExpatError:\\n return nps\\n\\n for coref in corefs:\\n try:\\n cid = coref.attributes['ID'].value\\n if ordered:\\n data = {}\\n for npid, np in nps:\\n if npid == cid:\\n data = np\\n break\\n else:\\n data = nps.get(cid, {})\\n except KeyError:\\n continue\\n\\n try:\\n data['ref'] = coref.attributes['REF'].value\\n except KeyError:\\n data['ref'] = None\\n\\n data['text'] = coref.firstChild.data\\n if ordered:\\n nps.append((cid, data))\\n else:\\n nps[cid] = data\\n\\n\\n return nps\",\n \"def toposorted(infos):\\n key_to_info = {}\\n depends = {}\\n for info in infos:\\n key_to_info[info.key] = info\\n depends[info.key] = []\\n for info in infos:\\n for after in info.after:\\n after_info = key_to_info[after]\\n depends[info.key].append(after_info)\\n for before in info.before:\\n before_info = key_to_info[before]\\n depends[before_info.key].append(info)\\n return topological_sort(infos, lambda info: depends[info.key])\",\n \"def references(self):\\n return tuple(self.__references)\",\n \"def references_list( self, theWeaver ):\\n return [ (c.name, c.seq) \\n for c in theWeaver.reference_style.chunkReferencedBy( self ) ]\",\n \"def required_by(self, node):\\n return sorted(self.__reverse_map[node], key=node_key)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7483979","0.6498939","0.60103464","0.59589404","0.592434","0.58175755","0.57886195","0.57791865","0.5778693","0.5724725","0.5648295","0.56302035","0.56052834","0.56052834","0.55912304","0.55762887","0.55696046","0.55564326","0.5543322","0.55140626","0.5509287","0.5503459","0.550083","0.5495144","0.54365057","0.54300624","0.54293966","0.54293627","0.5421236","0.5412274","0.539919","0.5374625","0.5361106","0.5348458","0.53445333","0.53398204","0.5334866","0.5332612","0.53310597","0.5321608","0.53200966","0.5319132","0.5314142","0.5295915","0.5286062","0.5285926","0.52803725","0.527589","0.52642167","0.5252621","0.52459943","0.5239207","0.5229275","0.52249897","0.5221252","0.51978046","0.5190709","0.5179104","0.5167664","0.5167664","0.5164533","0.51572734","0.51513886","0.5147298","0.5146823","0.5140444","0.513264","0.51308346","0.5126068","0.51239246","0.51218176","0.51213235","0.5103477","0.50996643","0.5095615","0.50834435","0.5082992","0.50791514","0.5071817","0.50691724","0.50658417","0.5055597","0.50548935","0.5049725","0.5038618","0.50368315","0.5031945","0.5030823","0.5027879","0.5022672","0.50213206","0.50183165","0.5017953","0.5017174","0.50167805","0.5013956","0.5002434","0.5001927","0.49986485","0.4996983"],"string":"[\n \"0.7483979\",\n \"0.6498939\",\n \"0.60103464\",\n \"0.59589404\",\n \"0.592434\",\n \"0.58175755\",\n \"0.57886195\",\n \"0.57791865\",\n \"0.5778693\",\n \"0.5724725\",\n \"0.5648295\",\n \"0.56302035\",\n \"0.56052834\",\n \"0.56052834\",\n \"0.55912304\",\n \"0.55762887\",\n \"0.55696046\",\n \"0.55564326\",\n \"0.5543322\",\n \"0.55140626\",\n \"0.5509287\",\n \"0.5503459\",\n \"0.550083\",\n \"0.5495144\",\n \"0.54365057\",\n \"0.54300624\",\n \"0.54293966\",\n \"0.54293627\",\n \"0.5421236\",\n \"0.5412274\",\n \"0.539919\",\n \"0.5374625\",\n \"0.5361106\",\n \"0.5348458\",\n \"0.53445333\",\n \"0.53398204\",\n \"0.5334866\",\n \"0.5332612\",\n \"0.53310597\",\n \"0.5321608\",\n \"0.53200966\",\n \"0.5319132\",\n \"0.5314142\",\n \"0.5295915\",\n \"0.5286062\",\n \"0.5285926\",\n \"0.52803725\",\n \"0.527589\",\n \"0.52642167\",\n \"0.5252621\",\n \"0.52459943\",\n \"0.5239207\",\n \"0.5229275\",\n \"0.52249897\",\n \"0.5221252\",\n \"0.51978046\",\n \"0.5190709\",\n \"0.5179104\",\n \"0.5167664\",\n \"0.5167664\",\n \"0.5164533\",\n \"0.51572734\",\n \"0.51513886\",\n \"0.5147298\",\n \"0.5146823\",\n \"0.5140444\",\n \"0.513264\",\n \"0.51308346\",\n \"0.5126068\",\n \"0.51239246\",\n \"0.51218176\",\n \"0.51213235\",\n \"0.5103477\",\n \"0.50996643\",\n \"0.5095615\",\n \"0.50834435\",\n \"0.5082992\",\n \"0.50791514\",\n \"0.5071817\",\n \"0.50691724\",\n \"0.50658417\",\n \"0.5055597\",\n \"0.50548935\",\n \"0.5049725\",\n \"0.5038618\",\n \"0.50368315\",\n \"0.5031945\",\n \"0.5030823\",\n \"0.5027879\",\n \"0.5022672\",\n \"0.50213206\",\n \"0.50183165\",\n \"0.5017953\",\n \"0.5017174\",\n \"0.50167805\",\n \"0.5013956\",\n \"0.5002434\",\n \"0.5001927\",\n \"0.49986485\",\n \"0.4996983\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70957726"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":15196,"cells":{"query":{"kind":"string","value":"Build and return our representation of the symbol table"},"document":{"kind":"string","value":"def build_gdb_symbol_table():\n\n tab = Symtab()\n n = gdb.parse_and_eval (\"symtab->nodes\")\n while (long(n)):\n if symtab_node_is_function (n):\n current_symbol = GdbFunction(tab, n)\n tab.all_functions.append (current_symbol)\n elif symtab_node_is_variable (n):\n current_symbol = GdbVariable(tab, n)\n tab.all_variables.append (current_symbol)\n else:\n raise gdb.GdbError (\"Encountered an unknown symbol table node\");\n\n tab.order_to_sym[current_symbol.order] = current_symbol\n tab.all_symbols.append (current_symbol)\n\n n = n[\"next\"]\n pass\n\n tab.fixup()\n return tab"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __str__(self):\n dictt = self.getFullDict()\n return \"SymbolTable(\\n{}\\n)\".format(pprint.pformat(dictt))","def symbol_table(self) -> str:\n return self._symbol_table","def getSymbolTable(self) -> ghidra.app.util.bin.format.pe.debug.DebugCodeViewSymbolTable:\n ...","def __init__(self, DEBUG=False):\n self.DEBUG = DEBUG\n\n self.classTable = {}\n self.subroutineTable = {}\n\n self.counts = {}\n self.counts[\"STATIC\"] = 0\n self.counts[\"FIELD\"] = 0\n self.counts[\"ARG\"] = 0\n self.counts[\"VAR\"] = 0\n\n if self.DEBUG:\n print(\"DEBUG(SymbolTable): INITIALIZED SYMBOL TABLES\")","def generate_symbol_struct(mode, symbols, definition):\n if \"vanilla\" == mode:\n return \"\"\n definitions = []\n hashes = []\n symbol_table_content = \"\"\n for ii in symbols:\n definitions += [\" %s;\" % (ii.generate_definition())]\n hashes += [\" %s%s,\" % (ii.generate_prototype(), ii.get_hash())]\n if \"dlfcn\" != mode:\n symbol_table_content = \" =\\n{\\n%s\\n}\" % (\"\\n\".join(hashes))\n return template_symbol_table % (definition, \"\\n\".join(definitions), symbol_table_content)","def __str__(self) -> str:\n\n return self._format_symbol_table_content(\"Symbol table\", self._symbols.items())","def generate_table(self):\n states = self.get_canonical_collection()\n # self.print_canonical_collection(states)\n table = [{} for _ in range(len(states))]\n\n for index in range(len(states)):\n state = states[index]\n first_rule_cnt = 0\n second_rule_cnt = 0\n third_rule_cnt = 0\n beta = []\n for prod in state:\n dot_index = prod[1].index('.')\n alpha = prod[1][:dot_index]\n beta = prod[1][dot_index + 1:]\n if len(beta) != 0:\n first_rule_cnt += 1\n else:\n if prod[0] != 'S1':\n second_rule_cnt += 1\n production_index = self.grammar.P.index((prod[0], alpha))\n elif alpha == [self.grammar.S[0]]:\n third_rule_cnt += 1\n if first_rule_cnt == len(state):\n table[index]['action'] = 'shift'\n\n elif second_rule_cnt == len(state):\n table[index]['action'] = 'reduce ' + str(production_index)\n\n elif third_rule_cnt == len(state):\n table[index]['action'] = 'acc'\n else:\n conflict_msg = 'Conflict! State I' + str(index) + ': ' + str(state) + '\\nSymbol: ' + beta[0]\n raise (Exception(conflict_msg))\n for symbol in self.grammar.N + self.grammar.E: # the goto part of the table\n next_state = self.go_to(state, symbol)\n if next_state in states:\n table[index][symbol] = states.index(next_state)\n # print(\"table\", table)\n return table","def __init__(self):\r\n self.s_table = SymbolTable.preSymbols","def __generate_symboltable(self, code):\n\n code_without_lables = []\n address = 0\n for line in code:\n label_code = line.split(':')\n label = label_code[0]\n if len(label) != len(line):\n self.__symboltable[label] = address\n address += REG_SIZE\n instruction = label_code.pop().strip()\n code_without_lables = code_without_lables + [instruction]\n else:\n instruction = label_code.pop().strip()\n code_without_lables = code_without_lables + [instruction]\n\n tokens = instruction.split(' ')\n asm_directive = tokens[0]\n if tokens[0] in AssemblerDirectives.to_string():\n if asm_directive == AssemblerDirectives.ORG.name:\n address = int(tokens[1])\n else:\n address += REG_SIZE\n\n return code_without_lables","def __init__(self, epsilon=EPSILON):\n cdef bytes name = 'SymbolTable<{0}>'.format(id(self)).encode('ascii')\n self.table = new sym.SymbolTable(<string> name)\n assert (self[epsilon] == EPSILON_ID)","def create_symbol_table(root):\n\n set_depth(root, 0)\n #Initialize the stack, with the AST root\n stack = Stack(root)\n\n #the symbol table maps the name to the scope.\n #Any node can belong to multiple scopes, therefore this\n #is a list of scope\n symbol_table = STable()\n \n #this represents objects imported from\n #other modules\n other_modules = {}\n\n for node, children, ntype in stack:\n\n if ntype == \"Import\":\n #Import object has names prop which\n #is an array of names\n for name in node.names:\n #name can be the name or an alias \n name_val = name.asname or name.name\n #insert in symbol_table \n symbol_table[name_val] = ()\n\n elif ntype == \"ImportFrom\":\n if node.names[0].name == '*':\n try:\n imp_mod = importlib.import_module(node.module)\n #Add all names in imported module, except those\n #starting with '_'\n for name in dir(imp_mod):\n if name[0] != '_':\n symbol_table[name] = stack_top(scopes)\n\n except ImportError:\n print \"Error: local system does not have {}. Skipping!\".format(node.module)\n pass\n else:\n #TODO: store node.module\n for name in node.names:\n #TODO: store name.name even if name.asname defined \n name_val = name.asname or name.name\n symbol_table[name_val] = stack.get_scopes(src_module=node.module)\n\n elif ntype == \"ClassDef\" or ntype == \"FunctionDef\": \n symbol_table[node.name] = stack.get_scopes()\n \n #NOTE: if a name is being loaded then it already exists and doesn't need\n #to be added to symbol_table\n elif ntype == \"Name\" and not is_load(children) and not has_global(stack.scope_tail(), node.id): \n symbol_table[node.id] = stack.get_scopes()\n\n elif ntype == \"arguments\":\n if node.vararg: \n symbol_table[node.vararg] = stack.get_scopes()\n if node.kwarg:\n symbol_table[node.kwarg] = stack.get_scopes()\n\n elif ntype == \"Global\":\n #add a list global vars on node on the top of \n #the stack\n #nonlocal could be handled in similar way\n set_globals(scopes[-1], node.names)\n\n #set lineno property of children nodes\n set_lineno(node, children)\n\n for child in children[::-1]:\n #set depth of child\n set_depth(child, node.depth + 1)\n #Add children to stack\n stack.append(child)\n\n #Add any new scopes\n #Need to do it here since scoping_nodes are defined in their parent scope\n stack.check_and_push_scope()\n\n print \"Symbol table is \"\n print symbol_table\n return symbol_table","def show_symbol_table(st):\n print(st)\n # Dump the name lists get_*()\n if isinstance(st, symtable.Function):\n for nlist in _NAME_LISTS:\n names = getattr(st, \"get_\"+nlist)()\n if names:\n print(' {} : {!r}'.format(nlist, names))\n # Dump the properties as short names is_global -> global, etc..\n for s in st.get_symbols():\n scope = to_scope_name(s._Symbol__scope)\n props = [scope]\n for p in _NAME_PROPS:\n if getattr(s, \"is_\"+p)():\n props.append(p)\n print(' \"{}\" : {}'.format(s.get_name(), ', '.join(props)))","def symbol_table(self, value: str):\n self._symbol_table = value","def parse_symbol_table(data, sections, elf_header):\n if is64bit(elf_header):\n symbol_entry_str = symbol_64_entry_str\n symbol_entry_spec = symbol_64_entry_spec\n else:\n symbol_entry_str = symbol_32_entry_str\n symbol_entry_spec = symbol_32_entry_spec\n entry_len = struct.calcsize(symbol_entry_str)\n \n st_offset = None\n if \".symtab\" in sections:\n section = \".symtab\"\n if \".strtab\" in sections:\n st_offset = sections[\".strtab\"][\"offset\"]\n else:\n st_offset = sections[section][\"offset\"]\n \n elif \".dynsym\" in sections:\n section = \".dynsym\"\n if \".dynstr\" in sections:\n st_offset = sections[\".dynstr\"][\"offset\"]\n else:\n st_offset = sections[section][\"offset\"]\n \n \n if section not in sections:\n return {}, {} \n \n symbols = {}\n imports = {}\n offset = sections[section][\"offset\"]\n size = sections[section][\"size\"]\n index = offset\n while index < offset + size:\n vals = {}\n if len(data) < index+entry_len: \n break\n \n val_data = struct.unpack(symbol_entry_str, data[index:index+entry_len])\n for i, elem in enumerate(symbol_entry_spec):\n vals[elem[0]] = val_data[i]\n \n if st_offset is None:\n symbols[vals[\"name\"]] = vals\n else:\n func_name = get_name_from_string_table(data, st_offset, vals[\"name\"])\n if func_name:\n vals.pop(\"name\")\n vals[\"info\"] = get_symbol_info(vals[\"info\"])\n vals[\"shndx\"] = get_symbol_shndx(vals[\"shndx\"])\n \n if vals[\"info\"] == \"UNDEFINED\" and vals[\"value\"] == 0:\n tmp_name = func_name\n import_name = \"Unknown\"\n if \"@@\" in func_name:\n i = tmp_name.find(\"@@\")\n func_name = tmp_name[:i]\n import_name = tmp_name[i:].strip(\"@@\") \n if import_name not in imports:\n imports[import_name] = {}\n imports[import_name][func_name] = vals\n symbols[func_name] = vals\n \n index += entry_len \n \n return symbols, imports","def __set_symbol_dict(self):\r\n return {0: list(alph) if self.is_case_snstv else list(alph)[:26],\r\n 1: list(dgt),\r\n 2: list(spcl) if self.is_spcl else []}","def construct_table(self):\n table_str = self.header_row\n row_lbls, col_lbls = self.get_idxvals()\n for r,rlbl in enumerate(row_lbls):\n row_data = [self.data[rlbl,clbl] for clbl in col_lbls]\n table_str += self.construct_row(r, row_data)\n \n return table_str","def generate_symbol_definitions(mode, symbols, prefix, definition):\n direct = []\n tabled = []\n for ii in symbols:\n direct += [ii.generate_rename_direct(prefix)]\n tabled += [ii.generate_rename_tabled(prefix)]\n if \"vanilla\" == mode:\n tabled = direct\n return template_symbol_definitions % (definition, \"\\n\".join(direct), \"\\n\".join(tabled))","def tables():\n return {\n \"MAT24_STD_OCTAD\" : STD_OCTAD,\n }","def save(self):\n # First, just allocate enough memory for the SDAT header.\n data = bytearray(0x40)\n\n # -------------------\n # Make the SYMB block\n\n symbolsStringTable = bytearray()\n def addSymbolAndGetOffset(symbol):\n if symbol is None:\n return -1\n offset = len(symbolsStringTable)\n symbolsStringTable.extend(symbol.encode('latin-1') + b'\\0')\n return offset\n\n symbolsHeaderOffsets = []\n\n # Parallel arrays, here.\n symbolsTableValues = []\n shouldIncrementByTableLen = []\n\n anySymbolsInWholeFile = False\n\n def addSymbolsFrom(namedList, nested=False):\n\n # First, figure out if any actual symbols exist\n anyActualSymbols = False\n anyActualSubsymbols = False\n if not nested:\n for symbol, _ in namedList:\n if symbol is not None:\n anyActualSymbols = True\n break\n else:\n for symbol, entry in namedList:\n if symbol is not None:\n anyActualSymbols = True\n break\n for subSymbol, subEntry in entry.sequences:\n if subSymbol is not None:\n anyActualSubsymbols = True\n break\n\n\n nonlocal anySymbolsInWholeFile\n anySymbolsInWholeFile |= anyActualSymbols\n anySymbolsInWholeFile |= anyActualSubsymbols\n\n # If there *are* any symbols, keep going\n symbolsHeaderOffsets.append(len(symbolsTableValues) * 4)\n\n if not nested:\n symbolsTableValues.append(len(namedList))\n shouldIncrementByTableLen.append(False)\n\n for symbol, _ in namedList:\n symbolsTableValues.append(addSymbolAndGetOffset(symbol))\n shouldIncrementByTableLen.append(True)\n\n else:\n mainList, subListsArea = [], []\n mainListSIBTL, subListsAreaSIBTL = [], []\n\n mainList.append(len(namedList))\n mainListSIBTL.append(False)\n\n mainListFullLength = (1 + 2 * len(namedList)) * 4\n subListsAreaOffset = (0x40\n + len(symbolsTableValues) * 4\n + mainListFullLength)\n\n for symbol, entry in namedList:\n\n mainList.append(addSymbolAndGetOffset(symbol))\n mainListSIBTL.append(True)\n\n subListOffset = subListsAreaOffset + len(subListsArea) * 4\n\n if entry is None:\n subNames = []\n else:\n subNames = [n for (n, s) in entry.sequences]\n\n if entry or subNames:\n subListsArea.append(len(subNames))\n subListsAreaSIBTL.append(False)\n\n for subSymbol in subNames:\n subListsArea.append(addSymbolAndGetOffset(subSymbol))\n subListsAreaSIBTL.append(True)\n\n mainList.append(subListOffset)\n mainListSIBTL.append(False)\n\n else:\n mainList.append(0)\n mainListSIBTL.append(False)\n\n symbolsTableValues.extend(mainList)\n symbolsTableValues.extend(subListsArea)\n shouldIncrementByTableLen.extend(mainListSIBTL)\n shouldIncrementByTableLen.extend(subListsAreaSIBTL)\n\n addSymbolsFrom(self.sequences)\n addSymbolsFrom(self.sequenceArchives, True)\n addSymbolsFrom(self.banks)\n addSymbolsFrom(self.waveArchives)\n addSymbolsFrom(self.sequencePlayers)\n addSymbolsFrom(self.groups)\n addSymbolsFrom(self.streamPlayers)\n addSymbolsFrom(self.streams)\n\n # Only add the SYMB block if there are any symbols\n if anySymbolsInWholeFile:\n symbolsBlockOffset = len(data)\n\n symbolsTableLen = len(symbolsTableValues) * 4\n symbolsTable = bytearray()\n for value, shouldIncrement in itertools.zip_longest(symbolsTableValues,\n shouldIncrementByTableLen):\n if value == -1:\n symbolsTable.extend(b'\\0\\0\\0\\0')\n else:\n if shouldIncrement:\n value += symbolsTableLen + 0x40\n symbolsTable.extend(struct.pack('<I', value))\n\n symbolsBlockSize = 0x40 + len(symbolsTable) + len(symbolsStringTable)\n paddedSymbSize = symbolsBlockSize\n while paddedSymbSize % 4:\n paddedSymbSize += 1\n if self.padSymbSizeTo4InSDATHeader:\n symbolsBlockSize = paddedSymbSize\n\n symbolsHeaderOffsetsTable = bytearray()\n for value in symbolsHeaderOffsets:\n if value is None:\n symbolsHeaderOffsetsTable.extend(b'\\0\\0\\0\\0')\n else:\n symbolsHeaderOffsetsTable.extend(struct.pack('<I', value + 0x40))\n\n symbolsHeader = struct.pack('<4sI',\n b'SYMB', paddedSymbSize)\n\n data.extend(symbolsHeader)\n data.extend(symbolsHeaderOffsetsTable)\n data.extend(b'\\0' * 0x18)\n data.extend(symbolsTable)\n data.extend(symbolsStringTable)\n\n else:\n symbolsBlockOffset = None\n symbolsBlockSize = None\n\n\n # -------------------\n # Make the INFO block\n while len(data) % 4: data.append(0)\n infoBlockOffset = len(data)\n\n # Add room to add the header later\n data.extend(b'\\0' * (8 + 8 * 4))\n\n # Pad to 0x20 relative to the INFO block, for some reason\n while (len(data) - infoBlockOffset) % 0x20: data.append(0)\n\n # Helper functions\n def info_declarePart(partNumber):\n struct.pack_into('<I', data, infoBlockOffset + 8 + 4 * partNumber,\n len(data) - infoBlockOffset)\n def addFileAndGetID(file, dataMergeOptimizationID):\n idx = _common.listFind(files, file)\n\n while idx != -1:\n if dataMergeOptimizationID == fileMergeIDs[idx]:\n return idx\n idx = _common.listFind(files, file, idx + 1)\n\n files.append(file)\n fileMergeIDs.append(dataMergeOptimizationID)\n return len(files) - 1\n\n # We encode sections out of order, so that the files will be in\n # the same order as in retail SDATs.\n fileMergeIDs = []\n files = []\n\n # Info part 0: SSEQ\n info_declarePart(0)\n\n data.extend(struct.pack('<I', len(self.sequences)))\n sseqOffsetsTableOffset = len(data)\n data.extend(b'\\0' * (4 * len(self.sequences)))\n\n for i, (_, sseq) in enumerate(self.sequences):\n if sseq is None:\n entryOff = 0\n else:\n entryOff = len(data) - infoBlockOffset\n\n (file, unk02, bankID, volume, channelPressure,\n polyphonicPressure, playerID) = sseq.save()\n fileID = addFileAndGetID(file, sseq.dataMergeOptimizationID)\n\n data.extend(struct.pack('<3H4Bxx',\n fileID, unk02, bankID, volume, channelPressure,\n polyphonicPressure, playerID))\n\n struct.pack_into('<I', data, sseqOffsetsTableOffset + 4 * i, entryOff)\n\n # Info part 1: SSAR\n info_declarePart(1)\n\n data.extend(struct.pack('<I', len(self.sequenceArchives)))\n ssarOffsetsTableOffset = len(data)\n data.extend(b'\\0' * (4 * len(self.sequenceArchives)))\n\n for i, (_, ssar) in enumerate(self.sequenceArchives):\n if ssar is None:\n entryOff = 0\n else:\n entryOff = len(data) - infoBlockOffset\n\n file, unk02, _ = ssar.save()\n fileID = addFileAndGetID(file, ssar.dataMergeOptimizationID)\n\n data.extend(struct.pack('<HH',\n fileID, unk02))\n\n struct.pack_into('<I', data, ssarOffsetsTableOffset + 4 * i, entryOff)\n\n # Info part 2: SBNK\n info_declarePart(2)\n\n data.extend(struct.pack('<I', len(self.banks)))\n sbnkOffsetsTableOffset = len(data)\n data.extend(b'\\0' * (4 * len(self.banks)))\n\n for i, (sbnkName, sbnk) in enumerate(self.banks):\n if sbnk is None:\n entryOff = 0\n else:\n entryOff = len(data) - infoBlockOffset\n\n file, unk02, waveArchives = sbnk.save()\n fileID = addFileAndGetID(file, sbnk.dataMergeOptimizationID)\n\n swarIDs = []\n for s in waveArchives:\n swarIDs.append(-1 if s is None else s)\n while len(swarIDs) < 4:\n swarIDs.append(-1)\n\n if len(swarIDs) > 4:\n raise ValueError(f'SBNK {i} (\"{sbnkName}\") uses '\n f'{len(swarIDs)} SWARs. The maximum is 4.')\n\n data.extend(struct.pack('<HH4h',\n fileID, unk02, *swarIDs))\n\n struct.pack_into('<I', data, sbnkOffsetsTableOffset + 4 * i, entryOff)\n\n\n # Info part 3: SWAR\n info_declarePart(3)\n\n data.extend(struct.pack('<I', len(self.waveArchives)))\n swarOffsetsTableOffset = len(data)\n data.extend(b'\\0' * (4 * len(self.waveArchives)))\n\n for i, (_, swar) in enumerate(self.waveArchives):\n if swar is None:\n entryOff = 0\n else:\n entryOff = len(data) - infoBlockOffset\n\n file, unk02 = swar.save()\n fileID = addFileAndGetID(file, swar.dataMergeOptimizationID)\n\n data.extend(struct.pack('<HH',\n fileID, unk02))\n\n struct.pack_into('<I', data, swarOffsetsTableOffset + 4 * i, entryOff)\n\n\n # Info part 4: Sequence players\n info_declarePart(4)\n\n data.extend(struct.pack('<I', len(self.sequencePlayers)))\n spOffsetsTableOffset = len(data)\n data.extend(b'\\0' * (4 * len(self.sequencePlayers)))\n\n for i, (_, sp) in enumerate(self.sequencePlayers):\n if sp is None:\n entryOff = 0\n else:\n entryOff = len(data) - infoBlockOffset\n\n maxSequences, channels, heapSize = sp.save()\n\n channelMask = 0\n for j in range(16):\n if j in channels:\n channelMask |= 1 << j\n\n data.extend(struct.pack('<HHI',\n maxSequences, channelMask, heapSize))\n\n struct.pack_into('<I', data, spOffsetsTableOffset + 4 * i, entryOff)\n\n\n # Info part 5: Groups\n info_declarePart(5)\n\n data.extend(struct.pack('<I', len(self.groups)))\n groupOffsetsTableOffset = len(data)\n data.extend(b'\\0' * (4 * len(self.groups)))\n\n for i, (_, group) in enumerate(self.groups):\n if group is None:\n entryOff = 0\n else:\n entryOff = len(data) - infoBlockOffset\n\n data.extend(struct.pack('<I', len(group)))\n\n for gEntry in group:\n data.extend(struct.pack('<BHxI', *gEntry.save()))\n\n struct.pack_into('<I', data, groupOffsetsTableOffset + 4 * i, entryOff)\n\n\n # Info part 6: Stream players\n info_declarePart(6)\n\n data.extend(struct.pack('<I', len(self.streamPlayers)))\n spOffsetsTableOffset = len(data)\n data.extend(b'\\0' * (4 * len(self.streamPlayers)))\n\n for i, (_, sp) in enumerate(self.streamPlayers):\n if sp is None:\n entryOff = 0\n else:\n entryOff = len(data) - infoBlockOffset\n\n channels = sp.save()\n chanCount = len(channels)\n while len(channels) < 16:\n channels.append(0xFF)\n\n data.append(chanCount)\n data.extend(channels)\n\n # This has to occur in order for the padding to work out\n # correctly. Weird, but, what can you do. Might even be\n # an unknown value.\n data.extend(b'\\0\\0\\0\\0')\n\n struct.pack_into('<I', data, spOffsetsTableOffset + 4 * i, entryOff)\n\n while len(data) % 4: data.append(0)\n\n\n # Info part 7: Streams\n info_declarePart(7)\n\n data.extend(struct.pack('<I', len(self.streams)))\n strmOffsetsTableOffset = len(data)\n data.extend(b'\\0' * (4 * len(self.streams)))\n\n for i, (_, strm) in enumerate(self.streams):\n if strm is None:\n entryOff = 0\n else:\n entryOff = len(data) - infoBlockOffset\n\n file, unk02, volume, priority, playerID, unk07 = strm.save()\n fileID = addFileAndGetID(file, strm.dataMergeOptimizationID)\n\n data.extend(struct.pack('<HH4B4x',\n fileID, unk02, volume, priority, playerID, unk07))\n\n struct.pack_into('<I', data, strmOffsetsTableOffset + 4 * i, entryOff)\n\n # Now we can finally fill the header in.\n struct.pack_into('<4sI', data, infoBlockOffset,\n b'INFO', len(data) - infoBlockOffset)\n\n infoBlockSize = len(data) - infoBlockOffset\n\n\n # ----------------------\n # Make a dummy FAT block, to be filled in when adding to the\n # FILE block\n\n while len(data) % 4: data.append(0)\n fatBlockOffset = len(data)\n fatBlockSize = 0xC + 0x10 * len(files)\n fatTableOffset = fatBlockOffset + 0xC\n\n fatHeader = struct.pack('<4sII',\n b'FAT ', 0xC + 0x10 * len(files), len(files))\n\n data.extend(fatHeader)\n data.extend(b'\\0' * (0x10 * len(files)))\n\n\n # -------------------\n # Make the FILE block and fill in the FAT block\n while len(data) % 4: data.append(0)\n fileBlockOffset = len(data)\n\n # Dummy header (to be filled in after we know the total size)\n data.extend(b'\\0' * 0xC)\n\n # Some games align the first file differently\n if self.firstFileAlignment is not None:\n while len(data) % self.firstFileAlignment:\n data.append(0)\n\n # Add each file\n for i, file in enumerate(files):\n\n # Files must be aligned to 0x20 relative to the SDAT\n # itself... usually. Some games align to other amounts.\n while len(data) % self.fileAlignment:\n data.append(0)\n\n # Actually add the file\n fileOffset = len(data)\n data.extend(file)\n \n # Add the appropriate FAT entry\n fLen = len(file)\n if self.fatLengthsIncludePadding:\n while fLen % self.fileAlignment: fLen += 1\n\n struct.pack_into('<II', data, fatTableOffset + 0x10 * i,\n fileOffset, fLen)\n\n # And one last pad for good measure. (And because retail files\n # do so.)\n if self.padAtEnd:\n while len(data) % self.fileAlignment:\n data.append(0)\n\n # Add the header\n struct.pack_into('<4sII', data, fileBlockOffset,\n b'FILE', len(data) - fileBlockOffset, len(files))\n\n fileBlockSize = len(data) - fileBlockOffset\n\n\n # -----------------------\n # Put the blocks together\n\n # Write the SDAT header\n struct.pack_into('<8I', data, 0x10,\n 0 if symbolsBlockOffset is None else symbolsBlockOffset,\n 0 if symbolsBlockSize is None else symbolsBlockSize,\n 0 if infoBlockOffset is None else infoBlockOffset,\n 0 if infoBlockSize is None else infoBlockSize,\n 0 if fatBlockOffset is None else fatBlockOffset,\n 0 if fatBlockSize is None else fatBlockSize,\n 0 if fileBlockOffset is None else fileBlockOffset,\n 0 if fileBlockSize is None else fileBlockSize)\n\n # Write the standard header to the beginning\n _common.NDS_STD_FILE_HEADER.pack_into(data, 0,\n b'SDAT', 0xFEFF, 0x100, len(data), 0x40,\n 3 if symbolsBlockOffset is None else 4)\n\n return data","def create_symbol_to_possible_cell_mapping(self):\r\n symbols_to_cells = defaultdict(set)\r\n for cell in self.iterate_empty_cells():\r\n for symbol in cell.get_possible_symbols():\r\n symbols_to_cells[symbol].add(cell)\r\n return symbols_to_cells","def _get_symbols(self):\n\n symbols = self.get_symbols()\n\n if isinstance(symbols, dict):\n keys = ['symbol', 'from_symbol', 'to_symbol']\n correct_keys = np.isin(keys, list(symbols.keys())).all()\n\n if not correct_keys:\n raise ImplementationError('''\n Dict should be in the form:\n {'symbol':[], 'from_symbol':[], 'to_symbol':[]}\n ''')\n else:\n symbols = pd.DataFrame(symbols, index = [symbols['symbol']])\n\n symbols.index = symbols.symbol\n\n return symbols","def _format_symbol_table_content(self, title: str, symbols: Any) -> str:\n\n header = f\"\\t\\t:::: {title} ::::\"\n lines = [\"\\n\", header, \"__\" * len(header)]\n if type(symbols).__name__ == \"odict_items\":\n lines.extend((f\"| {key}: {value}\") for key, value in self._symbols.items())\n elif type(symbols).__name__ == \"odict_keys\":\n lines.extend((f\"| {key}\") for key in self._symbols.keys())\n\n lines.append(\"\\n\")\n formatted_content = \"\\n\".join(lines)\n return formatted_content","def list_symbol_tables(mst):\n stlist = []\n def append_st(st):\n #print(st)\n stlist.append(st)\n for s in st.get_symbols():\n for ns in s.get_namespaces():\n append_st(ns)\n if not isinstance(mst, symtable.SymbolTable):\n # Assume it is text of a program to compile\n mst = symtable.symtable(mst, '<string>', 'exec')\n append_st(mst)\n return stlist","def return_astropy_table(self):\n table = Table()\n for name in self.hdfile.root.Data.Fibers.colnames:\n if hasattr(self, name):\n table[name] = getattr(self, name)\n\n return table","def return_astropy_table(self):\n table = Table()\n for name in self.hdfile.root.Data.Fibers.colnames:\n if hasattr(self, name):\n table[name] = getattr(self, name)\n\n return table","def __repr__(self):\n return 'HashTable({!r})'.format(self.items())","def execute(self, symbol_table, test_mode=False):","def execute(self, symbol_table, test_mode=False):","def _symbols_table_file_content(\n rule_set: _RewriteRuleSet) -> Generator[str, None, None]:\n\n def _line(symbol: str, index: int) -> str:\n return f\"{symbol}\\t{index}\\n\"\n\n fst_symbols = []\n\n for rule in rule_set.rule:\n fst_symbols.extend(_symbols_of_input(rule.input))\n fst_symbols.extend(_symbols_of_output(rule.output))\n\n unique_symbols = set(fst_symbols).difference({common.EPSILON})\n complex_symbols = [s for s in unique_symbols if len(s) > 1]\n\n index = 983040 # start of the Unicode private use area.\n\n for symbol in sorted(complex_symbols):\n yield _line(symbol, index)\n index += 1\n\n logging.info(\"generated complex symbols file content\")","def __repr__(self):\n return dict_to_table(self)","def copy(self):\n cdef SymbolTable result = SymbolTable.__new__(SymbolTable)\n result.table = new sym.SymbolTable(self.table[0])\n return result","def popSym(self):\r\n res=self.dbConn.execute(\"SELECT * FROM Symposia ORDER BY StartDate\").fetchall()\r\n self.symList = [ln[\"Name\"] for ln in res]\r\n self.symID_Title = {ln[\"SymposiumID\"]:ln[\"Name\"] for ln in res}\r\n for ln in res:\r\n self.symID_Title[ln[\"Name\"]] = ln[\"SymposiumID\"]","def __init__(self):\n\n self.st = {} # symbol table\n self.st[\"itrs\"] = [{}, {}, {}]\n self.existVecs = False\n self.existMats = False\n self.applyOnce = {}","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 create_root_symbols(self):\n RootSymbol = Symbol(Token(None,None,'R00t.Symbol'))\n RootSymbol.GlobalSymbolDict=self.GlobalSymbolDict\n StartDocSymbol = Symbol(Token(None,None,'%^'))\n StartDocSymbol.regex = Set('%^')\n StartDocSymbol.is_lit = True\n StartDocSymbol.GlobalSymbolDict=self.GlobalSymbolDict\n EndDocSymbol = Symbol(Token(None,None,'%$'))\n EndDocSymbol.regex = Set('%$')\n EndDocSymbol.is_lit = True\n EndDocSymbol.GlobalSymbolDict=self.GlobalSymbolDict\n RootSymbol.productions = [Production(RootSymbol,[StartDocSymbol]+self.get_roots()+[EndDocSymbol])]\n self.GlobalSymbolDict['R00t.Symbol'] = RootSymbol #XXX this is a nasty hack\n self.GlobalSymbolDict['%^']=StartDocSymbol\n self.GlobalSymbolDict['%$']=EndDocSymbol","def __init__(self):\n # just the list of class/construct types\n self.lut = {}\n self.lut[\"struct\"] = structure\n self.lut[\"typedef\"] = typedef\n self.lut[\"define\"] = define\n self.lut[\"enum\"] = enum\n self.lut[\"enumEntry\"] = enumEntry\n self.lut[\"ifdef\"] = ifdef\n self.lut[\"ifndef\"] = ifndef\n self.lut[\"hashIf\"] = hashIf\n self.lut[\"hashElse\"] = hashElse\n self.lut[\"hashElif\"] = hashElif\n self.lut[\"endif\"] = endif\n self.lut[\"banner\"] = banner\n self.lut[\"general\"] = general\n self.lut[\"listDefine\"] = listDefine\n self.lut[\"listEntry\"] = listEntry\n self.lut[\"listNumEls\"] = listNumEls\n self.lut[\"union\"] = union\n\n # and the dictionary of all symbols we declare\n self.symbols = {}","def nk_table(self):\n return self.map(\"keys\", \"values\")","def generate_rename_tabled(self, prefix):\n return \"#define %s%s g_symbol_table.%s\" % (prefix, self.__name, self.__name)","def _generate_symbols(self):\n\n def infix(id, bp):\n def led(self, left):\n self.first = left\n self.second = self.parent.expression(bp)\n return self\n\n self.symbol_factory(id, bp).led = led\n\n def prefix(id, bp):\n def nud(self):\n self.first = self.parent.expression(bp)\n return self\n\n self.symbol_factory(id, bp).nud = nud\n\n def infixr(id, bp):\n def led(self, left):\n self.first = left\n self.second = self.parent.expression(bp - 1)\n return self\n\n self.symbol_factory(id, bp).led = led\n\n def paren(id):\n def nud(self):\n expr = self.parent.expression()\n self.parent._advance(\"RIGHT_PAREN\")\n return expr\n\n self.symbol_factory(id).nud = nud\n\n paren(\"LEFT_PAREN\")\n self.symbol_factory(\"RIGHT_PAREN\")\n self.symbol_factory(\"END\")\n self.symbol_factory(\":\")\n self.symbol_factory(\"NEWLINE\")\n self.symbol_factory(\"INDENT\")\n self.symbol_factory(\"DEDENT\")\n\n # numbers denote order of operations\n infix(\"+\", 10)\n infix(\"-\", 10)\n infix(\"*\", 20)\n infix(\"/\", 20)\n infix(\"==\", 5)\n infix(\">\", 5)\n infix(\"<\", 5)\n infix(\"&\", 4)\n infix(\"|\", 3)\n infix(\",\", 1)\n infix(\"::\", 1)\n \n infixr(\"=\", 1) # assignment is a little different from others.\n\n # example +4 , -2 \n prefix(\"+\", 100)\n prefix(\"-\", 100)\n\n def literal(id):\n self.symbol_factory(id).nud = lambda self: self\n\n for l in [\"NUMBER\", \"FLOAT\", \"NAME\", \"STRING\", \"BOOL\"]:\n literal(l)\n\n def statement(id, std):\n self.symbol_factory(id).stmt_begin = True\n self.symbol_factory(id).std = std\n\n def if_statement(self):\n self.first = self.parent.expression()\n self.parent._advance([\":\"])\n self.parent._advance([\"NEWLINE\"])\n self.second = self.parent.Block()\n if self.parent.token.id == \"else\":\n self.parent._advance([\"else\"])\n self.parent._advance([\":\"])\n self.parent._advance([\"NEWLINE\"])\n self.third = self.parent.Block()\n return self\n\n def let_statement(self):\n self.first = self.parent.expression()\n self.parent._advance([\"NEWLINE\"])\n return self\n\n def print_statement(self):\n self.parent._advance([\"LEFT_PAREN\"])\n self.first = self.parent.expression()\n self.parent._advance([\"RIGHT_PAREN\"])\n self.parent._advance([\"NEWLINE\"])\n return self\n\n def while_statement(self):\n self.parent._advance([\"LEFT_PAREN\"])\n self.first = self.parent.expression()\n self.parent._advance([\"RIGHT_PAREN\"])\n self.parent._advance([\":\"])\n self.parent._advance([\"NEWLINE\"])\n self.second = self.parent.Block()\n return self\n\n def func_statement(self):\n arg_list = []\n\n self.first = self.parent.expression()\n self.parent._advance([\"LEFT_PAREN\"])\n self.second = self.parent.expression()\n self.parent._advance([\"RIGHT_PAREN\"])\n self.parent._advance([\":\"])\n self.parent._advance([\"NEWLINE\"])\n self.third = self.parent.Block()\n return self\n\n statement(\"if\", if_statement)\n statement(\"let\", let_statement)\n statement(\"print\", print_statement)\n statement(\"while\", while_statement)\n statement(\"fn\", func_statement)","def create_possible_symbols_to_cells_mapping(self):\r\n possibles_to_cells = defaultdict(set)\r\n for cell in self.iterate_empty_cells():\r\n possibles_to_cells[frozenset(cell.get_possible_symbols())].add(cell)\r\n return possibles_to_cells","def add_symbol_und(self, name):\n label_name = \"symtab_\" + name\n if osarch_is_32_bit():\n self.add_data((\"st_name\", 4, \"strtab_%s - strtab\" % (name)))\n self.add_data((\"st_value\", PlatformVar(\"addr\"), label_name, label_name))\n self.add_data((\"st_size\", PlatformVar(\"addr\"), PlatformVar(\"addr\")))\n self.add_data((\"st_info\", 1, 17))\n self.add_data((\"st_other\", 1, 0))\n self.add_data((\"st_shndx\", 2, 1))\n elif osarch_is_64_bit():\n self.add_data((\"st_name\", 4, \"strtab_%s - strtab\" % (name)))\n self.add_data((\"st_info\", 1, 17))\n self.add_data((\"st_other\", 1, 0))\n self.add_data((\"st_shndx\", 2, 1))\n self.add_data((\"st_value\", PlatformVar(\"addr\"), label_name, label_name))\n self.add_data((\"st_size\", PlatformVar(\"addr\"), PlatformVar(\"addr\")))\n else:\n raise_unknown_address_size()","def pretty(self):\n #table = [\"\".join([\"%8s \" % s for s in self.alpha.getSymbols()])]\n table = []\n for row in PWM.getFreq(self):\n table.append(\"\".join([\"%8.6f \" % y for y in row]))\n return table","def symbols_details(self):\n pass","def map_table(asm):\n # Dictionary of mappings between pre-defined names\n table = {\n \"SP\" : 0,\n \"LCL\" : 1,\n \"ARG\" : 2,\n \"THIS\" : 3,\n \"THAT\" : 4,\n \"SCREEN\": 16384,\n \"KBD\" : 24576,\n }\n # R0-R15\n for i in range(0, 16):\n table[\"R\" + str(i)] = i\n\n # Add user-defined names i.e. variables and gotos\n variables_list = [] # list of all @-values\n reg = 16 # start after R15\n count = -1 # keep track of instruction memory position\n\n for line in asm:\n parsed, flag = parser(line)\n\n if flag == \"GOTO_INSTRUCTION\":\n table[parsed] = count + 1 # add next position after goto\n elif flag == \"A_DECIMAL\":\n count += 1\n elif flag == \"A_INSTRUCTION\":\n if parsed not in variables_list:\n variables_list.append(parsed) # append to list if it doesn't exist\n count += 1\n elif flag == \"C_INSTRUCTION\":\n count += 1\n\n for i in variables_list:\n try:\n table[i]\n except KeyError:\n table[i] = reg # if key doesn't exist add it\n reg += 1\n\n return table","def __str__(self):\n\n # Create grid headers for the table\n headers = [letter for letter in string.ascii_uppercase[:self.width]]\n\n board_state = []\n board_state.extend([[value for value in row] for i, row in enumerate(self.board_state)])\n\n for idx, row in enumerate(board_state):\n row.insert(0, idx + 1)\n\n return tabulate(board_state, headers, tablefmt=\"grid\")","def _sym_constant(self, table: Mapping[int, str]) -> str:\n try:\n return table[self.sym]\n except KeyError:\n return str(self.sym)","def make_sym(self):\n\n phi_list = []\n sym_vars = sym.zeros(len(self.rigid_body_list) * 12, 1)\n\n for i, rigid_body in enumerate(self.rigid_body_list): # Global symbolic variable matrix (column vector)\n for j, sim_var in enumerate(rigid_body.symbolic_variables):\n sym_vars[i * 12 + j, 0] = rigid_body.symbolic_variables[j]\n phi_list.extend(rigid_body.constraints)\n\n self.r = sym_vars\n\n for i in self.constraint_list:\n phi_list.append(i.symbolic)\n\n phi = sym.zeros(len(phi_list), 1)\n\n for i, constraint in enumerate(phi_list):\n phi[i] = constraint\n\n self.phi = phi\n self.phi_t = self.phi.diff(t)\n\n rows = len(self.r)\n columns = len(phi)\n\n phi_r = sym.zeros(rows, columns)\n\n for j, constraint in enumerate(phi):\n for i, var in enumerate(sym_vars):\n phi_r[i, j] = constraint.diff(var)\n\n self.phi_r = phi_r\n\n self.b = sym.Matrix([- (self.phi_r.diff(t)).T*self.r.diff(t) - self.phi_t.diff(t) -\n 2*self.alpha*(self.phi_r.T*self.r.diff(t) + self.phi_t) -\n (self.beta**2)*self.phi])","def gen_get_const_table(cls, names, p, const_p):\n s = \"// Store constant table for {p} to {const_p}\\n\".format(\n const_p = const_p, p = p\n ) \n s += \"{c} = {t}[(((({p}) + 1) * {mul}) >> 8) & 7];\\n\".format(\n c = const_p, p = p, t = names[cls.T_NAME],\n mul = cls.deBruijnMult\n )\n return s","def get_shapes_table(self):\n\n title_list = ['idx', 'Class', '__str__', 'Perimeter', 'Perimeter Formula', 'Area', 'Area Formula']\n cell_length = []\n table = ''\n for title in title_list:\n cell_length.append(len(title))\n cell_length = self.get_length(cell_length)\n for i in range(len(cell_length)):\n cell_length[i] += 2\n table += '/' + '-' * (sum(cell_length) + len(title_list)-1) + '\\\\\\n'\n for i in range(len(title_list)):\n table += '|{:^{}}'.format(title_list[i], cell_length[i])\n table += '|\\n'\n idx = 0\n for shape in self.shapes:\n table += '|' + '-' * (sum(cell_length) + len(title_list)-1) + '|\\n'\n table += '|{:^{}}|{:^{}}|{:^{}}|{:^{}}|{:^{}}|{:^{}}|{:^{}}|\\n'. \\\n format(idx, cell_length[0], shape.__class__.__name__, cell_length[1],\n shape.__str__(), cell_length[2], round(shape.perimeter, 2), cell_length[3],\n shape.get_perimeter_formula(), cell_length[4], round(shape.area, 2),\n cell_length[5], shape.get_area_formula(), cell_length[6])\n table += '\\\\' + '-' * (sum(cell_length) + len(title_list) - 1) + '/\\n'\n return table","def _build_micro_tree_tables(self):\n # A mapping that associates micro tree encoding with its corresponding table.\n self._micro_tables = {}\n\n # A mapping that stores the encoding of each micro tree.\n self._codes = {}\n\n # For every micro tree compute a simle table to answer LA queries.\n for p in self._micro_roots:\n code, f, f_inv = self._encode(p) # encode the micro tree\n self._codes[p.index()] = code, f, f_inv\n if code not in self._micro_tables: # build a simple table if needed\n repr_tree = self._decode(code)\n self._micro_tables[code] = LA_table(repr_tree)","def __repr__(self):\n # return 'HashTable({})'.format(self.length())\n return 'HashTable({})'.format(str(self.buckets))","def _create_TableDescriptor(self):\n\n self.conn.cursor.execute(\"PRAGMA table_info(\" + self.table_name + \")\")\n descriptions = self.conn.cursor.fetchall()\n column_map = {}\n for description in descriptions:\n column_map[description[1]] = description[2]\n td = TD(self.table_name, column_map) \n\n# self.conn.cursor.execute(\"SELECT sql FROM sqlite_master WHERE name='{tb}'\"\\\n# .format(tb=self.table_name))\n# aa = str(self.conn.cursor.fetchone()[0])\n# sindx = aa.find(\"(\")\n# eindx = aa.find(\")\")\n# aa = aa[sindx+1:eindx]\n# aa = aa.split(\",\")\n# column_map = {kyval.split()[0]:kyval.split()[1] for kyval in aa}\n# td = TD(self.table_name, column_map) \n\n return td","def symbols(self):\n pass","def __init__(self):\n self.class_symbol_table = dict()\n self.subroutine_symbol_table = dict()\n self.counter = {VAR: 0, ARG: 0, FIELD: 0, STATIC: 0}","def symbols(self) -> Dict[str, Variable]:\n symbols = {}\n symbols.update(self.args)\n symbols.update(self.locals)\n return symbols","def add_dt_symtab(self, op):\n d_tag = AssemblerVariable((\"d_tag, DT_SYMTAB = 6\", PlatformVar(\"addr\"), 6))\n d_un = AssemblerVariable((\"d_un\", PlatformVar(\"addr\"), op))\n self.__data[0:0] = [d_tag, d_un]\n self.refresh_name_label()","def _generate_table(self):\n for i in xrange(32):\n dest = [0]\n gw = [0]\n self._table.append(\n {'destination': dest, 'gateway': gw}\n )","def get_data():\n state = np.array([1,1,1,1,1,1,1,1,1], dtype=np.bool)\n taps = np.array([0,0,0,0,1,0,0,0,1], dtype=np.bool)\n p = np.zeros(176, dtype=np.uint8)\n for i in range(176):\n p[i] = np.sum(state[-3:]*[4,2,1])\n for _ in range(3):\n state = np.concatenate(([np.sum(state&taps)&1], state[0:-1]))\n a = np.zeros(176, common.SYMB_SCRAMBLE_DTYPE)\n ## 8PSK modulation\n constellation = PhysicalLayer.make_psk(8,range(8))['points']\n a['scramble'] = constellation[p,]\n known_symbols = np.mod(range(176),48)>=32\n a['symb'][known_symbols] = a['scramble'][known_symbols]\n return a","def build_versioned_syms_gtirb() -> gtirb.IR:\n (ir, module) = gth.create_test_module(\n gtirb.Module.FileFormat.ELF,\n gtirb.Module.ISA.X64,\n )\n (text_section, text_bi) = gth.add_text_section(module)\n\n proxy_a = gth.add_proxy_block(module)\n symbol_a = gth.add_symbol(module, \"a\", proxy_a)\n se_a = gtirb.SymAddrConst(\n 0, symbol_a, {gtirb.SymbolicExpression.Attribute.PLT}\n )\n proxy_a2 = gth.add_proxy_block(module)\n symbol_a2 = gth.add_symbol(module, \"a\", proxy_a2)\n se_a2 = gtirb.SymAddrConst(\n 0, symbol_a2, {gtirb.SymbolicExpression.Attribute.PLT}\n )\n\n module.aux_data[\"elfSymbolVersions\"] = gtirb.AuxData(\n type_name=(\n \"tuple<mapping<uint16_t,tuple<sequence<string>,uint16_t>>,\"\n \"mapping<string,mapping<uint16_t,string>>,\"\n \"mapping<UUID,tuple<uint16_t,bool>>>\"\n ),\n data=(\n # ElfSymVerDefs\n {},\n # ElfSymVerNeeded\n {\"libmya.so\": {1: \"LIBA_1.0\", 2: \"LIBA_2.0\"}},\n # ElfSymbolVersionsEntries\n {symbol_a.uuid: (1, False), symbol_a2.uuid: (2, False)},\n ),\n )\n\n # For the following code:\n # e8 00 00 00 00 callq a@LIBA_1.0@plt\n # e8 00 00 00 00 callq a@LIBA_2.0@plt\n # 48 31 c0 xor %rax,%rax\n # 48 c7 c0 3c 00 00 00 mov $0x3c,%rax\n # 48 31 ff xor %rdi,%rdi\n # 0f 05 syscall\n cb = gth.add_code_block(\n text_bi,\n b\"\\xe8\\x00\\x00\\x00\\x00\"\n b\"\\xe8\\x00\\x00\\x00\\x00\"\n b\"\\x48\\x31\\xc0\"\n b\"\\x48\\xc7\\xc0\\x3c\\x00\\x00\\x00\"\n b\"\\x48\\x31\\xff\"\n b\"\\x0f\\x05\",\n {1: se_a, 6: se_a2},\n )\n symbol_start = gth.add_symbol(module, \"_start\", cb)\n\n module.aux_data[\"libraries\"].data.extend([\"libmya.so\"])\n\n for sym in (symbol_start, symbol_a, symbol_a2):\n module.aux_data[\"elfSymbolInfo\"].data[sym.uuid] = (\n 0,\n \"FUNC\",\n \"GLOBAL\",\n \"DEFAULT\",\n 0,\n )\n\n return ir","def generate_str (obj):\n d = obj.dim(obj)\n units = [ obj( ( [zer]*i + [one] + [zer]*(d-i-1) )) for i in range(d) ]\n table = []\n raw_table = []\n for j in units:\n table.append([])\n raw_table.append([])\n for i in units:\n if DEBUG: raw_table[-1].append(str(j*i))\n table[-1].append(str(obj([c.name_in(s) for c in (j*i).state])))\n if DEBUG: print('{} × {} = {}'.format(j,i,j*i))\n return table","def tabledict(self):\n return dict(table=self.tablename,\n dffeld=self.name_dateifuehrungsschluessel,\n statusfeld=self.name_status,\n schluesselfeld=self.name_schluessel)","def _build_sparse_table(self):\n self._table = {}\n\n for p in self._jump_nodes:\n self._table[p.index()] = [self._tree.parent(p)] # table[p][0] = parent(p)\n\n l = 0\n while l < self._logsize:\n u = self._table[p.index()][l]\n\n if u is None:\n break\n\n if self._ind[u.index()] < self._pow[l]: # incomplete ladder\n break\n\n i = self._path[u.index()] # u belongs to path_i\n j = self._ind[u.index()] # path_i[j] = u\n w = self._ladders[i][j - self._pow[l]]\n self._table[p.index()].append(w)\n l += 1","def __init__(self, owner, name, addr, size, binding, sym_type, sh_info):\n super(Symbol, self).__init__()\n self.owner_obj = owner\n self.name = name\n self.addr = addr\n self.size = size\n self.binding = binding\n self.type = sym_type\n self.sh_info = sh_info if sh_info != 'SHN_UNDEF' else None\n self.resolved = False\n self.resolvedby = None\n if (claripy and isinstance(self.addr, claripy.ast.Base)) or self.addr != 0:\n self.owner_obj.symbols_by_addr[self.addr] = self\n # would be nice if we could populate demangled_names here...\n\n #demangled = self.demangled_name\n #if demangled is not None:\n # self.owner_obj.demangled_names[self.name] = demangled","def pretty(self):\n table = [\"\".join([\"%4s \" % s for s in self.alpha.getSymbols()])]\n table.append(\"\".join([\"%3.2f \" % y for y in Distrib.getFreq(self)]))\n return table","def __str__(self):\n ts_rows = [\n [\"Trees\", str(self.num_trees)],\n [\n \"Sequence Length\",\n str(\n int(self.sequence_length)\n if self.discrete_genome\n else self.sequence_length\n ),\n ],\n [\"Time Units\", self.time_units],\n [\"Sample Nodes\", str(self.num_samples)],\n [\"Total Size\", util.naturalsize(self.nbytes)],\n ]\n header = [\"Table\", \"Rows\", \"Size\", \"Has Metadata\"]\n table_rows = []\n for name, table in self.tables.table_name_map.items():\n table_rows.append(\n [\n str(s)\n for s in [\n name.capitalize(),\n table.num_rows,\n util.naturalsize(table.nbytes),\n \"Yes\"\n if hasattr(table, \"metadata\") and len(table.metadata) > 0\n else \"No\",\n ]\n ]\n )\n return util.unicode_table(ts_rows, title=\"TreeSequence\") + util.unicode_table(\n table_rows, header=header\n )","def to_xml(self):\n xml_strings = ['<table name=\"%s\">\\n' % self.name]\n if self.tablespace_name:\n xml_strings.append(' <tablespace name=')\n xml_strings.append('\"%s\" />\\n' % self.tablespace_name)\n # Columns\n for column in self.columns:\n col_details = self.columns[column]\n xml_strings.append(' <column name=\"%s\"' % column)\n xml_strings.append(' data-type=\"%s\"' % col_details['type'])\n xml_strings.append(' sequence=\"%d\">\\n' % col_details['sequence'])\n # The following statement means we need Python 2.5 and above\n # pre 2.5 it would be col_details.has_key('length')\n if 'length' in col_details:\n xml_strings.append(' <length>')\n xml_strings.append(str(col_details['length']))\n xml_strings.append('</length>\\n')\n if 'precision' in col_details and col_details['precision'] != 0:\n xml_strings.append(' <precision>')\n xml_strings.append(str(col_details['precision'])+'</precision>\\n')\n if 'scale' in col_details:\n xml_strings.append(' <scale>')\n xml_strings.append(str(col_details['scale']))\n xml_strings.append('</scale>\\n')\n xml_strings.append(' </column>\\n')\n # Constraints\n for constraint, cons_details in list(self.constraints.items()):\n # Exclude check constraint that start with 'SYS_C' (an Oracle hack)\n if cons_details['type'] != 'Check' or not constraint.startswith(\"SYS_C\"):\n xml_strings.append(' <constraint name=\"%s\"' % constraint)\n xml_strings.append(' type=\"%s\">\\n' % cons_details['type'])\n if cons_details['type'] == 'Check':\n xml_strings.append(' <details>')\n xml_strings.append(cons_details['condition'])\n xml_strings.append('</details>\\n')\n if cons_details['type'] == 'Primary':\n for column in cons_details['columns']:\n xml_strings.append(' <column name=\"%s\" />\\n' % column)\n if cons_details['type'] == 'Foreign':\n xml_strings.append(' <jointable ')\n xml_strings.append(' name=\"%s\"' % cons_details['reftable'])\n xml_strings.append(' pk=\"%s\">\\n' % cons_details['refpk'])\n for col_index in range(len(cons_details['columns'])):\n xml_strings.append(' <constraintcolumn')\n name = cons_details['columns'][col_index]\n xml_strings.append(' name=\"%s\"' % name)\n xml_strings.append(' joincolumn')\n join_column = cons_details['refcolumns'][col_index]\n xml_strings.append('=\"%s\" />\\n' % join_column)\n xml_strings.append(' </jointable>\\n')\n xml_strings.append(' </constraint>\\n')\n # Indexes\n for index in self.indexes:\n index_details = self.indexes[index]\n xml_strings.append(' <index name=\"%s\"' % index)\n xml_strings.append(' type=\"%s\">\\n' % index_details['type'])\n for column in index_details['columns']:\n xml_strings.append(' <column name=\"%s\" />\\n' % column)\n xml_strings.append(' </index>\\n')\n # Triggers\n for trigger in self.triggers:\n xml_strings.append(self.triggers[trigger].to_xml())\n xml_strings.append('</table>')\n return \"\".join(xml_strings)","def list_syms():\n\tSymStringVec=[];\n\tSymStringVec.append(\"CSYM\");\n\tSymStringVec.append(\"DSYM\");\n\tSymStringVec.append(\"TET_SYM\");\n\tSymStringVec.append(\"OCT_SYM\");\n\tSymStringVec.append(\"ICOS_SYM\");\n\tSymStringVec.append(\"ISYM\");\n\treturn SymStringVec","def symbol_factory(self, id, bp=0):\n try:\n s = self.sym[id] # if already in table don't do anything. Memoized\n except KeyError as e:\n\n class s(BaseSymbol): \n # create appropriate symbol class at run time\n pass\n\n s.__name__ = \"sym(\" + id + \")\"\n s.id = id\n s.lbp = bp\n s.parent = self\n self.sym[id] = s\n else:\n s.lbp = max(bp, s.lbp)\n return s # NOTE: This function does not returns an object. It returns the class","def get_symbol(self):\n return []","def __str__(self):\n\n table_list = [self.headers]\n\n for row in self.data:\n table_list.append([row[col] or \"\" for col in self.headers])\n\n return create_table_string(table_list)","def to_frame(self):\n # Create a set of dictionaries/lists for each column\n data = dict([(i_var.name, []) for i_var in self.inputs])\n data.update({self.OUTPUT_LABEL: [], self.INPUT_LABEL: [], self.name: []})\n\n # A very ugly loop to produce all the probabilities in a nice way.\n # Note that this just reproduces what is already in `self.lookup`.\n # Honestly, I just haven't thought of a better way to get nice output.\n for i_index, i_state in enumerate(self.input_states):\n for o_var, results in zip(self.outputs, self.per_state_results):\n for o_state, o_p in enumerate(results[i_index]):\n for i_var, s in zip(self.inputs, i_state):\n data[i_var.name].append(s)\n data[self.OUTPUT_LABEL].append(o_var.name)\n data[self.INPUT_LABEL].append(o_state)\n data[self.name].append(o_p)\n all_data = pd.DataFrame(data=data)\n\n # The magnificent pivot table function does all the work\n return pd.pivot_table(data=all_data, values=[self.name],\n index=[i_var.name for i_var in self.inputs],\n columns=[self.OUTPUT_LABEL, self.INPUT_LABEL])","def frame(self):\n return _generate_generic_frame(len(self.table), self.unit, self.names, self.physical_types)","def symbol_state_map(self):\n map = {}\n for state in self:\n map[state.symbol] = state\n map.update(self.symbol_synonyms)\n if not self.case_sensitive:\n for state in self:\n if state.symbol.islower():\n map[state.symbol.upper()] = state\n else:\n map[state.symbol.lower()] = state\n for symbol, state in self.symbol_synonyms.items():\n if symbol.islower():\n map[symbol.upper()] = state\n else:\n map[symbol.lower()] = state\n return map","def get_structure(self):\n if len(self.headers) == 0:\n self.restore_structure()\n columns = self.parse_declaration()\n result = \"<tablestructure>\\n\"\n result += \"\\t<table id=\\\"%s\\\" name=\\\"%s\\\">\\n\" % (self.id, self.name)\n result += \"\\t<header>\\n\"\n for header in self.headers:\n result += \"\\t\\t%s\\n\" % columns[header].to_xml()\n result += \"\\t</header>\\n\"\n result += \"\\t</table>\\n\"\n result += \"</tablestructure>\"\n return result","def create_state_symbols(nVars,nParams):\n\n nSensitivityEqs = nVars * nParams\n\n #state variables\n x_sp = np.array(sp.symbols('x0:' + str(nVars)))\n\n #sensitivity variables\n sensitivity_sp = np.array(list(sp.symbols('s0:' + str(nSensitivityEqs))))\n\n return [x_sp,sensitivity_sp]","def build_table(self):\n if len(self._abslines) == 0:\n return\n comp_tbl = QTable()\n comp_tbl.add_column(Column([iline.wrest.to(u.AA).value for iline in self._abslines]*u.AA,name='wrest'))\n for attrib in ['z', 'flagN', 'N', 'Nsig']:\n comp_tbl.add_column(Column([iline.attrib[attrib] for iline in self._abslines], name=attrib))\n # Return\n return comp_tbl","def mono_table():\n return Table(\n {\n \"obs_id\": [1, 1, 1, 1, 1, 2],\n \"event_id\": [1, 1, 1, 2, 2, 1],\n \"tel_id\": [1, 2, 3, 5, 7, 1],\n \"hillas_intensity\": [1, 2, 0, 1, 5, 9],\n \"hillas_width\": [0.1, 0.2, 0.1, 0.1, 0.2, 0.1] * u.deg,\n \"hillas_length\": 3 * ([0.1, 0.2, 0.1, 0.1, 0.2, 0.1] * u.deg),\n \"dummy_tel_energy\": [1, 10, 4, 0.5, 0.7, 1] * u.TeV,\n \"dummy_tel_is_valid\": [\n True,\n True,\n True,\n True,\n False,\n False,\n ],\n \"classifier_tel_prediction\": [1, 0, 0.5, 0, 0.6, 1],\n \"classifier_tel_is_valid\": [\n True,\n True,\n False,\n True,\n True,\n True,\n ],\n \"disp_tel_alt\": [58.5, 58, 62.5, 72, 74.5, 81] * u.deg,\n \"disp_tel_az\": [12.5, 15, 13, 21, 20, 14.5] * u.deg,\n \"disp_tel_is_valid\": [\n True,\n False,\n True,\n True,\n True,\n True,\n ],\n }\n )","def __repr__(self):\n return \"[\" + \", \".join([str(member) for member in self.table]).rstrip(\",\") + \"]\"","def build_extension_symtab(ext_type):\n table = ext_type.attribute_table\n for attr_name, attr_type in table.attributedict.iteritems():\n ext_type.symtab[attr_name] = symtab.Variable(attr_type,\n promotable_type=False)","def get_symbols(self):\n\n raise NotImplementedError('''\n Must implement get_symbols. Call help() for details.\n ''')","def __init__(self):\n self.table = {}","def __init__(self, symbols, short_window, long_window, command_execute):\n\n\t\t# Create a new Macs object for every stock\n\t\tself.data = {s: Macs(short_window, long_window) for s in symbols}\n\t\tself.command_execute = command_execute","def get_table(self):\n return copy.deepcopy(self._table)","def build_import_table(self):\n self.section_alignment = 4096\n pe = pefile.PE(data=self.mem_dump.dump)\n IAT_addr = pe.OPTIONAL_HEADER.DATA_DIRECTORY[1].VirtualAddress\n print 'IAT_addr: ' + hex(IAT_addr)\n raw_size = self.import_table.raw_memory_size()\n jump_table_size = self.import_table.get_jump_table_size()\n\n print \"raw_size: \", `raw_size`\n print \"jump table size: \", `jump_table_size`\n\n size = ((raw_size+jump_table_size) / self.section_alignment + 1) * self.section_alignment\n print size\n byte_array = bytearray(size)\n IID_pos = 0\n content_pos = (len(self.import_table.dlls) + 1) * 20\n\n jump_table_pos = IID_pos + raw_size\n\n print \"jump table position: \", hex(jump_table_pos)\n\n for dll in self.import_table.dlls:\n print dll\n thunk_position = content_pos + len(dll) + 1\n byte_array[IID_pos + 12:IID_pos + 16] = pack('<L', content_pos + IAT_addr)\n byte_array[IID_pos + 16:IID_pos + 20] = pack('<L', thunk_position + IAT_addr)\n\n print 'Dll position: ', content_pos\n byte_array[content_pos:content_pos + len(dll)] = dll\n names_pos = thunk_position + (len(self.import_table.dlls[dll]) + 1) * 4\n\n for function_name in self.import_table.dlls[dll]:\n self.import_table.set_thunk_addr(dll, function_name, thunk_position + IAT_addr)\n byte_array[thunk_position:thunk_position + 4] = pack('<L', names_pos + IAT_addr)\n func_name = '\\x00\\x00' + function_name\n func_name_len = len(function_name) + 2\n byte_array[names_pos:names_pos + func_name_len] = func_name\n\n\n # Write the jump table entry \n byte_array[jump_table_pos] = 0xFF\n byte_array[jump_table_pos+1] = 0x25\n byte_array[jump_table_pos+2:jump_table_pos+6] = pack(\"<L\", thunk_position + IAT_addr + self.mem_dump.base_address)\n\n self.import_table.set_jump_addr(dll, function_name, jump_table_pos + IAT_addr)\n\n # Accumulate the new counters\n thunk_position += 4\n names_pos += func_name_len\n jump_table_pos += 6\n\n IID_pos += 20\n content_pos = names_pos + 1\n\n self.mem_dump.append_memory_before_end(byte_array, IAT_addr)","def table_fields() -> Dict[str, TableFieldDetails]:\n return {\n \"REPEATS\": TableFieldDetails(\n subtype=\"uint\",\n bit_low=0,\n bit_high=15,\n description=\"Number of times the line will repeat\",\n labels=None,\n ),\n \"TRIGGER\": TableFieldDetails(\n subtype=\"enum\",\n bit_low=16,\n bit_high=19,\n description=\"The trigger condition to start the phases\",\n labels=[\n \"Immediate\",\n \"BITA=0\",\n \"BITA=1\",\n \"BITB=0\",\n \"BITB=1\",\n \"BITC=0\",\n \"BITC=1\",\n \"POSA>=POSITION\",\n \"POSA<=POSITION\",\n \"POSB>=POSITION\",\n \"POSB<=POSITION\",\n \"POSC>=POSITION\",\n \"POSC<=POSITION\",\n ],\n ),\n \"POSITION\": TableFieldDetails(\n subtype=\"int\",\n bit_low=32,\n bit_high=63,\n description=\"The position that can be used in trigger condition\",\n labels=None,\n ),\n \"TIME1\": TableFieldDetails(\n subtype=\"uint\",\n bit_low=64,\n bit_high=95,\n description=\"The time the optional phase 1 should take\",\n labels=None,\n ),\n \"OUTA1\": TableFieldDetails(\n subtype=\"uint\",\n bit_low=20,\n bit_high=20,\n description=\"Output A value during phase 1\",\n labels=None,\n ),\n \"OUTB1\": TableFieldDetails(\n subtype=\"uint\",\n bit_low=21,\n bit_high=21,\n description=\"Output B value during phase 1\",\n labels=None,\n ),\n \"OUTC1\": TableFieldDetails(\n subtype=\"uint\",\n bit_low=22,\n bit_high=22,\n description=\"Output C value during phase 1\",\n labels=None,\n ),\n \"OUTD1\": TableFieldDetails(\n subtype=\"uint\",\n bit_low=23,\n bit_high=23,\n description=\"Output D value during phase 1\",\n labels=None,\n ),\n \"OUTE1\": TableFieldDetails(\n subtype=\"uint\",\n bit_low=24,\n bit_high=24,\n description=\"Output E value during phase 1\",\n labels=None,\n ),\n \"OUTF1\": TableFieldDetails(\n subtype=\"uint\",\n bit_low=25,\n bit_high=25,\n description=\"Output F value during phase 1\",\n labels=None,\n ),\n \"TIME2\": TableFieldDetails(\n subtype=\"uint\",\n bit_low=96,\n bit_high=127,\n description=\"The time the mandatory phase 2 should take\",\n labels=None,\n ),\n \"OUTA2\": TableFieldDetails(\n subtype=\"uint\",\n bit_low=26,\n bit_high=26,\n description=\"Output A value during phase 2\",\n labels=None,\n ),\n \"OUTB2\": TableFieldDetails(\n subtype=\"uint\",\n bit_low=27,\n bit_high=27,\n description=\"Output B value during phase 2\",\n labels=None,\n ),\n \"OUTC2\": TableFieldDetails(\n subtype=\"uint\",\n bit_low=28,\n bit_high=28,\n description=\"Output C value during phase 2\",\n labels=None,\n ),\n \"OUTD2\": TableFieldDetails(\n subtype=\"uint\",\n bit_low=29,\n bit_high=29,\n description=\"Output D value during phase 2\",\n labels=None,\n ),\n \"OUTE2\": TableFieldDetails(\n subtype=\"uint\",\n bit_low=30,\n bit_high=30,\n description=\"Output E value during phase 2\",\n labels=None,\n ),\n \"OUTF2\": TableFieldDetails(\n subtype=\"uint\",\n bit_low=31,\n bit_high=31,\n description=\"Output F value during phase 2\",\n labels=None,\n ),\n }","def __init__(self, lzw_min_code_sz, col_table_sz):\n self.code_table = dict()\n clear_code = 1<<lzw_min_code_sz\n eoi_code = clear_code + 1\n self.code_table[clear_code] = [CLEARCODEVAL]\n self.code_table[eoi_code] = [EOICODEVAL]\n for color in range(col_table_sz):\n self.code_table[color] = [color]","def makeTableNamesList(n, ):","def _prepare_links_table(self):\n\n links_tbl = OrderedDict()\n for colname in itertools.islice(self._pinfos, 1, None):\n links_tbl[colname] = {}\n links_tbl[colname][\"name\"] = f\"{colname}\"\n fname = colname.replace(\"%\", \"_pcnt\") + \".html\"\n links_tbl[colname][\"fname\"] = fname\n links_tbl[colname][\"hlink\"] = f\"<a href=\\\"{fname}\\\">{colname}</a>\"\n\n return links_tbl","def _index_symbols(predicates, functions):\n symbols, symbol_types = OrderedDict(), {}\n\n for s in predicates:\n argtypes = [t.type for t in s.arguments]\n symbols[s.name] = base.Predicate(s.name, argtypes)\n symbol_types[s.name] = 'bool'\n\n for s in functions:\n if s.name != 'total-cost': # Ignore the \"fake\" total-cost function\n argtypes = [t.type for t in s.arguments]\n symbols[s.name] = base.Function(s.name, argtypes, s.type)\n symbol_types[s.name] = s.type\n\n return symbols, symbol_types","def __getFontTable(self):\n\n fontTable = \"{\\\\fonttbl\\n\"\n for font in self.fonts:\n fontTable += \"%s\\n\" % font.getRtf()\n return fontTable + \"}\\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)","def items(self):\n cdef sym.SymbolTableIterator* it = new sym.SymbolTableIterator(self.table[0])\n try:\n while not it.Done():\n yield (it.Symbol().decode('utf8'), it.Value())\n it.Next()\n finally:\n del it","def get_package_hash_table():\n return packageHashTable","def set_symbols(self, symboltable: dict):\n\n for index in range(1, self.symbol_layout.rowCount()):\n self.symbol_layout.removeRow(index)\n\n font = QFont('Fira Code', 8, QFont.Medium)\n for entry in symboltable:\n symbol = QLineEdit()\n symbol.setReadOnly(True)\n symbol.setText(entry)\n symbol.setFont(font)\n address = QLineEdit()\n address.setReadOnly(True)\n address.setFont(font)\n address.setText(str(symboltable[entry]))\n self.symbol_layout.addRow(address, symbol)","def make_symbolic(symfile_path=\"fung_Dsym\",resym=False):\n # Construct the quadratic form as a flat list of independent entries\n q = np.array([sp.symbols('q_{}{}'.format(i,j)) for \n (i,j) in lin.utri_indices(6)])\n\n # We also need its matrix form\n Q = np.empty((6,6),dtype=object)\n for (k,(i,j)) in zip(range(len(q)),lin.utri_indices(6)):\n Q[i,j] = q[k]\n Q[j,i] = Q[i,j]\n\n # Construct the Lagrangian strain (E) as a *vector* (e)\n f = np.array([sp.symbols('f_{i}'.format(i=i)) for i in range(9)])\n F = np.reshape(f,(3,3))\n J = sp.Matrix(F.tolist()).det()\n # TODO: Is this supposed to be J**(-4/3) or J**(-2/3)?\n E = 0.5*(J**sp.Rational(-2,3)*np.dot(F.T,F) - np.eye(3))\n e = lin.utri_flat(E)\n\n # Expand the quadratic form's action on e\n Qee = np.dot(e,np.dot(Q,e))\n\n # Attempt to load this from a pickle file\n try:\n Dsym = pickle.load(open(symfile_path+\".pkl\",'rb'))\n\n # Otherwise, just recompute it\n except Exception:\n # Construct the tangent stiffness as a symbolic expression\n\n # Calculate first derivatives\n dQ = np.empty(9,dtype=object)\n for i in range(9):\n print(\"Symbolic dQ_{}\".format(i))\n dQ[i] = sp.diff(Qee,f[i])\n\n # Calculate second derivatives\n Dsym = np.empty((9,9),dtype=object)\n for (i,j) in lin.utri_indices(9):\n print(\"Symbolic ddQ_{0}{1}\".format(i,j))\n dQi = dQ[i]\n dQj = dQ[j]\n dQij = sp.diff(dQi,f[j])\n Dsym[i,j] = dQi*dQj + dQij\n\n # Optimize the derivative by substituting for J\n print(\" Simplifying...\")\n print(\" J \",end=\"\")\n sys.stdout.flush()\n Dsym[i,j] = Dsym[i,j].subs(J,sp.symbols('J'))\n # Further optimize by replacing products of f compoenents\n if resym == True:\n for (k,l) in lin.utri_indices(9):\n print(\"f{}f{}\".format(k,l),end=\" \")\n sys.stdout.flush()\n pair_symbol = sp.symbols('ff_{0}{1}'.format(k,l))\n Dsym[i,j] = Dsym[i,j].subs(f[k]*f[l],pair_symbol)\n # Since D will be symmetric, assign the symmetric components\n print(\"\\n Symmetrizing...\")\n Dsym[j,i] = Dsym[i,j]\n # This computation is pretty costly, so let's save it\n # frequently\n if resym == True:\n pickle.dump(Dsym, open(symfile_path+\"_{}{}.pkl\".format(i,j),'wb'))\n pickle.dump(Dsym, open(symfile_path+\".pkl\",'wb'))\n\n return Dsym","def make_typedefs(self):\n type_dict = self.python_madz_types_dict + self.mangled_namespace\n res = \"{} = {{}}\\n\".format(type_dict)\n\n for node in self.description.declarations():\n varname = self.python_madz_types + self.mangled_namespace + \"___\" + node.name\n # Hack to get self referential top level structs.\n if (node.type.node_type() == pdl.TypeStruct):\n self._is_top_level = varname\n res += self.gen_type_string(node.type)\n res += \"\\n\"\n else:\n res += \"{} = {}\\n\".format(varname, self.gen_type_string(node.type))\n res += \"{}['{}'] = {}\\n\".format(type_dict, node.name, varname)\n return res","def startSubroutine(self):\n self.subroutineTable = {}\n self.counts[\"ARG\"] = 0\n self.counts[\"VAR\"] = 0\n\n if self.DEBUG:\n print(\"DEBUG(SymbolTable): Reset subroutine symbol table\")","def build_table():\n with contextlib.ExitStack() as stack:\n files = [stack.enter_context(gzip.open(f, 'rt')) for f in sys.argv[1:]]\n iters = [(line.split() for line in f) for f in files]\n for it in iters:\n next(it)\n key = operator.itemgetter(0)\n table = []\n for k, g in itertools.groupby(merge(*iters, key=key), key=key):\n props = list(g)\n if len(props) == len(iters):\n table.append([k] + [x[1] for x in props])\n for snp in table:\n print(*snp)","def buildTypedefInfoDeclaration(self):\n if len(self.name) == 0:\n dec = \"<p>Aliases an anonymous enumeration.</p>\\n\"\n else:\n dec = \"<p>Aliases a enumeration, called: '\"+self.name+\"'.</p>\\n\"\n dec += \"<p>\"+self.info+\"</p>\\n\"\n dec += \"<table border=1 cellpadding=5>\\n\"\n for entry in self.entries:\n dec += entry.buildFullInfoDeclaration()\n dec += \"</table>\\n\"\n return dec","def to_table(self):\n table = Table()\n table['THETA_LO'] = Quantity([self.counts.offset[:-1]], unit=self.counts.offset.unit)\n table['THETA_HI'] = Quantity([self.counts.offset[1:]], unit=self.counts.offset.unit)\n table['ENERG_LO'] = Quantity([self.counts.energy[:-1]], unit=self.counts.energy.unit)\n table['ENERG_HI'] = Quantity([self.counts.energy[1:]], unit=self.counts.energy.unit)\n table['counts'] = self.counts.to_table()['data']\n if self.counts.data_err is not None:\n table['counts_err'] = self.counts.to_table()['data_err']\n table['livetime'] = self.livetime.to_table()['data']\n table['bkg'] = self.bg_rate.to_table()['data']\n if self.bg_rate.data_err is not None:\n table['bkg_err'] = self.bg_rate.to_table()['data_err']\n table.meta['HDUNAME'] = \"bkg_2d\"\n return table"],"string":"[\n \"def __str__(self):\\n dictt = self.getFullDict()\\n return \\\"SymbolTable(\\\\n{}\\\\n)\\\".format(pprint.pformat(dictt))\",\n \"def symbol_table(self) -> str:\\n return self._symbol_table\",\n \"def getSymbolTable(self) -> ghidra.app.util.bin.format.pe.debug.DebugCodeViewSymbolTable:\\n ...\",\n \"def __init__(self, DEBUG=False):\\n self.DEBUG = DEBUG\\n\\n self.classTable = {}\\n self.subroutineTable = {}\\n\\n self.counts = {}\\n self.counts[\\\"STATIC\\\"] = 0\\n self.counts[\\\"FIELD\\\"] = 0\\n self.counts[\\\"ARG\\\"] = 0\\n self.counts[\\\"VAR\\\"] = 0\\n\\n if self.DEBUG:\\n print(\\\"DEBUG(SymbolTable): INITIALIZED SYMBOL TABLES\\\")\",\n \"def generate_symbol_struct(mode, symbols, definition):\\n if \\\"vanilla\\\" == mode:\\n return \\\"\\\"\\n definitions = []\\n hashes = []\\n symbol_table_content = \\\"\\\"\\n for ii in symbols:\\n definitions += [\\\" %s;\\\" % (ii.generate_definition())]\\n hashes += [\\\" %s%s,\\\" % (ii.generate_prototype(), ii.get_hash())]\\n if \\\"dlfcn\\\" != mode:\\n symbol_table_content = \\\" =\\\\n{\\\\n%s\\\\n}\\\" % (\\\"\\\\n\\\".join(hashes))\\n return template_symbol_table % (definition, \\\"\\\\n\\\".join(definitions), symbol_table_content)\",\n \"def __str__(self) -> str:\\n\\n return self._format_symbol_table_content(\\\"Symbol table\\\", self._symbols.items())\",\n \"def generate_table(self):\\n states = self.get_canonical_collection()\\n # self.print_canonical_collection(states)\\n table = [{} for _ in range(len(states))]\\n\\n for index in range(len(states)):\\n state = states[index]\\n first_rule_cnt = 0\\n second_rule_cnt = 0\\n third_rule_cnt = 0\\n beta = []\\n for prod in state:\\n dot_index = prod[1].index('.')\\n alpha = prod[1][:dot_index]\\n beta = prod[1][dot_index + 1:]\\n if len(beta) != 0:\\n first_rule_cnt += 1\\n else:\\n if prod[0] != 'S1':\\n second_rule_cnt += 1\\n production_index = self.grammar.P.index((prod[0], alpha))\\n elif alpha == [self.grammar.S[0]]:\\n third_rule_cnt += 1\\n if first_rule_cnt == len(state):\\n table[index]['action'] = 'shift'\\n\\n elif second_rule_cnt == len(state):\\n table[index]['action'] = 'reduce ' + str(production_index)\\n\\n elif third_rule_cnt == len(state):\\n table[index]['action'] = 'acc'\\n else:\\n conflict_msg = 'Conflict! State I' + str(index) + ': ' + str(state) + '\\\\nSymbol: ' + beta[0]\\n raise (Exception(conflict_msg))\\n for symbol in self.grammar.N + self.grammar.E: # the goto part of the table\\n next_state = self.go_to(state, symbol)\\n if next_state in states:\\n table[index][symbol] = states.index(next_state)\\n # print(\\\"table\\\", table)\\n return table\",\n \"def __init__(self):\\r\\n self.s_table = SymbolTable.preSymbols\",\n \"def __generate_symboltable(self, code):\\n\\n code_without_lables = []\\n address = 0\\n for line in code:\\n label_code = line.split(':')\\n label = label_code[0]\\n if len(label) != len(line):\\n self.__symboltable[label] = address\\n address += REG_SIZE\\n instruction = label_code.pop().strip()\\n code_without_lables = code_without_lables + [instruction]\\n else:\\n instruction = label_code.pop().strip()\\n code_without_lables = code_without_lables + [instruction]\\n\\n tokens = instruction.split(' ')\\n asm_directive = tokens[0]\\n if tokens[0] in AssemblerDirectives.to_string():\\n if asm_directive == AssemblerDirectives.ORG.name:\\n address = int(tokens[1])\\n else:\\n address += REG_SIZE\\n\\n return code_without_lables\",\n \"def __init__(self, epsilon=EPSILON):\\n cdef bytes name = 'SymbolTable<{0}>'.format(id(self)).encode('ascii')\\n self.table = new sym.SymbolTable(<string> name)\\n assert (self[epsilon] == EPSILON_ID)\",\n \"def create_symbol_table(root):\\n\\n set_depth(root, 0)\\n #Initialize the stack, with the AST root\\n stack = Stack(root)\\n\\n #the symbol table maps the name to the scope.\\n #Any node can belong to multiple scopes, therefore this\\n #is a list of scope\\n symbol_table = STable()\\n \\n #this represents objects imported from\\n #other modules\\n other_modules = {}\\n\\n for node, children, ntype in stack:\\n\\n if ntype == \\\"Import\\\":\\n #Import object has names prop which\\n #is an array of names\\n for name in node.names:\\n #name can be the name or an alias \\n name_val = name.asname or name.name\\n #insert in symbol_table \\n symbol_table[name_val] = ()\\n\\n elif ntype == \\\"ImportFrom\\\":\\n if node.names[0].name == '*':\\n try:\\n imp_mod = importlib.import_module(node.module)\\n #Add all names in imported module, except those\\n #starting with '_'\\n for name in dir(imp_mod):\\n if name[0] != '_':\\n symbol_table[name] = stack_top(scopes)\\n\\n except ImportError:\\n print \\\"Error: local system does not have {}. Skipping!\\\".format(node.module)\\n pass\\n else:\\n #TODO: store node.module\\n for name in node.names:\\n #TODO: store name.name even if name.asname defined \\n name_val = name.asname or name.name\\n symbol_table[name_val] = stack.get_scopes(src_module=node.module)\\n\\n elif ntype == \\\"ClassDef\\\" or ntype == \\\"FunctionDef\\\": \\n symbol_table[node.name] = stack.get_scopes()\\n \\n #NOTE: if a name is being loaded then it already exists and doesn't need\\n #to be added to symbol_table\\n elif ntype == \\\"Name\\\" and not is_load(children) and not has_global(stack.scope_tail(), node.id): \\n symbol_table[node.id] = stack.get_scopes()\\n\\n elif ntype == \\\"arguments\\\":\\n if node.vararg: \\n symbol_table[node.vararg] = stack.get_scopes()\\n if node.kwarg:\\n symbol_table[node.kwarg] = stack.get_scopes()\\n\\n elif ntype == \\\"Global\\\":\\n #add a list global vars on node on the top of \\n #the stack\\n #nonlocal could be handled in similar way\\n set_globals(scopes[-1], node.names)\\n\\n #set lineno property of children nodes\\n set_lineno(node, children)\\n\\n for child in children[::-1]:\\n #set depth of child\\n set_depth(child, node.depth + 1)\\n #Add children to stack\\n stack.append(child)\\n\\n #Add any new scopes\\n #Need to do it here since scoping_nodes are defined in their parent scope\\n stack.check_and_push_scope()\\n\\n print \\\"Symbol table is \\\"\\n print symbol_table\\n return symbol_table\",\n \"def show_symbol_table(st):\\n print(st)\\n # Dump the name lists get_*()\\n if isinstance(st, symtable.Function):\\n for nlist in _NAME_LISTS:\\n names = getattr(st, \\\"get_\\\"+nlist)()\\n if names:\\n print(' {} : {!r}'.format(nlist, names))\\n # Dump the properties as short names is_global -> global, etc..\\n for s in st.get_symbols():\\n scope = to_scope_name(s._Symbol__scope)\\n props = [scope]\\n for p in _NAME_PROPS:\\n if getattr(s, \\\"is_\\\"+p)():\\n props.append(p)\\n print(' \\\"{}\\\" : {}'.format(s.get_name(), ', '.join(props)))\",\n \"def symbol_table(self, value: str):\\n self._symbol_table = value\",\n \"def parse_symbol_table(data, sections, elf_header):\\n if is64bit(elf_header):\\n symbol_entry_str = symbol_64_entry_str\\n symbol_entry_spec = symbol_64_entry_spec\\n else:\\n symbol_entry_str = symbol_32_entry_str\\n symbol_entry_spec = symbol_32_entry_spec\\n entry_len = struct.calcsize(symbol_entry_str)\\n \\n st_offset = None\\n if \\\".symtab\\\" in sections:\\n section = \\\".symtab\\\"\\n if \\\".strtab\\\" in sections:\\n st_offset = sections[\\\".strtab\\\"][\\\"offset\\\"]\\n else:\\n st_offset = sections[section][\\\"offset\\\"]\\n \\n elif \\\".dynsym\\\" in sections:\\n section = \\\".dynsym\\\"\\n if \\\".dynstr\\\" in sections:\\n st_offset = sections[\\\".dynstr\\\"][\\\"offset\\\"]\\n else:\\n st_offset = sections[section][\\\"offset\\\"]\\n \\n \\n if section not in sections:\\n return {}, {} \\n \\n symbols = {}\\n imports = {}\\n offset = sections[section][\\\"offset\\\"]\\n size = sections[section][\\\"size\\\"]\\n index = offset\\n while index < offset + size:\\n vals = {}\\n if len(data) < index+entry_len: \\n break\\n \\n val_data = struct.unpack(symbol_entry_str, data[index:index+entry_len])\\n for i, elem in enumerate(symbol_entry_spec):\\n vals[elem[0]] = val_data[i]\\n \\n if st_offset is None:\\n symbols[vals[\\\"name\\\"]] = vals\\n else:\\n func_name = get_name_from_string_table(data, st_offset, vals[\\\"name\\\"])\\n if func_name:\\n vals.pop(\\\"name\\\")\\n vals[\\\"info\\\"] = get_symbol_info(vals[\\\"info\\\"])\\n vals[\\\"shndx\\\"] = get_symbol_shndx(vals[\\\"shndx\\\"])\\n \\n if vals[\\\"info\\\"] == \\\"UNDEFINED\\\" and vals[\\\"value\\\"] == 0:\\n tmp_name = func_name\\n import_name = \\\"Unknown\\\"\\n if \\\"@@\\\" in func_name:\\n i = tmp_name.find(\\\"@@\\\")\\n func_name = tmp_name[:i]\\n import_name = tmp_name[i:].strip(\\\"@@\\\") \\n if import_name not in imports:\\n imports[import_name] = {}\\n imports[import_name][func_name] = vals\\n symbols[func_name] = vals\\n \\n index += entry_len \\n \\n return symbols, imports\",\n \"def __set_symbol_dict(self):\\r\\n return {0: list(alph) if self.is_case_snstv else list(alph)[:26],\\r\\n 1: list(dgt),\\r\\n 2: list(spcl) if self.is_spcl else []}\",\n \"def construct_table(self):\\n table_str = self.header_row\\n row_lbls, col_lbls = self.get_idxvals()\\n for r,rlbl in enumerate(row_lbls):\\n row_data = [self.data[rlbl,clbl] for clbl in col_lbls]\\n table_str += self.construct_row(r, row_data)\\n \\n return table_str\",\n \"def generate_symbol_definitions(mode, symbols, prefix, definition):\\n direct = []\\n tabled = []\\n for ii in symbols:\\n direct += [ii.generate_rename_direct(prefix)]\\n tabled += [ii.generate_rename_tabled(prefix)]\\n if \\\"vanilla\\\" == mode:\\n tabled = direct\\n return template_symbol_definitions % (definition, \\\"\\\\n\\\".join(direct), \\\"\\\\n\\\".join(tabled))\",\n \"def tables():\\n return {\\n \\\"MAT24_STD_OCTAD\\\" : STD_OCTAD,\\n }\",\n \"def save(self):\\n # First, just allocate enough memory for the SDAT header.\\n data = bytearray(0x40)\\n\\n # -------------------\\n # Make the SYMB block\\n\\n symbolsStringTable = bytearray()\\n def addSymbolAndGetOffset(symbol):\\n if symbol is None:\\n return -1\\n offset = len(symbolsStringTable)\\n symbolsStringTable.extend(symbol.encode('latin-1') + b'\\\\0')\\n return offset\\n\\n symbolsHeaderOffsets = []\\n\\n # Parallel arrays, here.\\n symbolsTableValues = []\\n shouldIncrementByTableLen = []\\n\\n anySymbolsInWholeFile = False\\n\\n def addSymbolsFrom(namedList, nested=False):\\n\\n # First, figure out if any actual symbols exist\\n anyActualSymbols = False\\n anyActualSubsymbols = False\\n if not nested:\\n for symbol, _ in namedList:\\n if symbol is not None:\\n anyActualSymbols = True\\n break\\n else:\\n for symbol, entry in namedList:\\n if symbol is not None:\\n anyActualSymbols = True\\n break\\n for subSymbol, subEntry in entry.sequences:\\n if subSymbol is not None:\\n anyActualSubsymbols = True\\n break\\n\\n\\n nonlocal anySymbolsInWholeFile\\n anySymbolsInWholeFile |= anyActualSymbols\\n anySymbolsInWholeFile |= anyActualSubsymbols\\n\\n # If there *are* any symbols, keep going\\n symbolsHeaderOffsets.append(len(symbolsTableValues) * 4)\\n\\n if not nested:\\n symbolsTableValues.append(len(namedList))\\n shouldIncrementByTableLen.append(False)\\n\\n for symbol, _ in namedList:\\n symbolsTableValues.append(addSymbolAndGetOffset(symbol))\\n shouldIncrementByTableLen.append(True)\\n\\n else:\\n mainList, subListsArea = [], []\\n mainListSIBTL, subListsAreaSIBTL = [], []\\n\\n mainList.append(len(namedList))\\n mainListSIBTL.append(False)\\n\\n mainListFullLength = (1 + 2 * len(namedList)) * 4\\n subListsAreaOffset = (0x40\\n + len(symbolsTableValues) * 4\\n + mainListFullLength)\\n\\n for symbol, entry in namedList:\\n\\n mainList.append(addSymbolAndGetOffset(symbol))\\n mainListSIBTL.append(True)\\n\\n subListOffset = subListsAreaOffset + len(subListsArea) * 4\\n\\n if entry is None:\\n subNames = []\\n else:\\n subNames = [n for (n, s) in entry.sequences]\\n\\n if entry or subNames:\\n subListsArea.append(len(subNames))\\n subListsAreaSIBTL.append(False)\\n\\n for subSymbol in subNames:\\n subListsArea.append(addSymbolAndGetOffset(subSymbol))\\n subListsAreaSIBTL.append(True)\\n\\n mainList.append(subListOffset)\\n mainListSIBTL.append(False)\\n\\n else:\\n mainList.append(0)\\n mainListSIBTL.append(False)\\n\\n symbolsTableValues.extend(mainList)\\n symbolsTableValues.extend(subListsArea)\\n shouldIncrementByTableLen.extend(mainListSIBTL)\\n shouldIncrementByTableLen.extend(subListsAreaSIBTL)\\n\\n addSymbolsFrom(self.sequences)\\n addSymbolsFrom(self.sequenceArchives, True)\\n addSymbolsFrom(self.banks)\\n addSymbolsFrom(self.waveArchives)\\n addSymbolsFrom(self.sequencePlayers)\\n addSymbolsFrom(self.groups)\\n addSymbolsFrom(self.streamPlayers)\\n addSymbolsFrom(self.streams)\\n\\n # Only add the SYMB block if there are any symbols\\n if anySymbolsInWholeFile:\\n symbolsBlockOffset = len(data)\\n\\n symbolsTableLen = len(symbolsTableValues) * 4\\n symbolsTable = bytearray()\\n for value, shouldIncrement in itertools.zip_longest(symbolsTableValues,\\n shouldIncrementByTableLen):\\n if value == -1:\\n symbolsTable.extend(b'\\\\0\\\\0\\\\0\\\\0')\\n else:\\n if shouldIncrement:\\n value += symbolsTableLen + 0x40\\n symbolsTable.extend(struct.pack('<I', value))\\n\\n symbolsBlockSize = 0x40 + len(symbolsTable) + len(symbolsStringTable)\\n paddedSymbSize = symbolsBlockSize\\n while paddedSymbSize % 4:\\n paddedSymbSize += 1\\n if self.padSymbSizeTo4InSDATHeader:\\n symbolsBlockSize = paddedSymbSize\\n\\n symbolsHeaderOffsetsTable = bytearray()\\n for value in symbolsHeaderOffsets:\\n if value is None:\\n symbolsHeaderOffsetsTable.extend(b'\\\\0\\\\0\\\\0\\\\0')\\n else:\\n symbolsHeaderOffsetsTable.extend(struct.pack('<I', value + 0x40))\\n\\n symbolsHeader = struct.pack('<4sI',\\n b'SYMB', paddedSymbSize)\\n\\n data.extend(symbolsHeader)\\n data.extend(symbolsHeaderOffsetsTable)\\n data.extend(b'\\\\0' * 0x18)\\n data.extend(symbolsTable)\\n data.extend(symbolsStringTable)\\n\\n else:\\n symbolsBlockOffset = None\\n symbolsBlockSize = None\\n\\n\\n # -------------------\\n # Make the INFO block\\n while len(data) % 4: data.append(0)\\n infoBlockOffset = len(data)\\n\\n # Add room to add the header later\\n data.extend(b'\\\\0' * (8 + 8 * 4))\\n\\n # Pad to 0x20 relative to the INFO block, for some reason\\n while (len(data) - infoBlockOffset) % 0x20: data.append(0)\\n\\n # Helper functions\\n def info_declarePart(partNumber):\\n struct.pack_into('<I', data, infoBlockOffset + 8 + 4 * partNumber,\\n len(data) - infoBlockOffset)\\n def addFileAndGetID(file, dataMergeOptimizationID):\\n idx = _common.listFind(files, file)\\n\\n while idx != -1:\\n if dataMergeOptimizationID == fileMergeIDs[idx]:\\n return idx\\n idx = _common.listFind(files, file, idx + 1)\\n\\n files.append(file)\\n fileMergeIDs.append(dataMergeOptimizationID)\\n return len(files) - 1\\n\\n # We encode sections out of order, so that the files will be in\\n # the same order as in retail SDATs.\\n fileMergeIDs = []\\n files = []\\n\\n # Info part 0: SSEQ\\n info_declarePart(0)\\n\\n data.extend(struct.pack('<I', len(self.sequences)))\\n sseqOffsetsTableOffset = len(data)\\n data.extend(b'\\\\0' * (4 * len(self.sequences)))\\n\\n for i, (_, sseq) in enumerate(self.sequences):\\n if sseq is None:\\n entryOff = 0\\n else:\\n entryOff = len(data) - infoBlockOffset\\n\\n (file, unk02, bankID, volume, channelPressure,\\n polyphonicPressure, playerID) = sseq.save()\\n fileID = addFileAndGetID(file, sseq.dataMergeOptimizationID)\\n\\n data.extend(struct.pack('<3H4Bxx',\\n fileID, unk02, bankID, volume, channelPressure,\\n polyphonicPressure, playerID))\\n\\n struct.pack_into('<I', data, sseqOffsetsTableOffset + 4 * i, entryOff)\\n\\n # Info part 1: SSAR\\n info_declarePart(1)\\n\\n data.extend(struct.pack('<I', len(self.sequenceArchives)))\\n ssarOffsetsTableOffset = len(data)\\n data.extend(b'\\\\0' * (4 * len(self.sequenceArchives)))\\n\\n for i, (_, ssar) in enumerate(self.sequenceArchives):\\n if ssar is None:\\n entryOff = 0\\n else:\\n entryOff = len(data) - infoBlockOffset\\n\\n file, unk02, _ = ssar.save()\\n fileID = addFileAndGetID(file, ssar.dataMergeOptimizationID)\\n\\n data.extend(struct.pack('<HH',\\n fileID, unk02))\\n\\n struct.pack_into('<I', data, ssarOffsetsTableOffset + 4 * i, entryOff)\\n\\n # Info part 2: SBNK\\n info_declarePart(2)\\n\\n data.extend(struct.pack('<I', len(self.banks)))\\n sbnkOffsetsTableOffset = len(data)\\n data.extend(b'\\\\0' * (4 * len(self.banks)))\\n\\n for i, (sbnkName, sbnk) in enumerate(self.banks):\\n if sbnk is None:\\n entryOff = 0\\n else:\\n entryOff = len(data) - infoBlockOffset\\n\\n file, unk02, waveArchives = sbnk.save()\\n fileID = addFileAndGetID(file, sbnk.dataMergeOptimizationID)\\n\\n swarIDs = []\\n for s in waveArchives:\\n swarIDs.append(-1 if s is None else s)\\n while len(swarIDs) < 4:\\n swarIDs.append(-1)\\n\\n if len(swarIDs) > 4:\\n raise ValueError(f'SBNK {i} (\\\"{sbnkName}\\\") uses '\\n f'{len(swarIDs)} SWARs. The maximum is 4.')\\n\\n data.extend(struct.pack('<HH4h',\\n fileID, unk02, *swarIDs))\\n\\n struct.pack_into('<I', data, sbnkOffsetsTableOffset + 4 * i, entryOff)\\n\\n\\n # Info part 3: SWAR\\n info_declarePart(3)\\n\\n data.extend(struct.pack('<I', len(self.waveArchives)))\\n swarOffsetsTableOffset = len(data)\\n data.extend(b'\\\\0' * (4 * len(self.waveArchives)))\\n\\n for i, (_, swar) in enumerate(self.waveArchives):\\n if swar is None:\\n entryOff = 0\\n else:\\n entryOff = len(data) - infoBlockOffset\\n\\n file, unk02 = swar.save()\\n fileID = addFileAndGetID(file, swar.dataMergeOptimizationID)\\n\\n data.extend(struct.pack('<HH',\\n fileID, unk02))\\n\\n struct.pack_into('<I', data, swarOffsetsTableOffset + 4 * i, entryOff)\\n\\n\\n # Info part 4: Sequence players\\n info_declarePart(4)\\n\\n data.extend(struct.pack('<I', len(self.sequencePlayers)))\\n spOffsetsTableOffset = len(data)\\n data.extend(b'\\\\0' * (4 * len(self.sequencePlayers)))\\n\\n for i, (_, sp) in enumerate(self.sequencePlayers):\\n if sp is None:\\n entryOff = 0\\n else:\\n entryOff = len(data) - infoBlockOffset\\n\\n maxSequences, channels, heapSize = sp.save()\\n\\n channelMask = 0\\n for j in range(16):\\n if j in channels:\\n channelMask |= 1 << j\\n\\n data.extend(struct.pack('<HHI',\\n maxSequences, channelMask, heapSize))\\n\\n struct.pack_into('<I', data, spOffsetsTableOffset + 4 * i, entryOff)\\n\\n\\n # Info part 5: Groups\\n info_declarePart(5)\\n\\n data.extend(struct.pack('<I', len(self.groups)))\\n groupOffsetsTableOffset = len(data)\\n data.extend(b'\\\\0' * (4 * len(self.groups)))\\n\\n for i, (_, group) in enumerate(self.groups):\\n if group is None:\\n entryOff = 0\\n else:\\n entryOff = len(data) - infoBlockOffset\\n\\n data.extend(struct.pack('<I', len(group)))\\n\\n for gEntry in group:\\n data.extend(struct.pack('<BHxI', *gEntry.save()))\\n\\n struct.pack_into('<I', data, groupOffsetsTableOffset + 4 * i, entryOff)\\n\\n\\n # Info part 6: Stream players\\n info_declarePart(6)\\n\\n data.extend(struct.pack('<I', len(self.streamPlayers)))\\n spOffsetsTableOffset = len(data)\\n data.extend(b'\\\\0' * (4 * len(self.streamPlayers)))\\n\\n for i, (_, sp) in enumerate(self.streamPlayers):\\n if sp is None:\\n entryOff = 0\\n else:\\n entryOff = len(data) - infoBlockOffset\\n\\n channels = sp.save()\\n chanCount = len(channels)\\n while len(channels) < 16:\\n channels.append(0xFF)\\n\\n data.append(chanCount)\\n data.extend(channels)\\n\\n # This has to occur in order for the padding to work out\\n # correctly. Weird, but, what can you do. Might even be\\n # an unknown value.\\n data.extend(b'\\\\0\\\\0\\\\0\\\\0')\\n\\n struct.pack_into('<I', data, spOffsetsTableOffset + 4 * i, entryOff)\\n\\n while len(data) % 4: data.append(0)\\n\\n\\n # Info part 7: Streams\\n info_declarePart(7)\\n\\n data.extend(struct.pack('<I', len(self.streams)))\\n strmOffsetsTableOffset = len(data)\\n data.extend(b'\\\\0' * (4 * len(self.streams)))\\n\\n for i, (_, strm) in enumerate(self.streams):\\n if strm is None:\\n entryOff = 0\\n else:\\n entryOff = len(data) - infoBlockOffset\\n\\n file, unk02, volume, priority, playerID, unk07 = strm.save()\\n fileID = addFileAndGetID(file, strm.dataMergeOptimizationID)\\n\\n data.extend(struct.pack('<HH4B4x',\\n fileID, unk02, volume, priority, playerID, unk07))\\n\\n struct.pack_into('<I', data, strmOffsetsTableOffset + 4 * i, entryOff)\\n\\n # Now we can finally fill the header in.\\n struct.pack_into('<4sI', data, infoBlockOffset,\\n b'INFO', len(data) - infoBlockOffset)\\n\\n infoBlockSize = len(data) - infoBlockOffset\\n\\n\\n # ----------------------\\n # Make a dummy FAT block, to be filled in when adding to the\\n # FILE block\\n\\n while len(data) % 4: data.append(0)\\n fatBlockOffset = len(data)\\n fatBlockSize = 0xC + 0x10 * len(files)\\n fatTableOffset = fatBlockOffset + 0xC\\n\\n fatHeader = struct.pack('<4sII',\\n b'FAT ', 0xC + 0x10 * len(files), len(files))\\n\\n data.extend(fatHeader)\\n data.extend(b'\\\\0' * (0x10 * len(files)))\\n\\n\\n # -------------------\\n # Make the FILE block and fill in the FAT block\\n while len(data) % 4: data.append(0)\\n fileBlockOffset = len(data)\\n\\n # Dummy header (to be filled in after we know the total size)\\n data.extend(b'\\\\0' * 0xC)\\n\\n # Some games align the first file differently\\n if self.firstFileAlignment is not None:\\n while len(data) % self.firstFileAlignment:\\n data.append(0)\\n\\n # Add each file\\n for i, file in enumerate(files):\\n\\n # Files must be aligned to 0x20 relative to the SDAT\\n # itself... usually. Some games align to other amounts.\\n while len(data) % self.fileAlignment:\\n data.append(0)\\n\\n # Actually add the file\\n fileOffset = len(data)\\n data.extend(file)\\n \\n # Add the appropriate FAT entry\\n fLen = len(file)\\n if self.fatLengthsIncludePadding:\\n while fLen % self.fileAlignment: fLen += 1\\n\\n struct.pack_into('<II', data, fatTableOffset + 0x10 * i,\\n fileOffset, fLen)\\n\\n # And one last pad for good measure. (And because retail files\\n # do so.)\\n if self.padAtEnd:\\n while len(data) % self.fileAlignment:\\n data.append(0)\\n\\n # Add the header\\n struct.pack_into('<4sII', data, fileBlockOffset,\\n b'FILE', len(data) - fileBlockOffset, len(files))\\n\\n fileBlockSize = len(data) - fileBlockOffset\\n\\n\\n # -----------------------\\n # Put the blocks together\\n\\n # Write the SDAT header\\n struct.pack_into('<8I', data, 0x10,\\n 0 if symbolsBlockOffset is None else symbolsBlockOffset,\\n 0 if symbolsBlockSize is None else symbolsBlockSize,\\n 0 if infoBlockOffset is None else infoBlockOffset,\\n 0 if infoBlockSize is None else infoBlockSize,\\n 0 if fatBlockOffset is None else fatBlockOffset,\\n 0 if fatBlockSize is None else fatBlockSize,\\n 0 if fileBlockOffset is None else fileBlockOffset,\\n 0 if fileBlockSize is None else fileBlockSize)\\n\\n # Write the standard header to the beginning\\n _common.NDS_STD_FILE_HEADER.pack_into(data, 0,\\n b'SDAT', 0xFEFF, 0x100, len(data), 0x40,\\n 3 if symbolsBlockOffset is None else 4)\\n\\n return data\",\n \"def create_symbol_to_possible_cell_mapping(self):\\r\\n symbols_to_cells = defaultdict(set)\\r\\n for cell in self.iterate_empty_cells():\\r\\n for symbol in cell.get_possible_symbols():\\r\\n symbols_to_cells[symbol].add(cell)\\r\\n return symbols_to_cells\",\n \"def _get_symbols(self):\\n\\n symbols = self.get_symbols()\\n\\n if isinstance(symbols, dict):\\n keys = ['symbol', 'from_symbol', 'to_symbol']\\n correct_keys = np.isin(keys, list(symbols.keys())).all()\\n\\n if not correct_keys:\\n raise ImplementationError('''\\n Dict should be in the form:\\n {'symbol':[], 'from_symbol':[], 'to_symbol':[]}\\n ''')\\n else:\\n symbols = pd.DataFrame(symbols, index = [symbols['symbol']])\\n\\n symbols.index = symbols.symbol\\n\\n return symbols\",\n \"def _format_symbol_table_content(self, title: str, symbols: Any) -> str:\\n\\n header = f\\\"\\\\t\\\\t:::: {title} ::::\\\"\\n lines = [\\\"\\\\n\\\", header, \\\"__\\\" * len(header)]\\n if type(symbols).__name__ == \\\"odict_items\\\":\\n lines.extend((f\\\"| {key}: {value}\\\") for key, value in self._symbols.items())\\n elif type(symbols).__name__ == \\\"odict_keys\\\":\\n lines.extend((f\\\"| {key}\\\") for key in self._symbols.keys())\\n\\n lines.append(\\\"\\\\n\\\")\\n formatted_content = \\\"\\\\n\\\".join(lines)\\n return formatted_content\",\n \"def list_symbol_tables(mst):\\n stlist = []\\n def append_st(st):\\n #print(st)\\n stlist.append(st)\\n for s in st.get_symbols():\\n for ns in s.get_namespaces():\\n append_st(ns)\\n if not isinstance(mst, symtable.SymbolTable):\\n # Assume it is text of a program to compile\\n mst = symtable.symtable(mst, '<string>', 'exec')\\n append_st(mst)\\n return stlist\",\n \"def return_astropy_table(self):\\n table = Table()\\n for name in self.hdfile.root.Data.Fibers.colnames:\\n if hasattr(self, name):\\n table[name] = getattr(self, name)\\n\\n return table\",\n \"def return_astropy_table(self):\\n table = Table()\\n for name in self.hdfile.root.Data.Fibers.colnames:\\n if hasattr(self, name):\\n table[name] = getattr(self, name)\\n\\n return table\",\n \"def __repr__(self):\\n return 'HashTable({!r})'.format(self.items())\",\n \"def execute(self, symbol_table, test_mode=False):\",\n \"def execute(self, symbol_table, test_mode=False):\",\n \"def _symbols_table_file_content(\\n rule_set: _RewriteRuleSet) -> Generator[str, None, None]:\\n\\n def _line(symbol: str, index: int) -> str:\\n return f\\\"{symbol}\\\\t{index}\\\\n\\\"\\n\\n fst_symbols = []\\n\\n for rule in rule_set.rule:\\n fst_symbols.extend(_symbols_of_input(rule.input))\\n fst_symbols.extend(_symbols_of_output(rule.output))\\n\\n unique_symbols = set(fst_symbols).difference({common.EPSILON})\\n complex_symbols = [s for s in unique_symbols if len(s) > 1]\\n\\n index = 983040 # start of the Unicode private use area.\\n\\n for symbol in sorted(complex_symbols):\\n yield _line(symbol, index)\\n index += 1\\n\\n logging.info(\\\"generated complex symbols file content\\\")\",\n \"def __repr__(self):\\n return dict_to_table(self)\",\n \"def copy(self):\\n cdef SymbolTable result = SymbolTable.__new__(SymbolTable)\\n result.table = new sym.SymbolTable(self.table[0])\\n return result\",\n \"def popSym(self):\\r\\n res=self.dbConn.execute(\\\"SELECT * FROM Symposia ORDER BY StartDate\\\").fetchall()\\r\\n self.symList = [ln[\\\"Name\\\"] for ln in res]\\r\\n self.symID_Title = {ln[\\\"SymposiumID\\\"]:ln[\\\"Name\\\"] for ln in res}\\r\\n for ln in res:\\r\\n self.symID_Title[ln[\\\"Name\\\"]] = ln[\\\"SymposiumID\\\"]\",\n \"def __init__(self):\\n\\n self.st = {} # symbol table\\n self.st[\\\"itrs\\\"] = [{}, {}, {}]\\n self.existVecs = False\\n self.existMats = False\\n self.applyOnce = {}\",\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 create_root_symbols(self):\\n RootSymbol = Symbol(Token(None,None,'R00t.Symbol'))\\n RootSymbol.GlobalSymbolDict=self.GlobalSymbolDict\\n StartDocSymbol = Symbol(Token(None,None,'%^'))\\n StartDocSymbol.regex = Set('%^')\\n StartDocSymbol.is_lit = True\\n StartDocSymbol.GlobalSymbolDict=self.GlobalSymbolDict\\n EndDocSymbol = Symbol(Token(None,None,'%$'))\\n EndDocSymbol.regex = Set('%$')\\n EndDocSymbol.is_lit = True\\n EndDocSymbol.GlobalSymbolDict=self.GlobalSymbolDict\\n RootSymbol.productions = [Production(RootSymbol,[StartDocSymbol]+self.get_roots()+[EndDocSymbol])]\\n self.GlobalSymbolDict['R00t.Symbol'] = RootSymbol #XXX this is a nasty hack\\n self.GlobalSymbolDict['%^']=StartDocSymbol\\n self.GlobalSymbolDict['%$']=EndDocSymbol\",\n \"def __init__(self):\\n # just the list of class/construct types\\n self.lut = {}\\n self.lut[\\\"struct\\\"] = structure\\n self.lut[\\\"typedef\\\"] = typedef\\n self.lut[\\\"define\\\"] = define\\n self.lut[\\\"enum\\\"] = enum\\n self.lut[\\\"enumEntry\\\"] = enumEntry\\n self.lut[\\\"ifdef\\\"] = ifdef\\n self.lut[\\\"ifndef\\\"] = ifndef\\n self.lut[\\\"hashIf\\\"] = hashIf\\n self.lut[\\\"hashElse\\\"] = hashElse\\n self.lut[\\\"hashElif\\\"] = hashElif\\n self.lut[\\\"endif\\\"] = endif\\n self.lut[\\\"banner\\\"] = banner\\n self.lut[\\\"general\\\"] = general\\n self.lut[\\\"listDefine\\\"] = listDefine\\n self.lut[\\\"listEntry\\\"] = listEntry\\n self.lut[\\\"listNumEls\\\"] = listNumEls\\n self.lut[\\\"union\\\"] = union\\n\\n # and the dictionary of all symbols we declare\\n self.symbols = {}\",\n \"def nk_table(self):\\n return self.map(\\\"keys\\\", \\\"values\\\")\",\n \"def generate_rename_tabled(self, prefix):\\n return \\\"#define %s%s g_symbol_table.%s\\\" % (prefix, self.__name, self.__name)\",\n \"def _generate_symbols(self):\\n\\n def infix(id, bp):\\n def led(self, left):\\n self.first = left\\n self.second = self.parent.expression(bp)\\n return self\\n\\n self.symbol_factory(id, bp).led = led\\n\\n def prefix(id, bp):\\n def nud(self):\\n self.first = self.parent.expression(bp)\\n return self\\n\\n self.symbol_factory(id, bp).nud = nud\\n\\n def infixr(id, bp):\\n def led(self, left):\\n self.first = left\\n self.second = self.parent.expression(bp - 1)\\n return self\\n\\n self.symbol_factory(id, bp).led = led\\n\\n def paren(id):\\n def nud(self):\\n expr = self.parent.expression()\\n self.parent._advance(\\\"RIGHT_PAREN\\\")\\n return expr\\n\\n self.symbol_factory(id).nud = nud\\n\\n paren(\\\"LEFT_PAREN\\\")\\n self.symbol_factory(\\\"RIGHT_PAREN\\\")\\n self.symbol_factory(\\\"END\\\")\\n self.symbol_factory(\\\":\\\")\\n self.symbol_factory(\\\"NEWLINE\\\")\\n self.symbol_factory(\\\"INDENT\\\")\\n self.symbol_factory(\\\"DEDENT\\\")\\n\\n # numbers denote order of operations\\n infix(\\\"+\\\", 10)\\n infix(\\\"-\\\", 10)\\n infix(\\\"*\\\", 20)\\n infix(\\\"/\\\", 20)\\n infix(\\\"==\\\", 5)\\n infix(\\\">\\\", 5)\\n infix(\\\"<\\\", 5)\\n infix(\\\"&\\\", 4)\\n infix(\\\"|\\\", 3)\\n infix(\\\",\\\", 1)\\n infix(\\\"::\\\", 1)\\n \\n infixr(\\\"=\\\", 1) # assignment is a little different from others.\\n\\n # example +4 , -2 \\n prefix(\\\"+\\\", 100)\\n prefix(\\\"-\\\", 100)\\n\\n def literal(id):\\n self.symbol_factory(id).nud = lambda self: self\\n\\n for l in [\\\"NUMBER\\\", \\\"FLOAT\\\", \\\"NAME\\\", \\\"STRING\\\", \\\"BOOL\\\"]:\\n literal(l)\\n\\n def statement(id, std):\\n self.symbol_factory(id).stmt_begin = True\\n self.symbol_factory(id).std = std\\n\\n def if_statement(self):\\n self.first = self.parent.expression()\\n self.parent._advance([\\\":\\\"])\\n self.parent._advance([\\\"NEWLINE\\\"])\\n self.second = self.parent.Block()\\n if self.parent.token.id == \\\"else\\\":\\n self.parent._advance([\\\"else\\\"])\\n self.parent._advance([\\\":\\\"])\\n self.parent._advance([\\\"NEWLINE\\\"])\\n self.third = self.parent.Block()\\n return self\\n\\n def let_statement(self):\\n self.first = self.parent.expression()\\n self.parent._advance([\\\"NEWLINE\\\"])\\n return self\\n\\n def print_statement(self):\\n self.parent._advance([\\\"LEFT_PAREN\\\"])\\n self.first = self.parent.expression()\\n self.parent._advance([\\\"RIGHT_PAREN\\\"])\\n self.parent._advance([\\\"NEWLINE\\\"])\\n return self\\n\\n def while_statement(self):\\n self.parent._advance([\\\"LEFT_PAREN\\\"])\\n self.first = self.parent.expression()\\n self.parent._advance([\\\"RIGHT_PAREN\\\"])\\n self.parent._advance([\\\":\\\"])\\n self.parent._advance([\\\"NEWLINE\\\"])\\n self.second = self.parent.Block()\\n return self\\n\\n def func_statement(self):\\n arg_list = []\\n\\n self.first = self.parent.expression()\\n self.parent._advance([\\\"LEFT_PAREN\\\"])\\n self.second = self.parent.expression()\\n self.parent._advance([\\\"RIGHT_PAREN\\\"])\\n self.parent._advance([\\\":\\\"])\\n self.parent._advance([\\\"NEWLINE\\\"])\\n self.third = self.parent.Block()\\n return self\\n\\n statement(\\\"if\\\", if_statement)\\n statement(\\\"let\\\", let_statement)\\n statement(\\\"print\\\", print_statement)\\n statement(\\\"while\\\", while_statement)\\n statement(\\\"fn\\\", func_statement)\",\n \"def create_possible_symbols_to_cells_mapping(self):\\r\\n possibles_to_cells = defaultdict(set)\\r\\n for cell in self.iterate_empty_cells():\\r\\n possibles_to_cells[frozenset(cell.get_possible_symbols())].add(cell)\\r\\n return possibles_to_cells\",\n \"def add_symbol_und(self, name):\\n label_name = \\\"symtab_\\\" + name\\n if osarch_is_32_bit():\\n self.add_data((\\\"st_name\\\", 4, \\\"strtab_%s - strtab\\\" % (name)))\\n self.add_data((\\\"st_value\\\", PlatformVar(\\\"addr\\\"), label_name, label_name))\\n self.add_data((\\\"st_size\\\", PlatformVar(\\\"addr\\\"), PlatformVar(\\\"addr\\\")))\\n self.add_data((\\\"st_info\\\", 1, 17))\\n self.add_data((\\\"st_other\\\", 1, 0))\\n self.add_data((\\\"st_shndx\\\", 2, 1))\\n elif osarch_is_64_bit():\\n self.add_data((\\\"st_name\\\", 4, \\\"strtab_%s - strtab\\\" % (name)))\\n self.add_data((\\\"st_info\\\", 1, 17))\\n self.add_data((\\\"st_other\\\", 1, 0))\\n self.add_data((\\\"st_shndx\\\", 2, 1))\\n self.add_data((\\\"st_value\\\", PlatformVar(\\\"addr\\\"), label_name, label_name))\\n self.add_data((\\\"st_size\\\", PlatformVar(\\\"addr\\\"), PlatformVar(\\\"addr\\\")))\\n else:\\n raise_unknown_address_size()\",\n \"def pretty(self):\\n #table = [\\\"\\\".join([\\\"%8s \\\" % s for s in self.alpha.getSymbols()])]\\n table = []\\n for row in PWM.getFreq(self):\\n table.append(\\\"\\\".join([\\\"%8.6f \\\" % y for y in row]))\\n return table\",\n \"def symbols_details(self):\\n pass\",\n \"def map_table(asm):\\n # Dictionary of mappings between pre-defined names\\n table = {\\n \\\"SP\\\" : 0,\\n \\\"LCL\\\" : 1,\\n \\\"ARG\\\" : 2,\\n \\\"THIS\\\" : 3,\\n \\\"THAT\\\" : 4,\\n \\\"SCREEN\\\": 16384,\\n \\\"KBD\\\" : 24576,\\n }\\n # R0-R15\\n for i in range(0, 16):\\n table[\\\"R\\\" + str(i)] = i\\n\\n # Add user-defined names i.e. variables and gotos\\n variables_list = [] # list of all @-values\\n reg = 16 # start after R15\\n count = -1 # keep track of instruction memory position\\n\\n for line in asm:\\n parsed, flag = parser(line)\\n\\n if flag == \\\"GOTO_INSTRUCTION\\\":\\n table[parsed] = count + 1 # add next position after goto\\n elif flag == \\\"A_DECIMAL\\\":\\n count += 1\\n elif flag == \\\"A_INSTRUCTION\\\":\\n if parsed not in variables_list:\\n variables_list.append(parsed) # append to list if it doesn't exist\\n count += 1\\n elif flag == \\\"C_INSTRUCTION\\\":\\n count += 1\\n\\n for i in variables_list:\\n try:\\n table[i]\\n except KeyError:\\n table[i] = reg # if key doesn't exist add it\\n reg += 1\\n\\n return table\",\n \"def __str__(self):\\n\\n # Create grid headers for the table\\n headers = [letter for letter in string.ascii_uppercase[:self.width]]\\n\\n board_state = []\\n board_state.extend([[value for value in row] for i, row in enumerate(self.board_state)])\\n\\n for idx, row in enumerate(board_state):\\n row.insert(0, idx + 1)\\n\\n return tabulate(board_state, headers, tablefmt=\\\"grid\\\")\",\n \"def _sym_constant(self, table: Mapping[int, str]) -> str:\\n try:\\n return table[self.sym]\\n except KeyError:\\n return str(self.sym)\",\n \"def make_sym(self):\\n\\n phi_list = []\\n sym_vars = sym.zeros(len(self.rigid_body_list) * 12, 1)\\n\\n for i, rigid_body in enumerate(self.rigid_body_list): # Global symbolic variable matrix (column vector)\\n for j, sim_var in enumerate(rigid_body.symbolic_variables):\\n sym_vars[i * 12 + j, 0] = rigid_body.symbolic_variables[j]\\n phi_list.extend(rigid_body.constraints)\\n\\n self.r = sym_vars\\n\\n for i in self.constraint_list:\\n phi_list.append(i.symbolic)\\n\\n phi = sym.zeros(len(phi_list), 1)\\n\\n for i, constraint in enumerate(phi_list):\\n phi[i] = constraint\\n\\n self.phi = phi\\n self.phi_t = self.phi.diff(t)\\n\\n rows = len(self.r)\\n columns = len(phi)\\n\\n phi_r = sym.zeros(rows, columns)\\n\\n for j, constraint in enumerate(phi):\\n for i, var in enumerate(sym_vars):\\n phi_r[i, j] = constraint.diff(var)\\n\\n self.phi_r = phi_r\\n\\n self.b = sym.Matrix([- (self.phi_r.diff(t)).T*self.r.diff(t) - self.phi_t.diff(t) -\\n 2*self.alpha*(self.phi_r.T*self.r.diff(t) + self.phi_t) -\\n (self.beta**2)*self.phi])\",\n \"def gen_get_const_table(cls, names, p, const_p):\\n s = \\\"// Store constant table for {p} to {const_p}\\\\n\\\".format(\\n const_p = const_p, p = p\\n ) \\n s += \\\"{c} = {t}[(((({p}) + 1) * {mul}) >> 8) & 7];\\\\n\\\".format(\\n c = const_p, p = p, t = names[cls.T_NAME],\\n mul = cls.deBruijnMult\\n )\\n return s\",\n \"def get_shapes_table(self):\\n\\n title_list = ['idx', 'Class', '__str__', 'Perimeter', 'Perimeter Formula', 'Area', 'Area Formula']\\n cell_length = []\\n table = ''\\n for title in title_list:\\n cell_length.append(len(title))\\n cell_length = self.get_length(cell_length)\\n for i in range(len(cell_length)):\\n cell_length[i] += 2\\n table += '/' + '-' * (sum(cell_length) + len(title_list)-1) + '\\\\\\\\\\\\n'\\n for i in range(len(title_list)):\\n table += '|{:^{}}'.format(title_list[i], cell_length[i])\\n table += '|\\\\n'\\n idx = 0\\n for shape in self.shapes:\\n table += '|' + '-' * (sum(cell_length) + len(title_list)-1) + '|\\\\n'\\n table += '|{:^{}}|{:^{}}|{:^{}}|{:^{}}|{:^{}}|{:^{}}|{:^{}}|\\\\n'. \\\\\\n format(idx, cell_length[0], shape.__class__.__name__, cell_length[1],\\n shape.__str__(), cell_length[2], round(shape.perimeter, 2), cell_length[3],\\n shape.get_perimeter_formula(), cell_length[4], round(shape.area, 2),\\n cell_length[5], shape.get_area_formula(), cell_length[6])\\n table += '\\\\\\\\' + '-' * (sum(cell_length) + len(title_list) - 1) + '/\\\\n'\\n return table\",\n \"def _build_micro_tree_tables(self):\\n # A mapping that associates micro tree encoding with its corresponding table.\\n self._micro_tables = {}\\n\\n # A mapping that stores the encoding of each micro tree.\\n self._codes = {}\\n\\n # For every micro tree compute a simle table to answer LA queries.\\n for p in self._micro_roots:\\n code, f, f_inv = self._encode(p) # encode the micro tree\\n self._codes[p.index()] = code, f, f_inv\\n if code not in self._micro_tables: # build a simple table if needed\\n repr_tree = self._decode(code)\\n self._micro_tables[code] = LA_table(repr_tree)\",\n \"def __repr__(self):\\n # return 'HashTable({})'.format(self.length())\\n return 'HashTable({})'.format(str(self.buckets))\",\n \"def _create_TableDescriptor(self):\\n\\n self.conn.cursor.execute(\\\"PRAGMA table_info(\\\" + self.table_name + \\\")\\\")\\n descriptions = self.conn.cursor.fetchall()\\n column_map = {}\\n for description in descriptions:\\n column_map[description[1]] = description[2]\\n td = TD(self.table_name, column_map) \\n\\n# self.conn.cursor.execute(\\\"SELECT sql FROM sqlite_master WHERE name='{tb}'\\\"\\\\\\n# .format(tb=self.table_name))\\n# aa = str(self.conn.cursor.fetchone()[0])\\n# sindx = aa.find(\\\"(\\\")\\n# eindx = aa.find(\\\")\\\")\\n# aa = aa[sindx+1:eindx]\\n# aa = aa.split(\\\",\\\")\\n# column_map = {kyval.split()[0]:kyval.split()[1] for kyval in aa}\\n# td = TD(self.table_name, column_map) \\n\\n return td\",\n \"def symbols(self):\\n pass\",\n \"def __init__(self):\\n self.class_symbol_table = dict()\\n self.subroutine_symbol_table = dict()\\n self.counter = {VAR: 0, ARG: 0, FIELD: 0, STATIC: 0}\",\n \"def symbols(self) -> Dict[str, Variable]:\\n symbols = {}\\n symbols.update(self.args)\\n symbols.update(self.locals)\\n return symbols\",\n \"def add_dt_symtab(self, op):\\n d_tag = AssemblerVariable((\\\"d_tag, DT_SYMTAB = 6\\\", PlatformVar(\\\"addr\\\"), 6))\\n d_un = AssemblerVariable((\\\"d_un\\\", PlatformVar(\\\"addr\\\"), op))\\n self.__data[0:0] = [d_tag, d_un]\\n self.refresh_name_label()\",\n \"def _generate_table(self):\\n for i in xrange(32):\\n dest = [0]\\n gw = [0]\\n self._table.append(\\n {'destination': dest, 'gateway': gw}\\n )\",\n \"def get_data():\\n state = np.array([1,1,1,1,1,1,1,1,1], dtype=np.bool)\\n taps = np.array([0,0,0,0,1,0,0,0,1], dtype=np.bool)\\n p = np.zeros(176, dtype=np.uint8)\\n for i in range(176):\\n p[i] = np.sum(state[-3:]*[4,2,1])\\n for _ in range(3):\\n state = np.concatenate(([np.sum(state&taps)&1], state[0:-1]))\\n a = np.zeros(176, common.SYMB_SCRAMBLE_DTYPE)\\n ## 8PSK modulation\\n constellation = PhysicalLayer.make_psk(8,range(8))['points']\\n a['scramble'] = constellation[p,]\\n known_symbols = np.mod(range(176),48)>=32\\n a['symb'][known_symbols] = a['scramble'][known_symbols]\\n return a\",\n \"def build_versioned_syms_gtirb() -> gtirb.IR:\\n (ir, module) = gth.create_test_module(\\n gtirb.Module.FileFormat.ELF,\\n gtirb.Module.ISA.X64,\\n )\\n (text_section, text_bi) = gth.add_text_section(module)\\n\\n proxy_a = gth.add_proxy_block(module)\\n symbol_a = gth.add_symbol(module, \\\"a\\\", proxy_a)\\n se_a = gtirb.SymAddrConst(\\n 0, symbol_a, {gtirb.SymbolicExpression.Attribute.PLT}\\n )\\n proxy_a2 = gth.add_proxy_block(module)\\n symbol_a2 = gth.add_symbol(module, \\\"a\\\", proxy_a2)\\n se_a2 = gtirb.SymAddrConst(\\n 0, symbol_a2, {gtirb.SymbolicExpression.Attribute.PLT}\\n )\\n\\n module.aux_data[\\\"elfSymbolVersions\\\"] = gtirb.AuxData(\\n type_name=(\\n \\\"tuple<mapping<uint16_t,tuple<sequence<string>,uint16_t>>,\\\"\\n \\\"mapping<string,mapping<uint16_t,string>>,\\\"\\n \\\"mapping<UUID,tuple<uint16_t,bool>>>\\\"\\n ),\\n data=(\\n # ElfSymVerDefs\\n {},\\n # ElfSymVerNeeded\\n {\\\"libmya.so\\\": {1: \\\"LIBA_1.0\\\", 2: \\\"LIBA_2.0\\\"}},\\n # ElfSymbolVersionsEntries\\n {symbol_a.uuid: (1, False), symbol_a2.uuid: (2, False)},\\n ),\\n )\\n\\n # For the following code:\\n # e8 00 00 00 00 callq a@LIBA_1.0@plt\\n # e8 00 00 00 00 callq a@LIBA_2.0@plt\\n # 48 31 c0 xor %rax,%rax\\n # 48 c7 c0 3c 00 00 00 mov $0x3c,%rax\\n # 48 31 ff xor %rdi,%rdi\\n # 0f 05 syscall\\n cb = gth.add_code_block(\\n text_bi,\\n b\\\"\\\\xe8\\\\x00\\\\x00\\\\x00\\\\x00\\\"\\n b\\\"\\\\xe8\\\\x00\\\\x00\\\\x00\\\\x00\\\"\\n b\\\"\\\\x48\\\\x31\\\\xc0\\\"\\n b\\\"\\\\x48\\\\xc7\\\\xc0\\\\x3c\\\\x00\\\\x00\\\\x00\\\"\\n b\\\"\\\\x48\\\\x31\\\\xff\\\"\\n b\\\"\\\\x0f\\\\x05\\\",\\n {1: se_a, 6: se_a2},\\n )\\n symbol_start = gth.add_symbol(module, \\\"_start\\\", cb)\\n\\n module.aux_data[\\\"libraries\\\"].data.extend([\\\"libmya.so\\\"])\\n\\n for sym in (symbol_start, symbol_a, symbol_a2):\\n module.aux_data[\\\"elfSymbolInfo\\\"].data[sym.uuid] = (\\n 0,\\n \\\"FUNC\\\",\\n \\\"GLOBAL\\\",\\n \\\"DEFAULT\\\",\\n 0,\\n )\\n\\n return ir\",\n \"def generate_str (obj):\\n d = obj.dim(obj)\\n units = [ obj( ( [zer]*i + [one] + [zer]*(d-i-1) )) for i in range(d) ]\\n table = []\\n raw_table = []\\n for j in units:\\n table.append([])\\n raw_table.append([])\\n for i in units:\\n if DEBUG: raw_table[-1].append(str(j*i))\\n table[-1].append(str(obj([c.name_in(s) for c in (j*i).state])))\\n if DEBUG: print('{} × {} = {}'.format(j,i,j*i))\\n return table\",\n \"def tabledict(self):\\n return dict(table=self.tablename,\\n dffeld=self.name_dateifuehrungsschluessel,\\n statusfeld=self.name_status,\\n schluesselfeld=self.name_schluessel)\",\n \"def _build_sparse_table(self):\\n self._table = {}\\n\\n for p in self._jump_nodes:\\n self._table[p.index()] = [self._tree.parent(p)] # table[p][0] = parent(p)\\n\\n l = 0\\n while l < self._logsize:\\n u = self._table[p.index()][l]\\n\\n if u is None:\\n break\\n\\n if self._ind[u.index()] < self._pow[l]: # incomplete ladder\\n break\\n\\n i = self._path[u.index()] # u belongs to path_i\\n j = self._ind[u.index()] # path_i[j] = u\\n w = self._ladders[i][j - self._pow[l]]\\n self._table[p.index()].append(w)\\n l += 1\",\n \"def __init__(self, owner, name, addr, size, binding, sym_type, sh_info):\\n super(Symbol, self).__init__()\\n self.owner_obj = owner\\n self.name = name\\n self.addr = addr\\n self.size = size\\n self.binding = binding\\n self.type = sym_type\\n self.sh_info = sh_info if sh_info != 'SHN_UNDEF' else None\\n self.resolved = False\\n self.resolvedby = None\\n if (claripy and isinstance(self.addr, claripy.ast.Base)) or self.addr != 0:\\n self.owner_obj.symbols_by_addr[self.addr] = self\\n # would be nice if we could populate demangled_names here...\\n\\n #demangled = self.demangled_name\\n #if demangled is not None:\\n # self.owner_obj.demangled_names[self.name] = demangled\",\n \"def pretty(self):\\n table = [\\\"\\\".join([\\\"%4s \\\" % s for s in self.alpha.getSymbols()])]\\n table.append(\\\"\\\".join([\\\"%3.2f \\\" % y for y in Distrib.getFreq(self)]))\\n return table\",\n \"def __str__(self):\\n ts_rows = [\\n [\\\"Trees\\\", str(self.num_trees)],\\n [\\n \\\"Sequence Length\\\",\\n str(\\n int(self.sequence_length)\\n if self.discrete_genome\\n else self.sequence_length\\n ),\\n ],\\n [\\\"Time Units\\\", self.time_units],\\n [\\\"Sample Nodes\\\", str(self.num_samples)],\\n [\\\"Total Size\\\", util.naturalsize(self.nbytes)],\\n ]\\n header = [\\\"Table\\\", \\\"Rows\\\", \\\"Size\\\", \\\"Has Metadata\\\"]\\n table_rows = []\\n for name, table in self.tables.table_name_map.items():\\n table_rows.append(\\n [\\n str(s)\\n for s in [\\n name.capitalize(),\\n table.num_rows,\\n util.naturalsize(table.nbytes),\\n \\\"Yes\\\"\\n if hasattr(table, \\\"metadata\\\") and len(table.metadata) > 0\\n else \\\"No\\\",\\n ]\\n ]\\n )\\n return util.unicode_table(ts_rows, title=\\\"TreeSequence\\\") + util.unicode_table(\\n table_rows, header=header\\n )\",\n \"def to_xml(self):\\n xml_strings = ['<table name=\\\"%s\\\">\\\\n' % self.name]\\n if self.tablespace_name:\\n xml_strings.append(' <tablespace name=')\\n xml_strings.append('\\\"%s\\\" />\\\\n' % self.tablespace_name)\\n # Columns\\n for column in self.columns:\\n col_details = self.columns[column]\\n xml_strings.append(' <column name=\\\"%s\\\"' % column)\\n xml_strings.append(' data-type=\\\"%s\\\"' % col_details['type'])\\n xml_strings.append(' sequence=\\\"%d\\\">\\\\n' % col_details['sequence'])\\n # The following statement means we need Python 2.5 and above\\n # pre 2.5 it would be col_details.has_key('length')\\n if 'length' in col_details:\\n xml_strings.append(' <length>')\\n xml_strings.append(str(col_details['length']))\\n xml_strings.append('</length>\\\\n')\\n if 'precision' in col_details and col_details['precision'] != 0:\\n xml_strings.append(' <precision>')\\n xml_strings.append(str(col_details['precision'])+'</precision>\\\\n')\\n if 'scale' in col_details:\\n xml_strings.append(' <scale>')\\n xml_strings.append(str(col_details['scale']))\\n xml_strings.append('</scale>\\\\n')\\n xml_strings.append(' </column>\\\\n')\\n # Constraints\\n for constraint, cons_details in list(self.constraints.items()):\\n # Exclude check constraint that start with 'SYS_C' (an Oracle hack)\\n if cons_details['type'] != 'Check' or not constraint.startswith(\\\"SYS_C\\\"):\\n xml_strings.append(' <constraint name=\\\"%s\\\"' % constraint)\\n xml_strings.append(' type=\\\"%s\\\">\\\\n' % cons_details['type'])\\n if cons_details['type'] == 'Check':\\n xml_strings.append(' <details>')\\n xml_strings.append(cons_details['condition'])\\n xml_strings.append('</details>\\\\n')\\n if cons_details['type'] == 'Primary':\\n for column in cons_details['columns']:\\n xml_strings.append(' <column name=\\\"%s\\\" />\\\\n' % column)\\n if cons_details['type'] == 'Foreign':\\n xml_strings.append(' <jointable ')\\n xml_strings.append(' name=\\\"%s\\\"' % cons_details['reftable'])\\n xml_strings.append(' pk=\\\"%s\\\">\\\\n' % cons_details['refpk'])\\n for col_index in range(len(cons_details['columns'])):\\n xml_strings.append(' <constraintcolumn')\\n name = cons_details['columns'][col_index]\\n xml_strings.append(' name=\\\"%s\\\"' % name)\\n xml_strings.append(' joincolumn')\\n join_column = cons_details['refcolumns'][col_index]\\n xml_strings.append('=\\\"%s\\\" />\\\\n' % join_column)\\n xml_strings.append(' </jointable>\\\\n')\\n xml_strings.append(' </constraint>\\\\n')\\n # Indexes\\n for index in self.indexes:\\n index_details = self.indexes[index]\\n xml_strings.append(' <index name=\\\"%s\\\"' % index)\\n xml_strings.append(' type=\\\"%s\\\">\\\\n' % index_details['type'])\\n for column in index_details['columns']:\\n xml_strings.append(' <column name=\\\"%s\\\" />\\\\n' % column)\\n xml_strings.append(' </index>\\\\n')\\n # Triggers\\n for trigger in self.triggers:\\n xml_strings.append(self.triggers[trigger].to_xml())\\n xml_strings.append('</table>')\\n return \\\"\\\".join(xml_strings)\",\n \"def list_syms():\\n\\tSymStringVec=[];\\n\\tSymStringVec.append(\\\"CSYM\\\");\\n\\tSymStringVec.append(\\\"DSYM\\\");\\n\\tSymStringVec.append(\\\"TET_SYM\\\");\\n\\tSymStringVec.append(\\\"OCT_SYM\\\");\\n\\tSymStringVec.append(\\\"ICOS_SYM\\\");\\n\\tSymStringVec.append(\\\"ISYM\\\");\\n\\treturn SymStringVec\",\n \"def symbol_factory(self, id, bp=0):\\n try:\\n s = self.sym[id] # if already in table don't do anything. Memoized\\n except KeyError as e:\\n\\n class s(BaseSymbol): \\n # create appropriate symbol class at run time\\n pass\\n\\n s.__name__ = \\\"sym(\\\" + id + \\\")\\\"\\n s.id = id\\n s.lbp = bp\\n s.parent = self\\n self.sym[id] = s\\n else:\\n s.lbp = max(bp, s.lbp)\\n return s # NOTE: This function does not returns an object. It returns the class\",\n \"def get_symbol(self):\\n return []\",\n \"def __str__(self):\\n\\n table_list = [self.headers]\\n\\n for row in self.data:\\n table_list.append([row[col] or \\\"\\\" for col in self.headers])\\n\\n return create_table_string(table_list)\",\n \"def to_frame(self):\\n # Create a set of dictionaries/lists for each column\\n data = dict([(i_var.name, []) for i_var in self.inputs])\\n data.update({self.OUTPUT_LABEL: [], self.INPUT_LABEL: [], self.name: []})\\n\\n # A very ugly loop to produce all the probabilities in a nice way.\\n # Note that this just reproduces what is already in `self.lookup`.\\n # Honestly, I just haven't thought of a better way to get nice output.\\n for i_index, i_state in enumerate(self.input_states):\\n for o_var, results in zip(self.outputs, self.per_state_results):\\n for o_state, o_p in enumerate(results[i_index]):\\n for i_var, s in zip(self.inputs, i_state):\\n data[i_var.name].append(s)\\n data[self.OUTPUT_LABEL].append(o_var.name)\\n data[self.INPUT_LABEL].append(o_state)\\n data[self.name].append(o_p)\\n all_data = pd.DataFrame(data=data)\\n\\n # The magnificent pivot table function does all the work\\n return pd.pivot_table(data=all_data, values=[self.name],\\n index=[i_var.name for i_var in self.inputs],\\n columns=[self.OUTPUT_LABEL, self.INPUT_LABEL])\",\n \"def frame(self):\\n return _generate_generic_frame(len(self.table), self.unit, self.names, self.physical_types)\",\n \"def symbol_state_map(self):\\n map = {}\\n for state in self:\\n map[state.symbol] = state\\n map.update(self.symbol_synonyms)\\n if not self.case_sensitive:\\n for state in self:\\n if state.symbol.islower():\\n map[state.symbol.upper()] = state\\n else:\\n map[state.symbol.lower()] = state\\n for symbol, state in self.symbol_synonyms.items():\\n if symbol.islower():\\n map[symbol.upper()] = state\\n else:\\n map[symbol.lower()] = state\\n return map\",\n \"def get_structure(self):\\n if len(self.headers) == 0:\\n self.restore_structure()\\n columns = self.parse_declaration()\\n result = \\\"<tablestructure>\\\\n\\\"\\n result += \\\"\\\\t<table id=\\\\\\\"%s\\\\\\\" name=\\\\\\\"%s\\\\\\\">\\\\n\\\" % (self.id, self.name)\\n result += \\\"\\\\t<header>\\\\n\\\"\\n for header in self.headers:\\n result += \\\"\\\\t\\\\t%s\\\\n\\\" % columns[header].to_xml()\\n result += \\\"\\\\t</header>\\\\n\\\"\\n result += \\\"\\\\t</table>\\\\n\\\"\\n result += \\\"</tablestructure>\\\"\\n return result\",\n \"def create_state_symbols(nVars,nParams):\\n\\n nSensitivityEqs = nVars * nParams\\n\\n #state variables\\n x_sp = np.array(sp.symbols('x0:' + str(nVars)))\\n\\n #sensitivity variables\\n sensitivity_sp = np.array(list(sp.symbols('s0:' + str(nSensitivityEqs))))\\n\\n return [x_sp,sensitivity_sp]\",\n \"def build_table(self):\\n if len(self._abslines) == 0:\\n return\\n comp_tbl = QTable()\\n comp_tbl.add_column(Column([iline.wrest.to(u.AA).value for iline in self._abslines]*u.AA,name='wrest'))\\n for attrib in ['z', 'flagN', 'N', 'Nsig']:\\n comp_tbl.add_column(Column([iline.attrib[attrib] for iline in self._abslines], name=attrib))\\n # Return\\n return comp_tbl\",\n \"def mono_table():\\n return Table(\\n {\\n \\\"obs_id\\\": [1, 1, 1, 1, 1, 2],\\n \\\"event_id\\\": [1, 1, 1, 2, 2, 1],\\n \\\"tel_id\\\": [1, 2, 3, 5, 7, 1],\\n \\\"hillas_intensity\\\": [1, 2, 0, 1, 5, 9],\\n \\\"hillas_width\\\": [0.1, 0.2, 0.1, 0.1, 0.2, 0.1] * u.deg,\\n \\\"hillas_length\\\": 3 * ([0.1, 0.2, 0.1, 0.1, 0.2, 0.1] * u.deg),\\n \\\"dummy_tel_energy\\\": [1, 10, 4, 0.5, 0.7, 1] * u.TeV,\\n \\\"dummy_tel_is_valid\\\": [\\n True,\\n True,\\n True,\\n True,\\n False,\\n False,\\n ],\\n \\\"classifier_tel_prediction\\\": [1, 0, 0.5, 0, 0.6, 1],\\n \\\"classifier_tel_is_valid\\\": [\\n True,\\n True,\\n False,\\n True,\\n True,\\n True,\\n ],\\n \\\"disp_tel_alt\\\": [58.5, 58, 62.5, 72, 74.5, 81] * u.deg,\\n \\\"disp_tel_az\\\": [12.5, 15, 13, 21, 20, 14.5] * u.deg,\\n \\\"disp_tel_is_valid\\\": [\\n True,\\n False,\\n True,\\n True,\\n True,\\n True,\\n ],\\n }\\n )\",\n \"def __repr__(self):\\n return \\\"[\\\" + \\\", \\\".join([str(member) for member in self.table]).rstrip(\\\",\\\") + \\\"]\\\"\",\n \"def build_extension_symtab(ext_type):\\n table = ext_type.attribute_table\\n for attr_name, attr_type in table.attributedict.iteritems():\\n ext_type.symtab[attr_name] = symtab.Variable(attr_type,\\n promotable_type=False)\",\n \"def get_symbols(self):\\n\\n raise NotImplementedError('''\\n Must implement get_symbols. Call help() for details.\\n ''')\",\n \"def __init__(self):\\n self.table = {}\",\n \"def __init__(self, symbols, short_window, long_window, command_execute):\\n\\n\\t\\t# Create a new Macs object for every stock\\n\\t\\tself.data = {s: Macs(short_window, long_window) for s in symbols}\\n\\t\\tself.command_execute = command_execute\",\n \"def get_table(self):\\n return copy.deepcopy(self._table)\",\n \"def build_import_table(self):\\n self.section_alignment = 4096\\n pe = pefile.PE(data=self.mem_dump.dump)\\n IAT_addr = pe.OPTIONAL_HEADER.DATA_DIRECTORY[1].VirtualAddress\\n print 'IAT_addr: ' + hex(IAT_addr)\\n raw_size = self.import_table.raw_memory_size()\\n jump_table_size = self.import_table.get_jump_table_size()\\n\\n print \\\"raw_size: \\\", `raw_size`\\n print \\\"jump table size: \\\", `jump_table_size`\\n\\n size = ((raw_size+jump_table_size) / self.section_alignment + 1) * self.section_alignment\\n print size\\n byte_array = bytearray(size)\\n IID_pos = 0\\n content_pos = (len(self.import_table.dlls) + 1) * 20\\n\\n jump_table_pos = IID_pos + raw_size\\n\\n print \\\"jump table position: \\\", hex(jump_table_pos)\\n\\n for dll in self.import_table.dlls:\\n print dll\\n thunk_position = content_pos + len(dll) + 1\\n byte_array[IID_pos + 12:IID_pos + 16] = pack('<L', content_pos + IAT_addr)\\n byte_array[IID_pos + 16:IID_pos + 20] = pack('<L', thunk_position + IAT_addr)\\n\\n print 'Dll position: ', content_pos\\n byte_array[content_pos:content_pos + len(dll)] = dll\\n names_pos = thunk_position + (len(self.import_table.dlls[dll]) + 1) * 4\\n\\n for function_name in self.import_table.dlls[dll]:\\n self.import_table.set_thunk_addr(dll, function_name, thunk_position + IAT_addr)\\n byte_array[thunk_position:thunk_position + 4] = pack('<L', names_pos + IAT_addr)\\n func_name = '\\\\x00\\\\x00' + function_name\\n func_name_len = len(function_name) + 2\\n byte_array[names_pos:names_pos + func_name_len] = func_name\\n\\n\\n # Write the jump table entry \\n byte_array[jump_table_pos] = 0xFF\\n byte_array[jump_table_pos+1] = 0x25\\n byte_array[jump_table_pos+2:jump_table_pos+6] = pack(\\\"<L\\\", thunk_position + IAT_addr + self.mem_dump.base_address)\\n\\n self.import_table.set_jump_addr(dll, function_name, jump_table_pos + IAT_addr)\\n\\n # Accumulate the new counters\\n thunk_position += 4\\n names_pos += func_name_len\\n jump_table_pos += 6\\n\\n IID_pos += 20\\n content_pos = names_pos + 1\\n\\n self.mem_dump.append_memory_before_end(byte_array, IAT_addr)\",\n \"def table_fields() -> Dict[str, TableFieldDetails]:\\n return {\\n \\\"REPEATS\\\": TableFieldDetails(\\n subtype=\\\"uint\\\",\\n bit_low=0,\\n bit_high=15,\\n description=\\\"Number of times the line will repeat\\\",\\n labels=None,\\n ),\\n \\\"TRIGGER\\\": TableFieldDetails(\\n subtype=\\\"enum\\\",\\n bit_low=16,\\n bit_high=19,\\n description=\\\"The trigger condition to start the phases\\\",\\n labels=[\\n \\\"Immediate\\\",\\n \\\"BITA=0\\\",\\n \\\"BITA=1\\\",\\n \\\"BITB=0\\\",\\n \\\"BITB=1\\\",\\n \\\"BITC=0\\\",\\n \\\"BITC=1\\\",\\n \\\"POSA>=POSITION\\\",\\n \\\"POSA<=POSITION\\\",\\n \\\"POSB>=POSITION\\\",\\n \\\"POSB<=POSITION\\\",\\n \\\"POSC>=POSITION\\\",\\n \\\"POSC<=POSITION\\\",\\n ],\\n ),\\n \\\"POSITION\\\": TableFieldDetails(\\n subtype=\\\"int\\\",\\n bit_low=32,\\n bit_high=63,\\n description=\\\"The position that can be used in trigger condition\\\",\\n labels=None,\\n ),\\n \\\"TIME1\\\": TableFieldDetails(\\n subtype=\\\"uint\\\",\\n bit_low=64,\\n bit_high=95,\\n description=\\\"The time the optional phase 1 should take\\\",\\n labels=None,\\n ),\\n \\\"OUTA1\\\": TableFieldDetails(\\n subtype=\\\"uint\\\",\\n bit_low=20,\\n bit_high=20,\\n description=\\\"Output A value during phase 1\\\",\\n labels=None,\\n ),\\n \\\"OUTB1\\\": TableFieldDetails(\\n subtype=\\\"uint\\\",\\n bit_low=21,\\n bit_high=21,\\n description=\\\"Output B value during phase 1\\\",\\n labels=None,\\n ),\\n \\\"OUTC1\\\": TableFieldDetails(\\n subtype=\\\"uint\\\",\\n bit_low=22,\\n bit_high=22,\\n description=\\\"Output C value during phase 1\\\",\\n labels=None,\\n ),\\n \\\"OUTD1\\\": TableFieldDetails(\\n subtype=\\\"uint\\\",\\n bit_low=23,\\n bit_high=23,\\n description=\\\"Output D value during phase 1\\\",\\n labels=None,\\n ),\\n \\\"OUTE1\\\": TableFieldDetails(\\n subtype=\\\"uint\\\",\\n bit_low=24,\\n bit_high=24,\\n description=\\\"Output E value during phase 1\\\",\\n labels=None,\\n ),\\n \\\"OUTF1\\\": TableFieldDetails(\\n subtype=\\\"uint\\\",\\n bit_low=25,\\n bit_high=25,\\n description=\\\"Output F value during phase 1\\\",\\n labels=None,\\n ),\\n \\\"TIME2\\\": TableFieldDetails(\\n subtype=\\\"uint\\\",\\n bit_low=96,\\n bit_high=127,\\n description=\\\"The time the mandatory phase 2 should take\\\",\\n labels=None,\\n ),\\n \\\"OUTA2\\\": TableFieldDetails(\\n subtype=\\\"uint\\\",\\n bit_low=26,\\n bit_high=26,\\n description=\\\"Output A value during phase 2\\\",\\n labels=None,\\n ),\\n \\\"OUTB2\\\": TableFieldDetails(\\n subtype=\\\"uint\\\",\\n bit_low=27,\\n bit_high=27,\\n description=\\\"Output B value during phase 2\\\",\\n labels=None,\\n ),\\n \\\"OUTC2\\\": TableFieldDetails(\\n subtype=\\\"uint\\\",\\n bit_low=28,\\n bit_high=28,\\n description=\\\"Output C value during phase 2\\\",\\n labels=None,\\n ),\\n \\\"OUTD2\\\": TableFieldDetails(\\n subtype=\\\"uint\\\",\\n bit_low=29,\\n bit_high=29,\\n description=\\\"Output D value during phase 2\\\",\\n labels=None,\\n ),\\n \\\"OUTE2\\\": TableFieldDetails(\\n subtype=\\\"uint\\\",\\n bit_low=30,\\n bit_high=30,\\n description=\\\"Output E value during phase 2\\\",\\n labels=None,\\n ),\\n \\\"OUTF2\\\": TableFieldDetails(\\n subtype=\\\"uint\\\",\\n bit_low=31,\\n bit_high=31,\\n description=\\\"Output F value during phase 2\\\",\\n labels=None,\\n ),\\n }\",\n \"def __init__(self, lzw_min_code_sz, col_table_sz):\\n self.code_table = dict()\\n clear_code = 1<<lzw_min_code_sz\\n eoi_code = clear_code + 1\\n self.code_table[clear_code] = [CLEARCODEVAL]\\n self.code_table[eoi_code] = [EOICODEVAL]\\n for color in range(col_table_sz):\\n self.code_table[color] = [color]\",\n \"def makeTableNamesList(n, ):\",\n \"def _prepare_links_table(self):\\n\\n links_tbl = OrderedDict()\\n for colname in itertools.islice(self._pinfos, 1, None):\\n links_tbl[colname] = {}\\n links_tbl[colname][\\\"name\\\"] = f\\\"{colname}\\\"\\n fname = colname.replace(\\\"%\\\", \\\"_pcnt\\\") + \\\".html\\\"\\n links_tbl[colname][\\\"fname\\\"] = fname\\n links_tbl[colname][\\\"hlink\\\"] = f\\\"<a href=\\\\\\\"{fname}\\\\\\\">{colname}</a>\\\"\\n\\n return links_tbl\",\n \"def _index_symbols(predicates, functions):\\n symbols, symbol_types = OrderedDict(), {}\\n\\n for s in predicates:\\n argtypes = [t.type for t in s.arguments]\\n symbols[s.name] = base.Predicate(s.name, argtypes)\\n symbol_types[s.name] = 'bool'\\n\\n for s in functions:\\n if s.name != 'total-cost': # Ignore the \\\"fake\\\" total-cost function\\n argtypes = [t.type for t in s.arguments]\\n symbols[s.name] = base.Function(s.name, argtypes, s.type)\\n symbol_types[s.name] = s.type\\n\\n return symbols, symbol_types\",\n \"def __getFontTable(self):\\n\\n fontTable = \\\"{\\\\\\\\fonttbl\\\\n\\\"\\n for font in self.fonts:\\n fontTable += \\\"%s\\\\n\\\" % font.getRtf()\\n return fontTable + \\\"}\\\\n\\\"\",\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 items(self):\\n cdef sym.SymbolTableIterator* it = new sym.SymbolTableIterator(self.table[0])\\n try:\\n while not it.Done():\\n yield (it.Symbol().decode('utf8'), it.Value())\\n it.Next()\\n finally:\\n del it\",\n \"def get_package_hash_table():\\n return packageHashTable\",\n \"def set_symbols(self, symboltable: dict):\\n\\n for index in range(1, self.symbol_layout.rowCount()):\\n self.symbol_layout.removeRow(index)\\n\\n font = QFont('Fira Code', 8, QFont.Medium)\\n for entry in symboltable:\\n symbol = QLineEdit()\\n symbol.setReadOnly(True)\\n symbol.setText(entry)\\n symbol.setFont(font)\\n address = QLineEdit()\\n address.setReadOnly(True)\\n address.setFont(font)\\n address.setText(str(symboltable[entry]))\\n self.symbol_layout.addRow(address, symbol)\",\n \"def make_symbolic(symfile_path=\\\"fung_Dsym\\\",resym=False):\\n # Construct the quadratic form as a flat list of independent entries\\n q = np.array([sp.symbols('q_{}{}'.format(i,j)) for \\n (i,j) in lin.utri_indices(6)])\\n\\n # We also need its matrix form\\n Q = np.empty((6,6),dtype=object)\\n for (k,(i,j)) in zip(range(len(q)),lin.utri_indices(6)):\\n Q[i,j] = q[k]\\n Q[j,i] = Q[i,j]\\n\\n # Construct the Lagrangian strain (E) as a *vector* (e)\\n f = np.array([sp.symbols('f_{i}'.format(i=i)) for i in range(9)])\\n F = np.reshape(f,(3,3))\\n J = sp.Matrix(F.tolist()).det()\\n # TODO: Is this supposed to be J**(-4/3) or J**(-2/3)?\\n E = 0.5*(J**sp.Rational(-2,3)*np.dot(F.T,F) - np.eye(3))\\n e = lin.utri_flat(E)\\n\\n # Expand the quadratic form's action on e\\n Qee = np.dot(e,np.dot(Q,e))\\n\\n # Attempt to load this from a pickle file\\n try:\\n Dsym = pickle.load(open(symfile_path+\\\".pkl\\\",'rb'))\\n\\n # Otherwise, just recompute it\\n except Exception:\\n # Construct the tangent stiffness as a symbolic expression\\n\\n # Calculate first derivatives\\n dQ = np.empty(9,dtype=object)\\n for i in range(9):\\n print(\\\"Symbolic dQ_{}\\\".format(i))\\n dQ[i] = sp.diff(Qee,f[i])\\n\\n # Calculate second derivatives\\n Dsym = np.empty((9,9),dtype=object)\\n for (i,j) in lin.utri_indices(9):\\n print(\\\"Symbolic ddQ_{0}{1}\\\".format(i,j))\\n dQi = dQ[i]\\n dQj = dQ[j]\\n dQij = sp.diff(dQi,f[j])\\n Dsym[i,j] = dQi*dQj + dQij\\n\\n # Optimize the derivative by substituting for J\\n print(\\\" Simplifying...\\\")\\n print(\\\" J \\\",end=\\\"\\\")\\n sys.stdout.flush()\\n Dsym[i,j] = Dsym[i,j].subs(J,sp.symbols('J'))\\n # Further optimize by replacing products of f compoenents\\n if resym == True:\\n for (k,l) in lin.utri_indices(9):\\n print(\\\"f{}f{}\\\".format(k,l),end=\\\" \\\")\\n sys.stdout.flush()\\n pair_symbol = sp.symbols('ff_{0}{1}'.format(k,l))\\n Dsym[i,j] = Dsym[i,j].subs(f[k]*f[l],pair_symbol)\\n # Since D will be symmetric, assign the symmetric components\\n print(\\\"\\\\n Symmetrizing...\\\")\\n Dsym[j,i] = Dsym[i,j]\\n # This computation is pretty costly, so let's save it\\n # frequently\\n if resym == True:\\n pickle.dump(Dsym, open(symfile_path+\\\"_{}{}.pkl\\\".format(i,j),'wb'))\\n pickle.dump(Dsym, open(symfile_path+\\\".pkl\\\",'wb'))\\n\\n return Dsym\",\n \"def make_typedefs(self):\\n type_dict = self.python_madz_types_dict + self.mangled_namespace\\n res = \\\"{} = {{}}\\\\n\\\".format(type_dict)\\n\\n for node in self.description.declarations():\\n varname = self.python_madz_types + self.mangled_namespace + \\\"___\\\" + node.name\\n # Hack to get self referential top level structs.\\n if (node.type.node_type() == pdl.TypeStruct):\\n self._is_top_level = varname\\n res += self.gen_type_string(node.type)\\n res += \\\"\\\\n\\\"\\n else:\\n res += \\\"{} = {}\\\\n\\\".format(varname, self.gen_type_string(node.type))\\n res += \\\"{}['{}'] = {}\\\\n\\\".format(type_dict, node.name, varname)\\n return res\",\n \"def startSubroutine(self):\\n self.subroutineTable = {}\\n self.counts[\\\"ARG\\\"] = 0\\n self.counts[\\\"VAR\\\"] = 0\\n\\n if self.DEBUG:\\n print(\\\"DEBUG(SymbolTable): Reset subroutine symbol table\\\")\",\n \"def build_table():\\n with contextlib.ExitStack() as stack:\\n files = [stack.enter_context(gzip.open(f, 'rt')) for f in sys.argv[1:]]\\n iters = [(line.split() for line in f) for f in files]\\n for it in iters:\\n next(it)\\n key = operator.itemgetter(0)\\n table = []\\n for k, g in itertools.groupby(merge(*iters, key=key), key=key):\\n props = list(g)\\n if len(props) == len(iters):\\n table.append([k] + [x[1] for x in props])\\n for snp in table:\\n print(*snp)\",\n \"def buildTypedefInfoDeclaration(self):\\n if len(self.name) == 0:\\n dec = \\\"<p>Aliases an anonymous enumeration.</p>\\\\n\\\"\\n else:\\n dec = \\\"<p>Aliases a enumeration, called: '\\\"+self.name+\\\"'.</p>\\\\n\\\"\\n dec += \\\"<p>\\\"+self.info+\\\"</p>\\\\n\\\"\\n dec += \\\"<table border=1 cellpadding=5>\\\\n\\\"\\n for entry in self.entries:\\n dec += entry.buildFullInfoDeclaration()\\n dec += \\\"</table>\\\\n\\\"\\n return dec\",\n \"def to_table(self):\\n table = Table()\\n table['THETA_LO'] = Quantity([self.counts.offset[:-1]], unit=self.counts.offset.unit)\\n table['THETA_HI'] = Quantity([self.counts.offset[1:]], unit=self.counts.offset.unit)\\n table['ENERG_LO'] = Quantity([self.counts.energy[:-1]], unit=self.counts.energy.unit)\\n table['ENERG_HI'] = Quantity([self.counts.energy[1:]], unit=self.counts.energy.unit)\\n table['counts'] = self.counts.to_table()['data']\\n if self.counts.data_err is not None:\\n table['counts_err'] = self.counts.to_table()['data_err']\\n table['livetime'] = self.livetime.to_table()['data']\\n table['bkg'] = self.bg_rate.to_table()['data']\\n if self.bg_rate.data_err is not None:\\n table['bkg_err'] = self.bg_rate.to_table()['data_err']\\n table.meta['HDUNAME'] = \\\"bkg_2d\\\"\\n return table\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7142161","0.7140003","0.7079655","0.67236257","0.66320723","0.65642846","0.65429175","0.65292776","0.64784485","0.6340965","0.6260409","0.62448263","0.62234396","0.61231375","0.60608643","0.6057268","0.5934887","0.58612394","0.5844101","0.5835696","0.5796547","0.5714663","0.56826395","0.5674987","0.5674987","0.567161","0.56626666","0.56626666","0.56476223","0.56268704","0.5616199","0.5614314","0.5600277","0.56001025","0.5583644","0.55763733","0.5557441","0.55389196","0.5524977","0.54998577","0.5497977","0.54906476","0.54727525","0.54671633","0.5465069","0.54534626","0.544661","0.541631","0.5400056","0.5396597","0.5391793","0.5385719","0.53714675","0.53582144","0.53539276","0.53526795","0.5344553","0.5342555","0.53335714","0.5329699","0.53236747","0.5321458","0.5315859","0.53125536","0.53110653","0.530619","0.5291185","0.5273354","0.5267491","0.5243075","0.52422607","0.5241045","0.52321166","0.5228604","0.5226108","0.5204504","0.5203327","0.52005744","0.5195425","0.51917523","0.51693743","0.5166621","0.51550496","0.5139414","0.5134011","0.5132686","0.5130515","0.5128289","0.5128005","0.51182044","0.5117286","0.51054984","0.5104979","0.51026136","0.5092798","0.5076773","0.5073747","0.506809","0.5061865","0.5057334"],"string":"[\n \"0.7142161\",\n \"0.7140003\",\n \"0.7079655\",\n \"0.67236257\",\n \"0.66320723\",\n \"0.65642846\",\n \"0.65429175\",\n \"0.65292776\",\n \"0.64784485\",\n \"0.6340965\",\n \"0.6260409\",\n \"0.62448263\",\n \"0.62234396\",\n \"0.61231375\",\n \"0.60608643\",\n \"0.6057268\",\n \"0.5934887\",\n \"0.58612394\",\n \"0.5844101\",\n \"0.5835696\",\n \"0.5796547\",\n \"0.5714663\",\n \"0.56826395\",\n \"0.5674987\",\n \"0.5674987\",\n \"0.567161\",\n \"0.56626666\",\n \"0.56626666\",\n \"0.56476223\",\n \"0.56268704\",\n \"0.5616199\",\n \"0.5614314\",\n \"0.5600277\",\n \"0.56001025\",\n \"0.5583644\",\n \"0.55763733\",\n \"0.5557441\",\n \"0.55389196\",\n \"0.5524977\",\n \"0.54998577\",\n \"0.5497977\",\n \"0.54906476\",\n \"0.54727525\",\n \"0.54671633\",\n \"0.5465069\",\n \"0.54534626\",\n \"0.544661\",\n \"0.541631\",\n \"0.5400056\",\n \"0.5396597\",\n \"0.5391793\",\n \"0.5385719\",\n \"0.53714675\",\n \"0.53582144\",\n \"0.53539276\",\n \"0.53526795\",\n \"0.5344553\",\n \"0.5342555\",\n \"0.53335714\",\n \"0.5329699\",\n \"0.53236747\",\n \"0.5321458\",\n \"0.5315859\",\n \"0.53125536\",\n \"0.53110653\",\n \"0.530619\",\n \"0.5291185\",\n \"0.5273354\",\n \"0.5267491\",\n \"0.5243075\",\n \"0.52422607\",\n \"0.5241045\",\n \"0.52321166\",\n \"0.5228604\",\n \"0.5226108\",\n \"0.5204504\",\n \"0.5203327\",\n \"0.52005744\",\n \"0.5195425\",\n \"0.51917523\",\n \"0.51693743\",\n \"0.5166621\",\n \"0.51550496\",\n \"0.5139414\",\n \"0.5134011\",\n \"0.5132686\",\n \"0.5130515\",\n \"0.5128289\",\n \"0.5128005\",\n \"0.51182044\",\n \"0.5117286\",\n \"0.51054984\",\n \"0.5104979\",\n \"0.51026136\",\n \"0.5092798\",\n \"0.5076773\",\n \"0.5073747\",\n \"0.506809\",\n \"0.5061865\",\n \"0.5057334\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7709988"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":15197,"cells":{"query":{"kind":"string","value":"Return text describing important edge flags or empty string"},"document":{"kind":"string","value":"def flags(self, f):\n if f.is_inlined:\n return \" (inlined)\"\n return \"\""},"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 human_readable(self):\n if self.no_flags_set():\n return \"no flags set\"\n else:\n flag_desc = []\n for name in (\"bookmarked\", \"for_validation\", \"candidate\", \"final causative\"):\n if getattr(self, \"flag_%s\" % name.replace(\" \", \"_\")):\n flag_desc.append(name)\n for name in (\"visual\", \"validation\", \"molecular\", \"phenotype_match\", \"summary\"):\n field = getattr(self, \"flag_%s\" % name)\n if field and field != \"empty\":\n flag_desc.append(\"%s rating is %s\" % (name.split(\"_\")[0], field))\n return \", \".join(flag_desc)","def on_edge(bits: int) -> str:\n edges = []\n if bits & N_EDGE:\n edges.append(\"n\")\n if bits & E_EDGE:\n edges.append(\"e\")\n if bits & S_EDGE:\n edges.append(\"s\")\n if bits & W_EDGE:\n edges.append(\"w\")\n return \"\".join(edges)","def show_ground_feature():\n ground_description_int = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS]\n mvaddstr(16, 3, GROUND_DESCRIPTIONS.get(ground_description_int), color_pair(GROUND_FEATURES_COLOUR) | A_BOLD)","def __repr__(self):\n\n flags = [str(flg) for flg in self.eset if str(flg) in self.flags]\n return ('<%s [%s] (0x%x)>' % (\n self.__class__.__name__, ', '.join(flags), self.bitflags))","def __str__(self):\n try:\n return \"Edge from \" + str(self.startVertex) + \" to \" + str(self.endVertex) + \" Weight \" + str(self.edgeWeight) + \" Dijkstra Criterion \" + str(self.dijkstraCriterion)\n except:\n return \"Edge from \" + str(self.startVertex) + \" to \" + str(self.endVertex) + \" Weight \" + str(self.edgeWeight)","def to_text(flags):\n\n return _to_text(flags, _by_value, _flags_order)","def _getTextForAvailability(self, obj):\n\n state = obj.getState()\n if not state.contains(pyatspi.STATE_SENSITIVE):\n # Translators: this represents an item on the screen that has\n # been set insensitive (or grayed out).\n #\n return _(\"grayed\")\n else:\n return None","def __str__(self):\n string_flag = ''\n for line in self.flag:\n string_flag += ''.join(line) + '\\n'\n return string_flag","def special_badge_text(self):\r\n return None","def NoDeltaGExplanation(self):\n for compound in self.reactants:\n if compound.compound.no_dg_explanation:\n name = compound.compound.common_names.all()[0].name\n return '%s %s' % (name,\n compound.compound.no_dg_explanation.lower())\n return None","def flagged_reason(self) -> Sequence[str]:\r\n return self._flagged_reason","def edns_to_text(flags):\n\n return _to_text(flags, _edns_by_value, _edns_flags_order)","def description(self) -> str:\n return f\"Maximize number of {colour_name(self.colour)} unit cells \" \\\n f\"that form a blob by touching sides. \" \\\n f\"Touching corners doesn't count\"","def _features_of(entry: _LexiconEntry) -> str:\n return entry[\"features\"]","def __str__(self):\n # string representation includes values of all inner fields\n return \\\n \"Edge Weight: \" + str(self.weight) + \"\\n\" + \\\n \"Edge Attributes: \" + str(self.attributes) + \"\\n\" + \\\n \"First Incident Node: \\n\" + str(self.first_incident_node.get_name()) + \"\\n\" + \\\n \"Second Incident Node: \\n\" + str(self.second_incident_node.get_name()) + \"\\n\"","def edge_cases():\n pris_edge_cases = {'OHI-': 'Ōi',\n 'ASCO-': 'Ascó',\n 'ROVNO-': 'Rivne',\n 'SHIN-KORI-': 'Kori',\n 'ANO-': 'Arkansas One',\n 'HANBIT-': 'Yeonggwang',\n 'FERMI-': 'Enrico Fermi',\n 'BALTIC-': 'Kaliningrad',\n 'COOK-': 'Donald C. Cook',\n 'HATCH-': 'Edwin I. Hatch',\n 'HARRIS-': 'Shearon Harris',\n 'SHIN-WOLSONG-': 'Wolseong',\n 'ST. ALBAN-': 'Saint-Alban',\n 'LASALLE-': 'LaSalle County',\n 'SUMMER-': 'Virgil C. Summer',\n 'FARLEY-': 'Joseph M. Farley',\n 'ST. LAURENT ': 'Saint-Laurent',\n 'HADDAM NECK': 'Connecticut Yankee',\n 'HIGASHI DORI-1 (TOHOKU)': 'Higashidōri',\n }\n return pris_edge_cases","def getText(self):\n return self.graph.get(\"__txt\", '')","def description(self):\n active = np.nonzero([bool(p) for p in self])[0]\n last_active = active[-1] if len(active) else -1\n return ' '.join([p.value_str for p in self][:last_active + 1])","def text(self):\n if self.is_root:\n return ''\n elif self.is_comment:\n return self.__value\n elif self.is_flag:\n if self.__value:\n return '[{0}]'.format(self.name)\n else:\n return '!{0}!'.format(self.name)\n else:\n return '[{0}:{1}]'.format(self.name, self.value)","def get_hover_text(self) -> str:\n if self.graph_element is None:\n return ''\n text = ''\n for name, value in self.graph_element.attr.items():\n if name in ('x', 'y') or name.startswith('.'):\n continue\n text += f'{name}: {value}\\n'\n return text[:-1]","def display_node_attributes(node):\n\n text = G[node][\"name\"] if hasattr(G[node], \"name\") else \"Node: \" + str(node)\n\n if nx.is_directed(G):\n text += \", In Degree: \" + str(G.in_degree[node])\n text += \", Out Degree: \" + str(G.out_degree[node])\n else:\n text += \"Degree: \" + str(G.degree[node])\n\n eccentricity = max(nx.single_source_shortest_path_length(G, node))\n text += \", Ecentricity: \" + str(eccentricity)\n\n if nx.is_directed(G):\n text += \", Reciprocity: {:.2f}\".format(reciprocities[node])\n\n return text","def __repr__(self) -> str:\n if self._has_direction:\n return (\n f\"<Edge: from {self._start} to {self._end} \"\n f\"with label '{self._label}'>\"\n )\n return (\n f\"<Edge: between {self._start} and {self._end} \"\n f\"with label '{self._label}'>\"\n )","def get_informative_message(self, msg_content):\n return \"{0}{1}{2}\".format(\"\\x1b[6;30;44m\", msg_content, \"\\x1b[0m\")","def flag(self) -> str:\n return pulumi.get(self, \"flag\")","def special_tags_to_text(self):\n if (self.windtag is None and self.tornadotag is None and\n self.hailtag is None and self.tornadodamagetag is None and\n self.waterspouttag is None and not self.flood_tags):\n return \"\"\n\n parts = []\n if self.tornadotag is not None:\n parts.append(\"tornado: %s\" % (\n self.tornadotag))\n if self.waterspouttag is not None:\n parts.append(\"waterspout: %s\" % (\n self.waterspouttag))\n if self.tornadodamagetag is not None:\n parts.append(\"tornado damage threat: %s\" % (\n self.tornadodamagetag))\n if self.windtag is not None:\n parts.append(\"wind: %s%s %s\" % (\n self.winddirtag.replace(\">\", \">\").replace(\"<\", \"<\"),\n self.windtag, self.windtagunits))\n if self.hailtag is not None:\n parts.append(\"hail: %s%s IN\" % (\n self.haildirtag.replace(\">\", \">\").replace(\"<\", \"<\"),\n self.hailtag))\n for k, v in self.flood_tags.items():\n parts.append(\"%s: %s\" % (k.lower(), v.lower()))\n return \" [\" + \", \".join(parts) + \"] \"","def make_edge_text(self):\n fmtstr = ub.codeblock(\n '''\n connect from {oport_abs_name}\n to {iport_abs_name}\n ''')\n parts = []\n for iport in self.iports.values():\n for oport in iport.connections:\n if oport is not None:\n part = fmtstr.format(\n oport_abs_name=oport.absname(),\n iport_abs_name=iport.absname(),\n )\n parts.append(part)\n text = '\\n'.join(parts)\n return text","def flagged(self) -> Sequence[str]:\r\n return self._flagged","def getFeatures(self):\n return \"1:\" + str(self.getEnergy()) + \\\n \" 2:\" + str(self.getCentroid()) + \\\n \" 3:\" + str(self.getZCrossingRate()) + \\\n \" 4:\" + str(self.getBandwidth())","def get_status(bool):\n if bool:\n return \"✓\"\n else:\n return \"...\"","def flag_titular(self):\n return self._flag_titular","def flags(self):\n return self.ast_node.flags","def get_text(downgrade_titles=False):","def writeEDGE(self):\n\t\tpass","def __str__(self):\n\n return '{0} {1} {2}'.format(self.feat, '==' if self.pos else '!=',\n self.val)","def __repr__(self):\n s = ''\n nums = (self.mines + 1) * self.clicked\n for row in range(0, self.rows):\n for col in range(0, self.cols):\n num = nums[row, col]\n if self.isFlagged(row, col):\n s += str(Board.FLAGGED) + ' '\n elif num == 0:\n s += str(Board.HIDDEN) + ' '\n else:\n if self.isMine(row, col):\n s += str(Board.MINE) + ' '\n else:\n s += str(int(num - 1)) + ' '\n s += '\\n'\n return s","def negations(self) -> str:","def get_edge(update: Update, context: CallbackContext):\n\n try:\n try: \n element = str(context.args[0])\n edge = str(context.args[1])\n message = look_edges_db(element,edge)\n except:\n element = str(context.args[0])\n message = look_edges_db(element) \n except:\n message = '''choose valid element, e.g. Co and edge: \\n\n Fe\n Ni L \n Co L3\n '''\n \n context.bot.send_message(chat_id=update.message.chat_id, text=message, parse_mode='HTML')","def _strSoft(self):\n return \"(Soft) Beta:%f Threshold:%f Enabled: %s\" % (self.beta, self.threshold, str(self.enabled))","def get_warning_text(self):\n \n to_print = []\n if self['skipped_subchannel'] > 0:\n to_print.append(\"Some event with large weight have been discarded.\"+\\\n \" This happens %s times.\" % self['skipped_subchannel'])\n if self['n_madloop_calls'] > 0:\n fraction = self['exceptional_points']/float(self['n_madloop_calls'])\n if fraction > 1.0e-4:\n to_print.append(\"Some PS with numerical instability have been set \"+\\\n \"to a zero matrix-element (%.3g%%)\" % (100.0*fraction))\n \n return ('\\n'.join(to_print)).replace(\"'\",\" \")","def edge_attribute(self):\n return self._edge_attribute","def edge_status(g, source, target):\n edge = source, target, g.graph['edge_key']\n if edge in g.graph['negatives']:\n status = 0\n elif edge in g.graph['positives']:\n status = 1\n else:\n status = int(g.has_edge(*edge)) + 2\n return status","def get_human_readable(self):\n\n def yesno(key):\n if getattr(self, key) and getattr(self, key) > 0:\n return \"Y\"\n else:\n return \"N\"\n\n keys = (\n \"pvs1\",\n \"ps1\",\n \"ps2\",\n \"ps3\",\n \"ps4\",\n \"pm1\",\n \"pm2\",\n \"pm3\",\n \"pm4\",\n \"pm5\",\n \"pm6\",\n \"pp1\",\n \"pp2\",\n \"pp3\",\n \"pp4\",\n \"pp5\",\n \"ba1\",\n \"bs1\",\n \"bs2\",\n \"bs3\",\n \"bs4\",\n \"bp1\",\n \"bp2\",\n \"bp3\",\n \"bp4\",\n \"bp5\",\n \"bp6\",\n \"bp7\",\n )\n result = \", \".join([\"%s: %s\" % (key.upper(), yesno(key)) for key in keys])\n result += \", ACMG classification: %s\" % self.class_auto\n if self.class_override:\n result += \", ACMG class. override: %s\" % self.class_override\n return result","def str_targetting(self):\n if not self.targetting: # set to none etc.\n return \"doing nothing\"\n if self.targetting[0] == \"marching\":\n return \"marching -> \" + self.targetting[1].color_name()\n if self.targetting[0] == \"defending\":\n return \"staying put\"\n assert self.targetting[0] == \"sneaking\"\n return \"sneaking -> \" + self.targetting[1].color_name()","def create_bar_pin_flag_text(self, unused_pin_flag=None):\n nids = []\n text = []\n #result_name = self.icase\n result_name = str('ElementID')\n for nid, data in sorted(self.nid_release_map.items()):\n sub_release_map = defaultdict(str)\n for (eid, pin_flagi) in data:\n sub_release_map[pin_flagi] += (str(eid) + ', ')\n texti = '\\n'.join(['%s-%s' % (pin_flagi, msg.rstrip(', '))\n for (pin_flagi, msg) in sorted(sub_release_map.items())])\n\n # super messy\n #texti = ', '.join(['%s-%s' % (pin_flagi, eid) for (eid, pin_flagi) in data])\n nids.append(nid)\n text.append(texti)\n self.gui.mark_nodes(nids, result_name, text)","def nft_flag(self) -> str:\n t_type = self.token_type\n if t_type == 65:\n return \"NFT_CHILD\"\n elif t_type == 129:\n return \"NFT_PARENT\"\n else:\n return None","def get_str ( self ):\n value = self.value\n def gen_words():\n if value == self.OV_NONE:\n yield \"none\"\n else:\n if value & self.OV_SYM_EXIST:\n if value & self.OV_SYM_DEAD:\n yield \"symlinks\"\n else:\n yield \"symlinks to existing files\"\n elif value & self.OV_SYM_DEAD:\n yield \"broken symlinks\"\n\n if value & self.OV_FILE:\n yield \"files\"\n # --- end of gen_words (...) ---\n\n return ', '.join ( gen_words() ) + \" (0x{:x})\".format ( value )","def additional_instruction_text(self):\r\n return ''","def __str__(self):\n s = f\"GraphViaEdges '{self.name}',\\nedges :\\n\"\n for edge, edgetype in self.edges.items():\n s += f\" {edge[0]} {edgetype.value} {edge[1]}\\n\"\n\n return s","def get_highlighted_style(feature):\r\n\r\n return {\"weight\": 3, \"color\": \"black\"}","def __repr__(self):\n ct = shortest_string_in_list(self.cause_texts)\n et = shortest_string_in_list(self.effect_texts)\n ev = ','.join(self.evidence_texts)\n return '%s -> %s [%s, %s, %s]' % (ct, et, ev,\n repr(self.cause_polarity),\n repr(self.effect_polarity))","def statflag(self) -> str | None:\n return self.status.get(\"STATFLAG\")","def __repr__(self):\n return f\"EdgeType.{self.name}\"","def GetDescription(cls):\n return textwrap.dedent('''\n This trace step includes a diagram of the Ego long. acceleration in the report.\n ''').strip()","def get_edge_name(options):\n user = pwd.getpwuid(os.getuid())[0]\n return \"%s-edge\" %(user)","def full_alert_text(self):\n if self.label:\n return '%s: %s' % (self.label, self.description)\n\n return self.description","def color_qualifiers(val: Any) -> str:\n if val == \"NO\":\n return \"color: #dc3545;\"\n elif val == \"YES\":\n return \"color: #198754;\"\n return \"\"","def print_ofpt_features_request(msg):\n pass","def get_comments(self):\n strg = \"QE measurement for detector %s\" % self.meta.instrument.detector\n return strg","def get_do_not_apply_label(self):\n return ''","def get_do_not_apply_label(self):\n return ''","def removeLabel(edge):\n return edge[:-2]","def removeLabel(edge):\n return edge[:-2]","def _flags(self):\n done, data = self._request('GE')\n if done:\n flags = int(data[1], 16)\n else:\n raise EvseError\n return {\n 'service_level': (flags & 0x0001) + 1,\n 'diode_check': not flags & 0x0002,\n 'vent_required': not flags & 0x0004,\n 'ground_check': not flags & 0x0008,\n 'stuck_relay_check': not flags & 0x0010,\n 'auto_service_level': not flags & 0x0020,\n 'auto_start': not flags & 0x0040,\n 'serial_debug': not not flags & 0x0080,\n 'lcd_type': 'monochrome' if flags & 0x0100 else 'rgb',\n 'gfi_self_test': not flags & 0x0200\n }","def GetInteriorEdgesHex(self):\n\n if not isinstance(self.all_edges,np.ndarray):\n self.GetEdgesHex()\n if not isinstance(self.edges,np.ndarray):\n self.GetBoundaryEdgesHex()\n\n edge_flags = in2d(self.all_edges.astype(self.edges.dtype),self.edges,consider_sort=True)\n edge_flags[edge_flags==True] = 1\n edge_flags[edge_flags==False] = 0\n interior_edges = self.all_edges[edge_flags==False,:]\n self.interior_edges = interior_edges\n\n return interior_edges, edge_flags","def urgency_explanation(self):\n return (\n factory.Faker(\"text\", max_nb_chars=500).generate()\n if self.urgency_level.requires_justification\n else \"\"\n )","def pretty_edge(edge_record):\n # String of the form (from_node) ===label===> (to_node)\n from_node = edge_record.get(\"fromNode\", {})\n to_node = edge_record.get(\"toNode\", {})\n label = edge_record.get(\"label\", None)\n\n edge_str = \"(\" + Utils.pretty_node(from_node) + \")\"\n edge_str += \" ===\" + label + \"===> \"\n edge_str += \"(\" + Utils.pretty_node(to_node) + \")\"\n\n return edge_str","def get_heatmode_stringlist(self):\n return text_heatmode","def is_important_text(node):\n\n return not (0 < len(node.get_text()) < TEXT_MIN_SCORE\n and node.name not in HEADING_TAGS)","def algorithmInfo():\n\t\treturn r\"\"\"TODO\"\"\"","def icon(self) -> str | None:\n icons = self.entity_description.on_off_icons\n return icons[0] if self.is_on else icons[1]","def flags_decomposer(flags):\n l = []\n if flags & 2 ** 0:\n l.append(\"superscript\")\n if flags & 2 ** 1:\n l.append(\"italic\")\n if flags & 2 ** 2:\n l.append(\"serifed\")\n else:\n l.append(\"sans\")\n if flags & 2 ** 3:\n l.append(\"monospaced\")\n else:\n l.append(\"proportional\")\n if flags & 2 ** 4:\n l.append(\"bold\")\n return \", \".join(l)","def to_faint_cap_str(svg_cap):\r\n # Fixme: Review, from old\r\n if svg_cap == 'butt':\r\n return 'flat'\r\n elif svg_cap == 'round':\r\n return 'round'\r\n else:\r\n return 'flat'","def __repr__(self):\n has_weights = any(True for k in self._weights.keys())\n \n ret = ''\n for key, value in sorted(self._edges.items()):\n ret += ' : '.join([repr(key), repr(value)])\n \n if has_weights:\n fs = frozenset\n ret += ' ' + repr([self._weights[fs((key, v))] for v in value])\n ret += '\\n'\n \n return ret.strip()","def _repr_options(self) -> str:\n return \"\"","def __str__(self):\n ret_str = \"\"\n for element_type in ('nodes', 'edges', 'layers'):\n elements = getattr(self, element_type)\n subtype_counts = defaultdict(int)\n ret_str += \"{0} {1}:\\n\".format(len(elements), element_type)\n for element in elements:\n subtype_counts[type(element).__name__] += 1\n for subtype in subtype_counts:\n ret_str += \"\\t{0}: {1}\\n\".format(subtype,\n subtype_counts[subtype])\n ret_str += \"\\n\"\n ret_str += \"primary text:\\n{0}\".format(self.text.encode('utf-8'))\n return ret_str","def get_alternative_flag(_image_path : str) -> str:\n image_extless = os.path.splitext(os.path.basename(_image_path))[0]\n\n #if the final character is an integer, then there's no alternative flag\n if re.search(ONLY_INTEGERS_REGEX, image_extless[-1]):\n alternative_flag = ''\n else:\n alternative_flag = image_extless[-1]\n\n return alternative_flag","def __repr__(self):\n return (f'Heuristic: {self.heuristic}\\n'\\\n f'Ancestors: {self.ancestors}\\n'\\\n f'Result: {self.result}\\n'\\\n f'Attributes: {self.attributes}\\n'\\\n f'Split Attribute: {self.split_attr}\\n'\\\n f'Has children: {self.val0 != None}\\n')","def format_flags(self):\n flags = []\n if self.is_unique:\n flags.append('Unique')\n if self.is_weak:\n flags.append('Weak')\n if self.is_ctor:\n flags.append('Constructor')\n if self.is_warning:\n flags.append('Warning')\n if self.is_ref:\n flags.append('Indirect reference')\n if self.is_reloc:\n flags.append('Reloc function')\n if self.is_debug:\n flags.append('Debug')\n if self.is_dynamic:\n flags.append('Dynamic')\n if self.is_func:\n flags.append('Function')\n if self.is_file:\n flags.append('File')\n if self.is_object:\n flags.append('Object')\n return flags","def info(self):\n import tc\n ## enumerate all options\n opts = self.to_list()\n res = \"\"\n fmt = \"%20s = %5s ## %s\\n\"\n\n for k, v in opts:\n res += fmt % (k, str(self.__getattribute__(k)),\n str(v.doc()).split('\\n')[0])\n\n return res","def flag_name(self):\n return self._flag_name","def _show_feature_flags(graph: nx.DiGraph, mode='sorted'):\n #plt.figure(figsize=(15, 15))\n if mode == 'sorted':\n pos = nx.multipartite_layout(graph)\n nx.draw(graph, pos, with_labels=True, arrows=True, node_color=\"#BA9DFB\")\n else:\n pos = graphviz_layout(graph)\n nx.draw_networkx(graph, pos, arrows=True, node_color=\"#BA9DFB\")\n plt.show()\n plt.clf()","def _color_info_text(self):\n\n t = ''\n for info in self.color_info:\n if info == 'rgbhex':\n t1 = tks.color_funcs.rgb_to_hex_string(self.rgb)\n elif info == 'rgb':\n t1 = tks.color_funcs.rgb_to_rgb_string(self.rgb, dp=2)\n elif info == 'hsv':\n t1 = tks.color_funcs.rgb_to_hsv_string(self.rgb, dp=2)\n elif info == 'hls':\n t1 = tks.color_funcs.rgb_to_hls_string(self.rgb, dp=2)\n\n t = t + '%s\\n' % t1\n\n return t","def mode_to_text(cls, mode: int) -> str:\n if mode == cls.ModeCV:\n return 'CV'\n elif mode == cls.ModeCC:\n return 'CC'\n else:\n return 'EE'","def describe(self):\n return ''","def edges(self):\n return self.dovetails + self.containments + self.internals","def aesthetics(cls: type[geom]) -> set[str]:\n main = cls.DEFAULT_AES.keys() | cls.REQUIRED_AES\n other = {\"group\"}\n # Need to recognize both spellings\n if \"color\" in main:\n other.add(\"colour\")\n if \"outlier_color\" in main:\n other.add(\"outlier_colour\")\n return main | other","def nodes_flags(self):\n return self._nodes_flags","def GetAGWFlags(self):\r\n \r\n return self._agwFlags","def get_tooltip_text(self): # real signature unknown; restored from __doc__\n return \"\"","def get_text(self):\n inp = \" \"\n if self.link_id:\n inp += \"LINK \" + self.link_id\n inp += self.status + ' '\n if self.node_id:\n inp += \"NODE \" + self.node_id + ' '\n if self.value:\n inp += self.control_type.name + ' ' + str(self.value) + ' '\n if self.time:\n inp += self.time + ' '\n if self.clock_time:\n inp += self.clock_time + ' '\n # TODO: research correct formatting of time, clock_time options\n return inp","def __repr__(self):\n if self.is_crowned():\n return \"R\" if self.is_red() else \"B\"\n return \"r\" if self.is_red() else \"b\"","def format_basis_for_nwchem(self, basopt):\n from collections import defaultdict\n\n text = ''\n for fr in range(self.nfragments()):\n if self.fragment_types[fr] == 'Absent':\n pass\n else:\n text += basopt.print_detail_nwchem()\n\n text += 'end \\n'\n\n options = defaultdict(lambda: defaultdict(dict))\n\n return text, options","def feature_flags(self):\r\n return self.env_tokens.get('FEATURES', dict())","def fallback_text(self):\n text = \"\"\n text += \"bad keyword {}\" + \"\\n\"\n text += \"retry\" + \"\\n\"\n text += \"\\n\"\n text += \"available functions\" + \"\\n\"\n\n for keyword in self.keywords:\n text += f'{keyword}\\n'\n\n return text","def control_edge_count(self) -> int:\n return int(self.graph_tuple_stats.control_edge_count or 0)","def __str__(self):\n if len(self.label) > 0:\n descr = [\"'%s', target='%s' [%s]\" % (self.label, self.target.name, self.target.body_type)]\n else:\n descr = [\"target='%s' [%s]\" % (self.target.name, self.target.body_type)]\n if self.baseline:\n descr[0] += ', initial baseline offset=%f' % (self.baseline.poly[-1],)\n if self.beam:\n descr[0] += ', beam height=%f' % (self.beam.height,)\n for scan_ind, scan in enumerate(self.scans):\n descr.append('%4d: %s' % (scan_ind, str(scan)))\n return '\\n'.join(descr)","def edge_model(label1, label2):\n if label1 == label2:\n return ALPHA\n else:\n return 1-ALPHA","def parseFlags(self):\n # Blank return value.\n retVal = \"\"\n \n try:\n # Store flags as we parse them.\n allFlags = []\n \n # Get the accumulator flag.\n accFlag = self.__flags & self.f_accum\n trendFlag = self.__flags & self.f_trend\n modeFlag = self.__flags & self.f_mode\n \n # Complete set of readings?\n if accFlag == self.f_accum_complete:\n # Completed loading values into the accumulator.\n allFlags.append('C')\n elif accFlag == self.f_accum_accum:\n # Still accumulating.\n allFlags.append('A')\n elif accFlag == self.f_accum_unk:\n # Unknown.\n allFlags.append('?')\n else:\n # Bad value.\n allFlags.append('!')\n \n # Trend?\n if (trendFlag) == self.f_trend_stable:\n # Readings stable.\n allFlags.append('S')\n elif (trendFlag) == self.f_trend_up:\n # Still accumulating.\n allFlags.append('U')\n elif (trendFlag) == self.f_trend_dn:\n # Still accumulating.\n allFlags.append('D')\n elif (trendFlag) == self.f_trend_unk:\n # Still accumulating.\n allFlags.append('?')\n else:\n # Bad value.\n allFlags.append('!')\n \n # Mode?\n if modeFlag == self.f_mode_fast:\n # Fast\n allFlags.append('F')\n elif modeFlag == self.f_mode_slow:\n # Slow\n allFlags.append('S')\n elif modeFlag == self.f_mode_counter:\n # Stream\n allFlags.append('C')\n elif modeFlag == self.f_mode_scaler:\n # Roll\n allFlags.append('L')\n else:\n # Bad value.\n allFlags.append('!')\n \n # Build a nice string.\n retVal = ''.join(allFlags)\n \n \n except:\n raise\n \n # Return value.\n return retVal","def _get_rating_text(self) -> str:\n\n rating_text = \"\"\n if self.current_level.rating:\n rating_text = f\"{self.current_level.rating}⭐\"\n\n return rating_text","def getGraphPointNamesString(self):\n names = []\n for gp in self.getGraphPoints():\n if hasattr(aq_base(gp), 'isBroken') and gp.isBroken():\n names.append('%s(<span style=\"color: red\">missing</span>)' %\n gp.id)\n else:\n names.append(gp.id)\n return ', '.join(names)"],"string":"[\n \"def human_readable(self):\\n if self.no_flags_set():\\n return \\\"no flags set\\\"\\n else:\\n flag_desc = []\\n for name in (\\\"bookmarked\\\", \\\"for_validation\\\", \\\"candidate\\\", \\\"final causative\\\"):\\n if getattr(self, \\\"flag_%s\\\" % name.replace(\\\" \\\", \\\"_\\\")):\\n flag_desc.append(name)\\n for name in (\\\"visual\\\", \\\"validation\\\", \\\"molecular\\\", \\\"phenotype_match\\\", \\\"summary\\\"):\\n field = getattr(self, \\\"flag_%s\\\" % name)\\n if field and field != \\\"empty\\\":\\n flag_desc.append(\\\"%s rating is %s\\\" % (name.split(\\\"_\\\")[0], field))\\n return \\\", \\\".join(flag_desc)\",\n \"def on_edge(bits: int) -> str:\\n edges = []\\n if bits & N_EDGE:\\n edges.append(\\\"n\\\")\\n if bits & E_EDGE:\\n edges.append(\\\"e\\\")\\n if bits & S_EDGE:\\n edges.append(\\\"s\\\")\\n if bits & W_EDGE:\\n edges.append(\\\"w\\\")\\n return \\\"\\\".join(edges)\",\n \"def show_ground_feature():\\n ground_description_int = GROUND_FEATURES_LIST[ZERO_BASE_PLYR_POS]\\n mvaddstr(16, 3, GROUND_DESCRIPTIONS.get(ground_description_int), color_pair(GROUND_FEATURES_COLOUR) | A_BOLD)\",\n \"def __repr__(self):\\n\\n flags = [str(flg) for flg in self.eset if str(flg) in self.flags]\\n return ('<%s [%s] (0x%x)>' % (\\n self.__class__.__name__, ', '.join(flags), self.bitflags))\",\n \"def __str__(self):\\n try:\\n return \\\"Edge from \\\" + str(self.startVertex) + \\\" to \\\" + str(self.endVertex) + \\\" Weight \\\" + str(self.edgeWeight) + \\\" Dijkstra Criterion \\\" + str(self.dijkstraCriterion)\\n except:\\n return \\\"Edge from \\\" + str(self.startVertex) + \\\" to \\\" + str(self.endVertex) + \\\" Weight \\\" + str(self.edgeWeight)\",\n \"def to_text(flags):\\n\\n return _to_text(flags, _by_value, _flags_order)\",\n \"def _getTextForAvailability(self, obj):\\n\\n state = obj.getState()\\n if not state.contains(pyatspi.STATE_SENSITIVE):\\n # Translators: this represents an item on the screen that has\\n # been set insensitive (or grayed out).\\n #\\n return _(\\\"grayed\\\")\\n else:\\n return None\",\n \"def __str__(self):\\n string_flag = ''\\n for line in self.flag:\\n string_flag += ''.join(line) + '\\\\n'\\n return string_flag\",\n \"def special_badge_text(self):\\r\\n return None\",\n \"def NoDeltaGExplanation(self):\\n for compound in self.reactants:\\n if compound.compound.no_dg_explanation:\\n name = compound.compound.common_names.all()[0].name\\n return '%s %s' % (name,\\n compound.compound.no_dg_explanation.lower())\\n return None\",\n \"def flagged_reason(self) -> Sequence[str]:\\r\\n return self._flagged_reason\",\n \"def edns_to_text(flags):\\n\\n return _to_text(flags, _edns_by_value, _edns_flags_order)\",\n \"def description(self) -> str:\\n return f\\\"Maximize number of {colour_name(self.colour)} unit cells \\\" \\\\\\n f\\\"that form a blob by touching sides. \\\" \\\\\\n f\\\"Touching corners doesn't count\\\"\",\n \"def _features_of(entry: _LexiconEntry) -> str:\\n return entry[\\\"features\\\"]\",\n \"def __str__(self):\\n # string representation includes values of all inner fields\\n return \\\\\\n \\\"Edge Weight: \\\" + str(self.weight) + \\\"\\\\n\\\" + \\\\\\n \\\"Edge Attributes: \\\" + str(self.attributes) + \\\"\\\\n\\\" + \\\\\\n \\\"First Incident Node: \\\\n\\\" + str(self.first_incident_node.get_name()) + \\\"\\\\n\\\" + \\\\\\n \\\"Second Incident Node: \\\\n\\\" + str(self.second_incident_node.get_name()) + \\\"\\\\n\\\"\",\n \"def edge_cases():\\n pris_edge_cases = {'OHI-': 'Ōi',\\n 'ASCO-': 'Ascó',\\n 'ROVNO-': 'Rivne',\\n 'SHIN-KORI-': 'Kori',\\n 'ANO-': 'Arkansas One',\\n 'HANBIT-': 'Yeonggwang',\\n 'FERMI-': 'Enrico Fermi',\\n 'BALTIC-': 'Kaliningrad',\\n 'COOK-': 'Donald C. Cook',\\n 'HATCH-': 'Edwin I. Hatch',\\n 'HARRIS-': 'Shearon Harris',\\n 'SHIN-WOLSONG-': 'Wolseong',\\n 'ST. ALBAN-': 'Saint-Alban',\\n 'LASALLE-': 'LaSalle County',\\n 'SUMMER-': 'Virgil C. Summer',\\n 'FARLEY-': 'Joseph M. Farley',\\n 'ST. LAURENT ': 'Saint-Laurent',\\n 'HADDAM NECK': 'Connecticut Yankee',\\n 'HIGASHI DORI-1 (TOHOKU)': 'Higashidōri',\\n }\\n return pris_edge_cases\",\n \"def getText(self):\\n return self.graph.get(\\\"__txt\\\", '')\",\n \"def description(self):\\n active = np.nonzero([bool(p) for p in self])[0]\\n last_active = active[-1] if len(active) else -1\\n return ' '.join([p.value_str for p in self][:last_active + 1])\",\n \"def text(self):\\n if self.is_root:\\n return ''\\n elif self.is_comment:\\n return self.__value\\n elif self.is_flag:\\n if self.__value:\\n return '[{0}]'.format(self.name)\\n else:\\n return '!{0}!'.format(self.name)\\n else:\\n return '[{0}:{1}]'.format(self.name, self.value)\",\n \"def get_hover_text(self) -> str:\\n if self.graph_element is None:\\n return ''\\n text = ''\\n for name, value in self.graph_element.attr.items():\\n if name in ('x', 'y') or name.startswith('.'):\\n continue\\n text += f'{name}: {value}\\\\n'\\n return text[:-1]\",\n \"def display_node_attributes(node):\\n\\n text = G[node][\\\"name\\\"] if hasattr(G[node], \\\"name\\\") else \\\"Node: \\\" + str(node)\\n\\n if nx.is_directed(G):\\n text += \\\", In Degree: \\\" + str(G.in_degree[node])\\n text += \\\", Out Degree: \\\" + str(G.out_degree[node])\\n else:\\n text += \\\"Degree: \\\" + str(G.degree[node])\\n\\n eccentricity = max(nx.single_source_shortest_path_length(G, node))\\n text += \\\", Ecentricity: \\\" + str(eccentricity)\\n\\n if nx.is_directed(G):\\n text += \\\", Reciprocity: {:.2f}\\\".format(reciprocities[node])\\n\\n return text\",\n \"def __repr__(self) -> str:\\n if self._has_direction:\\n return (\\n f\\\"<Edge: from {self._start} to {self._end} \\\"\\n f\\\"with label '{self._label}'>\\\"\\n )\\n return (\\n f\\\"<Edge: between {self._start} and {self._end} \\\"\\n f\\\"with label '{self._label}'>\\\"\\n )\",\n \"def get_informative_message(self, msg_content):\\n return \\\"{0}{1}{2}\\\".format(\\\"\\\\x1b[6;30;44m\\\", msg_content, \\\"\\\\x1b[0m\\\")\",\n \"def flag(self) -> str:\\n return pulumi.get(self, \\\"flag\\\")\",\n \"def special_tags_to_text(self):\\n if (self.windtag is None and self.tornadotag is None and\\n self.hailtag is None and self.tornadodamagetag is None and\\n self.waterspouttag is None and not self.flood_tags):\\n return \\\"\\\"\\n\\n parts = []\\n if self.tornadotag is not None:\\n parts.append(\\\"tornado: %s\\\" % (\\n self.tornadotag))\\n if self.waterspouttag is not None:\\n parts.append(\\\"waterspout: %s\\\" % (\\n self.waterspouttag))\\n if self.tornadodamagetag is not None:\\n parts.append(\\\"tornado damage threat: %s\\\" % (\\n self.tornadodamagetag))\\n if self.windtag is not None:\\n parts.append(\\\"wind: %s%s %s\\\" % (\\n self.winddirtag.replace(\\\">\\\", \\\">\\\").replace(\\\"<\\\", \\\"<\\\"),\\n self.windtag, self.windtagunits))\\n if self.hailtag is not None:\\n parts.append(\\\"hail: %s%s IN\\\" % (\\n self.haildirtag.replace(\\\">\\\", \\\">\\\").replace(\\\"<\\\", \\\"<\\\"),\\n self.hailtag))\\n for k, v in self.flood_tags.items():\\n parts.append(\\\"%s: %s\\\" % (k.lower(), v.lower()))\\n return \\\" [\\\" + \\\", \\\".join(parts) + \\\"] \\\"\",\n \"def make_edge_text(self):\\n fmtstr = ub.codeblock(\\n '''\\n connect from {oport_abs_name}\\n to {iport_abs_name}\\n ''')\\n parts = []\\n for iport in self.iports.values():\\n for oport in iport.connections:\\n if oport is not None:\\n part = fmtstr.format(\\n oport_abs_name=oport.absname(),\\n iport_abs_name=iport.absname(),\\n )\\n parts.append(part)\\n text = '\\\\n'.join(parts)\\n return text\",\n \"def flagged(self) -> Sequence[str]:\\r\\n return self._flagged\",\n \"def getFeatures(self):\\n return \\\"1:\\\" + str(self.getEnergy()) + \\\\\\n \\\" 2:\\\" + str(self.getCentroid()) + \\\\\\n \\\" 3:\\\" + str(self.getZCrossingRate()) + \\\\\\n \\\" 4:\\\" + str(self.getBandwidth())\",\n \"def get_status(bool):\\n if bool:\\n return \\\"✓\\\"\\n else:\\n return \\\"...\\\"\",\n \"def flag_titular(self):\\n return self._flag_titular\",\n \"def flags(self):\\n return self.ast_node.flags\",\n \"def get_text(downgrade_titles=False):\",\n \"def writeEDGE(self):\\n\\t\\tpass\",\n \"def __str__(self):\\n\\n return '{0} {1} {2}'.format(self.feat, '==' if self.pos else '!=',\\n self.val)\",\n \"def __repr__(self):\\n s = ''\\n nums = (self.mines + 1) * self.clicked\\n for row in range(0, self.rows):\\n for col in range(0, self.cols):\\n num = nums[row, col]\\n if self.isFlagged(row, col):\\n s += str(Board.FLAGGED) + ' '\\n elif num == 0:\\n s += str(Board.HIDDEN) + ' '\\n else:\\n if self.isMine(row, col):\\n s += str(Board.MINE) + ' '\\n else:\\n s += str(int(num - 1)) + ' '\\n s += '\\\\n'\\n return s\",\n \"def negations(self) -> str:\",\n \"def get_edge(update: Update, context: CallbackContext):\\n\\n try:\\n try: \\n element = str(context.args[0])\\n edge = str(context.args[1])\\n message = look_edges_db(element,edge)\\n except:\\n element = str(context.args[0])\\n message = look_edges_db(element) \\n except:\\n message = '''choose valid element, e.g. Co and edge: \\\\n\\n Fe\\n Ni L \\n Co L3\\n '''\\n \\n context.bot.send_message(chat_id=update.message.chat_id, text=message, parse_mode='HTML')\",\n \"def _strSoft(self):\\n return \\\"(Soft) Beta:%f Threshold:%f Enabled: %s\\\" % (self.beta, self.threshold, str(self.enabled))\",\n \"def get_warning_text(self):\\n \\n to_print = []\\n if self['skipped_subchannel'] > 0:\\n to_print.append(\\\"Some event with large weight have been discarded.\\\"+\\\\\\n \\\" This happens %s times.\\\" % self['skipped_subchannel'])\\n if self['n_madloop_calls'] > 0:\\n fraction = self['exceptional_points']/float(self['n_madloop_calls'])\\n if fraction > 1.0e-4:\\n to_print.append(\\\"Some PS with numerical instability have been set \\\"+\\\\\\n \\\"to a zero matrix-element (%.3g%%)\\\" % (100.0*fraction))\\n \\n return ('\\\\n'.join(to_print)).replace(\\\"'\\\",\\\" \\\")\",\n \"def edge_attribute(self):\\n return self._edge_attribute\",\n \"def edge_status(g, source, target):\\n edge = source, target, g.graph['edge_key']\\n if edge in g.graph['negatives']:\\n status = 0\\n elif edge in g.graph['positives']:\\n status = 1\\n else:\\n status = int(g.has_edge(*edge)) + 2\\n return status\",\n \"def get_human_readable(self):\\n\\n def yesno(key):\\n if getattr(self, key) and getattr(self, key) > 0:\\n return \\\"Y\\\"\\n else:\\n return \\\"N\\\"\\n\\n keys = (\\n \\\"pvs1\\\",\\n \\\"ps1\\\",\\n \\\"ps2\\\",\\n \\\"ps3\\\",\\n \\\"ps4\\\",\\n \\\"pm1\\\",\\n \\\"pm2\\\",\\n \\\"pm3\\\",\\n \\\"pm4\\\",\\n \\\"pm5\\\",\\n \\\"pm6\\\",\\n \\\"pp1\\\",\\n \\\"pp2\\\",\\n \\\"pp3\\\",\\n \\\"pp4\\\",\\n \\\"pp5\\\",\\n \\\"ba1\\\",\\n \\\"bs1\\\",\\n \\\"bs2\\\",\\n \\\"bs3\\\",\\n \\\"bs4\\\",\\n \\\"bp1\\\",\\n \\\"bp2\\\",\\n \\\"bp3\\\",\\n \\\"bp4\\\",\\n \\\"bp5\\\",\\n \\\"bp6\\\",\\n \\\"bp7\\\",\\n )\\n result = \\\", \\\".join([\\\"%s: %s\\\" % (key.upper(), yesno(key)) for key in keys])\\n result += \\\", ACMG classification: %s\\\" % self.class_auto\\n if self.class_override:\\n result += \\\", ACMG class. override: %s\\\" % self.class_override\\n return result\",\n \"def str_targetting(self):\\n if not self.targetting: # set to none etc.\\n return \\\"doing nothing\\\"\\n if self.targetting[0] == \\\"marching\\\":\\n return \\\"marching -> \\\" + self.targetting[1].color_name()\\n if self.targetting[0] == \\\"defending\\\":\\n return \\\"staying put\\\"\\n assert self.targetting[0] == \\\"sneaking\\\"\\n return \\\"sneaking -> \\\" + self.targetting[1].color_name()\",\n \"def create_bar_pin_flag_text(self, unused_pin_flag=None):\\n nids = []\\n text = []\\n #result_name = self.icase\\n result_name = str('ElementID')\\n for nid, data in sorted(self.nid_release_map.items()):\\n sub_release_map = defaultdict(str)\\n for (eid, pin_flagi) in data:\\n sub_release_map[pin_flagi] += (str(eid) + ', ')\\n texti = '\\\\n'.join(['%s-%s' % (pin_flagi, msg.rstrip(', '))\\n for (pin_flagi, msg) in sorted(sub_release_map.items())])\\n\\n # super messy\\n #texti = ', '.join(['%s-%s' % (pin_flagi, eid) for (eid, pin_flagi) in data])\\n nids.append(nid)\\n text.append(texti)\\n self.gui.mark_nodes(nids, result_name, text)\",\n \"def nft_flag(self) -> str:\\n t_type = self.token_type\\n if t_type == 65:\\n return \\\"NFT_CHILD\\\"\\n elif t_type == 129:\\n return \\\"NFT_PARENT\\\"\\n else:\\n return None\",\n \"def get_str ( self ):\\n value = self.value\\n def gen_words():\\n if value == self.OV_NONE:\\n yield \\\"none\\\"\\n else:\\n if value & self.OV_SYM_EXIST:\\n if value & self.OV_SYM_DEAD:\\n yield \\\"symlinks\\\"\\n else:\\n yield \\\"symlinks to existing files\\\"\\n elif value & self.OV_SYM_DEAD:\\n yield \\\"broken symlinks\\\"\\n\\n if value & self.OV_FILE:\\n yield \\\"files\\\"\\n # --- end of gen_words (...) ---\\n\\n return ', '.join ( gen_words() ) + \\\" (0x{:x})\\\".format ( value )\",\n \"def additional_instruction_text(self):\\r\\n return ''\",\n \"def __str__(self):\\n s = f\\\"GraphViaEdges '{self.name}',\\\\nedges :\\\\n\\\"\\n for edge, edgetype in self.edges.items():\\n s += f\\\" {edge[0]} {edgetype.value} {edge[1]}\\\\n\\\"\\n\\n return s\",\n \"def get_highlighted_style(feature):\\r\\n\\r\\n return {\\\"weight\\\": 3, \\\"color\\\": \\\"black\\\"}\",\n \"def __repr__(self):\\n ct = shortest_string_in_list(self.cause_texts)\\n et = shortest_string_in_list(self.effect_texts)\\n ev = ','.join(self.evidence_texts)\\n return '%s -> %s [%s, %s, %s]' % (ct, et, ev,\\n repr(self.cause_polarity),\\n repr(self.effect_polarity))\",\n \"def statflag(self) -> str | None:\\n return self.status.get(\\\"STATFLAG\\\")\",\n \"def __repr__(self):\\n return f\\\"EdgeType.{self.name}\\\"\",\n \"def GetDescription(cls):\\n return textwrap.dedent('''\\n This trace step includes a diagram of the Ego long. acceleration in the report.\\n ''').strip()\",\n \"def get_edge_name(options):\\n user = pwd.getpwuid(os.getuid())[0]\\n return \\\"%s-edge\\\" %(user)\",\n \"def full_alert_text(self):\\n if self.label:\\n return '%s: %s' % (self.label, self.description)\\n\\n return self.description\",\n \"def color_qualifiers(val: Any) -> str:\\n if val == \\\"NO\\\":\\n return \\\"color: #dc3545;\\\"\\n elif val == \\\"YES\\\":\\n return \\\"color: #198754;\\\"\\n return \\\"\\\"\",\n \"def print_ofpt_features_request(msg):\\n pass\",\n \"def get_comments(self):\\n strg = \\\"QE measurement for detector %s\\\" % self.meta.instrument.detector\\n return strg\",\n \"def get_do_not_apply_label(self):\\n return ''\",\n \"def get_do_not_apply_label(self):\\n return ''\",\n \"def removeLabel(edge):\\n return edge[:-2]\",\n \"def removeLabel(edge):\\n return edge[:-2]\",\n \"def _flags(self):\\n done, data = self._request('GE')\\n if done:\\n flags = int(data[1], 16)\\n else:\\n raise EvseError\\n return {\\n 'service_level': (flags & 0x0001) + 1,\\n 'diode_check': not flags & 0x0002,\\n 'vent_required': not flags & 0x0004,\\n 'ground_check': not flags & 0x0008,\\n 'stuck_relay_check': not flags & 0x0010,\\n 'auto_service_level': not flags & 0x0020,\\n 'auto_start': not flags & 0x0040,\\n 'serial_debug': not not flags & 0x0080,\\n 'lcd_type': 'monochrome' if flags & 0x0100 else 'rgb',\\n 'gfi_self_test': not flags & 0x0200\\n }\",\n \"def GetInteriorEdgesHex(self):\\n\\n if not isinstance(self.all_edges,np.ndarray):\\n self.GetEdgesHex()\\n if not isinstance(self.edges,np.ndarray):\\n self.GetBoundaryEdgesHex()\\n\\n edge_flags = in2d(self.all_edges.astype(self.edges.dtype),self.edges,consider_sort=True)\\n edge_flags[edge_flags==True] = 1\\n edge_flags[edge_flags==False] = 0\\n interior_edges = self.all_edges[edge_flags==False,:]\\n self.interior_edges = interior_edges\\n\\n return interior_edges, edge_flags\",\n \"def urgency_explanation(self):\\n return (\\n factory.Faker(\\\"text\\\", max_nb_chars=500).generate()\\n if self.urgency_level.requires_justification\\n else \\\"\\\"\\n )\",\n \"def pretty_edge(edge_record):\\n # String of the form (from_node) ===label===> (to_node)\\n from_node = edge_record.get(\\\"fromNode\\\", {})\\n to_node = edge_record.get(\\\"toNode\\\", {})\\n label = edge_record.get(\\\"label\\\", None)\\n\\n edge_str = \\\"(\\\" + Utils.pretty_node(from_node) + \\\")\\\"\\n edge_str += \\\" ===\\\" + label + \\\"===> \\\"\\n edge_str += \\\"(\\\" + Utils.pretty_node(to_node) + \\\")\\\"\\n\\n return edge_str\",\n \"def get_heatmode_stringlist(self):\\n return text_heatmode\",\n \"def is_important_text(node):\\n\\n return not (0 < len(node.get_text()) < TEXT_MIN_SCORE\\n and node.name not in HEADING_TAGS)\",\n \"def algorithmInfo():\\n\\t\\treturn r\\\"\\\"\\\"TODO\\\"\\\"\\\"\",\n \"def icon(self) -> str | None:\\n icons = self.entity_description.on_off_icons\\n return icons[0] if self.is_on else icons[1]\",\n \"def flags_decomposer(flags):\\n l = []\\n if flags & 2 ** 0:\\n l.append(\\\"superscript\\\")\\n if flags & 2 ** 1:\\n l.append(\\\"italic\\\")\\n if flags & 2 ** 2:\\n l.append(\\\"serifed\\\")\\n else:\\n l.append(\\\"sans\\\")\\n if flags & 2 ** 3:\\n l.append(\\\"monospaced\\\")\\n else:\\n l.append(\\\"proportional\\\")\\n if flags & 2 ** 4:\\n l.append(\\\"bold\\\")\\n return \\\", \\\".join(l)\",\n \"def to_faint_cap_str(svg_cap):\\r\\n # Fixme: Review, from old\\r\\n if svg_cap == 'butt':\\r\\n return 'flat'\\r\\n elif svg_cap == 'round':\\r\\n return 'round'\\r\\n else:\\r\\n return 'flat'\",\n \"def __repr__(self):\\n has_weights = any(True for k in self._weights.keys())\\n \\n ret = ''\\n for key, value in sorted(self._edges.items()):\\n ret += ' : '.join([repr(key), repr(value)])\\n \\n if has_weights:\\n fs = frozenset\\n ret += ' ' + repr([self._weights[fs((key, v))] for v in value])\\n ret += '\\\\n'\\n \\n return ret.strip()\",\n \"def _repr_options(self) -> str:\\n return \\\"\\\"\",\n \"def __str__(self):\\n ret_str = \\\"\\\"\\n for element_type in ('nodes', 'edges', 'layers'):\\n elements = getattr(self, element_type)\\n subtype_counts = defaultdict(int)\\n ret_str += \\\"{0} {1}:\\\\n\\\".format(len(elements), element_type)\\n for element in elements:\\n subtype_counts[type(element).__name__] += 1\\n for subtype in subtype_counts:\\n ret_str += \\\"\\\\t{0}: {1}\\\\n\\\".format(subtype,\\n subtype_counts[subtype])\\n ret_str += \\\"\\\\n\\\"\\n ret_str += \\\"primary text:\\\\n{0}\\\".format(self.text.encode('utf-8'))\\n return ret_str\",\n \"def get_alternative_flag(_image_path : str) -> str:\\n image_extless = os.path.splitext(os.path.basename(_image_path))[0]\\n\\n #if the final character is an integer, then there's no alternative flag\\n if re.search(ONLY_INTEGERS_REGEX, image_extless[-1]):\\n alternative_flag = ''\\n else:\\n alternative_flag = image_extless[-1]\\n\\n return alternative_flag\",\n \"def __repr__(self):\\n return (f'Heuristic: {self.heuristic}\\\\n'\\\\\\n f'Ancestors: {self.ancestors}\\\\n'\\\\\\n f'Result: {self.result}\\\\n'\\\\\\n f'Attributes: {self.attributes}\\\\n'\\\\\\n f'Split Attribute: {self.split_attr}\\\\n'\\\\\\n f'Has children: {self.val0 != None}\\\\n')\",\n \"def format_flags(self):\\n flags = []\\n if self.is_unique:\\n flags.append('Unique')\\n if self.is_weak:\\n flags.append('Weak')\\n if self.is_ctor:\\n flags.append('Constructor')\\n if self.is_warning:\\n flags.append('Warning')\\n if self.is_ref:\\n flags.append('Indirect reference')\\n if self.is_reloc:\\n flags.append('Reloc function')\\n if self.is_debug:\\n flags.append('Debug')\\n if self.is_dynamic:\\n flags.append('Dynamic')\\n if self.is_func:\\n flags.append('Function')\\n if self.is_file:\\n flags.append('File')\\n if self.is_object:\\n flags.append('Object')\\n return flags\",\n \"def info(self):\\n import tc\\n ## enumerate all options\\n opts = self.to_list()\\n res = \\\"\\\"\\n fmt = \\\"%20s = %5s ## %s\\\\n\\\"\\n\\n for k, v in opts:\\n res += fmt % (k, str(self.__getattribute__(k)),\\n str(v.doc()).split('\\\\n')[0])\\n\\n return res\",\n \"def flag_name(self):\\n return self._flag_name\",\n \"def _show_feature_flags(graph: nx.DiGraph, mode='sorted'):\\n #plt.figure(figsize=(15, 15))\\n if mode == 'sorted':\\n pos = nx.multipartite_layout(graph)\\n nx.draw(graph, pos, with_labels=True, arrows=True, node_color=\\\"#BA9DFB\\\")\\n else:\\n pos = graphviz_layout(graph)\\n nx.draw_networkx(graph, pos, arrows=True, node_color=\\\"#BA9DFB\\\")\\n plt.show()\\n plt.clf()\",\n \"def _color_info_text(self):\\n\\n t = ''\\n for info in self.color_info:\\n if info == 'rgbhex':\\n t1 = tks.color_funcs.rgb_to_hex_string(self.rgb)\\n elif info == 'rgb':\\n t1 = tks.color_funcs.rgb_to_rgb_string(self.rgb, dp=2)\\n elif info == 'hsv':\\n t1 = tks.color_funcs.rgb_to_hsv_string(self.rgb, dp=2)\\n elif info == 'hls':\\n t1 = tks.color_funcs.rgb_to_hls_string(self.rgb, dp=2)\\n\\n t = t + '%s\\\\n' % t1\\n\\n return t\",\n \"def mode_to_text(cls, mode: int) -> str:\\n if mode == cls.ModeCV:\\n return 'CV'\\n elif mode == cls.ModeCC:\\n return 'CC'\\n else:\\n return 'EE'\",\n \"def describe(self):\\n return ''\",\n \"def edges(self):\\n return self.dovetails + self.containments + self.internals\",\n \"def aesthetics(cls: type[geom]) -> set[str]:\\n main = cls.DEFAULT_AES.keys() | cls.REQUIRED_AES\\n other = {\\\"group\\\"}\\n # Need to recognize both spellings\\n if \\\"color\\\" in main:\\n other.add(\\\"colour\\\")\\n if \\\"outlier_color\\\" in main:\\n other.add(\\\"outlier_colour\\\")\\n return main | other\",\n \"def nodes_flags(self):\\n return self._nodes_flags\",\n \"def GetAGWFlags(self):\\r\\n \\r\\n return self._agwFlags\",\n \"def get_tooltip_text(self): # real signature unknown; restored from __doc__\\n return \\\"\\\"\",\n \"def get_text(self):\\n inp = \\\" \\\"\\n if self.link_id:\\n inp += \\\"LINK \\\" + self.link_id\\n inp += self.status + ' '\\n if self.node_id:\\n inp += \\\"NODE \\\" + self.node_id + ' '\\n if self.value:\\n inp += self.control_type.name + ' ' + str(self.value) + ' '\\n if self.time:\\n inp += self.time + ' '\\n if self.clock_time:\\n inp += self.clock_time + ' '\\n # TODO: research correct formatting of time, clock_time options\\n return inp\",\n \"def __repr__(self):\\n if self.is_crowned():\\n return \\\"R\\\" if self.is_red() else \\\"B\\\"\\n return \\\"r\\\" if self.is_red() else \\\"b\\\"\",\n \"def format_basis_for_nwchem(self, basopt):\\n from collections import defaultdict\\n\\n text = ''\\n for fr in range(self.nfragments()):\\n if self.fragment_types[fr] == 'Absent':\\n pass\\n else:\\n text += basopt.print_detail_nwchem()\\n\\n text += 'end \\\\n'\\n\\n options = defaultdict(lambda: defaultdict(dict))\\n\\n return text, options\",\n \"def feature_flags(self):\\r\\n return self.env_tokens.get('FEATURES', dict())\",\n \"def fallback_text(self):\\n text = \\\"\\\"\\n text += \\\"bad keyword {}\\\" + \\\"\\\\n\\\"\\n text += \\\"retry\\\" + \\\"\\\\n\\\"\\n text += \\\"\\\\n\\\"\\n text += \\\"available functions\\\" + \\\"\\\\n\\\"\\n\\n for keyword in self.keywords:\\n text += f'{keyword}\\\\n'\\n\\n return text\",\n \"def control_edge_count(self) -> int:\\n return int(self.graph_tuple_stats.control_edge_count or 0)\",\n \"def __str__(self):\\n if len(self.label) > 0:\\n descr = [\\\"'%s', target='%s' [%s]\\\" % (self.label, self.target.name, self.target.body_type)]\\n else:\\n descr = [\\\"target='%s' [%s]\\\" % (self.target.name, self.target.body_type)]\\n if self.baseline:\\n descr[0] += ', initial baseline offset=%f' % (self.baseline.poly[-1],)\\n if self.beam:\\n descr[0] += ', beam height=%f' % (self.beam.height,)\\n for scan_ind, scan in enumerate(self.scans):\\n descr.append('%4d: %s' % (scan_ind, str(scan)))\\n return '\\\\n'.join(descr)\",\n \"def edge_model(label1, label2):\\n if label1 == label2:\\n return ALPHA\\n else:\\n return 1-ALPHA\",\n \"def parseFlags(self):\\n # Blank return value.\\n retVal = \\\"\\\"\\n \\n try:\\n # Store flags as we parse them.\\n allFlags = []\\n \\n # Get the accumulator flag.\\n accFlag = self.__flags & self.f_accum\\n trendFlag = self.__flags & self.f_trend\\n modeFlag = self.__flags & self.f_mode\\n \\n # Complete set of readings?\\n if accFlag == self.f_accum_complete:\\n # Completed loading values into the accumulator.\\n allFlags.append('C')\\n elif accFlag == self.f_accum_accum:\\n # Still accumulating.\\n allFlags.append('A')\\n elif accFlag == self.f_accum_unk:\\n # Unknown.\\n allFlags.append('?')\\n else:\\n # Bad value.\\n allFlags.append('!')\\n \\n # Trend?\\n if (trendFlag) == self.f_trend_stable:\\n # Readings stable.\\n allFlags.append('S')\\n elif (trendFlag) == self.f_trend_up:\\n # Still accumulating.\\n allFlags.append('U')\\n elif (trendFlag) == self.f_trend_dn:\\n # Still accumulating.\\n allFlags.append('D')\\n elif (trendFlag) == self.f_trend_unk:\\n # Still accumulating.\\n allFlags.append('?')\\n else:\\n # Bad value.\\n allFlags.append('!')\\n \\n # Mode?\\n if modeFlag == self.f_mode_fast:\\n # Fast\\n allFlags.append('F')\\n elif modeFlag == self.f_mode_slow:\\n # Slow\\n allFlags.append('S')\\n elif modeFlag == self.f_mode_counter:\\n # Stream\\n allFlags.append('C')\\n elif modeFlag == self.f_mode_scaler:\\n # Roll\\n allFlags.append('L')\\n else:\\n # Bad value.\\n allFlags.append('!')\\n \\n # Build a nice string.\\n retVal = ''.join(allFlags)\\n \\n \\n except:\\n raise\\n \\n # Return value.\\n return retVal\",\n \"def _get_rating_text(self) -> str:\\n\\n rating_text = \\\"\\\"\\n if self.current_level.rating:\\n rating_text = f\\\"{self.current_level.rating}⭐\\\"\\n\\n return rating_text\",\n \"def getGraphPointNamesString(self):\\n names = []\\n for gp in self.getGraphPoints():\\n if hasattr(aq_base(gp), 'isBroken') and gp.isBroken():\\n names.append('%s(<span style=\\\"color: red\\\">missing</span>)' %\\n gp.id)\\n else:\\n names.append(gp.id)\\n return ', '.join(names)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6562656","0.612036","0.56815875","0.5583346","0.55517215","0.55415154","0.5524572","0.548128","0.54642874","0.5456155","0.541521","0.5414519","0.54008186","0.5340721","0.5325096","0.5318845","0.5292452","0.5237705","0.52254677","0.52168465","0.51546","0.51543224","0.51486427","0.51422286","0.5141875","0.51323277","0.51302016","0.51213455","0.5108562","0.51011455","0.5092521","0.50884527","0.5077469","0.50746316","0.50650084","0.5046253","0.5045218","0.5030613","0.5014229","0.49996123","0.49892017","0.49807283","0.4974438","0.4970815","0.49701867","0.49523064","0.49508274","0.49447298","0.49400753","0.49247038","0.4912563","0.49123427","0.49097505","0.49066538","0.4904271","0.48985174","0.48953614","0.48892725","0.4867774","0.4867774","0.48677","0.48677","0.48639223","0.4857788","0.4856296","0.48553348","0.48530146","0.48502588","0.48501253","0.48492375","0.48410085","0.48369566","0.48317564","0.48303935","0.48253894","0.48248243","0.4818119","0.4812183","0.48050666","0.47991377","0.47981158","0.478734","0.47829488","0.4780367","0.4779583","0.47616506","0.4756049","0.47556016","0.47544423","0.4747044","0.47421622","0.474114","0.47386828","0.47381687","0.47352216","0.47349414","0.47341502","0.4729535","0.47232977","0.47214326"],"string":"[\n \"0.6562656\",\n \"0.612036\",\n \"0.56815875\",\n \"0.5583346\",\n \"0.55517215\",\n \"0.55415154\",\n \"0.5524572\",\n \"0.548128\",\n \"0.54642874\",\n \"0.5456155\",\n \"0.541521\",\n \"0.5414519\",\n \"0.54008186\",\n \"0.5340721\",\n \"0.5325096\",\n \"0.5318845\",\n \"0.5292452\",\n \"0.5237705\",\n \"0.52254677\",\n \"0.52168465\",\n \"0.51546\",\n \"0.51543224\",\n \"0.51486427\",\n \"0.51422286\",\n \"0.5141875\",\n \"0.51323277\",\n \"0.51302016\",\n \"0.51213455\",\n \"0.5108562\",\n \"0.51011455\",\n \"0.5092521\",\n \"0.50884527\",\n \"0.5077469\",\n \"0.50746316\",\n \"0.50650084\",\n \"0.5046253\",\n \"0.5045218\",\n \"0.5030613\",\n \"0.5014229\",\n \"0.49996123\",\n \"0.49892017\",\n \"0.49807283\",\n \"0.4974438\",\n \"0.4970815\",\n \"0.49701867\",\n \"0.49523064\",\n \"0.49508274\",\n \"0.49447298\",\n \"0.49400753\",\n \"0.49247038\",\n \"0.4912563\",\n \"0.49123427\",\n \"0.49097505\",\n \"0.49066538\",\n \"0.4904271\",\n \"0.48985174\",\n \"0.48953614\",\n \"0.48892725\",\n \"0.4867774\",\n \"0.4867774\",\n \"0.48677\",\n \"0.48677\",\n \"0.48639223\",\n \"0.4857788\",\n \"0.4856296\",\n \"0.48553348\",\n \"0.48530146\",\n \"0.48502588\",\n \"0.48501253\",\n \"0.48492375\",\n \"0.48410085\",\n \"0.48369566\",\n \"0.48317564\",\n \"0.48303935\",\n \"0.48253894\",\n \"0.48248243\",\n \"0.4818119\",\n \"0.4812183\",\n \"0.48050666\",\n \"0.47991377\",\n \"0.47981158\",\n \"0.478734\",\n \"0.47829488\",\n \"0.4780367\",\n \"0.4779583\",\n \"0.47616506\",\n \"0.4756049\",\n \"0.47556016\",\n \"0.47544423\",\n \"0.4747044\",\n \"0.47421622\",\n \"0.474114\",\n \"0.47386828\",\n \"0.47381687\",\n \"0.47352216\",\n \"0.47349414\",\n \"0.47341502\",\n \"0.4729535\",\n \"0.47232977\",\n \"0.47214326\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.584295"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":15198,"cells":{"query":{"kind":"string","value":"Output the model predictions for the test set"},"document":{"kind":"string","value":"def output_predictions(predictions_file, relations, predictions, test_set_keys, test_labels):\n with codecs.open(predictions_file, 'w', 'utf-8') as f_out:\n for i, (w1, w2) in enumerate(test_set_keys):\n f_out.write('\\t'.join([w1, w2, relations[test_labels[i]], relations[predictions[i]]]) + '\\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 test():\n # load dataset and model\n X, observed_y = load_data('../data/dev.txt')\n\n model = pickle.load(open('test.model', 'rb'))\n model.traverse()\n\n # predict labels for dataset\n preds = model.predict(X)\n\n # print(preds)\n # output model predictions\n np.savetxt('test.predictions', preds, fmt='%s')","def test(self) -> None:\n\n self._predictions = self._lr.predict(self._X_test)","def predict(self):\n self.predicted_test_summary = []\n for step in xrange(0, self.test_size // self.test_batch_size):\n print 'Predicting Batch No.:', step\n offset = (step * self.test_batch_size) % self.test_size\n batch_data_fwd = self.X_tst_fwd[offset:(offset + self.test_batch_size), :].T\n batch_data_bwd = self.X_tst_bwd[offset:(offset + self.test_batch_size), :].T\n summary_test_out = self._predict_batch(batch_data_fwd, batch_data_bwd)\n self.predicted_test_summary.extend(summary_test_out)\n\n print 'Prediction Complete. Moving Forward..'\n\n # test answers\n self.test_review = self.X_tst_fwd\n self.predicted_test_summary = self.predicted_test_summary\n self.true_summary = self.Y_tst","def get_predictions(fitted_model_filename):\n click.echo(\"Mode: predicting probabilities.\\n\")\n defaults = get_defaults()\n\n fitted_model_filename = add_extension(fitted_model_filename)\n fitted_model_path = os.path.join(defaults.OUTPUT.FITTED_MODELS_PATH, fitted_model_filename)\n new_options = [\"OUTPUT.FITTED_MODEL_PATH\", fitted_model_path]\n\n # boot_data = bootstrap(new_options, mode=\"internal_test\")\n # model = boot_data['model']\n #\n # X_test_int, y_test_int = boot_data['data']\n # internal_test_proba = model.predict_proba(X_test_int)\n # internal_test_proba = np.c_[y_test_int, internal_test_proba[:, 1]]\n\n boot_data = bootstrap(new_options, mode=\"external_test\")\n model = boot_data['model']\n X_test_ext, y_test_ext = boot_data['data']\n\n # fit scaler on train data and transform test data\n scaler = StandardScaler()\n X_train, y_train = load_data(defaults, which='train')\n\n numeric_cols = X_train.select_dtypes(include=np.float64).columns.tolist()\n scaler.fit(X_train[numeric_cols])\n X_test_ext.loc[:, numeric_cols] = scaler.transform(X_test_ext[numeric_cols])\n\n external_test_proba = model.predict_proba(X_test_ext)\n external_test_proba = np.c_[y_test_ext, external_test_proba[:, 1]]\n\n # internal_test_results_path = os.path.join(defaults.OUTPUT.PREDS_PATH, \"internal_test_preds.csv\")\n external_test_results_path = os.path.join(defaults.OUTPUT.PREDS_PATH,\n f\"external_test_preds_{fitted_model_filename.replace('.pkl', '')}.csv\")\n # pd.DataFrame(internal_test_proba, columns=['target', 'proba']).to_csv(internal_test_results_path, index=False)\n pd.DataFrame(external_test_proba, columns=['target', 'proba']).to_csv(external_test_results_path, index=False)","def __test_model(self, test, model, expected):\n prediction = model.predict(test)\n message = \"Prediction:\", *prediction, \"| Actual:\", expected\n self.__logger.info(message)","def predict(self): \n return self.model.predict(self.test_x)","def save_predictions(model, dataset, output_dir):\n preds = model.predict(dataset, verbose=1)\n preds = scipy.special.softmax(preds, 1) # Apply softmax\n with tf.io.gfile.GFile(os.path.join(output_dir, 'test_preds.pkl'), 'wb') as f:\n pickle.dump(preds, f)","def predict(self, model, x_test):\n pass","def evaluate(model, test_files):\n print(\"Running predictions.\")\n models = load_model(model)\n predictions = predict(models, test_files)\n\n # # write predictions to file\n # write_predictions(\"evaluate_out.json\",predictions)\n evaluate_individual(predictions, test_files, models)\n evaluate_overall(predictions)","def predict(model, X_testing):\n predictions = model.predict(X_testing)\n\n return predictions","def output_predictions(pipeline):\n ##### Write code here #######\n X_train, y_train_true = load_data_file(TRAIN_FILE)\n X_dev, y_dev_true = load_data_file(DEV_FILE)\n X_test, y_test_true = load_data_file(TEST_FILE)\n\n #train pipeline with dev and train file\n pipeline.fit(X=X_train, y=y_train_true)\n pipeline.fit(X=X_dev, y=y_dev_true)\n\n y_pred_test = pipeline.predict(X=X_test)\n\n df = pd.DataFrame(y_pred_test)\n with open('predictions.tsv', 'w'):\n df.to_csv('predictions.tsv', sep='\\t', index=False, header=False)\n ##### End of your work ######","def predict(self):\n train_vec, test_vec = self.get_tfidf_vectors()\n clf = self.get_classifier()\n\n print '-'*40\n print 'Making predictions ...'\n clf.fit(train_vec, self.train_ans)\n clf_predictions = clf.predict_proba(test_vec)\n\n print 'Storing predictions in', self.pred_file\n pred_out = [\"Id,predictions\"]\n num_pred = range(30)\n for fid, pred in zip(self.test_index, clf_predictions):\n top_rec = sorted(num_pred, key=lambda k: pred[k], reverse=True)[:3]\n pred_out.append(\"%s,%s\" % (fid, ' '.join( [clf.classes_[rec] for rec in top_rec] )))\n with open(self.pred_file, 'w') as f:\n f.write('%s\\n' % ('\\n'.join(pred_out)))","def fit_predict(self):\n self.classifier = self.model\n self.classifier.fit(self.X_sample, self.y_sample)\n self.y_pred = self.classifier.predict(self.X_test)","def predict(x_tst, model):\n\n predictions = model.predict(x_tst)\n return predictions","def evaluate_model(model, X_test, y_test):\n # run prediction with test data\n y_pred = model.predict(X_test)\n\n # print precision, recall and f1-score\n i = 0\n for col in y_test:\n print('Evaluation for \"{}\": \\n {} \\n\\n'.format(col, classification_report(y_test[col], y_pred[:,i])))\n i += 1","def predict_1(trained_model, X_test, y_test):\n # Predict with test data\n start_time = timeit.default_timer()\n test_prediction = trained_model.predict(X_test)\n end_time = timeit.default_timer()\n time = end_time - start_time\n speed = int(X_test.shape[0] / time)\n \n # Get loss and accuracy\n test_loss, test_accuracy = trained_model.evaluate(X_test, y_test)\n \n # Prepare results messages\n msg_time = \"prediction time: {:.3f}s ({}px/s)\\n\".format(time, speed)\n msg_test_loss = \"test_loss: {:.3f}\\n\".format(test_loss)\n msg_test_acc = \"test_accuracy: {:.3f}\\n\\n\".format(test_accuracy)\n \n # Write results messages\n with open(OUTPUT_FILE, 'a') as f:\n f.write(msg_time)\n f.write(msg_test_loss)\n f.write(msg_test_acc)","def predict(self, X_test):\n return self.model.predict(X_test)","def create_prediction(df_test, X_train, y_train, X_test):\n\n # make model: with or without dropout between hidden layers\n model = create_model(X_train)\n # model = create_dropout_model()\n # print(model.summary())\n\n # train model\n training = model.fit(X_train, y_train, epochs=25, batch_size=50,\\\n validation_split=0.2, verbose=0)\n val_acc = np.mean(training.history['val_accuracy'])\n print(\"NN model validation accuracy during training: \", val_acc)\n\n # calculate predictions for test dataset\n df_test['category'] = model.predict(X_test)\n print(df_test.head())\n solution = df_test[['srch_id', 'prop_id', 'category']]\n\n date_time = time.strftime(\"%Y-%m-%d-%H-%M\")\n # solution.to_csv(\"results/unsorted\" + str(date_time) + \".csv\", index=False)\n\n # save prediction in output file\n solution = solution.sort_values(by='category', ascending=False)\n # solution = solution.drop(\"category\", axis=1)\n solution.to_csv(\"results/solutions/nn_NIEUW\" + str(date_time) + \".csv\", index=False)\n\n return val_acc","def model_predict(classifier, X_test:list) -> list:\n y_predict = classifier.predict(X_test)\n return y_predict","def make_prediction(x_train, y_train, x_test, model):\n model.fit(x_train, y_train)\n y_predict = model.predict(x_test)\n return y_predict","def predict(self, test_data):\r\n return self.gs.predict(test_data)","def evaluate(self):\n\n\t\t## We should be evaluating on dev dataset as well, so commenting x_test\n\t\t#self.model_score = self.model.evaluate(self.x_test, self.y_test_oh, batch_size=2048)\n\t\tself.model_score = self.model.evaluate(self.x_dev, self.y_dev_oh, batch_size=2048)\n\t\tprint(\"%s score = %f\\n\" %(self.modelName, self.model_score[1]))\n\n\t\t##Saving atucal vs predicted predictions\n\t\t##np.argmax returns the index where it see's 1 in the row\n\t\t#y_pred = np.argmax(self.model.predict(self.x_test, batch_size=2048), axis=1)\n\t\ty_pred = np.argmax(self.model.predict(self.x_dev, batch_size=2048), axis=1)\n\n\t\t## vstack will stack them in 2 rows, so we use Trasnpose to get them in column stack\n\t\t#output_predict = np.vstack((np.argmax(self.y_test_oh, axis=1), y_pred)).T\n\t\toutput_predict = np.vstack((np.argmax(self.y_dev_oh, axis=1), y_pred)).T\n\t\toutputFile = self.resultDir + \"/outputPredict.csv\" \n\t\tnp.savetxt(outputFile, output_predict, fmt=\"%5.0f\", delimiter=\",\")\n\n\t\t##Error Analysis of the prediction\n\t\terrorAnalysis(outputFile)\n\n\t\treturn self.model_score","def postprocess_model_outputs(self, predictions, expected):\n\n predictions = {k: t.numpy() for k, t in predictions.items()}\n\n return predictions, expected","def predict(self):\n path = self._artifact_repo.artifact_path(self._ARTIFACT_MODEL)\n model = tf.keras.models.load_model(path)\n\n _, _, x_test, y_test = self._load_data()\n x_test = tf.keras.utils.normalize(x_test, axis=1)\n\n preds = model.predict(x_test)\n self._show_cf_matrix(np.array([np.argmax(probas) for probas in preds]), y_test)","def evaluate(self, model, y_test, y_pred, softmax_predictions,\n config_dict, y_paths):\n print('Model metrics: ', model.metrics_names)\n assert(y_test.shape == y_pred.shape)\n\n if len(y_pred.shape) > 2: # If sequential data\n y_pred, paths = get_majority_vote_3d(y_pred, y_paths)\n softmax_predictions, _ = get_majority_vote_3d(softmax_predictions, y_paths)\n y_test, _ = get_majority_vote_3d(y_test, y_paths)\n # self.look_at_classifications(y_test, y_pred, paths, softmax_predictions)\n nb_preds = len(y_pred)\n nb_tests = len(y_test)\n\n if nb_preds != nb_tests:\n print(\"Warning, number of predictions not the same as the length of the y_test vector.\")\n print(\"Y test length: \", nb_tests)\n print(\"Y pred length: \", nb_preds)\n if nb_preds < nb_tests:\n y_test = y_test[:nb_preds]\n else:\n y_pred = y_pred[:nb_tests]\n\n # Print labels and predictions.\n print('y_test.shape: ', y_test.shape)\n print('y_pred.shape: ', y_pred.shape)\n # print('y_test and y_test.shape: ', y_test, y_test.shape)\n # print('y_pred and y_pred.shape: ', y_pred, y_pred.shape)\n\n self.print_and_save_evaluations(y_test, y_pred, softmax_predictions, config_dict)","def predict_4(trained_model, X_test, y_test):\n # Predict with test data\n start_time = timeit.default_timer()\n trained_model.predict(X_test)\n end_time = timeit.default_timer()\n time = end_time - start_time\n speed = int(X_test.shape[0] / time)\n \n # Get loss and accuracy\n test_accuracy = trained_model.score(X_test, y_test)\n \n # Prepare results messages\n msg_time = \"prediction time: {:.3f}s ({}px/s)\\n\".format(time, speed)\n msg_test_acc = \"test_accuracy: {:.3f}\\n\\n\".format(test_accuracy)\n \n # Write results messages\n with open(OUTPUT_FILE, 'a') as f:\n f.write(msg_time)\n f.write(msg_test_acc)","def test_test_model(self):\n\n dataset = ClassificationTestDataset()\n model = ClassificationTestModel(dataset)\n preds = list(model.predict(dataset.examples))\n self.assertEqual(np.argmax(preds[0]['preds']), 2)\n self.assertEqual(np.argmax(preds[1]['preds']), 1)\n self.assertEqual(np.argmax(preds[2]['preds']), 4)\n self.assertEqual(np.argmax(preds[3]['preds']), 3)","def predict(self):\n batch = get_predict_batch(1, num_rec_out=self.num_test_rec)\n self.g_model.test_batch(\n batch, self.global_step, num_rec_out=self.num_test_rec)","def test_print_results(self):\n calculated = super().predict_and_print()\n self.assertEqual(calculated, EXP_PRINT_OUTPUT_BASE.format(.18, .1, 0.186, self.test_model.model.train_time) +\n \"Max tree max_depth: 1\\n\"\n \"Number of n_estimators: 1\\n\"\n \"Impurity method: entropy\\n\")","def test_output(self, test_data):\n for finput in test_data[\"EKFSLAM.EKFSLAM.predict\"]:\n params = tuple(finput.values())\n\n self_1, eta_1, P_1, z_odo_1 = deepcopy(params)\n\n self_2, eta_2, P_2, z_odo_2 = deepcopy(params)\n\n etapred_1, P_1 = EKFSLAM.EKFSLAM.predict(self_1, eta_1, P_1, z_odo_1)\n\n etapred_2, P_2 = solution.EKFSLAM.EKFSLAM.predict(self_2, eta_2, P_2, z_odo_2)\n \n assert compare(etapred_1, etapred_2)\n assert compare(P_1, P_2)\n \n assert compare(self_1, self_2)\n assert compare(eta_1, eta_2)\n assert compare(P_1, P_2)\n assert compare(z_odo_1, z_odo_2)","def predict_2(trained_model, X_test, y_test):\n # Predict with test data\n start_time = timeit.default_timer()\n test_prediction = trained_model.predict(X_test)\n end_time = timeit.default_timer()\n time = end_time - start_time\n speed = int(X_test.shape[0] / time)\n \n # Get loss and accuracy\n test_loss, test_accuracy = trained_model.evaluate(X_test, y_test)\n \n # Prepare results messages\n msg_time = \"prediction time: {:.3f}s ({}px/s)\\n\".format(time, speed)\n msg_test_loss = \"test_loss: {:.3f}\\n\".format(test_loss)\n msg_test_acc = \"test_accuracy: {:.3f}\\n\\n\".format(test_accuracy)\n \n # Write results messages\n with open(OUTPUT_FILE, 'a') as f:\n f.write(msg_time)\n f.write(msg_test_loss)\n f.write(msg_test_acc)","def predict(self, test_dataset: Dataset) -> PredictionOutput:\n test_dataloader = self.get_test_dataloader(test_dataset)\n return self._prediction_loop(test_dataloader, description=\"Prediction\")","def predict(self, Xtt):\n # predict outputs for test dataset\n self.logger.info(\n self.__name__ + ' predicts on {:d} samples.'.format(Xtt.shape[0]))\n pass","def predict(self, test_set, test_labels):\n\n with tf.Session() as self.tf_session:\n self.tf_saver.restore(self.tf_session, self.models_dir + self.model_name)\n return self.accuracy.eval({self.input_data: test_set, self.input_labels: test_labels})","def test_predict(self):\n\n docs = self.docs\n for m in self.models:\n preds = m.predict(docs)\n self.assertTrue(isinstance(preds, turicreate.SArray))\n self.assertEqual(len(preds), len(docs))\n self.assertEqual(preds.dtype, int)\n\n preds = m.predict(docs, output_type=\"probability\")\n self.assertTrue(isinstance(preds, turicreate.SArray))\n self.assertTrue(len(preds) == len(docs))\n s = preds.apply(lambda x: sum(x))\n self.assertTrue((s.apply(lambda x: abs(x - 1)) < 0.000001).all())\n\n # Test predictions when docs have new words\n new_docs = turicreate.SArray([{\"-1,-1\": 3.0, \"0,4\": 5.0, \"0,3\": 2.0}])\n preds = m.predict(new_docs)\n self.assertEqual(len(preds), len(new_docs))\n\n # Test additional burnin. Ideally we could show that things\n # converge as you increase burnin.\n preds_no_burnin = m.predict(docs, output_type=\"probability\", num_burnin=0)\n self.assertEqual(len(preds_no_burnin), len(docs))","def predictSet(self, testData=\"\"):\n rawTestDataDump = self._read_file(testData)\n formattedTestData = [line.split(' ') for line in rawTestDataDump.split('\\n')]\n for test in formattedTestData:\n self._predictions.append(self.predict(test))\n return self._predictions","def predict(model):\n # load test dataset\n test = dict(json.load(open('util_files/test.json')))\n ids = test['ids']\n data = test['data']\n\n df = pd.read_csv('data/document_departments.csv')\n labels = dict(df.values.tolist())\n\n id2cls = dict(json.load(open('util_files/id2cls.json')))\n \n ytrue = []\n ypredicted = []\n \n for i in range(len(data)):\n \n prediction = np.argmax(model.predict_on_batch(np.expand_dims(data[i], axis=0)))\n \n ypredicted.append(id2cls[str(prediction)])\n \n cls = labels[int(ids[i])]\n ytrue.append(cls)\n \n print \"classification report\"\n print classification_report(y_true=ytrue,\n y_pred=ypredicted)\n \n print \"*********************\"\n print \"Accuracy on test set\"\n print accuracy_score(y_true=ytrue,\n y_pred=ypredicted)\n print \"*********************\"","def predict_3(trained_model, X_test, y_test, image_name):\n iterations = trained_model.booster_.current_iteration()\n results = np.zeros((iterations, ))\n for pos in range(iterations):\n \n # Calculate the current iteration (from 1 to iterations)\n iteration = pos + 1\n \n # Predict test set for the current iteration\n start_time = timeit.default_timer()\n test_pred = trained_model.predict(X_test, num_iteration=iteration)\n end_time = timeit.default_timer()\n time = end_time - start_time\n speed = int(X_test.shape[0] / time)\n \n # Number of hits\n test_ok = (test_pred == y_test)\n \n # Percentage of hits\n test_acc = test_ok.sum() / test_ok.size\n \n # Actualize data for plotting results\n results[pos] = test_acc\n \n # Prepare test messages\n classes = trained_model.n_classes_\n msg_estimators = \"\\nn_estimators: {}\\n\".format(iteration)\n msg_trees = \"Number of trees: {}\\n\".format(classes * iteration)\n msg_time = \"prediction time: {:.3f}s ({}px/s)\\n\".format(time, speed)\n msg_test_acc = \"test_acc: {:.3f}\\n\".format(test_acc)\n \n # Write test messages\n with open(OUTPUT_FILE, 'a') as f:\n f.write(msg_estimators)\n f.write(msg_trees)\n f.write(msg_time)\n f.write(msg_test_acc)\n \n # Generate accuracy plot\n plt.figure()\n plt.plot(results, 'b')\n plt.title('Test accuracy')\n plt.xlabel('iterations')\n plt.ylabel('accuracy')\n plt.legend()\n \n # Save test plot\n plot_file = os.path.join(OUTPUT_DIR, \"{}_test_accuracy\".format(image_name))\n plt.savefig(plot_file + \".svg\", bbox_inches='tight', format='svg')","def predict(self, test_data):\n return self.leader.predict(test_data)","def test_predict(self):\n self.regression_single.predict(self.X_test)\n self.assertTrue(len(self.regression_single.y_pred))\n self.regression_boston.predict(self.boston_x_test)\n self.assertTrue(len(self.regression_boston.y_pred))","def model_predict(model,x_test,y_test):\n\n\n y_pred = model.predict(x_test)\n\n predict_class = np.argmax(y_pred, axis=1)\n\n predict_class = predict_class.tolist()\n\n return(y_pred,predict_class)","def make_predictions(model, test_set, val_set):\n \n ## Uses model to predict some amount of images\n predict = model.predict_classes(test_set, batch_size=5, verbose=1)\n \n ## We use the length of these two arrays when we sift through the data to find\n ## the right predictions and wrong predictions\n images = len(test_set)\n\n ## Initialises variables for loop\n correctly_guessed = 0\n\n ## Begins loop to find total correct predictions\n for i in range(images):\n if predict[i] == np.argmax(val_set[i]):\n correctly_guessed += 1\n\n ## Returns amount of predictions were correct\n print('\\nCorrectly guessed = ', correctly_guessed)\n print('Inorrectly guessed = ', (images - correctly_guessed))","def prediction(X_test, clf_object):\n\tY_prediction = clf_object.predict(X_test)\n\tprint(\"Total Predicted Values: \", len(Y_prediction))\n\treturn Y_prediction","def test(self, test_instances, test_labels):\n scores = self.classifier.predict(test_instances)\n # TODO: print report","def output_predictions_test_set(\n self,\n test_set,\n max_key=None,\n min_key=None,\n progressbar=None,\n test_loader_kwargs={},\n ):\n if progressbar is None:\n progressbar = not self.noprogressbar\n\n if not isinstance(test_set, DataLoader):\n test_loader_kwargs[\"ckpt_prefix\"] = None\n test_set = self.make_dataloader(\n test_set, Stage.TEST, **test_loader_kwargs\n )\n\n save_file = os.path.join(\n self.hparams.output_folder, \"predictions.csv\"\n )\n with open(save_file, \"w\", newline=\"\") as csvfile:\n outwriter = csv.writer(csvfile, delimiter=\",\")\n outwriter.writerow([\"id\", \"prediction\", \"true_value\"])\n\n self.on_evaluate_start(max_key=max_key, min_key=min_key) # done before\n self.modules.eval()\n with torch.no_grad():\n for batch in tqdm(\n test_set, dynamic_ncols=True, disable=not progressbar\n ):\n self.step += 1\n\n emo_ids = batch.id\n true_vals = batch.emo_encoded.data.squeeze(dim=1).tolist()\n output = self.compute_forward(batch, stage=Stage.TEST)\n predictions = (\n torch.argmax(output, dim=-1).squeeze(dim=1).tolist()\n )\n\n with open(save_file, \"a\", newline=\"\") as csvfile:\n outwriter = csv.writer(csvfile, delimiter=\",\")\n for emo_id, prediction, true_val in zip(\n emo_ids, predictions, true_vals\n ):\n outwriter.writerow([emo_id, prediction, true_val])\n\n # Debug mode only runs a few batches\n if self.debug and self.step == self.debug_batches:\n break\n self.step = 0","def make_predictions(self):\n if is_classification(self.model):\n if self.ct == None:\n prediction = self.model.predict(self.input_data.to_numpy())\n probabilities = self.model.predict_proba(self.input_data.to_numpy())\n return prediction, probabilities\n elif self.ct != None: \n prediction = self.model.predict(self.data_into_model())\n probabilities = self.model.predict_proba(self.data_into_model())\n return prediction, probabilities\n else:\n raise Exception((\"{} not supported. Please create an issue on Github\").format(self.model))\n \n else:\n if self.ct == None:\n prediction = self.model.predict(self.input_data)\n return prediction\n elif self.ct != None: \n prediction = self.model.predict(self.data_into_model())\n return prediction\n else:\n raise Exception((\"{} not supported. Please create an issue on Github\").format(self.self.model))","def postprocess_model_outputs(self, predictions, expected):\n\n for key, val in predictions.items():\n predictions[key] = val.numpy()\n\n for key, val in expected.items():\n expected[key] = val.numpy()\n\n return predictions, expected","def test_model(model, trainset, testset):\n model.eval()\n \n predictions = []\n actuals = []\n \n for data in testset:\n # data will have batch of features and labels\n X = data[0:4]\n y = data[4:]\n \n pred = np.round(model(X).detach().numpy())\n actual = y.detach().numpy()\n # print(f'pred: {pred}')\n # print(f'actual: {actual}')\n predictions.append(pred)\n actuals.append(actual)\n \n print(accuracy_score(y_true=actuals, y_pred=predictions))\n \n \n # Confusion Matrix\n \n confusion_matrix = np.zeros((3, 3))\n for i,j in zip(predictions, actuals):\n confusion_matrix[i, j] += 1\n print(\"Confusion matrix:\\n\", confusion_matrix)","def test(self):\n y_list = []\n y_hat_list = []\n for ex_dict in ut.TEST_LIST:\n y_list.append(ex_dict[1])\n y_hat_list.append(self.predict(ex_dict[0]))\n acc = ut.compute_accuracy(y_hat_list, y_list)\n return y_hat_list, acc","def get_predictions():\n\n print(\"OK1\");\n print(\"OK2\");\n return;","def evaluate(self):\n predictions = self.model.predict(self.test[0])\n accuracy = accuracy_score(self.test[1], predictions)\n print(\"Accuracy:\", str(accuracy * 100) + \"%\")\n self.plot_results(predictions)","def class_predict_3(trained_model, X_test, y_test, image_name):\n # Predict test set\n try:\n test_pred = trained_model.predict_proba(X_test)\n except:\n test_pred = trained_model.predict(X_test)\n \n if len(test_pred.shape) == 1:\n raise Exception(\"Probabilistic prediction needed.\")\n \n # Transform y_test\n if len(y_test.shape) > 1:\n y_test = np.argmax(y_test, axis=1)\n \n classes = np.unique(y_test)\n results = np.zeros((len(classes), ))\n for class_num in classes:\n \n # Take predictions for current class\n X_pred = test_pred[y_test == class_num, :]\n \n # Number of hits\n pred_ok = (np.argmax(X_pred, axis=1) == class_num).sum()\n \n # Percentage of hits\n pred_acc = pred_ok / X_pred.shape[0]\n \n # Actualize data for plotting results\n results[class_num] = pred_acc\n \n # Write test message\n with open(OUTPUT_FILE, 'a') as f:\n f.write(\"test_acc of class {}: {:.3f}\\n\".format(class_num,\n pred_acc))\n \n # Generate accuracy plot\n plt.figure()\n plt.bar(classes, results, align='center')\n plt.xticks(classes, classes)\n plt.title('Per class test accuracy')\n plt.xlabel('class')\n plt.ylabel('accuracy')\n plt.legend()\n \n # Save test plot\n plot_file = os.path.join(OUTPUT_DIR, \"{}_test_accuracy\".format(image_name))\n plt.savefig(plot_file + \".svg\", bbox_inches='tight', format='svg')","def evaluate_prediction(self):\n\n # ratio_train = self.evaluate_data(self.train_x, self.train_y)\n ratio_test = self.evaluate_data(self.test_x, self.test_y)\n\n print(\"\\n*NAIVE BAYES:\")\n # print(\"Test1: {}%\".format(ratio_dev*100))\n print(\"Test: {} %\".format(ratio_test*100))","def predictions(self, model):\n return get_predictions_from_df(\n model=model, df=self.prediction_df,\n fixed_effects=self.fixed_effects,\n random_effect=self.random_effect,\n spline=self.spline,\n offset=self.offset,\n )","def evaluate_model(model, X_test, Y_test, category_names):\n \n y_preds = model.predict(X_test)\n predictions = pd.DataFrame(data=y_preds, columns=Y_test.columns, index=Y_test.index)\n for col in Y_test.columns:\n print(classification_report(predictions[col],Y_test[col]))","def evaluate_model(model, X_test, Y_test, category_names):\n y_pred = model.predict(X_test)\n print(classification_report(Y_test, y_pred, target_names=Y_test.keys()))","def make_predictions(model, x_test, y_test):\r\n preds = model.predict(x_test)\r\n y_hat = np.argmax(preds, axis=-1)\r\n print(type(y_test))\r\n y_test.columns = [0, 1]\r\n y = y_test.idxmax(axis=1)\r\n print(y_hat.shape)\r\n print(y.shape)\r\n return y_hat, y","def predictions(self):\n return self._pred","def test_predict(self):\n \n\n model ,vec, x_testing=setup_log_reg_classifier(self.training_data, self.training_y, self.testing_data,\"text\", method=\"count\")\n \n model2 ,vec_tfidf, x_testing2=setup_log_reg_classifier(self.training_data, self.training_y, self.testing_data,\"text\", method=\"tfidf\")\n \n \n \"\"\" Test correct data types and corrrect range of predicted values (1,0) for predict with countVectorizer\"\"\" \n \n self.assertIsInstance(predict(model,x_testing),\n np.ndarray)\n \n self.assertTrue(([0,1] ==np.unique(predict(model2,x_testing2))).all())\n\n \n \"\"\" Test correct data types and corrrect range of predicted values (1,0) for predict with tfidfVectorizer\"\"\" \n \n self.assertIsInstance(predict(model,x_testing),\n np.ndarray)\n \n self.assertTrue(([0,1] ==np.unique(predict(model2,x_testing2))).all())","def test_model (self, text_test, labels_test):\n print(classification_report(labels_test, self.classify(text_test)))","def predict(self):\r\n\r\n # reshape test_array since it is a single row of data\r\n user_array = np.asanyarray(self.test_array).reshape(1, -1)\r\n # one hot encode user_array\r\n self.enc.fit(user_array)\r\n user_array = self.enc.transform(user_array)\r\n # create, train and predict the model with the dataset\r\n model = (\"Ridge\", linear_model.Ridge(alpha=0.01, random_state=4))\r\n model[1].fit(self.X_train, self.y_train)\r\n y_pred = model[1].predict(self.X_test)\r\n # predict with user provided chords\r\n y_usr = model[1].predict(user_array)\r\n if y_usr[0] < 0:\r\n y_usr[0] = 0\r\n acc = metrics.r2_score(self.y_test, y_pred)\r\n output = \"I am {}% sure that you like this progression.\".format('%.2f' % (100 * y_usr[0]))\r\n model_info = \"Predicted using a {} model with {} accuracy from {} data samples.\".format(model[0], '%.3f' % acc,\r\n self.data_count())\r\n return output, model_info","def model_pred(model_name):\n with open('model-'+model_name+'.pickle', 'rb') as clf_file:\n clf_test = pickle.load(clf_file)\n\n df_test = pd.read_csv(\"test.csv\")\n df_test = df_test.fillna(method='ffill')\n\n for column in df_test.columns:\n if df_test[column].dtype == type(object):\n le = preprocessing.LabelEncoder()\n df_test[column] = le.fit_transform(df_test[column])\n\n y_test_output = df_test.values\n y_pred_output = clf_test.predict(y_test_output)\n output = []\n for a,b in zip(y_test_output,y_pred_output):\n output.append([int(a[0]),b])\n\n out_df = pd.DataFrame(output,columns = ['id','P'])\n out_df.to_csv('pred-'+model_name+'.csv',index = False)","def _predict(self, testX):\n pass","def train_predict(model_list,X_train, X_test, y_train, y_test):\n P = np.zeros((y_test.shape[0], len(model_list)))\n P = pd.DataFrame(P)\n\n print(\"Fitting models.\")\n cols = list()\n for i, (name, m) in enumerate(models.items()):\n print(\"%s...\" % name, end=\" \", flush=False)\n m.fit(X_train, y_train)\n P.iloc[:, i] = m.predict_proba(X_test)[:, 1]\n cols.append(name)\n print(\"done\")\n\n P.columns = cols\n print(\"Done.\\n\")\n return P","def evaluate_model(model, X_test, Y_test, category_names):\n \n Y_pred = model.predict(X_test)\n \n print(classification_report(Y_test.values, Y_pred, target_names=category_names))","def getPredictions(self):\n\t\tself.bestLabel = self.testingProbs.apply(lambda x: x.argmax(),1)","def eval(self): \n inputs,enc_input_weights, outputs, dec_input_weights = self.get_batch()\n predicted_ids = self.model.step(self.sess, inputs, enc_input_weights) \n print(\"=\"*20)\n for i in range(FLAGS.batch_size):\n print(\"* %dth sample target: %s\" % (i,str(outputs[i,1:]-2)))\n for predict in predicted_ids[i]:\n print(\"prediction: \"+str(predict)) \n print(\"=\"*20)","def predict(self, X_test, **kwargs):\n\n # Normalize inputs\n if self.normalize_input:\n X_, _, _ = zero_mean_unit_var_normalization(X_test, self.X_mean, self.X_std)\n else:\n X_ = X_test\n\n # Sample a number of predictions for each given point\n # Generate mean and variance for each given point from sampled predictions\n\n X_ = torch.Tensor(X_)\n self.model.eval()\n Yt_hat = self.model(X_).data.cpu().numpy()\n\n if self.normalize_output:\n Yt_hat = zero_mean_unit_var_denormalization(Yt_hat, self.y_mean, self.y_std)\n\n logger.debug(f\"Generated final outputs array of shape {Yt_hat.shape}\")\n\n return Yt_hat","def evaluate_model(model, X_test, y_test, category_names):\n y_pred = model.predict(X_test)\n labels = np.unique(y_pred)\n print(labels)\n #print out score for each class and mean scores, including precision, recall, f1 score\n print(classification_report(y_test.values, y_pred, target_names=category_names.values))","def test_04_predict(self):\n today = date.today()\n log_file = os.path.join(LOG_DIR, \"{}-predict-{}-{}.log\".format(LOG_PREFIX, today.year, today.month))\n\n ## update the log\n y_pred = [0]\n y_proba = [0.6,0.4]\n runtime = \"00:00:02\"\n model_version = 0.1\n country = \"india\"\n target_date = '2018-01-05'\n\n update_predict_log(country, y_pred,y_proba,target_date,runtime,\n model_version, test=True, prefix=LOG_PREFIX)\n\n df = pd.read_csv(log_file)\n logged_y_pred = [literal_eval(i) for i in df['y_pred'].copy()][-1]\n self.assertEqual(y_pred,logged_y_pred)","def do_predict(self):\n answer = []\n response = []\n\n for it_predictions in json.loads(request.data.decode('UTF-8')):\n prediction = it_predictions['score']\n for ite_clf in g_list_of_classifier:\n answer.append(ite_clf.predict(prediction))\n if answer.count(True) > answer.count(False):\n response.append({'answer' : True})\n else:\n response.append({'answer' : False})\n return json.dumps(response, indent=4)","def predict(self, testX):\n predicted = self.model.predict(testX)\n return predicted","def evaluate_model(model, X_test, Y_test, category_names):\n \n \n yPredictorTest = model.predict(X_test)\n \n for idx, col in enumerate(Y_test):\n print(col, classification_report(Y_test[col], yPredictorTest[:, idx]))","def predict(self, test_x):\n \n graph = tf.Graph()\n with graph.as_default():\n with tf.compat.v1.Session() as sess:\n tf.compat.v1.saved_model.loader.load(sess, [tf.saved_model.SERVING], \n self.save_file_directory)\n x = graph.get_tensor_by_name('inputs:0')\n outputs = graph.get_tensor_by_name('outputs:0')\n \n test_y_hat = sess.run(outputs, feed_dict={x: test_x})\n \n return test_y_hat","def predictions(self):\n\n return self._predictions","def cv_predict_3(trained_model, X_test, y_test):\n # Predict test set\n start_time = timeit.default_timer()\n test_pred = trained_model.predict(X_test)\n end_time = timeit.default_timer()\n time = end_time - start_time\n speed = int(X_test.shape[0] / time)\n \n # Number of hits\n test_ok = (test_pred == y_test)\n \n # Percentage of hits\n test_acc = test_ok.sum() / test_ok.size\n \n # Prepare test messages\n classes = trained_model.n_classes_\n msg_time = \"prediction time: {:.3f}s ({}px/s)\\n\".format(time,\n speed)\n msg_test_acc = \"test_acc: {:.3f}\\n\".format(test_acc)\n \n # Write test messages\n with open(OUTPUT_FILE, 'a') as f:\n f.write(msg_time)\n f.write(msg_test_acc)","def run_prediction(data, sess, placeholders, scores): \r\n \r\n X, Y = data\r\n source_pl, target_pl, training_pl = placeholders\r\n split_set = int(math.floor(0.9*len(X))) # Value for spliting the set in 90% training / 10% test \r\n \r\n X_batch, Y_batch = batch(X[:split_set:], Y[:split_set:]) # Take a batch of sentences from the training set\r\n feed_dict = {source_pl: X_batch, target_pl: Y_batch, training_pl: False}\r\n prediction = sess.run(scores, feed_dict=feed_dict) \r\n X_batch = np.squeeze(X_batch) \r\n prediction = np.squeeze(prediction)\r\n \r\n source_sentences = treatment.sentences_from_one_hot(X_batch, CORPUS_ENGLISH)\r\n target_sentences = treatment.sentences_from_one_hot(prediction, CORPUS_FRENCH)\r\n\r\n\t# Print the pairs source -> target\r\n for source, target in zip(source_sentences, target_sentences): \r\n print(source + \" --> \" + target)\r\n \r\n print(\"================================================================\")\r\n \r\n X_batch, Y_batch = batch(X[split_set+1:], Y[split_set+1:]) # Take a batch of sentences from the test set\r\n feed_dict = {source_pl: X_batch, target_pl: Y_batch, training_pl: False}\r\n prediction = sess.run(scores, feed_dict=feed_dict) \r\n \r\n X_batch = np.squeeze(X_batch) \r\n prediction = np.squeeze(prediction)\r\n \r\n \r\n source_sentences = treatment.sentences_from_one_hot(X_batch, CORPUS_ENGLISH)\r\n target_sentences = treatment.sentences_from_one_hot(prediction, CORPUS_FRENCH)\r\n\r\n\t# Print the pairs source -> target\r\n for source, target in zip(source_sentences, target_sentences): \r\n print(source + \" --> \" + target)","def test(self):\n\t\treturn classification_report(self.test_labels, self.predict(self.test_data), target_names=self.le.classes_)","def predict(self, x_test, y_test, model_path):\n tf.reset_default_graph()\n with tf.compat.v1.Session() as sess:\n saver = tf.compat.v1.train.import_meta_graph(model_path + \".meta\")\n saver.restore(sess, model_path)\n graph = tf.compat.v1.get_default_graph()\n x = graph.get_operation_by_name(\"x_input\").outputs[0]\n y = tf.compat.v1.get_collection(\"network_architecture\")[0]\n no_samples = x_test.shape[0]\n predictions = []\n n_iteration = no_samples // self.batch_size\n for step in range(n_iteration):\n x_batch, y_batch = get_batch_data(x_test, y_test, iter_step=step, batch_size=self.batch_size)\n preds = sess.run(y, feed_dict={x: x_batch})\n predictions.append(preds)\n return predictions","def test_model(model, models_dir, test_dir, out_dir, test_files=None, test_file=None):\n begin = int(round(time.time() * 1000))\n utils.print_success(\"Testing \" + model)\n pred_dir = out_dir + model\n clf = joblib.load(models_dir + model + \"/\" + model + \".pkl\")\n if test_files is not None:\n pred_dir = pred_dir + \"/\"\n utils.create_dir(pred_dir)\n for index, test_file in enumerate(test_files):\n # Check if isrc is in groundtruths to speed up computation time\n if test_file[:12] in groundtruths:\n test_features = read_test_file(test_dir + test_file)\n try:\n predictions = clf.predict_proba(test_features)\n except AttributeError:\n utils.print_warning(\"predict_proba does not exists for \" + model + \"\\nRegular predict function is used.\")\n predictions = clf.predict(test_features)\n with open(pred_dir + test_file, \"w\") as filep:\n for pred in predictions:\n filep.write(str(pred[0]) + \"\\n\")\n elif test_file is not None:\n pred_dir = pred_dir + \"_\"\n test_features = []\n filename = []\n with open(test_file, \"r\") as filep:\n for index, line in enumerate(filep):\n line = line.split(\",\")\n # print(str(index) + \" \" + line[0])\n test_features.append(line[1:-1])\n filename.append(line[0])\n try:\n predictions = clf.predict_proba(test_features)\n with open(pred_dir + \"predict_proba.csv\", \"a\") as filep2:\n for filen, pred in zip(filename, predictions):\n filep2.write(filen + \",\" + str(pred[0]) + \"\\n\")\n except:\n pass\n predictions = clf.predict(test_features)\n with open(pred_dir + \"predict.csv\", \"a\") as filep2:\n for filen, pred in zip(filename, predictions):\n filep2.write(filen + \",\" + str(pred[0]) + \"\\n\")\n else:\n utils.print_error(\"Error in arg for test_model() function\")\n utils.print_info(model + \" done in \" + str(int(round(time.time() * 1000)) - begin) + \"ms\")","def fit_and_get_test_predictions(self, trace, tuning=True):\n pass","def predict(self):\n self.get_test_data()\n predicted_labels = []\n for row in self.test_data:\n predicted_labels.append(DecisionTree.predict_row(self.classifier, row))\n return predicted_labels","def test_predict(self):\n\t\tMY_TEST_MODEL = \"v1_rm500\"\n\t\tx_test = np.genfromtxt(\"tests/data/ensg_input.txt\",delimiter=\"\\t\")\n\t\tquery_localdirs = cancerscope.get_models.findmodel(os.path.dirname(cancerscope.__file__),MY_TEST_MODEL)\n\t\tif query_localdirs is not None:\n\t\t\tmodel_in = query_localdirs[MY_TEST_MODEL]\n\t\telse:\n\t\t\tmodel_in = cancerscope.get_models.downloadmodel(model_label=MY_TEST_MODEL)\n\t\t\n\t\t\"\"\"Compare results with what you get from 'getmodel()'\"\"\"\n\t\tmodeldir_v1_rm500 = cancerscope.get_models.getmodel(model_label = MY_TEST_MODEL)\n\t\tself.assertEqual(modeldir_v1_rm500[MY_TEST_MODEL][MY_TEST_MODEL], model_in)\n\t\t\n\t\t\"\"\"Test prediction\"\"\"\n\t\tlmodel = cancerscope.scopemodel(model_in)\n\t\tlmodel.fit()\n\t\trandom_sample = np.nan_to_num(x_test[0:17688, 1].reshape(1,17688))\n\t\tpred_testX = lmodel.predict(random_sample)[0][0][0]\n\t\tself.assertEqual(pred_testX, \"ESCA_TS\")\n\t\t\n\t\tallpreds_testX = lmodel.predict(random_sample, get_all_predictions=True, get_numeric=False,get_predictions_dict=False)[0]\n\t\tallpredsNumeric_testX = lmodel.predict(random_sample, get_all_predictions=True, get_numeric=True, get_predictions_dict=False)[0]\n\t\t\n\t\tself.assertEqual(len(allpreds_testX), 66)\n\t\tself.assertEqual(len(allpredsNumeric_testX), 66)\n\t\tself.assertEqual(allpreds_testX[0], \"BRCA_TS\")\n\t\tself.assertTrue(isinstance(allpredsNumeric_testX[0], Number))\n\t\t\n\t\t\"\"\"Test if normalization works and is evaluated to correct floatpoint\"\"\"\n\t\tnormalized_testX = lmodel.get_normalized_input(random_sample)[0]\n\t\tself.assertEqual(normalized_testX[0],0.60640558591378269)\t\n\t\t\n\t\t\"\"\"Test if Jacobian is evaluated correctly\"\"\"\n\t\t#Mar19 keras noncompat#jacobian_test = lmodel.get_jacobian(random_sample)\n\t\t#class0_highestjacobian = np.amax(jacobian_test[0,:])\n\t\t#self.assertEqual(jacobian_test.shape[0], 66) ## Num rows = classes\n\t\t#self.assertEqual(jacobian_test.shape[1], 17688) ## Num columns = genes\n\t\t#self.assertAlmostEqual(class0_highestjacobian, 0.00012377805544766)\n\t\t#END OF #Mar19 keras noncompat#","def write_predictions(all_examples, all_features, all_results, n_best_size,\n max_answer_length, do_lower_case, output_prediction_file,\n output_nbest_file, verbose_logging):\n logger.info(\"Writing predictions to: %s\" % (output_prediction_file))\n logger.info(\"Writing nbest to: %s\" % (output_nbest_file))\n\n example_index_to_features = collections.defaultdict(list)\n for feature in all_features:\n example_index_to_features[feature.example_index].append(feature)\n\n unique_id_to_result = {}\n for result in all_results:\n unique_id_to_result[result.unique_id] = result\n\n _PrelimPrediction = collections.namedtuple( # pylint: disable=invalid-name\n \"PrelimPrediction\",\n [\"feature_index\", \"start_index\", \"end_index\", \"start_logit\", \"end_logit\", \"label_logit\"])\n\n all_predictions = collections.OrderedDict()\n all_nbest_json = collections.OrderedDict()\n for (example_index, example) in enumerate(all_examples):\n features = example_index_to_features[example_index]\n\n prelim_predictions = []\n for (feature_index, feature) in enumerate(features):\n result = unique_id_to_result[feature.unique_id]\n\n start_indexes = _get_best_indexes(result.start_logits, n_best_size)\n end_indexes = _get_best_indexes(result.end_logits, n_best_size)\n for start_index in start_indexes:\n for end_index in end_indexes:\n # We could hypothetically create invalid predictions, e.g., predict\n # that the start of the span is in the question. We throw out all\n # invalid predictions.\n if start_index >= len(feature.tokens):\n continue\n if end_index >= len(feature.tokens):\n continue\n if start_index not in feature.token_to_orig_map:\n continue\n if end_index not in feature.token_to_orig_map:\n continue\n if not feature.token_is_max_context.get(start_index, False):\n continue\n if end_index < start_index:\n continue\n length = end_index - start_index + 1\n if length > max_answer_length:\n continue\n prelim_predictions.append(\n _PrelimPrediction(\n feature_index=feature_index,\n start_index=start_index,\n end_index=end_index,\n start_logit=result.start_logits[start_index],\n end_logit=result.end_logits[end_index],\n label_logit=result.label_logits))\n\n prelim_predictions = sorted(\n prelim_predictions,\n key=lambda x: (x.start_logit + x.end_logit),\n reverse=True)\n\n _NbestPrediction = collections.namedtuple( # pylint: disable=invalid-name\n \"NbestPrediction\", [\"text\", \"start_logit\", \"end_logit\", \"label_logit\"])\n\n seen_predictions = {}\n nbest = []\n for pred in prelim_predictions:\n if len(nbest) >= n_best_size:\n break\n feature = features[pred.feature_index]\n\n tok_tokens = feature.tokens[pred.start_index:(pred.end_index + 1)]\n orig_doc_start = feature.token_to_orig_map[pred.start_index]\n orig_doc_end = feature.token_to_orig_map[pred.end_index]\n orig_tokens = example.doc_tokens[orig_doc_start:(orig_doc_end + 1)]\n tok_text = \" \".join(tok_tokens)\n\n # De-tokenize WordPieces that have been split off.\n tok_text = tok_text.replace(\" ##\", \"\")\n tok_text = tok_text.replace(\"##\", \"\")\n\n # Clean whitespace\n tok_text = tok_text.strip()\n tok_text = \" \".join(tok_text.split())\n orig_text = \" \".join(orig_tokens)\n\n final_text = get_final_text(tok_text, orig_text, do_lower_case, verbose_logging)\n if final_text in seen_predictions:\n continue\n\n seen_predictions[final_text] = True\n nbest.append(\n _NbestPrediction(\n text=final_text,\n start_logit=pred.start_logit,\n end_logit=pred.end_logit,\n label_logit=pred.label_logit))\n\n # In very rare edge cases we could have no valid predictions. So we\n # just create a nonce prediction in this case to avoid failure.\n if not nbest:\n nbest.append(\n _NbestPrediction(text=\"empty\", start_logit=0.0, end_logit=0.0, label_logit=0.0))\n\n assert len(nbest) >= 1\n\n total_scores = []\n for entry in nbest:\n total_scores.append(entry.start_logit + entry.end_logit)\n\n probs = _compute_softmax(total_scores)\n\n nbest_json = []\n for (i, entry) in enumerate(nbest):\n output = collections.OrderedDict()\n output[\"text\"] = entry.text\n output[\"probability\"] = probs[i]\n output[\"start_logit\"] = entry.start_logit\n output[\"end_logit\"] = entry.end_logit\n output[\"label_logit\"] = entry.label_logit\n nbest_json.append(output)\n\n assert len(nbest_json) >= 1\n\n if nbest_json[0][\"label_logit\"] and (example.qas_id not in all_predictions.keys() or all_nbest_json[example.qas_id][0][\"probability\"] < nbest_json[0][\"probability\"]):\n all_predictions[example.qas_id] = nbest_json[0][\"text\"]\n all_nbest_json[example.qas_id] = nbest_json\n\n with open(output_prediction_file, \"w\") as writer:\n writer.write(json.dumps(all_predictions, indent=4) + \"\\n\")\n\n with open(output_nbest_file, \"w\") as writer:\n writer.write(json.dumps(all_nbest_json, indent=4) + \"\\n\")","def write_predictions(self):\n unique_id_to_result = {}\n for result in self._all_results:\n unique_id_to_result[result.unique_id] = result\n\n _PrelimPrediction = collections.namedtuple( # pylint: disable=invalid-name\n \"PrelimPrediction\",\n [\"feature_index\", \"start_index\", \"end_index\", \"start_logit\",\n \"end_logit\"])\n\n all_predictions = collections.OrderedDict()\n all_nbest_json = collections.OrderedDict()\n scores_diff_json = collections.OrderedDict()\n\n for example in self._eval_examples:\n example_id = example.qas_id if (\"squad\" in self._name or \"cmrc2018\" in self._name or \"drcd\" in self._name) else example.qid\n features = self._task.featurize(example, False, for_eval=True)\n\n prelim_predictions = []\n # keep track of the minimum score of null start+end of position 0\n score_null = 1000000 # large and positive\n for (feature_index, feature) in enumerate(features):\n result = unique_id_to_result[feature[self._name + \"_eid\"]]\n if self._config.joint_prediction:\n start_indexes = result.start_top_index\n end_indexes = result.end_top_index\n else:\n start_indexes = _get_best_indexes(result.start_logits,\n self._config.n_best_size)\n end_indexes = _get_best_indexes(result.end_logits,\n self._config.n_best_size)\n # if we could have irrelevant answers, get the min score of irrelevant\n if self._v2:\n if self._config.answerable_classifier:\n feature_null_score = result.answerable_logit\n else:\n feature_null_score = result.start_logits[0] + result.end_logits[0]\n if feature_null_score < score_null:\n score_null = feature_null_score\n for i, start_index in enumerate(start_indexes):\n for j, end_index in enumerate(\n end_indexes[i] if self._config.joint_prediction else end_indexes):\n # We could hypothetically create invalid predictions, e.g., predict\n # that the start of the span is in the question. We throw out all\n # invalid predictions.\n if start_index >= len(feature[self._name + \"_tokens\"]):\n continue\n if end_index >= len(feature[self._name + \"_tokens\"]):\n continue\n if start_index == 0:\n continue\n if start_index not in feature[self._name + \"_token_to_orig_map\"]:\n continue\n if end_index not in feature[self._name + \"_token_to_orig_map\"]:\n continue\n if not feature[self._name + \"_token_is_max_context\"].get(\n start_index, False):\n continue\n if end_index < start_index:\n continue\n length = end_index - start_index + 1\n if length > self._config.max_answer_length:\n continue\n start_logit = (result.start_top_log_probs[i] if\n self._config.joint_prediction else\n result.start_logits[start_index])\n end_logit = (result.end_top_log_probs[i, j] if\n self._config.joint_prediction else\n result.end_logits[end_index])\n prelim_predictions.append(\n _PrelimPrediction(\n feature_index=feature_index,\n start_index=start_index,\n end_index=end_index,\n start_logit=start_logit,\n end_logit=end_logit))\n\n if self._v2:\n if len(prelim_predictions) == 0 and self._config.debug:\n tokid = sorted(feature[self._name + \"_token_to_orig_map\"].keys())[0]\n prelim_predictions.append(_PrelimPrediction(\n feature_index=0,\n start_index=tokid,\n end_index=tokid + 1,\n start_logit=1.0,\n end_logit=1.0))\n prelim_predictions = sorted(\n prelim_predictions,\n key=lambda x: (x.start_logit + x.end_logit),\n reverse=True)\n\n _NbestPrediction = collections.namedtuple( # pylint: disable=invalid-name\n \"NbestPrediction\", [\"text\", \"start_logit\", \"end_logit\"])\n\n seen_predictions = {}\n nbest = []\n for pred in prelim_predictions:\n if len(nbest) >= self._config.n_best_size:\n break\n feature = features[pred.feature_index]\n tok_tokens = feature[self._name + \"_tokens\"][\n pred.start_index:(pred.end_index + 1)]\n orig_doc_start = feature[\n self._name + \"_token_to_orig_map\"][pred.start_index]\n orig_doc_end = feature[\n self._name + \"_token_to_orig_map\"][pred.end_index]\n orig_tokens = example.doc_tokens[orig_doc_start:(orig_doc_end + 1)]\n tok_text = \" \".join(tok_tokens)\n\n # De-tokenize WordPieces that have been split off.\n tok_text = tok_text.replace(\" ##\", \"\")\n tok_text = tok_text.replace(\"##\", \"\")\n\n # Clean whitespace\n tok_text = tok_text.strip()\n tok_text = \" \".join(tok_text.split())\n orig_text = \" \".join(orig_tokens)\n\n final_text = get_final_text(self._config, tok_text, orig_text)\n if final_text in seen_predictions:\n continue\n\n seen_predictions[final_text] = True\n\n nbest.append(\n _NbestPrediction(\n text=final_text,\n start_logit=pred.start_logit,\n end_logit=pred.end_logit))\n\n # In very rare edge cases we could have no valid predictions. So we\n # just create a nonce prediction in this case to avoid failure.\n if not nbest:\n nbest.append(\n _NbestPrediction(text=\"empty\", start_logit=0.0, end_logit=0.0))\n\n assert len(nbest) >= 1\n\n total_scores = []\n best_non_null_entry = None\n for entry in nbest:\n total_scores.append(entry.start_logit + entry.end_logit)\n if not best_non_null_entry:\n if entry.text:\n best_non_null_entry = entry\n\n probs = _compute_softmax(total_scores)\n\n nbest_json = []\n for (i, entry) in enumerate(nbest):\n output = collections.OrderedDict()\n output[\"text\"] = entry.text\n output[\"probability\"] = probs[i]\n output[\"start_logit\"] = entry.start_logit\n output[\"end_logit\"] = entry.end_logit\n nbest_json.append(dict(output))\n\n assert len(nbest_json) >= 1\n\n if not self._v2:\n all_predictions[example_id] = nbest_json[0][\"text\"]\n else:\n # predict \"\" iff the null score - the score of best non-null > threshold\n if self._config.answerable_classifier:\n score_diff = score_null\n else:\n score_diff = score_null - best_non_null_entry.start_logit - (\n best_non_null_entry.end_logit)\n scores_diff_json[example_id] = score_diff\n all_predictions[example_id] = best_non_null_entry.text\n\n all_nbest_json[example_id] = nbest_json\n\n utils.write_json(dict(all_predictions),\n self._config.qa_preds_file(self._name+\"_\"+self._split))\n if self._v2:\n utils.write_json({\n k: float(v) for k, v in six.iteritems(scores_diff_json)},\n self._config.qa_na_file(self._name+\"_\"+self._split))","def predict(self, test_data):\n random.seed(self.seed)\n preds = [{\"id\": instance['id'], \"prediction\": random.choice([0, 1])} for instance in test_data]\n return preds","def test_prediction(model, raw_data):\n data = PredictionData(**raw_data)\n formated_data = {}\n for key, value in data.dict().items():\n formated_data[key] = [value]\n df = pd.DataFrame(formated_data)\n res = model.predict(df)[0]\n assert type(res) == np.float64","def evaluate_model(model, X_test, Y_test, category_names): \n \n Y_pred = model.predict(X_test)\n print(classification_report(Y_test, Y_pred))\n display_results(Y_test, Y_pred)","def predict_test(model, test_dataloader):\r\n # Put the model into the evaluation mode. The dropout layers are disabled during\r\n # the test time.\r\n model.eval()\r\n\r\n all_logits = []\r\n\r\n # For each batch in our test set...\r\n for batch in test_dataloader:\r\n # Load batch to GPU\r\n b_input_ids, b_attn_mask = tuple(t.to(device) for t in batch)[:2]\r\n\r\n # Compute logits\r\n with torch.no_grad():\r\n logits = model(b_input_ids, b_attn_mask)\r\n all_logits.append(logits)\r\n \r\n # Concatenate logits from each batch\r\n all_logits = torch.cat(all_logits, dim=0)\r\n\r\n # Apply softmax to calculate probabilities\r\n probs = F.softmax(all_logits, dim=1).cpu().numpy()\r\n\r\n return probs","def evaluate_test(model, history, class_labels, train_X, test_X, train_y, test_y):\n train_loss, train_acc = model.evaluate(train_X, train_y, verbose=0)\n test_loss, test_acc = model.evaluate(test_X, test_y, verbose=0)\n print('Accuracy \\n Train: %.3f, Test: %.3f' % (train_acc, test_acc))\n print('Loss \\n Train: %.3f, Test: %.3f \\n' % (train_loss, test_loss))\n # plot loss during training\n plt.subplots_adjust(hspace = .5, wspace = 0.5)\n plt.subplot(211)\n plt.title('Loss', weight='bold')\n plt.plot(history.history['loss'], label='train')\n plt.plot(history.history['val_loss'], label='val')\n plt.legend()\n # plot accuracy during training\n plt.subplot(212)\n plt.title('Accuracy', weight='bold')\n plt.plot(history.history['acc'], label='train')\n plt.plot(history.history['val_acc'], label='val')\n plt.legend()\n plt.show()\n print('\\n')\n # predict probabilities for test set\n yhat_probs = model.predict(test_X, verbose=0)\n # predict classes for test set\n yhat_classes = model.predict_classes(test_X, verbose=0)\n # reduce to 1d array\n yhat_probs = yhat_probs[:, 0]\n yhat_classes = yhat_classes[:, 0]\n # calculate metrics\n report = metrics.classification_report(test_y, yhat_classes, target_names=class_labels)\n confusion_matrix = metrics.confusion_matrix(test_y, yhat_classes)\n plot_confusion_matrix(confusion_matrix, class_labels)\n print('\\n')\n return report","def make_ensemble_prediction(trn_features, models, test_df):\n test_id: pd.Series = test_df.iloc[:, 0]\n test_features: pd.DataFrame = test_df.iloc[:, 1:]\n\n test_features = pd.concat([trn_features, test_features])\n\n clean_test_features, test_log = clean_features(test_features)\n clean_test_features = clean_test_features.iloc[trn_features.shape[0]:, :]\n\n predictions = np.empty([0, trn_features.shape[0] - 1])\n for model in models:\n prediction = np.array([model.predict(clean_test_features)])\n predictions = np.vstack([predictions, prediction])\n\n prediction = np.mean(predictions, axis=0)\n\n # print(predictions, prediction)\n result_df = pd.DataFrame(columns=[\"Id\", \"SalePrice\"])\n\n for i in range(test_id.shape[0]):\n result_df = result_df.append(pd.DataFrame([[int(test_id.iloc[i]), prediction[i]]], columns=[\"Id\", \"SalePrice\"]))\n\n print(result_df)\n result_df.to_csv('../data/result.csv', index=False)","def evaluate_model(model, X_test, Y_test, category_names):\n y_pred_grid = model.predict(X_test)\n print(\n classification_report(Y_test.values, y_pred_grid, target_names=category_names)\n )","def evaluate_model(self, model, testX_norm, testY_bin, batch_size, label_names, n_epochs, output_filename):\n # Predictions\n predictions = model.predict(testX_norm, batch_size=batch_size)\n \n # Classification report\n classification = classification_report(testY_bin.argmax(axis=1),\n predictions.argmax(axis=1),\n target_names=label_names)\n \n # Print classification report\n print(classification)\n \n # Save classification report\n output_path = os.path.join(\"..\", \"output\", output_filename)\n with open(output_path, 'w', encoding='utf-8') as f:\n f.write(f\"Below are the classification metrics for the trained model. Batch size = {batch_size} and number of epochs = {n_epochs}.\\n\\n {classification}\")","def save_predicted_results(predicted_results):\n # Save the model\n with open(\"predicted_results\", \"wb\") as predicted_results_file:\n pickle.dump(predicted_results, predicted_results_file)","def evaluate_model(model, X_test_input, y_test_input):\r\n pred_class = [model.classes_[i] for i in model.predict_proba(X_test_input).argmax(axis=-1)]\r\n pred_accuracy = np.sum(np.array(y_test_input)==np.array(pred_class))/len(pred_class)\r\n return pred_class, pred_accuracy","def evaluate_model(model, X_test, Y_test, category_names):\n y_pred = model.predict(X_test)\n print(classification_report(Y_test, y_pred, target_names=category_names))\n pass","def get_predictions(self, model, inputs=None):\n if inputs is None:\n inputs = self.inputs\n\n refl_id = BaseModel.get_refl_id(inputs)\n iobs = BaseModel.get_intensities(inputs).flatten()\n sig_iobs = BaseModel.get_uncertainties(inputs).flatten()\n asu_id,H = self.asu_collection.to_asu_id_and_miller_index(refl_id)\n #ipred = model(inputs)\n ipred,sigipred = model.prediction_mean_stddev(inputs)\n\n h,k,l = H.T\n results = ()\n for i,asu in enumerate(self.asu_collection):\n idx = asu_id == i\n idx = idx.flatten()\n output = rs.DataSet({\n 'H' : h[idx],\n 'K' : k[idx],\n 'L' : l[idx],\n 'Iobs' : iobs[idx],\n 'SigIobs' : sig_iobs[idx],\n 'Ipred' : ipred[idx],\n 'SigIpred' : sigipred[idx],\n }, \n cell=asu.cell, \n spacegroup=asu.spacegroup,\n merged=False,\n ).infer_mtz_dtypes().set_index(['H', 'K', 'L'])\n results += (output, )\n return results","def show_predictions(model, test_set, val_set, image_guess, img_res, data='OSNR', GRAY=True):\n \n ## Uses model to predict some amount of images\n predict = model.predict_classes(test_set, batch_size=5, verbose=1)\n \n ## Initialises variables for loop\n correctly_guessed = 0\n\n ## Defines figure dimensions\n fig = plt.figure(figsize=(20,30))\n\n ## Begins loop to find correct predictions and relay results to user\n ## Searches through the prediction array and compares it to the actual array.\n ## Displays image with the prediction and answer on the title\n for i in range(image_guess):\n correct = False\n actual = np.argmax(val_set[i])\n\n if predict[i] == actual:\n correctly_guessed += 1\n correct = True\n\n plt.subplot(6,3,i+1)\n fig.subplots_adjust(left=0.01,\n right=0.7,\n bottom=0.1,\n top=1.2,\n wspace=0.5,\n hspace=0.2\n )\n if GRAY == False:\n plt.imshow(test_set[i].reshape(img_res,img_res,3))\n else:\n plt.imshow(test_set[i].reshape(img_res,img_res), cmap='gray')\n\n if correct == True:\n if data == 'disp':\n plt.title('Correct! \\nPrediction = {}ps/nm Truth = {}ps/nm'\n .format((10+10*predict[i]), (10+10*(actual))), fontsize=15)\n \n if data == 'disp-short':\n plt.title('Correct! \\nPrediction = {} ~ {}ps/nm Truth = {} ~{}ps/nm'\n .format(100*(predict[i]), (100+100*predict[i]), 100*(actual), (100+100*(actual)), fontsize=15))\n \n if data == 'OSNR':\n plt.title('Correct! \\nPrediction = {}dB Truth = {}dB'\n .format((12+0.5*predict[i]), (12+0.5*(actual))), fontsize=15)\n \n \n else:\n if data == 'disp':\n plt.title('\\nPrediction = {}ps/nm Truth = {}ps/nm'\n .format((10+10*predict[i]), (10+10*(actual))), fontsize=15)\n \n if data == 'disp-short':\n plt.title('\\nPrediction = {} ~ {}ps/nm Truth = {} ~{}ps/nm'\n .format(100*(predict[i]), (100+100*predict[i]), 100*(actual), (100+100*(actual)), fontsize=15))\n \n if data == 'OSNR':\n plt.title('\\nPrediction = {}dB Truth = {}dB'\n .format((12+0.5*predict[i]), (12+0.5*(actual))), fontsize=15)\n\n ## Returns amount of predictions that were correct\n print('Correctly guessed = ', correctly_guessed)\n print('Inorrectly guessed = ', (image_guess-correctly_guessed))","def show_score(clf, X_test, y_test):\n y_pred = predict(clf, X_test)\n print metrics.classification_report(y_test.astype(np.int), y_pred)","def evaluate_model(model, X_train, y_train, X_test, y_test):\n model = model\n model.fit(X_train, y_train)\n\n y_pred = model.predict(X_test)\n\n report = classificationreport(y_test, y_pred, target_names= [\"0\", \"1\"], output_dict=True)\n\n return report"],"string":"[\n \"def test():\\n # load dataset and model\\n X, observed_y = load_data('../data/dev.txt')\\n\\n model = pickle.load(open('test.model', 'rb'))\\n model.traverse()\\n\\n # predict labels for dataset\\n preds = model.predict(X)\\n\\n # print(preds)\\n # output model predictions\\n np.savetxt('test.predictions', preds, fmt='%s')\",\n \"def test(self) -> None:\\n\\n self._predictions = self._lr.predict(self._X_test)\",\n \"def predict(self):\\n self.predicted_test_summary = []\\n for step in xrange(0, self.test_size // self.test_batch_size):\\n print 'Predicting Batch No.:', step\\n offset = (step * self.test_batch_size) % self.test_size\\n batch_data_fwd = self.X_tst_fwd[offset:(offset + self.test_batch_size), :].T\\n batch_data_bwd = self.X_tst_bwd[offset:(offset + self.test_batch_size), :].T\\n summary_test_out = self._predict_batch(batch_data_fwd, batch_data_bwd)\\n self.predicted_test_summary.extend(summary_test_out)\\n\\n print 'Prediction Complete. Moving Forward..'\\n\\n # test answers\\n self.test_review = self.X_tst_fwd\\n self.predicted_test_summary = self.predicted_test_summary\\n self.true_summary = self.Y_tst\",\n \"def get_predictions(fitted_model_filename):\\n click.echo(\\\"Mode: predicting probabilities.\\\\n\\\")\\n defaults = get_defaults()\\n\\n fitted_model_filename = add_extension(fitted_model_filename)\\n fitted_model_path = os.path.join(defaults.OUTPUT.FITTED_MODELS_PATH, fitted_model_filename)\\n new_options = [\\\"OUTPUT.FITTED_MODEL_PATH\\\", fitted_model_path]\\n\\n # boot_data = bootstrap(new_options, mode=\\\"internal_test\\\")\\n # model = boot_data['model']\\n #\\n # X_test_int, y_test_int = boot_data['data']\\n # internal_test_proba = model.predict_proba(X_test_int)\\n # internal_test_proba = np.c_[y_test_int, internal_test_proba[:, 1]]\\n\\n boot_data = bootstrap(new_options, mode=\\\"external_test\\\")\\n model = boot_data['model']\\n X_test_ext, y_test_ext = boot_data['data']\\n\\n # fit scaler on train data and transform test data\\n scaler = StandardScaler()\\n X_train, y_train = load_data(defaults, which='train')\\n\\n numeric_cols = X_train.select_dtypes(include=np.float64).columns.tolist()\\n scaler.fit(X_train[numeric_cols])\\n X_test_ext.loc[:, numeric_cols] = scaler.transform(X_test_ext[numeric_cols])\\n\\n external_test_proba = model.predict_proba(X_test_ext)\\n external_test_proba = np.c_[y_test_ext, external_test_proba[:, 1]]\\n\\n # internal_test_results_path = os.path.join(defaults.OUTPUT.PREDS_PATH, \\\"internal_test_preds.csv\\\")\\n external_test_results_path = os.path.join(defaults.OUTPUT.PREDS_PATH,\\n f\\\"external_test_preds_{fitted_model_filename.replace('.pkl', '')}.csv\\\")\\n # pd.DataFrame(internal_test_proba, columns=['target', 'proba']).to_csv(internal_test_results_path, index=False)\\n pd.DataFrame(external_test_proba, columns=['target', 'proba']).to_csv(external_test_results_path, index=False)\",\n \"def __test_model(self, test, model, expected):\\n prediction = model.predict(test)\\n message = \\\"Prediction:\\\", *prediction, \\\"| Actual:\\\", expected\\n self.__logger.info(message)\",\n \"def predict(self): \\n return self.model.predict(self.test_x)\",\n \"def save_predictions(model, dataset, output_dir):\\n preds = model.predict(dataset, verbose=1)\\n preds = scipy.special.softmax(preds, 1) # Apply softmax\\n with tf.io.gfile.GFile(os.path.join(output_dir, 'test_preds.pkl'), 'wb') as f:\\n pickle.dump(preds, f)\",\n \"def predict(self, model, x_test):\\n pass\",\n \"def evaluate(model, test_files):\\n print(\\\"Running predictions.\\\")\\n models = load_model(model)\\n predictions = predict(models, test_files)\\n\\n # # write predictions to file\\n # write_predictions(\\\"evaluate_out.json\\\",predictions)\\n evaluate_individual(predictions, test_files, models)\\n evaluate_overall(predictions)\",\n \"def predict(model, X_testing):\\n predictions = model.predict(X_testing)\\n\\n return predictions\",\n \"def output_predictions(pipeline):\\n ##### Write code here #######\\n X_train, y_train_true = load_data_file(TRAIN_FILE)\\n X_dev, y_dev_true = load_data_file(DEV_FILE)\\n X_test, y_test_true = load_data_file(TEST_FILE)\\n\\n #train pipeline with dev and train file\\n pipeline.fit(X=X_train, y=y_train_true)\\n pipeline.fit(X=X_dev, y=y_dev_true)\\n\\n y_pred_test = pipeline.predict(X=X_test)\\n\\n df = pd.DataFrame(y_pred_test)\\n with open('predictions.tsv', 'w'):\\n df.to_csv('predictions.tsv', sep='\\\\t', index=False, header=False)\\n ##### End of your work ######\",\n \"def predict(self):\\n train_vec, test_vec = self.get_tfidf_vectors()\\n clf = self.get_classifier()\\n\\n print '-'*40\\n print 'Making predictions ...'\\n clf.fit(train_vec, self.train_ans)\\n clf_predictions = clf.predict_proba(test_vec)\\n\\n print 'Storing predictions in', self.pred_file\\n pred_out = [\\\"Id,predictions\\\"]\\n num_pred = range(30)\\n for fid, pred in zip(self.test_index, clf_predictions):\\n top_rec = sorted(num_pred, key=lambda k: pred[k], reverse=True)[:3]\\n pred_out.append(\\\"%s,%s\\\" % (fid, ' '.join( [clf.classes_[rec] for rec in top_rec] )))\\n with open(self.pred_file, 'w') as f:\\n f.write('%s\\\\n' % ('\\\\n'.join(pred_out)))\",\n \"def fit_predict(self):\\n self.classifier = self.model\\n self.classifier.fit(self.X_sample, self.y_sample)\\n self.y_pred = self.classifier.predict(self.X_test)\",\n \"def predict(x_tst, model):\\n\\n predictions = model.predict(x_tst)\\n return predictions\",\n \"def evaluate_model(model, X_test, y_test):\\n # run prediction with test data\\n y_pred = model.predict(X_test)\\n\\n # print precision, recall and f1-score\\n i = 0\\n for col in y_test:\\n print('Evaluation for \\\"{}\\\": \\\\n {} \\\\n\\\\n'.format(col, classification_report(y_test[col], y_pred[:,i])))\\n i += 1\",\n \"def predict_1(trained_model, X_test, y_test):\\n # Predict with test data\\n start_time = timeit.default_timer()\\n test_prediction = trained_model.predict(X_test)\\n end_time = timeit.default_timer()\\n time = end_time - start_time\\n speed = int(X_test.shape[0] / time)\\n \\n # Get loss and accuracy\\n test_loss, test_accuracy = trained_model.evaluate(X_test, y_test)\\n \\n # Prepare results messages\\n msg_time = \\\"prediction time: {:.3f}s ({}px/s)\\\\n\\\".format(time, speed)\\n msg_test_loss = \\\"test_loss: {:.3f}\\\\n\\\".format(test_loss)\\n msg_test_acc = \\\"test_accuracy: {:.3f}\\\\n\\\\n\\\".format(test_accuracy)\\n \\n # Write results messages\\n with open(OUTPUT_FILE, 'a') as f:\\n f.write(msg_time)\\n f.write(msg_test_loss)\\n f.write(msg_test_acc)\",\n \"def predict(self, X_test):\\n return self.model.predict(X_test)\",\n \"def create_prediction(df_test, X_train, y_train, X_test):\\n\\n # make model: with or without dropout between hidden layers\\n model = create_model(X_train)\\n # model = create_dropout_model()\\n # print(model.summary())\\n\\n # train model\\n training = model.fit(X_train, y_train, epochs=25, batch_size=50,\\\\\\n validation_split=0.2, verbose=0)\\n val_acc = np.mean(training.history['val_accuracy'])\\n print(\\\"NN model validation accuracy during training: \\\", val_acc)\\n\\n # calculate predictions for test dataset\\n df_test['category'] = model.predict(X_test)\\n print(df_test.head())\\n solution = df_test[['srch_id', 'prop_id', 'category']]\\n\\n date_time = time.strftime(\\\"%Y-%m-%d-%H-%M\\\")\\n # solution.to_csv(\\\"results/unsorted\\\" + str(date_time) + \\\".csv\\\", index=False)\\n\\n # save prediction in output file\\n solution = solution.sort_values(by='category', ascending=False)\\n # solution = solution.drop(\\\"category\\\", axis=1)\\n solution.to_csv(\\\"results/solutions/nn_NIEUW\\\" + str(date_time) + \\\".csv\\\", index=False)\\n\\n return val_acc\",\n \"def model_predict(classifier, X_test:list) -> list:\\n y_predict = classifier.predict(X_test)\\n return y_predict\",\n \"def make_prediction(x_train, y_train, x_test, model):\\n model.fit(x_train, y_train)\\n y_predict = model.predict(x_test)\\n return y_predict\",\n \"def predict(self, test_data):\\r\\n return self.gs.predict(test_data)\",\n \"def evaluate(self):\\n\\n\\t\\t## We should be evaluating on dev dataset as well, so commenting x_test\\n\\t\\t#self.model_score = self.model.evaluate(self.x_test, self.y_test_oh, batch_size=2048)\\n\\t\\tself.model_score = self.model.evaluate(self.x_dev, self.y_dev_oh, batch_size=2048)\\n\\t\\tprint(\\\"%s score = %f\\\\n\\\" %(self.modelName, self.model_score[1]))\\n\\n\\t\\t##Saving atucal vs predicted predictions\\n\\t\\t##np.argmax returns the index where it see's 1 in the row\\n\\t\\t#y_pred = np.argmax(self.model.predict(self.x_test, batch_size=2048), axis=1)\\n\\t\\ty_pred = np.argmax(self.model.predict(self.x_dev, batch_size=2048), axis=1)\\n\\n\\t\\t## vstack will stack them in 2 rows, so we use Trasnpose to get them in column stack\\n\\t\\t#output_predict = np.vstack((np.argmax(self.y_test_oh, axis=1), y_pred)).T\\n\\t\\toutput_predict = np.vstack((np.argmax(self.y_dev_oh, axis=1), y_pred)).T\\n\\t\\toutputFile = self.resultDir + \\\"/outputPredict.csv\\\" \\n\\t\\tnp.savetxt(outputFile, output_predict, fmt=\\\"%5.0f\\\", delimiter=\\\",\\\")\\n\\n\\t\\t##Error Analysis of the prediction\\n\\t\\terrorAnalysis(outputFile)\\n\\n\\t\\treturn self.model_score\",\n \"def postprocess_model_outputs(self, predictions, expected):\\n\\n predictions = {k: t.numpy() for k, t in predictions.items()}\\n\\n return predictions, expected\",\n \"def predict(self):\\n path = self._artifact_repo.artifact_path(self._ARTIFACT_MODEL)\\n model = tf.keras.models.load_model(path)\\n\\n _, _, x_test, y_test = self._load_data()\\n x_test = tf.keras.utils.normalize(x_test, axis=1)\\n\\n preds = model.predict(x_test)\\n self._show_cf_matrix(np.array([np.argmax(probas) for probas in preds]), y_test)\",\n \"def evaluate(self, model, y_test, y_pred, softmax_predictions,\\n config_dict, y_paths):\\n print('Model metrics: ', model.metrics_names)\\n assert(y_test.shape == y_pred.shape)\\n\\n if len(y_pred.shape) > 2: # If sequential data\\n y_pred, paths = get_majority_vote_3d(y_pred, y_paths)\\n softmax_predictions, _ = get_majority_vote_3d(softmax_predictions, y_paths)\\n y_test, _ = get_majority_vote_3d(y_test, y_paths)\\n # self.look_at_classifications(y_test, y_pred, paths, softmax_predictions)\\n nb_preds = len(y_pred)\\n nb_tests = len(y_test)\\n\\n if nb_preds != nb_tests:\\n print(\\\"Warning, number of predictions not the same as the length of the y_test vector.\\\")\\n print(\\\"Y test length: \\\", nb_tests)\\n print(\\\"Y pred length: \\\", nb_preds)\\n if nb_preds < nb_tests:\\n y_test = y_test[:nb_preds]\\n else:\\n y_pred = y_pred[:nb_tests]\\n\\n # Print labels and predictions.\\n print('y_test.shape: ', y_test.shape)\\n print('y_pred.shape: ', y_pred.shape)\\n # print('y_test and y_test.shape: ', y_test, y_test.shape)\\n # print('y_pred and y_pred.shape: ', y_pred, y_pred.shape)\\n\\n self.print_and_save_evaluations(y_test, y_pred, softmax_predictions, config_dict)\",\n \"def predict_4(trained_model, X_test, y_test):\\n # Predict with test data\\n start_time = timeit.default_timer()\\n trained_model.predict(X_test)\\n end_time = timeit.default_timer()\\n time = end_time - start_time\\n speed = int(X_test.shape[0] / time)\\n \\n # Get loss and accuracy\\n test_accuracy = trained_model.score(X_test, y_test)\\n \\n # Prepare results messages\\n msg_time = \\\"prediction time: {:.3f}s ({}px/s)\\\\n\\\".format(time, speed)\\n msg_test_acc = \\\"test_accuracy: {:.3f}\\\\n\\\\n\\\".format(test_accuracy)\\n \\n # Write results messages\\n with open(OUTPUT_FILE, 'a') as f:\\n f.write(msg_time)\\n f.write(msg_test_acc)\",\n \"def test_test_model(self):\\n\\n dataset = ClassificationTestDataset()\\n model = ClassificationTestModel(dataset)\\n preds = list(model.predict(dataset.examples))\\n self.assertEqual(np.argmax(preds[0]['preds']), 2)\\n self.assertEqual(np.argmax(preds[1]['preds']), 1)\\n self.assertEqual(np.argmax(preds[2]['preds']), 4)\\n self.assertEqual(np.argmax(preds[3]['preds']), 3)\",\n \"def predict(self):\\n batch = get_predict_batch(1, num_rec_out=self.num_test_rec)\\n self.g_model.test_batch(\\n batch, self.global_step, num_rec_out=self.num_test_rec)\",\n \"def test_print_results(self):\\n calculated = super().predict_and_print()\\n self.assertEqual(calculated, EXP_PRINT_OUTPUT_BASE.format(.18, .1, 0.186, self.test_model.model.train_time) +\\n \\\"Max tree max_depth: 1\\\\n\\\"\\n \\\"Number of n_estimators: 1\\\\n\\\"\\n \\\"Impurity method: entropy\\\\n\\\")\",\n \"def test_output(self, test_data):\\n for finput in test_data[\\\"EKFSLAM.EKFSLAM.predict\\\"]:\\n params = tuple(finput.values())\\n\\n self_1, eta_1, P_1, z_odo_1 = deepcopy(params)\\n\\n self_2, eta_2, P_2, z_odo_2 = deepcopy(params)\\n\\n etapred_1, P_1 = EKFSLAM.EKFSLAM.predict(self_1, eta_1, P_1, z_odo_1)\\n\\n etapred_2, P_2 = solution.EKFSLAM.EKFSLAM.predict(self_2, eta_2, P_2, z_odo_2)\\n \\n assert compare(etapred_1, etapred_2)\\n assert compare(P_1, P_2)\\n \\n assert compare(self_1, self_2)\\n assert compare(eta_1, eta_2)\\n assert compare(P_1, P_2)\\n assert compare(z_odo_1, z_odo_2)\",\n \"def predict_2(trained_model, X_test, y_test):\\n # Predict with test data\\n start_time = timeit.default_timer()\\n test_prediction = trained_model.predict(X_test)\\n end_time = timeit.default_timer()\\n time = end_time - start_time\\n speed = int(X_test.shape[0] / time)\\n \\n # Get loss and accuracy\\n test_loss, test_accuracy = trained_model.evaluate(X_test, y_test)\\n \\n # Prepare results messages\\n msg_time = \\\"prediction time: {:.3f}s ({}px/s)\\\\n\\\".format(time, speed)\\n msg_test_loss = \\\"test_loss: {:.3f}\\\\n\\\".format(test_loss)\\n msg_test_acc = \\\"test_accuracy: {:.3f}\\\\n\\\\n\\\".format(test_accuracy)\\n \\n # Write results messages\\n with open(OUTPUT_FILE, 'a') as f:\\n f.write(msg_time)\\n f.write(msg_test_loss)\\n f.write(msg_test_acc)\",\n \"def predict(self, test_dataset: Dataset) -> PredictionOutput:\\n test_dataloader = self.get_test_dataloader(test_dataset)\\n return self._prediction_loop(test_dataloader, description=\\\"Prediction\\\")\",\n \"def predict(self, Xtt):\\n # predict outputs for test dataset\\n self.logger.info(\\n self.__name__ + ' predicts on {:d} samples.'.format(Xtt.shape[0]))\\n pass\",\n \"def predict(self, test_set, test_labels):\\n\\n with tf.Session() as self.tf_session:\\n self.tf_saver.restore(self.tf_session, self.models_dir + self.model_name)\\n return self.accuracy.eval({self.input_data: test_set, self.input_labels: test_labels})\",\n \"def test_predict(self):\\n\\n docs = self.docs\\n for m in self.models:\\n preds = m.predict(docs)\\n self.assertTrue(isinstance(preds, turicreate.SArray))\\n self.assertEqual(len(preds), len(docs))\\n self.assertEqual(preds.dtype, int)\\n\\n preds = m.predict(docs, output_type=\\\"probability\\\")\\n self.assertTrue(isinstance(preds, turicreate.SArray))\\n self.assertTrue(len(preds) == len(docs))\\n s = preds.apply(lambda x: sum(x))\\n self.assertTrue((s.apply(lambda x: abs(x - 1)) < 0.000001).all())\\n\\n # Test predictions when docs have new words\\n new_docs = turicreate.SArray([{\\\"-1,-1\\\": 3.0, \\\"0,4\\\": 5.0, \\\"0,3\\\": 2.0}])\\n preds = m.predict(new_docs)\\n self.assertEqual(len(preds), len(new_docs))\\n\\n # Test additional burnin. Ideally we could show that things\\n # converge as you increase burnin.\\n preds_no_burnin = m.predict(docs, output_type=\\\"probability\\\", num_burnin=0)\\n self.assertEqual(len(preds_no_burnin), len(docs))\",\n \"def predictSet(self, testData=\\\"\\\"):\\n rawTestDataDump = self._read_file(testData)\\n formattedTestData = [line.split(' ') for line in rawTestDataDump.split('\\\\n')]\\n for test in formattedTestData:\\n self._predictions.append(self.predict(test))\\n return self._predictions\",\n \"def predict(model):\\n # load test dataset\\n test = dict(json.load(open('util_files/test.json')))\\n ids = test['ids']\\n data = test['data']\\n\\n df = pd.read_csv('data/document_departments.csv')\\n labels = dict(df.values.tolist())\\n\\n id2cls = dict(json.load(open('util_files/id2cls.json')))\\n \\n ytrue = []\\n ypredicted = []\\n \\n for i in range(len(data)):\\n \\n prediction = np.argmax(model.predict_on_batch(np.expand_dims(data[i], axis=0)))\\n \\n ypredicted.append(id2cls[str(prediction)])\\n \\n cls = labels[int(ids[i])]\\n ytrue.append(cls)\\n \\n print \\\"classification report\\\"\\n print classification_report(y_true=ytrue,\\n y_pred=ypredicted)\\n \\n print \\\"*********************\\\"\\n print \\\"Accuracy on test set\\\"\\n print accuracy_score(y_true=ytrue,\\n y_pred=ypredicted)\\n print \\\"*********************\\\"\",\n \"def predict_3(trained_model, X_test, y_test, image_name):\\n iterations = trained_model.booster_.current_iteration()\\n results = np.zeros((iterations, ))\\n for pos in range(iterations):\\n \\n # Calculate the current iteration (from 1 to iterations)\\n iteration = pos + 1\\n \\n # Predict test set for the current iteration\\n start_time = timeit.default_timer()\\n test_pred = trained_model.predict(X_test, num_iteration=iteration)\\n end_time = timeit.default_timer()\\n time = end_time - start_time\\n speed = int(X_test.shape[0] / time)\\n \\n # Number of hits\\n test_ok = (test_pred == y_test)\\n \\n # Percentage of hits\\n test_acc = test_ok.sum() / test_ok.size\\n \\n # Actualize data for plotting results\\n results[pos] = test_acc\\n \\n # Prepare test messages\\n classes = trained_model.n_classes_\\n msg_estimators = \\\"\\\\nn_estimators: {}\\\\n\\\".format(iteration)\\n msg_trees = \\\"Number of trees: {}\\\\n\\\".format(classes * iteration)\\n msg_time = \\\"prediction time: {:.3f}s ({}px/s)\\\\n\\\".format(time, speed)\\n msg_test_acc = \\\"test_acc: {:.3f}\\\\n\\\".format(test_acc)\\n \\n # Write test messages\\n with open(OUTPUT_FILE, 'a') as f:\\n f.write(msg_estimators)\\n f.write(msg_trees)\\n f.write(msg_time)\\n f.write(msg_test_acc)\\n \\n # Generate accuracy plot\\n plt.figure()\\n plt.plot(results, 'b')\\n plt.title('Test accuracy')\\n plt.xlabel('iterations')\\n plt.ylabel('accuracy')\\n plt.legend()\\n \\n # Save test plot\\n plot_file = os.path.join(OUTPUT_DIR, \\\"{}_test_accuracy\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\",\n \"def predict(self, test_data):\\n return self.leader.predict(test_data)\",\n \"def test_predict(self):\\n self.regression_single.predict(self.X_test)\\n self.assertTrue(len(self.regression_single.y_pred))\\n self.regression_boston.predict(self.boston_x_test)\\n self.assertTrue(len(self.regression_boston.y_pred))\",\n \"def model_predict(model,x_test,y_test):\\n\\n\\n y_pred = model.predict(x_test)\\n\\n predict_class = np.argmax(y_pred, axis=1)\\n\\n predict_class = predict_class.tolist()\\n\\n return(y_pred,predict_class)\",\n \"def make_predictions(model, test_set, val_set):\\n \\n ## Uses model to predict some amount of images\\n predict = model.predict_classes(test_set, batch_size=5, verbose=1)\\n \\n ## We use the length of these two arrays when we sift through the data to find\\n ## the right predictions and wrong predictions\\n images = len(test_set)\\n\\n ## Initialises variables for loop\\n correctly_guessed = 0\\n\\n ## Begins loop to find total correct predictions\\n for i in range(images):\\n if predict[i] == np.argmax(val_set[i]):\\n correctly_guessed += 1\\n\\n ## Returns amount of predictions were correct\\n print('\\\\nCorrectly guessed = ', correctly_guessed)\\n print('Inorrectly guessed = ', (images - correctly_guessed))\",\n \"def prediction(X_test, clf_object):\\n\\tY_prediction = clf_object.predict(X_test)\\n\\tprint(\\\"Total Predicted Values: \\\", len(Y_prediction))\\n\\treturn Y_prediction\",\n \"def test(self, test_instances, test_labels):\\n scores = self.classifier.predict(test_instances)\\n # TODO: print report\",\n \"def output_predictions_test_set(\\n self,\\n test_set,\\n max_key=None,\\n min_key=None,\\n progressbar=None,\\n test_loader_kwargs={},\\n ):\\n if progressbar is None:\\n progressbar = not self.noprogressbar\\n\\n if not isinstance(test_set, DataLoader):\\n test_loader_kwargs[\\\"ckpt_prefix\\\"] = None\\n test_set = self.make_dataloader(\\n test_set, Stage.TEST, **test_loader_kwargs\\n )\\n\\n save_file = os.path.join(\\n self.hparams.output_folder, \\\"predictions.csv\\\"\\n )\\n with open(save_file, \\\"w\\\", newline=\\\"\\\") as csvfile:\\n outwriter = csv.writer(csvfile, delimiter=\\\",\\\")\\n outwriter.writerow([\\\"id\\\", \\\"prediction\\\", \\\"true_value\\\"])\\n\\n self.on_evaluate_start(max_key=max_key, min_key=min_key) # done before\\n self.modules.eval()\\n with torch.no_grad():\\n for batch in tqdm(\\n test_set, dynamic_ncols=True, disable=not progressbar\\n ):\\n self.step += 1\\n\\n emo_ids = batch.id\\n true_vals = batch.emo_encoded.data.squeeze(dim=1).tolist()\\n output = self.compute_forward(batch, stage=Stage.TEST)\\n predictions = (\\n torch.argmax(output, dim=-1).squeeze(dim=1).tolist()\\n )\\n\\n with open(save_file, \\\"a\\\", newline=\\\"\\\") as csvfile:\\n outwriter = csv.writer(csvfile, delimiter=\\\",\\\")\\n for emo_id, prediction, true_val in zip(\\n emo_ids, predictions, true_vals\\n ):\\n outwriter.writerow([emo_id, prediction, true_val])\\n\\n # Debug mode only runs a few batches\\n if self.debug and self.step == self.debug_batches:\\n break\\n self.step = 0\",\n \"def make_predictions(self):\\n if is_classification(self.model):\\n if self.ct == None:\\n prediction = self.model.predict(self.input_data.to_numpy())\\n probabilities = self.model.predict_proba(self.input_data.to_numpy())\\n return prediction, probabilities\\n elif self.ct != None: \\n prediction = self.model.predict(self.data_into_model())\\n probabilities = self.model.predict_proba(self.data_into_model())\\n return prediction, probabilities\\n else:\\n raise Exception((\\\"{} not supported. Please create an issue on Github\\\").format(self.model))\\n \\n else:\\n if self.ct == None:\\n prediction = self.model.predict(self.input_data)\\n return prediction\\n elif self.ct != None: \\n prediction = self.model.predict(self.data_into_model())\\n return prediction\\n else:\\n raise Exception((\\\"{} not supported. Please create an issue on Github\\\").format(self.self.model))\",\n \"def postprocess_model_outputs(self, predictions, expected):\\n\\n for key, val in predictions.items():\\n predictions[key] = val.numpy()\\n\\n for key, val in expected.items():\\n expected[key] = val.numpy()\\n\\n return predictions, expected\",\n \"def test_model(model, trainset, testset):\\n model.eval()\\n \\n predictions = []\\n actuals = []\\n \\n for data in testset:\\n # data will have batch of features and labels\\n X = data[0:4]\\n y = data[4:]\\n \\n pred = np.round(model(X).detach().numpy())\\n actual = y.detach().numpy()\\n # print(f'pred: {pred}')\\n # print(f'actual: {actual}')\\n predictions.append(pred)\\n actuals.append(actual)\\n \\n print(accuracy_score(y_true=actuals, y_pred=predictions))\\n \\n \\n # Confusion Matrix\\n \\n confusion_matrix = np.zeros((3, 3))\\n for i,j in zip(predictions, actuals):\\n confusion_matrix[i, j] += 1\\n print(\\\"Confusion matrix:\\\\n\\\", confusion_matrix)\",\n \"def test(self):\\n y_list = []\\n y_hat_list = []\\n for ex_dict in ut.TEST_LIST:\\n y_list.append(ex_dict[1])\\n y_hat_list.append(self.predict(ex_dict[0]))\\n acc = ut.compute_accuracy(y_hat_list, y_list)\\n return y_hat_list, acc\",\n \"def get_predictions():\\n\\n print(\\\"OK1\\\");\\n print(\\\"OK2\\\");\\n return;\",\n \"def evaluate(self):\\n predictions = self.model.predict(self.test[0])\\n accuracy = accuracy_score(self.test[1], predictions)\\n print(\\\"Accuracy:\\\", str(accuracy * 100) + \\\"%\\\")\\n self.plot_results(predictions)\",\n \"def class_predict_3(trained_model, X_test, y_test, image_name):\\n # Predict test set\\n try:\\n test_pred = trained_model.predict_proba(X_test)\\n except:\\n test_pred = trained_model.predict(X_test)\\n \\n if len(test_pred.shape) == 1:\\n raise Exception(\\\"Probabilistic prediction needed.\\\")\\n \\n # Transform y_test\\n if len(y_test.shape) > 1:\\n y_test = np.argmax(y_test, axis=1)\\n \\n classes = np.unique(y_test)\\n results = np.zeros((len(classes), ))\\n for class_num in classes:\\n \\n # Take predictions for current class\\n X_pred = test_pred[y_test == class_num, :]\\n \\n # Number of hits\\n pred_ok = (np.argmax(X_pred, axis=1) == class_num).sum()\\n \\n # Percentage of hits\\n pred_acc = pred_ok / X_pred.shape[0]\\n \\n # Actualize data for plotting results\\n results[class_num] = pred_acc\\n \\n # Write test message\\n with open(OUTPUT_FILE, 'a') as f:\\n f.write(\\\"test_acc of class {}: {:.3f}\\\\n\\\".format(class_num,\\n pred_acc))\\n \\n # Generate accuracy plot\\n plt.figure()\\n plt.bar(classes, results, align='center')\\n plt.xticks(classes, classes)\\n plt.title('Per class test accuracy')\\n plt.xlabel('class')\\n plt.ylabel('accuracy')\\n plt.legend()\\n \\n # Save test plot\\n plot_file = os.path.join(OUTPUT_DIR, \\\"{}_test_accuracy\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\",\n \"def evaluate_prediction(self):\\n\\n # ratio_train = self.evaluate_data(self.train_x, self.train_y)\\n ratio_test = self.evaluate_data(self.test_x, self.test_y)\\n\\n print(\\\"\\\\n*NAIVE BAYES:\\\")\\n # print(\\\"Test1: {}%\\\".format(ratio_dev*100))\\n print(\\\"Test: {} %\\\".format(ratio_test*100))\",\n \"def predictions(self, model):\\n return get_predictions_from_df(\\n model=model, df=self.prediction_df,\\n fixed_effects=self.fixed_effects,\\n random_effect=self.random_effect,\\n spline=self.spline,\\n offset=self.offset,\\n )\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n \\n y_preds = model.predict(X_test)\\n predictions = pd.DataFrame(data=y_preds, columns=Y_test.columns, index=Y_test.index)\\n for col in Y_test.columns:\\n print(classification_report(predictions[col],Y_test[col]))\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n y_pred = model.predict(X_test)\\n print(classification_report(Y_test, y_pred, target_names=Y_test.keys()))\",\n \"def make_predictions(model, x_test, y_test):\\r\\n preds = model.predict(x_test)\\r\\n y_hat = np.argmax(preds, axis=-1)\\r\\n print(type(y_test))\\r\\n y_test.columns = [0, 1]\\r\\n y = y_test.idxmax(axis=1)\\r\\n print(y_hat.shape)\\r\\n print(y.shape)\\r\\n return y_hat, y\",\n \"def predictions(self):\\n return self._pred\",\n \"def test_predict(self):\\n \\n\\n model ,vec, x_testing=setup_log_reg_classifier(self.training_data, self.training_y, self.testing_data,\\\"text\\\", method=\\\"count\\\")\\n \\n model2 ,vec_tfidf, x_testing2=setup_log_reg_classifier(self.training_data, self.training_y, self.testing_data,\\\"text\\\", method=\\\"tfidf\\\")\\n \\n \\n \\\"\\\"\\\" Test correct data types and corrrect range of predicted values (1,0) for predict with countVectorizer\\\"\\\"\\\" \\n \\n self.assertIsInstance(predict(model,x_testing),\\n np.ndarray)\\n \\n self.assertTrue(([0,1] ==np.unique(predict(model2,x_testing2))).all())\\n\\n \\n \\\"\\\"\\\" Test correct data types and corrrect range of predicted values (1,0) for predict with tfidfVectorizer\\\"\\\"\\\" \\n \\n self.assertIsInstance(predict(model,x_testing),\\n np.ndarray)\\n \\n self.assertTrue(([0,1] ==np.unique(predict(model2,x_testing2))).all())\",\n \"def test_model (self, text_test, labels_test):\\n print(classification_report(labels_test, self.classify(text_test)))\",\n \"def predict(self):\\r\\n\\r\\n # reshape test_array since it is a single row of data\\r\\n user_array = np.asanyarray(self.test_array).reshape(1, -1)\\r\\n # one hot encode user_array\\r\\n self.enc.fit(user_array)\\r\\n user_array = self.enc.transform(user_array)\\r\\n # create, train and predict the model with the dataset\\r\\n model = (\\\"Ridge\\\", linear_model.Ridge(alpha=0.01, random_state=4))\\r\\n model[1].fit(self.X_train, self.y_train)\\r\\n y_pred = model[1].predict(self.X_test)\\r\\n # predict with user provided chords\\r\\n y_usr = model[1].predict(user_array)\\r\\n if y_usr[0] < 0:\\r\\n y_usr[0] = 0\\r\\n acc = metrics.r2_score(self.y_test, y_pred)\\r\\n output = \\\"I am {}% sure that you like this progression.\\\".format('%.2f' % (100 * y_usr[0]))\\r\\n model_info = \\\"Predicted using a {} model with {} accuracy from {} data samples.\\\".format(model[0], '%.3f' % acc,\\r\\n self.data_count())\\r\\n return output, model_info\",\n \"def model_pred(model_name):\\n with open('model-'+model_name+'.pickle', 'rb') as clf_file:\\n clf_test = pickle.load(clf_file)\\n\\n df_test = pd.read_csv(\\\"test.csv\\\")\\n df_test = df_test.fillna(method='ffill')\\n\\n for column in df_test.columns:\\n if df_test[column].dtype == type(object):\\n le = preprocessing.LabelEncoder()\\n df_test[column] = le.fit_transform(df_test[column])\\n\\n y_test_output = df_test.values\\n y_pred_output = clf_test.predict(y_test_output)\\n output = []\\n for a,b in zip(y_test_output,y_pred_output):\\n output.append([int(a[0]),b])\\n\\n out_df = pd.DataFrame(output,columns = ['id','P'])\\n out_df.to_csv('pred-'+model_name+'.csv',index = False)\",\n \"def _predict(self, testX):\\n pass\",\n \"def train_predict(model_list,X_train, X_test, y_train, y_test):\\n P = np.zeros((y_test.shape[0], len(model_list)))\\n P = pd.DataFrame(P)\\n\\n print(\\\"Fitting models.\\\")\\n cols = list()\\n for i, (name, m) in enumerate(models.items()):\\n print(\\\"%s...\\\" % name, end=\\\" \\\", flush=False)\\n m.fit(X_train, y_train)\\n P.iloc[:, i] = m.predict_proba(X_test)[:, 1]\\n cols.append(name)\\n print(\\\"done\\\")\\n\\n P.columns = cols\\n print(\\\"Done.\\\\n\\\")\\n return P\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n \\n Y_pred = model.predict(X_test)\\n \\n print(classification_report(Y_test.values, Y_pred, target_names=category_names))\",\n \"def getPredictions(self):\\n\\t\\tself.bestLabel = self.testingProbs.apply(lambda x: x.argmax(),1)\",\n \"def eval(self): \\n inputs,enc_input_weights, outputs, dec_input_weights = self.get_batch()\\n predicted_ids = self.model.step(self.sess, inputs, enc_input_weights) \\n print(\\\"=\\\"*20)\\n for i in range(FLAGS.batch_size):\\n print(\\\"* %dth sample target: %s\\\" % (i,str(outputs[i,1:]-2)))\\n for predict in predicted_ids[i]:\\n print(\\\"prediction: \\\"+str(predict)) \\n print(\\\"=\\\"*20)\",\n \"def predict(self, X_test, **kwargs):\\n\\n # Normalize inputs\\n if self.normalize_input:\\n X_, _, _ = zero_mean_unit_var_normalization(X_test, self.X_mean, self.X_std)\\n else:\\n X_ = X_test\\n\\n # Sample a number of predictions for each given point\\n # Generate mean and variance for each given point from sampled predictions\\n\\n X_ = torch.Tensor(X_)\\n self.model.eval()\\n Yt_hat = self.model(X_).data.cpu().numpy()\\n\\n if self.normalize_output:\\n Yt_hat = zero_mean_unit_var_denormalization(Yt_hat, self.y_mean, self.y_std)\\n\\n logger.debug(f\\\"Generated final outputs array of shape {Yt_hat.shape}\\\")\\n\\n return Yt_hat\",\n \"def evaluate_model(model, X_test, y_test, category_names):\\n y_pred = model.predict(X_test)\\n labels = np.unique(y_pred)\\n print(labels)\\n #print out score for each class and mean scores, including precision, recall, f1 score\\n print(classification_report(y_test.values, y_pred, target_names=category_names.values))\",\n \"def test_04_predict(self):\\n today = date.today()\\n log_file = os.path.join(LOG_DIR, \\\"{}-predict-{}-{}.log\\\".format(LOG_PREFIX, today.year, today.month))\\n\\n ## update the log\\n y_pred = [0]\\n y_proba = [0.6,0.4]\\n runtime = \\\"00:00:02\\\"\\n model_version = 0.1\\n country = \\\"india\\\"\\n target_date = '2018-01-05'\\n\\n update_predict_log(country, y_pred,y_proba,target_date,runtime,\\n model_version, test=True, prefix=LOG_PREFIX)\\n\\n df = pd.read_csv(log_file)\\n logged_y_pred = [literal_eval(i) for i in df['y_pred'].copy()][-1]\\n self.assertEqual(y_pred,logged_y_pred)\",\n \"def do_predict(self):\\n answer = []\\n response = []\\n\\n for it_predictions in json.loads(request.data.decode('UTF-8')):\\n prediction = it_predictions['score']\\n for ite_clf in g_list_of_classifier:\\n answer.append(ite_clf.predict(prediction))\\n if answer.count(True) > answer.count(False):\\n response.append({'answer' : True})\\n else:\\n response.append({'answer' : False})\\n return json.dumps(response, indent=4)\",\n \"def predict(self, testX):\\n predicted = self.model.predict(testX)\\n return predicted\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n \\n \\n yPredictorTest = model.predict(X_test)\\n \\n for idx, col in enumerate(Y_test):\\n print(col, classification_report(Y_test[col], yPredictorTest[:, idx]))\",\n \"def predict(self, test_x):\\n \\n graph = tf.Graph()\\n with graph.as_default():\\n with tf.compat.v1.Session() as sess:\\n tf.compat.v1.saved_model.loader.load(sess, [tf.saved_model.SERVING], \\n self.save_file_directory)\\n x = graph.get_tensor_by_name('inputs:0')\\n outputs = graph.get_tensor_by_name('outputs:0')\\n \\n test_y_hat = sess.run(outputs, feed_dict={x: test_x})\\n \\n return test_y_hat\",\n \"def predictions(self):\\n\\n return self._predictions\",\n \"def cv_predict_3(trained_model, X_test, y_test):\\n # Predict test set\\n start_time = timeit.default_timer()\\n test_pred = trained_model.predict(X_test)\\n end_time = timeit.default_timer()\\n time = end_time - start_time\\n speed = int(X_test.shape[0] / time)\\n \\n # Number of hits\\n test_ok = (test_pred == y_test)\\n \\n # Percentage of hits\\n test_acc = test_ok.sum() / test_ok.size\\n \\n # Prepare test messages\\n classes = trained_model.n_classes_\\n msg_time = \\\"prediction time: {:.3f}s ({}px/s)\\\\n\\\".format(time,\\n speed)\\n msg_test_acc = \\\"test_acc: {:.3f}\\\\n\\\".format(test_acc)\\n \\n # Write test messages\\n with open(OUTPUT_FILE, 'a') as f:\\n f.write(msg_time)\\n f.write(msg_test_acc)\",\n \"def run_prediction(data, sess, placeholders, scores): \\r\\n \\r\\n X, Y = data\\r\\n source_pl, target_pl, training_pl = placeholders\\r\\n split_set = int(math.floor(0.9*len(X))) # Value for spliting the set in 90% training / 10% test \\r\\n \\r\\n X_batch, Y_batch = batch(X[:split_set:], Y[:split_set:]) # Take a batch of sentences from the training set\\r\\n feed_dict = {source_pl: X_batch, target_pl: Y_batch, training_pl: False}\\r\\n prediction = sess.run(scores, feed_dict=feed_dict) \\r\\n X_batch = np.squeeze(X_batch) \\r\\n prediction = np.squeeze(prediction)\\r\\n \\r\\n source_sentences = treatment.sentences_from_one_hot(X_batch, CORPUS_ENGLISH)\\r\\n target_sentences = treatment.sentences_from_one_hot(prediction, CORPUS_FRENCH)\\r\\n\\r\\n\\t# Print the pairs source -> target\\r\\n for source, target in zip(source_sentences, target_sentences): \\r\\n print(source + \\\" --> \\\" + target)\\r\\n \\r\\n print(\\\"================================================================\\\")\\r\\n \\r\\n X_batch, Y_batch = batch(X[split_set+1:], Y[split_set+1:]) # Take a batch of sentences from the test set\\r\\n feed_dict = {source_pl: X_batch, target_pl: Y_batch, training_pl: False}\\r\\n prediction = sess.run(scores, feed_dict=feed_dict) \\r\\n \\r\\n X_batch = np.squeeze(X_batch) \\r\\n prediction = np.squeeze(prediction)\\r\\n \\r\\n \\r\\n source_sentences = treatment.sentences_from_one_hot(X_batch, CORPUS_ENGLISH)\\r\\n target_sentences = treatment.sentences_from_one_hot(prediction, CORPUS_FRENCH)\\r\\n\\r\\n\\t# Print the pairs source -> target\\r\\n for source, target in zip(source_sentences, target_sentences): \\r\\n print(source + \\\" --> \\\" + target)\",\n \"def test(self):\\n\\t\\treturn classification_report(self.test_labels, self.predict(self.test_data), target_names=self.le.classes_)\",\n \"def predict(self, x_test, y_test, model_path):\\n tf.reset_default_graph()\\n with tf.compat.v1.Session() as sess:\\n saver = tf.compat.v1.train.import_meta_graph(model_path + \\\".meta\\\")\\n saver.restore(sess, model_path)\\n graph = tf.compat.v1.get_default_graph()\\n x = graph.get_operation_by_name(\\\"x_input\\\").outputs[0]\\n y = tf.compat.v1.get_collection(\\\"network_architecture\\\")[0]\\n no_samples = x_test.shape[0]\\n predictions = []\\n n_iteration = no_samples // self.batch_size\\n for step in range(n_iteration):\\n x_batch, y_batch = get_batch_data(x_test, y_test, iter_step=step, batch_size=self.batch_size)\\n preds = sess.run(y, feed_dict={x: x_batch})\\n predictions.append(preds)\\n return predictions\",\n \"def test_model(model, models_dir, test_dir, out_dir, test_files=None, test_file=None):\\n begin = int(round(time.time() * 1000))\\n utils.print_success(\\\"Testing \\\" + model)\\n pred_dir = out_dir + model\\n clf = joblib.load(models_dir + model + \\\"/\\\" + model + \\\".pkl\\\")\\n if test_files is not None:\\n pred_dir = pred_dir + \\\"/\\\"\\n utils.create_dir(pred_dir)\\n for index, test_file in enumerate(test_files):\\n # Check if isrc is in groundtruths to speed up computation time\\n if test_file[:12] in groundtruths:\\n test_features = read_test_file(test_dir + test_file)\\n try:\\n predictions = clf.predict_proba(test_features)\\n except AttributeError:\\n utils.print_warning(\\\"predict_proba does not exists for \\\" + model + \\\"\\\\nRegular predict function is used.\\\")\\n predictions = clf.predict(test_features)\\n with open(pred_dir + test_file, \\\"w\\\") as filep:\\n for pred in predictions:\\n filep.write(str(pred[0]) + \\\"\\\\n\\\")\\n elif test_file is not None:\\n pred_dir = pred_dir + \\\"_\\\"\\n test_features = []\\n filename = []\\n with open(test_file, \\\"r\\\") as filep:\\n for index, line in enumerate(filep):\\n line = line.split(\\\",\\\")\\n # print(str(index) + \\\" \\\" + line[0])\\n test_features.append(line[1:-1])\\n filename.append(line[0])\\n try:\\n predictions = clf.predict_proba(test_features)\\n with open(pred_dir + \\\"predict_proba.csv\\\", \\\"a\\\") as filep2:\\n for filen, pred in zip(filename, predictions):\\n filep2.write(filen + \\\",\\\" + str(pred[0]) + \\\"\\\\n\\\")\\n except:\\n pass\\n predictions = clf.predict(test_features)\\n with open(pred_dir + \\\"predict.csv\\\", \\\"a\\\") as filep2:\\n for filen, pred in zip(filename, predictions):\\n filep2.write(filen + \\\",\\\" + str(pred[0]) + \\\"\\\\n\\\")\\n else:\\n utils.print_error(\\\"Error in arg for test_model() function\\\")\\n utils.print_info(model + \\\" done in \\\" + str(int(round(time.time() * 1000)) - begin) + \\\"ms\\\")\",\n \"def fit_and_get_test_predictions(self, trace, tuning=True):\\n pass\",\n \"def predict(self):\\n self.get_test_data()\\n predicted_labels = []\\n for row in self.test_data:\\n predicted_labels.append(DecisionTree.predict_row(self.classifier, row))\\n return predicted_labels\",\n \"def test_predict(self):\\n\\t\\tMY_TEST_MODEL = \\\"v1_rm500\\\"\\n\\t\\tx_test = np.genfromtxt(\\\"tests/data/ensg_input.txt\\\",delimiter=\\\"\\\\t\\\")\\n\\t\\tquery_localdirs = cancerscope.get_models.findmodel(os.path.dirname(cancerscope.__file__),MY_TEST_MODEL)\\n\\t\\tif query_localdirs is not None:\\n\\t\\t\\tmodel_in = query_localdirs[MY_TEST_MODEL]\\n\\t\\telse:\\n\\t\\t\\tmodel_in = cancerscope.get_models.downloadmodel(model_label=MY_TEST_MODEL)\\n\\t\\t\\n\\t\\t\\\"\\\"\\\"Compare results with what you get from 'getmodel()'\\\"\\\"\\\"\\n\\t\\tmodeldir_v1_rm500 = cancerscope.get_models.getmodel(model_label = MY_TEST_MODEL)\\n\\t\\tself.assertEqual(modeldir_v1_rm500[MY_TEST_MODEL][MY_TEST_MODEL], model_in)\\n\\t\\t\\n\\t\\t\\\"\\\"\\\"Test prediction\\\"\\\"\\\"\\n\\t\\tlmodel = cancerscope.scopemodel(model_in)\\n\\t\\tlmodel.fit()\\n\\t\\trandom_sample = np.nan_to_num(x_test[0:17688, 1].reshape(1,17688))\\n\\t\\tpred_testX = lmodel.predict(random_sample)[0][0][0]\\n\\t\\tself.assertEqual(pred_testX, \\\"ESCA_TS\\\")\\n\\t\\t\\n\\t\\tallpreds_testX = lmodel.predict(random_sample, get_all_predictions=True, get_numeric=False,get_predictions_dict=False)[0]\\n\\t\\tallpredsNumeric_testX = lmodel.predict(random_sample, get_all_predictions=True, get_numeric=True, get_predictions_dict=False)[0]\\n\\t\\t\\n\\t\\tself.assertEqual(len(allpreds_testX), 66)\\n\\t\\tself.assertEqual(len(allpredsNumeric_testX), 66)\\n\\t\\tself.assertEqual(allpreds_testX[0], \\\"BRCA_TS\\\")\\n\\t\\tself.assertTrue(isinstance(allpredsNumeric_testX[0], Number))\\n\\t\\t\\n\\t\\t\\\"\\\"\\\"Test if normalization works and is evaluated to correct floatpoint\\\"\\\"\\\"\\n\\t\\tnormalized_testX = lmodel.get_normalized_input(random_sample)[0]\\n\\t\\tself.assertEqual(normalized_testX[0],0.60640558591378269)\\t\\n\\t\\t\\n\\t\\t\\\"\\\"\\\"Test if Jacobian is evaluated correctly\\\"\\\"\\\"\\n\\t\\t#Mar19 keras noncompat#jacobian_test = lmodel.get_jacobian(random_sample)\\n\\t\\t#class0_highestjacobian = np.amax(jacobian_test[0,:])\\n\\t\\t#self.assertEqual(jacobian_test.shape[0], 66) ## Num rows = classes\\n\\t\\t#self.assertEqual(jacobian_test.shape[1], 17688) ## Num columns = genes\\n\\t\\t#self.assertAlmostEqual(class0_highestjacobian, 0.00012377805544766)\\n\\t\\t#END OF #Mar19 keras noncompat#\",\n \"def write_predictions(all_examples, all_features, all_results, n_best_size,\\n max_answer_length, do_lower_case, output_prediction_file,\\n output_nbest_file, verbose_logging):\\n logger.info(\\\"Writing predictions to: %s\\\" % (output_prediction_file))\\n logger.info(\\\"Writing nbest to: %s\\\" % (output_nbest_file))\\n\\n example_index_to_features = collections.defaultdict(list)\\n for feature in all_features:\\n example_index_to_features[feature.example_index].append(feature)\\n\\n unique_id_to_result = {}\\n for result in all_results:\\n unique_id_to_result[result.unique_id] = result\\n\\n _PrelimPrediction = collections.namedtuple( # pylint: disable=invalid-name\\n \\\"PrelimPrediction\\\",\\n [\\\"feature_index\\\", \\\"start_index\\\", \\\"end_index\\\", \\\"start_logit\\\", \\\"end_logit\\\", \\\"label_logit\\\"])\\n\\n all_predictions = collections.OrderedDict()\\n all_nbest_json = collections.OrderedDict()\\n for (example_index, example) in enumerate(all_examples):\\n features = example_index_to_features[example_index]\\n\\n prelim_predictions = []\\n for (feature_index, feature) in enumerate(features):\\n result = unique_id_to_result[feature.unique_id]\\n\\n start_indexes = _get_best_indexes(result.start_logits, n_best_size)\\n end_indexes = _get_best_indexes(result.end_logits, n_best_size)\\n for start_index in start_indexes:\\n for end_index in end_indexes:\\n # We could hypothetically create invalid predictions, e.g., predict\\n # that the start of the span is in the question. We throw out all\\n # invalid predictions.\\n if start_index >= len(feature.tokens):\\n continue\\n if end_index >= len(feature.tokens):\\n continue\\n if start_index not in feature.token_to_orig_map:\\n continue\\n if end_index not in feature.token_to_orig_map:\\n continue\\n if not feature.token_is_max_context.get(start_index, False):\\n continue\\n if end_index < start_index:\\n continue\\n length = end_index - start_index + 1\\n if length > max_answer_length:\\n continue\\n prelim_predictions.append(\\n _PrelimPrediction(\\n feature_index=feature_index,\\n start_index=start_index,\\n end_index=end_index,\\n start_logit=result.start_logits[start_index],\\n end_logit=result.end_logits[end_index],\\n label_logit=result.label_logits))\\n\\n prelim_predictions = sorted(\\n prelim_predictions,\\n key=lambda x: (x.start_logit + x.end_logit),\\n reverse=True)\\n\\n _NbestPrediction = collections.namedtuple( # pylint: disable=invalid-name\\n \\\"NbestPrediction\\\", [\\\"text\\\", \\\"start_logit\\\", \\\"end_logit\\\", \\\"label_logit\\\"])\\n\\n seen_predictions = {}\\n nbest = []\\n for pred in prelim_predictions:\\n if len(nbest) >= n_best_size:\\n break\\n feature = features[pred.feature_index]\\n\\n tok_tokens = feature.tokens[pred.start_index:(pred.end_index + 1)]\\n orig_doc_start = feature.token_to_orig_map[pred.start_index]\\n orig_doc_end = feature.token_to_orig_map[pred.end_index]\\n orig_tokens = example.doc_tokens[orig_doc_start:(orig_doc_end + 1)]\\n tok_text = \\\" \\\".join(tok_tokens)\\n\\n # De-tokenize WordPieces that have been split off.\\n tok_text = tok_text.replace(\\\" ##\\\", \\\"\\\")\\n tok_text = tok_text.replace(\\\"##\\\", \\\"\\\")\\n\\n # Clean whitespace\\n tok_text = tok_text.strip()\\n tok_text = \\\" \\\".join(tok_text.split())\\n orig_text = \\\" \\\".join(orig_tokens)\\n\\n final_text = get_final_text(tok_text, orig_text, do_lower_case, verbose_logging)\\n if final_text in seen_predictions:\\n continue\\n\\n seen_predictions[final_text] = True\\n nbest.append(\\n _NbestPrediction(\\n text=final_text,\\n start_logit=pred.start_logit,\\n end_logit=pred.end_logit,\\n label_logit=pred.label_logit))\\n\\n # In very rare edge cases we could have no valid predictions. So we\\n # just create a nonce prediction in this case to avoid failure.\\n if not nbest:\\n nbest.append(\\n _NbestPrediction(text=\\\"empty\\\", start_logit=0.0, end_logit=0.0, label_logit=0.0))\\n\\n assert len(nbest) >= 1\\n\\n total_scores = []\\n for entry in nbest:\\n total_scores.append(entry.start_logit + entry.end_logit)\\n\\n probs = _compute_softmax(total_scores)\\n\\n nbest_json = []\\n for (i, entry) in enumerate(nbest):\\n output = collections.OrderedDict()\\n output[\\\"text\\\"] = entry.text\\n output[\\\"probability\\\"] = probs[i]\\n output[\\\"start_logit\\\"] = entry.start_logit\\n output[\\\"end_logit\\\"] = entry.end_logit\\n output[\\\"label_logit\\\"] = entry.label_logit\\n nbest_json.append(output)\\n\\n assert len(nbest_json) >= 1\\n\\n if nbest_json[0][\\\"label_logit\\\"] and (example.qas_id not in all_predictions.keys() or all_nbest_json[example.qas_id][0][\\\"probability\\\"] < nbest_json[0][\\\"probability\\\"]):\\n all_predictions[example.qas_id] = nbest_json[0][\\\"text\\\"]\\n all_nbest_json[example.qas_id] = nbest_json\\n\\n with open(output_prediction_file, \\\"w\\\") as writer:\\n writer.write(json.dumps(all_predictions, indent=4) + \\\"\\\\n\\\")\\n\\n with open(output_nbest_file, \\\"w\\\") as writer:\\n writer.write(json.dumps(all_nbest_json, indent=4) + \\\"\\\\n\\\")\",\n \"def write_predictions(self):\\n unique_id_to_result = {}\\n for result in self._all_results:\\n unique_id_to_result[result.unique_id] = result\\n\\n _PrelimPrediction = collections.namedtuple( # pylint: disable=invalid-name\\n \\\"PrelimPrediction\\\",\\n [\\\"feature_index\\\", \\\"start_index\\\", \\\"end_index\\\", \\\"start_logit\\\",\\n \\\"end_logit\\\"])\\n\\n all_predictions = collections.OrderedDict()\\n all_nbest_json = collections.OrderedDict()\\n scores_diff_json = collections.OrderedDict()\\n\\n for example in self._eval_examples:\\n example_id = example.qas_id if (\\\"squad\\\" in self._name or \\\"cmrc2018\\\" in self._name or \\\"drcd\\\" in self._name) else example.qid\\n features = self._task.featurize(example, False, for_eval=True)\\n\\n prelim_predictions = []\\n # keep track of the minimum score of null start+end of position 0\\n score_null = 1000000 # large and positive\\n for (feature_index, feature) in enumerate(features):\\n result = unique_id_to_result[feature[self._name + \\\"_eid\\\"]]\\n if self._config.joint_prediction:\\n start_indexes = result.start_top_index\\n end_indexes = result.end_top_index\\n else:\\n start_indexes = _get_best_indexes(result.start_logits,\\n self._config.n_best_size)\\n end_indexes = _get_best_indexes(result.end_logits,\\n self._config.n_best_size)\\n # if we could have irrelevant answers, get the min score of irrelevant\\n if self._v2:\\n if self._config.answerable_classifier:\\n feature_null_score = result.answerable_logit\\n else:\\n feature_null_score = result.start_logits[0] + result.end_logits[0]\\n if feature_null_score < score_null:\\n score_null = feature_null_score\\n for i, start_index in enumerate(start_indexes):\\n for j, end_index in enumerate(\\n end_indexes[i] if self._config.joint_prediction else end_indexes):\\n # We could hypothetically create invalid predictions, e.g., predict\\n # that the start of the span is in the question. We throw out all\\n # invalid predictions.\\n if start_index >= len(feature[self._name + \\\"_tokens\\\"]):\\n continue\\n if end_index >= len(feature[self._name + \\\"_tokens\\\"]):\\n continue\\n if start_index == 0:\\n continue\\n if start_index not in feature[self._name + \\\"_token_to_orig_map\\\"]:\\n continue\\n if end_index not in feature[self._name + \\\"_token_to_orig_map\\\"]:\\n continue\\n if not feature[self._name + \\\"_token_is_max_context\\\"].get(\\n start_index, False):\\n continue\\n if end_index < start_index:\\n continue\\n length = end_index - start_index + 1\\n if length > self._config.max_answer_length:\\n continue\\n start_logit = (result.start_top_log_probs[i] if\\n self._config.joint_prediction else\\n result.start_logits[start_index])\\n end_logit = (result.end_top_log_probs[i, j] if\\n self._config.joint_prediction else\\n result.end_logits[end_index])\\n prelim_predictions.append(\\n _PrelimPrediction(\\n feature_index=feature_index,\\n start_index=start_index,\\n end_index=end_index,\\n start_logit=start_logit,\\n end_logit=end_logit))\\n\\n if self._v2:\\n if len(prelim_predictions) == 0 and self._config.debug:\\n tokid = sorted(feature[self._name + \\\"_token_to_orig_map\\\"].keys())[0]\\n prelim_predictions.append(_PrelimPrediction(\\n feature_index=0,\\n start_index=tokid,\\n end_index=tokid + 1,\\n start_logit=1.0,\\n end_logit=1.0))\\n prelim_predictions = sorted(\\n prelim_predictions,\\n key=lambda x: (x.start_logit + x.end_logit),\\n reverse=True)\\n\\n _NbestPrediction = collections.namedtuple( # pylint: disable=invalid-name\\n \\\"NbestPrediction\\\", [\\\"text\\\", \\\"start_logit\\\", \\\"end_logit\\\"])\\n\\n seen_predictions = {}\\n nbest = []\\n for pred in prelim_predictions:\\n if len(nbest) >= self._config.n_best_size:\\n break\\n feature = features[pred.feature_index]\\n tok_tokens = feature[self._name + \\\"_tokens\\\"][\\n pred.start_index:(pred.end_index + 1)]\\n orig_doc_start = feature[\\n self._name + \\\"_token_to_orig_map\\\"][pred.start_index]\\n orig_doc_end = feature[\\n self._name + \\\"_token_to_orig_map\\\"][pred.end_index]\\n orig_tokens = example.doc_tokens[orig_doc_start:(orig_doc_end + 1)]\\n tok_text = \\\" \\\".join(tok_tokens)\\n\\n # De-tokenize WordPieces that have been split off.\\n tok_text = tok_text.replace(\\\" ##\\\", \\\"\\\")\\n tok_text = tok_text.replace(\\\"##\\\", \\\"\\\")\\n\\n # Clean whitespace\\n tok_text = tok_text.strip()\\n tok_text = \\\" \\\".join(tok_text.split())\\n orig_text = \\\" \\\".join(orig_tokens)\\n\\n final_text = get_final_text(self._config, tok_text, orig_text)\\n if final_text in seen_predictions:\\n continue\\n\\n seen_predictions[final_text] = True\\n\\n nbest.append(\\n _NbestPrediction(\\n text=final_text,\\n start_logit=pred.start_logit,\\n end_logit=pred.end_logit))\\n\\n # In very rare edge cases we could have no valid predictions. So we\\n # just create a nonce prediction in this case to avoid failure.\\n if not nbest:\\n nbest.append(\\n _NbestPrediction(text=\\\"empty\\\", start_logit=0.0, end_logit=0.0))\\n\\n assert len(nbest) >= 1\\n\\n total_scores = []\\n best_non_null_entry = None\\n for entry in nbest:\\n total_scores.append(entry.start_logit + entry.end_logit)\\n if not best_non_null_entry:\\n if entry.text:\\n best_non_null_entry = entry\\n\\n probs = _compute_softmax(total_scores)\\n\\n nbest_json = []\\n for (i, entry) in enumerate(nbest):\\n output = collections.OrderedDict()\\n output[\\\"text\\\"] = entry.text\\n output[\\\"probability\\\"] = probs[i]\\n output[\\\"start_logit\\\"] = entry.start_logit\\n output[\\\"end_logit\\\"] = entry.end_logit\\n nbest_json.append(dict(output))\\n\\n assert len(nbest_json) >= 1\\n\\n if not self._v2:\\n all_predictions[example_id] = nbest_json[0][\\\"text\\\"]\\n else:\\n # predict \\\"\\\" iff the null score - the score of best non-null > threshold\\n if self._config.answerable_classifier:\\n score_diff = score_null\\n else:\\n score_diff = score_null - best_non_null_entry.start_logit - (\\n best_non_null_entry.end_logit)\\n scores_diff_json[example_id] = score_diff\\n all_predictions[example_id] = best_non_null_entry.text\\n\\n all_nbest_json[example_id] = nbest_json\\n\\n utils.write_json(dict(all_predictions),\\n self._config.qa_preds_file(self._name+\\\"_\\\"+self._split))\\n if self._v2:\\n utils.write_json({\\n k: float(v) for k, v in six.iteritems(scores_diff_json)},\\n self._config.qa_na_file(self._name+\\\"_\\\"+self._split))\",\n \"def predict(self, test_data):\\n random.seed(self.seed)\\n preds = [{\\\"id\\\": instance['id'], \\\"prediction\\\": random.choice([0, 1])} for instance in test_data]\\n return preds\",\n \"def test_prediction(model, raw_data):\\n data = PredictionData(**raw_data)\\n formated_data = {}\\n for key, value in data.dict().items():\\n formated_data[key] = [value]\\n df = pd.DataFrame(formated_data)\\n res = model.predict(df)[0]\\n assert type(res) == np.float64\",\n \"def evaluate_model(model, X_test, Y_test, category_names): \\n \\n Y_pred = model.predict(X_test)\\n print(classification_report(Y_test, Y_pred))\\n display_results(Y_test, Y_pred)\",\n \"def predict_test(model, test_dataloader):\\r\\n # Put the model into the evaluation mode. The dropout layers are disabled during\\r\\n # the test time.\\r\\n model.eval()\\r\\n\\r\\n all_logits = []\\r\\n\\r\\n # For each batch in our test set...\\r\\n for batch in test_dataloader:\\r\\n # Load batch to GPU\\r\\n b_input_ids, b_attn_mask = tuple(t.to(device) for t in batch)[:2]\\r\\n\\r\\n # Compute logits\\r\\n with torch.no_grad():\\r\\n logits = model(b_input_ids, b_attn_mask)\\r\\n all_logits.append(logits)\\r\\n \\r\\n # Concatenate logits from each batch\\r\\n all_logits = torch.cat(all_logits, dim=0)\\r\\n\\r\\n # Apply softmax to calculate probabilities\\r\\n probs = F.softmax(all_logits, dim=1).cpu().numpy()\\r\\n\\r\\n return probs\",\n \"def evaluate_test(model, history, class_labels, train_X, test_X, train_y, test_y):\\n train_loss, train_acc = model.evaluate(train_X, train_y, verbose=0)\\n test_loss, test_acc = model.evaluate(test_X, test_y, verbose=0)\\n print('Accuracy \\\\n Train: %.3f, Test: %.3f' % (train_acc, test_acc))\\n print('Loss \\\\n Train: %.3f, Test: %.3f \\\\n' % (train_loss, test_loss))\\n # plot loss during training\\n plt.subplots_adjust(hspace = .5, wspace = 0.5)\\n plt.subplot(211)\\n plt.title('Loss', weight='bold')\\n plt.plot(history.history['loss'], label='train')\\n plt.plot(history.history['val_loss'], label='val')\\n plt.legend()\\n # plot accuracy during training\\n plt.subplot(212)\\n plt.title('Accuracy', weight='bold')\\n plt.plot(history.history['acc'], label='train')\\n plt.plot(history.history['val_acc'], label='val')\\n plt.legend()\\n plt.show()\\n print('\\\\n')\\n # predict probabilities for test set\\n yhat_probs = model.predict(test_X, verbose=0)\\n # predict classes for test set\\n yhat_classes = model.predict_classes(test_X, verbose=0)\\n # reduce to 1d array\\n yhat_probs = yhat_probs[:, 0]\\n yhat_classes = yhat_classes[:, 0]\\n # calculate metrics\\n report = metrics.classification_report(test_y, yhat_classes, target_names=class_labels)\\n confusion_matrix = metrics.confusion_matrix(test_y, yhat_classes)\\n plot_confusion_matrix(confusion_matrix, class_labels)\\n print('\\\\n')\\n return report\",\n \"def make_ensemble_prediction(trn_features, models, test_df):\\n test_id: pd.Series = test_df.iloc[:, 0]\\n test_features: pd.DataFrame = test_df.iloc[:, 1:]\\n\\n test_features = pd.concat([trn_features, test_features])\\n\\n clean_test_features, test_log = clean_features(test_features)\\n clean_test_features = clean_test_features.iloc[trn_features.shape[0]:, :]\\n\\n predictions = np.empty([0, trn_features.shape[0] - 1])\\n for model in models:\\n prediction = np.array([model.predict(clean_test_features)])\\n predictions = np.vstack([predictions, prediction])\\n\\n prediction = np.mean(predictions, axis=0)\\n\\n # print(predictions, prediction)\\n result_df = pd.DataFrame(columns=[\\\"Id\\\", \\\"SalePrice\\\"])\\n\\n for i in range(test_id.shape[0]):\\n result_df = result_df.append(pd.DataFrame([[int(test_id.iloc[i]), prediction[i]]], columns=[\\\"Id\\\", \\\"SalePrice\\\"]))\\n\\n print(result_df)\\n result_df.to_csv('../data/result.csv', index=False)\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n y_pred_grid = model.predict(X_test)\\n print(\\n classification_report(Y_test.values, y_pred_grid, target_names=category_names)\\n )\",\n \"def evaluate_model(self, model, testX_norm, testY_bin, batch_size, label_names, n_epochs, output_filename):\\n # Predictions\\n predictions = model.predict(testX_norm, batch_size=batch_size)\\n \\n # Classification report\\n classification = classification_report(testY_bin.argmax(axis=1),\\n predictions.argmax(axis=1),\\n target_names=label_names)\\n \\n # Print classification report\\n print(classification)\\n \\n # Save classification report\\n output_path = os.path.join(\\\"..\\\", \\\"output\\\", output_filename)\\n with open(output_path, 'w', encoding='utf-8') as f:\\n f.write(f\\\"Below are the classification metrics for the trained model. Batch size = {batch_size} and number of epochs = {n_epochs}.\\\\n\\\\n {classification}\\\")\",\n \"def save_predicted_results(predicted_results):\\n # Save the model\\n with open(\\\"predicted_results\\\", \\\"wb\\\") as predicted_results_file:\\n pickle.dump(predicted_results, predicted_results_file)\",\n \"def evaluate_model(model, X_test_input, y_test_input):\\r\\n pred_class = [model.classes_[i] for i in model.predict_proba(X_test_input).argmax(axis=-1)]\\r\\n pred_accuracy = np.sum(np.array(y_test_input)==np.array(pred_class))/len(pred_class)\\r\\n return pred_class, pred_accuracy\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n y_pred = model.predict(X_test)\\n print(classification_report(Y_test, y_pred, target_names=category_names))\\n pass\",\n \"def get_predictions(self, model, inputs=None):\\n if inputs is None:\\n inputs = self.inputs\\n\\n refl_id = BaseModel.get_refl_id(inputs)\\n iobs = BaseModel.get_intensities(inputs).flatten()\\n sig_iobs = BaseModel.get_uncertainties(inputs).flatten()\\n asu_id,H = self.asu_collection.to_asu_id_and_miller_index(refl_id)\\n #ipred = model(inputs)\\n ipred,sigipred = model.prediction_mean_stddev(inputs)\\n\\n h,k,l = H.T\\n results = ()\\n for i,asu in enumerate(self.asu_collection):\\n idx = asu_id == i\\n idx = idx.flatten()\\n output = rs.DataSet({\\n 'H' : h[idx],\\n 'K' : k[idx],\\n 'L' : l[idx],\\n 'Iobs' : iobs[idx],\\n 'SigIobs' : sig_iobs[idx],\\n 'Ipred' : ipred[idx],\\n 'SigIpred' : sigipred[idx],\\n }, \\n cell=asu.cell, \\n spacegroup=asu.spacegroup,\\n merged=False,\\n ).infer_mtz_dtypes().set_index(['H', 'K', 'L'])\\n results += (output, )\\n return results\",\n \"def show_predictions(model, test_set, val_set, image_guess, img_res, data='OSNR', GRAY=True):\\n \\n ## Uses model to predict some amount of images\\n predict = model.predict_classes(test_set, batch_size=5, verbose=1)\\n \\n ## Initialises variables for loop\\n correctly_guessed = 0\\n\\n ## Defines figure dimensions\\n fig = plt.figure(figsize=(20,30))\\n\\n ## Begins loop to find correct predictions and relay results to user\\n ## Searches through the prediction array and compares it to the actual array.\\n ## Displays image with the prediction and answer on the title\\n for i in range(image_guess):\\n correct = False\\n actual = np.argmax(val_set[i])\\n\\n if predict[i] == actual:\\n correctly_guessed += 1\\n correct = True\\n\\n plt.subplot(6,3,i+1)\\n fig.subplots_adjust(left=0.01,\\n right=0.7,\\n bottom=0.1,\\n top=1.2,\\n wspace=0.5,\\n hspace=0.2\\n )\\n if GRAY == False:\\n plt.imshow(test_set[i].reshape(img_res,img_res,3))\\n else:\\n plt.imshow(test_set[i].reshape(img_res,img_res), cmap='gray')\\n\\n if correct == True:\\n if data == 'disp':\\n plt.title('Correct! \\\\nPrediction = {}ps/nm Truth = {}ps/nm'\\n .format((10+10*predict[i]), (10+10*(actual))), fontsize=15)\\n \\n if data == 'disp-short':\\n plt.title('Correct! \\\\nPrediction = {} ~ {}ps/nm Truth = {} ~{}ps/nm'\\n .format(100*(predict[i]), (100+100*predict[i]), 100*(actual), (100+100*(actual)), fontsize=15))\\n \\n if data == 'OSNR':\\n plt.title('Correct! \\\\nPrediction = {}dB Truth = {}dB'\\n .format((12+0.5*predict[i]), (12+0.5*(actual))), fontsize=15)\\n \\n \\n else:\\n if data == 'disp':\\n plt.title('\\\\nPrediction = {}ps/nm Truth = {}ps/nm'\\n .format((10+10*predict[i]), (10+10*(actual))), fontsize=15)\\n \\n if data == 'disp-short':\\n plt.title('\\\\nPrediction = {} ~ {}ps/nm Truth = {} ~{}ps/nm'\\n .format(100*(predict[i]), (100+100*predict[i]), 100*(actual), (100+100*(actual)), fontsize=15))\\n \\n if data == 'OSNR':\\n plt.title('\\\\nPrediction = {}dB Truth = {}dB'\\n .format((12+0.5*predict[i]), (12+0.5*(actual))), fontsize=15)\\n\\n ## Returns amount of predictions that were correct\\n print('Correctly guessed = ', correctly_guessed)\\n print('Inorrectly guessed = ', (image_guess-correctly_guessed))\",\n \"def show_score(clf, X_test, y_test):\\n y_pred = predict(clf, X_test)\\n print metrics.classification_report(y_test.astype(np.int), y_pred)\",\n \"def evaluate_model(model, X_train, y_train, X_test, y_test):\\n model = model\\n model.fit(X_train, y_train)\\n\\n y_pred = model.predict(X_test)\\n\\n report = classificationreport(y_test, y_pred, target_names= [\\\"0\\\", \\\"1\\\"], output_dict=True)\\n\\n return report\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7996614","0.7647699","0.75771004","0.7555528","0.7431584","0.73849654","0.7349671","0.7293962","0.721062","0.71926904","0.71917266","0.7171003","0.7115817","0.71051496","0.7090768","0.70273274","0.70217824","0.70038015","0.69980234","0.6995777","0.6968296","0.69272035","0.69184965","0.69183433","0.69173664","0.68980324","0.68968195","0.68968046","0.6894786","0.68868685","0.686522","0.6858353","0.6858275","0.68449426","0.6840987","0.68201214","0.68169546","0.68114847","0.68084913","0.6807544","0.68056244","0.67885727","0.67867893","0.67790866","0.67752445","0.6772699","0.67690283","0.6761658","0.6757594","0.67433876","0.6732184","0.67157054","0.670305","0.669977","0.66946214","0.669103","0.667344","0.6672809","0.66671944","0.66649365","0.6655266","0.6653483","0.66530937","0.6650208","0.6643036","0.6628481","0.66260046","0.66233927","0.6610302","0.66098815","0.66067487","0.6597972","0.65960336","0.65893495","0.65867954","0.6582293","0.65806794","0.657464","0.657098","0.65667236","0.6559125","0.65555084","0.6552555","0.6551218","0.6547016","0.6547002","0.6542674","0.6540473","0.6540008","0.65385944","0.65182054","0.6515709","0.6513486","0.6507396","0.6501596","0.6497471","0.6496695","0.6488997","0.6488053","0.6484307"],"string":"[\n \"0.7996614\",\n \"0.7647699\",\n \"0.75771004\",\n \"0.7555528\",\n \"0.7431584\",\n \"0.73849654\",\n \"0.7349671\",\n \"0.7293962\",\n \"0.721062\",\n \"0.71926904\",\n \"0.71917266\",\n \"0.7171003\",\n \"0.7115817\",\n \"0.71051496\",\n \"0.7090768\",\n \"0.70273274\",\n \"0.70217824\",\n \"0.70038015\",\n \"0.69980234\",\n \"0.6995777\",\n \"0.6968296\",\n \"0.69272035\",\n \"0.69184965\",\n \"0.69183433\",\n \"0.69173664\",\n \"0.68980324\",\n \"0.68968195\",\n \"0.68968046\",\n \"0.6894786\",\n \"0.68868685\",\n \"0.686522\",\n \"0.6858353\",\n \"0.6858275\",\n \"0.68449426\",\n \"0.6840987\",\n \"0.68201214\",\n \"0.68169546\",\n \"0.68114847\",\n \"0.68084913\",\n \"0.6807544\",\n \"0.68056244\",\n \"0.67885727\",\n \"0.67867893\",\n \"0.67790866\",\n \"0.67752445\",\n \"0.6772699\",\n \"0.67690283\",\n \"0.6761658\",\n \"0.6757594\",\n \"0.67433876\",\n \"0.6732184\",\n \"0.67157054\",\n \"0.670305\",\n \"0.669977\",\n \"0.66946214\",\n \"0.669103\",\n \"0.667344\",\n \"0.6672809\",\n \"0.66671944\",\n \"0.66649365\",\n \"0.6655266\",\n \"0.6653483\",\n \"0.66530937\",\n \"0.6650208\",\n \"0.6643036\",\n \"0.6628481\",\n \"0.66260046\",\n \"0.66233927\",\n \"0.6610302\",\n \"0.66098815\",\n \"0.66067487\",\n \"0.6597972\",\n \"0.65960336\",\n \"0.65893495\",\n \"0.65867954\",\n \"0.6582293\",\n \"0.65806794\",\n \"0.657464\",\n \"0.657098\",\n \"0.65667236\",\n \"0.6559125\",\n \"0.65555084\",\n \"0.6552555\",\n \"0.6551218\",\n \"0.6547016\",\n \"0.6547002\",\n \"0.6542674\",\n \"0.6540473\",\n \"0.6540008\",\n \"0.65385944\",\n \"0.65182054\",\n \"0.6515709\",\n \"0.6513486\",\n \"0.6507396\",\n \"0.6501596\",\n \"0.6497471\",\n \"0.6496695\",\n \"0.6488997\",\n \"0.6488053\",\n \"0.6484307\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6510511"},"document_rank":{"kind":"string","value":"93"}}},{"rowIdx":15199,"cells":{"query":{"kind":"string","value":"Evaluate performance of the model on the test set"},"document":{"kind":"string","value":"def evaluate(test_set, predictions):\n full_report = metrics.classification_report(test_set.labels, predictions,\n labels=range(len(test_set.index2label)),\n target_names=test_set.index2label, digits=3)\n pre, rec, f1, support = metrics.precision_recall_fscore_support(test_set.labels, predictions, average='weighted')\n return pre, rec, f1, support, full_report"},"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 test_evaluate():\n X_train, X_test, y_train, y_test = src.load()\n clf, score = src.train(X_train, y_train)\n test_score = src.evaluate(clf, X_test, y_test)\n assert isinstance(test_score, float)","def evaluate(self, test_x, test_y):\n score = self._model.evaluate(test_x, test_y, verbose=self._verbose)\n print(\"Test score: \", score[0])\n print(\"Test accuracy: \", score[1])","def evaluate(self):\n predictions = self.model.predict(self.test[0])\n accuracy = accuracy_score(self.test[1], predictions)\n print(\"Accuracy:\", str(accuracy * 100) + \"%\")\n self.plot_results(predictions)","def evaluate_model(model, X_test, y_test):\n # run prediction with test data\n y_pred = model.predict(X_test)\n\n # print precision, recall and f1-score\n i = 0\n for col in y_test:\n print('Evaluation for \"{}\": \\n {} \\n\\n'.format(col, classification_report(y_test[col], y_pred[:,i])))\n i += 1","def evaluate(self, test_data):\n result = self.model.run(test_data)\n self._save_result(result)","def eval_perf_test(model, X_test, y_test):\n\n y_hat_test = model.predict(X_test)\n\n test_mae = metrics.mean_absolute_error(y_test, y_hat_test)\n test_mse = metrics.mean_squared_error(y_test, y_hat_test)\n test_rmse = np.sqrt(metrics.mean_squared_error(y_test, y_hat_test))\n test_r = metrics.r2_score(y_test, y_hat_test)\n\n print('Evaluating Performance on Testing Data:\\n')\n print(f'Test Mean Absolute Error: {test_mae:,.2f}')\n print(f'Test Mean Squared Error: {test_mse:,.2f}\\n')\n print(f'Test Root Mean Squared Error: {test_rmse:,.2f}')\n print(f'Test R-Square Value: {round(test_r,2)}')","def eval_perf_total(model, X_train, y_train, X_test, y_test):\n\n y_hat_train = model.predict(X_train)\n y_hat_test = model.predict(X_test)\n \n train_mae = metrics.mean_absolute_error(y_train, y_hat_train)\n train_mse = metrics.mean_squared_error(y_train, y_hat_train)\n train_rmse = np.sqrt(metrics.mean_squared_error(y_train, y_hat_train))\n train_r = metrics.r2_score(y_train, y_hat_train)\n\n print('Evaluating Performance on Training Data:\\n')\n print(f' Train Mean Absolute Error: {train_mae:,.2f}')\n print(f' Train Mean Squared Error: {train_mse:,.2f}\\n')\n print(f'Train Root Mean Squared Error: {train_rmse:,.2f}')\n print(f'Train R-Square Value: {round(train_r,2)}')\n\n print('\\n'+'---'*25+'\\n')\n\n test_mae = metrics.mean_absolute_error(y_test, y_hat_test)\n test_mse = metrics.mean_squared_error(y_test, y_hat_test)\n test_rmse = np.sqrt(metrics.mean_squared_error(y_test, y_hat_test))\n test_r = metrics.r2_score(y_test, y_hat_test)\n\n print('Evaluating Performance on Testing Data:\\n')\n print(f' Test Mean Absolute Error: {test_mae:,.2f}')\n print(f' Test Mean Squared Error: {test_mse:,.2f}\\n')\n print(f'Test Root Mean Squared Error: {test_rmse:,.2f}')\n print(f'Test R-Square Value: {round(test_r,2)}')","def evaluate_model(model, X_test, Y_test, category_names):\n\n print(\"Testing Performance\")\n print(classification_report(Y_test, model.predict(X_test), target_names=category_names))\n\n #Todo cat names","def evaluate(self, test):\r\n self.logger.info(\"Testing model over test set\")\r\n metrics = self.run_evaluate(test)\r\n msg = \" - \".join([\"{} {:04.2f}\".format(k, v)\r\n for k, v in metrics.items()])\r\n self.logger.info(msg)\r\n return metrics","def test(self):\r\n \r\n args = self.args\r\n model = self.model\r\n dataset = self.dataset\r\n \r\n dataset.set_split('test')\r\n batch_generator = generate_nmt_batches(dataset, \r\n batch_size=len(dataset), \r\n device=args.device)\r\n\r\n acc_sum = 0.0\r\n model.eval()\r\n \r\n for batch_index, batch_dict in enumerate(batch_generator):\r\n # step 1. compute the output\r\n if isinstance(model,NMTModelWithMLTM):\r\n y_pred = model(batch_dict['x_source'], \r\n batch_dict['x_source_mltm_vector'],\r\n batch_dict['x_source_length'], \r\n batch_dict['x_target'])\r\n else:\r\n y_pred = model(batch_dict['x_source'], \r\n batch_dict['x_source_length'], \r\n batch_dict['x_target'])\r\n\r\n acc_t = compute_accuracy(y_pred, batch_dict['y_target'], self.mask_index)\r\n acc_sum += acc_t\r\n \r\n return acc_sum / (batch_index+1)","def evaluate(self, test):\n self.logger.info(\"Testing model over test set\")\n metrics = self.run_evaluate(test)\n msg = \" - \".join([\"{} {:04.2f}\".format(k, v)\n for k, v in metrics.items()])\n self.logger.info(msg)\n return metrics","def eval_perf_train(model, X_train=None, y_train=None):\n\n # if X_train != None and y_train != None:\n\n y_hat_train = model.predict(X_train)\n \n train_mae = metrics.mean_absolute_error(y_train, y_hat_train)\n train_mse = metrics.mean_squared_error(y_train, y_hat_train)\n train_rmse = np.sqrt(metrics.mean_squared_error(y_train, y_hat_train))\n train_r = metrics.r2_score(y_train, y_hat_train)\n\n print('Evaluating Performance on Training Data:\\n')\n print(f'Train Mean Absolute Error: {train_mae:,.2f}')\n print(f'Train Mean Squared Error: {train_mse:,.2f}\\n')\n print(f'Train Root Mean Squared Error: {train_rmse:,.2f}')\n print(f'Train R-Square Value: {round(train_r,2)}')\n\n # if X_test != None and y_test != None:\n\n # y_hat_test = model.predict(X_test)\n\n # test_mae = metrics.mean_absolute_error(y_test, y_hat_test)\n # test_mse = metrics.mean_squared_error(y_test, y_hat_test)\n # test_rmse = np.sqrt(metrics.mean_squared_error(y_test, y_hat_test))\n # test_r = metrics.r2_score(y_test, y_hat_test)\n\n # print('Evaluating Performance on Testing Data:\\n')\n # print(f'Test Mean Absolute Error: {test_mae:,.2f}')\n # print(f'Test Mean Squared Error: {test_mse:,.2f}\\n')\n # print(f'Test Root Mean Squared Error: {test_rmse:,.2f}')\n # print(f'Test R-Square Value: {round(test_r,2)}')","def evaluate(self, X_test, y_test):\n self.run(self)\n self.y_pred = self.pipeline.predict(X_test)\n self.rmse = compute_rmse(self.y_pred, y_test)","def evaluate_model(self, test_data, test_labels,verbose=2):\n test_loss, test_acc = self.model.evaluate(test_data, test_labels, verbose=verbose)\n return test_loss, test_acc","def evaluate(X_test, y_test):\n # batch size is 16 for evaluation\n batch_size = 16\n\n # Load Model\n model = load_model('model/model.h5')\n return model.evaluate(X_test, y_test, batch_size, verbose = 1)","def evaluate(self):\n\n\t\tself.model_score = self.model.evaluate(self.x_test, self.y_test, batch_size=2048)\n\t\tprint(\"%s score = %f\\n\" %(self.modelName, self.model_score[1]))\n\t\treturn self.model_score","def model_evaluate(self, test):\n features = {name: np.array(value) for name, value in test.items()}\n labels = {name: features.pop(name) for name in self.label_names}\n metrics = self.model.evaluate(x=features, y=labels, batch_size=5)\n return metrics","def test_evaluate(self):\n # Check build does not raise errors\n dataset = KDDCupDataset()\n dataset.create_fixed_samples(\n *self.data, samples_num=1, partition_sizes=self.partition_sizes)\n dataset.set_current_sample(0)\n model = self.MODEL(dataset, **self.model_arguments)\n model.fit(training_epochs=50)\n metric = model.evaluate('test')\n self.assertLessEqual(0, metric)\n self.assertGreaterEqual(1, metric)","def evaluate(self, x_test, y_test, verbose=0):\n\n if self.model is None:\n raise StandardError('Model is not built. Run build method or load model before fitting')\n\n test_results = self.model.evaluate(x_test,\n y_test,\n batch_size=self.batch_size,\n verbose=verbose)\n self.val_history = test_results\n return test_results","def evaluate(self, x_test, y_test, verbose=0):\n\n if self.model is None:\n raise StandardError('Model is not built. Run build method or load model before fitting')\n\n test_results = self.model.evaluate(x_test,\n y_test,\n batch_size=self.batch_size,\n verbose=verbose)\n self.val_history = test_results\n return test_results","def evaluate(self, x_test, y_test, verbose=0):\n\n if self.model is None:\n raise StandardError('Model is not built. Run build method or load model before fitting')\n\n test_results = self.model.evaluate(x_test,\n y_test,\n batch_size=self.batch_size,\n verbose=verbose)\n self.val_history = test_results\n return test_results","def evaluate_model_performance():\n\n config = load_config()\n data_processor = DataProcessor()\n df_test = data_processor.create_user_click_sequence(\n start_date=config[\"test_split_date\"]\n )\n df_test[\"truths\"] = df_test[\"merchant_seq\"].apply(lambda x: list(set(x)))\n truth_dict = dict(zip(df_test[\"user_id\"], df_test[\"truths\"]))\n\n # get model\n print(\"model training...\")\n model = Merchant2VecModel()\n model.train()\n\n # compute mAP@k\n k = model.num_rec\n all_truths, all_preds = [], []\n for user_id, user_merchants in truth_dict.items():\n this_pred = model.generate_predictions(\n user_id=user_id, eval_date=config[\"test_split_date\"]\n )\n all_truths.append(user_merchants)\n all_preds.append(this_pred)\n score = mapk(all_truths, all_preds, k)\n print(\"mAP@{} for current model: {:.4f}\".format(k, score))","def evaluate(self, test_data, test_labels):\n raise NotImplementedError","def model_evaluate(model,x_train,n_y_array,x_val, vald_array):\n\n scores = model.evaluate(x_train, n_y_array, verbose=1)\n\n scores2 = model.evaluate(x_val, vald_array, verbose=1)\n\n\n print(\"for traininf set\")\n\n print(\"%s: %.2f%%\" % (model.metrics_names[1], scores[1]*100))\n\n print(\"%s: %.2f%%\" % (model.metrics_names[0], scores[0]))\n\n\n\n print(\"for validation set : \") \n\n print(\"%s: %.2f%%\" % (model.metrics_names[1], scores2[1]*100))\n\n print(\"%s: %.2f%%\" % (model.metrics_names[0], scores2[0]))","def evaluate(self, train_set=\"train_set\", test_set=\"test_set\", targets=\"targets\", k=10):\n\n test_set = self.cache.fetch(test_set) if isinstance(test_set, str) else test_set\n\n # Predict\n preds = self.run(dataset=train_set, targets=targets, k=k)\n\n # Evaluate model\n print(\"evaluating model ...\")\n score = evaluate(preds, test_set)\n print(\"MAP@{}: {:.5f}\\n\".format(k, score))\n\n return score","def evaluate(self):\n\n\t\t## We should be evaluating on dev dataset as well, so commenting x_test\n\t\t#self.model_score = self.model.evaluate(self.x_test, self.y_test_oh, batch_size=2048)\n\t\tself.model_score = self.model.evaluate(self.x_dev, self.y_dev_oh, batch_size=2048)\n\t\tprint(\"%s score = %f\\n\" %(self.modelName, self.model_score[1]))\n\n\t\t##Saving atucal vs predicted predictions\n\t\t##np.argmax returns the index where it see's 1 in the row\n\t\t#y_pred = np.argmax(self.model.predict(self.x_test, batch_size=2048), axis=1)\n\t\ty_pred = np.argmax(self.model.predict(self.x_dev, batch_size=2048), axis=1)\n\n\t\t## vstack will stack them in 2 rows, so we use Trasnpose to get them in column stack\n\t\t#output_predict = np.vstack((np.argmax(self.y_test_oh, axis=1), y_pred)).T\n\t\toutput_predict = np.vstack((np.argmax(self.y_dev_oh, axis=1), y_pred)).T\n\t\toutputFile = self.resultDir + \"/outputPredict.csv\" \n\t\tnp.savetxt(outputFile, output_predict, fmt=\"%5.0f\", delimiter=\",\")\n\n\t\t##Error Analysis of the prediction\n\t\terrorAnalysis(outputFile)\n\n\t\treturn self.model_score","def evaluate_model(model, X_test, Y_test, category_names): \n # predict on the X_test\n y_pred = model.predict(X_test)\n \n # build classification report on every column\n performances = []\n for i in range(len(category_names)):\n performances.append([f1_score(Y_test.iloc[:, i].values, y_pred[:, i], average='micro'),\n precision_score(Y_test.iloc[:, i].values, y_pred[:, i], average='micro'),\n recall_score(Y_test.iloc[:, i].values, y_pred[:, i], average='micro')])\n # build dataframe\n performances = pd.DataFrame(performances, columns=['f1 score', 'precision', 'recall'],\n index = category_names) \n return performances","def evaluate_model(model, X_test, Y_test): \n #Make predictions with the model\n Y_pred = model.predict(X_test)\n #convert numpy output to dataframe and add columns\n Y_pred_df = pd.DataFrame(Y_pred)\n Y_pred_df.columns = Y_test.columns\n #Convert predictions and correct y values to float for faciliate comparison\n Y_pred_df = Y_pred_df.astype('float64')\n Y_test = Y_test.astype('float64')\n print_score(Y_test, Y_pred_df, 'weighted avg')","def evaluate_model(model, testset):\n\n # Sort data by top level label to ease inspection\n testset = testset.sort_using_layer(-1, reverse=True)\n\n # Feed the samples to the model to obtain each layers' activations\n v = testset.get_layer(0)\n hs = model.transform(v)[1:]\n\n # Read model weights\n ws = [params['w'] for params in model.parameters]\n del params\n\n # Take the (hidden) labels from the data set\n ls = testset.get_layers()[1:]\n\n # In each layer, reorder and invert neurons to match best with the labels\n for i in range(len(ls)):\n hs[i], ws[i] = align_with_labels(ls[i], hs[i], ws[i])\n del i\n\n # Measure correlations, etcetera\n metrics = compare(ls, hs)\n\n # Simply return a dict with all used variables\n return locals()","def evaluate(cfg: DictConfig):\n\n experiments = cfg.get('experiment_type', f'{cfg.model.name}_only')\n fixed_t0 = cfg.get('fixed_t0', False)\n ext = '_fixedT0' if fixed_t0 else ''\n\n base_dir = cfg.device.root\n datasource = cfg.datasource.name\n\n if experiments == 'ablations':\n models = {\n 'FluxRGNN': ['final',\n 'final_without_encoder',\n 'final_without_boundary'],\n 'LocalLSTM': ['final']\n }\n elif experiments == 'final':\n models = {\n 'FluxRGNN': ['final'],\n 'GAM': ['final'],\n 'HA': ['final'],\n 'GBT': ['final']\n }\n else:\n m = cfg.model.name\n year = cfg.datasource.test_year\n\n # find all experiments available for this model, datasource and test year\n result_dir = osp.join(base_dir, 'results', datasource, m, f'test_{year}')\n models = {\n m : [ f.name for f in os.scandir(result_dir) if f.is_dir() ]\n }\n\n\n # thresholds for binary classification metrics\n if cfg.datasource.name == 'abm':\n thresholds = [0.0019, 0.0207]\n else:\n thresholds = [0, 10, 20]\n\n rmse_per_hour = []\n mae_per_hour = []\n pcc_per_hour = []\n bin_per_hour = []\n\n rmse_per_night = []\n mae_per_night = []\n\n output_dir = osp.join(base_dir, 'results', datasource, f'performance_evaluation{ext}', experiments)\n os.makedirs(output_dir, exist_ok=True)\n\n counter = 0\n\n for m, dirs in models.items():\n print(f'evaluate {m}')\n\n for d in dirs:\n result_dir = osp.join(base_dir, 'results', datasource, m, f'test_{cfg.datasource.test_year}', d)\n\n # check if directory exists\n if os.path.isdir(result_dir):\n results, model_cfg = load_cv_results(result_dir, trials=cfg.task.repeats, ext=ext)\n\n df_prep = pd.read_csv(osp.join(base_dir, 'data', 'preprocessed',\n f'{model_cfg[\"t_unit\"]}_{model_cfg[\"model\"][\"edge_type\"]}_ndummy={model_cfg[\"datasource\"][\"n_dummy_radars\"]}',\n datasource, cfg.season, str(cfg.datasource.test_year), 'dynamic_features.csv'))\n tidx2night = dict(zip(df_prep.tidx, df_prep.nightID))\n\n rmse_per_hour.append(compute_rmse(m, d, results, tidx2night, groupby=['horizon', 'trial'],\n threshold=0, km2=True, fixed_t0=fixed_t0))\n mae_per_hour.append(compute_mae(m, d, results, tidx2night, groupby=['horizon', 'trial'],\n threshold=0, km2=True, fixed_t0=fixed_t0))\n pcc_per_hour.append(compute_pcc(m, d, results, tidx2night, groupby=['horizon', 'trial'],\n threshold=0, km2=True, fixed_t0=fixed_t0))\n\n if fixed_t0:\n rmse_per_night.append(compute_rmse_per_night(m, d, results, tidx2night, groupby=['night_horizon', 'trial']))\n mae_per_night.append(compute_mae_per_night(m, d, results, tidx2night, groupby=['night_horizon', 'trial']))\n\n # compute binary classification measures\n for thr in thresholds:\n bin_per_hour.append(compute_bin(m, d, results, groupby=['horizon', 'trial'], threshold=thr, km2=True))\n\n counter += 1\n\n else:\n print(f'Experiment \"{d}\" for model \"{m}\" and datasource \"{datasource}\" is not available. '\n f'Use \"run_experiments.py model={m} datasource={datasource} +experiment={d}\" to run this experiment.')\n\n if counter > 0:\n rmse_per_hour = pd.concat(rmse_per_hour)\n rmse_per_hour.to_csv(osp.join(output_dir, f'rmse_per_hour.csv'))\n\n mae_per_hour = pd.concat(mae_per_hour)\n mae_per_hour.to_csv(osp.join(output_dir, f'mae_per_hour.csv'))\n\n pcc_per_hour = pd.concat(pcc_per_hour)\n pcc_per_hour.to_csv(osp.join(output_dir, f'pcc_per_hour.csv'))\n\n bin_per_hour = pd.concat(bin_per_hour)\n bin_per_hour.to_csv(osp.join(output_dir, f'bin_per_hour.csv'))\n\n if fixed_t0:\n rmse_per_night = pd.concat(rmse_per_night)\n rmse_per_night.to_csv(osp.join(output_dir, f'rmse_per_night.csv'))\n\n mae_per_night = pd.concat(mae_per_night)\n mae_per_night.to_csv(osp.join(output_dir, f'mae_per_night.csv'))","def test(self, dataset):\n test_accuracy = 0\n test_loss = 0\n num_examples_tested = 0\n # Put model into evaluation mode\n self.model.eval()\n for num, batch in enumerate(dataset.loader):\n xs, ys = batch\n batch_size = len(xs)\n num_examples_tested += batch_size\n iloss, iaccuracy = self.model(xs, ys)\n test_loss += iloss.cpu().data.numpy().item() * batch_size\n test_accuracy += iaccuracy.cpu().data.numpy().item() * batch_size\n test_accuracy = test_accuracy / num_examples_tested\n test_loss = test_loss / num_examples_tested\n # Return accuracy and loss for this model on the test set\n return test_accuracy, test_loss","def evaluate_model(model, X_train, y_train, X_test, y_test):\n model = model\n model.fit(X_train, y_train)\n\n y_pred = model.predict(X_test)\n\n report = classificationreport(y_test, y_pred, target_names= [\"0\", \"1\"], output_dict=True)\n\n return report","def evaluate(model, test_files):\n print(\"Running predictions.\")\n models = load_model(model)\n predictions = predict(models, test_files)\n\n # # write predictions to file\n # write_predictions(\"evaluate_out.json\",predictions)\n evaluate_individual(predictions, test_files, models)\n evaluate_overall(predictions)","def test_eval(model, test_set):\n num_test_batch = len(test_set)\n test_loss = np.zeros((num_test_batch, 1), dtype=float)\n test_acc = np.zeros((num_test_batch, 1), dtype=float)\n for ibatch, batch in enumerate(test_set):\n result = model.test_on_batch({'input':batch[0]}, {'fp1':batch[1], 'fp2':batch[1], 'fp3':batch[1], 'ave':batch[1]})\n test_loss[ibatch] = result[0]\n test_acc[ibatch] = result[-1]\n return np.mean(test_loss), np.mean(test_acc)","def test(self):\n y_list = []\n y_hat_list = []\n for ex_dict in ut.TEST_LIST:\n y_list.append(ex_dict[1])\n y_hat_list.append(self.predict(ex_dict[0]))\n acc = ut.compute_accuracy(y_hat_list, y_list)\n return y_hat_list, acc","def evaluate_model(model, X_test, Y_test, category_names):\n\n y_pred = model.predict(X_test)\n Y_test_as_array = np.array(Y_test)\n for i in range(len(category_names)):\n print(\"{} accuracy {} precision {} recall {} f1 {}\".format(\n category_names[i],\n (y_pred[:, i] == Y_test_as_array[:, i]).mean(), # accuracy\n precision_score(Y_test_as_array[:, i], y_pred[:, i], average=None), # precision\n recall_score(Y_test_as_array[:, i], y_pred[:, i], average=None), # recall\n f1_score(Y_test_as_array[:, i], y_pred[:, i], average=None) # f1\n ))\n print(\"mean accuracy {}\".format((y_pred == Y_test_as_array).mean().mean()))","def run_evaluate(self, test):\n accs = []\n correct_preds, total_correct, total_preds = 0., 0., 0.\n for words, labels in minibatches(test, self.config.batch_size):\n labels_pred, sequence_lengths = self.predict_batch(words)\n\n for lab, lab_pred, length in zip(labels, labels_pred,\n sequence_lengths):\n lab = lab[:length]\n lab_pred = lab_pred[:length]\n accs += [a==b for (a, b) in zip(lab, lab_pred)]\n\n lab_chunks = set(get_chunks(lab, self.config.vocab_tags))\n lab_pred_chunks = set(get_chunks(lab_pred,\n self.config.vocab_tags))\n\n correct_preds += len(lab_chunks & lab_pred_chunks)\n total_preds += len(lab_pred_chunks)\n total_correct += len(lab_chunks)\n\n p = correct_preds / total_preds if correct_preds > 0 else 0\n r = correct_preds / total_correct if correct_preds > 0 else 0\n f1 = 2 * p * r / (p + r) if correct_preds > 0 else 0\n acc = np.mean(accs)\n\n return {\"acc\": 100*acc, \"f1\": 100*f1}","def evaluate(self, X_test, y_test):\n pipeline = run()\n y_pred = pipeline.predict(X_test)\n rmse = compute_rmse(y_pred, y_test)\n print(rmse)\n return rmse","def evaluate(self, X_test, y_test):\n y_pred_train = self.pipeline.predict(self.X)\n mse_train = mean_squared_error(self.y, y_pred_train)\n rmse_train = np.sqrt(mse_train)\n \n self.mlflow_log_metric('rmse_train', rmse_train)\n \n y_pred_test = self.pipeline.predict(X_test)\n mse_test = mean_squared_error(y_test, y_pred_test)\n rmse_test = np.sqrt(mse_test)\n self.mlflow_log_metric('rmse_test', rmse_test)\n \n return (round(rmse_train, 3) ,round(rmse_test, 3))","def evaluate_model(sess, model, data_set):\n total_cost = 0.0\n total_r_cost = 0.0\n total_kl_cost = 0.0\n for batch in range(data_set.num_batches):\n unused_orig_x, x, s = data_set.get_batch(batch)\n feed = {model.input_data: x, model.sequence_lengths: s}\n (cost, r_cost,\n kl_cost) = sess.run([model.cost, model.r_cost, model.kl_cost], feed)\n total_cost += cost\n total_r_cost += r_cost\n total_kl_cost += kl_cost\n\n total_cost /= (data_set.num_batches)\n total_r_cost /= (data_set.num_batches)\n total_kl_cost /= (data_set.num_batches)\n return (total_cost, total_r_cost, total_kl_cost)","def test(self):\n for data_tier in self.data_tiers:\n tot = len(self.preprocessed_data[data_tier]['features'])\n p = int(math.floor(tot*0.2))\n test_features = np.array(self.preprocessed_data[data_tier]['features'][p:])\n trend_test_classifications = np.array(self.preprocessed_data[data_tier]['trend_classifications'][p:])\n avg_test_classifications = np.array(self.preprocessed_data[data_tier]['avg_classifications'][p:])\n accuracy_trend = self.clf_trend[data_tier].score(test_features, trend_test_classifications)\n accuracy_avg = self.clf_avg[data_tier].score(test_features, avg_test_classifications)\n self.logger.info('The accuracy of %s trend classifier for data tier %s is %.3f', self.name, data_tier, accuracy_trend)\n self.logger.info('The accuracy of %s avg regressor for data tier %s is %.3f', self.name, data_tier, accuracy_avg)","def evaluate(self, test_dir='data/dev', target='real'):\n test_data = {c: os.path.join(test_dir, c) for c in self.classes}\n if not target in test_data:\n print('Error: target class does not exist in test data.')\n return\n outcomes = {'TP': 0, 'TN': 0, 'FP': 0, 'FN': 0}\n # >>> YOUR ANSWER HERE\n data = []\n for c in test_data:\n docs = open(test_data[c]).readlines()\n for doc in docs:\n preprocess_doc = doc.strip()\n data.append((c, preprocess_doc))\n for item in data:\n predict_ans = self.predict(item[1])\n if item[0] == 'real':\n if predict_ans == 'real':\n outcomes['TP'] += 1\n else:\n outcomes['FN'] += 1\n else:\n if predict_ans == 'real':\n outcomes['FP'] += 1\n else:\n outcomes['TN'] += 1\n precision = outcomes['TP'] / (outcomes['TP'] + outcomes['FP']) # replace with equation for precision\n recall = outcomes['TP'] / (outcomes['TP'] + outcomes['FN']) # replace with equation for recall\n f1_score = 2 * ((precision * recall) / (precision + recall)) # replace with equation for f1\n # >>> END YOUR ANSWER\n return precision, recall, f1_score","def _evaluate(self, train_x, train_y, test_x, test_y, n_targets, name):\n r_temp = {}\n for metric_name in self.metrics:\n r_temp.update({f\"{metric_name}_Model\": name, f\"{metric_name}_Sum\": 0,\n f\"{metric_name}_Min\": 1000000, f\"{metric_name}_Max\": 0})\n\n for i in range(self.repetitions):\n is_nan = True\n while (is_nan):\n model = self.get_model(train_x.shape[1], n_targets)\n model.fit(train_x, train_y, **self.fit_kwargs)\n result = model.predict(test_x)\n is_nan = np.any(np.isnan(result))\n del model\n\n for metric_name in self.metrics:\n metric = self.get_metrics(metric_name)\n value = metric(result, test_y)\n r_temp[f\"{metric_name}_Sum\"] += value\n if r_temp[f\"{metric_name}_Min\"] > value:\n r_temp[f\"{metric_name}_Min\"] = value\n if r_temp[f\"{metric_name}_Max\"] < value:\n r_temp[f\"{metric_name}_Max\"] = value\n keras.backend.clear_session()\n for metric_name in self.metrics:\n r_temp[f\"{metric_name}_Mean\"] = r_temp[f\"{metric_name}_Sum\"] / self.repetitions\n return r_temp","def evaluate_model(model, X_test, y_test, category_names):\n # Predict for test set\n y_pred = model.predict(X_test)\n \n print(\"**** Scores for each category *****\\n\")\n for i in range(36):\n print(\"Scores for '{}':\".format(category_names[i]))\n print(classification_report(y_test.values[:,i], y_pred[:,i]))","def eval_performance(weights, test_y, test_x):\n y_predicted = predict_labels(weights, test_x)\n accuracy = len(y_predicted[y_predicted == test_y]) / len(y_predicted)\n return accuracy","def evaluate_model(model, X_test, y_test, category_names):\n y_pred = model.predict(X_test)\n labels = np.unique(y_pred)\n print(labels)\n #print out score for each class and mean scores, including precision, recall, f1 score\n print(classification_report(y_test.values, y_pred, target_names=category_names.values))","def evaluate(\n self,\n num_samples: int = 10,\n report_every: int = 100,\n train_or_test: str = \"test\",\n ) -> None:\n # asset train or test valid\n assert train_or_test in [\"train\", \"test\"]\n\n # set device and num_gpus\n num_gpus = num_devices()\n device = torch_device()\n torch.backends.cudnn.benchmark = True if cuda.is_available() else False\n\n # init model with gpu (or not)\n self.model.to(device)\n if num_gpus > 1:\n self.model = nn.DataParallel(model)\n self.model.eval()\n\n # set train or test\n ds = (\n self.dataset.test_ds\n if train_or_test == \"test\"\n else self.dataset.train_ds\n )\n\n # set num_samples\n ds.dataset.num_samples = num_samples\n print(\n f\"{len(self.dataset.test_ds)} samples of {self.dataset.test_ds[0][0][0].shape}\"\n )\n\n # Loop over all examples in the test set and compute accuracies\n ret = dict(\n infer_times=[],\n video_preds=[],\n video_trues=[],\n clip_preds=[],\n clip_trues=[],\n )\n report_every = 100\n\n # inference\n with torch.no_grad():\n for i in range(\n 1, len(ds)\n ): # [::10]: # Skip some examples to speed up accuracy computation\n if i % report_every == 0:\n print(\n f\"Processsing {i} of {len(self.dataset.test_ds)} samples..\"\n )\n\n # Get model inputs\n inputs, label = ds[i]\n inputs = inputs.to(device, non_blocking=True)\n\n # Run inference\n start_time = time()\n outputs = self.model(inputs)\n outputs = outputs.cpu().numpy()\n infer_time = time() - start_time\n ret[\"infer_times\"].append(infer_time)\n\n # Store results\n ret[\"video_preds\"].append(outputs.sum(axis=0).argmax())\n ret[\"video_trues\"].append(label)\n ret[\"clip_preds\"].extend(outputs.argmax(axis=1))\n ret[\"clip_trues\"].extend([label] * num_samples)\n\n print(\n f\"Avg. inference time per video ({len(ds)} clips) =\",\n round(np.array(ret[\"infer_times\"]).mean() * 1000, 2),\n \"ms\",\n )\n print(\n \"Video prediction accuracy =\",\n round(accuracy_score(ret[\"video_trues\"], ret[\"video_preds\"]), 2),\n )\n print(\n \"Clip prediction accuracy =\",\n round(accuracy_score(ret[\"clip_trues\"], ret[\"clip_preds\"]), 2),\n )\n return ret","def evaluate_model(valp):\n\n a = valp.predict(data_inputs[\"Test\"], [], new=True)[0]\n\n m2e = np.mean(mse(a[\"o0\"], data_outputs[\"Test\"][\"o0\"]))\n acc = 1 - acc_err(a[\"o1\"][:, 0], np.argmax(data_outputs[\"Test\"][\"o1\"], axis=1))\n i_d = 50-np.mean(inception_score(a[\"o2\"][:100]))\n\n return np.array([m2e, acc, i_d])","def run_evaluate(self, test):\n accs = []\n correct_preds, total_correct, total_preds = 0., 0., 0.\n for words, labels in minibatches(test, self.config.batch_size):\n labels_pred, sequence_lengths = self.predict_batch(words)\n\n for lab, lab_pred, length in zip(labels, labels_pred,\n sequence_lengths):\n lab = lab[:length]\n lab_pred = lab_pred[:length]\n accs += [a==b for (a, b) in zip(lab, lab_pred)]\n\n lab_chunks = set(get_chunks(lab, self.config.vocab_tags))\n lab_pred_chunks = set(get_chunks(lab_pred,\n self.config.vocab_tags))\n\n correct_preds += len(lab_chunks & lab_pred_chunks)\n total_preds += len(lab_pred_chunks)\n total_correct += len(lab_chunks)\n\n p = correct_preds / total_preds if correct_preds > 0 else 0\n r = correct_preds / total_correct if correct_preds > 0 else 0\n f1 = 2 * p * r / (p + r) if correct_preds > 0 else 0\n acc = np.mean(accs)\n print('*'*20, '\\n')\n print('precision:', p, 'recall:', r, 'f1:', f1, '\\n')\n print('*'*20)\n\n return {\"acc\": 100*acc, \"f1\": 100*f1}","def evaluate(model, eval_data, num_labels): \n # Turn on the evaluation state to ignore dropouts\n model.eval()\n results = [predict(model, x) for x, y in eval_data]\n f1_score, accuracy = get_metrics(np.array([y for x, y in eval_data]), results, num_labels)\n return f1_score, accuracy","def test_model_performance(model_es,test_file):\n test_label = get_test_label(test_file)\n result = model_es.predict(input_fn = lambda :input_fn(test_file,1,False,100,True))\n predict_list = []\n for one_res in result:\n if \"probabilities\" in one_res:\n predict_list.append(one_res['probabilities'][1])\n get_auc(predict_list,test_label)","def test(self):\n with torch.no_grad():\n self.model.eval()\n p10_forecast, p10_forecast, p90_forecast, target = None, None, None, None\n\n t = time()\n for step, sample in enumerate(self.test_loader):\n\n # Hide future predictions from input vector, set to 0 (or 1) values where timestep > encoder_steps\n steps = self.cnf.all_params['num_encoder_steps']\n pred_len = sample['outputs'].shape[1]\n x = sample['inputs'].float().to(self.cnf.device)\n x[:, steps:, 0] = 1\n\n # Feed input to the model\n if self.cnf.all_params[\"model\"] == \"transformer\" or self.cnf.all_params[\"model\"] == \"grn_transformer\":\n\n # Auto-regressive prediction\n for i in range(pred_len):\n output = self.model.forward(x)\n x[:, steps + i, 0] = output[:, i, 1]\n output = self.model.forward(x)\n\n elif self.cnf.all_params[\"model\"] == \"tf_transformer\":\n output, _, _ = self.model.forward(x)\n else:\n raise NameError\n\n output = output.squeeze()\n y, y_pred = sample['outputs'].squeeze().float().to(self.cnf.device), output\n\n # Compute loss\n loss, _ = self.loss(y_pred, y)\n smape = symmetric_mean_absolute_percentage_error(output[:, :, 1].detach().cpu().numpy(),\n sample['outputs'][:, :, 0].detach().cpu().numpy())\n\n # De-Normalize to compute metrics\n target = unnormalize_tensor(self.data_formatter, y, sample['identifier'][0][0])\n p10_forecast = unnormalize_tensor(self.data_formatter, y_pred[..., 0], sample['identifier'][0][0])\n p50_forecast = unnormalize_tensor(self.data_formatter, y_pred[..., 1], sample['identifier'][0][0])\n p90_forecast = unnormalize_tensor(self.data_formatter, y_pred[..., 2], sample['identifier'][0][0])\n\n # Compute metrics\n self.test_losses['p10'].append(self.loss.numpy_normalised_quantile_loss(p10_forecast, target, 0.1))\n self.test_losses['p50'].append(self.loss.numpy_normalised_quantile_loss(p50_forecast, target, 0.5))\n self.test_losses['p90'].append(self.loss.numpy_normalised_quantile_loss(p90_forecast, target, 0.9))\n\n self.test_loss.append(loss.item())\n self.test_smape.append(smape)\n\n # Plot serie prediction\n p1, p2, p3, target = np.expand_dims(p10_forecast, axis=-1), np.expand_dims(p50_forecast, axis=-1), \\\n np.expand_dims(p90_forecast, axis=-1), np.expand_dims(target, axis=-1)\n p = np.concatenate((p1, p2, p3), axis=-1)\n plot_temporal_serie(p, target)\n\n # Log stuff\n for k in self.test_losses.keys():\n mean_test_loss = np.mean(self.test_losses[k])\n print(f'\\t● AVG {k} Loss on TEST-set: {mean_test_loss:.6f} │ T: {time() - t:.2f} s')\n\n # log log log\n mean_test_loss = np.mean(self.test_loss)\n mean_smape = np.mean(self.test_smape)\n print(f'\\t● AVG Loss on TEST-set: {mean_test_loss:.6f} │ T: {time() - t:.2f} s')\n print(f'\\t● AVG SMAPE on TEST-set: {mean_smape:.6f} │ T: {time() - t:.2f} s')","def evaluate(self, X_test, y_test):\n \n y_pred = self.pipeline.predict(X_test)\n test_rmse = compute_rmse(y_pred, y_test)\n print(\"test rmse:\", test_rmse)\n return test_rmse","def test(self, idx_test):\n self.eval()\n output = self.predict()\n # output = self.output\n loss_test = F.nll_loss(output[idx_test], self.labels[idx_test])\n acc_test = utils.accuracy(output[idx_test], self.labels[idx_test])\n print(\"Test set results:\",\n \"loss= {:.4f}\".format(loss_test.item()),\n \"accuracy= {:.4f}\".format(acc_test.item()))\n return acc_test.item()","def evaluate(self, model, X_train, X_test, y_train, y_test):\n\n model.fit(X_train,y_train)\n y_pred = model.predict(X_test)\n R2 = r2_score(y_test, y_pred)\n MAE = round(mape(y_test, y_pred), 2)\n RMSE = round(rmse(y_test, y_pred), 2)\n\n res = {'Model': self.model, 'R2' : R2, 'MAPE': MAE, 'RMSE': RMSE}\n return res","def evaluate_model(model, X_test, Y_test, category_names):\n y_pred = pd.DataFrame(data = model.predict(X_test), columns = category_names)\n\n precision, recall, f1_score = [], [], []\n\n for category in category_names:\n scores = classification_report(Y_test[category], y_pred[category])\n precision.append([x for x in scores.strip().split(\"avg / total\")[1].strip().split(\" \") \n if len(x) > 0][:3][0])\n recall.append([x for x in scores.strip().split(\"avg / total\")[1].strip().split(\" \") \n if len(x) > 0][:3][1])\n \n model_metric = pd.concat([\n pd.DataFrame(data = [precision, recall], index = [\"precision\", \"recall\"], \n columns = category_names),\n (Y_test.reset_index() == y_pred.reset_index()).mean()[1:].to_frame(\"accuracy\").T\n ])\n\n for col in model_metric.columns:\n model_metric[col] = model_metric[col].astype(float)\n\n return model_metric","def eval_model(self, model):\n evaluation = model.evaluate(x=self.xt_test, y=self.yt_test)\n print(\"loss : \" + str(round(evaluation[0]*100, 2)) + \"%\")\n print(\"accuracy: \" + str(round(evaluation[1]*100, 2)) + \"%\")","def _evaluate_during_fit(self, test_loader, epoch):","def evaluate(self):\n # Method variables definition\n X_train, X_test, y_train, y_test = dm.reshape_y_set_split_data(self.datasetManager)\n featureScaleDependentVariables = self.datasetManager.params.featureScaleDependentVariables\n\n # Feature Scaling\n X_scaler, X_train = dm.do_feature_scaling(X_train)\n if featureScaleDependentVariables:\n y_scaler, y_train = dm.do_feature_scaling(y_train)\n else:\n y_scaler = None\n y_train = self.datasetManager.y_train\n \n self.X_scaler = X_scaler\n self.y_scaler = y_scaler\n\n # Training the SVR model on the training set\n regressor = SVR(kernel = 'rbf')\n regressor.fit(X_train, y_train.ravel())\n self.regressor = regressor\n\n # Predicting the Test set results\n self.y_pred = y_scaler.inverse_transform(regressor.predict(X_scaler.transform(X_test))) if featureScaleDependentVariables else regressor.predict(X_test)\n \n # Returning the process result : the regression type and the predicted dependent variables set\n return [\"Support Vector Regression\", self.get_r2_score(y_test, self.y_pred)]","def evaluate_model(model_name, y_true, y_pred):\n\n # Calculate performance metrics\n rmse_eval = evaluate_rmse(y_true, y_pred)\n mae_eval = evaluate_mae(y_true, y_pred) \n r2_eval = evaluate_r2(y_true, y_pred)\n\n # Print results\n print_evaluation(model_name, mae_eval, rmse_eval, r2_eval)","def evaluate_model(predictions_table: pd.DataFrame, ratings_table: pd.DataFrame,\n test_table: pd.DataFrame, viewed_table: pd.DataFrame,\n all_predictions_table: pd.DataFrame) -> Dict:\n\n viewed = viewed_table.to_numpy()\n predictions = predictions_table.to_numpy()\n all_predictions = all_predictions_table.to_numpy()\n ratings = ratings_table.to_numpy()\n test = test_table.to_numpy(copy=True)\n test_demeaned = test - np.mean(test, axis=1).reshape(-1, 1)\n test_set = test_table.apply(lambda x: x != 0.0).astype(int).to_numpy()\n\n result = dict()\n\n # Test set evaluation\n test_predictions = np.multiply(all_predictions, test_set)\n diff = np.subtract(test_predictions, test_demeaned)\n rmse = np.sqrt(np.mean(np.square(diff)))\n result.update({\"RMSE\": rmse})\n mae = np.mean(np.absolute(diff))\n result.update({\"MAE\": mae})\n\n # overall evaluation\n movies_recommended = set()\n i = 0\n for index, row in predictions_table.iterrows():\n if i > 10000: break\n else: i += 1\n\n labels = row.nlargest(20).keys().tolist()\n for movie in labels:\n movies_recommended.update(movie)\n\n result.update({\"Coverage\": len(movies_recommended)})\n\n return result","def evaluate_model(model, X_test, Y_test, category_names): \n \n Y_pred = model.predict(X_test)\n print(classification_report(Y_test, Y_pred))\n display_results(Y_test, Y_pred)","def score_model(self, model, test_training, test_target):\n\n target_prediction = model.predict(test_training)\n from sklearn.metrics import classification_report\n if(self.VERBOSE):\n print(classification_report(test_target, target_prediction))\n\n return [\n f1_score(test_target, target_prediction, average='weighted'),\n precision_score(test_target, target_prediction, average='weighted'),\n recall_score(test_target, target_prediction, average='weighted')\n ]","def estimatePerformance(self, model):\n Y_pred = model.computeLOO()\n #performance = self.measure.multiOutputPerformance(self.Y, Y_pred)\n #performance = self.measure.getPerformance(self.Y, Y_pred)\n #performance = measure_utilities.aggregate(performance)\n performance = self.measure(self.Y, Y_pred)\n self.predictions.append(Y_pred)\n return performance","def evaluate(self, X_test, y_test):\n y_pred = self.pipeline.predict(X_test)\n return compute_rmse(y_pred, y_test)","def evaluate_test(model, history, class_labels, train_X, test_X, train_y, test_y):\n train_loss, train_acc = model.evaluate(train_X, train_y, verbose=0)\n test_loss, test_acc = model.evaluate(test_X, test_y, verbose=0)\n print('Accuracy \\n Train: %.3f, Test: %.3f' % (train_acc, test_acc))\n print('Loss \\n Train: %.3f, Test: %.3f \\n' % (train_loss, test_loss))\n # plot loss during training\n plt.subplots_adjust(hspace = .5, wspace = 0.5)\n plt.subplot(211)\n plt.title('Loss', weight='bold')\n plt.plot(history.history['loss'], label='train')\n plt.plot(history.history['val_loss'], label='val')\n plt.legend()\n # plot accuracy during training\n plt.subplot(212)\n plt.title('Accuracy', weight='bold')\n plt.plot(history.history['acc'], label='train')\n plt.plot(history.history['val_acc'], label='val')\n plt.legend()\n plt.show()\n print('\\n')\n # predict probabilities for test set\n yhat_probs = model.predict(test_X, verbose=0)\n # predict classes for test set\n yhat_classes = model.predict_classes(test_X, verbose=0)\n # reduce to 1d array\n yhat_probs = yhat_probs[:, 0]\n yhat_classes = yhat_classes[:, 0]\n # calculate metrics\n report = metrics.classification_report(test_y, yhat_classes, target_names=class_labels)\n confusion_matrix = metrics.confusion_matrix(test_y, yhat_classes)\n plot_confusion_matrix(confusion_matrix, class_labels)\n print('\\n')\n return report","def evaluate_model(model, X_test, Y_test, category_names):\n# Print out Precision , recall F1_score and support for each column using classification_report function\n y_pred_test = model.predict(X_test)\n print(classification_report(Y_test, y_pred_test, target_names=category_names))","def evaluate(train, train_labels, test, test_labels):\n \n # Use the same model for each training set for now\n model = RandomForestClassifier(n_estimators = 100, \n random_state = 50, n_jobs = -1)\n \n train = train.replace({np.inf: np.nan, -np.inf: np.nan})\n test = test.replace({np.inf: np.nan, -np.inf:np.nan})\n \n feature_names = list(train.columns)\n \n # Impute the missing values\n imputer = Imputer(strategy = 'median', axis = 1)\n train = imputer.fit_transform(train)\n test = imputer.transform(test)\n \n cv_score = 1 * cross_val_score(model, train, train_labels, \n scoring = \"f1\", \n cv = 5)\n \n # Fit on the training data and make predictions\n model.fit(train, train_labels)\n preds = model.predict(test)\n \n # Calculate the performance\n f1 = f1_score(test_labels, preds)\n print('5-fold CV F1: {:.2f} with std: {:.2f}'.format(cv_score.mean(),cv_score.std()))\n print('Test F1: {:.2f}.'.format(f1))\n \n feature_importances = pd.DataFrame({'feature': feature_names, \n 'importance': model.feature_importances_})\n \n return preds, feature_importances","def test(self, test=False): \n if test == True:\n if os.path.exists(self.student_save_path):\n checkpoint = torch.load(self.student_save_path, map_location=self.device)\n else:\n raise ValueError('No file with the pretrained model selected')\n\n self.student_model.load_state_dict(checkpoint)\n self.student_model.eval()\n\n running_acc = 0\n with torch.no_grad():\n for data, label in self.testloader:\n data, label = data.to(self.device), label.to(self.device)\n\n student_logits, *student_activations = self.student_model(data)\n\n running_acc += utils.accuracy(student_logits.data, label)\n\n print(f\"Test accuracy: {running_acc / len(self.testloader)}\")\n return running_acc / len(self.testloader)","def evaluate_on_test_set(self, energy_threshold=80):\n losses = []\n accuracies = []\n codings = []\n codings_label = []\n losses_item = []\n test_loader = self.dm.get_test_set()\n N = 0\n gamma_sum = 0\n mu_sum = 0\n cov_mat_sum = 0\n\n # Change the model to evaluation mode\n self.model.eval()\n\n with torch.no_grad():\n # Create pytorch's train data_loader\n train_loader = self.dm.get_train_set()\n\n for i, data in enumerate(train_loader, 0):\n # transfer tensors to selected device\n train_inputs, _ = data[0].to(self.device), data[1].to(self.device)\n\n # forward pass\n code, x_hat, cosim, z, gamma = self.model(train_inputs)\n phi, mu, cov_mat = self.model.compute_params(z, gamma)\n\n batch_gamma_sum = gamma.sum(axis=0)\n\n gamma_sum += batch_gamma_sum\n mu_sum += mu * batch_gamma_sum.unsqueeze(-1) # keep sums of the numerator only\n cov_mat_sum += cov_mat * batch_gamma_sum.unsqueeze(-1).unsqueeze(-1) # keep sums of the numerator only\n\n N += train_inputs.shape[0]\n\n train_phi = gamma_sum / N\n train_mu = mu_sum / gamma_sum.unsqueeze(-1)\n train_cov = cov_mat_sum / gamma_sum.unsqueeze(-1).unsqueeze(-1)\n\n print(\"Train N:\", N)\n print(\"phi :\\n\", train_phi)\n print(\"mu :\\n\", train_mu)\n print(\"cov :\\n\", train_cov)\n\n # Calculate energy using estimated parameters\n\n train_energy = []\n train_labels = []\n train_z = []\n\n for i, data in enumerate(train_loader, 0):\n # transfer tensors to selected device\n train_inputs, train_inputs_labels = data[0].to(self.device), data[1]\n\n # forward pass\n code, x_hat, cosim, z, gamma = self.model(train_inputs)\n sample_energy, pen_cov_mat = self.model.estimate_sample_energy(z,\n train_phi,\n train_mu,\n train_cov,\n average_it=False,\n device=self.device)\n\n train_energy.append(sample_energy.cpu().numpy())\n train_z.append(z.cpu().numpy())\n train_labels.append(train_inputs_labels.numpy())\n\n train_energy = np.concatenate(train_energy, axis=0)\n train_z = np.concatenate(train_z, axis=0)\n train_labels = np.concatenate(train_labels, axis=0)\n\n test_energy = []\n test_labels = []\n test_z = []\n\n for data in test_loader:\n test_inputs, label_inputs = data[0].to(self.device), data[1]\n\n # forward pass\n code, x_hat, cosim, z, gamma = self.model(test_inputs)\n sample_energy, pen_cov_mat = self.model.estimate_sample_energy(z,\n train_phi,\n train_mu,\n train_cov,\n average_it=False,\n device=self.device)\n test_energy.append(sample_energy.cpu().numpy())\n test_z.append(z.cpu().numpy())\n test_labels.append(label_inputs.numpy())\n\n test_energy = np.concatenate(test_energy, axis=0)\n test_z = np.concatenate(test_z, axis=0)\n test_labels = np.concatenate(test_labels, axis=0)\n\n combined_energy = np.concatenate([train_energy, test_energy], axis=0)\n combined_labels = np.concatenate([train_labels, test_labels], axis=0)\n\n thresh = np.percentile(combined_energy, energy_threshold)\n print(\"Threshold :\", thresh)\n\n # Prediction using the threshold value\n pred = (test_energy > thresh).astype(int)\n groundtruth = test_labels.astype(int)\n\n accuracy = accuracy_score(groundtruth, pred)\n precision, recall, f_score, support = prf(groundtruth, pred, average='binary')\n\n print(f\"Accuracy:{accuracy}, \"\n f\"Precision:{precision}, \"\n f\"Recall:{recall}, \"\n f\"F-score:{f_score}, \"\n f\"\\nconfusion-matrix: {confusion_matrix(groundtruth, pred)}\")\n\n # switch back to train mode\n self.model.train()\n return accuracy, precision, recall, f_score, test_z, test_labels, combined_energy","def evaluate_performance(data_loader, model):\n acc = mx.metric.Accuracy()\n\n for idx, (data, label) in enumerate(data_loader):\n data = data.as_in_context(model.ctx)\n label = label.as_in_context(model.ctx)\n pred = model(data)\n pred = mx.nd.argmax(pred, axis=1)\n acc.update(label, pred)\n return acc.get()","def evaluate_model(args, eval_runs, warm_runs, metrics=['psnr', 'ssim', 'fps']):\n upsampler = Upsampler(args)\n if warm_runs > 0:\n print(\"Warming up for evaluation\")\n for i in range(warm_runs):\n print(\"Performing warm-up run\", str(i+1))\n for sequence in ['foliage', 'walk', 'calendar', 'city']:\n bix_dir = os.path.join(VID4_DIR, 'BIx4', sequence)\n upsampler.run_dir(bix_dir, reset=False)\n \n time = 0.\n psnrs = []\n ssims = []\n for i in range(eval_runs):\n run_psnrs = []\n run_ssims = []\n print(\"Performing evaluation run\", str(i+1))\n for sequence in ['foliage', 'walk', 'calendar', 'city']:\n bix_dir = os.path.join(VID4_DIR, 'BIx4', sequence)\n gt_dir = os.path.join(VID4_DIR, 'GT', sequence)\n print(\"Evaluating on\", bix_dir)\n time += upsampler.run_dir(bix_dir, reset=False)\n vid_psnrs, vid_ssims = _eval_sr_perf(os.path.join(bix_dir, 'up'), gt_dir)\n run_psnrs += vid_psnrs\n run_ssims += vid_ssims\n if i == eval_runs-1:\n with open(os.path.join(upsampler.get_model_dir(), \"psnr.txt\"), \"w\") as f:\n f.writelines(str(psnr) + '\\n' for psnr in run_psnrs)\n with open(os.path.join(upsampler.get_model_dir(), \"ssim.txt\"), \"w\") as f:\n f.writelines(str(ssim) + '\\n' for ssim in run_ssims)\n psnrs += run_psnrs\n ssims += run_ssims\n\n fps = VID4_LENGTH/ (time/eval_runs)\n return Performance(psnr=psnrs, ssim=ssims, fps=fps)","def assess_model(model, test_data, label):\n return model.score(test_data,label)","def evaluate(train: pd.DataFrame, test: pd.DataFrame, algorithm):\n\n model = algorithm(train)\n\n test_labels = test['Labels']\n\n predictions = predict_data(test, model)\n\n error = mean_square_error(predictions, test_labels)\n\n acc = accuracy(predictions, test_labels)\n\n return acc, error","def evaluate_model(model, X_test, Y_test, category_names):\n \n \n yPredictorTest = model.predict(X_test)\n \n for idx, col in enumerate(Y_test):\n print(col, classification_report(Y_test[col], yPredictorTest[:, idx]))","def test(self):\n self.load()\n bottleneck_features = np.load(self.feature_path)\n test = bottleneck_features['test']\n _, test_targets = load_dataset(self.image_path_test) \n predictions = [np.argmax(self.model.predict(np.expand_dims(feature, axis=0))) for feature in test]\n test_accuracy = 100*np.sum(np.array(predictions) == np.argmax(test_targets, axis=1))/len(predictions)\n print('{}, test accuracy: {:.4f}%'.format(self.name, test_accuracy))\n return test_accuracy","def test(self) -> None:\n\n self._predictions = self._lr.predict(self._X_test)","def evaluate_model(model, X_test, Y_test, category_names):\n y_pred = model.predict(X_test)\n print(classification_report(Y_test, y_pred, target_names=Y_test.keys()))","def compute(self) -> None:\n \n self.model.eval()\n \n with torch.no_grad():\n for (input, target, _) in self.loader:\n\n # self.model = self.model.train(False) # TEST @lacoupe\n output, _ = self.model(input)\n \n output = (output >= 0.5)\n \n for out, tar in zip(output, target):\n \n tar = bool(tar)\n \n if out and tar:\n self.confusion['true_positive'] += 1\n elif not out and not tar:\n self.confusion['true_negative'] += 1\n elif out and not tar:\n self.confusion['false_positive'] += 1\n elif not out and tar:\n self.confusion['false_negative'] += 1\n \n self.accuracy = (self.confusion['true_positive'] + self.confusion['true_negative']) \\\n / sum(list(self.confusion.values()))\n \n if (self.confusion['true_positive'] + self.confusion['false_positive']) == 0.:\n self.precision = 0.\n else:\n self.precision = self.confusion['true_positive'] \\\n / (self.confusion['true_positive'] + self.confusion['false_positive'])\n \n if (self.confusion['true_positive'] + self.confusion['false_negative']) == 0.:\n self.recall = 0.\n else:\n self.recall = self.confusion['true_positive'] \\\n / (self.confusion['true_positive'] + self.confusion['false_negative'])\n \n if (self.precision + self.recall) == 0.:\n self.f1_score = 0.\n else:\n self.f1_score = 2 * self.precision * self.recall / (self.precision + self.recall)","def evaluate_model(model, X_test_input, y_test_input):\r\n pred_class = [model.classes_[i] for i in model.predict_proba(X_test_input).argmax(axis=-1)]\r\n pred_accuracy = np.sum(np.array(y_test_input)==np.array(pred_class))/len(pred_class)\r\n return pred_class, pred_accuracy","def test(self, test_fn, eval_metrics):\n # Load gold and predict\n X, Y = self.load_dataset(test_fn)\n y = self.model.predict(X)\n\n # Get most probable predictions and flatten\n Y = RNN_model.consolidate_labels(self.transform_output_probs(Y).flatten())\n y = RNN_model.consolidate_labels(self.transform_output_probs(y).flatten())\n\n # Run evaluation metrics and report\n # TODO: is it possible to compare without the padding?\n ret = []\n for (metric_name, metric_func) in eval_metrics:\n ret.append((metric_name, metric_func(Y, y)))\n logging.debug(\"calculating {}\".format(ret[-1]))\n\n for (metric_name, metric_val) in ret:\n logging.info(\"{}: {:.4f}\".format(metric_name,\n metric_val))\n return Y, y, ret","def evaluate_model(model, X_test, Y_test, category_names):\n y_pred_grid = model.predict(X_test)\n print(\n classification_report(Y_test.values, y_pred_grid, target_names=category_names)\n )","def evaluate_model(model, X_test, Y_test, category_names):\n \n Y_pred = model.predict(X_test)\n \n print(classification_report(Y_test.values, Y_pred, target_names=category_names))","def test(args, model, device, data, target):\n model.eval()\n test_loss = 0\n correct = 0\n data, target = data.to(device), target.to(device)\n output = model(data)\n # Final result will be average of averages of the same size\n test_loss += F.nll_loss(output, target, reduction='mean').item()\n ppe.reporting.report({'val/loss': test_loss})\n pred = output.argmax(dim=1, keepdim=True)\n correct += pred.eq(target.view_as(pred)).sum().item()\n ppe.reporting.report({'val/acc': correct / len(data)})","def evaluate_model(model, X_test, Y_test, category_names):\n Y_prediction = model.predict(X_test)\n Y_prediction_df = pd.DataFrame(Y_prediction, columns=category_names)\n \n for col in category_names:\n print(f\"category:{col}\")\n print(classification_report(Y_test[col], Y_prediction_df[col]))\n print('------------------------------------------------------')\n \n accuracy = np.mean(Y_prediction == Y_test.values)\n print(f\"Accuracy: {accuracy:.2%}\")","def evaluate_model(model, X_test, Y_test, category_names):\n Y_pred = model.predict(X_test)\n Y_pred = pd.DataFrame(Y_pred, columns=category_names)\n \n # calculate summary stats on test data\n results = pd.DataFrame()\n for column_name in Y_pred.columns:\n col_report = classification_report(y_true=Y_test[[column_name]], y_pred=Y_pred[[column_name]], output_dict=True)\n accuracy = col_report['accuracy']\n precision = col_report['macro avg']['precision']\n recall = col_report['macro avg']['recall']\n results[column_name] = [accuracy, precision, recall]\n results.index = ['accuracy', 'precision', 'recall']\n results.mean(axis=1) \n \n # save results to local csv file\n model_name = type(model.best_params_['clf']).__name__\n avg_accuracy = results.mean(axis=1)['accuracy']\n avg_precision = results.mean(axis=1)['precision']\n avg_recall = results.mean(axis=1)['recall']\n params = model.best_params_\n stored_results = pd.DataFrame({'Model': [model_name], 'Accuracy': [avg_accuracy], 'Precision': [avg_precision], \n 'Recall': [avg_recall], 'Parameters': [params]})\n\n add_header = not os.path.isfile('models/model_results.csv')\n with open('models/model_results.csv', 'a') as f:\n stored_results.to_csv(f, header=add_header, index=False)","def evaluate(func, dset_path, model_path):\n dset = load_dataset(dset_path, 'trva', False)\n\n \"\"\"\n average class-based zero-shot accuracy\n \"\"\"\n scores = func(dset['Xte_unseen'], dset['Ste_unseen_gt'], model_path)\n preds = np.argmax(scores, 1)\n preds = dset['Cte_unseen'][preds]\n acc_zsl = compute_acc(dset['Lte_unseen'], preds)\n\n \"\"\"\n average class-based generalized zsl accuracy on seen test classes\n \"\"\"\n scores = func(dset['Xte_seen'], dset['Sall_gt'], model_path)\n preds = np.argmax(scores, 1)\n preds = dset['Call'][preds]\n acc_gzsl_seen = compute_acc(dset['Lte_seen'], preds)\n\n \"\"\"\n average class-based generalized zsl accuracy on unseen test classes\n \"\"\"\n scores = func(dset['Xte_unseen'], dset['Sall_gt'], model_path)\n preds = np.argmax(scores, 1)\n preds = dset['Call'][preds]\n acc_gzsl_unseen = compute_acc(dset['Lte_unseen'], preds)\n\n print 'ZSL accuracy: ', acc_zsl\n print 'Generalized ZSL accuracy on seen classes: ', acc_gzsl_seen\n print 'Generalized ZSL accuracy on unseen classes: ', acc_gzsl_unseen","def compute_test():\n model.eval()\n sets = list(features.keys())\n for dset, loaders in zip(sets, [train_loaders, val_loaders, test_loaders]):\n final_specific_loss = 0\n final_total_loss = 0\n for loader in loaders:\n loader_total_loss = 0\n loader_specific_loss = 0\n for data in loader:\n output = model(data.to(device))\n specific_loss = specific_loss_torch_geom(output, (data.pos, data.y),\n data.batch, batch_sizes[dset]).detach()\n loader_specific_loss += specific_loss\n loader_total_loss += torch.mean(specific_loss)\n # Average the loss over each loader\n loader_specific_loss /= len(loader)\n loader_total_loss /= len(loader)\n # Average the loss over the different loaders\n final_specific_loss += loader_specific_loss / len(loaders)\n final_total_loss += loader_total_loss / len(loaders)\n del output, loader_specific_loss\n\n print(\"Test set results \", dset, \": loss= {:.4f}\".format(final_total_loss))\n print(dset, \": \", final_specific_loss)\n print(\"Results in log scale\", np.log10(final_specific_loss.detach().cpu()),\n np.log10(final_total_loss.detach().cpu().numpy()))\n if args.wandb:\n wandb.run.summary[\"test results\"] = np.log10(final_specific_loss.detach().cpu())\n # free unnecessary data\n\n\n final_specific_numpy = np.log10(final_specific_loss.detach().cpu())\n del final_total_loss, final_specific_loss\n torch.cuda.empty_cache()\n return final_specific_numpy","def final_eval(self):\n # Test performance - Load best model\n self.load_model(self.best_model_path, model_type='best')\n logging.info(\"Loading best model after epoch: %d\" %\n self.train_info['epoch'])\n\n perf_file = path.join(self.model_dir, \"perf.json\")\n if self.slurm_id:\n parent_dir = path.dirname(path.normpath(self.model_dir))\n perf_dir = path.join(parent_dir, \"perf\")\n if not path.exists(perf_dir):\n os.makedirs(perf_dir)\n perf_file = path.join(perf_dir, self.slurm_id + \".json\")\n\n output_dict = {'model_dir': self.model_dir}\n for key, val in vars(self.args).items():\n output_dict[key] = val\n\n for split in ['dev', 'test']:\n logging.info('\\n')\n logging.info('%s' % split.capitalize())\n result_dict = self.eval_model(split, final_eval=True)\n if split != 'test':\n logging.info('Calculated F1: %.3f' % result_dict['fscore'])\n\n output_dict[split] = result_dict\n\n json.dump(output_dict, open(perf_file, 'w'), indent=2)\n\n logging.info(\"Final performance summary at %s\" % perf_file)\n sys.stdout.flush()","def test(args, model, lossfn, device, data, target):\n model.eval()\n test_loss = 0\n correct = 0\n data, target = data.to(device), target.to(device)\n output = model(data)\n # Final result will be average of averages of the same size\n test_loss += lossfn(output, target).item()\n ppe.reporting.report({\"val/loss\": test_loss})\n pred = output.argmax(dim=1, keepdim=True)\n correct += pred.eq(target.view_as(pred)).sum().item()\n ppe.reporting.report({\"val/acc\": correct / len(data)})","def evaluate(model_class, params, matches, valid_index, test_index,\n seasons_train, seasons_valid, seasons_test, eval_functions):\n model = model_class(**params)\n output = {}\n start = time()\n predictions = model.fit_predict(matches, seasons_train, seasons_valid, seasons_test)\n output['train_time'] = np.round((time() - start) / 60., 4)\n # TODO: Monitor train results\n for eval_set, index in zip(('valid', 'test'), (valid_index, test_index)):\n for eval_fun in eval_functions:\n output['{}_{}'.format(eval_set, eval_fun.__name__)] = np.round(eval_fun(predictions[index],\n matches['FTR'][index]), 4)\n output['{}_size'.format(eval_set)] = index.sum()\n output['model'] = model_class.__name__\n return {**params, **output}","def test(model, dataloader):\n model.eval()\n device = model.device\n time_start = time.time()\n batch_time = 0.0\n accuracy = 0.0\n all_prob, all_labels = [], []\n \n with torch.no_grad():\n for (batch_seqs, batch_seq_masks, batch_seq_segments, batch_labels) in dataloader:\n batch_start = time.time()\n seqs = batch_seqs.to(device) \n masks = batch_seq_masks.to(device)\n segments = batch_seq_segments.to(device)\n labels = batch_labels.to(device)\n\n _, _, probabilities = model(seqs, masks, segments, labels)\n accuracy += correct_predictions(probabilities, labels)\n batch_time += time.time() - batch_start\n all_prob.extend(probabilities[:, 1].cpu().numpy())\n all_labels.extend(batch_labels)\n batch_time /= len(dataloader)\n total_time = time.time() - time_start\n accuracy /= (len(dataloader.dataset))\n return batch_time, total_time, accuracy, roc_auc_score(all_labels, all_prob)","def evaluate(self, predicted_df):\n logging.info(\"Evaluating model: {}\".format(self.model_type))\n y_true = predicted_df[\"user_label\"].as_matrix()\n y_pred = predicted_df[\"label\"].as_matrix()\n\n scores_cols = [col for col in predicted_df.columns if col.startswith(\"scores_\")]\n print(\"scores_cols: {}\".format(scores_cols))\n\n y_pred_scores = predicted_df[scores_cols].copy().fillna(value=0).as_matrix()\n print(\"predicted scores: {}\".format(y_pred_scores))\n y_true_scores = []\n for lab in predicted_df[\"user_label\"]:\n trues = [0 for _ in range(len(scores_cols))]\n if \"scores_\"+lab in scores_cols:\n trues[scores_cols.index(\"scores_\"+lab)] = 1\n y_true_scores.append(trues)\n print(\"true scores: {}\".format(y_true_scores))\n y_true_scores = np.array(y_true_scores)\n\n performance = {\"model\": self.model_type, \"description\": self.description}\n if 'categorical_accuracy' in self.metrics:\n logging.info(\"Calculating categorical accuracy for {}\".format(self))\n performance['categorical_accuracy'] = sklearn.metrics.accuracy_score(y_true,\n y_pred) # np.mean(y_pred == y_true)\n if 'fmeasure' in self.metrics:\n logging.info(\"Calculating fmeasure for {}\".format(self))\n performance['fmeasure'] = sklearn.metrics.f1_score(y_true, y_pred, average=self.metrics_average)\n if 'MRR' in self.metrics:\n logging.info(\"Calculating MRR for {}\".format(self))\n performance['MRR'] = sklearn.metrics.label_ranking_average_precision_score(y_true_scores, y_pred_scores)\n logging.info(\"Calculated performance: {}\".format(performance))\n print(performance)\n return pd.DataFrame(performance, index=[0])","def evaluate_model(model, X_test, Y_test, category_names):\n y_pred = model.predict(X_test)\n # print the metrics\n for i, col in enumerate(category_names):\n print('{} category metrics: '.format(col))\n print(classification_report(Y_test.iloc[:,i], y_pred[:,i]))","def evaluate_model(model, X_test, Y_test, category_names):\n Y_pred=model.predict(X_test)\n acc=[]\n for i,c in enumerate(Y_test.columns):\n print(c)\n print(classification_report(Y_test[c], Y_pred[:,i]))\n acc.append(accuracy_score(Y_test[c], Y_pred[:,i]))\n print('Accuracy :',np.mean(acc))\n\n pass","def fit_test(self):","def evaluate(self):\n self.training = False","def evaluate(model, datagen, X_test, Y_test, batch_size, save_folder_path=None):\n\n print(\"[INFO] Evaluating model...\")\n\n scores = model.evaluate_generator(\n datagen.flow(X_test, Y_test, batch_size=batch_size),\n verbose=1)\n \n print(\"[INFO] Evaluation results:\\n{0}: {1:.2f}\\n{2}: {3:.2f}\".format(model.metrics_names[0], scores[0]*100, model.metrics_names[1], scores[1]*100))\n \n if save_folder_path is not None:\n # Write results to path\n assert os.path.isdir(save_folder_path) == True, \"Unable to save evaluation results, save_folder_path is not a folder\"\n eval_results_path = save_folder_path + \"/eval_results.txt\"\n eval_handle = open(eval_results_path, 'w')\n eval_handle.write(\"Model name: {}\\n\\n\".format(MODEL_NAME))\n eval_handle.write(\"Evaluation results:\\n{0}: {1:.2f}\\n{2}: {3:.2f}\".format(model.metrics_names[0], scores[0]*100, model.metrics_names[1], scores[1]*100))\n eval_handle.close()","def test(self):\n self.model.eval()\n\n for step, sample in enumerate(self.test_loader):\n x, _, _ = sample\n x = x.to(self.device)\n\n y_pred = self.model.forward(x)\n loss = nn.MSELoss()(y_pred, x)\n self.test_losses.append(loss.item())\n\n if step % (max(8, len(self.test_loader)) // 8) == 0:\n out_img = torch.cat([x[0], torch.clamp(y_pred[0], 0, 1)], dim=2)\n self.sw.add_image(tag=f'sample_{step}', img_tensor=out_img, global_step=self.epoch)\n\n # log average loss on test set\n mean_test_loss = np.mean(self.test_losses)\n self.test_losses = []\n print(f'\\t● AVG Loss on TEST-set: {mean_test_loss:.6f} │ patience: ', end='')\n self.sw.add_scalar(tag='test_loss', scalar_value=mean_test_loss, global_step=self.epoch)\n\n # save best model and update training patience\n if self.best_test_loss is None or mean_test_loss < self.best_test_loss:\n self.best_test_loss = mean_test_loss\n self.patience = conf.FX_PATIENCE\n torch.save(self.model.state_dict(), self.log_path / 'best.pth')\n else:\n self.patience = self.patience - 1\n print(f'{self.patience}/{conf.FX_PATIENCE}')\n\n if self.patience == 0:\n self.show_completion_msg()","def model_run(self, model, estimators):\n model.fit(self.X_train, self.y_train)\n y_score = model.predict(self.X_test)\n accu_train = np.sum(model.predict(self.X_train) == self.y_train) / self.y_train.size\n accu_test = np.sum(y_score == self.y_test) / self.y_test.size\n\n self.results.write(\"Model Results\\n\")\n self.results.write(\"Number of Estimators: \" + str(estimators) + \"\\n\")\n self.results.write(\"Accuracy on Train: \" + str(accu_train) + \"\\n\")\n self.results.write(\"Accuracy on Test: \" + str(accu_test) + \"\\n\")\n return model","def evaluate_model(model, X_test, Y_test, category_names):\n \n y_preds = model.predict(X_test)\n predictions = pd.DataFrame(data=y_preds, columns=Y_test.columns, index=Y_test.index)\n for col in Y_test.columns:\n print(classification_report(predictions[col],Y_test[col]))"],"string":"[\n \"def test_evaluate():\\n X_train, X_test, y_train, y_test = src.load()\\n clf, score = src.train(X_train, y_train)\\n test_score = src.evaluate(clf, X_test, y_test)\\n assert isinstance(test_score, float)\",\n \"def evaluate(self, test_x, test_y):\\n score = self._model.evaluate(test_x, test_y, verbose=self._verbose)\\n print(\\\"Test score: \\\", score[0])\\n print(\\\"Test accuracy: \\\", score[1])\",\n \"def evaluate(self):\\n predictions = self.model.predict(self.test[0])\\n accuracy = accuracy_score(self.test[1], predictions)\\n print(\\\"Accuracy:\\\", str(accuracy * 100) + \\\"%\\\")\\n self.plot_results(predictions)\",\n \"def evaluate_model(model, X_test, y_test):\\n # run prediction with test data\\n y_pred = model.predict(X_test)\\n\\n # print precision, recall and f1-score\\n i = 0\\n for col in y_test:\\n print('Evaluation for \\\"{}\\\": \\\\n {} \\\\n\\\\n'.format(col, classification_report(y_test[col], y_pred[:,i])))\\n i += 1\",\n \"def evaluate(self, test_data):\\n result = self.model.run(test_data)\\n self._save_result(result)\",\n \"def eval_perf_test(model, X_test, y_test):\\n\\n y_hat_test = model.predict(X_test)\\n\\n test_mae = metrics.mean_absolute_error(y_test, y_hat_test)\\n test_mse = metrics.mean_squared_error(y_test, y_hat_test)\\n test_rmse = np.sqrt(metrics.mean_squared_error(y_test, y_hat_test))\\n test_r = metrics.r2_score(y_test, y_hat_test)\\n\\n print('Evaluating Performance on Testing Data:\\\\n')\\n print(f'Test Mean Absolute Error: {test_mae:,.2f}')\\n print(f'Test Mean Squared Error: {test_mse:,.2f}\\\\n')\\n print(f'Test Root Mean Squared Error: {test_rmse:,.2f}')\\n print(f'Test R-Square Value: {round(test_r,2)}')\",\n \"def eval_perf_total(model, X_train, y_train, X_test, y_test):\\n\\n y_hat_train = model.predict(X_train)\\n y_hat_test = model.predict(X_test)\\n \\n train_mae = metrics.mean_absolute_error(y_train, y_hat_train)\\n train_mse = metrics.mean_squared_error(y_train, y_hat_train)\\n train_rmse = np.sqrt(metrics.mean_squared_error(y_train, y_hat_train))\\n train_r = metrics.r2_score(y_train, y_hat_train)\\n\\n print('Evaluating Performance on Training Data:\\\\n')\\n print(f' Train Mean Absolute Error: {train_mae:,.2f}')\\n print(f' Train Mean Squared Error: {train_mse:,.2f}\\\\n')\\n print(f'Train Root Mean Squared Error: {train_rmse:,.2f}')\\n print(f'Train R-Square Value: {round(train_r,2)}')\\n\\n print('\\\\n'+'---'*25+'\\\\n')\\n\\n test_mae = metrics.mean_absolute_error(y_test, y_hat_test)\\n test_mse = metrics.mean_squared_error(y_test, y_hat_test)\\n test_rmse = np.sqrt(metrics.mean_squared_error(y_test, y_hat_test))\\n test_r = metrics.r2_score(y_test, y_hat_test)\\n\\n print('Evaluating Performance on Testing Data:\\\\n')\\n print(f' Test Mean Absolute Error: {test_mae:,.2f}')\\n print(f' Test Mean Squared Error: {test_mse:,.2f}\\\\n')\\n print(f'Test Root Mean Squared Error: {test_rmse:,.2f}')\\n print(f'Test R-Square Value: {round(test_r,2)}')\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n\\n print(\\\"Testing Performance\\\")\\n print(classification_report(Y_test, model.predict(X_test), target_names=category_names))\\n\\n #Todo cat names\",\n \"def evaluate(self, test):\\r\\n self.logger.info(\\\"Testing model over test set\\\")\\r\\n metrics = self.run_evaluate(test)\\r\\n msg = \\\" - \\\".join([\\\"{} {:04.2f}\\\".format(k, v)\\r\\n for k, v in metrics.items()])\\r\\n self.logger.info(msg)\\r\\n return metrics\",\n \"def test(self):\\r\\n \\r\\n args = self.args\\r\\n model = self.model\\r\\n dataset = self.dataset\\r\\n \\r\\n dataset.set_split('test')\\r\\n batch_generator = generate_nmt_batches(dataset, \\r\\n batch_size=len(dataset), \\r\\n device=args.device)\\r\\n\\r\\n acc_sum = 0.0\\r\\n model.eval()\\r\\n \\r\\n for batch_index, batch_dict in enumerate(batch_generator):\\r\\n # step 1. compute the output\\r\\n if isinstance(model,NMTModelWithMLTM):\\r\\n y_pred = model(batch_dict['x_source'], \\r\\n batch_dict['x_source_mltm_vector'],\\r\\n batch_dict['x_source_length'], \\r\\n batch_dict['x_target'])\\r\\n else:\\r\\n y_pred = model(batch_dict['x_source'], \\r\\n batch_dict['x_source_length'], \\r\\n batch_dict['x_target'])\\r\\n\\r\\n acc_t = compute_accuracy(y_pred, batch_dict['y_target'], self.mask_index)\\r\\n acc_sum += acc_t\\r\\n \\r\\n return acc_sum / (batch_index+1)\",\n \"def evaluate(self, test):\\n self.logger.info(\\\"Testing model over test set\\\")\\n metrics = self.run_evaluate(test)\\n msg = \\\" - \\\".join([\\\"{} {:04.2f}\\\".format(k, v)\\n for k, v in metrics.items()])\\n self.logger.info(msg)\\n return metrics\",\n \"def eval_perf_train(model, X_train=None, y_train=None):\\n\\n # if X_train != None and y_train != None:\\n\\n y_hat_train = model.predict(X_train)\\n \\n train_mae = metrics.mean_absolute_error(y_train, y_hat_train)\\n train_mse = metrics.mean_squared_error(y_train, y_hat_train)\\n train_rmse = np.sqrt(metrics.mean_squared_error(y_train, y_hat_train))\\n train_r = metrics.r2_score(y_train, y_hat_train)\\n\\n print('Evaluating Performance on Training Data:\\\\n')\\n print(f'Train Mean Absolute Error: {train_mae:,.2f}')\\n print(f'Train Mean Squared Error: {train_mse:,.2f}\\\\n')\\n print(f'Train Root Mean Squared Error: {train_rmse:,.2f}')\\n print(f'Train R-Square Value: {round(train_r,2)}')\\n\\n # if X_test != None and y_test != None:\\n\\n # y_hat_test = model.predict(X_test)\\n\\n # test_mae = metrics.mean_absolute_error(y_test, y_hat_test)\\n # test_mse = metrics.mean_squared_error(y_test, y_hat_test)\\n # test_rmse = np.sqrt(metrics.mean_squared_error(y_test, y_hat_test))\\n # test_r = metrics.r2_score(y_test, y_hat_test)\\n\\n # print('Evaluating Performance on Testing Data:\\\\n')\\n # print(f'Test Mean Absolute Error: {test_mae:,.2f}')\\n # print(f'Test Mean Squared Error: {test_mse:,.2f}\\\\n')\\n # print(f'Test Root Mean Squared Error: {test_rmse:,.2f}')\\n # print(f'Test R-Square Value: {round(test_r,2)}')\",\n \"def evaluate(self, X_test, y_test):\\n self.run(self)\\n self.y_pred = self.pipeline.predict(X_test)\\n self.rmse = compute_rmse(self.y_pred, y_test)\",\n \"def evaluate_model(self, test_data, test_labels,verbose=2):\\n test_loss, test_acc = self.model.evaluate(test_data, test_labels, verbose=verbose)\\n return test_loss, test_acc\",\n \"def evaluate(X_test, y_test):\\n # batch size is 16 for evaluation\\n batch_size = 16\\n\\n # Load Model\\n model = load_model('model/model.h5')\\n return model.evaluate(X_test, y_test, batch_size, verbose = 1)\",\n \"def evaluate(self):\\n\\n\\t\\tself.model_score = self.model.evaluate(self.x_test, self.y_test, batch_size=2048)\\n\\t\\tprint(\\\"%s score = %f\\\\n\\\" %(self.modelName, self.model_score[1]))\\n\\t\\treturn self.model_score\",\n \"def model_evaluate(self, test):\\n features = {name: np.array(value) for name, value in test.items()}\\n labels = {name: features.pop(name) for name in self.label_names}\\n metrics = self.model.evaluate(x=features, y=labels, batch_size=5)\\n return metrics\",\n \"def test_evaluate(self):\\n # Check build does not raise errors\\n dataset = KDDCupDataset()\\n dataset.create_fixed_samples(\\n *self.data, samples_num=1, partition_sizes=self.partition_sizes)\\n dataset.set_current_sample(0)\\n model = self.MODEL(dataset, **self.model_arguments)\\n model.fit(training_epochs=50)\\n metric = model.evaluate('test')\\n self.assertLessEqual(0, metric)\\n self.assertGreaterEqual(1, metric)\",\n \"def evaluate(self, x_test, y_test, verbose=0):\\n\\n if self.model is None:\\n raise StandardError('Model is not built. Run build method or load model before fitting')\\n\\n test_results = self.model.evaluate(x_test,\\n y_test,\\n batch_size=self.batch_size,\\n verbose=verbose)\\n self.val_history = test_results\\n return test_results\",\n \"def evaluate(self, x_test, y_test, verbose=0):\\n\\n if self.model is None:\\n raise StandardError('Model is not built. Run build method or load model before fitting')\\n\\n test_results = self.model.evaluate(x_test,\\n y_test,\\n batch_size=self.batch_size,\\n verbose=verbose)\\n self.val_history = test_results\\n return test_results\",\n \"def evaluate(self, x_test, y_test, verbose=0):\\n\\n if self.model is None:\\n raise StandardError('Model is not built. Run build method or load model before fitting')\\n\\n test_results = self.model.evaluate(x_test,\\n y_test,\\n batch_size=self.batch_size,\\n verbose=verbose)\\n self.val_history = test_results\\n return test_results\",\n \"def evaluate_model_performance():\\n\\n config = load_config()\\n data_processor = DataProcessor()\\n df_test = data_processor.create_user_click_sequence(\\n start_date=config[\\\"test_split_date\\\"]\\n )\\n df_test[\\\"truths\\\"] = df_test[\\\"merchant_seq\\\"].apply(lambda x: list(set(x)))\\n truth_dict = dict(zip(df_test[\\\"user_id\\\"], df_test[\\\"truths\\\"]))\\n\\n # get model\\n print(\\\"model training...\\\")\\n model = Merchant2VecModel()\\n model.train()\\n\\n # compute mAP@k\\n k = model.num_rec\\n all_truths, all_preds = [], []\\n for user_id, user_merchants in truth_dict.items():\\n this_pred = model.generate_predictions(\\n user_id=user_id, eval_date=config[\\\"test_split_date\\\"]\\n )\\n all_truths.append(user_merchants)\\n all_preds.append(this_pred)\\n score = mapk(all_truths, all_preds, k)\\n print(\\\"mAP@{} for current model: {:.4f}\\\".format(k, score))\",\n \"def evaluate(self, test_data, test_labels):\\n raise NotImplementedError\",\n \"def model_evaluate(model,x_train,n_y_array,x_val, vald_array):\\n\\n scores = model.evaluate(x_train, n_y_array, verbose=1)\\n\\n scores2 = model.evaluate(x_val, vald_array, verbose=1)\\n\\n\\n print(\\\"for traininf set\\\")\\n\\n print(\\\"%s: %.2f%%\\\" % (model.metrics_names[1], scores[1]*100))\\n\\n print(\\\"%s: %.2f%%\\\" % (model.metrics_names[0], scores[0]))\\n\\n\\n\\n print(\\\"for validation set : \\\") \\n\\n print(\\\"%s: %.2f%%\\\" % (model.metrics_names[1], scores2[1]*100))\\n\\n print(\\\"%s: %.2f%%\\\" % (model.metrics_names[0], scores2[0]))\",\n \"def evaluate(self, train_set=\\\"train_set\\\", test_set=\\\"test_set\\\", targets=\\\"targets\\\", k=10):\\n\\n test_set = self.cache.fetch(test_set) if isinstance(test_set, str) else test_set\\n\\n # Predict\\n preds = self.run(dataset=train_set, targets=targets, k=k)\\n\\n # Evaluate model\\n print(\\\"evaluating model ...\\\")\\n score = evaluate(preds, test_set)\\n print(\\\"MAP@{}: {:.5f}\\\\n\\\".format(k, score))\\n\\n return score\",\n \"def evaluate(self):\\n\\n\\t\\t## We should be evaluating on dev dataset as well, so commenting x_test\\n\\t\\t#self.model_score = self.model.evaluate(self.x_test, self.y_test_oh, batch_size=2048)\\n\\t\\tself.model_score = self.model.evaluate(self.x_dev, self.y_dev_oh, batch_size=2048)\\n\\t\\tprint(\\\"%s score = %f\\\\n\\\" %(self.modelName, self.model_score[1]))\\n\\n\\t\\t##Saving atucal vs predicted predictions\\n\\t\\t##np.argmax returns the index where it see's 1 in the row\\n\\t\\t#y_pred = np.argmax(self.model.predict(self.x_test, batch_size=2048), axis=1)\\n\\t\\ty_pred = np.argmax(self.model.predict(self.x_dev, batch_size=2048), axis=1)\\n\\n\\t\\t## vstack will stack them in 2 rows, so we use Trasnpose to get them in column stack\\n\\t\\t#output_predict = np.vstack((np.argmax(self.y_test_oh, axis=1), y_pred)).T\\n\\t\\toutput_predict = np.vstack((np.argmax(self.y_dev_oh, axis=1), y_pred)).T\\n\\t\\toutputFile = self.resultDir + \\\"/outputPredict.csv\\\" \\n\\t\\tnp.savetxt(outputFile, output_predict, fmt=\\\"%5.0f\\\", delimiter=\\\",\\\")\\n\\n\\t\\t##Error Analysis of the prediction\\n\\t\\terrorAnalysis(outputFile)\\n\\n\\t\\treturn self.model_score\",\n \"def evaluate_model(model, X_test, Y_test, category_names): \\n # predict on the X_test\\n y_pred = model.predict(X_test)\\n \\n # build classification report on every column\\n performances = []\\n for i in range(len(category_names)):\\n performances.append([f1_score(Y_test.iloc[:, i].values, y_pred[:, i], average='micro'),\\n precision_score(Y_test.iloc[:, i].values, y_pred[:, i], average='micro'),\\n recall_score(Y_test.iloc[:, i].values, y_pred[:, i], average='micro')])\\n # build dataframe\\n performances = pd.DataFrame(performances, columns=['f1 score', 'precision', 'recall'],\\n index = category_names) \\n return performances\",\n \"def evaluate_model(model, X_test, Y_test): \\n #Make predictions with the model\\n Y_pred = model.predict(X_test)\\n #convert numpy output to dataframe and add columns\\n Y_pred_df = pd.DataFrame(Y_pred)\\n Y_pred_df.columns = Y_test.columns\\n #Convert predictions and correct y values to float for faciliate comparison\\n Y_pred_df = Y_pred_df.astype('float64')\\n Y_test = Y_test.astype('float64')\\n print_score(Y_test, Y_pred_df, 'weighted avg')\",\n \"def evaluate_model(model, testset):\\n\\n # Sort data by top level label to ease inspection\\n testset = testset.sort_using_layer(-1, reverse=True)\\n\\n # Feed the samples to the model to obtain each layers' activations\\n v = testset.get_layer(0)\\n hs = model.transform(v)[1:]\\n\\n # Read model weights\\n ws = [params['w'] for params in model.parameters]\\n del params\\n\\n # Take the (hidden) labels from the data set\\n ls = testset.get_layers()[1:]\\n\\n # In each layer, reorder and invert neurons to match best with the labels\\n for i in range(len(ls)):\\n hs[i], ws[i] = align_with_labels(ls[i], hs[i], ws[i])\\n del i\\n\\n # Measure correlations, etcetera\\n metrics = compare(ls, hs)\\n\\n # Simply return a dict with all used variables\\n return locals()\",\n \"def evaluate(cfg: DictConfig):\\n\\n experiments = cfg.get('experiment_type', f'{cfg.model.name}_only')\\n fixed_t0 = cfg.get('fixed_t0', False)\\n ext = '_fixedT0' if fixed_t0 else ''\\n\\n base_dir = cfg.device.root\\n datasource = cfg.datasource.name\\n\\n if experiments == 'ablations':\\n models = {\\n 'FluxRGNN': ['final',\\n 'final_without_encoder',\\n 'final_without_boundary'],\\n 'LocalLSTM': ['final']\\n }\\n elif experiments == 'final':\\n models = {\\n 'FluxRGNN': ['final'],\\n 'GAM': ['final'],\\n 'HA': ['final'],\\n 'GBT': ['final']\\n }\\n else:\\n m = cfg.model.name\\n year = cfg.datasource.test_year\\n\\n # find all experiments available for this model, datasource and test year\\n result_dir = osp.join(base_dir, 'results', datasource, m, f'test_{year}')\\n models = {\\n m : [ f.name for f in os.scandir(result_dir) if f.is_dir() ]\\n }\\n\\n\\n # thresholds for binary classification metrics\\n if cfg.datasource.name == 'abm':\\n thresholds = [0.0019, 0.0207]\\n else:\\n thresholds = [0, 10, 20]\\n\\n rmse_per_hour = []\\n mae_per_hour = []\\n pcc_per_hour = []\\n bin_per_hour = []\\n\\n rmse_per_night = []\\n mae_per_night = []\\n\\n output_dir = osp.join(base_dir, 'results', datasource, f'performance_evaluation{ext}', experiments)\\n os.makedirs(output_dir, exist_ok=True)\\n\\n counter = 0\\n\\n for m, dirs in models.items():\\n print(f'evaluate {m}')\\n\\n for d in dirs:\\n result_dir = osp.join(base_dir, 'results', datasource, m, f'test_{cfg.datasource.test_year}', d)\\n\\n # check if directory exists\\n if os.path.isdir(result_dir):\\n results, model_cfg = load_cv_results(result_dir, trials=cfg.task.repeats, ext=ext)\\n\\n df_prep = pd.read_csv(osp.join(base_dir, 'data', 'preprocessed',\\n f'{model_cfg[\\\"t_unit\\\"]}_{model_cfg[\\\"model\\\"][\\\"edge_type\\\"]}_ndummy={model_cfg[\\\"datasource\\\"][\\\"n_dummy_radars\\\"]}',\\n datasource, cfg.season, str(cfg.datasource.test_year), 'dynamic_features.csv'))\\n tidx2night = dict(zip(df_prep.tidx, df_prep.nightID))\\n\\n rmse_per_hour.append(compute_rmse(m, d, results, tidx2night, groupby=['horizon', 'trial'],\\n threshold=0, km2=True, fixed_t0=fixed_t0))\\n mae_per_hour.append(compute_mae(m, d, results, tidx2night, groupby=['horizon', 'trial'],\\n threshold=0, km2=True, fixed_t0=fixed_t0))\\n pcc_per_hour.append(compute_pcc(m, d, results, tidx2night, groupby=['horizon', 'trial'],\\n threshold=0, km2=True, fixed_t0=fixed_t0))\\n\\n if fixed_t0:\\n rmse_per_night.append(compute_rmse_per_night(m, d, results, tidx2night, groupby=['night_horizon', 'trial']))\\n mae_per_night.append(compute_mae_per_night(m, d, results, tidx2night, groupby=['night_horizon', 'trial']))\\n\\n # compute binary classification measures\\n for thr in thresholds:\\n bin_per_hour.append(compute_bin(m, d, results, groupby=['horizon', 'trial'], threshold=thr, km2=True))\\n\\n counter += 1\\n\\n else:\\n print(f'Experiment \\\"{d}\\\" for model \\\"{m}\\\" and datasource \\\"{datasource}\\\" is not available. '\\n f'Use \\\"run_experiments.py model={m} datasource={datasource} +experiment={d}\\\" to run this experiment.')\\n\\n if counter > 0:\\n rmse_per_hour = pd.concat(rmse_per_hour)\\n rmse_per_hour.to_csv(osp.join(output_dir, f'rmse_per_hour.csv'))\\n\\n mae_per_hour = pd.concat(mae_per_hour)\\n mae_per_hour.to_csv(osp.join(output_dir, f'mae_per_hour.csv'))\\n\\n pcc_per_hour = pd.concat(pcc_per_hour)\\n pcc_per_hour.to_csv(osp.join(output_dir, f'pcc_per_hour.csv'))\\n\\n bin_per_hour = pd.concat(bin_per_hour)\\n bin_per_hour.to_csv(osp.join(output_dir, f'bin_per_hour.csv'))\\n\\n if fixed_t0:\\n rmse_per_night = pd.concat(rmse_per_night)\\n rmse_per_night.to_csv(osp.join(output_dir, f'rmse_per_night.csv'))\\n\\n mae_per_night = pd.concat(mae_per_night)\\n mae_per_night.to_csv(osp.join(output_dir, f'mae_per_night.csv'))\",\n \"def test(self, dataset):\\n test_accuracy = 0\\n test_loss = 0\\n num_examples_tested = 0\\n # Put model into evaluation mode\\n self.model.eval()\\n for num, batch in enumerate(dataset.loader):\\n xs, ys = batch\\n batch_size = len(xs)\\n num_examples_tested += batch_size\\n iloss, iaccuracy = self.model(xs, ys)\\n test_loss += iloss.cpu().data.numpy().item() * batch_size\\n test_accuracy += iaccuracy.cpu().data.numpy().item() * batch_size\\n test_accuracy = test_accuracy / num_examples_tested\\n test_loss = test_loss / num_examples_tested\\n # Return accuracy and loss for this model on the test set\\n return test_accuracy, test_loss\",\n \"def evaluate_model(model, X_train, y_train, X_test, y_test):\\n model = model\\n model.fit(X_train, y_train)\\n\\n y_pred = model.predict(X_test)\\n\\n report = classificationreport(y_test, y_pred, target_names= [\\\"0\\\", \\\"1\\\"], output_dict=True)\\n\\n return report\",\n \"def evaluate(model, test_files):\\n print(\\\"Running predictions.\\\")\\n models = load_model(model)\\n predictions = predict(models, test_files)\\n\\n # # write predictions to file\\n # write_predictions(\\\"evaluate_out.json\\\",predictions)\\n evaluate_individual(predictions, test_files, models)\\n evaluate_overall(predictions)\",\n \"def test_eval(model, test_set):\\n num_test_batch = len(test_set)\\n test_loss = np.zeros((num_test_batch, 1), dtype=float)\\n test_acc = np.zeros((num_test_batch, 1), dtype=float)\\n for ibatch, batch in enumerate(test_set):\\n result = model.test_on_batch({'input':batch[0]}, {'fp1':batch[1], 'fp2':batch[1], 'fp3':batch[1], 'ave':batch[1]})\\n test_loss[ibatch] = result[0]\\n test_acc[ibatch] = result[-1]\\n return np.mean(test_loss), np.mean(test_acc)\",\n \"def test(self):\\n y_list = []\\n y_hat_list = []\\n for ex_dict in ut.TEST_LIST:\\n y_list.append(ex_dict[1])\\n y_hat_list.append(self.predict(ex_dict[0]))\\n acc = ut.compute_accuracy(y_hat_list, y_list)\\n return y_hat_list, acc\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n\\n y_pred = model.predict(X_test)\\n Y_test_as_array = np.array(Y_test)\\n for i in range(len(category_names)):\\n print(\\\"{} accuracy {} precision {} recall {} f1 {}\\\".format(\\n category_names[i],\\n (y_pred[:, i] == Y_test_as_array[:, i]).mean(), # accuracy\\n precision_score(Y_test_as_array[:, i], y_pred[:, i], average=None), # precision\\n recall_score(Y_test_as_array[:, i], y_pred[:, i], average=None), # recall\\n f1_score(Y_test_as_array[:, i], y_pred[:, i], average=None) # f1\\n ))\\n print(\\\"mean accuracy {}\\\".format((y_pred == Y_test_as_array).mean().mean()))\",\n \"def run_evaluate(self, test):\\n accs = []\\n correct_preds, total_correct, total_preds = 0., 0., 0.\\n for words, labels in minibatches(test, self.config.batch_size):\\n labels_pred, sequence_lengths = self.predict_batch(words)\\n\\n for lab, lab_pred, length in zip(labels, labels_pred,\\n sequence_lengths):\\n lab = lab[:length]\\n lab_pred = lab_pred[:length]\\n accs += [a==b for (a, b) in zip(lab, lab_pred)]\\n\\n lab_chunks = set(get_chunks(lab, self.config.vocab_tags))\\n lab_pred_chunks = set(get_chunks(lab_pred,\\n self.config.vocab_tags))\\n\\n correct_preds += len(lab_chunks & lab_pred_chunks)\\n total_preds += len(lab_pred_chunks)\\n total_correct += len(lab_chunks)\\n\\n p = correct_preds / total_preds if correct_preds > 0 else 0\\n r = correct_preds / total_correct if correct_preds > 0 else 0\\n f1 = 2 * p * r / (p + r) if correct_preds > 0 else 0\\n acc = np.mean(accs)\\n\\n return {\\\"acc\\\": 100*acc, \\\"f1\\\": 100*f1}\",\n \"def evaluate(self, X_test, y_test):\\n pipeline = run()\\n y_pred = pipeline.predict(X_test)\\n rmse = compute_rmse(y_pred, y_test)\\n print(rmse)\\n return rmse\",\n \"def evaluate(self, X_test, y_test):\\n y_pred_train = self.pipeline.predict(self.X)\\n mse_train = mean_squared_error(self.y, y_pred_train)\\n rmse_train = np.sqrt(mse_train)\\n \\n self.mlflow_log_metric('rmse_train', rmse_train)\\n \\n y_pred_test = self.pipeline.predict(X_test)\\n mse_test = mean_squared_error(y_test, y_pred_test)\\n rmse_test = np.sqrt(mse_test)\\n self.mlflow_log_metric('rmse_test', rmse_test)\\n \\n return (round(rmse_train, 3) ,round(rmse_test, 3))\",\n \"def evaluate_model(sess, model, data_set):\\n total_cost = 0.0\\n total_r_cost = 0.0\\n total_kl_cost = 0.0\\n for batch in range(data_set.num_batches):\\n unused_orig_x, x, s = data_set.get_batch(batch)\\n feed = {model.input_data: x, model.sequence_lengths: s}\\n (cost, r_cost,\\n kl_cost) = sess.run([model.cost, model.r_cost, model.kl_cost], feed)\\n total_cost += cost\\n total_r_cost += r_cost\\n total_kl_cost += kl_cost\\n\\n total_cost /= (data_set.num_batches)\\n total_r_cost /= (data_set.num_batches)\\n total_kl_cost /= (data_set.num_batches)\\n return (total_cost, total_r_cost, total_kl_cost)\",\n \"def test(self):\\n for data_tier in self.data_tiers:\\n tot = len(self.preprocessed_data[data_tier]['features'])\\n p = int(math.floor(tot*0.2))\\n test_features = np.array(self.preprocessed_data[data_tier]['features'][p:])\\n trend_test_classifications = np.array(self.preprocessed_data[data_tier]['trend_classifications'][p:])\\n avg_test_classifications = np.array(self.preprocessed_data[data_tier]['avg_classifications'][p:])\\n accuracy_trend = self.clf_trend[data_tier].score(test_features, trend_test_classifications)\\n accuracy_avg = self.clf_avg[data_tier].score(test_features, avg_test_classifications)\\n self.logger.info('The accuracy of %s trend classifier for data tier %s is %.3f', self.name, data_tier, accuracy_trend)\\n self.logger.info('The accuracy of %s avg regressor for data tier %s is %.3f', self.name, data_tier, accuracy_avg)\",\n \"def evaluate(self, test_dir='data/dev', target='real'):\\n test_data = {c: os.path.join(test_dir, c) for c in self.classes}\\n if not target in test_data:\\n print('Error: target class does not exist in test data.')\\n return\\n outcomes = {'TP': 0, 'TN': 0, 'FP': 0, 'FN': 0}\\n # >>> YOUR ANSWER HERE\\n data = []\\n for c in test_data:\\n docs = open(test_data[c]).readlines()\\n for doc in docs:\\n preprocess_doc = doc.strip()\\n data.append((c, preprocess_doc))\\n for item in data:\\n predict_ans = self.predict(item[1])\\n if item[0] == 'real':\\n if predict_ans == 'real':\\n outcomes['TP'] += 1\\n else:\\n outcomes['FN'] += 1\\n else:\\n if predict_ans == 'real':\\n outcomes['FP'] += 1\\n else:\\n outcomes['TN'] += 1\\n precision = outcomes['TP'] / (outcomes['TP'] + outcomes['FP']) # replace with equation for precision\\n recall = outcomes['TP'] / (outcomes['TP'] + outcomes['FN']) # replace with equation for recall\\n f1_score = 2 * ((precision * recall) / (precision + recall)) # replace with equation for f1\\n # >>> END YOUR ANSWER\\n return precision, recall, f1_score\",\n \"def _evaluate(self, train_x, train_y, test_x, test_y, n_targets, name):\\n r_temp = {}\\n for metric_name in self.metrics:\\n r_temp.update({f\\\"{metric_name}_Model\\\": name, f\\\"{metric_name}_Sum\\\": 0,\\n f\\\"{metric_name}_Min\\\": 1000000, f\\\"{metric_name}_Max\\\": 0})\\n\\n for i in range(self.repetitions):\\n is_nan = True\\n while (is_nan):\\n model = self.get_model(train_x.shape[1], n_targets)\\n model.fit(train_x, train_y, **self.fit_kwargs)\\n result = model.predict(test_x)\\n is_nan = np.any(np.isnan(result))\\n del model\\n\\n for metric_name in self.metrics:\\n metric = self.get_metrics(metric_name)\\n value = metric(result, test_y)\\n r_temp[f\\\"{metric_name}_Sum\\\"] += value\\n if r_temp[f\\\"{metric_name}_Min\\\"] > value:\\n r_temp[f\\\"{metric_name}_Min\\\"] = value\\n if r_temp[f\\\"{metric_name}_Max\\\"] < value:\\n r_temp[f\\\"{metric_name}_Max\\\"] = value\\n keras.backend.clear_session()\\n for metric_name in self.metrics:\\n r_temp[f\\\"{metric_name}_Mean\\\"] = r_temp[f\\\"{metric_name}_Sum\\\"] / self.repetitions\\n return r_temp\",\n \"def evaluate_model(model, X_test, y_test, category_names):\\n # Predict for test set\\n y_pred = model.predict(X_test)\\n \\n print(\\\"**** Scores for each category *****\\\\n\\\")\\n for i in range(36):\\n print(\\\"Scores for '{}':\\\".format(category_names[i]))\\n print(classification_report(y_test.values[:,i], y_pred[:,i]))\",\n \"def eval_performance(weights, test_y, test_x):\\n y_predicted = predict_labels(weights, test_x)\\n accuracy = len(y_predicted[y_predicted == test_y]) / len(y_predicted)\\n return accuracy\",\n \"def evaluate_model(model, X_test, y_test, category_names):\\n y_pred = model.predict(X_test)\\n labels = np.unique(y_pred)\\n print(labels)\\n #print out score for each class and mean scores, including precision, recall, f1 score\\n print(classification_report(y_test.values, y_pred, target_names=category_names.values))\",\n \"def evaluate(\\n self,\\n num_samples: int = 10,\\n report_every: int = 100,\\n train_or_test: str = \\\"test\\\",\\n ) -> None:\\n # asset train or test valid\\n assert train_or_test in [\\\"train\\\", \\\"test\\\"]\\n\\n # set device and num_gpus\\n num_gpus = num_devices()\\n device = torch_device()\\n torch.backends.cudnn.benchmark = True if cuda.is_available() else False\\n\\n # init model with gpu (or not)\\n self.model.to(device)\\n if num_gpus > 1:\\n self.model = nn.DataParallel(model)\\n self.model.eval()\\n\\n # set train or test\\n ds = (\\n self.dataset.test_ds\\n if train_or_test == \\\"test\\\"\\n else self.dataset.train_ds\\n )\\n\\n # set num_samples\\n ds.dataset.num_samples = num_samples\\n print(\\n f\\\"{len(self.dataset.test_ds)} samples of {self.dataset.test_ds[0][0][0].shape}\\\"\\n )\\n\\n # Loop over all examples in the test set and compute accuracies\\n ret = dict(\\n infer_times=[],\\n video_preds=[],\\n video_trues=[],\\n clip_preds=[],\\n clip_trues=[],\\n )\\n report_every = 100\\n\\n # inference\\n with torch.no_grad():\\n for i in range(\\n 1, len(ds)\\n ): # [::10]: # Skip some examples to speed up accuracy computation\\n if i % report_every == 0:\\n print(\\n f\\\"Processsing {i} of {len(self.dataset.test_ds)} samples..\\\"\\n )\\n\\n # Get model inputs\\n inputs, label = ds[i]\\n inputs = inputs.to(device, non_blocking=True)\\n\\n # Run inference\\n start_time = time()\\n outputs = self.model(inputs)\\n outputs = outputs.cpu().numpy()\\n infer_time = time() - start_time\\n ret[\\\"infer_times\\\"].append(infer_time)\\n\\n # Store results\\n ret[\\\"video_preds\\\"].append(outputs.sum(axis=0).argmax())\\n ret[\\\"video_trues\\\"].append(label)\\n ret[\\\"clip_preds\\\"].extend(outputs.argmax(axis=1))\\n ret[\\\"clip_trues\\\"].extend([label] * num_samples)\\n\\n print(\\n f\\\"Avg. inference time per video ({len(ds)} clips) =\\\",\\n round(np.array(ret[\\\"infer_times\\\"]).mean() * 1000, 2),\\n \\\"ms\\\",\\n )\\n print(\\n \\\"Video prediction accuracy =\\\",\\n round(accuracy_score(ret[\\\"video_trues\\\"], ret[\\\"video_preds\\\"]), 2),\\n )\\n print(\\n \\\"Clip prediction accuracy =\\\",\\n round(accuracy_score(ret[\\\"clip_trues\\\"], ret[\\\"clip_preds\\\"]), 2),\\n )\\n return ret\",\n \"def evaluate_model(valp):\\n\\n a = valp.predict(data_inputs[\\\"Test\\\"], [], new=True)[0]\\n\\n m2e = np.mean(mse(a[\\\"o0\\\"], data_outputs[\\\"Test\\\"][\\\"o0\\\"]))\\n acc = 1 - acc_err(a[\\\"o1\\\"][:, 0], np.argmax(data_outputs[\\\"Test\\\"][\\\"o1\\\"], axis=1))\\n i_d = 50-np.mean(inception_score(a[\\\"o2\\\"][:100]))\\n\\n return np.array([m2e, acc, i_d])\",\n \"def run_evaluate(self, test):\\n accs = []\\n correct_preds, total_correct, total_preds = 0., 0., 0.\\n for words, labels in minibatches(test, self.config.batch_size):\\n labels_pred, sequence_lengths = self.predict_batch(words)\\n\\n for lab, lab_pred, length in zip(labels, labels_pred,\\n sequence_lengths):\\n lab = lab[:length]\\n lab_pred = lab_pred[:length]\\n accs += [a==b for (a, b) in zip(lab, lab_pred)]\\n\\n lab_chunks = set(get_chunks(lab, self.config.vocab_tags))\\n lab_pred_chunks = set(get_chunks(lab_pred,\\n self.config.vocab_tags))\\n\\n correct_preds += len(lab_chunks & lab_pred_chunks)\\n total_preds += len(lab_pred_chunks)\\n total_correct += len(lab_chunks)\\n\\n p = correct_preds / total_preds if correct_preds > 0 else 0\\n r = correct_preds / total_correct if correct_preds > 0 else 0\\n f1 = 2 * p * r / (p + r) if correct_preds > 0 else 0\\n acc = np.mean(accs)\\n print('*'*20, '\\\\n')\\n print('precision:', p, 'recall:', r, 'f1:', f1, '\\\\n')\\n print('*'*20)\\n\\n return {\\\"acc\\\": 100*acc, \\\"f1\\\": 100*f1}\",\n \"def evaluate(model, eval_data, num_labels): \\n # Turn on the evaluation state to ignore dropouts\\n model.eval()\\n results = [predict(model, x) for x, y in eval_data]\\n f1_score, accuracy = get_metrics(np.array([y for x, y in eval_data]), results, num_labels)\\n return f1_score, accuracy\",\n \"def test_model_performance(model_es,test_file):\\n test_label = get_test_label(test_file)\\n result = model_es.predict(input_fn = lambda :input_fn(test_file,1,False,100,True))\\n predict_list = []\\n for one_res in result:\\n if \\\"probabilities\\\" in one_res:\\n predict_list.append(one_res['probabilities'][1])\\n get_auc(predict_list,test_label)\",\n \"def test(self):\\n with torch.no_grad():\\n self.model.eval()\\n p10_forecast, p10_forecast, p90_forecast, target = None, None, None, None\\n\\n t = time()\\n for step, sample in enumerate(self.test_loader):\\n\\n # Hide future predictions from input vector, set to 0 (or 1) values where timestep > encoder_steps\\n steps = self.cnf.all_params['num_encoder_steps']\\n pred_len = sample['outputs'].shape[1]\\n x = sample['inputs'].float().to(self.cnf.device)\\n x[:, steps:, 0] = 1\\n\\n # Feed input to the model\\n if self.cnf.all_params[\\\"model\\\"] == \\\"transformer\\\" or self.cnf.all_params[\\\"model\\\"] == \\\"grn_transformer\\\":\\n\\n # Auto-regressive prediction\\n for i in range(pred_len):\\n output = self.model.forward(x)\\n x[:, steps + i, 0] = output[:, i, 1]\\n output = self.model.forward(x)\\n\\n elif self.cnf.all_params[\\\"model\\\"] == \\\"tf_transformer\\\":\\n output, _, _ = self.model.forward(x)\\n else:\\n raise NameError\\n\\n output = output.squeeze()\\n y, y_pred = sample['outputs'].squeeze().float().to(self.cnf.device), output\\n\\n # Compute loss\\n loss, _ = self.loss(y_pred, y)\\n smape = symmetric_mean_absolute_percentage_error(output[:, :, 1].detach().cpu().numpy(),\\n sample['outputs'][:, :, 0].detach().cpu().numpy())\\n\\n # De-Normalize to compute metrics\\n target = unnormalize_tensor(self.data_formatter, y, sample['identifier'][0][0])\\n p10_forecast = unnormalize_tensor(self.data_formatter, y_pred[..., 0], sample['identifier'][0][0])\\n p50_forecast = unnormalize_tensor(self.data_formatter, y_pred[..., 1], sample['identifier'][0][0])\\n p90_forecast = unnormalize_tensor(self.data_formatter, y_pred[..., 2], sample['identifier'][0][0])\\n\\n # Compute metrics\\n self.test_losses['p10'].append(self.loss.numpy_normalised_quantile_loss(p10_forecast, target, 0.1))\\n self.test_losses['p50'].append(self.loss.numpy_normalised_quantile_loss(p50_forecast, target, 0.5))\\n self.test_losses['p90'].append(self.loss.numpy_normalised_quantile_loss(p90_forecast, target, 0.9))\\n\\n self.test_loss.append(loss.item())\\n self.test_smape.append(smape)\\n\\n # Plot serie prediction\\n p1, p2, p3, target = np.expand_dims(p10_forecast, axis=-1), np.expand_dims(p50_forecast, axis=-1), \\\\\\n np.expand_dims(p90_forecast, axis=-1), np.expand_dims(target, axis=-1)\\n p = np.concatenate((p1, p2, p3), axis=-1)\\n plot_temporal_serie(p, target)\\n\\n # Log stuff\\n for k in self.test_losses.keys():\\n mean_test_loss = np.mean(self.test_losses[k])\\n print(f'\\\\t● AVG {k} Loss on TEST-set: {mean_test_loss:.6f} │ T: {time() - t:.2f} s')\\n\\n # log log log\\n mean_test_loss = np.mean(self.test_loss)\\n mean_smape = np.mean(self.test_smape)\\n print(f'\\\\t● AVG Loss on TEST-set: {mean_test_loss:.6f} │ T: {time() - t:.2f} s')\\n print(f'\\\\t● AVG SMAPE on TEST-set: {mean_smape:.6f} │ T: {time() - t:.2f} s')\",\n \"def evaluate(self, X_test, y_test):\\n \\n y_pred = self.pipeline.predict(X_test)\\n test_rmse = compute_rmse(y_pred, y_test)\\n print(\\\"test rmse:\\\", test_rmse)\\n return test_rmse\",\n \"def test(self, idx_test):\\n self.eval()\\n output = self.predict()\\n # output = self.output\\n loss_test = F.nll_loss(output[idx_test], self.labels[idx_test])\\n acc_test = utils.accuracy(output[idx_test], self.labels[idx_test])\\n print(\\\"Test set results:\\\",\\n \\\"loss= {:.4f}\\\".format(loss_test.item()),\\n \\\"accuracy= {:.4f}\\\".format(acc_test.item()))\\n return acc_test.item()\",\n \"def evaluate(self, model, X_train, X_test, y_train, y_test):\\n\\n model.fit(X_train,y_train)\\n y_pred = model.predict(X_test)\\n R2 = r2_score(y_test, y_pred)\\n MAE = round(mape(y_test, y_pred), 2)\\n RMSE = round(rmse(y_test, y_pred), 2)\\n\\n res = {'Model': self.model, 'R2' : R2, 'MAPE': MAE, 'RMSE': RMSE}\\n return res\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n y_pred = pd.DataFrame(data = model.predict(X_test), columns = category_names)\\n\\n precision, recall, f1_score = [], [], []\\n\\n for category in category_names:\\n scores = classification_report(Y_test[category], y_pred[category])\\n precision.append([x for x in scores.strip().split(\\\"avg / total\\\")[1].strip().split(\\\" \\\") \\n if len(x) > 0][:3][0])\\n recall.append([x for x in scores.strip().split(\\\"avg / total\\\")[1].strip().split(\\\" \\\") \\n if len(x) > 0][:3][1])\\n \\n model_metric = pd.concat([\\n pd.DataFrame(data = [precision, recall], index = [\\\"precision\\\", \\\"recall\\\"], \\n columns = category_names),\\n (Y_test.reset_index() == y_pred.reset_index()).mean()[1:].to_frame(\\\"accuracy\\\").T\\n ])\\n\\n for col in model_metric.columns:\\n model_metric[col] = model_metric[col].astype(float)\\n\\n return model_metric\",\n \"def eval_model(self, model):\\n evaluation = model.evaluate(x=self.xt_test, y=self.yt_test)\\n print(\\\"loss : \\\" + str(round(evaluation[0]*100, 2)) + \\\"%\\\")\\n print(\\\"accuracy: \\\" + str(round(evaluation[1]*100, 2)) + \\\"%\\\")\",\n \"def _evaluate_during_fit(self, test_loader, epoch):\",\n \"def evaluate(self):\\n # Method variables definition\\n X_train, X_test, y_train, y_test = dm.reshape_y_set_split_data(self.datasetManager)\\n featureScaleDependentVariables = self.datasetManager.params.featureScaleDependentVariables\\n\\n # Feature Scaling\\n X_scaler, X_train = dm.do_feature_scaling(X_train)\\n if featureScaleDependentVariables:\\n y_scaler, y_train = dm.do_feature_scaling(y_train)\\n else:\\n y_scaler = None\\n y_train = self.datasetManager.y_train\\n \\n self.X_scaler = X_scaler\\n self.y_scaler = y_scaler\\n\\n # Training the SVR model on the training set\\n regressor = SVR(kernel = 'rbf')\\n regressor.fit(X_train, y_train.ravel())\\n self.regressor = regressor\\n\\n # Predicting the Test set results\\n self.y_pred = y_scaler.inverse_transform(regressor.predict(X_scaler.transform(X_test))) if featureScaleDependentVariables else regressor.predict(X_test)\\n \\n # Returning the process result : the regression type and the predicted dependent variables set\\n return [\\\"Support Vector Regression\\\", self.get_r2_score(y_test, self.y_pred)]\",\n \"def evaluate_model(model_name, y_true, y_pred):\\n\\n # Calculate performance metrics\\n rmse_eval = evaluate_rmse(y_true, y_pred)\\n mae_eval = evaluate_mae(y_true, y_pred) \\n r2_eval = evaluate_r2(y_true, y_pred)\\n\\n # Print results\\n print_evaluation(model_name, mae_eval, rmse_eval, r2_eval)\",\n \"def evaluate_model(predictions_table: pd.DataFrame, ratings_table: pd.DataFrame,\\n test_table: pd.DataFrame, viewed_table: pd.DataFrame,\\n all_predictions_table: pd.DataFrame) -> Dict:\\n\\n viewed = viewed_table.to_numpy()\\n predictions = predictions_table.to_numpy()\\n all_predictions = all_predictions_table.to_numpy()\\n ratings = ratings_table.to_numpy()\\n test = test_table.to_numpy(copy=True)\\n test_demeaned = test - np.mean(test, axis=1).reshape(-1, 1)\\n test_set = test_table.apply(lambda x: x != 0.0).astype(int).to_numpy()\\n\\n result = dict()\\n\\n # Test set evaluation\\n test_predictions = np.multiply(all_predictions, test_set)\\n diff = np.subtract(test_predictions, test_demeaned)\\n rmse = np.sqrt(np.mean(np.square(diff)))\\n result.update({\\\"RMSE\\\": rmse})\\n mae = np.mean(np.absolute(diff))\\n result.update({\\\"MAE\\\": mae})\\n\\n # overall evaluation\\n movies_recommended = set()\\n i = 0\\n for index, row in predictions_table.iterrows():\\n if i > 10000: break\\n else: i += 1\\n\\n labels = row.nlargest(20).keys().tolist()\\n for movie in labels:\\n movies_recommended.update(movie)\\n\\n result.update({\\\"Coverage\\\": len(movies_recommended)})\\n\\n return result\",\n \"def evaluate_model(model, X_test, Y_test, category_names): \\n \\n Y_pred = model.predict(X_test)\\n print(classification_report(Y_test, Y_pred))\\n display_results(Y_test, Y_pred)\",\n \"def score_model(self, model, test_training, test_target):\\n\\n target_prediction = model.predict(test_training)\\n from sklearn.metrics import classification_report\\n if(self.VERBOSE):\\n print(classification_report(test_target, target_prediction))\\n\\n return [\\n f1_score(test_target, target_prediction, average='weighted'),\\n precision_score(test_target, target_prediction, average='weighted'),\\n recall_score(test_target, target_prediction, average='weighted')\\n ]\",\n \"def estimatePerformance(self, model):\\n Y_pred = model.computeLOO()\\n #performance = self.measure.multiOutputPerformance(self.Y, Y_pred)\\n #performance = self.measure.getPerformance(self.Y, Y_pred)\\n #performance = measure_utilities.aggregate(performance)\\n performance = self.measure(self.Y, Y_pred)\\n self.predictions.append(Y_pred)\\n return performance\",\n \"def evaluate(self, X_test, y_test):\\n y_pred = self.pipeline.predict(X_test)\\n return compute_rmse(y_pred, y_test)\",\n \"def evaluate_test(model, history, class_labels, train_X, test_X, train_y, test_y):\\n train_loss, train_acc = model.evaluate(train_X, train_y, verbose=0)\\n test_loss, test_acc = model.evaluate(test_X, test_y, verbose=0)\\n print('Accuracy \\\\n Train: %.3f, Test: %.3f' % (train_acc, test_acc))\\n print('Loss \\\\n Train: %.3f, Test: %.3f \\\\n' % (train_loss, test_loss))\\n # plot loss during training\\n plt.subplots_adjust(hspace = .5, wspace = 0.5)\\n plt.subplot(211)\\n plt.title('Loss', weight='bold')\\n plt.plot(history.history['loss'], label='train')\\n plt.plot(history.history['val_loss'], label='val')\\n plt.legend()\\n # plot accuracy during training\\n plt.subplot(212)\\n plt.title('Accuracy', weight='bold')\\n plt.plot(history.history['acc'], label='train')\\n plt.plot(history.history['val_acc'], label='val')\\n plt.legend()\\n plt.show()\\n print('\\\\n')\\n # predict probabilities for test set\\n yhat_probs = model.predict(test_X, verbose=0)\\n # predict classes for test set\\n yhat_classes = model.predict_classes(test_X, verbose=0)\\n # reduce to 1d array\\n yhat_probs = yhat_probs[:, 0]\\n yhat_classes = yhat_classes[:, 0]\\n # calculate metrics\\n report = metrics.classification_report(test_y, yhat_classes, target_names=class_labels)\\n confusion_matrix = metrics.confusion_matrix(test_y, yhat_classes)\\n plot_confusion_matrix(confusion_matrix, class_labels)\\n print('\\\\n')\\n return report\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n# Print out Precision , recall F1_score and support for each column using classification_report function\\n y_pred_test = model.predict(X_test)\\n print(classification_report(Y_test, y_pred_test, target_names=category_names))\",\n \"def evaluate(train, train_labels, test, test_labels):\\n \\n # Use the same model for each training set for now\\n model = RandomForestClassifier(n_estimators = 100, \\n random_state = 50, n_jobs = -1)\\n \\n train = train.replace({np.inf: np.nan, -np.inf: np.nan})\\n test = test.replace({np.inf: np.nan, -np.inf:np.nan})\\n \\n feature_names = list(train.columns)\\n \\n # Impute the missing values\\n imputer = Imputer(strategy = 'median', axis = 1)\\n train = imputer.fit_transform(train)\\n test = imputer.transform(test)\\n \\n cv_score = 1 * cross_val_score(model, train, train_labels, \\n scoring = \\\"f1\\\", \\n cv = 5)\\n \\n # Fit on the training data and make predictions\\n model.fit(train, train_labels)\\n preds = model.predict(test)\\n \\n # Calculate the performance\\n f1 = f1_score(test_labels, preds)\\n print('5-fold CV F1: {:.2f} with std: {:.2f}'.format(cv_score.mean(),cv_score.std()))\\n print('Test F1: {:.2f}.'.format(f1))\\n \\n feature_importances = pd.DataFrame({'feature': feature_names, \\n 'importance': model.feature_importances_})\\n \\n return preds, feature_importances\",\n \"def test(self, test=False): \\n if test == True:\\n if os.path.exists(self.student_save_path):\\n checkpoint = torch.load(self.student_save_path, map_location=self.device)\\n else:\\n raise ValueError('No file with the pretrained model selected')\\n\\n self.student_model.load_state_dict(checkpoint)\\n self.student_model.eval()\\n\\n running_acc = 0\\n with torch.no_grad():\\n for data, label in self.testloader:\\n data, label = data.to(self.device), label.to(self.device)\\n\\n student_logits, *student_activations = self.student_model(data)\\n\\n running_acc += utils.accuracy(student_logits.data, label)\\n\\n print(f\\\"Test accuracy: {running_acc / len(self.testloader)}\\\")\\n return running_acc / len(self.testloader)\",\n \"def evaluate_on_test_set(self, energy_threshold=80):\\n losses = []\\n accuracies = []\\n codings = []\\n codings_label = []\\n losses_item = []\\n test_loader = self.dm.get_test_set()\\n N = 0\\n gamma_sum = 0\\n mu_sum = 0\\n cov_mat_sum = 0\\n\\n # Change the model to evaluation mode\\n self.model.eval()\\n\\n with torch.no_grad():\\n # Create pytorch's train data_loader\\n train_loader = self.dm.get_train_set()\\n\\n for i, data in enumerate(train_loader, 0):\\n # transfer tensors to selected device\\n train_inputs, _ = data[0].to(self.device), data[1].to(self.device)\\n\\n # forward pass\\n code, x_hat, cosim, z, gamma = self.model(train_inputs)\\n phi, mu, cov_mat = self.model.compute_params(z, gamma)\\n\\n batch_gamma_sum = gamma.sum(axis=0)\\n\\n gamma_sum += batch_gamma_sum\\n mu_sum += mu * batch_gamma_sum.unsqueeze(-1) # keep sums of the numerator only\\n cov_mat_sum += cov_mat * batch_gamma_sum.unsqueeze(-1).unsqueeze(-1) # keep sums of the numerator only\\n\\n N += train_inputs.shape[0]\\n\\n train_phi = gamma_sum / N\\n train_mu = mu_sum / gamma_sum.unsqueeze(-1)\\n train_cov = cov_mat_sum / gamma_sum.unsqueeze(-1).unsqueeze(-1)\\n\\n print(\\\"Train N:\\\", N)\\n print(\\\"phi :\\\\n\\\", train_phi)\\n print(\\\"mu :\\\\n\\\", train_mu)\\n print(\\\"cov :\\\\n\\\", train_cov)\\n\\n # Calculate energy using estimated parameters\\n\\n train_energy = []\\n train_labels = []\\n train_z = []\\n\\n for i, data in enumerate(train_loader, 0):\\n # transfer tensors to selected device\\n train_inputs, train_inputs_labels = data[0].to(self.device), data[1]\\n\\n # forward pass\\n code, x_hat, cosim, z, gamma = self.model(train_inputs)\\n sample_energy, pen_cov_mat = self.model.estimate_sample_energy(z,\\n train_phi,\\n train_mu,\\n train_cov,\\n average_it=False,\\n device=self.device)\\n\\n train_energy.append(sample_energy.cpu().numpy())\\n train_z.append(z.cpu().numpy())\\n train_labels.append(train_inputs_labels.numpy())\\n\\n train_energy = np.concatenate(train_energy, axis=0)\\n train_z = np.concatenate(train_z, axis=0)\\n train_labels = np.concatenate(train_labels, axis=0)\\n\\n test_energy = []\\n test_labels = []\\n test_z = []\\n\\n for data in test_loader:\\n test_inputs, label_inputs = data[0].to(self.device), data[1]\\n\\n # forward pass\\n code, x_hat, cosim, z, gamma = self.model(test_inputs)\\n sample_energy, pen_cov_mat = self.model.estimate_sample_energy(z,\\n train_phi,\\n train_mu,\\n train_cov,\\n average_it=False,\\n device=self.device)\\n test_energy.append(sample_energy.cpu().numpy())\\n test_z.append(z.cpu().numpy())\\n test_labels.append(label_inputs.numpy())\\n\\n test_energy = np.concatenate(test_energy, axis=0)\\n test_z = np.concatenate(test_z, axis=0)\\n test_labels = np.concatenate(test_labels, axis=0)\\n\\n combined_energy = np.concatenate([train_energy, test_energy], axis=0)\\n combined_labels = np.concatenate([train_labels, test_labels], axis=0)\\n\\n thresh = np.percentile(combined_energy, energy_threshold)\\n print(\\\"Threshold :\\\", thresh)\\n\\n # Prediction using the threshold value\\n pred = (test_energy > thresh).astype(int)\\n groundtruth = test_labels.astype(int)\\n\\n accuracy = accuracy_score(groundtruth, pred)\\n precision, recall, f_score, support = prf(groundtruth, pred, average='binary')\\n\\n print(f\\\"Accuracy:{accuracy}, \\\"\\n f\\\"Precision:{precision}, \\\"\\n f\\\"Recall:{recall}, \\\"\\n f\\\"F-score:{f_score}, \\\"\\n f\\\"\\\\nconfusion-matrix: {confusion_matrix(groundtruth, pred)}\\\")\\n\\n # switch back to train mode\\n self.model.train()\\n return accuracy, precision, recall, f_score, test_z, test_labels, combined_energy\",\n \"def evaluate_performance(data_loader, model):\\n acc = mx.metric.Accuracy()\\n\\n for idx, (data, label) in enumerate(data_loader):\\n data = data.as_in_context(model.ctx)\\n label = label.as_in_context(model.ctx)\\n pred = model(data)\\n pred = mx.nd.argmax(pred, axis=1)\\n acc.update(label, pred)\\n return acc.get()\",\n \"def evaluate_model(args, eval_runs, warm_runs, metrics=['psnr', 'ssim', 'fps']):\\n upsampler = Upsampler(args)\\n if warm_runs > 0:\\n print(\\\"Warming up for evaluation\\\")\\n for i in range(warm_runs):\\n print(\\\"Performing warm-up run\\\", str(i+1))\\n for sequence in ['foliage', 'walk', 'calendar', 'city']:\\n bix_dir = os.path.join(VID4_DIR, 'BIx4', sequence)\\n upsampler.run_dir(bix_dir, reset=False)\\n \\n time = 0.\\n psnrs = []\\n ssims = []\\n for i in range(eval_runs):\\n run_psnrs = []\\n run_ssims = []\\n print(\\\"Performing evaluation run\\\", str(i+1))\\n for sequence in ['foliage', 'walk', 'calendar', 'city']:\\n bix_dir = os.path.join(VID4_DIR, 'BIx4', sequence)\\n gt_dir = os.path.join(VID4_DIR, 'GT', sequence)\\n print(\\\"Evaluating on\\\", bix_dir)\\n time += upsampler.run_dir(bix_dir, reset=False)\\n vid_psnrs, vid_ssims = _eval_sr_perf(os.path.join(bix_dir, 'up'), gt_dir)\\n run_psnrs += vid_psnrs\\n run_ssims += vid_ssims\\n if i == eval_runs-1:\\n with open(os.path.join(upsampler.get_model_dir(), \\\"psnr.txt\\\"), \\\"w\\\") as f:\\n f.writelines(str(psnr) + '\\\\n' for psnr in run_psnrs)\\n with open(os.path.join(upsampler.get_model_dir(), \\\"ssim.txt\\\"), \\\"w\\\") as f:\\n f.writelines(str(ssim) + '\\\\n' for ssim in run_ssims)\\n psnrs += run_psnrs\\n ssims += run_ssims\\n\\n fps = VID4_LENGTH/ (time/eval_runs)\\n return Performance(psnr=psnrs, ssim=ssims, fps=fps)\",\n \"def assess_model(model, test_data, label):\\n return model.score(test_data,label)\",\n \"def evaluate(train: pd.DataFrame, test: pd.DataFrame, algorithm):\\n\\n model = algorithm(train)\\n\\n test_labels = test['Labels']\\n\\n predictions = predict_data(test, model)\\n\\n error = mean_square_error(predictions, test_labels)\\n\\n acc = accuracy(predictions, test_labels)\\n\\n return acc, error\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n \\n \\n yPredictorTest = model.predict(X_test)\\n \\n for idx, col in enumerate(Y_test):\\n print(col, classification_report(Y_test[col], yPredictorTest[:, idx]))\",\n \"def test(self):\\n self.load()\\n bottleneck_features = np.load(self.feature_path)\\n test = bottleneck_features['test']\\n _, test_targets = load_dataset(self.image_path_test) \\n predictions = [np.argmax(self.model.predict(np.expand_dims(feature, axis=0))) for feature in test]\\n test_accuracy = 100*np.sum(np.array(predictions) == np.argmax(test_targets, axis=1))/len(predictions)\\n print('{}, test accuracy: {:.4f}%'.format(self.name, test_accuracy))\\n return test_accuracy\",\n \"def test(self) -> None:\\n\\n self._predictions = self._lr.predict(self._X_test)\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n y_pred = model.predict(X_test)\\n print(classification_report(Y_test, y_pred, target_names=Y_test.keys()))\",\n \"def compute(self) -> None:\\n \\n self.model.eval()\\n \\n with torch.no_grad():\\n for (input, target, _) in self.loader:\\n\\n # self.model = self.model.train(False) # TEST @lacoupe\\n output, _ = self.model(input)\\n \\n output = (output >= 0.5)\\n \\n for out, tar in zip(output, target):\\n \\n tar = bool(tar)\\n \\n if out and tar:\\n self.confusion['true_positive'] += 1\\n elif not out and not tar:\\n self.confusion['true_negative'] += 1\\n elif out and not tar:\\n self.confusion['false_positive'] += 1\\n elif not out and tar:\\n self.confusion['false_negative'] += 1\\n \\n self.accuracy = (self.confusion['true_positive'] + self.confusion['true_negative']) \\\\\\n / sum(list(self.confusion.values()))\\n \\n if (self.confusion['true_positive'] + self.confusion['false_positive']) == 0.:\\n self.precision = 0.\\n else:\\n self.precision = self.confusion['true_positive'] \\\\\\n / (self.confusion['true_positive'] + self.confusion['false_positive'])\\n \\n if (self.confusion['true_positive'] + self.confusion['false_negative']) == 0.:\\n self.recall = 0.\\n else:\\n self.recall = self.confusion['true_positive'] \\\\\\n / (self.confusion['true_positive'] + self.confusion['false_negative'])\\n \\n if (self.precision + self.recall) == 0.:\\n self.f1_score = 0.\\n else:\\n self.f1_score = 2 * self.precision * self.recall / (self.precision + self.recall)\",\n \"def evaluate_model(model, X_test_input, y_test_input):\\r\\n pred_class = [model.classes_[i] for i in model.predict_proba(X_test_input).argmax(axis=-1)]\\r\\n pred_accuracy = np.sum(np.array(y_test_input)==np.array(pred_class))/len(pred_class)\\r\\n return pred_class, pred_accuracy\",\n \"def test(self, test_fn, eval_metrics):\\n # Load gold and predict\\n X, Y = self.load_dataset(test_fn)\\n y = self.model.predict(X)\\n\\n # Get most probable predictions and flatten\\n Y = RNN_model.consolidate_labels(self.transform_output_probs(Y).flatten())\\n y = RNN_model.consolidate_labels(self.transform_output_probs(y).flatten())\\n\\n # Run evaluation metrics and report\\n # TODO: is it possible to compare without the padding?\\n ret = []\\n for (metric_name, metric_func) in eval_metrics:\\n ret.append((metric_name, metric_func(Y, y)))\\n logging.debug(\\\"calculating {}\\\".format(ret[-1]))\\n\\n for (metric_name, metric_val) in ret:\\n logging.info(\\\"{}: {:.4f}\\\".format(metric_name,\\n metric_val))\\n return Y, y, ret\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n y_pred_grid = model.predict(X_test)\\n print(\\n classification_report(Y_test.values, y_pred_grid, target_names=category_names)\\n )\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n \\n Y_pred = model.predict(X_test)\\n \\n print(classification_report(Y_test.values, Y_pred, target_names=category_names))\",\n \"def test(args, model, device, data, target):\\n model.eval()\\n test_loss = 0\\n correct = 0\\n data, target = data.to(device), target.to(device)\\n output = model(data)\\n # Final result will be average of averages of the same size\\n test_loss += F.nll_loss(output, target, reduction='mean').item()\\n ppe.reporting.report({'val/loss': test_loss})\\n pred = output.argmax(dim=1, keepdim=True)\\n correct += pred.eq(target.view_as(pred)).sum().item()\\n ppe.reporting.report({'val/acc': correct / len(data)})\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n Y_prediction = model.predict(X_test)\\n Y_prediction_df = pd.DataFrame(Y_prediction, columns=category_names)\\n \\n for col in category_names:\\n print(f\\\"category:{col}\\\")\\n print(classification_report(Y_test[col], Y_prediction_df[col]))\\n print('------------------------------------------------------')\\n \\n accuracy = np.mean(Y_prediction == Y_test.values)\\n print(f\\\"Accuracy: {accuracy:.2%}\\\")\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n Y_pred = model.predict(X_test)\\n Y_pred = pd.DataFrame(Y_pred, columns=category_names)\\n \\n # calculate summary stats on test data\\n results = pd.DataFrame()\\n for column_name in Y_pred.columns:\\n col_report = classification_report(y_true=Y_test[[column_name]], y_pred=Y_pred[[column_name]], output_dict=True)\\n accuracy = col_report['accuracy']\\n precision = col_report['macro avg']['precision']\\n recall = col_report['macro avg']['recall']\\n results[column_name] = [accuracy, precision, recall]\\n results.index = ['accuracy', 'precision', 'recall']\\n results.mean(axis=1) \\n \\n # save results to local csv file\\n model_name = type(model.best_params_['clf']).__name__\\n avg_accuracy = results.mean(axis=1)['accuracy']\\n avg_precision = results.mean(axis=1)['precision']\\n avg_recall = results.mean(axis=1)['recall']\\n params = model.best_params_\\n stored_results = pd.DataFrame({'Model': [model_name], 'Accuracy': [avg_accuracy], 'Precision': [avg_precision], \\n 'Recall': [avg_recall], 'Parameters': [params]})\\n\\n add_header = not os.path.isfile('models/model_results.csv')\\n with open('models/model_results.csv', 'a') as f:\\n stored_results.to_csv(f, header=add_header, index=False)\",\n \"def evaluate(func, dset_path, model_path):\\n dset = load_dataset(dset_path, 'trva', False)\\n\\n \\\"\\\"\\\"\\n average class-based zero-shot accuracy\\n \\\"\\\"\\\"\\n scores = func(dset['Xte_unseen'], dset['Ste_unseen_gt'], model_path)\\n preds = np.argmax(scores, 1)\\n preds = dset['Cte_unseen'][preds]\\n acc_zsl = compute_acc(dset['Lte_unseen'], preds)\\n\\n \\\"\\\"\\\"\\n average class-based generalized zsl accuracy on seen test classes\\n \\\"\\\"\\\"\\n scores = func(dset['Xte_seen'], dset['Sall_gt'], model_path)\\n preds = np.argmax(scores, 1)\\n preds = dset['Call'][preds]\\n acc_gzsl_seen = compute_acc(dset['Lte_seen'], preds)\\n\\n \\\"\\\"\\\"\\n average class-based generalized zsl accuracy on unseen test classes\\n \\\"\\\"\\\"\\n scores = func(dset['Xte_unseen'], dset['Sall_gt'], model_path)\\n preds = np.argmax(scores, 1)\\n preds = dset['Call'][preds]\\n acc_gzsl_unseen = compute_acc(dset['Lte_unseen'], preds)\\n\\n print 'ZSL accuracy: ', acc_zsl\\n print 'Generalized ZSL accuracy on seen classes: ', acc_gzsl_seen\\n print 'Generalized ZSL accuracy on unseen classes: ', acc_gzsl_unseen\",\n \"def compute_test():\\n model.eval()\\n sets = list(features.keys())\\n for dset, loaders in zip(sets, [train_loaders, val_loaders, test_loaders]):\\n final_specific_loss = 0\\n final_total_loss = 0\\n for loader in loaders:\\n loader_total_loss = 0\\n loader_specific_loss = 0\\n for data in loader:\\n output = model(data.to(device))\\n specific_loss = specific_loss_torch_geom(output, (data.pos, data.y),\\n data.batch, batch_sizes[dset]).detach()\\n loader_specific_loss += specific_loss\\n loader_total_loss += torch.mean(specific_loss)\\n # Average the loss over each loader\\n loader_specific_loss /= len(loader)\\n loader_total_loss /= len(loader)\\n # Average the loss over the different loaders\\n final_specific_loss += loader_specific_loss / len(loaders)\\n final_total_loss += loader_total_loss / len(loaders)\\n del output, loader_specific_loss\\n\\n print(\\\"Test set results \\\", dset, \\\": loss= {:.4f}\\\".format(final_total_loss))\\n print(dset, \\\": \\\", final_specific_loss)\\n print(\\\"Results in log scale\\\", np.log10(final_specific_loss.detach().cpu()),\\n np.log10(final_total_loss.detach().cpu().numpy()))\\n if args.wandb:\\n wandb.run.summary[\\\"test results\\\"] = np.log10(final_specific_loss.detach().cpu())\\n # free unnecessary data\\n\\n\\n final_specific_numpy = np.log10(final_specific_loss.detach().cpu())\\n del final_total_loss, final_specific_loss\\n torch.cuda.empty_cache()\\n return final_specific_numpy\",\n \"def final_eval(self):\\n # Test performance - Load best model\\n self.load_model(self.best_model_path, model_type='best')\\n logging.info(\\\"Loading best model after epoch: %d\\\" %\\n self.train_info['epoch'])\\n\\n perf_file = path.join(self.model_dir, \\\"perf.json\\\")\\n if self.slurm_id:\\n parent_dir = path.dirname(path.normpath(self.model_dir))\\n perf_dir = path.join(parent_dir, \\\"perf\\\")\\n if not path.exists(perf_dir):\\n os.makedirs(perf_dir)\\n perf_file = path.join(perf_dir, self.slurm_id + \\\".json\\\")\\n\\n output_dict = {'model_dir': self.model_dir}\\n for key, val in vars(self.args).items():\\n output_dict[key] = val\\n\\n for split in ['dev', 'test']:\\n logging.info('\\\\n')\\n logging.info('%s' % split.capitalize())\\n result_dict = self.eval_model(split, final_eval=True)\\n if split != 'test':\\n logging.info('Calculated F1: %.3f' % result_dict['fscore'])\\n\\n output_dict[split] = result_dict\\n\\n json.dump(output_dict, open(perf_file, 'w'), indent=2)\\n\\n logging.info(\\\"Final performance summary at %s\\\" % perf_file)\\n sys.stdout.flush()\",\n \"def test(args, model, lossfn, device, data, target):\\n model.eval()\\n test_loss = 0\\n correct = 0\\n data, target = data.to(device), target.to(device)\\n output = model(data)\\n # Final result will be average of averages of the same size\\n test_loss += lossfn(output, target).item()\\n ppe.reporting.report({\\\"val/loss\\\": test_loss})\\n pred = output.argmax(dim=1, keepdim=True)\\n correct += pred.eq(target.view_as(pred)).sum().item()\\n ppe.reporting.report({\\\"val/acc\\\": correct / len(data)})\",\n \"def evaluate(model_class, params, matches, valid_index, test_index,\\n seasons_train, seasons_valid, seasons_test, eval_functions):\\n model = model_class(**params)\\n output = {}\\n start = time()\\n predictions = model.fit_predict(matches, seasons_train, seasons_valid, seasons_test)\\n output['train_time'] = np.round((time() - start) / 60., 4)\\n # TODO: Monitor train results\\n for eval_set, index in zip(('valid', 'test'), (valid_index, test_index)):\\n for eval_fun in eval_functions:\\n output['{}_{}'.format(eval_set, eval_fun.__name__)] = np.round(eval_fun(predictions[index],\\n matches['FTR'][index]), 4)\\n output['{}_size'.format(eval_set)] = index.sum()\\n output['model'] = model_class.__name__\\n return {**params, **output}\",\n \"def test(model, dataloader):\\n model.eval()\\n device = model.device\\n time_start = time.time()\\n batch_time = 0.0\\n accuracy = 0.0\\n all_prob, all_labels = [], []\\n \\n with torch.no_grad():\\n for (batch_seqs, batch_seq_masks, batch_seq_segments, batch_labels) in dataloader:\\n batch_start = time.time()\\n seqs = batch_seqs.to(device) \\n masks = batch_seq_masks.to(device)\\n segments = batch_seq_segments.to(device)\\n labels = batch_labels.to(device)\\n\\n _, _, probabilities = model(seqs, masks, segments, labels)\\n accuracy += correct_predictions(probabilities, labels)\\n batch_time += time.time() - batch_start\\n all_prob.extend(probabilities[:, 1].cpu().numpy())\\n all_labels.extend(batch_labels)\\n batch_time /= len(dataloader)\\n total_time = time.time() - time_start\\n accuracy /= (len(dataloader.dataset))\\n return batch_time, total_time, accuracy, roc_auc_score(all_labels, all_prob)\",\n \"def evaluate(self, predicted_df):\\n logging.info(\\\"Evaluating model: {}\\\".format(self.model_type))\\n y_true = predicted_df[\\\"user_label\\\"].as_matrix()\\n y_pred = predicted_df[\\\"label\\\"].as_matrix()\\n\\n scores_cols = [col for col in predicted_df.columns if col.startswith(\\\"scores_\\\")]\\n print(\\\"scores_cols: {}\\\".format(scores_cols))\\n\\n y_pred_scores = predicted_df[scores_cols].copy().fillna(value=0).as_matrix()\\n print(\\\"predicted scores: {}\\\".format(y_pred_scores))\\n y_true_scores = []\\n for lab in predicted_df[\\\"user_label\\\"]:\\n trues = [0 for _ in range(len(scores_cols))]\\n if \\\"scores_\\\"+lab in scores_cols:\\n trues[scores_cols.index(\\\"scores_\\\"+lab)] = 1\\n y_true_scores.append(trues)\\n print(\\\"true scores: {}\\\".format(y_true_scores))\\n y_true_scores = np.array(y_true_scores)\\n\\n performance = {\\\"model\\\": self.model_type, \\\"description\\\": self.description}\\n if 'categorical_accuracy' in self.metrics:\\n logging.info(\\\"Calculating categorical accuracy for {}\\\".format(self))\\n performance['categorical_accuracy'] = sklearn.metrics.accuracy_score(y_true,\\n y_pred) # np.mean(y_pred == y_true)\\n if 'fmeasure' in self.metrics:\\n logging.info(\\\"Calculating fmeasure for {}\\\".format(self))\\n performance['fmeasure'] = sklearn.metrics.f1_score(y_true, y_pred, average=self.metrics_average)\\n if 'MRR' in self.metrics:\\n logging.info(\\\"Calculating MRR for {}\\\".format(self))\\n performance['MRR'] = sklearn.metrics.label_ranking_average_precision_score(y_true_scores, y_pred_scores)\\n logging.info(\\\"Calculated performance: {}\\\".format(performance))\\n print(performance)\\n return pd.DataFrame(performance, index=[0])\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n y_pred = model.predict(X_test)\\n # print the metrics\\n for i, col in enumerate(category_names):\\n print('{} category metrics: '.format(col))\\n print(classification_report(Y_test.iloc[:,i], y_pred[:,i]))\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n Y_pred=model.predict(X_test)\\n acc=[]\\n for i,c in enumerate(Y_test.columns):\\n print(c)\\n print(classification_report(Y_test[c], Y_pred[:,i]))\\n acc.append(accuracy_score(Y_test[c], Y_pred[:,i]))\\n print('Accuracy :',np.mean(acc))\\n\\n pass\",\n \"def fit_test(self):\",\n \"def evaluate(self):\\n self.training = False\",\n \"def evaluate(model, datagen, X_test, Y_test, batch_size, save_folder_path=None):\\n\\n print(\\\"[INFO] Evaluating model...\\\")\\n\\n scores = model.evaluate_generator(\\n datagen.flow(X_test, Y_test, batch_size=batch_size),\\n verbose=1)\\n \\n print(\\\"[INFO] Evaluation results:\\\\n{0}: {1:.2f}\\\\n{2}: {3:.2f}\\\".format(model.metrics_names[0], scores[0]*100, model.metrics_names[1], scores[1]*100))\\n \\n if save_folder_path is not None:\\n # Write results to path\\n assert os.path.isdir(save_folder_path) == True, \\\"Unable to save evaluation results, save_folder_path is not a folder\\\"\\n eval_results_path = save_folder_path + \\\"/eval_results.txt\\\"\\n eval_handle = open(eval_results_path, 'w')\\n eval_handle.write(\\\"Model name: {}\\\\n\\\\n\\\".format(MODEL_NAME))\\n eval_handle.write(\\\"Evaluation results:\\\\n{0}: {1:.2f}\\\\n{2}: {3:.2f}\\\".format(model.metrics_names[0], scores[0]*100, model.metrics_names[1], scores[1]*100))\\n eval_handle.close()\",\n \"def test(self):\\n self.model.eval()\\n\\n for step, sample in enumerate(self.test_loader):\\n x, _, _ = sample\\n x = x.to(self.device)\\n\\n y_pred = self.model.forward(x)\\n loss = nn.MSELoss()(y_pred, x)\\n self.test_losses.append(loss.item())\\n\\n if step % (max(8, len(self.test_loader)) // 8) == 0:\\n out_img = torch.cat([x[0], torch.clamp(y_pred[0], 0, 1)], dim=2)\\n self.sw.add_image(tag=f'sample_{step}', img_tensor=out_img, global_step=self.epoch)\\n\\n # log average loss on test set\\n mean_test_loss = np.mean(self.test_losses)\\n self.test_losses = []\\n print(f'\\\\t● AVG Loss on TEST-set: {mean_test_loss:.6f} │ patience: ', end='')\\n self.sw.add_scalar(tag='test_loss', scalar_value=mean_test_loss, global_step=self.epoch)\\n\\n # save best model and update training patience\\n if self.best_test_loss is None or mean_test_loss < self.best_test_loss:\\n self.best_test_loss = mean_test_loss\\n self.patience = conf.FX_PATIENCE\\n torch.save(self.model.state_dict(), self.log_path / 'best.pth')\\n else:\\n self.patience = self.patience - 1\\n print(f'{self.patience}/{conf.FX_PATIENCE}')\\n\\n if self.patience == 0:\\n self.show_completion_msg()\",\n \"def model_run(self, model, estimators):\\n model.fit(self.X_train, self.y_train)\\n y_score = model.predict(self.X_test)\\n accu_train = np.sum(model.predict(self.X_train) == self.y_train) / self.y_train.size\\n accu_test = np.sum(y_score == self.y_test) / self.y_test.size\\n\\n self.results.write(\\\"Model Results\\\\n\\\")\\n self.results.write(\\\"Number of Estimators: \\\" + str(estimators) + \\\"\\\\n\\\")\\n self.results.write(\\\"Accuracy on Train: \\\" + str(accu_train) + \\\"\\\\n\\\")\\n self.results.write(\\\"Accuracy on Test: \\\" + str(accu_test) + \\\"\\\\n\\\")\\n return model\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n \\n y_preds = model.predict(X_test)\\n predictions = pd.DataFrame(data=y_preds, columns=Y_test.columns, index=Y_test.index)\\n for col in Y_test.columns:\\n print(classification_report(predictions[col],Y_test[col]))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.78246766","0.76479584","0.7578219","0.75720495","0.7560957","0.75514156","0.75444853","0.75016856","0.747195","0.7463784","0.745974","0.7456538","0.74170643","0.7399785","0.73661226","0.73332477","0.73242176","0.7319569","0.7294839","0.7294839","0.7294839","0.7253193","0.7248325","0.72376156","0.7231026","0.71821797","0.7166656","0.71611756","0.7125381","0.7090139","0.7089796","0.7056619","0.7050335","0.70466083","0.7029967","0.7018701","0.7010029","0.6997665","0.6995479","0.69794863","0.6974386","0.6966791","0.69617796","0.69596803","0.69490176","0.69447565","0.6927797","0.6924334","0.69239664","0.6918481","0.6917315","0.6912594","0.6899598","0.68994075","0.68893206","0.6885031","0.6884747","0.6884026","0.68776715","0.68773055","0.6873776","0.68672156","0.68623143","0.68581796","0.685395","0.6849712","0.68291825","0.6810035","0.680487","0.68023896","0.6800098","0.6797649","0.67837465","0.67832834","0.67817545","0.67786384","0.6777957","0.67686003","0.6767021","0.6762108","0.675621","0.6754865","0.67541474","0.67504466","0.67489374","0.67343444","0.67288494","0.6726523","0.6724766","0.6720984","0.6712677","0.6705669","0.6703957","0.6703014","0.6702634","0.6701217","0.6697802","0.66956854","0.6694945","0.6692676","0.66856855"],"string":"[\n \"0.78246766\",\n \"0.76479584\",\n \"0.7578219\",\n \"0.75720495\",\n \"0.7560957\",\n \"0.75514156\",\n \"0.75444853\",\n \"0.75016856\",\n \"0.747195\",\n \"0.7463784\",\n \"0.745974\",\n \"0.7456538\",\n \"0.74170643\",\n \"0.7399785\",\n \"0.73661226\",\n \"0.73332477\",\n \"0.73242176\",\n \"0.7319569\",\n \"0.7294839\",\n \"0.7294839\",\n \"0.7294839\",\n \"0.7253193\",\n \"0.7248325\",\n \"0.72376156\",\n \"0.7231026\",\n \"0.71821797\",\n \"0.7166656\",\n \"0.71611756\",\n \"0.7125381\",\n \"0.7090139\",\n \"0.7089796\",\n \"0.7056619\",\n \"0.7050335\",\n \"0.70466083\",\n \"0.7029967\",\n \"0.7018701\",\n \"0.7010029\",\n \"0.6997665\",\n \"0.6995479\",\n \"0.69794863\",\n \"0.6974386\",\n \"0.6966791\",\n \"0.69617796\",\n \"0.69596803\",\n \"0.69490176\",\n \"0.69447565\",\n \"0.6927797\",\n \"0.6924334\",\n \"0.69239664\",\n \"0.6918481\",\n \"0.6917315\",\n \"0.6912594\",\n \"0.6899598\",\n \"0.68994075\",\n \"0.68893206\",\n \"0.6885031\",\n \"0.6884747\",\n \"0.6884026\",\n \"0.68776715\",\n \"0.68773055\",\n \"0.6873776\",\n \"0.68672156\",\n \"0.68623143\",\n \"0.68581796\",\n \"0.685395\",\n \"0.6849712\",\n \"0.68291825\",\n \"0.6810035\",\n \"0.680487\",\n \"0.68023896\",\n \"0.6800098\",\n \"0.6797649\",\n \"0.67837465\",\n \"0.67832834\",\n \"0.67817545\",\n \"0.67786384\",\n \"0.6777957\",\n \"0.67686003\",\n \"0.6767021\",\n \"0.6762108\",\n \"0.675621\",\n \"0.6754865\",\n \"0.67541474\",\n \"0.67504466\",\n \"0.67489374\",\n \"0.67343444\",\n \"0.67288494\",\n \"0.6726523\",\n \"0.6724766\",\n \"0.6720984\",\n \"0.6712677\",\n \"0.6705669\",\n \"0.6703957\",\n \"0.6703014\",\n \"0.6702634\",\n \"0.6701217\",\n \"0.6697802\",\n \"0.66956854\",\n \"0.6694945\",\n \"0.6692676\",\n \"0.66856855\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":151,"numItemsPerPage":100,"numTotalItems":95772,"offset":15100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjA4NTM5MywianRpIjoiNTQxZjg5OGYtOGYxNC00NDIzLWExMmUtMmViOTgwY2EzMWI1Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYwODg5OTMsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.ezKxXFtjI_dU1kiTxhsbRasgI020ePUcr_tbtyvJdhhAm_rjoTUfl-bWIJSF-7mbLAaBEtDWFUIn3h1GxxNdBg","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 |
|---|---|---|---|---|---|---|
Callback when user is logged in. | def OnRspUserLogin(self, data: dict, error: dict, reqid: int) -> None:
if not error["ErrorID"]:
self.login_status = True
self.gateway.write_log("行情服务器登录成功")
else:
self.gateway.write_error("行情服务器登录失败", error) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_logged_in_callback(sender, request, user, **kwargs):\n logger.info(f'User {user.username} logged in from {get_client_ip(request)}')",
"def user_logged_in(self, sender, request, user, **kwargs):",
"def login_handler(self, callback):\n self.login_callback = callback",
"def on_login(self, use... | [
"0.789974",
"0.7703393",
"0.7245435",
"0.7236388",
"0.7236388",
"0.70610535",
"0.70293653",
"0.695483",
"0.6927883",
"0.68283254",
"0.6776559",
"0.67763287",
"0.67668027",
"0.6766721",
"0.66924137",
"0.658599",
"0.6539081",
"0.64897805",
"0.64482677",
"0.6437369",
"0.6432834"... | 0.0 | -1 |
Callback when error occured. | def OnRspError(self, error: dict, reqid: int, last: bool) -> None:
self.gateway.write_error("行情接口报错", error) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_error(self, callback):\n self.error_callback = callback",
"def error(self, error):\n pass",
"def handle_err(self):\n pass",
"def on_error(self, status_code, data):\n\t\tprint(\"error_code: \",status_code)",
"def error(self, handler):\n pass",
"def error(self):\n ... | [
"0.85879654",
"0.7715628",
"0.7679042",
"0.7646983",
"0.7572662",
"0.75094223",
"0.7407471",
"0.73268825",
"0.7325381",
"0.7301533",
"0.726713",
"0.7255212",
"0.7183879",
"0.71608186",
"0.7125598",
"0.71248835",
"0.7107659",
"0.7065004",
"0.7035008",
"0.70276827",
"0.70155627... | 0.6388604 | 66 |
Callback of tick data update. | def OnRtnDepthMarketData(self, data: dict) -> None:
current_date = data["TradingDay"]
current_time = data["UpdateTime"]
dt = datetime.strptime(
f'{current_date}-{current_time}', "%Y%m%d-%H:%M:%S"
)
dt = CHINA_TZ.localize(dt)
tick = TickData(
symbo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_job_tick(self, tick):",
"def update(self, ticks):\n pass",
"def update_tick(self, tick: InstigatorTick):",
"def on_tick(self, tick: TickData):\n self.tick = tick",
"def on_tick(self, tick: TickData):\n self.bg.update_tick(tick)\n print(tick)\n # self.trading = ... | [
"0.7463311",
"0.7442837",
"0.7347183",
"0.7238007",
"0.71351826",
"0.71069616",
"0.70744145",
"0.6964057",
"0.69078505",
"0.68956757",
"0.68956757",
"0.687171",
"0.6827966",
"0.67373866",
"0.6635167",
"0.6617738",
"0.6617738",
"0.6608783",
"0.6513095",
"0.64243895",
"0.639442... | 0.0 | -1 |
Start connection to server. | def connect(
self,
userid: str,
password: str,
address: str,
account_type: str,
address_type: str
) -> None:
self.userid = userid
self.password = password
self.address = address
self.account_type = account_type
self.address_type... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start(self):\n self.conn.start()",
"def start(self):\n # create socket\n try:\n self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n # 10 minutes for timeout\n self._socket.settimeout(600)\n except socket.error as msg:\n lo... | [
"0.82934177",
"0.7824189",
"0.7737643",
"0.7737643",
"0.7612089",
"0.757878",
"0.75057286",
"0.7497898",
"0.7447365",
"0.7411365",
"0.74090743",
"0.7395181",
"0.7393807",
"0.7377273",
"0.7344493",
"0.73364323",
"0.73364323",
"0.72697157",
"0.72300607",
"0.7222807",
"0.7183704... | 0.0 | -1 |
Subscribe to tick data update. | def subscribe(self, req: SubscribeRequest) -> None:
if self.login_status:
exchange = EXCHANGE_VT2TORA[req.exchange]
self.api.SubscribeMarketData([str.encode(req.symbol)], exchange) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def subscribe_ticker(self, symbol, update_handler=None):\n pass",
"def on_tick(self, tick: TickData):\n self.tick = tick",
"def subscribe(self, req: SubscribeRequest):\n tick = TickData(\n symbol=req.symbol,\n exchange=req.exchange,\n name=req.symbol,\n ... | [
"0.69724196",
"0.69078016",
"0.66735667",
"0.6626216",
"0.6624965",
"0.6597413",
"0.6534558",
"0.6439006",
"0.6439006",
"0.63466096",
"0.63453573",
"0.6293573",
"0.6279039",
"0.6268057",
"0.61558324",
"0.6137555",
"0.6033202",
"0.60168976",
"0.60114104",
"0.5989403",
"0.59863... | 0.0 | -1 |
Callback of order status update. | def OnRtnOrder(self, data: dict) -> None:
symbol = data["SecurityID"]
exchange = EXCHANGE_TORA2VT[bytes.decode(data["ExchangeID"])]
frontid = data["FrontID"]
sessionid = data["SessionID"]
order_ref = data["OrderRef"]
order_id = f"{frontid}_{sessionid}_{order_ref}"
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def update_order_status():\n symbol = App.config[\"symbol\"]\n\n # Get currently active order and id (if any)\n order = App.order\n order_id = order.get(\"orderId\", 0) if order else 0\n if not order_id:\n log.error(f\"Wrong state or use: check order status cannot find the order id.\")\... | [
"0.7749015",
"0.7728731",
"0.6911425",
"0.6906238",
"0.67833894",
"0.6753864",
"0.67357075",
"0.66341084",
"0.65383065",
"0.6533396",
"0.65114367",
"0.6507055",
"0.64955324",
"0.6472817",
"0.64492893",
"0.6402538",
"0.6388845",
"0.6340959",
"0.63233924",
"0.6302051",
"0.62727... | 0.0 | -1 |
Callback of trade status update. | def OnRtnTrade(self, data: dict) -> None:
symbol = data["SecurityID"]
exchange = EXCHANGE_TORA2VT[bytes.decode(data["ExchangeID"])]
orderid = self.sysid_orderid_map[data["OrderSysID"]]
timestamp = f"{data['TradeDate']} {data['TradeTime']}"
dt = datetime.strptime(timestamp, "%Y%... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def update_trade_status():\n # GET /api/v3/openOrders - get current open orders\n # GET /api/v3/allOrders - get all orders: active, canceled, or filled\n\n symbol = App.config[\"symbol\"]\n\n # -----\n try:\n open_orders = App.client.get_open_orders(symbol=symbol) # By \"open\" orders ... | [
"0.7169281",
"0.6498282",
"0.6427896",
"0.6379953",
"0.6349944",
"0.63152",
"0.63101655",
"0.6266528",
"0.6243253",
"0.6225849",
"0.61614215",
"0.6132186",
"0.60759616",
"0.60623944",
"0.60568434",
"0.5980201",
"0.5978488",
"0.59761935",
"0.59761935",
"0.5975587",
"0.5947008"... | 0.0 | -1 |
Callback of instrument query. | def OnRspQrySecurity(
self,
data: dict,
error: dict,
reqid: int,
last: bool
) -> None:
if last:
self.gateway.write_log("合约信息查询成功")
if not data:
return
contract = ContractData(
gateway_name=self.gateway.gateway_name,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _run_query(self):",
"def query(self, query):",
"async def query(self, metric):\n raise NotImplementedError()",
"def query(self):",
"def query(self):\n pass",
"def do(self, callback_name, *args):\n logger.info(\"Monitoring on auxiliary data started\")\n value_dict = self._e... | [
"0.6340802",
"0.6000926",
"0.57745737",
"0.5768567",
"0.5700282",
"0.56895113",
"0.5620076",
"0.5598061",
"0.55726093",
"0.55297154",
"0.55225503",
"0.5518425",
"0.5518425",
"0.54621327",
"0.54131967",
"0.53976476",
"0.53892046",
"0.53803647",
"0.5348278",
"0.5331391",
"0.533... | 0.0 | -1 |
Start connection to server. | def connect(
self,
userid: str,
password: str,
address: str,
account_type: str,
address_type: str
) -> None:
self.userid = userid
self.password = password
self.address = address
self.account_type = account_type
self.address_type... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start(self):\n self.conn.start()",
"def start(self):\n # create socket\n try:\n self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n # 10 minutes for timeout\n self._socket.settimeout(600)\n except socket.error as msg:\n lo... | [
"0.82934177",
"0.7824189",
"0.7737643",
"0.7737643",
"0.7612089",
"0.757878",
"0.75057286",
"0.7497898",
"0.7447365",
"0.7411365",
"0.74090743",
"0.7395181",
"0.7393807",
"0.7377273",
"0.7344493",
"0.73364323",
"0.73364323",
"0.72697157",
"0.72300607",
"0.7222807",
"0.7183704... | 0.0 | -1 |
Factory to make list of HeadingProduct objects from a list of Product objs. Works the same way as award.awards_list.make_list() | def make_list(products):
heading_products = []
genres = set([p.genre for p in products])
for genre in genres:
this_heading_product = HeadingProduct(genre, products)
if len(this_heading_product.products):
heading_products.append(this_heading_product)
return heading_products | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_list(cls, *args):\n return _create_list(cls, *args)",
"def create_list(cls, *args):\n return _create_list(cls, *args)",
"def test_createGlossaryByList(self):\n li = []\n li.append(['term', 'tags', 'value'])\n li.append(['foo', 'a', '1'])\n li.append(['bar', ... | [
"0.56937706",
"0.56937706",
"0.561895",
"0.5307927",
"0.52138203",
"0.5196834",
"0.51320314",
"0.5119527",
"0.50780755",
"0.5066703",
"0.50650996",
"0.5048959",
"0.5017417",
"0.49839976",
"0.49739638",
"0.49701428",
"0.4967386",
"0.49507985",
"0.48988718",
"0.4894856",
"0.489... | 0.7035925 | 0 |
same approach as the to_markup_dict() method on Product | def to_markup_dict(self, markup):
ret = self.to_dict()
ret["markup"] = markup.make(self.to_dict())
return ret | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _format_product(self, product):\n formatted = {}\n variants = []\n formatted['id'] = product.get('id')\n formatted['name'] = product.get('name')\n formatted['in_stock'] = True if product.get('stock_status') == 'instock' else False\n # Variants (Includes prices here sin... | [
"0.64752793",
"0.605072",
"0.60264534",
"0.6015541",
"0.5958979",
"0.5930521",
"0.59252644",
"0.591506",
"0.5822085",
"0.5803746",
"0.58024323",
"0.5743002",
"0.57425123",
"0.57264364",
"0.57172954",
"0.5709384",
"0.5706299",
"0.5706014",
"0.5695772",
"0.5667667",
"0.5665223"... | 0.63571995 | 1 |
Gets the meshes we need to start the script running | def get_meshes(scene):
# all the instances we want to duplicate and change the source
instances = []
# the mesh we want to use as the new source
replacement_mesh = None
# the original mesh
original_mesh = None
for item in scene.selected:
if item.isAnInstance:
i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_meshes(self):\n for meta_mesh in self.gltf.meshes:\n # Returns a list of meshes\n meshes = meta_mesh.load(self.materials)\n self.meshes.append(meshes)\n\n for mesh in meshes:\n self.scene.meshes.append(mesh)",
"def getMeshes():\n nodes... | [
"0.63373065",
"0.61222684",
"0.60875696",
"0.5780625",
"0.5610957",
"0.5601388",
"0.5586091",
"0.55387825",
"0.5537301",
"0.55358857",
"0.5527687",
"0.54873574",
"0.54691595",
"0.5454848",
"0.54036236",
"0.53925985",
"0.53647876",
"0.5352783",
"0.53096044",
"0.53068966",
"0.5... | 0.53674656 | 16 |
Parses the arguments provided through the command line. Run the program with option "h" to see a humanreadable description of the arguments | def parse_command_line_arguments():
description, epilog = __doc__.split("\n\n", 1)
parser = argparse.ArgumentParser(
formatter_class=argparse.RawDescriptionHelpFormatter,
description=description,
epilog=epilog)
parser.add_argument('-s', '--s', dest='s', action='store', type=float,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def parse_command_line(self, argv):\n from optparse import OptionParser\n usage = \"usage: %prog [options]\"\n parser = OptionParser(usage)\n\n (options, args) = parser.parse_args(argv)",
"def _parse_command_line_arguments():\n parser = ArgumentParse... | [
"0.759162",
"0.7564268",
"0.7409217",
"0.73762953",
"0.7314469",
"0.73079437",
"0.73056304",
"0.7302154",
"0.7300697",
"0.7277389",
"0.7264116",
"0.72568136",
"0.72564495",
"0.7254421",
"0.7247843",
"0.7229367",
"0.72214586",
"0.72115606",
"0.72052646",
"0.71983063",
"0.71907... | 0.7351256 | 4 |
Initializes all the needed resources for the YUV decoder | def __init__(self, input_file_path, convert_to_bgr=False):
Thread.__init__(self)
self.__logger = logging.getLogger(__name__)
# self.__logger.setLevel(logging.DEBUG)
self.__input_file_path = input_file_path
self.__convert_to_bgr = convert_to_bgr
self.__file_object = open(s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, input_file_path, convert_to_bgr=False):\n self.__yuv_video = YuvDecoder(input_file_path, convert_to_bgr=True)\n print('After INSTANTIATION')\n self.__yuv_video.start()",
"def initialize(self):\n self.conv1.reset_parameters()\n self.conv2.reset_parameters()",
... | [
"0.68046194",
"0.62969315",
"0.6167498",
"0.61130714",
"0.5984008",
"0.5953548",
"0.5937117",
"0.58982736",
"0.5884753",
"0.58662254",
"0.5835936",
"0.58020806",
"0.57903916",
"0.5711412",
"0.5692242",
"0.56784385",
"0.564403",
"0.563651",
"0.56304187",
"0.56178665",
"0.56097... | 0.0 | -1 |
Calculates the number of frames o file | def __calculate_number_of_frames(self):
# Save current position
current_pos = self.__file_object.tell()
# Go to start of first frame
self.__file_object.seek(self.__first_frame_raw_data_position)
self.number_of_frames = 0
while True:
if not self.__file_object... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getFileCount(self) -> int:\n ...",
"def fileCount(self):\n pass",
"def num_frames(length, fsize, fshift):\n pad = (fsize - fshift)\n if length % fshift == 0:\n M = (length + pad * 2 - fsize) // fshift + 1\n else:\n M = (length + pad * 2 - fsize) // fshift + 2\n retur... | [
"0.74542373",
"0.7406315",
"0.7370555",
"0.72805226",
"0.7188262",
"0.7104647",
"0.7006017",
"0.69780296",
"0.6961714",
"0.69169277",
"0.6900665",
"0.68425745",
"0.68258554",
"0.6812102",
"0.678976",
"0.6787598",
"0.67869854",
"0.6778575",
"0.6771477",
"0.67232835",
"0.670670... | 0.81756157 | 0 |
Interprets the header of the YUV file | def __read_header(self):
header = self.__file_object.readline()
header_string = header.decode('utf-8')
print(header_string)
# Ignore first letter
self.frame_width = int(re.findall('W\d+', header_string)[0][1:])
self.frame_height = int(re.findall('H\d+', header_string)[0][... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _decode_header(self):\n #header = self.file_content[0:6]\n log_screen_descr = self.file_content[6:13]\n self.canvas_width = log_screen_descr[0] + (log_screen_descr[1]<<8)\n self.canvas_height = log_screen_descr[2] + (log_screen_descr[3]<<8)\n # is there a global color table? ... | [
"0.7273211",
"0.6998706",
"0.6676672",
"0.66659373",
"0.66317815",
"0.6631482",
"0.65219945",
"0.65159136",
"0.64302945",
"0.6422038",
"0.6355497",
"0.6351281",
"0.6338665",
"0.63145584",
"0.6309015",
"0.6292449",
"0.629189",
"0.62856424",
"0.62795275",
"0.62275565",
"0.61913... | 0.74078685 | 0 |
Tries to extrapolate the subsampling method by the frame size | def determine_color_space_by_frame_size(self):
possible_sub_sampling_methods = {}
# Calculate 4:2:0 frame size
possible_sub_sampling_methods['4:2:0'] = int(
self.frame_width * self.frame_height * 3 / 2)
# Calculate 4:2:2 frame size
possible_sub_sampling_methods['4:2:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def downsample_sam(self, factor):",
"def _compute_quantized_subsamples(self):\n self._down_sample()\n self._quantize()",
"def _down_sample(self):\n self._subsamples = self._raw_data.samples[::self._down_sample_factor]\n # Neglects the redundant subsamples in the tails.\n if len(self._subsamples)... | [
"0.68432665",
"0.6632987",
"0.6390778",
"0.63845605",
"0.6257276",
"0.6140709",
"0.6111693",
"0.6003684",
"0.5990974",
"0.5911649",
"0.5829483",
"0.58266044",
"0.580334",
"0.5798149",
"0.57649136",
"0.57622963",
"0.574139",
"0.5720655",
"0.5622281",
"0.5589497",
"0.55634445",... | 0.5070363 | 86 |
Returns a buffer containing the next frame in the file | def __get_next_yuv_frame(self):
raw_frame_buffer = self.__file_object.read(self.__frame_raw_data_size)
# Ignore FRAME header
self.__file_object.readline()
return raw_frame_buffer | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_next_frame(self):\n try:\n return self.framegen.next()\n except StopIteration:\n return None",
"def __readNext(self, f) -> bytes:\n try:\n fBuffer = f.read(Rudp.Packet.payloadMax)\n except Exception as e:\n print(\"Exception when rea... | [
"0.658763",
"0.6512409",
"0.64798796",
"0.63112426",
"0.6304167",
"0.6280922",
"0.62393665",
"0.6209724",
"0.6112247",
"0.6055701",
"0.5982976",
"0.5950312",
"0.5921946",
"0.59020406",
"0.5859815",
"0.58452123",
"0.5819238",
"0.5807083",
"0.57893544",
"0.5751586",
"0.5741709"... | 0.7203122 | 0 |
Builds a YUV frame from the 3 planes | def __concatenate_planes_to_444yuv_frame(self, y_plane, u_plane, v_plane):
np.set_printoptions(formatter={'int': hex})
y_plane.shape = (self.frame_height, self.frame_width, 1)
u_plane.shape = (self.frame_height, self.frame_width, 1)
v_plane.shape = (self.frame_height, self.frame_width, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bytes_to_yuv(data, resolution):\n width, height = resolution\n fwidth, fheight = raw_resolution(resolution)\n y_len = fwidth * fheight\n uv_len = (fwidth // 2) * (fheight // 2)\n if len(data) != (y_len + 2 * uv_len):\n raise PiCameraValueError(\n 'Incorrect buffer length for re... | [
"0.6178987",
"0.6112994",
"0.60437536",
"0.60061175",
"0.5818813",
"0.5782524",
"0.5594121",
"0.5592523",
"0.55896294",
"0.5515905",
"0.54654443",
"0.54456806",
"0.5360084",
"0.5344593",
"0.5332781",
"0.5281292",
"0.52807987",
"0.5253911",
"0.5192978",
"0.51899076",
"0.517477... | 0.70961094 | 0 |
Gets the next frame from the stream as RGB. Returns (False, None) if EOF. | def next_frame(self):
while True:
if self.grabbed:
buffer = self.__get_next_yuv_frame()
if len(buffer) != self.__frame_raw_data_size:
self.frame = False, False
self.stopped = True
break
y, u,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __next__(self):\n while True:\n self.stream_bytes += self.stream_conn.read(1024)\n first = bytearray(self.stream_bytes).find(b'\\xff\\xd8')\n last = bytearray(self.stream_bytes).find(b'\\xff\\xd9')\n if first != -1 and last != -1:\n jpg = self.s... | [
"0.6480714",
"0.63872474",
"0.6296677",
"0.6196712",
"0.5917676",
"0.587839",
"0.579213",
"0.5756493",
"0.56737775",
"0.56716037",
"0.5643117",
"0.5601835",
"0.5566194",
"0.5565655",
"0.5558515",
"0.55306965",
"0.5480496",
"0.5423163",
"0.5407114",
"0.5400058",
"0.53833944",
... | 0.54139644 | 18 |
Gracefully closes the resources | def close(self):
self.__file_object.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def close():",
"def do_close(self):\n self.cleanup(True)\n self.close()",
"def cleanup(self):\n self.io.close()",
"def close(self):\n for lrms in self.resources.itervalues():\n lrms.close()",
"def close(self) -> None:",
"def close(self) -> None:",
"def close(self)... | [
"0.7931051",
"0.7838053",
"0.761006",
"0.7568386",
"0.75207824",
"0.75207824",
"0.75207824",
"0.75207824",
"0.75207824",
"0.75207824",
"0.75207824",
"0.75207824",
"0.7486898",
"0.74619836",
"0.74619836",
"0.7451234",
"0.74416775",
"0.74416775",
"0.7441357",
"0.7432075",
"0.74... | 0.0 | -1 |
Creates a video player object with the specified input file path | def __init__(self, input_file_path, convert_to_bgr=False):
self.__yuv_video = YuvDecoder(input_file_path, convert_to_bgr=True)
print('After INSTANTIATION')
self.__yuv_video.start() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_video_from_path(path: Union[Path, str]) -> videoType:\n\n if isinstance(path, str):\n path = Path(path)\n video_path = path.resolve()\n if video_path.exists():\n print(f\"Video loaded from {video_path}\")\n vid: videoType = cv2.VideoCapture(str(video_path))\n else:\n ... | [
"0.6658787",
"0.6298418",
"0.62545097",
"0.61926234",
"0.6146118",
"0.60982794",
"0.60793835",
"0.6035831",
"0.6027104",
"0.6026964",
"0.598783",
"0.59465235",
"0.5931537",
"0.58999956",
"0.58965343",
"0.58954424",
"0.58553547",
"0.58519715",
"0.5841672",
"0.5807772",
"0.5807... | 0.61915356 | 4 |
Plays the specified stream | def play_video(self):
cv.namedWindow('Planes', cv.WINDOW_NORMAL)
cv.resizeWindow('Planes', self.__yuv_video.frame_width, self.__yuv_video.frame_height)
inter_frame_delay = int(1000 / self.__yuv_video.frame_rate)
while True:
(ret, frame) = self.__yuv_video.get_frame()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def play(self, stream_url):\n print(\"Ready to play \" + stream_url)\n self.close()\n\n opts = [\"mplayer\", \"-quiet\", \n \"-slave\",\n \"-softvol\",\n \"-cache\", str(self.config.get('cache-kb')),\n \"-cache-min\", str(self.config.get('cache-min')... | [
"0.7143811",
"0.7028232",
"0.69565",
"0.6894225",
"0.6752168",
"0.6553306",
"0.64828676",
"0.6470522",
"0.6458766",
"0.644849",
"0.6426984",
"0.6425514",
"0.63402015",
"0.63358396",
"0.6331446",
"0.63015044",
"0.6297024",
"0.6294525",
"0.6294525",
"0.6217255",
"0.6208271",
... | 0.0 | -1 |
Do not return anything, modify matrix inplace instead. | def setZeroes(self, matrix: List[List[int]]) -> None:
m, n = len(matrix), len(matrix[0]) if matrix else 0
row = [False for _ in range(m)]
col = [False for _ in range(n)]
for i in range(m):
for j in range(n):
if matrix[i][j] == 0:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __update_matrix(self, old_matrix_view):\n # if we've cleaned dirt - we will see it on our next move, so we substitute only unseen cells\n # which are marked with \"o\"\n new_matrix_view = []\n for row in range(self.matrix_rows):\n new_matrix_view.append([char for char in ... | [
"0.70664227",
"0.684492",
"0.6359314",
"0.6214309",
"0.61908424",
"0.6126168",
"0.6038709",
"0.5992883",
"0.5966755",
"0.5938156",
"0.5928229",
"0.5917942",
"0.5897078",
"0.5853082",
"0.58382195",
"0.580802",
"0.5800106",
"0.57914895",
"0.57380044",
"0.57230836",
"0.57099885"... | 0.0 | -1 |
Do not return anything, modify matrix inplace instead. | def setZeroes(self, matrix: List[List[int]]) -> None:
m, n = len(matrix), len(matrix[0]) if matrix else 0
# Use first row to store zero-info for each col
# Use first col to store zero-info for each row
# matrix[0][0] will store col info
is_first_row = any(x == 0... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __update_matrix(self, old_matrix_view):\n # if we've cleaned dirt - we will see it on our next move, so we substitute only unseen cells\n # which are marked with \"o\"\n new_matrix_view = []\n for row in range(self.matrix_rows):\n new_matrix_view.append([char for char in ... | [
"0.70664227",
"0.684492",
"0.6359314",
"0.6214309",
"0.61908424",
"0.6126168",
"0.6038709",
"0.5992883",
"0.5966755",
"0.5938156",
"0.5928229",
"0.5917942",
"0.5897078",
"0.5853082",
"0.58382195",
"0.580802",
"0.5800106",
"0.57914895",
"0.57380044",
"0.57230836",
"0.57099885"... | 0.0 | -1 |
Class to train and evaluate a Base Cluster Class with Number of Clusters Specified evaluate_by = column name to use to compare across the clusters eventually | def __init__(self,
X,
n_clusters=2,
evaluate_by=None,
scaled=True,
random_state=101,
space=None,
const_params=None,
loss_fun=None):
self.evaluate_by = evaluate_by
if (... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate(self):\n results = dict()\n for metric in self.metrics:\n print('Evaluating clustering with metric %s' % metric)\n if metric in LABEL_METRICS.keys():\n results[metric] = LABEL_METRICS[metric](self.X, self.model.labels_)\n results['adjusted_rand... | [
"0.6347601",
"0.6259447",
"0.6242199",
"0.619887",
"0.6134004",
"0.6122757",
"0.6117709",
"0.6106118",
"0.61054987",
"0.6089926",
"0.60873955",
"0.6071255",
"0.60541445",
"0.6051448",
"0.60498863",
"0.6030983",
"0.60236627",
"0.60101587",
"0.5973187",
"0.5970434",
"0.5955364"... | 0.7258767 | 0 |
Train the clustering method | def train(self, n_clusters=None, merge=True):
if (n_clusters is not None):
self.n_clusters = n_clusters
setattr(self.cluster_obj, 'n_clusters', self.n_clusters)
if (self.scaled):
self.cluster_obj.fit(self.X_scaled)
else:
self.cluster_obj.fit(self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self):\n\n print \"==> Running Kmeans on data set of shape: {}\".format(self.data.shape)\n km = KMeans(n_clusters = self.n_clusters)\n km.fit(self.data.values)\n self.labels = km.labels_\n self.inertia = km.inertia_",
"def train(x_train, y_train, x_test, y_test):\n\n ... | [
"0.7712707",
"0.72494555",
"0.7233073",
"0.71406126",
"0.7139295",
"0.69487053",
"0.6906541",
"0.6893633",
"0.6839416",
"0.6824507",
"0.6815389",
"0.67691666",
"0.67483765",
"0.674466",
"0.67176473",
"0.67146057",
"0.668835",
"0.668835",
"0.668835",
"0.668835",
"0.668835",
... | 0.6333595 | 70 |
Provides the Goodness of Fit Statistics for the clustering algorithm | def evaluate_fit(self,
metric="silhoutte"):
if (metric == "silhoutte"):
if (self.scaled):
self.silhoutte_score = (
metrics.silhouette_score(
self.X_scaled,
self.labels,
ra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit(self):\n self.cluseter_agglomerative(n_clusters=20, linkage='average', iterate=5)\n self.sub_clustering(n_clusters=3, index_cluster=[79], linkage='complete')\n self.merge_clusters([[0,9,53],[1,83],[46,35,67],[88,23],[6,68]])\n self.merge_clusters([[6,33,52],[17,14]])\n se... | [
"0.63789237",
"0.6352993",
"0.6279656",
"0.62341934",
"0.6150818",
"0.61435586",
"0.61145175",
"0.6083344",
"0.6083169",
"0.6061328",
"0.60520655",
"0.60070646",
"0.5999566",
"0.59873974",
"0.59863216",
"0.59418356",
"0.59418356",
"0.588487",
"0.5862444",
"0.5856919",
"0.5843... | 0.541007 | 87 |
Gives the number of observations in each cluster | def cluster_obs_count(self):
return(self.merged_data.groupby(
'labels').count().transpose().iloc[0, :]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cluster_count(self) -> int:\n return len(self.get_all_cluster_ids())",
"def cluster_count(self) -> int:\n cluster_count = max(1, round(16**3 * (self.vein.purity / 100.0) / self.cluster_size))\n return self.distribution.scale_cluster_count(cluster_count)",
"def analysis_function_num... | [
"0.7697342",
"0.7521841",
"0.74846464",
"0.745221",
"0.73620665",
"0.7293663",
"0.7275436",
"0.7197757",
"0.7003787",
"0.6995928",
"0.6992263",
"0.69813204",
"0.68972546",
"0.67149794",
"0.6631092",
"0.66106117",
"0.6603212",
"0.65768135",
"0.65458935",
"0.65229785",
"0.64970... | 0.8255985 | 0 |
Provides the means of the cluster features for each cluster If evaluate_by is set, then clusters will be sorted by the mean value of the "evaluate_by" column | def cluster_means(self):
if self.evaluate_by is not None:
return(self.merged_data.groupby(
'labels').mean().sort_values(self.evaluate_by).transpose())
else:
return(self.merged_data.groupby('labels').mean().transpose()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cluster_means_scaled(self):\n if self.evaluate_by is not None:\n return(self.merged_scaled_data.groupby(\n 'labels').mean().sort_values(self.evaluate_by).transpose())\n else:\n return(self.merged_scaled_data.groupby(\n 'labels').mean().transpose... | [
"0.74477243",
"0.64676",
"0.630643",
"0.61944944",
"0.6128539",
"0.6070738",
"0.604014",
"0.58796227",
"0.58664966",
"0.5865818",
"0.584644",
"0.5843564",
"0.57876366",
"0.5773927",
"0.5773633",
"0.5760417",
"0.57511604",
"0.57441485",
"0.57324463",
"0.5730679",
"0.5674215",
... | 0.8206238 | 0 |
Provides the means (scaled) of the cluster features for each cluster If evaluate_by is set, then clusters will be sorted by the mean value of the "evaluate_by" column | def cluster_means_scaled(self):
if self.evaluate_by is not None:
return(self.merged_scaled_data.groupby(
'labels').mean().sort_values(self.evaluate_by).transpose())
else:
return(self.merged_scaled_data.groupby(
'labels').mean().transpose()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cluster_means(self):\n if self.evaluate_by is not None:\n return(self.merged_data.groupby(\n 'labels').mean().sort_values(self.evaluate_by).transpose())\n else:\n return(self.merged_data.groupby('labels').mean().transpose())",
"def _compute_cluster_averages(... | [
"0.8101285",
"0.63563937",
"0.6221742",
"0.6118103",
"0.6082124",
"0.60302347",
"0.5986253",
"0.59648865",
"0.5944979",
"0.58651084",
"0.5829008",
"0.582223",
"0.58143276",
"0.5798003",
"0.5790433",
"0.57677114",
"0.5756863",
"0.5707412",
"0.5699087",
"0.56949383",
"0.5688631... | 0.8028111 | 1 |
Plot the parallel coordinate plots for the features in each cluster | def plot_parallel_coordinates(self,
scaled=True,
frac=0.05,
figsize=(12, 6),
xrot=0):
if (scaled):
vh.plot_parallel_coordinates(data=self.merged_scaled_data,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plotClusters(self):\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n fig.set_size_inches(18.5, 9.5)\n ax.set_title('Identification of Cluster Particles with Voronoi Volumes', fontsize=22)\n ax.set_xlabel('x [m]', fontsize=18)\n ax.set_ylabel('y [m]',... | [
"0.76316774",
"0.7617254",
"0.75599796",
"0.72110313",
"0.7137577",
"0.6990033",
"0.6882812",
"0.68758214",
"0.68178517",
"0.67636615",
"0.67213136",
"0.6671495",
"0.6667161",
"0.66629606",
"0.6654885",
"0.66313726",
"0.66146934",
"0.6613701",
"0.66068953",
"0.6563773",
"0.65... | 0.6238072 | 44 |
Always plots the with unscaled data irrespecive of what was used for training. This ensures, we maintain the original context. | def plot_means_heatmap(self,
scale_rows=True,
cmap='viridis',
figsize=(6, 6),
annot=False,
valfmt="{x:.1f}",
fontsize=12,
fontweigh... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_original(self):\n #check if it is in color or grayscale\n if self.scaled.shape[-1] == 3:\n plt.imshow(self.scaled)\n plt.axis(\"off\")\n plt.show()\n else:\n plt.imshow(self.scaled, cmap=\"gray\")\n plt.axis(\"off\")\n ... | [
"0.66189766",
"0.6493985",
"0.644305",
"0.63004386",
"0.6300371",
"0.6198771",
"0.61908394",
"0.6128892",
"0.61004347",
"0.60623384",
"0.60620713",
"0.6049097",
"0.60434496",
"0.60070294",
"0.5978044",
"0.59771746",
"0.592588",
"0.5924549",
"0.5912928",
"0.5877057",
"0.586584... | 0.0 | -1 |
Convert the datapoint into a pandas DataFrame. | def to_pandas(self, camel_case: bool = False) -> pandas.DataFrame: # type: ignore[override]
pd = cast(Any, local_import("pandas"))
dumped = self.dump(camel_case=camel_case)
timestamp = dumped.pop("timestamp")
return pd.DataFrame(dumped, index=[pd.Timestamp(timestamp, unit="ms")]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_pandas_df(self):\n data = self._get_data(pd=True)\n return data",
"def _to_dataframe(self, dataset_name):\n values = self[dataset_name][:]\n columns = self.get_columns(dataset_name)\n timestamps = self.get_timestamps(dataset_name)[...]\n if len(columns) < values.s... | [
"0.7275672",
"0.7162703",
"0.70742196",
"0.7039702",
"0.6986552",
"0.6943344",
"0.6943344",
"0.69128364",
"0.69108045",
"0.6888451",
"0.6863301",
"0.6789416",
"0.67679477",
"0.6743493",
"0.6637931",
"0.6491211",
"0.6372196",
"0.63680935",
"0.6360144",
"0.6356569",
"0.6350265"... | 0.6223477 | 39 |
Dump the DatapointsArray into a json serializable Python data type. | def dump(self, camel_case: bool = False, convert_timestamps: bool = False) -> Dict[str, Any]:
attrs, arrays = self._data_fields()
if not convert_timestamps: # Eh.. so.. we still have to convert...
arrays[0] = arrays[0].astype("datetime64[ms]").astype(np.int64)
else:
# No... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def json_serialize_numpy_array(array):\n return json.dumps(json_ready_numpy_array(array))",
"def json_serialize_numpy_array(array):\n return json.dumps(json_ready_numpy_array(array))",
"def serialize(self, data):\n if isinstance(data, dict):\n return json.dumps(\n {\n ... | [
"0.6917405",
"0.6917405",
"0.66256297",
"0.6568424",
"0.65429455",
"0.62955934",
"0.6242224",
"0.6130758",
"0.6124644",
"0.61071646",
"0.6085675",
"0.60757726",
"0.6034072",
"0.6031695",
"0.5964728",
"0.5943574",
"0.59400827",
"0.5803232",
"0.57991076",
"0.5782903",
"0.578060... | 0.57586277 | 22 |
Convert the DatapointsArray into a pandas DataFrame. | def to_pandas( # type: ignore [override]
self,
column_names: Literal["id", "external_id"] = "external_id",
include_aggregate_name: bool = True,
include_granularity_name: bool = False,
) -> pandas.DataFrame:
pd = cast(Any, local_import("pandas"))
if column_names == "i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _to_dataframe(self, dataset_name):\n values = self[dataset_name][:]\n columns = self.get_columns(dataset_name)\n timestamps = self.get_timestamps(dataset_name)[...]\n if len(columns) < values.shape[1]:\n columns.resize(values.shape[1])\n\n # transform missing data ... | [
"0.70953417",
"0.70682985",
"0.690592",
"0.6754507",
"0.67391706",
"0.66165286",
"0.6560893",
"0.6546581",
"0.6533122",
"0.6470177",
"0.6456739",
"0.64290935",
"0.64260834",
"0.63697124",
"0.6347784",
"0.6347784",
"0.6338845",
"0.6321473",
"0.6319904",
"0.63081855",
"0.618971... | 0.5750251 | 66 |
Dump the datapoints into a json serializable Python data type. | def dump(self, camel_case: bool = False) -> Dict[str, Any]:
dumped = {
"id": self.id,
"external_id": self.external_id,
"is_string": self.is_string,
"is_step": self.is_step,
"unit": self.unit,
"datapoints": [dp.dump(camel_case=camel_case) fo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dump(self, data_points):\n print(data_points)",
"def serialize(self, data):\n if isinstance(data, dict):\n return json.dumps(\n {\n key: value.tolist() if isinstance(value, np.ndarray) else value\n for key, value in data.items()\n ... | [
"0.69947106",
"0.6595288",
"0.64354455",
"0.64343506",
"0.63421845",
"0.63324994",
"0.63205224",
"0.63117635",
"0.6263104",
"0.62422466",
"0.6237221",
"0.6157662",
"0.61288905",
"0.6121606",
"0.6094647",
"0.60797375",
"0.6019733",
"0.59913826",
"0.595882",
"0.595867",
"0.5938... | 0.0 | -1 |
Convert the datapoints into a pandas DataFrame. | def to_pandas( # type: ignore [override]
self,
column_names: str = "external_id",
include_aggregate_name: bool = True,
include_granularity_name: bool = False,
include_errors: bool = False,
) -> pandas.DataFrame:
pd = cast(Any, local_import("pandas"))
if colum... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _to_dataframe(self, dataset_name):\n values = self[dataset_name][:]\n columns = self.get_columns(dataset_name)\n timestamps = self.get_timestamps(dataset_name)[...]\n if len(columns) < values.shape[1]:\n columns.resize(values.shape[1])\n\n # transform missing data ... | [
"0.76260304",
"0.7595923",
"0.74861777",
"0.7397173",
"0.7382126",
"0.71352553",
"0.7028942",
"0.6888257",
"0.6883333",
"0.68173844",
"0.68173844",
"0.6742965",
"0.6644486",
"0.66278166",
"0.66209453",
"0.6607725",
"0.66036254",
"0.66008824",
"0.6582569",
"0.65765226",
"0.656... | 0.0 | -1 |
Concatenates all arrays with duplicated IDs. Arrays with the same ids are stacked in chronological order. Caveat This method is not guaranteed to preserve the order of the list. | def concat_duplicate_ids(self) -> None:
# Rebuilt list instead of removing duplicated one at a time at the cost of O(n).
self.data.clear()
# This implementation takes advantage of the ordering of the duplicated in the __init__ method
has_external_ids = set()
for ext_id, items i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def combine_ids(ids):\r\n return hash_all(sorted(ids)) # We sort so that the id isn't sensitive to order.\r",
"def flat_unique(ls):\n return list(unique(chain.from_iterable(ls), key=id))",
"def remove_duplicates_array(self, array: List) -> List:\n seen = set()\n seen_add = seen.add\n ... | [
"0.6108058",
"0.6034065",
"0.56852865",
"0.5684234",
"0.5662172",
"0.5658944",
"0.5629316",
"0.5507034",
"0.5439302",
"0.54389274",
"0.5396021",
"0.53948885",
"0.53855747",
"0.538059",
"0.53791827",
"0.53729856",
"0.5346434",
"0.53187525",
"0.52948135",
"0.5288018",
"0.527519... | 0.7894388 | 0 |
Get a specific DatapointsArray from this list by id or exernal_id. | def get( # type: ignore [override]
self,
id: Optional[int] = None,
external_id: Optional[str] = None,
) -> Union[None, DatapointsArray, List[DatapointsArray]]:
# TODO: Question, can we type annotate without specifying the function?
return super().get(id, external_id) # type... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get( # type: ignore [override]\n self,\n id: Optional[int] = None,\n external_id: Optional[str] = None,\n ) -> Union[None, Datapoints, List[Datapoints]]:\n # TODO: Question, can we type annotate without specifying the function?\n return super().get(id, external_id) # typ... | [
"0.6054171",
"0.5667537",
"0.54831964",
"0.54567707",
"0.53983647",
"0.5365511",
"0.5321282",
"0.51933724",
"0.5130589",
"0.5129982",
"0.5032065",
"0.50203216",
"0.5008644",
"0.49614123",
"0.4957775",
"0.49143854",
"0.48843566",
"0.48525918",
"0.4837254",
"0.48273316",
"0.482... | 0.6824546 | 0 |
Convert the DatapointsArrayList into a pandas DataFrame. | def to_pandas( # type: ignore [override]
self,
column_names: Literal["id", "external_id"] = "external_id",
include_aggregate_name: bool = True,
include_granularity_name: bool = False,
) -> pandas.DataFrame:
pd = cast(Any, local_import("pandas"))
dfs = [dps.to_pandas(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def as_dataframe(self) -> \"pd.DataFrame\":\n import pandas as pd\n\n df = pd.DataFrame([row.as_series() for row in self.rows])\n return df",
"def to_dataframe(dslist):\n from pytraj.utils import _import_pandas\n has_pandas, pd = _import_pandas()\n \n if not has_pandas:\n ... | [
"0.70076054",
"0.68862015",
"0.680678",
"0.67758507",
"0.6767373",
"0.67039317",
"0.66800386",
"0.6670868",
"0.66436577",
"0.66392887",
"0.6600126",
"0.65596896",
"0.65596896",
"0.65123266",
"0.6492922",
"0.64803016",
"0.6430784",
"0.63652426",
"0.6329354",
"0.6299667",
"0.62... | 0.56777686 | 84 |
Dump the instance into a json serializable Python data type. | def dump(self, camel_case: bool = False, convert_timestamps: bool = False) -> List[Dict[str, Any]]:
return [dps.dump(camel_case, convert_timestamps) for dps in self] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dump(self):\n return json.dumps(self.__data)",
"def json (self):\n\n return jsonpickle.encode(self, unpicklable=False)",
"def json (self):\n\n return jsonpickle.encode(self, unpicklable=False)",
"def cls2json(self):\n return json.dumps(self.__dict__)",
"def cls2json(self):\n... | [
"0.7410046",
"0.7390639",
"0.7390639",
"0.7369746",
"0.7369746",
"0.734897",
"0.73247975",
"0.73004895",
"0.72948474",
"0.72887063",
"0.7257161",
"0.7257161",
"0.7257161",
"0.71929294",
"0.71359366",
"0.7125709",
"0.70946866",
"0.70464027",
"0.70386195",
"0.70275664",
"0.7023... | 0.0 | -1 |
Get a specific Datapoints from this list by id or exernal_id. | def get( # type: ignore [override]
self,
id: Optional[int] = None,
external_id: Optional[str] = None,
) -> Union[None, Datapoints, List[Datapoints]]:
# TODO: Question, can we type annotate without specifying the function?
return super().get(id, external_id) # type: ignore [... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get( # type: ignore [override]\n self,\n id: Optional[int] = None,\n external_id: Optional[str] = None,\n ) -> Union[None, DatapointsArray, List[DatapointsArray]]:\n # TODO: Question, can we type annotate without specifying the function?\n return super().get(id, external_... | [
"0.61743337",
"0.59749645",
"0.5939584",
"0.58991456",
"0.57974106",
"0.5651259",
"0.55687577",
"0.55102324",
"0.54533166",
"0.5403147",
"0.53751576",
"0.53591925",
"0.53410923",
"0.53159577",
"0.52451044",
"0.5237156",
"0.5236404",
"0.52126646",
"0.516919",
"0.5158489",
"0.5... | 0.6380494 | 0 |
Convert the datapoints list into a pandas DataFrame. | def to_pandas( # type: ignore [override]
self,
column_names: Literal["id", "external_id"] = "external_id",
include_aggregate_name: bool = True,
include_granularity_name: bool = False,
) -> pandas.DataFrame:
pd = cast(Any, local_import("pandas"))
dfs = [dps.to_pandas(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _list_to_df(self, data):\n indices = pd.tseries.index.DatetimeIndex(\n [data[x]['time'] for x in range(0, len(data))])\n outData = pd.DataFrame(data, index=indices)\n outData.columns = ['Ask_close', 'Bid_close', 'complete',\n 'Ask_high', 'Bid_high', 'As... | [
"0.7257707",
"0.7187801",
"0.70569354",
"0.69478846",
"0.682004",
"0.6778485",
"0.66762257",
"0.66401494",
"0.6633746",
"0.65886825",
"0.650772",
"0.64041877",
"0.638807",
"0.6384034",
"0.6351428",
"0.63409454",
"0.6307943",
"0.6295035",
"0.6282479",
"0.6234472",
"0.62033075"... | 0.0 | -1 |
Get filename for simulated community produced by mete.sim_spatial_whole() | def comm_filename(S, N, ncomm, bisec, transect=False, abu=None, comm_name=None):
if not comm_name:
comm_name = 'S%s_N%s' % (S, N)
if abu:
empir = '_empirSAD'
else:
empir = ''
if transect:
runtype = 'transect'
else:
runtype = 'grid'
return... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filename(self):\n return os.path.basename(self._spatial_filename)",
"def get_sim_file(cls, root_dir, constants):\n return os.path.join(root_dir, '%s.hdf5' % constants['mos_type'])",
"def get_sim_file(cls, root_dir, constants):\n return os.path.join(root_dir, '%s.hdf5' % constants['mos_... | [
"0.65646577",
"0.6268533",
"0.6268533",
"0.6141475",
"0.6039565",
"0.59756315",
"0.5955562",
"0.5923402",
"0.5783788",
"0.572006",
"0.5696253",
"0.5686741",
"0.56813705",
"0.5656483",
"0.56059337",
"0.557937",
"0.5579157",
"0.5563723",
"0.552336",
"0.5519685",
"0.55115503",
... | 0.5922241 | 8 |
execute_call rtype [stdout, stderr] | def __init__(self, execute_call):
self._exe = execute_call | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shell_call(cmd):\n try:\n x = subprocess.run(\n cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True\n )\n ret = (x.returncode, str(x.stdout, \"utf-8\"), str(x.stderr, \"utf-8\"))\n return ret\n except subprocess.SubprocessError as e:\n ... | [
"0.6699401",
"0.6614548",
"0.65856606",
"0.6457852",
"0.63748205",
"0.63311875",
"0.62365687",
"0.6107923",
"0.60889196",
"0.6088098",
"0.60574377",
"0.6047747",
"0.5997989",
"0.59733754",
"0.597151",
"0.59694576",
"0.5967142",
"0.5951768",
"0.5942475",
"0.5924821",
"0.590206... | 0.0 | -1 |
Intialize Paillier object with seed. | def __init__(self, seed=None, g=None, n=None, Lambda=None, mu=None):
if seed is None:
# initialization of these values directly is useful for testing purposes.
if not (g and n and Lambda and mu):
raise ValueError('If seed is set to none then g, n, Lambda and mu'
' need t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize(self, seed=None):\r\n self.seed(seed)",
"def seed():",
"def setUp(self) -> None:\n self.random = np.random.RandomState(seed=42)",
"def setup_method(cls):\n seed()",
"def __init__(self, user_ctor, seed=0):\n self._user_ctor = user_ctor\n self._seed = seed\n self.... | [
"0.7124703",
"0.6873926",
"0.66557026",
"0.6635872",
"0.66220367",
"0.66217875",
"0.6620926",
"0.6619582",
"0.6579991",
"0.6579991",
"0.65695995",
"0.6544197",
"0.6544197",
"0.6466076",
"0.64453214",
"0.63837",
"0.63440156",
"0.6340025",
"0.6286774",
"0.6257284",
"0.6195322",... | 0.0 | -1 |
Paillier encryption of plaintext. | def Encrypt(self, plaintext, r_value=None):
if not isinstance(plaintext, int) and not isinstance(plaintext, long):
raise ValueError('Expected int or long type plaintext but got: %s' %
type(plaintext))
r = r_value or self._GetRandomFromZNStar(N_LENGTH, self.n)
return (ModExp(sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def encrypt(key, plaintext):\n data = fk(keyGen(key)[0], ip(plaintext))\n return fp(fk(keyGen(key)[1], swapNibbles(data)))",
"def encrypt(self, plaintext):\n return self._transform(plaintext, self._forward)",
"def encrypt(self, plaintext: str) -> str:\n\n return self.run(plaintext, Cryptogr... | [
"0.74186486",
"0.7412809",
"0.7190593",
"0.71807045",
"0.717247",
"0.71419",
"0.7132922",
"0.7085513",
"0.7065311",
"0.7059154",
"0.7038782",
"0.6996194",
"0.69921005",
"0.69722354",
"0.69490004",
"0.6947714",
"0.69423634",
"0.690892",
"0.6870051",
"0.6833222",
"0.68193686",
... | 0.0 | -1 |
Paillier decryption of ciphertext. | def Decrypt(self, ciphertext):
if not isinstance(ciphertext, int) and not isinstance(ciphertext, long):
raise ValueError('Expected int or long type ciphertext but got: %s' %
type(ciphertext))
u = ModExp(ciphertext, self.__lambda, self.nsquare)
l_of_u = (u - 1) // self.n
retu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def decrypt(self, data):",
"def decrypt(self, ciphertext):\n return self._transform(ciphertext, self._backward)",
"def decrypt(self, ciphertext: bytes,\n padding: AsymmetricPadding) -> bytes:\n pass",
"def decrypt(key, ciphertext):\n data = fk(keyGen(key)[1], ip(ciphertext))\n... | [
"0.7848477",
"0.75641656",
"0.7524535",
"0.73206985",
"0.7286307",
"0.72835225",
"0.72690964",
"0.72618794",
"0.7212608",
"0.7205247",
"0.7195099",
"0.7137887",
"0.71262866",
"0.7091146",
"0.7087095",
"0.70816773",
"0.70771307",
"0.7038318",
"0.7032224",
"0.70132124",
"0.7003... | 0.6916724 | 26 |
returns E(m1 + m2) given E(m1) and E(m2). | def Add(self, ciphertext1, ciphertext2):
for c in (ciphertext1, ciphertext2):
if not isinstance(c, int) and not isinstance(c, long):
raise ValueError('Expected int or long type for %s but got %s' %
(c, type(c)))
return ciphertext1 * ciphertext2 % self.nsquare | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge_energies(e1, m1, e2, m2):\n e = sorted(list(set(e1) | set(e2)))\n return extend_energies(e, e1, m1), extend_energies(e, e2, m2)",
"def add_evaluations(e1, e2):\n true_positive = e1[0] + e2[0]\n false_positive = e1[1] + e2[1]\n distance = e1[2] + e2[2]\n ... | [
"0.6536726",
"0.65350455",
"0.6385849",
"0.6172982",
"0.6172982",
"0.61607146",
"0.60881215",
"0.6072571",
"0.6053043",
"0.59517604",
"0.5910559",
"0.5869283",
"0.586799",
"0.585753",
"0.5848492",
"0.581566",
"0.5808591",
"0.5779007",
"0.57597685",
"0.5756444",
"0.57328486",
... | 0.0 | -1 |
Returns E(am + b) given E(m), a and b. | def Affine(self, ciphertext, a=1, b=0):
# This works for raw paillier payload but may not for int64/float payload.
# First multiply ciphertext with a
a_mult_ciphertext = pow(ciphertext, a, self.nsquare)
# Add b to it.
return a_mult_ciphertext * pow(self.g, b, self.nsquare) % self.nsquare | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def f(m, x, b):\n return m*x + b",
"def e_add(pub, a, b):\n return a * b % pub.n_sq",
"def expFromAdd(a,b):\n\tif (b == 0):\n\t\treturn 1\n\tresult = 1\n\tfor c1 in range(0, b):\n\t\ttemp = 0\n\t\tfor c2 in range(0, a):\n\t\t\ttemp += result\n\t\tresult = temp\n\treturn result",
"def compute_e(f_mat, m_m... | [
"0.67376345",
"0.6200308",
"0.59969324",
"0.5870638",
"0.5860816",
"0.58210766",
"0.5788327",
"0.5785067",
"0.5766659",
"0.5740566",
"0.57211226",
"0.57102543",
"0.5681401",
"0.5625148",
"0.56201667",
"0.5617707",
"0.561648",
"0.5609634",
"0.5599497",
"0.5594552",
"0.5576395"... | 0.0 | -1 |
Paillier encryption of an Int64 plaintext. Paillier homomorphic addition only directly adds positive values, however, we would like to add both positive and negative values (i.e. int64 is signed). To achieve this, we will represent negative values with twos complement representation. Also, in order to detect overflow a... | def EncryptInt64(self, plaintext, r_value=None):
if not isinstance(plaintext, int) and not isinstance(plaintext, long):
raise ValueError('Expected int or long plaintext but got: %s' %
type(plaintext))
if plaintext < MIN_INT64 or plaintext > MAX_INT64:
raise ValueError('Int64 v... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _raw_mul(self, plaintext):\n if not isinstance(plaintext, int) and not isinstance(plaintext, type(mpz(1))) and not isinstance(plaintext, numpy.int64):\n raise TypeError('Expected ciphertext to be int, not %s' %\n type(plaintext))\n\n if plaintext < 0 or plaintext >= self... | [
"0.5790192",
"0.576911",
"0.56213176",
"0.54513925",
"0.5386436",
"0.53785866",
"0.5376329",
"0.5372119",
"0.5359393",
"0.53206307",
"0.5317017",
"0.53136617",
"0.5303635",
"0.5297727",
"0.52348304",
"0.52161306",
"0.51484716",
"0.51110023",
"0.508157",
"0.50726026",
"0.50640... | 0.652218 | 0 |
Paillier encryption of multiple 64 bit integers into a single payload. | def EncryptMultipleInt64s(self, numberlist, r_value=None):
plaintext = 0
number_counter = 0
if len(numberlist) > PACKING_LIMIT:
raise ValueError('The number of entries in the input list cannot be'
+ ' more than %d' % (PACKING_LIMIT))
for entry in numberlist:
if not isi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pack_uint64s(data: List[int]) -> bytes:\n result = b\"\"\n for i in data:\n result += pack_uint64(i)\n return result",
"def rop64(*args):\n\tpacked = \"\"\n\tfor x in args:\n\t\tif type(x) == int or type(x) == long:\n\t\t\tpacked += pack64(x)\n\t\telse:\n\t\t\tpacked += x\n\treturn packed",
... | [
"0.6469461",
"0.62068796",
"0.61395895",
"0.5897477",
"0.5856876",
"0.5820442",
"0.57950085",
"0.5781007",
"0.57714444",
"0.57406914",
"0.57406914",
"0.57341266",
"0.5697893",
"0.5689338",
"0.5596759",
"0.5524",
"0.5515085",
"0.5504577",
"0.5504514",
"0.5503515",
"0.54212505"... | 0.7172408 | 0 |
Paillier decryption of ciphertext into multiple int64 values. | def DecryptMultipleInt64s(self, ciphertext):
if not isinstance(ciphertext, int) and not isinstance(ciphertext, long):
raise ValueError('Expected int or long type ciphertext but got: %s' %
type(ciphertext))
plaintext = self.Decrypt(ciphertext)
decrypted_numbers = []
for unuse... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def DecryptInt64(self, ciphertext):\n if not isinstance(ciphertext, int) and not isinstance(ciphertext, long):\n raise ValueError('Expected int or long type ciphertext but got: %s' %\n type(ciphertext))\n plaintext = self.Decrypt(ciphertext)\n return self._Unwrap96bitTo64bit(pla... | [
"0.6999377",
"0.68856674",
"0.67466295",
"0.67262083",
"0.6428826",
"0.6360104",
"0.6349768",
"0.6308733",
"0.6303354",
"0.6211624",
"0.61085457",
"0.60960937",
"0.60612965",
"0.60026455",
"0.5953625",
"0.5937819",
"0.59188956",
"0.5888119",
"0.58588505",
"0.5841659",
"0.5826... | 0.7780901 | 0 |
Paillier decryption of ciphertext into a int64 value. | def DecryptInt64(self, ciphertext):
if not isinstance(ciphertext, int) and not isinstance(ciphertext, long):
raise ValueError('Expected int or long type ciphertext but got: %s' %
type(ciphertext))
plaintext = self.Decrypt(ciphertext)
return self._Unwrap96bitTo64bit(plaintext) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Decrypt(self, ciphertext):\n if not isinstance(ciphertext, int) and not isinstance(ciphertext, long):\n raise ValueError('Expected int or long type ciphertext but got: %s' %\n type(ciphertext))\n u = ModExp(ciphertext, self.__lambda, self.nsquare)\n l_of_u = (u - 1) // self.... | [
"0.76950616",
"0.751412",
"0.7208298",
"0.6586208",
"0.6520382",
"0.6476167",
"0.6406717",
"0.6404868",
"0.63836175",
"0.6361718",
"0.6336824",
"0.6297889",
"0.6279345",
"0.6242041",
"0.62175155",
"0.6204211",
"0.6166816",
"0.61604214",
"0.61572933",
"0.61452925",
"0.6128287"... | 0.7853171 | 0 |
Encrypt float (IEEE754 binary64bit) values with limited exponents. Paillier homomorphic addition only directly adds positive binary values, however, we would like to add both positive and negative float values | def EncryptFloat(self, plaintext, r_value=None):
if not isinstance(plaintext, float):
raise ValueError('Expected float plaintext but got: %s' % type(plaintext))
input_as_long = struct.unpack('Q', struct.pack('d', plaintext))[0]
mantissa = (input_as_long & 0xfffffffffffff) | 0x10000000000000
expon... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _enc(x: int) -> float:\n return 2 + x + (29 / (x ** 2 + (1 - x) ** 2))",
"def _raw_add(self, e_a, e_b):\n return e_a * e_b % self.public_key.nsquare",
"async def test_floating_point_encoding(self, r):\n await r.flushdb()\n timestamp = 1349673917.939762\n await r.zadd('a', tim... | [
"0.5811039",
"0.57055616",
"0.5681594",
"0.5667057",
"0.55601025",
"0.5532706",
"0.5469459",
"0.5463289",
"0.54342914",
"0.5426036",
"0.53601795",
"0.5341179",
"0.5299423",
"0.52942103",
"0.52717775",
"0.5256707",
"0.52175176",
"0.5214884",
"0.5214496",
"0.51952034",
"0.51585... | 0.73143375 | 0 |
Paillier decryption of ciphertext into a IEEE754 binary64 float value. | def DecryptFloat(self, ciphertext):
original_plaintext = self.Decrypt(ciphertext)
plaintext = original_plaintext
mantissa_and_exponent = plaintext & _ONES_FLOAT_SIGN_LOW_LSB
plaintext >>= FLOAT_SIGN_LOW_LSB # >>= 831
sign_low32 = plaintext & 0xffffffff
plaintext >>= 32
sign_high32 = plainte... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def EncryptFloat(self, plaintext, r_value=None):\n if not isinstance(plaintext, float):\n raise ValueError('Expected float plaintext but got: %s' % type(plaintext))\n\n input_as_long = struct.unpack('Q', struct.pack('d', plaintext))[0]\n mantissa = (input_as_long & 0xfffffffffffff) | 0x10000000000000... | [
"0.6348259",
"0.6295682",
"0.6129",
"0.60495037",
"0.6032528",
"0.6025274",
"0.5985032",
"0.5756852",
"0.5723989",
"0.5710238",
"0.5611292",
"0.5578155",
"0.55487376",
"0.55423474",
"0.5519347",
"0.5498408",
"0.54967207",
"0.5486184",
"0.54766923",
"0.5475583",
"0.54647607",
... | 0.7470246 | 0 |
Returns the number of bytes in the Bignum. | def _NumBytesBn(bn):
if not _FOUND_SSL:
raise RuntimeError('Cannot evaluate _NumBytesBn because ssl library was '
'not found')
size_in_bits = ssl.BN_num_bits(bn)
return int(math.ceil(size_in_bits / 8.0)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def num_bytes(self) -> str:\n return pulumi.get(self, \"num_bytes\")",
"def size_bytes(self) -> int:\n return pulumi.get(self, \"size_bytes\")",
"def _get_nr_of_bits(self):\n return sum(self._size_var)",
"def lenb(self) -> int:\n return self._core.lenb()",
"def size_bytes(self):... | [
"0.76290935",
"0.7256088",
"0.7226742",
"0.7202238",
"0.69278276",
"0.69196373",
"0.684339",
"0.6731235",
"0.6718147",
"0.6697299",
"0.66349",
"0.6583386",
"0.65817887",
"0.65500563",
"0.65500563",
"0.6529792",
"0.6513275",
"0.6505297",
"0.64666075",
"0.64448845",
"0.64410853... | 0.7820821 | 0 |
Uses openssl, if available, to do a^b mod c where a,b,c are longs. | def ModExp(a, b, c):
if not _FOUND_SSL:
return pow(a, b, c)
# convert arbitrary long args to bytes
bytes_a = number.LongToBytes(a)
bytes_b = number.LongToBytes(b)
bytes_c = number.LongToBytes(c)
# convert bytes to (pointer to) Bignums.
bn_a = ssl.BN_bin2bn(bytes_a, len(bytes_a), 0)
bn_b = ssl.BN_bi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def powMod(a,b,c):\n if GMPY:\n return(gmpy2.powmod(a,b,c))\n else:\n return pow(a,b,c)",
"def TestSslRegression():\n if not _FOUND_SSL:\n return\n a = 13237154333272387305 # random\n b = 14222796656191241573 # random\n c = 14335739297692523692 # random\n expect_m = 106592315454997... | [
"0.6681694",
"0.64587593",
"0.6410224",
"0.6405954",
"0.62579936",
"0.62428784",
"0.6195865",
"0.61904657",
"0.6125475",
"0.6122947",
"0.6103147",
"0.6046036",
"0.6010627",
"0.60101646",
"0.5995779",
"0.5965606",
"0.5963928",
"0.5952755",
"0.59174013",
"0.5871228",
"0.5864174... | 0.7635855 | 0 |
Test openssl BN functions ctypes setup for regressions. | def TestSslRegression():
if not _FOUND_SSL:
return
a = 13237154333272387305 # random
b = 14222796656191241573 # random
c = 14335739297692523692 # random
expect_m = 10659231545499717801 # pow(a, b, c)
m = ModExp(a, b, c)
assert m == expect_m, 'TestSslRegression: unexpected ModExp result' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_ssl_default(self):\n e = ErrataConnector()\n assert e.ssl_verify",
"def test_ssl_default(self):\n assert security.security_settings.ssl_verify()",
"def test_alpn_call_failure(self):\n context = Context(SSLv23_METHOD)\n with pytest.raises(ValueError):\n con... | [
"0.58895886",
"0.54251087",
"0.5340569",
"0.52410597",
"0.51989615",
"0.5001536",
"0.4908221",
"0.48994425",
"0.4890942",
"0.4880682",
"0.48786157",
"0.48503911",
"0.4837446",
"0.4806173",
"0.48055226",
"0.47952127",
"0.479222",
"0.47784704",
"0.47668955",
"0.47659346",
"0.47... | 0.5731037 | 1 |
Add an API document | async def post(self):
if SmartAPI.find(self.args.url, "url"):
raise HTTPError(409)
try:
file = await download_async(self.args.url)
except DownloadError as err:
raise HTTPError(400, reason=str(err)) from err
try:
smartapi = SmartAPI(self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_document(self, doc):\n assert isinstance(doc, pylastica.document.Document), \"doc must be of type Document: %r\" % doc\n path = urllib.quote_plus(str(doc.doc_id))\n request_type = pylastica.request.Request.PUT\n if path is None or path == '':\n #no doc id has been giv... | [
"0.73654747",
"0.6919095",
"0.68352044",
"0.67469156",
"0.66946566",
"0.66113096",
"0.65432954",
"0.652964",
"0.6526783",
"0.64139986",
"0.62950844",
"0.6260293",
"0.6199671",
"0.6193585",
"0.61837125",
"0.6173589",
"0.613345",
"0.6122149",
"0.610493",
"0.6092834",
"0.6081412... | 0.0 | -1 |
/api/suggestion?field= Returns aggregations for any field provided | def get(self):
res = SmartAPI.get_tags(self.args.field)
self.finish(res) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def searchkit_aggs(aggs):\n return [\n {\"title\": k.capitalize(), \"aggName\": k, \"field\": v[\"terms\"][\"field\"]}\n for k, v in aggs.items()\n ]",
"def get_aggs(es, query, args):\n return es.search(index=args.index,\n body=query,\n timeout=float... | [
"0.60265315",
"0.5873109",
"0.58511466",
"0.5806916",
"0.58002204",
"0.5789221",
"0.5758926",
"0.56962925",
"0.5630357",
"0.56241834",
"0.55668694",
"0.55170536",
"0.54953665",
"0.549357",
"0.54658186",
"0.54531634",
"0.54515153",
"0.54498994",
"0.5301895",
"0.5282511",
"0.52... | 0.0 | -1 |
return exapnded value list for a given biolink class name | def get_expanded_values(self, value: Union[str, List[str]]) -> List[str]:
if isinstance(value, str):
value = [value]
_out = []
for v in value:
try:
v = self.biolink_model_toolkit.get_descendants(v, reflexive=True, formatted=True)
v = [x.spl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_values_for_class(self, class_name) -> list:\n class_items = self.soup.find_all(attrs={'class': class_name})\n class_items_values = []\n for class_item in class_items:\n class_item_value = class_item.text.strip()\n class_items_values.append(class_item_value)\n ... | [
"0.6817521",
"0.6197597",
"0.5983348",
"0.5813055",
"0.57524914",
"0.56284046",
"0.555421",
"0.555421",
"0.5522398",
"0.5507856",
"0.5482042",
"0.5441845",
"0.53842086",
"0.53817147",
"0.537343",
"0.5366936",
"0.53596956",
"0.53590965",
"0.5354571",
"0.5346339",
"0.5314848",
... | 0.5465229 | 11 |
Overwrite the biothings query handler to add graphml format (&format=graphml) added &download=True to download .graphml file automatically, can disable (&download=False) | def write(self, chunk):
try:
if self.format == "graphml":
chunk = edges2graphml(chunk, self.request.uri, self.request.protocol, self.request.host, edge_default="directed")
self.set_header("Content-Type", "text/graphml; charset=utf-8")
if self.args.down... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download(self, outputfile:str, **format_options) -> str:\n return self.connection.download(self.graph, outputfile, format_options)",
"def download(self, outputfile:str, **format_options) -> str:\n return self.session.download(self.graph, outputfile, format_options)",
"def ExportMetaGraph(pref... | [
"0.5644568",
"0.5576068",
"0.52066654",
"0.5030416",
"0.49787995",
"0.4950677",
"0.4896912",
"0.48899424",
"0.48656175",
"0.48630908",
"0.48574403",
"0.48385876",
"0.47709388",
"0.47572508",
"0.47426155",
"0.47091573",
"0.46963683",
"0.46870074",
"0.46818873",
"0.46762022",
"... | 0.62148756 | 0 |
Tests if NAPI can allocate automatically an IPv4 Address in a Network with available addresses. | def test_try_create_auto_ip(self):
name_file = 'api_ip/tests/sanity/ipv4/json/post/ipv4_auto_net_free.json'
# Does get request
response = self.client.post(
'/api/v3/ipv4/',
data=json.dumps(self.load_json_file(name_file)),
content_type='application/json')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def SupportsIPv4(self) -> bool:",
"def OSSupportsIPv4(self) -> bool:",
"def test_ipv4_in_net(self):\n test_ip = ip_address.IPAddress(\"192.168.178.4\", force_v4=True)\n assert test_ip.in_network(\"192.168.178.0/24\")\n assert test_ip.in_network(\"192.168.178.0/29\")\n \n test... | [
"0.7272328",
"0.7198159",
"0.67391574",
"0.67383194",
"0.6654193",
"0.6471453",
"0.63947624",
"0.6319289",
"0.6268624",
"0.6263439",
"0.6223236",
"0.61894363",
"0.6161831",
"0.61440897",
"0.6140726",
"0.61142963",
"0.61017936",
"0.6090846",
"0.60064334",
"0.5994998",
"0.59949... | 0.6010965 | 18 |
Tests if NAPI deny manually creation of invalid IPv4 Address | def test_try_create_invalid_ip(self):
name_file = 'api_ip/tests/sanity/ipv4/json/post/ipv4_10_0_0_430_net_5.json'
response = self.client.post(
'/api/v3/ipv4/',
data=json.dumps(self.load_json_file(name_file)),
content_type='application/json')
self.compare_sta... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_ipv4_validation_failure():\n with pytest.raises(socket.error):\n is_ipv4('256.8.8.8')",
"def OSSupportsIPv4(self) -> bool:",
"def is_valid_ipv4_address(address):\n invalid_list = ['0.0.0.0','255.255.255.255']\n try:\n ip = ipaddress.IPv4Address(address)\n if (ip.is_reserv... | [
"0.72859496",
"0.70323485",
"0.68951535",
"0.6847824",
"0.6812048",
"0.6801668",
"0.6789916",
"0.67470616",
"0.6685381",
"0.66446495",
"0.6567437",
"0.6566745",
"0.6563316",
"0.64939386",
"0.6490158",
"0.64708686",
"0.645474",
"0.6440327",
"0.6436727",
"0.6431015",
"0.6426202... | 0.70039326 | 2 |
Tests if NAPI can allocate an IPv4 Address manually and associate it to an equipment in a Network with available addresses. | def test_try_create_ip_associating_to_equipment(self):
name_file = 'api_ip/tests/sanity/ipv4/json/post/ipv4_10_0_0_99_net_5_eqpt_1.json'
response = self.client.post(
'/api/v3/ipv4/',
data=json.dumps(self.load_json_file(name_file)),
content_type='application/json')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def OSSupportsIPv4(self) -> bool:",
"def SupportsIPv4(self) -> bool:",
"def is_valid_ipv4_address(address):\n invalid_list = ['0.0.0.0','255.255.255.255']\n try:\n ip = ipaddress.IPv4Address(address)\n if (ip.is_reserved) or (ip.is_multicast) or (ip.is_loopback) or (address in invalid_list)... | [
"0.71589625",
"0.7132811",
"0.6699066",
"0.667038",
"0.66682065",
"0.6354351",
"0.6350155",
"0.6333899",
"0.6307554",
"0.62972105",
"0.6198987",
"0.6176109",
"0.61498463",
"0.61370105",
"0.61114895",
"0.6062955",
"0.60503006",
"0.60055053",
"0.59972554",
"0.5990023",
"0.59806... | 0.6774612 | 2 |
Tests if NAPI deny an IPv4 manually creation in a full network. Refactor to allow create the ip. | def test_try_create_ip_in_full_network(self):
name_file = 'api_ip/tests/sanity/ipv4/json/post/ipv4_10_0_4_1_net_8.json'
response = self.client.post(
'/api/v3/ipv4/',
data=json.dumps(self.load_json_file(name_file)),
content_type='application/json')
self.compa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_try_create_auto_ip(self):\n\n name_file = 'api_ip/tests/sanity/ipv4/json/post/ipv4_auto_net_free.json'\n\n # Does get request\n response = self.client.post(\n '/api/v3/ipv4/',\n data=json.dumps(self.load_json_file(name_file)),\n content_type='applicati... | [
"0.72138643",
"0.7143597",
"0.7103163",
"0.69434977",
"0.6816763",
"0.6809881",
"0.6664153",
"0.65963924",
"0.6582416",
"0.6578206",
"0.65741384",
"0.6565793",
"0.65070087",
"0.64682233",
"0.6466719",
"0.6372231",
"0.6264613",
"0.62450415",
"0.6238998",
"0.61737835",
"0.61651... | 0.7489132 | 0 |
Tests if NAPI deny out of range network IPv4 manually creation. | def test_try_create_out_of_range_ip_in_network(self):
name_file = 'api_ip/tests/sanity/ipv4/json/post/out_of_range_ipv4_172_0_0_5_net_5.json'
response = self.client.post(
'/api/v3/ipv4/',
data=json.dumps(self.load_json_file(name_file)),
content_type='application/json... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_ipv4_in_range(self):\n\n test_ip = ip_address.IPAddress(\"192.168.178.4\", force_v4=True)\n \n assert test_ip.in_range(\"191.167.0.0\",\"193.169.0.0\")\n assert test_ip.in_range(\"192.167.0.0\",\"192.169.0.0\")\n assert test_ip.in_range(\"192.168.0.0\",\"192.168.255.0\")... | [
"0.73434836",
"0.6952464",
"0.6907861",
"0.67323136",
"0.67003703",
"0.65595746",
"0.65477157",
"0.6545432",
"0.64953184",
"0.6441315",
"0.6403229",
"0.6263367",
"0.62485737",
"0.6163018",
"0.6136902",
"0.6079953",
"0.5962481",
"0.5961101",
"0.5927232",
"0.5911758",
"0.590265... | 0.76985526 | 0 |
returns the coords in terms of degree of visual angle converts Euclidean to Polar coordinates based on a fixation point, viewing distance, and a window size | def get_correct_coords(start_x=0,viewing_distance=12.0,field_height=10,field_width=10,pixel_width=0.282,pixel_height=0.282,**config):
x = (start_x + np.arange(np.ceil(-field_width/2.0),np.ceil(field_width/2.0),1))*pixel_width
y = np.arange(np.ceil(-field_height/2.0),np.ceil(field_height/2.0),1)*pixel_heigh... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _find_wing_coord(self):\n frac = 0.1\n r = 0.5\n sin45 = np.sin(np.pi / 4.)\n\n if self.out == True:\n d = r - frac * sin45\n elif self.out == False:\n d = r + frac * sin45\n else:\n raise TypeError(\"arg: out must be True or False\")\n... | [
"0.5799795",
"0.56280833",
"0.5603186",
"0.5591351",
"0.5571056",
"0.54761297",
"0.54758763",
"0.5474499",
"0.5455909",
"0.5451462",
"0.5448108",
"0.54459554",
"0.5430218",
"0.5429687",
"0.5427534",
"0.5413009",
"0.5412867",
"0.54114604",
"0.5395979",
"0.53953",
"0.53925055",... | 0.508621 | 71 |
degrees is viewing angle of the entire image image_width is size of entire in pixels | def get_viewing_distance_to_span_image(image_width=20,degree_span=1.0,screen_pixel_size=0.282):
image_width_mm = image_width * screen_pixel_size
inch_per_mm = 1.0/25.4 # 1 inch / 25.4 mm
image_width_inches = image_width_mm * inch_per_mm
distance_inches = (0.5*image_width_inches)/np.tan(np.radians(deg... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_image_width_in_degrees(image_width=100,viewing_distance=24.0,screen_pixel_size=0.282):\n \n mm_per_inch = 25.4\n degrees_per_image = np.degrees(np.arctan(((image_width*0.5)*screen_pixel_size)/(viewing_distance*mm_per_inch))*2.0)\n return degrees_per_image",
"def get_degrees_at_pixels(pixels=1... | [
"0.7489394",
"0.6826391",
"0.6754941",
"0.66690886",
"0.66166484",
"0.65727824",
"0.65432596",
"0.64801717",
"0.63533795",
"0.6318814",
"0.6151516",
"0.6134267",
"0.61262107",
"0.61192167",
"0.6071068",
"0.6059474",
"0.60218817",
"0.60012805",
"0.5956256",
"0.5939335",
"0.593... | 0.55289996 | 61 |
image_width is size of entire in pixels | def get_image_width_in_degrees(image_width=100,viewing_distance=24.0,screen_pixel_size=0.282):
mm_per_inch = 25.4
degrees_per_image = np.degrees(np.arctan(((image_width*0.5)*screen_pixel_size)/(viewing_distance*mm_per_inch))*2.0)
return degrees_per_image | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def width(self) -> int:\n return self._image_data.width",
"def get_image_size(self):",
"def size(img):\n\treturn img.size",
"def getWidth(self):\n return self._image.width()",
"def get_num_of_images(self):",
"def getWidth(self):\n return _tkCall(self.image.width)",
"def get_size(image)... | [
"0.8215068",
"0.80310565",
"0.7730426",
"0.7420991",
"0.72717816",
"0.7238899",
"0.70968026",
"0.70014775",
"0.69751096",
"0.6955615",
"0.6931812",
"0.69124746",
"0.68738365",
"0.6867451",
"0.68297815",
"0.68035495",
"0.6801516",
"0.6789067",
"0.6769961",
"0.6754286",
"0.6748... | 0.0 | -1 |
degrees is viewing angle of the entire image | def get_image_width_in_pixels(degrees=1.0,viewing_distance=24.0,screen_pixel_size=0.282):
mm_per_inch = 25.4
pixels = ((viewing_distance*mm_per_inch) * np.tan(np.radians(degrees*0.5))*2.0)/screen_pixel_size
return pixels | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def angle(self) -> float:\n ...",
"def angle(self) -> int:",
"def angle(self):\n return 0",
"def radians(image):\n\n return ee.Image(image).toFloat().multiply(3.1415927).divide(180)",
"def get_rotation_angle(self, image):\n \n # TODO: Make real functionality\n return 0... | [
"0.7453366",
"0.7291728",
"0.7175526",
"0.69610626",
"0.6937594",
"0.6864348",
"0.6816392",
"0.68125284",
"0.67985547",
"0.66943544",
"0.6686886",
"0.66842663",
"0.66842663",
"0.66842663",
"0.66715056",
"0.6663147",
"0.6585255",
"0.65779006",
"0.6576634",
"0.6564779",
"0.6543... | 0.0 | -1 |
pixels if fovea is centered on an image, pixels is half the image width in pixels returns half the viewing_angle | def get_degrees_at_pixels(pixels=10,viewing_distance=24.0,screen_pixel_size=0.282):
return 0.5*get_image_width_in_degrees(image_width=2.0*pixels,viewing_distance=viewing_distance,screen_pixel_size=screen_pixel_size) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def angle_from_point( x, img_width=640, fov_angle=44 ):\r\n return( -( ( img_width / 2 ) - x ) * fov_angle )",
"def check_angle(self):\n self.find_pixels()\n alpha_theta=np.deg2rad(70)\n alpha_phi=np.deg2rad(70)\n extreme_values=self.compute_extreme_values(alpha_phi, alpha_theta)\n... | [
"0.6824647",
"0.6658534",
"0.6381927",
"0.6312453",
"0.63035583",
"0.61653453",
"0.61300296",
"0.60928273",
"0.60626274",
"0.59572023",
"0.5940662",
"0.5912819",
"0.58653146",
"0.5843251",
"0.5800258",
"0.5789099",
"0.5782187",
"0.572229",
"0.57170427",
"0.57151014",
"0.57143... | 0.605287 | 9 |
degrees if fovea is centered on an image, degrees is half the viewing angle | def get_pixels_at_degrees(degrees=1.0,viewing_distance=24.0,screen_pixel_size=0.282):
return 0.5*get_image_width_in_pixels(degrees=2.0*degrees,viewing_distance=viewing_distance,screen_pixel_size=screen_pixel_size) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def angle_from_point( x, img_width=640, fov_angle=44 ):\r\n return( -( ( img_width / 2 ) - x ) * fov_angle )",
"def angle(self) -> int:",
"def angle(self) -> float:\n ...",
"def check_angle(self):\n self.find_pixels()\n alpha_theta=np.deg2rad(70)\n alpha_phi=np.deg2rad(70)\n ... | [
"0.6839408",
"0.65049446",
"0.65028924",
"0.64734244",
"0.6420284",
"0.6358528",
"0.635704",
"0.626297",
"0.6253376",
"0.6234422",
"0.62234956",
"0.61913675",
"0.6079786",
"0.604909",
"0.6048486",
"0.6022565",
"0.6022565",
"0.601494",
"0.6008876",
"0.5976437",
"0.5971544",
... | 0.0 | -1 |
For each point on the image (image_height x image_width) returns the sigma associated with each point due to the offset from the fovea of the image. The average of all the sigmas may be used as an approximation to the full set of all sigmas. Each sigma is used as the basis for creating the J operator which is the weigh... | def get_sigma_map(start_x = 0,field_height=100,field_width=100,viewing_distance=12.0,screen_pixel_size=0.282,debug=False):
start_x_pixels = np.round(get_pixels_at_degrees(degrees=start_x,viewing_distance=viewing_distance,screen_pixel_size=screen_pixel_size))
optical_nodal_distance = 17.0 # mm from lens to fovea... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def EST_NOISE(images):\n num = images.shape[0]\n m_e_bar = sum(images)/num\n m_sigma = np.sqrt(sum((images - m_e_bar)**2)/(num - 1))\n \n return m_sigma",
"def differenceOfGausssians(image,sigma0, sigma1,window_size, roi, out = None):\n return (vigra.filters.gaussianSmoothing(im... | [
"0.6426034",
"0.618826",
"0.6164799",
"0.6043242",
"0.6033193",
"0.5991623",
"0.59840286",
"0.5953327",
"0.59327376",
"0.5929004",
"0.5924567",
"0.5899973",
"0.58948284",
"0.5870835",
"0.5813454",
"0.57735664",
"0.56811696",
"0.5678987",
"0.5676586",
"0.56728524",
"0.56640273... | 0.57426494 | 16 |
Function implements sieve of Eratosthenes (for all numbers uptil N). Returns array erat_sieve If erat_sieve[i] is True, then 2i + 3 is a prime. | def sieve_of_erat(N):
erat_sieve = [True]*int(N/2)
prime_list = []
prime_list.append(2)
for i in range(int((math.sqrt(N)-3)/2)+1): # Only need to run till sqrt(n)
if erat_sieve[i] == True:
j = i + (2*i+3)
while j < int(N/2):
erat_sieve[j] = False
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def primeSieve(n):\n result = []\n sieve = array.array('i', (True for i in range(0, n+1)))\n for k in range(2, n+1):\n if sieve[k]:\n result.append(k)\n i = k * k\n while i <= n:\n sieve[i] = False\n i += k\n return result",
"def e... | [
"0.7732913",
"0.7636703",
"0.7548963",
"0.7507189",
"0.7439305",
"0.7436849",
"0.7405845",
"0.73973405",
"0.73973405",
"0.7349964",
"0.73457396",
"0.7325795",
"0.7229576",
"0.72279704",
"0.7197789",
"0.7099972",
"0.7085385",
"0.70812255",
"0.7055499",
"0.70475835",
"0.7027430... | 0.77103347 | 1 |
Handle file(s) arguments from command line This method takes the string(s) which were passed to the cli which indicate the files on which to operate. It expands the path arguments and creates a list of `pathlib.Path` objects which unambiguously point to the files indicated by the cli arguments. | def handle_files_args(*paths_args):
paths = []
for paths_arg in paths_args:
# Handle paths implicitly rooted at user home dir
paths_arg = os.path.expanduser(paths_arg)
# Expand wildcards
paths_arg = glob.glob(paths_arg)
# Create list of pathlib.Path objects
pat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parser():\n \n \n parser = ap.ArgumentParser(description='Parsing some file names in various forms')\n group = parser.add_mutually_exclusive_group()\n group.add_argument('-f','--filepaths',dest='filepaths',metavar='PATH1,PATH2,...',type=str,\n help='Input a string or list ... | [
"0.6453815",
"0.6248218",
"0.6234054",
"0.6233103",
"0.6151754",
"0.60948",
"0.59932786",
"0.59910625",
"0.594788",
"0.5934068",
"0.5930487",
"0.5909474",
"0.58889955",
"0.587302",
"0.585867",
"0.58419037",
"0.58233815",
"0.5807165",
"0.57825506",
"0.5780803",
"0.5777409",
... | 0.6813794 | 0 |
Factory method to return child of RefFile This method returns either a BibFile or NonbibFile object depending on which is appropriate based on if the `path` arg points to a file containing valid BibTeX or invalid BibTeX, respectively. | def reffile_factory(path):
try:
b = BibFile(path)
except UnparseableBibtexError:
b = NonbibFile(path)
return b | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fileobj(path_or_file, mode='r'):\n if isinstance(path_or_file, basestring):\n try:\n return open(path_or_file, mode)\n except:\n return closing(StringIO())\n else:\n return closing(path_or_file)",
"def get(self, path, content=True, type=None, format=None):\n ... | [
"0.5633376",
"0.5386271",
"0.5277653",
"0.5108195",
"0.5107922",
"0.50593334",
"0.5048385",
"0.49720398",
"0.49453267",
"0.49376675",
"0.49356878",
"0.49261934",
"0.49225807",
"0.49225807",
"0.48910007",
"0.48887247",
"0.48831517",
"0.4878487",
"0.4875914",
"0.4871508",
"0.48... | 0.79184014 | 0 |
List of data corresponding to individual bib files | def construct_bibfile_data(*paths):
bibs = [reffile_factory(path) for path in paths]
return bibs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _FindBibEntries(self):\n bibs = \" \".join(glob.glob(\"*.bib\"))\n cat_process = subprocess.Popen(shlex.split(\"cat %s\" % bibs),\n stdout=subprocess.PIPE)\n grep_process = subprocess.Popen(shlex.split(\"grep ^@\"),\n ... | [
"0.7137384",
"0.6268261",
"0.6240238",
"0.6198332",
"0.61708087",
"0.61559683",
"0.61306244",
"0.60698205",
"0.6049318",
"0.5935787",
"0.5895451",
"0.5891294",
"0.58823615",
"0.58217996",
"0.58115286",
"0.57741606",
"0.5756594",
"0.57499486",
"0.5724294",
"0.57221454",
"0.572... | 0.71239555 | 1 |
Sublist of bibfile_data whos elements are val_type This method examines each bib_dict element of a bibfile_data list and returns the subset which can be classified according to val_type. | def bib_sublist(bibfile_data, val_type):
sublist = [bibfile for bibfile in bibfile_data if isinstance(bibfile.bib, val_type)]
return sublist | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getvartypelist(self,subj,vartype): # 3\n num_ = None\n if num_ is None:\n num_ = len(subj)\n elif num_ != len(subj):\n raise IndexError(\"Inconsistent length of array subj\")\n if num_ is None: num_ = 0\n if subj is None: raise TypeError(\"Invalid type for argument subj\"... | [
"0.5007208",
"0.49767375",
"0.49480826",
"0.46832088",
"0.46792015",
"0.4644492",
"0.46313435",
"0.46113947",
"0.45949426",
"0.45826903",
"0.45621505",
"0.45417857",
"0.4523038",
"0.45103496",
"0.4509286",
"0.4508049",
"0.4495507",
"0.4486568",
"0.44805893",
"0.44530094",
"0.... | 0.82294893 | 0 |
Generate appropriate message for STDOUT This method creates the string to be printed to STDOUT from the items of the `bibfile_data` list argument. It generates either a terse or verbose message based on the state of the `verbose` argument. | def gen_stdout_test_msg(bibfile_data, verbose=False):
msg_list = [bibfile.test_msg(verbose) for bibfile in bibfile_data]
msg = "\n".join(msg_list)
return msg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_verbose(message:str):\n if params['verbose']:\n print(message)\n return",
"def print_verbose(args, msg):\n if args.verbose:\n print(msg)",
"def print_info(message: str):\n global verbose\n if verbose:\n print(\"%s%s%s\" % (KYEL, message, KNRM))",
"def print_warni... | [
"0.55090094",
"0.5451742",
"0.5423902",
"0.5419448",
"0.5378487",
"0.53770965",
"0.5367469",
"0.53551465",
"0.53439623",
"0.53236914",
"0.53030246",
"0.52971905",
"0.52728134",
"0.52330023",
"0.5109582",
"0.5108932",
"0.5082648",
"0.50546724",
"0.5050566",
"0.50337845",
"0.50... | 0.7657903 | 0 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self,*args):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.72756827",
"0.7249146",
"0.7249146",
"0.7249146",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
... | 0.0 | -1 |
This function determines if the user input is a valid player. If input is 'Q', exits program. | def is_valid_player(user_input):
i = user_input.upper()
if i in Board.player_decoder:
return True
elif i == 'Q':
exit("\nExiting program. Thanks for using Clue Detective!\n")
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def end_input(self):\n inp = input()\n if inp.upper() == \"Q\":\n return False\n if inp == \"\" \\\n \"\":\n return True\n return self.end_input",
"def validate_input(user_input: str) -> bool:\n\n if not user_input.islower():\n return F... | [
"0.7061746",
"0.7001091",
"0.6993307",
"0.685947",
"0.679399",
"0.6632149",
"0.6587232",
"0.6581674",
"0.6562173",
"0.65193605",
"0.65072095",
"0.6485321",
"0.6314308",
"0.6312182",
"0.6304966",
"0.63033706",
"0.62971884",
"0.62611985",
"0.62489146",
"0.6245538",
"0.6236307",... | 0.8541527 | 0 |
This function determines if the user input is a valid card. If skip = True, also allows 'X' as a valid input. If input is 'Q', exits program. | def is_valid(user_input, card_type=None, skip=False):
i = user_input.upper()
if i == 'Q':
exit("\nExiting program. Thanks for using Clue Detective!\n")
if skip:
if i == 'X':
return True
if card_type:
key_list = [key for key in Board.input_decoder
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_valid_player(user_input):\n \n i = user_input.upper()\n if i in Board.player_decoder:\n return True\n elif i == 'Q':\n exit(\"\\nExiting program. Thanks for using Clue Detective!\\n\")\n else:\n return False",
"def player_discard(self, inpt):\n \n if inpt.... | [
"0.6342533",
"0.59396064",
"0.58468616",
"0.58279556",
"0.5803147",
"0.5801814",
"0.5795636",
"0.5759419",
"0.57581276",
"0.5757214",
"0.57171595",
"0.5706514",
"0.5694613",
"0.5655004",
"0.5642363",
"0.5630517",
"0.5617309",
"0.5616001",
"0.55874807",
"0.55715656",
"0.556892... | 0.8009378 | 0 |
This function collects a list user inputs for players and suspects and decodes them. | def collect_players_and_suspects_list():
players_list = []
while (players_input := input("Enter player: ")) != '#':
i = players_input.upper()
if not is_valid_player(i):
print("Please enter a valid Suspect.")
continue
if i not in players_list:
play... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collect_players_list():\n \n players_list = []\n while (players_input := input(\"Enter player: \")) != '#':\n i = players_input.upper()\n if not is_valid_player(i):\n print(\"Please enter a valid Suspect.\")\n continue\n if i not in players_list:\n ... | [
"0.7785427",
"0.5724351",
"0.5629555",
"0.5615475",
"0.5556688",
"0.54903173",
"0.53061044",
"0.5302518",
"0.5204586",
"0.51927483",
"0.5189104",
"0.515343",
"0.51155186",
"0.5102323",
"0.50311154",
"0.50235236",
"0.5017103",
"0.49988022",
"0.49984848",
"0.4991658",
"0.499021... | 0.8002285 | 0 |
This function collects a list user inputs for players and decodes them. | def collect_players_list():
players_list = []
while (players_input := input("Enter player: ")) != '#':
i = players_input.upper()
if not is_valid_player(i):
print("Please enter a valid Suspect.")
continue
if i not in players_list:
players_list.appe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collect_players_and_suspects_list():\n \n players_list = []\n while (players_input := input(\"Enter player: \")) != '#':\n i = players_input.upper()\n if not is_valid_player(i):\n print(\"Please enter a valid Suspect.\")\n continue\n if i not in players_list:... | [
"0.7349576",
"0.5860871",
"0.5805779",
"0.57845634",
"0.5769686",
"0.57296795",
"0.56243366",
"0.5612682",
"0.5509435",
"0.5483779",
"0.54824257",
"0.54214525",
"0.54100615",
"0.54100615",
"0.5393822",
"0.5390574",
"0.53871775",
"0.5355974",
"0.5330425",
"0.531194",
"0.530722... | 0.7726118 | 0 |
This function collects a list user inputs for cards and decodes them. | def collect_cards():
cards_list = []
while (cards_input := input("Enter card: ")) != '#':
i = cards_input.upper()
if not is_valid(i):
print(f"Please enter a valid card.")
continue
cards_list.append(i)
cards_decoded = [Board.translate(card) for card in car... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collect_players_list():\n \n players_list = []\n while (players_input := input(\"Enter player: \")) != '#':\n i = players_input.upper()\n if not is_valid_player(i):\n print(\"Please enter a valid Suspect.\")\n continue\n if i not in players_list:\n ... | [
"0.6567946",
"0.63332915",
"0.5622721",
"0.5523507",
"0.5515353",
"0.5509751",
"0.54955375",
"0.54447144",
"0.53823245",
"0.53788084",
"0.5369966",
"0.5357542",
"0.5334989",
"0.5311229",
"0.5299947",
"0.52394986",
"0.52083004",
"0.52079797",
"0.5192435",
"0.5192203",
"0.51900... | 0.7617722 | 0 |
Count the approximate number of words in a file. | def count_words(filename):
try:
with open(filename) as file_object:
contents = file_object.read()
except FileNotFoundError:
message = "Sorry, the file " + filename + " does not exist."
print(message)
else:
# Count approximate number of words in the file.
w... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_words(filename):",
"def count_words_in_file(file_name):\n\n\treturn len(get_words_in_file(file_name))",
"def count_words(filename):\n\ttry:\n\t\twith open(filename, encoding='utf-8') as f_obj:\n\t\t\tcontents = f_obj.read()\n\texcept FileNotFoundError:\n\t\tmsg = \"Sorry, the file \" + filename + \" ... | [
"0.89932305",
"0.87853706",
"0.8404579",
"0.82420474",
"0.82162976",
"0.814177",
"0.81379974",
"0.80925703",
"0.8089069",
"0.8040269",
"0.7950105",
"0.79354155",
"0.7916694",
"0.7770902",
"0.7747514",
"0.7704495",
"0.763296",
"0.7585351",
"0.7514763",
"0.748077",
"0.74705595"... | 0.82336766 | 4 |
Return dataset with various zonal terms. Preserve a dimensionless | def compute_terms(file_full, file_mean, file_out, file_global='means.nc'):
# Load datasets
# TODO: Rename 'plev' to 'lev'
# NOTE: GFDL doesn't use CF conventions right now.
# See: https://github.com/xgcm/xgcm/issues/91
timer()
if os.path.exists(file_out):
os.remove(file_out)
data_ful... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def CreateDesignMatrix_X(z, x, y, n ):\n if len(x.shape) > 1:\n x = np.ravel(x)\n y = np.ravel(y)\n\n N = len(x)\n l = int((n+1)*(n+2)/2) \n X = np.ones((N,l))\n\n for i in range(1,n+1):\n q = int((i)*(i+1)/2)\n for k in range(i+1):\n X[:,q+k] = x**(i-k) *... | [
"0.6005747",
"0.5714818",
"0.5702035",
"0.5689056",
"0.5609547",
"0.5551824",
"0.55210054",
"0.55030423",
"0.5433913",
"0.5422668",
"0.5372532",
"0.5342346",
"0.53412604",
"0.5335583",
"0.5334253",
"0.53181136",
"0.53163016",
"0.531613",
"0.5307196",
"0.5300388",
"0.5294038",... | 0.0 | -1 |
Return tuple with name and symbol order of symbol table node gdbval | def get_symbol_name_order(gdbval):
return (symtab_node_name (gdbval), int(gdbval["order"])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_gdb_symbol_table():\n\n tab = Symtab()\n n = gdb.parse_and_eval (\"symtab->nodes\")\n while (long(n)):\n if symtab_node_is_function (n):\n current_symbol = GdbFunction(tab, n)\n tab.all_functions.append (current_symbol)\n elif symtab_node_is_variable (n):\n ... | [
"0.63522923",
"0.5892707",
"0.5717121",
"0.5676088",
"0.5654664",
"0.5606972",
"0.55600977",
"0.55475837",
"0.5519339",
"0.5508528",
"0.54735756",
"0.54546064",
"0.5445889",
"0.5444502",
"0.53737164",
"0.53344953",
"0.531329",
"0.53073454",
"0.52950823",
"0.52532065",
"0.5196... | 0.802892 | 0 |
Return pruned candidates containing only flags that are set in gdbval | def bool_attr_list(gdbval, candidates):
r = []
for i in candidates:
if long (gdbval[i]) != 0:
r.append(i)
pass
pass
return r | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bool_attr_list_1(gdbval, candidates):\n\n r = []\n for i in candidates:\n if long (gdbval[i[0]]) != 0:\n r.append(i[1])\n pass\n pass\n return r",
"def flags(self):\n flags = self.Flags\n return [x for x in self.FLAGS_VALUES if flags & x]",
"def ch... | [
"0.62069196",
"0.58500195",
"0.5761298",
"0.56516194",
"0.54694813",
"0.54386127",
"0.5421935",
"0.5417712",
"0.54035455",
"0.53730446",
"0.53225636",
"0.53167844",
"0.5297252",
"0.529056",
"0.528956",
"0.5206268",
"0.5202388",
"0.5171703",
"0.51404",
"0.51187575",
"0.5093403... | 0.62399405 | 0 |
Like above but now candidates are tuples of real flag and user visible name | def bool_attr_list_1(gdbval, candidates):
r = []
for i in candidates:
if long (gdbval[i[0]]) != 0:
r.append(i[1])
pass
pass
return r | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def view_candidates(self):\n items = ['id', self.filter, 'half_light', 'separation', 'P_c']\n for add_on in ['P_O', 'P_Ox']:\n if add_on in self.candidates.keys():\n items += [add_on]\n print(self.candidates[items])",
"def flags(self) -> UserFlag:",
"def candidate... | [
"0.62182224",
"0.608126",
"0.60353684",
"0.5863966",
"0.5694711",
"0.5597789",
"0.5595839",
"0.55818534",
"0.55225366",
"0.55154634",
"0.5509682",
"0.5467662",
"0.5419843",
"0.5375041",
"0.53720033",
"0.5312513",
"0.5310887",
"0.5301905",
"0.5269061",
"0.5194035",
"0.5187451"... | 0.5899639 | 3 |
To be made method. Loads common attributes from symbol base | def load_symtab_base_attrs(self):
sym = self.gdbval
vis = bool_attr_list (sym, ["in_other_partition",
"used_from_other_partition", "force_output",
"forced_by_abi", "externally_visible"])
vis.extend(bool_attr_list_1(sym["decl"]["base"],
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _base_attrs(self, service):\n keys = ['name', 'desc', 'url']\n return {name:getattr(service, name, None) for name in keys}",
"def __extract_common_attrs(self, raw_data: Dict) -> None:\n for attr in self.COMMON_ATTRS:\n if attr not in self.ATTRS and attr in raw_data:\n ... | [
"0.61585546",
"0.6084663",
"0.6044661",
"0.5943379",
"0.5886491",
"0.5802792",
"0.57020926",
"0.5637599",
"0.56372637",
"0.56197745",
"0.56000906",
"0.55648845",
"0.5503462",
"0.5496226",
"0.5459958",
"0.5452533",
"0.54436445",
"0.5441584",
"0.54250926",
"0.540444",
"0.539474... | 0.6953629 | 0 |
Return orders of nodes ipa_ref_list references | def gather_references_orders (gdbval):
# TODO: Somehow also note speculative references and attributes in
# general
vec = gdbval["references"]
return [int(i["referred"]["order"]) for i in vec_iter(vec)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gather_referring_orders (gdbval):\n# TODO: Somehow also note speculative references and attributes in\n# general\n vec = gdbval[\"referring\"]\n return [int(i[\"referring\"][\"order\"]) for i in vec_iter(vec)]",
"def angle_sort_adjacent_nodes(self,n,ref_nbr=None):\n nbrs=self.node_to_nodes(n)\n ... | [
"0.731949",
"0.6546845",
"0.6098026",
"0.6095413",
"0.6079038",
"0.5992602",
"0.5936781",
"0.59094507",
"0.58531016",
"0.58507776",
"0.58364546",
"0.58358586",
"0.58252954",
"0.58145785",
"0.5806854",
"0.5802949",
"0.5786999",
"0.5780388",
"0.5758174",
"0.5740272",
"0.5738646... | 0.79086727 | 0 |
Return orders of nodes referring node associated with ipa_ref_list | def gather_referring_orders (gdbval):
# TODO: Somehow also note speculative references and attributes in
# general
vec = gdbval["referring"]
return [int(i["referring"]["order"]) for i in vec_iter(vec)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gather_references_orders (gdbval):\n# TODO: Somehow also note speculative references and attributes in\n# general\n vec = gdbval[\"references\"]\n return [int(i[\"referred\"][\"order\"]) for i in vec_iter(vec)]",
"def angle_sort_adjacent_nodes(self,n,ref_nbr=None):\n nbrs=self.node_to_nodes(n)\n... | [
"0.7483979",
"0.6498939",
"0.60103464",
"0.59589404",
"0.592434",
"0.58175755",
"0.57886195",
"0.57791865",
"0.5778693",
"0.5724725",
"0.5648295",
"0.56302035",
"0.56052834",
"0.56052834",
"0.55912304",
"0.55762887",
"0.55696046",
"0.55564326",
"0.5543322",
"0.55140626",
"0.5... | 0.70957726 | 1 |
Build and return our representation of the symbol table | def build_gdb_symbol_table():
tab = Symtab()
n = gdb.parse_and_eval ("symtab->nodes")
while (long(n)):
if symtab_node_is_function (n):
current_symbol = GdbFunction(tab, n)
tab.all_functions.append (current_symbol)
elif symtab_node_is_variable (n):
current... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n dictt = self.getFullDict()\n return \"SymbolTable(\\n{}\\n)\".format(pprint.pformat(dictt))",
"def symbol_table(self) -> str:\n return self._symbol_table",
"def getSymbolTable(self) -> ghidra.app.util.bin.format.pe.debug.DebugCodeViewSymbolTable:\n ...",
"def ... | [
"0.7142161",
"0.7140003",
"0.7079655",
"0.67236257",
"0.66320723",
"0.65642846",
"0.65429175",
"0.65292776",
"0.64784485",
"0.6340965",
"0.6260409",
"0.62448263",
"0.62234396",
"0.61231375",
"0.60608643",
"0.6057268",
"0.5934887",
"0.58612394",
"0.5844101",
"0.5835696",
"0.57... | 0.7709988 | 0 |
Return text describing important edge flags or empty string | def flags(self, f):
if f.is_inlined:
return " (inlined)"
return "" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def human_readable(self):\n if self.no_flags_set():\n return \"no flags set\"\n else:\n flag_desc = []\n for name in (\"bookmarked\", \"for_validation\", \"candidate\", \"final causative\"):\n if getattr(self, \"flag_%s\" % name.replace(\" \", \"_\")):\... | [
"0.6562656",
"0.612036",
"0.56815875",
"0.5583346",
"0.55517215",
"0.55415154",
"0.5524572",
"0.548128",
"0.54642874",
"0.5456155",
"0.541521",
"0.5414519",
"0.54008186",
"0.5340721",
"0.5325096",
"0.5318845",
"0.5292452",
"0.5237705",
"0.52254677",
"0.52168465",
"0.51546",
... | 0.584295 | 2 |
Output the model predictions for the test set | def output_predictions(predictions_file, relations, predictions, test_set_keys, test_labels):
with codecs.open(predictions_file, 'w', 'utf-8') as f_out:
for i, (w1, w2) in enumerate(test_set_keys):
f_out.write('\t'.join([w1, w2, relations[test_labels[i]], relations[predictions[i]]]) + '\n') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test():\n # load dataset and model\n X, observed_y = load_data('../data/dev.txt')\n\n model = pickle.load(open('test.model', 'rb'))\n model.traverse()\n\n # predict labels for dataset\n preds = model.predict(X)\n\n # print(preds)\n # output model predictions\n np.savetxt('test.predict... | [
"0.7996614",
"0.7647699",
"0.75771004",
"0.7555528",
"0.7431584",
"0.73849654",
"0.7349671",
"0.7293962",
"0.721062",
"0.71926904",
"0.71917266",
"0.7171003",
"0.7115817",
"0.71051496",
"0.7090768",
"0.70273274",
"0.70217824",
"0.70038015",
"0.69980234",
"0.6995777",
"0.69682... | 0.6510511 | 93 |
Evaluate performance of the model on the test set | def evaluate(test_set, predictions):
full_report = metrics.classification_report(test_set.labels, predictions,
labels=range(len(test_set.index2label)),
target_names=test_set.index2label, digits=3)
pre, rec, f1, suppo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_evaluate():\n X_train, X_test, y_train, y_test = src.load()\n clf, score = src.train(X_train, y_train)\n test_score = src.evaluate(clf, X_test, y_test)\n assert isinstance(test_score, float)",
"def evaluate(self, test_x, test_y):\n score = self._model.evaluate(test_x, test_y, verbose=... | [
"0.78246766",
"0.76479584",
"0.7578219",
"0.75720495",
"0.7560957",
"0.75514156",
"0.75444853",
"0.75016856",
"0.747195",
"0.7463784",
"0.745974",
"0.7456538",
"0.74170643",
"0.7399785",
"0.73661226",
"0.73332477",
"0.73242176",
"0.7319569",
"0.7294839",
"0.7294839",
"0.72948... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.