0 or I2 > 0:\n if I1 > 0:\n ArgsList.append(\"-i1\")\n ArgsList.append(str(I1)) \n if I2 > 0:\n ArgsList.append(\"-i2\")\n ArgsList.append(str(I2))\n else: \n ArgsList.append(\"--noinput\")\n \n if O1 > 0 or O2 > 0 or O3 > 0:\n if O1 > 0:\n ArgsList.append(\"-o1\")\n ArgsList.append(str(O1)) \n if O2 > 0:\n ArgsList.append(\"-o2\")\n ArgsList.append(str(O2))\n if O3 > 0:\n ArgsList.append(\"-o3\")\n ArgsList.append(str(O3))\n else: \n ArgsList.append(\"--nooutput\")\n \n ArgsList.append(\"--nosummary\")\n ArgsList.append(\"--verbose\")\n return ArgsList"],"string":"[\n \"def gen_command(process):\\n cmd = \\\"{} \\\".format(process.name)\\n for o in process.options.opt_list:\\n i = 0\\n opt = \\\"\\\"\\n for el in o: \\n if el and el != \\\"input\\\" and el != \\\"output\\\" and i != 3:\\n opt += str(el)\\n if opt[-1] != \\\"=\\\" and opt[-1] != \\\"'\\\": # command without space\\n opt += \\\" \\\" # space\\n i += 1\\n cmd += opt\\n return cmd\",\n \"def command_and_args(self) -> str:\\n if self.command and self.args:\\n rtn = f'{self.command} {self.args}'\\n elif self.command:\\n # there were no arguments to the command\\n rtn = self.command\\n else:\\n rtn = ''\\n return rtn\",\n \"def build_command_line_parameters(params, command_name=\\\"-param\\\"):\\n if params is None:\\n return \\\"\\\"\\n res = []\\n for k, v in sorted(params.items()):\\n if '\\\"' in v:\\n v = v.replace('\\\"', '\\\\\\\\\\\"')\\n one = '{2} {0}=\\\"{1}\\\"'.format(k, v, command_name)\\n res.append(one)\\n return \\\" \\\".join(res)\",\n \"def generate_command_string(self, operation, *args, **kwargs):\\n cmd = [self.terraform_binary_path, operation]\\n\\n for key, value in kwargs.items():\\n if key == \\\"var\\\":\\n for varkey, varval in value.items():\\n option = \\\"-var=\\\"\\n option += \\\"'%s=%s'\\\" % (varkey, varval)\\n cmd.append(option)\\n else:\\n option = \\\"\\\"\\n if \\\"_\\\" in key:\\n key = key.replace(\\\"_\\\", \\\"-\\\")\\n\\n if value == \\\"IsFlag\\\":\\n option = \\\"-%s\\\" % key\\n else:\\n option = \\\"-%s=%s\\\" % (key, value)\\n cmd.append(option)\\n\\n if len(args) > 0:\\n for arg in args:\\n cmd.append(arg)\\n\\n return \\\" \\\".join(cmd)\",\n \"def makecmd(self, options):\",\n \"def _build_command(self, cmd, unit):\\n return '#' + unit + cmd + NEWLINE\",\n \"def _arg_to_command(k: str, v: Optional[Union[str, int, float]] = None):\\n command = _arg_to_flag(k)\\n if v is not None:\\n command += f' {v}'\\n return command\",\n \"def buildCommand(self, kwargs):\\r\\n self.command = \\\"\\\"\\r\\n try:\\r\\n if not self.isEnabled():\\r\\n return\\r\\n except Exception, e:\\r\\n print \\\"<ERROR>\\\", e\\r\\n return\\r\\n self.command = self.app\\r\\n \\r\\n \\r\\n \\r\\n # filename should be last in the command, so iterate again\\r\\n for key in kwargs:\\r\\n if key == 'filename':\\r\\n if type(kwargs[key]) == str:\\r\\n f = kwargs[key]\\r\\n if os.path.exists(f):\\r\\n self.command += \\\" \\\" + str(f)\\r\\n else:\\r\\n self.command = \\\"\\\"\\r\\n raise Exception, \\\"File does not exist!\\\"\\r\\n else:\\r\\n self.command = \\\"\\\"\\r\\n raise Exception, \\\"File needs to be a string.\\\"\",\n \"def _build_send_optode_command(self, cmd, command):\\n return \\\"%s=%s%s\\\" % (cmd, command, self._newline)\",\n \"def __buildOptionString ( self ):\\n\\n #-- 1 --\\n result = []\\n\\n #-- 2 --\\n # [ result +:= strings defining each element of self.switchSpecs\\n # as getopt.getopt requires it ]\\n for sw in self.switchSpecs:\\n #-- 2 body --\\n # [ if sw is a SwitchArg ->\\n # result +:= a string defining sw as getopt.getopt\\n # requires it ]\\n if sw.takesValue:\\n result.append ( \\\"%s:\\\" % sw.letter )\\n else:\\n result.append ( sw.letter )\\n\\n #-- 3 --\\n # [ return the strings in result, concatenated ]\\n return \\\"\\\".join ( result )\",\n \"def create_command(command: str, *parameters) -> str:\\n if parameters and isinstance(parameters, tuple) and isinstance(parameters[0], tuple):\\n parameters = parameters[0]\\n str_param: str = ' '.join([str(param) for param in parameters]) if parameters else \\\"\\\"\\n result = command+' ' + str_param + '\\\\r\\\\n' if str_param else command + '\\\\r\\\\n'\\n return result\",\n \"def _get_cmd(cls, command, f_config, verbose=False):\\n if command not in cls.COMMANDS:\\n raise KeyError('Could not recongize command \\\"{}\\\". '\\n 'Available commands are: {}'\\n .format(command, cls.COMMANDS))\\n cmd = cls.CMD_BASE.format(fp_config=f_config, command=command)\\n if verbose:\\n cmd += ' -v'\\n\\n return cmd\",\n \"def __str__(self):\\n self._validate()\\n commandline = \\\"%s \\\" % self.program_name\\n for parameter in self.parameters:\\n if parameter.is_set:\\n #This will include a trailing space:\\n commandline += str(parameter)\\n return commandline.strip() # remove trailing space\",\n \"def format_command(cls, arg: int = 9600) -> str:\\n if arg not in cls.arguments:\\n raise ArgumentError(f\\\"arg not one of {cls.arguments}\\\")\\n return f\\\"{cls.name},{arg}\\\"\",\n \"def buildCommandModel ( switchSpecs, posSpecs ):\\n\\n #-- 1 --\\n result = []\\n\\n #-- 2 --\\n # [ result +:= strings representing the options in switchSpecs ]\\n for switch in switchSpecs:\\n result.append ( \\\"-%s\\\" % switch.letter )\\n\\n #-- 3 --\\n # [ result +:= strings representing the keys in posSpecs ]\\n for pos in posSpecs:\\n if pos.optional:\\n result.append ( \\\"[%s]\\\" % pos.key )\\n else:\\n result.append ( pos.key )\\n if pos.repeated:\\n result.append ( \\\"...\\\" )\\n\\n #-- 4 --\\n # [ return the concatenation of the strings in result with single\\n # spaces between them ]\\n return \\\" \\\".join ( result )\",\n \"def create_ipmi_ext_command_string(command, **options):\\n\\n new_options = collections.OrderedDict()\\n for option in ipmi_required_options:\\n # This is to prevent boot table \\\"-N 10\\\" vs user input timeout.\\n if \\\" -N \\\" in command and option == \\\"N\\\":\\n continue\\n if option in options:\\n # If the caller has specified this particular option, use it in\\n # preference to the default value.\\n new_options[option] = options[option]\\n # Delete the value from the caller's options.\\n del options[option]\\n else:\\n # The caller hasn't specified this required option so specify it\\n # for them using the global value.\\n var_name = 'ipmi_' + ipmi_option_name_map[option]\\n value = eval(var_name)\\n new_options[option] = value\\n # Include the remainder of the caller's options in the new options\\n # dictionary.\\n for key, value in options.items():\\n new_options[key] = value\\n\\n return gc.create_command_string('ipmitool', command, new_options)\",\n \"def build_cmdline():\\n\\tcmd=optparse.OptionParser(version=__version__)\\n\\tcmd.add_option('-c', '', dest='config_fname',type=\\\"string\\\", help='WHM/WHMCS configuration file', metavar=\\\"FILE\\\")\\n\\tcmd.add_option('-s', '', dest=\\\"whm_section\\\", type=\\\"string\\\", help=\\\"WHM server to use. Specify section name. eg: -s ds01\\\", metavar=\\\"SERVER\\\")\\n\\tcmd.add_option('','--search', action=\\\"store\\\", dest='search', type=\\\"string\\\", help=\\\"Search client by DNS domain name or cPanel username\\\", metavar=\\\"STRING\\\")\\n\\tcmd.add_option('-d', '', dest='whmcs_deptid', type=\\\"int\\\", help=\\\"WHMCS Department ID\\\", metavar=\\\"INT\\\") \\n\\tcmd.add_option('-m', '', dest='whmcs_ticketmsg_fname', type=\\\"string\\\", help=\\\"WHMCS abuse ticket template file\\\", metavar='FILE')\\n\\tcmd.add_option('-r', '', dest='whm_suspendmsg_fname', type=\\\"string\\\", help='cPanel account suspension reason template file', metavar='FILE')\\n\\tcmd.add_option('-f', '', dest='whmcs_proofmsg_fname', type=\\\"string\\\", help='Abuse proof file which will be appended to abuse ticket message', metavar='FILE')\\n\\tcmd.add_option('', '--subject', dest='whmcs_subject', type=\\\"string\\\", help='Specify abuse ticket subject title.', metavar=\\\"STRING\\\")\\n\\tcmd.add_option('-y', '--allyes', dest='allyes', action=\\\"store_true\\\", default=False, help='Assume yes as an answer to any question which would be asked')\\n\\treturn cmd\",\n \"def __str__(self):\\n if not self._args and not self.subcommand:\\n return self.cmd\\n elif not self._args and self.subcommand:\\n return '{} {}'.format(\\n self.cmd, self.subcommand)\\n elif self._args and not self.subcommand:\\n return '{} {}'.format(\\n self.cmd, ' '.join(self._args))\\n else:\\n return '{} {} {}'.format(\\n self.cmd, self.subcommand, ' '.join(self._args))\",\n \"def _cmd_builder(self, test_config):\\n arg_str = ''\\n for key, value in sorted(test_config['args'].items()):\\n arg_str += '--{} {} '.format(key, value)\\n return test_config['pycmd'].format(arg_str)\",\n \"def _build_direct_command(self, cmd, arg):\\n return \\\"%s%s\\\" % (arg, self._newline)\",\n \"def _build_command(self, command_name, hardware_address = '', comp_var_dict = None):\\n # Start command adn set name\\n command = \\\"<Command><Name>{command_name}</Name>\\\".format(command_name=command_name)\\n\\n if hardware_address:\\n command += \\\"<DeviceDetails><HardwareAddress>{hardware_address}</HardwareAddress></DeviceDetails>\\\".format(hardware_address=hardware_address)\\n\\n if comp_var_dict is not None:\\n comp_keys = comp_var_dict.keys()\\n if len(comp_keys) > 0:\\n for comp_key in comp_keys:\\n # Build requested variable list\\n command += \\\"<Components><Component><Name>{comp_key}</Name><Variables>\\\".format(comp_key=comp_key)\\n variables = comp_var_dict[comp_key]\\n for var in variables:\\n command += \\\"<Variable><Name>{var}</Name></Variable>\\\".format(var=var)\\n command += \\\"</Variables></Component></Components>\\\"\\n else:\\n # Request all variables from all components\\n command += \\\"<Components><All>Y</All></Components>\\\"\\n\\n # Close command\\n command += \\\"</Command>\\\"\\n \\n return command\",\n \"def _BuildCommand(self, command_name, parameter_files=None, **kwargs):\\n command = [YCSB_EXE, command_name, self.database]\\n\\n parameters = self.parameters.copy()\\n parameters.update(kwargs)\\n\\n # Adding -s prints status which includes average throughput per sec.\\n if _THROUGHPUT_TIME_SERIES.value and command_name == 'run':\\n command.append('-s')\\n parameters['status.interval'] = _STATUS_INTERVAL_SEC\\n\\n # These are passed as flags rather than properties, so they\\n # are handled differently.\\n for flag in self.FLAG_ATTRIBUTES:\\n value = parameters.pop(flag, None)\\n if value is not None:\\n command.extend(('-{0}'.format(flag), str(value)))\\n\\n for param_file in list(self.parameter_files) + list(parameter_files or []):\\n command.extend(('-P', param_file))\\n\\n for parameter, value in parameters.items():\\n command.extend(('-p', '{0}={1}'.format(parameter, value)))\\n\\n return 'cd %s && %s' % (YCSB_DIR, ' '.join(command))\",\n \"def generic(self, switches=[\\\"--help\\\"]):\\n return self._command_template(switches)\",\n \"def build_options(self):\\n opts = [\\n \\\"-k rpm.rpmva=off\\\",\\n \\\"-k apache.log=True\\\",\\n ]\\n\\n sensitive_keys = {\\n self._engine_plugin: 'sensitive_keys',\\n 'ovirt_engine_dwh': 'dwh_sensitive_keys',\\n }\\n if self.configuration['include_sensitive_data']:\\n for plugin in sensitive_keys:\\n self.configuration[sensitive_keys[plugin]] = ':'\\n\\n for plugin in sensitive_keys:\\n if self.configuration.get(sensitive_keys[plugin]):\\n opts.append(\\n '-k {plugin}.sensitive_keys={keys}'.format(\\n plugin=plugin,\\n keys=self.configuration.get(sensitive_keys[plugin]),\\n )\\n )\\n\\n if self.configuration.get(\\\"ticket_number\\\"):\\n opts.append(\\n \\\"--ticket-number=%s\\\" % self.configuration.get(\\\"ticket_number\\\")\\n )\\n\\n if self.sos_version < '30':\\n opts.append('--report')\\n\\n if self.configuration.get(\\\"log_size\\\"):\\n opts.append(\\n \\\"--log-size=%s\\\" %\\n self.configuration.get('log_size')\\n )\\n else:\\n if self.sos_version < '30':\\n opts.append('--report')\\n opts.append(\\\"-k general.all_logs=True\\\")\\n elif self.sos_version < '32':\\n opts.append(\\\"-k logs.all_logs=True\\\")\\n else:\\n opts.append(\\\"--all-logs\\\")\\n\\n if self.configuration.get(\\\"upload\\\"):\\n opts.append(\\\"--upload=%s\\\" % self.configuration.get(\\\"upload\\\"))\\n return \\\" \\\".join(opts)\",\n \"def GenerateToolArgStrings(options):\\n # Preparing dnstreexport\\n dnstreeexport_array = [options.tree_export]\\n dnstreeexport_array.extend(['-c', options.config_file])\\n if( options.force ):\\n dnstreeexport_array.append('--force')\\n if( options.quiet ):\\n dnstreeexport_array.append('--quiet')\\n dnstreeexport_arg_string = ' '.join(dnstreeexport_array)\\n\\n # Preparing dnscheckconfig\\n dnscheckconfig_array = [options.check_config]\\n dnscheckconfig_array.extend(['-i', '%s' % options.id])\\n dnscheckconfig_array.extend(['--config-file', options.config_file])\\n if( options.named_checkzone ):\\n dnscheckconfig_array.extend(['-z', options.named_checkzone])\\n if( options.named_checkconf ):\\n dnscheckconfig_array.extend(['-c', options.named_checkconf])\\n if( not options.quiet ):\\n dnscheckconfig_array.append('-v')\\n dnscheckconfig_arg_string = ' '.join(dnscheckconfig_array)\\n\\n # Preparing dnsservercheck\\n dnsservercheck_array = [options.server_check]\\n dnsservercheck_array.extend(['--export-config'])\\n dnsservercheck_array.extend(['-c', options.config_file])\\n dnsservercheck_array.extend(['-i', '%s' % options.id])\\n dnsservercheck_arg_string = ' '.join(dnsservercheck_array)\\n\\n # Preparing dnsconfigsync\\n dnsconfigsync_array = [options.config_sync]\\n dnsconfigsync_array.extend(['--export-config'])\\n dnsconfigsync_array.extend(['-i', '%s' % options.id])\\n dnsconfigsync_array.extend(['-c', options.config_file])\\n if( options.ssh_id ):\\n dnsconfigsync_array.extend(['--ssh-id', options.ssh_id])\\n if( options.rndc_exec ):\\n dnsconfigsync_array.extend(['--rndc-exec', options.rndc_exec])\\n if( options.rndc_port ):\\n dnsconfigsync_array.extend(['--rndc-port', options.rndc_port])\\n if( options.rndc_key ):\\n dnsconfigsync_array.extend(['--rndc-key', options.rndc_key])\\n if( options.rndc_conf ):\\n dnsconfigsync_array.extend(['--rndc-conf', options.rndc_conf])\\n dnsconfigsync_arg_string = ' '.join(dnsconfigsync_array)\\n\\n # Preparing dnsquerycheck\\n dnsquerycheck_array = [options.query_check]\\n dnsquerycheck_array.extend(['--export-config'])\\n dnsquerycheck_array.extend(['-c', options.config_file])\\n dnsquerycheck_array.extend(['-i', '%s' % options.id])\\n dnsquerycheck_array.extend(['-n', '%s' % options.number])\\n dnsquerycheck_array.extend(['-p', '%s' % options.port])\\n dnsquerycheck_arg_string = ' '.join(dnsquerycheck_array)\\n\\n return [dnstreeexport_arg_string,\\n dnscheckconfig_arg_string,\\n dnsservercheck_arg_string,\\n dnsconfigsync_arg_string, \\n dnsquerycheck_arg_string]\",\n \"def _extract_command(self, args):\\n opts = self.gopts[:]\\n for cmd in self.ctable.values():\\n opts.extend(cmd.opts)\\n sfl, lfl, _ = self._compute_flags(opts, check_conflicts=False)\\n\\n lopts,largs = getopt.getopt(args, sfl, lfl)\\n if not largs:\\n return None\\n return self._command(largs[0])\",\n \"def buildCmd( tcmpCmd, cmd, target, sequence, fieldList):\\n cmdList = [tcmpCmd, cmd, target, sequence, fieldList]\\n\\n return \\\"<{cmd}>\\\".format(cmd=\\\":\\\".join(cmdList))\",\n \"def formatCommand(command):\\n cmdstr=\\\"\\\"\\n logging.debug(repr(command))\\n for arg in command:\\n if \\\" \\\" in arg:\\n cmdstr=cmdstr+\\\" \\\\\\\"\\\"+arg+\\\"\\\\\\\"\\\"\\n else:\\n cmdstr=cmdstr+\\\" \\\"+arg\\n return cmdstr\",\n \"def shell_command(self):\\n # TODO: fix this naive version by adding quotes where appropriate\\n return \\\" \\\".join(self.args)\",\n \"def _get_command_args_syntax_help_string(command, is_no_command, args):\\n syntax_string = ''\\n if args:\\n for i, arg in enumerate(args):\\n if i > 0:\\n syntax_string += ' '\\n \\n if _is_string(arg):\\n syntax_string += arg\\n continue\\n\\n if type(arg) == tuple:\\n if debug.description():\\n print _line(), command['self'], arg\\n\\n if is_no_command:\\n optional = arg.get('optional-for-no', False)\\n else:\\n optional = arg.get('optional', False)\\n if optional:\\n syntax_string += '['\\n \\n choices = arg.get('choices')\\n nested_args = arg.get('args')\\n if nested_args:\\n if choices:\\n raise error.CommandDescriptionError('An argument can\\\\'t have both '\\n '\\\"choices\\\" and \\\"args\\\" attributes', command)\\n choices = (nested_args,)\\n if choices:\\n # Suppress choice delimiters if we've already emitted the square\\n # brackets to indicate an optional argument. This is so we get\\n # something simpler (e.g. \\\"[this | that]\\\" ) instead of getting\\n # doubled delimiters (e.g. \\\"[{this | that}]\\\").\\n if not optional:\\n syntax_string += '{'\\n \\n for j, choice in enumerate(choices):\\n if j > 0:\\n syntax_string += ' | '\\n choice_args = _get_choice_args(choice)\\n choice_syntax_string = _get_command_args_syntax_help_string(command,\\n is_no_command,\\n choice_args)\\n syntax_string += choice_syntax_string\\n \\n if not optional:\\n syntax_string += '}'\\n else:\\n field = arg.get('field')\\n \\n tag = arg.get('tag')\\n if tag:\\n syntax_string += tag + ' '\\n \\n token = arg.get('token')\\n if token:\\n syntax_string += token\\n\\n if (field != None) and (arg.get('type') != 'boolean'):\\n help_name = arg.get('help-name')\\n if help_name:\\n help_name = '<' + help_name + '>'\\n else:\\n if arg.get('type') == 'enum':\\n values = arg.get('values')\\n if values:\\n if _is_string(values):\\n values = (values,)\\n help_name = ' | '.join(values)\\n if len(values) > 1:\\n help_name = '{' + help_name + '}'\\n if not help_name:\\n help_name = '<' + field + '>'\\n syntax_string += help_name\\n if optional:\\n syntax_string += ']'\\n \\n return syntax_string\",\n \"def cmd(*args):\\r\\n return \\\" \\\".join([str(arg) for arg in args])\",\n \"def build_command(args, parser):\\n cmd = \\\"ipmitool -I lanplus\\\"\\n if not args.host:\\n print \\\"\\\\nERROR: hostname is required.\\\\n\\\"\\n parser.print_help()\\n sys.exit(1)\\n else:\\n cmd += ' -H ' + args.host\\n if args.port:\\n cmd += ' -p ' + args.port\\n if not args.user:\\n print \\\"\\\\nERROR: username is required.\\\\n\\\"\\n parser.print_help()\\n sys.exit(1)\\n else:\\n cmd += ' -U ' + args.user\\n if args.passwd:\\n cmd += ' -P ' + args.passwd\\n cmd += ' dcmi power reading'\\n if args.interval:\\n global INTERVAL\\n INTERVAL = args.interval\\n if args.nread:\\n global NREAD\\n NREAD = args.nread\\n else:\\n global INFINITY\\n INFINITY = True\\n if args.store:\\n global STORE\\n STORE = True\\n return cmd\",\n \"def command_string(func, targets, sources, kwds):\\n args= [repr(targets[0])] if len(targets) == 1 \\\\\\n else [] if not targets else [repr(targets)]\\n if sources:\\n args.append(repr(sources[0]) if len(sources) == 1\\n else repr(sources))\\n if kwds:\\n args.append(', '.join(['{}={}'.format(k, repr(v))\\n for k, v in kwds.items()]))\\n return '{}({})'.format(func.__name__, ', '.join(args))\",\n \"def __init__(self, cmd):\\n # Build command + options \\n self.cmd = cmd \\n setattr(self, 'command', \\\"%s\\\" % (cmd))\",\n \"def optstr(self) -> str:\\n if self.is_help:\\n return self.namestr()\\n typestr: str = (\\n self.typestr().upper() if self.type_frozen else self.typestr()\\n )\\n\\n if not self.ns_param or not self.argname_shorten:\\n # * makes sure it's not wrapped'\\n return f\\\"{self.namestr()}*[{typestr}]\\\"\\n\\n ret: List[str] = []\\n for term in sorted(self.terminals, key=len):\\n ret.append(f\\\"~<ns>.{term}\\\")\\n return \\\", \\\".join(ret) + f\\\"*[{typestr}]\\\"\",\n \"def __generate_usage_string(self):\\n usage = \\\"{} <command> [<args>]\\\\n\\\\n\\\" \\\\\\n \\\"Available commands:\\\\n\\\".format(self.name)\\n max_name_length = len(max(self.cmd_list, key=lambda x: len(x[0]))[0])\\n for name, desc in self.cmd_list:\\n name_spacing = \\\" \\\" * (max_name_length - len(name)) + \\\" \\\" * 5\\n usage += \\\" {}{}{}\\\\n\\\".format(name, name_spacing, desc)\\n\\n return usage\",\n \"def __cmd_builder(self):\\n self.cmd = 'python -m lizard \\\"%s\\\" ' % self.get_proj_path()\\n args = \\\"\\\"\\n if self.get_cyclo_args():\\n args = self.get_cyclo_args()\\n exclude = \\\",\\\".join(str(x) for x in self.get_cyclo_exclude() if x is not None)\\n if exclude:\\n exclude = ','.join(' -x \\\"{0}\\\"'.format(w) for w in exclude.rstrip().split(','))\\n self.cmd = self.cmd + args + \\\" \\\" + exclude + \\\" --csv\\\"\\n print(self.cmd) # pragma: no mutate\",\n \"def command_help(self):\\n print(\\\"Command \\\", self)\\n print(\\\"\\\\t\\\\thelp (Get help for command)\\\")\\n\\n params = self.params.copy()\\n del params[\\\"help\\\"]\\n\\n if len(params) == 0:\\n print(\\\"This command has no parameters\\\")\\n return\\n\\n print(\\\"Parameters:\\\")\\n for info in params.values():\\n print(\\\" %s\\\" % info.get_basic_info())\\n description = info.get_desc()\\n if description != \\\"\\\":\\n print(textwrap.fill(description,\\n initial_indent=\\\" \\\",\\n subsequent_indent=\\\" \\\",\\n width=70))\",\n \"def command(self):\\n # These are pset variables, (aside from sfh)\\n dt = [(\\\"zred\\\", \\\"%.2f\\\"), (\\\"zmet\\\", \\\"%02i\\\"), (\\\"tau\\\", \\\"%.10f\\\"),\\n (\\\"const\\\", \\\"%.4f\\\"), (\\\"sf_start\\\", \\\"%.2f\\\"), (\\\"tage\\\", \\\"%.4f\\\"),\\n (\\\"fburst\\\", \\\"%.4f\\\"), (\\\"tburst\\\", \\\"%.4f\\\"), (\\\"imf1\\\", \\\"%.2f\\\"),\\n (\\\"imf2\\\", \\\"%.2f\\\"), (\\\"imf3\\\", \\\"%.2f\\\"), (\\\"vdmc\\\", \\\"%.2f\\\"),\\n (\\\"mdave\\\", \\\"%.1f\\\"), (\\\"dust_tesc\\\", \\\"%.2f\\\"), (\\\"dust1\\\", \\\"%.6f\\\"),\\n (\\\"dust2\\\", \\\"%.6f\\\"), (\\\"dust_clumps\\\", \\\"%.1f\\\"),\\n (\\\"frac_nodust\\\", \\\"%.2f\\\"), (\\\"dust_index\\\", \\\"%.2f\\\"),\\n (\\\"mwr\\\", \\\"%.2f\\\"), (\\\"uvb\\\", \\\"%.2f\\\"), (\\\"wgp1\\\", \\\"%i\\\"),\\n (\\\"wgp2\\\", \\\"%i\\\"), (\\\"wgp3\\\", \\\"%i\\\"), (\\\"dell\\\", \\\"%.2f\\\"),\\n (\\\"delt\\\", \\\"%.2f\\\"), (\\\"sbss\\\", \\\"%.2f\\\"), (\\\"fbhb\\\", \\\"%.2f\\\"),\\n (\\\"pagb\\\", \\\"%.2f\\\")]\\n cmd = str(self.name) + \\\" \\\" + \\\" \\\".join([s % self.p[k] for (k, s) in dt])\\n return cmd\",\n \"def get_command_help(self, module_name, command_name):\\r\\n command = self.env.get_command(module_name, command_name)\\r\\n\\r\\n default_format = 'raw'\\r\\n if sys.stdout.isatty():\\r\\n default_format = 'table'\\r\\n\\r\\n arg_doc = command.__doc__\\r\\n\\r\\n if 'confirm' in command.options:\\r\\n arg_doc += \\\"\\\"\\\"\\r\\nPrompt Options:\\r\\n -y, --really Confirm all prompt actions\\r\\n\\\"\\\"\\\"\\r\\n\\r\\n if '[options]' in arg_doc:\\r\\n arg_doc += \\\"\\\"\\\"\\r\\nStandard Options:\\r\\n --format=ARG Output format. [Options: table, raw] [Default: %s]\\r\\n -C FILE --config=FILE Config file location. [Default: ~/.softlayer]\\r\\n --debug=LEVEL Specifies the debug noise level\\r\\n 1=warn, 2=info, 3=debug\\r\\n --timings Time each API call and display after results\\r\\n --proxy=PROTO:PROXY_URL HTTP[s] proxy to be use to make API calls\\r\\n -h --help Show this screen\\r\\n\\\"\\\"\\\" % default_format\\r\\n return arg_doc.strip()\",\n \"def create_command_line(clt_desc, input_dict):\\n args = []\\n if 'arguments' in clt_desc:\\n for argument in clt_desc['arguments']:\\n if not isinstance(argument, str):\\n exit_system_error('Sorry: I only understand strings for arguments.'\\n 'Please use the inputs to pass arguments from input parameters.')\\n args.append((-1, clt_desc['arguments']))\\n\\n for parameter in clt_desc['inputs']:\\n args.append(create_argument(parameter, input_dict))\\n\\n args.sort(key=lambda arg: arg[0])\\n\\n # drop keys and flatten\\n command_line = []\\n for _, items in args:\\n if items is not None:\\n command_line.extend(items)\\n return command_line\",\n \"def cmd_help(args):\",\n \"def _GetCommand(self):\\n cmd = [FLAGS.openstack_cli_path]\\n cmd.extend(self.args)\\n for flag_name, values in six.iteritems(self.flags):\\n flag_name_str = '--%s' % flag_name\\n if values is True:\\n cmd.append(flag_name_str)\\n else:\\n values_iterable = values if isinstance(values, list) else [values]\\n for value in values_iterable:\\n cmd.append(flag_name_str)\\n cmd.append(str(value))\\n cmd.extend(self.additional_flags)\\n return cmd\",\n \"def command_with_params(self):\\n command = [super().command_with_params]\\n for name in sorted(self._jobs):\\n if name == \\\"global\\\":\\n command.insert(1, str(self._jobs[name]))\\n else:\\n command.append(str(self._jobs[name]))\\n return \\\" \\\".join(command)\",\n \"def command_short():\\n pass\",\n \"def _buildCmd(self, cmd, cmdArg=0x00):\\n res = [cmd, cmdArg]\\n if self.USE_SUFFIX:\\n return res + [self.CMD_SUFFIX]\\n return res\",\n \"def win32_command(command, *args, **kwargs):\\n # pylint: disable = redefined-outer-name\\n return ' '.join([metasub(\\n '\\\"%s\\\"' % (slashsub(token).replace('\\\"', '\\\\\\\\\\\"'),)\\n if needq(token) else token\\n ) for token in map(_make_formatter(*args, **kwargs),\\n split_command(command))])\",\n \"def get_spoon_cmd(parameter_dict):\\n class_name_parameter = \\\" --e class=com.kkbox.tests.e2e.\\\"\\n # class_name_parameter = \\\" --e class=com.kkbox.tests.e2e.cucumber.feature.\\\"\\n # class_name_parameter = \\\" --e package=com.kkbox.tests.e2e.\\\"\\n test_case_size = \\\" --size \\\"\\n spoon_cmd = \\\"java -jar {0}/spoon-runner-1.7.1-jar-with-dependencies.jar \\\\\\n --output {1}/result \\\\\\n --grant-all \\\\\\n --no-animations \\\\\\n --apk {2}/KKBOX-play-debug.apk \\\\\\n --test-apk {2}/KKBOX-play-debug-androidTest.apk\\\".format(spoon_folder, output_folder, apk_output_folder)\\n\\n if 'class' in parameter_dict:\\n class_name_parameter += parameter_dict.get('class')\\n spoon_cmd += class_name_parameter\\n\\n if 'size' in parameter_dict:\\n test_case_size += parameter_dict.get('size')\\n spoon_cmd += test_case_size\\n\\n return spoon_cmd\",\n \"def get_cmd(self, cmd_class, argument_string=\\\"\\\"): \\n cmd = cmd_class()\\n cmd.caller = self.char1\\n cmd.cmdstring = cmd_class.key\\n cmd.args = argument_string\\n cmd.cmdset = None\\n cmd.obj = self.char1\\n return cmd\",\n \"def get_usage_command(self):\\n return textwrap.fill(self.expand_prog_name(\\\"Type '%prog help' for usage information.\\\"), 78)\",\n \"def DoHelp(options, args):\\n __pychecker__ = 'unusednames=options'\\n if len(args) == 1 and args[0] in COMMAND_USAGE_TEXT:\\n print(COMMAND_USAGE_TEXT[args[0]])\\n else:\\n raise gclient_utils.Error(\\\"unknown subcommand '%s'; see 'gclient help'\\\" %\\n args[0])\",\n \"def _build_simple_command(self, cmd):\\n return cmd+SBE37_NEWLINE\",\n \"def prepare_executable_cmd(args: dict):\\n return [str(args[\\\"executable\\\"].resolve(strict=True)),\\n \\\"-m\\\", str(args[\\\"model\\\"].resolve(strict=True)),\\n \\\"-d\\\", args[\\\"device\\\"]]\",\n \"def arg_str(self):\\n\\n args = ['self']\\n args.extend([x.name for x in self.required_inputs])\\n args.extend([\\\"{}=None\\\".format(x.name) for x in self.optional_inputs])\\n\\n return \\\", \\\".join(args)\",\n \"def help_command(bot: Phial) -> str:\\n help_text = cast(str, bot.config.get(\\\"baseHelpText\\\", \\\"\\\"))\\n if help_text:\\n help_text += \\\"\\\\n\\\"\\n for command in bot.commands:\\n if command.hide_from_help_command:\\n continue\\n command_doc = command.help_text\\n if not command_doc:\\n # If no help text default to blank string\\n command_doc = \\\"\\\"\\n command_help_text = parse_help_text(command_doc)\\n help_text += \\\"*{0}* - {1}\\\\n\\\".format(command.pattern_string, command_help_text)\\n return help_text\",\n \"def help(command = None):\\n if command is None:\\n option = \\\" {:12} {}\\\"\\n help_text = [\\n \\\"Usage: tracker <command> [<args>]\\\",\\n \\\"\\\",\\n \\\"Available commands:\\\",\\n option.format(\\\"help\\\", \\\"display this dialog\\\"),\\n option.format(\\\"update\\\", \\\"save data to tracker\\\"),\\n option.format(\\\"list\\\", \\\"list available trackers\\\"),\\n option.format(\\\"show\\\", \\\"display raw tracker data\\\"),\\n option.format(\\\"rename\\\", \\\"rename tracker\\\"),\\n option.format(\\\"delete\\\", \\\"remove tracker\\\"),\\n option.format(\\\"stats\\\", \\\"show statistics\\\"),\\n option.format(\\\"plot\\\", \\\"show graph\\\"),\\n \\\"\\\",\\n \\\"Use 'tracker help <command>' for a command's detailed usage.\\\"\\n ]\\n print(\\\"\\\\n\\\".join(help_text))\\n else:\\n # commands = [\\\"update\\\", \\\"list\\\", \\\"show\\\", \\\"rename\\\", \\\"delete\\\", \\\"stats\\\", \\\"plot\\\"]\\n usage = \\\" {}\\\"\\n desc = \\\" {}\\\"\\n if command == \\\"update\\\":\\n help_text = [\\n \\\"Update: command which adds (numerical) data to a tracker.\\\",\\n \\\"\\\",\\n \\\"Usage:\\\",\\n usage.format(\\\"tracker update <tracker> <data>\\\"),\\n usage.format(\\\"tracker update <tracker>\\\"),\\n \\\"\\\",\\n \\\"Description:\\\",\\n usage.format(\\\"tracker update <tracker> <data>\\\"),\\n desc.format(\\\"This form is shorthand for saving <data> to \\\" +\\n \\\"<tracker> for today's date.\\\"),\\n \\\"\\\",\\n usage.format(\\\"tracker update <tracker>\\\"),\\n desc.format(\\\"This form is used to set the value for an \\\" +\\n \\\"arbitrary date for <tracker>.\\\"),\\n desc.format(\\\"The date must be in the format YYYY-MM-DD.\\\"),\\n \\\"\\\",\\n \\\"Options:\\\",\\n usage.format(\\\"<tracker>\\\"),\\n desc.format(\\\"The name of the tracker to update, converted to lowercase.\\\"),\\n desc.format(\\\"If <tracker> does not exist, you will be prompted to create it.\\\"),\\n \\\"\\\",\\n usage.format(\\\"<data>\\\"),\\n desc.format(\\\"The value to save to the tracker to update, must be numerical.\\\")\\n ]\\n elif command == \\\"list\\\":\\n help_text = [\\n \\\"List: displays a list of trackers which have been created\\\",\\n \\\"\\\",\\n \\\"Usage:\\\",\\n usage.format(\\\"tracker list\\\")\\n ]\\n elif command == \\\"show\\\":\\n help_text = [\\n \\\"Show: displays raw dates and values for a tracker\\\",\\n \\\"\\\",\\n \\\"Usage:\\\",\\n usage.format(\\\"tracker show <tracker>\\\"),\\n \\\"\\\",\\n \\\"Description:\\\",\\n usage.format(\\\"tracker show <tracker>\\\"),\\n desc.format(\\\"Displays all data for <tracker> in the form '<date> | <value>'.\\\"),\\n desc.format(\\\"Note: <date> is formatted as 'YYYY-MM-DD'.\\\"),\\n \\\"\\\",\\n \\\"Options:\\\",\\n usage.format(\\\"<tracker>\\\"),\\n desc.format(\\\"The name of the tracker to show, converted to lowercase.\\\"),\\n ]\\n elif command == \\\"rename\\\":\\n help_text = [\\n \\\"Rename: change name of a tracker\\\",\\n \\\"\\\",\\n \\\"Usage:\\\",\\n usage.format(\\\"tracker rename <tracker> <new_tracker>\\\"),\\n \\\"\\\",\\n \\\"Description:\\\",\\n usage.format(\\\"tracker rename <tracker> <new_tracker>\\\"),\\n desc.format(\\\"All <tracker> entries will not be <new_tracker> entries.\\\"),\\n \\\"\\\",\\n \\\"Options:\\\",\\n usage.format(\\\"<tracker>\\\"),\\n desc.format(\\\"The name of the existing tracker to change, converted to lowercase.\\\"),\\n \\\"\\\",\\n usage.format(\\\"<new_tracker>\\\"),\\n desc.format(\\\"The name of the new tracker (must not already exist), converted to lowercase.\\\")\\n ]\\n elif command == \\\"delete\\\":\\n help_text = [\\n \\\"Delete: permanently removes all data entries for a given tracker\\\",\\n \\\"\\\",\\n \\\"Usage:\\\",\\n usage.format(\\\"tracker delete <tracker>\\\"),\\n \\\"\\\",\\n \\\"Description:\\\",\\n usage.format(\\\"tracker delete <tracker>\\\"),\\n desc.format(\\\"All sqlite entries associated with <tracker> are deleted.\\\"),\\n \\\"\\\",\\n \\\"Options:\\\",\\n usage.format(\\\"<tracker>\\\"),\\n desc.format(\\\"The name of the tracker to delete, converted to lowercase.\\\")\\n ]\\n elif command == \\\"stats\\\":\\n help_text = [\\n \\\"Stats: show statistics for tracker(s)\\\",\\n \\\"\\\",\\n \\\"Usage:\\\",\\n usage.format(\\\"tracker stats <tracker> <tracker>\\\"),\\n usage.format(\\\"tracker stats <tracker>\\\"),\\n usage.format(\\\"tracker stats\\\"),\\n \\\"\\\",\\n \\\"Description:\\\",\\n usage.format(\\\"tracker stats <tracker> <tracker>\\\"),\\n desc.format(\\\"Show correlation coefficient between two trackers.\\\"),\\n \\\"\\\",\\n usage.format(\\\"tracker stats <tracker>\\\"),\\n desc.format(\\\"Display information for each weekday and entire time period.\\\"),\\n desc.format(\\\"Stats included: total, mean, min, max.\\\"),\\n \\\"\\\",\\n usage.format(\\\"tracker stats\\\"),\\n desc.format(\\\"Displays information about all trackers.\\\"),\\n desc.format(\\\"Stats included: total entries, entries per tracker.\\\"),\\n \\\"\\\",\\n \\\"Options:\\\",\\n usage.format(\\\"<tracker>\\\"),\\n desc.format(\\\"The name of the tracker to show stats for, converted to lowercase.\\\")\\n ]\\n elif command == \\\"plot\\\":\\n help_text = [\\n \\\"Plot: show graph for tracker\\\",\\n \\\"\\\",\\n \\\"Usage:\\\",\\n usage.format(\\\"tracker plot <tracker>\\\"),\\n \\\"\\\",\\n \\\"Description:\\\",\\n usage.format(\\\"tracker stats <tracker>\\\"),\\n desc.format(\\\"Displays graph for <tracker> from first entry to last entry.\\\"),\\n \\\"\\\",\\n \\\"Options:\\\",\\n usage.format(\\\"<tracker>\\\"),\\n desc.format(\\\"The name of the tracker to graph, converted to lowercase.\\\")\\n ]\\n else:\\n error(\\\"Invalid command: '{}'\\\".format(command))\\n print(\\\"\\\\n\\\".join(help_text))\\n sys.exit(1)\",\n \"def help(self):\\n\\n option_args_help = Template(\\n messages.help.details\\n ).render(\\n module_name = self.name,\\n description = self.info['description'],\\n mand_arguments = self.args_mandatory,\\n opt_arguments = self.args_optional,\\n stored_arguments = self.session[self.name]['stored_args'],\\n vector_arg = (self.bind_to_vectors, self.vectors.get_names())\\n )\\n\\n log.info(option_args_help)\",\n \"def format_help(self, prog: Optional[str] = None) -> str:\\n actions = self._build()[1]\\n prog = prog or Path(sys.argv[0]).name\\n\\n formatter = argparse.HelpFormatter(prog)\\n formatter.add_usage(None, actions, [])\\n\\n if self.help:\\n formatter.add_text(self.help)\\n\\n if actions:\\n formatter.add_text(\\\"OPTIONS:\\\")\\n formatter.start_section(None)\\n formatter.add_arguments(actions)\\n formatter.end_section()\\n\\n subhelp = []\\n for name, child in self._children.items():\\n child._subhelp(name, subhelp)\\n\\n if subhelp:\\n formatter.add_text(\\\"COMMANDS:\\\")\\n subhelp.insert(0, \\\"\\\")\\n\\n return formatter.format_help() + \\\"\\\\n\\\".join(subhelp)\",\n \"def cmdify(self):\\n return \\\" \\\".join(\\n itertools.chain(\\n [_quote_if_contains(self.command, r\\\"[\\\\s^()]\\\")],\\n (_quote_if_contains(arg, r\\\"[\\\\s^]\\\") for arg in self.args),\\n )\\n )\",\n \"def make_help_cmd(cmd, docstring):\\n def help_cmd(message=docstring, cmd=cmd):\\n print('=' * 15)\\n print('\\\\nHelp for command %s:\\\\n' % (cmd,))\\n print(message.strip())\\n print('')\\n print('=' * 15)\\n print('')\\n\\n return help_cmd\",\n \"def get_cli_string():\\n return os.path.basename(sys.argv[0]) + \\\" \\\" + \\\" \\\".join(sys.argv[1:])\",\n \"def makeCommands(f0,psi0,th,logFileName,mat,fnyld,fnhrd):\\n from mk.library.lib import gen_tempfile\\n stdoutFileName = gen_tempfile(\\n prefix='stdout-mkrun')\\n # stdoutFileName ='/tmp/dump'\\n\\n cmd = 'python main.py --fn %s -f %5.4f -p %+6.1f -t %+7.2f --fnyld %s --fnhrd %s '%(\\n logFileName,f0,psi0,th,fnyld,fnhrd)\\n\\n if mat!=-1:\\n cmd = cmd + ' --mat %i'%mat\\n cmd = cmd + ' > %s'%stdoutFileName\\n print 'cmd:',cmd\\n return cmd\",\n \"def dict2argstr(args_dict):\\n arg_str = \\\"\\\"\\n for arg, value in args_dict.items():\\n if value is not None:\\n arg_str += \\\" --{} {}\\\".format(str(arg), str(value))\\n return arg_str\",\n \"def format_magic_R_args(**magic_R_args):\\n return ' '.join(f\\\"--{k}={v}\\\" for k, v in magic_R_args.items())\",\n \"def __repr__(self):\\n klass = self.__class__.__qualname__\\n cmd = \\\" \\\".join(sys.argv)\\n cmd_ = f\\\"$ {cmd}\\\"\\n args = pformat(self.get_args())\\n repr_ = \\\"\\\\n\\\".join((klass, cmd_, args))\\n return f\\\"<{repr_}>\\\"\",\n \"def command(self) -> str:\\n cmd = ''\\n if self.argv:\\n cmd = self.argv[0]\\n return cmd\",\n \"def __str__(self):\\n args = []\\n if len(self.args) > 0:\\n args += ['{}'.format(a) for a in self.args]\\n if len(self.kwargs) > 0:\\n args += [\\\"{}={}\\\".format(k, v) for k, v in self.kwargs.items()]\\n return '{}({})'.format(self.name, ', '.join(args))\",\n \"def get_usage_command(self):\\n return textwrap.fill(self.sbtools.parser.expand_prog_name(\\\"Type '%prog help %s' for usage.\\\") % (self.tool.get_command()), 78)\",\n \"def optstr(self) -> str:\\n typestr: str = (\\n self.typestr().upper() if self.type_frozen else self.typestr()\\n )\\n if not self.ns_param or not self.argname_shorten:\\n # * makes sure it's not wrapped\\n return (\\n self.namestr()\\n if self.is_help\\n else f\\\"{self.namestr()}*<{typestr}>\\\"\\n )\\n\\n ret: List[str] = []\\n for term in sorted(self.terminals, key=len):\\n ret.append(f\\\"~<ns>.{term}\\\")\\n return \\\", \\\".join(ret) + f\\\"*<{typestr}>\\\"\",\n \"def help(self):\\n msg = \\\"`%s' performs the computational aspects of genotyping-by-sequencing.\\\\n\\\" % os.path.basename(sys.argv[0])\\n msg += \\\"\\\\n\\\"\\n msg += \\\"Usage: %s [OPTIONS] ...\\\\n\\\" % os.path.basename(sys.argv[0])\\n msg += \\\"\\\\n\\\"\\n msg += \\\"Options:\\\\n\\\"\\n msg += \\\" -h, --help\\\\tdisplay the help and exit\\\\n\\\"\\n msg += \\\" -V, --version\\\\toutput version information and exit\\\\n\\\"\\n msg += \\\" -v, --verbose\\\\tverbosity level (0/default=1/2/3)\\\\n\\\"\\n msg += \\\" --proj1\\\\tname of the project used for steps 1 to 4\\\\n\\\"\\n msg += \\\"\\\\t\\\\tmention a reference genome only if all samples belong to\\\\n\\\"\\n msg += \\\"\\\\t\\\\t the same species, and will be mapped to the same ref genome\\\\n\\\"\\n msg += \\\" --proj2\\\\tname of the project used for steps 4 to 8\\\\n\\\"\\n msg += \\\"\\\\t\\\\tcan be the same as --proj1, or can be different\\\\n\\\"\\n msg +=\\\"\\\\t\\\\t notably when samples come from different species\\\\n\\\"\\n msg += \\\"\\\\t\\\\t or if one wants to align reads to different ref genomes\\\\n\\\"\\n msg += \\\" --schdlr\\\\tname of the cluster scheduler (default=SGE)\\\\n\\\"\\n msg += \\\" --queue\\\\tname of the cluster queue (default=normal.q)\\\\n\\\"\\n msg += \\\" --resou\\\\tcluster resources (e.g. 'test' for 'qsub -l test')\\\\n\\\"\\n msg += \\\" --rmvb\\\\tremove bash scripts for jobs launched in parallel\\\\n\\\"\\n msg += \\\" --step\\\\tstep to perform (1/2/3/.../9)\\\\n\\\"\\n msg += \\\"\\\\t\\\\t1: raw read quality per lane (with FastQC v >= 0.11.2)\\\\n\\\"\\n msg += \\\"\\\\t\\\\t2: demultiplexing per lane (with demultiplex.py v >= 1.14.0)\\\\n\\\"\\n msg += \\\"\\\\t\\\\t3: cleaning per sample (with CutAdapt v >= 1.8)\\\\n\\\"\\n msg += \\\"\\\\t\\\\t4: alignment per sample (with BWA MEM v >= 0.7.12, Samtools v >= 1.3, Picard and R v >= 3)\\\\n\\\"\\n msg += \\\"\\\\t\\\\t5: local realignment per sample (with GATK v >= 3.5)\\\\n\\\"\\n msg += \\\"\\\\t\\\\t6: local realignment per genotype (with GATK v >= 3.5)\\\\n\\\"\\n msg += \\\"\\\\t\\\\t7: variant and genotype calling per genotype (with GATK HaplotypeCaller v >= 3.5)\\\\n\\\"\\n msg += \\\"\\\\t\\\\t8: variant and genotype calling jointly across genotypes (with GATK GenotypeGVCFs v >= 3.5)\\\\n\\\"\\n msg += \\\"\\\\t\\\\t9: variant and genotype filtering (with GATK v >= 3.5)\\\\n\\\"\\n msg += \\\" --samples\\\\tpath to the 'samples' file\\\\n\\\"\\n msg += \\\"\\\\t\\\\tcompulsory for all steps, but can differ between steps\\\\n\\\"\\n msg += \\\"\\\\t\\\\t e.g. if samples come from different species or are aligned\\\\n\\\"\\n msg += \\\"\\\\t\\\\t on different ref genomes, different samples file should\\\\n\\\"\\n msg += \\\"\\\\t\\\\t be used for steps 4-9, representing different subsets of\\\\n\\\"\\n msg += \\\"\\\\t\\\\t the file used for steps 1-3\\\\n\\\"\\n msg += \\\"\\\\t\\\\tthe file should be encoded in ASCII\\\\n\\\"\\n msg += \\\"\\\\t\\\\tthe first row should be a header with column names\\\\n\\\"\\n msg += \\\"\\\\t\\\\teach 'sample' (see details below) should have one and only one row\\\\n\\\"\\n msg += \\\"\\\\t\\\\tany two columns should be separated with one tabulation\\\\n\\\"\\n msg += \\\"\\\\t\\\\tcolumns can be in any order\\\\n\\\"\\n msg += \\\"\\\\t\\\\trows starting by '#' are skipped\\\\n\\\"\\n msg += \\\"\\\\t\\\\t12 columns are compulsory (but there can be more):\\\\n\\\"\\n msg += \\\"\\\\t\\\\t genotype (see details below, e.g. 'Col-0', but use neither underscore '_' nor space ' ' nor dot '.', use dash '-' instead)\\\\n\\\"\\n msg += \\\"\\\\t\\\\t ref_genome (identifier of the reference genome used for alignment, e.g. 'Atha_v2', but use neither space ' ' nor dot '.'; the full species name, e.g. 'Arabidopsis thaliana', will be present in the file given to --dict)\\\\n\\\"\\n msg += \\\"\\\\t\\\\t library (e.g. can be the same as 'genotype')\\\\n\\\"\\n msg += \\\"\\\\t\\\\t barcode (e.g. 'ATGG')\\\\n\\\"\\n msg += \\\"\\\\t\\\\t seq_center (e.g. 'Broad Institute', 'GenoToul', etc)\\\\n\\\"\\n msg += \\\"\\\\t\\\\t seq_platform (e.g. 'ILLUMINA', see SAM format specification)\\\\n\\\"\\n msg += \\\"\\\\t\\\\t seq_platform_model (e.g. 'HiSeq 2000')\\\\n\\\"\\n msg += \\\"\\\\t\\\\t flowcell (e.g. 'C5YMDACXX')\\\\n\\\"\\n msg += \\\"\\\\t\\\\t lane (e.g. '3', can be '31' if a first demultiplexing was done per index)\\\\n\\\"\\n msg += \\\"\\\\t\\\\t date (e.g. '2015-01-15', see SAM format specification)\\\\n\\\"\\n msg += \\\"\\\\t\\\\t fastq_file_R1 (filename, one per lane, gzip-compressed)\\\\n\\\"\\n msg += \\\"\\\\t\\\\t fastq_file_R2 (filename, one per lane, gzip-compressed)\\\\n\\\"\\n msg += \\\" --fcln\\\\tidentifier of a flowcell and lane number\\\\n\\\"\\n msg += \\\"\\\\t\\\\tformat as <flowcell>_<lane-number>, e.g. 'C5YMDACXX_1'\\\\n\\\"\\n msg += \\\"\\\\t\\\\tif set, only the samples from this lane will be analyzed\\\\n\\\"\\n msg += \\\" --pird\\\\tpath to the input reads directory\\\\n\\\"\\n msg += \\\"\\\\t\\\\tcompulsory for steps 1 and 2\\\\n\\\"\\n msg += \\\"\\\\t\\\\twill be added to the columns 'fastq_file_R*' from the sample file\\\\n\\\"\\n msg += \\\"\\\\t\\\\tif not set, input read files should be in current directory\\\\n\\\"\\n msg += \\\" --enz\\\\tname of the restriction enzyme\\\\n\\\"\\n msg += \\\"\\\\t\\\\tcompulsory for step 2\\\\n\\\"\\n msg += \\\"\\\\t\\\\tdefault=ApeKI\\\\n\\\"\\n msg += \\\" --dmxmet\\\\tmethod used to demultiplex\\\\n\\\"\\n msg += \\\"\\\\t\\\\tcompulsory for step 2\\\\n\\\"\\n msg += \\\"\\\\t\\\\tdefault=4c (see the help of demultiplex.py to know more)\\\\n\\\"\\n msg += \\\" --subst\\\\tnumber of substitutions allowed during demultiplexing\\\\n\\\"\\n msg += \\\"\\\\t\\\\tcompulsory for step 2\\\\n\\\"\\n msg += \\\"\\\\t\\\\tdefault=2\\\\n\\\"\\n msg += \\\" --ensubst\\\\tenforce the nb of substitutions allowed\\\\n\\\"\\n msg += \\\"\\\\t\\\\tcompulsory for step 2\\\\n\\\"\\n msg += \\\"\\\\t\\\\tdefault=lenient/strict\\\\n\\\"\\n msg += \\\" --adp\\\\tpath to the file containing the adapters\\\\n\\\"\\n msg += \\\"\\\\t\\\\tcompulsory for step 3\\\\n\\\"\\n msg += \\\"\\\\t\\\\tsame format as FastQC: name<tab>sequence\\\\n\\\"\\n msg += \\\"\\\\t\\\\tname: at least 'adpR1' (also 'adpR2' if paired-end)\\\\n\\\"\\n msg += \\\"\\\\t\\\\tsequence: from 5' (left) to 3' (right)\\\\n\\\"\\n msg += \\\" --errtol\\\\terror tolerance to find adapters\\\\n\\\"\\n msg += \\\"\\\\t\\\\tcompulsory for step 3\\\\n\\\"\\n msg += \\\"\\\\t\\\\tdefault=0.2\\\\n\\\"\\n msg += \\\" --minovl\\\\tminimum overlap length between reads and adapters\\\\n\\\"\\n msg += \\\"\\\\t\\\\tcompulsory for step 3\\\\n\\\"\\n msg += \\\"\\\\t\\\\tdefault=3 (in bases)\\\\n\\\"\\n msg += \\\" --minrl\\\\tminimum length to keep a read\\\\n\\\"\\n msg += \\\"\\\\t\\\\tcompulsory for step 3\\\\n\\\"\\n msg += \\\"\\\\t\\\\tdefault=35 (in bases)\\\\n\\\"\\n msg += \\\" --minq\\\\tminimum quality to trim a read\\\\n\\\"\\n msg += \\\"\\\\t\\\\tcompulsory for step 3\\\\n\\\"\\n msg += \\\"\\\\t\\\\tdefault=20 (used for both reads if paired-end)\\\\n\\\"\\n msg += \\\" --maxNp\\\\tmaximum percentage of N to keep a read\\\\n\\\"\\n msg += \\\"\\\\t\\\\tcompulsory for step 3\\\\n\\\"\\n msg += \\\"\\\\t\\\\tdefault=0.2\\\\n\\\"\\n msg += \\\" --ref\\\\tpath to the prefix of files for the reference genome\\\\n\\\"\\n msg += \\\"\\\\t\\\\tcompulsory for steps 4, 5, 6, 7, 8, 9\\\\n\\\"\\n msg += \\\"\\\\t\\\\tshould correspond to the 'ref_genome' column in --samples\\\\n\\\"\\n msg += \\\"\\\\t\\\\te.g. '/data/Atha_v2' for '/data/Atha_v2.fa', '/data/Atha_v2.bwt', etc\\\\n\\\"\\n msg += \\\"\\\\t\\\\tthese files are produced via 'bwa index ...'\\\\n\\\"\\n msg += \\\" --dict\\\\tpath to the 'dict' file (SAM header with @SQ tags)\\\\n\\\"\\n msg += \\\"\\\\t\\\\tcompulsory for step 4\\\\n\\\"\\n msg += \\\"\\\\t\\\\tsee 'CreateSequenceDictionary' in the Picard software\\\\n\\\"\\n msg += \\\" --jgid\\\\tcohort identifier to use for joint genotyping\\\\n\\\"\\n msg += \\\"\\\\t\\\\tcompulsory for steps 8, 9\\\\n\\\"\\n msg += \\\"\\\\t\\\\tuseful to launch several, different cohorts in parallel\\\\n\\\"\\n msg += \\\" --rat\\\\trestrict alleles to be of a particular allelicity\\\\n\\\"\\n msg += \\\"\\\\t\\\\tused in step 9\\\\n\\\"\\n msg += \\\"\\\\t\\\\tdefault=ALL/BIALLELIC/MULTIALLELIC\\\\n\\\"\\n msg += \\\"\\\\t\\\\tsee '--restrictAllelesTo' in GATK's SelectVariant\\\\n\\\"\\n msg += \\\" --mdp\\\\tminimum value for DP (read depth; e.g. 10)\\\\n\\\"\\n msg += \\\"\\\\t\\\\tused in step 9\\\\n\\\"\\n msg += \\\"\\\\t\\\\tsee GATK's VariantFiltration\\\\n\\\"\\n msg += \\\" --mgq\\\\tminimum value for GQ (genotype quality; e.g. 20)\\\\n\\\"\\n msg += \\\"\\\\t\\\\tused in step 9\\\\n\\\"\\n msg += \\\"\\\\t\\\\tsee GATK's VariantFiltration\\\\n\\\"\\n msg += \\\" --mnfg\\\\tmaximum number of filtered genotypes to keep a variant\\\\n\\\"\\n msg += \\\"\\\\t\\\\tused in step 9\\\\n\\\"\\n msg += \\\"\\\\t\\\\tsee '--maxFilteredGenotypes' in GATK's SelectVariants\\\\n\\\"\\n msg += \\\" --mffg\\\\tmaximum fraction of filtered genotypes to keep a variant\\\\n\\\"\\n msg += \\\"\\\\t\\\\tused in step 9\\\\n\\\"\\n msg += \\\"\\\\t\\\\tsee '--maxFractionFilteredGenotypes' in GATK's SelectVariants\\\\n\\\"\\n msg += \\\" --mnnc\\\\tmaximum number of not-called genotypes to keep a variant\\\\n\\\"\\n msg += \\\"\\\\t\\\\tused in step 9\\\\n\\\"\\n msg += \\\" --mfnc\\\\tmaximum fraction of not-called genotypes to keep a variant\\\\n\\\"\\n msg += \\\"\\\\t\\\\tused in step 9\\\\n\\\"\\n msg += \\\"\\\\t\\\\tsee '--maxNOCALLfraction' in GATK's SelectVariants\\\\n\\\"\\n msg += \\\" --fam\\\\tpath to the file containing pedigree information\\\\n\\\"\\n msg += \\\"\\\\t\\\\tused in step 9\\\\n\\\"\\n msg += \\\"\\\\t\\\\tdiscard variants with Mendelian violations (see Semler et al, 2012)\\\\n\\\"\\n msg += \\\"\\\\t\\\\tshould be in the 'fam' format specified by PLINK\\\\n\\\"\\n msg += \\\"\\\\t\\\\tvalidation strictness (GATK '-pedValidationType') is set at 'SILENT'\\\\n\\\"\\n msg += \\\"\\\\t\\\\t allowing some samples to be absent from the pedigree\\\\n\\\"\\n msg += \\\" --mvq\\\\tminimum GQ for each trio member to accept a variant as a Mendelian violation\\\\n\\\"\\n msg += \\\"\\\\t\\\\tused in step 9 if '--fam' is specified\\\\n\\\"\\n msg += \\\"\\\\t\\\\tdefault=0\\\\n\\\"\\n msg += \\\" --xlssf\\\\tpath to the file with genotypes to exclude\\\\n\\\"\\n msg += \\\"\\\\t\\\\tused in step 9 (can be especially useful if '--fam' is specified)\\\\n\\\"\\n msg += \\\" --tmpd\\\\tpath to a temporary directory on child nodes (default=.)\\\\n\\\"\\n msg += \\\"\\\\t\\\\te.g. it can be /tmp or /scratch\\\\n\\\"\\n msg += \\\"\\\\t\\\\tused in step 4 for 'samtools sort'\\\\n\\\"\\n msg += \\\"\\\\t\\\\tused in step 7 for 'GATK HaplotypeCaller'\\\\n\\\"\\n msg += \\\" --jvmXms\\\\tinitial memory allocated to the Java Virtual Machine\\\\n\\\"\\n msg += \\\"\\\\t\\\\tdefault=512m (can also be specified as 1024k, 1g, etc)\\\\n\\\"\\n msg += \\\"\\\\t\\\\tused in steps 4, 5, 6, 7 and 8 for Picard and GATK\\\\n\\\"\\n msg += \\\" --jvmXmx\\\\tmaximum memory allocated to the Java Virtual Machine\\\\n\\\"\\n msg += \\\"\\\\t\\\\tdefault=4g\\\\n\\\"\\n msg += \\\"\\\\t\\\\tused in steps 4, 5, 6, 7 and 8 for Picard and GATK\\\\n\\\"\\n msg += \\\" --queue2\\\\tname of the second cluster queue (default=bigmem.q)\\\\n\\\"\\n msg += \\\"\\\\t\\\\tused in step 4 for Picard to collect insert sizes\\\\n\\\"\\n msg += \\\" --knowni\\\\tpath to a VCF file with known indels (for local realignment)\\\\n\\\"\\n msg += \\\" --known\\\\tpath to a VCF file with known variants (e.g. from dbSNP)\\\\n\\\"\\n msg += \\\" --force\\\\tforce to re-run step(s)\\\\n\\\"\\n msg += \\\"\\\\t\\\\tthis removes without warning the step directory if it exists\\\\n\\\"\\n msg += \\\"\\\\n\\\"\\n msg += \\\"Examples:\\\\n\\\"\\n msg += \\\" %s --step 1 --samples samples.txt\\\\n\\\" % os.path.basename(sys.argv[0])\\n msg += \\\"\\\\n\\\"\\n msg += \\\"Details:\\\\n\\\"\\n msg += \\\"This program aims at genotyping a set of 'genotypes' using data from\\\\n\\\"\\n msg += \\\"a restriction-assisted DNA sequencing (RAD-seq) experiment, also known\\\\n\\\"\\n msg += \\\"as a genotyping-by-sequencing (GBS) experiment.\\\\n\\\"\\n msg += \\\"Here, by 'genotype', we mean the entity which is the focus of the\\\\n\\\"\\n msg += \\\"study. For instance, it can be a plant variety (or a human being), or\\\\n\\\"\\n msg += \\\"the specific clone of a given plant variety (or a specific tumor of a\\\\n\\\"\\n msg += \\\"given human being), etc.\\\\n\\\"\\n msg += \\\"Importantly, note that the content of the 'genotype' column will\\\\n\\\"\\n msg += \\\"be used to set the 'SM' (sample) tag of the 'RG' (read group) header\\\\n\\\"\\n msg += \\\"record type of the SAM format (see http://www.htslib.org/). However,\\\\n\\\"\\n msg += \\\"internal to this program, the term 'sample' corresponds to the unique\\\\n\\\"\\n msg += \\\"quadruplet (genotype,flowcell,lane,barcode) for steps 1 and 2, and to\\\\n\\\"\\n msg += \\\"the unique triplet (genotype,flowcell,lane) for the others.\\\\n\\\"\\n msg += \\\"Jobs are executed in parallel (--schdlr). Their return status is\\\\n\\\"\\n msg += \\\"recorded in a SQLite database which is removed at the end. If a job\\\\n\\\"\\n msg += \\\"fails, the whole script stops with an error.\\\\n\\\"\\n msg += \\\"\\\\n\\\"\\n msg += \\\"Dependencies:\\\\n\\\"\\n msg += \\\"Python >= 2.7; Biopython; pyutilstimflutre >= 0.5\\\\n\\\"\\n msg += \\\"\\\\n\\\"\\n msg += \\\"Report bugs to <timothee.flutre@inra.fr>.\\\"\\n print(msg); sys.stdout.flush()\",\n \"def test_commandRepr(self):\\n repr(imap4.Command(b\\\"COMMAND\\\", [b\\\"arg\\\"], (b'extra')))\",\n \"def _build_solo_command(self, cmd):\\n return COMMAND_CHAR[cmd]\",\n \"def __init__(self, cmd, **kwargs):\\n # Init method - should be subclassed!\\n # \\n # The subclass methods should look like this:\\n # \\n # def __init__(self, cmd=\\\"muscle\\\", **kwargs):\\n # self.parameters = [...]\\n # AbstractCommandline.__init__(self, cmd, **kwargs)\\n # \\n # i.e. There should have an optional argument \\\"cmd\\\" to set the location\\n # of the executable (with a sensible default which should work if the\\n # command is on the path on Unix), and keyword arguments. It should\\n # then define a list of parameters, all objects derived from the base\\n # class _AbstractParameter.\\n # \\n # The keyword arguments should be any valid parameter name, and will\\n # be used to set the associated parameter.\\n self.program_name = cmd\\n try:\\n parameters = self.parameters\\n except AttributeError:\\n raise AttributeError(\\\"Subclass should have defined self.parameters\\\")\\n #Create properties for each parameter at run time\\n aliases = set()\\n for p in parameters:\\n for name in p.names:\\n if name in aliases:\\n raise ValueError(\\\"Parameter alias %s multiply defined\\\" \\\\\\n % name)\\n aliases.add(name)\\n name = p.names[-1]\\n if _re_prop_name.match(name) is None:\\n raise ValueError(\\\"Final parameter name %s cannot be used as \\\"\\n \\\"an argument or property name in python\\\"\\n % repr(name))\\n if name in _reserved_names:\\n raise ValueError(\\\"Final parameter name %s cannot be used as \\\"\\n \\\"an argument or property name because it is \\\"\\n \\\"a reserved word in python\\\" % repr(name))\\n if name in _local_reserved_names:\\n raise ValueError(\\\"Final parameter name %s cannot be used as \\\"\\n \\\"an argument or property name due to the \\\"\\n \\\"way the AbstractCommandline class works\\\"\\n % repr(name))\\n #Beware of binding-versus-assignment confusion issues\\n def getter(name):\\n return lambda x : x._get_parameter(name)\\n def setter(name):\\n return lambda x, value : x.set_parameter(name, value)\\n def deleter(name):\\n return lambda x : x._clear_parameter(name)\\n doc = p.description\\n if isinstance(p, _Switch):\\n doc += \\\"\\\\n\\\\nThis property controls the addition of the %s \\\" \\\\\\n \\\"switch, treat this property as a boolean.\\\" % p.names[0]\\n else:\\n doc += \\\"\\\\n\\\\nThis controls the addition of the %s parameter \\\" \\\\\\n \\\"and its associated value. Set this property to the \\\" \\\\\\n \\\"argument value required.\\\" % p.names[0]\\n prop = property(getter(name), setter(name), deleter(name), doc)\\n setattr(self.__class__, name, prop) #magic!\\n for key, value in kwargs.iteritems():\\n self.set_parameter(key, value)\",\n \"def test_cli_help(self):\\n output = self.update_command('-h')\",\n \"def build_command(device, command_tuple, single_commands=False):\\n if isinstance(command_tuple, (str)):\\n command_tuple = (command_tuple, \\\"\\\") # make da dummy command\\n\\n if command_tuple[0] in device:\\n\\n if isinstance(device[command_tuple[0]], dict):\\n try:\\n com = device[command_tuple[0]][\\\"command\\\"]\\n except:\\n l.error(\\n \\\"Dict command structure recognised but no actual command found for passed order {}\\\".format(\\n command_tuple\\n ),\\n exc_info=True,\\n )\\n return None\\n else:\\n com = device[command_tuple[0]]\\n\\n if isinstance(command_tuple[1], (str, float, int)):\\n try:\\n return com.format(command_tuple[1])\\n except IndexError:\\n l.error(\\n \\\"You attempted to send a command with the wrong number of parameters the command structure is: {}\\\"\\n \\\" but you passed: [{}] as parameter(s)\\\".format(\\n com, command_tuple[1]\\n ),\\n exc_info=True,\\n )\\n\\n elif single_commands:\\n if isinstance(command_tuple[1], list) or isinstance(\\n command_tuple[1], tuple\\n ):\\n return [com.format(single) for single in command_tuple[1]]\\n else:\\n l.error(\\\"In order to build a list command, a list has to be passed!\\\")\\n return None\\n\\n elif isinstance(command_tuple[1], list) or isinstance(command_tuple[1], tuple):\\n # Find occurance of {} in string if list is as long as occurance of {} then just pass otherwise join a string\\n brackets_count = device[command_tuple[0]].count(\\\"{}\\\")\\n if len(command_tuple[1]) == brackets_count:\\n return com.format(*command_tuple[1])\\n elif brackets_count == 1 and len(command_tuple[1]) > brackets_count:\\n sep = device.get(\\\"separator\\\", \\\" \\\")\\n return com.format(sep.join([str(x) for x in command_tuple[1]]))\\n elif (\\n len(command_tuple[1]) > brackets_count\\n or len(command_tuple[1]) < brackets_count\\n and brackets_count != 1\\n ):\\n l.error(\\n \\\"Could not build command for input length {}\\\"\\n \\\" and input parameters length {}. Input parameters must be of same length\\\"\\n \\\" as defined in config or 1\\\".format(\\n len(command_tuple[1]), brackets_count\\n )\\n )\\n return None\\n else:\\n l.error(\\n \\\"Could not find command {} in command list of device: {}\\\".format(\\n command_tuple[0], device[\\\"Device_name\\\"]\\n )\\n )\",\n \"def make_command(remit=str(),\\n source=str(),\\n writer=str(),\\n extension=str(),\\n pandoc_options=list()):\\n # if no extension specified, infer it from writer\\n if not extension and writer:\\n if writer in spec.DEFAULT_EXTENSION:\\n extension = spec.DEFAULT_EXTENSION[writer]\\n else:\\n print('WARNING: No known extension for writer \\\"%s\\\", '\\n 'using \\\".UNKNOWN\\\"' % writer)\\n extension = '.UNKNOWN'\\n # start building the command...\\n # remit\\n command = [remit]\\n # input file\\n # - if remit_WRITER.md exists, then use it!\\n writer_specific_source = remit + '_' + writer + '.md'\\n if os.path.exists(writer_specific_source):\\n command += [writer_specific_source]\\n else:\\n command += [remit + '.md']\\n # writer\\n if writer:\\n command += ['-t']\\n command += [writer]\\n # other options\\n command.extend(pandoc_options)\\n # output\\n # - first build output filename...\\n if writer == '':\\n pretty_writer_string = 'default'\\n else:\\n pretty_writer_string = writer\\n target = os.path.join(os.getcwd(), '..', '..', 'output-'+remit,\\n source,\\n pretty_writer_string\\n + ''.join(pandoc_options)\\n + extension)\\n target = os.path.normpath(target)\\n target = os.path.relpath(target)\\n command += ['-o']\\n command += [target]\\n # panzer-specific options\\n if remit == 'panzer':\\n command += ['---quiet']\\n # support directory\\n command += ['---panzer-support']\\n target = os.path.join(os.getcwd(), '..', '..', 'dot-panzer')\\n target = os.path.normpath(target)\\n target = os.path.relpath(target)\\n command += [target]\\n # debug outputs\\n # command += ['---debug']\\n # target = os.path.join(os.getcwd(), '..', '..', 'output-'+remit,\\n # source, 'debug', 'debug_' + source)\\n # target = os.path.normpath(target)\\n # command += [target\\n # + \\\"_\\\"\\n # + pretty_writer_string\\n # + ''.join(pandoc_options)]\\n # done!\\n return command\",\n \"def create_cmd(self, out_log, err_log):\\n instructions_list = []\\n\\n # executable path\\n instructions_list.append(self.reduce_path)\\n\\n if self.flip: instructions_list.append('-FLIP')\\n if self.noflip: instructions_list.append('-NOFLIP')\\n if self.nuclear: instructions_list.append('-NUClear')\\n if self.nooh: instructions_list.append('-NOOH')\\n if self.oh: instructions_list.append('-OH')\\n if self.his: instructions_list.append('-HIS')\\n if self.noheth: instructions_list.append('-NOHETh')\\n if self.rotnh3: instructions_list.append('-ROTNH3')\\n if self.norotnh3: instructions_list.append('-NOROTNH3')\\n if self.rotexist: instructions_list.append('-ROTEXist')\\n if self.rotexoh: instructions_list.append('-ROTEXOH')\\n if self.allalt: instructions_list.append('-ALLALT')\\n if self.onlya: instructions_list.append('-ONLYA')\\n if self.charges: instructions_list.append('-CHARGEs')\\n if self.dorotmet: instructions_list.append('-DOROTMET')\\n if self.noadjust: instructions_list.append('-NOADJust')\\n if self.build: instructions_list.append('-BUILD')\\n\\n instructions_list.append(self.input_path)\\n instructions_list.append('>')\\n instructions_list.append(self.output_path)\\n\\n return instructions_list\",\n \"def createHelp():\\n \\n epilog_string=\\\"Any bug is welcome reported to fanxiaojuan@picb.ac.cn\\\"\\n description_string='The program is going to extend the paired-end reads interval nucleotides'\\n parser = argparse.ArgumentParser(description=description_string,epilog=epilog_string)\\n parser.add_argument('-i', '--input file', dest='fnIn', default='plasmid.rmdup.bed', type=str,help='input file')\\n parser.add_argument('-i_gtf', '--gtf', dest='gtf', default='gencode.v28lift37.annotation.gtf', type=str,help='input gencode gtf annotation file')\\n parser.add_argument('-db', '--db', dest='db', default='gencode_v28lift37_comprehensive.txt', type=str,help='input file')\\n parser.add_argument('-o', '--overhang', dest='o', default=0, type=int,help='input file')\\n parser.add_argument('-o_anno', '--out-annotation', dest='anno', default='plasmid.fragment.rmdup.annotation.bed', type=str,help='output mature mRNA')\\n op=parser.parse_args()\\n return op\",\n \"def _process_command_line():\\n # pylint: disable=C0103\\n global parameters\\n # pylint: enable=C0103\\n\\n # option letters followed by : expect an argument\\n # same for option strings followed by =\\n if parameters[\\\"Command flavour\\\"] in (\\\"posix\\\", \\\"linux\\\"):\\n character_options = \\\"s?\\\"\\n else: # if parameters[\\\"Command flavour\\\"] in (\\\"PNU\\\", \\\"bsd\\\", \\\"bsd:freebsd\\\"):\\n character_options = \\\"qs?\\\"\\n string_options = [\\n \\\"debug\\\",\\n \\\"help\\\",\\n \\\"version\\\",\\n ]\\n\\n try:\\n options, remaining_arguments = getopt.getopt(\\n sys.argv[1:], character_options, string_options\\n )\\n except getopt.GetoptError as error:\\n logging.critical(\\\"Syntax error: %s\\\", error)\\n _display_help()\\n sys.exit(1) # no match\\n\\n for option, _ in options:\\n\\n if option == \\\"--debug\\\":\\n logging.disable(logging.NOTSET)\\n\\n elif option in (\\\"--help\\\", \\\"-?\\\"):\\n _display_help()\\n sys.exit(1) # no match\\n\\n elif option == \\\"-q\\\":\\n parameters[\\\"No formatting\\\"] = True\\n\\n elif option == \\\"-s\\\":\\n parameters[\\\"First match only\\\"] = True\\n\\n elif option == \\\"--version\\\":\\n print(ID.replace(\\\"@(\\\" + \\\"#)\\\" + \\\" $\\\" + \\\"Id\\\" + \\\": \\\", \\\"\\\").replace(\\\" $\\\", \\\"\\\"))\\n sys.exit(1) # no match\\n\\n logging.debug(\\\"_process_command_line(): parameters:\\\")\\n logging.debug(parameters)\\n logging.debug(\\\"_process_command_line(): remaining_arguments:\\\")\\n logging.debug(remaining_arguments)\\n\\n return remaining_arguments\",\n \"def command_as_str(self, argument_filter=None):\\n \\n def apply_extensions(extensions):\\n for extension in extensions:\\n verify_type_or_subclass(extension, Extension)\\n if isclass(extension):\\n extension = extension()\\n extension.apply_to_executor(self.executor)\\n apply_extensions(extension.extensions)\\n\\n apply_extensions(self.extensions)\\n\\n return self.executor.command_as_str(argument_filter)\",\n \"def command_create(self):\\n command = []\\n for macro in self.my_xml.tool_data[self.shell_dict['short_name']]['pre_tmpls']:\\n command.append(self.my_xml.chth_tmpl.substitute(macro=macro))\\n command.extend(self.pre_chth)\\n command.append(Template('@CMD_BEGIN@ $short_name').substitute(self.shell_dict))\\n command.extend(self.tool_chth)\\n for macro in self.my_xml.tool_data[self.shell_dict['short_name']]['post_tmpls']:\\n command.append(self.my_xml.chth_tmpl.substitute(macro=macro))\\n\\n return '\\\\n'.join(command)\",\n \"def format(self, command, *params):\\n\\n\\t\\tif command.upper() not in self.commands:\\n\\t\\t\\traise InvalidCommandError(\\\"Unknown command\\\")\\n\\n\\t\\t# See RFC 2812 2.3 Messages (2nd paragraph)\\n\\t\\tif len(params) > 15:\\n\\t\\t\\traise InvalidParameterCountError(\\n\\t\\t\\t\\t\\\"Too much parameters (only 15 allowed)\\\"\\n\\t\\t\\t)\\n\\n\\t\\tm = \\\"{} {}\\\\r\\\\n\\\".format(command, \\\" \\\".join(str(x) for x in params))\\n\\n\\t\\tif len(m) > 512:\\n\\t\\t\\traise MessageTooLongError(\\\"Message exceeds 512 characters\\\")\\n\\n\\t\\treturn m\",\n \"def FormSSHCommandLine(self, args, extra_ssh_args=None, port_forward=False,\\n connect_timeout=None):\\n if self.local:\\n # We run the command through the shell locally for consistency with\\n # how commands are run through SSH (crbug.com/239161). This work\\n # around will be unnecessary once we implement a persistent SSH\\n # connection to run remote commands (crbug.com/239607).\\n return ['sh', '-c', \\\" \\\".join(args)]\\n\\n full_args = ['ssh', '-o ForwardX11=no', '-o ForwardX11Trusted=no', '-n']\\n if connect_timeout:\\n full_args += ['-o ConnectTimeout=%d' % connect_timeout]\\n else:\\n full_args += [\\n '-o ConnectTimeout=%d' % self._DEFAULT_SSH_CONNECTION_TIMEOUT]\\n # As remote port forwarding might conflict with the control socket\\n # sharing, skip the control socket args if it is for remote port forwarding.\\n if not port_forward:\\n full_args += ['-S', self._ssh_control_file]\\n full_args += self._ssh_args\\n if self._ssh_identity is not None:\\n full_args.extend(['-i', self._ssh_identity])\\n if extra_ssh_args:\\n full_args.extend(extra_ssh_args)\\n full_args.append('root@%s' % self._hostname)\\n full_args.append('-p%d' % self._ssh_port)\\n full_args.extend(args)\\n return full_args\",\n \"def get_hmm_cmd_str(self, algorithm, csv_infname, csv_outfname, parameter_dir):\\n cmd_str = os.getenv('PWD') + '/packages/ham/bcrham'\\n if self.args.slurm:\\n cmd_str = 'srun ' + cmd_str\\n cmd_str += ' --algorithm ' + algorithm\\n cmd_str += ' --chunk-cache '\\n cmd_str += ' --n_best_events ' + str(self.args.n_best_events)\\n cmd_str += ' --debug ' + str(self.args.debug)\\n cmd_str += ' --hmmdir ' + parameter_dir + '/hmms'\\n cmd_str += ' --datadir ' + os.getcwd() + '/' + self.args.datadir\\n cmd_str += ' --infile ' + csv_infname\\n cmd_str += ' --outfile ' + csv_outfname\\n cmd_str += ' --max-logprob-drop ' + str(self.args.max_logprob_drop)\\n\\n if self.args.auto_hamming_fraction_bounds:\\n bound = self.get_naive_hamming_auto_bounds(parameter_dir)\\n print ' auto naive hamming bound %f' % bound\\n self.args.hamming_fraction_bounds = [bound, bound]\\n\\n cmd_str += ' --hamming-fraction-bound-lo ' + str(self.args.hamming_fraction_bounds[0])\\n cmd_str += ' --hamming-fraction-bound-hi ' + str(self.args.hamming_fraction_bounds[1])\\n if self.args.smc_particles > 1:\\n os.environ['GSL_RNG_TYPE'] = 'ranlux'\\n os.environ['GSL_RNG_SEED'] = str(random.randint(0, 99999))\\n cmd_str += ' --smc-particles ' + str(self.args.smc_particles)\\n if self.args.rescale_emissions:\\n cmd_str += ' --rescale-emissions'\\n if self.args.action == 'partition':\\n cmd_str += ' --partition'\\n cmd_str += ' --cachefile ' + self.hmm_cachefname\\n if self.args.truncate_n_sets:\\n cmd_str += ' --truncate-seqs'\\n if not self.args.dont_allow_unphysical_insertions:\\n cmd_str += ' --unphysical-insertions'\\n assert len(utils.ambiguous_bases) == 1 # could allow more than one, but it's not implemented a.t.m.\\n cmd_str += ' --ambig-base ' + utils.ambiguous_bases[0]\\n\\n return cmd_str\",\n \"def _build_menu_command(self, cmd):\\n if COMMAND_CHAR[cmd]:\\n return COMMAND_CHAR[cmd]+self._newline\\n else:\\n raise InstrumentProtocolException(\\\"Unknown command character for %s\\\" % cmd)\",\n \"def StringifyCommand(cmd):\\n ret = ''\\n grouping = 0\\n for a in cmd:\\n if grouping == 0 and len(ret) > 0:\\n ret += \\\" \\\\\\\\\\\\n \\\"\\n elif grouping > 0:\\n ret += \\\" \\\"\\n if grouping == 0:\\n grouping = 1\\n if a.startswith('-') and len(a) == 2:\\n grouping = 2\\n ret += a\\n grouping -= 1\\n return ret\",\n \"def help(self):\\n help = ''\\n cmds = [(x, y) for x, y in Commands.__dict__.iteritems()]\\n cmds.sort(key=lambda x: x[0])\\n for name, member in cmds:\\n if name.startswith('cmd_') and callable(member):\\n help += ' %s\\\\n' % ' '.join([name[4:]] +\\n ['<%s>' % x for x in\\n inspect.getargspec(member).args[1:]])\\n if member.__doc__:\\n help += ' %s\\\\n' % member.__doc__.splitlines()[0]\\n return 'Available commands:\\\\n%s' % help\",\n \"def _build_command_list(self, arguments=None, debug=False):\\n \\n if debug:\\n command_name = arguments[\\\"script_name\\\"]\\n else:\\n command_name = os.path.splitext(arguments[\\\"script_name\\\"])[0]\\n \\n command_list = [command_name]\\n #del arguments[\\\"script_name\\\"]\\n #del arguments[\\\"optional_arguments\\\"]\\n\\n for k in arguments:\\n if k == \\\"script_name\\\": continue\\n if type(arguments[k]) == type(list()):\\n for n in arguments[k]:\\n command_list.append(\\\"--{0}\\\".format(k))\\n command_list.append(\\\"{0}\\\".format(n))\\n else: \\n command_list.append(\\\"--{0}\\\".format(k))\\n command_list.append(\\\"{0}\\\".format(arguments[k]))\\n \\n return command_list\",\n \"def format_command(cls, address: int = 102) -> str:\\n if address not in cls.addresses:\\n raise ArgumentError(f\\\"address {address} not in range 1-127\\\")\\n return f\\\"{cls.name},{address}\\\"\",\n \"def build(self, origin, token, args):\\r\\n # If the last argument is \\\"long\\\", package it for sending\\r\\n if len(args) > 0:\\r\\n if args[-1].find(\\\" \\\") > -1:\\r\\n build_last_arg = \\\":\\\" + args[-1]\\r\\n build_args = args[0:-1] + build_last_arg.split(\\\" \\\")\\r\\n else:\\r\\n build_args = args\\r\\n else:\\r\\n build_args = []\\r\\n # Build the line\\r\\n # Future compatibility - only send \\\\n\\r\\n ret = create_numeric(origin) + \\\" \\\" + token + \\\" \\\" \\\\\\r\\n + \\\" \\\".join(build_args) + \\\"\\\\n\\\"\\r\\n \\r\\n # Check we're not sending things which are protocol violations\\r\\n if len(ret) > 512:\\r\\n raise ProtocolError('Line too long to send')\\r\\n if not token.isupper() and not token.isdigit():\\r\\n raise ProtocolError('Command not in uppercase during build')\\r\\n \\r\\n return ret\",\n \"def buildCommand(self, player, game, json):\",\n \"def HelpCommand(self, unused_args, unused_sub_opts=None, unused_headers=None,\\n unused_debug=None):\\n self.OutputUsageAndExit()\",\n \"def cmd_help(self, commands=None, usage=False):\\n if commands:\\n usage = True\\n commands = {self.approx.decmd(c.lower()) for c in commands}\\n rejects = commands - self.approx.keys()\\n for reject in rejects:\\n self.put_pretty(\\\"No command named %r\\\" % reject)\\n continue\\n commands -= rejects\\n if self.debug:\\n assert not any(self.approx.encmd(r) in self.mod_commands for\\n r in rejects)\\n assert all(self.approx.encmd(c) in self.mod_commands for\\n c in commands)\\n if not commands:\\n return\\n requested = zip(commands, (self.approx[c] for c in commands))\\n else:\\n requested = self.approx.items()\\n help = znc.CTable()\\n help.AddColumn(\\\"Command\\\")\\n help.AddColumn(\\\"Usage\\\" if usage else \\\"Description\\\")\\n from itertools import zip_longest\\n #\\n for command, parser in requested:\\n if usage:\\n upre = \\\"usage: %s\\\" % command\\n rest = (parser.format_usage()\\n .replace(upre, \\\"\\\", 1)\\n .replace(\\\"[-h] \\\", \\\"\\\", 1))\\n desc = [l.strip() for l in rest.split(\\\"\\\\n\\\") if l.strip()]\\n else:\\n desc = [parser.description]\\n for line, comm in zip_longest(desc, (command,), fillvalue=\\\"\\\"):\\n help.AddRow()\\n help.SetCell(\\\"Command\\\", comm)\\n help.SetCell(\\\"Usage\\\" if usage else \\\"Description\\\", line)\\n #\\n s_line = znc.String()\\n strung = []\\n while help.GetLine(len(strung), s_line):\\n strung.append(s_line.s)\\n also = \\\" (<command> [-h] for details)\\\"\\n strung[1] = strung[1].replace(len(also) * \\\" \\\", also, 1)\\n self.put_pretty(\\\"\\\\n\\\".join(strung))\",\n \"def help_enhancer(_h):\\n return ''.join(reversed(_h))\",\n \"def get_help(self):\\n helpstr = \\\"\\\"\\n helpstr += self.get_usage()\\n helpstr += \\\"\\\\n\\\"\\n helpstr += textwrap.fill(self.expand_prog_name(\\\"Type '%prog help <subcommand>' for help on a specific subcommand.\\\"), 78)\\n helpstr += \\\"\\\\n\\\"\\n helpstr += textwrap.fill(self.expand_prog_name(\\\"Type '%prog --version' to see the program version.\\\"), 78)\\n helpstr += \\\"\\\\n\\\"\\n helpstr += textwrap.fill(self.expand_prog_name(\\\"Type '%prog --verbose-load' to see the packages and plug-ins detected, and if plug-ins are successfully loaded.\\\"), 78)\\n helpstr += \\\"\\\\n\\\\n\\\"\\n\\n helpstr += textwrap.fill(\\\"Subcommands consist of built-in subcommands and subcommands provided by installed plug-ins.\\\", 78)\\n helpstr += \\\"\\\\n\\\\n\\\"\\n\\n helpstr += \\\"Available subcommands:\\\\n\\\"\\n helpstr += self.sbtools.get_subcommands()\\n\\n return helpstr\",\n \"def parseCMDParam():\\n\\n progName = sys.argv[0]\\n\\n progName = extractFileName(progName)\\n\\n format = \\\"python \\\" + progName + \\\" [-h] -b binary_path -p hardware_platform -k private_key_path -x bootloader_hex_file_path\\\"\\n\\n example1 = \\\"\\\\t get help: \\\\n\\\" + \\\"\\\\t\\\\tpython \\\" + progName + \\\" -h\\\"\\n\\n example2 = \\\"\\\\t use inputImage.bin, MCHP-Curiosity-PIC32MZEF, private_key.pem , aws_bootloader.X.production.hex as parameter : \\\\n\\\" \\\\\\n + \\\"\\\\t\\\\tpython \\\" + progName + \\\" -b inputImage.bin -p MCHP-Curiosity-PIC32MZEF -k private_key.pem -x aws_bootloader.X.production.hex\\\"\\n\\n usageMsg = format + \\\"\\\\n\\\\n\\\" + \\\"example usages:\\\" + \\\"\\\\n\\\" + example1 + \\\"\\\\n\\\" + example2\\n\\n parser = argparse.ArgumentParser(usage=usageMsg)\\n\\n parser.add_argument('-b', required=True, help=\\\" path of input binary image \\\")\\n parser.add_argument('-p', required=True, help=\\\" hardware platform name \\\")\\n parser.add_argument('-k', required=True, help=\\\" path of the private key used to sign the image \\\")\\n parser.add_argument('-x', required=True, help=\\\" path of the bootloader hex file \\\")\\n\\n args = vars(parser.parse_args())\\n\\n inputImagePath = args[\\\"b\\\"]\\n\\n hardwarePlatform = args[\\\"p\\\"]\\n\\n privateKeyPath = args[\\\"k\\\"]\\n\\n bootloaderHexPath = args[\\\"x\\\"]\\n\\n return inputImagePath, hardwarePlatform, privateKeyPath, bootloaderHexPath\",\n \"def get_command(self, version=2):\\n if self.username:\\n # Not supported on SunOS\\n # \\\"-o ConnectTimeout={}\\n command = \\\"ssh \\\" \\\\\\n \\\"-o UserKnownHostsFile=/dev/null \\\" \\\\\\n \\\"-o StrictHostKeyChecking=no \\\" \\\\\\n \\\"-{} \\\" \\\\\\n \\\"-p {} {}@{}\\\".format(version, self.port, self.username, self.hostname)\\n else:\\n command = \\\"ssh \\\" \\\\\\n \\\"-o UserKnownHostsFile=/dev/null \\\" \\\\\\n \\\"-o StrictHostKeyChecking=no \\\" \\\\\\n \\\"-{} \\\" \\\\\\n \\\"-p {} {}\\\".format(version, self.port, self.hostname)\\n return command\",\n \"def args_str(self):\",\n \"def gen_cmake_command(options, arguments):\\n command = []\\n command.append('CXX=%s' % arguments['--cxx'])\\n command.append('cmake')\\n command.append('-DEXTRA_CXXFLAGS=\\\"%s\\\"' % arguments['--extra-cxx-flags'])\\n command.append('-DENABLE_CODE_COVERAGE=%s' % arguments['--coverage'])\\n command.append('-DENABLE_OPENMP=%s' % arguments['--omp'])\\n command.append('-DENABLE_BLAS=%s' % arguments['--blas'])\\n command.append('-DENABLE_LAPACK=%s' % arguments['--lapack'])\\n command.append('-DMKL_FLAG=%s' % arguments['--mkl'])\\n command.append('-DMATH_LIB_SEARCH_ORDER=\\\"MKL;ESSL;ATLAS;ACML;SYSTEM_NATIVE\\\"')\\n command.append('-DBLAS_LANG=Fortran')\\n command.append('-DLAPACK_LANG=Fortran')\\n command.append('-DGOOGLETEST_ROOT=external/googletest')\\n command.append('-DCMAKE_BUILD_TYPE=%s' % arguments['--type'])\\n command.append('-G \\\"%s\\\"' % arguments['--generator'])\\n\\n return ' '.join(command)\",\n \"def generateArgsList(self, I1, I2, O1, O2, O3, N, M, S, C ):\\n ArgsList = [ \\n \\\"-n\\\", str(N), \\n # \\\"-m\\\", str(M), \\n # \\\"-s\\\", str(S), \\n \\\"-c\\\", str(C), \\n ]\\n if I1 > 0 or I2 > 0:\\n if I1 > 0:\\n ArgsList.append(\\\"-i1\\\")\\n ArgsList.append(str(I1)) \\n if I2 > 0:\\n ArgsList.append(\\\"-i2\\\")\\n ArgsList.append(str(I2))\\n else: \\n ArgsList.append(\\\"--noinput\\\")\\n \\n if O1 > 0 or O2 > 0 or O3 > 0:\\n if O1 > 0:\\n ArgsList.append(\\\"-o1\\\")\\n ArgsList.append(str(O1)) \\n if O2 > 0:\\n ArgsList.append(\\\"-o2\\\")\\n ArgsList.append(str(O2))\\n if O3 > 0:\\n ArgsList.append(\\\"-o3\\\")\\n ArgsList.append(str(O3))\\n else: \\n ArgsList.append(\\\"--nooutput\\\")\\n \\n ArgsList.append(\\\"--nosummary\\\")\\n ArgsList.append(\\\"--verbose\\\")\\n return ArgsList\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6516497","0.64271504","0.6422479","0.63904124","0.6238994","0.6229805","0.62154454","0.6114734","0.6070556","0.5986263","0.59837586","0.5973345","0.59382427","0.5915507","0.5883363","0.5877054","0.58658147","0.58613133","0.58564746","0.585302","0.58369714","0.5796753","0.577163","0.57699174","0.57617456","0.57166255","0.56980675","0.56980383","0.5696898","0.56919104","0.5653084","0.5645336","0.56231165","0.56090295","0.5596402","0.55803394","0.5575896","0.55495155","0.55348057","0.5507895","0.550597","0.549803","0.54978114","0.54725254","0.54674363","0.54525274","0.54434","0.54304725","0.5410228","0.5398383","0.53624535","0.5358057","0.53373957","0.53187734","0.53127337","0.5292451","0.5291891","0.5291857","0.5285972","0.5279165","0.52724355","0.52708995","0.52463675","0.52395326","0.5239051","0.52362645","0.52345866","0.52207726","0.52202445","0.5216818","0.5203874","0.51993865","0.51990694","0.5197136","0.51931775","0.5187687","0.5186869","0.5183968","0.51683813","0.5156397","0.51562023","0.51554596","0.5129998","0.512504","0.512291","0.5119517","0.5114739","0.5114408","0.5113223","0.5107105","0.50981724","0.50954586","0.509158","0.5082759","0.50818694","0.5075743","0.5073006","0.5058336","0.505541","0.5055088"],"string":"[\n \"0.6516497\",\n \"0.64271504\",\n \"0.6422479\",\n \"0.63904124\",\n \"0.6238994\",\n \"0.6229805\",\n \"0.62154454\",\n \"0.6114734\",\n \"0.6070556\",\n \"0.5986263\",\n \"0.59837586\",\n \"0.5973345\",\n \"0.59382427\",\n \"0.5915507\",\n \"0.5883363\",\n \"0.5877054\",\n \"0.58658147\",\n \"0.58613133\",\n \"0.58564746\",\n \"0.585302\",\n \"0.58369714\",\n \"0.5796753\",\n \"0.577163\",\n \"0.57699174\",\n \"0.57617456\",\n \"0.57166255\",\n \"0.56980675\",\n \"0.56980383\",\n \"0.5696898\",\n \"0.56919104\",\n \"0.5653084\",\n \"0.5645336\",\n \"0.56231165\",\n \"0.56090295\",\n \"0.5596402\",\n \"0.55803394\",\n \"0.5575896\",\n \"0.55495155\",\n \"0.55348057\",\n \"0.5507895\",\n \"0.550597\",\n \"0.549803\",\n \"0.54978114\",\n \"0.54725254\",\n \"0.54674363\",\n \"0.54525274\",\n \"0.54434\",\n \"0.54304725\",\n \"0.5410228\",\n \"0.5398383\",\n \"0.53624535\",\n \"0.5358057\",\n \"0.53373957\",\n \"0.53187734\",\n \"0.53127337\",\n \"0.5292451\",\n \"0.5291891\",\n \"0.5291857\",\n \"0.5285972\",\n \"0.5279165\",\n \"0.52724355\",\n \"0.52708995\",\n \"0.52463675\",\n \"0.52395326\",\n \"0.5239051\",\n \"0.52362645\",\n \"0.52345866\",\n \"0.52207726\",\n \"0.52202445\",\n \"0.5216818\",\n \"0.5203874\",\n \"0.51993865\",\n \"0.51990694\",\n \"0.5197136\",\n \"0.51931775\",\n \"0.5187687\",\n \"0.5186869\",\n \"0.5183968\",\n \"0.51683813\",\n \"0.5156397\",\n \"0.51562023\",\n \"0.51554596\",\n \"0.5129998\",\n \"0.512504\",\n \"0.512291\",\n \"0.5119517\",\n \"0.5114739\",\n \"0.5114408\",\n \"0.5113223\",\n \"0.5107105\",\n \"0.50981724\",\n \"0.50954586\",\n \"0.509158\",\n \"0.5082759\",\n \"0.50818694\",\n \"0.5075743\",\n \"0.5073006\",\n \"0.5058336\",\n \"0.505541\",\n \"0.5055088\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7719122"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21959,"cells":{"query":{"kind":"string","value":"Put your parsing code here."},"document":{"kind":"string","value":"def on_new_line(self, line, is_full_line):\n try:\n if is_full_line:\n self._parse_v_option(line)\n self._parse_general_info(line)\n self._parse_header(line)\n except ParsingDone:\n pass # line has been fully parsed by one of above parse-methods\n return super(W, self).on_new_line(line, is_full_line)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _parse(self):\n pass","def parse(self):","def parse(self):\n pass","def parse(self):\n pass","def parse(self):\n pass","def parse(self):\n pass","def parse(self) -> None:\n pass","def run(self, parsed):","def parse(self, input):\n pass","def after_parsing(self):","def parse(self, content):\n pass","def _parse(self, infile):\n raise NotImplementedError()","def parse(self): \n pass","def parse(self):\n raise NotImplementedError","def parse(self, infile):\r\n raise NotImplementedError()","def parse(self):\n raise NotImplementedError(\"Parse not specified!\")","def parse(self, args):\n pass","def parse(self, response):","def parse(self, data):\n raise NotImplementedError","def parse(cls, data):\n raise NotImplementedError","def parse_data(self):\n\t\traise NotImplementedError('%s: No parse function implemented!' % self.name)","def test_simple_parse(self):\n pass","def main():\n parse_file(sys.argv[1])","def _parse(self):\n tree = etree.parse(self.filename)\n root_node = tree.getroot()\n\n text_node = root_node.find(\"TEXT\")\n\n # Get text\n self.text = self._extract_text(text_node)\n\n # Get and create Event objects\n self.events = self._get_and_create_event_objects(text_node, root_node)\n\n # Get and create Timex objects\n self.timex = self._get_and_create_timex_objects(text_node, root_node)\n\n # Create Relation objects and link them\n self.relations = self._get_and_create_relation_objects(root_node)\n\n # Build text structure. Must be called last.\n self.text_structure = self._get_and_build_text_structure()","def _parse(self, args):\n parser = self._create_parser()\n return parser.parse(args)","def finish_parse(self) -> None:\n pass","def __parse(self):\n\t\tparser=xml.sax.make_parser()\n\t\tparser.setContentHandler(OSMXMLFileParser(self))\n\t\tparser.parse(self.filename)\n\t\n\t\t# convert them back to lists\n\t\tself.nodes = self.nodes.values()\n\t\tself.ways = self.ways.values()\n\t\tself.relations = self.relations.values()","def parse(data):\n parser=Parser(data, True)\n return parser.parse()","def setup_parser(self, parser):","def parse(self, url):\n pass","def parse_items(self):","def parse_from_tree(self, parse):\n pass","def parse(self, fstring):\n pass","def parse(cls, s):\n raise NotImplementedError","def parse_response(self):\n pass","def on_parse(\n self,\n ) -> AsyncIteratorOrIterator[None]: # pragma: no cover # pyright: ignore\n yield None","def parse(self):\n logger=self.logger\n tokenizer=Tokenizer()\n self.scope=produtil.testing.parsetree.Scope()\n self.override(self.scope)\n self.parser=Parser(self.run_mode,logger,self.verbose)\n self.parser.requested_platform_name=self.platform_name\n morevars=self.make_vars()\n with open(self.inloc,'rt') as fileobj:\n self.parse_result=self.parser.parse(\n TokenizeFile(tokenizer,fileobj,self.inloc,1),self.scope,\n unique_id=self.unique_id,morevars=morevars)","def _parse(self):\n try:\n # parse token stream into abstract syntax tree (AST)\n self._ast = self._rule_container()\n\n except ParseError:\n raise\n\n except Exception as exc:\n raise ParseError(u'Unexpected error: {0}'.format(unicode(exc)))","def parse_data(fp):\n pass","def parse(self, response: BeautifulSoup):\n raise NotImplementedError","def test_parse(self): \n\n results = self.parser.parse()\n self.assertEqual(results, test_case_data['parse_output'])","def parse(token):\n\n pass","def Parse(self, ctx:Context, resp:Response)->Generator[Any,None,None]:\n yield Error(msg=\"Parse function not implemented\", code=Unimplemented)","def run_parsing(self):\n\n if self.version:\n print(f'\"{VERSION}\"')\n return VERSION\n elif self.limit is not None and self.limit <= 0:\n print(\"Limit must be greater than 0!\")\n return \"Limit must be greater than 0!\"\n elif self.date:\n if len(str(self.date)) != 8:\n print(\"Wrong date format!\")\n else:\n self.print_if_verbose(\n f\"Method 'run_parsing' is working: \\n\"\n f\"'run_parsing' method calls 'get_content_from_cache' method: \\n\")\n self.rss_feed = self.get_content_from_cache()\n if self.rss_feed:\n if self.json:\n self.print_if_verbose(f\"'run_parsing' method calls 'print_json_content' method: \\n\")\n self.print_json_content(self.rss_feed)\n else:\n self.print_if_verbose(f\"'run_parsing' method calls 'print_content_from_cache' method: \\n\")\n self.print_content_from_cache(self.rss_feed)\n\n if self.to_html_path:\n self.print_if_verbose(f\"'run_parsing' method calls 'save_to_html' method: \\n\")\n self.save_to_html(self.rss_feed)\n\n if self.to_fb2_path:\n self.print_if_verbose(f\"'run_parsing' method calls 'save_to_fb2' method: \\n\")\n self.save_to_fb2(self.rss_feed)\n\n else:\n self.print_if_verbose(\n f\"Method 'run_parsing' is working: \\n\"\n f\"'run_parsing' method calls 'get_content' method: \\n\")\n self.content = self.get_content()\n\n if self.content:\n self.print_if_verbose(f\"'run_parsing' method calls 'process_content' method: \\n\")\n self.rss_feed = self.process_content(self.content)\n\n self.print_if_verbose(f\"'run_parsing' method calls 'save_news_to_cache' method: \\n\")\n self.save_news_to_cache(self.rss_feed)\n\n if self.json:\n self.print_if_verbose(f\"'run_parsing' method calls 'print_json_content' method: \\n\")\n self.print_json_content(self.rss_feed)\n else:\n self.print_if_verbose(f\"'run_parsing' method calls 'print_content' method: \\n\")\n self.print_content(self.rss_feed)\n\n if self.to_html_path:\n self.print_if_verbose(f\"'run_parsing' method calls 'save_to_html' method: \\n\")\n self.save_to_html(self.rss_feed)\n\n if self.to_fb2_path:\n self.print_if_verbose(f\"'run_parsing' method calls 'save_to_fb2' method: \\n\")\n self.save_to_fb2(self.rss_feed)\n\n self.print_if_verbose(f\"Program execution completed!\")\n\n return \"Program execution completed!\"","def parse(self) -> None:\n self._parse_zone_files()\n self._process_rules()\n self._process_zones()\n self._process_links()","def parse(self):\n for section in self.sections:\n section.parse()","def test_parsing_action(self):\n self.grammar.parse(open(TEST_ASSETS + '/test_item.txt').read())","def parse(self, message: Message):\n\t\tpass","def parse(self, tokenizer):\n pass","def parse(self):\n if not self.header_parsed:\n self.parse_header()","def interpret(self):\n tree = self.parser.parse()\n if tree is None:\n return ''\n self.visit(tree)","def parse(cls, line):\r\n raise NotImplementedError","def setup_parser(self) -> Dict[str, Any]:\n\n\n # % GALAT - SPP Single Point Positioning\n # % -------------------------------------\n # % Processing Option\n # % ------------------\n # % GNSS system(s) : GALILEO\n # % Orbit type : Broadcast - INAV\n # % Solution type : SPP\n # % Frequency : E1\n # % Elevation mask : 5.0 deg\n # % Time interval : 30.0 s\n # % Ionosphere opt : NeQuick-G\n # % Troposhere opt : GMF with GPT\n # % Obs start : 2020/01/04 00:00:00.0 GPST (week 2086 518400.0s)\n # % Obs end : 2020/01/04 23:59:30.0 GPST (week 2086 604770.0s)\n # % Epoch expected : 2880\n # % Epoch have : 2880\n # %\n # % Input file(s) : KOUG00GUF_R_20200040000_01D_30S_MO.rnx\n # % Input file(s) : CNES0030.20L\n # % Input file(s) : CNES0040.20L\n # % Input file(s) : igs14.atx\n # %\n # % RINEX header info\n # % ------------------\n # % Marker : KOUG 97301M402\n # % Receiver T/V/# : SEPT POLARX5TR 5.3.0 17323022503\n # % Antenna T/ /# : LEIAR25.R3 LEIT 10180007\n # % Position XYZ : 3855263.3407 -5049731.9986 563040.4252\n # % Antenna H/E/N : 0.0000 0.0000 0.0000\n self._parse_header()\n\n # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+--\n # 2020/01/04 00:00:00 5.098466365 -52.639742999 106.8901 -0.603 -0.821 -0.349 1.018 0.349 \n # 2020/01/04 00:00:30 5.098466094 -52.639742684 107.4962 -0.633 -0.856 0.257 1.065 0.257 \n # 2020/01/04 00:01:00 5.098466030 -52.639740961 107.6125 -0.640 -1.047 0.373 1.228 0.373 \n return dict(\n names=(\n \"yyyymmdd\", \n \"hhmmss\", \n \"latitude\", \n \"longitude\", \n \"height\", \n \"dlatitude\", \n \"dlongitude\", \n \"dheight\",\n \"hpe\",\n \"vpe\",\n \"site_vel_3d\",\n \"pdop\",\n \"num_satellite_available\",\n \"num_satellite_used\",\n ),\n comments=\"%\",\n delimiter=(10, 9, 15, 15, 10, 9, 9, 9, 9, 9, 9, 6, 4, 4),\n dtype=(\"U10\", \"U9\", \"f8\", \"f8\", \"f8\", \"f8\", \"f8\", \"f8\", \"f8\", \"f8\", \"f8\", \"f8\", \"f8\", \"f8\"),\n autostrip=True,\n )","def parse(self):\n\t\tself.maincfg_values = self._load_static_file(self.cfg_file)\n\t\t\n\t\tself.cfg_files = self.get_cfg_files()\n\t\t\n\t\tself.resource_values = self.get_resources()\n\t\t\n\t\tself.timestamps = self.get_timestamps()\n\t\t\n\t\t## This loads everything into\n\t\tfor cfg_file in self.cfg_files:\n\t\t\tself._load_file(cfg_file)\n\n\t\tself._post_parse()","def parse_and_alert(self):\n self.parse_feed()\n self.alert_new_posts()","def parse_string(self, data):\n pass","async def parse(self, raw: str) -> dict:","def __init__(self, parser=None):","def _scrape(self):","def postparse(self, parse_result):\n return parse_result","def parse(self, data: Any) -> Any:\n if self._parse:\n return self._parse(data)\n else:\n return data","def parseSearchHtml(self):\n pass","def parseSearchHtml(self):\n pass","def parse_contents(self):\n self.parsed_contents = tokenize(self.contents)[0]","def parse(self):\n\t\tsub = self.body.split(' ')\n\t\tif len(sub) == 3:\n\t\t\tself.latitude = float(sub[1])\n\t\t\tself.longitude = float(sub[2])\n\t\telse:\n\t\t\tself.latitude = None\n\t\t\tself.longitude = None\n\t\t\traise Exception(\"Invalid message\")","def parser(self):\n\t\tdom = ET.parse(self.input_filename)\n\t\tself.doc = dom.getroot()","def task_parse_results():\n pass","def parse(self, fp):\n\n # create the plex scanner for fp\n self.create_scanner(fp)\n\n # call parsing logic\n self.stmt_list()\n print('Parsing successful!')","def parse_data(self):\n\n msg = self.xml['dom'].childNodes[0]\n self.data = xml_to_dicts(msg, False)\n\n # Get some metadata together\n self.id = \"%s:%s\" % (self.data['src']['name']['#cdata'], self.data['src']['id']['#cdata'])\n self.temp = self.data['tmpr']['#cdata']\n self.watts = self.data['ch1']['watts']['#cdata']\n\n # Time - CurrentCost and local\n self.date = {}\n self.date['cc'] = [ int(self.data['date'][k]['#cdata']) for k in ('dsb','hr','min','sec') ]\n self.date['now'] = localtime()","def __init__(self, parser: Any = None):","def __init__(self, data):\n self.data = self.get_api_reference_html(data)\n self.parsed_data = []","def _main(hgt_results_fp,\n method):\n\n with open(hgt_results_fp, 'U') as input_f:\n\t if method == 'ranger-dtl':\n\t parse_rangerdtl(input_f=input_f)\n\t elif method == 'trex':\n\t parse_trex(input_f=input_f)\n\t elif method == 'riata-hgt':\n\t parse_riatahgt(input_f=input_f)\n\t elif method == 'jane4':\n\t parse_jane4(input_f=input_f)\n\t elif method == 'consel':\n\t parse_consel(input_f=input_f)","def main():\n\t\n\tfilename = optParse()\n\t\n\ttry:\n\t\tinput = loadFile(filename)\n\texcept IOError, (errno, msg):\n\t\tprint >>sys.stderr, msg\n\t\tsys.exit(-1)\n\t\n\toutput = parse(input)\n\tprint output","def __init__(self):\n Parser.__init__(self)\n self.__line_number = 0 # initialize the line number to 0","def _parse_input(self):\n #temperature\n regex = re.compile(\"TEMP=(\\d+\\.\\d*|\\d+)\")\n r = regex.search(self.file_dic['input'])\n if r:\n self.temperature = r.groups()[0]\n else:\n self.temperature = 298.15\n #theory\n regex = re.compile('(\\$contrl.+\\$end|\\$basis.+ \\$end)')\n temp_theory = regex.findall(self.file_dic['input'])\n contrl = temp_theory[0][:-4][7:].strip()\n basis = temp_theory[1][:-4][6:].strip()\n self.theory = contrl + ' ' + basis","def load_parsed(self):\n with open(self.fname) as f:\n self.parsed = BeautifulSoup(f.read(), features=\"html.parser\")","def parse(self, data):\n self.links = []\n self.images = []\n self.current_tags = []\n self.reset()\n self.feed(data)","def __parse(self):\n # raw/objects: detect name, type, use major tag for type as parent node\n # raw/graphics: as object raw, but add TILE_PAGE\n # init: usually flat file, except\n # embark_profiles.txt: [PROFILE] is parent\n # interface.txt: [BIND] is parent (legacy will be flat)\n # world_gen.txt: [WORLD_GEN] is parent\n # Non-raw files (unsupported): init/arena.txt, subdirs of raw/objects\n parse_raw(self, self.read(self.filename))","def preparse(self, raw):\n return raw","def _parser(self, request, *args, **kwargs):\n\n self.request = request\n\n # parse header\n self.header = {k[5:]: v for k, v in request.META.items() if k.startswith('HTTP_')}\n self.header['CONTENT_TYPE'] = request.META.get('CONTENT_TYPE')\n\n # parse boby\n if request.method not in ['GET', 'HEAD']:\n\n # TODO: serve other body format\n if 'multipart/form-data' in self.header['CONTENT_TYPE']:\n self.body = request.POST.dict()\n\n else:\n # default: application/json\n if self.request.body:\n try:\n self.body = json.loads(self.request.body)\n except Exception as e:\n raise Exception('parse json body error')\n \n # parse query\n self.query = request.GET.dict()\n\n # parse cookie\n self.cookie = {k: v for k, v in request.COOKIES.items()}","def __parser__(self):\n return self","def setup_parse(self, inputstring: str, document: nodes.document) -> None:\n self.inputstring = inputstring\n self.document = document","def parse(self, text, start=None):\n return self.parser.parse(text, start=start)","def main():\n print('<<< Spotify Parser >>>')\n print('-'*101)\n spotify_api.get_json_file(JSON_TRACK_FILE, TRACK, 'track', CLIENT_ID, CLIENT_SECRET)\n parse_json_track(JSON_TRACK_FILE)\n print('-'*101)\n spotify_api.get_json_file(JSON_ARTIST_FILE, ARTIST, 'artist', CLIENT_ID, CLIENT_SECRET)\n parse_json_artist(JSON_ARTIST_FILE)\n print('-'*101)","def on_class_parse(self, ctx):\n return None","def __parse(self):\n lines = self.data.readlines()\n for i in range(0, len(lines)):\n line = lines[i]\n if line[0] == '#':\n continue\n tokens = line.split(\"\\t\")\n time_str = tokens[self.timecol]\n if time_str.find('start:') != -1:\n time_str = time_str.split()[1] + \" \" + time_str.split()[2]\n self.calls.append((0, 0, 0))\n self.durations.append(0.0)\n elif time_str.find('end:') != -1:\n time_str = time_str.split()[1] + \" \" + time_str.split()[2]\n time = datetime.strptime(time_str, \"%Y-%m-%d %H:%M:%S\")\n self.times.append(time)\n self.calls.append((0, 0, 0))\n self.durations.append(0.0)\n break\n else:\n duration = float(tokens[6])\n fms = int(tokens[2])\n hfms = int(tokens[3])\n svs = int(tokens[4])\n self.calls.append((fms, hfms, svs))\n self.durations.append(duration)\n time = datetime.strptime(time_str, \"%Y-%m-%d %H:%M:%S\")\n self.times.append(time)\n self.length = (self.times[len(self.times) - 1] -\\\n self.times[0]).seconds","def _parse_preset(self, xmldata):\r\n\r\n raise NotImplementedError","def parse(self, word):\n raise NotImplementedError","def parse_data( self ):\n self.parsed_data = dict( self.results )","def _parse(self):\n\n self.specification = {}\n\n while True:\n try:\n line = self._lines.current\n if ':' in line:\n self.specification.update(self._parse_spec())\n elif line.startswith('NODE_COORD_SECTION'):\n next(self._lines)\n self.coords = self._parse_coords()\n elif line.startswith('EDGE_WEIGHT_SECTION'):\n next(self._lines)\n self.weights = self._parse_weights()\n elif line.startswith('DISPLAY_DATA_SECTION'):\n next(self._lines)\n self.display = self._parse_coords()\n else:\n break\n except StopIteration:\n break\n\n del self._lines","def __init__(self):\n print \"You asked for a Parser!\"","def _parse(self):\n\n self.specification = {}\n\n while True:\n try:\n line = self._lines.current\n if ':' in line:\n self.specification.update(self._parse_spec())\n elif line.startswith('TOUR_SECTION'):\n next(self._lines)\n self.tour = self._parse_tour()\n else:\n break\n except StopIteration:\n break\n\n del self._lines\n\n if 'TYPE' in self.specification and \\\n self.specification['TYPE'] != 'TOUR':\n raise TypeError('Unsupported TSPLib file type. Only TOUR type \\\n is supported')","def __init__(self, *args, **kw):\n self.parser = Parser(*args, **kw)","def __init__(self, source):\n self.tree = ET.parse(source)\n self.root = self.tree.getroot()","def create_parser():\n pass","def do_post_parse_xml(self, *args, **kwargs): # real signature unknown\n pass","def parse(self, value):\n raise NotImplementedError(\"Please implement the Class\")","def parse(source):\r\n #remove shared indentation\r\n source = dedent(source)\r\n print source\r\n\r\n structure = structure_parse(source)\r\n\r\n print structure.signature\r\n print structure.annotation\r\n print structure.body\r\n\r\n\r\n signature = signature_parse(structure.signature)\r\n\r\n kernel = kernel_parse(signature.kernel)\r\n inputs = input_parse(signature.input)\r\n\r\n print signature.kernel\r\n print signature.input\r\n print signature.output\r\n\r\n\r\n quit()","def _parse(self):\n with open(self.input) as f:\n for line in f:\n if not line.lstrip().startswith(\"#\"): # comment\n stripped_line=line.split(\"#\")[0].strip()\n \n # Initialise an empty option dictionary with some good defaults\n if \"[\" in stripped_line:\n molname=stripped_line.split()[1]\n self.options[molname]=self.empty_option_dict.copy() # dict1=dict2 does not copy!\n self.options[molname][\"MolName\"]=molname\n if \":\" in stripped_line: \n # now process line by line\n if \"{\" not in stripped_line:\n key,value=[i.strip() for i in stripped_line.split(\":\")]\n\n if key not in self.options[molname].keys():\n raise BaseException(\"Option \\\"{}\\\" not known, please check your input file\".format(key))\n self.options[molname][key]=value \n else:\n # This is to define special lines that are given by a dictionary\n key,value=stripped_line.split(\":\",1) # split on first occurence\n if key==\"Addon\": # additional atoms to be added per molecule\n addondict=self.empty_addon_dict.copy()\n addondict_string = value.split(\"}\",-1)[0].split(\"{\",1)[1]\n for pair in addondict_string.split(\",\"):\n addonkey,addonvalue=[i.strip() for i in pair.split(\":\")]\n if addonkey not in addondict.keys():\n raise BaseException(\"Option \\\"{}\\\" in Addon section of molecule {} not known, please check your input file\".format(addonkey,molname))\n addondict[addonkey]=addonvalue\n value=addondict\n # Since addon keyword can be used many times, this is a list\n self.options[molname][key].append(value) \n self._check()","def _parser(data=\"\"):\r\n\r\n if data == \"\":\r\n pass\r\n \r\n \"\"\"Retrieve timestamp\"\"\"\r\n validate(data[:25])\r\n \"\"\"retrieve log data\"\"\"\r\n log_data = re.findall(r\"[\\w]+\", data)\r\n \"\"\"Retrieve user info\"\"\"\r\n login_info = [log_data[i] for i in (7, 9, 11, 13, 15)]\r\n\r\n \r\n return login_info, log_data","def _runParser(self):\n with open(self.var('filePath')) as f:\n return json.load(f)"],"string":"[\n \"def _parse(self):\\n pass\",\n \"def parse(self):\",\n \"def parse(self):\\n pass\",\n \"def parse(self):\\n pass\",\n \"def parse(self):\\n pass\",\n \"def parse(self):\\n pass\",\n \"def parse(self) -> None:\\n pass\",\n \"def run(self, parsed):\",\n \"def parse(self, input):\\n pass\",\n \"def after_parsing(self):\",\n \"def parse(self, content):\\n pass\",\n \"def _parse(self, infile):\\n raise NotImplementedError()\",\n \"def parse(self): \\n pass\",\n \"def parse(self):\\n raise NotImplementedError\",\n \"def parse(self, infile):\\r\\n raise NotImplementedError()\",\n \"def parse(self):\\n raise NotImplementedError(\\\"Parse not specified!\\\")\",\n \"def parse(self, args):\\n pass\",\n \"def parse(self, response):\",\n \"def parse(self, data):\\n raise NotImplementedError\",\n \"def parse(cls, data):\\n raise NotImplementedError\",\n \"def parse_data(self):\\n\\t\\traise NotImplementedError('%s: No parse function implemented!' % self.name)\",\n \"def test_simple_parse(self):\\n pass\",\n \"def main():\\n parse_file(sys.argv[1])\",\n \"def _parse(self):\\n tree = etree.parse(self.filename)\\n root_node = tree.getroot()\\n\\n text_node = root_node.find(\\\"TEXT\\\")\\n\\n # Get text\\n self.text = self._extract_text(text_node)\\n\\n # Get and create Event objects\\n self.events = self._get_and_create_event_objects(text_node, root_node)\\n\\n # Get and create Timex objects\\n self.timex = self._get_and_create_timex_objects(text_node, root_node)\\n\\n # Create Relation objects and link them\\n self.relations = self._get_and_create_relation_objects(root_node)\\n\\n # Build text structure. Must be called last.\\n self.text_structure = self._get_and_build_text_structure()\",\n \"def _parse(self, args):\\n parser = self._create_parser()\\n return parser.parse(args)\",\n \"def finish_parse(self) -> None:\\n pass\",\n \"def __parse(self):\\n\\t\\tparser=xml.sax.make_parser()\\n\\t\\tparser.setContentHandler(OSMXMLFileParser(self))\\n\\t\\tparser.parse(self.filename)\\n\\t\\n\\t\\t# convert them back to lists\\n\\t\\tself.nodes = self.nodes.values()\\n\\t\\tself.ways = self.ways.values()\\n\\t\\tself.relations = self.relations.values()\",\n \"def parse(data):\\n parser=Parser(data, True)\\n return parser.parse()\",\n \"def setup_parser(self, parser):\",\n \"def parse(self, url):\\n pass\",\n \"def parse_items(self):\",\n \"def parse_from_tree(self, parse):\\n pass\",\n \"def parse(self, fstring):\\n pass\",\n \"def parse(cls, s):\\n raise NotImplementedError\",\n \"def parse_response(self):\\n pass\",\n \"def on_parse(\\n self,\\n ) -> AsyncIteratorOrIterator[None]: # pragma: no cover # pyright: ignore\\n yield None\",\n \"def parse(self):\\n logger=self.logger\\n tokenizer=Tokenizer()\\n self.scope=produtil.testing.parsetree.Scope()\\n self.override(self.scope)\\n self.parser=Parser(self.run_mode,logger,self.verbose)\\n self.parser.requested_platform_name=self.platform_name\\n morevars=self.make_vars()\\n with open(self.inloc,'rt') as fileobj:\\n self.parse_result=self.parser.parse(\\n TokenizeFile(tokenizer,fileobj,self.inloc,1),self.scope,\\n unique_id=self.unique_id,morevars=morevars)\",\n \"def _parse(self):\\n try:\\n # parse token stream into abstract syntax tree (AST)\\n self._ast = self._rule_container()\\n\\n except ParseError:\\n raise\\n\\n except Exception as exc:\\n raise ParseError(u'Unexpected error: {0}'.format(unicode(exc)))\",\n \"def parse_data(fp):\\n pass\",\n \"def parse(self, response: BeautifulSoup):\\n raise NotImplementedError\",\n \"def test_parse(self): \\n\\n results = self.parser.parse()\\n self.assertEqual(results, test_case_data['parse_output'])\",\n \"def parse(token):\\n\\n pass\",\n \"def Parse(self, ctx:Context, resp:Response)->Generator[Any,None,None]:\\n yield Error(msg=\\\"Parse function not implemented\\\", code=Unimplemented)\",\n \"def run_parsing(self):\\n\\n if self.version:\\n print(f'\\\"{VERSION}\\\"')\\n return VERSION\\n elif self.limit is not None and self.limit <= 0:\\n print(\\\"Limit must be greater than 0!\\\")\\n return \\\"Limit must be greater than 0!\\\"\\n elif self.date:\\n if len(str(self.date)) != 8:\\n print(\\\"Wrong date format!\\\")\\n else:\\n self.print_if_verbose(\\n f\\\"Method 'run_parsing' is working: \\\\n\\\"\\n f\\\"'run_parsing' method calls 'get_content_from_cache' method: \\\\n\\\")\\n self.rss_feed = self.get_content_from_cache()\\n if self.rss_feed:\\n if self.json:\\n self.print_if_verbose(f\\\"'run_parsing' method calls 'print_json_content' method: \\\\n\\\")\\n self.print_json_content(self.rss_feed)\\n else:\\n self.print_if_verbose(f\\\"'run_parsing' method calls 'print_content_from_cache' method: \\\\n\\\")\\n self.print_content_from_cache(self.rss_feed)\\n\\n if self.to_html_path:\\n self.print_if_verbose(f\\\"'run_parsing' method calls 'save_to_html' method: \\\\n\\\")\\n self.save_to_html(self.rss_feed)\\n\\n if self.to_fb2_path:\\n self.print_if_verbose(f\\\"'run_parsing' method calls 'save_to_fb2' method: \\\\n\\\")\\n self.save_to_fb2(self.rss_feed)\\n\\n else:\\n self.print_if_verbose(\\n f\\\"Method 'run_parsing' is working: \\\\n\\\"\\n f\\\"'run_parsing' method calls 'get_content' method: \\\\n\\\")\\n self.content = self.get_content()\\n\\n if self.content:\\n self.print_if_verbose(f\\\"'run_parsing' method calls 'process_content' method: \\\\n\\\")\\n self.rss_feed = self.process_content(self.content)\\n\\n self.print_if_verbose(f\\\"'run_parsing' method calls 'save_news_to_cache' method: \\\\n\\\")\\n self.save_news_to_cache(self.rss_feed)\\n\\n if self.json:\\n self.print_if_verbose(f\\\"'run_parsing' method calls 'print_json_content' method: \\\\n\\\")\\n self.print_json_content(self.rss_feed)\\n else:\\n self.print_if_verbose(f\\\"'run_parsing' method calls 'print_content' method: \\\\n\\\")\\n self.print_content(self.rss_feed)\\n\\n if self.to_html_path:\\n self.print_if_verbose(f\\\"'run_parsing' method calls 'save_to_html' method: \\\\n\\\")\\n self.save_to_html(self.rss_feed)\\n\\n if self.to_fb2_path:\\n self.print_if_verbose(f\\\"'run_parsing' method calls 'save_to_fb2' method: \\\\n\\\")\\n self.save_to_fb2(self.rss_feed)\\n\\n self.print_if_verbose(f\\\"Program execution completed!\\\")\\n\\n return \\\"Program execution completed!\\\"\",\n \"def parse(self) -> None:\\n self._parse_zone_files()\\n self._process_rules()\\n self._process_zones()\\n self._process_links()\",\n \"def parse(self):\\n for section in self.sections:\\n section.parse()\",\n \"def test_parsing_action(self):\\n self.grammar.parse(open(TEST_ASSETS + '/test_item.txt').read())\",\n \"def parse(self, message: Message):\\n\\t\\tpass\",\n \"def parse(self, tokenizer):\\n pass\",\n \"def parse(self):\\n if not self.header_parsed:\\n self.parse_header()\",\n \"def interpret(self):\\n tree = self.parser.parse()\\n if tree is None:\\n return ''\\n self.visit(tree)\",\n \"def parse(cls, line):\\r\\n raise NotImplementedError\",\n \"def setup_parser(self) -> Dict[str, Any]:\\n\\n\\n # % GALAT - SPP Single Point Positioning\\n # % -------------------------------------\\n # % Processing Option\\n # % ------------------\\n # % GNSS system(s) : GALILEO\\n # % Orbit type : Broadcast - INAV\\n # % Solution type : SPP\\n # % Frequency : E1\\n # % Elevation mask : 5.0 deg\\n # % Time interval : 30.0 s\\n # % Ionosphere opt : NeQuick-G\\n # % Troposhere opt : GMF with GPT\\n # % Obs start : 2020/01/04 00:00:00.0 GPST (week 2086 518400.0s)\\n # % Obs end : 2020/01/04 23:59:30.0 GPST (week 2086 604770.0s)\\n # % Epoch expected : 2880\\n # % Epoch have : 2880\\n # %\\n # % Input file(s) : KOUG00GUF_R_20200040000_01D_30S_MO.rnx\\n # % Input file(s) : CNES0030.20L\\n # % Input file(s) : CNES0040.20L\\n # % Input file(s) : igs14.atx\\n # %\\n # % RINEX header info\\n # % ------------------\\n # % Marker : KOUG 97301M402\\n # % Receiver T/V/# : SEPT POLARX5TR 5.3.0 17323022503\\n # % Antenna T/ /# : LEIAR25.R3 LEIT 10180007\\n # % Position XYZ : 3855263.3407 -5049731.9986 563040.4252\\n # % Antenna H/E/N : 0.0000 0.0000 0.0000\\n self._parse_header()\\n\\n # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+--\\n # 2020/01/04 00:00:00 5.098466365 -52.639742999 106.8901 -0.603 -0.821 -0.349 1.018 0.349 \\n # 2020/01/04 00:00:30 5.098466094 -52.639742684 107.4962 -0.633 -0.856 0.257 1.065 0.257 \\n # 2020/01/04 00:01:00 5.098466030 -52.639740961 107.6125 -0.640 -1.047 0.373 1.228 0.373 \\n return dict(\\n names=(\\n \\\"yyyymmdd\\\", \\n \\\"hhmmss\\\", \\n \\\"latitude\\\", \\n \\\"longitude\\\", \\n \\\"height\\\", \\n \\\"dlatitude\\\", \\n \\\"dlongitude\\\", \\n \\\"dheight\\\",\\n \\\"hpe\\\",\\n \\\"vpe\\\",\\n \\\"site_vel_3d\\\",\\n \\\"pdop\\\",\\n \\\"num_satellite_available\\\",\\n \\\"num_satellite_used\\\",\\n ),\\n comments=\\\"%\\\",\\n delimiter=(10, 9, 15, 15, 10, 9, 9, 9, 9, 9, 9, 6, 4, 4),\\n dtype=(\\\"U10\\\", \\\"U9\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\"),\\n autostrip=True,\\n )\",\n \"def parse(self):\\n\\t\\tself.maincfg_values = self._load_static_file(self.cfg_file)\\n\\t\\t\\n\\t\\tself.cfg_files = self.get_cfg_files()\\n\\t\\t\\n\\t\\tself.resource_values = self.get_resources()\\n\\t\\t\\n\\t\\tself.timestamps = self.get_timestamps()\\n\\t\\t\\n\\t\\t## This loads everything into\\n\\t\\tfor cfg_file in self.cfg_files:\\n\\t\\t\\tself._load_file(cfg_file)\\n\\n\\t\\tself._post_parse()\",\n \"def parse_and_alert(self):\\n self.parse_feed()\\n self.alert_new_posts()\",\n \"def parse_string(self, data):\\n pass\",\n \"async def parse(self, raw: str) -> dict:\",\n \"def __init__(self, parser=None):\",\n \"def _scrape(self):\",\n \"def postparse(self, parse_result):\\n return parse_result\",\n \"def parse(self, data: Any) -> Any:\\n if self._parse:\\n return self._parse(data)\\n else:\\n return data\",\n \"def parseSearchHtml(self):\\n pass\",\n \"def parseSearchHtml(self):\\n pass\",\n \"def parse_contents(self):\\n self.parsed_contents = tokenize(self.contents)[0]\",\n \"def parse(self):\\n\\t\\tsub = self.body.split(' ')\\n\\t\\tif len(sub) == 3:\\n\\t\\t\\tself.latitude = float(sub[1])\\n\\t\\t\\tself.longitude = float(sub[2])\\n\\t\\telse:\\n\\t\\t\\tself.latitude = None\\n\\t\\t\\tself.longitude = None\\n\\t\\t\\traise Exception(\\\"Invalid message\\\")\",\n \"def parser(self):\\n\\t\\tdom = ET.parse(self.input_filename)\\n\\t\\tself.doc = dom.getroot()\",\n \"def task_parse_results():\\n pass\",\n \"def parse(self, fp):\\n\\n # create the plex scanner for fp\\n self.create_scanner(fp)\\n\\n # call parsing logic\\n self.stmt_list()\\n print('Parsing successful!')\",\n \"def parse_data(self):\\n\\n msg = self.xml['dom'].childNodes[0]\\n self.data = xml_to_dicts(msg, False)\\n\\n # Get some metadata together\\n self.id = \\\"%s:%s\\\" % (self.data['src']['name']['#cdata'], self.data['src']['id']['#cdata'])\\n self.temp = self.data['tmpr']['#cdata']\\n self.watts = self.data['ch1']['watts']['#cdata']\\n\\n # Time - CurrentCost and local\\n self.date = {}\\n self.date['cc'] = [ int(self.data['date'][k]['#cdata']) for k in ('dsb','hr','min','sec') ]\\n self.date['now'] = localtime()\",\n \"def __init__(self, parser: Any = None):\",\n \"def __init__(self, data):\\n self.data = self.get_api_reference_html(data)\\n self.parsed_data = []\",\n \"def _main(hgt_results_fp,\\n method):\\n\\n with open(hgt_results_fp, 'U') as input_f:\\n\\t if method == 'ranger-dtl':\\n\\t parse_rangerdtl(input_f=input_f)\\n\\t elif method == 'trex':\\n\\t parse_trex(input_f=input_f)\\n\\t elif method == 'riata-hgt':\\n\\t parse_riatahgt(input_f=input_f)\\n\\t elif method == 'jane4':\\n\\t parse_jane4(input_f=input_f)\\n\\t elif method == 'consel':\\n\\t parse_consel(input_f=input_f)\",\n \"def main():\\n\\t\\n\\tfilename = optParse()\\n\\t\\n\\ttry:\\n\\t\\tinput = loadFile(filename)\\n\\texcept IOError, (errno, msg):\\n\\t\\tprint >>sys.stderr, msg\\n\\t\\tsys.exit(-1)\\n\\t\\n\\toutput = parse(input)\\n\\tprint output\",\n \"def __init__(self):\\n Parser.__init__(self)\\n self.__line_number = 0 # initialize the line number to 0\",\n \"def _parse_input(self):\\n #temperature\\n regex = re.compile(\\\"TEMP=(\\\\d+\\\\.\\\\d*|\\\\d+)\\\")\\n r = regex.search(self.file_dic['input'])\\n if r:\\n self.temperature = r.groups()[0]\\n else:\\n self.temperature = 298.15\\n #theory\\n regex = re.compile('(\\\\$contrl.+\\\\$end|\\\\$basis.+ \\\\$end)')\\n temp_theory = regex.findall(self.file_dic['input'])\\n contrl = temp_theory[0][:-4][7:].strip()\\n basis = temp_theory[1][:-4][6:].strip()\\n self.theory = contrl + ' ' + basis\",\n \"def load_parsed(self):\\n with open(self.fname) as f:\\n self.parsed = BeautifulSoup(f.read(), features=\\\"html.parser\\\")\",\n \"def parse(self, data):\\n self.links = []\\n self.images = []\\n self.current_tags = []\\n self.reset()\\n self.feed(data)\",\n \"def __parse(self):\\n # raw/objects: detect name, type, use major tag for type as parent node\\n # raw/graphics: as object raw, but add TILE_PAGE\\n # init: usually flat file, except\\n # embark_profiles.txt: [PROFILE] is parent\\n # interface.txt: [BIND] is parent (legacy will be flat)\\n # world_gen.txt: [WORLD_GEN] is parent\\n # Non-raw files (unsupported): init/arena.txt, subdirs of raw/objects\\n parse_raw(self, self.read(self.filename))\",\n \"def preparse(self, raw):\\n return raw\",\n \"def _parser(self, request, *args, **kwargs):\\n\\n self.request = request\\n\\n # parse header\\n self.header = {k[5:]: v for k, v in request.META.items() if k.startswith('HTTP_')}\\n self.header['CONTENT_TYPE'] = request.META.get('CONTENT_TYPE')\\n\\n # parse boby\\n if request.method not in ['GET', 'HEAD']:\\n\\n # TODO: serve other body format\\n if 'multipart/form-data' in self.header['CONTENT_TYPE']:\\n self.body = request.POST.dict()\\n\\n else:\\n # default: application/json\\n if self.request.body:\\n try:\\n self.body = json.loads(self.request.body)\\n except Exception as e:\\n raise Exception('parse json body error')\\n \\n # parse query\\n self.query = request.GET.dict()\\n\\n # parse cookie\\n self.cookie = {k: v for k, v in request.COOKIES.items()}\",\n \"def __parser__(self):\\n return self\",\n \"def setup_parse(self, inputstring: str, document: nodes.document) -> None:\\n self.inputstring = inputstring\\n self.document = document\",\n \"def parse(self, text, start=None):\\n return self.parser.parse(text, start=start)\",\n \"def main():\\n print('<<< Spotify Parser >>>')\\n print('-'*101)\\n spotify_api.get_json_file(JSON_TRACK_FILE, TRACK, 'track', CLIENT_ID, CLIENT_SECRET)\\n parse_json_track(JSON_TRACK_FILE)\\n print('-'*101)\\n spotify_api.get_json_file(JSON_ARTIST_FILE, ARTIST, 'artist', CLIENT_ID, CLIENT_SECRET)\\n parse_json_artist(JSON_ARTIST_FILE)\\n print('-'*101)\",\n \"def on_class_parse(self, ctx):\\n return None\",\n \"def __parse(self):\\n lines = self.data.readlines()\\n for i in range(0, len(lines)):\\n line = lines[i]\\n if line[0] == '#':\\n continue\\n tokens = line.split(\\\"\\\\t\\\")\\n time_str = tokens[self.timecol]\\n if time_str.find('start:') != -1:\\n time_str = time_str.split()[1] + \\\" \\\" + time_str.split()[2]\\n self.calls.append((0, 0, 0))\\n self.durations.append(0.0)\\n elif time_str.find('end:') != -1:\\n time_str = time_str.split()[1] + \\\" \\\" + time_str.split()[2]\\n time = datetime.strptime(time_str, \\\"%Y-%m-%d %H:%M:%S\\\")\\n self.times.append(time)\\n self.calls.append((0, 0, 0))\\n self.durations.append(0.0)\\n break\\n else:\\n duration = float(tokens[6])\\n fms = int(tokens[2])\\n hfms = int(tokens[3])\\n svs = int(tokens[4])\\n self.calls.append((fms, hfms, svs))\\n self.durations.append(duration)\\n time = datetime.strptime(time_str, \\\"%Y-%m-%d %H:%M:%S\\\")\\n self.times.append(time)\\n self.length = (self.times[len(self.times) - 1] -\\\\\\n self.times[0]).seconds\",\n \"def _parse_preset(self, xmldata):\\r\\n\\r\\n raise NotImplementedError\",\n \"def parse(self, word):\\n raise NotImplementedError\",\n \"def parse_data( self ):\\n self.parsed_data = dict( self.results )\",\n \"def _parse(self):\\n\\n self.specification = {}\\n\\n while True:\\n try:\\n line = self._lines.current\\n if ':' in line:\\n self.specification.update(self._parse_spec())\\n elif line.startswith('NODE_COORD_SECTION'):\\n next(self._lines)\\n self.coords = self._parse_coords()\\n elif line.startswith('EDGE_WEIGHT_SECTION'):\\n next(self._lines)\\n self.weights = self._parse_weights()\\n elif line.startswith('DISPLAY_DATA_SECTION'):\\n next(self._lines)\\n self.display = self._parse_coords()\\n else:\\n break\\n except StopIteration:\\n break\\n\\n del self._lines\",\n \"def __init__(self):\\n print \\\"You asked for a Parser!\\\"\",\n \"def _parse(self):\\n\\n self.specification = {}\\n\\n while True:\\n try:\\n line = self._lines.current\\n if ':' in line:\\n self.specification.update(self._parse_spec())\\n elif line.startswith('TOUR_SECTION'):\\n next(self._lines)\\n self.tour = self._parse_tour()\\n else:\\n break\\n except StopIteration:\\n break\\n\\n del self._lines\\n\\n if 'TYPE' in self.specification and \\\\\\n self.specification['TYPE'] != 'TOUR':\\n raise TypeError('Unsupported TSPLib file type. Only TOUR type \\\\\\n is supported')\",\n \"def __init__(self, *args, **kw):\\n self.parser = Parser(*args, **kw)\",\n \"def __init__(self, source):\\n self.tree = ET.parse(source)\\n self.root = self.tree.getroot()\",\n \"def create_parser():\\n pass\",\n \"def do_post_parse_xml(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def parse(self, value):\\n raise NotImplementedError(\\\"Please implement the Class\\\")\",\n \"def parse(source):\\r\\n #remove shared indentation\\r\\n source = dedent(source)\\r\\n print source\\r\\n\\r\\n structure = structure_parse(source)\\r\\n\\r\\n print structure.signature\\r\\n print structure.annotation\\r\\n print structure.body\\r\\n\\r\\n\\r\\n signature = signature_parse(structure.signature)\\r\\n\\r\\n kernel = kernel_parse(signature.kernel)\\r\\n inputs = input_parse(signature.input)\\r\\n\\r\\n print signature.kernel\\r\\n print signature.input\\r\\n print signature.output\\r\\n\\r\\n\\r\\n quit()\",\n \"def _parse(self):\\n with open(self.input) as f:\\n for line in f:\\n if not line.lstrip().startswith(\\\"#\\\"): # comment\\n stripped_line=line.split(\\\"#\\\")[0].strip()\\n \\n # Initialise an empty option dictionary with some good defaults\\n if \\\"[\\\" in stripped_line:\\n molname=stripped_line.split()[1]\\n self.options[molname]=self.empty_option_dict.copy() # dict1=dict2 does not copy!\\n self.options[molname][\\\"MolName\\\"]=molname\\n if \\\":\\\" in stripped_line: \\n # now process line by line\\n if \\\"{\\\" not in stripped_line:\\n key,value=[i.strip() for i in stripped_line.split(\\\":\\\")]\\n\\n if key not in self.options[molname].keys():\\n raise BaseException(\\\"Option \\\\\\\"{}\\\\\\\" not known, please check your input file\\\".format(key))\\n self.options[molname][key]=value \\n else:\\n # This is to define special lines that are given by a dictionary\\n key,value=stripped_line.split(\\\":\\\",1) # split on first occurence\\n if key==\\\"Addon\\\": # additional atoms to be added per molecule\\n addondict=self.empty_addon_dict.copy()\\n addondict_string = value.split(\\\"}\\\",-1)[0].split(\\\"{\\\",1)[1]\\n for pair in addondict_string.split(\\\",\\\"):\\n addonkey,addonvalue=[i.strip() for i in pair.split(\\\":\\\")]\\n if addonkey not in addondict.keys():\\n raise BaseException(\\\"Option \\\\\\\"{}\\\\\\\" in Addon section of molecule {} not known, please check your input file\\\".format(addonkey,molname))\\n addondict[addonkey]=addonvalue\\n value=addondict\\n # Since addon keyword can be used many times, this is a list\\n self.options[molname][key].append(value) \\n self._check()\",\n \"def _parser(data=\\\"\\\"):\\r\\n\\r\\n if data == \\\"\\\":\\r\\n pass\\r\\n \\r\\n \\\"\\\"\\\"Retrieve timestamp\\\"\\\"\\\"\\r\\n validate(data[:25])\\r\\n \\\"\\\"\\\"retrieve log data\\\"\\\"\\\"\\r\\n log_data = re.findall(r\\\"[\\\\w]+\\\", data)\\r\\n \\\"\\\"\\\"Retrieve user info\\\"\\\"\\\"\\r\\n login_info = [log_data[i] for i in (7, 9, 11, 13, 15)]\\r\\n\\r\\n \\r\\n return login_info, log_data\",\n \"def _runParser(self):\\n with open(self.var('filePath')) as f:\\n return json.load(f)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7996566","0.7783249","0.76065314","0.76065314","0.76065314","0.76065314","0.7285606","0.7165976","0.70817536","0.7069374","0.70202744","0.6931129","0.6881782","0.68361986","0.6675497","0.6673735","0.6653678","0.66311437","0.65552753","0.6510659","0.6476338","0.6399898","0.6356738","0.6258586","0.6252675","0.6216772","0.61843973","0.61821204","0.6181459","0.61708564","0.615049","0.61256534","0.6118624","0.6111802","0.6091358","0.6084635","0.60754913","0.6065043","0.6041019","0.6029133","0.6018511","0.6008246","0.6004003","0.59821254","0.59789234","0.5913182","0.5908016","0.5897306","0.58936435","0.58697563","0.5839188","0.5833423","0.5827607","0.5827183","0.5811248","0.5809337","0.57960814","0.5779829","0.57563746","0.57521224","0.5715754","0.5709371","0.5709371","0.5708265","0.570776","0.5706716","0.57043713","0.56917477","0.56895196","0.56839854","0.5675888","0.56733286","0.56687236","0.56676656","0.5663751","0.5642265","0.56361645","0.56321","0.56296116","0.5628397","0.56138825","0.55879325","0.5585669","0.55827343","0.5581949","0.5580305","0.55779964","0.5560188","0.5558295","0.55470395","0.55468625","0.5526572","0.5521045","0.5520716","0.5518689","0.55151963","0.5510222","0.5505264","0.55048203","0.5499995","0.5487798"],"string":"[\n \"0.7996566\",\n \"0.7783249\",\n \"0.76065314\",\n \"0.76065314\",\n \"0.76065314\",\n \"0.76065314\",\n \"0.7285606\",\n \"0.7165976\",\n \"0.70817536\",\n \"0.7069374\",\n \"0.70202744\",\n \"0.6931129\",\n \"0.6881782\",\n \"0.68361986\",\n \"0.6675497\",\n \"0.6673735\",\n \"0.6653678\",\n \"0.66311437\",\n \"0.65552753\",\n \"0.6510659\",\n \"0.6476338\",\n \"0.6399898\",\n \"0.6356738\",\n \"0.6258586\",\n \"0.6252675\",\n \"0.6216772\",\n \"0.61843973\",\n \"0.61821204\",\n \"0.6181459\",\n \"0.61708564\",\n \"0.615049\",\n \"0.61256534\",\n \"0.6118624\",\n \"0.6111802\",\n \"0.6091358\",\n \"0.6084635\",\n \"0.60754913\",\n \"0.6065043\",\n \"0.6041019\",\n \"0.6029133\",\n \"0.6018511\",\n \"0.6008246\",\n \"0.6004003\",\n \"0.59821254\",\n \"0.59789234\",\n \"0.5913182\",\n \"0.5908016\",\n \"0.5897306\",\n \"0.58936435\",\n \"0.58697563\",\n \"0.5839188\",\n \"0.5833423\",\n \"0.5827607\",\n \"0.5827183\",\n \"0.5811248\",\n \"0.5809337\",\n \"0.57960814\",\n \"0.5779829\",\n \"0.57563746\",\n \"0.57521224\",\n \"0.5715754\",\n \"0.5709371\",\n \"0.5709371\",\n \"0.5708265\",\n \"0.570776\",\n \"0.5706716\",\n \"0.57043713\",\n \"0.56917477\",\n \"0.56895196\",\n \"0.56839854\",\n \"0.5675888\",\n \"0.56733286\",\n \"0.56687236\",\n \"0.56676656\",\n \"0.5663751\",\n \"0.5642265\",\n \"0.56361645\",\n \"0.56321\",\n \"0.56296116\",\n \"0.5628397\",\n \"0.56138825\",\n \"0.55879325\",\n \"0.5585669\",\n \"0.55827343\",\n \"0.5581949\",\n \"0.5580305\",\n \"0.55779964\",\n \"0.5560188\",\n \"0.5558295\",\n \"0.55470395\",\n \"0.55468625\",\n \"0.5526572\",\n \"0.5521045\",\n \"0.5520716\",\n \"0.5518689\",\n \"0.55151963\",\n \"0.5510222\",\n \"0.5505264\",\n \"0.55048203\",\n \"0.5499995\",\n \"0.5487798\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21960,"cells":{"query":{"kind":"string","value":"Parse general information in line and update it to GENERAL_INFO dictionary."},"document":{"kind":"string","value":"def _parse_general_info(self, line):\n if self._regex_helper.search_compiled(W._re_general_info, line):\n self.current_ret['GENERAL_INFO'].update({\n 'time': datetime.datetime.strptime(self._regex_helper.group(\"TIME\"), '%H:%M:%S').time(),\n 'uptime': self._regex_helper.group(\"UPTIME\"),\n 'user_number': self._regex_helper.group(\"USER_NUMBER\"),\n 'load_average': self._regex_helper.group(\"L_AVERAGE\")\n })\n raise ParsingDone"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _parse_line(self, line):\n fields = line.split('|', 4) # stop splitting after fourth | found\n line_info = {'raw_message': line}\n if len(fields) == 5:\n line_info.update(dict(zip(self._fieldnames, fields)))\n return line_info","def _parse_general_info_V4X(par, parfile):\n line = None\n while line != '':\n pos = parfile.tell()\n line = parfile.readline()\n #Parse the useful parts of the general info entry on the left and\n #right of the colon: key and value\n m = re.search(r'\\. ([^<>\\(\\)\\[\\]]*[a-zA-Z]).*: *(.*)', line)\n if not m:\n parfile.seek(pos)\n break\n key, val = m.group(1, 2)\n key = _sanitize_to_identifer(key).lower()\n #Try to guess the type of the field by conversion\n _val_split = val.split()\n if len(_val_split) > 1:\n try:\n val = np.array(tuple(float(x) for x in _val_split))\n except:\n pass\n else:\n try:\n val = int(val)\n except ValueError:\n pass\n #logger.debug(\"Key = '{0}' Val = '{1}'\".format(key, val))\n setattr(par.gen_info, key, val)\n return par.gen_info","def parse_ensembl_line(line, header):\n line = line.rstrip().split(\"\\t\")\n header = [head.lower() for head in header]\n raw_info = dict(zip(header, line))\n\n ensembl_info = {}\n\n for word in raw_info:\n value = raw_info[word]\n if not value:\n continue\n\n if \"chromosome\" in word:\n ensembl_info[\"chrom\"] = value\n if \"gene name\" in word:\n ensembl_info[\"hgnc_symbol\"] = value\n if \"hgnc id\" in word:\n ensembl_info[\"hgnc_id\"] = int(value.split(\":\")[-1])\n if \"hgnc symbol\" in word:\n ensembl_info[\"hgnc_symbol\"] = value\n if \"strand\" in word:\n ensembl_info[\"strand\"] = int(value)\n\n update_gene_info(ensembl_info, word, value)\n update_transcript_info(ensembl_info, word, value)\n update_exon_info(ensembl_info, word, value)\n update_utr_info(ensembl_info, word, value)\n update_refseq_info(ensembl_info, word, value)\n return ensembl_info","def _parse_line(self, line):\n msg_info = {'raw_message': line}\n line_split = line.split(None, 2)\n try:\n msg_info['timestamp'] = datetime.strptime(' '.join(line_split[:2]), self.time_format)\n msg_info['message'] = line_split[2]\n except (ValueError, IndexError):\n pass\n return msg_info","def get_read_group_info(line, logger=default_logger):\n\n rg_dict = dict()\n #Initialize the dictionary, so we know if any fields are missing\n rg_dict[\"PI\"] = \"\"\n rg_dict[\"CN\"] = \"UNKNOWN\"\n rg_dict[\"ID\"] = \"\"\n rg_dict[\"PL\"] = \"UNKNOWN\"\n rg_dict[\"LB\"] = \"\"\n rg_dict[\"SM\"] = \"\"\n rg_dict[\"PU\"] = \"\"\n rg_dict[\"DT\"] = \"\"\n sline = line.split('\\t')\n\n for item in sline:\n item = item.strip()\n\n if(item.startswith(\"ID:\")):\n rg_dict[\"ID\"] = item[3:]\n elif(item.startswith(\"PL:\")):\n rg_dict[\"PL\"] = item[3:]\n elif(item.startswith(\"PU:\")):\n item = item.replace(\".\", \"_\") #to agree with ICGC SOP\n rg_dict[\"PU\"] = item[3:]\n elif(item.startswith(\"LB:\")):\n rg_dict[\"LB\"] = item[3:]\n elif(item.startswith(\"DT:\")):\n rg_dict[\"DT\"] = item[3:]\n elif(item.startswith(\"SM:\")):\n rg_dict[\"SM\"] = item[3:]\n elif(item.startswith(\"CN:\")):\n rg_dict[\"CN\"] = item[3:]\n elif(item.startswith(\"PI:\")):\n rg_dict[\"PI\"] = item[3:]\n else:\n pass\n\n for key,value in rg_dict.items():\n if value == \"\":\n logger.warning(\"missing RG field %s\" % key)\n\n return rg_dict","def parse_line(self, line):\n success = self.parser.handle_line(line)\n if success:\n self.data.update()\n else:\n self.bot.log(\"didn't handle line: '{}'\".format(line))","def fill_project_info(self, line_read, new_format):\n if new_format:\n \"\"\" list(set()) converts list into a set to remove duplicates, but\n does not preserve order. dict key must always be 1st element\n in line_read else the project_info dict will not be updated\n properly. The code below gets rid of duplicated values while\n preserving the order of the elements in line_read. Code was\n taken from a StackOverflow thread about the same issue. \"\"\"\n tmp_list = set() # new empty set\n tmp_add = tmp_list.add # built-in method 'add' of set object\n temp = [x for x in line_read if not (x in tmp_list or tmp_add(x))]\n line_read = temp\n else:\n line_read = line_read.split(':', 1)\n line_read[0] = re.sub('[- ]', '', line_read[0])\n key_name = line_read[0].lower()\n\n if 'sapid' in key_name:\n self.project_info.update({'SAP ID': line_read[1].strip(' ')})\n if 'golive' in key_name:\n self.project_info.update({'Go Live Date': line_read[1]})\n if 'customer' in key_name:\n site_name = re.sub('State|Lottery', '', line_read[1])\n site_name = site_name.strip(' ')\n self.project_info.update({'Site': site_name})","def process_line(self, line):\n find_result = re.findall(LINE_REGEX, line)\n line_data = {r[0]: r[1] for r in find_result}\n self.process_url(line_data.get('request_to'))\n self.process_status_code(line_data.get('response_status'))","def getLineInformation(line):\n \n pass","def parse_line(cls, line):\n regex = re.compile(cls.pattern)\n m = regex.search(line)\n if m:\n data = m.groupdict()\n data = cls.post_process(data)\n if cls.date_format:\n data['time'] = cls.convert_time(data['time'])\n else:\n data['time'] = datetime.now()\n return data\n else:\n return {}","def _process_line(line, status):\n\n if line.startswith(ADAPTER_LINE_STARTSWITH):\n status.add_block('adapter', 'name', line)\n return\n elif line.startswith(EXIT_LINE_STARTSWITH):\n status.consolidate()\n return\n\n key, value = [el.strip(' \\t\\r\\n') for el in line.split(':', 1)]\n\n if key in KEY_TO_CONTEXT.keys():\n status.add_block(KEY_TO_CONTEXT[key], key, value)\n else:\n status.set_property(key, value)","def parse_info(s:str) -> dict:\n d = {}\n d[\"SVTYPE\"] = re.search(r'(?<=SVTYPE=)\\w+',s).group(0)\n d[\"SUPPORT\"] = re.search(r'(?<=SUPPORT=)\\d+',s).group(0)\n if d[\"SVTYPE\"] in [\"BND\"]:\n return d\n d[\"END\"] = re.search(r'(?<=END=)\\d+',s).group(0)\n if d[\"SVTYPE\"] in [\"INV\"]:\n return d\n d[\"SVLEN\"] = re.search(r'(?<=SVLEN=)(.*?)(?=;)',s).group(0)\n d[\"READS\"] = re.search(r'(?<=READS=)(.*?)(?=$)',s).group(0).split(\",\")\n if d[\"SVTYPE\"] == \"INS\":\n d[\"SEQS\"] = re.search(r'(?<=SEQS=)(.*?)(?=;)',s).group(0).split(\",\")\n return d","def parse_line(self, line):\n raise NotImplementedError","def _read_info(self):\n my_filelines = self.file_lines\n info = dict()\n\n for i, line in enumerate(my_filelines):\n if line.startswith(\"VEHICLE\"):\n vehicle_pro_start = i + 2\n elif line.startswith(\"CUSTOMER\"):\n customer_pro_start = i + 3\n\n elif line.startswith(\"NUMBER\"):\n splited = line.split(' ')\n info[splited[0]] = 0\n info[splited[-1]] = 0\n return info, (vehicle_pro_start, customer_pro_start)","def process_line(line):\n\n name_comp_list = []\n givenname_comp_list = []\n surname_comp_list = []\n geocode_comp_list = []\n locality_comp_list = []\n date1_comp_list = []\n date2_comp_list = []\n\n # Split the line into the basic fields - - - - - - - - - - - - - - - - - - -\n #\n if (config.in_file_type in ['CSV','CSVQ','TAB','TABQ']):\n # Comma or tabulator separated\n try:\n line_list = config.line_parser.parse(line)\n except:\n log_message('CSV line parsing failed with inout: '+line,'err')\n\n if (len(line_list) < config.input_len):\n log_message('Input line does not contain enough fields,' +\\\n 'fill up with empty fields','warn')\n while (len(line_list) < config.input_len):\n line_list.append('')\n\n config.curr_line_list = line_list # Save current line list\n\n # Extract fields into different component lists - - - - - - - - - - - - - -\n #\n if (config.input_component['name'] != []): # Extract name fields\n for i in config.input_component['name']:\n name_comp_list.append(line_list[i])\n\n else: # Extract givenname and surname into separate components - - - - - -\n if (config.input_component['givenname'] != []): # Extract g-name fields\n for i in config.input_component['givenname']:\n givenname_comp_list.append(line_list[i])\n\n if (config.input_component['surname'] != []): # Extract surname fields\n for i in config.input_component['surname']:\n surname_comp_list.append(line_list[i])\n\n if (config.input_component['geocode'] != []): # Extract geocode fields\n for i in config.input_component['geocode']:\n geocode_comp_list.append(line_list[i])\n\n if (config.input_component['locality'] != []): # Extract locality fields\n for i in config.input_component['locality']:\n locality_comp_list.append(line_list[i])\n\n if (config.input_component['date1'] != []): # Extract date1 fields\n for i in config.input_component['date1']:\n date1_comp_list.append(line_list[i])\n\n if (config.input_component['date2'] != []): # Extract date2 fields\n for i in config.input_component['date2']:\n date2_comp_list.append(line_list[i])\n\n elif (config.in_file_type == 'COL'): # Column based input file - - - - - - -\n\n if (len(line) < config.input_len):\n log_message('Input line is not long enough, fill up with spaces','warn')\n line += ' '*(config.input_len-len(line))\n\n if (config.input_component['name'] != []): # Extract name fields\n for (col_start,length) in config.input_component['name']:\n name_comp_list.append(line[col_start,col_start+length])\n\n else: # Extract givenname and surname into separate components - - - - - -\n if (config.input_component['givenname'] != []): # Extract g-name fields\n for (col_start,length) in config.input_component['givenname']:\n givenname_comp_list.append(line[col_start,col_start+length])\n\n if (config.input_component['surname'] != []): # Extract surname fields\n for (col_start,length) in config.input_component['surname']:\n surname_comp_list.append(line[col_start,col_start+length])\n\n if (config.input_component['geocode'] != []): # Extract geocode fields\n for (col_start,length) in config.input_component['geocode']:\n geocode_comp_list.append(line[col_start,col_start+length])\n\n if (config.input_component['locality'] != []): # Extract locality fields\n for (col_start,length) in config.input_component['locality']:\n locality_comp_list.append(line[col_start,col_start+length])\n\n if (config.input_component['date1'] != []): # Extract date1 fields\n for (col_start,length) in config.input_component['date1']:\n date1_comp_list.append(line[col_start,col_start+length])\n\n if (config.input_component['date2'] != []): # Extract date2 fields\n for (col_start,length) in config.input_component['date2']:\n date2_comp_list.append(line[col_start,col_start+length])\n\n # elif (config.in_file_type == 'SQL'): # - - - - - - - - - - - - - - - - - -\n\n ################################\n # Add later: SQL database access\n ################################\n\n msg = [' Component basic field lists:', \\\n ' Name: '+str(name_comp_list), \\\n ' Given name: '+str(givenname_comp_list), \\\n ' Surname: '+str(surname_comp_list), \\\n ' Geocode: '+str(geocode_comp_list), \\\n ' Locality: '+str(locality_comp_list), \\\n ' Date1: '+str(date1_comp_list), \\\n ' Date2: '+str(date2_comp_list)]\n log_message(msg,'v2')\n\n name_comp = ''\n givenname_comp = ''\n surname_comp = ''\n geocode_comp = ''\n locality_comp = ''\n date1_comp = ''\n date2_comp = ''\n\n # Now clean and then concatenate component lists into strings - - - - - - - -\n #\n if (name_comp_list != []): # Name component\n name_comp = name_comp_list[0] # Start with first field in list\n\n for f in name_comp_list[1:]: # Loop over following fields (if any)\n if (f != ''):\n if (config.input_space_sep['name'] == 1):\n sep = ' ' # Set separator to space between fields\n else:\n sep = '' # No space between fields\n\n # Check field spilling only if space separator is set to ' ' \n #\n if (sep == ' ') and (config.input_check_spilling['name'] == 1):\n sep = check_field_spill(name_comp, f)\n\n name_comp = name_comp+sep+f # Append separator and field\n\n if (givenname_comp_list != []): # Givenname component - - - - - - - - - - -\n givenname_comp = givenname_comp_list[0] # Start with first field in list\n\n for f in givenname_comp_list[1:]: # Loop over following fields (if any)\n if (f != ''):\n if (config.input_space_sep['givenname'] == 1):\n sep = ' ' # Set separator to space between fields\n else:\n sep = '' # No space between fields\n\n # Check field spilling only if space separator is set to ' ' \n #\n if (sep == ' ') and (config.input_check_spilling['givenname'] == 1):\n sep = check_field_spill(givenname_comp, f)\n\n givenname_comp = givenname_comp+sep+f # Append separator and field\n\n if (surname_comp_list != []): # Surname component - - - - - - - - - - - - -\n surname_comp = surname_comp_list[0] # Start with first field in list\n\n for f in surname_comp_list[1:]: # Loop over following fields (if any)\n if (f != ''):\n if (config.input_space_sep['surname'] == 1):\n sep = ' ' # Set separator to space between fields\n else:\n sep = '' # No space between fields\n\n # Check field spilling only if space separator is set to ' ' \n #\n if (sep == ' ') and (config.input_check_spilling['surname'] == 1):\n sep = check_field_spill(surname_comp, f)\n\n surname_comp = surname_comp+sep+f # Append separator and field\n\n if (geocode_comp_list != []): # Geocode component - - - - - - - - - - - - -\n geocode_comp = geocode_comp_list[0] # Start with first field in list\n\n for f in geocode_comp_list[1:]: # Loop over following fields (if any)\n if (f != ''):\n if (config.input_space_sep['geocode'] == 1):\n sep = ' ' # Set separator to space between fields\n else:\n sep = '' # No space between fields\n\n # Check field spilling only if space separator is set to ' ' \n #\n if (sep == ' ') and (config.input_check_spilling['geocode'] == 1):\n sep = check_field_spill(geocode_comp, f)\n\n geocode_comp = geocode_comp+sep+f # Append separator and field\n\n if (locality_comp_list != []): # Locality component - - - - - - - - - - - -\n locality_comp = locality_comp_list[0] # Start with first field in list\n\n for f in locality_comp_list[1:]: # Loop over following fields (if any)\n if (f != ''):\n if (config.input_space_sep['locality'] == 1):\n sep = ' ' # Set separator to space between fields\n else:\n sep = '' # No space between fields\n\n # Check field spilling only if space separator is set to ' ' \n #\n if (sep == ' ') and (config.input_check_spilling['locality'] == 1):\n sep = check_field_spill(locality_comp, f)\n\n locality_comp = locality_comp+sep+f # Append separator and field\n\n if (date1_comp_list != []): # Date1 component - - - - - - - - - - - - - - -\n date1_comp = date1_comp_list[0] # Start with first field in list\n\n for f in date1_comp_list[1:]: # Loop over following fields (if any)\n if (f != ''):\n if (config.input_space_sep['date1'] == 1):\n sep = ' ' # Set separator to space between fields\n else:\n sep = '' # No space between fields\n\n # Check field spilling only if space separator is set to ' ' \n #\n if (sep == ' ') and (config.input_check_spilling['date1'] == 1):\n if (date1_comp[-1] != ' ') and (f[0] != ' '):\n tmp_list0 = date1_comp.split()\n tmp_list1 = f.split()\n check_word = tmp_list0[-1]+tmp_list1[0]\n\n if (check_word in ['jan','feb','mar','apr','may','jun','jul','aug', \\\n 'sep','oct','nov','dec','january','february','march','april', \\\n 'may','june','july','august','september','october','november', \\\n 'december']):\n\n sep = '' # Set separator to no space\n msg = ' Correct date1 word spilling: \"'+date1_comp+'\",\"'+f+'\"'\n log_message(msg,'v1')\n\n date1_comp = date1_comp+sep+f # Append separator and field\n\n if (date2_comp_list != []): # Date2 component - - - - - - - - - - - - - - -\n date2_comp = date2_comp_list[0] # Start with first field in list\n\n for f in date2_comp_list[1:]: # Loop over following fields (if any)\n if (f != ''):\n if (config.input_space_sep['date2'] == 1):\n sep = ' ' # Set separator to space between fields\n else:\n sep = '' # No space between fields\n\n # Check field spilling only if space separator is set to ' ' \n #\n if (sep == ' ') and (config.input_check_spilling['date2'] == 1):\n if (date2_comp[-1] != ' ') and (f[0] != ' '):\n tmp_list0 = date1_comp.split()\n tmp_list1 = f.split()\n check_word = tmp_list0[-1]+tmp_list1[0]\n\n if (check_word in ['jan','feb','mar','apr','may','jun','jul','aug', \\\n 'sep','oct','nov','dec','january','february','march','april', \\\n 'may','june','july','august','september','october','november', \\\n 'december']):\n\n sep = '' # Set separator to no space\n msg = ' Correct date1 word spilling: \"'+date1_comp+'\",\"'+f+'\"'\n log_message(msg,'v1')\n\n date2_comp = date2_comp+sep+f # Append separator and field\n\n # Check if name component is given or givenname and surname separately - - -\n #\n if (config.input_component['givenname'] != []) or \\\n (config.input_component['surname'] != []):\n name_comp = [givenname_comp, surname_comp]\n\n msg = [' Components:', \\\n ' Name: \"'+str(name_comp)+'\"', \\\n ' Geocode: \"'+geocode_comp+'\"', \\\n ' Locality: \"'+locality_comp+'\"', \\\n ' Date1: \"'+date1_comp+'\"', \\\n ' Date2: \"'+date2_comp+'\"']\n log_message(msg,'v1')\n\n return [name_comp, geocode_comp, locality_comp, date1_comp, date2_comp]","def process_entry(self):\n\n for line_item in self.entry:\n pairs = line_item.split(' ')\n for pair in pairs:\n if ':' in pair:\n key, value = pair.split(':')\n if value.isdigit():\n self.fields[key] = int(value)\n else:\n self.fields[key] = value","def parse_aunt_information(line: str) -> (int, Mapping[str, int]):\n sue_number, parameters = re.split(': ', line, maxsplit=1)\n number = int(re.sub('Sue ', '', sue_number))\n\n def parse_param(description: str) -> (str, int):\n \"\"\"The name and value of the described parameter.\"\"\"\n name, value = re.split(': ', description)\n return name, int(value)\n\n return number, dict(map(parse_param, re.split(', ', parameters)))","def parse_info(self, info_lines):\n info = {}\n for line in info_lines:\n if not line or line.startswith(\"#\"):\n continue\n\n if \":\" not in line:\n collectd.warning(\"redis_info plugin: Bad format for info line: %s\" % line)\n continue\n\n key, val = line.split(\":\", 1)\n\n # Handle multi-value keys (for dbs and slaves).\n # db lines look like \"db0:keys=10,expire=0\"\n # slave lines look like\n # \"slave0:ip=192.168.0.181,port=6379,\n # state=online,offset=1650991674247,lag=1\"\n if \",\" in val:\n split_val = val.split(\",\")\n for sub_val in split_val:\n k, _, v = sub_val.rpartition(\"=\")\n sub_key = \"{0}_{1}\".format(key, k)\n info[sub_key] = v\n else:\n info[key] = val\n\n # compatibility with pre-2.6 redis (used changes_since_last_save)\n info[\"changes_since_last_save\"] = info.get(\"changes_since_last_save\", info.get(\"rdb_changes_since_last_save\"))\n\n return info","def parse_line(self, line):\n line = line.strip()\n log.debug(\"Parsing line: '{}'\".format(line))\n if len(line) == 0:\n log.warning(\"Zero length line detected\")\n return\n split = line.split(DELIMETER)\n key = split[0]\n if key in FORMATS:\n log.debug(\"Using formatter for key: {}\".format(key))\n formatter = FORMATS[key]\n for (name, parser), value in zip(formatter,split[1:]):\n self._params[name] = parser(value)\n log.info(\"Parameters: {}\".format(self._params))\n self.notify_watchers()\n else:\n log.debug(\"Invalid key: {}\".format(key))","def process(line):\n output = {}\n\n fields = line.split(\" \")\n if len(fields) < 6:\n return False\n \n output[\"log_level\"] = fields[0]\n \n # Convert date/time to object or reject line\n try:\n output[\"datetime\"] = datetime.datetime.strptime(\n \"%s %s\" % (fields[1], fields[2]),\n \"%Y-%m-%d %H:%M:%S,%f\"\n )\n except ValueError:\n return False\n \n output[\"logger\"] = fields[3]\n output[\"thread\"] = fields[4]\n output[\"process\"] = fields[5]\n output[\"message\"] = \" \".join(fields[6:])\n \n return output","def ParseLine(line):\n fields = line.split()\n ip = fields[0]\n datestr = ' '.join(fields[3:5])[1:-1]\n timestamp = datetime.strptime(\n datestr, '%d/%b/%Y:%H:%M:%S %z'\n ).timestamp()\n command = fields[5][1:]\n uri = fields[6]\n protocol = fields[7][:-1]\n status = int(fields[8])\n size = int(fields[9])\n meta = [var.strip('\"') for var in fields[11:-1]]\n return {\n 'timestamp': timestamp,\n 'ip': ip,\n 'command': command,\n 'uri': uri,\n 'protocol': protocol,\n 'status': status,\n 'size': size,\n 'meta': meta\n }","def get_line_desc(self, line):\n return dict(zip(self.header, line))","def _parse_line(line: Match[str]) -> dict:\n request = line.group(\"request\")\n request = request.split()\n req_method = request[0] # GET, POST, PUT, etc.\n url = request[1]\n x = url.split(\"/\")[3:]\n uri = f'/{\"/\".join(x)}'\n\n timestamp = line.group(\"timestamp\") # timestamp in ISO format\n timestamp = MyTime._try_isoformat(timestamp, tzinfo=\"UTC\").dt\n\n res = {\n \"url\": url,\n \"uri\": uri,\n \"req_method\": req_method,\n \"timestamp\": timestamp,\n \"user_agent\": line.group(\"user_agent\"),\n }\n return res","def parse_user_dict(self, line):\n pass","def _parseLine(self, line, delimiter = \":\"):\r\n\t\tsplt = line.split(delimiter)\r\n\t\tinVec = self._parseVec(splt[0])\r\n\t\toutVec = self._parseVec(splt[1])\r\n\t\tif (len(splt) == 2):\r\n\t\t\tlabel = \"\"\r\n\t\telse:\r\n\t\t\tlabel = splt[2]\r\n\t\tself.data.append({'in':inVec, 'out':outVec, 'label':label})","def parseLine(self, line):\n\n # Bail out on lines with a malformed timestamp\n try:\n timestamp = time.mktime(time.strptime(line[1:25], \"%a %b %d %H:%M:%S %Y\"))\n except:\n return\n \n text = line[27:]\n \n if self.myname: \n self.attendance.mark(timestamp, self.myname)\n text = self.re_myname.sub(self.myname + ' ', text) \n \n damage = self.re_damage.search(text)\n #damage = False\n death = self.re_death.search(text)\n #death = False\n miss = self.re_miss.search(text)\n #miss = False\n #defensive = self.re_defensive.search(text)\n defensive = False\n loot = self.re_loot.search(text)\n attendance = self.re_attendance.search(text)\n if damage:\n (attacker, atktype, defender, amount, nonmelee) = damage.groups()\n if nonmelee:\n atktype = 'non-melee'\n if self.extract and (self.extract == attacker or self.extract == defender):\n self.fights.getFight(timestamp, attacker, defender).addAttack(timestamp, atktype, int(amount))\n if attacker.count(' ') == 0:\n self.attendance.mark(timestamp, attacker)\n if defender.count(' ') == 0:\n self.defender.mark(timestamp, defender)\n elif miss:\n (attacker, atktype, defender) = miss.groups()\n if self.extract and (self.extract == attacker or self.extract == defender):\n self.fights.getFight(timestamp, attacker, defender).addAttack(timestamp, atktype, 'miss')\n if attacker.count(' ') == 0:\n self.attendance.mark(timestamp, attacker)\n if defender.count(' ') == 0:\n self.defender.mark(timestamp, defender)\n elif defensive:\n (attacker, atktype, defender, defensetype) = defensive.groups()\n if self.extract and (self.extract == attacker or self.extract == defender):\n self.fights.getFight(timestamp, attacker, defender).addAttack(timestamp, atktype, defensetype)\n if attacker.count(' ') == 0:\n self.attendance.mark(timestamp, attacker)\n if defender.count(' ') == 0:\n self.defender.mark(timestamp, defender)\n elif death:\n (defender, junk, attacker) = death.groups()\n if junk.count('have slain'):\n (defender, attacker) = (attacker, defender)\n # Use PC deaths to track their attendance\n if defender.count(' ') == 0:\n self.attendance.mark(timestamp, defender)\n elif attacker.count(' ') == 0:\n self.kills.addKill(timestamp, defender)\n if self.extract and (self.extract == attacker or self.extract == defender):\n self.fights.addDeath(timestamp, attacker, defender)\n if attacker.count(' ') == 0:\n self.attendance.mark(timestamp, attacker)\n elif loot:\n (looter, item) = loot.groups()\n self.loot.addLoot(timestamp, looter, item)\n self.attendance.mark(timestamp, looter)\n elif attendance:\n attendee = attendance.group(1)\n self.attendance.mark(timestamp, attendee)","def Process_line(line, summary):\n line = line.lower() # lower all words in the line\n line = line.translate(str.maketrans('','', string.punctuation)) # Remove all punctuation\n words = line.split() # Split word from the line\n add_word(words, summary) # Add word to dictionary","def parse(self, src, line):\n r = line.split('\\t')\n p = {}\n if src == 'sf':\n p['businessID'] = r[0]\n p['name'] = r[1]\n p['address'] = r[2]\n p['city'] = r[3]\n p['state'] = r[4]\n p['zip'] = r[5]\n p['latitude'] = r[6]\n p['longitude'] = r[7]\n p['phone'] = r[8]\n elif src == 'nyc':\n p['businessID'] = r[0]\n p['name'] = r[1]\n # nyc separates the building number from the street name\n p['address'] = ' '.join([r[3].strip(), r[4].strip()])\n p['city'] = 'NYC'\n p['state'] = 'NY'\n p['zip'] = r[5]\n p['latitude'] = None\n p['longitude'] = None\n p['phone'] = r[6]\n return p","def _parse_line(self):\n # check if line contains a rule or not\n stripped = self._line.strip()\n if not stripped or stripped.startswith(\"#\"):\n return None\n\n # strip out double quotes from values, and simplify equals strings\n simplified = self._line.replace(\"==\", \"=\").replace('\"', '')\n\n # return a dictionary formed from the key=value pairs found in line\n return dict(f.strip().split(\"=\", 1) for f in simplified.split(\",\"))","def process_log_line(self, line):\n int_map = self.int_map\n timestamp = line[0:26]\n if len(timestamp) >= 26:\n msg = {}\n try:\n # %Y-%m-%d %H:%M:%S.%f - 2017-06-27 13:46:10.048844\n day = int_map[timestamp[8:10]]\n hour = int_map[timestamp[11:13]]\n minute = int_map[timestamp[14:16]]\n second = int_map[timestamp[17:19]]\n usecond = int_map[timestamp[20:22]] * 10000 + \\\n int_map[timestamp[22:24]] * 100 + int_map[timestamp[24:26]]\n event_time = (hour * 3600.0 + minute * 60.0 + second) + (usecond / 1000000)\n if day == self.start_day:\n elapsed = event_time - self.start_time\n else:\n elapsed = event_time + (float(3600 * 24) - self.start_time)\n msg['timestamp'] = elapsed\n if msg['timestamp'] >= 0:\n offset = line.find(']: ', 32)\n if offset >= 0:\n try:\n thread = line[34:offset]\n separator = thread.find(':')\n if separator >= 0:\n thread = thread[separator + 1:].strip()\n msg['thread'] = thread\n msg['level'] = line[offset + 3:offset + 4]\n msg_start = line.find(' ', offset + 5)\n if msg_start >= 0:\n msg['category'] = line[offset + 5:msg_start]\n msg['message'] = line[msg_start + 1:]\n if msg['category'] == 'nsHttp':\n if msg['thread'] == 'Main Thread':\n self.main_thread_http_entry(msg)\n elif msg['thread'] == 'Socket Thread':\n self.socket_thread_http_entry(msg)\n elif msg['category'] == 'nsSocketTransport':\n self.socket_transport_entry(msg)\n elif msg['category'] == 'nsHostResolver':\n self.dns_entry(msg)\n except Exception:\n logging.exception('Error processing log line')\n except Exception:\n pass","def _analyzeLine(self, line, date, data):\n user = re.search(': (.*)', line).group().split()[1]\n data[user].add(ConvertTime(date, line))","def _read_header_line_2(lines: list) -> dict:\n fields = (\n \"detection_status\",\n \"warning\",\n \"cloud_base_data\",\n \"warning_flags\",\n )\n values = [[line[0], line[1], line[3:20], line[21:].strip()] for line in lines]\n return values_to_dict(fields, values)","def make_entry(line):\n #focus on relevant parts\n parts = line.split(\" - \")\n visitor_id = parts[0]\n subparts = parts[1].split('\"')\n method_and_uri = subparts[1]\n method_and_uri_parts = method_and_uri.split(\" \")\n method = method_and_uri_parts[0]\n uri = method_and_uri_parts[1]\n d = dict()\n d[\"visitor_id\"] = visitor_id\n d[\"method\"] = method\n d[\"uri\"] = uri\n return d","def _prepare_analytic_line(self, cr, uid, obj_line, context=None):\n return {'name': obj_line.name,\n 'date': obj_line.date,\n 'account_id': obj_line.analytic_account_id.id,\n 'unit_amount': obj_line.quantity,\n 'product_id': obj_line.product_id and obj_line.product_id.id or False,\n 'product_uom_id': obj_line.product_uom_id and obj_line.product_uom_id.id or False,\n 'amount': (obj_line.credit or 0.0) - (obj_line.debit or 0.0),\n 'general_account_id': obj_line.account_id.id,\n 'journal_id': obj_line.journal_id.analytic_journal_id.id,\n 'ref': obj_line.ref,\n 'move_id': obj_line.id,\n 'user_id': uid,\n }","def parse(cls, line):\r\n raise NotImplementedError","def __init__(self, line):\n columns = self._split_line(line)\n self.query_name = columns[0].strip()\n self.eggnog_ortholog = self._get_value(columns[1], split=False)\n self.eggnog_score = self._get_value(columns[2], split=False)\n self.eggnog_evalue = self._get_value(columns[3], split=False)\n self.eggnog_tax = self._get_value(columns[5], split=False)\n\n self.go = self._get_value(columns[6])\n self.ecnumber = self._get_value(columns[7])\n self.kegg = self._get_value(columns[8])\n self.brite = self._get_value(columns[13])\n self.bigg_reaction = self._get_value(columns[16])\n self.ogs = self._get_value(columns[19])\n self.cog = self._get_value(columns[20])\n self.eggnog = [parse.quote(columns[21])] if columns[21] else []","def _read_entry_detail(self, line):\n account_number = 0\n try:\n account_number = int(line[12:29].strip().replace('-', ''))\n except ValueError as err:\n print('Error parsing account number field -> ' + str(err))\n\n result_dict = {'Transaction Code': line[1:3],\n 'ReceivingID': line[3:11],\n 'CheckDigit': line[11],\n 'Account Number': account_number,\n 'Amount': int(line[29:39]) / 100,\n 'Individual ID': line[39:54],\n 'Receiver Name': line[54:76].strip(),\n 'DiscretionaryData': line[76:78],\n 'AddendaIndicator': line[78],\n 'TraceNumber': line[79:94]}\n\n self.entries.append(result_dict)","def get_general(soup):\n \n general_info = {}\n general_info.update(get_route_name(soup))\n general_info.update(get_box_data(soup))\n general_info.update(get_description(soup))\n general_info.update(get_hierarchy(soup))\n general_info.update(get_first_img_source(soup))\n\n return general_info","def on_new_line(self, line, is_full_line):\n try:\n if is_full_line:\n self._parse_v_option(line)\n self._parse_general_info(line)\n self._parse_header(line)\n except ParsingDone:\n pass # line has been fully parsed by one of above parse-methods\n return super(W, self).on_new_line(line, is_full_line)","def process_info(self, info):\n return info","def parse_report_line(self,line):\n\n report = self.new_police_report()\n report['original_text'] = line\n \n #\n # extract month and day\n match_date = REPORT_DATE_REGEXP.search(line)\n assert(match_date)\n start_index=match_date.start('month')\n stop_index=match_date.end('month')\n report['date_month'] = int(line[start_index:stop_index])\n\n start_index=match_date.start('day')\n stop_index=match_date.end('day')\n report['date_day'] = int(line[start_index:stop_index])\n\n my_logger.debug('extracted date (%d/%d)' % (report['date_month'],report['date_day']))\n\n #############################################\n # extract location & scale\n line = line[0:match_date.start('month')-1] # truncate after start of date\n \n #\n # trim off preceding html and trailing comma\n start_index=line.rfind('>')+1\n assert(start_index>0)\n\n stop_index=line.rfind(',',start_index)\n \n if stop_index >= 2:\n #\n # found a comma, \n line = line[start_index:stop_index]\n else:\n #\n # no comma found\n line = line[start_index:]\n my_logger.debug('truncated string: (%s)' % line)\n report['address']=line\n #\n # try to determine which case:\n # a block\n # an exact address\n # an establishment\n # an intersection\n # special cases, like: \"downtown mountain view\"\n # \n\n if (BLOCK_REGEXP.match(line)!=None):\n my_logger.debug('BLOCK detected')\n report['map_scale']=mapscale.BLOCK\n elif (INTERSECTION_REGEXP.match(line)!=None):\n my_logger.debug('INTERSECTION detected')\n report['map_scale']=mapscale.INTERSECTION\n elif (EXACT_REGEXP.match(line)!=None):\n my_logger.debug('EXACT detected')\n report['map_scale']=mapscale.EXACT\n else:\n #\n # must be manually assigned\n report['map_scale']=mapscale.OTHER\n\n\n return report","def parse(line):\n return dict([pair.split(':') for pair in line.split()])","def split(self, line):\n parts = line.split()\n return {\n 'size': 0 if parts[9] == '-' else int(parts[9]), \n 'file_requested': parts[6]\n }","def do_info (self, line) :\n\t\tprint\n\t\tprint get_info_string( self.__image )\n\t\tprint","def get_values_from_global_info_file(global_info_file):\n global_values = {}\n\n with open(global_info_file, 'r') as f:\n\n lines = f.readlines()\n for i, line in enumerate(lines):\n\n split_line = line.strip().split(' ')\n\n cur_last_val = line.strip().split('\\t')[-1]\n if i < (len(lines)-1):\n next_last_val = lines[i+1].strip().split('\\t')[-1]\n\n if split_line[0] == 'Vertices':\n global_values['Vertices'] = cur_last_val\n\n elif split_line[0] == 'Edges':\n global_values['Edges'] = cur_last_val\n\n elif split_line[0] == 'Total':\n if split_line[1] == 'degree':\n global_values['Total_degree'] = cur_last_val\n\n elif split_line[1] == 'strength':\n global_values['Total_strength'] = cur_last_val\n\n elif split_line[0] == 'Average':\n if split_line[1] == 'degree':\n global_values['Average_degree'] = cur_last_val\n\n elif split_line[1] == 'strength':\n global_values['Average_strength'] = cur_last_val\n\n elif split_line[1] == 'clustering':\n if split_line[2] == 'coefficient':\n global_values['Clustering_coeff'] = cur_last_val\n a = 'Clustering_coeff_weighted'\n global_values[a] = next_last_val # not very nice\n\n elif split_line[0] == 'Minimum':\n if split_line[1] == 'degree':\n global_values['Minimum_degree'] = cur_last_val\n\n elif split_line[1] == 'strength':\n global_values['Minimum_strength'] = cur_last_val\n\n elif split_line[0] == 'Maximum':\n if split_line[1] == 'degree':\n global_values['Maximum_degree'] = cur_last_val\n\n elif split_line[1] == 'strength':\n global_values['Maximum_strength'] = cur_last_val\n\n elif split_line[0] == 'Assortativity':\n global_values['Assortativity'] = cur_last_val\n global_values['Assortativity_weighted'] = next_last_val\n\n return global_values","def parse_line(line):\n parts = line.strip().split('\\t')\n\n output = {}\n\n if len(parts) != len(COLUMNS):\n raise Exception('Incorrect number of columns in line.', parts, COLUMNS)\n\n for key, value in zip(COLUMNS, parts):\n if key == 'attributes':\n output[key] = parse_attributes(value)\n elif key == 'start' or key == 'stop':\n output[key] = int(value)\n else:\n output[key] = value\n\n return output","def parse_line(line: str) -> Tuple[str, dict]:\n email, first_name, last_name, birth, gender = line.split(\",\")\n person = {\n \"first_name\": first_name,\n \"last_name\": last_name,\n \"birth\": birth,\n \"gender\": gender,\n }\n return email, person","def parseAttrLine(line):\n\tpre, post = line.strip().split(':')\n\tnumber, attr = pre.strip().split('.')\n\tattr = attr.strip().replace('%','').replace(' ', '-')\n\tvals = [clean(x) for x in post.strip().strip('.').split(',')]\n\treturn {'num':int(number), 'attr':clean(attr), 'vals':vals}","def process_line(self, line):\n for char in line:\n if self.current_state == 1:\n\n if char == \"{\":\n self.current_state = 2 # Comment\n elif char == \":\":\n self.set_type = \", Assign\"\n self.set_value = char\n self.current_state = 3 # Assign\n elif char in self.letters:\n self.set_type = \", Identifier\"\n self.set_value = char\n self.current_state = 4 # Identifier\n elif char in self.digits:\n self.set_type = \", Number\"\n self.set_value = char\n self.current_state = 5 # Number\n elif char in self.special_symbols:\n self.set_type = \", SpecialSymbol\"\n self.set_value = char\n self.tokens.append(self.set_value + self.set_type) # Done\n self.current_state = 1\n elif char != \" \" and char != \"\\n\":\n self.current_state = -1\n elif self.current_state == 2:\n\n if char == \"}\":\n self.current_state = 1\n self.set_value = \"\"\n elif self.current_state == 3:\n\n if char == \"=\":\n self.set_value += char\n self.tokens.append(self.set_value + self.set_type) # Done\n self.current_state = 1\n else:\n self.current_state = -1\n elif self.current_state == 4:\n\n if char in self.letters:\n self.set_value += char\n else: # Done\n self.current_state = 1\n if self.set_value in self.reserverd_words:\n self.set_type = \", Reserverd Word\"\n self.tokens.append(self.set_value + self.set_type) # Done\n elif self.current_state == 5:\n\n if char in self.digits:\n self.set_value += char\n else: # Done\n self.tokens.append(self.set_value + self.set_type)\n self.current_state = 1\n # elif self.current_state == 6:\n #\n #\n # self.tokens.append(self.set_value + self.set_type)\n # self.current_state = 1","def agline(line):\n\n vals = {}\n x = ['date', 'movie', 'offset', 'well', 'gen', 'flarem', 'flares', \n 'chargem', 'charges', 'charget', 'escdm', 'escds', 'escddur', 'escmm', 'escms', \n 'escmdur']\n y = line.strip('\\n').split(',')[0:16]\n z = zip(x, y)\n\n for item in z:\n vals[item[0]] = item[1]\n\n return(vals)","def parse(self,att_line):\r\n att_line = {item.split('=')[0]:item.split('=')[1] for item in att_line.split(';')}\r\n if 'ID' in att_line:\r\n self.id = att_line.pop('ID',None)\r\n if 'Name' in att_line:\r\n self.name = att_line.pop('Name',None)\r\n if 'Alias' in att_line:\r\n self.alias = att_line.pop('Alias',None)\r\n if 'Parent' in att_line:\r\n self.parent = att_line.pop('Parent',None)\r\n if 'Target' in att_line:\r\n self.target = att_line.pop('Target',None)\r\n if 'Gap' in att_line:\r\n self.gap = att_line.pop('Gap',None)\r\n if 'Derives_from' in att_line:\r\n self.derives_from = att_line.pop('Derives_from',None)\r\n if 'Note' in att_line:\r\n self.note = att_line.pop('Note',None)\r\n if 'Dbxref' in att_line:\r\n self.dbxref = att_line.pop('Dbxref',None)\r\n if 'Ontology_term' in att_line:\r\n self.ontology_term = att_line.pop('Ontology_term',None)\r\n if 'Is_circular' in att_line:\r\n self.is_circular = att_line.pop('Is_circular',None)\r\n if self.allele_key in att_line:\r\n self.allele = att_line.pop(self.allele_key,None).split(',')\r\n if self.discovered_key in att_line:\r\n discovered_val = att_line.pop(self.discovered_key,None)\r\n if discovered_val in self.enabled:\r\n self.discovered = True\r\n elif discovered_val in self.disabled:\r\n self.discovered = False\r\n if self.validated_key in att_line:\r\n validated_val = att_line.pop(self.validated_key,None)\r\n if validated_val in self.enabled:\r\n self.validated = True\r\n elif validated_val in self.disabled:\r\n self.validated = False\r\n if self.active_key in att_line:\r\n active_val = att_line.pop(self.active_key,None)\r\n if active_val in self.enabled:\r\n self.active = False\r\n elif active_val in self.disabled:\r\n self.active = True\r\n else:\r\n pass#print(\"{} is not a valid entry for {}\".format(active_val,self.active_key))\r\n else:\r\n #TODO this will make every element withought existing value active.\r\n self.active = True\r\n rest_dict = {}\r\n for key,value in att_line.items():\r\n if self.history_key in key:\r\n parts = att_line[key].split(',')\r\n if len(parts) == 3:\r\n self.add_history(*parts)\r\n else:\r\n reason = '.'.join(parts[2:])\r\n self.add_history(parts[0],parts[1],reason)\r\n else:\r\n rest_dict[key] = value\r\n if rest_dict != {}:\r\n #TODO: maybe add this to a logger instead\r\n #print(\"attributes put in other: {}\".format(', '.join(att_line.keys())))\r\n self.other = att_line\r\n return self","def _parse_track_line(self, inp):\n self.metadata = {}\n ltmp = shlex.split(inp.strip(\"\\n\"))\n for item in ltmp:\n k, v = item.split(\"=\")\n self.metadata[k] = v\n\n track_type = self.metadata.get(\"type\", None)\n if track_type is not None:\n if track_type in bed_x_formats:\n self.printer.write(\n \"Found track type '%s' in track definition line. Assuming extra columns follow UCSC definitions.\"\n % track_type\n )\n if self.extra_columns == 0:\n self.extra_columns = bed_x_formats[track_type]\n elif self.extra_columns != bed_x_formats[track_type]:\n my_columns = self._get_extra_column_names()\n track_format_columns = \",\".join([X[0] for X in bed_x_formats[track_type]])\n warn(\"Extra columns specified by %s track type declaration (%s) don't match those specified by user (%s). Using those specified by user.\" %\\\n (track_type,track_format_columns,my_columns),FileFormatWarning)\n self.metadata[\"type\"] = \"custom\"\n else:\n self.printer.write(\"Found track type '%s' in track definition line.\" % track_type)","def agline2(line):\n \n vals = {}\n y = line.strip('\\n').split(',')\n y.extend(y[0].strip('.MTS').split('_'))\n \n #print(y)\n \n x = ['movie', 'moviecode', 'offset', 'well', 'agmin', 'agsec', 'agdur', \n 'agtype', 'agcomm', 'escmin', 'escsec', 'escdur', 'esctype', 'escbeh', \n 'esccomm', 'gen', 'date', 'assay', 'fps', 'flyid', 'side', 'moviepart']\n \n z = zip(x, y)\n\n for item in z:\n vals[item[0]] = item[1]\n\n return(vals)","def ingest(in_info):\n if type(in_info) == str:\n with open(in_info) as infile:\n lines = (line.split(None) for line in infile)\n in_dict = {defn[0] : defn[1:] for defn in lines}\n else:\n in_dict = in_info\n return in_dict","def process(raw):\n entry = { }\n cooked = [ ]\n\n for line in raw:\n line = line.strip()\n if len(line) == 0 or line[0]==\"#\" :\n continue\n parts = line.split(';')\n if len(parts) == 3:\n entry[\"description\"] = parts[0].strip() #adding key and values to the dict\n entry[\"long\"] = parts[1].strip()\n entry[\"lat\"] = parts[2].strip()\n cooked.append(entry) #add this dict entry into the array\n entry = { }\n continue\n else:\n raise ValueError(\"Trouble wiht line: '{}'\\n\".format(line))\n \n return cooked #returning an array of dicts","def parse_line(self, line):\n\n kv_match = self.kv_rex.match(line)\n\n if kv_match:\n kv_dict = kv_match.groupdict()\n kv_key = kv_dict['key']\n kv_value = kv_dict['value']\n\n if 'time_' in kv_key:\n kv_unit = kv_dict['unit']\n\n if not kv_key in self.kv_times:\n self.kv_times[kv_key] = {'unit': kv_unit, 'values': []}\n\n self.kv_times[kv_key]['values'].append(float(kv_value))\n else:\n if not kv_key in self.kv_counts:\n self.kv_counts[kv_key] = 0.0\n\n self.kv_counts[kv_key] += float(kv_value)","def parse(self, line):\n try:\n (year, month, day, hour, minute, second, microseconds, offset_hour, offset_minute, source, process, logentry) = re.match('^(\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d)T(\\d\\d):(\\d\\d):(\\d\\d)\\.([\\d]+)\\+(\\d\\d):(\\d\\d) ([a-z]+)\\[([a-zA-Z0-9_.]+)\\]: ([0-9a-z-A-Z\\-_\\.\\[\\]:\\?\\#\\\",/\\ ={}\\'\\(\\)<>]+)$', line).groups()\n except:\n pass\n \n try:\n parsed_data = dict()\n parsed_data['timestamp'] = \" \".join([\"-\".join([year, month, day]), \":\".join([hour, minute, second])])\n parsed_data['log_time'] = datetime.datetime(int(year), int(month), int(day), int(hour), int(minute), int(second))\n parsed_data['log_source'] = source\n parsed_data['log_type'] = process\n except (AttributeError, UnboundLocalError):\n PARSE_ERRORS.append(line)\n return False\n\n #TODO: This still needs work on spaces in values surrounded by \" \" \n if parsed_data['log_source'] == \"heroku\":\n if logentry.__len__() > 1:\n logentry = re.sub(', ', ',', logentry)\n line_chunks = re.split(' ', logentry)\n for chunk in line_chunks:\n line_chunks = re.split('=', chunk)\n if line_chunks.__len__() > 2:\n #fwd and path are a little clunky to parse\n pass\n elif line_chunks.__len__() > 1:\n parsed_data[line_chunks[0]] = line_chunks[1]\n else:\n pass\n else:\n return False\n else:\n # TODO: [app] \n # Needs parsing. Do that here.\n return False\n\n return parsed_data","def process(line) -> dict:\n dict = {}\n entities = line.split(',')\n country = entities[1]\n cur_num = int(entities[len(entities) - 1])\n if country in dict.keys():\n dict[country] += cur_num\n else:\n dict[country] = cur_num\n return dict","def parse_rating_dict(self, line):\n pass","def _parse_refraction(line, lines):\n split_line = line.split()\n\n energy = float(split_line[0])\n ref_ind_xx = float(split_line[1])\n ref_ind_zz = float(split_line[2])\n extinct_xx = float(split_line[3])\n extinct_zz = float(split_line[4])\n\n return {\"energy\": energy, \"ref_ind_xx\": ref_ind_xx, \"ref_ind_zz\": ref_ind_zz, \"extinct_xx\": extinct_xx,\n \"extinct_zz\": extinct_zz}","def parse_line(self, line):\n # set line number\n self.line_count += 1\n if len(line) == 0:\n return\n\n # parse line to kw line\n kw_line = self._parse_line(line, line_number=self.line_count)\n if kw_line.is_comment:\n return\n\n func = kw_line.items[0]\n\n # pre import lib\n if func == 'import':\n self.default_func['import'](*kw_line.items[1:])\n\n if func not in self.kw_func and func not in self.kw_var:\n raise ValueError('Define not found {}'.format(func), kw_line.line_number)\n\n # set var\n if kw_line.var:\n self.kw_var[kw_line.var] = None\n\n # add kw line to cache\n self.kw_lines.append(kw_line)","def _process_text_line(self, line, columns, format, lower_case, num_line,\n fill_missing=0, filter_case=None,\n strict_separator=False):\n if not isinstance(line, list) and not isinstance(\n line, tuple) and not isinstance(line, numpy.ndarray):\n if format != \"tsv\":\n raise Exception(\"unable to process format \" + format)\n line = line.strip(\"\\r\\n \").replace(\"\\n\", \" \")\n line = DatabaseCore2._split_expr.split(line)\n\n if filter_case is not None:\n line = [filter_case(s) for s in line]\n\n try:\n if fill_missing > 0:\n m = max(columns.keys())\n if m >= len(line):\n line = copy.copy(line)\n add = 0\n while m >= len(line) and add < fill_missing:\n a, b = columns[len(line)]\n if b is int:\n line.append(\"0\")\n elif b is float:\n line.append(\"0.0\")\n elif b is decimal.Decimal:\n line.append(\"0\")\n elif b is str:\n line.append(\"\")\n else:\n line.append(\"\")\n add += 1\n\n res = {}\n for c, v in columns.items():\n if \"AUTOFILL\" in v:\n res[v[0]] = \"NULL\"\n elif \"AUTOINCREMENT\" in v:\n continue\n else:\n if c >= len(line):\n self.LOG(\n \"(a)line number \",\n num_line,\n \"*unable to process a line columns \",\n c,\n \"#\",\n line,\n \" columns \",\n columns)\n return None\n\n val = line[c]\n if len(v) > 2 and v[2].lower() not in [\n \"primarykey\", \"autofill\"]:\n val = v[2](val)\n\n try:\n if isinstance(v[1], tuple):\n val = v[1][0](val)\n elif v[1] is datetime.datetime:\n if isinstance(val, datetime.datetime):\n pass\n elif isinstance(val, str):\n val = datetime.datetime.parse(val)\n else:\n raise TypeError(\n \"unable to convert %s into datetime\" % str(\n type(val)))\n else:\n val = v[1](val)\n except ValueError: # as e :\n self.LOG(\n \"(b)line number \",\n num_line,\n \"**unable to process a line columns \",\n c,\n \"#\",\n v[0],\n \" type \",\n v[1],\n \" value \",\n repr(\n line[c]))\n return None\n\n if isinstance(val, str):\n val = val.replace(\"'\", \"''\")\n if lower_case:\n val = val.lower()\n res[v[0]] = val\n\n return res\n except Exception:\n self.LOG(\"(c)line number\", num_line,\n \"***unable to process a line columns:\", line)\n return None","def _format_globalpars(self, staticneighs, ifdistance, format_level):\n ## Basic information how it will be input neighs_info\n self.level = format_level\n ## Global known information about relative position\n self.ifdistance = ifdistance\n ## Global known information about get information\n self.staticneighs = staticneighs\n ## Setting changable information about static neighs setting\n self.staticneighs_set = None\n if self.level is None:\n self.staticneighs_set = None\n elif self.level <= 2:\n self.staticneighs_set = True\n if self.level == 3:\n self.staticneighs_set = False","def _parse(line: str) -> Tuple[int, str, str, bool]:\n level, tag, args = None, None, None\n try:\n # Try to split the line into three parts, then try two parts\n try:\n level, tag, args = line.split(' ', maxsplit=2)\n except ValueError:\n try:\n level, tag = line.split(' ', maxsplit=1)\n except ValueError:\n raise InvalidLineException(f'Invalid line: {line}')\n\n # INDI nor FAM should not be the tag\n if tag in ('INDI', 'FAM'):\n raise InvalidLineException(f'Invalid tag {line}')\n\n # If INDI or FAM are args, swap the args and tag\n if args in ('INDI', 'FAM'):\n temp = args\n args = tag\n tag = temp\n\n # Level must be between 0 and 2 inclusive\n if level not in ('0', '1', '2'):\n raise InvalidLineException(f'Invalid level: {level}')\n level = int(level)\n\n # Allow a trailing space\n if args == '':\n args = None\n\n if tag == 'INDI':\n assert level == 0\n assert args is not None\n elif tag == 'NAME':\n assert level == 1\n assert args is not None\n elif tag == 'SEX':\n assert level == 1\n assert args in ('M', 'F')\n elif tag == 'BIRT':\n assert level == 1\n assert args is None\n elif tag == 'DEAT':\n assert level == 1\n assert args is None\n elif tag == 'FAMC':\n assert level == 1\n assert args is not None\n elif tag == 'FAMS':\n assert level == 1\n assert args is not None\n elif tag == 'FAM':\n assert level == 0\n assert args is not None\n elif tag == 'MARR':\n assert level == 1\n assert args is None\n elif tag == 'HUSB':\n assert level == 1\n assert args is not None\n elif tag == 'WIFE':\n assert level == 1\n assert args is not None\n elif tag == 'CHIL':\n assert level == 1\n assert args is not None\n elif tag == 'DIV':\n assert level == 1\n assert args is None\n elif tag == 'DATE':\n assert level == 2\n assert args is not None\n # Date must have valid args\n try:\n day, month, year = args.split(' ', maxsplit=2)\n except ValueError:\n raise InvalidLineException(f'Not enough values for DATE: {args}')\n assert day == '0' or not day[0] == '0' and day.isdigit()\n assert month in ('JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC')\n assert len(year) == 4 and year.isdigit()\n elif tag == 'HEAD':\n assert level == 0\n assert args is None\n elif tag == 'TRLR':\n assert level == 0\n assert args is None\n elif tag == 'NOTE':\n assert level == 0\n else:\n raise InvalidLineException(f'Unknown Tag: {tag}')\n except (AssertionError, InvalidLineException):\n return level, tag, args, False\n\n return level, tag, args, True","def arduinoLineToDictionary(self, line):\n\n # Temperatures have the following syntax:\n # name=TempX,serial_num=blahblah,value=50,units=F\n\n # Analog pin outputs have the following syntax:\n # analogpin:name=PinX,pin_num=X,value=val\n\n # Digital pins have the following syntax:\n # digitalpin:name=PinX,pin_num=X,value=val\n\n # For the temperature sensors, it has to find the serial number, then populate the\n # Temperature value in the ard_dictionary\n\n # For the pressure sensors, it has to find an analog pin_num, then match that to the one in the ard_dictionary\n\n # For the heaters and pumps, it has to find a digital pin_num, then match that to the one in the ard_dictionary\n\n # Split the serial read text by colons to get the type of data and the data itself\n serial_read_input_list = line.split(\":\")\n\n try:\n # First entry is the type, the rest is the data\n type_of_data = serial_read_input_list[0]\n data = serial_read_input_list[1]\n except:\n return\n\n if type_of_data == \"tempsensor\":\n self.process_temp_data(data)\n\n if type_of_data == \"analogpin\":\n self.process_pressure_data(data)\n\n if type_of_data == \"digitalpin\":\n self.process_heater_pump_data(data)","def _result_to_dict(line):\n f = line.split(':;')\n return {'server': f[0], 'os_name': f[1], 'status': f[2], 'ipv4': f[3]}","def process_line(self,\n event_file,\n raw_log_line,\n header_length=29,\n log_filename=\"\"):\n\n event_data = {}\n for filter_name, regex in self._filters_dict.items():\n match = regex.search(raw_log_line)\n if match:\n match_data = match.groups()\n event_data[filter_name] = match_data\n\n if event_data:\n if log_filename:\n event_data[\"log_filename\"] = log_filename\n event_data[\"raw_log_line\"] = raw_log_line.rstrip()[header_length:]\n event_data[\"system_timestamp\"] = raw_log_line[1:27]\n event_data[\"matched_timestamp\"] = \\\n datetime.datetime.now().strftime(TIMESTAMP_FORMAT)\n event_file.write(json.dumps(event_data) + \"\\n\")\n event_file.flush()","def _parse_head(line):\n retval = {}\n m = re.match(\n '[0-9]+: (?P<if>\\w+\\d{1,3}): <(?P<flags>[^>]+)> mtu (?P<mtu>[0-9]+)',\n line\n )\n if m:\n retval['ifname'] = m.group('if')\n retval['mtu'] = int(m.group('mtu'))\n retval['flags'] = m.group('flags').split(',')\n return retval","def __parseLine(line):\n\n # extract name\n name_len = line.index(\" \")\n name = line[:name_len]\n line = line[name_len + 3:]\n\n # array-ize 'electron' val\n elec_pos = line.index(\"electron\") + 9\n line = line[:elec_pos] + '[' + line[elec_pos:].replace(' ', ',') + ']'\n\n # quote 'small' val\n line = line.replace(' ', '')\n line = line.replace('small:', 'small:\"').replace(',molar', '\",molar')\n\n # quote all keys\n for i in [\"position\", \"number\", \"small\", \"molar\", \"electron\"]:\n line = line.replace(i, '\"' + i + '\"')\n\n return eval('{\"name\":\"' + name + '\",' + line + '}')","def _collect_line_info(self, dso, real_path, addr_shifts):\n # 1. Collect addrs to send to addr2line.\n addr_set = set()\n for addr in dso.addrs:\n addr_obj = dso.addrs[addr]\n if addr_obj.source_lines: # already has source line, no need to search.\n continue\n for shift in addr_shifts:\n # The addr after shift shouldn't change to another function.\n shifted_addr = max(addr + shift, addr_obj.func_addr)\n addr_set.add(shifted_addr)\n if shifted_addr == addr_obj.func_addr:\n break\n if not addr_set:\n return\n addr_request = '\\n'.join(['%x' % addr for addr in sorted(addr_set)])\n\n # 2. Use addr2line to collect line info.\n try:\n subproc = subprocess.Popen([self.addr2line_path, '-ai', '-e', real_path],\n stdin=subprocess.PIPE, stdout=subprocess.PIPE)\n (stdoutdata, _) = subproc.communicate(str_to_bytes(addr_request))\n stdoutdata = bytes_to_str(stdoutdata)\n except:\n return\n addr_map = {}\n cur_line_list = None\n for line in stdoutdata.strip().split('\\n'):\n if line[:2] == '0x':\n # a new address\n cur_line_list = addr_map[int(line, 16)] = []\n else:\n # a file:line.\n if cur_line_list is None:\n continue\n # Handle lines like \"C:\\Users\\...\\file:32\".\n items = line.rsplit(':', 1)\n if len(items) != 2:\n continue\n if '?' in line:\n # if ? in line, it doesn't have a valid line info.\n # An addr can have a list of (file, line), when the addr belongs to an inlined\n # function. Sometimes only part of the list has ? mark. In this case, we think\n # the line info is valid if the first line doesn't have ? mark.\n if not cur_line_list:\n cur_line_list = None\n continue\n (file_path, line_number) = items\n line_number = line_number.split()[0] # Remove comments after line number\n try:\n line_number = int(line_number)\n except ValueError:\n continue\n file_id = self._get_file_id(file_path)\n cur_line_list.append((file_id, line_number))\n\n # 3. Fill line info in dso.addrs.\n for addr in dso.addrs:\n addr_obj = dso.addrs[addr]\n if addr_obj.source_lines:\n continue\n for shift in addr_shifts:\n shifted_addr = max(addr + shift, addr_obj.func_addr)\n lines = addr_map.get(shifted_addr)\n if lines:\n addr_obj.source_lines = lines\n break\n if shifted_addr == addr_obj.func_addr:\n break","def parse(line, half=1):\n line = line.strip()\n logger.debug(\"LINE '%s'\", line)\n\n global aipname, alonging, ats_chapter, coords_wrap, obj, feature\n global features, finalcoord, lastn, laste, lastv, airsport_intable\n global border, re_coord3, country\n global sectors, name_cont, cold_resp\n\n if line==LINEBREAK:\n # drop current feature, if we don't have vertl by now,\n # then this is just an overview polygon\n feature = {\"properties\":{}}\n obj = []\n alonging = False\n coords_wrap = \"\"\n lastv = None\n return\n\n\n if ad_aip and not \"ENNO\" in filename:\n if not ats_chapter:\n # skip to chapter 2.71\n if \"ATS airspace\" in line or \"ATS AIRSPACE\" in line:\n logger.debug(\"Found chapter 2.71\")\n ats_chapter=True\n return\n else:\n # then skip everything after\n if \"AD 2.\" in line or \"ATS COMM\" in line:\n #if \"ATS komm\" in line or \"Kallesignal\" in line:\n logger.debug(\"End chapter 2.71\")\n ats_chapter=False\n\n class_=re_class.search(line) or re_class2.search(line) or re_class_openair.search(line)\n if class_:\n logger.debug(\"Found class in line: %s\", line)\n class_=class_.groupdict()\n feature['properties']['class']=class_.get('class')\n if tia_aip:\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\n return\n\n # SPECIAL CASE temporary workaround KRAMFORS\n if aipname and (\"KRAMFORS\" in aipname) and (\"within\" in line):\n return\n # SPECIAL CASE workaround SÄLEN/SAAB CTR sectors\n if aipname and ((\"SÄLEN\" in aipname) or (\"SAAB\" in aipname)) and (\"Sector\" in line):\n logger.debug(\"TEST: Breaking up SÄLEN/SAAB, aipname=.\"+aipname)\n sectors.append((aipname, obj))\n feature, obj = {\"properties\":{}}, []\n if \"SÄLEN\" in aipname:\n aipname = \"SÄLEN CTR \"+line\n else:\n aipname = \"SAAB CTR \"+line\n # SPECIAL CASE check for Valldal AIP names\n if valldal and 'Valldal' in line:\n aipname=\" \".join(line.strip().split()[0:2])\n logger.debug(\"Valldal aipname: '%s'\", aipname)\n feature['properties']['class']='Luftsport'\n feature['properties']['from (ft amsl)']=0\n feature['properties']['from (m amsl)'] =0\n\n coords = re_coord.search(line)\n coords2 = re_coord2.search(line)\n coords3 = re_coord3.findall(line)\n\n if (coords or coords2 or coords3):\n\n logger.debug(\"Found %i coords in line: %s\", coords3 and len(coords3) or 1, line)\n logger.debug(printj(coords3))\n if line.strip()[-1] == \"N\":\n coords_wrap += line.strip() + \" \"\n logger.debug(\"Continuing line after N coordinate: %s\", coords_wrap)\n return\n elif coords_wrap:\n nline = coords_wrap + line\n logger.debug(\"Continued line: %s\", nline)\n coords = re_coord.search(nline)\n coords2 = re_coord2.search(nline)\n coords3 = re_coord3.findall(nline)\n logger.debug(\"Found %i coords in merged line: %s\", coords3 and len(coords3) or '1', nline)\n line = nline\n coords_wrap = \"\"\n\n if coords and not (\"Lyng\" in aipname or \"Halten\" in aipname):\n coords = coords.groupdict()\n n = coords.get('cn') or coords.get('n')\n e = coords.get('ce') or coords.get('e')\n #n = coords.get('n') or coords.get('cn')\n #e = coords.get('e') or coords.get('ce')\n rad = coords.get('rad')\n if not rad:\n rad_m = coords.get('rad_m')\n if rad_m:\n rad = m2nm(rad_m)\n if not n or not e or not rad:\n coords_wrap += line.strip() + \" \"\n # FIXME: incomplete circle continuation is broken\n logger.debug(\"Continuing line after incomplete circle: %s\", coords_wrap)\n return\n lastn, laste = n, e\n logger.debug(\"Circle center is %s %s %s %s\", coords.get('n'), coords.get('e'), coords.get('cn'), coords.get('ce'))\n logger.debug(\"COORDS is %s\", json.dumps(coords))\n c_gen = gen_circle(n, e, rad)\n logger.debug(\"LENS %s %s\", len(obj), len(c_gen))\n obj = merge_poly(obj, c_gen)\n logger.debug(\"LENS %s %s\", len(obj), len(c_gen))\n\n elif coords2:\n coords = coords2.groupdict()\n n = coords.get('n')\n e = coords.get('e')\n if n is None and e is None:\n n,e = lastn, laste\n secfrom = coords.get('secfrom')\n secto = coords.get('secto')\n radfrom = coords.get('radfrom')\n radto = coords.get('rad')\n c_gen = gen_sector(n, e, secfrom, secto, radfrom, radto)\n\n obj = merge_poly(obj, c_gen)\n\n else:\n skip_next = 0\n for blob in coords3:\n ne,n,e,along,arc,rad,cn,ce = blob[:8]\n circle = blob[8] if len(blob)==9 else None\n logger.debug(\"Coords: %s\", (n,e,ne,along,arc,rad,cn,ce,circle))\n if skip_next > 0 and n:\n logger.debug(\"Skipped.\")\n skip_next -= 1\n continue\n if arc:\n arcdata = re_arc.search(line)\n if not arcdata:\n coords_wrap += line.strip() + \" \"\n logger.debug(\"Continuing line after incomplete arc: %s\", coords_wrap)\n return\n arcdata = arcdata.groupdict()\n logger.debug(\"Completed arc: %s\", arcdata)\n n = arcdata['n']\n e = arcdata['e']\n rad = arcdata.get('rad1') or arcdata.get('rad2')\n arc = gen_circle(n, e, rad, convert=False)\n to_n = arcdata['n2']\n to_e = arcdata['e2']\n cw = arcdata['dir']\n logger.debug(\"ARC IS \"+cw)\n fill = fill_along(obj[-1],(to_n,to_e), arc, (cw=='clockwise'))\n lastn, laste = None, None\n\n for apair in fill:\n bn, be = ll2c(apair)\n obj.insert(0,(bn,be))\n skip_next = 1\n elif circle:\n coords_wrap += line.strip() + \" \"\n # FIXME: incomplete circle continuation is broken\n logger.debug(\"Continuing line after incomplete circle (3): %s\", coords_wrap)\n return\n\n\n if alonging:\n if not n and not e:\n n, e = lastn, laste\n fill = fill_along(alonging, (n,e), border)\n alonging = False\n lastn, laste = None, None\n #HACK matching point in the wrong direction - FIXME don't select closest but next point in correct direction\n if \"Sälen TMA b\" in aipname or \"SÄLEN CTR Sector b\" in aipname:\n fill=fill[1:]\n for bpair in fill:\n bn, be = ll2c(bpair)\n obj.insert(0,(bn,be))\n\n if rad and cn and ce:\n c_gen = gen_circle(cn, ce, rad)\n logger.debug(\"Merging circle using cn, ce.\")\n obj = merge_poly(obj, c_gen)\n if n and e:\n lastn, laste = n, e\n obj.insert(0,(n,e))\n if along:\n if not n and not e:\n n, e = lastn, laste\n alonging = (n,e)\n if '(' in ne:\n finalcoord = True\n logger.debug(\"Found final coord.\")\n else:\n finalcoord = False\n if (airsport_aip or aip_sup or military_aip) and finalcoord:\n if feature['properties'].get('from (ft amsl)') is not None:\n logger.debug(\"Finalizing: finalcoord.\")\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\n lastv = None\n\n if not valldal:\n return\n\n # IDENTIFY temporary restrictions\n period = re_period.search(line) or re_period2.search(line) or re_period3.search(line)\n\n if cold_resp and not feature.get('properties',{}).get('temporary'):\n logger.debug(\"Adding temporary restriction to cold response airspace.\")\n feature['properties']['temporary'] = True\n feature['properties']['dashArray'] = \"5 5\"\n feature['properties']['Date from'] = [\"14 MAR\"]\n feature['properties']['Date until'] = [\"31 MAR\"]\n feature['properties']['Time from (UTC)'] = \"0000\"\n feature['properties']['Time to (UTC)'] = \"2359\"\n\n # IDENTIFY frequencies\n freq = re_freq.search(line)\n if freq:\n freq = freq.groupdict()\n logger.debug(\"Found FREQUENCY: %s\", freq['freq'])\n feature['properties']['frequency'] = freq.get('freq')\n\n # IDENTIFY altitude limits\n vertl = re_vertl_upper.search(line) or re_vertl_lower.search(line) or re_vertl.search(line) or re_vertl2.search(line) or (military_aip and re_vertl3.search(line))\n\n if vertl:\n vertl = vertl.groupdict()\n logger.debug(\"Found vertl in line: %s\", vertl)\n fromamsl, toamsl = None, None\n\n v = vertl.get('ftamsl')\n flfrom = vertl.get('flfrom')\n flto = vertl.get('flto')\n fl = vertl.get('fl')\n rmk = vertl.get('rmk')\n\n if rmk is not None:\n v = 14999 # HACK: rmk = \"Lower limit of controlled airspace -> does not affect us\"\n if fl is not None:\n v = int(fl) * 100\n\n if flto is not None:\n toamsl = int(flto) * 100\n if flfrom:\n fromamsl = v or (int(flfrom) * 100)\n fl = fl or flfrom\n elif flfrom is not None:\n fromamsl = int(flfrom) * 100\n fl = fl or flfrom\n elif v is not None:\n if lastv is None:\n toamsl = v\n if fl is not None:\n flto = fl\n else:\n fromamsl = v\n else:\n fromamsl = vertl.get('msl',vertl.get('gnd',vertl.get('from')))\n if fromamsl == \"GND\": fromamsl = 0\n if fromamsl == \"MSL\": fromamsl = 0\n toamsl = vertl.get('unl',vertl.get('to'))\n if toamsl == \"UNL\": toamsl = 999999\n\n if toamsl is not None:\n lastv = toamsl\n currentv = feature['properties'].get('to (ft amsl)')\n if currentv is not None and currentv != toamsl:\n logger.warning(\"attempt to overwrite vertl_to %s with %s.\" % (currentv, toamsl))\n if int(currentv) > int(toamsl):\n logger.warning(\"skipping.\")\n return\n logger.warning(\"ok.\")\n if flto is not None:\n feature['properties']['to (fl)']=flto\n feature['properties']['to (ft amsl)']=toamsl\n feature['properties']['to (m amsl)'] = ft2m(toamsl)\n if valldal:\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\n lastv = None\n if fromamsl is not None:\n currentv = feature['properties'].get('from (ft amsl)')\n if currentv is not None and currentv != fromamsl:\n logger.warning(\"attempt to overwrite vertl_from %s with %s.\" % (currentv, fromamsl))\n if int(currentv) < int(fromamsl):\n logger.warning(\"skipping.\")\n return\n logger.warning(\"ok.\")\n if fl is not None:\n feature['properties']['from (fl)']=fl\n feature['properties']['from (ft amsl)']=fromamsl\n feature['properties']['from (m amsl)'] = ft2m(fromamsl)\n lastv = None\n if (((cta_aip or airsport_aip or aip_sup or tia_aip or (aipname and (\"TIZ\" in aipname))) and (finalcoord or tia_aip_acc)) or country != 'EN'):\n logger.debug(\"Finalizing poly: Vertl complete.\")\n if aipname and ((\"SÄLEN\" in aipname) or (\"SAAB\" in aipname)) and len(sectors)>0:\n for x in sectors[1:]: # skip the first sector, which is the union of the other sectors in Swedish docs\n aipname_, obj_ = x\n logger.debug(\"Restoring \"+aipname_+\" \"+str(len(sectors)))\n feature_ = deepcopy(feature)\n logger.debug(\"Finalizing SAAB/SÄLEN: \" + aipname_)\n finalize(feature_, features, obj_, source, aipname_, cta_aip, restrict_aip, aip_sup, tia_aip)\n sectors = []\n logger.debug(\"Finalizing last poly as .\"+aipname)\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\n\n logger.debug(\"From %s to %s\", feature['properties'].get('from (ft amsl)'), feature['properties'].get('to (ft amsl)'))\n return\n\n # IDENTIFY airspace naming\n name = re_name.search(line) or re_name2.search(line) or re_name3.search(line) or re_name4.search(line) or \\\n re_miscnames.search(line) or re_name5.search(line) or re_name_cr.search(line) or re_name6.search(line) or \\\n re_name_openair.search(line)\n\n if name_cont and not 'Real time' in line:\n aipname = aipname + \" \" + line\n logger.debug(\"Continuing name as \"+aipname)\n if line == '' or 'EN D' in aipname:\n name_cont = False\n\n if name:\n named=name.groupdict()\n if en_enr_5_1 or \"Hareid\" in line:\n logger.debug(\"RESTRICT/HAREID\")\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\n lastv = None\n\n name=named.get('name')\n if 'polaris' in name.lower() and 'norway' in name.lower():\n pos = name.lower().index('norway')\n name = name[:pos]\n\n if name[:6]==\"Sector\" and \"ACC\" in aipname:\n return\n\n if named.get('name_cont'):\n name += ' '+named.get('name_cont')\n name_cont=True\n\n if (name == \"Sector a\") or (name == \"Sector b\") or (aipname and (\"Sector\" in aipname) and ((\"SÄLEN\" in aipname) or (\"SAAB\" in aipname))):\n return\n if \"ES R\" in name or \"ES D\" in name:\n name_cont=True\n if \"EN D\" in name and len(name)<8:\n name_cont=True\n\n if restrict_aip or military_aip:\n if feature['properties'].get('from (ft amsl)') is not None and (feature['properties'].get('to (ft amsl)') or \"Romerike\" in aipname or \"Oslo\" in aipname):\n logger.debug(\"RESTRICT/MILITARY + name and vertl complete\")\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\n lastv = None\n else:\n logger.debug(\"RESTRICT/MILITARY + name and vertl NOT complete\")\n\n aipname = name\n logger.debug(\"Found name '%s' in line: %s\", aipname, line)\n return\n\n # The airsport document doesn't have recognizable airspace names\n # so we just assume every line that isn't otherwise parsed is the name of the next box.\n if airsport_aip and line.strip():\n logger.debug(\"Unhandled line in airsport_aip: %s\", line)\n if wstrip(line)==\"1\":\n logger.debug(\"Starting airsport_aip table\")\n airsport_intable = True\n elif wstrip(line)[0] != \"2\" and airsport_intable:\n logger.debug(\"Considering as new aipname: '%s'\", line)\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\n aipname = wstrip(line)\n\n if line.strip()==\"-+-\":\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)","def learn(self, line):\n value = self.find(line)\n if value is not \"notfound\" and not value in self._insts:\n self._insts[value] = \"%s_%d\" % (self._clean_name, len(self._insts) - self._num_defaults + 1)\n #if the line type requires multiple values to be replaced, do that instead of only searching for one\n elif self._top_key != \"none\":\n top_components = line.split(\",\")\n for comp in top_components:\n samples = comp.split(\"=\")\n if self._top_key in samples[0]:\n if samples[1] not in self._insts:\n self._insts[samples[1]] = \"%s_%d\" % (self._clean_name, len(self._insts) - self._num_defaults + 1)\n print self._insts[samples[1]]","def _parse(self):\n with open(self.input) as f:\n for line in f:\n if not line.lstrip().startswith(\"#\"): # comment\n stripped_line=line.split(\"#\")[0].strip()\n \n # Initialise an empty option dictionary with some good defaults\n if \"[\" in stripped_line:\n molname=stripped_line.split()[1]\n self.options[molname]=self.empty_option_dict.copy() # dict1=dict2 does not copy!\n self.options[molname][\"MolName\"]=molname\n if \":\" in stripped_line: \n # now process line by line\n if \"{\" not in stripped_line:\n key,value=[i.strip() for i in stripped_line.split(\":\")]\n\n if key not in self.options[molname].keys():\n raise BaseException(\"Option \\\"{}\\\" not known, please check your input file\".format(key))\n self.options[molname][key]=value \n else:\n # This is to define special lines that are given by a dictionary\n key,value=stripped_line.split(\":\",1) # split on first occurence\n if key==\"Addon\": # additional atoms to be added per molecule\n addondict=self.empty_addon_dict.copy()\n addondict_string = value.split(\"}\",-1)[0].split(\"{\",1)[1]\n for pair in addondict_string.split(\",\"):\n addonkey,addonvalue=[i.strip() for i in pair.split(\":\")]\n if addonkey not in addondict.keys():\n raise BaseException(\"Option \\\"{}\\\" in Addon section of molecule {} not known, please check your input file\".format(addonkey,molname))\n addondict[addonkey]=addonvalue\n value=addondict\n # Since addon keyword can be used many times, this is a list\n self.options[molname][key].append(value) \n self._check()","def __init__(self, line):\n (self.timestamp, self.status_code, self.content_length, self.url, self.hop_path, self.via,\n self.mime, self.thread, self.start_time_plus_duration, self.hash, self.source,\n self.annotation_string) = re.split(\" +\", line.strip(), maxsplit=11)\n # Account for any JSON 'extra info' ending, strip or split:\n if self.annotation_string.endswith(' {}'):\n self.annotation_string = self.annotation_string[:-3]\n elif ' {\"' in self.annotation_string and self.annotation_string.endswith('}'):\n self.annotation_string, self.extra_json = re.split(re.escape(' {\"'), self.annotation_string, maxsplit=1)\n self.extra_json = '{\"%s' % self.extra_json\n # And split out the annotations:\n self.annotations = self.annotation_string.split(',')\n\n # Some regexes:\n self.re_ip = re.compile('^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$')\n self.re_tries = re.compile('^\\d+t$')\n self.re_dol = re.compile('^dol:\\d+') # Discarded out-links - make a total?","def sanitize(self, line):\n self.line_count = self.line_count + 1\n components = line.split(\",\")\n for comp in components:\n # if any field has IP in it, see if the value matches something in the dict\n items = comp.split(\"=\")\n if \"ip\" in items[0]:\n if items[1] in self._insts:\n # found this dirty IP in our learned dictionary, replace it\n dirty_ip = items[1]\n clean_ip = self._insts[dirty_ip]\n line = re.sub(dirty_ip, clean_ip, line, 1)\n\n # if this message has a pdu, clean up the pdu too\n msg_type = self._extract_by_key(line, \"type\")\n if \"sflow\" in msg_type or \"event\" in msg_type:\n pdu = self._extract_by_key(line, \"pdu\")\n # substitute the converted IP based on type\n if \".\" in dirty_ip:\n # v4\n line = re.sub(self._v4_string_to_hex(dirty_ip),\n self._v4_string_to_hex(clean_ip), line)\n\n pdu = self.fix_checksum(pdu)\n\n line = line[0: (line.find(\"pdu=\")) +4] + pdu + \",\\n\"\n else:\n # v6 - remove : and go to lower case before swap\n dirty_swap = re.sub(\":\", \"\", dirty_ip)\n dirty_swap = dirty_swap.lower()\n line = re.sub(dirty_swap, self._v4_string_to_hex(clean_ip), line)\n if (args.hexdump):\n pdu_hex = pdu\n pdu_hex = \" \".join(pdu_hex[i:i+2] for i in range(0, len(pdu_hex), 2)) #put timestamp and offset in front of pdu hex\n pdu_hex = pdu[0:15] + \" 000000 \" + pdu_hex + \" ,\\n\"\n hexdump_file.write(pdu_hex)\n return line","def parse_entry(self, entry_string):\n entry_type, entry_string = self.pop_entry_type(entry_string)\n cite_key, entry_string = self.pop_key(entry_string)\n field_dict = dict(self.extract_fields(entry_string))\n field_dict[\"type\"] = entry_type\n self.force_field.citations[cite_key] = field_dict","def parse_line(line, key):\n keys = key.split(', ')\n ParseLine = (line.get(id) for id in keys)\n\n return ParseLine","def parse_wrapper_line(line, linecnt):\n #pylint: disable=unbalanced-tuple-unpacking\n wrapinfo = {}\n lineparts = miscutils.fwsplit(line.strip())\n if len(lineparts) == 5:\n (wrapinfo['wrapnum'], wrapinfo['wrapname'], wrapinfo['wclfile'], wrapinfo['wrapdebug'], wrapinfo['logfile']) = lineparts\n elif len(lineparts) == 4:\n (wrapinfo['wrapnum'], wrapinfo['wrapname'], wrapinfo['wclfile'], wrapinfo['logfile']) = lineparts\n wrapinfo['wrapdebug'] = 0 # default wrapdebug\n else:\n print \"Error: incorrect number of items in line #%s\" % linecnt\n print \" Check that modnamepat matches wrapperloop\"\n print \"\\tline: %s\" % line\n raise SyntaxError(\"Error: incorrect number of items in line #%s\" % linecnt)\n #wrapinfo['logfile'] = None\n return wrapinfo","def parseLine(self, line):\n # Removes surrounding whitespace\n line = self.separateElements(line)\n if len(line) == 0: return\n # Checks if the line is a label declaration\n if line[0].lower() == \"label\":\n # --Validates the line\n if len(line) != 2: raise Exception(\"Invalid Label\")\n if len(line[1]) < 2: raise Exception(\"Invalid Label\") \n if line[1][-1] != ':': raise Exception(\"Invalid Label\")\n # Gets the label name\n labelName = line[1][:-1]\n\n # Creates a new symbol entry for the label, the pointer refers to the memory location of the label\n # It defaults to the location of the label in the instruction sequence\n self.symbolTable.append({ \"type\": \"LABEL\", \"name\": labelName, \"pointer\": len(self.instructionList) * 4})\n # Checks if the line is data declaration\n elif line[0].lower() == \"data\" or (line[0].lower()[:4] == \"data\" and line[0][4] == \"[\"):\n # Removes the DATA tag from the data\n line[0] = line[0][4:]\n # --Validates the line\n if len(line) < 2: raise Exception(\"Invalid DATA\")\n # Gets the data name\n dataName = line[1]\n # Stores the data length\n dataLength = 4 # A word\n # Gets any default data\n defaultData = 0\n # Stores the data type\n dataType = \"int\"\n if len(line) == 3:\n if line[2][0] == \"\\\"\" and line[2][-1] == \"\\\"\":\n dataType = \"string\"\n defaultData = line[2][1:-1]\n dataLength = len(defaultData)\n elif line[2].isnumeric():\n defaultData = line[2]\n elif line[2][-1] == 'f' and line[2][:-1].isnumeric():\n dataType = \"float\"\n defaultData = line[2][0]\n # Checks if a data length was given\n if len(line[0]) > 2 and (line[0][0] == \"[\" and line[0][-1] == \"]\"):\n data = line[0][1:-1]\n if not data.isnumeric(): raise TypeError(\"Invalid data length type\")\n dataLength = int(data)\n\n # Creates a new symbol entry for the data\n self.symbolTable.append({ \"type\": \"DATA\", \"name\": dataName, \"default\": defaultData, \"dataType\": dataType, \"length\": dataLength})\n # The line is most likely an instruction\n else:\n # --Validates the line\n #Stores the control bits\n controlBits = 1 << 5 # Sets it to 0b100000\n # Checks if the first element is control bits\n if line[0][0] == \"{\" and line[0][-1] == \"}\": # First element is control bits\n # Separates the two sections of the control bits\n controlSections = line[0].split(':')\n #Goes through the characters and constructs the control bits for the instruction\n carryBits = controlSections[0].lower()\n carryFlag = int('c' in carryBits)\n zeroFlag = int('z' in carryBits)\n negativeFlag = int('n' in carryBits)\n signedOverflowFlag = int('s' in carryBits)\n #Gets the conditions bits\n if len(controlSections) == 2:\n conditionBits = controlSections[1].lower()\n isAnd = int('x' in conditionBits)\n isOne = int('1' in conditionBits)\n #Sets the last two bits on controlBits to the conditionBits\n controlBits ^= isAnd << 1\n controlBits ^= isOne\n # Constructs the control bits section\n controlBits ^= carryFlag << 5\n controlBits ^= zeroFlag << 4\n controlBits ^= negativeFlag << 3\n controlBits ^= signedOverflowFlag << 2\n # Removes the control bits section from the line\n line.pop(0)\n # Performs this check as the controlbits element gets removed (if it existed) and so the length of the elments could be zerp\n if len(line) == 0: raise Exception(\"Invalid Instruction\")\n # --The first element is the instruction\n # Identifies the instruction from the mnemonic using the lookup table\n if line[0] in self.InstructionLookupTable:\n ins = self.InstructionLookupTable[line[0]]\n insCode = ins[\"code\"]\n insControlBits = ins['controlBits'] if ins['controlBits'] else controlBits\n # Creates a representation of the instruction, this is stored in the instructionList and is assembled later\n instrucitonRepr = {\n \"code\": insCode,\n \"controlBits\": insControlBits,\n }\n # Parses the arguments given and stores the operandStruct returned in the instruciton representation\n if len(line) > 1: instrucitonRepr[\"operand\"] = self.parseArgs(line[1:], insCode)\n self.instructionList.append(instrucitonRepr)","def parse_line(self, line):\n if self.signal_eof:\n return \"\"\n\n match = re.search(\"^([\\w\\s]+from) ([^:]+):(\\d+)(:|,)$\", line)\n if match:\n return self.parse_line_from(match)\n\n match = re.search(\"^([^:]+):(?:((?:\\d+:)?\\d+):)?(?:(error|warning|note):)?(.+)$\", line)\n if match:\n return self.parse_line_err(match)\n\n return line","def update_gene_info(ensembl_info, word, value):\n if \"gene\" in word:\n if \"id\" in word:\n ensembl_info[\"ensembl_gene_id\"] = value\n elif \"start\" in word:\n ensembl_info[\"gene_start\"] = int(value)\n elif \"end\" in word:\n ensembl_info[\"gene_end\"] = int(value)\n return ensembl_info","def _parse_line(self, line):\n with open(self._manifest.path, 'r') as manifest_file:\n if isinstance(line, str):\n assert line in self.BASE_INFORMATION.keys(), \\\n 'An attempt to get non-existent information from the manifest'\n for _ in range(self.BASE_INFORMATION[line]):\n fline = manifest_file.readline()\n return json.loads(fline)[line]\n else:\n assert self._index, 'No prepared index'\n offset = self._index[line]\n manifest_file.seek(offset)\n properties = manifest_file.readline()\n return json.loads(properties)","def _parse_file_line(line):\n # match initially added ebuilds\n match = ebuild_ADM_regex.match(line)\n if match:\n status = match.group('status')\n category = match.group('category')\n pkg = match.group('P')\n try:\n return atom_cls(f'={category}/{pkg}'), status\n except MalformedAtom:\n return None\n\n # match renamed ebuilds\n match = ebuild_R_regex.match(line)\n if match:\n status = match.group('status')\n category = match.group('category')\n pkg = match.group('P')\n try:\n return atom_cls(f'={category}/{pkg}'), status\n except MalformedAtom:\n return None","def processFileLocInfo(self):\n\t\t# If bit 1 of the flags field is set\n\t\tif int(self.header['flags']) & 2 > 0:\n\n\t\t\t# Read size of file location info\n\t\t\ttxt = self.fpLnk.read(4)\n\t\t\tself.file_loc = {}\n\t\t\tself.file_loc['size'] = struct.unpack(\"<I\", txt)[0]\n\t\t\t\t\n\t\t\t# Read size of file location info and prepend the previous read value.\n\t\t\t# Txt was prepended to remove a special condition case need to skip\n\t\t\t# the re-reading of the size field.\n\t\t\tfile_loc_raw = txt + self.fpLnk.read(self.file_loc['size'] - 4)\n\n\t\t\t# Loop throuh predefine file format, extracting field into a new data\n\t\t\t# file location header dictionary.\n\t\t\t# XXX: do we really want to clobber the dictionary we just created\n\t\t\t# and not self.file_loc.update(parseStructuredData())?\n\t\t\tself.file_loc = parseStructuredData(file_loc_raw, FILE_LOC_HEADER)\n\t\t\n\t\t\t# Process local volume info if flag is set\n\t\t\tif (self.file_loc['flags'] & 1) > 0:\n\t\t\t\tlocalVolTbl = processVolTbl(file_loc_raw, \n\t\t\t\t\tself.file_loc['local_vol_info_offset'], LOCAL_VOL_TBL)\n\t\t\t\tself.file_loc['localVolTbl'] = localVolTbl\n\t\t\t\toffset = self.file_loc['local_base_path_offset']\n\t\t\t\tbasePathname = file_loc_raw[offset:].split('\\x00')[0]\n\t\t\t\tself.file_loc['basePathname'] = basePathname\n\t\t\telse:\n\t\t\t\tself.file_loc['localVolTbl'] = None\n\n\t\t\t# Process net volume info if flag is set\n\t\t\tif (self.file_loc['flags'] & 2) > 0:\n\t\t\t\tnetVolTbl = processVolTbl(file_loc_raw, \n\t\t\t\t\tself.file_loc['net_vol_info_offset'], NET_VOL_TBL)\n\t\t\t\tself.file_loc['netVolTbl'] = netVolTbl\n\t\t\telse:\n\t\t\t\tself.file_loc['netVolTbl'] = None\n\n\t\t\t# Process remaining portion of pathname\n\t\t\toffset = self.file_loc['remain_pathname_offset']\n\t\t\tremainPathname = file_loc_raw[offset:].split('\\x00')[0]\n\t\t\tself.file_loc['remainPathname'] = remainPathname","def _read_header(self, line):\n try:\n creation_date = datetime.strptime(line[23:33], '%y%m%d%H%M')\n except ValueError as err:\n print('Error parsing file creation date -> ' + str(err))\n creation_date = '000000'\n\n self.file_header = {'Priority Code': line[1:3],\n 'Immediate Destination': line[3:13].strip(),\n 'Immediate Origin': line[13:23].strip(),\n 'Creation Date': creation_date,\n 'File ID Modifier': line[33],\n 'Record Size': int(line[34:37].strip()),\n 'Blocking Factor': int(line[37:39]),\n 'Format Code': line[39],\n 'Immediate Destination Name': line[40:63].strip(),\n 'Immediate Origin Name': line[63:86].strip(),\n 'Reference Code': line[86:93]}","def process_line(self, line, data):\n return data","def _read_header_line_1(self, lines: list) -> dict:\n fields = (\n \"model_id\",\n \"unit_id\",\n \"software_level\",\n \"message_number\",\n \"message_subclass\",\n )\n if self._is_ct25k():\n indices = [1, 3, 4, 6, 7, 8]\n else:\n indices = [1, 3, 4, 7, 8, 9]\n values = [split_string(line, indices) for line in lines]\n return values_to_dict(fields, values)","def _parse(self):\n\n self.specification = {}\n\n while True:\n try:\n line = self._lines.current\n if ':' in line:\n self.specification.update(self._parse_spec())\n elif line.startswith('NODE_COORD_SECTION'):\n next(self._lines)\n self.coords = self._parse_coords()\n elif line.startswith('EDGE_WEIGHT_SECTION'):\n next(self._lines)\n self.weights = self._parse_weights()\n elif line.startswith('DISPLAY_DATA_SECTION'):\n next(self._lines)\n self.display = self._parse_coords()\n else:\n break\n except StopIteration:\n break\n\n del self._lines","def ReadBasicInfo():\r\n\r\n EquilibriumStep, ProductionStep,HEPCP,HEPCE,Multiple=10000000,10000000,100,100,2\r\n InputPath,OutputPath,AtomParameterPath,TaskSuffix,MaterialInputFormat='..','..','..','','mol'\r\n GasType,GasAtomTypeNum,GasAtomType,GasPartialPressure,TemperatureList,PressureList,\\\r\n TorqueSetting,MuSiCSetting,Nodes=[],[],[],[],[],[],[],[],['1:ppn=1']\r\n CutOff,GridSpacingP,GridSpacingE=12.8,2.0,2.0\r\n MakeGCMC,UsePmap,UseEmap,UsePost,MakePmap,MakeEmap,MakeTorque,KeyOne,KeyTwo,\\\r\n PDBCharges = False,False,False,False,False,False,False,False,False,False\r\n\r\n with open('GlueParameters', 'r') as File:\r\n for Line in File.readlines():\r\n if Line.strip():\r\n WordList = Line.strip().split()\r\n if len(WordList)>1 or KeyOne==True or KeyTwo==True:\r\n if WordList[0]=='#':\r\n continue\r\n\r\n # Controlled part\r\n elif WordList[0] == 'MakeGCMC:' and WordList[1] == 'open':\r\n MakeGCMC = True\r\n elif WordList[0] == 'UsePmap:' and WordList[1] == 'yes':\r\n UsePmap = True\r\n elif WordList[0] == 'UseEmap:' and WordList[1] == 'yes':\r\n UseEmap = True\r\n elif WordList[0] == 'UsePost:' and WordList[1] == 'yes':\r\n UsePost = True\r\n elif WordList[0] == 'MakePmap:' and WordList[1] == 'open':\r\n MakePmap = True\r\n elif WordList[0] == 'MakeEmap:' and WordList[1] == 'open':\r\n MakeEmap = True\r\n elif WordList[0] == 'MakeTorque:' and WordList[1] == 'open':\r\n MakeTorque = True\r\n elif WordList[0] == 'UseChargesFromPDBFile:' and WordList[1] == 'yes':\r\n PDBCharges = True\r\n\r\n # Basic part\r\n elif WordList[0]=='InputPath:':\r\n InputPath=WordList[1]\r\n elif WordList[0]=='MaterialInputFormat:':\r\n MaterialInputFormat=WordList[1]\r\n elif WordList[0]=='OutputPath:':\r\n OutputPath=WordList[1]\r\n elif WordList[0]=='AtomParameterPath:':\r\n AtomParameterPath=WordList[1]\r\n elif WordList[0] == 'GasType:':\r\n GasType = list(WordList[1:])\r\n elif WordList[0] == 'GasAtomTypeNum:':\r\n\r\n for i in WordList[1:]:\r\n GasAtomTypeNum.append(int(i))\r\n\r\n elif WordList[0] == 'GasAtomType:':\r\n GasAtomType = list(WordList[1:])\r\n elif WordList[0] == 'Multiple:':\r\n Multiple = int(WordList[1])\r\n elif WordList[0] == 'CutOff:':\r\n CutOff = float(WordList[1])\r\n\r\n # GCMC part\r\n\r\n elif WordList[0] == 'GasPartialPressure:':\r\n\r\n for j in WordList[1:]:\r\n GasPartialPressure.append(str(j))\r\n\r\n elif WordList[0] == 'TemperatureList(K):':\r\n\r\n for l in WordList[1:]:\r\n TemperatureList.append(float(l))\r\n\r\n elif WordList[0] == 'PressureList(kPa):':\r\n\r\n for k in WordList[1:]:\r\n PressureList.append(float(k))\r\n\r\n elif WordList[0] == 'EquilibriumStep:':\r\n EquilibriumStep = int(WordList[1])\r\n elif WordList[0] == 'ProductionStep:':\r\n ProductionStep = int(WordList[1])\r\n\r\n # Pmap part\r\n elif WordList[0] == 'GridSpacingP(Ang):':\r\n GridSpacingP = float(WordList[1])\r\n elif WordList[0] == 'HighEndPotentialCutoffP(kJ/mol):':\r\n HEPCP = int(WordList[1])\r\n\r\n # Emap part\r\n elif WordList[0] == 'GridSpacingE(Ang):':\r\n GridSpacingE = float(WordList[1])\r\n elif WordList[0] == 'HighEndPotentialCutoffE(kJ/mol):':\r\n HEPCE = int(WordList[1])\r\n\r\n # Torque part\r\n elif WordList[0] == 'Nodes:':\r\n Nodes = WordList[1:]\r\n elif WordList[0] == 'TaskSuffix:':\r\n TaskSuffix = WordList[1]\r\n elif WordList[0] == 'TorqueSetting:':\r\n KeyOne = True\r\n elif WordList[0] == 'MuSiCSetting:':\r\n KeyOne = False\r\n KeyTwo = True\r\n elif WordList[0] == 'END':\r\n KeyTwo = False\r\n elif KeyOne == True:\r\n TorqueSetting.append(Line)\r\n elif KeyTwo == True:\r\n MuSiCSetting.append(Line)\r\n\r\n return (InputPath,OutputPath,AtomParameterPath,MakeTorque,GasType,\r\n GasAtomTypeNum,GasAtomType,GasPartialPressure,TemperatureList,PressureList,CutOff,MakeGCMC,UsePmap,\r\n UseEmap,UsePost,MakePmap,MakeEmap,EquilibriumStep,ProductionStep,GridSpacingP,HEPCP,GridSpacingE,HEPCE,\r\n Multiple,TorqueSetting,MuSiCSetting,Nodes,TaskSuffix,PDBCharges,MaterialInputFormat)","def __build_line_update(self, line):\n\n output = \"\"\n if line not in self.__line_messages_copy.keys():\n return output\n\n if self.__line_messages_copy[line][\"passengers\"]:\n output += self.__build_update_regarding_passengers(line) + \"\\n\"\n if self.__line_messages_copy[line][\"buses\"]:\n output += self.__build_update_regarding_buses(line) + \"\\n\"\n if self.__line_messages_copy[line][\"kick reason\"] != \"\" and self.__line_messages_copy[line][\n \"kick_reason\"] not in self.__global_messages_copy[\"kick reason\"]:\n output += f\"kicked for:{self.__line_messages_copy[line]['kick reason']}\" + \"\\n\"\n if self.__line_messages_copy[line][\"free text\"] != \"\" and self.__line_messages_copy[line][\"free text\"] not in \\\n self.__global_messages_copy[\"free text\"]:\n output += \"free text:\" + self.__line_messages_copy[line][\"free text\"] + \"\\n\"\n return output","def HST_info(info_file):\n info_values = {}\n f = open(info_file, 'r')\n # the first line must contain PyHST or NUM_X\n line = f.readline()\n if line.startswith('! PyHST'):\n # read an extra line\n line = f.readline()\n elif line.startswith('NUM_X'):\n pass\n else:\n sys.exit('The file does not seem to be a PyHST info file')\n info_values['x_dim'] = int(line.split()[2])\n info_values['y_dim'] = int(f.readline().split()[2])\n info_values['z_dim'] = int(f.readline().split()[2])\n try:\n info_values['data_type'] = f.readline().split()[2]\n except IndexError:\n pass\n return info_values","def update(self, line):","def _process_info_message(self, message):\n # Extract the output resolution from the appropriate message, if\n # it's present.\n contents = message.get('contents', None)\n if message['messageCode'] == 'JOB_RUNNING_RESOLUTION':\n self._resolution = contents['resolutionMs']\n elif message['messageCode'] == 'FETCH_NUM_TIMESERIES':\n self._num_input_timeseries += int(message['numInputTimeSeries'])\n elif message['messageCode'] == 'FIND_MATCHED_NO_TIMESERIES':\n self._find_matched_no_timeseries = True\n elif message['messageCode'] == 'FIND_LIMITED_RESULT_SET':\n self._find_limited_resultset = True\n self._find_matched_size = contents['matchedSize']\n self._find_limit_size = contents['limitSize']\n elif message['messageCode'] == 'GROUPBY_MISSING_PROPERTY':\n self._group_by_missing_property = True\n self._group_by_missing_properties = contents['propertyNames']","def _parse_header(self, line):\n if self._regex_helper.search_compiled(W._re_header, line):\n if not self.headers:\n for value in re.findall(W._re_header, line):\n self.headers.append(value[0])\n raise ParsingDone\n else:\n # Dictionary which is going to be appended to the returned list\n ret = dict()\n # List of entries\n _entries = list()\n # List of values in WHAT entry\n _what_entry = list()\n for value in re.findall(W._re_header, line):\n _entries.append(value[0])\n for what_index in range(len(self.headers) - 1, len(_entries)):\n _what_entry.append(_entries[what_index])\n _what_entry_string = ' '.join(_what_entry)\n for index in range(len(self.headers)):\n if index < len(self.headers) - 1:\n ret.update({self.headers[index]: _entries[index]})\n else:\n ret.update({self.headers[index]: _what_entry_string})\n self.current_ret['RESULT'].append(ret)\n raise ParsingDone","def parseLine(self,incoming):\n\t\tself.addContentLine(incoming)\n\t\tif incoming.mustProcess == 0: return \n\t\tself.iLineObject = incoming\n\t\titems = self.iLineObject.getItems()\n\t\tkeyword = string.upper(items[0])\n\t\tif len(items) < 2: \n\t\t\tif not keyword in self.sQuotedKeywords: \n\t\t\t\tself.addErrorMessage('2. Unrecognized keyword SIMULATOR_BLOCK:', self.iLineObject)\n\t\t\treturn\n\t\tself.parseKeyword(keyword,items[1:])","def parse_galrep_line(L):\n data = L.split(maxsplit=1)\n record = parse_galrep_data_string(\"\" if len(data) == 1 else data[1])\n record['label'] = label = data[0]\n return label, record","def process_gene_line(self, line):\n kwargs = self.extract_gene_args(line)\n if not kwargs:\n return\n gene_id = kwargs['identifier']\n self.genes[gene_id] = Gene(**kwargs)","def from_info(self, info: Dict[str, Any]) -> None:","def setup_parser(self) -> Dict[str, Any]:\n\n\n # % GALAT - SPP Single Point Positioning\n # % -------------------------------------\n # % Processing Option\n # % ------------------\n # % GNSS system(s) : GALILEO\n # % Orbit type : Broadcast - INAV\n # % Solution type : SPP\n # % Frequency : E1\n # % Elevation mask : 5.0 deg\n # % Time interval : 30.0 s\n # % Ionosphere opt : NeQuick-G\n # % Troposhere opt : GMF with GPT\n # % Obs start : 2020/01/04 00:00:00.0 GPST (week 2086 518400.0s)\n # % Obs end : 2020/01/04 23:59:30.0 GPST (week 2086 604770.0s)\n # % Epoch expected : 2880\n # % Epoch have : 2880\n # %\n # % Input file(s) : KOUG00GUF_R_20200040000_01D_30S_MO.rnx\n # % Input file(s) : CNES0030.20L\n # % Input file(s) : CNES0040.20L\n # % Input file(s) : igs14.atx\n # %\n # % RINEX header info\n # % ------------------\n # % Marker : KOUG 97301M402\n # % Receiver T/V/# : SEPT POLARX5TR 5.3.0 17323022503\n # % Antenna T/ /# : LEIAR25.R3 LEIT 10180007\n # % Position XYZ : 3855263.3407 -5049731.9986 563040.4252\n # % Antenna H/E/N : 0.0000 0.0000 0.0000\n self._parse_header()\n\n # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+--\n # 2020/01/04 00:00:00 5.098466365 -52.639742999 106.8901 -0.603 -0.821 -0.349 1.018 0.349 \n # 2020/01/04 00:00:30 5.098466094 -52.639742684 107.4962 -0.633 -0.856 0.257 1.065 0.257 \n # 2020/01/04 00:01:00 5.098466030 -52.639740961 107.6125 -0.640 -1.047 0.373 1.228 0.373 \n return dict(\n names=(\n \"yyyymmdd\", \n \"hhmmss\", \n \"latitude\", \n \"longitude\", \n \"height\", \n \"dlatitude\", \n \"dlongitude\", \n \"dheight\",\n \"hpe\",\n \"vpe\",\n \"site_vel_3d\",\n \"pdop\",\n \"num_satellite_available\",\n \"num_satellite_used\",\n ),\n comments=\"%\",\n delimiter=(10, 9, 15, 15, 10, 9, 9, 9, 9, 9, 9, 6, 4, 4),\n dtype=(\"U10\", \"U9\", \"f8\", \"f8\", \"f8\", \"f8\", \"f8\", \"f8\", \"f8\", \"f8\", \"f8\", \"f8\", \"f8\", \"f8\"),\n autostrip=True,\n )","def parse_pdb(self, line):\n super().parse_pdb(line)\n self.num_remark = int(line[10:15].strip())\n self.num_het = int(line[20:25].strip())\n self.num_helix = int(line[25:30].strip())\n self.num_sheet = int(line[30:35].strip())\n self.num_turn = int(line[35:40].strip())\n self.num_site = int(line[40:45].strip())\n self.num_xform = int(line[45:50].strip())\n self.num_coord = int(line[50:55].strip())\n self.num_ter = int(line[55:60].strip())\n self.num_conect = int(line[60:65].strip())\n self.num_seq = int(line[65:70].strip())"],"string":"[\n \"def _parse_line(self, line):\\n fields = line.split('|', 4) # stop splitting after fourth | found\\n line_info = {'raw_message': line}\\n if len(fields) == 5:\\n line_info.update(dict(zip(self._fieldnames, fields)))\\n return line_info\",\n \"def _parse_general_info_V4X(par, parfile):\\n line = None\\n while line != '':\\n pos = parfile.tell()\\n line = parfile.readline()\\n #Parse the useful parts of the general info entry on the left and\\n #right of the colon: key and value\\n m = re.search(r'\\\\. ([^<>\\\\(\\\\)\\\\[\\\\]]*[a-zA-Z]).*: *(.*)', line)\\n if not m:\\n parfile.seek(pos)\\n break\\n key, val = m.group(1, 2)\\n key = _sanitize_to_identifer(key).lower()\\n #Try to guess the type of the field by conversion\\n _val_split = val.split()\\n if len(_val_split) > 1:\\n try:\\n val = np.array(tuple(float(x) for x in _val_split))\\n except:\\n pass\\n else:\\n try:\\n val = int(val)\\n except ValueError:\\n pass\\n #logger.debug(\\\"Key = '{0}' Val = '{1}'\\\".format(key, val))\\n setattr(par.gen_info, key, val)\\n return par.gen_info\",\n \"def parse_ensembl_line(line, header):\\n line = line.rstrip().split(\\\"\\\\t\\\")\\n header = [head.lower() for head in header]\\n raw_info = dict(zip(header, line))\\n\\n ensembl_info = {}\\n\\n for word in raw_info:\\n value = raw_info[word]\\n if not value:\\n continue\\n\\n if \\\"chromosome\\\" in word:\\n ensembl_info[\\\"chrom\\\"] = value\\n if \\\"gene name\\\" in word:\\n ensembl_info[\\\"hgnc_symbol\\\"] = value\\n if \\\"hgnc id\\\" in word:\\n ensembl_info[\\\"hgnc_id\\\"] = int(value.split(\\\":\\\")[-1])\\n if \\\"hgnc symbol\\\" in word:\\n ensembl_info[\\\"hgnc_symbol\\\"] = value\\n if \\\"strand\\\" in word:\\n ensembl_info[\\\"strand\\\"] = int(value)\\n\\n update_gene_info(ensembl_info, word, value)\\n update_transcript_info(ensembl_info, word, value)\\n update_exon_info(ensembl_info, word, value)\\n update_utr_info(ensembl_info, word, value)\\n update_refseq_info(ensembl_info, word, value)\\n return ensembl_info\",\n \"def _parse_line(self, line):\\n msg_info = {'raw_message': line}\\n line_split = line.split(None, 2)\\n try:\\n msg_info['timestamp'] = datetime.strptime(' '.join(line_split[:2]), self.time_format)\\n msg_info['message'] = line_split[2]\\n except (ValueError, IndexError):\\n pass\\n return msg_info\",\n \"def get_read_group_info(line, logger=default_logger):\\n\\n rg_dict = dict()\\n #Initialize the dictionary, so we know if any fields are missing\\n rg_dict[\\\"PI\\\"] = \\\"\\\"\\n rg_dict[\\\"CN\\\"] = \\\"UNKNOWN\\\"\\n rg_dict[\\\"ID\\\"] = \\\"\\\"\\n rg_dict[\\\"PL\\\"] = \\\"UNKNOWN\\\"\\n rg_dict[\\\"LB\\\"] = \\\"\\\"\\n rg_dict[\\\"SM\\\"] = \\\"\\\"\\n rg_dict[\\\"PU\\\"] = \\\"\\\"\\n rg_dict[\\\"DT\\\"] = \\\"\\\"\\n sline = line.split('\\\\t')\\n\\n for item in sline:\\n item = item.strip()\\n\\n if(item.startswith(\\\"ID:\\\")):\\n rg_dict[\\\"ID\\\"] = item[3:]\\n elif(item.startswith(\\\"PL:\\\")):\\n rg_dict[\\\"PL\\\"] = item[3:]\\n elif(item.startswith(\\\"PU:\\\")):\\n item = item.replace(\\\".\\\", \\\"_\\\") #to agree with ICGC SOP\\n rg_dict[\\\"PU\\\"] = item[3:]\\n elif(item.startswith(\\\"LB:\\\")):\\n rg_dict[\\\"LB\\\"] = item[3:]\\n elif(item.startswith(\\\"DT:\\\")):\\n rg_dict[\\\"DT\\\"] = item[3:]\\n elif(item.startswith(\\\"SM:\\\")):\\n rg_dict[\\\"SM\\\"] = item[3:]\\n elif(item.startswith(\\\"CN:\\\")):\\n rg_dict[\\\"CN\\\"] = item[3:]\\n elif(item.startswith(\\\"PI:\\\")):\\n rg_dict[\\\"PI\\\"] = item[3:]\\n else:\\n pass\\n\\n for key,value in rg_dict.items():\\n if value == \\\"\\\":\\n logger.warning(\\\"missing RG field %s\\\" % key)\\n\\n return rg_dict\",\n \"def parse_line(self, line):\\n success = self.parser.handle_line(line)\\n if success:\\n self.data.update()\\n else:\\n self.bot.log(\\\"didn't handle line: '{}'\\\".format(line))\",\n \"def fill_project_info(self, line_read, new_format):\\n if new_format:\\n \\\"\\\"\\\" list(set()) converts list into a set to remove duplicates, but\\n does not preserve order. dict key must always be 1st element\\n in line_read else the project_info dict will not be updated\\n properly. The code below gets rid of duplicated values while\\n preserving the order of the elements in line_read. Code was\\n taken from a StackOverflow thread about the same issue. \\\"\\\"\\\"\\n tmp_list = set() # new empty set\\n tmp_add = tmp_list.add # built-in method 'add' of set object\\n temp = [x for x in line_read if not (x in tmp_list or tmp_add(x))]\\n line_read = temp\\n else:\\n line_read = line_read.split(':', 1)\\n line_read[0] = re.sub('[- ]', '', line_read[0])\\n key_name = line_read[0].lower()\\n\\n if 'sapid' in key_name:\\n self.project_info.update({'SAP ID': line_read[1].strip(' ')})\\n if 'golive' in key_name:\\n self.project_info.update({'Go Live Date': line_read[1]})\\n if 'customer' in key_name:\\n site_name = re.sub('State|Lottery', '', line_read[1])\\n site_name = site_name.strip(' ')\\n self.project_info.update({'Site': site_name})\",\n \"def process_line(self, line):\\n find_result = re.findall(LINE_REGEX, line)\\n line_data = {r[0]: r[1] for r in find_result}\\n self.process_url(line_data.get('request_to'))\\n self.process_status_code(line_data.get('response_status'))\",\n \"def getLineInformation(line):\\n \\n pass\",\n \"def parse_line(cls, line):\\n regex = re.compile(cls.pattern)\\n m = regex.search(line)\\n if m:\\n data = m.groupdict()\\n data = cls.post_process(data)\\n if cls.date_format:\\n data['time'] = cls.convert_time(data['time'])\\n else:\\n data['time'] = datetime.now()\\n return data\\n else:\\n return {}\",\n \"def _process_line(line, status):\\n\\n if line.startswith(ADAPTER_LINE_STARTSWITH):\\n status.add_block('adapter', 'name', line)\\n return\\n elif line.startswith(EXIT_LINE_STARTSWITH):\\n status.consolidate()\\n return\\n\\n key, value = [el.strip(' \\\\t\\\\r\\\\n') for el in line.split(':', 1)]\\n\\n if key in KEY_TO_CONTEXT.keys():\\n status.add_block(KEY_TO_CONTEXT[key], key, value)\\n else:\\n status.set_property(key, value)\",\n \"def parse_info(s:str) -> dict:\\n d = {}\\n d[\\\"SVTYPE\\\"] = re.search(r'(?<=SVTYPE=)\\\\w+',s).group(0)\\n d[\\\"SUPPORT\\\"] = re.search(r'(?<=SUPPORT=)\\\\d+',s).group(0)\\n if d[\\\"SVTYPE\\\"] in [\\\"BND\\\"]:\\n return d\\n d[\\\"END\\\"] = re.search(r'(?<=END=)\\\\d+',s).group(0)\\n if d[\\\"SVTYPE\\\"] in [\\\"INV\\\"]:\\n return d\\n d[\\\"SVLEN\\\"] = re.search(r'(?<=SVLEN=)(.*?)(?=;)',s).group(0)\\n d[\\\"READS\\\"] = re.search(r'(?<=READS=)(.*?)(?=$)',s).group(0).split(\\\",\\\")\\n if d[\\\"SVTYPE\\\"] == \\\"INS\\\":\\n d[\\\"SEQS\\\"] = re.search(r'(?<=SEQS=)(.*?)(?=;)',s).group(0).split(\\\",\\\")\\n return d\",\n \"def parse_line(self, line):\\n raise NotImplementedError\",\n \"def _read_info(self):\\n my_filelines = self.file_lines\\n info = dict()\\n\\n for i, line in enumerate(my_filelines):\\n if line.startswith(\\\"VEHICLE\\\"):\\n vehicle_pro_start = i + 2\\n elif line.startswith(\\\"CUSTOMER\\\"):\\n customer_pro_start = i + 3\\n\\n elif line.startswith(\\\"NUMBER\\\"):\\n splited = line.split(' ')\\n info[splited[0]] = 0\\n info[splited[-1]] = 0\\n return info, (vehicle_pro_start, customer_pro_start)\",\n \"def process_line(line):\\n\\n name_comp_list = []\\n givenname_comp_list = []\\n surname_comp_list = []\\n geocode_comp_list = []\\n locality_comp_list = []\\n date1_comp_list = []\\n date2_comp_list = []\\n\\n # Split the line into the basic fields - - - - - - - - - - - - - - - - - - -\\n #\\n if (config.in_file_type in ['CSV','CSVQ','TAB','TABQ']):\\n # Comma or tabulator separated\\n try:\\n line_list = config.line_parser.parse(line)\\n except:\\n log_message('CSV line parsing failed with inout: '+line,'err')\\n\\n if (len(line_list) < config.input_len):\\n log_message('Input line does not contain enough fields,' +\\\\\\n 'fill up with empty fields','warn')\\n while (len(line_list) < config.input_len):\\n line_list.append('')\\n\\n config.curr_line_list = line_list # Save current line list\\n\\n # Extract fields into different component lists - - - - - - - - - - - - - -\\n #\\n if (config.input_component['name'] != []): # Extract name fields\\n for i in config.input_component['name']:\\n name_comp_list.append(line_list[i])\\n\\n else: # Extract givenname and surname into separate components - - - - - -\\n if (config.input_component['givenname'] != []): # Extract g-name fields\\n for i in config.input_component['givenname']:\\n givenname_comp_list.append(line_list[i])\\n\\n if (config.input_component['surname'] != []): # Extract surname fields\\n for i in config.input_component['surname']:\\n surname_comp_list.append(line_list[i])\\n\\n if (config.input_component['geocode'] != []): # Extract geocode fields\\n for i in config.input_component['geocode']:\\n geocode_comp_list.append(line_list[i])\\n\\n if (config.input_component['locality'] != []): # Extract locality fields\\n for i in config.input_component['locality']:\\n locality_comp_list.append(line_list[i])\\n\\n if (config.input_component['date1'] != []): # Extract date1 fields\\n for i in config.input_component['date1']:\\n date1_comp_list.append(line_list[i])\\n\\n if (config.input_component['date2'] != []): # Extract date2 fields\\n for i in config.input_component['date2']:\\n date2_comp_list.append(line_list[i])\\n\\n elif (config.in_file_type == 'COL'): # Column based input file - - - - - - -\\n\\n if (len(line) < config.input_len):\\n log_message('Input line is not long enough, fill up with spaces','warn')\\n line += ' '*(config.input_len-len(line))\\n\\n if (config.input_component['name'] != []): # Extract name fields\\n for (col_start,length) in config.input_component['name']:\\n name_comp_list.append(line[col_start,col_start+length])\\n\\n else: # Extract givenname and surname into separate components - - - - - -\\n if (config.input_component['givenname'] != []): # Extract g-name fields\\n for (col_start,length) in config.input_component['givenname']:\\n givenname_comp_list.append(line[col_start,col_start+length])\\n\\n if (config.input_component['surname'] != []): # Extract surname fields\\n for (col_start,length) in config.input_component['surname']:\\n surname_comp_list.append(line[col_start,col_start+length])\\n\\n if (config.input_component['geocode'] != []): # Extract geocode fields\\n for (col_start,length) in config.input_component['geocode']:\\n geocode_comp_list.append(line[col_start,col_start+length])\\n\\n if (config.input_component['locality'] != []): # Extract locality fields\\n for (col_start,length) in config.input_component['locality']:\\n locality_comp_list.append(line[col_start,col_start+length])\\n\\n if (config.input_component['date1'] != []): # Extract date1 fields\\n for (col_start,length) in config.input_component['date1']:\\n date1_comp_list.append(line[col_start,col_start+length])\\n\\n if (config.input_component['date2'] != []): # Extract date2 fields\\n for (col_start,length) in config.input_component['date2']:\\n date2_comp_list.append(line[col_start,col_start+length])\\n\\n # elif (config.in_file_type == 'SQL'): # - - - - - - - - - - - - - - - - - -\\n\\n ################################\\n # Add later: SQL database access\\n ################################\\n\\n msg = [' Component basic field lists:', \\\\\\n ' Name: '+str(name_comp_list), \\\\\\n ' Given name: '+str(givenname_comp_list), \\\\\\n ' Surname: '+str(surname_comp_list), \\\\\\n ' Geocode: '+str(geocode_comp_list), \\\\\\n ' Locality: '+str(locality_comp_list), \\\\\\n ' Date1: '+str(date1_comp_list), \\\\\\n ' Date2: '+str(date2_comp_list)]\\n log_message(msg,'v2')\\n\\n name_comp = ''\\n givenname_comp = ''\\n surname_comp = ''\\n geocode_comp = ''\\n locality_comp = ''\\n date1_comp = ''\\n date2_comp = ''\\n\\n # Now clean and then concatenate component lists into strings - - - - - - - -\\n #\\n if (name_comp_list != []): # Name component\\n name_comp = name_comp_list[0] # Start with first field in list\\n\\n for f in name_comp_list[1:]: # Loop over following fields (if any)\\n if (f != ''):\\n if (config.input_space_sep['name'] == 1):\\n sep = ' ' # Set separator to space between fields\\n else:\\n sep = '' # No space between fields\\n\\n # Check field spilling only if space separator is set to ' ' \\n #\\n if (sep == ' ') and (config.input_check_spilling['name'] == 1):\\n sep = check_field_spill(name_comp, f)\\n\\n name_comp = name_comp+sep+f # Append separator and field\\n\\n if (givenname_comp_list != []): # Givenname component - - - - - - - - - - -\\n givenname_comp = givenname_comp_list[0] # Start with first field in list\\n\\n for f in givenname_comp_list[1:]: # Loop over following fields (if any)\\n if (f != ''):\\n if (config.input_space_sep['givenname'] == 1):\\n sep = ' ' # Set separator to space between fields\\n else:\\n sep = '' # No space between fields\\n\\n # Check field spilling only if space separator is set to ' ' \\n #\\n if (sep == ' ') and (config.input_check_spilling['givenname'] == 1):\\n sep = check_field_spill(givenname_comp, f)\\n\\n givenname_comp = givenname_comp+sep+f # Append separator and field\\n\\n if (surname_comp_list != []): # Surname component - - - - - - - - - - - - -\\n surname_comp = surname_comp_list[0] # Start with first field in list\\n\\n for f in surname_comp_list[1:]: # Loop over following fields (if any)\\n if (f != ''):\\n if (config.input_space_sep['surname'] == 1):\\n sep = ' ' # Set separator to space between fields\\n else:\\n sep = '' # No space between fields\\n\\n # Check field spilling only if space separator is set to ' ' \\n #\\n if (sep == ' ') and (config.input_check_spilling['surname'] == 1):\\n sep = check_field_spill(surname_comp, f)\\n\\n surname_comp = surname_comp+sep+f # Append separator and field\\n\\n if (geocode_comp_list != []): # Geocode component - - - - - - - - - - - - -\\n geocode_comp = geocode_comp_list[0] # Start with first field in list\\n\\n for f in geocode_comp_list[1:]: # Loop over following fields (if any)\\n if (f != ''):\\n if (config.input_space_sep['geocode'] == 1):\\n sep = ' ' # Set separator to space between fields\\n else:\\n sep = '' # No space between fields\\n\\n # Check field spilling only if space separator is set to ' ' \\n #\\n if (sep == ' ') and (config.input_check_spilling['geocode'] == 1):\\n sep = check_field_spill(geocode_comp, f)\\n\\n geocode_comp = geocode_comp+sep+f # Append separator and field\\n\\n if (locality_comp_list != []): # Locality component - - - - - - - - - - - -\\n locality_comp = locality_comp_list[0] # Start with first field in list\\n\\n for f in locality_comp_list[1:]: # Loop over following fields (if any)\\n if (f != ''):\\n if (config.input_space_sep['locality'] == 1):\\n sep = ' ' # Set separator to space between fields\\n else:\\n sep = '' # No space between fields\\n\\n # Check field spilling only if space separator is set to ' ' \\n #\\n if (sep == ' ') and (config.input_check_spilling['locality'] == 1):\\n sep = check_field_spill(locality_comp, f)\\n\\n locality_comp = locality_comp+sep+f # Append separator and field\\n\\n if (date1_comp_list != []): # Date1 component - - - - - - - - - - - - - - -\\n date1_comp = date1_comp_list[0] # Start with first field in list\\n\\n for f in date1_comp_list[1:]: # Loop over following fields (if any)\\n if (f != ''):\\n if (config.input_space_sep['date1'] == 1):\\n sep = ' ' # Set separator to space between fields\\n else:\\n sep = '' # No space between fields\\n\\n # Check field spilling only if space separator is set to ' ' \\n #\\n if (sep == ' ') and (config.input_check_spilling['date1'] == 1):\\n if (date1_comp[-1] != ' ') and (f[0] != ' '):\\n tmp_list0 = date1_comp.split()\\n tmp_list1 = f.split()\\n check_word = tmp_list0[-1]+tmp_list1[0]\\n\\n if (check_word in ['jan','feb','mar','apr','may','jun','jul','aug', \\\\\\n 'sep','oct','nov','dec','january','february','march','april', \\\\\\n 'may','june','july','august','september','october','november', \\\\\\n 'december']):\\n\\n sep = '' # Set separator to no space\\n msg = ' Correct date1 word spilling: \\\"'+date1_comp+'\\\",\\\"'+f+'\\\"'\\n log_message(msg,'v1')\\n\\n date1_comp = date1_comp+sep+f # Append separator and field\\n\\n if (date2_comp_list != []): # Date2 component - - - - - - - - - - - - - - -\\n date2_comp = date2_comp_list[0] # Start with first field in list\\n\\n for f in date2_comp_list[1:]: # Loop over following fields (if any)\\n if (f != ''):\\n if (config.input_space_sep['date2'] == 1):\\n sep = ' ' # Set separator to space between fields\\n else:\\n sep = '' # No space between fields\\n\\n # Check field spilling only if space separator is set to ' ' \\n #\\n if (sep == ' ') and (config.input_check_spilling['date2'] == 1):\\n if (date2_comp[-1] != ' ') and (f[0] != ' '):\\n tmp_list0 = date1_comp.split()\\n tmp_list1 = f.split()\\n check_word = tmp_list0[-1]+tmp_list1[0]\\n\\n if (check_word in ['jan','feb','mar','apr','may','jun','jul','aug', \\\\\\n 'sep','oct','nov','dec','january','february','march','april', \\\\\\n 'may','june','july','august','september','october','november', \\\\\\n 'december']):\\n\\n sep = '' # Set separator to no space\\n msg = ' Correct date1 word spilling: \\\"'+date1_comp+'\\\",\\\"'+f+'\\\"'\\n log_message(msg,'v1')\\n\\n date2_comp = date2_comp+sep+f # Append separator and field\\n\\n # Check if name component is given or givenname and surname separately - - -\\n #\\n if (config.input_component['givenname'] != []) or \\\\\\n (config.input_component['surname'] != []):\\n name_comp = [givenname_comp, surname_comp]\\n\\n msg = [' Components:', \\\\\\n ' Name: \\\"'+str(name_comp)+'\\\"', \\\\\\n ' Geocode: \\\"'+geocode_comp+'\\\"', \\\\\\n ' Locality: \\\"'+locality_comp+'\\\"', \\\\\\n ' Date1: \\\"'+date1_comp+'\\\"', \\\\\\n ' Date2: \\\"'+date2_comp+'\\\"']\\n log_message(msg,'v1')\\n\\n return [name_comp, geocode_comp, locality_comp, date1_comp, date2_comp]\",\n \"def process_entry(self):\\n\\n for line_item in self.entry:\\n pairs = line_item.split(' ')\\n for pair in pairs:\\n if ':' in pair:\\n key, value = pair.split(':')\\n if value.isdigit():\\n self.fields[key] = int(value)\\n else:\\n self.fields[key] = value\",\n \"def parse_aunt_information(line: str) -> (int, Mapping[str, int]):\\n sue_number, parameters = re.split(': ', line, maxsplit=1)\\n number = int(re.sub('Sue ', '', sue_number))\\n\\n def parse_param(description: str) -> (str, int):\\n \\\"\\\"\\\"The name and value of the described parameter.\\\"\\\"\\\"\\n name, value = re.split(': ', description)\\n return name, int(value)\\n\\n return number, dict(map(parse_param, re.split(', ', parameters)))\",\n \"def parse_info(self, info_lines):\\n info = {}\\n for line in info_lines:\\n if not line or line.startswith(\\\"#\\\"):\\n continue\\n\\n if \\\":\\\" not in line:\\n collectd.warning(\\\"redis_info plugin: Bad format for info line: %s\\\" % line)\\n continue\\n\\n key, val = line.split(\\\":\\\", 1)\\n\\n # Handle multi-value keys (for dbs and slaves).\\n # db lines look like \\\"db0:keys=10,expire=0\\\"\\n # slave lines look like\\n # \\\"slave0:ip=192.168.0.181,port=6379,\\n # state=online,offset=1650991674247,lag=1\\\"\\n if \\\",\\\" in val:\\n split_val = val.split(\\\",\\\")\\n for sub_val in split_val:\\n k, _, v = sub_val.rpartition(\\\"=\\\")\\n sub_key = \\\"{0}_{1}\\\".format(key, k)\\n info[sub_key] = v\\n else:\\n info[key] = val\\n\\n # compatibility with pre-2.6 redis (used changes_since_last_save)\\n info[\\\"changes_since_last_save\\\"] = info.get(\\\"changes_since_last_save\\\", info.get(\\\"rdb_changes_since_last_save\\\"))\\n\\n return info\",\n \"def parse_line(self, line):\\n line = line.strip()\\n log.debug(\\\"Parsing line: '{}'\\\".format(line))\\n if len(line) == 0:\\n log.warning(\\\"Zero length line detected\\\")\\n return\\n split = line.split(DELIMETER)\\n key = split[0]\\n if key in FORMATS:\\n log.debug(\\\"Using formatter for key: {}\\\".format(key))\\n formatter = FORMATS[key]\\n for (name, parser), value in zip(formatter,split[1:]):\\n self._params[name] = parser(value)\\n log.info(\\\"Parameters: {}\\\".format(self._params))\\n self.notify_watchers()\\n else:\\n log.debug(\\\"Invalid key: {}\\\".format(key))\",\n \"def process(line):\\n output = {}\\n\\n fields = line.split(\\\" \\\")\\n if len(fields) < 6:\\n return False\\n \\n output[\\\"log_level\\\"] = fields[0]\\n \\n # Convert date/time to object or reject line\\n try:\\n output[\\\"datetime\\\"] = datetime.datetime.strptime(\\n \\\"%s %s\\\" % (fields[1], fields[2]),\\n \\\"%Y-%m-%d %H:%M:%S,%f\\\"\\n )\\n except ValueError:\\n return False\\n \\n output[\\\"logger\\\"] = fields[3]\\n output[\\\"thread\\\"] = fields[4]\\n output[\\\"process\\\"] = fields[5]\\n output[\\\"message\\\"] = \\\" \\\".join(fields[6:])\\n \\n return output\",\n \"def ParseLine(line):\\n fields = line.split()\\n ip = fields[0]\\n datestr = ' '.join(fields[3:5])[1:-1]\\n timestamp = datetime.strptime(\\n datestr, '%d/%b/%Y:%H:%M:%S %z'\\n ).timestamp()\\n command = fields[5][1:]\\n uri = fields[6]\\n protocol = fields[7][:-1]\\n status = int(fields[8])\\n size = int(fields[9])\\n meta = [var.strip('\\\"') for var in fields[11:-1]]\\n return {\\n 'timestamp': timestamp,\\n 'ip': ip,\\n 'command': command,\\n 'uri': uri,\\n 'protocol': protocol,\\n 'status': status,\\n 'size': size,\\n 'meta': meta\\n }\",\n \"def get_line_desc(self, line):\\n return dict(zip(self.header, line))\",\n \"def _parse_line(line: Match[str]) -> dict:\\n request = line.group(\\\"request\\\")\\n request = request.split()\\n req_method = request[0] # GET, POST, PUT, etc.\\n url = request[1]\\n x = url.split(\\\"/\\\")[3:]\\n uri = f'/{\\\"/\\\".join(x)}'\\n\\n timestamp = line.group(\\\"timestamp\\\") # timestamp in ISO format\\n timestamp = MyTime._try_isoformat(timestamp, tzinfo=\\\"UTC\\\").dt\\n\\n res = {\\n \\\"url\\\": url,\\n \\\"uri\\\": uri,\\n \\\"req_method\\\": req_method,\\n \\\"timestamp\\\": timestamp,\\n \\\"user_agent\\\": line.group(\\\"user_agent\\\"),\\n }\\n return res\",\n \"def parse_user_dict(self, line):\\n pass\",\n \"def _parseLine(self, line, delimiter = \\\":\\\"):\\r\\n\\t\\tsplt = line.split(delimiter)\\r\\n\\t\\tinVec = self._parseVec(splt[0])\\r\\n\\t\\toutVec = self._parseVec(splt[1])\\r\\n\\t\\tif (len(splt) == 2):\\r\\n\\t\\t\\tlabel = \\\"\\\"\\r\\n\\t\\telse:\\r\\n\\t\\t\\tlabel = splt[2]\\r\\n\\t\\tself.data.append({'in':inVec, 'out':outVec, 'label':label})\",\n \"def parseLine(self, line):\\n\\n # Bail out on lines with a malformed timestamp\\n try:\\n timestamp = time.mktime(time.strptime(line[1:25], \\\"%a %b %d %H:%M:%S %Y\\\"))\\n except:\\n return\\n \\n text = line[27:]\\n \\n if self.myname: \\n self.attendance.mark(timestamp, self.myname)\\n text = self.re_myname.sub(self.myname + ' ', text) \\n \\n damage = self.re_damage.search(text)\\n #damage = False\\n death = self.re_death.search(text)\\n #death = False\\n miss = self.re_miss.search(text)\\n #miss = False\\n #defensive = self.re_defensive.search(text)\\n defensive = False\\n loot = self.re_loot.search(text)\\n attendance = self.re_attendance.search(text)\\n if damage:\\n (attacker, atktype, defender, amount, nonmelee) = damage.groups()\\n if nonmelee:\\n atktype = 'non-melee'\\n if self.extract and (self.extract == attacker or self.extract == defender):\\n self.fights.getFight(timestamp, attacker, defender).addAttack(timestamp, atktype, int(amount))\\n if attacker.count(' ') == 0:\\n self.attendance.mark(timestamp, attacker)\\n if defender.count(' ') == 0:\\n self.defender.mark(timestamp, defender)\\n elif miss:\\n (attacker, atktype, defender) = miss.groups()\\n if self.extract and (self.extract == attacker or self.extract == defender):\\n self.fights.getFight(timestamp, attacker, defender).addAttack(timestamp, atktype, 'miss')\\n if attacker.count(' ') == 0:\\n self.attendance.mark(timestamp, attacker)\\n if defender.count(' ') == 0:\\n self.defender.mark(timestamp, defender)\\n elif defensive:\\n (attacker, atktype, defender, defensetype) = defensive.groups()\\n if self.extract and (self.extract == attacker or self.extract == defender):\\n self.fights.getFight(timestamp, attacker, defender).addAttack(timestamp, atktype, defensetype)\\n if attacker.count(' ') == 0:\\n self.attendance.mark(timestamp, attacker)\\n if defender.count(' ') == 0:\\n self.defender.mark(timestamp, defender)\\n elif death:\\n (defender, junk, attacker) = death.groups()\\n if junk.count('have slain'):\\n (defender, attacker) = (attacker, defender)\\n # Use PC deaths to track their attendance\\n if defender.count(' ') == 0:\\n self.attendance.mark(timestamp, defender)\\n elif attacker.count(' ') == 0:\\n self.kills.addKill(timestamp, defender)\\n if self.extract and (self.extract == attacker or self.extract == defender):\\n self.fights.addDeath(timestamp, attacker, defender)\\n if attacker.count(' ') == 0:\\n self.attendance.mark(timestamp, attacker)\\n elif loot:\\n (looter, item) = loot.groups()\\n self.loot.addLoot(timestamp, looter, item)\\n self.attendance.mark(timestamp, looter)\\n elif attendance:\\n attendee = attendance.group(1)\\n self.attendance.mark(timestamp, attendee)\",\n \"def Process_line(line, summary):\\n line = line.lower() # lower all words in the line\\n line = line.translate(str.maketrans('','', string.punctuation)) # Remove all punctuation\\n words = line.split() # Split word from the line\\n add_word(words, summary) # Add word to dictionary\",\n \"def parse(self, src, line):\\n r = line.split('\\\\t')\\n p = {}\\n if src == 'sf':\\n p['businessID'] = r[0]\\n p['name'] = r[1]\\n p['address'] = r[2]\\n p['city'] = r[3]\\n p['state'] = r[4]\\n p['zip'] = r[5]\\n p['latitude'] = r[6]\\n p['longitude'] = r[7]\\n p['phone'] = r[8]\\n elif src == 'nyc':\\n p['businessID'] = r[0]\\n p['name'] = r[1]\\n # nyc separates the building number from the street name\\n p['address'] = ' '.join([r[3].strip(), r[4].strip()])\\n p['city'] = 'NYC'\\n p['state'] = 'NY'\\n p['zip'] = r[5]\\n p['latitude'] = None\\n p['longitude'] = None\\n p['phone'] = r[6]\\n return p\",\n \"def _parse_line(self):\\n # check if line contains a rule or not\\n stripped = self._line.strip()\\n if not stripped or stripped.startswith(\\\"#\\\"):\\n return None\\n\\n # strip out double quotes from values, and simplify equals strings\\n simplified = self._line.replace(\\\"==\\\", \\\"=\\\").replace('\\\"', '')\\n\\n # return a dictionary formed from the key=value pairs found in line\\n return dict(f.strip().split(\\\"=\\\", 1) for f in simplified.split(\\\",\\\"))\",\n \"def process_log_line(self, line):\\n int_map = self.int_map\\n timestamp = line[0:26]\\n if len(timestamp) >= 26:\\n msg = {}\\n try:\\n # %Y-%m-%d %H:%M:%S.%f - 2017-06-27 13:46:10.048844\\n day = int_map[timestamp[8:10]]\\n hour = int_map[timestamp[11:13]]\\n minute = int_map[timestamp[14:16]]\\n second = int_map[timestamp[17:19]]\\n usecond = int_map[timestamp[20:22]] * 10000 + \\\\\\n int_map[timestamp[22:24]] * 100 + int_map[timestamp[24:26]]\\n event_time = (hour * 3600.0 + minute * 60.0 + second) + (usecond / 1000000)\\n if day == self.start_day:\\n elapsed = event_time - self.start_time\\n else:\\n elapsed = event_time + (float(3600 * 24) - self.start_time)\\n msg['timestamp'] = elapsed\\n if msg['timestamp'] >= 0:\\n offset = line.find(']: ', 32)\\n if offset >= 0:\\n try:\\n thread = line[34:offset]\\n separator = thread.find(':')\\n if separator >= 0:\\n thread = thread[separator + 1:].strip()\\n msg['thread'] = thread\\n msg['level'] = line[offset + 3:offset + 4]\\n msg_start = line.find(' ', offset + 5)\\n if msg_start >= 0:\\n msg['category'] = line[offset + 5:msg_start]\\n msg['message'] = line[msg_start + 1:]\\n if msg['category'] == 'nsHttp':\\n if msg['thread'] == 'Main Thread':\\n self.main_thread_http_entry(msg)\\n elif msg['thread'] == 'Socket Thread':\\n self.socket_thread_http_entry(msg)\\n elif msg['category'] == 'nsSocketTransport':\\n self.socket_transport_entry(msg)\\n elif msg['category'] == 'nsHostResolver':\\n self.dns_entry(msg)\\n except Exception:\\n logging.exception('Error processing log line')\\n except Exception:\\n pass\",\n \"def _analyzeLine(self, line, date, data):\\n user = re.search(': (.*)', line).group().split()[1]\\n data[user].add(ConvertTime(date, line))\",\n \"def _read_header_line_2(lines: list) -> dict:\\n fields = (\\n \\\"detection_status\\\",\\n \\\"warning\\\",\\n \\\"cloud_base_data\\\",\\n \\\"warning_flags\\\",\\n )\\n values = [[line[0], line[1], line[3:20], line[21:].strip()] for line in lines]\\n return values_to_dict(fields, values)\",\n \"def make_entry(line):\\n #focus on relevant parts\\n parts = line.split(\\\" - \\\")\\n visitor_id = parts[0]\\n subparts = parts[1].split('\\\"')\\n method_and_uri = subparts[1]\\n method_and_uri_parts = method_and_uri.split(\\\" \\\")\\n method = method_and_uri_parts[0]\\n uri = method_and_uri_parts[1]\\n d = dict()\\n d[\\\"visitor_id\\\"] = visitor_id\\n d[\\\"method\\\"] = method\\n d[\\\"uri\\\"] = uri\\n return d\",\n \"def _prepare_analytic_line(self, cr, uid, obj_line, context=None):\\n return {'name': obj_line.name,\\n 'date': obj_line.date,\\n 'account_id': obj_line.analytic_account_id.id,\\n 'unit_amount': obj_line.quantity,\\n 'product_id': obj_line.product_id and obj_line.product_id.id or False,\\n 'product_uom_id': obj_line.product_uom_id and obj_line.product_uom_id.id or False,\\n 'amount': (obj_line.credit or 0.0) - (obj_line.debit or 0.0),\\n 'general_account_id': obj_line.account_id.id,\\n 'journal_id': obj_line.journal_id.analytic_journal_id.id,\\n 'ref': obj_line.ref,\\n 'move_id': obj_line.id,\\n 'user_id': uid,\\n }\",\n \"def parse(cls, line):\\r\\n raise NotImplementedError\",\n \"def __init__(self, line):\\n columns = self._split_line(line)\\n self.query_name = columns[0].strip()\\n self.eggnog_ortholog = self._get_value(columns[1], split=False)\\n self.eggnog_score = self._get_value(columns[2], split=False)\\n self.eggnog_evalue = self._get_value(columns[3], split=False)\\n self.eggnog_tax = self._get_value(columns[5], split=False)\\n\\n self.go = self._get_value(columns[6])\\n self.ecnumber = self._get_value(columns[7])\\n self.kegg = self._get_value(columns[8])\\n self.brite = self._get_value(columns[13])\\n self.bigg_reaction = self._get_value(columns[16])\\n self.ogs = self._get_value(columns[19])\\n self.cog = self._get_value(columns[20])\\n self.eggnog = [parse.quote(columns[21])] if columns[21] else []\",\n \"def _read_entry_detail(self, line):\\n account_number = 0\\n try:\\n account_number = int(line[12:29].strip().replace('-', ''))\\n except ValueError as err:\\n print('Error parsing account number field -> ' + str(err))\\n\\n result_dict = {'Transaction Code': line[1:3],\\n 'ReceivingID': line[3:11],\\n 'CheckDigit': line[11],\\n 'Account Number': account_number,\\n 'Amount': int(line[29:39]) / 100,\\n 'Individual ID': line[39:54],\\n 'Receiver Name': line[54:76].strip(),\\n 'DiscretionaryData': line[76:78],\\n 'AddendaIndicator': line[78],\\n 'TraceNumber': line[79:94]}\\n\\n self.entries.append(result_dict)\",\n \"def get_general(soup):\\n \\n general_info = {}\\n general_info.update(get_route_name(soup))\\n general_info.update(get_box_data(soup))\\n general_info.update(get_description(soup))\\n general_info.update(get_hierarchy(soup))\\n general_info.update(get_first_img_source(soup))\\n\\n return general_info\",\n \"def on_new_line(self, line, is_full_line):\\n try:\\n if is_full_line:\\n self._parse_v_option(line)\\n self._parse_general_info(line)\\n self._parse_header(line)\\n except ParsingDone:\\n pass # line has been fully parsed by one of above parse-methods\\n return super(W, self).on_new_line(line, is_full_line)\",\n \"def process_info(self, info):\\n return info\",\n \"def parse_report_line(self,line):\\n\\n report = self.new_police_report()\\n report['original_text'] = line\\n \\n #\\n # extract month and day\\n match_date = REPORT_DATE_REGEXP.search(line)\\n assert(match_date)\\n start_index=match_date.start('month')\\n stop_index=match_date.end('month')\\n report['date_month'] = int(line[start_index:stop_index])\\n\\n start_index=match_date.start('day')\\n stop_index=match_date.end('day')\\n report['date_day'] = int(line[start_index:stop_index])\\n\\n my_logger.debug('extracted date (%d/%d)' % (report['date_month'],report['date_day']))\\n\\n #############################################\\n # extract location & scale\\n line = line[0:match_date.start('month')-1] # truncate after start of date\\n \\n #\\n # trim off preceding html and trailing comma\\n start_index=line.rfind('>')+1\\n assert(start_index>0)\\n\\n stop_index=line.rfind(',',start_index)\\n \\n if stop_index >= 2:\\n #\\n # found a comma, \\n line = line[start_index:stop_index]\\n else:\\n #\\n # no comma found\\n line = line[start_index:]\\n my_logger.debug('truncated string: (%s)' % line)\\n report['address']=line\\n #\\n # try to determine which case:\\n # a block\\n # an exact address\\n # an establishment\\n # an intersection\\n # special cases, like: \\\"downtown mountain view\\\"\\n # \\n\\n if (BLOCK_REGEXP.match(line)!=None):\\n my_logger.debug('BLOCK detected')\\n report['map_scale']=mapscale.BLOCK\\n elif (INTERSECTION_REGEXP.match(line)!=None):\\n my_logger.debug('INTERSECTION detected')\\n report['map_scale']=mapscale.INTERSECTION\\n elif (EXACT_REGEXP.match(line)!=None):\\n my_logger.debug('EXACT detected')\\n report['map_scale']=mapscale.EXACT\\n else:\\n #\\n # must be manually assigned\\n report['map_scale']=mapscale.OTHER\\n\\n\\n return report\",\n \"def parse(line):\\n return dict([pair.split(':') for pair in line.split()])\",\n \"def split(self, line):\\n parts = line.split()\\n return {\\n 'size': 0 if parts[9] == '-' else int(parts[9]), \\n 'file_requested': parts[6]\\n }\",\n \"def do_info (self, line) :\\n\\t\\tprint\\n\\t\\tprint get_info_string( self.__image )\\n\\t\\tprint\",\n \"def get_values_from_global_info_file(global_info_file):\\n global_values = {}\\n\\n with open(global_info_file, 'r') as f:\\n\\n lines = f.readlines()\\n for i, line in enumerate(lines):\\n\\n split_line = line.strip().split(' ')\\n\\n cur_last_val = line.strip().split('\\\\t')[-1]\\n if i < (len(lines)-1):\\n next_last_val = lines[i+1].strip().split('\\\\t')[-1]\\n\\n if split_line[0] == 'Vertices':\\n global_values['Vertices'] = cur_last_val\\n\\n elif split_line[0] == 'Edges':\\n global_values['Edges'] = cur_last_val\\n\\n elif split_line[0] == 'Total':\\n if split_line[1] == 'degree':\\n global_values['Total_degree'] = cur_last_val\\n\\n elif split_line[1] == 'strength':\\n global_values['Total_strength'] = cur_last_val\\n\\n elif split_line[0] == 'Average':\\n if split_line[1] == 'degree':\\n global_values['Average_degree'] = cur_last_val\\n\\n elif split_line[1] == 'strength':\\n global_values['Average_strength'] = cur_last_val\\n\\n elif split_line[1] == 'clustering':\\n if split_line[2] == 'coefficient':\\n global_values['Clustering_coeff'] = cur_last_val\\n a = 'Clustering_coeff_weighted'\\n global_values[a] = next_last_val # not very nice\\n\\n elif split_line[0] == 'Minimum':\\n if split_line[1] == 'degree':\\n global_values['Minimum_degree'] = cur_last_val\\n\\n elif split_line[1] == 'strength':\\n global_values['Minimum_strength'] = cur_last_val\\n\\n elif split_line[0] == 'Maximum':\\n if split_line[1] == 'degree':\\n global_values['Maximum_degree'] = cur_last_val\\n\\n elif split_line[1] == 'strength':\\n global_values['Maximum_strength'] = cur_last_val\\n\\n elif split_line[0] == 'Assortativity':\\n global_values['Assortativity'] = cur_last_val\\n global_values['Assortativity_weighted'] = next_last_val\\n\\n return global_values\",\n \"def parse_line(line):\\n parts = line.strip().split('\\\\t')\\n\\n output = {}\\n\\n if len(parts) != len(COLUMNS):\\n raise Exception('Incorrect number of columns in line.', parts, COLUMNS)\\n\\n for key, value in zip(COLUMNS, parts):\\n if key == 'attributes':\\n output[key] = parse_attributes(value)\\n elif key == 'start' or key == 'stop':\\n output[key] = int(value)\\n else:\\n output[key] = value\\n\\n return output\",\n \"def parse_line(line: str) -> Tuple[str, dict]:\\n email, first_name, last_name, birth, gender = line.split(\\\",\\\")\\n person = {\\n \\\"first_name\\\": first_name,\\n \\\"last_name\\\": last_name,\\n \\\"birth\\\": birth,\\n \\\"gender\\\": gender,\\n }\\n return email, person\",\n \"def parseAttrLine(line):\\n\\tpre, post = line.strip().split(':')\\n\\tnumber, attr = pre.strip().split('.')\\n\\tattr = attr.strip().replace('%','').replace(' ', '-')\\n\\tvals = [clean(x) for x in post.strip().strip('.').split(',')]\\n\\treturn {'num':int(number), 'attr':clean(attr), 'vals':vals}\",\n \"def process_line(self, line):\\n for char in line:\\n if self.current_state == 1:\\n\\n if char == \\\"{\\\":\\n self.current_state = 2 # Comment\\n elif char == \\\":\\\":\\n self.set_type = \\\", Assign\\\"\\n self.set_value = char\\n self.current_state = 3 # Assign\\n elif char in self.letters:\\n self.set_type = \\\", Identifier\\\"\\n self.set_value = char\\n self.current_state = 4 # Identifier\\n elif char in self.digits:\\n self.set_type = \\\", Number\\\"\\n self.set_value = char\\n self.current_state = 5 # Number\\n elif char in self.special_symbols:\\n self.set_type = \\\", SpecialSymbol\\\"\\n self.set_value = char\\n self.tokens.append(self.set_value + self.set_type) # Done\\n self.current_state = 1\\n elif char != \\\" \\\" and char != \\\"\\\\n\\\":\\n self.current_state = -1\\n elif self.current_state == 2:\\n\\n if char == \\\"}\\\":\\n self.current_state = 1\\n self.set_value = \\\"\\\"\\n elif self.current_state == 3:\\n\\n if char == \\\"=\\\":\\n self.set_value += char\\n self.tokens.append(self.set_value + self.set_type) # Done\\n self.current_state = 1\\n else:\\n self.current_state = -1\\n elif self.current_state == 4:\\n\\n if char in self.letters:\\n self.set_value += char\\n else: # Done\\n self.current_state = 1\\n if self.set_value in self.reserverd_words:\\n self.set_type = \\\", Reserverd Word\\\"\\n self.tokens.append(self.set_value + self.set_type) # Done\\n elif self.current_state == 5:\\n\\n if char in self.digits:\\n self.set_value += char\\n else: # Done\\n self.tokens.append(self.set_value + self.set_type)\\n self.current_state = 1\\n # elif self.current_state == 6:\\n #\\n #\\n # self.tokens.append(self.set_value + self.set_type)\\n # self.current_state = 1\",\n \"def agline(line):\\n\\n vals = {}\\n x = ['date', 'movie', 'offset', 'well', 'gen', 'flarem', 'flares', \\n 'chargem', 'charges', 'charget', 'escdm', 'escds', 'escddur', 'escmm', 'escms', \\n 'escmdur']\\n y = line.strip('\\\\n').split(',')[0:16]\\n z = zip(x, y)\\n\\n for item in z:\\n vals[item[0]] = item[1]\\n\\n return(vals)\",\n \"def parse(self,att_line):\\r\\n att_line = {item.split('=')[0]:item.split('=')[1] for item in att_line.split(';')}\\r\\n if 'ID' in att_line:\\r\\n self.id = att_line.pop('ID',None)\\r\\n if 'Name' in att_line:\\r\\n self.name = att_line.pop('Name',None)\\r\\n if 'Alias' in att_line:\\r\\n self.alias = att_line.pop('Alias',None)\\r\\n if 'Parent' in att_line:\\r\\n self.parent = att_line.pop('Parent',None)\\r\\n if 'Target' in att_line:\\r\\n self.target = att_line.pop('Target',None)\\r\\n if 'Gap' in att_line:\\r\\n self.gap = att_line.pop('Gap',None)\\r\\n if 'Derives_from' in att_line:\\r\\n self.derives_from = att_line.pop('Derives_from',None)\\r\\n if 'Note' in att_line:\\r\\n self.note = att_line.pop('Note',None)\\r\\n if 'Dbxref' in att_line:\\r\\n self.dbxref = att_line.pop('Dbxref',None)\\r\\n if 'Ontology_term' in att_line:\\r\\n self.ontology_term = att_line.pop('Ontology_term',None)\\r\\n if 'Is_circular' in att_line:\\r\\n self.is_circular = att_line.pop('Is_circular',None)\\r\\n if self.allele_key in att_line:\\r\\n self.allele = att_line.pop(self.allele_key,None).split(',')\\r\\n if self.discovered_key in att_line:\\r\\n discovered_val = att_line.pop(self.discovered_key,None)\\r\\n if discovered_val in self.enabled:\\r\\n self.discovered = True\\r\\n elif discovered_val in self.disabled:\\r\\n self.discovered = False\\r\\n if self.validated_key in att_line:\\r\\n validated_val = att_line.pop(self.validated_key,None)\\r\\n if validated_val in self.enabled:\\r\\n self.validated = True\\r\\n elif validated_val in self.disabled:\\r\\n self.validated = False\\r\\n if self.active_key in att_line:\\r\\n active_val = att_line.pop(self.active_key,None)\\r\\n if active_val in self.enabled:\\r\\n self.active = False\\r\\n elif active_val in self.disabled:\\r\\n self.active = True\\r\\n else:\\r\\n pass#print(\\\"{} is not a valid entry for {}\\\".format(active_val,self.active_key))\\r\\n else:\\r\\n #TODO this will make every element withought existing value active.\\r\\n self.active = True\\r\\n rest_dict = {}\\r\\n for key,value in att_line.items():\\r\\n if self.history_key in key:\\r\\n parts = att_line[key].split(',')\\r\\n if len(parts) == 3:\\r\\n self.add_history(*parts)\\r\\n else:\\r\\n reason = '.'.join(parts[2:])\\r\\n self.add_history(parts[0],parts[1],reason)\\r\\n else:\\r\\n rest_dict[key] = value\\r\\n if rest_dict != {}:\\r\\n #TODO: maybe add this to a logger instead\\r\\n #print(\\\"attributes put in other: {}\\\".format(', '.join(att_line.keys())))\\r\\n self.other = att_line\\r\\n return self\",\n \"def _parse_track_line(self, inp):\\n self.metadata = {}\\n ltmp = shlex.split(inp.strip(\\\"\\\\n\\\"))\\n for item in ltmp:\\n k, v = item.split(\\\"=\\\")\\n self.metadata[k] = v\\n\\n track_type = self.metadata.get(\\\"type\\\", None)\\n if track_type is not None:\\n if track_type in bed_x_formats:\\n self.printer.write(\\n \\\"Found track type '%s' in track definition line. Assuming extra columns follow UCSC definitions.\\\"\\n % track_type\\n )\\n if self.extra_columns == 0:\\n self.extra_columns = bed_x_formats[track_type]\\n elif self.extra_columns != bed_x_formats[track_type]:\\n my_columns = self._get_extra_column_names()\\n track_format_columns = \\\",\\\".join([X[0] for X in bed_x_formats[track_type]])\\n warn(\\\"Extra columns specified by %s track type declaration (%s) don't match those specified by user (%s). Using those specified by user.\\\" %\\\\\\n (track_type,track_format_columns,my_columns),FileFormatWarning)\\n self.metadata[\\\"type\\\"] = \\\"custom\\\"\\n else:\\n self.printer.write(\\\"Found track type '%s' in track definition line.\\\" % track_type)\",\n \"def agline2(line):\\n \\n vals = {}\\n y = line.strip('\\\\n').split(',')\\n y.extend(y[0].strip('.MTS').split('_'))\\n \\n #print(y)\\n \\n x = ['movie', 'moviecode', 'offset', 'well', 'agmin', 'agsec', 'agdur', \\n 'agtype', 'agcomm', 'escmin', 'escsec', 'escdur', 'esctype', 'escbeh', \\n 'esccomm', 'gen', 'date', 'assay', 'fps', 'flyid', 'side', 'moviepart']\\n \\n z = zip(x, y)\\n\\n for item in z:\\n vals[item[0]] = item[1]\\n\\n return(vals)\",\n \"def ingest(in_info):\\n if type(in_info) == str:\\n with open(in_info) as infile:\\n lines = (line.split(None) for line in infile)\\n in_dict = {defn[0] : defn[1:] for defn in lines}\\n else:\\n in_dict = in_info\\n return in_dict\",\n \"def process(raw):\\n entry = { }\\n cooked = [ ]\\n\\n for line in raw:\\n line = line.strip()\\n if len(line) == 0 or line[0]==\\\"#\\\" :\\n continue\\n parts = line.split(';')\\n if len(parts) == 3:\\n entry[\\\"description\\\"] = parts[0].strip() #adding key and values to the dict\\n entry[\\\"long\\\"] = parts[1].strip()\\n entry[\\\"lat\\\"] = parts[2].strip()\\n cooked.append(entry) #add this dict entry into the array\\n entry = { }\\n continue\\n else:\\n raise ValueError(\\\"Trouble wiht line: '{}'\\\\n\\\".format(line))\\n \\n return cooked #returning an array of dicts\",\n \"def parse_line(self, line):\\n\\n kv_match = self.kv_rex.match(line)\\n\\n if kv_match:\\n kv_dict = kv_match.groupdict()\\n kv_key = kv_dict['key']\\n kv_value = kv_dict['value']\\n\\n if 'time_' in kv_key:\\n kv_unit = kv_dict['unit']\\n\\n if not kv_key in self.kv_times:\\n self.kv_times[kv_key] = {'unit': kv_unit, 'values': []}\\n\\n self.kv_times[kv_key]['values'].append(float(kv_value))\\n else:\\n if not kv_key in self.kv_counts:\\n self.kv_counts[kv_key] = 0.0\\n\\n self.kv_counts[kv_key] += float(kv_value)\",\n \"def parse(self, line):\\n try:\\n (year, month, day, hour, minute, second, microseconds, offset_hour, offset_minute, source, process, logentry) = re.match('^(\\\\d\\\\d\\\\d\\\\d)-(\\\\d\\\\d)-(\\\\d\\\\d)T(\\\\d\\\\d):(\\\\d\\\\d):(\\\\d\\\\d)\\\\.([\\\\d]+)\\\\+(\\\\d\\\\d):(\\\\d\\\\d) ([a-z]+)\\\\[([a-zA-Z0-9_.]+)\\\\]: ([0-9a-z-A-Z\\\\-_\\\\.\\\\[\\\\]:\\\\?\\\\#\\\\\\\",/\\\\ ={}\\\\'\\\\(\\\\)<>]+)$', line).groups()\\n except:\\n pass\\n \\n try:\\n parsed_data = dict()\\n parsed_data['timestamp'] = \\\" \\\".join([\\\"-\\\".join([year, month, day]), \\\":\\\".join([hour, minute, second])])\\n parsed_data['log_time'] = datetime.datetime(int(year), int(month), int(day), int(hour), int(minute), int(second))\\n parsed_data['log_source'] = source\\n parsed_data['log_type'] = process\\n except (AttributeError, UnboundLocalError):\\n PARSE_ERRORS.append(line)\\n return False\\n\\n #TODO: This still needs work on spaces in values surrounded by \\\" \\\" \\n if parsed_data['log_source'] == \\\"heroku\\\":\\n if logentry.__len__() > 1:\\n logentry = re.sub(', ', ',', logentry)\\n line_chunks = re.split(' ', logentry)\\n for chunk in line_chunks:\\n line_chunks = re.split('=', chunk)\\n if line_chunks.__len__() > 2:\\n #fwd and path are a little clunky to parse\\n pass\\n elif line_chunks.__len__() > 1:\\n parsed_data[line_chunks[0]] = line_chunks[1]\\n else:\\n pass\\n else:\\n return False\\n else:\\n # TODO: [app] \\n # Needs parsing. Do that here.\\n return False\\n\\n return parsed_data\",\n \"def process(line) -> dict:\\n dict = {}\\n entities = line.split(',')\\n country = entities[1]\\n cur_num = int(entities[len(entities) - 1])\\n if country in dict.keys():\\n dict[country] += cur_num\\n else:\\n dict[country] = cur_num\\n return dict\",\n \"def parse_rating_dict(self, line):\\n pass\",\n \"def _parse_refraction(line, lines):\\n split_line = line.split()\\n\\n energy = float(split_line[0])\\n ref_ind_xx = float(split_line[1])\\n ref_ind_zz = float(split_line[2])\\n extinct_xx = float(split_line[3])\\n extinct_zz = float(split_line[4])\\n\\n return {\\\"energy\\\": energy, \\\"ref_ind_xx\\\": ref_ind_xx, \\\"ref_ind_zz\\\": ref_ind_zz, \\\"extinct_xx\\\": extinct_xx,\\n \\\"extinct_zz\\\": extinct_zz}\",\n \"def parse_line(self, line):\\n # set line number\\n self.line_count += 1\\n if len(line) == 0:\\n return\\n\\n # parse line to kw line\\n kw_line = self._parse_line(line, line_number=self.line_count)\\n if kw_line.is_comment:\\n return\\n\\n func = kw_line.items[0]\\n\\n # pre import lib\\n if func == 'import':\\n self.default_func['import'](*kw_line.items[1:])\\n\\n if func not in self.kw_func and func not in self.kw_var:\\n raise ValueError('Define not found {}'.format(func), kw_line.line_number)\\n\\n # set var\\n if kw_line.var:\\n self.kw_var[kw_line.var] = None\\n\\n # add kw line to cache\\n self.kw_lines.append(kw_line)\",\n \"def _process_text_line(self, line, columns, format, lower_case, num_line,\\n fill_missing=0, filter_case=None,\\n strict_separator=False):\\n if not isinstance(line, list) and not isinstance(\\n line, tuple) and not isinstance(line, numpy.ndarray):\\n if format != \\\"tsv\\\":\\n raise Exception(\\\"unable to process format \\\" + format)\\n line = line.strip(\\\"\\\\r\\\\n \\\").replace(\\\"\\\\n\\\", \\\" \\\")\\n line = DatabaseCore2._split_expr.split(line)\\n\\n if filter_case is not None:\\n line = [filter_case(s) for s in line]\\n\\n try:\\n if fill_missing > 0:\\n m = max(columns.keys())\\n if m >= len(line):\\n line = copy.copy(line)\\n add = 0\\n while m >= len(line) and add < fill_missing:\\n a, b = columns[len(line)]\\n if b is int:\\n line.append(\\\"0\\\")\\n elif b is float:\\n line.append(\\\"0.0\\\")\\n elif b is decimal.Decimal:\\n line.append(\\\"0\\\")\\n elif b is str:\\n line.append(\\\"\\\")\\n else:\\n line.append(\\\"\\\")\\n add += 1\\n\\n res = {}\\n for c, v in columns.items():\\n if \\\"AUTOFILL\\\" in v:\\n res[v[0]] = \\\"NULL\\\"\\n elif \\\"AUTOINCREMENT\\\" in v:\\n continue\\n else:\\n if c >= len(line):\\n self.LOG(\\n \\\"(a)line number \\\",\\n num_line,\\n \\\"*unable to process a line columns \\\",\\n c,\\n \\\"#\\\",\\n line,\\n \\\" columns \\\",\\n columns)\\n return None\\n\\n val = line[c]\\n if len(v) > 2 and v[2].lower() not in [\\n \\\"primarykey\\\", \\\"autofill\\\"]:\\n val = v[2](val)\\n\\n try:\\n if isinstance(v[1], tuple):\\n val = v[1][0](val)\\n elif v[1] is datetime.datetime:\\n if isinstance(val, datetime.datetime):\\n pass\\n elif isinstance(val, str):\\n val = datetime.datetime.parse(val)\\n else:\\n raise TypeError(\\n \\\"unable to convert %s into datetime\\\" % str(\\n type(val)))\\n else:\\n val = v[1](val)\\n except ValueError: # as e :\\n self.LOG(\\n \\\"(b)line number \\\",\\n num_line,\\n \\\"**unable to process a line columns \\\",\\n c,\\n \\\"#\\\",\\n v[0],\\n \\\" type \\\",\\n v[1],\\n \\\" value \\\",\\n repr(\\n line[c]))\\n return None\\n\\n if isinstance(val, str):\\n val = val.replace(\\\"'\\\", \\\"''\\\")\\n if lower_case:\\n val = val.lower()\\n res[v[0]] = val\\n\\n return res\\n except Exception:\\n self.LOG(\\\"(c)line number\\\", num_line,\\n \\\"***unable to process a line columns:\\\", line)\\n return None\",\n \"def _format_globalpars(self, staticneighs, ifdistance, format_level):\\n ## Basic information how it will be input neighs_info\\n self.level = format_level\\n ## Global known information about relative position\\n self.ifdistance = ifdistance\\n ## Global known information about get information\\n self.staticneighs = staticneighs\\n ## Setting changable information about static neighs setting\\n self.staticneighs_set = None\\n if self.level is None:\\n self.staticneighs_set = None\\n elif self.level <= 2:\\n self.staticneighs_set = True\\n if self.level == 3:\\n self.staticneighs_set = False\",\n \"def _parse(line: str) -> Tuple[int, str, str, bool]:\\n level, tag, args = None, None, None\\n try:\\n # Try to split the line into three parts, then try two parts\\n try:\\n level, tag, args = line.split(' ', maxsplit=2)\\n except ValueError:\\n try:\\n level, tag = line.split(' ', maxsplit=1)\\n except ValueError:\\n raise InvalidLineException(f'Invalid line: {line}')\\n\\n # INDI nor FAM should not be the tag\\n if tag in ('INDI', 'FAM'):\\n raise InvalidLineException(f'Invalid tag {line}')\\n\\n # If INDI or FAM are args, swap the args and tag\\n if args in ('INDI', 'FAM'):\\n temp = args\\n args = tag\\n tag = temp\\n\\n # Level must be between 0 and 2 inclusive\\n if level not in ('0', '1', '2'):\\n raise InvalidLineException(f'Invalid level: {level}')\\n level = int(level)\\n\\n # Allow a trailing space\\n if args == '':\\n args = None\\n\\n if tag == 'INDI':\\n assert level == 0\\n assert args is not None\\n elif tag == 'NAME':\\n assert level == 1\\n assert args is not None\\n elif tag == 'SEX':\\n assert level == 1\\n assert args in ('M', 'F')\\n elif tag == 'BIRT':\\n assert level == 1\\n assert args is None\\n elif tag == 'DEAT':\\n assert level == 1\\n assert args is None\\n elif tag == 'FAMC':\\n assert level == 1\\n assert args is not None\\n elif tag == 'FAMS':\\n assert level == 1\\n assert args is not None\\n elif tag == 'FAM':\\n assert level == 0\\n assert args is not None\\n elif tag == 'MARR':\\n assert level == 1\\n assert args is None\\n elif tag == 'HUSB':\\n assert level == 1\\n assert args is not None\\n elif tag == 'WIFE':\\n assert level == 1\\n assert args is not None\\n elif tag == 'CHIL':\\n assert level == 1\\n assert args is not None\\n elif tag == 'DIV':\\n assert level == 1\\n assert args is None\\n elif tag == 'DATE':\\n assert level == 2\\n assert args is not None\\n # Date must have valid args\\n try:\\n day, month, year = args.split(' ', maxsplit=2)\\n except ValueError:\\n raise InvalidLineException(f'Not enough values for DATE: {args}')\\n assert day == '0' or not day[0] == '0' and day.isdigit()\\n assert month in ('JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC')\\n assert len(year) == 4 and year.isdigit()\\n elif tag == 'HEAD':\\n assert level == 0\\n assert args is None\\n elif tag == 'TRLR':\\n assert level == 0\\n assert args is None\\n elif tag == 'NOTE':\\n assert level == 0\\n else:\\n raise InvalidLineException(f'Unknown Tag: {tag}')\\n except (AssertionError, InvalidLineException):\\n return level, tag, args, False\\n\\n return level, tag, args, True\",\n \"def arduinoLineToDictionary(self, line):\\n\\n # Temperatures have the following syntax:\\n # name=TempX,serial_num=blahblah,value=50,units=F\\n\\n # Analog pin outputs have the following syntax:\\n # analogpin:name=PinX,pin_num=X,value=val\\n\\n # Digital pins have the following syntax:\\n # digitalpin:name=PinX,pin_num=X,value=val\\n\\n # For the temperature sensors, it has to find the serial number, then populate the\\n # Temperature value in the ard_dictionary\\n\\n # For the pressure sensors, it has to find an analog pin_num, then match that to the one in the ard_dictionary\\n\\n # For the heaters and pumps, it has to find a digital pin_num, then match that to the one in the ard_dictionary\\n\\n # Split the serial read text by colons to get the type of data and the data itself\\n serial_read_input_list = line.split(\\\":\\\")\\n\\n try:\\n # First entry is the type, the rest is the data\\n type_of_data = serial_read_input_list[0]\\n data = serial_read_input_list[1]\\n except:\\n return\\n\\n if type_of_data == \\\"tempsensor\\\":\\n self.process_temp_data(data)\\n\\n if type_of_data == \\\"analogpin\\\":\\n self.process_pressure_data(data)\\n\\n if type_of_data == \\\"digitalpin\\\":\\n self.process_heater_pump_data(data)\",\n \"def _result_to_dict(line):\\n f = line.split(':;')\\n return {'server': f[0], 'os_name': f[1], 'status': f[2], 'ipv4': f[3]}\",\n \"def process_line(self,\\n event_file,\\n raw_log_line,\\n header_length=29,\\n log_filename=\\\"\\\"):\\n\\n event_data = {}\\n for filter_name, regex in self._filters_dict.items():\\n match = regex.search(raw_log_line)\\n if match:\\n match_data = match.groups()\\n event_data[filter_name] = match_data\\n\\n if event_data:\\n if log_filename:\\n event_data[\\\"log_filename\\\"] = log_filename\\n event_data[\\\"raw_log_line\\\"] = raw_log_line.rstrip()[header_length:]\\n event_data[\\\"system_timestamp\\\"] = raw_log_line[1:27]\\n event_data[\\\"matched_timestamp\\\"] = \\\\\\n datetime.datetime.now().strftime(TIMESTAMP_FORMAT)\\n event_file.write(json.dumps(event_data) + \\\"\\\\n\\\")\\n event_file.flush()\",\n \"def _parse_head(line):\\n retval = {}\\n m = re.match(\\n '[0-9]+: (?P<if>\\\\w+\\\\d{1,3}): <(?P<flags>[^>]+)> mtu (?P<mtu>[0-9]+)',\\n line\\n )\\n if m:\\n retval['ifname'] = m.group('if')\\n retval['mtu'] = int(m.group('mtu'))\\n retval['flags'] = m.group('flags').split(',')\\n return retval\",\n \"def __parseLine(line):\\n\\n # extract name\\n name_len = line.index(\\\" \\\")\\n name = line[:name_len]\\n line = line[name_len + 3:]\\n\\n # array-ize 'electron' val\\n elec_pos = line.index(\\\"electron\\\") + 9\\n line = line[:elec_pos] + '[' + line[elec_pos:].replace(' ', ',') + ']'\\n\\n # quote 'small' val\\n line = line.replace(' ', '')\\n line = line.replace('small:', 'small:\\\"').replace(',molar', '\\\",molar')\\n\\n # quote all keys\\n for i in [\\\"position\\\", \\\"number\\\", \\\"small\\\", \\\"molar\\\", \\\"electron\\\"]:\\n line = line.replace(i, '\\\"' + i + '\\\"')\\n\\n return eval('{\\\"name\\\":\\\"' + name + '\\\",' + line + '}')\",\n \"def _collect_line_info(self, dso, real_path, addr_shifts):\\n # 1. Collect addrs to send to addr2line.\\n addr_set = set()\\n for addr in dso.addrs:\\n addr_obj = dso.addrs[addr]\\n if addr_obj.source_lines: # already has source line, no need to search.\\n continue\\n for shift in addr_shifts:\\n # The addr after shift shouldn't change to another function.\\n shifted_addr = max(addr + shift, addr_obj.func_addr)\\n addr_set.add(shifted_addr)\\n if shifted_addr == addr_obj.func_addr:\\n break\\n if not addr_set:\\n return\\n addr_request = '\\\\n'.join(['%x' % addr for addr in sorted(addr_set)])\\n\\n # 2. Use addr2line to collect line info.\\n try:\\n subproc = subprocess.Popen([self.addr2line_path, '-ai', '-e', real_path],\\n stdin=subprocess.PIPE, stdout=subprocess.PIPE)\\n (stdoutdata, _) = subproc.communicate(str_to_bytes(addr_request))\\n stdoutdata = bytes_to_str(stdoutdata)\\n except:\\n return\\n addr_map = {}\\n cur_line_list = None\\n for line in stdoutdata.strip().split('\\\\n'):\\n if line[:2] == '0x':\\n # a new address\\n cur_line_list = addr_map[int(line, 16)] = []\\n else:\\n # a file:line.\\n if cur_line_list is None:\\n continue\\n # Handle lines like \\\"C:\\\\Users\\\\...\\\\file:32\\\".\\n items = line.rsplit(':', 1)\\n if len(items) != 2:\\n continue\\n if '?' in line:\\n # if ? in line, it doesn't have a valid line info.\\n # An addr can have a list of (file, line), when the addr belongs to an inlined\\n # function. Sometimes only part of the list has ? mark. In this case, we think\\n # the line info is valid if the first line doesn't have ? mark.\\n if not cur_line_list:\\n cur_line_list = None\\n continue\\n (file_path, line_number) = items\\n line_number = line_number.split()[0] # Remove comments after line number\\n try:\\n line_number = int(line_number)\\n except ValueError:\\n continue\\n file_id = self._get_file_id(file_path)\\n cur_line_list.append((file_id, line_number))\\n\\n # 3. Fill line info in dso.addrs.\\n for addr in dso.addrs:\\n addr_obj = dso.addrs[addr]\\n if addr_obj.source_lines:\\n continue\\n for shift in addr_shifts:\\n shifted_addr = max(addr + shift, addr_obj.func_addr)\\n lines = addr_map.get(shifted_addr)\\n if lines:\\n addr_obj.source_lines = lines\\n break\\n if shifted_addr == addr_obj.func_addr:\\n break\",\n \"def parse(line, half=1):\\n line = line.strip()\\n logger.debug(\\\"LINE '%s'\\\", line)\\n\\n global aipname, alonging, ats_chapter, coords_wrap, obj, feature\\n global features, finalcoord, lastn, laste, lastv, airsport_intable\\n global border, re_coord3, country\\n global sectors, name_cont, cold_resp\\n\\n if line==LINEBREAK:\\n # drop current feature, if we don't have vertl by now,\\n # then this is just an overview polygon\\n feature = {\\\"properties\\\":{}}\\n obj = []\\n alonging = False\\n coords_wrap = \\\"\\\"\\n lastv = None\\n return\\n\\n\\n if ad_aip and not \\\"ENNO\\\" in filename:\\n if not ats_chapter:\\n # skip to chapter 2.71\\n if \\\"ATS airspace\\\" in line or \\\"ATS AIRSPACE\\\" in line:\\n logger.debug(\\\"Found chapter 2.71\\\")\\n ats_chapter=True\\n return\\n else:\\n # then skip everything after\\n if \\\"AD 2.\\\" in line or \\\"ATS COMM\\\" in line:\\n #if \\\"ATS komm\\\" in line or \\\"Kallesignal\\\" in line:\\n logger.debug(\\\"End chapter 2.71\\\")\\n ats_chapter=False\\n\\n class_=re_class.search(line) or re_class2.search(line) or re_class_openair.search(line)\\n if class_:\\n logger.debug(\\\"Found class in line: %s\\\", line)\\n class_=class_.groupdict()\\n feature['properties']['class']=class_.get('class')\\n if tia_aip:\\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\\n return\\n\\n # SPECIAL CASE temporary workaround KRAMFORS\\n if aipname and (\\\"KRAMFORS\\\" in aipname) and (\\\"within\\\" in line):\\n return\\n # SPECIAL CASE workaround SÄLEN/SAAB CTR sectors\\n if aipname and ((\\\"SÄLEN\\\" in aipname) or (\\\"SAAB\\\" in aipname)) and (\\\"Sector\\\" in line):\\n logger.debug(\\\"TEST: Breaking up SÄLEN/SAAB, aipname=.\\\"+aipname)\\n sectors.append((aipname, obj))\\n feature, obj = {\\\"properties\\\":{}}, []\\n if \\\"SÄLEN\\\" in aipname:\\n aipname = \\\"SÄLEN CTR \\\"+line\\n else:\\n aipname = \\\"SAAB CTR \\\"+line\\n # SPECIAL CASE check for Valldal AIP names\\n if valldal and 'Valldal' in line:\\n aipname=\\\" \\\".join(line.strip().split()[0:2])\\n logger.debug(\\\"Valldal aipname: '%s'\\\", aipname)\\n feature['properties']['class']='Luftsport'\\n feature['properties']['from (ft amsl)']=0\\n feature['properties']['from (m amsl)'] =0\\n\\n coords = re_coord.search(line)\\n coords2 = re_coord2.search(line)\\n coords3 = re_coord3.findall(line)\\n\\n if (coords or coords2 or coords3):\\n\\n logger.debug(\\\"Found %i coords in line: %s\\\", coords3 and len(coords3) or 1, line)\\n logger.debug(printj(coords3))\\n if line.strip()[-1] == \\\"N\\\":\\n coords_wrap += line.strip() + \\\" \\\"\\n logger.debug(\\\"Continuing line after N coordinate: %s\\\", coords_wrap)\\n return\\n elif coords_wrap:\\n nline = coords_wrap + line\\n logger.debug(\\\"Continued line: %s\\\", nline)\\n coords = re_coord.search(nline)\\n coords2 = re_coord2.search(nline)\\n coords3 = re_coord3.findall(nline)\\n logger.debug(\\\"Found %i coords in merged line: %s\\\", coords3 and len(coords3) or '1', nline)\\n line = nline\\n coords_wrap = \\\"\\\"\\n\\n if coords and not (\\\"Lyng\\\" in aipname or \\\"Halten\\\" in aipname):\\n coords = coords.groupdict()\\n n = coords.get('cn') or coords.get('n')\\n e = coords.get('ce') or coords.get('e')\\n #n = coords.get('n') or coords.get('cn')\\n #e = coords.get('e') or coords.get('ce')\\n rad = coords.get('rad')\\n if not rad:\\n rad_m = coords.get('rad_m')\\n if rad_m:\\n rad = m2nm(rad_m)\\n if not n or not e or not rad:\\n coords_wrap += line.strip() + \\\" \\\"\\n # FIXME: incomplete circle continuation is broken\\n logger.debug(\\\"Continuing line after incomplete circle: %s\\\", coords_wrap)\\n return\\n lastn, laste = n, e\\n logger.debug(\\\"Circle center is %s %s %s %s\\\", coords.get('n'), coords.get('e'), coords.get('cn'), coords.get('ce'))\\n logger.debug(\\\"COORDS is %s\\\", json.dumps(coords))\\n c_gen = gen_circle(n, e, rad)\\n logger.debug(\\\"LENS %s %s\\\", len(obj), len(c_gen))\\n obj = merge_poly(obj, c_gen)\\n logger.debug(\\\"LENS %s %s\\\", len(obj), len(c_gen))\\n\\n elif coords2:\\n coords = coords2.groupdict()\\n n = coords.get('n')\\n e = coords.get('e')\\n if n is None and e is None:\\n n,e = lastn, laste\\n secfrom = coords.get('secfrom')\\n secto = coords.get('secto')\\n radfrom = coords.get('radfrom')\\n radto = coords.get('rad')\\n c_gen = gen_sector(n, e, secfrom, secto, radfrom, radto)\\n\\n obj = merge_poly(obj, c_gen)\\n\\n else:\\n skip_next = 0\\n for blob in coords3:\\n ne,n,e,along,arc,rad,cn,ce = blob[:8]\\n circle = blob[8] if len(blob)==9 else None\\n logger.debug(\\\"Coords: %s\\\", (n,e,ne,along,arc,rad,cn,ce,circle))\\n if skip_next > 0 and n:\\n logger.debug(\\\"Skipped.\\\")\\n skip_next -= 1\\n continue\\n if arc:\\n arcdata = re_arc.search(line)\\n if not arcdata:\\n coords_wrap += line.strip() + \\\" \\\"\\n logger.debug(\\\"Continuing line after incomplete arc: %s\\\", coords_wrap)\\n return\\n arcdata = arcdata.groupdict()\\n logger.debug(\\\"Completed arc: %s\\\", arcdata)\\n n = arcdata['n']\\n e = arcdata['e']\\n rad = arcdata.get('rad1') or arcdata.get('rad2')\\n arc = gen_circle(n, e, rad, convert=False)\\n to_n = arcdata['n2']\\n to_e = arcdata['e2']\\n cw = arcdata['dir']\\n logger.debug(\\\"ARC IS \\\"+cw)\\n fill = fill_along(obj[-1],(to_n,to_e), arc, (cw=='clockwise'))\\n lastn, laste = None, None\\n\\n for apair in fill:\\n bn, be = ll2c(apair)\\n obj.insert(0,(bn,be))\\n skip_next = 1\\n elif circle:\\n coords_wrap += line.strip() + \\\" \\\"\\n # FIXME: incomplete circle continuation is broken\\n logger.debug(\\\"Continuing line after incomplete circle (3): %s\\\", coords_wrap)\\n return\\n\\n\\n if alonging:\\n if not n and not e:\\n n, e = lastn, laste\\n fill = fill_along(alonging, (n,e), border)\\n alonging = False\\n lastn, laste = None, None\\n #HACK matching point in the wrong direction - FIXME don't select closest but next point in correct direction\\n if \\\"Sälen TMA b\\\" in aipname or \\\"SÄLEN CTR Sector b\\\" in aipname:\\n fill=fill[1:]\\n for bpair in fill:\\n bn, be = ll2c(bpair)\\n obj.insert(0,(bn,be))\\n\\n if rad and cn and ce:\\n c_gen = gen_circle(cn, ce, rad)\\n logger.debug(\\\"Merging circle using cn, ce.\\\")\\n obj = merge_poly(obj, c_gen)\\n if n and e:\\n lastn, laste = n, e\\n obj.insert(0,(n,e))\\n if along:\\n if not n and not e:\\n n, e = lastn, laste\\n alonging = (n,e)\\n if '(' in ne:\\n finalcoord = True\\n logger.debug(\\\"Found final coord.\\\")\\n else:\\n finalcoord = False\\n if (airsport_aip or aip_sup or military_aip) and finalcoord:\\n if feature['properties'].get('from (ft amsl)') is not None:\\n logger.debug(\\\"Finalizing: finalcoord.\\\")\\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\\n lastv = None\\n\\n if not valldal:\\n return\\n\\n # IDENTIFY temporary restrictions\\n period = re_period.search(line) or re_period2.search(line) or re_period3.search(line)\\n\\n if cold_resp and not feature.get('properties',{}).get('temporary'):\\n logger.debug(\\\"Adding temporary restriction to cold response airspace.\\\")\\n feature['properties']['temporary'] = True\\n feature['properties']['dashArray'] = \\\"5 5\\\"\\n feature['properties']['Date from'] = [\\\"14 MAR\\\"]\\n feature['properties']['Date until'] = [\\\"31 MAR\\\"]\\n feature['properties']['Time from (UTC)'] = \\\"0000\\\"\\n feature['properties']['Time to (UTC)'] = \\\"2359\\\"\\n\\n # IDENTIFY frequencies\\n freq = re_freq.search(line)\\n if freq:\\n freq = freq.groupdict()\\n logger.debug(\\\"Found FREQUENCY: %s\\\", freq['freq'])\\n feature['properties']['frequency'] = freq.get('freq')\\n\\n # IDENTIFY altitude limits\\n vertl = re_vertl_upper.search(line) or re_vertl_lower.search(line) or re_vertl.search(line) or re_vertl2.search(line) or (military_aip and re_vertl3.search(line))\\n\\n if vertl:\\n vertl = vertl.groupdict()\\n logger.debug(\\\"Found vertl in line: %s\\\", vertl)\\n fromamsl, toamsl = None, None\\n\\n v = vertl.get('ftamsl')\\n flfrom = vertl.get('flfrom')\\n flto = vertl.get('flto')\\n fl = vertl.get('fl')\\n rmk = vertl.get('rmk')\\n\\n if rmk is not None:\\n v = 14999 # HACK: rmk = \\\"Lower limit of controlled airspace -> does not affect us\\\"\\n if fl is not None:\\n v = int(fl) * 100\\n\\n if flto is not None:\\n toamsl = int(flto) * 100\\n if flfrom:\\n fromamsl = v or (int(flfrom) * 100)\\n fl = fl or flfrom\\n elif flfrom is not None:\\n fromamsl = int(flfrom) * 100\\n fl = fl or flfrom\\n elif v is not None:\\n if lastv is None:\\n toamsl = v\\n if fl is not None:\\n flto = fl\\n else:\\n fromamsl = v\\n else:\\n fromamsl = vertl.get('msl',vertl.get('gnd',vertl.get('from')))\\n if fromamsl == \\\"GND\\\": fromamsl = 0\\n if fromamsl == \\\"MSL\\\": fromamsl = 0\\n toamsl = vertl.get('unl',vertl.get('to'))\\n if toamsl == \\\"UNL\\\": toamsl = 999999\\n\\n if toamsl is not None:\\n lastv = toamsl\\n currentv = feature['properties'].get('to (ft amsl)')\\n if currentv is not None and currentv != toamsl:\\n logger.warning(\\\"attempt to overwrite vertl_to %s with %s.\\\" % (currentv, toamsl))\\n if int(currentv) > int(toamsl):\\n logger.warning(\\\"skipping.\\\")\\n return\\n logger.warning(\\\"ok.\\\")\\n if flto is not None:\\n feature['properties']['to (fl)']=flto\\n feature['properties']['to (ft amsl)']=toamsl\\n feature['properties']['to (m amsl)'] = ft2m(toamsl)\\n if valldal:\\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\\n lastv = None\\n if fromamsl is not None:\\n currentv = feature['properties'].get('from (ft amsl)')\\n if currentv is not None and currentv != fromamsl:\\n logger.warning(\\\"attempt to overwrite vertl_from %s with %s.\\\" % (currentv, fromamsl))\\n if int(currentv) < int(fromamsl):\\n logger.warning(\\\"skipping.\\\")\\n return\\n logger.warning(\\\"ok.\\\")\\n if fl is not None:\\n feature['properties']['from (fl)']=fl\\n feature['properties']['from (ft amsl)']=fromamsl\\n feature['properties']['from (m amsl)'] = ft2m(fromamsl)\\n lastv = None\\n if (((cta_aip or airsport_aip or aip_sup or tia_aip or (aipname and (\\\"TIZ\\\" in aipname))) and (finalcoord or tia_aip_acc)) or country != 'EN'):\\n logger.debug(\\\"Finalizing poly: Vertl complete.\\\")\\n if aipname and ((\\\"SÄLEN\\\" in aipname) or (\\\"SAAB\\\" in aipname)) and len(sectors)>0:\\n for x in sectors[1:]: # skip the first sector, which is the union of the other sectors in Swedish docs\\n aipname_, obj_ = x\\n logger.debug(\\\"Restoring \\\"+aipname_+\\\" \\\"+str(len(sectors)))\\n feature_ = deepcopy(feature)\\n logger.debug(\\\"Finalizing SAAB/SÄLEN: \\\" + aipname_)\\n finalize(feature_, features, obj_, source, aipname_, cta_aip, restrict_aip, aip_sup, tia_aip)\\n sectors = []\\n logger.debug(\\\"Finalizing last poly as .\\\"+aipname)\\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\\n\\n logger.debug(\\\"From %s to %s\\\", feature['properties'].get('from (ft amsl)'), feature['properties'].get('to (ft amsl)'))\\n return\\n\\n # IDENTIFY airspace naming\\n name = re_name.search(line) or re_name2.search(line) or re_name3.search(line) or re_name4.search(line) or \\\\\\n re_miscnames.search(line) or re_name5.search(line) or re_name_cr.search(line) or re_name6.search(line) or \\\\\\n re_name_openair.search(line)\\n\\n if name_cont and not 'Real time' in line:\\n aipname = aipname + \\\" \\\" + line\\n logger.debug(\\\"Continuing name as \\\"+aipname)\\n if line == '' or 'EN D' in aipname:\\n name_cont = False\\n\\n if name:\\n named=name.groupdict()\\n if en_enr_5_1 or \\\"Hareid\\\" in line:\\n logger.debug(\\\"RESTRICT/HAREID\\\")\\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\\n lastv = None\\n\\n name=named.get('name')\\n if 'polaris' in name.lower() and 'norway' in name.lower():\\n pos = name.lower().index('norway')\\n name = name[:pos]\\n\\n if name[:6]==\\\"Sector\\\" and \\\"ACC\\\" in aipname:\\n return\\n\\n if named.get('name_cont'):\\n name += ' '+named.get('name_cont')\\n name_cont=True\\n\\n if (name == \\\"Sector a\\\") or (name == \\\"Sector b\\\") or (aipname and (\\\"Sector\\\" in aipname) and ((\\\"SÄLEN\\\" in aipname) or (\\\"SAAB\\\" in aipname))):\\n return\\n if \\\"ES R\\\" in name or \\\"ES D\\\" in name:\\n name_cont=True\\n if \\\"EN D\\\" in name and len(name)<8:\\n name_cont=True\\n\\n if restrict_aip or military_aip:\\n if feature['properties'].get('from (ft amsl)') is not None and (feature['properties'].get('to (ft amsl)') or \\\"Romerike\\\" in aipname or \\\"Oslo\\\" in aipname):\\n logger.debug(\\\"RESTRICT/MILITARY + name and vertl complete\\\")\\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\\n lastv = None\\n else:\\n logger.debug(\\\"RESTRICT/MILITARY + name and vertl NOT complete\\\")\\n\\n aipname = name\\n logger.debug(\\\"Found name '%s' in line: %s\\\", aipname, line)\\n return\\n\\n # The airsport document doesn't have recognizable airspace names\\n # so we just assume every line that isn't otherwise parsed is the name of the next box.\\n if airsport_aip and line.strip():\\n logger.debug(\\\"Unhandled line in airsport_aip: %s\\\", line)\\n if wstrip(line)==\\\"1\\\":\\n logger.debug(\\\"Starting airsport_aip table\\\")\\n airsport_intable = True\\n elif wstrip(line)[0] != \\\"2\\\" and airsport_intable:\\n logger.debug(\\\"Considering as new aipname: '%s'\\\", line)\\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\\n aipname = wstrip(line)\\n\\n if line.strip()==\\\"-+-\\\":\\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\",\n \"def learn(self, line):\\n value = self.find(line)\\n if value is not \\\"notfound\\\" and not value in self._insts:\\n self._insts[value] = \\\"%s_%d\\\" % (self._clean_name, len(self._insts) - self._num_defaults + 1)\\n #if the line type requires multiple values to be replaced, do that instead of only searching for one\\n elif self._top_key != \\\"none\\\":\\n top_components = line.split(\\\",\\\")\\n for comp in top_components:\\n samples = comp.split(\\\"=\\\")\\n if self._top_key in samples[0]:\\n if samples[1] not in self._insts:\\n self._insts[samples[1]] = \\\"%s_%d\\\" % (self._clean_name, len(self._insts) - self._num_defaults + 1)\\n print self._insts[samples[1]]\",\n \"def _parse(self):\\n with open(self.input) as f:\\n for line in f:\\n if not line.lstrip().startswith(\\\"#\\\"): # comment\\n stripped_line=line.split(\\\"#\\\")[0].strip()\\n \\n # Initialise an empty option dictionary with some good defaults\\n if \\\"[\\\" in stripped_line:\\n molname=stripped_line.split()[1]\\n self.options[molname]=self.empty_option_dict.copy() # dict1=dict2 does not copy!\\n self.options[molname][\\\"MolName\\\"]=molname\\n if \\\":\\\" in stripped_line: \\n # now process line by line\\n if \\\"{\\\" not in stripped_line:\\n key,value=[i.strip() for i in stripped_line.split(\\\":\\\")]\\n\\n if key not in self.options[molname].keys():\\n raise BaseException(\\\"Option \\\\\\\"{}\\\\\\\" not known, please check your input file\\\".format(key))\\n self.options[molname][key]=value \\n else:\\n # This is to define special lines that are given by a dictionary\\n key,value=stripped_line.split(\\\":\\\",1) # split on first occurence\\n if key==\\\"Addon\\\": # additional atoms to be added per molecule\\n addondict=self.empty_addon_dict.copy()\\n addondict_string = value.split(\\\"}\\\",-1)[0].split(\\\"{\\\",1)[1]\\n for pair in addondict_string.split(\\\",\\\"):\\n addonkey,addonvalue=[i.strip() for i in pair.split(\\\":\\\")]\\n if addonkey not in addondict.keys():\\n raise BaseException(\\\"Option \\\\\\\"{}\\\\\\\" in Addon section of molecule {} not known, please check your input file\\\".format(addonkey,molname))\\n addondict[addonkey]=addonvalue\\n value=addondict\\n # Since addon keyword can be used many times, this is a list\\n self.options[molname][key].append(value) \\n self._check()\",\n \"def __init__(self, line):\\n (self.timestamp, self.status_code, self.content_length, self.url, self.hop_path, self.via,\\n self.mime, self.thread, self.start_time_plus_duration, self.hash, self.source,\\n self.annotation_string) = re.split(\\\" +\\\", line.strip(), maxsplit=11)\\n # Account for any JSON 'extra info' ending, strip or split:\\n if self.annotation_string.endswith(' {}'):\\n self.annotation_string = self.annotation_string[:-3]\\n elif ' {\\\"' in self.annotation_string and self.annotation_string.endswith('}'):\\n self.annotation_string, self.extra_json = re.split(re.escape(' {\\\"'), self.annotation_string, maxsplit=1)\\n self.extra_json = '{\\\"%s' % self.extra_json\\n # And split out the annotations:\\n self.annotations = self.annotation_string.split(',')\\n\\n # Some regexes:\\n self.re_ip = re.compile('^\\\\d{1,3}\\\\.\\\\d{1,3}\\\\.\\\\d{1,3}\\\\.\\\\d{1,3}$')\\n self.re_tries = re.compile('^\\\\d+t$')\\n self.re_dol = re.compile('^dol:\\\\d+') # Discarded out-links - make a total?\",\n \"def sanitize(self, line):\\n self.line_count = self.line_count + 1\\n components = line.split(\\\",\\\")\\n for comp in components:\\n # if any field has IP in it, see if the value matches something in the dict\\n items = comp.split(\\\"=\\\")\\n if \\\"ip\\\" in items[0]:\\n if items[1] in self._insts:\\n # found this dirty IP in our learned dictionary, replace it\\n dirty_ip = items[1]\\n clean_ip = self._insts[dirty_ip]\\n line = re.sub(dirty_ip, clean_ip, line, 1)\\n\\n # if this message has a pdu, clean up the pdu too\\n msg_type = self._extract_by_key(line, \\\"type\\\")\\n if \\\"sflow\\\" in msg_type or \\\"event\\\" in msg_type:\\n pdu = self._extract_by_key(line, \\\"pdu\\\")\\n # substitute the converted IP based on type\\n if \\\".\\\" in dirty_ip:\\n # v4\\n line = re.sub(self._v4_string_to_hex(dirty_ip),\\n self._v4_string_to_hex(clean_ip), line)\\n\\n pdu = self.fix_checksum(pdu)\\n\\n line = line[0: (line.find(\\\"pdu=\\\")) +4] + pdu + \\\",\\\\n\\\"\\n else:\\n # v6 - remove : and go to lower case before swap\\n dirty_swap = re.sub(\\\":\\\", \\\"\\\", dirty_ip)\\n dirty_swap = dirty_swap.lower()\\n line = re.sub(dirty_swap, self._v4_string_to_hex(clean_ip), line)\\n if (args.hexdump):\\n pdu_hex = pdu\\n pdu_hex = \\\" \\\".join(pdu_hex[i:i+2] for i in range(0, len(pdu_hex), 2)) #put timestamp and offset in front of pdu hex\\n pdu_hex = pdu[0:15] + \\\" 000000 \\\" + pdu_hex + \\\" ,\\\\n\\\"\\n hexdump_file.write(pdu_hex)\\n return line\",\n \"def parse_entry(self, entry_string):\\n entry_type, entry_string = self.pop_entry_type(entry_string)\\n cite_key, entry_string = self.pop_key(entry_string)\\n field_dict = dict(self.extract_fields(entry_string))\\n field_dict[\\\"type\\\"] = entry_type\\n self.force_field.citations[cite_key] = field_dict\",\n \"def parse_line(line, key):\\n keys = key.split(', ')\\n ParseLine = (line.get(id) for id in keys)\\n\\n return ParseLine\",\n \"def parse_wrapper_line(line, linecnt):\\n #pylint: disable=unbalanced-tuple-unpacking\\n wrapinfo = {}\\n lineparts = miscutils.fwsplit(line.strip())\\n if len(lineparts) == 5:\\n (wrapinfo['wrapnum'], wrapinfo['wrapname'], wrapinfo['wclfile'], wrapinfo['wrapdebug'], wrapinfo['logfile']) = lineparts\\n elif len(lineparts) == 4:\\n (wrapinfo['wrapnum'], wrapinfo['wrapname'], wrapinfo['wclfile'], wrapinfo['logfile']) = lineparts\\n wrapinfo['wrapdebug'] = 0 # default wrapdebug\\n else:\\n print \\\"Error: incorrect number of items in line #%s\\\" % linecnt\\n print \\\" Check that modnamepat matches wrapperloop\\\"\\n print \\\"\\\\tline: %s\\\" % line\\n raise SyntaxError(\\\"Error: incorrect number of items in line #%s\\\" % linecnt)\\n #wrapinfo['logfile'] = None\\n return wrapinfo\",\n \"def parseLine(self, line):\\n # Removes surrounding whitespace\\n line = self.separateElements(line)\\n if len(line) == 0: return\\n # Checks if the line is a label declaration\\n if line[0].lower() == \\\"label\\\":\\n # --Validates the line\\n if len(line) != 2: raise Exception(\\\"Invalid Label\\\")\\n if len(line[1]) < 2: raise Exception(\\\"Invalid Label\\\") \\n if line[1][-1] != ':': raise Exception(\\\"Invalid Label\\\")\\n # Gets the label name\\n labelName = line[1][:-1]\\n\\n # Creates a new symbol entry for the label, the pointer refers to the memory location of the label\\n # It defaults to the location of the label in the instruction sequence\\n self.symbolTable.append({ \\\"type\\\": \\\"LABEL\\\", \\\"name\\\": labelName, \\\"pointer\\\": len(self.instructionList) * 4})\\n # Checks if the line is data declaration\\n elif line[0].lower() == \\\"data\\\" or (line[0].lower()[:4] == \\\"data\\\" and line[0][4] == \\\"[\\\"):\\n # Removes the DATA tag from the data\\n line[0] = line[0][4:]\\n # --Validates the line\\n if len(line) < 2: raise Exception(\\\"Invalid DATA\\\")\\n # Gets the data name\\n dataName = line[1]\\n # Stores the data length\\n dataLength = 4 # A word\\n # Gets any default data\\n defaultData = 0\\n # Stores the data type\\n dataType = \\\"int\\\"\\n if len(line) == 3:\\n if line[2][0] == \\\"\\\\\\\"\\\" and line[2][-1] == \\\"\\\\\\\"\\\":\\n dataType = \\\"string\\\"\\n defaultData = line[2][1:-1]\\n dataLength = len(defaultData)\\n elif line[2].isnumeric():\\n defaultData = line[2]\\n elif line[2][-1] == 'f' and line[2][:-1].isnumeric():\\n dataType = \\\"float\\\"\\n defaultData = line[2][0]\\n # Checks if a data length was given\\n if len(line[0]) > 2 and (line[0][0] == \\\"[\\\" and line[0][-1] == \\\"]\\\"):\\n data = line[0][1:-1]\\n if not data.isnumeric(): raise TypeError(\\\"Invalid data length type\\\")\\n dataLength = int(data)\\n\\n # Creates a new symbol entry for the data\\n self.symbolTable.append({ \\\"type\\\": \\\"DATA\\\", \\\"name\\\": dataName, \\\"default\\\": defaultData, \\\"dataType\\\": dataType, \\\"length\\\": dataLength})\\n # The line is most likely an instruction\\n else:\\n # --Validates the line\\n #Stores the control bits\\n controlBits = 1 << 5 # Sets it to 0b100000\\n # Checks if the first element is control bits\\n if line[0][0] == \\\"{\\\" and line[0][-1] == \\\"}\\\": # First element is control bits\\n # Separates the two sections of the control bits\\n controlSections = line[0].split(':')\\n #Goes through the characters and constructs the control bits for the instruction\\n carryBits = controlSections[0].lower()\\n carryFlag = int('c' in carryBits)\\n zeroFlag = int('z' in carryBits)\\n negativeFlag = int('n' in carryBits)\\n signedOverflowFlag = int('s' in carryBits)\\n #Gets the conditions bits\\n if len(controlSections) == 2:\\n conditionBits = controlSections[1].lower()\\n isAnd = int('x' in conditionBits)\\n isOne = int('1' in conditionBits)\\n #Sets the last two bits on controlBits to the conditionBits\\n controlBits ^= isAnd << 1\\n controlBits ^= isOne\\n # Constructs the control bits section\\n controlBits ^= carryFlag << 5\\n controlBits ^= zeroFlag << 4\\n controlBits ^= negativeFlag << 3\\n controlBits ^= signedOverflowFlag << 2\\n # Removes the control bits section from the line\\n line.pop(0)\\n # Performs this check as the controlbits element gets removed (if it existed) and so the length of the elments could be zerp\\n if len(line) == 0: raise Exception(\\\"Invalid Instruction\\\")\\n # --The first element is the instruction\\n # Identifies the instruction from the mnemonic using the lookup table\\n if line[0] in self.InstructionLookupTable:\\n ins = self.InstructionLookupTable[line[0]]\\n insCode = ins[\\\"code\\\"]\\n insControlBits = ins['controlBits'] if ins['controlBits'] else controlBits\\n # Creates a representation of the instruction, this is stored in the instructionList and is assembled later\\n instrucitonRepr = {\\n \\\"code\\\": insCode,\\n \\\"controlBits\\\": insControlBits,\\n }\\n # Parses the arguments given and stores the operandStruct returned in the instruciton representation\\n if len(line) > 1: instrucitonRepr[\\\"operand\\\"] = self.parseArgs(line[1:], insCode)\\n self.instructionList.append(instrucitonRepr)\",\n \"def parse_line(self, line):\\n if self.signal_eof:\\n return \\\"\\\"\\n\\n match = re.search(\\\"^([\\\\w\\\\s]+from) ([^:]+):(\\\\d+)(:|,)$\\\", line)\\n if match:\\n return self.parse_line_from(match)\\n\\n match = re.search(\\\"^([^:]+):(?:((?:\\\\d+:)?\\\\d+):)?(?:(error|warning|note):)?(.+)$\\\", line)\\n if match:\\n return self.parse_line_err(match)\\n\\n return line\",\n \"def update_gene_info(ensembl_info, word, value):\\n if \\\"gene\\\" in word:\\n if \\\"id\\\" in word:\\n ensembl_info[\\\"ensembl_gene_id\\\"] = value\\n elif \\\"start\\\" in word:\\n ensembl_info[\\\"gene_start\\\"] = int(value)\\n elif \\\"end\\\" in word:\\n ensembl_info[\\\"gene_end\\\"] = int(value)\\n return ensembl_info\",\n \"def _parse_line(self, line):\\n with open(self._manifest.path, 'r') as manifest_file:\\n if isinstance(line, str):\\n assert line in self.BASE_INFORMATION.keys(), \\\\\\n 'An attempt to get non-existent information from the manifest'\\n for _ in range(self.BASE_INFORMATION[line]):\\n fline = manifest_file.readline()\\n return json.loads(fline)[line]\\n else:\\n assert self._index, 'No prepared index'\\n offset = self._index[line]\\n manifest_file.seek(offset)\\n properties = manifest_file.readline()\\n return json.loads(properties)\",\n \"def _parse_file_line(line):\\n # match initially added ebuilds\\n match = ebuild_ADM_regex.match(line)\\n if match:\\n status = match.group('status')\\n category = match.group('category')\\n pkg = match.group('P')\\n try:\\n return atom_cls(f'={category}/{pkg}'), status\\n except MalformedAtom:\\n return None\\n\\n # match renamed ebuilds\\n match = ebuild_R_regex.match(line)\\n if match:\\n status = match.group('status')\\n category = match.group('category')\\n pkg = match.group('P')\\n try:\\n return atom_cls(f'={category}/{pkg}'), status\\n except MalformedAtom:\\n return None\",\n \"def processFileLocInfo(self):\\n\\t\\t# If bit 1 of the flags field is set\\n\\t\\tif int(self.header['flags']) & 2 > 0:\\n\\n\\t\\t\\t# Read size of file location info\\n\\t\\t\\ttxt = self.fpLnk.read(4)\\n\\t\\t\\tself.file_loc = {}\\n\\t\\t\\tself.file_loc['size'] = struct.unpack(\\\"<I\\\", txt)[0]\\n\\t\\t\\t\\t\\n\\t\\t\\t# Read size of file location info and prepend the previous read value.\\n\\t\\t\\t# Txt was prepended to remove a special condition case need to skip\\n\\t\\t\\t# the re-reading of the size field.\\n\\t\\t\\tfile_loc_raw = txt + self.fpLnk.read(self.file_loc['size'] - 4)\\n\\n\\t\\t\\t# Loop throuh predefine file format, extracting field into a new data\\n\\t\\t\\t# file location header dictionary.\\n\\t\\t\\t# XXX: do we really want to clobber the dictionary we just created\\n\\t\\t\\t# and not self.file_loc.update(parseStructuredData())?\\n\\t\\t\\tself.file_loc = parseStructuredData(file_loc_raw, FILE_LOC_HEADER)\\n\\t\\t\\n\\t\\t\\t# Process local volume info if flag is set\\n\\t\\t\\tif (self.file_loc['flags'] & 1) > 0:\\n\\t\\t\\t\\tlocalVolTbl = processVolTbl(file_loc_raw, \\n\\t\\t\\t\\t\\tself.file_loc['local_vol_info_offset'], LOCAL_VOL_TBL)\\n\\t\\t\\t\\tself.file_loc['localVolTbl'] = localVolTbl\\n\\t\\t\\t\\toffset = self.file_loc['local_base_path_offset']\\n\\t\\t\\t\\tbasePathname = file_loc_raw[offset:].split('\\\\x00')[0]\\n\\t\\t\\t\\tself.file_loc['basePathname'] = basePathname\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.file_loc['localVolTbl'] = None\\n\\n\\t\\t\\t# Process net volume info if flag is set\\n\\t\\t\\tif (self.file_loc['flags'] & 2) > 0:\\n\\t\\t\\t\\tnetVolTbl = processVolTbl(file_loc_raw, \\n\\t\\t\\t\\t\\tself.file_loc['net_vol_info_offset'], NET_VOL_TBL)\\n\\t\\t\\t\\tself.file_loc['netVolTbl'] = netVolTbl\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.file_loc['netVolTbl'] = None\\n\\n\\t\\t\\t# Process remaining portion of pathname\\n\\t\\t\\toffset = self.file_loc['remain_pathname_offset']\\n\\t\\t\\tremainPathname = file_loc_raw[offset:].split('\\\\x00')[0]\\n\\t\\t\\tself.file_loc['remainPathname'] = remainPathname\",\n \"def _read_header(self, line):\\n try:\\n creation_date = datetime.strptime(line[23:33], '%y%m%d%H%M')\\n except ValueError as err:\\n print('Error parsing file creation date -> ' + str(err))\\n creation_date = '000000'\\n\\n self.file_header = {'Priority Code': line[1:3],\\n 'Immediate Destination': line[3:13].strip(),\\n 'Immediate Origin': line[13:23].strip(),\\n 'Creation Date': creation_date,\\n 'File ID Modifier': line[33],\\n 'Record Size': int(line[34:37].strip()),\\n 'Blocking Factor': int(line[37:39]),\\n 'Format Code': line[39],\\n 'Immediate Destination Name': line[40:63].strip(),\\n 'Immediate Origin Name': line[63:86].strip(),\\n 'Reference Code': line[86:93]}\",\n \"def process_line(self, line, data):\\n return data\",\n \"def _read_header_line_1(self, lines: list) -> dict:\\n fields = (\\n \\\"model_id\\\",\\n \\\"unit_id\\\",\\n \\\"software_level\\\",\\n \\\"message_number\\\",\\n \\\"message_subclass\\\",\\n )\\n if self._is_ct25k():\\n indices = [1, 3, 4, 6, 7, 8]\\n else:\\n indices = [1, 3, 4, 7, 8, 9]\\n values = [split_string(line, indices) for line in lines]\\n return values_to_dict(fields, values)\",\n \"def _parse(self):\\n\\n self.specification = {}\\n\\n while True:\\n try:\\n line = self._lines.current\\n if ':' in line:\\n self.specification.update(self._parse_spec())\\n elif line.startswith('NODE_COORD_SECTION'):\\n next(self._lines)\\n self.coords = self._parse_coords()\\n elif line.startswith('EDGE_WEIGHT_SECTION'):\\n next(self._lines)\\n self.weights = self._parse_weights()\\n elif line.startswith('DISPLAY_DATA_SECTION'):\\n next(self._lines)\\n self.display = self._parse_coords()\\n else:\\n break\\n except StopIteration:\\n break\\n\\n del self._lines\",\n \"def ReadBasicInfo():\\r\\n\\r\\n EquilibriumStep, ProductionStep,HEPCP,HEPCE,Multiple=10000000,10000000,100,100,2\\r\\n InputPath,OutputPath,AtomParameterPath,TaskSuffix,MaterialInputFormat='..','..','..','','mol'\\r\\n GasType,GasAtomTypeNum,GasAtomType,GasPartialPressure,TemperatureList,PressureList,\\\\\\r\\n TorqueSetting,MuSiCSetting,Nodes=[],[],[],[],[],[],[],[],['1:ppn=1']\\r\\n CutOff,GridSpacingP,GridSpacingE=12.8,2.0,2.0\\r\\n MakeGCMC,UsePmap,UseEmap,UsePost,MakePmap,MakeEmap,MakeTorque,KeyOne,KeyTwo,\\\\\\r\\n PDBCharges = False,False,False,False,False,False,False,False,False,False\\r\\n\\r\\n with open('GlueParameters', 'r') as File:\\r\\n for Line in File.readlines():\\r\\n if Line.strip():\\r\\n WordList = Line.strip().split()\\r\\n if len(WordList)>1 or KeyOne==True or KeyTwo==True:\\r\\n if WordList[0]=='#':\\r\\n continue\\r\\n\\r\\n # Controlled part\\r\\n elif WordList[0] == 'MakeGCMC:' and WordList[1] == 'open':\\r\\n MakeGCMC = True\\r\\n elif WordList[0] == 'UsePmap:' and WordList[1] == 'yes':\\r\\n UsePmap = True\\r\\n elif WordList[0] == 'UseEmap:' and WordList[1] == 'yes':\\r\\n UseEmap = True\\r\\n elif WordList[0] == 'UsePost:' and WordList[1] == 'yes':\\r\\n UsePost = True\\r\\n elif WordList[0] == 'MakePmap:' and WordList[1] == 'open':\\r\\n MakePmap = True\\r\\n elif WordList[0] == 'MakeEmap:' and WordList[1] == 'open':\\r\\n MakeEmap = True\\r\\n elif WordList[0] == 'MakeTorque:' and WordList[1] == 'open':\\r\\n MakeTorque = True\\r\\n elif WordList[0] == 'UseChargesFromPDBFile:' and WordList[1] == 'yes':\\r\\n PDBCharges = True\\r\\n\\r\\n # Basic part\\r\\n elif WordList[0]=='InputPath:':\\r\\n InputPath=WordList[1]\\r\\n elif WordList[0]=='MaterialInputFormat:':\\r\\n MaterialInputFormat=WordList[1]\\r\\n elif WordList[0]=='OutputPath:':\\r\\n OutputPath=WordList[1]\\r\\n elif WordList[0]=='AtomParameterPath:':\\r\\n AtomParameterPath=WordList[1]\\r\\n elif WordList[0] == 'GasType:':\\r\\n GasType = list(WordList[1:])\\r\\n elif WordList[0] == 'GasAtomTypeNum:':\\r\\n\\r\\n for i in WordList[1:]:\\r\\n GasAtomTypeNum.append(int(i))\\r\\n\\r\\n elif WordList[0] == 'GasAtomType:':\\r\\n GasAtomType = list(WordList[1:])\\r\\n elif WordList[0] == 'Multiple:':\\r\\n Multiple = int(WordList[1])\\r\\n elif WordList[0] == 'CutOff:':\\r\\n CutOff = float(WordList[1])\\r\\n\\r\\n # GCMC part\\r\\n\\r\\n elif WordList[0] == 'GasPartialPressure:':\\r\\n\\r\\n for j in WordList[1:]:\\r\\n GasPartialPressure.append(str(j))\\r\\n\\r\\n elif WordList[0] == 'TemperatureList(K):':\\r\\n\\r\\n for l in WordList[1:]:\\r\\n TemperatureList.append(float(l))\\r\\n\\r\\n elif WordList[0] == 'PressureList(kPa):':\\r\\n\\r\\n for k in WordList[1:]:\\r\\n PressureList.append(float(k))\\r\\n\\r\\n elif WordList[0] == 'EquilibriumStep:':\\r\\n EquilibriumStep = int(WordList[1])\\r\\n elif WordList[0] == 'ProductionStep:':\\r\\n ProductionStep = int(WordList[1])\\r\\n\\r\\n # Pmap part\\r\\n elif WordList[0] == 'GridSpacingP(Ang):':\\r\\n GridSpacingP = float(WordList[1])\\r\\n elif WordList[0] == 'HighEndPotentialCutoffP(kJ/mol):':\\r\\n HEPCP = int(WordList[1])\\r\\n\\r\\n # Emap part\\r\\n elif WordList[0] == 'GridSpacingE(Ang):':\\r\\n GridSpacingE = float(WordList[1])\\r\\n elif WordList[0] == 'HighEndPotentialCutoffE(kJ/mol):':\\r\\n HEPCE = int(WordList[1])\\r\\n\\r\\n # Torque part\\r\\n elif WordList[0] == 'Nodes:':\\r\\n Nodes = WordList[1:]\\r\\n elif WordList[0] == 'TaskSuffix:':\\r\\n TaskSuffix = WordList[1]\\r\\n elif WordList[0] == 'TorqueSetting:':\\r\\n KeyOne = True\\r\\n elif WordList[0] == 'MuSiCSetting:':\\r\\n KeyOne = False\\r\\n KeyTwo = True\\r\\n elif WordList[0] == 'END':\\r\\n KeyTwo = False\\r\\n elif KeyOne == True:\\r\\n TorqueSetting.append(Line)\\r\\n elif KeyTwo == True:\\r\\n MuSiCSetting.append(Line)\\r\\n\\r\\n return (InputPath,OutputPath,AtomParameterPath,MakeTorque,GasType,\\r\\n GasAtomTypeNum,GasAtomType,GasPartialPressure,TemperatureList,PressureList,CutOff,MakeGCMC,UsePmap,\\r\\n UseEmap,UsePost,MakePmap,MakeEmap,EquilibriumStep,ProductionStep,GridSpacingP,HEPCP,GridSpacingE,HEPCE,\\r\\n Multiple,TorqueSetting,MuSiCSetting,Nodes,TaskSuffix,PDBCharges,MaterialInputFormat)\",\n \"def __build_line_update(self, line):\\n\\n output = \\\"\\\"\\n if line not in self.__line_messages_copy.keys():\\n return output\\n\\n if self.__line_messages_copy[line][\\\"passengers\\\"]:\\n output += self.__build_update_regarding_passengers(line) + \\\"\\\\n\\\"\\n if self.__line_messages_copy[line][\\\"buses\\\"]:\\n output += self.__build_update_regarding_buses(line) + \\\"\\\\n\\\"\\n if self.__line_messages_copy[line][\\\"kick reason\\\"] != \\\"\\\" and self.__line_messages_copy[line][\\n \\\"kick_reason\\\"] not in self.__global_messages_copy[\\\"kick reason\\\"]:\\n output += f\\\"kicked for:{self.__line_messages_copy[line]['kick reason']}\\\" + \\\"\\\\n\\\"\\n if self.__line_messages_copy[line][\\\"free text\\\"] != \\\"\\\" and self.__line_messages_copy[line][\\\"free text\\\"] not in \\\\\\n self.__global_messages_copy[\\\"free text\\\"]:\\n output += \\\"free text:\\\" + self.__line_messages_copy[line][\\\"free text\\\"] + \\\"\\\\n\\\"\\n return output\",\n \"def HST_info(info_file):\\n info_values = {}\\n f = open(info_file, 'r')\\n # the first line must contain PyHST or NUM_X\\n line = f.readline()\\n if line.startswith('! PyHST'):\\n # read an extra line\\n line = f.readline()\\n elif line.startswith('NUM_X'):\\n pass\\n else:\\n sys.exit('The file does not seem to be a PyHST info file')\\n info_values['x_dim'] = int(line.split()[2])\\n info_values['y_dim'] = int(f.readline().split()[2])\\n info_values['z_dim'] = int(f.readline().split()[2])\\n try:\\n info_values['data_type'] = f.readline().split()[2]\\n except IndexError:\\n pass\\n return info_values\",\n \"def update(self, line):\",\n \"def _process_info_message(self, message):\\n # Extract the output resolution from the appropriate message, if\\n # it's present.\\n contents = message.get('contents', None)\\n if message['messageCode'] == 'JOB_RUNNING_RESOLUTION':\\n self._resolution = contents['resolutionMs']\\n elif message['messageCode'] == 'FETCH_NUM_TIMESERIES':\\n self._num_input_timeseries += int(message['numInputTimeSeries'])\\n elif message['messageCode'] == 'FIND_MATCHED_NO_TIMESERIES':\\n self._find_matched_no_timeseries = True\\n elif message['messageCode'] == 'FIND_LIMITED_RESULT_SET':\\n self._find_limited_resultset = True\\n self._find_matched_size = contents['matchedSize']\\n self._find_limit_size = contents['limitSize']\\n elif message['messageCode'] == 'GROUPBY_MISSING_PROPERTY':\\n self._group_by_missing_property = True\\n self._group_by_missing_properties = contents['propertyNames']\",\n \"def _parse_header(self, line):\\n if self._regex_helper.search_compiled(W._re_header, line):\\n if not self.headers:\\n for value in re.findall(W._re_header, line):\\n self.headers.append(value[0])\\n raise ParsingDone\\n else:\\n # Dictionary which is going to be appended to the returned list\\n ret = dict()\\n # List of entries\\n _entries = list()\\n # List of values in WHAT entry\\n _what_entry = list()\\n for value in re.findall(W._re_header, line):\\n _entries.append(value[0])\\n for what_index in range(len(self.headers) - 1, len(_entries)):\\n _what_entry.append(_entries[what_index])\\n _what_entry_string = ' '.join(_what_entry)\\n for index in range(len(self.headers)):\\n if index < len(self.headers) - 1:\\n ret.update({self.headers[index]: _entries[index]})\\n else:\\n ret.update({self.headers[index]: _what_entry_string})\\n self.current_ret['RESULT'].append(ret)\\n raise ParsingDone\",\n \"def parseLine(self,incoming):\\n\\t\\tself.addContentLine(incoming)\\n\\t\\tif incoming.mustProcess == 0: return \\n\\t\\tself.iLineObject = incoming\\n\\t\\titems = self.iLineObject.getItems()\\n\\t\\tkeyword = string.upper(items[0])\\n\\t\\tif len(items) < 2: \\n\\t\\t\\tif not keyword in self.sQuotedKeywords: \\n\\t\\t\\t\\tself.addErrorMessage('2. Unrecognized keyword SIMULATOR_BLOCK:', self.iLineObject)\\n\\t\\t\\treturn\\n\\t\\tself.parseKeyword(keyword,items[1:])\",\n \"def parse_galrep_line(L):\\n data = L.split(maxsplit=1)\\n record = parse_galrep_data_string(\\\"\\\" if len(data) == 1 else data[1])\\n record['label'] = label = data[0]\\n return label, record\",\n \"def process_gene_line(self, line):\\n kwargs = self.extract_gene_args(line)\\n if not kwargs:\\n return\\n gene_id = kwargs['identifier']\\n self.genes[gene_id] = Gene(**kwargs)\",\n \"def from_info(self, info: Dict[str, Any]) -> None:\",\n \"def setup_parser(self) -> Dict[str, Any]:\\n\\n\\n # % GALAT - SPP Single Point Positioning\\n # % -------------------------------------\\n # % Processing Option\\n # % ------------------\\n # % GNSS system(s) : GALILEO\\n # % Orbit type : Broadcast - INAV\\n # % Solution type : SPP\\n # % Frequency : E1\\n # % Elevation mask : 5.0 deg\\n # % Time interval : 30.0 s\\n # % Ionosphere opt : NeQuick-G\\n # % Troposhere opt : GMF with GPT\\n # % Obs start : 2020/01/04 00:00:00.0 GPST (week 2086 518400.0s)\\n # % Obs end : 2020/01/04 23:59:30.0 GPST (week 2086 604770.0s)\\n # % Epoch expected : 2880\\n # % Epoch have : 2880\\n # %\\n # % Input file(s) : KOUG00GUF_R_20200040000_01D_30S_MO.rnx\\n # % Input file(s) : CNES0030.20L\\n # % Input file(s) : CNES0040.20L\\n # % Input file(s) : igs14.atx\\n # %\\n # % RINEX header info\\n # % ------------------\\n # % Marker : KOUG 97301M402\\n # % Receiver T/V/# : SEPT POLARX5TR 5.3.0 17323022503\\n # % Antenna T/ /# : LEIAR25.R3 LEIT 10180007\\n # % Position XYZ : 3855263.3407 -5049731.9986 563040.4252\\n # % Antenna H/E/N : 0.0000 0.0000 0.0000\\n self._parse_header()\\n\\n # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+--\\n # 2020/01/04 00:00:00 5.098466365 -52.639742999 106.8901 -0.603 -0.821 -0.349 1.018 0.349 \\n # 2020/01/04 00:00:30 5.098466094 -52.639742684 107.4962 -0.633 -0.856 0.257 1.065 0.257 \\n # 2020/01/04 00:01:00 5.098466030 -52.639740961 107.6125 -0.640 -1.047 0.373 1.228 0.373 \\n return dict(\\n names=(\\n \\\"yyyymmdd\\\", \\n \\\"hhmmss\\\", \\n \\\"latitude\\\", \\n \\\"longitude\\\", \\n \\\"height\\\", \\n \\\"dlatitude\\\", \\n \\\"dlongitude\\\", \\n \\\"dheight\\\",\\n \\\"hpe\\\",\\n \\\"vpe\\\",\\n \\\"site_vel_3d\\\",\\n \\\"pdop\\\",\\n \\\"num_satellite_available\\\",\\n \\\"num_satellite_used\\\",\\n ),\\n comments=\\\"%\\\",\\n delimiter=(10, 9, 15, 15, 10, 9, 9, 9, 9, 9, 9, 6, 4, 4),\\n dtype=(\\\"U10\\\", \\\"U9\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\", \\\"f8\\\"),\\n autostrip=True,\\n )\",\n \"def parse_pdb(self, line):\\n super().parse_pdb(line)\\n self.num_remark = int(line[10:15].strip())\\n self.num_het = int(line[20:25].strip())\\n self.num_helix = int(line[25:30].strip())\\n self.num_sheet = int(line[30:35].strip())\\n self.num_turn = int(line[35:40].strip())\\n self.num_site = int(line[40:45].strip())\\n self.num_xform = int(line[45:50].strip())\\n self.num_coord = int(line[50:55].strip())\\n self.num_ter = int(line[55:60].strip())\\n self.num_conect = int(line[60:65].strip())\\n self.num_seq = int(line[65:70].strip())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6655572","0.65438634","0.61774","0.6080733","0.6014996","0.59691495","0.5966504","0.5905911","0.58785135","0.583794","0.5830027","0.57280356","0.5722466","0.56339806","0.562032","0.5615857","0.5602782","0.5572568","0.5570758","0.5545635","0.5519029","0.5480071","0.5456602","0.5442831","0.5408473","0.5386417","0.53773934","0.5375964","0.5373519","0.536676","0.5365131","0.5354858","0.53058696","0.5305234","0.529679","0.529501","0.5212292","0.5207818","0.52038157","0.5179252","0.51746005","0.5170729","0.51579404","0.51294386","0.5127966","0.5125792","0.51240075","0.51196265","0.5114673","0.51132065","0.5111363","0.5103664","0.5097887","0.5084753","0.5075824","0.5059386","0.50564784","0.5053303","0.5051317","0.5046579","0.5044943","0.5035021","0.5033949","0.5019699","0.5017364","0.49994844","0.49951276","0.49940473","0.49925864","0.4991734","0.49861032","0.4983619","0.4979395","0.4970001","0.49482456","0.49477333","0.4945728","0.49448672","0.49375468","0.49226156","0.49149215","0.4905524","0.48961043","0.48912662","0.48892015","0.48880985","0.4883863","0.4877732","0.4875491","0.48674554","0.48629525","0.48550472","0.4851036","0.48501697","0.48483124","0.48388484","0.48381573","0.48307824","0.4826307","0.48226315"],"string":"[\n \"0.6655572\",\n \"0.65438634\",\n \"0.61774\",\n \"0.6080733\",\n \"0.6014996\",\n \"0.59691495\",\n \"0.5966504\",\n \"0.5905911\",\n \"0.58785135\",\n \"0.583794\",\n \"0.5830027\",\n \"0.57280356\",\n \"0.5722466\",\n \"0.56339806\",\n \"0.562032\",\n \"0.5615857\",\n \"0.5602782\",\n \"0.5572568\",\n \"0.5570758\",\n \"0.5545635\",\n \"0.5519029\",\n \"0.5480071\",\n \"0.5456602\",\n \"0.5442831\",\n \"0.5408473\",\n \"0.5386417\",\n \"0.53773934\",\n \"0.5375964\",\n \"0.5373519\",\n \"0.536676\",\n \"0.5365131\",\n \"0.5354858\",\n \"0.53058696\",\n \"0.5305234\",\n \"0.529679\",\n \"0.529501\",\n \"0.5212292\",\n \"0.5207818\",\n \"0.52038157\",\n \"0.5179252\",\n \"0.51746005\",\n \"0.5170729\",\n \"0.51579404\",\n \"0.51294386\",\n \"0.5127966\",\n \"0.5125792\",\n \"0.51240075\",\n \"0.51196265\",\n \"0.5114673\",\n \"0.51132065\",\n \"0.5111363\",\n \"0.5103664\",\n \"0.5097887\",\n \"0.5084753\",\n \"0.5075824\",\n \"0.5059386\",\n \"0.50564784\",\n \"0.5053303\",\n \"0.5051317\",\n \"0.5046579\",\n \"0.5044943\",\n \"0.5035021\",\n \"0.5033949\",\n \"0.5019699\",\n \"0.5017364\",\n \"0.49994844\",\n \"0.49951276\",\n \"0.49940473\",\n \"0.49925864\",\n \"0.4991734\",\n \"0.49861032\",\n \"0.4983619\",\n \"0.4979395\",\n \"0.4970001\",\n \"0.49482456\",\n \"0.49477333\",\n \"0.4945728\",\n \"0.49448672\",\n \"0.49375468\",\n \"0.49226156\",\n \"0.49149215\",\n \"0.4905524\",\n \"0.48961043\",\n \"0.48912662\",\n \"0.48892015\",\n \"0.48880985\",\n \"0.4883863\",\n \"0.4877732\",\n \"0.4875491\",\n \"0.48674554\",\n \"0.48629525\",\n \"0.48550472\",\n \"0.4851036\",\n \"0.48501697\",\n \"0.48483124\",\n \"0.48388484\",\n \"0.48381573\",\n \"0.48307824\",\n \"0.4826307\",\n \"0.48226315\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8499883"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21961,"cells":{"query":{"kind":"string","value":"Parse V option output in line and append it to RESULT list."},"document":{"kind":"string","value":"def _parse_v_option(self, line):\n if self._regex_helper.search_compiled(W._re_v_option, line):\n self.current_ret['RESULT'].append(self._regex_helper.group(\"V_OPTION\"))\n raise ParsingDone"},"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 processOption (self, line) :\n ll = line.split ('=')\n if len (ll) < 2:\n print \"Cannot parse option \" , line\n sys.exit()\n result = (ll[0].strip() , ll[1].strip())\n return result","def _parse_results(self):\n for line in self.file_dic['output'].splitlines():\n if line.startswith(' * GAMESS VERSION = '):\n temp = line.split('=')[1]\n temp = temp.split('*')[0]\n self.version = temp.strip()\n\n if line[1:25] == 'FREE ENERGY OF SOLVATION' and line.find('1 ATM') == -1:\n temp = line.split()\n #Take the next number after =\n #In KCAL/MOL\n self.solvation_energy = float(temp[temp.index(\"=\") + 1])","def parse_output(result):\n output = result['output']\n parsed = output.split('\\n')\n output = []\n for _line in parsed:\n output.append(_line.strip())\n log.debug(_line)\n return output","def _do_option(self, line: str) -> None:\n if line.startswith(\"option verbosity\"):\n self._verbosity = Level(int(line[len(\"option verbosity \") :]))\n _write(\"ok\")\n else:\n _write(\"unsupported\")","def parse_results(variants):\n out = []\n\n # set header\n lines = variants[0].get_output().split('\\n')\n for line in lines[:-1]:\n out.append(line.split('\\t')[0])\n\n # append output for all variants to single list\n for var in variants:\n lines = var.get_output().split('\\n')\n for i in range(0, len(lines) - 1):\n out[i] += '\\t{}'.format(lines[i].split()[1])\n\n return out","def v_action(option,opt_str,value,parser):\n cmdline_main.message(\"Enabling verbose message output.\")\n if hasattr(parameterized,'get_logger'):\n parameterized.get_logger().setLevel(parameterized.VERBOSE)\n else: # For versions of the param package before 9 May 2013\n parameterized.min_print_level=parameterized.VERBOSE","def on_new_line(self, line, is_full_line):\n try:\n if is_full_line:\n self._parse_v_option(line)\n self._parse_general_info(line)\n self._parse_header(line)\n except ParsingDone:\n pass # line has been fully parsed by one of above parse-methods\n return super(W, self).on_new_line(line, is_full_line)","def __init__(self, optv):\n self.__p4optv = optv\n # Treat '-g' like '-G' except the marshal'ed Python dicts\n # will be unmarshal'ed.\n if '-g' in self.__p4optv:\n self.__p4optv[self.__p4optv.index('-g')] = '-G'\n self.__unmarshal = 1\n else:\n self.__unmarshal = 0\n # Drop '-s'. 'p4' implements this on the client side and so\n # should 'px' (XXX though it does not yet), so the option should\n # not be passed to the server.\n if '-s' in self.__p4optv:\n self.__p4optv.remove('-s')\n log.warn(\"dropping '-s' option, px cannot yet handle it\")\n _ListCmd.__init__(self)","def parse_options():\n\n from optparse import OptionParser\n usage = r\"\"\"%prog [options] <voxel_file>\"\"\"\n p = OptionParser(usage=usage)\n p.add_option('-o', '--output', action='store', dest='output',\n default='plot', help='Path to output SILO or VTK file.')\n p.add_option('-v', '--vtk', action='store_true', dest='vtk',\n default=False, help='Flag to convert to VTK instead of SILO.')\n parsed = p.parse_args()\n if not parsed[1]:\n p.print_help()\n return parsed\n return parsed","def process_options(self):\n\n argv = sys.argv\n\n # process any optlist_ options\n self.valid_opts.check_special_opts(argv)\n\n # process terminal options without the option_list interface\n # (so that errors are not reported)\n\n # if no arguments are given, do default processing\n if '-help' in argv or len(argv) < 2:\n print(g_help_string)\n return 1\n\n if '-hist' in argv:\n print(g_history)\n return 1\n\n if '-show_valid_opts' in argv:\n self.valid_opts.show('', 1)\n return 1\n\n if '-ver' in argv:\n print(g_version)\n return 1\n\n # ============================================================\n # read options specified by the user\n self.user_opts = OL.read_options(argv, self.valid_opts)\n uopts = self.user_opts # convenience variable\n if not uopts: return -1 # error condition\n\n # ------------------------------------------------------------\n # process verb first\n\n val, err = uopts.get_type_opt(int, '-verb')\n if val != None and not err: self.verb = val\n\n # ------------------------------------------------------------\n # process options sequentially, to make them like a script\n errs = 0\n for opt in self.user_opts.olist:\n # check for anything to skip\n if opt.name == '-verb': pass\n\n elif opt.name == '-infiles':\n self.infiles, err = uopts.get_string_list('', opt=opt)\n if self.infiles == None or err:\n print('** failed to read -infiles list')\n errs +=1\n\n self.parse_infile_names()\n\n elif opt.name == '-overwrite':\n self.overwrite = 1\n\n elif opt.name == '-separator':\n self.separator, err = uopts.get_string_opt('', opt=opt)\n if self.separator == None or err:\n print(\"** bad -tablefile option\")\n errs += 1\n if self.separator == 'tab': self.separator = '\\t'\n elif self.separator == 'whitespace': self.separator = 'ws'\n self.seplen = len(self.separator)\n\n elif opt.name == '-showlabs':\n self.showlabs = 1\n\n elif opt.name == '-show_missing':\n self.show_missing = 1\n\n elif opt.name == '-tablefile':\n self.tablefile, err = uopts.get_string_opt('', opt=opt)\n if self.tablefile == None or err:\n print(\"** bad -tablefile option\")\n errs +=1\n\n else:\n oind = self.user_opts.olist.index(opt)\n print('** unknown option # %d: %s' % (oind+1, opt.name))\n errs += 1\n break\n\n # allow early and late error returns\n if errs: return -1\n\n # ------------------------------------------------------------\n # apply any trailing logic\n\n if len(self.infiles) < 1:\n print('** missing -infiles option')\n errs += 1\n\n if errs: return -1\n\n return 0","def print_result(self, result_line: str):\r\n if self.output_option == 1:\r\n print(result_line)\r\n else:\r\n self.ER_file.write('{}\\n'.format(result_line))","def _parseLine(self, line, delimiter = \":\"):\r\n\t\tsplt = line.split(delimiter)\r\n\t\tinVec = self._parseVec(splt[0])\r\n\t\toutVec = self._parseVec(splt[1])\r\n\t\tif (len(splt) == 2):\r\n\t\t\tlabel = \"\"\r\n\t\telse:\r\n\t\t\tlabel = splt[2]\r\n\t\tself.data.append({'in':inVec, 'out':outVec, 'label':label})","def result_handler(raw_output):\n write_log(raw_output[1])\n item_list = []\n line_list = raw_output[1].split('\\n')\n title_list = re.sub(\"\\s{2,}\", \"\\t\", line_list[0]).split(\"\\t\")\n for line in line_list[1:]:\n item_list.append(re.sub(\"\\s{2,}\", \"\\t\", line).split(\"\\t\"))\n return raw_output[0], title_list, item_list","def _parse_result(self, result, *, verbose=False, **kwargs):\n return get_fermilat_datafile(result)","def options(self, content, result='all'):\n if not self.tracconfig:\n raise Exception('TracMacroConfig not setup properly - no config')\n good_result = [ 'all', 'wellknown', 'extra', 'nothing' ]\n if not result is None and not result in good_result:\n raise ValueError(\"TracMacroConfig.options(result='%s') invalid;\"\n \" use one of %s, or None.\" % (\n result, ','.join([ \"%s\" % x for x in good_result ])))\n self.results_list, options = parse_args(content, strict=False)\n self._log('parse incoming %s' % options)\n self._parse(options)\n if result is None or result == 'nothing':\n return None\n results = {}\n for key, ent in self.results.iteritems():\n if result == 'all' or \\\n (result == 'wellknown' and key in self.wanted) or \\\n (result == 'extra' and not key in self.wanted):\n results[key] = ent[0]\n self._log('parse results %s' % results)\n return results","def ProcessOptions():\n \n MiscUtil.PrintInfo(\"Processing options...\")\n \n # Validate options...\n ValidateOptions()\n \n OptionsInfo[\"CalcRMSD\"] = Options[\"--calcRMSD\"]\n OptionsInfo[\"UseBestRMSD\"] = False\n if re.match(\"^BestRMSD$\", OptionsInfo[\"CalcRMSD\"], re.I):\n OptionsInfo[\"UseBestRMSD\"] = True\n \n OptionsInfo[\"MaxIters\"] = int(Options[\"--maxIters\"])\n \n OptionsInfo[\"Mode\"] = Options[\"--mode\"]\n \n OptionsInfo[\"RefFile\"] = Options[\"--reffile\"]\n OptionsInfo[\"ProbeFile\"] = Options[\"--probefile\"]\n\n # No need for any RDKit specific --outfileParams....\n OptionsInfo[\"InfileParams\"] = MiscUtil.ProcessOptionInfileParameters(\"--infileParams\", Options[\"--infileParams\"])\n \n OptionsInfo[\"Outfile\"] = Options[\"--outfile\"]\n \n OptionsInfo[\"Overwrite\"] = Options[\"--overwrite\"]\n \n OptionsInfo[\"OutDelim\"] = \" \"\n if MiscUtil.CheckFileExt(OptionsInfo[\"Outfile\"], \"csv\"):\n OptionsInfo[\"OutDelim\"] = \",\"\n elif MiscUtil.CheckFileExt(OptionsInfo[\"Outfile\"], \"tsv txt\"):\n OptionsInfo[\"OutDelim\"] = \"\\t\"\n else:\n MiscUtil.PrintError(\"The file name specified , %s, for option \\\"--outfile\\\" is not valid. Supported file formats: csv tsv txt\\n\" % (OptionsInfo[\"Outfile\"]))","def parse_options(self):\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"-i\",\n \"--input_csv\",\n type=str,\n help=\"Input CSV path(s)\",\n required=True,\n nargs=\"+\",\n )\n parser.add_argument(\n \"-o\", \"--output_csv\", type=str, help=\"Output CSV path\", required=True\n )\n parser.add_argument(\n \"-k\",\n \"--kernel\",\n type=str,\n default=\"rbf\",\n help='SVM kernel type (\"rbf\", \"linear\", \"poly\" or \"sigmoid\")',\n )\n parser.add_argument(\n \"-c\", type=float, default=1.0, help=\"Penalty parameter C of the error term\"\n )\n parser.add_argument(\n \"-g\",\n \"--gamma\",\n type=str,\n default=\"auto\",\n help=\"Gamma parameter of the SVM.\",\n )\n parser.add_argument(\n \"-r\",\n \"--mb_ram\",\n type=float,\n default=4000,\n help=\"Available RAM in megabytes, for SVM calculation\",\n )\n parser.add_argument(\n \"-f\",\n \"--fdr_cutoff\",\n type=float,\n default=0.01,\n help=\"Target PSMs with a lower FDR will be used as a \"\n \"positive training set\",\n )\n parser.add_argument(\n \"-x\",\n \"--columns_as_features\",\n type=str,\n nargs=\"+\",\n default=[\n \"MS-GF:RawScore\",\n \"MS-GF:DeNovoScore\",\n \"MS-GF:SpecEValue\",\n \"MS-GF:EValue\",\n \"OMSSA:evalue\",\n \"OMSSA:pvalue\",\n \"X\\!Tandem:expect\",\n \"X\\!Tandem:hyperscore\",\n ],\n help=\"Columns that should be used as a feature directly \"\n \"(e.g. secondary scores). Will be converted to float\",\n )\n parser.add_argument(\n \"-d\",\n \"--dump_svm_matrix\",\n type=str,\n default=False,\n help=\"Dump SVM matrix in PIN (Percolator input) format \"\n \"to the specified path, mostly for debugging \"\n \"and benchmarking.\",\n )\n\n arg_dict = vars(parser.parse_args()) # convert to dict\n self.update(arg_dict)\n try:\n self[\"gamma\"] = float(self[\"gamma\"])\n except ValueError:\n assert (\n self[\"gamma\"] == \"auto\"\n ), \"Invalid gamma param: \" '\"{0}\", using \"auto\" instead.'.format(\n self[\"gamma\"]\n )","def get_options(self):\n options = dict()\n while True:\n line = self.rfile.readline().decode(\"utf8\").strip()\n if not line:\n break\n self.log.debug(\"Got line: %s\", line)\n if \":\" not in line:\n self.log.debug(\"Invalid option: %s\", line)\n error_msg = \"header not in 'Name: value' format\"\n raise oa.errors.InvalidOption(error_msg)\n name, value = line.split(\":\", 1)\n options[name.lower()] = value.strip()\n return options","def get_parse():\n parser = argparse.ArgumentParser(description=print(mytext),\n add_help=True,\n formatter_class=argparse.RawTextHelpFormatter)\n requiredNAMED = parser.add_argument_group('required arguments')\n\n requiredNAMED.add_argument(\"-i\", \"--input\",\n required=True,\n default=None,\n dest=\"input\",\n type=str,\n help='''/path/to/VariantsToTable_output.txt\nIt is assumed that there is either a 'locus' or 'unstitched_locus' column.\nThe 'locus' column elements are the hyphen-separated\nCHROM-POS. If the 'unstitched_chrom' column is present, the code will use the\n'unstitched_locus' column for SNP names, otherwise 'CHROM' and 'locus'. The\n'unstitched_locus' elements are therefore the hyphen-separated \nunstitched_locus-unstitched_pos. FREQ columns from VarScan are also \nassumed.\n''')\n requiredNAMED.add_argument(\"-o\",\"--outdir\",\n required=True,\n default=None,\n dest=\"outdir\",\n type=str,\n help='''/path/to/cmh_test_output_dir/\nFile output from cmh_test.py will be saved in the outdir, with the original\nname of the input file, but with the suffix \"_CMH-test-results.txt\"''')\n requiredNAMED.add_argument(\"--case\",\n required=True,\n default=None,\n dest=\"case\",\n type=str,\n help='''The string present in every column for pools in \"case\" treatments.''')\n requiredNAMED.add_argument(\"--control\",\n required=True,\n default=None,\n dest=\"control\",\n type=str,\n help='''The string present in every column for pools in \"control\" treatments.''') \n requiredNAMED.add_argument(\"-p\",\"--ploidy\",\n required=True,\n default=None,\n dest=\"ploidyfile\",\n type=str,\n help='''/path/to/the/ploidy.pkl file output by the VarScan pipeline. This is a python\ndictionary with key=pool_name, value=dict with key=pop, value=ploidy. The code\nwill prompt for pool_name if necessary.''')\n requiredNAMED.add_argument(\"-e\",\"--engines\",\n required=True,\n default=None,\n dest=\"engines\",\n type=int,\n help=\"The number of ipcluster engines that will be launched.\")\n parser.add_argument(\"--ipcluster-profile\",\n required=False,\n default='default',\n dest=\"profile\",\n type=str,\n help=\"The ipcluster profile name with which to start engines. Default: 'default'\")\n parser.add_argument('--keep-engines',\n required=False,\n action='store_true',\n dest=\"keep_engines\",\n help='''Boolean: true if used, false otherwise. If you want to keep\nthe ipcluster engines alive, use this flag. Otherwise engines will be killed automatically.\n(default: False)''')\n\n # check flags\n args = parser.parse_args()\n if not op.exists(args.outdir):\n print(ColorText(f\"FAIL: the directory for the output file(s) does not exist.\").fail())\n print(ColorText(f\"FAIL: please create this directory: %s\" % args.outdir).fail())\n print(ColorText(\"exiting cmh_test.py\").fail())\n exit()\n\n # make sure input and ploidyfile exist\n nopath = []\n for x in [args.input, args.ploidyfile]: # TODO: check for $HOME or other bash vars in path\n if not op.exists(x):\n nopath.append(x)\n\n # if input or ploidy file do not exist:\n if len(nopath) > 0:\n print(ColorText(\"FAIL: The following path(s) do not exist:\").fail())\n for f in nopath:\n print(ColorText(\"\\tFAIL: %s\" % f).fail())\n print(ColorText('\\nexiting cmh_test.py').fail())\n exit()\n\n print('args = ', args)\n return args","def getResult(f, opt, model_name):\n tacc = []\n vacc = []\n opt.write('======= ' + model_name + ' =======\\n')\n for l in f.readlines():\n if l.startswith('#'):\n opt.write(l[2:] + '\\n')\n elif l.startswith('Epoch'):\n continue\n else:\n data = l.split(' - ')\n tacc.append(float(data[2].split(': ')[1]))\n vacc.append(float(data[4].split(': ')[1]))\n return np.array(tacc), np.array(vacc)","def parse_command_line():\n\n parser=OptionParser(usage=\"%prog [options] \",\n description=\" updates tracker\" )\n parser.add_option(\"-c\", \"--candidate\", action=\"store\", type=\"string\",\n dest=\"candidate\", default=\"\", help=\"candidate name\")\n parser.add_option(\"-u\", \"--username\", action=\"store\", type=\"string\",\n dest=\"username\", default=\"gzhou\",\n help=\"username\")\n parser.add_option(\"-p\",\"--password\", action=\"store\",\n dest=\"password\", default=\"egghead\", help=\"password\")\n parser.add_option(\"-i\",\"--input\", action=\"store\",\n dest=\"input\", default=\"tracker_temp.txt\", help=\"Input file\") \n parser.add_option(\"-l\",\"--upload\", action=\"store\",\n dest=\"upload\", default=None, help=\"upload file\") \n parser.add_option(\"-d\",\"--description\", action=\"store\",\n dest=\"description\", default=None, help=\"descirption\") \n (options, args)=parser.parse_args()\n\n return options, args","def test_parsingValues(self):\n argV = (\"--fooint 912 --foofloat -823.1 \"\n \"--eggint 32 --eggfloat 21\").split()\n self.usage.parseOptions(argV)\n self.failUnlessEqual(self.usage.opts['fooint'], 912)\n self.assert_(isinstance(self.usage.opts['fooint'], int))\n self.failUnlessEqual(self.usage.opts['foofloat'], -823.1)\n self.assert_(isinstance(self.usage.opts['foofloat'], float))\n self.failUnlessEqual(self.usage.opts['eggint'], 32)\n self.assert_(isinstance(self.usage.opts['eggint'], int))\n self.failUnlessEqual(self.usage.opts['eggfloat'], 21.)\n self.assert_(isinstance(self.usage.opts['eggfloat'], float))","def parse_options(self, options):\n pass","def parse_lspci_vv_chk_error(output,raiseOnErrors = \"1\"):\n \n found_devSta = 0\n \n #sys.exit(1)\n if re.search(\"DevSta\",output):\n found_devSta = 1\n \n # remove DevStat after splitting it\n l_a = output.split(\":\")\n l_a1 = l_a[1].split()\n for m in l_a1:\n \n # if ends with +, \n if re.search(\"Err\",m):\n if re.search(\".*\\+$\",m):\n \n print \"-\" * 8\n \n errorStr = \"Found + in lspci output for '%s' , line details '%s'\"%(m,output)\n trace_error(errorStr)\n if raiseOnErrors == \"1\":\n raise ViriError(errorStr)\n\n return 2\n \n if found_devSta == 0:\n raise ViriError(\"Did not find 'devSta' in the output %s\"%output)\n\n trace_info(\"No lspci correctable or uncorrectable issues seem to be present , output '%s'\"%output)\n return 1","def _build_parsed_values(self):\n match = OptodeSettingsParticle.regex_compiled().match(self.raw_data)\n\n if not match:\n raise SampleException(\"No regex match of parsed optode data: [%s]\" %\n self.raw_data)\n\n try:\n return self._get_multiline_values()\n except ValueError as e:\n raise SampleException(\"ValueError while decoding optode output: [%s]\" % e)","def _parse(self):\n with open(self.input) as f:\n for line in f:\n if not line.lstrip().startswith(\"#\"): # comment\n stripped_line=line.split(\"#\")[0].strip()\n \n # Initialise an empty option dictionary with some good defaults\n if \"[\" in stripped_line:\n molname=stripped_line.split()[1]\n self.options[molname]=self.empty_option_dict.copy() # dict1=dict2 does not copy!\n self.options[molname][\"MolName\"]=molname\n if \":\" in stripped_line: \n # now process line by line\n if \"{\" not in stripped_line:\n key,value=[i.strip() for i in stripped_line.split(\":\")]\n\n if key not in self.options[molname].keys():\n raise BaseException(\"Option \\\"{}\\\" not known, please check your input file\".format(key))\n self.options[molname][key]=value \n else:\n # This is to define special lines that are given by a dictionary\n key,value=stripped_line.split(\":\",1) # split on first occurence\n if key==\"Addon\": # additional atoms to be added per molecule\n addondict=self.empty_addon_dict.copy()\n addondict_string = value.split(\"}\",-1)[0].split(\"{\",1)[1]\n for pair in addondict_string.split(\",\"):\n addonkey,addonvalue=[i.strip() for i in pair.split(\":\")]\n if addonkey not in addondict.keys():\n raise BaseException(\"Option \\\"{}\\\" in Addon section of molecule {} not known, please check your input file\".format(addonkey,molname))\n addondict[addonkey]=addonvalue\n value=addondict\n # Since addon keyword can be used many times, this is a list\n self.options[molname][key].append(value) \n self._check()","def main():\n global options\n parser = OptionParser(\n usage = '%prog [OPTIONS] RESULTPATH',\n version='%prog 0.99', #\n description='Calculate results on acl2018 datasets',\n epilog='Contact simon.clematide@uzh.ch'\n )\n parser.add_option('-l', '--logfile', dest='logfilename',\n help='write log to FILE', metavar='FILE')\n parser.add_option('-q', '--quiet',\n action='store_true', dest='quiet', default=False,\n help='do not print status messages to stderr')\n parser.add_option('-d', '--debug',\n action='store_true', dest='debug', default=False,\n help='print debug information')\n parser.add_option('-g', '--glob',\n action='store', dest='glob', default='{RESULTPATH}/x*x/*/s*/*eval',\n help='change file globbing for accessing evaluation results (%default)')\n parser.add_option('-f', '--fold_filter',\n action='store', dest='fold_filter', default=None,\n help='only use folds matching (re.search) the specified regular expression on the fold name (e.g. \"^english\" for all folds starting with the string english) (Default \"%default\")')\n parser.add_option('-D', '--decoder_filter',\n action='store', dest='decoder_filter', default=\"greedy|beam4\",\n help='''used on decoding mode label; matches (re.search) with the specified regular expression (Default \"%default\")''')\n parser.add_option('-m', '--mode',\n action='store', dest='mode', default='ms',\n help='''compatibel characters can be combined\n s: individual seed results;\n S: only individual seed results;\n m: mean/sd values (on seeds and folds);\n M: mean/sd (on folds only);\n e: include ensembles;\n E: only ensembles;\n T: only test results;\n D: only dev results\n q: sort the results by accuracy\n L: evaluate on edit distance, not on Accuracy\n ''')\n\n (options, args) = parser.parse_args()\n if options.debug:\n print(\"options=\",options,file=sys.stderr)\n\n if len(args) < 1:\n print('# RESULTPATH needed')\n parser.print_help()\n exit(1)\n options.mode = set(options.mode)\n process(options=options,args=args)","def processArgs(self, argv):\n parser = OptionParser(usage=usage)\n parser.add_option(\"-a\", \"--show_ADT\", action=\"store_true\", dest=\"show_ADT\",\n default=self.show_ADT, help=\"Display ADT value if set\")\n parser.add_option(\"-f\", \"--show_file\", action=\"store_true\", dest=\"show_file\",\n default=self.show_file, help=\"Display matching filename if set\")\n parser.add_option(\"-t\", \"--show_time\", action=\"store_true\", dest=\"show_time\",\n default=self.show_time, help=\"Display message time\")\n parser.add_option(\"-v\", \"--show_visitID\", action=\"store_true\", dest=\"show_visitID\",\n default=self.show_visitID, help=\"Display visit ID\")\n parser.add_option(\"-p\", \"--show_pc\",\n action=\"store_true\",\n dest=\"show_pc\",\n default=self.show_pc,\n help=\"Display patient class\")\n\n (options, pargs) = parser.parse_args()\n if len(pargs) < 3:\n parser.error(\"incorrect number of arguments\")\n\n self.show_ADT = parser.values.show_ADT\n self.show_file = parser.values.show_file\n self.show_time = parser.values.show_time\n self.show_visitID = parser.values.show_visitID\n self.show_pc = parser.values.show_pc\n \n self.segments_of_interest = pargs.pop(0)\n if len(self.segments_of_interest) != 3:\n parser.error(\"segment '%s' looks incorrect, expected something like 'PV1'\"\n % self.segments_of_interest)\n\n try:\n nums = pargs.pop(0).split(\",\")\n for num in nums:\n if 'MSH' == self.segments_of_interest:\n num = int(num) - 1\n self.sequences.append(int(num))\n except:\n parser.error(\"sequence must be an integer, separate multiple w/ comma and no spaces\")\n\n for patternOrFile in pargs:\n for file in glob.glob(patternOrFile):\n if not os.path.isfile(file):\n parser.error(\"can't open input file %s\" % file)\n self.filelist.append(file)\n \n # Require at least one file\n if not len(self.filelist):\n parser.error(\"at least one input file is required\")","def _parse_output_status_details(lines):\n details = list()\n detail_indicator = re.compile(\"^--\")\n for line in lines:\n line = line.rstrip()\n if re.match(detail_indicator, line):\n details.append(line)\n else:\n break\n return details","def _parse_vn(lines, out_format):\n number = 0\n lines_out = []\n loa = lines_out.append\n for line in lines:\n coordinates = split_line(line)\n if len(coordinates) == 3:\n number += 1\n loa(out_format % (-float(coordinates[0]),\n float(coordinates[1]),\n float(coordinates[2])))\n return number, lines_out","def parseResults(result):\n # Split the results based on newline characters\n results_cut = result.text.split('\\n')[12:-49]\n # Initialize lists of the values to be parsed from results_cut \n visit_id = []\n name = []\n ra_hour = []\n ra_min = []\n ra_sec = []\n dec_deg = []\n dec_min = []\n dec_sec = []\n v_mag = []\n ra_motion = []\n dec_motion = []\n # Iterate through results_cut and append them to the respective lists\n for line in results_cut:\n visit_id.append(int(line[6:12]))\n name.append(line[12:36])\n ra_hour.append(int(line[38:40]))\n ra_min.append(int(line[41:43]))\n ra_sec.append(float(line[44:48]))\n dec_deg.append(int(line[49:52]))\n dec_min.append(int(line[53:55]))\n dec_sec.append(int(line[56:58]))\n try:\n v_mag.append(float(line[60:64]))\n except ValueError:\n # If there is no reported v_mag for the object, return -99\n v_mag.append(-99.0)\n ra_motion.append('%s%i' % (line[84], int(line[82:84])))\n dec_motion.append('%s%i' % (line[91], int(line[89:91])))\n # Initialize the pandas dataframe to be returned\n results_df = pd.DataFrame(np.array([visit_id, name, ra_hour, ra_min, ra_sec, \n dec_deg, dec_min, dec_sec, v_mag, \n ra_motion, dec_motion]).T, \n columns=['visit_id', 'name', 'ra_hour', 'ra_min', 'ra_sec', \n 'dec_deg', 'dec_min', 'dec_sec', 'v_mag', \n 'ra_motion', 'dec_motion'])\n # Add the lists to the dataframe\n results_df['visit_id'] = pd.to_numeric(results_df['visit_id'])\n results_df['ra_hour'] = pd.to_numeric(results_df['ra_hour'])\n results_df['ra_min'] = pd.to_numeric(results_df['ra_min'])\n results_df['ra_sec'] = pd.to_numeric(results_df['ra_sec'])\n results_df['dec_deg'] = pd.to_numeric(results_df['dec_deg'])\n results_df['dec_min'] = pd.to_numeric(results_df['dec_min'])\n results_df['dec_sec'] = pd.to_numeric(results_df['dec_sec'])\n results_df['v_mag'] = pd.to_numeric(results_df['v_mag'])\n results_df['ra_motion'] = pd.to_numeric(results_df['ra_motion'])\n results_df['dec_motion'] = pd.to_numeric(results_df['dec_motion'])\n \n return results_df","def _parse_options(self, cmd_line_args):\n args = self._create_parser().parse_args(cmd_line_args)\n\n if args.verbose and not args.debug:\n logging.basicConfig(level=logging.INFO)\n\n if args.debug:\n logging.basicConfig(level=logging.DEBUG)","def vultr_cli(parser):\n return parser","def get_options():\n \n parser = argparse.ArgumentParser(description=\"Filter VCFs for inherited\"\n \"variants in trios.\")\n \n # the --ped and --child options are mutually exclusive\n group = parser.add_mutually_exclusive_group(required=True)\n group.add_argument(\"--ped\",\n help=\"Path to ped file containing cohort details for multiple trios.\")\n group.add_argument(\"--child\", help=\"Path to child's VCF file.\")\n \n parser.add_argument(\"--mother\", help=\"Path to mother's VCF file.\")\n parser.add_argument(\"--father\", help=\"Path to father's VCF file.\")\n parser.add_argument(\"--gender\", help=\"The child's gender (male or female).\")\n parser.add_argument(\"--mom-aff\",\n help=\"Mother's affected status (1=unaffected, or 2=affected).\")\n parser.add_argument(\"--dad-aff\",\n help=\"Father's affected status (1=unaffected, or 2=affected).\")\n \n parser.add_argument(\"--syndrome-regions\", dest=\"regions\",\n help=\"Path to list of CNV regions known to occur in disorders.\")\n parser.add_argument(\"--known-genes\",\n help=\"Path to table of known disease causative genes.\")\n parser.add_argument(\"--known-genes-date\", dest=\"genes_date\",\n help=\"Date that the list of known disease causative genes was last\"\n \"updated, used to track the version of known-genes used for\"\n \"analysis.\")\n parser.add_argument(\"-o\", \"--output\",\n help=\"Path for analysis output in tabular format.\")\n parser.add_argument(\"--export-vcf\",\n help=\"Directory or file path for analysis output in VCF format.\")\n parser.add_argument(\"--log\", dest=\"loglevel\", default=\"debug\",\n help=\"Level of logging to use, choose from: debug, info, warning,\"\n \"error or critical.\")\n parser.add_argument(\"--debug-chrom\",\n help=\"chromosome of variant for which to debug the filtering behaviour.\")\n parser.add_argument(\"--debug-pos\", type=int,\n help=\"position of variant for which to debug the filtering behaviour.\")\n parser.add_argument(\"--lof-sites\",\n help=\"path to file of sites at the last base of exons that are \"\n \"potentially LoF sites.\")\n \n # New argument added by PJ to allow DNM_PP filtering to be disabled.\n parser.add_argument(\"--pp-dnm-threshold\", dest=\"pp_filter\", type=float,\n default=0.0,\n help=\"Set PP_DNM threshold for filtering (defaults to >=0.9)\")\n parser.add_argument(\"--maf-populations\",\n default=\"AFR_AF,AMR_AF,ASN_AF,DDD_AF,EAS_AF,ESP_AF,EUR_AF,MAX_AF,\"\n \"SAS_AF,UK10K_cohort_AF\",\n help=\"Comma separated list of population tags that can exist in the \"\n \"INFO field for population-specific minor allele frequencies\")\n\n #new argument added by re3 to require a file of sums of log2 ratio on X chromosome for CNV filtering\n parser.add_argument(\"--sum_x_lr2_file\", help=\"Path to file containing the sum of lr2 on x chromosome for each sample\")\n \n args = parser.parse_args()\n \n if args.pp_filter < 0.0 or args.pp_filter > 1:\n parser.error(\"--pp-dnm-threshold must be between 0 and 1\")\n \n if args.child is not None:\n if args.father is not None and args.dad_aff is None:\n parser.error(\"--dad-aff must also be used if --father is used\")\n if args.mother is not None and args.mom_aff is None:\n parser.error(\"--mom-aff must also be used if --mother is used\")\n\n if args.sum_x_lr2_file is None:\n parser.error(\"--sum_x_lr2_file must be used\")\n\n args.populations = args.maf_populations.split(',')\n \n return args","def print_options(val, cur_matches):\n print val\n\n #skip one to print none at end\n for i,v in enumerate(cur_matches[1:]):\n print \"[%i] %s : %s \"%(i+1, v[0], v[1])\n print \"[%i] %s : %s \" % (0, cur_matches[0][0], cur_matches[0][1])\n\n print \n print 'Choice?'","def parse_cmdline(cmdline_args):\n option_parser = optparse.OptionParser(usage='usage: %prog [options] <pattern>',\n description='ts short for TextSearch, Grep like tool', prog='ts', add_help_option=False) # -h is a real option\n\n option_parser.add_option('-h', '--help', action='store_true', dest='help', help='Display this information')\n option_parser.add_option('-e', '--extension', action='store', dest='extension', type='string', default=None,\n help='file extension')\n\n group_searching = optparse.OptionGroup(option_parser, 'Regexp selection and interpretation')\n group_searching.add_option('-i', '--ignore-case', action='store_true', dest='ignore_case', default=False,\n help='Ignore case distinctions in the pattern')\n group_searching.add_option('-w', '--word-regexp', action='store_true', dest='word_regexp', default=False,\n help='Force the pattern to match only whole words')\n group_searching.add_option('-l', '--literal', action='store_true', dest='literal', default=False,\n help='Quote all metacharacters; the pattern is literal')\n option_parser.add_option_group(group_searching)\n\n group_miscellaneous = optparse.OptionGroup(option_parser, 'Miscellaneous')\n group_miscellaneous.add_option('--path-only', action='store_true', dest='path_only', default=False,\n help='only print out the matching file')\n group_miscellaneous.add_option('-v', '--invert-match', action='store_true', dest='invert_match', default=False,\n help='Invert the sense of matching, to select non-matching lines.')\n option_parser.add_option_group(group_miscellaneous)\n\n group_output = optparse.OptionGroup(option_parser, 'Output control')\n group_output.add_option('-c', '--count', action='store_true', dest='count', default=False,\n help='Suppress normal output; instead print a count of matching lines for each input file.')\n group_output.add_option('-o', '--only-matching', action='store_true', dest='only_matching', default=False,\n help='Print only the matched (non-empty) parts of a matching line, with each such part on '\n 'a separate output line.')\n option_parser.add_option_group(group_output)\n\n options, args = option_parser.parse_args(cmdline_args)\n return options, args, option_parser","def parse_options():\n options ={ \"vcf\":None, \"out\":None, \"ref\":None, \"haplotypes\":False, \"sample\":None, \"chrom\":None, \"refcheck\" :True }\n\t\n try:\n opts, args = getopt.getopt(sys.argv[1:], \"v:o:r:s:c:h\", [\"vcf\", \"out\", \"ref\", \"sample\", \"chrom\", \"haplotypes\"])\n print opts, args\n except Exception as err:\n print str(err)\n sys.exit()\n\n for o, a in opts:\n print o,a\n if o in [\"-v\",\"--vcf\"]: options[\"vcf\"] = a\n if o in [\"-r\",\"--ref\"]: options[\"ref\"] = a\n if o in [\"-s\",\"--sample\"]: options[\"sample\"] = a\n if o in [\"-c\",\"--chrom\"]: options[\"chrom\"] = a\n if o in [\"-h\",\"--haplotypes\"]: options[\"haplotypes\"] = True\n elif o in [\"-o\",\"--out\"]: options[\"out\"] = a\n \n if not options[\"haplotypes\"]:\n raise Exception(\"Only implemented for haplotype option (-h)\")\n \n print \"found options:\"\n print options\n return options","def _parse_command_line_arguments():\n global config\n # Get command line args for vispy\n argnames = ['vispy-backend=', 'vispy-gl-debug', 'vispy-glir-file=',\n 'vispy-log=', 'vispy-help', 'vispy-profile=', 'vispy-cprofile',\n 'vispy-dpi=', 'vispy-audit-tests']\n try:\n opts, args = getopt.getopt(sys.argv[1:], '', argnames)\n except getopt.GetoptError:\n opts = []\n # Use them to set the config values\n for o, a in opts:\n if o.startswith('--vispy'):\n if o == '--vispy-backend':\n config['default_backend'] = a\n logger.info('vispy backend: %s', a)\n elif o == '--vispy-gl-debug':\n config['gl_debug'] = True\n elif o == '--vispy-glir-file':\n config['glir_file'] = a\n elif o == '--vispy-log':\n if ',' in a:\n verbose, match = a.split(',')\n else:\n verbose = a\n match = None\n config['logging_level'] = a\n set_log_level(verbose, match)\n elif o == '--vispy-profile':\n config['profile'] = a\n elif o == '--vispy-cprofile':\n _enable_profiling()\n elif o == '--vispy-help':\n print(VISPY_HELP)\n elif o == '--vispy-dpi':\n config['dpi'] = int(a)\n elif o == '--vispy-audit-tests':\n config['audit_tests'] = True\n else:\n logger.warning(\"Unsupported vispy flag: %s\" % o)","def parseArgs( argv ):\r\n\r\n parser = OptionParser()\r\n parser.add_option(\"-o\", \"--order\", type=\"choice\", action=\"store\", choices=[\"p\",\"h\",\"g\",\"c\"], default=\"p\", dest=\"orderType\",\r\n help=\"specify a display sorted by (p)lugin, (c)ve id, (h)ost, or just (g)enerate a hostfile\")\r\n parser.add_option(\"-f\", \"--odf\", type=\"string\", action=\"store\", dest=\"odfOutputFilename\",\r\n help=\"output to this file in ODF format\", default=\"\")\r\n parser.add_option(\"-p\", \"--portlist\", type=\"string\", action=\"store\", dest=\"portList\",\r\n help=\"specify specific ports to show\")\r\n parser.add_option(\"-r\", \"--riskfactors\", type=\"string\", action=\"store\", dest=\"riskFactorsList\", default=\"critical,high,moderate,medium,low,none\",\r\n help=\"specify list of allowable risk factors (default is any of critical,high,moderate,medium,low,none\")\r\n parser.add_option(\"-t\", \"--hostlist\", type=\"string\", action=\"store\", dest=\"hostList\",\r\n help=\"specify specific hosts to show\")\r\n parser.add_option(\"-s\", \"--severities\", type=\"string\", action=\"store\", dest=\"severityList\", default=\"critical_hole,hole,warn,note,info,openport\",\r\n help=\"specify specific list of severity codes to show (default is any of critical_hole,hole,warn,note,info,openport\")\r\n parser.add_option(\"-q\", \"--query\", type=\"string\", action=\"store\", dest=\"contentQuery\",\r\n help=\"show all results whose synopses match this regular expression\")\r\n parser.add_option(\"-i\", \"--idlist\", type=\"string\", action=\"store\", dest=\"pluginIDList\",\r\n help=\"display only results that match these Nessus plugin IDs\")\r\n parser.add_option(\"-c\", \"--csv\", type=\"string\", action=\"store\", dest=\"csvOutputFilename\", default=\"\",\r\n help='output CSV-friendly text delimitted by default or overriden delimiter to a given filename (use \"0\" for standard output)')\r\n# parser.add_option(\"-c\", \"--csv\", action=\"store_true\", dest=\"CSV\", default=False,\r\n# help=\"output CSV-friendly text delimitted by |++| (overridable with the 'd' option)\")\r\n parser.add_option(\"-d\", \"--delimiter\", type=\"string\", action=\"store\", dest=\"delimiter\", default=\"|++|\", \r\n help=\"override CSV delimiter default of |++|\")\r\n\r\n (options, args) = parser.parse_args() \r\n \r\n if options.orderType: options.orderType = options.orderType.lower()\r\n\r\n return (options,args)","def parse_cli_output(self, output, operation, name, index):\n state = None\n regex = None\n error = self.__cli_connection_error(output)\n if(not error):\n if index is not None:\n regex = re.search( r'RuntimeCmd:\\s*(' + re.escape(name) + r'\\[' + index + r'\\])=\\s*(\\d+)', output, re.M|re.I)\n else:\n regex = re.search( r'RuntimeCmd:\\s*(' + re.escape(name) + r')=\\s*([\\d+,\\s]+)', output, re.M|re.I)\n\n if regex:\n state = regex.group(2)\n else:\n # regex = re.search( r'RuntimeCmd:(\\sError:\\s|\\s)(.*)\\((.*)\\)\\n', output, re.M|re.I)\n regex = re.search( r'RuntimeCmd:(\\sError:\\s|\\s)(.*)\\n', output, re.M|re.I)\n if regex:\n # self.logger.error(\"CLI Error: %s - %s\", regex.group(2), regex.group(3))\n self.logger.error(\"CLI Error [%s %s]: %s\", operation, name, regex.group(2))\n return state","def command(self):\n with open(self.x, 'rt') as fi:\n line = next(fi) # the first line\n\n version, cmd_line = line.strip().split(';')\n version = version.split(' ')[2]\n cmd_line = re.sub('\"', '', cmd_line.strip())\n\n return [version, cmd_line]","def run(self, desired_result, input, limit):\n cfg = desired_result.configuration.data\n\n opt_seq = ''\n\n for flag in OPT_FLAGS:\n if cfg[flag] == 'on':\n opt_seq += ' {0}'.format(flag)\n\n tmp_dir = \"./tmp\" \n compd_opt_cmd = 'opt -S {0} mcsema/test.proposed.inline.ll -o {1}/test.proposed.opt.ll'.format(\n opt_seq, tmp_dir)\n compd_opt_result = self.call_program(compd_opt_cmd)\n if compd_opt_result['returncode'] != 0:\n print(compd_opt_result)\n assert 0\n\n mcsema_opt_cmd = 'opt -S {0} ../binary/test.mcsema.inline.ll -o {1}/test.mcsema.opt.ll'.format(\n opt_seq, tmp_dir)\n mcsema_opt_result = self.call_program(mcsema_opt_cmd)\n if mcsema_opt_result['returncode'] != 0:\n print(mcsema_opt_result)\n assert 0\n\n matcher = args.matcher\n if(matcher == ''):\n matcher = home + '/Github//validating-binary-decompilation/source/build/bin//matcher'\n\n matcher_run_cmd = '{0} --file1 {1}/test.mcsema.opt.ll:{2} --file2 {1}/test.proposed.opt.ll:{2} --potential-match-accuracy'.format(\n matcher, tmp_dir, args.func)\n\n matcher_run_result = self.call_program(matcher_run_cmd)\n if matcher_run_result['returncode'] != 0:\n print(matcher_run_result)\n assert 0\n\n matcher_stderr = matcher_run_result['stderr']\n z = re.findall(\n r\"^Accuracy:(\\d+\\.[\\deE+-]+)\",\n matcher_stderr,\n re.MULTILINE)\n cost = 1 - float(z[0])\n\n log.debug('[Run] Cost:{0} [{1}]'.format(cost, opt_seq))\n\n # Early exit\n outfile = args.outdir + '/' + 'normalizer_final_config.json'\n if cost == 0:\n log.info(\n \"run: Early Exit: Optimal pass sequence written to {0}: [{1}]\".format(\n outfile, opt_seq))\n with open(outfile, 'a') as fd:\n fd.write('{0}\\n'.format(opt_seq))\n\n return Result(time=cost)","def parse_akmaxsat_output(out):\n for line in out.splitlines():\n temp = str(line.decode())\n if temp.startswith('v'):\n GS = sorted([int(x) for x in temp[2:].split()], key=abs)\n return np.argwhere(np.array(GS)>0).flatten()","def visit_option_argument(self, node):\n self.body.append(node.get('delimiter', ' '))","def visit_option_argument(self, node):\n self.body.append(node.get('delimiter', ' '))","def readOpt(self, String0):\n Name = re.match(r\"NAME : (.*)\", String0)[1]\n COMMENT = re.search(r\"COMMENT : (.*)\", String0)[1]\n TYPE = re.search(r\"TYPE : (.*)\", String0)[1]\n DIMENSION = re.search(r\"DIMENSION : (.*)\", String0)[1]\n split = String0.split(\"\\n\")\n Tour = []\n for s0 in split:\n if (s0 and s0[0] <= '9' and s0[0] >= '0'):\n Tour.append(int(s0))\n return Name, COMMENT, TYPE, DIMENSION, Tour","def get_args():\n\n # Make argparse object, add description\n parser = argparse.ArgumentParser(\n formatter_class=argparse.RawTextHelpFormatter,\n description=textwrap.dedent(\n '''\n summary:\n Takes a VCF file and parses the variants to produce a tab delimited \n variant report.\n '''\n ))\n\n\n # Version info\n parser.add_argument(\n '-v', '--version', action='version', \n version=\n '%(prog)s\\nversion:\\t{}\\nlast updated:\\t{}'.format(\n __version__, __updated__\n ))\n\n\n # Arguments (see help string for full descriptions):\n # REQUIRED: VCF file input\n parser.add_argument(\n 'input', action='store', \n help='Filepath to input VCF file. REQUIRED.'\n )\n\n\n # OPTIONAL: Output folder, defaults to current directory if empty\n parser.add_argument(\n '-O', '--output', action='store', \n help=textwrap.dedent(\n '''\n Filepath to folder where output reports will be saved. \n If missing, defaults to current directory.\n \\n'''\n ))\n\n\n # OPTIONAL: List of preferred transcripts\n parser.add_argument(\n '-t', '--transcripts', action='store', \n help=textwrap.dedent(\n '''\n Filepath to preferred transcripts file. \n\n Must be a tab seperated file with preferred transcripts in the second \n column. If missing, all entries in the preferred transcript column \n will be labelled as 'Unknown'.\n \\n'''\n ))\n\n\n # OPTIONAL: Preferred transcripts strictness\n parser.add_argument(\n '-T', '--transcript_strictness', action='store', default='low', \n help=textwrap.dedent(\n '''\n Strictness of matching while annotating preferred transcripts.\n Default setting is low.\n\n Options: \n\n high - Transcripts must be an exact match. \n e.g. NM_001007553.2 and NM_001007553.1 won't match,\n NM_001007553.1 and NM_001007553.1 will.\n\n low - Transcripts will match regardless of the version number. The \n version number is after the . at the end of a transcript \n e.g. NM_001007553.2 and NM_001007553.1 will match.\n \\n'''\n ))\n\n\n # OPTIONAL: either a single BED file or a folder containing BED \n # files, only one of these can be used\n bed_files = parser.add_mutually_exclusive_group()\n\n # Single BED file\n bed_files.add_argument(\n '-b', '--bed', action='store', \n help=textwrap.dedent(\n '''\n Filepath to a single BED file. \n\n The BED file will be applied to the variant report and a seperate\n report saved with the BED file applied. This report will be saved in \n the same output folder as the original variant report, with the BED \n file name added to it.\n Cannot be used together with -B flag.\n \\n'''\n ))\n\n # Multiple BED files\n bed_files.add_argument(\n '-B', '--bed_folder', action='store', \n help=textwrap.dedent(\n '''\n Filepath to folder containing BED files. \n\n Each BED file will be applied to the variant report and a seperate\n report saved with the BED file applied. These reports will be saved in\n a new folder within the output folder, named the same as the input BED\n folder. \n The file names will be the same as the original variant report, with \n the BED file name added to them.\n Cannot be used together with -b flag.\n \\n'''\n ))\n\n\n # OPTIONAL: File containing known variants\n parser.add_argument(\n '-k', '--known_variants', action='store', \n help=textwrap.dedent(\n '''\n Filepath to known variants file. \n\n This is a VCF file containing any known variants and an associated \n classification. The classification will be added to the variant \n report. The VCF must have an annotation named 'Classification' within \n the INFO field for each variant.\n\n Key:\n 0 - Artifact\n 1 - Benign\n 2 - Likely benign\n 3 - VUS\n 4 - Likely pathogenic\n 5 - Pathogenic\n \\n'''\n ))\n\n\n # OPTIONAL: File containing the headers for the report\n parser.add_argument(\n '-c', '--config', action='store', \n help=textwrap.dedent(\n '''\n Filepath to config file. \n\n This is a tab seperated text file containing a number of rows, where \n each row specifies an annotation to be included in the variant report.\n Only annotations included in the config file will be included in the\n variant report.\n The columns in the variant report will be in the same order as the \n order in which the annotations appear in the config file.\n\n Each row contains:\n\n Column 1 - Required. Annotation headers, these must match up with how\n they appear in the VCF (case sensitive).\n\n Column 2 - Required. Location where to find the data within the VCF, \n used to select the correct parsing function.\n options: info, format, vep, filter or pref.\n\n Column 3 - Optional. Alternative name for column header.\n\n To make a config file with all available options from a VCF, run:\n vcf_parse -l path_to_input_vcf > config.txt\n \\n'''\n ))\n\n\n # OPTIONAL: Lists all headers in a vcf then exits\n parser.add_argument(\n '-l', '--config_list', action='store_true', \n help=textwrap.dedent(\n '''\n Return a list of all availabile config to the screen, then exit.\n See CONFIG section for usage.\n \\n'''\n ))\n\n\n # OPTIONAL: Filter out any variants where FILTER column is not PASS\n parser.add_argument(\n '-F', '--filter_non_pass', action='store_true', \n help=textwrap.dedent(\n '''\n Filters out any variants where the FILTER annotation is not \n PASS. If missing then there will be no fitering based on the\n FILTER annotation.\n \\n'''\n ))\n\n return parser.parse_args()","def format_options_as_lines(options):\r\n option_lines = []\r\n option_fields = str(options).split(\",\")\r\n\r\n for field in option_fields:\r\n option_lines.append(str(field).strip(\"{\").strip(\"}\"))\r\n\r\n return option_lines","def _process_command_line():\n # pylint: disable=C0103\n global parameters\n # pylint: enable=C0103\n\n # option letters followed by : expect an argument\n # same for option strings followed by =\n character_options = \"qV?\"\n string_options = [\n \"debug\",\n \"help\",\n \"version\",\n ]\n\n try:\n options, remaining_arguments = getopt.getopt(\n sys.argv[1:], character_options, string_options\n )\n except getopt.GetoptError as error:\n logging.critical(\"Syntax error: %s\", error)\n _display_help()\n sys.exit(1)\n\n for option, _ in options:\n\n if option == \"--debug\":\n logging.disable(logging.NOTSET)\n\n elif option in (\"--help\", \"-?\"):\n _display_help()\n sys.exit(0)\n\n elif option == \"-q\":\n parameters[\"Quiet mode\"] = True\n\n elif option == \"-V\":\n if parameters[\"Command flavour\"] in (\"gnu\", \"gnu:linux\", \"linux\"):\n print(ID.replace(\"@(\" + \"#)\" + \" $\" + \"Id\" + \": \", \"\").replace(\" $\", \"\"))\n sys.exit(0)\n\n elif option == \"--version\":\n print(ID.replace(\"@(\" + \"#)\" + \" $\" + \"Id\" + \": \", \"\").replace(\" $\", \"\"))\n sys.exit(0)\n\n logging.debug(\"_process_command_line(): parameters:\")\n logging.debug(parameters)\n logging.debug(\"_process_command_line(): remaining_arguments:\")\n logging.debug(remaining_arguments)\n\n return remaining_arguments","def parse_options(options, return_list=True):\n\n cmd_options = []\n\n for key, value in options.items():\n\n if value is not None:\n txt = f\"--{key} {value}\"\n else:\n txt = f\"--{key}\"\n\n cmd_options.append(txt)\n\n if return_list:\n return cmd_options\n\n cmd_options = \" \".join(cmd_options)\n\n return cmd_options","def load_file_lines(option_value):\n if not hasattr(option_value, 'read'):\n raise IncompetentDeveloperError(\"Input type must be a file object.\")\n \n return [line.strip() for line in option_value]","def _libsvm_parse_line(libsvm_line):\n tokens = libsvm_line.split()\n qid = int(tokens[1].split(\":\")[1])\n\n features = {_LABEL_FEATURE: float(tokens[0])}\n key_values = [key_value.split(\":\") for key_value in tokens[2:]]\n features.update({key: float(value) for (key, value) in key_values})\n\n return qid, features","def __processOutputLine(self, line):\n if (\n line.startswith(\"--- \") or\n line.startswith(\"+++ \")\n ):\n self.__processFileLine(line)\n \n self.__output.append(line)","def parseshowvlancommand(message):\n\n vlanparsed = _begin_parse(message)\n vlanschema = parse_get_nsmap(vlanparsed)\n vlans = parse_xml_heirarchy('ROW_mtuinfo', ['vlanshowinfo-vlanid', 'vlanshowinfo-vlanmode'], vlanschema,\n vlanparsed)\n\n elements = parse_xml_heirarchy('ROW_vlanbrief',\n ['vlanshowbr-vlanname', 'vlanshowbr-vlanstate', 'vlanshowbr-shutstate',\n 'vlanshowplist-ifidx'], vlanschema, vlanparsed)\n for d in elements:\n if 'vlanshowplist-ifidx' in d:\n d['vlanshowplist-ifidx'] = _intexpand(d['vlanshowplist-ifidx'])\n\n [v.update(e) for v, e in zip(vlans, elements)]\n return vlans","def parse_virsh_command_line(command):\n for cmd, regex in _virsh_commands:\n match = regex.search(command)\n if match:\n return (cmd,) + match.groups()\n raise RuntimeError('unrecognized command: {}'.format(command))","def parseCommandLine():\n parser = OptionParser(usage=\"%prog \", version=\"%prog \" + __version__,\n description='''\n This program calculates omegaAB value from a hexagonal lattice trajectory\n stored in xyz file (see for more details)''')\n parser.add_option(\"-f\", \"--traj\", dest=\"inXyzFilename\",default = \"hexTraj.xyz\",\n help=\"xyz input trajectory file (default traj.xyz)\", metavar=\"INXYZFILE\")\n parser.add_option(\"-r\", \"--reference\", dest=\"symbol\",default = \"P11\",\n help=\"reference particle name\", metavar=\"ADATOM\")\n parser.add_option(\"-o\", \"--output\", dest=\"outDatFilename\", default=\"omega.dat\",\n help=\"output dat file with omega values for each frame. WARNING: it will be overriden\", metavar=\"OUTXYZFILE\")\n \n parser.add_option(\"-q\", \"--quiet\",\n action=\"store_false\", dest=\"verbose\", default=True,\n help=\"don't print status messages to stdout\")\n\n (options, _) = parser.parse_args()\n\n return options","def ParseOption():\n parser = optparse.OptionParser()\n parser.add_option('--input', dest='input', help='Input file path')\n parser.add_option('--output', dest='output', help='Output file path')\n parser.add_option(\n '--var_name', dest='var_name', help='Var name for the array')\n return parser.parse_args()[0]","def help2optparse(self):\n helpstring_offset = self._get_helpoffset()\n option_cnt = -1\n option_list = []\n ## 1 is 'Options' line\n for line in self.parselines[1:]:\n if len(line) < helpstring_offset:\n break\n if '--help' in line:\n continue\n tmp = line.split()\n metavar = None\n if tmp[0][:2] == '--':\n ## only long option\n longopt = tmp[0]\n if '=' in longopt:\n longtmp = longopt.split(\"=\")\n longopt = longtmp[0]\n metavar = longtmp[1]\n option_list.append({'short': None,\n 'long': longopt,\n 'metavar': metavar,\n 'help': line[helpstring_offset:] + ' '})\n option_cnt += 1\n elif tmp[0][0] == '-':\n ## short option\n shortopt = tmp[0][:2]\n longopt = None\n if line[helpstring_offset - 1] is ' ':\n help_string = line[helpstring_offset:]\n else:\n help_string = \"\"\n if tmp[1][:2] == '--':\n longopt = tmp[1]\n if '=' in longopt:\n longtmp = longopt.split(\"=\")\n longopt = longtmp[0]\n metavar = longtmp[1]\n else: # found metavar\n metavar = tmp[1][:-1]\n longopt = tmp[2].split(\"=\")[0]\n option_list.append({'short': shortopt,\n 'long': longopt,\n 'metavar': metavar,\n 'help': help_string + ' '})\n option_cnt += 1\n else:\n ## only help-strings line\n option_list[option_cnt]['help'] += line[helpstring_offset:]\n option_list[option_cnt]['help'] += \" \"\n return self._get_parserobj(option_list)","def print_parse_result(self, line, log_probs, backpointer, length):\n line = line.strip()\n if log_probs[(0, length-1)][START_SYM] != -float('inf'):\n print(\n self._format_parse(START_SYM, backpointer, 0, length-1, 0))\n print(log_probs[(0, length-1)][START_SYM])\n else:\n print('NONE')","def _output_vadapter_list_verbose(outf, name, vadapter_list):\n\n if vadapter_list:\n FMT = \"%s\\n%-10s\\n%-20s\\n%-5s\\n%s\\n%s\\n%s\\n%s\\n%s\\n%s\\n%s\\n%s\\n%s\\n%s\\n%s\\n%s\\n%s\\n\"\n# HEADER = (\"id\",\"name\",\"io_module_id\",\"vfabric_id\",\"protocol\",\"init_type\",\"desc\",\"status\",\"mac\"\n# ,\"prmiscuous_mode\",\"silent_listener\",\"vlan\",\"wwnn\",\"wwpn\",\"fc_id\",\"spma\",\"fmpa\") \n\t\n for (n , vadapter) in vadapter_list:\n name = vadapter['NAME']\n id = vadapter['ID']\n protocol = vadapter['PROTOCOL']\n vfabric = vadapter['VFABRIC']\n io_module = vadapter['IO_MODULE_ID']\n desc = vadapter['DESC']\n status = vadapter['STATUS']\n init_type = vadapter['INIT_TYPE']\n running_mode = vadapter['RUNNING_MODE']\n if protocol == 1:\n mac = vadapter['MAC']\n promiscuous = vadapter['PROMISCUOUS']\n silent = vadapter['SILENT']\n vlan = vadapter['VLAN']\n elif protocol == 3:\n wwnn = vadapter['WWNN']\n wwpn = vadapter['WWPN']\n spma = vadapter['SPMA']\n fpma = vadapter['FPMA']\n fc_id = vadapter['FC_ID']\n\n\n if _LIMITED_SHOW:\n outf.write('General Attr:\\nId: %s\\n\\tName: %s\\n\\tIO_Module: %s\\n\\tVfabric: %s\\n\\tProtocol: %s\\n\\tInitization_Type: %s\\n\\tDescription: %s\\n\\tStatus: %-20s\\n\\n' % (id, name, io_module, vfabric, protocol, init_type, desc, status)) \n \n\t\telif _DETAIL_SHOW: \n if protocol == 3:\n outf.write('General Attr:\\nId: %s\\nName: %s\\nIO_Module: %s\\nVfabric: %s\\nProtocol: %s\\nInitization_Type: %s\\nDescription: %s\\nStatus: %-20s\\nRUNNING_MODE :%s\\nFC_Attr:\\n\\tWWNN: %s\\n\\tWWNP: %s\\n\\tFC_ID: %s\\n\\tSPMA: %s\\n\\tFMPA: %s\\n\\n' % (id, name, io_module, vfabric, protocol, init_type, desc, status, running_mode, wwnn, wwpn,fc_id,spma,fpma)) \n \n elif protocol == 1:\n\t\t\t outf.write('General Attr:\\nId: %s\\nName: %s\\nIO_Module: %s\\nVfabric: %s\\nProtocol: %s\\nInitization_Type: %s\\nDescription: %s\\nStatus: %-20s\\nRUNNING_MODE :%s\\nEN_Attr:\\n\\tMAC: %s\\n\\tVLAN: %s\\n\\tPromiscuous: %s\\n\\tSilent Listener: %s\\n\\n' % (id , name, io_module,vfabric, protocol, init_type, desc, status, running_mode, mac,vlan, promiscuous, silent))","def parse_commandline():\n parser = optparse.OptionParser()\n\n parser.add_option(\"-n\", \"--num\", help=\"Pulsar number\", default=0, type=int)\n parser.add_option(\"-p\", \"--prfile\", help=\"Parameter file\", type=str)\n parser.add_option(\"-d\", \"--drop\", \\\n help=\"Drop pulsar with index --num in a full-PTA run \\\n (0 - No / 1 - Yes)\", default=0, type=int)\n parser.add_option(\"-c\", \"--clearcache\", \\\n help=\"Clear psrs cache file, associated with the run \\\n (to-do after changes to .par and .tim files)\", \\\n default=0, type=int)\n parser.add_option(\"-m\", \"--mpi_regime\", \\\n help=\"In MPI, manipulating with files and directories \\\n causes errors. So, we provide 3 regimes: \\n \\\n (0) No MPI - run code as usual; \\n \\\n (1) MPI preparation - manipulate files and prepare \\\n for the run (should be done outside MPI); \\n \\\n (2) MPI run - run the code, assuming all necessary \\\n file manipulations have been performed. \\n \\\n PolychordLite sampler in Bilby supports MPI\",\n default=0, type=int)\n parser.add_option(\"-w\", \"--wipe_old_output\", \\\n help=\"Wipe contents of the output directory. Otherwise, \\\n the code will attempt to resume the previous run. \\\n Be careful: all subdirectories are removed too!\", \\\n default=0, type=int)\n parser.add_option(\"-x\", \"--extra_model_terms\", \\\n help=\"Extra noise terms to add to the .json noise model \\\n file, a string that will be converted to dict. \\\n E.g. {'J0437-4715': {'system_noise': \\\n 'CPSR2_20CM'}}. Extra terms are applied either on \\\n the only model, or the second model.\", \\\n default='None', type=str)\n\n opts, args = parser.parse_args()\n\n return opts","def parse_commandline():\n parser = optparse.OptionParser()\n\n parser.add_option(\"-w\", \"--wavelength\", default=600, type=int)\n parser.add_option(\"-f\", \"--filter\", default=1, type=int)\n parser.add_option(\"-g\", \"--grating\", default=3, type=int)\n parser.add_option(\"--doMonoWavelength\", action=\"store_true\", default=False)\n parser.add_option(\"--doMonoFilter\", action=\"store_true\", default=False)\n parser.add_option(\"--doMonoGrating\", action=\"store_true\", default=False)\n parser.add_option(\"--doGetMono\", action=\"store_true\", default=False)\n parser.add_option(\"-v\", \"--verbose\", action=\"store_true\", default=False)\n\n opts, args = parser.parse_args()\n\n return opts","def task_parse_results():\n pass","def parse_csv_option(option):\n if option:\n return option.split(',')\n else:\n return []","def parse_csv_option(option):\n if option:\n return option.split(',')\n else:\n return []","def parse_commandline():\n parser = optparse.OptionParser(usage = __doc__,version=git_version.verbose_msg)\n\n parser.add_option(\"-t\", \"--timeFile\",help=\"Text file with central times.\",default = 'centralTimes.txt')\n\tparser.add_option(\"-c\", \"--channel\",help=\"IFO channel.\",default = 'L1:GDS-CALIB_STRAIN')\n\tparser.add_option(\"-w\", \"--workdirectory\",help=\"Working directory.\",default = '.')\n\tparser.add_option(\"-s\", \"--sourceDir\",help=\"Name of source directory.\",default = 'source')\n\n opts, args = parser.parse_args()\n return opts","def parse_pts(pts_result_file, global_var_list, parsed_results_file):\n fill_value_name(pts_result_file, global_var_list, parsed_results_file)","def _parse_option_value(line, option_name):\n try:\n option_value = line.split('=')[1].strip()\n except IndexError:\n option_value = ''\n if not option_value:\n raise ValueError(\"No value specified for {} option.\".format(option_name))\n return option_value","def _parse_param_line(regex, line):\n out = []\n for r in regex.findall(line):\n converter, variable = r[0] or 'default', r[1]\n out.append((_CONVERTERS[converter], variable))\n return out","def parse_options(options):\r\n # convert single quotes inside option values to html encoded string\r\n options = re.sub(r\"([a-zA-Z])('|\\\\')([a-zA-Z])\", r\"\\1'\\3\", options)\r\n options = re.sub(r\"\\\\'\", r\"'\", options) # replace already escaped single quotes\r\n # parse the set of possible options\r\n lexer = shlex.shlex(options[1:-1].encode('utf8'))\r\n lexer.quotes = \"'\"\r\n # Allow options to be separated by whitespace as well as commas\r\n lexer.whitespace = \", \"\r\n\r\n # remove quotes\r\n # convert escaped single quotes (html encoded string) back to single quotes\r\n tokens = [x[1:-1].decode('utf8').replace(\"'\", \"'\") for x in lexer]\r\n\r\n # make list of (option_id, option_description), with description=id\r\n return [(t, t) for t in tokens]","def parse_options():\n global parser\n parser.add_option(\"-r\", \"--regions\", dest=\"input_brain_regions\",\n help=\"Input file for brain region data\",\n action=\"store\", type='string')\n\n parser.add_option(\"-g\", \"--gray\", dest=\"input_gray_levels\",\n help=\"Input file for gray level data\",\n action=\"store\", type='string')\n\n parser.add_option(\"-n\", \"--nissl\", dest=\"input_nissl\",\n help=\"Input file for nissl data\",\n action=\"store\", type='string')\n\n parser.add_option(\"-o\", \"--output\", dest=\"output_folder_path\",\n help=\"Output folder for extracted data files\",\n action=\"store\", type='string')\n\n return parser.parse_args()","def argument_parser():\n parser = argparse.ArgumentParser(\n description='separate mutect only calls, strelka only calls, and intersect calls from two vcf files')\n\n parser.add_argument('-o', '--outputDIR', required=False, default=os.getcwd())\n parser.add_argument('-m', '--mutect', required=True, help='Mutect VCF')\n parser.add_argument('-s', '--sampleName', required=True, help='Sample name of tumor sample that is used in the header of VCF file. Usually identified from `@RG SM:` tag from BAM file')\n\n# parser.add_argument('-n', '--normal_column', type=int, required=True, help='Tells whether normal column is written before cancer column. For example after the <FORMAT> column of vcf, if the order is <TUMOR> <NORMAL>, then --normal_column is 1. If <NORMAL> <TUMOR> then --normal_column is 0')\n parser.add_argument('-t', '--threshold', type=float, required=True, help ='Threshold to filter out those variants that has variant reads in normal Bam')\n\n args = vars(parser.parse_args())\n\n outputDIR = args['outputDIR']\n mutect = args['mutect']\n# normal_column = args['normal_column']\n sampleName = args['sampleName']\n threshold = args['threshold']\n return outputDIR, mutect, sampleName, threshold","def parse_command_line(self):\n return self.command_line_parser.parse()","def parse(self, command_line=sys.argv[1:]):\n return self._parser.parse_args(command_line)","def printOptions(opts,subject_ids,session_ids,task_list, run_list, acq, rec):\n uname = os.popen('uname -s -n -r').read()\n print \"\\n\"\n print \"* Pipeline started at \"+time.strftime(\"%c\")+\"on \"+uname\n print \"* Command line is : \\n \"+str(sys.argv)+\"\\n\"\n print \"* The source directory is : \"+opts.sourceDir\n print \"* The target directory is : \"+opts.targetDir+\"\\n\"\n print \"* Data-set Subject ID(s) is/are : \"+str(', '.join(subject_ids))+\"\\n\"\n # print \"* PET conditions : \"+ ','.join(opts.condiList)+\"\\n\"\n print \"* Sessions : \", session_ids, \"\\n\"\n print \"* Tasks : \" , task_list , \"\\n\"\n print \"* Runs : \" , run_list , \"\\n\"\n print \"* Acquisition : \" , acq , \"\\n\"\n print \"* Reconstruction : \" , rec , \"\\n\"","def handle_option(self, option, options):\n pass","def parse_vcf_line(line):\n\n if isinstance(line, str):\n if line.startswith('#'):\n return None\n\n elem = line.strip().split('\\t')\n elif isinstance(line, list):\n elem = line\n\n try:\n quality = int(elem[5])\n except ValueError:\n try:\n quality = float(elem[5])\n except ValueError:\n quality = None\n\n filter_field = None\n\n if elem[6] != '.':\n filter_field = elem[6].split(';')\n\n info = elem[7]\n\n try:\n fmt = elem[8]\n except IndexError:\n fmt = None\n else:\n if fmt == '.':\n fmt = None\n\n return VCFRecord(elem[0], int(elem[1]), None if elem[2] == '.' else elem[2], elem[3],\n elem[4].split(','), quality, filter_field, info, fmt, elem[9:])","def process_output(self):\n vim.command('call setqflist([])')\n qf_list = []\n qf_dict = {}\n\n for line in self.output:\n skip = False\n for exclude_pattern in self.exclude_list:\n if exclude_pattern in line[2]:\n skip = True\n break\n if skip:\n continue\n qf_dict['bufnr'] = self.bufnr\n qf_dict['lnum'] = line[0]\n qf_dict['col'] = line[1]\n qf_dict['text'] = line[2]\n qf_dict['type'] = line[2][0]\n qf_list.append(qf_dict)\n qf_dict = {}\n\n self.output = []\n vim.command('call setqflist(%s)' % str(qf_list))\n if qf_list:\n vim.command('copen')","def cliOptions():\n parser = OptionParser()\n\n parser.add_option(\"-s\", \"--saint\", help=\"Please provide the Saint CSV file\", dest=\"saint\")\n parser.add_option(\"-n\", \"--nessus\", help=\"Please provide the Nessus CSV file\", dest=\"nessus\")\n parser.add_option(\"-e\", \"--export\", help=\"Please provide an name for export\", dest=\"export\")\n\n (options, args) = parser.parse_args()\n\n # hard coding the path to the csv files until i get the results I want and for simple testing.\n # you can remove/comment out the next two lines and invoke the python script with the flags above.\n #options.saint = 'data/saint.csv'\n #options.nessus = 'data/nessus.csv'\n #options.export = 'data/export.csv'\n\n # Ensure the Saint/Nessus csv files have been provided\n if options.saint is None or options.nessus is None:\n print 'Forgot the CSV reports'\n sys.exit(2)\n\n # Call Merged Results\n MergedResults(options.saint, options.nessus, options.export)","def _process_line(line, status):\n\n if line.startswith(ADAPTER_LINE_STARTSWITH):\n status.add_block('adapter', 'name', line)\n return\n elif line.startswith(EXIT_LINE_STARTSWITH):\n status.consolidate()\n return\n\n key, value = [el.strip(' \\t\\r\\n') for el in line.split(':', 1)]\n\n if key in KEY_TO_CONTEXT.keys():\n status.add_block(KEY_TO_CONTEXT[key], key, value)\n else:\n status.set_property(key, value)","def parse_listing(self, raw_output):\n return output_parser.listing(raw_output)","def V_action(option,opt_str,value,parser):\n print topo.__version__\n sys.exit()","def parse_list_output(output):\n lines = output.splitlines()\n keys = filter(None, lines[1].split('|'))\n keys = [x.lower().strip() for x in keys]\n r = []\n for line in lines[3:-1]:\n if len(line.split()) <= 1:\n continue\n values = filter(None, line.split('|'))\n values = [x.strip() for x in values]\n assert len(keys) == len(values)\n record = dict(zip(keys, values))\n r.append(record)\n return r","def versatileOptions():\r\n return tuple(sorted(i[0] for i in list(Options.defaults().items()) if i[1].find(' #v ') > 0))","def _parse_qselect(qselect_output):\n jobs = qselect_output.splitlines()\n if not jobs or (len(jobs) == 1 and jobs[0] == ''):\n return []\n return [int(job.split('.')[0]) for job in jobs]","def parse_cmd_line_options():\n parser = argparse.ArgumentParser(prog='runner.py', description=\"Measure and view your internet speeds\")\n subparsers = parser.add_subparsers(help='help for subcommand', dest=\"command\")\n\n # create the parser for the \"run\" command\n run_parser = subparsers.add_parser('run', description=\"Measure internet speed periodically by setting frequency and duration.\",\n epilog=\"Both frequency and duration should be formatted as follows \\\n ----------- interger [sec|min|hour|day|] ex) 5 min\")\n run_parser.add_argument(\"-f\", \"--frequency\", nargs=2, required=True,\n help='How often should we run.')\n run_parser.add_argument(\"-d\", \"--duration\", nargs=2, default=[24, \"hour\"],\n help=\"How long should we run. (default=%(default)s)\")\n run_parser.add_argument(\"-resultfile\", default=\"speedresults.json\",\n help=\"Location where results shouls be saved (default=%(default)s)\")\n run_parser.add_argument(\"-configfile\")\n run_parser.add_argument(\"-pidfile\")\n\n # create the parser for the \"draw\" command\n draw_parser = subparsers.add_parser('draw', help='help for command_2')\n draw_parser.add_argument(\"-resultfile\", default=\"speedresults.json\", help=\"Choose results file to draw. (default=%(default)s)\")\n draw_parser.add_argument(\"-type\", default=\"pyplot\", choices=[\"pyplot\", \"plotly\"],\n help=\"The type of graph to display (default=%(default)s)\")\n draw_parser.add_argument(\"-filter\", nargs=2, help='Filter data on specific key value pairs')\n draw_parser.add_argument(\"-options\", default=\"download\", choices=[\"download\", \"upload\"],\n help='Graph upload or download speeds. (default=%(default)s)')\n return parser.parse_args()","def parse_command_line(argv):\n formatter_class = argparse.RawDescriptionHelpFormatter\n parser = argparse.ArgumentParser(description=module,formatter_class=formatter_class)\n parser.add_argument('-n', '--name', dest=\"name\", metavar=\"hostname\",\n nargs='?', \n type=str,\n required=True,\n help=\"Define a virtual hostname\")\n parser.add_argument('-o', '--os', dest=\"os\", metavar=\"os\",\n nargs='?', \n required=True,\n type=str,\n choices=['debian','mint','centos','mac','w7'],\n help=\"Define a operating system\")\n parser.add_argument(\"--dry-run\", help=\"Only print throughput, do not execute command.\",\n action=\"store_true\")\n parser.add_argument(\"--legacy\", help=\"Use legacy install (from official repository).\",\n action=\"store_true\")\n parser.add_argument(\"--version\", action=\"version\",\n version=\"%(prog)s {}\".format(__version__))\n parser.add_argument(\"-v\", \"--verbose\", dest=\"verbose_count\",\n action=\"count\", default=0,\n help=\"increases log verbosity for each occurence.\")\n arguments = parser.parse_args(argv[1:])\n # Sets log level to WARN going more verbose for each new -v.\n log.setLevel(max(3 - arguments.verbose_count, 0) * 10)\n return arguments","def set_parser():\n\n print('\\n\\nLoading Options and Configurations\\n' + 72 * '~' + '\\n')\n parser = ArgumentParser( \\\n description=('''\\n\nUsed to validate the TELEMAC system against a benchmark of test cases for\na certain rank, and a certain tag'''))\n\n parser = add_runcode_argument(parser)\n parser.add_argument( \\\n \"-b\", \"--bypass\", action=\"store_true\", dest=\"bypass\", default=False,\n help=\"will bypass execution failures and try to carry on \"\\\n \"(final report at the end)\")\n # Combine with all filters above, \"rank\" now controls everything\n # and Jenkins can control \"rank\"\n parser.add_argument( \\\n \"-k\", \"--rank\", dest=\"rank\", type=int, default=4,\n help=\"specify the ranks to be validated all rank lower or equal to \"\n \"the value will be run\")\n parser.add_argument( \\\n \"--tags\", dest=\"tags\", default='all',\n help=\\\n \"specify tags (; separated) to run \"\\\n \" '-tag' will do the opposite and \"\\\n \"tag1+tag2 will run cases that has both tag1 and tag2), \"\\\n \"default is all of them\")\n parser.add_argument( \\\n \"--valrootdir\", dest=\"val_root\", default='',\n help=\"specify the directory in which to search the validation cases, \"\\\n \"default is taken from config file\")\n parser.add_argument( \\\n \"--vnv-pre\", action=\"store_true\", dest=\"vnv_pre\", default=False,\n help=\"Only do pre-treatment\")\n parser.add_argument( \\\n \"--vnv-run\", action=\"store_true\", dest=\"vnv_run\", default=False,\n help=\"Only do execution for each study\")\n parser.add_argument( \\\n \"--vnv-check\", action=\"store_true\", dest=\"vnv_check\", default=False,\n help=\"Only do check of results (epsilons)\")\n parser.add_argument( \\\n \"--vnv-post\", action=\"store_true\", dest=\"vnv_post\", default=False,\n help=\"Only do post-treatment\")\n parser.add_argument( \\\n \"--report-name\", dest=\"report_name\", default='',\n help=\"will create a csv containing information on the validation \"\\\n \"such as execution time, rank, if it passed...\")\n parser.add_argument( \\\n \"--clean\", action=\"store_true\", dest=\"cleanup\", default=False,\n help=\"will erase all object, executable, result files \"\\\n \"from subfolders for the actual configuration\")\n parser.add_argument( \\\n \"--full-clean\", action=\"store_true\", dest=\"full_cleanup\", default=False,\n help=\"will erase all vnv study folders regarding of configurations\")\n\n # Options for notebook\n parser.add_argument(\n \"--notebook\",\n dest=\"notebook\",\n action=\"store_true\", default=False,\n help=\"Run validation of notebook\")\n parser.add_argument(\n \"--notebook-timeout\",\n dest=\"nb_timeout\", type=int, default=60000,\n help=\"Time after whihc the notebook will be killed if still running\")\n parser.add_argument(\n \"--notebook-update\",\n dest=\"nb_update\",\n action=\"store_true\", default=False,\n help=\"Update notebook file with the runned one\")\n parser.add_argument(\n \"--verbose\",\n dest=\"verbose\",\n action=\"store_true\", default=False,\n help=\"More verbose validation\")\n\n # Options for api\n parser.add_argument(\n \"--api\",\n dest=\"api\",\n action=\"store_true\", default=False,\n help=\"Run validation of api\")\n\n parser.add_argument(\"args\", metavar='Python file(s)', nargs='*')\n options = parser.parse_args()\n\n # Conversion of options.tags (replacing all by list) and checking that the\n # value is valid\n # Removing quotes\n tmp_tag = options.tags.strip(\"'\\\"\")\n options.tags = tmp_tag\n # Checking that tags are valid\n for tag in options.tags.split(';'):\n if '+' in tag:\n for and_tag in tag.split('+'):\n # Removing - if in tag\n ttag = and_tag[1:] if and_tag[0] == '-' else and_tag\n if ttag not in TAGS:\n raise TelemacException(\\\n \"Unknow tag: {tag}\\nTags available: {tags}\"\\\n .format(tag=ttag, tags=';'.join(TAGS)))\n else:\n if tag == 'all':\n continue\n # Removing - if in tag\n ttag = tag[1:] if tag[0] == '-' else tag\n if ttag not in TAGS:\n raise TelemacException(\\\n \"Unknow tag: {tag}\\nTags available: {tags}\"\\\n .format(tag=ttag, tags=';'.join(TAGS)))\n\n # Replacing all by list of tags\n if 'all' in options.tags.split(';'):\n options.tags = options.tags.replace('all', ';'.join(TAGS))\n\n # If pre, run, post are all false switching them to true\n if not(options.vnv_pre or options.vnv_run or\n options.vnv_check or options.vnv_post):\n options.vnv_pre = True\n options.vnv_run = True\n options.vnv_check = True\n options.vnv_post = True\n\n return options","def _parse_qselect(qselect_output):\n jobs = qselect_output.splitlines()\n if not jobs or (len(jobs) == 1 and jobs[0] is ''):\n return []\n return [int(job.split('.')[0]) for job in jobs]","def set_option_parse_svn_entries(self, boolean, apikey=''):\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/action/setOptionParseSVNEntries/', {'Boolean': boolean, 'apikey': apikey})))","def parseOptions():\n desc = \"Compute the likelihood of sequences coming from a list of barcodes.\"\n parser = argparse.ArgumentParser(description=desc, add_help=False)\n\n def canonicalizedFilePath(path):\n return os.path.abspath(os.path.expanduser(path))\n\n def checkInputFile(path):\n if not os.path.isfile(path):\n parser.error(\"Input file %s not found.\" % (path,))\n\n def checkOutputFile(path):\n try:\n f = open(path, \"a\")\n f.close()\n except:\n parser.error(\"Output file %s cannot be written.\" % (path,))\n\n basics = parser.add_argument_group(\"Basic required options\")\n basics.add_argument(\n \"cmpH5Filename\",\n type=canonicalizedFilePath,\n metavar=\"CMP.H5\",\n help=\"The filename of the input Bas.H5 file\")\n basics.add_argument(\n \"referenceFasta\",\n type=canonicalizedFilePath,\n metavar=\"REFERENCE_FASTA\",\n help=\"The reference sequences of interest in FASTA format\")\n basics.add_argument(\n \"basH5Fofn\",\n type=canonicalizedFilePath,\n metavar=\"BARCODE_FASTA\",\n help=\"The filename of the barcode FASTA\")\n basics.add_argument(\n \"-o\", \"--outputFilename\",\n type=str,\n default=os.path.join(os.getcwd(), \"output.csv\"),\n metavar=\"CSV\",\n help=\"The filename of the CSV to output barcode scoring data to.\")\n basics.add_argument(\n \"-m\", \"--minSize\",\n type=int,\n default=3,\n metavar=\"INT\",\n help=\"The minimum size of a homopolymer context to record\")\n\n debugging = parser.add_argument_group(\"Verbosity and debugging/profiling\")\n debugging.add_argument(\"--help\", \"-h\",\n action=\"help\")\n debugging.add_argument(\n \"--nZmws\",\n default=-1,\n type=int,\n help=\"Label only the first N ZMWs for testing purposes.\")\n debugging.add_argument(\n \"--verbose\", \"-v\",\n dest=\"verbosity\",\n action=\"count\",\n help=\"Set the verbosity level.\")\n debugging.add_argument(\n \"--quiet\",\n dest=\"quiet\",\n action=\"store_true\",\n help=\"Turn off all logging, including warnings\")\n class PrintVersionAction(argparse.Action):\n def __call__(self, parser, namespace, values, option_string=None):\n print \" RegionTools version: %s\" % __version__\n print \" h5py version: %s\" % h5py.version.version\n print \" hdf5 version: %s\" % h5py.version.hdf5_version\n sys.exit(0)\n debugging.add_argument(\"--version\",\n nargs=0,\n action=PrintVersionAction)\n\n parser.parse_args(namespace=options)\n\n for path in (options.cmpH5Filename, options.referenceFasta, options.basH5Fofn):\n if path is not None:\n checkInputFile(path)\n\n for path in (options.outputFilename,):\n if path is not None:\n checkOutputFile(path)\n\n options.shellCommand = \" \".join(sys.argv)","def _process_command_line():\n # pylint: disable=C0103\n global parameters\n # pylint: enable=C0103\n\n # option letters followed by : expect an argument\n # same for option strings followed by =\n if parameters[\"Command flavour\"] in (\"posix\", \"linux\"):\n character_options = \"s?\"\n else: # if parameters[\"Command flavour\"] in (\"PNU\", \"bsd\", \"bsd:freebsd\"):\n character_options = \"qs?\"\n string_options = [\n \"debug\",\n \"help\",\n \"version\",\n ]\n\n try:\n options, remaining_arguments = getopt.getopt(\n sys.argv[1:], character_options, string_options\n )\n except getopt.GetoptError as error:\n logging.critical(\"Syntax error: %s\", error)\n _display_help()\n sys.exit(1) # no match\n\n for option, _ in options:\n\n if option == \"--debug\":\n logging.disable(logging.NOTSET)\n\n elif option in (\"--help\", \"-?\"):\n _display_help()\n sys.exit(1) # no match\n\n elif option == \"-q\":\n parameters[\"No formatting\"] = True\n\n elif option == \"-s\":\n parameters[\"First match only\"] = True\n\n elif option == \"--version\":\n print(ID.replace(\"@(\" + \"#)\" + \" $\" + \"Id\" + \": \", \"\").replace(\" $\", \"\"))\n sys.exit(1) # no match\n\n logging.debug(\"_process_command_line(): parameters:\")\n logging.debug(parameters)\n logging.debug(\"_process_command_line(): remaining_arguments:\")\n logging.debug(remaining_arguments)\n\n return remaining_arguments","def do_Promo_line_parse (Promo_line, line_number, filehash) :\n result = [filehash,\n line_number,\n Promo_line[0:8].strip(),\n Promo_line[9:13].strip(),\n Promo_line[14:19].strip(),\n Promo_line[20:26].strip().lstrip('0'), # Spec indicates numerical field\n Promo_line[27:30].strip().lstrip('0'), # Spec indicates numerical field\n Promo_line[31:40].strip(),\n Promo_line[41:49].strip(),\n Promo_line[50:].strip()\n ]\n return result\n # Having the line number passed in is ugly, but kind of works :/\n # Having all the field extraction explicit is kind of ugly too...\n # We're using the hash here to link? Yeah, that's because Python\n # doesn't know what the autonumbered load table is up to in the\n # DB when it starts to coalesce the raw files together.","def _parse_options():\n parser = OptionParser()\n parser.add_option('-q', '--quiet', help='set logging to ERROR',\n action='store_const', dest='loglevel',\n const=logging.ERROR, default=logging.INFO)\n parser.add_option('-d', '--debug', help='set logging to DEBUG',\n action='store_const', dest='loglevel',\n const=logging.DEBUG, default=logging.INFO)\n parser.add_option('-v', '--verbose', help='set logging to COMM',\n action='store_const', dest='loglevel',\n const=5, default=logging.INFO)\n options, _ = parser.parse_args()\n logging.basicConfig(level=options.loglevel,\n format='%(levelname)-8s %(message)s')","def _result_to_dict(line):\n f = line.split(':;')\n return {'server': f[0], 'os_name': f[1], 'status': f[2], 'ipv4': f[3]}","def _parse_version_string(cmd_result: str) -> str:\n lines = cmd_result.splitlines()\n split_lines = [line.split(\" \") for line in lines]\n version_line = [\n line for line in split_lines if len(line) > 0 and line[1] == \"version\"\n ][0]\n version_string = version_line[2].replace('\"', \"\")\n return version_string","def _handle_short_form(element):\n if len(element) <= 1:\n raise CmdLineException(\"Invalid option: '{}'\".format(element))\n tokens = []\n for i in range(1, len(element)):\n if element[i: i + 1] == \"=\":\n if i + 1 < len(element):\n tokens.append(element[i + 1:])\n break\n tokens.append(\"-\" + element[i: i + 1])\n return tokens","def main() -> int:\n ucvm_out = \"\"\n for j in frange(CORNERS[\"bl\"][\"n\"], CORNERS[\"ur\"][\"n\"], SPACING):\n for i in frange(CORNERS[\"bl\"][\"e\"], CORNERS[\"ur\"][\"e\"] + SPACING, SPACING):\n ucvm_out += \"%.2f %.2f 0\\n\" % (i, j)\n os.chdir(\"/Users/davidgil/ucvm-15.10.0/bin\")\n proc = Popen(\n [\"./ucvm_query\", \"-f\", \"../conf/ucvm.conf\"], stdout=PIPE, stdin=PIPE, stderr=STDOUT\n )\n out_arr = np.zeros(\n shape=(\n int((CORNERS[\"ur\"][\"n\"] - CORNERS[\"bl\"][\"n\"]) / SPACING) + 2,\n int((CORNERS[\"ur\"][\"e\"] - CORNERS[\"bl\"][\"e\"]) / SPACING) + 2\n )\n )\n output = proc.communicate(input=ucvm_out.encode(\"ASCII\"))[0]\n i = 0\n j = 0\n for line in output.decode(\"ASCII\").split(\"\\n\")[2:-1]:\n line_split = line.split()\n try:\n out_arr[j][i] = float(line_split[4])\n except IndexError:\n print(line_split)\n if i == int((CORNERS[\"ur\"][\"e\"] - CORNERS[\"bl\"][\"e\"]) / SPACING):\n i = 0\n j += 1\n else:\n i += 1\n np.save(\"vs30.dat\", out_arr)\n return 0","def parse_commandline():\n parser = optparse.OptionParser()\n\n parser.add_option(\"-l\",\"--lamp\", default=100, type=int)\n parser.add_option(\"-c\",\"--doCompile\", action=\"store_true\", default=False)\n parser.add_option(\"--doLamp\", action=\"store_true\", default=False)\n\n opts, args = parser.parse_args()\n\n return opts","def ParseArgsMain():\n parser = argparse.ArgumentParser() # command-line string parser\n\n parser.description = 'vSphereTools version: {}. vSphereTools is a set of scripts from DevOpsHQ to support working with vSphere and virtual machines (VMs) on it, which are based on the pysphere library.'.format(__version__)\n parser.epilog = 'See examples on GitHub: http://devopshq.github.io/vspheretools/'\n parser.usage = 'vspheretools [options] [command]'\n\n parser.add_argument('-v', '--version', action='store_true', help='Show current version of vSphereTools.')\n\n # --- server options:\n parser.add_argument('-s', '--server', type=str, help='main vSphere Server Cluster, e.g. vcenter-01.example.com.')\n parser.add_argument('-l', '--login', type=str, help='Username for work with vSphere.')\n parser.add_argument('-p', '--password', type=str, help='Sphere Userpass.')\n\n parser.add_argument('-n', '--name', type=str, help='Name of virtual machine.')\n\n parser.add_argument('-gl', '--guest-login', type=str, help='Guest Username for work with Guest OS on VM.')\n parser.add_argument('-gp', '--guest-password', type=str, help='VM Guest Userpass.')\n\n parser.add_argument('-d', '--clone-dir', type=str, help='Directory name on vSphere for clonning virtual machine. \"Clones\" by default.')\n parser.add_argument('-t', '--timeout', type=str, help='Operations timeout in seconds, 300s. by default.')\n\n # --- commands:\n parser.add_argument('--status', action='store_true', help='Get virtual machine status.')\n parser.add_argument('--start', action='store_true', help='Starting virtual machine.')\n parser.add_argument('--start-wait', action='store_true', help='Starting virtual machine and wait while guest OS started.')\n parser.add_argument('--stop', action='store_true', help='Stopping virtual machine.')\n\n parser.add_argument('--snapshots', action='store_true', help='Get list of all snapshots of virtual machine.')\n parser.add_argument('--create-snapshot', type=str, nargs='+', help='Create snapshot of VM with options. Example: --create-snapshot name=\"Snapshot name\" rewrite=True fail-if-exist=False')\n parser.add_argument('--revert-to-current-snapshot', action='store_true', help='Revert virtual machine to current snapshot.')\n parser.add_argument('--revert-to-snapshot', type=str, help='Revert virtual machine to snapshot by name.')\n\n parser.add_argument('--properties', action='store_true', help='Get all avaliable properties of virtual machine.')\n parser.add_argument('--get-ip', action='store_true', help='Get ip address of virtual machine.')\n parser.add_argument('--set-ip-into-teamcity-param', type=str, help='Set up ip address of virtual machine into predefine TeamCity parameter, vm_ip by default.')\n\n parser.add_argument('--clone', type=str, help='Clone virtual machine into directory VM_CLONES_DIR with given name.')\n\n parser.add_argument('--delete', action='store_true', help='Remove virtual machine by name.')\n\n parser.add_argument('--upload-file', type=str, nargs='+', help='Copy file into virtual machine with True to overwrite. Example: --upload-file srcFile dstFile True')\n parser.add_argument('--download-file', type=str, nargs='+', help='Download file from virtual machine with True to overwrite local file. Example: --download-file srcFile dstFile True')\n\n parser.add_argument('--mkdir', type=str, nargs='+', help='Creating directory and all sub-directory in given path with True to create sub-dirs. Example: --mkdir dir_path True')\n parser.add_argument('--execute', type=str, nargs='+', help=r'Execute program on guest OS with parameters. Example: --execute program=\"C:\\Windows\\System32\\cmd.exe\" args=\"/T:Green /C echo %%aaa%% & echo %%bbb%%\" env=\"aaa:10, bbb:20\" cwd=\"C:\\Windows\\System32\" pythonbin=\"c:\\python27\\python.exe\" wait=True')\n\n parser.add_argument('--not-skip-run', type=str, help='This is parameter for TeamCity support. Scripts executed if \"TRUE\". Scripts skipped if \"FALSE\". Otherwise exception raised.')\n\n return parser.parse_args()"],"string":"[\n \"def processOption (self, line) :\\n ll = line.split ('=')\\n if len (ll) < 2:\\n print \\\"Cannot parse option \\\" , line\\n sys.exit()\\n result = (ll[0].strip() , ll[1].strip())\\n return result\",\n \"def _parse_results(self):\\n for line in self.file_dic['output'].splitlines():\\n if line.startswith(' * GAMESS VERSION = '):\\n temp = line.split('=')[1]\\n temp = temp.split('*')[0]\\n self.version = temp.strip()\\n\\n if line[1:25] == 'FREE ENERGY OF SOLVATION' and line.find('1 ATM') == -1:\\n temp = line.split()\\n #Take the next number after =\\n #In KCAL/MOL\\n self.solvation_energy = float(temp[temp.index(\\\"=\\\") + 1])\",\n \"def parse_output(result):\\n output = result['output']\\n parsed = output.split('\\\\n')\\n output = []\\n for _line in parsed:\\n output.append(_line.strip())\\n log.debug(_line)\\n return output\",\n \"def _do_option(self, line: str) -> None:\\n if line.startswith(\\\"option verbosity\\\"):\\n self._verbosity = Level(int(line[len(\\\"option verbosity \\\") :]))\\n _write(\\\"ok\\\")\\n else:\\n _write(\\\"unsupported\\\")\",\n \"def parse_results(variants):\\n out = []\\n\\n # set header\\n lines = variants[0].get_output().split('\\\\n')\\n for line in lines[:-1]:\\n out.append(line.split('\\\\t')[0])\\n\\n # append output for all variants to single list\\n for var in variants:\\n lines = var.get_output().split('\\\\n')\\n for i in range(0, len(lines) - 1):\\n out[i] += '\\\\t{}'.format(lines[i].split()[1])\\n\\n return out\",\n \"def v_action(option,opt_str,value,parser):\\n cmdline_main.message(\\\"Enabling verbose message output.\\\")\\n if hasattr(parameterized,'get_logger'):\\n parameterized.get_logger().setLevel(parameterized.VERBOSE)\\n else: # For versions of the param package before 9 May 2013\\n parameterized.min_print_level=parameterized.VERBOSE\",\n \"def on_new_line(self, line, is_full_line):\\n try:\\n if is_full_line:\\n self._parse_v_option(line)\\n self._parse_general_info(line)\\n self._parse_header(line)\\n except ParsingDone:\\n pass # line has been fully parsed by one of above parse-methods\\n return super(W, self).on_new_line(line, is_full_line)\",\n \"def __init__(self, optv):\\n self.__p4optv = optv\\n # Treat '-g' like '-G' except the marshal'ed Python dicts\\n # will be unmarshal'ed.\\n if '-g' in self.__p4optv:\\n self.__p4optv[self.__p4optv.index('-g')] = '-G'\\n self.__unmarshal = 1\\n else:\\n self.__unmarshal = 0\\n # Drop '-s'. 'p4' implements this on the client side and so\\n # should 'px' (XXX though it does not yet), so the option should\\n # not be passed to the server.\\n if '-s' in self.__p4optv:\\n self.__p4optv.remove('-s')\\n log.warn(\\\"dropping '-s' option, px cannot yet handle it\\\")\\n _ListCmd.__init__(self)\",\n \"def parse_options():\\n\\n from optparse import OptionParser\\n usage = r\\\"\\\"\\\"%prog [options] <voxel_file>\\\"\\\"\\\"\\n p = OptionParser(usage=usage)\\n p.add_option('-o', '--output', action='store', dest='output',\\n default='plot', help='Path to output SILO or VTK file.')\\n p.add_option('-v', '--vtk', action='store_true', dest='vtk',\\n default=False, help='Flag to convert to VTK instead of SILO.')\\n parsed = p.parse_args()\\n if not parsed[1]:\\n p.print_help()\\n return parsed\\n return parsed\",\n \"def process_options(self):\\n\\n argv = sys.argv\\n\\n # process any optlist_ options\\n self.valid_opts.check_special_opts(argv)\\n\\n # process terminal options without the option_list interface\\n # (so that errors are not reported)\\n\\n # if no arguments are given, do default processing\\n if '-help' in argv or len(argv) < 2:\\n print(g_help_string)\\n return 1\\n\\n if '-hist' in argv:\\n print(g_history)\\n return 1\\n\\n if '-show_valid_opts' in argv:\\n self.valid_opts.show('', 1)\\n return 1\\n\\n if '-ver' in argv:\\n print(g_version)\\n return 1\\n\\n # ============================================================\\n # read options specified by the user\\n self.user_opts = OL.read_options(argv, self.valid_opts)\\n uopts = self.user_opts # convenience variable\\n if not uopts: return -1 # error condition\\n\\n # ------------------------------------------------------------\\n # process verb first\\n\\n val, err = uopts.get_type_opt(int, '-verb')\\n if val != None and not err: self.verb = val\\n\\n # ------------------------------------------------------------\\n # process options sequentially, to make them like a script\\n errs = 0\\n for opt in self.user_opts.olist:\\n # check for anything to skip\\n if opt.name == '-verb': pass\\n\\n elif opt.name == '-infiles':\\n self.infiles, err = uopts.get_string_list('', opt=opt)\\n if self.infiles == None or err:\\n print('** failed to read -infiles list')\\n errs +=1\\n\\n self.parse_infile_names()\\n\\n elif opt.name == '-overwrite':\\n self.overwrite = 1\\n\\n elif opt.name == '-separator':\\n self.separator, err = uopts.get_string_opt('', opt=opt)\\n if self.separator == None or err:\\n print(\\\"** bad -tablefile option\\\")\\n errs += 1\\n if self.separator == 'tab': self.separator = '\\\\t'\\n elif self.separator == 'whitespace': self.separator = 'ws'\\n self.seplen = len(self.separator)\\n\\n elif opt.name == '-showlabs':\\n self.showlabs = 1\\n\\n elif opt.name == '-show_missing':\\n self.show_missing = 1\\n\\n elif opt.name == '-tablefile':\\n self.tablefile, err = uopts.get_string_opt('', opt=opt)\\n if self.tablefile == None or err:\\n print(\\\"** bad -tablefile option\\\")\\n errs +=1\\n\\n else:\\n oind = self.user_opts.olist.index(opt)\\n print('** unknown option # %d: %s' % (oind+1, opt.name))\\n errs += 1\\n break\\n\\n # allow early and late error returns\\n if errs: return -1\\n\\n # ------------------------------------------------------------\\n # apply any trailing logic\\n\\n if len(self.infiles) < 1:\\n print('** missing -infiles option')\\n errs += 1\\n\\n if errs: return -1\\n\\n return 0\",\n \"def print_result(self, result_line: str):\\r\\n if self.output_option == 1:\\r\\n print(result_line)\\r\\n else:\\r\\n self.ER_file.write('{}\\\\n'.format(result_line))\",\n \"def _parseLine(self, line, delimiter = \\\":\\\"):\\r\\n\\t\\tsplt = line.split(delimiter)\\r\\n\\t\\tinVec = self._parseVec(splt[0])\\r\\n\\t\\toutVec = self._parseVec(splt[1])\\r\\n\\t\\tif (len(splt) == 2):\\r\\n\\t\\t\\tlabel = \\\"\\\"\\r\\n\\t\\telse:\\r\\n\\t\\t\\tlabel = splt[2]\\r\\n\\t\\tself.data.append({'in':inVec, 'out':outVec, 'label':label})\",\n \"def result_handler(raw_output):\\n write_log(raw_output[1])\\n item_list = []\\n line_list = raw_output[1].split('\\\\n')\\n title_list = re.sub(\\\"\\\\s{2,}\\\", \\\"\\\\t\\\", line_list[0]).split(\\\"\\\\t\\\")\\n for line in line_list[1:]:\\n item_list.append(re.sub(\\\"\\\\s{2,}\\\", \\\"\\\\t\\\", line).split(\\\"\\\\t\\\"))\\n return raw_output[0], title_list, item_list\",\n \"def _parse_result(self, result, *, verbose=False, **kwargs):\\n return get_fermilat_datafile(result)\",\n \"def options(self, content, result='all'):\\n if not self.tracconfig:\\n raise Exception('TracMacroConfig not setup properly - no config')\\n good_result = [ 'all', 'wellknown', 'extra', 'nothing' ]\\n if not result is None and not result in good_result:\\n raise ValueError(\\\"TracMacroConfig.options(result='%s') invalid;\\\"\\n \\\" use one of %s, or None.\\\" % (\\n result, ','.join([ \\\"%s\\\" % x for x in good_result ])))\\n self.results_list, options = parse_args(content, strict=False)\\n self._log('parse incoming %s' % options)\\n self._parse(options)\\n if result is None or result == 'nothing':\\n return None\\n results = {}\\n for key, ent in self.results.iteritems():\\n if result == 'all' or \\\\\\n (result == 'wellknown' and key in self.wanted) or \\\\\\n (result == 'extra' and not key in self.wanted):\\n results[key] = ent[0]\\n self._log('parse results %s' % results)\\n return results\",\n \"def ProcessOptions():\\n \\n MiscUtil.PrintInfo(\\\"Processing options...\\\")\\n \\n # Validate options...\\n ValidateOptions()\\n \\n OptionsInfo[\\\"CalcRMSD\\\"] = Options[\\\"--calcRMSD\\\"]\\n OptionsInfo[\\\"UseBestRMSD\\\"] = False\\n if re.match(\\\"^BestRMSD$\\\", OptionsInfo[\\\"CalcRMSD\\\"], re.I):\\n OptionsInfo[\\\"UseBestRMSD\\\"] = True\\n \\n OptionsInfo[\\\"MaxIters\\\"] = int(Options[\\\"--maxIters\\\"])\\n \\n OptionsInfo[\\\"Mode\\\"] = Options[\\\"--mode\\\"]\\n \\n OptionsInfo[\\\"RefFile\\\"] = Options[\\\"--reffile\\\"]\\n OptionsInfo[\\\"ProbeFile\\\"] = Options[\\\"--probefile\\\"]\\n\\n # No need for any RDKit specific --outfileParams....\\n OptionsInfo[\\\"InfileParams\\\"] = MiscUtil.ProcessOptionInfileParameters(\\\"--infileParams\\\", Options[\\\"--infileParams\\\"])\\n \\n OptionsInfo[\\\"Outfile\\\"] = Options[\\\"--outfile\\\"]\\n \\n OptionsInfo[\\\"Overwrite\\\"] = Options[\\\"--overwrite\\\"]\\n \\n OptionsInfo[\\\"OutDelim\\\"] = \\\" \\\"\\n if MiscUtil.CheckFileExt(OptionsInfo[\\\"Outfile\\\"], \\\"csv\\\"):\\n OptionsInfo[\\\"OutDelim\\\"] = \\\",\\\"\\n elif MiscUtil.CheckFileExt(OptionsInfo[\\\"Outfile\\\"], \\\"tsv txt\\\"):\\n OptionsInfo[\\\"OutDelim\\\"] = \\\"\\\\t\\\"\\n else:\\n MiscUtil.PrintError(\\\"The file name specified , %s, for option \\\\\\\"--outfile\\\\\\\" is not valid. Supported file formats: csv tsv txt\\\\n\\\" % (OptionsInfo[\\\"Outfile\\\"]))\",\n \"def parse_options(self):\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n \\\"-i\\\",\\n \\\"--input_csv\\\",\\n type=str,\\n help=\\\"Input CSV path(s)\\\",\\n required=True,\\n nargs=\\\"+\\\",\\n )\\n parser.add_argument(\\n \\\"-o\\\", \\\"--output_csv\\\", type=str, help=\\\"Output CSV path\\\", required=True\\n )\\n parser.add_argument(\\n \\\"-k\\\",\\n \\\"--kernel\\\",\\n type=str,\\n default=\\\"rbf\\\",\\n help='SVM kernel type (\\\"rbf\\\", \\\"linear\\\", \\\"poly\\\" or \\\"sigmoid\\\")',\\n )\\n parser.add_argument(\\n \\\"-c\\\", type=float, default=1.0, help=\\\"Penalty parameter C of the error term\\\"\\n )\\n parser.add_argument(\\n \\\"-g\\\",\\n \\\"--gamma\\\",\\n type=str,\\n default=\\\"auto\\\",\\n help=\\\"Gamma parameter of the SVM.\\\",\\n )\\n parser.add_argument(\\n \\\"-r\\\",\\n \\\"--mb_ram\\\",\\n type=float,\\n default=4000,\\n help=\\\"Available RAM in megabytes, for SVM calculation\\\",\\n )\\n parser.add_argument(\\n \\\"-f\\\",\\n \\\"--fdr_cutoff\\\",\\n type=float,\\n default=0.01,\\n help=\\\"Target PSMs with a lower FDR will be used as a \\\"\\n \\\"positive training set\\\",\\n )\\n parser.add_argument(\\n \\\"-x\\\",\\n \\\"--columns_as_features\\\",\\n type=str,\\n nargs=\\\"+\\\",\\n default=[\\n \\\"MS-GF:RawScore\\\",\\n \\\"MS-GF:DeNovoScore\\\",\\n \\\"MS-GF:SpecEValue\\\",\\n \\\"MS-GF:EValue\\\",\\n \\\"OMSSA:evalue\\\",\\n \\\"OMSSA:pvalue\\\",\\n \\\"X\\\\!Tandem:expect\\\",\\n \\\"X\\\\!Tandem:hyperscore\\\",\\n ],\\n help=\\\"Columns that should be used as a feature directly \\\"\\n \\\"(e.g. secondary scores). Will be converted to float\\\",\\n )\\n parser.add_argument(\\n \\\"-d\\\",\\n \\\"--dump_svm_matrix\\\",\\n type=str,\\n default=False,\\n help=\\\"Dump SVM matrix in PIN (Percolator input) format \\\"\\n \\\"to the specified path, mostly for debugging \\\"\\n \\\"and benchmarking.\\\",\\n )\\n\\n arg_dict = vars(parser.parse_args()) # convert to dict\\n self.update(arg_dict)\\n try:\\n self[\\\"gamma\\\"] = float(self[\\\"gamma\\\"])\\n except ValueError:\\n assert (\\n self[\\\"gamma\\\"] == \\\"auto\\\"\\n ), \\\"Invalid gamma param: \\\" '\\\"{0}\\\", using \\\"auto\\\" instead.'.format(\\n self[\\\"gamma\\\"]\\n )\",\n \"def get_options(self):\\n options = dict()\\n while True:\\n line = self.rfile.readline().decode(\\\"utf8\\\").strip()\\n if not line:\\n break\\n self.log.debug(\\\"Got line: %s\\\", line)\\n if \\\":\\\" not in line:\\n self.log.debug(\\\"Invalid option: %s\\\", line)\\n error_msg = \\\"header not in 'Name: value' format\\\"\\n raise oa.errors.InvalidOption(error_msg)\\n name, value = line.split(\\\":\\\", 1)\\n options[name.lower()] = value.strip()\\n return options\",\n \"def get_parse():\\n parser = argparse.ArgumentParser(description=print(mytext),\\n add_help=True,\\n formatter_class=argparse.RawTextHelpFormatter)\\n requiredNAMED = parser.add_argument_group('required arguments')\\n\\n requiredNAMED.add_argument(\\\"-i\\\", \\\"--input\\\",\\n required=True,\\n default=None,\\n dest=\\\"input\\\",\\n type=str,\\n help='''/path/to/VariantsToTable_output.txt\\nIt is assumed that there is either a 'locus' or 'unstitched_locus' column.\\nThe 'locus' column elements are the hyphen-separated\\nCHROM-POS. If the 'unstitched_chrom' column is present, the code will use the\\n'unstitched_locus' column for SNP names, otherwise 'CHROM' and 'locus'. The\\n'unstitched_locus' elements are therefore the hyphen-separated \\nunstitched_locus-unstitched_pos. FREQ columns from VarScan are also \\nassumed.\\n''')\\n requiredNAMED.add_argument(\\\"-o\\\",\\\"--outdir\\\",\\n required=True,\\n default=None,\\n dest=\\\"outdir\\\",\\n type=str,\\n help='''/path/to/cmh_test_output_dir/\\nFile output from cmh_test.py will be saved in the outdir, with the original\\nname of the input file, but with the suffix \\\"_CMH-test-results.txt\\\"''')\\n requiredNAMED.add_argument(\\\"--case\\\",\\n required=True,\\n default=None,\\n dest=\\\"case\\\",\\n type=str,\\n help='''The string present in every column for pools in \\\"case\\\" treatments.''')\\n requiredNAMED.add_argument(\\\"--control\\\",\\n required=True,\\n default=None,\\n dest=\\\"control\\\",\\n type=str,\\n help='''The string present in every column for pools in \\\"control\\\" treatments.''') \\n requiredNAMED.add_argument(\\\"-p\\\",\\\"--ploidy\\\",\\n required=True,\\n default=None,\\n dest=\\\"ploidyfile\\\",\\n type=str,\\n help='''/path/to/the/ploidy.pkl file output by the VarScan pipeline. This is a python\\ndictionary with key=pool_name, value=dict with key=pop, value=ploidy. The code\\nwill prompt for pool_name if necessary.''')\\n requiredNAMED.add_argument(\\\"-e\\\",\\\"--engines\\\",\\n required=True,\\n default=None,\\n dest=\\\"engines\\\",\\n type=int,\\n help=\\\"The number of ipcluster engines that will be launched.\\\")\\n parser.add_argument(\\\"--ipcluster-profile\\\",\\n required=False,\\n default='default',\\n dest=\\\"profile\\\",\\n type=str,\\n help=\\\"The ipcluster profile name with which to start engines. Default: 'default'\\\")\\n parser.add_argument('--keep-engines',\\n required=False,\\n action='store_true',\\n dest=\\\"keep_engines\\\",\\n help='''Boolean: true if used, false otherwise. If you want to keep\\nthe ipcluster engines alive, use this flag. Otherwise engines will be killed automatically.\\n(default: False)''')\\n\\n # check flags\\n args = parser.parse_args()\\n if not op.exists(args.outdir):\\n print(ColorText(f\\\"FAIL: the directory for the output file(s) does not exist.\\\").fail())\\n print(ColorText(f\\\"FAIL: please create this directory: %s\\\" % args.outdir).fail())\\n print(ColorText(\\\"exiting cmh_test.py\\\").fail())\\n exit()\\n\\n # make sure input and ploidyfile exist\\n nopath = []\\n for x in [args.input, args.ploidyfile]: # TODO: check for $HOME or other bash vars in path\\n if not op.exists(x):\\n nopath.append(x)\\n\\n # if input or ploidy file do not exist:\\n if len(nopath) > 0:\\n print(ColorText(\\\"FAIL: The following path(s) do not exist:\\\").fail())\\n for f in nopath:\\n print(ColorText(\\\"\\\\tFAIL: %s\\\" % f).fail())\\n print(ColorText('\\\\nexiting cmh_test.py').fail())\\n exit()\\n\\n print('args = ', args)\\n return args\",\n \"def getResult(f, opt, model_name):\\n tacc = []\\n vacc = []\\n opt.write('======= ' + model_name + ' =======\\\\n')\\n for l in f.readlines():\\n if l.startswith('#'):\\n opt.write(l[2:] + '\\\\n')\\n elif l.startswith('Epoch'):\\n continue\\n else:\\n data = l.split(' - ')\\n tacc.append(float(data[2].split(': ')[1]))\\n vacc.append(float(data[4].split(': ')[1]))\\n return np.array(tacc), np.array(vacc)\",\n \"def parse_command_line():\\n\\n parser=OptionParser(usage=\\\"%prog [options] \\\",\\n description=\\\" updates tracker\\\" )\\n parser.add_option(\\\"-c\\\", \\\"--candidate\\\", action=\\\"store\\\", type=\\\"string\\\",\\n dest=\\\"candidate\\\", default=\\\"\\\", help=\\\"candidate name\\\")\\n parser.add_option(\\\"-u\\\", \\\"--username\\\", action=\\\"store\\\", type=\\\"string\\\",\\n dest=\\\"username\\\", default=\\\"gzhou\\\",\\n help=\\\"username\\\")\\n parser.add_option(\\\"-p\\\",\\\"--password\\\", action=\\\"store\\\",\\n dest=\\\"password\\\", default=\\\"egghead\\\", help=\\\"password\\\")\\n parser.add_option(\\\"-i\\\",\\\"--input\\\", action=\\\"store\\\",\\n dest=\\\"input\\\", default=\\\"tracker_temp.txt\\\", help=\\\"Input file\\\") \\n parser.add_option(\\\"-l\\\",\\\"--upload\\\", action=\\\"store\\\",\\n dest=\\\"upload\\\", default=None, help=\\\"upload file\\\") \\n parser.add_option(\\\"-d\\\",\\\"--description\\\", action=\\\"store\\\",\\n dest=\\\"description\\\", default=None, help=\\\"descirption\\\") \\n (options, args)=parser.parse_args()\\n\\n return options, args\",\n \"def test_parsingValues(self):\\n argV = (\\\"--fooint 912 --foofloat -823.1 \\\"\\n \\\"--eggint 32 --eggfloat 21\\\").split()\\n self.usage.parseOptions(argV)\\n self.failUnlessEqual(self.usage.opts['fooint'], 912)\\n self.assert_(isinstance(self.usage.opts['fooint'], int))\\n self.failUnlessEqual(self.usage.opts['foofloat'], -823.1)\\n self.assert_(isinstance(self.usage.opts['foofloat'], float))\\n self.failUnlessEqual(self.usage.opts['eggint'], 32)\\n self.assert_(isinstance(self.usage.opts['eggint'], int))\\n self.failUnlessEqual(self.usage.opts['eggfloat'], 21.)\\n self.assert_(isinstance(self.usage.opts['eggfloat'], float))\",\n \"def parse_options(self, options):\\n pass\",\n \"def parse_lspci_vv_chk_error(output,raiseOnErrors = \\\"1\\\"):\\n \\n found_devSta = 0\\n \\n #sys.exit(1)\\n if re.search(\\\"DevSta\\\",output):\\n found_devSta = 1\\n \\n # remove DevStat after splitting it\\n l_a = output.split(\\\":\\\")\\n l_a1 = l_a[1].split()\\n for m in l_a1:\\n \\n # if ends with +, \\n if re.search(\\\"Err\\\",m):\\n if re.search(\\\".*\\\\+$\\\",m):\\n \\n print \\\"-\\\" * 8\\n \\n errorStr = \\\"Found + in lspci output for '%s' , line details '%s'\\\"%(m,output)\\n trace_error(errorStr)\\n if raiseOnErrors == \\\"1\\\":\\n raise ViriError(errorStr)\\n\\n return 2\\n \\n if found_devSta == 0:\\n raise ViriError(\\\"Did not find 'devSta' in the output %s\\\"%output)\\n\\n trace_info(\\\"No lspci correctable or uncorrectable issues seem to be present , output '%s'\\\"%output)\\n return 1\",\n \"def _build_parsed_values(self):\\n match = OptodeSettingsParticle.regex_compiled().match(self.raw_data)\\n\\n if not match:\\n raise SampleException(\\\"No regex match of parsed optode data: [%s]\\\" %\\n self.raw_data)\\n\\n try:\\n return self._get_multiline_values()\\n except ValueError as e:\\n raise SampleException(\\\"ValueError while decoding optode output: [%s]\\\" % e)\",\n \"def _parse(self):\\n with open(self.input) as f:\\n for line in f:\\n if not line.lstrip().startswith(\\\"#\\\"): # comment\\n stripped_line=line.split(\\\"#\\\")[0].strip()\\n \\n # Initialise an empty option dictionary with some good defaults\\n if \\\"[\\\" in stripped_line:\\n molname=stripped_line.split()[1]\\n self.options[molname]=self.empty_option_dict.copy() # dict1=dict2 does not copy!\\n self.options[molname][\\\"MolName\\\"]=molname\\n if \\\":\\\" in stripped_line: \\n # now process line by line\\n if \\\"{\\\" not in stripped_line:\\n key,value=[i.strip() for i in stripped_line.split(\\\":\\\")]\\n\\n if key not in self.options[molname].keys():\\n raise BaseException(\\\"Option \\\\\\\"{}\\\\\\\" not known, please check your input file\\\".format(key))\\n self.options[molname][key]=value \\n else:\\n # This is to define special lines that are given by a dictionary\\n key,value=stripped_line.split(\\\":\\\",1) # split on first occurence\\n if key==\\\"Addon\\\": # additional atoms to be added per molecule\\n addondict=self.empty_addon_dict.copy()\\n addondict_string = value.split(\\\"}\\\",-1)[0].split(\\\"{\\\",1)[1]\\n for pair in addondict_string.split(\\\",\\\"):\\n addonkey,addonvalue=[i.strip() for i in pair.split(\\\":\\\")]\\n if addonkey not in addondict.keys():\\n raise BaseException(\\\"Option \\\\\\\"{}\\\\\\\" in Addon section of molecule {} not known, please check your input file\\\".format(addonkey,molname))\\n addondict[addonkey]=addonvalue\\n value=addondict\\n # Since addon keyword can be used many times, this is a list\\n self.options[molname][key].append(value) \\n self._check()\",\n \"def main():\\n global options\\n parser = OptionParser(\\n usage = '%prog [OPTIONS] RESULTPATH',\\n version='%prog 0.99', #\\n description='Calculate results on acl2018 datasets',\\n epilog='Contact simon.clematide@uzh.ch'\\n )\\n parser.add_option('-l', '--logfile', dest='logfilename',\\n help='write log to FILE', metavar='FILE')\\n parser.add_option('-q', '--quiet',\\n action='store_true', dest='quiet', default=False,\\n help='do not print status messages to stderr')\\n parser.add_option('-d', '--debug',\\n action='store_true', dest='debug', default=False,\\n help='print debug information')\\n parser.add_option('-g', '--glob',\\n action='store', dest='glob', default='{RESULTPATH}/x*x/*/s*/*eval',\\n help='change file globbing for accessing evaluation results (%default)')\\n parser.add_option('-f', '--fold_filter',\\n action='store', dest='fold_filter', default=None,\\n help='only use folds matching (re.search) the specified regular expression on the fold name (e.g. \\\"^english\\\" for all folds starting with the string english) (Default \\\"%default\\\")')\\n parser.add_option('-D', '--decoder_filter',\\n action='store', dest='decoder_filter', default=\\\"greedy|beam4\\\",\\n help='''used on decoding mode label; matches (re.search) with the specified regular expression (Default \\\"%default\\\")''')\\n parser.add_option('-m', '--mode',\\n action='store', dest='mode', default='ms',\\n help='''compatibel characters can be combined\\n s: individual seed results;\\n S: only individual seed results;\\n m: mean/sd values (on seeds and folds);\\n M: mean/sd (on folds only);\\n e: include ensembles;\\n E: only ensembles;\\n T: only test results;\\n D: only dev results\\n q: sort the results by accuracy\\n L: evaluate on edit distance, not on Accuracy\\n ''')\\n\\n (options, args) = parser.parse_args()\\n if options.debug:\\n print(\\\"options=\\\",options,file=sys.stderr)\\n\\n if len(args) < 1:\\n print('# RESULTPATH needed')\\n parser.print_help()\\n exit(1)\\n options.mode = set(options.mode)\\n process(options=options,args=args)\",\n \"def processArgs(self, argv):\\n parser = OptionParser(usage=usage)\\n parser.add_option(\\\"-a\\\", \\\"--show_ADT\\\", action=\\\"store_true\\\", dest=\\\"show_ADT\\\",\\n default=self.show_ADT, help=\\\"Display ADT value if set\\\")\\n parser.add_option(\\\"-f\\\", \\\"--show_file\\\", action=\\\"store_true\\\", dest=\\\"show_file\\\",\\n default=self.show_file, help=\\\"Display matching filename if set\\\")\\n parser.add_option(\\\"-t\\\", \\\"--show_time\\\", action=\\\"store_true\\\", dest=\\\"show_time\\\",\\n default=self.show_time, help=\\\"Display message time\\\")\\n parser.add_option(\\\"-v\\\", \\\"--show_visitID\\\", action=\\\"store_true\\\", dest=\\\"show_visitID\\\",\\n default=self.show_visitID, help=\\\"Display visit ID\\\")\\n parser.add_option(\\\"-p\\\", \\\"--show_pc\\\",\\n action=\\\"store_true\\\",\\n dest=\\\"show_pc\\\",\\n default=self.show_pc,\\n help=\\\"Display patient class\\\")\\n\\n (options, pargs) = parser.parse_args()\\n if len(pargs) < 3:\\n parser.error(\\\"incorrect number of arguments\\\")\\n\\n self.show_ADT = parser.values.show_ADT\\n self.show_file = parser.values.show_file\\n self.show_time = parser.values.show_time\\n self.show_visitID = parser.values.show_visitID\\n self.show_pc = parser.values.show_pc\\n \\n self.segments_of_interest = pargs.pop(0)\\n if len(self.segments_of_interest) != 3:\\n parser.error(\\\"segment '%s' looks incorrect, expected something like 'PV1'\\\"\\n % self.segments_of_interest)\\n\\n try:\\n nums = pargs.pop(0).split(\\\",\\\")\\n for num in nums:\\n if 'MSH' == self.segments_of_interest:\\n num = int(num) - 1\\n self.sequences.append(int(num))\\n except:\\n parser.error(\\\"sequence must be an integer, separate multiple w/ comma and no spaces\\\")\\n\\n for patternOrFile in pargs:\\n for file in glob.glob(patternOrFile):\\n if not os.path.isfile(file):\\n parser.error(\\\"can't open input file %s\\\" % file)\\n self.filelist.append(file)\\n \\n # Require at least one file\\n if not len(self.filelist):\\n parser.error(\\\"at least one input file is required\\\")\",\n \"def _parse_output_status_details(lines):\\n details = list()\\n detail_indicator = re.compile(\\\"^--\\\")\\n for line in lines:\\n line = line.rstrip()\\n if re.match(detail_indicator, line):\\n details.append(line)\\n else:\\n break\\n return details\",\n \"def _parse_vn(lines, out_format):\\n number = 0\\n lines_out = []\\n loa = lines_out.append\\n for line in lines:\\n coordinates = split_line(line)\\n if len(coordinates) == 3:\\n number += 1\\n loa(out_format % (-float(coordinates[0]),\\n float(coordinates[1]),\\n float(coordinates[2])))\\n return number, lines_out\",\n \"def parseResults(result):\\n # Split the results based on newline characters\\n results_cut = result.text.split('\\\\n')[12:-49]\\n # Initialize lists of the values to be parsed from results_cut \\n visit_id = []\\n name = []\\n ra_hour = []\\n ra_min = []\\n ra_sec = []\\n dec_deg = []\\n dec_min = []\\n dec_sec = []\\n v_mag = []\\n ra_motion = []\\n dec_motion = []\\n # Iterate through results_cut and append them to the respective lists\\n for line in results_cut:\\n visit_id.append(int(line[6:12]))\\n name.append(line[12:36])\\n ra_hour.append(int(line[38:40]))\\n ra_min.append(int(line[41:43]))\\n ra_sec.append(float(line[44:48]))\\n dec_deg.append(int(line[49:52]))\\n dec_min.append(int(line[53:55]))\\n dec_sec.append(int(line[56:58]))\\n try:\\n v_mag.append(float(line[60:64]))\\n except ValueError:\\n # If there is no reported v_mag for the object, return -99\\n v_mag.append(-99.0)\\n ra_motion.append('%s%i' % (line[84], int(line[82:84])))\\n dec_motion.append('%s%i' % (line[91], int(line[89:91])))\\n # Initialize the pandas dataframe to be returned\\n results_df = pd.DataFrame(np.array([visit_id, name, ra_hour, ra_min, ra_sec, \\n dec_deg, dec_min, dec_sec, v_mag, \\n ra_motion, dec_motion]).T, \\n columns=['visit_id', 'name', 'ra_hour', 'ra_min', 'ra_sec', \\n 'dec_deg', 'dec_min', 'dec_sec', 'v_mag', \\n 'ra_motion', 'dec_motion'])\\n # Add the lists to the dataframe\\n results_df['visit_id'] = pd.to_numeric(results_df['visit_id'])\\n results_df['ra_hour'] = pd.to_numeric(results_df['ra_hour'])\\n results_df['ra_min'] = pd.to_numeric(results_df['ra_min'])\\n results_df['ra_sec'] = pd.to_numeric(results_df['ra_sec'])\\n results_df['dec_deg'] = pd.to_numeric(results_df['dec_deg'])\\n results_df['dec_min'] = pd.to_numeric(results_df['dec_min'])\\n results_df['dec_sec'] = pd.to_numeric(results_df['dec_sec'])\\n results_df['v_mag'] = pd.to_numeric(results_df['v_mag'])\\n results_df['ra_motion'] = pd.to_numeric(results_df['ra_motion'])\\n results_df['dec_motion'] = pd.to_numeric(results_df['dec_motion'])\\n \\n return results_df\",\n \"def _parse_options(self, cmd_line_args):\\n args = self._create_parser().parse_args(cmd_line_args)\\n\\n if args.verbose and not args.debug:\\n logging.basicConfig(level=logging.INFO)\\n\\n if args.debug:\\n logging.basicConfig(level=logging.DEBUG)\",\n \"def vultr_cli(parser):\\n return parser\",\n \"def get_options():\\n \\n parser = argparse.ArgumentParser(description=\\\"Filter VCFs for inherited\\\"\\n \\\"variants in trios.\\\")\\n \\n # the --ped and --child options are mutually exclusive\\n group = parser.add_mutually_exclusive_group(required=True)\\n group.add_argument(\\\"--ped\\\",\\n help=\\\"Path to ped file containing cohort details for multiple trios.\\\")\\n group.add_argument(\\\"--child\\\", help=\\\"Path to child's VCF file.\\\")\\n \\n parser.add_argument(\\\"--mother\\\", help=\\\"Path to mother's VCF file.\\\")\\n parser.add_argument(\\\"--father\\\", help=\\\"Path to father's VCF file.\\\")\\n parser.add_argument(\\\"--gender\\\", help=\\\"The child's gender (male or female).\\\")\\n parser.add_argument(\\\"--mom-aff\\\",\\n help=\\\"Mother's affected status (1=unaffected, or 2=affected).\\\")\\n parser.add_argument(\\\"--dad-aff\\\",\\n help=\\\"Father's affected status (1=unaffected, or 2=affected).\\\")\\n \\n parser.add_argument(\\\"--syndrome-regions\\\", dest=\\\"regions\\\",\\n help=\\\"Path to list of CNV regions known to occur in disorders.\\\")\\n parser.add_argument(\\\"--known-genes\\\",\\n help=\\\"Path to table of known disease causative genes.\\\")\\n parser.add_argument(\\\"--known-genes-date\\\", dest=\\\"genes_date\\\",\\n help=\\\"Date that the list of known disease causative genes was last\\\"\\n \\\"updated, used to track the version of known-genes used for\\\"\\n \\\"analysis.\\\")\\n parser.add_argument(\\\"-o\\\", \\\"--output\\\",\\n help=\\\"Path for analysis output in tabular format.\\\")\\n parser.add_argument(\\\"--export-vcf\\\",\\n help=\\\"Directory or file path for analysis output in VCF format.\\\")\\n parser.add_argument(\\\"--log\\\", dest=\\\"loglevel\\\", default=\\\"debug\\\",\\n help=\\\"Level of logging to use, choose from: debug, info, warning,\\\"\\n \\\"error or critical.\\\")\\n parser.add_argument(\\\"--debug-chrom\\\",\\n help=\\\"chromosome of variant for which to debug the filtering behaviour.\\\")\\n parser.add_argument(\\\"--debug-pos\\\", type=int,\\n help=\\\"position of variant for which to debug the filtering behaviour.\\\")\\n parser.add_argument(\\\"--lof-sites\\\",\\n help=\\\"path to file of sites at the last base of exons that are \\\"\\n \\\"potentially LoF sites.\\\")\\n \\n # New argument added by PJ to allow DNM_PP filtering to be disabled.\\n parser.add_argument(\\\"--pp-dnm-threshold\\\", dest=\\\"pp_filter\\\", type=float,\\n default=0.0,\\n help=\\\"Set PP_DNM threshold for filtering (defaults to >=0.9)\\\")\\n parser.add_argument(\\\"--maf-populations\\\",\\n default=\\\"AFR_AF,AMR_AF,ASN_AF,DDD_AF,EAS_AF,ESP_AF,EUR_AF,MAX_AF,\\\"\\n \\\"SAS_AF,UK10K_cohort_AF\\\",\\n help=\\\"Comma separated list of population tags that can exist in the \\\"\\n \\\"INFO field for population-specific minor allele frequencies\\\")\\n\\n #new argument added by re3 to require a file of sums of log2 ratio on X chromosome for CNV filtering\\n parser.add_argument(\\\"--sum_x_lr2_file\\\", help=\\\"Path to file containing the sum of lr2 on x chromosome for each sample\\\")\\n \\n args = parser.parse_args()\\n \\n if args.pp_filter < 0.0 or args.pp_filter > 1:\\n parser.error(\\\"--pp-dnm-threshold must be between 0 and 1\\\")\\n \\n if args.child is not None:\\n if args.father is not None and args.dad_aff is None:\\n parser.error(\\\"--dad-aff must also be used if --father is used\\\")\\n if args.mother is not None and args.mom_aff is None:\\n parser.error(\\\"--mom-aff must also be used if --mother is used\\\")\\n\\n if args.sum_x_lr2_file is None:\\n parser.error(\\\"--sum_x_lr2_file must be used\\\")\\n\\n args.populations = args.maf_populations.split(',')\\n \\n return args\",\n \"def print_options(val, cur_matches):\\n print val\\n\\n #skip one to print none at end\\n for i,v in enumerate(cur_matches[1:]):\\n print \\\"[%i] %s : %s \\\"%(i+1, v[0], v[1])\\n print \\\"[%i] %s : %s \\\" % (0, cur_matches[0][0], cur_matches[0][1])\\n\\n print \\n print 'Choice?'\",\n \"def parse_cmdline(cmdline_args):\\n option_parser = optparse.OptionParser(usage='usage: %prog [options] <pattern>',\\n description='ts short for TextSearch, Grep like tool', prog='ts', add_help_option=False) # -h is a real option\\n\\n option_parser.add_option('-h', '--help', action='store_true', dest='help', help='Display this information')\\n option_parser.add_option('-e', '--extension', action='store', dest='extension', type='string', default=None,\\n help='file extension')\\n\\n group_searching = optparse.OptionGroup(option_parser, 'Regexp selection and interpretation')\\n group_searching.add_option('-i', '--ignore-case', action='store_true', dest='ignore_case', default=False,\\n help='Ignore case distinctions in the pattern')\\n group_searching.add_option('-w', '--word-regexp', action='store_true', dest='word_regexp', default=False,\\n help='Force the pattern to match only whole words')\\n group_searching.add_option('-l', '--literal', action='store_true', dest='literal', default=False,\\n help='Quote all metacharacters; the pattern is literal')\\n option_parser.add_option_group(group_searching)\\n\\n group_miscellaneous = optparse.OptionGroup(option_parser, 'Miscellaneous')\\n group_miscellaneous.add_option('--path-only', action='store_true', dest='path_only', default=False,\\n help='only print out the matching file')\\n group_miscellaneous.add_option('-v', '--invert-match', action='store_true', dest='invert_match', default=False,\\n help='Invert the sense of matching, to select non-matching lines.')\\n option_parser.add_option_group(group_miscellaneous)\\n\\n group_output = optparse.OptionGroup(option_parser, 'Output control')\\n group_output.add_option('-c', '--count', action='store_true', dest='count', default=False,\\n help='Suppress normal output; instead print a count of matching lines for each input file.')\\n group_output.add_option('-o', '--only-matching', action='store_true', dest='only_matching', default=False,\\n help='Print only the matched (non-empty) parts of a matching line, with each such part on '\\n 'a separate output line.')\\n option_parser.add_option_group(group_output)\\n\\n options, args = option_parser.parse_args(cmdline_args)\\n return options, args, option_parser\",\n \"def parse_options():\\n options ={ \\\"vcf\\\":None, \\\"out\\\":None, \\\"ref\\\":None, \\\"haplotypes\\\":False, \\\"sample\\\":None, \\\"chrom\\\":None, \\\"refcheck\\\" :True }\\n\\t\\n try:\\n opts, args = getopt.getopt(sys.argv[1:], \\\"v:o:r:s:c:h\\\", [\\\"vcf\\\", \\\"out\\\", \\\"ref\\\", \\\"sample\\\", \\\"chrom\\\", \\\"haplotypes\\\"])\\n print opts, args\\n except Exception as err:\\n print str(err)\\n sys.exit()\\n\\n for o, a in opts:\\n print o,a\\n if o in [\\\"-v\\\",\\\"--vcf\\\"]: options[\\\"vcf\\\"] = a\\n if o in [\\\"-r\\\",\\\"--ref\\\"]: options[\\\"ref\\\"] = a\\n if o in [\\\"-s\\\",\\\"--sample\\\"]: options[\\\"sample\\\"] = a\\n if o in [\\\"-c\\\",\\\"--chrom\\\"]: options[\\\"chrom\\\"] = a\\n if o in [\\\"-h\\\",\\\"--haplotypes\\\"]: options[\\\"haplotypes\\\"] = True\\n elif o in [\\\"-o\\\",\\\"--out\\\"]: options[\\\"out\\\"] = a\\n \\n if not options[\\\"haplotypes\\\"]:\\n raise Exception(\\\"Only implemented for haplotype option (-h)\\\")\\n \\n print \\\"found options:\\\"\\n print options\\n return options\",\n \"def _parse_command_line_arguments():\\n global config\\n # Get command line args for vispy\\n argnames = ['vispy-backend=', 'vispy-gl-debug', 'vispy-glir-file=',\\n 'vispy-log=', 'vispy-help', 'vispy-profile=', 'vispy-cprofile',\\n 'vispy-dpi=', 'vispy-audit-tests']\\n try:\\n opts, args = getopt.getopt(sys.argv[1:], '', argnames)\\n except getopt.GetoptError:\\n opts = []\\n # Use them to set the config values\\n for o, a in opts:\\n if o.startswith('--vispy'):\\n if o == '--vispy-backend':\\n config['default_backend'] = a\\n logger.info('vispy backend: %s', a)\\n elif o == '--vispy-gl-debug':\\n config['gl_debug'] = True\\n elif o == '--vispy-glir-file':\\n config['glir_file'] = a\\n elif o == '--vispy-log':\\n if ',' in a:\\n verbose, match = a.split(',')\\n else:\\n verbose = a\\n match = None\\n config['logging_level'] = a\\n set_log_level(verbose, match)\\n elif o == '--vispy-profile':\\n config['profile'] = a\\n elif o == '--vispy-cprofile':\\n _enable_profiling()\\n elif o == '--vispy-help':\\n print(VISPY_HELP)\\n elif o == '--vispy-dpi':\\n config['dpi'] = int(a)\\n elif o == '--vispy-audit-tests':\\n config['audit_tests'] = True\\n else:\\n logger.warning(\\\"Unsupported vispy flag: %s\\\" % o)\",\n \"def parseArgs( argv ):\\r\\n\\r\\n parser = OptionParser()\\r\\n parser.add_option(\\\"-o\\\", \\\"--order\\\", type=\\\"choice\\\", action=\\\"store\\\", choices=[\\\"p\\\",\\\"h\\\",\\\"g\\\",\\\"c\\\"], default=\\\"p\\\", dest=\\\"orderType\\\",\\r\\n help=\\\"specify a display sorted by (p)lugin, (c)ve id, (h)ost, or just (g)enerate a hostfile\\\")\\r\\n parser.add_option(\\\"-f\\\", \\\"--odf\\\", type=\\\"string\\\", action=\\\"store\\\", dest=\\\"odfOutputFilename\\\",\\r\\n help=\\\"output to this file in ODF format\\\", default=\\\"\\\")\\r\\n parser.add_option(\\\"-p\\\", \\\"--portlist\\\", type=\\\"string\\\", action=\\\"store\\\", dest=\\\"portList\\\",\\r\\n help=\\\"specify specific ports to show\\\")\\r\\n parser.add_option(\\\"-r\\\", \\\"--riskfactors\\\", type=\\\"string\\\", action=\\\"store\\\", dest=\\\"riskFactorsList\\\", default=\\\"critical,high,moderate,medium,low,none\\\",\\r\\n help=\\\"specify list of allowable risk factors (default is any of critical,high,moderate,medium,low,none\\\")\\r\\n parser.add_option(\\\"-t\\\", \\\"--hostlist\\\", type=\\\"string\\\", action=\\\"store\\\", dest=\\\"hostList\\\",\\r\\n help=\\\"specify specific hosts to show\\\")\\r\\n parser.add_option(\\\"-s\\\", \\\"--severities\\\", type=\\\"string\\\", action=\\\"store\\\", dest=\\\"severityList\\\", default=\\\"critical_hole,hole,warn,note,info,openport\\\",\\r\\n help=\\\"specify specific list of severity codes to show (default is any of critical_hole,hole,warn,note,info,openport\\\")\\r\\n parser.add_option(\\\"-q\\\", \\\"--query\\\", type=\\\"string\\\", action=\\\"store\\\", dest=\\\"contentQuery\\\",\\r\\n help=\\\"show all results whose synopses match this regular expression\\\")\\r\\n parser.add_option(\\\"-i\\\", \\\"--idlist\\\", type=\\\"string\\\", action=\\\"store\\\", dest=\\\"pluginIDList\\\",\\r\\n help=\\\"display only results that match these Nessus plugin IDs\\\")\\r\\n parser.add_option(\\\"-c\\\", \\\"--csv\\\", type=\\\"string\\\", action=\\\"store\\\", dest=\\\"csvOutputFilename\\\", default=\\\"\\\",\\r\\n help='output CSV-friendly text delimitted by default or overriden delimiter to a given filename (use \\\"0\\\" for standard output)')\\r\\n# parser.add_option(\\\"-c\\\", \\\"--csv\\\", action=\\\"store_true\\\", dest=\\\"CSV\\\", default=False,\\r\\n# help=\\\"output CSV-friendly text delimitted by |++| (overridable with the 'd' option)\\\")\\r\\n parser.add_option(\\\"-d\\\", \\\"--delimiter\\\", type=\\\"string\\\", action=\\\"store\\\", dest=\\\"delimiter\\\", default=\\\"|++|\\\", \\r\\n help=\\\"override CSV delimiter default of |++|\\\")\\r\\n\\r\\n (options, args) = parser.parse_args() \\r\\n \\r\\n if options.orderType: options.orderType = options.orderType.lower()\\r\\n\\r\\n return (options,args)\",\n \"def parse_cli_output(self, output, operation, name, index):\\n state = None\\n regex = None\\n error = self.__cli_connection_error(output)\\n if(not error):\\n if index is not None:\\n regex = re.search( r'RuntimeCmd:\\\\s*(' + re.escape(name) + r'\\\\[' + index + r'\\\\])=\\\\s*(\\\\d+)', output, re.M|re.I)\\n else:\\n regex = re.search( r'RuntimeCmd:\\\\s*(' + re.escape(name) + r')=\\\\s*([\\\\d+,\\\\s]+)', output, re.M|re.I)\\n\\n if regex:\\n state = regex.group(2)\\n else:\\n # regex = re.search( r'RuntimeCmd:(\\\\sError:\\\\s|\\\\s)(.*)\\\\((.*)\\\\)\\\\n', output, re.M|re.I)\\n regex = re.search( r'RuntimeCmd:(\\\\sError:\\\\s|\\\\s)(.*)\\\\n', output, re.M|re.I)\\n if regex:\\n # self.logger.error(\\\"CLI Error: %s - %s\\\", regex.group(2), regex.group(3))\\n self.logger.error(\\\"CLI Error [%s %s]: %s\\\", operation, name, regex.group(2))\\n return state\",\n \"def command(self):\\n with open(self.x, 'rt') as fi:\\n line = next(fi) # the first line\\n\\n version, cmd_line = line.strip().split(';')\\n version = version.split(' ')[2]\\n cmd_line = re.sub('\\\"', '', cmd_line.strip())\\n\\n return [version, cmd_line]\",\n \"def run(self, desired_result, input, limit):\\n cfg = desired_result.configuration.data\\n\\n opt_seq = ''\\n\\n for flag in OPT_FLAGS:\\n if cfg[flag] == 'on':\\n opt_seq += ' {0}'.format(flag)\\n\\n tmp_dir = \\\"./tmp\\\" \\n compd_opt_cmd = 'opt -S {0} mcsema/test.proposed.inline.ll -o {1}/test.proposed.opt.ll'.format(\\n opt_seq, tmp_dir)\\n compd_opt_result = self.call_program(compd_opt_cmd)\\n if compd_opt_result['returncode'] != 0:\\n print(compd_opt_result)\\n assert 0\\n\\n mcsema_opt_cmd = 'opt -S {0} ../binary/test.mcsema.inline.ll -o {1}/test.mcsema.opt.ll'.format(\\n opt_seq, tmp_dir)\\n mcsema_opt_result = self.call_program(mcsema_opt_cmd)\\n if mcsema_opt_result['returncode'] != 0:\\n print(mcsema_opt_result)\\n assert 0\\n\\n matcher = args.matcher\\n if(matcher == ''):\\n matcher = home + '/Github//validating-binary-decompilation/source/build/bin//matcher'\\n\\n matcher_run_cmd = '{0} --file1 {1}/test.mcsema.opt.ll:{2} --file2 {1}/test.proposed.opt.ll:{2} --potential-match-accuracy'.format(\\n matcher, tmp_dir, args.func)\\n\\n matcher_run_result = self.call_program(matcher_run_cmd)\\n if matcher_run_result['returncode'] != 0:\\n print(matcher_run_result)\\n assert 0\\n\\n matcher_stderr = matcher_run_result['stderr']\\n z = re.findall(\\n r\\\"^Accuracy:(\\\\d+\\\\.[\\\\deE+-]+)\\\",\\n matcher_stderr,\\n re.MULTILINE)\\n cost = 1 - float(z[0])\\n\\n log.debug('[Run] Cost:{0} [{1}]'.format(cost, opt_seq))\\n\\n # Early exit\\n outfile = args.outdir + '/' + 'normalizer_final_config.json'\\n if cost == 0:\\n log.info(\\n \\\"run: Early Exit: Optimal pass sequence written to {0}: [{1}]\\\".format(\\n outfile, opt_seq))\\n with open(outfile, 'a') as fd:\\n fd.write('{0}\\\\n'.format(opt_seq))\\n\\n return Result(time=cost)\",\n \"def parse_akmaxsat_output(out):\\n for line in out.splitlines():\\n temp = str(line.decode())\\n if temp.startswith('v'):\\n GS = sorted([int(x) for x in temp[2:].split()], key=abs)\\n return np.argwhere(np.array(GS)>0).flatten()\",\n \"def visit_option_argument(self, node):\\n self.body.append(node.get('delimiter', ' '))\",\n \"def visit_option_argument(self, node):\\n self.body.append(node.get('delimiter', ' '))\",\n \"def readOpt(self, String0):\\n Name = re.match(r\\\"NAME : (.*)\\\", String0)[1]\\n COMMENT = re.search(r\\\"COMMENT : (.*)\\\", String0)[1]\\n TYPE = re.search(r\\\"TYPE : (.*)\\\", String0)[1]\\n DIMENSION = re.search(r\\\"DIMENSION : (.*)\\\", String0)[1]\\n split = String0.split(\\\"\\\\n\\\")\\n Tour = []\\n for s0 in split:\\n if (s0 and s0[0] <= '9' and s0[0] >= '0'):\\n Tour.append(int(s0))\\n return Name, COMMENT, TYPE, DIMENSION, Tour\",\n \"def get_args():\\n\\n # Make argparse object, add description\\n parser = argparse.ArgumentParser(\\n formatter_class=argparse.RawTextHelpFormatter,\\n description=textwrap.dedent(\\n '''\\n summary:\\n Takes a VCF file and parses the variants to produce a tab delimited \\n variant report.\\n '''\\n ))\\n\\n\\n # Version info\\n parser.add_argument(\\n '-v', '--version', action='version', \\n version=\\n '%(prog)s\\\\nversion:\\\\t{}\\\\nlast updated:\\\\t{}'.format(\\n __version__, __updated__\\n ))\\n\\n\\n # Arguments (see help string for full descriptions):\\n # REQUIRED: VCF file input\\n parser.add_argument(\\n 'input', action='store', \\n help='Filepath to input VCF file. REQUIRED.'\\n )\\n\\n\\n # OPTIONAL: Output folder, defaults to current directory if empty\\n parser.add_argument(\\n '-O', '--output', action='store', \\n help=textwrap.dedent(\\n '''\\n Filepath to folder where output reports will be saved. \\n If missing, defaults to current directory.\\n \\\\n'''\\n ))\\n\\n\\n # OPTIONAL: List of preferred transcripts\\n parser.add_argument(\\n '-t', '--transcripts', action='store', \\n help=textwrap.dedent(\\n '''\\n Filepath to preferred transcripts file. \\n\\n Must be a tab seperated file with preferred transcripts in the second \\n column. If missing, all entries in the preferred transcript column \\n will be labelled as 'Unknown'.\\n \\\\n'''\\n ))\\n\\n\\n # OPTIONAL: Preferred transcripts strictness\\n parser.add_argument(\\n '-T', '--transcript_strictness', action='store', default='low', \\n help=textwrap.dedent(\\n '''\\n Strictness of matching while annotating preferred transcripts.\\n Default setting is low.\\n\\n Options: \\n\\n high - Transcripts must be an exact match. \\n e.g. NM_001007553.2 and NM_001007553.1 won't match,\\n NM_001007553.1 and NM_001007553.1 will.\\n\\n low - Transcripts will match regardless of the version number. The \\n version number is after the . at the end of a transcript \\n e.g. NM_001007553.2 and NM_001007553.1 will match.\\n \\\\n'''\\n ))\\n\\n\\n # OPTIONAL: either a single BED file or a folder containing BED \\n # files, only one of these can be used\\n bed_files = parser.add_mutually_exclusive_group()\\n\\n # Single BED file\\n bed_files.add_argument(\\n '-b', '--bed', action='store', \\n help=textwrap.dedent(\\n '''\\n Filepath to a single BED file. \\n\\n The BED file will be applied to the variant report and a seperate\\n report saved with the BED file applied. This report will be saved in \\n the same output folder as the original variant report, with the BED \\n file name added to it.\\n Cannot be used together with -B flag.\\n \\\\n'''\\n ))\\n\\n # Multiple BED files\\n bed_files.add_argument(\\n '-B', '--bed_folder', action='store', \\n help=textwrap.dedent(\\n '''\\n Filepath to folder containing BED files. \\n\\n Each BED file will be applied to the variant report and a seperate\\n report saved with the BED file applied. These reports will be saved in\\n a new folder within the output folder, named the same as the input BED\\n folder. \\n The file names will be the same as the original variant report, with \\n the BED file name added to them.\\n Cannot be used together with -b flag.\\n \\\\n'''\\n ))\\n\\n\\n # OPTIONAL: File containing known variants\\n parser.add_argument(\\n '-k', '--known_variants', action='store', \\n help=textwrap.dedent(\\n '''\\n Filepath to known variants file. \\n\\n This is a VCF file containing any known variants and an associated \\n classification. The classification will be added to the variant \\n report. The VCF must have an annotation named 'Classification' within \\n the INFO field for each variant.\\n\\n Key:\\n 0 - Artifact\\n 1 - Benign\\n 2 - Likely benign\\n 3 - VUS\\n 4 - Likely pathogenic\\n 5 - Pathogenic\\n \\\\n'''\\n ))\\n\\n\\n # OPTIONAL: File containing the headers for the report\\n parser.add_argument(\\n '-c', '--config', action='store', \\n help=textwrap.dedent(\\n '''\\n Filepath to config file. \\n\\n This is a tab seperated text file containing a number of rows, where \\n each row specifies an annotation to be included in the variant report.\\n Only annotations included in the config file will be included in the\\n variant report.\\n The columns in the variant report will be in the same order as the \\n order in which the annotations appear in the config file.\\n\\n Each row contains:\\n\\n Column 1 - Required. Annotation headers, these must match up with how\\n they appear in the VCF (case sensitive).\\n\\n Column 2 - Required. Location where to find the data within the VCF, \\n used to select the correct parsing function.\\n options: info, format, vep, filter or pref.\\n\\n Column 3 - Optional. Alternative name for column header.\\n\\n To make a config file with all available options from a VCF, run:\\n vcf_parse -l path_to_input_vcf > config.txt\\n \\\\n'''\\n ))\\n\\n\\n # OPTIONAL: Lists all headers in a vcf then exits\\n parser.add_argument(\\n '-l', '--config_list', action='store_true', \\n help=textwrap.dedent(\\n '''\\n Return a list of all availabile config to the screen, then exit.\\n See CONFIG section for usage.\\n \\\\n'''\\n ))\\n\\n\\n # OPTIONAL: Filter out any variants where FILTER column is not PASS\\n parser.add_argument(\\n '-F', '--filter_non_pass', action='store_true', \\n help=textwrap.dedent(\\n '''\\n Filters out any variants where the FILTER annotation is not \\n PASS. If missing then there will be no fitering based on the\\n FILTER annotation.\\n \\\\n'''\\n ))\\n\\n return parser.parse_args()\",\n \"def format_options_as_lines(options):\\r\\n option_lines = []\\r\\n option_fields = str(options).split(\\\",\\\")\\r\\n\\r\\n for field in option_fields:\\r\\n option_lines.append(str(field).strip(\\\"{\\\").strip(\\\"}\\\"))\\r\\n\\r\\n return option_lines\",\n \"def _process_command_line():\\n # pylint: disable=C0103\\n global parameters\\n # pylint: enable=C0103\\n\\n # option letters followed by : expect an argument\\n # same for option strings followed by =\\n character_options = \\\"qV?\\\"\\n string_options = [\\n \\\"debug\\\",\\n \\\"help\\\",\\n \\\"version\\\",\\n ]\\n\\n try:\\n options, remaining_arguments = getopt.getopt(\\n sys.argv[1:], character_options, string_options\\n )\\n except getopt.GetoptError as error:\\n logging.critical(\\\"Syntax error: %s\\\", error)\\n _display_help()\\n sys.exit(1)\\n\\n for option, _ in options:\\n\\n if option == \\\"--debug\\\":\\n logging.disable(logging.NOTSET)\\n\\n elif option in (\\\"--help\\\", \\\"-?\\\"):\\n _display_help()\\n sys.exit(0)\\n\\n elif option == \\\"-q\\\":\\n parameters[\\\"Quiet mode\\\"] = True\\n\\n elif option == \\\"-V\\\":\\n if parameters[\\\"Command flavour\\\"] in (\\\"gnu\\\", \\\"gnu:linux\\\", \\\"linux\\\"):\\n print(ID.replace(\\\"@(\\\" + \\\"#)\\\" + \\\" $\\\" + \\\"Id\\\" + \\\": \\\", \\\"\\\").replace(\\\" $\\\", \\\"\\\"))\\n sys.exit(0)\\n\\n elif option == \\\"--version\\\":\\n print(ID.replace(\\\"@(\\\" + \\\"#)\\\" + \\\" $\\\" + \\\"Id\\\" + \\\": \\\", \\\"\\\").replace(\\\" $\\\", \\\"\\\"))\\n sys.exit(0)\\n\\n logging.debug(\\\"_process_command_line(): parameters:\\\")\\n logging.debug(parameters)\\n logging.debug(\\\"_process_command_line(): remaining_arguments:\\\")\\n logging.debug(remaining_arguments)\\n\\n return remaining_arguments\",\n \"def parse_options(options, return_list=True):\\n\\n cmd_options = []\\n\\n for key, value in options.items():\\n\\n if value is not None:\\n txt = f\\\"--{key} {value}\\\"\\n else:\\n txt = f\\\"--{key}\\\"\\n\\n cmd_options.append(txt)\\n\\n if return_list:\\n return cmd_options\\n\\n cmd_options = \\\" \\\".join(cmd_options)\\n\\n return cmd_options\",\n \"def load_file_lines(option_value):\\n if not hasattr(option_value, 'read'):\\n raise IncompetentDeveloperError(\\\"Input type must be a file object.\\\")\\n \\n return [line.strip() for line in option_value]\",\n \"def _libsvm_parse_line(libsvm_line):\\n tokens = libsvm_line.split()\\n qid = int(tokens[1].split(\\\":\\\")[1])\\n\\n features = {_LABEL_FEATURE: float(tokens[0])}\\n key_values = [key_value.split(\\\":\\\") for key_value in tokens[2:]]\\n features.update({key: float(value) for (key, value) in key_values})\\n\\n return qid, features\",\n \"def __processOutputLine(self, line):\\n if (\\n line.startswith(\\\"--- \\\") or\\n line.startswith(\\\"+++ \\\")\\n ):\\n self.__processFileLine(line)\\n \\n self.__output.append(line)\",\n \"def parseshowvlancommand(message):\\n\\n vlanparsed = _begin_parse(message)\\n vlanschema = parse_get_nsmap(vlanparsed)\\n vlans = parse_xml_heirarchy('ROW_mtuinfo', ['vlanshowinfo-vlanid', 'vlanshowinfo-vlanmode'], vlanschema,\\n vlanparsed)\\n\\n elements = parse_xml_heirarchy('ROW_vlanbrief',\\n ['vlanshowbr-vlanname', 'vlanshowbr-vlanstate', 'vlanshowbr-shutstate',\\n 'vlanshowplist-ifidx'], vlanschema, vlanparsed)\\n for d in elements:\\n if 'vlanshowplist-ifidx' in d:\\n d['vlanshowplist-ifidx'] = _intexpand(d['vlanshowplist-ifidx'])\\n\\n [v.update(e) for v, e in zip(vlans, elements)]\\n return vlans\",\n \"def parse_virsh_command_line(command):\\n for cmd, regex in _virsh_commands:\\n match = regex.search(command)\\n if match:\\n return (cmd,) + match.groups()\\n raise RuntimeError('unrecognized command: {}'.format(command))\",\n \"def parseCommandLine():\\n parser = OptionParser(usage=\\\"%prog \\\", version=\\\"%prog \\\" + __version__,\\n description='''\\n This program calculates omegaAB value from a hexagonal lattice trajectory\\n stored in xyz file (see for more details)''')\\n parser.add_option(\\\"-f\\\", \\\"--traj\\\", dest=\\\"inXyzFilename\\\",default = \\\"hexTraj.xyz\\\",\\n help=\\\"xyz input trajectory file (default traj.xyz)\\\", metavar=\\\"INXYZFILE\\\")\\n parser.add_option(\\\"-r\\\", \\\"--reference\\\", dest=\\\"symbol\\\",default = \\\"P11\\\",\\n help=\\\"reference particle name\\\", metavar=\\\"ADATOM\\\")\\n parser.add_option(\\\"-o\\\", \\\"--output\\\", dest=\\\"outDatFilename\\\", default=\\\"omega.dat\\\",\\n help=\\\"output dat file with omega values for each frame. WARNING: it will be overriden\\\", metavar=\\\"OUTXYZFILE\\\")\\n \\n parser.add_option(\\\"-q\\\", \\\"--quiet\\\",\\n action=\\\"store_false\\\", dest=\\\"verbose\\\", default=True,\\n help=\\\"don't print status messages to stdout\\\")\\n\\n (options, _) = parser.parse_args()\\n\\n return options\",\n \"def ParseOption():\\n parser = optparse.OptionParser()\\n parser.add_option('--input', dest='input', help='Input file path')\\n parser.add_option('--output', dest='output', help='Output file path')\\n parser.add_option(\\n '--var_name', dest='var_name', help='Var name for the array')\\n return parser.parse_args()[0]\",\n \"def help2optparse(self):\\n helpstring_offset = self._get_helpoffset()\\n option_cnt = -1\\n option_list = []\\n ## 1 is 'Options' line\\n for line in self.parselines[1:]:\\n if len(line) < helpstring_offset:\\n break\\n if '--help' in line:\\n continue\\n tmp = line.split()\\n metavar = None\\n if tmp[0][:2] == '--':\\n ## only long option\\n longopt = tmp[0]\\n if '=' in longopt:\\n longtmp = longopt.split(\\\"=\\\")\\n longopt = longtmp[0]\\n metavar = longtmp[1]\\n option_list.append({'short': None,\\n 'long': longopt,\\n 'metavar': metavar,\\n 'help': line[helpstring_offset:] + ' '})\\n option_cnt += 1\\n elif tmp[0][0] == '-':\\n ## short option\\n shortopt = tmp[0][:2]\\n longopt = None\\n if line[helpstring_offset - 1] is ' ':\\n help_string = line[helpstring_offset:]\\n else:\\n help_string = \\\"\\\"\\n if tmp[1][:2] == '--':\\n longopt = tmp[1]\\n if '=' in longopt:\\n longtmp = longopt.split(\\\"=\\\")\\n longopt = longtmp[0]\\n metavar = longtmp[1]\\n else: # found metavar\\n metavar = tmp[1][:-1]\\n longopt = tmp[2].split(\\\"=\\\")[0]\\n option_list.append({'short': shortopt,\\n 'long': longopt,\\n 'metavar': metavar,\\n 'help': help_string + ' '})\\n option_cnt += 1\\n else:\\n ## only help-strings line\\n option_list[option_cnt]['help'] += line[helpstring_offset:]\\n option_list[option_cnt]['help'] += \\\" \\\"\\n return self._get_parserobj(option_list)\",\n \"def print_parse_result(self, line, log_probs, backpointer, length):\\n line = line.strip()\\n if log_probs[(0, length-1)][START_SYM] != -float('inf'):\\n print(\\n self._format_parse(START_SYM, backpointer, 0, length-1, 0))\\n print(log_probs[(0, length-1)][START_SYM])\\n else:\\n print('NONE')\",\n \"def _output_vadapter_list_verbose(outf, name, vadapter_list):\\n\\n if vadapter_list:\\n FMT = \\\"%s\\\\n%-10s\\\\n%-20s\\\\n%-5s\\\\n%s\\\\n%s\\\\n%s\\\\n%s\\\\n%s\\\\n%s\\\\n%s\\\\n%s\\\\n%s\\\\n%s\\\\n%s\\\\n%s\\\\n%s\\\\n\\\"\\n# HEADER = (\\\"id\\\",\\\"name\\\",\\\"io_module_id\\\",\\\"vfabric_id\\\",\\\"protocol\\\",\\\"init_type\\\",\\\"desc\\\",\\\"status\\\",\\\"mac\\\"\\n# ,\\\"prmiscuous_mode\\\",\\\"silent_listener\\\",\\\"vlan\\\",\\\"wwnn\\\",\\\"wwpn\\\",\\\"fc_id\\\",\\\"spma\\\",\\\"fmpa\\\") \\n\\t\\n for (n , vadapter) in vadapter_list:\\n name = vadapter['NAME']\\n id = vadapter['ID']\\n protocol = vadapter['PROTOCOL']\\n vfabric = vadapter['VFABRIC']\\n io_module = vadapter['IO_MODULE_ID']\\n desc = vadapter['DESC']\\n status = vadapter['STATUS']\\n init_type = vadapter['INIT_TYPE']\\n running_mode = vadapter['RUNNING_MODE']\\n if protocol == 1:\\n mac = vadapter['MAC']\\n promiscuous = vadapter['PROMISCUOUS']\\n silent = vadapter['SILENT']\\n vlan = vadapter['VLAN']\\n elif protocol == 3:\\n wwnn = vadapter['WWNN']\\n wwpn = vadapter['WWPN']\\n spma = vadapter['SPMA']\\n fpma = vadapter['FPMA']\\n fc_id = vadapter['FC_ID']\\n\\n\\n if _LIMITED_SHOW:\\n outf.write('General Attr:\\\\nId: %s\\\\n\\\\tName: %s\\\\n\\\\tIO_Module: %s\\\\n\\\\tVfabric: %s\\\\n\\\\tProtocol: %s\\\\n\\\\tInitization_Type: %s\\\\n\\\\tDescription: %s\\\\n\\\\tStatus: %-20s\\\\n\\\\n' % (id, name, io_module, vfabric, protocol, init_type, desc, status)) \\n \\n\\t\\telif _DETAIL_SHOW: \\n if protocol == 3:\\n outf.write('General Attr:\\\\nId: %s\\\\nName: %s\\\\nIO_Module: %s\\\\nVfabric: %s\\\\nProtocol: %s\\\\nInitization_Type: %s\\\\nDescription: %s\\\\nStatus: %-20s\\\\nRUNNING_MODE :%s\\\\nFC_Attr:\\\\n\\\\tWWNN: %s\\\\n\\\\tWWNP: %s\\\\n\\\\tFC_ID: %s\\\\n\\\\tSPMA: %s\\\\n\\\\tFMPA: %s\\\\n\\\\n' % (id, name, io_module, vfabric, protocol, init_type, desc, status, running_mode, wwnn, wwpn,fc_id,spma,fpma)) \\n \\n elif protocol == 1:\\n\\t\\t\\t outf.write('General Attr:\\\\nId: %s\\\\nName: %s\\\\nIO_Module: %s\\\\nVfabric: %s\\\\nProtocol: %s\\\\nInitization_Type: %s\\\\nDescription: %s\\\\nStatus: %-20s\\\\nRUNNING_MODE :%s\\\\nEN_Attr:\\\\n\\\\tMAC: %s\\\\n\\\\tVLAN: %s\\\\n\\\\tPromiscuous: %s\\\\n\\\\tSilent Listener: %s\\\\n\\\\n' % (id , name, io_module,vfabric, protocol, init_type, desc, status, running_mode, mac,vlan, promiscuous, silent))\",\n \"def parse_commandline():\\n parser = optparse.OptionParser()\\n\\n parser.add_option(\\\"-n\\\", \\\"--num\\\", help=\\\"Pulsar number\\\", default=0, type=int)\\n parser.add_option(\\\"-p\\\", \\\"--prfile\\\", help=\\\"Parameter file\\\", type=str)\\n parser.add_option(\\\"-d\\\", \\\"--drop\\\", \\\\\\n help=\\\"Drop pulsar with index --num in a full-PTA run \\\\\\n (0 - No / 1 - Yes)\\\", default=0, type=int)\\n parser.add_option(\\\"-c\\\", \\\"--clearcache\\\", \\\\\\n help=\\\"Clear psrs cache file, associated with the run \\\\\\n (to-do after changes to .par and .tim files)\\\", \\\\\\n default=0, type=int)\\n parser.add_option(\\\"-m\\\", \\\"--mpi_regime\\\", \\\\\\n help=\\\"In MPI, manipulating with files and directories \\\\\\n causes errors. So, we provide 3 regimes: \\\\n \\\\\\n (0) No MPI - run code as usual; \\\\n \\\\\\n (1) MPI preparation - manipulate files and prepare \\\\\\n for the run (should be done outside MPI); \\\\n \\\\\\n (2) MPI run - run the code, assuming all necessary \\\\\\n file manipulations have been performed. \\\\n \\\\\\n PolychordLite sampler in Bilby supports MPI\\\",\\n default=0, type=int)\\n parser.add_option(\\\"-w\\\", \\\"--wipe_old_output\\\", \\\\\\n help=\\\"Wipe contents of the output directory. Otherwise, \\\\\\n the code will attempt to resume the previous run. \\\\\\n Be careful: all subdirectories are removed too!\\\", \\\\\\n default=0, type=int)\\n parser.add_option(\\\"-x\\\", \\\"--extra_model_terms\\\", \\\\\\n help=\\\"Extra noise terms to add to the .json noise model \\\\\\n file, a string that will be converted to dict. \\\\\\n E.g. {'J0437-4715': {'system_noise': \\\\\\n 'CPSR2_20CM'}}. Extra terms are applied either on \\\\\\n the only model, or the second model.\\\", \\\\\\n default='None', type=str)\\n\\n opts, args = parser.parse_args()\\n\\n return opts\",\n \"def parse_commandline():\\n parser = optparse.OptionParser()\\n\\n parser.add_option(\\\"-w\\\", \\\"--wavelength\\\", default=600, type=int)\\n parser.add_option(\\\"-f\\\", \\\"--filter\\\", default=1, type=int)\\n parser.add_option(\\\"-g\\\", \\\"--grating\\\", default=3, type=int)\\n parser.add_option(\\\"--doMonoWavelength\\\", action=\\\"store_true\\\", default=False)\\n parser.add_option(\\\"--doMonoFilter\\\", action=\\\"store_true\\\", default=False)\\n parser.add_option(\\\"--doMonoGrating\\\", action=\\\"store_true\\\", default=False)\\n parser.add_option(\\\"--doGetMono\\\", action=\\\"store_true\\\", default=False)\\n parser.add_option(\\\"-v\\\", \\\"--verbose\\\", action=\\\"store_true\\\", default=False)\\n\\n opts, args = parser.parse_args()\\n\\n return opts\",\n \"def task_parse_results():\\n pass\",\n \"def parse_csv_option(option):\\n if option:\\n return option.split(',')\\n else:\\n return []\",\n \"def parse_csv_option(option):\\n if option:\\n return option.split(',')\\n else:\\n return []\",\n \"def parse_commandline():\\n parser = optparse.OptionParser(usage = __doc__,version=git_version.verbose_msg)\\n\\n parser.add_option(\\\"-t\\\", \\\"--timeFile\\\",help=\\\"Text file with central times.\\\",default = 'centralTimes.txt')\\n\\tparser.add_option(\\\"-c\\\", \\\"--channel\\\",help=\\\"IFO channel.\\\",default = 'L1:GDS-CALIB_STRAIN')\\n\\tparser.add_option(\\\"-w\\\", \\\"--workdirectory\\\",help=\\\"Working directory.\\\",default = '.')\\n\\tparser.add_option(\\\"-s\\\", \\\"--sourceDir\\\",help=\\\"Name of source directory.\\\",default = 'source')\\n\\n opts, args = parser.parse_args()\\n return opts\",\n \"def parse_pts(pts_result_file, global_var_list, parsed_results_file):\\n fill_value_name(pts_result_file, global_var_list, parsed_results_file)\",\n \"def _parse_option_value(line, option_name):\\n try:\\n option_value = line.split('=')[1].strip()\\n except IndexError:\\n option_value = ''\\n if not option_value:\\n raise ValueError(\\\"No value specified for {} option.\\\".format(option_name))\\n return option_value\",\n \"def _parse_param_line(regex, line):\\n out = []\\n for r in regex.findall(line):\\n converter, variable = r[0] or 'default', r[1]\\n out.append((_CONVERTERS[converter], variable))\\n return out\",\n \"def parse_options(options):\\r\\n # convert single quotes inside option values to html encoded string\\r\\n options = re.sub(r\\\"([a-zA-Z])('|\\\\\\\\')([a-zA-Z])\\\", r\\\"\\\\1'\\\\3\\\", options)\\r\\n options = re.sub(r\\\"\\\\\\\\'\\\", r\\\"'\\\", options) # replace already escaped single quotes\\r\\n # parse the set of possible options\\r\\n lexer = shlex.shlex(options[1:-1].encode('utf8'))\\r\\n lexer.quotes = \\\"'\\\"\\r\\n # Allow options to be separated by whitespace as well as commas\\r\\n lexer.whitespace = \\\", \\\"\\r\\n\\r\\n # remove quotes\\r\\n # convert escaped single quotes (html encoded string) back to single quotes\\r\\n tokens = [x[1:-1].decode('utf8').replace(\\\"'\\\", \\\"'\\\") for x in lexer]\\r\\n\\r\\n # make list of (option_id, option_description), with description=id\\r\\n return [(t, t) for t in tokens]\",\n \"def parse_options():\\n global parser\\n parser.add_option(\\\"-r\\\", \\\"--regions\\\", dest=\\\"input_brain_regions\\\",\\n help=\\\"Input file for brain region data\\\",\\n action=\\\"store\\\", type='string')\\n\\n parser.add_option(\\\"-g\\\", \\\"--gray\\\", dest=\\\"input_gray_levels\\\",\\n help=\\\"Input file for gray level data\\\",\\n action=\\\"store\\\", type='string')\\n\\n parser.add_option(\\\"-n\\\", \\\"--nissl\\\", dest=\\\"input_nissl\\\",\\n help=\\\"Input file for nissl data\\\",\\n action=\\\"store\\\", type='string')\\n\\n parser.add_option(\\\"-o\\\", \\\"--output\\\", dest=\\\"output_folder_path\\\",\\n help=\\\"Output folder for extracted data files\\\",\\n action=\\\"store\\\", type='string')\\n\\n return parser.parse_args()\",\n \"def argument_parser():\\n parser = argparse.ArgumentParser(\\n description='separate mutect only calls, strelka only calls, and intersect calls from two vcf files')\\n\\n parser.add_argument('-o', '--outputDIR', required=False, default=os.getcwd())\\n parser.add_argument('-m', '--mutect', required=True, help='Mutect VCF')\\n parser.add_argument('-s', '--sampleName', required=True, help='Sample name of tumor sample that is used in the header of VCF file. Usually identified from `@RG SM:` tag from BAM file')\\n\\n# parser.add_argument('-n', '--normal_column', type=int, required=True, help='Tells whether normal column is written before cancer column. For example after the <FORMAT> column of vcf, if the order is <TUMOR> <NORMAL>, then --normal_column is 1. If <NORMAL> <TUMOR> then --normal_column is 0')\\n parser.add_argument('-t', '--threshold', type=float, required=True, help ='Threshold to filter out those variants that has variant reads in normal Bam')\\n\\n args = vars(parser.parse_args())\\n\\n outputDIR = args['outputDIR']\\n mutect = args['mutect']\\n# normal_column = args['normal_column']\\n sampleName = args['sampleName']\\n threshold = args['threshold']\\n return outputDIR, mutect, sampleName, threshold\",\n \"def parse_command_line(self):\\n return self.command_line_parser.parse()\",\n \"def parse(self, command_line=sys.argv[1:]):\\n return self._parser.parse_args(command_line)\",\n \"def printOptions(opts,subject_ids,session_ids,task_list, run_list, acq, rec):\\n uname = os.popen('uname -s -n -r').read()\\n print \\\"\\\\n\\\"\\n print \\\"* Pipeline started at \\\"+time.strftime(\\\"%c\\\")+\\\"on \\\"+uname\\n print \\\"* Command line is : \\\\n \\\"+str(sys.argv)+\\\"\\\\n\\\"\\n print \\\"* The source directory is : \\\"+opts.sourceDir\\n print \\\"* The target directory is : \\\"+opts.targetDir+\\\"\\\\n\\\"\\n print \\\"* Data-set Subject ID(s) is/are : \\\"+str(', '.join(subject_ids))+\\\"\\\\n\\\"\\n # print \\\"* PET conditions : \\\"+ ','.join(opts.condiList)+\\\"\\\\n\\\"\\n print \\\"* Sessions : \\\", session_ids, \\\"\\\\n\\\"\\n print \\\"* Tasks : \\\" , task_list , \\\"\\\\n\\\"\\n print \\\"* Runs : \\\" , run_list , \\\"\\\\n\\\"\\n print \\\"* Acquisition : \\\" , acq , \\\"\\\\n\\\"\\n print \\\"* Reconstruction : \\\" , rec , \\\"\\\\n\\\"\",\n \"def handle_option(self, option, options):\\n pass\",\n \"def parse_vcf_line(line):\\n\\n if isinstance(line, str):\\n if line.startswith('#'):\\n return None\\n\\n elem = line.strip().split('\\\\t')\\n elif isinstance(line, list):\\n elem = line\\n\\n try:\\n quality = int(elem[5])\\n except ValueError:\\n try:\\n quality = float(elem[5])\\n except ValueError:\\n quality = None\\n\\n filter_field = None\\n\\n if elem[6] != '.':\\n filter_field = elem[6].split(';')\\n\\n info = elem[7]\\n\\n try:\\n fmt = elem[8]\\n except IndexError:\\n fmt = None\\n else:\\n if fmt == '.':\\n fmt = None\\n\\n return VCFRecord(elem[0], int(elem[1]), None if elem[2] == '.' else elem[2], elem[3],\\n elem[4].split(','), quality, filter_field, info, fmt, elem[9:])\",\n \"def process_output(self):\\n vim.command('call setqflist([])')\\n qf_list = []\\n qf_dict = {}\\n\\n for line in self.output:\\n skip = False\\n for exclude_pattern in self.exclude_list:\\n if exclude_pattern in line[2]:\\n skip = True\\n break\\n if skip:\\n continue\\n qf_dict['bufnr'] = self.bufnr\\n qf_dict['lnum'] = line[0]\\n qf_dict['col'] = line[1]\\n qf_dict['text'] = line[2]\\n qf_dict['type'] = line[2][0]\\n qf_list.append(qf_dict)\\n qf_dict = {}\\n\\n self.output = []\\n vim.command('call setqflist(%s)' % str(qf_list))\\n if qf_list:\\n vim.command('copen')\",\n \"def cliOptions():\\n parser = OptionParser()\\n\\n parser.add_option(\\\"-s\\\", \\\"--saint\\\", help=\\\"Please provide the Saint CSV file\\\", dest=\\\"saint\\\")\\n parser.add_option(\\\"-n\\\", \\\"--nessus\\\", help=\\\"Please provide the Nessus CSV file\\\", dest=\\\"nessus\\\")\\n parser.add_option(\\\"-e\\\", \\\"--export\\\", help=\\\"Please provide an name for export\\\", dest=\\\"export\\\")\\n\\n (options, args) = parser.parse_args()\\n\\n # hard coding the path to the csv files until i get the results I want and for simple testing.\\n # you can remove/comment out the next two lines and invoke the python script with the flags above.\\n #options.saint = 'data/saint.csv'\\n #options.nessus = 'data/nessus.csv'\\n #options.export = 'data/export.csv'\\n\\n # Ensure the Saint/Nessus csv files have been provided\\n if options.saint is None or options.nessus is None:\\n print 'Forgot the CSV reports'\\n sys.exit(2)\\n\\n # Call Merged Results\\n MergedResults(options.saint, options.nessus, options.export)\",\n \"def _process_line(line, status):\\n\\n if line.startswith(ADAPTER_LINE_STARTSWITH):\\n status.add_block('adapter', 'name', line)\\n return\\n elif line.startswith(EXIT_LINE_STARTSWITH):\\n status.consolidate()\\n return\\n\\n key, value = [el.strip(' \\\\t\\\\r\\\\n') for el in line.split(':', 1)]\\n\\n if key in KEY_TO_CONTEXT.keys():\\n status.add_block(KEY_TO_CONTEXT[key], key, value)\\n else:\\n status.set_property(key, value)\",\n \"def parse_listing(self, raw_output):\\n return output_parser.listing(raw_output)\",\n \"def V_action(option,opt_str,value,parser):\\n print topo.__version__\\n sys.exit()\",\n \"def parse_list_output(output):\\n lines = output.splitlines()\\n keys = filter(None, lines[1].split('|'))\\n keys = [x.lower().strip() for x in keys]\\n r = []\\n for line in lines[3:-1]:\\n if len(line.split()) <= 1:\\n continue\\n values = filter(None, line.split('|'))\\n values = [x.strip() for x in values]\\n assert len(keys) == len(values)\\n record = dict(zip(keys, values))\\n r.append(record)\\n return r\",\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 _parse_qselect(qselect_output):\\n jobs = qselect_output.splitlines()\\n if not jobs or (len(jobs) == 1 and jobs[0] == ''):\\n return []\\n return [int(job.split('.')[0]) for job in jobs]\",\n \"def parse_cmd_line_options():\\n parser = argparse.ArgumentParser(prog='runner.py', description=\\\"Measure and view your internet speeds\\\")\\n subparsers = parser.add_subparsers(help='help for subcommand', dest=\\\"command\\\")\\n\\n # create the parser for the \\\"run\\\" command\\n run_parser = subparsers.add_parser('run', description=\\\"Measure internet speed periodically by setting frequency and duration.\\\",\\n epilog=\\\"Both frequency and duration should be formatted as follows \\\\\\n ----------- interger [sec|min|hour|day|] ex) 5 min\\\")\\n run_parser.add_argument(\\\"-f\\\", \\\"--frequency\\\", nargs=2, required=True,\\n help='How often should we run.')\\n run_parser.add_argument(\\\"-d\\\", \\\"--duration\\\", nargs=2, default=[24, \\\"hour\\\"],\\n help=\\\"How long should we run. (default=%(default)s)\\\")\\n run_parser.add_argument(\\\"-resultfile\\\", default=\\\"speedresults.json\\\",\\n help=\\\"Location where results shouls be saved (default=%(default)s)\\\")\\n run_parser.add_argument(\\\"-configfile\\\")\\n run_parser.add_argument(\\\"-pidfile\\\")\\n\\n # create the parser for the \\\"draw\\\" command\\n draw_parser = subparsers.add_parser('draw', help='help for command_2')\\n draw_parser.add_argument(\\\"-resultfile\\\", default=\\\"speedresults.json\\\", help=\\\"Choose results file to draw. (default=%(default)s)\\\")\\n draw_parser.add_argument(\\\"-type\\\", default=\\\"pyplot\\\", choices=[\\\"pyplot\\\", \\\"plotly\\\"],\\n help=\\\"The type of graph to display (default=%(default)s)\\\")\\n draw_parser.add_argument(\\\"-filter\\\", nargs=2, help='Filter data on specific key value pairs')\\n draw_parser.add_argument(\\\"-options\\\", default=\\\"download\\\", choices=[\\\"download\\\", \\\"upload\\\"],\\n help='Graph upload or download speeds. (default=%(default)s)')\\n return parser.parse_args()\",\n \"def parse_command_line(argv):\\n formatter_class = argparse.RawDescriptionHelpFormatter\\n parser = argparse.ArgumentParser(description=module,formatter_class=formatter_class)\\n parser.add_argument('-n', '--name', dest=\\\"name\\\", metavar=\\\"hostname\\\",\\n nargs='?', \\n type=str,\\n required=True,\\n help=\\\"Define a virtual hostname\\\")\\n parser.add_argument('-o', '--os', dest=\\\"os\\\", metavar=\\\"os\\\",\\n nargs='?', \\n required=True,\\n type=str,\\n choices=['debian','mint','centos','mac','w7'],\\n help=\\\"Define a operating system\\\")\\n parser.add_argument(\\\"--dry-run\\\", help=\\\"Only print throughput, do not execute command.\\\",\\n action=\\\"store_true\\\")\\n parser.add_argument(\\\"--legacy\\\", help=\\\"Use legacy install (from official repository).\\\",\\n action=\\\"store_true\\\")\\n parser.add_argument(\\\"--version\\\", action=\\\"version\\\",\\n version=\\\"%(prog)s {}\\\".format(__version__))\\n parser.add_argument(\\\"-v\\\", \\\"--verbose\\\", dest=\\\"verbose_count\\\",\\n action=\\\"count\\\", default=0,\\n help=\\\"increases log verbosity for each occurence.\\\")\\n arguments = parser.parse_args(argv[1:])\\n # Sets log level to WARN going more verbose for each new -v.\\n log.setLevel(max(3 - arguments.verbose_count, 0) * 10)\\n return arguments\",\n \"def set_parser():\\n\\n print('\\\\n\\\\nLoading Options and Configurations\\\\n' + 72 * '~' + '\\\\n')\\n parser = ArgumentParser( \\\\\\n description=('''\\\\n\\nUsed to validate the TELEMAC system against a benchmark of test cases for\\na certain rank, and a certain tag'''))\\n\\n parser = add_runcode_argument(parser)\\n parser.add_argument( \\\\\\n \\\"-b\\\", \\\"--bypass\\\", action=\\\"store_true\\\", dest=\\\"bypass\\\", default=False,\\n help=\\\"will bypass execution failures and try to carry on \\\"\\\\\\n \\\"(final report at the end)\\\")\\n # Combine with all filters above, \\\"rank\\\" now controls everything\\n # and Jenkins can control \\\"rank\\\"\\n parser.add_argument( \\\\\\n \\\"-k\\\", \\\"--rank\\\", dest=\\\"rank\\\", type=int, default=4,\\n help=\\\"specify the ranks to be validated all rank lower or equal to \\\"\\n \\\"the value will be run\\\")\\n parser.add_argument( \\\\\\n \\\"--tags\\\", dest=\\\"tags\\\", default='all',\\n help=\\\\\\n \\\"specify tags (; separated) to run \\\"\\\\\\n \\\" '-tag' will do the opposite and \\\"\\\\\\n \\\"tag1+tag2 will run cases that has both tag1 and tag2), \\\"\\\\\\n \\\"default is all of them\\\")\\n parser.add_argument( \\\\\\n \\\"--valrootdir\\\", dest=\\\"val_root\\\", default='',\\n help=\\\"specify the directory in which to search the validation cases, \\\"\\\\\\n \\\"default is taken from config file\\\")\\n parser.add_argument( \\\\\\n \\\"--vnv-pre\\\", action=\\\"store_true\\\", dest=\\\"vnv_pre\\\", default=False,\\n help=\\\"Only do pre-treatment\\\")\\n parser.add_argument( \\\\\\n \\\"--vnv-run\\\", action=\\\"store_true\\\", dest=\\\"vnv_run\\\", default=False,\\n help=\\\"Only do execution for each study\\\")\\n parser.add_argument( \\\\\\n \\\"--vnv-check\\\", action=\\\"store_true\\\", dest=\\\"vnv_check\\\", default=False,\\n help=\\\"Only do check of results (epsilons)\\\")\\n parser.add_argument( \\\\\\n \\\"--vnv-post\\\", action=\\\"store_true\\\", dest=\\\"vnv_post\\\", default=False,\\n help=\\\"Only do post-treatment\\\")\\n parser.add_argument( \\\\\\n \\\"--report-name\\\", dest=\\\"report_name\\\", default='',\\n help=\\\"will create a csv containing information on the validation \\\"\\\\\\n \\\"such as execution time, rank, if it passed...\\\")\\n parser.add_argument( \\\\\\n \\\"--clean\\\", action=\\\"store_true\\\", dest=\\\"cleanup\\\", default=False,\\n help=\\\"will erase all object, executable, result files \\\"\\\\\\n \\\"from subfolders for the actual configuration\\\")\\n parser.add_argument( \\\\\\n \\\"--full-clean\\\", action=\\\"store_true\\\", dest=\\\"full_cleanup\\\", default=False,\\n help=\\\"will erase all vnv study folders regarding of configurations\\\")\\n\\n # Options for notebook\\n parser.add_argument(\\n \\\"--notebook\\\",\\n dest=\\\"notebook\\\",\\n action=\\\"store_true\\\", default=False,\\n help=\\\"Run validation of notebook\\\")\\n parser.add_argument(\\n \\\"--notebook-timeout\\\",\\n dest=\\\"nb_timeout\\\", type=int, default=60000,\\n help=\\\"Time after whihc the notebook will be killed if still running\\\")\\n parser.add_argument(\\n \\\"--notebook-update\\\",\\n dest=\\\"nb_update\\\",\\n action=\\\"store_true\\\", default=False,\\n help=\\\"Update notebook file with the runned one\\\")\\n parser.add_argument(\\n \\\"--verbose\\\",\\n dest=\\\"verbose\\\",\\n action=\\\"store_true\\\", default=False,\\n help=\\\"More verbose validation\\\")\\n\\n # Options for api\\n parser.add_argument(\\n \\\"--api\\\",\\n dest=\\\"api\\\",\\n action=\\\"store_true\\\", default=False,\\n help=\\\"Run validation of api\\\")\\n\\n parser.add_argument(\\\"args\\\", metavar='Python file(s)', nargs='*')\\n options = parser.parse_args()\\n\\n # Conversion of options.tags (replacing all by list) and checking that the\\n # value is valid\\n # Removing quotes\\n tmp_tag = options.tags.strip(\\\"'\\\\\\\"\\\")\\n options.tags = tmp_tag\\n # Checking that tags are valid\\n for tag in options.tags.split(';'):\\n if '+' in tag:\\n for and_tag in tag.split('+'):\\n # Removing - if in tag\\n ttag = and_tag[1:] if and_tag[0] == '-' else and_tag\\n if ttag not in TAGS:\\n raise TelemacException(\\\\\\n \\\"Unknow tag: {tag}\\\\nTags available: {tags}\\\"\\\\\\n .format(tag=ttag, tags=';'.join(TAGS)))\\n else:\\n if tag == 'all':\\n continue\\n # Removing - if in tag\\n ttag = tag[1:] if tag[0] == '-' else tag\\n if ttag not in TAGS:\\n raise TelemacException(\\\\\\n \\\"Unknow tag: {tag}\\\\nTags available: {tags}\\\"\\\\\\n .format(tag=ttag, tags=';'.join(TAGS)))\\n\\n # Replacing all by list of tags\\n if 'all' in options.tags.split(';'):\\n options.tags = options.tags.replace('all', ';'.join(TAGS))\\n\\n # If pre, run, post are all false switching them to true\\n if not(options.vnv_pre or options.vnv_run or\\n options.vnv_check or options.vnv_post):\\n options.vnv_pre = True\\n options.vnv_run = True\\n options.vnv_check = True\\n options.vnv_post = True\\n\\n return options\",\n \"def _parse_qselect(qselect_output):\\n jobs = qselect_output.splitlines()\\n if not jobs or (len(jobs) == 1 and jobs[0] is ''):\\n return []\\n return [int(job.split('.')[0]) for job in jobs]\",\n \"def set_option_parse_svn_entries(self, boolean, apikey=''):\\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/action/setOptionParseSVNEntries/', {'Boolean': boolean, 'apikey': apikey})))\",\n \"def parseOptions():\\n desc = \\\"Compute the likelihood of sequences coming from a list of barcodes.\\\"\\n parser = argparse.ArgumentParser(description=desc, add_help=False)\\n\\n def canonicalizedFilePath(path):\\n return os.path.abspath(os.path.expanduser(path))\\n\\n def checkInputFile(path):\\n if not os.path.isfile(path):\\n parser.error(\\\"Input file %s not found.\\\" % (path,))\\n\\n def checkOutputFile(path):\\n try:\\n f = open(path, \\\"a\\\")\\n f.close()\\n except:\\n parser.error(\\\"Output file %s cannot be written.\\\" % (path,))\\n\\n basics = parser.add_argument_group(\\\"Basic required options\\\")\\n basics.add_argument(\\n \\\"cmpH5Filename\\\",\\n type=canonicalizedFilePath,\\n metavar=\\\"CMP.H5\\\",\\n help=\\\"The filename of the input Bas.H5 file\\\")\\n basics.add_argument(\\n \\\"referenceFasta\\\",\\n type=canonicalizedFilePath,\\n metavar=\\\"REFERENCE_FASTA\\\",\\n help=\\\"The reference sequences of interest in FASTA format\\\")\\n basics.add_argument(\\n \\\"basH5Fofn\\\",\\n type=canonicalizedFilePath,\\n metavar=\\\"BARCODE_FASTA\\\",\\n help=\\\"The filename of the barcode FASTA\\\")\\n basics.add_argument(\\n \\\"-o\\\", \\\"--outputFilename\\\",\\n type=str,\\n default=os.path.join(os.getcwd(), \\\"output.csv\\\"),\\n metavar=\\\"CSV\\\",\\n help=\\\"The filename of the CSV to output barcode scoring data to.\\\")\\n basics.add_argument(\\n \\\"-m\\\", \\\"--minSize\\\",\\n type=int,\\n default=3,\\n metavar=\\\"INT\\\",\\n help=\\\"The minimum size of a homopolymer context to record\\\")\\n\\n debugging = parser.add_argument_group(\\\"Verbosity and debugging/profiling\\\")\\n debugging.add_argument(\\\"--help\\\", \\\"-h\\\",\\n action=\\\"help\\\")\\n debugging.add_argument(\\n \\\"--nZmws\\\",\\n default=-1,\\n type=int,\\n help=\\\"Label only the first N ZMWs for testing purposes.\\\")\\n debugging.add_argument(\\n \\\"--verbose\\\", \\\"-v\\\",\\n dest=\\\"verbosity\\\",\\n action=\\\"count\\\",\\n help=\\\"Set the verbosity level.\\\")\\n debugging.add_argument(\\n \\\"--quiet\\\",\\n dest=\\\"quiet\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Turn off all logging, including warnings\\\")\\n class PrintVersionAction(argparse.Action):\\n def __call__(self, parser, namespace, values, option_string=None):\\n print \\\" RegionTools version: %s\\\" % __version__\\n print \\\" h5py version: %s\\\" % h5py.version.version\\n print \\\" hdf5 version: %s\\\" % h5py.version.hdf5_version\\n sys.exit(0)\\n debugging.add_argument(\\\"--version\\\",\\n nargs=0,\\n action=PrintVersionAction)\\n\\n parser.parse_args(namespace=options)\\n\\n for path in (options.cmpH5Filename, options.referenceFasta, options.basH5Fofn):\\n if path is not None:\\n checkInputFile(path)\\n\\n for path in (options.outputFilename,):\\n if path is not None:\\n checkOutputFile(path)\\n\\n options.shellCommand = \\\" \\\".join(sys.argv)\",\n \"def _process_command_line():\\n # pylint: disable=C0103\\n global parameters\\n # pylint: enable=C0103\\n\\n # option letters followed by : expect an argument\\n # same for option strings followed by =\\n if parameters[\\\"Command flavour\\\"] in (\\\"posix\\\", \\\"linux\\\"):\\n character_options = \\\"s?\\\"\\n else: # if parameters[\\\"Command flavour\\\"] in (\\\"PNU\\\", \\\"bsd\\\", \\\"bsd:freebsd\\\"):\\n character_options = \\\"qs?\\\"\\n string_options = [\\n \\\"debug\\\",\\n \\\"help\\\",\\n \\\"version\\\",\\n ]\\n\\n try:\\n options, remaining_arguments = getopt.getopt(\\n sys.argv[1:], character_options, string_options\\n )\\n except getopt.GetoptError as error:\\n logging.critical(\\\"Syntax error: %s\\\", error)\\n _display_help()\\n sys.exit(1) # no match\\n\\n for option, _ in options:\\n\\n if option == \\\"--debug\\\":\\n logging.disable(logging.NOTSET)\\n\\n elif option in (\\\"--help\\\", \\\"-?\\\"):\\n _display_help()\\n sys.exit(1) # no match\\n\\n elif option == \\\"-q\\\":\\n parameters[\\\"No formatting\\\"] = True\\n\\n elif option == \\\"-s\\\":\\n parameters[\\\"First match only\\\"] = True\\n\\n elif option == \\\"--version\\\":\\n print(ID.replace(\\\"@(\\\" + \\\"#)\\\" + \\\" $\\\" + \\\"Id\\\" + \\\": \\\", \\\"\\\").replace(\\\" $\\\", \\\"\\\"))\\n sys.exit(1) # no match\\n\\n logging.debug(\\\"_process_command_line(): parameters:\\\")\\n logging.debug(parameters)\\n logging.debug(\\\"_process_command_line(): remaining_arguments:\\\")\\n logging.debug(remaining_arguments)\\n\\n return remaining_arguments\",\n \"def do_Promo_line_parse (Promo_line, line_number, filehash) :\\n result = [filehash,\\n line_number,\\n Promo_line[0:8].strip(),\\n Promo_line[9:13].strip(),\\n Promo_line[14:19].strip(),\\n Promo_line[20:26].strip().lstrip('0'), # Spec indicates numerical field\\n Promo_line[27:30].strip().lstrip('0'), # Spec indicates numerical field\\n Promo_line[31:40].strip(),\\n Promo_line[41:49].strip(),\\n Promo_line[50:].strip()\\n ]\\n return result\\n # Having the line number passed in is ugly, but kind of works :/\\n # Having all the field extraction explicit is kind of ugly too...\\n # We're using the hash here to link? Yeah, that's because Python\\n # doesn't know what the autonumbered load table is up to in the\\n # DB when it starts to coalesce the raw files together.\",\n \"def _parse_options():\\n parser = OptionParser()\\n parser.add_option('-q', '--quiet', help='set logging to ERROR',\\n action='store_const', dest='loglevel',\\n const=logging.ERROR, default=logging.INFO)\\n parser.add_option('-d', '--debug', help='set logging to DEBUG',\\n action='store_const', dest='loglevel',\\n const=logging.DEBUG, default=logging.INFO)\\n parser.add_option('-v', '--verbose', help='set logging to COMM',\\n action='store_const', dest='loglevel',\\n const=5, default=logging.INFO)\\n options, _ = parser.parse_args()\\n logging.basicConfig(level=options.loglevel,\\n format='%(levelname)-8s %(message)s')\",\n \"def _result_to_dict(line):\\n f = line.split(':;')\\n return {'server': f[0], 'os_name': f[1], 'status': f[2], 'ipv4': f[3]}\",\n \"def _parse_version_string(cmd_result: str) -> str:\\n lines = cmd_result.splitlines()\\n split_lines = [line.split(\\\" \\\") for line in lines]\\n version_line = [\\n line for line in split_lines if len(line) > 0 and line[1] == \\\"version\\\"\\n ][0]\\n version_string = version_line[2].replace('\\\"', \\\"\\\")\\n return version_string\",\n \"def _handle_short_form(element):\\n if len(element) <= 1:\\n raise CmdLineException(\\\"Invalid option: '{}'\\\".format(element))\\n tokens = []\\n for i in range(1, len(element)):\\n if element[i: i + 1] == \\\"=\\\":\\n if i + 1 < len(element):\\n tokens.append(element[i + 1:])\\n break\\n tokens.append(\\\"-\\\" + element[i: i + 1])\\n return tokens\",\n \"def main() -> int:\\n ucvm_out = \\\"\\\"\\n for j in frange(CORNERS[\\\"bl\\\"][\\\"n\\\"], CORNERS[\\\"ur\\\"][\\\"n\\\"], SPACING):\\n for i in frange(CORNERS[\\\"bl\\\"][\\\"e\\\"], CORNERS[\\\"ur\\\"][\\\"e\\\"] + SPACING, SPACING):\\n ucvm_out += \\\"%.2f %.2f 0\\\\n\\\" % (i, j)\\n os.chdir(\\\"/Users/davidgil/ucvm-15.10.0/bin\\\")\\n proc = Popen(\\n [\\\"./ucvm_query\\\", \\\"-f\\\", \\\"../conf/ucvm.conf\\\"], stdout=PIPE, stdin=PIPE, stderr=STDOUT\\n )\\n out_arr = np.zeros(\\n shape=(\\n int((CORNERS[\\\"ur\\\"][\\\"n\\\"] - CORNERS[\\\"bl\\\"][\\\"n\\\"]) / SPACING) + 2,\\n int((CORNERS[\\\"ur\\\"][\\\"e\\\"] - CORNERS[\\\"bl\\\"][\\\"e\\\"]) / SPACING) + 2\\n )\\n )\\n output = proc.communicate(input=ucvm_out.encode(\\\"ASCII\\\"))[0]\\n i = 0\\n j = 0\\n for line in output.decode(\\\"ASCII\\\").split(\\\"\\\\n\\\")[2:-1]:\\n line_split = line.split()\\n try:\\n out_arr[j][i] = float(line_split[4])\\n except IndexError:\\n print(line_split)\\n if i == int((CORNERS[\\\"ur\\\"][\\\"e\\\"] - CORNERS[\\\"bl\\\"][\\\"e\\\"]) / SPACING):\\n i = 0\\n j += 1\\n else:\\n i += 1\\n np.save(\\\"vs30.dat\\\", out_arr)\\n return 0\",\n \"def parse_commandline():\\n parser = optparse.OptionParser()\\n\\n parser.add_option(\\\"-l\\\",\\\"--lamp\\\", default=100, type=int)\\n parser.add_option(\\\"-c\\\",\\\"--doCompile\\\", action=\\\"store_true\\\", default=False)\\n parser.add_option(\\\"--doLamp\\\", action=\\\"store_true\\\", default=False)\\n\\n opts, args = parser.parse_args()\\n\\n return opts\",\n \"def ParseArgsMain():\\n parser = argparse.ArgumentParser() # command-line string parser\\n\\n parser.description = 'vSphereTools version: {}. vSphereTools is a set of scripts from DevOpsHQ to support working with vSphere and virtual machines (VMs) on it, which are based on the pysphere library.'.format(__version__)\\n parser.epilog = 'See examples on GitHub: http://devopshq.github.io/vspheretools/'\\n parser.usage = 'vspheretools [options] [command]'\\n\\n parser.add_argument('-v', '--version', action='store_true', help='Show current version of vSphereTools.')\\n\\n # --- server options:\\n parser.add_argument('-s', '--server', type=str, help='main vSphere Server Cluster, e.g. vcenter-01.example.com.')\\n parser.add_argument('-l', '--login', type=str, help='Username for work with vSphere.')\\n parser.add_argument('-p', '--password', type=str, help='Sphere Userpass.')\\n\\n parser.add_argument('-n', '--name', type=str, help='Name of virtual machine.')\\n\\n parser.add_argument('-gl', '--guest-login', type=str, help='Guest Username for work with Guest OS on VM.')\\n parser.add_argument('-gp', '--guest-password', type=str, help='VM Guest Userpass.')\\n\\n parser.add_argument('-d', '--clone-dir', type=str, help='Directory name on vSphere for clonning virtual machine. \\\"Clones\\\" by default.')\\n parser.add_argument('-t', '--timeout', type=str, help='Operations timeout in seconds, 300s. by default.')\\n\\n # --- commands:\\n parser.add_argument('--status', action='store_true', help='Get virtual machine status.')\\n parser.add_argument('--start', action='store_true', help='Starting virtual machine.')\\n parser.add_argument('--start-wait', action='store_true', help='Starting virtual machine and wait while guest OS started.')\\n parser.add_argument('--stop', action='store_true', help='Stopping virtual machine.')\\n\\n parser.add_argument('--snapshots', action='store_true', help='Get list of all snapshots of virtual machine.')\\n parser.add_argument('--create-snapshot', type=str, nargs='+', help='Create snapshot of VM with options. Example: --create-snapshot name=\\\"Snapshot name\\\" rewrite=True fail-if-exist=False')\\n parser.add_argument('--revert-to-current-snapshot', action='store_true', help='Revert virtual machine to current snapshot.')\\n parser.add_argument('--revert-to-snapshot', type=str, help='Revert virtual machine to snapshot by name.')\\n\\n parser.add_argument('--properties', action='store_true', help='Get all avaliable properties of virtual machine.')\\n parser.add_argument('--get-ip', action='store_true', help='Get ip address of virtual machine.')\\n parser.add_argument('--set-ip-into-teamcity-param', type=str, help='Set up ip address of virtual machine into predefine TeamCity parameter, vm_ip by default.')\\n\\n parser.add_argument('--clone', type=str, help='Clone virtual machine into directory VM_CLONES_DIR with given name.')\\n\\n parser.add_argument('--delete', action='store_true', help='Remove virtual machine by name.')\\n\\n parser.add_argument('--upload-file', type=str, nargs='+', help='Copy file into virtual machine with True to overwrite. Example: --upload-file srcFile dstFile True')\\n parser.add_argument('--download-file', type=str, nargs='+', help='Download file from virtual machine with True to overwrite local file. Example: --download-file srcFile dstFile True')\\n\\n parser.add_argument('--mkdir', type=str, nargs='+', help='Creating directory and all sub-directory in given path with True to create sub-dirs. Example: --mkdir dir_path True')\\n parser.add_argument('--execute', type=str, nargs='+', help=r'Execute program on guest OS with parameters. Example: --execute program=\\\"C:\\\\Windows\\\\System32\\\\cmd.exe\\\" args=\\\"/T:Green /C echo %%aaa%% & echo %%bbb%%\\\" env=\\\"aaa:10, bbb:20\\\" cwd=\\\"C:\\\\Windows\\\\System32\\\" pythonbin=\\\"c:\\\\python27\\\\python.exe\\\" wait=True')\\n\\n parser.add_argument('--not-skip-run', type=str, help='This is parameter for TeamCity support. Scripts executed if \\\"TRUE\\\". Scripts skipped if \\\"FALSE\\\". Otherwise exception raised.')\\n\\n return parser.parse_args()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6423425","0.5811027","0.580129","0.5655842","0.55434406","0.533609","0.53108877","0.53000253","0.5271251","0.5269717","0.5203191","0.51964784","0.5171904","0.5154556","0.5100387","0.5036834","0.5026639","0.5026215","0.5009487","0.49926525","0.49875903","0.49847418","0.49475414","0.49277356","0.4921028","0.4915675","0.48955688","0.4889478","0.48839632","0.48807707","0.48793072","0.4876434","0.48564488","0.48481637","0.4835363","0.48232737","0.48206002","0.48154587","0.47981578","0.47966528","0.47958663","0.47932068","0.4786825","0.4785955","0.4785955","0.47828928","0.47816044","0.47645238","0.4761123","0.47551033","0.47535866","0.47532612","0.47488198","0.47473502","0.4745938","0.47381046","0.47364017","0.4733994","0.4728158","0.47202128","0.47174978","0.4705676","0.47039157","0.4701678","0.4701678","0.46970454","0.46923295","0.46867156","0.4683963","0.46833786","0.46807227","0.46775034","0.46715003","0.46696275","0.46682823","0.46619955","0.46559626","0.46558166","0.465271","0.4647245","0.46458986","0.46412987","0.4641002","0.46406308","0.46352974","0.46347275","0.46324584","0.4627597","0.46274644","0.4627011","0.46266317","0.46186835","0.4607815","0.4602847","0.4594862","0.45923692","0.45890084","0.4588954","0.45848894","0.45839062"],"string":"[\n \"0.6423425\",\n \"0.5811027\",\n \"0.580129\",\n \"0.5655842\",\n \"0.55434406\",\n \"0.533609\",\n \"0.53108877\",\n \"0.53000253\",\n \"0.5271251\",\n \"0.5269717\",\n \"0.5203191\",\n \"0.51964784\",\n \"0.5171904\",\n \"0.5154556\",\n \"0.5100387\",\n \"0.5036834\",\n \"0.5026639\",\n \"0.5026215\",\n \"0.5009487\",\n \"0.49926525\",\n \"0.49875903\",\n \"0.49847418\",\n \"0.49475414\",\n \"0.49277356\",\n \"0.4921028\",\n \"0.4915675\",\n \"0.48955688\",\n \"0.4889478\",\n \"0.48839632\",\n \"0.48807707\",\n \"0.48793072\",\n \"0.4876434\",\n \"0.48564488\",\n \"0.48481637\",\n \"0.4835363\",\n \"0.48232737\",\n \"0.48206002\",\n \"0.48154587\",\n \"0.47981578\",\n \"0.47966528\",\n \"0.47958663\",\n \"0.47932068\",\n \"0.4786825\",\n \"0.4785955\",\n \"0.4785955\",\n \"0.47828928\",\n \"0.47816044\",\n \"0.47645238\",\n \"0.4761123\",\n \"0.47551033\",\n \"0.47535866\",\n \"0.47532612\",\n \"0.47488198\",\n \"0.47473502\",\n \"0.4745938\",\n \"0.47381046\",\n \"0.47364017\",\n \"0.4733994\",\n \"0.4728158\",\n \"0.47202128\",\n \"0.47174978\",\n \"0.4705676\",\n \"0.47039157\",\n \"0.4701678\",\n \"0.4701678\",\n \"0.46970454\",\n \"0.46923295\",\n \"0.46867156\",\n \"0.4683963\",\n \"0.46833786\",\n \"0.46807227\",\n \"0.46775034\",\n \"0.46715003\",\n \"0.46696275\",\n \"0.46682823\",\n \"0.46619955\",\n \"0.46559626\",\n \"0.46558166\",\n \"0.465271\",\n \"0.4647245\",\n \"0.46458986\",\n \"0.46412987\",\n \"0.4641002\",\n \"0.46406308\",\n \"0.46352974\",\n \"0.46347275\",\n \"0.46324584\",\n \"0.4627597\",\n \"0.46274644\",\n \"0.4627011\",\n \"0.46266317\",\n \"0.46186835\",\n \"0.4607815\",\n \"0.4602847\",\n \"0.4594862\",\n \"0.45923692\",\n \"0.45890084\",\n \"0.4588954\",\n \"0.45848894\",\n \"0.45839062\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8179622"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21962,"cells":{"query":{"kind":"string","value":"Parse headers and entries in line, create dictionary and append it to RESULT list."},"document":{"kind":"string","value":"def _parse_header(self, line):\n if self._regex_helper.search_compiled(W._re_header, line):\n if not self.headers:\n for value in re.findall(W._re_header, line):\n self.headers.append(value[0])\n raise ParsingDone\n else:\n # Dictionary which is going to be appended to the returned list\n ret = dict()\n # List of entries\n _entries = list()\n # List of values in WHAT entry\n _what_entry = list()\n for value in re.findall(W._re_header, line):\n _entries.append(value[0])\n for what_index in range(len(self.headers) - 1, len(_entries)):\n _what_entry.append(_entries[what_index])\n _what_entry_string = ' '.join(_what_entry)\n for index in range(len(self.headers)):\n if index < len(self.headers) - 1:\n ret.update({self.headers[index]: _entries[index]})\n else:\n ret.update({self.headers[index]: _what_entry_string})\n self.current_ret['RESULT'].append(ret)\n raise ParsingDone"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def process_line(self, line):\n find_result = re.findall(LINE_REGEX, line)\n line_data = {r[0]: r[1] for r in find_result}\n self.process_url(line_data.get('request_to'))\n self.process_status_code(line_data.get('response_status'))","def process_line(line):\n\n name_comp_list = []\n givenname_comp_list = []\n surname_comp_list = []\n geocode_comp_list = []\n locality_comp_list = []\n date1_comp_list = []\n date2_comp_list = []\n\n # Split the line into the basic fields - - - - - - - - - - - - - - - - - - -\n #\n if (config.in_file_type in ['CSV','CSVQ','TAB','TABQ']):\n # Comma or tabulator separated\n try:\n line_list = config.line_parser.parse(line)\n except:\n log_message('CSV line parsing failed with inout: '+line,'err')\n\n if (len(line_list) < config.input_len):\n log_message('Input line does not contain enough fields,' +\\\n 'fill up with empty fields','warn')\n while (len(line_list) < config.input_len):\n line_list.append('')\n\n config.curr_line_list = line_list # Save current line list\n\n # Extract fields into different component lists - - - - - - - - - - - - - -\n #\n if (config.input_component['name'] != []): # Extract name fields\n for i in config.input_component['name']:\n name_comp_list.append(line_list[i])\n\n else: # Extract givenname and surname into separate components - - - - - -\n if (config.input_component['givenname'] != []): # Extract g-name fields\n for i in config.input_component['givenname']:\n givenname_comp_list.append(line_list[i])\n\n if (config.input_component['surname'] != []): # Extract surname fields\n for i in config.input_component['surname']:\n surname_comp_list.append(line_list[i])\n\n if (config.input_component['geocode'] != []): # Extract geocode fields\n for i in config.input_component['geocode']:\n geocode_comp_list.append(line_list[i])\n\n if (config.input_component['locality'] != []): # Extract locality fields\n for i in config.input_component['locality']:\n locality_comp_list.append(line_list[i])\n\n if (config.input_component['date1'] != []): # Extract date1 fields\n for i in config.input_component['date1']:\n date1_comp_list.append(line_list[i])\n\n if (config.input_component['date2'] != []): # Extract date2 fields\n for i in config.input_component['date2']:\n date2_comp_list.append(line_list[i])\n\n elif (config.in_file_type == 'COL'): # Column based input file - - - - - - -\n\n if (len(line) < config.input_len):\n log_message('Input line is not long enough, fill up with spaces','warn')\n line += ' '*(config.input_len-len(line))\n\n if (config.input_component['name'] != []): # Extract name fields\n for (col_start,length) in config.input_component['name']:\n name_comp_list.append(line[col_start,col_start+length])\n\n else: # Extract givenname and surname into separate components - - - - - -\n if (config.input_component['givenname'] != []): # Extract g-name fields\n for (col_start,length) in config.input_component['givenname']:\n givenname_comp_list.append(line[col_start,col_start+length])\n\n if (config.input_component['surname'] != []): # Extract surname fields\n for (col_start,length) in config.input_component['surname']:\n surname_comp_list.append(line[col_start,col_start+length])\n\n if (config.input_component['geocode'] != []): # Extract geocode fields\n for (col_start,length) in config.input_component['geocode']:\n geocode_comp_list.append(line[col_start,col_start+length])\n\n if (config.input_component['locality'] != []): # Extract locality fields\n for (col_start,length) in config.input_component['locality']:\n locality_comp_list.append(line[col_start,col_start+length])\n\n if (config.input_component['date1'] != []): # Extract date1 fields\n for (col_start,length) in config.input_component['date1']:\n date1_comp_list.append(line[col_start,col_start+length])\n\n if (config.input_component['date2'] != []): # Extract date2 fields\n for (col_start,length) in config.input_component['date2']:\n date2_comp_list.append(line[col_start,col_start+length])\n\n # elif (config.in_file_type == 'SQL'): # - - - - - - - - - - - - - - - - - -\n\n ################################\n # Add later: SQL database access\n ################################\n\n msg = [' Component basic field lists:', \\\n ' Name: '+str(name_comp_list), \\\n ' Given name: '+str(givenname_comp_list), \\\n ' Surname: '+str(surname_comp_list), \\\n ' Geocode: '+str(geocode_comp_list), \\\n ' Locality: '+str(locality_comp_list), \\\n ' Date1: '+str(date1_comp_list), \\\n ' Date2: '+str(date2_comp_list)]\n log_message(msg,'v2')\n\n name_comp = ''\n givenname_comp = ''\n surname_comp = ''\n geocode_comp = ''\n locality_comp = ''\n date1_comp = ''\n date2_comp = ''\n\n # Now clean and then concatenate component lists into strings - - - - - - - -\n #\n if (name_comp_list != []): # Name component\n name_comp = name_comp_list[0] # Start with first field in list\n\n for f in name_comp_list[1:]: # Loop over following fields (if any)\n if (f != ''):\n if (config.input_space_sep['name'] == 1):\n sep = ' ' # Set separator to space between fields\n else:\n sep = '' # No space between fields\n\n # Check field spilling only if space separator is set to ' ' \n #\n if (sep == ' ') and (config.input_check_spilling['name'] == 1):\n sep = check_field_spill(name_comp, f)\n\n name_comp = name_comp+sep+f # Append separator and field\n\n if (givenname_comp_list != []): # Givenname component - - - - - - - - - - -\n givenname_comp = givenname_comp_list[0] # Start with first field in list\n\n for f in givenname_comp_list[1:]: # Loop over following fields (if any)\n if (f != ''):\n if (config.input_space_sep['givenname'] == 1):\n sep = ' ' # Set separator to space between fields\n else:\n sep = '' # No space between fields\n\n # Check field spilling only if space separator is set to ' ' \n #\n if (sep == ' ') and (config.input_check_spilling['givenname'] == 1):\n sep = check_field_spill(givenname_comp, f)\n\n givenname_comp = givenname_comp+sep+f # Append separator and field\n\n if (surname_comp_list != []): # Surname component - - - - - - - - - - - - -\n surname_comp = surname_comp_list[0] # Start with first field in list\n\n for f in surname_comp_list[1:]: # Loop over following fields (if any)\n if (f != ''):\n if (config.input_space_sep['surname'] == 1):\n sep = ' ' # Set separator to space between fields\n else:\n sep = '' # No space between fields\n\n # Check field spilling only if space separator is set to ' ' \n #\n if (sep == ' ') and (config.input_check_spilling['surname'] == 1):\n sep = check_field_spill(surname_comp, f)\n\n surname_comp = surname_comp+sep+f # Append separator and field\n\n if (geocode_comp_list != []): # Geocode component - - - - - - - - - - - - -\n geocode_comp = geocode_comp_list[0] # Start with first field in list\n\n for f in geocode_comp_list[1:]: # Loop over following fields (if any)\n if (f != ''):\n if (config.input_space_sep['geocode'] == 1):\n sep = ' ' # Set separator to space between fields\n else:\n sep = '' # No space between fields\n\n # Check field spilling only if space separator is set to ' ' \n #\n if (sep == ' ') and (config.input_check_spilling['geocode'] == 1):\n sep = check_field_spill(geocode_comp, f)\n\n geocode_comp = geocode_comp+sep+f # Append separator and field\n\n if (locality_comp_list != []): # Locality component - - - - - - - - - - - -\n locality_comp = locality_comp_list[0] # Start with first field in list\n\n for f in locality_comp_list[1:]: # Loop over following fields (if any)\n if (f != ''):\n if (config.input_space_sep['locality'] == 1):\n sep = ' ' # Set separator to space between fields\n else:\n sep = '' # No space between fields\n\n # Check field spilling only if space separator is set to ' ' \n #\n if (sep == ' ') and (config.input_check_spilling['locality'] == 1):\n sep = check_field_spill(locality_comp, f)\n\n locality_comp = locality_comp+sep+f # Append separator and field\n\n if (date1_comp_list != []): # Date1 component - - - - - - - - - - - - - - -\n date1_comp = date1_comp_list[0] # Start with first field in list\n\n for f in date1_comp_list[1:]: # Loop over following fields (if any)\n if (f != ''):\n if (config.input_space_sep['date1'] == 1):\n sep = ' ' # Set separator to space between fields\n else:\n sep = '' # No space between fields\n\n # Check field spilling only if space separator is set to ' ' \n #\n if (sep == ' ') and (config.input_check_spilling['date1'] == 1):\n if (date1_comp[-1] != ' ') and (f[0] != ' '):\n tmp_list0 = date1_comp.split()\n tmp_list1 = f.split()\n check_word = tmp_list0[-1]+tmp_list1[0]\n\n if (check_word in ['jan','feb','mar','apr','may','jun','jul','aug', \\\n 'sep','oct','nov','dec','january','february','march','april', \\\n 'may','june','july','august','september','october','november', \\\n 'december']):\n\n sep = '' # Set separator to no space\n msg = ' Correct date1 word spilling: \"'+date1_comp+'\",\"'+f+'\"'\n log_message(msg,'v1')\n\n date1_comp = date1_comp+sep+f # Append separator and field\n\n if (date2_comp_list != []): # Date2 component - - - - - - - - - - - - - - -\n date2_comp = date2_comp_list[0] # Start with first field in list\n\n for f in date2_comp_list[1:]: # Loop over following fields (if any)\n if (f != ''):\n if (config.input_space_sep['date2'] == 1):\n sep = ' ' # Set separator to space between fields\n else:\n sep = '' # No space between fields\n\n # Check field spilling only if space separator is set to ' ' \n #\n if (sep == ' ') and (config.input_check_spilling['date2'] == 1):\n if (date2_comp[-1] != ' ') and (f[0] != ' '):\n tmp_list0 = date1_comp.split()\n tmp_list1 = f.split()\n check_word = tmp_list0[-1]+tmp_list1[0]\n\n if (check_word in ['jan','feb','mar','apr','may','jun','jul','aug', \\\n 'sep','oct','nov','dec','january','february','march','april', \\\n 'may','june','july','august','september','october','november', \\\n 'december']):\n\n sep = '' # Set separator to no space\n msg = ' Correct date1 word spilling: \"'+date1_comp+'\",\"'+f+'\"'\n log_message(msg,'v1')\n\n date2_comp = date2_comp+sep+f # Append separator and field\n\n # Check if name component is given or givenname and surname separately - - -\n #\n if (config.input_component['givenname'] != []) or \\\n (config.input_component['surname'] != []):\n name_comp = [givenname_comp, surname_comp]\n\n msg = [' Components:', \\\n ' Name: \"'+str(name_comp)+'\"', \\\n ' Geocode: \"'+geocode_comp+'\"', \\\n ' Locality: \"'+locality_comp+'\"', \\\n ' Date1: \"'+date1_comp+'\"', \\\n ' Date2: \"'+date2_comp+'\"']\n log_message(msg,'v1')\n\n return [name_comp, geocode_comp, locality_comp, date1_comp, date2_comp]","def _result_to_dict(line):\n f = line.split(':;')\n return {'server': f[0], 'os_name': f[1], 'status': f[2], 'ipv4': f[3]}","def _parse_line(line: Match[str]) -> dict:\n request = line.group(\"request\")\n request = request.split()\n req_method = request[0] # GET, POST, PUT, etc.\n url = request[1]\n x = url.split(\"/\")[3:]\n uri = f'/{\"/\".join(x)}'\n\n timestamp = line.group(\"timestamp\") # timestamp in ISO format\n timestamp = MyTime._try_isoformat(timestamp, tzinfo=\"UTC\").dt\n\n res = {\n \"url\": url,\n \"uri\": uri,\n \"req_method\": req_method,\n \"timestamp\": timestamp,\n \"user_agent\": line.group(\"user_agent\"),\n }\n return res","def parse_line(line):\n parts = line.strip().split('\\t')\n\n output = {}\n\n if len(parts) != len(COLUMNS):\n raise Exception('Incorrect number of columns in line.', parts, COLUMNS)\n\n for key, value in zip(COLUMNS, parts):\n if key == 'attributes':\n output[key] = parse_attributes(value)\n elif key == 'start' or key == 'stop':\n output[key] = int(value)\n else:\n output[key] = value\n\n return output","def _parse_line(self, line):\n fields = line.split('|', 4) # stop splitting after fourth | found\n line_info = {'raw_message': line}\n if len(fields) == 5:\n line_info.update(dict(zip(self._fieldnames, fields)))\n return line_info","def _parse_header(lines):\n # The dict into which we will store header fields.\n header = {}\n # Loop over lines in the header.\n for line in lines:\n # Find the first colon.\n index = line.index(COLON)\n # Up to the colon is the field name.\n name = line[: index]\n # After the colon is the field value.\n value = line[index + 1 :]\n # The field value may begin or end with extra space, which is not \n # significant. Remove it.\n value = value.strip()\n # Store the field.\n header[name] = value\n # All done.\n return header","def process_line(self,\n event_file,\n raw_log_line,\n header_length=29,\n log_filename=\"\"):\n\n event_data = {}\n for filter_name, regex in self._filters_dict.items():\n match = regex.search(raw_log_line)\n if match:\n match_data = match.groups()\n event_data[filter_name] = match_data\n\n if event_data:\n if log_filename:\n event_data[\"log_filename\"] = log_filename\n event_data[\"raw_log_line\"] = raw_log_line.rstrip()[header_length:]\n event_data[\"system_timestamp\"] = raw_log_line[1:27]\n event_data[\"matched_timestamp\"] = \\\n datetime.datetime.now().strftime(TIMESTAMP_FORMAT)\n event_file.write(json.dumps(event_data) + \"\\n\")\n event_file.flush()","def get_data(contents):\n\n header = {}\n copy = contents.split(\"\\n\")\n\n header_contents = dict(\n start_date=\"Start Date\",\n end_date=\" End Date\",\n subject=\" Subject\",\n experiment=\" Experiment\",\n group=\" Group\",\n box=\" Box\",\n start_time=\" Start Time\",\n end_time=\" End Time\",\n program=\" Program\",\n msn=\" MSN\",\n )\n\n for line in copy:\n for key in header_contents:\n heading = line.split(\":\")\n if heading[0] == header_contents[key]:\n if key == \"start_time\" or key == \"end_time\":\n header[key] = (\n heading[1].lstrip() + \":\" + heading[2] + \":\" + heading[3]\n )\n else:\n header[key] = heading[1].lstrip()\n\n data = {}\n copy = contents.split()\n\n uppercase = string.ascii_uppercase\n\n idx = []\n for i, val in enumerate(copy):\n if val[0] in uppercase and val[1] == \":\":\n idx.append(i)\n\n for i, j in zip(idx[:-1], idx[1:]):\n data[copy[i].lower()[0]] = [\n timestamp for timestamp in copy[i + 1 : j] if timestamp[-1] != \":\"\n ]\n\n return header, data","def parse_line(cls, line):\n regex = re.compile(cls.pattern)\n m = regex.search(line)\n if m:\n data = m.groupdict()\n data = cls.post_process(data)\n if cls.date_format:\n data['time'] = cls.convert_time(data['time'])\n else:\n data['time'] = datetime.now()\n return data\n else:\n return {}","def process(raw):\n entry = { }\n cooked = [ ]\n\n for line in raw:\n line = line.strip()\n if len(line) == 0 or line[0]==\"#\" :\n continue\n parts = line.split(';')\n if len(parts) == 3:\n entry[\"description\"] = parts[0].strip() #adding key and values to the dict\n entry[\"long\"] = parts[1].strip()\n entry[\"lat\"] = parts[2].strip()\n cooked.append(entry) #add this dict entry into the array\n entry = { }\n continue\n else:\n raise ValueError(\"Trouble wiht line: '{}'\\n\".format(line))\n \n return cooked #returning an array of dicts","def agline(line):\n\n vals = {}\n x = ['date', 'movie', 'offset', 'well', 'gen', 'flarem', 'flares', \n 'chargem', 'charges', 'charget', 'escdm', 'escds', 'escddur', 'escmm', 'escms', \n 'escmdur']\n y = line.strip('\\n').split(',')[0:16]\n z = zip(x, y)\n\n for item in z:\n vals[item[0]] = item[1]\n\n return(vals)","def process(line):\n output = {}\n\n fields = line.split(\" \")\n if len(fields) < 6:\n return False\n \n output[\"log_level\"] = fields[0]\n \n # Convert date/time to object or reject line\n try:\n output[\"datetime\"] = datetime.datetime.strptime(\n \"%s %s\" % (fields[1], fields[2]),\n \"%Y-%m-%d %H:%M:%S,%f\"\n )\n except ValueError:\n return False\n \n output[\"logger\"] = fields[3]\n output[\"thread\"] = fields[4]\n output[\"process\"] = fields[5]\n output[\"message\"] = \" \".join(fields[6:])\n \n return output","def parse(self, src, line):\n r = line.split('\\t')\n p = {}\n if src == 'sf':\n p['businessID'] = r[0]\n p['name'] = r[1]\n p['address'] = r[2]\n p['city'] = r[3]\n p['state'] = r[4]\n p['zip'] = r[5]\n p['latitude'] = r[6]\n p['longitude'] = r[7]\n p['phone'] = r[8]\n elif src == 'nyc':\n p['businessID'] = r[0]\n p['name'] = r[1]\n # nyc separates the building number from the street name\n p['address'] = ' '.join([r[3].strip(), r[4].strip()])\n p['city'] = 'NYC'\n p['state'] = 'NY'\n p['zip'] = r[5]\n p['latitude'] = None\n p['longitude'] = None\n p['phone'] = r[6]\n return p","def ParseLine(line):\n fields = line.split()\n ip = fields[0]\n datestr = ' '.join(fields[3:5])[1:-1]\n timestamp = datetime.strptime(\n datestr, '%d/%b/%Y:%H:%M:%S %z'\n ).timestamp()\n command = fields[5][1:]\n uri = fields[6]\n protocol = fields[7][:-1]\n status = int(fields[8])\n size = int(fields[9])\n meta = [var.strip('\"') for var in fields[11:-1]]\n return {\n 'timestamp': timestamp,\n 'ip': ip,\n 'command': command,\n 'uri': uri,\n 'protocol': protocol,\n 'status': status,\n 'size': size,\n 'meta': meta\n }","def _parse_line(self):\n # check if line contains a rule or not\n stripped = self._line.strip()\n if not stripped or stripped.startswith(\"#\"):\n return None\n\n # strip out double quotes from values, and simplify equals strings\n simplified = self._line.replace(\"==\", \"=\").replace('\"', '')\n\n # return a dictionary formed from the key=value pairs found in line\n return dict(f.strip().split(\"=\", 1) for f in simplified.split(\",\"))","def do_Promo_line_parse (Promo_line, line_number, filehash) :\n result = [filehash,\n line_number,\n Promo_line[0:8].strip(),\n Promo_line[9:13].strip(),\n Promo_line[14:19].strip(),\n Promo_line[20:26].strip().lstrip('0'), # Spec indicates numerical field\n Promo_line[27:30].strip().lstrip('0'), # Spec indicates numerical field\n Promo_line[31:40].strip(),\n Promo_line[41:49].strip(),\n Promo_line[50:].strip()\n ]\n return result\n # Having the line number passed in is ugly, but kind of works :/\n # Having all the field extraction explicit is kind of ugly too...\n # We're using the hash here to link? Yeah, that's because Python\n # doesn't know what the autonumbered load table is up to in the\n # DB when it starts to coalesce the raw files together.","def agline2(line):\n \n vals = {}\n y = line.strip('\\n').split(',')\n y.extend(y[0].strip('.MTS').split('_'))\n \n #print(y)\n \n x = ['movie', 'moviecode', 'offset', 'well', 'agmin', 'agsec', 'agdur', \n 'agtype', 'agcomm', 'escmin', 'escsec', 'escdur', 'esctype', 'escbeh', \n 'esccomm', 'gen', 'date', 'assay', 'fps', 'flyid', 'side', 'moviepart']\n \n z = zip(x, y)\n\n for item in z:\n vals[item[0]] = item[1]\n\n return(vals)","def _read_header_line_1(self, lines: list) -> dict:\n fields = (\n \"model_id\",\n \"unit_id\",\n \"software_level\",\n \"message_number\",\n \"message_subclass\",\n )\n if self._is_ct25k():\n indices = [1, 3, 4, 6, 7, 8]\n else:\n indices = [1, 3, 4, 7, 8, 9]\n values = [split_string(line, indices) for line in lines]\n return values_to_dict(fields, values)","def get_line_desc(self, line):\n return dict(zip(self.header, line))","def parse_header(line):\n # 2015-09-27 14:55:41 UTC [192.0.2.1]:56721 -> [192.0.2.2]:443 (37):\n m = re.match(r'(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2} \\S+) \\[(.+?)\\]:(\\d+) -> \\[(.+?)\\]:(\\d+) \\((\\d+|EOF)\\):?', line)\n if not m:\n raise LogSyntaxError(line)\n res = {}\n res['timestamp'] = m.group(1)\n res['src_addr'] = m.group(2)\n res['src_port'] = int(m.group(3))\n res['dst_addr'] = m.group(4)\n res['dst_port'] = int(m.group(5))\n if m.group(6) == 'EOF':\n res['eof'] = True\n else:\n res['eof'] = False\n res['size'] = int(m.group(6))\n return res","def readHeaders(lines):\n\n result = {}\n for line in lines:\n if line[0] == \"#\":\n continue\n if line.strip() == \"\":\n continue\n key, value = line.split(\":\", 1)\n result[key.strip()] = parseSloppily(value)\n return result","def make_entry(line):\n #focus on relevant parts\n parts = line.split(\" - \")\n visitor_id = parts[0]\n subparts = parts[1].split('\"')\n method_and_uri = subparts[1]\n method_and_uri_parts = method_and_uri.split(\" \")\n method = method_and_uri_parts[0]\n uri = method_and_uri_parts[1]\n d = dict()\n d[\"visitor_id\"] = visitor_id\n d[\"method\"] = method\n d[\"uri\"] = uri\n return d","def parse_ensembl_line(line, header):\n line = line.rstrip().split(\"\\t\")\n header = [head.lower() for head in header]\n raw_info = dict(zip(header, line))\n\n ensembl_info = {}\n\n for word in raw_info:\n value = raw_info[word]\n if not value:\n continue\n\n if \"chromosome\" in word:\n ensembl_info[\"chrom\"] = value\n if \"gene name\" in word:\n ensembl_info[\"hgnc_symbol\"] = value\n if \"hgnc id\" in word:\n ensembl_info[\"hgnc_id\"] = int(value.split(\":\")[-1])\n if \"hgnc symbol\" in word:\n ensembl_info[\"hgnc_symbol\"] = value\n if \"strand\" in word:\n ensembl_info[\"strand\"] = int(value)\n\n update_gene_info(ensembl_info, word, value)\n update_transcript_info(ensembl_info, word, value)\n update_exon_info(ensembl_info, word, value)\n update_utr_info(ensembl_info, word, value)\n update_refseq_info(ensembl_info, word, value)\n return ensembl_info","def _read_header_line_2(lines: list) -> dict:\n fields = (\n \"detection_status\",\n \"warning\",\n \"cloud_base_data\",\n \"warning_flags\",\n )\n values = [[line[0], line[1], line[3:20], line[21:].strip()] for line in lines]\n return values_to_dict(fields, values)","def parse(line):\n return dict([pair.split(':') for pair in line.split()])","def split(self, line):\n parts = line.split()\n return {\n 'size': 0 if parts[9] == '-' else int(parts[9]), \n 'file_requested': parts[6]\n }","def _read_entry_detail(self, line):\n account_number = 0\n try:\n account_number = int(line[12:29].strip().replace('-', ''))\n except ValueError as err:\n print('Error parsing account number field -> ' + str(err))\n\n result_dict = {'Transaction Code': line[1:3],\n 'ReceivingID': line[3:11],\n 'CheckDigit': line[11],\n 'Account Number': account_number,\n 'Amount': int(line[29:39]) / 100,\n 'Individual ID': line[39:54],\n 'Receiver Name': line[54:76].strip(),\n 'DiscretionaryData': line[76:78],\n 'AddendaIndicator': line[78],\n 'TraceNumber': line[79:94]}\n\n self.entries.append(result_dict)","def parse_header(header_lines):\n info = {}\n for line in header_lines:\n if line.startswith('Citation'):\n info['Citation'] = line.split()[-1].strip()\n elif ':' in line:\n try:\n field, value = map(strip,line.split(':',1))\n info[field] = value\n except ValueError:\n #no interesting header line\n continue\n else:\n continue\n return Info(info)","def _read_batch_header(self, line):\n try:\n effective_entry_date = datetime.strptime(line[69:75], '%y%m%d')\n except ValueError as err:\n print('Error parsing effective entry date -> ' + str(err))\n effective_entry_date = '00000000'\n\n batch_header_dict = {'Service Class Code': line[1:4],\n 'Company Name': line[4:20].strip(),\n 'Company Discretionary Data': line[20:40].strip(),\n 'Company ID': line[40:50].strip(),\n 'SEC Code': line[50:53],\n 'Company Entry Description': line[53:63].strip(),\n 'Company Descriptive Date': line[63:69].strip(),\n 'Effective Entry Date': effective_entry_date,\n 'Settlement Date Julian': line[75:78],\n 'Originator Status Code': line[78],\n 'Originating DFI ID': line[79:87],\n 'Batch Number': line[87:94]}\n self.batch_headers.append(batch_header_dict)","def process_entries(entries):\n data = {}\n for e in entries:\n e = e.strip()\n if e and not e.startswith('#') and not e.startswith('-e'):\n project, version = e.split('==')\n if not version:\n raise ValueError(\"Unexpected syntax '{0}'\".format(e))\n data[project] = version\n return data","def parse_line(cls, line):\n assert isinstance(line, bytes)\n\n match = HEADER_FIELD_REGEX.match(line)\n\n if not match:\n raise HeaderParseError(line)\n\n name, content = (s.decode(\"ascii\").strip() for s in match.groups(b\"\"))\n name = name.lower()\n\n if name != \"set-cookie\" or is_rfc1123_datetime(content):\n content = cls.split_field_content(content)\n\n return (name, content)","def parse_results(stdout):\n for line in stdout.split(b\"\\n\"):\n log.debug(\"processing line %s\", line)\n fields = line.strip().split()\n if len(fields) != 9:\n continue\n metric = fields[1].decode(\"ascii\")\n info = lm_function_map[metric]\n dtype = info['dtype']\n yield {\n \"metric\": metric,\n \"n_compart\": int(fields[3]),\n \"n_exclude\": int(fields[4].strip(b\"()\")),\n \"total\": dtype(fields[2]),\n \"min\": dtype(fields[5]),\n \"avg\": float(fields[6]),\n \"max\": dtype(fields[7]),\n \"units\": info[\"units\"],\n }","def analyseHeaders(line):\n\n csvlist=[]\n for col in line:\n \tfound=False\n \tcol=col.lower()\n\tfor key in hostinfo:\n\t if col in hostinfo[key]['aka']:\n\t \tcsvlist.append(key)\n\t\tfound=True\n\t\tcontinue\n\tif not found:\n\t csvlist.append('-')\n\n if verbFlag:\n \tprint \"CSV to key mapping\"\n\tfor i in range(len(csvlist)):\n\t try:\n\t \tline[i]\n\t except IndexError:\n\t \tcontinue\n\t if csvlist[i]=='-':\n\t \tprint \"\\t%s-> unmapped\" % line[i]\n\t else:\n\t\tprint \"\\t%s->%s\" % (line[i], csvlist[i])\n\n return csvlist","def _parse_head(line):\n retval = {}\n m = re.match(\n '[0-9]+: (?P<if>\\w+\\d{1,3}): <(?P<flags>[^>]+)> mtu (?P<mtu>[0-9]+)',\n line\n )\n if m:\n retval['ifname'] = m.group('if')\n retval['mtu'] = int(m.group('mtu'))\n retval['flags'] = m.group('flags').split(',')\n return retval","def parse_line(self, line):\n line = line.strip()\n log.debug(\"Parsing line: '{}'\".format(line))\n if len(line) == 0:\n log.warning(\"Zero length line detected\")\n return\n split = line.split(DELIMETER)\n key = split[0]\n if key in FORMATS:\n log.debug(\"Using formatter for key: {}\".format(key))\n formatter = FORMATS[key]\n for (name, parser), value in zip(formatter,split[1:]):\n self._params[name] = parser(value)\n log.info(\"Parameters: {}\".format(self._params))\n self.notify_watchers()\n else:\n log.debug(\"Invalid key: {}\".format(key))","def _parse_handle_section(lines):\n data = {}\n key = ''\n next(lines)\n\n for line in lines:\n line = line.rstrip()\n if line.startswith('\\t\\t'):\n if isinstance(data[key], list):\n data[key].append(line.lstrip())\n elif line.startswith('\\t'):\n key, value = [i.strip() for i in line.lstrip().split(':', 1)]\n key = normalize(key)\n if value:\n data[key] = value\n else:\n data[key] = []\n else:\n break\n\n return data","def _process_line(line, status):\n\n if line.startswith(ADAPTER_LINE_STARTSWITH):\n status.add_block('adapter', 'name', line)\n return\n elif line.startswith(EXIT_LINE_STARTSWITH):\n status.consolidate()\n return\n\n key, value = [el.strip(' \\t\\r\\n') for el in line.split(':', 1)]\n\n if key in KEY_TO_CONTEXT.keys():\n status.add_block(KEY_TO_CONTEXT[key], key, value)\n else:\n status.set_property(key, value)","def _read_header(self, line):\n try:\n creation_date = datetime.strptime(line[23:33], '%y%m%d%H%M')\n except ValueError as err:\n print('Error parsing file creation date -> ' + str(err))\n creation_date = '000000'\n\n self.file_header = {'Priority Code': line[1:3],\n 'Immediate Destination': line[3:13].strip(),\n 'Immediate Origin': line[13:23].strip(),\n 'Creation Date': creation_date,\n 'File ID Modifier': line[33],\n 'Record Size': int(line[34:37].strip()),\n 'Blocking Factor': int(line[37:39]),\n 'Format Code': line[39],\n 'Immediate Destination Name': line[40:63].strip(),\n 'Immediate Origin Name': line[63:86].strip(),\n 'Reference Code': line[86:93]}","def Process_line(line, summary):\n line = line.lower() # lower all words in the line\n line = line.translate(str.maketrans('','', string.punctuation)) # Remove all punctuation\n words = line.split() # Split word from the line\n add_word(words, summary) # Add word to dictionary","def parse(self, line):\n try:\n (year, month, day, hour, minute, second, microseconds, offset_hour, offset_minute, source, process, logentry) = re.match('^(\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d)T(\\d\\d):(\\d\\d):(\\d\\d)\\.([\\d]+)\\+(\\d\\d):(\\d\\d) ([a-z]+)\\[([a-zA-Z0-9_.]+)\\]: ([0-9a-z-A-Z\\-_\\.\\[\\]:\\?\\#\\\",/\\ ={}\\'\\(\\)<>]+)$', line).groups()\n except:\n pass\n \n try:\n parsed_data = dict()\n parsed_data['timestamp'] = \" \".join([\"-\".join([year, month, day]), \":\".join([hour, minute, second])])\n parsed_data['log_time'] = datetime.datetime(int(year), int(month), int(day), int(hour), int(minute), int(second))\n parsed_data['log_source'] = source\n parsed_data['log_type'] = process\n except (AttributeError, UnboundLocalError):\n PARSE_ERRORS.append(line)\n return False\n\n #TODO: This still needs work on spaces in values surrounded by \" \" \n if parsed_data['log_source'] == \"heroku\":\n if logentry.__len__() > 1:\n logentry = re.sub(', ', ',', logentry)\n line_chunks = re.split(' ', logentry)\n for chunk in line_chunks:\n line_chunks = re.split('=', chunk)\n if line_chunks.__len__() > 2:\n #fwd and path are a little clunky to parse\n pass\n elif line_chunks.__len__() > 1:\n parsed_data[line_chunks[0]] = line_chunks[1]\n else:\n pass\n else:\n return False\n else:\n # TODO: [app] \n # Needs parsing. Do that here.\n return False\n\n return parsed_data","def parse(lines): \n replied = len(lines)\n avg_delay, lost = 0, 0\n qos = 1.0\n \n if replied != 0:\n for line in lines:\n line.strip() #remove leading and trailing spaces\n \"\"\"\n Each line has the following fields:\n [status code] [reply time (seconds since epoch)] [source IP] [source url] [source query] [serving delay]\n \n e.g.:\n 200 1296756182 192.168.10.2 /home.php ?N=192 11045\n 200 1296756183 192.168.10.2 /home.php ?N=192 230036\n 200 1296756183 192.168.10.2 /home.php ?N=192 230684\n \"\"\"\n status, time, sourceIP, url, query, delay = line.split()\n \n time = int(time)\n delay = int(delay)\n \n if delay > DEADLINE:\n lost += 1\n avg_delay += delay\n avg_delay /= replied\n qos = (replied - lost) / replied\n\n return {'replied': replied, 'delay' : avg_delay, 'qos' : qos, 'lost': lost}","def collect_response(response_lines):\n response_dict = {}\n for entry in filter(None, response_lines):\n prefix = entry[0]\n if prefix in response_dict:\n response_dict[prefix] += [entry]\n else:\n response_dict[prefix] = [entry]\n return response_dict","def parse_header_parameters(line):\n parts = _parseparam(\";\" + line)\n key = parts.__next__().lower()\n pdict = {}\n for p in parts:\n i = p.find(\"=\")\n if i >= 0:\n has_encoding = False\n name = p[:i].strip().lower()\n if name.endswith(\"*\"):\n # Lang/encoding embedded in the value (like \"filename*=UTF-8''file.ext\")\n # https://tools.ietf.org/html/rfc2231#section-4\n name = name[:-1]\n if p.count(\"'\") == 2:\n has_encoding = True\n value = p[i + 1 :].strip()\n if len(value) >= 2 and value[0] == value[-1] == '\"':\n value = value[1:-1]\n value = value.replace(\"\\\\\\\\\", \"\\\\\").replace('\\\\\"', '\"')\n if has_encoding:\n encoding, lang, value = value.split(\"'\")\n value = unquote(value, encoding=encoding)\n pdict[name] = value\n return key, pdict","def addline(self, line):\n # If the line begins with whitespace, assume it is a continuation of\n # the previous line, and append it to the last value read. I'm not\n # sure how legit this is but all examples of multi-line headers\n # I've seen seem to follow this pattern. It is possible that\n # the previous line ending with ; is a more reliable indicator.\n if line.startswith('\\t'):\n # Since we are using OrderedDict, can get the most recently\n # added key.\n key = list(self.keys())[-1]\n vals = [ll.strip() for ll in line[1].split(';')]\n self[key].extend(vals)\n else:\n idx = line.index(':')\n key = line[:idx]\n vals = [ll.strip() for ll in line[idx+1:].split(';')]\n self[key] = vals","def read(self):\r\n entById = {}\r\n entsByName = {}\r\n header = 'HEADER '\r\n readheader = False\r\n for line in self.file:\r\n e = self.parseLine(line)\r\n if e:\r\n entById[int(e[\"id\"])] = e\r\n ids = e.get(e[\"name\"],[])\r\n ids.append(e[\"id\"])\r\n entsByName[e[\"name\"]] = list(set(ids))\r\n elif 'HEADER' in line:\r\n readheader = True\r\n elif readheader:\r\n if 'ENDSEC' in line:\r\n readheader = False\r\n else:\r\n header += line\r\n \r\n return [entById, entsByName, header]","def parse_line(line, patterns=None):\n if patterns is None:\n patterns = LINE_PATTERNS\n\n for line_re in patterns:\n match = line_re.match(line)\n if match:\n data = match.groupdict()\n av_pairs = data['av_pairs']\n data['av_pairs'] = cleanup_av_pairs(av_pairs)\n return data\n\n return None","def parse_header_block(lines):\n data = [line for line in lines[:MAX_HEADER_HEIGHT] if line.strip()]\n if not data or not INVITATION_RE.match(data[0]):\n return None\n out = {'number':None, 'type':None, 'date':None, 'time':None, 'place':None, 'datetime':None}\n for item in data:\n # typ a poradove cislo zastupitelstva\n m = TITLE_RE.match(item)\n if m:\n out['number'] = m.group(1).strip()\n out['type'] = m.group(2).strip()\n\n # den konani zastupitelstva\n m = TERM_DATE_RE.match(item)\n if m:\n try:\n out['date'] = date(int(m.group(3).strip()), int(m.group(2).strip()), int(m.group(1).strip()))\n except ValueError:\n pass\n\n # cas konani zastupitelstva\n m = TERM_TIME_RE.match(item)\n if m:\n try:\n out['time'] = time(int(m.group(1).strip()), int(m.group(2).strip()))\n except ValueError:\n pass\n\n # misto konani zastupitelstva\n m = PLACE_RE.match(item)\n if m:\n out['place'] = m.group(1).strip()\n\n # poskladani kompletniho datetime objektu\n out['datetime'] = out['date'] and out['time'] and \\\n datetime.combine(out['date'], out['time']) or None\n\n return out","def parse_parameters_file(lines):\n param_dict = {}\n for line in lines:\n line = line.strip()\n if line:\n (param, values) = line.split('\\t')\n param_dict[param] = values.split(',')\n return param_dict","def parse_line(self, line):\n\n kv_match = self.kv_rex.match(line)\n\n if kv_match:\n kv_dict = kv_match.groupdict()\n kv_key = kv_dict['key']\n kv_value = kv_dict['value']\n\n if 'time_' in kv_key:\n kv_unit = kv_dict['unit']\n\n if not kv_key in self.kv_times:\n self.kv_times[kv_key] = {'unit': kv_unit, 'values': []}\n\n self.kv_times[kv_key]['values'].append(float(kv_value))\n else:\n if not kv_key in self.kv_counts:\n self.kv_counts[kv_key] = 0.0\n\n self.kv_counts[kv_key] += float(kv_value)","def map_line(reader, headers):\n\n readings = {}\n\n line = reader.readline()\n\n if len(line) == 0:\n raise EOFError('That\\'s all the data!')\n\n line = line.rstrip()\n\n value_strings = line.split(' ')\n for i, string in enumerate(value_strings):\n if string != 'NaN':\n value = float(string)\n\n if i < len(headers):\n if headers[i]['is_point']:\n value = get_decimal_degrees(value)\n key = headers[i]['name'] + \"-\" + headers[i]['units']\n readings[key] = value\n\n # Provide generic timestamp regardless of type for iterator\n # convenience\n # Keep originals for those interested\n if 'm_present_time-timestamp' in readings:\n readings['timestamp'] = readings['m_present_time-timestamp']\n elif 'sci_m_present_time-timestamp' in readings:\n readings['timestamp'] = readings['sci_m_present_time-timestamp']\n\n return readings","def task1_mapper():\n line_count = 0\n for line in sys.stdin:\n # Clean input and split it\n lines = line.strip().split(\",\")\n line_count += 1\n # Check that the line is of the correct format and filtering the HEADER record \n # If line is malformed, we ignore the line and continue to the next line\n if line_count == 1:\n continue\n else:\n if len(lines) != 12:\n continue\n \n category = lines[3].strip()\n videoid = lines[0].strip()\n country = lines[11].strip()\n k_key = category+','+videoid\n\n print(\"{}\\t{}\".format(k_key, country))","def process_log(log_file):\n result_list = []\n file_root = get_fname_root(log_file)\n\n with open(log_file) as l_file:\n reading_steps = False\n result_dict = {}\n for line in l_file:\n line = line.strip()\n if STEP_PAT.match(line):\n reading_steps = True\n result_dict[FILE_NAME] = file_root\n result_dict[TIMESTEP] = int(line.split()[2])\n elif reading_steps:\n if len(line) == 0:\n break\n s_line = line.split()\n if s_line[0] == TOTENG:\n for key_id, key in enumerate([TOTENG, KINENG, TEMP]):\n result_dict[key] = float(s_line[2 + key_id * 3])\n elif s_line[0] == POTENG:\n for key_id, key in enumerate([POTENG, E_BOND, E_ANGL]):\n result_dict[key] = float(s_line[2 + key_id * 3])\n elif s_line[0] == E_DIHED:\n for key_id, key in enumerate([E_DIHED, E_IMPRO, E_VDWL]):\n result_dict[key] = float(s_line[2 + key_id * 3])\n elif s_line[0] == E_COUL:\n for key_id, key in enumerate([E_COUL, E_LONG, PRESS]):\n result_dict[key] = float(s_line[2 + key_id * 3])\n result_list.append(dict(result_dict))\n else:\n # when stop matching, done reading file (either by normal or abnormal termination)\n break\n\n return result_list","def _parse_line(self, line):\n msg_info = {'raw_message': line}\n line_split = line.split(None, 2)\n try:\n msg_info['timestamp'] = datetime.strptime(' '.join(line_split[:2]), self.time_format)\n msg_info['message'] = line_split[2]\n except (ValueError, IndexError):\n pass\n return msg_info","def process_line(nlp, line, parsed_file):\n m = json.loads(line)\n if \"highlights\" in m:\n if m['sentences'] != '' and m['sentences'] != [] and m['sentences'] != [''] and m['highlights'] != '':\n m[\"highlights_ud\"] = dependency_parse(nlp, m['highlights'])\n m[\"sentences_ud\"] = dependency_parse(nlp, m['sentences'])\n else:\n if m['sentences'] != '' and m['sentences'] != [] and m['sentences'] != ['']:\n m[\"sentences_ud\"] = dependency_parse(nlp, m['sentences'])\n if \"sentences_ud\" in m:\n parsed_file.write(json.dumps(m))\n parsed_file.write('\\n')","def process_query(query_file):\r\n query_data = query_file.readlines()\r\n query_dict = {}\r\n x = 1 \r\n search_dict = {}\r\n search_dict['username'] = query_data[x].strip('\\n')\r\n x += 1\r\n operation_list = []\r\n \r\n while query_data[x] != 'FILTER\\n': \r\n operation_list.append(query_data[x].strip('\\n'))\r\n x += 1\r\n \r\n search_dict['operations'] = operation_list \r\n query_dict['search'] = search_dict \r\n x += 1\r\n \r\n filter_dict = {}\r\n filter_format(filter_dict, query_data, 'name-includes', x)\r\n filter_format(filter_dict, query_data, 'location-includes', x)\r\n filter_format(filter_dict, query_data, 'follower', x)\r\n filter_format(filter_dict, query_data, 'following', x)\r\n query_dict['filter'] = filter_dict\r\n \r\n present_dict = {}\r\n sort_by = query_data[-2].strip('sort-by ')\r\n present_dict['sort-by'] = sort_by.strip('\\n')\r\n \r\n format_type = query_data[-1].lstrip('format ')\r\n present_dict['format'] = format_type\r\n query_dict['present'] = present_dict\r\n \r\n return query_dict","def test_parseLine1(mocker):\n \n # given: setup test framework\n worker = Worker()\n testString = \"12Nov2019,Teacher,Brighter Futures,12000\"\n expectedResult = {\n 'date': '2019-11-12',\n 'job_title': 'Teacher',\n 'company_name': 'Brighter Futures',\n 'salary': 12000\n }\n \n # when:\n result = worker.parseLineCSV(testString)\n \n # then:\n assert result == expectedResult","def process_query (file):\n\n # initialize all the dictionaries and lists we will be using\n query_data = {}\n query_data ['search'] = {'operations':[]}\n query_data ['filter'] = {}\n query_data ['present'] = {}\n\n temp = ''\n\n file.readline() # for when the file says SEARCH\n\n query_data ['search']['username'] = file.readline().strip()\n\n temp = file.readline().strip()\n while temp != 'FILTER': # go until the the filter section\n query_data ['search']['operations'].append (temp)\n temp = file.readline().strip()\n\n temp = file.readline().strip()\n while temp != 'PRESENT': # go until the present section\n # we make the key everything from the beginning to the first space\n # then the value is everything after the first space\n query_data ['filter'][temp[:temp.find(' ')]] = temp[temp.find(' ') + 1:]\n temp = file.readline().strip()\n\n temp = file.readline().strip()\n while temp != '': # go until the end of the file\n # same process as the previous while loop\n query_data ['present'][temp[:temp.find(' ')]] = temp[temp.find(' ') + 1:]\n temp = file.readline().strip()\n\n return query_data","def _parser(self,\n search_str):\n return {line_index: parsed_line_keys for (line_index, parsed_line_keys)\n in enumerate(self._load_line(search_str=search_str))\n if parsed_line_keys\n }","def process_header_request(self, request, http_s_obj):\n response_dict = {}\n data = request.split(\"\\r\\n\\r\\n\")\n header_info = data[0].split(\"\\r\\n\")\n headers = self.updateheader(header_info, http_s_obj)\n response_dict.update({'type': header_info[0].split()[0]})\n response_dict.update({'headers': headers})\n body = data[1]\n response_dict.update({'data': body})\n path = header_info[0].split()[1]\n if path.find('?') != -1:\n split_sym = '?'\n if path.find('&') != -1:\n split_sym = '&'\n try:\n req = path.split(split_sym)\n path = req[0]\n query = req[1]\n except Exception as e:\n query = ''\n response_dict.update({'path': path})\n response_dict.update({'query': query})\n\n return response_dict","def parse_line(self, line):\n raise NotImplementedError","def main(iterator):\n\n entries = OrderedDict()\n for line in iterator:\n\n if \"START\" in line:\n entries.update({\"start_time\":int(re.search(r'\\d+', line).group())})\n if \"STOP\" in line:\n entries.update({\"end_time\":int(re.search(r'\\d+', line).group())})\n if \"NUMERIC SORT\" in line and \"Done with\" not in line:\n #print(float(re.search(r'\\d+', line).group()))\n entries.update({\"numeric_sort\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n entries.update({\"numeric_sort_abs_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"numeric_sort_rel_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"numeric_sort_num_runs\":int(re.search(r'\\d+', line).group())})\n line = next(iterator)\n \n entries.update({\"numeric_sort_num_arrs\":int(re.search(r'\\d+', line).group())})\n line = next(iterator)\n \n entries.update({\"numeric_sort_arr_size\":int(re.search(r'\\d+', line).group())})\n\n if \"STRING SORT\" in line and \"Done with\" not in line:\n #print(float(re.search(r'\\d+', line).group()))\n entries.update({\"string_sort\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"string_sort_abs_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"string_sort_rel_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"string_sort_num_runs\":int(re.search(r'\\d+', line).group())})\n line = next(iterator)\n \n entries.update({\"string_sort_num_arrs\":int(re.search(r'\\d+', line).group())})\n line = next(iterator)\n \n entries.update({\"string_sort_arr_size\":int(re.search(r'\\d+', line).group())})\n\n if \"STRING SORT\" in line and \"Done with\" not in line:\n #print(float(re.search(r'\\d+', line).group()))\n entries.update({\"string_sort\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"string_sort_abs_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"string_sort_rel_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"string_sort_num_runs\":int(re.search(r'\\d+', line).group())})\n line = next(iterator)\n \n entries.update({\"string_sort_num_arrs\":int(re.search(r'\\d+', line).group())})\n line = next(iterator)\n \n entries.update({\"string_sort_arr_size\":int(re.search(r'\\d+', line).group())})\n\n if \"BITFIELD\" in line and \"Done with\" not in line:\n #print(float(re.search(r'\\d+', line).group()))\n entries.update({\"bitfield\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"bitfield_abs_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"bitfield_rel_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"bitfield_num_runs\":int(re.search(r'\\d+', line).group())})\n line = next(iterator)\n \n entries.update({\"bitfield_ops_arr_size\":int(re.search(r'\\d+', line).group())})\n line = next(iterator)\n \n entries.update({\"bitfield_arr_size\":int(re.search(r'\\d+', line).group())})\n\n if \"FP EMULATION\" in line and \"Done with\" not in line:\n #print(float(re.search(r'\\d+', line).group()))\n entries.update({\"fp_emul\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"fp_emul_abs_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"fp_emul_rel_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"fp_emul_num_runs\":int(re.search(r'\\d+', line).group())})\n line = next(iterator)\n \n entries.update({\"fp_emul_num_loops\":int(re.search(r'\\d+', line).group())})\n line = next(iterator)\n \n entries.update({\"fp_emul_arr_size\":int(re.search(r'\\d+', line).group())})\n\n if \"FOURIER\" in line and \"Done with\" not in line:\n #print(float(re.search(r'\\d+', line).group()))\n entries.update({\"fourier\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"fourier_abs_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"fourier_rel_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"fourier_num_runs\":int(re.search(r'\\d+', line).group())})\n line = next(iterator)\n \n entries.update({\"fourier_num_coef\":int(re.search(r'\\d+', line).group())})\n\n if \"ASSIGNMENT\" in line and \"Done with\" not in line:\n #print(float(re.search(r'\\d+', line).group()))\n entries.update({\"assignment\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n entries.update({\"assignment_abs_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"assignment_rel_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"assignment_num_runs\":int(re.search(r'\\d+', line).group())})\n line = next(iterator)\n \n entries.update({\"assignment_num_arrs\":int(re.search(r'\\d+', line).group())})\n\n if \"IDEA\" in line and \"Done with\" not in line:\n #print(float(re.search(r'\\d+', line).group()))\n entries.update({\"idea\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"idea_abs_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"idea_rel_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"idea_num_runs\":int(re.search(r'\\d+', line).group())})\n line = next(iterator)\n \n entries.update({\"idea_arr_size\":int(re.search(r'\\d+', line).group())})\n line = next(iterator)\n \n entries.update({\"idea_num_loops\":int(re.search(r'\\d+', line).group())})\n \n if \"HUFFMAN\" in line and \"Done with\" not in line:\n #print(float(re.search(r'\\d+', line).group()))\n entries.update({\"huffman\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"huffman_abs_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"huffman_rel_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"huffman_num_runs\":int(re.search(r'\\d+', line).group())})\n line = next(iterator)\n \n entries.update({\"huffman_arr_size\":int(re.search(r'\\d+', line).group())})\n line = next(iterator)\n \n entries.update({\"huffman_num_loops\":int(re.search(r'\\d+', line).group())})\n\n\n if \"NEURAL NET\" in line and \"Done with\" not in line:\n #print(float(re.search(r'\\d+', line).group()))\n entries.update({\"nnet\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"nnet_abs_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"nnet_rel_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"nnet_num_runs\":int(re.search(r'\\d+', line).group())})\n line = next(iterator)\n \n entries.update({\"nnet_num_loops\":int(re.search(r'\\d+', line).group())})\n\n if \"LU DECOMPOSITION\" in line and \"Done with\" not in line:\n #print(float(re.search(r'\\d+', line).group()))\n entries.update({\"lu_decomp\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"lu_decomp_abs_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"lu_decomp_rel_sdv\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"lu_decomp_num_runs\":int(re.search(r'\\d+', line).group())})\n line = next(iterator)\n \n entries.update({\"lu_decomp_num_arrs\":int(re.search(r'\\d+', line).group())})\n\n if \"libc\" in line and \"Baseline\" not in line and \"*\" not in line:\n line = next(iterator)\n \n entries.update({\"memory_index\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"integer_index\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n line = next(iterator)\n \n entries.update({\"float_index\":float(re.search(r\"[+-]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?\", line).group())})\n\n #print(entries)\n return entries","def parse_line(line: str) -> Tuple[str, dict]:\n email, first_name, last_name, birth, gender = line.split(\",\")\n person = {\n \"first_name\": first_name,\n \"last_name\": last_name,\n \"birth\": birth,\n \"gender\": gender,\n }\n return email, person","def parse(lines, descriptions):\n # TODO does startswith with an empty string always return true?\n result = {}\n for description in descriptions: # Fill dict with empty arrays for all entries\n result[description[0]] = []\n\n for line in lines:\n words = line.split()\n for description in descriptions:\n try:\n result[description[0]].append(parse_line(words, description[0], description[1]))\n break\n except ValueError:\n pass\n return result","def extract(self):\n self.logger.info(f'Opening {self.file}')\n try:\n f = open(self.file, 'r')\n except FileNotFoundError:\n self.logger.info('Could not open the .vrt file')\n return\n\n result = {}\n self.logger.info('Extracting')\n for line in f:\n # Only attempt to extract if line is correct\n if self.is_target(line):\n # Add the closing text tag to make the line have proper XML\n xml_attributes = XML.fromstring(line.rstrip()+'</text>').attrib\n # Extract wanted parameters\n month = xml_attributes['date'][5:7] # Extract month\n # Add month to the keys\n if month not in result.keys():\n result[month] = []\n result[month].append({\n 'title': xml_attributes['title'], # Extract thread title\n 'thread_id': xml_attributes['thread_id'], # Extract thread id\n 'datetime': xml_attributes['datetime'] # Extract datetime\n })\n self.logger.info('Extraction complete')\n self.db = result\n # self.db[self.year] = result # Assign results to year\n self.save_result() # Save the results","def parse_lines(lines, options=None):\n if not options:\n options = {}\n res = []\n transaction = OrderedDict()\n for (idx, line) in enumerate(lines):\n line = line.strip()\n if not line:\n continue\n field_id = line[0]\n if field_id == \"^\":\n if transaction:\n res.append(transaction)\n transaction = OrderedDict([])\n elif field_id in list(config.FIELDS.keys()):\n transaction[config.FIELDS[field_id]] = line[1:]\n elif line:\n transaction[\"%s\" % idx] = line\n\n if len(list(transaction.keys())):\n res.append(transaction)\n\n # post-check to not interfere with present keys order\n for t in res:\n for field in list(config.FIELDS.values()):\n if field not in t:\n t[field] = None\n t[u\"filename\"] = options.get(\"src\", \"\")\n return res","def parse_line(line, key):\n keys = key.split(', ')\n ParseLine = (line.get(id) for id in keys)\n\n return ParseLine","def parse_header(self):","def _parse_refraction(line, lines):\n split_line = line.split()\n\n energy = float(split_line[0])\n ref_ind_xx = float(split_line[1])\n ref_ind_zz = float(split_line[2])\n extinct_xx = float(split_line[3])\n extinct_zz = float(split_line[4])\n\n return {\"energy\": energy, \"ref_ind_xx\": ref_ind_xx, \"ref_ind_zz\": ref_ind_zz, \"extinct_xx\": extinct_xx,\n \"extinct_zz\": extinct_zz}","def parse_lines(self, lines):\n assert isinstance(lines, Iterable)\n\n for line in lines:\n name, values = self.parse_line(line)\n self.add(name, values)","def _parse_general_info(self, line):\n if self._regex_helper.search_compiled(W._re_general_info, line):\n self.current_ret['GENERAL_INFO'].update({\n 'time': datetime.datetime.strptime(self._regex_helper.group(\"TIME\"), '%H:%M:%S').time(),\n 'uptime': self._regex_helper.group(\"UPTIME\"),\n 'user_number': self._regex_helper.group(\"USER_NUMBER\"),\n 'load_average': self._regex_helper.group(\"L_AVERAGE\")\n })\n raise ParsingDone","def _parse_logs_for_results(self, logs):\n results = {}\n for line in logs.split(\"\\n\"):\n split_line = line.split(\":\")\n if len(split_line) == 2:\n results[split_line[0].strip()] = split_line[1].strip()\n if results == {}:\n results = None\n return results","def process_entry(self):\n\n for line_item in self.entry:\n pairs = line_item.split(' ')\n for pair in pairs:\n if ':' in pair:\n key, value = pair.split(':')\n if value.isdigit():\n self.fields[key] = int(value)\n else:\n self.fields[key] = value","def parse_entry(lines):\n entry = {}\n for line in lines:\n line = line.replace('\\n', '').replace('\\r', '')\n if ':: ' in line:\n (key, value) = line.split(':: ')\n value = base64.b64decode(value).decode('utf-8')\n elif ': ' in line:\n (key, value) = line.split(': ')\n else:\n continue\n if key not in entry:\n entry[key] = []\n entry[key].append(value)\n return entry","def _parse_results(self):\n for line in self.file_dic['output'].splitlines():\n if line.startswith(' * GAMESS VERSION = '):\n temp = line.split('=')[1]\n temp = temp.split('*')[0]\n self.version = temp.strip()\n\n if line[1:25] == 'FREE ENERGY OF SOLVATION' and line.find('1 ATM') == -1:\n temp = line.split()\n #Take the next number after =\n #In KCAL/MOL\n self.solvation_energy = float(temp[temp.index(\"=\") + 1])","def parse_log_entry(line):\n\n line_pattern = r\"^(?P<host>.*) - - \\[(?P<timestamp>.*)\\] \" \\\n \"\\\"(?P<request>.*)\\\" (?P<http_code>\\d\\d\\d) (?P<bytes>.*)$\"\n line_groups = re.match(line_pattern, line)\n request_pattern = r\"^(?P<request_method>[A-Z]*) (?P<resource>\\S+) ?.*$\"\n request_groups = re.match(request_pattern, line_groups.group('request'))\n host = line_groups.group('host')\n timestamp = line_groups.group('timestamp')\n timestamp = parse_date(line_groups.group('timestamp'))\n http_code = int(line_groups.group('http_code'))\n num_bytes = line_groups.group('bytes')\n num_bytes = 0 if num_bytes == '-' else int(num_bytes)\n if request_groups:\n request_method = request_groups.group('request_method')\n resource = request_groups.group('resource')\n else:\n request_method = None\n resource = None\n return ParsedRequest(\n host, timestamp, request_method,\n resource, http_code, num_bytes)","def parse(line):\n data = json.loads(line)\n return data['SUPPLIERS_ID'], data['CATEGORY_ID'], data['NAME'], data['COUNTRY'], data['CITY'], data[\n 'LAST_UPDATE_DATE']","def parse_lines(lines):\n for line in lines:\n yield Record(line)","def _analyzeLine(self, line, date, data):\n user = re.search(': (.*)', line).group().split()[1]\n data[user].add(ConvertTime(date, line))","def parse_file_content(content_of_log_file):\n \n search_regex = re.compile('^=== \\[(?P<process_time>.+)\\] :(?P<process_state>.+): (?P<process_name>[^\\s]+)\\s*(?P<process_status>[0-9])*$')\n jobs_dict = {}\n for log_line in content_of_log_file:\n parsed_log_line = search_regex.search(log_line)\n if parsed_log_line is not None:\n process = parsed_log_line.group('process_name')\n if parsed_log_line.group('process_state') == \"START\" : \n start_time = (parsed_log_line.group('process_time'))\n jobs_dict[process] = Job(name = process, start_time = start_time, end_time = None, status = None)\n elif parsed_log_line.group('process_state') == \"END\":\n end_time = parsed_log_line.group('process_time')\n if process in jobs_dict.keys():\n jobs_dict[process].end_time = end_time\n else:\n print(\"Start of the project is not present in the log file. Could not record end\")\n if parsed_log_line.group('process_state') == \"STATUS\":\n if process in jobs_dict.keys():\n jobs_dict[process].status = parsed_log_line.group('process_status')\n else:\n print(\"Start of the project is not present in the log file. Could not record status\")\n return jobs_dict","def process(self, line):\n arr_line = list(line.split('\\t'))\n hash_line = self.get_hash(arr_line)\n\n with open(self.file_name_hash, 'a') as hash_txt:\n hash_txt.write(hash_line + '\\n')","def parse_line(line, lang):\n parsed = []\n\n #this is to display correctly beginning white characters\n while len(line) > 0 and (line[0] == ' ' or line[0] == '\\t'):\n if line[0] == ' ':\n parsed.append( {'class':'space', 'value':''} )\n else:\n parsed.append( {'class':'tab', 'value':''} )\n line = line[1:]\n\n #then follow the rest of the line\n if lang == settings.C_LANGUAGE:\n keywords = settings.C_KEYWORDS\n types = settings.C_TYPES\n elif lang == settings.CPP_LANGUAGE:\n keywords = settings.CPP_KEYWORDS\n types = settings.CPP_TYPES\n elif lang == settings.JAVA_LANGUAGE:\n keywords = settings.JAVA_KEYWORDS\n types = settings.JAVA_TYPES\n elif lang == settings.PYTHON_LANGUAGE:\n keywords = settings.PYTHON_KEYWORDS\n types = settings.PYTHON_TYPES\n\n splited = line.split()\n for s in splited:\n if s in keywords:\n parsed.append( {'class':'keyword', 'value':s} )\n \n elif s in types:\n parsed.append( {'class':'types', 'value':s} )\n \n elif (lang == 'CPP' or lang == 'C') and s.startswith('#'):\n parsed.append( {'class':'special', 'value':s} )\n \n elif (lang == 'CPP' or lang == 'C') and s.startswith('<') and s.endswith('>'):\n parsed.append( {'class':'special', 'value':s} )\n \n else:\n parsed.append( {'class':'normal', 'value':s} )\n\n return parsed","def _readheader(lines):\n hdrdict = {}\n #input list of 26 lines of header\n #station and channel\n line = lines[5]\n parts = line.strip().split()\n fname = parts[1]\n fparts = fname.split('_')\n hdrdict['station'] = fparts[-2]+'_'+fparts[-1]\n\n #the \"Component\" lines look like either: Component S00W, Component S90E, Component Up\n compstr = lines[12].strip().split()[1]\n hdrdict['channel'] = get_comp_name(compstr)\n\n #instrument\n hdrdict['instrument'] = lines[3].split()[1].strip()\n \n #location string\n line = lines[6]\n hdrdict['location'] = line.strip()\n #event origin, buffer start year/month\n line = lines[16]\n parts = line.strip().split()\n bufyear = int(parts[8])\n bufmonth = int(parts[9])\n #epicentral location, buffer start day/hour\n line = lines[17]\n parts = line.strip().split()\n bufday = int(parts[8])\n bufhour = int(parts[9])\n #numpoints, buffer start min/sec\n line = lines[19]\n parts = line.strip().split()\n hdrdict['npts'] = int(parts[0])\n bufmin = int(parts[8])\n millisec = int(parts[9])\n bufsec = int(millisec/1000)\n bufmicrosec = int(np.round(millisec/1000.0 - bufsec))\n hdrdict['starttime'] = UTCDateTime(datetime(bufyear,bufmonth,bufday,bufhour,bufmin,bufsec,bufmicrosec))\n #part C\n #frequency, calibration value and some other stuff we don't care about\n line = lines[20]\n parts = line.strip().split()\n hdrdict['sampling_rate'] = float(parts[0])\n hdrdict['delta'] = 1.0/hdrdict['sampling_rate']\n hdrdict['calib'] = float(parts[7])\n #site location info, this time in dd\n line = lines[21]\n parts = line.strip().split()\n hdrdict['lat'] = float(parts[0]) * -1\n hdrdict['lon'] = float(parts[1])\n hdrdict['height'] = 0.0\n #duration\n line = lines[22]\n parts = line.strip().split()\n hdrdict['duration'] = float(parts[0])\n hdrdict['endtime'] = hdrdict['starttime'] + hdrdict['duration']\n #max acceleration - good for sanity check\n line = lines[23]\n parts = line.strip().split()\n hdrdict['maxacc'] = float(parts[0])\n hdrdict['network'] = 'NZ'\n hdrdict['units'] = 'acc'\n return hdrdict","def parseLine(line):\n\n\teq = line.find('=')\n\tif eq == -1: raise Exception()\n\tkey = line[:eq].strip()\n\tvalue = line[eq+1:-1].strip()\n\treturn key, parseValue(value)","def parse_line(lines, project, project_in):\n # NOTE: project_in, here, is whether or not the given project is currently\n # clocked in, rather than whether any is, like 'finished' in other functions.\n # Find the corresponding line index\n # project should already be lower case\n length = len(project)\n i = 0\n for i, l in enumerate(lines[HEADER_L:]):\n if l[:length] == project:\n new = False\n i += HEADER_L\n break\n else:\n i += HEADER_L + 1\n new = True\n \n # Process the line\n line = [project, \"0\"] if new else lines[i].split(PUNCH_SEP)\n last = None if project_in else datetime.strptime(line[-1], TIMEF)\n times = []\n for punch in (line[2:] if project_in else (line[2:-1])):\n time_in, time_out = punch.split(IN_OUT_SEP)\n time_in = datetime.strptime(time_in, TIMEF)\n time_out = datetime.strptime(time_out, TIMEF)\n times.append(time_out - time_in)\n\n return line, i, last, new, times","def getPriorityRequests(self, line):\n # self.optimizationResultsFile = open(self.fileName, 'r')\n # for i, line in enumerate(self.optimizationResultsFile):\n # if i in range(15, requiredLineNo):\n reqPhase, earliestArrival, latestArrival, delay, vehicleClass = line.split()\n if int(vehicleClass) == EV:\n self.requestedPhase_EV.append(int(reqPhase))\n self.ETA_EV.append(float(latestArrival) - 4.0)\n self.ETA_EV.append(float(latestArrival) - 4.0)\n self.ETA_Duration_EV.append(4.0)\n self.ETA_Duration_EV.append(4.0)\n self.vehicleType_EV.append(int(vehicleClass))\n self.delay_EV.append(float(delay))\n\n elif int(vehicleClass) == TRANSIT:\n self.requestedPhase_Transit.append(int(reqPhase))\n self.ETA_Transit.append(float(latestArrival) - 4.0)\n self.ETA_Transit.append(float(latestArrival) - 4.0)\n self.ETA_Duration_Transit.append(4.0)\n self.ETA_Duration_Transit.append(4.0)\n self.vehicleType_Transit.append(int(vehicleClass))\n if (float(delay) > 0):\n self.delay_Transit.append(\n float(delay) - (float(latestArrival) - float(earliestArrival) - 4.0))\n\n elif int(vehicleClass) == TRUCK:\n self.requestedPhase_Truck.append(int(reqPhase))\n self.ETA_Truck.append(float(latestArrival) - 4.0)\n self.ETA_Truck.append(float(latestArrival) - 4.0)\n self.ETA_Duration_Truck.append(4.0)\n self.ETA_Duration_Truck.append(4.0)\n self.vehicleType_Truck.append(int(vehicleClass))\n if (float(delay) > 0):\n self.delay_Truck.append(\n float(delay) - (float(latestArrival) - float(earliestArrival) - 4.0))\n\n elif int(vehicleClass) == DILEMMAZONE:\n self.requestedPhase_DilemmaZone.append(int(reqPhase))\n self.ETA_DilemmaZone.append(float(latestArrival) - 4.0)\n self.ETA_DilemmaZone.append(float(latestArrival) - 4.0)\n self.ETA_Duration_DilemmaZone.append(4.0)\n self.ETA_Duration_DilemmaZone.append(4.0)\n self.vehicleType_DilemmaZone.append(int(vehicleClass))\n self.delay_DilemmaZone.append(float(delay))\n\n elif int(vehicleClass) == COORDINATION:\n self.requestedPhase_Coordination.append(int(reqPhase))\n self.ETA_Coordination.append(float(earliestArrival))\n self.ETA_Coordination.append(float(earliestArrival))\n self.ETA_Duration_Coordination.append(\n float(latestArrival) - float(earliestArrival))\n self.ETA_Duration_Coordination.append(\n float(latestArrival) - float(earliestArrival))\n self.vehicleType_Coordination.append(int(vehicleClass))\n self.delay_Coordination.append(float(delay))\n\n # self.optimizationResultsFile.close()","def parse_entry(tr):\n\ttr = tr.replace('\"', '')\n\ttrl = tr.split(\"; \")\n\ttrdict = OrderedDict()\n\n\tfor j in trl:\n\t\tk = j.split(\" \")\n\n\t\tif k[0] in trdict:\n# print \"%s already in dict\" % (k[0])\n\t\t\ttrdict[k[0]].append(k[1])\n\t\telse: \n\t\t\ttrdict[k[0]]=[k[1]]\n\treturn trdict","def parse_api_header(content):\n result = {}\n for line in content.split('\\n'):\n for kw in KEYWORDS:\n if kw in line:\n _, _, value = line.strip().split()\n value = value.strip()\n\n if kw == oqs.CRYPTO_ALGNAME:\n assert value[0] == value[-1] == '\"'\n value = value[1:-1]\n\n result[kw] = value\n break\n\n return result","def _build_header_dictionary(self):\n start = 0\n #print self.raw_data\n for a in range(20):\n redatapuller = re.compile(\"\\r\\n\\r\\n\\r\\n(?P<word>.*?)\\t.*?\\n\", re.DOTALL)\n m = redatapuller.search(self.raw_data[start:])\n if not(m):\n break\n self.header_dictionary[m.group(\"word\")] = start + m.end()\n if a==0:\n self.header_dictionary[\"main\"] = start + m.end()\n start += m.end()","def parse_results(results):\n # hold the results in a dictionary\n results_dict = {}\n # loop over each line (result)\n for result in results:\n # split the string based on spaces\n parts = result.split()\n # there should only be a name and an outcome ('w', 'l')\n if len(parts) > 2:\n raise Exception(\"the results file has a bad format\")\n # keep track of the name and the outcome so I don't have to use \n # parts[0] and parts[1]\n name = parts[0]\n outcome = parts[1]\n # add the name to the dictionary if it's not already there\n if name not in results_dict:\n results_dict[name] = (0, 0)\n # modify the results tuple according to whether its a win or loss\n if outcome == 'w':\n results_dict[name] = (results_dict[name][0]+1, results_dict[name][1])\n elif outcome == 'l':\n results_dict[name] = (results_dict[name][0], results_dict[name][1]+1)\n else:\n raise Exception(\"I didn't recognize the outcome\")\n return results_dict","def parse_header(self, out):\n self.headers = {}\n for h in out.split(\"\\r\\n\\r\\n\", 1)[0].split(\"\\r\\n\"):\n x = h.split(\":\")\n self.headers[x[0]] = \":\".join(x[1:]).lstrip()\n return True","def __init__(self, line):\n (self.timestamp, self.status_code, self.content_length, self.url, self.hop_path, self.via,\n self.mime, self.thread, self.start_time_plus_duration, self.hash, self.source,\n self.annotation_string) = re.split(\" +\", line.strip(), maxsplit=11)\n # Account for any JSON 'extra info' ending, strip or split:\n if self.annotation_string.endswith(' {}'):\n self.annotation_string = self.annotation_string[:-3]\n elif ' {\"' in self.annotation_string and self.annotation_string.endswith('}'):\n self.annotation_string, self.extra_json = re.split(re.escape(' {\"'), self.annotation_string, maxsplit=1)\n self.extra_json = '{\"%s' % self.extra_json\n # And split out the annotations:\n self.annotations = self.annotation_string.split(',')\n\n # Some regexes:\n self.re_ip = re.compile('^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$')\n self.re_tries = re.compile('^\\d+t$')\n self.re_dol = re.compile('^dol:\\d+') # Discarded out-links - make a total?","def read_header(self, lines):\n\n comp = None\n data_lines = []\n for ii, line in enumerate(lines):\n if line.find(\"=\") > 0 and line.find(\"$\") == 0:\n key, value = line[1:].split(\"=\")\n key = \".\".join(\n [\n validate_attribute(k)\n for k in key.replace(\":\", \".\").split(\".\")\n ]\n )\n\n value = value.lower().strip()\n if \",\" in value:\n value = [v.strip() for v in value.split(\",\")]\n if \"length\" in key:\n value = value.split()\n if len(value) > 1:\n value = value[0]\n else:\n value = value[0].strip()\n\n if \"rx.cmp\" in key:\n comp = value\n data_lines.append(line)\n self._comp_dict[comp] = {\"rx\": Rx(), \"ch\": CH()}\n if comp is not None:\n comp_key, comp_attr = key.split(\".\")\n\n self._comp_dict[comp][comp_key].set_attr_from_name(\n comp_attr, value\n )\n else:\n self.set_attr_from_name(key, value)\n else:\n if len(line) > 2:\n data_lines.append(line)\n\n return data_lines","def parse_headers(file_contents: str) -> dict:\n\n match = re.search(r'#HEADER#(.*?)#', file_contents, re.MULTILINE | re.DOTALL)\n\n if match is None:\n raise Exception('No #HEADER# provided')\n\n headers = {}\n lines = match.group(1).split(\"\\n\")\n\n for line in lines:\n if line.strip() != '':\n parts = line.split(' : ')\n value = re.sub(r'(^[\\'\"]|[\\'\"]$)', '', parts[1].strip())\n headers[parts[0].strip()] = value\n\n return headers","def _process_text_line(self, line, columns, format, lower_case, num_line,\n fill_missing=0, filter_case=None,\n strict_separator=False):\n if not isinstance(line, list) and not isinstance(\n line, tuple) and not isinstance(line, numpy.ndarray):\n if format != \"tsv\":\n raise Exception(\"unable to process format \" + format)\n line = line.strip(\"\\r\\n \").replace(\"\\n\", \" \")\n line = DatabaseCore2._split_expr.split(line)\n\n if filter_case is not None:\n line = [filter_case(s) for s in line]\n\n try:\n if fill_missing > 0:\n m = max(columns.keys())\n if m >= len(line):\n line = copy.copy(line)\n add = 0\n while m >= len(line) and add < fill_missing:\n a, b = columns[len(line)]\n if b is int:\n line.append(\"0\")\n elif b is float:\n line.append(\"0.0\")\n elif b is decimal.Decimal:\n line.append(\"0\")\n elif b is str:\n line.append(\"\")\n else:\n line.append(\"\")\n add += 1\n\n res = {}\n for c, v in columns.items():\n if \"AUTOFILL\" in v:\n res[v[0]] = \"NULL\"\n elif \"AUTOINCREMENT\" in v:\n continue\n else:\n if c >= len(line):\n self.LOG(\n \"(a)line number \",\n num_line,\n \"*unable to process a line columns \",\n c,\n \"#\",\n line,\n \" columns \",\n columns)\n return None\n\n val = line[c]\n if len(v) > 2 and v[2].lower() not in [\n \"primarykey\", \"autofill\"]:\n val = v[2](val)\n\n try:\n if isinstance(v[1], tuple):\n val = v[1][0](val)\n elif v[1] is datetime.datetime:\n if isinstance(val, datetime.datetime):\n pass\n elif isinstance(val, str):\n val = datetime.datetime.parse(val)\n else:\n raise TypeError(\n \"unable to convert %s into datetime\" % str(\n type(val)))\n else:\n val = v[1](val)\n except ValueError: # as e :\n self.LOG(\n \"(b)line number \",\n num_line,\n \"**unable to process a line columns \",\n c,\n \"#\",\n v[0],\n \" type \",\n v[1],\n \" value \",\n repr(\n line[c]))\n return None\n\n if isinstance(val, str):\n val = val.replace(\"'\", \"''\")\n if lower_case:\n val = val.lower()\n res[v[0]] = val\n\n return res\n except Exception:\n self.LOG(\"(c)line number\", num_line,\n \"***unable to process a line columns:\", line)\n return None","def mapper(self, _, line):\n if line:\n try:\n line_values = re.match(self.REGEXP, line).groupdict()\n user_agent = user_agents.parse(line_values['user_agent']).browser.family\n self.increment_counter('Browsers', user_agent, 1)\n ip = line_values['ip']\n try:\n byte_count = int(line_values['byte_count'])\n except ValueError:\n byte_count = 0\n yield ip, ValueFormat(byte_count, 1)\n except AttributeError:\n self.increment_counter('ERRORS', 'ERRORS', 1)","def parse_user_dict(self, line):\n pass","def _parseLine(self, line, delimiter = \":\"):\r\n\t\tsplt = line.split(delimiter)\r\n\t\tinVec = self._parseVec(splt[0])\r\n\t\toutVec = self._parseVec(splt[1])\r\n\t\tif (len(splt) == 2):\r\n\t\t\tlabel = \"\"\r\n\t\telse:\r\n\t\t\tlabel = splt[2]\r\n\t\tself.data.append({'in':inVec, 'out':outVec, 'label':label})","def parseLine(self,incoming):\n\t\tself.addContentLine(incoming)\n\t\tif incoming.mustProcess == 0: return \n\t\tself.iLineObject = incoming\n\t\titems = self.iLineObject.getItems()\n\t\tkeyword = string.upper(items[0])\n\t\tif len(items) < 2: \n\t\t\tif not keyword in self.sQuotedKeywords: \n\t\t\t\tself.addErrorMessage('2. Unrecognized keyword SIMULATOR_BLOCK:', self.iLineObject)\n\t\t\treturn\n\t\tself.parseKeyword(keyword,items[1:])","def _parse_headers(raw_headers: List[str]) -> Dict[str, str]:\n headers: Dict[str, str] = {}\n for header in raw_headers:\n name = header[: header.find(\":\")].strip()\n value = header[header.find(\":\") + 1 :].strip()\n headers[name.lower()] = value\n\n return headers"],"string":"[\n \"def process_line(self, line):\\n find_result = re.findall(LINE_REGEX, line)\\n line_data = {r[0]: r[1] for r in find_result}\\n self.process_url(line_data.get('request_to'))\\n self.process_status_code(line_data.get('response_status'))\",\n \"def process_line(line):\\n\\n name_comp_list = []\\n givenname_comp_list = []\\n surname_comp_list = []\\n geocode_comp_list = []\\n locality_comp_list = []\\n date1_comp_list = []\\n date2_comp_list = []\\n\\n # Split the line into the basic fields - - - - - - - - - - - - - - - - - - -\\n #\\n if (config.in_file_type in ['CSV','CSVQ','TAB','TABQ']):\\n # Comma or tabulator separated\\n try:\\n line_list = config.line_parser.parse(line)\\n except:\\n log_message('CSV line parsing failed with inout: '+line,'err')\\n\\n if (len(line_list) < config.input_len):\\n log_message('Input line does not contain enough fields,' +\\\\\\n 'fill up with empty fields','warn')\\n while (len(line_list) < config.input_len):\\n line_list.append('')\\n\\n config.curr_line_list = line_list # Save current line list\\n\\n # Extract fields into different component lists - - - - - - - - - - - - - -\\n #\\n if (config.input_component['name'] != []): # Extract name fields\\n for i in config.input_component['name']:\\n name_comp_list.append(line_list[i])\\n\\n else: # Extract givenname and surname into separate components - - - - - -\\n if (config.input_component['givenname'] != []): # Extract g-name fields\\n for i in config.input_component['givenname']:\\n givenname_comp_list.append(line_list[i])\\n\\n if (config.input_component['surname'] != []): # Extract surname fields\\n for i in config.input_component['surname']:\\n surname_comp_list.append(line_list[i])\\n\\n if (config.input_component['geocode'] != []): # Extract geocode fields\\n for i in config.input_component['geocode']:\\n geocode_comp_list.append(line_list[i])\\n\\n if (config.input_component['locality'] != []): # Extract locality fields\\n for i in config.input_component['locality']:\\n locality_comp_list.append(line_list[i])\\n\\n if (config.input_component['date1'] != []): # Extract date1 fields\\n for i in config.input_component['date1']:\\n date1_comp_list.append(line_list[i])\\n\\n if (config.input_component['date2'] != []): # Extract date2 fields\\n for i in config.input_component['date2']:\\n date2_comp_list.append(line_list[i])\\n\\n elif (config.in_file_type == 'COL'): # Column based input file - - - - - - -\\n\\n if (len(line) < config.input_len):\\n log_message('Input line is not long enough, fill up with spaces','warn')\\n line += ' '*(config.input_len-len(line))\\n\\n if (config.input_component['name'] != []): # Extract name fields\\n for (col_start,length) in config.input_component['name']:\\n name_comp_list.append(line[col_start,col_start+length])\\n\\n else: # Extract givenname and surname into separate components - - - - - -\\n if (config.input_component['givenname'] != []): # Extract g-name fields\\n for (col_start,length) in config.input_component['givenname']:\\n givenname_comp_list.append(line[col_start,col_start+length])\\n\\n if (config.input_component['surname'] != []): # Extract surname fields\\n for (col_start,length) in config.input_component['surname']:\\n surname_comp_list.append(line[col_start,col_start+length])\\n\\n if (config.input_component['geocode'] != []): # Extract geocode fields\\n for (col_start,length) in config.input_component['geocode']:\\n geocode_comp_list.append(line[col_start,col_start+length])\\n\\n if (config.input_component['locality'] != []): # Extract locality fields\\n for (col_start,length) in config.input_component['locality']:\\n locality_comp_list.append(line[col_start,col_start+length])\\n\\n if (config.input_component['date1'] != []): # Extract date1 fields\\n for (col_start,length) in config.input_component['date1']:\\n date1_comp_list.append(line[col_start,col_start+length])\\n\\n if (config.input_component['date2'] != []): # Extract date2 fields\\n for (col_start,length) in config.input_component['date2']:\\n date2_comp_list.append(line[col_start,col_start+length])\\n\\n # elif (config.in_file_type == 'SQL'): # - - - - - - - - - - - - - - - - - -\\n\\n ################################\\n # Add later: SQL database access\\n ################################\\n\\n msg = [' Component basic field lists:', \\\\\\n ' Name: '+str(name_comp_list), \\\\\\n ' Given name: '+str(givenname_comp_list), \\\\\\n ' Surname: '+str(surname_comp_list), \\\\\\n ' Geocode: '+str(geocode_comp_list), \\\\\\n ' Locality: '+str(locality_comp_list), \\\\\\n ' Date1: '+str(date1_comp_list), \\\\\\n ' Date2: '+str(date2_comp_list)]\\n log_message(msg,'v2')\\n\\n name_comp = ''\\n givenname_comp = ''\\n surname_comp = ''\\n geocode_comp = ''\\n locality_comp = ''\\n date1_comp = ''\\n date2_comp = ''\\n\\n # Now clean and then concatenate component lists into strings - - - - - - - -\\n #\\n if (name_comp_list != []): # Name component\\n name_comp = name_comp_list[0] # Start with first field in list\\n\\n for f in name_comp_list[1:]: # Loop over following fields (if any)\\n if (f != ''):\\n if (config.input_space_sep['name'] == 1):\\n sep = ' ' # Set separator to space between fields\\n else:\\n sep = '' # No space between fields\\n\\n # Check field spilling only if space separator is set to ' ' \\n #\\n if (sep == ' ') and (config.input_check_spilling['name'] == 1):\\n sep = check_field_spill(name_comp, f)\\n\\n name_comp = name_comp+sep+f # Append separator and field\\n\\n if (givenname_comp_list != []): # Givenname component - - - - - - - - - - -\\n givenname_comp = givenname_comp_list[0] # Start with first field in list\\n\\n for f in givenname_comp_list[1:]: # Loop over following fields (if any)\\n if (f != ''):\\n if (config.input_space_sep['givenname'] == 1):\\n sep = ' ' # Set separator to space between fields\\n else:\\n sep = '' # No space between fields\\n\\n # Check field spilling only if space separator is set to ' ' \\n #\\n if (sep == ' ') and (config.input_check_spilling['givenname'] == 1):\\n sep = check_field_spill(givenname_comp, f)\\n\\n givenname_comp = givenname_comp+sep+f # Append separator and field\\n\\n if (surname_comp_list != []): # Surname component - - - - - - - - - - - - -\\n surname_comp = surname_comp_list[0] # Start with first field in list\\n\\n for f in surname_comp_list[1:]: # Loop over following fields (if any)\\n if (f != ''):\\n if (config.input_space_sep['surname'] == 1):\\n sep = ' ' # Set separator to space between fields\\n else:\\n sep = '' # No space between fields\\n\\n # Check field spilling only if space separator is set to ' ' \\n #\\n if (sep == ' ') and (config.input_check_spilling['surname'] == 1):\\n sep = check_field_spill(surname_comp, f)\\n\\n surname_comp = surname_comp+sep+f # Append separator and field\\n\\n if (geocode_comp_list != []): # Geocode component - - - - - - - - - - - - -\\n geocode_comp = geocode_comp_list[0] # Start with first field in list\\n\\n for f in geocode_comp_list[1:]: # Loop over following fields (if any)\\n if (f != ''):\\n if (config.input_space_sep['geocode'] == 1):\\n sep = ' ' # Set separator to space between fields\\n else:\\n sep = '' # No space between fields\\n\\n # Check field spilling only if space separator is set to ' ' \\n #\\n if (sep == ' ') and (config.input_check_spilling['geocode'] == 1):\\n sep = check_field_spill(geocode_comp, f)\\n\\n geocode_comp = geocode_comp+sep+f # Append separator and field\\n\\n if (locality_comp_list != []): # Locality component - - - - - - - - - - - -\\n locality_comp = locality_comp_list[0] # Start with first field in list\\n\\n for f in locality_comp_list[1:]: # Loop over following fields (if any)\\n if (f != ''):\\n if (config.input_space_sep['locality'] == 1):\\n sep = ' ' # Set separator to space between fields\\n else:\\n sep = '' # No space between fields\\n\\n # Check field spilling only if space separator is set to ' ' \\n #\\n if (sep == ' ') and (config.input_check_spilling['locality'] == 1):\\n sep = check_field_spill(locality_comp, f)\\n\\n locality_comp = locality_comp+sep+f # Append separator and field\\n\\n if (date1_comp_list != []): # Date1 component - - - - - - - - - - - - - - -\\n date1_comp = date1_comp_list[0] # Start with first field in list\\n\\n for f in date1_comp_list[1:]: # Loop over following fields (if any)\\n if (f != ''):\\n if (config.input_space_sep['date1'] == 1):\\n sep = ' ' # Set separator to space between fields\\n else:\\n sep = '' # No space between fields\\n\\n # Check field spilling only if space separator is set to ' ' \\n #\\n if (sep == ' ') and (config.input_check_spilling['date1'] == 1):\\n if (date1_comp[-1] != ' ') and (f[0] != ' '):\\n tmp_list0 = date1_comp.split()\\n tmp_list1 = f.split()\\n check_word = tmp_list0[-1]+tmp_list1[0]\\n\\n if (check_word in ['jan','feb','mar','apr','may','jun','jul','aug', \\\\\\n 'sep','oct','nov','dec','january','february','march','april', \\\\\\n 'may','june','july','august','september','october','november', \\\\\\n 'december']):\\n\\n sep = '' # Set separator to no space\\n msg = ' Correct date1 word spilling: \\\"'+date1_comp+'\\\",\\\"'+f+'\\\"'\\n log_message(msg,'v1')\\n\\n date1_comp = date1_comp+sep+f # Append separator and field\\n\\n if (date2_comp_list != []): # Date2 component - - - - - - - - - - - - - - -\\n date2_comp = date2_comp_list[0] # Start with first field in list\\n\\n for f in date2_comp_list[1:]: # Loop over following fields (if any)\\n if (f != ''):\\n if (config.input_space_sep['date2'] == 1):\\n sep = ' ' # Set separator to space between fields\\n else:\\n sep = '' # No space between fields\\n\\n # Check field spilling only if space separator is set to ' ' \\n #\\n if (sep == ' ') and (config.input_check_spilling['date2'] == 1):\\n if (date2_comp[-1] != ' ') and (f[0] != ' '):\\n tmp_list0 = date1_comp.split()\\n tmp_list1 = f.split()\\n check_word = tmp_list0[-1]+tmp_list1[0]\\n\\n if (check_word in ['jan','feb','mar','apr','may','jun','jul','aug', \\\\\\n 'sep','oct','nov','dec','january','february','march','april', \\\\\\n 'may','june','july','august','september','october','november', \\\\\\n 'december']):\\n\\n sep = '' # Set separator to no space\\n msg = ' Correct date1 word spilling: \\\"'+date1_comp+'\\\",\\\"'+f+'\\\"'\\n log_message(msg,'v1')\\n\\n date2_comp = date2_comp+sep+f # Append separator and field\\n\\n # Check if name component is given or givenname and surname separately - - -\\n #\\n if (config.input_component['givenname'] != []) or \\\\\\n (config.input_component['surname'] != []):\\n name_comp = [givenname_comp, surname_comp]\\n\\n msg = [' Components:', \\\\\\n ' Name: \\\"'+str(name_comp)+'\\\"', \\\\\\n ' Geocode: \\\"'+geocode_comp+'\\\"', \\\\\\n ' Locality: \\\"'+locality_comp+'\\\"', \\\\\\n ' Date1: \\\"'+date1_comp+'\\\"', \\\\\\n ' Date2: \\\"'+date2_comp+'\\\"']\\n log_message(msg,'v1')\\n\\n return [name_comp, geocode_comp, locality_comp, date1_comp, date2_comp]\",\n \"def _result_to_dict(line):\\n f = line.split(':;')\\n return {'server': f[0], 'os_name': f[1], 'status': f[2], 'ipv4': f[3]}\",\n \"def _parse_line(line: Match[str]) -> dict:\\n request = line.group(\\\"request\\\")\\n request = request.split()\\n req_method = request[0] # GET, POST, PUT, etc.\\n url = request[1]\\n x = url.split(\\\"/\\\")[3:]\\n uri = f'/{\\\"/\\\".join(x)}'\\n\\n timestamp = line.group(\\\"timestamp\\\") # timestamp in ISO format\\n timestamp = MyTime._try_isoformat(timestamp, tzinfo=\\\"UTC\\\").dt\\n\\n res = {\\n \\\"url\\\": url,\\n \\\"uri\\\": uri,\\n \\\"req_method\\\": req_method,\\n \\\"timestamp\\\": timestamp,\\n \\\"user_agent\\\": line.group(\\\"user_agent\\\"),\\n }\\n return res\",\n \"def parse_line(line):\\n parts = line.strip().split('\\\\t')\\n\\n output = {}\\n\\n if len(parts) != len(COLUMNS):\\n raise Exception('Incorrect number of columns in line.', parts, COLUMNS)\\n\\n for key, value in zip(COLUMNS, parts):\\n if key == 'attributes':\\n output[key] = parse_attributes(value)\\n elif key == 'start' or key == 'stop':\\n output[key] = int(value)\\n else:\\n output[key] = value\\n\\n return output\",\n \"def _parse_line(self, line):\\n fields = line.split('|', 4) # stop splitting after fourth | found\\n line_info = {'raw_message': line}\\n if len(fields) == 5:\\n line_info.update(dict(zip(self._fieldnames, fields)))\\n return line_info\",\n \"def _parse_header(lines):\\n # The dict into which we will store header fields.\\n header = {}\\n # Loop over lines in the header.\\n for line in lines:\\n # Find the first colon.\\n index = line.index(COLON)\\n # Up to the colon is the field name.\\n name = line[: index]\\n # After the colon is the field value.\\n value = line[index + 1 :]\\n # The field value may begin or end with extra space, which is not \\n # significant. Remove it.\\n value = value.strip()\\n # Store the field.\\n header[name] = value\\n # All done.\\n return header\",\n \"def process_line(self,\\n event_file,\\n raw_log_line,\\n header_length=29,\\n log_filename=\\\"\\\"):\\n\\n event_data = {}\\n for filter_name, regex in self._filters_dict.items():\\n match = regex.search(raw_log_line)\\n if match:\\n match_data = match.groups()\\n event_data[filter_name] = match_data\\n\\n if event_data:\\n if log_filename:\\n event_data[\\\"log_filename\\\"] = log_filename\\n event_data[\\\"raw_log_line\\\"] = raw_log_line.rstrip()[header_length:]\\n event_data[\\\"system_timestamp\\\"] = raw_log_line[1:27]\\n event_data[\\\"matched_timestamp\\\"] = \\\\\\n datetime.datetime.now().strftime(TIMESTAMP_FORMAT)\\n event_file.write(json.dumps(event_data) + \\\"\\\\n\\\")\\n event_file.flush()\",\n \"def get_data(contents):\\n\\n header = {}\\n copy = contents.split(\\\"\\\\n\\\")\\n\\n header_contents = dict(\\n start_date=\\\"Start Date\\\",\\n end_date=\\\" End Date\\\",\\n subject=\\\" Subject\\\",\\n experiment=\\\" Experiment\\\",\\n group=\\\" Group\\\",\\n box=\\\" Box\\\",\\n start_time=\\\" Start Time\\\",\\n end_time=\\\" End Time\\\",\\n program=\\\" Program\\\",\\n msn=\\\" MSN\\\",\\n )\\n\\n for line in copy:\\n for key in header_contents:\\n heading = line.split(\\\":\\\")\\n if heading[0] == header_contents[key]:\\n if key == \\\"start_time\\\" or key == \\\"end_time\\\":\\n header[key] = (\\n heading[1].lstrip() + \\\":\\\" + heading[2] + \\\":\\\" + heading[3]\\n )\\n else:\\n header[key] = heading[1].lstrip()\\n\\n data = {}\\n copy = contents.split()\\n\\n uppercase = string.ascii_uppercase\\n\\n idx = []\\n for i, val in enumerate(copy):\\n if val[0] in uppercase and val[1] == \\\":\\\":\\n idx.append(i)\\n\\n for i, j in zip(idx[:-1], idx[1:]):\\n data[copy[i].lower()[0]] = [\\n timestamp for timestamp in copy[i + 1 : j] if timestamp[-1] != \\\":\\\"\\n ]\\n\\n return header, data\",\n \"def parse_line(cls, line):\\n regex = re.compile(cls.pattern)\\n m = regex.search(line)\\n if m:\\n data = m.groupdict()\\n data = cls.post_process(data)\\n if cls.date_format:\\n data['time'] = cls.convert_time(data['time'])\\n else:\\n data['time'] = datetime.now()\\n return data\\n else:\\n return {}\",\n \"def process(raw):\\n entry = { }\\n cooked = [ ]\\n\\n for line in raw:\\n line = line.strip()\\n if len(line) == 0 or line[0]==\\\"#\\\" :\\n continue\\n parts = line.split(';')\\n if len(parts) == 3:\\n entry[\\\"description\\\"] = parts[0].strip() #adding key and values to the dict\\n entry[\\\"long\\\"] = parts[1].strip()\\n entry[\\\"lat\\\"] = parts[2].strip()\\n cooked.append(entry) #add this dict entry into the array\\n entry = { }\\n continue\\n else:\\n raise ValueError(\\\"Trouble wiht line: '{}'\\\\n\\\".format(line))\\n \\n return cooked #returning an array of dicts\",\n \"def agline(line):\\n\\n vals = {}\\n x = ['date', 'movie', 'offset', 'well', 'gen', 'flarem', 'flares', \\n 'chargem', 'charges', 'charget', 'escdm', 'escds', 'escddur', 'escmm', 'escms', \\n 'escmdur']\\n y = line.strip('\\\\n').split(',')[0:16]\\n z = zip(x, y)\\n\\n for item in z:\\n vals[item[0]] = item[1]\\n\\n return(vals)\",\n \"def process(line):\\n output = {}\\n\\n fields = line.split(\\\" \\\")\\n if len(fields) < 6:\\n return False\\n \\n output[\\\"log_level\\\"] = fields[0]\\n \\n # Convert date/time to object or reject line\\n try:\\n output[\\\"datetime\\\"] = datetime.datetime.strptime(\\n \\\"%s %s\\\" % (fields[1], fields[2]),\\n \\\"%Y-%m-%d %H:%M:%S,%f\\\"\\n )\\n except ValueError:\\n return False\\n \\n output[\\\"logger\\\"] = fields[3]\\n output[\\\"thread\\\"] = fields[4]\\n output[\\\"process\\\"] = fields[5]\\n output[\\\"message\\\"] = \\\" \\\".join(fields[6:])\\n \\n return output\",\n \"def parse(self, src, line):\\n r = line.split('\\\\t')\\n p = {}\\n if src == 'sf':\\n p['businessID'] = r[0]\\n p['name'] = r[1]\\n p['address'] = r[2]\\n p['city'] = r[3]\\n p['state'] = r[4]\\n p['zip'] = r[5]\\n p['latitude'] = r[6]\\n p['longitude'] = r[7]\\n p['phone'] = r[8]\\n elif src == 'nyc':\\n p['businessID'] = r[0]\\n p['name'] = r[1]\\n # nyc separates the building number from the street name\\n p['address'] = ' '.join([r[3].strip(), r[4].strip()])\\n p['city'] = 'NYC'\\n p['state'] = 'NY'\\n p['zip'] = r[5]\\n p['latitude'] = None\\n p['longitude'] = None\\n p['phone'] = r[6]\\n return p\",\n \"def ParseLine(line):\\n fields = line.split()\\n ip = fields[0]\\n datestr = ' '.join(fields[3:5])[1:-1]\\n timestamp = datetime.strptime(\\n datestr, '%d/%b/%Y:%H:%M:%S %z'\\n ).timestamp()\\n command = fields[5][1:]\\n uri = fields[6]\\n protocol = fields[7][:-1]\\n status = int(fields[8])\\n size = int(fields[9])\\n meta = [var.strip('\\\"') for var in fields[11:-1]]\\n return {\\n 'timestamp': timestamp,\\n 'ip': ip,\\n 'command': command,\\n 'uri': uri,\\n 'protocol': protocol,\\n 'status': status,\\n 'size': size,\\n 'meta': meta\\n }\",\n \"def _parse_line(self):\\n # check if line contains a rule or not\\n stripped = self._line.strip()\\n if not stripped or stripped.startswith(\\\"#\\\"):\\n return None\\n\\n # strip out double quotes from values, and simplify equals strings\\n simplified = self._line.replace(\\\"==\\\", \\\"=\\\").replace('\\\"', '')\\n\\n # return a dictionary formed from the key=value pairs found in line\\n return dict(f.strip().split(\\\"=\\\", 1) for f in simplified.split(\\\",\\\"))\",\n \"def do_Promo_line_parse (Promo_line, line_number, filehash) :\\n result = [filehash,\\n line_number,\\n Promo_line[0:8].strip(),\\n Promo_line[9:13].strip(),\\n Promo_line[14:19].strip(),\\n Promo_line[20:26].strip().lstrip('0'), # Spec indicates numerical field\\n Promo_line[27:30].strip().lstrip('0'), # Spec indicates numerical field\\n Promo_line[31:40].strip(),\\n Promo_line[41:49].strip(),\\n Promo_line[50:].strip()\\n ]\\n return result\\n # Having the line number passed in is ugly, but kind of works :/\\n # Having all the field extraction explicit is kind of ugly too...\\n # We're using the hash here to link? Yeah, that's because Python\\n # doesn't know what the autonumbered load table is up to in the\\n # DB when it starts to coalesce the raw files together.\",\n \"def agline2(line):\\n \\n vals = {}\\n y = line.strip('\\\\n').split(',')\\n y.extend(y[0].strip('.MTS').split('_'))\\n \\n #print(y)\\n \\n x = ['movie', 'moviecode', 'offset', 'well', 'agmin', 'agsec', 'agdur', \\n 'agtype', 'agcomm', 'escmin', 'escsec', 'escdur', 'esctype', 'escbeh', \\n 'esccomm', 'gen', 'date', 'assay', 'fps', 'flyid', 'side', 'moviepart']\\n \\n z = zip(x, y)\\n\\n for item in z:\\n vals[item[0]] = item[1]\\n\\n return(vals)\",\n \"def _read_header_line_1(self, lines: list) -> dict:\\n fields = (\\n \\\"model_id\\\",\\n \\\"unit_id\\\",\\n \\\"software_level\\\",\\n \\\"message_number\\\",\\n \\\"message_subclass\\\",\\n )\\n if self._is_ct25k():\\n indices = [1, 3, 4, 6, 7, 8]\\n else:\\n indices = [1, 3, 4, 7, 8, 9]\\n values = [split_string(line, indices) for line in lines]\\n return values_to_dict(fields, values)\",\n \"def get_line_desc(self, line):\\n return dict(zip(self.header, line))\",\n \"def parse_header(line):\\n # 2015-09-27 14:55:41 UTC [192.0.2.1]:56721 -> [192.0.2.2]:443 (37):\\n m = re.match(r'(\\\\d{4}-\\\\d{2}-\\\\d{2} \\\\d{2}:\\\\d{2}:\\\\d{2} \\\\S+) \\\\[(.+?)\\\\]:(\\\\d+) -> \\\\[(.+?)\\\\]:(\\\\d+) \\\\((\\\\d+|EOF)\\\\):?', line)\\n if not m:\\n raise LogSyntaxError(line)\\n res = {}\\n res['timestamp'] = m.group(1)\\n res['src_addr'] = m.group(2)\\n res['src_port'] = int(m.group(3))\\n res['dst_addr'] = m.group(4)\\n res['dst_port'] = int(m.group(5))\\n if m.group(6) == 'EOF':\\n res['eof'] = True\\n else:\\n res['eof'] = False\\n res['size'] = int(m.group(6))\\n return res\",\n \"def readHeaders(lines):\\n\\n result = {}\\n for line in lines:\\n if line[0] == \\\"#\\\":\\n continue\\n if line.strip() == \\\"\\\":\\n continue\\n key, value = line.split(\\\":\\\", 1)\\n result[key.strip()] = parseSloppily(value)\\n return result\",\n \"def make_entry(line):\\n #focus on relevant parts\\n parts = line.split(\\\" - \\\")\\n visitor_id = parts[0]\\n subparts = parts[1].split('\\\"')\\n method_and_uri = subparts[1]\\n method_and_uri_parts = method_and_uri.split(\\\" \\\")\\n method = method_and_uri_parts[0]\\n uri = method_and_uri_parts[1]\\n d = dict()\\n d[\\\"visitor_id\\\"] = visitor_id\\n d[\\\"method\\\"] = method\\n d[\\\"uri\\\"] = uri\\n return d\",\n \"def parse_ensembl_line(line, header):\\n line = line.rstrip().split(\\\"\\\\t\\\")\\n header = [head.lower() for head in header]\\n raw_info = dict(zip(header, line))\\n\\n ensembl_info = {}\\n\\n for word in raw_info:\\n value = raw_info[word]\\n if not value:\\n continue\\n\\n if \\\"chromosome\\\" in word:\\n ensembl_info[\\\"chrom\\\"] = value\\n if \\\"gene name\\\" in word:\\n ensembl_info[\\\"hgnc_symbol\\\"] = value\\n if \\\"hgnc id\\\" in word:\\n ensembl_info[\\\"hgnc_id\\\"] = int(value.split(\\\":\\\")[-1])\\n if \\\"hgnc symbol\\\" in word:\\n ensembl_info[\\\"hgnc_symbol\\\"] = value\\n if \\\"strand\\\" in word:\\n ensembl_info[\\\"strand\\\"] = int(value)\\n\\n update_gene_info(ensembl_info, word, value)\\n update_transcript_info(ensembl_info, word, value)\\n update_exon_info(ensembl_info, word, value)\\n update_utr_info(ensembl_info, word, value)\\n update_refseq_info(ensembl_info, word, value)\\n return ensembl_info\",\n \"def _read_header_line_2(lines: list) -> dict:\\n fields = (\\n \\\"detection_status\\\",\\n \\\"warning\\\",\\n \\\"cloud_base_data\\\",\\n \\\"warning_flags\\\",\\n )\\n values = [[line[0], line[1], line[3:20], line[21:].strip()] for line in lines]\\n return values_to_dict(fields, values)\",\n \"def parse(line):\\n return dict([pair.split(':') for pair in line.split()])\",\n \"def split(self, line):\\n parts = line.split()\\n return {\\n 'size': 0 if parts[9] == '-' else int(parts[9]), \\n 'file_requested': parts[6]\\n }\",\n \"def _read_entry_detail(self, line):\\n account_number = 0\\n try:\\n account_number = int(line[12:29].strip().replace('-', ''))\\n except ValueError as err:\\n print('Error parsing account number field -> ' + str(err))\\n\\n result_dict = {'Transaction Code': line[1:3],\\n 'ReceivingID': line[3:11],\\n 'CheckDigit': line[11],\\n 'Account Number': account_number,\\n 'Amount': int(line[29:39]) / 100,\\n 'Individual ID': line[39:54],\\n 'Receiver Name': line[54:76].strip(),\\n 'DiscretionaryData': line[76:78],\\n 'AddendaIndicator': line[78],\\n 'TraceNumber': line[79:94]}\\n\\n self.entries.append(result_dict)\",\n \"def parse_header(header_lines):\\n info = {}\\n for line in header_lines:\\n if line.startswith('Citation'):\\n info['Citation'] = line.split()[-1].strip()\\n elif ':' in line:\\n try:\\n field, value = map(strip,line.split(':',1))\\n info[field] = value\\n except ValueError:\\n #no interesting header line\\n continue\\n else:\\n continue\\n return Info(info)\",\n \"def _read_batch_header(self, line):\\n try:\\n effective_entry_date = datetime.strptime(line[69:75], '%y%m%d')\\n except ValueError as err:\\n print('Error parsing effective entry date -> ' + str(err))\\n effective_entry_date = '00000000'\\n\\n batch_header_dict = {'Service Class Code': line[1:4],\\n 'Company Name': line[4:20].strip(),\\n 'Company Discretionary Data': line[20:40].strip(),\\n 'Company ID': line[40:50].strip(),\\n 'SEC Code': line[50:53],\\n 'Company Entry Description': line[53:63].strip(),\\n 'Company Descriptive Date': line[63:69].strip(),\\n 'Effective Entry Date': effective_entry_date,\\n 'Settlement Date Julian': line[75:78],\\n 'Originator Status Code': line[78],\\n 'Originating DFI ID': line[79:87],\\n 'Batch Number': line[87:94]}\\n self.batch_headers.append(batch_header_dict)\",\n \"def process_entries(entries):\\n data = {}\\n for e in entries:\\n e = e.strip()\\n if e and not e.startswith('#') and not e.startswith('-e'):\\n project, version = e.split('==')\\n if not version:\\n raise ValueError(\\\"Unexpected syntax '{0}'\\\".format(e))\\n data[project] = version\\n return data\",\n \"def parse_line(cls, line):\\n assert isinstance(line, bytes)\\n\\n match = HEADER_FIELD_REGEX.match(line)\\n\\n if not match:\\n raise HeaderParseError(line)\\n\\n name, content = (s.decode(\\\"ascii\\\").strip() for s in match.groups(b\\\"\\\"))\\n name = name.lower()\\n\\n if name != \\\"set-cookie\\\" or is_rfc1123_datetime(content):\\n content = cls.split_field_content(content)\\n\\n return (name, content)\",\n \"def parse_results(stdout):\\n for line in stdout.split(b\\\"\\\\n\\\"):\\n log.debug(\\\"processing line %s\\\", line)\\n fields = line.strip().split()\\n if len(fields) != 9:\\n continue\\n metric = fields[1].decode(\\\"ascii\\\")\\n info = lm_function_map[metric]\\n dtype = info['dtype']\\n yield {\\n \\\"metric\\\": metric,\\n \\\"n_compart\\\": int(fields[3]),\\n \\\"n_exclude\\\": int(fields[4].strip(b\\\"()\\\")),\\n \\\"total\\\": dtype(fields[2]),\\n \\\"min\\\": dtype(fields[5]),\\n \\\"avg\\\": float(fields[6]),\\n \\\"max\\\": dtype(fields[7]),\\n \\\"units\\\": info[\\\"units\\\"],\\n }\",\n \"def analyseHeaders(line):\\n\\n csvlist=[]\\n for col in line:\\n \\tfound=False\\n \\tcol=col.lower()\\n\\tfor key in hostinfo:\\n\\t if col in hostinfo[key]['aka']:\\n\\t \\tcsvlist.append(key)\\n\\t\\tfound=True\\n\\t\\tcontinue\\n\\tif not found:\\n\\t csvlist.append('-')\\n\\n if verbFlag:\\n \\tprint \\\"CSV to key mapping\\\"\\n\\tfor i in range(len(csvlist)):\\n\\t try:\\n\\t \\tline[i]\\n\\t except IndexError:\\n\\t \\tcontinue\\n\\t if csvlist[i]=='-':\\n\\t \\tprint \\\"\\\\t%s-> unmapped\\\" % line[i]\\n\\t else:\\n\\t\\tprint \\\"\\\\t%s->%s\\\" % (line[i], csvlist[i])\\n\\n return csvlist\",\n \"def _parse_head(line):\\n retval = {}\\n m = re.match(\\n '[0-9]+: (?P<if>\\\\w+\\\\d{1,3}): <(?P<flags>[^>]+)> mtu (?P<mtu>[0-9]+)',\\n line\\n )\\n if m:\\n retval['ifname'] = m.group('if')\\n retval['mtu'] = int(m.group('mtu'))\\n retval['flags'] = m.group('flags').split(',')\\n return retval\",\n \"def parse_line(self, line):\\n line = line.strip()\\n log.debug(\\\"Parsing line: '{}'\\\".format(line))\\n if len(line) == 0:\\n log.warning(\\\"Zero length line detected\\\")\\n return\\n split = line.split(DELIMETER)\\n key = split[0]\\n if key in FORMATS:\\n log.debug(\\\"Using formatter for key: {}\\\".format(key))\\n formatter = FORMATS[key]\\n for (name, parser), value in zip(formatter,split[1:]):\\n self._params[name] = parser(value)\\n log.info(\\\"Parameters: {}\\\".format(self._params))\\n self.notify_watchers()\\n else:\\n log.debug(\\\"Invalid key: {}\\\".format(key))\",\n \"def _parse_handle_section(lines):\\n data = {}\\n key = ''\\n next(lines)\\n\\n for line in lines:\\n line = line.rstrip()\\n if line.startswith('\\\\t\\\\t'):\\n if isinstance(data[key], list):\\n data[key].append(line.lstrip())\\n elif line.startswith('\\\\t'):\\n key, value = [i.strip() for i in line.lstrip().split(':', 1)]\\n key = normalize(key)\\n if value:\\n data[key] = value\\n else:\\n data[key] = []\\n else:\\n break\\n\\n return data\",\n \"def _process_line(line, status):\\n\\n if line.startswith(ADAPTER_LINE_STARTSWITH):\\n status.add_block('adapter', 'name', line)\\n return\\n elif line.startswith(EXIT_LINE_STARTSWITH):\\n status.consolidate()\\n return\\n\\n key, value = [el.strip(' \\\\t\\\\r\\\\n') for el in line.split(':', 1)]\\n\\n if key in KEY_TO_CONTEXT.keys():\\n status.add_block(KEY_TO_CONTEXT[key], key, value)\\n else:\\n status.set_property(key, value)\",\n \"def _read_header(self, line):\\n try:\\n creation_date = datetime.strptime(line[23:33], '%y%m%d%H%M')\\n except ValueError as err:\\n print('Error parsing file creation date -> ' + str(err))\\n creation_date = '000000'\\n\\n self.file_header = {'Priority Code': line[1:3],\\n 'Immediate Destination': line[3:13].strip(),\\n 'Immediate Origin': line[13:23].strip(),\\n 'Creation Date': creation_date,\\n 'File ID Modifier': line[33],\\n 'Record Size': int(line[34:37].strip()),\\n 'Blocking Factor': int(line[37:39]),\\n 'Format Code': line[39],\\n 'Immediate Destination Name': line[40:63].strip(),\\n 'Immediate Origin Name': line[63:86].strip(),\\n 'Reference Code': line[86:93]}\",\n \"def Process_line(line, summary):\\n line = line.lower() # lower all words in the line\\n line = line.translate(str.maketrans('','', string.punctuation)) # Remove all punctuation\\n words = line.split() # Split word from the line\\n add_word(words, summary) # Add word to dictionary\",\n \"def parse(self, line):\\n try:\\n (year, month, day, hour, minute, second, microseconds, offset_hour, offset_minute, source, process, logentry) = re.match('^(\\\\d\\\\d\\\\d\\\\d)-(\\\\d\\\\d)-(\\\\d\\\\d)T(\\\\d\\\\d):(\\\\d\\\\d):(\\\\d\\\\d)\\\\.([\\\\d]+)\\\\+(\\\\d\\\\d):(\\\\d\\\\d) ([a-z]+)\\\\[([a-zA-Z0-9_.]+)\\\\]: ([0-9a-z-A-Z\\\\-_\\\\.\\\\[\\\\]:\\\\?\\\\#\\\\\\\",/\\\\ ={}\\\\'\\\\(\\\\)<>]+)$', line).groups()\\n except:\\n pass\\n \\n try:\\n parsed_data = dict()\\n parsed_data['timestamp'] = \\\" \\\".join([\\\"-\\\".join([year, month, day]), \\\":\\\".join([hour, minute, second])])\\n parsed_data['log_time'] = datetime.datetime(int(year), int(month), int(day), int(hour), int(minute), int(second))\\n parsed_data['log_source'] = source\\n parsed_data['log_type'] = process\\n except (AttributeError, UnboundLocalError):\\n PARSE_ERRORS.append(line)\\n return False\\n\\n #TODO: This still needs work on spaces in values surrounded by \\\" \\\" \\n if parsed_data['log_source'] == \\\"heroku\\\":\\n if logentry.__len__() > 1:\\n logentry = re.sub(', ', ',', logentry)\\n line_chunks = re.split(' ', logentry)\\n for chunk in line_chunks:\\n line_chunks = re.split('=', chunk)\\n if line_chunks.__len__() > 2:\\n #fwd and path are a little clunky to parse\\n pass\\n elif line_chunks.__len__() > 1:\\n parsed_data[line_chunks[0]] = line_chunks[1]\\n else:\\n pass\\n else:\\n return False\\n else:\\n # TODO: [app] \\n # Needs parsing. Do that here.\\n return False\\n\\n return parsed_data\",\n \"def parse(lines): \\n replied = len(lines)\\n avg_delay, lost = 0, 0\\n qos = 1.0\\n \\n if replied != 0:\\n for line in lines:\\n line.strip() #remove leading and trailing spaces\\n \\\"\\\"\\\"\\n Each line has the following fields:\\n [status code] [reply time (seconds since epoch)] [source IP] [source url] [source query] [serving delay]\\n \\n e.g.:\\n 200 1296756182 192.168.10.2 /home.php ?N=192 11045\\n 200 1296756183 192.168.10.2 /home.php ?N=192 230036\\n 200 1296756183 192.168.10.2 /home.php ?N=192 230684\\n \\\"\\\"\\\"\\n status, time, sourceIP, url, query, delay = line.split()\\n \\n time = int(time)\\n delay = int(delay)\\n \\n if delay > DEADLINE:\\n lost += 1\\n avg_delay += delay\\n avg_delay /= replied\\n qos = (replied - lost) / replied\\n\\n return {'replied': replied, 'delay' : avg_delay, 'qos' : qos, 'lost': lost}\",\n \"def collect_response(response_lines):\\n response_dict = {}\\n for entry in filter(None, response_lines):\\n prefix = entry[0]\\n if prefix in response_dict:\\n response_dict[prefix] += [entry]\\n else:\\n response_dict[prefix] = [entry]\\n return response_dict\",\n \"def parse_header_parameters(line):\\n parts = _parseparam(\\\";\\\" + line)\\n key = parts.__next__().lower()\\n pdict = {}\\n for p in parts:\\n i = p.find(\\\"=\\\")\\n if i >= 0:\\n has_encoding = False\\n name = p[:i].strip().lower()\\n if name.endswith(\\\"*\\\"):\\n # Lang/encoding embedded in the value (like \\\"filename*=UTF-8''file.ext\\\")\\n # https://tools.ietf.org/html/rfc2231#section-4\\n name = name[:-1]\\n if p.count(\\\"'\\\") == 2:\\n has_encoding = True\\n value = p[i + 1 :].strip()\\n if len(value) >= 2 and value[0] == value[-1] == '\\\"':\\n value = value[1:-1]\\n value = value.replace(\\\"\\\\\\\\\\\\\\\\\\\", \\\"\\\\\\\\\\\").replace('\\\\\\\\\\\"', '\\\"')\\n if has_encoding:\\n encoding, lang, value = value.split(\\\"'\\\")\\n value = unquote(value, encoding=encoding)\\n pdict[name] = value\\n return key, pdict\",\n \"def addline(self, line):\\n # If the line begins with whitespace, assume it is a continuation of\\n # the previous line, and append it to the last value read. I'm not\\n # sure how legit this is but all examples of multi-line headers\\n # I've seen seem to follow this pattern. It is possible that\\n # the previous line ending with ; is a more reliable indicator.\\n if line.startswith('\\\\t'):\\n # Since we are using OrderedDict, can get the most recently\\n # added key.\\n key = list(self.keys())[-1]\\n vals = [ll.strip() for ll in line[1].split(';')]\\n self[key].extend(vals)\\n else:\\n idx = line.index(':')\\n key = line[:idx]\\n vals = [ll.strip() for ll in line[idx+1:].split(';')]\\n self[key] = vals\",\n \"def read(self):\\r\\n entById = {}\\r\\n entsByName = {}\\r\\n header = 'HEADER '\\r\\n readheader = False\\r\\n for line in self.file:\\r\\n e = self.parseLine(line)\\r\\n if e:\\r\\n entById[int(e[\\\"id\\\"])] = e\\r\\n ids = e.get(e[\\\"name\\\"],[])\\r\\n ids.append(e[\\\"id\\\"])\\r\\n entsByName[e[\\\"name\\\"]] = list(set(ids))\\r\\n elif 'HEADER' in line:\\r\\n readheader = True\\r\\n elif readheader:\\r\\n if 'ENDSEC' in line:\\r\\n readheader = False\\r\\n else:\\r\\n header += line\\r\\n \\r\\n return [entById, entsByName, header]\",\n \"def parse_line(line, patterns=None):\\n if patterns is None:\\n patterns = LINE_PATTERNS\\n\\n for line_re in patterns:\\n match = line_re.match(line)\\n if match:\\n data = match.groupdict()\\n av_pairs = data['av_pairs']\\n data['av_pairs'] = cleanup_av_pairs(av_pairs)\\n return data\\n\\n return None\",\n \"def parse_header_block(lines):\\n data = [line for line in lines[:MAX_HEADER_HEIGHT] if line.strip()]\\n if not data or not INVITATION_RE.match(data[0]):\\n return None\\n out = {'number':None, 'type':None, 'date':None, 'time':None, 'place':None, 'datetime':None}\\n for item in data:\\n # typ a poradove cislo zastupitelstva\\n m = TITLE_RE.match(item)\\n if m:\\n out['number'] = m.group(1).strip()\\n out['type'] = m.group(2).strip()\\n\\n # den konani zastupitelstva\\n m = TERM_DATE_RE.match(item)\\n if m:\\n try:\\n out['date'] = date(int(m.group(3).strip()), int(m.group(2).strip()), int(m.group(1).strip()))\\n except ValueError:\\n pass\\n\\n # cas konani zastupitelstva\\n m = TERM_TIME_RE.match(item)\\n if m:\\n try:\\n out['time'] = time(int(m.group(1).strip()), int(m.group(2).strip()))\\n except ValueError:\\n pass\\n\\n # misto konani zastupitelstva\\n m = PLACE_RE.match(item)\\n if m:\\n out['place'] = m.group(1).strip()\\n\\n # poskladani kompletniho datetime objektu\\n out['datetime'] = out['date'] and out['time'] and \\\\\\n datetime.combine(out['date'], out['time']) or None\\n\\n return out\",\n \"def parse_parameters_file(lines):\\n param_dict = {}\\n for line in lines:\\n line = line.strip()\\n if line:\\n (param, values) = line.split('\\\\t')\\n param_dict[param] = values.split(',')\\n return param_dict\",\n \"def parse_line(self, line):\\n\\n kv_match = self.kv_rex.match(line)\\n\\n if kv_match:\\n kv_dict = kv_match.groupdict()\\n kv_key = kv_dict['key']\\n kv_value = kv_dict['value']\\n\\n if 'time_' in kv_key:\\n kv_unit = kv_dict['unit']\\n\\n if not kv_key in self.kv_times:\\n self.kv_times[kv_key] = {'unit': kv_unit, 'values': []}\\n\\n self.kv_times[kv_key]['values'].append(float(kv_value))\\n else:\\n if not kv_key in self.kv_counts:\\n self.kv_counts[kv_key] = 0.0\\n\\n self.kv_counts[kv_key] += float(kv_value)\",\n \"def map_line(reader, headers):\\n\\n readings = {}\\n\\n line = reader.readline()\\n\\n if len(line) == 0:\\n raise EOFError('That\\\\'s all the data!')\\n\\n line = line.rstrip()\\n\\n value_strings = line.split(' ')\\n for i, string in enumerate(value_strings):\\n if string != 'NaN':\\n value = float(string)\\n\\n if i < len(headers):\\n if headers[i]['is_point']:\\n value = get_decimal_degrees(value)\\n key = headers[i]['name'] + \\\"-\\\" + headers[i]['units']\\n readings[key] = value\\n\\n # Provide generic timestamp regardless of type for iterator\\n # convenience\\n # Keep originals for those interested\\n if 'm_present_time-timestamp' in readings:\\n readings['timestamp'] = readings['m_present_time-timestamp']\\n elif 'sci_m_present_time-timestamp' in readings:\\n readings['timestamp'] = readings['sci_m_present_time-timestamp']\\n\\n return readings\",\n \"def task1_mapper():\\n line_count = 0\\n for line in sys.stdin:\\n # Clean input and split it\\n lines = line.strip().split(\\\",\\\")\\n line_count += 1\\n # Check that the line is of the correct format and filtering the HEADER record \\n # If line is malformed, we ignore the line and continue to the next line\\n if line_count == 1:\\n continue\\n else:\\n if len(lines) != 12:\\n continue\\n \\n category = lines[3].strip()\\n videoid = lines[0].strip()\\n country = lines[11].strip()\\n k_key = category+','+videoid\\n\\n print(\\\"{}\\\\t{}\\\".format(k_key, country))\",\n \"def process_log(log_file):\\n result_list = []\\n file_root = get_fname_root(log_file)\\n\\n with open(log_file) as l_file:\\n reading_steps = False\\n result_dict = {}\\n for line in l_file:\\n line = line.strip()\\n if STEP_PAT.match(line):\\n reading_steps = True\\n result_dict[FILE_NAME] = file_root\\n result_dict[TIMESTEP] = int(line.split()[2])\\n elif reading_steps:\\n if len(line) == 0:\\n break\\n s_line = line.split()\\n if s_line[0] == TOTENG:\\n for key_id, key in enumerate([TOTENG, KINENG, TEMP]):\\n result_dict[key] = float(s_line[2 + key_id * 3])\\n elif s_line[0] == POTENG:\\n for key_id, key in enumerate([POTENG, E_BOND, E_ANGL]):\\n result_dict[key] = float(s_line[2 + key_id * 3])\\n elif s_line[0] == E_DIHED:\\n for key_id, key in enumerate([E_DIHED, E_IMPRO, E_VDWL]):\\n result_dict[key] = float(s_line[2 + key_id * 3])\\n elif s_line[0] == E_COUL:\\n for key_id, key in enumerate([E_COUL, E_LONG, PRESS]):\\n result_dict[key] = float(s_line[2 + key_id * 3])\\n result_list.append(dict(result_dict))\\n else:\\n # when stop matching, done reading file (either by normal or abnormal termination)\\n break\\n\\n return result_list\",\n \"def _parse_line(self, line):\\n msg_info = {'raw_message': line}\\n line_split = line.split(None, 2)\\n try:\\n msg_info['timestamp'] = datetime.strptime(' '.join(line_split[:2]), self.time_format)\\n msg_info['message'] = line_split[2]\\n except (ValueError, IndexError):\\n pass\\n return msg_info\",\n \"def process_line(nlp, line, parsed_file):\\n m = json.loads(line)\\n if \\\"highlights\\\" in m:\\n if m['sentences'] != '' and m['sentences'] != [] and m['sentences'] != [''] and m['highlights'] != '':\\n m[\\\"highlights_ud\\\"] = dependency_parse(nlp, m['highlights'])\\n m[\\\"sentences_ud\\\"] = dependency_parse(nlp, m['sentences'])\\n else:\\n if m['sentences'] != '' and m['sentences'] != [] and m['sentences'] != ['']:\\n m[\\\"sentences_ud\\\"] = dependency_parse(nlp, m['sentences'])\\n if \\\"sentences_ud\\\" in m:\\n parsed_file.write(json.dumps(m))\\n parsed_file.write('\\\\n')\",\n \"def process_query(query_file):\\r\\n query_data = query_file.readlines()\\r\\n query_dict = {}\\r\\n x = 1 \\r\\n search_dict = {}\\r\\n search_dict['username'] = query_data[x].strip('\\\\n')\\r\\n x += 1\\r\\n operation_list = []\\r\\n \\r\\n while query_data[x] != 'FILTER\\\\n': \\r\\n operation_list.append(query_data[x].strip('\\\\n'))\\r\\n x += 1\\r\\n \\r\\n search_dict['operations'] = operation_list \\r\\n query_dict['search'] = search_dict \\r\\n x += 1\\r\\n \\r\\n filter_dict = {}\\r\\n filter_format(filter_dict, query_data, 'name-includes', x)\\r\\n filter_format(filter_dict, query_data, 'location-includes', x)\\r\\n filter_format(filter_dict, query_data, 'follower', x)\\r\\n filter_format(filter_dict, query_data, 'following', x)\\r\\n query_dict['filter'] = filter_dict\\r\\n \\r\\n present_dict = {}\\r\\n sort_by = query_data[-2].strip('sort-by ')\\r\\n present_dict['sort-by'] = sort_by.strip('\\\\n')\\r\\n \\r\\n format_type = query_data[-1].lstrip('format ')\\r\\n present_dict['format'] = format_type\\r\\n query_dict['present'] = present_dict\\r\\n \\r\\n return query_dict\",\n \"def test_parseLine1(mocker):\\n \\n # given: setup test framework\\n worker = Worker()\\n testString = \\\"12Nov2019,Teacher,Brighter Futures,12000\\\"\\n expectedResult = {\\n 'date': '2019-11-12',\\n 'job_title': 'Teacher',\\n 'company_name': 'Brighter Futures',\\n 'salary': 12000\\n }\\n \\n # when:\\n result = worker.parseLineCSV(testString)\\n \\n # then:\\n assert result == expectedResult\",\n \"def process_query (file):\\n\\n # initialize all the dictionaries and lists we will be using\\n query_data = {}\\n query_data ['search'] = {'operations':[]}\\n query_data ['filter'] = {}\\n query_data ['present'] = {}\\n\\n temp = ''\\n\\n file.readline() # for when the file says SEARCH\\n\\n query_data ['search']['username'] = file.readline().strip()\\n\\n temp = file.readline().strip()\\n while temp != 'FILTER': # go until the the filter section\\n query_data ['search']['operations'].append (temp)\\n temp = file.readline().strip()\\n\\n temp = file.readline().strip()\\n while temp != 'PRESENT': # go until the present section\\n # we make the key everything from the beginning to the first space\\n # then the value is everything after the first space\\n query_data ['filter'][temp[:temp.find(' ')]] = temp[temp.find(' ') + 1:]\\n temp = file.readline().strip()\\n\\n temp = file.readline().strip()\\n while temp != '': # go until the end of the file\\n # same process as the previous while loop\\n query_data ['present'][temp[:temp.find(' ')]] = temp[temp.find(' ') + 1:]\\n temp = file.readline().strip()\\n\\n return query_data\",\n \"def _parser(self,\\n search_str):\\n return {line_index: parsed_line_keys for (line_index, parsed_line_keys)\\n in enumerate(self._load_line(search_str=search_str))\\n if parsed_line_keys\\n }\",\n \"def process_header_request(self, request, http_s_obj):\\n response_dict = {}\\n data = request.split(\\\"\\\\r\\\\n\\\\r\\\\n\\\")\\n header_info = data[0].split(\\\"\\\\r\\\\n\\\")\\n headers = self.updateheader(header_info, http_s_obj)\\n response_dict.update({'type': header_info[0].split()[0]})\\n response_dict.update({'headers': headers})\\n body = data[1]\\n response_dict.update({'data': body})\\n path = header_info[0].split()[1]\\n if path.find('?') != -1:\\n split_sym = '?'\\n if path.find('&') != -1:\\n split_sym = '&'\\n try:\\n req = path.split(split_sym)\\n path = req[0]\\n query = req[1]\\n except Exception as e:\\n query = ''\\n response_dict.update({'path': path})\\n response_dict.update({'query': query})\\n\\n return response_dict\",\n \"def parse_line(self, line):\\n raise NotImplementedError\",\n \"def main(iterator):\\n\\n entries = OrderedDict()\\n for line in iterator:\\n\\n if \\\"START\\\" in line:\\n entries.update({\\\"start_time\\\":int(re.search(r'\\\\d+', line).group())})\\n if \\\"STOP\\\" in line:\\n entries.update({\\\"end_time\\\":int(re.search(r'\\\\d+', line).group())})\\n if \\\"NUMERIC SORT\\\" in line and \\\"Done with\\\" not in line:\\n #print(float(re.search(r'\\\\d+', line).group()))\\n entries.update({\\\"numeric_sort\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n entries.update({\\\"numeric_sort_abs_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"numeric_sort_rel_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"numeric_sort_num_runs\\\":int(re.search(r'\\\\d+', line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"numeric_sort_num_arrs\\\":int(re.search(r'\\\\d+', line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"numeric_sort_arr_size\\\":int(re.search(r'\\\\d+', line).group())})\\n\\n if \\\"STRING SORT\\\" in line and \\\"Done with\\\" not in line:\\n #print(float(re.search(r'\\\\d+', line).group()))\\n entries.update({\\\"string_sort\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"string_sort_abs_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"string_sort_rel_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"string_sort_num_runs\\\":int(re.search(r'\\\\d+', line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"string_sort_num_arrs\\\":int(re.search(r'\\\\d+', line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"string_sort_arr_size\\\":int(re.search(r'\\\\d+', line).group())})\\n\\n if \\\"STRING SORT\\\" in line and \\\"Done with\\\" not in line:\\n #print(float(re.search(r'\\\\d+', line).group()))\\n entries.update({\\\"string_sort\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"string_sort_abs_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"string_sort_rel_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"string_sort_num_runs\\\":int(re.search(r'\\\\d+', line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"string_sort_num_arrs\\\":int(re.search(r'\\\\d+', line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"string_sort_arr_size\\\":int(re.search(r'\\\\d+', line).group())})\\n\\n if \\\"BITFIELD\\\" in line and \\\"Done with\\\" not in line:\\n #print(float(re.search(r'\\\\d+', line).group()))\\n entries.update({\\\"bitfield\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"bitfield_abs_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"bitfield_rel_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"bitfield_num_runs\\\":int(re.search(r'\\\\d+', line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"bitfield_ops_arr_size\\\":int(re.search(r'\\\\d+', line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"bitfield_arr_size\\\":int(re.search(r'\\\\d+', line).group())})\\n\\n if \\\"FP EMULATION\\\" in line and \\\"Done with\\\" not in line:\\n #print(float(re.search(r'\\\\d+', line).group()))\\n entries.update({\\\"fp_emul\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"fp_emul_abs_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"fp_emul_rel_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"fp_emul_num_runs\\\":int(re.search(r'\\\\d+', line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"fp_emul_num_loops\\\":int(re.search(r'\\\\d+', line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"fp_emul_arr_size\\\":int(re.search(r'\\\\d+', line).group())})\\n\\n if \\\"FOURIER\\\" in line and \\\"Done with\\\" not in line:\\n #print(float(re.search(r'\\\\d+', line).group()))\\n entries.update({\\\"fourier\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"fourier_abs_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"fourier_rel_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"fourier_num_runs\\\":int(re.search(r'\\\\d+', line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"fourier_num_coef\\\":int(re.search(r'\\\\d+', line).group())})\\n\\n if \\\"ASSIGNMENT\\\" in line and \\\"Done with\\\" not in line:\\n #print(float(re.search(r'\\\\d+', line).group()))\\n entries.update({\\\"assignment\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n entries.update({\\\"assignment_abs_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"assignment_rel_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"assignment_num_runs\\\":int(re.search(r'\\\\d+', line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"assignment_num_arrs\\\":int(re.search(r'\\\\d+', line).group())})\\n\\n if \\\"IDEA\\\" in line and \\\"Done with\\\" not in line:\\n #print(float(re.search(r'\\\\d+', line).group()))\\n entries.update({\\\"idea\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"idea_abs_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"idea_rel_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"idea_num_runs\\\":int(re.search(r'\\\\d+', line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"idea_arr_size\\\":int(re.search(r'\\\\d+', line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"idea_num_loops\\\":int(re.search(r'\\\\d+', line).group())})\\n \\n if \\\"HUFFMAN\\\" in line and \\\"Done with\\\" not in line:\\n #print(float(re.search(r'\\\\d+', line).group()))\\n entries.update({\\\"huffman\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"huffman_abs_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"huffman_rel_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"huffman_num_runs\\\":int(re.search(r'\\\\d+', line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"huffman_arr_size\\\":int(re.search(r'\\\\d+', line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"huffman_num_loops\\\":int(re.search(r'\\\\d+', line).group())})\\n\\n\\n if \\\"NEURAL NET\\\" in line and \\\"Done with\\\" not in line:\\n #print(float(re.search(r'\\\\d+', line).group()))\\n entries.update({\\\"nnet\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"nnet_abs_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"nnet_rel_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"nnet_num_runs\\\":int(re.search(r'\\\\d+', line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"nnet_num_loops\\\":int(re.search(r'\\\\d+', line).group())})\\n\\n if \\\"LU DECOMPOSITION\\\" in line and \\\"Done with\\\" not in line:\\n #print(float(re.search(r'\\\\d+', line).group()))\\n entries.update({\\\"lu_decomp\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"lu_decomp_abs_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"lu_decomp_rel_sdv\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"lu_decomp_num_runs\\\":int(re.search(r'\\\\d+', line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"lu_decomp_num_arrs\\\":int(re.search(r'\\\\d+', line).group())})\\n\\n if \\\"libc\\\" in line and \\\"Baseline\\\" not in line and \\\"*\\\" not in line:\\n line = next(iterator)\\n \\n entries.update({\\\"memory_index\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"integer_index\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n line = next(iterator)\\n \\n entries.update({\\\"float_index\\\":float(re.search(r\\\"[+-]?(\\\\d+(\\\\.\\\\d*)?|\\\\.\\\\d+)([eE][+-]?\\\\d+)?\\\", line).group())})\\n\\n #print(entries)\\n return entries\",\n \"def parse_line(line: str) -> Tuple[str, dict]:\\n email, first_name, last_name, birth, gender = line.split(\\\",\\\")\\n person = {\\n \\\"first_name\\\": first_name,\\n \\\"last_name\\\": last_name,\\n \\\"birth\\\": birth,\\n \\\"gender\\\": gender,\\n }\\n return email, person\",\n \"def parse(lines, descriptions):\\n # TODO does startswith with an empty string always return true?\\n result = {}\\n for description in descriptions: # Fill dict with empty arrays for all entries\\n result[description[0]] = []\\n\\n for line in lines:\\n words = line.split()\\n for description in descriptions:\\n try:\\n result[description[0]].append(parse_line(words, description[0], description[1]))\\n break\\n except ValueError:\\n pass\\n return result\",\n \"def extract(self):\\n self.logger.info(f'Opening {self.file}')\\n try:\\n f = open(self.file, 'r')\\n except FileNotFoundError:\\n self.logger.info('Could not open the .vrt file')\\n return\\n\\n result = {}\\n self.logger.info('Extracting')\\n for line in f:\\n # Only attempt to extract if line is correct\\n if self.is_target(line):\\n # Add the closing text tag to make the line have proper XML\\n xml_attributes = XML.fromstring(line.rstrip()+'</text>').attrib\\n # Extract wanted parameters\\n month = xml_attributes['date'][5:7] # Extract month\\n # Add month to the keys\\n if month not in result.keys():\\n result[month] = []\\n result[month].append({\\n 'title': xml_attributes['title'], # Extract thread title\\n 'thread_id': xml_attributes['thread_id'], # Extract thread id\\n 'datetime': xml_attributes['datetime'] # Extract datetime\\n })\\n self.logger.info('Extraction complete')\\n self.db = result\\n # self.db[self.year] = result # Assign results to year\\n self.save_result() # Save the results\",\n \"def parse_lines(lines, options=None):\\n if not options:\\n options = {}\\n res = []\\n transaction = OrderedDict()\\n for (idx, line) in enumerate(lines):\\n line = line.strip()\\n if not line:\\n continue\\n field_id = line[0]\\n if field_id == \\\"^\\\":\\n if transaction:\\n res.append(transaction)\\n transaction = OrderedDict([])\\n elif field_id in list(config.FIELDS.keys()):\\n transaction[config.FIELDS[field_id]] = line[1:]\\n elif line:\\n transaction[\\\"%s\\\" % idx] = line\\n\\n if len(list(transaction.keys())):\\n res.append(transaction)\\n\\n # post-check to not interfere with present keys order\\n for t in res:\\n for field in list(config.FIELDS.values()):\\n if field not in t:\\n t[field] = None\\n t[u\\\"filename\\\"] = options.get(\\\"src\\\", \\\"\\\")\\n return res\",\n \"def parse_line(line, key):\\n keys = key.split(', ')\\n ParseLine = (line.get(id) for id in keys)\\n\\n return ParseLine\",\n \"def parse_header(self):\",\n \"def _parse_refraction(line, lines):\\n split_line = line.split()\\n\\n energy = float(split_line[0])\\n ref_ind_xx = float(split_line[1])\\n ref_ind_zz = float(split_line[2])\\n extinct_xx = float(split_line[3])\\n extinct_zz = float(split_line[4])\\n\\n return {\\\"energy\\\": energy, \\\"ref_ind_xx\\\": ref_ind_xx, \\\"ref_ind_zz\\\": ref_ind_zz, \\\"extinct_xx\\\": extinct_xx,\\n \\\"extinct_zz\\\": extinct_zz}\",\n \"def parse_lines(self, lines):\\n assert isinstance(lines, Iterable)\\n\\n for line in lines:\\n name, values = self.parse_line(line)\\n self.add(name, values)\",\n \"def _parse_general_info(self, line):\\n if self._regex_helper.search_compiled(W._re_general_info, line):\\n self.current_ret['GENERAL_INFO'].update({\\n 'time': datetime.datetime.strptime(self._regex_helper.group(\\\"TIME\\\"), '%H:%M:%S').time(),\\n 'uptime': self._regex_helper.group(\\\"UPTIME\\\"),\\n 'user_number': self._regex_helper.group(\\\"USER_NUMBER\\\"),\\n 'load_average': self._regex_helper.group(\\\"L_AVERAGE\\\")\\n })\\n raise ParsingDone\",\n \"def _parse_logs_for_results(self, logs):\\n results = {}\\n for line in logs.split(\\\"\\\\n\\\"):\\n split_line = line.split(\\\":\\\")\\n if len(split_line) == 2:\\n results[split_line[0].strip()] = split_line[1].strip()\\n if results == {}:\\n results = None\\n return results\",\n \"def process_entry(self):\\n\\n for line_item in self.entry:\\n pairs = line_item.split(' ')\\n for pair in pairs:\\n if ':' in pair:\\n key, value = pair.split(':')\\n if value.isdigit():\\n self.fields[key] = int(value)\\n else:\\n self.fields[key] = value\",\n \"def parse_entry(lines):\\n entry = {}\\n for line in lines:\\n line = line.replace('\\\\n', '').replace('\\\\r', '')\\n if ':: ' in line:\\n (key, value) = line.split(':: ')\\n value = base64.b64decode(value).decode('utf-8')\\n elif ': ' in line:\\n (key, value) = line.split(': ')\\n else:\\n continue\\n if key not in entry:\\n entry[key] = []\\n entry[key].append(value)\\n return entry\",\n \"def _parse_results(self):\\n for line in self.file_dic['output'].splitlines():\\n if line.startswith(' * GAMESS VERSION = '):\\n temp = line.split('=')[1]\\n temp = temp.split('*')[0]\\n self.version = temp.strip()\\n\\n if line[1:25] == 'FREE ENERGY OF SOLVATION' and line.find('1 ATM') == -1:\\n temp = line.split()\\n #Take the next number after =\\n #In KCAL/MOL\\n self.solvation_energy = float(temp[temp.index(\\\"=\\\") + 1])\",\n \"def parse_log_entry(line):\\n\\n line_pattern = r\\\"^(?P<host>.*) - - \\\\[(?P<timestamp>.*)\\\\] \\\" \\\\\\n \\\"\\\\\\\"(?P<request>.*)\\\\\\\" (?P<http_code>\\\\d\\\\d\\\\d) (?P<bytes>.*)$\\\"\\n line_groups = re.match(line_pattern, line)\\n request_pattern = r\\\"^(?P<request_method>[A-Z]*) (?P<resource>\\\\S+) ?.*$\\\"\\n request_groups = re.match(request_pattern, line_groups.group('request'))\\n host = line_groups.group('host')\\n timestamp = line_groups.group('timestamp')\\n timestamp = parse_date(line_groups.group('timestamp'))\\n http_code = int(line_groups.group('http_code'))\\n num_bytes = line_groups.group('bytes')\\n num_bytes = 0 if num_bytes == '-' else int(num_bytes)\\n if request_groups:\\n request_method = request_groups.group('request_method')\\n resource = request_groups.group('resource')\\n else:\\n request_method = None\\n resource = None\\n return ParsedRequest(\\n host, timestamp, request_method,\\n resource, http_code, num_bytes)\",\n \"def parse(line):\\n data = json.loads(line)\\n return data['SUPPLIERS_ID'], data['CATEGORY_ID'], data['NAME'], data['COUNTRY'], data['CITY'], data[\\n 'LAST_UPDATE_DATE']\",\n \"def parse_lines(lines):\\n for line in lines:\\n yield Record(line)\",\n \"def _analyzeLine(self, line, date, data):\\n user = re.search(': (.*)', line).group().split()[1]\\n data[user].add(ConvertTime(date, line))\",\n \"def parse_file_content(content_of_log_file):\\n \\n search_regex = re.compile('^=== \\\\[(?P<process_time>.+)\\\\] :(?P<process_state>.+): (?P<process_name>[^\\\\s]+)\\\\s*(?P<process_status>[0-9])*$')\\n jobs_dict = {}\\n for log_line in content_of_log_file:\\n parsed_log_line = search_regex.search(log_line)\\n if parsed_log_line is not None:\\n process = parsed_log_line.group('process_name')\\n if parsed_log_line.group('process_state') == \\\"START\\\" : \\n start_time = (parsed_log_line.group('process_time'))\\n jobs_dict[process] = Job(name = process, start_time = start_time, end_time = None, status = None)\\n elif parsed_log_line.group('process_state') == \\\"END\\\":\\n end_time = parsed_log_line.group('process_time')\\n if process in jobs_dict.keys():\\n jobs_dict[process].end_time = end_time\\n else:\\n print(\\\"Start of the project is not present in the log file. Could not record end\\\")\\n if parsed_log_line.group('process_state') == \\\"STATUS\\\":\\n if process in jobs_dict.keys():\\n jobs_dict[process].status = parsed_log_line.group('process_status')\\n else:\\n print(\\\"Start of the project is not present in the log file. Could not record status\\\")\\n return jobs_dict\",\n \"def process(self, line):\\n arr_line = list(line.split('\\\\t'))\\n hash_line = self.get_hash(arr_line)\\n\\n with open(self.file_name_hash, 'a') as hash_txt:\\n hash_txt.write(hash_line + '\\\\n')\",\n \"def parse_line(line, lang):\\n parsed = []\\n\\n #this is to display correctly beginning white characters\\n while len(line) > 0 and (line[0] == ' ' or line[0] == '\\\\t'):\\n if line[0] == ' ':\\n parsed.append( {'class':'space', 'value':''} )\\n else:\\n parsed.append( {'class':'tab', 'value':''} )\\n line = line[1:]\\n\\n #then follow the rest of the line\\n if lang == settings.C_LANGUAGE:\\n keywords = settings.C_KEYWORDS\\n types = settings.C_TYPES\\n elif lang == settings.CPP_LANGUAGE:\\n keywords = settings.CPP_KEYWORDS\\n types = settings.CPP_TYPES\\n elif lang == settings.JAVA_LANGUAGE:\\n keywords = settings.JAVA_KEYWORDS\\n types = settings.JAVA_TYPES\\n elif lang == settings.PYTHON_LANGUAGE:\\n keywords = settings.PYTHON_KEYWORDS\\n types = settings.PYTHON_TYPES\\n\\n splited = line.split()\\n for s in splited:\\n if s in keywords:\\n parsed.append( {'class':'keyword', 'value':s} )\\n \\n elif s in types:\\n parsed.append( {'class':'types', 'value':s} )\\n \\n elif (lang == 'CPP' or lang == 'C') and s.startswith('#'):\\n parsed.append( {'class':'special', 'value':s} )\\n \\n elif (lang == 'CPP' or lang == 'C') and s.startswith('<') and s.endswith('>'):\\n parsed.append( {'class':'special', 'value':s} )\\n \\n else:\\n parsed.append( {'class':'normal', 'value':s} )\\n\\n return parsed\",\n \"def _readheader(lines):\\n hdrdict = {}\\n #input list of 26 lines of header\\n #station and channel\\n line = lines[5]\\n parts = line.strip().split()\\n fname = parts[1]\\n fparts = fname.split('_')\\n hdrdict['station'] = fparts[-2]+'_'+fparts[-1]\\n\\n #the \\\"Component\\\" lines look like either: Component S00W, Component S90E, Component Up\\n compstr = lines[12].strip().split()[1]\\n hdrdict['channel'] = get_comp_name(compstr)\\n\\n #instrument\\n hdrdict['instrument'] = lines[3].split()[1].strip()\\n \\n #location string\\n line = lines[6]\\n hdrdict['location'] = line.strip()\\n #event origin, buffer start year/month\\n line = lines[16]\\n parts = line.strip().split()\\n bufyear = int(parts[8])\\n bufmonth = int(parts[9])\\n #epicentral location, buffer start day/hour\\n line = lines[17]\\n parts = line.strip().split()\\n bufday = int(parts[8])\\n bufhour = int(parts[9])\\n #numpoints, buffer start min/sec\\n line = lines[19]\\n parts = line.strip().split()\\n hdrdict['npts'] = int(parts[0])\\n bufmin = int(parts[8])\\n millisec = int(parts[9])\\n bufsec = int(millisec/1000)\\n bufmicrosec = int(np.round(millisec/1000.0 - bufsec))\\n hdrdict['starttime'] = UTCDateTime(datetime(bufyear,bufmonth,bufday,bufhour,bufmin,bufsec,bufmicrosec))\\n #part C\\n #frequency, calibration value and some other stuff we don't care about\\n line = lines[20]\\n parts = line.strip().split()\\n hdrdict['sampling_rate'] = float(parts[0])\\n hdrdict['delta'] = 1.0/hdrdict['sampling_rate']\\n hdrdict['calib'] = float(parts[7])\\n #site location info, this time in dd\\n line = lines[21]\\n parts = line.strip().split()\\n hdrdict['lat'] = float(parts[0]) * -1\\n hdrdict['lon'] = float(parts[1])\\n hdrdict['height'] = 0.0\\n #duration\\n line = lines[22]\\n parts = line.strip().split()\\n hdrdict['duration'] = float(parts[0])\\n hdrdict['endtime'] = hdrdict['starttime'] + hdrdict['duration']\\n #max acceleration - good for sanity check\\n line = lines[23]\\n parts = line.strip().split()\\n hdrdict['maxacc'] = float(parts[0])\\n hdrdict['network'] = 'NZ'\\n hdrdict['units'] = 'acc'\\n return hdrdict\",\n \"def parseLine(line):\\n\\n\\teq = line.find('=')\\n\\tif eq == -1: raise Exception()\\n\\tkey = line[:eq].strip()\\n\\tvalue = line[eq+1:-1].strip()\\n\\treturn key, parseValue(value)\",\n \"def parse_line(lines, project, project_in):\\n # NOTE: project_in, here, is whether or not the given project is currently\\n # clocked in, rather than whether any is, like 'finished' in other functions.\\n # Find the corresponding line index\\n # project should already be lower case\\n length = len(project)\\n i = 0\\n for i, l in enumerate(lines[HEADER_L:]):\\n if l[:length] == project:\\n new = False\\n i += HEADER_L\\n break\\n else:\\n i += HEADER_L + 1\\n new = True\\n \\n # Process the line\\n line = [project, \\\"0\\\"] if new else lines[i].split(PUNCH_SEP)\\n last = None if project_in else datetime.strptime(line[-1], TIMEF)\\n times = []\\n for punch in (line[2:] if project_in else (line[2:-1])):\\n time_in, time_out = punch.split(IN_OUT_SEP)\\n time_in = datetime.strptime(time_in, TIMEF)\\n time_out = datetime.strptime(time_out, TIMEF)\\n times.append(time_out - time_in)\\n\\n return line, i, last, new, times\",\n \"def getPriorityRequests(self, line):\\n # self.optimizationResultsFile = open(self.fileName, 'r')\\n # for i, line in enumerate(self.optimizationResultsFile):\\n # if i in range(15, requiredLineNo):\\n reqPhase, earliestArrival, latestArrival, delay, vehicleClass = line.split()\\n if int(vehicleClass) == EV:\\n self.requestedPhase_EV.append(int(reqPhase))\\n self.ETA_EV.append(float(latestArrival) - 4.0)\\n self.ETA_EV.append(float(latestArrival) - 4.0)\\n self.ETA_Duration_EV.append(4.0)\\n self.ETA_Duration_EV.append(4.0)\\n self.vehicleType_EV.append(int(vehicleClass))\\n self.delay_EV.append(float(delay))\\n\\n elif int(vehicleClass) == TRANSIT:\\n self.requestedPhase_Transit.append(int(reqPhase))\\n self.ETA_Transit.append(float(latestArrival) - 4.0)\\n self.ETA_Transit.append(float(latestArrival) - 4.0)\\n self.ETA_Duration_Transit.append(4.0)\\n self.ETA_Duration_Transit.append(4.0)\\n self.vehicleType_Transit.append(int(vehicleClass))\\n if (float(delay) > 0):\\n self.delay_Transit.append(\\n float(delay) - (float(latestArrival) - float(earliestArrival) - 4.0))\\n\\n elif int(vehicleClass) == TRUCK:\\n self.requestedPhase_Truck.append(int(reqPhase))\\n self.ETA_Truck.append(float(latestArrival) - 4.0)\\n self.ETA_Truck.append(float(latestArrival) - 4.0)\\n self.ETA_Duration_Truck.append(4.0)\\n self.ETA_Duration_Truck.append(4.0)\\n self.vehicleType_Truck.append(int(vehicleClass))\\n if (float(delay) > 0):\\n self.delay_Truck.append(\\n float(delay) - (float(latestArrival) - float(earliestArrival) - 4.0))\\n\\n elif int(vehicleClass) == DILEMMAZONE:\\n self.requestedPhase_DilemmaZone.append(int(reqPhase))\\n self.ETA_DilemmaZone.append(float(latestArrival) - 4.0)\\n self.ETA_DilemmaZone.append(float(latestArrival) - 4.0)\\n self.ETA_Duration_DilemmaZone.append(4.0)\\n self.ETA_Duration_DilemmaZone.append(4.0)\\n self.vehicleType_DilemmaZone.append(int(vehicleClass))\\n self.delay_DilemmaZone.append(float(delay))\\n\\n elif int(vehicleClass) == COORDINATION:\\n self.requestedPhase_Coordination.append(int(reqPhase))\\n self.ETA_Coordination.append(float(earliestArrival))\\n self.ETA_Coordination.append(float(earliestArrival))\\n self.ETA_Duration_Coordination.append(\\n float(latestArrival) - float(earliestArrival))\\n self.ETA_Duration_Coordination.append(\\n float(latestArrival) - float(earliestArrival))\\n self.vehicleType_Coordination.append(int(vehicleClass))\\n self.delay_Coordination.append(float(delay))\\n\\n # self.optimizationResultsFile.close()\",\n \"def parse_entry(tr):\\n\\ttr = tr.replace('\\\"', '')\\n\\ttrl = tr.split(\\\"; \\\")\\n\\ttrdict = OrderedDict()\\n\\n\\tfor j in trl:\\n\\t\\tk = j.split(\\\" \\\")\\n\\n\\t\\tif k[0] in trdict:\\n# print \\\"%s already in dict\\\" % (k[0])\\n\\t\\t\\ttrdict[k[0]].append(k[1])\\n\\t\\telse: \\n\\t\\t\\ttrdict[k[0]]=[k[1]]\\n\\treturn trdict\",\n \"def parse_api_header(content):\\n result = {}\\n for line in content.split('\\\\n'):\\n for kw in KEYWORDS:\\n if kw in line:\\n _, _, value = line.strip().split()\\n value = value.strip()\\n\\n if kw == oqs.CRYPTO_ALGNAME:\\n assert value[0] == value[-1] == '\\\"'\\n value = value[1:-1]\\n\\n result[kw] = value\\n break\\n\\n return result\",\n \"def _build_header_dictionary(self):\\n start = 0\\n #print self.raw_data\\n for a in range(20):\\n redatapuller = re.compile(\\\"\\\\r\\\\n\\\\r\\\\n\\\\r\\\\n(?P<word>.*?)\\\\t.*?\\\\n\\\", re.DOTALL)\\n m = redatapuller.search(self.raw_data[start:])\\n if not(m):\\n break\\n self.header_dictionary[m.group(\\\"word\\\")] = start + m.end()\\n if a==0:\\n self.header_dictionary[\\\"main\\\"] = start + m.end()\\n start += m.end()\",\n \"def parse_results(results):\\n # hold the results in a dictionary\\n results_dict = {}\\n # loop over each line (result)\\n for result in results:\\n # split the string based on spaces\\n parts = result.split()\\n # there should only be a name and an outcome ('w', 'l')\\n if len(parts) > 2:\\n raise Exception(\\\"the results file has a bad format\\\")\\n # keep track of the name and the outcome so I don't have to use \\n # parts[0] and parts[1]\\n name = parts[0]\\n outcome = parts[1]\\n # add the name to the dictionary if it's not already there\\n if name not in results_dict:\\n results_dict[name] = (0, 0)\\n # modify the results tuple according to whether its a win or loss\\n if outcome == 'w':\\n results_dict[name] = (results_dict[name][0]+1, results_dict[name][1])\\n elif outcome == 'l':\\n results_dict[name] = (results_dict[name][0], results_dict[name][1]+1)\\n else:\\n raise Exception(\\\"I didn't recognize the outcome\\\")\\n return results_dict\",\n \"def parse_header(self, out):\\n self.headers = {}\\n for h in out.split(\\\"\\\\r\\\\n\\\\r\\\\n\\\", 1)[0].split(\\\"\\\\r\\\\n\\\"):\\n x = h.split(\\\":\\\")\\n self.headers[x[0]] = \\\":\\\".join(x[1:]).lstrip()\\n return True\",\n \"def __init__(self, line):\\n (self.timestamp, self.status_code, self.content_length, self.url, self.hop_path, self.via,\\n self.mime, self.thread, self.start_time_plus_duration, self.hash, self.source,\\n self.annotation_string) = re.split(\\\" +\\\", line.strip(), maxsplit=11)\\n # Account for any JSON 'extra info' ending, strip or split:\\n if self.annotation_string.endswith(' {}'):\\n self.annotation_string = self.annotation_string[:-3]\\n elif ' {\\\"' in self.annotation_string and self.annotation_string.endswith('}'):\\n self.annotation_string, self.extra_json = re.split(re.escape(' {\\\"'), self.annotation_string, maxsplit=1)\\n self.extra_json = '{\\\"%s' % self.extra_json\\n # And split out the annotations:\\n self.annotations = self.annotation_string.split(',')\\n\\n # Some regexes:\\n self.re_ip = re.compile('^\\\\d{1,3}\\\\.\\\\d{1,3}\\\\.\\\\d{1,3}\\\\.\\\\d{1,3}$')\\n self.re_tries = re.compile('^\\\\d+t$')\\n self.re_dol = re.compile('^dol:\\\\d+') # Discarded out-links - make a total?\",\n \"def read_header(self, lines):\\n\\n comp = None\\n data_lines = []\\n for ii, line in enumerate(lines):\\n if line.find(\\\"=\\\") > 0 and line.find(\\\"$\\\") == 0:\\n key, value = line[1:].split(\\\"=\\\")\\n key = \\\".\\\".join(\\n [\\n validate_attribute(k)\\n for k in key.replace(\\\":\\\", \\\".\\\").split(\\\".\\\")\\n ]\\n )\\n\\n value = value.lower().strip()\\n if \\\",\\\" in value:\\n value = [v.strip() for v in value.split(\\\",\\\")]\\n if \\\"length\\\" in key:\\n value = value.split()\\n if len(value) > 1:\\n value = value[0]\\n else:\\n value = value[0].strip()\\n\\n if \\\"rx.cmp\\\" in key:\\n comp = value\\n data_lines.append(line)\\n self._comp_dict[comp] = {\\\"rx\\\": Rx(), \\\"ch\\\": CH()}\\n if comp is not None:\\n comp_key, comp_attr = key.split(\\\".\\\")\\n\\n self._comp_dict[comp][comp_key].set_attr_from_name(\\n comp_attr, value\\n )\\n else:\\n self.set_attr_from_name(key, value)\\n else:\\n if len(line) > 2:\\n data_lines.append(line)\\n\\n return data_lines\",\n \"def parse_headers(file_contents: str) -> dict:\\n\\n match = re.search(r'#HEADER#(.*?)#', file_contents, re.MULTILINE | re.DOTALL)\\n\\n if match is None:\\n raise Exception('No #HEADER# provided')\\n\\n headers = {}\\n lines = match.group(1).split(\\\"\\\\n\\\")\\n\\n for line in lines:\\n if line.strip() != '':\\n parts = line.split(' : ')\\n value = re.sub(r'(^[\\\\'\\\"]|[\\\\'\\\"]$)', '', parts[1].strip())\\n headers[parts[0].strip()] = value\\n\\n return headers\",\n \"def _process_text_line(self, line, columns, format, lower_case, num_line,\\n fill_missing=0, filter_case=None,\\n strict_separator=False):\\n if not isinstance(line, list) and not isinstance(\\n line, tuple) and not isinstance(line, numpy.ndarray):\\n if format != \\\"tsv\\\":\\n raise Exception(\\\"unable to process format \\\" + format)\\n line = line.strip(\\\"\\\\r\\\\n \\\").replace(\\\"\\\\n\\\", \\\" \\\")\\n line = DatabaseCore2._split_expr.split(line)\\n\\n if filter_case is not None:\\n line = [filter_case(s) for s in line]\\n\\n try:\\n if fill_missing > 0:\\n m = max(columns.keys())\\n if m >= len(line):\\n line = copy.copy(line)\\n add = 0\\n while m >= len(line) and add < fill_missing:\\n a, b = columns[len(line)]\\n if b is int:\\n line.append(\\\"0\\\")\\n elif b is float:\\n line.append(\\\"0.0\\\")\\n elif b is decimal.Decimal:\\n line.append(\\\"0\\\")\\n elif b is str:\\n line.append(\\\"\\\")\\n else:\\n line.append(\\\"\\\")\\n add += 1\\n\\n res = {}\\n for c, v in columns.items():\\n if \\\"AUTOFILL\\\" in v:\\n res[v[0]] = \\\"NULL\\\"\\n elif \\\"AUTOINCREMENT\\\" in v:\\n continue\\n else:\\n if c >= len(line):\\n self.LOG(\\n \\\"(a)line number \\\",\\n num_line,\\n \\\"*unable to process a line columns \\\",\\n c,\\n \\\"#\\\",\\n line,\\n \\\" columns \\\",\\n columns)\\n return None\\n\\n val = line[c]\\n if len(v) > 2 and v[2].lower() not in [\\n \\\"primarykey\\\", \\\"autofill\\\"]:\\n val = v[2](val)\\n\\n try:\\n if isinstance(v[1], tuple):\\n val = v[1][0](val)\\n elif v[1] is datetime.datetime:\\n if isinstance(val, datetime.datetime):\\n pass\\n elif isinstance(val, str):\\n val = datetime.datetime.parse(val)\\n else:\\n raise TypeError(\\n \\\"unable to convert %s into datetime\\\" % str(\\n type(val)))\\n else:\\n val = v[1](val)\\n except ValueError: # as e :\\n self.LOG(\\n \\\"(b)line number \\\",\\n num_line,\\n \\\"**unable to process a line columns \\\",\\n c,\\n \\\"#\\\",\\n v[0],\\n \\\" type \\\",\\n v[1],\\n \\\" value \\\",\\n repr(\\n line[c]))\\n return None\\n\\n if isinstance(val, str):\\n val = val.replace(\\\"'\\\", \\\"''\\\")\\n if lower_case:\\n val = val.lower()\\n res[v[0]] = val\\n\\n return res\\n except Exception:\\n self.LOG(\\\"(c)line number\\\", num_line,\\n \\\"***unable to process a line columns:\\\", line)\\n return None\",\n \"def mapper(self, _, line):\\n if line:\\n try:\\n line_values = re.match(self.REGEXP, line).groupdict()\\n user_agent = user_agents.parse(line_values['user_agent']).browser.family\\n self.increment_counter('Browsers', user_agent, 1)\\n ip = line_values['ip']\\n try:\\n byte_count = int(line_values['byte_count'])\\n except ValueError:\\n byte_count = 0\\n yield ip, ValueFormat(byte_count, 1)\\n except AttributeError:\\n self.increment_counter('ERRORS', 'ERRORS', 1)\",\n \"def parse_user_dict(self, line):\\n pass\",\n \"def _parseLine(self, line, delimiter = \\\":\\\"):\\r\\n\\t\\tsplt = line.split(delimiter)\\r\\n\\t\\tinVec = self._parseVec(splt[0])\\r\\n\\t\\toutVec = self._parseVec(splt[1])\\r\\n\\t\\tif (len(splt) == 2):\\r\\n\\t\\t\\tlabel = \\\"\\\"\\r\\n\\t\\telse:\\r\\n\\t\\t\\tlabel = splt[2]\\r\\n\\t\\tself.data.append({'in':inVec, 'out':outVec, 'label':label})\",\n \"def parseLine(self,incoming):\\n\\t\\tself.addContentLine(incoming)\\n\\t\\tif incoming.mustProcess == 0: return \\n\\t\\tself.iLineObject = incoming\\n\\t\\titems = self.iLineObject.getItems()\\n\\t\\tkeyword = string.upper(items[0])\\n\\t\\tif len(items) < 2: \\n\\t\\t\\tif not keyword in self.sQuotedKeywords: \\n\\t\\t\\t\\tself.addErrorMessage('2. Unrecognized keyword SIMULATOR_BLOCK:', self.iLineObject)\\n\\t\\t\\treturn\\n\\t\\tself.parseKeyword(keyword,items[1:])\",\n \"def _parse_headers(raw_headers: List[str]) -> Dict[str, str]:\\n headers: Dict[str, str] = {}\\n for header in raw_headers:\\n name = header[: header.find(\\\":\\\")].strip()\\n value = header[header.find(\\\":\\\") + 1 :].strip()\\n headers[name.lower()] = value\\n\\n return headers\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66752446","0.6504577","0.63924736","0.6246586","0.60992664","0.60275394","0.59553164","0.5938524","0.58829117","0.58815986","0.58645564","0.5864273","0.5848218","0.5842252","0.58342505","0.58329415","0.5803412","0.5788858","0.57804203","0.5771522","0.57667285","0.57658106","0.5758933","0.57427806","0.573765","0.5730785","0.5693323","0.5683553","0.56792504","0.5668925","0.5647936","0.5635282","0.5632715","0.561327","0.55712837","0.5559786","0.5551553","0.55422145","0.5535736","0.553396","0.55301434","0.55245674","0.5524008","0.5512501","0.54954517","0.5452048","0.5450164","0.5443407","0.5441312","0.54392135","0.54275197","0.54212403","0.54211175","0.5418921","0.54112226","0.5410183","0.54011285","0.5384456","0.53504086","0.5329753","0.5325237","0.5323741","0.53197604","0.53172636","0.53073305","0.5292172","0.52806157","0.5272896","0.5270322","0.5268982","0.5261744","0.5249427","0.5242679","0.5228363","0.5215942","0.5211316","0.5207704","0.520356","0.5199117","0.51934725","0.5183309","0.51807356","0.5173142","0.5166672","0.5148404","0.5145741","0.514303","0.5142421","0.51367056","0.51361847","0.51313585","0.5127315","0.51245934","0.51202637","0.51140666","0.51125747","0.5110977","0.5107491","0.51072025","0.5098708"],"string":"[\n \"0.66752446\",\n \"0.6504577\",\n \"0.63924736\",\n \"0.6246586\",\n \"0.60992664\",\n \"0.60275394\",\n \"0.59553164\",\n \"0.5938524\",\n \"0.58829117\",\n \"0.58815986\",\n \"0.58645564\",\n \"0.5864273\",\n \"0.5848218\",\n \"0.5842252\",\n \"0.58342505\",\n \"0.58329415\",\n \"0.5803412\",\n \"0.5788858\",\n \"0.57804203\",\n \"0.5771522\",\n \"0.57667285\",\n \"0.57658106\",\n \"0.5758933\",\n \"0.57427806\",\n \"0.573765\",\n \"0.5730785\",\n \"0.5693323\",\n \"0.5683553\",\n \"0.56792504\",\n \"0.5668925\",\n \"0.5647936\",\n \"0.5635282\",\n \"0.5632715\",\n \"0.561327\",\n \"0.55712837\",\n \"0.5559786\",\n \"0.5551553\",\n \"0.55422145\",\n \"0.5535736\",\n \"0.553396\",\n \"0.55301434\",\n \"0.55245674\",\n \"0.5524008\",\n \"0.5512501\",\n \"0.54954517\",\n \"0.5452048\",\n \"0.5450164\",\n \"0.5443407\",\n \"0.5441312\",\n \"0.54392135\",\n \"0.54275197\",\n \"0.54212403\",\n \"0.54211175\",\n \"0.5418921\",\n \"0.54112226\",\n \"0.5410183\",\n \"0.54011285\",\n \"0.5384456\",\n \"0.53504086\",\n \"0.5329753\",\n \"0.5325237\",\n \"0.5323741\",\n \"0.53197604\",\n \"0.53172636\",\n \"0.53073305\",\n \"0.5292172\",\n \"0.52806157\",\n \"0.5272896\",\n \"0.5270322\",\n \"0.5268982\",\n \"0.5261744\",\n \"0.5249427\",\n \"0.5242679\",\n \"0.5228363\",\n \"0.5215942\",\n \"0.5211316\",\n \"0.5207704\",\n \"0.520356\",\n \"0.5199117\",\n \"0.51934725\",\n \"0.5183309\",\n \"0.51807356\",\n \"0.5173142\",\n \"0.5166672\",\n \"0.5148404\",\n \"0.5145741\",\n \"0.514303\",\n \"0.5142421\",\n \"0.51367056\",\n \"0.51361847\",\n \"0.51313585\",\n \"0.5127315\",\n \"0.51245934\",\n \"0.51202637\",\n \"0.51140666\",\n \"0.51125747\",\n \"0.5110977\",\n \"0.5107491\",\n \"0.51072025\",\n \"0.5098708\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7336327"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21963,"cells":{"query":{"kind":"string","value":"We need to find the halfedge h that is incident to u and is on the face that contains the diagonal uv. To find it, we test every pair of halfedges incident to u and v until we find a pair belonging to the same face."},"document":{"kind":"string","value":"def referenceEdge(u,v):\n v1 = u\n v2 = v\n\n e1 = u.getEdge().getPrev()\n e2 = v.getEdge().getPrev()\n\n aux = None #aux is an half-edge incident to u \n while aux != e1:\n if aux is None: aux = e1\n aux2 = None #aux2 is an half-edge incident to v\n\n while aux2 != e2:\n if aux2 is None: aux2 = e2\n if aux.getFace() == aux2.getFace(): return aux\n aux2 = aux2.getNext().getTwin() \n\n aux = aux.getNext().getTwin()\n\n return e1"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def solve_homography(u, v):\r\n N = u.shape[0]\r\n H = None\r\n\r\n if v.shape[0] is not N:\r\n print('u and v should have the same size')\r\n return None\r\n if N < 4:\r\n print('At least 4 points should be given')\r\n\r\n # TODO: 1.forming A\r\n A = np.zeros((2*N, 8))\r\n for i in range(N):\r\n A[2*i, :] = np.array([u[i, 0], u[i, 1], 1, 0, 0, 0, -u[i, 0]*v[i,0], -u[i, 1]*v[i, 0]])\r\n A[2*i+1, :] = np.array([0, 0, 0, u[i, 0], u[i, 1], 1, -u[i, 0]*v[i, 1], -u[i, 1]*v[i, 1]])\r\n\r\n # TODO: 2.solve H with A\r\n b = v.reshape(-1)\r\n H, res, _, _ = np.linalg.lstsq(A, b, rcond=None)\r\n H = np.concatenate((H, np.array([1])))\r\n H = H.reshape(3,3)\r\n\r\n return H","def edge_on_silhouette(self, vertices_2d: np.ndarray) -> np.ndarray:\n assert vertices_2d.ndim == 2\n assert vertices_2d.shape[1] == 2\n triangles = vertices_2d[self.faces, :]\n u = triangles[:, 1, :] - triangles[:, 0, :]\n v = triangles[:, 2, :] - triangles[:, 0, :]\n face_visible = np.cross(u, v) > 0 if self.clockwise else np.cross(u, v) < 0\n edge_bool = (self.edges_faces_ones * face_visible) == 1\n return edge_bool[self.faces_edges]","def trimesh_collapse_edge(self, u, v, t=0.5, allow_boundary=False, fixed=None):\r\n if t < 0.0:\r\n raise ValueError('Parameter t should be greater than or equal to 0.')\r\n if t > 1.0:\r\n raise ValueError('Parameter t should be smaller than or equal to 1.')\r\n\r\n # check collapse conditions\r\n if not is_collapse_legal(self, u, v, allow_boundary=allow_boundary):\r\n return False\r\n\r\n # compare to fixed\r\n fixed = fixed or []\r\n if v in fixed or u in fixed:\r\n return False\r\n\r\n # move U\r\n x, y, z = self.edge_point(u, v, t)\r\n\r\n self.vertex[u]['x'] = x\r\n self.vertex[u]['y'] = y\r\n self.vertex[u]['z'] = z\r\n\r\n # UV face\r\n fkey = self.halfedge[u][v]\r\n\r\n if fkey is None:\r\n del self.halfedge[u][v]\r\n else:\r\n face = self.face[fkey]\r\n\r\n o = face[face.index(u) - 1]\r\n\r\n del self.halfedge[u][v]\r\n del self.halfedge[v][o]\r\n del self.halfedge[o][u]\r\n del self.face[fkey]\r\n\r\n if len(self.halfedge[o]) < 2:\r\n del self.halfedge[o]\r\n del self.vertex[o]\r\n del self.halfedge[u][o]\r\n\r\n # VU face\r\n fkey = self.halfedge[v][u]\r\n\r\n if fkey is None:\r\n del self.halfedge[v][u]\r\n else:\r\n face = self.face[fkey]\r\n\r\n o = face[face.index(v) - 1]\r\n\r\n del self.halfedge[v][u]\r\n del self.halfedge[u][o]\r\n del self.halfedge[o][v]\r\n del self.face[fkey]\r\n\r\n if len(self.halfedge[o]) < 2:\r\n del self.halfedge[o]\r\n del self.vertex[o]\r\n del self.halfedge[v][o]\r\n\r\n # neighborhood of V\r\n for nbr, fkey in list(self.halfedge[v].items()):\r\n\r\n if fkey is None:\r\n self.halfedge[u][nbr] = None\r\n del self.halfedge[v][nbr]\r\n else:\r\n # a > v > nbr => a > u > nbr\r\n face = self.face[fkey]\r\n a = face[face.index(v) - 1]\r\n self.face[fkey] = [a, u, nbr]\r\n\r\n if v in self.halfedge[a]:\r\n del self.halfedge[a][v]\r\n del self.halfedge[v][nbr]\r\n\r\n self.halfedge[a][u] = fkey\r\n self.halfedge[u][nbr] = fkey\r\n self.halfedge[nbr][a] = fkey\r\n\r\n # nbr > v > d => nbr > u > d\r\n if v in self.halfedge[nbr]:\r\n self.halfedge[nbr][u] = self.halfedge[nbr][v]\r\n del self.halfedge[nbr][v]\r\n\r\n # delete V\r\n del self.halfedge[v]\r\n del self.vertex[v]\r\n\r\n # clean up\r\n for nu in self.halfedge[u]:\r\n for nbr in self.halfedge[nu]:\r\n if nbr == v:\r\n self.halfedge[nu][u] = self.halfedge[nu][v]\r\n del self.halfedge[nu][v]\r\n\r\n return True","def get_faces(ulist, vlist):\n width = len(ulist)\n faces = []\n for i in range(len(ulist) - 1):\n for j in range(len(vlist) - 1):\n topleft = j * width + i\n topright = topleft + 1\n bottomleft = ((j + 1) * width) + i\n bottomright = bottomleft + 1\n one = [topleft, topright, bottomleft]\n two = [bottomleft, topright, bottomright]\n faces.append(one)\n faces.append(two)\n\n return faces","def close_up_hull(hull, edge_count, used_pivots):\n face_added = close_up(edge_count, used_pivots)\n if not face_added:\n face = list(hull[0])\n # det(A) = -det (B) if two cols swap (odd and even)\n face[-2], face[-1] = face[-1], face[-2]\n face_added = [tuple(face)]\n for face in face_added:\n hull.append(face)\n\n return len(face_added)","def findFours(self):\n\n for i in range(6):\n for j in range(7):\n if self.board[i][j] != ' ':\n # check if a vertical four-in-a-row starts at (i, j)\n if self.verticalCheck(i, j):\n self.highlightFour(i, j, 'vertical')\n \n # check if a horizontal four-in-a-row starts at (i, j)\n if self.horizontalCheck(i, j):\n self.highlightFour(i, j, 'horizontal')\n \n # check if a diagonal (either way) four-in-a-row starts at (i, j)\n # also, get the slope of the four if there is one\n diag_fours, slope = self.diagonalCheck(i, j)\n if diag_fours:\n self.highlightFour(i, j, 'diagonal', slope)","def H(self, u, v):\n return (self.E(u, v) * self.N(u, v)\n - 2 * self.F(u, v) * self.M(u, v)\n + self.G(u, v) * self.L(u, v)) / \\\n (2 * (self.E(u, v) * self.G(u, v) - np.square(self.F(u, v))))","def Neighbourgs(abcd, h):\n\n Nelem = len(abcd)\n\n a = abcd[h][0]\n b = abcd[h][1]\n c = abcd[h][2]\n d = abcd[h][3]\n\n el1, el2, el3, el4 = 0, 0, 0, 0\n\n N = 0\n\n for j in range(0, Nelem - 1):\n\n if N == 4:\n break\n\n if a in abcd[j, :] and b in abcd[j, :] and j != h:\n N += 1\n el1 = j + 1\n\n if b in abcd[j, :] and c in abcd[j, :] and j != h:\n N += 1\n el2 = j + 1\n\n if c in abcd[j, :] and d in abcd[j, :] and j != h:\n N += 1\n el3 = j + 1\n\n if d in abcd[j, :] and a in abcd[j, :] and j != h:\n N += 1\n el4 = j + 1\n\n return [el1, el2, el3, el4]","def _get_single_direction_neighbors(object_idx, ui_v_dist, ui_h_dist):\n neighbor_dict = {}\n vertical_dist = ui_v_dist[object_idx]\n horizontal_dist = ui_h_dist[object_idx]\n bottom_neighbors = np.array([\n idx for idx in range(len(vertical_dist)) if vertical_dist[idx] > 0 and\n abs(horizontal_dist[idx]) < config.NORM_HORIZONTAL_NEIGHBOR_MARGIN\n ])\n top_neighbors = np.array([\n idx for idx in range(len(vertical_dist)) if vertical_dist[idx] < 0 and\n abs(horizontal_dist[idx]) < config.NORM_HORIZONTAL_NEIGHBOR_MARGIN\n ])\n right_neighbors = np.array([\n idx for idx in range(len(horizontal_dist)) if horizontal_dist[idx] > 0 and\n abs(vertical_dist[idx]) < config.NORM_VERTICAL_NEIGHBOR_MARGIN\n ])\n left_neighbors = np.array([\n idx for idx in range(len(horizontal_dist)) if horizontal_dist[idx] < 0 and\n abs(vertical_dist[idx]) < config.NORM_VERTICAL_NEIGHBOR_MARGIN\n ])\n\n if bottom_neighbors.size:\n neighbor_dict[NeighborContextDesc.TOP] = bottom_neighbors[np.argmin(\n vertical_dist[bottom_neighbors])]\n if top_neighbors.size:\n neighbor_dict[NeighborContextDesc.BOTTOM] = top_neighbors[np.argmax(\n vertical_dist[top_neighbors])]\n if right_neighbors.size:\n neighbor_dict[NeighborContextDesc.LEFT] = right_neighbors[np.argmin(\n horizontal_dist[right_neighbors])]\n if left_neighbors.size:\n neighbor_dict[NeighborContextDesc.RIGHT] = left_neighbors[np.argmax(\n horizontal_dist[left_neighbors])]\n\n return neighbor_dict","def faceIntersection(self, face):\n # Test wether both ends of the edge are in the same half space\n # (relative to <face>'s plane).\n normal = face.normalVect()\n v0 = vector(face.vertices[0])\n vp = vector(self.pvt)\n vn = vector(self.nvt)\n p = normal.dotProduct(vp - v0) * normal.dotProduct(vn - v0)\n if p > 0:\n return False\n elif abs(p) <= COMPARISON_EPSILON or abs(normal.dotProduct(vp - vn) / (normal.norm() * (vp - vn).norm())) <= COMPARISON_EPSILON:\n # print('ah')\n return False\n else:\n interVect = vn + (normal.dotProduct(v0 - vn) /\n normal.dotProduct(vp - vn)) * (vp - vn)\n lastCross = ((vector(face.vertices[-1]) - interVect) *\n (vector(face.vertices[0]) - interVect))\n for i in range(len(face.vertices)):\n cross = ((vector(face.vertices[i]) - interVect) *\n (vector(face.vertices[(i + 1) % len(face.vertices)]) -\n interVect))\n p = cross.dotProduct(lastCross)\n if p < 0:\n return False\n elif p == 0 and cross.norm() != 0:\n if cross.norm() > COMPARISON_EPSILON:\n warnings.warn(\"Cross product's norm is very low\")\n lastCross = cross\n return interVect.coords()","def inside(i,j,im,h=H): #X\n return i-h >=0 and j-h >=0 and i+h+1<=im.shape[0] and j+h+1<=im.shape[1]","def detector_outline( bottom_vec3d_list, top_vec3d_list ):\n # hardcoded angular offset for hexagon\n phi0 = -20.0 * I3Units.degree \n\n # hardcoded threshold for an edge\n cos_angle_threshold = math.cos( 7.0 * I3Units.degree ) \n\n bottom = Vec3dList()\n top = Vec3dList()\n\n string_coords = []\n for b, t in zip( bottom_vec3d_list, top_vec3d_list ):\n if t[2] < 450.0 * I3Units.meter: # ignore deep-core\n continue\n string_coords.append(( math.atan2(t[1], t[0]),\n t[0], t[1], b[2], t[2] ))\n\n # border detection:\n # check if there is a point in each angular segment of hexagon\n border = []\n for i, cur in enumerate( string_coords ):\n counts = [False, False, False, False, False , False]\n for j, other in enumerate( string_coords ):\n if i == j: continue\n dx = cur[1] - other[1]\n dy = cur[2] - other[2]\n phi = int((math.atan2( dy, dx ) - phi0) / I3Units.degree)\n if phi < 0:\n phi += 360\n counts[phi // 60] = True\n neighbor_count = sum( counts )\n # border points don't have a full hexagon of neighbors\n if neighbor_count < 6:\n border.append( cur )\n\n border.sort() # put in circular order\n\n # edge detection:\n # check if differential vectors of three consecutive points have an angle\n for i in xrange( len(border) ):\n ax = border[i - 1][1] - border[i - 2][1]\n ay = border[i - 1][2] - border[i - 2][2]\n bx = border[i][1] - border[i - 1][1]\n by = border[i][2] - border[i - 1][2]\n anorm = (ax ** 2 + ay ** 2) ** 0.5\n bnorm = (bx ** 2 + by ** 2) ** 0.5\n cos_angle = (bx * ax + by * ay) / (anorm * bnorm)\n if cos_angle < cos_angle_threshold:\n cur = border[i - 1]\n bottom.append( vec3d(cur[1], cur[2], cur[3]) )\n top.append( vec3d(cur[1], cur[2], cur[4]) )\n\n return bottom, top","def neighbours2((u,v)):\r\n\r\n return ((u-1, v+1), (u,v+1), (u+1,v+1), \r\n (u-1,v), (u+1,v),\r\n (u-1,v-1), (u,v-1), (u+1,v-1))","def split_face_mesh(mesh, fkey, u, v):\n if u not in mesh.face[fkey] or v not in mesh.face[fkey]:\n raise ValueError('The split vertices do not belong to the split face.')\n if mesh.face[fkey][u] == v:\n raise ValueError('The split vertices are neighbours.')\n d = mesh.face[fkey][u]\n f = [u]\n while True:\n f.append(d)\n if d == v:\n break\n d = mesh.face[fkey][d]\n d = mesh.face[fkey][v]\n g = [v]\n while True:\n g.append(d)\n if d == u:\n break\n d = mesh.face[fkey][d]\n f = mesh.add_face(f)\n g = mesh.add_face(g)\n del mesh.face[fkey]\n return f, g","def bipartite_vertex_cover(bigraph, algo=\"Hopcroft-Karp\"):\n if algo == \"Hopcroft-Karp\":\n coord = [(irow,icol) for irow,cols in enumerate(bigraph) for icol in cols]\n coord = np.array(coord)\n graph = csr_matrix((np.ones(coord.shape[0]),(coord[:,0],coord[:,1])))\n matchV = maximum_bipartite_matching(graph, perm_type='row')\n matchV = [None if x==-1 else x for x in matchV]\n nU, nV = graph.shape\n assert len(matchV) == nV\n elif algo == \"Hungarian\":\n matchV = max_bipartite_matching2(bigraph)\n nU, nV = len(bigraph), len(matchV)\n else:\n assert False\n\n matchU = [None] * nU\n \n for v in range(nV): # -- build the mapping from U to V\n if matchV[v] is not None:\n matchU[matchV[v]] = v\n \n def old_konig():\n visitU = [False] * nU # -- build max alternating forest\n visitV = [False] * nV\n for u in range(nU):\n if matchU[u] is None: # -- starting with free vertices in U\n _alternate(u, bigraph, visitU, visitV, matchV)\n inverse = [not b for b in visitU]\n return (inverse, visitV)\n \n def new_konig():\n # solve the limitation of huge number of recursive calls\n visitU = [False] * nU # -- build max alternating forest\n visitV = [False] * nV\n wait_u = set(range(nU)) - set(matchV) \n while len(wait_u) > 0:\n u = wait_u.pop()\n visitU[u] = True\n for v in bigraph[u]:\n if not visitV[v]:\n visitV[v] = True\n assert matchV[v] is not None # otherwise match is not maximum\n assert matchV[v] not in wait_u\n wait_u.add(matchV[v])\n inverse = [not b for b in visitU]\n return (inverse, visitV)\n \n #res_old = old_konig()\n res_new = new_konig()\n #assert res_old == res_new\n return res_new","def halfedgeConstruction(self,facetList):\n\t\tedges = []\n\t\t# the temporary map of the halfedges\n\t\tedgeMap = {}\n\t\tcount = 0\n\t\tfor i in range(0,len(facetList)):\n\t\t\t# \n\t\t\tfor j in range(0,len(facetList[i])):\n\t\t\t\t# j is the index of the current vertex\n\t\t\t\tkey = (facetList[i][j-1],facetList[i][j])\n\t\t\t\tedges.append(key)\n\t\t\t\tedgeMap[key] = count\n\t\t\t\tcount += 1\n\t\t\t\t# initialze the current halfedge\n\t\t\t\the = Halfedge()\n\t\t\t\t# assume that the mesh has been well oriented\n\t\t\t\the.setVertex(self._mesh._vertices[facetList[i][j]])\n\t\t\t\tself._mesh._halfedges.append(he)\n\t\t# construct the opposite halfedge\n\t\tfor key in edgeMap:\n\t\t\ti = edgeMap[key]\n\t\t\tif self._mesh._halfedges[i].opposite() is None:\n\t\t\t\t# the opposite has not been set\n\t\t\t\toppo = key[1],key[0]\n\t\t\t\tif oppo in edgeMap:\n\t\t\t\t\t# interior edge\n\t\t\t\t\tj = edgeMap[oppo]\n\t\t\t\t\tself._mesh._halfedges[i].setOpposite(self._mesh._halfedges[j])\n\t\t\t\t\tself._mesh._halfedges[j].setOpposite(self._mesh._halfedges[i])\n\t\t\t\telse:\n\t\t\t\t\t# border edge\n\t\t\t\t\t# construct a border halfedge\n\t\t\t\t\the = Halfedge()\n\t\t\t\t\t# the edge is border edge\n\t\t\t\t\the._isBorder = True\n\t\t\t\t\tself._mesh._halfedges[i].setOpposite(he)\n\t\t\t\t\the.setOpposite(self._mesh._halfedges[i])\n\t\t\t\t\t# append the halfedge\n\t\t\t\t\tself._mesh._halfedges.append(he)\n\t\t\t\t\tcount += 1\n\t\t# set next and prev halfedge\n\t\t# the interior edges\n\t\tcount = 0\n\t\tfor i in range(0,len(facetList)):\n\t\t\tfor j in range(0,len(facetList[i])):\n\t\t\t\tif j == len(facetList[i])-1:\n\t\t\t\t\t# the last edge: the next edge is the beggining edge\n\t\t\t\t\tself._mesh._halfedges[count+j].setNext(self._mesh._halfedges[count])\n\t\t\t\t\tself._mesh._halfedges[count+j].setPrev(self._mesh._halfedges[count+j-1])\n\t\t\t\telif j == 0:\n\t\t\t\t\t# the beginning edge: the prev edge is the last one\n\t\t\t\t\tself._mesh._halfedges[count+j].setNext(self._mesh._halfedges[count+j+1])\n\t\t\t\t\tself._mesh._halfedges[count+j].setPrev(self._mesh._halfedges[count+len(facetList[i])-1])\n\t\t\t\telse:\n\t\t\t\t\t# the interior edge\n\t\t\t\t\tself._mesh._halfedges[count+j].setNext(self._mesh._halfedges[count+j+1])\n\t\t\t\t\tself._mesh._halfedges[count+j].setPrev(self._mesh._halfedges[count+j-1])\n\t\t\t# the count\n\t\t\tcount += len(facetList[i])\n\t\t# the border edges\n\t\tfor i in range(count,len(self._mesh._halfedges)):\n\t\t\the = self._mesh._halfedges[i]\n\t\t\t# first set the vertex\n\t\t\the.setVertex(he.opposite().prev().vertex())\n\t\t\t# two kinds of situation\n\t\t\tif he.opposite().prev().opposite().isBorder():\n\t\t\t\the.setNext(he.opposite().prev().opposite())\n\t\t\telse:\n\t\t\t\the.setNext(he.opposite().prev().opposite().prev().opposite())\n\t\t\tif he.opposite().next().opposite().isBorder():\n\t\t\t\the.setPrev(he.opposite().next().opposite())\n\t\t\telse:\n\t\t\t\the.setPrev(he.opposite().next().opposite().next().opposite())","def get_k2_boundary(tri, v_neighbours):\n three = np.array([0, 1, 2])\n nv = tri.shape[0]\n k2s = np.empty((nv, 3), dtype=np.int32)\n for i in range(nv):\n for k in range(3):\n neighbour = v_neighbours[i, k]\n if neighbour == -1:\n k2s[i,k] = -1\n else:\n k2 = ((v_neighbours[neighbour] == i) * three).sum()\n k2s[i, k] = k2\n return k2s","def neighbours((u,v)):\r\n return ((u,v+1), (u+1,v), (u,v-1), (u-1,v))","def query_rect(triu_reader, i0, i1, j0, j1):\n\n # symmetric query\n if (i0, i1) == (j0, j1):\n i, j, v = triu_reader(i0, i1, i0, i1)\n nodiag = i != j\n i, j, v = np.r_[i, j[nodiag]], np.r_[j, i[nodiag]], np.r_[v, v[nodiag]]\n\n # asymmetric query\n else:\n transpose = False\n if j0 < i0 or (i0 == j0 and i1 < j1):\n i0, i1, j0, j1 = j0, j1, i0, i1\n transpose = True\n\n # non-overlapping\n if _comes_before(i0, i1, j0, j1, strict=True):\n i, j, v = triu_reader(i0, i1, j0, j1)\n\n # partially overlapping\n elif _comes_before(i0, i1, j0, j1):\n ix, jx, vx = triu_reader(i0, j0, j0, i1)\n iy, jy, vy = triu_reader(j0, i1, j0, i1)\n iz, jz, vz = triu_reader(i0, i1, i1, j1)\n nodiag = iy != jy\n iy, jy, vy = np.r_[iy, jy[nodiag]], np.r_[jy, iy[nodiag]], np.r_[vy, vy[nodiag]]\n i, j, v = np.r_[ix, iy, iz], np.r_[jx, jy, jz], np.r_[vx, vy, vz]\n\n # nested\n elif _contains(i0, i1, j0, j1):\n ix, jx, vx = triu_reader(i0, j0, j0, j1)\n iy, jy, vy = triu_reader(j0, j1, j0, j1)\n jz, iz, vz = triu_reader(j0, j1, j1, i1)\n nodiag = iy != jy\n iy, jy, vy = np.r_[iy, jy[nodiag]], np.r_[jy, iy[nodiag]], np.r_[vy, vy[nodiag]]\n i, j, v = np.r_[ix, iy, iz], np.r_[jx, jy, jz], np.r_[vx, vy, vz]\n\n else:\n raise IndexError(\"This shouldn't happen\")\n\n if transpose:\n i, j = j, i\n\n return i, j, v","def _edge(u, v):\n return (u, v) if u < v else (v, u)","def neighbour(t, i, j):\n v0 = t[i][(j + 1) % 3]\n v1 = t[i][(j + 2) % 3]\n\n for k in range(len(t)):\n if k != i:\n if v0 in t[k] and v1 in t[k]:\n return k\n\n return None","def bernstein_surface(i, j, nU, nV, u, v):\n return np.outer(comb(nU, i) * (u ** (nU - i)) * ((1 - u) ** i),\n comb(nV, j) * (v ** (nV - j)) * ((1 - v) ** j))","def approximate_hypercube_iou(hs: List[Tuple[float, List[float]]], new_hs: Tuple[float, List[float]], m_rel: int) \\\n -> List[float]:\n\n # TODO: umschreiben so dass new_hs die random Punkte enthält -> die müssen dadurch nur einmal erzeugt werden und\n # dann wird für jeden Punkt getestet in welchen hs er noch liegt. -> dadurch Punkte nur einmal erzeugen und\n # Volumen nur einmal berechnen\n\n if hs is None or len(hs) == 0 or not hs:\n return [-1]\n\n number_rand_points = 10000 * m_rel\n\n inside_ref = [0] * len(hs)\n\n new_r, new_c = new_hs\n new_v = calc_hypercube_volume(new_r, m_rel)\n\n for i, (r, c) in enumerate(hs):\n j = 0\n while j < number_rand_points:\n max_x = np.array(c) + r\n min_x = np.array(c) - r\n p = np.random.rand(m_rel) * (max_x - min_x) + min_x\n p_inside_hc = is_point_inside_hypercube(p, c, r)\n if p_inside_hc:\n j += 1\n if p_inside_hc and is_point_inside_hypercube(p, new_c, new_r):\n inside_ref[i] += 1\n\n result = []\n\n for (r, c), k in zip(hs, inside_ref):\n v = calc_hypercube_volume(r, m_rel)\n inter = (k / number_rand_points) * v\n union = v + new_v - inter\n result.append(inter / union)\n\n return result","def mesh_collapse_edge(self, u, v, t=0.5, allow_boundary=False, fixed=None):\r\n if t < 0.0:\r\n raise ValueError('Parameter t should be greater than or equal to 0.')\r\n if t > 1.0:\r\n raise ValueError('Parameter t should be smaller than or equal to 1.')\r\n\r\n # # collapsing of boundary vertices is currently not supported\r\n # # change this to `and` to support collapsing to or from the boundary\r\n # if self.is_vertex_on_boundary(u) or self.is_vertex_on_boundary(v):\r\n # return\r\n\r\n # # check for contained faces\r\n # for nbr in self.halfedge[u]:\r\n # if nbr in self.halfedge[v]:\r\n # # check if U > V > NBR is a face\r\n # if (self.halfedge[u][v] != self.halfedge[v][nbr] or self.halfedge[u][v] != self.halfedge[nbr][u]):\r\n # # check if V > U > NBR is a face\r\n # if (self.halfedge[v][u] != self.halfedge[u][nbr] or self.halfedge[v][u] != self.halfedge[nbr][v]):\r\n # return\r\n # for nbr in self.halfedge[v]:\r\n # if nbr in self.halfedge[u]:\r\n # # check if U > V > NBR is a face\r\n # if (self.halfedge[u][v] != self.halfedge[v][nbr] or self.halfedge[u][v] != self.halfedge[nbr][u]):\r\n # # check if V > U > NBR is a face\r\n # if (self.halfedge[v][u] != self.halfedge[u][nbr] or self.halfedge[v][u] != self.halfedge[nbr][v]):\r\n # return\r\n\r\n # check collapse conditions\r\n if not is_collapse_legal(self, u, v, allow_boundary=allow_boundary):\r\n return False\r\n\r\n # compare to fixed\r\n fixed = fixed or []\r\n if v in fixed or u in fixed:\r\n return False\r\n\r\n # move U\r\n x, y, z = self.edge_point(u, v, t)\r\n self.vertex[u]['x'] = x\r\n self.vertex[u]['y'] = y\r\n self.vertex[u]['z'] = z\r\n\r\n # UV face\r\n fkey = self.halfedge[u][v]\r\n\r\n if fkey is None:\r\n del self.halfedge[u][v]\r\n\r\n else:\r\n face = self.face_vertices(fkey)\r\n f = len(face)\r\n\r\n # switch between UV face sizes\r\n # note: in a triself this is not necessary!\r\n if f < 3:\r\n raise Exception(\"Invalid self face: {}\".format(fkey))\r\n if f == 3:\r\n # delete UV\r\n o = face[face.index(u) - 1]\r\n del self.halfedge[u][v]\r\n del self.halfedge[v][o]\r\n del self.halfedge[o][u]\r\n del self.face[fkey]\r\n else:\r\n # u > v > d => u > d\r\n d = self.face_vertex_descendant(fkey, v)\r\n face.remove(v)\r\n del self.halfedge[u][v]\r\n del self.halfedge[v][d]\r\n self.halfedge[u][d] = fkey\r\n\r\n # VU face\r\n fkey = self.halfedge[v][u]\r\n\r\n if fkey is None:\r\n del self.halfedge[v][u]\r\n\r\n else:\r\n face = self.face_vertices(fkey)\r\n f = len(face)\r\n\r\n # switch between VU face sizes\r\n # note: in a triself this is not necessary!\r\n if f < 3:\r\n raise Exception(\"Invalid mesh face: {}\".format(fkey))\r\n if f == 3:\r\n # delete UV\r\n o = face[face.index(v) - 1]\r\n del self.halfedge[v][u] # the collapsing halfedge\r\n del self.halfedge[u][o]\r\n del self.halfedge[o][v]\r\n del self.face[fkey]\r\n else:\r\n # a > v > u => a > u\r\n a = self.face_vertex_ancestor(fkey, v)\r\n face.remove(v)\r\n del self.halfedge[a][v]\r\n del self.halfedge[v][u]\r\n self.halfedge[a][u] = fkey\r\n\r\n # V neighbors and halfedges coming into V\r\n for nbr, fkey in list(self.halfedge[v].items()):\r\n\r\n if fkey is None:\r\n self.halfedge[u][nbr] = None\r\n del self.halfedge[v][nbr]\r\n else:\r\n # a > v > nbr => a > u > nbr\r\n face = self.face[fkey]\r\n a = self.face_vertex_ancestor(fkey, v)\r\n face[face.index(v)] = u\r\n\r\n if v in self.halfedge[a]:\r\n del self.halfedge[a][v]\r\n del self.halfedge[v][nbr]\r\n self.halfedge[a][u] = fkey\r\n self.halfedge[u][nbr] = fkey\r\n\r\n # only update what will not be updated in the previous part\r\n # verify what this is exactly\r\n # nbr > v > d => nbr > u > d\r\n if v in self.halfedge[nbr]:\r\n fkey = self.halfedge[nbr][v]\r\n del self.halfedge[nbr][v]\r\n self.halfedge[nbr][u] = fkey\r\n\r\n # delete V\r\n del self.halfedge[v]\r\n del self.vertex[v]","def corners((u,v)):\r\n return ((u+1,v+1), (u+1,v), (u,v), (u,v+1))","def inside(self, uv):\n result = self._trimmed.Perform(gp_Pnt2d(uv[0], uv[1]))\n return result == TopAbs_IN","def is_edge(graph, u, v):\n return graph.matrix[u][v]","def cw_face_edges(self,face):\n\n l0 = self.region_link[face]\n if face == self.left_region[l0]:\n l0 = (l0[1], l0[0])\n l = l0\n\n traversing = True\n edges = []\n while traversing:\n edges.append(l)\n r = self.right_region[l]\n if r == face:\n l = self.succ_right[l]\n else:\n l = self.succ_left[l]\n if l == l0:\n traversing = False\n return edges","def householder_transformation(v):\n size_of_v = v.shape[1]\n e1 = np.zeros_like(v)\n e1[0, 0] = 1\n vector = get_norm(v) * e1\n if v[0, 0] < 0:\n vector = - vector\n u = (v + vector).astype(np.float32)\n norm2 = get_norm(u)\n u = u / norm2\n H = np.identity(size_of_v) - ((2 * np.matmul(np.transpose(u), u)) / np.matmul(u, np.transpose(u)))\n return H, u","def solve_driv(v, ene, s, n, h):\n\n xs = np.array([(k+1)*h for k in range(n)])\n h2 = h*h\n k = np.sqrt(2.0*ene)\n \n vs = [v(x)-ene for x in xs]\n\n mat = laplacian_mat(n) -2.0 * h2 * scipy.sparse.diags(vs, 0) + bc_outgoing_mat(n, h, k)\n vec = np.array([-2.0*h*h*s(x) for x in xs])\n\n ys = scipy.sparse.linalg.spsolve(mat, vec)\n return (xs, ys)","def find_hull_vertices(points: np.ndarray) -> np.ndarray:\n M = 3\n N = points.shape[0]\n for i in range(4, N):\n while ccw(points[M], points[M - 1], points[i]) >= 0:\n M -= 1\n\n M += 1\n swap(points, M, i)\n\n return points[1:M + 1]","def detect_edges_hed(self):\n inp = cv2.dnn.blobFromImage(self.input_image, scalefactor=1.0,\n size=(self.WIDTH, self.HEIGHT),\n mean=(104.00698793, 116.66876762, 122.67891434),\n swapRB=False, crop=False)\n self.net.setInput(inp)\n out = self.net.forward()\n hed = out[0, 0]\n hed = (255 * hed).astype(\"uint8\")\n hed = cv2.fastNlMeansDenoising(hed, SMOOTH_FACTOR, SMOOTH_FACTOR, 21)\n save_image_opencv(hed, 'hed')\n hed_skel = skeletonize(hed).astype(\"uint8\")\n save_image_opencv(hed_skel, 'hed_skel')\n thresheld_hed = cv2.threshold(hed_skel, 0, 255,\n cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]\n save_image_opencv(thresheld_hed, 'thresheld_hed')\n return hed, thresheld_hed","def apply_thinning(A_ub_top, A_ub_bottom, v_u, w):\n v_inds_r_remove = np.argwhere(v_u ==0)[:, 0]\n v_inds_r_keep = np.delete(np.arange(len(v_u)), v_inds_r_remove)\n\n log.debug(f\"Removing {len(v_inds_r_remove)} out of {len(v_u)} variables.\")\n\n v_u = np.delete(v_u, v_inds_r_remove, axis=0)\n A_ub_top = np.delete(A_ub_top, v_inds_r_remove, axis=1)\n A_ub_bottom = np.delete(A_ub_bottom, v_inds_r_remove, axis=1)\n A_ub_bottom = np.delete(A_ub_bottom, v_inds_r_remove, axis=0)\n\n # Remove also groups that completely disappeared --> remove columns from the right part of A_ub\n v_inds_s_remove = np.argwhere(np.sum(A_ub_bottom, axis=0) == 0)[:, 0]\n log.debug(f\"{len(v_inds_s_remove)} groups have disappeared\")\n assert np.sum(v_inds_s_remove < len(v_u)) == 0 # just in case\n A_ub_top = np.delete(A_ub_top, v_inds_s_remove, axis=1)\n A_ub_bottom = np.delete(A_ub_bottom, v_inds_s_remove, axis=1)\n w = np.delete(w, v_inds_s_remove - len(v_u), axis=0)\n\n return A_ub_top, A_ub_bottom, v_u, w, v_inds_r_keep","def get_unhindered_positions(self, endposition):\n current_position = self.position\n potential_positions = { \n 'diag1' : [],\n 'diag2' : [],\n 'diag3' : [],\n 'diag4' : []\n }\n space_down = current_position[0]-1\n space_up = self.ncols-current_position[0]\n space_right = self.nrows - (ord('H')-ord(current_position[1]))\n space_left = ord(current_position[1]) - ord('A')\n\n for i in range(1, space_down+1):\n diag1 = (current_position[0]-i, chr(ord(current_position[1])+i))\n diag2 = (current_position[0]-i, chr(ord(current_position[1])-i))\n if self.pos_within_bounds(diag1):\n potential_positions['diag1'].append(diag1)\n if self.pos_within_bounds(diag2):\n potential_positions['diag2'].append(diag2)\n\n for i in range(1, space_up+1):\n diag3 = (current_position[0]+i, chr(ord(current_position[1])+i))\n diag4 = (current_position[0]+i, chr(ord(current_position[1])-i))\n if self.pos_within_bounds(diag3):\n potential_positions['diag3'].append(diag3)\n if self.pos_within_bounds(diag4):\n potential_positions['diag4'].append(diag4)\n \n for direction, square in potential_positions.items():\n if tuple(endposition) in square:\n return potential_positions[direction]","def hypergraph_common_edges(u, v, hypergraph):\n total = 0\n for e in hypergraph.edges():\n if u in e.elements and v in e.elements:\n total += 1\n return total","def closest_pair_strip(cluster_list, horiz_center, half_width):\n\n # compute list of indices for the clusters ordered in the horizontal direction\n strip_and_index = [(cluster_list[idx], idx)\n for idx in range(len(cluster_list)) \n if abs(cluster_list[idx].horiz_center() - horiz_center) < half_width]\n #print 'strip_and_index:', strip_and_index\n #hcoord_and_index.sort()\n # print hcoord_and_index\n #horiz_order = [hcoord_and_index[idx][1]\n # for idx in range(len(hcoord_and_index))]\n \n # compute list of indices for the clusters ordered in vertical direction\n vcoord_and_index = [(strip_and_index[idx][0].vert_center(), idx)\n for idx in range(len(strip_and_index))]\n vcoord_and_index.sort()\n vert_order = [strip_and_index[vcoord_and_index[idx][1]][1]\n for idx in range(len(vcoord_and_index))] \n #print 'vert_order:', vert_order \n \n dij = (float('inf'), -1, -1)\n for udx in range(len(vert_order) - 1): # len - 2?\n start = udx + 1\n stop = min(udx + 4, len(vert_order))\n for vdx in range(start, stop):\n dist = pair_distance(cluster_list, vert_order[udx], vert_order[vdx])\n #print 'udx, vdx:', udx, vdx, 'dist:', dist\n if dist[0] < dij[0]:\n dij = dist\n \n return dij","def SH_FindOverlap(xcenter, ycenter, xlength, ylength, xp_corner, yp_corner):\n\n areaClipped = 0.0\n top = ycenter + 0.5 * ylength\n bottom = ycenter - 0.5 * ylength\n\n left = xcenter - 0.5 * xlength\n right = xcenter + 0.5 * xlength\n\n nVertices = 4 # input detector pixel vertices\n MaxVertices = 9\n # initialize xPixel, yPixel to the detector pixel corners.\n # xPixel,yPixel will become the clipped polygon vertices inside the cube pixel\n # xnew,ynew xpixel and ypixel of size MaxVertices\n\n xPixel = []\n yPixel = []\n\n xnew = []\n ynew = []\n\n for j in range(0, 9):\n xnew.append(0.0)\n ynew.append(0.0)\n xPixel.append(0.0)\n yPixel.append(0.0)\n\n\n # Xpixel, YPixel closed (5 corners)\n for i in range(0, 4):\n xPixel[i] = xp_corner[i]\n yPixel[i] = yp_corner[i]\n xPixel[4] = xp_corner[0]\n yPixel[4] = yp_corner[0]\n\n\n for i in range(0, 4): # 0:left, 1: right, 2: bottom, 3: top\n nVertices2 = 0\n for j in range(0, nVertices):\n x1 = xPixel[j]\n y1 = yPixel[j]\n x2 = xPixel[j + 1]\n y2 = yPixel[j + 1]\n condition = calcCondition(i, x1, y1, x2, y2, left, right, top, bottom)\n x = 0\n y = 0\n\n if condition == 1:\n x, y = solveIntersection(i, x1, y1, x2, y2,\n left, right, top, bottom)\n nVertices2 = addpoint(x, y, xnew, ynew, nVertices2);\n nVertices2 = addpoint(x2, y2, xnew, ynew, nVertices2)\n\n elif condition == 2:\n nVertices2 = addpoint(x2, y2, xnew, ynew, nVertices2)\n elif condition == 3:\n x, y = solveIntersection(i, x1, y1, x2, y2,\n left, right, top, bottom)\n nVertices2 = addpoint(x, y, xnew, ynew, nVertices2)\n\n#\tcondition == 4: points outside\n# Done looping over J corners\n nVertices2 = addpoint(xnew[0], ynew[0], xnew, ynew, nVertices2) # close polygon\n\n if nVertices2 > MaxVertices:\n raise Error2DPolygon(\" Failure in finding the clipped polygon, nVertices2 > 9 \")\n\n\n nVertices = nVertices2 - 1;\n\n for k in range(0, nVertices2):\n xPixel[k] = xnew[k]\n yPixel[k] = ynew[k]\n\n# done loop over top,bottom,left,right\n nVertices = nVertices + 1\n\n\n if nVertices > 0:\n areaClipped = FindAreaPoly(nVertices, xPixel, yPixel);\n\n\n return areaClipped;","def intersect_exit_hint(self, sq, hh):\n\n if not self.hints_prepped:\n self.reset_hints()\n self.hints_prepped=1\n pos=self.local2global(sq)\n if self.kind=='pararooms':\n to_outside_dvs=[dv for dv in range(4) if add(sq, dv) not in self.sqs]\n else:\n to_outside_dvs=[dv for dv in range(4) if add(sq, dv) not in self.allsqs]\n okwaysout=[]\n #~ if self.hashid=='bfb08f4204ceecf84767e77869cabce5x009x000':\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\n for h in hh:\n if h[1]=='OUT':\n okwaysout.extend(to_outside_dvs)\n continue\n if h[0]=='IN':\n okwaysout.append(h[1])\n continue\n okwaysout.append(h[1])\n okwaysout=list(set(okwaysout))\n newh=set([gh for gh in self._global_hints[pos] if gh[1] in okwaysout])\n if not newh and self._global_hints[pos]:\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\n print 'promoting cause of a conflict between the rooms-exit',pos\n return pos\n self._global_hints[pos]=newh\n self._hints[sq]=newh.copy()","def next_in_hull(p, v, L): \r\n N = normalize(p, L)\r\n if N != []:\r\n q = N[0]\r\n index = 0\r\n for k in range(1, len(N)):\r\n if (N[k] - q).dot(v) >= 0: # points on support line included\r\n q = N[k]\r\n index = k\r\n \r\n return index","def test_get_convex_hull(self):\n\n these_vertex_indices = skeleton_lines._get_convex_hull(\n vertex_x_coords=VERTEX_X_COORDS[END_NODE_VERTEX_INDICES],\n vertex_y_coords=VERTEX_Y_COORDS[END_NODE_VERTEX_INDICES])\n\n expected_indices = numpy.linspace(\n 0, len(END_NODE_VERTEX_INDICES) - 1,\n num=len(END_NODE_VERTEX_INDICES), dtype=int)\n self.assertTrue(numpy.array_equal(\n these_vertex_indices, expected_indices))","def get_neighbors(y, x, H, W):\n neighbors = []\n\n for i in (y-1, y, y+1):\n for j in (x-1, x, x+1):\n if i >= 0 and i < H and j >= 0 and j < W:\n if (i == y and j == x):\n continue\n neighbors.append((i, j))\n\n return neighbors","def get_neighbors(y, x, H, W):\n neighbors = []\n\n for i in (y-1, y, y+1):\n for j in (x-1, x, x+1):\n if i >= 0 and i < H and j >= 0 and j < W:\n if (i == y and j == x):\n continue\n neighbors.append((i, j))\n\n return neighbors","def wedge_distance(u, v):\n n_it = np.size(u)\n sum = 0\n for i in range(1, n_it):\n for j in range(i):\n sum += np.abs(u[i] * v[j] - u[j] * v[i]) ** 2\n return sum","def GetFaceToAdjacentFaces(self, p_int, int_tuple):\n ...","def FindSideToSideEdges(self, grey_image):\n kernel_size = 5\n blur_gray = cv2.GaussianBlur(grey_image, (kernel_size, kernel_size), 0)\n self.printImageForTestingPurpose('BLURRED', blur_gray)\n low_threshold = 25\n high_threshold = 75\n edges = cv2.Canny(blur_gray, low_threshold, high_threshold)\n self.printImageForTestingPurpose('EDGES USING CANNY', edges)\n\n vertical = np.copy(blur_gray)\n # [vert]\n # Specify size on vertical axis\n rows = vertical.shape[0]\n verticalsize = rows // 30\n # Create structure element for extracting vertical lines through morphology operations\n verticalStructure = cv2.getStructuringElement(cv2.MORPH_RECT, (1, verticalsize))\n # Apply morphology operations\n vertical = cv2.erode(vertical, verticalStructure)\n vertical = cv2.dilate(vertical, verticalStructure)\n # Show extracted vertical lines\n self.printImageForTestingPurpose(\"vertical\", vertical)\n # [vert]\n # [smooth]\n # Inverse vertical image\n vertical = cv2.bitwise_not(vertical)\n self.printImageForTestingPurpose(\"vertical bit\", vertical)\n\n imshape = grey_image.shape\n print(imshape)\n vertices = np.array([[(0, imshape[0]), (150, imshape[1]), (500, imshape[1]), (imshape[1], imshape[0])]],\n dtype=np.int32)\n cv2.fillPoly(grey_image, vertices, None)\n masked_edges = cv2.bitwise_and(edges, grey_image)\n self.printImageForTestingPurpose('Masked Edges', masked_edges)\n ##TODO Copied code from the medium blog.... have to see the test results.???\n rho = 0.75 # distance resolution in pixels of the Hough grid\n theta = np.pi / 180 # angular resolution in radians of the Hough grid\n threshold = 20 # minimum number of votes (intersections in Hough grid cell)\n min_line_length = 20 # minimum number of pixels making up a line\n max_line_gap = 20 # maximum gap in pixels between connectable line segments\n line_image = np.copy(grey_image) * 0 # creating a blank to draw lines on\n lines = cv2.HoughLinesP(masked_edges, rho, theta, threshold, np.array([]), min_line_length, max_line_gap)\n\n for line in lines:\n for x1, y1, x2, y2 in line:\n cv2.line(line_image, (x1, y1), (x2, y2), (255, 25, 255), 5)\n\n lines_edges = cv2.addWeighted(grey_image, 0.8, line_image, 1, 0)\n self.printImageForTestingPurpose('Lines Edges New', lines_edges)\n\n columnList = [\"y=100/98x-420\", \"y=-100/97+690\"] # Temp List\n return columnList","def firstNeighbor(v):\n for u in ranks:\n if u in matched or not self.adjacent(u, v):\n continue\n\n return u","def computeHomography(src_pnt: np.ndarray, dst_pnt: np.ndarray) -> (np.ndarray, float):\r\n\r\n A = []\r\n for i in range(0, len(src_pnt)):\r\n x, y = src_pnt[i][0], src_pnt[i][1]\r\n u, v = dst_pnt[i][0], dst_pnt[i][1]\r\n A.append([x, y, 1, 0, 0, 0, -u * x, -u * y, -u])# like we saw in class append for evey point two rows\r\n A.append([0, 0, 0, x, y, 1, -v * x, -v * y, -v])\r\n\r\n A = np.asarray(A)\r\n U, S, Vh = np.linalg.svd(A) # use SVD to find the values of the variables in the matrix\r\n L = Vh[-1, :] / Vh[-1, -1] # divided by the last row like we see in the exercise\r\n H = L.reshape(3, 3) # reshaping to 3 by 3\r\n print(H) # print our Homography\r\n #print openCv homography\r\n M, mask = cv2.findHomography(src_pnt, dst_pnt)\r\n print(\"=======================\")\r\n print(M)\r\n return H","def silhouettePhoto(self, focalPoint, focalDist, angles):\n sil = silhouette(focalPoint, focalDist, angles, [])\n sil.edgesTaken = []\n X, Y, Z = baseFromAngles(angles)\n fVect = vector(focalPoint)\n fVert = vertex(focalPoint)\n for e in self.edges:\n vertOfP = next(filter(lambda x: x not in [e.pvt, e.nvt],\n e.pFace.vertices))\n vertOfN = next(filter(lambda x: x not in [e.pvt, e.nvt],\n e.nFace.vertices))\n equ = (X.x, X.y, X.z, focalDist + fVect.dotProduct(X))\n projOfP = vector(planeLineIntersect(focalPoint, vertOfP, equ))\n projOfN = vector(planeLineIntersect(focalPoint, vertOfN, equ))\n pvtProj = vector(planeLineIntersect(focalPoint, e.pvt, equ))\n nvtProj = vector(planeLineIntersect(focalPoint, e.nvt, equ))\n print((projOfP - fVect), vector(vertOfP) - fVect)\n assert ((projOfP - fVect) * vector(vertOfP) - fVect).norm() < COMPARISON_EPSILON\n nvtReduced = vector((nvtProj - fVect).dotProduct(Z),\n (nvtProj - fVect).dotProduct(Y), 0)\n pvtReduced = vector((pvtProj - fVect).dotProduct(Z),\n (pvtProj - fVect).dotProduct(Y), 0)\n nfvReduced = vector((projOfN - fVect).dotProduct(Z),\n (projOfN - fVect).dotProduct(Y), 0)\n pfvReduced = vector((projOfP - fVect).dotProduct(Z),\n (projOfP - fVect).dotProduct(Y), 0)\n normal = (pvtReduced - nvtReduced).twoDNormal()\n s1 = normal.dotProduct(pfvReduced - pvtReduced)\n if s1 * normal.dotProduct(nfvReduced - pvtReduced) >= 0:\n if s1 > 0:\n sil.segments.append((pvtReduced.coords2D(),\n nvtReduced.coords2D()))\n else:\n sil.segments.append((nvtReduced.coords2D(),\n pvtReduced.coords2D()))\n sil.edgesTaken.append(e)\n return sil","def footprint_corner_indices():","def searchPairsBinaryOrient(_session, _beg, _end, _const):\n res = []\n it1 = _session.create_iterator(_session.sc_constraint_new(sc_constants.CONSTR_5_a_a_f_a_f, \n sc.SC_NODE | _const, # 2 \n sc.SC_ARC | sc.SC_POS | _const, # 1\n _beg, # 0\n sc.SC_ARC | sc.SC_POS | _const, # 5\n keynodes.n_1), # 6\n True)\n while not it1.is_over():\n # check if node 2 is a sheaf\n if checkIncToSets(_session, it1.value(0), [keynodes.info.stype_sheaf], sc.SC_POS | sc.SC_CONST):\n # finding other nodes to end\n res2 = _session.search_one_shot(_session.sc_constraint_new(sc_constants.CONSTR_5_f_a_f_a_f,\n it1.value(0), # 2\n sc.SC_ARC | sc.SC_POS | _const, # 3\n _end, # 4\n sc.SC_ARC | sc.SC_POS | _const, # 7\n keynodes.n_2\n ), True, 5)\n if res2 is not None:\n res.append((_beg, it1.value(1), it1.value(0), res2[1], _end, \n it1.value(4), keynodes.n_1, res[3], keynodes.n_2))\n it1.next()\n \n if len(res) > 0:\n return res\n \n return None","def TR_algo8(self, h):\n ve = 0\n vd = self._vd\n k = 0\n p = [0,]*self._N\n m = max(self._compact_M)\n vM = sum(self._compact_M)\n for i in range(m-1, -1, -1):\n mu = self.extract_mask(i)\n mu_norm = sum([bit_component(mu, j) for j in range(self._N)])\n mu = rotate_right(mu, vd+1)\n pi = rotate_right(ve, vd+1) & (~mu & 2**self._N-1)\n r = [bit_component(h, vM - k - (j+1)) for j in range(mu_norm)][::-1]\n r = sum( [rx*2**j for j, rx in enumerate(r)] )\n k = k + mu_norm\n w = gcr_inv(r, mu, pi)\n l = gc(w)\n l = T_inv(ve, vd, l)\n for j in range(self._N):\n p[j] |= bit_component(l, j) << i\n ve = ve ^ (rotate_left(e(w), vd+1))\n vd = (vd + d(w) + 1) % self._N\n return p","def get_edge(self,u,v):\n return self._outgoing[u].get(v)","def flowaux(v, e, v_in, v_out, v_c, f, l_k, k):\n v_out_prime = set()\n c_prime = set()\n\n for q in v_c:\n N = search_neighbor(q, e)\n p_set = N & (v - v_out)\n if len(p_set) == 1:\n p = list(p_set)[0]\n f[p] = q\n l_k[p] = k\n v_out_prime = v_out_prime | {p}\n c_prime = c_prime | {q}\n # determine whether there exists flow\n if not v_out_prime:\n finished = True\n if v_out == v:\n exist = True\n else:\n exist = False\n else:\n finished = False\n exist = True\n return (\n v_out | v_out_prime,\n (v_c - c_prime) | (v_out_prime & (v - v_in)),\n f,\n l_k,\n finished,\n exist,\n )","def getNeighbours(seg,meta,inversedIndex):\n return np.unique(np.fromiter( (inversedIndex[x] for x in np.concatenate([meta.loc[seg]['ins'],meta.loc[seg]['outs']])),dtype=np.int))","def common_nbrs(self, u, v):\n u_adj = self.nx_graph.neighbors(u)\n v_adj = self.nx_graph.neighbors(v)\n nbrs = []\n for u in u_adj:\n if u in v_adj:\n nbrs.append(u)\n\n return nbrs, u_adj, v_adj","def recognize_pieces(edges, v, squares):\n\n pieces = []\n\n v = cv2.equalizeHist(v)\n for p1, p2 in squares:\n # count the number of slightly centered edges\n occupancy = sum(edges[y][x]\n for x in range(p1.x + 5, p2.x - 5)\n for y in range(p1.y + 5, p2.y - 5))\n\n if occupancy > 70*255:\n corners = (v[p1.y][p1.x], v[p1.y][p2.x],\n v[p2.y][p1.x], v[p2.y][p2.x])\n\n # average v-component of the corners\n avg = sum(map(float, corners)) / len(corners)\n\n # black pixels should be relatively black\n # when compared to the corner average\n black = sum(v[y][x] / avg < 0.2\n for x in range(p1.x, p2.x + 1)\n for y in range(p1.y, p2.y + 1))\n\n if black >= 1000 and black != 1049:\n color = \"B\"\n else:\n color = \"W\"\n\n pieces.append(color)\n else:\n pieces.append(None)\n\n return pieces","def Voronoi_cell(hull, centers, vertex, original_fan):\n # make a copy so that the original does not get mutated\n fan = copy.deepcopy(original_fan)\n\n # start by moving the center\n # of the first one in the list of adjacent faces\n # to the resulting polygon\n simplex = fan.pop(0)\n result = [centers[simplex]]\n\n # find the vertices of this face\n simplex_vertices = hull.simplices[simplex]\n\n # there should only be two other vertices on this face\n # other than our given vertex\n\n # pick one of them and mark it 'known'\n # the other one will be common to the next simplex to consider\n known_vertex, common_vertex = [x for x in simplex_vertices if x != vertex]\n\n while fan:\n # the collection of faces is not exhausted yet\n assert known_vertex in simplex_vertices\n\n known_vertex_index = list(simplex_vertices).index(known_vertex)\n\n # next simplex to consider\n # it is the simplex which is opposite to the known vertex\n simplex = hull.neighbors[simplex][known_vertex_index]\n\n assert simplex in fan\n\n # now move its center to our resulting polygon\n fan.remove(simplex)\n result.append(centers[simplex])\n\n # and repeat the process\n simplex_vertices = hull.simplices[simplex]\n known_vertex = common_vertex\n\n # of the three vertices of the simplex\n # one should be our given vertex\n # and one should already have been processed\n remaining = [x for x in hull.simplices[simplex]\n if x != vertex and x != known_vertex]\n\n assert len(remaining) == 1\n common_vertex = remaining[0]\n\n return numpy.array(result)","def get_faces(self):\n for i, j in combinations(self.gens, 2):\n c0 = self.triangle_verts[self.vertex_at_mirrors(i, j)]\n f0 = []\n m = self.cox_mat[i][j]\n H = (i, j)\n type = 0\n if self.active[i] and self.active[j]:\n type = 1\n for k in range(m):\n f0.append(self.G.move(self.vtable, 0, (i, j) * k))\n f0.append(self.G.move(self.vtable, 0, (i, j) * k + (i,)))\n elif self.active[i] and m > 2:\n for k in range(m):\n f0.append(self.G.move(self.vtable, 0, (j, i) * k))\n elif self.active[j] and m > 2:\n for k in range(m):\n f0.append(self.G.move(self.vtable, 0, (i, j) * k))\n else:\n continue\n\n reps = set(self.word_generator(parabolic=H))\n reps = self.G.sort_words(reps)\n flist = []\n for word in reps:\n f = tuple(self.G.move(self.vtable, v, word) for v in f0)\n if None not in f and not helpers.check_duplicate_face(f, flist):\n center = self.transform(word, c0)\n coords = [self.vertices_coords[k] for k in f]\n face = DihedralFace(word, f, center, coords, type)\n flist.append(face)\n\n self.face_indices[(i, j)] = flist\n\n self.num_faces = sum(len(L) for L in self.face_indices.values())","def intersect_hint(self, sq, hh):\n if not self.hints_prepped:\n self.reset_hints()\n self.hints_prepped=1\n #~ self._hints[sq]=self._hints[sq].intersection(hh)\n pos=self.local2global(sq)\n #~ self._global_hints[pos]=self._global_hints[pos].intersection(hh)\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\n #~ bad=0\n #~ for h in hh:\n #~ if 'IN'==h[0]:\n #~ bad=1\n #~ break\n #~ if 'OUT'==h[1]:\n #~ bad=1\n #~ break\n #~ if bad:\n #~ for h in hh:\n #~ if 'IN'==h[0]:\n #~ self._global_hints[pos]=[gh for gh in self._global_hints[pos] if gh[1]==h[1]]\n #~ self._hints[sq]=[lh for lh in self._hints[sq] if lh[1]==h[1]]\n #~ if 'OUT'==h[1]:\n #~ self._global_hints[pos]=[gh for gh in self._global_hints[pos] if gh[0]==h[0]]\n #~ self._hints[sq]=[lh for lh in self._hints[sq] if lh[0]==h[0]]\n #~ if h in self._global_hints[pos]:\n #~ self._global_hints[pos].remove(h)\n #~ self._hints[sq].remove(h)\n #~ else:\n self._hints[sq]=self._hints[sq].intersection(hh)\n self._global_hints[pos]=self._global_hints[pos].intersection(hh)","def project (u, v):\r\n\r\n # Construct linear system Ap = d\r\n A = sps.lil_matrix ((width*height, width*height))\r\n d = np.zeros ((width*height))\r\n\r\n for i in range (1, height-1):\r\n for j in range (1, width-1):\r\n A[index(i,j), index(i,j)] = 4\r\n A[index(i,j), index(i-1,j)] = -1\r\n A[index(i,j), index(i+1,j)] = -1\r\n A[index(i,j), index(i,j-1)] = -1\r\n A[index(i,j), index(i,j+1)] = -1\r\n \r\n d[index(i,j)] = -1/h * (u[i,j] - u[i,j-1] + v[i,j] - v[i-1,j])\r\n\r\n # Unhandled boundary cases, we assume solid walls that don't move\r\n A[index(0,0), index(0,0)] = 2\r\n A[index(0,0), index(1,0)] = -1\r\n A[index(0,0), index(0,1)] = -1\r\n d[index(0,0)] = -1/h * (u[0,0] + v[0,0])\r\n\r\n A[index(height-1,0), index(0,0)] = 2\r\n A[index(height-1,0), index(height-1,1)] = -1\r\n A[index(height-1,0), index(height-2,0)] = -1\r\n d[index(height-1,0)] = -1/h * (u[height-1,0] - v[height-2,0])\r\n\r\n A[index(0,width-1), index(0,width-1)] = 2\r\n A[index(0,width-1), index(1,width-1)] = -1\r\n A[index(0,width-1), index(0,width-2)] = -1\r\n d[index(0,width-1)] = -1/h * (-u[0,width-2] + v[0,width-1])\r\n\r\n A[index(height-1,width-1), index(height-1,width-1)] = 2\r\n A[index(height-1,width-1), index(height-2,width-1)] = -1\r\n A[index(height-1,width-1), index(height-1,width-2)] = -1\r\n d[index(height-1,width-1)] = -1/h * (-u[height-1,width-2] - v[height-2,width-1])\r\n\r\n\r\n for i in range (1, height-1):\r\n A[index(i,0), index(i,0)] = 3\r\n A[index(i,0), index(i-1,0)] = -1\r\n A[index(i,0), index(i+1,0)] = -1\r\n A[index(i,0), index(i,1)] = -1\r\n d[index(i,0)] = -1/h * (u[i,0] + v[i,0] - v[i-1,0])\r\n\r\n for i in range (1, height-1):\r\n A[index(i,width-1), index(i,width-1)] = 3\r\n A[index(i,width-1), index(i-1,width-1)] = -1\r\n A[index(i,width-1), index(i+1,width-1)] = -1\r\n A[index(i,width-1), index(i,width-2)] = -1\r\n d[index(i,width-1)] = -1/h * (- u[i,width-2] + v[i, width-1] - v[i-1,width-1])\r\n\r\n for j in range (1, width-1):\r\n A[index(0,j), index(0,j)] = 3\r\n A[index(0,j), index(1,j)] = -1\r\n A[index(0,j), index(0,j-1)] = -1\r\n A[index(0,j), index(0,j+1)] = -1\r\n d[index(0,j)] = -1/h * (u[0,j] - u[0,j-1] + v[0,j])\r\n \r\n for j in range (1, width-1):\r\n A[index(height-1,j), index(height-1,j)] = 3\r\n A[index(height-1,j), index(height-2,j)] = -1\r\n A[index(height-1,j), index(height-1,j-1)] = -1\r\n A[index(height-1,j), index(height-1,j+1)] = -1\r\n d[index(height-1,j)] = -1/h * (u[height-1,j] - u[height-1,j-1] - v[height-2,j])\r\n\r\n\r\n A = A * dt / (density * h**2)\r\n\r\n A = sps.csr_matrix (A)\r\n p = np.reshape(spsolve (A, d), (height, width))\r\n\r\n # Calculate new velocity field based on this pressure field\r\n for i in range (height):\r\n for j in range (width):\r\n if (i == height-1 and j == width-1) or (i == height-1 and j == 0) or (i == 0 and j == width-1) or (i == 0 and j == 0):\r\n # Set vertical velocity to movement of solid wall 0\r\n u[i,j] = 0\r\n v[i,j] = 0\r\n elif i == height-1 or i == 0:\r\n u[i,j] = u[i,j] - dt / (density * h) * (p[i,j+1] - p[i,j])\r\n v[i,j] = 0\r\n elif j == width-1 or j == 0:\r\n u[i,j] = 0\r\n v[i,j] = v[i,j] - dt / (density * h) * (p[i+1,j] - p[i,j])\r\n else:\r\n u[i,j] = u[i,j] - dt / (density * h) * (p[i,j+1] - p[i,j])\r\n v[i,j] = v[i,j] - dt / (density * h) * (p[i+1,j] - p[i,j])\r\n\r\n # let's get some inflow\r\n u[4:12, 0] = 1\r\n\r\n return u, v, p","def vorticity_divergence(self, u, v):\n vort, div = vorticity_divergence_spectral(u, v)\n return self.to_grid(vort), self.to_grid(div)","def split_edge_mesh(mesh, u, v, t=0.5, allow_boundary=False):\n if t <= 0.0:\n raise ValueError('t should be greater than 0.0.')\n if t >= 1.0:\n raise ValueError('t should be smaller than 1.0.')\n # check if the split is legal\n # don't split if edge is on boundary\n fkey_uv = mesh.halfedge[u][v]\n fkey_vu = mesh.halfedge[v][u]\n if not allow_boundary:\n if fkey_uv is None or fkey_vu is None:\n return\n # the split vertex\n sp = mesh.vertex_coordinates(u)\n ep = mesh.vertex_coordinates(v)\n line = Line(sp, ep)\n line.scale(t)\n x, y, z = line.end\n # --------------------------------------------------------------------------\n # this interpolates the attributes\n # perhaps this should be left up to a user function\n # btw, all algorithms should have ufuncs...\n u_attr = mesh.vertex[u]\n v_attr = mesh.vertex[v]\n w_attr = {}\n for name in u_attr:\n try:\n w_attr[name] = 0.5 * (u_attr[name] + v_attr[name])\n except:\n try:\n w_attr[name] = [0.5 * (u_attr[name][_] + v_attr[name][_]) for _ in range(len(u_attr[name]))]\n except:\n w_attr[name] = None\n # --------------------------------------------------------------------------\n w = mesh.add_vertex(attr_dict=w_attr, x=x, y=y, z=z)\n # split half-edge UV\n mesh.halfedge[u][w] = fkey_uv\n mesh.halfedge[w][v] = fkey_uv\n del mesh.halfedge[u][v]\n # update the UV face if it is not the `None` face\n if fkey_uv is not None:\n mesh.face[fkey_uv][u] = w\n mesh.face[fkey_uv][w] = v\n # split half-edge VU\n mesh.halfedge[v][w] = fkey_vu\n mesh.halfedge[w][u] = fkey_vu\n del mesh.halfedge[v][u]\n # update the VU face if it is not the `None` face\n if fkey_vu is not None:\n mesh.face[fkey_vu][v] = w\n mesh.face[fkey_vu][w] = u\n # return the key of the split vertex\n return w","def rook_neighbors_face(self, face):\n edges = self.cw_face_edges(face)\n return list(set([ self.left_region[edge] for edge in edges]))","def wer(r, h):\n # initialisation\n import numpy\n d = numpy.zeros((len(r)+1)*(len(h)+1), dtype=numpy.uint8)\n d = d.reshape((len(r)+1, len(h)+1))\n for i in range(len(r)+1):\n for j in range(len(h)+1):\n if i == 0:\n d[0][j] = j\n elif j == 0:\n d[i][0] = i\n\n # computation\n for i in range(1, len(r)+1):\n for j in range(1, len(h)+1):\n if r[i-1] == h[j-1]:\n d[i][j] = d[i-1][j-1]\n else:\n substitution = d[i-1][j-1] + 1\n insertion = d[i][j-1] + 1\n deletion = d[i-1][j] + 1\n d[i][j] = min(substitution, insertion, deletion)\n\n return d[len(r)][len(h)]","def HDIF(img: list, v: int, u: int, kernel: tuple):\n if u >= v:\n print(\"v has to be larger than u\")\n else:\n diff = v - u\n blur_u = blur_n_times(img, v, kernel)\n result = get_max(get_diff(blur_n_times(blur_u, diff, kernel), blur_u))\n return result","def borders((u,v)):\r\n return ((u,v+1,S), (u+1,v,W), (u,v,S), (u,v,W))","def get_neighbors(self, row, col):\n neighbors = set()\n for d in [-1,1]:\n if row+d >= 0 and row+d < self._height and \\\n (row+d,col) in self._empty_spaces:\n neighbors.add((row+d,col))\n if col+d >= 0 and col+d < self._width and \\\n (row,col+d) in self._empty_spaces:\n neighbors.add((row,col+d))\n return neighbors","def center_flows(L_wprime, U_wprime, L_w3, U_w3, L_overlap, U_overlap):\n # examine every possible point\n current_dist_to_edge = -1\n point = (0,0)\n #print(\"w3 range: [{}, {}]\".format(L_w3, U_w3))\n #print(\"w' range: [{}, {}]\".format(L_wprime, U_wprime))\n #print(\"overlap range: [{},{}]\".format(L_overlap, U_overlap))\n for y in range(L_w3, U_w3 + 1):\n #print(\"y={}\".format(y))\n LH_bound = max(L_wprime, L_overlap - y)\n #print(\"LH bound = {}\".format(LH_bound))\n RH_bound = min(U_wprime, U_overlap - y)\n #print(\"RH bound = {}\".format(RH_bound))\n for x in range(LH_bound, RH_bound + 1):\n # w3 UB: 0x + 1y - U_w3 = 0\n # w3 LB: 0x + 1y - L_w3 = 0\n # wprime UB: 1x + 0y - U_wprime\n # wprime LB: 1x + 0y - L_wprime\n # wprime + w3 UB: 1x + 1y - U_wprime,wk\n # wprime + w3 LB: 1x + 1y - L_wprime,wk\n dist_to_edge = min(distance_point_to_line(x, y, 0, -1, U_w3), #0x-1y+U_w3=0\n distance_point_to_line(x, y, 0, -1, L_w3), #0x-1y+L_w3=0\n # -1x + 0y + U_wprime = 0\n distance_point_to_line(x, y, -1, 0, U_wprime),\n # -1x + 0y + L_wprime = 0\n distance_point_to_line(x, y, -1, 0, L_wprime),\n # -1x - 1y + U_overlap = 0\n distance_point_to_line(x, y, -1, -1, U_overlap),\n # -1 x - y + L_overlap = 0\n distance_point_to_line(x, y, -1, -1, L_overlap))\n if dist_to_edge > current_dist_to_edge:\n #print(\"At point ({},{}), distance to edge increased from {} to {}.\"\\\n # .format(x,y,current_dist_to_edge,dist_to_edge))\n current_dist_to_edge = dist_to_edge\n point = (x,y)\n return(point)","def neighbors(i , j) :\n ns = []\n # vector de direction\n dx = [+1, +1, 0, 1]\n dy = [0, +1, 1, -1]\n for d in range(4) :\n ns.append((i + dx[d], j + dy[d]))\n #remove neagative element\n ns = [i for i in ns if i[0] >= 0 and i[1] >= 0]\n return ns","def neighbors(self, u):\r\n return filter(lambda v: self.getCapacity((u,v)) > 0, self.adjacent[u])","def regions_from_graph(vertices, edges):\n # step 0 remove filaments (not included in original algorithm)\n nv = np.zeros(len(vertices))\n v = vertices.keys()\n v.sort()\n v2e = {}\n for edge in edges:\n s,e = edge\n nv[v.index(s)] += 1\n nv[v.index(e)] += 1\n v2e[s] = edge\n v2e[e] = edge\n\n filament_nodes = np.nonzero(nv==1)[0]\n filaments = []\n for f in filament_nodes:\n filaments.append(v2e[f])\n edges.remove(v2e[f])\n\n #print filaments\n\n # step 1\n # have a twin for each directed edge\n dedges = edges[:]\n for edge in edges:\n new_edge = edge[1], edge[0]\n if new_edge not in dedges:\n dedges.append( (edge[1],edge[0]) )\n\n # step 2 complement each directed edge with an angle formed with horizontal\n # line passing through edge[0] for each edge\n angles = []\n from math import atan2, degrees\n\n for edge in dedges:\n\n v1 = vertices[edge[0]]\n v2 = vertices[edge[1]]\n dx = v2[0] - v1[0]\n dy = v2[1] - v1[1]\n at = atan2(dy, dx)\n d = degrees(at)\n if d < 0:\n d = 360 + d\n angles.append( [ (edge[0],d), (edge[0],edge[1]) ])\n\n # step 3 sort the list into ascending order using vi and angle as primary and\n # secondary keys\n angles.sort()\n\n\n # form wedges on consecutive entries with same vi (vi,vj,dij), (vi,vk,dik)\n # gives the wedge (vk,vi,vj)\n wedges = []\n start = angles[0]\n c = 0\n for i in range(1,len(angles)):\n next_edge = angles[i]\n previous_edge = angles[i-1]\n if next_edge[0][0] == start[0][0]:\n wedge = [ next_edge[1][1], previous_edge[1][0], previous_edge[1][1] ]\n wedges.append(wedge)\n else:\n # first form wedge with last and first entry of current group\n # to do\n wedge = [ start[1][1], previous_edge[1][0], previous_edge[1][1] ]\n wedges.append(wedge)\n start = next_edge\n\n # final pair\n\n wedge = [ start[1][1], previous_edge[1][0], next_edge[1][1] ]\n wedges.append(wedge)\n\n\n # phase two\n # form regions from contiguous wedges\n\n nw = len(wedges)\n used = [0]*nw\n wedges.sort()\n #print wedges\n\n #print 'forming regions'\n\n i = 0\n regions = []\n while sum(used) < nw:\n i = used.index(0)\n wi = wedges[i]\n start = wedges[i]\n used[i] = 1\n region = [start]\n # find next contiguous wedge for wi\n forming = True\n while forming:\n\n\n # find first wedge contiguous to wi\n for j in xrange(nw):\n wj = wedges[j]\n if wj[0] == wi[1] and wj[1] == wi[2]:\n region.append(wj)\n used[j] = 1\n wi = wj\n if wi[1] == start[0] and wi[2] == start[1]:\n forming = False\n regions.append(region)\n #print start, regions\n #raw_input('h')\n break\n\n # put in closed cartographic form\n nodes = []\n for region in regions:\n wedge0 = [ wedge[0] for wedge in region]\n wedge0.append(wedge0[0])\n nodes.append(wedge0)\n\n results = {}\n results['regions'] = nodes\n results['filaments'] = filaments\n\n return results","def GetBoundaryFacesHex(self):\n\n p = self.InferPolynomialDegree()\n\n # DO NOT COMPUTE IF ALREADY COMPUTED\n if isinstance(self.faces,np.ndarray):\n if self.faces.shape[0] > 1:\n # IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION\n if self.faces.shape[1] == 4 and p > 1:\n pass\n else:\n return\n\n node_arranger = NodeArrangementHex(p-1)[0]\n\n # CONCATENATE ALL THE FACES MADE FROM ELEMENTS\n all_faces = np.concatenate((np.concatenate((\n np.concatenate((np.concatenate((np.concatenate((self.elements[:,node_arranger[0,:]],\n self.elements[:,node_arranger[1,:]]),axis=0),self.elements[:,node_arranger[2,:]]),axis=0),\n self.elements[:,node_arranger[3,:]]),axis=0),self.elements[:,node_arranger[4,:]]),axis=0),\n self.elements[:,node_arranger[5,:]]),axis=0).astype(np.int64)\n # GET UNIQUE ROWS\n uniques, idx, inv = unique2d(all_faces,consider_sort=True,order=False,return_index=True,return_inverse=True)\n\n # ROWS THAT APPEAR ONLY ONCE CORRESPOND TO BOUNDARY FACES\n freqs_inv = itemfreq(inv)\n faces_ext_flags = freqs_inv[freqs_inv[:,1]==1,0]\n # NOT ARRANGED\n self.faces = uniques[faces_ext_flags,:]\n\n # DETERMINE WHICH FACE OF THE ELEMENT THEY ARE\n boundary_face_to_element = np.zeros((faces_ext_flags.shape[0],2),dtype=np.int64)\n\n # FURTHER RE-ARRANGEMENT / ARANGE THE NODES BASED ON THE ORDER THEY APPEAR\n # IN ELEMENT CONNECTIVITY\n # THIS STEP IS NOT NECESSARY INDEED - ITS JUST FOR RE-ARANGMENT OF FACES\n all_faces_in_faces = in2d(all_faces,self.faces,consider_sort=True)\n all_faces_in_faces = np.where(all_faces_in_faces==True)[0]\n\n # boundary_face_to_element = np.zeros((all_faces_in_faces.shape[0],2),dtype=np.int64)\n boundary_face_to_element[:,0] = all_faces_in_faces % self.elements.shape[0]\n boundary_face_to_element[:,1] = all_faces_in_faces // self.elements.shape[0]\n\n # ARRANGE FOR ANY ORDER OF BASES/ELEMENTS AND ASSIGN DATA MEMBERS\n self.faces = self.elements[boundary_face_to_element[:,0][:,None],node_arranger[boundary_face_to_element[:,1],:]]\n self.faces = self.faces.astype(np.uint64)\n self.boundary_face_to_element = boundary_face_to_element","def detect_four_corners_based_on_ref_squares(img,\n ref_vertex,\n search_margin=0.1,\n square_width=50./2480,\n debug_=False):\n square_ratio_range = [0.8, 1.2]\n square_width_margin = 0.5\n square_fill_thresh = 0.8\n\n debug_in_ = False\n\n dim = img.shape[1::-1]\n square_width = square_width * dim[0]\n real_vertices = hp.generate_four_vertices_from_ref_vertex(ref_vertex, dim)\n crop_boxes = []\n offsets = [int(x*search_margin) for x in dim]\n crop_boxes.append([real_vertices[0][0], real_vertices[0][1],\n real_vertices[0][0]+offsets[0], real_vertices[0][1]+offsets[1]])\n crop_boxes.append([real_vertices[1][0]-offsets[0], real_vertices[1][1],\n real_vertices[1][0], real_vertices[1][1]+offsets[1]])\n crop_boxes.append([real_vertices[2][0], real_vertices[2][1]-offsets[1],\n real_vertices[2][0]+offsets[0], real_vertices[2][1]])\n crop_boxes.append([real_vertices[3][0]-offsets[0], real_vertices[3][1]-offsets[1],\n real_vertices[3][0], real_vertices[3][1]])\n\n detected_vertices = []\n kernel = np.ones((5,5),np.uint8)\n for idx in range(4):\n crop_img = img[crop_boxes[idx][1]:crop_boxes[idx][3],\n crop_boxes[idx][0]:crop_boxes[idx][2]]\n gray_img = cv2.cvtColor(crop_img, cv2.COLOR_RGB2GRAY)\n ret, thresh_gray = cv2.threshold(gray_img,\n thresh=200,\n maxval=255,\n # type=cv2.THRESH_BINARY)\n type=cv2.THRESH_BINARY+cv2.THRESH_OTSU)\n for _ in range(3):\n thresh_gray = cv2.morphologyEx(thresh_gray, cv2.MORPH_CLOSE, kernel)\n cv2.bitwise_not(thresh_gray, thresh_gray)\n thresh_color = cv2.cvtColor(thresh_gray, cv2.COLOR_GRAY2RGB)\n ret, contours, hierarchy = cv2.findContours(thresh_gray, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n min_width_ratio = 1\n det_vertex = []\n for i, cont in enumerate(contours):\n x1, y1, w, h = cv2.boundingRect(cont)\n ratio = h/w\n width_ratio = abs(square_width - w) / square_width\n if debug_in_:\n if w > 10 and h > 10:\n # cv2.drawContours(crop_img, contours, i, hp.GREEN, thickness=4)\n cv2.drawContours(thresh_color, contours, i, hp.GREEN, thickness=4)\n print(\"-------\")\n print(i)\n print(x1, y1, w, h, width_ratio)\n print(ratio, cv2.contourArea(cont)/(w*h))\n\n if square_ratio_range[0] < ratio < square_ratio_range[1] and \\\n width_ratio < square_width_margin and \\\n cv2.contourArea(cont) / (w*h) > square_fill_thresh:\n moments = cv2.moments(cont)\n cx = int(moments['m10'] / moments['m00'])\n cy = int(moments['m01'] / moments['m00'])\n if width_ratio < min_width_ratio:\n det_vertex = [cx + crop_boxes[idx][0], cy + crop_boxes[idx][1]]\n min_width_ratio = width_ratio\n # print(\"****\")\n if debug_:\n disp_img = np.copy(crop_img)\n cv2.drawContours(disp_img, contours, i, hp.RED, thickness=4)\n cv2.circle(disp_img,(cx, cy), 8, hp.GREEN, -1)\n hp.hp_imshow(disp_img)\n if debug_in_:\n hp.hp_imshow(thresh_color, desc=\"thresh_color\")\n if det_vertex:\n detected_vertices.append(det_vertex)\n box_img = np.copy(img)\n if len(detected_vertices) != 4:\n # print(\" @ Error: 4 corners are NOT detected!\")\n return False, detected_vertices, img\n\n cv2.line(box_img, tuple(detected_vertices[0]), tuple(detected_vertices[1]), hp.RED, 10)\n cv2.line(box_img, tuple(detected_vertices[0]), tuple(detected_vertices[2]), hp.RED, 10)\n cv2.line(box_img, tuple(detected_vertices[1]), tuple(detected_vertices[3]), hp.RED, 10)\n cv2.line(box_img, tuple(detected_vertices[2]), tuple(detected_vertices[3]), hp.RED, 10)\n if debug_:\n hp.hp_imshow(box_img, desc=\"four corners\")\n\n return True, detected_vertices, img","def is_collapse_legal(mesh, u, v, allow_boundary=False):\r\n # collapsing of boundary vertices is currently not supported\r\n # change this to `and` to support collapsing to or from the boundary\r\n if not allow_boundary:\r\n if mesh.is_vertex_on_boundary(v) or mesh.is_vertex_on_boundary(u):\r\n return False\r\n\r\n # check for contained faces\r\n for nbr in mesh.halfedge[u]:\r\n if nbr in mesh.halfedge[v]:\r\n # check if U > V > NBR is a face\r\n fkey = mesh.halfedge[u][v]\r\n if fkey != mesh.halfedge[v][nbr] or fkey != mesh.halfedge[nbr][u]:\r\n # check if V > U > NBR is a face\r\n fkey = mesh.halfedge[v][u]\r\n if fkey != mesh.halfedge[u][nbr] or fkey != mesh.halfedge[nbr][v]:\r\n return False\r\n\r\n for nbr in mesh.halfedge[v]:\r\n if nbr in mesh.halfedge[u]:\r\n # check if U > V > NBR is a face\r\n fkey = mesh.halfedge[u][v]\r\n if fkey != mesh.halfedge[v][nbr] or fkey != mesh.halfedge[nbr][u]:\r\n # check if V > U > NBR is a face\r\n fkey = mesh.halfedge[v][u]\r\n if fkey != mesh.halfedge[u][nbr] or fkey != mesh.halfedge[nbr][v]:\r\n return False\r\n\r\n return True","def get_shouldering(binary_mask):\n shoulder_dict = get_shoulders(binary_mask)\n\n top_y_min = shoulder_dict[\"top_y_min\"]\n top_y_max = shoulder_dict[\"top_y_max\"]\n top_x_min = shoulder_dict[\"top_x_min\"]\n top_x_max = shoulder_dict[\"top_x_max\"]\n\n bottom_y_min = shoulder_dict[\"bottom_y_min\"]\n bottom_y_max = shoulder_dict[\"bottom_y_max\"]\n bottom_x_min = shoulder_dict[\"bottom_x_min\"]\n bottom_x_max = shoulder_dict[\"bottom_x_max\"]\n\n top_shoulder = binary_mask[top_y_min:top_y_max, top_x_min:top_x_max]\n bottom_shoulder = binary_mask[bottom_y_min:bottom_y_max, bottom_x_min:bottom_x_max]\n\n white_top = get_biomass(top_shoulder)\n black_top = (top_shoulder.shape[0] * top_shoulder.shape[1]) - white_top\n\n white_bottom = get_biomass(bottom_shoulder)\n black_bottom = (bottom_shoulder.shape[0] * bottom_shoulder.shape[1]) - white_bottom\n\n return black_top, black_bottom","def is_vert(e) :\n f = e[0][0]\n for t in e :\n if f != t[0] :\n return False\n return True","def conv_hls_halfmask(image):\n image = np.copy(image)\n # Convert to HSV color space and separate the V channel\n hls = cv2.cvtColor(image, cv2.COLOR_RGB2HLS).astype(np.float)\n # AOI (area of interest) mask - we only care about lower part of the image\n size_x, size_y, size_ch = hls.shape\n hls[0:size_x//2,:,:] = 0\n return hls","def get_k2(tri, v_neighbours):\n three = np.array([0, 1, 2])\n nv = tri.shape[0]\n k2s = np.empty((nv, 3), dtype=np.int32)\n for i in range(nv):\n for k in range(3):\n neighbour = v_neighbours[i, k]\n k2 = ((v_neighbours[neighbour] == i) * three).sum()\n k2s[i, k] = k2\n return k2s","def divergence(self, u, v):\n return self.to_grid(self.divergence_spectral(u, v))","def GetFaceToAdjacentFacesArray(self, p_int):\n ...","def close_up(edge_count, used_pivots):\n edges = []\n for edge, count in edge_count.items():\n if count == 1:\n edges.append(edge)\n\n faces = []\n lazy_update = collections.defaultdict(int) # default = 0\n while edges:\n vertices = None\n for (i, edge_a), (j, edge_b) in\\\n itertools.combinations(enumerate(edges), 2):\n vertices = set(edge_a).union(set(edge_b))\n if len(vertices) == len(edge_a[0]):\n edges[i], edges[j], edges[-1], edges[-2] =\\\n edges[-1], edges[-2], edges[i], edges[j]\n edges.pop()\n edges.pop()\n break\n else:\n # Cannot find a face, update edges and edges count\n updated = False\n for edge in lazy_update: # = .keys()\n if lazy_update[edge] + edge_count[edge] == 1:\n edges.append(edge)\n lazy_update[edge] = 2 # Avoid duplicated edges\n updated = True\n if not updated:\n break\n continue\n\n face = list(vertices)\n for pivot in used_pivots: # = .keys()\n if pivot not in vertices:\n if not check_inside(face, pivot)[0]:\n # det(A) = -det (B) if two cols swap (odd and even)\n face[-1], face[-2] = face[-2], face[-1]\n break\n else:\n # This edge is the first edge\n return []\n\n faces.append(tuple(face))\n for edge in itertools.combinations(tuple(face), len(face) - 1):\n lazy_update[tuple(sort_vertices(edge))] += 1\n\n return faces","def get_neighbours(tri,neigh=None,Range=None):\n n_v = tri.shape[0]\n if neigh is None:\n neigh = np.ones_like(tri,dtype=np.int32)*-1\n if Range is None:\n Range = np.arange(n_v)\n tri_compare = np.concatenate((tri.T, tri.T)).T.reshape((-1, 3, 2))\n for j in Range:#range(n_v):\n tri_sample_flip = np.flip(tri[j])\n tri_i = np.concatenate((tri_sample_flip,tri_sample_flip)).reshape(3,2)\n for k in range(3):\n if neigh[j,k]==-1:\n neighb,l = np.nonzero((tri_compare[:,:,0]==tri_i[k,0])*(tri_compare[:,:,1]==tri_i[k,1]))\n neighb,l = neighb[0],l[0]\n neigh[j,k] = neighb\n neigh[neighb,np.mod(2-l,3)] = j\n return neigh","def closest_pair_strip(cluster_list, horiz_center, half_width):\n indices = [] \n\n # Let S be a list of the set {i: |xi - mid| < half_width}\n indices = [index for index in range(len(cluster_list)) if abs(cluster_list[index].horiz_center()-horiz_center)<=half_width]\n \n\t# Sort the indices in S in nondecreasing order of the vertial (y) coordinates of their associated points;\n indices.sort(key = lambda index: cluster_list[index].vert_center())\n\n cl_sorted = cluster_list[:]\n cl_sorted.sort(key = lambda cluster: cluster.vert_center())\n\n # k <-- length(S);\n len_indices = len(indices)\n\n # (d,i,j) <-- (infinity, -1, -1);\n output_list = [float('inf'), -1, -1]\t\n\n # for u <-- 0 to k - 2 do\n for value1 in range(len_indices-1):\n \t# \tfor v <-- u + 1 to min{u+3,k-1} do\n for value2 in range(value1+1, min(value1+6,len_indices)):\n # (d,i,j) <-- min{(d,i,j),(dsub(psubS[u],PsubS[v]), S[u],S[v])}\n min_dist = min(output_list[0], pair_distance(cluster_list,indices[value1],indices[value2])[0])\n if output_list[0] > min_dist:\n indices_sorted = sorted([indices[value1], indices[value2]])\n \toutput_list = [pair_distance(cluster_list,indices[value1],indices[value2])[0], indices_sorted[0], indices_sorted[1]]\n\n # return(d,i,j)\n return tuple(output_list)","def directed_Hausdorff_hyperbox(b1,b2): \n return max(0,np.max(np.hstack((b1.u-b2.u,b2.l-b1.l))))","def calc_surface(u, v):\n\n # # Wavy surface\n # surface = np.array([\n # u,\n # v,\n # np.exp(- (u**2 + v**2) / 30) * np.cos(np.sqrt(u**2 + v**2))\n # ])\n\n # Shere - {one_point}\n surface = np.array([\n 2 * u,\n 2 * v,\n 1 - u**2 - v**2\n ]) / (1 + u**2 + v**2)\n return (surface[0], surface[1], surface[2])","def endpoints((u,v,o)):\r\n return { W : ((u,v+1), (u,v)),\r\n S : ((u+1,v), (u,v)) }[o]","def cross_junctions(I, bounds, Wpts):\n #--- FILL ME IN ---\n\n Ipts = np.zeros((2, 48))\n\n#parameters\n alpha = 0.15 #typically 0.04 to 0.06\n threshold = 1500 #default 2000\n sigma = 2\n ws = 12 #window size for saddle point\n\n#building Harris Detecter\n I = I/255.0\n gradx, grady = np.gradient(I)\n IxIx = gaussian_filter(gradx*gradx,sigma)\n IxIy = gaussian_filter(gradx*grady,sigma)\n IyIy = gaussian_filter(grady*grady,sigma)\n print(I.shape)\n\n #get harris score\n cand_score = []\n cand_index = []\n cand = []\n s_cand = []\n\n for j in range(len(I)):\n for i in range(len(I[0])):\n a11 = IxIx[j][i]\n a12 = IxIy[j][i]\n a21 = a12\n a22 = IyIy[j][i]\n A = np.array([[a11, a12],[a21, a22]])\n ev0, ev1 = np.linalg.eigvals(A)\n h_score = ev0*ev1 - alpha*(ev0+ev1)**2\n cand_score.append(-h_score)\n cand_index.append([i, j])\n\n #get the coordinates of the top 5000 scores\n sorted_ind = np.argsort(cand_score)\n sorted_score = np.sort(cand_score).tolist()\n\n for ind in sorted_ind[:threshold]:\n cand.append(cand_index[ind])\n s_cand = sorted_score[:threshold]\n\n\n#clustering\n #using homography to project candidate points to a up-front view\n new_bbox = np.array([[0, 100, 100, 0],[0, 0, 80, 80]])\n H = dlt_homography(bounds, new_bbox)\n cand = np.array(cand).T\n cand = np.vstack((cand, np.ones(cand.shape[1])))\n Ho_cand = np.matmul(H,cand).T\n for pt in Ho_cand:\n pt[0] = pt[0]/pt[2]\n pt[1] = pt[1]/pt[2]\n Ho_cand = Ho_cand[:,:2]\n Ho_cand = Ho_cand.tolist()\n\n #get rid of points that are not in the boundry\n temp_Ho_cand = []\n temp_s_cand = []\n for i in range(len(Ho_cand)):\n pt = Ho_cand[i]\n if (pt[0]>=100) or (pt[0]<0) or (pt[1]>=80) or (pt[1]<0):\n continue\n else:\n temp_Ho_cand.append(pt)\n temp_s_cand.append(s_cand[i])\n Ho_cand = np.array(temp_Ho_cand)\n s_cand = temp_s_cand\n #divide candidates into clusters\n assignment = []\n assignment_score = []\n\n #first put in the point that has the highest score\n assignment.append([Ho_cand[0]])\n assignment_score.append([s_cand[0]])\n for i in range(len(Ho_cand)):\n pt = Ho_cand[i]\n dist = []\n for c in assignment:\n dist.append(np.linalg.norm(pt - c[0]))\n if min(dist) > 6:\n assignment.append([pt])\n assignment_score.append([s_cand[i]])\n\n assignment = np.array(assignment)\n\n #assign points to clusters\n for i in range(len(Ho_cand)):\n pt = Ho_cand[i]\n if (pt[0] == Ho_cand[0][0]) and (pt[1] == Ho_cand[0][1]):\n continue\n dist = []\n for c in assignment:\n dist.append(np.linalg.norm(pt - c[0]))\n index = np.argsort(dist)[-1]\n np.append(assignment[index], pt)\n assignment_score[index].append(s_cand[i])\n\n #get centroids for each cluster\n Ho_centroids = []\n for i in range(len(assignment)):\n cl = assignment[i]\n cl = np.array(cl)\n Ho_centroids.append([np.mean(cl.T[0]),np.mean(cl.T[1])])\n assignment_score[i] = sum(assignment_score[i])\n\n print(len(assignment_score))\n\n Ho_centroids = np.array(Ho_centroids)\n #get rid of edge points\n\n xmin = np.amin(Ho_centroids.T[0])\n xmax = np.amax(Ho_centroids.T[0]) \n ymin = np.amin(Ho_centroids.T[1])\n ymax = np.amax(Ho_centroids.T[1])\n\n final_cand = []\n final_score = []\n for i in range(len(Ho_centroids)):\n pt = Ho_centroids[i]\n if (abs(pt[0] - xmin) <= 3) or (abs(pt[0] - xmax) <= 3) or (abs(pt[1] - ymin) <= 3) or (abs(pt[1] - ymax) <= 3):\n continue\n else:\n final_cand.append(pt)\n final_score.append(assignment_score[i])\n print(\"Number of corner found: \")\n print(len(final_cand))\n\n #get rid of fake corners\n if (len(final_cand)>48):\n ultimate_cand =[]\n for ind in np.argsort(final_score)[:48]:\n ultimate_cand.append(final_cand[ind])\n final_cand = ultimate_cand\n print(\"real corners count:\", len(ultimate_cand))\n\n\n #sort the points\n final_cand = np.array(final_cand)\n y_sort_ind = np.argsort(final_cand.T[1])\n final_cand = final_cand.tolist()\n rows = []\n for i in range(6):\n row = []\n for ind in y_sort_ind[i*8:(i+1)*8]:\n row.append(final_cand[ind])\n rows.append(row)\n\n ordered = []\n for row in rows:\n r = []\n x_sort_ind = np.argsort(np.array(row).T[0])\n for ind in x_sort_ind:\n r.append(row[ind])\n ordered.append(r)\n\n final_cand = []\n for row in ordered:\n for pt in row:\n final_cand.append(pt)\n \n\n\n #get coordinates of the centroids in the original frame\n Ho_centroids = np.array(final_cand)\n\n centroids = np.vstack((Ho_centroids.T, np.ones(Ho_centroids.shape[0])))\n centroids = np.matmul(np.linalg.inv(H), centroids).T\n for pt in centroids:\n pt[0] = int(pt[0]/pt[2])\n pt[1] = int(pt[1]/pt[2])\n centroids = centroids[:,:2]\n\n#finding saddle points around the centroids\n saddle_points = []\n for pt in centroids:\n img = I[int(pt[1]-ws):int(pt[1]+ws), int(pt[0]-ws):int(pt[0]+ws)]\n saddle = saddle_point(img)\n saddle = [saddle[0][0]+pt[0]-ws, saddle[1][0]+pt[1]-ws]\n saddle_points.append(saddle)\n\n saddle_points = np.array(saddle_points)\n #------------------\n print(saddle_points.T)\n return saddle_points.T","def dndt2(jx, iy, h, n, u, v, dx, dy) :\n p5 = np.float32(0.5)\n depth_jm0im0 = h[jx, iy ]+n[jx, iy]\n depth_jp1im0 = h[jx+1,iy] +n[jx+1,iy]\n depth_jm1im0 = h[jx-1,iy] +n[jx-1,iy]\n depth_jm0ip1 = h[jx, iy+1]+n[jx, iy+1]\n depth_jm0im1 = h[jx, iy-1]+n[jx, iy-1]\n \n hx_jp1 = u[jx+1,iy]*(depth_jm0im0 + depth_jp1im0)*p5\n hx_jm0 = u[jx, iy]*(depth_jm1im0 + depth_jm0im0)*p5\n \n \n hy_ip1 = v[jx,iy+1]*(depth_jm0im0 + depth_jm0ip1)*p5\n hy_im0 = v[jx,iy ]*(depth_jm0im1 + depth_jm0im0)*p5\n \n # assume u and v are zero on edge\n dhx = (hx_jp1-hx_jm0)/dx#[jx,iy]\n dhy = (hy_ip1-hy_im0)/dy#[jx,iy]\n\n \n return ( -dhx-dhy )","def GetEdgeToAdjacentFacesArray(self, p_int):\n ...","def get_inverse_2x2(u, v):\n if not is_linearly_independent_2x2(u, v):\n return\n uv = get_uv(u, v)\n iden = get_uv([1, 0],[0, 1])\n a = np.zeros((2, 4))\n for i in range(2):\n for j in range(2):\n a[i][j] = uv[i][j]\n a[i][j+2] = iden[i][j]\n\n q = a[0][1] / a[1][1]\n a[0] = a[0] - q * a[1]\n\n q = a[1][0] / a[0][0]\n a[1] = a[1] - q * a[0]\n\n a[0] /= a[0][0]\n\n a[1] /= a[1][1]\n\n for i in range(2):\n for j in range(2):\n uv[i][j] = a[i][j+2]\n return uv","def check_uv_border_crossing(progress_controller=None):\n if progress_controller is None:\n progress_controller = ProgressControllerBase()\n\n # skip if this is a representation\n v = staging.get(\"version\")\n if v and Representation.repr_separator in v.take_name:\n progress_controller.complete()\n return\n\n all_meshes = pm.ls(type=\"mesh\")\n mesh_count = len(all_meshes)\n progress_controller.maximum = mesh_count\n nodes_with_uvs_crossing_borders = []\n\n for node in all_meshes:\n all_uvs = node.getUVs()\n # before doing anything get all the uvs and skip if all of them are\n # in the same UV quadrant (which is the wrong name, sorry!)\n all_uvs_u = sorted(all_uvs[0])\n all_uvs_v = sorted(all_uvs[1])\n if int(all_uvs_u[0]) == int(all_uvs_u[-1]) and int(all_uvs_v[0]) == int(\n all_uvs_v[-1]\n ):\n # skip this mesh\n continue\n\n #\n # Group uvs according to their UV shells\n #\n # The following method is 20-25% faster than using getUvShellsIds()\n #\n num_uvs = node.numUVs()\n uv_ids = list(range(num_uvs))\n\n uv_shells_and_uv_ids = []\n uv_shells_and_uv_coords = []\n\n i = 0\n while len(uv_ids) and i < num_uvs + 1:\n current_uv_id = uv_ids[0]\n # the polyListComponentConversion takes 85% of the processing time\n # of getting the uvShells here\n shell_uv_group_ids = pm.polyListComponentConversion(\n \"%s.map[%s]\" % (node.name(), current_uv_id), toUV=1, uvShell=1\n )\n\n uv_shell_uv_ids = []\n uv_shell_uv_coords = [[], []]\n for uv_group_ids in shell_uv_group_ids:\n if \":\" in uv_group_ids:\n splits = uv_group_ids.split(\":\")\n start_uv_id = int(splits[0].split(\"[\")[1])\n end_uv_id = int(splits[1].split(\"]\")[0])\n else:\n splits = uv_group_ids.split(\"[\")\n start_uv_id = int(splits[1].split(\"]\")[0])\n end_uv_id = start_uv_id\n\n for j in range(start_uv_id, end_uv_id + 1):\n uv_ids.remove(j)\n uv_shell_uv_ids.append(j)\n uv_shell_uv_coords[0].append(all_uvs[0][j])\n uv_shell_uv_coords[1].append(all_uvs[1][j])\n\n # store the uv ids and uv coords in this shell\n uv_shells_and_uv_ids.append(uv_shell_uv_ids)\n uv_shells_and_uv_coords.append(uv_shell_uv_coords)\n\n # go to the next pseudo uv shell id\n i += 1\n\n # now check all uvs per shell\n try:\n for uv_shell_uv_coords in uv_shells_and_uv_coords:\n us = sorted(uv_shell_uv_coords[0])\n vs = sorted(uv_shell_uv_coords[1])\n\n # check first and last u and v values\n if int(us[0]) != int(us[-1]) or int(vs[0]) != int(vs[-1]):\n # they are not equal it is crossing spaces\n nodes_with_uvs_crossing_borders.append(node)\n break\n except (IndexError, RuntimeError) as e:\n print(\"%s\\nnode: %s\" % (e, node))\n raise RuntimeError()\n\n progress_controller.increment()\n\n progress_controller.complete()\n if len(nodes_with_uvs_crossing_borders):\n # get transform nodes\n tra_nodes = list(map(lambda x: x.getParent(), nodes_with_uvs_crossing_borders))\n pm.select(tra_nodes)\n raise RuntimeError(\n \"\"\"There are nodes with <b>UV-Shells</b> that are crossing\n <b>UV BORDERS</b>:<br><br>%s\"\"\"\n % \"<br>\".join(map(lambda x: x.name(), tra_nodes[:MAX_NODE_DISPLAY]))\n )","def wer(r, h):\n #build the matrix\n d = numpy.zeros((len(r)+1)*(len(h)+1), dtype=numpy.uint8).reshape((len(r)+1, len(h)+1))\n for i in range(len(r)+1):\n for j in range(len(h)+1):\n if i == 0: d[0][j] = j\n elif j == 0: d[i][0] = i\n for i in range(1, len(r)+1):\n for j in range(1, len(h)+1):\n if r[i-1] == h[j-1]:\n d[i][j] = d[i-1][j-1]\n else:\n substitute = d[i-1][j-1] + 1\n insert = d[i][j-1] + 1\n delete = d[i-1][j] + 1\n d[i][j] = min(substitute, insert, delete)\n result = float(d[len(r)][len(h)]) / len(r) * 100\n result = str(\"%.2f\" % result) + \"%\"\n return d[len(r)][len(h)]\n #find out the manipulation steps","def H_inside(self, r):\n\n return self.S * quad(self.H_integ_inside, 0, 1, args=(r,))[0]","def get_NONuniform_polar_angle(xx, yy, rsq, angle_thresh = 3*np.pi/4, rsq_thresh = 0, pysub = 'hcp_999999'):\n\n hsv_angle = []\n hsv_angle = np.ones((len(rsq), 3))\n\n ## calculate polar angle\n polar_angle = np.angle(xx + yy * 1j)\n\n ## set normalized polar angle (0-1), and make nan irrelevant vertices\n hsv_angle[:, 0] = np.nan \n hsv_angle[:, 0][rsq > rsq_thresh] = ((polar_angle + np.pi) / (np.pi * 2.0))[rsq > rsq_thresh]\n\n ## normalize angle threshold for overepresentation\n angle_thresh_norm = (angle_thresh + np.pi) / (np.pi * 2.0)\n\n ## get mid vertex index (diving hemispheres)\n left_index = cortex.db.get_surfinfo(pysub).left.shape[0] \n\n ## set angles within threh interval to 0\n ind_thresh = np.where((hsv_angle[:left_index, 0] > angle_thresh_norm) | (hsv_angle[:left_index, 0] < 1-angle_thresh_norm))[0]\n hsv_angle[:left_index, 0][ind_thresh] = 0\n\n ## now take angles from RH (thus LVF) \n #### ATENÇÃO -> minus sign to flip angles vertically (then order of colors same for both hemispheres) ###\n # also normalize it\n hsv_angle[left_index:, 0] = ((np.angle(-1*xx + yy * 1j) + np.pi) / (np.pi * 2.0))[left_index:]\n\n # set angles within threh interval to 0\n ind_thresh = np.where((hsv_angle[left_index:, 0] > angle_thresh_norm) | (hsv_angle[left_index:, 0] < 1-angle_thresh_norm))[0]\n hsv_angle[left_index:, 0][ind_thresh] = 0\n\n ## make final RGB array\n rgb_angle = np.ones((len(rsq), 3))\n rgb_angle[:] = np.nan\n\n rgb_angle[rsq > rsq_thresh] = colors.hsv_to_rgb(hsv_angle[rsq > rsq_thresh])\n\n return rgb_angle","def pair_is_consistent(graph, u, v):\n relations = get_all_relations(graph, u, v)\n\n if 1 != len(relations):\n return False\n\n return list(relations)[0]","def _upward_triangle_indicies(height=3):\n return [(height-r,c) for r in range(height) for c in range(-abs(r),abs(r)+1)]","def get_neighbors(size_i, size_j, ij):\n i,j = ij\n neighbors = set()\n if i>0:\n neighbors.add((i-1, j))\n if j>0:\n neighbors.add((i, j-1))\n if i<size_i-1:\n neighbors.add((i+1, j))\n if j<size_j-1:\n neighbors.add((i, j+1))\n return neighbors","def get_kequiv_by_face_quad(self, conj_faces):\n ADJs=np.array([self.mb.get_adjacencies(face, 3) for face in self.all_faces])\n\n centroids=np.array([self.mtu.get_average_position([v]) for v in self.all_volumes])\n\n ADJsv=np.array([self.mb.get_adjacencies(face, 0) for face in self.all_faces])\n\n ks=self.mb.tag_get_data(self.perm_tag, self.all_volumes)\n #vol_to_pos=dict(zip(M1.all_volumes,range(len(M1.all_volumes))))\n vol_to_pos=dict(zip(self.all_volumes,range(len(self.all_volumes))))\n cont=0\n K_eq=[]\n for f in self.all_faces:\n adjs=ADJs[cont]\n adjsv=ADJsv[cont]\n cont+=1\n if len(adjs)==2:\n v1=adjs[0]\n v2=adjs[1]\n k1 = ks[vol_to_pos[v1]].reshape([3, 3])\n k2 = ks[vol_to_pos[v2]].reshape([3, 3])\n centroid1 = centroids[vol_to_pos[v1]]\n centroid2 = centroids[vol_to_pos[v2]]\n direction = centroid2 - centroid1\n norm=np.linalg.norm(direction)\n uni = np.absolute(direction/norm)\n k1 = np.dot(np.dot(k1,uni), uni)\n k2 = np.dot(np.dot(k2,uni), uni)\n k_harm = (2*k1*k2)/(k1+k2)\n\n vertex_cent=np.array([self.mb.get_coords([np.uint64(a)]) for a in adjsv])\n dx=max(vertex_cent[:,0])-min(vertex_cent[:,0])\n dy=max(vertex_cent[:,1])-min(vertex_cent[:,1])\n dz=max(vertex_cent[:,2])-min(vertex_cent[:,2])\n if dx<0.001:\n dx=1\n if dy<0.001:\n dy=1\n if dz<0.001:\n dz=1\n area=dx*dy*dz\n #area = self.mb.tag_get_data(self.area_tag, face, flat=True)[0]\n #s_gr = self.gama*keq*(centroid2[2]-centroid1[2])\n keq = k_harm*area/(self.mi*norm)\n\n K_eq.append(keq)\n else:\n K_eq.append(0.0)\n self.mb.tag_set_data(self.k_eq_tag, self.all_faces, K_eq)","def delaunay_triangle_calculation(rect, points):\n # creating the subdiv class\n subdiv = cv2.Subdiv2D(rect)\n\n # Insert points into subdiv class\n for p in points:\n subdiv.insert(p)\n\n triangle_list = subdiv.getTriangleList()\n\n delaunay_tri = []\n pt = []\n\n for t in triangle_list:\n pt.append((t[0], t[1]))\n pt1 = (t[0], t[1])\n\n pt.append((t[2], t[3]))\n pt2 = (t[2], t[3])\n\n pt.append((t[4], t[5]))\n pt3 = (t[4], t[5])\n\n if in_rectangle(rect, pt1) and in_rectangle(rect, pt2) and in_rectangle(rect, pt3):\n ind = []\n # Get face-points (from 68 face detector) by coordinates\n for j in range(0, 3):\n for k in range(0, len(points)):\n if abs(pt[j][0] - points[k][0]) < 1.0 and abs(pt[j][1] - points[k][1]) < 1.0:\n ind.append(k)\n\n if len(ind) == 3:\n delaunay_tri.append((ind[0], ind[1], ind[2]))\n\n pt = []\n\n return delaunay_tri","def isOnInteriorSide(self, v):\n n = self.normalVect()\n return n.dotProduct(vector(self.vertices[0]) - vector(v)) > 0"],"string":"[\n \"def solve_homography(u, v):\\r\\n N = u.shape[0]\\r\\n H = None\\r\\n\\r\\n if v.shape[0] is not N:\\r\\n print('u and v should have the same size')\\r\\n return None\\r\\n if N < 4:\\r\\n print('At least 4 points should be given')\\r\\n\\r\\n # TODO: 1.forming A\\r\\n A = np.zeros((2*N, 8))\\r\\n for i in range(N):\\r\\n A[2*i, :] = np.array([u[i, 0], u[i, 1], 1, 0, 0, 0, -u[i, 0]*v[i,0], -u[i, 1]*v[i, 0]])\\r\\n A[2*i+1, :] = np.array([0, 0, 0, u[i, 0], u[i, 1], 1, -u[i, 0]*v[i, 1], -u[i, 1]*v[i, 1]])\\r\\n\\r\\n # TODO: 2.solve H with A\\r\\n b = v.reshape(-1)\\r\\n H, res, _, _ = np.linalg.lstsq(A, b, rcond=None)\\r\\n H = np.concatenate((H, np.array([1])))\\r\\n H = H.reshape(3,3)\\r\\n\\r\\n return H\",\n \"def edge_on_silhouette(self, vertices_2d: np.ndarray) -> np.ndarray:\\n assert vertices_2d.ndim == 2\\n assert vertices_2d.shape[1] == 2\\n triangles = vertices_2d[self.faces, :]\\n u = triangles[:, 1, :] - triangles[:, 0, :]\\n v = triangles[:, 2, :] - triangles[:, 0, :]\\n face_visible = np.cross(u, v) > 0 if self.clockwise else np.cross(u, v) < 0\\n edge_bool = (self.edges_faces_ones * face_visible) == 1\\n return edge_bool[self.faces_edges]\",\n \"def trimesh_collapse_edge(self, u, v, t=0.5, allow_boundary=False, fixed=None):\\r\\n if t < 0.0:\\r\\n raise ValueError('Parameter t should be greater than or equal to 0.')\\r\\n if t > 1.0:\\r\\n raise ValueError('Parameter t should be smaller than or equal to 1.')\\r\\n\\r\\n # check collapse conditions\\r\\n if not is_collapse_legal(self, u, v, allow_boundary=allow_boundary):\\r\\n return False\\r\\n\\r\\n # compare to fixed\\r\\n fixed = fixed or []\\r\\n if v in fixed or u in fixed:\\r\\n return False\\r\\n\\r\\n # move U\\r\\n x, y, z = self.edge_point(u, v, t)\\r\\n\\r\\n self.vertex[u]['x'] = x\\r\\n self.vertex[u]['y'] = y\\r\\n self.vertex[u]['z'] = z\\r\\n\\r\\n # UV face\\r\\n fkey = self.halfedge[u][v]\\r\\n\\r\\n if fkey is None:\\r\\n del self.halfedge[u][v]\\r\\n else:\\r\\n face = self.face[fkey]\\r\\n\\r\\n o = face[face.index(u) - 1]\\r\\n\\r\\n del self.halfedge[u][v]\\r\\n del self.halfedge[v][o]\\r\\n del self.halfedge[o][u]\\r\\n del self.face[fkey]\\r\\n\\r\\n if len(self.halfedge[o]) < 2:\\r\\n del self.halfedge[o]\\r\\n del self.vertex[o]\\r\\n del self.halfedge[u][o]\\r\\n\\r\\n # VU face\\r\\n fkey = self.halfedge[v][u]\\r\\n\\r\\n if fkey is None:\\r\\n del self.halfedge[v][u]\\r\\n else:\\r\\n face = self.face[fkey]\\r\\n\\r\\n o = face[face.index(v) - 1]\\r\\n\\r\\n del self.halfedge[v][u]\\r\\n del self.halfedge[u][o]\\r\\n del self.halfedge[o][v]\\r\\n del self.face[fkey]\\r\\n\\r\\n if len(self.halfedge[o]) < 2:\\r\\n del self.halfedge[o]\\r\\n del self.vertex[o]\\r\\n del self.halfedge[v][o]\\r\\n\\r\\n # neighborhood of V\\r\\n for nbr, fkey in list(self.halfedge[v].items()):\\r\\n\\r\\n if fkey is None:\\r\\n self.halfedge[u][nbr] = None\\r\\n del self.halfedge[v][nbr]\\r\\n else:\\r\\n # a > v > nbr => a > u > nbr\\r\\n face = self.face[fkey]\\r\\n a = face[face.index(v) - 1]\\r\\n self.face[fkey] = [a, u, nbr]\\r\\n\\r\\n if v in self.halfedge[a]:\\r\\n del self.halfedge[a][v]\\r\\n del self.halfedge[v][nbr]\\r\\n\\r\\n self.halfedge[a][u] = fkey\\r\\n self.halfedge[u][nbr] = fkey\\r\\n self.halfedge[nbr][a] = fkey\\r\\n\\r\\n # nbr > v > d => nbr > u > d\\r\\n if v in self.halfedge[nbr]:\\r\\n self.halfedge[nbr][u] = self.halfedge[nbr][v]\\r\\n del self.halfedge[nbr][v]\\r\\n\\r\\n # delete V\\r\\n del self.halfedge[v]\\r\\n del self.vertex[v]\\r\\n\\r\\n # clean up\\r\\n for nu in self.halfedge[u]:\\r\\n for nbr in self.halfedge[nu]:\\r\\n if nbr == v:\\r\\n self.halfedge[nu][u] = self.halfedge[nu][v]\\r\\n del self.halfedge[nu][v]\\r\\n\\r\\n return True\",\n \"def get_faces(ulist, vlist):\\n width = len(ulist)\\n faces = []\\n for i in range(len(ulist) - 1):\\n for j in range(len(vlist) - 1):\\n topleft = j * width + i\\n topright = topleft + 1\\n bottomleft = ((j + 1) * width) + i\\n bottomright = bottomleft + 1\\n one = [topleft, topright, bottomleft]\\n two = [bottomleft, topright, bottomright]\\n faces.append(one)\\n faces.append(two)\\n\\n return faces\",\n \"def close_up_hull(hull, edge_count, used_pivots):\\n face_added = close_up(edge_count, used_pivots)\\n if not face_added:\\n face = list(hull[0])\\n # det(A) = -det (B) if two cols swap (odd and even)\\n face[-2], face[-1] = face[-1], face[-2]\\n face_added = [tuple(face)]\\n for face in face_added:\\n hull.append(face)\\n\\n return len(face_added)\",\n \"def findFours(self):\\n\\n for i in range(6):\\n for j in range(7):\\n if self.board[i][j] != ' ':\\n # check if a vertical four-in-a-row starts at (i, j)\\n if self.verticalCheck(i, j):\\n self.highlightFour(i, j, 'vertical')\\n \\n # check if a horizontal four-in-a-row starts at (i, j)\\n if self.horizontalCheck(i, j):\\n self.highlightFour(i, j, 'horizontal')\\n \\n # check if a diagonal (either way) four-in-a-row starts at (i, j)\\n # also, get the slope of the four if there is one\\n diag_fours, slope = self.diagonalCheck(i, j)\\n if diag_fours:\\n self.highlightFour(i, j, 'diagonal', slope)\",\n \"def H(self, u, v):\\n return (self.E(u, v) * self.N(u, v)\\n - 2 * self.F(u, v) * self.M(u, v)\\n + self.G(u, v) * self.L(u, v)) / \\\\\\n (2 * (self.E(u, v) * self.G(u, v) - np.square(self.F(u, v))))\",\n \"def Neighbourgs(abcd, h):\\n\\n Nelem = len(abcd)\\n\\n a = abcd[h][0]\\n b = abcd[h][1]\\n c = abcd[h][2]\\n d = abcd[h][3]\\n\\n el1, el2, el3, el4 = 0, 0, 0, 0\\n\\n N = 0\\n\\n for j in range(0, Nelem - 1):\\n\\n if N == 4:\\n break\\n\\n if a in abcd[j, :] and b in abcd[j, :] and j != h:\\n N += 1\\n el1 = j + 1\\n\\n if b in abcd[j, :] and c in abcd[j, :] and j != h:\\n N += 1\\n el2 = j + 1\\n\\n if c in abcd[j, :] and d in abcd[j, :] and j != h:\\n N += 1\\n el3 = j + 1\\n\\n if d in abcd[j, :] and a in abcd[j, :] and j != h:\\n N += 1\\n el4 = j + 1\\n\\n return [el1, el2, el3, el4]\",\n \"def _get_single_direction_neighbors(object_idx, ui_v_dist, ui_h_dist):\\n neighbor_dict = {}\\n vertical_dist = ui_v_dist[object_idx]\\n horizontal_dist = ui_h_dist[object_idx]\\n bottom_neighbors = np.array([\\n idx for idx in range(len(vertical_dist)) if vertical_dist[idx] > 0 and\\n abs(horizontal_dist[idx]) < config.NORM_HORIZONTAL_NEIGHBOR_MARGIN\\n ])\\n top_neighbors = np.array([\\n idx for idx in range(len(vertical_dist)) if vertical_dist[idx] < 0 and\\n abs(horizontal_dist[idx]) < config.NORM_HORIZONTAL_NEIGHBOR_MARGIN\\n ])\\n right_neighbors = np.array([\\n idx for idx in range(len(horizontal_dist)) if horizontal_dist[idx] > 0 and\\n abs(vertical_dist[idx]) < config.NORM_VERTICAL_NEIGHBOR_MARGIN\\n ])\\n left_neighbors = np.array([\\n idx for idx in range(len(horizontal_dist)) if horizontal_dist[idx] < 0 and\\n abs(vertical_dist[idx]) < config.NORM_VERTICAL_NEIGHBOR_MARGIN\\n ])\\n\\n if bottom_neighbors.size:\\n neighbor_dict[NeighborContextDesc.TOP] = bottom_neighbors[np.argmin(\\n vertical_dist[bottom_neighbors])]\\n if top_neighbors.size:\\n neighbor_dict[NeighborContextDesc.BOTTOM] = top_neighbors[np.argmax(\\n vertical_dist[top_neighbors])]\\n if right_neighbors.size:\\n neighbor_dict[NeighborContextDesc.LEFT] = right_neighbors[np.argmin(\\n horizontal_dist[right_neighbors])]\\n if left_neighbors.size:\\n neighbor_dict[NeighborContextDesc.RIGHT] = left_neighbors[np.argmax(\\n horizontal_dist[left_neighbors])]\\n\\n return neighbor_dict\",\n \"def faceIntersection(self, face):\\n # Test wether both ends of the edge are in the same half space\\n # (relative to <face>'s plane).\\n normal = face.normalVect()\\n v0 = vector(face.vertices[0])\\n vp = vector(self.pvt)\\n vn = vector(self.nvt)\\n p = normal.dotProduct(vp - v0) * normal.dotProduct(vn - v0)\\n if p > 0:\\n return False\\n elif abs(p) <= COMPARISON_EPSILON or abs(normal.dotProduct(vp - vn) / (normal.norm() * (vp - vn).norm())) <= COMPARISON_EPSILON:\\n # print('ah')\\n return False\\n else:\\n interVect = vn + (normal.dotProduct(v0 - vn) /\\n normal.dotProduct(vp - vn)) * (vp - vn)\\n lastCross = ((vector(face.vertices[-1]) - interVect) *\\n (vector(face.vertices[0]) - interVect))\\n for i in range(len(face.vertices)):\\n cross = ((vector(face.vertices[i]) - interVect) *\\n (vector(face.vertices[(i + 1) % len(face.vertices)]) -\\n interVect))\\n p = cross.dotProduct(lastCross)\\n if p < 0:\\n return False\\n elif p == 0 and cross.norm() != 0:\\n if cross.norm() > COMPARISON_EPSILON:\\n warnings.warn(\\\"Cross product's norm is very low\\\")\\n lastCross = cross\\n return interVect.coords()\",\n \"def inside(i,j,im,h=H): #X\\n return i-h >=0 and j-h >=0 and i+h+1<=im.shape[0] and j+h+1<=im.shape[1]\",\n \"def detector_outline( bottom_vec3d_list, top_vec3d_list ):\\n # hardcoded angular offset for hexagon\\n phi0 = -20.0 * I3Units.degree \\n\\n # hardcoded threshold for an edge\\n cos_angle_threshold = math.cos( 7.0 * I3Units.degree ) \\n\\n bottom = Vec3dList()\\n top = Vec3dList()\\n\\n string_coords = []\\n for b, t in zip( bottom_vec3d_list, top_vec3d_list ):\\n if t[2] < 450.0 * I3Units.meter: # ignore deep-core\\n continue\\n string_coords.append(( math.atan2(t[1], t[0]),\\n t[0], t[1], b[2], t[2] ))\\n\\n # border detection:\\n # check if there is a point in each angular segment of hexagon\\n border = []\\n for i, cur in enumerate( string_coords ):\\n counts = [False, False, False, False, False , False]\\n for j, other in enumerate( string_coords ):\\n if i == j: continue\\n dx = cur[1] - other[1]\\n dy = cur[2] - other[2]\\n phi = int((math.atan2( dy, dx ) - phi0) / I3Units.degree)\\n if phi < 0:\\n phi += 360\\n counts[phi // 60] = True\\n neighbor_count = sum( counts )\\n # border points don't have a full hexagon of neighbors\\n if neighbor_count < 6:\\n border.append( cur )\\n\\n border.sort() # put in circular order\\n\\n # edge detection:\\n # check if differential vectors of three consecutive points have an angle\\n for i in xrange( len(border) ):\\n ax = border[i - 1][1] - border[i - 2][1]\\n ay = border[i - 1][2] - border[i - 2][2]\\n bx = border[i][1] - border[i - 1][1]\\n by = border[i][2] - border[i - 1][2]\\n anorm = (ax ** 2 + ay ** 2) ** 0.5\\n bnorm = (bx ** 2 + by ** 2) ** 0.5\\n cos_angle = (bx * ax + by * ay) / (anorm * bnorm)\\n if cos_angle < cos_angle_threshold:\\n cur = border[i - 1]\\n bottom.append( vec3d(cur[1], cur[2], cur[3]) )\\n top.append( vec3d(cur[1], cur[2], cur[4]) )\\n\\n return bottom, top\",\n \"def neighbours2((u,v)):\\r\\n\\r\\n return ((u-1, v+1), (u,v+1), (u+1,v+1), \\r\\n (u-1,v), (u+1,v),\\r\\n (u-1,v-1), (u,v-1), (u+1,v-1))\",\n \"def split_face_mesh(mesh, fkey, u, v):\\n if u not in mesh.face[fkey] or v not in mesh.face[fkey]:\\n raise ValueError('The split vertices do not belong to the split face.')\\n if mesh.face[fkey][u] == v:\\n raise ValueError('The split vertices are neighbours.')\\n d = mesh.face[fkey][u]\\n f = [u]\\n while True:\\n f.append(d)\\n if d == v:\\n break\\n d = mesh.face[fkey][d]\\n d = mesh.face[fkey][v]\\n g = [v]\\n while True:\\n g.append(d)\\n if d == u:\\n break\\n d = mesh.face[fkey][d]\\n f = mesh.add_face(f)\\n g = mesh.add_face(g)\\n del mesh.face[fkey]\\n return f, g\",\n \"def bipartite_vertex_cover(bigraph, algo=\\\"Hopcroft-Karp\\\"):\\n if algo == \\\"Hopcroft-Karp\\\":\\n coord = [(irow,icol) for irow,cols in enumerate(bigraph) for icol in cols]\\n coord = np.array(coord)\\n graph = csr_matrix((np.ones(coord.shape[0]),(coord[:,0],coord[:,1])))\\n matchV = maximum_bipartite_matching(graph, perm_type='row')\\n matchV = [None if x==-1 else x for x in matchV]\\n nU, nV = graph.shape\\n assert len(matchV) == nV\\n elif algo == \\\"Hungarian\\\":\\n matchV = max_bipartite_matching2(bigraph)\\n nU, nV = len(bigraph), len(matchV)\\n else:\\n assert False\\n\\n matchU = [None] * nU\\n \\n for v in range(nV): # -- build the mapping from U to V\\n if matchV[v] is not None:\\n matchU[matchV[v]] = v\\n \\n def old_konig():\\n visitU = [False] * nU # -- build max alternating forest\\n visitV = [False] * nV\\n for u in range(nU):\\n if matchU[u] is None: # -- starting with free vertices in U\\n _alternate(u, bigraph, visitU, visitV, matchV)\\n inverse = [not b for b in visitU]\\n return (inverse, visitV)\\n \\n def new_konig():\\n # solve the limitation of huge number of recursive calls\\n visitU = [False] * nU # -- build max alternating forest\\n visitV = [False] * nV\\n wait_u = set(range(nU)) - set(matchV) \\n while len(wait_u) > 0:\\n u = wait_u.pop()\\n visitU[u] = True\\n for v in bigraph[u]:\\n if not visitV[v]:\\n visitV[v] = True\\n assert matchV[v] is not None # otherwise match is not maximum\\n assert matchV[v] not in wait_u\\n wait_u.add(matchV[v])\\n inverse = [not b for b in visitU]\\n return (inverse, visitV)\\n \\n #res_old = old_konig()\\n res_new = new_konig()\\n #assert res_old == res_new\\n return res_new\",\n \"def halfedgeConstruction(self,facetList):\\n\\t\\tedges = []\\n\\t\\t# the temporary map of the halfedges\\n\\t\\tedgeMap = {}\\n\\t\\tcount = 0\\n\\t\\tfor i in range(0,len(facetList)):\\n\\t\\t\\t# \\n\\t\\t\\tfor j in range(0,len(facetList[i])):\\n\\t\\t\\t\\t# j is the index of the current vertex\\n\\t\\t\\t\\tkey = (facetList[i][j-1],facetList[i][j])\\n\\t\\t\\t\\tedges.append(key)\\n\\t\\t\\t\\tedgeMap[key] = count\\n\\t\\t\\t\\tcount += 1\\n\\t\\t\\t\\t# initialze the current halfedge\\n\\t\\t\\t\\the = Halfedge()\\n\\t\\t\\t\\t# assume that the mesh has been well oriented\\n\\t\\t\\t\\the.setVertex(self._mesh._vertices[facetList[i][j]])\\n\\t\\t\\t\\tself._mesh._halfedges.append(he)\\n\\t\\t# construct the opposite halfedge\\n\\t\\tfor key in edgeMap:\\n\\t\\t\\ti = edgeMap[key]\\n\\t\\t\\tif self._mesh._halfedges[i].opposite() is None:\\n\\t\\t\\t\\t# the opposite has not been set\\n\\t\\t\\t\\toppo = key[1],key[0]\\n\\t\\t\\t\\tif oppo in edgeMap:\\n\\t\\t\\t\\t\\t# interior edge\\n\\t\\t\\t\\t\\tj = edgeMap[oppo]\\n\\t\\t\\t\\t\\tself._mesh._halfedges[i].setOpposite(self._mesh._halfedges[j])\\n\\t\\t\\t\\t\\tself._mesh._halfedges[j].setOpposite(self._mesh._halfedges[i])\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t# border edge\\n\\t\\t\\t\\t\\t# construct a border halfedge\\n\\t\\t\\t\\t\\the = Halfedge()\\n\\t\\t\\t\\t\\t# the edge is border edge\\n\\t\\t\\t\\t\\the._isBorder = True\\n\\t\\t\\t\\t\\tself._mesh._halfedges[i].setOpposite(he)\\n\\t\\t\\t\\t\\the.setOpposite(self._mesh._halfedges[i])\\n\\t\\t\\t\\t\\t# append the halfedge\\n\\t\\t\\t\\t\\tself._mesh._halfedges.append(he)\\n\\t\\t\\t\\t\\tcount += 1\\n\\t\\t# set next and prev halfedge\\n\\t\\t# the interior edges\\n\\t\\tcount = 0\\n\\t\\tfor i in range(0,len(facetList)):\\n\\t\\t\\tfor j in range(0,len(facetList[i])):\\n\\t\\t\\t\\tif j == len(facetList[i])-1:\\n\\t\\t\\t\\t\\t# the last edge: the next edge is the beggining edge\\n\\t\\t\\t\\t\\tself._mesh._halfedges[count+j].setNext(self._mesh._halfedges[count])\\n\\t\\t\\t\\t\\tself._mesh._halfedges[count+j].setPrev(self._mesh._halfedges[count+j-1])\\n\\t\\t\\t\\telif j == 0:\\n\\t\\t\\t\\t\\t# the beginning edge: the prev edge is the last one\\n\\t\\t\\t\\t\\tself._mesh._halfedges[count+j].setNext(self._mesh._halfedges[count+j+1])\\n\\t\\t\\t\\t\\tself._mesh._halfedges[count+j].setPrev(self._mesh._halfedges[count+len(facetList[i])-1])\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t# the interior edge\\n\\t\\t\\t\\t\\tself._mesh._halfedges[count+j].setNext(self._mesh._halfedges[count+j+1])\\n\\t\\t\\t\\t\\tself._mesh._halfedges[count+j].setPrev(self._mesh._halfedges[count+j-1])\\n\\t\\t\\t# the count\\n\\t\\t\\tcount += len(facetList[i])\\n\\t\\t# the border edges\\n\\t\\tfor i in range(count,len(self._mesh._halfedges)):\\n\\t\\t\\the = self._mesh._halfedges[i]\\n\\t\\t\\t# first set the vertex\\n\\t\\t\\the.setVertex(he.opposite().prev().vertex())\\n\\t\\t\\t# two kinds of situation\\n\\t\\t\\tif he.opposite().prev().opposite().isBorder():\\n\\t\\t\\t\\the.setNext(he.opposite().prev().opposite())\\n\\t\\t\\telse:\\n\\t\\t\\t\\the.setNext(he.opposite().prev().opposite().prev().opposite())\\n\\t\\t\\tif he.opposite().next().opposite().isBorder():\\n\\t\\t\\t\\the.setPrev(he.opposite().next().opposite())\\n\\t\\t\\telse:\\n\\t\\t\\t\\the.setPrev(he.opposite().next().opposite().next().opposite())\",\n \"def get_k2_boundary(tri, v_neighbours):\\n three = np.array([0, 1, 2])\\n nv = tri.shape[0]\\n k2s = np.empty((nv, 3), dtype=np.int32)\\n for i in range(nv):\\n for k in range(3):\\n neighbour = v_neighbours[i, k]\\n if neighbour == -1:\\n k2s[i,k] = -1\\n else:\\n k2 = ((v_neighbours[neighbour] == i) * three).sum()\\n k2s[i, k] = k2\\n return k2s\",\n \"def neighbours((u,v)):\\r\\n return ((u,v+1), (u+1,v), (u,v-1), (u-1,v))\",\n \"def query_rect(triu_reader, i0, i1, j0, j1):\\n\\n # symmetric query\\n if (i0, i1) == (j0, j1):\\n i, j, v = triu_reader(i0, i1, i0, i1)\\n nodiag = i != j\\n i, j, v = np.r_[i, j[nodiag]], np.r_[j, i[nodiag]], np.r_[v, v[nodiag]]\\n\\n # asymmetric query\\n else:\\n transpose = False\\n if j0 < i0 or (i0 == j0 and i1 < j1):\\n i0, i1, j0, j1 = j0, j1, i0, i1\\n transpose = True\\n\\n # non-overlapping\\n if _comes_before(i0, i1, j0, j1, strict=True):\\n i, j, v = triu_reader(i0, i1, j0, j1)\\n\\n # partially overlapping\\n elif _comes_before(i0, i1, j0, j1):\\n ix, jx, vx = triu_reader(i0, j0, j0, i1)\\n iy, jy, vy = triu_reader(j0, i1, j0, i1)\\n iz, jz, vz = triu_reader(i0, i1, i1, j1)\\n nodiag = iy != jy\\n iy, jy, vy = np.r_[iy, jy[nodiag]], np.r_[jy, iy[nodiag]], np.r_[vy, vy[nodiag]]\\n i, j, v = np.r_[ix, iy, iz], np.r_[jx, jy, jz], np.r_[vx, vy, vz]\\n\\n # nested\\n elif _contains(i0, i1, j0, j1):\\n ix, jx, vx = triu_reader(i0, j0, j0, j1)\\n iy, jy, vy = triu_reader(j0, j1, j0, j1)\\n jz, iz, vz = triu_reader(j0, j1, j1, i1)\\n nodiag = iy != jy\\n iy, jy, vy = np.r_[iy, jy[nodiag]], np.r_[jy, iy[nodiag]], np.r_[vy, vy[nodiag]]\\n i, j, v = np.r_[ix, iy, iz], np.r_[jx, jy, jz], np.r_[vx, vy, vz]\\n\\n else:\\n raise IndexError(\\\"This shouldn't happen\\\")\\n\\n if transpose:\\n i, j = j, i\\n\\n return i, j, v\",\n \"def _edge(u, v):\\n return (u, v) if u < v else (v, u)\",\n \"def neighbour(t, i, j):\\n v0 = t[i][(j + 1) % 3]\\n v1 = t[i][(j + 2) % 3]\\n\\n for k in range(len(t)):\\n if k != i:\\n if v0 in t[k] and v1 in t[k]:\\n return k\\n\\n return None\",\n \"def bernstein_surface(i, j, nU, nV, u, v):\\n return np.outer(comb(nU, i) * (u ** (nU - i)) * ((1 - u) ** i),\\n comb(nV, j) * (v ** (nV - j)) * ((1 - v) ** j))\",\n \"def approximate_hypercube_iou(hs: List[Tuple[float, List[float]]], new_hs: Tuple[float, List[float]], m_rel: int) \\\\\\n -> List[float]:\\n\\n # TODO: umschreiben so dass new_hs die random Punkte enthält -> die müssen dadurch nur einmal erzeugt werden und\\n # dann wird für jeden Punkt getestet in welchen hs er noch liegt. -> dadurch Punkte nur einmal erzeugen und\\n # Volumen nur einmal berechnen\\n\\n if hs is None or len(hs) == 0 or not hs:\\n return [-1]\\n\\n number_rand_points = 10000 * m_rel\\n\\n inside_ref = [0] * len(hs)\\n\\n new_r, new_c = new_hs\\n new_v = calc_hypercube_volume(new_r, m_rel)\\n\\n for i, (r, c) in enumerate(hs):\\n j = 0\\n while j < number_rand_points:\\n max_x = np.array(c) + r\\n min_x = np.array(c) - r\\n p = np.random.rand(m_rel) * (max_x - min_x) + min_x\\n p_inside_hc = is_point_inside_hypercube(p, c, r)\\n if p_inside_hc:\\n j += 1\\n if p_inside_hc and is_point_inside_hypercube(p, new_c, new_r):\\n inside_ref[i] += 1\\n\\n result = []\\n\\n for (r, c), k in zip(hs, inside_ref):\\n v = calc_hypercube_volume(r, m_rel)\\n inter = (k / number_rand_points) * v\\n union = v + new_v - inter\\n result.append(inter / union)\\n\\n return result\",\n \"def mesh_collapse_edge(self, u, v, t=0.5, allow_boundary=False, fixed=None):\\r\\n if t < 0.0:\\r\\n raise ValueError('Parameter t should be greater than or equal to 0.')\\r\\n if t > 1.0:\\r\\n raise ValueError('Parameter t should be smaller than or equal to 1.')\\r\\n\\r\\n # # collapsing of boundary vertices is currently not supported\\r\\n # # change this to `and` to support collapsing to or from the boundary\\r\\n # if self.is_vertex_on_boundary(u) or self.is_vertex_on_boundary(v):\\r\\n # return\\r\\n\\r\\n # # check for contained faces\\r\\n # for nbr in self.halfedge[u]:\\r\\n # if nbr in self.halfedge[v]:\\r\\n # # check if U > V > NBR is a face\\r\\n # if (self.halfedge[u][v] != self.halfedge[v][nbr] or self.halfedge[u][v] != self.halfedge[nbr][u]):\\r\\n # # check if V > U > NBR is a face\\r\\n # if (self.halfedge[v][u] != self.halfedge[u][nbr] or self.halfedge[v][u] != self.halfedge[nbr][v]):\\r\\n # return\\r\\n # for nbr in self.halfedge[v]:\\r\\n # if nbr in self.halfedge[u]:\\r\\n # # check if U > V > NBR is a face\\r\\n # if (self.halfedge[u][v] != self.halfedge[v][nbr] or self.halfedge[u][v] != self.halfedge[nbr][u]):\\r\\n # # check if V > U > NBR is a face\\r\\n # if (self.halfedge[v][u] != self.halfedge[u][nbr] or self.halfedge[v][u] != self.halfedge[nbr][v]):\\r\\n # return\\r\\n\\r\\n # check collapse conditions\\r\\n if not is_collapse_legal(self, u, v, allow_boundary=allow_boundary):\\r\\n return False\\r\\n\\r\\n # compare to fixed\\r\\n fixed = fixed or []\\r\\n if v in fixed or u in fixed:\\r\\n return False\\r\\n\\r\\n # move U\\r\\n x, y, z = self.edge_point(u, v, t)\\r\\n self.vertex[u]['x'] = x\\r\\n self.vertex[u]['y'] = y\\r\\n self.vertex[u]['z'] = z\\r\\n\\r\\n # UV face\\r\\n fkey = self.halfedge[u][v]\\r\\n\\r\\n if fkey is None:\\r\\n del self.halfedge[u][v]\\r\\n\\r\\n else:\\r\\n face = self.face_vertices(fkey)\\r\\n f = len(face)\\r\\n\\r\\n # switch between UV face sizes\\r\\n # note: in a triself this is not necessary!\\r\\n if f < 3:\\r\\n raise Exception(\\\"Invalid self face: {}\\\".format(fkey))\\r\\n if f == 3:\\r\\n # delete UV\\r\\n o = face[face.index(u) - 1]\\r\\n del self.halfedge[u][v]\\r\\n del self.halfedge[v][o]\\r\\n del self.halfedge[o][u]\\r\\n del self.face[fkey]\\r\\n else:\\r\\n # u > v > d => u > d\\r\\n d = self.face_vertex_descendant(fkey, v)\\r\\n face.remove(v)\\r\\n del self.halfedge[u][v]\\r\\n del self.halfedge[v][d]\\r\\n self.halfedge[u][d] = fkey\\r\\n\\r\\n # VU face\\r\\n fkey = self.halfedge[v][u]\\r\\n\\r\\n if fkey is None:\\r\\n del self.halfedge[v][u]\\r\\n\\r\\n else:\\r\\n face = self.face_vertices(fkey)\\r\\n f = len(face)\\r\\n\\r\\n # switch between VU face sizes\\r\\n # note: in a triself this is not necessary!\\r\\n if f < 3:\\r\\n raise Exception(\\\"Invalid mesh face: {}\\\".format(fkey))\\r\\n if f == 3:\\r\\n # delete UV\\r\\n o = face[face.index(v) - 1]\\r\\n del self.halfedge[v][u] # the collapsing halfedge\\r\\n del self.halfedge[u][o]\\r\\n del self.halfedge[o][v]\\r\\n del self.face[fkey]\\r\\n else:\\r\\n # a > v > u => a > u\\r\\n a = self.face_vertex_ancestor(fkey, v)\\r\\n face.remove(v)\\r\\n del self.halfedge[a][v]\\r\\n del self.halfedge[v][u]\\r\\n self.halfedge[a][u] = fkey\\r\\n\\r\\n # V neighbors and halfedges coming into V\\r\\n for nbr, fkey in list(self.halfedge[v].items()):\\r\\n\\r\\n if fkey is None:\\r\\n self.halfedge[u][nbr] = None\\r\\n del self.halfedge[v][nbr]\\r\\n else:\\r\\n # a > v > nbr => a > u > nbr\\r\\n face = self.face[fkey]\\r\\n a = self.face_vertex_ancestor(fkey, v)\\r\\n face[face.index(v)] = u\\r\\n\\r\\n if v in self.halfedge[a]:\\r\\n del self.halfedge[a][v]\\r\\n del self.halfedge[v][nbr]\\r\\n self.halfedge[a][u] = fkey\\r\\n self.halfedge[u][nbr] = fkey\\r\\n\\r\\n # only update what will not be updated in the previous part\\r\\n # verify what this is exactly\\r\\n # nbr > v > d => nbr > u > d\\r\\n if v in self.halfedge[nbr]:\\r\\n fkey = self.halfedge[nbr][v]\\r\\n del self.halfedge[nbr][v]\\r\\n self.halfedge[nbr][u] = fkey\\r\\n\\r\\n # delete V\\r\\n del self.halfedge[v]\\r\\n del self.vertex[v]\",\n \"def corners((u,v)):\\r\\n return ((u+1,v+1), (u+1,v), (u,v), (u,v+1))\",\n \"def inside(self, uv):\\n result = self._trimmed.Perform(gp_Pnt2d(uv[0], uv[1]))\\n return result == TopAbs_IN\",\n \"def is_edge(graph, u, v):\\n return graph.matrix[u][v]\",\n \"def cw_face_edges(self,face):\\n\\n l0 = self.region_link[face]\\n if face == self.left_region[l0]:\\n l0 = (l0[1], l0[0])\\n l = l0\\n\\n traversing = True\\n edges = []\\n while traversing:\\n edges.append(l)\\n r = self.right_region[l]\\n if r == face:\\n l = self.succ_right[l]\\n else:\\n l = self.succ_left[l]\\n if l == l0:\\n traversing = False\\n return edges\",\n \"def householder_transformation(v):\\n size_of_v = v.shape[1]\\n e1 = np.zeros_like(v)\\n e1[0, 0] = 1\\n vector = get_norm(v) * e1\\n if v[0, 0] < 0:\\n vector = - vector\\n u = (v + vector).astype(np.float32)\\n norm2 = get_norm(u)\\n u = u / norm2\\n H = np.identity(size_of_v) - ((2 * np.matmul(np.transpose(u), u)) / np.matmul(u, np.transpose(u)))\\n return H, u\",\n \"def solve_driv(v, ene, s, n, h):\\n\\n xs = np.array([(k+1)*h for k in range(n)])\\n h2 = h*h\\n k = np.sqrt(2.0*ene)\\n \\n vs = [v(x)-ene for x in xs]\\n\\n mat = laplacian_mat(n) -2.0 * h2 * scipy.sparse.diags(vs, 0) + bc_outgoing_mat(n, h, k)\\n vec = np.array([-2.0*h*h*s(x) for x in xs])\\n\\n ys = scipy.sparse.linalg.spsolve(mat, vec)\\n return (xs, ys)\",\n \"def find_hull_vertices(points: np.ndarray) -> np.ndarray:\\n M = 3\\n N = points.shape[0]\\n for i in range(4, N):\\n while ccw(points[M], points[M - 1], points[i]) >= 0:\\n M -= 1\\n\\n M += 1\\n swap(points, M, i)\\n\\n return points[1:M + 1]\",\n \"def detect_edges_hed(self):\\n inp = cv2.dnn.blobFromImage(self.input_image, scalefactor=1.0,\\n size=(self.WIDTH, self.HEIGHT),\\n mean=(104.00698793, 116.66876762, 122.67891434),\\n swapRB=False, crop=False)\\n self.net.setInput(inp)\\n out = self.net.forward()\\n hed = out[0, 0]\\n hed = (255 * hed).astype(\\\"uint8\\\")\\n hed = cv2.fastNlMeansDenoising(hed, SMOOTH_FACTOR, SMOOTH_FACTOR, 21)\\n save_image_opencv(hed, 'hed')\\n hed_skel = skeletonize(hed).astype(\\\"uint8\\\")\\n save_image_opencv(hed_skel, 'hed_skel')\\n thresheld_hed = cv2.threshold(hed_skel, 0, 255,\\n cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]\\n save_image_opencv(thresheld_hed, 'thresheld_hed')\\n return hed, thresheld_hed\",\n \"def apply_thinning(A_ub_top, A_ub_bottom, v_u, w):\\n v_inds_r_remove = np.argwhere(v_u ==0)[:, 0]\\n v_inds_r_keep = np.delete(np.arange(len(v_u)), v_inds_r_remove)\\n\\n log.debug(f\\\"Removing {len(v_inds_r_remove)} out of {len(v_u)} variables.\\\")\\n\\n v_u = np.delete(v_u, v_inds_r_remove, axis=0)\\n A_ub_top = np.delete(A_ub_top, v_inds_r_remove, axis=1)\\n A_ub_bottom = np.delete(A_ub_bottom, v_inds_r_remove, axis=1)\\n A_ub_bottom = np.delete(A_ub_bottom, v_inds_r_remove, axis=0)\\n\\n # Remove also groups that completely disappeared --> remove columns from the right part of A_ub\\n v_inds_s_remove = np.argwhere(np.sum(A_ub_bottom, axis=0) == 0)[:, 0]\\n log.debug(f\\\"{len(v_inds_s_remove)} groups have disappeared\\\")\\n assert np.sum(v_inds_s_remove < len(v_u)) == 0 # just in case\\n A_ub_top = np.delete(A_ub_top, v_inds_s_remove, axis=1)\\n A_ub_bottom = np.delete(A_ub_bottom, v_inds_s_remove, axis=1)\\n w = np.delete(w, v_inds_s_remove - len(v_u), axis=0)\\n\\n return A_ub_top, A_ub_bottom, v_u, w, v_inds_r_keep\",\n \"def get_unhindered_positions(self, endposition):\\n current_position = self.position\\n potential_positions = { \\n 'diag1' : [],\\n 'diag2' : [],\\n 'diag3' : [],\\n 'diag4' : []\\n }\\n space_down = current_position[0]-1\\n space_up = self.ncols-current_position[0]\\n space_right = self.nrows - (ord('H')-ord(current_position[1]))\\n space_left = ord(current_position[1]) - ord('A')\\n\\n for i in range(1, space_down+1):\\n diag1 = (current_position[0]-i, chr(ord(current_position[1])+i))\\n diag2 = (current_position[0]-i, chr(ord(current_position[1])-i))\\n if self.pos_within_bounds(diag1):\\n potential_positions['diag1'].append(diag1)\\n if self.pos_within_bounds(diag2):\\n potential_positions['diag2'].append(diag2)\\n\\n for i in range(1, space_up+1):\\n diag3 = (current_position[0]+i, chr(ord(current_position[1])+i))\\n diag4 = (current_position[0]+i, chr(ord(current_position[1])-i))\\n if self.pos_within_bounds(diag3):\\n potential_positions['diag3'].append(diag3)\\n if self.pos_within_bounds(diag4):\\n potential_positions['diag4'].append(diag4)\\n \\n for direction, square in potential_positions.items():\\n if tuple(endposition) in square:\\n return potential_positions[direction]\",\n \"def hypergraph_common_edges(u, v, hypergraph):\\n total = 0\\n for e in hypergraph.edges():\\n if u in e.elements and v in e.elements:\\n total += 1\\n return total\",\n \"def closest_pair_strip(cluster_list, horiz_center, half_width):\\n\\n # compute list of indices for the clusters ordered in the horizontal direction\\n strip_and_index = [(cluster_list[idx], idx)\\n for idx in range(len(cluster_list)) \\n if abs(cluster_list[idx].horiz_center() - horiz_center) < half_width]\\n #print 'strip_and_index:', strip_and_index\\n #hcoord_and_index.sort()\\n # print hcoord_and_index\\n #horiz_order = [hcoord_and_index[idx][1]\\n # for idx in range(len(hcoord_and_index))]\\n \\n # compute list of indices for the clusters ordered in vertical direction\\n vcoord_and_index = [(strip_and_index[idx][0].vert_center(), idx)\\n for idx in range(len(strip_and_index))]\\n vcoord_and_index.sort()\\n vert_order = [strip_and_index[vcoord_and_index[idx][1]][1]\\n for idx in range(len(vcoord_and_index))] \\n #print 'vert_order:', vert_order \\n \\n dij = (float('inf'), -1, -1)\\n for udx in range(len(vert_order) - 1): # len - 2?\\n start = udx + 1\\n stop = min(udx + 4, len(vert_order))\\n for vdx in range(start, stop):\\n dist = pair_distance(cluster_list, vert_order[udx], vert_order[vdx])\\n #print 'udx, vdx:', udx, vdx, 'dist:', dist\\n if dist[0] < dij[0]:\\n dij = dist\\n \\n return dij\",\n \"def SH_FindOverlap(xcenter, ycenter, xlength, ylength, xp_corner, yp_corner):\\n\\n areaClipped = 0.0\\n top = ycenter + 0.5 * ylength\\n bottom = ycenter - 0.5 * ylength\\n\\n left = xcenter - 0.5 * xlength\\n right = xcenter + 0.5 * xlength\\n\\n nVertices = 4 # input detector pixel vertices\\n MaxVertices = 9\\n # initialize xPixel, yPixel to the detector pixel corners.\\n # xPixel,yPixel will become the clipped polygon vertices inside the cube pixel\\n # xnew,ynew xpixel and ypixel of size MaxVertices\\n\\n xPixel = []\\n yPixel = []\\n\\n xnew = []\\n ynew = []\\n\\n for j in range(0, 9):\\n xnew.append(0.0)\\n ynew.append(0.0)\\n xPixel.append(0.0)\\n yPixel.append(0.0)\\n\\n\\n # Xpixel, YPixel closed (5 corners)\\n for i in range(0, 4):\\n xPixel[i] = xp_corner[i]\\n yPixel[i] = yp_corner[i]\\n xPixel[4] = xp_corner[0]\\n yPixel[4] = yp_corner[0]\\n\\n\\n for i in range(0, 4): # 0:left, 1: right, 2: bottom, 3: top\\n nVertices2 = 0\\n for j in range(0, nVertices):\\n x1 = xPixel[j]\\n y1 = yPixel[j]\\n x2 = xPixel[j + 1]\\n y2 = yPixel[j + 1]\\n condition = calcCondition(i, x1, y1, x2, y2, left, right, top, bottom)\\n x = 0\\n y = 0\\n\\n if condition == 1:\\n x, y = solveIntersection(i, x1, y1, x2, y2,\\n left, right, top, bottom)\\n nVertices2 = addpoint(x, y, xnew, ynew, nVertices2);\\n nVertices2 = addpoint(x2, y2, xnew, ynew, nVertices2)\\n\\n elif condition == 2:\\n nVertices2 = addpoint(x2, y2, xnew, ynew, nVertices2)\\n elif condition == 3:\\n x, y = solveIntersection(i, x1, y1, x2, y2,\\n left, right, top, bottom)\\n nVertices2 = addpoint(x, y, xnew, ynew, nVertices2)\\n\\n#\\tcondition == 4: points outside\\n# Done looping over J corners\\n nVertices2 = addpoint(xnew[0], ynew[0], xnew, ynew, nVertices2) # close polygon\\n\\n if nVertices2 > MaxVertices:\\n raise Error2DPolygon(\\\" Failure in finding the clipped polygon, nVertices2 > 9 \\\")\\n\\n\\n nVertices = nVertices2 - 1;\\n\\n for k in range(0, nVertices2):\\n xPixel[k] = xnew[k]\\n yPixel[k] = ynew[k]\\n\\n# done loop over top,bottom,left,right\\n nVertices = nVertices + 1\\n\\n\\n if nVertices > 0:\\n areaClipped = FindAreaPoly(nVertices, xPixel, yPixel);\\n\\n\\n return areaClipped;\",\n \"def intersect_exit_hint(self, sq, hh):\\n\\n if not self.hints_prepped:\\n self.reset_hints()\\n self.hints_prepped=1\\n pos=self.local2global(sq)\\n if self.kind=='pararooms':\\n to_outside_dvs=[dv for dv in range(4) if add(sq, dv) not in self.sqs]\\n else:\\n to_outside_dvs=[dv for dv in range(4) if add(sq, dv) not in self.allsqs]\\n okwaysout=[]\\n #~ if self.hashid=='bfb08f4204ceecf84767e77869cabce5x009x000':\\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\\n for h in hh:\\n if h[1]=='OUT':\\n okwaysout.extend(to_outside_dvs)\\n continue\\n if h[0]=='IN':\\n okwaysout.append(h[1])\\n continue\\n okwaysout.append(h[1])\\n okwaysout=list(set(okwaysout))\\n newh=set([gh for gh in self._global_hints[pos] if gh[1] in okwaysout])\\n if not newh and self._global_hints[pos]:\\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\\n print 'promoting cause of a conflict between the rooms-exit',pos\\n return pos\\n self._global_hints[pos]=newh\\n self._hints[sq]=newh.copy()\",\n \"def next_in_hull(p, v, L): \\r\\n N = normalize(p, L)\\r\\n if N != []:\\r\\n q = N[0]\\r\\n index = 0\\r\\n for k in range(1, len(N)):\\r\\n if (N[k] - q).dot(v) >= 0: # points on support line included\\r\\n q = N[k]\\r\\n index = k\\r\\n \\r\\n return index\",\n \"def test_get_convex_hull(self):\\n\\n these_vertex_indices = skeleton_lines._get_convex_hull(\\n vertex_x_coords=VERTEX_X_COORDS[END_NODE_VERTEX_INDICES],\\n vertex_y_coords=VERTEX_Y_COORDS[END_NODE_VERTEX_INDICES])\\n\\n expected_indices = numpy.linspace(\\n 0, len(END_NODE_VERTEX_INDICES) - 1,\\n num=len(END_NODE_VERTEX_INDICES), dtype=int)\\n self.assertTrue(numpy.array_equal(\\n these_vertex_indices, expected_indices))\",\n \"def get_neighbors(y, x, H, W):\\n neighbors = []\\n\\n for i in (y-1, y, y+1):\\n for j in (x-1, x, x+1):\\n if i >= 0 and i < H and j >= 0 and j < W:\\n if (i == y and j == x):\\n continue\\n neighbors.append((i, j))\\n\\n return neighbors\",\n \"def get_neighbors(y, x, H, W):\\n neighbors = []\\n\\n for i in (y-1, y, y+1):\\n for j in (x-1, x, x+1):\\n if i >= 0 and i < H and j >= 0 and j < W:\\n if (i == y and j == x):\\n continue\\n neighbors.append((i, j))\\n\\n return neighbors\",\n \"def wedge_distance(u, v):\\n n_it = np.size(u)\\n sum = 0\\n for i in range(1, n_it):\\n for j in range(i):\\n sum += np.abs(u[i] * v[j] - u[j] * v[i]) ** 2\\n return sum\",\n \"def GetFaceToAdjacentFaces(self, p_int, int_tuple):\\n ...\",\n \"def FindSideToSideEdges(self, grey_image):\\n kernel_size = 5\\n blur_gray = cv2.GaussianBlur(grey_image, (kernel_size, kernel_size), 0)\\n self.printImageForTestingPurpose('BLURRED', blur_gray)\\n low_threshold = 25\\n high_threshold = 75\\n edges = cv2.Canny(blur_gray, low_threshold, high_threshold)\\n self.printImageForTestingPurpose('EDGES USING CANNY', edges)\\n\\n vertical = np.copy(blur_gray)\\n # [vert]\\n # Specify size on vertical axis\\n rows = vertical.shape[0]\\n verticalsize = rows // 30\\n # Create structure element for extracting vertical lines through morphology operations\\n verticalStructure = cv2.getStructuringElement(cv2.MORPH_RECT, (1, verticalsize))\\n # Apply morphology operations\\n vertical = cv2.erode(vertical, verticalStructure)\\n vertical = cv2.dilate(vertical, verticalStructure)\\n # Show extracted vertical lines\\n self.printImageForTestingPurpose(\\\"vertical\\\", vertical)\\n # [vert]\\n # [smooth]\\n # Inverse vertical image\\n vertical = cv2.bitwise_not(vertical)\\n self.printImageForTestingPurpose(\\\"vertical bit\\\", vertical)\\n\\n imshape = grey_image.shape\\n print(imshape)\\n vertices = np.array([[(0, imshape[0]), (150, imshape[1]), (500, imshape[1]), (imshape[1], imshape[0])]],\\n dtype=np.int32)\\n cv2.fillPoly(grey_image, vertices, None)\\n masked_edges = cv2.bitwise_and(edges, grey_image)\\n self.printImageForTestingPurpose('Masked Edges', masked_edges)\\n ##TODO Copied code from the medium blog.... have to see the test results.???\\n rho = 0.75 # distance resolution in pixels of the Hough grid\\n theta = np.pi / 180 # angular resolution in radians of the Hough grid\\n threshold = 20 # minimum number of votes (intersections in Hough grid cell)\\n min_line_length = 20 # minimum number of pixels making up a line\\n max_line_gap = 20 # maximum gap in pixels between connectable line segments\\n line_image = np.copy(grey_image) * 0 # creating a blank to draw lines on\\n lines = cv2.HoughLinesP(masked_edges, rho, theta, threshold, np.array([]), min_line_length, max_line_gap)\\n\\n for line in lines:\\n for x1, y1, x2, y2 in line:\\n cv2.line(line_image, (x1, y1), (x2, y2), (255, 25, 255), 5)\\n\\n lines_edges = cv2.addWeighted(grey_image, 0.8, line_image, 1, 0)\\n self.printImageForTestingPurpose('Lines Edges New', lines_edges)\\n\\n columnList = [\\\"y=100/98x-420\\\", \\\"y=-100/97+690\\\"] # Temp List\\n return columnList\",\n \"def firstNeighbor(v):\\n for u in ranks:\\n if u in matched or not self.adjacent(u, v):\\n continue\\n\\n return u\",\n \"def computeHomography(src_pnt: np.ndarray, dst_pnt: np.ndarray) -> (np.ndarray, float):\\r\\n\\r\\n A = []\\r\\n for i in range(0, len(src_pnt)):\\r\\n x, y = src_pnt[i][0], src_pnt[i][1]\\r\\n u, v = dst_pnt[i][0], dst_pnt[i][1]\\r\\n A.append([x, y, 1, 0, 0, 0, -u * x, -u * y, -u])# like we saw in class append for evey point two rows\\r\\n A.append([0, 0, 0, x, y, 1, -v * x, -v * y, -v])\\r\\n\\r\\n A = np.asarray(A)\\r\\n U, S, Vh = np.linalg.svd(A) # use SVD to find the values of the variables in the matrix\\r\\n L = Vh[-1, :] / Vh[-1, -1] # divided by the last row like we see in the exercise\\r\\n H = L.reshape(3, 3) # reshaping to 3 by 3\\r\\n print(H) # print our Homography\\r\\n #print openCv homography\\r\\n M, mask = cv2.findHomography(src_pnt, dst_pnt)\\r\\n print(\\\"=======================\\\")\\r\\n print(M)\\r\\n return H\",\n \"def silhouettePhoto(self, focalPoint, focalDist, angles):\\n sil = silhouette(focalPoint, focalDist, angles, [])\\n sil.edgesTaken = []\\n X, Y, Z = baseFromAngles(angles)\\n fVect = vector(focalPoint)\\n fVert = vertex(focalPoint)\\n for e in self.edges:\\n vertOfP = next(filter(lambda x: x not in [e.pvt, e.nvt],\\n e.pFace.vertices))\\n vertOfN = next(filter(lambda x: x not in [e.pvt, e.nvt],\\n e.nFace.vertices))\\n equ = (X.x, X.y, X.z, focalDist + fVect.dotProduct(X))\\n projOfP = vector(planeLineIntersect(focalPoint, vertOfP, equ))\\n projOfN = vector(planeLineIntersect(focalPoint, vertOfN, equ))\\n pvtProj = vector(planeLineIntersect(focalPoint, e.pvt, equ))\\n nvtProj = vector(planeLineIntersect(focalPoint, e.nvt, equ))\\n print((projOfP - fVect), vector(vertOfP) - fVect)\\n assert ((projOfP - fVect) * vector(vertOfP) - fVect).norm() < COMPARISON_EPSILON\\n nvtReduced = vector((nvtProj - fVect).dotProduct(Z),\\n (nvtProj - fVect).dotProduct(Y), 0)\\n pvtReduced = vector((pvtProj - fVect).dotProduct(Z),\\n (pvtProj - fVect).dotProduct(Y), 0)\\n nfvReduced = vector((projOfN - fVect).dotProduct(Z),\\n (projOfN - fVect).dotProduct(Y), 0)\\n pfvReduced = vector((projOfP - fVect).dotProduct(Z),\\n (projOfP - fVect).dotProduct(Y), 0)\\n normal = (pvtReduced - nvtReduced).twoDNormal()\\n s1 = normal.dotProduct(pfvReduced - pvtReduced)\\n if s1 * normal.dotProduct(nfvReduced - pvtReduced) >= 0:\\n if s1 > 0:\\n sil.segments.append((pvtReduced.coords2D(),\\n nvtReduced.coords2D()))\\n else:\\n sil.segments.append((nvtReduced.coords2D(),\\n pvtReduced.coords2D()))\\n sil.edgesTaken.append(e)\\n return sil\",\n \"def footprint_corner_indices():\",\n \"def searchPairsBinaryOrient(_session, _beg, _end, _const):\\n res = []\\n it1 = _session.create_iterator(_session.sc_constraint_new(sc_constants.CONSTR_5_a_a_f_a_f, \\n sc.SC_NODE | _const, # 2 \\n sc.SC_ARC | sc.SC_POS | _const, # 1\\n _beg, # 0\\n sc.SC_ARC | sc.SC_POS | _const, # 5\\n keynodes.n_1), # 6\\n True)\\n while not it1.is_over():\\n # check if node 2 is a sheaf\\n if checkIncToSets(_session, it1.value(0), [keynodes.info.stype_sheaf], sc.SC_POS | sc.SC_CONST):\\n # finding other nodes to end\\n res2 = _session.search_one_shot(_session.sc_constraint_new(sc_constants.CONSTR_5_f_a_f_a_f,\\n it1.value(0), # 2\\n sc.SC_ARC | sc.SC_POS | _const, # 3\\n _end, # 4\\n sc.SC_ARC | sc.SC_POS | _const, # 7\\n keynodes.n_2\\n ), True, 5)\\n if res2 is not None:\\n res.append((_beg, it1.value(1), it1.value(0), res2[1], _end, \\n it1.value(4), keynodes.n_1, res[3], keynodes.n_2))\\n it1.next()\\n \\n if len(res) > 0:\\n return res\\n \\n return None\",\n \"def TR_algo8(self, h):\\n ve = 0\\n vd = self._vd\\n k = 0\\n p = [0,]*self._N\\n m = max(self._compact_M)\\n vM = sum(self._compact_M)\\n for i in range(m-1, -1, -1):\\n mu = self.extract_mask(i)\\n mu_norm = sum([bit_component(mu, j) for j in range(self._N)])\\n mu = rotate_right(mu, vd+1)\\n pi = rotate_right(ve, vd+1) & (~mu & 2**self._N-1)\\n r = [bit_component(h, vM - k - (j+1)) for j in range(mu_norm)][::-1]\\n r = sum( [rx*2**j for j, rx in enumerate(r)] )\\n k = k + mu_norm\\n w = gcr_inv(r, mu, pi)\\n l = gc(w)\\n l = T_inv(ve, vd, l)\\n for j in range(self._N):\\n p[j] |= bit_component(l, j) << i\\n ve = ve ^ (rotate_left(e(w), vd+1))\\n vd = (vd + d(w) + 1) % self._N\\n return p\",\n \"def get_edge(self,u,v):\\n return self._outgoing[u].get(v)\",\n \"def flowaux(v, e, v_in, v_out, v_c, f, l_k, k):\\n v_out_prime = set()\\n c_prime = set()\\n\\n for q in v_c:\\n N = search_neighbor(q, e)\\n p_set = N & (v - v_out)\\n if len(p_set) == 1:\\n p = list(p_set)[0]\\n f[p] = q\\n l_k[p] = k\\n v_out_prime = v_out_prime | {p}\\n c_prime = c_prime | {q}\\n # determine whether there exists flow\\n if not v_out_prime:\\n finished = True\\n if v_out == v:\\n exist = True\\n else:\\n exist = False\\n else:\\n finished = False\\n exist = True\\n return (\\n v_out | v_out_prime,\\n (v_c - c_prime) | (v_out_prime & (v - v_in)),\\n f,\\n l_k,\\n finished,\\n exist,\\n )\",\n \"def getNeighbours(seg,meta,inversedIndex):\\n return np.unique(np.fromiter( (inversedIndex[x] for x in np.concatenate([meta.loc[seg]['ins'],meta.loc[seg]['outs']])),dtype=np.int))\",\n \"def common_nbrs(self, u, v):\\n u_adj = self.nx_graph.neighbors(u)\\n v_adj = self.nx_graph.neighbors(v)\\n nbrs = []\\n for u in u_adj:\\n if u in v_adj:\\n nbrs.append(u)\\n\\n return nbrs, u_adj, v_adj\",\n \"def recognize_pieces(edges, v, squares):\\n\\n pieces = []\\n\\n v = cv2.equalizeHist(v)\\n for p1, p2 in squares:\\n # count the number of slightly centered edges\\n occupancy = sum(edges[y][x]\\n for x in range(p1.x + 5, p2.x - 5)\\n for y in range(p1.y + 5, p2.y - 5))\\n\\n if occupancy > 70*255:\\n corners = (v[p1.y][p1.x], v[p1.y][p2.x],\\n v[p2.y][p1.x], v[p2.y][p2.x])\\n\\n # average v-component of the corners\\n avg = sum(map(float, corners)) / len(corners)\\n\\n # black pixels should be relatively black\\n # when compared to the corner average\\n black = sum(v[y][x] / avg < 0.2\\n for x in range(p1.x, p2.x + 1)\\n for y in range(p1.y, p2.y + 1))\\n\\n if black >= 1000 and black != 1049:\\n color = \\\"B\\\"\\n else:\\n color = \\\"W\\\"\\n\\n pieces.append(color)\\n else:\\n pieces.append(None)\\n\\n return pieces\",\n \"def Voronoi_cell(hull, centers, vertex, original_fan):\\n # make a copy so that the original does not get mutated\\n fan = copy.deepcopy(original_fan)\\n\\n # start by moving the center\\n # of the first one in the list of adjacent faces\\n # to the resulting polygon\\n simplex = fan.pop(0)\\n result = [centers[simplex]]\\n\\n # find the vertices of this face\\n simplex_vertices = hull.simplices[simplex]\\n\\n # there should only be two other vertices on this face\\n # other than our given vertex\\n\\n # pick one of them and mark it 'known'\\n # the other one will be common to the next simplex to consider\\n known_vertex, common_vertex = [x for x in simplex_vertices if x != vertex]\\n\\n while fan:\\n # the collection of faces is not exhausted yet\\n assert known_vertex in simplex_vertices\\n\\n known_vertex_index = list(simplex_vertices).index(known_vertex)\\n\\n # next simplex to consider\\n # it is the simplex which is opposite to the known vertex\\n simplex = hull.neighbors[simplex][known_vertex_index]\\n\\n assert simplex in fan\\n\\n # now move its center to our resulting polygon\\n fan.remove(simplex)\\n result.append(centers[simplex])\\n\\n # and repeat the process\\n simplex_vertices = hull.simplices[simplex]\\n known_vertex = common_vertex\\n\\n # of the three vertices of the simplex\\n # one should be our given vertex\\n # and one should already have been processed\\n remaining = [x for x in hull.simplices[simplex]\\n if x != vertex and x != known_vertex]\\n\\n assert len(remaining) == 1\\n common_vertex = remaining[0]\\n\\n return numpy.array(result)\",\n \"def get_faces(self):\\n for i, j in combinations(self.gens, 2):\\n c0 = self.triangle_verts[self.vertex_at_mirrors(i, j)]\\n f0 = []\\n m = self.cox_mat[i][j]\\n H = (i, j)\\n type = 0\\n if self.active[i] and self.active[j]:\\n type = 1\\n for k in range(m):\\n f0.append(self.G.move(self.vtable, 0, (i, j) * k))\\n f0.append(self.G.move(self.vtable, 0, (i, j) * k + (i,)))\\n elif self.active[i] and m > 2:\\n for k in range(m):\\n f0.append(self.G.move(self.vtable, 0, (j, i) * k))\\n elif self.active[j] and m > 2:\\n for k in range(m):\\n f0.append(self.G.move(self.vtable, 0, (i, j) * k))\\n else:\\n continue\\n\\n reps = set(self.word_generator(parabolic=H))\\n reps = self.G.sort_words(reps)\\n flist = []\\n for word in reps:\\n f = tuple(self.G.move(self.vtable, v, word) for v in f0)\\n if None not in f and not helpers.check_duplicate_face(f, flist):\\n center = self.transform(word, c0)\\n coords = [self.vertices_coords[k] for k in f]\\n face = DihedralFace(word, f, center, coords, type)\\n flist.append(face)\\n\\n self.face_indices[(i, j)] = flist\\n\\n self.num_faces = sum(len(L) for L in self.face_indices.values())\",\n \"def intersect_hint(self, sq, hh):\\n if not self.hints_prepped:\\n self.reset_hints()\\n self.hints_prepped=1\\n #~ self._hints[sq]=self._hints[sq].intersection(hh)\\n pos=self.local2global(sq)\\n #~ self._global_hints[pos]=self._global_hints[pos].intersection(hh)\\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\\n #~ bad=0\\n #~ for h in hh:\\n #~ if 'IN'==h[0]:\\n #~ bad=1\\n #~ break\\n #~ if 'OUT'==h[1]:\\n #~ bad=1\\n #~ break\\n #~ if bad:\\n #~ for h in hh:\\n #~ if 'IN'==h[0]:\\n #~ self._global_hints[pos]=[gh for gh in self._global_hints[pos] if gh[1]==h[1]]\\n #~ self._hints[sq]=[lh for lh in self._hints[sq] if lh[1]==h[1]]\\n #~ if 'OUT'==h[1]:\\n #~ self._global_hints[pos]=[gh for gh in self._global_hints[pos] if gh[0]==h[0]]\\n #~ self._hints[sq]=[lh for lh in self._hints[sq] if lh[0]==h[0]]\\n #~ if h in self._global_hints[pos]:\\n #~ self._global_hints[pos].remove(h)\\n #~ self._hints[sq].remove(h)\\n #~ else:\\n self._hints[sq]=self._hints[sq].intersection(hh)\\n self._global_hints[pos]=self._global_hints[pos].intersection(hh)\",\n \"def project (u, v):\\r\\n\\r\\n # Construct linear system Ap = d\\r\\n A = sps.lil_matrix ((width*height, width*height))\\r\\n d = np.zeros ((width*height))\\r\\n\\r\\n for i in range (1, height-1):\\r\\n for j in range (1, width-1):\\r\\n A[index(i,j), index(i,j)] = 4\\r\\n A[index(i,j), index(i-1,j)] = -1\\r\\n A[index(i,j), index(i+1,j)] = -1\\r\\n A[index(i,j), index(i,j-1)] = -1\\r\\n A[index(i,j), index(i,j+1)] = -1\\r\\n \\r\\n d[index(i,j)] = -1/h * (u[i,j] - u[i,j-1] + v[i,j] - v[i-1,j])\\r\\n\\r\\n # Unhandled boundary cases, we assume solid walls that don't move\\r\\n A[index(0,0), index(0,0)] = 2\\r\\n A[index(0,0), index(1,0)] = -1\\r\\n A[index(0,0), index(0,1)] = -1\\r\\n d[index(0,0)] = -1/h * (u[0,0] + v[0,0])\\r\\n\\r\\n A[index(height-1,0), index(0,0)] = 2\\r\\n A[index(height-1,0), index(height-1,1)] = -1\\r\\n A[index(height-1,0), index(height-2,0)] = -1\\r\\n d[index(height-1,0)] = -1/h * (u[height-1,0] - v[height-2,0])\\r\\n\\r\\n A[index(0,width-1), index(0,width-1)] = 2\\r\\n A[index(0,width-1), index(1,width-1)] = -1\\r\\n A[index(0,width-1), index(0,width-2)] = -1\\r\\n d[index(0,width-1)] = -1/h * (-u[0,width-2] + v[0,width-1])\\r\\n\\r\\n A[index(height-1,width-1), index(height-1,width-1)] = 2\\r\\n A[index(height-1,width-1), index(height-2,width-1)] = -1\\r\\n A[index(height-1,width-1), index(height-1,width-2)] = -1\\r\\n d[index(height-1,width-1)] = -1/h * (-u[height-1,width-2] - v[height-2,width-1])\\r\\n\\r\\n\\r\\n for i in range (1, height-1):\\r\\n A[index(i,0), index(i,0)] = 3\\r\\n A[index(i,0), index(i-1,0)] = -1\\r\\n A[index(i,0), index(i+1,0)] = -1\\r\\n A[index(i,0), index(i,1)] = -1\\r\\n d[index(i,0)] = -1/h * (u[i,0] + v[i,0] - v[i-1,0])\\r\\n\\r\\n for i in range (1, height-1):\\r\\n A[index(i,width-1), index(i,width-1)] = 3\\r\\n A[index(i,width-1), index(i-1,width-1)] = -1\\r\\n A[index(i,width-1), index(i+1,width-1)] = -1\\r\\n A[index(i,width-1), index(i,width-2)] = -1\\r\\n d[index(i,width-1)] = -1/h * (- u[i,width-2] + v[i, width-1] - v[i-1,width-1])\\r\\n\\r\\n for j in range (1, width-1):\\r\\n A[index(0,j), index(0,j)] = 3\\r\\n A[index(0,j), index(1,j)] = -1\\r\\n A[index(0,j), index(0,j-1)] = -1\\r\\n A[index(0,j), index(0,j+1)] = -1\\r\\n d[index(0,j)] = -1/h * (u[0,j] - u[0,j-1] + v[0,j])\\r\\n \\r\\n for j in range (1, width-1):\\r\\n A[index(height-1,j), index(height-1,j)] = 3\\r\\n A[index(height-1,j), index(height-2,j)] = -1\\r\\n A[index(height-1,j), index(height-1,j-1)] = -1\\r\\n A[index(height-1,j), index(height-1,j+1)] = -1\\r\\n d[index(height-1,j)] = -1/h * (u[height-1,j] - u[height-1,j-1] - v[height-2,j])\\r\\n\\r\\n\\r\\n A = A * dt / (density * h**2)\\r\\n\\r\\n A = sps.csr_matrix (A)\\r\\n p = np.reshape(spsolve (A, d), (height, width))\\r\\n\\r\\n # Calculate new velocity field based on this pressure field\\r\\n for i in range (height):\\r\\n for j in range (width):\\r\\n if (i == height-1 and j == width-1) or (i == height-1 and j == 0) or (i == 0 and j == width-1) or (i == 0 and j == 0):\\r\\n # Set vertical velocity to movement of solid wall 0\\r\\n u[i,j] = 0\\r\\n v[i,j] = 0\\r\\n elif i == height-1 or i == 0:\\r\\n u[i,j] = u[i,j] - dt / (density * h) * (p[i,j+1] - p[i,j])\\r\\n v[i,j] = 0\\r\\n elif j == width-1 or j == 0:\\r\\n u[i,j] = 0\\r\\n v[i,j] = v[i,j] - dt / (density * h) * (p[i+1,j] - p[i,j])\\r\\n else:\\r\\n u[i,j] = u[i,j] - dt / (density * h) * (p[i,j+1] - p[i,j])\\r\\n v[i,j] = v[i,j] - dt / (density * h) * (p[i+1,j] - p[i,j])\\r\\n\\r\\n # let's get some inflow\\r\\n u[4:12, 0] = 1\\r\\n\\r\\n return u, v, p\",\n \"def vorticity_divergence(self, u, v):\\n vort, div = vorticity_divergence_spectral(u, v)\\n return self.to_grid(vort), self.to_grid(div)\",\n \"def split_edge_mesh(mesh, u, v, t=0.5, allow_boundary=False):\\n if t <= 0.0:\\n raise ValueError('t should be greater than 0.0.')\\n if t >= 1.0:\\n raise ValueError('t should be smaller than 1.0.')\\n # check if the split is legal\\n # don't split if edge is on boundary\\n fkey_uv = mesh.halfedge[u][v]\\n fkey_vu = mesh.halfedge[v][u]\\n if not allow_boundary:\\n if fkey_uv is None or fkey_vu is None:\\n return\\n # the split vertex\\n sp = mesh.vertex_coordinates(u)\\n ep = mesh.vertex_coordinates(v)\\n line = Line(sp, ep)\\n line.scale(t)\\n x, y, z = line.end\\n # --------------------------------------------------------------------------\\n # this interpolates the attributes\\n # perhaps this should be left up to a user function\\n # btw, all algorithms should have ufuncs...\\n u_attr = mesh.vertex[u]\\n v_attr = mesh.vertex[v]\\n w_attr = {}\\n for name in u_attr:\\n try:\\n w_attr[name] = 0.5 * (u_attr[name] + v_attr[name])\\n except:\\n try:\\n w_attr[name] = [0.5 * (u_attr[name][_] + v_attr[name][_]) for _ in range(len(u_attr[name]))]\\n except:\\n w_attr[name] = None\\n # --------------------------------------------------------------------------\\n w = mesh.add_vertex(attr_dict=w_attr, x=x, y=y, z=z)\\n # split half-edge UV\\n mesh.halfedge[u][w] = fkey_uv\\n mesh.halfedge[w][v] = fkey_uv\\n del mesh.halfedge[u][v]\\n # update the UV face if it is not the `None` face\\n if fkey_uv is not None:\\n mesh.face[fkey_uv][u] = w\\n mesh.face[fkey_uv][w] = v\\n # split half-edge VU\\n mesh.halfedge[v][w] = fkey_vu\\n mesh.halfedge[w][u] = fkey_vu\\n del mesh.halfedge[v][u]\\n # update the VU face if it is not the `None` face\\n if fkey_vu is not None:\\n mesh.face[fkey_vu][v] = w\\n mesh.face[fkey_vu][w] = u\\n # return the key of the split vertex\\n return w\",\n \"def rook_neighbors_face(self, face):\\n edges = self.cw_face_edges(face)\\n return list(set([ self.left_region[edge] for edge in edges]))\",\n \"def wer(r, h):\\n # initialisation\\n import numpy\\n d = numpy.zeros((len(r)+1)*(len(h)+1), dtype=numpy.uint8)\\n d = d.reshape((len(r)+1, len(h)+1))\\n for i in range(len(r)+1):\\n for j in range(len(h)+1):\\n if i == 0:\\n d[0][j] = j\\n elif j == 0:\\n d[i][0] = i\\n\\n # computation\\n for i in range(1, len(r)+1):\\n for j in range(1, len(h)+1):\\n if r[i-1] == h[j-1]:\\n d[i][j] = d[i-1][j-1]\\n else:\\n substitution = d[i-1][j-1] + 1\\n insertion = d[i][j-1] + 1\\n deletion = d[i-1][j] + 1\\n d[i][j] = min(substitution, insertion, deletion)\\n\\n return d[len(r)][len(h)]\",\n \"def HDIF(img: list, v: int, u: int, kernel: tuple):\\n if u >= v:\\n print(\\\"v has to be larger than u\\\")\\n else:\\n diff = v - u\\n blur_u = blur_n_times(img, v, kernel)\\n result = get_max(get_diff(blur_n_times(blur_u, diff, kernel), blur_u))\\n return result\",\n \"def borders((u,v)):\\r\\n return ((u,v+1,S), (u+1,v,W), (u,v,S), (u,v,W))\",\n \"def get_neighbors(self, row, col):\\n neighbors = set()\\n for d in [-1,1]:\\n if row+d >= 0 and row+d < self._height and \\\\\\n (row+d,col) in self._empty_spaces:\\n neighbors.add((row+d,col))\\n if col+d >= 0 and col+d < self._width and \\\\\\n (row,col+d) in self._empty_spaces:\\n neighbors.add((row,col+d))\\n return neighbors\",\n \"def center_flows(L_wprime, U_wprime, L_w3, U_w3, L_overlap, U_overlap):\\n # examine every possible point\\n current_dist_to_edge = -1\\n point = (0,0)\\n #print(\\\"w3 range: [{}, {}]\\\".format(L_w3, U_w3))\\n #print(\\\"w' range: [{}, {}]\\\".format(L_wprime, U_wprime))\\n #print(\\\"overlap range: [{},{}]\\\".format(L_overlap, U_overlap))\\n for y in range(L_w3, U_w3 + 1):\\n #print(\\\"y={}\\\".format(y))\\n LH_bound = max(L_wprime, L_overlap - y)\\n #print(\\\"LH bound = {}\\\".format(LH_bound))\\n RH_bound = min(U_wprime, U_overlap - y)\\n #print(\\\"RH bound = {}\\\".format(RH_bound))\\n for x in range(LH_bound, RH_bound + 1):\\n # w3 UB: 0x + 1y - U_w3 = 0\\n # w3 LB: 0x + 1y - L_w3 = 0\\n # wprime UB: 1x + 0y - U_wprime\\n # wprime LB: 1x + 0y - L_wprime\\n # wprime + w3 UB: 1x + 1y - U_wprime,wk\\n # wprime + w3 LB: 1x + 1y - L_wprime,wk\\n dist_to_edge = min(distance_point_to_line(x, y, 0, -1, U_w3), #0x-1y+U_w3=0\\n distance_point_to_line(x, y, 0, -1, L_w3), #0x-1y+L_w3=0\\n # -1x + 0y + U_wprime = 0\\n distance_point_to_line(x, y, -1, 0, U_wprime),\\n # -1x + 0y + L_wprime = 0\\n distance_point_to_line(x, y, -1, 0, L_wprime),\\n # -1x - 1y + U_overlap = 0\\n distance_point_to_line(x, y, -1, -1, U_overlap),\\n # -1 x - y + L_overlap = 0\\n distance_point_to_line(x, y, -1, -1, L_overlap))\\n if dist_to_edge > current_dist_to_edge:\\n #print(\\\"At point ({},{}), distance to edge increased from {} to {}.\\\"\\\\\\n # .format(x,y,current_dist_to_edge,dist_to_edge))\\n current_dist_to_edge = dist_to_edge\\n point = (x,y)\\n return(point)\",\n \"def neighbors(i , j) :\\n ns = []\\n # vector de direction\\n dx = [+1, +1, 0, 1]\\n dy = [0, +1, 1, -1]\\n for d in range(4) :\\n ns.append((i + dx[d], j + dy[d]))\\n #remove neagative element\\n ns = [i for i in ns if i[0] >= 0 and i[1] >= 0]\\n return ns\",\n \"def neighbors(self, u):\\r\\n return filter(lambda v: self.getCapacity((u,v)) > 0, self.adjacent[u])\",\n \"def regions_from_graph(vertices, edges):\\n # step 0 remove filaments (not included in original algorithm)\\n nv = np.zeros(len(vertices))\\n v = vertices.keys()\\n v.sort()\\n v2e = {}\\n for edge in edges:\\n s,e = edge\\n nv[v.index(s)] += 1\\n nv[v.index(e)] += 1\\n v2e[s] = edge\\n v2e[e] = edge\\n\\n filament_nodes = np.nonzero(nv==1)[0]\\n filaments = []\\n for f in filament_nodes:\\n filaments.append(v2e[f])\\n edges.remove(v2e[f])\\n\\n #print filaments\\n\\n # step 1\\n # have a twin for each directed edge\\n dedges = edges[:]\\n for edge in edges:\\n new_edge = edge[1], edge[0]\\n if new_edge not in dedges:\\n dedges.append( (edge[1],edge[0]) )\\n\\n # step 2 complement each directed edge with an angle formed with horizontal\\n # line passing through edge[0] for each edge\\n angles = []\\n from math import atan2, degrees\\n\\n for edge in dedges:\\n\\n v1 = vertices[edge[0]]\\n v2 = vertices[edge[1]]\\n dx = v2[0] - v1[0]\\n dy = v2[1] - v1[1]\\n at = atan2(dy, dx)\\n d = degrees(at)\\n if d < 0:\\n d = 360 + d\\n angles.append( [ (edge[0],d), (edge[0],edge[1]) ])\\n\\n # step 3 sort the list into ascending order using vi and angle as primary and\\n # secondary keys\\n angles.sort()\\n\\n\\n # form wedges on consecutive entries with same vi (vi,vj,dij), (vi,vk,dik)\\n # gives the wedge (vk,vi,vj)\\n wedges = []\\n start = angles[0]\\n c = 0\\n for i in range(1,len(angles)):\\n next_edge = angles[i]\\n previous_edge = angles[i-1]\\n if next_edge[0][0] == start[0][0]:\\n wedge = [ next_edge[1][1], previous_edge[1][0], previous_edge[1][1] ]\\n wedges.append(wedge)\\n else:\\n # first form wedge with last and first entry of current group\\n # to do\\n wedge = [ start[1][1], previous_edge[1][0], previous_edge[1][1] ]\\n wedges.append(wedge)\\n start = next_edge\\n\\n # final pair\\n\\n wedge = [ start[1][1], previous_edge[1][0], next_edge[1][1] ]\\n wedges.append(wedge)\\n\\n\\n # phase two\\n # form regions from contiguous wedges\\n\\n nw = len(wedges)\\n used = [0]*nw\\n wedges.sort()\\n #print wedges\\n\\n #print 'forming regions'\\n\\n i = 0\\n regions = []\\n while sum(used) < nw:\\n i = used.index(0)\\n wi = wedges[i]\\n start = wedges[i]\\n used[i] = 1\\n region = [start]\\n # find next contiguous wedge for wi\\n forming = True\\n while forming:\\n\\n\\n # find first wedge contiguous to wi\\n for j in xrange(nw):\\n wj = wedges[j]\\n if wj[0] == wi[1] and wj[1] == wi[2]:\\n region.append(wj)\\n used[j] = 1\\n wi = wj\\n if wi[1] == start[0] and wi[2] == start[1]:\\n forming = False\\n regions.append(region)\\n #print start, regions\\n #raw_input('h')\\n break\\n\\n # put in closed cartographic form\\n nodes = []\\n for region in regions:\\n wedge0 = [ wedge[0] for wedge in region]\\n wedge0.append(wedge0[0])\\n nodes.append(wedge0)\\n\\n results = {}\\n results['regions'] = nodes\\n results['filaments'] = filaments\\n\\n return results\",\n \"def GetBoundaryFacesHex(self):\\n\\n p = self.InferPolynomialDegree()\\n\\n # DO NOT COMPUTE IF ALREADY COMPUTED\\n if isinstance(self.faces,np.ndarray):\\n if self.faces.shape[0] > 1:\\n # IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION\\n if self.faces.shape[1] == 4 and p > 1:\\n pass\\n else:\\n return\\n\\n node_arranger = NodeArrangementHex(p-1)[0]\\n\\n # CONCATENATE ALL THE FACES MADE FROM ELEMENTS\\n all_faces = np.concatenate((np.concatenate((\\n np.concatenate((np.concatenate((np.concatenate((self.elements[:,node_arranger[0,:]],\\n self.elements[:,node_arranger[1,:]]),axis=0),self.elements[:,node_arranger[2,:]]),axis=0),\\n self.elements[:,node_arranger[3,:]]),axis=0),self.elements[:,node_arranger[4,:]]),axis=0),\\n self.elements[:,node_arranger[5,:]]),axis=0).astype(np.int64)\\n # GET UNIQUE ROWS\\n uniques, idx, inv = unique2d(all_faces,consider_sort=True,order=False,return_index=True,return_inverse=True)\\n\\n # ROWS THAT APPEAR ONLY ONCE CORRESPOND TO BOUNDARY FACES\\n freqs_inv = itemfreq(inv)\\n faces_ext_flags = freqs_inv[freqs_inv[:,1]==1,0]\\n # NOT ARRANGED\\n self.faces = uniques[faces_ext_flags,:]\\n\\n # DETERMINE WHICH FACE OF THE ELEMENT THEY ARE\\n boundary_face_to_element = np.zeros((faces_ext_flags.shape[0],2),dtype=np.int64)\\n\\n # FURTHER RE-ARRANGEMENT / ARANGE THE NODES BASED ON THE ORDER THEY APPEAR\\n # IN ELEMENT CONNECTIVITY\\n # THIS STEP IS NOT NECESSARY INDEED - ITS JUST FOR RE-ARANGMENT OF FACES\\n all_faces_in_faces = in2d(all_faces,self.faces,consider_sort=True)\\n all_faces_in_faces = np.where(all_faces_in_faces==True)[0]\\n\\n # boundary_face_to_element = np.zeros((all_faces_in_faces.shape[0],2),dtype=np.int64)\\n boundary_face_to_element[:,0] = all_faces_in_faces % self.elements.shape[0]\\n boundary_face_to_element[:,1] = all_faces_in_faces // self.elements.shape[0]\\n\\n # ARRANGE FOR ANY ORDER OF BASES/ELEMENTS AND ASSIGN DATA MEMBERS\\n self.faces = self.elements[boundary_face_to_element[:,0][:,None],node_arranger[boundary_face_to_element[:,1],:]]\\n self.faces = self.faces.astype(np.uint64)\\n self.boundary_face_to_element = boundary_face_to_element\",\n \"def detect_four_corners_based_on_ref_squares(img,\\n ref_vertex,\\n search_margin=0.1,\\n square_width=50./2480,\\n debug_=False):\\n square_ratio_range = [0.8, 1.2]\\n square_width_margin = 0.5\\n square_fill_thresh = 0.8\\n\\n debug_in_ = False\\n\\n dim = img.shape[1::-1]\\n square_width = square_width * dim[0]\\n real_vertices = hp.generate_four_vertices_from_ref_vertex(ref_vertex, dim)\\n crop_boxes = []\\n offsets = [int(x*search_margin) for x in dim]\\n crop_boxes.append([real_vertices[0][0], real_vertices[0][1],\\n real_vertices[0][0]+offsets[0], real_vertices[0][1]+offsets[1]])\\n crop_boxes.append([real_vertices[1][0]-offsets[0], real_vertices[1][1],\\n real_vertices[1][0], real_vertices[1][1]+offsets[1]])\\n crop_boxes.append([real_vertices[2][0], real_vertices[2][1]-offsets[1],\\n real_vertices[2][0]+offsets[0], real_vertices[2][1]])\\n crop_boxes.append([real_vertices[3][0]-offsets[0], real_vertices[3][1]-offsets[1],\\n real_vertices[3][0], real_vertices[3][1]])\\n\\n detected_vertices = []\\n kernel = np.ones((5,5),np.uint8)\\n for idx in range(4):\\n crop_img = img[crop_boxes[idx][1]:crop_boxes[idx][3],\\n crop_boxes[idx][0]:crop_boxes[idx][2]]\\n gray_img = cv2.cvtColor(crop_img, cv2.COLOR_RGB2GRAY)\\n ret, thresh_gray = cv2.threshold(gray_img,\\n thresh=200,\\n maxval=255,\\n # type=cv2.THRESH_BINARY)\\n type=cv2.THRESH_BINARY+cv2.THRESH_OTSU)\\n for _ in range(3):\\n thresh_gray = cv2.morphologyEx(thresh_gray, cv2.MORPH_CLOSE, kernel)\\n cv2.bitwise_not(thresh_gray, thresh_gray)\\n thresh_color = cv2.cvtColor(thresh_gray, cv2.COLOR_GRAY2RGB)\\n ret, contours, hierarchy = cv2.findContours(thresh_gray, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\n min_width_ratio = 1\\n det_vertex = []\\n for i, cont in enumerate(contours):\\n x1, y1, w, h = cv2.boundingRect(cont)\\n ratio = h/w\\n width_ratio = abs(square_width - w) / square_width\\n if debug_in_:\\n if w > 10 and h > 10:\\n # cv2.drawContours(crop_img, contours, i, hp.GREEN, thickness=4)\\n cv2.drawContours(thresh_color, contours, i, hp.GREEN, thickness=4)\\n print(\\\"-------\\\")\\n print(i)\\n print(x1, y1, w, h, width_ratio)\\n print(ratio, cv2.contourArea(cont)/(w*h))\\n\\n if square_ratio_range[0] < ratio < square_ratio_range[1] and \\\\\\n width_ratio < square_width_margin and \\\\\\n cv2.contourArea(cont) / (w*h) > square_fill_thresh:\\n moments = cv2.moments(cont)\\n cx = int(moments['m10'] / moments['m00'])\\n cy = int(moments['m01'] / moments['m00'])\\n if width_ratio < min_width_ratio:\\n det_vertex = [cx + crop_boxes[idx][0], cy + crop_boxes[idx][1]]\\n min_width_ratio = width_ratio\\n # print(\\\"****\\\")\\n if debug_:\\n disp_img = np.copy(crop_img)\\n cv2.drawContours(disp_img, contours, i, hp.RED, thickness=4)\\n cv2.circle(disp_img,(cx, cy), 8, hp.GREEN, -1)\\n hp.hp_imshow(disp_img)\\n if debug_in_:\\n hp.hp_imshow(thresh_color, desc=\\\"thresh_color\\\")\\n if det_vertex:\\n detected_vertices.append(det_vertex)\\n box_img = np.copy(img)\\n if len(detected_vertices) != 4:\\n # print(\\\" @ Error: 4 corners are NOT detected!\\\")\\n return False, detected_vertices, img\\n\\n cv2.line(box_img, tuple(detected_vertices[0]), tuple(detected_vertices[1]), hp.RED, 10)\\n cv2.line(box_img, tuple(detected_vertices[0]), tuple(detected_vertices[2]), hp.RED, 10)\\n cv2.line(box_img, tuple(detected_vertices[1]), tuple(detected_vertices[3]), hp.RED, 10)\\n cv2.line(box_img, tuple(detected_vertices[2]), tuple(detected_vertices[3]), hp.RED, 10)\\n if debug_:\\n hp.hp_imshow(box_img, desc=\\\"four corners\\\")\\n\\n return True, detected_vertices, img\",\n \"def is_collapse_legal(mesh, u, v, allow_boundary=False):\\r\\n # collapsing of boundary vertices is currently not supported\\r\\n # change this to `and` to support collapsing to or from the boundary\\r\\n if not allow_boundary:\\r\\n if mesh.is_vertex_on_boundary(v) or mesh.is_vertex_on_boundary(u):\\r\\n return False\\r\\n\\r\\n # check for contained faces\\r\\n for nbr in mesh.halfedge[u]:\\r\\n if nbr in mesh.halfedge[v]:\\r\\n # check if U > V > NBR is a face\\r\\n fkey = mesh.halfedge[u][v]\\r\\n if fkey != mesh.halfedge[v][nbr] or fkey != mesh.halfedge[nbr][u]:\\r\\n # check if V > U > NBR is a face\\r\\n fkey = mesh.halfedge[v][u]\\r\\n if fkey != mesh.halfedge[u][nbr] or fkey != mesh.halfedge[nbr][v]:\\r\\n return False\\r\\n\\r\\n for nbr in mesh.halfedge[v]:\\r\\n if nbr in mesh.halfedge[u]:\\r\\n # check if U > V > NBR is a face\\r\\n fkey = mesh.halfedge[u][v]\\r\\n if fkey != mesh.halfedge[v][nbr] or fkey != mesh.halfedge[nbr][u]:\\r\\n # check if V > U > NBR is a face\\r\\n fkey = mesh.halfedge[v][u]\\r\\n if fkey != mesh.halfedge[u][nbr] or fkey != mesh.halfedge[nbr][v]:\\r\\n return False\\r\\n\\r\\n return True\",\n \"def get_shouldering(binary_mask):\\n shoulder_dict = get_shoulders(binary_mask)\\n\\n top_y_min = shoulder_dict[\\\"top_y_min\\\"]\\n top_y_max = shoulder_dict[\\\"top_y_max\\\"]\\n top_x_min = shoulder_dict[\\\"top_x_min\\\"]\\n top_x_max = shoulder_dict[\\\"top_x_max\\\"]\\n\\n bottom_y_min = shoulder_dict[\\\"bottom_y_min\\\"]\\n bottom_y_max = shoulder_dict[\\\"bottom_y_max\\\"]\\n bottom_x_min = shoulder_dict[\\\"bottom_x_min\\\"]\\n bottom_x_max = shoulder_dict[\\\"bottom_x_max\\\"]\\n\\n top_shoulder = binary_mask[top_y_min:top_y_max, top_x_min:top_x_max]\\n bottom_shoulder = binary_mask[bottom_y_min:bottom_y_max, bottom_x_min:bottom_x_max]\\n\\n white_top = get_biomass(top_shoulder)\\n black_top = (top_shoulder.shape[0] * top_shoulder.shape[1]) - white_top\\n\\n white_bottom = get_biomass(bottom_shoulder)\\n black_bottom = (bottom_shoulder.shape[0] * bottom_shoulder.shape[1]) - white_bottom\\n\\n return black_top, black_bottom\",\n \"def is_vert(e) :\\n f = e[0][0]\\n for t in e :\\n if f != t[0] :\\n return False\\n return True\",\n \"def conv_hls_halfmask(image):\\n image = np.copy(image)\\n # Convert to HSV color space and separate the V channel\\n hls = cv2.cvtColor(image, cv2.COLOR_RGB2HLS).astype(np.float)\\n # AOI (area of interest) mask - we only care about lower part of the image\\n size_x, size_y, size_ch = hls.shape\\n hls[0:size_x//2,:,:] = 0\\n return hls\",\n \"def get_k2(tri, v_neighbours):\\n three = np.array([0, 1, 2])\\n nv = tri.shape[0]\\n k2s = np.empty((nv, 3), dtype=np.int32)\\n for i in range(nv):\\n for k in range(3):\\n neighbour = v_neighbours[i, k]\\n k2 = ((v_neighbours[neighbour] == i) * three).sum()\\n k2s[i, k] = k2\\n return k2s\",\n \"def divergence(self, u, v):\\n return self.to_grid(self.divergence_spectral(u, v))\",\n \"def GetFaceToAdjacentFacesArray(self, p_int):\\n ...\",\n \"def close_up(edge_count, used_pivots):\\n edges = []\\n for edge, count in edge_count.items():\\n if count == 1:\\n edges.append(edge)\\n\\n faces = []\\n lazy_update = collections.defaultdict(int) # default = 0\\n while edges:\\n vertices = None\\n for (i, edge_a), (j, edge_b) in\\\\\\n itertools.combinations(enumerate(edges), 2):\\n vertices = set(edge_a).union(set(edge_b))\\n if len(vertices) == len(edge_a[0]):\\n edges[i], edges[j], edges[-1], edges[-2] =\\\\\\n edges[-1], edges[-2], edges[i], edges[j]\\n edges.pop()\\n edges.pop()\\n break\\n else:\\n # Cannot find a face, update edges and edges count\\n updated = False\\n for edge in lazy_update: # = .keys()\\n if lazy_update[edge] + edge_count[edge] == 1:\\n edges.append(edge)\\n lazy_update[edge] = 2 # Avoid duplicated edges\\n updated = True\\n if not updated:\\n break\\n continue\\n\\n face = list(vertices)\\n for pivot in used_pivots: # = .keys()\\n if pivot not in vertices:\\n if not check_inside(face, pivot)[0]:\\n # det(A) = -det (B) if two cols swap (odd and even)\\n face[-1], face[-2] = face[-2], face[-1]\\n break\\n else:\\n # This edge is the first edge\\n return []\\n\\n faces.append(tuple(face))\\n for edge in itertools.combinations(tuple(face), len(face) - 1):\\n lazy_update[tuple(sort_vertices(edge))] += 1\\n\\n return faces\",\n \"def get_neighbours(tri,neigh=None,Range=None):\\n n_v = tri.shape[0]\\n if neigh is None:\\n neigh = np.ones_like(tri,dtype=np.int32)*-1\\n if Range is None:\\n Range = np.arange(n_v)\\n tri_compare = np.concatenate((tri.T, tri.T)).T.reshape((-1, 3, 2))\\n for j in Range:#range(n_v):\\n tri_sample_flip = np.flip(tri[j])\\n tri_i = np.concatenate((tri_sample_flip,tri_sample_flip)).reshape(3,2)\\n for k in range(3):\\n if neigh[j,k]==-1:\\n neighb,l = np.nonzero((tri_compare[:,:,0]==tri_i[k,0])*(tri_compare[:,:,1]==tri_i[k,1]))\\n neighb,l = neighb[0],l[0]\\n neigh[j,k] = neighb\\n neigh[neighb,np.mod(2-l,3)] = j\\n return neigh\",\n \"def closest_pair_strip(cluster_list, horiz_center, half_width):\\n indices = [] \\n\\n # Let S be a list of the set {i: |xi - mid| < half_width}\\n indices = [index for index in range(len(cluster_list)) if abs(cluster_list[index].horiz_center()-horiz_center)<=half_width]\\n \\n\\t# Sort the indices in S in nondecreasing order of the vertial (y) coordinates of their associated points;\\n indices.sort(key = lambda index: cluster_list[index].vert_center())\\n\\n cl_sorted = cluster_list[:]\\n cl_sorted.sort(key = lambda cluster: cluster.vert_center())\\n\\n # k <-- length(S);\\n len_indices = len(indices)\\n\\n # (d,i,j) <-- (infinity, -1, -1);\\n output_list = [float('inf'), -1, -1]\\t\\n\\n # for u <-- 0 to k - 2 do\\n for value1 in range(len_indices-1):\\n \\t# \\tfor v <-- u + 1 to min{u+3,k-1} do\\n for value2 in range(value1+1, min(value1+6,len_indices)):\\n # (d,i,j) <-- min{(d,i,j),(dsub(psubS[u],PsubS[v]), S[u],S[v])}\\n min_dist = min(output_list[0], pair_distance(cluster_list,indices[value1],indices[value2])[0])\\n if output_list[0] > min_dist:\\n indices_sorted = sorted([indices[value1], indices[value2]])\\n \\toutput_list = [pair_distance(cluster_list,indices[value1],indices[value2])[0], indices_sorted[0], indices_sorted[1]]\\n\\n # return(d,i,j)\\n return tuple(output_list)\",\n \"def directed_Hausdorff_hyperbox(b1,b2): \\n return max(0,np.max(np.hstack((b1.u-b2.u,b2.l-b1.l))))\",\n \"def calc_surface(u, v):\\n\\n # # Wavy surface\\n # surface = np.array([\\n # u,\\n # v,\\n # np.exp(- (u**2 + v**2) / 30) * np.cos(np.sqrt(u**2 + v**2))\\n # ])\\n\\n # Shere - {one_point}\\n surface = np.array([\\n 2 * u,\\n 2 * v,\\n 1 - u**2 - v**2\\n ]) / (1 + u**2 + v**2)\\n return (surface[0], surface[1], surface[2])\",\n \"def endpoints((u,v,o)):\\r\\n return { W : ((u,v+1), (u,v)),\\r\\n S : ((u+1,v), (u,v)) }[o]\",\n \"def cross_junctions(I, bounds, Wpts):\\n #--- FILL ME IN ---\\n\\n Ipts = np.zeros((2, 48))\\n\\n#parameters\\n alpha = 0.15 #typically 0.04 to 0.06\\n threshold = 1500 #default 2000\\n sigma = 2\\n ws = 12 #window size for saddle point\\n\\n#building Harris Detecter\\n I = I/255.0\\n gradx, grady = np.gradient(I)\\n IxIx = gaussian_filter(gradx*gradx,sigma)\\n IxIy = gaussian_filter(gradx*grady,sigma)\\n IyIy = gaussian_filter(grady*grady,sigma)\\n print(I.shape)\\n\\n #get harris score\\n cand_score = []\\n cand_index = []\\n cand = []\\n s_cand = []\\n\\n for j in range(len(I)):\\n for i in range(len(I[0])):\\n a11 = IxIx[j][i]\\n a12 = IxIy[j][i]\\n a21 = a12\\n a22 = IyIy[j][i]\\n A = np.array([[a11, a12],[a21, a22]])\\n ev0, ev1 = np.linalg.eigvals(A)\\n h_score = ev0*ev1 - alpha*(ev0+ev1)**2\\n cand_score.append(-h_score)\\n cand_index.append([i, j])\\n\\n #get the coordinates of the top 5000 scores\\n sorted_ind = np.argsort(cand_score)\\n sorted_score = np.sort(cand_score).tolist()\\n\\n for ind in sorted_ind[:threshold]:\\n cand.append(cand_index[ind])\\n s_cand = sorted_score[:threshold]\\n\\n\\n#clustering\\n #using homography to project candidate points to a up-front view\\n new_bbox = np.array([[0, 100, 100, 0],[0, 0, 80, 80]])\\n H = dlt_homography(bounds, new_bbox)\\n cand = np.array(cand).T\\n cand = np.vstack((cand, np.ones(cand.shape[1])))\\n Ho_cand = np.matmul(H,cand).T\\n for pt in Ho_cand:\\n pt[0] = pt[0]/pt[2]\\n pt[1] = pt[1]/pt[2]\\n Ho_cand = Ho_cand[:,:2]\\n Ho_cand = Ho_cand.tolist()\\n\\n #get rid of points that are not in the boundry\\n temp_Ho_cand = []\\n temp_s_cand = []\\n for i in range(len(Ho_cand)):\\n pt = Ho_cand[i]\\n if (pt[0]>=100) or (pt[0]<0) or (pt[1]>=80) or (pt[1]<0):\\n continue\\n else:\\n temp_Ho_cand.append(pt)\\n temp_s_cand.append(s_cand[i])\\n Ho_cand = np.array(temp_Ho_cand)\\n s_cand = temp_s_cand\\n #divide candidates into clusters\\n assignment = []\\n assignment_score = []\\n\\n #first put in the point that has the highest score\\n assignment.append([Ho_cand[0]])\\n assignment_score.append([s_cand[0]])\\n for i in range(len(Ho_cand)):\\n pt = Ho_cand[i]\\n dist = []\\n for c in assignment:\\n dist.append(np.linalg.norm(pt - c[0]))\\n if min(dist) > 6:\\n assignment.append([pt])\\n assignment_score.append([s_cand[i]])\\n\\n assignment = np.array(assignment)\\n\\n #assign points to clusters\\n for i in range(len(Ho_cand)):\\n pt = Ho_cand[i]\\n if (pt[0] == Ho_cand[0][0]) and (pt[1] == Ho_cand[0][1]):\\n continue\\n dist = []\\n for c in assignment:\\n dist.append(np.linalg.norm(pt - c[0]))\\n index = np.argsort(dist)[-1]\\n np.append(assignment[index], pt)\\n assignment_score[index].append(s_cand[i])\\n\\n #get centroids for each cluster\\n Ho_centroids = []\\n for i in range(len(assignment)):\\n cl = assignment[i]\\n cl = np.array(cl)\\n Ho_centroids.append([np.mean(cl.T[0]),np.mean(cl.T[1])])\\n assignment_score[i] = sum(assignment_score[i])\\n\\n print(len(assignment_score))\\n\\n Ho_centroids = np.array(Ho_centroids)\\n #get rid of edge points\\n\\n xmin = np.amin(Ho_centroids.T[0])\\n xmax = np.amax(Ho_centroids.T[0]) \\n ymin = np.amin(Ho_centroids.T[1])\\n ymax = np.amax(Ho_centroids.T[1])\\n\\n final_cand = []\\n final_score = []\\n for i in range(len(Ho_centroids)):\\n pt = Ho_centroids[i]\\n if (abs(pt[0] - xmin) <= 3) or (abs(pt[0] - xmax) <= 3) or (abs(pt[1] - ymin) <= 3) or (abs(pt[1] - ymax) <= 3):\\n continue\\n else:\\n final_cand.append(pt)\\n final_score.append(assignment_score[i])\\n print(\\\"Number of corner found: \\\")\\n print(len(final_cand))\\n\\n #get rid of fake corners\\n if (len(final_cand)>48):\\n ultimate_cand =[]\\n for ind in np.argsort(final_score)[:48]:\\n ultimate_cand.append(final_cand[ind])\\n final_cand = ultimate_cand\\n print(\\\"real corners count:\\\", len(ultimate_cand))\\n\\n\\n #sort the points\\n final_cand = np.array(final_cand)\\n y_sort_ind = np.argsort(final_cand.T[1])\\n final_cand = final_cand.tolist()\\n rows = []\\n for i in range(6):\\n row = []\\n for ind in y_sort_ind[i*8:(i+1)*8]:\\n row.append(final_cand[ind])\\n rows.append(row)\\n\\n ordered = []\\n for row in rows:\\n r = []\\n x_sort_ind = np.argsort(np.array(row).T[0])\\n for ind in x_sort_ind:\\n r.append(row[ind])\\n ordered.append(r)\\n\\n final_cand = []\\n for row in ordered:\\n for pt in row:\\n final_cand.append(pt)\\n \\n\\n\\n #get coordinates of the centroids in the original frame\\n Ho_centroids = np.array(final_cand)\\n\\n centroids = np.vstack((Ho_centroids.T, np.ones(Ho_centroids.shape[0])))\\n centroids = np.matmul(np.linalg.inv(H), centroids).T\\n for pt in centroids:\\n pt[0] = int(pt[0]/pt[2])\\n pt[1] = int(pt[1]/pt[2])\\n centroids = centroids[:,:2]\\n\\n#finding saddle points around the centroids\\n saddle_points = []\\n for pt in centroids:\\n img = I[int(pt[1]-ws):int(pt[1]+ws), int(pt[0]-ws):int(pt[0]+ws)]\\n saddle = saddle_point(img)\\n saddle = [saddle[0][0]+pt[0]-ws, saddle[1][0]+pt[1]-ws]\\n saddle_points.append(saddle)\\n\\n saddle_points = np.array(saddle_points)\\n #------------------\\n print(saddle_points.T)\\n return saddle_points.T\",\n \"def dndt2(jx, iy, h, n, u, v, dx, dy) :\\n p5 = np.float32(0.5)\\n depth_jm0im0 = h[jx, iy ]+n[jx, iy]\\n depth_jp1im0 = h[jx+1,iy] +n[jx+1,iy]\\n depth_jm1im0 = h[jx-1,iy] +n[jx-1,iy]\\n depth_jm0ip1 = h[jx, iy+1]+n[jx, iy+1]\\n depth_jm0im1 = h[jx, iy-1]+n[jx, iy-1]\\n \\n hx_jp1 = u[jx+1,iy]*(depth_jm0im0 + depth_jp1im0)*p5\\n hx_jm0 = u[jx, iy]*(depth_jm1im0 + depth_jm0im0)*p5\\n \\n \\n hy_ip1 = v[jx,iy+1]*(depth_jm0im0 + depth_jm0ip1)*p5\\n hy_im0 = v[jx,iy ]*(depth_jm0im1 + depth_jm0im0)*p5\\n \\n # assume u and v are zero on edge\\n dhx = (hx_jp1-hx_jm0)/dx#[jx,iy]\\n dhy = (hy_ip1-hy_im0)/dy#[jx,iy]\\n\\n \\n return ( -dhx-dhy )\",\n \"def GetEdgeToAdjacentFacesArray(self, p_int):\\n ...\",\n \"def get_inverse_2x2(u, v):\\n if not is_linearly_independent_2x2(u, v):\\n return\\n uv = get_uv(u, v)\\n iden = get_uv([1, 0],[0, 1])\\n a = np.zeros((2, 4))\\n for i in range(2):\\n for j in range(2):\\n a[i][j] = uv[i][j]\\n a[i][j+2] = iden[i][j]\\n\\n q = a[0][1] / a[1][1]\\n a[0] = a[0] - q * a[1]\\n\\n q = a[1][0] / a[0][0]\\n a[1] = a[1] - q * a[0]\\n\\n a[0] /= a[0][0]\\n\\n a[1] /= a[1][1]\\n\\n for i in range(2):\\n for j in range(2):\\n uv[i][j] = a[i][j+2]\\n return uv\",\n \"def check_uv_border_crossing(progress_controller=None):\\n if progress_controller is None:\\n progress_controller = ProgressControllerBase()\\n\\n # skip if this is a representation\\n v = staging.get(\\\"version\\\")\\n if v and Representation.repr_separator in v.take_name:\\n progress_controller.complete()\\n return\\n\\n all_meshes = pm.ls(type=\\\"mesh\\\")\\n mesh_count = len(all_meshes)\\n progress_controller.maximum = mesh_count\\n nodes_with_uvs_crossing_borders = []\\n\\n for node in all_meshes:\\n all_uvs = node.getUVs()\\n # before doing anything get all the uvs and skip if all of them are\\n # in the same UV quadrant (which is the wrong name, sorry!)\\n all_uvs_u = sorted(all_uvs[0])\\n all_uvs_v = sorted(all_uvs[1])\\n if int(all_uvs_u[0]) == int(all_uvs_u[-1]) and int(all_uvs_v[0]) == int(\\n all_uvs_v[-1]\\n ):\\n # skip this mesh\\n continue\\n\\n #\\n # Group uvs according to their UV shells\\n #\\n # The following method is 20-25% faster than using getUvShellsIds()\\n #\\n num_uvs = node.numUVs()\\n uv_ids = list(range(num_uvs))\\n\\n uv_shells_and_uv_ids = []\\n uv_shells_and_uv_coords = []\\n\\n i = 0\\n while len(uv_ids) and i < num_uvs + 1:\\n current_uv_id = uv_ids[0]\\n # the polyListComponentConversion takes 85% of the processing time\\n # of getting the uvShells here\\n shell_uv_group_ids = pm.polyListComponentConversion(\\n \\\"%s.map[%s]\\\" % (node.name(), current_uv_id), toUV=1, uvShell=1\\n )\\n\\n uv_shell_uv_ids = []\\n uv_shell_uv_coords = [[], []]\\n for uv_group_ids in shell_uv_group_ids:\\n if \\\":\\\" in uv_group_ids:\\n splits = uv_group_ids.split(\\\":\\\")\\n start_uv_id = int(splits[0].split(\\\"[\\\")[1])\\n end_uv_id = int(splits[1].split(\\\"]\\\")[0])\\n else:\\n splits = uv_group_ids.split(\\\"[\\\")\\n start_uv_id = int(splits[1].split(\\\"]\\\")[0])\\n end_uv_id = start_uv_id\\n\\n for j in range(start_uv_id, end_uv_id + 1):\\n uv_ids.remove(j)\\n uv_shell_uv_ids.append(j)\\n uv_shell_uv_coords[0].append(all_uvs[0][j])\\n uv_shell_uv_coords[1].append(all_uvs[1][j])\\n\\n # store the uv ids and uv coords in this shell\\n uv_shells_and_uv_ids.append(uv_shell_uv_ids)\\n uv_shells_and_uv_coords.append(uv_shell_uv_coords)\\n\\n # go to the next pseudo uv shell id\\n i += 1\\n\\n # now check all uvs per shell\\n try:\\n for uv_shell_uv_coords in uv_shells_and_uv_coords:\\n us = sorted(uv_shell_uv_coords[0])\\n vs = sorted(uv_shell_uv_coords[1])\\n\\n # check first and last u and v values\\n if int(us[0]) != int(us[-1]) or int(vs[0]) != int(vs[-1]):\\n # they are not equal it is crossing spaces\\n nodes_with_uvs_crossing_borders.append(node)\\n break\\n except (IndexError, RuntimeError) as e:\\n print(\\\"%s\\\\nnode: %s\\\" % (e, node))\\n raise RuntimeError()\\n\\n progress_controller.increment()\\n\\n progress_controller.complete()\\n if len(nodes_with_uvs_crossing_borders):\\n # get transform nodes\\n tra_nodes = list(map(lambda x: x.getParent(), nodes_with_uvs_crossing_borders))\\n pm.select(tra_nodes)\\n raise RuntimeError(\\n \\\"\\\"\\\"There are nodes with <b>UV-Shells</b> that are crossing\\n <b>UV BORDERS</b>:<br><br>%s\\\"\\\"\\\"\\n % \\\"<br>\\\".join(map(lambda x: x.name(), tra_nodes[:MAX_NODE_DISPLAY]))\\n )\",\n \"def wer(r, h):\\n #build the matrix\\n d = numpy.zeros((len(r)+1)*(len(h)+1), dtype=numpy.uint8).reshape((len(r)+1, len(h)+1))\\n for i in range(len(r)+1):\\n for j in range(len(h)+1):\\n if i == 0: d[0][j] = j\\n elif j == 0: d[i][0] = i\\n for i in range(1, len(r)+1):\\n for j in range(1, len(h)+1):\\n if r[i-1] == h[j-1]:\\n d[i][j] = d[i-1][j-1]\\n else:\\n substitute = d[i-1][j-1] + 1\\n insert = d[i][j-1] + 1\\n delete = d[i-1][j] + 1\\n d[i][j] = min(substitute, insert, delete)\\n result = float(d[len(r)][len(h)]) / len(r) * 100\\n result = str(\\\"%.2f\\\" % result) + \\\"%\\\"\\n return d[len(r)][len(h)]\\n #find out the manipulation steps\",\n \"def H_inside(self, r):\\n\\n return self.S * quad(self.H_integ_inside, 0, 1, args=(r,))[0]\",\n \"def get_NONuniform_polar_angle(xx, yy, rsq, angle_thresh = 3*np.pi/4, rsq_thresh = 0, pysub = 'hcp_999999'):\\n\\n hsv_angle = []\\n hsv_angle = np.ones((len(rsq), 3))\\n\\n ## calculate polar angle\\n polar_angle = np.angle(xx + yy * 1j)\\n\\n ## set normalized polar angle (0-1), and make nan irrelevant vertices\\n hsv_angle[:, 0] = np.nan \\n hsv_angle[:, 0][rsq > rsq_thresh] = ((polar_angle + np.pi) / (np.pi * 2.0))[rsq > rsq_thresh]\\n\\n ## normalize angle threshold for overepresentation\\n angle_thresh_norm = (angle_thresh + np.pi) / (np.pi * 2.0)\\n\\n ## get mid vertex index (diving hemispheres)\\n left_index = cortex.db.get_surfinfo(pysub).left.shape[0] \\n\\n ## set angles within threh interval to 0\\n ind_thresh = np.where((hsv_angle[:left_index, 0] > angle_thresh_norm) | (hsv_angle[:left_index, 0] < 1-angle_thresh_norm))[0]\\n hsv_angle[:left_index, 0][ind_thresh] = 0\\n\\n ## now take angles from RH (thus LVF) \\n #### ATENÇÃO -> minus sign to flip angles vertically (then order of colors same for both hemispheres) ###\\n # also normalize it\\n hsv_angle[left_index:, 0] = ((np.angle(-1*xx + yy * 1j) + np.pi) / (np.pi * 2.0))[left_index:]\\n\\n # set angles within threh interval to 0\\n ind_thresh = np.where((hsv_angle[left_index:, 0] > angle_thresh_norm) | (hsv_angle[left_index:, 0] < 1-angle_thresh_norm))[0]\\n hsv_angle[left_index:, 0][ind_thresh] = 0\\n\\n ## make final RGB array\\n rgb_angle = np.ones((len(rsq), 3))\\n rgb_angle[:] = np.nan\\n\\n rgb_angle[rsq > rsq_thresh] = colors.hsv_to_rgb(hsv_angle[rsq > rsq_thresh])\\n\\n return rgb_angle\",\n \"def pair_is_consistent(graph, u, v):\\n relations = get_all_relations(graph, u, v)\\n\\n if 1 != len(relations):\\n return False\\n\\n return list(relations)[0]\",\n \"def _upward_triangle_indicies(height=3):\\n return [(height-r,c) for r in range(height) for c in range(-abs(r),abs(r)+1)]\",\n \"def get_neighbors(size_i, size_j, ij):\\n i,j = ij\\n neighbors = set()\\n if i>0:\\n neighbors.add((i-1, j))\\n if j>0:\\n neighbors.add((i, j-1))\\n if i<size_i-1:\\n neighbors.add((i+1, j))\\n if j<size_j-1:\\n neighbors.add((i, j+1))\\n return neighbors\",\n \"def get_kequiv_by_face_quad(self, conj_faces):\\n ADJs=np.array([self.mb.get_adjacencies(face, 3) for face in self.all_faces])\\n\\n centroids=np.array([self.mtu.get_average_position([v]) for v in self.all_volumes])\\n\\n ADJsv=np.array([self.mb.get_adjacencies(face, 0) for face in self.all_faces])\\n\\n ks=self.mb.tag_get_data(self.perm_tag, self.all_volumes)\\n #vol_to_pos=dict(zip(M1.all_volumes,range(len(M1.all_volumes))))\\n vol_to_pos=dict(zip(self.all_volumes,range(len(self.all_volumes))))\\n cont=0\\n K_eq=[]\\n for f in self.all_faces:\\n adjs=ADJs[cont]\\n adjsv=ADJsv[cont]\\n cont+=1\\n if len(adjs)==2:\\n v1=adjs[0]\\n v2=adjs[1]\\n k1 = ks[vol_to_pos[v1]].reshape([3, 3])\\n k2 = ks[vol_to_pos[v2]].reshape([3, 3])\\n centroid1 = centroids[vol_to_pos[v1]]\\n centroid2 = centroids[vol_to_pos[v2]]\\n direction = centroid2 - centroid1\\n norm=np.linalg.norm(direction)\\n uni = np.absolute(direction/norm)\\n k1 = np.dot(np.dot(k1,uni), uni)\\n k2 = np.dot(np.dot(k2,uni), uni)\\n k_harm = (2*k1*k2)/(k1+k2)\\n\\n vertex_cent=np.array([self.mb.get_coords([np.uint64(a)]) for a in adjsv])\\n dx=max(vertex_cent[:,0])-min(vertex_cent[:,0])\\n dy=max(vertex_cent[:,1])-min(vertex_cent[:,1])\\n dz=max(vertex_cent[:,2])-min(vertex_cent[:,2])\\n if dx<0.001:\\n dx=1\\n if dy<0.001:\\n dy=1\\n if dz<0.001:\\n dz=1\\n area=dx*dy*dz\\n #area = self.mb.tag_get_data(self.area_tag, face, flat=True)[0]\\n #s_gr = self.gama*keq*(centroid2[2]-centroid1[2])\\n keq = k_harm*area/(self.mi*norm)\\n\\n K_eq.append(keq)\\n else:\\n K_eq.append(0.0)\\n self.mb.tag_set_data(self.k_eq_tag, self.all_faces, K_eq)\",\n \"def delaunay_triangle_calculation(rect, points):\\n # creating the subdiv class\\n subdiv = cv2.Subdiv2D(rect)\\n\\n # Insert points into subdiv class\\n for p in points:\\n subdiv.insert(p)\\n\\n triangle_list = subdiv.getTriangleList()\\n\\n delaunay_tri = []\\n pt = []\\n\\n for t in triangle_list:\\n pt.append((t[0], t[1]))\\n pt1 = (t[0], t[1])\\n\\n pt.append((t[2], t[3]))\\n pt2 = (t[2], t[3])\\n\\n pt.append((t[4], t[5]))\\n pt3 = (t[4], t[5])\\n\\n if in_rectangle(rect, pt1) and in_rectangle(rect, pt2) and in_rectangle(rect, pt3):\\n ind = []\\n # Get face-points (from 68 face detector) by coordinates\\n for j in range(0, 3):\\n for k in range(0, len(points)):\\n if abs(pt[j][0] - points[k][0]) < 1.0 and abs(pt[j][1] - points[k][1]) < 1.0:\\n ind.append(k)\\n\\n if len(ind) == 3:\\n delaunay_tri.append((ind[0], ind[1], ind[2]))\\n\\n pt = []\\n\\n return delaunay_tri\",\n \"def isOnInteriorSide(self, v):\\n n = self.normalVect()\\n return n.dotProduct(vector(self.vertices[0]) - vector(v)) > 0\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60242623","0.5956021","0.58149","0.5760208","0.56859523","0.5671715","0.56677574","0.5637607","0.5518257","0.54610336","0.54298204","0.5412329","0.5374091","0.53719383","0.53666955","0.53609663","0.53559095","0.5352723","0.5348312","0.5332194","0.5313079","0.53066266","0.53063536","0.5306167","0.52991766","0.5298575","0.5294784","0.52927667","0.5287437","0.5284519","0.5280897","0.52373105","0.5236531","0.5230369","0.5208892","0.5204126","0.5193869","0.5191506","0.5189048","0.5187058","0.51787573","0.51787573","0.5178666","0.51781046","0.51620483","0.5153319","0.5151723","0.51488316","0.5140851","0.5133694","0.51267576","0.51182437","0.5117786","0.5104923","0.5100794","0.5089226","0.50890696","0.5072547","0.50648797","0.5061375","0.5061191","0.5058663","0.50582576","0.5056204","0.50473297","0.50429595","0.5039808","0.5039118","0.50367063","0.5034148","0.5033745","0.5023111","0.501011","0.5006149","0.49869433","0.4986184","0.4973321","0.49610484","0.4953573","0.49452186","0.4944621","0.4944073","0.4938161","0.4925145","0.4912992","0.49127305","0.49110216","0.49103993","0.49082676","0.49051252","0.49013633","0.48967502","0.4895125","0.4895031","0.48943716","0.48933935","0.4887316","0.48822957","0.4878511","0.48617435"],"string":"[\n \"0.60242623\",\n \"0.5956021\",\n \"0.58149\",\n \"0.5760208\",\n \"0.56859523\",\n \"0.5671715\",\n \"0.56677574\",\n \"0.5637607\",\n \"0.5518257\",\n \"0.54610336\",\n \"0.54298204\",\n \"0.5412329\",\n \"0.5374091\",\n \"0.53719383\",\n \"0.53666955\",\n \"0.53609663\",\n \"0.53559095\",\n \"0.5352723\",\n \"0.5348312\",\n \"0.5332194\",\n \"0.5313079\",\n \"0.53066266\",\n \"0.53063536\",\n \"0.5306167\",\n \"0.52991766\",\n \"0.5298575\",\n \"0.5294784\",\n \"0.52927667\",\n \"0.5287437\",\n \"0.5284519\",\n \"0.5280897\",\n \"0.52373105\",\n \"0.5236531\",\n \"0.5230369\",\n \"0.5208892\",\n \"0.5204126\",\n \"0.5193869\",\n \"0.5191506\",\n \"0.5189048\",\n \"0.5187058\",\n \"0.51787573\",\n \"0.51787573\",\n \"0.5178666\",\n \"0.51781046\",\n \"0.51620483\",\n \"0.5153319\",\n \"0.5151723\",\n \"0.51488316\",\n \"0.5140851\",\n \"0.5133694\",\n \"0.51267576\",\n \"0.51182437\",\n \"0.5117786\",\n \"0.5104923\",\n \"0.5100794\",\n \"0.5089226\",\n \"0.50890696\",\n \"0.5072547\",\n \"0.50648797\",\n \"0.5061375\",\n \"0.5061191\",\n \"0.5058663\",\n \"0.50582576\",\n \"0.5056204\",\n \"0.50473297\",\n \"0.50429595\",\n \"0.5039808\",\n \"0.5039118\",\n \"0.50367063\",\n \"0.5034148\",\n \"0.5033745\",\n \"0.5023111\",\n \"0.501011\",\n \"0.5006149\",\n \"0.49869433\",\n \"0.4986184\",\n \"0.4973321\",\n \"0.49610484\",\n \"0.4953573\",\n \"0.49452186\",\n \"0.4944621\",\n \"0.4944073\",\n \"0.4938161\",\n \"0.4925145\",\n \"0.4912992\",\n \"0.49127305\",\n \"0.49110216\",\n \"0.49103993\",\n \"0.49082676\",\n \"0.49051252\",\n \"0.49013633\",\n \"0.48967502\",\n \"0.4895125\",\n \"0.4895031\",\n \"0.48943716\",\n \"0.48933935\",\n \"0.4887316\",\n \"0.48822957\",\n \"0.4878511\",\n \"0.48617435\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62999815"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21964,"cells":{"query":{"kind":"string","value":"FNV1 64bit hash function Implement this, and/or DJB2."},"document":{"kind":"string","value":"def fnv1(self, key):\n # hash = 0xff\n hash = 0xcbf29ce484222325\n for n in key.encode():\n # print(n)\n hash = hash ^ n\n hash = hash * 0x100000001b3\n\n # print(hash)\n return hash"},"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 fnv1(self, key, seed=0):\n # def fnv1(self, key):\n\n # Your code here\n \"\"\"\n Returns: The FNV-1 hash (64-bit) of a given string. \n \"\"\"\n #Constants : Fails the tests\n # FNV_prime = 1099511628211\n # offset_basis = 14695981039346656037\n\n # #FNV-1a Hash Function\n # hash = offset_basis + seed\n # # hash = offset_basis\n # for c in key:\n # hash = hash * FNV_prime\n # hash = hash ^ ord(c)\n # return hash\n\n \"\"\"\n Returns: The FNV-1a (alternate) hash of a given string\n \"\"\"\n # #Constants : Passes the tests\n # FNV_prime = 1099511628211\n # offset_basis = 14695981039346656037\n\n # #FNV-1a alternate Hash Function\n # hash = offset_basis + seed\n # for c in key:\n # hash = hash ^ ord(c)\n # hash = hash * FNV_prime\n # return hash","def HashAlgorithm(self) -> _n_7_t_0:","def FNV1Hash(filename):\n \n FNV1_32_INIT = 0x811c9dc5\n FNV1_PRIME_32 = 16777619\n\n lowerName = filename.lower()\n \n _hash = FNV1_32_INIT\n uint32_max = 2 ** 32\n \n for c in lowerName:\n _hash = (_hash * FNV1_PRIME_32) % uint32_max\n _hash = _hash ^ ord(c)\n return format(_hash, 'x')","def SHA1(self) -> _n_0_t_3[_n_0_t_9]:","def hash64bits(*args):\n # 64 bits hexdigest\n h = hashlib.sha1(bytes(repr(args), \"utf-8\")).hexdigest()[:16]\n # Convert to an integer and return\n return int(h, 16)","def hash_1(self):\n return self.unpack_qword(0x18)","def fnvhash(a): \n h = 2166136261 \n for i in a: \n t = (h * 16777619) & 0xffffffffL \n h = t ^ i \n return h","def _hash_djb2(self, key):\n # OPTIONAL STRETCH: Research and implement DJB2\n hash_grotto = 5381\n for k in key:\n hash_grotto = ((hash_grotto << 5) + hash_grotto) + ord(k)\n return hash_grotto & 0xFFFFFFFF","def _hash_function(self, x):\n return hashlib.sha1(x).hexdigest()","def _hash(self, key):\n if self.function == 'fnv':\n h = 2166136261\n for i in range(len(key)):\n h = (h * 16777619) ^ ord(key[i])\n return h\n elif self.function == 'add':\n h = 0\n for i in range(len(key)):\n h += ord(key[i])\n return h","def _hash(self):\r\n MAX = sys.maxint\r\n MASK = 2 * MAX + 1\r\n n = len(self)\r\n h = 1927868237 * (n + 1)\r\n h &= MASK\r\n for x in self:\r\n hx = hash(x)\r\n h ^= (hx ^ (hx << 16) ^ 89869747) * 3644798167\r\n h &= MASK\r\n h = h * 69069 + 907133923\r\n h &= MASK\r\n if h > MAX:\r\n h -= MASK + 1\r\n if h == -1:\r\n h = 590923713\r\n return h","def get_num_slots(self):\n Return the load factor for this hash table.\n\n Implement this.\n \"\"\"\n return self.elements / self.capacity\n\n\n def fnv1(self, key):\n \"\"\"\n FNV-1 Hash, 64-bit\n\n Implement this, and/or DJB2.pyy\n \"\"\"\n\n # Your code here\n\n\n def djb2(self, key):\n \"\"\"\n DJB2 hash, 32-bit\n\n Implement this, and/or FNV-1.\n \"\"\"\n # Your code here\n\n\n def hash_index(self, key):\n \"\"\"\n Take an arbitrary key and return a valid integer index\n between within the storage capacity of the hash table.\n \"\"\"\n #return self.fnv1(key) % self.capacity\n<<<<<<< Updated upstream\n return self.djb2(key) % self.capacity\n=======\n return self.djb2(key) % len(self.storage)\n>>>>>>> Stashed changes\n\n def put(self, key, value):\n \"\"\"\n Store the value with the given key.\n\n Hash collisions should be handled with Linked List Chaining.\n\n Implement this.\n \"\"\"\n<<<<<<< Updated upstream\n # Your code here\n=======\n # need to account for if the key value is the same \n\n i = self.hash_index(key)\n if not self.storage[i]:\n hte = HashTableEntry(key, value)\n self.storage[i] = hte\n self.elements += 1\n hte.head = HashTableEntry(key, value)\n elif self.storage[i] and self.storage[i].key != key:\n self.storage[i].insert_at_head(HashTableEntry(key, value))\n>>>>>>> Stashed changes\n\n\n def delete(self, key):\n \"\"\"\n Remove the value stored with the given key.\n\n Print a warning if the key is not found.\n\n Implement this.\n \"\"\"\n<<<<<<< Updated upstream\n # Your code here\n=======\n i = self.hash_index(key)\n node = self.storage[i]\n prev = None\n if node.key == key:\n self.storage[i] = node.next\n return\n while node != None:\n if node.key == key:\n prev.next = node.next\n self.storage[i].next = None\n return\n prev = node\n node = node.next\n self.elements -= 1\n return\n>>>>>>> Stashed changes\n\n\n def get(self, key):\n \"\"\"\n Retrieve the value stored with the given key.\n\n Returns None if the key is not found.\n\n Implement this.\n \"\"\"\n<<<<<<< Updated upstream\n # Your code here\n=======\n # - find the index in the hash table for the key\n i = self.hash_index(key)\n # - search the list for that key\n if not self.storage[i]:\n return None\n else:\n if self.storage[i].find_key(key) == key:\n return self.storage[i].value\n>>>>>>> Stashed changes\n\n\n def resize(self, new_capacity):\n \"\"\"\n Changes the capacity of the hash table and\n rehashes all key/value pairs.\n\n Implement this.\n \"\"\"\n<<<<<<< Updated upstream\n # Your code here\n=======\n prev_storage = self.storage\n self.capacity = new_cap\n self.storage = [None] * new_cap\n for i in range(len(prev_storage)):\n prev = prev_storage[i]\n if prev:\n while prev:\n if prev.key:\n self.put(prev.key, prev.value)\n prev = prev.next\n\n>>>>>>> Stashed changes\n\n\n\nif __name__ == \"__main__\":\n ht = HashTable(8)\n\n ht.put(\"line_1\", \"'Twas brillig, and the slithy toves\")\n ht.put(\"line_2\", \"Did gyre and gimble in the wabe:\")\n ht.put(\"line_3\", \"All mimsy were the borogoves,\")\n ht.put(\"line_4\", \"And the mome raths outgrabe.\")\n ht.put(\"line_5\", '\"Beware the Jabberwock, my son!')\n ht.put(\"line_6\", \"The jaws that bite, the claws that catch!\")\n ht.put(\"line_7\", \"Beware the Jubjub bird, and shun\")\n ht.put(\"line_8\", 'The frumious Bandersnatch!\"')\n ht.put(\"line_9\", \"He took his vorpal sword in hand;\")\n ht.put(\"line_10\", \"Long time the manxome foe he sought--\")\n ht.put(\"line_11\", \"So rested he by the Tumtum tree\")\n ht.put(\"line_12\", \"And stood awhile in thought.\")\n\n print(\"\")\n\n # Test storing beyond capacity\n for i in range(1, 13):\n print(ht.get(f\"line_{i}\"))\n\n # Test resizing\n old_capacity = ht.get_num_slots()\n ht.resize(ht.capacity * 2)\n new_capacity = ht.get_num_slots()\n\n print(f\"\\nResized from {old_capacity} to {new_capacity}.\\n\")\n\n # Test if data intact after resizing\n for i in range(1, 13):\n print(ht.get(f\"line_{i}\"))\n\n print(\"\")","def _hash_function(self, n):\n # Get the mask for this n, or make a new one of 32 random bits.\n mask = self._memomask.get(n)\n if mask is None:\n random.seed(n ^ self.seed_mask)\n mask = self._memomask[n] = int(random.getrandbits(32))\n # Now return a function that uses Jenkins Hash\n #\n def somehash(x):\n return hashlittle(x, mask)\n return somehash","def hash(self) -> bytes:","def hash_functions(self):\n pass","def HashValue(self) -> _n_0_t_3[_n_0_t_9]:","def getHashLfn(lfn):\n return hashlib.sha224(lfn).hexdigest()","def _hash(self, key):\n # OPTIONAL STRETCH: You may replace the Python hash with DJB2 as a stretch goal\n # return hash(key)\n return self._hash_djb2(key)","def hash(x) -> int:\n pass","def _hash_function(self, key):\n h = 0\n a = 31\n table_size = self.size\n for i in range(len(key)):\n h = (h * a + ord(key[i])) % table_size\n return h","def hash(self) -> str:\r\n ...","def _hash(self, key):\n\n return long(hashlib.md5(key).hexdigest(), 16)","def _hash(self, key):\n\n return long(hashlib.md5(key).hexdigest(), 16)","def _hash_function(self, k):\n return (hash(k) * self._scale + self._shift) % self._prime % len(self._table)","def unique_hash(self):\n raise NotImplementedError(\"unique_hash Method not implemented\")","def hash_2(self):\n return self.unpack_qword(0x20)","def fnv_1a(key: KeyT, seed: int = 0) -> int:\n max64mod = UINT64_T_MAX + 1\n hval = (14695981039346656037 + (31 * seed)) % max64mod\n fnv_64_prime = 1099511628211\n tmp = list(key) if not isinstance(key, str) else list(map(ord, key))\n for t_str in tmp:\n hval ^= t_str\n hval *= fnv_64_prime\n hval %= max64mod\n return hval","def __hash__(self):\n hash_value = 0\n \n # approximate_online_count\n hash_value ^= self.approximate_online_count\n \n # approximate_user_count\n hash_value ^= self.approximate_user_count << 12\n \n # description\n description = self.description\n if (description is not None):\n hash_value ^= hash(description)\n \n # discovery_splash\n hash_value ^= hash(self.discovery_splash)\n \n # emojis\n emojis = self.emojis\n hash_value ^= len(emojis) << 1\n for emoji in emojis.values():\n hash_value ^= hash(emoji)\n \n # features\n features = self.features\n hash_value ^= len(features) << 5\n for feature in features:\n hash_value ^= hash(feature)\n \n # icon\n hash_value ^= hash(self.icon)\n \n # id\n hash_value ^= self.id\n \n # invite_splash\n hash_value ^= hash(self.invite_splash)\n \n # stickers\n stickers = self.stickers\n hash_value ^= len(stickers) << 9\n for sticker in stickers.values():\n hash_value ^= hash(sticker)\n \n # name\n name = self.name\n if (description is None) or (description != name):\n hash_value ^= hash(name)\n \n return hash_value","def __hash__(self):\n base = 1\n h = 0\n for l in self.data:\n for i in l:\n if i:\n h += base\n base *= 2\n return hash(h)","def calHash(n, m):\n return int(m*BloomFilter.ln2/n)","def djb2(self, key):\n # Your code here\n hash = 5381\n for c in key:\n hash = (hash*33)+ ord(c)\n return hash","def compute_dhash(im):\n return imagehash.dhash(ensure_pil(im))","def djb2_hash(key):\n\n hash = 5381\n\n for i in range(len(key)):\n hash = ((hash << 5) + hash) + ord(key[i])\n\n return hash","def hash_function_1(key):\n hash = 0\n for i in key:\n hash = hash + ord(i)\n return hash","def __hash__(self):\n x = xxhash.xxh64()\n x.update(self.puzzle)\n return x.intdigest()","def h_python(key, N):\n return hash(key) % N","def hash_djb2(string):\n hashval = ctypes.c_uint(5381)\n for char in string:\n hashval.value = ((hashval.value << 5) + hashval.value) + ord(char)\n return hashval.value & 0x7FFFFFFF","def djb2(self, key):\n\n hash = 5381\n for n in key.encode():\n # hash = ((hash << 5) + hash) + n\n hash = hash * 33 + n\n\n return hash\n # return hash & 0xFFFFFFFF","def _Hash(self):\n fullhash = util.PrefixHash(self.key_bytes)\n return util.Base64WSEncode(fullhash[:constants.KEY_HASH_SIZE])","def _calc_hash(self) -> None:\n self.image = Image.open(self.path)\n self.image = self.image.convert(\"L\")\n self.image = self.image.resize((self.width, self.height), Image.ANTIALIAS)\n lpixels = list(self.image.getdata())\n self.hash = \"0b\"\n for i, pixel in enumerate(lpixels):\n if (i + 1) % self.width == 0 and i != 0:\n continue\n if pixel < lpixels[i + 1]:\n self.hash += \"1\"\n continue\n self.hash += \"0\"\n self.hash_hex = DHash.bin2hex(self.hash)","def hash(self):\n raise NotImplementedError() # To be subclassed","def internal_hash(self): \n return hash(tuple(sorted(self.hashtriples())))","def hash_key(self):","def pre_compute_hashes(s, M1, M2, X):\n n = len(s)\n h1 = [0 for _ in range(n+1)]\n h2 = [0 for _ in range(n+1)]\n for i in range(1, n+1):\n ch = ord(s[i-1])\n h1[i] = (X*h1[i-1] + ch) % M1\n h2[i] = (X*h2[i-1] + ch) % M2\n return h1, h2","def _Hash(self):\n fullhash = util.Hash(util.IntToBytes(len(self.key_bytes)), self.key_bytes)\n return util.Encode(fullhash[:keyczar.KEY_HASH_SIZE])","def SHA256(self) -> _n_0_t_3[_n_0_t_9]:","def nice_hash(*args):\n h = sha1()\n for item in args:\n h.update(unicode(item))\n return b32encode(h.digest())","def calc_statistics_hash(self) -> bytes:\n return b\"somehash\"","def hash_function_2(key):\n hash = 0\n index = 0\n for i in key:\n hash = hash + (index + 1) * ord(i)\n index = index + 1\n return hash","def get_hash(self):\r\n return","def calc_statistics_hash(self) -> bytes:\n raise NotImplementedError()","def __hash__(self) -> int:\r\n return hash((hash(self.data), self.version, self.compatibilityLimit,\r\n self.script, self.seriesSignature, self.pha,\r\n self.identityInfo, self.message))","def sdbm_hash(name):\n ret = 0\n for ii in name:\n ret = (ret * 65599 + ord(ii)) & 0xFFFFFFFF\n return hex(ret)","def elf_hash(key):\n\n hash = 0\n x = 0\n\n for i in range(len(key)):\n hash = (hash << 4) + ord(key[i])\n x = hash & 0xF0000000\n\n if x != 0:\n hash **= (x >24)\n\n hash &= ~x\n\n return (hash & 0x7FFFFFFF)","def _hash(self, hashKey):\n return hashKey % self.size","def hash_function(s):\n\n # O(n) over the key length\n # O(1) over the HASH_DATA_SIZE\n\n bytes_list = s.encode()\n\n total = 0\n\n\n for b in bytes_list: # O(n) over the length of the key\n total += b\n\n\n total &= 0xffffffff # 32 bit (8 f's)\n\n return total","def __hash__(self):\n hash_value = 0\n \n # avatar\n hash_value ^= hash(self.avatar)\n \n # boosts_since\n boosts_since = self.boosts_since\n if (boosts_since is not None):\n hash_value ^= hash(boosts_since)\n \n # flags\n hash_value ^= self.flags\n \n # joined_at\n joined_at = self.joined_at\n if (joined_at is not None):\n hash_value ^= hash(joined_at)\n \n # nick\n nick = self.nick\n if (nick is not None):\n hash_value ^= hash(nick)\n \n # pending\n hash_value ^= self.pending\n \n # role_ids\n role_ids = self.role_ids\n if (role_ids is not None):\n hash_value ^= len(role_ids) << 4\n for role_id in role_ids:\n hash_value ^= role_id\n \n # timed_out_until\n timed_out_until = self.timed_out_until\n if (timed_out_until is not None):\n hash_value ^= hash(timed_out_until)\n \n return hash_value","def hash_function_2(key):\n\n hash = 0\n index = 0\n for i in key:\n hash = hash + (index + 1) * ord(i)\n index = index + 1\n return hash","def hash_function_2(key):\n\n hash = 0\n index = 0\n for i in key:\n hash = hash + (index + 1) * ord(i)\n index = index + 1\n return hash","def hash_function_2(key):\n\n hash = 0\n index = 0\n for i in key:\n hash = hash + (index + 1) * ord(i)\n index = index + 1\n return hash","def seed_hash(*args):\n args_str = str(args)\n return int(hashlib.md5(args_str.encode(\"utf-8\")).hexdigest(), 16) % (2**31)","def test_default_hash_colision(self):\n h1 = default_fnv_1a(\"gMPflVXtwGDXbIhP73TX\", 5)\n h2 = default_fnv_1a(\"LtHf1prlU1bCeYZEdqWf\", 5)\n\n self.assertEqual(h1[0], h2[0]) # these should match\n for i in range(1, 5):\n self.assertNotEqual(h1[i], h2[i])","def __Hash(self):\n return self._Hash()","def hexdigest(self, *args, **kwargs): # real signature unknown\n pass","def hexdigest(self, *args, **kwargs): # real signature unknown\n pass","def hexdigest(self, *args, **kwargs): # real signature unknown\n pass","def hexdigest(self, *args, **kwargs): # real signature unknown\n pass","def hexdigest(self, *args, **kwargs): # real signature unknown\n pass","def hexdigest(self, *args, **kwargs): # real signature unknown\n pass","def customHashFunc(str):\n return sum(ord(chr) for chr in str)%128","def __hash__(self):\n return hash((self.SYMBOL, self._.hash_parameters))","def computeHash(string):\n\tif isBytes(string):\n\t\tstring = string.decode(\"latin-1\")\n\thash_ = 63689\n\tfor char in string:\n\t\thash_ = hash_ * 378551 + ord(char)\n\treturn hash_ % 65536","def computePerceptualHash(img, length=64):\n img_resize = cv2.resize(img, (32, 32))\n img_DCT = cv2.dct(img_resize)\n\n if length==64:\n low_freq_dct = img_DCT[1:9, 1:9]\n elif length==32:\n low_freq_dct = img_DCT[1:7, 1:7]\n\n avg = np.mean(low_freq_dct)\n img_hash = np.where(low_freq_dct > avg, 1, 0)\n hash = \"\".join(map(str, img_hash.flatten()[0:length]))\n return hash","def __hash__(self):\n return hash(self.hash)","def useOldServerHashFunction():\r\n global serverHashFunction\r\n serverHashFunction = crc32","def djb_hash(s):\n h = 5381\n for c in s:\n h = h * 33 + ord(c)\n return h & 0xffffffff","def hash(self):\n return Hash.dhash(bytes(self))","def current_hash(self):","def __hash__(self):\n hash_value = 0\n \n # required\n hash_value ^= self.required << 14\n \n # title\n hash_value ^= hash(self.title)\n \n # type\n hash_value ^= hash(self.type)\n \n # values\n values = self.values\n if (values is not None):\n hash_value ^= len(values)\n \n for value in values:\n hash_value ^= hash(value)\n \n return hash_value","def __hash__(self):\n Name._hashes_used += 1\n if self._name is None:\n return 0\n value = ord(self._name[0]) << 7\n for char in self._name:\n value = c_mul(1000003, value) ^ ord(char)\n value = value ^ len(self._name)\n if value == -1:\n value = -2\n # The result is trimmed down to 31 bits (plus a sign bit) to give\n # consistent results on 32 and 64 bit systems\n # Otherwise hash() will implicitly do this based on the Python build\n # see https://docs.python.org/3/reference/datamodel.html#object.__hash__\n value = value % 0b0111_1111_1111_1111_1111_1111_1111_1111\n return value","def h(x):\n\n hasher = hashlib.sha256()\n hasher.update(x)\n return hasher.digest()","def badhash(x):\n x = (((x >> 16) ^ x) * 0x045d9f3b) & 0xFFFFFFFF\n x = (((x >> 16) ^ x) * 0x045d9f3b) & 0xFFFFFFFF\n x = ((x >> 16) ^ x) & 0xFFFFFFFF\n return x","def hash_128_bit_pass(passwd):\n h = hashlib.sha256()\n h.update(passwd)\n return h.hexdigest()[:16]","def djb2(self, key):\n # Your code here\n # https://stackoverflow.com/questions/1579721/why-are-5381-and-33-so-important-in-the-djb2-algorithm \n hash = 5381\n bytes_to_hash = key.encode() \n\n for byte in bytes_to_hash:\n # << is a bitwise operator; in this case, it shifts the \"bits\" of `hash` left by 5 \n hash = ((hash << 5) + byte)\n \n # for x in key: \n # # << is a bitwise operator; in this case, it shifts the \"bits\" of `hash` left by 5 \"bits\"\n # hash = (( hash << 5) + hash) + ord(x) # hash + 33 + ord(x)\n \n return hash","def __hash__(self) -> int:","def test_12_multihash(self):\n self.base_12_multihash(\"sha256\")\n if sha512_supported:\n self.base_12_multihash(\"sha512_256\")","def get_data_hash(args):\n pass","def hashing_info(string):#KEY HASHING FUNCTION\n nodeInfo = string.encode('utf-8')\n\n #md5 -> 2^7 = 128 bits\n hash_object = hashlib.md5()\n hash_object.update(nodeInfo)\n\n tmp = hash_object.hexdigest()\n tmp = int(tmp,16)\n\n result = tmp >> (128-16)\n return result","def strongHashFunction(self):\n\t\treturn self._strongHashFunction","def hash_fn(x):\r\n # Debug.\r\n counter = Counter.get_default()\r\n count = counter.count()\r\n if count % DEBUG_FREQ == 0:\r\n logger.debug(\">> (hash_fn start) Node counter is: {}.\".format(count))\r\n\r\n hashed = hash(x.tostring())\r\n\r\n return hashed","def hash_functions(self):\n def hash_factory(n):\n return lambda x: hash(\"salt\" + str(n) + str(x) + \"salt\")\n return [ hash_factory(_) for _ in range(self.dim) ]","def r_soft_hash(x):\n if abs(x) < 1e-9:return 0\n # round it to some number of bits\n b = ns.round(ns.log(abs(x)) / ns.log(2))\n gran = 2**(b-30)\n return ns.round(x / gran) * gran","def __polynomial_hash(self, s, base = 31, max_size=168):\r\n digest = 0\r\n max_size = 168\r\n for c in s: digest = base * digest + ord(c)\r\n digest &= 2 ** max_size - 1 \r\n return hex(digest).rstrip('L')","def hash(self, key):\n return self._hash_function(key) % self.size # Modular hashing","def hash(self, oid):\n data = self.family_name + self.name +\\\n self.date_of_birth + self.date_of_issue +\\\n self.date_of_expiry + self.issuing_country +\\\n self.issuing_authority + self.license_number +\\\n \"\".join(self.categories_of_vehicles) +\\\n str(self.number_of_entries)\n if oid == 'id-sha1':\n digest = hashes.Hash(hashes.SHA1(), backend=default_backend())\n digest.update(data.encode())\n return digest.finalize()\n elif oid == 'id-sha224':\n digest = hashes.Hash(hashes.SHA224(), backend=default_backend())\n digest.update(data.encode())\n return digest.finalize()\n elif oid == 'id-sha256':\n digest = hashes.Hash(hashes.SHA256(), backend=default_backend())\n digest.update(data.encode())\n return digest.finalize()\n elif oid == 'id-sha384':\n digest = hashes.Hash(hashes.SHA384(), backend=default_backend())\n digest.update(data.encode())\n return digest.finalize()\n elif oid == 'id-sha512':\n digest = hashes.Hash(hashes.SHA512(), backend=default_backend())\n digest.update(data.encode())\n return digest.finalize()\n else:\n print('ERROR: Hash algorithm not implemented.')\n sys.exit(1)","def _hash(self, string, hash_type):\n hash_types = {\n 'TABLE_OFFSET': 0,\n 'HASH_A': 1,\n 'HASH_B': 2,\n 'TABLE': 3\n }\n seed1 = 0x7FED7FED\n seed2 = 0xEEEEEEEE\n\n for ch in string.upper():\n if not isinstance(ch, int): ch = ord(ch)\n value = self.encryption_table[(hash_types[hash_type] << 8) + ch]\n seed1 = (value ^ (seed1 + seed2)) & 0xFFFFFFFF\n seed2 = ch + seed1 + seed2 + (seed2 << 5) + 3 & 0xFFFFFFFF\n\n return seed1","def concatHash(h1: int, h2: int, len2: int, mod=10**11 + 7, base=1313131) -> int:\r\n return (h1 * pow(base, len2, mod) + h2) % mod","def test_hash(self):\n ffs = get_available_force_fields()\n\n for ff1, ff2 in itertools.combinations(ffs, 2):\n assert hash(ff1) != hash(ff2)","def soft_hash(p):\n return tuple(map(r_soft_hash, p))","def hasher((x1, y1), (x0, y0)=(0,0)):\n return _point_hash((x0, y0)) ^ _point_hash((x0, y1)) ^ _point_hash((x1, y0)) ^ _point_hash((x1, y1))"],"string":"[\n \"def fnv1(self, key, seed=0):\\n # def fnv1(self, key):\\n\\n # Your code here\\n \\\"\\\"\\\"\\n Returns: The FNV-1 hash (64-bit) of a given string. \\n \\\"\\\"\\\"\\n #Constants : Fails the tests\\n # FNV_prime = 1099511628211\\n # offset_basis = 14695981039346656037\\n\\n # #FNV-1a Hash Function\\n # hash = offset_basis + seed\\n # # hash = offset_basis\\n # for c in key:\\n # hash = hash * FNV_prime\\n # hash = hash ^ ord(c)\\n # return hash\\n\\n \\\"\\\"\\\"\\n Returns: The FNV-1a (alternate) hash of a given string\\n \\\"\\\"\\\"\\n # #Constants : Passes the tests\\n # FNV_prime = 1099511628211\\n # offset_basis = 14695981039346656037\\n\\n # #FNV-1a alternate Hash Function\\n # hash = offset_basis + seed\\n # for c in key:\\n # hash = hash ^ ord(c)\\n # hash = hash * FNV_prime\\n # return hash\",\n \"def HashAlgorithm(self) -> _n_7_t_0:\",\n \"def FNV1Hash(filename):\\n \\n FNV1_32_INIT = 0x811c9dc5\\n FNV1_PRIME_32 = 16777619\\n\\n lowerName = filename.lower()\\n \\n _hash = FNV1_32_INIT\\n uint32_max = 2 ** 32\\n \\n for c in lowerName:\\n _hash = (_hash * FNV1_PRIME_32) % uint32_max\\n _hash = _hash ^ ord(c)\\n return format(_hash, 'x')\",\n \"def SHA1(self) -> _n_0_t_3[_n_0_t_9]:\",\n \"def hash64bits(*args):\\n # 64 bits hexdigest\\n h = hashlib.sha1(bytes(repr(args), \\\"utf-8\\\")).hexdigest()[:16]\\n # Convert to an integer and return\\n return int(h, 16)\",\n \"def hash_1(self):\\n return self.unpack_qword(0x18)\",\n \"def fnvhash(a): \\n h = 2166136261 \\n for i in a: \\n t = (h * 16777619) & 0xffffffffL \\n h = t ^ i \\n return h\",\n \"def _hash_djb2(self, key):\\n # OPTIONAL STRETCH: Research and implement DJB2\\n hash_grotto = 5381\\n for k in key:\\n hash_grotto = ((hash_grotto << 5) + hash_grotto) + ord(k)\\n return hash_grotto & 0xFFFFFFFF\",\n \"def _hash_function(self, x):\\n return hashlib.sha1(x).hexdigest()\",\n \"def _hash(self, key):\\n if self.function == 'fnv':\\n h = 2166136261\\n for i in range(len(key)):\\n h = (h * 16777619) ^ ord(key[i])\\n return h\\n elif self.function == 'add':\\n h = 0\\n for i in range(len(key)):\\n h += ord(key[i])\\n return h\",\n \"def _hash(self):\\r\\n MAX = sys.maxint\\r\\n MASK = 2 * MAX + 1\\r\\n n = len(self)\\r\\n h = 1927868237 * (n + 1)\\r\\n h &= MASK\\r\\n for x in self:\\r\\n hx = hash(x)\\r\\n h ^= (hx ^ (hx << 16) ^ 89869747) * 3644798167\\r\\n h &= MASK\\r\\n h = h * 69069 + 907133923\\r\\n h &= MASK\\r\\n if h > MAX:\\r\\n h -= MASK + 1\\r\\n if h == -1:\\r\\n h = 590923713\\r\\n return h\",\n \"def get_num_slots(self):\\n Return the load factor for this hash table.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n return self.elements / self.capacity\\n\\n\\n def fnv1(self, key):\\n \\\"\\\"\\\"\\n FNV-1 Hash, 64-bit\\n\\n Implement this, and/or DJB2.pyy\\n \\\"\\\"\\\"\\n\\n # Your code here\\n\\n\\n def djb2(self, key):\\n \\\"\\\"\\\"\\n DJB2 hash, 32-bit\\n\\n Implement this, and/or FNV-1.\\n \\\"\\\"\\\"\\n # Your code here\\n\\n\\n def hash_index(self, key):\\n \\\"\\\"\\\"\\n Take an arbitrary key and return a valid integer index\\n between within the storage capacity of the hash table.\\n \\\"\\\"\\\"\\n #return self.fnv1(key) % self.capacity\\n<<<<<<< Updated upstream\\n return self.djb2(key) % self.capacity\\n=======\\n return self.djb2(key) % len(self.storage)\\n>>>>>>> Stashed changes\\n\\n def put(self, key, value):\\n \\\"\\\"\\\"\\n Store the value with the given key.\\n\\n Hash collisions should be handled with Linked List Chaining.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n<<<<<<< Updated upstream\\n # Your code here\\n=======\\n # need to account for if the key value is the same \\n\\n i = self.hash_index(key)\\n if not self.storage[i]:\\n hte = HashTableEntry(key, value)\\n self.storage[i] = hte\\n self.elements += 1\\n hte.head = HashTableEntry(key, value)\\n elif self.storage[i] and self.storage[i].key != key:\\n self.storage[i].insert_at_head(HashTableEntry(key, value))\\n>>>>>>> Stashed changes\\n\\n\\n def delete(self, key):\\n \\\"\\\"\\\"\\n Remove the value stored with the given key.\\n\\n Print a warning if the key is not found.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n<<<<<<< Updated upstream\\n # Your code here\\n=======\\n i = self.hash_index(key)\\n node = self.storage[i]\\n prev = None\\n if node.key == key:\\n self.storage[i] = node.next\\n return\\n while node != None:\\n if node.key == key:\\n prev.next = node.next\\n self.storage[i].next = None\\n return\\n prev = node\\n node = node.next\\n self.elements -= 1\\n return\\n>>>>>>> Stashed changes\\n\\n\\n def get(self, key):\\n \\\"\\\"\\\"\\n Retrieve the value stored with the given key.\\n\\n Returns None if the key is not found.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n<<<<<<< Updated upstream\\n # Your code here\\n=======\\n # - find the index in the hash table for the key\\n i = self.hash_index(key)\\n # - search the list for that key\\n if not self.storage[i]:\\n return None\\n else:\\n if self.storage[i].find_key(key) == key:\\n return self.storage[i].value\\n>>>>>>> Stashed changes\\n\\n\\n def resize(self, new_capacity):\\n \\\"\\\"\\\"\\n Changes the capacity of the hash table and\\n rehashes all key/value pairs.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n<<<<<<< Updated upstream\\n # Your code here\\n=======\\n prev_storage = self.storage\\n self.capacity = new_cap\\n self.storage = [None] * new_cap\\n for i in range(len(prev_storage)):\\n prev = prev_storage[i]\\n if prev:\\n while prev:\\n if prev.key:\\n self.put(prev.key, prev.value)\\n prev = prev.next\\n\\n>>>>>>> Stashed changes\\n\\n\\n\\nif __name__ == \\\"__main__\\\":\\n ht = HashTable(8)\\n\\n ht.put(\\\"line_1\\\", \\\"'Twas brillig, and the slithy toves\\\")\\n ht.put(\\\"line_2\\\", \\\"Did gyre and gimble in the wabe:\\\")\\n ht.put(\\\"line_3\\\", \\\"All mimsy were the borogoves,\\\")\\n ht.put(\\\"line_4\\\", \\\"And the mome raths outgrabe.\\\")\\n ht.put(\\\"line_5\\\", '\\\"Beware the Jabberwock, my son!')\\n ht.put(\\\"line_6\\\", \\\"The jaws that bite, the claws that catch!\\\")\\n ht.put(\\\"line_7\\\", \\\"Beware the Jubjub bird, and shun\\\")\\n ht.put(\\\"line_8\\\", 'The frumious Bandersnatch!\\\"')\\n ht.put(\\\"line_9\\\", \\\"He took his vorpal sword in hand;\\\")\\n ht.put(\\\"line_10\\\", \\\"Long time the manxome foe he sought--\\\")\\n ht.put(\\\"line_11\\\", \\\"So rested he by the Tumtum tree\\\")\\n ht.put(\\\"line_12\\\", \\\"And stood awhile in thought.\\\")\\n\\n print(\\\"\\\")\\n\\n # Test storing beyond capacity\\n for i in range(1, 13):\\n print(ht.get(f\\\"line_{i}\\\"))\\n\\n # Test resizing\\n old_capacity = ht.get_num_slots()\\n ht.resize(ht.capacity * 2)\\n new_capacity = ht.get_num_slots()\\n\\n print(f\\\"\\\\nResized from {old_capacity} to {new_capacity}.\\\\n\\\")\\n\\n # Test if data intact after resizing\\n for i in range(1, 13):\\n print(ht.get(f\\\"line_{i}\\\"))\\n\\n print(\\\"\\\")\",\n \"def _hash_function(self, n):\\n # Get the mask for this n, or make a new one of 32 random bits.\\n mask = self._memomask.get(n)\\n if mask is None:\\n random.seed(n ^ self.seed_mask)\\n mask = self._memomask[n] = int(random.getrandbits(32))\\n # Now return a function that uses Jenkins Hash\\n #\\n def somehash(x):\\n return hashlittle(x, mask)\\n return somehash\",\n \"def hash(self) -> bytes:\",\n \"def hash_functions(self):\\n pass\",\n \"def HashValue(self) -> _n_0_t_3[_n_0_t_9]:\",\n \"def getHashLfn(lfn):\\n return hashlib.sha224(lfn).hexdigest()\",\n \"def _hash(self, key):\\n # OPTIONAL STRETCH: You may replace the Python hash with DJB2 as a stretch goal\\n # return hash(key)\\n return self._hash_djb2(key)\",\n \"def hash(x) -> int:\\n pass\",\n \"def _hash_function(self, key):\\n h = 0\\n a = 31\\n table_size = self.size\\n for i in range(len(key)):\\n h = (h * a + ord(key[i])) % table_size\\n return h\",\n \"def hash(self) -> str:\\r\\n ...\",\n \"def _hash(self, key):\\n\\n return long(hashlib.md5(key).hexdigest(), 16)\",\n \"def _hash(self, key):\\n\\n return long(hashlib.md5(key).hexdigest(), 16)\",\n \"def _hash_function(self, k):\\n return (hash(k) * self._scale + self._shift) % self._prime % len(self._table)\",\n \"def unique_hash(self):\\n raise NotImplementedError(\\\"unique_hash Method not implemented\\\")\",\n \"def hash_2(self):\\n return self.unpack_qword(0x20)\",\n \"def fnv_1a(key: KeyT, seed: int = 0) -> int:\\n max64mod = UINT64_T_MAX + 1\\n hval = (14695981039346656037 + (31 * seed)) % max64mod\\n fnv_64_prime = 1099511628211\\n tmp = list(key) if not isinstance(key, str) else list(map(ord, key))\\n for t_str in tmp:\\n hval ^= t_str\\n hval *= fnv_64_prime\\n hval %= max64mod\\n return hval\",\n \"def __hash__(self):\\n hash_value = 0\\n \\n # approximate_online_count\\n hash_value ^= self.approximate_online_count\\n \\n # approximate_user_count\\n hash_value ^= self.approximate_user_count << 12\\n \\n # description\\n description = self.description\\n if (description is not None):\\n hash_value ^= hash(description)\\n \\n # discovery_splash\\n hash_value ^= hash(self.discovery_splash)\\n \\n # emojis\\n emojis = self.emojis\\n hash_value ^= len(emojis) << 1\\n for emoji in emojis.values():\\n hash_value ^= hash(emoji)\\n \\n # features\\n features = self.features\\n hash_value ^= len(features) << 5\\n for feature in features:\\n hash_value ^= hash(feature)\\n \\n # icon\\n hash_value ^= hash(self.icon)\\n \\n # id\\n hash_value ^= self.id\\n \\n # invite_splash\\n hash_value ^= hash(self.invite_splash)\\n \\n # stickers\\n stickers = self.stickers\\n hash_value ^= len(stickers) << 9\\n for sticker in stickers.values():\\n hash_value ^= hash(sticker)\\n \\n # name\\n name = self.name\\n if (description is None) or (description != name):\\n hash_value ^= hash(name)\\n \\n return hash_value\",\n \"def __hash__(self):\\n base = 1\\n h = 0\\n for l in self.data:\\n for i in l:\\n if i:\\n h += base\\n base *= 2\\n return hash(h)\",\n \"def calHash(n, m):\\n return int(m*BloomFilter.ln2/n)\",\n \"def djb2(self, key):\\n # Your code here\\n hash = 5381\\n for c in key:\\n hash = (hash*33)+ ord(c)\\n return hash\",\n \"def compute_dhash(im):\\n return imagehash.dhash(ensure_pil(im))\",\n \"def djb2_hash(key):\\n\\n hash = 5381\\n\\n for i in range(len(key)):\\n hash = ((hash << 5) + hash) + ord(key[i])\\n\\n return hash\",\n \"def hash_function_1(key):\\n hash = 0\\n for i in key:\\n hash = hash + ord(i)\\n return hash\",\n \"def __hash__(self):\\n x = xxhash.xxh64()\\n x.update(self.puzzle)\\n return x.intdigest()\",\n \"def h_python(key, N):\\n return hash(key) % N\",\n \"def hash_djb2(string):\\n hashval = ctypes.c_uint(5381)\\n for char in string:\\n hashval.value = ((hashval.value << 5) + hashval.value) + ord(char)\\n return hashval.value & 0x7FFFFFFF\",\n \"def djb2(self, key):\\n\\n hash = 5381\\n for n in key.encode():\\n # hash = ((hash << 5) + hash) + n\\n hash = hash * 33 + n\\n\\n return hash\\n # return hash & 0xFFFFFFFF\",\n \"def _Hash(self):\\n fullhash = util.PrefixHash(self.key_bytes)\\n return util.Base64WSEncode(fullhash[:constants.KEY_HASH_SIZE])\",\n \"def _calc_hash(self) -> None:\\n self.image = Image.open(self.path)\\n self.image = self.image.convert(\\\"L\\\")\\n self.image = self.image.resize((self.width, self.height), Image.ANTIALIAS)\\n lpixels = list(self.image.getdata())\\n self.hash = \\\"0b\\\"\\n for i, pixel in enumerate(lpixels):\\n if (i + 1) % self.width == 0 and i != 0:\\n continue\\n if pixel < lpixels[i + 1]:\\n self.hash += \\\"1\\\"\\n continue\\n self.hash += \\\"0\\\"\\n self.hash_hex = DHash.bin2hex(self.hash)\",\n \"def hash(self):\\n raise NotImplementedError() # To be subclassed\",\n \"def internal_hash(self): \\n return hash(tuple(sorted(self.hashtriples())))\",\n \"def hash_key(self):\",\n \"def pre_compute_hashes(s, M1, M2, X):\\n n = len(s)\\n h1 = [0 for _ in range(n+1)]\\n h2 = [0 for _ in range(n+1)]\\n for i in range(1, n+1):\\n ch = ord(s[i-1])\\n h1[i] = (X*h1[i-1] + ch) % M1\\n h2[i] = (X*h2[i-1] + ch) % M2\\n return h1, h2\",\n \"def _Hash(self):\\n fullhash = util.Hash(util.IntToBytes(len(self.key_bytes)), self.key_bytes)\\n return util.Encode(fullhash[:keyczar.KEY_HASH_SIZE])\",\n \"def SHA256(self) -> _n_0_t_3[_n_0_t_9]:\",\n \"def nice_hash(*args):\\n h = sha1()\\n for item in args:\\n h.update(unicode(item))\\n return b32encode(h.digest())\",\n \"def calc_statistics_hash(self) -> bytes:\\n return b\\\"somehash\\\"\",\n \"def hash_function_2(key):\\n hash = 0\\n index = 0\\n for i in key:\\n hash = hash + (index + 1) * ord(i)\\n index = index + 1\\n return hash\",\n \"def get_hash(self):\\r\\n return\",\n \"def calc_statistics_hash(self) -> bytes:\\n raise NotImplementedError()\",\n \"def __hash__(self) -> int:\\r\\n return hash((hash(self.data), self.version, self.compatibilityLimit,\\r\\n self.script, self.seriesSignature, self.pha,\\r\\n self.identityInfo, self.message))\",\n \"def sdbm_hash(name):\\n ret = 0\\n for ii in name:\\n ret = (ret * 65599 + ord(ii)) & 0xFFFFFFFF\\n return hex(ret)\",\n \"def elf_hash(key):\\n\\n hash = 0\\n x = 0\\n\\n for i in range(len(key)):\\n hash = (hash << 4) + ord(key[i])\\n x = hash & 0xF0000000\\n\\n if x != 0:\\n hash **= (x >24)\\n\\n hash &= ~x\\n\\n return (hash & 0x7FFFFFFF)\",\n \"def _hash(self, hashKey):\\n return hashKey % self.size\",\n \"def hash_function(s):\\n\\n # O(n) over the key length\\n # O(1) over the HASH_DATA_SIZE\\n\\n bytes_list = s.encode()\\n\\n total = 0\\n\\n\\n for b in bytes_list: # O(n) over the length of the key\\n total += b\\n\\n\\n total &= 0xffffffff # 32 bit (8 f's)\\n\\n return total\",\n \"def __hash__(self):\\n hash_value = 0\\n \\n # avatar\\n hash_value ^= hash(self.avatar)\\n \\n # boosts_since\\n boosts_since = self.boosts_since\\n if (boosts_since is not None):\\n hash_value ^= hash(boosts_since)\\n \\n # flags\\n hash_value ^= self.flags\\n \\n # joined_at\\n joined_at = self.joined_at\\n if (joined_at is not None):\\n hash_value ^= hash(joined_at)\\n \\n # nick\\n nick = self.nick\\n if (nick is not None):\\n hash_value ^= hash(nick)\\n \\n # pending\\n hash_value ^= self.pending\\n \\n # role_ids\\n role_ids = self.role_ids\\n if (role_ids is not None):\\n hash_value ^= len(role_ids) << 4\\n for role_id in role_ids:\\n hash_value ^= role_id\\n \\n # timed_out_until\\n timed_out_until = self.timed_out_until\\n if (timed_out_until is not None):\\n hash_value ^= hash(timed_out_until)\\n \\n return hash_value\",\n \"def hash_function_2(key):\\n\\n hash = 0\\n index = 0\\n for i in key:\\n hash = hash + (index + 1) * ord(i)\\n index = index + 1\\n return hash\",\n \"def hash_function_2(key):\\n\\n hash = 0\\n index = 0\\n for i in key:\\n hash = hash + (index + 1) * ord(i)\\n index = index + 1\\n return hash\",\n \"def hash_function_2(key):\\n\\n hash = 0\\n index = 0\\n for i in key:\\n hash = hash + (index + 1) * ord(i)\\n index = index + 1\\n return hash\",\n \"def seed_hash(*args):\\n args_str = str(args)\\n return int(hashlib.md5(args_str.encode(\\\"utf-8\\\")).hexdigest(), 16) % (2**31)\",\n \"def test_default_hash_colision(self):\\n h1 = default_fnv_1a(\\\"gMPflVXtwGDXbIhP73TX\\\", 5)\\n h2 = default_fnv_1a(\\\"LtHf1prlU1bCeYZEdqWf\\\", 5)\\n\\n self.assertEqual(h1[0], h2[0]) # these should match\\n for i in range(1, 5):\\n self.assertNotEqual(h1[i], h2[i])\",\n \"def __Hash(self):\\n return self._Hash()\",\n \"def hexdigest(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def hexdigest(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def hexdigest(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def hexdigest(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def hexdigest(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def hexdigest(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def customHashFunc(str):\\n return sum(ord(chr) for chr in str)%128\",\n \"def __hash__(self):\\n return hash((self.SYMBOL, self._.hash_parameters))\",\n \"def computeHash(string):\\n\\tif isBytes(string):\\n\\t\\tstring = string.decode(\\\"latin-1\\\")\\n\\thash_ = 63689\\n\\tfor char in string:\\n\\t\\thash_ = hash_ * 378551 + ord(char)\\n\\treturn hash_ % 65536\",\n \"def computePerceptualHash(img, length=64):\\n img_resize = cv2.resize(img, (32, 32))\\n img_DCT = cv2.dct(img_resize)\\n\\n if length==64:\\n low_freq_dct = img_DCT[1:9, 1:9]\\n elif length==32:\\n low_freq_dct = img_DCT[1:7, 1:7]\\n\\n avg = np.mean(low_freq_dct)\\n img_hash = np.where(low_freq_dct > avg, 1, 0)\\n hash = \\\"\\\".join(map(str, img_hash.flatten()[0:length]))\\n return hash\",\n \"def __hash__(self):\\n return hash(self.hash)\",\n \"def useOldServerHashFunction():\\r\\n global serverHashFunction\\r\\n serverHashFunction = crc32\",\n \"def djb_hash(s):\\n h = 5381\\n for c in s:\\n h = h * 33 + ord(c)\\n return h & 0xffffffff\",\n \"def hash(self):\\n return Hash.dhash(bytes(self))\",\n \"def current_hash(self):\",\n \"def __hash__(self):\\n hash_value = 0\\n \\n # required\\n hash_value ^= self.required << 14\\n \\n # title\\n hash_value ^= hash(self.title)\\n \\n # type\\n hash_value ^= hash(self.type)\\n \\n # values\\n values = self.values\\n if (values is not None):\\n hash_value ^= len(values)\\n \\n for value in values:\\n hash_value ^= hash(value)\\n \\n return hash_value\",\n \"def __hash__(self):\\n Name._hashes_used += 1\\n if self._name is None:\\n return 0\\n value = ord(self._name[0]) << 7\\n for char in self._name:\\n value = c_mul(1000003, value) ^ ord(char)\\n value = value ^ len(self._name)\\n if value == -1:\\n value = -2\\n # The result is trimmed down to 31 bits (plus a sign bit) to give\\n # consistent results on 32 and 64 bit systems\\n # Otherwise hash() will implicitly do this based on the Python build\\n # see https://docs.python.org/3/reference/datamodel.html#object.__hash__\\n value = value % 0b0111_1111_1111_1111_1111_1111_1111_1111\\n return value\",\n \"def h(x):\\n\\n hasher = hashlib.sha256()\\n hasher.update(x)\\n return hasher.digest()\",\n \"def badhash(x):\\n x = (((x >> 16) ^ x) * 0x045d9f3b) & 0xFFFFFFFF\\n x = (((x >> 16) ^ x) * 0x045d9f3b) & 0xFFFFFFFF\\n x = ((x >> 16) ^ x) & 0xFFFFFFFF\\n return x\",\n \"def hash_128_bit_pass(passwd):\\n h = hashlib.sha256()\\n h.update(passwd)\\n return h.hexdigest()[:16]\",\n \"def djb2(self, key):\\n # Your code here\\n # https://stackoverflow.com/questions/1579721/why-are-5381-and-33-so-important-in-the-djb2-algorithm \\n hash = 5381\\n bytes_to_hash = key.encode() \\n\\n for byte in bytes_to_hash:\\n # << is a bitwise operator; in this case, it shifts the \\\"bits\\\" of `hash` left by 5 \\n hash = ((hash << 5) + byte)\\n \\n # for x in key: \\n # # << is a bitwise operator; in this case, it shifts the \\\"bits\\\" of `hash` left by 5 \\\"bits\\\"\\n # hash = (( hash << 5) + hash) + ord(x) # hash + 33 + ord(x)\\n \\n return hash\",\n \"def __hash__(self) -> int:\",\n \"def test_12_multihash(self):\\n self.base_12_multihash(\\\"sha256\\\")\\n if sha512_supported:\\n self.base_12_multihash(\\\"sha512_256\\\")\",\n \"def get_data_hash(args):\\n pass\",\n \"def hashing_info(string):#KEY HASHING FUNCTION\\n nodeInfo = string.encode('utf-8')\\n\\n #md5 -> 2^7 = 128 bits\\n hash_object = hashlib.md5()\\n hash_object.update(nodeInfo)\\n\\n tmp = hash_object.hexdigest()\\n tmp = int(tmp,16)\\n\\n result = tmp >> (128-16)\\n return result\",\n \"def strongHashFunction(self):\\n\\t\\treturn self._strongHashFunction\",\n \"def hash_fn(x):\\r\\n # Debug.\\r\\n counter = Counter.get_default()\\r\\n count = counter.count()\\r\\n if count % DEBUG_FREQ == 0:\\r\\n logger.debug(\\\">> (hash_fn start) Node counter is: {}.\\\".format(count))\\r\\n\\r\\n hashed = hash(x.tostring())\\r\\n\\r\\n return hashed\",\n \"def hash_functions(self):\\n def hash_factory(n):\\n return lambda x: hash(\\\"salt\\\" + str(n) + str(x) + \\\"salt\\\")\\n return [ hash_factory(_) for _ in range(self.dim) ]\",\n \"def r_soft_hash(x):\\n if abs(x) < 1e-9:return 0\\n # round it to some number of bits\\n b = ns.round(ns.log(abs(x)) / ns.log(2))\\n gran = 2**(b-30)\\n return ns.round(x / gran) * gran\",\n \"def __polynomial_hash(self, s, base = 31, max_size=168):\\r\\n digest = 0\\r\\n max_size = 168\\r\\n for c in s: digest = base * digest + ord(c)\\r\\n digest &= 2 ** max_size - 1 \\r\\n return hex(digest).rstrip('L')\",\n \"def hash(self, key):\\n return self._hash_function(key) % self.size # Modular hashing\",\n \"def hash(self, oid):\\n data = self.family_name + self.name +\\\\\\n self.date_of_birth + self.date_of_issue +\\\\\\n self.date_of_expiry + self.issuing_country +\\\\\\n self.issuing_authority + self.license_number +\\\\\\n \\\"\\\".join(self.categories_of_vehicles) +\\\\\\n str(self.number_of_entries)\\n if oid == 'id-sha1':\\n digest = hashes.Hash(hashes.SHA1(), backend=default_backend())\\n digest.update(data.encode())\\n return digest.finalize()\\n elif oid == 'id-sha224':\\n digest = hashes.Hash(hashes.SHA224(), backend=default_backend())\\n digest.update(data.encode())\\n return digest.finalize()\\n elif oid == 'id-sha256':\\n digest = hashes.Hash(hashes.SHA256(), backend=default_backend())\\n digest.update(data.encode())\\n return digest.finalize()\\n elif oid == 'id-sha384':\\n digest = hashes.Hash(hashes.SHA384(), backend=default_backend())\\n digest.update(data.encode())\\n return digest.finalize()\\n elif oid == 'id-sha512':\\n digest = hashes.Hash(hashes.SHA512(), backend=default_backend())\\n digest.update(data.encode())\\n return digest.finalize()\\n else:\\n print('ERROR: Hash algorithm not implemented.')\\n sys.exit(1)\",\n \"def _hash(self, string, hash_type):\\n hash_types = {\\n 'TABLE_OFFSET': 0,\\n 'HASH_A': 1,\\n 'HASH_B': 2,\\n 'TABLE': 3\\n }\\n seed1 = 0x7FED7FED\\n seed2 = 0xEEEEEEEE\\n\\n for ch in string.upper():\\n if not isinstance(ch, int): ch = ord(ch)\\n value = self.encryption_table[(hash_types[hash_type] << 8) + ch]\\n seed1 = (value ^ (seed1 + seed2)) & 0xFFFFFFFF\\n seed2 = ch + seed1 + seed2 + (seed2 << 5) + 3 & 0xFFFFFFFF\\n\\n return seed1\",\n \"def concatHash(h1: int, h2: int, len2: int, mod=10**11 + 7, base=1313131) -> int:\\r\\n return (h1 * pow(base, len2, mod) + h2) % mod\",\n \"def test_hash(self):\\n ffs = get_available_force_fields()\\n\\n for ff1, ff2 in itertools.combinations(ffs, 2):\\n assert hash(ff1) != hash(ff2)\",\n \"def soft_hash(p):\\n return tuple(map(r_soft_hash, p))\",\n \"def hasher((x1, y1), (x0, y0)=(0,0)):\\n return _point_hash((x0, y0)) ^ _point_hash((x0, y1)) ^ _point_hash((x1, y0)) ^ _point_hash((x1, y1))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7850084","0.72370136","0.7108986","0.705044","0.6990908","0.691239","0.67458034","0.6731104","0.6608719","0.6538066","0.65314394","0.6447355","0.6440217","0.6417119","0.63966304","0.6386951","0.63631225","0.6338462","0.6330434","0.63016164","0.62938416","0.62520784","0.62520784","0.6247326","0.6244987","0.6243137","0.6238413","0.6222898","0.62160987","0.61988044","0.61957544","0.6185601","0.6172113","0.61711264","0.61708117","0.6157969","0.61407316","0.61275","0.61271566","0.6126418","0.61253375","0.60890347","0.6078189","0.60724974","0.60700315","0.6067513","0.6055186","0.6047978","0.6037457","0.6030802","0.60188955","0.60171133","0.6014793","0.60145843","0.6008888","0.60069567","0.60038924","0.60014904","0.60014904","0.60014904","0.5998758","0.5995741","0.5986152","0.5982382","0.5982382","0.5982382","0.5982382","0.5982382","0.5982382","0.5971679","0.59716547","0.59686416","0.5964067","0.59612685","0.5961213","0.5950973","0.5938216","0.5937732","0.5935364","0.59352696","0.5927916","0.5926391","0.5914532","0.59134024","0.59100413","0.59099525","0.5909665","0.5900857","0.5899291","0.5897292","0.58940095","0.5887705","0.58663815","0.58540064","0.58530504","0.58526176","0.5851568","0.584492","0.5843757","0.5834124"],"string":"[\n \"0.7850084\",\n \"0.72370136\",\n \"0.7108986\",\n \"0.705044\",\n \"0.6990908\",\n \"0.691239\",\n \"0.67458034\",\n \"0.6731104\",\n \"0.6608719\",\n \"0.6538066\",\n \"0.65314394\",\n \"0.6447355\",\n \"0.6440217\",\n \"0.6417119\",\n \"0.63966304\",\n \"0.6386951\",\n \"0.63631225\",\n \"0.6338462\",\n \"0.6330434\",\n \"0.63016164\",\n \"0.62938416\",\n \"0.62520784\",\n \"0.62520784\",\n \"0.6247326\",\n \"0.6244987\",\n \"0.6243137\",\n \"0.6238413\",\n \"0.6222898\",\n \"0.62160987\",\n \"0.61988044\",\n \"0.61957544\",\n \"0.6185601\",\n \"0.6172113\",\n \"0.61711264\",\n \"0.61708117\",\n \"0.6157969\",\n \"0.61407316\",\n \"0.61275\",\n \"0.61271566\",\n \"0.6126418\",\n \"0.61253375\",\n \"0.60890347\",\n \"0.6078189\",\n \"0.60724974\",\n \"0.60700315\",\n \"0.6067513\",\n \"0.6055186\",\n \"0.6047978\",\n \"0.6037457\",\n \"0.6030802\",\n \"0.60188955\",\n \"0.60171133\",\n \"0.6014793\",\n \"0.60145843\",\n \"0.6008888\",\n \"0.60069567\",\n \"0.60038924\",\n \"0.60014904\",\n \"0.60014904\",\n \"0.60014904\",\n \"0.5998758\",\n \"0.5995741\",\n \"0.5986152\",\n \"0.5982382\",\n \"0.5982382\",\n \"0.5982382\",\n \"0.5982382\",\n \"0.5982382\",\n \"0.5982382\",\n \"0.5971679\",\n \"0.59716547\",\n \"0.59686416\",\n \"0.5964067\",\n \"0.59612685\",\n \"0.5961213\",\n \"0.5950973\",\n \"0.5938216\",\n \"0.5937732\",\n \"0.5935364\",\n \"0.59352696\",\n \"0.5927916\",\n \"0.5926391\",\n \"0.5914532\",\n \"0.59134024\",\n \"0.59100413\",\n \"0.59099525\",\n \"0.5909665\",\n \"0.5900857\",\n \"0.5899291\",\n \"0.5897292\",\n \"0.58940095\",\n \"0.5887705\",\n \"0.58663815\",\n \"0.58540064\",\n \"0.58530504\",\n \"0.58526176\",\n \"0.5851568\",\n \"0.584492\",\n \"0.5843757\",\n \"0.5834124\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75328153"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":21965,"cells":{"query":{"kind":"string","value":"DJB2 32bit hash function Implement this, and/or FNV1."},"document":{"kind":"string","value":"def djb2(self, key):\n\n hash = 5381\n for n in key.encode():\n # hash = ((hash << 5) + hash) + n\n hash = hash * 33 + n\n\n return hash\n # return hash & 0xFFFFFFFF"},"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 _hash_djb2(self, key):\n # OPTIONAL STRETCH: Research and implement DJB2\n hash_grotto = 5381\n for k in key:\n hash_grotto = ((hash_grotto << 5) + hash_grotto) + ord(k)\n return hash_grotto & 0xFFFFFFFF","def HashAlgorithm(self) -> _n_7_t_0:","def get_num_slots(self):\n Return the load factor for this hash table.\n\n Implement this.\n \"\"\"\n return self.elements / self.capacity\n\n\n def fnv1(self, key):\n \"\"\"\n FNV-1 Hash, 64-bit\n\n Implement this, and/or DJB2.pyy\n \"\"\"\n\n # Your code here\n\n\n def djb2(self, key):\n \"\"\"\n DJB2 hash, 32-bit\n\n Implement this, and/or FNV-1.\n \"\"\"\n # Your code here\n\n\n def hash_index(self, key):\n \"\"\"\n Take an arbitrary key and return a valid integer index\n between within the storage capacity of the hash table.\n \"\"\"\n #return self.fnv1(key) % self.capacity\n<<<<<<< Updated upstream\n return self.djb2(key) % self.capacity\n=======\n return self.djb2(key) % len(self.storage)\n>>>>>>> Stashed changes\n\n def put(self, key, value):\n \"\"\"\n Store the value with the given key.\n\n Hash collisions should be handled with Linked List Chaining.\n\n Implement this.\n \"\"\"\n<<<<<<< Updated upstream\n # Your code here\n=======\n # need to account for if the key value is the same \n\n i = self.hash_index(key)\n if not self.storage[i]:\n hte = HashTableEntry(key, value)\n self.storage[i] = hte\n self.elements += 1\n hte.head = HashTableEntry(key, value)\n elif self.storage[i] and self.storage[i].key != key:\n self.storage[i].insert_at_head(HashTableEntry(key, value))\n>>>>>>> Stashed changes\n\n\n def delete(self, key):\n \"\"\"\n Remove the value stored with the given key.\n\n Print a warning if the key is not found.\n\n Implement this.\n \"\"\"\n<<<<<<< Updated upstream\n # Your code here\n=======\n i = self.hash_index(key)\n node = self.storage[i]\n prev = None\n if node.key == key:\n self.storage[i] = node.next\n return\n while node != None:\n if node.key == key:\n prev.next = node.next\n self.storage[i].next = None\n return\n prev = node\n node = node.next\n self.elements -= 1\n return\n>>>>>>> Stashed changes\n\n\n def get(self, key):\n \"\"\"\n Retrieve the value stored with the given key.\n\n Returns None if the key is not found.\n\n Implement this.\n \"\"\"\n<<<<<<< Updated upstream\n # Your code here\n=======\n # - find the index in the hash table for the key\n i = self.hash_index(key)\n # - search the list for that key\n if not self.storage[i]:\n return None\n else:\n if self.storage[i].find_key(key) == key:\n return self.storage[i].value\n>>>>>>> Stashed changes\n\n\n def resize(self, new_capacity):\n \"\"\"\n Changes the capacity of the hash table and\n rehashes all key/value pairs.\n\n Implement this.\n \"\"\"\n<<<<<<< Updated upstream\n # Your code here\n=======\n prev_storage = self.storage\n self.capacity = new_cap\n self.storage = [None] * new_cap\n for i in range(len(prev_storage)):\n prev = prev_storage[i]\n if prev:\n while prev:\n if prev.key:\n self.put(prev.key, prev.value)\n prev = prev.next\n\n>>>>>>> Stashed changes\n\n\n\nif __name__ == \"__main__\":\n ht = HashTable(8)\n\n ht.put(\"line_1\", \"'Twas brillig, and the slithy toves\")\n ht.put(\"line_2\", \"Did gyre and gimble in the wabe:\")\n ht.put(\"line_3\", \"All mimsy were the borogoves,\")\n ht.put(\"line_4\", \"And the mome raths outgrabe.\")\n ht.put(\"line_5\", '\"Beware the Jabberwock, my son!')\n ht.put(\"line_6\", \"The jaws that bite, the claws that catch!\")\n ht.put(\"line_7\", \"Beware the Jubjub bird, and shun\")\n ht.put(\"line_8\", 'The frumious Bandersnatch!\"')\n ht.put(\"line_9\", \"He took his vorpal sword in hand;\")\n ht.put(\"line_10\", \"Long time the manxome foe he sought--\")\n ht.put(\"line_11\", \"So rested he by the Tumtum tree\")\n ht.put(\"line_12\", \"And stood awhile in thought.\")\n\n print(\"\")\n\n # Test storing beyond capacity\n for i in range(1, 13):\n print(ht.get(f\"line_{i}\"))\n\n # Test resizing\n old_capacity = ht.get_num_slots()\n ht.resize(ht.capacity * 2)\n new_capacity = ht.get_num_slots()\n\n print(f\"\\nResized from {old_capacity} to {new_capacity}.\\n\")\n\n # Test if data intact after resizing\n for i in range(1, 13):\n print(ht.get(f\"line_{i}\"))\n\n print(\"\")","def djb2(self, key):\n # Your code here\n hash = 5381\n for c in key:\n hash = (hash*33)+ ord(c)\n return hash","def fnv1(self, key):\n # hash = 0xff\n hash = 0xcbf29ce484222325\n for n in key.encode():\n # print(n)\n hash = hash ^ n\n hash = hash * 0x100000001b3\n\n # print(hash)\n return hash","def _hash(self, key):\n if self.function == 'fnv':\n h = 2166136261\n for i in range(len(key)):\n h = (h * 16777619) ^ ord(key[i])\n return h\n elif self.function == 'add':\n h = 0\n for i in range(len(key)):\n h += ord(key[i])\n return h","def fnv1(self, key, seed=0):\n # def fnv1(self, key):\n\n # Your code here\n \"\"\"\n Returns: The FNV-1 hash (64-bit) of a given string. \n \"\"\"\n #Constants : Fails the tests\n # FNV_prime = 1099511628211\n # offset_basis = 14695981039346656037\n\n # #FNV-1a Hash Function\n # hash = offset_basis + seed\n # # hash = offset_basis\n # for c in key:\n # hash = hash * FNV_prime\n # hash = hash ^ ord(c)\n # return hash\n\n \"\"\"\n Returns: The FNV-1a (alternate) hash of a given string\n \"\"\"\n # #Constants : Passes the tests\n # FNV_prime = 1099511628211\n # offset_basis = 14695981039346656037\n\n # #FNV-1a alternate Hash Function\n # hash = offset_basis + seed\n # for c in key:\n # hash = hash ^ ord(c)\n # hash = hash * FNV_prime\n # return hash","def b32hash(s):\n _hash = hashlib.sha256()\n _hash.update(str2bytes(s))\n return bytes2str(b32encode(_hash.digest()))","def _hash(self, key):\n # OPTIONAL STRETCH: You may replace the Python hash with DJB2 as a stretch goal\n # return hash(key)\n return self._hash_djb2(key)","def hash_2(self):\n return self.unpack_qword(0x20)","def _hash_function(self, key):\n h = 0\n a = 31\n table_size = self.size\n for i in range(len(key)):\n h = (h * a + ord(key[i])) % table_size\n return h","def djb2_hash(key):\n\n hash = 5381\n\n for i in range(len(key)):\n hash = ((hash << 5) + hash) + ord(key[i])\n\n return hash","def hash_functions(self):\n pass","def _hash_function(self, k):\n return (hash(k) * self._scale + self._shift) % self._prime % len(self._table)","def h_python(key, N):\n return hash(key) % N","def fnvhash(a): \n h = 2166136261 \n for i in a: \n t = (h * 16777619) & 0xffffffffL \n h = t ^ i \n return h","def hash(x) -> int:\n pass","def _hash(self):\r\n MAX = sys.maxint\r\n MASK = 2 * MAX + 1\r\n n = len(self)\r\n h = 1927868237 * (n + 1)\r\n h &= MASK\r\n for x in self:\r\n hx = hash(x)\r\n h ^= (hx ^ (hx << 16) ^ 89869747) * 3644798167\r\n h &= MASK\r\n h = h * 69069 + 907133923\r\n h &= MASK\r\n if h > MAX:\r\n h -= MASK + 1\r\n if h == -1:\r\n h = 590923713\r\n return h","def hash_djb2(string):\n hashval = ctypes.c_uint(5381)\n for char in string:\n hashval.value = ((hashval.value << 5) + hashval.value) + ord(char)\n return hashval.value & 0x7FFFFFFF","def hash_eth2(data: bytes) -> Hash32:\n return Hash32(keccak(data))","def djb_hash(s):\n h = 5381\n for c in s:\n h = h * 33 + ord(c)\n return h & 0xffffffff","def SHA256(self) -> _n_0_t_3[_n_0_t_9]:","def hash_function_2(key):\n hash = 0\n index = 0\n for i in key:\n hash = hash + (index + 1) * ord(i)\n index = index + 1\n return hash","def strongHashFunction(self):\n\t\treturn self._strongHashFunction","def HashValue(self) -> _n_0_t_3[_n_0_t_9]:","def djb2(self, key):\n # Your code here\n # https://stackoverflow.com/questions/1579721/why-are-5381-and-33-so-important-in-the-djb2-algorithm \n hash = 5381\n bytes_to_hash = key.encode() \n\n for byte in bytes_to_hash:\n # << is a bitwise operator; in this case, it shifts the \"bits\" of `hash` left by 5 \n hash = ((hash << 5) + byte)\n \n # for x in key: \n # # << is a bitwise operator; in this case, it shifts the \"bits\" of `hash` left by 5 \"bits\"\n # hash = (( hash << 5) + hash) + ord(x) # hash + 33 + ord(x)\n \n return hash","def hash_function_2(key):\n\n hash = 0\n index = 0\n for i in key:\n hash = hash + (index + 1) * ord(i)\n index = index + 1\n return hash","def hash_function_2(key):\n\n hash = 0\n index = 0\n for i in key:\n hash = hash + (index + 1) * ord(i)\n index = index + 1\n return hash","def hash_function_2(key):\n\n hash = 0\n index = 0\n for i in key:\n hash = hash + (index + 1) * ord(i)\n index = index + 1\n return hash","def __hash__(self):\n base = 1\n h = 0\n for l in self.data:\n for i in l:\n if i:\n h += base\n base *= 2\n return hash(h)","def useOldServerHashFunction():\r\n global serverHashFunction\r\n serverHashFunction = crc32","def hash64bits(*args):\n # 64 bits hexdigest\n h = hashlib.sha1(bytes(repr(args), \"utf-8\")).hexdigest()[:16]\n # Convert to an integer and return\n return int(h, 16)","def _hash(self, key):\n\n return long(hashlib.md5(key).hexdigest(), 16)","def _hash(self, key):\n\n return long(hashlib.md5(key).hexdigest(), 16)","def FNV1Hash(filename):\n \n FNV1_32_INIT = 0x811c9dc5\n FNV1_PRIME_32 = 16777619\n\n lowerName = filename.lower()\n \n _hash = FNV1_32_INIT\n uint32_max = 2 ** 32\n \n for c in lowerName:\n _hash = (_hash * FNV1_PRIME_32) % uint32_max\n _hash = _hash ^ ord(c)\n return format(_hash, 'x')","def __hash__(self):\n hash_value = 0\n \n # approximate_online_count\n hash_value ^= self.approximate_online_count\n \n # approximate_user_count\n hash_value ^= self.approximate_user_count << 12\n \n # description\n description = self.description\n if (description is not None):\n hash_value ^= hash(description)\n \n # discovery_splash\n hash_value ^= hash(self.discovery_splash)\n \n # emojis\n emojis = self.emojis\n hash_value ^= len(emojis) << 1\n for emoji in emojis.values():\n hash_value ^= hash(emoji)\n \n # features\n features = self.features\n hash_value ^= len(features) << 5\n for feature in features:\n hash_value ^= hash(feature)\n \n # icon\n hash_value ^= hash(self.icon)\n \n # id\n hash_value ^= self.id\n \n # invite_splash\n hash_value ^= hash(self.invite_splash)\n \n # stickers\n stickers = self.stickers\n hash_value ^= len(stickers) << 9\n for sticker in stickers.values():\n hash_value ^= hash(sticker)\n \n # name\n name = self.name\n if (description is None) or (description != name):\n hash_value ^= hash(name)\n \n return hash_value","def __hash__(self):\n hash_value = 0\n \n # avatar\n hash_value ^= hash(self.avatar)\n \n # boosts_since\n boosts_since = self.boosts_since\n if (boosts_since is not None):\n hash_value ^= hash(boosts_since)\n \n # flags\n hash_value ^= self.flags\n \n # joined_at\n joined_at = self.joined_at\n if (joined_at is not None):\n hash_value ^= hash(joined_at)\n \n # nick\n nick = self.nick\n if (nick is not None):\n hash_value ^= hash(nick)\n \n # pending\n hash_value ^= self.pending\n \n # role_ids\n role_ids = self.role_ids\n if (role_ids is not None):\n hash_value ^= len(role_ids) << 4\n for role_id in role_ids:\n hash_value ^= role_id\n \n # timed_out_until\n timed_out_until = self.timed_out_until\n if (timed_out_until is not None):\n hash_value ^= hash(timed_out_until)\n \n return hash_value","def h(x):\n\n hasher = hashlib.sha256()\n hasher.update(x)\n return hasher.digest()","def _hash_function(self, n):\n # Get the mask for this n, or make a new one of 32 random bits.\n mask = self._memomask.get(n)\n if mask is None:\n random.seed(n ^ self.seed_mask)\n mask = self._memomask[n] = int(random.getrandbits(32))\n # Now return a function that uses Jenkins Hash\n #\n def somehash(x):\n return hashlittle(x, mask)\n return somehash","def _hash(self, hashKey):\n return hashKey % self.size","def hash(self) -> bytes:","def hash_1(self):\n return self.unpack_qword(0x18)","def internal_hash(self): \n return hash(tuple(sorted(self.hashtriples())))","def __hash__(self):\n return 31 * hash(self.head_vertex) + hash(self.tail_vertex) + hash(self.weight)","def __hash__(self):\n return 31 * hash(self.head_vertex) + hash(self.tail_vertex) + hash(self.weight)","def hash_function_1(key):\n hash = 0\n for i in key:\n hash = hash + ord(i)\n return hash","def __hash__(self):\n hash_value = 0\n \n # required\n hash_value ^= self.required << 14\n \n # title\n hash_value ^= hash(self.title)\n \n # type\n hash_value ^= hash(self.type)\n \n # values\n values = self.values\n if (values is not None):\n hash_value ^= len(values)\n \n for value in values:\n hash_value ^= hash(value)\n \n return hash_value","def hash(self) -> str:\r\n ...","def concatHash(h1: int, h2: int, len2: int, mod=10**11 + 7, base=1313131) -> int:\r\n return (h1 * pow(base, len2, mod) + h2) % mod","def __hash__(self) -> int:\r\n return hash((hash(self.data), self.version, self.compatibilityLimit,\r\n self.script, self.seriesSignature, self.pha,\r\n self.identityInfo, self.message))","def badhash(x):\n x = (((x >> 16) ^ x) * 0x045d9f3b) & 0xFFFFFFFF\n x = (((x >> 16) ^ x) * 0x045d9f3b) & 0xFFFFFFFF\n x = ((x >> 16) ^ x) & 0xFFFFFFFF\n return x","def compute_hash(self, key: int):\n return key % 42","def __Hash(self):\n return self._Hash()","def hash_function(s):\n\n # O(n) over the key length\n # O(1) over the HASH_DATA_SIZE\n\n bytes_list = s.encode()\n\n total = 0\n\n\n for b in bytes_list: # O(n) over the length of the key\n total += b\n\n\n total &= 0xffffffff # 32 bit (8 f's)\n\n return total","def crc32_hash(v):\n return '%x' % (binascii.crc32(v) & 0xffffffff) # 取crc32的八位数据 %x返回16进制","def hash_key(self):","def __hash__(self):\n return hash(self.hash)","def calHash(n, m):\n return int(m*BloomFilter.ln2/n)","def _hash32(x, seed=1):\n x = tf.convert_to_tensor(x)\n assert x.dtype == tf.int32\n # TODO(austinwaters): Change to an int64 valued hash once fast_gather\n # supports that type. For int64, the corresponding CityHash prime (k_mul) is\n # 0x9ddfea08eb382d69, and we should right shift by 32 bits in the last line.\n k_mul = 0xcc9e2d51 # Large prime borrowed from CityHash.\n m = (seed + x) * k_mul\n return tf.bitwise.bitwise_xor(m, (tf.bitwise.right_shift(m, 16)))","def _Hash(self):\n fullhash = util.Hash(util.IntToBytes(len(self.key_bytes)), self.key_bytes)\n return util.Encode(fullhash[:keyczar.KEY_HASH_SIZE])","def hash(self, searchkey):\n return searchkey % self.n","def digest(self):\n d = MegaCrypto.str_to_a32(self.hash)\n return (d[0] ^ d[1], d[2] ^ d[3])","def elf_hash(key):\n\n hash = 0\n x = 0\n\n for i in range(len(key)):\n hash = (hash << 4) + ord(key[i])\n x = hash & 0xF0000000\n\n if x != 0:\n hash **= (x >24)\n\n hash &= ~x\n\n return (hash & 0x7FFFFFFF)","def _Hash(self):\n fullhash = util.PrefixHash(self.key_bytes)\n return util.Base64WSEncode(fullhash[:constants.KEY_HASH_SIZE])","def __hash__(self):\n return hash((self.SYMBOL, self._.hash_parameters))","def hash(self):\n raise NotImplementedError() # To be subclassed","def test_hash(self):\n ffs = get_available_force_fields()\n\n for ff1, ff2 in itertools.combinations(ffs, 2):\n assert hash(ff1) != hash(ff2)","def compute_dhash(im):\n return imagehash.dhash(ensure_pil(im))","def getHashLfn(lfn):\n return hashlib.sha224(lfn).hexdigest()","def get_hash(self):\r\n return","def __hash__(self) -> int:","def test_12_multihash(self):\n self.base_12_multihash(\"sha256\")\n if sha512_supported:\n self.base_12_multihash(\"sha512_256\")","def hashing(word) :\r\n ans = hashlib.sha256(word.encode())\r\n return ans.hexdigest()","def customHashFunc(str):\n return sum(ord(chr) for chr in str)%128","def __hash__(self):\n x = xxhash.xxh64()\n x.update(self.puzzle)\n return x.intdigest()","def hash(self, key):\n return self._hash_function(key) % self.size # Modular hashing","def _hash_function(self, x):\n return hashlib.sha1(x).hexdigest()","def __hash__(self):\n return 31 * hash(self.head_vertex) + hash(self.tail_vertex)","def hashing(self, key):\n #return hash(key) % self.__size\n if type(key) == str:\n hashVal = 0\n for i, c in enumerate(key):\n hashVal += int(ord(c)) * 31 ** (len(key) -1 - i)\n return hashVal % self.__size\n return key % self.__size","def soft_hash(p):\n return tuple(map(r_soft_hash, p))","def __hash__(self):\n return hash(self.base_location) ^ hash(self.fold_path) ^ hash(self.field)","def hash(self, key):\n key = str(key)\n h = 0\n a = self.hash_base\n for i in range(len(str(key))):\n h = (h * a + ord(key[i])) % self.table_capacity\n return h","def crc32_hash(self, key: T) -> int:\n\n if isinstance(key, str):\n crc32: int = 0xffffffff\n for b in key.encode('utf-8'):\n crc32 = (crc32 >> 8) ^ self.crc32_table[(crc32 & 0xff) ^ b]\n crc32 ^= 0xffffffff # invert all bits\n return crc32 % self.table_size\n else:\n return self.prime_mod_hash(key)","def LSH_hash(value, XORvalue):\n # Sha1 has is more computational expensive than md5 while for our purpose the specific hash doesnt matter\n #new_value = hashlib.sha1(value.to_bytes(INT_SIZE, 'big')).digest()[0: INT_SIZE_BYTES]\n new_value = hashlib.md5(value.to_bytes(INT_SIZE, 'big')).digest()[0: INT_SIZE_BYTES]\n new_int_value = int.from_bytes(new_value, 'big')\n return new_int_value ^ XORvalue","def marvin32_hash(self, buf):\n def rotl(x, n, w):\n return (x.value << n) | (x.value >> (w - n))\n\n def to_uint32_le(four_bytes):\n b1, b2, b3, b4 = bytearray(four_bytes)\n return b1 | (b2 << 8) | (b3 << 16) | (b4 << 24)\n\n def marvin32_mix(state, val):\n lo, hi = state\n lo.value += val.value\n hi.value ^= lo.value\n lo.value = rotl(lo, 20, 32) + hi.value\n hi.value = rotl(hi, 9, 32) ^ lo.value\n lo.value = rotl(lo, 27, 32) + hi.value\n hi.value = rotl(hi, 19, 32)\n return (lo, hi)\n\n seed = self._marvin32seed\n lo = c_uint32(seed)\n hi = c_uint32(seed >> 32)\n state = (lo, hi)\n\n length = len(buf)\n pos = 0\n val = c_uint32()\n\n while length >= 4:\n val.value = to_uint32_le(buf[pos:pos+4])\n state = marvin32_mix(state, val)\n pos += 4\n length -= 4\n\n final = c_uint32(0x80)\n if length == 3:\n final.value = (final.value << 8) | buf[pos+2]\n elif length == 2:\n final.value = (final.value << 8) | buf[pos+1]\n elif length == 1:\n final.value = (final.value << 8) | buf[pos]\n\n state = marvin32_mix(state, final)\n state = marvin32_mix(state, c_uint32(0))\n lo, hi = state\n return (hi.value << 32 | lo.value)","def sdbm_hash(name):\n ret = 0\n for ii in name:\n ret = (ret * 65599 + ord(ii)) & 0xFFFFFFFF\n return hex(ret)","def _hash(self,key):\r\n \"\"\"Fundamentals of Python\"\"\"\r\n \"\"\"by Kenneth Lambert\"\"\"\r\n \"\"\"pg.792 section 19.3.2\"\"\"\r\n \"\"\"changed variable sum -> total\"\"\"\r\n \"\"\"changed variable item -> key\"\"\"\r\n if len(key) >4 and \\\r\n (key[0].islower() or key [0].isupper()):\r\n key = key[1:]\r\n total=0\r\n for ch in key:\r\n total += ord(ch)\r\n if len(key) > 2:\r\n total -= 2 * ord(key[-1])\r\n return total","def h2(data1=None, data2=None, data3=None, data4=None, data5=None, data6=None):\n\n hsh = SHA512.new()\n hsh.update(b\"5\")\n hsh.update(data1)\n hsh.update(data2)\n hsh.update(data3)\n hsh.update(data4)\n hsh.update(data5)\n hsh.update(data6)\n return hsh","def SHA1(self) -> _n_0_t_3[_n_0_t_9]:","def sha_process(self):\n\n # Break chunk into sixteen 32-bit big-endian words m[0..15]\n m = [0] * 64\n # Extend the sixteen 32-bit words into sixty-four 32-bit words\n j = 0\n for i in range(16):\n m[i] = self.data_b[j] << 24 | self.data_b[j+1] << 16\\\n | self.data_b[j+2] << 8 | self.data_b[j+3]\n j += 4\n\n for i in range(16, 64):\n sig0 = self.rotr(m[i-15], 7) ^ self.rotr(m[i-15], 18)\\\n ^ (m[i-15] >> 3)\n sig1 = self.rotr(m[i-2], 17) ^ self.rotr(m[i-2], 19)\\\n ^ (m[i-2] >> 10)\n m[i] = (sig1 + m[i-7] + sig0 + m[i-16]) & 0xFFFFFFFF\n\n # Initialize hash value for this chunk\n a, b, c, d, e, f, g, h = self.h\n\n for i in range(64):\n ep0 = (self.rotr(a, 2) ^ self.rotr(a, 13) ^ self.rotr(a, 22))\\\n & 0xFFFFFFFF\n ep1 = (self.rotr(e, 6) ^ self.rotr(e, 11) ^ self.rotr(e, 25))\\\n & 0xFFFFFFFF\n ch = ((e & f) ^ ((~e) & g))\n maj = ((a & b) ^ (a & c) ^ (b & c))\n t1 = (h + ep1 + ch + self.k[i] + m[i]) & 0xFFFFFFFF\n t2 = (ep0 + maj) & 0xFFFFFFFF\n h = g\n g = f\n f = e\n e = (d + t1) & 0xFFFFFFFF\n d = c\n c = b\n b = a\n a = (t1 + t2) & 0xFFFFFFFF\n\n # Add this chunk's hash to result so far\n self.h[0] = (self.h[0] + a) & 0xFFFFFFFF\n self.h[1] = (self.h[1] + b) & 0xFFFFFFFF\n self.h[2] = (self.h[2] + c) & 0xFFFFFFFF\n self.h[3] = (self.h[3] + d) & 0xFFFFFFFF\n self.h[4] = (self.h[4] + e) & 0xFFFFFFFF\n self.h[5] = (self.h[5] + f) & 0xFFFFFFFF\n self.h[6] = (self.h[6] + g) & 0xFFFFFFFF\n self.h[7] = (self.h[7] + h) & 0xFFFFFFFF","def calc_statistics_hash(self) -> bytes:\n return b\"somehash\"","def hash_index(self, key):\n #return self.fnv1(key) % self.capacity\n return self.djb2(key) % self.capacity","def __hash__(self) -> int:\n ...","def __hash__(self) -> int:\n ...","def hash(self):\n return Hash.dhash(bytes(self))","def sdbm_hash(key):\n\n hash = 0\n\n for i in range(len(key)):\n hash = ord(key[i]) + (hash << 6) + (hash << 16) - hash\n\n return (hash & 0x7FFFFFFF)","def h0(data_1=None, data_2=None):\n\n hsh = SHA512.new()\n hsh.update(b\"3\")\n hsh.update(data_1)\n hsh.update(data_2)\n return hsh","def __hash__(self):\n\n return hash((str(self.type) + str(self.value)))","def hash_functions(self):\n def hash_factory(n):\n return lambda x: hash(\"salt\" + str(n) + str(x) + \"salt\")\n return [ hash_factory(_) for _ in range(self.dim) ]","def _hash(self, string, hash_type):\n hash_types = {\n 'TABLE_OFFSET': 0,\n 'HASH_A': 1,\n 'HASH_B': 2,\n 'TABLE': 3\n }\n seed1 = 0x7FED7FED\n seed2 = 0xEEEEEEEE\n\n for ch in string.upper():\n if not isinstance(ch, int): ch = ord(ch)\n value = self.encryption_table[(hash_types[hash_type] << 8) + ch]\n seed1 = (value ^ (seed1 + seed2)) & 0xFFFFFFFF\n seed2 = ch + seed1 + seed2 + (seed2 << 5) + 3 & 0xFFFFFFFF\n\n return seed1"],"string":"[\n \"def _hash_djb2(self, key):\\n # OPTIONAL STRETCH: Research and implement DJB2\\n hash_grotto = 5381\\n for k in key:\\n hash_grotto = ((hash_grotto << 5) + hash_grotto) + ord(k)\\n return hash_grotto & 0xFFFFFFFF\",\n \"def HashAlgorithm(self) -> _n_7_t_0:\",\n \"def get_num_slots(self):\\n Return the load factor for this hash table.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n return self.elements / self.capacity\\n\\n\\n def fnv1(self, key):\\n \\\"\\\"\\\"\\n FNV-1 Hash, 64-bit\\n\\n Implement this, and/or DJB2.pyy\\n \\\"\\\"\\\"\\n\\n # Your code here\\n\\n\\n def djb2(self, key):\\n \\\"\\\"\\\"\\n DJB2 hash, 32-bit\\n\\n Implement this, and/or FNV-1.\\n \\\"\\\"\\\"\\n # Your code here\\n\\n\\n def hash_index(self, key):\\n \\\"\\\"\\\"\\n Take an arbitrary key and return a valid integer index\\n between within the storage capacity of the hash table.\\n \\\"\\\"\\\"\\n #return self.fnv1(key) % self.capacity\\n<<<<<<< Updated upstream\\n return self.djb2(key) % self.capacity\\n=======\\n return self.djb2(key) % len(self.storage)\\n>>>>>>> Stashed changes\\n\\n def put(self, key, value):\\n \\\"\\\"\\\"\\n Store the value with the given key.\\n\\n Hash collisions should be handled with Linked List Chaining.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n<<<<<<< Updated upstream\\n # Your code here\\n=======\\n # need to account for if the key value is the same \\n\\n i = self.hash_index(key)\\n if not self.storage[i]:\\n hte = HashTableEntry(key, value)\\n self.storage[i] = hte\\n self.elements += 1\\n hte.head = HashTableEntry(key, value)\\n elif self.storage[i] and self.storage[i].key != key:\\n self.storage[i].insert_at_head(HashTableEntry(key, value))\\n>>>>>>> Stashed changes\\n\\n\\n def delete(self, key):\\n \\\"\\\"\\\"\\n Remove the value stored with the given key.\\n\\n Print a warning if the key is not found.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n<<<<<<< Updated upstream\\n # Your code here\\n=======\\n i = self.hash_index(key)\\n node = self.storage[i]\\n prev = None\\n if node.key == key:\\n self.storage[i] = node.next\\n return\\n while node != None:\\n if node.key == key:\\n prev.next = node.next\\n self.storage[i].next = None\\n return\\n prev = node\\n node = node.next\\n self.elements -= 1\\n return\\n>>>>>>> Stashed changes\\n\\n\\n def get(self, key):\\n \\\"\\\"\\\"\\n Retrieve the value stored with the given key.\\n\\n Returns None if the key is not found.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n<<<<<<< Updated upstream\\n # Your code here\\n=======\\n # - find the index in the hash table for the key\\n i = self.hash_index(key)\\n # - search the list for that key\\n if not self.storage[i]:\\n return None\\n else:\\n if self.storage[i].find_key(key) == key:\\n return self.storage[i].value\\n>>>>>>> Stashed changes\\n\\n\\n def resize(self, new_capacity):\\n \\\"\\\"\\\"\\n Changes the capacity of the hash table and\\n rehashes all key/value pairs.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n<<<<<<< Updated upstream\\n # Your code here\\n=======\\n prev_storage = self.storage\\n self.capacity = new_cap\\n self.storage = [None] * new_cap\\n for i in range(len(prev_storage)):\\n prev = prev_storage[i]\\n if prev:\\n while prev:\\n if prev.key:\\n self.put(prev.key, prev.value)\\n prev = prev.next\\n\\n>>>>>>> Stashed changes\\n\\n\\n\\nif __name__ == \\\"__main__\\\":\\n ht = HashTable(8)\\n\\n ht.put(\\\"line_1\\\", \\\"'Twas brillig, and the slithy toves\\\")\\n ht.put(\\\"line_2\\\", \\\"Did gyre and gimble in the wabe:\\\")\\n ht.put(\\\"line_3\\\", \\\"All mimsy were the borogoves,\\\")\\n ht.put(\\\"line_4\\\", \\\"And the mome raths outgrabe.\\\")\\n ht.put(\\\"line_5\\\", '\\\"Beware the Jabberwock, my son!')\\n ht.put(\\\"line_6\\\", \\\"The jaws that bite, the claws that catch!\\\")\\n ht.put(\\\"line_7\\\", \\\"Beware the Jubjub bird, and shun\\\")\\n ht.put(\\\"line_8\\\", 'The frumious Bandersnatch!\\\"')\\n ht.put(\\\"line_9\\\", \\\"He took his vorpal sword in hand;\\\")\\n ht.put(\\\"line_10\\\", \\\"Long time the manxome foe he sought--\\\")\\n ht.put(\\\"line_11\\\", \\\"So rested he by the Tumtum tree\\\")\\n ht.put(\\\"line_12\\\", \\\"And stood awhile in thought.\\\")\\n\\n print(\\\"\\\")\\n\\n # Test storing beyond capacity\\n for i in range(1, 13):\\n print(ht.get(f\\\"line_{i}\\\"))\\n\\n # Test resizing\\n old_capacity = ht.get_num_slots()\\n ht.resize(ht.capacity * 2)\\n new_capacity = ht.get_num_slots()\\n\\n print(f\\\"\\\\nResized from {old_capacity} to {new_capacity}.\\\\n\\\")\\n\\n # Test if data intact after resizing\\n for i in range(1, 13):\\n print(ht.get(f\\\"line_{i}\\\"))\\n\\n print(\\\"\\\")\",\n \"def djb2(self, key):\\n # Your code here\\n hash = 5381\\n for c in key:\\n hash = (hash*33)+ ord(c)\\n return hash\",\n \"def fnv1(self, key):\\n # hash = 0xff\\n hash = 0xcbf29ce484222325\\n for n in key.encode():\\n # print(n)\\n hash = hash ^ n\\n hash = hash * 0x100000001b3\\n\\n # print(hash)\\n return hash\",\n \"def _hash(self, key):\\n if self.function == 'fnv':\\n h = 2166136261\\n for i in range(len(key)):\\n h = (h * 16777619) ^ ord(key[i])\\n return h\\n elif self.function == 'add':\\n h = 0\\n for i in range(len(key)):\\n h += ord(key[i])\\n return h\",\n \"def fnv1(self, key, seed=0):\\n # def fnv1(self, key):\\n\\n # Your code here\\n \\\"\\\"\\\"\\n Returns: The FNV-1 hash (64-bit) of a given string. \\n \\\"\\\"\\\"\\n #Constants : Fails the tests\\n # FNV_prime = 1099511628211\\n # offset_basis = 14695981039346656037\\n\\n # #FNV-1a Hash Function\\n # hash = offset_basis + seed\\n # # hash = offset_basis\\n # for c in key:\\n # hash = hash * FNV_prime\\n # hash = hash ^ ord(c)\\n # return hash\\n\\n \\\"\\\"\\\"\\n Returns: The FNV-1a (alternate) hash of a given string\\n \\\"\\\"\\\"\\n # #Constants : Passes the tests\\n # FNV_prime = 1099511628211\\n # offset_basis = 14695981039346656037\\n\\n # #FNV-1a alternate Hash Function\\n # hash = offset_basis + seed\\n # for c in key:\\n # hash = hash ^ ord(c)\\n # hash = hash * FNV_prime\\n # return hash\",\n \"def b32hash(s):\\n _hash = hashlib.sha256()\\n _hash.update(str2bytes(s))\\n return bytes2str(b32encode(_hash.digest()))\",\n \"def _hash(self, key):\\n # OPTIONAL STRETCH: You may replace the Python hash with DJB2 as a stretch goal\\n # return hash(key)\\n return self._hash_djb2(key)\",\n \"def hash_2(self):\\n return self.unpack_qword(0x20)\",\n \"def _hash_function(self, key):\\n h = 0\\n a = 31\\n table_size = self.size\\n for i in range(len(key)):\\n h = (h * a + ord(key[i])) % table_size\\n return h\",\n \"def djb2_hash(key):\\n\\n hash = 5381\\n\\n for i in range(len(key)):\\n hash = ((hash << 5) + hash) + ord(key[i])\\n\\n return hash\",\n \"def hash_functions(self):\\n pass\",\n \"def _hash_function(self, k):\\n return (hash(k) * self._scale + self._shift) % self._prime % len(self._table)\",\n \"def h_python(key, N):\\n return hash(key) % N\",\n \"def fnvhash(a): \\n h = 2166136261 \\n for i in a: \\n t = (h * 16777619) & 0xffffffffL \\n h = t ^ i \\n return h\",\n \"def hash(x) -> int:\\n pass\",\n \"def _hash(self):\\r\\n MAX = sys.maxint\\r\\n MASK = 2 * MAX + 1\\r\\n n = len(self)\\r\\n h = 1927868237 * (n + 1)\\r\\n h &= MASK\\r\\n for x in self:\\r\\n hx = hash(x)\\r\\n h ^= (hx ^ (hx << 16) ^ 89869747) * 3644798167\\r\\n h &= MASK\\r\\n h = h * 69069 + 907133923\\r\\n h &= MASK\\r\\n if h > MAX:\\r\\n h -= MASK + 1\\r\\n if h == -1:\\r\\n h = 590923713\\r\\n return h\",\n \"def hash_djb2(string):\\n hashval = ctypes.c_uint(5381)\\n for char in string:\\n hashval.value = ((hashval.value << 5) + hashval.value) + ord(char)\\n return hashval.value & 0x7FFFFFFF\",\n \"def hash_eth2(data: bytes) -> Hash32:\\n return Hash32(keccak(data))\",\n \"def djb_hash(s):\\n h = 5381\\n for c in s:\\n h = h * 33 + ord(c)\\n return h & 0xffffffff\",\n \"def SHA256(self) -> _n_0_t_3[_n_0_t_9]:\",\n \"def hash_function_2(key):\\n hash = 0\\n index = 0\\n for i in key:\\n hash = hash + (index + 1) * ord(i)\\n index = index + 1\\n return hash\",\n \"def strongHashFunction(self):\\n\\t\\treturn self._strongHashFunction\",\n \"def HashValue(self) -> _n_0_t_3[_n_0_t_9]:\",\n \"def djb2(self, key):\\n # Your code here\\n # https://stackoverflow.com/questions/1579721/why-are-5381-and-33-so-important-in-the-djb2-algorithm \\n hash = 5381\\n bytes_to_hash = key.encode() \\n\\n for byte in bytes_to_hash:\\n # << is a bitwise operator; in this case, it shifts the \\\"bits\\\" of `hash` left by 5 \\n hash = ((hash << 5) + byte)\\n \\n # for x in key: \\n # # << is a bitwise operator; in this case, it shifts the \\\"bits\\\" of `hash` left by 5 \\\"bits\\\"\\n # hash = (( hash << 5) + hash) + ord(x) # hash + 33 + ord(x)\\n \\n return hash\",\n \"def hash_function_2(key):\\n\\n hash = 0\\n index = 0\\n for i in key:\\n hash = hash + (index + 1) * ord(i)\\n index = index + 1\\n return hash\",\n \"def hash_function_2(key):\\n\\n hash = 0\\n index = 0\\n for i in key:\\n hash = hash + (index + 1) * ord(i)\\n index = index + 1\\n return hash\",\n \"def hash_function_2(key):\\n\\n hash = 0\\n index = 0\\n for i in key:\\n hash = hash + (index + 1) * ord(i)\\n index = index + 1\\n return hash\",\n \"def __hash__(self):\\n base = 1\\n h = 0\\n for l in self.data:\\n for i in l:\\n if i:\\n h += base\\n base *= 2\\n return hash(h)\",\n \"def useOldServerHashFunction():\\r\\n global serverHashFunction\\r\\n serverHashFunction = crc32\",\n \"def hash64bits(*args):\\n # 64 bits hexdigest\\n h = hashlib.sha1(bytes(repr(args), \\\"utf-8\\\")).hexdigest()[:16]\\n # Convert to an integer and return\\n return int(h, 16)\",\n \"def _hash(self, key):\\n\\n return long(hashlib.md5(key).hexdigest(), 16)\",\n \"def _hash(self, key):\\n\\n return long(hashlib.md5(key).hexdigest(), 16)\",\n \"def FNV1Hash(filename):\\n \\n FNV1_32_INIT = 0x811c9dc5\\n FNV1_PRIME_32 = 16777619\\n\\n lowerName = filename.lower()\\n \\n _hash = FNV1_32_INIT\\n uint32_max = 2 ** 32\\n \\n for c in lowerName:\\n _hash = (_hash * FNV1_PRIME_32) % uint32_max\\n _hash = _hash ^ ord(c)\\n return format(_hash, 'x')\",\n \"def __hash__(self):\\n hash_value = 0\\n \\n # approximate_online_count\\n hash_value ^= self.approximate_online_count\\n \\n # approximate_user_count\\n hash_value ^= self.approximate_user_count << 12\\n \\n # description\\n description = self.description\\n if (description is not None):\\n hash_value ^= hash(description)\\n \\n # discovery_splash\\n hash_value ^= hash(self.discovery_splash)\\n \\n # emojis\\n emojis = self.emojis\\n hash_value ^= len(emojis) << 1\\n for emoji in emojis.values():\\n hash_value ^= hash(emoji)\\n \\n # features\\n features = self.features\\n hash_value ^= len(features) << 5\\n for feature in features:\\n hash_value ^= hash(feature)\\n \\n # icon\\n hash_value ^= hash(self.icon)\\n \\n # id\\n hash_value ^= self.id\\n \\n # invite_splash\\n hash_value ^= hash(self.invite_splash)\\n \\n # stickers\\n stickers = self.stickers\\n hash_value ^= len(stickers) << 9\\n for sticker in stickers.values():\\n hash_value ^= hash(sticker)\\n \\n # name\\n name = self.name\\n if (description is None) or (description != name):\\n hash_value ^= hash(name)\\n \\n return hash_value\",\n \"def __hash__(self):\\n hash_value = 0\\n \\n # avatar\\n hash_value ^= hash(self.avatar)\\n \\n # boosts_since\\n boosts_since = self.boosts_since\\n if (boosts_since is not None):\\n hash_value ^= hash(boosts_since)\\n \\n # flags\\n hash_value ^= self.flags\\n \\n # joined_at\\n joined_at = self.joined_at\\n if (joined_at is not None):\\n hash_value ^= hash(joined_at)\\n \\n # nick\\n nick = self.nick\\n if (nick is not None):\\n hash_value ^= hash(nick)\\n \\n # pending\\n hash_value ^= self.pending\\n \\n # role_ids\\n role_ids = self.role_ids\\n if (role_ids is not None):\\n hash_value ^= len(role_ids) << 4\\n for role_id in role_ids:\\n hash_value ^= role_id\\n \\n # timed_out_until\\n timed_out_until = self.timed_out_until\\n if (timed_out_until is not None):\\n hash_value ^= hash(timed_out_until)\\n \\n return hash_value\",\n \"def h(x):\\n\\n hasher = hashlib.sha256()\\n hasher.update(x)\\n return hasher.digest()\",\n \"def _hash_function(self, n):\\n # Get the mask for this n, or make a new one of 32 random bits.\\n mask = self._memomask.get(n)\\n if mask is None:\\n random.seed(n ^ self.seed_mask)\\n mask = self._memomask[n] = int(random.getrandbits(32))\\n # Now return a function that uses Jenkins Hash\\n #\\n def somehash(x):\\n return hashlittle(x, mask)\\n return somehash\",\n \"def _hash(self, hashKey):\\n return hashKey % self.size\",\n \"def hash(self) -> bytes:\",\n \"def hash_1(self):\\n return self.unpack_qword(0x18)\",\n \"def internal_hash(self): \\n return hash(tuple(sorted(self.hashtriples())))\",\n \"def __hash__(self):\\n return 31 * hash(self.head_vertex) + hash(self.tail_vertex) + hash(self.weight)\",\n \"def __hash__(self):\\n return 31 * hash(self.head_vertex) + hash(self.tail_vertex) + hash(self.weight)\",\n \"def hash_function_1(key):\\n hash = 0\\n for i in key:\\n hash = hash + ord(i)\\n return hash\",\n \"def __hash__(self):\\n hash_value = 0\\n \\n # required\\n hash_value ^= self.required << 14\\n \\n # title\\n hash_value ^= hash(self.title)\\n \\n # type\\n hash_value ^= hash(self.type)\\n \\n # values\\n values = self.values\\n if (values is not None):\\n hash_value ^= len(values)\\n \\n for value in values:\\n hash_value ^= hash(value)\\n \\n return hash_value\",\n \"def hash(self) -> str:\\r\\n ...\",\n \"def concatHash(h1: int, h2: int, len2: int, mod=10**11 + 7, base=1313131) -> int:\\r\\n return (h1 * pow(base, len2, mod) + h2) % mod\",\n \"def __hash__(self) -> int:\\r\\n return hash((hash(self.data), self.version, self.compatibilityLimit,\\r\\n self.script, self.seriesSignature, self.pha,\\r\\n self.identityInfo, self.message))\",\n \"def badhash(x):\\n x = (((x >> 16) ^ x) * 0x045d9f3b) & 0xFFFFFFFF\\n x = (((x >> 16) ^ x) * 0x045d9f3b) & 0xFFFFFFFF\\n x = ((x >> 16) ^ x) & 0xFFFFFFFF\\n return x\",\n \"def compute_hash(self, key: int):\\n return key % 42\",\n \"def __Hash(self):\\n return self._Hash()\",\n \"def hash_function(s):\\n\\n # O(n) over the key length\\n # O(1) over the HASH_DATA_SIZE\\n\\n bytes_list = s.encode()\\n\\n total = 0\\n\\n\\n for b in bytes_list: # O(n) over the length of the key\\n total += b\\n\\n\\n total &= 0xffffffff # 32 bit (8 f's)\\n\\n return total\",\n \"def crc32_hash(v):\\n return '%x' % (binascii.crc32(v) & 0xffffffff) # 取crc32的八位数据 %x返回16进制\",\n \"def hash_key(self):\",\n \"def __hash__(self):\\n return hash(self.hash)\",\n \"def calHash(n, m):\\n return int(m*BloomFilter.ln2/n)\",\n \"def _hash32(x, seed=1):\\n x = tf.convert_to_tensor(x)\\n assert x.dtype == tf.int32\\n # TODO(austinwaters): Change to an int64 valued hash once fast_gather\\n # supports that type. For int64, the corresponding CityHash prime (k_mul) is\\n # 0x9ddfea08eb382d69, and we should right shift by 32 bits in the last line.\\n k_mul = 0xcc9e2d51 # Large prime borrowed from CityHash.\\n m = (seed + x) * k_mul\\n return tf.bitwise.bitwise_xor(m, (tf.bitwise.right_shift(m, 16)))\",\n \"def _Hash(self):\\n fullhash = util.Hash(util.IntToBytes(len(self.key_bytes)), self.key_bytes)\\n return util.Encode(fullhash[:keyczar.KEY_HASH_SIZE])\",\n \"def hash(self, searchkey):\\n return searchkey % self.n\",\n \"def digest(self):\\n d = MegaCrypto.str_to_a32(self.hash)\\n return (d[0] ^ d[1], d[2] ^ d[3])\",\n \"def elf_hash(key):\\n\\n hash = 0\\n x = 0\\n\\n for i in range(len(key)):\\n hash = (hash << 4) + ord(key[i])\\n x = hash & 0xF0000000\\n\\n if x != 0:\\n hash **= (x >24)\\n\\n hash &= ~x\\n\\n return (hash & 0x7FFFFFFF)\",\n \"def _Hash(self):\\n fullhash = util.PrefixHash(self.key_bytes)\\n return util.Base64WSEncode(fullhash[:constants.KEY_HASH_SIZE])\",\n \"def __hash__(self):\\n return hash((self.SYMBOL, self._.hash_parameters))\",\n \"def hash(self):\\n raise NotImplementedError() # To be subclassed\",\n \"def test_hash(self):\\n ffs = get_available_force_fields()\\n\\n for ff1, ff2 in itertools.combinations(ffs, 2):\\n assert hash(ff1) != hash(ff2)\",\n \"def compute_dhash(im):\\n return imagehash.dhash(ensure_pil(im))\",\n \"def getHashLfn(lfn):\\n return hashlib.sha224(lfn).hexdigest()\",\n \"def get_hash(self):\\r\\n return\",\n \"def __hash__(self) -> int:\",\n \"def test_12_multihash(self):\\n self.base_12_multihash(\\\"sha256\\\")\\n if sha512_supported:\\n self.base_12_multihash(\\\"sha512_256\\\")\",\n \"def hashing(word) :\\r\\n ans = hashlib.sha256(word.encode())\\r\\n return ans.hexdigest()\",\n \"def customHashFunc(str):\\n return sum(ord(chr) for chr in str)%128\",\n \"def __hash__(self):\\n x = xxhash.xxh64()\\n x.update(self.puzzle)\\n return x.intdigest()\",\n \"def hash(self, key):\\n return self._hash_function(key) % self.size # Modular hashing\",\n \"def _hash_function(self, x):\\n return hashlib.sha1(x).hexdigest()\",\n \"def __hash__(self):\\n return 31 * hash(self.head_vertex) + hash(self.tail_vertex)\",\n \"def hashing(self, key):\\n #return hash(key) % self.__size\\n if type(key) == str:\\n hashVal = 0\\n for i, c in enumerate(key):\\n hashVal += int(ord(c)) * 31 ** (len(key) -1 - i)\\n return hashVal % self.__size\\n return key % self.__size\",\n \"def soft_hash(p):\\n return tuple(map(r_soft_hash, p))\",\n \"def __hash__(self):\\n return hash(self.base_location) ^ hash(self.fold_path) ^ hash(self.field)\",\n \"def hash(self, key):\\n key = str(key)\\n h = 0\\n a = self.hash_base\\n for i in range(len(str(key))):\\n h = (h * a + ord(key[i])) % self.table_capacity\\n return h\",\n \"def crc32_hash(self, key: T) -> int:\\n\\n if isinstance(key, str):\\n crc32: int = 0xffffffff\\n for b in key.encode('utf-8'):\\n crc32 = (crc32 >> 8) ^ self.crc32_table[(crc32 & 0xff) ^ b]\\n crc32 ^= 0xffffffff # invert all bits\\n return crc32 % self.table_size\\n else:\\n return self.prime_mod_hash(key)\",\n \"def LSH_hash(value, XORvalue):\\n # Sha1 has is more computational expensive than md5 while for our purpose the specific hash doesnt matter\\n #new_value = hashlib.sha1(value.to_bytes(INT_SIZE, 'big')).digest()[0: INT_SIZE_BYTES]\\n new_value = hashlib.md5(value.to_bytes(INT_SIZE, 'big')).digest()[0: INT_SIZE_BYTES]\\n new_int_value = int.from_bytes(new_value, 'big')\\n return new_int_value ^ XORvalue\",\n \"def marvin32_hash(self, buf):\\n def rotl(x, n, w):\\n return (x.value << n) | (x.value >> (w - n))\\n\\n def to_uint32_le(four_bytes):\\n b1, b2, b3, b4 = bytearray(four_bytes)\\n return b1 | (b2 << 8) | (b3 << 16) | (b4 << 24)\\n\\n def marvin32_mix(state, val):\\n lo, hi = state\\n lo.value += val.value\\n hi.value ^= lo.value\\n lo.value = rotl(lo, 20, 32) + hi.value\\n hi.value = rotl(hi, 9, 32) ^ lo.value\\n lo.value = rotl(lo, 27, 32) + hi.value\\n hi.value = rotl(hi, 19, 32)\\n return (lo, hi)\\n\\n seed = self._marvin32seed\\n lo = c_uint32(seed)\\n hi = c_uint32(seed >> 32)\\n state = (lo, hi)\\n\\n length = len(buf)\\n pos = 0\\n val = c_uint32()\\n\\n while length >= 4:\\n val.value = to_uint32_le(buf[pos:pos+4])\\n state = marvin32_mix(state, val)\\n pos += 4\\n length -= 4\\n\\n final = c_uint32(0x80)\\n if length == 3:\\n final.value = (final.value << 8) | buf[pos+2]\\n elif length == 2:\\n final.value = (final.value << 8) | buf[pos+1]\\n elif length == 1:\\n final.value = (final.value << 8) | buf[pos]\\n\\n state = marvin32_mix(state, final)\\n state = marvin32_mix(state, c_uint32(0))\\n lo, hi = state\\n return (hi.value << 32 | lo.value)\",\n \"def sdbm_hash(name):\\n ret = 0\\n for ii in name:\\n ret = (ret * 65599 + ord(ii)) & 0xFFFFFFFF\\n return hex(ret)\",\n \"def _hash(self,key):\\r\\n \\\"\\\"\\\"Fundamentals of Python\\\"\\\"\\\"\\r\\n \\\"\\\"\\\"by Kenneth Lambert\\\"\\\"\\\"\\r\\n \\\"\\\"\\\"pg.792 section 19.3.2\\\"\\\"\\\"\\r\\n \\\"\\\"\\\"changed variable sum -> total\\\"\\\"\\\"\\r\\n \\\"\\\"\\\"changed variable item -> key\\\"\\\"\\\"\\r\\n if len(key) >4 and \\\\\\r\\n (key[0].islower() or key [0].isupper()):\\r\\n key = key[1:]\\r\\n total=0\\r\\n for ch in key:\\r\\n total += ord(ch)\\r\\n if len(key) > 2:\\r\\n total -= 2 * ord(key[-1])\\r\\n return total\",\n \"def h2(data1=None, data2=None, data3=None, data4=None, data5=None, data6=None):\\n\\n hsh = SHA512.new()\\n hsh.update(b\\\"5\\\")\\n hsh.update(data1)\\n hsh.update(data2)\\n hsh.update(data3)\\n hsh.update(data4)\\n hsh.update(data5)\\n hsh.update(data6)\\n return hsh\",\n \"def SHA1(self) -> _n_0_t_3[_n_0_t_9]:\",\n \"def sha_process(self):\\n\\n # Break chunk into sixteen 32-bit big-endian words m[0..15]\\n m = [0] * 64\\n # Extend the sixteen 32-bit words into sixty-four 32-bit words\\n j = 0\\n for i in range(16):\\n m[i] = self.data_b[j] << 24 | self.data_b[j+1] << 16\\\\\\n | self.data_b[j+2] << 8 | self.data_b[j+3]\\n j += 4\\n\\n for i in range(16, 64):\\n sig0 = self.rotr(m[i-15], 7) ^ self.rotr(m[i-15], 18)\\\\\\n ^ (m[i-15] >> 3)\\n sig1 = self.rotr(m[i-2], 17) ^ self.rotr(m[i-2], 19)\\\\\\n ^ (m[i-2] >> 10)\\n m[i] = (sig1 + m[i-7] + sig0 + m[i-16]) & 0xFFFFFFFF\\n\\n # Initialize hash value for this chunk\\n a, b, c, d, e, f, g, h = self.h\\n\\n for i in range(64):\\n ep0 = (self.rotr(a, 2) ^ self.rotr(a, 13) ^ self.rotr(a, 22))\\\\\\n & 0xFFFFFFFF\\n ep1 = (self.rotr(e, 6) ^ self.rotr(e, 11) ^ self.rotr(e, 25))\\\\\\n & 0xFFFFFFFF\\n ch = ((e & f) ^ ((~e) & g))\\n maj = ((a & b) ^ (a & c) ^ (b & c))\\n t1 = (h + ep1 + ch + self.k[i] + m[i]) & 0xFFFFFFFF\\n t2 = (ep0 + maj) & 0xFFFFFFFF\\n h = g\\n g = f\\n f = e\\n e = (d + t1) & 0xFFFFFFFF\\n d = c\\n c = b\\n b = a\\n a = (t1 + t2) & 0xFFFFFFFF\\n\\n # Add this chunk's hash to result so far\\n self.h[0] = (self.h[0] + a) & 0xFFFFFFFF\\n self.h[1] = (self.h[1] + b) & 0xFFFFFFFF\\n self.h[2] = (self.h[2] + c) & 0xFFFFFFFF\\n self.h[3] = (self.h[3] + d) & 0xFFFFFFFF\\n self.h[4] = (self.h[4] + e) & 0xFFFFFFFF\\n self.h[5] = (self.h[5] + f) & 0xFFFFFFFF\\n self.h[6] = (self.h[6] + g) & 0xFFFFFFFF\\n self.h[7] = (self.h[7] + h) & 0xFFFFFFFF\",\n \"def calc_statistics_hash(self) -> bytes:\\n return b\\\"somehash\\\"\",\n \"def hash_index(self, key):\\n #return self.fnv1(key) % self.capacity\\n return self.djb2(key) % self.capacity\",\n \"def __hash__(self) -> int:\\n ...\",\n \"def __hash__(self) -> int:\\n ...\",\n \"def hash(self):\\n return Hash.dhash(bytes(self))\",\n \"def sdbm_hash(key):\\n\\n hash = 0\\n\\n for i in range(len(key)):\\n hash = ord(key[i]) + (hash << 6) + (hash << 16) - hash\\n\\n return (hash & 0x7FFFFFFF)\",\n \"def h0(data_1=None, data_2=None):\\n\\n hsh = SHA512.new()\\n hsh.update(b\\\"3\\\")\\n hsh.update(data_1)\\n hsh.update(data_2)\\n return hsh\",\n \"def __hash__(self):\\n\\n return hash((str(self.type) + str(self.value)))\",\n \"def hash_functions(self):\\n def hash_factory(n):\\n return lambda x: hash(\\\"salt\\\" + str(n) + str(x) + \\\"salt\\\")\\n return [ hash_factory(_) for _ in range(self.dim) ]\",\n \"def _hash(self, string, hash_type):\\n hash_types = {\\n 'TABLE_OFFSET': 0,\\n 'HASH_A': 1,\\n 'HASH_B': 2,\\n 'TABLE': 3\\n }\\n seed1 = 0x7FED7FED\\n seed2 = 0xEEEEEEEE\\n\\n for ch in string.upper():\\n if not isinstance(ch, int): ch = ord(ch)\\n value = self.encryption_table[(hash_types[hash_type] << 8) + ch]\\n seed1 = (value ^ (seed1 + seed2)) & 0xFFFFFFFF\\n seed2 = ch + seed1 + seed2 + (seed2 << 5) + 3 & 0xFFFFFFFF\\n\\n return seed1\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75013524","0.73342395","0.6955384","0.6919217","0.6897323","0.6879067","0.684995","0.68333465","0.68108124","0.6808085","0.6805619","0.67863303","0.6743211","0.65885407","0.6543602","0.65120983","0.65104103","0.6497235","0.6493313","0.6491135","0.6490053","0.6475826","0.64616436","0.6459245","0.64475524","0.64276385","0.6427096","0.6427096","0.6427096","0.6394009","0.6382638","0.6332704","0.6299561","0.6299561","0.62961847","0.6279153","0.6273786","0.6268086","0.6267673","0.6267172","0.6266752","0.62575954","0.62510186","0.6238747","0.6238747","0.6236072","0.6218337","0.62114894","0.6203698","0.62030303","0.6200927","0.62008786","0.61992943","0.61959964","0.61800945","0.6178347","0.61746144","0.6167096","0.61631155","0.6146219","0.61451507","0.614199","0.61406493","0.61340725","0.61325246","0.6124923","0.6118854","0.611206","0.6111707","0.6089626","0.6087626","0.6084292","0.60831666","0.60784614","0.6075497","0.6058192","0.60493696","0.60451","0.6029409","0.6024467","0.6006921","0.6006864","0.6005765","0.60054517","0.6005449","0.5993718","0.5987647","0.59743655","0.5971096","0.59669447","0.5964524","0.5956962","0.5956867","0.5956867","0.59464574","0.5944963","0.5925994","0.59206","0.5917153","0.5915176"],"string":"[\n \"0.75013524\",\n \"0.73342395\",\n \"0.6955384\",\n \"0.6919217\",\n \"0.6897323\",\n \"0.6879067\",\n \"0.684995\",\n \"0.68333465\",\n \"0.68108124\",\n \"0.6808085\",\n \"0.6805619\",\n \"0.67863303\",\n \"0.6743211\",\n \"0.65885407\",\n \"0.6543602\",\n \"0.65120983\",\n \"0.65104103\",\n \"0.6497235\",\n \"0.6493313\",\n \"0.6491135\",\n \"0.6490053\",\n \"0.6475826\",\n \"0.64616436\",\n \"0.6459245\",\n \"0.64475524\",\n \"0.64276385\",\n \"0.6427096\",\n \"0.6427096\",\n \"0.6427096\",\n \"0.6394009\",\n \"0.6382638\",\n \"0.6332704\",\n \"0.6299561\",\n \"0.6299561\",\n \"0.62961847\",\n \"0.6279153\",\n \"0.6273786\",\n \"0.6268086\",\n \"0.6267673\",\n \"0.6267172\",\n \"0.6266752\",\n \"0.62575954\",\n \"0.62510186\",\n \"0.6238747\",\n \"0.6238747\",\n \"0.6236072\",\n \"0.6218337\",\n \"0.62114894\",\n \"0.6203698\",\n \"0.62030303\",\n \"0.6200927\",\n \"0.62008786\",\n \"0.61992943\",\n \"0.61959964\",\n \"0.61800945\",\n \"0.6178347\",\n \"0.61746144\",\n \"0.6167096\",\n \"0.61631155\",\n \"0.6146219\",\n \"0.61451507\",\n \"0.614199\",\n \"0.61406493\",\n \"0.61340725\",\n \"0.61325246\",\n \"0.6124923\",\n \"0.6118854\",\n \"0.611206\",\n \"0.6111707\",\n \"0.6089626\",\n \"0.6087626\",\n \"0.6084292\",\n \"0.60831666\",\n \"0.60784614\",\n \"0.6075497\",\n \"0.6058192\",\n \"0.60493696\",\n \"0.60451\",\n \"0.6029409\",\n \"0.6024467\",\n \"0.6006921\",\n \"0.6006864\",\n \"0.6005765\",\n \"0.60054517\",\n \"0.6005449\",\n \"0.5993718\",\n \"0.5987647\",\n \"0.59743655\",\n \"0.5971096\",\n \"0.59669447\",\n \"0.5964524\",\n \"0.5956962\",\n \"0.5956867\",\n \"0.5956867\",\n \"0.59464574\",\n \"0.5944963\",\n \"0.5925994\",\n \"0.59206\",\n \"0.5917153\",\n \"0.5915176\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.685876"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":21966,"cells":{"query":{"kind":"string","value":"Take an arbitrary key and return a valid integer index between within the storage capacity of the hash table."},"document":{"kind":"string","value":"def hash_index(self, key):\n # return self.fnv1(key) % self.capacity\n return self.djb2(key) % self.capacity"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_index(self, key):\r\n\t\tindex = self._hash_function(key) % self.capacity\r\n\t\treturn index","def _get_index(self, key):\n return self._hash_function(key) % self.capacity","def find(self, key: T) -> int:\n\n try:\n # passes check with primary hashing function\n idx: int = self.hash_fn(key)\n if self.table[idx][0] == key:\n return idx\n\n # use secondary function to find an interval to use\n # i.e. if they had no matching value, double hashing is used to probe to the next key\n idx2: int = self.h2(key)\n i: int = 1\n while self.table[(idx + i * idx2) % self.table_size][0] != key:\n i += 1\n self.key_comparison_counts += 1\n except TypeError as err:\n raise Exception(\"Key doesn't exist in hashtable\") from err\n return (idx + i * idx2) % self.table_size","def hash_index(self, key):\n #return self.fnv1(key) % self.capacity\n return self.djb2(key) % self.capacity","def _bucket_index(self, key):\n # return hash(key) % len(self.buckets)\n hash_value = 0 # hash is set to 0\n for char in key: # iterates through as much as the number of characters in key\n hash_value += ord(char) # return the unicode value to make the number different everytime\n return hash_value % len(self.buckets) # returns a number that will never be greater than the length of the bucket","def get_index(self, key):\r\n if self.hash_table[self.horner_hash(key)] is None:\r\n return None\r\n if self.hash_table[self.horner_hash(key)].key is key:\r\n return self.horner_hash(key)","def _bucket_index(self, key):\n # Calculate the given key's hash code and transform into bucket index\n return hash(key) % len(self.buckets)","def bucket_indexof(table, key):","def get(self, key: int) -> int:\n t = key % 20011\n for item in self.hash[t]:\n if item[0] == key:\n return item[1]\n return -1","def index(self, key: _K) -> int: # type: ignore[override]\n if isinstance(key, int):\n if 0 <= key < len(self.__keys):\n return key\n raise IndexError(key)\n elif isinstance(key, str):\n try:\n return self.__keys.index(key)\n except ValueError as exc:\n raise KeyError(key) from exc\n else:\n raise TypeError(key)","def linear_search(self, key):\r\n index = 0\r\n while index < self.num_keys() and self.keys[index] < key:\r\n index += 1\r\n return index","def get_index(self, key):\n return self.keys.index(key)","def get(self, key: int) -> int:\n pos = self.hash(key)\n\n if key in self.table[pos]:\n return self.table[pos][key]\n else:\n return -1","def _hash_func(self, key: int) -> int:\n return key % self.capacity","def get(self, key: int) -> int:\n pos = key % self.space\n head = self.hash_table[pos]\n curr = head\n\n while curr.next:\n if curr.next.key == key:\n return curr.next.val\n curr = curr.next\n\n return -1","def get(self, key: int) -> int:\n idx = key % self.size\n curr = self.hashmap[idx]\n while curr:\n if curr.key == key:\n return curr.value\n else:\n curr = curr.next\n return -1","def get(self, key):\n ha = self.myhash(key)\n if key not in self.hashmap[ha][0]:\n return -1\n else:\n return self.hashmap[ha][1][self.hashmap[ha][0].index(key)]","def get(self, key: int) -> int:\n index = key % self.size\n \n if self.table[index].value is None:\n return -1\n \n p = self.table[index]\n \n while p:\n if p.key == key:\n return p.value\n p = p.next\n return -1","def get(self, key: int) -> int:\n hashKey = key % 1000\n if self.bucket[hashKey]:\n node = self.bucket[hashKey]\n while node:\n if node.pair[0] == key:\n return node.pair[1]\n node = node.next\n return -1","def get(self, key: int) -> int:\n idx = key % self.size\n if self.mp[idx]:\n for i in range(len(self.mp[idx])):\n if self.mp[idx][i][0] == key:\n return self.mp[idx][i][1] \n return -1\n else:\n return -1","def quadratic_probe(self, key): #hidden\n # the index should be\n index = self.hash_function(key)\n # do not insert empty string\n if index != -1:\n bucketsprobed = 0\n i = 0\n while bucketsprobed < self.capacity:\n if self.table[index] is not None:\n # if the key in the table\n if self.table[index].key == key:\n return index\n elif self.table[index] is None:\n return index\n # Increment i and recompute bucket index\n i += 1\n index = (index + i * i) % self.capacity\n # Increment number of buckets probed\n bucketsprobed += 1\n return index","def get_idx(self, key):\n found = [i for i, e in enumerate(self.list) if e.key == key]\n if found:\n return found[0]\n\n else:\n return -1","def get(self, key: int) -> int:\n if key < self.len:\n return self._map[key]\n return -1","def get(self, key):\n hashv = self.hash(key)\n bucket=self.hashmap[hashv]\n for i,(k,v) in enumerate(bucket):\n if k==key:\n return v\n return -1","def _find_key(self, key: int, find_empty: bool) -> int:\n hash_idx = self._hash_func(key)\n\n while self.slots[hash_idx] is not None:\n if self.slots[hash_idx] == key:\n return hash_idx\n\n if find_empty and self.slots[hash_idx] == '==TOMBSTONE==':\n return hash_idx\n\n hash_idx = self._hash_func(5 * hash_idx + 1)\n\n if find_empty:\n return hash_idx\n\n return -1","def _index(self,key):\n index=0\n for item in self._item:\n if item.key==key:\n return index\n index+=1\n return -1","def rehash(self, key) -> int:\n return (key + 1) % self.size","def get(self, key):\n if key < self.length:\n return self.buckets[key]\n return -1","def get(self, key: int) -> int:\n hashvalue = key%1000\n if self.hashset[hashvalue]==None:\n return -1\n head = self.hashset[hashvalue]\n \n while head:\n k,v = head.data \n if k==key:\n return v\n \n head = head.next\n return -1","def get(self, key: int) -> int:\n sh = key % 37\n if self.map[sh] == None:\n return -1\n for i in range(len(self.map[sh])):\n kv = self.map[sh][i]\n if kv[0] == key:\n return kv[1]\n return -1","def locate_successor(self, key):\r\n index = 0\r\n while index < self.num_keys() and self.keys[index] <= key:\r\n index += 1\r\n return index","def get(self, key: int) -> int:\n if key in self.hashmap.keys():return self.hashmap[key]\n else:return -1","def index(self, key):\n return self._sequence.index(key)","def linear_search(self, num_lst, key):\r\n # Running time: O(n)\r\n for i in range(len(num_lst)):\r\n if num_lst[i] == key:\r\n return i\r\n \r\n return -1","def hash_function(self, key):\n index = key % len(self.objects_list)\n return index","def _key_hash(self, key):\n\n # Hash key with Python's built-in hash function (returns and integer)\n py_hashed_key = hash(key)\n\n # Map to an index in main_array\n # Note: len() is O(1) constant time in Python\n return py_hashed_key % len(self.main_array)","def _findPosition(self, key):\n for i in range(len(self._entryList)):\n if self._entryList[i].key == key:\n return i\n return None","def get(self, key: int) -> int:\n idx = key % 1000\n if not self.map[idx]:\n return -1\n else:\n curr = self.map[idx]\n while curr:\n if curr.key == key:\n return curr.val\n curr = curr.next\n return -1","def get(self, key: int) -> int:\n if key not in self.map:\n return -1\n return self.map[key]","def _hash_function(self, key):\n h = 0\n a = 31\n table_size = self.size\n for i in range(len(key)):\n h = (h * a + ord(key[i])) % table_size\n return h","def hashId(key, size):\n return sum([ord(c) for c in key]) % size","def index(self, key):\n try:\n return self._keys.index(key)\n except ValueError:\n raise KeyError(key)","def get(self, key: int) -> int:\n index = key % 10000\n head = self.array[index]\n while head.next:\n head = head.next\n if head.key == key:\n return head.value\n break\n return -1","def compute_hash(self, key: int):\n return key % 42","def _get_node_pos(self, key):\n if not self._hashring:\n return\n\n k = md5_bytes(key)\n key = (k[3] << 24) | (k[2] << 16) | (k[1] << 8) | k[0]\n\n nodes = self._sorted_keys\n pos = bisect(nodes, key)\n\n if pos == len(nodes):\n return 0\n return pos","def find_pos(self, _node, _key):\n for i, key in enumerate(_node.keys):\n if _key < key:\n return i\n \n return len(_node.pt)-1","def node_index(self, key):\n return self._key_to_node_index[key]","def keyIndex(self, key):\n key ^= bsr(key, 33)\n key *= 0xff51afd7ed558ccdL\n key ^= bsr(key, 33)\n key *= 0xc4ceb9fe1a85ec53L\n key ^= bsr(key, 33)\n return key","def get_hash_address(self, key: keyType) -> int:\n # List and set are unhashable type. So transform the type into 'tuple' if needed.\n tmp = None\n if isinstance(key, set):\n tmp = tuple(key)\n elif isinstance(key, list):\n tmp = tuple(key)\n return tmp.__hash__() % self.length","def hash_key(self,key: str) -> int: \n \n total = 0\n prime = 3\n \n for index, char in enumerate(key,start=1):\n \n total += ord(char)*(prime)**index\n \n return total % self.buckets","def get(self, key):\n index = key % self.size\n\n cur = self.bucket[index]\n while cur:\n if cur.key == key:\n return cur.val\n cur = cur.next\n return -1","def _key_hash(self, key):\n\n split_key = key.strip(' ').split(' ')[1]\n return int(split_key)","def _index_from_key(self, key):\n\t\t\n\t\treturn self.columns.index(str.upper(key[0])), self.rows.index(key[1])","def __getitem__(self, key):\n position = self.hash(key)\n\n for _ in range(self.table_capacity):\n if self.array[position] is None:\n raise KeyError(key)\n elif self.array[position][0] == key:\n return self.array[position][1]\n else:\n position = (position + 1) % self.table_capacity\n raise KeyError(key)","def h2(self, key) -> int:\n idx: int = (self.b * self.encode(key)) % self.table_size\n return idx if idx != 0 else 1","def index(self, key):\r\n return self.keyOrder.index(key)","def get(self, key):\n index = key % self.size\n curr_node = self.hash_table[index]\n\n while curr_node:\n if curr_node.key == key:\n return curr_node.value\n else:\n curr_node = curr_node.next\n\n return -1","def search(self, key):\r\n left = 0 \r\n right = self.num_keys()\r\n while right > left:\r\n mid = (left + right)//2\r\n if self.keys[mid] >= key:\r\n right = mid\r\n else:\r\n left = mid + 1\r\n return left","def key_for_bucket(self, key):\n\n try:\n return int(key[0] // 16), int(key[1] // 16), int(key[2] // 16)\n except ValueError:\n return KeyError(\"Key %s isn't usable here!\" % repr(key))","def count_hash(cls, key, size):\n return key%size","def _get_pos_from_key(key, char):\n return [i+1 for i, c in enumerate(key) if c == char]","def get(self, key: int) -> int:\n chain, idx = self._search(key)\n if idx is not None:\n return chain[idx][1]\n return -1","def linear_search(alist, key):\n for i in range(len(alist)):\n if alist[i] == key:\n return i\n return -1","def linear_search(mylist, key):\r\n for i in range(len(mylist)):\r\n if mylist[i] == key:\r\n return i\r\n return -1","def key_for_bucket(self, key):\n\n try:\n return int(key[0] // 16), int(key[1] // 16)\n except ValueError:\n return KeyError(\"Key %s isn't usable here!\" % repr(key))","def exist_key(self, key: keyType) -> Tuple[int, int]:\n for head_node_index in range(self.length):\n if key in self.hashTable[head_node_index].keys:\n link_lst = self.hashTable[head_node_index].singlyLinkedList\n for chain_node_index in range(len(link_lst)):\n if link_lst[chain_node_index].key == key:\n return head_node_index, chain_node_index\n return -1, -1","def _find_if_hashclash(self, key: str, location: int, key_or_value: str):\n if key in self.HashMap[location]:\n idx = self.HashMap[location].index(key)\n else:\n idx = None\n\n if idx is not None:\n if key_or_value == \"v\":\n return idx + 1\n else:\n return idx","def checkIndex(key):\n if not isinstance(key, (int, float)): raise TypeError\n if key<0: raise IndexError","def get_position(self, key):\n return bisect.bisect_left(self.keys, key)","def get(self, key: int) -> int:\n index = self.hash(key)\n curr = self.map[index]\n\n # Search through list\n while curr:\n # If the value in list matches key, return value\n if curr.val[0] == key: return curr.val[1]\n curr = curr.next\n\n # If it doesn't exist, return -1\n return -1","def hash_key(aMap, key):\n\t#uses the hash function to get the unique integer associated with the key\n\t#then uses the modulus to make sure that number is in the range of the aMap\n\treturn hash(key) % len(aMap)","def index(self, key):\n count = 0\n for k in self.__ordered_keys:\n if k.lower() == key.lower():\n return count\n count = count + 1\n raise KeyError(key)","def get(self, key: int) -> int:\n if key in self.keys:\n return self.values[self.keys.index(key)]\n else:\n return -1","def prime_mod_hash(self, key: T) -> int:\n return (self.a * self.encode(key)) % self.table_size","def get(self, key):\r\n index = self.hash(key)\r\n l = self.bucket[index]\r\n while l.next:\r\n if l.next.key == key:\r\n return l.next.val\r\n l = l.next\r\n return -1","def test_integer_map_key_index():\n\tlib.backup_and_restore(\n\t\tlambda context: create_indexes(lib.create_integer_map_key_index),\n\t\tNone,\n\t\tlambda context: check_indexes(lib.check_map_key_index, 12345)\n\t)","def h_python(key, N):\n return hash(key) % N","def get_first_valid_idx(input_k):\n past_idxs = input_k[input_k < 0]\n if past_idxs.size == 0: # empty\n past_idxs = 0\n else:\n past_idxs = abs(min(past_idxs))\n return past_idxs","def get_ceil_index(left, right, key, A):\n while right - left > 1:\n mid = left + ( right - left) // 2\n\n if A[mid] >= key:\n right = mid\n else:\n left = mid\n\n\n return right","def linear(sequence, n, key=def_key):\n length = len(sequence)\n\n if length == 0:\n return None\n\n # For each element...\n for i in range(length):\n\n # If sequence[i] is the element, return its index\n if n == key(sequence[i]):\n return i\n\n # Did not find the element\n return None","def binary(sequence, n, key=def_key):\n length = len(sequence)\n\n if length == 0:\n return None\n\n j = 0 # start\n k = length # stop\n i = (j + k) // 2 # middle\n\n while j <= i:\n # If sequence[i] is the element, return its index\n if n == key(sequence[i]):\n return i\n elif j == i:\n return None\n elif n < key(sequence[i]):\n k = i # update stop\n else:\n j = i # update start\n\n i = (j + k) // 2\n\n # Did not find the element\n return None","def _hash(self, hashKey):\n return hashKey % self.size","def index(a, x):\n i = bisect_left(a, x)\n if i != len(a) and a[i] == x:\n return i\n raise ValueError","def binary_search(self, num_lst, key):\r\n # Running time: O(log n) with O(n logn) overhead\r\n # get sorted list\r\n num_lst = sorted(num_lst)\r\n \r\n low, high, idx = 0, len(num_lst), -1\r\n \r\n while low < high:\r\n mid = int(math.floor((low+high) / 2.0))\r\n \r\n if key < num_lst[mid]: high = mid - 1\r\n elif key > num_lst[mid]: low = mid + 1\r\n elif key == num_lst[mid]: \r\n idx = mid\r\n return idx\r\n \r\n return idx","def get(hash, key: int) -> V:\r\n hash_value = key % hash.size\r\n while True:\r\n if hash.keyset == None:\r\n return None\r\n i = 0\r\n while i < hash.size:\r\n if hash.data[i].key == None:\r\n i += 1\r\n continue\r\n else:\r\n p = hash.data[i]\r\n while p != None:\r\n if p.key == key:\r\n return p.value\r\n p = p.next\r\n i += 1\r\n return None","def hash(self, key):\n key = str(key)\n h = 0\n a = self.hash_base\n for i in range(len(str(key))):\n h = (h * a + ord(key[i])) % self.table_capacity\n return h","def hashing(self, key):\n #return hash(key) % self.__size\n if type(key) == str:\n hashVal = 0\n for i, c in enumerate(key):\n hashVal += int(ord(c)) * 31 ** (len(key) -1 - i)\n return hashVal % self.__size\n return key % self.__size","def get_slot(aMap, key, default=None):\n\tbucket = get_bucket(aMap, key)\n\n\tfor i, kv in enumerate(bucket):\n\t\tk, v = kv\n\t\tif key == k:\n\t\t\treturn i, k, v\n\n\treturn -1, key, default","def hash_key(aMap, key):\n\treturn hash(key) % len(aMap) #(this will give numbers between 0 and 255)","def hash(self, key):\n\n return hash(key) % len(self.table)","def _double_hashing(self, key: int, slots: List[int] = None) -> int:\n if not slots:\n slots = self.slots\n\n hash_idx = self._hash_func(key)\n while slots[hash_idx] is not None:\n hash_idx = self._hash_func(5 * hash_idx + 1)\n\n return hash_idx","def _rehash(self, hashKey, integer):\n return ( hashKey + integer * integer ) % self.size","def __getitem__(self, key: Union[Hashable, int]) -> Any: # type: ignore\n if isinstance(key, int):\n return self.contents[key]\n else:\n matches = [i for i, c in enumerate(self.contents)\n if self._hashify(c) == key]\n if len(matches) == 0:\n raise KeyError(f'{key} is not in {self.__class__.__name__}')\n elif len(matches) == 1:\n return matches[0]\n else:\n return matches","def _get_loc_single_level_index(self, level_index: Index, key: Hashable) -> int:\n if is_scalar(key) and isna(key):\n # TODO: need is_valid_na_for_dtype(key, level_index.dtype)\n return -1\n else:\n return level_index.get_loc(key)","def hash_key(aMap,key):#\n\treturn hash(key)%len(aMap)","def _index_lookup(self, key: int) -> str:\n if key in self.ind2tok:\n return self.ind2tok[key]\n else:\n return self.unk_token","def first_ge(sorted_list, input_key):\n\t# Basically, do a binary search\n\tlow = 0\n\thigh = len(sorted_list)\n\twhile low != high:\n\t\tmid = int(math.floor((low + high) / 2))\n\t\tif sorted_list[mid] <= input_key:\n\t\t\tlow = mid + 1\n\t\telse:\n\t\t\thigh = mid\n\t# If an element greater than equal to the key exists\n\t# both low and mid contain the index of that element\n\tif low == high:\n\t\treturn low\n\telse:\n\t\treturn -1","def hash_key(self, key):\r\n hashed_key = sum((ord(char) for char in key))\r\n return hashed_key % 20","def item_to_index(self, item_id):\n if item_id in self.item_dict:\n return self.item_dict[item_id]\n else:\n return -1"],"string":"[\n \"def get_index(self, key):\\r\\n\\t\\tindex = self._hash_function(key) % self.capacity\\r\\n\\t\\treturn index\",\n \"def _get_index(self, key):\\n return self._hash_function(key) % self.capacity\",\n \"def find(self, key: T) -> int:\\n\\n try:\\n # passes check with primary hashing function\\n idx: int = self.hash_fn(key)\\n if self.table[idx][0] == key:\\n return idx\\n\\n # use secondary function to find an interval to use\\n # i.e. if they had no matching value, double hashing is used to probe to the next key\\n idx2: int = self.h2(key)\\n i: int = 1\\n while self.table[(idx + i * idx2) % self.table_size][0] != key:\\n i += 1\\n self.key_comparison_counts += 1\\n except TypeError as err:\\n raise Exception(\\\"Key doesn't exist in hashtable\\\") from err\\n return (idx + i * idx2) % self.table_size\",\n \"def hash_index(self, key):\\n #return self.fnv1(key) % self.capacity\\n return self.djb2(key) % self.capacity\",\n \"def _bucket_index(self, key):\\n # return hash(key) % len(self.buckets)\\n hash_value = 0 # hash is set to 0\\n for char in key: # iterates through as much as the number of characters in key\\n hash_value += ord(char) # return the unicode value to make the number different everytime\\n return hash_value % len(self.buckets) # returns a number that will never be greater than the length of the bucket\",\n \"def get_index(self, key):\\r\\n if self.hash_table[self.horner_hash(key)] is None:\\r\\n return None\\r\\n if self.hash_table[self.horner_hash(key)].key is key:\\r\\n return self.horner_hash(key)\",\n \"def _bucket_index(self, key):\\n # Calculate the given key's hash code and transform into bucket index\\n return hash(key) % len(self.buckets)\",\n \"def bucket_indexof(table, key):\",\n \"def get(self, key: int) -> int:\\n t = key % 20011\\n for item in self.hash[t]:\\n if item[0] == key:\\n return item[1]\\n return -1\",\n \"def index(self, key: _K) -> int: # type: ignore[override]\\n if isinstance(key, int):\\n if 0 <= key < len(self.__keys):\\n return key\\n raise IndexError(key)\\n elif isinstance(key, str):\\n try:\\n return self.__keys.index(key)\\n except ValueError as exc:\\n raise KeyError(key) from exc\\n else:\\n raise TypeError(key)\",\n \"def linear_search(self, key):\\r\\n index = 0\\r\\n while index < self.num_keys() and self.keys[index] < key:\\r\\n index += 1\\r\\n return index\",\n \"def get_index(self, key):\\n return self.keys.index(key)\",\n \"def get(self, key: int) -> int:\\n pos = self.hash(key)\\n\\n if key in self.table[pos]:\\n return self.table[pos][key]\\n else:\\n return -1\",\n \"def _hash_func(self, key: int) -> int:\\n return key % self.capacity\",\n \"def get(self, key: int) -> int:\\n pos = key % self.space\\n head = self.hash_table[pos]\\n curr = head\\n\\n while curr.next:\\n if curr.next.key == key:\\n return curr.next.val\\n curr = curr.next\\n\\n return -1\",\n \"def get(self, key: int) -> int:\\n idx = key % self.size\\n curr = self.hashmap[idx]\\n while curr:\\n if curr.key == key:\\n return curr.value\\n else:\\n curr = curr.next\\n return -1\",\n \"def get(self, key):\\n ha = self.myhash(key)\\n if key not in self.hashmap[ha][0]:\\n return -1\\n else:\\n return self.hashmap[ha][1][self.hashmap[ha][0].index(key)]\",\n \"def get(self, key: int) -> int:\\n index = key % self.size\\n \\n if self.table[index].value is None:\\n return -1\\n \\n p = self.table[index]\\n \\n while p:\\n if p.key == key:\\n return p.value\\n p = p.next\\n return -1\",\n \"def get(self, key: int) -> int:\\n hashKey = key % 1000\\n if self.bucket[hashKey]:\\n node = self.bucket[hashKey]\\n while node:\\n if node.pair[0] == key:\\n return node.pair[1]\\n node = node.next\\n return -1\",\n \"def get(self, key: int) -> int:\\n idx = key % self.size\\n if self.mp[idx]:\\n for i in range(len(self.mp[idx])):\\n if self.mp[idx][i][0] == key:\\n return self.mp[idx][i][1] \\n return -1\\n else:\\n return -1\",\n \"def quadratic_probe(self, key): #hidden\\n # the index should be\\n index = self.hash_function(key)\\n # do not insert empty string\\n if index != -1:\\n bucketsprobed = 0\\n i = 0\\n while bucketsprobed < self.capacity:\\n if self.table[index] is not None:\\n # if the key in the table\\n if self.table[index].key == key:\\n return index\\n elif self.table[index] is None:\\n return index\\n # Increment i and recompute bucket index\\n i += 1\\n index = (index + i * i) % self.capacity\\n # Increment number of buckets probed\\n bucketsprobed += 1\\n return index\",\n \"def get_idx(self, key):\\n found = [i for i, e in enumerate(self.list) if e.key == key]\\n if found:\\n return found[0]\\n\\n else:\\n return -1\",\n \"def get(self, key: int) -> int:\\n if key < self.len:\\n return self._map[key]\\n return -1\",\n \"def get(self, key):\\n hashv = self.hash(key)\\n bucket=self.hashmap[hashv]\\n for i,(k,v) in enumerate(bucket):\\n if k==key:\\n return v\\n return -1\",\n \"def _find_key(self, key: int, find_empty: bool) -> int:\\n hash_idx = self._hash_func(key)\\n\\n while self.slots[hash_idx] is not None:\\n if self.slots[hash_idx] == key:\\n return hash_idx\\n\\n if find_empty and self.slots[hash_idx] == '==TOMBSTONE==':\\n return hash_idx\\n\\n hash_idx = self._hash_func(5 * hash_idx + 1)\\n\\n if find_empty:\\n return hash_idx\\n\\n return -1\",\n \"def _index(self,key):\\n index=0\\n for item in self._item:\\n if item.key==key:\\n return index\\n index+=1\\n return -1\",\n \"def rehash(self, key) -> int:\\n return (key + 1) % self.size\",\n \"def get(self, key):\\n if key < self.length:\\n return self.buckets[key]\\n return -1\",\n \"def get(self, key: int) -> int:\\n hashvalue = key%1000\\n if self.hashset[hashvalue]==None:\\n return -1\\n head = self.hashset[hashvalue]\\n \\n while head:\\n k,v = head.data \\n if k==key:\\n return v\\n \\n head = head.next\\n return -1\",\n \"def get(self, key: int) -> int:\\n sh = key % 37\\n if self.map[sh] == None:\\n return -1\\n for i in range(len(self.map[sh])):\\n kv = self.map[sh][i]\\n if kv[0] == key:\\n return kv[1]\\n return -1\",\n \"def locate_successor(self, key):\\r\\n index = 0\\r\\n while index < self.num_keys() and self.keys[index] <= key:\\r\\n index += 1\\r\\n return index\",\n \"def get(self, key: int) -> int:\\n if key in self.hashmap.keys():return self.hashmap[key]\\n else:return -1\",\n \"def index(self, key):\\n return self._sequence.index(key)\",\n \"def linear_search(self, num_lst, key):\\r\\n # Running time: O(n)\\r\\n for i in range(len(num_lst)):\\r\\n if num_lst[i] == key:\\r\\n return i\\r\\n \\r\\n return -1\",\n \"def hash_function(self, key):\\n index = key % len(self.objects_list)\\n return index\",\n \"def _key_hash(self, key):\\n\\n # Hash key with Python's built-in hash function (returns and integer)\\n py_hashed_key = hash(key)\\n\\n # Map to an index in main_array\\n # Note: len() is O(1) constant time in Python\\n return py_hashed_key % len(self.main_array)\",\n \"def _findPosition(self, key):\\n for i in range(len(self._entryList)):\\n if self._entryList[i].key == key:\\n return i\\n return None\",\n \"def get(self, key: int) -> int:\\n idx = key % 1000\\n if not self.map[idx]:\\n return -1\\n else:\\n curr = self.map[idx]\\n while curr:\\n if curr.key == key:\\n return curr.val\\n curr = curr.next\\n return -1\",\n \"def get(self, key: int) -> int:\\n if key not in self.map:\\n return -1\\n return self.map[key]\",\n \"def _hash_function(self, key):\\n h = 0\\n a = 31\\n table_size = self.size\\n for i in range(len(key)):\\n h = (h * a + ord(key[i])) % table_size\\n return h\",\n \"def hashId(key, size):\\n return sum([ord(c) for c in key]) % size\",\n \"def index(self, key):\\n try:\\n return self._keys.index(key)\\n except ValueError:\\n raise KeyError(key)\",\n \"def get(self, key: int) -> int:\\n index = key % 10000\\n head = self.array[index]\\n while head.next:\\n head = head.next\\n if head.key == key:\\n return head.value\\n break\\n return -1\",\n \"def compute_hash(self, key: int):\\n return key % 42\",\n \"def _get_node_pos(self, key):\\n if not self._hashring:\\n return\\n\\n k = md5_bytes(key)\\n key = (k[3] << 24) | (k[2] << 16) | (k[1] << 8) | k[0]\\n\\n nodes = self._sorted_keys\\n pos = bisect(nodes, key)\\n\\n if pos == len(nodes):\\n return 0\\n return pos\",\n \"def find_pos(self, _node, _key):\\n for i, key in enumerate(_node.keys):\\n if _key < key:\\n return i\\n \\n return len(_node.pt)-1\",\n \"def node_index(self, key):\\n return self._key_to_node_index[key]\",\n \"def keyIndex(self, key):\\n key ^= bsr(key, 33)\\n key *= 0xff51afd7ed558ccdL\\n key ^= bsr(key, 33)\\n key *= 0xc4ceb9fe1a85ec53L\\n key ^= bsr(key, 33)\\n return key\",\n \"def get_hash_address(self, key: keyType) -> int:\\n # List and set are unhashable type. So transform the type into 'tuple' if needed.\\n tmp = None\\n if isinstance(key, set):\\n tmp = tuple(key)\\n elif isinstance(key, list):\\n tmp = tuple(key)\\n return tmp.__hash__() % self.length\",\n \"def hash_key(self,key: str) -> int: \\n \\n total = 0\\n prime = 3\\n \\n for index, char in enumerate(key,start=1):\\n \\n total += ord(char)*(prime)**index\\n \\n return total % self.buckets\",\n \"def get(self, key):\\n index = key % self.size\\n\\n cur = self.bucket[index]\\n while cur:\\n if cur.key == key:\\n return cur.val\\n cur = cur.next\\n return -1\",\n \"def _key_hash(self, key):\\n\\n split_key = key.strip(' ').split(' ')[1]\\n return int(split_key)\",\n \"def _index_from_key(self, key):\\n\\t\\t\\n\\t\\treturn self.columns.index(str.upper(key[0])), self.rows.index(key[1])\",\n \"def __getitem__(self, key):\\n position = self.hash(key)\\n\\n for _ in range(self.table_capacity):\\n if self.array[position] is None:\\n raise KeyError(key)\\n elif self.array[position][0] == key:\\n return self.array[position][1]\\n else:\\n position = (position + 1) % self.table_capacity\\n raise KeyError(key)\",\n \"def h2(self, key) -> int:\\n idx: int = (self.b * self.encode(key)) % self.table_size\\n return idx if idx != 0 else 1\",\n \"def index(self, key):\\r\\n return self.keyOrder.index(key)\",\n \"def get(self, key):\\n index = key % self.size\\n curr_node = self.hash_table[index]\\n\\n while curr_node:\\n if curr_node.key == key:\\n return curr_node.value\\n else:\\n curr_node = curr_node.next\\n\\n return -1\",\n \"def search(self, key):\\r\\n left = 0 \\r\\n right = self.num_keys()\\r\\n while right > left:\\r\\n mid = (left + right)//2\\r\\n if self.keys[mid] >= key:\\r\\n right = mid\\r\\n else:\\r\\n left = mid + 1\\r\\n return left\",\n \"def key_for_bucket(self, key):\\n\\n try:\\n return int(key[0] // 16), int(key[1] // 16), int(key[2] // 16)\\n except ValueError:\\n return KeyError(\\\"Key %s isn't usable here!\\\" % repr(key))\",\n \"def count_hash(cls, key, size):\\n return key%size\",\n \"def _get_pos_from_key(key, char):\\n return [i+1 for i, c in enumerate(key) if c == char]\",\n \"def get(self, key: int) -> int:\\n chain, idx = self._search(key)\\n if idx is not None:\\n return chain[idx][1]\\n return -1\",\n \"def linear_search(alist, key):\\n for i in range(len(alist)):\\n if alist[i] == key:\\n return i\\n return -1\",\n \"def linear_search(mylist, key):\\r\\n for i in range(len(mylist)):\\r\\n if mylist[i] == key:\\r\\n return i\\r\\n return -1\",\n \"def key_for_bucket(self, key):\\n\\n try:\\n return int(key[0] // 16), int(key[1] // 16)\\n except ValueError:\\n return KeyError(\\\"Key %s isn't usable here!\\\" % repr(key))\",\n \"def exist_key(self, key: keyType) -> Tuple[int, int]:\\n for head_node_index in range(self.length):\\n if key in self.hashTable[head_node_index].keys:\\n link_lst = self.hashTable[head_node_index].singlyLinkedList\\n for chain_node_index in range(len(link_lst)):\\n if link_lst[chain_node_index].key == key:\\n return head_node_index, chain_node_index\\n return -1, -1\",\n \"def _find_if_hashclash(self, key: str, location: int, key_or_value: str):\\n if key in self.HashMap[location]:\\n idx = self.HashMap[location].index(key)\\n else:\\n idx = None\\n\\n if idx is not None:\\n if key_or_value == \\\"v\\\":\\n return idx + 1\\n else:\\n return idx\",\n \"def checkIndex(key):\\n if not isinstance(key, (int, float)): raise TypeError\\n if key<0: raise IndexError\",\n \"def get_position(self, key):\\n return bisect.bisect_left(self.keys, key)\",\n \"def get(self, key: int) -> int:\\n index = self.hash(key)\\n curr = self.map[index]\\n\\n # Search through list\\n while curr:\\n # If the value in list matches key, return value\\n if curr.val[0] == key: return curr.val[1]\\n curr = curr.next\\n\\n # If it doesn't exist, return -1\\n return -1\",\n \"def hash_key(aMap, key):\\n\\t#uses the hash function to get the unique integer associated with the key\\n\\t#then uses the modulus to make sure that number is in the range of the aMap\\n\\treturn hash(key) % len(aMap)\",\n \"def index(self, key):\\n count = 0\\n for k in self.__ordered_keys:\\n if k.lower() == key.lower():\\n return count\\n count = count + 1\\n raise KeyError(key)\",\n \"def get(self, key: int) -> int:\\n if key in self.keys:\\n return self.values[self.keys.index(key)]\\n else:\\n return -1\",\n \"def prime_mod_hash(self, key: T) -> int:\\n return (self.a * self.encode(key)) % self.table_size\",\n \"def get(self, key):\\r\\n index = self.hash(key)\\r\\n l = self.bucket[index]\\r\\n while l.next:\\r\\n if l.next.key == key:\\r\\n return l.next.val\\r\\n l = l.next\\r\\n return -1\",\n \"def test_integer_map_key_index():\\n\\tlib.backup_and_restore(\\n\\t\\tlambda context: create_indexes(lib.create_integer_map_key_index),\\n\\t\\tNone,\\n\\t\\tlambda context: check_indexes(lib.check_map_key_index, 12345)\\n\\t)\",\n \"def h_python(key, N):\\n return hash(key) % N\",\n \"def get_first_valid_idx(input_k):\\n past_idxs = input_k[input_k < 0]\\n if past_idxs.size == 0: # empty\\n past_idxs = 0\\n else:\\n past_idxs = abs(min(past_idxs))\\n return past_idxs\",\n \"def get_ceil_index(left, right, key, A):\\n while right - left > 1:\\n mid = left + ( right - left) // 2\\n\\n if A[mid] >= key:\\n right = mid\\n else:\\n left = mid\\n\\n\\n return right\",\n \"def linear(sequence, n, key=def_key):\\n length = len(sequence)\\n\\n if length == 0:\\n return None\\n\\n # For each element...\\n for i in range(length):\\n\\n # If sequence[i] is the element, return its index\\n if n == key(sequence[i]):\\n return i\\n\\n # Did not find the element\\n return None\",\n \"def binary(sequence, n, key=def_key):\\n length = len(sequence)\\n\\n if length == 0:\\n return None\\n\\n j = 0 # start\\n k = length # stop\\n i = (j + k) // 2 # middle\\n\\n while j <= i:\\n # If sequence[i] is the element, return its index\\n if n == key(sequence[i]):\\n return i\\n elif j == i:\\n return None\\n elif n < key(sequence[i]):\\n k = i # update stop\\n else:\\n j = i # update start\\n\\n i = (j + k) // 2\\n\\n # Did not find the element\\n return None\",\n \"def _hash(self, hashKey):\\n return hashKey % self.size\",\n \"def index(a, x):\\n i = bisect_left(a, x)\\n if i != len(a) and a[i] == x:\\n return i\\n raise ValueError\",\n \"def binary_search(self, num_lst, key):\\r\\n # Running time: O(log n) with O(n logn) overhead\\r\\n # get sorted list\\r\\n num_lst = sorted(num_lst)\\r\\n \\r\\n low, high, idx = 0, len(num_lst), -1\\r\\n \\r\\n while low < high:\\r\\n mid = int(math.floor((low+high) / 2.0))\\r\\n \\r\\n if key < num_lst[mid]: high = mid - 1\\r\\n elif key > num_lst[mid]: low = mid + 1\\r\\n elif key == num_lst[mid]: \\r\\n idx = mid\\r\\n return idx\\r\\n \\r\\n return idx\",\n \"def get(hash, key: int) -> V:\\r\\n hash_value = key % hash.size\\r\\n while True:\\r\\n if hash.keyset == None:\\r\\n return None\\r\\n i = 0\\r\\n while i < hash.size:\\r\\n if hash.data[i].key == None:\\r\\n i += 1\\r\\n continue\\r\\n else:\\r\\n p = hash.data[i]\\r\\n while p != None:\\r\\n if p.key == key:\\r\\n return p.value\\r\\n p = p.next\\r\\n i += 1\\r\\n return None\",\n \"def hash(self, key):\\n key = str(key)\\n h = 0\\n a = self.hash_base\\n for i in range(len(str(key))):\\n h = (h * a + ord(key[i])) % self.table_capacity\\n return h\",\n \"def hashing(self, key):\\n #return hash(key) % self.__size\\n if type(key) == str:\\n hashVal = 0\\n for i, c in enumerate(key):\\n hashVal += int(ord(c)) * 31 ** (len(key) -1 - i)\\n return hashVal % self.__size\\n return key % self.__size\",\n \"def get_slot(aMap, key, default=None):\\n\\tbucket = get_bucket(aMap, key)\\n\\n\\tfor i, kv in enumerate(bucket):\\n\\t\\tk, v = kv\\n\\t\\tif key == k:\\n\\t\\t\\treturn i, k, v\\n\\n\\treturn -1, key, default\",\n \"def hash_key(aMap, key):\\n\\treturn hash(key) % len(aMap) #(this will give numbers between 0 and 255)\",\n \"def hash(self, key):\\n\\n return hash(key) % len(self.table)\",\n \"def _double_hashing(self, key: int, slots: List[int] = None) -> int:\\n if not slots:\\n slots = self.slots\\n\\n hash_idx = self._hash_func(key)\\n while slots[hash_idx] is not None:\\n hash_idx = self._hash_func(5 * hash_idx + 1)\\n\\n return hash_idx\",\n \"def _rehash(self, hashKey, integer):\\n return ( hashKey + integer * integer ) % self.size\",\n \"def __getitem__(self, key: Union[Hashable, int]) -> Any: # type: ignore\\n if isinstance(key, int):\\n return self.contents[key]\\n else:\\n matches = [i for i, c in enumerate(self.contents)\\n if self._hashify(c) == key]\\n if len(matches) == 0:\\n raise KeyError(f'{key} is not in {self.__class__.__name__}')\\n elif len(matches) == 1:\\n return matches[0]\\n else:\\n return matches\",\n \"def _get_loc_single_level_index(self, level_index: Index, key: Hashable) -> int:\\n if is_scalar(key) and isna(key):\\n # TODO: need is_valid_na_for_dtype(key, level_index.dtype)\\n return -1\\n else:\\n return level_index.get_loc(key)\",\n \"def hash_key(aMap,key):#\\n\\treturn hash(key)%len(aMap)\",\n \"def _index_lookup(self, key: int) -> str:\\n if key in self.ind2tok:\\n return self.ind2tok[key]\\n else:\\n return self.unk_token\",\n \"def first_ge(sorted_list, input_key):\\n\\t# Basically, do a binary search\\n\\tlow = 0\\n\\thigh = len(sorted_list)\\n\\twhile low != high:\\n\\t\\tmid = int(math.floor((low + high) / 2))\\n\\t\\tif sorted_list[mid] <= input_key:\\n\\t\\t\\tlow = mid + 1\\n\\t\\telse:\\n\\t\\t\\thigh = mid\\n\\t# If an element greater than equal to the key exists\\n\\t# both low and mid contain the index of that element\\n\\tif low == high:\\n\\t\\treturn low\\n\\telse:\\n\\t\\treturn -1\",\n \"def hash_key(self, key):\\r\\n hashed_key = sum((ord(char) for char in key))\\r\\n return hashed_key % 20\",\n \"def item_to_index(self, item_id):\\n if item_id in self.item_dict:\\n return self.item_dict[item_id]\\n else:\\n return -1\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.82723343","0.8059556","0.7425421","0.7415482","0.7330069","0.7317209","0.7286038","0.72367275","0.72197723","0.7199164","0.71206874","0.7113054","0.71044403","0.7025496","0.6955795","0.690559","0.6811699","0.6794608","0.6751182","0.6741437","0.6739836","0.67058754","0.66964126","0.669297","0.6692896","0.6688725","0.66623825","0.66578275","0.664828","0.6634344","0.65833807","0.6581958","0.65399987","0.6528245","0.6524","0.6514586","0.6504817","0.6496924","0.6488739","0.64756364","0.6455589","0.6420999","0.6396138","0.63767946","0.6375882","0.63540286","0.63340586","0.6327112","0.6317424","0.63106036","0.6308002","0.63065726","0.6297647","0.6283621","0.62717986","0.62659854","0.6262521","0.6258393","0.6228231","0.6223284","0.62204075","0.6216649","0.6214131","0.6205247","0.62040937","0.61945397","0.6182255","0.6123579","0.61178666","0.61148965","0.61070335","0.61014","0.6093428","0.6091253","0.60883594","0.60647273","0.6027707","0.60058075","0.5989508","0.5972401","0.5965267","0.59582615","0.59374666","0.5935657","0.58856016","0.5881894","0.58705","0.5867569","0.58495396","0.5848304","0.58439267","0.58332694","0.5826351","0.5812522","0.58100724","0.5789161","0.5779592","0.5777974","0.5774669"],"string":"[\n \"0.82723343\",\n \"0.8059556\",\n \"0.7425421\",\n \"0.7415482\",\n \"0.7330069\",\n \"0.7317209\",\n \"0.7286038\",\n \"0.72367275\",\n \"0.72197723\",\n \"0.7199164\",\n \"0.71206874\",\n \"0.7113054\",\n \"0.71044403\",\n \"0.7025496\",\n \"0.6955795\",\n \"0.690559\",\n \"0.6811699\",\n \"0.6794608\",\n \"0.6751182\",\n \"0.6741437\",\n \"0.6739836\",\n \"0.67058754\",\n \"0.66964126\",\n \"0.669297\",\n \"0.6692896\",\n \"0.6688725\",\n \"0.66623825\",\n \"0.66578275\",\n \"0.664828\",\n \"0.6634344\",\n \"0.65833807\",\n \"0.6581958\",\n \"0.65399987\",\n \"0.6528245\",\n \"0.6524\",\n \"0.6514586\",\n \"0.6504817\",\n \"0.6496924\",\n \"0.6488739\",\n \"0.64756364\",\n \"0.6455589\",\n \"0.6420999\",\n \"0.6396138\",\n \"0.63767946\",\n \"0.6375882\",\n \"0.63540286\",\n \"0.63340586\",\n \"0.6327112\",\n \"0.6317424\",\n \"0.63106036\",\n \"0.6308002\",\n \"0.63065726\",\n \"0.6297647\",\n \"0.6283621\",\n \"0.62717986\",\n \"0.62659854\",\n \"0.6262521\",\n \"0.6258393\",\n \"0.6228231\",\n \"0.6223284\",\n \"0.62204075\",\n \"0.6216649\",\n \"0.6214131\",\n \"0.6205247\",\n \"0.62040937\",\n \"0.61945397\",\n \"0.6182255\",\n \"0.6123579\",\n \"0.61178666\",\n \"0.61148965\",\n \"0.61070335\",\n \"0.61014\",\n \"0.6093428\",\n \"0.6091253\",\n \"0.60883594\",\n \"0.60647273\",\n \"0.6027707\",\n \"0.60058075\",\n \"0.5989508\",\n \"0.5972401\",\n \"0.5965267\",\n \"0.59582615\",\n \"0.59374666\",\n \"0.5935657\",\n \"0.58856016\",\n \"0.5881894\",\n \"0.58705\",\n \"0.5867569\",\n \"0.58495396\",\n \"0.5848304\",\n \"0.58439267\",\n \"0.58332694\",\n \"0.5826351\",\n \"0.5812522\",\n \"0.58100724\",\n \"0.5789161\",\n \"0.5779592\",\n \"0.5777974\",\n \"0.5774669\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7555435"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":21967,"cells":{"query":{"kind":"string","value":"Store the value with the given key. Hash collisions should be handled with Linked List Chaining. Implement this."},"document":{"kind":"string","value":"def put(self, key, value):\n hi = self.hash_index(key)\n if self.storage[hi]:\n current = self.storage[hi]\n while current.next and current.key != key:\n current = current.next\n\n if current.key == key:\n current.value = value\n else:\n current.next = HashTableEntry(key, value)\n self.numberOfItems += 1\n else:\n self.storage[hi] = HashTableEntry(key, value)\n self.numberOfItems += 1\n\n self.calculateLoad()"},"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 put(self, key, value):\n ha = self.myhash(key)\n if key not in self.hashmap[ha][0]:\n self.hashmap[ha][0].append(key)\n self.hashmap[ha][1].append(value)\n else:\n self.hashmap[ha][1][self.hashmap[ha][0].index(key)] = value","def put(self, key, value):\n index = key % self.size\n\n if not self.hash_table[index]:\n # We do not have anything in this bin, just create a new node\n self.hash_table[index] = ListNode(key, value)\n else:\n # We do have something in this bin, traverse it checking to see if we have a matching key.\n # If not just append a node to the end of the bin\n curr_node = self.hash_table[index]\n\n while curr_node:\n if curr_node.key == key:\n curr_node.value = value\n return\n if not curr_node.next:\n break\n curr_node = curr_node.next\n # Did not find a matching key here, so append a key, value pair in this bin\n curr_node.next = ListNode(key, value)","def put(self, key: int, value: int) -> None:\n hashvalue = key % 1000\n \n if self.hashset[hashvalue] ==None:\n \n self.hashset[hashvalue]=Node((key,value))\n else :\n head= self.hashset[hashvalue]\n while head:\n k,v = head.data \n if k==key:\n head.data = (key,value)\n return \n if head.next==None:\n break\n else:\n head = head.next\n head.next= Node((key,value))","def put(self, key: int, value: int) -> None:\n pos = key % self.space\n head = self.hash_table[pos]\n curr = head\n\n while curr.next:\n if curr.next.key == key:\n curr.next.val = value\n return\n curr = curr.next\n\n curr.next = Node(key, value)","def put(self, key: int, value: int) -> None:\n\n index = self.hash(key)\n\n # If there's no other values here, just chuck it in!\n if not self.map[index]:\n self.map[index] = lNode((key, value))\n\n # Otherwise, we either need to rewrite \n # existing node or chuck on end of list - i.e. we have collision\n else:\n # Check head first since we'll need curr.next\n curr = self.map[index]\n\n # rewrite value if it exists\n if curr.val[0] == key:\n curr.val = (key, value)\n\n # Otherwise chuck on end of list\n else:\n while curr.next:\n\n # Forgot condition here...\n if curr.next.val[0] == key:\n curr.next.val = (key, value)\n return\n\n curr = curr.next\n\n curr.next = lNode((key,value))","def put(self, key: int, value: int) -> None:\n idx = key % self.size\n\n if self.hashmap[idx] == None:\n self.hashmap[idx] = ListNode(key, value)\n else:\n curr = self.hashmap[idx]\n while True:\n if curr.key == key:\n curr.value = value\n return\n if curr.next == None:\n break\n curr = curr.next\n curr.next = ListNode(key, value)","def put(self, key, value):\n # Your code here\n index = self.hash_index(key)\n # check for linkedlist if it is empty\n if self.data[index].head == None:\n self.data[index].head = HashTableEntry(key, value) # similar to node class we used before\n self.count +=1\n # #-----\n # self.loadfactor = self.count / self.capacity\n # if self.loadfactor > 0.7:\n # self.resize(self.capacity * 2)\n \n else:\n # Linklist is not empty \n # create reference for the head node\n cur= self.data[index].head\n\n while cur.next:\n # checking if the key already exist then we will just override the value\n if cur.key == key:\n cur.value == value\n # checking each node of the Linkedlist till we break the while loop \n cur= cur.next\n # if key is not found, add the new hashtableentry(key, value) to the linkedlist\n cur.next = HashTableEntry(key, value)\n self.count +=1","def put(self, key, value):\n h = key%self.m\n a = self.a\n if a[h]:\n a[h].val = value\n else:\n a[h] = ListNode(value)","def put(self, key, value):\n\n node = self._get_node(key) # Get the node with the key (if it exists)\n\n if node is None:\n index = self._get_index(key)\n self._buckets[index].add_front(key, value) # Key was not found (add it to the front of the list)\n self.size += 1\n else:\n node.value = value # Key was found (update the value)","def put(self, key, value):\n hashv = self.hash(key)\n bucket=self.hashmap[hashv]\n for i,(k,v) in enumerate(bucket):\n if k==key:\n bucket[i]=(key,value)\n return\n bucket.append((key,value))","def put(self, key: int, value: int) -> None:\n t = key % 20011\n for item in self.hash[t]:\n if item[0] == key:\n item[1] = value\n return\n self.hash[t].append([key, value])","def put(self, key, value):\n # Your code here\n\n idx = self.hash_index(key)\n entry = HashTableEntry(key, value)\n match = None\n\n # if there's already something stored at this index\n if self.hash_table[idx] is not None:\n curr_node = self.hash_table[idx]\n\n # look for an existing entry with the same key\n while match is None:\n if curr_node.key == key:\n match = curr_node\n else:\n curr_node = curr_node.next\n \n # if we reached the tail and still haven't found an existing match, break out of the loop\n if curr_node is None:\n break\n\n # if we reached the end and didn't find an existing entry matching the provided key\n # add a new entry at the end\n if match is None and curr_node.next is None:\n curr_node.next = entry\n self.total_items+= 1\n self.determine_resize_type()\n\n # if an entry with the provided key already exists, just update its value with the provided value\n elif match is not None:\n match.value = value\n \n \n # if nothing exists as this index, just add the entry\n else:\n self.hash_table[idx] = entry\n self.total_items+= 1\n self.determine_resize_type()","def put(self, key, value):\n index = key % self.size\n\n if not self.bucket[index]:\n self.bucket[index] = ListNode(key , value)\n else:\n cur = self.bucket[index]\n\n while cur:\n if cur.key == key:\n cur.val = value\n return\n if not cur.next: break\n cur = cur.next\n cur.next = ListNode(key, value)","def store(self, key, value):\n pass","def put(self, key, value):\r\n\r\n\r\n\t\tindex = self.get_index(key) # get the index\r\n\t\tcur_list = self._buckets[index] # this is the linked list\r\n\r\n\t\t# remove the key and assign the returned boolean in removed\r\n\t\tremoved = cur_list.remove(key)\r\n\t\tcur_list.add_front(key, value) # re-add the key with updated value\r\n\r\n\t\t# if removed is false, then a new key was added so increase size by 1\r\n\t\tif not removed:\r\n\t\t\tself.size += 1","def __setitem__(self, key, value):\n\n # Get hashed key\n i = self.hash(key)\n\n # If key not already in hash map\n if key not in self.keys_set:\n\n # Increment size\n self.size += 1\n\n # Add key to set of keys for reference\n self.keys_set.add(key)\n\n # Append key location to keys reference hash table\n self.keys_ref[i].append(key)\n\n # Apped value to hash map chain\n self.table[i].append(value)\n\n # If key already in hash map\n else:\n\n # Get key index for hash map chain\n chain_idx = self.keys_ref[i].index(key)\n\n # Overwrite value in hash map\n self.table[i][chain_idx] = value\n\n # If load greater than maximum load factor\n if self.load() >= self.max_load_factor:\n\n # Call resize for hash map\n self.resize()","def put(self, key, value):\n # O(1) in best case and O(n) in worst case Time Complexity\n # O(1) in best case and O(n) in worst case Space Complexity\n\n currentNode = self.getElement(key)\n if (currentNode.next == None):\n currentNode.next = Node(key, value)\n else:\n currentNode.next.v = value\n return","def put(self, key: int, value: int) -> None:\n hashKey = key % 1000\n if not self.bucket[hashKey]:\n self.bucket[hashKey] = LinkNode(key, value)\n else:\n node = self.bucket[hashKey]\n while node:\n if node.pair[0] == key:\n node.pair[1] = value\n return\n if not node.next:\n node.next = LinkNode(key, value)\n node = node.next","def set(self, key, value):\n # First, look for the key in the cache using `self.get()`\n # If not exists (returns None), add key-value to head\n # If exists, pop old key-value from list, add new value to head\n pass","def put(self, key, value):\n hash_key = key % self.key_space\n self.hash_table[hash_key].update(key, value)","def put(self, key: int, value: int) -> None:\n index = key % 10000\n head = self.array[index]\n while head.next:\n head = head.next\n if head.key == key:\n head.value = value\n return\n head.next = LinkedListNode(key, value)","def put(self, key, value):\n self._store[key] = value","def set_value(self, key: keyType, new_value: valueType) -> None:\n self.validate(key, new_value)\n head_node_index, chain_node_index = self.exist_key(key)\n # \"head_node_index is equal to -1\" means that 'key' doesn't exist in dictionary object.\n if head_node_index == -1:\n self.add(key, new_value)\n else:\n self.hashTable[head_node_index].singlyLinkedList[chain_node_index].values = [new_value]","def __setitem__(self, key_to_store: int, value: Any):\n hash = self.compute_hash(key_to_store)\n\n # First time we're seeing this\n if hash not in self.storage:\n self.storage[hash] = list()\n\n self.storage[hash].append((key_to_store, value))","def put(self, k: Any, v: Any):\n i = abs(hash(k)) % self.size\n current = self.data[i]\n while current is not None:\n if current.key == k:\n current.value = v\n return\n current = current.next\n new_node = self.Node(k, v)\n new_node.next = self.data[i]\n self.data[i] = new_node","def add(self, key: keyType, value: valueType) -> None:\n\n self.validate(key, value)\n hash_address = self.get_hash_address(key)\n head_node = self.hashTable[hash_address]\n\n # To uniform form of key\n uniform_key = key\n if isinstance(key, (list, set)):\n uniform_key = tuple(key)\n # else:\n # uniform_key = key\n # Create a new node and assign values.\n node_new = ChainNode()\n node_new.key = uniform_key\n node_new.values.append(value)\n\n # 'head_node.count == 0' means that there is no collision.\n if head_node.count == 0:\n head_node.singlyLinkedList.append(node_new)\n head_node.count = 1\n head_node.keys.append(uniform_key)\n else:\n # To deal with collision.\n if uniform_key not in head_node.keys:\n head_node.singlyLinkedList.append(node_new)\n head_node.keys.append(uniform_key)\n head_node.count = head_node.count + 1\n else:\n # For the same 'key', determine whether 'value' already exists. If not, then store.\n for index in range(len(head_node.singlyLinkedList)):\n if uniform_key == head_node.singlyLinkedList[index].key:\n if value not in head_node.singlyLinkedList[index].values:\n head_node.singlyLinkedList[index].values.append(value)\n head_node.count = head_node.count + 1\n break\n logger.info(\"Successfully add a new element.\")","def put(self, key: int, value: int) -> None:\n idx = key % 1000\n if not self.map[idx]:\n self.map[idx] = Node(key, value)\n else:\n curr = self.map[idx]\n while True:\n if curr.key == key:\n curr.val = value\n return\n if not curr.next:\n break\n curr = curr.next\n curr.next = Node(key, value)","def set(self, key, value):\n number = self._hash(key)\n stored_key = number if self.function == 'fnv' else key\n if self.get(key) is None:\n self.bucket_list[number % self.bucket_number].insert(stored_key, value)","def set(self, key, value):\n hk = hash(key)\n h = self._hash(hk)\n i = 0\n while i < self.size:\n if self.slot[h] == None:\n self.slot[h] = key\n self.data[h] = value\n break\n i += 1\n h = self._rehash(hk, i)","def store(self, key, value):\n self._cache[key] = value","def put(self, key: int, value: int) -> None:\n idx = key % self.size\n if self.mp[idx]:\n for i in range(len(self.mp[idx])):\n if self.mp[idx][i][0] == key:\n self.mp[idx][i][1] = value\n return\n self.mp[idx].append([key, value])\n else:\n self.mp[idx].append([key, value])","def _put(self, key, value, current_node):\n pass","def append(self, key, value):\n dkey = digest(key)\n node = Node(dkey)\n\n def append_(nodes):\n # if this node is close too, then store here as well\n if not nodes or self.node.distanceTo(node) < max([n.distanceTo(node) for n in nodes]):\n try:\n pvalue = json.loads(value)\n self.set_keys.add(dkey)\n if dkey not in self.storage:\n _log.debug(\"%s local append key: %s not in storage set value: %s\" % (base64.b64encode(node.id), base64.b64encode(dkey), pvalue))\n self.storage[dkey] = value\n else:\n old_value_ = self.storage[dkey]\n try:\n old_value = json.loads(old_value_)\n new_value = list(set(old_value + pvalue))\n except:\n # When the key have been used for single values it does not contain a list\n # When have been deleted contains None\n # Just replace old value\n new_value = pvalue\n old_value = old_value_\n _log.debug(\"%s local append key: %s old: %s add: %s new: %s\" % (base64.b64encode(node.id), base64.b64encode(dkey), old_value, pvalue, new_value))\n self.storage[dkey] = json.dumps(new_value)\n except:\n _log.debug(\"Trying to append something not a JSON coded list %s\" % value, exc_info=True)\n ds = [self.protocol.callAppend(n, dkey, value) for n in nodes]\n return defer.DeferredList(ds).addCallback(self._anyRespondSuccess)\n\n nearest = self.protocol.router.findNeighbors(node)\n if len(nearest) == 0:\n self.log.warning(\"There are no known neighbors to set key %s\" % key)\n _log.debug(\"There are no known neighbors to set key %s\" % key)\n return defer.succeed(False)\n\n spider = NodeSpiderCrawl(self.protocol, node, nearest, self.ksize, self.alpha)\n return spider.find().addCallback(append_)","def put(self, key, value):\n self.__setitem__(key=key, value=value)","def put(self, key: int, value: int) -> None:\n pos = self.hash(key)\n self.table[pos][key] = value","def put(self, key: int, value: int) -> None:\n chain, idx = self._search(key)\n if idx is None:\n chain.append((key, value))\n else:\n chain[idx] = (key, value)","def put(self, key, val):\n pass","def __setitem__(self, key, value):\n if self.count == self.size: # For now, rehash only when full (better to keep it half empty always)\n self.rehash()\n\n hashed_idx = self._linear_probe(key, \"set\") # Get position to put. _probe() takes care of hashing the key\n if self.keys[hashed_idx] != key: # If _probe() returns a spot that doesn't have this key, then increment count\n self.count += 1\n self.keys[hashed_idx] = key # Store key in the keys array\n self.values[hashed_idx] = value # Store value in the values array","def put(self, key: int, value: int) -> None:\n if key in self.keys:\n self.values[self.keys.index(key)] = value\n else:\n self.keys.append(key)\n self.values.append(value)","def __setitem__(self, key, value):\n self.put(key, value)","def __setitem__(self, key, value):\n self.put(key, value)","def put(self, key, value):\n hash_key = self._hash_function(key) % self.capacity # finds index for new key/value pair\n\n if self._buckets[hash_key].size == 0: # if bucket is empty, add new key/value pair\n self.size += 1\n self._buckets[hash_key].add_front(key, value)\n else:\n if self._buckets[hash_key].contains(key):\n self._buckets[hash_key].remove(key) # if key already exists, delete old key/value pair\n self.size -= 1\n self._buckets[hash_key].add_front(key, value) # add new key/value pair\n self.size += 1","def __setitem__(self, key, value):\n\t\tself.__dStore[key] = value","def insert_key(self, key : str, value : int) -> None:\n \n hash_key = self.hash_key(key)\n head = self.array[hash_key]\n \n while head.next:\n if head.next.key == key:\n head.next.value = value\n return\n head = head.next\n head.next = Node(key,value)\n self.keys.append(key)","def put(k, v):\n index = get_index(k)\n hash_data[index] = v","def __setitem__(self, key, value):\n self._get_storage()[key] = value","def add(self, key, value):\n self._store[key] = value","def put(self, key: int, value: int) -> None:\n index = key % self.size\n \n if self.table[index].value == None:\n self.table[index] = ListNode(key, value)\n return\n \n p = self.table[index]\n while p:\n if p.key == key:\n p.value = value\n return\n \n if p.next is None:\n break\n p = p.next\n p.next = ListNode(key,value)","def insert(self, key, value):\n hash_key = hash(key) % self.length\n bucket = self.array[hash_key]\n for idx, key_val_pair in enumerate(bucket):\n k, v = key_val_pair\n if k == key:\n bucket[idx] = [key, value]\n return\n bucket.append([key, value])","def insert(self, key, value):\n\n # Map key to an index in main_array\n item_index = self._key_hash(key)\n\n # Turn input key, value pair into a HashEntry object\n data = HashEntry(key, value)\n\n # Append key, value pair to end of appropriate linked list\n self.main_array[item_index].append(data)","def put(self, key: int, value: int) -> None:\n self.hashmap[key] = value","def put(self, key: int, value: int) -> None:\n sh = key % 37\n if self.map[sh] == None:\n self.map[sh] = [[key, value]]\n return\n for i in range(len(self.map[sh])):\n kv = self.map[sh][i]\n if kv[0] == key:\n kv[1] = value\n return\n self.map[sh].append([key, value])","def set(self, key: t.Hashable, value: t.Any) -> None:","def set(self, key, value):\r\n if not isinstance(key, str):\r\n raise TypeError(\"Key must be a string\")\r\n\r\n bin_num = self._get_bin(key)\r\n cur = self.bins[bin_num]\r\n\r\n if cur.next is None: # If first element is trailer node, insert here\r\n self._ensure_load()\r\n self.bins[bin_num] = Node((key, value), cur)\r\n success = True\r\n elif cur.value[0] == key: # If existing key, overwrite\r\n cur.value = (cur.value[0], value)\r\n success = False\r\n else: # Move towards end of linked list\r\n while cur.next is not None:\r\n prev = cur\r\n cur = cur.next\r\n self._ensure_load()\r\n prev.next = Node((key, value), cur)\r\n success = True\r\n\r\n if success:\r\n self.size += 1\r\n return success","def put(self, key, value):\r\n temp = [key, value]\r\n flag = False\r\n for i in range(len(self.lis)):\r\n if self.lis[i][0] == temp[0]:\r\n self.lis[i][1] = temp[1]\r\n flag = True\r\n break\r\n if flag == False:\r\n self.lis.append(temp)","def __setitem__(self, key, value):\n self.list[key] = value","def __setitem__(self, key, value):\n\n bucket_key = self.key_for_bucket(key)\n self.buckets[bucket_key][key] = value","def __setitem__(self, key: Hashable, value: Any) -> None:\n self.contents[key] = value\n return","def set(self, key, val):\n if not isinstance(key, str):\n raise TypeError('key must be type str')\n index = self._hash(key)\n bucket = self.table[index]\n for item in bucket:\n if key == item[0]:\n bucket.remove(item)\n break\n bucket.append((key, val))\n return None","def set(self, key, val):\n if not isinstance(key, str):\n raise TypeError('key must be type str')\n index = self._hash(key)\n bucket = self.table[index]\n for item in bucket:\n if key == item[0]:\n bucket.remove(item)\n break\n bucket.append((key, val))\n return None","def __setitem__(self, key, value):\n self.tree[key] = value","def set(self, key, value):\n # Find bucket where given key belongs\n # Check if key-value entry exists in bucket\n # If found, update value associated with given key\n # Otherwise, insert given key-value entry into bucket\n # key bucket index\n key_bucket = self._bucket_index(key) # O(1) time\n bucket = self.buckets[key_bucket] # O(1) time\n in_hash_table = False\n\n \"\"\"\n # for key_value_tuple in bucket.items():\n # old_key, old_value = key_value_tuple\n items = bucket.items() # O(l) for l items in bucket (LL)\n for old_key, old_value in items: # O(l) iterations in worst case, O(1) beast case\n if old_key is key:\n in_hash_table = True\n bucket.delete((key, old_value)) # O(l)\n bucket.append((key, value)) # O(1)\n \"\"\"\n\n # O(l) in worst case because we iterate over all nodes if near tail or not found\n key_value_pair = bucket.find(lambda key_value: key_value[0] == key)\n if key_value_pair is not None:\n bucket.delete(key_value_pair) # O(l) time in worst case\n bucket.append((key, value)) # O(1) time if using tail\n\n # if not in_hash_table:\n else:\n bucket.append((key, value))","def put(self, key, value):\n while len(self.buckets) <= key:\n self.buckets = self.buckets + [-1] * len(self.buckets)\n self.length = self.length * 2\n self.buckets[key] = value","def put(self, key, value):\n return self.sp.put(key, value)","def add(self, key: str, value: str) -> Optional[None]:\n threshhold = self.capacity * 0.75\n if self.length >= threshhold:\n self._increase_size()\n\n hashkey = self._gethash(key)\n if not self.HashMap[hashkey]:\n # The key does not exist so add it\n value_to_store = [key, value]\n self.HashMap[hashkey] = value_to_store\n self.length += 1\n elif self.HashMap[hashkey] and key not in self.HashMap[hashkey]:\n # There is a hashclash append to the location\n self.HashMap[hashkey].extend([key, value])\n self.length += 1\n else:\n # The key exists and matches so the value gets overlayed\n self.HashMap[hashkey] = [key, value]","def __setitem__(self, key, value):\n self.set(key, value)","def __setitem__(self, key, value):\n self.set(key, value)","def __setitem__(self, key, value):\n self.set(key, value)","def _put(self, key: str, value):\n pass","def set(self, key, value):\n self.log.debug(\"setting '%s' = '%s' on network\" % (key, value))\n dkey = digest(key)\n node = Node(dkey)\n\n def store(nodes):\n self.log.info(\"setting '%s' on %s\" % (key, list(map(str, nodes))))\n # if this node is close too, then store here as well\n if self.node.distanceTo(node) < max([n.distanceTo(node) for n in nodes]):\n self.storage[dkey] = value\n ds = [self.protocol.callStore(n, dkey, value) for n in nodes]\n d = defer.DeferredList(ds)\n d.addCallback(self._anyRespondSuccess)\n d.addErrback(self.onError)\n return d\n\n nearest = self.protocol.router.findNeighbors(node)\n if len(nearest) == 0:\n self.log.warning(\"There are no known neighbors to set key %s\" % key)\n return defer.succeed(False)\n spider = NodeSpiderCrawl(self.protocol, node, nearest, self.ksize, self.alpha)\n d = spider.find()\n d.addCallback(store)\n d.addErrback(self.onError)\n return d","def __setitem__(self, key, value):\n index=self._index(key)\n if index==-1:\n self._item.append(Item(key,value))\n self._size+=1\n else:\n self._item[index].value=value","def set(self, key, value):\n # TODO: Insert or update the given key-value entry into a bucket\n hash_key = self._bucket_index(key) # Gets the key in the array\n key_value = (key, value) # Store tuple containing key and value in key_value\n bucket = self.buckets[hash_key]\n\n if bucket.find(lambda (tuple_key, _): tuple_key == key):\n self.delete(key) # Removing the key from the list\n return True\n\n bucket.append(key_value) # Append the new tuple\n self.size += 1 # Change the size because the delete reduces it by 2\n return True\n\n # Important example of repetition\n ''' if bucket.is_empty() is True: # Bucket returns None, the result of the hash_key, if empty\n self.size += 1 # Increments the size everytime set() is called\n bucket.append(key_value) # Creates a new list based on the hash_key\n return True\n # If bucket contains key\n elif bucket.find(lambda (tuple_key, _): tuple_key == key):\n # elif bucket.find(lambda (k, v): k == key):\n # elif bucket.find(lambda data: data[0] == key):\n self.delete(key) # Removing the key from the list\n bucket.append(key_value) # Append the new tuple\n self.size += 1 # Change the size because the delete reduces it by 2\n return True\n else: # Bucket contains key-value entry\n bucket.append(key_value) # If the key doesn't exist, add the tuple\n self.size += 1 # Increments the size everytime set() is called\n return True\n '''","def _insert(self, key, value):\n entry = self._lookup(key)\n if entry.value is None:\n self.used += 1\n if entry.key is not dummy:\n self.filled += 1\n entry.key = key\n entry.hash = self.first_hash(key)\n entry.value = value","def __setitem__(self, key, val):\n self.__check_key_validity(key)\n self.data[key[0]][key[1]] = val","def put(self, key, value):\n try: \n value = self.pop(key)\n \n except KeyError: \n if len(self) >= self.max_size: \n self.popitem(last=False)\n \n self[key] = value","def put(self, key, value):\n if key is None or value is None:\n raise TypeError\n\n index = self.__get_cache_set_index(key)\n cache_set = self.cache_sets[index]\n h_key = self.__ensure_hashable_key(key)\n cache_set.put(h_key, value)","def __setitem__(self, key, value):\n try:\n index = self.__keys.index(key)\n self.__vals[index] = value\n except ValueError:\n try:\n index = self.__vals.index(key)\n self.__keys[index] = value\n except ValueError:\n self.__keys.append(key)\n self.__vals.append(value)","def set(self, key, value):\n validate_is_bytes(key)\n validate_is_bytes(value)\n\n self.root_hash = self._set(self.root_hash, encode_to_bin(key), value)","def __setitem__(self, key, value):\n\n key = to_unicode(key)\n\n if key in self:\n key = self.get_data_reference(key, default=key)\n else:\n if self.is_view:\n self._view.append(key)\n\n self._storage[key] = to_unicode(value)","def put(self, key, obj):\n \n\n def find(found_item, hash_table_cell):\n \"\"\"This function is a closer function which will pass to the find_by_key function to get the value. the purpose of this \n function is to check if key is already present than replace the value else append the value in same bucket.\"\"\"\n if found_item:\n found_item[1] = obj\n else:\n hash_table_cell.append([key, obj])\n self.size += 1\n self._keys.append(key)\n\n self._find_by_key(key, find)\n return self","def __setitem__(self, key, value):\n try:\n kvp = self.keyvaluepair_set.get(key=key)\n except KeyValuePair.DoesNotExist:\n KeyValuePair.objects.create(container=self, key=key, value=value)\n else:\n kvp.value = value\n kvp.save()","def __setitem__(self, key, value):\n self.setdefault(key, []).append(value)","def __setitem__(self, key, value):\n self.setdefault(key, []).append(value)","def __setitem__(self, key, value):\r\n self.setdefault(key, []).append(value)","def put(hash, key: int, value: V) -> HashMap:\r\n if hash == None:\r\n hash = HashMap()\r\n hash_key = key % hash.size\r\n if hash.data[hash_key].key == None:\r\n hash.data[hash_key].value = value\r\n hash.data[hash_key].key = key\r\n hash.keyset.append(key)\r\n else:\r\n temp = Node(key, value)\r\n hash.keyset.append(key)\r\n p = hash.data[hash_key]\r\n while p.next != None:\r\n p = p.next\r\n p.next = temp\r\n\r\n return hash","def set(self, key, value):\n _log.debug(\"setting '%s' = '%s' on network\" % (key, value))\n dkey = digest(key)\n node = Node(dkey)\n\n def store(nodes):\n _log.debug(\"setting '%s' to %s on %s\" % (key, value, map(str, nodes)))\n # if this node is close too, then store here as well\n if (not nodes or self.node.distanceTo(node) < max([n.distanceTo(node) for n in nodes]) or\n dkey in self.storage):\n _log.debug(\"setting '%s' to %s locally\" % (key, value))\n self.storage[dkey] = value\n ds = [self.protocol.callStore(n, dkey, value) for n in nodes]\n return defer.DeferredList(ds).addCallback(self._anyRespondSuccess)\n\n nearest = self.protocol.router.findNeighbors(node)\n if len(nearest) == 0:\n _log.warning(\"There are no known neighbors to set key %s\" % key)\n return defer.succeed(False)\n spider = NodeSpiderCrawl(self.protocol, node, nearest, self.ksize, self.alpha)\n return spider.find().addCallback(store)","def __setitem__(self, key, value):\n self._data[key] = value","def __setitem__(self, key, value):\n list.__setitem__(self, key, self.convertNode(value))","def set(self, key, value):\n #try to lock the tree. If we succeed make sure\n #we dont lose updates from any other process\n if self._storage.lock():\n self._refresh_tree_ref()\n #get current top-level node and make a value-ref\n node = self._follow(self._tree_ref)\n value_ref = ValueRef(value)\n #insert and get new tree ref\n self._tree_ref = self._insert(node, key, value_ref)\n self._tree_ref = self._blacken(self._follow(self._tree_ref))","def __setitem__(self, key, value):\n if not key in self.ordered_list:\n self.ordered_list.append(key)\n self.__dict__[key] = value","def put_key_value(self, key, value):\n if self.is_key_in_cache(key):\n entry_node, entry_frequency_node = self.__remove_key(key)\n entry_node.value = value\n if entry_frequency_node.next.key != entry_frequency_node.key + 1:\n self.__create_frequency_node_after(entry_frequency_node)\n self.key_to_frequency_node[entry_node.key] = entry_frequency_node.next\n self.__add_entry_to_frequency_node(entry_node, entry_frequency_node.next)\n if entry_frequency_node.frequency_cache.size == 0: # if frequency group now empty, remove it\n self.__remove_frequency_node(entry_frequency_node)\n elif self.is_at_capacity():\n self.__evict_least_frequent_entry()\n self.__add_new_entry(key, value)\n else:\n self.__add_new_entry(key, value)","def __setitem__(self, key, value):\n self.data[key] = value","def __setitem__(self, key, value):\n self.data[key] = value","def __setitem__(self, key, value):\r\n key = self.key(key)\r\n if key in self.data_with_same_key:\r\n self.data_with_same_key[key] += [self.data[key]]\r\n elif key in self.data:\r\n self.data_with_same_key[key] = [self.data[key]]\r\n self.data[key] = value","def set(self, key, value):\n raise NotImplementedError","def put(self, key, value):\n self.container[key] = value","def put(self, key, value):\n i = key //1000\n j = key%1000\n self.container[i][j] = value","def add(self, key, value):\n\t\tself.__add_key_to_bt(key)[3] = self.__add_key_value_to_ll(key, value)","def __setitem__(self, key, value):\r\n self.data[key] = value","def __setitem__(self, key, value):\n bucket = self._buckets[self._index(key)]\n for node in bucket.linked_list:\n # key, value pair stored in bucket linked list\n bucket_object_key, bucket_object_value = node.value\n assert isinstance(bucket_object_key, BucketObject)\n assert isinstance(bucket_object_value, BucketObject)\n if bucket_object_key.load_value() == key:\n key_list_node, value_list_node = (\n self._object_to_list_node[bucket_object_key],\n self._object_to_list_node[bucket_object_value],\n )\n # update key_list_node and remove value_list_node\n self._in_memory_objects.remove_and_append(key_list_node)\n self._disk_objects.remove_and_append(key_list_node)\n self._in_memory_objects.remove(value_list_node)\n self._disk_objects.remove(value_list_node)\n self._object_to_list_node.pop(bucket_object_value)\n # append value list node to in-memory linked list\n bucket_object_value.value = value\n self._object_to_list_node[\n bucket_object_value\n ] = DoublyLinkedList.create_new_node(bucket_object_value)\n self._in_memory_objects.append(\n self._object_to_list_node[bucket_object_value]\n )\n # balance memory usage\n self._balance()\n return\n # append key-value pair to current bucket\n bucket_object_key, bucket_object_value = (\n BucketObject(key, bucket),\n BucketObject(value, bucket),\n )\n bucket.linked_list.append(\n DoublyLinkedList.create_new_node((bucket_object_key, bucket_object_value))\n )\n # append key_object and value_object to in_memory_objects\n key_list_node = DoublyLinkedList.create_new_node(bucket_object_key)\n self._in_memory_objects.append(key_list_node)\n value_list_node = DoublyLinkedList.create_new_node(bucket_object_value)\n self._in_memory_objects.append(value_list_node)\n # update object -> list node dict\n self._object_to_list_node[bucket_object_key] = key_list_node\n self._object_to_list_node[bucket_object_value] = value_list_node\n # balance memory usage\n self._balance()"],"string":"[\n \"def put(self, key, value):\\n ha = self.myhash(key)\\n if key not in self.hashmap[ha][0]:\\n self.hashmap[ha][0].append(key)\\n self.hashmap[ha][1].append(value)\\n else:\\n self.hashmap[ha][1][self.hashmap[ha][0].index(key)] = value\",\n \"def put(self, key, value):\\n index = key % self.size\\n\\n if not self.hash_table[index]:\\n # We do not have anything in this bin, just create a new node\\n self.hash_table[index] = ListNode(key, value)\\n else:\\n # We do have something in this bin, traverse it checking to see if we have a matching key.\\n # If not just append a node to the end of the bin\\n curr_node = self.hash_table[index]\\n\\n while curr_node:\\n if curr_node.key == key:\\n curr_node.value = value\\n return\\n if not curr_node.next:\\n break\\n curr_node = curr_node.next\\n # Did not find a matching key here, so append a key, value pair in this bin\\n curr_node.next = ListNode(key, value)\",\n \"def put(self, key: int, value: int) -> None:\\n hashvalue = key % 1000\\n \\n if self.hashset[hashvalue] ==None:\\n \\n self.hashset[hashvalue]=Node((key,value))\\n else :\\n head= self.hashset[hashvalue]\\n while head:\\n k,v = head.data \\n if k==key:\\n head.data = (key,value)\\n return \\n if head.next==None:\\n break\\n else:\\n head = head.next\\n head.next= Node((key,value))\",\n \"def put(self, key: int, value: int) -> None:\\n pos = key % self.space\\n head = self.hash_table[pos]\\n curr = head\\n\\n while curr.next:\\n if curr.next.key == key:\\n curr.next.val = value\\n return\\n curr = curr.next\\n\\n curr.next = Node(key, value)\",\n \"def put(self, key: int, value: int) -> None:\\n\\n index = self.hash(key)\\n\\n # If there's no other values here, just chuck it in!\\n if not self.map[index]:\\n self.map[index] = lNode((key, value))\\n\\n # Otherwise, we either need to rewrite \\n # existing node or chuck on end of list - i.e. we have collision\\n else:\\n # Check head first since we'll need curr.next\\n curr = self.map[index]\\n\\n # rewrite value if it exists\\n if curr.val[0] == key:\\n curr.val = (key, value)\\n\\n # Otherwise chuck on end of list\\n else:\\n while curr.next:\\n\\n # Forgot condition here...\\n if curr.next.val[0] == key:\\n curr.next.val = (key, value)\\n return\\n\\n curr = curr.next\\n\\n curr.next = lNode((key,value))\",\n \"def put(self, key: int, value: int) -> None:\\n idx = key % self.size\\n\\n if self.hashmap[idx] == None:\\n self.hashmap[idx] = ListNode(key, value)\\n else:\\n curr = self.hashmap[idx]\\n while True:\\n if curr.key == key:\\n curr.value = value\\n return\\n if curr.next == None:\\n break\\n curr = curr.next\\n curr.next = ListNode(key, value)\",\n \"def put(self, key, value):\\n # Your code here\\n index = self.hash_index(key)\\n # check for linkedlist if it is empty\\n if self.data[index].head == None:\\n self.data[index].head = HashTableEntry(key, value) # similar to node class we used before\\n self.count +=1\\n # #-----\\n # self.loadfactor = self.count / self.capacity\\n # if self.loadfactor > 0.7:\\n # self.resize(self.capacity * 2)\\n \\n else:\\n # Linklist is not empty \\n # create reference for the head node\\n cur= self.data[index].head\\n\\n while cur.next:\\n # checking if the key already exist then we will just override the value\\n if cur.key == key:\\n cur.value == value\\n # checking each node of the Linkedlist till we break the while loop \\n cur= cur.next\\n # if key is not found, add the new hashtableentry(key, value) to the linkedlist\\n cur.next = HashTableEntry(key, value)\\n self.count +=1\",\n \"def put(self, key, value):\\n h = key%self.m\\n a = self.a\\n if a[h]:\\n a[h].val = value\\n else:\\n a[h] = ListNode(value)\",\n \"def put(self, key, value):\\n\\n node = self._get_node(key) # Get the node with the key (if it exists)\\n\\n if node is None:\\n index = self._get_index(key)\\n self._buckets[index].add_front(key, value) # Key was not found (add it to the front of the list)\\n self.size += 1\\n else:\\n node.value = value # Key was found (update the value)\",\n \"def put(self, key, value):\\n hashv = self.hash(key)\\n bucket=self.hashmap[hashv]\\n for i,(k,v) in enumerate(bucket):\\n if k==key:\\n bucket[i]=(key,value)\\n return\\n bucket.append((key,value))\",\n \"def put(self, key: int, value: int) -> None:\\n t = key % 20011\\n for item in self.hash[t]:\\n if item[0] == key:\\n item[1] = value\\n return\\n self.hash[t].append([key, value])\",\n \"def put(self, key, value):\\n # Your code here\\n\\n idx = self.hash_index(key)\\n entry = HashTableEntry(key, value)\\n match = None\\n\\n # if there's already something stored at this index\\n if self.hash_table[idx] is not None:\\n curr_node = self.hash_table[idx]\\n\\n # look for an existing entry with the same key\\n while match is None:\\n if curr_node.key == key:\\n match = curr_node\\n else:\\n curr_node = curr_node.next\\n \\n # if we reached the tail and still haven't found an existing match, break out of the loop\\n if curr_node is None:\\n break\\n\\n # if we reached the end and didn't find an existing entry matching the provided key\\n # add a new entry at the end\\n if match is None and curr_node.next is None:\\n curr_node.next = entry\\n self.total_items+= 1\\n self.determine_resize_type()\\n\\n # if an entry with the provided key already exists, just update its value with the provided value\\n elif match is not None:\\n match.value = value\\n \\n \\n # if nothing exists as this index, just add the entry\\n else:\\n self.hash_table[idx] = entry\\n self.total_items+= 1\\n self.determine_resize_type()\",\n \"def put(self, key, value):\\n index = key % self.size\\n\\n if not self.bucket[index]:\\n self.bucket[index] = ListNode(key , value)\\n else:\\n cur = self.bucket[index]\\n\\n while cur:\\n if cur.key == key:\\n cur.val = value\\n return\\n if not cur.next: break\\n cur = cur.next\\n cur.next = ListNode(key, value)\",\n \"def store(self, key, value):\\n pass\",\n \"def put(self, key, value):\\r\\n\\r\\n\\r\\n\\t\\tindex = self.get_index(key) # get the index\\r\\n\\t\\tcur_list = self._buckets[index] # this is the linked list\\r\\n\\r\\n\\t\\t# remove the key and assign the returned boolean in removed\\r\\n\\t\\tremoved = cur_list.remove(key)\\r\\n\\t\\tcur_list.add_front(key, value) # re-add the key with updated value\\r\\n\\r\\n\\t\\t# if removed is false, then a new key was added so increase size by 1\\r\\n\\t\\tif not removed:\\r\\n\\t\\t\\tself.size += 1\",\n \"def __setitem__(self, key, value):\\n\\n # Get hashed key\\n i = self.hash(key)\\n\\n # If key not already in hash map\\n if key not in self.keys_set:\\n\\n # Increment size\\n self.size += 1\\n\\n # Add key to set of keys for reference\\n self.keys_set.add(key)\\n\\n # Append key location to keys reference hash table\\n self.keys_ref[i].append(key)\\n\\n # Apped value to hash map chain\\n self.table[i].append(value)\\n\\n # If key already in hash map\\n else:\\n\\n # Get key index for hash map chain\\n chain_idx = self.keys_ref[i].index(key)\\n\\n # Overwrite value in hash map\\n self.table[i][chain_idx] = value\\n\\n # If load greater than maximum load factor\\n if self.load() >= self.max_load_factor:\\n\\n # Call resize for hash map\\n self.resize()\",\n \"def put(self, key, value):\\n # O(1) in best case and O(n) in worst case Time Complexity\\n # O(1) in best case and O(n) in worst case Space Complexity\\n\\n currentNode = self.getElement(key)\\n if (currentNode.next == None):\\n currentNode.next = Node(key, value)\\n else:\\n currentNode.next.v = value\\n return\",\n \"def put(self, key: int, value: int) -> None:\\n hashKey = key % 1000\\n if not self.bucket[hashKey]:\\n self.bucket[hashKey] = LinkNode(key, value)\\n else:\\n node = self.bucket[hashKey]\\n while node:\\n if node.pair[0] == key:\\n node.pair[1] = value\\n return\\n if not node.next:\\n node.next = LinkNode(key, value)\\n node = node.next\",\n \"def set(self, key, value):\\n # First, look for the key in the cache using `self.get()`\\n # If not exists (returns None), add key-value to head\\n # If exists, pop old key-value from list, add new value to head\\n pass\",\n \"def put(self, key, value):\\n hash_key = key % self.key_space\\n self.hash_table[hash_key].update(key, value)\",\n \"def put(self, key: int, value: int) -> None:\\n index = key % 10000\\n head = self.array[index]\\n while head.next:\\n head = head.next\\n if head.key == key:\\n head.value = value\\n return\\n head.next = LinkedListNode(key, value)\",\n \"def put(self, key, value):\\n self._store[key] = value\",\n \"def set_value(self, key: keyType, new_value: valueType) -> None:\\n self.validate(key, new_value)\\n head_node_index, chain_node_index = self.exist_key(key)\\n # \\\"head_node_index is equal to -1\\\" means that 'key' doesn't exist in dictionary object.\\n if head_node_index == -1:\\n self.add(key, new_value)\\n else:\\n self.hashTable[head_node_index].singlyLinkedList[chain_node_index].values = [new_value]\",\n \"def __setitem__(self, key_to_store: int, value: Any):\\n hash = self.compute_hash(key_to_store)\\n\\n # First time we're seeing this\\n if hash not in self.storage:\\n self.storage[hash] = list()\\n\\n self.storage[hash].append((key_to_store, value))\",\n \"def put(self, k: Any, v: Any):\\n i = abs(hash(k)) % self.size\\n current = self.data[i]\\n while current is not None:\\n if current.key == k:\\n current.value = v\\n return\\n current = current.next\\n new_node = self.Node(k, v)\\n new_node.next = self.data[i]\\n self.data[i] = new_node\",\n \"def add(self, key: keyType, value: valueType) -> None:\\n\\n self.validate(key, value)\\n hash_address = self.get_hash_address(key)\\n head_node = self.hashTable[hash_address]\\n\\n # To uniform form of key\\n uniform_key = key\\n if isinstance(key, (list, set)):\\n uniform_key = tuple(key)\\n # else:\\n # uniform_key = key\\n # Create a new node and assign values.\\n node_new = ChainNode()\\n node_new.key = uniform_key\\n node_new.values.append(value)\\n\\n # 'head_node.count == 0' means that there is no collision.\\n if head_node.count == 0:\\n head_node.singlyLinkedList.append(node_new)\\n head_node.count = 1\\n head_node.keys.append(uniform_key)\\n else:\\n # To deal with collision.\\n if uniform_key not in head_node.keys:\\n head_node.singlyLinkedList.append(node_new)\\n head_node.keys.append(uniform_key)\\n head_node.count = head_node.count + 1\\n else:\\n # For the same 'key', determine whether 'value' already exists. If not, then store.\\n for index in range(len(head_node.singlyLinkedList)):\\n if uniform_key == head_node.singlyLinkedList[index].key:\\n if value not in head_node.singlyLinkedList[index].values:\\n head_node.singlyLinkedList[index].values.append(value)\\n head_node.count = head_node.count + 1\\n break\\n logger.info(\\\"Successfully add a new element.\\\")\",\n \"def put(self, key: int, value: int) -> None:\\n idx = key % 1000\\n if not self.map[idx]:\\n self.map[idx] = Node(key, value)\\n else:\\n curr = self.map[idx]\\n while True:\\n if curr.key == key:\\n curr.val = value\\n return\\n if not curr.next:\\n break\\n curr = curr.next\\n curr.next = Node(key, value)\",\n \"def set(self, key, value):\\n number = self._hash(key)\\n stored_key = number if self.function == 'fnv' else key\\n if self.get(key) is None:\\n self.bucket_list[number % self.bucket_number].insert(stored_key, value)\",\n \"def set(self, key, value):\\n hk = hash(key)\\n h = self._hash(hk)\\n i = 0\\n while i < self.size:\\n if self.slot[h] == None:\\n self.slot[h] = key\\n self.data[h] = value\\n break\\n i += 1\\n h = self._rehash(hk, i)\",\n \"def store(self, key, value):\\n self._cache[key] = value\",\n \"def put(self, key: int, value: int) -> None:\\n idx = key % self.size\\n if self.mp[idx]:\\n for i in range(len(self.mp[idx])):\\n if self.mp[idx][i][0] == key:\\n self.mp[idx][i][1] = value\\n return\\n self.mp[idx].append([key, value])\\n else:\\n self.mp[idx].append([key, value])\",\n \"def _put(self, key, value, current_node):\\n pass\",\n \"def append(self, key, value):\\n dkey = digest(key)\\n node = Node(dkey)\\n\\n def append_(nodes):\\n # if this node is close too, then store here as well\\n if not nodes or self.node.distanceTo(node) < max([n.distanceTo(node) for n in nodes]):\\n try:\\n pvalue = json.loads(value)\\n self.set_keys.add(dkey)\\n if dkey not in self.storage:\\n _log.debug(\\\"%s local append key: %s not in storage set value: %s\\\" % (base64.b64encode(node.id), base64.b64encode(dkey), pvalue))\\n self.storage[dkey] = value\\n else:\\n old_value_ = self.storage[dkey]\\n try:\\n old_value = json.loads(old_value_)\\n new_value = list(set(old_value + pvalue))\\n except:\\n # When the key have been used for single values it does not contain a list\\n # When have been deleted contains None\\n # Just replace old value\\n new_value = pvalue\\n old_value = old_value_\\n _log.debug(\\\"%s local append key: %s old: %s add: %s new: %s\\\" % (base64.b64encode(node.id), base64.b64encode(dkey), old_value, pvalue, new_value))\\n self.storage[dkey] = json.dumps(new_value)\\n except:\\n _log.debug(\\\"Trying to append something not a JSON coded list %s\\\" % value, exc_info=True)\\n ds = [self.protocol.callAppend(n, dkey, value) for n in nodes]\\n return defer.DeferredList(ds).addCallback(self._anyRespondSuccess)\\n\\n nearest = self.protocol.router.findNeighbors(node)\\n if len(nearest) == 0:\\n self.log.warning(\\\"There are no known neighbors to set key %s\\\" % key)\\n _log.debug(\\\"There are no known neighbors to set key %s\\\" % key)\\n return defer.succeed(False)\\n\\n spider = NodeSpiderCrawl(self.protocol, node, nearest, self.ksize, self.alpha)\\n return spider.find().addCallback(append_)\",\n \"def put(self, key, value):\\n self.__setitem__(key=key, value=value)\",\n \"def put(self, key: int, value: int) -> None:\\n pos = self.hash(key)\\n self.table[pos][key] = value\",\n \"def put(self, key: int, value: int) -> None:\\n chain, idx = self._search(key)\\n if idx is None:\\n chain.append((key, value))\\n else:\\n chain[idx] = (key, value)\",\n \"def put(self, key, val):\\n pass\",\n \"def __setitem__(self, key, value):\\n if self.count == self.size: # For now, rehash only when full (better to keep it half empty always)\\n self.rehash()\\n\\n hashed_idx = self._linear_probe(key, \\\"set\\\") # Get position to put. _probe() takes care of hashing the key\\n if self.keys[hashed_idx] != key: # If _probe() returns a spot that doesn't have this key, then increment count\\n self.count += 1\\n self.keys[hashed_idx] = key # Store key in the keys array\\n self.values[hashed_idx] = value # Store value in the values array\",\n \"def put(self, key: int, value: int) -> None:\\n if key in self.keys:\\n self.values[self.keys.index(key)] = value\\n else:\\n self.keys.append(key)\\n self.values.append(value)\",\n \"def __setitem__(self, key, value):\\n self.put(key, value)\",\n \"def __setitem__(self, key, value):\\n self.put(key, value)\",\n \"def put(self, key, value):\\n hash_key = self._hash_function(key) % self.capacity # finds index for new key/value pair\\n\\n if self._buckets[hash_key].size == 0: # if bucket is empty, add new key/value pair\\n self.size += 1\\n self._buckets[hash_key].add_front(key, value)\\n else:\\n if self._buckets[hash_key].contains(key):\\n self._buckets[hash_key].remove(key) # if key already exists, delete old key/value pair\\n self.size -= 1\\n self._buckets[hash_key].add_front(key, value) # add new key/value pair\\n self.size += 1\",\n \"def __setitem__(self, key, value):\\n\\t\\tself.__dStore[key] = value\",\n \"def insert_key(self, key : str, value : int) -> None:\\n \\n hash_key = self.hash_key(key)\\n head = self.array[hash_key]\\n \\n while head.next:\\n if head.next.key == key:\\n head.next.value = value\\n return\\n head = head.next\\n head.next = Node(key,value)\\n self.keys.append(key)\",\n \"def put(k, v):\\n index = get_index(k)\\n hash_data[index] = v\",\n \"def __setitem__(self, key, value):\\n self._get_storage()[key] = value\",\n \"def add(self, key, value):\\n self._store[key] = value\",\n \"def put(self, key: int, value: int) -> None:\\n index = key % self.size\\n \\n if self.table[index].value == None:\\n self.table[index] = ListNode(key, value)\\n return\\n \\n p = self.table[index]\\n while p:\\n if p.key == key:\\n p.value = value\\n return\\n \\n if p.next is None:\\n break\\n p = p.next\\n p.next = ListNode(key,value)\",\n \"def insert(self, key, value):\\n hash_key = hash(key) % self.length\\n bucket = self.array[hash_key]\\n for idx, key_val_pair in enumerate(bucket):\\n k, v = key_val_pair\\n if k == key:\\n bucket[idx] = [key, value]\\n return\\n bucket.append([key, value])\",\n \"def insert(self, key, value):\\n\\n # Map key to an index in main_array\\n item_index = self._key_hash(key)\\n\\n # Turn input key, value pair into a HashEntry object\\n data = HashEntry(key, value)\\n\\n # Append key, value pair to end of appropriate linked list\\n self.main_array[item_index].append(data)\",\n \"def put(self, key: int, value: int) -> None:\\n self.hashmap[key] = value\",\n \"def put(self, key: int, value: int) -> None:\\n sh = key % 37\\n if self.map[sh] == None:\\n self.map[sh] = [[key, value]]\\n return\\n for i in range(len(self.map[sh])):\\n kv = self.map[sh][i]\\n if kv[0] == key:\\n kv[1] = value\\n return\\n self.map[sh].append([key, value])\",\n \"def set(self, key: t.Hashable, value: t.Any) -> None:\",\n \"def set(self, key, value):\\r\\n if not isinstance(key, str):\\r\\n raise TypeError(\\\"Key must be a string\\\")\\r\\n\\r\\n bin_num = self._get_bin(key)\\r\\n cur = self.bins[bin_num]\\r\\n\\r\\n if cur.next is None: # If first element is trailer node, insert here\\r\\n self._ensure_load()\\r\\n self.bins[bin_num] = Node((key, value), cur)\\r\\n success = True\\r\\n elif cur.value[0] == key: # If existing key, overwrite\\r\\n cur.value = (cur.value[0], value)\\r\\n success = False\\r\\n else: # Move towards end of linked list\\r\\n while cur.next is not None:\\r\\n prev = cur\\r\\n cur = cur.next\\r\\n self._ensure_load()\\r\\n prev.next = Node((key, value), cur)\\r\\n success = True\\r\\n\\r\\n if success:\\r\\n self.size += 1\\r\\n return success\",\n \"def put(self, key, value):\\r\\n temp = [key, value]\\r\\n flag = False\\r\\n for i in range(len(self.lis)):\\r\\n if self.lis[i][0] == temp[0]:\\r\\n self.lis[i][1] = temp[1]\\r\\n flag = True\\r\\n break\\r\\n if flag == False:\\r\\n self.lis.append(temp)\",\n \"def __setitem__(self, key, value):\\n self.list[key] = value\",\n \"def __setitem__(self, key, value):\\n\\n bucket_key = self.key_for_bucket(key)\\n self.buckets[bucket_key][key] = value\",\n \"def __setitem__(self, key: Hashable, value: Any) -> None:\\n self.contents[key] = value\\n return\",\n \"def set(self, key, val):\\n if not isinstance(key, str):\\n raise TypeError('key must be type str')\\n index = self._hash(key)\\n bucket = self.table[index]\\n for item in bucket:\\n if key == item[0]:\\n bucket.remove(item)\\n break\\n bucket.append((key, val))\\n return None\",\n \"def set(self, key, val):\\n if not isinstance(key, str):\\n raise TypeError('key must be type str')\\n index = self._hash(key)\\n bucket = self.table[index]\\n for item in bucket:\\n if key == item[0]:\\n bucket.remove(item)\\n break\\n bucket.append((key, val))\\n return None\",\n \"def __setitem__(self, key, value):\\n self.tree[key] = value\",\n \"def set(self, key, value):\\n # Find bucket where given key belongs\\n # Check if key-value entry exists in bucket\\n # If found, update value associated with given key\\n # Otherwise, insert given key-value entry into bucket\\n # key bucket index\\n key_bucket = self._bucket_index(key) # O(1) time\\n bucket = self.buckets[key_bucket] # O(1) time\\n in_hash_table = False\\n\\n \\\"\\\"\\\"\\n # for key_value_tuple in bucket.items():\\n # old_key, old_value = key_value_tuple\\n items = bucket.items() # O(l) for l items in bucket (LL)\\n for old_key, old_value in items: # O(l) iterations in worst case, O(1) beast case\\n if old_key is key:\\n in_hash_table = True\\n bucket.delete((key, old_value)) # O(l)\\n bucket.append((key, value)) # O(1)\\n \\\"\\\"\\\"\\n\\n # O(l) in worst case because we iterate over all nodes if near tail or not found\\n key_value_pair = bucket.find(lambda key_value: key_value[0] == key)\\n if key_value_pair is not None:\\n bucket.delete(key_value_pair) # O(l) time in worst case\\n bucket.append((key, value)) # O(1) time if using tail\\n\\n # if not in_hash_table:\\n else:\\n bucket.append((key, value))\",\n \"def put(self, key, value):\\n while len(self.buckets) <= key:\\n self.buckets = self.buckets + [-1] * len(self.buckets)\\n self.length = self.length * 2\\n self.buckets[key] = value\",\n \"def put(self, key, value):\\n return self.sp.put(key, value)\",\n \"def add(self, key: str, value: str) -> Optional[None]:\\n threshhold = self.capacity * 0.75\\n if self.length >= threshhold:\\n self._increase_size()\\n\\n hashkey = self._gethash(key)\\n if not self.HashMap[hashkey]:\\n # The key does not exist so add it\\n value_to_store = [key, value]\\n self.HashMap[hashkey] = value_to_store\\n self.length += 1\\n elif self.HashMap[hashkey] and key not in self.HashMap[hashkey]:\\n # There is a hashclash append to the location\\n self.HashMap[hashkey].extend([key, value])\\n self.length += 1\\n else:\\n # The key exists and matches so the value gets overlayed\\n self.HashMap[hashkey] = [key, value]\",\n \"def __setitem__(self, key, value):\\n self.set(key, value)\",\n \"def __setitem__(self, key, value):\\n self.set(key, value)\",\n \"def __setitem__(self, key, value):\\n self.set(key, value)\",\n \"def _put(self, key: str, value):\\n pass\",\n \"def set(self, key, value):\\n self.log.debug(\\\"setting '%s' = '%s' on network\\\" % (key, value))\\n dkey = digest(key)\\n node = Node(dkey)\\n\\n def store(nodes):\\n self.log.info(\\\"setting '%s' on %s\\\" % (key, list(map(str, nodes))))\\n # if this node is close too, then store here as well\\n if self.node.distanceTo(node) < max([n.distanceTo(node) for n in nodes]):\\n self.storage[dkey] = value\\n ds = [self.protocol.callStore(n, dkey, value) for n in nodes]\\n d = defer.DeferredList(ds)\\n d.addCallback(self._anyRespondSuccess)\\n d.addErrback(self.onError)\\n return d\\n\\n nearest = self.protocol.router.findNeighbors(node)\\n if len(nearest) == 0:\\n self.log.warning(\\\"There are no known neighbors to set key %s\\\" % key)\\n return defer.succeed(False)\\n spider = NodeSpiderCrawl(self.protocol, node, nearest, self.ksize, self.alpha)\\n d = spider.find()\\n d.addCallback(store)\\n d.addErrback(self.onError)\\n return d\",\n \"def __setitem__(self, key, value):\\n index=self._index(key)\\n if index==-1:\\n self._item.append(Item(key,value))\\n self._size+=1\\n else:\\n self._item[index].value=value\",\n \"def set(self, key, value):\\n # TODO: Insert or update the given key-value entry into a bucket\\n hash_key = self._bucket_index(key) # Gets the key in the array\\n key_value = (key, value) # Store tuple containing key and value in key_value\\n bucket = self.buckets[hash_key]\\n\\n if bucket.find(lambda (tuple_key, _): tuple_key == key):\\n self.delete(key) # Removing the key from the list\\n return True\\n\\n bucket.append(key_value) # Append the new tuple\\n self.size += 1 # Change the size because the delete reduces it by 2\\n return True\\n\\n # Important example of repetition\\n ''' if bucket.is_empty() is True: # Bucket returns None, the result of the hash_key, if empty\\n self.size += 1 # Increments the size everytime set() is called\\n bucket.append(key_value) # Creates a new list based on the hash_key\\n return True\\n # If bucket contains key\\n elif bucket.find(lambda (tuple_key, _): tuple_key == key):\\n # elif bucket.find(lambda (k, v): k == key):\\n # elif bucket.find(lambda data: data[0] == key):\\n self.delete(key) # Removing the key from the list\\n bucket.append(key_value) # Append the new tuple\\n self.size += 1 # Change the size because the delete reduces it by 2\\n return True\\n else: # Bucket contains key-value entry\\n bucket.append(key_value) # If the key doesn't exist, add the tuple\\n self.size += 1 # Increments the size everytime set() is called\\n return True\\n '''\",\n \"def _insert(self, key, value):\\n entry = self._lookup(key)\\n if entry.value is None:\\n self.used += 1\\n if entry.key is not dummy:\\n self.filled += 1\\n entry.key = key\\n entry.hash = self.first_hash(key)\\n entry.value = value\",\n \"def __setitem__(self, key, val):\\n self.__check_key_validity(key)\\n self.data[key[0]][key[1]] = val\",\n \"def put(self, key, value):\\n try: \\n value = self.pop(key)\\n \\n except KeyError: \\n if len(self) >= self.max_size: \\n self.popitem(last=False)\\n \\n self[key] = value\",\n \"def put(self, key, value):\\n if key is None or value is None:\\n raise TypeError\\n\\n index = self.__get_cache_set_index(key)\\n cache_set = self.cache_sets[index]\\n h_key = self.__ensure_hashable_key(key)\\n cache_set.put(h_key, value)\",\n \"def __setitem__(self, key, value):\\n try:\\n index = self.__keys.index(key)\\n self.__vals[index] = value\\n except ValueError:\\n try:\\n index = self.__vals.index(key)\\n self.__keys[index] = value\\n except ValueError:\\n self.__keys.append(key)\\n self.__vals.append(value)\",\n \"def set(self, key, value):\\n validate_is_bytes(key)\\n validate_is_bytes(value)\\n\\n self.root_hash = self._set(self.root_hash, encode_to_bin(key), value)\",\n \"def __setitem__(self, key, value):\\n\\n key = to_unicode(key)\\n\\n if key in self:\\n key = self.get_data_reference(key, default=key)\\n else:\\n if self.is_view:\\n self._view.append(key)\\n\\n self._storage[key] = to_unicode(value)\",\n \"def put(self, key, obj):\\n \\n\\n def find(found_item, hash_table_cell):\\n \\\"\\\"\\\"This function is a closer function which will pass to the find_by_key function to get the value. the purpose of this \\n function is to check if key is already present than replace the value else append the value in same bucket.\\\"\\\"\\\"\\n if found_item:\\n found_item[1] = obj\\n else:\\n hash_table_cell.append([key, obj])\\n self.size += 1\\n self._keys.append(key)\\n\\n self._find_by_key(key, find)\\n return self\",\n \"def __setitem__(self, key, value):\\n try:\\n kvp = self.keyvaluepair_set.get(key=key)\\n except KeyValuePair.DoesNotExist:\\n KeyValuePair.objects.create(container=self, key=key, value=value)\\n else:\\n kvp.value = value\\n kvp.save()\",\n \"def __setitem__(self, key, value):\\n self.setdefault(key, []).append(value)\",\n \"def __setitem__(self, key, value):\\n self.setdefault(key, []).append(value)\",\n \"def __setitem__(self, key, value):\\r\\n self.setdefault(key, []).append(value)\",\n \"def put(hash, key: int, value: V) -> HashMap:\\r\\n if hash == None:\\r\\n hash = HashMap()\\r\\n hash_key = key % hash.size\\r\\n if hash.data[hash_key].key == None:\\r\\n hash.data[hash_key].value = value\\r\\n hash.data[hash_key].key = key\\r\\n hash.keyset.append(key)\\r\\n else:\\r\\n temp = Node(key, value)\\r\\n hash.keyset.append(key)\\r\\n p = hash.data[hash_key]\\r\\n while p.next != None:\\r\\n p = p.next\\r\\n p.next = temp\\r\\n\\r\\n return hash\",\n \"def set(self, key, value):\\n _log.debug(\\\"setting '%s' = '%s' on network\\\" % (key, value))\\n dkey = digest(key)\\n node = Node(dkey)\\n\\n def store(nodes):\\n _log.debug(\\\"setting '%s' to %s on %s\\\" % (key, value, map(str, nodes)))\\n # if this node is close too, then store here as well\\n if (not nodes or self.node.distanceTo(node) < max([n.distanceTo(node) for n in nodes]) or\\n dkey in self.storage):\\n _log.debug(\\\"setting '%s' to %s locally\\\" % (key, value))\\n self.storage[dkey] = value\\n ds = [self.protocol.callStore(n, dkey, value) for n in nodes]\\n return defer.DeferredList(ds).addCallback(self._anyRespondSuccess)\\n\\n nearest = self.protocol.router.findNeighbors(node)\\n if len(nearest) == 0:\\n _log.warning(\\\"There are no known neighbors to set key %s\\\" % key)\\n return defer.succeed(False)\\n spider = NodeSpiderCrawl(self.protocol, node, nearest, self.ksize, self.alpha)\\n return spider.find().addCallback(store)\",\n \"def __setitem__(self, key, value):\\n self._data[key] = value\",\n \"def __setitem__(self, key, value):\\n list.__setitem__(self, key, self.convertNode(value))\",\n \"def set(self, key, value):\\n #try to lock the tree. If we succeed make sure\\n #we dont lose updates from any other process\\n if self._storage.lock():\\n self._refresh_tree_ref()\\n #get current top-level node and make a value-ref\\n node = self._follow(self._tree_ref)\\n value_ref = ValueRef(value)\\n #insert and get new tree ref\\n self._tree_ref = self._insert(node, key, value_ref)\\n self._tree_ref = self._blacken(self._follow(self._tree_ref))\",\n \"def __setitem__(self, key, value):\\n if not key in self.ordered_list:\\n self.ordered_list.append(key)\\n self.__dict__[key] = value\",\n \"def put_key_value(self, key, value):\\n if self.is_key_in_cache(key):\\n entry_node, entry_frequency_node = self.__remove_key(key)\\n entry_node.value = value\\n if entry_frequency_node.next.key != entry_frequency_node.key + 1:\\n self.__create_frequency_node_after(entry_frequency_node)\\n self.key_to_frequency_node[entry_node.key] = entry_frequency_node.next\\n self.__add_entry_to_frequency_node(entry_node, entry_frequency_node.next)\\n if entry_frequency_node.frequency_cache.size == 0: # if frequency group now empty, remove it\\n self.__remove_frequency_node(entry_frequency_node)\\n elif self.is_at_capacity():\\n self.__evict_least_frequent_entry()\\n self.__add_new_entry(key, value)\\n else:\\n self.__add_new_entry(key, value)\",\n \"def __setitem__(self, key, value):\\n self.data[key] = value\",\n \"def __setitem__(self, key, value):\\n self.data[key] = value\",\n \"def __setitem__(self, key, value):\\r\\n key = self.key(key)\\r\\n if key in self.data_with_same_key:\\r\\n self.data_with_same_key[key] += [self.data[key]]\\r\\n elif key in self.data:\\r\\n self.data_with_same_key[key] = [self.data[key]]\\r\\n self.data[key] = value\",\n \"def set(self, key, value):\\n raise NotImplementedError\",\n \"def put(self, key, value):\\n self.container[key] = value\",\n \"def put(self, key, value):\\n i = key //1000\\n j = key%1000\\n self.container[i][j] = value\",\n \"def add(self, key, value):\\n\\t\\tself.__add_key_to_bt(key)[3] = self.__add_key_value_to_ll(key, value)\",\n \"def __setitem__(self, key, value):\\r\\n self.data[key] = value\",\n \"def __setitem__(self, key, value):\\n bucket = self._buckets[self._index(key)]\\n for node in bucket.linked_list:\\n # key, value pair stored in bucket linked list\\n bucket_object_key, bucket_object_value = node.value\\n assert isinstance(bucket_object_key, BucketObject)\\n assert isinstance(bucket_object_value, BucketObject)\\n if bucket_object_key.load_value() == key:\\n key_list_node, value_list_node = (\\n self._object_to_list_node[bucket_object_key],\\n self._object_to_list_node[bucket_object_value],\\n )\\n # update key_list_node and remove value_list_node\\n self._in_memory_objects.remove_and_append(key_list_node)\\n self._disk_objects.remove_and_append(key_list_node)\\n self._in_memory_objects.remove(value_list_node)\\n self._disk_objects.remove(value_list_node)\\n self._object_to_list_node.pop(bucket_object_value)\\n # append value list node to in-memory linked list\\n bucket_object_value.value = value\\n self._object_to_list_node[\\n bucket_object_value\\n ] = DoublyLinkedList.create_new_node(bucket_object_value)\\n self._in_memory_objects.append(\\n self._object_to_list_node[bucket_object_value]\\n )\\n # balance memory usage\\n self._balance()\\n return\\n # append key-value pair to current bucket\\n bucket_object_key, bucket_object_value = (\\n BucketObject(key, bucket),\\n BucketObject(value, bucket),\\n )\\n bucket.linked_list.append(\\n DoublyLinkedList.create_new_node((bucket_object_key, bucket_object_value))\\n )\\n # append key_object and value_object to in_memory_objects\\n key_list_node = DoublyLinkedList.create_new_node(bucket_object_key)\\n self._in_memory_objects.append(key_list_node)\\n value_list_node = DoublyLinkedList.create_new_node(bucket_object_value)\\n self._in_memory_objects.append(value_list_node)\\n # update object -> list node dict\\n self._object_to_list_node[bucket_object_key] = key_list_node\\n self._object_to_list_node[bucket_object_value] = value_list_node\\n # balance memory usage\\n self._balance()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.81106144","0.80772465","0.8076398","0.80682015","0.8036524","0.8018422","0.79838794","0.7905589","0.7890816","0.7876302","0.78534526","0.781982","0.77786344","0.77710927","0.77464396","0.76788867","0.7675746","0.7673336","0.7644221","0.76339984","0.76021016","0.7564971","0.7562352","0.7544747","0.7497845","0.74859893","0.7462402","0.74502635","0.742286","0.7416171","0.7414919","0.7409382","0.7376308","0.7369824","0.73601806","0.7347749","0.73289496","0.7322543","0.7302096","0.72979915","0.72979915","0.72859913","0.7278492","0.72761726","0.72728914","0.7270675","0.7257386","0.723852","0.7229267","0.72128576","0.71937716","0.7151556","0.71051896","0.7099411","0.7092445","0.70793885","0.7075035","0.7067167","0.7050606","0.7050606","0.70416266","0.7027565","0.7025865","0.70250297","0.7020069","0.70192873","0.70192873","0.70192873","0.70115685","0.70108783","0.7008959","0.6996914","0.69938314","0.69823956","0.69799554","0.69656384","0.69576645","0.6944985","0.69415903","0.69363636","0.69361573","0.6928826","0.6928826","0.69210124","0.6908017","0.6907513","0.6906981","0.6901022","0.6900201","0.68940425","0.6891474","0.6885402","0.6885402","0.68813777","0.6880713","0.68760586","0.6870896","0.68667513","0.6857807","0.6855821"],"string":"[\n \"0.81106144\",\n \"0.80772465\",\n \"0.8076398\",\n \"0.80682015\",\n \"0.8036524\",\n \"0.8018422\",\n \"0.79838794\",\n \"0.7905589\",\n \"0.7890816\",\n \"0.7876302\",\n \"0.78534526\",\n \"0.781982\",\n \"0.77786344\",\n \"0.77710927\",\n \"0.77464396\",\n \"0.76788867\",\n \"0.7675746\",\n \"0.7673336\",\n \"0.7644221\",\n \"0.76339984\",\n \"0.76021016\",\n \"0.7564971\",\n \"0.7562352\",\n \"0.7544747\",\n \"0.7497845\",\n \"0.74859893\",\n \"0.7462402\",\n \"0.74502635\",\n \"0.742286\",\n \"0.7416171\",\n \"0.7414919\",\n \"0.7409382\",\n \"0.7376308\",\n \"0.7369824\",\n \"0.73601806\",\n \"0.7347749\",\n \"0.73289496\",\n \"0.7322543\",\n \"0.7302096\",\n \"0.72979915\",\n \"0.72979915\",\n \"0.72859913\",\n \"0.7278492\",\n \"0.72761726\",\n \"0.72728914\",\n \"0.7270675\",\n \"0.7257386\",\n \"0.723852\",\n \"0.7229267\",\n \"0.72128576\",\n \"0.71937716\",\n \"0.7151556\",\n \"0.71051896\",\n \"0.7099411\",\n \"0.7092445\",\n \"0.70793885\",\n \"0.7075035\",\n \"0.7067167\",\n \"0.7050606\",\n \"0.7050606\",\n \"0.70416266\",\n \"0.7027565\",\n \"0.7025865\",\n \"0.70250297\",\n \"0.7020069\",\n \"0.70192873\",\n \"0.70192873\",\n \"0.70192873\",\n \"0.70115685\",\n \"0.70108783\",\n \"0.7008959\",\n \"0.6996914\",\n \"0.69938314\",\n \"0.69823956\",\n \"0.69799554\",\n \"0.69656384\",\n \"0.69576645\",\n \"0.6944985\",\n \"0.69415903\",\n \"0.69363636\",\n \"0.69361573\",\n \"0.6928826\",\n \"0.6928826\",\n \"0.69210124\",\n \"0.6908017\",\n \"0.6907513\",\n \"0.6906981\",\n \"0.6901022\",\n \"0.6900201\",\n \"0.68940425\",\n \"0.6891474\",\n \"0.6885402\",\n \"0.6885402\",\n \"0.68813777\",\n \"0.6880713\",\n \"0.68760586\",\n \"0.6870896\",\n \"0.68667513\",\n \"0.6857807\",\n \"0.6855821\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8438726"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21968,"cells":{"query":{"kind":"string","value":"Remove the value stored with the given key. Print a warning if the key is not found. Implement this."},"document":{"kind":"string","value":"def delete(self, key):\n\n hi = self.hash_index(key)\n\n # if that hi is empty ignore\n # if self.storage[hi] is None:\n # print(\"WARNING: no key\")\n # return\n\n current = self.storage[hi]\n prev = self.storage[hi]\n while current and current.key != key:\n prev = current\n current = current.next\n\n if (current and current.key == key):\n # if its the first link in the list\n if (current == self.storage[hi]):\n self.storage[hi] = current.next\n else:\n prev.next = current.next\n\n self.numberOfItems -= 1\n else:\n print(\"WARNING: no key\")\n\n self.calculateLoad()"},"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 remove_value(self, key: str) -> None:\n raise NotImplementedError","def remove(self, key):\n\n index = self._get_hash(key)\n\n if self.table[index] is not None:\n for i, pair in enumerate(self.table[index]):\n if key == pair[0]:\n del self.table[index][i]\n self.size -= 1\n return\n\n raise ValueError(f\"can't find value with given key {key}\")","def remove(self, key: int | str):\n self.__delitem__(key)","def remove(self, key: int) -> None:\n if key in self.keys:\n idx = self.keys.index(key)\n self.keys.pop(idx)\n self.values.pop(idx)","def remove(self, key):\n del self[key]","def remove(self, key):\n elem = self.find(key)\n if not elem:\n return\n self.remove_elem(elem)","def remove(self, key):\n pass","def remove(self, key: str) -> None:\n thekey = self._gethash(key)\n if self.HashMap[thekey] is not None:\n if len(self.HashMap[thekey]) == 2:\n self.HashMap[\n self._gethash(key)\n ] = None # Keep the location but set the value to None\n else:\n hashkey = self._gethash(key)\n idx = self._find_if_hashclash(key, hashkey, \"i\")\n self.HashMap[hashkey].pop(idx)\n self.HashMap[hashkey].pop(idx)\n self.length -= 1","def remove(self, key):","def __delitem__(self, key):\n try:\n kvp = self.keyvaluepair_set.get(key=key)\n except KeyValuePair.DoesNotExist:\n raise KeyError\n else:\n kvp.delete()","def remove(self, key: int) -> None:\n if key in self.map:\n del self.map[key]","def remove(self, key: int) -> None:\n pos = self.hash(key)\n\n if key in self.table[pos]:\n del self.table[pos][key]","def remove(self, key): # pragma: no cover\n\n del self.stash[key]","def remove_key(self, key):\n del self.data[key]\n self.save_data()","def remove(self, key):\n h = key%self.m\n a = self.a\n if a[h]:\n a[h] = None","def delete(self, key):\n try: \n self.pop(key)\n \n except KeyError: \n raise KeyError","def remove(self, key):\n try:\n del self._store[key]\n except KeyError:\n pass","def remove_key(self, key) -> None:\n with suppress(KeyError):\n self.size -= len(self.data[key])\n del self.data[key]","def remove(self, key: int) -> None:\n sh = key % 37\n if self.map[sh] == None:\n return\n for i in range(len(self.map[sh])):\n kv = self.map[sh][i]\n if kv[0] == key:\n self.map[sh].remove(kv)\n return","def remove(self, key):\n self.container[key] = -1","def remove(self, key: int) -> None:\n if key in self.hashmap.keys():del self.hashmap[key]","def remove(self, key):\n self.arr[key] = -1","def remove(self, key):\n tk = self._timed_key(key)\n try:\n del self._store[tk]\n except KeyError:\n pass","def remove(self, key):\r\n\r\n\t\t# if the key doesn't exist, exit the function\r\n\t\tif not self.contains_key(key):\r\n\t\t\treturn\r\n\t\telse:\r\n\t\t\tindex = self.get_index(key) # get the index of the key\r\n\t\t\tlinked_list = self._buckets[index] # now get the entire linked list\r\n\t\t\tlinked_list.remove(key) # call the remove function from the linked list\r\n\t\t\tself.size -= 1 # subtract 1\r","def remove(self, key):\n if key in self._store:\n del self._store[key]","def delete(self, key):\n self.map.pop(key, None)","def remove(self, key):\n if self.contains_key(key): # if key exists in hashmap, remove key/value pair\n hash_key = self._hash_function(key) % self.capacity\n bucket = self._buckets[hash_key]\n bucket.remove(key)","def remove(self, key):\n ndx = self._findPosition(key)\n assert ndx, 'Invalid map key'\n self._entryList.pop(key)","def delete(self, key):\r\n index = self.search(key)\r\n if self.contains_key_at(key, index):\r\n del self.keys[index]","def __delitem__(self, key):\n self.f_remove(key)","def remove(self, key: int) -> None:\n t = key % 20011\n delete = []\n for item in self.hash[t]:\n if item[0] == key:\n delete = item\n if delete:\n self.hash[t].remove(delete)","def remove(self, key: int) -> None:\n chain, idx = self._search(key)\n if idx is not None:\n chain.pop(idx)","def remove(self, key: int) -> None:\n if key < self.len:\n self._map[key] = -1","def remove(self, key):\n hashv = self.hash(key)\n bucket=self.hashmap[hashv]\n for i,(k,v) in enumerate(bucket):\n if k==key:\n del bucket[i]","def remove_key(self, key: keyType) -> None:\n self.validate_key(key)\n hash_address = self.get_hash_address(key)\n head_node = self.hashTable[hash_address]\n if key not in head_node.keys:\n raise Exception\n\n for index in range(len(head_node.singlyLinkedList)):\n if head_node.singlyLinkedList[index].key == key:\n head_node.count -= len(head_node.singlyLinkedList[index].values)\n head_node.keys.remove(key)\n head_node.singlyLinkedList.pop(index)\n break\n logger.info(\"Successfully remove the element.\")","def remove(self, key):\n ha = self.myhash(key)\n if key in self.hashmap[ha][0]:\n i = self.hashmap[ha][0].index(key)\n self.hashmap[ha][0].pop(i)\n self.hashmap[ha][1].pop(i)","def remove_value(self, thing_key, dkey):\n if thing_key in self.things_dict:\n dic = self.things_dict[thing_key]\n if type(dic) != type({}):\n return\n dic.pop(dkey, None)","def remove(self, key, value):\n if key not in self: return\n elif self[key] == value: del(self[key])\n else:\n try:\n parts = self.list(key)\n parts.remove(value)\n self[key] = \"\\n\".join(parts)\n except ValueError:\n if key in self: del(self[key])","def remove(self, key):\n return self._db.hdel(self.index, key)","def remove(self, value) -> None:\n key = getattr(value, self.keyattr)\n if callable(key):\n key = key()\n with suppress(ValueError):\n self.data[key].remove(value)\n self.size -= 1","def _delKey(self, key):\n pass","def delete(self, key):\n return None","def remove(self, key):\n index = self._hash_mod(key)\n node = self.storage[index]\n node_before = None\n if node:\n while node:\n if node.key == key:\n if node_before:\n node_before.next = node.next\n elif node.next:\n self.storage[index] = node.next\n else:\n self.storage[index] = None\n self.key_count -= 1\n return\n node_before = node\n node = node.next\n print(f\"An element with key '{key}' cannot be found!\")","def __delitem__(self, key):\n del self._data[key]","def __delitem__(self, key):\n\n # If key is in hash map\n if self.__contains__(key):\n\n # Get hashed key\n i = self.hash(key)\n\n # Get chain index of key value pair\n chain_idx = self.keys_ref[i].index(key)\n\n # Delete value associated with key in hash map\n del self.table[i][chain_idx]\n\n # Delete key from hash table\n del self.keys_ref[i][chain_idx]\n\n # Remove key from set of keys\n self.keys_set.remove(key)\n\n # Decrement size\n self.size -= 1\n\n # If key not in hash map\n else:\n\n # Raise error\n raise KeyError(key)","def remove(self, key):\n hash_key = key % self.key_space\n self.hash_table[hash_key].remove(key)","def _map___delitem__(self, key):\n if not isinstance(key, self.keytype):\n raise KeyError('type of `key` should be ' + repr(self.keytype) + ' but got ' + repr(type(key)))\n if key not in self:\n raise KeyError('key not found')\n self.erase(self.find(key))\n return","def __delitem__(self, key: tuple):\n s, a = key\n del self.store[s][a]","def remove(self, key):\n if key < self.length:\n self.buckets[key] = -1","def _delKey(self, key):\n try:\n self._getKeyList().remove(key)\n except KeyError:\n # This shouldn't happen, but what do we do if it does?\n pass\n self._testKeySubNsDel()","def remove(self, key):\n\t\tfrom collections import OrderedDict\n\t\tdic = self.__dict__\n\t\tif not dic.get(key):\n\t\t\traise ValueError(\"Inputted Key is not valid for removal.\")\n\t\tdel dic[key]\n\t\tnew_dict = {}\n\t\targs = dic.values()\n\t\tfor x, y in enumerate(args):\n\t\t\tnew_dict.update({x: y})\n\t\tnew_dict = OrderedDict(sorted(new_dict.items()))\n\t\tself.__dict__ = new_dict","def delete(self, key) -> None:\n with self.__lock:\n if key not in self.__data:\n return # Ignore if key is non-existent\n del self.__data[key]\n self.flush()","def __delitem__(self, key):\n with self.__lock:\n log.debug(\"__delitem__: {}\".format(key))\n del self._d[key]","def remove(self, key):\r\n for i in range(len(self.lis)):\r\n if self.lis[i][0] == key:\r\n self.lis.pop(i)\r\n break","def eliminate_key (self,key):\r\n\r\n if self.using_shelf:\r\n\r\n del self.key_dict[str(key)]","def __delitem__(self, key):\n del self._get_storage()[key]","def remove(self, key: int) -> None:\n idx = key % self.size\n if self.mp[idx]:\n for i in range(len(self.mp[idx])):\n if self.mp[idx][i][0] == key:\n #self.mp[idx].pop(i)\n del self.mp[idx][i]\n break","def remove(self, key):\n i = key //1000\n j = key%1000\n self.container[i][j] = -1","def remove(self, key):\n \n # If there used to be a key, there must exist an old value blob somewhere in the database. It should be deallocated after a successful commit to disk.\n if key in self.keys:\n if self.keys[key] is not None:\n punchat,punchlen = self.keys[key]\n self.awaitingpunch.append((punchat, punchlen))\n\n self.keys.pop(key, None)\n self.buffered.pop(key, None)\n self.cache.pop(key, None)\n\n if self.autocommit:\n commit()","def remove(self, key_name: str):\n pass","def __delitem__(self, key: str) -> None:\n del self.variables[key]","def __delitem__(self, key):\n del self.list[key]","def delete(self, key):\n pass","def delete(self, key):\n pass","def remove_key(self, key: str):\r\n\r\n if key in self._inner_dict:\r\n del self._inner_dict[key]\r\n else:\r\n raise KeyError(f\"key '{key}' is invalid\")","def remove(self, key):\n index = int((keyIndex(key) & (self.BUCKET_SIZE - 1)))\n inner = self.keys[index]\n if inner == None:\n return None\n i = 0\n while len(inner):\n if inner[i] == self.EMPTY_KEY:\n break\n if inner[i] == key:\n value = self.values[index][i]\n while len(inner):\n if inner[i] == self.EMPTY_KEY:\n break\n inner[i - 1] = inner[i]\n self.values[index][i - 1] = self.values[index][i]\n i += 1\n inner[i - 1] = self.EMPTY_KEY\n self.values[index][i - 1] = None\n self.size -= 1\n self.modCount += 1\n return value\n i += 1\n return None","def __delitem__(self, key):\n self.delete(key)","def __delitem__(self, key):\n self.delete(key)","def __delitem__(self, key: Hashable) -> None:\n del self.contents[key]\n return","def delete(self, key):\n raise NotImplementedError","def delete(self, key):\n raise NotImplementedError","def remove(self, value):\r\n if value not in self:\r\n raise KeyError(value)\r\n self.discard(value)","def delete(self, key):\n node = self.search(key)\n if node:\n self.remove_node(node)","def __delitem__(self, key):\n try:\n del self._maps[0][key]\n except KeyError:\n raise KeyError(\n 'Key not found in the last mapping: {!r}'.format(key))","def delete(self, key: int) -> None:\n node = self.search(key)\n if node:\n self._delete(node)","def __delitem__(self, key):\n\n if '.' in key:\n path = key.split('.', 1)\n self.parser.remove_option(path[0], path[1])\n else:\n raise KeyError","def delete(self, key):\n raise NotImplementedError()","def delete(self, key: T) -> None:\n\n idx: int = self.hash_fn(key) # get an index location for 'key'\n if self.table[idx] is None: # 'key' doesn't exists in hash table\n raise Exception(\"Key doesn't exist in hashtable\")\n else:\n self.table[self.find(key)] = None # delete value at 'key'\n self.filled_count -= 1","def delete(self, key):","def __delitem__(self, k):\n if not self.is_empty():\n p = self._subtree_search(self.root(), k)\n if k == p.key():\n self.delete(p)\n return\n self._rebalance_access(p)\n raise KeyError('Key Error:' + repr(k))","def delSit(self, key):\n if hasattr(key, \"encode\"):\n key = key.encode(\"utf-8\") # convert str to bytes\n return self.delVal(self.sits, key)","def delete(self, key: str):\n raise NotImplementedError","def _delete(self, key):\n path = self._get_key_path(key)\n remove(path)","def __delitem__(self, key):\n del self.elements[key]","def delete(self, key):\n # TODO: Find the given key and delete its entry if found\n self.size -= 1\n hash_key = self._bucket_index(key) # Gets the index of the key\n if self.contains(key) is True:\n for key_value_pair in self.buckets[hash_key]: # Iteratre through the value pair\n if key_value_pair[0] is key: # If the key matches\n self.buckets[hash_key].delete(key_value_pair)\n # self.buckets[hash_key] = None\n return True\n else:\n raise KeyError(\"Key no longer exists\") # If key doesn't exist, return None","def delete(self, key):\n visitor = VisitorDelete()\n\n self.visit(key, visitor)\n\n if (visitor.result):\n self.size -= 1\n\n return visitor.result","def __delitem__(self, key):\n if not self._set:\n raise TypeError('This dict is read-only')\n return self._set(key, None)","def remove(self, key: int) -> None:\n index = key % 10000\n previous = self.array[index]\n current = previous.next\n while current:\n if current.key == key:\n previous.next = current.next\n break\n previous = previous.next\n current = current.next","def delKey(self, key ):\n if key in self.conf:\n del self.conf[key]","def __delitem__(self, key: T) -> None:\n self.delete(key)","def __delitem__(self, key):\n i, kv_pair = self._lookup(key, self._backing)\n if kv_pair and not kv_pair.value is Hashmap.absent:\n self._backing[i] = KeyValue(key, Hashmap.absent)\n self._deleted += 1\n\n size = len(self._backing)\n utilization = (self._used - self._deleted)/size \n if utilization < 0.16:\n self._resize(self._decr_size(size))\n else:\n raise KeyError('no such item!')","def delete(self, key):\n hash_key = hash(key) % self.length\n bucket = self.array[hash_key]\n if not bucket:\n raise ValueError('Key does not exist')\n for key_val_pair in bucket:\n if key_val_pair[0] == key:\n bucket.remove(key_val_pair)","def remove(self, data, key, value):\n if key in data:\n if not value: # value is empty or false, just remove it\n data.pop(key, None) # delete\n elif isinstance(value, type(data[key])): # if same type\n if isinstance(value, list): # if it's a list, like modules\n data[key] = list(set(data[key]) - set(value))\n elif isinstance(\n value, dict\n ): # if it's a dict, difference of the keys and rebuild dict\n for k, v in value.items():\n data[key][k] = self.remove(data[key], k, v)\n else:\n raise TypeError(\n f\"Value of {key} is {type(value)} and\"\n f\" the imported {key} is {type(data[key])}. Type mismatch.\"\n )\n return data[key]","def remove(kv_data, key):\n if isinstance(kv_data, str):\n kv_data = loads(kv_data) # Turn into Dictionary\n try:\n del kv_data[key]\n except NameError:\n print(key, \" does not exists in key value pair.\")\n kv_data = dumps(kv_data)\n else:\n print(\"Provide a Json Key Value String\")\n sys.exit(6)\n return kv_data","def __delitem__(self, key):\n\t\tdel self.__dStore[key]","def __delitem__(self, key):\n\n dict.__delitem__(self, key)\n self.changed()","def remove(self, key: int) -> None:\n \n \n hashvalue=key% 1000\n if self.hashset[hashvalue]==None:\n return\n head = self.hashset[hashvalue]\n dummy_head = Node(0)\n curr = dummy_head\n while head:\n k,v = head.data\n if k==key:\n head=head.next\n curr.next=head\n curr= curr.next\n if head != None:\n \n head = head.next\n \n self.hashset[hashvalue]=dummy_head.next","def delete(self, key):\n self.tree.delete(key)","def remove(self, key: int) -> None:\n \n index = self.hash(key)\n\n # If list doesn't exist just return\n if not self.map[index]: return\n\n # If it's the head of list, manipulate pointers\n if self.map[index].val[0] == key:\n self.map[index] = self.map[index].next\n return\n\n curr = self.map[index]\n\n # Search through list\n while curr.next:\n # If the value in list matches key, manipulate list\n if curr.next.val[0] == key: \n curr.next = curr.next.next\n return\n\n curr = curr.next\n\n # Otherwise if it's not in list do nothing","def delete(self, key: object):\n try:\n del self._user_data[key]\n except KeyError:\n pass","def remove(self, key: int) -> None:\n pos = key % self.space\n head = self.hash_table[pos]\n curr = head\n\n while curr.next:\n if curr.next.key == key:\n curr.next = curr.next.next\n return\n curr = curr.next"],"string":"[\n \"def remove_value(self, key: str) -> None:\\n raise NotImplementedError\",\n \"def remove(self, key):\\n\\n index = self._get_hash(key)\\n\\n if self.table[index] is not None:\\n for i, pair in enumerate(self.table[index]):\\n if key == pair[0]:\\n del self.table[index][i]\\n self.size -= 1\\n return\\n\\n raise ValueError(f\\\"can't find value with given key {key}\\\")\",\n \"def remove(self, key: int | str):\\n self.__delitem__(key)\",\n \"def remove(self, key: int) -> None:\\n if key in self.keys:\\n idx = self.keys.index(key)\\n self.keys.pop(idx)\\n self.values.pop(idx)\",\n \"def remove(self, key):\\n del self[key]\",\n \"def remove(self, key):\\n elem = self.find(key)\\n if not elem:\\n return\\n self.remove_elem(elem)\",\n \"def remove(self, key):\\n pass\",\n \"def remove(self, key: str) -> None:\\n thekey = self._gethash(key)\\n if self.HashMap[thekey] is not None:\\n if len(self.HashMap[thekey]) == 2:\\n self.HashMap[\\n self._gethash(key)\\n ] = None # Keep the location but set the value to None\\n else:\\n hashkey = self._gethash(key)\\n idx = self._find_if_hashclash(key, hashkey, \\\"i\\\")\\n self.HashMap[hashkey].pop(idx)\\n self.HashMap[hashkey].pop(idx)\\n self.length -= 1\",\n \"def remove(self, key):\",\n \"def __delitem__(self, key):\\n try:\\n kvp = self.keyvaluepair_set.get(key=key)\\n except KeyValuePair.DoesNotExist:\\n raise KeyError\\n else:\\n kvp.delete()\",\n \"def remove(self, key: int) -> None:\\n if key in self.map:\\n del self.map[key]\",\n \"def remove(self, key: int) -> None:\\n pos = self.hash(key)\\n\\n if key in self.table[pos]:\\n del self.table[pos][key]\",\n \"def remove(self, key): # pragma: no cover\\n\\n del self.stash[key]\",\n \"def remove_key(self, key):\\n del self.data[key]\\n self.save_data()\",\n \"def remove(self, key):\\n h = key%self.m\\n a = self.a\\n if a[h]:\\n a[h] = None\",\n \"def delete(self, key):\\n try: \\n self.pop(key)\\n \\n except KeyError: \\n raise KeyError\",\n \"def remove(self, key):\\n try:\\n del self._store[key]\\n except KeyError:\\n pass\",\n \"def remove_key(self, key) -> None:\\n with suppress(KeyError):\\n self.size -= len(self.data[key])\\n del self.data[key]\",\n \"def remove(self, key: int) -> None:\\n sh = key % 37\\n if self.map[sh] == None:\\n return\\n for i in range(len(self.map[sh])):\\n kv = self.map[sh][i]\\n if kv[0] == key:\\n self.map[sh].remove(kv)\\n return\",\n \"def remove(self, key):\\n self.container[key] = -1\",\n \"def remove(self, key: int) -> None:\\n if key in self.hashmap.keys():del self.hashmap[key]\",\n \"def remove(self, key):\\n self.arr[key] = -1\",\n \"def remove(self, key):\\n tk = self._timed_key(key)\\n try:\\n del self._store[tk]\\n except KeyError:\\n pass\",\n \"def remove(self, key):\\r\\n\\r\\n\\t\\t# if the key doesn't exist, exit the function\\r\\n\\t\\tif not self.contains_key(key):\\r\\n\\t\\t\\treturn\\r\\n\\t\\telse:\\r\\n\\t\\t\\tindex = self.get_index(key) # get the index of the key\\r\\n\\t\\t\\tlinked_list = self._buckets[index] # now get the entire linked list\\r\\n\\t\\t\\tlinked_list.remove(key) # call the remove function from the linked list\\r\\n\\t\\t\\tself.size -= 1 # subtract 1\\r\",\n \"def remove(self, key):\\n if key in self._store:\\n del self._store[key]\",\n \"def delete(self, key):\\n self.map.pop(key, None)\",\n \"def remove(self, key):\\n if self.contains_key(key): # if key exists in hashmap, remove key/value pair\\n hash_key = self._hash_function(key) % self.capacity\\n bucket = self._buckets[hash_key]\\n bucket.remove(key)\",\n \"def remove(self, key):\\n ndx = self._findPosition(key)\\n assert ndx, 'Invalid map key'\\n self._entryList.pop(key)\",\n \"def delete(self, key):\\r\\n index = self.search(key)\\r\\n if self.contains_key_at(key, index):\\r\\n del self.keys[index]\",\n \"def __delitem__(self, key):\\n self.f_remove(key)\",\n \"def remove(self, key: int) -> None:\\n t = key % 20011\\n delete = []\\n for item in self.hash[t]:\\n if item[0] == key:\\n delete = item\\n if delete:\\n self.hash[t].remove(delete)\",\n \"def remove(self, key: int) -> None:\\n chain, idx = self._search(key)\\n if idx is not None:\\n chain.pop(idx)\",\n \"def remove(self, key: int) -> None:\\n if key < self.len:\\n self._map[key] = -1\",\n \"def remove(self, key):\\n hashv = self.hash(key)\\n bucket=self.hashmap[hashv]\\n for i,(k,v) in enumerate(bucket):\\n if k==key:\\n del bucket[i]\",\n \"def remove_key(self, key: keyType) -> None:\\n self.validate_key(key)\\n hash_address = self.get_hash_address(key)\\n head_node = self.hashTable[hash_address]\\n if key not in head_node.keys:\\n raise Exception\\n\\n for index in range(len(head_node.singlyLinkedList)):\\n if head_node.singlyLinkedList[index].key == key:\\n head_node.count -= len(head_node.singlyLinkedList[index].values)\\n head_node.keys.remove(key)\\n head_node.singlyLinkedList.pop(index)\\n break\\n logger.info(\\\"Successfully remove the element.\\\")\",\n \"def remove(self, key):\\n ha = self.myhash(key)\\n if key in self.hashmap[ha][0]:\\n i = self.hashmap[ha][0].index(key)\\n self.hashmap[ha][0].pop(i)\\n self.hashmap[ha][1].pop(i)\",\n \"def remove_value(self, thing_key, dkey):\\n if thing_key in self.things_dict:\\n dic = self.things_dict[thing_key]\\n if type(dic) != type({}):\\n return\\n dic.pop(dkey, None)\",\n \"def remove(self, key, value):\\n if key not in self: return\\n elif self[key] == value: del(self[key])\\n else:\\n try:\\n parts = self.list(key)\\n parts.remove(value)\\n self[key] = \\\"\\\\n\\\".join(parts)\\n except ValueError:\\n if key in self: del(self[key])\",\n \"def remove(self, key):\\n return self._db.hdel(self.index, key)\",\n \"def remove(self, value) -> None:\\n key = getattr(value, self.keyattr)\\n if callable(key):\\n key = key()\\n with suppress(ValueError):\\n self.data[key].remove(value)\\n self.size -= 1\",\n \"def _delKey(self, key):\\n pass\",\n \"def delete(self, key):\\n return None\",\n \"def remove(self, key):\\n index = self._hash_mod(key)\\n node = self.storage[index]\\n node_before = None\\n if node:\\n while node:\\n if node.key == key:\\n if node_before:\\n node_before.next = node.next\\n elif node.next:\\n self.storage[index] = node.next\\n else:\\n self.storage[index] = None\\n self.key_count -= 1\\n return\\n node_before = node\\n node = node.next\\n print(f\\\"An element with key '{key}' cannot be found!\\\")\",\n \"def __delitem__(self, key):\\n del self._data[key]\",\n \"def __delitem__(self, key):\\n\\n # If key is in hash map\\n if self.__contains__(key):\\n\\n # Get hashed key\\n i = self.hash(key)\\n\\n # Get chain index of key value pair\\n chain_idx = self.keys_ref[i].index(key)\\n\\n # Delete value associated with key in hash map\\n del self.table[i][chain_idx]\\n\\n # Delete key from hash table\\n del self.keys_ref[i][chain_idx]\\n\\n # Remove key from set of keys\\n self.keys_set.remove(key)\\n\\n # Decrement size\\n self.size -= 1\\n\\n # If key not in hash map\\n else:\\n\\n # Raise error\\n raise KeyError(key)\",\n \"def remove(self, key):\\n hash_key = key % self.key_space\\n self.hash_table[hash_key].remove(key)\",\n \"def _map___delitem__(self, key):\\n if not isinstance(key, self.keytype):\\n raise KeyError('type of `key` should be ' + repr(self.keytype) + ' but got ' + repr(type(key)))\\n if key not in self:\\n raise KeyError('key not found')\\n self.erase(self.find(key))\\n return\",\n \"def __delitem__(self, key: tuple):\\n s, a = key\\n del self.store[s][a]\",\n \"def remove(self, key):\\n if key < self.length:\\n self.buckets[key] = -1\",\n \"def _delKey(self, key):\\n try:\\n self._getKeyList().remove(key)\\n except KeyError:\\n # This shouldn't happen, but what do we do if it does?\\n pass\\n self._testKeySubNsDel()\",\n \"def remove(self, key):\\n\\t\\tfrom collections import OrderedDict\\n\\t\\tdic = self.__dict__\\n\\t\\tif not dic.get(key):\\n\\t\\t\\traise ValueError(\\\"Inputted Key is not valid for removal.\\\")\\n\\t\\tdel dic[key]\\n\\t\\tnew_dict = {}\\n\\t\\targs = dic.values()\\n\\t\\tfor x, y in enumerate(args):\\n\\t\\t\\tnew_dict.update({x: y})\\n\\t\\tnew_dict = OrderedDict(sorted(new_dict.items()))\\n\\t\\tself.__dict__ = new_dict\",\n \"def delete(self, key) -> None:\\n with self.__lock:\\n if key not in self.__data:\\n return # Ignore if key is non-existent\\n del self.__data[key]\\n self.flush()\",\n \"def __delitem__(self, key):\\n with self.__lock:\\n log.debug(\\\"__delitem__: {}\\\".format(key))\\n del self._d[key]\",\n \"def remove(self, key):\\r\\n for i in range(len(self.lis)):\\r\\n if self.lis[i][0] == key:\\r\\n self.lis.pop(i)\\r\\n break\",\n \"def eliminate_key (self,key):\\r\\n\\r\\n if self.using_shelf:\\r\\n\\r\\n del self.key_dict[str(key)]\",\n \"def __delitem__(self, key):\\n del self._get_storage()[key]\",\n \"def remove(self, key: int) -> None:\\n idx = key % self.size\\n if self.mp[idx]:\\n for i in range(len(self.mp[idx])):\\n if self.mp[idx][i][0] == key:\\n #self.mp[idx].pop(i)\\n del self.mp[idx][i]\\n break\",\n \"def remove(self, key):\\n i = key //1000\\n j = key%1000\\n self.container[i][j] = -1\",\n \"def remove(self, key):\\n \\n # If there used to be a key, there must exist an old value blob somewhere in the database. It should be deallocated after a successful commit to disk.\\n if key in self.keys:\\n if self.keys[key] is not None:\\n punchat,punchlen = self.keys[key]\\n self.awaitingpunch.append((punchat, punchlen))\\n\\n self.keys.pop(key, None)\\n self.buffered.pop(key, None)\\n self.cache.pop(key, None)\\n\\n if self.autocommit:\\n commit()\",\n \"def remove(self, key_name: str):\\n pass\",\n \"def __delitem__(self, key: str) -> None:\\n del self.variables[key]\",\n \"def __delitem__(self, key):\\n del self.list[key]\",\n \"def delete(self, key):\\n pass\",\n \"def delete(self, key):\\n pass\",\n \"def remove_key(self, key: str):\\r\\n\\r\\n if key in self._inner_dict:\\r\\n del self._inner_dict[key]\\r\\n else:\\r\\n raise KeyError(f\\\"key '{key}' is invalid\\\")\",\n \"def remove(self, key):\\n index = int((keyIndex(key) & (self.BUCKET_SIZE - 1)))\\n inner = self.keys[index]\\n if inner == None:\\n return None\\n i = 0\\n while len(inner):\\n if inner[i] == self.EMPTY_KEY:\\n break\\n if inner[i] == key:\\n value = self.values[index][i]\\n while len(inner):\\n if inner[i] == self.EMPTY_KEY:\\n break\\n inner[i - 1] = inner[i]\\n self.values[index][i - 1] = self.values[index][i]\\n i += 1\\n inner[i - 1] = self.EMPTY_KEY\\n self.values[index][i - 1] = None\\n self.size -= 1\\n self.modCount += 1\\n return value\\n i += 1\\n return None\",\n \"def __delitem__(self, key):\\n self.delete(key)\",\n \"def __delitem__(self, key):\\n self.delete(key)\",\n \"def __delitem__(self, key: Hashable) -> None:\\n del self.contents[key]\\n return\",\n \"def delete(self, key):\\n raise NotImplementedError\",\n \"def delete(self, key):\\n raise NotImplementedError\",\n \"def remove(self, value):\\r\\n if value not in self:\\r\\n raise KeyError(value)\\r\\n self.discard(value)\",\n \"def delete(self, key):\\n node = self.search(key)\\n if node:\\n self.remove_node(node)\",\n \"def __delitem__(self, key):\\n try:\\n del self._maps[0][key]\\n except KeyError:\\n raise KeyError(\\n 'Key not found in the last mapping: {!r}'.format(key))\",\n \"def delete(self, key: int) -> None:\\n node = self.search(key)\\n if node:\\n self._delete(node)\",\n \"def __delitem__(self, key):\\n\\n if '.' in key:\\n path = key.split('.', 1)\\n self.parser.remove_option(path[0], path[1])\\n else:\\n raise KeyError\",\n \"def delete(self, key):\\n raise NotImplementedError()\",\n \"def delete(self, key: T) -> None:\\n\\n idx: int = self.hash_fn(key) # get an index location for 'key'\\n if self.table[idx] is None: # 'key' doesn't exists in hash table\\n raise Exception(\\\"Key doesn't exist in hashtable\\\")\\n else:\\n self.table[self.find(key)] = None # delete value at 'key'\\n self.filled_count -= 1\",\n \"def delete(self, key):\",\n \"def __delitem__(self, k):\\n if not self.is_empty():\\n p = self._subtree_search(self.root(), k)\\n if k == p.key():\\n self.delete(p)\\n return\\n self._rebalance_access(p)\\n raise KeyError('Key Error:' + repr(k))\",\n \"def delSit(self, key):\\n if hasattr(key, \\\"encode\\\"):\\n key = key.encode(\\\"utf-8\\\") # convert str to bytes\\n return self.delVal(self.sits, key)\",\n \"def delete(self, key: str):\\n raise NotImplementedError\",\n \"def _delete(self, key):\\n path = self._get_key_path(key)\\n remove(path)\",\n \"def __delitem__(self, key):\\n del self.elements[key]\",\n \"def delete(self, key):\\n # TODO: Find the given key and delete its entry if found\\n self.size -= 1\\n hash_key = self._bucket_index(key) # Gets the index of the key\\n if self.contains(key) is True:\\n for key_value_pair in self.buckets[hash_key]: # Iteratre through the value pair\\n if key_value_pair[0] is key: # If the key matches\\n self.buckets[hash_key].delete(key_value_pair)\\n # self.buckets[hash_key] = None\\n return True\\n else:\\n raise KeyError(\\\"Key no longer exists\\\") # If key doesn't exist, return None\",\n \"def delete(self, key):\\n visitor = VisitorDelete()\\n\\n self.visit(key, visitor)\\n\\n if (visitor.result):\\n self.size -= 1\\n\\n return visitor.result\",\n \"def __delitem__(self, key):\\n if not self._set:\\n raise TypeError('This dict is read-only')\\n return self._set(key, None)\",\n \"def remove(self, key: int) -> None:\\n index = key % 10000\\n previous = self.array[index]\\n current = previous.next\\n while current:\\n if current.key == key:\\n previous.next = current.next\\n break\\n previous = previous.next\\n current = current.next\",\n \"def delKey(self, key ):\\n if key in self.conf:\\n del self.conf[key]\",\n \"def __delitem__(self, key: T) -> None:\\n self.delete(key)\",\n \"def __delitem__(self, key):\\n i, kv_pair = self._lookup(key, self._backing)\\n if kv_pair and not kv_pair.value is Hashmap.absent:\\n self._backing[i] = KeyValue(key, Hashmap.absent)\\n self._deleted += 1\\n\\n size = len(self._backing)\\n utilization = (self._used - self._deleted)/size \\n if utilization < 0.16:\\n self._resize(self._decr_size(size))\\n else:\\n raise KeyError('no such item!')\",\n \"def delete(self, key):\\n hash_key = hash(key) % self.length\\n bucket = self.array[hash_key]\\n if not bucket:\\n raise ValueError('Key does not exist')\\n for key_val_pair in bucket:\\n if key_val_pair[0] == key:\\n bucket.remove(key_val_pair)\",\n \"def remove(self, data, key, value):\\n if key in data:\\n if not value: # value is empty or false, just remove it\\n data.pop(key, None) # delete\\n elif isinstance(value, type(data[key])): # if same type\\n if isinstance(value, list): # if it's a list, like modules\\n data[key] = list(set(data[key]) - set(value))\\n elif isinstance(\\n value, dict\\n ): # if it's a dict, difference of the keys and rebuild dict\\n for k, v in value.items():\\n data[key][k] = self.remove(data[key], k, v)\\n else:\\n raise TypeError(\\n f\\\"Value of {key} is {type(value)} and\\\"\\n f\\\" the imported {key} is {type(data[key])}. Type mismatch.\\\"\\n )\\n return data[key]\",\n \"def remove(kv_data, key):\\n if isinstance(kv_data, str):\\n kv_data = loads(kv_data) # Turn into Dictionary\\n try:\\n del kv_data[key]\\n except NameError:\\n print(key, \\\" does not exists in key value pair.\\\")\\n kv_data = dumps(kv_data)\\n else:\\n print(\\\"Provide a Json Key Value String\\\")\\n sys.exit(6)\\n return kv_data\",\n \"def __delitem__(self, key):\\n\\t\\tdel self.__dStore[key]\",\n \"def __delitem__(self, key):\\n\\n dict.__delitem__(self, key)\\n self.changed()\",\n \"def remove(self, key: int) -> None:\\n \\n \\n hashvalue=key% 1000\\n if self.hashset[hashvalue]==None:\\n return\\n head = self.hashset[hashvalue]\\n dummy_head = Node(0)\\n curr = dummy_head\\n while head:\\n k,v = head.data\\n if k==key:\\n head=head.next\\n curr.next=head\\n curr= curr.next\\n if head != None:\\n \\n head = head.next\\n \\n self.hashset[hashvalue]=dummy_head.next\",\n \"def delete(self, key):\\n self.tree.delete(key)\",\n \"def remove(self, key: int) -> None:\\n \\n index = self.hash(key)\\n\\n # If list doesn't exist just return\\n if not self.map[index]: return\\n\\n # If it's the head of list, manipulate pointers\\n if self.map[index].val[0] == key:\\n self.map[index] = self.map[index].next\\n return\\n\\n curr = self.map[index]\\n\\n # Search through list\\n while curr.next:\\n # If the value in list matches key, manipulate list\\n if curr.next.val[0] == key: \\n curr.next = curr.next.next\\n return\\n\\n curr = curr.next\\n\\n # Otherwise if it's not in list do nothing\",\n \"def delete(self, key: object):\\n try:\\n del self._user_data[key]\\n except KeyError:\\n pass\",\n \"def remove(self, key: int) -> None:\\n pos = key % self.space\\n head = self.hash_table[pos]\\n curr = head\\n\\n while curr.next:\\n if curr.next.key == key:\\n curr.next = curr.next.next\\n return\\n curr = curr.next\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8015489","0.7890396","0.78630865","0.77276903","0.7694492","0.7658495","0.75991946","0.7547378","0.7540013","0.75382787","0.7528272","0.7514823","0.74924624","0.74631125","0.74571407","0.74240434","0.7404178","0.740016","0.7383215","0.7339205","0.7312927","0.73084694","0.7299147","0.7292786","0.7262589","0.7259542","0.72505337","0.7230171","0.72213364","0.7213354","0.7204039","0.7199149","0.71656233","0.71525234","0.71247417","0.7120345","0.7092144","0.7089557","0.70658207","0.70549214","0.70380265","0.7027337","0.70259273","0.70234543","0.7006545","0.7003801","0.70031977","0.6994655","0.6977009","0.6976624","0.6966257","0.69508183","0.6920087","0.6912002","0.6911744","0.6888273","0.6877643","0.6875138","0.6872282","0.6869909","0.6864265","0.6849796","0.6844839","0.6844839","0.6844115","0.6829279","0.6827499","0.6827499","0.68060005","0.6805828","0.6805828","0.680147","0.6801088","0.68001807","0.67997843","0.67920715","0.6787126","0.6785372","0.67794085","0.67432886","0.6737817","0.673641","0.6727269","0.67258966","0.6712747","0.6706682","0.6691285","0.66846627","0.6684153","0.66705996","0.6669169","0.6666968","0.6666889","0.6650579","0.66483235","0.6647025","0.66466236","0.6640764","0.6638059","0.66376173","0.66332555"],"string":"[\n \"0.8015489\",\n \"0.7890396\",\n \"0.78630865\",\n \"0.77276903\",\n \"0.7694492\",\n \"0.7658495\",\n \"0.75991946\",\n \"0.7547378\",\n \"0.7540013\",\n \"0.75382787\",\n \"0.7528272\",\n \"0.7514823\",\n \"0.74924624\",\n \"0.74631125\",\n \"0.74571407\",\n \"0.74240434\",\n \"0.7404178\",\n \"0.740016\",\n \"0.7383215\",\n \"0.7339205\",\n \"0.7312927\",\n \"0.73084694\",\n \"0.7299147\",\n \"0.7292786\",\n \"0.7262589\",\n \"0.7259542\",\n \"0.72505337\",\n \"0.7230171\",\n \"0.72213364\",\n \"0.7213354\",\n \"0.7204039\",\n \"0.7199149\",\n \"0.71656233\",\n \"0.71525234\",\n \"0.71247417\",\n \"0.7120345\",\n \"0.7092144\",\n \"0.7089557\",\n \"0.70658207\",\n \"0.70549214\",\n \"0.70380265\",\n \"0.7027337\",\n \"0.70259273\",\n \"0.70234543\",\n \"0.7006545\",\n \"0.7003801\",\n \"0.70031977\",\n \"0.6994655\",\n \"0.6977009\",\n \"0.6976624\",\n \"0.6966257\",\n \"0.69508183\",\n \"0.6920087\",\n \"0.6912002\",\n \"0.6911744\",\n \"0.6888273\",\n \"0.6877643\",\n \"0.6875138\",\n \"0.6872282\",\n \"0.6869909\",\n \"0.6864265\",\n \"0.6849796\",\n \"0.6844839\",\n \"0.6844839\",\n \"0.6844115\",\n \"0.6829279\",\n \"0.6827499\",\n \"0.6827499\",\n \"0.68060005\",\n \"0.6805828\",\n \"0.6805828\",\n \"0.680147\",\n \"0.6801088\",\n \"0.68001807\",\n \"0.67997843\",\n \"0.67920715\",\n \"0.6787126\",\n \"0.6785372\",\n \"0.67794085\",\n \"0.67432886\",\n \"0.6737817\",\n \"0.673641\",\n \"0.6727269\",\n \"0.67258966\",\n \"0.6712747\",\n \"0.6706682\",\n \"0.6691285\",\n \"0.66846627\",\n \"0.6684153\",\n \"0.66705996\",\n \"0.6669169\",\n \"0.6666968\",\n \"0.6666889\",\n \"0.6650579\",\n \"0.66483235\",\n \"0.6647025\",\n \"0.66466236\",\n \"0.6640764\",\n \"0.6638059\",\n \"0.66376173\",\n \"0.66332555\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21969,"cells":{"query":{"kind":"string","value":"Retrieve the value stored with the given key. Returns None if the key is not found. Implement this."},"document":{"kind":"string","value":"def get(self, key):\n hi = self.hash_index(key)\n if (self.storage[hi]):\n if(self.storage[hi].next):\n current = self.storage[hi]\n while current.next and current.key != key:\n current = current.next\n return current.value\n else:\n return self.storage[hi].value\n\n return None"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def retrieve(self, key):\n index = self._hash_mod(key)\n node = self.storage[index]\n while node is not None:\n if node.key == key:\n return node.value\n node = node.next\n return None","def get(self, key):\n\n node = self._get_node(key) # Get the node with the key (if it exists)\n\n if node is None:\n return None\n else:\n return node.value","def get(self, key: K) -> Optional[V]:\n return self.mget([key])[0]","def get(self, key):\n # TODO: Check if the given key exists and return its associated value\n hash_key = self._bucket_index(key) # Gets the index of the key\n\n if self.buckets[hash_key].is_empty() is False: # If the hask_key exists\n for key_value_pair in self.buckets[hash_key]: # Iteratre through the value pair\n if key_value_pair[0] is key: # If the key matches\n return key_value_pair[1] # Return the value\n raise KeyError(\"Key doesn't exist\") # If key doesn't exist, return None","def get_value(self, key: str) -> Any:\r\n if key is None:\r\n return self.data\r\n try:\r\n return self.data[key]\r\n except KeyError:\r\n return None","def get(self, key):\r\n\t\t# return None if the key doesn't exist\r\n\t\tif not self.contains_key(key):\r\n\t\t\treturn None\r\n\t\telse:\r\n\t\t\tindex = self.get_index(key) # get the index of the key\r\n\r\n\t\t\t# begin traversal of the linked list until we reach the key\r\n\t\t\tcur_node = self._buckets[index].head\r\n\t\t\twhile cur_node.key != key:\r\n\t\t\t\tcur_node = cur_node.next\r\n\r\n\t\t\treturn cur_node.value","def get_value(self, key):\r\n if self.hash_table[self.horner_hash(key)] is not None:\r\n if self.hash_table[self.horner_hash(key)].key == key:\r\n return self.hash_table[self.horner_hash(key)].value\r\n else:\r\n return None","def get(self, key):\r\n if not isinstance(key, str):\r\n raise TypeError(\"Key must be a string\")\r\n\r\n node = self._find_node(key)\r\n if node is None:\r\n return None\r\n else:\r\n return node.value[1]","def get(self, key):\n if key in self._db:\n return self._db[key]\n else:\n return None","def _get(self, key):\n try:\n val = getattr(self, f\"_{key}\")\n if val is not None:\n return val\n else:\n self._load()\n return getattr(self, f\"_{key}\")\n except AttributeError:\n return None","def get(self, key):\n if key in self.fields:\n return self.fields.get(key).get()\n return None","def get_value(self, key):\n return self[key]","def get(self, key: str) -> Optional[Value]:\n\n return self._blob.get(key)","def get_value(self, key):\n return self.data.get(key)","def get(self, key):\n if type(key) != str:\n raise TypeError(\"This is not the string you're looking for!\")\n number = self._hash(key)\n stored_key = number if self.function == 'fnv' else key\n try:\n return self.bucket_list[number % self.bucket_number].search(stored_key).stored_value\n except AttributeError:\n return None","def get(self, key):\n if key and key in self.cache_data:\n return self.cache_data[key]\n return None","def get(self, key):\n if key is None:\n return None # None is not a valid key\n return get_from_subtree(self.root, key)","def get(self, key):\n try:\n return(self._data[key])\n except:\n log.error(\"Can't get data '%s'\" % key)\n return","def get(self, key: K)-> Optional[V]:\n return self._func(key)","def get(self, key):\n if key:\n return self.cache_data.get(key)\n else:\n return None","def get(self, key):\n hk = hash(key)\n h = self._hash(hk)\n i = 0\n while i < self.size:\n if self.slot[h] == key:\n return self.data[h]\n else:\n h = self._rehash(hk, i)\n i += 1\n return None","async def get(self, key):\n return self.dict.get(key, None)","def get(self, key):\n h = key%self.m\n a = self.a\n if a[h]:\n return a[h].val\n else:\n return -1","def get_value(self, key: str) -> Optional[str]:\n raise NotImplementedError","def get_value(self, key):\n try:\n return self.map[key]\n except KeyError:\n raise KeyError('key is not in map')","def get(self, key):\n if key and key in self.cache_data.keys():\n return self.cache_data[key]\n else:\n return None","def get(self, key):\n if key and key in self.cache_data.keys():\n return self.cache_data[key]\n else:\n return None","def get( self, key ):\n if key not in self._values:\n raise ValueError( 'Invalid argument key \"{}\".'.format( key ) )\n return self._values[ key ]","def get(self, key):\n if key is None:\n return None\n return self.cache_data.get(key, None)","def get(self, key, default=None):\n key = self._validate_key(key)\n sql = u\"\"\"\n SELECT `value` FROM `{table}` WHERE key = ?\n \"\"\".format(table=self.name)\n\n r = self.conn.execute(sql, (key,)).fetchone()\n\n if r:\n return self.convert_out(r['value'])\n\n return default","def get(self, key):\n # Your code here\n\n idx = self.hash_index(key)\n\n # check if the index is in range\n if idx >= 0 and idx < self.capacity:\n curr_node = self.hash_table[idx]\n\n # check if any node at index exists\n if curr_node is None:\n return None\n\n # if there's already something at this index\n while curr_node is not None:\n \n # check to see if there is an entry at this index whose key matches the provided key\n while curr_node.key is not key:\n curr_node = curr_node.next\n \n # if we never found an entry with a matching key, return None\n if curr_node.key is not key or curr_node is None:\n return None\n else:\n return curr_node.value\n \n \n # otherwise return None if the index is not in range\n else:\n return None","def get(self, key):\n index = int((keyIndex(key) & (self.BUCKET_SIZE - 1)))\n inner = self.keys[index]\n if inner == None:\n return None\n i = 0\n while len(inner):\n innerKey = inner[i]\n if innerKey == self.EMPTY_KEY:\n return None\n elif innerKey == key:\n return self.values[index][i]\n i += 1\n return None","def value(self, key):\n item = self.default(key)\n return self.__getSafeValue(key, item)","def lookup(self, key):\n n = self.find(key)\n if n:\n return n.value\n else:\n return False","def get(self, key):\n return self[key]","def get(self, key):\n # Find bucket where given key belongs\n # Check if key-value entry exists in bucket\n # If found, return value associated with given key\n # Otherwise, raise error to tell user get failed\n # Hint: raise KeyError('Key not found: {}'.format(key))\n key_bucket = self._bucket_index(key)\n\n for key_value_tuple in self.buckets[key_bucket].items():\n if key_value_tuple[0] is key:\n return key_value_tuple[1]\n\n raise KeyError('Key not found: {}'.format(key))","def get(self, key):\n node = self._get_node(key)\n\n if node:\n return node.data","def __getitem__(self, key):\n if self._root:\n node = self._getItemHelper(key, self._root)\n if node:\n return node.value\n else:\n return None\n else:\n return None","def get(self, key):\n return self._store.get(key, None)","def get(self, key):\n return self._store.get(key, None)","def get(self, key):\n\t\treturn self.__get(key, key[1:])","def get(self, key):\n return self.sp.get(key)","def get(self, key):\n hash_key = self._hash_function(key) % self.capacity # returns hashed keys corresponding bucket index\n bucket = self._buckets[hash_key] # get bucket for that index\n\n current = bucket.head # set bucket.head to variable as not to override linked list\n\n while current is not None: # iterate through linked list until value is found, or returns None\n if current.key == key:\n return current.value\n current = current.next","def get(self, key: T) -> Optional[U]:\n return self._store.get(key)","def get_value(self, key):\n return self[key]['value']","def get_value(self, conn, key):\n if self.exists(conn, key):\n return conn.get(key)\n else:\n raise Exception, \"No key (%s) exists\" %key","def get_value(key):\n\n oErr = ErrHandle()\n infoval = None\n try:\n obj = TsgInfo.objects.filter(infokey__iexact=key).first()\n if obj != None:\n infoval = obj.infoval\n except:\n msg = oErr.get_error_message()\n oErr.DoError(\"TsgInfo/get_value\")\n return infoval","def get(self, key, def_value=None):\n\n index = self._get_hash(key)\n\n if self.table[index] is not None:\n for pair in self.table[index]:\n if key == pair[0]:\n return pair[1]\n\n if def_value is not None:\n return def_value\n\n raise ValueError(f\"can't find value with given key {key}\")","def get_item(self, key):\n search_slot = self.count_hash(key, len(self.slots))\n\n if self.slots[search_slot] == key:\n data = self.data[search_slot]\n elif isinstance(self.slots[search_slot], tuple):\n index_tuple = (self.slots[search_slot].index(key))\n data = (self.data[search_slot][index_tuple])\n else:\n data = None\n\n return data","def lookup(self, key):\n k = self.get_position(key)\n\n if self.keys[k] == key:\n return node.values[k]\n\n # Lookup in the child node.\n if self.refs[k+1] == None:\n return None\n return self.refs[k+1].lookup(key)","def get_value(self, key):\n pass","def get_value(key):\n\n request_dict = RequestFileCom.file_to_dict()\n\n try:\n\n return request_dict[key]\n\n except:\n\n return None","def get(self, key):\n _filter = {'_id': key}\n doc = self.collection.find_one(_filter)\n\n if doc and not self._verify_timeout(doc):\n return self._unpickle(doc['value'])","def get(self, key):\n if key in self.cache:\n value = self.cache[key].value\n # Re-enqueue to indicate recently used\n self._re_enqueue(self.cache[key])\n return value\n else:\n return -1","def get(self, k: Any) -> Any:\n i = abs(hash(k)) % self.size\n current = self.data[i]\n while current is not None:\n if current.key == k:\n return current.value\n current = current.next\n return None","def get(self, key):\n return self._cache[key]","def get(self, key):\r\n index = self.hash(key)\r\n l = self.bucket[index]\r\n while l.next:\r\n if l.next.key == key:\r\n return l.next.val\r\n l = l.next\r\n return -1","def get(\n self,\n key: str,\n ) -> T.Optional[VALUE]:\n record = self._get_record_from_backend(key)\n if record is None:\n return None\n\n if record.expire:\n now = utc_now()\n if (now.timestamp() - record.update_ts) < record.expire:\n return self.deserialize(record.value)\n else:\n return None\n else:\n return self.deserialize(record.value)","def fetch(self,key):\n try:\n return self.__content[key]\n except KeyError:\n return None","def __getitem__(self, key):\n _, kv_pair = self._lookup(key, self._backing)\n if kv_pair:\n return kv_pair.value\n else:\n return Hashmap.absent","def get(self, key):\n if key is None:\n raise TypeError\n\n index = self.__get_cache_set_index(key)\n cache_set = self.cache_sets[index]\n h_key = self.__ensure_hashable_key(key)\n return cache_set.get(h_key)","def get(self, key):\n hash_key = key % self.key_space\n return self.hash_table[hash_key].get(key)","def get(self, key, default=None):\n return self.data.get(key, default)","def get(self, key, default=None):\n return self.data.get(key, default)","def get(self, key, default=None):\n return self._data.get(key, default)","def get_if_exist(self, data, key):\n if key in data:\n return data[key]\n return None","def get(self, key, default=None):\r\n return self.data.get(IdentityRef(key),default)","def get(self, key, default=None):\n return self._d.get(key, default)","def get(self, key):\n hashv = self.hash(key)\n bucket=self.hashmap[hashv]\n for i,(k,v) in enumerate(bucket):\n if k==key:\n return v\n return -1","def get(self, key, default=None):\n if key in self:\n return self[key]\n return default","def get(self, key):\n raise NotImplementedError","def get(self, key):\n return self.container[key]","def get(self, key):\n index = key % self.size\n\n cur = self.bucket[index]\n while cur:\n if cur.key == key:\n return cur.val\n cur = cur.next\n return -1","def get(self, key):\n # O(1) in best case and O(n) in worst case Time Complexity\n # O(1) in best case and O(n) in worst case Space Complexity\n\n currentNode = self.getElement(key)\n if (currentNode.next == None):\n return -1\n else:\n return currentNode.next.v","def get(self, key: str) -> str:\n hashkey = self._gethash(key)\n if type(self.HashMap[hashkey]) is list:\n if len(self.HashMap[hashkey]) > 2:\n \"\"\"\n Return correct Key and value from the\n location which has a hashclash\n \"\"\"\n idx = self._find_if_hashclash(key, hashkey, \"v\")\n if idx is not None:\n return self.HashMap[hashkey][idx]\n elif self.HashMap[hashkey][0] == key:\n # Check that the data matches the key and return it if it does\n return self.HashMap[hashkey][1]\n return \"\"","def get(self, key: int) -> int:\n chain, idx = self._search(key)\n if idx is not None:\n return chain[idx][1]\n return -1","def __getitem__(self, key):\n return self._get(key)","def __getitem__(self, key):\n return self.keyvaluepair_set.get(key=key).value","def __getitem__(self, key):\n ndx = self._findPosition(key)\n assert ndx is not None, 'Invalid map key'\n return self._entryList[ndx].value","def get(self, key: str):\r\n\r\n if key in self._inner_dict:\r\n return self._inner_dict[key]\r\n else:\r\n raise KeyError(f\"key '{key}' is invalid\")","def get(self, key: str, default: t.Optional[object] = None) -> t.Any:\n try:\n index = self.__keys.index(str(key))\n except ValueError:\n return default\n if 0 <= index < len(self):\n return self._super_getitem_single(index)\n else:\n return default","def get(self, key):\n return self.execute_command(self.GET_CMD, key)","def get(self, key):\n return self.cache_data.get(key)","def get(self, key, default=None):\n try:\n value = self.list[key]\n except KeyError:\n return default\n else:\n return value","def GetValue(self, key):\n return self._metadata_dict[key]","def get(self, key: str) -> Any:\n return self.db.get(key)","def get(self, key):\n return self.arr[key]","def __getitem__(self, key):\n value = self.secrets.get(key)\n if value is None:\n log.warning(f\"Value for '{key}' was not found in the secrets file. Returning 'None'.\")\n return value","def get(self, key):\n value = self.driftwood.cache.download(\"DB:\"+key) # Check if the value is cached.\n\n if not value:\n value = self.__scaffydb.get(key)\n\n if not value:\n self.driftwood.log.msg(\"ERROR\", \"Database\", \"no such key\", \"\\\"{0}\\\"\".format(key))\n return None\n\n self.driftwood.cache.upload(\"DB:\"+key, value) # Cache the value.\n self.driftwood.log.info(\"Database\", \"get\", \"\\\"{0}\\\"\".format(key))\n return value","def _getValue(self, field):\n if self._contents.has_key(field):\n return self._contents[field]\n else:\n return None","def get(self, key):\n index = key % self.size\n curr_node = self.hash_table[index]\n\n while curr_node:\n if curr_node.key == key:\n return curr_node.value\n else:\n curr_node = curr_node.next\n\n return -1","def get(self, key):\n if self.db is None:\n self._init()\n return self.db[key]","def get(self, key):\n ha = self.myhash(key)\n if key not in self.hashmap[ha][0]:\n return -1\n else:\n return self.hashmap[ha][1][self.hashmap[ha][0].index(key)]","def get(self, key, default=None):\n try:\n return self._get(key)\n except Exception:\n return default","def get(self, key):\n # Initialize key variables\n result = self.cache.get(key)\n\n # Return\n return result","def resolve(self, key: str) -> Optional[Any]:\n return self.dict.get(key)","def try_read(self, key):\n if key not in self.db:\n return None\n return self.db[key]","def get_value(self, key: Union[str, ConfigurationVariable]) -> Any:\n if not key:\n raise KeyError(key)\n key_str = key.name if isinstance(key, ConfigurationVariable) else key\n return self._fetch_value(key_str)","def get(self, key):\n dkey = digest(key)\n _log.debug(\"Server:get %s\" % base64.b64encode(dkey))\n # if this node has it, return it\n exists, value = self.storage.get(dkey)\n if exists:\n return defer.succeed(value)\n node = Node(dkey)\n nearest = self.protocol.router.findNeighbors(node)\n if len(nearest) == 0:\n self.log.warning(\"There are no known neighbors to get key %s\" % key)\n return defer.succeed(None)\n spider = ValueSpiderCrawl(self.protocol, node, nearest, self.ksize, self.alpha)\n return spider.find()","def get(self, key, default=None):\n try:\n return self.__getitem__(key)\n except ValueError:\n if default is not None:\n return default\n else:\n raise"],"string":"[\n \"def retrieve(self, key):\\n index = self._hash_mod(key)\\n node = self.storage[index]\\n while node is not None:\\n if node.key == key:\\n return node.value\\n node = node.next\\n return None\",\n \"def get(self, key):\\n\\n node = self._get_node(key) # Get the node with the key (if it exists)\\n\\n if node is None:\\n return None\\n else:\\n return node.value\",\n \"def get(self, key: K) -> Optional[V]:\\n return self.mget([key])[0]\",\n \"def get(self, key):\\n # TODO: Check if the given key exists and return its associated value\\n hash_key = self._bucket_index(key) # Gets the index of the key\\n\\n if self.buckets[hash_key].is_empty() is False: # If the hask_key exists\\n for key_value_pair in self.buckets[hash_key]: # Iteratre through the value pair\\n if key_value_pair[0] is key: # If the key matches\\n return key_value_pair[1] # Return the value\\n raise KeyError(\\\"Key doesn't exist\\\") # If key doesn't exist, return None\",\n \"def get_value(self, key: str) -> Any:\\r\\n if key is None:\\r\\n return self.data\\r\\n try:\\r\\n return self.data[key]\\r\\n except KeyError:\\r\\n return None\",\n \"def get(self, key):\\r\\n\\t\\t# return None if the key doesn't exist\\r\\n\\t\\tif not self.contains_key(key):\\r\\n\\t\\t\\treturn None\\r\\n\\t\\telse:\\r\\n\\t\\t\\tindex = self.get_index(key) # get the index of the key\\r\\n\\r\\n\\t\\t\\t# begin traversal of the linked list until we reach the key\\r\\n\\t\\t\\tcur_node = self._buckets[index].head\\r\\n\\t\\t\\twhile cur_node.key != key:\\r\\n\\t\\t\\t\\tcur_node = cur_node.next\\r\\n\\r\\n\\t\\t\\treturn cur_node.value\",\n \"def get_value(self, key):\\r\\n if self.hash_table[self.horner_hash(key)] is not None:\\r\\n if self.hash_table[self.horner_hash(key)].key == key:\\r\\n return self.hash_table[self.horner_hash(key)].value\\r\\n else:\\r\\n return None\",\n \"def get(self, key):\\r\\n if not isinstance(key, str):\\r\\n raise TypeError(\\\"Key must be a string\\\")\\r\\n\\r\\n node = self._find_node(key)\\r\\n if node is None:\\r\\n return None\\r\\n else:\\r\\n return node.value[1]\",\n \"def get(self, key):\\n if key in self._db:\\n return self._db[key]\\n else:\\n return None\",\n \"def _get(self, key):\\n try:\\n val = getattr(self, f\\\"_{key}\\\")\\n if val is not None:\\n return val\\n else:\\n self._load()\\n return getattr(self, f\\\"_{key}\\\")\\n except AttributeError:\\n return None\",\n \"def get(self, key):\\n if key in self.fields:\\n return self.fields.get(key).get()\\n return None\",\n \"def get_value(self, key):\\n return self[key]\",\n \"def get(self, key: str) -> Optional[Value]:\\n\\n return self._blob.get(key)\",\n \"def get_value(self, key):\\n return self.data.get(key)\",\n \"def get(self, key):\\n if type(key) != str:\\n raise TypeError(\\\"This is not the string you're looking for!\\\")\\n number = self._hash(key)\\n stored_key = number if self.function == 'fnv' else key\\n try:\\n return self.bucket_list[number % self.bucket_number].search(stored_key).stored_value\\n except AttributeError:\\n return None\",\n \"def get(self, key):\\n if key and key in self.cache_data:\\n return self.cache_data[key]\\n return None\",\n \"def get(self, key):\\n if key is None:\\n return None # None is not a valid key\\n return get_from_subtree(self.root, key)\",\n \"def get(self, key):\\n try:\\n return(self._data[key])\\n except:\\n log.error(\\\"Can't get data '%s'\\\" % key)\\n return\",\n \"def get(self, key: K)-> Optional[V]:\\n return self._func(key)\",\n \"def get(self, key):\\n if key:\\n return self.cache_data.get(key)\\n else:\\n return None\",\n \"def get(self, key):\\n hk = hash(key)\\n h = self._hash(hk)\\n i = 0\\n while i < self.size:\\n if self.slot[h] == key:\\n return self.data[h]\\n else:\\n h = self._rehash(hk, i)\\n i += 1\\n return None\",\n \"async def get(self, key):\\n return self.dict.get(key, None)\",\n \"def get(self, key):\\n h = key%self.m\\n a = self.a\\n if a[h]:\\n return a[h].val\\n else:\\n return -1\",\n \"def get_value(self, key: str) -> Optional[str]:\\n raise NotImplementedError\",\n \"def get_value(self, key):\\n try:\\n return self.map[key]\\n except KeyError:\\n raise KeyError('key is not in map')\",\n \"def get(self, key):\\n if key and key in self.cache_data.keys():\\n return self.cache_data[key]\\n else:\\n return None\",\n \"def get(self, key):\\n if key and key in self.cache_data.keys():\\n return self.cache_data[key]\\n else:\\n return None\",\n \"def get( self, key ):\\n if key not in self._values:\\n raise ValueError( 'Invalid argument key \\\"{}\\\".'.format( key ) )\\n return self._values[ key ]\",\n \"def get(self, key):\\n if key is None:\\n return None\\n return self.cache_data.get(key, None)\",\n \"def get(self, key, default=None):\\n key = self._validate_key(key)\\n sql = u\\\"\\\"\\\"\\n SELECT `value` FROM `{table}` WHERE key = ?\\n \\\"\\\"\\\".format(table=self.name)\\n\\n r = self.conn.execute(sql, (key,)).fetchone()\\n\\n if r:\\n return self.convert_out(r['value'])\\n\\n return default\",\n \"def get(self, key):\\n # Your code here\\n\\n idx = self.hash_index(key)\\n\\n # check if the index is in range\\n if idx >= 0 and idx < self.capacity:\\n curr_node = self.hash_table[idx]\\n\\n # check if any node at index exists\\n if curr_node is None:\\n return None\\n\\n # if there's already something at this index\\n while curr_node is not None:\\n \\n # check to see if there is an entry at this index whose key matches the provided key\\n while curr_node.key is not key:\\n curr_node = curr_node.next\\n \\n # if we never found an entry with a matching key, return None\\n if curr_node.key is not key or curr_node is None:\\n return None\\n else:\\n return curr_node.value\\n \\n \\n # otherwise return None if the index is not in range\\n else:\\n return None\",\n \"def get(self, key):\\n index = int((keyIndex(key) & (self.BUCKET_SIZE - 1)))\\n inner = self.keys[index]\\n if inner == None:\\n return None\\n i = 0\\n while len(inner):\\n innerKey = inner[i]\\n if innerKey == self.EMPTY_KEY:\\n return None\\n elif innerKey == key:\\n return self.values[index][i]\\n i += 1\\n return None\",\n \"def value(self, key):\\n item = self.default(key)\\n return self.__getSafeValue(key, item)\",\n \"def lookup(self, key):\\n n = self.find(key)\\n if n:\\n return n.value\\n else:\\n return False\",\n \"def get(self, key):\\n return self[key]\",\n \"def get(self, key):\\n # Find bucket where given key belongs\\n # Check if key-value entry exists in bucket\\n # If found, return value associated with given key\\n # Otherwise, raise error to tell user get failed\\n # Hint: raise KeyError('Key not found: {}'.format(key))\\n key_bucket = self._bucket_index(key)\\n\\n for key_value_tuple in self.buckets[key_bucket].items():\\n if key_value_tuple[0] is key:\\n return key_value_tuple[1]\\n\\n raise KeyError('Key not found: {}'.format(key))\",\n \"def get(self, key):\\n node = self._get_node(key)\\n\\n if node:\\n return node.data\",\n \"def __getitem__(self, key):\\n if self._root:\\n node = self._getItemHelper(key, self._root)\\n if node:\\n return node.value\\n else:\\n return None\\n else:\\n return None\",\n \"def get(self, key):\\n return self._store.get(key, None)\",\n \"def get(self, key):\\n return self._store.get(key, None)\",\n \"def get(self, key):\\n\\t\\treturn self.__get(key, key[1:])\",\n \"def get(self, key):\\n return self.sp.get(key)\",\n \"def get(self, key):\\n hash_key = self._hash_function(key) % self.capacity # returns hashed keys corresponding bucket index\\n bucket = self._buckets[hash_key] # get bucket for that index\\n\\n current = bucket.head # set bucket.head to variable as not to override linked list\\n\\n while current is not None: # iterate through linked list until value is found, or returns None\\n if current.key == key:\\n return current.value\\n current = current.next\",\n \"def get(self, key: T) -> Optional[U]:\\n return self._store.get(key)\",\n \"def get_value(self, key):\\n return self[key]['value']\",\n \"def get_value(self, conn, key):\\n if self.exists(conn, key):\\n return conn.get(key)\\n else:\\n raise Exception, \\\"No key (%s) exists\\\" %key\",\n \"def get_value(key):\\n\\n oErr = ErrHandle()\\n infoval = None\\n try:\\n obj = TsgInfo.objects.filter(infokey__iexact=key).first()\\n if obj != None:\\n infoval = obj.infoval\\n except:\\n msg = oErr.get_error_message()\\n oErr.DoError(\\\"TsgInfo/get_value\\\")\\n return infoval\",\n \"def get(self, key, def_value=None):\\n\\n index = self._get_hash(key)\\n\\n if self.table[index] is not None:\\n for pair in self.table[index]:\\n if key == pair[0]:\\n return pair[1]\\n\\n if def_value is not None:\\n return def_value\\n\\n raise ValueError(f\\\"can't find value with given key {key}\\\")\",\n \"def get_item(self, key):\\n search_slot = self.count_hash(key, len(self.slots))\\n\\n if self.slots[search_slot] == key:\\n data = self.data[search_slot]\\n elif isinstance(self.slots[search_slot], tuple):\\n index_tuple = (self.slots[search_slot].index(key))\\n data = (self.data[search_slot][index_tuple])\\n else:\\n data = None\\n\\n return data\",\n \"def lookup(self, key):\\n k = self.get_position(key)\\n\\n if self.keys[k] == key:\\n return node.values[k]\\n\\n # Lookup in the child node.\\n if self.refs[k+1] == None:\\n return None\\n return self.refs[k+1].lookup(key)\",\n \"def get_value(self, key):\\n pass\",\n \"def get_value(key):\\n\\n request_dict = RequestFileCom.file_to_dict()\\n\\n try:\\n\\n return request_dict[key]\\n\\n except:\\n\\n return None\",\n \"def get(self, key):\\n _filter = {'_id': key}\\n doc = self.collection.find_one(_filter)\\n\\n if doc and not self._verify_timeout(doc):\\n return self._unpickle(doc['value'])\",\n \"def get(self, key):\\n if key in self.cache:\\n value = self.cache[key].value\\n # Re-enqueue to indicate recently used\\n self._re_enqueue(self.cache[key])\\n return value\\n else:\\n return -1\",\n \"def get(self, k: Any) -> Any:\\n i = abs(hash(k)) % self.size\\n current = self.data[i]\\n while current is not None:\\n if current.key == k:\\n return current.value\\n current = current.next\\n return None\",\n \"def get(self, key):\\n return self._cache[key]\",\n \"def get(self, key):\\r\\n index = self.hash(key)\\r\\n l = self.bucket[index]\\r\\n while l.next:\\r\\n if l.next.key == key:\\r\\n return l.next.val\\r\\n l = l.next\\r\\n return -1\",\n \"def get(\\n self,\\n key: str,\\n ) -> T.Optional[VALUE]:\\n record = self._get_record_from_backend(key)\\n if record is None:\\n return None\\n\\n if record.expire:\\n now = utc_now()\\n if (now.timestamp() - record.update_ts) < record.expire:\\n return self.deserialize(record.value)\\n else:\\n return None\\n else:\\n return self.deserialize(record.value)\",\n \"def fetch(self,key):\\n try:\\n return self.__content[key]\\n except KeyError:\\n return None\",\n \"def __getitem__(self, key):\\n _, kv_pair = self._lookup(key, self._backing)\\n if kv_pair:\\n return kv_pair.value\\n else:\\n return Hashmap.absent\",\n \"def get(self, key):\\n if key is None:\\n raise TypeError\\n\\n index = self.__get_cache_set_index(key)\\n cache_set = self.cache_sets[index]\\n h_key = self.__ensure_hashable_key(key)\\n return cache_set.get(h_key)\",\n \"def get(self, key):\\n hash_key = key % self.key_space\\n return self.hash_table[hash_key].get(key)\",\n \"def get(self, key, default=None):\\n return self.data.get(key, default)\",\n \"def get(self, key, default=None):\\n return self.data.get(key, default)\",\n \"def get(self, key, default=None):\\n return self._data.get(key, default)\",\n \"def get_if_exist(self, data, key):\\n if key in data:\\n return data[key]\\n return None\",\n \"def get(self, key, default=None):\\r\\n return self.data.get(IdentityRef(key),default)\",\n \"def get(self, key, default=None):\\n return self._d.get(key, default)\",\n \"def get(self, key):\\n hashv = self.hash(key)\\n bucket=self.hashmap[hashv]\\n for i,(k,v) in enumerate(bucket):\\n if k==key:\\n return v\\n return -1\",\n \"def get(self, key, default=None):\\n if key in self:\\n return self[key]\\n return default\",\n \"def get(self, key):\\n raise NotImplementedError\",\n \"def get(self, key):\\n return self.container[key]\",\n \"def get(self, key):\\n index = key % self.size\\n\\n cur = self.bucket[index]\\n while cur:\\n if cur.key == key:\\n return cur.val\\n cur = cur.next\\n return -1\",\n \"def get(self, key):\\n # O(1) in best case and O(n) in worst case Time Complexity\\n # O(1) in best case and O(n) in worst case Space Complexity\\n\\n currentNode = self.getElement(key)\\n if (currentNode.next == None):\\n return -1\\n else:\\n return currentNode.next.v\",\n \"def get(self, key: str) -> str:\\n hashkey = self._gethash(key)\\n if type(self.HashMap[hashkey]) is list:\\n if len(self.HashMap[hashkey]) > 2:\\n \\\"\\\"\\\"\\n Return correct Key and value from the\\n location which has a hashclash\\n \\\"\\\"\\\"\\n idx = self._find_if_hashclash(key, hashkey, \\\"v\\\")\\n if idx is not None:\\n return self.HashMap[hashkey][idx]\\n elif self.HashMap[hashkey][0] == key:\\n # Check that the data matches the key and return it if it does\\n return self.HashMap[hashkey][1]\\n return \\\"\\\"\",\n \"def get(self, key: int) -> int:\\n chain, idx = self._search(key)\\n if idx is not None:\\n return chain[idx][1]\\n return -1\",\n \"def __getitem__(self, key):\\n return self._get(key)\",\n \"def __getitem__(self, key):\\n return self.keyvaluepair_set.get(key=key).value\",\n \"def __getitem__(self, key):\\n ndx = self._findPosition(key)\\n assert ndx is not None, 'Invalid map key'\\n return self._entryList[ndx].value\",\n \"def get(self, key: str):\\r\\n\\r\\n if key in self._inner_dict:\\r\\n return self._inner_dict[key]\\r\\n else:\\r\\n raise KeyError(f\\\"key '{key}' is invalid\\\")\",\n \"def get(self, key: str, default: t.Optional[object] = None) -> t.Any:\\n try:\\n index = self.__keys.index(str(key))\\n except ValueError:\\n return default\\n if 0 <= index < len(self):\\n return self._super_getitem_single(index)\\n else:\\n return default\",\n \"def get(self, key):\\n return self.execute_command(self.GET_CMD, key)\",\n \"def get(self, key):\\n return self.cache_data.get(key)\",\n \"def get(self, key, default=None):\\n try:\\n value = self.list[key]\\n except KeyError:\\n return default\\n else:\\n return value\",\n \"def GetValue(self, key):\\n return self._metadata_dict[key]\",\n \"def get(self, key: str) -> Any:\\n return self.db.get(key)\",\n \"def get(self, key):\\n return self.arr[key]\",\n \"def __getitem__(self, key):\\n value = self.secrets.get(key)\\n if value is None:\\n log.warning(f\\\"Value for '{key}' was not found in the secrets file. Returning 'None'.\\\")\\n return value\",\n \"def get(self, key):\\n value = self.driftwood.cache.download(\\\"DB:\\\"+key) # Check if the value is cached.\\n\\n if not value:\\n value = self.__scaffydb.get(key)\\n\\n if not value:\\n self.driftwood.log.msg(\\\"ERROR\\\", \\\"Database\\\", \\\"no such key\\\", \\\"\\\\\\\"{0}\\\\\\\"\\\".format(key))\\n return None\\n\\n self.driftwood.cache.upload(\\\"DB:\\\"+key, value) # Cache the value.\\n self.driftwood.log.info(\\\"Database\\\", \\\"get\\\", \\\"\\\\\\\"{0}\\\\\\\"\\\".format(key))\\n return value\",\n \"def _getValue(self, field):\\n if self._contents.has_key(field):\\n return self._contents[field]\\n else:\\n return None\",\n \"def get(self, key):\\n index = key % self.size\\n curr_node = self.hash_table[index]\\n\\n while curr_node:\\n if curr_node.key == key:\\n return curr_node.value\\n else:\\n curr_node = curr_node.next\\n\\n return -1\",\n \"def get(self, key):\\n if self.db is None:\\n self._init()\\n return self.db[key]\",\n \"def get(self, key):\\n ha = self.myhash(key)\\n if key not in self.hashmap[ha][0]:\\n return -1\\n else:\\n return self.hashmap[ha][1][self.hashmap[ha][0].index(key)]\",\n \"def get(self, key, default=None):\\n try:\\n return self._get(key)\\n except Exception:\\n return default\",\n \"def get(self, key):\\n # Initialize key variables\\n result = self.cache.get(key)\\n\\n # Return\\n return result\",\n \"def resolve(self, key: str) -> Optional[Any]:\\n return self.dict.get(key)\",\n \"def try_read(self, key):\\n if key not in self.db:\\n return None\\n return self.db[key]\",\n \"def get_value(self, key: Union[str, ConfigurationVariable]) -> Any:\\n if not key:\\n raise KeyError(key)\\n key_str = key.name if isinstance(key, ConfigurationVariable) else key\\n return self._fetch_value(key_str)\",\n \"def get(self, key):\\n dkey = digest(key)\\n _log.debug(\\\"Server:get %s\\\" % base64.b64encode(dkey))\\n # if this node has it, return it\\n exists, value = self.storage.get(dkey)\\n if exists:\\n return defer.succeed(value)\\n node = Node(dkey)\\n nearest = self.protocol.router.findNeighbors(node)\\n if len(nearest) == 0:\\n self.log.warning(\\\"There are no known neighbors to get key %s\\\" % key)\\n return defer.succeed(None)\\n spider = ValueSpiderCrawl(self.protocol, node, nearest, self.ksize, self.alpha)\\n return spider.find()\",\n \"def get(self, key, default=None):\\n try:\\n return self.__getitem__(key)\\n except ValueError:\\n if default is not None:\\n return default\\n else:\\n raise\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8208157","0.8203918","0.8190829","0.8146119","0.8118441","0.8083434","0.80767083","0.80651796","0.7955004","0.7951158","0.7878939","0.787848","0.7858636","0.7857246","0.78159803","0.78017765","0.7784482","0.77715313","0.77582735","0.7758255","0.77547365","0.7746204","0.774399","0.77140933","0.7709448","0.7695936","0.7695936","0.76889825","0.7676339","0.76539874","0.76382226","0.76279324","0.76052725","0.75771844","0.7542876","0.754165","0.75121135","0.7508293","0.7480697","0.7480697","0.7445978","0.7435168","0.7425954","0.7385503","0.7382715","0.73824686","0.7374794","0.73469865","0.73414004","0.7331105","0.7300122","0.7288698","0.7281179","0.72414327","0.7232272","0.72249585","0.7221272","0.71988267","0.71755236","0.7139544","0.7138003","0.71343154","0.7114329","0.7114329","0.7092185","0.70729035","0.70705855","0.7068509","0.70565623","0.7055919","0.70461535","0.7038295","0.7022904","0.70209676","0.701534","0.7011432","0.70008886","0.6993899","0.699307","0.6963332","0.6958585","0.69511336","0.69480526","0.694246","0.6939641","0.6938066","0.69332725","0.6928578","0.69191545","0.69024855","0.6901499","0.6900949","0.69002223","0.68966615","0.68911743","0.6889055","0.68883646","0.6880632","0.68796563","0.68759984"],"string":"[\n \"0.8208157\",\n \"0.8203918\",\n \"0.8190829\",\n \"0.8146119\",\n \"0.8118441\",\n \"0.8083434\",\n \"0.80767083\",\n \"0.80651796\",\n \"0.7955004\",\n \"0.7951158\",\n \"0.7878939\",\n \"0.787848\",\n \"0.7858636\",\n \"0.7857246\",\n \"0.78159803\",\n \"0.78017765\",\n \"0.7784482\",\n \"0.77715313\",\n \"0.77582735\",\n \"0.7758255\",\n \"0.77547365\",\n \"0.7746204\",\n \"0.774399\",\n \"0.77140933\",\n \"0.7709448\",\n \"0.7695936\",\n \"0.7695936\",\n \"0.76889825\",\n \"0.7676339\",\n \"0.76539874\",\n \"0.76382226\",\n \"0.76279324\",\n \"0.76052725\",\n \"0.75771844\",\n \"0.7542876\",\n \"0.754165\",\n \"0.75121135\",\n \"0.7508293\",\n \"0.7480697\",\n \"0.7480697\",\n \"0.7445978\",\n \"0.7435168\",\n \"0.7425954\",\n \"0.7385503\",\n \"0.7382715\",\n \"0.73824686\",\n \"0.7374794\",\n \"0.73469865\",\n \"0.73414004\",\n \"0.7331105\",\n \"0.7300122\",\n \"0.7288698\",\n \"0.7281179\",\n \"0.72414327\",\n \"0.7232272\",\n \"0.72249585\",\n \"0.7221272\",\n \"0.71988267\",\n \"0.71755236\",\n \"0.7139544\",\n \"0.7138003\",\n \"0.71343154\",\n \"0.7114329\",\n \"0.7114329\",\n \"0.7092185\",\n \"0.70729035\",\n \"0.70705855\",\n \"0.7068509\",\n \"0.70565623\",\n \"0.7055919\",\n \"0.70461535\",\n \"0.7038295\",\n \"0.7022904\",\n \"0.70209676\",\n \"0.701534\",\n \"0.7011432\",\n \"0.70008886\",\n \"0.6993899\",\n \"0.699307\",\n \"0.6963332\",\n \"0.6958585\",\n \"0.69511336\",\n \"0.69480526\",\n \"0.694246\",\n \"0.6939641\",\n \"0.6938066\",\n \"0.69332725\",\n \"0.6928578\",\n \"0.69191545\",\n \"0.69024855\",\n \"0.6901499\",\n \"0.6900949\",\n \"0.69002223\",\n \"0.68966615\",\n \"0.68911743\",\n \"0.6889055\",\n \"0.68883646\",\n \"0.6880632\",\n \"0.68796563\",\n \"0.68759984\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.79671395"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":21970,"cells":{"query":{"kind":"string","value":"Doubles the capacity of the hash table and rehash all key/value pairs. Implement this."},"document":{"kind":"string","value":"def resize(self, factor=2):\n self.capacity = round(self.capacity*factor)\n newarr = [None] * self.capacity\n\n for i, v in enumerate(self.storage):\n while v:\n hi = self.hash_index(v.key)\n if newarr[hi]:\n current = newarr[hi]\n while current.next:\n current = current.next\n\n current.next = HashTableEntry(v.key, v.value)\n else:\n newarr[hi] = HashTableEntry(v.key, v.value)\n\n v = v.next\n\n self.storage = newarr\n\n # Solution 2 - Much cleaner\n # newHashTable = HashTable(round(self.capacity*factor))\n # for i, v in enumerate(self.storage):\n # while v:\n # newHashTable.put(v.key, v.value)\n # v = v.next\n\n # self.capacity = newHashTable.capacity\n # self.storage = newHashTable.storage"},"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 rehash(self):\n new_cap = self._get_new_capacity() # Choose not to handle the ValueError thrown by _get_new_capacity()\n new_table = HashTable(new_cap) # Create a new hash table directly\n for i in range(self.size):\n if self.keys[i] is not None: # Only put() when there exists a key (no Nones)\n new_table[self.keys[i]] = self.values[i] # Rehash and insert into the new table\n\n self.keys = new_table.keys # Update instance variables\n self.values = new_table.values\n self.size = new_cap # Update N\n self.count_rehashes += 1 # Increment total rehashes","def rehash(self):\n old = list()\n # use iteration to record existing items\n for i in range(self.capacity // 2):\n if self.table[i] is not None:\n old.append(self.table[i])\n self.table = self.capacity * [None] # then reset table to desired capacity\n self.size = 0\n for i in old:\n index = self.quadratic_probe(i.key)\n self.table[index] = i\n self.size += 1","def resize(self):\n\n # Stores the new size of the hash map\n new_size = len(self.table) * 2 - 1\n\n # Creates new hash map table (empty)\n new_table = [[]] * new_size\n\n # Creates new key hash table (empty)\n new_ref = [[]] * new_size\n\n # For key value pair in the current hash map\n for key, value in self:\n\n # Get new hashed key for new hash map\n i = hash(key) % len(new_table)\n\n # Put key in new key hash table for index reference\n new_ref[i].append(key)\n\n # Put value in hash map\n new_table[i].append(value)\n\n # Overwrite old hash map with new hash map\n self.table = new_table.copy()\n\n # Overwrite old key hash table with new key hash table\n self.keys_ref = new_ref.copy()","def resize_table(self, capacity):\r\n\t\t# make a new HashMap with the desired capacity\r\n\t\tnew_map = HashMap(capacity, self._hash_function)\r\n\r\n\t\t# for each linked list in the map, rehash and add to new_map\r\n\t\tfor i in self._buckets:\r\n\t\t\tcur_node = i.head\r\n\t\t\twhile cur_node is not None:\r\n\t\t\t\tindex = self._hash_function(cur_node.key) % capacity # get the new index for the key\r\n\t\t\t\tnew_map._buckets[index].add_front(cur_node.key, cur_node.value) # add the key-value pair to the new map\r\n\t\t\t\tcur_node = cur_node.next # move to the next node in the linked list\r\n\t\tself._buckets = new_map._buckets # reassign self._buckets to the new_map\r\n\t\tself.capacity = capacity","def resize_table(self, capacity):\n\n temp = HashMap(capacity, self._hash_function) # Temporary hash map to store new values\n\n for index in range(self.capacity):\n if self._buckets[index].head is not None:\n node = self._buckets[index].head\n while node is not None:\n temp.put(node.key, node.value) # Iterate over the values and re-hash them into the temp table\n node = node.next\n\n self._buckets = temp._buckets # Update the hash map to use the new buckets\n self.capacity = capacity","def resize(self) -> None:\n\n size: int = 2 * self.table_size + 1\n if size > self.primes_table[len(self.primes_table) - 1]:\n self.primes_table = self.primes_below_n(10 * size)\n size: int = self.primes_table[bisect_left(self.primes_table, size)]\n\n # rehash all entries of the hash table after the increase in table size\n temp: List[(T, T)] = self.table\n self.table_size = size\n self.table = [None] * self.table_size\n self.filled_count = 0\n\n for pair in temp:\n if pair is not None:\n self[pair[0]] = pair[1]","def resize_table(self, capacity):\n old_buckets = self._buckets # save current buckets with variable\n\n self._buckets = [] # initialize new empty buckets\n self.capacity = capacity\n for i in range(capacity):\n self._buckets.append(LinkedList())\n self.size = 0\n\n for bucket in old_buckets: # loops through old hashmap and adds key/value pairs to new hashmap\n if bucket.size == 0:\n pass\n else:\n while bucket.head is not None:\n self.put(bucket.head.key, bucket.head.value)\n bucket.remove(bucket.head.key)","def rehash(self):\n primes = [3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, 631, 761,\n 919, 1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591,\n 17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363, 156437,\n 187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403, 968897, 1162687, 1395263,\n 1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559, 5999471, 7199369]\n\n temp_list = []\n for i in self.array:\n if i is not None:\n temp_list.append(i)\n\n self.table_capacity = 2 * self.table_capacity\n\n\n try:\n for i in range(len(primes)):\n if primes[i] > self.table_capacity:\n self.table_capacity = primes[i]\n break\n elif i == (len(primes) -1) :\n if not primes[i] > self.table_capacity:\n raise ValueError(\"There is no prime in the list such that prime > \" + self.table_capacity)\n except Exception as error:\n print(error)\n\n self.array = [None] * self.table_capacity\n self.count = 0\n for element in temp_list:\n self.insert(element[0], element[1])\n\n self.rehash_count += 1","def resize(self, new_capacity):\n # Your code here\n self.capacity = new_capacity\n\n # make new array to store the current self.hash_table\n # update self.hash_table to be array of size new_capacity\n # for each item in our copy array\n # self.put(item) in our newly size self.hash_table\n # if item.next is not None\n # make sure to self.put(item.next) to get all chained nodes\n\n old_storage = self.hash_table\n self.hash_table = [None] * new_capacity\n\n for i, el in enumerate(old_storage):\n if el is not None:\n self.put(el.key, el.value)\n\n curr_node = el\n\n if curr_node is not None:\n # add all chained nodes\n while curr_node.next is not None:\n curr_node = curr_node.next\n if curr_node is not None:\n self.put(curr_node.key, curr_node.value)","def grow(self):\n self.capacity = self.capacity * 2\n self.rehash()","def _increase_size(self) -> None:\n keys_vals_to_move = [item for item in self.HashMap if item]\n self.length = 0\n self.capacity = self.capacity * 2\n self.HashMap = [None] * self.capacity\n for item in keys_vals_to_move:\n while len(item) > 0:\n self.add(item[0], item[1])\n item.pop(0)\n item.pop(0)","def rehash(self, new_len):\n print(\"!!!!!!!!!Rehash\")\n oldtable = self.table\n self.table = [set() for x in range(new_len)]\n for numberset in oldtable:\n for number in numberset:\n self.insert(number)\n\n print(\"Rehash-table-print\")\n print(self.table)","def resize(self, new_capacity):\n # Your code here \n self.capacity= new_capacity\n new_data= [LinkedList()]* new_capacity \n \n # resizing of storage needed if loadfactor >0.7 or <0.2\n if self.get_load_factor() > 0.7: \n #iterate through all the items in the orginal data\n for i in self.data:\n cur = i.head\n while cur: \n # rehash the key/value pairs of data with new_capacity and get the new index\n \n index = self.hash_index(cur.key)\n\n # now add all the items to the new list\n if new_data[index].head is None:\n #make new node the head\n new_data[index].head= HashTableEntry(cur.key, cur.value)\n else:\n new_node = HashTableEntry(cur.key, cur.value)\n print(\"Keys\",cur.key) \n print(\"Values\",cur.value)\n # add new_node to the head and shift the head pointers \n new_node.next = new_data[index].head\n new_data[index].head = new_node\n # repeat till all the nodes have been added to new storage \n cur = cur.next \n # Once all the nodes have been added to new_data: self.data== new_data\n self.data= new_data","def __setitem__(self, k, v):\n j = self._hash_function(k)\n self._bucket_setitem(j, k, v)\n if self._n > len(self._table) // 2:\n self._resize(2 * len(self._table) -1)","def get_num_slots(self):\n Return the load factor for this hash table.\n\n Implement this.\n \"\"\"\n return self.elements / self.capacity\n\n\n def fnv1(self, key):\n \"\"\"\n FNV-1 Hash, 64-bit\n\n Implement this, and/or DJB2.pyy\n \"\"\"\n\n # Your code here\n\n\n def djb2(self, key):\n \"\"\"\n DJB2 hash, 32-bit\n\n Implement this, and/or FNV-1.\n \"\"\"\n # Your code here\n\n\n def hash_index(self, key):\n \"\"\"\n Take an arbitrary key and return a valid integer index\n between within the storage capacity of the hash table.\n \"\"\"\n #return self.fnv1(key) % self.capacity\n<<<<<<< Updated upstream\n return self.djb2(key) % self.capacity\n=======\n return self.djb2(key) % len(self.storage)\n>>>>>>> Stashed changes\n\n def put(self, key, value):\n \"\"\"\n Store the value with the given key.\n\n Hash collisions should be handled with Linked List Chaining.\n\n Implement this.\n \"\"\"\n<<<<<<< Updated upstream\n # Your code here\n=======\n # need to account for if the key value is the same \n\n i = self.hash_index(key)\n if not self.storage[i]:\n hte = HashTableEntry(key, value)\n self.storage[i] = hte\n self.elements += 1\n hte.head = HashTableEntry(key, value)\n elif self.storage[i] and self.storage[i].key != key:\n self.storage[i].insert_at_head(HashTableEntry(key, value))\n>>>>>>> Stashed changes\n\n\n def delete(self, key):\n \"\"\"\n Remove the value stored with the given key.\n\n Print a warning if the key is not found.\n\n Implement this.\n \"\"\"\n<<<<<<< Updated upstream\n # Your code here\n=======\n i = self.hash_index(key)\n node = self.storage[i]\n prev = None\n if node.key == key:\n self.storage[i] = node.next\n return\n while node != None:\n if node.key == key:\n prev.next = node.next\n self.storage[i].next = None\n return\n prev = node\n node = node.next\n self.elements -= 1\n return\n>>>>>>> Stashed changes\n\n\n def get(self, key):\n \"\"\"\n Retrieve the value stored with the given key.\n\n Returns None if the key is not found.\n\n Implement this.\n \"\"\"\n<<<<<<< Updated upstream\n # Your code here\n=======\n # - find the index in the hash table for the key\n i = self.hash_index(key)\n # - search the list for that key\n if not self.storage[i]:\n return None\n else:\n if self.storage[i].find_key(key) == key:\n return self.storage[i].value\n>>>>>>> Stashed changes\n\n\n def resize(self, new_capacity):\n \"\"\"\n Changes the capacity of the hash table and\n rehashes all key/value pairs.\n\n Implement this.\n \"\"\"\n<<<<<<< Updated upstream\n # Your code here\n=======\n prev_storage = self.storage\n self.capacity = new_cap\n self.storage = [None] * new_cap\n for i in range(len(prev_storage)):\n prev = prev_storage[i]\n if prev:\n while prev:\n if prev.key:\n self.put(prev.key, prev.value)\n prev = prev.next\n\n>>>>>>> Stashed changes\n\n\n\nif __name__ == \"__main__\":\n ht = HashTable(8)\n\n ht.put(\"line_1\", \"'Twas brillig, and the slithy toves\")\n ht.put(\"line_2\", \"Did gyre and gimble in the wabe:\")\n ht.put(\"line_3\", \"All mimsy were the borogoves,\")\n ht.put(\"line_4\", \"And the mome raths outgrabe.\")\n ht.put(\"line_5\", '\"Beware the Jabberwock, my son!')\n ht.put(\"line_6\", \"The jaws that bite, the claws that catch!\")\n ht.put(\"line_7\", \"Beware the Jubjub bird, and shun\")\n ht.put(\"line_8\", 'The frumious Bandersnatch!\"')\n ht.put(\"line_9\", \"He took his vorpal sword in hand;\")\n ht.put(\"line_10\", \"Long time the manxome foe he sought--\")\n ht.put(\"line_11\", \"So rested he by the Tumtum tree\")\n ht.put(\"line_12\", \"And stood awhile in thought.\")\n\n print(\"\")\n\n # Test storing beyond capacity\n for i in range(1, 13):\n print(ht.get(f\"line_{i}\"))\n\n # Test resizing\n old_capacity = ht.get_num_slots()\n ht.resize(ht.capacity * 2)\n new_capacity = ht.get_num_slots()\n\n print(f\"\\nResized from {old_capacity} to {new_capacity}.\\n\")\n\n # Test if data intact after resizing\n for i in range(1, 13):\n print(ht.get(f\"line_{i}\"))\n\n print(\"\")","def resize(self):\n load_factor = self._get_load_factor()\n if load_factor < 0.2:\n self.capacity //= 2\n elif load_factor > 0.7:\n self.capacity *= 2\n else:\n print(f'Resizing unnecessary due to a load factor of {load_factor}:.2f')\n return\n temp_storage = [None] * self.capacity\n for i in range(len(self.storage)):\n node = self.storage[i]\n while node is not None:\n index = self._hash_mod(node.key)\n node_to_add = temp_storage[index]\n if node_to_add is None:\n temp_storage[index] = LinkedPair(node.key, node.value)\n else:\n while node_to_add is not None:\n if node_to_add.next is None:\n node_to_add.next = LinkedPair(node.key, node.value)\n break\n node_to_add = node_to_add.next\n node = node.next\n self.storage = temp_storage","def _rehash(self, hashKey, integer):\n return ( hashKey + integer * integer ) % self.size","def _resize(self, c):\n old = list(self.items())\n self._table = [None] * c\n self._n = 0\n for (k, v) in old:\n self[k] = v","def _double_hashing(self, key: int, slots: List[int] = None) -> int:\n if not slots:\n slots = self.slots\n\n hash_idx = self._hash_func(key)\n while slots[hash_idx] is not None:\n hash_idx = self._hash_func(5 * hash_idx + 1)\n\n return hash_idx","def _resize(self, minused):\n newsize = self.size\n # Find the smalled value for newsize.\n while newsize <= minused and newsize > 0:\n newsize <<= 1\n newsize += 1\n oldtable = self.table\n # Create a new table newsize long.\n newtable = []\n while len(newtable) < newsize:\n newtable.append(Entry())\n # Replace the old table.\n self.table = newtable\n self.used = 0\n self.filled = 0\n # Copy the old data into the new table.\n for entry in oldtable:\n if entry.value is not None:\n self._insert_into_clean(entry)\n elif entry.key is dummy:\n entry.key = None\n self.size = newsize","def update(self, key: T, value: T) -> None:\n\n if self.load_factor >= self.resize_threshold:\n self.resize() # increase table size once threshold is reached\n\n idx: int = self.hash_fn(key) # get an index location for 'key'\n if self.table[idx] is None: # idx location not occupied\n self.table[idx] = (key, value)\n self.filled_count += 1\n else: # idx location occupied\n if self.table[idx][0] == key: # trying to insert to the same key\n self.table[idx] = (self.table[idx][0], value) # update 'value' at 'key'\n else:\n # probe for next free position using double hashing\n idx2: int = self.h2(key)\n i: int = 1\n while self.table[(idx + i * idx2) % self.table_size] is not None:\n i += 1\n self.table[(idx + i * idx2) % self.table_size] = (key, value) # insert at an unoccupied location\n self.filled_count += 1","def __init__(self):\n self.size = 1000\n self.hash_table = [None] * self.size","def hash_double(d):\n # initialize table\n table = [\"-\"] * 19\n # consider each integer k in the input\n for k in d:\n # if k is already in the table this is a duplicate so move to next integer in the input\n # note this check for a duplicate is using the functionality of python rather than checking using a linear probe\n if k in table:\n continue\n # apply the hash function\n i = (6 * k + 3) % 19\n t = i\n # initialize count that checks whether linear probe has considered each bucket and is now full\n count = 0\n j = 0\n # while bucket is already filled\n s = 11 - (k % 11)\n while table[i] != '-':\n j += 1\n # move to next bucket\n i = (t + j*s) % 19\n # increment count\n count += 1\n\n # if table is full\n if count >= 18:\n # can return table as nothing further can be added\n break\n\n # Ensure table[i] is empty so k can be added here\n if table[i] == '-':\n table[i] = k\n\n # now each part of the input has been considered return the table\n return table","def _hash_mod(self, key):\n return self._hash(key) % self.capacity","def insert(self, key, value):\r\n hash_val = Hash(key, value)\r\n self.hash_table[self.horner_hash(key)] = hash_val\r\n self.num_items += 1\r\n\r\n if self.get_load_factor() > 0.5:\r\n prev = HashTable(self.table_size)\r\n prev.num_items = self.num_items\r\n prev.hash_table = self.hash_table\r\n prev.table_size = self.table_size\r\n\r\n self.table_size = self.table_size * 2 + 1\r\n self.num_items = 0\r\n self.hash_table = [None] * self.table_size\r\n\r\n for i in range(prev.table_size):\r\n if prev.hash_table[i] is not None:\r\n self.insert(prev.hash_table[i].key, prev.hash_table[i].value)","def hash(self, key):\n\n return hash(key) % len(self.table)","def __setitem__(self, key, value):\n\n # Get hashed key\n i = self.hash(key)\n\n # If key not already in hash map\n if key not in self.keys_set:\n\n # Increment size\n self.size += 1\n\n # Add key to set of keys for reference\n self.keys_set.add(key)\n\n # Append key location to keys reference hash table\n self.keys_ref[i].append(key)\n\n # Apped value to hash map chain\n self.table[i].append(value)\n\n # If key already in hash map\n else:\n\n # Get key index for hash map chain\n chain_idx = self.keys_ref[i].index(key)\n\n # Overwrite value in hash map\n self.table[i][chain_idx] = value\n\n # If load greater than maximum load factor\n if self.load() >= self.max_load_factor:\n\n # Call resize for hash map\n self.resize()","def double_hashing(hash, hash2, A, x):\n i = 0\n s = len(A)\n while A[getRemainder((hash(x) + i*hash2(x)), s)] is not None:\n i = i + 1\n index = getRemainder((hash(x) + i*hash2(x)), s)\n print(f'Double Hashing index is: {index}')\n A[index] = x\n print(f'insertion of {x}: {A}')","def hash(self, key):\n return self._hash_function(key) % self.size # Modular hashing","def put(self, key, value):\n # Your code here\n index = self.hash_index(key)\n # check for linkedlist if it is empty\n if self.data[index].head == None:\n self.data[index].head = HashTableEntry(key, value) # similar to node class we used before\n self.count +=1\n # #-----\n # self.loadfactor = self.count / self.capacity\n # if self.loadfactor > 0.7:\n # self.resize(self.capacity * 2)\n \n else:\n # Linklist is not empty \n # create reference for the head node\n cur= self.data[index].head\n\n while cur.next:\n # checking if the key already exist then we will just override the value\n if cur.key == key:\n cur.value == value\n # checking each node of the Linkedlist till we break the while loop \n cur= cur.next\n # if key is not found, add the new hashtableentry(key, value) to the linkedlist\n cur.next = HashTableEntry(key, value)\n self.count +=1","def rehash(self, key) -> int:\n return (key + 1) % self.size","def _shrink(self):\n self.capacity = round(self.capacity / self.factor)\n temp = [None] * self.capacity\n for i in range(self.capacity):\n temp[i] = self.store[i]\n self.store = temp","def shrink(self):\n old = self.data # keep track of existing list\n self.capacity = self.capacity // 2\n self.data = [None] * (self.capacity) # allocate list with new capacity\n walk = self.head\n for k in range(self.size): # only consider existing elements\n self.data[k] = old[walk] # intentionally shift indices\n walk = (1 + walk) % len(old) # use old size as modulus\n self.head = 0 # front has been realigned\n self.tail = self.size","def shrink(self):\r\n\r\n old = self._data\r\n self._capacity = self._capacity // 2\r\n self._data = [0] * self._capacity\r\n\r\n if len(old) >= 1:\r\n for i in range(self._size):\r\n\r\n self._data[i] = old[i]","def clear(self):\n\n self.size = 0\n\n self.table = [[]] * 100\n\n self.keys_set = set()\n\n self.keys_ref = [[]] * 100","def __init__(self):\n self.size = 10000\n self.hashmap = [None] * self.size","def __hash__(self):\n return hash(self._table)","def __delitem__(self, k):\n j = self._hash_function(k)\n self._bucket_delitem(j, k)\n self._n -= 1","def _insert_into_clean(self, entry):\n i = entry.hash\n new_entry = self.table[i]\n while new_entry.key is not None:\n i += self.second_hash(new_entry.key)\n new_entry = self.table[i]\n new_entry.key = entry.key\n new_entry.value = entry.value\n new_entry.hash = entry.hash\n self.used += 1\n self.filled += 1","def merge(self, ht):\n # All the items go into our table, offset by our current size\n # Check compatibility\n assert self.maxtimebits == ht.maxtimebits\n ncurrent = len(self.names)\n # size = len(self.counts)\n self.names += ht.names\n self.hashesperid = np.append(self.hashesperid, ht.hashesperid)\n # Shift all the IDs in the second table down by ncurrent\n idoffset = (1 << self.maxtimebits) * ncurrent\n for hash_ in np.nonzero(ht.counts)[0]:\n allvals = np.r_[self.table[hash_, :self.counts[hash_]],\n ht.table[hash_, :ht.counts[hash_]] + idoffset]\n # ht.counts[hash_] may be more than the actual number of\n # hashes we obtained, if ht.counts[hash_] > ht.depth.\n # Subselect based on actual size.\n if len(allvals) > self.depth:\n # Our hash bin is filled: randomly subselect the\n # hashes, and update count to accurately track the\n # total number of hashes we've seen for this bin.\n somevals = np.random.permutation(allvals)[:self.depth]\n self.table[hash_,] = somevals\n self.counts[hash_] += ht.counts[hash_]\n else:\n # Our bin isn't full. Store all the hashes, and\n # accurately track how many values it contains. This\n # may mean some of the hashes counted for full buckets\n # in ht are \"forgotten\" if ht.depth < self.depth.\n self.table[hash_, :len(allvals)] = allvals\n self.counts[hash_] = len(allvals)\n\n self.dirty = True","def __init__(self, capacity):\n self.capacity = capacity # Number of buckets in the hash table\n self.storage = [None] * capacity\n self.key_count = 0","def delete(self, key):\n if not self.__contains__(key):\n raise KeyError(\"Error: Key \" + key + \" does not exist!\") # Rethrow exception for documentation purposes\n\n hashed_idx = self._linear_probe(key, 'delete')\n # Clear the spot\n self.keys[hashed_idx] = None\n self.values[hashed_idx] = None\n # Rehash all keys in the same cluster\n start_rehash = (hashed_idx + 1) % self.size\n i = start_rehash\n while self.keys[i] is not None:\n # Save key and value to rehash\n key_to_rehash = self.keys[i]\n val_to_rehash = self.values[i]\n # Clear the spots and re-insert\n self.keys[i] = None\n self.values[i] = None\n self.count -= 1 # decrement count\n self[key_to_rehash] = val_to_rehash # Simply put() it back into the table\n i = (i + 1) % self.size\n\n self.count -= 1 # Remember to decrement count again","def _grow(self):\n self.capacity *= self.factor\n temp = [None] * self.capacity\n for i in range(self.size):\n temp[i] = self.store[i]\n self.store = temp","def __delitem__(self, key):\n\n # If key is in hash map\n if self.__contains__(key):\n\n # Get hashed key\n i = self.hash(key)\n\n # Get chain index of key value pair\n chain_idx = self.keys_ref[i].index(key)\n\n # Delete value associated with key in hash map\n del self.table[i][chain_idx]\n\n # Delete key from hash table\n del self.keys_ref[i][chain_idx]\n\n # Remove key from set of keys\n self.keys_set.remove(key)\n\n # Decrement size\n self.size -= 1\n\n # If key not in hash map\n else:\n\n # Raise error\n raise KeyError(key)","def shrink(self):\r\n # Shrink the size by half but not below the default capacity\r\n # and remove those garbage cells from the underlying list\r\n newSize = max(self._capacity, len(self) // 2)\r\n for count in range(len(self) - newSize):\r\n self._items.pop()","def clear(self):\r\n\t\t# re-initialize self._buckets\r\n\t\tself._buckets = []\r\n\t\tself.size = 0\r\n\t\tfor i in range(self.capacity):\r\n\t\t\tself._buckets.append(LinkedList())","def _hash(self, hashKey):\n return hashKey % self.size","def __delitem__(self, key):\n i, kv_pair = self._lookup(key, self._backing)\n if kv_pair and not kv_pair.value is Hashmap.absent:\n self._backing[i] = KeyValue(key, Hashmap.absent)\n self._deleted += 1\n\n size = len(self._backing)\n utilization = (self._used - self._deleted)/size \n if utilization < 0.16:\n self._resize(self._decr_size(size))\n else:\n raise KeyError('no such item!')","def rehash_config(self):\n self._cache[\"config\"] = utilities.hash_object_sha256(self._get_config_raw())","def clear(self):\n if self.size == 0:\n return\n self.modCount += 1\n self.size = 0\n Arrays.fill(self.keys, None)\n Arrays.fill(self.values, None)","def _enforce_lru_size(self):\n\n # if a limit was defined and we have blown it\n if self._max_lru and len(self) > self._max_lru:\n # make sure in-memory dictionary doesn't get bigger\n for key in self._lru_list[self._max_lru:]:\n super(pyCacheBack, self).__delitem__(key)\n # also truncate the LRU list\n self._lru_list = self._lru_list[:self._max_lru]","def clear(self):\n\n for i in range(self.capacity):\n self._buckets[i].head = None # Empty out the LinkedList in each bucket\n self._buckets[i].size = 0\n self.size = 0","def __setitem__(self, key, value):\n i, kv_pair = self._lookup(key, self._backing)\n self._backing[i] = KeyValue(key, value)\n if kv_pair is None:\n self._used += 1\n \n size = len(self._backing)\n utilization = self._used/size\n if utilization > 0.67:\n self._resize(self._incr_size(size))","def _gethash(self, invalue) -> int:\n return hash(invalue) % self.capacity","def _bucket_setitem(self, j, k, v):\n if self._table[j] is None:\n self._table[j] = UnsortedTableMap() # create new bucket at index j\n oldSize = len(self._table[j])\n self._table[j][k] = v\n if len(self._table[j]) > oldSize: # key is new to the table\n self._n += 1","def put(self, key, value):\n hi = self.hash_index(key)\n if self.storage[hi]:\n current = self.storage[hi]\n while current.next and current.key != key:\n current = current.next\n\n if current.key == key:\n current.value = value\n else:\n current.next = HashTableEntry(key, value)\n self.numberOfItems += 1\n else:\n self.storage[hi] = HashTableEntry(key, value)\n self.numberOfItems += 1\n\n self.calculateLoad()","def hash(self, key):\n key = str(key)\n h = 0\n a = self.hash_base\n for i in range(len(str(key))):\n h = (h * a + ord(key[i])) % self.table_capacity\n return h","def grow(self):\r\n\r\n old = self._data\r\n self._capacity = 2 * self._capacity\r\n self._data = [0] * self._capacity\r\n\r\n for i in range(self._size):\r\n\r\n self._data[i] = old[i]","def put(self, key, value):\n while len(self.buckets) <= key:\n self.buckets = self.buckets + [-1] * len(self.buckets)\n self.length = self.length * 2\n self.buckets[key] = value","def put(self, key, value):\n hash_key = self._hash_function(key) % self.capacity # finds index for new key/value pair\n\n if self._buckets[hash_key].size == 0: # if bucket is empty, add new key/value pair\n self.size += 1\n self._buckets[hash_key].add_front(key, value)\n else:\n if self._buckets[hash_key].contains(key):\n self._buckets[hash_key].remove(key) # if key already exists, delete old key/value pair\n self.size -= 1\n self._buckets[hash_key].add_front(key, value) # add new key/value pair\n self.size += 1","def internal_hash(self): \n return hash(tuple(sorted(self.hashtriples())))","def refresh(self):\n node, ans = self.list_head.next.next, 0\n # first update key_nodes in even positions\n while node:\n ans += 1\n node = node.next.next\n # then update tree_nodes's current_btree_node in odd positions\n node = self.list_head.next\n while node:\n node.current_btree_node = self\n if node.next:\n node = node.next.next\n else:\n break\n self.size = ans","def dup_hash_state(self) -> None:\n assert len(self.hash_states) > 0\n self.hash_states.append(self.hash_states[-1].copy())","def insert(self, value):\n bucketNum = self.__hash(value)\n originalBucketNum = bucketNum\n if self.__buckets[bucketNum] is not None:\n bucketNum = self.__rehash(bucketNum)\n while self.__buckets[bucketNum] is not None and bucketNum != originalBucketNum:\n bucketNum = self.__rehash(bucketNum)\n if self.__buckets[bucketNum] is None:\n self.__buckets[bucketNum] = value\n else:\n raise Exception(\"Table Full\")","def clear(self):\n LongObjectHashMap.self.clear()","def clear(self):\n LongObjectHashMap.self.clear()","def remove(self, key):\n hash_key = key % self.key_space\n self.hash_table[hash_key].remove(key)","def remove(self):\n if LongObjectHashMap.self.modCount != self.expectedModCount:\n raise ConcurrentModificationException()\n if self.lastReturned == self.EMPTY_KEY:\n raise IllegalStateException()\n self.count -= 1\n LongObjectHashMap.self.remove(self.lastReturned)\n self.lastReturned = self.EMPTY_KEY\n self.expectedModCount = LongObjectHashMap.self.modCount","def clear(self):\n self.size = 0 # set size to 0 and reinitialize buckets as empty\n self._buckets = []","def update_hashes(self, ret=False) -> None:\n self.hash = self.calculate_hash()\n self.stub_hash = self.calculate_hash(include_md=False)","def put(self, key, value):\n # Your code here\n\n idx = self.hash_index(key)\n entry = HashTableEntry(key, value)\n match = None\n\n # if there's already something stored at this index\n if self.hash_table[idx] is not None:\n curr_node = self.hash_table[idx]\n\n # look for an existing entry with the same key\n while match is None:\n if curr_node.key == key:\n match = curr_node\n else:\n curr_node = curr_node.next\n \n # if we reached the tail and still haven't found an existing match, break out of the loop\n if curr_node is None:\n break\n\n # if we reached the end and didn't find an existing entry matching the provided key\n # add a new entry at the end\n if match is None and curr_node.next is None:\n curr_node.next = entry\n self.total_items+= 1\n self.determine_resize_type()\n\n # if an entry with the provided key already exists, just update its value with the provided value\n elif match is not None:\n match.value = value\n \n \n # if nothing exists as this index, just add the entry\n else:\n self.hash_table[idx] = entry\n self.total_items+= 1\n self.determine_resize_type()","def __init__(self, table_capacity=101, hash_base=31):\n\n self.table_capacity = table_capacity\n self.hash_base = hash_base\n self.array = [None] * self.table_capacity # Array initialized with 'None\" in each element.\n self.count = 0 # the number of items in the table, initially set to '0'\n self.rehash_count = 0\n self.probe_array = []","def reset(self):\n for k in self.data_keys:\n setattr(self, k, [])\n self.size = 0","def remove(self, key):\n if self.contains_key(key): # if key exists in hashmap, remove key/value pair\n hash_key = self._hash_function(key) % self.capacity\n bucket = self._buckets[hash_key]\n bucket.remove(key)","def __hash__(self):\r\n return hash(self.__key())","def reset() -> None:\n Stat._cache = SortedDict()","def hash(self, key):\n return hash(key) % len(self.array)","def _checklru(self):\n if len(self._dict)>self._maxsize:\n lru=self._head._next\n lru._previous._next=lru._next\n lru._next._previous=lru._previous\n del self._dict[lru._key]","def hash_index(self, key):\n #return self.fnv1(key) % self.capacity\n return self.djb2(key) % self.capacity","def grow(self):\n old = self.data # keep track of existing list\n self.capacity = self.capacity*2\n self.data = [None] * (self.capacity) # allocate list with new capacity\n walk = self.head\n for k in range(self.size): # only consider existing elements\n self.data[k] = old[walk] # intentionally shift indices\n walk = (1 + walk) % len(old) # use old size as modulus\n self.head = 0 # front has been realigned","def htable(nbuckets):","def hash(df, col, bucket_size):\n new_df = df[[c for c in df.columns if c != col]]\n new_df[col] = df[col].apply(lambda x: farmhash.fingerprint64(x) % bucket_size) \n return new_df","def __setitem__(self, key, value):\n if self.count == self.size: # For now, rehash only when full (better to keep it half empty always)\n self.rehash()\n\n hashed_idx = self._linear_probe(key, \"set\") # Get position to put. _probe() takes care of hashing the key\n if self.keys[hashed_idx] != key: # If _probe() returns a spot that doesn't have this key, then increment count\n self.count += 1\n self.keys[hashed_idx] = key # Store key in the keys array\n self.values[hashed_idx] = value # Store value in the values array","def removeall(self):\n\n # If there used to be a key, there must exist an old value blob somewhere in the database. It should be deallocated after a successful commit to disk.\n for key in self.keys:\n if self.keys[key] is not None:\n punchat,punchlen = self.keys[key]\n self.awaitingpunch.append((punchat, punchlen))\n \n self.keys = {}\n self.buffered = {}\n self.cache = {}\n \n if self.autocommit:\n commit()","def _reduce_rep(self):\n for k, v in self.items():\n if not k:\n self[k] = 0\n for per1, per2 in pairwise(k):\n if per1 == per2:\n self[k] = 0\n super()._reduce_rep()","def _hash(self, key):\n # OPTIONAL STRETCH: You may replace the Python hash with DJB2 as a stretch goal\n # return hash(key)\n return self._hash_djb2(key)","def clone(self):\n clone = super(LongObjectHashMap, self).clone()\n clone.clear()\n clone.initialize()\n for key in keySet():\n value = self.get(key)\n clone.put(key, value)\n return clone","def __init__(self):\n self.hashmap = [[] for _ in range(self._cap)]","def _hashed_items(self):\n return self","def hash_index(self, key):\n # return self.fnv1(key) % self.capacity\n return self.djb2(key) % self.capacity","def hash_index(self, key):\n # return self.fnv1(key) % self.capacity\n return self.djb2(key) % self.capacity","def test_remove_from_index_shared_hashes_partial(self):\n # Simulate initial state with some descriptor hashed to one value and\n # other descriptors hashed to another.\n\n descriptors = [\n DescriptorMemoryElement('t', 0),\n DescriptorMemoryElement('t', 1),\n DescriptorMemoryElement('t', 2),\n DescriptorMemoryElement('t', 3),\n DescriptorMemoryElement('t', 4),\n ]\n # Vectors of length 1 for easy dummy hashing prediction.\n for d in descriptors:\n d.set_vector(np.ones(1, float) * d.uuid())\n\n # Dummy hash function to do the simulated thing\n hash_func = DummyHashFunctor()\n hash_func.get_hash = mock.Mock(\n # Vectors of even sum hash to 0, odd to 1.\n side_effect=lambda vec: [vec.sum() % 2]\n )\n\n d_set = MemoryDescriptorIndex()\n d_set._table = {\n 0: descriptors[0],\n 1: descriptors[1],\n 2: descriptors[2],\n 3: descriptors[3],\n 4: descriptors[4],\n }\n\n hash2uid_kvs = MemoryKeyValueStore()\n hash2uid_kvs._table = {\n 0: {0, 2, 4},\n 1: {1, 3},\n }\n\n idx = LSHNearestNeighborIndex(hash_func, d_set, hash2uid_kvs)\n idx.hash_index = mock.Mock(spec=HashIndex)\n\n idx.remove_from_index([1, 2, 3])\n # Check that only one hash vector was passed to hash_index's removal\n # method (deque of hash-code vectors).\n idx.hash_index.remove_from_index.assert_called_once_with(\n collections.deque([\n [1],\n ])\n )\n self.assertDictEqual(d_set._table, {\n 0: descriptors[0],\n 4: descriptors[4],\n })\n self.assertDictEqual(hash2uid_kvs._table, {0: {0, 4}})","def __init__(self):\n self.size = 997\n self.hash_set = [None] * self.size","def dense_hash(hash_, block_size=16):\n results = list()\n for index in range(0, len(hash_), block_size):\n\n block = hash_[index:index + block_size]\n\n total = 0\n for i in block:\n total ^= i\n\n results.append(total)\n\n return results","def hashing(self, key):\n #return hash(key) % self.__size\n if type(key) == str:\n hashVal = 0\n for i, c in enumerate(key):\n hashVal += int(ord(c)) * 31 ** (len(key) -1 - i)\n return hashVal % self.__size\n return key % self.__size","def test_splittable_del(self):\n a, b = self.make_shared_key_dict(2)\n\n orig_size = sys.getsizeof(a)\n\n del a['y'] # split table is combined\n with self.assertRaises(KeyError):\n del a['y']\n\n self.assertEqual(list(a), ['x', 'z'])\n self.assertEqual(list(b), ['x', 'y', 'z'])\n\n # Two dicts have different insertion order.\n a['y'] = 42\n self.assertEqual(list(a), ['x', 'z', 'y'])\n self.assertEqual(list(b), ['x', 'y', 'z'])","def __hash__(self):\n return hash(self.hash)","def __init__(self):\n # better to be a prime number, less collision\n self.key_space = 2069\n self.hash_table = [Bucket() for i in range(self.key_space)]","def test_splittable_setdefault(self):\n a, b = self.make_shared_key_dict(2)\n\n a['a'] = 1\n size_a = sys.getsizeof(a)\n a['b'] = 2\n b.setdefault('b', 2)\n size_b = sys.getsizeof(b)\n b['a'] = 1\n\n self.assertEqual(list(a), ['x', 'y', 'z', 'a', 'b'])\n self.assertEqual(list(b), ['x', 'y', 'z', 'b', 'a'])","def _hash(self, item):\r\n pass # TODO\r"],"string":"[\n \"def rehash(self):\\n new_cap = self._get_new_capacity() # Choose not to handle the ValueError thrown by _get_new_capacity()\\n new_table = HashTable(new_cap) # Create a new hash table directly\\n for i in range(self.size):\\n if self.keys[i] is not None: # Only put() when there exists a key (no Nones)\\n new_table[self.keys[i]] = self.values[i] # Rehash and insert into the new table\\n\\n self.keys = new_table.keys # Update instance variables\\n self.values = new_table.values\\n self.size = new_cap # Update N\\n self.count_rehashes += 1 # Increment total rehashes\",\n \"def rehash(self):\\n old = list()\\n # use iteration to record existing items\\n for i in range(self.capacity // 2):\\n if self.table[i] is not None:\\n old.append(self.table[i])\\n self.table = self.capacity * [None] # then reset table to desired capacity\\n self.size = 0\\n for i in old:\\n index = self.quadratic_probe(i.key)\\n self.table[index] = i\\n self.size += 1\",\n \"def resize(self):\\n\\n # Stores the new size of the hash map\\n new_size = len(self.table) * 2 - 1\\n\\n # Creates new hash map table (empty)\\n new_table = [[]] * new_size\\n\\n # Creates new key hash table (empty)\\n new_ref = [[]] * new_size\\n\\n # For key value pair in the current hash map\\n for key, value in self:\\n\\n # Get new hashed key for new hash map\\n i = hash(key) % len(new_table)\\n\\n # Put key in new key hash table for index reference\\n new_ref[i].append(key)\\n\\n # Put value in hash map\\n new_table[i].append(value)\\n\\n # Overwrite old hash map with new hash map\\n self.table = new_table.copy()\\n\\n # Overwrite old key hash table with new key hash table\\n self.keys_ref = new_ref.copy()\",\n \"def resize_table(self, capacity):\\r\\n\\t\\t# make a new HashMap with the desired capacity\\r\\n\\t\\tnew_map = HashMap(capacity, self._hash_function)\\r\\n\\r\\n\\t\\t# for each linked list in the map, rehash and add to new_map\\r\\n\\t\\tfor i in self._buckets:\\r\\n\\t\\t\\tcur_node = i.head\\r\\n\\t\\t\\twhile cur_node is not None:\\r\\n\\t\\t\\t\\tindex = self._hash_function(cur_node.key) % capacity # get the new index for the key\\r\\n\\t\\t\\t\\tnew_map._buckets[index].add_front(cur_node.key, cur_node.value) # add the key-value pair to the new map\\r\\n\\t\\t\\t\\tcur_node = cur_node.next # move to the next node in the linked list\\r\\n\\t\\tself._buckets = new_map._buckets # reassign self._buckets to the new_map\\r\\n\\t\\tself.capacity = capacity\",\n \"def resize_table(self, capacity):\\n\\n temp = HashMap(capacity, self._hash_function) # Temporary hash map to store new values\\n\\n for index in range(self.capacity):\\n if self._buckets[index].head is not None:\\n node = self._buckets[index].head\\n while node is not None:\\n temp.put(node.key, node.value) # Iterate over the values and re-hash them into the temp table\\n node = node.next\\n\\n self._buckets = temp._buckets # Update the hash map to use the new buckets\\n self.capacity = capacity\",\n \"def resize(self) -> None:\\n\\n size: int = 2 * self.table_size + 1\\n if size > self.primes_table[len(self.primes_table) - 1]:\\n self.primes_table = self.primes_below_n(10 * size)\\n size: int = self.primes_table[bisect_left(self.primes_table, size)]\\n\\n # rehash all entries of the hash table after the increase in table size\\n temp: List[(T, T)] = self.table\\n self.table_size = size\\n self.table = [None] * self.table_size\\n self.filled_count = 0\\n\\n for pair in temp:\\n if pair is not None:\\n self[pair[0]] = pair[1]\",\n \"def resize_table(self, capacity):\\n old_buckets = self._buckets # save current buckets with variable\\n\\n self._buckets = [] # initialize new empty buckets\\n self.capacity = capacity\\n for i in range(capacity):\\n self._buckets.append(LinkedList())\\n self.size = 0\\n\\n for bucket in old_buckets: # loops through old hashmap and adds key/value pairs to new hashmap\\n if bucket.size == 0:\\n pass\\n else:\\n while bucket.head is not None:\\n self.put(bucket.head.key, bucket.head.value)\\n bucket.remove(bucket.head.key)\",\n \"def rehash(self):\\n primes = [3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, 631, 761,\\n 919, 1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591,\\n 17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363, 156437,\\n 187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403, 968897, 1162687, 1395263,\\n 1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559, 5999471, 7199369]\\n\\n temp_list = []\\n for i in self.array:\\n if i is not None:\\n temp_list.append(i)\\n\\n self.table_capacity = 2 * self.table_capacity\\n\\n\\n try:\\n for i in range(len(primes)):\\n if primes[i] > self.table_capacity:\\n self.table_capacity = primes[i]\\n break\\n elif i == (len(primes) -1) :\\n if not primes[i] > self.table_capacity:\\n raise ValueError(\\\"There is no prime in the list such that prime > \\\" + self.table_capacity)\\n except Exception as error:\\n print(error)\\n\\n self.array = [None] * self.table_capacity\\n self.count = 0\\n for element in temp_list:\\n self.insert(element[0], element[1])\\n\\n self.rehash_count += 1\",\n \"def resize(self, new_capacity):\\n # Your code here\\n self.capacity = new_capacity\\n\\n # make new array to store the current self.hash_table\\n # update self.hash_table to be array of size new_capacity\\n # for each item in our copy array\\n # self.put(item) in our newly size self.hash_table\\n # if item.next is not None\\n # make sure to self.put(item.next) to get all chained nodes\\n\\n old_storage = self.hash_table\\n self.hash_table = [None] * new_capacity\\n\\n for i, el in enumerate(old_storage):\\n if el is not None:\\n self.put(el.key, el.value)\\n\\n curr_node = el\\n\\n if curr_node is not None:\\n # add all chained nodes\\n while curr_node.next is not None:\\n curr_node = curr_node.next\\n if curr_node is not None:\\n self.put(curr_node.key, curr_node.value)\",\n \"def grow(self):\\n self.capacity = self.capacity * 2\\n self.rehash()\",\n \"def _increase_size(self) -> None:\\n keys_vals_to_move = [item for item in self.HashMap if item]\\n self.length = 0\\n self.capacity = self.capacity * 2\\n self.HashMap = [None] * self.capacity\\n for item in keys_vals_to_move:\\n while len(item) > 0:\\n self.add(item[0], item[1])\\n item.pop(0)\\n item.pop(0)\",\n \"def rehash(self, new_len):\\n print(\\\"!!!!!!!!!Rehash\\\")\\n oldtable = self.table\\n self.table = [set() for x in range(new_len)]\\n for numberset in oldtable:\\n for number in numberset:\\n self.insert(number)\\n\\n print(\\\"Rehash-table-print\\\")\\n print(self.table)\",\n \"def resize(self, new_capacity):\\n # Your code here \\n self.capacity= new_capacity\\n new_data= [LinkedList()]* new_capacity \\n \\n # resizing of storage needed if loadfactor >0.7 or <0.2\\n if self.get_load_factor() > 0.7: \\n #iterate through all the items in the orginal data\\n for i in self.data:\\n cur = i.head\\n while cur: \\n # rehash the key/value pairs of data with new_capacity and get the new index\\n \\n index = self.hash_index(cur.key)\\n\\n # now add all the items to the new list\\n if new_data[index].head is None:\\n #make new node the head\\n new_data[index].head= HashTableEntry(cur.key, cur.value)\\n else:\\n new_node = HashTableEntry(cur.key, cur.value)\\n print(\\\"Keys\\\",cur.key) \\n print(\\\"Values\\\",cur.value)\\n # add new_node to the head and shift the head pointers \\n new_node.next = new_data[index].head\\n new_data[index].head = new_node\\n # repeat till all the nodes have been added to new storage \\n cur = cur.next \\n # Once all the nodes have been added to new_data: self.data== new_data\\n self.data= new_data\",\n \"def __setitem__(self, k, v):\\n j = self._hash_function(k)\\n self._bucket_setitem(j, k, v)\\n if self._n > len(self._table) // 2:\\n self._resize(2 * len(self._table) -1)\",\n \"def get_num_slots(self):\\n Return the load factor for this hash table.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n return self.elements / self.capacity\\n\\n\\n def fnv1(self, key):\\n \\\"\\\"\\\"\\n FNV-1 Hash, 64-bit\\n\\n Implement this, and/or DJB2.pyy\\n \\\"\\\"\\\"\\n\\n # Your code here\\n\\n\\n def djb2(self, key):\\n \\\"\\\"\\\"\\n DJB2 hash, 32-bit\\n\\n Implement this, and/or FNV-1.\\n \\\"\\\"\\\"\\n # Your code here\\n\\n\\n def hash_index(self, key):\\n \\\"\\\"\\\"\\n Take an arbitrary key and return a valid integer index\\n between within the storage capacity of the hash table.\\n \\\"\\\"\\\"\\n #return self.fnv1(key) % self.capacity\\n<<<<<<< Updated upstream\\n return self.djb2(key) % self.capacity\\n=======\\n return self.djb2(key) % len(self.storage)\\n>>>>>>> Stashed changes\\n\\n def put(self, key, value):\\n \\\"\\\"\\\"\\n Store the value with the given key.\\n\\n Hash collisions should be handled with Linked List Chaining.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n<<<<<<< Updated upstream\\n # Your code here\\n=======\\n # need to account for if the key value is the same \\n\\n i = self.hash_index(key)\\n if not self.storage[i]:\\n hte = HashTableEntry(key, value)\\n self.storage[i] = hte\\n self.elements += 1\\n hte.head = HashTableEntry(key, value)\\n elif self.storage[i] and self.storage[i].key != key:\\n self.storage[i].insert_at_head(HashTableEntry(key, value))\\n>>>>>>> Stashed changes\\n\\n\\n def delete(self, key):\\n \\\"\\\"\\\"\\n Remove the value stored with the given key.\\n\\n Print a warning if the key is not found.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n<<<<<<< Updated upstream\\n # Your code here\\n=======\\n i = self.hash_index(key)\\n node = self.storage[i]\\n prev = None\\n if node.key == key:\\n self.storage[i] = node.next\\n return\\n while node != None:\\n if node.key == key:\\n prev.next = node.next\\n self.storage[i].next = None\\n return\\n prev = node\\n node = node.next\\n self.elements -= 1\\n return\\n>>>>>>> Stashed changes\\n\\n\\n def get(self, key):\\n \\\"\\\"\\\"\\n Retrieve the value stored with the given key.\\n\\n Returns None if the key is not found.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n<<<<<<< Updated upstream\\n # Your code here\\n=======\\n # - find the index in the hash table for the key\\n i = self.hash_index(key)\\n # - search the list for that key\\n if not self.storage[i]:\\n return None\\n else:\\n if self.storage[i].find_key(key) == key:\\n return self.storage[i].value\\n>>>>>>> Stashed changes\\n\\n\\n def resize(self, new_capacity):\\n \\\"\\\"\\\"\\n Changes the capacity of the hash table and\\n rehashes all key/value pairs.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n<<<<<<< Updated upstream\\n # Your code here\\n=======\\n prev_storage = self.storage\\n self.capacity = new_cap\\n self.storage = [None] * new_cap\\n for i in range(len(prev_storage)):\\n prev = prev_storage[i]\\n if prev:\\n while prev:\\n if prev.key:\\n self.put(prev.key, prev.value)\\n prev = prev.next\\n\\n>>>>>>> Stashed changes\\n\\n\\n\\nif __name__ == \\\"__main__\\\":\\n ht = HashTable(8)\\n\\n ht.put(\\\"line_1\\\", \\\"'Twas brillig, and the slithy toves\\\")\\n ht.put(\\\"line_2\\\", \\\"Did gyre and gimble in the wabe:\\\")\\n ht.put(\\\"line_3\\\", \\\"All mimsy were the borogoves,\\\")\\n ht.put(\\\"line_4\\\", \\\"And the mome raths outgrabe.\\\")\\n ht.put(\\\"line_5\\\", '\\\"Beware the Jabberwock, my son!')\\n ht.put(\\\"line_6\\\", \\\"The jaws that bite, the claws that catch!\\\")\\n ht.put(\\\"line_7\\\", \\\"Beware the Jubjub bird, and shun\\\")\\n ht.put(\\\"line_8\\\", 'The frumious Bandersnatch!\\\"')\\n ht.put(\\\"line_9\\\", \\\"He took his vorpal sword in hand;\\\")\\n ht.put(\\\"line_10\\\", \\\"Long time the manxome foe he sought--\\\")\\n ht.put(\\\"line_11\\\", \\\"So rested he by the Tumtum tree\\\")\\n ht.put(\\\"line_12\\\", \\\"And stood awhile in thought.\\\")\\n\\n print(\\\"\\\")\\n\\n # Test storing beyond capacity\\n for i in range(1, 13):\\n print(ht.get(f\\\"line_{i}\\\"))\\n\\n # Test resizing\\n old_capacity = ht.get_num_slots()\\n ht.resize(ht.capacity * 2)\\n new_capacity = ht.get_num_slots()\\n\\n print(f\\\"\\\\nResized from {old_capacity} to {new_capacity}.\\\\n\\\")\\n\\n # Test if data intact after resizing\\n for i in range(1, 13):\\n print(ht.get(f\\\"line_{i}\\\"))\\n\\n print(\\\"\\\")\",\n \"def resize(self):\\n load_factor = self._get_load_factor()\\n if load_factor < 0.2:\\n self.capacity //= 2\\n elif load_factor > 0.7:\\n self.capacity *= 2\\n else:\\n print(f'Resizing unnecessary due to a load factor of {load_factor}:.2f')\\n return\\n temp_storage = [None] * self.capacity\\n for i in range(len(self.storage)):\\n node = self.storage[i]\\n while node is not None:\\n index = self._hash_mod(node.key)\\n node_to_add = temp_storage[index]\\n if node_to_add is None:\\n temp_storage[index] = LinkedPair(node.key, node.value)\\n else:\\n while node_to_add is not None:\\n if node_to_add.next is None:\\n node_to_add.next = LinkedPair(node.key, node.value)\\n break\\n node_to_add = node_to_add.next\\n node = node.next\\n self.storage = temp_storage\",\n \"def _rehash(self, hashKey, integer):\\n return ( hashKey + integer * integer ) % self.size\",\n \"def _resize(self, c):\\n old = list(self.items())\\n self._table = [None] * c\\n self._n = 0\\n for (k, v) in old:\\n self[k] = v\",\n \"def _double_hashing(self, key: int, slots: List[int] = None) -> int:\\n if not slots:\\n slots = self.slots\\n\\n hash_idx = self._hash_func(key)\\n while slots[hash_idx] is not None:\\n hash_idx = self._hash_func(5 * hash_idx + 1)\\n\\n return hash_idx\",\n \"def _resize(self, minused):\\n newsize = self.size\\n # Find the smalled value for newsize.\\n while newsize <= minused and newsize > 0:\\n newsize <<= 1\\n newsize += 1\\n oldtable = self.table\\n # Create a new table newsize long.\\n newtable = []\\n while len(newtable) < newsize:\\n newtable.append(Entry())\\n # Replace the old table.\\n self.table = newtable\\n self.used = 0\\n self.filled = 0\\n # Copy the old data into the new table.\\n for entry in oldtable:\\n if entry.value is not None:\\n self._insert_into_clean(entry)\\n elif entry.key is dummy:\\n entry.key = None\\n self.size = newsize\",\n \"def update(self, key: T, value: T) -> None:\\n\\n if self.load_factor >= self.resize_threshold:\\n self.resize() # increase table size once threshold is reached\\n\\n idx: int = self.hash_fn(key) # get an index location for 'key'\\n if self.table[idx] is None: # idx location not occupied\\n self.table[idx] = (key, value)\\n self.filled_count += 1\\n else: # idx location occupied\\n if self.table[idx][0] == key: # trying to insert to the same key\\n self.table[idx] = (self.table[idx][0], value) # update 'value' at 'key'\\n else:\\n # probe for next free position using double hashing\\n idx2: int = self.h2(key)\\n i: int = 1\\n while self.table[(idx + i * idx2) % self.table_size] is not None:\\n i += 1\\n self.table[(idx + i * idx2) % self.table_size] = (key, value) # insert at an unoccupied location\\n self.filled_count += 1\",\n \"def __init__(self):\\n self.size = 1000\\n self.hash_table = [None] * self.size\",\n \"def hash_double(d):\\n # initialize table\\n table = [\\\"-\\\"] * 19\\n # consider each integer k in the input\\n for k in d:\\n # if k is already in the table this is a duplicate so move to next integer in the input\\n # note this check for a duplicate is using the functionality of python rather than checking using a linear probe\\n if k in table:\\n continue\\n # apply the hash function\\n i = (6 * k + 3) % 19\\n t = i\\n # initialize count that checks whether linear probe has considered each bucket and is now full\\n count = 0\\n j = 0\\n # while bucket is already filled\\n s = 11 - (k % 11)\\n while table[i] != '-':\\n j += 1\\n # move to next bucket\\n i = (t + j*s) % 19\\n # increment count\\n count += 1\\n\\n # if table is full\\n if count >= 18:\\n # can return table as nothing further can be added\\n break\\n\\n # Ensure table[i] is empty so k can be added here\\n if table[i] == '-':\\n table[i] = k\\n\\n # now each part of the input has been considered return the table\\n return table\",\n \"def _hash_mod(self, key):\\n return self._hash(key) % self.capacity\",\n \"def insert(self, key, value):\\r\\n hash_val = Hash(key, value)\\r\\n self.hash_table[self.horner_hash(key)] = hash_val\\r\\n self.num_items += 1\\r\\n\\r\\n if self.get_load_factor() > 0.5:\\r\\n prev = HashTable(self.table_size)\\r\\n prev.num_items = self.num_items\\r\\n prev.hash_table = self.hash_table\\r\\n prev.table_size = self.table_size\\r\\n\\r\\n self.table_size = self.table_size * 2 + 1\\r\\n self.num_items = 0\\r\\n self.hash_table = [None] * self.table_size\\r\\n\\r\\n for i in range(prev.table_size):\\r\\n if prev.hash_table[i] is not None:\\r\\n self.insert(prev.hash_table[i].key, prev.hash_table[i].value)\",\n \"def hash(self, key):\\n\\n return hash(key) % len(self.table)\",\n \"def __setitem__(self, key, value):\\n\\n # Get hashed key\\n i = self.hash(key)\\n\\n # If key not already in hash map\\n if key not in self.keys_set:\\n\\n # Increment size\\n self.size += 1\\n\\n # Add key to set of keys for reference\\n self.keys_set.add(key)\\n\\n # Append key location to keys reference hash table\\n self.keys_ref[i].append(key)\\n\\n # Apped value to hash map chain\\n self.table[i].append(value)\\n\\n # If key already in hash map\\n else:\\n\\n # Get key index for hash map chain\\n chain_idx = self.keys_ref[i].index(key)\\n\\n # Overwrite value in hash map\\n self.table[i][chain_idx] = value\\n\\n # If load greater than maximum load factor\\n if self.load() >= self.max_load_factor:\\n\\n # Call resize for hash map\\n self.resize()\",\n \"def double_hashing(hash, hash2, A, x):\\n i = 0\\n s = len(A)\\n while A[getRemainder((hash(x) + i*hash2(x)), s)] is not None:\\n i = i + 1\\n index = getRemainder((hash(x) + i*hash2(x)), s)\\n print(f'Double Hashing index is: {index}')\\n A[index] = x\\n print(f'insertion of {x}: {A}')\",\n \"def hash(self, key):\\n return self._hash_function(key) % self.size # Modular hashing\",\n \"def put(self, key, value):\\n # Your code here\\n index = self.hash_index(key)\\n # check for linkedlist if it is empty\\n if self.data[index].head == None:\\n self.data[index].head = HashTableEntry(key, value) # similar to node class we used before\\n self.count +=1\\n # #-----\\n # self.loadfactor = self.count / self.capacity\\n # if self.loadfactor > 0.7:\\n # self.resize(self.capacity * 2)\\n \\n else:\\n # Linklist is not empty \\n # create reference for the head node\\n cur= self.data[index].head\\n\\n while cur.next:\\n # checking if the key already exist then we will just override the value\\n if cur.key == key:\\n cur.value == value\\n # checking each node of the Linkedlist till we break the while loop \\n cur= cur.next\\n # if key is not found, add the new hashtableentry(key, value) to the linkedlist\\n cur.next = HashTableEntry(key, value)\\n self.count +=1\",\n \"def rehash(self, key) -> int:\\n return (key + 1) % self.size\",\n \"def _shrink(self):\\n self.capacity = round(self.capacity / self.factor)\\n temp = [None] * self.capacity\\n for i in range(self.capacity):\\n temp[i] = self.store[i]\\n self.store = temp\",\n \"def shrink(self):\\n old = self.data # keep track of existing list\\n self.capacity = self.capacity // 2\\n self.data = [None] * (self.capacity) # allocate list with new capacity\\n walk = self.head\\n for k in range(self.size): # only consider existing elements\\n self.data[k] = old[walk] # intentionally shift indices\\n walk = (1 + walk) % len(old) # use old size as modulus\\n self.head = 0 # front has been realigned\\n self.tail = self.size\",\n \"def shrink(self):\\r\\n\\r\\n old = self._data\\r\\n self._capacity = self._capacity // 2\\r\\n self._data = [0] * self._capacity\\r\\n\\r\\n if len(old) >= 1:\\r\\n for i in range(self._size):\\r\\n\\r\\n self._data[i] = old[i]\",\n \"def clear(self):\\n\\n self.size = 0\\n\\n self.table = [[]] * 100\\n\\n self.keys_set = set()\\n\\n self.keys_ref = [[]] * 100\",\n \"def __init__(self):\\n self.size = 10000\\n self.hashmap = [None] * self.size\",\n \"def __hash__(self):\\n return hash(self._table)\",\n \"def __delitem__(self, k):\\n j = self._hash_function(k)\\n self._bucket_delitem(j, k)\\n self._n -= 1\",\n \"def _insert_into_clean(self, entry):\\n i = entry.hash\\n new_entry = self.table[i]\\n while new_entry.key is not None:\\n i += self.second_hash(new_entry.key)\\n new_entry = self.table[i]\\n new_entry.key = entry.key\\n new_entry.value = entry.value\\n new_entry.hash = entry.hash\\n self.used += 1\\n self.filled += 1\",\n \"def merge(self, ht):\\n # All the items go into our table, offset by our current size\\n # Check compatibility\\n assert self.maxtimebits == ht.maxtimebits\\n ncurrent = len(self.names)\\n # size = len(self.counts)\\n self.names += ht.names\\n self.hashesperid = np.append(self.hashesperid, ht.hashesperid)\\n # Shift all the IDs in the second table down by ncurrent\\n idoffset = (1 << self.maxtimebits) * ncurrent\\n for hash_ in np.nonzero(ht.counts)[0]:\\n allvals = np.r_[self.table[hash_, :self.counts[hash_]],\\n ht.table[hash_, :ht.counts[hash_]] + idoffset]\\n # ht.counts[hash_] may be more than the actual number of\\n # hashes we obtained, if ht.counts[hash_] > ht.depth.\\n # Subselect based on actual size.\\n if len(allvals) > self.depth:\\n # Our hash bin is filled: randomly subselect the\\n # hashes, and update count to accurately track the\\n # total number of hashes we've seen for this bin.\\n somevals = np.random.permutation(allvals)[:self.depth]\\n self.table[hash_,] = somevals\\n self.counts[hash_] += ht.counts[hash_]\\n else:\\n # Our bin isn't full. Store all the hashes, and\\n # accurately track how many values it contains. This\\n # may mean some of the hashes counted for full buckets\\n # in ht are \\\"forgotten\\\" if ht.depth < self.depth.\\n self.table[hash_, :len(allvals)] = allvals\\n self.counts[hash_] = len(allvals)\\n\\n self.dirty = True\",\n \"def __init__(self, capacity):\\n self.capacity = capacity # Number of buckets in the hash table\\n self.storage = [None] * capacity\\n self.key_count = 0\",\n \"def delete(self, key):\\n if not self.__contains__(key):\\n raise KeyError(\\\"Error: Key \\\" + key + \\\" does not exist!\\\") # Rethrow exception for documentation purposes\\n\\n hashed_idx = self._linear_probe(key, 'delete')\\n # Clear the spot\\n self.keys[hashed_idx] = None\\n self.values[hashed_idx] = None\\n # Rehash all keys in the same cluster\\n start_rehash = (hashed_idx + 1) % self.size\\n i = start_rehash\\n while self.keys[i] is not None:\\n # Save key and value to rehash\\n key_to_rehash = self.keys[i]\\n val_to_rehash = self.values[i]\\n # Clear the spots and re-insert\\n self.keys[i] = None\\n self.values[i] = None\\n self.count -= 1 # decrement count\\n self[key_to_rehash] = val_to_rehash # Simply put() it back into the table\\n i = (i + 1) % self.size\\n\\n self.count -= 1 # Remember to decrement count again\",\n \"def _grow(self):\\n self.capacity *= self.factor\\n temp = [None] * self.capacity\\n for i in range(self.size):\\n temp[i] = self.store[i]\\n self.store = temp\",\n \"def __delitem__(self, key):\\n\\n # If key is in hash map\\n if self.__contains__(key):\\n\\n # Get hashed key\\n i = self.hash(key)\\n\\n # Get chain index of key value pair\\n chain_idx = self.keys_ref[i].index(key)\\n\\n # Delete value associated with key in hash map\\n del self.table[i][chain_idx]\\n\\n # Delete key from hash table\\n del self.keys_ref[i][chain_idx]\\n\\n # Remove key from set of keys\\n self.keys_set.remove(key)\\n\\n # Decrement size\\n self.size -= 1\\n\\n # If key not in hash map\\n else:\\n\\n # Raise error\\n raise KeyError(key)\",\n \"def shrink(self):\\r\\n # Shrink the size by half but not below the default capacity\\r\\n # and remove those garbage cells from the underlying list\\r\\n newSize = max(self._capacity, len(self) // 2)\\r\\n for count in range(len(self) - newSize):\\r\\n self._items.pop()\",\n \"def clear(self):\\r\\n\\t\\t# re-initialize self._buckets\\r\\n\\t\\tself._buckets = []\\r\\n\\t\\tself.size = 0\\r\\n\\t\\tfor i in range(self.capacity):\\r\\n\\t\\t\\tself._buckets.append(LinkedList())\",\n \"def _hash(self, hashKey):\\n return hashKey % self.size\",\n \"def __delitem__(self, key):\\n i, kv_pair = self._lookup(key, self._backing)\\n if kv_pair and not kv_pair.value is Hashmap.absent:\\n self._backing[i] = KeyValue(key, Hashmap.absent)\\n self._deleted += 1\\n\\n size = len(self._backing)\\n utilization = (self._used - self._deleted)/size \\n if utilization < 0.16:\\n self._resize(self._decr_size(size))\\n else:\\n raise KeyError('no such item!')\",\n \"def rehash_config(self):\\n self._cache[\\\"config\\\"] = utilities.hash_object_sha256(self._get_config_raw())\",\n \"def clear(self):\\n if self.size == 0:\\n return\\n self.modCount += 1\\n self.size = 0\\n Arrays.fill(self.keys, None)\\n Arrays.fill(self.values, None)\",\n \"def _enforce_lru_size(self):\\n\\n # if a limit was defined and we have blown it\\n if self._max_lru and len(self) > self._max_lru:\\n # make sure in-memory dictionary doesn't get bigger\\n for key in self._lru_list[self._max_lru:]:\\n super(pyCacheBack, self).__delitem__(key)\\n # also truncate the LRU list\\n self._lru_list = self._lru_list[:self._max_lru]\",\n \"def clear(self):\\n\\n for i in range(self.capacity):\\n self._buckets[i].head = None # Empty out the LinkedList in each bucket\\n self._buckets[i].size = 0\\n self.size = 0\",\n \"def __setitem__(self, key, value):\\n i, kv_pair = self._lookup(key, self._backing)\\n self._backing[i] = KeyValue(key, value)\\n if kv_pair is None:\\n self._used += 1\\n \\n size = len(self._backing)\\n utilization = self._used/size\\n if utilization > 0.67:\\n self._resize(self._incr_size(size))\",\n \"def _gethash(self, invalue) -> int:\\n return hash(invalue) % self.capacity\",\n \"def _bucket_setitem(self, j, k, v):\\n if self._table[j] is None:\\n self._table[j] = UnsortedTableMap() # create new bucket at index j\\n oldSize = len(self._table[j])\\n self._table[j][k] = v\\n if len(self._table[j]) > oldSize: # key is new to the table\\n self._n += 1\",\n \"def put(self, key, value):\\n hi = self.hash_index(key)\\n if self.storage[hi]:\\n current = self.storage[hi]\\n while current.next and current.key != key:\\n current = current.next\\n\\n if current.key == key:\\n current.value = value\\n else:\\n current.next = HashTableEntry(key, value)\\n self.numberOfItems += 1\\n else:\\n self.storage[hi] = HashTableEntry(key, value)\\n self.numberOfItems += 1\\n\\n self.calculateLoad()\",\n \"def hash(self, key):\\n key = str(key)\\n h = 0\\n a = self.hash_base\\n for i in range(len(str(key))):\\n h = (h * a + ord(key[i])) % self.table_capacity\\n return h\",\n \"def grow(self):\\r\\n\\r\\n old = self._data\\r\\n self._capacity = 2 * self._capacity\\r\\n self._data = [0] * self._capacity\\r\\n\\r\\n for i in range(self._size):\\r\\n\\r\\n self._data[i] = old[i]\",\n \"def put(self, key, value):\\n while len(self.buckets) <= key:\\n self.buckets = self.buckets + [-1] * len(self.buckets)\\n self.length = self.length * 2\\n self.buckets[key] = value\",\n \"def put(self, key, value):\\n hash_key = self._hash_function(key) % self.capacity # finds index for new key/value pair\\n\\n if self._buckets[hash_key].size == 0: # if bucket is empty, add new key/value pair\\n self.size += 1\\n self._buckets[hash_key].add_front(key, value)\\n else:\\n if self._buckets[hash_key].contains(key):\\n self._buckets[hash_key].remove(key) # if key already exists, delete old key/value pair\\n self.size -= 1\\n self._buckets[hash_key].add_front(key, value) # add new key/value pair\\n self.size += 1\",\n \"def internal_hash(self): \\n return hash(tuple(sorted(self.hashtriples())))\",\n \"def refresh(self):\\n node, ans = self.list_head.next.next, 0\\n # first update key_nodes in even positions\\n while node:\\n ans += 1\\n node = node.next.next\\n # then update tree_nodes's current_btree_node in odd positions\\n node = self.list_head.next\\n while node:\\n node.current_btree_node = self\\n if node.next:\\n node = node.next.next\\n else:\\n break\\n self.size = ans\",\n \"def dup_hash_state(self) -> None:\\n assert len(self.hash_states) > 0\\n self.hash_states.append(self.hash_states[-1].copy())\",\n \"def insert(self, value):\\n bucketNum = self.__hash(value)\\n originalBucketNum = bucketNum\\n if self.__buckets[bucketNum] is not None:\\n bucketNum = self.__rehash(bucketNum)\\n while self.__buckets[bucketNum] is not None and bucketNum != originalBucketNum:\\n bucketNum = self.__rehash(bucketNum)\\n if self.__buckets[bucketNum] is None:\\n self.__buckets[bucketNum] = value\\n else:\\n raise Exception(\\\"Table Full\\\")\",\n \"def clear(self):\\n LongObjectHashMap.self.clear()\",\n \"def clear(self):\\n LongObjectHashMap.self.clear()\",\n \"def remove(self, key):\\n hash_key = key % self.key_space\\n self.hash_table[hash_key].remove(key)\",\n \"def remove(self):\\n if LongObjectHashMap.self.modCount != self.expectedModCount:\\n raise ConcurrentModificationException()\\n if self.lastReturned == self.EMPTY_KEY:\\n raise IllegalStateException()\\n self.count -= 1\\n LongObjectHashMap.self.remove(self.lastReturned)\\n self.lastReturned = self.EMPTY_KEY\\n self.expectedModCount = LongObjectHashMap.self.modCount\",\n \"def clear(self):\\n self.size = 0 # set size to 0 and reinitialize buckets as empty\\n self._buckets = []\",\n \"def update_hashes(self, ret=False) -> None:\\n self.hash = self.calculate_hash()\\n self.stub_hash = self.calculate_hash(include_md=False)\",\n \"def put(self, key, value):\\n # Your code here\\n\\n idx = self.hash_index(key)\\n entry = HashTableEntry(key, value)\\n match = None\\n\\n # if there's already something stored at this index\\n if self.hash_table[idx] is not None:\\n curr_node = self.hash_table[idx]\\n\\n # look for an existing entry with the same key\\n while match is None:\\n if curr_node.key == key:\\n match = curr_node\\n else:\\n curr_node = curr_node.next\\n \\n # if we reached the tail and still haven't found an existing match, break out of the loop\\n if curr_node is None:\\n break\\n\\n # if we reached the end and didn't find an existing entry matching the provided key\\n # add a new entry at the end\\n if match is None and curr_node.next is None:\\n curr_node.next = entry\\n self.total_items+= 1\\n self.determine_resize_type()\\n\\n # if an entry with the provided key already exists, just update its value with the provided value\\n elif match is not None:\\n match.value = value\\n \\n \\n # if nothing exists as this index, just add the entry\\n else:\\n self.hash_table[idx] = entry\\n self.total_items+= 1\\n self.determine_resize_type()\",\n \"def __init__(self, table_capacity=101, hash_base=31):\\n\\n self.table_capacity = table_capacity\\n self.hash_base = hash_base\\n self.array = [None] * self.table_capacity # Array initialized with 'None\\\" in each element.\\n self.count = 0 # the number of items in the table, initially set to '0'\\n self.rehash_count = 0\\n self.probe_array = []\",\n \"def reset(self):\\n for k in self.data_keys:\\n setattr(self, k, [])\\n self.size = 0\",\n \"def remove(self, key):\\n if self.contains_key(key): # if key exists in hashmap, remove key/value pair\\n hash_key = self._hash_function(key) % self.capacity\\n bucket = self._buckets[hash_key]\\n bucket.remove(key)\",\n \"def __hash__(self):\\r\\n return hash(self.__key())\",\n \"def reset() -> None:\\n Stat._cache = SortedDict()\",\n \"def hash(self, key):\\n return hash(key) % len(self.array)\",\n \"def _checklru(self):\\n if len(self._dict)>self._maxsize:\\n lru=self._head._next\\n lru._previous._next=lru._next\\n lru._next._previous=lru._previous\\n del self._dict[lru._key]\",\n \"def hash_index(self, key):\\n #return self.fnv1(key) % self.capacity\\n return self.djb2(key) % self.capacity\",\n \"def grow(self):\\n old = self.data # keep track of existing list\\n self.capacity = self.capacity*2\\n self.data = [None] * (self.capacity) # allocate list with new capacity\\n walk = self.head\\n for k in range(self.size): # only consider existing elements\\n self.data[k] = old[walk] # intentionally shift indices\\n walk = (1 + walk) % len(old) # use old size as modulus\\n self.head = 0 # front has been realigned\",\n \"def htable(nbuckets):\",\n \"def hash(df, col, bucket_size):\\n new_df = df[[c for c in df.columns if c != col]]\\n new_df[col] = df[col].apply(lambda x: farmhash.fingerprint64(x) % bucket_size) \\n return new_df\",\n \"def __setitem__(self, key, value):\\n if self.count == self.size: # For now, rehash only when full (better to keep it half empty always)\\n self.rehash()\\n\\n hashed_idx = self._linear_probe(key, \\\"set\\\") # Get position to put. _probe() takes care of hashing the key\\n if self.keys[hashed_idx] != key: # If _probe() returns a spot that doesn't have this key, then increment count\\n self.count += 1\\n self.keys[hashed_idx] = key # Store key in the keys array\\n self.values[hashed_idx] = value # Store value in the values array\",\n \"def removeall(self):\\n\\n # If there used to be a key, there must exist an old value blob somewhere in the database. It should be deallocated after a successful commit to disk.\\n for key in self.keys:\\n if self.keys[key] is not None:\\n punchat,punchlen = self.keys[key]\\n self.awaitingpunch.append((punchat, punchlen))\\n \\n self.keys = {}\\n self.buffered = {}\\n self.cache = {}\\n \\n if self.autocommit:\\n commit()\",\n \"def _reduce_rep(self):\\n for k, v in self.items():\\n if not k:\\n self[k] = 0\\n for per1, per2 in pairwise(k):\\n if per1 == per2:\\n self[k] = 0\\n super()._reduce_rep()\",\n \"def _hash(self, key):\\n # OPTIONAL STRETCH: You may replace the Python hash with DJB2 as a stretch goal\\n # return hash(key)\\n return self._hash_djb2(key)\",\n \"def clone(self):\\n clone = super(LongObjectHashMap, self).clone()\\n clone.clear()\\n clone.initialize()\\n for key in keySet():\\n value = self.get(key)\\n clone.put(key, value)\\n return clone\",\n \"def __init__(self):\\n self.hashmap = [[] for _ in range(self._cap)]\",\n \"def _hashed_items(self):\\n return self\",\n \"def hash_index(self, key):\\n # return self.fnv1(key) % self.capacity\\n return self.djb2(key) % self.capacity\",\n \"def hash_index(self, key):\\n # return self.fnv1(key) % self.capacity\\n return self.djb2(key) % self.capacity\",\n \"def test_remove_from_index_shared_hashes_partial(self):\\n # Simulate initial state with some descriptor hashed to one value and\\n # other descriptors hashed to another.\\n\\n descriptors = [\\n DescriptorMemoryElement('t', 0),\\n DescriptorMemoryElement('t', 1),\\n DescriptorMemoryElement('t', 2),\\n DescriptorMemoryElement('t', 3),\\n DescriptorMemoryElement('t', 4),\\n ]\\n # Vectors of length 1 for easy dummy hashing prediction.\\n for d in descriptors:\\n d.set_vector(np.ones(1, float) * d.uuid())\\n\\n # Dummy hash function to do the simulated thing\\n hash_func = DummyHashFunctor()\\n hash_func.get_hash = mock.Mock(\\n # Vectors of even sum hash to 0, odd to 1.\\n side_effect=lambda vec: [vec.sum() % 2]\\n )\\n\\n d_set = MemoryDescriptorIndex()\\n d_set._table = {\\n 0: descriptors[0],\\n 1: descriptors[1],\\n 2: descriptors[2],\\n 3: descriptors[3],\\n 4: descriptors[4],\\n }\\n\\n hash2uid_kvs = MemoryKeyValueStore()\\n hash2uid_kvs._table = {\\n 0: {0, 2, 4},\\n 1: {1, 3},\\n }\\n\\n idx = LSHNearestNeighborIndex(hash_func, d_set, hash2uid_kvs)\\n idx.hash_index = mock.Mock(spec=HashIndex)\\n\\n idx.remove_from_index([1, 2, 3])\\n # Check that only one hash vector was passed to hash_index's removal\\n # method (deque of hash-code vectors).\\n idx.hash_index.remove_from_index.assert_called_once_with(\\n collections.deque([\\n [1],\\n ])\\n )\\n self.assertDictEqual(d_set._table, {\\n 0: descriptors[0],\\n 4: descriptors[4],\\n })\\n self.assertDictEqual(hash2uid_kvs._table, {0: {0, 4}})\",\n \"def __init__(self):\\n self.size = 997\\n self.hash_set = [None] * self.size\",\n \"def dense_hash(hash_, block_size=16):\\n results = list()\\n for index in range(0, len(hash_), block_size):\\n\\n block = hash_[index:index + block_size]\\n\\n total = 0\\n for i in block:\\n total ^= i\\n\\n results.append(total)\\n\\n return results\",\n \"def hashing(self, key):\\n #return hash(key) % self.__size\\n if type(key) == str:\\n hashVal = 0\\n for i, c in enumerate(key):\\n hashVal += int(ord(c)) * 31 ** (len(key) -1 - i)\\n return hashVal % self.__size\\n return key % self.__size\",\n \"def test_splittable_del(self):\\n a, b = self.make_shared_key_dict(2)\\n\\n orig_size = sys.getsizeof(a)\\n\\n del a['y'] # split table is combined\\n with self.assertRaises(KeyError):\\n del a['y']\\n\\n self.assertEqual(list(a), ['x', 'z'])\\n self.assertEqual(list(b), ['x', 'y', 'z'])\\n\\n # Two dicts have different insertion order.\\n a['y'] = 42\\n self.assertEqual(list(a), ['x', 'z', 'y'])\\n self.assertEqual(list(b), ['x', 'y', 'z'])\",\n \"def __hash__(self):\\n return hash(self.hash)\",\n \"def __init__(self):\\n # better to be a prime number, less collision\\n self.key_space = 2069\\n self.hash_table = [Bucket() for i in range(self.key_space)]\",\n \"def test_splittable_setdefault(self):\\n a, b = self.make_shared_key_dict(2)\\n\\n a['a'] = 1\\n size_a = sys.getsizeof(a)\\n a['b'] = 2\\n b.setdefault('b', 2)\\n size_b = sys.getsizeof(b)\\n b['a'] = 1\\n\\n self.assertEqual(list(a), ['x', 'y', 'z', 'a', 'b'])\\n self.assertEqual(list(b), ['x', 'y', 'z', 'b', 'a'])\",\n \"def _hash(self, item):\\r\\n pass # TODO\\r\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.81800413","0.80060524","0.78790945","0.720138","0.7163807","0.7084468","0.70818853","0.68698233","0.68121934","0.6672545","0.66696256","0.6579458","0.64621586","0.6386414","0.62088525","0.61762494","0.59902906","0.5952233","0.581466","0.5799071","0.57671523","0.5721532","0.5683754","0.5666269","0.56389004","0.563889","0.56347793","0.56140053","0.559613","0.5560543","0.5555226","0.55216444","0.55063194","0.5472982","0.547063","0.54675984","0.5460416","0.54549056","0.5453809","0.54291016","0.54251534","0.54198354","0.5357229","0.5341861","0.53334415","0.5323022","0.5312883","0.5303284","0.5302023","0.5215588","0.5202329","0.51745117","0.51574385","0.51548177","0.51526165","0.5147788","0.5138494","0.5132366","0.5131416","0.51215893","0.511785","0.51043785","0.5084151","0.50776553","0.50764525","0.50764525","0.50741345","0.5071851","0.5059371","0.5057796","0.50328004","0.5024774","0.5024324","0.50232506","0.5020897","0.50193053","0.5016982","0.50084186","0.50040066","0.500159","0.49946916","0.49725625","0.49705955","0.4967033","0.4965261","0.49641806","0.49593228","0.49472803","0.49425983","0.4942236","0.4942236","0.4940223","0.49391416","0.4938973","0.4933838","0.49298185","0.49231583","0.49160135","0.49158257","0.49115092"],"string":"[\n \"0.81800413\",\n \"0.80060524\",\n \"0.78790945\",\n \"0.720138\",\n \"0.7163807\",\n \"0.7084468\",\n \"0.70818853\",\n \"0.68698233\",\n \"0.68121934\",\n \"0.6672545\",\n \"0.66696256\",\n \"0.6579458\",\n \"0.64621586\",\n \"0.6386414\",\n \"0.62088525\",\n \"0.61762494\",\n \"0.59902906\",\n \"0.5952233\",\n \"0.581466\",\n \"0.5799071\",\n \"0.57671523\",\n \"0.5721532\",\n \"0.5683754\",\n \"0.5666269\",\n \"0.56389004\",\n \"0.563889\",\n \"0.56347793\",\n \"0.56140053\",\n \"0.559613\",\n \"0.5560543\",\n \"0.5555226\",\n \"0.55216444\",\n \"0.55063194\",\n \"0.5472982\",\n \"0.547063\",\n \"0.54675984\",\n \"0.5460416\",\n \"0.54549056\",\n \"0.5453809\",\n \"0.54291016\",\n \"0.54251534\",\n \"0.54198354\",\n \"0.5357229\",\n \"0.5341861\",\n \"0.53334415\",\n \"0.5323022\",\n \"0.5312883\",\n \"0.5303284\",\n \"0.5302023\",\n \"0.5215588\",\n \"0.5202329\",\n \"0.51745117\",\n \"0.51574385\",\n \"0.51548177\",\n \"0.51526165\",\n \"0.5147788\",\n \"0.5138494\",\n \"0.5132366\",\n \"0.5131416\",\n \"0.51215893\",\n \"0.511785\",\n \"0.51043785\",\n \"0.5084151\",\n \"0.50776553\",\n \"0.50764525\",\n \"0.50764525\",\n \"0.50741345\",\n \"0.5071851\",\n \"0.5059371\",\n \"0.5057796\",\n \"0.50328004\",\n \"0.5024774\",\n \"0.5024324\",\n \"0.50232506\",\n \"0.5020897\",\n \"0.50193053\",\n \"0.5016982\",\n \"0.50084186\",\n \"0.50040066\",\n \"0.500159\",\n \"0.49946916\",\n \"0.49725625\",\n \"0.49705955\",\n \"0.4967033\",\n \"0.4965261\",\n \"0.49641806\",\n \"0.49593228\",\n \"0.49472803\",\n \"0.49425983\",\n \"0.4942236\",\n \"0.4942236\",\n \"0.4940223\",\n \"0.49391416\",\n \"0.4938973\",\n \"0.4933838\",\n \"0.49298185\",\n \"0.49231583\",\n \"0.49160135\",\n \"0.49158257\",\n \"0.49115092\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6915366"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":21971,"cells":{"query":{"kind":"string","value":"Write a program that takes as input a BST and an interger k, and returns the k largest elements in the BST in decreasing order."},"document":{"kind":"string","value":"def find_k_largest_in_bst_recursively(tree, k):\n\n def find_k_largest_in_bst_helper(tree):\n if tree and len(k_largest_elements) < k: # Smart: Recursion iff we don't have K largest elements collected\n find_k_largest_in_bst_helper(tree.right)\n if len(k_largest_elements) < k:\n k_largest_elements.append(tree.data)\n find_k_largest_in_bst_helper(tree.left)\n\n k_largest_elements = []\n find_k_largest_in_bst_helper(tree)\n return k_largest_elements"},"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 findKthLargest(self, nums: List[int], k: int) -> int:\n return sorted(nums)[-k]","def _get_k_largest(lst, k):\n sorted_lst = sorted([(val, index) for index, val in enumerate(lst)])\n return list(reversed(sorted_lst[-k:]))","def kth_largest(arr: list, k: int):\n # Do not search if k is larger than total number of elements\n if k > len(arr):\n raise IndexError\n # Count all numbers\n nums = Counter(arr)\n # Go from the largest to smaller ones\n for key in sorted(nums, reverse=True):\n if nums[key] >= k:\n return key\n else:\n k -= nums[key]","def test_find_kth_smallest(self):\n sortedValues = sorted(self.values)[::-1]\n for index, value in enumerate(sortedValues):\n valueFound = self.tree.findKthGreatest(index + 1)\n self.assertEquals(value, valueFound)","def _kth_largest(self, k: int, start : int, end : int):\n # 1. select a random pivot\n pivotIndex = self.get_pivot_index(start, end)\n # print('Before partition start, end, pivotIndex ', start, end, pivotIndex)\n pivotIndex = self.partition(pivotIndex, start, end)\n # print(f'After partition , data = {data}, pivotIndex = {pivotIndex}')\n\n if end-pivotIndex >=k:\n return self._kth_largest(k, pivotIndex+1, end)\n \n elif end-pivotIndex+1 == k:\n return pivotIndex, self.data[pivotIndex]\n else:\n return self._kth_largest(k-1-(end-pivotIndex), start , pivotIndex-1)","def kth_smallest(root, k=1):\n\n node_status = defaultdict(lambda: 'unvisited')\n\n count = 0\n stack = [root] # A list is a stack.\n\n while len(stack) != 0:\n do_increment = False\n current_node = stack[-1] # ie peek\n\n node_status[current_node] = 'visited'\n\n if current_node.left is not None:\n\n left_status = node_status[current_node.left]\n if left_status == 'exited':\n stack.pop()\n do_increment = True\n\n elif left_status == 'unvisited':\n stack.append(current_node.left)\n continue\n else:\n stack.pop()\n do_increment = True\n\n if current_node.right is not None:\n stack.append(current_node.right)\n\n if do_increment:\n node_status[current_node] = 'exited'\n count += 1\n if count == k:\n return current_node.key\n\n raise IndexError(\"Tree is too small! Only found: {} nodes\".format(count))","def top_k(self, k):\n with self.mutating:\n topk = heapq.nsmallest(k, self.queue)\n return topk","def top_k(self, k = 1):\n\t if self.shapley_rank == {}:\n\t \treturn []\n\n\t n = self.nodes\n\t topknodes = []\n\t i = 0\n\t count = 0\n\t while count < k and not i == n:\n\t if self.shapley_rank[i][0] not in topknodes and not self.is_adj(self.shapley_rank[i][0], topknodes):\n\t topknodes.append(self.shapley_rank[i][0])\n\t count += 1\n\t i += 1\n\t i = 0\n\t if not count == k:\n\t while not count == k:\n\t if self.shapley_rank[i][0] not in topknodes:\n\t topknodes.append(self.shapley_rank[i][0])\n\t count += 1\n\t i += 1\n\t return topknodes","def find_order(input, k):\n if ( k >= len(input) or k < 0 ):\n return None\n elif len(input) == 0:\n return None\n elif len(input) == 1:\n # k should be 0\n assert k == 0\n return input[0]\n else:\n pivot = input[len(input)//2]\n left = [x for x in input if x <= pivot]\n left.remove(pivot)\n \n if len(left) == k:\n return pivot\n elif len(left) > k:\n return find_order(left, k)\n else:\n right = [x for x in input if x > pivot]\n return find_order(right, k-1-len(left))","def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n\n if k == 1:\n return [max(nums)]\n\n hash_map = {}\n for i, n in enumerate(nums):\n hash_map[n] = i\n\n candidates = nums[: len(nums) - k + 1]\n print(candidates)\n mx = max(candidates)\n mx_idx = hash_map[mx]\n op = nums[mx_idx : mx_idx + k]\n return op","def heapdown(h, k):\n\n #put this value in the correct place\n v = h[k]\n\n while 2 * k < len(h):\n\n #assign j to be the left child\n j = 2 * k\n\n #is there a child to the right\n if j + 1 < len(h):\n\n #is the left child smaller than the right child\n if h[j] < h[j+1]:\n j = j + 1\n\n #if v is greater than its larger child\n if v >= h[j]:\n break\n else:\n h[k] = h[j]\n k = j\n\n h[k] = v","def kth_to_last_recursive(node: Node, k: int):\n\n if node == None:\n return 0\n\n index = kth_to_last_recursive(node.next, k) + 1\n\n if index == k:\n print(node.value)\n\n return index","def swap(root, k):\n q = deque([(root, 1)])\n while q:\n node, level = q.popleft()\n if node is None:\n continue\n if level % k == 0:\n node.left, node.right = node.right, node.left\n q.append((node.left, level+1))\n q.append((node.right, level+1))","def top(self, k):\n if not 1 <= k <= len(self):\n raise ValueError('Illegal value for k')\n \n # making a copy of the original list\n temp = PositionalList()\n for item in self._data:\n temp.add_last(item)\n\n # repeatedly find, report, and remove element with largest count\n for j in range(k):\n # find and report next highest from temp\n highPos = temp.first()\n walk = temp.after(highPos)\n while walk is not None:\n if walk.element()._count > highPos.element()._count:\n highPos = walk\n walk = temp.after(walk)\n # found the element with highest count\n yield highPos.element()._value # report element to user\n temp.delete(highPos)","def top(self, k):\n if not 1 <= k <= len(self):\n raise ValueError('illegal value for k')\n\n # making a copy of the original list\n temp = PositionalList()\n for item in self._data: # positional lists support iteration\n temp.add_last(item)\n\n # repeatedly find, report and remove element with largest count\n for j in range(k):\n # find and report next highest from temp\n highPos = temp.first()\n walk = temp.after(highPos)\n while walk is not None:\n if walk.element()._count > highPos.element()._count:\n highPos = walk\n walk = temp.after(walk)\n # found the element with highest count\n yield highPos.element()._value # report element to user\n temp.delete(highPos) # remove from temp list","def kth_to_last_recursive_1(self, k):\n class Index(object):\n def __init__(self):\n self.index = 0\n idx = Index()\n node = self._kth_to_last_recursive_1(self.head, k, idx)\n if node is None:\n raise IndexError('List index out of range')\n else:\n return node.value","def find_max_in_array(arr, k):\r\n print(\" Amazon interview question\")\r\n arr[:] = sorted(arr)\r\n return ((arr[len(arr)-k]))","def twoSumLessThanK(nums, k):\n nums.sort()\n start = 0\n end = len(nums) - 1\n max_sum = -1\n while start < end:\n curr_sum = nums[start] + nums[end]\n if curr_sum < k:\n max_sum = max(curr_sum, max_sum)\n if curr_sum >= k:\n end -= 1\n else:\n start += 1\n\n return max_sum","def top_k(a, k=1):\n if not type(a) is Blob:\n raise ValueError('`a` should be neoml.Blob.')\n\n if int(k) <= 0:\n raise ValueError('`k` should be > 0.')\n\n if a.size == 0:\n raise ValueError(\"The blob shouldn't be empty.\")\n \n return Blob(PythonWrapper.blob_top_k(a._internal, int(k)))","def kth_to_last_recursive(self, k):\n node, _ = self._kth_to_last_recursive(self.head, k)\n if node is None:\n raise IndexError('List index out of range')\n else:\n return node.value","def _kth_to_last_recursive(self, head, k):\n if head is None:\n return None, 0 \n node, index = self._kth_to_last_recursive(head.next_node, k) \n index += 1 \n if index == k:\n return head, index\n return node, index","def get_top_N(root,n):\n\n\tglobal files\n\tfind_files(root)\n\theapq.heapify(files)\n\tret = heapq.nlargest(n,files)\n\tfiles = []\n\treturn ret","def fetch_top_k(vect, mat, k):\n resultant = np.dot(mat, vect)\n arglist = np.argsort(resultant)\n arglist = arglist[-1:(-1 - k):-1]\n return arglist, resultant","def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n max_heap = []\n item_dict = {}\n result = []\n\n for i in range(len(nums)):\n item = [-nums[i], False]\n heapq.heappush(max_heap, item)\n\n if nums[i] not in item_dict:\n item_dict[nums[i]] = [item]\n else:\n item_dict[nums[i]].append(item)\n\n if i - k >= 0:\n # \"remove\" element from heap\n item_to_remove = nums[i - k]\n\n in_heap_item = item_dict[item_to_remove].pop()\n in_heap_item[1] = True # mark as removed\n\n while max_heap[0][1] is True:\n heapq.heappop(max_heap)\n\n result.append(-max_heap[0][0])\n if i == k - 1:\n # handle the first window\n result.append(-max_heap[0][0])\n\n return result","def top(self, k):\n if not 1 <= k <= len(self):\n raise ValueError(\"Illegal value for k\")\n temp = PositionalList()\n for item in self.data:\n temp.add_last(item)\n\n for j in range(k):\n high_pos = temp.first()\n walk = temp.after(high_pos)\n while walk is not None:\n if walk.element()._count > high_pos.element()._count:\n high_pos = walk\n walk = temp.after(walk)\n yield high_pos.element()._value\n temp.delete(high_pos)","def next_larger(self, k):\n node = self.find(k)\n return node and node.next_larger()","def top(self, array, key, k):\n\n return heapq.nlargest(\n k,\n range(len(array)),\n key\n )","def maxSlidingWindow_v2(self, nums: List[int], k: int) -> List[int]:\n m_queue = deque()\n result = []\n\n for i in range(len(nums)):\n while m_queue and m_queue[-1] < nums[i]:\n m_queue.pop()\n m_queue.append(nums[i])\n\n if i - k >= 0:\n item_to_remove = nums[i - k]\n\n if item_to_remove == m_queue[0]:\n m_queue.popleft()\n\n if i >= k - 1:\n result.append(m_queue[0])\n\n return result","def kth_to_last_recursive(head, k):\n if not head:\n return 0\n\n index = kth_to_last_recursive(head.next(), k)\n\n if index == k:\n print(head.value())\n\n index += 1\n return index","def kthSmallest(A, k):\n if k >= len(A):\n return None\n return select(A, 0, len(A) - 1, k)","def kth_from_end(self, k):\n if k < 0:\n raise ValueError(\"Positive integer required\")\n\n current = self.head\n arr = []\n while current:\n arr.append(current)\n current = current.next\n\n if len(arr) < k:\n raise IndexError(\"Value extends length of List.\")\n\n arr.reverse()\n\n if k == len(arr):\n k = k - 1\n return arr[k].value","def top_k(input, k=1, sorted=True, index_type=dtypes.int32, name=None): # pylint: disable=redefined-builtin\n return gen_nn_ops.top_kv2(\n input, k=k, sorted=sorted, index_type=index_type, name=name\n )","def test_find_kth_smallest(self):\n sortedValues = sorted(self.values)\n for index, value in enumerate(sortedValues):\n valueFound = self.tree.findKthSmallest(index + 1)\n self.assertEquals(value, valueFound)","def next_larger(self, k):\n node = self.find(k)\n return node and node.successor()","def find_top_k(predictions, boxes, k):\r\n\r\n if predictions.shape[0] == 0:\r\n predictions2 = torch.Tensor([]).to(device)\r\n labels2 = torch.Tensor([]).to(device)\r\n boxes2 = torch.Tensor([]).to(device)\r\n scores2 = torch.Tensor([]).to(device)\r\n\r\n else:\r\n predictions0 = predictions\r\n scores0 = torch.max(predictions0, dim=1)[0]\r\n labels0 = torch.argmax(predictions0, dim=1)\r\n boxes0 = boxes\r\n\r\n sort = torch.argsort(scores0, descending=True)\r\n boxes1, labels1, scores1, predictions1 = boxes0[sort], labels0[sort], scores0[sort], predictions0[sort]\r\n\r\n boxes2, labels2, scores2, predictions2 = boxes1[:k], labels1[:k] + 1, scores1[:k], predictions1[:k]\r\n\r\n return predictions2, boxes2, labels2, scores2","def max_heapify(lst, n, root):\n\n largest = root\n l = 2 * root + 1\n r = 2 * root + 2\n\n if l < n and lst[l] > lst[largest]:\n largest = l\n if r < n and lst[r] > lst[largest]:\n largest = r\n if largest != root:\n lst[root], lst[largest] = lst[largest], lst[root]\n max_heapify(lst, n, largest)","def findChildB(T,k):\r\n for i in range(len(T.data)):\r\n if k < T.data[i].word:\r\n return i\r\n return len(T.data)","def _kth_to_last_iterative(self, head, k): #\n node1 = head\n node2 = None \n flag = False \n i = 0 \n while node1 is not None:\n i += 1 \n node1 = node1.next_node \n if flag: \n node2 = node2.next_node \n if i == k:\n flag = True \n node2 = head \n return node2","def findMaximumSubarraySlidingWindow(self, k, nums):\n window_start, window_sum, window_max= 0, 0, 0\n for i in range(len(nums)):\n window_sum += nums[i] #add the next element\n # slide the window, we don't need to slide if we have not hit the required window size of K\n if i >= k-1:\n window_max = max(window_sum, window_max) # calculate the maximum sum\n window_sum -= nums[window_start] #substract the element going out\n window_start += 1 #slide the window ahead\n return window_max","def topKFrequent(self, nums, k):\n\n # Generate dictionary of frequencies\n frequency = defaultdict(int)\n for num in nums:\n frequency[num] += 1\n\n k_most = []\n # Grab the k most frequent values, sorted descending\n for val in sorted(frequency.values())[::-1][:k]:\n # Append the associated key to k_most if it isn't already there\n k_most.append([key for key, value in frequency.items() if (value == val and not key in k_most)][0])\n return k_most","def sorted_top_k(item_counts, k):\n # Partitioning runs in O(d) time.\n top_k_unsorted = np.argpartition(-item_counts, k - 1)[:k]\n # Sorting highest k counts runs in O(k * log(k)) time.\n sorting_order = np.argsort(item_counts[top_k_unsorted])[::-1]\n return top_k_unsorted[sorting_order]","def get_top_k(matrix,k):\n assert k <= matrix.shape[1]\n col_inds = np.argpartition(matrix, -k)[:,-k:].flatten()\n row_inds = np.repeat(range(matrix.shape[0]),k)\n\n vals = matrix[row_inds, col_inds]\n\n return vals, col_inds","def kth_to_last_iterative(self, k):\n node = self._kth_to_last_iterative(self.head, k)\n if node is None:\n raise IndexError('List index out of range')\n else:\n return node.value","def convert_topk(g, op, block):\n\n data = g.get_node(op.input(\"X\")[0])\n if op.input(\"K\"):\n k = g.get_node(op.input(\"K\")[0])\n else:\n k = op.attr(\"k\")\n\n largest = True\n axis = -1\n if op.has_attr(\"axis\"):\n axis = op.attr(\"axis\")\n if op.has_attr(\"largest\"):\n largest = op.attr(\"largest\")\n is_ascend = not largest\n\n value_names = op.output(\"Out\")\n indice_names = op.output(\"Indices\")\n\n out = None\n indice = None\n if value_names and indice_names:\n out, indice = _op.topk(data=data, k=k, axis=axis, ret_type=\"both\", is_ascend=is_ascend)\n elif value_names:\n out = _op.topk(data=data, k=k, axis=axis, ret_type=\"values\", is_ascend=is_ascend)\n elif indice_names:\n indice = _op.topk(data=data, k=k, axis=axis, ret_type=\"indices\", is_ascend=is_ascend)\n\n if out is not None:\n g.add_node(value_names[0], out)\n if indice is not None:\n g.add_node(indice_names[0], indice)","def rank_k_element(A, B, k):\n if len(A) + len(B) < k:\n return None\n i = 0\n j = 0\n while i < len(A) and j < len(B) and k:\n if A[i] < B[j]:\n rank = A[i]\n i += 1\n else:\n rank = B[j]\n j += 1\n k -= 1\n if not k:\n return rank\n if i == len(A):\n z = j\n P = B\n else:\n z = i\n P = A\n while k:\n rank = P[z]\n z += 1\n k -= 1\n return rank","def get_min_depth(l_k):\n return max(l_k.values())","def search_highest_k_neighbor(self, k):\n max_score = 0\n target_node = None\n from_idx = None\n to_idx = None\n for i in range(k):\n node = self.graph.nodes[random.randrange(len(self.graph.nodes))]\n cluster_idx = self.search_cluster_by_node(node)\n if len(self.result[cluster_idx].get_nodes()) == 1:\n end_i = len(self.result)\n else:\n end_i = len(self.result) + 1\n\n random_cluster_idx = random.randrange(end_i)\n if random_cluster_idx != cluster_idx:\n tried_score = self.try_replace_node(node, cluster_idx, random_cluster_idx)\n if max_score < tried_score:\n max_score = tried_score\n target_node = node\n from_idx = cluster_idx\n to_idx = random_cluster_idx\n\n return max_score, target_node, from_idx, to_idx","def indices_of_top_k(arr, k):\n return np.sort(np.argpartition(np.array(arr), -k)[-k:])","def tf_top_k_probs(probs, k):\n\n if k > 0:\n return probs.argsort()[-k:][::-1]\n else:\n return probs.argsort()[:][::-1]","def top_k(m, k):\n ml = m.tolil()\n ms = [_top_k(d, r, k) for d, r in zip(ml.data, ml.rows)]\n return zip(*ms)","def first_larger(array, k):\n\t\n\t# check if array is None, empty,...\n\tif array is None or len(array) == 0:\n\t\treturn False\n\n\tif array[-1] <= k:\n\t\treturn False\n\n\tbegin = 0\n\tend = len(array)\n\n\twhile begin + 1 < end:\n\t\tmed = begin + (end-begin) / 2\n\t\tif array[med] == k: \n\t\t\twhile array[med] == k:\n\t\t\t\tmed += 1\n\t\t\treturn med\n\t\telif array[med] > k:\n\t\t\tend = med\n\t\telse:\n\t\t\tbegin = med\n\n\treturn end","def fn(n, k):\n if k == 1: return n \n if n == 0: return 0 \n ans = inf \n for x in range(1, n+1): \n ans = min(ans, 1 + max(fn(x-1, k-1), fn(n-x, k)))\n return ans","def nchoosek(n, k):\n if n < k:\n return 0\n return partition(n, [k, n - k])","def heightTree(root):\n try:\n if (root is None):\n return -1\n else:\n return 1 + max(heightTree(root['left']), heightTree(root['right']))\n except Exception as exp:\n error.reraise(exp, 'RBT:heightTree')","def down_heap(array, k, n):\n new_elem = array[k]\n while k <= n / 2:\n child = 2 * k\n if child < n and array[child] < array[child + 1]:\n child += 1\n if new_elem >= array[child]:\n break\n array[k] = array[child]\n k = child\n array[k] = new_elem","def find_max_average_sub(nums, k):\n\n\n\tresult = sum(nums[:k]) / k\n\tcurrent = result\n\n\tfor i in range(1, len(nums) - k + 1):\n\n\t\tcurrent = (current * k - nums[i - 1] +\\\n\t\t nums[i + k - 1]) / k\n\n\t\tif result < current:\n\t\t\tresult = current\n\n\n\treturn result","def findKthNumber(self, m: int, n: int, k: int) -> int:\n l, r = 1, m * n\n while l < r:\n mid = l + ((r - l) >> 1)\n\n # Check if there are k or more values that are less than mid.\n # For each row, its elements look like 1*i, 2*i, ... n*i, so the\n # largest number that is less than x will be x // i. But if x is\n # too large for the current row, the total count for this row\n # will be n instead.\n if sum(min(mid // r, n) for r in range(1, m + 1)) >= k:\n # mid is our candidate.\n r = mid\n else:\n l = mid + 1\n\n return l","def _find_max(self, root):\n while root.right:\n root = root.right\n return root","def top_view(root):\n\n if root is None:\n return\n\n # make an empty queue for BFS\n q = deque()\n\n # empty set\n sets = set({})\n\n # list to store top view keys\n topview = []\n\n # append root in the queue with horizontal distance as 0\n q.append((root, 0))\n\n while q:\n # get the element and horizontal distance\n elem, d = q.popleft()\n\n # if the hd is seen first time it will be top view\n if d not in sets:\n topview.append((elem.data, d))\n sets.add(d)\n\n # add left and right child in the queue with hd - 1 and hd + 1\n if elem.left is not None:\n q.append((elem.left, d - 1))\n if elem.right is not None:\n q.append((elem.right, d + 1))\n\n # return the sorted topview on the basis of hd\n return sorted(topview, key=lambda x: x[1])","def max_heapify(array, root):\n print(array)\n while True:\n left_child = 2*i\n right_child = 2*i + 1\n print(left_child, right_child)\n n = len(array)\n\n if left_child <= n and array[left_child] > array[i]:\n largest = left_child\n else:\n largest = i\n print(right_child)\n print('largest index',largest)\n if right_child <= n and array[right_child] > array[largest]:\n largest = right_child\n print(array[largest])\n\n if largest != i:\n a, b = array.index(array[i]), array.index(array[largest])\n array[b], array[a] = array[a], array[b]\n print(largest)\n return max_heapify(array, largest)","def top_k_frequent_elements(nums, k):\r\n freq_dict = {}\r\n for elem in nums:\r\n freq_dict[elem] = freq_dict.get(elem, 0) + 1\r\n \r\n return sorted(freq_dict.keys(), key= lambda x: freq_dict[x], reverse=True)[:k]","def kth_to_last(l_list, k=1):\n if not l_list:\n return\n\n if k > len(l_list):\n return\n\n runner = l_list.head()\n for i in range(k):\n if runner.next(): # Prevent the runner to become None in case the last element is asked for.\n runner = runner.next()\n\n curr = l_list.head()\n while runner.next():\n runner = runner.next()\n curr = curr.next()\n\n return curr.value()","def build_most_significant_tree(ktree, outputdir):\n stree = Tree()\n root = max(ktree.parents.keys())\n for cpt, popval in ktree.population.items():\n if popval == 1:\n stree.population[cpt] = 1\n _iter_build_most_significant_tree(ktree, stree, root)\n with open(os.path.join(outputdir, \"most_significant_tree.p\"), \"wb\") as f:\n pickle.dump(stree, f)\n return stree","def tflite_top_k_probs(probs, k):\n\n if k > 0:\n return np.flip(probs[0].argsort()[-k:])\n else:\n return np.flip(probs[0].argsort())","def get_sliding_window_max(numbers: Sequence[int], k: int) -> Iterable[int]:\n\n assert 1 <= k <= len(numbers)\n\n # Deque to store useful for calculation number indices.\n dq: Deque[int] = deque()\n\n for i in range(k):\n while dq and numbers[dq[-1]] < numbers[i]:\n dq.pop()\n\n dq.append(i)\n\n yield numbers[dq[0]]\n\n for i in range(k, len(numbers)):\n while dq[0] <= i - k:\n dq.popleft()\n\n while dq and numbers[dq[-1]] < numbers[i]:\n dq.pop()\n\n dq.append(i)\n\n yield numbers[dq[0]]","def _my_top_k(x, k):\n if k > 10:\n return tf.nn.top_k(x, k)\n values = []\n indices = []\n depth = tf.shape(x)[1]\n for i in range(k):\n values.append(tf.reduce_max(x, 1))\n argmax = tf.argmax(x, 1)\n indices.append(argmax)\n if i + 1 < k:\n x += tf.one_hot(argmax, depth, -1e9)\n return tf.stack(values, axis=1), tf.to_int32(tf.stack(indices, axis=1))","def quick_select(lst, k):\n if lst != []:\n pivot = lst[(len(lst)//2)]\n smallerlist = []\n largerlist = []\n count = 0\n for i in range(0,len(lst)):\n if lst[i] == pivot:\n count += 1\n elif lst[i] < pivot:\n smallerlist.append(lst[i])\n elif lst[i] > pivot:\n largerlist.append(lst[i])\n m = len(smallerlist)\n if k >= m and k < m + count:\n return pivot\n elif m > k:\n return quick_select(smallerlist, k)\n else:\n return quick_select(largerlist,k - m - count)","def fn(arr, k):\n ans = []\n for i, x in enumerate(arr): \n while ans and ans[-1] < x and len(ans) + len(arr) - i > k: ans.pop()\n if len(ans) < k: ans.append(x)\n return ans","def solve_sort(self):\n if self.k < 0 or self.k > len(self.numbers):\n return None\n\n self.numbers.sort() # in place\n return self.numbers[-self.k]","def k_nearest_neighbor(self, k, target, current_root, k_nearest_heap = LargeHeap()):\n iter_list = [] # a stack to store iteration path\n # step1: find the 'nearest' leaf\n nearest_leaf = current_root\n while nearest_leaf is not None:\n iter_list.append(nearest_leaf) # store the path\n tt = nearest_leaf.point\n tt1 = nearest_leaf.axis\n if target[nearest_leaf.axis] < nearest_leaf.point[nearest_leaf.axis]:\n if nearest_leaf.left is not None: # then go to the left child\n nearest_leaf = nearest_leaf.left\n else:\n break\n else:\n if nearest_leaf.right is not None: # else, go to the right child\n nearest_leaf = nearest_leaf.right\n else:\n break\n while nearest_leaf.left is not None or nearest_leaf.right is not None:\n if nearest_leaf.left is not None:\n nearest_leaf = nearest_leaf.left\n iter_list.append(nearest_leaf)\n if nearest_leaf.right is not None:\n nearest_leaf = nearest_leaf.right\n iter_list.append(nearest_leaf)\n tt = nearest_leaf.point\n \"\"\"\n step2: find the k nearest by backtracking upside\n Two situations to add the point into the heap k_nearest_heap\n A. when len(k_nearest_heap) < k\n B. when dis(point, target) < current_max_dis\n \"\"\"\n # k_nearest_heap = LargeHeap() # the large heap to store the current 'nearest' neighbors\n # the max distance is actually the distance between target and the top of the heap\n '''\n current_max_dis = self.distance(target, nearest_leaf.point[:self.n_dim])\n k_nearest_heap.add(nearest_leaf, current_max_dis)\n tmp = iter_list.pop()\n '''\n former_node = nearest_leaf # the former 'current_node', to indicate whether go through this child\n while iter_list != []:\n if k_nearest_heap.len > 0:\n current_max_dis = k_nearest_heap.heaplist[0][1]\n else:\n current_max_dis = -1\n current_pointer = iter_list.pop()\n tt = current_pointer.point\n dis = self.distance(current_pointer.point[:self.n_dim], target)\n if k_nearest_heap.len < k:\n k_nearest_heap.add(current_pointer, dis)\n elif dis < current_max_dis:\n k_nearest_heap.pop()\n k_nearest_heap.add(current_pointer, dis)\n # current_max_dis = self.distance(k_nearest_heap.heaplist[0][0].point[:self.n_dim], target)\n current_max_dis = k_nearest_heap.heaplist[0][1]\n axis = current_pointer.axis\n if abs(target[axis] - current_pointer.point[axis]) >= current_max_dis:\n former_node = current_pointer\n # if not intersect with\n continue\n if current_pointer.left is not None and current_pointer.left != former_node:\n tt = current_pointer.left\n # iter_list.append(current_pointer.left)\n self.k_nearest_neighbor(k, target, current_pointer.left, k_nearest_heap)\n if current_pointer.right is not None and current_pointer.right != former_node:\n tt = current_pointer.right\n # iter_list.append(current_pointer.righat)\n self.k_nearest_neighbor(k, target, current_pointer.right, k_nearest_heap)\n former_node = current_pointer\n rlist = []\n rdis = []\n for ele in k_nearest_heap.heaplist:\n rlist.append(ele[0].point)\n rdis.append(ele[1])\n return rdis, rlist","def get_max(self):\n if self.root is None: # BC1\n return float('-inf')\n\n current = self.root\n while current.right is not None: # Traverse like a linked-list\n current = current.right\n\n return current.key","def k_nearest_neighbor(self, k, target, current_root, k_nearest_heap): # 1 step\r\n iter_list = [] # a stack to store iteration path # 1 step\r\n # step1: find the 'nearest' leaf\r\n nearest_leaf = current_root # 1 step\r\n while nearest_leaf is not None: # 2 steps: while, is not\r\n iter_list.append(nearest_leaf) # store the path # 1 step\r\n tt = nearest_leaf.point # 2 steps: nearest_leaf.point, tt = \r\n if target[nearest_leaf.axis] < nearest_leaf.point[nearest_leaf.axis]: # 6 steps: if, <, nearest_leaf.axis, nearest_leaf.point, nearest_leaf.point[],target[]\r\n if nearest_leaf.left is not None: # then go to the left child # 3 steps: if, is not, nearest_leaf.left\r\n nearest_leaf = nearest_leaf.left # 2 steps: nearest_leaf.left, nearest_leaf = \r\n else:\r\n break\r\n else:\r\n if nearest_leaf.right is not None: # else, go to the right child\r\n nearest_leaf = nearest_leaf.right\r\n else:\r\n break\r\n while nearest_leaf.left is not None or nearest_leaf.right is not None: # 6 steps: while, is not, or, is not, nearest_leaf.left, nearest_leaf.right\r\n if nearest_leaf.left is not None: # 3 steps: if, is not, nearest_leaf.left\r\n nearest_leaf = nearest_leaf.left # 2 steps: nearest_leaf.left, = \r\n iter_list.append(nearest_leaf) # 1 step\r\n if nearest_leaf.right is not None: # 3 steps: if, is not, nearest_leaf.right\r\n nearest_leaf = nearest_leaf.right # 2 steps: nearest_leaf.right, = \r\n iter_list.append(nearest_leaf) # 1 step\r\n tt = nearest_leaf.point # 2 steps: nearest_leaf.point, tt = \r\n \"\"\"\r\n step2: find the k nearest by backtracking upside\r\n Two situations to add the point into the heap k_nearest_heap\r\n A. when len(k_nearest_heap) < k\r\n B. when dis(point, target) < current_max_dis\r\n \"\"\"\r\n # k_nearest_heap = LargeHeap() # the large heap to store the current 'nearest' neighbors\r\n # the max distance is actually the distance between target and the top of the heap\r\n '''\r\n current_max_dis = self.distance(target, nearest_leaf.point[:self.n_dim])\r\n k_nearest_heap.add(nearest_leaf, current_max_dis)\r\n tmp = iter_list.pop()\r\n '''\r\n former_node = nearest_leaf # the former 'current_node', to indicate whether go through this child\r\n # 1 step\r\n while iter_list != []: # 2 steps: while, !=\r\n if k_nearest_heap.len > 0: # 3 steps: if, k_nearest_heap.len, >\r\n current_max_dis = k_nearest_heap.heaplist[0][1] # 4 steps: k_nearest_heap.heaplist, k_nearest_heap.heaplist[0], k_nearest_heap.heaplist[0][1], current_max_dis =\r\n else:\r\n current_max_dis = -1\r\n current_pointer = iter_list.pop() # 1+38 steps: 1 step - current_pointer = ; 38 steps - iter_list.pop()\r\n tt = current_pointer.point # 2 steps: current_pointer.point, tt=\r\n dis = self.distance(current_pointer.point[:self.n_dim], target) \r\n # 1+11 steps: 1 step - dis=, 11 steps - self.distance()\r\n if k_nearest_heap.len < k:\r\n k_nearest_heap.add(current_pointer, dis)\r\n elif dis < current_max_dis: # 2 steps: elif, <\r\n k_nearest_heap.pop() # 38 steps: k_nearest_heap.pop()\r\n k_nearest_heap.add(current_pointer, dis) # 30 steps: k_nearest_heap.add()\r\n # current_max_dis = self.distance(k_nearest_heap.heaplist[0][0].point[:self.n_dim], target)\r\n current_max_dis = k_nearest_heap.heaplist[0][1] # 4 steps: k_nearest_heap.heaplist, k_nearest_heap.heaplist[],k_nearest_heap.heaplist[][], current_max_dis =\r\n axis = current_pointer.axis # 2 steps: current_pointer.axis, axis = \r\n if abs(target[axis] - current_pointer.point[axis]) >= current_max_dis:\r\n # 6 steps: if, >=, target[axis], - , current_pointer.point[], abs()\r\n former_node = current_pointer # 1 step\r\n # if not intersect with\r\n continue # 1 step\r\n if current_pointer.left is not None and current_pointer.left != former_node:\r\n # 5 steps: if, is not, and, current_pointer.left, !=\r\n tt = current_pointer.left # 2 steps: current_pointer.left, tt =\r\n # iter_list.append(current_pointer.left)\r\n self.k_nearest_neighbor(k, target, current_pointer.left, k_nearest_heap)\r\n # T(n/2) steps: self.k_nearest_neighbor()\r\n if current_pointer.right is not None and current_pointer.right != former_node:\r\n # 5 steps: if, is not, and, current_pointer.left, !=\r\n tt = current_pointer.right # 2 steps: current_pointer.left, tt =\r\n # iter_list.append(current_pointer.righat)\r\n self.k_nearest_neighbor(k, target, current_pointer.right, k_nearest_heap)\r\n # T(n/2) steps: self.k_nearest_neighbor()\r\n former_node = current_pointer # 1 step\r\n rlist = [] # 1 step\r\n rdis = [] # 1 step\r\n for ele in k_nearest_heap.heaplist: # 2 steps: for, in \r\n rlist.append(ele[0].point) # 3 steps: append(), ele[0], ele[0].point\r\n rdis.append(ele[1]) # 2 steps: append(), ele[1]\r\n return rdis, rlist # 1 step\r","def fn(stack, x, k=0):\n if x == 0: return ans.append(stack.copy())\n for i in range(k, len(candidates)):\n if candidates[i] > x: break \n if i > k and candidates[i] == candidates[i-1]: continue\n stack.append(candidates[i])\n fn(stack, x - candidates[i], i+1)\n stack.pop()","def binarySearch(A, k):\n \n #TODO: Implement without using python's in-built functiondef binary(A, k):\n def bSearch(A, k, low, high):\n if high == low:\n if A[low] == k:\n return low\n else:\n return -1\n mid = (low + high)//2\n if A[mid] == k:\n return mid\n elif A[mid] > k:\n if low == mid:\n return -1\n else:\n return bSearch(A, k, low, mid-1)\n else:\n return bSearch(A, k, mid+1, high)\n if isinstance(A, list) == False or isinstance(k, int) == False:\n return -1\n else:\n if len(A) == 0:\n return -1\n else:\n x = bSearch(A, k, 0, len(A)-1)\n return x","def kth_to_last(k, head_node):\n\n # Find length of list \n current = head_node\n\n length = 1\n\n while current.next:\n current = current.next\n length += 1\n\n # Target node is the node at this position\n target = length - k\n\n # Walk through the list again to find the target node\n current = head_node\n\n for i in range(target):\n current = current.next\n\n return current","def largest(n,xs):\n return sorted(xs, reverse = True)[:n][::-1]","def kthPrimeNumber_error(self, k):\n import heapq\n\n h1 = QueueNode(3)\n h2 = QueueNode(5)\n h3 = QueueNode(7)\n\n heap = [h1, h2, h3]\n heapq.heapify(heap)\n\n for cnt in xrange(k-1):\n h = heapq.heappop(heap)\n if h == h1:\n for i in [3, 5, 7]:\n h1.q.append(i*h1.val)\n\n h1.next()\n heapq.heappush(heap, h1)\n elif h == h2:\n for i in [5, 7]:\n h2.q.append(i*h2.val)\n\n h2.next()\n heapq.heappush(heap, h2)\n else:\n for i in [7]:\n h3.q.append(i*h3.val)\n\n h3.next()\n heapq.heappush(heap, h3)\n\n return heapq.heappop(heap).val","def delete_top_from_max_heap(x):\n last = x[-1]\n x = x.at[0].set(last)[:-1]\n return heapify_subtree(x, 0)","def kthsmall(v, k):\n n=len(v)\n k-=1\n if k<0 or k >= n:\n return -1\n l=0\n u=n-1\n while True:\n m=part(v,l,u)\n if m==k: return v[m]\n if m<k: l = m+1\n else: u=m-1","def bfs(self, root: TreeNode) -> int:\n if not root:\n return 0\n queue = deque([(root, 1)])\n while queue:\n node, level = queue.popleft()\n if not node.left and not node.right:\n return level\n if node.left:\n queue.append((node.left, level + 1))\n if node.right:\n queue.append((node.right, level + 1))\n return -1","def find_leaf(self, _key):\n cur_node = self.root\n while type(cur_node) is not leaf:\n\n flag = True\n for i, key in enumerate(cur_node.keys):\n if key > _key:\n cur_node = cur_node.pt[i]\n flag = False\n break\n \n # the value passed in is greater than all the keys in this node\n if flag:\n cur_node = cur_node.pt[-1]\n \n return cur_node","def top_k(indices, words, k):\n inds = np.argpartition(indices, -k)[-k:]\n topkwords = words[inds]\n topkvals = indices[inds]\n top = [(word, val) for word, val in zip(topkwords, topkvals)]\n top = sorted(top, key=lambda t: t[1], reverse=True)\n return top","def fn(stack, x, k=0):\n if x == 0: return ans.append(stack.copy()) #store a copy \n for i in range(k, len(candidates)): \n if candidates[i] > x: break \n stack.append(candidates[i])\n fn(stack, x-candidates[i], i)\n stack.pop()","def top(self, k):\n if not 1 <= k <= len(self):\n raise ValueError('Illegal value for k')\n walk = self._data.first()\n for j in range(k):\n item = walk.element() # element of list is _Item\n yield item._value\n walk = self._data.after(walk)","def rank(self, k, arr):\n\n # arr must be sorted\n if not(arr[0] < arr[len(arr)//2] < arr[len(arr)-1]):\n raise ValueError(\"Array must be sorted\")\n\n lo = 0\n hi = len(arr) - 1\n\n while lo <= hi:\n mid = lo + (hi - lo) // 2\n\n if k < arr[mid]:\n hi = mid - 1\n elif k > arr[mid]:\n lo = mid + 1\n else:\n return mid\n\n return -1","def down(self, i):\n x = self.heap[i]\n n = len(self.heap)\n while True:\n left = 2 * i # climb down the tree\n right = left + 1\n if (right < n and self.heap[right] < x and\n self.heap[right] < self.heap[left]):\n self.heap[i] = self.heap[right]\n self.rank[self.heap[right]] = i # go back up right child\n i = right\n elif left < n and self.heap[left] < x:\n self.heap[i] = self.heap[left]\n self.rank[self.heap[left]] = i # go back up left child\n i = left\n else:\n self.heap[i] = x # insertion index found\n self.rank[x] = i\n return","def heap_select(self, arr, k):\n h = []\n for i in range(len(arr)):\n if i < k:\n heapq.heappush(h, arr[i])\n else:\n heapq.heappush(h, arr[i])\n heapq.heappop(h)\n return h[0]","def find_ge(self, k):\n if self.is_empty():\n return None\n else:\n p = self.find_position(k)\n if p.key() < k:\n p = self.after(p)\n if p is not None:\n return (p.key(), p.value())\n else: \n return None","def order_preserving_k_max(input_tensor, k):\n ndims = input_tensor.shape.ndims\n \n # get indices of topk elements\n indices = tf.nn.top_k(input_tensor, k, sorted=False).indices#shape [d1,d2..,dn-1,k]\n # sort indices of topk elements\n indices = tf.nn.top_k(indices, k, sorted=True).values#shape [d1,d2..,dn-1,k]\n indices = tf.expand_dims(indices, axis=ndims)#shape [d1,d2..,dn-1,1,k]\n\n # build supporting indices for first n-1 dims\n support = tf.meshgrid(*[tf.range(tf.shape(input_tensor)[d])\n for d in xrange(ndims-1)], indexing='ij')#see numpy.meshgrid\n support = tf.stack(support, axis=ndims-1)#shape [d1,d2..,dn-1,ndims-1]\n support = tf.expand_dims(support, axis=ndims-1)#shape [d1,d2..,dn-1,1,ndims-1]\n support = tf.tile(support, [1]*(ndims-1)+[k, 1])#shape [d1,d2..,dn-1,k,ndims-1]\n\n full_indices = tf.concat([support, indices], axis=ndims)#shape [d1,d2..,dn-1,k,ndims]\n output = tf.gather_nd(input_tensor, full_indices)\n \n return output","def get_top_k(cfg):\n score = get_score(cfg)\n oc = get_oc(cfg)\n top_k_open = []\n top_k_close = []\n top_k_global = []\n for score_tup in score:\n coord_id = score_tup[IX_SCORE_COORD_NAME]\n oc_status = oc[coord_id]\n if (len(top_k_global) < K):\n top_k_global.append(coord_id)\n if (oc_status == OC_STATUS_OPEN):\n if (len(top_k_open) < K):\n top_k_open.append(coord_id)\n else:\n if (len(top_k_close) < K):\n top_k_close.append(coord_id)\n if ((len(top_k_close) == K) and (len(top_k_open) == K) and (len(top_k_global) == K)):\n break\n return {\"global\":top_k_global, \"open\":top_k_open, \"close\":top_k_close}","def topk(vec, k):\n vec = torch.topk(vec, k)\n return vec.view(-1).data.tolist()","def maxResult(self, nums: List[int], k: int) -> int:\n # Solution 1 - 964 ms\n # Solution 2 - 864 ms\n n = len(nums)\n if n == 0:\n return 0\n if n == 1:\n return nums[0]\n\n dp = [0] * n\n dp[0] = nums[0]\n max_sum = dp[0]\n max_sum_pointer = 0\n for i in range(1, n):\n if max_sum_pointer >= i - k:\n if max_sum < dp[i - 1] and i > 0:\n max_sum = dp[i - 1]\n max_sum_pointer = i - 1\n else:\n if i - k > 0:\n max_sum = dp[i - k]\n max_sum_pointer = i - k\n for p in range(i - k, i):\n if max_sum <= dp[p]:\n max_sum = dp[p]\n max_sum_pointer = p\n\n dp[i] = max_sum + nums[i]\n\n dp[-1] = max_sum + nums[-1]\n return dp[-1]","def keySetTree(root, klist):\n try:\n if (root is not None):\n keySetTree(root['left'], klist)\n lt.addLast(klist, root['key'])\n keySetTree(root['right'], klist)\n return klist\n except Exception as exp:\n error.reraise(exp, 'BST:keySetTree')","def n_choose_k(n: int, k: int) -> int:\n # Edge case, no possible way to choose.\n if k > n or k < 0 or n < 0: return 0\n # We choose the min of k or n - k\n # since nCk == nC(n - k).\n k = min(k, n - k)\n # The numerator represents the product\n # n * (n - 1) * (n - 2) * ... * (n - k - 1)\n numerator = reduce(mul, range(n, n - k, -1), 1)\n # The denominator represents the product\n # 1 * 2 * ... * k\n denominator = reduce(mul, range(1, k + 1), 1)\n # return the result as an integer.\n return numerator // denominator","def integer_root(n,k):\n # from https://stackoverflow.com/questions/15978781/how-to-find-integer-nth-roots/15979957:\n # Newton's method to find kth root of n\n u, s = n, n+1\n while u < s:\n s = u\n t = (k-1) * s + n // pow(s, k-1)\n u = t // k\n return s","def find_maximum_value(self):\n if self.root: \n self.max_val = self.root.value\n else:\n return 'No tree found'\n def inner(root):\n if root.left:\n inner(root.left)\n\n if root.right:\n inner(root.right)\n\n if self.max_val < root.value:\n self.max_val = root.value\n\n inner(self.root)\n return self.max_val","def sift_down_recursion(self, index):\n if self.size() == 0:\n return\n\n left = self.left_child(index)\n right = self.right_child(index)\n # if the element is leaf\n if left >= self.size():\n return\n\n max_child_index = left\n if right < self.size():\n if self.heap[right] > self.heap[left]:\n max_child_index = right\n\n # if already max heap, return\n if self.heap[index] >= self.heap[max_child_index]:\n return\n\n self.heap[index], self.heap[max_child_index] = self.heap[max_child_index], self.heap[index]\n\n index = max_child_index\n self.sift_down_recursion(index)","def get_subset(h, k, elements):\n n = len(elements)\n maxM = binom(n, k) - 1\n ans = [0] * k\n a = n\n b = k\n # x is the \"dual\" of h.\n x = maxM - h\n for i in range(0, k):\n ans[i] = largestV(a, b, x)\n x -= binom(ans[i], b)\n a = ans[i]\n b = b - 1\n ans = [elements[(n - 1) - ans[i]] for i in range(0, k)]\n return ans","def printMaxdeque(arr, n, k):\n Qi = deque()\n\n # Process first k (or first window) elements of array\n for i in range(k):\n\n # For every element, the previous smaller elements are useless\n # so remove them from Qi\n while Qi and arr[i] >= arr[Qi[-1]]:\n Qi.pop()\n\n # Add new element at rear of queue\n Qi.append(i)\n print(Qi)\n\n # Process rest of the elements, i.e.\n # from arr[k] to arr[n-1]\n for i in range(k, n):\n print(Qi)\n # The element at the front of the\n # queue is the largest element of\n # previous window, so print it\n print(str(arr[Qi[0]]) + \" \", end=\"\")\n\n # Remove the elements which are\n # out of this window\n while Qi and Qi[0] <= i - k:\n # remove from front of deque\n Qi.popleft()\n\n # Remove all elements smaller than\n # the currently being added element\n # (Remove useless elements)\n while Qi and arr[i] >= arr[Qi[-1]]:\n Qi.pop()\n\n # Add current element at the rear of Qi\n Qi.append(i)\n\n # Print the maximum element of last window\n print(str(arr[Qi[0]]))","def test_swap_k_max(self):\r\n self.num2 = [1, 2, 3, 4, 5, 6]\r\n a1.swap_k(self.num2, len(self.num2)//2)\r\n self.assertEqual(self.num2, [4, 5, 6, 1, 2, 3])"],"string":"[\n \"def findKthLargest(self, nums: List[int], k: int) -> int:\\n return sorted(nums)[-k]\",\n \"def _get_k_largest(lst, k):\\n sorted_lst = sorted([(val, index) for index, val in enumerate(lst)])\\n return list(reversed(sorted_lst[-k:]))\",\n \"def kth_largest(arr: list, k: int):\\n # Do not search if k is larger than total number of elements\\n if k > len(arr):\\n raise IndexError\\n # Count all numbers\\n nums = Counter(arr)\\n # Go from the largest to smaller ones\\n for key in sorted(nums, reverse=True):\\n if nums[key] >= k:\\n return key\\n else:\\n k -= nums[key]\",\n \"def test_find_kth_smallest(self):\\n sortedValues = sorted(self.values)[::-1]\\n for index, value in enumerate(sortedValues):\\n valueFound = self.tree.findKthGreatest(index + 1)\\n self.assertEquals(value, valueFound)\",\n \"def _kth_largest(self, k: int, start : int, end : int):\\n # 1. select a random pivot\\n pivotIndex = self.get_pivot_index(start, end)\\n # print('Before partition start, end, pivotIndex ', start, end, pivotIndex)\\n pivotIndex = self.partition(pivotIndex, start, end)\\n # print(f'After partition , data = {data}, pivotIndex = {pivotIndex}')\\n\\n if end-pivotIndex >=k:\\n return self._kth_largest(k, pivotIndex+1, end)\\n \\n elif end-pivotIndex+1 == k:\\n return pivotIndex, self.data[pivotIndex]\\n else:\\n return self._kth_largest(k-1-(end-pivotIndex), start , pivotIndex-1)\",\n \"def kth_smallest(root, k=1):\\n\\n node_status = defaultdict(lambda: 'unvisited')\\n\\n count = 0\\n stack = [root] # A list is a stack.\\n\\n while len(stack) != 0:\\n do_increment = False\\n current_node = stack[-1] # ie peek\\n\\n node_status[current_node] = 'visited'\\n\\n if current_node.left is not None:\\n\\n left_status = node_status[current_node.left]\\n if left_status == 'exited':\\n stack.pop()\\n do_increment = True\\n\\n elif left_status == 'unvisited':\\n stack.append(current_node.left)\\n continue\\n else:\\n stack.pop()\\n do_increment = True\\n\\n if current_node.right is not None:\\n stack.append(current_node.right)\\n\\n if do_increment:\\n node_status[current_node] = 'exited'\\n count += 1\\n if count == k:\\n return current_node.key\\n\\n raise IndexError(\\\"Tree is too small! Only found: {} nodes\\\".format(count))\",\n \"def top_k(self, k):\\n with self.mutating:\\n topk = heapq.nsmallest(k, self.queue)\\n return topk\",\n \"def top_k(self, k = 1):\\n\\t if self.shapley_rank == {}:\\n\\t \\treturn []\\n\\n\\t n = self.nodes\\n\\t topknodes = []\\n\\t i = 0\\n\\t count = 0\\n\\t while count < k and not i == n:\\n\\t if self.shapley_rank[i][0] not in topknodes and not self.is_adj(self.shapley_rank[i][0], topknodes):\\n\\t topknodes.append(self.shapley_rank[i][0])\\n\\t count += 1\\n\\t i += 1\\n\\t i = 0\\n\\t if not count == k:\\n\\t while not count == k:\\n\\t if self.shapley_rank[i][0] not in topknodes:\\n\\t topknodes.append(self.shapley_rank[i][0])\\n\\t count += 1\\n\\t i += 1\\n\\t return topknodes\",\n \"def find_order(input, k):\\n if ( k >= len(input) or k < 0 ):\\n return None\\n elif len(input) == 0:\\n return None\\n elif len(input) == 1:\\n # k should be 0\\n assert k == 0\\n return input[0]\\n else:\\n pivot = input[len(input)//2]\\n left = [x for x in input if x <= pivot]\\n left.remove(pivot)\\n \\n if len(left) == k:\\n return pivot\\n elif len(left) > k:\\n return find_order(left, k)\\n else:\\n right = [x for x in input if x > pivot]\\n return find_order(right, k-1-len(left))\",\n \"def largestSubarray(self, nums: List[int], k: int) -> List[int]:\\n\\n if k == 1:\\n return [max(nums)]\\n\\n hash_map = {}\\n for i, n in enumerate(nums):\\n hash_map[n] = i\\n\\n candidates = nums[: len(nums) - k + 1]\\n print(candidates)\\n mx = max(candidates)\\n mx_idx = hash_map[mx]\\n op = nums[mx_idx : mx_idx + k]\\n return op\",\n \"def heapdown(h, k):\\n\\n #put this value in the correct place\\n v = h[k]\\n\\n while 2 * k < len(h):\\n\\n #assign j to be the left child\\n j = 2 * k\\n\\n #is there a child to the right\\n if j + 1 < len(h):\\n\\n #is the left child smaller than the right child\\n if h[j] < h[j+1]:\\n j = j + 1\\n\\n #if v is greater than its larger child\\n if v >= h[j]:\\n break\\n else:\\n h[k] = h[j]\\n k = j\\n\\n h[k] = v\",\n \"def kth_to_last_recursive(node: Node, k: int):\\n\\n if node == None:\\n return 0\\n\\n index = kth_to_last_recursive(node.next, k) + 1\\n\\n if index == k:\\n print(node.value)\\n\\n return index\",\n \"def swap(root, k):\\n q = deque([(root, 1)])\\n while q:\\n node, level = q.popleft()\\n if node is None:\\n continue\\n if level % k == 0:\\n node.left, node.right = node.right, node.left\\n q.append((node.left, level+1))\\n q.append((node.right, level+1))\",\n \"def top(self, k):\\n if not 1 <= k <= len(self):\\n raise ValueError('Illegal value for k')\\n \\n # making a copy of the original list\\n temp = PositionalList()\\n for item in self._data:\\n temp.add_last(item)\\n\\n # repeatedly find, report, and remove element with largest count\\n for j in range(k):\\n # find and report next highest from temp\\n highPos = temp.first()\\n walk = temp.after(highPos)\\n while walk is not None:\\n if walk.element()._count > highPos.element()._count:\\n highPos = walk\\n walk = temp.after(walk)\\n # found the element with highest count\\n yield highPos.element()._value # report element to user\\n temp.delete(highPos)\",\n \"def top(self, k):\\n if not 1 <= k <= len(self):\\n raise ValueError('illegal value for k')\\n\\n # making a copy of the original list\\n temp = PositionalList()\\n for item in self._data: # positional lists support iteration\\n temp.add_last(item)\\n\\n # repeatedly find, report and remove element with largest count\\n for j in range(k):\\n # find and report next highest from temp\\n highPos = temp.first()\\n walk = temp.after(highPos)\\n while walk is not None:\\n if walk.element()._count > highPos.element()._count:\\n highPos = walk\\n walk = temp.after(walk)\\n # found the element with highest count\\n yield highPos.element()._value # report element to user\\n temp.delete(highPos) # remove from temp list\",\n \"def kth_to_last_recursive_1(self, k):\\n class Index(object):\\n def __init__(self):\\n self.index = 0\\n idx = Index()\\n node = self._kth_to_last_recursive_1(self.head, k, idx)\\n if node is None:\\n raise IndexError('List index out of range')\\n else:\\n return node.value\",\n \"def find_max_in_array(arr, k):\\r\\n print(\\\" Amazon interview question\\\")\\r\\n arr[:] = sorted(arr)\\r\\n return ((arr[len(arr)-k]))\",\n \"def twoSumLessThanK(nums, k):\\n nums.sort()\\n start = 0\\n end = len(nums) - 1\\n max_sum = -1\\n while start < end:\\n curr_sum = nums[start] + nums[end]\\n if curr_sum < k:\\n max_sum = max(curr_sum, max_sum)\\n if curr_sum >= k:\\n end -= 1\\n else:\\n start += 1\\n\\n return max_sum\",\n \"def top_k(a, k=1):\\n if not type(a) is Blob:\\n raise ValueError('`a` should be neoml.Blob.')\\n\\n if int(k) <= 0:\\n raise ValueError('`k` should be > 0.')\\n\\n if a.size == 0:\\n raise ValueError(\\\"The blob shouldn't be empty.\\\")\\n \\n return Blob(PythonWrapper.blob_top_k(a._internal, int(k)))\",\n \"def kth_to_last_recursive(self, k):\\n node, _ = self._kth_to_last_recursive(self.head, k)\\n if node is None:\\n raise IndexError('List index out of range')\\n else:\\n return node.value\",\n \"def _kth_to_last_recursive(self, head, k):\\n if head is None:\\n return None, 0 \\n node, index = self._kth_to_last_recursive(head.next_node, k) \\n index += 1 \\n if index == k:\\n return head, index\\n return node, index\",\n \"def get_top_N(root,n):\\n\\n\\tglobal files\\n\\tfind_files(root)\\n\\theapq.heapify(files)\\n\\tret = heapq.nlargest(n,files)\\n\\tfiles = []\\n\\treturn ret\",\n \"def fetch_top_k(vect, mat, k):\\n resultant = np.dot(mat, vect)\\n arglist = np.argsort(resultant)\\n arglist = arglist[-1:(-1 - k):-1]\\n return arglist, resultant\",\n \"def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\\n max_heap = []\\n item_dict = {}\\n result = []\\n\\n for i in range(len(nums)):\\n item = [-nums[i], False]\\n heapq.heappush(max_heap, item)\\n\\n if nums[i] not in item_dict:\\n item_dict[nums[i]] = [item]\\n else:\\n item_dict[nums[i]].append(item)\\n\\n if i - k >= 0:\\n # \\\"remove\\\" element from heap\\n item_to_remove = nums[i - k]\\n\\n in_heap_item = item_dict[item_to_remove].pop()\\n in_heap_item[1] = True # mark as removed\\n\\n while max_heap[0][1] is True:\\n heapq.heappop(max_heap)\\n\\n result.append(-max_heap[0][0])\\n if i == k - 1:\\n # handle the first window\\n result.append(-max_heap[0][0])\\n\\n return result\",\n \"def top(self, k):\\n if not 1 <= k <= len(self):\\n raise ValueError(\\\"Illegal value for k\\\")\\n temp = PositionalList()\\n for item in self.data:\\n temp.add_last(item)\\n\\n for j in range(k):\\n high_pos = temp.first()\\n walk = temp.after(high_pos)\\n while walk is not None:\\n if walk.element()._count > high_pos.element()._count:\\n high_pos = walk\\n walk = temp.after(walk)\\n yield high_pos.element()._value\\n temp.delete(high_pos)\",\n \"def next_larger(self, k):\\n node = self.find(k)\\n return node and node.next_larger()\",\n \"def top(self, array, key, k):\\n\\n return heapq.nlargest(\\n k,\\n range(len(array)),\\n key\\n )\",\n \"def maxSlidingWindow_v2(self, nums: List[int], k: int) -> List[int]:\\n m_queue = deque()\\n result = []\\n\\n for i in range(len(nums)):\\n while m_queue and m_queue[-1] < nums[i]:\\n m_queue.pop()\\n m_queue.append(nums[i])\\n\\n if i - k >= 0:\\n item_to_remove = nums[i - k]\\n\\n if item_to_remove == m_queue[0]:\\n m_queue.popleft()\\n\\n if i >= k - 1:\\n result.append(m_queue[0])\\n\\n return result\",\n \"def kth_to_last_recursive(head, k):\\n if not head:\\n return 0\\n\\n index = kth_to_last_recursive(head.next(), k)\\n\\n if index == k:\\n print(head.value())\\n\\n index += 1\\n return index\",\n \"def kthSmallest(A, k):\\n if k >= len(A):\\n return None\\n return select(A, 0, len(A) - 1, k)\",\n \"def kth_from_end(self, k):\\n if k < 0:\\n raise ValueError(\\\"Positive integer required\\\")\\n\\n current = self.head\\n arr = []\\n while current:\\n arr.append(current)\\n current = current.next\\n\\n if len(arr) < k:\\n raise IndexError(\\\"Value extends length of List.\\\")\\n\\n arr.reverse()\\n\\n if k == len(arr):\\n k = k - 1\\n return arr[k].value\",\n \"def top_k(input, k=1, sorted=True, index_type=dtypes.int32, name=None): # pylint: disable=redefined-builtin\\n return gen_nn_ops.top_kv2(\\n input, k=k, sorted=sorted, index_type=index_type, name=name\\n )\",\n \"def test_find_kth_smallest(self):\\n sortedValues = sorted(self.values)\\n for index, value in enumerate(sortedValues):\\n valueFound = self.tree.findKthSmallest(index + 1)\\n self.assertEquals(value, valueFound)\",\n \"def next_larger(self, k):\\n node = self.find(k)\\n return node and node.successor()\",\n \"def find_top_k(predictions, boxes, k):\\r\\n\\r\\n if predictions.shape[0] == 0:\\r\\n predictions2 = torch.Tensor([]).to(device)\\r\\n labels2 = torch.Tensor([]).to(device)\\r\\n boxes2 = torch.Tensor([]).to(device)\\r\\n scores2 = torch.Tensor([]).to(device)\\r\\n\\r\\n else:\\r\\n predictions0 = predictions\\r\\n scores0 = torch.max(predictions0, dim=1)[0]\\r\\n labels0 = torch.argmax(predictions0, dim=1)\\r\\n boxes0 = boxes\\r\\n\\r\\n sort = torch.argsort(scores0, descending=True)\\r\\n boxes1, labels1, scores1, predictions1 = boxes0[sort], labels0[sort], scores0[sort], predictions0[sort]\\r\\n\\r\\n boxes2, labels2, scores2, predictions2 = boxes1[:k], labels1[:k] + 1, scores1[:k], predictions1[:k]\\r\\n\\r\\n return predictions2, boxes2, labels2, scores2\",\n \"def max_heapify(lst, n, root):\\n\\n largest = root\\n l = 2 * root + 1\\n r = 2 * root + 2\\n\\n if l < n and lst[l] > lst[largest]:\\n largest = l\\n if r < n and lst[r] > lst[largest]:\\n largest = r\\n if largest != root:\\n lst[root], lst[largest] = lst[largest], lst[root]\\n max_heapify(lst, n, largest)\",\n \"def findChildB(T,k):\\r\\n for i in range(len(T.data)):\\r\\n if k < T.data[i].word:\\r\\n return i\\r\\n return len(T.data)\",\n \"def _kth_to_last_iterative(self, head, k): #\\n node1 = head\\n node2 = None \\n flag = False \\n i = 0 \\n while node1 is not None:\\n i += 1 \\n node1 = node1.next_node \\n if flag: \\n node2 = node2.next_node \\n if i == k:\\n flag = True \\n node2 = head \\n return node2\",\n \"def findMaximumSubarraySlidingWindow(self, k, nums):\\n window_start, window_sum, window_max= 0, 0, 0\\n for i in range(len(nums)):\\n window_sum += nums[i] #add the next element\\n # slide the window, we don't need to slide if we have not hit the required window size of K\\n if i >= k-1:\\n window_max = max(window_sum, window_max) # calculate the maximum sum\\n window_sum -= nums[window_start] #substract the element going out\\n window_start += 1 #slide the window ahead\\n return window_max\",\n \"def topKFrequent(self, nums, k):\\n\\n # Generate dictionary of frequencies\\n frequency = defaultdict(int)\\n for num in nums:\\n frequency[num] += 1\\n\\n k_most = []\\n # Grab the k most frequent values, sorted descending\\n for val in sorted(frequency.values())[::-1][:k]:\\n # Append the associated key to k_most if it isn't already there\\n k_most.append([key for key, value in frequency.items() if (value == val and not key in k_most)][0])\\n return k_most\",\n \"def sorted_top_k(item_counts, k):\\n # Partitioning runs in O(d) time.\\n top_k_unsorted = np.argpartition(-item_counts, k - 1)[:k]\\n # Sorting highest k counts runs in O(k * log(k)) time.\\n sorting_order = np.argsort(item_counts[top_k_unsorted])[::-1]\\n return top_k_unsorted[sorting_order]\",\n \"def get_top_k(matrix,k):\\n assert k <= matrix.shape[1]\\n col_inds = np.argpartition(matrix, -k)[:,-k:].flatten()\\n row_inds = np.repeat(range(matrix.shape[0]),k)\\n\\n vals = matrix[row_inds, col_inds]\\n\\n return vals, col_inds\",\n \"def kth_to_last_iterative(self, k):\\n node = self._kth_to_last_iterative(self.head, k)\\n if node is None:\\n raise IndexError('List index out of range')\\n else:\\n return node.value\",\n \"def convert_topk(g, op, block):\\n\\n data = g.get_node(op.input(\\\"X\\\")[0])\\n if op.input(\\\"K\\\"):\\n k = g.get_node(op.input(\\\"K\\\")[0])\\n else:\\n k = op.attr(\\\"k\\\")\\n\\n largest = True\\n axis = -1\\n if op.has_attr(\\\"axis\\\"):\\n axis = op.attr(\\\"axis\\\")\\n if op.has_attr(\\\"largest\\\"):\\n largest = op.attr(\\\"largest\\\")\\n is_ascend = not largest\\n\\n value_names = op.output(\\\"Out\\\")\\n indice_names = op.output(\\\"Indices\\\")\\n\\n out = None\\n indice = None\\n if value_names and indice_names:\\n out, indice = _op.topk(data=data, k=k, axis=axis, ret_type=\\\"both\\\", is_ascend=is_ascend)\\n elif value_names:\\n out = _op.topk(data=data, k=k, axis=axis, ret_type=\\\"values\\\", is_ascend=is_ascend)\\n elif indice_names:\\n indice = _op.topk(data=data, k=k, axis=axis, ret_type=\\\"indices\\\", is_ascend=is_ascend)\\n\\n if out is not None:\\n g.add_node(value_names[0], out)\\n if indice is not None:\\n g.add_node(indice_names[0], indice)\",\n \"def rank_k_element(A, B, k):\\n if len(A) + len(B) < k:\\n return None\\n i = 0\\n j = 0\\n while i < len(A) and j < len(B) and k:\\n if A[i] < B[j]:\\n rank = A[i]\\n i += 1\\n else:\\n rank = B[j]\\n j += 1\\n k -= 1\\n if not k:\\n return rank\\n if i == len(A):\\n z = j\\n P = B\\n else:\\n z = i\\n P = A\\n while k:\\n rank = P[z]\\n z += 1\\n k -= 1\\n return rank\",\n \"def get_min_depth(l_k):\\n return max(l_k.values())\",\n \"def search_highest_k_neighbor(self, k):\\n max_score = 0\\n target_node = None\\n from_idx = None\\n to_idx = None\\n for i in range(k):\\n node = self.graph.nodes[random.randrange(len(self.graph.nodes))]\\n cluster_idx = self.search_cluster_by_node(node)\\n if len(self.result[cluster_idx].get_nodes()) == 1:\\n end_i = len(self.result)\\n else:\\n end_i = len(self.result) + 1\\n\\n random_cluster_idx = random.randrange(end_i)\\n if random_cluster_idx != cluster_idx:\\n tried_score = self.try_replace_node(node, cluster_idx, random_cluster_idx)\\n if max_score < tried_score:\\n max_score = tried_score\\n target_node = node\\n from_idx = cluster_idx\\n to_idx = random_cluster_idx\\n\\n return max_score, target_node, from_idx, to_idx\",\n \"def indices_of_top_k(arr, k):\\n return np.sort(np.argpartition(np.array(arr), -k)[-k:])\",\n \"def tf_top_k_probs(probs, k):\\n\\n if k > 0:\\n return probs.argsort()[-k:][::-1]\\n else:\\n return probs.argsort()[:][::-1]\",\n \"def top_k(m, k):\\n ml = m.tolil()\\n ms = [_top_k(d, r, k) for d, r in zip(ml.data, ml.rows)]\\n return zip(*ms)\",\n \"def first_larger(array, k):\\n\\t\\n\\t# check if array is None, empty,...\\n\\tif array is None or len(array) == 0:\\n\\t\\treturn False\\n\\n\\tif array[-1] <= k:\\n\\t\\treturn False\\n\\n\\tbegin = 0\\n\\tend = len(array)\\n\\n\\twhile begin + 1 < end:\\n\\t\\tmed = begin + (end-begin) / 2\\n\\t\\tif array[med] == k: \\n\\t\\t\\twhile array[med] == k:\\n\\t\\t\\t\\tmed += 1\\n\\t\\t\\treturn med\\n\\t\\telif array[med] > k:\\n\\t\\t\\tend = med\\n\\t\\telse:\\n\\t\\t\\tbegin = med\\n\\n\\treturn end\",\n \"def fn(n, k):\\n if k == 1: return n \\n if n == 0: return 0 \\n ans = inf \\n for x in range(1, n+1): \\n ans = min(ans, 1 + max(fn(x-1, k-1), fn(n-x, k)))\\n return ans\",\n \"def nchoosek(n, k):\\n if n < k:\\n return 0\\n return partition(n, [k, n - k])\",\n \"def heightTree(root):\\n try:\\n if (root is None):\\n return -1\\n else:\\n return 1 + max(heightTree(root['left']), heightTree(root['right']))\\n except Exception as exp:\\n error.reraise(exp, 'RBT:heightTree')\",\n \"def down_heap(array, k, n):\\n new_elem = array[k]\\n while k <= n / 2:\\n child = 2 * k\\n if child < n and array[child] < array[child + 1]:\\n child += 1\\n if new_elem >= array[child]:\\n break\\n array[k] = array[child]\\n k = child\\n array[k] = new_elem\",\n \"def find_max_average_sub(nums, k):\\n\\n\\n\\tresult = sum(nums[:k]) / k\\n\\tcurrent = result\\n\\n\\tfor i in range(1, len(nums) - k + 1):\\n\\n\\t\\tcurrent = (current * k - nums[i - 1] +\\\\\\n\\t\\t nums[i + k - 1]) / k\\n\\n\\t\\tif result < current:\\n\\t\\t\\tresult = current\\n\\n\\n\\treturn result\",\n \"def findKthNumber(self, m: int, n: int, k: int) -> int:\\n l, r = 1, m * n\\n while l < r:\\n mid = l + ((r - l) >> 1)\\n\\n # Check if there are k or more values that are less than mid.\\n # For each row, its elements look like 1*i, 2*i, ... n*i, so the\\n # largest number that is less than x will be x // i. But if x is\\n # too large for the current row, the total count for this row\\n # will be n instead.\\n if sum(min(mid // r, n) for r in range(1, m + 1)) >= k:\\n # mid is our candidate.\\n r = mid\\n else:\\n l = mid + 1\\n\\n return l\",\n \"def _find_max(self, root):\\n while root.right:\\n root = root.right\\n return root\",\n \"def top_view(root):\\n\\n if root is None:\\n return\\n\\n # make an empty queue for BFS\\n q = deque()\\n\\n # empty set\\n sets = set({})\\n\\n # list to store top view keys\\n topview = []\\n\\n # append root in the queue with horizontal distance as 0\\n q.append((root, 0))\\n\\n while q:\\n # get the element and horizontal distance\\n elem, d = q.popleft()\\n\\n # if the hd is seen first time it will be top view\\n if d not in sets:\\n topview.append((elem.data, d))\\n sets.add(d)\\n\\n # add left and right child in the queue with hd - 1 and hd + 1\\n if elem.left is not None:\\n q.append((elem.left, d - 1))\\n if elem.right is not None:\\n q.append((elem.right, d + 1))\\n\\n # return the sorted topview on the basis of hd\\n return sorted(topview, key=lambda x: x[1])\",\n \"def max_heapify(array, root):\\n print(array)\\n while True:\\n left_child = 2*i\\n right_child = 2*i + 1\\n print(left_child, right_child)\\n n = len(array)\\n\\n if left_child <= n and array[left_child] > array[i]:\\n largest = left_child\\n else:\\n largest = i\\n print(right_child)\\n print('largest index',largest)\\n if right_child <= n and array[right_child] > array[largest]:\\n largest = right_child\\n print(array[largest])\\n\\n if largest != i:\\n a, b = array.index(array[i]), array.index(array[largest])\\n array[b], array[a] = array[a], array[b]\\n print(largest)\\n return max_heapify(array, largest)\",\n \"def top_k_frequent_elements(nums, k):\\r\\n freq_dict = {}\\r\\n for elem in nums:\\r\\n freq_dict[elem] = freq_dict.get(elem, 0) + 1\\r\\n \\r\\n return sorted(freq_dict.keys(), key= lambda x: freq_dict[x], reverse=True)[:k]\",\n \"def kth_to_last(l_list, k=1):\\n if not l_list:\\n return\\n\\n if k > len(l_list):\\n return\\n\\n runner = l_list.head()\\n for i in range(k):\\n if runner.next(): # Prevent the runner to become None in case the last element is asked for.\\n runner = runner.next()\\n\\n curr = l_list.head()\\n while runner.next():\\n runner = runner.next()\\n curr = curr.next()\\n\\n return curr.value()\",\n \"def build_most_significant_tree(ktree, outputdir):\\n stree = Tree()\\n root = max(ktree.parents.keys())\\n for cpt, popval in ktree.population.items():\\n if popval == 1:\\n stree.population[cpt] = 1\\n _iter_build_most_significant_tree(ktree, stree, root)\\n with open(os.path.join(outputdir, \\\"most_significant_tree.p\\\"), \\\"wb\\\") as f:\\n pickle.dump(stree, f)\\n return stree\",\n \"def tflite_top_k_probs(probs, k):\\n\\n if k > 0:\\n return np.flip(probs[0].argsort()[-k:])\\n else:\\n return np.flip(probs[0].argsort())\",\n \"def get_sliding_window_max(numbers: Sequence[int], k: int) -> Iterable[int]:\\n\\n assert 1 <= k <= len(numbers)\\n\\n # Deque to store useful for calculation number indices.\\n dq: Deque[int] = deque()\\n\\n for i in range(k):\\n while dq and numbers[dq[-1]] < numbers[i]:\\n dq.pop()\\n\\n dq.append(i)\\n\\n yield numbers[dq[0]]\\n\\n for i in range(k, len(numbers)):\\n while dq[0] <= i - k:\\n dq.popleft()\\n\\n while dq and numbers[dq[-1]] < numbers[i]:\\n dq.pop()\\n\\n dq.append(i)\\n\\n yield numbers[dq[0]]\",\n \"def _my_top_k(x, k):\\n if k > 10:\\n return tf.nn.top_k(x, k)\\n values = []\\n indices = []\\n depth = tf.shape(x)[1]\\n for i in range(k):\\n values.append(tf.reduce_max(x, 1))\\n argmax = tf.argmax(x, 1)\\n indices.append(argmax)\\n if i + 1 < k:\\n x += tf.one_hot(argmax, depth, -1e9)\\n return tf.stack(values, axis=1), tf.to_int32(tf.stack(indices, axis=1))\",\n \"def quick_select(lst, k):\\n if lst != []:\\n pivot = lst[(len(lst)//2)]\\n smallerlist = []\\n largerlist = []\\n count = 0\\n for i in range(0,len(lst)):\\n if lst[i] == pivot:\\n count += 1\\n elif lst[i] < pivot:\\n smallerlist.append(lst[i])\\n elif lst[i] > pivot:\\n largerlist.append(lst[i])\\n m = len(smallerlist)\\n if k >= m and k < m + count:\\n return pivot\\n elif m > k:\\n return quick_select(smallerlist, k)\\n else:\\n return quick_select(largerlist,k - m - count)\",\n \"def fn(arr, k):\\n ans = []\\n for i, x in enumerate(arr): \\n while ans and ans[-1] < x and len(ans) + len(arr) - i > k: ans.pop()\\n if len(ans) < k: ans.append(x)\\n return ans\",\n \"def solve_sort(self):\\n if self.k < 0 or self.k > len(self.numbers):\\n return None\\n\\n self.numbers.sort() # in place\\n return self.numbers[-self.k]\",\n \"def k_nearest_neighbor(self, k, target, current_root, k_nearest_heap = LargeHeap()):\\n iter_list = [] # a stack to store iteration path\\n # step1: find the 'nearest' leaf\\n nearest_leaf = current_root\\n while nearest_leaf is not None:\\n iter_list.append(nearest_leaf) # store the path\\n tt = nearest_leaf.point\\n tt1 = nearest_leaf.axis\\n if target[nearest_leaf.axis] < nearest_leaf.point[nearest_leaf.axis]:\\n if nearest_leaf.left is not None: # then go to the left child\\n nearest_leaf = nearest_leaf.left\\n else:\\n break\\n else:\\n if nearest_leaf.right is not None: # else, go to the right child\\n nearest_leaf = nearest_leaf.right\\n else:\\n break\\n while nearest_leaf.left is not None or nearest_leaf.right is not None:\\n if nearest_leaf.left is not None:\\n nearest_leaf = nearest_leaf.left\\n iter_list.append(nearest_leaf)\\n if nearest_leaf.right is not None:\\n nearest_leaf = nearest_leaf.right\\n iter_list.append(nearest_leaf)\\n tt = nearest_leaf.point\\n \\\"\\\"\\\"\\n step2: find the k nearest by backtracking upside\\n Two situations to add the point into the heap k_nearest_heap\\n A. when len(k_nearest_heap) < k\\n B. when dis(point, target) < current_max_dis\\n \\\"\\\"\\\"\\n # k_nearest_heap = LargeHeap() # the large heap to store the current 'nearest' neighbors\\n # the max distance is actually the distance between target and the top of the heap\\n '''\\n current_max_dis = self.distance(target, nearest_leaf.point[:self.n_dim])\\n k_nearest_heap.add(nearest_leaf, current_max_dis)\\n tmp = iter_list.pop()\\n '''\\n former_node = nearest_leaf # the former 'current_node', to indicate whether go through this child\\n while iter_list != []:\\n if k_nearest_heap.len > 0:\\n current_max_dis = k_nearest_heap.heaplist[0][1]\\n else:\\n current_max_dis = -1\\n current_pointer = iter_list.pop()\\n tt = current_pointer.point\\n dis = self.distance(current_pointer.point[:self.n_dim], target)\\n if k_nearest_heap.len < k:\\n k_nearest_heap.add(current_pointer, dis)\\n elif dis < current_max_dis:\\n k_nearest_heap.pop()\\n k_nearest_heap.add(current_pointer, dis)\\n # current_max_dis = self.distance(k_nearest_heap.heaplist[0][0].point[:self.n_dim], target)\\n current_max_dis = k_nearest_heap.heaplist[0][1]\\n axis = current_pointer.axis\\n if abs(target[axis] - current_pointer.point[axis]) >= current_max_dis:\\n former_node = current_pointer\\n # if not intersect with\\n continue\\n if current_pointer.left is not None and current_pointer.left != former_node:\\n tt = current_pointer.left\\n # iter_list.append(current_pointer.left)\\n self.k_nearest_neighbor(k, target, current_pointer.left, k_nearest_heap)\\n if current_pointer.right is not None and current_pointer.right != former_node:\\n tt = current_pointer.right\\n # iter_list.append(current_pointer.righat)\\n self.k_nearest_neighbor(k, target, current_pointer.right, k_nearest_heap)\\n former_node = current_pointer\\n rlist = []\\n rdis = []\\n for ele in k_nearest_heap.heaplist:\\n rlist.append(ele[0].point)\\n rdis.append(ele[1])\\n return rdis, rlist\",\n \"def get_max(self):\\n if self.root is None: # BC1\\n return float('-inf')\\n\\n current = self.root\\n while current.right is not None: # Traverse like a linked-list\\n current = current.right\\n\\n return current.key\",\n \"def k_nearest_neighbor(self, k, target, current_root, k_nearest_heap): # 1 step\\r\\n iter_list = [] # a stack to store iteration path # 1 step\\r\\n # step1: find the 'nearest' leaf\\r\\n nearest_leaf = current_root # 1 step\\r\\n while nearest_leaf is not None: # 2 steps: while, is not\\r\\n iter_list.append(nearest_leaf) # store the path # 1 step\\r\\n tt = nearest_leaf.point # 2 steps: nearest_leaf.point, tt = \\r\\n if target[nearest_leaf.axis] < nearest_leaf.point[nearest_leaf.axis]: # 6 steps: if, <, nearest_leaf.axis, nearest_leaf.point, nearest_leaf.point[],target[]\\r\\n if nearest_leaf.left is not None: # then go to the left child # 3 steps: if, is not, nearest_leaf.left\\r\\n nearest_leaf = nearest_leaf.left # 2 steps: nearest_leaf.left, nearest_leaf = \\r\\n else:\\r\\n break\\r\\n else:\\r\\n if nearest_leaf.right is not None: # else, go to the right child\\r\\n nearest_leaf = nearest_leaf.right\\r\\n else:\\r\\n break\\r\\n while nearest_leaf.left is not None or nearest_leaf.right is not None: # 6 steps: while, is not, or, is not, nearest_leaf.left, nearest_leaf.right\\r\\n if nearest_leaf.left is not None: # 3 steps: if, is not, nearest_leaf.left\\r\\n nearest_leaf = nearest_leaf.left # 2 steps: nearest_leaf.left, = \\r\\n iter_list.append(nearest_leaf) # 1 step\\r\\n if nearest_leaf.right is not None: # 3 steps: if, is not, nearest_leaf.right\\r\\n nearest_leaf = nearest_leaf.right # 2 steps: nearest_leaf.right, = \\r\\n iter_list.append(nearest_leaf) # 1 step\\r\\n tt = nearest_leaf.point # 2 steps: nearest_leaf.point, tt = \\r\\n \\\"\\\"\\\"\\r\\n step2: find the k nearest by backtracking upside\\r\\n Two situations to add the point into the heap k_nearest_heap\\r\\n A. when len(k_nearest_heap) < k\\r\\n B. when dis(point, target) < current_max_dis\\r\\n \\\"\\\"\\\"\\r\\n # k_nearest_heap = LargeHeap() # the large heap to store the current 'nearest' neighbors\\r\\n # the max distance is actually the distance between target and the top of the heap\\r\\n '''\\r\\n current_max_dis = self.distance(target, nearest_leaf.point[:self.n_dim])\\r\\n k_nearest_heap.add(nearest_leaf, current_max_dis)\\r\\n tmp = iter_list.pop()\\r\\n '''\\r\\n former_node = nearest_leaf # the former 'current_node', to indicate whether go through this child\\r\\n # 1 step\\r\\n while iter_list != []: # 2 steps: while, !=\\r\\n if k_nearest_heap.len > 0: # 3 steps: if, k_nearest_heap.len, >\\r\\n current_max_dis = k_nearest_heap.heaplist[0][1] # 4 steps: k_nearest_heap.heaplist, k_nearest_heap.heaplist[0], k_nearest_heap.heaplist[0][1], current_max_dis =\\r\\n else:\\r\\n current_max_dis = -1\\r\\n current_pointer = iter_list.pop() # 1+38 steps: 1 step - current_pointer = ; 38 steps - iter_list.pop()\\r\\n tt = current_pointer.point # 2 steps: current_pointer.point, tt=\\r\\n dis = self.distance(current_pointer.point[:self.n_dim], target) \\r\\n # 1+11 steps: 1 step - dis=, 11 steps - self.distance()\\r\\n if k_nearest_heap.len < k:\\r\\n k_nearest_heap.add(current_pointer, dis)\\r\\n elif dis < current_max_dis: # 2 steps: elif, <\\r\\n k_nearest_heap.pop() # 38 steps: k_nearest_heap.pop()\\r\\n k_nearest_heap.add(current_pointer, dis) # 30 steps: k_nearest_heap.add()\\r\\n # current_max_dis = self.distance(k_nearest_heap.heaplist[0][0].point[:self.n_dim], target)\\r\\n current_max_dis = k_nearest_heap.heaplist[0][1] # 4 steps: k_nearest_heap.heaplist, k_nearest_heap.heaplist[],k_nearest_heap.heaplist[][], current_max_dis =\\r\\n axis = current_pointer.axis # 2 steps: current_pointer.axis, axis = \\r\\n if abs(target[axis] - current_pointer.point[axis]) >= current_max_dis:\\r\\n # 6 steps: if, >=, target[axis], - , current_pointer.point[], abs()\\r\\n former_node = current_pointer # 1 step\\r\\n # if not intersect with\\r\\n continue # 1 step\\r\\n if current_pointer.left is not None and current_pointer.left != former_node:\\r\\n # 5 steps: if, is not, and, current_pointer.left, !=\\r\\n tt = current_pointer.left # 2 steps: current_pointer.left, tt =\\r\\n # iter_list.append(current_pointer.left)\\r\\n self.k_nearest_neighbor(k, target, current_pointer.left, k_nearest_heap)\\r\\n # T(n/2) steps: self.k_nearest_neighbor()\\r\\n if current_pointer.right is not None and current_pointer.right != former_node:\\r\\n # 5 steps: if, is not, and, current_pointer.left, !=\\r\\n tt = current_pointer.right # 2 steps: current_pointer.left, tt =\\r\\n # iter_list.append(current_pointer.righat)\\r\\n self.k_nearest_neighbor(k, target, current_pointer.right, k_nearest_heap)\\r\\n # T(n/2) steps: self.k_nearest_neighbor()\\r\\n former_node = current_pointer # 1 step\\r\\n rlist = [] # 1 step\\r\\n rdis = [] # 1 step\\r\\n for ele in k_nearest_heap.heaplist: # 2 steps: for, in \\r\\n rlist.append(ele[0].point) # 3 steps: append(), ele[0], ele[0].point\\r\\n rdis.append(ele[1]) # 2 steps: append(), ele[1]\\r\\n return rdis, rlist # 1 step\\r\",\n \"def fn(stack, x, k=0):\\n if x == 0: return ans.append(stack.copy())\\n for i in range(k, len(candidates)):\\n if candidates[i] > x: break \\n if i > k and candidates[i] == candidates[i-1]: continue\\n stack.append(candidates[i])\\n fn(stack, x - candidates[i], i+1)\\n stack.pop()\",\n \"def binarySearch(A, k):\\n \\n #TODO: Implement without using python's in-built functiondef binary(A, k):\\n def bSearch(A, k, low, high):\\n if high == low:\\n if A[low] == k:\\n return low\\n else:\\n return -1\\n mid = (low + high)//2\\n if A[mid] == k:\\n return mid\\n elif A[mid] > k:\\n if low == mid:\\n return -1\\n else:\\n return bSearch(A, k, low, mid-1)\\n else:\\n return bSearch(A, k, mid+1, high)\\n if isinstance(A, list) == False or isinstance(k, int) == False:\\n return -1\\n else:\\n if len(A) == 0:\\n return -1\\n else:\\n x = bSearch(A, k, 0, len(A)-1)\\n return x\",\n \"def kth_to_last(k, head_node):\\n\\n # Find length of list \\n current = head_node\\n\\n length = 1\\n\\n while current.next:\\n current = current.next\\n length += 1\\n\\n # Target node is the node at this position\\n target = length - k\\n\\n # Walk through the list again to find the target node\\n current = head_node\\n\\n for i in range(target):\\n current = current.next\\n\\n return current\",\n \"def largest(n,xs):\\n return sorted(xs, reverse = True)[:n][::-1]\",\n \"def kthPrimeNumber_error(self, k):\\n import heapq\\n\\n h1 = QueueNode(3)\\n h2 = QueueNode(5)\\n h3 = QueueNode(7)\\n\\n heap = [h1, h2, h3]\\n heapq.heapify(heap)\\n\\n for cnt in xrange(k-1):\\n h = heapq.heappop(heap)\\n if h == h1:\\n for i in [3, 5, 7]:\\n h1.q.append(i*h1.val)\\n\\n h1.next()\\n heapq.heappush(heap, h1)\\n elif h == h2:\\n for i in [5, 7]:\\n h2.q.append(i*h2.val)\\n\\n h2.next()\\n heapq.heappush(heap, h2)\\n else:\\n for i in [7]:\\n h3.q.append(i*h3.val)\\n\\n h3.next()\\n heapq.heappush(heap, h3)\\n\\n return heapq.heappop(heap).val\",\n \"def delete_top_from_max_heap(x):\\n last = x[-1]\\n x = x.at[0].set(last)[:-1]\\n return heapify_subtree(x, 0)\",\n \"def kthsmall(v, k):\\n n=len(v)\\n k-=1\\n if k<0 or k >= n:\\n return -1\\n l=0\\n u=n-1\\n while True:\\n m=part(v,l,u)\\n if m==k: return v[m]\\n if m<k: l = m+1\\n else: u=m-1\",\n \"def bfs(self, root: TreeNode) -> int:\\n if not root:\\n return 0\\n queue = deque([(root, 1)])\\n while queue:\\n node, level = queue.popleft()\\n if not node.left and not node.right:\\n return level\\n if node.left:\\n queue.append((node.left, level + 1))\\n if node.right:\\n queue.append((node.right, level + 1))\\n return -1\",\n \"def find_leaf(self, _key):\\n cur_node = self.root\\n while type(cur_node) is not leaf:\\n\\n flag = True\\n for i, key in enumerate(cur_node.keys):\\n if key > _key:\\n cur_node = cur_node.pt[i]\\n flag = False\\n break\\n \\n # the value passed in is greater than all the keys in this node\\n if flag:\\n cur_node = cur_node.pt[-1]\\n \\n return cur_node\",\n \"def top_k(indices, words, k):\\n inds = np.argpartition(indices, -k)[-k:]\\n topkwords = words[inds]\\n topkvals = indices[inds]\\n top = [(word, val) for word, val in zip(topkwords, topkvals)]\\n top = sorted(top, key=lambda t: t[1], reverse=True)\\n return top\",\n \"def fn(stack, x, k=0):\\n if x == 0: return ans.append(stack.copy()) #store a copy \\n for i in range(k, len(candidates)): \\n if candidates[i] > x: break \\n stack.append(candidates[i])\\n fn(stack, x-candidates[i], i)\\n stack.pop()\",\n \"def top(self, k):\\n if not 1 <= k <= len(self):\\n raise ValueError('Illegal value for k')\\n walk = self._data.first()\\n for j in range(k):\\n item = walk.element() # element of list is _Item\\n yield item._value\\n walk = self._data.after(walk)\",\n \"def rank(self, k, arr):\\n\\n # arr must be sorted\\n if not(arr[0] < arr[len(arr)//2] < arr[len(arr)-1]):\\n raise ValueError(\\\"Array must be sorted\\\")\\n\\n lo = 0\\n hi = len(arr) - 1\\n\\n while lo <= hi:\\n mid = lo + (hi - lo) // 2\\n\\n if k < arr[mid]:\\n hi = mid - 1\\n elif k > arr[mid]:\\n lo = mid + 1\\n else:\\n return mid\\n\\n return -1\",\n \"def down(self, i):\\n x = self.heap[i]\\n n = len(self.heap)\\n while True:\\n left = 2 * i # climb down the tree\\n right = left + 1\\n if (right < n and self.heap[right] < x and\\n self.heap[right] < self.heap[left]):\\n self.heap[i] = self.heap[right]\\n self.rank[self.heap[right]] = i # go back up right child\\n i = right\\n elif left < n and self.heap[left] < x:\\n self.heap[i] = self.heap[left]\\n self.rank[self.heap[left]] = i # go back up left child\\n i = left\\n else:\\n self.heap[i] = x # insertion index found\\n self.rank[x] = i\\n return\",\n \"def heap_select(self, arr, k):\\n h = []\\n for i in range(len(arr)):\\n if i < k:\\n heapq.heappush(h, arr[i])\\n else:\\n heapq.heappush(h, arr[i])\\n heapq.heappop(h)\\n return h[0]\",\n \"def find_ge(self, k):\\n if self.is_empty():\\n return None\\n else:\\n p = self.find_position(k)\\n if p.key() < k:\\n p = self.after(p)\\n if p is not None:\\n return (p.key(), p.value())\\n else: \\n return None\",\n \"def order_preserving_k_max(input_tensor, k):\\n ndims = input_tensor.shape.ndims\\n \\n # get indices of topk elements\\n indices = tf.nn.top_k(input_tensor, k, sorted=False).indices#shape [d1,d2..,dn-1,k]\\n # sort indices of topk elements\\n indices = tf.nn.top_k(indices, k, sorted=True).values#shape [d1,d2..,dn-1,k]\\n indices = tf.expand_dims(indices, axis=ndims)#shape [d1,d2..,dn-1,1,k]\\n\\n # build supporting indices for first n-1 dims\\n support = tf.meshgrid(*[tf.range(tf.shape(input_tensor)[d])\\n for d in xrange(ndims-1)], indexing='ij')#see numpy.meshgrid\\n support = tf.stack(support, axis=ndims-1)#shape [d1,d2..,dn-1,ndims-1]\\n support = tf.expand_dims(support, axis=ndims-1)#shape [d1,d2..,dn-1,1,ndims-1]\\n support = tf.tile(support, [1]*(ndims-1)+[k, 1])#shape [d1,d2..,dn-1,k,ndims-1]\\n\\n full_indices = tf.concat([support, indices], axis=ndims)#shape [d1,d2..,dn-1,k,ndims]\\n output = tf.gather_nd(input_tensor, full_indices)\\n \\n return output\",\n \"def get_top_k(cfg):\\n score = get_score(cfg)\\n oc = get_oc(cfg)\\n top_k_open = []\\n top_k_close = []\\n top_k_global = []\\n for score_tup in score:\\n coord_id = score_tup[IX_SCORE_COORD_NAME]\\n oc_status = oc[coord_id]\\n if (len(top_k_global) < K):\\n top_k_global.append(coord_id)\\n if (oc_status == OC_STATUS_OPEN):\\n if (len(top_k_open) < K):\\n top_k_open.append(coord_id)\\n else:\\n if (len(top_k_close) < K):\\n top_k_close.append(coord_id)\\n if ((len(top_k_close) == K) and (len(top_k_open) == K) and (len(top_k_global) == K)):\\n break\\n return {\\\"global\\\":top_k_global, \\\"open\\\":top_k_open, \\\"close\\\":top_k_close}\",\n \"def topk(vec, k):\\n vec = torch.topk(vec, k)\\n return vec.view(-1).data.tolist()\",\n \"def maxResult(self, nums: List[int], k: int) -> int:\\n # Solution 1 - 964 ms\\n # Solution 2 - 864 ms\\n n = len(nums)\\n if n == 0:\\n return 0\\n if n == 1:\\n return nums[0]\\n\\n dp = [0] * n\\n dp[0] = nums[0]\\n max_sum = dp[0]\\n max_sum_pointer = 0\\n for i in range(1, n):\\n if max_sum_pointer >= i - k:\\n if max_sum < dp[i - 1] and i > 0:\\n max_sum = dp[i - 1]\\n max_sum_pointer = i - 1\\n else:\\n if i - k > 0:\\n max_sum = dp[i - k]\\n max_sum_pointer = i - k\\n for p in range(i - k, i):\\n if max_sum <= dp[p]:\\n max_sum = dp[p]\\n max_sum_pointer = p\\n\\n dp[i] = max_sum + nums[i]\\n\\n dp[-1] = max_sum + nums[-1]\\n return dp[-1]\",\n \"def keySetTree(root, klist):\\n try:\\n if (root is not None):\\n keySetTree(root['left'], klist)\\n lt.addLast(klist, root['key'])\\n keySetTree(root['right'], klist)\\n return klist\\n except Exception as exp:\\n error.reraise(exp, 'BST:keySetTree')\",\n \"def n_choose_k(n: int, k: int) -> int:\\n # Edge case, no possible way to choose.\\n if k > n or k < 0 or n < 0: return 0\\n # We choose the min of k or n - k\\n # since nCk == nC(n - k).\\n k = min(k, n - k)\\n # The numerator represents the product\\n # n * (n - 1) * (n - 2) * ... * (n - k - 1)\\n numerator = reduce(mul, range(n, n - k, -1), 1)\\n # The denominator represents the product\\n # 1 * 2 * ... * k\\n denominator = reduce(mul, range(1, k + 1), 1)\\n # return the result as an integer.\\n return numerator // denominator\",\n \"def integer_root(n,k):\\n # from https://stackoverflow.com/questions/15978781/how-to-find-integer-nth-roots/15979957:\\n # Newton's method to find kth root of n\\n u, s = n, n+1\\n while u < s:\\n s = u\\n t = (k-1) * s + n // pow(s, k-1)\\n u = t // k\\n return s\",\n \"def find_maximum_value(self):\\n if self.root: \\n self.max_val = self.root.value\\n else:\\n return 'No tree found'\\n def inner(root):\\n if root.left:\\n inner(root.left)\\n\\n if root.right:\\n inner(root.right)\\n\\n if self.max_val < root.value:\\n self.max_val = root.value\\n\\n inner(self.root)\\n return self.max_val\",\n \"def sift_down_recursion(self, index):\\n if self.size() == 0:\\n return\\n\\n left = self.left_child(index)\\n right = self.right_child(index)\\n # if the element is leaf\\n if left >= self.size():\\n return\\n\\n max_child_index = left\\n if right < self.size():\\n if self.heap[right] > self.heap[left]:\\n max_child_index = right\\n\\n # if already max heap, return\\n if self.heap[index] >= self.heap[max_child_index]:\\n return\\n\\n self.heap[index], self.heap[max_child_index] = self.heap[max_child_index], self.heap[index]\\n\\n index = max_child_index\\n self.sift_down_recursion(index)\",\n \"def get_subset(h, k, elements):\\n n = len(elements)\\n maxM = binom(n, k) - 1\\n ans = [0] * k\\n a = n\\n b = k\\n # x is the \\\"dual\\\" of h.\\n x = maxM - h\\n for i in range(0, k):\\n ans[i] = largestV(a, b, x)\\n x -= binom(ans[i], b)\\n a = ans[i]\\n b = b - 1\\n ans = [elements[(n - 1) - ans[i]] for i in range(0, k)]\\n return ans\",\n \"def printMaxdeque(arr, n, k):\\n Qi = deque()\\n\\n # Process first k (or first window) elements of array\\n for i in range(k):\\n\\n # For every element, the previous smaller elements are useless\\n # so remove them from Qi\\n while Qi and arr[i] >= arr[Qi[-1]]:\\n Qi.pop()\\n\\n # Add new element at rear of queue\\n Qi.append(i)\\n print(Qi)\\n\\n # Process rest of the elements, i.e.\\n # from arr[k] to arr[n-1]\\n for i in range(k, n):\\n print(Qi)\\n # The element at the front of the\\n # queue is the largest element of\\n # previous window, so print it\\n print(str(arr[Qi[0]]) + \\\" \\\", end=\\\"\\\")\\n\\n # Remove the elements which are\\n # out of this window\\n while Qi and Qi[0] <= i - k:\\n # remove from front of deque\\n Qi.popleft()\\n\\n # Remove all elements smaller than\\n # the currently being added element\\n # (Remove useless elements)\\n while Qi and arr[i] >= arr[Qi[-1]]:\\n Qi.pop()\\n\\n # Add current element at the rear of Qi\\n Qi.append(i)\\n\\n # Print the maximum element of last window\\n print(str(arr[Qi[0]]))\",\n \"def test_swap_k_max(self):\\r\\n self.num2 = [1, 2, 3, 4, 5, 6]\\r\\n a1.swap_k(self.num2, len(self.num2)//2)\\r\\n self.assertEqual(self.num2, [4, 5, 6, 1, 2, 3])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7045558","0.701398","0.6677336","0.6673362","0.66666937","0.65226465","0.65028167","0.646503","0.6402724","0.63980407","0.6357561","0.6304622","0.617777","0.61401814","0.6116958","0.6113665","0.6077666","0.60618454","0.60614383","0.60428995","0.60170496","0.59952575","0.59936005","0.597438","0.59521353","0.5933596","0.5875272","0.5846028","0.5825565","0.5808315","0.5807433","0.579821","0.57968193","0.5778443","0.57696426","0.5769109","0.5755988","0.5749271","0.5744856","0.5744093","0.57440025","0.573984","0.5734842","0.5717458","0.57119334","0.5706415","0.5687801","0.56848985","0.5651249","0.56508815","0.5630169","0.5629829","0.56236583","0.56187403","0.56124085","0.56088006","0.5594233","0.55892754","0.55848676","0.55840296","0.5569023","0.55512786","0.55374736","0.55374545","0.5527019","0.5526818","0.55257046","0.55151075","0.5512466","0.55114067","0.54955924","0.54838425","0.54800916","0.5477048","0.5462855","0.5460212","0.5459062","0.5450196","0.54429185","0.543415","0.54326296","0.5432061","0.54297835","0.5424999","0.5419442","0.5413792","0.54066133","0.5399449","0.53966737","0.5393257","0.5388207","0.5384628","0.53772885","0.5366678","0.5364","0.5359683","0.5357198","0.5347824","0.53461903","0.53092974"],"string":"[\n \"0.7045558\",\n \"0.701398\",\n \"0.6677336\",\n \"0.6673362\",\n \"0.66666937\",\n \"0.65226465\",\n \"0.65028167\",\n \"0.646503\",\n \"0.6402724\",\n \"0.63980407\",\n \"0.6357561\",\n \"0.6304622\",\n \"0.617777\",\n \"0.61401814\",\n \"0.6116958\",\n \"0.6113665\",\n \"0.6077666\",\n \"0.60618454\",\n \"0.60614383\",\n \"0.60428995\",\n \"0.60170496\",\n \"0.59952575\",\n \"0.59936005\",\n \"0.597438\",\n \"0.59521353\",\n \"0.5933596\",\n \"0.5875272\",\n \"0.5846028\",\n \"0.5825565\",\n \"0.5808315\",\n \"0.5807433\",\n \"0.579821\",\n \"0.57968193\",\n \"0.5778443\",\n \"0.57696426\",\n \"0.5769109\",\n \"0.5755988\",\n \"0.5749271\",\n \"0.5744856\",\n \"0.5744093\",\n \"0.57440025\",\n \"0.573984\",\n \"0.5734842\",\n \"0.5717458\",\n \"0.57119334\",\n \"0.5706415\",\n \"0.5687801\",\n \"0.56848985\",\n \"0.5651249\",\n \"0.56508815\",\n \"0.5630169\",\n \"0.5629829\",\n \"0.56236583\",\n \"0.56187403\",\n \"0.56124085\",\n \"0.56088006\",\n \"0.5594233\",\n \"0.55892754\",\n \"0.55848676\",\n \"0.55840296\",\n \"0.5569023\",\n \"0.55512786\",\n \"0.55374736\",\n \"0.55374545\",\n \"0.5527019\",\n \"0.5526818\",\n \"0.55257046\",\n \"0.55151075\",\n \"0.5512466\",\n \"0.55114067\",\n \"0.54955924\",\n \"0.54838425\",\n \"0.54800916\",\n \"0.5477048\",\n \"0.5462855\",\n \"0.5460212\",\n \"0.5459062\",\n \"0.5450196\",\n \"0.54429185\",\n \"0.543415\",\n \"0.54326296\",\n \"0.5432061\",\n \"0.54297835\",\n \"0.5424999\",\n \"0.5419442\",\n \"0.5413792\",\n \"0.54066133\",\n \"0.5399449\",\n \"0.53966737\",\n \"0.5393257\",\n \"0.5388207\",\n \"0.5384628\",\n \"0.53772885\",\n \"0.5366678\",\n \"0.5364\",\n \"0.5359683\",\n \"0.5357198\",\n \"0.5347824\",\n \"0.53461903\",\n \"0.53092974\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8523908"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21972,"cells":{"query":{"kind":"string","value":"Calculate upper percentile MCP cutoff for avoiding Andor saturation Andor begins saturating at ~5000 for 'signal' value. Set percentile cutoff of incident fluence (mcp) to the percentile where Andor reaches 4000, well before saturation. If that is greater than the 99.9th percentile, set percentile cutoff to 99.9 to eliminate potential strong outliers in incident fluence."},"document":{"kind":"string","value":"def _calculate_percentile_cutoff(run_numbers):\n mcp_values = []\n andor_values = []\n for run_number in run_numbers:\n current_data_path = ''.join([DATA_PATH, 'run', str(run_number), 'allevts.h5'])\n f = h5py.File(current_data_path, 'r')\n current_phot = _get_photon_energy(f, run_number)\n current_mcp = np.array(f['Acqiris2']['acq'])\n current_mcp = current_mcp[(current_phot > 781) & (current_phot < 782)]\n mcp_values.extend(current_mcp)\n current_andor = np.array(f['Andor']['signal'])\n current_andor = current_andor[(current_phot > 781) & (current_phot < 782)]\n andor_values.extend(current_andor)\n #plt.figure()\n #plt.scatter(mcp_values, andor_values)\n mcp_percentile_cutoff = min([percentileofscore(andor_values, 4000), 99.9])\n return mcp_percentile_cutoff"},"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 cut_spectrum(input_spectrum, desired_frequency_range):\n channels_ip = []\n for ip in input_spectrum.GetChannels():\n channel_ip = []\n channel_op = []\n for n, i in enumerate(ip):\n if n > desired_frequency_range[0] / input_spectrum.GetResolution() and n < desired_frequency_range[1] / \\\n input_spectrum.GetResolution():\n channel_ip.append(i)\n else:\n channel_ip.append(0.0)\n channel_op.append(0.0)\n channels_ip.append(tuple(channel_ip))\n input_spectrum_modified = sumpf.Spectrum(channels=tuple(channels_ip), resolution=input_spectrum.GetResolution(),\n labels=input_spectrum.GetLabels())\n return input_spectrum_modified","def get_silence_threshold(sound, lower_quantile):\n soundint = sound.to_intensity()\n max_intensity = call(soundint, 'Get quantile', 0.0, 0.0, 1)\n sil_intensity = call(soundint, 'Get quantile', 0.0, 0.0, lower_quantile)\n return sil_intensity - max_intensity","def sigmaCorrectionFactor(baselineMode, npts, percentile):\n edgeValue = (npts/128.)**0.08\n if (baselineMode == 'edge'):\n return(edgeValue)\n value = edgeValue*2.8*(percentile/10.)**-0.25\n casalogPost(\"sigmaCorrectionFactor using percentile = %g to get sCF=%g\" % (percentile, value), debug=True)\n return(value)","def bandstop_filter(data, lowcut, highcut, fs=2000, numtaps=255):\n nyq = fs / 2\n\n # design filter\n fe1 = lowcut / nyq\n fe2 = highcut / nyq\n b = firwin(numtaps, (fe1, fe2), pass_zero=True)\n\n filtered = lfilter(b, 1, data)\n\n return filtered","def low_cut_filter(x, fs, cutoff=70):\n nyquist = fs // 2\n norm_cutoff = cutoff / nyquist\n\n # low cut filter\n fil = firwin(255, norm_cutoff, pass_zero=False)\n lcf_x = lfilter(fil, 1, x)\n\n return lcf_x","def iqr_outlier_cutoff(myseries, multiplier=1.5):\n # calculate IQR\n q1 = myseries.quantile(.25)\n q3 = myseries.quantile(.75)\n iqr = q3 - q1\n\n # get outlier cutoff\n cutoff = q3 + iqr*multiplier\n\n return cutoff","def compute_percentile(value, cutoffs):\n\tif value < cutoffs[0]:\n\t\treturn 0.0\n\n\tfor i, cutoff in enumerate(cutoffs):\n\t\tif value < cutoff:\n\t\t\treturn math.floor(100 * (float(i)/(len(cutoffs))))\n\t\t\tbreak\n\treturn 100.0","def _standardize_cutoff(cutoff):\n cutoff = np.asarray(cutoff)\n cutoff[0] = max(0., cutoff[0])\n cutoff[1] = min(1., cutoff[1])\n cutoff[0] = np.min([cutoff[0], 0.09])\n cutoff[1] = np.max([cutoff[1], 0.91])\n return cutoff","def butter_bandstop_filter(data, lowcut, highcut, fs, order):\n\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n\n i, u = sg.butter(order, (low, high), btype='bandstop')\n y = sg.filtfilt(i, u, data)\n return y","def get_thresh(amp,c): \n #Helper functions for fitting the psychometric curve, need to be\n #defined within the local scope, so that they can grok the data:\n \n def weib_fit(pars):\n thresh,slope = pars\n return weibull(x,thresh,slope,guess,flake)\n\n def err_func(pars):\n return y-weib_fit(pars)\n\n #Throw away the None's:\n hit_amps = amp[c==1]\n miss_amps = amp[c==0]\n\n # Get rid of floating point error:\n hit_amps = defloaterrorize(hit_amps)\n miss_amps = defloaterrorize(miss_amps)\n\n all_amps = np.hstack([hit_amps,miss_amps])\n stim_intensities = np.unique(all_amps)\n\n n_correct = [len(np.where(hit_amps==i)[0]) for i in stim_intensities]\n n_trials = [len(np.where(all_amps==i)[0]) for i in stim_intensities]\n Data = zip(stim_intensities,n_correct,n_trials)\n x = []\n y = []\n n = []\n for idx,this in enumerate(Data):\n #Take only cases where there were at least n_up observations:\n if n_trials[idx]>=self.n_up:\n #Contrast values: \n x = np.hstack([x,this[2] * [this[0]]])\n #% correct:\n y = np.hstack([y,this[2] * [this[1]/float(this[2])]])\n\n initial = np.mean(x),slope\n this_fit , msg = leastsq(err_func,initial)\n return this_fit,x,y","def bandpass_filter(data, lowcut, highcut, fs=2000, numtaps=255):\n nyq = fs / 2\n\n # design filter\n fe1 = lowcut / nyq\n fe2 = highcut / nyq\n b = firwin(numtaps, (fe1, fe2), pass_zero=False)\n\n filtered = lfilter(b, 1, data)\n\n return filtered","def clip_signal(signal, clipping_thresh=1000, clipped_value=215):\n index_factor = rate / CHUNK\n while index_factor * np.argmax(signal) >= clipping_thresh:\n signal[np.argmax(signal)] = 0\n return signal","def _adjust_screening_percentile(screening_percentile, mask_img, verbose=0):\n original_screening_percentile = screening_percentile\n # correct screening_percentile according to the volume of the data mask\n mask_volume = _get_mask_volume(mask_img)\n if mask_volume > 1.1 * MNI152_BRAIN_VOLUME:\n warnings.warn(\n \"Brain mask is bigger than the volume of a standard \"\n \"human brain. This object is probably not tuned to \"\n \"be used on such data.\",\n stacklevel=2,\n )\n elif mask_volume < 0.005 * MNI152_BRAIN_VOLUME:\n warnings.warn(\n \"Brain mask is smaller than .5% of the volume \"\n \"human brain. This object is probably not tuned to \"\n \"be used on such data.\",\n stacklevel=2,\n )\n\n if screening_percentile < 100.0:\n screening_percentile = screening_percentile * (\n MNI152_BRAIN_VOLUME / mask_volume\n )\n screening_percentile = min(screening_percentile, 100.0)\n # if screening_percentile is 100, we don't do anything\n\n if verbose > 1:\n print(\n f\"Mask volume = {mask_volume:g}mm^3 = {mask_volume / 1000.0:g}cm^3\"\n )\n print(\n \"Standard brain volume \"\n f\"= {MNI152_BRAIN_VOLUME:g}mm^3 \"\n f\"= {MNI152_BRAIN_VOLUME / 1.0e3:g}cm^3\"\n )\n print(\n f\"Original screening-percentile: {original_screening_percentile:g}\"\n )\n print(\n f\"Volume-corrected screening-percentile: {screening_percentile:g}\"\n )\n return screening_percentile","def filter_pupil(self, hp=0.01, lp=10.0):\r\n self.logger.info('Band-pass filtering of pupil signals, hp = %2.3f, lp = %2.3f'%(hp, lp))\r\n\r\n self.lp_filt_pupil = _butter_lowpass(data=self.interpolated_pupil.astype('float64'), highcut=lp, fs=self.sample_rate, order=3)\r\n self.hp_filt_pupil = _butter_highpass(data=self.interpolated_pupil.astype('float64'), lowcut=hp, fs=self.sample_rate, order=3)\r\n self.bp_filt_pupil = self.hp_filt_pupil - (self.interpolated_pupil-self.lp_filt_pupil)\r\n self.baseline_filt_pupil = self.lp_filt_pupil - self.bp_filt_pupil\r\n\r\n # import mne\r\n # from mne import filter\r\n # self.lp_filt_pupil = mne.filter.low_pass_filter(x=self.interpolated_pupil.astype('float64'), Fs=self.sample_rate, Fp=lp, filter_length=None, method='iir', iir_params={'ftype':'butter', 'order':3}, picks=None, n_jobs=1, copy=True, verbose=None)\r\n # self.hp_filt_pupil = mne.filter.high_pass_filter(x=self.interpolated_pupil.astype('float64'), Fs=self.sample_rate, Fp=hp, filter_length=None, method='iir', iir_params={'ftype':'butter', 'order':3}, picks=None, n_jobs=1, copy=True, verbose=None)\r\n # self.bp_filt_pupil = self.hp_filt_pupil - (self.interpolated_pupil-self.lp_filt_pupil)\r\n # self.baseline_filt_pupil = self.lp_filt_pupil - self.bp_filt_pupil\r","def filterHighs( adata, bandlimit = 5000) :\n\n # TODO: compute Fourier representation of data\n\n fig = plt.figure()\n fig.add_subplot(2, 1, 1)\n plt.plot( np.real(fdata))\n plt.xlim( [0,adata.size])\n\n # TODO: filter data\n\n fig.add_subplot(2, 1, 2)\n plt.plot( np.real(fdata))\n plt.xlim( [0,adata.size])\n plt.show()\n\n # TODO: restore time domain representation of data\n\n return adata_filtered","def outlier_thresholds(dataframe, col_name, low_quantile, up_quantile):\n quartile1 = dataframe[col_name].quantile(low_quantile)\n quartile3 = dataframe[col_name].quantile(up_quantile)\n interquantile_range = quartile3 - quartile1\n up_limit = quartile3 + 1.5 * interquantile_range\n low_limit = quartile1 - 1.5 * interquantile_range\n return low_limit, up_limit","def butter_bandpass_filter(data, lowcut, highcut, fs, order=5, axis=0): \n omega = 0.5 * fs\n low = lowcut / omega\n high = highcut / omega\n b, a = signal.butter(order, [low, high], btype='band')\n y = signal.lfilter(b, a, data, axis=0)\n return y","def heat_chi2_cut(stream, df):\n heat_chi2_threshold = quality_parameters[stream]['heat_chi2_threshold']\n chi2_heat = df['chi2_heat']\n energy_adu_heat = df['energy_adu_heat']\n \n # chi2_threshold = heat_chi2_threshold * ( 1 + (energy_adu_heat/2e3)**2 )\n chi2_threshold = heat_chi2_threshold_function(\n heat_chi2_threshold,\n energy_adu_heat\n )\n \n df['chi2_heat_cut'] = (chi2_heat < chi2_threshold)\n \n return None","def telluric_mask(data, sigma=2.5, lsf=4.8, pwv=None, pixel_start=10, pixel_end=-30, outlier_rejection=2.5, diagnostic=True, save_to_path='./'):\n\n\tdata.flux = data.flux[pixel_start:pixel_end]\n\tdata.wave = data.wave[pixel_start:pixel_end]\n\tdata.noise = data.noise[pixel_start:pixel_end]\n\n\tdata0 = copy.deepcopy(data)\n\n\t# take the closest airmass from the header\n\tairmass = float(round(data.header['AIRMASS']*2)/2)\n\tif airmass > 3.0: airmass = 3.0\n\n\t# simple chi2 comparison with different pwv\n\tif pwv is None:\n\t\tpwvs = [0.5, 1.0, 1.5, 2.5, 3.5, 5.0, 7.5, 10.0, 20.0]\n\t\tpwv_chi2 = []\n\t\t\n\t\tfor pwv in pwvs:\n\t\t\tdata_tmp = copy.deepcopy(data)\n\t\n\t\t\t#data_tmp = smart.continuumTelluric(data=data_tmp, model=model_tmp)\n\t\t\tmodel_tmp = tellurics.makeTelluricModel(lsf=lsf, airmass=airmass, pwv=pwv, flux_offset=0, wave_offset=0, data=data_tmp, deg=10)\n\t\n\t\t\tmodel_tmp.flux = np.array(smart.integralResample(xh=model_tmp.wave, yh=model_tmp.flux, xl=data_tmp.wave))\n\t\t\tmodel_tmp.wave = data_tmp.wave\n\n\t\t\t#plt.plot(data_tmp.wave, data_tmp.flux, 'k-')\n\t\t\t#plt.plot(model_tmp.wave, model_tmp.flux, 'r-')\n\t\t\t#plt.show()\n\t\t\t#plt.close()\n\t\n\t\t\tpwv_chi2.append(smart.chisquare(data_tmp, model_tmp))\n\t\t# find the pwv with minimum chisquare\n\t\tpwv_chi2_array = np.array(pwv_chi2)\n\t\t\n\t\tif diagnostic:\n\t\t\tplt.plot(pwvs, pwv_chi2)\n\t\t\tplt.xlabel('pwv (mm)', fontsize=15)\n\t\t\tplt.ylabel('$\\chi^2$', fontsize=15)\n\t\t\tplt.tight_layout()\n\t\t\tplt.savefig(save_to_path+'pwv_chi2.png')\n\t\t\t#plt.show()\n\t\t\tplt.close()\n\n\tpwv_min_index = np.where(pwv_chi2_array == np.min(pwv_chi2_array))[0][0]\n\tpwv = pwvs[pwv_min_index]\n\n\tdata_tmp = copy.deepcopy(data)\n\n\tmodel = tellurics.makeTelluricModel(lsf=lsf, airmass=airmass, pwv=pwv, flux_offset=0, wave_offset=0, data=data_tmp)\n\n\tmodel_0 = copy.deepcopy(model)\n\n\t# generate the mask based on sigma clipping\n\tpixel = np.delete(np.arange(len(data.oriWave)), data.mask)[pixel_start: pixel_end]\n\t#pixel = np.delete(np.arange(len(data_tmp.oriWave)),data_tmp.mask)\n\tmask = pixel[np.where(np.abs(data_tmp.flux-model.flux) > outlier_rejection*np.std(data_tmp.flux-model.flux))]\n\n\t#plt.plot(data_tmp.wave, data_tmp.flux, 'k-')\n\t#plt.plot(model.wave, model.flux, 'r-')\n\t#plt.show()\n\t#plt.close()\n\n\tdata_tmp.mask_custom(mask)\n\tdata_tmp.flux = data_tmp.flux[pixel_start:pixel_end]\n\tdata_tmp.wave = data_tmp.wave[pixel_start:pixel_end]\n\tdata_tmp.noise = data_tmp.noise[pixel_start:pixel_end]\n\n\t#plt.plot(data_tmp.wave, data_tmp.flux, 'k-')\n\t#plt.plot(model.wave, model.flux, 'r-')\n\t#plt.show()\n\t#plt.close()\n\n\t# use curve_fit\n\tdef tell_model_fit(wave, airmass, pwv, flux_offset, wave_offset):\n\t\tmodel = tellurics.makeTelluricModel(lsf=lsf, airmass=airmass, pwv=pwv, flux_offset=flux_offset, wave_offset=wave_offset, data=data_tmp)\n\t\treturn model.flux\n\n\tprint('initial airmass and pwv', airmass, pwv)\n\tflux_med = np.median(data_tmp.flux)\n\tp0 = [airmass, pwv, 0, 0]\n\tbounds = ([airmass-0.5, pwv-0.5, -flux_med*0.05, -0.05], [airmass+0.5, pwv+0.5, flux_med*0.05, 0.05])\n\n\tpopt, pcov = curve_fit(tell_model_fit, data_tmp.wave, data_tmp.flux, p0=p0, bounds=bounds)\n\n\tairmass, pwv, flux_offset, wave_offset = popt[0], popt[1], popt[2], popt[3]\n\tprint('best-fit airmass, pwv, flux_offset, wave_offset', airmass, pwv, flux_offset, wave_offset)\n\tmodel = tellurics.makeTelluricModel(lsf=lsf, airmass=airmass, pwv=pwv, flux_offset=0, wave_offset=0, data=data_tmp)\n\tprint('old telluric mask', mask)\n\tpixel = np.delete(np.arange(len(data_tmp.oriWave)), mask)[pixel_start: pixel_end]\n\t#print('len pixel, data, model', len(pixel), len(data_tmp.wave), len(model.wave))\n\tmask = pixel[np.where(np.abs(data_tmp.flux-model.flux) > outlier_rejection*np.std(data_tmp.flux-model.flux))]\n\t# combine the masks\n\tmask = np.union1d(mask,np.array(data_tmp.mask))\n\tprint('new telluric mask', mask)\n\n\tdata.mask_custom(mask)\n\tdata.flux = data.flux[pixel_start:pixel_end]\n\tdata.wave = data.wave[pixel_start:pixel_end]\n\tdata.noise = data.noise[pixel_start:pixel_end]\n\tprint(data.mask)\n\n\t#plt.plot(data.wave, data.flux, 'k-')\n\t#plt.plot(model.wave, model.flux, 'r-')\n\t#plt.plot(model_0.wave, model_0.flux, 'b-', alpha=0.5)\n\t#plt.show()\n\t#plt.close()\n\n\tif diagnostic:\n\t\tdata.flux = data.flux[pixel_start:pixel_end]\n\t\tdata.wave = data.wave[pixel_start:pixel_end]\n\t\tdata.noise = data.noise[pixel_start:pixel_end]\n\t\t\n\t\tmodel = tellurics.makeTelluricModel(lsf=lsf, airmass=airmass, pwv=pwv, flux_offset=0, wave_offset=0, data=data)\n\t\t\n\t\tplt.plot(data0.wave, data0.flux, 'k-', label='original data', alpha=0.5)\n\t\tplt.plot(data.wave, data.flux, 'k-', label='masked data')\n\t\tplt.plot(model.wave, model.flux, 'r-', alpha=0.7)\n\t\tplt.plot(data.wave, data.flux-model.flux, 'r-')\n\t\tplt.xlabel('$\\lambda (\\AA)$')\n\t\tplt.ylabel('$F_{\\lambda}$')\n\t\tplt.savefig(save_to_path+'telluric_data_model_mask.png')\n\t\t#plt.show()\n\t\tplt.close()\n\n\treturn mask.tolist(), pwv, airmass","def computeMedianCorrectionFactor(baselineMode, percentile):\n if (baselineMode == 'edge'):\n return(0)\n return(6.3*(5.0/percentile)**0.5)","def internal_external_canopy_heat_capacity(lumped_cover_heat_capacity: float) -> float:\n return 0.1 * lumped_cover_heat_capacity","def sky_median_sig_clip(input_arr, sig_fract, percent_fract, max_iter=100, low_cut=True, high_cut=True):\r\n\t\r\n\twork_arr = np.ravel(input_arr)\r\n\told_sky = np.median(work_arr)\r\n\toldStaDesviation = work_arr.std()\r\n\tupper_limit = old_sky + sig_fract * oldStaDesviation\r\n\tlower_limit = old_sky - sig_fract * oldStaDesviation\r\n\tif low_cut and high_cut:\r\n\t\tindices = np.where((work_arr < upper_limit) & (work_arr > lower_limit))\r\n\telse:\r\n\t\tif low_cut:\r\n\t\t\tindices = np.where((work_arr > lower_limit))\r\n\t\telse:\r\n\t\t\tindices = np.where((work_arr < upper_limit))\r\n\twork_arr = work_arr[indices]\r\n\tnew_sky = np.median(work_arr)\r\n\titeration = 0\r\n\twhile ((math.fabs(old_sky - new_sky)/new_sky) > percent_fract) and (iteration < max_iter) :\r\n\t\titeration += 1\r\n\t\told_sky = new_sky\r\n\t\toldStaDesviation = work_arr.std()\r\n\t\tupper_limit = old_sky + sig_fract * oldStaDesviation\r\n\t\tlower_limit = old_sky - sig_fract * oldStaDesviation\r\n\t\tif low_cut and high_cut:\r\n\t\t\tindices = np.where((work_arr < upper_limit) & (work_arr > lower_limit))\r\n\t\telse:\r\n\t\t\tif low_cut:\r\n\t\t\t\tindices = np.where((work_arr > lower_limit))\r\n\t\t\telse:\r\n\t\t\t\tindices = np.where((work_arr < upper_limit))\r\n\t\twork_arr = work_arr[indices]\r\n\t\tnew_sky = np.median(work_arr)\r\n\treturn (new_sky, iteration)","def calc_iqr(sig):\n # iqr = subtract(*percentile(sig, [75, 25]))\n return np.percentile(sig, 75) - np.percentile(sig, 25)","def percentile_filter(data, feats):\n\n # Determines the fraction of nonzero values in the data.\n sparsity_frac = feats['nonzeros'] / (feats['nrows'] * feats['ncols'])\n\n # NOTE: Added convenience term derived from experience.\n thresh = np.percentile(data.ravel(), q=100 * (1 - (sparsity_frac + 0.1)))\n\n # Replace p-values below threshold with zero.\n data[(data > 0) & (data < thresh)] = 0\n\n return data","def limit(filename,threshold,makeup,wout=True,plot=False):\n start=time.time()\n n, data, data_dB,sr,ch=inputwav(filename)\n dataL,dataL_bit=compress(filename,threshold,1000.0,makeup,1.0,500.0,wout=False,plot=plot)\n if wout==True:\n print('Exporting...')\n sf.write(filename[0:len(filename)-4]+'_limit.wav',dataL_bit,44100,'PCM_16')\n end=time.time()\n elapsed=int(1000*(end-start))\n print('Done!')\n print('...............................')\n print('Completed in '+str(elapsed)+' milliseconds.') \n return dataL,dataL_bit","def filter_sat(img_sat_ch, threshold = (170,255)):\n assert img_sat_ch.ndim==2\n sat_binary = np.zeros_like(img_sat_ch)\n scaled_s_ch = np.uint8(255*img_sat_ch/np.max(img_sat_ch))\n sat_binary[(scaled_s_ch >= threshold[0]) & (scaled_s_ch <= threshold[1])] = 1\n return sat_binary","def perc(data,percentile):\n clip_value = np.percentile(data,percentile)\n data = clip(data,clip_value)\n return data","def _compute_cutoffs(self):\n self._cutoffidx=np.zeros(self.nsamples,dtype=np.int)\n # Find the inlfection point\n # TODO: check robustness of this method against fluctuations in the data\n self.samplesdatadiff=np.diff(self.samplesdata,axis=0)\n flex=np.argmax(self.samplesdatadiff,axis=0)\n # if the detected cycles is the last one, then the flex has not yet been reached, warn.\n for i,f in enumerate(flex):\n #self._message(\"(%s) Preanalysis - detection of inflection point.\"%(self.samples[i])) \n if f==(self.nvalues-1):\n self._cutoffidx[i]=f\n self._message(\"Warning: (%s) Inflection point not detected. Using all fluorescent values available (%d cycles).\"%(self.samples[i],f)) \n elif f<10:\n self._message(\"Warning: (%s) Early inflection point (cycle %d).\"%(self.samples[i],f))\n else: \n self._cutoffidx[i]=np.minimum(f+2,self.nvalues)\n #self._message(\"(%s) Inflection point found at cycle %d).\"%(self.samples[i],f)) ","def set_min_uncertainty(signal, threshold=0.05):\n # Increase Hirex-Sr uncertainties to be a rel error of 5% minimum (JUST FOR TESTING)\n corrected_unc=signal.std_y/signal.y<=0.05\n signal.std_y[corrected_unc]=0.05*signal.y[corrected_unc]\n\n # correction for normalized uncertainties\n if signal.s/signal.m<=0.05:\n signal.s=0.05*signal.m\n\n signal.std_y_norm=scipy.sqrt((signal.std_y / signal.m)**2.0 + ((signal.y / signal.m)*(signal.s / signal.m))**2.0)","def findScalingCoeffsLimiter(self, PFC, lqCN, lqCF):\n # Get R and Z vectors at the midplane\n# R_omp_sol = PFC.ep.g['lcfs'][:,0].max()\n R_omp_sol = self.map_R_psi(1.0,PFC)\n R_omp_min = R_omp_sol #this is a limited discharge so Rmin = Rlcfs\n if lqCN > lqCF:\n lqMax = lqCN\n else:\n lqMax = lqCF\n R_omp_max = R_omp_sol + 20.0*lqMax #already in m\n #if R_omp_max is outside EFIT grid, cap at maximum R of grid\n if R_omp_max > max(PFC.ep.g['R']):\n R_omp_max = max(PFC.ep.g['R']) #in meters now\n R_omp = np.linspace(R_omp_min, R_omp_max, 1000)\n Z_omp = np.zeros(R_omp.shape)\n\n # Evaluate B at outboard midplane\n Bp_omp = PFC.ep.BpFunc.ev(R_omp,Z_omp)\n Bt_omp = PFC.ep.BtFunc.ev(R_omp,Z_omp)\n B_omp = np.sqrt(Bp_omp**2 + Bt_omp**2)\n\n #Find coordinate transformation vector at midplane\n psiaxis = PFC.ep.g['psiAxis']\n psiedge = PFC.ep.g['psiSep']\n deltaPsi = np.abs(psiedge - psiaxis)\n gradPsi = Bp_omp*R_omp\n xfm = gradPsi / deltaPsi\n\n # transform hf width into flux space\n lqCN_hat = lqCN*xfm\n lqCF_hat = lqCF*xfm\n\n\n #Calculate flux at midplane using gfile\n psiN = PFC.ep.psiFunc.ev(R_omp,Z_omp)\n psi = psiN*(psiedge - psiaxis) + psiaxis\n PFC.psiMinLCFS = PFC.ep.psiFunc.ev(R_omp_sol,0.0)\n s_hat = psiN - PFC.psiMinLCFS\n\n\n print('psiMinLCFS: {:f}'.format(PFC.psiMinLCFS))\n# print('un-normalized psiMinLCFS: {:f}'.format(PFC.ep.psiFunc_noN.ev(R_omp_sol,0.0)))\n print('Minimum s_hat: {:f}'.format(s_hat.min()))\n\n\n #integral in flux space\n qCN_hat = np.exp(-s_hat / lqCN_hat)\n qCF_hat = np.exp(-s_hat / lqCF_hat)\n\n #note: simps integration will fail if x variable (psi) is not monotonic\n #reinke method\n #intCN = simps(qCN_hat / B_omp, psi)\n #intCF = simps(qCF_hat / B_omp, psi)\n #menard method\n intCN = simps(qCN_hat, psi)\n intCF = simps(qCF_hat, psi)\n\n P0 = 2*np.pi * (intCN*self.fracCN + intCF*self.fracCF)\n #account for nonphysical power\n if P0 < 0: P0 = -P0\n #Scale to input power\n q0 = self.Psol/P0\n\n #old method left for reference\n #q0 = (self.Psol/(2*np.pi)) / (intCN*self.fracCN + intCF*self.fracCF)\n\n return q0","def butter_bp_coe(lowcut, highcut, fs, order=1):\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n b, a = butter(order, [low, high], btype='band')\n return b, a","def ssc(signal,samplerate=16000,winlen=0.025,winstep=0.01,\n nfilt=26,nfft=512,lowfreq=0,highfreq=None,preemph=0.97): \n highfreq= highfreq or samplerate/2\n signal = sigproc.preemphasis(signal,preemph)\n frames = sigproc.framesig(signal, winlen*samplerate, winstep*samplerate)\n pspec = sigproc.powspec(frames,nfft)\n pspec = pylab.where(pspec == 0,pylab.finfo(float).eps,pspec) # if things are all zeros we get problems\n \n fb = get_filterbanks(nfilt,nfft,samplerate,lowfreq,highfreq)\n feat = pylab.dot(pspec,fb.T) # compute the filterbank energies\n R = pylab.tile(pylab.linspace(1,samplerate/2,pylab.size(pspec,1)),(pylab.size(pspec,0),1))\n \n return pylab.dot(pspec*R,fb.T) / feat","def _find_cutoff(self):\n cutoff = 1\n while ((self.linear_rstar_unnorm(cutoff) -\n self.turing_rstar_unnorm(cutoff))**2\n > self.approx_turing_variance(cutoff)):\n cutoff += 1\n return cutoff","def butter_filter(datalist):\n fs = 200.00\n fHigh = 50.00\n fLow = 5.00\n N=4\n [b,a]=sg.butter(N,[fLow/fs, fHigh/fs], btype='band')\n global filtered\n #IIR filter\n return sg.filtfilt(b,a,datalist)","def piece_wise_cutoff(dist, cutoff):\n return (0.5 * np.cos(np.pi * dist / cutoff) + 0.5) * (dist <= cutoff)","def optimalFilter(mp):#, signalTransform = None):\n\n \"\"\" get power spectra of cmb and noise maps \"\"\"\n pNoise = liteMap1.fftTools1.powerFromLiteMap(mp)\n pNoise = pNoise.powerMap\n pNoise = liteMap1.liteMapFromDataAndWCS(pNoise, mp.wcs)\n\n return pNoise\n\n \"\"\" calculate filter \"\"\"","def get_bright_noise(image, csf_noise, percentiles):\n image_array = sitk.GetArrayViewFromImage(image)\n csf_mean = sitk.GetArrayViewFromImage(csf_noise).mean()\n perc_a, perc_b = np.percentile(image_array, percentiles)\n new_mean = torch.FloatTensor(1).uniform_(perc_a, perc_b).item()\n return csf_noise + (new_mean - csf_mean)","def process_unc(unc):\n unc = np.where(unc == 32767, np.nan, unc/1000.)","def compute_cutoff_threshold(C: list, threshold: float):\n C.append({'e': threshold, 'c': 0})\n C = sorted(C, key=lambda k: k['e'])\n cutoff = 0.0\n gap = 0.0\n i = 0\n while i < len(C) - 1 and C[i + 1]['e'] <= threshold:\n if gap < (C[i + 1]['e'] - C[i]['e']):\n gap = C[i + 1]['e'] - C[i]['e']\n cutoff = C[i]['e']\n i += 1\n return cutoff","def clip_outliers(values, p=99):\n min = np.percentile(values, 100 - p)\n max = np.percentile(values, p)\n return np.clip(values, min, max)","def clip_outliers(values, p=99):\n min = np.percentile(values, 100 - p)\n max = np.percentile(values, p)\n return np.clip(values, min, max)","def clip_at_nth(infits, cut=10):\n\n#\n#--- trim the extreme values\n#\n upper = find_nth(infits, cut)\n\n cmd1 = \"/usr/bin/env PERL5LIB=\"\n cmd2 = ' dmimgthresh infile=' + infits+ ' outfile=zout.fits cut=\"0:' + str(upper) + '\" value=0 clobber=yes'\n cmd = cmd1 + cmd2\n bash(cmd, env=ascdsenv)\n\n outfile = infits.replace('.fits','_full.fits')\n cmd = 'mv ' + infits + ' ' + outfile\n os.system(cmd)\n \n m = re.search('gz', infits)\n if m is not None:\n os.system('gzip zout.fits')\n cmd = 'mv zout.fits.gz ' + infits\n os.system(cmd)\n else:\n cmd = 'mv zout.fits ' + infits\n os.system(cmd)","def interpolate_turbidity_cutoff_probability(turb, levels):\n probability_all = np.zeros_like(turb)\n # The last dimension through apply_ufnuc is the quantile dimension\n funclist = [\n lambda v1, v2: (12.0 - v1) / (v2 - v1) * 0.20 + 0.05,\n lambda v1, v2: (12.0 - v1) / (v2 - v1) * 0.25 + 0.25,\n lambda v1, v2: (12.0 - v1) / (v2 - v1) * 0.25 + 0.5,\n lambda v1, v2: (12.0 - v2) / (v2 - v1) * 0.25 + 0.75,\n ]\n n_quantiles = turb.shape[-1]\n for l in range(n_quantiles):\n # For the last quantile, use the previous quantile set\n l_ = l if l != n_quantiles - 1 else l - 1\n v1 = turb[..., l_]\n v2 = turb[..., l_ + 1]\n probability_all[..., l] = funclist[l](v1, v2)\n result = np.select(\n [levels == i for i in range(n_quantiles)],\n [probability_all[..., i] for i in range(n_quantiles)],\n default=0.0,\n )\n np.clip(result, 0.0, 1.0, out=result)\n return result","def _signal_filter_butterworth(signal, sampling_rate=1000, lowcut=None, highcut=None, order=2):\n if lowcut is not None and highcut is not None:\n sos = scipy.signal.butter(order, [lowcut, highcut], btype=\"bandpass\", output='sos', fs=sampling_rate)\n elif lowcut is not None:\n sos = scipy.signal.butter(order, [lowcut], btype=\"highpass\", output='sos', fs=sampling_rate)\n elif highcut is not None:\n sos = scipy.signal.butter(order, [highcut], btype=\"lowpass\", output='sos', fs=sampling_rate)\n\n filtered = scipy.signal.sosfiltfilt(sos, signal)\n return filtered","def filter_percentile(df, col, up=95, down=5):\n pup = np.percentile(df[col].values, up)\n pdw = np.percentile(df[col].values, down)\n\n s = (df[col]<pup) & (df[col]>pdw)\n df2 = df[s]\n\n return df2","def FoldChangeFilterBasedOnMaxFC(X, data_headers, cutoff=0.5):\n XX = Linear(X.copy(), data_headers)\n X_ToMin = XX[data_headers] / XX[data_headers].min(axis=0)\n Xidx = np.any(X_ToMin.values >= X_ToMin.max().values * cutoff, axis=1)\n return X.iloc[Xidx, :]","def _get_percentile_cutoff(data, cutoff=None, percentile=None, required=False):\n if percentile is not None:\n if cutoff is not None:\n raise ValueError(\n \"Only one of `cutoff` and `percentile` should be given.\"\n \"Got cutoff={}, percentile={}\".format(cutoff, percentile)\n )\n if not isinstance(percentile, numbers.Number):\n return [_get_percentile_cutoff(data, percentile=p) for p in percentile]\n if percentile < 1:\n warnings.warn(\n \"`percentile` expects values between 0 and 100.\"\n \"Got {}. Did you mean {}?\".format(percentile, percentile * 100),\n UserWarning,\n )\n cutoff = np.percentile(np.array(data).reshape(-1), percentile)\n elif cutoff is None and required:\n raise ValueError(\"One of either `cutoff` or `percentile` must be given.\")\n return cutoff","def butter_highpass_filter(data, cutoff, fs, order=1):\n b, a = butter_highpass(cutoff, fs, order=order)\n y = filtfilt(b, a, data)\n return y","def chiaki_threshold(C_f, Fe_f, H_f, return_value = False):\n\n threshold = 10.0**(-5.07)\n\n H_abund = H_f / 1.00790\n C_abund = C_f / 12.0107\n Fe_abund = Fe_f / 55.8450\n\n C_H_solar = 8.43 - 12.0\n Fe_H_solar = 7.50 - 12.0\n\n C_over_H = np.log10( C_abund / H_abund) - C_H_solar\n Fe_over_H = np.log10( Fe_abund / H_abund) - Fe_H_solar\n\n local_C_Fe = 10.0**(C_over_H-2.3) + 10.0**(Fe_over_H)\n\n if return_value:\n return local_C_Fe\n else:\n return local_C_Fe >= threshold","def low_high_filter(image, param=1.6):\r\n nan_pos = np.isnan(image)\r\n img = image.copy()\r\n mean = np.nanmean(img)\r\n img[nan_pos] = mean\r\n\r\n low_filtered_image = gaussian(img, sigma = 4)\r\n gau = gaussian(img, sigma = 4/param)\r\n high_filtered_image = gau - low_filtered_image\r\n\r\n low_filtered_image[nan_pos] = np.nan\r\n high_filtered_image[nan_pos] = np.nan\r\n return low_filtered_image, high_filtered_image","def lin_cutoff_calc_from_perc(image, minimum, maximum):\n if minimum < 0 or maximum < 0 or minimum > 100 or maximum > 100:\n raise Exception(\"rvt.blend_funct.lin_cutoff_calc_from_perc: minimum, maximum are percent and have to be in \"\n \"range 0-100!\")\n if minimum + maximum > 100:\n raise Exception(\"rvt.blend_funct.lin_cutoff_calc_from_perc: if minimum + maximum > 100% then there are no\"\n \" values left! You can't cutoff whole image!\")\n distribution = np.nanpercentile(a=image, q=np.array([minimum, 100 - maximum]))\n min_lin = distribution[0]\n max_lin = distribution[1]\n if min_lin == max_lin:\n min_lin = np.nanmin(image)\n max_lin = np.nanmax(image)\n return {\"min_lin\": min_lin, \"max_lin\": max_lin}","def normalize_signal(signal):\n gain = 1.0 / (np.max(np.abs(signal)) + 1e-9)\n return signal * gain","def process_pain(x, lb, ub):\n x = x.abs()\n x.loc[(x > ub)] = 8\n x.loc[(x < lb) | (x > ub)] = np.nan\n return x","def butter_bandpass_filter(data, lowcut, highcut, fs, order=1):\n b, a = butter_bandpass(lowcut, highcut, fs, order=order)\n y = filtfilt(b, a, data)\n return y","def FE_capping_outliers_beyond_IQR_Range(df, features, cap_at_nth_largest=5, IQR_multiplier=1.5,\r\n drop=False, verbose=False):\r\n outlier_indices = []\r\n df = df.copy(deep=True)\r\n if isinstance(features, str):\r\n features = [features]\r\n # iterate over features(columns)\r\n for col in features:\r\n ### this is how the column looks now before capping outliers\r\n if verbose:\r\n fig, (ax1,ax2) = plt.subplots(1,2,figsize=(12,5))\r\n df[col].plot(kind='box', title = '%s before capping outliers' %col, ax=ax1)\r\n # 1st quartile (25%)\r\n Q1 = np.percentile(df[col], 25)\r\n # 3rd quartile (75%)\r\n Q3 = np.percentile(df[col],75)\r\n # Interquartile range (IQR)\r\n IQR = Q3 - Q1\r\n\r\n # outlier step using multiplier\r\n outlier_step = IQR_multiplier * IQR\r\n\r\n lower_limit = Q1 - outlier_step\r\n upper_limit = Q3 + outlier_step\r\n\r\n # Determine a list of indices of outliers for feature col\r\n outlier_list_col = df[(df[col] < lower_limit) | (df[col] > upper_limit )].index\r\n\r\n ### Capping using the n largest value based on n given in input.\r\n maxval = df[col].max() ## what is the maximum value in this column?\r\n num_maxs = df[df[col]==maxval].shape[0] ## number of rows that have max value\r\n ### find the n_largest values after the maximum value based on given input n\r\n num_largest_after_max = num_maxs + cap_at_nth_largest\r\n capped_value = df[col].nlargest(num_largest_after_max).iloc[-1] ## this is the value we cap it against\r\n df.loc[df[col]==maxval, col] = capped_value ## maximum values are now capped\r\n ### you are now good to go - you can show how they are capped using before and after pics\r\n if verbose:\r\n df[col].plot(kind='box', title = '%s after capping outliers' %col, ax=ax2)\r\n plt.show()\r\n\r\n # Let's save the list of outliers and see if there are some with outliers in multiple columns\r\n outlier_indices.extend(outlier_list_col)\r\n\r\n # select certain observations containing more than one outlier in 2 columns or more. We can drop them!\r\n outlier_indices = Counter(outlier_indices)\r\n multiple_outliers = list( k for k, v in outlier_indices.items() if v > 3 )\r\n ### now drop these rows altogether ####\r\n if drop:\r\n print('Shape of dataframe before outliers being dropped: %s' %(df.shape,))\r\n number_of_rows = df.shape[0]\r\n df.drop(multiple_outliers, axis=0, inplace=True)\r\n print('Shape of dataframe after outliers being dropped: %s' %(df.shape,))\r\n print('\\nNumber_of_rows with multiple outliers in more than 3 columns which were dropped = %d' %(number_of_rows-df.shape[0]))\r\n return df","def default_quantile():\n return np.logspace(-5, 0, 100)","def pl_exp_cut_low_high(x, **params):\n result = (x / params['Scale_CR']) ** (-params['Index_CR'])\n result *= params['Prefactor_CR']\n result *= np.exp(-x / params['Emax_CR']) * np.exp(-params['Emin_CR'] / x)\n return result","def set_new_threshold(wavform, thr, n_pre=N_PRE_PT, rng=SEARCH_RNG, i_chg=20):\n wav = np.array(wavform)\n sgn = np.sign(thr)\n if np.max(wav[rng[0]:rng[1]] * sgn) < np.abs(thr): return None # reject\n\n \"\"\" NOT USED -- GIVES IMPRECISE RESULT\n # -- align: find the steepest point having the same sign as `sgn`\n df = np.diff(wav)\n si = np.argsort(-sgn * df) # reverse sorted\n for i in si:\n if np.sign(wav[i]) == sgn: break\n \"\"\"\n # -- align: find the point where waveform crosses `thr`\n n = len(wav)\n for i in range(n - 1):\n if sgn * wav[i] <= sgn * thr and sgn * thr <= sgn * wav[i + 1]:\n break\n if i == n - 2:\n # although i could be n - 2, it's highly likely an artifact\n return None\n n_shift = n_pre - i - 1 # > 0: right shift, < 0: left shift\n if n_shift == 0:\n return wav\n\n wavnew = np.empty(wav.shape)\n wavnew[n_shift:] = wav[:-n_shift] # PBC shifting\n wavnew[:n_shift] = wav[-n_shift:]\n\n # -- done: but if the spike doesn't change its sign\n # within `i_chg`, reject.\n if np.max(-sgn * wavnew[n_pre:i_chg]) < 0:\n return None\n\n \"\"\" DEBUG\n if np.abs(n_shift) > 3:\n print '!!!', n_shift, '/', i, '/', n\n print '---', np.max(-sgn * wavnew[n_pre:i_chg])\n print list(wav)\n print list(wavnew)\n \"\"\"\n\n return wavnew","def settings_outside_clinical_bounds(cir, isf, sbr):\n return (\n (float(isf) < 10)\n | (float(isf) > 500)\n | (float(cir) < 2)\n | (float(cir) > 150)\n | (float(sbr) < 0.05)\n | (float(sbr) > 30)\n )","def _cutoff(xdata, ydata, btype, fs, ff):\r\n try:\r\n# print ff\r\n if ff != None:\r\n nPts = int(1./(((xdata.max()-xdata.min())/xdata.shape[0])*(ff/10.)))\r\n else:\r\n nPts = 0\r\n if nPts%2 == 0:\r\n nPts = nPts + 1\r\n if nPts < xdata.shape[0]:\r\n nPts = xdata.shape[0]\r\n# print nPts\r\n window = np.hanning(ydata.shape[0])\r\n freq = FourierFrequency(xdata, nPts)\r\n index = np.argsort(freq)\r\n tdf = FourierTransform(ydata*window, nPts)\r\n tdf = abs(tdf)\r\n pp = _maxima(tdf[index], freq[index], lookahead = 1)\r\n# mm = _minima(tdf[index], freq[index], lookahead=1)\r\n pp, hh = np.array(np.array(pp).T[0]), np.array(np.array(pp).T[1])\r\n# mm = np.array(np.array(mm).T[0])#, np.array(np.array(mm).T[1])\r\n ind = np.where(pp == min(abs(pp)))[0][0]\r\n ind2 = np.where(hh == max(hh[(ind+1):]))[0][0]\r\n for u, i in enumerate(freq):\r\n if i > abs(pp[ind2])*1.5 or i < -abs(pp[ind2])*1.5 or (i < abs(pp[ind2])/2. and i > -abs(pp[ind2])/2.) or (tdf[u] > hh[ind2]*1.05): #(abs(i) < abs(mm[indmin])) or \r\n tdf[u] = 0.\r\n def lor2(x, A0, x0, gamma0):\r\n return A0*(1/np.pi)*(gamma0/2)/((x-x0)**2+(gamma0/2)**2)+A0*(1/np.pi)*(gamma0/2)/((x+x0)**2+(gamma0/2)**2)\r\n lmod2 = lmf.Model(lor2)\r\n lmod2.make_params()\r\n lmod2.set_param_hint('A0', value=max(tdf), min=max(tdf)/1000.)\r\n lmod2.set_param_hint('x0', value=abs(pp[ind2]), min=0.)\r\n lmod2.set_param_hint('gamma0', value=1., min=0.)\r\n result2 = lmod2.fit(tdf[index], x=freq[index])\r\n# print result2.values.get('x0'), result2.values.get('gamma0')\r\n if btype=='high':\r\n if result2.values.get('x0')-result2.values.get('gamma0') > 0.:\r\n# print \"frequency: \", result2.values.get('x0')-result2.values.get('gamma0')\r\n if hh[ind2] != max(hh[(ind+1):]):\r\n print \"False\", \" maximum\", \"\\n\", \"\\n\", \"\\n\"\r\n return result2.values.get('x0')-result2.values.get('gamma0')\r\n else:\r\n# print \"failed: 0\"\r\n return 0.\r\n elif btype=='low':\r\n return result2.values.get('x0')+result2.values.get('gamma0')\r\n except Exception:\r\n pass\r\n finally:\r\n pass","def ion_chi2_cut(stream, df):\n ion_chi2_threshold = quality_parameters['ion_chi2_threshold']\n \n truth_array = pd.Series(data=True, index=df.index)\n for suffix in ion_channel_labels:\n chi2_column_name = 'chi2_ion{}'.format(suffix)\n chi2_ion = df[chi2_column_name]\n \n energy_column_name = 'energy_adu_ion{}'.format(suffix)\n energy_adu_ion = abs( df[energy_column_name] )\n \n # chi2_threshold = ion_chi2_threshold * ( 1 + (energy_adu_ion/3e2)**2.2 )\n chi2_threshold = ion_chi2_threshold_function(\n ion_chi2_threshold,\n energy_adu_ion\n )\n \n truth_array = truth_array & (chi2_ion < chi2_threshold)\n \n df['chi2_ion_cut'] = truth_array\n \n return None","def _uppLim(self):\n if self.getResult(param='TS value')[0] >= self.tsmin:\n print(\"\\t=== TS value {} is above TSmin {}, no need to compute an upperlimit ===\"\n .format(self.getResult(param='TS value')[0], self.tsmin))\n return\n\n from UpperLimits import UpperLimits\n import UnbinnedAnalysis as UA\n \n like = UA.unbinnedAnalysis(evfile=self.outmktime, scfile=self.ft2, expmap=self.outexpmap,\n expcube=self.outltcube, irfs=self.irf, optimizer=\"NewMinuit\", srcmdl=self.model)\n like.fit(0)\n ul = UpperLimits(like)\n\n try:\n upp, norm=ul['TARGET'].bayesianUL(emin=self.emin, emax=self.emax, cl=0.95) \n except:\n upp = -1\n wf = open(self.outgtlike, 'a')\n wf.write(\"\\nUpper limit on source 'TARGET': {} ph/cm2/s.\".format(upp))\n wf.close()\n return","def above_threshold(self, value):\n # We use floating point number here so we have to take care\n return finf(value,self.min) or finf(self.max,value)","def trim(self, edge_ic_cutoff=0.4):\n pwm = self.pwm[:]\n while len(pwm) > 0 and self.ic_pos(pwm[0]) < edge_ic_cutoff:\n pwm = pwm[1:]\n self.pwm = self.pwm[1:]\n self.pfm = self.pfm[1:]\n while len(pwm) > 0 and self.ic_pos(pwm[-1]) < edge_ic_cutoff:\n pwm = pwm[:-1]\n self.pwm = self.pwm[:-1]\n self.pfm = self.pfm[:-1]\n \n self.consensus = None \n self.min_score = None\n self.max_score = None\n self.wiggled_pwm = None\n \n return self","def _butter_bandpass_filter(self, data: np.ndarray, lowcut: float, highcut: float, fs: float, order: int = 5):\n b, a = self._butter_bandpass(lowcut, highcut, fs, order=order)\n y = lfilter(b, a, data)\n return y","def butter_bandpass_filter(data, lowcut, highcut, fs, order=2):\n nyq = 0.5 * fs\n low = lowcut / nyq\n high = highcut / nyq\n \n # butter() and lfilter() are from scipy.signal\n \n b, a = butter(order, [low, high], btype='band')\n y = lfilter(b, a, data)\n return y","def get_chisqrs(prf,diff,nbins): \n off_pulse = np.zeros(39)\n off_pulse[:20] = prf[:20]\n off_pulse[20:] = prf[45:] #Making off pulse region\n # print(\"Off pulse Region \",off_pulse)\n op_rms = np.var(off_pulse) #Rms\n # print(\"Off pulse RMS \",op_rms)\n s = 0\n for d in diff:\n s += d**2/op_rms\n\n s = s/(nbins - 1)\n # print(\"Chisqr value = \",s)\n\n return s","def change_saturation_conv(image, value):\n image = rescale_image_0255(image)\n image = change_saturation(image, value)\n return rescale_image_01(image)","def fir_filter(sig, sampling_freq, critical_freq, kernel_window = 'hamming', taps = 101, kind = 'band', **kwargs):\n\n kernel = make_fir_filter(sampling_freq, critical_freq, kernel_window, taps, kind, **kwargs) \n\n return np.roll(scipy.signal.lfilter(kernel, [1], sig), -taps/2+1)","def u_crit(state, sys):\n s = state[0]\n i = state[1]\n tau = scipy.interpolate.interp1d(sys.tau.s, sys.tau.i, kind = \"cubic\")\n phi = scipy.interpolate.interp1d(sys.phi.s, sys.phi.i, kind = \"cubic\")\n cc = scipy.interpolate.interp1d(sys.commutation_curve[0],\n sys.commutation_curve[1],\n kind = \"cubic\")\n if i > sys.imax:\n return sys.umax\n if s <= sys.commutation_curve[0][-1]:\n #print(\"Case 1\")\n if s < sys.sbar or i < tau(s):\n return 0\n return sys.umax\n elif s > sys.commutation_curve[0][-1] and s < sys.commutation_curve[0][0]:\n #print(\"Case 2\")\n if ((i > tau(s)) and (i < cc(s))) or (i > sys.imax):\n return sys.umax\n elif i > cc(s) and i < sys.imax:\n return 0\n else:\n return 0\n else:\n #print(\"Case 3\")\n if i > sys.imax:\n return sys.umax\n elif s > sys.sstar and i > phi(s):\n return sys.umax\n return 0","def trigger_cut(\n df,\n nearest_data_trigger_allowed=5,\n furthest_simu_trigger_allowed=5\n ):\n df['trigger_cut'] = (\n ( abs(df['t_nearest_data_trigger']) > nearest_data_trigger_allowed )\n & ( abs(df['t_input_simu_trigger']) < furthest_simu_trigger_allowed )\n )","def get_kcut_profile(kmax,kcut,apo_over):\n ret = np.ones(kmax)\n if kcut+apo_over == 0:\n return ret\n \n rising = sin_profile(kcut+apo_over,kcut,1)\n falling = 1.0-sin_profile(kcut+apo_over,kcut,0)[::-1]\n \n ret[:len(rising)]=rising\n if len(falling) == 0:\n print (\"fourier resolution bigger than the cut size asked\")\n pass\n else:\n ret[-len(falling):]=falling\n \n ret[ret<0] = 0\n return np.fft.fftshift(ret)","def SignalFilter_LPFBessel(signal, LPF, samplefreq, NPole=8, reduce=False, bidir=False):\n if debugFlag:\n print(\"sfreq: %f LPF: %f HPF: %f\" % (samplefreq, LPF))\n flpf = float(LPF)\n sf = float(samplefreq)\n wn = [flpf/(sf/2.0)]\n reduction = 1\n if reduce:\n if LPF <= samplefreq/2.0:\n reduction = int(samplefreq/LPF)\n if debugFlag is True:\n print(\"signalfilter: samplef: %f wn: %f, lpf: %f, NPoles: %d \" % (\n sf, wn, flpf, NPole))\n filter_b,filter_a=spSignal.bessel(\n NPole,\n wn,\n btype = 'low',\n output = 'ba')\n if signal.ndim == 1:\n sm = numpy.mean(signal)\n if bidir:\n w=spSignal.filtfilt(filter_b, filter_a, signal-sm) # filter the incoming signal\n else:\n w=spSignal.lfilter(filter_b, filter_a, signal-sm) # filter the incoming signal\n\n w = w + sm\n if reduction > 1:\n w = spSignal.resample(w, reduction)\n return(w)\n if signal.ndim == 2:\n sh = numpy.shape(signal)\n for i in range(0, numpy.shape(signal)[0]):\n sm = numpy.mean(signal[i,:])\n if bidir:\n w1 = spSignal.filtfilt(filter_b, filter_a, signal[i, :]-sm)\n else:\n w1 = spSignal.lfilter(filter_b, filter_a, signal[i, :]-sm)\n\n w1 = w1 + sm\n if reduction == 1:\n w1 = spSignal.resample(w1, reduction)\n if i == 0:\n w = numpy.empty((sh[0], numpy.shape(w1)[0]))\n w[i,:] = w1\n return w\n if signal.ndim == 3:\n sh = numpy.shape(signal)\n for i in range(0, numpy.shape(signal)[0]):\n for j in range(0, numpy.shape(signal)[1]):\n sm = numpy.mean(signal[i,j,:])\n if bidir:\n w1 = spSignal.filtfilt(filter_b, filter_a, signal[i,j,:]-sm)\n else:\n w1 = spSignal.lfilter(filter_b, filter_a, signal[i,j,:]-sm)\n w1 = w1 + sm\n if reduction == 1:\n w1 = spSignal.resample(w1, reduction)\n if i == 0 and j == 0:\n w = numpy.empty((sh[0], sh[1], numpy.shape(w1)[0]))\n w[i,j,:] = w1\n return(w)\n if signal.ndim > 3:\n print(\"Error: signal dimesions of > 3 are not supported (no filtering applied)\")\n return signal","def bandpassFilter (self, lowerFreq, upperFreq):\n self.bandpassLimits = (lowerFreq, upperFreq)\n # stuff to do","def _clamp_percent(value):\n if value < 0:\n print(\"Less than 0 percent specified for extension. Clamping to 0\")\n value = 0\n elif value > 100:\n print(\"More than 100 percent specified for extension. Clamping to 100\")\n value = 100\n return value","def mod_filterbank(signal, fs, modf):\n modf = np.asarray(modf)\n fcs = modf[1:]\n fcut = modf[0]\n # Make signal odd length\n signal = signal[0:-1] if (len(signal) % 2) == 0 else signal\n\n q = 1. # Q-factor of band-pass filters\n lp_order = 3. # order of the low-pass filter\n\n n = signal.shape[-1] # length of envelope signals\n X = fft(signal)\n X_mag = np.abs(X)\n X_power = np.square(X_mag) / n # power spectrum\n X_power_pos = X_power[0:np.floor(n / 2).astype('int') + 1]\n # take positive frequencies only and multiply by two to get the same total\n # energy\n X_power_pos[1:] = X_power_pos[1:] * 2\n\n pos_freqs = np.linspace(0, fs / 2, X_power_pos.shape[-1])\n # Concatenate vector of 0:fs and -fs:1\n freqs = np.concatenate((pos_freqs, -1 * pos_freqs[-1:0:-1]))\n\n # Initialize transfer function\n TFs = np.zeros((len(fcs) + 1, len(freqs))).astype('complex')\n # Calculating frequency-domain transfer function for each center frequency:\n for k in range(len(fcs)):\n TFs[k + 1, 1:] = 1. / (1. + (1j * q * (freqs[1:] / fcs[k] - fcs[k] /\n freqs[1:]))) # p287 Hambley.\n\n # squared filter magnitude transfer functions\n Wcf = np.square(np.abs(TFs))\n\n # Low-pass filter squared transfer function, third order Butterworth filter\n # TF from:\n # http://en.wikipedia.org/wiki/Butterworth_filter\n Wcf[0, :] = 1 / (1 + ((2 * pi * freqs / (2 * pi * fcut)) ** (2 * lp_order)))\n # Transfer function of low-pass filter\n TFs[0, :] = np.sqrt(Wcf[0, :])\n\n # initialize output product:\n vout = np.zeros((len(fcs) + 1, len(pos_freqs)))\n powers = np.zeros(len(modf))\n\n # ------------ DC-power, --------------------------\n # here divide by two such that a fully modulated tone has an AC-power of 1.\n dc_power = X_power_pos[0] / n / 2\n # ------------------------------------------------\n X_filt = np.zeros((Wcf.shape[0], X.shape[-1]), dtype='complex128')\n filtered_envs = np.zeros_like(X_filt, dtype='float')\n\n for k, (w, TF) in enumerate(zip(Wcf, TFs)):\n vout[k] = X_power_pos * w[:np.floor(n / 2).astype('int') + 1]\n # Integration estimated as a sum from f > 0\n # integrate envelope power in the passband of the filter. Index goes\n # from 2:end since integration is for f>0\n powers[k] = np.sum(vout[k, 1:]) / n / dc_power\n # Filtering and inverse Fourier transform to get time signal.\n X_filt[k] = X * TF\n filtered_envs[k] = np.real(ifft(X_filt[k]))\n return powers, filtered_envs","def filt_hp(sig: np.ndarray, Ss: int, Cfs: int, Cfs1: None,\n order=5) -> np.ndarray:\n nyq = 0.5 * Ss\n normal_cutoff = Cfs / nyq\n b, a = butter(order, normal_cutoff, btype='high', analog=False)\n return lfilter(b, a, sig)","def test_set_clip_precentile_update(self):\n data = np.array([1., 2., 3.])\n self.mode.set_clip_percentile(10, 90)\n result = self.mode.get_bounds(data)\n self.mode.set_clip_percentile(20, 80)\n result = self.mode.get_bounds(data)\n np.testing.assert_array_almost_equal(result,\n np.percentile(data, [20, 80]))","def genChirpIC(Ih=-100,Rm=100,amp=5):\n pA_per_mV=1000/Rm\n print(\"%.02f pA requried to shift 1mV\"%pA_per_mV)\n xs,ys,zi=genSine()\n ys=ys*pA_per_mV*amp+Ih\n genATF(xs,ys,'stimulus-IC.atf')\n graphData(xs,ys,zi,\"Current Clamp Stimulus\",'stimulus-IC.png')","def append_opt_band(S, low_noise_thresh, med_noise_thresh, confluence_fp,opt_band, \n uctuner):\n with open(confluence_fp,'a') as cfile: # Making the markdown string to append to file\n top=\"||SMuRF band||uc att (.5dB steps)||tone power (3dB steps)||dc att (.5dB steps)||Num. Channels||Med. White Noise (pA/rtHz)||Num. Channels||Med. White Noise (pA/rtHz)||\"\n fmt = \"\"\n if uctuner.best_wl <= low_noise_thresh:\n fmt='_'\n elif uctuner.best_wl >= med_noise_thresh:\n fmt='*'\n confluence_row = f\"|{opt_band}|{uctuner.best_att}|{uctuner.best_tone}|\"+\\\n f\"{S.get_att_dc(opt_band)}|{uctuner.best_length}|\" +\\\n f\"{fmt}{uctuner.best_wl}{fmt}| | |\\n\"\n cfile.write(confluence_row)\n if opt_band == 7:\n cfile.write(\"||Total|| || || || || || TODO || ||\\n \")","def find_outlier_range(dfs: pd.Series, iqr_factor=1.5, clip_low=None, clip_high=None):\n quant1 = dfs.quantile(0.25)\n quant3 = dfs.quantile(0.75)\n IQR = quant3 - quant1\n low = quant1 - iqr_factor * IQR\n high = quant3 + iqr_factor * IQR\n\n if clip_low is not None:\n low = max(clip_low, low)\n if clip_high is not None:\n high = min(clip_high, high)\n return (low, high)","def reduce_signal(signal):\n fft = get_fft(signal)\n doms = get_dom_freq(fft[0], fft[1], 50)\n reduced = get_reduced_signal(doms[0], doms[1], len(signal))\n return reduced","def adjust_saturation(image, factor):\r\n image[..., 1] = np.clip(image[..., 1] * factor, 0, 255)\r\n return image","def get_xi_threshold(Mu,Y_max,Effective_Impedance,Phi_max):\n return (np.pi*Phi_max**5*ImZ_over_k)/(32*Mu*(Mu+1)*chi(Mu,Y_max)*Effective_Impedance)","def compute_filt(up, down, fc='nn', beta=5.0, N=32001, return_fc=False):\n\n # see explanation in resample below\n if up==down:\n raise ValueError('upsampling and downsampling rate cannot be the same.')\n\n # Determine our up and down factors\n g = gcd(up, down)\n up = up//g\n down = down//g\n max_rate = max(up, down)\n\n sfact = np.sqrt(1+(beta/np.pi)**2)\n\n if isinstance(fc, float):\n pass\n\n # the \"standard\" way to generate the filter is to just place fc on the\n # Nyquist frequency, which results in considerable aliasing but is\n # neccesary for perfect reconstruction multirate filterbanks but not\n # for audio resampling! Included here mostly for completeness and\n # comparison purposes.\n elif fc == 'standard':\n fc = 1/max_rate\n\n # The paper by Kaiser gives a formula for the neccesary length of the\n # filter given a desired stopband attenuation and transition band width;\n # conversly, we can determine the transition band width from the stop\n # band attenuation and filter length. This allows us to shift fc.\n elif fc == 'kaiser' or fc == 'Kaiser':\n As = As_from_beta(beta)\n offset = (As-7.95)/(14.36*N)\n fc = (1/max_rate)-offset\n\n # The null-on-Nyquist method: the reason I wrote this package in the first\n # place. My argument is that the cutoff frequency should be on the border\n # between the main lobe of the filter and the first sidelobe; this should\n # give the best tradeoff between retaining the desired signal and\n # suppressing aliasing.\n elif fc == 'nn':\n # This is a two-step procedure. First we generate a filter in the\n # 'normal' way: with 6dB attenuation at Falsef_c.\n init_filt = sig.fir_filter_design.firwin(N, 1/max_rate,\n window=('kaiser', beta))\n\n # Next, find the first null. Convert the filter into frequency domain.\n N_FFT = 2**19\n NBINS = N_FFT/2+1\n paddedfilt = np.zeros(N_FFT)\n paddedfilt[:N] = init_filt\n ffilt = np.fft.rfft(paddedfilt)\n\n # Now find the minimum between f_c and f_c+sqrt(1+(beta/pi)^2)/L\n bot = int(np.floor(NBINS/max_rate))\n top = int(np.ceil(NBINS*(1/max_rate + 2*sfact/N)))\n firstnull = (np.argmin(np.abs(ffilt[bot:top])) + bot)/NBINS\n\n # get the new fc\n fc = -firstnull+2/max_rate\n\n else:\n raise ValueError('Unknown option for fc in compute_filt')\n\n # Now we can generate the desired filter\n f = sig.fir_filter_design.firwin(N, fc, window=('kaiser', beta))\n\n if return_fc:\n return f, fc\n else:\n return f","def filter_strength_pil(self, pil_df, threshold, pil_label):\n # Create single dataframe with the cutting threshold which contains ~95% PIL flux\n cut_label = pil_df[pil_df['cut_threshold'] > threshold].label.values\n\n # Check individual pil index which total strength not equal to initial total flux\n cut_idx = np.isin(pil_label, cut_label)\n\n # Set small PIL flux label to 0, only keep big PIL flux label\n pil_label[cut_idx] = 0\n\n return pil_label","def find_cosmics_in_cut(x, cut_wave, cut_brightest_line, line_wavelength = 0.,\n kernel_median_cosmics = 5, cosmic_higher_than = 100, extra_factor = 1., plot=False, verbose=False):\n \n gc_bl=signal.medfilt(cut_brightest_line,kernel_size=kernel_median_cosmics)\n max_val = np.abs(cut_brightest_line-gc_bl)\n\n gc=signal.medfilt(cut_wave,kernel_size=kernel_median_cosmics)\n verde=np.abs(cut_wave-gc)-extra_factor*max_val\n \n cosmics_list = [i for i, x in enumerate(verde) if x > cosmic_higher_than]\n \n if plot:\n ptitle=\"Cosmic identification in cut\"\n if line_wavelength != 0 : ptitle=\"Cosmic identification in cut at \"+np.str(line_wavelength)+\" $\\mathrm{\\AA}$\" \n plot_plot(x,verde, ymin=0,ymax=200, hlines=[cosmic_higher_than], ptitle=ptitle, ylabel=\"abs (cut - medfilt(cut)) - extra_factor * max_val\")\n \n if verbose:\n if line_wavelength == 0:\n print(\"\\n> Identified\", len(cosmics_list),\"cosmics in fibres\",cosmics_list)\n else:\n print(\"\\n> Identified\", len(cosmics_list),\"cosmics at\",np.str(line_wavelength),\"A in fibres\",cosmics_list)\n return cosmics_list","def mfcc(signal,samplerate=16000,winlen=0.025,winstep=0.01,numcep=13,\n nfilt=23,nfft=512,lowfreq=20,highfreq=None,dither=1.0,remove_dc_offset=True,preemph=0.97,\n ceplifter=22,useEnergy=True,wintype='povey'):\n feat,energy = fbank(signal,samplerate,winlen,winstep,nfilt,nfft,lowfreq,highfreq,dither,remove_dc_offset,preemph,wintype)\n feat = numpy.log(feat)\n feat = dct(feat, type=2, axis=1, norm='ortho')[:,:numcep]\n feat = lifter(feat,ceplifter)\n if useEnergy: feat[:,0] = numpy.log(energy) # replace first cepstral coefficient with log of frame energy\n return feat","def SetNarrowBandwidth(self, value: 'double') -> \"void\":\n return _itkReinitializeLevelSetImageFilterPython.itkReinitializeLevelSetImageFilterIF3_SetNarrowBandwidth(self, value)","def fir(self):\r\n #Passband and stop-band are expressed as fraction of the Nyquist\r\n #frequency:\r\n if self.ub is not None:\r\n ub_frac = self.ub / (self.sampling_rate / 2.)\r\n else:\r\n ub_frac = 1.0\r\n\r\n lb_frac = self.lb / (self.sampling_rate / 2.)\r\n\r\n if lb_frac < 0 or ub_frac > 1:\r\n e_s = \"The lower-bound or upper bound used to filter\"\r\n e_s += \" are beyond the range 0-Nyquist. You asked for\"\r\n e_s += \" a filter between\"\r\n e_s += \"%s and %s percent of\" % (lb_frac * 100, ub_frac * 100)\r\n e_s += \"the Nyquist frequency\"\r\n raise ValueError(e_s)\r\n\r\n n_taps = self._filt_order + 1\r\n\r\n #This means the filter order you chose was too large (needs to be\r\n #shorter than a 1/3 of your time-series )\r\n if n_taps > self.data.shape[-1] * 3:\r\n e_s = \"The filter order chosen is too large for this time-series\"\r\n raise ValueError(e_s)\r\n\r\n # a is always 1:\r\n a = [1]\r\n\r\n sig = ts.TimeSeries(data=self.data, sampling_rate=self.sampling_rate)\r\n\r\n #Lowpass:\r\n if ub_frac < 1:\r\n b = signal.firwin(n_taps, ub_frac, window=self._win)\r\n sig = self.filtfilt(b, a, sig)\r\n\r\n #High-pass\r\n if lb_frac > 0:\r\n #Includes a spectral inversion:\r\n b = -1 * signal.firwin(n_taps, lb_frac, window=self._win)\r\n b[n_taps / 2] = b[n_taps / 2] + 1\r\n sig = self.filtfilt(b, a, sig)\r\n\r\n return sig","def normalizeprctile(expdat,percent=80):\n\tparams=locals()\n\n\t# select the bacteria to use - don't want to include very low freq. bacteria\n\tnewexp=hs.filterminreads(expdat,1*len(expdat.samples))\n\n\tpercvals=np.percentile(newexp.data,percent,axis=0)\n#\tplt.figure()\n#\tplt.plot(percvals)\n\tpercvals=percvals/np.mean(percvals)\n\tnewexp=hs.copyexp(expdat)\n\tfor idx,samp in enumerate(expdat.samples):\n\t\tnewexp.data[:,idx]=newexp.data[:,idx]*percvals[idx]\n\tnewexp.filters.append(\"normalize percentile %f\" % percent)\n\ths.addcommand(newexp,\"normalizeprctile\",params=params,replaceparams={'expdat':expdat})\n\n\treturn newexp","def do_mcp_nonlinearity_calibration():\n no_sample_data_path = ''.join([DATA_PATH, 'run108allevts.h5'])\n f = h5py.File(no_sample_data_path)\n phot = _get_photon_energy(f, 108)\n mcp = np.array(f['Acqiris2']['acq'])\n andor = np.array(f['Andor']['signal']-f['Andor']['reference'])\n # Subtract dark signals:\n dark_calibration = _get_dark_calibration()\n mcp = mcp-dark_calibration['mcp']\n andor = andor-dark_calibration['andor']\n # Take data within (relatively) narrow photon energy range:\n phot_in_range = (phot > 781) & (phot < 782)\n mcp = mcp[phot_in_range]\n andor = andor[phot_in_range]\n # make sure to only take data for which andor doesn't saturate\n mcp_percentile_cutoff = min([percentileofscore(andor, 4000), 99.9])\n mcp_cutoff_value = scoreatpercentile(mcp, mcp_percentile_cutoff)\n mcp_in_range = mcp < mcp_cutoff_value\n mcp = mcp[mcp_in_range]\n andor = andor[mcp_in_range]\n correction_polynomial = np.polyfit(\n mcp, \n andor*(np.mean(mcp)/np.mean(andor)),\n deg=3)\n plt.figure()\n plt.scatter(mcp, andor)\n plt.scatter(np.polyval(correction_polynomial, mcp), andor)\n pickle_on = open(MCP_CALIBRATION_FILE, 'wb')\n pickle.dump(correction_polynomial, pickle_on)\n pickle_on.close()","def get_cutoff(xml_file):\n\n heavy_atoms = 0\n with open(xml_file, 'r') as xml:\n for line in xml:\n if line.startswith('<Type'):\n # line.split('element')[1][2] is guaranteed* to be where the element names are in the xml. *hopefully\n if line.split('element')[1][2] != 'H':\n heavy_atoms += 1\n\n if heavy_atoms < 3:\n cutoff = 1.1\n elif heavy_atoms < 5:\n cutoff = 1.3\n else:\n cutoff = 1.5\n\n print(f'{heavy_atoms} heavy atoms found in {xml_file[:-4]}; cut-off is {cutoff}')\n return cutoff","def subtract_median_bias_residue_channel(ChannelCube,time=None,percentile=50):\n\n if time is None:\n time = np.arange(ChannelCube.shape[0])\n hsize = int(ChannelCube.shape[1]/2)\n\n TopBiasResidue = fit_slope_with_zero_intercept_residue(time,[np.percentile(tile,percentile) for tile in ChannelCube[:,0:hsize,:]])\n BotBiasResidue = fit_slope_with_zero_intercept_residue(time,[np.percentile(tile,percentile) for tile in ChannelCube[:,hsize:,:]])\n \n ResidueCorrectionSlopes = (TopBiasResidue - BotBiasResidue)/(hsize/2 - (hsize + hsize/2))\n x = np.arange(ChannelCube.shape[1])\n ResidueCorrection = BotBiasResidue[:,np.newaxis] + ResidueCorrectionSlopes[:,np.newaxis] * (x - (hsize + hsize/2))[np.newaxis,:]\n return ChannelCube + ResidueCorrection[:,:,np.newaxis]","def compute_value_at_bandwidth(self, x):\n x = x.value\n\n if x < 0:\n raise ComputeValueException(\n 'Bandwidth must be greater than 0: {0}'.format(x),\n 'TA.compute_value')\n elif x < self.total_minimum_bandwidth.value:\n return 0.0\n elif x < MAX_BANDWIDTH.value:\n return self.scaling_factor * \\\n (100 - 100 * (math.e ** (-self.c * x)))\n else:\n return self.scaling_factor * \\\n (100 - 100 * (math.e ** (-self.c * MAX_BANDWIDTH.value)))","def mfcc(signal,samplerate=16000,winlen=0.025,winstep=0.01,numcep=13,\n nfilt=26,nfft=512,lowfreq=0,highfreq=None,preemph=0.97,ceplifter=22,appendEnergy=True): \n feat, energy = fbank(signal,samplerate,winlen,winstep,nfilt,nfft,lowfreq,highfreq,preemph)\n feat = pylab.log(feat)\n feat = dct(feat, type=2, axis=1, norm='ortho')[:,:numcep]\n feat = lifter(feat,ceplifter)\n if appendEnergy: feat[:,0] = pylab.log(energy) # replace first cepstral coefficient with log of frame energy\n return feat","def apply_thresholding(x):\n return x > threshold_otsu(x)","def calculate_bandwidth(self, complist):\n\n self.type = complist[0]\n self.spot = complist[2]\n self.value = complist[1]\n self.fail = False\n\n if self.spot == \"1\" or self.spot == \"2\":\n # print \"Calculation if Loop 1st filter\"\n if self.type == \"C\":\n if self.c1 == 0:\n self.c1 = self.value\n else:\n self.fail = True\n else:\n if self.r1 == 0:\n self.r1 = self.value\n else:\n self.fail = True\n\n if self.spot == \"3\" or self.spot == \"4\":\n # print \"Calculation if loop 2nd filter\"\n if self.type == \"C\":\n if self.c2 == 0:\n self.c2 = self.value\n else:\n self.fail = True\n else: #self.type == \"R\"\n if self.r2 == 0:\n self.r2 = self.value\n else:\n self.fail = True\n\n if self.c1 != 0 and self.c2 != 0 and self.r1 != 0 and self.r2 != 0:\n cf_low = int((1/(2*pi*(self.r1)*(self.c1))/1000))\n #print \"hello!\"\n cf_low = str(cf_low)\n self.cutoff_freql = cf_low\n self.cutoff_freql_text = cf_low + \"K\"\n print self.cutoff_freql_text\n cf_high = int((1/(2*pi*(self.r2)*(self.c2))/1000))\n cf_high = str(cf_high)\n self.cutoff_freqh = cf_high\n self.cutoff_freqh_text = cf_high + \"K\"\n print self.cutoff_freqh_text\n voltage_change = float((self.r2)/self.r1)\n voltage = 5 + voltage_change\n self.voltage = str(voltage)\n print self.voltage","def calculate_enrichment_factor_optimal(molecules, ranked_dataset_percentage_cutoff, pic50_cutoff):\n\n ratio = sum(molecules[\"pIC50\"] >= pic50_cutoff) / len(molecules) * 100\n if ranked_dataset_percentage_cutoff <= ratio:\n enrichment_factor_optimal = round(100 / ratio * ranked_dataset_percentage_cutoff, 1)\n else:\n enrichment_factor_optimal = 100.0\n return enrichment_factor_optimal","def filt_bp(sig: np.ndarray, Ss: int, Cfs0: int, Cfs1: None,\n order=5) -> np.ndarray:\n nyq = 0.5 * Ss\n normal_cutoff1 = Cfs0 / nyq\n normal_cutoff2 = Cfs1 / nyq\n b, a = butter(order, (normal_cutoff1, normal_cutoff2),\n btype='band',\n analog=False)\n return lfilter(b, a, sig)"],"string":"[\n \"def cut_spectrum(input_spectrum, desired_frequency_range):\\n channels_ip = []\\n for ip in input_spectrum.GetChannels():\\n channel_ip = []\\n channel_op = []\\n for n, i in enumerate(ip):\\n if n > desired_frequency_range[0] / input_spectrum.GetResolution() and n < desired_frequency_range[1] / \\\\\\n input_spectrum.GetResolution():\\n channel_ip.append(i)\\n else:\\n channel_ip.append(0.0)\\n channel_op.append(0.0)\\n channels_ip.append(tuple(channel_ip))\\n input_spectrum_modified = sumpf.Spectrum(channels=tuple(channels_ip), resolution=input_spectrum.GetResolution(),\\n labels=input_spectrum.GetLabels())\\n return input_spectrum_modified\",\n \"def get_silence_threshold(sound, lower_quantile):\\n soundint = sound.to_intensity()\\n max_intensity = call(soundint, 'Get quantile', 0.0, 0.0, 1)\\n sil_intensity = call(soundint, 'Get quantile', 0.0, 0.0, lower_quantile)\\n return sil_intensity - max_intensity\",\n \"def sigmaCorrectionFactor(baselineMode, npts, percentile):\\n edgeValue = (npts/128.)**0.08\\n if (baselineMode == 'edge'):\\n return(edgeValue)\\n value = edgeValue*2.8*(percentile/10.)**-0.25\\n casalogPost(\\\"sigmaCorrectionFactor using percentile = %g to get sCF=%g\\\" % (percentile, value), debug=True)\\n return(value)\",\n \"def bandstop_filter(data, lowcut, highcut, fs=2000, numtaps=255):\\n nyq = fs / 2\\n\\n # design filter\\n fe1 = lowcut / nyq\\n fe2 = highcut / nyq\\n b = firwin(numtaps, (fe1, fe2), pass_zero=True)\\n\\n filtered = lfilter(b, 1, data)\\n\\n return filtered\",\n \"def low_cut_filter(x, fs, cutoff=70):\\n nyquist = fs // 2\\n norm_cutoff = cutoff / nyquist\\n\\n # low cut filter\\n fil = firwin(255, norm_cutoff, pass_zero=False)\\n lcf_x = lfilter(fil, 1, x)\\n\\n return lcf_x\",\n \"def iqr_outlier_cutoff(myseries, multiplier=1.5):\\n # calculate IQR\\n q1 = myseries.quantile(.25)\\n q3 = myseries.quantile(.75)\\n iqr = q3 - q1\\n\\n # get outlier cutoff\\n cutoff = q3 + iqr*multiplier\\n\\n return cutoff\",\n \"def compute_percentile(value, cutoffs):\\n\\tif value < cutoffs[0]:\\n\\t\\treturn 0.0\\n\\n\\tfor i, cutoff in enumerate(cutoffs):\\n\\t\\tif value < cutoff:\\n\\t\\t\\treturn math.floor(100 * (float(i)/(len(cutoffs))))\\n\\t\\t\\tbreak\\n\\treturn 100.0\",\n \"def _standardize_cutoff(cutoff):\\n cutoff = np.asarray(cutoff)\\n cutoff[0] = max(0., cutoff[0])\\n cutoff[1] = min(1., cutoff[1])\\n cutoff[0] = np.min([cutoff[0], 0.09])\\n cutoff[1] = np.max([cutoff[1], 0.91])\\n return cutoff\",\n \"def butter_bandstop_filter(data, lowcut, highcut, fs, order):\\n\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n\\n i, u = sg.butter(order, (low, high), btype='bandstop')\\n y = sg.filtfilt(i, u, data)\\n return y\",\n \"def get_thresh(amp,c): \\n #Helper functions for fitting the psychometric curve, need to be\\n #defined within the local scope, so that they can grok the data:\\n \\n def weib_fit(pars):\\n thresh,slope = pars\\n return weibull(x,thresh,slope,guess,flake)\\n\\n def err_func(pars):\\n return y-weib_fit(pars)\\n\\n #Throw away the None's:\\n hit_amps = amp[c==1]\\n miss_amps = amp[c==0]\\n\\n # Get rid of floating point error:\\n hit_amps = defloaterrorize(hit_amps)\\n miss_amps = defloaterrorize(miss_amps)\\n\\n all_amps = np.hstack([hit_amps,miss_amps])\\n stim_intensities = np.unique(all_amps)\\n\\n n_correct = [len(np.where(hit_amps==i)[0]) for i in stim_intensities]\\n n_trials = [len(np.where(all_amps==i)[0]) for i in stim_intensities]\\n Data = zip(stim_intensities,n_correct,n_trials)\\n x = []\\n y = []\\n n = []\\n for idx,this in enumerate(Data):\\n #Take only cases where there were at least n_up observations:\\n if n_trials[idx]>=self.n_up:\\n #Contrast values: \\n x = np.hstack([x,this[2] * [this[0]]])\\n #% correct:\\n y = np.hstack([y,this[2] * [this[1]/float(this[2])]])\\n\\n initial = np.mean(x),slope\\n this_fit , msg = leastsq(err_func,initial)\\n return this_fit,x,y\",\n \"def bandpass_filter(data, lowcut, highcut, fs=2000, numtaps=255):\\n nyq = fs / 2\\n\\n # design filter\\n fe1 = lowcut / nyq\\n fe2 = highcut / nyq\\n b = firwin(numtaps, (fe1, fe2), pass_zero=False)\\n\\n filtered = lfilter(b, 1, data)\\n\\n return filtered\",\n \"def clip_signal(signal, clipping_thresh=1000, clipped_value=215):\\n index_factor = rate / CHUNK\\n while index_factor * np.argmax(signal) >= clipping_thresh:\\n signal[np.argmax(signal)] = 0\\n return signal\",\n \"def _adjust_screening_percentile(screening_percentile, mask_img, verbose=0):\\n original_screening_percentile = screening_percentile\\n # correct screening_percentile according to the volume of the data mask\\n mask_volume = _get_mask_volume(mask_img)\\n if mask_volume > 1.1 * MNI152_BRAIN_VOLUME:\\n warnings.warn(\\n \\\"Brain mask is bigger than the volume of a standard \\\"\\n \\\"human brain. This object is probably not tuned to \\\"\\n \\\"be used on such data.\\\",\\n stacklevel=2,\\n )\\n elif mask_volume < 0.005 * MNI152_BRAIN_VOLUME:\\n warnings.warn(\\n \\\"Brain mask is smaller than .5% of the volume \\\"\\n \\\"human brain. This object is probably not tuned to \\\"\\n \\\"be used on such data.\\\",\\n stacklevel=2,\\n )\\n\\n if screening_percentile < 100.0:\\n screening_percentile = screening_percentile * (\\n MNI152_BRAIN_VOLUME / mask_volume\\n )\\n screening_percentile = min(screening_percentile, 100.0)\\n # if screening_percentile is 100, we don't do anything\\n\\n if verbose > 1:\\n print(\\n f\\\"Mask volume = {mask_volume:g}mm^3 = {mask_volume / 1000.0:g}cm^3\\\"\\n )\\n print(\\n \\\"Standard brain volume \\\"\\n f\\\"= {MNI152_BRAIN_VOLUME:g}mm^3 \\\"\\n f\\\"= {MNI152_BRAIN_VOLUME / 1.0e3:g}cm^3\\\"\\n )\\n print(\\n f\\\"Original screening-percentile: {original_screening_percentile:g}\\\"\\n )\\n print(\\n f\\\"Volume-corrected screening-percentile: {screening_percentile:g}\\\"\\n )\\n return screening_percentile\",\n \"def filter_pupil(self, hp=0.01, lp=10.0):\\r\\n self.logger.info('Band-pass filtering of pupil signals, hp = %2.3f, lp = %2.3f'%(hp, lp))\\r\\n\\r\\n self.lp_filt_pupil = _butter_lowpass(data=self.interpolated_pupil.astype('float64'), highcut=lp, fs=self.sample_rate, order=3)\\r\\n self.hp_filt_pupil = _butter_highpass(data=self.interpolated_pupil.astype('float64'), lowcut=hp, fs=self.sample_rate, order=3)\\r\\n self.bp_filt_pupil = self.hp_filt_pupil - (self.interpolated_pupil-self.lp_filt_pupil)\\r\\n self.baseline_filt_pupil = self.lp_filt_pupil - self.bp_filt_pupil\\r\\n\\r\\n # import mne\\r\\n # from mne import filter\\r\\n # self.lp_filt_pupil = mne.filter.low_pass_filter(x=self.interpolated_pupil.astype('float64'), Fs=self.sample_rate, Fp=lp, filter_length=None, method='iir', iir_params={'ftype':'butter', 'order':3}, picks=None, n_jobs=1, copy=True, verbose=None)\\r\\n # self.hp_filt_pupil = mne.filter.high_pass_filter(x=self.interpolated_pupil.astype('float64'), Fs=self.sample_rate, Fp=hp, filter_length=None, method='iir', iir_params={'ftype':'butter', 'order':3}, picks=None, n_jobs=1, copy=True, verbose=None)\\r\\n # self.bp_filt_pupil = self.hp_filt_pupil - (self.interpolated_pupil-self.lp_filt_pupil)\\r\\n # self.baseline_filt_pupil = self.lp_filt_pupil - self.bp_filt_pupil\\r\",\n \"def filterHighs( adata, bandlimit = 5000) :\\n\\n # TODO: compute Fourier representation of data\\n\\n fig = plt.figure()\\n fig.add_subplot(2, 1, 1)\\n plt.plot( np.real(fdata))\\n plt.xlim( [0,adata.size])\\n\\n # TODO: filter data\\n\\n fig.add_subplot(2, 1, 2)\\n plt.plot( np.real(fdata))\\n plt.xlim( [0,adata.size])\\n plt.show()\\n\\n # TODO: restore time domain representation of data\\n\\n return adata_filtered\",\n \"def outlier_thresholds(dataframe, col_name, low_quantile, up_quantile):\\n quartile1 = dataframe[col_name].quantile(low_quantile)\\n quartile3 = dataframe[col_name].quantile(up_quantile)\\n interquantile_range = quartile3 - quartile1\\n up_limit = quartile3 + 1.5 * interquantile_range\\n low_limit = quartile1 - 1.5 * interquantile_range\\n return low_limit, up_limit\",\n \"def butter_bandpass_filter(data, lowcut, highcut, fs, order=5, axis=0): \\n omega = 0.5 * fs\\n low = lowcut / omega\\n high = highcut / omega\\n b, a = signal.butter(order, [low, high], btype='band')\\n y = signal.lfilter(b, a, data, axis=0)\\n return y\",\n \"def heat_chi2_cut(stream, df):\\n heat_chi2_threshold = quality_parameters[stream]['heat_chi2_threshold']\\n chi2_heat = df['chi2_heat']\\n energy_adu_heat = df['energy_adu_heat']\\n \\n # chi2_threshold = heat_chi2_threshold * ( 1 + (energy_adu_heat/2e3)**2 )\\n chi2_threshold = heat_chi2_threshold_function(\\n heat_chi2_threshold,\\n energy_adu_heat\\n )\\n \\n df['chi2_heat_cut'] = (chi2_heat < chi2_threshold)\\n \\n return None\",\n \"def telluric_mask(data, sigma=2.5, lsf=4.8, pwv=None, pixel_start=10, pixel_end=-30, outlier_rejection=2.5, diagnostic=True, save_to_path='./'):\\n\\n\\tdata.flux = data.flux[pixel_start:pixel_end]\\n\\tdata.wave = data.wave[pixel_start:pixel_end]\\n\\tdata.noise = data.noise[pixel_start:pixel_end]\\n\\n\\tdata0 = copy.deepcopy(data)\\n\\n\\t# take the closest airmass from the header\\n\\tairmass = float(round(data.header['AIRMASS']*2)/2)\\n\\tif airmass > 3.0: airmass = 3.0\\n\\n\\t# simple chi2 comparison with different pwv\\n\\tif pwv is None:\\n\\t\\tpwvs = [0.5, 1.0, 1.5, 2.5, 3.5, 5.0, 7.5, 10.0, 20.0]\\n\\t\\tpwv_chi2 = []\\n\\t\\t\\n\\t\\tfor pwv in pwvs:\\n\\t\\t\\tdata_tmp = copy.deepcopy(data)\\n\\t\\n\\t\\t\\t#data_tmp = smart.continuumTelluric(data=data_tmp, model=model_tmp)\\n\\t\\t\\tmodel_tmp = tellurics.makeTelluricModel(lsf=lsf, airmass=airmass, pwv=pwv, flux_offset=0, wave_offset=0, data=data_tmp, deg=10)\\n\\t\\n\\t\\t\\tmodel_tmp.flux = np.array(smart.integralResample(xh=model_tmp.wave, yh=model_tmp.flux, xl=data_tmp.wave))\\n\\t\\t\\tmodel_tmp.wave = data_tmp.wave\\n\\n\\t\\t\\t#plt.plot(data_tmp.wave, data_tmp.flux, 'k-')\\n\\t\\t\\t#plt.plot(model_tmp.wave, model_tmp.flux, 'r-')\\n\\t\\t\\t#plt.show()\\n\\t\\t\\t#plt.close()\\n\\t\\n\\t\\t\\tpwv_chi2.append(smart.chisquare(data_tmp, model_tmp))\\n\\t\\t# find the pwv with minimum chisquare\\n\\t\\tpwv_chi2_array = np.array(pwv_chi2)\\n\\t\\t\\n\\t\\tif diagnostic:\\n\\t\\t\\tplt.plot(pwvs, pwv_chi2)\\n\\t\\t\\tplt.xlabel('pwv (mm)', fontsize=15)\\n\\t\\t\\tplt.ylabel('$\\\\chi^2$', fontsize=15)\\n\\t\\t\\tplt.tight_layout()\\n\\t\\t\\tplt.savefig(save_to_path+'pwv_chi2.png')\\n\\t\\t\\t#plt.show()\\n\\t\\t\\tplt.close()\\n\\n\\tpwv_min_index = np.where(pwv_chi2_array == np.min(pwv_chi2_array))[0][0]\\n\\tpwv = pwvs[pwv_min_index]\\n\\n\\tdata_tmp = copy.deepcopy(data)\\n\\n\\tmodel = tellurics.makeTelluricModel(lsf=lsf, airmass=airmass, pwv=pwv, flux_offset=0, wave_offset=0, data=data_tmp)\\n\\n\\tmodel_0 = copy.deepcopy(model)\\n\\n\\t# generate the mask based on sigma clipping\\n\\tpixel = np.delete(np.arange(len(data.oriWave)), data.mask)[pixel_start: pixel_end]\\n\\t#pixel = np.delete(np.arange(len(data_tmp.oriWave)),data_tmp.mask)\\n\\tmask = pixel[np.where(np.abs(data_tmp.flux-model.flux) > outlier_rejection*np.std(data_tmp.flux-model.flux))]\\n\\n\\t#plt.plot(data_tmp.wave, data_tmp.flux, 'k-')\\n\\t#plt.plot(model.wave, model.flux, 'r-')\\n\\t#plt.show()\\n\\t#plt.close()\\n\\n\\tdata_tmp.mask_custom(mask)\\n\\tdata_tmp.flux = data_tmp.flux[pixel_start:pixel_end]\\n\\tdata_tmp.wave = data_tmp.wave[pixel_start:pixel_end]\\n\\tdata_tmp.noise = data_tmp.noise[pixel_start:pixel_end]\\n\\n\\t#plt.plot(data_tmp.wave, data_tmp.flux, 'k-')\\n\\t#plt.plot(model.wave, model.flux, 'r-')\\n\\t#plt.show()\\n\\t#plt.close()\\n\\n\\t# use curve_fit\\n\\tdef tell_model_fit(wave, airmass, pwv, flux_offset, wave_offset):\\n\\t\\tmodel = tellurics.makeTelluricModel(lsf=lsf, airmass=airmass, pwv=pwv, flux_offset=flux_offset, wave_offset=wave_offset, data=data_tmp)\\n\\t\\treturn model.flux\\n\\n\\tprint('initial airmass and pwv', airmass, pwv)\\n\\tflux_med = np.median(data_tmp.flux)\\n\\tp0 = [airmass, pwv, 0, 0]\\n\\tbounds = ([airmass-0.5, pwv-0.5, -flux_med*0.05, -0.05], [airmass+0.5, pwv+0.5, flux_med*0.05, 0.05])\\n\\n\\tpopt, pcov = curve_fit(tell_model_fit, data_tmp.wave, data_tmp.flux, p0=p0, bounds=bounds)\\n\\n\\tairmass, pwv, flux_offset, wave_offset = popt[0], popt[1], popt[2], popt[3]\\n\\tprint('best-fit airmass, pwv, flux_offset, wave_offset', airmass, pwv, flux_offset, wave_offset)\\n\\tmodel = tellurics.makeTelluricModel(lsf=lsf, airmass=airmass, pwv=pwv, flux_offset=0, wave_offset=0, data=data_tmp)\\n\\tprint('old telluric mask', mask)\\n\\tpixel = np.delete(np.arange(len(data_tmp.oriWave)), mask)[pixel_start: pixel_end]\\n\\t#print('len pixel, data, model', len(pixel), len(data_tmp.wave), len(model.wave))\\n\\tmask = pixel[np.where(np.abs(data_tmp.flux-model.flux) > outlier_rejection*np.std(data_tmp.flux-model.flux))]\\n\\t# combine the masks\\n\\tmask = np.union1d(mask,np.array(data_tmp.mask))\\n\\tprint('new telluric mask', mask)\\n\\n\\tdata.mask_custom(mask)\\n\\tdata.flux = data.flux[pixel_start:pixel_end]\\n\\tdata.wave = data.wave[pixel_start:pixel_end]\\n\\tdata.noise = data.noise[pixel_start:pixel_end]\\n\\tprint(data.mask)\\n\\n\\t#plt.plot(data.wave, data.flux, 'k-')\\n\\t#plt.plot(model.wave, model.flux, 'r-')\\n\\t#plt.plot(model_0.wave, model_0.flux, 'b-', alpha=0.5)\\n\\t#plt.show()\\n\\t#plt.close()\\n\\n\\tif diagnostic:\\n\\t\\tdata.flux = data.flux[pixel_start:pixel_end]\\n\\t\\tdata.wave = data.wave[pixel_start:pixel_end]\\n\\t\\tdata.noise = data.noise[pixel_start:pixel_end]\\n\\t\\t\\n\\t\\tmodel = tellurics.makeTelluricModel(lsf=lsf, airmass=airmass, pwv=pwv, flux_offset=0, wave_offset=0, data=data)\\n\\t\\t\\n\\t\\tplt.plot(data0.wave, data0.flux, 'k-', label='original data', alpha=0.5)\\n\\t\\tplt.plot(data.wave, data.flux, 'k-', label='masked data')\\n\\t\\tplt.plot(model.wave, model.flux, 'r-', alpha=0.7)\\n\\t\\tplt.plot(data.wave, data.flux-model.flux, 'r-')\\n\\t\\tplt.xlabel('$\\\\lambda (\\\\AA)$')\\n\\t\\tplt.ylabel('$F_{\\\\lambda}$')\\n\\t\\tplt.savefig(save_to_path+'telluric_data_model_mask.png')\\n\\t\\t#plt.show()\\n\\t\\tplt.close()\\n\\n\\treturn mask.tolist(), pwv, airmass\",\n \"def computeMedianCorrectionFactor(baselineMode, percentile):\\n if (baselineMode == 'edge'):\\n return(0)\\n return(6.3*(5.0/percentile)**0.5)\",\n \"def internal_external_canopy_heat_capacity(lumped_cover_heat_capacity: float) -> float:\\n return 0.1 * lumped_cover_heat_capacity\",\n \"def sky_median_sig_clip(input_arr, sig_fract, percent_fract, max_iter=100, low_cut=True, high_cut=True):\\r\\n\\t\\r\\n\\twork_arr = np.ravel(input_arr)\\r\\n\\told_sky = np.median(work_arr)\\r\\n\\toldStaDesviation = work_arr.std()\\r\\n\\tupper_limit = old_sky + sig_fract * oldStaDesviation\\r\\n\\tlower_limit = old_sky - sig_fract * oldStaDesviation\\r\\n\\tif low_cut and high_cut:\\r\\n\\t\\tindices = np.where((work_arr < upper_limit) & (work_arr > lower_limit))\\r\\n\\telse:\\r\\n\\t\\tif low_cut:\\r\\n\\t\\t\\tindices = np.where((work_arr > lower_limit))\\r\\n\\t\\telse:\\r\\n\\t\\t\\tindices = np.where((work_arr < upper_limit))\\r\\n\\twork_arr = work_arr[indices]\\r\\n\\tnew_sky = np.median(work_arr)\\r\\n\\titeration = 0\\r\\n\\twhile ((math.fabs(old_sky - new_sky)/new_sky) > percent_fract) and (iteration < max_iter) :\\r\\n\\t\\titeration += 1\\r\\n\\t\\told_sky = new_sky\\r\\n\\t\\toldStaDesviation = work_arr.std()\\r\\n\\t\\tupper_limit = old_sky + sig_fract * oldStaDesviation\\r\\n\\t\\tlower_limit = old_sky - sig_fract * oldStaDesviation\\r\\n\\t\\tif low_cut and high_cut:\\r\\n\\t\\t\\tindices = np.where((work_arr < upper_limit) & (work_arr > lower_limit))\\r\\n\\t\\telse:\\r\\n\\t\\t\\tif low_cut:\\r\\n\\t\\t\\t\\tindices = np.where((work_arr > lower_limit))\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tindices = np.where((work_arr < upper_limit))\\r\\n\\t\\twork_arr = work_arr[indices]\\r\\n\\t\\tnew_sky = np.median(work_arr)\\r\\n\\treturn (new_sky, iteration)\",\n \"def calc_iqr(sig):\\n # iqr = subtract(*percentile(sig, [75, 25]))\\n return np.percentile(sig, 75) - np.percentile(sig, 25)\",\n \"def percentile_filter(data, feats):\\n\\n # Determines the fraction of nonzero values in the data.\\n sparsity_frac = feats['nonzeros'] / (feats['nrows'] * feats['ncols'])\\n\\n # NOTE: Added convenience term derived from experience.\\n thresh = np.percentile(data.ravel(), q=100 * (1 - (sparsity_frac + 0.1)))\\n\\n # Replace p-values below threshold with zero.\\n data[(data > 0) & (data < thresh)] = 0\\n\\n return data\",\n \"def limit(filename,threshold,makeup,wout=True,plot=False):\\n start=time.time()\\n n, data, data_dB,sr,ch=inputwav(filename)\\n dataL,dataL_bit=compress(filename,threshold,1000.0,makeup,1.0,500.0,wout=False,plot=plot)\\n if wout==True:\\n print('Exporting...')\\n sf.write(filename[0:len(filename)-4]+'_limit.wav',dataL_bit,44100,'PCM_16')\\n end=time.time()\\n elapsed=int(1000*(end-start))\\n print('Done!')\\n print('...............................')\\n print('Completed in '+str(elapsed)+' milliseconds.') \\n return dataL,dataL_bit\",\n \"def filter_sat(img_sat_ch, threshold = (170,255)):\\n assert img_sat_ch.ndim==2\\n sat_binary = np.zeros_like(img_sat_ch)\\n scaled_s_ch = np.uint8(255*img_sat_ch/np.max(img_sat_ch))\\n sat_binary[(scaled_s_ch >= threshold[0]) & (scaled_s_ch <= threshold[1])] = 1\\n return sat_binary\",\n \"def perc(data,percentile):\\n clip_value = np.percentile(data,percentile)\\n data = clip(data,clip_value)\\n return data\",\n \"def _compute_cutoffs(self):\\n self._cutoffidx=np.zeros(self.nsamples,dtype=np.int)\\n # Find the inlfection point\\n # TODO: check robustness of this method against fluctuations in the data\\n self.samplesdatadiff=np.diff(self.samplesdata,axis=0)\\n flex=np.argmax(self.samplesdatadiff,axis=0)\\n # if the detected cycles is the last one, then the flex has not yet been reached, warn.\\n for i,f in enumerate(flex):\\n #self._message(\\\"(%s) Preanalysis - detection of inflection point.\\\"%(self.samples[i])) \\n if f==(self.nvalues-1):\\n self._cutoffidx[i]=f\\n self._message(\\\"Warning: (%s) Inflection point not detected. Using all fluorescent values available (%d cycles).\\\"%(self.samples[i],f)) \\n elif f<10:\\n self._message(\\\"Warning: (%s) Early inflection point (cycle %d).\\\"%(self.samples[i],f))\\n else: \\n self._cutoffidx[i]=np.minimum(f+2,self.nvalues)\\n #self._message(\\\"(%s) Inflection point found at cycle %d).\\\"%(self.samples[i],f)) \",\n \"def set_min_uncertainty(signal, threshold=0.05):\\n # Increase Hirex-Sr uncertainties to be a rel error of 5% minimum (JUST FOR TESTING)\\n corrected_unc=signal.std_y/signal.y<=0.05\\n signal.std_y[corrected_unc]=0.05*signal.y[corrected_unc]\\n\\n # correction for normalized uncertainties\\n if signal.s/signal.m<=0.05:\\n signal.s=0.05*signal.m\\n\\n signal.std_y_norm=scipy.sqrt((signal.std_y / signal.m)**2.0 + ((signal.y / signal.m)*(signal.s / signal.m))**2.0)\",\n \"def findScalingCoeffsLimiter(self, PFC, lqCN, lqCF):\\n # Get R and Z vectors at the midplane\\n# R_omp_sol = PFC.ep.g['lcfs'][:,0].max()\\n R_omp_sol = self.map_R_psi(1.0,PFC)\\n R_omp_min = R_omp_sol #this is a limited discharge so Rmin = Rlcfs\\n if lqCN > lqCF:\\n lqMax = lqCN\\n else:\\n lqMax = lqCF\\n R_omp_max = R_omp_sol + 20.0*lqMax #already in m\\n #if R_omp_max is outside EFIT grid, cap at maximum R of grid\\n if R_omp_max > max(PFC.ep.g['R']):\\n R_omp_max = max(PFC.ep.g['R']) #in meters now\\n R_omp = np.linspace(R_omp_min, R_omp_max, 1000)\\n Z_omp = np.zeros(R_omp.shape)\\n\\n # Evaluate B at outboard midplane\\n Bp_omp = PFC.ep.BpFunc.ev(R_omp,Z_omp)\\n Bt_omp = PFC.ep.BtFunc.ev(R_omp,Z_omp)\\n B_omp = np.sqrt(Bp_omp**2 + Bt_omp**2)\\n\\n #Find coordinate transformation vector at midplane\\n psiaxis = PFC.ep.g['psiAxis']\\n psiedge = PFC.ep.g['psiSep']\\n deltaPsi = np.abs(psiedge - psiaxis)\\n gradPsi = Bp_omp*R_omp\\n xfm = gradPsi / deltaPsi\\n\\n # transform hf width into flux space\\n lqCN_hat = lqCN*xfm\\n lqCF_hat = lqCF*xfm\\n\\n\\n #Calculate flux at midplane using gfile\\n psiN = PFC.ep.psiFunc.ev(R_omp,Z_omp)\\n psi = psiN*(psiedge - psiaxis) + psiaxis\\n PFC.psiMinLCFS = PFC.ep.psiFunc.ev(R_omp_sol,0.0)\\n s_hat = psiN - PFC.psiMinLCFS\\n\\n\\n print('psiMinLCFS: {:f}'.format(PFC.psiMinLCFS))\\n# print('un-normalized psiMinLCFS: {:f}'.format(PFC.ep.psiFunc_noN.ev(R_omp_sol,0.0)))\\n print('Minimum s_hat: {:f}'.format(s_hat.min()))\\n\\n\\n #integral in flux space\\n qCN_hat = np.exp(-s_hat / lqCN_hat)\\n qCF_hat = np.exp(-s_hat / lqCF_hat)\\n\\n #note: simps integration will fail if x variable (psi) is not monotonic\\n #reinke method\\n #intCN = simps(qCN_hat / B_omp, psi)\\n #intCF = simps(qCF_hat / B_omp, psi)\\n #menard method\\n intCN = simps(qCN_hat, psi)\\n intCF = simps(qCF_hat, psi)\\n\\n P0 = 2*np.pi * (intCN*self.fracCN + intCF*self.fracCF)\\n #account for nonphysical power\\n if P0 < 0: P0 = -P0\\n #Scale to input power\\n q0 = self.Psol/P0\\n\\n #old method left for reference\\n #q0 = (self.Psol/(2*np.pi)) / (intCN*self.fracCN + intCF*self.fracCF)\\n\\n return q0\",\n \"def butter_bp_coe(lowcut, highcut, fs, order=1):\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n b, a = butter(order, [low, high], btype='band')\\n return b, a\",\n \"def ssc(signal,samplerate=16000,winlen=0.025,winstep=0.01,\\n nfilt=26,nfft=512,lowfreq=0,highfreq=None,preemph=0.97): \\n highfreq= highfreq or samplerate/2\\n signal = sigproc.preemphasis(signal,preemph)\\n frames = sigproc.framesig(signal, winlen*samplerate, winstep*samplerate)\\n pspec = sigproc.powspec(frames,nfft)\\n pspec = pylab.where(pspec == 0,pylab.finfo(float).eps,pspec) # if things are all zeros we get problems\\n \\n fb = get_filterbanks(nfilt,nfft,samplerate,lowfreq,highfreq)\\n feat = pylab.dot(pspec,fb.T) # compute the filterbank energies\\n R = pylab.tile(pylab.linspace(1,samplerate/2,pylab.size(pspec,1)),(pylab.size(pspec,0),1))\\n \\n return pylab.dot(pspec*R,fb.T) / feat\",\n \"def _find_cutoff(self):\\n cutoff = 1\\n while ((self.linear_rstar_unnorm(cutoff) -\\n self.turing_rstar_unnorm(cutoff))**2\\n > self.approx_turing_variance(cutoff)):\\n cutoff += 1\\n return cutoff\",\n \"def butter_filter(datalist):\\n fs = 200.00\\n fHigh = 50.00\\n fLow = 5.00\\n N=4\\n [b,a]=sg.butter(N,[fLow/fs, fHigh/fs], btype='band')\\n global filtered\\n #IIR filter\\n return sg.filtfilt(b,a,datalist)\",\n \"def piece_wise_cutoff(dist, cutoff):\\n return (0.5 * np.cos(np.pi * dist / cutoff) + 0.5) * (dist <= cutoff)\",\n \"def optimalFilter(mp):#, signalTransform = None):\\n\\n \\\"\\\"\\\" get power spectra of cmb and noise maps \\\"\\\"\\\"\\n pNoise = liteMap1.fftTools1.powerFromLiteMap(mp)\\n pNoise = pNoise.powerMap\\n pNoise = liteMap1.liteMapFromDataAndWCS(pNoise, mp.wcs)\\n\\n return pNoise\\n\\n \\\"\\\"\\\" calculate filter \\\"\\\"\\\"\",\n \"def get_bright_noise(image, csf_noise, percentiles):\\n image_array = sitk.GetArrayViewFromImage(image)\\n csf_mean = sitk.GetArrayViewFromImage(csf_noise).mean()\\n perc_a, perc_b = np.percentile(image_array, percentiles)\\n new_mean = torch.FloatTensor(1).uniform_(perc_a, perc_b).item()\\n return csf_noise + (new_mean - csf_mean)\",\n \"def process_unc(unc):\\n unc = np.where(unc == 32767, np.nan, unc/1000.)\",\n \"def compute_cutoff_threshold(C: list, threshold: float):\\n C.append({'e': threshold, 'c': 0})\\n C = sorted(C, key=lambda k: k['e'])\\n cutoff = 0.0\\n gap = 0.0\\n i = 0\\n while i < len(C) - 1 and C[i + 1]['e'] <= threshold:\\n if gap < (C[i + 1]['e'] - C[i]['e']):\\n gap = C[i + 1]['e'] - C[i]['e']\\n cutoff = C[i]['e']\\n i += 1\\n return cutoff\",\n \"def clip_outliers(values, p=99):\\n min = np.percentile(values, 100 - p)\\n max = np.percentile(values, p)\\n return np.clip(values, min, max)\",\n \"def clip_outliers(values, p=99):\\n min = np.percentile(values, 100 - p)\\n max = np.percentile(values, p)\\n return np.clip(values, min, max)\",\n \"def clip_at_nth(infits, cut=10):\\n\\n#\\n#--- trim the extreme values\\n#\\n upper = find_nth(infits, cut)\\n\\n cmd1 = \\\"/usr/bin/env PERL5LIB=\\\"\\n cmd2 = ' dmimgthresh infile=' + infits+ ' outfile=zout.fits cut=\\\"0:' + str(upper) + '\\\" value=0 clobber=yes'\\n cmd = cmd1 + cmd2\\n bash(cmd, env=ascdsenv)\\n\\n outfile = infits.replace('.fits','_full.fits')\\n cmd = 'mv ' + infits + ' ' + outfile\\n os.system(cmd)\\n \\n m = re.search('gz', infits)\\n if m is not None:\\n os.system('gzip zout.fits')\\n cmd = 'mv zout.fits.gz ' + infits\\n os.system(cmd)\\n else:\\n cmd = 'mv zout.fits ' + infits\\n os.system(cmd)\",\n \"def interpolate_turbidity_cutoff_probability(turb, levels):\\n probability_all = np.zeros_like(turb)\\n # The last dimension through apply_ufnuc is the quantile dimension\\n funclist = [\\n lambda v1, v2: (12.0 - v1) / (v2 - v1) * 0.20 + 0.05,\\n lambda v1, v2: (12.0 - v1) / (v2 - v1) * 0.25 + 0.25,\\n lambda v1, v2: (12.0 - v1) / (v2 - v1) * 0.25 + 0.5,\\n lambda v1, v2: (12.0 - v2) / (v2 - v1) * 0.25 + 0.75,\\n ]\\n n_quantiles = turb.shape[-1]\\n for l in range(n_quantiles):\\n # For the last quantile, use the previous quantile set\\n l_ = l if l != n_quantiles - 1 else l - 1\\n v1 = turb[..., l_]\\n v2 = turb[..., l_ + 1]\\n probability_all[..., l] = funclist[l](v1, v2)\\n result = np.select(\\n [levels == i for i in range(n_quantiles)],\\n [probability_all[..., i] for i in range(n_quantiles)],\\n default=0.0,\\n )\\n np.clip(result, 0.0, 1.0, out=result)\\n return result\",\n \"def _signal_filter_butterworth(signal, sampling_rate=1000, lowcut=None, highcut=None, order=2):\\n if lowcut is not None and highcut is not None:\\n sos = scipy.signal.butter(order, [lowcut, highcut], btype=\\\"bandpass\\\", output='sos', fs=sampling_rate)\\n elif lowcut is not None:\\n sos = scipy.signal.butter(order, [lowcut], btype=\\\"highpass\\\", output='sos', fs=sampling_rate)\\n elif highcut is not None:\\n sos = scipy.signal.butter(order, [highcut], btype=\\\"lowpass\\\", output='sos', fs=sampling_rate)\\n\\n filtered = scipy.signal.sosfiltfilt(sos, signal)\\n return filtered\",\n \"def filter_percentile(df, col, up=95, down=5):\\n pup = np.percentile(df[col].values, up)\\n pdw = np.percentile(df[col].values, down)\\n\\n s = (df[col]<pup) & (df[col]>pdw)\\n df2 = df[s]\\n\\n return df2\",\n \"def FoldChangeFilterBasedOnMaxFC(X, data_headers, cutoff=0.5):\\n XX = Linear(X.copy(), data_headers)\\n X_ToMin = XX[data_headers] / XX[data_headers].min(axis=0)\\n Xidx = np.any(X_ToMin.values >= X_ToMin.max().values * cutoff, axis=1)\\n return X.iloc[Xidx, :]\",\n \"def _get_percentile_cutoff(data, cutoff=None, percentile=None, required=False):\\n if percentile is not None:\\n if cutoff is not None:\\n raise ValueError(\\n \\\"Only one of `cutoff` and `percentile` should be given.\\\"\\n \\\"Got cutoff={}, percentile={}\\\".format(cutoff, percentile)\\n )\\n if not isinstance(percentile, numbers.Number):\\n return [_get_percentile_cutoff(data, percentile=p) for p in percentile]\\n if percentile < 1:\\n warnings.warn(\\n \\\"`percentile` expects values between 0 and 100.\\\"\\n \\\"Got {}. Did you mean {}?\\\".format(percentile, percentile * 100),\\n UserWarning,\\n )\\n cutoff = np.percentile(np.array(data).reshape(-1), percentile)\\n elif cutoff is None and required:\\n raise ValueError(\\\"One of either `cutoff` or `percentile` must be given.\\\")\\n return cutoff\",\n \"def butter_highpass_filter(data, cutoff, fs, order=1):\\n b, a = butter_highpass(cutoff, fs, order=order)\\n y = filtfilt(b, a, data)\\n return y\",\n \"def chiaki_threshold(C_f, Fe_f, H_f, return_value = False):\\n\\n threshold = 10.0**(-5.07)\\n\\n H_abund = H_f / 1.00790\\n C_abund = C_f / 12.0107\\n Fe_abund = Fe_f / 55.8450\\n\\n C_H_solar = 8.43 - 12.0\\n Fe_H_solar = 7.50 - 12.0\\n\\n C_over_H = np.log10( C_abund / H_abund) - C_H_solar\\n Fe_over_H = np.log10( Fe_abund / H_abund) - Fe_H_solar\\n\\n local_C_Fe = 10.0**(C_over_H-2.3) + 10.0**(Fe_over_H)\\n\\n if return_value:\\n return local_C_Fe\\n else:\\n return local_C_Fe >= threshold\",\n \"def low_high_filter(image, param=1.6):\\r\\n nan_pos = np.isnan(image)\\r\\n img = image.copy()\\r\\n mean = np.nanmean(img)\\r\\n img[nan_pos] = mean\\r\\n\\r\\n low_filtered_image = gaussian(img, sigma = 4)\\r\\n gau = gaussian(img, sigma = 4/param)\\r\\n high_filtered_image = gau - low_filtered_image\\r\\n\\r\\n low_filtered_image[nan_pos] = np.nan\\r\\n high_filtered_image[nan_pos] = np.nan\\r\\n return low_filtered_image, high_filtered_image\",\n \"def lin_cutoff_calc_from_perc(image, minimum, maximum):\\n if minimum < 0 or maximum < 0 or minimum > 100 or maximum > 100:\\n raise Exception(\\\"rvt.blend_funct.lin_cutoff_calc_from_perc: minimum, maximum are percent and have to be in \\\"\\n \\\"range 0-100!\\\")\\n if minimum + maximum > 100:\\n raise Exception(\\\"rvt.blend_funct.lin_cutoff_calc_from_perc: if minimum + maximum > 100% then there are no\\\"\\n \\\" values left! You can't cutoff whole image!\\\")\\n distribution = np.nanpercentile(a=image, q=np.array([minimum, 100 - maximum]))\\n min_lin = distribution[0]\\n max_lin = distribution[1]\\n if min_lin == max_lin:\\n min_lin = np.nanmin(image)\\n max_lin = np.nanmax(image)\\n return {\\\"min_lin\\\": min_lin, \\\"max_lin\\\": max_lin}\",\n \"def normalize_signal(signal):\\n gain = 1.0 / (np.max(np.abs(signal)) + 1e-9)\\n return signal * gain\",\n \"def process_pain(x, lb, ub):\\n x = x.abs()\\n x.loc[(x > ub)] = 8\\n x.loc[(x < lb) | (x > ub)] = np.nan\\n return x\",\n \"def butter_bandpass_filter(data, lowcut, highcut, fs, order=1):\\n b, a = butter_bandpass(lowcut, highcut, fs, order=order)\\n y = filtfilt(b, a, data)\\n return y\",\n \"def FE_capping_outliers_beyond_IQR_Range(df, features, cap_at_nth_largest=5, IQR_multiplier=1.5,\\r\\n drop=False, verbose=False):\\r\\n outlier_indices = []\\r\\n df = df.copy(deep=True)\\r\\n if isinstance(features, str):\\r\\n features = [features]\\r\\n # iterate over features(columns)\\r\\n for col in features:\\r\\n ### this is how the column looks now before capping outliers\\r\\n if verbose:\\r\\n fig, (ax1,ax2) = plt.subplots(1,2,figsize=(12,5))\\r\\n df[col].plot(kind='box', title = '%s before capping outliers' %col, ax=ax1)\\r\\n # 1st quartile (25%)\\r\\n Q1 = np.percentile(df[col], 25)\\r\\n # 3rd quartile (75%)\\r\\n Q3 = np.percentile(df[col],75)\\r\\n # Interquartile range (IQR)\\r\\n IQR = Q3 - Q1\\r\\n\\r\\n # outlier step using multiplier\\r\\n outlier_step = IQR_multiplier * IQR\\r\\n\\r\\n lower_limit = Q1 - outlier_step\\r\\n upper_limit = Q3 + outlier_step\\r\\n\\r\\n # Determine a list of indices of outliers for feature col\\r\\n outlier_list_col = df[(df[col] < lower_limit) | (df[col] > upper_limit )].index\\r\\n\\r\\n ### Capping using the n largest value based on n given in input.\\r\\n maxval = df[col].max() ## what is the maximum value in this column?\\r\\n num_maxs = df[df[col]==maxval].shape[0] ## number of rows that have max value\\r\\n ### find the n_largest values after the maximum value based on given input n\\r\\n num_largest_after_max = num_maxs + cap_at_nth_largest\\r\\n capped_value = df[col].nlargest(num_largest_after_max).iloc[-1] ## this is the value we cap it against\\r\\n df.loc[df[col]==maxval, col] = capped_value ## maximum values are now capped\\r\\n ### you are now good to go - you can show how they are capped using before and after pics\\r\\n if verbose:\\r\\n df[col].plot(kind='box', title = '%s after capping outliers' %col, ax=ax2)\\r\\n plt.show()\\r\\n\\r\\n # Let's save the list of outliers and see if there are some with outliers in multiple columns\\r\\n outlier_indices.extend(outlier_list_col)\\r\\n\\r\\n # select certain observations containing more than one outlier in 2 columns or more. We can drop them!\\r\\n outlier_indices = Counter(outlier_indices)\\r\\n multiple_outliers = list( k for k, v in outlier_indices.items() if v > 3 )\\r\\n ### now drop these rows altogether ####\\r\\n if drop:\\r\\n print('Shape of dataframe before outliers being dropped: %s' %(df.shape,))\\r\\n number_of_rows = df.shape[0]\\r\\n df.drop(multiple_outliers, axis=0, inplace=True)\\r\\n print('Shape of dataframe after outliers being dropped: %s' %(df.shape,))\\r\\n print('\\\\nNumber_of_rows with multiple outliers in more than 3 columns which were dropped = %d' %(number_of_rows-df.shape[0]))\\r\\n return df\",\n \"def default_quantile():\\n return np.logspace(-5, 0, 100)\",\n \"def pl_exp_cut_low_high(x, **params):\\n result = (x / params['Scale_CR']) ** (-params['Index_CR'])\\n result *= params['Prefactor_CR']\\n result *= np.exp(-x / params['Emax_CR']) * np.exp(-params['Emin_CR'] / x)\\n return result\",\n \"def set_new_threshold(wavform, thr, n_pre=N_PRE_PT, rng=SEARCH_RNG, i_chg=20):\\n wav = np.array(wavform)\\n sgn = np.sign(thr)\\n if np.max(wav[rng[0]:rng[1]] * sgn) < np.abs(thr): return None # reject\\n\\n \\\"\\\"\\\" NOT USED -- GIVES IMPRECISE RESULT\\n # -- align: find the steepest point having the same sign as `sgn`\\n df = np.diff(wav)\\n si = np.argsort(-sgn * df) # reverse sorted\\n for i in si:\\n if np.sign(wav[i]) == sgn: break\\n \\\"\\\"\\\"\\n # -- align: find the point where waveform crosses `thr`\\n n = len(wav)\\n for i in range(n - 1):\\n if sgn * wav[i] <= sgn * thr and sgn * thr <= sgn * wav[i + 1]:\\n break\\n if i == n - 2:\\n # although i could be n - 2, it's highly likely an artifact\\n return None\\n n_shift = n_pre - i - 1 # > 0: right shift, < 0: left shift\\n if n_shift == 0:\\n return wav\\n\\n wavnew = np.empty(wav.shape)\\n wavnew[n_shift:] = wav[:-n_shift] # PBC shifting\\n wavnew[:n_shift] = wav[-n_shift:]\\n\\n # -- done: but if the spike doesn't change its sign\\n # within `i_chg`, reject.\\n if np.max(-sgn * wavnew[n_pre:i_chg]) < 0:\\n return None\\n\\n \\\"\\\"\\\" DEBUG\\n if np.abs(n_shift) > 3:\\n print '!!!', n_shift, '/', i, '/', n\\n print '---', np.max(-sgn * wavnew[n_pre:i_chg])\\n print list(wav)\\n print list(wavnew)\\n \\\"\\\"\\\"\\n\\n return wavnew\",\n \"def settings_outside_clinical_bounds(cir, isf, sbr):\\n return (\\n (float(isf) < 10)\\n | (float(isf) > 500)\\n | (float(cir) < 2)\\n | (float(cir) > 150)\\n | (float(sbr) < 0.05)\\n | (float(sbr) > 30)\\n )\",\n \"def _cutoff(xdata, ydata, btype, fs, ff):\\r\\n try:\\r\\n# print ff\\r\\n if ff != None:\\r\\n nPts = int(1./(((xdata.max()-xdata.min())/xdata.shape[0])*(ff/10.)))\\r\\n else:\\r\\n nPts = 0\\r\\n if nPts%2 == 0:\\r\\n nPts = nPts + 1\\r\\n if nPts < xdata.shape[0]:\\r\\n nPts = xdata.shape[0]\\r\\n# print nPts\\r\\n window = np.hanning(ydata.shape[0])\\r\\n freq = FourierFrequency(xdata, nPts)\\r\\n index = np.argsort(freq)\\r\\n tdf = FourierTransform(ydata*window, nPts)\\r\\n tdf = abs(tdf)\\r\\n pp = _maxima(tdf[index], freq[index], lookahead = 1)\\r\\n# mm = _minima(tdf[index], freq[index], lookahead=1)\\r\\n pp, hh = np.array(np.array(pp).T[0]), np.array(np.array(pp).T[1])\\r\\n# mm = np.array(np.array(mm).T[0])#, np.array(np.array(mm).T[1])\\r\\n ind = np.where(pp == min(abs(pp)))[0][0]\\r\\n ind2 = np.where(hh == max(hh[(ind+1):]))[0][0]\\r\\n for u, i in enumerate(freq):\\r\\n if i > abs(pp[ind2])*1.5 or i < -abs(pp[ind2])*1.5 or (i < abs(pp[ind2])/2. and i > -abs(pp[ind2])/2.) or (tdf[u] > hh[ind2]*1.05): #(abs(i) < abs(mm[indmin])) or \\r\\n tdf[u] = 0.\\r\\n def lor2(x, A0, x0, gamma0):\\r\\n return A0*(1/np.pi)*(gamma0/2)/((x-x0)**2+(gamma0/2)**2)+A0*(1/np.pi)*(gamma0/2)/((x+x0)**2+(gamma0/2)**2)\\r\\n lmod2 = lmf.Model(lor2)\\r\\n lmod2.make_params()\\r\\n lmod2.set_param_hint('A0', value=max(tdf), min=max(tdf)/1000.)\\r\\n lmod2.set_param_hint('x0', value=abs(pp[ind2]), min=0.)\\r\\n lmod2.set_param_hint('gamma0', value=1., min=0.)\\r\\n result2 = lmod2.fit(tdf[index], x=freq[index])\\r\\n# print result2.values.get('x0'), result2.values.get('gamma0')\\r\\n if btype=='high':\\r\\n if result2.values.get('x0')-result2.values.get('gamma0') > 0.:\\r\\n# print \\\"frequency: \\\", result2.values.get('x0')-result2.values.get('gamma0')\\r\\n if hh[ind2] != max(hh[(ind+1):]):\\r\\n print \\\"False\\\", \\\" maximum\\\", \\\"\\\\n\\\", \\\"\\\\n\\\", \\\"\\\\n\\\"\\r\\n return result2.values.get('x0')-result2.values.get('gamma0')\\r\\n else:\\r\\n# print \\\"failed: 0\\\"\\r\\n return 0.\\r\\n elif btype=='low':\\r\\n return result2.values.get('x0')+result2.values.get('gamma0')\\r\\n except Exception:\\r\\n pass\\r\\n finally:\\r\\n pass\",\n \"def ion_chi2_cut(stream, df):\\n ion_chi2_threshold = quality_parameters['ion_chi2_threshold']\\n \\n truth_array = pd.Series(data=True, index=df.index)\\n for suffix in ion_channel_labels:\\n chi2_column_name = 'chi2_ion{}'.format(suffix)\\n chi2_ion = df[chi2_column_name]\\n \\n energy_column_name = 'energy_adu_ion{}'.format(suffix)\\n energy_adu_ion = abs( df[energy_column_name] )\\n \\n # chi2_threshold = ion_chi2_threshold * ( 1 + (energy_adu_ion/3e2)**2.2 )\\n chi2_threshold = ion_chi2_threshold_function(\\n ion_chi2_threshold,\\n energy_adu_ion\\n )\\n \\n truth_array = truth_array & (chi2_ion < chi2_threshold)\\n \\n df['chi2_ion_cut'] = truth_array\\n \\n return None\",\n \"def _uppLim(self):\\n if self.getResult(param='TS value')[0] >= self.tsmin:\\n print(\\\"\\\\t=== TS value {} is above TSmin {}, no need to compute an upperlimit ===\\\"\\n .format(self.getResult(param='TS value')[0], self.tsmin))\\n return\\n\\n from UpperLimits import UpperLimits\\n import UnbinnedAnalysis as UA\\n \\n like = UA.unbinnedAnalysis(evfile=self.outmktime, scfile=self.ft2, expmap=self.outexpmap,\\n expcube=self.outltcube, irfs=self.irf, optimizer=\\\"NewMinuit\\\", srcmdl=self.model)\\n like.fit(0)\\n ul = UpperLimits(like)\\n\\n try:\\n upp, norm=ul['TARGET'].bayesianUL(emin=self.emin, emax=self.emax, cl=0.95) \\n except:\\n upp = -1\\n wf = open(self.outgtlike, 'a')\\n wf.write(\\\"\\\\nUpper limit on source 'TARGET': {} ph/cm2/s.\\\".format(upp))\\n wf.close()\\n return\",\n \"def above_threshold(self, value):\\n # We use floating point number here so we have to take care\\n return finf(value,self.min) or finf(self.max,value)\",\n \"def trim(self, edge_ic_cutoff=0.4):\\n pwm = self.pwm[:]\\n while len(pwm) > 0 and self.ic_pos(pwm[0]) < edge_ic_cutoff:\\n pwm = pwm[1:]\\n self.pwm = self.pwm[1:]\\n self.pfm = self.pfm[1:]\\n while len(pwm) > 0 and self.ic_pos(pwm[-1]) < edge_ic_cutoff:\\n pwm = pwm[:-1]\\n self.pwm = self.pwm[:-1]\\n self.pfm = self.pfm[:-1]\\n \\n self.consensus = None \\n self.min_score = None\\n self.max_score = None\\n self.wiggled_pwm = None\\n \\n return self\",\n \"def _butter_bandpass_filter(self, data: np.ndarray, lowcut: float, highcut: float, fs: float, order: int = 5):\\n b, a = self._butter_bandpass(lowcut, highcut, fs, order=order)\\n y = lfilter(b, a, data)\\n return y\",\n \"def butter_bandpass_filter(data, lowcut, highcut, fs, order=2):\\n nyq = 0.5 * fs\\n low = lowcut / nyq\\n high = highcut / nyq\\n \\n # butter() and lfilter() are from scipy.signal\\n \\n b, a = butter(order, [low, high], btype='band')\\n y = lfilter(b, a, data)\\n return y\",\n \"def get_chisqrs(prf,diff,nbins): \\n off_pulse = np.zeros(39)\\n off_pulse[:20] = prf[:20]\\n off_pulse[20:] = prf[45:] #Making off pulse region\\n # print(\\\"Off pulse Region \\\",off_pulse)\\n op_rms = np.var(off_pulse) #Rms\\n # print(\\\"Off pulse RMS \\\",op_rms)\\n s = 0\\n for d in diff:\\n s += d**2/op_rms\\n\\n s = s/(nbins - 1)\\n # print(\\\"Chisqr value = \\\",s)\\n\\n return s\",\n \"def change_saturation_conv(image, value):\\n image = rescale_image_0255(image)\\n image = change_saturation(image, value)\\n return rescale_image_01(image)\",\n \"def fir_filter(sig, sampling_freq, critical_freq, kernel_window = 'hamming', taps = 101, kind = 'band', **kwargs):\\n\\n kernel = make_fir_filter(sampling_freq, critical_freq, kernel_window, taps, kind, **kwargs) \\n\\n return np.roll(scipy.signal.lfilter(kernel, [1], sig), -taps/2+1)\",\n \"def u_crit(state, sys):\\n s = state[0]\\n i = state[1]\\n tau = scipy.interpolate.interp1d(sys.tau.s, sys.tau.i, kind = \\\"cubic\\\")\\n phi = scipy.interpolate.interp1d(sys.phi.s, sys.phi.i, kind = \\\"cubic\\\")\\n cc = scipy.interpolate.interp1d(sys.commutation_curve[0],\\n sys.commutation_curve[1],\\n kind = \\\"cubic\\\")\\n if i > sys.imax:\\n return sys.umax\\n if s <= sys.commutation_curve[0][-1]:\\n #print(\\\"Case 1\\\")\\n if s < sys.sbar or i < tau(s):\\n return 0\\n return sys.umax\\n elif s > sys.commutation_curve[0][-1] and s < sys.commutation_curve[0][0]:\\n #print(\\\"Case 2\\\")\\n if ((i > tau(s)) and (i < cc(s))) or (i > sys.imax):\\n return sys.umax\\n elif i > cc(s) and i < sys.imax:\\n return 0\\n else:\\n return 0\\n else:\\n #print(\\\"Case 3\\\")\\n if i > sys.imax:\\n return sys.umax\\n elif s > sys.sstar and i > phi(s):\\n return sys.umax\\n return 0\",\n \"def trigger_cut(\\n df,\\n nearest_data_trigger_allowed=5,\\n furthest_simu_trigger_allowed=5\\n ):\\n df['trigger_cut'] = (\\n ( abs(df['t_nearest_data_trigger']) > nearest_data_trigger_allowed )\\n & ( abs(df['t_input_simu_trigger']) < furthest_simu_trigger_allowed )\\n )\",\n \"def get_kcut_profile(kmax,kcut,apo_over):\\n ret = np.ones(kmax)\\n if kcut+apo_over == 0:\\n return ret\\n \\n rising = sin_profile(kcut+apo_over,kcut,1)\\n falling = 1.0-sin_profile(kcut+apo_over,kcut,0)[::-1]\\n \\n ret[:len(rising)]=rising\\n if len(falling) == 0:\\n print (\\\"fourier resolution bigger than the cut size asked\\\")\\n pass\\n else:\\n ret[-len(falling):]=falling\\n \\n ret[ret<0] = 0\\n return np.fft.fftshift(ret)\",\n \"def SignalFilter_LPFBessel(signal, LPF, samplefreq, NPole=8, reduce=False, bidir=False):\\n if debugFlag:\\n print(\\\"sfreq: %f LPF: %f HPF: %f\\\" % (samplefreq, LPF))\\n flpf = float(LPF)\\n sf = float(samplefreq)\\n wn = [flpf/(sf/2.0)]\\n reduction = 1\\n if reduce:\\n if LPF <= samplefreq/2.0:\\n reduction = int(samplefreq/LPF)\\n if debugFlag is True:\\n print(\\\"signalfilter: samplef: %f wn: %f, lpf: %f, NPoles: %d \\\" % (\\n sf, wn, flpf, NPole))\\n filter_b,filter_a=spSignal.bessel(\\n NPole,\\n wn,\\n btype = 'low',\\n output = 'ba')\\n if signal.ndim == 1:\\n sm = numpy.mean(signal)\\n if bidir:\\n w=spSignal.filtfilt(filter_b, filter_a, signal-sm) # filter the incoming signal\\n else:\\n w=spSignal.lfilter(filter_b, filter_a, signal-sm) # filter the incoming signal\\n\\n w = w + sm\\n if reduction > 1:\\n w = spSignal.resample(w, reduction)\\n return(w)\\n if signal.ndim == 2:\\n sh = numpy.shape(signal)\\n for i in range(0, numpy.shape(signal)[0]):\\n sm = numpy.mean(signal[i,:])\\n if bidir:\\n w1 = spSignal.filtfilt(filter_b, filter_a, signal[i, :]-sm)\\n else:\\n w1 = spSignal.lfilter(filter_b, filter_a, signal[i, :]-sm)\\n\\n w1 = w1 + sm\\n if reduction == 1:\\n w1 = spSignal.resample(w1, reduction)\\n if i == 0:\\n w = numpy.empty((sh[0], numpy.shape(w1)[0]))\\n w[i,:] = w1\\n return w\\n if signal.ndim == 3:\\n sh = numpy.shape(signal)\\n for i in range(0, numpy.shape(signal)[0]):\\n for j in range(0, numpy.shape(signal)[1]):\\n sm = numpy.mean(signal[i,j,:])\\n if bidir:\\n w1 = spSignal.filtfilt(filter_b, filter_a, signal[i,j,:]-sm)\\n else:\\n w1 = spSignal.lfilter(filter_b, filter_a, signal[i,j,:]-sm)\\n w1 = w1 + sm\\n if reduction == 1:\\n w1 = spSignal.resample(w1, reduction)\\n if i == 0 and j == 0:\\n w = numpy.empty((sh[0], sh[1], numpy.shape(w1)[0]))\\n w[i,j,:] = w1\\n return(w)\\n if signal.ndim > 3:\\n print(\\\"Error: signal dimesions of > 3 are not supported (no filtering applied)\\\")\\n return signal\",\n \"def bandpassFilter (self, lowerFreq, upperFreq):\\n self.bandpassLimits = (lowerFreq, upperFreq)\\n # stuff to do\",\n \"def _clamp_percent(value):\\n if value < 0:\\n print(\\\"Less than 0 percent specified for extension. Clamping to 0\\\")\\n value = 0\\n elif value > 100:\\n print(\\\"More than 100 percent specified for extension. Clamping to 100\\\")\\n value = 100\\n return value\",\n \"def mod_filterbank(signal, fs, modf):\\n modf = np.asarray(modf)\\n fcs = modf[1:]\\n fcut = modf[0]\\n # Make signal odd length\\n signal = signal[0:-1] if (len(signal) % 2) == 0 else signal\\n\\n q = 1. # Q-factor of band-pass filters\\n lp_order = 3. # order of the low-pass filter\\n\\n n = signal.shape[-1] # length of envelope signals\\n X = fft(signal)\\n X_mag = np.abs(X)\\n X_power = np.square(X_mag) / n # power spectrum\\n X_power_pos = X_power[0:np.floor(n / 2).astype('int') + 1]\\n # take positive frequencies only and multiply by two to get the same total\\n # energy\\n X_power_pos[1:] = X_power_pos[1:] * 2\\n\\n pos_freqs = np.linspace(0, fs / 2, X_power_pos.shape[-1])\\n # Concatenate vector of 0:fs and -fs:1\\n freqs = np.concatenate((pos_freqs, -1 * pos_freqs[-1:0:-1]))\\n\\n # Initialize transfer function\\n TFs = np.zeros((len(fcs) + 1, len(freqs))).astype('complex')\\n # Calculating frequency-domain transfer function for each center frequency:\\n for k in range(len(fcs)):\\n TFs[k + 1, 1:] = 1. / (1. + (1j * q * (freqs[1:] / fcs[k] - fcs[k] /\\n freqs[1:]))) # p287 Hambley.\\n\\n # squared filter magnitude transfer functions\\n Wcf = np.square(np.abs(TFs))\\n\\n # Low-pass filter squared transfer function, third order Butterworth filter\\n # TF from:\\n # http://en.wikipedia.org/wiki/Butterworth_filter\\n Wcf[0, :] = 1 / (1 + ((2 * pi * freqs / (2 * pi * fcut)) ** (2 * lp_order)))\\n # Transfer function of low-pass filter\\n TFs[0, :] = np.sqrt(Wcf[0, :])\\n\\n # initialize output product:\\n vout = np.zeros((len(fcs) + 1, len(pos_freqs)))\\n powers = np.zeros(len(modf))\\n\\n # ------------ DC-power, --------------------------\\n # here divide by two such that a fully modulated tone has an AC-power of 1.\\n dc_power = X_power_pos[0] / n / 2\\n # ------------------------------------------------\\n X_filt = np.zeros((Wcf.shape[0], X.shape[-1]), dtype='complex128')\\n filtered_envs = np.zeros_like(X_filt, dtype='float')\\n\\n for k, (w, TF) in enumerate(zip(Wcf, TFs)):\\n vout[k] = X_power_pos * w[:np.floor(n / 2).astype('int') + 1]\\n # Integration estimated as a sum from f > 0\\n # integrate envelope power in the passband of the filter. Index goes\\n # from 2:end since integration is for f>0\\n powers[k] = np.sum(vout[k, 1:]) / n / dc_power\\n # Filtering and inverse Fourier transform to get time signal.\\n X_filt[k] = X * TF\\n filtered_envs[k] = np.real(ifft(X_filt[k]))\\n return powers, filtered_envs\",\n \"def filt_hp(sig: np.ndarray, Ss: int, Cfs: int, Cfs1: None,\\n order=5) -> np.ndarray:\\n nyq = 0.5 * Ss\\n normal_cutoff = Cfs / nyq\\n b, a = butter(order, normal_cutoff, btype='high', analog=False)\\n return lfilter(b, a, sig)\",\n \"def test_set_clip_precentile_update(self):\\n data = np.array([1., 2., 3.])\\n self.mode.set_clip_percentile(10, 90)\\n result = self.mode.get_bounds(data)\\n self.mode.set_clip_percentile(20, 80)\\n result = self.mode.get_bounds(data)\\n np.testing.assert_array_almost_equal(result,\\n np.percentile(data, [20, 80]))\",\n \"def genChirpIC(Ih=-100,Rm=100,amp=5):\\n pA_per_mV=1000/Rm\\n print(\\\"%.02f pA requried to shift 1mV\\\"%pA_per_mV)\\n xs,ys,zi=genSine()\\n ys=ys*pA_per_mV*amp+Ih\\n genATF(xs,ys,'stimulus-IC.atf')\\n graphData(xs,ys,zi,\\\"Current Clamp Stimulus\\\",'stimulus-IC.png')\",\n \"def append_opt_band(S, low_noise_thresh, med_noise_thresh, confluence_fp,opt_band, \\n uctuner):\\n with open(confluence_fp,'a') as cfile: # Making the markdown string to append to file\\n top=\\\"||SMuRF band||uc att (.5dB steps)||tone power (3dB steps)||dc att (.5dB steps)||Num. Channels||Med. White Noise (pA/rtHz)||Num. Channels||Med. White Noise (pA/rtHz)||\\\"\\n fmt = \\\"\\\"\\n if uctuner.best_wl <= low_noise_thresh:\\n fmt='_'\\n elif uctuner.best_wl >= med_noise_thresh:\\n fmt='*'\\n confluence_row = f\\\"|{opt_band}|{uctuner.best_att}|{uctuner.best_tone}|\\\"+\\\\\\n f\\\"{S.get_att_dc(opt_band)}|{uctuner.best_length}|\\\" +\\\\\\n f\\\"{fmt}{uctuner.best_wl}{fmt}| | |\\\\n\\\"\\n cfile.write(confluence_row)\\n if opt_band == 7:\\n cfile.write(\\\"||Total|| || || || || || TODO || ||\\\\n \\\")\",\n \"def find_outlier_range(dfs: pd.Series, iqr_factor=1.5, clip_low=None, clip_high=None):\\n quant1 = dfs.quantile(0.25)\\n quant3 = dfs.quantile(0.75)\\n IQR = quant3 - quant1\\n low = quant1 - iqr_factor * IQR\\n high = quant3 + iqr_factor * IQR\\n\\n if clip_low is not None:\\n low = max(clip_low, low)\\n if clip_high is not None:\\n high = min(clip_high, high)\\n return (low, high)\",\n \"def reduce_signal(signal):\\n fft = get_fft(signal)\\n doms = get_dom_freq(fft[0], fft[1], 50)\\n reduced = get_reduced_signal(doms[0], doms[1], len(signal))\\n return reduced\",\n \"def adjust_saturation(image, factor):\\r\\n image[..., 1] = np.clip(image[..., 1] * factor, 0, 255)\\r\\n return image\",\n \"def get_xi_threshold(Mu,Y_max,Effective_Impedance,Phi_max):\\n return (np.pi*Phi_max**5*ImZ_over_k)/(32*Mu*(Mu+1)*chi(Mu,Y_max)*Effective_Impedance)\",\n \"def compute_filt(up, down, fc='nn', beta=5.0, N=32001, return_fc=False):\\n\\n # see explanation in resample below\\n if up==down:\\n raise ValueError('upsampling and downsampling rate cannot be the same.')\\n\\n # Determine our up and down factors\\n g = gcd(up, down)\\n up = up//g\\n down = down//g\\n max_rate = max(up, down)\\n\\n sfact = np.sqrt(1+(beta/np.pi)**2)\\n\\n if isinstance(fc, float):\\n pass\\n\\n # the \\\"standard\\\" way to generate the filter is to just place fc on the\\n # Nyquist frequency, which results in considerable aliasing but is\\n # neccesary for perfect reconstruction multirate filterbanks but not\\n # for audio resampling! Included here mostly for completeness and\\n # comparison purposes.\\n elif fc == 'standard':\\n fc = 1/max_rate\\n\\n # The paper by Kaiser gives a formula for the neccesary length of the\\n # filter given a desired stopband attenuation and transition band width;\\n # conversly, we can determine the transition band width from the stop\\n # band attenuation and filter length. This allows us to shift fc.\\n elif fc == 'kaiser' or fc == 'Kaiser':\\n As = As_from_beta(beta)\\n offset = (As-7.95)/(14.36*N)\\n fc = (1/max_rate)-offset\\n\\n # The null-on-Nyquist method: the reason I wrote this package in the first\\n # place. My argument is that the cutoff frequency should be on the border\\n # between the main lobe of the filter and the first sidelobe; this should\\n # give the best tradeoff between retaining the desired signal and\\n # suppressing aliasing.\\n elif fc == 'nn':\\n # This is a two-step procedure. First we generate a filter in the\\n # 'normal' way: with 6dB attenuation at Falsef_c.\\n init_filt = sig.fir_filter_design.firwin(N, 1/max_rate,\\n window=('kaiser', beta))\\n\\n # Next, find the first null. Convert the filter into frequency domain.\\n N_FFT = 2**19\\n NBINS = N_FFT/2+1\\n paddedfilt = np.zeros(N_FFT)\\n paddedfilt[:N] = init_filt\\n ffilt = np.fft.rfft(paddedfilt)\\n\\n # Now find the minimum between f_c and f_c+sqrt(1+(beta/pi)^2)/L\\n bot = int(np.floor(NBINS/max_rate))\\n top = int(np.ceil(NBINS*(1/max_rate + 2*sfact/N)))\\n firstnull = (np.argmin(np.abs(ffilt[bot:top])) + bot)/NBINS\\n\\n # get the new fc\\n fc = -firstnull+2/max_rate\\n\\n else:\\n raise ValueError('Unknown option for fc in compute_filt')\\n\\n # Now we can generate the desired filter\\n f = sig.fir_filter_design.firwin(N, fc, window=('kaiser', beta))\\n\\n if return_fc:\\n return f, fc\\n else:\\n return f\",\n \"def filter_strength_pil(self, pil_df, threshold, pil_label):\\n # Create single dataframe with the cutting threshold which contains ~95% PIL flux\\n cut_label = pil_df[pil_df['cut_threshold'] > threshold].label.values\\n\\n # Check individual pil index which total strength not equal to initial total flux\\n cut_idx = np.isin(pil_label, cut_label)\\n\\n # Set small PIL flux label to 0, only keep big PIL flux label\\n pil_label[cut_idx] = 0\\n\\n return pil_label\",\n \"def find_cosmics_in_cut(x, cut_wave, cut_brightest_line, line_wavelength = 0.,\\n kernel_median_cosmics = 5, cosmic_higher_than = 100, extra_factor = 1., plot=False, verbose=False):\\n \\n gc_bl=signal.medfilt(cut_brightest_line,kernel_size=kernel_median_cosmics)\\n max_val = np.abs(cut_brightest_line-gc_bl)\\n\\n gc=signal.medfilt(cut_wave,kernel_size=kernel_median_cosmics)\\n verde=np.abs(cut_wave-gc)-extra_factor*max_val\\n \\n cosmics_list = [i for i, x in enumerate(verde) if x > cosmic_higher_than]\\n \\n if plot:\\n ptitle=\\\"Cosmic identification in cut\\\"\\n if line_wavelength != 0 : ptitle=\\\"Cosmic identification in cut at \\\"+np.str(line_wavelength)+\\\" $\\\\mathrm{\\\\AA}$\\\" \\n plot_plot(x,verde, ymin=0,ymax=200, hlines=[cosmic_higher_than], ptitle=ptitle, ylabel=\\\"abs (cut - medfilt(cut)) - extra_factor * max_val\\\")\\n \\n if verbose:\\n if line_wavelength == 0:\\n print(\\\"\\\\n> Identified\\\", len(cosmics_list),\\\"cosmics in fibres\\\",cosmics_list)\\n else:\\n print(\\\"\\\\n> Identified\\\", len(cosmics_list),\\\"cosmics at\\\",np.str(line_wavelength),\\\"A in fibres\\\",cosmics_list)\\n return cosmics_list\",\n \"def mfcc(signal,samplerate=16000,winlen=0.025,winstep=0.01,numcep=13,\\n nfilt=23,nfft=512,lowfreq=20,highfreq=None,dither=1.0,remove_dc_offset=True,preemph=0.97,\\n ceplifter=22,useEnergy=True,wintype='povey'):\\n feat,energy = fbank(signal,samplerate,winlen,winstep,nfilt,nfft,lowfreq,highfreq,dither,remove_dc_offset,preemph,wintype)\\n feat = numpy.log(feat)\\n feat = dct(feat, type=2, axis=1, norm='ortho')[:,:numcep]\\n feat = lifter(feat,ceplifter)\\n if useEnergy: feat[:,0] = numpy.log(energy) # replace first cepstral coefficient with log of frame energy\\n return feat\",\n \"def SetNarrowBandwidth(self, value: 'double') -> \\\"void\\\":\\n return _itkReinitializeLevelSetImageFilterPython.itkReinitializeLevelSetImageFilterIF3_SetNarrowBandwidth(self, value)\",\n \"def fir(self):\\r\\n #Passband and stop-band are expressed as fraction of the Nyquist\\r\\n #frequency:\\r\\n if self.ub is not None:\\r\\n ub_frac = self.ub / (self.sampling_rate / 2.)\\r\\n else:\\r\\n ub_frac = 1.0\\r\\n\\r\\n lb_frac = self.lb / (self.sampling_rate / 2.)\\r\\n\\r\\n if lb_frac < 0 or ub_frac > 1:\\r\\n e_s = \\\"The lower-bound or upper bound used to filter\\\"\\r\\n e_s += \\\" are beyond the range 0-Nyquist. You asked for\\\"\\r\\n e_s += \\\" a filter between\\\"\\r\\n e_s += \\\"%s and %s percent of\\\" % (lb_frac * 100, ub_frac * 100)\\r\\n e_s += \\\"the Nyquist frequency\\\"\\r\\n raise ValueError(e_s)\\r\\n\\r\\n n_taps = self._filt_order + 1\\r\\n\\r\\n #This means the filter order you chose was too large (needs to be\\r\\n #shorter than a 1/3 of your time-series )\\r\\n if n_taps > self.data.shape[-1] * 3:\\r\\n e_s = \\\"The filter order chosen is too large for this time-series\\\"\\r\\n raise ValueError(e_s)\\r\\n\\r\\n # a is always 1:\\r\\n a = [1]\\r\\n\\r\\n sig = ts.TimeSeries(data=self.data, sampling_rate=self.sampling_rate)\\r\\n\\r\\n #Lowpass:\\r\\n if ub_frac < 1:\\r\\n b = signal.firwin(n_taps, ub_frac, window=self._win)\\r\\n sig = self.filtfilt(b, a, sig)\\r\\n\\r\\n #High-pass\\r\\n if lb_frac > 0:\\r\\n #Includes a spectral inversion:\\r\\n b = -1 * signal.firwin(n_taps, lb_frac, window=self._win)\\r\\n b[n_taps / 2] = b[n_taps / 2] + 1\\r\\n sig = self.filtfilt(b, a, sig)\\r\\n\\r\\n return sig\",\n \"def normalizeprctile(expdat,percent=80):\\n\\tparams=locals()\\n\\n\\t# select the bacteria to use - don't want to include very low freq. bacteria\\n\\tnewexp=hs.filterminreads(expdat,1*len(expdat.samples))\\n\\n\\tpercvals=np.percentile(newexp.data,percent,axis=0)\\n#\\tplt.figure()\\n#\\tplt.plot(percvals)\\n\\tpercvals=percvals/np.mean(percvals)\\n\\tnewexp=hs.copyexp(expdat)\\n\\tfor idx,samp in enumerate(expdat.samples):\\n\\t\\tnewexp.data[:,idx]=newexp.data[:,idx]*percvals[idx]\\n\\tnewexp.filters.append(\\\"normalize percentile %f\\\" % percent)\\n\\ths.addcommand(newexp,\\\"normalizeprctile\\\",params=params,replaceparams={'expdat':expdat})\\n\\n\\treturn newexp\",\n \"def do_mcp_nonlinearity_calibration():\\n no_sample_data_path = ''.join([DATA_PATH, 'run108allevts.h5'])\\n f = h5py.File(no_sample_data_path)\\n phot = _get_photon_energy(f, 108)\\n mcp = np.array(f['Acqiris2']['acq'])\\n andor = np.array(f['Andor']['signal']-f['Andor']['reference'])\\n # Subtract dark signals:\\n dark_calibration = _get_dark_calibration()\\n mcp = mcp-dark_calibration['mcp']\\n andor = andor-dark_calibration['andor']\\n # Take data within (relatively) narrow photon energy range:\\n phot_in_range = (phot > 781) & (phot < 782)\\n mcp = mcp[phot_in_range]\\n andor = andor[phot_in_range]\\n # make sure to only take data for which andor doesn't saturate\\n mcp_percentile_cutoff = min([percentileofscore(andor, 4000), 99.9])\\n mcp_cutoff_value = scoreatpercentile(mcp, mcp_percentile_cutoff)\\n mcp_in_range = mcp < mcp_cutoff_value\\n mcp = mcp[mcp_in_range]\\n andor = andor[mcp_in_range]\\n correction_polynomial = np.polyfit(\\n mcp, \\n andor*(np.mean(mcp)/np.mean(andor)),\\n deg=3)\\n plt.figure()\\n plt.scatter(mcp, andor)\\n plt.scatter(np.polyval(correction_polynomial, mcp), andor)\\n pickle_on = open(MCP_CALIBRATION_FILE, 'wb')\\n pickle.dump(correction_polynomial, pickle_on)\\n pickle_on.close()\",\n \"def get_cutoff(xml_file):\\n\\n heavy_atoms = 0\\n with open(xml_file, 'r') as xml:\\n for line in xml:\\n if line.startswith('<Type'):\\n # line.split('element')[1][2] is guaranteed* to be where the element names are in the xml. *hopefully\\n if line.split('element')[1][2] != 'H':\\n heavy_atoms += 1\\n\\n if heavy_atoms < 3:\\n cutoff = 1.1\\n elif heavy_atoms < 5:\\n cutoff = 1.3\\n else:\\n cutoff = 1.5\\n\\n print(f'{heavy_atoms} heavy atoms found in {xml_file[:-4]}; cut-off is {cutoff}')\\n return cutoff\",\n \"def subtract_median_bias_residue_channel(ChannelCube,time=None,percentile=50):\\n\\n if time is None:\\n time = np.arange(ChannelCube.shape[0])\\n hsize = int(ChannelCube.shape[1]/2)\\n\\n TopBiasResidue = fit_slope_with_zero_intercept_residue(time,[np.percentile(tile,percentile) for tile in ChannelCube[:,0:hsize,:]])\\n BotBiasResidue = fit_slope_with_zero_intercept_residue(time,[np.percentile(tile,percentile) for tile in ChannelCube[:,hsize:,:]])\\n \\n ResidueCorrectionSlopes = (TopBiasResidue - BotBiasResidue)/(hsize/2 - (hsize + hsize/2))\\n x = np.arange(ChannelCube.shape[1])\\n ResidueCorrection = BotBiasResidue[:,np.newaxis] + ResidueCorrectionSlopes[:,np.newaxis] * (x - (hsize + hsize/2))[np.newaxis,:]\\n return ChannelCube + ResidueCorrection[:,:,np.newaxis]\",\n \"def compute_value_at_bandwidth(self, x):\\n x = x.value\\n\\n if x < 0:\\n raise ComputeValueException(\\n 'Bandwidth must be greater than 0: {0}'.format(x),\\n 'TA.compute_value')\\n elif x < self.total_minimum_bandwidth.value:\\n return 0.0\\n elif x < MAX_BANDWIDTH.value:\\n return self.scaling_factor * \\\\\\n (100 - 100 * (math.e ** (-self.c * x)))\\n else:\\n return self.scaling_factor * \\\\\\n (100 - 100 * (math.e ** (-self.c * MAX_BANDWIDTH.value)))\",\n \"def mfcc(signal,samplerate=16000,winlen=0.025,winstep=0.01,numcep=13,\\n nfilt=26,nfft=512,lowfreq=0,highfreq=None,preemph=0.97,ceplifter=22,appendEnergy=True): \\n feat, energy = fbank(signal,samplerate,winlen,winstep,nfilt,nfft,lowfreq,highfreq,preemph)\\n feat = pylab.log(feat)\\n feat = dct(feat, type=2, axis=1, norm='ortho')[:,:numcep]\\n feat = lifter(feat,ceplifter)\\n if appendEnergy: feat[:,0] = pylab.log(energy) # replace first cepstral coefficient with log of frame energy\\n return feat\",\n \"def apply_thresholding(x):\\n return x > threshold_otsu(x)\",\n \"def calculate_bandwidth(self, complist):\\n\\n self.type = complist[0]\\n self.spot = complist[2]\\n self.value = complist[1]\\n self.fail = False\\n\\n if self.spot == \\\"1\\\" or self.spot == \\\"2\\\":\\n # print \\\"Calculation if Loop 1st filter\\\"\\n if self.type == \\\"C\\\":\\n if self.c1 == 0:\\n self.c1 = self.value\\n else:\\n self.fail = True\\n else:\\n if self.r1 == 0:\\n self.r1 = self.value\\n else:\\n self.fail = True\\n\\n if self.spot == \\\"3\\\" or self.spot == \\\"4\\\":\\n # print \\\"Calculation if loop 2nd filter\\\"\\n if self.type == \\\"C\\\":\\n if self.c2 == 0:\\n self.c2 = self.value\\n else:\\n self.fail = True\\n else: #self.type == \\\"R\\\"\\n if self.r2 == 0:\\n self.r2 = self.value\\n else:\\n self.fail = True\\n\\n if self.c1 != 0 and self.c2 != 0 and self.r1 != 0 and self.r2 != 0:\\n cf_low = int((1/(2*pi*(self.r1)*(self.c1))/1000))\\n #print \\\"hello!\\\"\\n cf_low = str(cf_low)\\n self.cutoff_freql = cf_low\\n self.cutoff_freql_text = cf_low + \\\"K\\\"\\n print self.cutoff_freql_text\\n cf_high = int((1/(2*pi*(self.r2)*(self.c2))/1000))\\n cf_high = str(cf_high)\\n self.cutoff_freqh = cf_high\\n self.cutoff_freqh_text = cf_high + \\\"K\\\"\\n print self.cutoff_freqh_text\\n voltage_change = float((self.r2)/self.r1)\\n voltage = 5 + voltage_change\\n self.voltage = str(voltage)\\n print self.voltage\",\n \"def calculate_enrichment_factor_optimal(molecules, ranked_dataset_percentage_cutoff, pic50_cutoff):\\n\\n ratio = sum(molecules[\\\"pIC50\\\"] >= pic50_cutoff) / len(molecules) * 100\\n if ranked_dataset_percentage_cutoff <= ratio:\\n enrichment_factor_optimal = round(100 / ratio * ranked_dataset_percentage_cutoff, 1)\\n else:\\n enrichment_factor_optimal = 100.0\\n return enrichment_factor_optimal\",\n \"def filt_bp(sig: np.ndarray, Ss: int, Cfs0: int, Cfs1: None,\\n order=5) -> np.ndarray:\\n nyq = 0.5 * Ss\\n normal_cutoff1 = Cfs0 / nyq\\n normal_cutoff2 = Cfs1 / nyq\\n b, a = butter(order, (normal_cutoff1, normal_cutoff2),\\n btype='band',\\n analog=False)\\n return lfilter(b, a, sig)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5653417","0.5633713","0.5491142","0.54786575","0.54064196","0.53240645","0.52246594","0.52203375","0.52071315","0.51993823","0.5179031","0.51522595","0.51460844","0.51184833","0.50988865","0.5083905","0.5054955","0.5052072","0.50464624","0.50445575","0.5017279","0.5010275","0.4993915","0.49769405","0.49761632","0.49754384","0.49731877","0.49703842","0.49702385","0.49601427","0.49580738","0.49561998","0.49480322","0.49362737","0.4929444","0.48985606","0.48942035","0.48864853","0.48591882","0.48521698","0.48521698","0.48476723","0.4847513","0.48440835","0.48337457","0.4829816","0.48221505","0.48154655","0.48061916","0.48001","0.47872815","0.47865686","0.47801244","0.47795418","0.4777751","0.4777365","0.47707805","0.4769999","0.47694653","0.4768098","0.47616994","0.47536412","0.4742648","0.47412592","0.47334296","0.47264674","0.4710189","0.47070286","0.47063193","0.4705458","0.47042903","0.46833345","0.4677547","0.4662104","0.4655829","0.46526","0.46486035","0.4648546","0.46474808","0.46426663","0.4642099","0.46397743","0.46386918","0.4637623","0.46326885","0.4631604","0.4631171","0.4629717","0.46284246","0.46230385","0.4620354","0.46158528","0.46096078","0.4608996","0.46074143","0.4605683","0.4605237","0.4599396","0.45950848","0.4593283"],"string":"[\n \"0.5653417\",\n \"0.5633713\",\n \"0.5491142\",\n \"0.54786575\",\n \"0.54064196\",\n \"0.53240645\",\n \"0.52246594\",\n \"0.52203375\",\n \"0.52071315\",\n \"0.51993823\",\n \"0.5179031\",\n \"0.51522595\",\n \"0.51460844\",\n \"0.51184833\",\n \"0.50988865\",\n \"0.5083905\",\n \"0.5054955\",\n \"0.5052072\",\n \"0.50464624\",\n \"0.50445575\",\n \"0.5017279\",\n \"0.5010275\",\n \"0.4993915\",\n \"0.49769405\",\n \"0.49761632\",\n \"0.49754384\",\n \"0.49731877\",\n \"0.49703842\",\n \"0.49702385\",\n \"0.49601427\",\n \"0.49580738\",\n \"0.49561998\",\n \"0.49480322\",\n \"0.49362737\",\n \"0.4929444\",\n \"0.48985606\",\n \"0.48942035\",\n \"0.48864853\",\n \"0.48591882\",\n \"0.48521698\",\n \"0.48521698\",\n \"0.48476723\",\n \"0.4847513\",\n \"0.48440835\",\n \"0.48337457\",\n \"0.4829816\",\n \"0.48221505\",\n \"0.48154655\",\n \"0.48061916\",\n \"0.48001\",\n \"0.47872815\",\n \"0.47865686\",\n \"0.47801244\",\n \"0.47795418\",\n \"0.4777751\",\n \"0.4777365\",\n \"0.47707805\",\n \"0.4769999\",\n \"0.47694653\",\n \"0.4768098\",\n \"0.47616994\",\n \"0.47536412\",\n \"0.4742648\",\n \"0.47412592\",\n \"0.47334296\",\n \"0.47264674\",\n \"0.4710189\",\n \"0.47070286\",\n \"0.47063193\",\n \"0.4705458\",\n \"0.47042903\",\n \"0.46833345\",\n \"0.4677547\",\n \"0.4662104\",\n \"0.4655829\",\n \"0.46526\",\n \"0.46486035\",\n \"0.4648546\",\n \"0.46474808\",\n \"0.46426663\",\n \"0.4642099\",\n \"0.46397743\",\n \"0.46386918\",\n \"0.4637623\",\n \"0.46326885\",\n \"0.4631604\",\n \"0.4631171\",\n \"0.4629717\",\n \"0.46284246\",\n \"0.46230385\",\n \"0.4620354\",\n \"0.46158528\",\n \"0.46096078\",\n \"0.4608996\",\n \"0.46074143\",\n \"0.4605683\",\n \"0.4605237\",\n \"0.4599396\",\n \"0.45950848\",\n \"0.4593283\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.59004277"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21973,"cells":{"query":{"kind":"string","value":"Calculate polynomial to correct slight nonlinearity in MCP response"},"document":{"kind":"string","value":"def do_mcp_nonlinearity_calibration():\n no_sample_data_path = ''.join([DATA_PATH, 'run108allevts.h5'])\n f = h5py.File(no_sample_data_path)\n phot = _get_photon_energy(f, 108)\n mcp = np.array(f['Acqiris2']['acq'])\n andor = np.array(f['Andor']['signal']-f['Andor']['reference'])\n # Subtract dark signals:\n dark_calibration = _get_dark_calibration()\n mcp = mcp-dark_calibration['mcp']\n andor = andor-dark_calibration['andor']\n # Take data within (relatively) narrow photon energy range:\n phot_in_range = (phot > 781) & (phot < 782)\n mcp = mcp[phot_in_range]\n andor = andor[phot_in_range]\n # make sure to only take data for which andor doesn't saturate\n mcp_percentile_cutoff = min([percentileofscore(andor, 4000), 99.9])\n mcp_cutoff_value = scoreatpercentile(mcp, mcp_percentile_cutoff)\n mcp_in_range = mcp < mcp_cutoff_value\n mcp = mcp[mcp_in_range]\n andor = andor[mcp_in_range]\n correction_polynomial = np.polyfit(\n mcp, \n andor*(np.mean(mcp)/np.mean(andor)),\n deg=3)\n plt.figure()\n plt.scatter(mcp, andor)\n plt.scatter(np.polyval(correction_polynomial, mcp), andor)\n pickle_on = open(MCP_CALIBRATION_FILE, 'wb')\n pickle.dump(correction_polynomial, pickle_on)\n pickle_on.close()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def generate_polynomial():\n degree = numpy.random.choice(range(3, 7))\n x = numpy.linspace(-10, 10, 1000)\n coefficients = numpy.random.chisquare(3, size=degree) + 1\n coefficients *= numpy.random.choice([-1, 1], size=coefficients.shape)\n coefficients *= 0.5\n y = numpy.polyval(coefficients, x)\n add_noise(y, 0.1)\n return x, y","def evaluate_polynomial(f,x):\n degree = len(f)-1\n ans = 0\n for i in f:\n ans += i*x**degree\n degree -= 1\n return(ans)","def _poly_func(x, a, b, c, d, e):\n return a * x ** 6 + b * x ** 5 + c * x ** 4 + d * x ** 3 + e * x ** 2","def E_polynomial(self):\n\n from nodepy import stability_function\n p, q = self.stability_function()\n return stability_function.E_polynomial(p, q)","def poly(x, degree=2):\n x = np.array(x)\n X_trans = np.transpose(np.vstack((x**k for k in range(degree + 1))))\n return np.linalg.qr(X_trans)[0][:, 1:]","def linear_polynomial(self, e: 'PFElement') -> Polynomial:\n poly = self.polynomial(-e)\n poly += poly.monic(1)\n return poly","def main():\r\n\r\n coef = [1,0,0,-1,-10]\r\n x = 2\r\n\r\n # The algorithm initializes result as coefficient of x^n, where n is the degree of polynomial and then\r\n # Repeatedly multiply result with x and add next coefficient to result\r\n result = coef[0]\r\n for i in range(1, len(coef)):\r\n result = (result * x) + coef[i]\r\n\r\n print(f'The function evaluate to : {result} for given x value: {x}')","def poly(x, y, pd) :\n # Maximum polynomial degree allowed is 7.\n maxD = 7\n if pd > maxD :\n exit(\"Please choose a reasonable polynomial degree (0 <= pd <= \" + maxD + \").\")\n \n # Make the polynomial matrix one degree at a time.\n p = np.zeros((len(x), int((pd+1)*(pd+2)/2)), float)\n count = 0\n numP = 0\n for i in range(pd + 1) :\n for j in range(numP + 1) :\n if (j == 0) and (numP == 0) :\n p[:,count] = 1\n elif (j == 0) :\n p[:,count] = x**(numP-j)\n elif (numP-j == 0) :\n p[:,count] = y**j\n else :\n p[:,count] = x**(numP-j) * y**j\n count += 1\n numP += 1\n \n return p","def polyval(p, x):\r\n val = 0\r\n ii = len(p) - 1\r\n for i in range(len(p) - 1):\r\n val += p[i] * (x ** ii)\r\n ii -= 1\r\n return val + p[-1]","def polyLS(pd, x, y, f, X, Y \\\n, coeff = [], xmc = [], ymc = [], ell = [], w = [], ELL = [], W = []) :\n xmc, ymc, ell, w, ELL, W = assignDefaults(x, y, xmc, ymc, ell, w, ELL, W)\n \n numP = int((pd + 1) * (pd + 2) / 2)\n \n if (len(xmc) == 1) and (len(ymc) == 1) :\n \n\n if coeff == [] :\n p = poly(x, y, pd)\n coeff = np.linalg.lstsq(p, f, rcond=None)[0]\n\n B = poly(X, Y, pd)\n approx = B.dot(coeff).flatten()\n coeff_copy = coeff\n \n else :\n \n approx = np.zeros(len(X), float)\n \n if coeff == [] :\n for i in range(len(xmc)) :\n IND = inSquare(x, y, xmc[i], ymc[i], ELL, W)\n if len(IND) < int(1.5 * numP) :\n raise ValueError(\"Not enough data for this polynomial \" \\\n + \"degree.\\nEither lower the polynomial degree or \" \\\n + \"decrease the number of subdivisions.\")\n p = poly(x[IND], y[IND], pd)\n lam = np.linalg.lstsq(p, f[IND], rcond=None)[0]\n coeff.append(lam)\n\n coeff_copy = coeff.copy()\n\n for i in range(len(xmc) - 1, -1, -1) :\n IND = inSquare(X, Y, xmc[i], ymc[i], ell, w)\n B = poly(X[IND], Y[IND], pd)\n lam = coeff.pop()\n approx[IND] = B.dot(lam).flatten()\n \n return approx, coeff_copy","def build_poly(x, degree):\n \"\"\"\n Assemble the 3 label vectors with the original ordering \n Inputs:\n - x (ndarray) : binary prediction for set 1\n - degree (int) : binary prediction for set 2 \n Outputs: \n - p (ndarray) : predicted labels for test set ( with the original ordering)\n \"\"\"\n # forming a matrix containing the data points\n terms = np.hstack([np.ones([x.shape[0],1]),np.tile(x,(1,degree))])\n index = np.arange(degree)+1\n \n # forming a matrix contnaining the exponents\n exponents = np.multiply(np.ones((1, x.shape[1])), index[:, np.newaxis])\n exponents = exponents.reshape([1, x.shape[1]*degree])\n exponents = np.multiply(exponents, np.ones([x.shape[0], 1]))\n exponents = np.hstack([np.ones( (x.shape[0], 1) ),exponents])\n \n # using the exponent matrix as the element-wise exponents of the terms in the terms matrix\n p=np.power(terms,exponents)\n return p","def construct_poly(data, power):\n return np.power(data, power)","def non_linear_polynomial_fit(self, seq, factor):\n B = np.array(seq[1:4])\n A = np.array([[seq[k], factor ** (k + 1), 1] for k in range(3)])\n return np.around(np.linalg.solve(A,B), decimals=2)","def poly(x, coeffs):\n return np.sum([coeffs[i] * x ** i for i in range(len(coeffs))], axis=0)","def poly_regression_cubic(X, Y, Xs_test, Ys_test):\n ## YOUR CODE HERE\n #################\n return 0","def coefficients_from_Weierstrass_polynomial(f):\n R = f.parent()\n cubic_variables = [x for x in R.gens() if f.degree(x) == 3]\n quadratic_variables = [y for y in R.gens() if f.degree(y) == 2]\n try:\n x = cubic_variables[0]\n y = quadratic_variables[0]\n except IndexError:\n raise ValueError('polynomial is not in long Weierstrass form')\n\n a1 = a2 = a3 = a4 = a6 = 0\n x3 = y2 = None\n for coeff, mon in f:\n if mon == x**3:\n x3 = coeff\n elif mon == x**2:\n a2 = coeff\n elif mon == x:\n a4 = coeff\n elif mon == 1:\n a6 = coeff\n elif mon == y**2:\n y2 = -coeff\n elif mon == x*y:\n a1 = -coeff\n elif mon == y:\n a3 = -coeff\n else:\n raise ValueError('polynomial is not in long Weierstrass form')\n\n if x3 != y2:\n raise ValueError('the coefficient of x^3 and -y^2 must be the same')\n elif x3 != 1:\n a1, a2, a3, a4, a6 = a1/x3, a2/x3, a3/x3, a4/x3, a6/x3\n return [a1, a2, a3, a4, a6]","def polyeval(self, x):\n return NotImplemented","def poly_func(x):\n \n # Create the polynomial object\n f = np.poly1d([1, -2, -28, 28, 12, -26, 100])\n\n # Return the value of the polynomial\n return f(x) * 0.05","def __getPolynomial(self) -> 'func':\n return lambda x: sum(self.pts[i]*base(x)\n for i, base in enumerate(self.basis))","def _reform_poly_coefficients(fit_poly_x, fit_poly_y):\n # Extract values for CD matrix and recombining\n c11 = fit_poly_x.c1_0.value\n c12 = fit_poly_x.c0_1.value\n c21 = fit_poly_y.c1_0.value\n c22 = fit_poly_y.c0_1.value\n sip_poly_x = fit_poly_x.copy()\n sip_poly_y = fit_poly_y.copy()\n # Force low order coefficients to be 0 as defined in SIP\n sip_poly_x.c0_0 = 0\n sip_poly_y.c0_0 = 0\n sip_poly_x.c1_0 = 0\n sip_poly_x.c0_1 = 0\n sip_poly_y.c1_0 = 0\n sip_poly_y.c0_1 = 0\n\n cdmat = ((c11, c12), (c21, c22))\n invcdmat = npla.inv(np.array(cdmat))\n degree = fit_poly_x.degree\n # Now loop through all remaining coefficients\n for i in range(0, degree + 1):\n for j in range(0, degree + 1):\n if (i + j > 1) and (i + j < degree + 1):\n old_x = getattr(fit_poly_x, f'c{i}_{j}').value\n old_y = getattr(fit_poly_y, f'c{i}_{j}').value\n newcoeff = np.dot(invcdmat, np.array([[old_x], [old_y]]))\n setattr(sip_poly_x, f'c{i}_{j}', newcoeff[0, 0])\n setattr(sip_poly_y, f'c{i}_{j}', newcoeff[1, 0])\n\n return cdmat, sip_poly_x, sip_poly_y","def poly_derivative(poly):\n if not poly or type(poly) is not list:\n return None\n\n response = []\n\n for order in range(1, len(poly)):\n response.append(order * poly[order])\n\n if not response:\n response.append(0)\n\n return response","def cheb_poly(x, n):\n if n == 0:\n return anp.array([1 for i in x])\n elif n == 1:\n return x\n else:\n return 2*x*cheb_poly(x, n-1)-cheb_poly(x, n-2)\n\n raise NotImplementedError(\"Problem 6 Incomplete\")","def __test_s_polynomial():\n poly_ring = PolynomialRing(QQ, 'x,y', order='deglex')\n x, y = poly_ring('x'), poly_ring('y')\n g = x ** 3 - 2 * x * y\n h = x ** 2 * y - 2 * y ** 2 + x\n print __s_polynomial(g, h) # Expected -x^2","def function_poly(coeffs, t, x, y, lc, coeffs_dict, coeffs_tuple, fix_coeffs, batman_params, poly_params, eclipse = False):\n new_flux = model_poly(coeffs, t, x, y, coeffs_dict, coeffs_tuple, fix_coeffs, batman_params, poly_params, eclipse = eclipse)\n return lc - new_flux","def polynomial(degree, coeffs):\n\n def h(x):\n result = 0\n degre=degree\n for i in range(len(coeffs)):\n result = result + coeffs[i]*(x**degre)\n degre = degre - 1\n return result\n \n\n def h(x):\n result = 0\n nonlocal degree\n for i in range(len(coeffs)):\n result = result + coeffs[i]*(x**degree)\n degree = degree - 1\n return result\n\n\n\n\n\n return h\n\n # def h(x):\n # result = 0\n # for i in range(degree, -1, -1):\n # result = result + coeffs[degree - i]*(x**i)\n \n # return result\n \n\n\n # return h","def get_poly_coeff(self, independent, dependent):\n\n try:\n x = self.df_input[[independent]]\n y = self.df_input[[dependent]]\n\n poly = PolynomialFeatures(degree = 2)\n x_poly = poly.fit_transform(x) \n\n model = LinearRegression()\n model.fit(x_poly, y)\n return model.coef_\n except Exception as e:\n print(e)","def coefficient(self) -> float:\n ...","def solve(n=5000,C=-6*10**11,a=900,b=3):\n coeffs = np.zeros(n+2)\n coeffs[0] = a-b*n\n coeffs[1] = b*(n+1) - a\n coeffs[-3] = -C\n coeffs[-2] = 2*C - a\n coeffs[-1] = a+b-C\n mp.dps = 27\n roots = polyroots(coeffs)\n for root in roots:\n print root","def polyFunction(x,weights):\n y=0\n for i in range (0,len(weights)):\n y+= weights[i]*(x**i)\n return y","def _evalPoly(self,a,x):\n y = a[0]\n for i in range(1,len(a)):\n y = self.F.Multiply(y, x)\n y = self.F.Add(y, a[i])\n return y","def polyFeat(X, p):\r\n # You need to return the following variables correctly.\r\n X_poly = np.zeros((X.shape[0], p))\r\n\r\n # ====================== YOUR CODE HERE ======================\r\n\r\n for i in range(p):\r\n X_poly[:, i] = X[:, 0] ** (i + 1)\r\n\r\n # ============================================================\r\n return X_poly","def phi_poly(self,x,i):\n return x**i","def test():\n assert str(Polynomial(0, 1, 0, -1, 4, -2, 0, 1, 3, 0)) == \"3x^8 + x^7 - 2x^5 + 4x^4 - x^3 + x\"\n assert str(Polynomial([-5, 1, 0, -1, 4, -2, 0, 1, 3, 0])) == \"3x^8 + x^7 - 2x^5 + 4x^4 - x^3 + x - 5\"\n assert str(Polynomial(x7=1, x4=4, x8=3, x9=0, x0=0, x5=-2, x3=-1, x1=1)) == \"3x^8 + x^7 - 2x^5 + 4x^4 - x^3 + x\"\n assert str(Polynomial(x2=0)) == \"0\"\n assert str(Polynomial(x0=0)) == \"0\"\n assert Polynomial(x0=2, x1=0, x3=0, x2=3) == Polynomial(2, 0, 3)\n assert Polynomial(x2=0) == Polynomial(x0=0)\n assert str(Polynomial(x0=1) + Polynomial(x1=1)) == \"x + 1\"\n assert str(Polynomial([-1, 1, 1, 0]) + Polynomial(1, -1, 1)) == \"2x^2\"\n pol1 = Polynomial(x2=3, x0=1)\n pol2 = Polynomial(x1=1, x3=0)\n assert str(pol1 + pol2) == \"3x^2 + x + 1\"\n assert str(pol1 + pol2) == \"3x^2 + x + 1\"\n assert str(Polynomial(x0=-1, x1=1) ** 1) == \"x - 1\"\n assert str(Polynomial(x0=-1, x1=1) ** 2) == \"x^2 - 2x + 1\"\n pol3 = Polynomial(x0=-1, x1=1)\n assert str(pol3 ** 4) == \"x^4 - 4x^3 + 6x^2 - 4x + 1\"\n assert str(pol3 ** 4) == \"x^4 - 4x^3 + 6x^2 - 4x + 1\"\n assert str(Polynomial(x0=2).derivative()) == \"0\"\n assert str(Polynomial(x3=2, x1=3, x0=2).derivative()) == \"6x^2 + 3\"\n assert str(Polynomial(x3=2, x1=3, x0=2).derivative().derivative()) == \"12x\"\n pol4 = Polynomial(x3=2, x1=3, x0=2)\n assert str(pol4.derivative()) == \"6x^2 + 3\"\n assert str(pol4.derivative()) == \"6x^2 + 3\"\n assert Polynomial(-2, 3, 4, -5).at_value(0) == -2\n assert Polynomial(x2=3, x0=-1, x1=-2).at_value(3) == 20\n assert Polynomial(x2=3, x0=-1, x1=-2).at_value(3, 5) == 44\n pol5 = Polynomial([1, 0, -2])\n assert pol5.at_value(-2.4) == -10.52\n assert pol5.at_value(-2.4) == -10.52\n assert pol5.at_value(-1, 3.6) == -23.92\n assert pol5.at_value(-1, 3.6) == -23.92","def pcoef(\n xte,yte,rle,\n x_cre,y_cre,d2ydx2_cre,th_cre,\n surface):\n\n # Initialize coefficients\n coef = np.zeros(6)\n\n # 1st coefficient depends on surface (pressure or suction)\n if surface.startswith('p'):\n coef[0] = -sqrt(2*rle)\n else:\n coef[0] = sqrt(2*rle)\n \n # Form system of equations\n A = np.array([\n [xte**1.5, xte**2.5, xte**3.5, xte**4.5, xte**5.5],\n [x_cre**1.5, x_cre**2.5, x_cre**3.5, x_cre**4.5, \n x_cre**5.5],\n [1.5*sqrt(xte), 2.5*xte**1.5, 3.5*xte**2.5, \n 4.5*xte**3.5, 5.5*xte**4.5],\n [1.5*sqrt(x_cre), 2.5*x_cre**1.5, 3.5*x_cre**2.5, \n 4.5*x_cre**3.5, 5.5*x_cre**4.5],\n [0.75*(1/sqrt(x_cre)), 3.75*sqrt(x_cre), 8.75*x_cre**1.5, \n 15.75*x_cre**2.5, 24.75*x_cre**3.5]\n ]) \n\n B = np.array([\n [yte - coef[0]*sqrt(xte)],\n [y_cre - coef[0]*sqrt(x_cre)],\n [tan(th_cre*pi/180) - 0.5*coef[0]*(1/sqrt(xte))],\n [-0.5*coef[0]*(1/sqrt(x_cre))],\n [d2ydx2_cre + 0.25*coef[0]*x_cre**(-1.5)]\n ])\n \n # Solve system of linear equations\n try:\n X = np.linalg.solve(A,B)\n except:\n X = np.linalg.solve(A+(1e-12*np.eye(5)),B)\n\n\n # Gather all coefficients\n coef[1:6] = X[0:5,0]\n\n # Return coefficients\n return coef","def zernikePoly(x, y, xOffset, yOffset, coefficients, xMax=-1e22, yMax=-1e22, verbose=False):\n\n if len(coefficients) > nMax + 1:\n raise ValueError('coefficients must have less than {} items.'.format(zernikies.nMax+1))\n\n if xMax == -1e22:\n xMax = np.nanmax(x - xOffset)\n if yMax == -1e22:\n yMax = np.nanmax(y - yOffset)\n\n xcn = (x - xOffset)/xMax\n ycn = (y - yOffset)/yMax\n\n rcn = np.sqrt(xcn**2. + ycn**2.)\n ucn = np.arctan2(ycn, xcn)\n\n z = zernikePolar(coefficients, rcn, ucn)\n\n if verbose:\n print(\"Zernike polynomials with coefficients\", coefficients)\n print(\"Their linear combination has mean: {0:.2e}, min: {1:.2e}, max: {2:.2e}\".format(np.mean(z), np.nanmin(z), np.nanmax(z)))\n\n return z","def poly_eq(self, independent, dependent):\n\n try:\n x = self.df_input[[independent]]\n y = self.df_input[[dependent]]\n\n poly = PolynomialFeatures(degree = 2)\n x_poly = poly.fit_transform(x) \n\n model = LinearRegression()\n model.fit(x_poly, y)\n coef_arr = model.coef_\n intercept_arr = model.intercept_\n \n poly_equation = \"y = \" + str(round(coef_arr[0][2], 4)) + \"x\\xB2\"\n \n if(coef_arr[0][1] < 0):\n poly_equation += \" + (\" + str(round(coef_arr[0][1], 4)) + \"x\" + \")\"\n else:\n poly_equation += \" + \" + str(round(coef_arr[0][1], 4)) + \"x\"\n \n if(intercept_arr[0] < 0):\n poly_equation += \" + (\" + str(round(intercept_arr[0], 4)) + \")\"\n else:\n poly_equation += \" + \" + str(round(intercept_arr[0], 4))\n \n return poly_equation\n except Exception as e:\n print(e)","def horner(poly: Sequence[float], x: float) -> float:\n result = 0.0\n for coeff in reversed(poly):\n result = result * x + coeff\n return result","def poly_derivative(poly):\n if type(poly) is not list or len(poly) < 1:\n return None\n if len(poly) == 1:\n return [0]\n\n derivated_coefficients = []\n\n for power, coefficient in enumerate(poly):\n if power == 0:\n pass\n\n else:\n new_coefficient = coefficient * power\n derivated_coefficients.append(new_coefficient)\n\n return(derivated_coefficients)","def coeffients(x, y):\n\n # ensure floating point datatypes\n x.astype(float)\n y.astype(float)\n\n # degree of interpolating polynomial\n n = len(x)\n\n # intitilize list of coeffients for interpolating polynomial to y values\n c = y.tolist()\n\n # compute coeffients\n for j in range(1, n):\n for i in range(n-1, j-1, -1):\n c[i] = float(c[i]-c[i-1])/float(x[i]-x[i-j])\n\n # return an array of polynomial coefficient, note: reverse order for np.polyval function\n return np.array(c[::-1])","def evaluate_polynomial(tropical_matrix, coefficient_list):\n identity_matrix = get_identity_matrix(tropical_matrix.get_dimension())\n sum_list = []\n sum_list.append(identity_matrix.mult_scalar(coefficient_list[0]))\n for i in range(1, len(coefficient_list)):\n sum_list.append(tropical_matrix.mult_scalar(coefficient_list[i]))\n return get_minimum_sum(sum_list)","def polynomial(a, x):\n\n sum = 0\n\n for i in range(len(a)):\n sum += a[i] * x**i\n return sum","def evaluate_poly(poly, x):\n exp = 0\n total = 0\n for coef in poly:\n total += coef * (x ** exp)\n exp += 1\n\n return total","def evaluate_poly(poly: Sequence[float], x: float) -> float:\n return sum(c * (x**i) for i, c in enumerate(poly))","def build_poly(x, degree): \n # ***************************************************\n # COPY YOUR CODE FROM EX03 HERE\n # polynomial basis function: TODO\n # this function should return the matrix formed\n # by applying the polynomial basis to the input data\n # ***************************************************\n raise NotImplementedError","def OF0_TestFunction_SimpleParabolic(x):\n return x ** 2","def Pol_Newton_un_punto(x,datos_x,datos_y):\n n = datos_x.shape[0]\n matriz=np.ones([n,n])\n for j in range(n):\n for i in range(n):\n if j>i:\n matriz[i][j]=0\n else:\n producto=1\n for k in range(j):\n producto=producto*(datos_x[i]-datos_x[k])\n matriz[i][j]=producto\n matriz,datos_y1= pivoteo_parcial(matriz,datos_y)\n x1 = descompo_LU(matriz,datos_y1)\n prod=np.zeros(x1.shape[0])\n for i in range(n):\n if i==0:\n prod[i]=1\n else: \n prod[i]=prod[i-1]*(x-datos_x[i-1])\n solucion=x1@prod\n return solucion","def evaluate_poly(poly, x):\n value_of_poly = 0\n for i in range(0, len(poly)):\n var = x\n power = i\n coeff = poly[i]\n value_of_poly += (coeff * (var**power))\n return value_of_poly","def polynomial_equation(funct):\n coeff = str(differentiation.parse_coefficient(funct))\n if \"^\" not in funct:\n divisor = \"1\"\n else:\n divisor_location = str(funct.index(\"^\") + 1)\n divisor = funct[divisor_location:]\n if divisor == \"-1\":\n pass\n else:\n divisor = str(int(divisor) + 1)\n coeff += \"/\" + divisor\n return coeff + \"x^\" + str(divisor)","def PBpoly(n, x):\n n = int(n)\n return Bpoly(n, x-math.floor(x))","def polynomial(x, y):\n \n var = copy(x)\n known = copy(y)\n V = vandermonde_matrix(var)\n a = gauss_elimination(V, known)\n return a","def PolyMulRed(multipliees, poly):\n if poly.degree() < 1:\n return poly.getRing().zero\n product = multipliees.pop()\n for factor in multipliees:\n #print type(product)\n #if factor.degree() >= poly.degree():\n #factor = PolyMod(factor, poly)\n #if factor == 0:\n # return 0\n product = product * factor\n if product.degree() >= poly.degree():\n product = PolyMod(product, poly)\n if not product:\n break\n return product","def get_polyfit_function(self):\n N = len(self.coefficients)\n return lambda x: np.dot( self.get_poly(x).T , self.coefficients.reshape(N, 1) )","def get_poly(self, n, xf = 14, y0=[1, 0], first_step = 1e-10, max_step = .1):\n self.n = n\n y0s = [1- first_step**2/2, - first_step]\n sol = integ.solve_ivp(lambda t, y: self.f(t, y, n), (first_step, xf), y0s, max_step=max_step, \\\n vectorized=True, events=self.find_zero)\n data_sol = np.array([sol.t, sol.y[0], sol.y[1]])\n data_sol[1, -1] = 1e-18\n data0 = np.array([0, y0[0], y0[1]]).reshape(3, 1)\n self.poly = np.concatenate((data0, data_sol), axis=1)","def get_expected_polynomial_coefs(y, degree, with_intercept=True):\n poly_matrix = np.vander(np.arange(len(y)), degree + 1)\n if not with_intercept:\n poly_matrix = poly_matrix[:, :-1]\n return np.linalg.lstsq(poly_matrix, y.to_numpy(), rcond=None)[0]","def pol_evl(x, coef, N):\n ans = coef[0]\n for i in range(1, N + 1):\n ans = ans * x + coef[i]\n return ans","def coef_val():\n\n basepath = path.join(path.dirname(path.realpath('__file__')), 'data')\n fdata = basepath + path.sep + 'VAWTPolySurfaceCoef_pub.csv' # published coefficients from paper\n # fdata = basepath + path.sep + 'VAWTPolySurfaceCoef.csv' # polynomial surface fitting coefficients\n\n loc1 = np.zeros(10)\n loc2 = np.zeros(10)\n loc3 = np.zeros(10)\n spr1 = np.zeros(10)\n spr2 = np.zeros(10)\n skw1 = np.zeros(10)\n skw2 = np.zeros(10)\n scl1 = np.zeros(10)\n scl2 = np.zeros(10)\n scl3 = np.zeros(10)\n\n f = open(fdata)\n csv_f = csv.reader(f)\n\n i = 0\n for row in csv_f:\n if i != 0:\n loc1[i-1] = float(row[0])\n loc2[i-1] = float(row[1])\n loc3[i-1] = float(row[2])\n spr1[i-1] = float(row[3])\n spr2[i-1] = float(row[4])\n skw1[i-1] = float(row[5])\n skw2[i-1] = float(row[6])\n scl1[i-1] = float(row[7])\n scl2[i-1] = float(row[8])\n scl3[i-1] = float(row[9])\n i += 1\n\n f.close()\n\n return loc1,loc2,loc3,spr1,spr2,skw1,skw2,scl1,scl2,scl3","def polynomial_value(multipliers, variable):\n def term(mult, var, order):\n if order > 1:\n return mult * variable ** order\n elif order == 1:\n return mult * variable\n elif order == 0:\n return mult\n return sum([term(mult, variable, order) for order, mult in enumerate(multipliers)])","def easy_eval(self, x):\n answer = 0\n for i in range(len(self.coefficients)):\n coef = self.coefficients[i]\n degree = len(self.coefficients) - (i+1)\n answer += x ** degree * coef\n return answer","def coef_approximation(p, order):\n\n\t# maintain parity of order +1\n\tn = 50 + order +1\n\tr = 1\n\txs = np.linspace(-r, r, num=n)\n\tys = p(xs)\n\n\t# [TODO]: fix coeffients method\n\t# replace with 'c = coeffients(xs, ys)'\n\tdegree = n \n\tc = np.polyfit(xs,ys,degree)\n\n\treturn c","def get_coeff(self):\n return bernoulli(self.degree+1) / factorial(self.degree + 1)","def evaluate_poly(poly, x):\n if len(poly) == 1:\n\t\t#base case\n\t\treturn poly[0]\n else:\n #recursive case\n #the first item in the tuple is the coefficient of X**0, so it's the final value\n #the rest of the items in the tuple need multiplied by X and put in new tuple\n #Yes, I'm cheating and casting a list to a tuple. GFY and your immutability.\n return poly[0] + evaluate_poly(tuple([x * coeff for coeff in poly[1:]]), x)","def zernike_radial_coeffs(l, m, exact=True):\n l = np.atleast_1d(l).astype(int)\n m = np.atleast_1d(np.abs(m)).astype(int)\n lm = np.vstack([l, m]).T\n # for modest to large arrays, faster to find unique values and\n # only evaluate those\n lms, idx = np.unique(lm, return_inverse=True, axis=0)\n\n npoly = len(lms)\n lmax = np.max(lms[:, 0])\n coeffs = np.zeros((npoly, lmax + 1), dtype=object)\n lm_even = ((lms[:, 0] - lms[:, 1]) % 2 == 0)[:, np.newaxis]\n for ii in range(npoly):\n ll = lms[ii, 0]\n mm = lms[ii, 1]\n for s in range(mm, ll + 1, 2):\n coeffs[ii, s] = (\n (-1) ** ((ll - s) // 2)\n * factorial((ll + s) // 2)\n // (\n factorial((ll - s) // 2)\n * factorial((s + mm) // 2)\n * factorial((s - mm) // 2)\n )\n )\n c = np.fliplr(np.where(lm_even, coeffs, 0))\n if not exact:\n try:\n c = c.astype(int)\n except OverflowError:\n c = c.astype(float)\n c = c[idx]\n return c","def fit_poly(x, y, n=5, log=False):\n \n x_g = x\n x = np.ma.array(x, mask=y.mask).compressed()\n y = y.compressed()\n if log:\n yl = np.log10(y)\n else:\n yl = y\n fit = np.polyfit(x, yl, n)\n p = np.poly1d(fit)\n \n if log:\n return 10**(p(x_g))\n else:\n return p(x_g)","def base_polynome(numbers):\n\n monomes = [ x**n for n in numbers ]\n polynome = sum(monomes)\n\n return poly(polynome, x)","def fit_polynomial_regression(self, x_train, y_train):\n x_poly = self.poly_reg.fit_transform(x_train)\n self.lin_reg.fit(x_poly, y_train)","def __pow__(self, exp):\n # We have (p o Q)^e = p^e o Q\n coeff = (self._unit_simplex_polynomial**exp).coeff\n if isinstance(exp, numbers.Integral):\n r = self.degree() * exp\n else:\n r = 0\n for i in range(len(exp)):\n r += self[i].degree() * exp[i]\n return PolynomialBernsteinSimplex(coeff, self.vertices, r)","def phasepoly14(param, x):\n # 2011-09-26 10:42 IJMC: Created from phaselamb14\n N = len(param) - 14\n cparam = array(param[N::], copy=True)\n cparam[0] = 1. / prod(1. + cparam[1::]) - 1.\n\n if len(x.shape)==1:\n was1d = True\n x = x.reshape(14, len(x)/14.)\n else:\n was1d = False\n\n ret = polyval(param[0:N], x)\n ret *= (1. + cparam.reshape(14,1))\n\n if was1d:\n ret = ret.ravel()\n\n return ret","def fit_poly(data, error_func, degree=4): \n\n # generate initial guss for polynomial model (all coeffs = 1)\n guess = np.poly1d(np.ones(degree + 1, dtype=np.float32))\n\n # plot intial guess\n x = np.linspace(-5, 5, 21)\n plt.plot(x, np.polyval(guess, x), 'm--', linewidth=2.0, label=\"Initial guess\")\n\n # call optimizer to minimize error function\n result = spo.minimize(error_poly, guess, args=(data,), method='SLSQP', options={'disp':True})\n \n # convert optimal result into a poly1d object\n return np.poly1d(result.x)","def claret_linear(mu, coeff):\n return 1.0 - coeff * (1.0 - mu)","def calculate_newton_interpolation(divided_differences):\n polynomial = []\n for i, divided_differences_row in enumerate(divided_differences):\n polynomial_part = '({0})'.format(divided_differences_row[0].divided_difference)\n\n for j in range(0, i):\n polynomial_part += '*(x-{0})'.format(divided_differences[0][j].x)\n\n polynomial_part += '+'\n polynomial.append(polynomial_part)\n polynomial_str = ''.join(polynomial)[:-1]\n\n print('Calculated polynomial: {0}'.format(polynomial_str))\n # Heuristic simplification of calculated polynomial\n simplified_polynomial = sy.simplify(polynomial_str)\n print(\"Simplified polynomial: {0}\".format(simplified_polynomial))\n return simplified_polynomial","def general_poly(L):\n def evaluate(x):\n length=len(L)-1\n value=0\n for i in L:\n value+=i*(x**length)\n length-=1\n return value\n return evaluate","def solve_nonlinear(self, params, unknowns, resids):\n\n x = params['x']\n m = self.slope\n b = self.intercept\n\n unknowns['y'] = m*x + b","def nc_coeffs(poly, var, max_deg=10, order='increasing'):\r\n\r\n # TODO: elegant way to find out the degree\r\n # workarround: pass the maximum expected degree as kwarg\r\n\r\n D0 = sp.Dummy('D0')\r\n poly = poly.expand() + D0 # ensure class add\r\n\r\n assert isinstance(poly, sp.Add)\r\n res = []\r\n # special case: 0-th power of var\r\n coeff = 0\r\n for a in poly.args:\r\n if not a.has(var):\r\n coeff += a\r\n res.append(coeff.subs(D0, 0))\r\n\r\n # special case: first power of var\r\n coeff = poly.diff(var).subs(var, 0)\r\n res.append(coeff)\r\n\r\n # powers > 1:\r\n for i in xrange(1, max_deg):\r\n coeff = 0\r\n for a in poly.args:\r\n if a.has(var**(i + 1)):\r\n term = a.subs(var, 1)\r\n coeff += term\r\n res.append(coeff)\r\n\r\n if order == \"decreasing\":\r\n res.reverse()\r\n\r\n return res","def F(cst, x):\n [u0, v0, u1, v1, u2, v2, coeffs] = cst\n [u, v, g1, g2, g3] = x\n a = g1*u1 - u0\n b = g2*u2 - u0\n c = g3*u - u0\n l = g1*v1 - v0 \n m = g2*v2 - v0\n n = g3*v - v0\n r = g1 - 1\n s = g2 - 1\n t = g3 - 1\n return np.array([\n coeffs[0]*(a**2-l**2) + 2*coeffs[1]*(a*b-l*m) + coeffs[2]*(b**2-m**2) + 2*coeffs[3]*(a*c-l*n) + 2*coeffs[4]*(b*c-m*n) + c**2 - n**2,\n coeffs[0]*(l**2-r**2) + 2*coeffs[1]*(l*m-r*s) + coeffs[2]*(m**2-s**2) + 2*coeffs[3]*(l*n-r*t) + 2*coeffs[4]*(m*n-s*t) + n**2 - t**2,\n coeffs[0]*a*l + coeffs[1]*(l*b+m*a) + coeffs[2]*m*b + coeffs[3]*(l*c+n*a) + coeffs[4]*(m*c+b*n) + c*n,\n coeffs[0]*a*r + coeffs[1]*(r*b+s*a) + coeffs[2]*s*b + coeffs[3]*(r*c+t*a) + coeffs[4]*(s*c+b*t) + c*t,\n coeffs[0]*r*l + coeffs[1]*(l*s+m*r) + coeffs[2]*m*s + coeffs[3]*(l*t+n*r) + coeffs[4]*(m*t+s*n) + t*n \n ])","def printPolyCoeffs(lam) :\n ell = len(lam)\n useFormat = \"2.6e\"\n count = 0\n def printLine(s, count) :\n if lam[count] < 0 :\n s = s + 3 * \" \"\n else :\n s = s + 4 * \" \"\n s = s + \"{0:\" + useFormat + \"}\"\n print(s . format(lam[count]))\n count = count + 1\n return count\n if ell >= 1 :\n count = printLine(\"x0y0\", count)\n if ell >= 3 :\n count = printLine(\"x1y0\", count)\n count = printLine(\"x0y1\", count)\n if ell >= 6 :\n count = printLine(\"x2y0\", count)\n count = printLine(\"x1y1\", count)\n count = printLine(\"x0y2\", count)\n if ell >= 10 :\n count = printLine(\"x3y0\", count)\n count = printLine(\"x2y1\", count)\n count = printLine(\"x1y2\", count)\n count = printLine(\"x0y3\", count)\n if ell >= 15 :\n count = printLine(\"x4y0\", count)\n count = printLine(\"x3y1\", count)\n count = printLine(\"x2y2\", count)\n count = printLine(\"x1y3\", count)\n count = printLine(\"x0y4\", count)\n if ell >= 21 :\n count = printLine(\"x5y0\", count)\n count = printLine(\"x4y1\", count)\n count = printLine(\"x3y2\", count)\n count = printLine(\"x2y3\", count)\n count = printLine(\"x1y4\", count)\n count = printLine(\"x0y5\", count)\n if ell >= 28 :\n count = printLine(\"x6y0\", count)\n count = printLine(\"x5y1\", count)\n count = printLine(\"x4y2\", count)\n count = printLine(\"x3y3\", count)\n count = printLine(\"x2y4\", count)\n count = printLine(\"x1y5\", count)\n count = printLine(\"x0y6\", count)\n if ell >= 36 :\n count = printLine(\"x7y0\", count)\n count = printLine(\"x6y1\", count)\n count = printLine(\"x5y2\", count)\n count = printLine(\"x4y3\", count)\n count = printLine(\"x3y4\", count)\n count = printLine(\"x2y5\", count)\n count = printLine(\"x1y6\", count)\n count = printLine(\"x0y7\", count)\n if (ell > 36) or (ell < 1) :\n raise ValueError(\"Polynomial degree less than or equal to 7, please.\")","def __pow__(self, power):\n if power == 1:\n return self\n elif power == 0:\n return Polynomial(1)\n\n self.polynomials = {key: val for key, val in self.polynomials.items() if val != 0}\n self.polynomials = dict(sorted(self.polynomials.items(), reverse=True))\n\n attributes = {}\n\n # Using Binomial theorem\n n = 0\n m = power\n use_n = True\n\n for k in range(0, power + 1):\n result = self.calculate_combinatorial_number(power, k)\n\n for index, polynomial in self.polynomials.items():\n if use_n:\n result *= pow(polynomial, (power - n))\n n += 1\n use_n = False\n else:\n result *= pow(polynomial, (power + m))\n m -= 1\n use_n = True\n\n attributes[\"x\" + str(n - 1)] = result\n\n return Polynomial(**attributes)","def conway_polynomial(n=100):\n \n xs = []\n ys = []\n for i in range(n):\n x = (i - n/2) / 50\n xs.append(x)\n\n y = x**71 - x**69 - 2*x**68 - x**67 + 2*x**66 + 2*x**65 + x**64 - x**63 - x**62 - x**61 - x**60 - x**59 + 2*x**58 + 5*x**57 + 3*x**56 +\\\n - 2*x**55 - 10*x**54 - 3*x**53 - 2*x**52 + 6*x**51 + 6*x**50 + x**49 + 9*x**48 - 3*x**47 - 7*x**46 - 8*x**45 - 8*x**44 + 10*x**43 +\\\n + 6*x**42 + 8*x**41 - 5*x**40 - 12*x**39 + 7*x**38 - 7*x**37 + 7*x**36 + x**35 - 3*x**34 + 10*x**33 + x**32 - 6*x**31 - 2*x**30 +\\\n - 10*x**29 - 3*x**28 + 2*x**27 + 9*x**26 - 3*x**25 + 14*x**24 - 8*x**23 - 7*x**21 + 9*x**20 + 3*x**19 - 4*x**18 - 10*x**17 - 7*x**16 +\\\n + 12*x**15 + 7*x**14 + 2*x**13 - 12*x**12 - 4*x**11 - 2*x**10 + 5*x**9 + x**7 - 7*x**6 + 7*x**5 - 4*x**4 + 12*x**3 - 6*x**2 + 3*x - 6\n\n ys.append(y)\n\n return xs, ys","def fourth_poly(a, b, c, d, e):\n return lambda z: a*z**4 + b*z**3 + c*z**2 + d*z + e","def general_poly (L):\n def to_apply (x):\n n = 0\n for i in L:\n n = x*n + i\n return n\n return to_apply","def _fit_poly(y_data, deg=5):\n x = np.arange(1, len(y_data) + 1)\n coeffs = np.polynomial.polynomial.polyfit(\n x, y_data, deg=deg)\n y_pred = poly(x, coeffs)\n return coeffs, np.mean((y_data - y_pred) ** 2)","def calc_poly_linear_regression(independent, dependent):\n # Reshape for sklearn\n independent = independent.values.reshape(-1,1)\n dependent = dependent.values.reshape(-1,1)\n # Make the whole thing poly\n poly = PolynomialFeatures(degree=2)\n independent_ = poly.fit_transform(independent)\n # Do the linear regression\n model = LinearRegression()\n model.fit(independent_, dependent)\n # Calculate R2\n return model.score(independent_, dependent)","def generate_polynomial_features(self, X) :\n\n n,d = X.shape\n\n ### ========== TODO : START ========== ###\n # part b: modify to create matrix for simple linear model\n # part g: modify to create matrix for polynomial model\n Phi = X\n m = self.m_\n\n if m == 1:\n Phi = np.zeros((n,2))\n for i in range(n):\n Phi[i,0] = 1\n Phi[i, 1] = X[i]\n\n else:\n Phi = np.ones((n,m+1))#n*m+1 dimmension\n power_arr = np.arange(0, m+1)\n for index, row in enumerate(Phi):# get every row\n row = np.repeat(X[index],m+1)\n row = np.power(row,power_arr)\n Phi [index,] = row\n #also could use the following\n \"\"\"\n import sklearn.preprocessing as sk\n #X is a N*1 vector\n poly_mat = sk.PolynomialFeatures(3)\n poly.fit_transform(a)\n \"\"\"\n\n\n\n\n\n ### ========== TODO : END ========== ###\n\n return Phi","def add_polynomial_features(x, power):\n if type(power) is int and type(x) is np.ndarray:\n return np.concatenate([x**i for i in range(1, power+1)], axis=1)\n return None","def parse_polynomial(s):\n\n def parse_n(s):\n '''Parse the number part of a polynomial string term'''\n if not s:\n return 1\n elif s == '-':\n return -1\n elif s == '+':\n return 1\n return float(eval(s))\n\n def parse_p(s, powerPattern):\n '''Parse the power part of a polynomial string term'''\n if not s:\n return 0\n multipliers = powerPattern.findall(s)[0]\n if not multipliers:\n return 1\n return int(multipliers)\n s = str(s).replace(' ', '') # remove all whitespace from string\n m = re.search('[a-zA-Z]+', s)\n try:\n varLetter = m.group(0)\n except AttributeError:\n varLetter = 'P'\n termPattern = re.compile(\n '([+-]?\\d*\\.?\\d*)\\**({var}?\\^?\\d?)'.format(var=varLetter))\n powerPattern = re.compile('{var}\\^?(\\d)?'.format(var=varLetter))\n order_multipliers = {}\n\n for n, p in termPattern.findall(s):\n n, p = n.strip(), p.strip()\n if not n and not p:\n continue\n n, p = parse_n(n), parse_p(p, powerPattern)\n if p in order_multipliers:\n order_multipliers[p] += n\n else:\n order_multipliers[p] = n\n highest_order = max(\n max(order_multipliers.keys()), 1) # order must be at least linear\n multipliers = [0] * (highest_order + 1)\n for key, val in order_multipliers.items():\n multipliers[key] = val\n\n return multipliers","def polynomial_incremental_value(multipliers, variable):\n return sum([(mult * order * variable ** (order - 1) if order > 0 else 0) for order, mult in enumerate(multipliers)])","def residuals_PL(self, p, data, x):\n err = data - self.PowerLaw(x,p)\n return err","def f(self, x, coeffs, jitter = 0):\n return np.polyval(np.flip(coeffs), x) + random.uniform(-jitter,jitter)","def _generate_poly_array(self, nchan, coeff=[]):\n if nchan < 0:\n raise ValueError, \"nchan should be >=0\"\n if len(coeff)==0:\n if nchan ==0: return []\n else: raise ValueError, \"No valid coefficient given.\"\n polyarr = numpy.zeros(nchan)\n for iorder in range(len(coeff)):\n polyarr += coeff[iorder]*numpy.array(xrange(nchan))**iorder\n return polyarr","def Bpoly(n, x):\n n = int(n)\n out = 0\n for k in xrange(0, n+1):\n out += comb(n,k)*Bnum(n-k)*x**float(k)\n return out","def solve_nonlinear(self, params, unknowns, resids):\n\n x = params['x']\n z = unknowns['z']\n znew = z\n\n iter = 0\n eps = 1.0e99\n while iter < self.maxiter and abs(eps) > self.atol:\n z = znew\n znew = 4.0 - x*z\n\n eps = x*znew + znew - 4.0\n\n unknowns['z'] = znew\n unknowns['y'] = x + 2.0*znew\n\n resids['z'] = eps\n #print(unknowns['y'], unknowns['z'])","def anti_deriv(self):\n poly_anti_deriv = [0]\n for i, val in enumerate(self.coeff):\n poly_anti_deriv.append(round(val/(i+1.0), 2))\n return Poly(poly_anti_deriv)","def preprocess_roots(poly):\n coeff = S.One\n\n poly_func = poly.func\n try:\n _, poly = poly.clear_denoms(convert=True)\n except DomainError:\n return coeff, poly\n\n poly = poly.primitive()[1]\n poly = poly.retract()\n\n # TODO: This is fragile. Figure out how to make this independent of construct_domain().\n if poly.get_domain().is_Poly and all(c.is_term for c in poly.rep.coeffs()):\n poly = poly.inject()\n\n strips = list(zip(*poly.monoms()))\n gens = list(poly.gens[1:])\n\n base, strips = strips[0], strips[1:]\n\n for gen, strip in zip(list(gens), strips):\n reverse = False\n\n if strip[0] < strip[-1]:\n strip = reversed(strip)\n reverse = True\n\n ratio = None\n\n for a, b in zip(base, strip):\n if not a and not b:\n continue\n elif not a or not b:\n break\n elif b % a != 0:\n break\n else:\n _ratio = b // a\n\n if ratio is None:\n ratio = _ratio\n elif ratio != _ratio:\n break\n else:\n if reverse:\n ratio = -ratio\n\n poly = poly.eval(gen, 1)\n coeff *= gen**(-ratio)\n gens.remove(gen)\n\n if gens:\n poly = poly.eject(*gens)\n\n if poly.is_univariate and poly.get_domain().is_ZZ:\n basis = _integer_basis(poly)\n\n if basis is not None:\n n = poly.degree()\n\n def func(k, coeff):\n return coeff//basis**(n - k[0])\n\n poly = poly.termwise(func)\n coeff *= basis\n\n if not isinstance(poly, poly_func):\n poly = poly_func(poly)\n return coeff, poly","def find_coefficients(self):\n self.make_matrix()\n self.coeffs = np.linalg.solve(self.global_matrix,self.global_vector)\n self.coeffs = np.append(self.coeffs, self.D) #Initial condition","def calculate(self, x):\n result = 0\n\n for index, polynomial in self.polynomials.items():\n result += polynomial * pow(x, int(index))\n\n return result","def test_solver():\n # Choice of nonlinear coefficient\n m = 2\n\n def q(u):\n return (1+u)**m\n\n def Dq(u):\n return m*(1+u)**(m-1)\n\n u_exact = Expression(\n 'pow((pow(2, m+1)-1)*x[0] + 1, 1.0/(m+1)) - 1', m=m)\n linear_solver = 'direct'\n errors = []\n for method in 'alg_Newton', 'pde_Newton':\n for J_comp in 'manual', 'automatic':\n for degree in 1, 2, 3:\n error_prev = -1\n for divisions in [(10, 10), (20, 20), (40, 40)]:\n u = solver(\n q, Dq, f, divisions, degree,\n method, J_comp,\n linear_solver,\n abs_tol_Krylov=1E-10,\n rel_tol_Krylov=1E-10,\n abs_tol_Newton=1E-10,\n rel_tol_Newton=1E-10)\n\n # Find max error\n u_e = interpolate(u_exact, u.function_space())\n import numpy as np\n error = np.abs(u_e.vector().array() -\n u.vector().array()).max()\n # Expect convergence as h**(degree+1)\n if error_prev > 0:\n frac = abs(error - error_prev/2**(degree+1))\n errors.append(frac)\n error_prev = error\n tol = 4E-5\n for error_reduction in errors:\n assert error_reduction < tol, error_reduction","def general_poly (L):\r\n\r\n def secondFunc(x):\r\n total = 0\r\n listLength = len(L)-1\r\n for i in L:\r\n total += i * x**listLength\r\n listLength -= 1\r\n return(total)\r\n return secondFunc","def test_degree(poly_equation):\n equation = poly_equation\n A = 1e10\n degree = np.log(equation.flux(A)/equation.flux(1))/np.log(A)\n npt.assert_allclose(equation.degree(), degree)","def generate_random_tropical_poly(max_degree, min_coefficient, max_coefficient):\n coefficients = []\n for d in range(0, random.randint(1, max_degree) + 1):\n coefficients.append(random.randint(min_coefficient, max_coefficient))\n return coefficients","def recf_legendre_poly(basetensor, ind, x):\n n = ind.getN()\n return (2.*n-1.)/n*basetensor[ind.all+ind.getSpecial()] \\\n * basetensor[ind.all + ind.getPreceding(1)] \\\n - (n-1.)/n*basetensor[ind.all + ind.getPreceding(2)]","def solve_nonlinear(self, params, unknowns, resids):\n\n x = params['x']\n a = self.a\n b = self.b\n c = self.c\n\n unknowns['y'] = a*x**2 + b*x + c"],"string":"[\n \"def generate_polynomial():\\n degree = numpy.random.choice(range(3, 7))\\n x = numpy.linspace(-10, 10, 1000)\\n coefficients = numpy.random.chisquare(3, size=degree) + 1\\n coefficients *= numpy.random.choice([-1, 1], size=coefficients.shape)\\n coefficients *= 0.5\\n y = numpy.polyval(coefficients, x)\\n add_noise(y, 0.1)\\n return x, y\",\n \"def evaluate_polynomial(f,x):\\n degree = len(f)-1\\n ans = 0\\n for i in f:\\n ans += i*x**degree\\n degree -= 1\\n return(ans)\",\n \"def _poly_func(x, a, b, c, d, e):\\n return a * x ** 6 + b * x ** 5 + c * x ** 4 + d * x ** 3 + e * x ** 2\",\n \"def E_polynomial(self):\\n\\n from nodepy import stability_function\\n p, q = self.stability_function()\\n return stability_function.E_polynomial(p, q)\",\n \"def poly(x, degree=2):\\n x = np.array(x)\\n X_trans = np.transpose(np.vstack((x**k for k in range(degree + 1))))\\n return np.linalg.qr(X_trans)[0][:, 1:]\",\n \"def linear_polynomial(self, e: 'PFElement') -> Polynomial:\\n poly = self.polynomial(-e)\\n poly += poly.monic(1)\\n return poly\",\n \"def main():\\r\\n\\r\\n coef = [1,0,0,-1,-10]\\r\\n x = 2\\r\\n\\r\\n # The algorithm initializes result as coefficient of x^n, where n is the degree of polynomial and then\\r\\n # Repeatedly multiply result with x and add next coefficient to result\\r\\n result = coef[0]\\r\\n for i in range(1, len(coef)):\\r\\n result = (result * x) + coef[i]\\r\\n\\r\\n print(f'The function evaluate to : {result} for given x value: {x}')\",\n \"def poly(x, y, pd) :\\n # Maximum polynomial degree allowed is 7.\\n maxD = 7\\n if pd > maxD :\\n exit(\\\"Please choose a reasonable polynomial degree (0 <= pd <= \\\" + maxD + \\\").\\\")\\n \\n # Make the polynomial matrix one degree at a time.\\n p = np.zeros((len(x), int((pd+1)*(pd+2)/2)), float)\\n count = 0\\n numP = 0\\n for i in range(pd + 1) :\\n for j in range(numP + 1) :\\n if (j == 0) and (numP == 0) :\\n p[:,count] = 1\\n elif (j == 0) :\\n p[:,count] = x**(numP-j)\\n elif (numP-j == 0) :\\n p[:,count] = y**j\\n else :\\n p[:,count] = x**(numP-j) * y**j\\n count += 1\\n numP += 1\\n \\n return p\",\n \"def polyval(p, x):\\r\\n val = 0\\r\\n ii = len(p) - 1\\r\\n for i in range(len(p) - 1):\\r\\n val += p[i] * (x ** ii)\\r\\n ii -= 1\\r\\n return val + p[-1]\",\n \"def polyLS(pd, x, y, f, X, Y \\\\\\n, coeff = [], xmc = [], ymc = [], ell = [], w = [], ELL = [], W = []) :\\n xmc, ymc, ell, w, ELL, W = assignDefaults(x, y, xmc, ymc, ell, w, ELL, W)\\n \\n numP = int((pd + 1) * (pd + 2) / 2)\\n \\n if (len(xmc) == 1) and (len(ymc) == 1) :\\n \\n\\n if coeff == [] :\\n p = poly(x, y, pd)\\n coeff = np.linalg.lstsq(p, f, rcond=None)[0]\\n\\n B = poly(X, Y, pd)\\n approx = B.dot(coeff).flatten()\\n coeff_copy = coeff\\n \\n else :\\n \\n approx = np.zeros(len(X), float)\\n \\n if coeff == [] :\\n for i in range(len(xmc)) :\\n IND = inSquare(x, y, xmc[i], ymc[i], ELL, W)\\n if len(IND) < int(1.5 * numP) :\\n raise ValueError(\\\"Not enough data for this polynomial \\\" \\\\\\n + \\\"degree.\\\\nEither lower the polynomial degree or \\\" \\\\\\n + \\\"decrease the number of subdivisions.\\\")\\n p = poly(x[IND], y[IND], pd)\\n lam = np.linalg.lstsq(p, f[IND], rcond=None)[0]\\n coeff.append(lam)\\n\\n coeff_copy = coeff.copy()\\n\\n for i in range(len(xmc) - 1, -1, -1) :\\n IND = inSquare(X, Y, xmc[i], ymc[i], ell, w)\\n B = poly(X[IND], Y[IND], pd)\\n lam = coeff.pop()\\n approx[IND] = B.dot(lam).flatten()\\n \\n return approx, coeff_copy\",\n \"def build_poly(x, degree):\\n \\\"\\\"\\\"\\n Assemble the 3 label vectors with the original ordering \\n Inputs:\\n - x (ndarray) : binary prediction for set 1\\n - degree (int) : binary prediction for set 2 \\n Outputs: \\n - p (ndarray) : predicted labels for test set ( with the original ordering)\\n \\\"\\\"\\\"\\n # forming a matrix containing the data points\\n terms = np.hstack([np.ones([x.shape[0],1]),np.tile(x,(1,degree))])\\n index = np.arange(degree)+1\\n \\n # forming a matrix contnaining the exponents\\n exponents = np.multiply(np.ones((1, x.shape[1])), index[:, np.newaxis])\\n exponents = exponents.reshape([1, x.shape[1]*degree])\\n exponents = np.multiply(exponents, np.ones([x.shape[0], 1]))\\n exponents = np.hstack([np.ones( (x.shape[0], 1) ),exponents])\\n \\n # using the exponent matrix as the element-wise exponents of the terms in the terms matrix\\n p=np.power(terms,exponents)\\n return p\",\n \"def construct_poly(data, power):\\n return np.power(data, power)\",\n \"def non_linear_polynomial_fit(self, seq, factor):\\n B = np.array(seq[1:4])\\n A = np.array([[seq[k], factor ** (k + 1), 1] for k in range(3)])\\n return np.around(np.linalg.solve(A,B), decimals=2)\",\n \"def poly(x, coeffs):\\n return np.sum([coeffs[i] * x ** i for i in range(len(coeffs))], axis=0)\",\n \"def poly_regression_cubic(X, Y, Xs_test, Ys_test):\\n ## YOUR CODE HERE\\n #################\\n return 0\",\n \"def coefficients_from_Weierstrass_polynomial(f):\\n R = f.parent()\\n cubic_variables = [x for x in R.gens() if f.degree(x) == 3]\\n quadratic_variables = [y for y in R.gens() if f.degree(y) == 2]\\n try:\\n x = cubic_variables[0]\\n y = quadratic_variables[0]\\n except IndexError:\\n raise ValueError('polynomial is not in long Weierstrass form')\\n\\n a1 = a2 = a3 = a4 = a6 = 0\\n x3 = y2 = None\\n for coeff, mon in f:\\n if mon == x**3:\\n x3 = coeff\\n elif mon == x**2:\\n a2 = coeff\\n elif mon == x:\\n a4 = coeff\\n elif mon == 1:\\n a6 = coeff\\n elif mon == y**2:\\n y2 = -coeff\\n elif mon == x*y:\\n a1 = -coeff\\n elif mon == y:\\n a3 = -coeff\\n else:\\n raise ValueError('polynomial is not in long Weierstrass form')\\n\\n if x3 != y2:\\n raise ValueError('the coefficient of x^3 and -y^2 must be the same')\\n elif x3 != 1:\\n a1, a2, a3, a4, a6 = a1/x3, a2/x3, a3/x3, a4/x3, a6/x3\\n return [a1, a2, a3, a4, a6]\",\n \"def polyeval(self, x):\\n return NotImplemented\",\n \"def poly_func(x):\\n \\n # Create the polynomial object\\n f = np.poly1d([1, -2, -28, 28, 12, -26, 100])\\n\\n # Return the value of the polynomial\\n return f(x) * 0.05\",\n \"def __getPolynomial(self) -> 'func':\\n return lambda x: sum(self.pts[i]*base(x)\\n for i, base in enumerate(self.basis))\",\n \"def _reform_poly_coefficients(fit_poly_x, fit_poly_y):\\n # Extract values for CD matrix and recombining\\n c11 = fit_poly_x.c1_0.value\\n c12 = fit_poly_x.c0_1.value\\n c21 = fit_poly_y.c1_0.value\\n c22 = fit_poly_y.c0_1.value\\n sip_poly_x = fit_poly_x.copy()\\n sip_poly_y = fit_poly_y.copy()\\n # Force low order coefficients to be 0 as defined in SIP\\n sip_poly_x.c0_0 = 0\\n sip_poly_y.c0_0 = 0\\n sip_poly_x.c1_0 = 0\\n sip_poly_x.c0_1 = 0\\n sip_poly_y.c1_0 = 0\\n sip_poly_y.c0_1 = 0\\n\\n cdmat = ((c11, c12), (c21, c22))\\n invcdmat = npla.inv(np.array(cdmat))\\n degree = fit_poly_x.degree\\n # Now loop through all remaining coefficients\\n for i in range(0, degree + 1):\\n for j in range(0, degree + 1):\\n if (i + j > 1) and (i + j < degree + 1):\\n old_x = getattr(fit_poly_x, f'c{i}_{j}').value\\n old_y = getattr(fit_poly_y, f'c{i}_{j}').value\\n newcoeff = np.dot(invcdmat, np.array([[old_x], [old_y]]))\\n setattr(sip_poly_x, f'c{i}_{j}', newcoeff[0, 0])\\n setattr(sip_poly_y, f'c{i}_{j}', newcoeff[1, 0])\\n\\n return cdmat, sip_poly_x, sip_poly_y\",\n \"def poly_derivative(poly):\\n if not poly or type(poly) is not list:\\n return None\\n\\n response = []\\n\\n for order in range(1, len(poly)):\\n response.append(order * poly[order])\\n\\n if not response:\\n response.append(0)\\n\\n return response\",\n \"def cheb_poly(x, n):\\n if n == 0:\\n return anp.array([1 for i in x])\\n elif n == 1:\\n return x\\n else:\\n return 2*x*cheb_poly(x, n-1)-cheb_poly(x, n-2)\\n\\n raise NotImplementedError(\\\"Problem 6 Incomplete\\\")\",\n \"def __test_s_polynomial():\\n poly_ring = PolynomialRing(QQ, 'x,y', order='deglex')\\n x, y = poly_ring('x'), poly_ring('y')\\n g = x ** 3 - 2 * x * y\\n h = x ** 2 * y - 2 * y ** 2 + x\\n print __s_polynomial(g, h) # Expected -x^2\",\n \"def function_poly(coeffs, t, x, y, lc, coeffs_dict, coeffs_tuple, fix_coeffs, batman_params, poly_params, eclipse = False):\\n new_flux = model_poly(coeffs, t, x, y, coeffs_dict, coeffs_tuple, fix_coeffs, batman_params, poly_params, eclipse = eclipse)\\n return lc - new_flux\",\n \"def polynomial(degree, coeffs):\\n\\n def h(x):\\n result = 0\\n degre=degree\\n for i in range(len(coeffs)):\\n result = result + coeffs[i]*(x**degre)\\n degre = degre - 1\\n return result\\n \\n\\n def h(x):\\n result = 0\\n nonlocal degree\\n for i in range(len(coeffs)):\\n result = result + coeffs[i]*(x**degree)\\n degree = degree - 1\\n return result\\n\\n\\n\\n\\n\\n return h\\n\\n # def h(x):\\n # result = 0\\n # for i in range(degree, -1, -1):\\n # result = result + coeffs[degree - i]*(x**i)\\n \\n # return result\\n \\n\\n\\n # return h\",\n \"def get_poly_coeff(self, independent, dependent):\\n\\n try:\\n x = self.df_input[[independent]]\\n y = self.df_input[[dependent]]\\n\\n poly = PolynomialFeatures(degree = 2)\\n x_poly = poly.fit_transform(x) \\n\\n model = LinearRegression()\\n model.fit(x_poly, y)\\n return model.coef_\\n except Exception as e:\\n print(e)\",\n \"def coefficient(self) -> float:\\n ...\",\n \"def solve(n=5000,C=-6*10**11,a=900,b=3):\\n coeffs = np.zeros(n+2)\\n coeffs[0] = a-b*n\\n coeffs[1] = b*(n+1) - a\\n coeffs[-3] = -C\\n coeffs[-2] = 2*C - a\\n coeffs[-1] = a+b-C\\n mp.dps = 27\\n roots = polyroots(coeffs)\\n for root in roots:\\n print root\",\n \"def polyFunction(x,weights):\\n y=0\\n for i in range (0,len(weights)):\\n y+= weights[i]*(x**i)\\n return y\",\n \"def _evalPoly(self,a,x):\\n y = a[0]\\n for i in range(1,len(a)):\\n y = self.F.Multiply(y, x)\\n y = self.F.Add(y, a[i])\\n return y\",\n \"def polyFeat(X, p):\\r\\n # You need to return the following variables correctly.\\r\\n X_poly = np.zeros((X.shape[0], p))\\r\\n\\r\\n # ====================== YOUR CODE HERE ======================\\r\\n\\r\\n for i in range(p):\\r\\n X_poly[:, i] = X[:, 0] ** (i + 1)\\r\\n\\r\\n # ============================================================\\r\\n return X_poly\",\n \"def phi_poly(self,x,i):\\n return x**i\",\n \"def test():\\n assert str(Polynomial(0, 1, 0, -1, 4, -2, 0, 1, 3, 0)) == \\\"3x^8 + x^7 - 2x^5 + 4x^4 - x^3 + x\\\"\\n assert str(Polynomial([-5, 1, 0, -1, 4, -2, 0, 1, 3, 0])) == \\\"3x^8 + x^7 - 2x^5 + 4x^4 - x^3 + x - 5\\\"\\n assert str(Polynomial(x7=1, x4=4, x8=3, x9=0, x0=0, x5=-2, x3=-1, x1=1)) == \\\"3x^8 + x^7 - 2x^5 + 4x^4 - x^3 + x\\\"\\n assert str(Polynomial(x2=0)) == \\\"0\\\"\\n assert str(Polynomial(x0=0)) == \\\"0\\\"\\n assert Polynomial(x0=2, x1=0, x3=0, x2=3) == Polynomial(2, 0, 3)\\n assert Polynomial(x2=0) == Polynomial(x0=0)\\n assert str(Polynomial(x0=1) + Polynomial(x1=1)) == \\\"x + 1\\\"\\n assert str(Polynomial([-1, 1, 1, 0]) + Polynomial(1, -1, 1)) == \\\"2x^2\\\"\\n pol1 = Polynomial(x2=3, x0=1)\\n pol2 = Polynomial(x1=1, x3=0)\\n assert str(pol1 + pol2) == \\\"3x^2 + x + 1\\\"\\n assert str(pol1 + pol2) == \\\"3x^2 + x + 1\\\"\\n assert str(Polynomial(x0=-1, x1=1) ** 1) == \\\"x - 1\\\"\\n assert str(Polynomial(x0=-1, x1=1) ** 2) == \\\"x^2 - 2x + 1\\\"\\n pol3 = Polynomial(x0=-1, x1=1)\\n assert str(pol3 ** 4) == \\\"x^4 - 4x^3 + 6x^2 - 4x + 1\\\"\\n assert str(pol3 ** 4) == \\\"x^4 - 4x^3 + 6x^2 - 4x + 1\\\"\\n assert str(Polynomial(x0=2).derivative()) == \\\"0\\\"\\n assert str(Polynomial(x3=2, x1=3, x0=2).derivative()) == \\\"6x^2 + 3\\\"\\n assert str(Polynomial(x3=2, x1=3, x0=2).derivative().derivative()) == \\\"12x\\\"\\n pol4 = Polynomial(x3=2, x1=3, x0=2)\\n assert str(pol4.derivative()) == \\\"6x^2 + 3\\\"\\n assert str(pol4.derivative()) == \\\"6x^2 + 3\\\"\\n assert Polynomial(-2, 3, 4, -5).at_value(0) == -2\\n assert Polynomial(x2=3, x0=-1, x1=-2).at_value(3) == 20\\n assert Polynomial(x2=3, x0=-1, x1=-2).at_value(3, 5) == 44\\n pol5 = Polynomial([1, 0, -2])\\n assert pol5.at_value(-2.4) == -10.52\\n assert pol5.at_value(-2.4) == -10.52\\n assert pol5.at_value(-1, 3.6) == -23.92\\n assert pol5.at_value(-1, 3.6) == -23.92\",\n \"def pcoef(\\n xte,yte,rle,\\n x_cre,y_cre,d2ydx2_cre,th_cre,\\n surface):\\n\\n # Initialize coefficients\\n coef = np.zeros(6)\\n\\n # 1st coefficient depends on surface (pressure or suction)\\n if surface.startswith('p'):\\n coef[0] = -sqrt(2*rle)\\n else:\\n coef[0] = sqrt(2*rle)\\n \\n # Form system of equations\\n A = np.array([\\n [xte**1.5, xte**2.5, xte**3.5, xte**4.5, xte**5.5],\\n [x_cre**1.5, x_cre**2.5, x_cre**3.5, x_cre**4.5, \\n x_cre**5.5],\\n [1.5*sqrt(xte), 2.5*xte**1.5, 3.5*xte**2.5, \\n 4.5*xte**3.5, 5.5*xte**4.5],\\n [1.5*sqrt(x_cre), 2.5*x_cre**1.5, 3.5*x_cre**2.5, \\n 4.5*x_cre**3.5, 5.5*x_cre**4.5],\\n [0.75*(1/sqrt(x_cre)), 3.75*sqrt(x_cre), 8.75*x_cre**1.5, \\n 15.75*x_cre**2.5, 24.75*x_cre**3.5]\\n ]) \\n\\n B = np.array([\\n [yte - coef[0]*sqrt(xte)],\\n [y_cre - coef[0]*sqrt(x_cre)],\\n [tan(th_cre*pi/180) - 0.5*coef[0]*(1/sqrt(xte))],\\n [-0.5*coef[0]*(1/sqrt(x_cre))],\\n [d2ydx2_cre + 0.25*coef[0]*x_cre**(-1.5)]\\n ])\\n \\n # Solve system of linear equations\\n try:\\n X = np.linalg.solve(A,B)\\n except:\\n X = np.linalg.solve(A+(1e-12*np.eye(5)),B)\\n\\n\\n # Gather all coefficients\\n coef[1:6] = X[0:5,0]\\n\\n # Return coefficients\\n return coef\",\n \"def zernikePoly(x, y, xOffset, yOffset, coefficients, xMax=-1e22, yMax=-1e22, verbose=False):\\n\\n if len(coefficients) > nMax + 1:\\n raise ValueError('coefficients must have less than {} items.'.format(zernikies.nMax+1))\\n\\n if xMax == -1e22:\\n xMax = np.nanmax(x - xOffset)\\n if yMax == -1e22:\\n yMax = np.nanmax(y - yOffset)\\n\\n xcn = (x - xOffset)/xMax\\n ycn = (y - yOffset)/yMax\\n\\n rcn = np.sqrt(xcn**2. + ycn**2.)\\n ucn = np.arctan2(ycn, xcn)\\n\\n z = zernikePolar(coefficients, rcn, ucn)\\n\\n if verbose:\\n print(\\\"Zernike polynomials with coefficients\\\", coefficients)\\n print(\\\"Their linear combination has mean: {0:.2e}, min: {1:.2e}, max: {2:.2e}\\\".format(np.mean(z), np.nanmin(z), np.nanmax(z)))\\n\\n return z\",\n \"def poly_eq(self, independent, dependent):\\n\\n try:\\n x = self.df_input[[independent]]\\n y = self.df_input[[dependent]]\\n\\n poly = PolynomialFeatures(degree = 2)\\n x_poly = poly.fit_transform(x) \\n\\n model = LinearRegression()\\n model.fit(x_poly, y)\\n coef_arr = model.coef_\\n intercept_arr = model.intercept_\\n \\n poly_equation = \\\"y = \\\" + str(round(coef_arr[0][2], 4)) + \\\"x\\\\xB2\\\"\\n \\n if(coef_arr[0][1] < 0):\\n poly_equation += \\\" + (\\\" + str(round(coef_arr[0][1], 4)) + \\\"x\\\" + \\\")\\\"\\n else:\\n poly_equation += \\\" + \\\" + str(round(coef_arr[0][1], 4)) + \\\"x\\\"\\n \\n if(intercept_arr[0] < 0):\\n poly_equation += \\\" + (\\\" + str(round(intercept_arr[0], 4)) + \\\")\\\"\\n else:\\n poly_equation += \\\" + \\\" + str(round(intercept_arr[0], 4))\\n \\n return poly_equation\\n except Exception as e:\\n print(e)\",\n \"def horner(poly: Sequence[float], x: float) -> float:\\n result = 0.0\\n for coeff in reversed(poly):\\n result = result * x + coeff\\n return result\",\n \"def poly_derivative(poly):\\n if type(poly) is not list or len(poly) < 1:\\n return None\\n if len(poly) == 1:\\n return [0]\\n\\n derivated_coefficients = []\\n\\n for power, coefficient in enumerate(poly):\\n if power == 0:\\n pass\\n\\n else:\\n new_coefficient = coefficient * power\\n derivated_coefficients.append(new_coefficient)\\n\\n return(derivated_coefficients)\",\n \"def coeffients(x, y):\\n\\n # ensure floating point datatypes\\n x.astype(float)\\n y.astype(float)\\n\\n # degree of interpolating polynomial\\n n = len(x)\\n\\n # intitilize list of coeffients for interpolating polynomial to y values\\n c = y.tolist()\\n\\n # compute coeffients\\n for j in range(1, n):\\n for i in range(n-1, j-1, -1):\\n c[i] = float(c[i]-c[i-1])/float(x[i]-x[i-j])\\n\\n # return an array of polynomial coefficient, note: reverse order for np.polyval function\\n return np.array(c[::-1])\",\n \"def evaluate_polynomial(tropical_matrix, coefficient_list):\\n identity_matrix = get_identity_matrix(tropical_matrix.get_dimension())\\n sum_list = []\\n sum_list.append(identity_matrix.mult_scalar(coefficient_list[0]))\\n for i in range(1, len(coefficient_list)):\\n sum_list.append(tropical_matrix.mult_scalar(coefficient_list[i]))\\n return get_minimum_sum(sum_list)\",\n \"def polynomial(a, x):\\n\\n sum = 0\\n\\n for i in range(len(a)):\\n sum += a[i] * x**i\\n return sum\",\n \"def evaluate_poly(poly, x):\\n exp = 0\\n total = 0\\n for coef in poly:\\n total += coef * (x ** exp)\\n exp += 1\\n\\n return total\",\n \"def evaluate_poly(poly: Sequence[float], x: float) -> float:\\n return sum(c * (x**i) for i, c in enumerate(poly))\",\n \"def build_poly(x, degree): \\n # ***************************************************\\n # COPY YOUR CODE FROM EX03 HERE\\n # polynomial basis function: TODO\\n # this function should return the matrix formed\\n # by applying the polynomial basis to the input data\\n # ***************************************************\\n raise NotImplementedError\",\n \"def OF0_TestFunction_SimpleParabolic(x):\\n return x ** 2\",\n \"def Pol_Newton_un_punto(x,datos_x,datos_y):\\n n = datos_x.shape[0]\\n matriz=np.ones([n,n])\\n for j in range(n):\\n for i in range(n):\\n if j>i:\\n matriz[i][j]=0\\n else:\\n producto=1\\n for k in range(j):\\n producto=producto*(datos_x[i]-datos_x[k])\\n matriz[i][j]=producto\\n matriz,datos_y1= pivoteo_parcial(matriz,datos_y)\\n x1 = descompo_LU(matriz,datos_y1)\\n prod=np.zeros(x1.shape[0])\\n for i in range(n):\\n if i==0:\\n prod[i]=1\\n else: \\n prod[i]=prod[i-1]*(x-datos_x[i-1])\\n solucion=x1@prod\\n return solucion\",\n \"def evaluate_poly(poly, x):\\n value_of_poly = 0\\n for i in range(0, len(poly)):\\n var = x\\n power = i\\n coeff = poly[i]\\n value_of_poly += (coeff * (var**power))\\n return value_of_poly\",\n \"def polynomial_equation(funct):\\n coeff = str(differentiation.parse_coefficient(funct))\\n if \\\"^\\\" not in funct:\\n divisor = \\\"1\\\"\\n else:\\n divisor_location = str(funct.index(\\\"^\\\") + 1)\\n divisor = funct[divisor_location:]\\n if divisor == \\\"-1\\\":\\n pass\\n else:\\n divisor = str(int(divisor) + 1)\\n coeff += \\\"/\\\" + divisor\\n return coeff + \\\"x^\\\" + str(divisor)\",\n \"def PBpoly(n, x):\\n n = int(n)\\n return Bpoly(n, x-math.floor(x))\",\n \"def polynomial(x, y):\\n \\n var = copy(x)\\n known = copy(y)\\n V = vandermonde_matrix(var)\\n a = gauss_elimination(V, known)\\n return a\",\n \"def PolyMulRed(multipliees, poly):\\n if poly.degree() < 1:\\n return poly.getRing().zero\\n product = multipliees.pop()\\n for factor in multipliees:\\n #print type(product)\\n #if factor.degree() >= poly.degree():\\n #factor = PolyMod(factor, poly)\\n #if factor == 0:\\n # return 0\\n product = product * factor\\n if product.degree() >= poly.degree():\\n product = PolyMod(product, poly)\\n if not product:\\n break\\n return product\",\n \"def get_polyfit_function(self):\\n N = len(self.coefficients)\\n return lambda x: np.dot( self.get_poly(x).T , self.coefficients.reshape(N, 1) )\",\n \"def get_poly(self, n, xf = 14, y0=[1, 0], first_step = 1e-10, max_step = .1):\\n self.n = n\\n y0s = [1- first_step**2/2, - first_step]\\n sol = integ.solve_ivp(lambda t, y: self.f(t, y, n), (first_step, xf), y0s, max_step=max_step, \\\\\\n vectorized=True, events=self.find_zero)\\n data_sol = np.array([sol.t, sol.y[0], sol.y[1]])\\n data_sol[1, -1] = 1e-18\\n data0 = np.array([0, y0[0], y0[1]]).reshape(3, 1)\\n self.poly = np.concatenate((data0, data_sol), axis=1)\",\n \"def get_expected_polynomial_coefs(y, degree, with_intercept=True):\\n poly_matrix = np.vander(np.arange(len(y)), degree + 1)\\n if not with_intercept:\\n poly_matrix = poly_matrix[:, :-1]\\n return np.linalg.lstsq(poly_matrix, y.to_numpy(), rcond=None)[0]\",\n \"def pol_evl(x, coef, N):\\n ans = coef[0]\\n for i in range(1, N + 1):\\n ans = ans * x + coef[i]\\n return ans\",\n \"def coef_val():\\n\\n basepath = path.join(path.dirname(path.realpath('__file__')), 'data')\\n fdata = basepath + path.sep + 'VAWTPolySurfaceCoef_pub.csv' # published coefficients from paper\\n # fdata = basepath + path.sep + 'VAWTPolySurfaceCoef.csv' # polynomial surface fitting coefficients\\n\\n loc1 = np.zeros(10)\\n loc2 = np.zeros(10)\\n loc3 = np.zeros(10)\\n spr1 = np.zeros(10)\\n spr2 = np.zeros(10)\\n skw1 = np.zeros(10)\\n skw2 = np.zeros(10)\\n scl1 = np.zeros(10)\\n scl2 = np.zeros(10)\\n scl3 = np.zeros(10)\\n\\n f = open(fdata)\\n csv_f = csv.reader(f)\\n\\n i = 0\\n for row in csv_f:\\n if i != 0:\\n loc1[i-1] = float(row[0])\\n loc2[i-1] = float(row[1])\\n loc3[i-1] = float(row[2])\\n spr1[i-1] = float(row[3])\\n spr2[i-1] = float(row[4])\\n skw1[i-1] = float(row[5])\\n skw2[i-1] = float(row[6])\\n scl1[i-1] = float(row[7])\\n scl2[i-1] = float(row[8])\\n scl3[i-1] = float(row[9])\\n i += 1\\n\\n f.close()\\n\\n return loc1,loc2,loc3,spr1,spr2,skw1,skw2,scl1,scl2,scl3\",\n \"def polynomial_value(multipliers, variable):\\n def term(mult, var, order):\\n if order > 1:\\n return mult * variable ** order\\n elif order == 1:\\n return mult * variable\\n elif order == 0:\\n return mult\\n return sum([term(mult, variable, order) for order, mult in enumerate(multipliers)])\",\n \"def easy_eval(self, x):\\n answer = 0\\n for i in range(len(self.coefficients)):\\n coef = self.coefficients[i]\\n degree = len(self.coefficients) - (i+1)\\n answer += x ** degree * coef\\n return answer\",\n \"def coef_approximation(p, order):\\n\\n\\t# maintain parity of order +1\\n\\tn = 50 + order +1\\n\\tr = 1\\n\\txs = np.linspace(-r, r, num=n)\\n\\tys = p(xs)\\n\\n\\t# [TODO]: fix coeffients method\\n\\t# replace with 'c = coeffients(xs, ys)'\\n\\tdegree = n \\n\\tc = np.polyfit(xs,ys,degree)\\n\\n\\treturn c\",\n \"def get_coeff(self):\\n return bernoulli(self.degree+1) / factorial(self.degree + 1)\",\n \"def evaluate_poly(poly, x):\\n if len(poly) == 1:\\n\\t\\t#base case\\n\\t\\treturn poly[0]\\n else:\\n #recursive case\\n #the first item in the tuple is the coefficient of X**0, so it's the final value\\n #the rest of the items in the tuple need multiplied by X and put in new tuple\\n #Yes, I'm cheating and casting a list to a tuple. GFY and your immutability.\\n return poly[0] + evaluate_poly(tuple([x * coeff for coeff in poly[1:]]), x)\",\n \"def zernike_radial_coeffs(l, m, exact=True):\\n l = np.atleast_1d(l).astype(int)\\n m = np.atleast_1d(np.abs(m)).astype(int)\\n lm = np.vstack([l, m]).T\\n # for modest to large arrays, faster to find unique values and\\n # only evaluate those\\n lms, idx = np.unique(lm, return_inverse=True, axis=0)\\n\\n npoly = len(lms)\\n lmax = np.max(lms[:, 0])\\n coeffs = np.zeros((npoly, lmax + 1), dtype=object)\\n lm_even = ((lms[:, 0] - lms[:, 1]) % 2 == 0)[:, np.newaxis]\\n for ii in range(npoly):\\n ll = lms[ii, 0]\\n mm = lms[ii, 1]\\n for s in range(mm, ll + 1, 2):\\n coeffs[ii, s] = (\\n (-1) ** ((ll - s) // 2)\\n * factorial((ll + s) // 2)\\n // (\\n factorial((ll - s) // 2)\\n * factorial((s + mm) // 2)\\n * factorial((s - mm) // 2)\\n )\\n )\\n c = np.fliplr(np.where(lm_even, coeffs, 0))\\n if not exact:\\n try:\\n c = c.astype(int)\\n except OverflowError:\\n c = c.astype(float)\\n c = c[idx]\\n return c\",\n \"def fit_poly(x, y, n=5, log=False):\\n \\n x_g = x\\n x = np.ma.array(x, mask=y.mask).compressed()\\n y = y.compressed()\\n if log:\\n yl = np.log10(y)\\n else:\\n yl = y\\n fit = np.polyfit(x, yl, n)\\n p = np.poly1d(fit)\\n \\n if log:\\n return 10**(p(x_g))\\n else:\\n return p(x_g)\",\n \"def base_polynome(numbers):\\n\\n monomes = [ x**n for n in numbers ]\\n polynome = sum(monomes)\\n\\n return poly(polynome, x)\",\n \"def fit_polynomial_regression(self, x_train, y_train):\\n x_poly = self.poly_reg.fit_transform(x_train)\\n self.lin_reg.fit(x_poly, y_train)\",\n \"def __pow__(self, exp):\\n # We have (p o Q)^e = p^e o Q\\n coeff = (self._unit_simplex_polynomial**exp).coeff\\n if isinstance(exp, numbers.Integral):\\n r = self.degree() * exp\\n else:\\n r = 0\\n for i in range(len(exp)):\\n r += self[i].degree() * exp[i]\\n return PolynomialBernsteinSimplex(coeff, self.vertices, r)\",\n \"def phasepoly14(param, x):\\n # 2011-09-26 10:42 IJMC: Created from phaselamb14\\n N = len(param) - 14\\n cparam = array(param[N::], copy=True)\\n cparam[0] = 1. / prod(1. + cparam[1::]) - 1.\\n\\n if len(x.shape)==1:\\n was1d = True\\n x = x.reshape(14, len(x)/14.)\\n else:\\n was1d = False\\n\\n ret = polyval(param[0:N], x)\\n ret *= (1. + cparam.reshape(14,1))\\n\\n if was1d:\\n ret = ret.ravel()\\n\\n return ret\",\n \"def fit_poly(data, error_func, degree=4): \\n\\n # generate initial guss for polynomial model (all coeffs = 1)\\n guess = np.poly1d(np.ones(degree + 1, dtype=np.float32))\\n\\n # plot intial guess\\n x = np.linspace(-5, 5, 21)\\n plt.plot(x, np.polyval(guess, x), 'm--', linewidth=2.0, label=\\\"Initial guess\\\")\\n\\n # call optimizer to minimize error function\\n result = spo.minimize(error_poly, guess, args=(data,), method='SLSQP', options={'disp':True})\\n \\n # convert optimal result into a poly1d object\\n return np.poly1d(result.x)\",\n \"def claret_linear(mu, coeff):\\n return 1.0 - coeff * (1.0 - mu)\",\n \"def calculate_newton_interpolation(divided_differences):\\n polynomial = []\\n for i, divided_differences_row in enumerate(divided_differences):\\n polynomial_part = '({0})'.format(divided_differences_row[0].divided_difference)\\n\\n for j in range(0, i):\\n polynomial_part += '*(x-{0})'.format(divided_differences[0][j].x)\\n\\n polynomial_part += '+'\\n polynomial.append(polynomial_part)\\n polynomial_str = ''.join(polynomial)[:-1]\\n\\n print('Calculated polynomial: {0}'.format(polynomial_str))\\n # Heuristic simplification of calculated polynomial\\n simplified_polynomial = sy.simplify(polynomial_str)\\n print(\\\"Simplified polynomial: {0}\\\".format(simplified_polynomial))\\n return simplified_polynomial\",\n \"def general_poly(L):\\n def evaluate(x):\\n length=len(L)-1\\n value=0\\n for i in L:\\n value+=i*(x**length)\\n length-=1\\n return value\\n return evaluate\",\n \"def solve_nonlinear(self, params, unknowns, resids):\\n\\n x = params['x']\\n m = self.slope\\n b = self.intercept\\n\\n unknowns['y'] = m*x + b\",\n \"def nc_coeffs(poly, var, max_deg=10, order='increasing'):\\r\\n\\r\\n # TODO: elegant way to find out the degree\\r\\n # workarround: pass the maximum expected degree as kwarg\\r\\n\\r\\n D0 = sp.Dummy('D0')\\r\\n poly = poly.expand() + D0 # ensure class add\\r\\n\\r\\n assert isinstance(poly, sp.Add)\\r\\n res = []\\r\\n # special case: 0-th power of var\\r\\n coeff = 0\\r\\n for a in poly.args:\\r\\n if not a.has(var):\\r\\n coeff += a\\r\\n res.append(coeff.subs(D0, 0))\\r\\n\\r\\n # special case: first power of var\\r\\n coeff = poly.diff(var).subs(var, 0)\\r\\n res.append(coeff)\\r\\n\\r\\n # powers > 1:\\r\\n for i in xrange(1, max_deg):\\r\\n coeff = 0\\r\\n for a in poly.args:\\r\\n if a.has(var**(i + 1)):\\r\\n term = a.subs(var, 1)\\r\\n coeff += term\\r\\n res.append(coeff)\\r\\n\\r\\n if order == \\\"decreasing\\\":\\r\\n res.reverse()\\r\\n\\r\\n return res\",\n \"def F(cst, x):\\n [u0, v0, u1, v1, u2, v2, coeffs] = cst\\n [u, v, g1, g2, g3] = x\\n a = g1*u1 - u0\\n b = g2*u2 - u0\\n c = g3*u - u0\\n l = g1*v1 - v0 \\n m = g2*v2 - v0\\n n = g3*v - v0\\n r = g1 - 1\\n s = g2 - 1\\n t = g3 - 1\\n return np.array([\\n coeffs[0]*(a**2-l**2) + 2*coeffs[1]*(a*b-l*m) + coeffs[2]*(b**2-m**2) + 2*coeffs[3]*(a*c-l*n) + 2*coeffs[4]*(b*c-m*n) + c**2 - n**2,\\n coeffs[0]*(l**2-r**2) + 2*coeffs[1]*(l*m-r*s) + coeffs[2]*(m**2-s**2) + 2*coeffs[3]*(l*n-r*t) + 2*coeffs[4]*(m*n-s*t) + n**2 - t**2,\\n coeffs[0]*a*l + coeffs[1]*(l*b+m*a) + coeffs[2]*m*b + coeffs[3]*(l*c+n*a) + coeffs[4]*(m*c+b*n) + c*n,\\n coeffs[0]*a*r + coeffs[1]*(r*b+s*a) + coeffs[2]*s*b + coeffs[3]*(r*c+t*a) + coeffs[4]*(s*c+b*t) + c*t,\\n coeffs[0]*r*l + coeffs[1]*(l*s+m*r) + coeffs[2]*m*s + coeffs[3]*(l*t+n*r) + coeffs[4]*(m*t+s*n) + t*n \\n ])\",\n \"def printPolyCoeffs(lam) :\\n ell = len(lam)\\n useFormat = \\\"2.6e\\\"\\n count = 0\\n def printLine(s, count) :\\n if lam[count] < 0 :\\n s = s + 3 * \\\" \\\"\\n else :\\n s = s + 4 * \\\" \\\"\\n s = s + \\\"{0:\\\" + useFormat + \\\"}\\\"\\n print(s . format(lam[count]))\\n count = count + 1\\n return count\\n if ell >= 1 :\\n count = printLine(\\\"x0y0\\\", count)\\n if ell >= 3 :\\n count = printLine(\\\"x1y0\\\", count)\\n count = printLine(\\\"x0y1\\\", count)\\n if ell >= 6 :\\n count = printLine(\\\"x2y0\\\", count)\\n count = printLine(\\\"x1y1\\\", count)\\n count = printLine(\\\"x0y2\\\", count)\\n if ell >= 10 :\\n count = printLine(\\\"x3y0\\\", count)\\n count = printLine(\\\"x2y1\\\", count)\\n count = printLine(\\\"x1y2\\\", count)\\n count = printLine(\\\"x0y3\\\", count)\\n if ell >= 15 :\\n count = printLine(\\\"x4y0\\\", count)\\n count = printLine(\\\"x3y1\\\", count)\\n count = printLine(\\\"x2y2\\\", count)\\n count = printLine(\\\"x1y3\\\", count)\\n count = printLine(\\\"x0y4\\\", count)\\n if ell >= 21 :\\n count = printLine(\\\"x5y0\\\", count)\\n count = printLine(\\\"x4y1\\\", count)\\n count = printLine(\\\"x3y2\\\", count)\\n count = printLine(\\\"x2y3\\\", count)\\n count = printLine(\\\"x1y4\\\", count)\\n count = printLine(\\\"x0y5\\\", count)\\n if ell >= 28 :\\n count = printLine(\\\"x6y0\\\", count)\\n count = printLine(\\\"x5y1\\\", count)\\n count = printLine(\\\"x4y2\\\", count)\\n count = printLine(\\\"x3y3\\\", count)\\n count = printLine(\\\"x2y4\\\", count)\\n count = printLine(\\\"x1y5\\\", count)\\n count = printLine(\\\"x0y6\\\", count)\\n if ell >= 36 :\\n count = printLine(\\\"x7y0\\\", count)\\n count = printLine(\\\"x6y1\\\", count)\\n count = printLine(\\\"x5y2\\\", count)\\n count = printLine(\\\"x4y3\\\", count)\\n count = printLine(\\\"x3y4\\\", count)\\n count = printLine(\\\"x2y5\\\", count)\\n count = printLine(\\\"x1y6\\\", count)\\n count = printLine(\\\"x0y7\\\", count)\\n if (ell > 36) or (ell < 1) :\\n raise ValueError(\\\"Polynomial degree less than or equal to 7, please.\\\")\",\n \"def __pow__(self, power):\\n if power == 1:\\n return self\\n elif power == 0:\\n return Polynomial(1)\\n\\n self.polynomials = {key: val for key, val in self.polynomials.items() if val != 0}\\n self.polynomials = dict(sorted(self.polynomials.items(), reverse=True))\\n\\n attributes = {}\\n\\n # Using Binomial theorem\\n n = 0\\n m = power\\n use_n = True\\n\\n for k in range(0, power + 1):\\n result = self.calculate_combinatorial_number(power, k)\\n\\n for index, polynomial in self.polynomials.items():\\n if use_n:\\n result *= pow(polynomial, (power - n))\\n n += 1\\n use_n = False\\n else:\\n result *= pow(polynomial, (power + m))\\n m -= 1\\n use_n = True\\n\\n attributes[\\\"x\\\" + str(n - 1)] = result\\n\\n return Polynomial(**attributes)\",\n \"def conway_polynomial(n=100):\\n \\n xs = []\\n ys = []\\n for i in range(n):\\n x = (i - n/2) / 50\\n xs.append(x)\\n\\n y = x**71 - x**69 - 2*x**68 - x**67 + 2*x**66 + 2*x**65 + x**64 - x**63 - x**62 - x**61 - x**60 - x**59 + 2*x**58 + 5*x**57 + 3*x**56 +\\\\\\n - 2*x**55 - 10*x**54 - 3*x**53 - 2*x**52 + 6*x**51 + 6*x**50 + x**49 + 9*x**48 - 3*x**47 - 7*x**46 - 8*x**45 - 8*x**44 + 10*x**43 +\\\\\\n + 6*x**42 + 8*x**41 - 5*x**40 - 12*x**39 + 7*x**38 - 7*x**37 + 7*x**36 + x**35 - 3*x**34 + 10*x**33 + x**32 - 6*x**31 - 2*x**30 +\\\\\\n - 10*x**29 - 3*x**28 + 2*x**27 + 9*x**26 - 3*x**25 + 14*x**24 - 8*x**23 - 7*x**21 + 9*x**20 + 3*x**19 - 4*x**18 - 10*x**17 - 7*x**16 +\\\\\\n + 12*x**15 + 7*x**14 + 2*x**13 - 12*x**12 - 4*x**11 - 2*x**10 + 5*x**9 + x**7 - 7*x**6 + 7*x**5 - 4*x**4 + 12*x**3 - 6*x**2 + 3*x - 6\\n\\n ys.append(y)\\n\\n return xs, ys\",\n \"def fourth_poly(a, b, c, d, e):\\n return lambda z: a*z**4 + b*z**3 + c*z**2 + d*z + e\",\n \"def general_poly (L):\\n def to_apply (x):\\n n = 0\\n for i in L:\\n n = x*n + i\\n return n\\n return to_apply\",\n \"def _fit_poly(y_data, deg=5):\\n x = np.arange(1, len(y_data) + 1)\\n coeffs = np.polynomial.polynomial.polyfit(\\n x, y_data, deg=deg)\\n y_pred = poly(x, coeffs)\\n return coeffs, np.mean((y_data - y_pred) ** 2)\",\n \"def calc_poly_linear_regression(independent, dependent):\\n # Reshape for sklearn\\n independent = independent.values.reshape(-1,1)\\n dependent = dependent.values.reshape(-1,1)\\n # Make the whole thing poly\\n poly = PolynomialFeatures(degree=2)\\n independent_ = poly.fit_transform(independent)\\n # Do the linear regression\\n model = LinearRegression()\\n model.fit(independent_, dependent)\\n # Calculate R2\\n return model.score(independent_, dependent)\",\n \"def generate_polynomial_features(self, X) :\\n\\n n,d = X.shape\\n\\n ### ========== TODO : START ========== ###\\n # part b: modify to create matrix for simple linear model\\n # part g: modify to create matrix for polynomial model\\n Phi = X\\n m = self.m_\\n\\n if m == 1:\\n Phi = np.zeros((n,2))\\n for i in range(n):\\n Phi[i,0] = 1\\n Phi[i, 1] = X[i]\\n\\n else:\\n Phi = np.ones((n,m+1))#n*m+1 dimmension\\n power_arr = np.arange(0, m+1)\\n for index, row in enumerate(Phi):# get every row\\n row = np.repeat(X[index],m+1)\\n row = np.power(row,power_arr)\\n Phi [index,] = row\\n #also could use the following\\n \\\"\\\"\\\"\\n import sklearn.preprocessing as sk\\n #X is a N*1 vector\\n poly_mat = sk.PolynomialFeatures(3)\\n poly.fit_transform(a)\\n \\\"\\\"\\\"\\n\\n\\n\\n\\n\\n ### ========== TODO : END ========== ###\\n\\n return Phi\",\n \"def add_polynomial_features(x, power):\\n if type(power) is int and type(x) is np.ndarray:\\n return np.concatenate([x**i for i in range(1, power+1)], axis=1)\\n return None\",\n \"def parse_polynomial(s):\\n\\n def parse_n(s):\\n '''Parse the number part of a polynomial string term'''\\n if not s:\\n return 1\\n elif s == '-':\\n return -1\\n elif s == '+':\\n return 1\\n return float(eval(s))\\n\\n def parse_p(s, powerPattern):\\n '''Parse the power part of a polynomial string term'''\\n if not s:\\n return 0\\n multipliers = powerPattern.findall(s)[0]\\n if not multipliers:\\n return 1\\n return int(multipliers)\\n s = str(s).replace(' ', '') # remove all whitespace from string\\n m = re.search('[a-zA-Z]+', s)\\n try:\\n varLetter = m.group(0)\\n except AttributeError:\\n varLetter = 'P'\\n termPattern = re.compile(\\n '([+-]?\\\\d*\\\\.?\\\\d*)\\\\**({var}?\\\\^?\\\\d?)'.format(var=varLetter))\\n powerPattern = re.compile('{var}\\\\^?(\\\\d)?'.format(var=varLetter))\\n order_multipliers = {}\\n\\n for n, p in termPattern.findall(s):\\n n, p = n.strip(), p.strip()\\n if not n and not p:\\n continue\\n n, p = parse_n(n), parse_p(p, powerPattern)\\n if p in order_multipliers:\\n order_multipliers[p] += n\\n else:\\n order_multipliers[p] = n\\n highest_order = max(\\n max(order_multipliers.keys()), 1) # order must be at least linear\\n multipliers = [0] * (highest_order + 1)\\n for key, val in order_multipliers.items():\\n multipliers[key] = val\\n\\n return multipliers\",\n \"def polynomial_incremental_value(multipliers, variable):\\n return sum([(mult * order * variable ** (order - 1) if order > 0 else 0) for order, mult in enumerate(multipliers)])\",\n \"def residuals_PL(self, p, data, x):\\n err = data - self.PowerLaw(x,p)\\n return err\",\n \"def f(self, x, coeffs, jitter = 0):\\n return np.polyval(np.flip(coeffs), x) + random.uniform(-jitter,jitter)\",\n \"def _generate_poly_array(self, nchan, coeff=[]):\\n if nchan < 0:\\n raise ValueError, \\\"nchan should be >=0\\\"\\n if len(coeff)==0:\\n if nchan ==0: return []\\n else: raise ValueError, \\\"No valid coefficient given.\\\"\\n polyarr = numpy.zeros(nchan)\\n for iorder in range(len(coeff)):\\n polyarr += coeff[iorder]*numpy.array(xrange(nchan))**iorder\\n return polyarr\",\n \"def Bpoly(n, x):\\n n = int(n)\\n out = 0\\n for k in xrange(0, n+1):\\n out += comb(n,k)*Bnum(n-k)*x**float(k)\\n return out\",\n \"def solve_nonlinear(self, params, unknowns, resids):\\n\\n x = params['x']\\n z = unknowns['z']\\n znew = z\\n\\n iter = 0\\n eps = 1.0e99\\n while iter < self.maxiter and abs(eps) > self.atol:\\n z = znew\\n znew = 4.0 - x*z\\n\\n eps = x*znew + znew - 4.0\\n\\n unknowns['z'] = znew\\n unknowns['y'] = x + 2.0*znew\\n\\n resids['z'] = eps\\n #print(unknowns['y'], unknowns['z'])\",\n \"def anti_deriv(self):\\n poly_anti_deriv = [0]\\n for i, val in enumerate(self.coeff):\\n poly_anti_deriv.append(round(val/(i+1.0), 2))\\n return Poly(poly_anti_deriv)\",\n \"def preprocess_roots(poly):\\n coeff = S.One\\n\\n poly_func = poly.func\\n try:\\n _, poly = poly.clear_denoms(convert=True)\\n except DomainError:\\n return coeff, poly\\n\\n poly = poly.primitive()[1]\\n poly = poly.retract()\\n\\n # TODO: This is fragile. Figure out how to make this independent of construct_domain().\\n if poly.get_domain().is_Poly and all(c.is_term for c in poly.rep.coeffs()):\\n poly = poly.inject()\\n\\n strips = list(zip(*poly.monoms()))\\n gens = list(poly.gens[1:])\\n\\n base, strips = strips[0], strips[1:]\\n\\n for gen, strip in zip(list(gens), strips):\\n reverse = False\\n\\n if strip[0] < strip[-1]:\\n strip = reversed(strip)\\n reverse = True\\n\\n ratio = None\\n\\n for a, b in zip(base, strip):\\n if not a and not b:\\n continue\\n elif not a or not b:\\n break\\n elif b % a != 0:\\n break\\n else:\\n _ratio = b // a\\n\\n if ratio is None:\\n ratio = _ratio\\n elif ratio != _ratio:\\n break\\n else:\\n if reverse:\\n ratio = -ratio\\n\\n poly = poly.eval(gen, 1)\\n coeff *= gen**(-ratio)\\n gens.remove(gen)\\n\\n if gens:\\n poly = poly.eject(*gens)\\n\\n if poly.is_univariate and poly.get_domain().is_ZZ:\\n basis = _integer_basis(poly)\\n\\n if basis is not None:\\n n = poly.degree()\\n\\n def func(k, coeff):\\n return coeff//basis**(n - k[0])\\n\\n poly = poly.termwise(func)\\n coeff *= basis\\n\\n if not isinstance(poly, poly_func):\\n poly = poly_func(poly)\\n return coeff, poly\",\n \"def find_coefficients(self):\\n self.make_matrix()\\n self.coeffs = np.linalg.solve(self.global_matrix,self.global_vector)\\n self.coeffs = np.append(self.coeffs, self.D) #Initial condition\",\n \"def calculate(self, x):\\n result = 0\\n\\n for index, polynomial in self.polynomials.items():\\n result += polynomial * pow(x, int(index))\\n\\n return result\",\n \"def test_solver():\\n # Choice of nonlinear coefficient\\n m = 2\\n\\n def q(u):\\n return (1+u)**m\\n\\n def Dq(u):\\n return m*(1+u)**(m-1)\\n\\n u_exact = Expression(\\n 'pow((pow(2, m+1)-1)*x[0] + 1, 1.0/(m+1)) - 1', m=m)\\n linear_solver = 'direct'\\n errors = []\\n for method in 'alg_Newton', 'pde_Newton':\\n for J_comp in 'manual', 'automatic':\\n for degree in 1, 2, 3:\\n error_prev = -1\\n for divisions in [(10, 10), (20, 20), (40, 40)]:\\n u = solver(\\n q, Dq, f, divisions, degree,\\n method, J_comp,\\n linear_solver,\\n abs_tol_Krylov=1E-10,\\n rel_tol_Krylov=1E-10,\\n abs_tol_Newton=1E-10,\\n rel_tol_Newton=1E-10)\\n\\n # Find max error\\n u_e = interpolate(u_exact, u.function_space())\\n import numpy as np\\n error = np.abs(u_e.vector().array() -\\n u.vector().array()).max()\\n # Expect convergence as h**(degree+1)\\n if error_prev > 0:\\n frac = abs(error - error_prev/2**(degree+1))\\n errors.append(frac)\\n error_prev = error\\n tol = 4E-5\\n for error_reduction in errors:\\n assert error_reduction < tol, error_reduction\",\n \"def general_poly (L):\\r\\n\\r\\n def secondFunc(x):\\r\\n total = 0\\r\\n listLength = len(L)-1\\r\\n for i in L:\\r\\n total += i * x**listLength\\r\\n listLength -= 1\\r\\n return(total)\\r\\n return secondFunc\",\n \"def test_degree(poly_equation):\\n equation = poly_equation\\n A = 1e10\\n degree = np.log(equation.flux(A)/equation.flux(1))/np.log(A)\\n npt.assert_allclose(equation.degree(), degree)\",\n \"def generate_random_tropical_poly(max_degree, min_coefficient, max_coefficient):\\n coefficients = []\\n for d in range(0, random.randint(1, max_degree) + 1):\\n coefficients.append(random.randint(min_coefficient, max_coefficient))\\n return coefficients\",\n \"def recf_legendre_poly(basetensor, ind, x):\\n n = ind.getN()\\n return (2.*n-1.)/n*basetensor[ind.all+ind.getSpecial()] \\\\\\n * basetensor[ind.all + ind.getPreceding(1)] \\\\\\n - (n-1.)/n*basetensor[ind.all + ind.getPreceding(2)]\",\n \"def solve_nonlinear(self, params, unknowns, resids):\\n\\n x = params['x']\\n a = self.a\\n b = self.b\\n c = self.c\\n\\n unknowns['y'] = a*x**2 + b*x + c\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66424847","0.65410674","0.65383047","0.6523504","0.6429001","0.63814205","0.6350041","0.6323735","0.62960255","0.6285092","0.6248639","0.6246817","0.6244223","0.6241529","0.62292457","0.6215943","0.6210995","0.6187557","0.61658406","0.6146332","0.6113267","0.6103433","0.6068119","0.60674936","0.6066396","0.605589","0.6040634","0.6022955","0.6019536","0.6017634","0.60170925","0.60099417","0.6008562","0.6004356","0.6002057","0.5999026","0.59858364","0.59806097","0.5965904","0.59551984","0.5953868","0.5952779","0.5942527","0.59394085","0.5938268","0.592401","0.5923904","0.59206545","0.5917993","0.5899233","0.588797","0.5881874","0.5873178","0.58729696","0.58526987","0.581408","0.58104694","0.58074856","0.5805333","0.58052653","0.5804119","0.5793579","0.5793084","0.5790095","0.57823116","0.577373","0.5771387","0.57693416","0.57622075","0.5754499","0.57493365","0.5743262","0.5740477","0.5739031","0.5738382","0.57339686","0.5728102","0.5726477","0.5725293","0.5715803","0.5712717","0.5711757","0.5708736","0.57002974","0.56894517","0.5688396","0.5684308","0.5677302","0.56752574","0.56748134","0.56678265","0.566702","0.5661745","0.56613034","0.56612605","0.5660878","0.5645979","0.5640869","0.5639999","0.5639696"],"string":"[\n \"0.66424847\",\n \"0.65410674\",\n \"0.65383047\",\n \"0.6523504\",\n \"0.6429001\",\n \"0.63814205\",\n \"0.6350041\",\n \"0.6323735\",\n \"0.62960255\",\n \"0.6285092\",\n \"0.6248639\",\n \"0.6246817\",\n \"0.6244223\",\n \"0.6241529\",\n \"0.62292457\",\n \"0.6215943\",\n \"0.6210995\",\n \"0.6187557\",\n \"0.61658406\",\n \"0.6146332\",\n \"0.6113267\",\n \"0.6103433\",\n \"0.6068119\",\n \"0.60674936\",\n \"0.6066396\",\n \"0.605589\",\n \"0.6040634\",\n \"0.6022955\",\n \"0.6019536\",\n \"0.6017634\",\n \"0.60170925\",\n \"0.60099417\",\n \"0.6008562\",\n \"0.6004356\",\n \"0.6002057\",\n \"0.5999026\",\n \"0.59858364\",\n \"0.59806097\",\n \"0.5965904\",\n \"0.59551984\",\n \"0.5953868\",\n \"0.5952779\",\n \"0.5942527\",\n \"0.59394085\",\n \"0.5938268\",\n \"0.592401\",\n \"0.5923904\",\n \"0.59206545\",\n \"0.5917993\",\n \"0.5899233\",\n \"0.588797\",\n \"0.5881874\",\n \"0.5873178\",\n \"0.58729696\",\n \"0.58526987\",\n \"0.581408\",\n \"0.58104694\",\n \"0.58074856\",\n \"0.5805333\",\n \"0.58052653\",\n \"0.5804119\",\n \"0.5793579\",\n \"0.5793084\",\n \"0.5790095\",\n \"0.57823116\",\n \"0.577373\",\n \"0.5771387\",\n \"0.57693416\",\n \"0.57622075\",\n \"0.5754499\",\n \"0.57493365\",\n \"0.5743262\",\n \"0.5740477\",\n \"0.5739031\",\n \"0.5738382\",\n \"0.57339686\",\n \"0.5728102\",\n \"0.5726477\",\n \"0.5725293\",\n \"0.5715803\",\n \"0.5712717\",\n \"0.5711757\",\n \"0.5708736\",\n \"0.57002974\",\n \"0.56894517\",\n \"0.5688396\",\n \"0.5684308\",\n \"0.5677302\",\n \"0.56752574\",\n \"0.56748134\",\n \"0.56678265\",\n \"0.566702\",\n \"0.5661745\",\n \"0.56613034\",\n \"0.56612605\",\n \"0.5660878\",\n \"0.5645979\",\n \"0.5640869\",\n \"0.5639999\",\n \"0.5639696\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.59670556"},"document_rank":{"kind":"string","value":"38"}}},{"rowIdx":21974,"cells":{"query":{"kind":"string","value":"hash file 'filename', return a sha1 object"},"document":{"kind":"string","value":"def hash_file ( filename ):\n sha1 = hashlib.sha1()\n with open( filename, 'rb' ) as f:\n while True:\n buf = f.read(65536) # read by 64kb buffers size\n if not buf:\n break\n sha1.update(buf)\n return sha1"},"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 hash_file(filename):\r\n\r\n # make a hash object\r\n h = hashlib.sha1()\r\n\r\n # open file for reading in binary mode\r\n with open(filename,'rb') as file:\r\n\r\n # loop till the end of the file\r\n chunk = 0\r\n while chunk != b'':\r\n # read only 1024 bytes at a time\r\n chunk = file.read(1024)\r\n h.update(chunk)\r\n\r\n # return the hex representation of digest\r\n return h.hexdigest()","def hash_file(filename):\n # make a hash object\n h = hashlib.sha1()\n \n # open file for reading in binary mode\n with open(filename,'rb') as file:\n # loop till the end of the file\n chunk = 0\n while chunk != b'':\n # read only 1024 bytes at a time\n chunk = file.read(1024)\n h.update(chunk)\n # return the hex representation of digest\n return h.hexdigest()","def hash_file(filename):\n # make a hash object\n h = hashlib.sha1()\n \n # open file for reading in binary mode\n with open(filename,'rb') as file:\n # loop till the end of the file\n chunk = 0\n while chunk != b'':\n # read only 1024 bytes at a time\n chunk = file.read(1024)\n h.update(chunk)\n # return the hex representation of digest\n return h.hexdigest()","def hash_file(filename):\n\n # make a hash object\n h = hashlib.sha1()\n\n # open file for reading in binary mode\n with open(filename, 'rb') as file:\n # loop till the end of the file\n chunk = 0\n while chunk != b'':\n # read only 1024 bytes at a time\n chunk = file.read(1024)\n h.update(chunk)\n\n # return the hex representation of digest\n return h.hexdigest()","def hash_file(filename):\n # make a hash object\n h = hashlib.sha1()\n # open file for reading in binary mode\n with open(filename,'rb') as file:\n # loop till the end of the file\n chunk = 0\n while chunk != b'':\n # read only 1024 bytes at a time\n chunk = file.read(1024)\n h.update(chunk)\n # return the hex representation of digest\n return h.hexdigest()","def hashfile(filename):\n BLOCKSIZE = 65536\n sha1 = hashlib.sha1()\n with open(filename, 'rb') as afile:\n buf = afile.read(BLOCKSIZE)\n while len(buf) > 0:\n sha1.update(buf)\n buf = afile.read(BLOCKSIZE)\n return(sha1.hexdigest())","def sha1HashFile(self, filename: Path):\n bufferSize = 65536\n sha1Hash = hashlib.sha1()\n\n with filename.open('rb') as f:\n while True:\n data = f.read(bufferSize)\n\n if not data:\n break\n\n sha1Hash.update(data)\n\n return str(sha1Hash.hexdigest())","def calchash(filename):\n sha = hashlib.sha1()\n with open(filename, 'rb') as f:\n sha.update(f.read())\n return sha","def hash_file(file_name):\n BLOCKSIZE = 65536\n hasher = hashlib.sha1()\n with open(file_name, 'rb') as afile:\n buf = afile.read(BLOCKSIZE)\n while len(buf) > 0:\n hasher.update(buf)\n buf = afile.read(BLOCKSIZE)\n return(hasher.hexdigest())","def hash_file_sha1(file_path, binary=False, buffer_size=65536):\n return hash_file(file_path, hash_type=hashlib.sha1, binary=binary, buffer_size=buffer_size)","def sha_hash(file_name: str):\n BLOCKSIZE = 65536\n line = '' # format one line for hash\n with open(file_name, 'rb') as afile:\n buf = afile.read(BLOCKSIZE) # read each line of doc\n while len(buf) > 0:\n line += buf.decode('utf-8')\n buf = afile.read(BLOCKSIZE)\n\n hex = \"0x\" + sha1(line.encode()) # create sha1 hash\n return int(hex, 0)","def hash_file(filename):\n\n # make a hash object\n h = hashlib.sha256()\n\n # open file for reading in binary mode\n with open(filename,'rb') as file:\n\n # loop till the end of the file\n chunk = 0\n while chunk != b'':\n # read only 1024 bytes at a time\n chunk = file.read(1024)\n h.update(chunk)\n\n # return the hex representation of digest\n return h.hexdigest()","def compute_hash(fileName):\n m = hashlib.sha1()\n try:\n fd = open(fileName,\"rb\")\n except IOError:\n print (\"Unable to open the file in readmode:\", fileName)\n return\n content = fd.readlines()\n fd.close()\n for eachLine in content:\n m.update(eachLine)\n return m.hexdigest()","def hash_file(filepath):\n digest = hashlib.sha1()\n with open(filepath, 'rb') as f:\n while True:\n chunk = f.read(1024*1024)\n if not chunk:\n break\n digest.update(chunk)\n return digest.hexdigest()","def hash(path):\n\n with open(path, 'r') as file:\n return hashlib.sha1(file.read()).hexdigest()","def computeHash(infile):\n f = open(infile, 'rb')\n buffer = f.read()\n f.close()\n return hashlib.sha1(buffer).hexdigest()","def sha1(fname):\n fh = open(fname, 'rb')\n sha1 = hashlib.sha1()\n block = fh.read(2 ** 16)\n while len(block) > 0:\n sha1.update(block)\n block = fh.read(2 ** 16)\n\n return sha1.hexdigest()","def get_hash(file_buffer):\n data = file_buffer.read()\n hasher = sha1()\n hasher.update(data)\n return hasher.hexdigest()","def hashFile(path: str) -> str:\n\tif not os.path.exists(path):\n\t\traise FileNotFoundError\n\n\thasher = hashlib.sha1()\n\tblock_sz = 8192\n\twith open(path, 'rb') as f:\n\t\tbuf = f.read(block_sz)\n\t\twhile len(buf) > 0:\n\t\t\thasher.update(buf)\n\t\t\tbuf = f.read(block_sz)\n\treturn str(hasher.hexdigest())","def GetFileSha1(file_path):\n return base64.b64encode(GetFileHashes(file_path, do_sha1=True)['sha1'])","def sha1sum(filename):\n if not os.path.isfile(filename):\n return ''\n hasher = hashlib.sha1()\n with open(filename, 'rb') as hash_file:\n buf = hash_file.read(HASH_BLOCK_SIZE)\n while len(buf) > 0:\n hasher.update(buf)\n buf = hash_file.read(HASH_BLOCK_SIZE)\n return hasher.hexdigest()","def hashfile(file):\n\n hasher = hashlib.sha256()\n\n with open(file, 'rb') as afile:\n buf = afile.read(BLOCKSIZE)\n hasher.update(buf)\n\n return(hasher.hexdigest())","def _calc_sha1(path):\n calc = hashlib.sha1()\n with open(path, 'r') as f:\n calc.update(f.read())\n return calc.hexdigest()","def file_sha1(file_name, ignore_format=False, max_call_times=None):\r\n _FILE_SLIM = 65536 # read stuff in 64kb chunks!\r\n call_times = 0\r\n my_sha1 = hashlib.sha1()\r\n with open(file_name, \"rb\") as ob:\r\n while True:\r\n data = ob.read(_FILE_SLIM)\r\n if not data:\r\n break\r\n if ignore_format:\r\n data = data.decode(encoding=\"utf-8\")\r\n data = data.replace(\"\\r\", '')\r\n data = data.replace(\"\\n\", '')\r\n data = data.encode(encoding=\"utf-8\")\r\n if max_call_times:\r\n call_times += 1\r\n if call_times > max_call_times:\r\n break\r\n my_sha1.update(data)\r\n return my_sha1.hexdigest()","def _get_sha_metadata(filename):\n with open(filename) as f:\n return hashlib.sha1(f.read()).hexdigest()","def hash_from_file(file_path):\r\n return hash_from_code(open(file_path, 'rb').read())","def computeHash(filename):\n fileHash = hashlib.sha256()\n with open(filename, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n fileHash.update(chunk)\n return fileHash.hexdigest()","def get_file_hash(fname, hash_length):\n hash_sha = hashlib.sha256()\n with open(fname, 'rb') as infile:\n for chunk in iter(lambda: infile.read(4096), b''):\n hash_sha.update(chunk)\n hash_sha = hash_sha.hexdigest()\n hash_sha = int(hash_sha, 16) % (2 ** (4 * hash_length))\n return hex_encode(hash_sha, hash_length)","def hash_of_file(path):\n with open(path, 'rb') as archive:\n sha = sha256()\n while True:\n data = archive.read(2 ** 20)\n if not data:\n break\n sha.update(data)\n return encoded_hash(sha)","def file_hash(filepath: Path):\n hsh = hashlib.sha256()\n b = bytearray(128 * 1024)\n mv = memoryview(b)\n with Path(filepath).open(\"rb\", buffering=0) as f:\n for n in iter(lambda: f.readinto(mv), 0):\n hsh.update(mv[:n])\n return hsh.hexdigest()","def hash_file(file_to_hash):\n print(\"Hashing \" + file_to_hash + \"...\")\n hash_algorithm = hashlib.sha256()\n file = open(file_to_hash, 'rb')\n while True:\n contents = file.read(65536)\n if not contents:\n break\n hash_algorithm.update(contents)\n hash_str = hash_algorithm.hexdigest()\n return hash_str","def get_sha256_file(filename):\n BLOCKSIZE = 65536\n hasher = hashlib.sha256()\n with open(filename, 'rb') as afile:\n buf = afile.read(BLOCKSIZE)\n while len(buf) > 0:\n hasher.update(buf)\n buf = afile.read(BLOCKSIZE)\n return hasher.hexdigest()","def calculate_hash(filename, raise_on_not_found = False):\n if not is_file(filename) and not raise_on_not_found:\n return \"NOTFOUND\"\n\n with open(filename, \"rb\") as file:\n sha256 = hashlib.sha256()\n buf = file.read(128)\n while len(buf) > 0:\n sha256.update(buf)\n buf = file.read(128)\n return str(binascii.hexlify(sha256.digest()), \"utf8\")","def sha1sum(filename):\n with open(filename, mode='rb') as f:\n d = hashlib.sha1()\n for buf in iter(functools.partial(f.read, 1024*100), b''):\n d.update(buf)\n return d.hexdigest()","def hashFile(filename):\n\tblocks = []\n\twith open(filename, 'rb') as f:\n\t\tblock = f.read(1024)\n\t\twhile block:\n\t\t\tblocks.append(block)\n\t\t\tblock = f.read(1024)\n\t\n\tprevHash = b''\n\tfor block in reversed(blocks):\n\t\thash = sha256(block + prevHash)\n\t\tprevHash = hash\n\treturn prevHash","def hash_for_file(file_name, block_size=2 ** 20):\n hasher = SHA256.new()\n source_file = open(file_name, \"r\")\n\n while True:\n data = source_file.read(block_size)\n if not data:\n break\n hasher.update(data.encode('utf-8'))\n\n source_file.close()\n return hasher.hexdigest()","def calc_file_hash(filepath):\n with open(filepath, 'rb') as f:\n return md5(f.read()).hexdigest()","def hash_file(path, digest=None):\r\n digest = digest or hashlib.sha1()\r\n with open(path, 'rb') as fd:\r\n s = fd.read(8192)\r\n while s:\r\n digest.update(s)\r\n s = fd.read(8192)\r\n return digest.hexdigest()","def get_file_hash(file_path):\n with open(file_path, 'rb') as f:\n file_name = os.path.basename(file_path)\n to_hash = f.read() + file_name.encode('utf-8')\n new_hash = hashlib.md5(to_hash).hexdigest()\n return new_hash","def FNV1Hash(filename):\n \n FNV1_32_INIT = 0x811c9dc5\n FNV1_PRIME_32 = 16777619\n\n lowerName = filename.lower()\n \n _hash = FNV1_32_INIT\n uint32_max = 2 ** 32\n \n for c in lowerName:\n _hash = (_hash * FNV1_PRIME_32) % uint32_max\n _hash = _hash ^ ord(c)\n return format(_hash, 'x')","def hash_file(path: str) -> str:\n return _hash_file(path, hashlib.md5()).hexdigest()","def compute_file_hash(filename: str, sha: str = 'sha1', bytes_to_read=None):\n size = os.path.getsize(filename)\n if bytes_to_read is None:\n bytes_to_read = size\n else:\n bytes_to_read = min(bytes_to_read, size)\n step = 1 << 20\n\n shas = ['md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512']\n assert sha in shas\n sha = getattr(hashlib, sha)() # sha instance\n\n with open(filename, 'rb') as f:\n while bytes_to_read > 0:\n read_bytes = f.read(min(bytes_to_read, step))\n assert read_bytes # make sure we actually read bytes\n bytes_to_read -= len(read_bytes)\n sha.update(read_bytes)\n return sha.hexdigest()","def _hash_file_content(self, path):\n hasher = hashlib.sha1()\n with open(path, 'rb') as file:\n buffer = file.read(self.hash_block_size)\n while len(buffer) > 0:\n hasher.update(buffer)\n buffer = file.read(self.hash_block_size)\n return hasher.hexdigest()","def get_hash(self, filepath):\n if (os.path.isfile(filepath) and not (\n os.path.islink(filepath) and self.ignorelinks)):\n file_hash = self.hashfile(open(filepath, 'rb'))\n else:\n file_hash = self.hashstring(filepath)\n if not self._increment_hash:\n self._increment_hash = file_hash\n else:\n self._increment_hash = self.hashstring(\n self._increment_hash + file_hash)\n return file_hash","def checksumFile(filename):\n return md5File(filename)","def semhash(file):\n _hash_helper(file)","def semhash(file):\n _hash_helper(file)","def _HashFilename(filename):\n if isinstance(filename, unicode):\n filename = filename.encode(UTF8)\n else:\n filename = unicode(filename, UTF8).encode(UTF8)\n m = hashlib.sha1(filename)\n return 'TRACKER_' + m.hexdigest() + '.' + filename[-16:]","def hash_file_at_path(file_path, algorithm=\"sha1\"):\n block_size = 64 * 1024\n hasher = getattr(hashlib, algorithm)()\n with open(file_path, \"rb\") as file_handler:\n while True:\n data = file_handler.read(block_size)\n if not data:\n break\n hasher.update(data)\n return hasher.hexdigest()","def _get_sha1(file_descriptor):\n sha1 = hashlib.sha1()\n for block in iter(partial(file_descriptor.read, BLOCK_SIZE), ''):\n sha1.update(block)\n file_descriptor.seek(0)\n return sha1.hexdigest()","def gdsii_hash(filename, engine=None):\n with open(filename, 'rb') as fin:\n data = fin.read()\n contents = []\n start = pos = 0\n while pos < len(data):\n size, rec = struct.unpack('>HH', data[pos:pos + 4])\n if rec == 0x0502:\n start = pos + 28\n elif rec == 0x0700:\n contents.append(data[start:pos])\n pos += size\n h = hashlib.sha1() if engine is None else engine\n for x in sorted(contents):\n h.update(x)\n return h.hexdigest()","def get_file_sha(full_path):\n in_file = open(full_path, 'rb')\n try:\n # Bug: why doesn't this use sha_func?\n sha_value = sha1()\n while True:\n bytes = in_file.read(READ_CHUNK_LEN)\n if bytes == \"\":\n break\n sha_value.update(bytes)\n return sha_value.digest()\n finally:\n in_file.close()","def getHashFile(file):\n try:\n fileContent = open(file, 'rb').read()\n except:\n raise IOError, \"No such file...\"\n return False\n return getHash(fileContent)","def get_file_hash (fullpath) : \n\n # This bit was sourced from Stack Overflow via Google, specifically:\n # http://stackoverflow.com/questions/1131220/get-md5-hash-of-a-files-without-open-it-in-python\n\n md5 = hashlib.md5()\n with open(fullpath,'rb') as f: \n for chunk in iter(lambda: f.read(512*md5.block_size), ''): \n md5.update(chunk)\n # Hexdigest is the safe varchar(32) style output\n return md5.hexdigest()","def hash_file(method, path):\n f = open(path, \"rb\")\n h = method()\n while True:\n buf = f.read(BUFSIZE)\n if not buf:\n break\n h.update(buf)\n return h.hexdigest()","def hashfile(self, afile):\n # encode_buffer = False\n\n buf = afile.read(self.blocksize)\n while buf:\n # Need to use string-escape for Python 2 non-unicode strings. For\n # Python 2 unicode strings and all Python 3 strings, we need to use\n # unicode-escape. The effect of them is the same.\n if isinstance(buf, str):\n buf = buf.encode('unicode-escape')\n\n self.hasher.update(buf)\n buf = afile.read(self.blocksize)\n return self.hasher.hexdigest()","def hashfile(fname, blocksize=65536):\n hasher = hashlib.md5()\n afile = open(fname, 'rb')\n buf = afile.read(blocksize)\n while len(buf) > 0:\n hasher.update(buf)\n buf = afile.read(blocksize)\n return hasher.hexdigest()","def hash_file(file_path, hash_type=hashlib.sha256, binary=False, buffer_size=65536):\n hash_func = hash_type()\n with open(file_path, \"rb\") as file:\n while True:\n data = file.read(buffer_size)\n if not data:\n break\n hash_func.update(data)\n return hash_func.digest() if binary else hash_func.hexdigest()","def gdsii_hash(filename, engine=None):\n if hasattr(filename, \"__fspath__\"):\n filename = filename.__fspath__()\n with open(filename, \"rb\") as fin:\n data = fin.read()\n contents = []\n start = pos = 0\n while pos < len(data):\n size, rec = struct.unpack(\">HH\", data[pos : pos + 4])\n if rec == 0x0502:\n start = pos + 28\n elif rec == 0x0700:\n contents.append(data[start:pos])\n elif size == 0:\n warnings.warn(\n \"[GDSPY] Zero-length record found in {0} at position {1}. \"\n \"Skipping the remaining of the file contents.\".format(filename, pos),\n stacklevel=2,\n )\n break\n pos += size\n h = hashlib.sha1() if engine is None else engine\n for x in sorted(contents):\n h.update(x)\n return h.hexdigest()","def file_hash(file_to_hash: Path) -> str:\n sha256_hash = hashlib.sha256()\n with file_to_hash.open(\"rb\") as f:\n for block in iter(lambda: f.read(4096), b\"\"):\n sha256_hash.update(block)\n return sha256_hash.hexdigest()","def quick_hash_file(fname,bs=M):\n size = os.path.getsize(fname)\n if size < 3*bs:\n return hash_file(fname,bs)\n h = hashlib.md5()\n with open(fname,'rb') as f:\n h.update(f.read(bs))\n f.seek(size//2,0)\n h.update(f.read(bs))\n f.seek(-bs,2)\n h.update(f.read(bs))\n return h.digest()","def static_file_hash(filepath):\n hasher = hashlib.md5() # nosec: B303\n\n with contextlib.closing(open(filepath, 'rb')) as file:\n hasher.update(file.read())\n return hasher.hexdigest()","def get_file_sha256(fname):\n with open(fname, 'rb') as afile:\n return base64.b64encode(get_file_hash(afile, hashlib.sha256()))","def hash_file(fname):\n hash_md5 = hashlib.md5()\n with open(fname, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def hash_file(self, file_path, file_arcname):\n\n file_path = os.path.abspath(file_path)\n\n # If the file_arcname argument is None use the base file name as the\n # arc name\n if file_arcname is None:\n file_arcname = os.path.basename(file_path)\n\n if not os.path.exists(file_path):\n task_error(\"%s doesn't exist\" % file_path)\n if not os.access(file_path, os.R_OK):\n task_error(\"Can't read from %s\" % file_path)\n\n file_mode = os.stat(file_path)[stat.ST_MODE]\n if not stat.S_ISDIR(file_mode) and not stat.S_ISREG(file_mode):\n task_error(\"Unknown file type for %s\" % file_path)\n\n file_in = None\n try:\n # open to read binary. This is important.\n file_in = open(file_path, 'rb')\n except IOError:\n task_error(\"Couldn't read from file: %s\" % file_path)\n\n # hash file 1Mb at a time\n hashval = hashlib.sha1()\n while True:\n data = file_in.read(1024 * 1024)\n if not data:\n break\n hashval.update(data)\n\n # update file bundle status\n\n self.running_size += len(data)\n\n self.percent_complete = 100.0 * self.running_size / self.bundle_size\n\n # only update significant progress\n if self.percent_complete - self.last_percent > 1:\n self.report_percent_complete()\n self.last_percent = self.percent_complete\n\n file_hash = hashval.hexdigest()\n\n # print 'hash: ' + file_hash\n file_in.close()\n\n modified_name = os.path.join('data', file_arcname)\n (file_dir, file_name) = os.path.split(modified_name)\n\n # linuxfy the directory\n file_dir = file_dir.replace('\\\\', '/')\n\n info = {}\n info['size'] = os.path.getsize(file_path)\n mime_type = mimetypes.guess_type(file_path, strict=True)[0]\n\n info['mimetype'] = mime_type if mime_type is not None else 'application/octet-stream'\n info['name'] = file_name\n info['mtime'] = DT.datetime.utcfromtimestamp(int(os.path.getmtime(file_path))).isoformat()\n info['ctime'] = DT.datetime.utcfromtimestamp(int(os.path.getctime(file_path))).isoformat()\n info['destinationTable'] = 'Files'\n info['subdir'] = file_dir\n info['hashsum'] = file_hash\n info['hashtype'] = 'sha1'\n\n # todo make sure errors bubble up without crashing\n if file_arcname in self.file_meta:\n print file_arcname\n task_error(\n \"Different file with the same arcname is already in the bundle\")\n return\n\n return info","def hash_file(file_like_object):\n checksum = hashlib.sha1()\n for chunk in iter(lambda: file_like_object.read(32768), b''):\n encoded_chunk = (chunk.encode(encoding='utf-8')\n if isinstance(chunk, six.string_types) else chunk)\n checksum.update(encoded_chunk)\n return checksum.hexdigest()","def hash_file(fname,bs=M):\n h = hashlib.md5()\n with open(fname,'rb') as f:\n chunk = f.read(bs)\n while chunk:\n h.update(chunk)\n chunk = f.read(bs)\n return h.digest()","def hash(cls, path, digest=None, hasher=sha1):\r\n if digest is None:\r\n digest = hasher()\r\n with open(path, 'rb') as fh:\r\n cls.update_hash(fh, digest)\r\n return digest.hexdigest()","def sha1sum(filename, blocksize=65536):\n hash = hashlib.sha1()\n with open(filename, \"rb\") as f:\n for block in iter(lambda: f.read(blocksize), b\"\"):\n hash.update(block)\n return hash.hexdigest()","def sha256sum(filename):\n if not os.path.isfile(filename):\n return ''\n hasher = hashlib.sha256()\n with open(filename, 'rb') as hash_file:\n buf = hash_file.read(HASH_BLOCK_SIZE)\n while len(buf) > 0:\n hasher.update(buf)\n buf = hash_file.read(HASH_BLOCK_SIZE)\n return hasher.hexdigest()","def _hash_file(fpath, algorithm='sha256', chunk_size=65535):\n if (algorithm == 'sha256') or (algorithm == 'auto' and len(hash) == 64):\n hasher = hashlib.sha256()\n else:\n hasher = hashlib.md5()\n\n with open(fpath, 'rb') as fpath_file:\n for chunk in iter(lambda: fpath_file.read(chunk_size), b''):\n hasher.update(chunk)\n\n return hasher.hexdigest()","def file_digest(file):\n # 'rb' file mode reads the file as bytes\n input_file = open(file, 'rb')\n data = input_file.read()\n # getting the digest\n digest = hash_comparing(data).hexdigest()\n input_file.close()\n return digest","def fast_hash(infile):\n\n m = hashlib.sha256()\n with open(infile, 'rb', 1024 * 1024) as f:\n l = f.read(1024 * 1024)\n while (len(l) > 0):\n m.update(l)\n f.seek(1024 * 1024 * (512 - 1), 1)\n l = f.read(1024 * 1024)\n return m.hexdigest()","def hash_file_sha256(file_path, binary=False, buffer_size=65536):\n return hash_file(file_path, hash_type=hashlib.sha256, binary=binary, buffer_size=buffer_size)","def get_file_hash(afile, hasher, block_size=65536):\n buf = afile.read(block_size)\n while len(buf) > 0:\n hasher.update(buf)\n buf = afile.read(block_size)\n return hasher.digest()","def hash_file(path):\n if not os.path.isfile(path):\n raise ValueError(\"The given path `{}` is not a file.\".format(path))\n\n md5 = hashlib.md5()\n\n with open(path, 'rb') as file_:\n while True:\n data = file_.read(65536)\n if not data:\n break\n md5.update(data)\n\n return \"{}\".format(md5.hexdigest())","def get_hash(file_url):\n file_extension = os.path.splitext(file_url)[1]\n return str(HASHES.get(file_extension))","def hash_file_native(file_path, tool=\"sha256sum\"):\n output = subprocess.check_output([tool, file_path], shell=False)\n return output.decode(\"utf-8\").partition(\" \")[0].strip()","def sha512_file(file_name):\n\n hash_func = hashlib.sha256()\n\n with open(file_name, \"rb\") as fd:\n hash_func.update(fd.read())\n\n return hash_func.hexdigest()","def _get_hash(self, path):\n with open(path, \"r\") as fp:\n content = fp.read()\n\n return sha256(content).hexdigest()","def get_hash_from_file(img):\n with open(img, 'rb') as f:\n return hashlib.sha256(f.read()).hexdigest()","def _hash_file(fpath, algorithm='sha256', chunk_size=65535):\n if (algorithm is 'sha256') or (algorithm is 'auto' and len(hash) is 64):\n hasher = hashlib.sha256()\n else:\n hasher = hashlib.md5()\n\n with open(fpath, 'rb') as fpath_file:\n for chunk in iter(lambda: fpath_file.read(chunk_size), b''):\n hasher.update(chunk)\n\n return hasher.hexdigest()","def sha256sum(filename):\n content = open(filename, 'rb').read()\n sha256_obj = hashlib.sha256(content)\n return sha256_obj.hexdigest()","def _get_file_sha256_hash(file_path):\n sha256hash = hashlib.sha256()\n chunk_size = 8192\n with open(file_path, \"rb\") as f:\n while True:\n buffer = f.read(chunk_size)\n if not buffer:\n break\n sha256hash.update(buffer)\n return sha256hash.hexdigest()","def check_sha1(filename, sha1_hash):\n sha1 = hashlib.sha1()\n with open(filename, 'rb') as f:\n while True:\n data = f.read(1048576)\n if not data:\n break\n sha1.update(data)\n\n sha1_file = sha1.hexdigest()\n l = min(len(sha1_file), len(sha1_hash))\n return sha1.hexdigest()[0:l] == sha1_hash[0:l]","def hash_file(hash_obj, path):\n with open(path, 'rb') as f:\n while True:\n b = f.read(8192)\n if not b:\n break\n hash_obj.update(b)\n return hash_obj","def sigfile(fpath):\n sigsha = hashlib.sha1()\n fbj = open(fpath, 'rb')\n try:\n sigsha.update(fbj.read()) # pylint: disable-msg=E1101\n finally:\n fbj.close()\n return sigsha.hexdigest()","def hash_file_in_zip(zip_handler, file_path_in_zip, algorithm=\"sha1\"):\n block_size = 64 * 1024\n hasher = getattr(hashlib, algorithm)()\n with zip_handler.open(file_path_in_zip, \"r\") as file_handler:\n while True:\n data = file_handler.read(block_size)\n if not data:\n break\n hasher.update(data)\n return hasher.hexdigest()","def hash(self):\n block = 1024 * 1024 * 4 # 4 MB.\n hasher = hashlib.sha256()\n\n with open(self.path, \"rb\") as f:\n while True:\n chunk = f.read(block)\n if not chunk:\n break\n hasher.update(hashlib.sha256(chunk).digest())\n\n digest = hasher.hexdigest()\n pdbox.debug(\"Hash for %s: %s\" % (self.path, digest))\n return digest","def get_sha1_from_stream(src: io.IOBase) -> str:\n if not isinstance(src, io.IOBase) or not src.readable():\n raise Exception(\"src is not stream or unreadable\")\n m: hashlib._hashlib.HASH = hashlib.sha1()\n return calc_hash(src, m)","def hash_file(self, filename_or_bytestream):\n\n try:\n for data in self._read_blocks(filename_or_bytestream):\n self._update(data)\n except OSError as e:\n print('digest: ', filename_or_bytestream, ': ', e.strerror, sep='', file=sys.stderr)\n return None\n return self._hexdigests()","def hashfile(file: str, block_size: int = 65536) -> str:\n with open(file, 'rb') as message:\n m = hashlib.sha256()\n block = message.read(block_size)\n while len(block) > 0:\n m.update(block)\n block = message.read(block_size)\n digest = m.hexdigest()\n\n return digest","def hash_file(file_path):\n\n \n\n def generator(f):\n while True:\n x = f.read(CHUNK_SIZE)\n if x:\n yield x\n else:\n return \n\n with open(file_path, 'rb') as f:\n a = generator(f)\n num_cores = min(multiprocessing.cpu_count(), MAX_CORES)\n hashes = Parallel(n_jobs=num_cores)(delayed(md4_hash)(i) for i in a)\n if len(hashes) == 1:\n return hashes[0].hex()\n else:\n return md4_hash(b\"\".join(hashes)).hex()","def _hash_file(fpath, algorithm='sha256', chunk_size=65535):\n if isinstance(algorithm, str):\n hasher = _resolve_hasher(algorithm)\n else:\n hasher = algorithm\n\n with open(fpath, 'rb') as fpath_file:\n for chunk in iter(lambda: fpath_file.read(chunk_size), b''):\n hasher.update(chunk)\n\n return hasher.hexdigest()","def get_hash(content):\n return hashlib.sha1(content).hexdigest()","def cksum(filename):\n hash, err = Popen([\"cksum\", filename], stdout=PIPE, stderr=PIPE).communicate()\n if err != '':\n raise Exception(\"Error hashing {filename}\".format(**locals()))\n return hash.split(\" \")[0]","def hash_file2(fpath, blocksize=65536, hasher='xx64'):\n import xxhash\n if hasher == 'xx32':\n hasher = xxhash.xxh32()\n elif hasher == 'xx64':\n hasher = xxhash.xxh64()\n\n with open(fpath, 'rb') as file:\n buf = file.read(blocksize)\n # otherwise hash the entire file\n while len(buf) > 0:\n hasher.update(buf)\n buf = file.read(blocksize)\n # Get the hashed representation\n text = ub.util_hash._digest_hasher(hasher, hashlen=None,\n base=ub.util_hash.DEFAULT_ALPHABET)\n return text","def hashing(file,pp):\n\n def myhash(instring):\n # sdbm hash\n res = 0\n for t in instring:\n res = (ord(t) + (res<<6) + (res<<16) - res) % 2**32\n return res\n\n return hex(myhash(file.replace('\\\\','/')+\":\"+pp))","def _hash_file(file: Union[str, Path], md5: Hash) -> Hash:\n if isinstance(file, str) and file.lower().startswith(\"file://\"):\n file = unquote(urlparse(file).path)\n if not Path(file).is_file():\n raise ValueError(str(file) + \" is not a valid file\")\n with open(file, \"rb\") as f:\n while True:\n data = f.read(BUF_SIZE)\n if not data:\n break\n md5.update(data)\n return md5","def hash_key(hashfunc=hashlib.md5):\n\n def _(_file):\n try:\n with open(_file.path, 'rb') as fd:\n _h = hashfunc()\n for chunk in read_chunks(fd, chunk_size=1024*1024*10):\n _h.update(chunk)\n return _h.digest()\n except (OSError, PermissionError):\n logger.warning(\n f\"Skipping File (Could Not Open To Read): {_file.path}\")\n\n return _"],"string":"[\n \"def hash_file(filename):\\r\\n\\r\\n # make a hash object\\r\\n h = hashlib.sha1()\\r\\n\\r\\n # open file for reading in binary mode\\r\\n with open(filename,'rb') as file:\\r\\n\\r\\n # loop till the end of the file\\r\\n chunk = 0\\r\\n while chunk != b'':\\r\\n # read only 1024 bytes at a time\\r\\n chunk = file.read(1024)\\r\\n h.update(chunk)\\r\\n\\r\\n # return the hex representation of digest\\r\\n return h.hexdigest()\",\n \"def hash_file(filename):\\n # make a hash object\\n h = hashlib.sha1()\\n \\n # open file for reading in binary mode\\n with open(filename,'rb') as file:\\n # loop till the end of the file\\n chunk = 0\\n while chunk != b'':\\n # read only 1024 bytes at a time\\n chunk = file.read(1024)\\n h.update(chunk)\\n # return the hex representation of digest\\n return h.hexdigest()\",\n \"def hash_file(filename):\\n # make a hash object\\n h = hashlib.sha1()\\n \\n # open file for reading in binary mode\\n with open(filename,'rb') as file:\\n # loop till the end of the file\\n chunk = 0\\n while chunk != b'':\\n # read only 1024 bytes at a time\\n chunk = file.read(1024)\\n h.update(chunk)\\n # return the hex representation of digest\\n return h.hexdigest()\",\n \"def hash_file(filename):\\n\\n # make a hash object\\n h = hashlib.sha1()\\n\\n # open file for reading in binary mode\\n with open(filename, 'rb') as file:\\n # loop till the end of the file\\n chunk = 0\\n while chunk != b'':\\n # read only 1024 bytes at a time\\n chunk = file.read(1024)\\n h.update(chunk)\\n\\n # return the hex representation of digest\\n return h.hexdigest()\",\n \"def hash_file(filename):\\n # make a hash object\\n h = hashlib.sha1()\\n # open file for reading in binary mode\\n with open(filename,'rb') as file:\\n # loop till the end of the file\\n chunk = 0\\n while chunk != b'':\\n # read only 1024 bytes at a time\\n chunk = file.read(1024)\\n h.update(chunk)\\n # return the hex representation of digest\\n return h.hexdigest()\",\n \"def hashfile(filename):\\n BLOCKSIZE = 65536\\n sha1 = hashlib.sha1()\\n with open(filename, 'rb') as afile:\\n buf = afile.read(BLOCKSIZE)\\n while len(buf) > 0:\\n sha1.update(buf)\\n buf = afile.read(BLOCKSIZE)\\n return(sha1.hexdigest())\",\n \"def sha1HashFile(self, filename: Path):\\n bufferSize = 65536\\n sha1Hash = hashlib.sha1()\\n\\n with filename.open('rb') as f:\\n while True:\\n data = f.read(bufferSize)\\n\\n if not data:\\n break\\n\\n sha1Hash.update(data)\\n\\n return str(sha1Hash.hexdigest())\",\n \"def calchash(filename):\\n sha = hashlib.sha1()\\n with open(filename, 'rb') as f:\\n sha.update(f.read())\\n return sha\",\n \"def hash_file(file_name):\\n BLOCKSIZE = 65536\\n hasher = hashlib.sha1()\\n with open(file_name, 'rb') as afile:\\n buf = afile.read(BLOCKSIZE)\\n while len(buf) > 0:\\n hasher.update(buf)\\n buf = afile.read(BLOCKSIZE)\\n return(hasher.hexdigest())\",\n \"def hash_file_sha1(file_path, binary=False, buffer_size=65536):\\n return hash_file(file_path, hash_type=hashlib.sha1, binary=binary, buffer_size=buffer_size)\",\n \"def sha_hash(file_name: str):\\n BLOCKSIZE = 65536\\n line = '' # format one line for hash\\n with open(file_name, 'rb') as afile:\\n buf = afile.read(BLOCKSIZE) # read each line of doc\\n while len(buf) > 0:\\n line += buf.decode('utf-8')\\n buf = afile.read(BLOCKSIZE)\\n\\n hex = \\\"0x\\\" + sha1(line.encode()) # create sha1 hash\\n return int(hex, 0)\",\n \"def hash_file(filename):\\n\\n # make a hash object\\n h = hashlib.sha256()\\n\\n # open file for reading in binary mode\\n with open(filename,'rb') as file:\\n\\n # loop till the end of the file\\n chunk = 0\\n while chunk != b'':\\n # read only 1024 bytes at a time\\n chunk = file.read(1024)\\n h.update(chunk)\\n\\n # return the hex representation of digest\\n return h.hexdigest()\",\n \"def compute_hash(fileName):\\n m = hashlib.sha1()\\n try:\\n fd = open(fileName,\\\"rb\\\")\\n except IOError:\\n print (\\\"Unable to open the file in readmode:\\\", fileName)\\n return\\n content = fd.readlines()\\n fd.close()\\n for eachLine in content:\\n m.update(eachLine)\\n return m.hexdigest()\",\n \"def hash_file(filepath):\\n digest = hashlib.sha1()\\n with open(filepath, 'rb') as f:\\n while True:\\n chunk = f.read(1024*1024)\\n if not chunk:\\n break\\n digest.update(chunk)\\n return digest.hexdigest()\",\n \"def hash(path):\\n\\n with open(path, 'r') as file:\\n return hashlib.sha1(file.read()).hexdigest()\",\n \"def computeHash(infile):\\n f = open(infile, 'rb')\\n buffer = f.read()\\n f.close()\\n return hashlib.sha1(buffer).hexdigest()\",\n \"def sha1(fname):\\n fh = open(fname, 'rb')\\n sha1 = hashlib.sha1()\\n block = fh.read(2 ** 16)\\n while len(block) > 0:\\n sha1.update(block)\\n block = fh.read(2 ** 16)\\n\\n return sha1.hexdigest()\",\n \"def get_hash(file_buffer):\\n data = file_buffer.read()\\n hasher = sha1()\\n hasher.update(data)\\n return hasher.hexdigest()\",\n \"def hashFile(path: str) -> str:\\n\\tif not os.path.exists(path):\\n\\t\\traise FileNotFoundError\\n\\n\\thasher = hashlib.sha1()\\n\\tblock_sz = 8192\\n\\twith open(path, 'rb') as f:\\n\\t\\tbuf = f.read(block_sz)\\n\\t\\twhile len(buf) > 0:\\n\\t\\t\\thasher.update(buf)\\n\\t\\t\\tbuf = f.read(block_sz)\\n\\treturn str(hasher.hexdigest())\",\n \"def GetFileSha1(file_path):\\n return base64.b64encode(GetFileHashes(file_path, do_sha1=True)['sha1'])\",\n \"def sha1sum(filename):\\n if not os.path.isfile(filename):\\n return ''\\n hasher = hashlib.sha1()\\n with open(filename, 'rb') as hash_file:\\n buf = hash_file.read(HASH_BLOCK_SIZE)\\n while len(buf) > 0:\\n hasher.update(buf)\\n buf = hash_file.read(HASH_BLOCK_SIZE)\\n return hasher.hexdigest()\",\n \"def hashfile(file):\\n\\n hasher = hashlib.sha256()\\n\\n with open(file, 'rb') as afile:\\n buf = afile.read(BLOCKSIZE)\\n hasher.update(buf)\\n\\n return(hasher.hexdigest())\",\n \"def _calc_sha1(path):\\n calc = hashlib.sha1()\\n with open(path, 'r') as f:\\n calc.update(f.read())\\n return calc.hexdigest()\",\n \"def file_sha1(file_name, ignore_format=False, max_call_times=None):\\r\\n _FILE_SLIM = 65536 # read stuff in 64kb chunks!\\r\\n call_times = 0\\r\\n my_sha1 = hashlib.sha1()\\r\\n with open(file_name, \\\"rb\\\") as ob:\\r\\n while True:\\r\\n data = ob.read(_FILE_SLIM)\\r\\n if not data:\\r\\n break\\r\\n if ignore_format:\\r\\n data = data.decode(encoding=\\\"utf-8\\\")\\r\\n data = data.replace(\\\"\\\\r\\\", '')\\r\\n data = data.replace(\\\"\\\\n\\\", '')\\r\\n data = data.encode(encoding=\\\"utf-8\\\")\\r\\n if max_call_times:\\r\\n call_times += 1\\r\\n if call_times > max_call_times:\\r\\n break\\r\\n my_sha1.update(data)\\r\\n return my_sha1.hexdigest()\",\n \"def _get_sha_metadata(filename):\\n with open(filename) as f:\\n return hashlib.sha1(f.read()).hexdigest()\",\n \"def hash_from_file(file_path):\\r\\n return hash_from_code(open(file_path, 'rb').read())\",\n \"def computeHash(filename):\\n fileHash = hashlib.sha256()\\n with open(filename, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n fileHash.update(chunk)\\n return fileHash.hexdigest()\",\n \"def get_file_hash(fname, hash_length):\\n hash_sha = hashlib.sha256()\\n with open(fname, 'rb') as infile:\\n for chunk in iter(lambda: infile.read(4096), b''):\\n hash_sha.update(chunk)\\n hash_sha = hash_sha.hexdigest()\\n hash_sha = int(hash_sha, 16) % (2 ** (4 * hash_length))\\n return hex_encode(hash_sha, hash_length)\",\n \"def hash_of_file(path):\\n with open(path, 'rb') as archive:\\n sha = sha256()\\n while True:\\n data = archive.read(2 ** 20)\\n if not data:\\n break\\n sha.update(data)\\n return encoded_hash(sha)\",\n \"def file_hash(filepath: Path):\\n hsh = hashlib.sha256()\\n b = bytearray(128 * 1024)\\n mv = memoryview(b)\\n with Path(filepath).open(\\\"rb\\\", buffering=0) as f:\\n for n in iter(lambda: f.readinto(mv), 0):\\n hsh.update(mv[:n])\\n return hsh.hexdigest()\",\n \"def hash_file(file_to_hash):\\n print(\\\"Hashing \\\" + file_to_hash + \\\"...\\\")\\n hash_algorithm = hashlib.sha256()\\n file = open(file_to_hash, 'rb')\\n while True:\\n contents = file.read(65536)\\n if not contents:\\n break\\n hash_algorithm.update(contents)\\n hash_str = hash_algorithm.hexdigest()\\n return hash_str\",\n \"def get_sha256_file(filename):\\n BLOCKSIZE = 65536\\n hasher = hashlib.sha256()\\n with open(filename, 'rb') as afile:\\n buf = afile.read(BLOCKSIZE)\\n while len(buf) > 0:\\n hasher.update(buf)\\n buf = afile.read(BLOCKSIZE)\\n return hasher.hexdigest()\",\n \"def calculate_hash(filename, raise_on_not_found = False):\\n if not is_file(filename) and not raise_on_not_found:\\n return \\\"NOTFOUND\\\"\\n\\n with open(filename, \\\"rb\\\") as file:\\n sha256 = hashlib.sha256()\\n buf = file.read(128)\\n while len(buf) > 0:\\n sha256.update(buf)\\n buf = file.read(128)\\n return str(binascii.hexlify(sha256.digest()), \\\"utf8\\\")\",\n \"def sha1sum(filename):\\n with open(filename, mode='rb') as f:\\n d = hashlib.sha1()\\n for buf in iter(functools.partial(f.read, 1024*100), b''):\\n d.update(buf)\\n return d.hexdigest()\",\n \"def hashFile(filename):\\n\\tblocks = []\\n\\twith open(filename, 'rb') as f:\\n\\t\\tblock = f.read(1024)\\n\\t\\twhile block:\\n\\t\\t\\tblocks.append(block)\\n\\t\\t\\tblock = f.read(1024)\\n\\t\\n\\tprevHash = b''\\n\\tfor block in reversed(blocks):\\n\\t\\thash = sha256(block + prevHash)\\n\\t\\tprevHash = hash\\n\\treturn prevHash\",\n \"def hash_for_file(file_name, block_size=2 ** 20):\\n hasher = SHA256.new()\\n source_file = open(file_name, \\\"r\\\")\\n\\n while True:\\n data = source_file.read(block_size)\\n if not data:\\n break\\n hasher.update(data.encode('utf-8'))\\n\\n source_file.close()\\n return hasher.hexdigest()\",\n \"def calc_file_hash(filepath):\\n with open(filepath, 'rb') as f:\\n return md5(f.read()).hexdigest()\",\n \"def hash_file(path, digest=None):\\r\\n digest = digest or hashlib.sha1()\\r\\n with open(path, 'rb') as fd:\\r\\n s = fd.read(8192)\\r\\n while s:\\r\\n digest.update(s)\\r\\n s = fd.read(8192)\\r\\n return digest.hexdigest()\",\n \"def get_file_hash(file_path):\\n with open(file_path, 'rb') as f:\\n file_name = os.path.basename(file_path)\\n to_hash = f.read() + file_name.encode('utf-8')\\n new_hash = hashlib.md5(to_hash).hexdigest()\\n return new_hash\",\n \"def FNV1Hash(filename):\\n \\n FNV1_32_INIT = 0x811c9dc5\\n FNV1_PRIME_32 = 16777619\\n\\n lowerName = filename.lower()\\n \\n _hash = FNV1_32_INIT\\n uint32_max = 2 ** 32\\n \\n for c in lowerName:\\n _hash = (_hash * FNV1_PRIME_32) % uint32_max\\n _hash = _hash ^ ord(c)\\n return format(_hash, 'x')\",\n \"def hash_file(path: str) -> str:\\n return _hash_file(path, hashlib.md5()).hexdigest()\",\n \"def compute_file_hash(filename: str, sha: str = 'sha1', bytes_to_read=None):\\n size = os.path.getsize(filename)\\n if bytes_to_read is None:\\n bytes_to_read = size\\n else:\\n bytes_to_read = min(bytes_to_read, size)\\n step = 1 << 20\\n\\n shas = ['md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512']\\n assert sha in shas\\n sha = getattr(hashlib, sha)() # sha instance\\n\\n with open(filename, 'rb') as f:\\n while bytes_to_read > 0:\\n read_bytes = f.read(min(bytes_to_read, step))\\n assert read_bytes # make sure we actually read bytes\\n bytes_to_read -= len(read_bytes)\\n sha.update(read_bytes)\\n return sha.hexdigest()\",\n \"def _hash_file_content(self, path):\\n hasher = hashlib.sha1()\\n with open(path, 'rb') as file:\\n buffer = file.read(self.hash_block_size)\\n while len(buffer) > 0:\\n hasher.update(buffer)\\n buffer = file.read(self.hash_block_size)\\n return hasher.hexdigest()\",\n \"def get_hash(self, filepath):\\n if (os.path.isfile(filepath) and not (\\n os.path.islink(filepath) and self.ignorelinks)):\\n file_hash = self.hashfile(open(filepath, 'rb'))\\n else:\\n file_hash = self.hashstring(filepath)\\n if not self._increment_hash:\\n self._increment_hash = file_hash\\n else:\\n self._increment_hash = self.hashstring(\\n self._increment_hash + file_hash)\\n return file_hash\",\n \"def checksumFile(filename):\\n return md5File(filename)\",\n \"def semhash(file):\\n _hash_helper(file)\",\n \"def semhash(file):\\n _hash_helper(file)\",\n \"def _HashFilename(filename):\\n if isinstance(filename, unicode):\\n filename = filename.encode(UTF8)\\n else:\\n filename = unicode(filename, UTF8).encode(UTF8)\\n m = hashlib.sha1(filename)\\n return 'TRACKER_' + m.hexdigest() + '.' + filename[-16:]\",\n \"def hash_file_at_path(file_path, algorithm=\\\"sha1\\\"):\\n block_size = 64 * 1024\\n hasher = getattr(hashlib, algorithm)()\\n with open(file_path, \\\"rb\\\") as file_handler:\\n while True:\\n data = file_handler.read(block_size)\\n if not data:\\n break\\n hasher.update(data)\\n return hasher.hexdigest()\",\n \"def _get_sha1(file_descriptor):\\n sha1 = hashlib.sha1()\\n for block in iter(partial(file_descriptor.read, BLOCK_SIZE), ''):\\n sha1.update(block)\\n file_descriptor.seek(0)\\n return sha1.hexdigest()\",\n \"def gdsii_hash(filename, engine=None):\\n with open(filename, 'rb') as fin:\\n data = fin.read()\\n contents = []\\n start = pos = 0\\n while pos < len(data):\\n size, rec = struct.unpack('>HH', data[pos:pos + 4])\\n if rec == 0x0502:\\n start = pos + 28\\n elif rec == 0x0700:\\n contents.append(data[start:pos])\\n pos += size\\n h = hashlib.sha1() if engine is None else engine\\n for x in sorted(contents):\\n h.update(x)\\n return h.hexdigest()\",\n \"def get_file_sha(full_path):\\n in_file = open(full_path, 'rb')\\n try:\\n # Bug: why doesn't this use sha_func?\\n sha_value = sha1()\\n while True:\\n bytes = in_file.read(READ_CHUNK_LEN)\\n if bytes == \\\"\\\":\\n break\\n sha_value.update(bytes)\\n return sha_value.digest()\\n finally:\\n in_file.close()\",\n \"def getHashFile(file):\\n try:\\n fileContent = open(file, 'rb').read()\\n except:\\n raise IOError, \\\"No such file...\\\"\\n return False\\n return getHash(fileContent)\",\n \"def get_file_hash (fullpath) : \\n\\n # This bit was sourced from Stack Overflow via Google, specifically:\\n # http://stackoverflow.com/questions/1131220/get-md5-hash-of-a-files-without-open-it-in-python\\n\\n md5 = hashlib.md5()\\n with open(fullpath,'rb') as f: \\n for chunk in iter(lambda: f.read(512*md5.block_size), ''): \\n md5.update(chunk)\\n # Hexdigest is the safe varchar(32) style output\\n return md5.hexdigest()\",\n \"def hash_file(method, path):\\n f = open(path, \\\"rb\\\")\\n h = method()\\n while True:\\n buf = f.read(BUFSIZE)\\n if not buf:\\n break\\n h.update(buf)\\n return h.hexdigest()\",\n \"def hashfile(self, afile):\\n # encode_buffer = False\\n\\n buf = afile.read(self.blocksize)\\n while buf:\\n # Need to use string-escape for Python 2 non-unicode strings. For\\n # Python 2 unicode strings and all Python 3 strings, we need to use\\n # unicode-escape. The effect of them is the same.\\n if isinstance(buf, str):\\n buf = buf.encode('unicode-escape')\\n\\n self.hasher.update(buf)\\n buf = afile.read(self.blocksize)\\n return self.hasher.hexdigest()\",\n \"def hashfile(fname, blocksize=65536):\\n hasher = hashlib.md5()\\n afile = open(fname, 'rb')\\n buf = afile.read(blocksize)\\n while len(buf) > 0:\\n hasher.update(buf)\\n buf = afile.read(blocksize)\\n return hasher.hexdigest()\",\n \"def hash_file(file_path, hash_type=hashlib.sha256, binary=False, buffer_size=65536):\\n hash_func = hash_type()\\n with open(file_path, \\\"rb\\\") as file:\\n while True:\\n data = file.read(buffer_size)\\n if not data:\\n break\\n hash_func.update(data)\\n return hash_func.digest() if binary else hash_func.hexdigest()\",\n \"def gdsii_hash(filename, engine=None):\\n if hasattr(filename, \\\"__fspath__\\\"):\\n filename = filename.__fspath__()\\n with open(filename, \\\"rb\\\") as fin:\\n data = fin.read()\\n contents = []\\n start = pos = 0\\n while pos < len(data):\\n size, rec = struct.unpack(\\\">HH\\\", data[pos : pos + 4])\\n if rec == 0x0502:\\n start = pos + 28\\n elif rec == 0x0700:\\n contents.append(data[start:pos])\\n elif size == 0:\\n warnings.warn(\\n \\\"[GDSPY] Zero-length record found in {0} at position {1}. \\\"\\n \\\"Skipping the remaining of the file contents.\\\".format(filename, pos),\\n stacklevel=2,\\n )\\n break\\n pos += size\\n h = hashlib.sha1() if engine is None else engine\\n for x in sorted(contents):\\n h.update(x)\\n return h.hexdigest()\",\n \"def file_hash(file_to_hash: Path) -> str:\\n sha256_hash = hashlib.sha256()\\n with file_to_hash.open(\\\"rb\\\") as f:\\n for block in iter(lambda: f.read(4096), b\\\"\\\"):\\n sha256_hash.update(block)\\n return sha256_hash.hexdigest()\",\n \"def quick_hash_file(fname,bs=M):\\n size = os.path.getsize(fname)\\n if size < 3*bs:\\n return hash_file(fname,bs)\\n h = hashlib.md5()\\n with open(fname,'rb') as f:\\n h.update(f.read(bs))\\n f.seek(size//2,0)\\n h.update(f.read(bs))\\n f.seek(-bs,2)\\n h.update(f.read(bs))\\n return h.digest()\",\n \"def static_file_hash(filepath):\\n hasher = hashlib.md5() # nosec: B303\\n\\n with contextlib.closing(open(filepath, 'rb')) as file:\\n hasher.update(file.read())\\n return hasher.hexdigest()\",\n \"def get_file_sha256(fname):\\n with open(fname, 'rb') as afile:\\n return base64.b64encode(get_file_hash(afile, hashlib.sha256()))\",\n \"def hash_file(fname):\\n hash_md5 = hashlib.md5()\\n with open(fname, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def hash_file(self, file_path, file_arcname):\\n\\n file_path = os.path.abspath(file_path)\\n\\n # If the file_arcname argument is None use the base file name as the\\n # arc name\\n if file_arcname is None:\\n file_arcname = os.path.basename(file_path)\\n\\n if not os.path.exists(file_path):\\n task_error(\\\"%s doesn't exist\\\" % file_path)\\n if not os.access(file_path, os.R_OK):\\n task_error(\\\"Can't read from %s\\\" % file_path)\\n\\n file_mode = os.stat(file_path)[stat.ST_MODE]\\n if not stat.S_ISDIR(file_mode) and not stat.S_ISREG(file_mode):\\n task_error(\\\"Unknown file type for %s\\\" % file_path)\\n\\n file_in = None\\n try:\\n # open to read binary. This is important.\\n file_in = open(file_path, 'rb')\\n except IOError:\\n task_error(\\\"Couldn't read from file: %s\\\" % file_path)\\n\\n # hash file 1Mb at a time\\n hashval = hashlib.sha1()\\n while True:\\n data = file_in.read(1024 * 1024)\\n if not data:\\n break\\n hashval.update(data)\\n\\n # update file bundle status\\n\\n self.running_size += len(data)\\n\\n self.percent_complete = 100.0 * self.running_size / self.bundle_size\\n\\n # only update significant progress\\n if self.percent_complete - self.last_percent > 1:\\n self.report_percent_complete()\\n self.last_percent = self.percent_complete\\n\\n file_hash = hashval.hexdigest()\\n\\n # print 'hash: ' + file_hash\\n file_in.close()\\n\\n modified_name = os.path.join('data', file_arcname)\\n (file_dir, file_name) = os.path.split(modified_name)\\n\\n # linuxfy the directory\\n file_dir = file_dir.replace('\\\\\\\\', '/')\\n\\n info = {}\\n info['size'] = os.path.getsize(file_path)\\n mime_type = mimetypes.guess_type(file_path, strict=True)[0]\\n\\n info['mimetype'] = mime_type if mime_type is not None else 'application/octet-stream'\\n info['name'] = file_name\\n info['mtime'] = DT.datetime.utcfromtimestamp(int(os.path.getmtime(file_path))).isoformat()\\n info['ctime'] = DT.datetime.utcfromtimestamp(int(os.path.getctime(file_path))).isoformat()\\n info['destinationTable'] = 'Files'\\n info['subdir'] = file_dir\\n info['hashsum'] = file_hash\\n info['hashtype'] = 'sha1'\\n\\n # todo make sure errors bubble up without crashing\\n if file_arcname in self.file_meta:\\n print file_arcname\\n task_error(\\n \\\"Different file with the same arcname is already in the bundle\\\")\\n return\\n\\n return info\",\n \"def hash_file(file_like_object):\\n checksum = hashlib.sha1()\\n for chunk in iter(lambda: file_like_object.read(32768), b''):\\n encoded_chunk = (chunk.encode(encoding='utf-8')\\n if isinstance(chunk, six.string_types) else chunk)\\n checksum.update(encoded_chunk)\\n return checksum.hexdigest()\",\n \"def hash_file(fname,bs=M):\\n h = hashlib.md5()\\n with open(fname,'rb') as f:\\n chunk = f.read(bs)\\n while chunk:\\n h.update(chunk)\\n chunk = f.read(bs)\\n return h.digest()\",\n \"def hash(cls, path, digest=None, hasher=sha1):\\r\\n if digest is None:\\r\\n digest = hasher()\\r\\n with open(path, 'rb') as fh:\\r\\n cls.update_hash(fh, digest)\\r\\n return digest.hexdigest()\",\n \"def sha1sum(filename, blocksize=65536):\\n hash = hashlib.sha1()\\n with open(filename, \\\"rb\\\") as f:\\n for block in iter(lambda: f.read(blocksize), b\\\"\\\"):\\n hash.update(block)\\n return hash.hexdigest()\",\n \"def sha256sum(filename):\\n if not os.path.isfile(filename):\\n return ''\\n hasher = hashlib.sha256()\\n with open(filename, 'rb') as hash_file:\\n buf = hash_file.read(HASH_BLOCK_SIZE)\\n while len(buf) > 0:\\n hasher.update(buf)\\n buf = hash_file.read(HASH_BLOCK_SIZE)\\n return hasher.hexdigest()\",\n \"def _hash_file(fpath, algorithm='sha256', chunk_size=65535):\\n if (algorithm == 'sha256') or (algorithm == 'auto' and len(hash) == 64):\\n hasher = hashlib.sha256()\\n else:\\n hasher = hashlib.md5()\\n\\n with open(fpath, 'rb') as fpath_file:\\n for chunk in iter(lambda: fpath_file.read(chunk_size), b''):\\n hasher.update(chunk)\\n\\n return hasher.hexdigest()\",\n \"def file_digest(file):\\n # 'rb' file mode reads the file as bytes\\n input_file = open(file, 'rb')\\n data = input_file.read()\\n # getting the digest\\n digest = hash_comparing(data).hexdigest()\\n input_file.close()\\n return digest\",\n \"def fast_hash(infile):\\n\\n m = hashlib.sha256()\\n with open(infile, 'rb', 1024 * 1024) as f:\\n l = f.read(1024 * 1024)\\n while (len(l) > 0):\\n m.update(l)\\n f.seek(1024 * 1024 * (512 - 1), 1)\\n l = f.read(1024 * 1024)\\n return m.hexdigest()\",\n \"def hash_file_sha256(file_path, binary=False, buffer_size=65536):\\n return hash_file(file_path, hash_type=hashlib.sha256, binary=binary, buffer_size=buffer_size)\",\n \"def get_file_hash(afile, hasher, block_size=65536):\\n buf = afile.read(block_size)\\n while len(buf) > 0:\\n hasher.update(buf)\\n buf = afile.read(block_size)\\n return hasher.digest()\",\n \"def hash_file(path):\\n if not os.path.isfile(path):\\n raise ValueError(\\\"The given path `{}` is not a file.\\\".format(path))\\n\\n md5 = hashlib.md5()\\n\\n with open(path, 'rb') as file_:\\n while True:\\n data = file_.read(65536)\\n if not data:\\n break\\n md5.update(data)\\n\\n return \\\"{}\\\".format(md5.hexdigest())\",\n \"def get_hash(file_url):\\n file_extension = os.path.splitext(file_url)[1]\\n return str(HASHES.get(file_extension))\",\n \"def hash_file_native(file_path, tool=\\\"sha256sum\\\"):\\n output = subprocess.check_output([tool, file_path], shell=False)\\n return output.decode(\\\"utf-8\\\").partition(\\\" \\\")[0].strip()\",\n \"def sha512_file(file_name):\\n\\n hash_func = hashlib.sha256()\\n\\n with open(file_name, \\\"rb\\\") as fd:\\n hash_func.update(fd.read())\\n\\n return hash_func.hexdigest()\",\n \"def _get_hash(self, path):\\n with open(path, \\\"r\\\") as fp:\\n content = fp.read()\\n\\n return sha256(content).hexdigest()\",\n \"def get_hash_from_file(img):\\n with open(img, 'rb') as f:\\n return hashlib.sha256(f.read()).hexdigest()\",\n \"def _hash_file(fpath, algorithm='sha256', chunk_size=65535):\\n if (algorithm is 'sha256') or (algorithm is 'auto' and len(hash) is 64):\\n hasher = hashlib.sha256()\\n else:\\n hasher = hashlib.md5()\\n\\n with open(fpath, 'rb') as fpath_file:\\n for chunk in iter(lambda: fpath_file.read(chunk_size), b''):\\n hasher.update(chunk)\\n\\n return hasher.hexdigest()\",\n \"def sha256sum(filename):\\n content = open(filename, 'rb').read()\\n sha256_obj = hashlib.sha256(content)\\n return sha256_obj.hexdigest()\",\n \"def _get_file_sha256_hash(file_path):\\n sha256hash = hashlib.sha256()\\n chunk_size = 8192\\n with open(file_path, \\\"rb\\\") as f:\\n while True:\\n buffer = f.read(chunk_size)\\n if not buffer:\\n break\\n sha256hash.update(buffer)\\n return sha256hash.hexdigest()\",\n \"def check_sha1(filename, sha1_hash):\\n sha1 = hashlib.sha1()\\n with open(filename, 'rb') as f:\\n while True:\\n data = f.read(1048576)\\n if not data:\\n break\\n sha1.update(data)\\n\\n sha1_file = sha1.hexdigest()\\n l = min(len(sha1_file), len(sha1_hash))\\n return sha1.hexdigest()[0:l] == sha1_hash[0:l]\",\n \"def hash_file(hash_obj, path):\\n with open(path, 'rb') as f:\\n while True:\\n b = f.read(8192)\\n if not b:\\n break\\n hash_obj.update(b)\\n return hash_obj\",\n \"def sigfile(fpath):\\n sigsha = hashlib.sha1()\\n fbj = open(fpath, 'rb')\\n try:\\n sigsha.update(fbj.read()) # pylint: disable-msg=E1101\\n finally:\\n fbj.close()\\n return sigsha.hexdigest()\",\n \"def hash_file_in_zip(zip_handler, file_path_in_zip, algorithm=\\\"sha1\\\"):\\n block_size = 64 * 1024\\n hasher = getattr(hashlib, algorithm)()\\n with zip_handler.open(file_path_in_zip, \\\"r\\\") as file_handler:\\n while True:\\n data = file_handler.read(block_size)\\n if not data:\\n break\\n hasher.update(data)\\n return hasher.hexdigest()\",\n \"def hash(self):\\n block = 1024 * 1024 * 4 # 4 MB.\\n hasher = hashlib.sha256()\\n\\n with open(self.path, \\\"rb\\\") as f:\\n while True:\\n chunk = f.read(block)\\n if not chunk:\\n break\\n hasher.update(hashlib.sha256(chunk).digest())\\n\\n digest = hasher.hexdigest()\\n pdbox.debug(\\\"Hash for %s: %s\\\" % (self.path, digest))\\n return digest\",\n \"def get_sha1_from_stream(src: io.IOBase) -> str:\\n if not isinstance(src, io.IOBase) or not src.readable():\\n raise Exception(\\\"src is not stream or unreadable\\\")\\n m: hashlib._hashlib.HASH = hashlib.sha1()\\n return calc_hash(src, m)\",\n \"def hash_file(self, filename_or_bytestream):\\n\\n try:\\n for data in self._read_blocks(filename_or_bytestream):\\n self._update(data)\\n except OSError as e:\\n print('digest: ', filename_or_bytestream, ': ', e.strerror, sep='', file=sys.stderr)\\n return None\\n return self._hexdigests()\",\n \"def hashfile(file: str, block_size: int = 65536) -> str:\\n with open(file, 'rb') as message:\\n m = hashlib.sha256()\\n block = message.read(block_size)\\n while len(block) > 0:\\n m.update(block)\\n block = message.read(block_size)\\n digest = m.hexdigest()\\n\\n return digest\",\n \"def hash_file(file_path):\\n\\n \\n\\n def generator(f):\\n while True:\\n x = f.read(CHUNK_SIZE)\\n if x:\\n yield x\\n else:\\n return \\n\\n with open(file_path, 'rb') as f:\\n a = generator(f)\\n num_cores = min(multiprocessing.cpu_count(), MAX_CORES)\\n hashes = Parallel(n_jobs=num_cores)(delayed(md4_hash)(i) for i in a)\\n if len(hashes) == 1:\\n return hashes[0].hex()\\n else:\\n return md4_hash(b\\\"\\\".join(hashes)).hex()\",\n \"def _hash_file(fpath, algorithm='sha256', chunk_size=65535):\\n if isinstance(algorithm, str):\\n hasher = _resolve_hasher(algorithm)\\n else:\\n hasher = algorithm\\n\\n with open(fpath, 'rb') as fpath_file:\\n for chunk in iter(lambda: fpath_file.read(chunk_size), b''):\\n hasher.update(chunk)\\n\\n return hasher.hexdigest()\",\n \"def get_hash(content):\\n return hashlib.sha1(content).hexdigest()\",\n \"def cksum(filename):\\n hash, err = Popen([\\\"cksum\\\", filename], stdout=PIPE, stderr=PIPE).communicate()\\n if err != '':\\n raise Exception(\\\"Error hashing {filename}\\\".format(**locals()))\\n return hash.split(\\\" \\\")[0]\",\n \"def hash_file2(fpath, blocksize=65536, hasher='xx64'):\\n import xxhash\\n if hasher == 'xx32':\\n hasher = xxhash.xxh32()\\n elif hasher == 'xx64':\\n hasher = xxhash.xxh64()\\n\\n with open(fpath, 'rb') as file:\\n buf = file.read(blocksize)\\n # otherwise hash the entire file\\n while len(buf) > 0:\\n hasher.update(buf)\\n buf = file.read(blocksize)\\n # Get the hashed representation\\n text = ub.util_hash._digest_hasher(hasher, hashlen=None,\\n base=ub.util_hash.DEFAULT_ALPHABET)\\n return text\",\n \"def hashing(file,pp):\\n\\n def myhash(instring):\\n # sdbm hash\\n res = 0\\n for t in instring:\\n res = (ord(t) + (res<<6) + (res<<16) - res) % 2**32\\n return res\\n\\n return hex(myhash(file.replace('\\\\\\\\','/')+\\\":\\\"+pp))\",\n \"def _hash_file(file: Union[str, Path], md5: Hash) -> Hash:\\n if isinstance(file, str) and file.lower().startswith(\\\"file://\\\"):\\n file = unquote(urlparse(file).path)\\n if not Path(file).is_file():\\n raise ValueError(str(file) + \\\" is not a valid file\\\")\\n with open(file, \\\"rb\\\") as f:\\n while True:\\n data = f.read(BUF_SIZE)\\n if not data:\\n break\\n md5.update(data)\\n return md5\",\n \"def hash_key(hashfunc=hashlib.md5):\\n\\n def _(_file):\\n try:\\n with open(_file.path, 'rb') as fd:\\n _h = hashfunc()\\n for chunk in read_chunks(fd, chunk_size=1024*1024*10):\\n _h.update(chunk)\\n return _h.digest()\\n except (OSError, PermissionError):\\n logger.warning(\\n f\\\"Skipping File (Could Not Open To Read): {_file.path}\\\")\\n\\n return _\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.86476487","0.8624012","0.8624012","0.8598889","0.85914165","0.85725063","0.8362854","0.82423913","0.82207185","0.8157332","0.81049347","0.80176985","0.8006898","0.7986033","0.79686046","0.7901671","0.7900068","0.7896424","0.78734815","0.77931935","0.77609146","0.7689186","0.76454675","0.7641597","0.76241684","0.76217645","0.7576001","0.752278","0.75064564","0.7473051","0.7463984","0.74569803","0.7448289","0.74446857","0.74428403","0.7413173","0.74101466","0.74005854","0.736173","0.732334","0.73229414","0.7313211","0.72991765","0.72656745","0.7260437","0.7255662","0.7255662","0.72505254","0.7250051","0.7238507","0.7209666","0.71740943","0.7173533","0.7171762","0.71611273","0.7156285","0.71133065","0.7106383","0.70935386","0.70685333","0.7054822","0.70541364","0.7022286","0.7008241","0.7003678","0.6983816","0.6974191","0.69630665","0.69313955","0.6913267","0.6912083","0.6911882","0.69054794","0.69042933","0.68980914","0.6896236","0.6895842","0.6894914","0.6891805","0.6891698","0.6889466","0.68868876","0.68458325","0.68214494","0.6816532","0.67836046","0.6780981","0.67740846","0.67731786","0.67458725","0.6726128","0.671434","0.6712038","0.6703821","0.67004657","0.6697367","0.6678724","0.66781163","0.66631234","0.66385865"],"string":"[\n \"0.86476487\",\n \"0.8624012\",\n \"0.8624012\",\n \"0.8598889\",\n \"0.85914165\",\n \"0.85725063\",\n \"0.8362854\",\n \"0.82423913\",\n \"0.82207185\",\n \"0.8157332\",\n \"0.81049347\",\n \"0.80176985\",\n \"0.8006898\",\n \"0.7986033\",\n \"0.79686046\",\n \"0.7901671\",\n \"0.7900068\",\n \"0.7896424\",\n \"0.78734815\",\n \"0.77931935\",\n \"0.77609146\",\n \"0.7689186\",\n \"0.76454675\",\n \"0.7641597\",\n \"0.76241684\",\n \"0.76217645\",\n \"0.7576001\",\n \"0.752278\",\n \"0.75064564\",\n \"0.7473051\",\n \"0.7463984\",\n \"0.74569803\",\n \"0.7448289\",\n \"0.74446857\",\n \"0.74428403\",\n \"0.7413173\",\n \"0.74101466\",\n \"0.74005854\",\n \"0.736173\",\n \"0.732334\",\n \"0.73229414\",\n \"0.7313211\",\n \"0.72991765\",\n \"0.72656745\",\n \"0.7260437\",\n \"0.7255662\",\n \"0.7255662\",\n \"0.72505254\",\n \"0.7250051\",\n \"0.7238507\",\n \"0.7209666\",\n \"0.71740943\",\n \"0.7173533\",\n \"0.7171762\",\n \"0.71611273\",\n \"0.7156285\",\n \"0.71133065\",\n \"0.7106383\",\n \"0.70935386\",\n \"0.70685333\",\n \"0.7054822\",\n \"0.70541364\",\n \"0.7022286\",\n \"0.7008241\",\n \"0.7003678\",\n \"0.6983816\",\n \"0.6974191\",\n \"0.69630665\",\n \"0.69313955\",\n \"0.6913267\",\n \"0.6912083\",\n \"0.6911882\",\n \"0.69054794\",\n \"0.69042933\",\n \"0.68980914\",\n \"0.6896236\",\n \"0.6895842\",\n \"0.6894914\",\n \"0.6891805\",\n \"0.6891698\",\n \"0.6889466\",\n \"0.68868876\",\n \"0.68458325\",\n \"0.68214494\",\n \"0.6816532\",\n \"0.67836046\",\n \"0.6780981\",\n \"0.67740846\",\n \"0.67731786\",\n \"0.67458725\",\n \"0.6726128\",\n \"0.671434\",\n \"0.6712038\",\n \"0.6703821\",\n \"0.67004657\",\n \"0.6697367\",\n \"0.6678724\",\n \"0.66781163\",\n \"0.66631234\",\n \"0.66385865\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.85206515"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":21975,"cells":{"query":{"kind":"string","value":"Determine the length of the shortest path from start cloud to end cloud while avoiding clouds with value 1. Jumps can be of length 1 or 2, although jumps must be made through the consequtive clouds."},"document":{"kind":"string","value":"def jumping_on_the_clouds(clouds):\n index_clouds = [index for index, v in enumerate(clouds) if v == 0]\n for cloud in index_clouds:\n if index_clouds.index(cloud) == len(index_clouds) - 1:\n break\n if index_clouds[index_clouds.index(cloud) - 1] == cloud - 1 and \\\n index_clouds[index_clouds.index(cloud) + 1] == cloud + 1:\n index_clouds.remove(cloud)\n\n return len(index_clouds) - 1"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def shortest_path_lengths(self, g, src):\n d = {} # d[v] is upper bound from s to v\n cloud = {} # map reachable v to its d[v] value\n pq = AdaptableHeapPriorityQueue() # vertex v will have key d[v]\n pqlocator = {} # map from vertex to its pq locator\n\n # for each vertex v of the graph, add an entry to the priority queue, with\n # the source having distance 0 and all others having infinite distance\n for v in g.vertices():\n if v is src:\n d[v] = 0\n else:\n d[v] = float('inf') # syntax for positive infinity\n pqlocator[v] = pq.add(d[v], v) # save locator for future updates\n\n while not pq.is_empty():\n key, u = pq.remove_min()\n cloud[u] = key # its correct d[u] value\n del pqlocator[u] # u is no longer in pq\n for e in g.incident_edges(u): # outgoing edges (u,v)\n v = e.opposite(u)\n if v not in cloud:\n # perform relaxation step on edge (u,v)\n wgt = e.element()\n if d[u] + wgt < d[v]: # better path to v?\n d[v] = d[u] + wgt # update the distance\n pq.update(pqlocator[v], d[v], v) # update the pq entry\n\n return cloud # only includes reachable vertices","def path_lengths(graph):\n allPairsPathLengths = dict(nx.all_pairs_dijkstra_path_length(graph, weight='lgth'))\n shortestPathLength = np.array([[length for length in pair.values()] for pair in allPairsPathLengths.values()])\n shortestPathLength = np.tril(shortestPathLength)\n shortestPathLength[shortestPathLength == 0] = np.nan\n return(shortestPathLength)","def numShortestPaths(g, start, end):\n if g == None or start == None or end == None:\n raise InvalidInputException(\"Input is null.\")\n if not g.containsVertex(start) or not g.containsVertex(end):\n raise InvalidInputException(\"Doesn't contain source.\")\n nodes = []\n nodes.append(start)\n # Adds two decorations to the vertices\n for node in g.iterVertices():\n node.minCount = float(\"inf\")\n node.numCount = 0\n start.minCount = 0\n while not len(nodes) == 0:\n node = nodes.pop(0)\n # Base case: if node is the end node, return the numCount decoration\n if node == end:\n return node.numCount\n # Decorates neighboring nodes and adds them to the list\n for edge in g.incidentEdges(node):\n new_node = g.opposite(node,edge)\n if new_node.minCount == float(\"inf\"):\n new_node.minCount = node.minCount+1\n nodes.append(new_node)\n if new_node.minCount == node.minCount + 1:\n new_node.numCount = node.numCount + 1","def shortestPathLength(self, graph: List[List[int]]) -> int:\n n = len(graph)\n steps = 0\n all_visited = (1<<n)-1\n queue = [(i, 1<<i) for i in range(n)]\n visited_status = set(queue)\n while queue:\n new_queue = []\n for i, visited in queue:\n if visited == all_visited:\n return steps\n for j in graph[i]:\n status = (j, visited | (1<<j))\n if status not in visited_status:\n visited_status.add(status)\n new_queue.append(status)\n steps += 1\n queue = new_queue\n\n return -1","def length(self):\n return self.endpoints[0].distance_to(self.endpoints[1])","def count_paths_staircase(length_staircase, possible_actions):\n path = [0] * length_staircase\n # First we add our possible_actions to our path count\n for i in possible_actions:\n path[i - 1] = 1\n # Compute number of path combinations to every step\n for i in range(length_staircase):\n for j in possible_actions:\n k = i + j\n if k >= length_staircase:\n continue\n path[k] += path[i]\n return path","def __len__(self):\r\n return int(np.ceil(len(self.pathways) / float(self.batch_size)))","def dist(gene1, gene2):\n return abs(len(gene1.goal) - len(gene2.goal))","def solution(map):\n # length[i][j] = the length of the shortest path from (i,j) to (w-1,h-1).\n # Modify the current location to -1 and continue searching from adjacent spaces.\n return Maze(map).shortest_length()","def shortestPathLength(self, graph):\n # binary representation of a state of which nodes visited.\n ans = (1 << len(graph)) - 1\n\n # typical template for bfs; initil\n qe = []\n visited = set()\n for i in range(len(graph)):\n qe.append((i, 1 << i))\n visited.add((i, 1 << i))\n\n moves = 0\n while qe:\n size = len(qe)\n while size > 0:\n size -= 1\n # queue: FIFO\n n, vnodes = qe.pop(0)\n if vnodes == ans:\n return moves\n neighbors = graph[n]\n for neighbor in neighbors:\n nvnodes = (vnodes | 1 << neighbor)\n if (neighbor, nvnodes) in visited:\n continue\n qe.append((neighbor, nvnodes))\n visited.add((neighbor, nvnodes))\n moves += 1\n return -1","def shortestPathLength(self, graph: List[List[int]]) -> int:\n n = len(graph)\n # Floyd-Warshall\n g = [[float('inf')]*n for _ in range(n)]\n for i, js in enumerate(graph):\n for j in js:\n g[i][j] = 1\n for k in range(n):\n for i in range(n):\n for j in range(n):\n if i == j:\n g[i][j] = 0\n else:\n g[i][j] = min(g[i][j], g[i][k] + g[k][j])\n\n # dfs\n @lru_cache(None)\n def dfs(i, remain):\n if remain == 0:\n return 0\n ret = float('inf')\n for j, d in enumerate(g[i]):\n if remain&(1<<j) != 0:\n ret = min(ret, d + dfs(j, remain ^ (1<<j)))\n return ret\n\n full_mask = (1<<n)-1\n return min(dfs(i, full_mask^(1<<i)) for i in range(n))","def path_length(self, u, v):\n mrca = self.mrca(u, v)\n if mrca == -1:\n return math.inf\n return self.depth(u) + self.depth(v) - 2 * self.depth(mrca)","def get_reached(g, source, hops, timeout):\n\n paths = nx.single_source_shortest_path(g, source, hops)\n total = len(paths)\n reached = total\n\n for v in paths.itervalues():\n for i in range(1, len(v)):\n lat = g[v[i-1]][v[i]][\"latency\"]\n if lat > timeout:\n reached -= 1\n break\n\n return float(reached)/float(total)","def evaluatePath(self):\n pathLength = 0\n if len(self.path) > 0:\n previousCity = self.path[0]\n for ind in range(1, len(self.path)):\n pathLength += previousCity.distanceWith(self.path[ind].name)\n previousCity = self.path[ind]\n return pathLength","def shortest_combined_wire_path(grid):\n current_minimum = sys.maxsize\n\n for crossing in grid.crossings:\n crossing_wires = grid.get(crossing[0], crossing[1])\n \n crossing_total = 0\n for wire in crossing_wires:\n crossing_total += wire['distance']\n\n if crossing_total < current_minimum:\n current_minimum = crossing_total\n\n print(f\"Total length of wire at {crossing} is {crossing_total}\")\n return current_minimum","def computeShortestPathCoherence(node1, node2, w):\n\n\tif node1.strip()==node2.strip():\n\t\treturn w\n\n\tfromCache=rds.get(\"%s:%s\" % (node1, node2))\n\tif fromCache:\n\t\treturn float(fromCache)*w\n\telse:\n\t\tg = Graph()\n\t\tq=\"MATCH path=shortestPath((m:Page {name:\\\"%s\\\"})-[LINKS_TO*1..10]-(n:Page {name:\\\"%s\\\"})) RETURN LENGTH(path) AS length, path, m, n\" % (node1, node2)\n\n\t\tcursor=g.run(q)\n\t\tpath=None\n\t\tfor c in cursor:\n\t\t\tpath=c\n\n\t#\n\t\tif path:\n\t\t\trds.set(\"%s:%s\" % (node1, node2), 1/path[\"length\"])\n\t\t\trds.set(\"%s:%s\" % (node2, node1), 1/path[\"length\"])\n\t\t\treturn w/path[\"length\"]\n\t\telse:\n\t\t\trds.set(\"%s:%s\" % (node1, node2), 0.0)\n\t\t\trds.set(\"%s:%s\" % (node2, node1), 0.0)\n\t\t\treturn 0.0","def mostLikelyPath(self, start, length=100):\n path = [start]\n for step in range(length):\n bestValue = -100000000\n bestAction = None\n for action in range(self.A):\n pathValue = self.valueLookAhead(path[-1][0], [1], action)\n # print((self.stateToCoord[nextState[0]], pathValue))\n if pathValue > bestValue:\n bestValue = pathValue\n bestAction = action\n possibleNextStates = self.trans(path[-1][0], path[-1][1])[bestAction]\n path.append(randomSample(possibleNextStates))\n return path","def compute_min_refills(distance: int, tank: int, stops: List[int]):\n location: int = 0\n n_stops = 0\n last_stop = 0\n max_drive = location + tank\n\n while max_drive < distance:\n counter = 0\n\n # Handle the case that stops are depleted before we reach distance\n if len(stops) == 0:\n return -1\n for s in stops:\n if s <= max_drive:\n counter += 1\n last_stop = s\n max_drive = last_stop + tank\n\n # Handle the case that wi did not reach the next stop\n if counter == 0:\n return -1\n else:\n del stops[0:counter]\n n_stops += 1\n\n return n_stops","def length(self) -> float:\n n = len(self.milestones[0])//2\n third = 1.0/3.0\n def distance(x,y):\n cp0 = x[:n]\n cp1 = vectorops.madd(cp0,x[n:],third)\n cp3 = y[:n]\n cp2 = vectorops.madd(cp3,y[n:],-third)\n return third*vectorops.norm(x[n:]) + vectorops.distance(cp1,cp2) + third*vectorops.norm(y[n:])\n return Trajectory.length(self,distance)","def __len__(self):\n return self.start.dist(self.end)","def length(self) -> float:\n n = self.geodesic.extrinsicDimension()\n third = 1.0/3.0\n def distance(x,y):\n cp0 = x[:n]\n cp1 = self.geodesic.integrate(cp0,vectorops.mul(x[n:],third))\n cp3 = y[:n]\n cp2 = self.geodesic.integrate(cp3,vectorops.mul(y[n:],-third))\n return self.geodesic.distance(cp0,cp1) + self.geodesic.distance(cp1,cp2) + self.geodesic.distance(cp2,cp3)\n return Trajectory.length(self,distance)","def distance( self, source, target ):\n return nx.shortest_path_length(self._G, source, target)","def cable_length(self):\n skel = self.physical_space(copy=False)\n\n v1 = skel.vertices[skel.edges[:,0]]\n v2 = skel.vertices[skel.edges[:,1]]\n\n delta = (v2 - v1)\n delta *= delta\n dist = np.sum(delta, axis=1)\n dist = np.sqrt(dist)\n\n return np.sum(dist)","def solution(s, v, dist, pred):\n path = [v]\n total = dist[v]\n while v != s:\n v = pred[v]\n path.insert(0, v)\n return \"length=\" + str(total) + \" \" + str(path)","def solve(k=[]):\n if len(k) < 2:\n return 1\n min_jumps = len(k)\n for i in reversed(range(k[0])):\n if i > len(k):\n return 1\n if k[i] != 0:\n sub_jumps = solve(k[i + 1 :])\n min_jumps = min(min_jumps, sub_jumps)\n return min_jumps","def length_dist(self,synset_1, synset_2):\n\t l_dist = sys.maxsize\n\t if synset_1 is None or synset_2 is None: \n\t return 0.0\n\t if synset_1 == synset_2:\n\t # if synset_1 and synset_2 are the same synset return 0\n\t l_dist = 0.0\n\t else:\n\t wset_1 = set([str(x.name()) for x in synset_1.lemmas()]) \n\t wset_2 = set([str(x.name()) for x in synset_2.lemmas()])\n\t if len(wset_1.intersection(wset_2)) > 0:\n\t # if synset_1 != synset_2 but there is word overlap, return 1.0\n\t l_dist = 1.0\n\t else:\n\t # just compute the shortest path between the two\n\t l_dist = synset_1.shortest_path_distance(synset_2)\n\t if l_dist is None:\n\t l_dist = 0.0\n\t # normalize path length to the range [0,1]\n\t return math.exp(-self.ALPHA * l_dist)","def nb_simple_paths(self, start, end):\n if start not in self.nodes or end not in self.nodes:\n return None\n\n visited = set()\n nb_paths = 0\n\n def search(node, goal):\n nonlocal nb_paths\n visited.add(node)\n\n if node == goal:\n nb_paths += 1\n else:\n for neighbor in self.nodes[node]:\n if neighbor not in visited:\n search(neighbor, goal)\n\n visited.remove(node)\n\n search(start, end)\n return nb_paths","def getPathLength(self, path):\r\n path_nodes = path\r\n # print(path_nodes)\r\n total_length = 0 # km\r\n for i in range(len(path_nodes)-1):\r\n next_edge = None\r\n for edge in self.graph.getAdj(path_nodes[i]):\r\n if edge.getExtremityNode() == path_nodes[i+1]:\r\n next_edge = edge\r\n if next_edge is None: # it means the path is invalid\r\n return None\r\n total_length += next_edge.getWeight()\r\n # print(next_edge.getTravelType(), end=\" \")\r\n return total_length","def shortest_distance(self, begin, end):\n\n begin_index = self._cell_indexes[begin]\n end_index = self._cell_indexes[end]\n\n distance = self._distance_mat[begin_index, end_index]\n # distance *= pq.meter\n\n path = [begin]\n inv_index = {v: k for k, v in self._cell_indexes.items()}\n while True:\n next_index = self._preds[end_index, begin_index]\n if next_index == -9999:\n break\n\n begin_index = next_index\n\n seg = inv_index[next_index]\n path.append(seg)\n\n return distance, path","def shortestPath(haystack, needle):\n if needle == haystack:\n return 0\n hyponyms = haystack.hyponyms()\n if len(hyponyms) > 0:\n return 1 + min([shortestPath(hypo, needle) for hypo in hyponyms])\n else:\n return 1000","def shortest_path_distance(self, other):\n if self == other:\n return 0\n\n paths = self.shortest_path(other)\n return None if paths == [] else len(paths[0]) - 1","def shortest_route(self, start, end):\n if start not in self.nodes or end not in self.nodes:\n return None\n\n previous = {}\n unvisited = set(self.nodes.keys())\n distance = {n: maxsize for n in unvisited}\n\n distance[start] = 0\n\n while unvisited:\n u = min(unvisited, key=distance.get)\n if distance[u] == maxsize:\n return None\n if u == end:\n break\n unvisited.remove(u)\n\n for neighbor in self.nodes[u]:\n if neighbor not in unvisited:\n continue\n\n d = distance[u] + self.edges[u, neighbor]\n if neighbor not in distance or d < distance[neighbor]:\n distance[neighbor] = d\n previous[neighbor] = u\n\n sequence = [end]\n u = end\n while u in previous:\n u = previous[u]\n sequence.append(u)\n sequence.reverse()\n return sequence, distance[end]","def dist_to_stop(speed):\n return speed ** 2 / 4","def OptimalWarpingPath( self, colStart=None ):\n rows = len(self.D)\n cols = len(self.D[0])\n n = rows-1\n m = cols-1\n if colStart:\n m=colStart\n path = [(n,m)]\n while n > 0 or m > 0:\n if n == 0 :\n path.insert(0,(0,m-1))\n m -= 1\n elif m == 0 :\n path.insert(0,(n-1,0))\n n -= 1\n else:\n minStep = min( self.D[n-1][m-1], self.D[n-1][m], self.D[n][m-1] )\n if self.D[n-1][m-1] == minStep:\n path.insert(0,(n-1,m-1))\n n -= 1\n m -= 1\n elif self.D[n-1][m] == minStep:\n path.insert(0,(n-1,m))\n n -= 1\n else: # self.D[n][m-1] == min:\n path.insert(0,(n,m-1))\n m -= 1\n return path, self.CostOfPath( path, self.D )","def path_cost(path):\n return len(path)","def path(l_s, l_f, leg_list):\n # candidates =\n return min(heuristic_path([l_s], l_f, leg_list, []), key = len)","def solution(path):\n pos = (0, 0)\n\n vector_path = [VECTORS[stepdir] for stepdir in path]\n\n max_from_start = 0\n for v in vector_path:\n pos = (pos[0] + v[0], pos[1] + v[1])\n max_from_start = max(max_from_start, hex_distance((0, 0), pos))\n if pos == (0, 0):\n # ended up back at start\n return 0\n # find shortest path from (0,0) to pos\n return hex_distance((0, 0), pos), max_from_start","def shortest_flight(self):\r\n distance = sys.maxsize\r\n for code, _list in self.edges.items():\r\n for edge in _list:\r\n if edge.distance < distance:\r\n distance = edge.distance\r\n start = edge.start\r\n destination = edge.destination\r\n return start, destination, distance","def get_shortest_route_floyd(network, start,destination, excludings=[]):\n\n # On récupère la liste des villes\n list_city = network[1].keys()\n \n # Si la ville de départ ou de fin n'existe pas\n if start not in list_city or destination not in list_city:\n return None\n\n # On retire les villes à exclure\n list_city = [x for x in list_city if x not in excludings]\n\n\n # Initialisation de se qu'on a besoin\n matrix = []\n distance = []\n n = len(list_city)\n\n \n # On construit la matrice adjacente où indique la distance si il existe une autoroute entre 2 villes\n for x in range(n): \n matrix.append( [] )\n distance.append( [] )\n for y in range(n):\n road_id = get_road_to(network,list_city[x],list_city[y])\n if road_id != None:\n matrix[x].append( get_length(network,road_id) )\n else:\n matrix[x].append( None )\n distance[x].append( [road_id] ) # Autoroute -> format: ['LA']\n\n\t \n # Algorithme de Floyd\n for k in range(n):\n for i in range(n):\n for j in range(n):\n if ( matrix[i][k] != None and matrix[k][j] != None ) and ( ( matrix[i][j] == None ) or ( matrix[i][j] > matrix[i][k] + matrix[k][j] ) ):\n matrix[i][j] = matrix[i][k] + matrix[k][j]\n\t\t \n\t\t # Hors Floyd / Ajout personnel\n if i != k and j != k: # Si i == k ou j == k, cela veut dire qu'on additionne un résultat supplémentaire à la case ij\n distance[i][j] = [] # Sinon ca signifie qu'on a trouvé un chemin plus court, du coup on supprime l'ancien chemin\n distance[i][j].extend( distance[i][k] ) # Chemin d'autoroute parcouru en plus -> format: ['LA','AH']\n distance[i][j].extend( distance[k][j] ) # Chemin d'autoroute parcouru en plus -> format: ['LA','AH']\n\n\t\t \n # On récupère simplement la liste des autoroutes parcourus\n idx_start = list_city.index( start )\n idx_destination = list_city.index( destination )\n distance_minimum = distance[ idx_start ][ idx_destination ]\n\n \n # Si on ne trouve aucune solution, on renvoie None\n if distance_minimum == [None]:\n distance_minimum = None\n \n return distance_minimum","def calculateWireLenght(path_list):\n\n total_length = 0\n for path in path_list:\n total_length += len(path)\n return total_length","def ab_path_length(trajectory, a, b):\n a_idx = find_closest_index(trajectory, a)\n b_idx = find_closest_index(trajectory, b)\n path = trajectory[a_idx:b_idx]\n step_dists = np.linalg.norm(np.diff(path, axis=0, prepend = np.array([[0,0]])), axis = 1)\n path_length = np.sum(step_dists)\n\n return(path_length)","def shortest_steps(connectors: List[int]):\n connectors = sorted(connectors)\n return [nxt-prv for prv, nxt in zip([0]+connectors, connectors)] + [3]","def longest_flight(self):\r\n distance = 0\r\n for code, _list in self.edges.items():\r\n for edge in _list:\r\n if edge.distance > distance:\r\n distance = edge.distance\r\n start = edge.start\r\n destination = edge.destination\r\n return start, destination, distance","def get_k_shortest_paths(env: RailEnv,\n source_position: Tuple[int, int],\n source_direction: int,\n target_position=Tuple[int, int],\n k: int = 1, debug=False) -> List[Tuple[Waypoint]]:\n\n # P: set of shortest paths from s to t\n # P =empty,\n shortest_paths: List[Tuple[Waypoint]] = []\n\n # countu: number of shortest paths found to node u\n # countu = 0, for all u in V\n count = {(r, c, d): 0 for r in range(env.height) for c in range(env.width) for d in range(4)}\n\n # B is a heap data structure containing paths\n # N.B. use OrderedSet to make result deterministic!\n heap: OrderedSet[Tuple[Waypoint]] = OrderedSet()\n\n # insert path Ps = {s} into B with cost 0\n heap.add((Waypoint(source_position, source_direction),))\n\n # while B is not empty and countt < K:\n while len(heap) > 0 and len(shortest_paths) < k:\n if debug:\n print(\"iteration heap={}, shortest_paths={}\".format(heap, shortest_paths))\n # – let Pu be the shortest cost path in B with cost C\n cost = np.inf\n pu = None\n for path in heap:\n if len(path) < cost:\n pu = path\n cost = len(path)\n u: Waypoint = pu[-1]\n if debug:\n print(\" looking at pu={}\".format(pu))\n\n # – B = B − {Pu }\n heap.remove(pu)\n # – countu = countu + 1\n\n urcd = (*u.position, u.direction)\n count[urcd] += 1\n\n # – if u = t then P = P U {Pu}\n if u.position == target_position:\n if debug:\n print(\" found of length {} {}\".format(len(pu), pu))\n shortest_paths.append(pu)\n\n # – if countu ≤ K then\n # CAVEAT: do not allow for loopy paths\n elif count[urcd] <= k:\n possible_transitions = env.rail.get_transitions(*urcd)\n if debug:\n print(\" looking at neighbors of u={}, transitions are {}\".format(u, possible_transitions))\n # for each vertex v adjacent to u:\n for new_direction in range(4):\n if debug:\n print(\" looking at new_direction={}\".format(new_direction))\n if possible_transitions[new_direction]:\n new_position = get_new_position(u.position, new_direction)\n if debug:\n print(\" looking at neighbor v={}\".format((*new_position, new_direction)))\n\n v = Waypoint(position=new_position, direction=new_direction)\n # CAVEAT: do not allow for loopy paths\n if v in pu:\n continue\n\n # – let Pv be a new path with cost C + w(u, v) formed by concatenating edge (u, v) to path Pu\n pv = pu + (v,)\n # – insert Pv into B\n heap.add(pv)\n\n # return P\n return shortest_paths","def part_2(distances: Distances) -> int:\n\n result, _ = max(generate_routes(distances))\n print(f\"part 2: longest route has distance {result}\")\n return result","def get_distance(start, end):\n\n\t\tloc_start, loc_end, dst_node = create_distance(start, end)\n\t\tdistance = cmds.getAttr(\"%s.distance\" % dst_node)\n\n\t\tcmds.delete([loc_start, loc_end, dst_node])\n\n\t\treturn distance","def ApproxConc280(Abs, pathLength = 10):\n pass","def DFS1(digraph, start, end, path, maxTotalDist, maxDistOutdoors):\n listP=[]\n path = path + [start]\n #print 'Current dfs path:', printPath(path)\n if start == end:\n listP.append(path)\n for node in digraph.childrenOf(start):\n if node not in path: #avoid cycles\n newPath = DFS1(digraph,node,end,path, maxTotalDist, maxDistOutdoors)\n if newPath != None:\n if outDisAdd(digraph, newPath) <maxDistOutdoors:\n listP.append(newPath)\n if listP==[]:\n raise ValueError\n else:\n return whichShortest(digraph, listP, maxTotalDist )","def slice_length(start, stop, step):\n return (stop - start + step - 1) // step","def length(self) -> float:\n return pos.distance(self.start, self.end)","def path_cost(self, c, state1, action, state2):\n # print(c)\n accao, direcao = action.split()\n if accao == WALK:\n return c + 1\n elif accao == PUSH:\n return c + 1","def compute_shortest_routes(start_ids, dest_ids, G):\n return ox.distance.shortest_path(G, start_ids, dest_ids, weight='travel_time', cpus=6)","def leg_length(self, *args):\n i, j = args\n return Partition(list(self)).leg_length(i-1, j-1)","def dikjistra(start, conex, target):\n\tind = list(set([con[0] for con in conex] + [con[1] for con in conex]))\n\tt = len(ind)\n\tmaxi = sum([con[2] for con in conex])\n\tdist = [maxi for ii in range(t)]\n\tcheck = [0 for ii in range(t)]\n\tdist[ind.index(start)]=0\n\t#print 'INDEX: ', ind\n\twhile True:\n\t\tmini = maxi + 1\n\t\tpos = -1\n\t\tfor ii in range(t):\n\t\t\tif (dist[ii]<mini and check[ii]==0):\n\t\t\t\tpos = ii\n\t\t\t\tmini = dist[ii]\n\t\tif (pos == -1):\n\t\t\treturn False\n\t\tif ind[pos] == target:\n\t\t\treturn dist[pos]\n\t\tfor aa, bb, dd in conex:\n\t\t\taaa, bbb = ind.index(aa), ind.index(bb)\n\t\t\tif aaa==pos and check[bbb]==0:\n\t\t\t\tdist[bbb] = min(dist[bbb], dist[pos] + dd)\n\t\t\tif bbb==pos and check[aaa]==0:\n\t\t\t\tdist[aaa] = min(dist[aaa], dist[pos] + dd)\n\t\tcheck[pos] = 1\n\t\t#print 'Vert, ', ind[pos], 'Distances, ', dist","def get_number_of_paths(node, x, y, current_player):\n paths = 0\n\n if current_player == PLAYER_A:\n # Possible downwards path\n if y != node.board_size - 1:\n for i in range(1, node.board_size - y):\n if node.board[y+i][x] != BLANK_SPACE_CHAR :\n break\n elif y + i == node.board_size - 1: \n paths += 1\n break \n\n # Possible downwards-right path\n if x != node.board_size - 1 and y != node.board_size - 1:\n limit = min([node.board_size - x, node.board_size - y])\n for i in range(1, limit):\n if node.board[y+i][x+i] != BLANK_SPACE_CHAR:\n break \n elif y + i == node.board_size - 1: \n paths += 1\n break \n\n # Possible downwards-left path\n if x != 0 and y != node.board_size - 1:\n limit = min([x + 1, node.board_size - y])\n for i in range(1, limit):\n if node.board[y+i][x-i] != BLANK_SPACE_CHAR:\n break \n elif y + i == node.board_size - 1: \n paths += 1\n break \n\n else:\n # Possible upwards path\n if y != 0:\n for i in range(1, y + 1):\n if node.board[y- i][x] != BLANK_SPACE_CHAR:\n break \n elif y - i == 0: \n paths += 1\n break \n\n # Possible upwards-right path\n if x != node.board_size - 1 and y != 0:\n limit = min([node.board_size - x, y + 1])\n for i in range(1, limit):\n if node.board[y-i][x+i] != BLANK_SPACE_CHAR:\n break \n elif x + i == node.board_size - 1 or y - i == 0: \n paths += 1\n break \n\n # Possible upwards-left path\n if x != 0 and y != 0:\n limit = min([x + 1, y + 1])\n for i in range(1, limit):\n if node.board[y-i][x-i] != BLANK_SPACE_CHAR:\n break \n elif x - i == 0 or y - i == 0: \n paths += 1\n break \n\n return paths","def longest_path_callback(self, data):\n min_idx = self.find_minimum_distance(data.poses) # closest point index\n if min_idx is None:\n return\n else:\n # extract 20 points along the closest point\n # use z position of ego car since z displacement doesn't matter\n # truncate if encounter head or tail\n path_points = np.array([\n (pose.pose.position.x, pose.pose.position.y, self.car_pos[2])\n for pose in data.poses[max(min_idx-10, 0):min_idx+10]]\n )\n # use svd to find the approximate tangent direction of longest path\n approx_dir = np.linalg.svd(path_points-np.mean(path_points,axis=0))[2][0]\n self.last_yaw_longestpath = np.arctan2(approx_dir[1], approx_dir[0])\n # perpendicular distance is then the norm of vector\n # (car_pos - pos_point) x approx_dir, x is cross product\n self.last_dist_longestpath = np.linalg.norm(\n np.cross(path_points[0,:] - self.car_pos, approx_dir)\n )\n # publish\n self.pub_closest_dist_longestpath.publish(self.last_dist_longestpath)","def distance(self,case):\r\n return max(abs(self.ligne-case.ligne),abs(self.colonne-case.colonne))","def trips_distance_constraint_bfs(self, start_node, end_node, max_distance):\n if start_node is None or len(start_node) != 1:\n raise Exception('Invalid start_city: %s' % start_node)\n if end_node is None or len(end_node) != 1:\n raise Exception('Invalid end_city: %s' % end_node)\n\n queue = [(start_node, 0, [])]\n paths = []\n while queue:\n node, distance, traceback = queue.pop(0)\n\n # We do not need to parse anymore as any further city addition will break our max_hops constraint\n if distance >= max_distance:\n continue\n\n path = traceback + [node]\n if len(path) > 2 and path[-1] == end_node:\n paths.append('-'.join(path) + (' (%d distance)' % distance))\n\n for neighbour in self.graph[node].keys():\n queue.append((neighbour, distance + self.graph[node][neighbour], traceback + [node]))\n\n return paths","def linelength(l):\n return dist(l[0],l[1])","def edit_distance(str1, str2):\n # Base Case:\n if len(str1) == 0:\n return len(str2)\n if len(str2) == 0:\n return len(str1)\n \n # Other base case\n if str1[-1] == str2[-1]:\n return edit_distance(str1[:-1], str2[:-1])\n \n option1 = edit_distance(str1[:-1], str2)\n option2 = edit_distance(str1, str2[:-1])\n option3 = edit_distance(str1[:-1], str2[:-1])\n \n return min(option1, option2, option3) + 1","def length(self):\n return math.sqrt(\n (self.endpoint_a.northing - self.endpoint_b.northing) ** 2 +\n (self.endpoint_a.easting - self.endpoint_b.easting) ** 2\n )","def part_1(distances: Distances) -> int:\n\n result, _ = min(generate_routes(distances))\n print(f\"part 1: shortest route has distance {result}\")\n return result","def tour_length(tour):\n return sum(distance(tour[i], tour[i-1]) for i in range(len(tour)))","def topo_shortestpathij(self, i, j):\n pathlist = []\n self.pathij(i, j, pathlist)\n distance = []\n \n for i in range(len(pathlist)):\n distance.append(len(pathlist[i]) - 1)\n \n if(len(distance) == 0):\n return None\n else:\n return min(distance)","def path_lengths(self):\n trip_id2length = defaultdict(float)\n prev_id = 0\n cur_id = 0\n prev_lat = 0\n prev_lon = 0\n num_big_hops = 0\n big_hops = {}\n print \"Bad Distances\"\n for line in self.lines:\n #normalized = dg.normalize(line)\n normalized = normalize_simple(line)\n cur_id = normalized[0]\n lat = normalized[1]\n lon = normalized[2]\n if cur_id == prev_id:\n distance = gps_dist_miles(prev_lat,prev_lon,lat,lon)\n if distance > 1:\n big_hops[cur_id] = 1\n num_big_hops += 1\n print cur_id\n trip_id2length[cur_id] += distance \n prev_lat = lat\n prev_lon = lon\n prev_id = cur_id\n\n print len(trip_id2length.keys())\n #for bad_id in big_hops.keys():\n # del trip_id2length[bad_id]\n\n for i in (15,18,333,24,12345):\n print \"%d: %f\" % (i,trip_id2length[i])\n\n #for i in range(1,25001):\n # if i not in trip_id2length.keys():\n # print i\n num_trips = len(trip_id2length.keys())\n print num_trips\n total_len = 0.0\n for i in trip_id2length.keys():\n if trip_id2length[i] > 50:\n print \"Big trip: %d\" % i\n #del trip_id2length[i]\n total_len += trip_id2length[i]\n heap = []\n for i in trip_id2length.keys():\n heapq.heappush(heap,trip_id2length[i])\n quarter_len = num_trips/4\n for i in range(quarter_len):\n heapq.heappop(heap)\n print \"25th percentile: %f\" % heapq.heappop(heap)\n for i in range(quarter_len):\n heapq.heappop(heap)\n print \"median: %f\" % heapq.heappop(heap)\n for i in range(quarter_len):\n heapq.heappop(heap)\n print \"75th percentile: %f\" % heapq.heappop(heap)\n\n num_trips = len(trip_id2length.keys())\n print num_trips\n avg_len = total_len/num_trips\n print \"average length: %f\" % avg_len \n print \"total length %f\" % total_len\n print \"number of big hops: %d\" % num_big_hops\n return trip_id2length,avg_len","def dfs_recursive_length(self, starting_vertex, destination_vertex, visited=None, path=None):\n if visited is None:\n visited = set()\n\n if path is None:\n path = []\n\n visited.add(starting_vertex)\n new_path = list(path)\n new_path.append(starting_vertex)\n # print(\"new_path\", new_path)\n # Do the thing!\n if starting_vertex == destination_vertex:\n return new_path\n\n for neighbour in self.vertices[starting_vertex]:\n if neighbour not in visited:\n neighbour_path = self.dfs_recursive_length(\n neighbour, destination_vertex, visited, new_path)\n if neighbour_path:\n # print(neighbour_path)\n return neighbour_path","def getPathLength(self, starlist):\n sum = 0\n for i in range(len(starlist)-1):\n sum += self.getDistance(starlist[i],starlist[i+1])\n return sum","def min_path(self, start, end, maxD=1e309):\n tdist, preceding_node = self.dijkstra(start, maxD)\n dist = tdist[end]\n backpath = [end]\n try:\n while end != start:\n end = preceding_node[end]\n backpath.append(end)\n path = list(reversed(backpath))\n except KeyError:\n path = None\n\n return dist, path","def flight_path(start_city, end_city):\n airport_dictionary = read_airports()\n airport_graph = nx.Graph()\n for city, data in airport_dictionary.items():\n airport_graph.add_node(city)\n for item in data['connections']:\n try:\n travel_dist = calculate_distance(data['lat_lon'], airport_dictionary[item]['lat_lon'])\n except KeyError:\n continue\n airport_graph.add_edge(city, item, weight=travel_dist)\n path = str(nx.dijkstra_path(airport_graph, start_city, end_city))\n length = nx.dijkstra_path_length(airport_graph, start_city, end_city)\n return \"The path is: {}, covering {} miles\".format(path, length)","def find_shortest_path(self, start, end):\n\n if start==None:\n return\n\n visited = {}\n\n distance = {start:0}\n parent = {start:None}\n\n queue = deque()\n queue.append(start)\n\n while queue:\n\n cn = queue.popleft()\n\n for n in self.adjacencylist[cn]:\n if n not in visited:\n queue.append(n)\n parent[n] = cn\n if n not in distance:\n distance[n] = 1\n else:\n distance[n] += 1\n\n visited[cn] = True\n\n if all(visited.values()) == True:\n print('BFS done')\n\n print(\"Finding shortest path\")\n\n path = []\n cn = end\n path.append(cn)\n\n while cn != start:\n cn = parent[cn]\n path.append(cn)\n\n print (path[::-1])","def nsi_cross_average_path_length(self, node_list1, node_list2):\n shortest_paths = self.path_lengths()\n nsi_shortest_paths = shortest_paths + np.eye(len(shortest_paths))\n node_weights = self.node_weights\n\n Wi = sum(node_weights[node_list1])\n Wj = sum(node_weights[node_list1])\n\n w_v = np.zeros([len(node_list2), len(node_list1)])\n w_v[:] = node_weights[node_list1]\n w_q = np.zeros([len(node_list1), len(node_list2)])\n w_q[:] = node_weights[node_list2]\n\n Wij = w_v.transpose() + w_q\n nsi_cross_paths = nsi_shortest_paths[node_list1, :][:, node_list2]\n Wij = Wij[np.isinf(nsi_cross_paths)].sum()\n nsi_shortest_paths[np.isinf(nsi_shortest_paths)] = self.N - 1\n nsi_cross_paths = nsi_shortest_paths[node_list1, :][:, node_list2]\n\n Lij = np.sum(nsi_cross_paths*node_weights[node_list2], axis=1)\n Lij = np.sum(Lij * node_weights[node_list1], axis=0)\n return Lij / (Wi*Wj - Wij)","def find_minimum_path_cost(cls, start_point: Coordination, current_point: Coordination) -> int:\n return abs(start_point.x - current_point.x) + abs(start_point.y - current_point.y)","def GetEpsilonBeer(Abs, conc, pathLength):\n return Abs / (conc * pathLength)","def flightLegs(Alist,start,dest):\n Alen = len(Alist) #length of Alist\n index = list(range(Alen)) #list of airport indexes\n Adict = dict(zip(index,Alist)) #zip into dictionary\n #Adict = dict.fromkeys(range(Alen),large value) possibly qiucker?\n \n Flights = [] #output\n\n checked = [] #empty list\n tocheck = deque() #empty deque for a queue of paths to be checked\n tocheck.append([start])\n \n if start == dest: #trivial case\n return \"trivial case explored\"\n \n while tocheck: #while there are elements in tocheck\n path = tocheck.popleft() #pop out a path to be checked\n node = path[-1] #extract last element of path, this node represents an airport\n if node not in checked: #check if this path terminates in a new node/airport\n adjacents = Adict[node] #look up in dictionary airport index and return list of adjacent airports\n for n in adjacents: #extracts nodes inside list of adjacents\n if n not in checked:\n new_path = path +[n] #add neighbour to this current path\n tocheck.append(new_path) #put this new path into the queue to be checked\n if n == dest: #if this neighbour is the final destination, then the new path is the full path\n if len(Flights)==0:\n Flights.append(new_path)\n elif len(new_path)==len(Flights[-1]):\n Flights.append(new_path)\n else:\n return (len(Flights[0]),len(Flights))\n \n checked.append(node)\n\n return Flights #finds all paths need to modify to stop after a path of non shortest length is found","def shortest_tour(tours):\n return min(tours, key=tour_length)","def min_distance(graph, begin, end):\n routes = {k: \"inf\" for (k, v) in graph.items()}\n\n nodes = deque([(begin, graph[begin])])\n\n while nodes:\n\n root, _nodes = nodes.popleft()\n\n for (name, dist) in _nodes:\n # current length from begining to a node name\n _dist = routes[root] + dist if routes[root] != \"inf\" else dist\n # if length ro a node name is not defined yet - define it\n if routes[name] != \"inf\":\n routes[name] = min([routes[name], _dist])\n else:\n # else - choose which way is shorter - a new or old\n routes[name] = _dist\n\n nodes.append([name, graph[name]])\n\n return routes[end]","def lenRange(start, stop, step=1):\n return (stop - start + step - 1 + 2 * (step < 0)) // step","def path(most_important_up, most_important_down, total_distance, to_source2, to_source1):\n\n if total_distance == min(total_distance, to_source2[0], to_source1[0]):\n return source_to_source(most_important_up, most_important_down), total_distance\n elif to_source2[0] == min(total_distance, to_source2[0], to_source1[0]):\n return most_important_to_source(to_source2[1]), to_source2[0]\n else:\n return most_important_to_source(to_source1[1], up=False), to_source1[0]","def compute_min_refills(distance, tank, stops):\n\n num_refills = 0\n current_refill = 0\n\n all_stops = []\n all_stops.append(0)\n for stop in stops:\n \tall_stops.append(stop)\n all_stops.append(distance)\n\n num_stops = len(all_stops)\n\n while current_refill < num_stops:\n \tlast_refill = current_refill\n\n \twhile (current_refill < num_stops and all_stops[current_refill+1]\n \t\t - all_stops[last_refill] <= tank):\n \t\tcurrent_refill += 1\n \t\tif current_refill == num_stops-1:\n \t\t\treturn num_refills\n\n \tif current_refill == last_refill:\n \t\treturn -1\n \tif current_refill < num_stops:\n \t\tnum_refills += 1\n\n return num_refills","def get_pathlengths(inp, origin, wires):\n\n lengths = np.full(wires.shape, fill_value=np.inf) # shape (2, posx, posy), float for inf sentinel\n lengths[:, origin[0], origin[1]] = 0\n for i,line in enumerate(inp.splitlines()):\n pos = origin.copy()\n pathlen = 0\n for word in line.split(','):\n dir,length = word[0], int(word[1:])\n l = np.arange(1, length + 1)\n # need min(...) for masking, hence inf sentinel\n if dir == 'R':\n lengths[i, pos[0] + l, pos[1] + 0*l] = np.minimum(l + pathlen, lengths[i, pos[0] + l, pos[1] + 0*l])\n pos += [length, 0]\n if dir == 'L':\n lengths[i, pos[0] - l, pos[1] + 0*l] = np.minimum(l + pathlen, lengths[i, pos[0] - l, pos[1] + 0*l])\n pos += [-length, 0]\n if dir == 'U':\n lengths[i, pos[0] + 0*l, pos[1] + l] = np.minimum(l + pathlen, lengths[i, pos[0] + 0*l, pos[1] + l])\n pos += [0, length]\n if dir == 'D':\n lengths[i, pos[0] + 0*l, pos[1] - l] = np.minimum(l + pathlen, lengths[i, pos[0] + 0*l, pos[1] - l])\n pos += [0, -length]\n pathlen += length\n\n # unmask, return int array of paths\n lengths[np.isinf(lengths)] = -1\n return lengths.astype(np.uint8)","def cheapest(self, src):\n\n # This uses \"Dijkstra's algorithm\" \n # (read about it in a textbook)\n\n inf = float('inf') # infinity\n\n # for each vertex v of the graph, add an entry to the \n # queue, with the source having distance 0 and all \n # others having infinite distance\n\n d = {v: 0 if v is src else inf for v in self.cities}\n queue = {v: (cost, v) for v, cost in d.items()}\n\n cloud = {} # map reachable v to its d[v] value\n\n while queue:\n # Remove the cheapest path from the queue\n # (this won't scale well, as we're constantly \n # sorting --- better to use a priority queue,\n # at the cost of a little more complexity)\n u_cost, u = queue.pop(sorted(queue.values())[0][1])\n\n # Note the cost of this\n cloud[u] = u_cost\n\n for v, v_cost in u.flights:\n # Look for a cheaper way to make this same leg\n if v not in cloud and d[u] + v_cost < d[v]:\n d[v] = d[u] + v_cost\n queue[v] = (d[v], v)\n\n return cloud","def shortest_path(start, end):\n if start == end:\n return []\n \n start_frontier = Queue.Queue()\n start_parent = {}\n start_level = {}\n start_parent_move = {}\n start_frontier.put(start)\n start_level[start] = 0\n start_parent[start] = None\n start_parent_move[start] = None\n \n end_frontier = Queue.Queue()\n end_parent = {}\n end_level = {}\n end_parent_move = {}\n end_frontier.put(end)\n end_level[end] = 0\n end_parent[end] = None\n end_parent_move[end] = None\n \n intersectFound = False\n intersect = None\n level = 0\n while (True):\n level += 1\n# print (\"level = \" + str(level))\n if not start_frontier.empty():\n vertex = start_frontier.get()\n for move in rubik.quarter_twists:\n position = rubik.perm_apply(move,vertex)\n if position not in start_parent:\n# print (\"start permutation unvisited\")\n start_parent[position] = vertex\n start_level[position] = level\n start_parent_move[position] = move\n start_frontier.put(position)\n if position in end_parent:\n# print (\"position exists in end_parent\")\n intersect = position\n intersectFound = True\n break\n if intersectFound:\n break\n if not end_frontier.empty():\n vertex = end_frontier.get()\n for move in rubik.quarter_twists:\n position = rubik.perm_apply(move,vertex)\n if position not in end_parent:\n# print (\"end permutation unvisited\")\n end_parent[position] = vertex\n end_level[position] = level\n end_parent_move[position] = move\n end_frontier.put(position)\n if position in start_parent:\n# print (\"position exists in start_parent\")\n intersect = position\n intersectFound = True\n break\n if intersectFound:\n break\n if end_frontier.empty() and start_frontier.empty():\n break\n \n if intersect is None:\n return None\n \n path = []\n pos = intersect\n while (start_parent[pos] is not None):\n path.insert(0,start_parent_move[pos])\n pos = start_parent[pos]\n \n pos = intersect\n while (end_parent[pos] is not None):\n move = rubik.perm_inverse(end_parent_move[pos])\n path.append(move)\n pos = end_parent[pos]\n \n# path = [None] * start_level[intersect]\n# pos = intersect\n# move = start_parent_move[pos]\n# path[start_level[intersect]-1] = move\n# for i in range(start_level[intersect]-2,-1,-1):\n# if (start_parent[pos] is not None):\n# pos = start_parent[pos]\n# move = start_parent_move[pos]\n# path[i] = move\n# \n# pos = intersect\n# while (end_parent[pos] is not None):\n# move = rubik.perm_inverse(end_parent_move[pos])\n# path.append(move)\n# pos = end_parent[pos]\n \n return path","def count_paths((min_i, min_j), (max_i, max_j)):\n\n def explore((i, j), path):\n found = 0\n for (x, y) in neighbors((min_i, min_j), (max_i, max_j), (i, j)):\n if (x, y) == (max_i, max_j):\n found += 1\n debug(\"neighbor %r of node %r on path %r is a goal node: +1\" % ((x, y), (i, j), path))\n elif (x, y) in path: \n debug(\"neighbor %r of node %r already on path %r; ignoring...\" % ((x, y), (i, j), path))\n continue\n else:\n debug(\"neighbor %r of node %r not already on path %r; exploring ...\" % ((x, y), (i, j), path))\n found += explore((x, y), mkpath(path, (x, y)))\n return found\n return explore((0, 0), set([(0, 0)]))","def get_shortest_path(self, r_start, r_goal):\n neighbors = [(0, 1), (0, -1), (1, 0), (-1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]\n start = (int(r_start[0] / Map.RESOLUTION), int(r_start[1] / Map.RESOLUTION))\n goal = (int(r_goal[0] / Map.RESOLUTION), int(r_goal[1] / Map.RESOLUTION))\n close_set = set()\n came_from = {}\n gscore = {start: 0}\n fscore = {start: Map._heuristic(start, goal)}\n oheap = []\n\n heappush(oheap, (fscore[start], start))\n\n while oheap:\n current = heappop(oheap)[1]\n\n if current == goal:\n data = []\n while current in came_from:\n data.append((int((current[0] * Map.RESOLUTION) + (Map.RESOLUTION / 2)),\n int((current[1] * Map.RESOLUTION) + (Map.RESOLUTION / 2))))\n current = came_from[current]\n data.reverse()\n return data\n\n close_set.add(current)\n for i, j in neighbors:\n neighbor = current[0] + i, current[1] + j\n tentative_g_score = gscore[current] + Map._heuristic(current, neighbor)\n if 0 <= neighbor[0] < self.col_grid.shape[0]:\n if 0 <= neighbor[1] < self.col_grid.shape[1]:\n if self.col_grid[neighbor[0]][neighbor[1]] == 1:\n continue\n else:\n # array bound y walls\n continue\n else:\n # array bound x walls\n continue\n\n if neighbor in close_set and tentative_g_score >= gscore.get(neighbor, 0):\n continue\n if tentative_g_score < gscore.get(neighbor, 0) or neighbor not in [i[1] for i in oheap]:\n came_from[neighbor] = current\n gscore[neighbor] = tentative_g_score\n fscore[neighbor] = tentative_g_score + Map._heuristic(neighbor, goal)\n heappush(oheap, (fscore[neighbor], neighbor))\n\n return []","def length_plateau_at(seq, start):\n\n length = 1\n\n # INVARIANT\n # All elements in seq[start:start+length] are equal.\n # VARIANT: len(seq) - length\n #\n while (start+length < len(seq)) and\\\n (seq[start] == seq[start+length]):\n length += 1\n \n return length","def test_shortest_route_from_a_to_c(self):\n railroad = trains.Railroad()\n self.assertEqual(railroad.shortest_route_distance('A', 'C'), 9)","def shortest(house1, house2):\n \n # x coordinate 1 of house 1\n x1h1 = house1.x1\n # x 1 of house 2\n x1h2 = house2.x1\n # x 2 of house 1\n x2h1 = house1.x2\n # x 2 of house 2\n x2h2 = house2.x2\n\n # y 1 of house 1\n y1h1 = house1.y1\n # y 1 of house 2\n y1h2 = house2.y1\n # y 2 of house 1\n y2h1 = house1.y2\n # y 2 of house 2\n y2h2 = house2.y2\n \n # The first two if statements check if the houses are directly horizontal or\n # vertical to each other. (Or inside each other.) The other two if statements\n # can determine between which corners the shortest distance is located \n # otherwise.\n\n # Checks if the houses are above each other\n if x1h1 <= x1h2 <= x2h1 or x1h1 <= x2h2 <= x2h1 or x1h2 <= x1h1 <= x2h2 or x1h2 <= x2h1 <= x2h2:\n\n # Checks if the houses are next to each other\n if y1h1 <= y1h2 <= y2h1 or y1h1 <= y2h2 <= y2h1 or y1h2 <= y1h1 <= y2h2 or y1h2 <= y2h1 <=y2h2:\n \n # If they are both above and nest to each other, they must be inside\n # each other, the total distance is returned as -1\n return -1\n\n # Checks if house 2 is below house 1\n elif y1h1 > y2h2:\n \n # If so, the distance between the lower wall of house 1 and the upper\n # wall of house 2 is returned\n return y1h1 - y2h2\n\n # Checks if house 2 is above house 1\n elif y2h1 < y1h2:\n \n # If so, the distance between the upper wall of house 1 and the lower\n # wall of house 2 is returned\n return y1h2 - y2h1\n\n # Checks if the houses are next to each other\n elif y1h1 <= y1h2 <= y2h1 or y1h1 <= y2h2 <= y2h1 or y1h2 <= y1h1 <= y2h2 or y1h2 <= y2h1 <=y2h2:\n\n # Checks if house 2 is to the left of house 1\n if x1h1 > x2h2:\n \n # If so, the distance between the left wall of house 1 and the right\n # wall of house 2 is returned\n return x1h1 - x2h2\n\n # Checks if house 2 is to the right of house 1\n elif x2h1 < x1h2:\n \n # If so, the distance between the right wall of house 1 and the left\n # wall of house 2 is returned\n return x1h2 - x2h1\n\n # The rest of the statements checks between which corners the shortest \n # distance is located. This distance is calculated with Pythagoras, using\n # the coordinates of the corners in question\n\n # Checks if house 2 is to the left of house 1\n elif x1h1 > x2h2:\n\n # Checks if house 2 is below house 1\n if y1h1 > y2h2:\n \n # House 2 is located to the bottom left of house 1\n return ((y1h1 - y2h2) ** 2 + (x1h1 - x2h2) ** 2) ** 0.5\n\n # Checks if house 2 is above house 1\n elif y2h1 < y1h2:\n \n # House 2 is located to the top left of house 1\n return ((y1h2 - y2h1) ** 2 + (x1h1 - x2h2) ** 2) ** 0.5\n\n # Checks if house 2 is to the right of house 1\n elif x2h1 < x1h2:\n\n # Checks if house 2 is below house 1\n if y1h1 > y2h2:\n \n # House 2 is located to the bottom right of house 1\n return ((y1h1 - y2h2) ** 2 + (x1h2 - x2h1) ** 2) ** 0.5\n\n # Checks if house 2 is above house 1\n elif y2h1 < y1h2:\n \n # House is located to the top right of house 1\n return ((y1h2 - y2h1) ** 2 + (x1h2 - x2h1) ** 2) ** 0.5\n\n # This should never occur, but it's here as a safety net\n else:\n print(\"error\")\n return -2","def longest_path(game, player, cur_length=0, max_length=10):\n moves = game.get_legal_moves(player)\n\n # Break recursion if we reach a dead end or we're at the limit.\n if not moves or cur_length >= max_length:\n return cur_length\n # Otherwise search recursively.\n else:\n best_depth = 0\n for move in moves:\n game_copy = try_move(game, move, player)\n move_depth = longest_path(game_copy, player, cur_length + 1)\n if move_depth > best_depth:\n best_depth = move_depth\n # As soon as we're at the depth limit, there's no reason to\n # search more moves.\n if best_depth == max_length:\n return best_depth\n return best_depth","def get_path(prevs, goal, start):\n path = OD({goal: 0})\n cur = goal\n while cur != start:\n (cost, node) = prevs.get(cur)\n if node == None or node in path:\n print(\"ERROR: No path found from %s -> %s\" % (start, goal))\n return (0, None)\n path[node] = path[cur] + cost\n cur = node\n return (path[start], path.keys()[::-1])","def _shortest_path(G, start, end, sp_cache):\n if (start, end) in SP_TABLE:\n return sp_cache[(start, end)]\n elif (end, start) in SP_TABLE:\n return sp_cache[(end, start)]\n else:\n D, P = _dijkstra(G, start, end)\n path = []\n temp = end\n while 1:\n path.append(end)\n if end == start: break\n end = P[end]\n path.reverse()\n sp_cache[(start, temp)] = path\n return path","def pathcost_cooler(k=5, lam=0.0003, limit=3000):\n return lambda t: (k * exp(-lam * t) if t < limit else 0)","def trips_hop_constraint_bfs(self, start_node, end_node, hops, equal=False):\n if start_node is None or len(start_node) != 1:\n raise Exception('Invalid start_city: %s' % start_node)\n if end_node is None or len(end_node) != 1:\n raise Exception('Invalid end_city: %s' % end_node)\n\n queue = [(start_node, 0, [])]\n paths = []\n while queue:\n node, depth, traceback = queue.pop(0)\n\n # We do not need to parse anymore as any further city addition will break our max_hops constraint\n if depth > hops:\n continue\n\n path = traceback + [node]\n if len(path) > 2 and path[-1] == end_node:\n if equal:\n if depth == hops:\n paths.append('-'.join(path) + (' (%d hops)' % depth))\n else:\n paths.append('-'.join(path) + (' (%d hops)' % depth))\n\n for neighbour in self.graph[node].keys():\n queue.append((neighbour, depth + 1, traceback + [node]))\n\n return paths","def solution(src, dest):\n # Define a board position lookup table\n board = [[0, 1, 2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13, 14, 15],\n [16, 17, 18, 19, 20, 21, 22, 23], [24, 25, 26, 27, 28, 29, 30, 31],\n [32, 33, 34, 35, 36, 37, 38, 39], [40, 41, 42, 43, 44, 45, 46, 47],\n [48, 49, 50, 51, 52, 53, 54, 55], [56, 57, 58, 59, 60, 61, 62, 63]]\n\n # Constant value for square board dimensions\n N = 8\n\n src_node = None\n dest_node = None\n\n # Get the x, y positions of src and dest cells\n for x in range(N):\n for y in range(N):\n if board[x][y] == src:\n src_node = Node(x, y)\n if board[x][y] == dest:\n dest_node = Node(x, y)\n\n # Search for the shortest path from src to dest and compute it's length\n path_length = search(src_node, dest_node, N)\n print(path_length)\n return path_length","def heuristic_1(node):\n x_node, y_node = node.state.location()\n goals = node.state.grid.components.white_walkers\n goals.append(node.state.grid.components.dragon_stone)\n distance = [np.sqrt((x_node - x)**2 + (y_node - y)**2) for x, y in goals]\n return distance[np.argmin(distance)]","def get_steps_of_closest_intersections(commands1, commands2):\n\n path1 = get_one_path(commands1)\n path2 = get_one_path(commands2)\n intersections = set(path1).intersection(set(path2))\n # index is 0 based, therefore +2\n return min(map(lambda x: path1.index(x) + path2.index(x), intersections)) + 2","def length(self):\n points = [Point(v, crs=self.crs) for v in self.vertices]\n distances = [a.distance(b) for a, b in zip(points[:-1], points[1:])]\n return sum(distances)","def get_length(self, start_length):\n\n id_shape = 0\n for shape in self.shapes:\n if len(str(id_shape)) > start_length[0]:\n start_length[0] = len(str(id_shape))\n if len(shape.__class__.__name__) > start_length[1]:\n start_length[1] = len(shape.__class__.__name__)\n if start_length[2] < len(shape.__str__()):\n start_length[2] = len(shape.__str__())\n if len(str(round(shape.perimeter, 2))) > start_length[3]:\n start_length[3] = len(str(round(shape.perimeter, 2)))\n if len(shape.perimeter_formula) > start_length[4]:\n start_length[4] = len(shape.perimeter_formula)\n if len(str(round(shape.area, 2))) > start_length[5]:\n start_length[5] = len(str(round(shape.area, 2)))\n if len(shape.area_formula) > start_length[6]:\n start_length[6] = len(shape.area_formula)\n id_shape += 1\n return start_length","def shortest_flight(g):\n min_distance = sys.maxsize\n min_destination = None\n min_key = None\n \n for key in g.city_dict:\n for flight in g.city_dict[key].get_flights_out():\n if(flight[1] < min_distance):\n min_key = key\n min_destination = flight[0]\n min_distance = flight[1]\n return g.city_dict[min_key].get_name(), min_destination, min_distance","def DFS(graph, start, end, path, shortest,shortest_path_length,shortest_out_dist,\\\r\n pathlength,maxOutdistance,toPrint = False):\r\n \r\n \r\n path = path + [start]\r\n totalpathlength=getTotalPathLength(path)\r\n outerpathlength=getOutPathLength(path)\r\n \r\n \r\n if toPrint:\r\n pass \r\n \r\n if start == end and outerpathlength<=maxOutdistance and (totalpathlength <= shortest_path_length):\r\n print('A Shorter Path found',path,[totalpathlength],[outerpathlength])\r\n return path\r\n for node in graph.childrenOf(start):\r\n if node not in path: #avoid cycles\r\n \r\n \r\n \r\n if shortest== None or totalpathlength <= shortest_path_length:\r\n if totalpathlength <shortest_path_length and outerpathlength<=maxOutdistance :\r\n newPath = DFS(graph, node, end, path, shortest, shortest_path_length,\\\r\n shortest_out_dist,pathlength, maxOutdistance, toPrint)\r\n \r\n if newPath != None:\r\n \r\n shortest = newPath\r\n shortest_path_length=getTotalPathLength(shortest)\r\n shortest_out_dist=getOutPathLength(shortest)\r\n \r\n\r\n \r\n return shortest","def find_shortest_path(self, start, end, path=[]):\n path = path+[start]\n if start == end:\n return path\n shortest_path = []\n for node in self.graph[start]:\n if node not in path:\n newpath = self.find_path(node, end, path)\n if not shortest_path or len(shortest_path) > len(newpath):\n shortest_path = newpath\n return shortest_path if shortest_path else None"],"string":"[\n \"def shortest_path_lengths(self, g, src):\\n d = {} # d[v] is upper bound from s to v\\n cloud = {} # map reachable v to its d[v] value\\n pq = AdaptableHeapPriorityQueue() # vertex v will have key d[v]\\n pqlocator = {} # map from vertex to its pq locator\\n\\n # for each vertex v of the graph, add an entry to the priority queue, with\\n # the source having distance 0 and all others having infinite distance\\n for v in g.vertices():\\n if v is src:\\n d[v] = 0\\n else:\\n d[v] = float('inf') # syntax for positive infinity\\n pqlocator[v] = pq.add(d[v], v) # save locator for future updates\\n\\n while not pq.is_empty():\\n key, u = pq.remove_min()\\n cloud[u] = key # its correct d[u] value\\n del pqlocator[u] # u is no longer in pq\\n for e in g.incident_edges(u): # outgoing edges (u,v)\\n v = e.opposite(u)\\n if v not in cloud:\\n # perform relaxation step on edge (u,v)\\n wgt = e.element()\\n if d[u] + wgt < d[v]: # better path to v?\\n d[v] = d[u] + wgt # update the distance\\n pq.update(pqlocator[v], d[v], v) # update the pq entry\\n\\n return cloud # only includes reachable vertices\",\n \"def path_lengths(graph):\\n allPairsPathLengths = dict(nx.all_pairs_dijkstra_path_length(graph, weight='lgth'))\\n shortestPathLength = np.array([[length for length in pair.values()] for pair in allPairsPathLengths.values()])\\n shortestPathLength = np.tril(shortestPathLength)\\n shortestPathLength[shortestPathLength == 0] = np.nan\\n return(shortestPathLength)\",\n \"def numShortestPaths(g, start, end):\\n if g == None or start == None or end == None:\\n raise InvalidInputException(\\\"Input is null.\\\")\\n if not g.containsVertex(start) or not g.containsVertex(end):\\n raise InvalidInputException(\\\"Doesn't contain source.\\\")\\n nodes = []\\n nodes.append(start)\\n # Adds two decorations to the vertices\\n for node in g.iterVertices():\\n node.minCount = float(\\\"inf\\\")\\n node.numCount = 0\\n start.minCount = 0\\n while not len(nodes) == 0:\\n node = nodes.pop(0)\\n # Base case: if node is the end node, return the numCount decoration\\n if node == end:\\n return node.numCount\\n # Decorates neighboring nodes and adds them to the list\\n for edge in g.incidentEdges(node):\\n new_node = g.opposite(node,edge)\\n if new_node.minCount == float(\\\"inf\\\"):\\n new_node.minCount = node.minCount+1\\n nodes.append(new_node)\\n if new_node.minCount == node.minCount + 1:\\n new_node.numCount = node.numCount + 1\",\n \"def shortestPathLength(self, graph: List[List[int]]) -> int:\\n n = len(graph)\\n steps = 0\\n all_visited = (1<<n)-1\\n queue = [(i, 1<<i) for i in range(n)]\\n visited_status = set(queue)\\n while queue:\\n new_queue = []\\n for i, visited in queue:\\n if visited == all_visited:\\n return steps\\n for j in graph[i]:\\n status = (j, visited | (1<<j))\\n if status not in visited_status:\\n visited_status.add(status)\\n new_queue.append(status)\\n steps += 1\\n queue = new_queue\\n\\n return -1\",\n \"def length(self):\\n return self.endpoints[0].distance_to(self.endpoints[1])\",\n \"def count_paths_staircase(length_staircase, possible_actions):\\n path = [0] * length_staircase\\n # First we add our possible_actions to our path count\\n for i in possible_actions:\\n path[i - 1] = 1\\n # Compute number of path combinations to every step\\n for i in range(length_staircase):\\n for j in possible_actions:\\n k = i + j\\n if k >= length_staircase:\\n continue\\n path[k] += path[i]\\n return path\",\n \"def __len__(self):\\r\\n return int(np.ceil(len(self.pathways) / float(self.batch_size)))\",\n \"def dist(gene1, gene2):\\n return abs(len(gene1.goal) - len(gene2.goal))\",\n \"def solution(map):\\n # length[i][j] = the length of the shortest path from (i,j) to (w-1,h-1).\\n # Modify the current location to -1 and continue searching from adjacent spaces.\\n return Maze(map).shortest_length()\",\n \"def shortestPathLength(self, graph):\\n # binary representation of a state of which nodes visited.\\n ans = (1 << len(graph)) - 1\\n\\n # typical template for bfs; initil\\n qe = []\\n visited = set()\\n for i in range(len(graph)):\\n qe.append((i, 1 << i))\\n visited.add((i, 1 << i))\\n\\n moves = 0\\n while qe:\\n size = len(qe)\\n while size > 0:\\n size -= 1\\n # queue: FIFO\\n n, vnodes = qe.pop(0)\\n if vnodes == ans:\\n return moves\\n neighbors = graph[n]\\n for neighbor in neighbors:\\n nvnodes = (vnodes | 1 << neighbor)\\n if (neighbor, nvnodes) in visited:\\n continue\\n qe.append((neighbor, nvnodes))\\n visited.add((neighbor, nvnodes))\\n moves += 1\\n return -1\",\n \"def shortestPathLength(self, graph: List[List[int]]) -> int:\\n n = len(graph)\\n # Floyd-Warshall\\n g = [[float('inf')]*n for _ in range(n)]\\n for i, js in enumerate(graph):\\n for j in js:\\n g[i][j] = 1\\n for k in range(n):\\n for i in range(n):\\n for j in range(n):\\n if i == j:\\n g[i][j] = 0\\n else:\\n g[i][j] = min(g[i][j], g[i][k] + g[k][j])\\n\\n # dfs\\n @lru_cache(None)\\n def dfs(i, remain):\\n if remain == 0:\\n return 0\\n ret = float('inf')\\n for j, d in enumerate(g[i]):\\n if remain&(1<<j) != 0:\\n ret = min(ret, d + dfs(j, remain ^ (1<<j)))\\n return ret\\n\\n full_mask = (1<<n)-1\\n return min(dfs(i, full_mask^(1<<i)) for i in range(n))\",\n \"def path_length(self, u, v):\\n mrca = self.mrca(u, v)\\n if mrca == -1:\\n return math.inf\\n return self.depth(u) + self.depth(v) - 2 * self.depth(mrca)\",\n \"def get_reached(g, source, hops, timeout):\\n\\n paths = nx.single_source_shortest_path(g, source, hops)\\n total = len(paths)\\n reached = total\\n\\n for v in paths.itervalues():\\n for i in range(1, len(v)):\\n lat = g[v[i-1]][v[i]][\\\"latency\\\"]\\n if lat > timeout:\\n reached -= 1\\n break\\n\\n return float(reached)/float(total)\",\n \"def evaluatePath(self):\\n pathLength = 0\\n if len(self.path) > 0:\\n previousCity = self.path[0]\\n for ind in range(1, len(self.path)):\\n pathLength += previousCity.distanceWith(self.path[ind].name)\\n previousCity = self.path[ind]\\n return pathLength\",\n \"def shortest_combined_wire_path(grid):\\n current_minimum = sys.maxsize\\n\\n for crossing in grid.crossings:\\n crossing_wires = grid.get(crossing[0], crossing[1])\\n \\n crossing_total = 0\\n for wire in crossing_wires:\\n crossing_total += wire['distance']\\n\\n if crossing_total < current_minimum:\\n current_minimum = crossing_total\\n\\n print(f\\\"Total length of wire at {crossing} is {crossing_total}\\\")\\n return current_minimum\",\n \"def computeShortestPathCoherence(node1, node2, w):\\n\\n\\tif node1.strip()==node2.strip():\\n\\t\\treturn w\\n\\n\\tfromCache=rds.get(\\\"%s:%s\\\" % (node1, node2))\\n\\tif fromCache:\\n\\t\\treturn float(fromCache)*w\\n\\telse:\\n\\t\\tg = Graph()\\n\\t\\tq=\\\"MATCH path=shortestPath((m:Page {name:\\\\\\\"%s\\\\\\\"})-[LINKS_TO*1..10]-(n:Page {name:\\\\\\\"%s\\\\\\\"})) RETURN LENGTH(path) AS length, path, m, n\\\" % (node1, node2)\\n\\n\\t\\tcursor=g.run(q)\\n\\t\\tpath=None\\n\\t\\tfor c in cursor:\\n\\t\\t\\tpath=c\\n\\n\\t#\\n\\t\\tif path:\\n\\t\\t\\trds.set(\\\"%s:%s\\\" % (node1, node2), 1/path[\\\"length\\\"])\\n\\t\\t\\trds.set(\\\"%s:%s\\\" % (node2, node1), 1/path[\\\"length\\\"])\\n\\t\\t\\treturn w/path[\\\"length\\\"]\\n\\t\\telse:\\n\\t\\t\\trds.set(\\\"%s:%s\\\" % (node1, node2), 0.0)\\n\\t\\t\\trds.set(\\\"%s:%s\\\" % (node2, node1), 0.0)\\n\\t\\t\\treturn 0.0\",\n \"def mostLikelyPath(self, start, length=100):\\n path = [start]\\n for step in range(length):\\n bestValue = -100000000\\n bestAction = None\\n for action in range(self.A):\\n pathValue = self.valueLookAhead(path[-1][0], [1], action)\\n # print((self.stateToCoord[nextState[0]], pathValue))\\n if pathValue > bestValue:\\n bestValue = pathValue\\n bestAction = action\\n possibleNextStates = self.trans(path[-1][0], path[-1][1])[bestAction]\\n path.append(randomSample(possibleNextStates))\\n return path\",\n \"def compute_min_refills(distance: int, tank: int, stops: List[int]):\\n location: int = 0\\n n_stops = 0\\n last_stop = 0\\n max_drive = location + tank\\n\\n while max_drive < distance:\\n counter = 0\\n\\n # Handle the case that stops are depleted before we reach distance\\n if len(stops) == 0:\\n return -1\\n for s in stops:\\n if s <= max_drive:\\n counter += 1\\n last_stop = s\\n max_drive = last_stop + tank\\n\\n # Handle the case that wi did not reach the next stop\\n if counter == 0:\\n return -1\\n else:\\n del stops[0:counter]\\n n_stops += 1\\n\\n return n_stops\",\n \"def length(self) -> float:\\n n = len(self.milestones[0])//2\\n third = 1.0/3.0\\n def distance(x,y):\\n cp0 = x[:n]\\n cp1 = vectorops.madd(cp0,x[n:],third)\\n cp3 = y[:n]\\n cp2 = vectorops.madd(cp3,y[n:],-third)\\n return third*vectorops.norm(x[n:]) + vectorops.distance(cp1,cp2) + third*vectorops.norm(y[n:])\\n return Trajectory.length(self,distance)\",\n \"def __len__(self):\\n return self.start.dist(self.end)\",\n \"def length(self) -> float:\\n n = self.geodesic.extrinsicDimension()\\n third = 1.0/3.0\\n def distance(x,y):\\n cp0 = x[:n]\\n cp1 = self.geodesic.integrate(cp0,vectorops.mul(x[n:],third))\\n cp3 = y[:n]\\n cp2 = self.geodesic.integrate(cp3,vectorops.mul(y[n:],-third))\\n return self.geodesic.distance(cp0,cp1) + self.geodesic.distance(cp1,cp2) + self.geodesic.distance(cp2,cp3)\\n return Trajectory.length(self,distance)\",\n \"def distance( self, source, target ):\\n return nx.shortest_path_length(self._G, source, target)\",\n \"def cable_length(self):\\n skel = self.physical_space(copy=False)\\n\\n v1 = skel.vertices[skel.edges[:,0]]\\n v2 = skel.vertices[skel.edges[:,1]]\\n\\n delta = (v2 - v1)\\n delta *= delta\\n dist = np.sum(delta, axis=1)\\n dist = np.sqrt(dist)\\n\\n return np.sum(dist)\",\n \"def solution(s, v, dist, pred):\\n path = [v]\\n total = dist[v]\\n while v != s:\\n v = pred[v]\\n path.insert(0, v)\\n return \\\"length=\\\" + str(total) + \\\" \\\" + str(path)\",\n \"def solve(k=[]):\\n if len(k) < 2:\\n return 1\\n min_jumps = len(k)\\n for i in reversed(range(k[0])):\\n if i > len(k):\\n return 1\\n if k[i] != 0:\\n sub_jumps = solve(k[i + 1 :])\\n min_jumps = min(min_jumps, sub_jumps)\\n return min_jumps\",\n \"def length_dist(self,synset_1, synset_2):\\n\\t l_dist = sys.maxsize\\n\\t if synset_1 is None or synset_2 is None: \\n\\t return 0.0\\n\\t if synset_1 == synset_2:\\n\\t # if synset_1 and synset_2 are the same synset return 0\\n\\t l_dist = 0.0\\n\\t else:\\n\\t wset_1 = set([str(x.name()) for x in synset_1.lemmas()]) \\n\\t wset_2 = set([str(x.name()) for x in synset_2.lemmas()])\\n\\t if len(wset_1.intersection(wset_2)) > 0:\\n\\t # if synset_1 != synset_2 but there is word overlap, return 1.0\\n\\t l_dist = 1.0\\n\\t else:\\n\\t # just compute the shortest path between the two\\n\\t l_dist = synset_1.shortest_path_distance(synset_2)\\n\\t if l_dist is None:\\n\\t l_dist = 0.0\\n\\t # normalize path length to the range [0,1]\\n\\t return math.exp(-self.ALPHA * l_dist)\",\n \"def nb_simple_paths(self, start, end):\\n if start not in self.nodes or end not in self.nodes:\\n return None\\n\\n visited = set()\\n nb_paths = 0\\n\\n def search(node, goal):\\n nonlocal nb_paths\\n visited.add(node)\\n\\n if node == goal:\\n nb_paths += 1\\n else:\\n for neighbor in self.nodes[node]:\\n if neighbor not in visited:\\n search(neighbor, goal)\\n\\n visited.remove(node)\\n\\n search(start, end)\\n return nb_paths\",\n \"def getPathLength(self, path):\\r\\n path_nodes = path\\r\\n # print(path_nodes)\\r\\n total_length = 0 # km\\r\\n for i in range(len(path_nodes)-1):\\r\\n next_edge = None\\r\\n for edge in self.graph.getAdj(path_nodes[i]):\\r\\n if edge.getExtremityNode() == path_nodes[i+1]:\\r\\n next_edge = edge\\r\\n if next_edge is None: # it means the path is invalid\\r\\n return None\\r\\n total_length += next_edge.getWeight()\\r\\n # print(next_edge.getTravelType(), end=\\\" \\\")\\r\\n return total_length\",\n \"def shortest_distance(self, begin, end):\\n\\n begin_index = self._cell_indexes[begin]\\n end_index = self._cell_indexes[end]\\n\\n distance = self._distance_mat[begin_index, end_index]\\n # distance *= pq.meter\\n\\n path = [begin]\\n inv_index = {v: k for k, v in self._cell_indexes.items()}\\n while True:\\n next_index = self._preds[end_index, begin_index]\\n if next_index == -9999:\\n break\\n\\n begin_index = next_index\\n\\n seg = inv_index[next_index]\\n path.append(seg)\\n\\n return distance, path\",\n \"def shortestPath(haystack, needle):\\n if needle == haystack:\\n return 0\\n hyponyms = haystack.hyponyms()\\n if len(hyponyms) > 0:\\n return 1 + min([shortestPath(hypo, needle) for hypo in hyponyms])\\n else:\\n return 1000\",\n \"def shortest_path_distance(self, other):\\n if self == other:\\n return 0\\n\\n paths = self.shortest_path(other)\\n return None if paths == [] else len(paths[0]) - 1\",\n \"def shortest_route(self, start, end):\\n if start not in self.nodes or end not in self.nodes:\\n return None\\n\\n previous = {}\\n unvisited = set(self.nodes.keys())\\n distance = {n: maxsize for n in unvisited}\\n\\n distance[start] = 0\\n\\n while unvisited:\\n u = min(unvisited, key=distance.get)\\n if distance[u] == maxsize:\\n return None\\n if u == end:\\n break\\n unvisited.remove(u)\\n\\n for neighbor in self.nodes[u]:\\n if neighbor not in unvisited:\\n continue\\n\\n d = distance[u] + self.edges[u, neighbor]\\n if neighbor not in distance or d < distance[neighbor]:\\n distance[neighbor] = d\\n previous[neighbor] = u\\n\\n sequence = [end]\\n u = end\\n while u in previous:\\n u = previous[u]\\n sequence.append(u)\\n sequence.reverse()\\n return sequence, distance[end]\",\n \"def dist_to_stop(speed):\\n return speed ** 2 / 4\",\n \"def OptimalWarpingPath( self, colStart=None ):\\n rows = len(self.D)\\n cols = len(self.D[0])\\n n = rows-1\\n m = cols-1\\n if colStart:\\n m=colStart\\n path = [(n,m)]\\n while n > 0 or m > 0:\\n if n == 0 :\\n path.insert(0,(0,m-1))\\n m -= 1\\n elif m == 0 :\\n path.insert(0,(n-1,0))\\n n -= 1\\n else:\\n minStep = min( self.D[n-1][m-1], self.D[n-1][m], self.D[n][m-1] )\\n if self.D[n-1][m-1] == minStep:\\n path.insert(0,(n-1,m-1))\\n n -= 1\\n m -= 1\\n elif self.D[n-1][m] == minStep:\\n path.insert(0,(n-1,m))\\n n -= 1\\n else: # self.D[n][m-1] == min:\\n path.insert(0,(n,m-1))\\n m -= 1\\n return path, self.CostOfPath( path, self.D )\",\n \"def path_cost(path):\\n return len(path)\",\n \"def path(l_s, l_f, leg_list):\\n # candidates =\\n return min(heuristic_path([l_s], l_f, leg_list, []), key = len)\",\n \"def solution(path):\\n pos = (0, 0)\\n\\n vector_path = [VECTORS[stepdir] for stepdir in path]\\n\\n max_from_start = 0\\n for v in vector_path:\\n pos = (pos[0] + v[0], pos[1] + v[1])\\n max_from_start = max(max_from_start, hex_distance((0, 0), pos))\\n if pos == (0, 0):\\n # ended up back at start\\n return 0\\n # find shortest path from (0,0) to pos\\n return hex_distance((0, 0), pos), max_from_start\",\n \"def shortest_flight(self):\\r\\n distance = sys.maxsize\\r\\n for code, _list in self.edges.items():\\r\\n for edge in _list:\\r\\n if edge.distance < distance:\\r\\n distance = edge.distance\\r\\n start = edge.start\\r\\n destination = edge.destination\\r\\n return start, destination, distance\",\n \"def get_shortest_route_floyd(network, start,destination, excludings=[]):\\n\\n # On récupère la liste des villes\\n list_city = network[1].keys()\\n \\n # Si la ville de départ ou de fin n'existe pas\\n if start not in list_city or destination not in list_city:\\n return None\\n\\n # On retire les villes à exclure\\n list_city = [x for x in list_city if x not in excludings]\\n\\n\\n # Initialisation de se qu'on a besoin\\n matrix = []\\n distance = []\\n n = len(list_city)\\n\\n \\n # On construit la matrice adjacente où indique la distance si il existe une autoroute entre 2 villes\\n for x in range(n): \\n matrix.append( [] )\\n distance.append( [] )\\n for y in range(n):\\n road_id = get_road_to(network,list_city[x],list_city[y])\\n if road_id != None:\\n matrix[x].append( get_length(network,road_id) )\\n else:\\n matrix[x].append( None )\\n distance[x].append( [road_id] ) # Autoroute -> format: ['LA']\\n\\n\\t \\n # Algorithme de Floyd\\n for k in range(n):\\n for i in range(n):\\n for j in range(n):\\n if ( matrix[i][k] != None and matrix[k][j] != None ) and ( ( matrix[i][j] == None ) or ( matrix[i][j] > matrix[i][k] + matrix[k][j] ) ):\\n matrix[i][j] = matrix[i][k] + matrix[k][j]\\n\\t\\t \\n\\t\\t # Hors Floyd / Ajout personnel\\n if i != k and j != k: # Si i == k ou j == k, cela veut dire qu'on additionne un résultat supplémentaire à la case ij\\n distance[i][j] = [] # Sinon ca signifie qu'on a trouvé un chemin plus court, du coup on supprime l'ancien chemin\\n distance[i][j].extend( distance[i][k] ) # Chemin d'autoroute parcouru en plus -> format: ['LA','AH']\\n distance[i][j].extend( distance[k][j] ) # Chemin d'autoroute parcouru en plus -> format: ['LA','AH']\\n\\n\\t\\t \\n # On récupère simplement la liste des autoroutes parcourus\\n idx_start = list_city.index( start )\\n idx_destination = list_city.index( destination )\\n distance_minimum = distance[ idx_start ][ idx_destination ]\\n\\n \\n # Si on ne trouve aucune solution, on renvoie None\\n if distance_minimum == [None]:\\n distance_minimum = None\\n \\n return distance_minimum\",\n \"def calculateWireLenght(path_list):\\n\\n total_length = 0\\n for path in path_list:\\n total_length += len(path)\\n return total_length\",\n \"def ab_path_length(trajectory, a, b):\\n a_idx = find_closest_index(trajectory, a)\\n b_idx = find_closest_index(trajectory, b)\\n path = trajectory[a_idx:b_idx]\\n step_dists = np.linalg.norm(np.diff(path, axis=0, prepend = np.array([[0,0]])), axis = 1)\\n path_length = np.sum(step_dists)\\n\\n return(path_length)\",\n \"def shortest_steps(connectors: List[int]):\\n connectors = sorted(connectors)\\n return [nxt-prv for prv, nxt in zip([0]+connectors, connectors)] + [3]\",\n \"def longest_flight(self):\\r\\n distance = 0\\r\\n for code, _list in self.edges.items():\\r\\n for edge in _list:\\r\\n if edge.distance > distance:\\r\\n distance = edge.distance\\r\\n start = edge.start\\r\\n destination = edge.destination\\r\\n return start, destination, distance\",\n \"def get_k_shortest_paths(env: RailEnv,\\n source_position: Tuple[int, int],\\n source_direction: int,\\n target_position=Tuple[int, int],\\n k: int = 1, debug=False) -> List[Tuple[Waypoint]]:\\n\\n # P: set of shortest paths from s to t\\n # P =empty,\\n shortest_paths: List[Tuple[Waypoint]] = []\\n\\n # countu: number of shortest paths found to node u\\n # countu = 0, for all u in V\\n count = {(r, c, d): 0 for r in range(env.height) for c in range(env.width) for d in range(4)}\\n\\n # B is a heap data structure containing paths\\n # N.B. use OrderedSet to make result deterministic!\\n heap: OrderedSet[Tuple[Waypoint]] = OrderedSet()\\n\\n # insert path Ps = {s} into B with cost 0\\n heap.add((Waypoint(source_position, source_direction),))\\n\\n # while B is not empty and countt < K:\\n while len(heap) > 0 and len(shortest_paths) < k:\\n if debug:\\n print(\\\"iteration heap={}, shortest_paths={}\\\".format(heap, shortest_paths))\\n # – let Pu be the shortest cost path in B with cost C\\n cost = np.inf\\n pu = None\\n for path in heap:\\n if len(path) < cost:\\n pu = path\\n cost = len(path)\\n u: Waypoint = pu[-1]\\n if debug:\\n print(\\\" looking at pu={}\\\".format(pu))\\n\\n # – B = B − {Pu }\\n heap.remove(pu)\\n # – countu = countu + 1\\n\\n urcd = (*u.position, u.direction)\\n count[urcd] += 1\\n\\n # – if u = t then P = P U {Pu}\\n if u.position == target_position:\\n if debug:\\n print(\\\" found of length {} {}\\\".format(len(pu), pu))\\n shortest_paths.append(pu)\\n\\n # – if countu ≤ K then\\n # CAVEAT: do not allow for loopy paths\\n elif count[urcd] <= k:\\n possible_transitions = env.rail.get_transitions(*urcd)\\n if debug:\\n print(\\\" looking at neighbors of u={}, transitions are {}\\\".format(u, possible_transitions))\\n # for each vertex v adjacent to u:\\n for new_direction in range(4):\\n if debug:\\n print(\\\" looking at new_direction={}\\\".format(new_direction))\\n if possible_transitions[new_direction]:\\n new_position = get_new_position(u.position, new_direction)\\n if debug:\\n print(\\\" looking at neighbor v={}\\\".format((*new_position, new_direction)))\\n\\n v = Waypoint(position=new_position, direction=new_direction)\\n # CAVEAT: do not allow for loopy paths\\n if v in pu:\\n continue\\n\\n # – let Pv be a new path with cost C + w(u, v) formed by concatenating edge (u, v) to path Pu\\n pv = pu + (v,)\\n # – insert Pv into B\\n heap.add(pv)\\n\\n # return P\\n return shortest_paths\",\n \"def part_2(distances: Distances) -> int:\\n\\n result, _ = max(generate_routes(distances))\\n print(f\\\"part 2: longest route has distance {result}\\\")\\n return result\",\n \"def get_distance(start, end):\\n\\n\\t\\tloc_start, loc_end, dst_node = create_distance(start, end)\\n\\t\\tdistance = cmds.getAttr(\\\"%s.distance\\\" % dst_node)\\n\\n\\t\\tcmds.delete([loc_start, loc_end, dst_node])\\n\\n\\t\\treturn distance\",\n \"def ApproxConc280(Abs, pathLength = 10):\\n pass\",\n \"def DFS1(digraph, start, end, path, maxTotalDist, maxDistOutdoors):\\n listP=[]\\n path = path + [start]\\n #print 'Current dfs path:', printPath(path)\\n if start == end:\\n listP.append(path)\\n for node in digraph.childrenOf(start):\\n if node not in path: #avoid cycles\\n newPath = DFS1(digraph,node,end,path, maxTotalDist, maxDistOutdoors)\\n if newPath != None:\\n if outDisAdd(digraph, newPath) <maxDistOutdoors:\\n listP.append(newPath)\\n if listP==[]:\\n raise ValueError\\n else:\\n return whichShortest(digraph, listP, maxTotalDist )\",\n \"def slice_length(start, stop, step):\\n return (stop - start + step - 1) // step\",\n \"def length(self) -> float:\\n return pos.distance(self.start, self.end)\",\n \"def path_cost(self, c, state1, action, state2):\\n # print(c)\\n accao, direcao = action.split()\\n if accao == WALK:\\n return c + 1\\n elif accao == PUSH:\\n return c + 1\",\n \"def compute_shortest_routes(start_ids, dest_ids, G):\\n return ox.distance.shortest_path(G, start_ids, dest_ids, weight='travel_time', cpus=6)\",\n \"def leg_length(self, *args):\\n i, j = args\\n return Partition(list(self)).leg_length(i-1, j-1)\",\n \"def dikjistra(start, conex, target):\\n\\tind = list(set([con[0] for con in conex] + [con[1] for con in conex]))\\n\\tt = len(ind)\\n\\tmaxi = sum([con[2] for con in conex])\\n\\tdist = [maxi for ii in range(t)]\\n\\tcheck = [0 for ii in range(t)]\\n\\tdist[ind.index(start)]=0\\n\\t#print 'INDEX: ', ind\\n\\twhile True:\\n\\t\\tmini = maxi + 1\\n\\t\\tpos = -1\\n\\t\\tfor ii in range(t):\\n\\t\\t\\tif (dist[ii]<mini and check[ii]==0):\\n\\t\\t\\t\\tpos = ii\\n\\t\\t\\t\\tmini = dist[ii]\\n\\t\\tif (pos == -1):\\n\\t\\t\\treturn False\\n\\t\\tif ind[pos] == target:\\n\\t\\t\\treturn dist[pos]\\n\\t\\tfor aa, bb, dd in conex:\\n\\t\\t\\taaa, bbb = ind.index(aa), ind.index(bb)\\n\\t\\t\\tif aaa==pos and check[bbb]==0:\\n\\t\\t\\t\\tdist[bbb] = min(dist[bbb], dist[pos] + dd)\\n\\t\\t\\tif bbb==pos and check[aaa]==0:\\n\\t\\t\\t\\tdist[aaa] = min(dist[aaa], dist[pos] + dd)\\n\\t\\tcheck[pos] = 1\\n\\t\\t#print 'Vert, ', ind[pos], 'Distances, ', dist\",\n \"def get_number_of_paths(node, x, y, current_player):\\n paths = 0\\n\\n if current_player == PLAYER_A:\\n # Possible downwards path\\n if y != node.board_size - 1:\\n for i in range(1, node.board_size - y):\\n if node.board[y+i][x] != BLANK_SPACE_CHAR :\\n break\\n elif y + i == node.board_size - 1: \\n paths += 1\\n break \\n\\n # Possible downwards-right path\\n if x != node.board_size - 1 and y != node.board_size - 1:\\n limit = min([node.board_size - x, node.board_size - y])\\n for i in range(1, limit):\\n if node.board[y+i][x+i] != BLANK_SPACE_CHAR:\\n break \\n elif y + i == node.board_size - 1: \\n paths += 1\\n break \\n\\n # Possible downwards-left path\\n if x != 0 and y != node.board_size - 1:\\n limit = min([x + 1, node.board_size - y])\\n for i in range(1, limit):\\n if node.board[y+i][x-i] != BLANK_SPACE_CHAR:\\n break \\n elif y + i == node.board_size - 1: \\n paths += 1\\n break \\n\\n else:\\n # Possible upwards path\\n if y != 0:\\n for i in range(1, y + 1):\\n if node.board[y- i][x] != BLANK_SPACE_CHAR:\\n break \\n elif y - i == 0: \\n paths += 1\\n break \\n\\n # Possible upwards-right path\\n if x != node.board_size - 1 and y != 0:\\n limit = min([node.board_size - x, y + 1])\\n for i in range(1, limit):\\n if node.board[y-i][x+i] != BLANK_SPACE_CHAR:\\n break \\n elif x + i == node.board_size - 1 or y - i == 0: \\n paths += 1\\n break \\n\\n # Possible upwards-left path\\n if x != 0 and y != 0:\\n limit = min([x + 1, y + 1])\\n for i in range(1, limit):\\n if node.board[y-i][x-i] != BLANK_SPACE_CHAR:\\n break \\n elif x - i == 0 or y - i == 0: \\n paths += 1\\n break \\n\\n return paths\",\n \"def longest_path_callback(self, data):\\n min_idx = self.find_minimum_distance(data.poses) # closest point index\\n if min_idx is None:\\n return\\n else:\\n # extract 20 points along the closest point\\n # use z position of ego car since z displacement doesn't matter\\n # truncate if encounter head or tail\\n path_points = np.array([\\n (pose.pose.position.x, pose.pose.position.y, self.car_pos[2])\\n for pose in data.poses[max(min_idx-10, 0):min_idx+10]]\\n )\\n # use svd to find the approximate tangent direction of longest path\\n approx_dir = np.linalg.svd(path_points-np.mean(path_points,axis=0))[2][0]\\n self.last_yaw_longestpath = np.arctan2(approx_dir[1], approx_dir[0])\\n # perpendicular distance is then the norm of vector\\n # (car_pos - pos_point) x approx_dir, x is cross product\\n self.last_dist_longestpath = np.linalg.norm(\\n np.cross(path_points[0,:] - self.car_pos, approx_dir)\\n )\\n # publish\\n self.pub_closest_dist_longestpath.publish(self.last_dist_longestpath)\",\n \"def distance(self,case):\\r\\n return max(abs(self.ligne-case.ligne),abs(self.colonne-case.colonne))\",\n \"def trips_distance_constraint_bfs(self, start_node, end_node, max_distance):\\n if start_node is None or len(start_node) != 1:\\n raise Exception('Invalid start_city: %s' % start_node)\\n if end_node is None or len(end_node) != 1:\\n raise Exception('Invalid end_city: %s' % end_node)\\n\\n queue = [(start_node, 0, [])]\\n paths = []\\n while queue:\\n node, distance, traceback = queue.pop(0)\\n\\n # We do not need to parse anymore as any further city addition will break our max_hops constraint\\n if distance >= max_distance:\\n continue\\n\\n path = traceback + [node]\\n if len(path) > 2 and path[-1] == end_node:\\n paths.append('-'.join(path) + (' (%d distance)' % distance))\\n\\n for neighbour in self.graph[node].keys():\\n queue.append((neighbour, distance + self.graph[node][neighbour], traceback + [node]))\\n\\n return paths\",\n \"def linelength(l):\\n return dist(l[0],l[1])\",\n \"def edit_distance(str1, str2):\\n # Base Case:\\n if len(str1) == 0:\\n return len(str2)\\n if len(str2) == 0:\\n return len(str1)\\n \\n # Other base case\\n if str1[-1] == str2[-1]:\\n return edit_distance(str1[:-1], str2[:-1])\\n \\n option1 = edit_distance(str1[:-1], str2)\\n option2 = edit_distance(str1, str2[:-1])\\n option3 = edit_distance(str1[:-1], str2[:-1])\\n \\n return min(option1, option2, option3) + 1\",\n \"def length(self):\\n return math.sqrt(\\n (self.endpoint_a.northing - self.endpoint_b.northing) ** 2 +\\n (self.endpoint_a.easting - self.endpoint_b.easting) ** 2\\n )\",\n \"def part_1(distances: Distances) -> int:\\n\\n result, _ = min(generate_routes(distances))\\n print(f\\\"part 1: shortest route has distance {result}\\\")\\n return result\",\n \"def tour_length(tour):\\n return sum(distance(tour[i], tour[i-1]) for i in range(len(tour)))\",\n \"def topo_shortestpathij(self, i, j):\\n pathlist = []\\n self.pathij(i, j, pathlist)\\n distance = []\\n \\n for i in range(len(pathlist)):\\n distance.append(len(pathlist[i]) - 1)\\n \\n if(len(distance) == 0):\\n return None\\n else:\\n return min(distance)\",\n \"def path_lengths(self):\\n trip_id2length = defaultdict(float)\\n prev_id = 0\\n cur_id = 0\\n prev_lat = 0\\n prev_lon = 0\\n num_big_hops = 0\\n big_hops = {}\\n print \\\"Bad Distances\\\"\\n for line in self.lines:\\n #normalized = dg.normalize(line)\\n normalized = normalize_simple(line)\\n cur_id = normalized[0]\\n lat = normalized[1]\\n lon = normalized[2]\\n if cur_id == prev_id:\\n distance = gps_dist_miles(prev_lat,prev_lon,lat,lon)\\n if distance > 1:\\n big_hops[cur_id] = 1\\n num_big_hops += 1\\n print cur_id\\n trip_id2length[cur_id] += distance \\n prev_lat = lat\\n prev_lon = lon\\n prev_id = cur_id\\n\\n print len(trip_id2length.keys())\\n #for bad_id in big_hops.keys():\\n # del trip_id2length[bad_id]\\n\\n for i in (15,18,333,24,12345):\\n print \\\"%d: %f\\\" % (i,trip_id2length[i])\\n\\n #for i in range(1,25001):\\n # if i not in trip_id2length.keys():\\n # print i\\n num_trips = len(trip_id2length.keys())\\n print num_trips\\n total_len = 0.0\\n for i in trip_id2length.keys():\\n if trip_id2length[i] > 50:\\n print \\\"Big trip: %d\\\" % i\\n #del trip_id2length[i]\\n total_len += trip_id2length[i]\\n heap = []\\n for i in trip_id2length.keys():\\n heapq.heappush(heap,trip_id2length[i])\\n quarter_len = num_trips/4\\n for i in range(quarter_len):\\n heapq.heappop(heap)\\n print \\\"25th percentile: %f\\\" % heapq.heappop(heap)\\n for i in range(quarter_len):\\n heapq.heappop(heap)\\n print \\\"median: %f\\\" % heapq.heappop(heap)\\n for i in range(quarter_len):\\n heapq.heappop(heap)\\n print \\\"75th percentile: %f\\\" % heapq.heappop(heap)\\n\\n num_trips = len(trip_id2length.keys())\\n print num_trips\\n avg_len = total_len/num_trips\\n print \\\"average length: %f\\\" % avg_len \\n print \\\"total length %f\\\" % total_len\\n print \\\"number of big hops: %d\\\" % num_big_hops\\n return trip_id2length,avg_len\",\n \"def dfs_recursive_length(self, starting_vertex, destination_vertex, visited=None, path=None):\\n if visited is None:\\n visited = set()\\n\\n if path is None:\\n path = []\\n\\n visited.add(starting_vertex)\\n new_path = list(path)\\n new_path.append(starting_vertex)\\n # print(\\\"new_path\\\", new_path)\\n # Do the thing!\\n if starting_vertex == destination_vertex:\\n return new_path\\n\\n for neighbour in self.vertices[starting_vertex]:\\n if neighbour not in visited:\\n neighbour_path = self.dfs_recursive_length(\\n neighbour, destination_vertex, visited, new_path)\\n if neighbour_path:\\n # print(neighbour_path)\\n return neighbour_path\",\n \"def getPathLength(self, starlist):\\n sum = 0\\n for i in range(len(starlist)-1):\\n sum += self.getDistance(starlist[i],starlist[i+1])\\n return sum\",\n \"def min_path(self, start, end, maxD=1e309):\\n tdist, preceding_node = self.dijkstra(start, maxD)\\n dist = tdist[end]\\n backpath = [end]\\n try:\\n while end != start:\\n end = preceding_node[end]\\n backpath.append(end)\\n path = list(reversed(backpath))\\n except KeyError:\\n path = None\\n\\n return dist, path\",\n \"def flight_path(start_city, end_city):\\n airport_dictionary = read_airports()\\n airport_graph = nx.Graph()\\n for city, data in airport_dictionary.items():\\n airport_graph.add_node(city)\\n for item in data['connections']:\\n try:\\n travel_dist = calculate_distance(data['lat_lon'], airport_dictionary[item]['lat_lon'])\\n except KeyError:\\n continue\\n airport_graph.add_edge(city, item, weight=travel_dist)\\n path = str(nx.dijkstra_path(airport_graph, start_city, end_city))\\n length = nx.dijkstra_path_length(airport_graph, start_city, end_city)\\n return \\\"The path is: {}, covering {} miles\\\".format(path, length)\",\n \"def find_shortest_path(self, start, end):\\n\\n if start==None:\\n return\\n\\n visited = {}\\n\\n distance = {start:0}\\n parent = {start:None}\\n\\n queue = deque()\\n queue.append(start)\\n\\n while queue:\\n\\n cn = queue.popleft()\\n\\n for n in self.adjacencylist[cn]:\\n if n not in visited:\\n queue.append(n)\\n parent[n] = cn\\n if n not in distance:\\n distance[n] = 1\\n else:\\n distance[n] += 1\\n\\n visited[cn] = True\\n\\n if all(visited.values()) == True:\\n print('BFS done')\\n\\n print(\\\"Finding shortest path\\\")\\n\\n path = []\\n cn = end\\n path.append(cn)\\n\\n while cn != start:\\n cn = parent[cn]\\n path.append(cn)\\n\\n print (path[::-1])\",\n \"def nsi_cross_average_path_length(self, node_list1, node_list2):\\n shortest_paths = self.path_lengths()\\n nsi_shortest_paths = shortest_paths + np.eye(len(shortest_paths))\\n node_weights = self.node_weights\\n\\n Wi = sum(node_weights[node_list1])\\n Wj = sum(node_weights[node_list1])\\n\\n w_v = np.zeros([len(node_list2), len(node_list1)])\\n w_v[:] = node_weights[node_list1]\\n w_q = np.zeros([len(node_list1), len(node_list2)])\\n w_q[:] = node_weights[node_list2]\\n\\n Wij = w_v.transpose() + w_q\\n nsi_cross_paths = nsi_shortest_paths[node_list1, :][:, node_list2]\\n Wij = Wij[np.isinf(nsi_cross_paths)].sum()\\n nsi_shortest_paths[np.isinf(nsi_shortest_paths)] = self.N - 1\\n nsi_cross_paths = nsi_shortest_paths[node_list1, :][:, node_list2]\\n\\n Lij = np.sum(nsi_cross_paths*node_weights[node_list2], axis=1)\\n Lij = np.sum(Lij * node_weights[node_list1], axis=0)\\n return Lij / (Wi*Wj - Wij)\",\n \"def find_minimum_path_cost(cls, start_point: Coordination, current_point: Coordination) -> int:\\n return abs(start_point.x - current_point.x) + abs(start_point.y - current_point.y)\",\n \"def GetEpsilonBeer(Abs, conc, pathLength):\\n return Abs / (conc * pathLength)\",\n \"def flightLegs(Alist,start,dest):\\n Alen = len(Alist) #length of Alist\\n index = list(range(Alen)) #list of airport indexes\\n Adict = dict(zip(index,Alist)) #zip into dictionary\\n #Adict = dict.fromkeys(range(Alen),large value) possibly qiucker?\\n \\n Flights = [] #output\\n\\n checked = [] #empty list\\n tocheck = deque() #empty deque for a queue of paths to be checked\\n tocheck.append([start])\\n \\n if start == dest: #trivial case\\n return \\\"trivial case explored\\\"\\n \\n while tocheck: #while there are elements in tocheck\\n path = tocheck.popleft() #pop out a path to be checked\\n node = path[-1] #extract last element of path, this node represents an airport\\n if node not in checked: #check if this path terminates in a new node/airport\\n adjacents = Adict[node] #look up in dictionary airport index and return list of adjacent airports\\n for n in adjacents: #extracts nodes inside list of adjacents\\n if n not in checked:\\n new_path = path +[n] #add neighbour to this current path\\n tocheck.append(new_path) #put this new path into the queue to be checked\\n if n == dest: #if this neighbour is the final destination, then the new path is the full path\\n if len(Flights)==0:\\n Flights.append(new_path)\\n elif len(new_path)==len(Flights[-1]):\\n Flights.append(new_path)\\n else:\\n return (len(Flights[0]),len(Flights))\\n \\n checked.append(node)\\n\\n return Flights #finds all paths need to modify to stop after a path of non shortest length is found\",\n \"def shortest_tour(tours):\\n return min(tours, key=tour_length)\",\n \"def min_distance(graph, begin, end):\\n routes = {k: \\\"inf\\\" for (k, v) in graph.items()}\\n\\n nodes = deque([(begin, graph[begin])])\\n\\n while nodes:\\n\\n root, _nodes = nodes.popleft()\\n\\n for (name, dist) in _nodes:\\n # current length from begining to a node name\\n _dist = routes[root] + dist if routes[root] != \\\"inf\\\" else dist\\n # if length ro a node name is not defined yet - define it\\n if routes[name] != \\\"inf\\\":\\n routes[name] = min([routes[name], _dist])\\n else:\\n # else - choose which way is shorter - a new or old\\n routes[name] = _dist\\n\\n nodes.append([name, graph[name]])\\n\\n return routes[end]\",\n \"def lenRange(start, stop, step=1):\\n return (stop - start + step - 1 + 2 * (step < 0)) // step\",\n \"def path(most_important_up, most_important_down, total_distance, to_source2, to_source1):\\n\\n if total_distance == min(total_distance, to_source2[0], to_source1[0]):\\n return source_to_source(most_important_up, most_important_down), total_distance\\n elif to_source2[0] == min(total_distance, to_source2[0], to_source1[0]):\\n return most_important_to_source(to_source2[1]), to_source2[0]\\n else:\\n return most_important_to_source(to_source1[1], up=False), to_source1[0]\",\n \"def compute_min_refills(distance, tank, stops):\\n\\n num_refills = 0\\n current_refill = 0\\n\\n all_stops = []\\n all_stops.append(0)\\n for stop in stops:\\n \\tall_stops.append(stop)\\n all_stops.append(distance)\\n\\n num_stops = len(all_stops)\\n\\n while current_refill < num_stops:\\n \\tlast_refill = current_refill\\n\\n \\twhile (current_refill < num_stops and all_stops[current_refill+1]\\n \\t\\t - all_stops[last_refill] <= tank):\\n \\t\\tcurrent_refill += 1\\n \\t\\tif current_refill == num_stops-1:\\n \\t\\t\\treturn num_refills\\n\\n \\tif current_refill == last_refill:\\n \\t\\treturn -1\\n \\tif current_refill < num_stops:\\n \\t\\tnum_refills += 1\\n\\n return num_refills\",\n \"def get_pathlengths(inp, origin, wires):\\n\\n lengths = np.full(wires.shape, fill_value=np.inf) # shape (2, posx, posy), float for inf sentinel\\n lengths[:, origin[0], origin[1]] = 0\\n for i,line in enumerate(inp.splitlines()):\\n pos = origin.copy()\\n pathlen = 0\\n for word in line.split(','):\\n dir,length = word[0], int(word[1:])\\n l = np.arange(1, length + 1)\\n # need min(...) for masking, hence inf sentinel\\n if dir == 'R':\\n lengths[i, pos[0] + l, pos[1] + 0*l] = np.minimum(l + pathlen, lengths[i, pos[0] + l, pos[1] + 0*l])\\n pos += [length, 0]\\n if dir == 'L':\\n lengths[i, pos[0] - l, pos[1] + 0*l] = np.minimum(l + pathlen, lengths[i, pos[0] - l, pos[1] + 0*l])\\n pos += [-length, 0]\\n if dir == 'U':\\n lengths[i, pos[0] + 0*l, pos[1] + l] = np.minimum(l + pathlen, lengths[i, pos[0] + 0*l, pos[1] + l])\\n pos += [0, length]\\n if dir == 'D':\\n lengths[i, pos[0] + 0*l, pos[1] - l] = np.minimum(l + pathlen, lengths[i, pos[0] + 0*l, pos[1] - l])\\n pos += [0, -length]\\n pathlen += length\\n\\n # unmask, return int array of paths\\n lengths[np.isinf(lengths)] = -1\\n return lengths.astype(np.uint8)\",\n \"def cheapest(self, src):\\n\\n # This uses \\\"Dijkstra's algorithm\\\" \\n # (read about it in a textbook)\\n\\n inf = float('inf') # infinity\\n\\n # for each vertex v of the graph, add an entry to the \\n # queue, with the source having distance 0 and all \\n # others having infinite distance\\n\\n d = {v: 0 if v is src else inf for v in self.cities}\\n queue = {v: (cost, v) for v, cost in d.items()}\\n\\n cloud = {} # map reachable v to its d[v] value\\n\\n while queue:\\n # Remove the cheapest path from the queue\\n # (this won't scale well, as we're constantly \\n # sorting --- better to use a priority queue,\\n # at the cost of a little more complexity)\\n u_cost, u = queue.pop(sorted(queue.values())[0][1])\\n\\n # Note the cost of this\\n cloud[u] = u_cost\\n\\n for v, v_cost in u.flights:\\n # Look for a cheaper way to make this same leg\\n if v not in cloud and d[u] + v_cost < d[v]:\\n d[v] = d[u] + v_cost\\n queue[v] = (d[v], v)\\n\\n return cloud\",\n \"def shortest_path(start, end):\\n if start == end:\\n return []\\n \\n start_frontier = Queue.Queue()\\n start_parent = {}\\n start_level = {}\\n start_parent_move = {}\\n start_frontier.put(start)\\n start_level[start] = 0\\n start_parent[start] = None\\n start_parent_move[start] = None\\n \\n end_frontier = Queue.Queue()\\n end_parent = {}\\n end_level = {}\\n end_parent_move = {}\\n end_frontier.put(end)\\n end_level[end] = 0\\n end_parent[end] = None\\n end_parent_move[end] = None\\n \\n intersectFound = False\\n intersect = None\\n level = 0\\n while (True):\\n level += 1\\n# print (\\\"level = \\\" + str(level))\\n if not start_frontier.empty():\\n vertex = start_frontier.get()\\n for move in rubik.quarter_twists:\\n position = rubik.perm_apply(move,vertex)\\n if position not in start_parent:\\n# print (\\\"start permutation unvisited\\\")\\n start_parent[position] = vertex\\n start_level[position] = level\\n start_parent_move[position] = move\\n start_frontier.put(position)\\n if position in end_parent:\\n# print (\\\"position exists in end_parent\\\")\\n intersect = position\\n intersectFound = True\\n break\\n if intersectFound:\\n break\\n if not end_frontier.empty():\\n vertex = end_frontier.get()\\n for move in rubik.quarter_twists:\\n position = rubik.perm_apply(move,vertex)\\n if position not in end_parent:\\n# print (\\\"end permutation unvisited\\\")\\n end_parent[position] = vertex\\n end_level[position] = level\\n end_parent_move[position] = move\\n end_frontier.put(position)\\n if position in start_parent:\\n# print (\\\"position exists in start_parent\\\")\\n intersect = position\\n intersectFound = True\\n break\\n if intersectFound:\\n break\\n if end_frontier.empty() and start_frontier.empty():\\n break\\n \\n if intersect is None:\\n return None\\n \\n path = []\\n pos = intersect\\n while (start_parent[pos] is not None):\\n path.insert(0,start_parent_move[pos])\\n pos = start_parent[pos]\\n \\n pos = intersect\\n while (end_parent[pos] is not None):\\n move = rubik.perm_inverse(end_parent_move[pos])\\n path.append(move)\\n pos = end_parent[pos]\\n \\n# path = [None] * start_level[intersect]\\n# pos = intersect\\n# move = start_parent_move[pos]\\n# path[start_level[intersect]-1] = move\\n# for i in range(start_level[intersect]-2,-1,-1):\\n# if (start_parent[pos] is not None):\\n# pos = start_parent[pos]\\n# move = start_parent_move[pos]\\n# path[i] = move\\n# \\n# pos = intersect\\n# while (end_parent[pos] is not None):\\n# move = rubik.perm_inverse(end_parent_move[pos])\\n# path.append(move)\\n# pos = end_parent[pos]\\n \\n return path\",\n \"def count_paths((min_i, min_j), (max_i, max_j)):\\n\\n def explore((i, j), path):\\n found = 0\\n for (x, y) in neighbors((min_i, min_j), (max_i, max_j), (i, j)):\\n if (x, y) == (max_i, max_j):\\n found += 1\\n debug(\\\"neighbor %r of node %r on path %r is a goal node: +1\\\" % ((x, y), (i, j), path))\\n elif (x, y) in path: \\n debug(\\\"neighbor %r of node %r already on path %r; ignoring...\\\" % ((x, y), (i, j), path))\\n continue\\n else:\\n debug(\\\"neighbor %r of node %r not already on path %r; exploring ...\\\" % ((x, y), (i, j), path))\\n found += explore((x, y), mkpath(path, (x, y)))\\n return found\\n return explore((0, 0), set([(0, 0)]))\",\n \"def get_shortest_path(self, r_start, r_goal):\\n neighbors = [(0, 1), (0, -1), (1, 0), (-1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]\\n start = (int(r_start[0] / Map.RESOLUTION), int(r_start[1] / Map.RESOLUTION))\\n goal = (int(r_goal[0] / Map.RESOLUTION), int(r_goal[1] / Map.RESOLUTION))\\n close_set = set()\\n came_from = {}\\n gscore = {start: 0}\\n fscore = {start: Map._heuristic(start, goal)}\\n oheap = []\\n\\n heappush(oheap, (fscore[start], start))\\n\\n while oheap:\\n current = heappop(oheap)[1]\\n\\n if current == goal:\\n data = []\\n while current in came_from:\\n data.append((int((current[0] * Map.RESOLUTION) + (Map.RESOLUTION / 2)),\\n int((current[1] * Map.RESOLUTION) + (Map.RESOLUTION / 2))))\\n current = came_from[current]\\n data.reverse()\\n return data\\n\\n close_set.add(current)\\n for i, j in neighbors:\\n neighbor = current[0] + i, current[1] + j\\n tentative_g_score = gscore[current] + Map._heuristic(current, neighbor)\\n if 0 <= neighbor[0] < self.col_grid.shape[0]:\\n if 0 <= neighbor[1] < self.col_grid.shape[1]:\\n if self.col_grid[neighbor[0]][neighbor[1]] == 1:\\n continue\\n else:\\n # array bound y walls\\n continue\\n else:\\n # array bound x walls\\n continue\\n\\n if neighbor in close_set and tentative_g_score >= gscore.get(neighbor, 0):\\n continue\\n if tentative_g_score < gscore.get(neighbor, 0) or neighbor not in [i[1] for i in oheap]:\\n came_from[neighbor] = current\\n gscore[neighbor] = tentative_g_score\\n fscore[neighbor] = tentative_g_score + Map._heuristic(neighbor, goal)\\n heappush(oheap, (fscore[neighbor], neighbor))\\n\\n return []\",\n \"def length_plateau_at(seq, start):\\n\\n length = 1\\n\\n # INVARIANT\\n # All elements in seq[start:start+length] are equal.\\n # VARIANT: len(seq) - length\\n #\\n while (start+length < len(seq)) and\\\\\\n (seq[start] == seq[start+length]):\\n length += 1\\n \\n return length\",\n \"def test_shortest_route_from_a_to_c(self):\\n railroad = trains.Railroad()\\n self.assertEqual(railroad.shortest_route_distance('A', 'C'), 9)\",\n \"def shortest(house1, house2):\\n \\n # x coordinate 1 of house 1\\n x1h1 = house1.x1\\n # x 1 of house 2\\n x1h2 = house2.x1\\n # x 2 of house 1\\n x2h1 = house1.x2\\n # x 2 of house 2\\n x2h2 = house2.x2\\n\\n # y 1 of house 1\\n y1h1 = house1.y1\\n # y 1 of house 2\\n y1h2 = house2.y1\\n # y 2 of house 1\\n y2h1 = house1.y2\\n # y 2 of house 2\\n y2h2 = house2.y2\\n \\n # The first two if statements check if the houses are directly horizontal or\\n # vertical to each other. (Or inside each other.) The other two if statements\\n # can determine between which corners the shortest distance is located \\n # otherwise.\\n\\n # Checks if the houses are above each other\\n if x1h1 <= x1h2 <= x2h1 or x1h1 <= x2h2 <= x2h1 or x1h2 <= x1h1 <= x2h2 or x1h2 <= x2h1 <= x2h2:\\n\\n # Checks if the houses are next to each other\\n if y1h1 <= y1h2 <= y2h1 or y1h1 <= y2h2 <= y2h1 or y1h2 <= y1h1 <= y2h2 or y1h2 <= y2h1 <=y2h2:\\n \\n # If they are both above and nest to each other, they must be inside\\n # each other, the total distance is returned as -1\\n return -1\\n\\n # Checks if house 2 is below house 1\\n elif y1h1 > y2h2:\\n \\n # If so, the distance between the lower wall of house 1 and the upper\\n # wall of house 2 is returned\\n return y1h1 - y2h2\\n\\n # Checks if house 2 is above house 1\\n elif y2h1 < y1h2:\\n \\n # If so, the distance between the upper wall of house 1 and the lower\\n # wall of house 2 is returned\\n return y1h2 - y2h1\\n\\n # Checks if the houses are next to each other\\n elif y1h1 <= y1h2 <= y2h1 or y1h1 <= y2h2 <= y2h1 or y1h2 <= y1h1 <= y2h2 or y1h2 <= y2h1 <=y2h2:\\n\\n # Checks if house 2 is to the left of house 1\\n if x1h1 > x2h2:\\n \\n # If so, the distance between the left wall of house 1 and the right\\n # wall of house 2 is returned\\n return x1h1 - x2h2\\n\\n # Checks if house 2 is to the right of house 1\\n elif x2h1 < x1h2:\\n \\n # If so, the distance between the right wall of house 1 and the left\\n # wall of house 2 is returned\\n return x1h2 - x2h1\\n\\n # The rest of the statements checks between which corners the shortest \\n # distance is located. This distance is calculated with Pythagoras, using\\n # the coordinates of the corners in question\\n\\n # Checks if house 2 is to the left of house 1\\n elif x1h1 > x2h2:\\n\\n # Checks if house 2 is below house 1\\n if y1h1 > y2h2:\\n \\n # House 2 is located to the bottom left of house 1\\n return ((y1h1 - y2h2) ** 2 + (x1h1 - x2h2) ** 2) ** 0.5\\n\\n # Checks if house 2 is above house 1\\n elif y2h1 < y1h2:\\n \\n # House 2 is located to the top left of house 1\\n return ((y1h2 - y2h1) ** 2 + (x1h1 - x2h2) ** 2) ** 0.5\\n\\n # Checks if house 2 is to the right of house 1\\n elif x2h1 < x1h2:\\n\\n # Checks if house 2 is below house 1\\n if y1h1 > y2h2:\\n \\n # House 2 is located to the bottom right of house 1\\n return ((y1h1 - y2h2) ** 2 + (x1h2 - x2h1) ** 2) ** 0.5\\n\\n # Checks if house 2 is above house 1\\n elif y2h1 < y1h2:\\n \\n # House is located to the top right of house 1\\n return ((y1h2 - y2h1) ** 2 + (x1h2 - x2h1) ** 2) ** 0.5\\n\\n # This should never occur, but it's here as a safety net\\n else:\\n print(\\\"error\\\")\\n return -2\",\n \"def longest_path(game, player, cur_length=0, max_length=10):\\n moves = game.get_legal_moves(player)\\n\\n # Break recursion if we reach a dead end or we're at the limit.\\n if not moves or cur_length >= max_length:\\n return cur_length\\n # Otherwise search recursively.\\n else:\\n best_depth = 0\\n for move in moves:\\n game_copy = try_move(game, move, player)\\n move_depth = longest_path(game_copy, player, cur_length + 1)\\n if move_depth > best_depth:\\n best_depth = move_depth\\n # As soon as we're at the depth limit, there's no reason to\\n # search more moves.\\n if best_depth == max_length:\\n return best_depth\\n return best_depth\",\n \"def get_path(prevs, goal, start):\\n path = OD({goal: 0})\\n cur = goal\\n while cur != start:\\n (cost, node) = prevs.get(cur)\\n if node == None or node in path:\\n print(\\\"ERROR: No path found from %s -> %s\\\" % (start, goal))\\n return (0, None)\\n path[node] = path[cur] + cost\\n cur = node\\n return (path[start], path.keys()[::-1])\",\n \"def _shortest_path(G, start, end, sp_cache):\\n if (start, end) in SP_TABLE:\\n return sp_cache[(start, end)]\\n elif (end, start) in SP_TABLE:\\n return sp_cache[(end, start)]\\n else:\\n D, P = _dijkstra(G, start, end)\\n path = []\\n temp = end\\n while 1:\\n path.append(end)\\n if end == start: break\\n end = P[end]\\n path.reverse()\\n sp_cache[(start, temp)] = path\\n return path\",\n \"def pathcost_cooler(k=5, lam=0.0003, limit=3000):\\n return lambda t: (k * exp(-lam * t) if t < limit else 0)\",\n \"def trips_hop_constraint_bfs(self, start_node, end_node, hops, equal=False):\\n if start_node is None or len(start_node) != 1:\\n raise Exception('Invalid start_city: %s' % start_node)\\n if end_node is None or len(end_node) != 1:\\n raise Exception('Invalid end_city: %s' % end_node)\\n\\n queue = [(start_node, 0, [])]\\n paths = []\\n while queue:\\n node, depth, traceback = queue.pop(0)\\n\\n # We do not need to parse anymore as any further city addition will break our max_hops constraint\\n if depth > hops:\\n continue\\n\\n path = traceback + [node]\\n if len(path) > 2 and path[-1] == end_node:\\n if equal:\\n if depth == hops:\\n paths.append('-'.join(path) + (' (%d hops)' % depth))\\n else:\\n paths.append('-'.join(path) + (' (%d hops)' % depth))\\n\\n for neighbour in self.graph[node].keys():\\n queue.append((neighbour, depth + 1, traceback + [node]))\\n\\n return paths\",\n \"def solution(src, dest):\\n # Define a board position lookup table\\n board = [[0, 1, 2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13, 14, 15],\\n [16, 17, 18, 19, 20, 21, 22, 23], [24, 25, 26, 27, 28, 29, 30, 31],\\n [32, 33, 34, 35, 36, 37, 38, 39], [40, 41, 42, 43, 44, 45, 46, 47],\\n [48, 49, 50, 51, 52, 53, 54, 55], [56, 57, 58, 59, 60, 61, 62, 63]]\\n\\n # Constant value for square board dimensions\\n N = 8\\n\\n src_node = None\\n dest_node = None\\n\\n # Get the x, y positions of src and dest cells\\n for x in range(N):\\n for y in range(N):\\n if board[x][y] == src:\\n src_node = Node(x, y)\\n if board[x][y] == dest:\\n dest_node = Node(x, y)\\n\\n # Search for the shortest path from src to dest and compute it's length\\n path_length = search(src_node, dest_node, N)\\n print(path_length)\\n return path_length\",\n \"def heuristic_1(node):\\n x_node, y_node = node.state.location()\\n goals = node.state.grid.components.white_walkers\\n goals.append(node.state.grid.components.dragon_stone)\\n distance = [np.sqrt((x_node - x)**2 + (y_node - y)**2) for x, y in goals]\\n return distance[np.argmin(distance)]\",\n \"def get_steps_of_closest_intersections(commands1, commands2):\\n\\n path1 = get_one_path(commands1)\\n path2 = get_one_path(commands2)\\n intersections = set(path1).intersection(set(path2))\\n # index is 0 based, therefore +2\\n return min(map(lambda x: path1.index(x) + path2.index(x), intersections)) + 2\",\n \"def length(self):\\n points = [Point(v, crs=self.crs) for v in self.vertices]\\n distances = [a.distance(b) for a, b in zip(points[:-1], points[1:])]\\n return sum(distances)\",\n \"def get_length(self, start_length):\\n\\n id_shape = 0\\n for shape in self.shapes:\\n if len(str(id_shape)) > start_length[0]:\\n start_length[0] = len(str(id_shape))\\n if len(shape.__class__.__name__) > start_length[1]:\\n start_length[1] = len(shape.__class__.__name__)\\n if start_length[2] < len(shape.__str__()):\\n start_length[2] = len(shape.__str__())\\n if len(str(round(shape.perimeter, 2))) > start_length[3]:\\n start_length[3] = len(str(round(shape.perimeter, 2)))\\n if len(shape.perimeter_formula) > start_length[4]:\\n start_length[4] = len(shape.perimeter_formula)\\n if len(str(round(shape.area, 2))) > start_length[5]:\\n start_length[5] = len(str(round(shape.area, 2)))\\n if len(shape.area_formula) > start_length[6]:\\n start_length[6] = len(shape.area_formula)\\n id_shape += 1\\n return start_length\",\n \"def shortest_flight(g):\\n min_distance = sys.maxsize\\n min_destination = None\\n min_key = None\\n \\n for key in g.city_dict:\\n for flight in g.city_dict[key].get_flights_out():\\n if(flight[1] < min_distance):\\n min_key = key\\n min_destination = flight[0]\\n min_distance = flight[1]\\n return g.city_dict[min_key].get_name(), min_destination, min_distance\",\n \"def DFS(graph, start, end, path, shortest,shortest_path_length,shortest_out_dist,\\\\\\r\\n pathlength,maxOutdistance,toPrint = False):\\r\\n \\r\\n \\r\\n path = path + [start]\\r\\n totalpathlength=getTotalPathLength(path)\\r\\n outerpathlength=getOutPathLength(path)\\r\\n \\r\\n \\r\\n if toPrint:\\r\\n pass \\r\\n \\r\\n if start == end and outerpathlength<=maxOutdistance and (totalpathlength <= shortest_path_length):\\r\\n print('A Shorter Path found',path,[totalpathlength],[outerpathlength])\\r\\n return path\\r\\n for node in graph.childrenOf(start):\\r\\n if node not in path: #avoid cycles\\r\\n \\r\\n \\r\\n \\r\\n if shortest== None or totalpathlength <= shortest_path_length:\\r\\n if totalpathlength <shortest_path_length and outerpathlength<=maxOutdistance :\\r\\n newPath = DFS(graph, node, end, path, shortest, shortest_path_length,\\\\\\r\\n shortest_out_dist,pathlength, maxOutdistance, toPrint)\\r\\n \\r\\n if newPath != None:\\r\\n \\r\\n shortest = newPath\\r\\n shortest_path_length=getTotalPathLength(shortest)\\r\\n shortest_out_dist=getOutPathLength(shortest)\\r\\n \\r\\n\\r\\n \\r\\n return shortest\",\n \"def find_shortest_path(self, start, end, path=[]):\\n path = path+[start]\\n if start == end:\\n return path\\n shortest_path = []\\n for node in self.graph[start]:\\n if node not in path:\\n newpath = self.find_path(node, end, path)\\n if not shortest_path or len(shortest_path) > len(newpath):\\n shortest_path = newpath\\n return shortest_path if shortest_path else None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61706465","0.57521135","0.5744518","0.568371","0.55816853","0.5577766","0.55322653","0.55223036","0.5512849","0.55110043","0.55074567","0.5502363","0.54598504","0.5440564","0.54400444","0.54284394","0.53597796","0.5335412","0.5313877","0.5312186","0.5305509","0.5248456","0.5228928","0.5201014","0.5199394","0.5197269","0.519423","0.51923907","0.5173755","0.5169323","0.51599497","0.5147963","0.5147223","0.5142221","0.51400363","0.5116163","0.5107783","0.5100235","0.5079139","0.50782704","0.507612","0.506316","0.5061292","0.50306076","0.5027507","0.50119114","0.4995326","0.49917224","0.49791443","0.49734333","0.49614182","0.4960008","0.49538502","0.4950775","0.4949248","0.4940338","0.49397752","0.4930627","0.49248594","0.49212795","0.49202666","0.49132612","0.49128935","0.49003792","0.4897631","0.48932666","0.4885447","0.48807505","0.48803967","0.48761922","0.48697412","0.4863233","0.48596376","0.48488706","0.4848087","0.4842653","0.484035","0.48338383","0.4833473","0.48289347","0.48254827","0.48243743","0.48198977","0.48169073","0.4815496","0.48119453","0.48016396","0.47995302","0.47965384","0.47912818","0.47832528","0.4783118","0.47828922","0.47797075","0.47780374","0.4774949","0.47632548","0.47630912","0.47590718","0.4745659"],"string":"[\n \"0.61706465\",\n \"0.57521135\",\n \"0.5744518\",\n \"0.568371\",\n \"0.55816853\",\n \"0.5577766\",\n \"0.55322653\",\n \"0.55223036\",\n \"0.5512849\",\n \"0.55110043\",\n \"0.55074567\",\n \"0.5502363\",\n \"0.54598504\",\n \"0.5440564\",\n \"0.54400444\",\n \"0.54284394\",\n \"0.53597796\",\n \"0.5335412\",\n \"0.5313877\",\n \"0.5312186\",\n \"0.5305509\",\n \"0.5248456\",\n \"0.5228928\",\n \"0.5201014\",\n \"0.5199394\",\n \"0.5197269\",\n \"0.519423\",\n \"0.51923907\",\n \"0.5173755\",\n \"0.5169323\",\n \"0.51599497\",\n \"0.5147963\",\n \"0.5147223\",\n \"0.5142221\",\n \"0.51400363\",\n \"0.5116163\",\n \"0.5107783\",\n \"0.5100235\",\n \"0.5079139\",\n \"0.50782704\",\n \"0.507612\",\n \"0.506316\",\n \"0.5061292\",\n \"0.50306076\",\n \"0.5027507\",\n \"0.50119114\",\n \"0.4995326\",\n \"0.49917224\",\n \"0.49791443\",\n \"0.49734333\",\n \"0.49614182\",\n \"0.4960008\",\n \"0.49538502\",\n \"0.4950775\",\n \"0.4949248\",\n \"0.4940338\",\n \"0.49397752\",\n \"0.4930627\",\n \"0.49248594\",\n \"0.49212795\",\n \"0.49202666\",\n \"0.49132612\",\n \"0.49128935\",\n \"0.49003792\",\n \"0.4897631\",\n \"0.48932666\",\n \"0.4885447\",\n \"0.48807505\",\n \"0.48803967\",\n \"0.48761922\",\n \"0.48697412\",\n \"0.4863233\",\n \"0.48596376\",\n \"0.48488706\",\n \"0.4848087\",\n \"0.4842653\",\n \"0.484035\",\n \"0.48338383\",\n \"0.4833473\",\n \"0.48289347\",\n \"0.48254827\",\n \"0.48243743\",\n \"0.48198977\",\n \"0.48169073\",\n \"0.4815496\",\n \"0.48119453\",\n \"0.48016396\",\n \"0.47995302\",\n \"0.47965384\",\n \"0.47912818\",\n \"0.47832528\",\n \"0.4783118\",\n \"0.47828922\",\n \"0.47797075\",\n \"0.47780374\",\n \"0.4774949\",\n \"0.47632548\",\n \"0.47630912\",\n \"0.47590718\",\n \"0.4745659\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5281062"},"document_rank":{"kind":"string","value":"21"}}},{"rowIdx":21976,"cells":{"query":{"kind":"string","value":"Receives input from stdin, provides output to stdout."},"document":{"kind":"string","value":"def main():\n raw_input()\n clouds = map(int, raw_input().split(' '))\n print jumping_on_the_clouds(clouds)"},"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 stdin(self):\n pass","def read_input():\n\n read = sys.stdin.readlines()\n\n text = ''\n for line in read:\n text += line\n\n return text","def read_stdin():\n return \"\".join(sys.stdin.readlines()).strip()","def _input(str=''):\n print(str, end='', flush=True)\n return stdin.readline().rstrip('\\n')","def monitor_stdin():\n while len(sys.stdin.read(1024)):\n pass\n if args.multi:\n client_monitor.notify_parent_exit()\n else:\n trigger_exit(ExitMode.PARENT)","def main():\n dt = DropToken()\n play = True\n while play:\n try:\n line = sys.stdin.readline()\n except KeyboardInterrupt:\n break\n if not line:\n break\n play = dt.inputProcess(line)","def read_input(args, parser):\n if args.text == sys.stdin:\n # check if stdin is empty\n stdin_ready, _, _ = select.select([sys.stdin], [], [], 0)\n if stdin_ready:\n return sys.stdin.read().strip()\n\n parser.print_help()\n sys.exit(1)\n\n return args.text","def stdin_read(self, data):\n self.write_master(data)","def _handle_stdin(self, line):\r\n return input(line.replace(STDIN_PROMPT, \"\"))","def stdin():\n\n while sys.stdin in select.select([sys.stdin], [], [], 0)[0]:\n\n line = sys.stdin.readline()\n\n if not line:\n yield from []\n break\n\n line = line.strip()\n yield line","def stdin_thread(self):\n while True:\n if not self.is_running():\n time.sleep(0.1)\n continue\n msg = self._stdin_queue.get()\n if msg is None:\n break # Ask to stop\n self._say(msg)","def test_pipe_to_stdin(self):\n original_stdin = sys.stdin\n with self.pipe_to_stdin() as input:\n self.assertNotEqual(original_stdin, sys.stdin)\n input.write(\"Hello world!\\n\")\n self.assertEqual(sys.stdin.readline(), \"Hello world!\\n\")\n self.assertEqual(original_stdin, sys.stdin)","def stdin(config, input):\n if input == 'history':\n home = str(Path.home())\n with open(home + '/.bash_history', 'r') as file:\n output = file.read()\n input = None\n m = SearchMatches(input, output, config.regex, config.color, config.underline)\n m.print_match_lines()\n else:\n input = shlex.split(input)\n output = subprocess.check_output(input).decode('ascii')\n input = None\n m = SearchMatches(input, output, config.regex, config.color, config.underline)\n m.print_match_lines()","def handle_input(self):\n\n\t\tline = sys.stdin.readline().strip()\n\n\t\tif line == '':\n\t\t\t# print('')\n\t\t\tself.print_prompt()\n\t\t\treturn\n\n\t\tcommand_name, *parts = line.split()\n\n\t\tif command_name in self.commands:\n\t\t\t# Call given command and unpack parts into args\n\t\t\tself.commands[command_name]['callback'](*parts)\n\t\telse:\n\t\t\tprint(command_name + ' : command not found')\n\t\t\tself.print_available_commands()\n\n\n\t\tself.print_prompt()","def read(self):\n global ALIVE\n line = sys.stdin.readline()\n if line:\n self.datalines.append(line.rstrip())\n else:\n ALIVE = False","def read_input(inp):\n epoll = select.epoll()\n epoll.register(sys.stdin.fileno(), select.EPOLLIN)\n while inp.running:\n if is_terminated():\n return\n\n events = epoll.poll(1)\n for fileno, event in events:\n line = \"[\"\n while \"[\" in line:\n line = sys.stdin.readline().strip(\",\").strip()\n inp.has_event = True\n try:\n event = json.loads(line)\n if \"instance\" in event:\n inp.callback(event)\n inp.redraw()\n except ValueError:\n pass\n epoll.unregister(sys.stdin.fileno())\n epoll.close()\n inp.has_event = True\n inp.clean_exit = True","def get_stdin(self) :\n\t\tif self.__stdin is not None :\n\t\t\t# probably no flush\n\t\t\treturn self.__stdin.getvalue()","def get_input(*args, **kw):\n if sys.version[0] == \"2\":\n return raw_input(*args, **kw)\n else:\n return input(*args, **kw)","def set_stdio(inp):\r\n default_stdin = sys.stdin\r\n sys.stdin = StringIO(inp)\r\n default_stdout = sys.stdout\r\n sys.stdout = mystdout = StringIO()\r\n return default_stdin, default_stdout, mystdout","def captured_stdout(stdin=\"\"):\n prevstdin = sys.stdin\n prevstdout = sys.stdout\n sys.stdin = StringIO(stdin)\n sys.stdout = StringIO()\n try:\n yield sys.stdout\n finally:\n sys.stdin = prevstdin\n sys.stdout = prevstdout","def pipe(cmdline, input = None):\n args = _shlex.split(cmdline)\n\n if input is not None:\n command = _subprocess.Popen(args, stdin = _subprocess.PIPE, stdout = _subprocess.PIPE, stderr = None)\n else:\n command = _subprocess.Popen(args, stdin = None, stdout = _subprocess.PIPE, stderr = None)\n\n (out, err) = command.communicate(input)\n return out","def start_console_reader():\n\n def console_reader():\n global console_input\n console_input = None\n\n while console_input is not False:\n sys.stderr.write(\"reading\\n\")\n if console_input is None:\n console_input = sys.stdin.readline()\n else:\n time.sleep(1)\n\n console_reader_thread = threading.Thread(target=console_reader)","def captured_io(stdin):\n new_out, new_err, new_input = StringIO(), StringIO(), stdin\n old_out, old_err, old_input = sys.stdout, sys.stderr, sys.stdin\n try:\n sys.stdout, sys.stderr, sys.stdin = new_out, new_err, new_input\n yield sys.stdout, sys.stderr\n finally:\n sys.stdout, sys.stderr, sys.stdin = old_out, old_err, old_input","def rawInput(string):\n if os.name == \"posix\":\n tcflush(sys.stdin, TCIFLUSH)\n return input(string)","def read_input(self) -> None:\n raw_input = sys.stdin.read()\n\n self.input = raw_input.split('\\n')\n self.input = self.input[0:-1]\n\n self.packets = []\n for item in self.input:\n if item:\n self.packets.append(literal_eval(item))","def text_input():\n return input(\">>>\")","def input_(self) -> str:\n\n # Try to input through the prefered medium, but revert to\n # backup if need to and log any errors found, for example:\n # logging.error(\"Problem!\")\n\n return IO.stdin()","def process(cmd_string, stdin=None):\n return process_results(process_run(cmd_string, stdin=stdin))","def send_data(sock):\n while True:\n data = sys.stdin.readline()\n sock.send(data.encode())","def _stdin_writer(self):\n self._is_launched.wait()\n while True:\n message = self.stdin_queue.get()\n if message is None or self._is_stopping or not self._is_running.is_set():\n if message is not None:\n log.debug(\"Ignore {0} on process {1} because it's stopped\".format(message, self.name))\n break\n self._direct_stdin_writer(message)\n self._log(\"raw\", \"write to stdin : {0}\".format(message.encode(\"utf-8\")))","def unicode_stdin_stream():\n stream = sys.stdin\n if PY3:\n try:\n stream_b = stream.buffer\n except AttributeError:\n return stream\n else:\n stream_b = stream\n\n return codecs.getreader('utf-8')(stream_b)","def _posix_shell(cls, chan, user_input, iotimeout, iodelay):\n timeout = 60 # 1 mins , only its only applicable to cmcli ssl commands\n result = ''\n input = list(user_input)\n input_end = 1\n try:\n chan.settimeout(iotimeout)\n input.reverse()\n start_time = time.time()\n\n while True:\n # we dont need this hack this is only happenning for ssl tests\n log.debug('Running select')\n r, w, e = select.select([chan, sys.stdin], [], [], 5)\n log.debug('select done')\n\n log.debug('r: %s' % repr(r))\n log.debug('w: %s' % repr(w))\n log.debug('e: %s' % repr(e))\n\n if chan in r:\n log.debug('rlist: wait until ready for reading')\n try:\n log.debug('channel receiving data')\n\n # Start with something\n x = \"DO IT\"\n while len(x) > 0:\n\n # Got stuff. Print it\n time.sleep(iodelay)\n log.debug('get some data')\n x = chan.recv(20480)\n last_prompt = x\n result += x\n log.debug('data received. Write it to stdout')\n sys.stdout.write(x)\n log.debug('flushing stdout')\n sys.stdout.flush()\n\n # We've sent it all. Let's get out\n if len(input) == input_end:\n log.debug('NOTHING LEFT TO SEND')\n\n # Program exited too soon\n if chan.exit_status_ready():\n log.warn('Hit exit status ready sooner than expected')\n chan.send('^D\\n')\n raise\n\n except socket.timeout:\n log.debug('All stdout exhausted')\n if len(input) > input_end:\n x = input.pop()\n log.debug('SENDING to input stream: %s' % x)\n chan_in = '%s' % x\n chan.send(chan_in)\n result += chan_in\n else:\n if chan.exit_status_ready():\n log.info('Program ready to exit')\n break\n\n # Keep reading for cmcli commands since we need to\n # wait until we get back to the prompt\n pass\n\n if not r:\n # FIXME: I think we want to inspect the the last prompt.\n # If it was input, we should probably attempt another select\n # if we are running a cmcli command\n log.debug(\"Nothing to send or unexpected prompt. \" +\n \"Prompt was: %s\" % last_prompt)\n raise\n\n finally:\n\n # Assume the last input is logout\n x = input.pop()\n log.debug('SENDING logout to input stream: %s' % x)\n chan_in = '%s\\n' % x\n chan.send(chan_in)\n result += chan_in\n\n log.debug('Trying to get exit status for command')\n exit_status = chan.recv_exit_status()\n log.debug('Got exit status for command: %s', exit_status)\n x = chan.recv(20480)\n log.debug(\"Last data received: %s\" % x)\n result += x\n sys.stdout.write(x)\n sys.stdout.flush()\n log.debug(\"return from posix shell\")\n return result, exit_status","def input_pipe():\n x = ''\n while True:\n x = yield x\n yield # to keep the generator in lock step with input","def main():\n\targs = sys.argv[1:]\n\t# If stdin is not empty (being piped to)\n\tif not sys.stdin.isatty():\n\t\targs += sys.stdin.readlines()\n\tcommand = Main()\n\tcatch = lnk.errors.Catch(1)\n\tcatch.catch(command.main, args, standalone_mode=False)","def runin(cmd, stdin):\n result = subprocess.Popen(cmd,stdin=subprocess.PIPE)\n result.wait()\n return result.returncode","def wait() -> None:\n\n process_input(input())","def parse_stdin(self, data):\n return data","def __init__(self, stdin=None, stdout=None):\n self._stdin = stdin or sys.stdin\n self._stdout = stdout or sys.stdout\n self._builtins = self._make_builtins()","def start(self, stdin=None, stdout=None, stderr=None):\n logging.debug(\"Starting '%s'\", \" \".join(self.cmd_line))\n self.proc = subprocess.Popen(self.cmd_line,\n stdin=stdin,\n stdout=stdout if stdout\n else subprocess.PIPE,\n stderr=stderr,\n env=self.env)\n self.thread = threading.Thread(target=self.tail)\n self.thread.daemon = True\n self.thread.start()\n self.running = True","def call_and_feed(cmd, data):\n p = Popen(cmd, shell=True, stdin=PIPE)\n p.stdin.write(data)\n p.stdin.close()\n return p.wait()","def run(self):\r\n while self._go.isSet(): #while app is running\r\n if self._check_console_input(): #if something to read on the console\r\n cmd = sys.stdin.readline() #read it\r\n self.inq.put(cmd) #dispatch it tpo the server\r\n response = self.outq.get(timeout=2.0) #wait for an answer\r\n sys.stdout.write(response) #write the answer on the console\r","def chk_stdin(self):\t# check keyboard input\n\t\tdr, dw, de = select([sys.stdin], [], [], 0)\n\t\treturn dr","def get_user_input(self):\n return stdin.readline().strip()","def main():\r\n import sys\r\n\r\n setup_logging()\r\n\r\n options = get_options()\r\n\r\n if options.rfilename == \"\":\r\n i = sys.stdin\r\n\tlogger.debug(\"Reading form console\")\r\n else:\r\n i=open(options.rfilename, \"rt\")\r\n\tlogger.debug(\"reading from %s\", options.rfilename)\r\n if options.ofilename == \"\":\r\n \to = sys.stdout\r\n\tlogger.debug(\"Writing to console\")\r\n else:\r\n\to = open(options.ofilename, \"wt\")\r\n\tlogger.debug(\"Writing to %s.\", options.ofilename)\r\n\r\n process_file(i,o)\r\n\r\n # close the files, if we opened them\r\n if i != sys.stdin:\r\n i.close()\r\n if o != sys.stdout:\r\n o.close()","def write( self, data ):\n os.write( self.stdin.fileno(), data )","def run(function, inp):\r\n sys.argv = inp.split() # input by command line parameters\r\n default_stdin, default_stdout, mystdout = set_stdio(inp) # input by input()\r\n function()\r\n reset_stdio(default_stdin, default_stdout)\r\n out = mystdout.getvalue()[:-1] # ignore the final newline\r\n return out","def start_stdio_server(self):\n ls = self.language_server(hub=self.hub)\n ls.start(sys.stdin.buffer, sys.stdout.buffer)","def get_value(Runner, input_str):\n Runner.stdin.write(input_str)\n output = Runner.stdout.readline() \n return output","def _direct_stdin_writer(self, msg):\n with self._stdin_lock:\n msg += \"\\n\"\n m = msg.encode(\"utf-8\")\n self._log(\"raw\", \"write to stdin : {0}\".format(m))\n self._popen.stdin.write(m)","def _get_input_from_stdin():\n params = sys.stdin.read()\n if not params:\n raise ValueError(\"No plugin input was found in argv or stdin.\")\n return params","def posix_shell(chan):\n import select\n \n oldtty = termios.tcgetattr(sys.stdin)\n try:\n tty.setraw(sys.stdin.fileno())\n tty.setcbreak(sys.stdin.fileno())\n chan.settimeout(0.0)\n\n while True:\n r, w, e = select.select([chan, sys.stdin], [], [])\n if chan in r:\n try:\n x = chan.recv(1024)\n if len(x) == 0:\n print '\\r\\n*** EOF\\r\\n',\n break\n sys.stdout.write(x)\n sys.stdout.flush()\n except socket.timeout:\n pass\n if sys.stdin in r:\n x = sys.stdin.read(1)\n if len(x) == 0:\n break\n chan.send(x)\n\n finally:\n termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)","def cmdline_main():\r\n import sys\r\n if (len(sys.argv) < 2 or len(sys.argv) > 4 or \"--help\" in sys.argv or\r\n \"-h\" in sys.argv or sys.argv[1] not in (\"-c\", \"-d\")):\r\n print(\"Usage: python -m snappy <-c/-d> [src [dst]]\")\r\n print(\" -c compress\")\r\n print(\" -d decompress\")\r\n print(\"output is stdout if dst is omitted or '-'\")\r\n print(\"input is stdin if src and dst are omitted or src is '-'.\")\r\n sys.exit(1)\r\n\r\n if len(sys.argv) >= 4 and sys.argv[3] != \"-\":\r\n dst = open(sys.argv[3], \"wb\")\r\n elif hasattr(sys.stdout, 'buffer'):\r\n dst = sys.stdout.buffer\r\n else:\r\n dst = sys.stdout\r\n\r\n if len(sys.argv) >= 3 and sys.argv[2] != \"-\":\r\n src = open(sys.argv[2], \"rb\")\r\n elif hasattr(sys.stdin, \"buffer\"):\r\n src = sys.stdin.buffer\r\n else:\r\n src = sys.stdin\r\n\r\n if sys.argv[1] == \"-c\":\r\n method = stream_compress\r\n else:\r\n method = stream_decompress\r\n\r\n method(src, dst)","def main():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"text\",\n help=\"text to convert (default: read from stdin)\",\n nargs=\"?\",\n default=sys.stdin,\n )\n parser.add_argument(\n \"-u\", \"--uppercase\", help=\"convert to uppercase\", action=\"store_true\"\n )\n parser.add_argument(\n \"-s\", \"--spaces\", help=\"add spaces between characters\", action=\"store_true\"\n )\n args = parser.parse_args()\n\n text = read_input(args, parser)\n processed_text = process_text(text, args)\n print(processed_text)","def pseudo_raw_input(self, prompt):\n\n # Deal with the vagaries of readline and ANSI escape codes\n safe_prompt = self._surround_ansi_escapes(prompt)\n\n if self.use_rawinput:\n try:\n if sys.stdin.isatty():\n line = sm.input(safe_prompt)\n else:\n line = sm.input()\n if self.echo:\n sys.stdout.write('{}{}\\n'.format(safe_prompt, line))\n except EOFError:\n line = 'eof'\n else:\n if self.stdin.isatty():\n # on a tty, print the prompt first, then read the line\n self.poutput(safe_prompt, end='')\n self.stdout.flush()\n line = self.stdin.readline()\n if len(line) == 0:\n line = 'eof'\n else:\n # we are reading from a pipe, read the line to see if there is\n # anything there, if so, then decide whether to print the\n # prompt or not\n line = self.stdin.readline()\n if len(line):\n # we read something, output the prompt and the something\n if self.echo:\n self.poutput('{}{}'.format(safe_prompt, line))\n else:\n line = 'eof'\n return line.strip()","def communicate(args, **kwargs):\n stdin = None\n # When stdin is passed as an argument, use it as the actual input data and\n # set the Popen() parameter accordingly.\n if 'stdin' in kwargs and isinstance(kwargs['stdin'], basestring):\n stdin = kwargs['stdin']\n kwargs['stdin'] = PIPE\n\n proc = Popen(args, **kwargs)\n return proc.communicate(stdin), proc.returncode","def _on_stdin_read(self, data):\n if not self.opts[\"udp\"]:\n self.fire(write(data))\n else:\n self.fire(write((self.host, self.port), data))","def write( shell, data ):\n #print 'cmd: ' + data\n global waiting\n os.write( shell.stdin.fileno(), data )\n waiting = True","def scan_input(self):\n proc = subprocess.Popen([\"ssh\", \"-tt\", \"pi@127.0.0.1\"],\n stdout=subprocess.PIPE, stdin=subprocess.PIPE)\n # give time to connect\n time.sleep(5)\n proc.stdin.write(\n b\"/home/pi/Desktop/GAssist/env/bin/google-assistant-demo\\n\")\n proc.stdin.flush()\n while True:\n next_line = proc.stdout.readline()\n if next_line != '':\n # the real code does filtering here\n tmp = next_line.decode(\"utf-8\")\n print(tmp)\n tmp = tmp.strip().lower()\n for test_re in self.text_regexes:\n match_test = test_re.match(tmp)\n if match_test:\n self.handle_input(match_test.group(1).strip())\n else:\n time.sleep(.01)","def input(self, prompt):\r\n return console_input(prompt)","def get_input(prompt):\n return input(prompt)","def get_input(prompt):\n return input(prompt)","def main():\n test_selector = DefaultTestSelector(init_host_test_cli_params())\n try:\n if not sys.stdin.isatty(): # Only monitor stdin if started from a parent process.\n t = threading.Thread(target=parent_monitor_thread, args=(test_selector,))\n t.start() # This thread will shutdown automatically after stdin is closed on returning from main()\n test_selector.run()\n except (KeyboardInterrupt, SystemExit):\n test_selector.finish()\n raise\n except:\n pass\n else:\n test_selector.finish()","def capture(args, **kwargs):\n kwargs.setdefault('stdin', DEVNULL)\n\n # Like check_output, deny the caller from using stdout arg.\n return communicate(args, stdout=PIPE, **kwargs)[0][0]","def map_stdin(fn):\n line = sys.stdin.readline()\n while line:\n try:\n fn(line.decode('utf8'))\n except (KeyError, ValueError), exc:\n stderr(u'%s\\n --> %s' % (exc, line.decode('utf8')))\n except (KeyboardInterrupt, EOFError):\n stderr(u'\\n -- Interrupted, exiting --\\n')\n break\n\n line = sys.stdin.readline()\n\n stderr(' -- Done --')","def run_and_tee_output(args):\n output_bytes = bytearray()\n\n def read(fd):\n data = os.read(fd, 1024)\n output_bytes.extend(data)\n return data\n\n pty.spawn(args, read)\n\n # Strip ANSI / terminal escapes.\n output_bytes = _ANSI_ESCAPE_8BIT_REGEX.sub(b'', output_bytes)\n\n return output_bytes.decode('utf-8')","def _replace_stdin(self, text):\n orig = sys.stdin\n sys.stdin = StringIO(text)\n yield\n sys.stdin = orig","def _queuing_input(procQueue, stdin_fd, query, valid, default):\n sys.stdin = os.fdopen(stdin_fd)\n procQueue.put(_get_user_input(query, valid, default))","def import_report_from_stdin():\n content = six.StringIO()\n for line in fileinput.input([]):\n content.write(line)\n content.seek(0)\n\n if not content:\n return\n import_report_from_email(content)","def test_stdin_input(self, api_client):\n runner = CliRunner()\n\n query = \"<query>\"\n api_client.stats.return_value = []\n expected = json.dumps([[]], indent=4, sort_keys=True)\n\n result = runner.invoke(subcommand.stats, [\"-f\", \"json\"], input=query)\n assert result.exit_code == 0\n assert result.output.strip(\"\\n\") == expected\n api_client.stats.assert_called_with(query=query)","def communicate(self, std_in=None, timeout=0):\n if timeout <= 0:\n return super(Popen, self).communicate(input=std_in)\n\n fds = []\n stdout = []\n stderr = []\n\n if self.stdout is not None:\n set_file_nonblock(self.stdout)\n fds.append(self.stdout)\n if self.stderr is not None:\n set_file_nonblock(self.stderr)\n fds.append(self.stderr)\n\n if std_in is not None and sys.stdin is not None:\n sys.stdin.write(std_in)\n\n returncode = None\n inactive = 0\n while returncode is None:\n (rlist, dummy_wlist, dummy_xlist) = select.select(\n fds, [], [], 1.0)\n\n if not rlist:\n inactive += 1\n if inactive >= timeout:\n raise TimeoutError\n else:\n inactive = 0\n for fd in rlist:\n if fd is self.stdout:\n stdout.append(fd.read())\n elif fd is self.stderr:\n stderr.append(fd.read())\n\n returncode = self.poll()\n\n if self.stdout is not None:\n stdout = ''.join(stdout)\n else:\n stdout = None\n if self.stderr is not None:\n stderr = ''.join(stderr)\n else:\n stderr = None\n\n return (stdout, stderr)","def run(self):\n def target():\n # Pass these inputs to STDIN with delays\n for i in self.delayed_inputs:\n if type(i) is int or type(i) is float:\n time.sleep(i)\n elif type(i) is bytes:\n try:\n self.process.stdin.write(i) \n except IOError as e:\n lg.info(\n \"Input: {} failed to write to stdin due to\\n{}\".format(i, e)\n )\n break\n if self.disable_communicate:\n self.process.wait()\n else:\n self.stdout_res, self.stderr_res = self.process.communicate(\n input=self.inputs)\n\n try:\n self.process = Popen(self.command, stdin=self.stdin,\n stdout=self.stdout, stderr=self.stderr,\n start_new_session=True, cwd=self.cwd, env=self.env)\n except OSError:\n lg.error(\"Couldn't Popen command {}\".format(self.command))\n raise\n self.thread = Thread(target=target)\n self.thread.start()","def interact(self):\n print('Ready to interact on socket connected with {}.'.format(self.remote_addr))\n try:\n # get initial input from user\n print('Enter input or press CTRL-D for no input.')\n data = sys.stdin.readline()\n self.remote_socket.sendall(data.encode())\n while True:\n if data.startswith('exit'):\n print('[*] Closing remote shell.')\n self.close()\n break\n # wait for response from target host\n recv_len = 1\n response = ''\n while recv_len:\n data = self.remote_socket.recv(4096)\n recv_len = len(data)\n response += data.decode()\n if recv_len < 4096:\n break\n print(response)\n # get further input from user\n print('Enter further input or press CTRL-D for no input.')\n data = sys.stdin.readline()\n self.remote_socket.sendall(data.encode())\n except Exception as e:\n print(e)\n print('[*] Closing remote shell.')\n self.close()","def clear_in():\r\n c = sys.stdin.read(1)\r\n while(c!='\\n'):\r\n c = sys.stdin.read(1)","def main(self):\n cmd = \"self.%s(sys.stdin)\" % sys.argv[1]\n exec(cmd)","def _get_input(question: str) -> str:\n print(question)\n sys.stdout.flush()\n user_input = sys.stdin.readline()\n user_input = user_input.strip()\n return user_input","def command(cmd: list, stdin: str):\n proc = Popen(cmd, stdout=PIPE, stderr=STDOUT, stdin=PIPE)\n out, err = proc.communicate(stdin.encode(\"utf-8\"))\n exit = proc.wait()\n return out.decode(\"utf-8\")","def communicate(host, port):\n s = socket.socket()\n s.connect((host, port))\n payload = sys.stdin.read().encode()\n s.sendall(payload)\n s.shutdown(socket.SHUT_WR)\n\n output = []\n while True:\n read = s.recv(READ_SIZE)\n if read:\n output.append(read.decode())\n else:\n break\n return ''.join(output)","def wait_for_input(self):\n if self._dont_enter_interactive_mode:\n return\n stop = False\n while True:\n print(\">>> \", end='')\n try:\n command_str = input()\n except EOFError:\n print(\"Exiting interactive mode\")\n break\n stop = self.interpret_command(command_str)\n if stop:\n print(\"Exiting interactive mode\")\n break","def new_user_input(self):\n ready, _, _ = select([stdin], [], [], 0.0)\n return stdin in ready","def read():\n for line in sys.stdin:\n if line == \"\\n\":\n return\n log_elements.append(log_element(line))","def recvraw(self):\n\n if self.stdin is None:\n return _python_input_function()\n else:\n return self.stdin.readline().rstrip('\\n')","def pseudo_raw_input(self, prompt):\n\n if self.use_rawinput:\n try:\n line = sm.input(prompt)\n except EOFError:\n line = 'EOF'\n else:\n self.stdout.write(prompt)\n self.stdout.flush()\n line = self.stdin.readline()\n if not len(line):\n line = 'EOF'\n else:\n if line[-1] == '\\n': # this was always true in Cmd\n line = line[:-1]\n return line","def runcmd(args, stdin=None):\n if type(args) is str:\n args = shlex.split(args)\n args = map(str, args)\n proc = subprocess.Popen(args, stdout=subprocess.PIPE,\n stdin=stdin)\n if stdin is None:\n return proc.stdout.read()\n else:\n return proc","async def interactive_shell():\n # Create Prompt.\n session = PromptSession('Say something: ')\n\n # Run echo loop. Read text from stdin, and reply it back.\n while True:\n try:\n result = await session.prompt(async_=True)\n print('You said: \"{0}\"'.format(result))\n except (EOFError, KeyboardInterrupt):\n return","def pipestring_process(cmd_string, stdin_string=''):\n f=SpooledTemporaryFile()\n f.write(stdin_string)\n f.seek(0)\n results=process(cmd_string, stdin=f)\n f.close()\n return results","def reset_stdio(default_stdout, default_stdin):\r\n sys.stdin = default_stdin\r\n sys.stdout = default_stdout","def output_to_pipe(pipe_in):\n os.dup2(pipe_in, 1) # stdout\n # os.dup2(pipe_in, 2) # stderr","def test_cli_stdin(\n config,\n):\n from YesssSMS.api import MAX_MESSAGE_LENGTH_STDIN\n\n testargs = [\"yessssms\", \"--test\", \"-l\", \"06641234567\", \"-p\", \"passw0rd\", \"-m\", \"-\"]\n\n in_message = \"\"\"Da steh’ ich nun, ich armer Thor!\nUnd bin so klug als wie zuvor;\nHeiße Magister, heiße Doctor gar,\nUnd ziehe schon an die zehen Jahr,\nHerauf, herab und quer und krumm,\nMeine Schüler an der Nase herum –\nUnd sehe, daß wir nichts wissen können!\nDas will mir schier das Herz verbrennen.\nZwar bin ich gescheidter als alle die Laffen,\nDoctoren, Magister, Schreiber und Pfaffen;\nMich plagen keine Scrupel noch Zweifel,\nFürchte mich weder vor Hölle noch Teufel –\nDafür ist mir auch alle Freud’ entrissen,\nBilde mir nicht ein was rechts zu wissen,\nBilde mir nicht ein, ich könnte was lehren,\nDie Menschen zu bessern und zu bekehren.\nAuch hab’ ich weder Gut noch Geld,\nNoch Ehr’ und Herrlichkeit der Welt.\nEs möchte kein Hund so länger leben!\nDrum hab’ ich mich der Magie ergeben,\nOb mir durch Geistes Kraft und Mund\nNicht manch Geheimniß würde kund;\nDaß ich nicht mehr mit sauerm Schweiß,\nZu sagen brauche, was ich nicht weiß;\"\"\"\n with mock.patch.object(sys, \"argv\", testargs):\n with mock.patch.object(sys, \"stdin\", in_message):\n with requests_mock.Mocker() as m:\n m.register_uri(\n \"POST\",\n # pylint: disable=protected-access\n _LOGIN_URL,\n status_code=302,\n # pylint: disable=protected-access\n headers={\"location\": _KONTOMANAGER_URL},\n )\n m.register_uri(\n \"GET\",\n # pylint: disable=protected-access\n _KONTOMANAGER_URL,\n status_code=200,\n )\n m.register_uri(\n \"GET\",\n # pylint: disable=protected-access\n _SMS_FORM_URL,\n status_code=200,\n text=TEST_FORM_TOKEN_SAMPLE,\n )\n m.register_uri(\n \"POST\",\n # pylint: disable=protected-access\n _SEND_SMS_URL,\n status_code=200,\n text=\"<h1>Ihre SMS wurde erfolgreich \" + \"verschickt!</h1>\",\n )\n m.register_uri(\n \"GET\",\n # pylint: disable=protected-access\n _LOGOUT_URL,\n status_code=200,\n )\n\n message = CLI().message\n\n assert message.startswith(\n \"\"\"Da steh’ ich nun, ich armer Thor!\nUnd bin so klug als wie zuvor;\"\"\"\n )\n assert message == in_message[:MAX_MESSAGE_LENGTH_STDIN]","def console(self, message):\n if self.proc is None or self.proc.poll() is not None:\n return\n message = message.split('\\n')[0] + '\\n'\n self.proc.stdin.write(message.encode())\n self.proc.stdin.flush()","def read():\n\n try:\n rl, _, _ = select([sys.stdin], [], [], 1.0)\n if not rl:\n return None\n except SelectError:\n return None\n\n inp = raw_input().strip()\n if inp == '[':\n return None\n\n inp = inp.strip(\",\")\n inp = json.loads(inp)\n return inp","def inp(text):\r\n input(text)","def _launch_command(args, out_cb, err_cb, done=None, **kwargs):\n\n def pump_stream(callback, stream):\n \"\"\"Pump the stream\"\"\"\n for line in stream:\n callback(line)\n callback(None)\n\n def joiner():\n \"\"\"Wait for streams to finish, then call done callback\"\"\"\n for th in threads:\n th.join()\n done(process)\n\n kwargs = kwargs.copy()\n in_data = kwargs.get(\"input\")\n if \"input\" in kwargs:\n del kwargs[\"input\"]\n assert kwargs.get(\"stdin\") is None, kwargs[\"stdin\"]\n kwargs[\"stdin\"] = PIPE\n elif \"stdin\" not in kwargs:\n kwargs[\"stdin\"] = DEVNULL\n kwargs.setdefault(\"stdout\", PIPE)\n kwargs.setdefault(\"stderr\", PIPE)\n kwargs[\"universal_newlines\"] = True # Text streams, not byte streams\n process = Popen(args, **kwargs)\n threads = []\n if process.stdout:\n thread = Thread(\n target=pump_stream, args=(out_cb, process.stdout), daemon=True\n )\n thread.start()\n threads.append(thread)\n if process.stderr:\n thread = Thread(\n target=pump_stream, args=(err_cb, process.stderr), daemon=True\n )\n thread.start()\n threads.append(thread)\n if done and threads:\n Thread(target=joiner, daemon=True).start()\n if in_data:\n process.stdin.write(str(in_data, \"utf-8\"))\n process.stdin.close()\n return process","def cont():\n\n try:\n input = raw_input()\n except Exception:\n pass","def run_python_stdin(python, file_args=None, directives=None):\n import shutil\n import tempfile\n\n with tempfile.NamedTemporaryFile(suffix='.py') as f:\n shutil.copyfileobj(sys.stdin, f)\n f.flush()\n\n file_args = [f.name] + list(file_args or ())\n run_python_file(python, file_args, directives)","def send_msg(self, msg):\n self.proc.stdin.write(msg)","def run_interactive(cls, shell, command, input):\n feed = '\\\\n'.join(input)\n icommand = \"echo -e '{}' | {}\".format(feed, command)\n _stdout, _stderr = cls.run(shell, icommand)\n return _stdout","def rshell(self, chan):\n logging.debug(\"\")\n logging.debug(\"************************************************************\")\n import select\n import termios\n import tty\n import socket\n from paramiko.py3compat import u\n oldtty = termios.tcgetattr(sys.stdin)\n try:\n tty.setraw(sys.stdin.fileno())\n tty.setcbreak(sys.stdin.fileno())\n chan.settimeout(0.0)\n while True:\n r, w, e = select.select([chan, sys.stdin], [], [])\n if chan in r:\n try:\n x = u(chan.recv(1024))\n if len(x) == 0:\n sys.stdout.write('\\n\\n')\n break\n sys.stdout.write(x)\n sys.stdout.flush()\n except socket.timeout:\n pass\n if sys.stdin in r:\n x = sys.stdin.read(1)\n if len(x) == 0:\n break\n chan.send(x)\n finally:\n termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)","def send_stdin(self, s_bytes):\n self._proc.stdin.write(s_bytes)\n self._proc.stdin.flush()","def read_mapper_input(stdin):\n for line in stdin:\n yield line.rstrip()","def inputloop():\n while True:\n for char in raw_input().decode('utf-8'):\n print script(char)","def _posix_shell(cls, chan, user_input, iotimeout, iodelay, cmcli_bool):\n timeout = 60 # 1 mins , only its only applicable to cmcli ssl commands\n result = ''\n input = list(user_input)\n cmcli_ssl_bool = False\n last_prompt = ''\n if len(filter(lambda x: x.find('ssl') >= 0, user_input)) > 0:\n cmcli_ssl_bool = True\n if cmcli_bool:\n input_end = 1\n else:\n input_end = 0\n try:\n iotimeout_save = chan.gettimeout()\n chan.settimeout(iotimeout)\n input.reverse()\n start_time = time.time()\n\n while True:\n # we dont need this hack this is only happenning for ssl tests\n if cmcli_ssl_bool and time.time() - start_time > timeout:\n log.error('time to break out of the loop.waited %s seconds' % timeout)\n raise OSError('Remote Command timeout after {} seconds'.format(timeout))\n log.debug('Running select')\n r, w, e = select.select([chan, sys.stdin], [], [], 5)\n log.debug('select done')\n\n log.debug('r: %s' % repr(r))\n log.debug('w: %s' % repr(w))\n log.debug('e: %s' % repr(e))\n\n if chan in r:\n log.debug('rlist: wait until ready for reading')\n try:\n log.debug('channel receiving data')\n\n # Start with something\n x = \"DO IT\"\n while len(x) > 0:\n\n # Got stuff. Print it\n time.sleep(iodelay)\n log.debug('get some data')\n x = chan.recv(20480)\n last_prompt = x\n result += x\n log.debug('data received. Write it to stdout')\n sys.stdout.write(x)\n log.debug('flushing stdout')\n sys.stdout.flush()\n\n # We've sent it all. Let's get out\n if len(input) == input_end:\n log.debug('NOTHING LEFT TO SEND')\n raise\n\n # Program exited too soon\n if chan.exit_status_ready():\n log.warn('Hit exit status ready sooner than expected')\n chan.send('\u0004\\n')\n raise\n\n except socket.timeout:\n log.debug('All stdout exhausted')\n if len(input) > input_end:\n x = input.pop()\n log.debug('SENDING to input stream: %s' % x)\n chan_in = '%s\\n' % x\n chan.send(chan_in)\n result += chan_in\n else:\n if chan.exit_status_ready():\n log.info('Program ready to exit')\n break\n\n # Keep reading for cmcli commands since we need to\n # wait until we get back to the prompt\n if not cmcli_bool:\n log.debug('Break out of select loop')\n break\n elif last_prompt and last_prompt.lower().find('cryptomanager>') >= 0:\n log.debug('Cryptomanager prompt is seen')\n break\n pass\n\n if not r:\n # FIXME: I think we want to inspect the the last prompt.\n # If it was input, we should probably attempt another select\n # if we are running a cmcli command\n log.debug(\"Nothing to send or unexpected prompt. \" +\n \"Prompt was: %s\" % last_prompt)\n raise\n\n finally:\n\n # Assume the last input is logout\n if cmcli_bool:\n x = input.pop()\n log.debug('SENDING logout to input stream: %s' % x)\n chan_in = '%s\\n' % x\n chan.send(chan_in)\n result += chan_in\n\n log.debug('Trying to get exit status for command')\n exit_status = chan.recv_exit_status()\n log.debug('Got exit status for command: %s', exit_status)\n x = chan.recv(20480)\n log.debug(\"Last data received: %s\" % x)\n result += x\n sys.stdout.write(x)\n sys.stdout.flush()\n log.debug(\"return from posix shell\")\n chan.settimeout(iotimeout_save)\n return result, exit_status"],"string":"[\n \"def stdin(self):\\n pass\",\n \"def read_input():\\n\\n read = sys.stdin.readlines()\\n\\n text = ''\\n for line in read:\\n text += line\\n\\n return text\",\n \"def read_stdin():\\n return \\\"\\\".join(sys.stdin.readlines()).strip()\",\n \"def _input(str=''):\\n print(str, end='', flush=True)\\n return stdin.readline().rstrip('\\\\n')\",\n \"def monitor_stdin():\\n while len(sys.stdin.read(1024)):\\n pass\\n if args.multi:\\n client_monitor.notify_parent_exit()\\n else:\\n trigger_exit(ExitMode.PARENT)\",\n \"def main():\\n dt = DropToken()\\n play = True\\n while play:\\n try:\\n line = sys.stdin.readline()\\n except KeyboardInterrupt:\\n break\\n if not line:\\n break\\n play = dt.inputProcess(line)\",\n \"def read_input(args, parser):\\n if args.text == sys.stdin:\\n # check if stdin is empty\\n stdin_ready, _, _ = select.select([sys.stdin], [], [], 0)\\n if stdin_ready:\\n return sys.stdin.read().strip()\\n\\n parser.print_help()\\n sys.exit(1)\\n\\n return args.text\",\n \"def stdin_read(self, data):\\n self.write_master(data)\",\n \"def _handle_stdin(self, line):\\r\\n return input(line.replace(STDIN_PROMPT, \\\"\\\"))\",\n \"def stdin():\\n\\n while sys.stdin in select.select([sys.stdin], [], [], 0)[0]:\\n\\n line = sys.stdin.readline()\\n\\n if not line:\\n yield from []\\n break\\n\\n line = line.strip()\\n yield line\",\n \"def stdin_thread(self):\\n while True:\\n if not self.is_running():\\n time.sleep(0.1)\\n continue\\n msg = self._stdin_queue.get()\\n if msg is None:\\n break # Ask to stop\\n self._say(msg)\",\n \"def test_pipe_to_stdin(self):\\n original_stdin = sys.stdin\\n with self.pipe_to_stdin() as input:\\n self.assertNotEqual(original_stdin, sys.stdin)\\n input.write(\\\"Hello world!\\\\n\\\")\\n self.assertEqual(sys.stdin.readline(), \\\"Hello world!\\\\n\\\")\\n self.assertEqual(original_stdin, sys.stdin)\",\n \"def stdin(config, input):\\n if input == 'history':\\n home = str(Path.home())\\n with open(home + '/.bash_history', 'r') as file:\\n output = file.read()\\n input = None\\n m = SearchMatches(input, output, config.regex, config.color, config.underline)\\n m.print_match_lines()\\n else:\\n input = shlex.split(input)\\n output = subprocess.check_output(input).decode('ascii')\\n input = None\\n m = SearchMatches(input, output, config.regex, config.color, config.underline)\\n m.print_match_lines()\",\n \"def handle_input(self):\\n\\n\\t\\tline = sys.stdin.readline().strip()\\n\\n\\t\\tif line == '':\\n\\t\\t\\t# print('')\\n\\t\\t\\tself.print_prompt()\\n\\t\\t\\treturn\\n\\n\\t\\tcommand_name, *parts = line.split()\\n\\n\\t\\tif command_name in self.commands:\\n\\t\\t\\t# Call given command and unpack parts into args\\n\\t\\t\\tself.commands[command_name]['callback'](*parts)\\n\\t\\telse:\\n\\t\\t\\tprint(command_name + ' : command not found')\\n\\t\\t\\tself.print_available_commands()\\n\\n\\n\\t\\tself.print_prompt()\",\n \"def read(self):\\n global ALIVE\\n line = sys.stdin.readline()\\n if line:\\n self.datalines.append(line.rstrip())\\n else:\\n ALIVE = False\",\n \"def read_input(inp):\\n epoll = select.epoll()\\n epoll.register(sys.stdin.fileno(), select.EPOLLIN)\\n while inp.running:\\n if is_terminated():\\n return\\n\\n events = epoll.poll(1)\\n for fileno, event in events:\\n line = \\\"[\\\"\\n while \\\"[\\\" in line:\\n line = sys.stdin.readline().strip(\\\",\\\").strip()\\n inp.has_event = True\\n try:\\n event = json.loads(line)\\n if \\\"instance\\\" in event:\\n inp.callback(event)\\n inp.redraw()\\n except ValueError:\\n pass\\n epoll.unregister(sys.stdin.fileno())\\n epoll.close()\\n inp.has_event = True\\n inp.clean_exit = True\",\n \"def get_stdin(self) :\\n\\t\\tif self.__stdin is not None :\\n\\t\\t\\t# probably no flush\\n\\t\\t\\treturn self.__stdin.getvalue()\",\n \"def get_input(*args, **kw):\\n if sys.version[0] == \\\"2\\\":\\n return raw_input(*args, **kw)\\n else:\\n return input(*args, **kw)\",\n \"def set_stdio(inp):\\r\\n default_stdin = sys.stdin\\r\\n sys.stdin = StringIO(inp)\\r\\n default_stdout = sys.stdout\\r\\n sys.stdout = mystdout = StringIO()\\r\\n return default_stdin, default_stdout, mystdout\",\n \"def captured_stdout(stdin=\\\"\\\"):\\n prevstdin = sys.stdin\\n prevstdout = sys.stdout\\n sys.stdin = StringIO(stdin)\\n sys.stdout = StringIO()\\n try:\\n yield sys.stdout\\n finally:\\n sys.stdin = prevstdin\\n sys.stdout = prevstdout\",\n \"def pipe(cmdline, input = None):\\n args = _shlex.split(cmdline)\\n\\n if input is not None:\\n command = _subprocess.Popen(args, stdin = _subprocess.PIPE, stdout = _subprocess.PIPE, stderr = None)\\n else:\\n command = _subprocess.Popen(args, stdin = None, stdout = _subprocess.PIPE, stderr = None)\\n\\n (out, err) = command.communicate(input)\\n return out\",\n \"def start_console_reader():\\n\\n def console_reader():\\n global console_input\\n console_input = None\\n\\n while console_input is not False:\\n sys.stderr.write(\\\"reading\\\\n\\\")\\n if console_input is None:\\n console_input = sys.stdin.readline()\\n else:\\n time.sleep(1)\\n\\n console_reader_thread = threading.Thread(target=console_reader)\",\n \"def captured_io(stdin):\\n new_out, new_err, new_input = StringIO(), StringIO(), stdin\\n old_out, old_err, old_input = sys.stdout, sys.stderr, sys.stdin\\n try:\\n sys.stdout, sys.stderr, sys.stdin = new_out, new_err, new_input\\n yield sys.stdout, sys.stderr\\n finally:\\n sys.stdout, sys.stderr, sys.stdin = old_out, old_err, old_input\",\n \"def rawInput(string):\\n if os.name == \\\"posix\\\":\\n tcflush(sys.stdin, TCIFLUSH)\\n return input(string)\",\n \"def read_input(self) -> None:\\n raw_input = sys.stdin.read()\\n\\n self.input = raw_input.split('\\\\n')\\n self.input = self.input[0:-1]\\n\\n self.packets = []\\n for item in self.input:\\n if item:\\n self.packets.append(literal_eval(item))\",\n \"def text_input():\\n return input(\\\">>>\\\")\",\n \"def input_(self) -> str:\\n\\n # Try to input through the prefered medium, but revert to\\n # backup if need to and log any errors found, for example:\\n # logging.error(\\\"Problem!\\\")\\n\\n return IO.stdin()\",\n \"def process(cmd_string, stdin=None):\\n return process_results(process_run(cmd_string, stdin=stdin))\",\n \"def send_data(sock):\\n while True:\\n data = sys.stdin.readline()\\n sock.send(data.encode())\",\n \"def _stdin_writer(self):\\n self._is_launched.wait()\\n while True:\\n message = self.stdin_queue.get()\\n if message is None or self._is_stopping or not self._is_running.is_set():\\n if message is not None:\\n log.debug(\\\"Ignore {0} on process {1} because it's stopped\\\".format(message, self.name))\\n break\\n self._direct_stdin_writer(message)\\n self._log(\\\"raw\\\", \\\"write to stdin : {0}\\\".format(message.encode(\\\"utf-8\\\")))\",\n \"def unicode_stdin_stream():\\n stream = sys.stdin\\n if PY3:\\n try:\\n stream_b = stream.buffer\\n except AttributeError:\\n return stream\\n else:\\n stream_b = stream\\n\\n return codecs.getreader('utf-8')(stream_b)\",\n \"def _posix_shell(cls, chan, user_input, iotimeout, iodelay):\\n timeout = 60 # 1 mins , only its only applicable to cmcli ssl commands\\n result = ''\\n input = list(user_input)\\n input_end = 1\\n try:\\n chan.settimeout(iotimeout)\\n input.reverse()\\n start_time = time.time()\\n\\n while True:\\n # we dont need this hack this is only happenning for ssl tests\\n log.debug('Running select')\\n r, w, e = select.select([chan, sys.stdin], [], [], 5)\\n log.debug('select done')\\n\\n log.debug('r: %s' % repr(r))\\n log.debug('w: %s' % repr(w))\\n log.debug('e: %s' % repr(e))\\n\\n if chan in r:\\n log.debug('rlist: wait until ready for reading')\\n try:\\n log.debug('channel receiving data')\\n\\n # Start with something\\n x = \\\"DO IT\\\"\\n while len(x) > 0:\\n\\n # Got stuff. Print it\\n time.sleep(iodelay)\\n log.debug('get some data')\\n x = chan.recv(20480)\\n last_prompt = x\\n result += x\\n log.debug('data received. Write it to stdout')\\n sys.stdout.write(x)\\n log.debug('flushing stdout')\\n sys.stdout.flush()\\n\\n # We've sent it all. Let's get out\\n if len(input) == input_end:\\n log.debug('NOTHING LEFT TO SEND')\\n\\n # Program exited too soon\\n if chan.exit_status_ready():\\n log.warn('Hit exit status ready sooner than expected')\\n chan.send('^D\\\\n')\\n raise\\n\\n except socket.timeout:\\n log.debug('All stdout exhausted')\\n if len(input) > input_end:\\n x = input.pop()\\n log.debug('SENDING to input stream: %s' % x)\\n chan_in = '%s' % x\\n chan.send(chan_in)\\n result += chan_in\\n else:\\n if chan.exit_status_ready():\\n log.info('Program ready to exit')\\n break\\n\\n # Keep reading for cmcli commands since we need to\\n # wait until we get back to the prompt\\n pass\\n\\n if not r:\\n # FIXME: I think we want to inspect the the last prompt.\\n # If it was input, we should probably attempt another select\\n # if we are running a cmcli command\\n log.debug(\\\"Nothing to send or unexpected prompt. \\\" +\\n \\\"Prompt was: %s\\\" % last_prompt)\\n raise\\n\\n finally:\\n\\n # Assume the last input is logout\\n x = input.pop()\\n log.debug('SENDING logout to input stream: %s' % x)\\n chan_in = '%s\\\\n' % x\\n chan.send(chan_in)\\n result += chan_in\\n\\n log.debug('Trying to get exit status for command')\\n exit_status = chan.recv_exit_status()\\n log.debug('Got exit status for command: %s', exit_status)\\n x = chan.recv(20480)\\n log.debug(\\\"Last data received: %s\\\" % x)\\n result += x\\n sys.stdout.write(x)\\n sys.stdout.flush()\\n log.debug(\\\"return from posix shell\\\")\\n return result, exit_status\",\n \"def input_pipe():\\n x = ''\\n while True:\\n x = yield x\\n yield # to keep the generator in lock step with input\",\n \"def main():\\n\\targs = sys.argv[1:]\\n\\t# If stdin is not empty (being piped to)\\n\\tif not sys.stdin.isatty():\\n\\t\\targs += sys.stdin.readlines()\\n\\tcommand = Main()\\n\\tcatch = lnk.errors.Catch(1)\\n\\tcatch.catch(command.main, args, standalone_mode=False)\",\n \"def runin(cmd, stdin):\\n result = subprocess.Popen(cmd,stdin=subprocess.PIPE)\\n result.wait()\\n return result.returncode\",\n \"def wait() -> None:\\n\\n process_input(input())\",\n \"def parse_stdin(self, data):\\n return data\",\n \"def __init__(self, stdin=None, stdout=None):\\n self._stdin = stdin or sys.stdin\\n self._stdout = stdout or sys.stdout\\n self._builtins = self._make_builtins()\",\n \"def start(self, stdin=None, stdout=None, stderr=None):\\n logging.debug(\\\"Starting '%s'\\\", \\\" \\\".join(self.cmd_line))\\n self.proc = subprocess.Popen(self.cmd_line,\\n stdin=stdin,\\n stdout=stdout if stdout\\n else subprocess.PIPE,\\n stderr=stderr,\\n env=self.env)\\n self.thread = threading.Thread(target=self.tail)\\n self.thread.daemon = True\\n self.thread.start()\\n self.running = True\",\n \"def call_and_feed(cmd, data):\\n p = Popen(cmd, shell=True, stdin=PIPE)\\n p.stdin.write(data)\\n p.stdin.close()\\n return p.wait()\",\n \"def run(self):\\r\\n while self._go.isSet(): #while app is running\\r\\n if self._check_console_input(): #if something to read on the console\\r\\n cmd = sys.stdin.readline() #read it\\r\\n self.inq.put(cmd) #dispatch it tpo the server\\r\\n response = self.outq.get(timeout=2.0) #wait for an answer\\r\\n sys.stdout.write(response) #write the answer on the console\\r\",\n \"def chk_stdin(self):\\t# check keyboard input\\n\\t\\tdr, dw, de = select([sys.stdin], [], [], 0)\\n\\t\\treturn dr\",\n \"def get_user_input(self):\\n return stdin.readline().strip()\",\n \"def main():\\r\\n import sys\\r\\n\\r\\n setup_logging()\\r\\n\\r\\n options = get_options()\\r\\n\\r\\n if options.rfilename == \\\"\\\":\\r\\n i = sys.stdin\\r\\n\\tlogger.debug(\\\"Reading form console\\\")\\r\\n else:\\r\\n i=open(options.rfilename, \\\"rt\\\")\\r\\n\\tlogger.debug(\\\"reading from %s\\\", options.rfilename)\\r\\n if options.ofilename == \\\"\\\":\\r\\n \\to = sys.stdout\\r\\n\\tlogger.debug(\\\"Writing to console\\\")\\r\\n else:\\r\\n\\to = open(options.ofilename, \\\"wt\\\")\\r\\n\\tlogger.debug(\\\"Writing to %s.\\\", options.ofilename)\\r\\n\\r\\n process_file(i,o)\\r\\n\\r\\n # close the files, if we opened them\\r\\n if i != sys.stdin:\\r\\n i.close()\\r\\n if o != sys.stdout:\\r\\n o.close()\",\n \"def write( self, data ):\\n os.write( self.stdin.fileno(), data )\",\n \"def run(function, inp):\\r\\n sys.argv = inp.split() # input by command line parameters\\r\\n default_stdin, default_stdout, mystdout = set_stdio(inp) # input by input()\\r\\n function()\\r\\n reset_stdio(default_stdin, default_stdout)\\r\\n out = mystdout.getvalue()[:-1] # ignore the final newline\\r\\n return out\",\n \"def start_stdio_server(self):\\n ls = self.language_server(hub=self.hub)\\n ls.start(sys.stdin.buffer, sys.stdout.buffer)\",\n \"def get_value(Runner, input_str):\\n Runner.stdin.write(input_str)\\n output = Runner.stdout.readline() \\n return output\",\n \"def _direct_stdin_writer(self, msg):\\n with self._stdin_lock:\\n msg += \\\"\\\\n\\\"\\n m = msg.encode(\\\"utf-8\\\")\\n self._log(\\\"raw\\\", \\\"write to stdin : {0}\\\".format(m))\\n self._popen.stdin.write(m)\",\n \"def _get_input_from_stdin():\\n params = sys.stdin.read()\\n if not params:\\n raise ValueError(\\\"No plugin input was found in argv or stdin.\\\")\\n return params\",\n \"def posix_shell(chan):\\n import select\\n \\n oldtty = termios.tcgetattr(sys.stdin)\\n try:\\n tty.setraw(sys.stdin.fileno())\\n tty.setcbreak(sys.stdin.fileno())\\n chan.settimeout(0.0)\\n\\n while True:\\n r, w, e = select.select([chan, sys.stdin], [], [])\\n if chan in r:\\n try:\\n x = chan.recv(1024)\\n if len(x) == 0:\\n print '\\\\r\\\\n*** EOF\\\\r\\\\n',\\n break\\n sys.stdout.write(x)\\n sys.stdout.flush()\\n except socket.timeout:\\n pass\\n if sys.stdin in r:\\n x = sys.stdin.read(1)\\n if len(x) == 0:\\n break\\n chan.send(x)\\n\\n finally:\\n termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)\",\n \"def cmdline_main():\\r\\n import sys\\r\\n if (len(sys.argv) < 2 or len(sys.argv) > 4 or \\\"--help\\\" in sys.argv or\\r\\n \\\"-h\\\" in sys.argv or sys.argv[1] not in (\\\"-c\\\", \\\"-d\\\")):\\r\\n print(\\\"Usage: python -m snappy <-c/-d> [src [dst]]\\\")\\r\\n print(\\\" -c compress\\\")\\r\\n print(\\\" -d decompress\\\")\\r\\n print(\\\"output is stdout if dst is omitted or '-'\\\")\\r\\n print(\\\"input is stdin if src and dst are omitted or src is '-'.\\\")\\r\\n sys.exit(1)\\r\\n\\r\\n if len(sys.argv) >= 4 and sys.argv[3] != \\\"-\\\":\\r\\n dst = open(sys.argv[3], \\\"wb\\\")\\r\\n elif hasattr(sys.stdout, 'buffer'):\\r\\n dst = sys.stdout.buffer\\r\\n else:\\r\\n dst = sys.stdout\\r\\n\\r\\n if len(sys.argv) >= 3 and sys.argv[2] != \\\"-\\\":\\r\\n src = open(sys.argv[2], \\\"rb\\\")\\r\\n elif hasattr(sys.stdin, \\\"buffer\\\"):\\r\\n src = sys.stdin.buffer\\r\\n else:\\r\\n src = sys.stdin\\r\\n\\r\\n if sys.argv[1] == \\\"-c\\\":\\r\\n method = stream_compress\\r\\n else:\\r\\n method = stream_decompress\\r\\n\\r\\n method(src, dst)\",\n \"def main():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n \\\"text\\\",\\n help=\\\"text to convert (default: read from stdin)\\\",\\n nargs=\\\"?\\\",\\n default=sys.stdin,\\n )\\n parser.add_argument(\\n \\\"-u\\\", \\\"--uppercase\\\", help=\\\"convert to uppercase\\\", action=\\\"store_true\\\"\\n )\\n parser.add_argument(\\n \\\"-s\\\", \\\"--spaces\\\", help=\\\"add spaces between characters\\\", action=\\\"store_true\\\"\\n )\\n args = parser.parse_args()\\n\\n text = read_input(args, parser)\\n processed_text = process_text(text, args)\\n print(processed_text)\",\n \"def pseudo_raw_input(self, prompt):\\n\\n # Deal with the vagaries of readline and ANSI escape codes\\n safe_prompt = self._surround_ansi_escapes(prompt)\\n\\n if self.use_rawinput:\\n try:\\n if sys.stdin.isatty():\\n line = sm.input(safe_prompt)\\n else:\\n line = sm.input()\\n if self.echo:\\n sys.stdout.write('{}{}\\\\n'.format(safe_prompt, line))\\n except EOFError:\\n line = 'eof'\\n else:\\n if self.stdin.isatty():\\n # on a tty, print the prompt first, then read the line\\n self.poutput(safe_prompt, end='')\\n self.stdout.flush()\\n line = self.stdin.readline()\\n if len(line) == 0:\\n line = 'eof'\\n else:\\n # we are reading from a pipe, read the line to see if there is\\n # anything there, if so, then decide whether to print the\\n # prompt or not\\n line = self.stdin.readline()\\n if len(line):\\n # we read something, output the prompt and the something\\n if self.echo:\\n self.poutput('{}{}'.format(safe_prompt, line))\\n else:\\n line = 'eof'\\n return line.strip()\",\n \"def communicate(args, **kwargs):\\n stdin = None\\n # When stdin is passed as an argument, use it as the actual input data and\\n # set the Popen() parameter accordingly.\\n if 'stdin' in kwargs and isinstance(kwargs['stdin'], basestring):\\n stdin = kwargs['stdin']\\n kwargs['stdin'] = PIPE\\n\\n proc = Popen(args, **kwargs)\\n return proc.communicate(stdin), proc.returncode\",\n \"def _on_stdin_read(self, data):\\n if not self.opts[\\\"udp\\\"]:\\n self.fire(write(data))\\n else:\\n self.fire(write((self.host, self.port), data))\",\n \"def write( shell, data ):\\n #print 'cmd: ' + data\\n global waiting\\n os.write( shell.stdin.fileno(), data )\\n waiting = True\",\n \"def scan_input(self):\\n proc = subprocess.Popen([\\\"ssh\\\", \\\"-tt\\\", \\\"pi@127.0.0.1\\\"],\\n stdout=subprocess.PIPE, stdin=subprocess.PIPE)\\n # give time to connect\\n time.sleep(5)\\n proc.stdin.write(\\n b\\\"/home/pi/Desktop/GAssist/env/bin/google-assistant-demo\\\\n\\\")\\n proc.stdin.flush()\\n while True:\\n next_line = proc.stdout.readline()\\n if next_line != '':\\n # the real code does filtering here\\n tmp = next_line.decode(\\\"utf-8\\\")\\n print(tmp)\\n tmp = tmp.strip().lower()\\n for test_re in self.text_regexes:\\n match_test = test_re.match(tmp)\\n if match_test:\\n self.handle_input(match_test.group(1).strip())\\n else:\\n time.sleep(.01)\",\n \"def input(self, prompt):\\r\\n return console_input(prompt)\",\n \"def get_input(prompt):\\n return input(prompt)\",\n \"def get_input(prompt):\\n return input(prompt)\",\n \"def main():\\n test_selector = DefaultTestSelector(init_host_test_cli_params())\\n try:\\n if not sys.stdin.isatty(): # Only monitor stdin if started from a parent process.\\n t = threading.Thread(target=parent_monitor_thread, args=(test_selector,))\\n t.start() # This thread will shutdown automatically after stdin is closed on returning from main()\\n test_selector.run()\\n except (KeyboardInterrupt, SystemExit):\\n test_selector.finish()\\n raise\\n except:\\n pass\\n else:\\n test_selector.finish()\",\n \"def capture(args, **kwargs):\\n kwargs.setdefault('stdin', DEVNULL)\\n\\n # Like check_output, deny the caller from using stdout arg.\\n return communicate(args, stdout=PIPE, **kwargs)[0][0]\",\n \"def map_stdin(fn):\\n line = sys.stdin.readline()\\n while line:\\n try:\\n fn(line.decode('utf8'))\\n except (KeyError, ValueError), exc:\\n stderr(u'%s\\\\n --> %s' % (exc, line.decode('utf8')))\\n except (KeyboardInterrupt, EOFError):\\n stderr(u'\\\\n -- Interrupted, exiting --\\\\n')\\n break\\n\\n line = sys.stdin.readline()\\n\\n stderr(' -- Done --')\",\n \"def run_and_tee_output(args):\\n output_bytes = bytearray()\\n\\n def read(fd):\\n data = os.read(fd, 1024)\\n output_bytes.extend(data)\\n return data\\n\\n pty.spawn(args, read)\\n\\n # Strip ANSI / terminal escapes.\\n output_bytes = _ANSI_ESCAPE_8BIT_REGEX.sub(b'', output_bytes)\\n\\n return output_bytes.decode('utf-8')\",\n \"def _replace_stdin(self, text):\\n orig = sys.stdin\\n sys.stdin = StringIO(text)\\n yield\\n sys.stdin = orig\",\n \"def _queuing_input(procQueue, stdin_fd, query, valid, default):\\n sys.stdin = os.fdopen(stdin_fd)\\n procQueue.put(_get_user_input(query, valid, default))\",\n \"def import_report_from_stdin():\\n content = six.StringIO()\\n for line in fileinput.input([]):\\n content.write(line)\\n content.seek(0)\\n\\n if not content:\\n return\\n import_report_from_email(content)\",\n \"def test_stdin_input(self, api_client):\\n runner = CliRunner()\\n\\n query = \\\"<query>\\\"\\n api_client.stats.return_value = []\\n expected = json.dumps([[]], indent=4, sort_keys=True)\\n\\n result = runner.invoke(subcommand.stats, [\\\"-f\\\", \\\"json\\\"], input=query)\\n assert result.exit_code == 0\\n assert result.output.strip(\\\"\\\\n\\\") == expected\\n api_client.stats.assert_called_with(query=query)\",\n \"def communicate(self, std_in=None, timeout=0):\\n if timeout <= 0:\\n return super(Popen, self).communicate(input=std_in)\\n\\n fds = []\\n stdout = []\\n stderr = []\\n\\n if self.stdout is not None:\\n set_file_nonblock(self.stdout)\\n fds.append(self.stdout)\\n if self.stderr is not None:\\n set_file_nonblock(self.stderr)\\n fds.append(self.stderr)\\n\\n if std_in is not None and sys.stdin is not None:\\n sys.stdin.write(std_in)\\n\\n returncode = None\\n inactive = 0\\n while returncode is None:\\n (rlist, dummy_wlist, dummy_xlist) = select.select(\\n fds, [], [], 1.0)\\n\\n if not rlist:\\n inactive += 1\\n if inactive >= timeout:\\n raise TimeoutError\\n else:\\n inactive = 0\\n for fd in rlist:\\n if fd is self.stdout:\\n stdout.append(fd.read())\\n elif fd is self.stderr:\\n stderr.append(fd.read())\\n\\n returncode = self.poll()\\n\\n if self.stdout is not None:\\n stdout = ''.join(stdout)\\n else:\\n stdout = None\\n if self.stderr is not None:\\n stderr = ''.join(stderr)\\n else:\\n stderr = None\\n\\n return (stdout, stderr)\",\n \"def run(self):\\n def target():\\n # Pass these inputs to STDIN with delays\\n for i in self.delayed_inputs:\\n if type(i) is int or type(i) is float:\\n time.sleep(i)\\n elif type(i) is bytes:\\n try:\\n self.process.stdin.write(i) \\n except IOError as e:\\n lg.info(\\n \\\"Input: {} failed to write to stdin due to\\\\n{}\\\".format(i, e)\\n )\\n break\\n if self.disable_communicate:\\n self.process.wait()\\n else:\\n self.stdout_res, self.stderr_res = self.process.communicate(\\n input=self.inputs)\\n\\n try:\\n self.process = Popen(self.command, stdin=self.stdin,\\n stdout=self.stdout, stderr=self.stderr,\\n start_new_session=True, cwd=self.cwd, env=self.env)\\n except OSError:\\n lg.error(\\\"Couldn't Popen command {}\\\".format(self.command))\\n raise\\n self.thread = Thread(target=target)\\n self.thread.start()\",\n \"def interact(self):\\n print('Ready to interact on socket connected with {}.'.format(self.remote_addr))\\n try:\\n # get initial input from user\\n print('Enter input or press CTRL-D for no input.')\\n data = sys.stdin.readline()\\n self.remote_socket.sendall(data.encode())\\n while True:\\n if data.startswith('exit'):\\n print('[*] Closing remote shell.')\\n self.close()\\n break\\n # wait for response from target host\\n recv_len = 1\\n response = ''\\n while recv_len:\\n data = self.remote_socket.recv(4096)\\n recv_len = len(data)\\n response += data.decode()\\n if recv_len < 4096:\\n break\\n print(response)\\n # get further input from user\\n print('Enter further input or press CTRL-D for no input.')\\n data = sys.stdin.readline()\\n self.remote_socket.sendall(data.encode())\\n except Exception as e:\\n print(e)\\n print('[*] Closing remote shell.')\\n self.close()\",\n \"def clear_in():\\r\\n c = sys.stdin.read(1)\\r\\n while(c!='\\\\n'):\\r\\n c = sys.stdin.read(1)\",\n \"def main(self):\\n cmd = \\\"self.%s(sys.stdin)\\\" % sys.argv[1]\\n exec(cmd)\",\n \"def _get_input(question: str) -> str:\\n print(question)\\n sys.stdout.flush()\\n user_input = sys.stdin.readline()\\n user_input = user_input.strip()\\n return user_input\",\n \"def command(cmd: list, stdin: str):\\n proc = Popen(cmd, stdout=PIPE, stderr=STDOUT, stdin=PIPE)\\n out, err = proc.communicate(stdin.encode(\\\"utf-8\\\"))\\n exit = proc.wait()\\n return out.decode(\\\"utf-8\\\")\",\n \"def communicate(host, port):\\n s = socket.socket()\\n s.connect((host, port))\\n payload = sys.stdin.read().encode()\\n s.sendall(payload)\\n s.shutdown(socket.SHUT_WR)\\n\\n output = []\\n while True:\\n read = s.recv(READ_SIZE)\\n if read:\\n output.append(read.decode())\\n else:\\n break\\n return ''.join(output)\",\n \"def wait_for_input(self):\\n if self._dont_enter_interactive_mode:\\n return\\n stop = False\\n while True:\\n print(\\\">>> \\\", end='')\\n try:\\n command_str = input()\\n except EOFError:\\n print(\\\"Exiting interactive mode\\\")\\n break\\n stop = self.interpret_command(command_str)\\n if stop:\\n print(\\\"Exiting interactive mode\\\")\\n break\",\n \"def new_user_input(self):\\n ready, _, _ = select([stdin], [], [], 0.0)\\n return stdin in ready\",\n \"def read():\\n for line in sys.stdin:\\n if line == \\\"\\\\n\\\":\\n return\\n log_elements.append(log_element(line))\",\n \"def recvraw(self):\\n\\n if self.stdin is None:\\n return _python_input_function()\\n else:\\n return self.stdin.readline().rstrip('\\\\n')\",\n \"def pseudo_raw_input(self, prompt):\\n\\n if self.use_rawinput:\\n try:\\n line = sm.input(prompt)\\n except EOFError:\\n line = 'EOF'\\n else:\\n self.stdout.write(prompt)\\n self.stdout.flush()\\n line = self.stdin.readline()\\n if not len(line):\\n line = 'EOF'\\n else:\\n if line[-1] == '\\\\n': # this was always true in Cmd\\n line = line[:-1]\\n return line\",\n \"def runcmd(args, stdin=None):\\n if type(args) is str:\\n args = shlex.split(args)\\n args = map(str, args)\\n proc = subprocess.Popen(args, stdout=subprocess.PIPE,\\n stdin=stdin)\\n if stdin is None:\\n return proc.stdout.read()\\n else:\\n return proc\",\n \"async def interactive_shell():\\n # Create Prompt.\\n session = PromptSession('Say something: ')\\n\\n # Run echo loop. Read text from stdin, and reply it back.\\n while True:\\n try:\\n result = await session.prompt(async_=True)\\n print('You said: \\\"{0}\\\"'.format(result))\\n except (EOFError, KeyboardInterrupt):\\n return\",\n \"def pipestring_process(cmd_string, stdin_string=''):\\n f=SpooledTemporaryFile()\\n f.write(stdin_string)\\n f.seek(0)\\n results=process(cmd_string, stdin=f)\\n f.close()\\n return results\",\n \"def reset_stdio(default_stdout, default_stdin):\\r\\n sys.stdin = default_stdin\\r\\n sys.stdout = default_stdout\",\n \"def output_to_pipe(pipe_in):\\n os.dup2(pipe_in, 1) # stdout\\n # os.dup2(pipe_in, 2) # stderr\",\n \"def test_cli_stdin(\\n config,\\n):\\n from YesssSMS.api import MAX_MESSAGE_LENGTH_STDIN\\n\\n testargs = [\\\"yessssms\\\", \\\"--test\\\", \\\"-l\\\", \\\"06641234567\\\", \\\"-p\\\", \\\"passw0rd\\\", \\\"-m\\\", \\\"-\\\"]\\n\\n in_message = \\\"\\\"\\\"Da steh’ ich nun, ich armer Thor!\\nUnd bin so klug als wie zuvor;\\nHeiße Magister, heiße Doctor gar,\\nUnd ziehe schon an die zehen Jahr,\\nHerauf, herab und quer und krumm,\\nMeine Schüler an der Nase herum –\\nUnd sehe, daß wir nichts wissen können!\\nDas will mir schier das Herz verbrennen.\\nZwar bin ich gescheidter als alle die Laffen,\\nDoctoren, Magister, Schreiber und Pfaffen;\\nMich plagen keine Scrupel noch Zweifel,\\nFürchte mich weder vor Hölle noch Teufel –\\nDafür ist mir auch alle Freud’ entrissen,\\nBilde mir nicht ein was rechts zu wissen,\\nBilde mir nicht ein, ich könnte was lehren,\\nDie Menschen zu bessern und zu bekehren.\\nAuch hab’ ich weder Gut noch Geld,\\nNoch Ehr’ und Herrlichkeit der Welt.\\nEs möchte kein Hund so länger leben!\\nDrum hab’ ich mich der Magie ergeben,\\nOb mir durch Geistes Kraft und Mund\\nNicht manch Geheimniß würde kund;\\nDaß ich nicht mehr mit sauerm Schweiß,\\nZu sagen brauche, was ich nicht weiß;\\\"\\\"\\\"\\n with mock.patch.object(sys, \\\"argv\\\", testargs):\\n with mock.patch.object(sys, \\\"stdin\\\", in_message):\\n with requests_mock.Mocker() as m:\\n m.register_uri(\\n \\\"POST\\\",\\n # pylint: disable=protected-access\\n _LOGIN_URL,\\n status_code=302,\\n # pylint: disable=protected-access\\n headers={\\\"location\\\": _KONTOMANAGER_URL},\\n )\\n m.register_uri(\\n \\\"GET\\\",\\n # pylint: disable=protected-access\\n _KONTOMANAGER_URL,\\n status_code=200,\\n )\\n m.register_uri(\\n \\\"GET\\\",\\n # pylint: disable=protected-access\\n _SMS_FORM_URL,\\n status_code=200,\\n text=TEST_FORM_TOKEN_SAMPLE,\\n )\\n m.register_uri(\\n \\\"POST\\\",\\n # pylint: disable=protected-access\\n _SEND_SMS_URL,\\n status_code=200,\\n text=\\\"<h1>Ihre SMS wurde erfolgreich \\\" + \\\"verschickt!</h1>\\\",\\n )\\n m.register_uri(\\n \\\"GET\\\",\\n # pylint: disable=protected-access\\n _LOGOUT_URL,\\n status_code=200,\\n )\\n\\n message = CLI().message\\n\\n assert message.startswith(\\n \\\"\\\"\\\"Da steh’ ich nun, ich armer Thor!\\nUnd bin so klug als wie zuvor;\\\"\\\"\\\"\\n )\\n assert message == in_message[:MAX_MESSAGE_LENGTH_STDIN]\",\n \"def console(self, message):\\n if self.proc is None or self.proc.poll() is not None:\\n return\\n message = message.split('\\\\n')[0] + '\\\\n'\\n self.proc.stdin.write(message.encode())\\n self.proc.stdin.flush()\",\n \"def read():\\n\\n try:\\n rl, _, _ = select([sys.stdin], [], [], 1.0)\\n if not rl:\\n return None\\n except SelectError:\\n return None\\n\\n inp = raw_input().strip()\\n if inp == '[':\\n return None\\n\\n inp = inp.strip(\\\",\\\")\\n inp = json.loads(inp)\\n return inp\",\n \"def inp(text):\\r\\n input(text)\",\n \"def _launch_command(args, out_cb, err_cb, done=None, **kwargs):\\n\\n def pump_stream(callback, stream):\\n \\\"\\\"\\\"Pump the stream\\\"\\\"\\\"\\n for line in stream:\\n callback(line)\\n callback(None)\\n\\n def joiner():\\n \\\"\\\"\\\"Wait for streams to finish, then call done callback\\\"\\\"\\\"\\n for th in threads:\\n th.join()\\n done(process)\\n\\n kwargs = kwargs.copy()\\n in_data = kwargs.get(\\\"input\\\")\\n if \\\"input\\\" in kwargs:\\n del kwargs[\\\"input\\\"]\\n assert kwargs.get(\\\"stdin\\\") is None, kwargs[\\\"stdin\\\"]\\n kwargs[\\\"stdin\\\"] = PIPE\\n elif \\\"stdin\\\" not in kwargs:\\n kwargs[\\\"stdin\\\"] = DEVNULL\\n kwargs.setdefault(\\\"stdout\\\", PIPE)\\n kwargs.setdefault(\\\"stderr\\\", PIPE)\\n kwargs[\\\"universal_newlines\\\"] = True # Text streams, not byte streams\\n process = Popen(args, **kwargs)\\n threads = []\\n if process.stdout:\\n thread = Thread(\\n target=pump_stream, args=(out_cb, process.stdout), daemon=True\\n )\\n thread.start()\\n threads.append(thread)\\n if process.stderr:\\n thread = Thread(\\n target=pump_stream, args=(err_cb, process.stderr), daemon=True\\n )\\n thread.start()\\n threads.append(thread)\\n if done and threads:\\n Thread(target=joiner, daemon=True).start()\\n if in_data:\\n process.stdin.write(str(in_data, \\\"utf-8\\\"))\\n process.stdin.close()\\n return process\",\n \"def cont():\\n\\n try:\\n input = raw_input()\\n except Exception:\\n pass\",\n \"def run_python_stdin(python, file_args=None, directives=None):\\n import shutil\\n import tempfile\\n\\n with tempfile.NamedTemporaryFile(suffix='.py') as f:\\n shutil.copyfileobj(sys.stdin, f)\\n f.flush()\\n\\n file_args = [f.name] + list(file_args or ())\\n run_python_file(python, file_args, directives)\",\n \"def send_msg(self, msg):\\n self.proc.stdin.write(msg)\",\n \"def run_interactive(cls, shell, command, input):\\n feed = '\\\\\\\\n'.join(input)\\n icommand = \\\"echo -e '{}' | {}\\\".format(feed, command)\\n _stdout, _stderr = cls.run(shell, icommand)\\n return _stdout\",\n \"def rshell(self, chan):\\n logging.debug(\\\"\\\")\\n logging.debug(\\\"************************************************************\\\")\\n import select\\n import termios\\n import tty\\n import socket\\n from paramiko.py3compat import u\\n oldtty = termios.tcgetattr(sys.stdin)\\n try:\\n tty.setraw(sys.stdin.fileno())\\n tty.setcbreak(sys.stdin.fileno())\\n chan.settimeout(0.0)\\n while True:\\n r, w, e = select.select([chan, sys.stdin], [], [])\\n if chan in r:\\n try:\\n x = u(chan.recv(1024))\\n if len(x) == 0:\\n sys.stdout.write('\\\\n\\\\n')\\n break\\n sys.stdout.write(x)\\n sys.stdout.flush()\\n except socket.timeout:\\n pass\\n if sys.stdin in r:\\n x = sys.stdin.read(1)\\n if len(x) == 0:\\n break\\n chan.send(x)\\n finally:\\n termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)\",\n \"def send_stdin(self, s_bytes):\\n self._proc.stdin.write(s_bytes)\\n self._proc.stdin.flush()\",\n \"def read_mapper_input(stdin):\\n for line in stdin:\\n yield line.rstrip()\",\n \"def inputloop():\\n while True:\\n for char in raw_input().decode('utf-8'):\\n print script(char)\",\n \"def _posix_shell(cls, chan, user_input, iotimeout, iodelay, cmcli_bool):\\n timeout = 60 # 1 mins , only its only applicable to cmcli ssl commands\\n result = ''\\n input = list(user_input)\\n cmcli_ssl_bool = False\\n last_prompt = ''\\n if len(filter(lambda x: x.find('ssl') >= 0, user_input)) > 0:\\n cmcli_ssl_bool = True\\n if cmcli_bool:\\n input_end = 1\\n else:\\n input_end = 0\\n try:\\n iotimeout_save = chan.gettimeout()\\n chan.settimeout(iotimeout)\\n input.reverse()\\n start_time = time.time()\\n\\n while True:\\n # we dont need this hack this is only happenning for ssl tests\\n if cmcli_ssl_bool and time.time() - start_time > timeout:\\n log.error('time to break out of the loop.waited %s seconds' % timeout)\\n raise OSError('Remote Command timeout after {} seconds'.format(timeout))\\n log.debug('Running select')\\n r, w, e = select.select([chan, sys.stdin], [], [], 5)\\n log.debug('select done')\\n\\n log.debug('r: %s' % repr(r))\\n log.debug('w: %s' % repr(w))\\n log.debug('e: %s' % repr(e))\\n\\n if chan in r:\\n log.debug('rlist: wait until ready for reading')\\n try:\\n log.debug('channel receiving data')\\n\\n # Start with something\\n x = \\\"DO IT\\\"\\n while len(x) > 0:\\n\\n # Got stuff. Print it\\n time.sleep(iodelay)\\n log.debug('get some data')\\n x = chan.recv(20480)\\n last_prompt = x\\n result += x\\n log.debug('data received. Write it to stdout')\\n sys.stdout.write(x)\\n log.debug('flushing stdout')\\n sys.stdout.flush()\\n\\n # We've sent it all. Let's get out\\n if len(input) == input_end:\\n log.debug('NOTHING LEFT TO SEND')\\n raise\\n\\n # Program exited too soon\\n if chan.exit_status_ready():\\n log.warn('Hit exit status ready sooner than expected')\\n chan.send('\\u0004\\\\n')\\n raise\\n\\n except socket.timeout:\\n log.debug('All stdout exhausted')\\n if len(input) > input_end:\\n x = input.pop()\\n log.debug('SENDING to input stream: %s' % x)\\n chan_in = '%s\\\\n' % x\\n chan.send(chan_in)\\n result += chan_in\\n else:\\n if chan.exit_status_ready():\\n log.info('Program ready to exit')\\n break\\n\\n # Keep reading for cmcli commands since we need to\\n # wait until we get back to the prompt\\n if not cmcli_bool:\\n log.debug('Break out of select loop')\\n break\\n elif last_prompt and last_prompt.lower().find('cryptomanager>') >= 0:\\n log.debug('Cryptomanager prompt is seen')\\n break\\n pass\\n\\n if not r:\\n # FIXME: I think we want to inspect the the last prompt.\\n # If it was input, we should probably attempt another select\\n # if we are running a cmcli command\\n log.debug(\\\"Nothing to send or unexpected prompt. \\\" +\\n \\\"Prompt was: %s\\\" % last_prompt)\\n raise\\n\\n finally:\\n\\n # Assume the last input is logout\\n if cmcli_bool:\\n x = input.pop()\\n log.debug('SENDING logout to input stream: %s' % x)\\n chan_in = '%s\\\\n' % x\\n chan.send(chan_in)\\n result += chan_in\\n\\n log.debug('Trying to get exit status for command')\\n exit_status = chan.recv_exit_status()\\n log.debug('Got exit status for command: %s', exit_status)\\n x = chan.recv(20480)\\n log.debug(\\\"Last data received: %s\\\" % x)\\n result += x\\n sys.stdout.write(x)\\n sys.stdout.flush()\\n log.debug(\\\"return from posix shell\\\")\\n chan.settimeout(iotimeout_save)\\n return result, exit_status\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.699605","0.6673594","0.6417195","0.641211","0.63803685","0.63787425","0.63246727","0.628672","0.6164965","0.6164865","0.6141185","0.6102546","0.6100803","0.59521854","0.5943102","0.58946633","0.58735377","0.58601946","0.5853264","0.58521783","0.5836183","0.5803626","0.5798304","0.57949054","0.57824427","0.5707754","0.5690607","0.5687231","0.56852293","0.5682402","0.5652561","0.5637827","0.56319386","0.56290704","0.5619967","0.5619096","0.5618336","0.5601411","0.55910605","0.55907136","0.55814415","0.5576247","0.55617195","0.55604553","0.55270356","0.5513825","0.5501272","0.5482545","0.5481424","0.5480984","0.54758644","0.545313","0.5444845","0.54400015","0.543986","0.54360914","0.5426012","0.54250026","0.541901","0.5417947","0.5417947","0.541516","0.53869194","0.5381627","0.53794783","0.5377383","0.53638613","0.5359005","0.5352926","0.53529143","0.53423756","0.534228","0.5339324","0.5338014","0.53366446","0.5321602","0.5316449","0.5314771","0.5306246","0.529918","0.5295762","0.5292571","0.52773505","0.52746165","0.5272242","0.5258691","0.525559","0.52549416","0.5252604","0.52429676","0.5237546","0.52350044","0.5229626","0.5228672","0.522797","0.5223973","0.52189577","0.5217393","0.52167207","0.52082986","0.5207655"],"string":"[\n \"0.699605\",\n \"0.6673594\",\n \"0.6417195\",\n \"0.641211\",\n \"0.63803685\",\n \"0.63787425\",\n \"0.63246727\",\n \"0.628672\",\n \"0.6164965\",\n \"0.6164865\",\n \"0.6141185\",\n \"0.6102546\",\n \"0.6100803\",\n \"0.59521854\",\n \"0.5943102\",\n \"0.58946633\",\n \"0.58735377\",\n \"0.58601946\",\n \"0.5853264\",\n \"0.58521783\",\n \"0.5836183\",\n \"0.5803626\",\n \"0.5798304\",\n \"0.57949054\",\n \"0.57824427\",\n \"0.5707754\",\n \"0.5690607\",\n \"0.5687231\",\n \"0.56852293\",\n \"0.5682402\",\n \"0.5652561\",\n \"0.5637827\",\n \"0.56319386\",\n \"0.56290704\",\n \"0.5619967\",\n \"0.5619096\",\n \"0.5618336\",\n \"0.5601411\",\n \"0.55910605\",\n \"0.55907136\",\n \"0.55814415\",\n \"0.5576247\",\n \"0.55617195\",\n \"0.55604553\",\n \"0.55270356\",\n \"0.5513825\",\n \"0.5501272\",\n \"0.5482545\",\n \"0.5481424\",\n \"0.5480984\",\n \"0.54758644\",\n \"0.545313\",\n \"0.5444845\",\n \"0.54400015\",\n \"0.543986\",\n \"0.54360914\",\n \"0.5426012\",\n \"0.54250026\",\n \"0.541901\",\n \"0.5417947\",\n \"0.5417947\",\n \"0.541516\",\n \"0.53869194\",\n \"0.5381627\",\n \"0.53794783\",\n \"0.5377383\",\n \"0.53638613\",\n \"0.5359005\",\n \"0.5352926\",\n \"0.53529143\",\n \"0.53423756\",\n \"0.534228\",\n \"0.5339324\",\n \"0.5338014\",\n \"0.53366446\",\n \"0.5321602\",\n \"0.5316449\",\n \"0.5314771\",\n \"0.5306246\",\n \"0.529918\",\n \"0.5295762\",\n \"0.5292571\",\n \"0.52773505\",\n \"0.52746165\",\n \"0.5272242\",\n \"0.5258691\",\n \"0.525559\",\n \"0.52549416\",\n \"0.5252604\",\n \"0.52429676\",\n \"0.5237546\",\n \"0.52350044\",\n \"0.5229626\",\n \"0.5228672\",\n \"0.522797\",\n \"0.5223973\",\n \"0.52189577\",\n \"0.5217393\",\n \"0.52167207\",\n \"0.52082986\",\n \"0.5207655\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21977,"cells":{"query":{"kind":"string","value":"Return the widget to give focus to when this plugin's dockwidget is raised on toplevel"},"document":{"kind":"string","value":"def get_focus_widget(self):\n return self.datatree"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_focus_widget(self):\r\n return self.shell","def XPGetWidgetWithFocus():\n pass","def get_focus(self):\n\n self.activateWindow()\n self.setFocus()","def get_focus_widget(self):\n # TODO - focus on channel list\n# self.combo.lineEdit().selectAll()\n# return self.combo\n return None","def dock_widget(self):\n d = self.declaration.dock_widget()\n if d is not None:\n return d.proxy.widget","def get_focus_widget(self):\r\n return self.get_current_editor()","def XPSetKeyboardFocus(inWidget):\n pass","def focus_master(qtile):\n grp = qtile.current_group\n if grp.layout.clients.current_index > 0:\n c = grp.layout.clients.focus_first()\n grp.focus(c, True)\n elif grp.layout.clients.current_index == 0 and len(grp.layout.clients.clients) > 0:\n grp.layout.cmd_down()","def XPBringRootWidgetToFront(inWidget):\n pass","def __window_focus(self):\n pass","def Top(self):\r\n\r\n self.dock_direction = AUI_DOCK_TOP\r\n return self","def Top(self):\r\n\r\n self.dock_direction = AUI_DOCK_TOP\r\n return self","def siguiente(self, widget):\n window = widget.get_toplevel()\n window.do_move_focus(window, gtk.DIR_TAB_FORWARD)","def get_focus(self, c: Cmdr=None, raw: bool=False, at_idle: bool=False) -> Widget:\n trace = 'focus' in g.app.debug\n trace_idle = False\n trace = trace and (trace_idle or not at_idle)\n app = QtWidgets.QApplication\n w = app.focusWidget()\n if w and not raw and isinstance(w, qt_text.LeoQTextBrowser):\n has_w = getattr(w, 'leo_wrapper', None)\n if has_w:\n if trace:\n g.trace(w)\n elif c:\n # Kludge: DynamicWindow creates the body pane\n # with wrapper = None, so return the LeoQtBody.\n w = c.frame.body\n if trace:\n name = w.objectName() if hasattr(w, 'objectName') else w.__class__.__name__\n g.trace('(LeoQtGui)', name)\n return w","def widget(self) -> tk.Frame:\r\n return self.main_frame","def toolkit_widget(self):\n return self.widget","def focus_window(i3, container_id):\n i3.command(f'[con_id=\"{container_id}\"] floating enable')\n i3.command(f'[con_id=\"{container_id}\"] focus')","def widget(self):\n return self.containedWidget","def set_focus(self, c: Cmdr, w: Wrapper) -> None:\n if not w:\n return\n if getattr(w, 'widget', None):\n if not isinstance(w, QtWidgets.QWidget):\n # w should be a wrapper.\n w = w.widget\n if 'focus' in g.app.debug:\n name = w.objectName() if hasattr(w, 'objectName') else w.__class__.__name__\n g.trace('(LeoQtGui)', name)\n w.setFocus()","def get_current_focus():\n\n grab = Gtk.grab_get_current()\n if grab:\n return grab\n\n for win in Gtk.Window.list_toplevels():\n if win.get_property('has-toplevel-focus'):\n return win.get_focus()\n return None","def OnChildFocus(self, event):\r\n\r\n # when a child pane has it's focus set, we should change the \r\n # pane's active state to reflect this. (this is only true if \r\n # active panes are allowed by the owner)\r\n\r\n window = event.GetWindow()\r\n if isinstance(window, wx.Dialog):\r\n # Ignore EVT_CHILD_FOCUS events originating from dialogs not\r\n # managed by AUI\r\n rootManager = None\r\n elif isinstance(window.GetParent(), AuiFloatingFrame):\r\n rootManager = GetManager(window)\r\n else:\r\n rootManager = self\r\n \r\n if rootManager:\r\n rootManager.ActivatePane(window)\r\n \r\n event.Skip()","def XPGetParentWidget(inWidget):\n pass","def maybe_focus_parent(self):\n parent_window_data = self.get_windows_with_parent_data()\n focused_node = filter(lambda w: w['window']['focused'], parent_window_data)\n if len(focused_node) <= 0:\n return\n focused_node = focused_node[0]\n\n focused_parent = focused_node['parent']\n focused_window = focused_node['window']\n if focused_parent['layout'] == 'tabbed':\n call('i3-msg focus parent')","def _get_toolkit_widget(self):\n try:\n res = self.parent.toolkit_widget\n except AttributeError:\n res = None\n return res","def focus(self, focus_library=True):\n if focus_library:\n self.treeview.grab_focus()\n if not self.grid.is_visible():\n self.toggle()\n else:\n self.vimiv.image.vimiv.image.scrolled_win.grab_focus()\n # Update info for the current mode\n self.vimiv.statusbar.update_info()","def set_top_widget(self, widg):\r\n if widg in self.widgets:\r\n self.widgets.remove(widg)\r\n self.widgets.insert(0, widg)\r\n for i in self.widgets:\r\n if i.get_visible():\r\n if not i == widg:\r\n i.unfocus()","def focus(self):\n raise NotImplementedError","def SetFocus(self):\r\n \r\n self._main_win.SetFocus()","def edit_widget_focus(self):\n if self.goto:\n self.goto_node()\n self.update_position(self.get_position())","def get_parent_window(self): # real signature unknown; restored from __doc__\n pass","def XPLoseKeyboardFocus(inWidget):\n pass","def get_master_widget(self, top: Widget=None) -> Widget:\n if top is None:\n top = self.c.frame.top\n master = top.leo_master or top\n return master","def getFocusedWindow(self):\n for window in self.getWindows().values():\n if window.focused:\n return window\n return None","def ev_windowfocusgained(self, event: WindowEvent) -> None:","def get_widget(self):\n\t\treturn None","def focus(self):\n self.image_window.focus_set()","def OnSetFocus(self, event):\r\n\r\n treectrl = self._wnd.GetParent()\r\n select = treectrl.GetSelection()\r\n\r\n # If the window is associated to an item that currently is selected\r\n # (has focus) we don't kill the focus. Otherwise we do it.\r\n if select != self:\r\n treectrl._hasFocus = False\r\n else:\r\n treectrl._hasFocus = True\r\n \r\n event.Skip()","def get_widget(self):\r\n return None","def takeWidget(self):\n widget = self.containedWidget\n if self.containedWidget:\n self.layout().removeWidget(self.containedWidget)\n self.containedWidget.setParent(None)\n self.containedWidget = None\n self.toolBar = None\n return widget","def Center(self):\r\n \r\n self.dock_direction = AUI_DOCK_CENTER\r\n return self","def ev_windowfocusgained(self, event: tcod.event.WindowEvent) -> T | None:","def Center(self):\r\n\r\n self.dock_direction = AUI_DOCK_CENTER\r\n return self","def currently_focused(self) -> int:","def OnSetFocus(self, event):\r\n\r\n self._owner.SetFocus()","def OnSetFocus(self, event):\r\n\r\n treectrl = self._owner\r\n select = treectrl.GetSelection()\r\n\r\n # If the window is associated to an item that currently is selected\r\n # (has focus) we don't kill the focus. Otherwise we do it.\r\n if select != self:\r\n treectrl._hasFocus = False\r\n else:\r\n treectrl._hasFocus = True\r\n \r\n event.Skip()","def init_widget(self):\n super(WxDockPane, self).init_widget()\n d = self.declaration\n self.set_title(d.title)\n self.set_title_bar_visible(d.title_bar_visible)\n self.set_title_bar_orientation(d.title_bar_orientation)\n self.set_closable(d.closable)\n self.set_movable(d.movable)\n self.set_floatable(d.floatable)\n self.set_floating(d.floating)\n self.set_dock_area(d.dock_area)\n self.set_allowed_dock_areas(d.allowed_dock_areas)\n widget = self.widget\n widget.Bind(EVT_DOCK_PANE_FLOATED, self.on_floated)\n widget.Bind(EVT_DOCK_PANE_DOCKED, self.on_docked)\n widget.Bind(EVT_DOCK_PANE_CLOSED, self.on_closed)","def focus_on_main_content(self):\n self.browser.execute_script(\"$('#main-content').focus()\")","def Dock(self):\r\n\r\n if self.IsNotebookPage():\r\n self.notebook_id = -1\r\n self.dock_direction = AUI_DOCK_NONE\r\n \r\n return self.SetFlag(self.optionFloating, False)","def FindFocusDescendant(ancestor):\r\n\r\n # Process events starting with the window with the focus, if any.\r\n focusWin = wx.Window.FindFocus()\r\n win = focusWin\r\n\r\n # Check if this is a descendant of this frame.\r\n # If not, win will be set to NULL.\r\n while win:\r\n if win == ancestor:\r\n break\r\n else:\r\n win = win.GetParent()\r\n\r\n if win is None:\r\n focusWin = None\r\n\r\n return focusWin","def GetMainWindow(self):\r\n \r\n return self._main_win","def TopDockable(self, b=True):\r\n \r\n return self.SetFlag(self.optionTopDockable, b)","def XPGetWidgetUnderlyingWindow(inWidget):\n pass","def getFocus(*args):","def getFocus(*args):","def getFocus(*args):","def getFocus(*args):","def __window_getSelection(self):\n return None","def getCurrentNodeEditorWidget(self):\n activeSubWindow = self.mdiArea.activeSubWindow()\n if activeSubWindow:\n return activeSubWindow.widget()\n return None","def getCurrentNodeEditorWidget(self):\n activeSubWindow = self.mdiArea.activeSubWindow()\n if activeSubWindow:\n return activeSubWindow.widget()\n return None","def focus_on(window):\n return Cmd(\"{}wincmd w\", window)","def __quickSearchFocusIn(self):\n self.quickFindtextCombo.lastActive = self.activeWindow()","def window(self):\n\tif getattr(self.android.settings, 'LV_AVOID_FOCUSED_COMMAND',\n\t\t\t\tself.android.internal.device.google_experience):\n\t\treturn window.previous(self)\n\n def fallback_window_command():\n try:\n w=self.android.internal.transport.view_server_query( 'FOCUSED\\n' )[0]\n except:\n w=\"\"\n return w\n\n try:\n # can't use GET_FOCUS command in secure builds, so fall back to FOCUSED command\n if self.android.device.is_secure_build():\n raise Exception()\n\t w=self.android.internal.transport.view_server_query('GET_FOCUS\\n')[0].split()[1]\n except:\n w = fallback_window_command()\n\n\tself.android.log.verbose(android.ui.TAG, \"Current window: '%s'\" % w)\n\treturn w","def Bottom(self):\r\n\r\n self.dock_direction = AUI_DOCK_BOTTOM\r\n return self","def Bottom(self):\r\n\r\n self.dock_direction = AUI_DOCK_BOTTOM\r\n return self","def focus_event(self, widget, event, hasFocus):\n return self.make_callback('focus', hasFocus)","def GetDock(self):\n return self.dock","def XPFindRootWidget(inWidget):\n pass","def main_window():\n # case: Maya\n if pkgutil.find_loader(\"maya\"):\n for obj in QtWidgets.QApplication.topLevelWidgets():\n if obj.objectName() == \"MayaWindow\":\n return obj\n\n # case: Houdini\n if pkgutil.find_loader(\"hou\"):\n module = importlib.import_module(\"hou\")\n return getattr(module.qt, \"mainWindow\")()\n\n # case: Nuke\n if pkgutil.find_loader(\"nuke\"):\n for obj in QtWidgets.QApplication.topLevelWidgets():\n cls_name = obj.metaObject().className()\n inherits = obj.inherits(\"QMainWindow\")\n if inherits and cls_name == \"Foundry::UI::DockMainWindow\":\n return obj\n\n return None","def win_raise(self):\n self.raise_()\n self.activateWindow()","def main_window(self) -> MainWindow:\n return self._main_window","def getRoot(self):\r\n if self.isFrame: return self.frame\r\n else: return self.master","def get_focus(self):\n return self._get_at(self._current)","def event(event):\n # Special case gets priority over modal widgets (e.g. scroll handles)\n for w in special_case:\n if event.type == MOUSEBUTTONDOWN:\n if w.rect.collidepoint(event.pos):\n focus.add(2, w)\n break\n else:\n focus.empty()\n else:\n if modal_widgets and not focus:\n modal_widgets.sprites()[-1].add(0)\n\n # Mouse focus\n if event.type == MOUSEBUTTONDOWN:\n if not modal_widgets:\n hit = False\n for widget_list in (reversed(layer_widgets.sprites()),\n active_widgets):\n for widget in widget_list:\n # Check if user clicked a widget\n if widget._can_focus and \\\n widget.rect.collidepoint(event.pos):\n if event.button == 1:\n focus.add(2, widget)\n if widget in layer_widgets:\n layer_widgets.move_to_front(widget)\n elif 4 <= event.button <= 7:\n widget._event(event)\n hit = True\n break\n if hit: break\n # Lose focus if clicking away from widgets\n if not hit:\n focus.empty()\n # Keyboard focus\n elif event.type == KEYDOWN and event.key == K_TAB:\n if not modal_widgets and focus_order:\n # Flattened focus_order\n order = sum(focus_order,())\n if focus.sprite not in order:\n curr_num = None\n else:\n # Focus number for current focused widget\n curr_num = order[order.index(focus.sprite)-1]\n # Sorted list of the focus numbers being used\n list_num = sorted(order[::2])\n if not event.mod & KMOD_SHIFT: # Move focus to next widget\n if curr_num is None:\n # If nothing focused, focus first widget\n new_num = list_num[0]\n elif not focus.sprite._change_focus(True):\n # Don't change when not at end of container widget\n new_num = curr_num\n elif list_num.index(curr_num) == len(list_num)-1:\n # Jump back to first widget\n new_num = list_num[0]\n else:\n # Next focus number in the list\n new_num = list_num[list_num.index(curr_num)+1]\n else: # Shift key - move focus to previous widget\n if curr_num is None:\n new_num = list_num[-1]\n elif not focus.sprite._change_focus(False):\n new_num = curr_num\n elif list_num.index(curr_num) == 0:\n # Jump back to last widget\n new_num = list_num[len(list_num)-1]\n else:\n new_num = list_num[list_num.index(curr_num)-1]\n if curr_num != new_num:\n # Set widget at new focus number\n focus.add(1, order[order.index(new_num)+1])\n\n # Send event to focused widget\n if focus:\n focus.sprite._event(event)","def _focus(self, event) -> None:\n self.focus = True","def create_widget(self):\n self.widget = wxDockPane(self.parent_widget())","def get_widget(self):\n return self.imgwin","def setFocus(*args):","def setFocus(*args):","def setFocus(*args):","def setFocus(*args):","def getPlotFocus():\n return simuConfig[\"PLOT.FOCUS\"]","def __switchFocus(self):\n if self.__focus == 0:\n self.__isoWindow.unfocus()\n self.__logWindow.focus()\n self.__focus = 1\n self.__focusedWindow = self.__logWindow\n else:\n self.__isoWindow.focus()\n self.__logWindow.unfocus()\n self.__focus = 0\n self.__focusedWindow = self.__isoWindow","def HandleFocusIn(self, event: tkEvent):\n pass","def OnChildFocusNotebook(self, event):\r\n \r\n # if we're dragging a tab, don't change the current selection.\r\n # This code prevents a bug that used to happen when the hint window\r\n # was hidden. In the bug, the focus would return to the notebook\r\n # child, which would then enter this handler and call\r\n # SetSelection, which is not desired turn tab dragging.\r\n\r\n event.Skip()\r\n \r\n all_panes = self._mgr.GetAllPanes()\r\n for pane in all_panes:\r\n if pane.name == \"dummy\":\r\n continue\r\n tabframe = pane.window\r\n if tabframe._tabs.IsDragging():\r\n return","def getWidget(self):","def widget(self) -> ttk.Treeview:\r\n return self.wrapper","def get_toplevel(self):\n raise NotImplementedError","def get_main_window():\n\n pass","def findFormWindow(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads\n return QDesignerFormWindowInterface","def __init__(self, **kwargs):\n parent = ArgsUtils.extract('parent', None, kwargs)\n self._application = ArgsUtils.extract('pyGlassApp', None, kwargs)\n self._qApplication = ArgsUtils.extract('qApp', None, kwargs)\n self._isMainWindow = ArgsUtils.extract('isMainWindow', bool(parent is None), kwargs)\n self._mainWindow = ArgsUtils.extract('mainWindow', None, kwargs)\n self._centerWidget = None\n\n self._keyboardCallback = ArgsUtils.extract('keyboardCallback', None, kwargs)\n\n if not self._mainWindow:\n if self._isMainWindow:\n self._mainWindow = self\n elif self._application:\n self._mainWindow = self._application.mainWindow\n\n self._dependentWindows = []\n self._currentWidget = None\n\n QtGui.QMainWindow.__init__(self, parent, ArgsUtils.extract('flags', 0, kwargs))\n\n if self._keyboardCallback is not None:\n self.setFocusPolicy(QtCore.Qt.StrongFocus)\n\n if self._isMainWindow:\n self._log = Logger(self, printOut=True)\n self._config = ApplicationConfig(self)\n self._commonConfig = ApplicationConfig(self, common=True)\n self._resourceFolderParts = PyGlassGuiUtils.getResourceFolderParts(self)\n\n icon = PyGlassGuiUtils.createIcon(\n ArgsUtils.get('iconsPath', self.getAppResourcePath('icons', isDir=True), kwargs) )\n if icon:\n self.setWindowIcon(icon)\n\n elif self._mainWindow:\n icon = self._mainWindow.windowIcon()\n if icon:\n self.setWindowIcon(icon)\n\n # Loads the ui file if it exists\n hasWindowFile = ArgsUtils.get('mainWindowFile', False, kwargs)\n if hasWindowFile:\n if not self._centerWidget:\n self._createCentralWidget()\n UiFileLoader.loadWidgetFile(self, target=self._centerWidget)\n\n self._styleSheet = ArgsUtils.get('styleSheet', None, kwargs)\n if self._styleSheet:\n self.setStyleSheet(self.styleSheetPath)\n\n # Sets a non-standard central widget\n centralWidgetName = ArgsUtils.get('centralWidgetName', None, kwargs)\n if centralWidgetName and hasattr(self, centralWidgetName):\n self._centerWidget = getattr(self, centralWidgetName)\n elif not hasWindowFile:\n self._centerWidget = None\n if ArgsUtils.get('defaultCenterWidget', False, kwargs):\n self._createCentralWidget()\n\n self._lastWidgetID = None\n self._widgetParent = None\n self._widgets = None\n self._widgetFlags = None\n\n self._widgetClasses = ArgsUtils.get('widgets', None, kwargs)\n if self._widgetClasses:\n self._initializeWidgetChildren()\n else:\n self._widgetClasses = dict()\n\n self.setWindowTitle(ArgsUtils.get('title', self._createTitleFromClass(), kwargs))\n self.updateStatusBar()","def focusInEvent(self, evt):\n self.gotFocus.emit()\n super(QuickSearchLineEdit, self).focusInEvent(evt) # pass it on","def click_user_widget_button(self):\n return self","def _current_window_for_event(event):\n return event.app.layout.current_window","def onInvoke():\n if dock.isVisible():\n dock.toggleViewAction().trigger()\n else:\n dock.setFloating(True)\n pos = QtGui.QCursor.pos()\n dock.move(pos.x() - dock.size().width() / 2,\n pos.y() - dock.size().height() / 2)\n dock.setVisible(True)","def DefaultPane(self):\r\n \r\n state = self.state \r\n state |= self.optionTopDockable | self.optionBottomDockable | \\\r\n self.optionLeftDockable | self.optionRightDockable | \\\r\n self.optionNotebookDockable | \\\r\n self.optionFloatable | self.optionMovable | self.optionResizable | \\\r\n self.optionCaption | self.optionPaneBorder | self.buttonClose\r\n\r\n self.state = state\r\n \r\n return self","def widget(self, p_int): # real signature unknown; restored from __doc__\n return QWidget","def AcceptsFocus(self):\r\n\r\n # overridden base class method, allows this ctrl to\r\n # participate in the tab-order, etc. It's overridable because\r\n # of deriving this class from wx.PyScrolledWindow...\r\n return True","def setFocus(*args, **kwargs)->None:\n pass","def focus_prev(self):\n self.focus_item(forward=False)","def get_active_window(self): # real signature unknown; restored from __doc__\n pass"],"string":"[\n \"def get_focus_widget(self):\\r\\n return self.shell\",\n \"def XPGetWidgetWithFocus():\\n pass\",\n \"def get_focus(self):\\n\\n self.activateWindow()\\n self.setFocus()\",\n \"def get_focus_widget(self):\\n # TODO - focus on channel list\\n# self.combo.lineEdit().selectAll()\\n# return self.combo\\n return None\",\n \"def dock_widget(self):\\n d = self.declaration.dock_widget()\\n if d is not None:\\n return d.proxy.widget\",\n \"def get_focus_widget(self):\\r\\n return self.get_current_editor()\",\n \"def XPSetKeyboardFocus(inWidget):\\n pass\",\n \"def focus_master(qtile):\\n grp = qtile.current_group\\n if grp.layout.clients.current_index > 0:\\n c = grp.layout.clients.focus_first()\\n grp.focus(c, True)\\n elif grp.layout.clients.current_index == 0 and len(grp.layout.clients.clients) > 0:\\n grp.layout.cmd_down()\",\n \"def XPBringRootWidgetToFront(inWidget):\\n pass\",\n \"def __window_focus(self):\\n pass\",\n \"def Top(self):\\r\\n\\r\\n self.dock_direction = AUI_DOCK_TOP\\r\\n return self\",\n \"def Top(self):\\r\\n\\r\\n self.dock_direction = AUI_DOCK_TOP\\r\\n return self\",\n \"def siguiente(self, widget):\\n window = widget.get_toplevel()\\n window.do_move_focus(window, gtk.DIR_TAB_FORWARD)\",\n \"def get_focus(self, c: Cmdr=None, raw: bool=False, at_idle: bool=False) -> Widget:\\n trace = 'focus' in g.app.debug\\n trace_idle = False\\n trace = trace and (trace_idle or not at_idle)\\n app = QtWidgets.QApplication\\n w = app.focusWidget()\\n if w and not raw and isinstance(w, qt_text.LeoQTextBrowser):\\n has_w = getattr(w, 'leo_wrapper', None)\\n if has_w:\\n if trace:\\n g.trace(w)\\n elif c:\\n # Kludge: DynamicWindow creates the body pane\\n # with wrapper = None, so return the LeoQtBody.\\n w = c.frame.body\\n if trace:\\n name = w.objectName() if hasattr(w, 'objectName') else w.__class__.__name__\\n g.trace('(LeoQtGui)', name)\\n return w\",\n \"def widget(self) -> tk.Frame:\\r\\n return self.main_frame\",\n \"def toolkit_widget(self):\\n return self.widget\",\n \"def focus_window(i3, container_id):\\n i3.command(f'[con_id=\\\"{container_id}\\\"] floating enable')\\n i3.command(f'[con_id=\\\"{container_id}\\\"] focus')\",\n \"def widget(self):\\n return self.containedWidget\",\n \"def set_focus(self, c: Cmdr, w: Wrapper) -> None:\\n if not w:\\n return\\n if getattr(w, 'widget', None):\\n if not isinstance(w, QtWidgets.QWidget):\\n # w should be a wrapper.\\n w = w.widget\\n if 'focus' in g.app.debug:\\n name = w.objectName() if hasattr(w, 'objectName') else w.__class__.__name__\\n g.trace('(LeoQtGui)', name)\\n w.setFocus()\",\n \"def get_current_focus():\\n\\n grab = Gtk.grab_get_current()\\n if grab:\\n return grab\\n\\n for win in Gtk.Window.list_toplevels():\\n if win.get_property('has-toplevel-focus'):\\n return win.get_focus()\\n return None\",\n \"def OnChildFocus(self, event):\\r\\n\\r\\n # when a child pane has it's focus set, we should change the \\r\\n # pane's active state to reflect this. (this is only true if \\r\\n # active panes are allowed by the owner)\\r\\n\\r\\n window = event.GetWindow()\\r\\n if isinstance(window, wx.Dialog):\\r\\n # Ignore EVT_CHILD_FOCUS events originating from dialogs not\\r\\n # managed by AUI\\r\\n rootManager = None\\r\\n elif isinstance(window.GetParent(), AuiFloatingFrame):\\r\\n rootManager = GetManager(window)\\r\\n else:\\r\\n rootManager = self\\r\\n \\r\\n if rootManager:\\r\\n rootManager.ActivatePane(window)\\r\\n \\r\\n event.Skip()\",\n \"def XPGetParentWidget(inWidget):\\n pass\",\n \"def maybe_focus_parent(self):\\n parent_window_data = self.get_windows_with_parent_data()\\n focused_node = filter(lambda w: w['window']['focused'], parent_window_data)\\n if len(focused_node) <= 0:\\n return\\n focused_node = focused_node[0]\\n\\n focused_parent = focused_node['parent']\\n focused_window = focused_node['window']\\n if focused_parent['layout'] == 'tabbed':\\n call('i3-msg focus parent')\",\n \"def _get_toolkit_widget(self):\\n try:\\n res = self.parent.toolkit_widget\\n except AttributeError:\\n res = None\\n return res\",\n \"def focus(self, focus_library=True):\\n if focus_library:\\n self.treeview.grab_focus()\\n if not self.grid.is_visible():\\n self.toggle()\\n else:\\n self.vimiv.image.vimiv.image.scrolled_win.grab_focus()\\n # Update info for the current mode\\n self.vimiv.statusbar.update_info()\",\n \"def set_top_widget(self, widg):\\r\\n if widg in self.widgets:\\r\\n self.widgets.remove(widg)\\r\\n self.widgets.insert(0, widg)\\r\\n for i in self.widgets:\\r\\n if i.get_visible():\\r\\n if not i == widg:\\r\\n i.unfocus()\",\n \"def focus(self):\\n raise NotImplementedError\",\n \"def SetFocus(self):\\r\\n \\r\\n self._main_win.SetFocus()\",\n \"def edit_widget_focus(self):\\n if self.goto:\\n self.goto_node()\\n self.update_position(self.get_position())\",\n \"def get_parent_window(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def XPLoseKeyboardFocus(inWidget):\\n pass\",\n \"def get_master_widget(self, top: Widget=None) -> Widget:\\n if top is None:\\n top = self.c.frame.top\\n master = top.leo_master or top\\n return master\",\n \"def getFocusedWindow(self):\\n for window in self.getWindows().values():\\n if window.focused:\\n return window\\n return None\",\n \"def ev_windowfocusgained(self, event: WindowEvent) -> None:\",\n \"def get_widget(self):\\n\\t\\treturn None\",\n \"def focus(self):\\n self.image_window.focus_set()\",\n \"def OnSetFocus(self, event):\\r\\n\\r\\n treectrl = self._wnd.GetParent()\\r\\n select = treectrl.GetSelection()\\r\\n\\r\\n # If the window is associated to an item that currently is selected\\r\\n # (has focus) we don't kill the focus. Otherwise we do it.\\r\\n if select != self:\\r\\n treectrl._hasFocus = False\\r\\n else:\\r\\n treectrl._hasFocus = True\\r\\n \\r\\n event.Skip()\",\n \"def get_widget(self):\\r\\n return None\",\n \"def takeWidget(self):\\n widget = self.containedWidget\\n if self.containedWidget:\\n self.layout().removeWidget(self.containedWidget)\\n self.containedWidget.setParent(None)\\n self.containedWidget = None\\n self.toolBar = None\\n return widget\",\n \"def Center(self):\\r\\n \\r\\n self.dock_direction = AUI_DOCK_CENTER\\r\\n return self\",\n \"def ev_windowfocusgained(self, event: tcod.event.WindowEvent) -> T | None:\",\n \"def Center(self):\\r\\n\\r\\n self.dock_direction = AUI_DOCK_CENTER\\r\\n return self\",\n \"def currently_focused(self) -> int:\",\n \"def OnSetFocus(self, event):\\r\\n\\r\\n self._owner.SetFocus()\",\n \"def OnSetFocus(self, event):\\r\\n\\r\\n treectrl = self._owner\\r\\n select = treectrl.GetSelection()\\r\\n\\r\\n # If the window is associated to an item that currently is selected\\r\\n # (has focus) we don't kill the focus. Otherwise we do it.\\r\\n if select != self:\\r\\n treectrl._hasFocus = False\\r\\n else:\\r\\n treectrl._hasFocus = True\\r\\n \\r\\n event.Skip()\",\n \"def init_widget(self):\\n super(WxDockPane, self).init_widget()\\n d = self.declaration\\n self.set_title(d.title)\\n self.set_title_bar_visible(d.title_bar_visible)\\n self.set_title_bar_orientation(d.title_bar_orientation)\\n self.set_closable(d.closable)\\n self.set_movable(d.movable)\\n self.set_floatable(d.floatable)\\n self.set_floating(d.floating)\\n self.set_dock_area(d.dock_area)\\n self.set_allowed_dock_areas(d.allowed_dock_areas)\\n widget = self.widget\\n widget.Bind(EVT_DOCK_PANE_FLOATED, self.on_floated)\\n widget.Bind(EVT_DOCK_PANE_DOCKED, self.on_docked)\\n widget.Bind(EVT_DOCK_PANE_CLOSED, self.on_closed)\",\n \"def focus_on_main_content(self):\\n self.browser.execute_script(\\\"$('#main-content').focus()\\\")\",\n \"def Dock(self):\\r\\n\\r\\n if self.IsNotebookPage():\\r\\n self.notebook_id = -1\\r\\n self.dock_direction = AUI_DOCK_NONE\\r\\n \\r\\n return self.SetFlag(self.optionFloating, False)\",\n \"def FindFocusDescendant(ancestor):\\r\\n\\r\\n # Process events starting with the window with the focus, if any.\\r\\n focusWin = wx.Window.FindFocus()\\r\\n win = focusWin\\r\\n\\r\\n # Check if this is a descendant of this frame.\\r\\n # If not, win will be set to NULL.\\r\\n while win:\\r\\n if win == ancestor:\\r\\n break\\r\\n else:\\r\\n win = win.GetParent()\\r\\n\\r\\n if win is None:\\r\\n focusWin = None\\r\\n\\r\\n return focusWin\",\n \"def GetMainWindow(self):\\r\\n \\r\\n return self._main_win\",\n \"def TopDockable(self, b=True):\\r\\n \\r\\n return self.SetFlag(self.optionTopDockable, b)\",\n \"def XPGetWidgetUnderlyingWindow(inWidget):\\n pass\",\n \"def getFocus(*args):\",\n \"def getFocus(*args):\",\n \"def getFocus(*args):\",\n \"def getFocus(*args):\",\n \"def __window_getSelection(self):\\n return None\",\n \"def getCurrentNodeEditorWidget(self):\\n activeSubWindow = self.mdiArea.activeSubWindow()\\n if activeSubWindow:\\n return activeSubWindow.widget()\\n return None\",\n \"def getCurrentNodeEditorWidget(self):\\n activeSubWindow = self.mdiArea.activeSubWindow()\\n if activeSubWindow:\\n return activeSubWindow.widget()\\n return None\",\n \"def focus_on(window):\\n return Cmd(\\\"{}wincmd w\\\", window)\",\n \"def __quickSearchFocusIn(self):\\n self.quickFindtextCombo.lastActive = self.activeWindow()\",\n \"def window(self):\\n\\tif getattr(self.android.settings, 'LV_AVOID_FOCUSED_COMMAND',\\n\\t\\t\\t\\tself.android.internal.device.google_experience):\\n\\t\\treturn window.previous(self)\\n\\n def fallback_window_command():\\n try:\\n w=self.android.internal.transport.view_server_query( 'FOCUSED\\\\n' )[0]\\n except:\\n w=\\\"\\\"\\n return w\\n\\n try:\\n # can't use GET_FOCUS command in secure builds, so fall back to FOCUSED command\\n if self.android.device.is_secure_build():\\n raise Exception()\\n\\t w=self.android.internal.transport.view_server_query('GET_FOCUS\\\\n')[0].split()[1]\\n except:\\n w = fallback_window_command()\\n\\n\\tself.android.log.verbose(android.ui.TAG, \\\"Current window: '%s'\\\" % w)\\n\\treturn w\",\n \"def Bottom(self):\\r\\n\\r\\n self.dock_direction = AUI_DOCK_BOTTOM\\r\\n return self\",\n \"def Bottom(self):\\r\\n\\r\\n self.dock_direction = AUI_DOCK_BOTTOM\\r\\n return self\",\n \"def focus_event(self, widget, event, hasFocus):\\n return self.make_callback('focus', hasFocus)\",\n \"def GetDock(self):\\n return self.dock\",\n \"def XPFindRootWidget(inWidget):\\n pass\",\n \"def main_window():\\n # case: Maya\\n if pkgutil.find_loader(\\\"maya\\\"):\\n for obj in QtWidgets.QApplication.topLevelWidgets():\\n if obj.objectName() == \\\"MayaWindow\\\":\\n return obj\\n\\n # case: Houdini\\n if pkgutil.find_loader(\\\"hou\\\"):\\n module = importlib.import_module(\\\"hou\\\")\\n return getattr(module.qt, \\\"mainWindow\\\")()\\n\\n # case: Nuke\\n if pkgutil.find_loader(\\\"nuke\\\"):\\n for obj in QtWidgets.QApplication.topLevelWidgets():\\n cls_name = obj.metaObject().className()\\n inherits = obj.inherits(\\\"QMainWindow\\\")\\n if inherits and cls_name == \\\"Foundry::UI::DockMainWindow\\\":\\n return obj\\n\\n return None\",\n \"def win_raise(self):\\n self.raise_()\\n self.activateWindow()\",\n \"def main_window(self) -> MainWindow:\\n return self._main_window\",\n \"def getRoot(self):\\r\\n if self.isFrame: return self.frame\\r\\n else: return self.master\",\n \"def get_focus(self):\\n return self._get_at(self._current)\",\n \"def event(event):\\n # Special case gets priority over modal widgets (e.g. scroll handles)\\n for w in special_case:\\n if event.type == MOUSEBUTTONDOWN:\\n if w.rect.collidepoint(event.pos):\\n focus.add(2, w)\\n break\\n else:\\n focus.empty()\\n else:\\n if modal_widgets and not focus:\\n modal_widgets.sprites()[-1].add(0)\\n\\n # Mouse focus\\n if event.type == MOUSEBUTTONDOWN:\\n if not modal_widgets:\\n hit = False\\n for widget_list in (reversed(layer_widgets.sprites()),\\n active_widgets):\\n for widget in widget_list:\\n # Check if user clicked a widget\\n if widget._can_focus and \\\\\\n widget.rect.collidepoint(event.pos):\\n if event.button == 1:\\n focus.add(2, widget)\\n if widget in layer_widgets:\\n layer_widgets.move_to_front(widget)\\n elif 4 <= event.button <= 7:\\n widget._event(event)\\n hit = True\\n break\\n if hit: break\\n # Lose focus if clicking away from widgets\\n if not hit:\\n focus.empty()\\n # Keyboard focus\\n elif event.type == KEYDOWN and event.key == K_TAB:\\n if not modal_widgets and focus_order:\\n # Flattened focus_order\\n order = sum(focus_order,())\\n if focus.sprite not in order:\\n curr_num = None\\n else:\\n # Focus number for current focused widget\\n curr_num = order[order.index(focus.sprite)-1]\\n # Sorted list of the focus numbers being used\\n list_num = sorted(order[::2])\\n if not event.mod & KMOD_SHIFT: # Move focus to next widget\\n if curr_num is None:\\n # If nothing focused, focus first widget\\n new_num = list_num[0]\\n elif not focus.sprite._change_focus(True):\\n # Don't change when not at end of container widget\\n new_num = curr_num\\n elif list_num.index(curr_num) == len(list_num)-1:\\n # Jump back to first widget\\n new_num = list_num[0]\\n else:\\n # Next focus number in the list\\n new_num = list_num[list_num.index(curr_num)+1]\\n else: # Shift key - move focus to previous widget\\n if curr_num is None:\\n new_num = list_num[-1]\\n elif not focus.sprite._change_focus(False):\\n new_num = curr_num\\n elif list_num.index(curr_num) == 0:\\n # Jump back to last widget\\n new_num = list_num[len(list_num)-1]\\n else:\\n new_num = list_num[list_num.index(curr_num)-1]\\n if curr_num != new_num:\\n # Set widget at new focus number\\n focus.add(1, order[order.index(new_num)+1])\\n\\n # Send event to focused widget\\n if focus:\\n focus.sprite._event(event)\",\n \"def _focus(self, event) -> None:\\n self.focus = True\",\n \"def create_widget(self):\\n self.widget = wxDockPane(self.parent_widget())\",\n \"def get_widget(self):\\n return self.imgwin\",\n \"def setFocus(*args):\",\n \"def setFocus(*args):\",\n \"def setFocus(*args):\",\n \"def setFocus(*args):\",\n \"def getPlotFocus():\\n return simuConfig[\\\"PLOT.FOCUS\\\"]\",\n \"def __switchFocus(self):\\n if self.__focus == 0:\\n self.__isoWindow.unfocus()\\n self.__logWindow.focus()\\n self.__focus = 1\\n self.__focusedWindow = self.__logWindow\\n else:\\n self.__isoWindow.focus()\\n self.__logWindow.unfocus()\\n self.__focus = 0\\n self.__focusedWindow = self.__isoWindow\",\n \"def HandleFocusIn(self, event: tkEvent):\\n pass\",\n \"def OnChildFocusNotebook(self, event):\\r\\n \\r\\n # if we're dragging a tab, don't change the current selection.\\r\\n # This code prevents a bug that used to happen when the hint window\\r\\n # was hidden. In the bug, the focus would return to the notebook\\r\\n # child, which would then enter this handler and call\\r\\n # SetSelection, which is not desired turn tab dragging.\\r\\n\\r\\n event.Skip()\\r\\n \\r\\n all_panes = self._mgr.GetAllPanes()\\r\\n for pane in all_panes:\\r\\n if pane.name == \\\"dummy\\\":\\r\\n continue\\r\\n tabframe = pane.window\\r\\n if tabframe._tabs.IsDragging():\\r\\n return\",\n \"def getWidget(self):\",\n \"def widget(self) -> ttk.Treeview:\\r\\n return self.wrapper\",\n \"def get_toplevel(self):\\n raise NotImplementedError\",\n \"def get_main_window():\\n\\n pass\",\n \"def findFormWindow(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads\\n return QDesignerFormWindowInterface\",\n \"def __init__(self, **kwargs):\\n parent = ArgsUtils.extract('parent', None, kwargs)\\n self._application = ArgsUtils.extract('pyGlassApp', None, kwargs)\\n self._qApplication = ArgsUtils.extract('qApp', None, kwargs)\\n self._isMainWindow = ArgsUtils.extract('isMainWindow', bool(parent is None), kwargs)\\n self._mainWindow = ArgsUtils.extract('mainWindow', None, kwargs)\\n self._centerWidget = None\\n\\n self._keyboardCallback = ArgsUtils.extract('keyboardCallback', None, kwargs)\\n\\n if not self._mainWindow:\\n if self._isMainWindow:\\n self._mainWindow = self\\n elif self._application:\\n self._mainWindow = self._application.mainWindow\\n\\n self._dependentWindows = []\\n self._currentWidget = None\\n\\n QtGui.QMainWindow.__init__(self, parent, ArgsUtils.extract('flags', 0, kwargs))\\n\\n if self._keyboardCallback is not None:\\n self.setFocusPolicy(QtCore.Qt.StrongFocus)\\n\\n if self._isMainWindow:\\n self._log = Logger(self, printOut=True)\\n self._config = ApplicationConfig(self)\\n self._commonConfig = ApplicationConfig(self, common=True)\\n self._resourceFolderParts = PyGlassGuiUtils.getResourceFolderParts(self)\\n\\n icon = PyGlassGuiUtils.createIcon(\\n ArgsUtils.get('iconsPath', self.getAppResourcePath('icons', isDir=True), kwargs) )\\n if icon:\\n self.setWindowIcon(icon)\\n\\n elif self._mainWindow:\\n icon = self._mainWindow.windowIcon()\\n if icon:\\n self.setWindowIcon(icon)\\n\\n # Loads the ui file if it exists\\n hasWindowFile = ArgsUtils.get('mainWindowFile', False, kwargs)\\n if hasWindowFile:\\n if not self._centerWidget:\\n self._createCentralWidget()\\n UiFileLoader.loadWidgetFile(self, target=self._centerWidget)\\n\\n self._styleSheet = ArgsUtils.get('styleSheet', None, kwargs)\\n if self._styleSheet:\\n self.setStyleSheet(self.styleSheetPath)\\n\\n # Sets a non-standard central widget\\n centralWidgetName = ArgsUtils.get('centralWidgetName', None, kwargs)\\n if centralWidgetName and hasattr(self, centralWidgetName):\\n self._centerWidget = getattr(self, centralWidgetName)\\n elif not hasWindowFile:\\n self._centerWidget = None\\n if ArgsUtils.get('defaultCenterWidget', False, kwargs):\\n self._createCentralWidget()\\n\\n self._lastWidgetID = None\\n self._widgetParent = None\\n self._widgets = None\\n self._widgetFlags = None\\n\\n self._widgetClasses = ArgsUtils.get('widgets', None, kwargs)\\n if self._widgetClasses:\\n self._initializeWidgetChildren()\\n else:\\n self._widgetClasses = dict()\\n\\n self.setWindowTitle(ArgsUtils.get('title', self._createTitleFromClass(), kwargs))\\n self.updateStatusBar()\",\n \"def focusInEvent(self, evt):\\n self.gotFocus.emit()\\n super(QuickSearchLineEdit, self).focusInEvent(evt) # pass it on\",\n \"def click_user_widget_button(self):\\n return self\",\n \"def _current_window_for_event(event):\\n return event.app.layout.current_window\",\n \"def onInvoke():\\n if dock.isVisible():\\n dock.toggleViewAction().trigger()\\n else:\\n dock.setFloating(True)\\n pos = QtGui.QCursor.pos()\\n dock.move(pos.x() - dock.size().width() / 2,\\n pos.y() - dock.size().height() / 2)\\n dock.setVisible(True)\",\n \"def DefaultPane(self):\\r\\n \\r\\n state = self.state \\r\\n state |= self.optionTopDockable | self.optionBottomDockable | \\\\\\r\\n self.optionLeftDockable | self.optionRightDockable | \\\\\\r\\n self.optionNotebookDockable | \\\\\\r\\n self.optionFloatable | self.optionMovable | self.optionResizable | \\\\\\r\\n self.optionCaption | self.optionPaneBorder | self.buttonClose\\r\\n\\r\\n self.state = state\\r\\n \\r\\n return self\",\n \"def widget(self, p_int): # real signature unknown; restored from __doc__\\n return QWidget\",\n \"def AcceptsFocus(self):\\r\\n\\r\\n # overridden base class method, allows this ctrl to\\r\\n # participate in the tab-order, etc. It's overridable because\\r\\n # of deriving this class from wx.PyScrolledWindow...\\r\\n return True\",\n \"def setFocus(*args, **kwargs)->None:\\n pass\",\n \"def focus_prev(self):\\n self.focus_item(forward=False)\",\n \"def get_active_window(self): # real signature unknown; restored from __doc__\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7704666","0.7102243","0.69277894","0.68596774","0.6834897","0.67454267","0.6497104","0.64854103","0.64425933","0.6428573","0.6415316","0.6415316","0.63931817","0.63340354","0.6328461","0.6324133","0.630882","0.6146666","0.61402094","0.6127258","0.6069467","0.6040384","0.6022973","0.6020987","0.59657973","0.5950334","0.59466755","0.59256","0.5920057","0.591002","0.5845887","0.58453715","0.5804434","0.5788102","0.5770068","0.5724479","0.5721828","0.5694562","0.5689464","0.5675505","0.5653516","0.56502664","0.5634091","0.56310123","0.5587495","0.5566541","0.5543956","0.5538842","0.55210525","0.5519185","0.55056095","0.5494281","0.5494095","0.5494095","0.5494095","0.5494095","0.5477781","0.54752684","0.54752684","0.54695535","0.5462904","0.5459865","0.54560965","0.54560965","0.54482627","0.5446696","0.54322","0.5427409","0.53981197","0.5385493","0.53533167","0.53455013","0.5340798","0.5333695","0.5329481","0.53286546","0.5320084","0.5320084","0.5320084","0.5320084","0.53051156","0.52980536","0.5288027","0.52765954","0.5263995","0.5263848","0.5243404","0.5236716","0.52255106","0.521777","0.52169424","0.5216824","0.52025557","0.52002496","0.5188273","0.5186015","0.5180603","0.5170073","0.51617444","0.5159074"],"string":"[\n \"0.7704666\",\n \"0.7102243\",\n \"0.69277894\",\n \"0.68596774\",\n \"0.6834897\",\n \"0.67454267\",\n \"0.6497104\",\n \"0.64854103\",\n \"0.64425933\",\n \"0.6428573\",\n \"0.6415316\",\n \"0.6415316\",\n \"0.63931817\",\n \"0.63340354\",\n \"0.6328461\",\n \"0.6324133\",\n \"0.630882\",\n \"0.6146666\",\n \"0.61402094\",\n \"0.6127258\",\n \"0.6069467\",\n \"0.6040384\",\n \"0.6022973\",\n \"0.6020987\",\n \"0.59657973\",\n \"0.5950334\",\n \"0.59466755\",\n \"0.59256\",\n \"0.5920057\",\n \"0.591002\",\n \"0.5845887\",\n \"0.58453715\",\n \"0.5804434\",\n \"0.5788102\",\n \"0.5770068\",\n \"0.5724479\",\n \"0.5721828\",\n \"0.5694562\",\n \"0.5689464\",\n \"0.5675505\",\n \"0.5653516\",\n \"0.56502664\",\n \"0.5634091\",\n \"0.56310123\",\n \"0.5587495\",\n \"0.5566541\",\n \"0.5543956\",\n \"0.5538842\",\n \"0.55210525\",\n \"0.5519185\",\n \"0.55056095\",\n \"0.5494281\",\n \"0.5494095\",\n \"0.5494095\",\n \"0.5494095\",\n \"0.5494095\",\n \"0.5477781\",\n \"0.54752684\",\n \"0.54752684\",\n \"0.54695535\",\n \"0.5462904\",\n \"0.5459865\",\n \"0.54560965\",\n \"0.54560965\",\n \"0.54482627\",\n \"0.5446696\",\n \"0.54322\",\n \"0.5427409\",\n \"0.53981197\",\n \"0.5385493\",\n \"0.53533167\",\n \"0.53455013\",\n \"0.5340798\",\n \"0.5333695\",\n \"0.5329481\",\n \"0.53286546\",\n \"0.5320084\",\n \"0.5320084\",\n \"0.5320084\",\n \"0.5320084\",\n \"0.53051156\",\n \"0.52980536\",\n \"0.5288027\",\n \"0.52765954\",\n \"0.5263995\",\n \"0.5263848\",\n \"0.5243404\",\n \"0.5236716\",\n \"0.52255106\",\n \"0.521777\",\n \"0.52169424\",\n \"0.5216824\",\n \"0.52025557\",\n \"0.52002496\",\n \"0.5188273\",\n \"0.5186015\",\n \"0.5180603\",\n \"0.5170073\",\n \"0.51617444\",\n \"0.5159074\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67533296"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":21978,"cells":{"query":{"kind":"string","value":"Return a list of actions related to plugin"},"document":{"kind":"string","value":"def get_plugin_actions(self):\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 getActions():\n return getPlugins(IRenamingAction, plugins)","def get_actions(self):\n return []","def get_list_of_actions(self):\n return self.actions","def actions(self):\n return self._action_list","def actions(self):\n from moztrap.view.lists.actions import actions\n return actions","def _get_actions(self):\n return self.__actions","def _get_actions(self):\n return self.__actions","def _get_actions(self):\n return self.__actions","def actions(self):\r\n return self.puzzle.actions","def get_actions(self):\n return self.agent.get_actions()","def get_available_actions(self):\n return self.actions","def GetCustomActions(debug, verbose, explicit_configurations):\r\n\r\n return []","def actions(self):\n return self._actions","def actions(self):\r\n return actions.Actions(self)","def getActions(self):\n actions = self.actions[:]\n return actions","def get_custom_actions(self, containers):\n\n def sorter(Plugin):\n \"\"\"Sort based on order attribute of the plugin\"\"\"\n return Plugin.order\n\n # Fedd an empty dict if no selection, this will ensure the compat\n # lookup always work, so plugin can interact with Scene Inventory\n # reversely.\n containers = containers or [dict()]\n\n # Check which action will be available in the menu\n Plugins = api.discover(api.InventoryAction)\n compatible = [p() for p in Plugins if\n any(p.is_compatible(c) for c in containers)]\n\n return sorted(compatible, key=sorter)","def actions(self):\n self._actions = {}\n self._actions['getItems'] = ('FileCrawler', None)\n #self._actions['getContents'] = ('ParseContents', ('path'))\n return self._actions","def list(self):\n\n return list(\n filter(\n lambda x: x.get('type') != 'tagit', # pragma: no cover\n self._post(\n request=ApiActions.LIST.value,\n uri=ApiUri.ACTIONS.value,\n ).get('actions')\n )\n )","def actions(self):\n\n return self._actions.getSlice(0)","def actions(self):\n\n return self._actions.getSlice(0)","def _generate_actions(self) -> list:\n pass","def get_actions(self):\n actions = []\n for section in self._sections:\n for (sec, action) in self._actions:\n if sec == section:\n actions.append(action)\n\n actions.append(MENU_SEPARATOR)\n return actions","def get_plugins_by_action(self, action, **kwargs):\n\n plugins = list()\n for plugin_name, plugin in self.plugins.iteritems():\n if action.pid and not plugin.id == action.pid:\n continue\n if plugin.has_action(action.request_name):\n plugins.append(plugin_name)\n return plugins","def actions(self):\n isinst = isinstance\n return [c.widget for c in self.children() if isinst(c, QtAction)]","def get_actions(self):\n\n if self.description == exceptions.NotAvailableError:\n raise exceptions.NotAvailableError('Can\\'t get actions because a description for this service is'\n ' not available.')\n return list(self.actions.values())","def actions(self):\n raise NotImplementedError","def actions(self):\n actions = []\n\n for name, item in self._definition.get('actions', {}).items():\n name = self._get_name('action', name)\n actions.append(Action(name, item, self._resource_defs))\n\n return actions","def list(self):\n return list(\n filter(\n lambda x: x.get('type') == 'tagit', # pragma: no cover\n self._post(\n request=ApiActions.LIST.value,\n uri=ApiUri.ACTIONS.value,\n ).get('actions')\n )\n )","def actions(cls):\n return [m for m in cls.__dict__ if not \"__\" in m]","def actions(self):\r\n return Actions(self)","def list_commands(self, ctx):\n return self.daemon.list_actions()","def get_available_actions(self, state):\n pass","def actions(self) -> list:\n if self.debug: print(f\"AState.actions()\")\n if not self._examined:\n if self.debug: print(f\"\\tExamining...\")\n self._actions = self._generate_actions()\n self._examined = True\n return self._actions","def actions(self) -> List[str]:\n return list(self.__endpoints.keys())","def actions(self, agent_state):\n raise NotImplementedError(\"Don't know what actions are available\")","def actions(self) -> List['outputs.PreventionJobTriggerInspectJobAction']:\n return pulumi.get(self, \"actions\")","def get_actions(self, request):\n return super(OrganizationAdmin, self).get_actions(request)","def actions():\n pass","def getAllHumanActions(self):\n return self.human_policy.actions","def actions(self, request, action_list, group):\n return action_list","def actions(self):\n r = self.session.query(models.Action).all()\n return [x.type_name for x in r]","def actions(self) -> Sequence[_A_out]:\n return self._actions","def actions(self):\n nodes = self._root.find(\"publishers\")\n\n retval = []\n for node in nodes:\n plugin = create_xml_plugin(node)\n if plugin is not None:\n retval.append(plugin)\n else:\n log.warning(\"Flexible publisher plugin {0} not found\".format(\n get_plugin_name(node)))\n\n return retval","def get_action_choices():\n from hardware.management.commands.gpio_buttons import Command\n import re\n pattern = re.compile(r'^on_(?P<name>\\w+)_press$')\n choices = []\n for member in dir(Command):\n match = pattern.match(member)\n if match:\n action = match.groupdict()['name']\n name = action.replace('_', ' ').title()\n choices.append((action, name))\n return choices","def get_all_actions(self, custom_move_ordering = False) :\n raise NotImplementedError","def get_actions(self, state: TState = None) -> Sequence[TAction]:\n pass","def list_actions() -> None:\n colorama_init()\n max_action_name_len = max(len(name) for name in KNOWN_ACTIONS.keys())\n wrapper = textwrap.TextWrapper(\n width=80 - max_action_name_len - 3,\n subsequent_indent=' ' * (max_action_name_len + 3),\n )\n print(\n '{bright}{name:<{max_action_name_len}} -{normal} {doc}'.format(\n bright=Style.BRIGHT,\n name='name',\n max_action_name_len=max_action_name_len,\n normal=Style.NORMAL,\n doc='description [(argument: type, ...)]',\n )\n )\n print('-' * 80)\n for name, action in KNOWN_ACTIONS.items():\n wrapped_doc = wrapper.fill(' '.join(str(action.__doc__).split()))\n print(\n '{bright}{name:<{max_action_name_len}} -{normal} {doc}'.format(\n bright=Style.BRIGHT,\n name=name,\n max_action_name_len=max_action_name_len,\n normal=Style.NORMAL,\n doc=wrapped_doc,\n )\n )\n return None","def plugin_list(self):\r\n return get_module_list()","def get_all_action_types() -> List[str]:\n\n actions: List[str] = []\n for name, val in actions_module_dict.items(): # iterate through every module's attributes\n if inspect.isclass(val) and issubclass(val, Action) and val != Action:\n actions.append(name)\n\n return actions","def list_plugins(request):\n plugins = plugin.get_plugins()\n return plugins","def getActions(self, state): \n util.raiseNotDefined()","def action_templates(self) -> List[ActionTemplate]:\n return self._action_templates","def all_actions(self):\n actions = self.actions.stream[:]\n for eq in self.equipment:\n actions.extend(eq.actions)\n return actions","def actions(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:\n return pulumi.get(self, \"actions\")","def actions(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:\n return pulumi.get(self, \"actions\")","def getAllRobotActions(self):\n return self.robot.actions","def get_available_actions() -> tuple:\n return tuple(method for method in dir(cli_commands) if callable(getattr(cli_commands, method)))","def do_list_commands(plugin):\n if not plugin.supported_commands:\n click.secho(\n f\"Plugin '{plugin.name}' does not define any commands.\", fg=\"yellow\"\n )\n return\n\n descriptions = {\n f\"{plugin.name}:{cmd}\": props.description\n for cmd, props in plugin.all_commands.items()\n }\n column_len = max(len(name) for name in descriptions.keys()) + 2\n for name, desc in descriptions.items():\n click.secho(name.ljust(column_len, \" \"), fg=\"blue\", nl=False)\n click.echo(desc)","def actions(self, phrase: str) -> list:\n return self._current_scope.get(phrase, [])","def get_custom_actions(self, form_wizard_entry, request=None):\n return self.custom_actions(form_wizard_entry, request)","def _help_actions(self):\n actions_str = \"\"\n for (key, value) in self.actions_help.items():\n actions_str += \"command: %s\\n%s\\n\\n\" % (key, value)\n print(actions_str)\n sys.exit(0)","def actions() -> None:\n pass","def request_plugins(self):","def get_content(self):\r\n for action in self._actions:\r\n action.execute()","def actions(self, state):\n myActionList= (1,2);\n return myActionList","def actions(self):\n return {0, 1, 2, 3, 4, 5, 11, 12}","def get_actions(self, request):\n actions = super(RateLimitedIPAdmin, self).get_actions(request)\n del actions['delete_selected']\n return actions","def right_click_plugins(self) -> misc_.plugins.PluginHandler:\n\t\treturn self._right_click_plugins","def get_custom_actions(self, form_entry, request=None):\n return self.custom_actions(form_entry, request)","def get_actions(\n self, observations: Observations, action_space: gym.Space\n ) -> Actions:\n return super().get_actions(observations, action_space)","def get_actions(self, request):\n actions = super().get_actions(request)\n actions.pop('delete_selected', None)\n\n return actions","def getCommands():\n return getPlugins(ICommand, plugins)","def get_legal_actions(self):\n pass","def _getAvailableActions(self, board):\r\n myPits = board.mySide(self.id)\r\n return [i for i in myPits if i > 0]","def _getAvailableActions(self, board):\r\n myPits = board.mySide(self.id)\r\n return [i for i in myPits if i > 0]","def list_actions(self, query_params: Dict[str, object] = None) -> List[Action]:\n if query_params is None:\n query_params = {}\n\n path_params = {\n }\n\n path = Template(\"/action/v1beta2/actions\").substitute(path_params)\n url = self.base_client.build_url(path)\n response = self.base_client.get(url, params=query_params)\n return handle_response(response, Action)","def get_actions(self):\r\n return -4,4","def server_plugin_list(ctx):\n data = ctx.obj.get_all_plugins()\n output_json_data(data)","def actions(self):\n return self._separated_constructs(RuleAction)","def all_action_names() -> List[str]:\n\n return list(map(lambda c: c.name, LoggingActions))","def all_actions(self, player):\n return [m for m in MOVES if m.norm() == 1]","def get_plugins(self):\n return []","def valid_actions(self) -> List[str]:\n return list(self.action_map().keys())","def _get_legal_actions(self):\n raise NotImplementedError","def getAllActions(self):\n decision_rules = self.getAllDecisionRules()\n return list(itertools.product(decision_rules, self.getAllRobotActions()))","def get_action_classes(app_name: str):\n from policyengine.models import PlatformAction\n actions = []\n for cls in apps.get_app_config(app_name).get_models():\n if issubclass(cls, PlatformAction) and hasattr(cls, \"action_codename\"):\n actions.append(cls)\n return actions","def get_actions(self, joueur):\n actions = []\n if joueur == \"w\":\n j2 = \"b\"\n else:\n j2 = \"w\"\n for p in self.pionsliste:\n start = time.time()\n if p.color == joueur:\n mvts = p.get_mvts(self)\n for m in mvts:\n actions.append(Action(p, m[0], m[1], self.get_copy(), j2))\n print(p.type, \"{:.4f}\".format(time.time()-start), len(mvts), len(actions))\n return actions","def get_actions(self, oid, action_id=None):\n if action_id is None:\n path = '/servers/%s/os-instance-actions' % oid\n key = 'instanceActions'\n else:\n path = '/servers/%s/os-instance-actions/%s' % (oid, action_id)\n key = 'instanceAction'\n res = self.client.call(path, 'GET', data='', \n token=self.manager.identity.token)\n self.logger.debug('get openstack server %s actions: %s' % \n (oid, truncate(res)))\n return res[0][key]","def _get_legal_actions(self):\n return self.game.get_legal_actions()","def legal_actions(self):\n raise NotImplementedError","def do_plugin_list(cc, args):\n params = {}\n\n if args.detail:\n fields = res_fields.PLUGIN_DETAILED_RESOURCE.fields\n field_labels = res_fields.PLUGIN_DETAILED_RESOURCE.labels\n elif args.fields:\n utils.check_for_invalid_fields(\n args.fields[0], res_fields.PLUGIN_DETAILED_RESOURCE.fields)\n resource = res_fields.Resource(args.fields[0])\n fields = resource.fields\n field_labels = resource.labels\n else:\n fields = res_fields.PLUGIN_RESOURCE.fields\n field_labels = res_fields.PLUGIN_RESOURCE.labels\n\n sort_fields = res_fields.PLUGIN_DETAILED_RESOURCE.sort_fields\n sort_field_labels = res_fields.PLUGIN_DETAILED_RESOURCE.sort_labels\n\n params.update(utils.common_params_for_list(args,\n sort_fields,\n sort_field_labels))\n\n if args.with_public:\n params['with_public'] = args.with_public\n\n if args.public:\n params['public'] = args.public\n\n if args.all_plugins:\n params['all_plugins'] = args.all_plugins\n\n plugins = cc.plugin.list(**params)\n cliutils.print_list(plugins, fields,\n field_labels=field_labels,\n sortby_index=None,\n json_flag=args.json)","def action_list(args):\n\n module_root = Path(\"modules/\")\n modules = load_modules(module_root)\n\n print(\"Available modules:\")\n for module in modules:\n print(f\"- {module}\")","def plugins():\n pass","def get_admin_commands(self):\n\n return []","def auto_discover():\n auto_registration(\"actions\")","def get_interactions(self):\n return self._interactions","def get_actions(self, hyper_s):\n hyper_actions = []\n for next_s in self._get_periphery(hyper_s):\n if not self._is_covered(hyper_actions, next_s):\n hyper_actions.append(Action(self._get_hyper_s(next_s)))\n\n return hyper_actions","def list():\n manager = Actions()\n tasks_list = manager.get_tasks_list()\n console_utils.print_tree(manager, tasks_list)","def solution(self):\n\t\treturn [node.action for node in self.path()[1:]]"],"string":"[\n \"def getActions():\\n return getPlugins(IRenamingAction, plugins)\",\n \"def get_actions(self):\\n return []\",\n \"def get_list_of_actions(self):\\n return self.actions\",\n \"def actions(self):\\n return self._action_list\",\n \"def actions(self):\\n from moztrap.view.lists.actions import actions\\n return actions\",\n \"def _get_actions(self):\\n return self.__actions\",\n \"def _get_actions(self):\\n return self.__actions\",\n \"def _get_actions(self):\\n return self.__actions\",\n \"def actions(self):\\r\\n return self.puzzle.actions\",\n \"def get_actions(self):\\n return self.agent.get_actions()\",\n \"def get_available_actions(self):\\n return self.actions\",\n \"def GetCustomActions(debug, verbose, explicit_configurations):\\r\\n\\r\\n return []\",\n \"def actions(self):\\n return self._actions\",\n \"def actions(self):\\r\\n return actions.Actions(self)\",\n \"def getActions(self):\\n actions = self.actions[:]\\n return actions\",\n \"def get_custom_actions(self, containers):\\n\\n def sorter(Plugin):\\n \\\"\\\"\\\"Sort based on order attribute of the plugin\\\"\\\"\\\"\\n return Plugin.order\\n\\n # Fedd an empty dict if no selection, this will ensure the compat\\n # lookup always work, so plugin can interact with Scene Inventory\\n # reversely.\\n containers = containers or [dict()]\\n\\n # Check which action will be available in the menu\\n Plugins = api.discover(api.InventoryAction)\\n compatible = [p() for p in Plugins if\\n any(p.is_compatible(c) for c in containers)]\\n\\n return sorted(compatible, key=sorter)\",\n \"def actions(self):\\n self._actions = {}\\n self._actions['getItems'] = ('FileCrawler', None)\\n #self._actions['getContents'] = ('ParseContents', ('path'))\\n return self._actions\",\n \"def list(self):\\n\\n return list(\\n filter(\\n lambda x: x.get('type') != 'tagit', # pragma: no cover\\n self._post(\\n request=ApiActions.LIST.value,\\n uri=ApiUri.ACTIONS.value,\\n ).get('actions')\\n )\\n )\",\n \"def actions(self):\\n\\n return self._actions.getSlice(0)\",\n \"def actions(self):\\n\\n return self._actions.getSlice(0)\",\n \"def _generate_actions(self) -> list:\\n pass\",\n \"def get_actions(self):\\n actions = []\\n for section in self._sections:\\n for (sec, action) in self._actions:\\n if sec == section:\\n actions.append(action)\\n\\n actions.append(MENU_SEPARATOR)\\n return actions\",\n \"def get_plugins_by_action(self, action, **kwargs):\\n\\n plugins = list()\\n for plugin_name, plugin in self.plugins.iteritems():\\n if action.pid and not plugin.id == action.pid:\\n continue\\n if plugin.has_action(action.request_name):\\n plugins.append(plugin_name)\\n return plugins\",\n \"def actions(self):\\n isinst = isinstance\\n return [c.widget for c in self.children() if isinst(c, QtAction)]\",\n \"def get_actions(self):\\n\\n if self.description == exceptions.NotAvailableError:\\n raise exceptions.NotAvailableError('Can\\\\'t get actions because a description for this service is'\\n ' not available.')\\n return list(self.actions.values())\",\n \"def actions(self):\\n raise NotImplementedError\",\n \"def actions(self):\\n actions = []\\n\\n for name, item in self._definition.get('actions', {}).items():\\n name = self._get_name('action', name)\\n actions.append(Action(name, item, self._resource_defs))\\n\\n return actions\",\n \"def list(self):\\n return list(\\n filter(\\n lambda x: x.get('type') == 'tagit', # pragma: no cover\\n self._post(\\n request=ApiActions.LIST.value,\\n uri=ApiUri.ACTIONS.value,\\n ).get('actions')\\n )\\n )\",\n \"def actions(cls):\\n return [m for m in cls.__dict__ if not \\\"__\\\" in m]\",\n \"def actions(self):\\r\\n return Actions(self)\",\n \"def list_commands(self, ctx):\\n return self.daemon.list_actions()\",\n \"def get_available_actions(self, state):\\n pass\",\n \"def actions(self) -> list:\\n if self.debug: print(f\\\"AState.actions()\\\")\\n if not self._examined:\\n if self.debug: print(f\\\"\\\\tExamining...\\\")\\n self._actions = self._generate_actions()\\n self._examined = True\\n return self._actions\",\n \"def actions(self) -> List[str]:\\n return list(self.__endpoints.keys())\",\n \"def actions(self, agent_state):\\n raise NotImplementedError(\\\"Don't know what actions are available\\\")\",\n \"def actions(self) -> List['outputs.PreventionJobTriggerInspectJobAction']:\\n return pulumi.get(self, \\\"actions\\\")\",\n \"def get_actions(self, request):\\n return super(OrganizationAdmin, self).get_actions(request)\",\n \"def actions():\\n pass\",\n \"def getAllHumanActions(self):\\n return self.human_policy.actions\",\n \"def actions(self, request, action_list, group):\\n return action_list\",\n \"def actions(self):\\n r = self.session.query(models.Action).all()\\n return [x.type_name for x in r]\",\n \"def actions(self) -> Sequence[_A_out]:\\n return self._actions\",\n \"def actions(self):\\n nodes = self._root.find(\\\"publishers\\\")\\n\\n retval = []\\n for node in nodes:\\n plugin = create_xml_plugin(node)\\n if plugin is not None:\\n retval.append(plugin)\\n else:\\n log.warning(\\\"Flexible publisher plugin {0} not found\\\".format(\\n get_plugin_name(node)))\\n\\n return retval\",\n \"def get_action_choices():\\n from hardware.management.commands.gpio_buttons import Command\\n import re\\n pattern = re.compile(r'^on_(?P<name>\\\\w+)_press$')\\n choices = []\\n for member in dir(Command):\\n match = pattern.match(member)\\n if match:\\n action = match.groupdict()['name']\\n name = action.replace('_', ' ').title()\\n choices.append((action, name))\\n return choices\",\n \"def get_all_actions(self, custom_move_ordering = False) :\\n raise NotImplementedError\",\n \"def get_actions(self, state: TState = None) -> Sequence[TAction]:\\n pass\",\n \"def list_actions() -> None:\\n colorama_init()\\n max_action_name_len = max(len(name) for name in KNOWN_ACTIONS.keys())\\n wrapper = textwrap.TextWrapper(\\n width=80 - max_action_name_len - 3,\\n subsequent_indent=' ' * (max_action_name_len + 3),\\n )\\n print(\\n '{bright}{name:<{max_action_name_len}} -{normal} {doc}'.format(\\n bright=Style.BRIGHT,\\n name='name',\\n max_action_name_len=max_action_name_len,\\n normal=Style.NORMAL,\\n doc='description [(argument: type, ...)]',\\n )\\n )\\n print('-' * 80)\\n for name, action in KNOWN_ACTIONS.items():\\n wrapped_doc = wrapper.fill(' '.join(str(action.__doc__).split()))\\n print(\\n '{bright}{name:<{max_action_name_len}} -{normal} {doc}'.format(\\n bright=Style.BRIGHT,\\n name=name,\\n max_action_name_len=max_action_name_len,\\n normal=Style.NORMAL,\\n doc=wrapped_doc,\\n )\\n )\\n return None\",\n \"def plugin_list(self):\\r\\n return get_module_list()\",\n \"def get_all_action_types() -> List[str]:\\n\\n actions: List[str] = []\\n for name, val in actions_module_dict.items(): # iterate through every module's attributes\\n if inspect.isclass(val) and issubclass(val, Action) and val != Action:\\n actions.append(name)\\n\\n return actions\",\n \"def list_plugins(request):\\n plugins = plugin.get_plugins()\\n return plugins\",\n \"def getActions(self, state): \\n util.raiseNotDefined()\",\n \"def action_templates(self) -> List[ActionTemplate]:\\n return self._action_templates\",\n \"def all_actions(self):\\n actions = self.actions.stream[:]\\n for eq in self.equipment:\\n actions.extend(eq.actions)\\n return actions\",\n \"def actions(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:\\n return pulumi.get(self, \\\"actions\\\")\",\n \"def actions(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:\\n return pulumi.get(self, \\\"actions\\\")\",\n \"def getAllRobotActions(self):\\n return self.robot.actions\",\n \"def get_available_actions() -> tuple:\\n return tuple(method for method in dir(cli_commands) if callable(getattr(cli_commands, method)))\",\n \"def do_list_commands(plugin):\\n if not plugin.supported_commands:\\n click.secho(\\n f\\\"Plugin '{plugin.name}' does not define any commands.\\\", fg=\\\"yellow\\\"\\n )\\n return\\n\\n descriptions = {\\n f\\\"{plugin.name}:{cmd}\\\": props.description\\n for cmd, props in plugin.all_commands.items()\\n }\\n column_len = max(len(name) for name in descriptions.keys()) + 2\\n for name, desc in descriptions.items():\\n click.secho(name.ljust(column_len, \\\" \\\"), fg=\\\"blue\\\", nl=False)\\n click.echo(desc)\",\n \"def actions(self, phrase: str) -> list:\\n return self._current_scope.get(phrase, [])\",\n \"def get_custom_actions(self, form_wizard_entry, request=None):\\n return self.custom_actions(form_wizard_entry, request)\",\n \"def _help_actions(self):\\n actions_str = \\\"\\\"\\n for (key, value) in self.actions_help.items():\\n actions_str += \\\"command: %s\\\\n%s\\\\n\\\\n\\\" % (key, value)\\n print(actions_str)\\n sys.exit(0)\",\n \"def actions() -> None:\\n pass\",\n \"def request_plugins(self):\",\n \"def get_content(self):\\r\\n for action in self._actions:\\r\\n action.execute()\",\n \"def actions(self, state):\\n myActionList= (1,2);\\n return myActionList\",\n \"def actions(self):\\n return {0, 1, 2, 3, 4, 5, 11, 12}\",\n \"def get_actions(self, request):\\n actions = super(RateLimitedIPAdmin, self).get_actions(request)\\n del actions['delete_selected']\\n return actions\",\n \"def right_click_plugins(self) -> misc_.plugins.PluginHandler:\\n\\t\\treturn self._right_click_plugins\",\n \"def get_custom_actions(self, form_entry, request=None):\\n return self.custom_actions(form_entry, request)\",\n \"def get_actions(\\n self, observations: Observations, action_space: gym.Space\\n ) -> Actions:\\n return super().get_actions(observations, action_space)\",\n \"def get_actions(self, request):\\n actions = super().get_actions(request)\\n actions.pop('delete_selected', None)\\n\\n return actions\",\n \"def getCommands():\\n return getPlugins(ICommand, plugins)\",\n \"def get_legal_actions(self):\\n pass\",\n \"def _getAvailableActions(self, board):\\r\\n myPits = board.mySide(self.id)\\r\\n return [i for i in myPits if i > 0]\",\n \"def _getAvailableActions(self, board):\\r\\n myPits = board.mySide(self.id)\\r\\n return [i for i in myPits if i > 0]\",\n \"def list_actions(self, query_params: Dict[str, object] = None) -> List[Action]:\\n if query_params is None:\\n query_params = {}\\n\\n path_params = {\\n }\\n\\n path = Template(\\\"/action/v1beta2/actions\\\").substitute(path_params)\\n url = self.base_client.build_url(path)\\n response = self.base_client.get(url, params=query_params)\\n return handle_response(response, Action)\",\n \"def get_actions(self):\\r\\n return -4,4\",\n \"def server_plugin_list(ctx):\\n data = ctx.obj.get_all_plugins()\\n output_json_data(data)\",\n \"def actions(self):\\n return self._separated_constructs(RuleAction)\",\n \"def all_action_names() -> List[str]:\\n\\n return list(map(lambda c: c.name, LoggingActions))\",\n \"def all_actions(self, player):\\n return [m for m in MOVES if m.norm() == 1]\",\n \"def get_plugins(self):\\n return []\",\n \"def valid_actions(self) -> List[str]:\\n return list(self.action_map().keys())\",\n \"def _get_legal_actions(self):\\n raise NotImplementedError\",\n \"def getAllActions(self):\\n decision_rules = self.getAllDecisionRules()\\n return list(itertools.product(decision_rules, self.getAllRobotActions()))\",\n \"def get_action_classes(app_name: str):\\n from policyengine.models import PlatformAction\\n actions = []\\n for cls in apps.get_app_config(app_name).get_models():\\n if issubclass(cls, PlatformAction) and hasattr(cls, \\\"action_codename\\\"):\\n actions.append(cls)\\n return actions\",\n \"def get_actions(self, joueur):\\n actions = []\\n if joueur == \\\"w\\\":\\n j2 = \\\"b\\\"\\n else:\\n j2 = \\\"w\\\"\\n for p in self.pionsliste:\\n start = time.time()\\n if p.color == joueur:\\n mvts = p.get_mvts(self)\\n for m in mvts:\\n actions.append(Action(p, m[0], m[1], self.get_copy(), j2))\\n print(p.type, \\\"{:.4f}\\\".format(time.time()-start), len(mvts), len(actions))\\n return actions\",\n \"def get_actions(self, oid, action_id=None):\\n if action_id is None:\\n path = '/servers/%s/os-instance-actions' % oid\\n key = 'instanceActions'\\n else:\\n path = '/servers/%s/os-instance-actions/%s' % (oid, action_id)\\n key = 'instanceAction'\\n res = self.client.call(path, 'GET', data='', \\n token=self.manager.identity.token)\\n self.logger.debug('get openstack server %s actions: %s' % \\n (oid, truncate(res)))\\n return res[0][key]\",\n \"def _get_legal_actions(self):\\n return self.game.get_legal_actions()\",\n \"def legal_actions(self):\\n raise NotImplementedError\",\n \"def do_plugin_list(cc, args):\\n params = {}\\n\\n if args.detail:\\n fields = res_fields.PLUGIN_DETAILED_RESOURCE.fields\\n field_labels = res_fields.PLUGIN_DETAILED_RESOURCE.labels\\n elif args.fields:\\n utils.check_for_invalid_fields(\\n args.fields[0], res_fields.PLUGIN_DETAILED_RESOURCE.fields)\\n resource = res_fields.Resource(args.fields[0])\\n fields = resource.fields\\n field_labels = resource.labels\\n else:\\n fields = res_fields.PLUGIN_RESOURCE.fields\\n field_labels = res_fields.PLUGIN_RESOURCE.labels\\n\\n sort_fields = res_fields.PLUGIN_DETAILED_RESOURCE.sort_fields\\n sort_field_labels = res_fields.PLUGIN_DETAILED_RESOURCE.sort_labels\\n\\n params.update(utils.common_params_for_list(args,\\n sort_fields,\\n sort_field_labels))\\n\\n if args.with_public:\\n params['with_public'] = args.with_public\\n\\n if args.public:\\n params['public'] = args.public\\n\\n if args.all_plugins:\\n params['all_plugins'] = args.all_plugins\\n\\n plugins = cc.plugin.list(**params)\\n cliutils.print_list(plugins, fields,\\n field_labels=field_labels,\\n sortby_index=None,\\n json_flag=args.json)\",\n \"def action_list(args):\\n\\n module_root = Path(\\\"modules/\\\")\\n modules = load_modules(module_root)\\n\\n print(\\\"Available modules:\\\")\\n for module in modules:\\n print(f\\\"- {module}\\\")\",\n \"def plugins():\\n pass\",\n \"def get_admin_commands(self):\\n\\n return []\",\n \"def auto_discover():\\n auto_registration(\\\"actions\\\")\",\n \"def get_interactions(self):\\n return self._interactions\",\n \"def get_actions(self, hyper_s):\\n hyper_actions = []\\n for next_s in self._get_periphery(hyper_s):\\n if not self._is_covered(hyper_actions, next_s):\\n hyper_actions.append(Action(self._get_hyper_s(next_s)))\\n\\n return hyper_actions\",\n \"def list():\\n manager = Actions()\\n tasks_list = manager.get_tasks_list()\\n console_utils.print_tree(manager, tasks_list)\",\n \"def solution(self):\\n\\t\\treturn [node.action for node in self.path()[1:]]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8130526","0.76124007","0.7425578","0.73972076","0.72777","0.7205521","0.7205521","0.7205521","0.7167486","0.7161599","0.7116936","0.7075639","0.70122087","0.68798953","0.67999965","0.6772967","0.6758088","0.67547417","0.6751595","0.6751595","0.67393315","0.6720449","0.6703838","0.6685096","0.6682575","0.6659212","0.6631779","0.6573402","0.64993525","0.6465212","0.64461166","0.64350706","0.64236015","0.64144665","0.63910186","0.637458","0.637131","0.63626635","0.63569295","0.63562196","0.6347627","0.634364","0.63320434","0.63171273","0.62686694","0.6209177","0.618048","0.61774796","0.61548764","0.61490846","0.61484706","0.61341697","0.61198884","0.6117559","0.6117559","0.61070055","0.6090278","0.60879964","0.60587895","0.60546076","0.6043218","0.60270274","0.601355","0.6011604","0.59877276","0.59814376","0.5953816","0.59236795","0.5919373","0.5918581","0.5917659","0.59151334","0.589342","0.58899146","0.58899146","0.58840543","0.5859887","0.5857634","0.58497643","0.58225834","0.5796349","0.57818913","0.5767738","0.5766013","0.5762452","0.5757184","0.5742098","0.5737133","0.57341033","0.57264245","0.57199526","0.56978077","0.5688094","0.56773156","0.5663219","0.56554943","0.5646075","0.564104","0.5635086"],"string":"[\n \"0.8130526\",\n \"0.76124007\",\n \"0.7425578\",\n \"0.73972076\",\n \"0.72777\",\n \"0.7205521\",\n \"0.7205521\",\n \"0.7205521\",\n \"0.7167486\",\n \"0.7161599\",\n \"0.7116936\",\n \"0.7075639\",\n \"0.70122087\",\n \"0.68798953\",\n \"0.67999965\",\n \"0.6772967\",\n \"0.6758088\",\n \"0.67547417\",\n \"0.6751595\",\n \"0.6751595\",\n \"0.67393315\",\n \"0.6720449\",\n \"0.6703838\",\n \"0.6685096\",\n \"0.6682575\",\n \"0.6659212\",\n \"0.6631779\",\n \"0.6573402\",\n \"0.64993525\",\n \"0.6465212\",\n \"0.64461166\",\n \"0.64350706\",\n \"0.64236015\",\n \"0.64144665\",\n \"0.63910186\",\n \"0.637458\",\n \"0.637131\",\n \"0.63626635\",\n \"0.63569295\",\n \"0.63562196\",\n \"0.6347627\",\n \"0.634364\",\n \"0.63320434\",\n \"0.63171273\",\n \"0.62686694\",\n \"0.6209177\",\n \"0.618048\",\n \"0.61774796\",\n \"0.61548764\",\n \"0.61490846\",\n \"0.61484706\",\n \"0.61341697\",\n \"0.61198884\",\n \"0.6117559\",\n \"0.6117559\",\n \"0.61070055\",\n \"0.6090278\",\n \"0.60879964\",\n \"0.60587895\",\n \"0.60546076\",\n \"0.6043218\",\n \"0.60270274\",\n \"0.601355\",\n \"0.6011604\",\n \"0.59877276\",\n \"0.59814376\",\n \"0.5953816\",\n \"0.59236795\",\n \"0.5919373\",\n \"0.5918581\",\n \"0.5917659\",\n \"0.59151334\",\n \"0.589342\",\n \"0.58899146\",\n \"0.58899146\",\n \"0.58840543\",\n \"0.5859887\",\n \"0.5857634\",\n \"0.58497643\",\n \"0.58225834\",\n \"0.5796349\",\n \"0.57818913\",\n \"0.5767738\",\n \"0.5766013\",\n \"0.5762452\",\n \"0.5757184\",\n \"0.5742098\",\n \"0.5737133\",\n \"0.57341033\",\n \"0.57264245\",\n \"0.57199526\",\n \"0.56978077\",\n \"0.5688094\",\n \"0.56773156\",\n \"0.5663219\",\n \"0.56554943\",\n \"0.5646075\",\n \"0.564104\",\n \"0.5635086\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8701119"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":21979,"cells":{"query":{"kind":"string","value":"Action to be performed on first plugin registration"},"document":{"kind":"string","value":"def on_first_registration(self):\n self.main.tabify_plugins(self.main.help, self)\n self.dockwidget.hide()"},"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 on_first_registration(self):\n pass","def plugin_loaded():\n events.broadcast(\"plugin_loaded\")","def init():\n g.registerHandler('new', new_hook)\n g.registerHandler('create-node', create_node_hook)\n g.registerHandler('select1', select1_hook)\n g.plugin_signon(__name__)\n return True","def request_plugins(self):","def onRegister(self):\n pass","def onRegister(self):\n pass","def registration_started(self):\n pass","def control_plugin(self):\n pass","def on_startup(self) -> None:\n ...","def register_default_plugins(self):\n self._requires_register_default = True","def init():\n ok = not g.unitTesting # Dangerous for unit testing.\n if ok:\n g.registerHandler(\"icondclick1\", onIconDoubleClick)\n g.plugin_signon(__name__)\n return ok","def plugins_ready():\n\n for plugin in registerorder:\n plugin.ready()","def test_register_dynamic_plugin1(self):\n pass","def registered(self):\n log.info(\"Registered.\")\n pass","def pluginsStarted(self):\n self.spamcontrolPlugin = self.getPlugin(\"spamcontrol\")\n if self.spamcontrolPlugin:\n self.patch_spamcontrolPlugin()","def core_plugin(self):\n pass","def plugin_one():\n return \"one\"","def auto_discover():\n auto_registration(\"actions\")","def plugin_init():\n\n global _recreate_omf_objects\n\n _logger.debug(\"{0} - URL {1}\".format(\"plugin_init\", _config['URL']))\n\n try:\n\n _recreate_omf_objects = True\n\n except Exception as ex:\n _message = plugin_common.MESSAGES_LIST[\"e000011\"].format(ex)\n\n _logger.error(_message)\n raise plugin_exceptions.PluginInitializeFailed(ex)","def plugins():\n pass","def register_plugin(self, plugin):\n self.log.info(\"Registering plugin %s\", type(plugin).__name__)\n self._register_commands(plugin)\n plugin.on_load()","def __init__(self):\n\n self.plugin_name = 'Yum'","def on_start(self):\n # self.signup()","def plugh():","def test_register_dynamic_plugin(self):\n pass","def register_plugin(self):\n self.edit_goto.connect(self.main.editor.load)\n self.redirect_stdio.connect(self.main.redirect_internalshell_stdio)\n self.main.add_dockwidget(self)\n\n unittesting_act = create_action(self, _(\"Run unit tests\"),\n icon=get_icon('profiler.png'),\n triggered=self.run_unittesting)\n unittesting_act.setEnabled(is_unittesting_installed())\n fixed_shortcut(\"Ctrl+Shift+F11\", self.main,\n self.run_unittesting)\n\n self.main.run_menu_actions += [unittesting_act]\n self.main.editor.pythonfile_dependent_actions += [unittesting_act]","def initialise(self):\n logging.debug(\"TrackerPlugin.initialise\")","def post_start(self):","def refresh_plugin(self):\n pass","def registration_started(self):\n self.resolution = 0","def get_plugin(self, name):","def on_register(cls):","def main():\n PLUGIN_ENTRY().run(\"\")","def init():\n g.registerHandler('after-create-leo-frame', onCreate)\n g.plugin_signon(__name__)\n if '_quickmove' not in g.app.db:\n g.app.db['_quickmove'] = {'global_targets': []}\n return True","def test_register_dynamic_plugin_manager1(self):\n pass","def OnStartup(cls, modName ):\r\n import sys\r\n targetMod = sys.modules[ modName ]\r\n cls.StartupVarsInjectToMod( targetMod )\r\n EasyIpyMagics.RegisterMagics()\r\n \r\n cls.RegisterPostExecute()","def plugin_finalize(self, plugin):","def init():\n global PLUGIN_NAME\n PLUGIN_NAME = inspect.currentframe().f_code.co_filename","async def pre_action_init(self) -> None:","def test_plugin_initialize(self):\n p = PluginCustom()\n self.assertEqual('youpie', p.toto)","def on_start(self):\n pass","def on_start(self):\n pass","def on_start(self):\n pass","def on_start(self):\n pass","def on_start(self):\n pass","def on_start(self):\n pass","def on_start(self):\n pass","def on_start(self):\n pass","def add_plugin(self, cls):\r\n command = cls.__module__.split('.')[-1]\r\n if command not in self.plugins:\r\n self.plugins[command] = {}\r\n self.plugins[command][cls.action] = cls","def on_load(self):\n pass","def on_load(self):\n pass","def auto_populate(self):\n Debug.printi(\"Call to autopopulater registered\")","def register_plugin(self):\n self.create_toggle_view_action()\n\n self.main.add_dockwidget(self)","def cb_at_start(hass):\n calls.append(1)","def cb_at_start(hass):\n calls.append(1)","def cb_at_start(hass):\n calls.append(1)","def init():\n ok = not g.unitTesting\n if ok:\n g.plugin_signon(__name__)\n return ok","def do_setup(self, context):\r\n LOG.debug(\"Do setup the plugin.\")\r\n return self.helper.login()","def init(): \n\tset_verbosity()\n\t_set_threads()\n\t_set_heartbeat()\n\t#_set_storage()\n\t\n\tinit_targets()\n\t\n\tsend_heartbeat(start=True)\n\t\n\tinfo_msg = \"init plugin script\"\n\tlogger.info(info_msg)\n\n\tinit_plugin()\n\n\tinfo_msg = \"loaded %s plugin(s)\" %(len(kb.plugins.handle))\n\tlogger.info(info_msg)","def pre_installation(self):\n pass","def pyang_plugin_init():\n plugin.register_plugin(OpenConfigPlugin())","def PluginInstall(self, pluginName, pluginPath):\n pass","def init():\n if g.app.gui is None:\n g.app.createQtGui(__file__)\n ok = g.app.gui.guiName().startswith('qt')\n if ok:\n g.registerHandler('after-create-leo-frame', onCreate)\n g.plugin_signon(__name__)\n else:\n g.es('nodewatch.py not loaded', color='red')\n return ok","def test_register_dynamic_plugin_manager(self):\n pass","async def on_start(self):\n\t\t\n\t\t# Register callback.\n\t\tawait self.instance.command_manager.register(\n\t\t\tCommand(command='muffin', target=self.muffin, admin=False, description='Bake a muffin').add_param(name='login', required=True))","def on_start(self):\n self.init()","def plugin_two():\n return \"two\"","def __init__(self, ui):\n super(WakaTimePlugin, self).__init__(ui)\n self._ui = ui\n\n try:\n e5App().registerPluginObject(pluginTypename, self)\n except KeyError:\n pass # ignore duplicate registration","def post(self):\n self.finish(self.register())","def startup(self):\n pass","def pre_start(self) -> None:\n pass","def server_plugin():","def do_post_install(self, context):\n pass","def afterInit(self):","def test_install_plugin_again_is_ok(self):\n raise NotImplementedError()","def get_plugin_interface(self):","def request():\n Provider.setProperty(PLUGIN_NAME, \"Hello!\", \"You are in %s.\" %\n Location.getCity())\n Provider.done(PLUGIN_NAME)","def plugin_first_label():\n return \"first\"","def on_load(self):\n self.__init__()","def onInit(self):\n pass","def post_init(self):\n\t\tpass","def post_setup(self, context):\n pass","def on_load(self):","def setup(self):\n\n if self.has_setup():\n self.logger.info(\"%s has a pre-flight setup routine. Running now.\" % self.plugin_dict_name)\n self._module.setup(self, self.versions)","def initGui(self):\n\n icon_path = ':/plugins/buienradar_plugin/icon.png'\n self.add_action(\n icon_path,\n text=self.tr(u'Buienradar Plugin'),\n callback=self.run,\n parent=self.iface.mainWindow())\n\n # will be set False in run()\n self.first_start = True","def on_start(self):","def on_start(self):","def pre_start_hook(self):\n\n LOG.debug(_('XManager pre_start_hook...'))\n\n pass","def register(self, plugin, name=None):\n plugin_name = super(PiPluginManager, self).register(plugin, name)\n if plugin not in self._plugin2calls:\n self._plugin2calls[plugin] = set()\n return plugin_name","def post_start_hook(self):\n\n LOG.debug(_('XManager post_start_hook...'))\n\n pass","def setup(self):\n rc = self.rc\n try:\n for plugin in self.plugins:\n plugin.setup(rc)\n except Exception as e:\n self.exit(e)","def ready(self):\n if settings.PLUGINS_ENABLED:\n if not canAppAccessDatabase(allow_test=True):\n logger.info(\"Skipping plugin loading sequence\") # pragma: no cover\n else:\n logger.info('Loading InvenTree plugins')\n\n if not registry.is_loading:\n # this is the first startup\n try:\n from common.models import InvenTreeSetting\n if InvenTreeSetting.get_setting('PLUGIN_ON_STARTUP', create=False, cache=False):\n # make sure all plugins are installed\n registry.install_plugin_file()\n except Exception: # pragma: no cover\n pass\n\n # get plugins and init them\n registry.plugin_modules = registry.collect_plugins()\n registry.load_plugins()\n\n # drop out of maintenance\n # makes sure we did not have an error in reloading and maintenance is still active\n set_maintenance_mode(False)\n\n # check git version\n registry.git_is_modern = check_git_version()\n if not registry.git_is_modern: # pragma: no cover # simulating old git seems not worth it for coverage\n log_error(_('Your enviroment has an outdated git version. This prevents InvenTree from loading plugin details.'), 'load')\n\n else:\n logger.info(\"Plugins not enabled - skipping loading sequence\") # pragma: no cover","def _post_hooks(self):","def _installed_apps_add(self):\n config.add_plugin(self.module_path)","def startup(self) -> None:","def _afterInit(self):\n pass","def register():\n \n global _registered\n if not _registered:\n _registered = True\n sys.path_hooks.insert(0, VFSImporter)","def connect(self, plug):","def on_register(self, response):\n print('You have been registered!')\n self.on_auth(response)","def prepare_plugin(self, plugin_path):\n # This method does not exist in MOS 7.0\n if not hasattr(self.env.admin_actions, 'upload_plugin'):\n mos7_upload_plugin(plugin=plugin_path, source=self.env.d_env)\n mos7_install_plugin(\n plugin_file_name=os.path.basename(plugin_path),\n source=self.env.d_env)\n else:\n self.env.admin_actions.upload_plugin(plugin=plugin_path)\n self.env.admin_actions.install_plugin(\n plugin_file_name=os.path.basename(plugin_path))"],"string":"[\n \"def on_first_registration(self):\\n pass\",\n \"def plugin_loaded():\\n events.broadcast(\\\"plugin_loaded\\\")\",\n \"def init():\\n g.registerHandler('new', new_hook)\\n g.registerHandler('create-node', create_node_hook)\\n g.registerHandler('select1', select1_hook)\\n g.plugin_signon(__name__)\\n return True\",\n \"def request_plugins(self):\",\n \"def onRegister(self):\\n pass\",\n \"def onRegister(self):\\n pass\",\n \"def registration_started(self):\\n pass\",\n \"def control_plugin(self):\\n pass\",\n \"def on_startup(self) -> None:\\n ...\",\n \"def register_default_plugins(self):\\n self._requires_register_default = True\",\n \"def init():\\n ok = not g.unitTesting # Dangerous for unit testing.\\n if ok:\\n g.registerHandler(\\\"icondclick1\\\", onIconDoubleClick)\\n g.plugin_signon(__name__)\\n return ok\",\n \"def plugins_ready():\\n\\n for plugin in registerorder:\\n plugin.ready()\",\n \"def test_register_dynamic_plugin1(self):\\n pass\",\n \"def registered(self):\\n log.info(\\\"Registered.\\\")\\n pass\",\n \"def pluginsStarted(self):\\n self.spamcontrolPlugin = self.getPlugin(\\\"spamcontrol\\\")\\n if self.spamcontrolPlugin:\\n self.patch_spamcontrolPlugin()\",\n \"def core_plugin(self):\\n pass\",\n \"def plugin_one():\\n return \\\"one\\\"\",\n \"def auto_discover():\\n auto_registration(\\\"actions\\\")\",\n \"def plugin_init():\\n\\n global _recreate_omf_objects\\n\\n _logger.debug(\\\"{0} - URL {1}\\\".format(\\\"plugin_init\\\", _config['URL']))\\n\\n try:\\n\\n _recreate_omf_objects = True\\n\\n except Exception as ex:\\n _message = plugin_common.MESSAGES_LIST[\\\"e000011\\\"].format(ex)\\n\\n _logger.error(_message)\\n raise plugin_exceptions.PluginInitializeFailed(ex)\",\n \"def plugins():\\n pass\",\n \"def register_plugin(self, plugin):\\n self.log.info(\\\"Registering plugin %s\\\", type(plugin).__name__)\\n self._register_commands(plugin)\\n plugin.on_load()\",\n \"def __init__(self):\\n\\n self.plugin_name = 'Yum'\",\n \"def on_start(self):\\n # self.signup()\",\n \"def plugh():\",\n \"def test_register_dynamic_plugin(self):\\n pass\",\n \"def register_plugin(self):\\n self.edit_goto.connect(self.main.editor.load)\\n self.redirect_stdio.connect(self.main.redirect_internalshell_stdio)\\n self.main.add_dockwidget(self)\\n\\n unittesting_act = create_action(self, _(\\\"Run unit tests\\\"),\\n icon=get_icon('profiler.png'),\\n triggered=self.run_unittesting)\\n unittesting_act.setEnabled(is_unittesting_installed())\\n fixed_shortcut(\\\"Ctrl+Shift+F11\\\", self.main,\\n self.run_unittesting)\\n\\n self.main.run_menu_actions += [unittesting_act]\\n self.main.editor.pythonfile_dependent_actions += [unittesting_act]\",\n \"def initialise(self):\\n logging.debug(\\\"TrackerPlugin.initialise\\\")\",\n \"def post_start(self):\",\n \"def refresh_plugin(self):\\n pass\",\n \"def registration_started(self):\\n self.resolution = 0\",\n \"def get_plugin(self, name):\",\n \"def on_register(cls):\",\n \"def main():\\n PLUGIN_ENTRY().run(\\\"\\\")\",\n \"def init():\\n g.registerHandler('after-create-leo-frame', onCreate)\\n g.plugin_signon(__name__)\\n if '_quickmove' not in g.app.db:\\n g.app.db['_quickmove'] = {'global_targets': []}\\n return True\",\n \"def test_register_dynamic_plugin_manager1(self):\\n pass\",\n \"def OnStartup(cls, modName ):\\r\\n import sys\\r\\n targetMod = sys.modules[ modName ]\\r\\n cls.StartupVarsInjectToMod( targetMod )\\r\\n EasyIpyMagics.RegisterMagics()\\r\\n \\r\\n cls.RegisterPostExecute()\",\n \"def plugin_finalize(self, plugin):\",\n \"def init():\\n global PLUGIN_NAME\\n PLUGIN_NAME = inspect.currentframe().f_code.co_filename\",\n \"async def pre_action_init(self) -> None:\",\n \"def test_plugin_initialize(self):\\n p = PluginCustom()\\n self.assertEqual('youpie', p.toto)\",\n \"def on_start(self):\\n pass\",\n \"def on_start(self):\\n pass\",\n \"def on_start(self):\\n pass\",\n \"def on_start(self):\\n pass\",\n \"def on_start(self):\\n pass\",\n \"def on_start(self):\\n pass\",\n \"def on_start(self):\\n pass\",\n \"def on_start(self):\\n pass\",\n \"def add_plugin(self, cls):\\r\\n command = cls.__module__.split('.')[-1]\\r\\n if command not in self.plugins:\\r\\n self.plugins[command] = {}\\r\\n self.plugins[command][cls.action] = cls\",\n \"def on_load(self):\\n pass\",\n \"def on_load(self):\\n pass\",\n \"def auto_populate(self):\\n Debug.printi(\\\"Call to autopopulater registered\\\")\",\n \"def register_plugin(self):\\n self.create_toggle_view_action()\\n\\n self.main.add_dockwidget(self)\",\n \"def cb_at_start(hass):\\n calls.append(1)\",\n \"def cb_at_start(hass):\\n calls.append(1)\",\n \"def cb_at_start(hass):\\n calls.append(1)\",\n \"def init():\\n ok = not g.unitTesting\\n if ok:\\n g.plugin_signon(__name__)\\n return ok\",\n \"def do_setup(self, context):\\r\\n LOG.debug(\\\"Do setup the plugin.\\\")\\r\\n return self.helper.login()\",\n \"def init(): \\n\\tset_verbosity()\\n\\t_set_threads()\\n\\t_set_heartbeat()\\n\\t#_set_storage()\\n\\t\\n\\tinit_targets()\\n\\t\\n\\tsend_heartbeat(start=True)\\n\\t\\n\\tinfo_msg = \\\"init plugin script\\\"\\n\\tlogger.info(info_msg)\\n\\n\\tinit_plugin()\\n\\n\\tinfo_msg = \\\"loaded %s plugin(s)\\\" %(len(kb.plugins.handle))\\n\\tlogger.info(info_msg)\",\n \"def pre_installation(self):\\n pass\",\n \"def pyang_plugin_init():\\n plugin.register_plugin(OpenConfigPlugin())\",\n \"def PluginInstall(self, pluginName, pluginPath):\\n pass\",\n \"def init():\\n if g.app.gui is None:\\n g.app.createQtGui(__file__)\\n ok = g.app.gui.guiName().startswith('qt')\\n if ok:\\n g.registerHandler('after-create-leo-frame', onCreate)\\n g.plugin_signon(__name__)\\n else:\\n g.es('nodewatch.py not loaded', color='red')\\n return ok\",\n \"def test_register_dynamic_plugin_manager(self):\\n pass\",\n \"async def on_start(self):\\n\\t\\t\\n\\t\\t# Register callback.\\n\\t\\tawait self.instance.command_manager.register(\\n\\t\\t\\tCommand(command='muffin', target=self.muffin, admin=False, description='Bake a muffin').add_param(name='login', required=True))\",\n \"def on_start(self):\\n self.init()\",\n \"def plugin_two():\\n return \\\"two\\\"\",\n \"def __init__(self, ui):\\n super(WakaTimePlugin, self).__init__(ui)\\n self._ui = ui\\n\\n try:\\n e5App().registerPluginObject(pluginTypename, self)\\n except KeyError:\\n pass # ignore duplicate registration\",\n \"def post(self):\\n self.finish(self.register())\",\n \"def startup(self):\\n pass\",\n \"def pre_start(self) -> None:\\n pass\",\n \"def server_plugin():\",\n \"def do_post_install(self, context):\\n pass\",\n \"def afterInit(self):\",\n \"def test_install_plugin_again_is_ok(self):\\n raise NotImplementedError()\",\n \"def get_plugin_interface(self):\",\n \"def request():\\n Provider.setProperty(PLUGIN_NAME, \\\"Hello!\\\", \\\"You are in %s.\\\" %\\n Location.getCity())\\n Provider.done(PLUGIN_NAME)\",\n \"def plugin_first_label():\\n return \\\"first\\\"\",\n \"def on_load(self):\\n self.__init__()\",\n \"def onInit(self):\\n pass\",\n \"def post_init(self):\\n\\t\\tpass\",\n \"def post_setup(self, context):\\n pass\",\n \"def on_load(self):\",\n \"def setup(self):\\n\\n if self.has_setup():\\n self.logger.info(\\\"%s has a pre-flight setup routine. Running now.\\\" % self.plugin_dict_name)\\n self._module.setup(self, self.versions)\",\n \"def initGui(self):\\n\\n icon_path = ':/plugins/buienradar_plugin/icon.png'\\n self.add_action(\\n icon_path,\\n text=self.tr(u'Buienradar Plugin'),\\n callback=self.run,\\n parent=self.iface.mainWindow())\\n\\n # will be set False in run()\\n self.first_start = True\",\n \"def on_start(self):\",\n \"def on_start(self):\",\n \"def pre_start_hook(self):\\n\\n LOG.debug(_('XManager pre_start_hook...'))\\n\\n pass\",\n \"def register(self, plugin, name=None):\\n plugin_name = super(PiPluginManager, self).register(plugin, name)\\n if plugin not in self._plugin2calls:\\n self._plugin2calls[plugin] = set()\\n return plugin_name\",\n \"def post_start_hook(self):\\n\\n LOG.debug(_('XManager post_start_hook...'))\\n\\n pass\",\n \"def setup(self):\\n rc = self.rc\\n try:\\n for plugin in self.plugins:\\n plugin.setup(rc)\\n except Exception as e:\\n self.exit(e)\",\n \"def ready(self):\\n if settings.PLUGINS_ENABLED:\\n if not canAppAccessDatabase(allow_test=True):\\n logger.info(\\\"Skipping plugin loading sequence\\\") # pragma: no cover\\n else:\\n logger.info('Loading InvenTree plugins')\\n\\n if not registry.is_loading:\\n # this is the first startup\\n try:\\n from common.models import InvenTreeSetting\\n if InvenTreeSetting.get_setting('PLUGIN_ON_STARTUP', create=False, cache=False):\\n # make sure all plugins are installed\\n registry.install_plugin_file()\\n except Exception: # pragma: no cover\\n pass\\n\\n # get plugins and init them\\n registry.plugin_modules = registry.collect_plugins()\\n registry.load_plugins()\\n\\n # drop out of maintenance\\n # makes sure we did not have an error in reloading and maintenance is still active\\n set_maintenance_mode(False)\\n\\n # check git version\\n registry.git_is_modern = check_git_version()\\n if not registry.git_is_modern: # pragma: no cover # simulating old git seems not worth it for coverage\\n log_error(_('Your enviroment has an outdated git version. This prevents InvenTree from loading plugin details.'), 'load')\\n\\n else:\\n logger.info(\\\"Plugins not enabled - skipping loading sequence\\\") # pragma: no cover\",\n \"def _post_hooks(self):\",\n \"def _installed_apps_add(self):\\n config.add_plugin(self.module_path)\",\n \"def startup(self) -> None:\",\n \"def _afterInit(self):\\n pass\",\n \"def register():\\n \\n global _registered\\n if not _registered:\\n _registered = True\\n sys.path_hooks.insert(0, VFSImporter)\",\n \"def connect(self, plug):\",\n \"def on_register(self, response):\\n print('You have been registered!')\\n self.on_auth(response)\",\n \"def prepare_plugin(self, plugin_path):\\n # This method does not exist in MOS 7.0\\n if not hasattr(self.env.admin_actions, 'upload_plugin'):\\n mos7_upload_plugin(plugin=plugin_path, source=self.env.d_env)\\n mos7_install_plugin(\\n plugin_file_name=os.path.basename(plugin_path),\\n source=self.env.d_env)\\n else:\\n self.env.admin_actions.upload_plugin(plugin=plugin_path)\\n self.env.admin_actions.install_plugin(\\n plugin_file_name=os.path.basename(plugin_path))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7602643","0.731127","0.69100946","0.6785684","0.67597336","0.67597336","0.6756247","0.6613261","0.658728","0.65075296","0.6474666","0.64614034","0.64464325","0.6428728","0.6416666","0.63851625","0.6381655","0.63470215","0.6346777","0.6321743","0.6249476","0.62354904","0.62223417","0.6212476","0.6198223","0.6189574","0.61612034","0.61567163","0.61375535","0.6133737","0.6111233","0.6094703","0.60808676","0.6055564","0.6050701","0.60409737","0.60173315","0.60111207","0.600395","0.59985614","0.59984225","0.59984225","0.59984225","0.59984225","0.59984225","0.59984225","0.59984225","0.59984225","0.598254","0.59766465","0.59766465","0.59745985","0.59729576","0.59702736","0.59702736","0.59702736","0.59698784","0.596585","0.5965034","0.595202","0.5939056","0.591264","0.58923024","0.58870405","0.58753484","0.58687586","0.5865212","0.58476067","0.58329785","0.58286154","0.58264697","0.58230275","0.58185256","0.5815561","0.58152395","0.5814061","0.58104795","0.5808596","0.5808498","0.5805441","0.58012176","0.5797697","0.5786888","0.57838726","0.5773023","0.5771482","0.5771482","0.57603997","0.5755865","0.5753631","0.5753425","0.5751908","0.5747317","0.5746191","0.574551","0.57449645","0.57428235","0.57415134","0.5738765","0.5700166"],"string":"[\n \"0.7602643\",\n \"0.731127\",\n \"0.69100946\",\n \"0.6785684\",\n \"0.67597336\",\n \"0.67597336\",\n \"0.6756247\",\n \"0.6613261\",\n \"0.658728\",\n \"0.65075296\",\n \"0.6474666\",\n \"0.64614034\",\n \"0.64464325\",\n \"0.6428728\",\n \"0.6416666\",\n \"0.63851625\",\n \"0.6381655\",\n \"0.63470215\",\n \"0.6346777\",\n \"0.6321743\",\n \"0.6249476\",\n \"0.62354904\",\n \"0.62223417\",\n \"0.6212476\",\n \"0.6198223\",\n \"0.6189574\",\n \"0.61612034\",\n \"0.61567163\",\n \"0.61375535\",\n \"0.6133737\",\n \"0.6111233\",\n \"0.6094703\",\n \"0.60808676\",\n \"0.6055564\",\n \"0.6050701\",\n \"0.60409737\",\n \"0.60173315\",\n \"0.60111207\",\n \"0.600395\",\n \"0.59985614\",\n \"0.59984225\",\n \"0.59984225\",\n \"0.59984225\",\n \"0.59984225\",\n \"0.59984225\",\n \"0.59984225\",\n \"0.59984225\",\n \"0.59984225\",\n \"0.598254\",\n \"0.59766465\",\n \"0.59766465\",\n \"0.59745985\",\n \"0.59729576\",\n \"0.59702736\",\n \"0.59702736\",\n \"0.59702736\",\n \"0.59698784\",\n \"0.596585\",\n \"0.5965034\",\n \"0.595202\",\n \"0.5939056\",\n \"0.591264\",\n \"0.58923024\",\n \"0.58870405\",\n \"0.58753484\",\n \"0.58687586\",\n \"0.5865212\",\n \"0.58476067\",\n \"0.58329785\",\n \"0.58286154\",\n \"0.58264697\",\n \"0.58230275\",\n \"0.58185256\",\n \"0.5815561\",\n \"0.58152395\",\n \"0.5814061\",\n \"0.58104795\",\n \"0.5808596\",\n \"0.5808498\",\n \"0.5805441\",\n \"0.58012176\",\n \"0.5797697\",\n \"0.5786888\",\n \"0.57838726\",\n \"0.5773023\",\n \"0.5771482\",\n \"0.5771482\",\n \"0.57603997\",\n \"0.5755865\",\n \"0.5753631\",\n \"0.5753425\",\n \"0.5751908\",\n \"0.5747317\",\n \"0.5746191\",\n \"0.574551\",\n \"0.57449645\",\n \"0.57428235\",\n \"0.57415134\",\n \"0.5738765\",\n \"0.5700166\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7290536"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":21980,"cells":{"query":{"kind":"string","value":"Register plugin in Spyder's main window"},"document":{"kind":"string","value":"def register_plugin(self):\n self.edit_goto.connect(self.main.editor.load)\n self.redirect_stdio.connect(self.main.redirect_internalshell_stdio)\n self.main.add_dockwidget(self)\n\n unittesting_act = create_action(self, _(\"Run unit tests\"),\n icon=get_icon('profiler.png'),\n triggered=self.run_unittesting)\n unittesting_act.setEnabled(is_unittesting_installed())\n fixed_shortcut(\"Ctrl+Shift+F11\", self.main,\n self.run_unittesting)\n\n self.main.run_menu_actions += [unittesting_act]\n self.main.editor.pythonfile_dependent_actions += [unittesting_act]"},"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 register_plugin(self):\n self.create_toggle_view_action()\n\n self.main.add_dockwidget(self)","def test_addplugin(self):\n app = QApplication(sys.argv)\n data = (np.random.rand(30, 31, 32) * 100).astype(np.int)\n data[15:40, 13:20, 10:18] += 50\n se = seededitorqt.QTSeedEditor(data)\n wg0 = seededitorqt.plugin.SampleThresholdPlugin()\n se.addPlugin(wg0)\n # se.exec_()\n # self.assertTrue(False)","def plugh():","def on_first_registration(self):\n self.main.tabify_plugins(self.main.help, self)\n self.dockwidget.hide()","def register():\n \n global _registered\n if not _registered:\n _registered = True\n sys.path_hooks.insert(0, VFSImporter)","def plugins():\n pass","def pyang_plugin_init():\n plugin.register_plugin(OpenConfigPlugin())","def plugin_register(api):\n api.range_tool_register('Example/01', MyPlugin)\n return True","def get_plugin(self, name):","def run_plugin(self, plugin_name, *args, nb_path=None, **kwargs):\n nb_path = self._resolve_nb_path(nb_path)\n if plugin_name in self._plugin_collections:\n pc = self._plugin_collections[plugin_name]\n else:\n pc = PluginCollection([plugin_name], nb_path, {})\n self._plugin_collections[plugin_name] = pc\n pc.run(\"from_notebook\", *args, **kwargs)","def show():\n from siding.addons import ui\n ui.show()","def test_show_editor(self):\n app = QApplication(sys.argv)\n data = (np.random.rand(30, 31, 32) * 100).astype(np.int)\n data[15:40, 13:20, 10:18] += 50\n se = seededitorqt.QTSeedEditor(data)\n wg0 = seededitorqt.plugin.SampleThresholdPlugin()\n wg1 = seededitorqt.plugin.SampleThresholdPlugin()\n se.addPlugin(wg0)\n se.addPlugin(wg1)\n se.exec_()\n # self.assertTrue(False)","def register() -> None:\n plot_backend = _get_plot_backend(\"matplotlib\")\n plot_backend.register()","def connect(self, plug):","def register(check_environ=False):\n from mundi.loader import register\n from mundi.types.region import REGION_PLUGINS\n\n if check_environ:\n import os\n\n if os.environ.get(\"MUNDI_DEMOGRAPHY\", \"on\").lower() in (\"off\", \"false\", \"no\"):\n return\n\n for k, v in FUNCTIONS.items():\n register(k, v)\n\n REGION_PLUGINS[\"population\"] = lambda x: population(x.id)\n REGION_PLUGINS[\"age_distribution\"] = lambda x: age_distribution(x.id)\n REGION_PLUGINS[\"age_pyramid\"] = lambda x: age_pyramid(x.id)","def core_plugin(self):\n pass","def __init__(self):\n\n self.plugin_name = 'Yum'","def get_plugin_interface(self):","def register():\n # DeepOBS\n deepobs.pytorch.testproblems.two_d_quadratic = two_d_quadratic\n\n # for CockpitPlotter\n if \"scalar\" in deepobs.config.DATA_SET_NAMING.keys():\n assert deepobs.config.DATA_SET_NAMING[\"scalar\"] == \"Scalar\"\n else:\n deepobs.config.DATA_SET_NAMING[\"scalar\"] = \"Scalar\"\n\n if \"deep\" in deepobs.config.TP_NAMING.keys():\n assert deepobs.config.TP_NAMING[\"deep\"] == \"Deep\"\n else:\n deepobs.config.TP_NAMING[\"deep\"] = \"deep\"\n\n # BackOBS\n backobs.utils.ALL += (two_d_quadratic,)\n backobs.utils.REGRESSION += (two_d_quadratic,)\n backobs.utils.SUPPORTED += (two_d_quadratic,)\n backobs.integration.SUPPORTED += (two_d_quadratic,)","def main():\n PLUGIN_ENTRY().run(\"\")","def init():\n global PLUGIN_NAME\n PLUGIN_NAME = inspect.currentframe().f_code.co_filename","def _installed_apps_add(self):\n config.add_plugin(self.module_path)","def launch_new_instance():\n import IPython\n\n IPython.Shell.start().mainloop()","def run(self):\n\n self.window.run_command(\"show_panel\", {\"panel\": \"output.reg_replace\"})","def startup():\n menuhook.register(\n \"quickpreview\",\n \"howtos\",\n quickpreview,\n menu=[\"&Scripting\", \"Python3 Development\", \"How To\"],\n text=\"Create a quick preview\",\n tooltip=\"Create a quick preview\")","def add_plugin(self, plugin):\n\n if not plugin:\n return\n\n plugin_btn = PluginButton(project=self._project, plugin=plugin)\n plugin_btn.clicked.connect(self.openPlugin.emit)\n self._flow_layout.addWidget(plugin_btn)","def register(name, value):\n\n return Plugins.register(name, value)","def new_plugin(ctx, **defaults):\n from .quickstart import plugin_quickstart\n\n project = ctx.get_project(silent=True)\n plugin_quickstart(defaults, project=project)","def test():\r\n from spyderlib.utils.qthelpers import qapplication\r\n app = qapplication()\r\n widget = BreakpointWidget(None)\r\n widget.show()\r\n sys.exit(app.exec_())","def setup(bot):\n bot.logger.debug(\n 'Registering extension \"Quiz\"'\n )\n bot.add_cog(QuizCog(bot))","def control_plugin(self):\n pass","def main():\n\tif mc.window( 'SetupOccUI', q = 1, ex = 1 ):\n\t\tmc.deleteUI( 'SetupOccUI' )\n\tPyForm=SetupOccUI()\n\tPyForm.show()","def load_ipython_extension(ipython):\n ipython.register_magics(ConductoMagics)","def register_plugin(self, plugin):\n self.log.info(\"Registering plugin %s\", type(plugin).__name__)\n self._register_commands(plugin)\n plugin.on_load()","def shell(state):\n IPython.embed(colors=\"Neutral\", banner1=BANNER, user_ns={\"sdk\": state.sdk})","def plugin_name(self):","def pyang_plugin_init():\n plugin.register_plugin(JNCPlugin())","def test_register_dynamic_plugin(self):\n pass","def init():\n if g.app.gui is None:\n g.app.createQtGui(__file__)\n ok = g.app.gui.guiName().startswith('qt')\n if ok:\n g.registerHandler('after-create-leo-frame', onCreate)\n g.plugin_signon(__name__)\n else:\n g.es('nodewatch.py not loaded', color='red')\n return ok","def launch (transparent=False): \n core.registerNew(resonance, str_to_bool(transparent))","def pyang_plugin_init():\n plugin.register_plugin(SwaggerPlugin())","def refresh_plugin(self):\n pass","def plugin_loaded():\n events.broadcast(\"plugin_loaded\")","def OnStartup(cls, modName ):\r\n import sys\r\n targetMod = sys.modules[ modName ]\r\n cls.StartupVarsInjectToMod( targetMod )\r\n EasyIpyMagics.RegisterMagics()\r\n \r\n cls.RegisterPostExecute()","def main():\r\n qApp = QtGui.QApplication(sys.argv)\r\n qApp.setApplicationName(\"Visualization Tool\")\r\n qApp.setOrganizationName(\"Marquette University Speechlab\")\r\n qApp.setWindowIcon(QtGui.QIcon(\":/vtIcon.ico\"))\r\n form = MainWindow()\r\n form.show()\r\n sys.exit(qApp.exec_())","def initGui(self):\n\n self.action = QAction(QIcon(self.plugdir + '/icon.png'), 'MGB Water Balance', self.iface.mainWindow())\n self.action.triggered.connect(self.run)\n self.iface.addToolBarIcon(self.action)\n self.iface.addPluginToMenu('&IPH - Plugins', self.action)","def __macroLoad(self):\n self.activeWindow().macroLoad()","def set_up_workspace():\n # Avoid Error #15: Initializing libiomp5.dylib, but found libiomp5.dylib already initialized.\n # https://stackoverflow.com/questions/53014306/error-15-initializing-libiomp5-dylib-but-found-libiomp5-dylib-already-initial\n os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'\n\n # Magic command for inline plotting\n # %matplotlib inline\n # %config InlineBackend.figure_format = 'retina'","def load_ipython_extension(ipython):\n _register_magics(ipython)","def add_profile(workbench, profile_config, names):\n p = workbench.get_plugin('exopy.instruments')\n p._unbind_observers()\n # Test observation of profiles folders\n for n in names:\n with open(os.path.join(p._profiles_folders[0], n + '.instr.ini'),\n 'wb') as f:\n profile_config.write(f)\n p._refresh_profiles()\n p._bind_observers()","def load_plugin():\n return HostTestPluginCopyMethod_Shell()","def register(func):\n plugins[func.__name__] = func\n return func","def add_plugin(self, cls):\r\n command = cls.__module__.split('.')[-1]\r\n if command not in self.plugins:\r\n self.plugins[command] = {}\r\n self.plugins[command][cls.action] = cls","def XPShowWidget(inWidget):\n pass","def register(name, templating=True):\n if name in _plugins:\n return\n import template\n _plugins.append(name)\n\n if templating:\n path = os.path.normpath(os.path.join(\n os.path.dirname(monkey.__file__),\n '../plugins/%s/templates' % name))\n template.add_template_path(path)\n template.add_template_path(path, prefix=name)","def launch(self):","def register(self, klass):\n if klass not in self.extensions:\n self.extensions.append(klass)","def main():\n parser = ap.ArgumentParser()\n parser.add_argument(\n 'plugins_file',\n type=ap.FileType(),\n help='file holding paths to plugins on GitHub'\n )\n args = parser.parse_args()\n contents = args.plugins_file.read()\n raw_path_list = contents.split('\\n')\n path_list = (pl.Path(raw_path) for raw_path in raw_path_list)\n customizer = VimCustomizer(path_list)\n customizer.configure()","def initGui(self):\n\n icon_path = ':/plugins/Hybriddekning/icon.png'\n self.add_action(\n icon_path,\n text=self.tr(u'Hybriddekning'),\n callback=self.run,\n parent=self.iface.mainWindow())","def __init__(self, ui):\n super(WakaTimePlugin, self).__init__(ui)\n self._ui = ui\n\n try:\n e5App().registerPluginObject(pluginTypename, self)\n except KeyError:\n pass # ignore duplicate registration","def register():\n PLUGINS = dict()\n def decorator(func):\n @functools.wraps(func)\n def wrapper(self, *args, **kwargs):\n value = func(*args, **kwargs)\n PLUGINS[func.__name__] = func\n return value\n return wrapper\n return decorator","def init():\n # vs_reset(None)\n global controllers\n # create global valuaspace controller for ipython\n g.visit_tree_item.add(colorize_headlines_visitor)\n g.registerHandler('after-create-leo-frame', onCreate)\n g.plugin_signon(__name__)\n return True","def _ipython_display_(self):\n with self._sc:\n self._box._ipython_display_()","def registrar(self):\r\n self.hide()\r\n self.ventana_registrar = VentanaRegistrar()\r\n self.ventana_registrar.show()","def ConfigGui(ss):\n width = 1600\n height = 1200\n\n gi.SetAppName(\"pat_assoc\")\n gi.SetAppAbout('illustrates how error-driven and hebbian learning can operate within a simple task-driven learning context, with no hidden layers. See <a href=\"https://github.com/CompCogNeuro/sims/blob/master/ch4/pat_assoc/README.md\">README.md on GitHub</a>.</p>')\n\n win = gi.NewMainWindow(\"pat_assoc\", \"Pattern Associator\", width, height)\n ss.Win = win\n\n vp = win.WinViewport2D()\n ss.vp = vp\n updt = vp.UpdateStart()\n\n mfr = win.SetMainFrame()\n\n tbar = gi.AddNewToolBar(mfr, \"tbar\")\n tbar.SetStretchMaxWidth()\n ss.ToolBar = tbar\n\n split = gi.AddNewSplitView(mfr, \"split\")\n split.Dim = mat32.X\n split.SetStretchMax()\n\n cv = ss.NewClassView(\"sv\")\n cv.AddFrame(split)\n cv.Config()\n\n tv = gi.AddNewTabView(split, \"tv\")\n\n nv = netview.NetView()\n tv.AddTab(nv, \"NetView\")\n nv.Var = \"Act\"\n nv.SetNet(ss.Net)\n ss.NetView = nv\n ss.ConfigNetView(nv)\n\n plt = eplot.Plot2D()\n tv.AddTab(plt, \"TrnEpcPlot\")\n ss.TrnEpcPlot = ss.ConfigTrnEpcPlot(plt, ss.TrnEpcLog)\n\n plt = eplot.Plot2D()\n tv.AddTab(plt, \"TstTrlPlot\")\n ss.TstTrlPlot = ss.ConfigTstTrlPlot(plt, ss.TstTrlLog)\n\n plt = eplot.Plot2D()\n tv.AddTab(plt, \"TstEpcPlot\")\n ss.TstEpcPlot = ss.ConfigTstEpcPlot(plt, ss.TstEpcLog)\n\n plt = eplot.Plot2D()\n tv.AddTab(plt, \"RunPlot\")\n ss.RunPlot = ss.ConfigRunPlot(plt, ss.RunLog)\n\n split.SetSplitsList(go.Slice_float32([.2, .8]))\n\n recv = win.This()\n \n tbar.AddAction(gi.ActOpts(Label=\"Init\", Icon=\"update\", Tooltip=\"Initialize everything including network weights, and start over. Also applies current params.\", UpdateFunc=UpdtFuncNotRunning), recv, InitCB)\n\n tbar.AddAction(gi.ActOpts(Label=\"Train\", Icon=\"run\", Tooltip=\"Starts the network training, picking up from wherever it may have left off. If not stopped, training will complete the specified number of Runs through the full number of Epochs of training, with testing automatically occuring at the specified interval.\", UpdateFunc=UpdtFuncNotRunning), recv, TrainCB)\n \n tbar.AddAction(gi.ActOpts(Label=\"Stop\", Icon=\"stop\", Tooltip=\"Interrupts running. Hitting Train again will pick back up where it left off.\", UpdateFunc=UpdtFuncRunning), recv, StopCB)\n \n tbar.AddAction(gi.ActOpts(Label=\"Step Trial\", Icon=\"step-fwd\", Tooltip=\"Advances one training trial at a time.\", UpdateFunc=UpdtFuncNotRunning), recv, StepTrialCB)\n \n tbar.AddAction(gi.ActOpts(Label=\"Step Epoch\", Icon=\"fast-fwd\", Tooltip=\"Advances one epoch (complete set of training patterns) at a time.\", UpdateFunc=UpdtFuncNotRunning), recv, StepEpochCB)\n\n tbar.AddAction(gi.ActOpts(Label=\"Step Run\", Icon=\"fast-fwd\", Tooltip=\"Advances one full training Run at a time.\", UpdateFunc=UpdtFuncNotRunning), recv, StepRunCB)\n \n tbar.AddSeparator(\"test\")\n \n tbar.AddAction(gi.ActOpts(Label=\"Test Trial\", Icon=\"step-fwd\", Tooltip=\"Runs the next testing trial.\", UpdateFunc=UpdtFuncNotRunning), recv, TestTrialCB)\n \n tbar.AddAction(gi.ActOpts(Label=\"Test Item\", Icon=\"step-fwd\", Tooltip=\"Prompts for a specific input pattern name to run, and runs it in testing mode.\", UpdateFunc=UpdtFuncNotRunning), recv, TestItemCB)\n \n tbar.AddAction(gi.ActOpts(Label=\"Test All\", Icon=\"fast-fwd\", Tooltip=\"Tests all of the testing trials.\", UpdateFunc=UpdtFuncNotRunning), recv, TestAllCB)\n\n tbar.AddSeparator(\"log\")\n \n tbar.AddAction(gi.ActOpts(Label=\"Reset RunLog\", Icon=\"reset\", Tooltip=\"Resets the accumulated log of all Runs, which are tagged with the ParamSet used\"), recv, ResetRunLogCB)\n\n tbar.AddSeparator(\"misc\")\n \n tbar.AddAction(gi.ActOpts(Label=\"New Seed\", Icon=\"new\", Tooltip=\"Generate a new initial random seed to get different results. By default, Init re-establishes the same initial seed every time.\"), recv, NewRndSeedCB)\n\n tbar.AddAction(gi.ActOpts(Label=\"README\", Icon=\"file-markdown\", Tooltip=\"Opens your browser on the README file that contains instructions for how to run this model.\"), recv, ReadmeCB)\n \n # main menu\n appnm = gi.AppName()\n mmen = win.MainMenu\n mmen.ConfigMenus(go.Slice_string([appnm, \"File\", \"Edit\", \"Window\"]))\n\n amen = gi.Action(win.MainMenu.ChildByName(appnm, 0))\n amen.Menu.AddAppMenu(win)\n\n emen = gi.Action(win.MainMenu.ChildByName(\"Edit\", 1))\n emen.Menu.AddCopyCutPaste(win)\n\n win.MainMenuUpdated()\n vp.UpdateEndNoSig(updt)\n win.GoStartEventLoop()","def show(self,window):\n self.showFunctions(window)","def load_ipython_extension(ipython):\n ipython.register_magics(CallGraphMagics)","def __init__(\n self,\n label : str,\n debug : bool = False,\n **kw\n ):\n super().__init__('plugin', label=label, **kw)\n\n import os, pathlib, sys\n from meerschaum.utils.warnings import error, warn\n from meerschaum.config._paths import PLUGINS_RESOURCES_PATH\n if str(PLUGINS_RESOURCES_PATH.parent) not in sys.path:\n sys.path.append(str(PLUGINS_RESOURCES_PATH.parent))\n\n self.resource_path = None\n for _plugin in os.listdir(PLUGINS_RESOURCES_PATH):\n plugin = _plugin.replace('.py', '')\n if plugin == self.label:\n self.resource_path = pathlib.Path(os.path.join(PLUGINS_RESOURCES_PATH, plugin))\n break\n if not self.resource_path:\n error(f\"Plugin '{self.label}' cannot be found. Is it installed?\")\n\n self.fetch = None\n try:\n exec(f'from plugins.{self.label} import fetch; self.fetch = fetch')\n except Exception as e:\n pass\n\n self.sync = None\n try:\n exec(f'from plugins.{self.label} import sync; self.sync = sync')\n except Exception as e:\n pass\n\n if self.fetch is None and self.sync is None:\n error(f\"Could not import `fetch()` or `sync()` methods for plugin '{self.label}'\")","def help(self, plugin):\n plug = plugin_source.load_plugin(plugin)\n plug.help()","def register(self, what, obj):\n # print(\"Registering pattern\", name, pattern)\n name = obj.name\n version = obj.version\n enable = obj.enable\n if enable == 'n':\n return\n\n key = Key(name, version)\n self.plugins[what][key] = obj","def show(self, window):\r\n\r\n return","def load_ipython_extension(ip):\n # this modifies ip\n SageCustomizations(shell=ip)","def plugins_show(what=None, name=None, version=None, details=False):\n global pluginmgr\n return pluginmgr.show(what, name, version, details)","def load_plugin(self, namespace_plugin):\n if namespace_plugin not in self.plugins:\n print(\"Plugin {} apply failed\\n\".format(namespace_plugin))\n else:\n tmp = namespace_plugin.split(\":\")\n ns = tmp[0]\n pg = tmp[1]\n mgr = driver.DriverManager(\n namespace=ns, name=pg, invoke_on_load=True)\n self.analyzer = mgr.driver\n self.current_analyzer = namespace_plugin\n self.djs_core.pic_save_pattern = self.analyzer.pic_save_pattern\n print(\"Plugin {} apply done.\\n\".format(namespace_plugin))","def main():\n\n log.init_logger()\n logger = logging.getLogger('main')\n\n logger.info(PySide.__version__)\n logger.info(PySide.QtCore.__version__)\n\n qt_app = QtGui.QApplication(sys.argv)\n\n dyninspector = DynInspector()\n\n window = gui.MainWindow(dyninspector)\n window.run()\n\n sys.exit(qt_app.exec_())","def show():\n setup()\n plt.show()","def add_plugin(self, plugin, callables, jobs, shutdowns, urls) -> None:\n self._plugins[plugin.name] = plugin\n self.register_callables(callables)\n self.register_jobs(jobs)\n self.register_shutdowns(shutdowns)\n self.register_urls(urls)","def init_app(self):\n \n tk_multi_depedencies = self.import_module(\"tk_multi_depedencies\")\n \n # register commands:\n display_name = self.get_setting(\"display_name\")\n \n # \"Publish Render\" ---> publish_render\n command_name = display_name.lower().replace(\" \", \"_\")\n if command_name.endswith(\"...\"):\n command_name = command_name[:-3]\n params = {\"short_name\": command_name, \n \"title\": \"%s...\" % display_name,\n \"description\": \"Publishing dependencies into Shotgun\"}\n\n show_dialog_callback = lambda: self.engine.show_dialog(display_name, self, tk_multi_depedencies.Dialog, self)\n \n self.log_debug(\"Registering command for tk-multi-dependencies\")\n self.engine.register_command(\"%s...\" % display_name, \n show_dialog_callback, \n params)","def embed_matplotlib(self):","def show_synth_editor(self, sid):\n pass","def add_plugin_files(self, plugin_name, *args, nb_path=None, **kwargs):\n nb_path = self._resolve_nb_path(nb_path)\n if plugin_name in self._plugin_collections:\n pc = self._plugin_collections[plugin_name]\n else:\n pc = PluginCollection([plugin_name], nb_path, {})\n self._plugin_collections[plugin_name] = pc\n addl_files = pc.run(\"notebook_export\", *args, **kwargs)[0]\n if addl_files is None:\n return\n self._addl_files.extend(addl_files)","def run(self):\n \n # IF SOMETHING SHALL BE MODIFIED BY USER THIS MUST BE HERE\n \n if self.pluginIsActive:\n self.onClosePlugin(True)\n else:\n self.pluginIsActive = True\n\n ImajnetLog.info(\"** STARTING QGisImajnetPlugin\")\n\n\n # Create the dockwidget (after translation) and keep reference\n self.dockwidget = QGisImajnetPluginDockWidget(self.iface, self)\n \n #enable the map tool\n self.imajnetMapTool = ImajnetMapTool(self)\n self.imajnetMapTool.setClickMode(False)\n \n # connect to provide cleanup on closing of dockwidget\n self.dockwidget.closingPlugin.connect(self.onClosePlugin)\n\n # show the dockwidget\n # TODO: fix to allow choice of dock location\n self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dockwidget)\n self.dockwidget.show()\n self._debugModeAction.setEnabled(True)\n \n if QGisImajnetPlugin.autoInitDebugWindow == True:\n self.showOrHideDebugWindow()","def setup(self):\n self.ui.setup_window()","def onWorkbench():\n workbench = Gui.activeWorkbench().__class__.__name__\n\n if layout:\n while not layout.isEmpty():\n item = layout.takeAt(0)\n del item\n\n buttons = cpcmd.workbenchButtons(workbench)\n\n if p.GetString(\"Layout\") == \"Grid\":\n columns = p.GetInt(\"ColumnNumber\", 1) - 1\n x = 0\n y = 0\n for btn in buttons:\n if y > columns:\n y = 0\n x += 1\n layout.addWidget(btn, x, y)\n y += 1\n else:\n for btn in buttons:\n layout.addWidget(btn)","def main():\n app = guisupport.get_app_qt4()\n\n if INPROCESS:\n from qtconsole.inprocess import QtInProcessKernelManager\n km = QtInProcessKernelManager()\n else:\n from qtconsole.manager import QtKernelManager\n km = QtKernelManager()\n km.start_kernel()\n km.kernel.gui = 'qt4'\n kc = km.client()\n kc.start_channels()\n\n widget = RichJupyterWidget()\n widget.kernel_manager = km\n widget.kernel_client = kc\n if CLEANSHUTDOWN: # slow exit on CTRL+D\n def stop():\n kc.stop_channels()\n km.shutdown_kernel()\n app.exit()\n widget.exit_requested.connect(stop)\n else: # fast exit on CTRL+D\n widget.exit_requested.connect(app.quit)\n widget.show()\n guisupport.start_event_loop_qt4(app)","def test_register_dynamic_plugin1(self):\n pass","def load_ipython_extension(shell=None):\n if shell is None:\n shell = get_ipython()\n if shell is None:\n return\n shell.register_magics(PrettyColorfulInspector)\n shell.register_magic_function(PrettyColorfulInspector.inspect_obj)\n shell.register_magic_function(PrettyColorfulInspector.ins)","def load_ipython_extension(ip):\n ip.register_magics(VentureMagics)\n if found_venture_ripl==1: \n print 'loaded VentureMagics with ripl \"ipy_ripl\"'","def addon(self, addon):\n\n self._addon = addon","def register_adhocs(self):\n aboutform = self.plugin['xep_0004'].makeForm('form', \"About SleekBot\")\n aboutform.addField('about', 'fixed', value= self.__doc__)\n self.plugin['xep_0050'].addCommand('about', 'About Sleekbot', aboutform)\n pluginform = self.plugin['xep_0004'].makeForm('form', 'Plugins')\n plugins = pluginform.addField('plugin', 'list-single', 'Plugins')\n for key in self.cmd_plugins:\n plugins.addOption(key, key)\n plugins = pluginform.addField('option', 'list-single', 'Commands')\n plugins.addOption('about', 'About')\n #plugins.addOption('config', 'Configure')\n self.plugin['xep_0050'].addCommand('plugins', 'Plugins', pluginform, self.form_plugin_command, True)","def widgets(overwrite=True):\n install_nbextension(os.path.join(PKGPATH, 'static'),\n destination='molviz',\n overwrite=overwrite)","def setup(self, registry):\n logger.info(\"%s %s\", self.dist_name, self.version)\n\n from .frontend import AutoplayFrontend\n registry.add(\"frontend\", AutoplayFrontend)","def nameToPlug(name):\n\n pass","def init_app(app):\n app.load_extension(__name__)","def init_extensions(self, package, module):\n\n pass","def main():\n import sys\n apps = QtWidgets.QApplication(sys.argv)\n window = ControllerMainApps()\n window.show()\n sys.exit(apps.exec_())","def init_app(self):\n\n self.setAttribute(PyQt5.QtCore.Qt.WA_DeleteOnClose)\n self.setGeometry(300, 300, 500, 550)\n self.setWindowTitle(\"DICOM Viewer\")","def main():\n PanelDemo().mainloop()","def request_plugins(self):","def setup(bot: Red):\n bot.add_cog(Welcome(bot))"],"string":"[\n \"def register_plugin(self):\\n self.create_toggle_view_action()\\n\\n self.main.add_dockwidget(self)\",\n \"def test_addplugin(self):\\n app = QApplication(sys.argv)\\n data = (np.random.rand(30, 31, 32) * 100).astype(np.int)\\n data[15:40, 13:20, 10:18] += 50\\n se = seededitorqt.QTSeedEditor(data)\\n wg0 = seededitorqt.plugin.SampleThresholdPlugin()\\n se.addPlugin(wg0)\\n # se.exec_()\\n # self.assertTrue(False)\",\n \"def plugh():\",\n \"def on_first_registration(self):\\n self.main.tabify_plugins(self.main.help, self)\\n self.dockwidget.hide()\",\n \"def register():\\n \\n global _registered\\n if not _registered:\\n _registered = True\\n sys.path_hooks.insert(0, VFSImporter)\",\n \"def plugins():\\n pass\",\n \"def pyang_plugin_init():\\n plugin.register_plugin(OpenConfigPlugin())\",\n \"def plugin_register(api):\\n api.range_tool_register('Example/01', MyPlugin)\\n return True\",\n \"def get_plugin(self, name):\",\n \"def run_plugin(self, plugin_name, *args, nb_path=None, **kwargs):\\n nb_path = self._resolve_nb_path(nb_path)\\n if plugin_name in self._plugin_collections:\\n pc = self._plugin_collections[plugin_name]\\n else:\\n pc = PluginCollection([plugin_name], nb_path, {})\\n self._plugin_collections[plugin_name] = pc\\n pc.run(\\\"from_notebook\\\", *args, **kwargs)\",\n \"def show():\\n from siding.addons import ui\\n ui.show()\",\n \"def test_show_editor(self):\\n app = QApplication(sys.argv)\\n data = (np.random.rand(30, 31, 32) * 100).astype(np.int)\\n data[15:40, 13:20, 10:18] += 50\\n se = seededitorqt.QTSeedEditor(data)\\n wg0 = seededitorqt.plugin.SampleThresholdPlugin()\\n wg1 = seededitorqt.plugin.SampleThresholdPlugin()\\n se.addPlugin(wg0)\\n se.addPlugin(wg1)\\n se.exec_()\\n # self.assertTrue(False)\",\n \"def register() -> None:\\n plot_backend = _get_plot_backend(\\\"matplotlib\\\")\\n plot_backend.register()\",\n \"def connect(self, plug):\",\n \"def register(check_environ=False):\\n from mundi.loader import register\\n from mundi.types.region import REGION_PLUGINS\\n\\n if check_environ:\\n import os\\n\\n if os.environ.get(\\\"MUNDI_DEMOGRAPHY\\\", \\\"on\\\").lower() in (\\\"off\\\", \\\"false\\\", \\\"no\\\"):\\n return\\n\\n for k, v in FUNCTIONS.items():\\n register(k, v)\\n\\n REGION_PLUGINS[\\\"population\\\"] = lambda x: population(x.id)\\n REGION_PLUGINS[\\\"age_distribution\\\"] = lambda x: age_distribution(x.id)\\n REGION_PLUGINS[\\\"age_pyramid\\\"] = lambda x: age_pyramid(x.id)\",\n \"def core_plugin(self):\\n pass\",\n \"def __init__(self):\\n\\n self.plugin_name = 'Yum'\",\n \"def get_plugin_interface(self):\",\n \"def register():\\n # DeepOBS\\n deepobs.pytorch.testproblems.two_d_quadratic = two_d_quadratic\\n\\n # for CockpitPlotter\\n if \\\"scalar\\\" in deepobs.config.DATA_SET_NAMING.keys():\\n assert deepobs.config.DATA_SET_NAMING[\\\"scalar\\\"] == \\\"Scalar\\\"\\n else:\\n deepobs.config.DATA_SET_NAMING[\\\"scalar\\\"] = \\\"Scalar\\\"\\n\\n if \\\"deep\\\" in deepobs.config.TP_NAMING.keys():\\n assert deepobs.config.TP_NAMING[\\\"deep\\\"] == \\\"Deep\\\"\\n else:\\n deepobs.config.TP_NAMING[\\\"deep\\\"] = \\\"deep\\\"\\n\\n # BackOBS\\n backobs.utils.ALL += (two_d_quadratic,)\\n backobs.utils.REGRESSION += (two_d_quadratic,)\\n backobs.utils.SUPPORTED += (two_d_quadratic,)\\n backobs.integration.SUPPORTED += (two_d_quadratic,)\",\n \"def main():\\n PLUGIN_ENTRY().run(\\\"\\\")\",\n \"def init():\\n global PLUGIN_NAME\\n PLUGIN_NAME = inspect.currentframe().f_code.co_filename\",\n \"def _installed_apps_add(self):\\n config.add_plugin(self.module_path)\",\n \"def launch_new_instance():\\n import IPython\\n\\n IPython.Shell.start().mainloop()\",\n \"def run(self):\\n\\n self.window.run_command(\\\"show_panel\\\", {\\\"panel\\\": \\\"output.reg_replace\\\"})\",\n \"def startup():\\n menuhook.register(\\n \\\"quickpreview\\\",\\n \\\"howtos\\\",\\n quickpreview,\\n menu=[\\\"&Scripting\\\", \\\"Python3 Development\\\", \\\"How To\\\"],\\n text=\\\"Create a quick preview\\\",\\n tooltip=\\\"Create a quick preview\\\")\",\n \"def add_plugin(self, plugin):\\n\\n if not plugin:\\n return\\n\\n plugin_btn = PluginButton(project=self._project, plugin=plugin)\\n plugin_btn.clicked.connect(self.openPlugin.emit)\\n self._flow_layout.addWidget(plugin_btn)\",\n \"def register(name, value):\\n\\n return Plugins.register(name, value)\",\n \"def new_plugin(ctx, **defaults):\\n from .quickstart import plugin_quickstart\\n\\n project = ctx.get_project(silent=True)\\n plugin_quickstart(defaults, project=project)\",\n \"def test():\\r\\n from spyderlib.utils.qthelpers import qapplication\\r\\n app = qapplication()\\r\\n widget = BreakpointWidget(None)\\r\\n widget.show()\\r\\n sys.exit(app.exec_())\",\n \"def setup(bot):\\n bot.logger.debug(\\n 'Registering extension \\\"Quiz\\\"'\\n )\\n bot.add_cog(QuizCog(bot))\",\n \"def control_plugin(self):\\n pass\",\n \"def main():\\n\\tif mc.window( 'SetupOccUI', q = 1, ex = 1 ):\\n\\t\\tmc.deleteUI( 'SetupOccUI' )\\n\\tPyForm=SetupOccUI()\\n\\tPyForm.show()\",\n \"def load_ipython_extension(ipython):\\n ipython.register_magics(ConductoMagics)\",\n \"def register_plugin(self, plugin):\\n self.log.info(\\\"Registering plugin %s\\\", type(plugin).__name__)\\n self._register_commands(plugin)\\n plugin.on_load()\",\n \"def shell(state):\\n IPython.embed(colors=\\\"Neutral\\\", banner1=BANNER, user_ns={\\\"sdk\\\": state.sdk})\",\n \"def plugin_name(self):\",\n \"def pyang_plugin_init():\\n plugin.register_plugin(JNCPlugin())\",\n \"def test_register_dynamic_plugin(self):\\n pass\",\n \"def init():\\n if g.app.gui is None:\\n g.app.createQtGui(__file__)\\n ok = g.app.gui.guiName().startswith('qt')\\n if ok:\\n g.registerHandler('after-create-leo-frame', onCreate)\\n g.plugin_signon(__name__)\\n else:\\n g.es('nodewatch.py not loaded', color='red')\\n return ok\",\n \"def launch (transparent=False): \\n core.registerNew(resonance, str_to_bool(transparent))\",\n \"def pyang_plugin_init():\\n plugin.register_plugin(SwaggerPlugin())\",\n \"def refresh_plugin(self):\\n pass\",\n \"def plugin_loaded():\\n events.broadcast(\\\"plugin_loaded\\\")\",\n \"def OnStartup(cls, modName ):\\r\\n import sys\\r\\n targetMod = sys.modules[ modName ]\\r\\n cls.StartupVarsInjectToMod( targetMod )\\r\\n EasyIpyMagics.RegisterMagics()\\r\\n \\r\\n cls.RegisterPostExecute()\",\n \"def main():\\r\\n qApp = QtGui.QApplication(sys.argv)\\r\\n qApp.setApplicationName(\\\"Visualization Tool\\\")\\r\\n qApp.setOrganizationName(\\\"Marquette University Speechlab\\\")\\r\\n qApp.setWindowIcon(QtGui.QIcon(\\\":/vtIcon.ico\\\"))\\r\\n form = MainWindow()\\r\\n form.show()\\r\\n sys.exit(qApp.exec_())\",\n \"def initGui(self):\\n\\n self.action = QAction(QIcon(self.plugdir + '/icon.png'), 'MGB Water Balance', self.iface.mainWindow())\\n self.action.triggered.connect(self.run)\\n self.iface.addToolBarIcon(self.action)\\n self.iface.addPluginToMenu('&IPH - Plugins', self.action)\",\n \"def __macroLoad(self):\\n self.activeWindow().macroLoad()\",\n \"def set_up_workspace():\\n # Avoid Error #15: Initializing libiomp5.dylib, but found libiomp5.dylib already initialized.\\n # https://stackoverflow.com/questions/53014306/error-15-initializing-libiomp5-dylib-but-found-libiomp5-dylib-already-initial\\n os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'\\n\\n # Magic command for inline plotting\\n # %matplotlib inline\\n # %config InlineBackend.figure_format = 'retina'\",\n \"def load_ipython_extension(ipython):\\n _register_magics(ipython)\",\n \"def add_profile(workbench, profile_config, names):\\n p = workbench.get_plugin('exopy.instruments')\\n p._unbind_observers()\\n # Test observation of profiles folders\\n for n in names:\\n with open(os.path.join(p._profiles_folders[0], n + '.instr.ini'),\\n 'wb') as f:\\n profile_config.write(f)\\n p._refresh_profiles()\\n p._bind_observers()\",\n \"def load_plugin():\\n return HostTestPluginCopyMethod_Shell()\",\n \"def register(func):\\n plugins[func.__name__] = func\\n return func\",\n \"def add_plugin(self, cls):\\r\\n command = cls.__module__.split('.')[-1]\\r\\n if command not in self.plugins:\\r\\n self.plugins[command] = {}\\r\\n self.plugins[command][cls.action] = cls\",\n \"def XPShowWidget(inWidget):\\n pass\",\n \"def register(name, templating=True):\\n if name in _plugins:\\n return\\n import template\\n _plugins.append(name)\\n\\n if templating:\\n path = os.path.normpath(os.path.join(\\n os.path.dirname(monkey.__file__),\\n '../plugins/%s/templates' % name))\\n template.add_template_path(path)\\n template.add_template_path(path, prefix=name)\",\n \"def launch(self):\",\n \"def register(self, klass):\\n if klass not in self.extensions:\\n self.extensions.append(klass)\",\n \"def main():\\n parser = ap.ArgumentParser()\\n parser.add_argument(\\n 'plugins_file',\\n type=ap.FileType(),\\n help='file holding paths to plugins on GitHub'\\n )\\n args = parser.parse_args()\\n contents = args.plugins_file.read()\\n raw_path_list = contents.split('\\\\n')\\n path_list = (pl.Path(raw_path) for raw_path in raw_path_list)\\n customizer = VimCustomizer(path_list)\\n customizer.configure()\",\n \"def initGui(self):\\n\\n icon_path = ':/plugins/Hybriddekning/icon.png'\\n self.add_action(\\n icon_path,\\n text=self.tr(u'Hybriddekning'),\\n callback=self.run,\\n parent=self.iface.mainWindow())\",\n \"def __init__(self, ui):\\n super(WakaTimePlugin, self).__init__(ui)\\n self._ui = ui\\n\\n try:\\n e5App().registerPluginObject(pluginTypename, self)\\n except KeyError:\\n pass # ignore duplicate registration\",\n \"def register():\\n PLUGINS = dict()\\n def decorator(func):\\n @functools.wraps(func)\\n def wrapper(self, *args, **kwargs):\\n value = func(*args, **kwargs)\\n PLUGINS[func.__name__] = func\\n return value\\n return wrapper\\n return decorator\",\n \"def init():\\n # vs_reset(None)\\n global controllers\\n # create global valuaspace controller for ipython\\n g.visit_tree_item.add(colorize_headlines_visitor)\\n g.registerHandler('after-create-leo-frame', onCreate)\\n g.plugin_signon(__name__)\\n return True\",\n \"def _ipython_display_(self):\\n with self._sc:\\n self._box._ipython_display_()\",\n \"def registrar(self):\\r\\n self.hide()\\r\\n self.ventana_registrar = VentanaRegistrar()\\r\\n self.ventana_registrar.show()\",\n \"def ConfigGui(ss):\\n width = 1600\\n height = 1200\\n\\n gi.SetAppName(\\\"pat_assoc\\\")\\n gi.SetAppAbout('illustrates how error-driven and hebbian learning can operate within a simple task-driven learning context, with no hidden layers. See <a href=\\\"https://github.com/CompCogNeuro/sims/blob/master/ch4/pat_assoc/README.md\\\">README.md on GitHub</a>.</p>')\\n\\n win = gi.NewMainWindow(\\\"pat_assoc\\\", \\\"Pattern Associator\\\", width, height)\\n ss.Win = win\\n\\n vp = win.WinViewport2D()\\n ss.vp = vp\\n updt = vp.UpdateStart()\\n\\n mfr = win.SetMainFrame()\\n\\n tbar = gi.AddNewToolBar(mfr, \\\"tbar\\\")\\n tbar.SetStretchMaxWidth()\\n ss.ToolBar = tbar\\n\\n split = gi.AddNewSplitView(mfr, \\\"split\\\")\\n split.Dim = mat32.X\\n split.SetStretchMax()\\n\\n cv = ss.NewClassView(\\\"sv\\\")\\n cv.AddFrame(split)\\n cv.Config()\\n\\n tv = gi.AddNewTabView(split, \\\"tv\\\")\\n\\n nv = netview.NetView()\\n tv.AddTab(nv, \\\"NetView\\\")\\n nv.Var = \\\"Act\\\"\\n nv.SetNet(ss.Net)\\n ss.NetView = nv\\n ss.ConfigNetView(nv)\\n\\n plt = eplot.Plot2D()\\n tv.AddTab(plt, \\\"TrnEpcPlot\\\")\\n ss.TrnEpcPlot = ss.ConfigTrnEpcPlot(plt, ss.TrnEpcLog)\\n\\n plt = eplot.Plot2D()\\n tv.AddTab(plt, \\\"TstTrlPlot\\\")\\n ss.TstTrlPlot = ss.ConfigTstTrlPlot(plt, ss.TstTrlLog)\\n\\n plt = eplot.Plot2D()\\n tv.AddTab(plt, \\\"TstEpcPlot\\\")\\n ss.TstEpcPlot = ss.ConfigTstEpcPlot(plt, ss.TstEpcLog)\\n\\n plt = eplot.Plot2D()\\n tv.AddTab(plt, \\\"RunPlot\\\")\\n ss.RunPlot = ss.ConfigRunPlot(plt, ss.RunLog)\\n\\n split.SetSplitsList(go.Slice_float32([.2, .8]))\\n\\n recv = win.This()\\n \\n tbar.AddAction(gi.ActOpts(Label=\\\"Init\\\", Icon=\\\"update\\\", Tooltip=\\\"Initialize everything including network weights, and start over. Also applies current params.\\\", UpdateFunc=UpdtFuncNotRunning), recv, InitCB)\\n\\n tbar.AddAction(gi.ActOpts(Label=\\\"Train\\\", Icon=\\\"run\\\", Tooltip=\\\"Starts the network training, picking up from wherever it may have left off. If not stopped, training will complete the specified number of Runs through the full number of Epochs of training, with testing automatically occuring at the specified interval.\\\", UpdateFunc=UpdtFuncNotRunning), recv, TrainCB)\\n \\n tbar.AddAction(gi.ActOpts(Label=\\\"Stop\\\", Icon=\\\"stop\\\", Tooltip=\\\"Interrupts running. Hitting Train again will pick back up where it left off.\\\", UpdateFunc=UpdtFuncRunning), recv, StopCB)\\n \\n tbar.AddAction(gi.ActOpts(Label=\\\"Step Trial\\\", Icon=\\\"step-fwd\\\", Tooltip=\\\"Advances one training trial at a time.\\\", UpdateFunc=UpdtFuncNotRunning), recv, StepTrialCB)\\n \\n tbar.AddAction(gi.ActOpts(Label=\\\"Step Epoch\\\", Icon=\\\"fast-fwd\\\", Tooltip=\\\"Advances one epoch (complete set of training patterns) at a time.\\\", UpdateFunc=UpdtFuncNotRunning), recv, StepEpochCB)\\n\\n tbar.AddAction(gi.ActOpts(Label=\\\"Step Run\\\", Icon=\\\"fast-fwd\\\", Tooltip=\\\"Advances one full training Run at a time.\\\", UpdateFunc=UpdtFuncNotRunning), recv, StepRunCB)\\n \\n tbar.AddSeparator(\\\"test\\\")\\n \\n tbar.AddAction(gi.ActOpts(Label=\\\"Test Trial\\\", Icon=\\\"step-fwd\\\", Tooltip=\\\"Runs the next testing trial.\\\", UpdateFunc=UpdtFuncNotRunning), recv, TestTrialCB)\\n \\n tbar.AddAction(gi.ActOpts(Label=\\\"Test Item\\\", Icon=\\\"step-fwd\\\", Tooltip=\\\"Prompts for a specific input pattern name to run, and runs it in testing mode.\\\", UpdateFunc=UpdtFuncNotRunning), recv, TestItemCB)\\n \\n tbar.AddAction(gi.ActOpts(Label=\\\"Test All\\\", Icon=\\\"fast-fwd\\\", Tooltip=\\\"Tests all of the testing trials.\\\", UpdateFunc=UpdtFuncNotRunning), recv, TestAllCB)\\n\\n tbar.AddSeparator(\\\"log\\\")\\n \\n tbar.AddAction(gi.ActOpts(Label=\\\"Reset RunLog\\\", Icon=\\\"reset\\\", Tooltip=\\\"Resets the accumulated log of all Runs, which are tagged with the ParamSet used\\\"), recv, ResetRunLogCB)\\n\\n tbar.AddSeparator(\\\"misc\\\")\\n \\n tbar.AddAction(gi.ActOpts(Label=\\\"New Seed\\\", Icon=\\\"new\\\", Tooltip=\\\"Generate a new initial random seed to get different results. By default, Init re-establishes the same initial seed every time.\\\"), recv, NewRndSeedCB)\\n\\n tbar.AddAction(gi.ActOpts(Label=\\\"README\\\", Icon=\\\"file-markdown\\\", Tooltip=\\\"Opens your browser on the README file that contains instructions for how to run this model.\\\"), recv, ReadmeCB)\\n \\n # main menu\\n appnm = gi.AppName()\\n mmen = win.MainMenu\\n mmen.ConfigMenus(go.Slice_string([appnm, \\\"File\\\", \\\"Edit\\\", \\\"Window\\\"]))\\n\\n amen = gi.Action(win.MainMenu.ChildByName(appnm, 0))\\n amen.Menu.AddAppMenu(win)\\n\\n emen = gi.Action(win.MainMenu.ChildByName(\\\"Edit\\\", 1))\\n emen.Menu.AddCopyCutPaste(win)\\n\\n win.MainMenuUpdated()\\n vp.UpdateEndNoSig(updt)\\n win.GoStartEventLoop()\",\n \"def show(self,window):\\n self.showFunctions(window)\",\n \"def load_ipython_extension(ipython):\\n ipython.register_magics(CallGraphMagics)\",\n \"def __init__(\\n self,\\n label : str,\\n debug : bool = False,\\n **kw\\n ):\\n super().__init__('plugin', label=label, **kw)\\n\\n import os, pathlib, sys\\n from meerschaum.utils.warnings import error, warn\\n from meerschaum.config._paths import PLUGINS_RESOURCES_PATH\\n if str(PLUGINS_RESOURCES_PATH.parent) not in sys.path:\\n sys.path.append(str(PLUGINS_RESOURCES_PATH.parent))\\n\\n self.resource_path = None\\n for _plugin in os.listdir(PLUGINS_RESOURCES_PATH):\\n plugin = _plugin.replace('.py', '')\\n if plugin == self.label:\\n self.resource_path = pathlib.Path(os.path.join(PLUGINS_RESOURCES_PATH, plugin))\\n break\\n if not self.resource_path:\\n error(f\\\"Plugin '{self.label}' cannot be found. Is it installed?\\\")\\n\\n self.fetch = None\\n try:\\n exec(f'from plugins.{self.label} import fetch; self.fetch = fetch')\\n except Exception as e:\\n pass\\n\\n self.sync = None\\n try:\\n exec(f'from plugins.{self.label} import sync; self.sync = sync')\\n except Exception as e:\\n pass\\n\\n if self.fetch is None and self.sync is None:\\n error(f\\\"Could not import `fetch()` or `sync()` methods for plugin '{self.label}'\\\")\",\n \"def help(self, plugin):\\n plug = plugin_source.load_plugin(plugin)\\n plug.help()\",\n \"def register(self, what, obj):\\n # print(\\\"Registering pattern\\\", name, pattern)\\n name = obj.name\\n version = obj.version\\n enable = obj.enable\\n if enable == 'n':\\n return\\n\\n key = Key(name, version)\\n self.plugins[what][key] = obj\",\n \"def show(self, window):\\r\\n\\r\\n return\",\n \"def load_ipython_extension(ip):\\n # this modifies ip\\n SageCustomizations(shell=ip)\",\n \"def plugins_show(what=None, name=None, version=None, details=False):\\n global pluginmgr\\n return pluginmgr.show(what, name, version, details)\",\n \"def load_plugin(self, namespace_plugin):\\n if namespace_plugin not in self.plugins:\\n print(\\\"Plugin {} apply failed\\\\n\\\".format(namespace_plugin))\\n else:\\n tmp = namespace_plugin.split(\\\":\\\")\\n ns = tmp[0]\\n pg = tmp[1]\\n mgr = driver.DriverManager(\\n namespace=ns, name=pg, invoke_on_load=True)\\n self.analyzer = mgr.driver\\n self.current_analyzer = namespace_plugin\\n self.djs_core.pic_save_pattern = self.analyzer.pic_save_pattern\\n print(\\\"Plugin {} apply done.\\\\n\\\".format(namespace_plugin))\",\n \"def main():\\n\\n log.init_logger()\\n logger = logging.getLogger('main')\\n\\n logger.info(PySide.__version__)\\n logger.info(PySide.QtCore.__version__)\\n\\n qt_app = QtGui.QApplication(sys.argv)\\n\\n dyninspector = DynInspector()\\n\\n window = gui.MainWindow(dyninspector)\\n window.run()\\n\\n sys.exit(qt_app.exec_())\",\n \"def show():\\n setup()\\n plt.show()\",\n \"def add_plugin(self, plugin, callables, jobs, shutdowns, urls) -> None:\\n self._plugins[plugin.name] = plugin\\n self.register_callables(callables)\\n self.register_jobs(jobs)\\n self.register_shutdowns(shutdowns)\\n self.register_urls(urls)\",\n \"def init_app(self):\\n \\n tk_multi_depedencies = self.import_module(\\\"tk_multi_depedencies\\\")\\n \\n # register commands:\\n display_name = self.get_setting(\\\"display_name\\\")\\n \\n # \\\"Publish Render\\\" ---> publish_render\\n command_name = display_name.lower().replace(\\\" \\\", \\\"_\\\")\\n if command_name.endswith(\\\"...\\\"):\\n command_name = command_name[:-3]\\n params = {\\\"short_name\\\": command_name, \\n \\\"title\\\": \\\"%s...\\\" % display_name,\\n \\\"description\\\": \\\"Publishing dependencies into Shotgun\\\"}\\n\\n show_dialog_callback = lambda: self.engine.show_dialog(display_name, self, tk_multi_depedencies.Dialog, self)\\n \\n self.log_debug(\\\"Registering command for tk-multi-dependencies\\\")\\n self.engine.register_command(\\\"%s...\\\" % display_name, \\n show_dialog_callback, \\n params)\",\n \"def embed_matplotlib(self):\",\n \"def show_synth_editor(self, sid):\\n pass\",\n \"def add_plugin_files(self, plugin_name, *args, nb_path=None, **kwargs):\\n nb_path = self._resolve_nb_path(nb_path)\\n if plugin_name in self._plugin_collections:\\n pc = self._plugin_collections[plugin_name]\\n else:\\n pc = PluginCollection([plugin_name], nb_path, {})\\n self._plugin_collections[plugin_name] = pc\\n addl_files = pc.run(\\\"notebook_export\\\", *args, **kwargs)[0]\\n if addl_files is None:\\n return\\n self._addl_files.extend(addl_files)\",\n \"def run(self):\\n \\n # IF SOMETHING SHALL BE MODIFIED BY USER THIS MUST BE HERE\\n \\n if self.pluginIsActive:\\n self.onClosePlugin(True)\\n else:\\n self.pluginIsActive = True\\n\\n ImajnetLog.info(\\\"** STARTING QGisImajnetPlugin\\\")\\n\\n\\n # Create the dockwidget (after translation) and keep reference\\n self.dockwidget = QGisImajnetPluginDockWidget(self.iface, self)\\n \\n #enable the map tool\\n self.imajnetMapTool = ImajnetMapTool(self)\\n self.imajnetMapTool.setClickMode(False)\\n \\n # connect to provide cleanup on closing of dockwidget\\n self.dockwidget.closingPlugin.connect(self.onClosePlugin)\\n\\n # show the dockwidget\\n # TODO: fix to allow choice of dock location\\n self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dockwidget)\\n self.dockwidget.show()\\n self._debugModeAction.setEnabled(True)\\n \\n if QGisImajnetPlugin.autoInitDebugWindow == True:\\n self.showOrHideDebugWindow()\",\n \"def setup(self):\\n self.ui.setup_window()\",\n \"def onWorkbench():\\n workbench = Gui.activeWorkbench().__class__.__name__\\n\\n if layout:\\n while not layout.isEmpty():\\n item = layout.takeAt(0)\\n del item\\n\\n buttons = cpcmd.workbenchButtons(workbench)\\n\\n if p.GetString(\\\"Layout\\\") == \\\"Grid\\\":\\n columns = p.GetInt(\\\"ColumnNumber\\\", 1) - 1\\n x = 0\\n y = 0\\n for btn in buttons:\\n if y > columns:\\n y = 0\\n x += 1\\n layout.addWidget(btn, x, y)\\n y += 1\\n else:\\n for btn in buttons:\\n layout.addWidget(btn)\",\n \"def main():\\n app = guisupport.get_app_qt4()\\n\\n if INPROCESS:\\n from qtconsole.inprocess import QtInProcessKernelManager\\n km = QtInProcessKernelManager()\\n else:\\n from qtconsole.manager import QtKernelManager\\n km = QtKernelManager()\\n km.start_kernel()\\n km.kernel.gui = 'qt4'\\n kc = km.client()\\n kc.start_channels()\\n\\n widget = RichJupyterWidget()\\n widget.kernel_manager = km\\n widget.kernel_client = kc\\n if CLEANSHUTDOWN: # slow exit on CTRL+D\\n def stop():\\n kc.stop_channels()\\n km.shutdown_kernel()\\n app.exit()\\n widget.exit_requested.connect(stop)\\n else: # fast exit on CTRL+D\\n widget.exit_requested.connect(app.quit)\\n widget.show()\\n guisupport.start_event_loop_qt4(app)\",\n \"def test_register_dynamic_plugin1(self):\\n pass\",\n \"def load_ipython_extension(shell=None):\\n if shell is None:\\n shell = get_ipython()\\n if shell is None:\\n return\\n shell.register_magics(PrettyColorfulInspector)\\n shell.register_magic_function(PrettyColorfulInspector.inspect_obj)\\n shell.register_magic_function(PrettyColorfulInspector.ins)\",\n \"def load_ipython_extension(ip):\\n ip.register_magics(VentureMagics)\\n if found_venture_ripl==1: \\n print 'loaded VentureMagics with ripl \\\"ipy_ripl\\\"'\",\n \"def addon(self, addon):\\n\\n self._addon = addon\",\n \"def register_adhocs(self):\\n aboutform = self.plugin['xep_0004'].makeForm('form', \\\"About SleekBot\\\")\\n aboutform.addField('about', 'fixed', value= self.__doc__)\\n self.plugin['xep_0050'].addCommand('about', 'About Sleekbot', aboutform)\\n pluginform = self.plugin['xep_0004'].makeForm('form', 'Plugins')\\n plugins = pluginform.addField('plugin', 'list-single', 'Plugins')\\n for key in self.cmd_plugins:\\n plugins.addOption(key, key)\\n plugins = pluginform.addField('option', 'list-single', 'Commands')\\n plugins.addOption('about', 'About')\\n #plugins.addOption('config', 'Configure')\\n self.plugin['xep_0050'].addCommand('plugins', 'Plugins', pluginform, self.form_plugin_command, True)\",\n \"def widgets(overwrite=True):\\n install_nbextension(os.path.join(PKGPATH, 'static'),\\n destination='molviz',\\n overwrite=overwrite)\",\n \"def setup(self, registry):\\n logger.info(\\\"%s %s\\\", self.dist_name, self.version)\\n\\n from .frontend import AutoplayFrontend\\n registry.add(\\\"frontend\\\", AutoplayFrontend)\",\n \"def nameToPlug(name):\\n\\n pass\",\n \"def init_app(app):\\n app.load_extension(__name__)\",\n \"def init_extensions(self, package, module):\\n\\n pass\",\n \"def main():\\n import sys\\n apps = QtWidgets.QApplication(sys.argv)\\n window = ControllerMainApps()\\n window.show()\\n sys.exit(apps.exec_())\",\n \"def init_app(self):\\n\\n self.setAttribute(PyQt5.QtCore.Qt.WA_DeleteOnClose)\\n self.setGeometry(300, 300, 500, 550)\\n self.setWindowTitle(\\\"DICOM Viewer\\\")\",\n \"def main():\\n PanelDemo().mainloop()\",\n \"def request_plugins(self):\",\n \"def setup(bot: Red):\\n bot.add_cog(Welcome(bot))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69762045","0.60747755","0.58828604","0.5874758","0.58635104","0.57819545","0.5741525","0.5716186","0.5689403","0.56821126","0.5669613","0.56537426","0.55752265","0.5545013","0.55267227","0.55135757","0.5477841","0.546501","0.5450378","0.54207486","0.53620833","0.5334271","0.53303087","0.53240544","0.5322914","0.53001785","0.5299282","0.5293697","0.5288459","0.5284721","0.52745914","0.5252284","0.521492","0.52038467","0.5200361","0.5184559","0.5176619","0.51678604","0.51653373","0.5155869","0.5141381","0.5141115","0.51299393","0.51204526","0.51083225","0.5102301","0.510036","0.5096815","0.5089978","0.5087491","0.50699705","0.50629556","0.5061628","0.5058687","0.504616","0.5042193","0.50412613","0.50335515","0.50303173","0.502117","0.5020017","0.50190204","0.5014142","0.5010984","0.5005248","0.49999174","0.4989905","0.49834344","0.4981213","0.4980172","0.49761757","0.49758872","0.49744785","0.49715215","0.495044","0.49358413","0.4934343","0.49337128","0.49256584","0.49217665","0.49188682","0.4917671","0.49123564","0.49064857","0.49024746","0.489958","0.48916334","0.48834723","0.48692596","0.4866626","0.48627114","0.48580492","0.48574308","0.48558345","0.4848447","0.4842582","0.48359218","0.4835257","0.4830349","0.48300073"],"string":"[\n \"0.69762045\",\n \"0.60747755\",\n \"0.58828604\",\n \"0.5874758\",\n \"0.58635104\",\n \"0.57819545\",\n \"0.5741525\",\n \"0.5716186\",\n \"0.5689403\",\n \"0.56821126\",\n \"0.5669613\",\n \"0.56537426\",\n \"0.55752265\",\n \"0.5545013\",\n \"0.55267227\",\n \"0.55135757\",\n \"0.5477841\",\n \"0.546501\",\n \"0.5450378\",\n \"0.54207486\",\n \"0.53620833\",\n \"0.5334271\",\n \"0.53303087\",\n \"0.53240544\",\n \"0.5322914\",\n \"0.53001785\",\n \"0.5299282\",\n \"0.5293697\",\n \"0.5288459\",\n \"0.5284721\",\n \"0.52745914\",\n \"0.5252284\",\n \"0.521492\",\n \"0.52038467\",\n \"0.5200361\",\n \"0.5184559\",\n \"0.5176619\",\n \"0.51678604\",\n \"0.51653373\",\n \"0.5155869\",\n \"0.5141381\",\n \"0.5141115\",\n \"0.51299393\",\n \"0.51204526\",\n \"0.51083225\",\n \"0.5102301\",\n \"0.510036\",\n \"0.5096815\",\n \"0.5089978\",\n \"0.5087491\",\n \"0.50699705\",\n \"0.50629556\",\n \"0.5061628\",\n \"0.5058687\",\n \"0.504616\",\n \"0.5042193\",\n \"0.50412613\",\n \"0.50335515\",\n \"0.50303173\",\n \"0.502117\",\n \"0.5020017\",\n \"0.50190204\",\n \"0.5014142\",\n \"0.5010984\",\n \"0.5005248\",\n \"0.49999174\",\n \"0.4989905\",\n \"0.49834344\",\n \"0.4981213\",\n \"0.4980172\",\n \"0.49761757\",\n \"0.49758872\",\n \"0.49744785\",\n \"0.49715215\",\n \"0.495044\",\n \"0.49358413\",\n \"0.4934343\",\n \"0.49337128\",\n \"0.49256584\",\n \"0.49217665\",\n \"0.49188682\",\n \"0.4917671\",\n \"0.49123564\",\n \"0.49064857\",\n \"0.49024746\",\n \"0.489958\",\n \"0.48916334\",\n \"0.48834723\",\n \"0.48692596\",\n \"0.4866626\",\n \"0.48627114\",\n \"0.48580492\",\n \"0.48574308\",\n \"0.48558345\",\n \"0.4848447\",\n \"0.4842582\",\n \"0.48359218\",\n \"0.4835257\",\n \"0.4830349\",\n \"0.48300073\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65753347"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":21981,"cells":{"query":{"kind":"string","value":"Refresh unit testing widget"},"document":{"kind":"string","value":"def refresh_plugin(self):\n pass"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def testRefresh(self):\n \n pass","def test_update(self):\n # this is tested graphically, as it is UI\n pass","def updateWidget(self):\n pass","def refresh(self):\n\t\tself.driver.refresh()","def test_visualisations_perform_visualisation_render_data_refresh_synchronously(self):\n pass","def test_empty_ui(self):","def test_visualisations_get_visualisation_render_data_refresh_job(self):\n pass","def testDirtyRefresh(self):\n \n pass","def onRefreshRepositoryRuns(self, data, projectid):\n self.runsDialog.initializeTests(listing=data )","def Refresh(self):\n pass","def refresh_screen(self):","def test_update_custom_button(self):\n pass","def _Refresh(self):\n raise NotImplementedError","def refresh(self):\n pass","def refresh(self):\n pass","def _refresh(self):\n self._need_display_update = True\n self._update()","def test_visualisations_create_visualisation_render_data_refresh_job(self):\n pass","def refresh(self) -> None:\n pass","def refresh(self) -> None:\n pass","def refresh(self) -> None:\n pass","def test_leaderboard_refresh(self):\n success = self.leaderboard.refresh()\n print(success)","def refresh_probe(self, widget, data=None):\n\t\tself.setup_monitor()","def refresh_view():\n pass","def refresh(self):\n self.Refresh()","def reload_and_trigger_output(self):\n self.browser.refresh()\n self.wait_for_js() # pylint: disable=no-member\n self.q(css='div#fixture button').first.click()","def test_update(self):\n pass","def test_update(self):\n pass","def test_update(self):\n pass","def refresh_dialog(self):\n self._client.update_elements()","def on_refresh(self):\n pass","def refresh(self):\n\n self.driver.implicitly_wait(5)\n self.driver.refresh()","def test_update(self):\n obj = self.provision_single_asset()\n test_string = \"testing this thing\"\n p = {'id': obj.id, 'description': test_string}\n self.put('widget', 200, params=p)\n self.session.refresh(obj)\n assert obj.description == test_string","def TestPeriodic(self):\n LiveWindow.Run()","def refresh(self):\n self._refresh_method()","def test_visualisations_cancel_visualisation_render_data_refresh_job(self):\n pass","def refresh(self):\n self.__refresh()","def _refresh_screen(self):\n self.myscreen.refresh()\n self.box1.refresh()\n self.box2.refresh()","def test_update_state(self):\n pass","def refresh(self):\n raise NotImplementedError","def refresh(self):\n raise NotImplementedError","def test_window_loaded(self):","def test_Analytics1(self):\n\n self.delayDisplay(\"We don't have a test\")","def init_widget(self):","def setUp(self):\n self.ui = UI()","def refresh_page(self):\n self.m_driver.refresh()\n time.sleep(30)","def test_dashboards_v2_update(self):\n pass","def refresh(self, view_manager):\n pass","def test_update_system(self):\n pass","def refresh(self):\n raise NotImplementedError(\"To be implemented\")","def refresh_view(self):\n # self.view_model.query_str = \"\"\n self.query_header.content.text = query_title_bar_text(self.shared_state)\n # self.view_model.update_results()\n self.layout.focus(self.query_window)","def test_update_connector(self):\n pass","def refresh(self) -> None:\n self.screen.refresh()","def test_update9(self):\n pass","def resetTestsCB(self):\n trace.into('ProctorGUI', 'resetTestsCB')\n self.tests = []\n self.result = None\n self.resetTestButtons()\n self.setState('idle')\n self.showTestOutput(None)\n self.updateProgress(0)\n trace.outof()\n return","def XeprGUIrefresh(self):\n with self._lock:\n self._API.XeprRefreshGUI()","def refresh(self):\n #self.find('counter-label').text = 'Counter: %i' % self.counter\n\n #@on('increment-button', 'click')\n #def on_button(self):\n \"\"\"\n This method is called every time a child element\n with ID 'increment-button' fires a 'click' event\n \"\"\"\n #self.counter += 1\n #self.refresh()","def test_update_composition(self):\n pass","def refresh(self):\n self.fetch(False)","def update_view(self): \n raise NotImplementedError(\"Widget descendents MUST implement the update_view() method!\")","def test_set_value(self):\n self.server_widget.value = 50\n assert self.client_widget.value == self.server_widget.value","def test_handle_refresh_changed(self):\n test_user = User(user)\n test_user.permissions_level = Permissions.admin\n team = Team(\"TeamID\", \"TeamName\", \"android\")\n team_update = Team(\"TeamID\", \"new team name\", \"android\")\n team_update.add_member(test_user.github_id)\n team2 = Team(\"OTEAM\", \"other team2\", \"ios\")\n\n self.db.retrieve.return_value = test_user\n self.db.query.return_value = [team, team2]\n self.gh.org_get_teams.return_value = [team_update, team2]\n attach = team_update.get_attachment()\n\n status = f\"1 teams changed, \" \\\n f\"0 added, \" \\\n f\"0 deleted. Wonderful.\"\n with self.app.app_context():\n resp, code = self.testcommand.handle(\"team refresh\", user)\n expect = {'attachments': [attach], 'text': status}\n self.assertDictEqual(resp, expect)\n self.assertEqual(code, 200)\n self.db.query.assert_called_once_with(Team)","def test_reload_parameter_starts_populateed(self, simulate_reload_one_day_main,\n caplog, qtbot):\n QtTest.QTest.qWaitForWindowShown(simulate_reload_one_day_main.form)\n qtbot.wait(3000)","def handle_reload_toolbox(self):","def setUp(self):\n self.display = StubDisplay()","def test_instr_view_display(instr_view):\n show_and_close_widget(instr_view)","def tearDown(self):\n reload(uc)","def runTest(self):\n changes = list()\n controller = EtcProposalsControllerStub()\n changes.append(EtcProposalsChangeStub())\n changes.append(EtcProposalsChangeStub())\n changes.append(EtcProposalsChangeStub())\n changesview = EtcProposalsChangesView(controller)\n changesview.update_changes(lambda: changes)\n changesview.show_all()\n self.testbox.pack_start(changesview, True, True, 1)\n gtk.main()\n self.failIf(self.Failed, 'Test failed.')","def test_update_activity(self):\n pass","def rescanTestsCB(self):\n trace.into('ProctorGUI', 'rescanTestsCB')\n if self.state == 'idle':\n self.busyStart()\n self._buildScanner()\n self._updateTestButtons()\n self.busyEnd()\n else:\n self.showError('Cannot rescan during a test run. Reset first.')\n trace.outof()\n return","def _updateTestButtons(self):\n trace.into('ProctorGUI', '_updateTestButtons')\n #\n # Remove any existing buttons\n #\n for name, button in self.test_buttons.items():\n button.delete()\n del self.test_buttons[name]\n self.update_idletasks()\n #\n # Make the new buttons\n #\n if self.scanner:\n module_tree = self.scanner.getModuleTree()\n self.test_buttons = {}\n self._createAllTestButtons(module_tree)\n trace.outof()\n return","def update(self):","def update(self):","def update(self):","def test_update_state2(self):\n pass","def runtest(self):","def test_ParameterWidget(self):\n\n instrument = setup_populated_instr_McStas()\n\n instrument.add_parameter(\"string\", \"choice\", options=[\"A\", \"B\", \"Long\"])\n\n parameters = {}\n # get default parameters from instrument\n for parameter in instrument.parameters:\n if parameter_has_default(parameter):\n parameters[parameter.name] = get_parameter_default(parameter)\n\n parameter_widgets = []\n parameterwidget_objects = []\n for parameter in instrument.parameters:\n par_widget = ParameterWidget(parameter, parameters)\n parameterwidget_objects.append(par_widget)\n parameter_widgets.append(par_widget.make_widget())\n\n self.assertEqual(parameterwidget_objects[0].name, \"theta\")\n self.assertEqual(parameterwidget_objects[0].default_value, None)\n # Parameter does not exist in parameter dict yet\n with self.assertRaises(KeyError):\n parameters[parameterwidget_objects[0].name]\n\n change = FakeChange(new=222)\n parameterwidget_objects[0].update(change)\n self.assertEqual(parameters[parameterwidget_objects[0].name], 222)\n\n self.assertEqual(parameterwidget_objects[1].name, \"has_default\")\n self.assertEqual(parameterwidget_objects[1].default_value, 37)\n self.assertEqual(parameters[parameterwidget_objects[1].name], 37)\n\n change = FakeChange(new=227)\n parameterwidget_objects[1].update(change)\n self.assertEqual(parameters[parameterwidget_objects[1].name], 227)\n\n self.assertEqual(parameterwidget_objects[2].name, \"choice\")\n self.assertEqual(parameterwidget_objects[2].default_value, None)\n with self.assertRaises(KeyError):\n parameters[parameterwidget_objects[2].name]\n\n change = FakeChange(new=\"test\")\n parameterwidget_objects[2].update(change) # Should add necessary extra quotation marks\n self.assertEqual(parameters[parameterwidget_objects[2].name], \"\\\"test\\\"\")","def test_update_state1(self):\n pass","def update(self):\r\n pass","def test_ProstateReporting1(self):\n\n self.delayDisplay(\"Starting the test\")\n\n self.delayDisplay('Test passed!')","def update(self):\n pass","def test_meeting_poll_update(self):\n pass","def test_update_scenario(self):\n pass","def __init__(self):\n self.data = {}\n self.refresh()","def test_connect(widget):\n ui = ConnectUI(opts={\"echo\": True})\n ui.setupUi(widget)\n ui.connector_input.setCurrentIndex(3)\n ui.host_input.setText(\"127.0.0.1\")\n ui.port_input.setValue(3307)\n ui.username_input.setText(\"ibcrg\")\n ui.password_input.setText(\"ibcrg\")\n ui.database_input.setText(\"ibcrg\")\n ui.connect_button.setFocus(Qt.OtherFocusReason)\n # continue with the engine added\n if len(sys.argv) > 2:\n if sys.argv[2] in TEST_CASES and sys.argv[2] != \"connect\":\n print(\"Next test cases will continue with the specified engine\")\n test_case = sys.argv[2]\n global AFTER_CONNECT_TEST\n\n def AFTER_CONNECT_TEST():\n global MEM\n widget = QWidget()\n res = test_edit(test_case, widget) if test_case != \"query\" \\\n else test_query(widget)\n widget.show()\n MEM += [widget, res]\n else:\n print(\"Invalid next test case\")\n print(\"Choose next test case from %s\" % str(TEST_CASES))\n print(\"(Except \\\"connect\\\")\")\n else:\n print(\"No more test cases will be performed\")\n return ui","def test_update_case(self):\n pass","def reload(self):","def reload(self):","def press_refresh(self):\n self.song_list.sort_songs(self.root.ids.spinner.text) #Sort_songs based on the text on the spinner\n self.create_entry_buttons() #Recreate the entry button whenever you click\n #Note & Comment : This Button supposes not to be included in the Gui layout and could be worked independently for each temp button and for the spinner , it does not undo the songs that have been learned.\n #Keeping button helps a more convenient way to show the result after pressing it .","def test_client_update(self):\n pass","def testHelp(self):\n self.widget.manager = QtWidgets.QWidget()\n self.widget.manager.showHelp = MagicMock()\n self.widget.displayHelp()\n self.assertTrue(self.widget.manager.showHelp.called_once())\n args = self.widget.manager.showHelp.call_args\n self.assertIn('sld_calculator_help.html', args[0][0])","def test_SegmentEditor1(self):\n self.delayDisplay(\"Starting the test\")\n self.delayDisplay('Test passed!')","def test_update_client(self):\n pass","def mock_dear_py_gui():\n def _gui_thread(self):\n while not self.stop:\n _ = self.process_data.get()\n\n BaseRealTimeVisualizer._gui_thread = _gui_thread\n BaseRealTimeVisualizer.should_close = lambda self: False","def update(self) -> None:\n ...","def refresh(self) :\n if not self.running:\n self.running = True\n self.strip.show()\n self.running = False\n self.refreshTimer.expired = True\n self.refreshTimer.isrunning = False","def driver_update_display(self):\n raise Exception(\"missing implementation \")","def Reload(self):\n self._inspector_backend.Navigate(self.url, None, 10)","def on_preview_refresh_activate(self,widget,data=None):\n self.app._update_preview()","def update(self):\n self.wc.update()","def dummy_update( self ):\r\n pass"],"string":"[\n \"def testRefresh(self):\\n \\n pass\",\n \"def test_update(self):\\n # this is tested graphically, as it is UI\\n pass\",\n \"def updateWidget(self):\\n pass\",\n \"def refresh(self):\\n\\t\\tself.driver.refresh()\",\n \"def test_visualisations_perform_visualisation_render_data_refresh_synchronously(self):\\n pass\",\n \"def test_empty_ui(self):\",\n \"def test_visualisations_get_visualisation_render_data_refresh_job(self):\\n pass\",\n \"def testDirtyRefresh(self):\\n \\n pass\",\n \"def onRefreshRepositoryRuns(self, data, projectid):\\n self.runsDialog.initializeTests(listing=data )\",\n \"def Refresh(self):\\n pass\",\n \"def refresh_screen(self):\",\n \"def test_update_custom_button(self):\\n pass\",\n \"def _Refresh(self):\\n raise NotImplementedError\",\n \"def refresh(self):\\n pass\",\n \"def refresh(self):\\n pass\",\n \"def _refresh(self):\\n self._need_display_update = True\\n self._update()\",\n \"def test_visualisations_create_visualisation_render_data_refresh_job(self):\\n pass\",\n \"def refresh(self) -> None:\\n pass\",\n \"def refresh(self) -> None:\\n pass\",\n \"def refresh(self) -> None:\\n pass\",\n \"def test_leaderboard_refresh(self):\\n success = self.leaderboard.refresh()\\n print(success)\",\n \"def refresh_probe(self, widget, data=None):\\n\\t\\tself.setup_monitor()\",\n \"def refresh_view():\\n pass\",\n \"def refresh(self):\\n self.Refresh()\",\n \"def reload_and_trigger_output(self):\\n self.browser.refresh()\\n self.wait_for_js() # pylint: disable=no-member\\n self.q(css='div#fixture button').first.click()\",\n \"def test_update(self):\\n pass\",\n \"def test_update(self):\\n pass\",\n \"def test_update(self):\\n pass\",\n \"def refresh_dialog(self):\\n self._client.update_elements()\",\n \"def on_refresh(self):\\n pass\",\n \"def refresh(self):\\n\\n self.driver.implicitly_wait(5)\\n self.driver.refresh()\",\n \"def test_update(self):\\n obj = self.provision_single_asset()\\n test_string = \\\"testing this thing\\\"\\n p = {'id': obj.id, 'description': test_string}\\n self.put('widget', 200, params=p)\\n self.session.refresh(obj)\\n assert obj.description == test_string\",\n \"def TestPeriodic(self):\\n LiveWindow.Run()\",\n \"def refresh(self):\\n self._refresh_method()\",\n \"def test_visualisations_cancel_visualisation_render_data_refresh_job(self):\\n pass\",\n \"def refresh(self):\\n self.__refresh()\",\n \"def _refresh_screen(self):\\n self.myscreen.refresh()\\n self.box1.refresh()\\n self.box2.refresh()\",\n \"def test_update_state(self):\\n pass\",\n \"def refresh(self):\\n raise NotImplementedError\",\n \"def refresh(self):\\n raise NotImplementedError\",\n \"def test_window_loaded(self):\",\n \"def test_Analytics1(self):\\n\\n self.delayDisplay(\\\"We don't have a test\\\")\",\n \"def init_widget(self):\",\n \"def setUp(self):\\n self.ui = UI()\",\n \"def refresh_page(self):\\n self.m_driver.refresh()\\n time.sleep(30)\",\n \"def test_dashboards_v2_update(self):\\n pass\",\n \"def refresh(self, view_manager):\\n pass\",\n \"def test_update_system(self):\\n pass\",\n \"def refresh(self):\\n raise NotImplementedError(\\\"To be implemented\\\")\",\n \"def refresh_view(self):\\n # self.view_model.query_str = \\\"\\\"\\n self.query_header.content.text = query_title_bar_text(self.shared_state)\\n # self.view_model.update_results()\\n self.layout.focus(self.query_window)\",\n \"def test_update_connector(self):\\n pass\",\n \"def refresh(self) -> None:\\n self.screen.refresh()\",\n \"def test_update9(self):\\n pass\",\n \"def resetTestsCB(self):\\n trace.into('ProctorGUI', 'resetTestsCB')\\n self.tests = []\\n self.result = None\\n self.resetTestButtons()\\n self.setState('idle')\\n self.showTestOutput(None)\\n self.updateProgress(0)\\n trace.outof()\\n return\",\n \"def XeprGUIrefresh(self):\\n with self._lock:\\n self._API.XeprRefreshGUI()\",\n \"def refresh(self):\\n #self.find('counter-label').text = 'Counter: %i' % self.counter\\n\\n #@on('increment-button', 'click')\\n #def on_button(self):\\n \\\"\\\"\\\"\\n This method is called every time a child element\\n with ID 'increment-button' fires a 'click' event\\n \\\"\\\"\\\"\\n #self.counter += 1\\n #self.refresh()\",\n \"def test_update_composition(self):\\n pass\",\n \"def refresh(self):\\n self.fetch(False)\",\n \"def update_view(self): \\n raise NotImplementedError(\\\"Widget descendents MUST implement the update_view() method!\\\")\",\n \"def test_set_value(self):\\n self.server_widget.value = 50\\n assert self.client_widget.value == self.server_widget.value\",\n \"def test_handle_refresh_changed(self):\\n test_user = User(user)\\n test_user.permissions_level = Permissions.admin\\n team = Team(\\\"TeamID\\\", \\\"TeamName\\\", \\\"android\\\")\\n team_update = Team(\\\"TeamID\\\", \\\"new team name\\\", \\\"android\\\")\\n team_update.add_member(test_user.github_id)\\n team2 = Team(\\\"OTEAM\\\", \\\"other team2\\\", \\\"ios\\\")\\n\\n self.db.retrieve.return_value = test_user\\n self.db.query.return_value = [team, team2]\\n self.gh.org_get_teams.return_value = [team_update, team2]\\n attach = team_update.get_attachment()\\n\\n status = f\\\"1 teams changed, \\\" \\\\\\n f\\\"0 added, \\\" \\\\\\n f\\\"0 deleted. Wonderful.\\\"\\n with self.app.app_context():\\n resp, code = self.testcommand.handle(\\\"team refresh\\\", user)\\n expect = {'attachments': [attach], 'text': status}\\n self.assertDictEqual(resp, expect)\\n self.assertEqual(code, 200)\\n self.db.query.assert_called_once_with(Team)\",\n \"def test_reload_parameter_starts_populateed(self, simulate_reload_one_day_main,\\n caplog, qtbot):\\n QtTest.QTest.qWaitForWindowShown(simulate_reload_one_day_main.form)\\n qtbot.wait(3000)\",\n \"def handle_reload_toolbox(self):\",\n \"def setUp(self):\\n self.display = StubDisplay()\",\n \"def test_instr_view_display(instr_view):\\n show_and_close_widget(instr_view)\",\n \"def tearDown(self):\\n reload(uc)\",\n \"def runTest(self):\\n changes = list()\\n controller = EtcProposalsControllerStub()\\n changes.append(EtcProposalsChangeStub())\\n changes.append(EtcProposalsChangeStub())\\n changes.append(EtcProposalsChangeStub())\\n changesview = EtcProposalsChangesView(controller)\\n changesview.update_changes(lambda: changes)\\n changesview.show_all()\\n self.testbox.pack_start(changesview, True, True, 1)\\n gtk.main()\\n self.failIf(self.Failed, 'Test failed.')\",\n \"def test_update_activity(self):\\n pass\",\n \"def rescanTestsCB(self):\\n trace.into('ProctorGUI', 'rescanTestsCB')\\n if self.state == 'idle':\\n self.busyStart()\\n self._buildScanner()\\n self._updateTestButtons()\\n self.busyEnd()\\n else:\\n self.showError('Cannot rescan during a test run. Reset first.')\\n trace.outof()\\n return\",\n \"def _updateTestButtons(self):\\n trace.into('ProctorGUI', '_updateTestButtons')\\n #\\n # Remove any existing buttons\\n #\\n for name, button in self.test_buttons.items():\\n button.delete()\\n del self.test_buttons[name]\\n self.update_idletasks()\\n #\\n # Make the new buttons\\n #\\n if self.scanner:\\n module_tree = self.scanner.getModuleTree()\\n self.test_buttons = {}\\n self._createAllTestButtons(module_tree)\\n trace.outof()\\n return\",\n \"def update(self):\",\n \"def update(self):\",\n \"def update(self):\",\n \"def test_update_state2(self):\\n pass\",\n \"def runtest(self):\",\n \"def test_ParameterWidget(self):\\n\\n instrument = setup_populated_instr_McStas()\\n\\n instrument.add_parameter(\\\"string\\\", \\\"choice\\\", options=[\\\"A\\\", \\\"B\\\", \\\"Long\\\"])\\n\\n parameters = {}\\n # get default parameters from instrument\\n for parameter in instrument.parameters:\\n if parameter_has_default(parameter):\\n parameters[parameter.name] = get_parameter_default(parameter)\\n\\n parameter_widgets = []\\n parameterwidget_objects = []\\n for parameter in instrument.parameters:\\n par_widget = ParameterWidget(parameter, parameters)\\n parameterwidget_objects.append(par_widget)\\n parameter_widgets.append(par_widget.make_widget())\\n\\n self.assertEqual(parameterwidget_objects[0].name, \\\"theta\\\")\\n self.assertEqual(parameterwidget_objects[0].default_value, None)\\n # Parameter does not exist in parameter dict yet\\n with self.assertRaises(KeyError):\\n parameters[parameterwidget_objects[0].name]\\n\\n change = FakeChange(new=222)\\n parameterwidget_objects[0].update(change)\\n self.assertEqual(parameters[parameterwidget_objects[0].name], 222)\\n\\n self.assertEqual(parameterwidget_objects[1].name, \\\"has_default\\\")\\n self.assertEqual(parameterwidget_objects[1].default_value, 37)\\n self.assertEqual(parameters[parameterwidget_objects[1].name], 37)\\n\\n change = FakeChange(new=227)\\n parameterwidget_objects[1].update(change)\\n self.assertEqual(parameters[parameterwidget_objects[1].name], 227)\\n\\n self.assertEqual(parameterwidget_objects[2].name, \\\"choice\\\")\\n self.assertEqual(parameterwidget_objects[2].default_value, None)\\n with self.assertRaises(KeyError):\\n parameters[parameterwidget_objects[2].name]\\n\\n change = FakeChange(new=\\\"test\\\")\\n parameterwidget_objects[2].update(change) # Should add necessary extra quotation marks\\n self.assertEqual(parameters[parameterwidget_objects[2].name], \\\"\\\\\\\"test\\\\\\\"\\\")\",\n \"def test_update_state1(self):\\n pass\",\n \"def update(self):\\r\\n pass\",\n \"def test_ProstateReporting1(self):\\n\\n self.delayDisplay(\\\"Starting the test\\\")\\n\\n self.delayDisplay('Test passed!')\",\n \"def update(self):\\n pass\",\n \"def test_meeting_poll_update(self):\\n pass\",\n \"def test_update_scenario(self):\\n pass\",\n \"def __init__(self):\\n self.data = {}\\n self.refresh()\",\n \"def test_connect(widget):\\n ui = ConnectUI(opts={\\\"echo\\\": True})\\n ui.setupUi(widget)\\n ui.connector_input.setCurrentIndex(3)\\n ui.host_input.setText(\\\"127.0.0.1\\\")\\n ui.port_input.setValue(3307)\\n ui.username_input.setText(\\\"ibcrg\\\")\\n ui.password_input.setText(\\\"ibcrg\\\")\\n ui.database_input.setText(\\\"ibcrg\\\")\\n ui.connect_button.setFocus(Qt.OtherFocusReason)\\n # continue with the engine added\\n if len(sys.argv) > 2:\\n if sys.argv[2] in TEST_CASES and sys.argv[2] != \\\"connect\\\":\\n print(\\\"Next test cases will continue with the specified engine\\\")\\n test_case = sys.argv[2]\\n global AFTER_CONNECT_TEST\\n\\n def AFTER_CONNECT_TEST():\\n global MEM\\n widget = QWidget()\\n res = test_edit(test_case, widget) if test_case != \\\"query\\\" \\\\\\n else test_query(widget)\\n widget.show()\\n MEM += [widget, res]\\n else:\\n print(\\\"Invalid next test case\\\")\\n print(\\\"Choose next test case from %s\\\" % str(TEST_CASES))\\n print(\\\"(Except \\\\\\\"connect\\\\\\\")\\\")\\n else:\\n print(\\\"No more test cases will be performed\\\")\\n return ui\",\n \"def test_update_case(self):\\n pass\",\n \"def reload(self):\",\n \"def reload(self):\",\n \"def press_refresh(self):\\n self.song_list.sort_songs(self.root.ids.spinner.text) #Sort_songs based on the text on the spinner\\n self.create_entry_buttons() #Recreate the entry button whenever you click\\n #Note & Comment : This Button supposes not to be included in the Gui layout and could be worked independently for each temp button and for the spinner , it does not undo the songs that have been learned.\\n #Keeping button helps a more convenient way to show the result after pressing it .\",\n \"def test_client_update(self):\\n pass\",\n \"def testHelp(self):\\n self.widget.manager = QtWidgets.QWidget()\\n self.widget.manager.showHelp = MagicMock()\\n self.widget.displayHelp()\\n self.assertTrue(self.widget.manager.showHelp.called_once())\\n args = self.widget.manager.showHelp.call_args\\n self.assertIn('sld_calculator_help.html', args[0][0])\",\n \"def test_SegmentEditor1(self):\\n self.delayDisplay(\\\"Starting the test\\\")\\n self.delayDisplay('Test passed!')\",\n \"def test_update_client(self):\\n pass\",\n \"def mock_dear_py_gui():\\n def _gui_thread(self):\\n while not self.stop:\\n _ = self.process_data.get()\\n\\n BaseRealTimeVisualizer._gui_thread = _gui_thread\\n BaseRealTimeVisualizer.should_close = lambda self: False\",\n \"def update(self) -> None:\\n ...\",\n \"def refresh(self) :\\n if not self.running:\\n self.running = True\\n self.strip.show()\\n self.running = False\\n self.refreshTimer.expired = True\\n self.refreshTimer.isrunning = False\",\n \"def driver_update_display(self):\\n raise Exception(\\\"missing implementation \\\")\",\n \"def Reload(self):\\n self._inspector_backend.Navigate(self.url, None, 10)\",\n \"def on_preview_refresh_activate(self,widget,data=None):\\n self.app._update_preview()\",\n \"def update(self):\\n self.wc.update()\",\n \"def dummy_update( self ):\\r\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77160954","0.6853362","0.6844457","0.6520042","0.64972293","0.6480656","0.6453007","0.64422596","0.6441096","0.64315104","0.64105207","0.640197","0.63611436","0.63520265","0.63520265","0.6331086","0.6330639","0.6268165","0.6268165","0.6268165","0.6226019","0.6144073","0.61096925","0.6109197","0.6064409","0.60538584","0.60538584","0.60538584","0.6020298","0.5997343","0.59756655","0.59397125","0.5924946","0.5912548","0.59038854","0.5900442","0.58974266","0.58923346","0.5876872","0.5876872","0.5868669","0.58010375","0.57979697","0.5779423","0.57791257","0.57704127","0.57574993","0.57519823","0.57304645","0.57047063","0.570367","0.5701801","0.5696667","0.56957775","0.5694485","0.56701684","0.56676406","0.56626534","0.5653962","0.5629025","0.56160957","0.56122625","0.5603387","0.55793786","0.5575051","0.55604917","0.5559466","0.5556083","0.5544899","0.5544124","0.55241716","0.55241716","0.55241716","0.5521112","0.55106366","0.55070007","0.55029136","0.5497711","0.54871255","0.5480895","0.54803807","0.5477933","0.5477033","0.5476957","0.54746336","0.54726183","0.54726183","0.54675174","0.5467105","0.54523677","0.54522294","0.54501086","0.5428839","0.54279137","0.5419366","0.5419199","0.5415124","0.5411682","0.54105103","0.54087985"],"string":"[\n \"0.77160954\",\n \"0.6853362\",\n \"0.6844457\",\n \"0.6520042\",\n \"0.64972293\",\n \"0.6480656\",\n \"0.6453007\",\n \"0.64422596\",\n \"0.6441096\",\n \"0.64315104\",\n \"0.64105207\",\n \"0.640197\",\n \"0.63611436\",\n \"0.63520265\",\n \"0.63520265\",\n \"0.6331086\",\n \"0.6330639\",\n \"0.6268165\",\n \"0.6268165\",\n \"0.6268165\",\n \"0.6226019\",\n \"0.6144073\",\n \"0.61096925\",\n \"0.6109197\",\n \"0.6064409\",\n \"0.60538584\",\n \"0.60538584\",\n \"0.60538584\",\n \"0.6020298\",\n \"0.5997343\",\n \"0.59756655\",\n \"0.59397125\",\n \"0.5924946\",\n \"0.5912548\",\n \"0.59038854\",\n \"0.5900442\",\n \"0.58974266\",\n \"0.58923346\",\n \"0.5876872\",\n \"0.5876872\",\n \"0.5868669\",\n \"0.58010375\",\n \"0.57979697\",\n \"0.5779423\",\n \"0.57791257\",\n \"0.57704127\",\n \"0.57574993\",\n \"0.57519823\",\n \"0.57304645\",\n \"0.57047063\",\n \"0.570367\",\n \"0.5701801\",\n \"0.5696667\",\n \"0.56957775\",\n \"0.5694485\",\n \"0.56701684\",\n \"0.56676406\",\n \"0.56626534\",\n \"0.5653962\",\n \"0.5629025\",\n \"0.56160957\",\n \"0.56122625\",\n \"0.5603387\",\n \"0.55793786\",\n \"0.5575051\",\n \"0.55604917\",\n \"0.5559466\",\n \"0.5556083\",\n \"0.5544899\",\n \"0.5544124\",\n \"0.55241716\",\n \"0.55241716\",\n \"0.55241716\",\n \"0.5521112\",\n \"0.55106366\",\n \"0.55070007\",\n \"0.55029136\",\n \"0.5497711\",\n \"0.54871255\",\n \"0.5480895\",\n \"0.54803807\",\n \"0.5477933\",\n \"0.5477033\",\n \"0.5476957\",\n \"0.54746336\",\n \"0.54726183\",\n \"0.54726183\",\n \"0.54675174\",\n \"0.5467105\",\n \"0.54523677\",\n \"0.54522294\",\n \"0.54501086\",\n \"0.5428839\",\n \"0.54279137\",\n \"0.5419366\",\n \"0.5419199\",\n \"0.5415124\",\n \"0.5411682\",\n \"0.54105103\",\n \"0.54087985\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5928176"},"document_rank":{"kind":"string","value":"32"}}},{"rowIdx":21982,"cells":{"query":{"kind":"string","value":"Perform actions before parent main window is closed"},"document":{"kind":"string","value":"def closing_plugin(self, cancelable=False):\n return True"},"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 __onclosing(self):\n self.window.destroy()","def __window_close(self):\n pass","def onCloseWindow(self, event):\r\n\r\n self.Destroy()","def close(self):\n self.parent.activate()","def close(self):\n self.state = False\n self.mainwindow.sendMessage('a')\n print(\"closing \" + self.name)","def OnClose(self, event):\r\n pos.app.main.Exit()","def exit(self):\n if self.window:\n self.window.close()","def _on_close(self):\n self.shell_obj.closed()","def close_UI(self):","def OnExit(self, event):\r\n self.Close(True)","def close_window(self):\n # Window - END\n self.root.destroy()","def _onExit(self, event):\n self.Close(True)","def closeEvent(self, event):\n aqt.mw.reset()\n super().closeEvent(event)","def cb_close(self, *args):\n Gtk.main_quit()","def ev_windowclose(self, event: WindowEvent) -> None:","def quit(self):\n\n self.main_window.destroy()","def OnClose(self, event):\n self._is_open = False\n wx.PostEvent(self, wxDockPaneClosedEvent())","def OnExit(self, event):\n self.Close(True)","def OnExit(self, event):\n self.Close(True)","def OnExit(self, event):\n self.Close(True)","def OnExit(self, event):\n self.Close(True)","def on_main_win_close(self):\n child_list = self.nb.winfo_children()\n for i in range(len(child_list)):\n index = self.nb.index('current')\n if self.get_current().edit_modified():\n ans = mb.askyesnocancel('Confirm on close', 'Do you want to save this file?')\n if ans:\n if self.save_file():\n self.tab_close(index, child_list)\n else:\n return\n elif ans is False:\n self.tab_close(index, child_list)\n else:\n return\n else:\n self.tab_close(index, child_list)\n self.main_window.destroy()","def closeEvent(self, event):\n print \"Window closed\"\n event.ignore()\n print \"Hide window.\"\n self.subWindow.hide()","def closeEvent(self, event):\n log.info(\"Received window close event.\")\n self.main.app_is_exiting()\n super().closeEvent(event)\n return","def force_close(self):\n\n\t\tself._window.force_close()","def OnClose(self, event):\n\t\tself.Show(False)","def close(self):\n self.window.destroy()\n self.buttons_window.destroy()","def close(event):\n event.widget.destroy()","def callback_destroy( self ):\r\n self.winRunning = False\r\n self.rootWin.destroy()\r\n exit()","def quit_click(self):\n\n self.parent.destroy()","def _close_window(self):\n render_window = self._iren.GetRenderWindow()\n render_window.Finalize()\n self._iren.TerminateApp()\n\n del render_window, self._iren, self._ren, self._renWin","def if_quit(self):\n answer = helper.quit_popup()\n if answer:\n self.parent.destroy()","def on_closing_event(self):\n self.exit_event(None)","def close_and_run(self, master, window):\r\n self.main_gui(master)\r\n window.destroy()","def close(self):\n\n\t\tself._window.close()","def onExitButtonClicked(self, widget):\n self.getGtkTopObject().close()","def callback_close(self, event=None):\n\n if self.show_var.get():\n self.master.program_config[\"startup_window\"] = False\n util.data.write_config(self.master.program_config)\n\n self.destroy()","def OnClose(self, event = None):\n ##Close.\n self.Hide()\n self.Destroy()","def OnClose(self, event):\n self.Show(False)","def close_pop_up_windows(self):\n self.button_click(self.DECLINE_BUTTON)\n self.button_click(self.CLOSE_POPUP_BUTTON)","def finalizeExit(self) -> None:\n base.graphicsEngine.removeAllWindows()\n if self.win is not None:\n print(\"Exiting KarelCraft app, bye!\")\n self.closeWindow(self.win)\n self.win = None\n self.destroy()\n sys.exit()","def onQuit(self, event):\n\n\t\tself.onClose(None)","def _close(self, event):\n self.EndModal(wx.ID_OK)","def close(self, *obj):\n self._save_size()\n self.clean_up()\n self.uistate.gwm.close_track(self.track)\n self.opened = False\n self.parent_window.present()","def exit(self):\n \t\troot.destroy()\n \t\tpass","def close(self):\n print(\"CAUGHT CLOSE SIGNAL\")\n self.root.destroy()","def onClose(self, event): \n \n self.Destroy()\n return","def onBtnCloseClicked(self):\n self.close()","def _delete_window(self):\n sys.exit(99)","def exit_btn_callback(evt):\n print(\"Inside exit_btn_callback. Event object is: \", evt)\n mainwin.destroy()","def onClose (self):\n \n pass","def closeEvent(self, event):\n self.is_active = False\n app._in_event_loop = False\n # It seems that interactor closes slower than the windows preventing from properly closing the interface.\n # The work-around is to wait a little bit\n time.sleep(0.1)\n super()","def OnClose(self, event):\n\n if not self.plot_deleted:\n pub.sendMessage( 'Close.%s' %self.GetLabel(), event=self )\n\n print(\"Window: '%s', closed by event: '%s'\" %( self.GetLabel(), event.__class__.__name__ ))\n self.Destroy()","def closeEvent(self, event):\n super(MainWindow, self).closeEvent(event)\n try:\n reactor.stop()\n except error.ReactorNotRunning: # if reactor has not been run in the session\n pass","def on_closebutton_handle_clicked(self, _widget):\n self._terminate.set()\n self.top_widget.destroy()\n self.top_widget = None","def closeEvent(self, event):\n self.is_active = False\n app._in_event_loop = False\n super()","def on_close(self, event):\n # Save pos and size\n x, y = self.GetPosition()\n width, height = self.GetSize()\n self.__config.set('window.x', x)\n self.__config.set('window.y', y)\n self.__config.set('window.width', width)\n self.__config.set('window.height', height)\n\n # Style\n style = self.GetWindowStyle()\n self.__config.set('window.style', style)\n\n self.__config.save()\n\n # Stop monitoring\n self.__cor.stop_monitor()\n\n # Kill graph as it seems to be stopping script from ending\n self.__graph = None\n\n # End\n event.Skip()","def destroy_on_close(self):\n self.deleteLater()","def onClose(self, *args):\n rospy.loginfo('Closing Cloud Map')\n self.root.quit()\n self.root.destroy()\n # rospy.signal_shutdown('Exited UI')","def closeEvent(self, event):\n self.stop()\n QtGui.QWidget.closeEvent(self, event)","def __on_close(self):\n # Release the resource and\n # close the windows\n LOGGER.info(\"closing...\")\n self.__quit.set()\n self.__detect.end()\n self.root.quit()","def on_actionQuit_triggered(self):\n\t\texit()","def handle_close(self):\n self.active = False\n self.close()","def _onClosing(self):\n if self.master is None: \n pass\n else:\n self.master.root.focus_set()\n if self.queue is not None:\n self.root.after_cancel(self._queueTimer)\n self.close()","def exit(self):\n self.root.grab_release()\n self.root.destroy()","def on_cancel(self, event=None):\r\n # put focus back to the parent window\r\n self.parent.focus_set()\r\n self.destroy()","def quit(self):\n self.window.quit()\n self.window.destroy()","def menu_quit (self,widget,data):\n\t\tself.window.delete_event()","def closeEvent(self, event):\n event.accept() # let the window close\n self.returnHome()","def exit_event(self, event):\n self.root.quit()","def OnFrameClose(self, event):\r\n\t\tself.Hide()","def on_close(self):\n print('[INFO] closing...')\n self.stopEvent.set()\n del self.tello\n self.root.quit()","def OnClose(self, event):\r\n\r\n if self._owner_mgr:\r\n self._owner_mgr.OnFloatingPaneClosed(self._pane_window, event)\r\n\r\n if not event.GetVeto():\r\n self._mgr.DetachPane(self._pane_window)\r\n\r\n if isinstance(self._pane_window, auibar.AuiToolBar):\r\n self._pane_window.SetAuiManager(self._owner_mgr)\r\n\r\n # if we do not do this, then we can crash...\r\n if self._owner_mgr and self._owner_mgr._action_window == self:\r\n self._owner_mgr._action_window = None\r\n\r\n self.Destroy()","def on_exit(self):\n if tkMessageBox.askyesno(\"Exit\", \"Do you want to quit the application?\"):\n self.logger(\"Program shutdown properly..\\n\")\n self.master.destroy()\n self.endCommand()","def quit(self, *args, **kwargs):\n self.parentApp.switchForm('MAIN')","def quit(self, *args, **kwargs):\n self.parentApp.switchForm('MAIN')","def quit(self, *args, **kwargs):\n self.parentApp.switchForm('MAIN')","def quit(self, *args, **kwargs):\n self.parentApp.switchForm('MAIN')","def closeEvent(self, event):\n\n\t\tevent.ignore()\n\t\tself.hide()\n\t\tself.__sys_tray_icon.show()","def update_ui(self):\r\n pass\r\n windowdata = self.window.get_data(self.__class__.__name__)\r\n windowdata['action_group'].get_action('UndoClose').set_sensitive(len(self.tabs_closed) > 0)\r\n windowdata['action_group'].get_action('CloseAll').set_sensitive(self.notebook.get_n_pages() > 0)\r\n windowdata['action_group'].get_action('CloseOthers').set_sensitive(self.notebook.get_n_pages() > 1)","def quit (event=None):\n root.destroy ()","def closeEvent(self, event):\n\n ## Check if exposure in progress\n if self.thread.isRunning():\n QtGui.QMessageBox.warning(self, \"Warning.\", \"Exposure in progress, unable to close program.\", QtGui.QMessageBox.Ok)\n event.ignore()\n\n ## Confirmation dialog for \n else:\n\n reply = QtGui.QMessageBox.question(self, 'Confirmation','Are you sure you want to shutdown the STA3800 controller?',\n QtGui.QMessageBox.Yes | QtGui.QMessageBox.No,\n QtGui.QMessageBox.No)\n\n if reply == QtGui.QMessageBox.Yes: \n try:\n self.settings.setValue(\"DATA_DIRECTORY\", DATA_DIRECTORY)\n restore.guisave(self, self.settings)\n except:\n self.logger.warning(\"Failed to save settings to INI file.\")\n event.accept()\n else:\n event.ignore()","def __window_stop(self):\n pass","def _quit():\r\n\twin.quit()\r\n\twin.destroy()\r\n\tquit()","def on_close(self, handler):\n if handler:\n raise AttributeError(\n \"Cannot set on_close handler for the main window. Use the app on_exit handler instead\"\n )","def destroy (self,event=None):\n \n self.top.withdraw() # Don't allow this window to be destroyed.","def closeEvent(self, event):\n self._parent.quit_application(event)","def OnCloseWindow(self, event):\r\n self.data.close()\r\n sizes[self.data.__class__.__name__] = self.GetSizeTuple()\r\n self.Destroy()","def quit_window(self, value=None):\n exit()","def callback(self):\n if tkMessageBox.askokcancel(\"Quit\", \"Do you really wish to quit?\"):\n root.destroy()","def _handle_popup_close(self):\n self._refresh()","def closeEvent(self, event) -> None:\n global dialog\n dialog = None","def back(self, _event=None):\n self.on_closingWindow()","def close_app(self):\n logging.info(\"Finished.\")\n Gtk.main_quit()","def on_cancel_click(self):\r\n\t\t# self.parent.show()\r\n\t\tself.close()","def window_close(self, item, e=None):\n\tif self.handler:\n self.handler.win_close(\"about\", None)\n\treturn 1","def OnClose(self):\n self.SaveData()\n self.destroy()","def window_close():\n response = messagebox.askokcancel(title=\"Exit?\",\n message=\"Are you sure you want to close the program?\")\n if response == True:\n root.destroy() # Closes the window\n # Else: The program continues as normal","def done(self):\n self.root.destroy()","def outCloseEvent(self):\r\n pass","def onClosePlugin(self):\n\n #print \"** CLOSING ActualizacionCatastral\"\n\n # disconnects\n self.dockwidget.closingPlugin.disconnect(self.onClosePlugin)\n\n # remove this statement if dockwidget is to remain\n # for reuse if plugin is reopened\n # Commented next statement since it causes QGIS crashe\n # when closing the docked window:\n # self.dockwidget = None\n\n self.pluginIsActive = False"],"string":"[\n \"def __onclosing(self):\\n self.window.destroy()\",\n \"def __window_close(self):\\n pass\",\n \"def onCloseWindow(self, event):\\r\\n\\r\\n self.Destroy()\",\n \"def close(self):\\n self.parent.activate()\",\n \"def close(self):\\n self.state = False\\n self.mainwindow.sendMessage('a')\\n print(\\\"closing \\\" + self.name)\",\n \"def OnClose(self, event):\\r\\n pos.app.main.Exit()\",\n \"def exit(self):\\n if self.window:\\n self.window.close()\",\n \"def _on_close(self):\\n self.shell_obj.closed()\",\n \"def close_UI(self):\",\n \"def OnExit(self, event):\\r\\n self.Close(True)\",\n \"def close_window(self):\\n # Window - END\\n self.root.destroy()\",\n \"def _onExit(self, event):\\n self.Close(True)\",\n \"def closeEvent(self, event):\\n aqt.mw.reset()\\n super().closeEvent(event)\",\n \"def cb_close(self, *args):\\n Gtk.main_quit()\",\n \"def ev_windowclose(self, event: WindowEvent) -> None:\",\n \"def quit(self):\\n\\n self.main_window.destroy()\",\n \"def OnClose(self, event):\\n self._is_open = False\\n wx.PostEvent(self, wxDockPaneClosedEvent())\",\n \"def OnExit(self, event):\\n self.Close(True)\",\n \"def OnExit(self, event):\\n self.Close(True)\",\n \"def OnExit(self, event):\\n self.Close(True)\",\n \"def OnExit(self, event):\\n self.Close(True)\",\n \"def on_main_win_close(self):\\n child_list = self.nb.winfo_children()\\n for i in range(len(child_list)):\\n index = self.nb.index('current')\\n if self.get_current().edit_modified():\\n ans = mb.askyesnocancel('Confirm on close', 'Do you want to save this file?')\\n if ans:\\n if self.save_file():\\n self.tab_close(index, child_list)\\n else:\\n return\\n elif ans is False:\\n self.tab_close(index, child_list)\\n else:\\n return\\n else:\\n self.tab_close(index, child_list)\\n self.main_window.destroy()\",\n \"def closeEvent(self, event):\\n print \\\"Window closed\\\"\\n event.ignore()\\n print \\\"Hide window.\\\"\\n self.subWindow.hide()\",\n \"def closeEvent(self, event):\\n log.info(\\\"Received window close event.\\\")\\n self.main.app_is_exiting()\\n super().closeEvent(event)\\n return\",\n \"def force_close(self):\\n\\n\\t\\tself._window.force_close()\",\n \"def OnClose(self, event):\\n\\t\\tself.Show(False)\",\n \"def close(self):\\n self.window.destroy()\\n self.buttons_window.destroy()\",\n \"def close(event):\\n event.widget.destroy()\",\n \"def callback_destroy( self ):\\r\\n self.winRunning = False\\r\\n self.rootWin.destroy()\\r\\n exit()\",\n \"def quit_click(self):\\n\\n self.parent.destroy()\",\n \"def _close_window(self):\\n render_window = self._iren.GetRenderWindow()\\n render_window.Finalize()\\n self._iren.TerminateApp()\\n\\n del render_window, self._iren, self._ren, self._renWin\",\n \"def if_quit(self):\\n answer = helper.quit_popup()\\n if answer:\\n self.parent.destroy()\",\n \"def on_closing_event(self):\\n self.exit_event(None)\",\n \"def close_and_run(self, master, window):\\r\\n self.main_gui(master)\\r\\n window.destroy()\",\n \"def close(self):\\n\\n\\t\\tself._window.close()\",\n \"def onExitButtonClicked(self, widget):\\n self.getGtkTopObject().close()\",\n \"def callback_close(self, event=None):\\n\\n if self.show_var.get():\\n self.master.program_config[\\\"startup_window\\\"] = False\\n util.data.write_config(self.master.program_config)\\n\\n self.destroy()\",\n \"def OnClose(self, event = None):\\n ##Close.\\n self.Hide()\\n self.Destroy()\",\n \"def OnClose(self, event):\\n self.Show(False)\",\n \"def close_pop_up_windows(self):\\n self.button_click(self.DECLINE_BUTTON)\\n self.button_click(self.CLOSE_POPUP_BUTTON)\",\n \"def finalizeExit(self) -> None:\\n base.graphicsEngine.removeAllWindows()\\n if self.win is not None:\\n print(\\\"Exiting KarelCraft app, bye!\\\")\\n self.closeWindow(self.win)\\n self.win = None\\n self.destroy()\\n sys.exit()\",\n \"def onQuit(self, event):\\n\\n\\t\\tself.onClose(None)\",\n \"def _close(self, event):\\n self.EndModal(wx.ID_OK)\",\n \"def close(self, *obj):\\n self._save_size()\\n self.clean_up()\\n self.uistate.gwm.close_track(self.track)\\n self.opened = False\\n self.parent_window.present()\",\n \"def exit(self):\\n \\t\\troot.destroy()\\n \\t\\tpass\",\n \"def close(self):\\n print(\\\"CAUGHT CLOSE SIGNAL\\\")\\n self.root.destroy()\",\n \"def onClose(self, event): \\n \\n self.Destroy()\\n return\",\n \"def onBtnCloseClicked(self):\\n self.close()\",\n \"def _delete_window(self):\\n sys.exit(99)\",\n \"def exit_btn_callback(evt):\\n print(\\\"Inside exit_btn_callback. Event object is: \\\", evt)\\n mainwin.destroy()\",\n \"def onClose (self):\\n \\n pass\",\n \"def closeEvent(self, event):\\n self.is_active = False\\n app._in_event_loop = False\\n # It seems that interactor closes slower than the windows preventing from properly closing the interface.\\n # The work-around is to wait a little bit\\n time.sleep(0.1)\\n super()\",\n \"def OnClose(self, event):\\n\\n if not self.plot_deleted:\\n pub.sendMessage( 'Close.%s' %self.GetLabel(), event=self )\\n\\n print(\\\"Window: '%s', closed by event: '%s'\\\" %( self.GetLabel(), event.__class__.__name__ ))\\n self.Destroy()\",\n \"def closeEvent(self, event):\\n super(MainWindow, self).closeEvent(event)\\n try:\\n reactor.stop()\\n except error.ReactorNotRunning: # if reactor has not been run in the session\\n pass\",\n \"def on_closebutton_handle_clicked(self, _widget):\\n self._terminate.set()\\n self.top_widget.destroy()\\n self.top_widget = None\",\n \"def closeEvent(self, event):\\n self.is_active = False\\n app._in_event_loop = False\\n super()\",\n \"def on_close(self, event):\\n # Save pos and size\\n x, y = self.GetPosition()\\n width, height = self.GetSize()\\n self.__config.set('window.x', x)\\n self.__config.set('window.y', y)\\n self.__config.set('window.width', width)\\n self.__config.set('window.height', height)\\n\\n # Style\\n style = self.GetWindowStyle()\\n self.__config.set('window.style', style)\\n\\n self.__config.save()\\n\\n # Stop monitoring\\n self.__cor.stop_monitor()\\n\\n # Kill graph as it seems to be stopping script from ending\\n self.__graph = None\\n\\n # End\\n event.Skip()\",\n \"def destroy_on_close(self):\\n self.deleteLater()\",\n \"def onClose(self, *args):\\n rospy.loginfo('Closing Cloud Map')\\n self.root.quit()\\n self.root.destroy()\\n # rospy.signal_shutdown('Exited UI')\",\n \"def closeEvent(self, event):\\n self.stop()\\n QtGui.QWidget.closeEvent(self, event)\",\n \"def __on_close(self):\\n # Release the resource and\\n # close the windows\\n LOGGER.info(\\\"closing...\\\")\\n self.__quit.set()\\n self.__detect.end()\\n self.root.quit()\",\n \"def on_actionQuit_triggered(self):\\n\\t\\texit()\",\n \"def handle_close(self):\\n self.active = False\\n self.close()\",\n \"def _onClosing(self):\\n if self.master is None: \\n pass\\n else:\\n self.master.root.focus_set()\\n if self.queue is not None:\\n self.root.after_cancel(self._queueTimer)\\n self.close()\",\n \"def exit(self):\\n self.root.grab_release()\\n self.root.destroy()\",\n \"def on_cancel(self, event=None):\\r\\n # put focus back to the parent window\\r\\n self.parent.focus_set()\\r\\n self.destroy()\",\n \"def quit(self):\\n self.window.quit()\\n self.window.destroy()\",\n \"def menu_quit (self,widget,data):\\n\\t\\tself.window.delete_event()\",\n \"def closeEvent(self, event):\\n event.accept() # let the window close\\n self.returnHome()\",\n \"def exit_event(self, event):\\n self.root.quit()\",\n \"def OnFrameClose(self, event):\\r\\n\\t\\tself.Hide()\",\n \"def on_close(self):\\n print('[INFO] closing...')\\n self.stopEvent.set()\\n del self.tello\\n self.root.quit()\",\n \"def OnClose(self, event):\\r\\n\\r\\n if self._owner_mgr:\\r\\n self._owner_mgr.OnFloatingPaneClosed(self._pane_window, event)\\r\\n\\r\\n if not event.GetVeto():\\r\\n self._mgr.DetachPane(self._pane_window)\\r\\n\\r\\n if isinstance(self._pane_window, auibar.AuiToolBar):\\r\\n self._pane_window.SetAuiManager(self._owner_mgr)\\r\\n\\r\\n # if we do not do this, then we can crash...\\r\\n if self._owner_mgr and self._owner_mgr._action_window == self:\\r\\n self._owner_mgr._action_window = None\\r\\n\\r\\n self.Destroy()\",\n \"def on_exit(self):\\n if tkMessageBox.askyesno(\\\"Exit\\\", \\\"Do you want to quit the application?\\\"):\\n self.logger(\\\"Program shutdown properly..\\\\n\\\")\\n self.master.destroy()\\n self.endCommand()\",\n \"def quit(self, *args, **kwargs):\\n self.parentApp.switchForm('MAIN')\",\n \"def quit(self, *args, **kwargs):\\n self.parentApp.switchForm('MAIN')\",\n \"def quit(self, *args, **kwargs):\\n self.parentApp.switchForm('MAIN')\",\n \"def quit(self, *args, **kwargs):\\n self.parentApp.switchForm('MAIN')\",\n \"def closeEvent(self, event):\\n\\n\\t\\tevent.ignore()\\n\\t\\tself.hide()\\n\\t\\tself.__sys_tray_icon.show()\",\n \"def update_ui(self):\\r\\n pass\\r\\n windowdata = self.window.get_data(self.__class__.__name__)\\r\\n windowdata['action_group'].get_action('UndoClose').set_sensitive(len(self.tabs_closed) > 0)\\r\\n windowdata['action_group'].get_action('CloseAll').set_sensitive(self.notebook.get_n_pages() > 0)\\r\\n windowdata['action_group'].get_action('CloseOthers').set_sensitive(self.notebook.get_n_pages() > 1)\",\n \"def quit (event=None):\\n root.destroy ()\",\n \"def closeEvent(self, event):\\n\\n ## Check if exposure in progress\\n if self.thread.isRunning():\\n QtGui.QMessageBox.warning(self, \\\"Warning.\\\", \\\"Exposure in progress, unable to close program.\\\", QtGui.QMessageBox.Ok)\\n event.ignore()\\n\\n ## Confirmation dialog for \\n else:\\n\\n reply = QtGui.QMessageBox.question(self, 'Confirmation','Are you sure you want to shutdown the STA3800 controller?',\\n QtGui.QMessageBox.Yes | QtGui.QMessageBox.No,\\n QtGui.QMessageBox.No)\\n\\n if reply == QtGui.QMessageBox.Yes: \\n try:\\n self.settings.setValue(\\\"DATA_DIRECTORY\\\", DATA_DIRECTORY)\\n restore.guisave(self, self.settings)\\n except:\\n self.logger.warning(\\\"Failed to save settings to INI file.\\\")\\n event.accept()\\n else:\\n event.ignore()\",\n \"def __window_stop(self):\\n pass\",\n \"def _quit():\\r\\n\\twin.quit()\\r\\n\\twin.destroy()\\r\\n\\tquit()\",\n \"def on_close(self, handler):\\n if handler:\\n raise AttributeError(\\n \\\"Cannot set on_close handler for the main window. Use the app on_exit handler instead\\\"\\n )\",\n \"def destroy (self,event=None):\\n \\n self.top.withdraw() # Don't allow this window to be destroyed.\",\n \"def closeEvent(self, event):\\n self._parent.quit_application(event)\",\n \"def OnCloseWindow(self, event):\\r\\n self.data.close()\\r\\n sizes[self.data.__class__.__name__] = self.GetSizeTuple()\\r\\n self.Destroy()\",\n \"def quit_window(self, value=None):\\n exit()\",\n \"def callback(self):\\n if tkMessageBox.askokcancel(\\\"Quit\\\", \\\"Do you really wish to quit?\\\"):\\n root.destroy()\",\n \"def _handle_popup_close(self):\\n self._refresh()\",\n \"def closeEvent(self, event) -> None:\\n global dialog\\n dialog = None\",\n \"def back(self, _event=None):\\n self.on_closingWindow()\",\n \"def close_app(self):\\n logging.info(\\\"Finished.\\\")\\n Gtk.main_quit()\",\n \"def on_cancel_click(self):\\r\\n\\t\\t# self.parent.show()\\r\\n\\t\\tself.close()\",\n \"def window_close(self, item, e=None):\\n\\tif self.handler:\\n self.handler.win_close(\\\"about\\\", None)\\n\\treturn 1\",\n \"def OnClose(self):\\n self.SaveData()\\n self.destroy()\",\n \"def window_close():\\n response = messagebox.askokcancel(title=\\\"Exit?\\\",\\n message=\\\"Are you sure you want to close the program?\\\")\\n if response == True:\\n root.destroy() # Closes the window\\n # Else: The program continues as normal\",\n \"def done(self):\\n self.root.destroy()\",\n \"def outCloseEvent(self):\\r\\n pass\",\n \"def onClosePlugin(self):\\n\\n #print \\\"** CLOSING ActualizacionCatastral\\\"\\n\\n # disconnects\\n self.dockwidget.closingPlugin.disconnect(self.onClosePlugin)\\n\\n # remove this statement if dockwidget is to remain\\n # for reuse if plugin is reopened\\n # Commented next statement since it causes QGIS crashe\\n # when closing the docked window:\\n # self.dockwidget = None\\n\\n self.pluginIsActive = False\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8200261","0.8100803","0.7912978","0.78707916","0.78692687","0.78053725","0.76622653","0.7656516","0.7632609","0.7623432","0.76179266","0.7617525","0.7596765","0.75940526","0.75664365","0.75600374","0.7546721","0.7520903","0.7520903","0.7520903","0.7520903","0.75098276","0.74896497","0.7469351","0.74578416","0.74295866","0.7419115","0.74158955","0.7409997","0.7386073","0.7385571","0.7373318","0.733905","0.73164195","0.7301586","0.7299668","0.7286172","0.7282271","0.72695065","0.7266481","0.7263564","0.7261907","0.7259244","0.7234726","0.72295994","0.7194742","0.71746033","0.716757","0.71627456","0.71467984","0.7141076","0.7135409","0.7111223","0.7099012","0.708562","0.70804626","0.7072096","0.70612955","0.7050018","0.7049995","0.7049114","0.70357305","0.70145196","0.7006229","0.70007914","0.69918466","0.698963","0.69845873","0.6973322","0.69674534","0.6954713","0.6944737","0.6936426","0.69344586","0.6934393","0.6934393","0.6934393","0.6934393","0.69300413","0.6929967","0.69243735","0.6922748","0.6920843","0.6917858","0.691146","0.69069314","0.6901516","0.6894807","0.6887099","0.68833137","0.6875531","0.6871463","0.68711174","0.6863348","0.6859292","0.6857737","0.685504","0.68524396","0.6848338","0.68349254","0.68341345"],"string":"[\n \"0.8200261\",\n \"0.8100803\",\n \"0.7912978\",\n \"0.78707916\",\n \"0.78692687\",\n \"0.78053725\",\n \"0.76622653\",\n \"0.7656516\",\n \"0.7632609\",\n \"0.7623432\",\n \"0.76179266\",\n \"0.7617525\",\n \"0.7596765\",\n \"0.75940526\",\n \"0.75664365\",\n \"0.75600374\",\n \"0.7546721\",\n \"0.7520903\",\n \"0.7520903\",\n \"0.7520903\",\n \"0.7520903\",\n \"0.75098276\",\n \"0.74896497\",\n \"0.7469351\",\n \"0.74578416\",\n \"0.74295866\",\n \"0.7419115\",\n \"0.74158955\",\n \"0.7409997\",\n \"0.7386073\",\n \"0.7385571\",\n \"0.7373318\",\n \"0.733905\",\n \"0.73164195\",\n \"0.7301586\",\n \"0.7299668\",\n \"0.7286172\",\n \"0.7282271\",\n \"0.72695065\",\n \"0.7266481\",\n \"0.7263564\",\n \"0.7261907\",\n \"0.7259244\",\n \"0.7234726\",\n \"0.72295994\",\n \"0.7194742\",\n \"0.71746033\",\n \"0.716757\",\n \"0.71627456\",\n \"0.71467984\",\n \"0.7141076\",\n \"0.7135409\",\n \"0.7111223\",\n \"0.7099012\",\n \"0.708562\",\n \"0.70804626\",\n \"0.7072096\",\n \"0.70612955\",\n \"0.7050018\",\n \"0.7049995\",\n \"0.7049114\",\n \"0.70357305\",\n \"0.70145196\",\n \"0.7006229\",\n \"0.70007914\",\n \"0.69918466\",\n \"0.698963\",\n \"0.69845873\",\n \"0.6973322\",\n \"0.69674534\",\n \"0.6954713\",\n \"0.6944737\",\n \"0.6936426\",\n \"0.69344586\",\n \"0.6934393\",\n \"0.6934393\",\n \"0.6934393\",\n \"0.6934393\",\n \"0.69300413\",\n \"0.6929967\",\n \"0.69243735\",\n \"0.6922748\",\n \"0.6920843\",\n \"0.6917858\",\n \"0.691146\",\n \"0.69069314\",\n \"0.6901516\",\n \"0.6894807\",\n \"0.6887099\",\n \"0.68833137\",\n \"0.6875531\",\n \"0.6871463\",\n \"0.68711174\",\n \"0.6863348\",\n \"0.6859292\",\n \"0.6857737\",\n \"0.685504\",\n \"0.68524396\",\n \"0.6848338\",\n \"0.68349254\",\n \"0.68341345\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21983,"cells":{"query":{"kind":"string","value":"Apply configuration file's plugin settings"},"document":{"kind":"string","value":"def apply_plugin_settings(self, options):\n pass"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def use_config_file(self):\n self.config_file = self.find_config_file()\n if self.config_file:\n self.apply_config_file(self.config_file)","def apply_config(filename):\n with open(filename) as config_file:\n config = json.load(config_file)\n for setting, value in config.items():\n CoreConfig.__dict__[setting] = value","def configure(self, options, conf):","def conf_update(self):\n pass","def update_config(self):\n if self.integration is None:\n return\n self.enabled = self.integration.has_option(self.get_config_name())\n self.pedantic = self.integration.configuration.get_bool(\n 'filter.mrproper')","def plugin_configure(config):\n collectd.info('Configuring collectd-mlab plugin.')\n parse_config(config)","def configure(self, options, conf):\n pass","def _configure(self):\n path = os.path.join(\n os.path.dirname(os.path.abspath(__file__)), 'config.yml'\n )\n\n with open(path) as file:\n defaultconfig = yaml.load(file)\n\n self.config = merge_dict(self.config, defaultconfig)\n\n if 'logging' in self.config:\n logging.config.dictConfig(self.config['logging'])\n else:\n logging.getLogger('sirbot').setLevel('INFO')","def update_from_file(self):\n config_path = os.environ.get('MINDINSIGHT_CONFIG', '')\n if not config_path:\n return\n\n config_module = None\n\n # python:full.path.for.config.module\n if config_path.startswith('python:'):\n config_module = import_module(config_path[len('python:'):])\n\n # file:full/path/for/config.py\n elif config_path.startswith('file:'):\n config_path = config_path[len('file:'):]\n module_name = '__mindinsightconfig__'\n config_module = types.ModuleType(module_name)\n machinery = import_module('importlib.machinery')\n loader = machinery.SourceFileLoader(module_name, config_path)\n loader.exec_module(config_module)\n\n if config_module is None:\n return\n\n for setting in dir(config_module):\n if setting.isupper() and setting in self._default_settings:\n setting_value = getattr(config_module, setting)\n setattr(self, setting, setting_value)\n self._explicit_settings.add(setting)","def plugin_settings(settings): # pylint: disable=unused-argument\n pass # lint-amnesty, pylint: disable=unnecessary-pass","def update_configs(self, config):\n for what in self.plugins: # backend, repo etc.\n for key in self.plugins[what]: # s3, filesystem etc.\n # print(\"Updating configuration of\", what, key)\n self.plugins[what][key].config(what='set', params=config)\n return","def config(ctx, flox: Flox, scope, profile, plugin, without_secrets, without_parameters):\n if ctx.invoked_subcommand:\n return\n\n if not plugin:\n raise ConfigurationException(\"You need to specify at least one plugin to be configured\",\n extra=\"Use flox config --plugin=<plugin-name>\")\n\n if not flox.initiated and scope == \"project\":\n warning(\"Unable to use scope project outside of project directory. Changing scope to 'user'\")\n scope = \"user\"\n\n for name in plugin:\n if not flox.plugins.has(name):\n raise MissingPluginException(name)\n\n info(f\"Starting configuration of {name} for '{scope}' scope\" + (f\" and '{profile}' profile\" if profile else \"\"))\n\n if not without_parameters:\n interactive_parameters(flox, name, flox.plugins.get(name), scope, profile)\n\n if not without_secrets:\n if scope == \"system\" and not click.confirm(warning(\"Flox can't manage secrets on the system level. \"\n \"If you like to continue all secrets would be stored at \"\n \"user level\", no_print=True)):\n raise Abort\n interactive_secrets(flox, name, flox.plugins.get(name), scope, profile)\n\n execute_stages(\n flox, \"configuration_change\", features=[name]\n )","def apply(self) -> None:\n _ba.apply_config()","def apply_settings(self):\n return True","def configure(self, conf):\n return","def setup_plugins(self, cfg, path):\n\n if cfg:\n with open(path, \"w\") as f:\n print(\"DOCUMENTATION='''\", file=f)\n print(\"---\", file=f)\n for key in cfg:\n print(f\"{key}: {cfg[key]}\", file=f)\n print(\"'''\", file=f)","def load_config(self):\n config = dict([(key, value) for key, value in iteritems(self.options)\n if key in self.cfg.settings and value is not None])\n for key, value in iteritems(config):\n self.cfg.set(key.lower(), value)","def apply_configuration(self, properties):\n\n (\n self.__enabled_plugins_for_starting_new_file,\n self.__enabled_plugins_for_next_token,\n self.__enabled_plugins_for_next_line,\n self.__enabled_plugins_for_completed_file,\n ) = ([], [], [], [])\n\n for next_plugin in self.__enabled_plugins:\n try:\n plugin_specific_facade = self.__find_configuration_for_plugin(\n next_plugin, properties, always_return_facade=True\n )\n\n next_plugin.plugin_instance.set_configuration_map(\n plugin_specific_facade\n )\n next_plugin.plugin_instance.initialize_from_config()\n except Exception as this_exception:\n raise BadPluginError(\n next_plugin.plugin_id,\n inspect.stack()[0].function,\n cause=this_exception,\n ) from this_exception\n\n if next_plugin.plugin_instance.is_next_token_implemented_in_plugin:\n self.__enabled_plugins_for_next_token.append(next_plugin)\n if next_plugin.plugin_instance.is_next_line_implemented_in_plugin:\n self.__enabled_plugins_for_next_line.append(next_plugin)\n if next_plugin.plugin_instance.is_completed_file_implemented_in_plugin:\n self.__enabled_plugins_for_completed_file.append(next_plugin)\n if next_plugin.plugin_instance.is_starting_new_file_implemented_in_plugin:\n self.__enabled_plugins_for_starting_new_file.append(next_plugin)","def configure(self, args):\n pass","def apply_config_defaults():\n\n # don't worry about broken settings, validate_config() will take\n # care of them\n\n if 'pre_action_callbacks' not in nori.cfg:\n nori.cfg['pre_action_callbacks'] = [\n (pre_action_drupal_readonly, [], {})\n ]\n\n if 'post_action_callbacks' not in nori.cfg:\n nori.cfg['post_action_callbacks'] = [\n (post_action_drupal_readonly, [], {}, True)\n ]\n\n if 'source_type' not in nori.cfg:\n nori.cfg['source_type'] = 'generic'\n\n if 'source_query_func' not in nori.cfg:\n if nori.core.cfg['source_type'] == 'generic':\n nori.core.cfg['source_query_func'] = generic_db_query\n elif nori.core.cfg['source_type'] == 'drupal':\n nori.core.cfg['source_query_func'] = drupal_db_query\n\n if 'source_query_defaulter' not in nori.cfg:\n if nori.core.cfg['source_type'] == 'generic':\n nori.core.cfg['source_query_defaulter'] = (\n apply_generic_arg_defaults\n )\n elif nori.core.cfg['source_type'] == 'drupal':\n nori.core.cfg['source_query_defaulter'] = None\n\n if 'source_query_validator' not in nori.cfg:\n if nori.core.cfg['source_type'] == 'generic':\n nori.core.cfg['source_query_validator'] = validate_generic_args\n elif nori.core.cfg['source_type'] == 'drupal':\n nori.core.cfg['source_query_validator'] = validate_drupal_args\n\n if 'source_template_change_callbacks' not in nori.cfg:\n if nori.core.cfg['source_type'] == 'generic':\n nori.core.cfg['source_template_change_callbacks'] = []\n elif nori.core.cfg['source_type'] == 'drupal':\n nori.core.cfg['source_template_change_callbacks'] = [\n (drupal_timestamp_callback, [], {})\n ]\n\n if 'source_global_change_callbacks' not in nori.cfg:\n if nori.core.cfg['source_type'] == 'generic':\n nori.core.cfg['source_global_change_callbacks'] = []\n elif nori.core.cfg['source_type'] == 'drupal':\n nori.core.cfg['source_global_change_callbacks'] = [\n (drupal_cache_callback, [], {})\n ]\n\n if 'dest_type' not in nori.cfg:\n nori.cfg['dest_type'] = 'generic'\n\n if 'dest_query_func' not in nori.cfg:\n if nori.core.cfg['dest_type'] == 'generic':\n nori.core.cfg['dest_query_func'] = generic_db_query\n elif nori.core.cfg['dest_type'] == 'drupal':\n nori.core.cfg['dest_query_func'] = drupal_db_query\n\n if 'dest_query_defaulter' not in nori.cfg:\n if nori.core.cfg['dest_type'] == 'generic':\n nori.core.cfg['dest_query_defaulter'] = (\n apply_generic_arg_defaults\n )\n elif nori.core.cfg['dest_type'] == 'drupal':\n nori.core.cfg['dest_query_defaulter'] = None\n\n if 'dest_query_validator' not in nori.cfg:\n if nori.core.cfg['dest_type'] == 'generic':\n nori.core.cfg['dest_query_validator'] = validate_generic_args\n elif nori.core.cfg['dest_type'] == 'drupal':\n nori.core.cfg['dest_query_validator'] = validate_drupal_args\n\n if 'dest_template_change_callbacks' not in nori.cfg:\n if nori.core.cfg['dest_type'] == 'generic':\n nori.core.cfg['dest_template_change_callbacks'] = []\n elif nori.core.cfg['dest_type'] == 'drupal':\n nori.core.cfg['dest_template_change_callbacks'] = [\n (drupal_timestamp_callback, [], {})\n ]\n\n if 'dest_global_change_callbacks' not in nori.cfg:\n if nori.core.cfg['dest_type'] == 'generic':\n nori.core.cfg['dest_global_change_callbacks'] = []\n elif nori.core.cfg['dest_type'] == 'drupal':\n nori.core.cfg['dest_global_change_callbacks'] = [\n (drupal_cache_callback, [], {})\n ]\n\n if 'templates' not in nori.core.cfg:\n return\n if not isinstance(nori.core.cfg['templates'],\n nori.core.MAIN_SEQUENCE_TYPES):\n return\n\n for i, template in enumerate(nori.core.cfg['templates']):\n if not isinstance(nori.core.cfg['templates'][i],\n nori.core.MAPPING_TYPES):\n continue\n\n if T_MULTIPLE_KEY not in template:\n nori.core.cfg['templates'][i][T_MULTIPLE_KEY] = False\n\n if T_S_QUERY_ARGS_KEY in template:\n args_t = template[T_S_QUERY_ARGS_KEY]\n defaulter = nori.core.cfg['source_query_defaulter']\n if (isinstance(args_t, tuple) and len(args_t) >= 2 and\n isinstance(args_t[0], nori.core.MAIN_SEQUENCE_TYPES) and\n isinstance(args_t[1], nori.core.MAPPING_TYPES) and\n defaulter and callable(defaulter)):\n defaulter(args_t[0], args_t[1])\n\n if T_TO_D_FUNC_KEY not in template:\n nori.core.cfg['templates'][i][T_TO_D_FUNC_KEY] = None\n\n if T_S_NO_REPL_KEY not in template:\n nori.core.cfg['templates'][i][T_S_NO_REPL_KEY] = False\n\n if T_S_CHANGE_CB_KEY not in template:\n nori.core.cfg['templates'][i][T_S_CHANGE_CB_KEY] = []\n\n if T_D_QUERY_ARGS_KEY in template:\n args_t = template[T_D_QUERY_ARGS_KEY]\n defaulter = nori.core.cfg['dest_query_defaulter']\n if (isinstance(args_t, tuple) and len(args_t) >= 2 and\n isinstance(args_t[0], nori.core.MAIN_SEQUENCE_TYPES) and\n isinstance(args_t[1], nori.core.MAPPING_TYPES) and\n defaulter and callable(defaulter)):\n defaulter(args_t[0], args_t[1])\n\n if T_TO_S_FUNC_KEY not in template:\n nori.core.cfg['templates'][i][T_TO_S_FUNC_KEY] = None\n\n if T_D_NO_REPL_KEY not in template:\n nori.core.cfg['templates'][i][T_D_NO_REPL_KEY] = False\n\n if T_D_CHANGE_CB_KEY not in template:\n nori.core.cfg['templates'][i][T_D_CHANGE_CB_KEY] = []\n\n if T_KEY_MODE_KEY not in template:\n nori.core.cfg['templates'][i][T_KEY_MODE_KEY] = 'all'\n\n if T_KEY_LIST_KEY not in template:\n nori.core.cfg['templates'][i][T_KEY_LIST_KEY] = []","def apply_config_file(self, filename):\n def extractor(template, options):\n \"\"\"Ignore things that are existing non default values\"\"\"\n for name, val in options:\n normalised = self.normalise_key(name)\n if normalised in self.values and not isinstance(self.values[normalised], Default):\n continue\n else:\n yield name, val\n\n items = json.load(open(filename)).items()\n self.use_options(items, extractor)","def configuration():","def update_config_file(invoker: AirflowInvoker) -> None:\n airflow_cfg_path = invoker.files[\"config\"]\n logging.debug(f\"Generated default '{str(airflow_cfg_path)}'\")\n\n # open the configuration and update it\n # now we let's update the config to use our stubs\n airflow_cfg = configparser.ConfigParser()\n\n with airflow_cfg_path.open() as cfg:\n airflow_cfg.read_file(cfg)\n logging.debug(f\"Loaded '{str(airflow_cfg_path)}'\")\n\n config = invoker.plugin_config_processed\n for section, cfg in config.items():\n airflow_cfg[section].update(cfg)\n logging.debug(f\"\\tUpdated section [{section}] with {cfg}\")\n\n with airflow_cfg_path.open(\"w\") as cfg:\n airflow_cfg.write(cfg)\n logging.debug(f\"Saved '{str(airflow_cfg_path)}'\")","def configure(self, section):","def update(self):\n self.save_config_file()","def configure(self, config: dict):\n self.config.update(config)","def configure(self, config_name, action, contents):\n config = self.default_config.copy()\n config.update(contents)\n\n _log.debug(\"Configuring Agent\")\n\n try:\n setting1 = int(config[\"setting1\"])\n setting2 = config[\"setting2\"]\n except ValueError as e:\n _log.error(\"ERROR PROCESSING CONFIGURATION: {}\".format(e))\n return\n\n for x in self.setting2:\n self._create_subscriptions(str(x))\n print(str(x))","def apply_config(self, responsible, paths, arg=None):\n self.warning(\"Reconfiguring NTP server (called with paths %s)\" % paths)\n return self.updateRunningConf(responsible)","def _auto_update_configuration(self) -> None:\n self.config = rasa.utils.train_utils.update_confidence_type(self.config)\n rasa.utils.train_utils.validate_configuration_settings(self.config)\n self.config = rasa.utils.train_utils.update_similarity_type(self.config)\n self.config = rasa.utils.train_utils.update_evaluation_parameters(self.config)","def _configure_addon(self):\n cfg = None\n try:\n data_dir = os.path.split(self.props.data_dir)\n\n cfg = Configuration(jobtype='Blender', \n data_path=data_dir[0],\n log_level=int(self.props.log_level),\n name=self.props.ini_file,\n datadir=data_dir[1])\n \n except (InvalidConfigException, IndexError) as exp:\n self.log.warning(\"Warning failed to load config file, \"\n \"creating new default config.\")\n self.log.warning(str(exp))\n \n finally:\n\n if not os.path.isdir(self.props.data_dir):\n raise EnvironmentError(\"Data directory not created - \"\n \"please ensure you have adequate permissions.\")\n\n if not cfg:\n cfg = Configuration(jobtype='Blender', log_level='warning')\n\n if self.props.endpoint:\n cfg = override_config(cfg, endpoint=self.props.endpoint)\n if self.props.account:\n cfg = override_config(cfg, account=self.props.account)\n if self.props.key:\n cfg = override_config(cfg, key=self.props.key)\n if self.props.client_id:\n cfg = override_config(cfg, client_id=self.props.client_id)\n if self.props.tenant:\n cfg = override_config(cfg, tenant=self.props.tenant)\n if self.props.redirect:\n cfg = override_config(cfg, redirect=self.props.redirect)\n\n cfg.save_config()\n return cfg","def plugin_reconfigure(handle, new_config):\n _LOGGER.info(\"Old config for Enviro pHAT plugin {} \\n new config {}\".format(handle, new_config))\n new_handle = copy.deepcopy(new_config)\n return new_handle","def apply_config(self, config_path: str) -> None:\n # pylint: disable=exec-used\n try:\n assert self._active_feature_set is None\n type(self)._active_feature_set = self\n\n # Apply both src and dist spinoff configs.\n exec_context: dict = {}\n with open(config_path, encoding='utf-8') as infile:\n config_contents = infile.read()\n\n # Use compile here so we can provide a nice file path for\n # error tracebacks.\n exec(\n compile(config_contents, config_path, 'exec'),\n exec_context,\n exec_context,\n )\n\n finally:\n assert type(self)._active_feature_set is self\n type(self)._active_feature_set = None","def config():","def config():","def configure(self) -> None:\n self._copy_repo_files()\n self._install_plugins()","def initialize_from_config(self):\n self.__allow_in_code_blocks = self.plugin_configuration.get_boolean_property(\n \"code_blocks\",\n default_value=True,\n )","def set_lite_plugin_settings(\n self, config_path: Path, plugin_id: str, settings: Dict[str, Any]\n ) -> None:\n whole_file = config = json.loads(config_path.read_text(**UTF8))\n if config_path.name == JUPYTERLITE_IPYNB:\n config = whole_file[\"metadata\"][JUPYTERLITE_METADATA]\n\n config.setdefault(JUPYTER_CONFIG_DATA, {}).setdefault(\n LITE_PLUGIN_SETTINGS, {}\n ).update({plugin_id: settings})\n\n config_path.write_text(json.dumps(whole_file, **JSON_FMT), **UTF8)\n self.log.debug(\"%s wrote settings in %s: %s\", plugin_id, config_path, settings)\n self.maybe_timestamp(config_path)","def on_pre_build(self, config):\n plugin_config = config['plugins']['encryptcontent'].config\n # Check if global password is set on plugin configuration\n if 'global_password' in config.keys():\n global_password = self.config.get('global_password')\n setattr(self, 'password', global_password)\n # Check if prefix title is set on plugin configuration to overwrite\n title_prefix = plugin_config.get('title_prefix')\n setattr(self, 'title_prefix', title_prefix)\n # Check if summary description is set on plugin configuration to overwrite\n summary = plugin_config.get('summary')\n setattr(self, 'summary', summary)\n # Check if placeholder description is set on plugin configuration to overwrite\n placeholder = plugin_config.get('placeholder')\n setattr(self, 'placeholder', placeholder)\n # Check if decryption_failure_message description is set on plugin configuration to overwrite\n decryption_failure_message = plugin_config.get('decryption_failure_message')\n setattr(self, 'decryption_failure_message', decryption_failure_message)\n # Check if encryption_info_message description is set on plugin configuration to overwrite\n encryption_info_message = plugin_config.get('encryption_info_message')\n setattr(self, 'encryption_info_message', encryption_info_message)\n # Check if hljs feature need to be enabled, based on theme configuration\n setattr(self, 'hljs', None)\n if 'highlightjs' in config['theme']._vars:\n highlightjs = config['theme']._vars['highlightjs'] \n if highlightjs:\n setattr(self, 'hljs', highlightjs)\n # Check if pymdownx.arithmatex feature need to be enabled, based on markdown_extensions configuration\n setattr(self, 'arithmatex', None)\n if 'pymdownx.arithmatex' in config['markdown_extensions']:\n setattr(self, 'arithmatex', True)\n # Check if tag_encrypted_page feature is enable: add an extra attribute `encrypted` is add on page object\n setattr(self, 'tag_encrypted_page', False)\n if 'tag_encrypted_page' in plugin_config.keys():\n tag_encrypted_page = self.config.get('tag_encrypted_page')\n setattr(self, 'tag_encrypted_page', tag_encrypted_page)\n # Check if cookie_password feature is enable: create a cookie for automatic decryption\n setattr(self, 'remember_password', False)\n setattr(self, 'disable_cookie_protection', False)\n if 'remember_password' in plugin_config.keys():\n remember_password = self.config.get('remember_password')\n setattr(self, 'remember_password', remember_password)\n # Check if cookie protection is disable *not good idea*: remove cookie flag 'Secure' & 'sameStie'\n setattr(self, 'disable_cookie_protection', False)\n if 'disable_cookie_protection' in plugin_config.keys():\n disable_cookie_protection = self.config.get('disable_cookie_protection')\n setattr(self, 'disable_cookie_protection', disable_cookie_protection)\n # Check if password_button feature is enable: Add button to trigger decryption process\n if 'password_button' in plugin_config.keys():\n password_button = plugin_config.get('password_button')\n setattr(self, 'password_button', password_button)\n # Check if password_button_text description is set on plugin configuration to overwrite\n if 'password_button_text' in plugin_config.keys():\n password_button_text = plugin_config.get('password_button_text')\n setattr(self, 'password_button_text', password_button_text)\n # Check if encrypted_something feature is enable: encrypt each other html tags targets\n setattr(self, 'encrypted_something', {})\n if 'encrypted_something' in plugin_config.keys():\n encrypted_something = self.config.get('encrypted_something')\n setattr(self, 'encrypted_something', encrypted_something)","def configure(self):","def configure(self):","def configure(self):","def configure(self):","def edit_cass_conf(self, out, plugin_instance):\n if config.DEBUG:\n filepath = '{conf_dir}/{conf_name}'.format(\n conf_dir=config.PLUGIN_CONF_DIR,\n conf_name=self.conf_name)\n else:\n filepath = '{app_dir}/{conf_dir}/{conf_name}'.format(\n app_dir=config.APP_DIR,\n conf_dir=config.PLUGIN_CONF_DIR,\n conf_name=self.conf_name)\n\n try:\n with open(filepath) as cfile:\n for line in cfile:\n url_re = re.search(\n r'ServiceURL \"CHANGE_THIS\"', line)\n if url_re is None:\n out.write(line)\n else:\n out.write(plugin_instance)\n except (IOError, OSError) as e:\n utils.eprint('Cannot open {}'.format(filepath))\n raise Exception(\n 'Error: {}\\n'\n 'Cannot open {}.'.format(e, filepath))","def override_config(self, config_path):\n self.config = p_config.ProsperConfig(config_path)","def setup_configuration_file(self):\n\n with open(self.config_path, \"w+\") as f_config:\n\n f_config.write(get_configuration_file_form())","def apply_user_configuration(self, config):\n self.logDisplay.set_logging_level(config['log'].get('logging_level', fallback='Verbose'))\n\n # MIDI\n self.winchMidiInputCombo.select_item(config['midi'].get('winch_midi_input', fallback='<no selection>'))\n self.midiOutputCombo.select_item(config['midi'].get('midi_output', fallback='<no selection>'))\n\n # OSC\n oscdef = config['osc']\n self.oscListenerConfig.set_OSC_port(oscdef.get('listener_addr', fallback='localhost'),\n oscdef.getint('listener_port', fallback=3751))\n\n self.oscSenderConfig.set_OSC_port(oscdef.get('sender_addr', fallback='localhost'),\n oscdef.getint('sender_port', fallback=3752))\n\n # DMX\n self.dmxSelect.select_item(config['dmx'].get('dmx_output_serial_port', fallback='<no selection>'))\n\n # winches\n for i, winchSelect in enumerate(self.winchSelects):\n key = \"winch_%d_output_serial_port\" % (i+1)\n winchSelect.select_item(config['winches'].get(key, fallback = '<no selection>'))\n return","async def _configure_plugins(self) -> None:\n logger.debug('Configuring plugins')\n funcs = [\n info['plugin'].configure(\n config=info['config'],\n session=self._session,\n router=self.app.router\n )\n for info in self._plugins.values()\n ]\n\n if funcs:\n await asyncio.gather(*funcs, loop=self._loop)\n logger.debug('Plugins configured')","def setup_config(self, args=None):\n self.config_parse(args=args)","def apply_settings():\n\n scs_globals = _get_scs_globals()\n\n # avoid recursion if another apply settings is running already\n if scs_globals.config_update_lock:\n return False\n\n # NOTE: save file paths in extra variables and apply them on the end\n # to make sure all of the settings are loaded first.\n # This is needed as some libraries reading are driven by other values from config file.\n # For example: \"use_infixed\"\n scs_project_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.scs_project_path, scs_globals)\n shader_presets_filepath = _property_utils.get_by_type(bpy.types.GlobalSCSProps.shader_presets_filepath, scs_globals)\n trigger_actions_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.trigger_actions_rel_path, scs_globals)\n sign_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.sign_library_rel_path, scs_globals)\n tsem_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.tsem_library_rel_path, scs_globals)\n traffic_rules_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.traffic_rules_library_rel_path, scs_globals)\n hookup_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.hookup_library_rel_path, scs_globals)\n matsubs_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.matsubs_library_rel_path, scs_globals)\n sun_profiles_library_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.sun_profiles_lib_path, scs_globals)\n conv_hlpr_converters_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.conv_hlpr_converters_path, scs_globals)\n\n # NOTE: as dump level is written in same section as config type\n # applying it directly might take place before we get information about config type\n # so it has to be saved into variable and applied only if global settings are loaded from config file\n dump_level = scs_globals.dump_level\n\n # lock update now, as we don't want any properties update functions to trigger rewrite of config file\n # which would lead to unwanted recursion\n engage_config_lock()\n\n config_container = _pix.get_data_from_file(get_config_filepath(), \" \")\n\n # avoid applying process of config if not present (most probably permission problems on config creation)\n if config_container is not None:\n\n settings_file_valid = 0\n for section in config_container:\n if settings_file_valid == 2:\n if section.type == \"Paths\":\n for prop in section.props:\n if prop[0] in (\"\", \"#\"):\n pass\n elif prop[0] == \"ProjectPath\":\n scs_project_path = prop[1]\n elif prop[0] == \"ShaderPresetsFilePath\":\n shader_presets_filepath = prop[1]\n elif prop[0] == \"TriggerActionsRelFilePath\":\n trigger_actions_rel_path = prop[1]\n elif prop[0] == \"TriggerActionsUseInfixed\":\n scs_globals.trigger_actions_use_infixed = prop[1]\n elif prop[0] == \"SignRelFilePath\":\n sign_library_rel_path = prop[1]\n elif prop[0] == \"SignUseInfixed\":\n scs_globals.sign_library_use_infixed = prop[1]\n elif prop[0] == \"TSemProfileRelFilePath\":\n tsem_library_rel_path = prop[1]\n elif prop[0] == \"TSemProfileUseInfixed\":\n scs_globals.tsem_library_use_infixed = prop[1]\n elif prop[0] == \"TrafficRulesRelFilePath\":\n traffic_rules_library_rel_path = prop[1]\n elif prop[0] == \"TrafficRulesUseInfixed\":\n scs_globals.traffic_rules_library_use_infixed = prop[1]\n elif prop[0] == \"HookupRelDirPath\":\n hookup_library_rel_path = prop[1]\n elif prop[0] == \"MatSubsRelFilePath\":\n matsubs_library_rel_path = prop[1]\n elif prop[0] == \"SunProfilesFilePath\":\n sun_profiles_library_path = prop[1]\n elif prop[0] == \"ConvertersPath\":\n conv_hlpr_converters_path = prop[1]\n elif prop[0] == \"UseAlternativeBases\":\n scs_globals.use_alternative_bases = prop[1]\n else:\n lprint('W Unrecognised item \"%s\" has been found in setting file! Skipping...', (str(prop[0]),))\n elif section.type == \"Import\":\n for prop in section.props:\n if prop[0] in (\"\", \"#\"):\n pass\n elif prop[0] == \"ImportScale\":\n scs_globals.import_scale = float(prop[1])\n elif prop[0] == \"PreservePathForExport\":\n scs_globals.import_preserve_path_for_export = prop[1]\n elif prop[0] == \"ImportPimFile\":\n scs_globals.import_pim_file = prop[1]\n elif prop[0] == \"UseWelding\":\n scs_globals.import_use_welding = prop[1]\n elif prop[0] == \"WeldingPrecision\":\n scs_globals.import_welding_precision = prop[1]\n elif prop[0] == \"UseNormals\":\n scs_globals.import_use_normals = prop[1]\n elif prop[0] == \"ImportPitFile\":\n scs_globals.import_pit_file = prop[1]\n elif prop[0] == \"LoadTextures\":\n scs_globals.import_load_textures = prop[1]\n elif prop[0] == \"ImportPicFile\":\n scs_globals.import_pic_file = prop[1]\n elif prop[0] == \"ImportPipFile\":\n scs_globals.import_pip_file = prop[1]\n elif prop[0] == \"ImportPisFile\":\n scs_globals.import_pis_file = prop[1]\n elif prop[0] == \"ConnectedBones\":\n scs_globals.import_connected_bones = prop[1]\n elif prop[0] == \"BoneImportScale\":\n scs_globals.import_bone_scale = float(prop[1])\n elif prop[0] == \"ImportPiaFile\":\n scs_globals.import_pia_file = prop[1]\n elif prop[0] == \"IncludeSubdirsForPia\":\n scs_globals.import_include_subdirs_for_pia = prop[1]\n elif section.type == \"Export\":\n for prop in section.props:\n if prop[0] in (\"\", \"#\"):\n pass\n elif prop[0] == \"ExportScale\":\n scs_globals.export_scale = float(prop[1])\n elif prop[0] == \"ApplyModifiers\":\n scs_globals.export_apply_modifiers = prop[1]\n elif prop[0] == \"ExcludeEdgesplit\":\n scs_globals.export_exclude_edgesplit = prop[1]\n elif prop[0] == \"IncludeEdgesplit\":\n scs_globals.export_include_edgesplit = prop[1]\n elif prop[0] == \"ActiveUVOnly\":\n scs_globals.export_active_uv_only = prop[1]\n elif prop[0] == \"ExportVertexGroups\":\n scs_globals.export_vertex_groups = prop[1]\n elif prop[0] == \"ExportVertexColor\":\n scs_globals.export_vertex_color = prop[1]\n elif prop[0] == \"ExportVertexColorType\":\n scs_globals.export_vertex_color_type = str(prop[1])\n elif prop[0] == \"ExportVertexColorType7\":\n scs_globals.export_vertex_color_type_7 = str(prop[1])\n elif prop[0] == \"ExportPimFile\":\n scs_globals.export_pim_file = prop[1]\n elif prop[0] == \"OutputType\":\n scs_globals.export_output_type = prop[1]\n elif prop[0] == \"ExportPitFile\":\n scs_globals.export_pit_file = prop[1]\n elif prop[0] == \"ExportPicFile\":\n scs_globals.export_pic_file = prop[1]\n elif prop[0] == \"ExportPipFile\":\n scs_globals.export_pip_file = prop[1]\n elif prop[0] == \"SignExport\":\n scs_globals.export_write_signature = prop[1]\n elif section.type == \"GlobalDisplay\":\n for prop in section.props:\n if prop[0] in (\"\", \"#\"):\n pass\n elif prop[0] == \"DisplayLocators\":\n scs_globals.display_locators = prop[1]\n elif prop[0] == \"LocatorSize\":\n scs_globals.locator_size = float(prop[1])\n elif prop[0] == \"LocatorEmptySize\":\n scs_globals.locator_empty_size = float(prop[1])\n elif prop[0] == \"DisplayConnections\":\n scs_globals.display_connections = prop[1]\n elif prop[0] == \"CurveSegments\":\n scs_globals.curve_segments = prop[1]\n elif prop[0] == \"OptimizedConnsDrawing\":\n scs_globals.optimized_connections_drawing = prop[1]\n elif prop[0] == \"DisplayTextInfo\":\n scs_globals.display_info = prop[1]\n else:\n lprint('W Unrecognised item \"%s\" has been found in setting file! Skipping...', (str(prop[0]),))\n elif section.type == \"GlobalColors\":\n for prop in section.props:\n if prop[0] in (\"\", \"#\"):\n pass\n elif prop[0] == \"PrefabLocatorsWire\":\n scs_globals.locator_prefab_wire_color = prop[1]\n elif prop[0] == \"ModelLocatorsWire\":\n scs_globals.locator_model_wire_color = prop[1]\n elif prop[0] == \"ColliderLocatorsWire\":\n scs_globals.locator_coll_wire_color = prop[1]\n elif prop[0] == \"ColliderLocatorsFace\":\n scs_globals.locator_coll_face_color = prop[1]\n elif prop[0] == \"NavigationCurveBase\":\n scs_globals.np_connection_base_color = prop[1]\n elif prop[0] == \"MapLineBase\":\n scs_globals.mp_connection_base_color = prop[1]\n elif prop[0] == \"TriggerLineBase\":\n scs_globals.tp_connection_base_color = prop[1]\n elif prop[0] == \"InfoText\":\n scs_globals.info_text_color = prop[1]\n elif prop[0] == \"BasePaint\":\n scs_globals.base_paint_color = prop[1]\n else:\n lprint('W Unrecognised item \"%s\" has been found in setting file! Skipping...', (str(prop[0]),))\n elif section.type == \"Header\":\n for prop in section.props:\n if prop[0] == \"FormatVersion\":\n if prop[1] == 1:\n settings_file_valid += 1\n elif prop[0] == \"Type\":\n if prop[1] == \"Configuration\":\n settings_file_valid += 1\n elif prop[0] == \"DumpLevel\":\n dump_level = prop[1]\n elif prop[0] == \"ConfigStoragePlace\":\n scs_globals.config_storage_place = prop[1]\n\n # if settings are read directly from blend file,\n # release update lock and don't search/apply any settings further\n if prop[1] == \"BlendFile\":\n settings_file_valid += 1\n\n # as dump level can be read already (it can be placed above config storage place property),\n # reset local variable back to value that was saved with blend file\n dump_level = scs_globals.dump_level\n\n break # to avoid further reading of header properties, so dump_level won't be overwritten unintentionally\n\n scs_globals.dump_level = dump_level\n\n # now as last apply all of the file paths\n # NOTE: applying paths is crucial for libraries\n # (they are reloaded/initiated in property update functions).\n if bpy.app.background: # if blender runs without UI then apply libraries directly as async operator is UI depended\n\n scs_globals.scs_project_path = scs_project_path\n scs_globals.shader_presets_filepath = shader_presets_filepath\n scs_globals.trigger_actions_rel_path = trigger_actions_rel_path\n scs_globals.sign_library_rel_path = sign_library_rel_path\n scs_globals.tsem_library_rel_path = tsem_library_rel_path\n scs_globals.traffic_rules_library_rel_path = traffic_rules_library_rel_path\n scs_globals.hookup_library_rel_path = hookup_library_rel_path\n scs_globals.matsubs_library_rel_path = matsubs_library_rel_path\n scs_globals.sun_profiles_lib_path = sun_profiles_library_path\n scs_globals.conv_hlpr_converters_path = conv_hlpr_converters_path\n\n else: # if blender is started normally use asynchronous operator to reload libraries\n\n bpy.ops.world.scs_paths_initialization('INVOKE_DEFAULT', paths_list=[\n {\"name\": \"project base path\", \"attr\": \"scs_project_path\", \"path\": scs_project_path},\n {\"name\": \"shader presets\", \"attr\": \"shader_presets_filepath\", \"path\": shader_presets_filepath},\n {\"name\": \"trigger actions library\", \"attr\": \"trigger_actions_rel_path\", \"path\": trigger_actions_rel_path},\n {\"name\": \"sign library\", \"attr\": \"sign_library_rel_path\", \"path\": sign_library_rel_path},\n {\"name\": \"traffic semaphore library\", \"attr\": \"tsem_library_rel_path\", \"path\": tsem_library_rel_path},\n {\"name\": \"traffic rules library\", \"attr\": \"traffic_rules_library_rel_path\", \"path\": traffic_rules_library_rel_path},\n {\"name\": \"hookups library\", \"attr\": \"hookup_library_rel_path\", \"path\": hookup_library_rel_path},\n {\"name\": \"material substance library\", \"attr\": \"matsubs_library_rel_path\", \"path\": matsubs_library_rel_path},\n {\"name\": \"sun profiles library\", \"attr\": \"sun_profiles_lib_path\", \"path\": sun_profiles_library_path},\n {\"name\": \"converters file path\", \"attr\": \"conv_hlpr_converters_path\", \"path\": conv_hlpr_converters_path},\n ])\n\n # release lock as properties are applied\n release_config_lock(use_paths_init_callback=not bpy.app.background)\n\n return True","def config_init(self):\n\n game_opts = [\n\n # Execution Options\n ('debug',False), # Toggle Debug Messaging\n ('log_path',False), # Turn on logging (w/path)\n ('log_lvl',logging.DEBUG), # Set log level\n\n # World Generation Options\n ('flex_limit',3) # Sets the maximum variance\n\n ]\n\n # Attempts to pull each value from the configuration\n # if not in config, the default value defined above\n # is set instead\n for opt in game_opts:\n try:\n setattr(self,opt[0],self.conf.conf_dict[opt[0]])\n except:\n setattr(self,opt[0],opt[1])\n continue","def updateSettings(self):\n self.parser.read(self.file)\n self.showTicker = self.parser.getboolean('Settings', 'showTicker')\n self.verbose = self.parser.getboolean('Settings', 'verbose')\n self.sleepTime = self.parser.getint('Settings', 'sleeptime')\n self.saveGraph = self.parser.getboolean('Settings', 'saveGraph')\n self.graphDPI = self.parser.getint('Settings', 'graphDPI')","def configure(self, options, config):\n Plugin.configure(self, options, config)\n self.config = config\n if self.enabled:\n self.jinja = Environment(\n loader=FileSystemLoader(os.path.join(os.path.dirname(__file__), 'templates')),\n trim_blocks=True,\n lstrip_blocks=True\n )\n self.stats = {'errors': 0, 'failures': 0, 'passes': 0, 'skipped': 0}\n self.report_data = defaultdict(Group)\n self.report_file = codecs.open(options.html_file, 'w', self.encoding, 'replace')","def configure(self):\n pass","def configure(self):\n pass","def config( **kwargs ):","def __writeConfig(self):\n page = None\n\n #TODO: get values of configurations here\n particles = \"#f\" if not base.particleMgrEnabled else \"#t\"\n volume = str(round(base.musicManager.getVolume(), 2))\n mute = \"#f\" if base.AppHasAudioFocus else \"#t\"\n #TODO: add any configuration variable name that you have added\n customConfigVariables = [\n \"\", \"particles-enabled\", \"audio-mute\", \"audio-volume\"]\n if os.path.exists(prcFile):\n # open the config file and change values according to current\n # application settings\n page = loadPrcFile(Filename.fromOsSpecific(prcFile))\n removeDecls = []\n for dec in range(page.getNumDeclarations()):\n # Check if our variables are given.\n # NOTE: This check has to be done to not loose our base or other\n # manual config changes by the user\n if page.getVariableName(dec) in customConfigVariables:\n decl = page.modifyDeclaration(dec)\n removeDecls.append(decl)\n for dec in removeDecls:\n page.deleteDeclaration(dec)\n # NOTE: particles-enabled and audio-mute are custom variables and\n # have to be loaded by hand at startup\n # Particles\n page.makeDeclaration(\"particles-enabled\", particles)\n # audio\n page.makeDeclaration(\"audio-volume\", volume)\n page.makeDeclaration(\"audio-mute\", mute)\n else:\n # Create a config file and set default values\n cpMgr = ConfigPageManager.getGlobalPtr()\n page = cpMgr.makeExplicitPage(\"%s Pandaconfig\"%appName)\n # set OpenGL to be the default\n page.makeDeclaration(\"load-display\", \"pandagl\")\n # get the displays width and height\n w = self.pipe.getDisplayWidth()\n h = self.pipe.getDisplayHeight()\n # set the window size in the config file\n page.makeDeclaration(\"win-size\", \"%d %d\"%(w, h))\n # set the default to fullscreen in the config file\n page.makeDeclaration(\"fullscreen\", \"1\")\n # particles\n page.makeDeclaration(\"particles-enabled\", \"#t\")\n # audio\n page.makeDeclaration(\"audio-volume\", volume)\n page.makeDeclaration(\"audio-mute\", \"#f\")\n # create a stream to the specified config file\n configfile = OFileStream(prcFile)\n # and now write it out\n page.write(configfile)\n # close the stream\n configfile.close()","def configure_settings(settings):\r\n if not 'PATH' in settings or not os.path.isdir(settings['PATH']):\r\n raise Exception('You need to specify a path containing the content'\r\n ' (see pelican --help for more information)')\r\n\r\n # specify the log messages to be ignored\r\n LimitFilter.ignore.update(set(settings.get('LOG_FILTER',\r\n DEFAULT_CONFIG['LOG_FILTER'])))\r\n\r\n # lookup the theme in \"pelican/themes\" if the given one doesn't exist\r\n if not os.path.isdir(settings['THEME']):\r\n theme_path = os.path.join(\r\n os.path.dirname(os.path.abspath(__file__)),\r\n 'themes',\r\n settings['THEME'])\r\n if os.path.exists(theme_path):\r\n settings['THEME'] = theme_path\r\n else:\r\n raise Exception(\"Could not find the theme %s\"\r\n % settings['THEME'])\r\n\r\n # make paths selected for writing absolute if necessary\r\n settings['WRITE_SELECTED'] = [\r\n os.path.abspath(path) for path in\r\n settings.get('WRITE_SELECTED', DEFAULT_CONFIG['WRITE_SELECTED'])\r\n ]\r\n\r\n # standardize strings to lowercase strings\r\n for key in [\r\n 'DEFAULT_LANG',\r\n ]:\r\n if key in settings:\r\n settings[key] = settings[key].lower()\r\n\r\n # standardize strings to lists\r\n for key in [\r\n 'LOCALE',\r\n ]:\r\n if key in settings and isinstance(settings[key], six.string_types):\r\n settings[key] = [settings[key]]\r\n\r\n # check settings that must be a particular type\r\n for key, types in [\r\n ('OUTPUT_SOURCES_EXTENSION', six.string_types),\r\n ('FILENAME_METADATA', six.string_types),\r\n ]:\r\n if key in settings and not isinstance(settings[key], types):\r\n value = settings.pop(key)\r\n logger.warn(\r\n 'Detected misconfigured {} ({}), '\r\n 'falling back to the default ({})'.format(\r\n key, value, DEFAULT_CONFIG[key]))\r\n\r\n # try to set the different locales, fallback on the default.\r\n locales = settings.get('LOCALE', DEFAULT_CONFIG['LOCALE'])\r\n\r\n for locale_ in locales:\r\n try:\r\n locale.setlocale(locale.LC_ALL, str(locale_))\r\n break # break if it is successful\r\n except locale.Error:\r\n pass\r\n else:\r\n logger.warning(\"LOCALE option doesn't contain a correct value\")\r\n\r\n if ('SITEURL' in settings):\r\n # If SITEURL has a trailing slash, remove it and provide a warning\r\n siteurl = settings['SITEURL']\r\n if (siteurl.endswith('/')):\r\n settings['SITEURL'] = siteurl[:-1]\r\n logger.warning(\"Removed extraneous trailing slash from SITEURL.\")\r\n # If SITEURL is defined but FEED_DOMAIN isn't,\r\n # set FEED_DOMAIN to SITEURL\r\n if not 'FEED_DOMAIN' in settings:\r\n settings['FEED_DOMAIN'] = settings['SITEURL']\r\n\r\n # check content caching layer and warn of incompatibilities\r\n if (settings.get('CACHE_CONTENT', False) and\r\n settings.get('CONTENT_CACHING_LAYER', '') == 'generator' and\r\n settings.get('WITH_FUTURE_DATES', DEFAULT_CONFIG['WITH_FUTURE_DATES'])):\r\n logger.warning('WITH_FUTURE_DATES conflicts with '\r\n \"CONTENT_CACHING_LAYER set to 'generator', \"\r\n \"use 'reader' layer instead\")\r\n\r\n # Warn if feeds are generated with both SITEURL & FEED_DOMAIN undefined\r\n feed_keys = [\r\n 'FEED_ATOM', 'FEED_RSS',\r\n 'FEED_ALL_ATOM', 'FEED_ALL_RSS',\r\n 'CATEGORY_FEED_ATOM', 'CATEGORY_FEED_RSS',\r\n 'AUTHOR_FEED_ATOM', 'AUTHOR_FEED_RSS',\r\n 'TAG_FEED_ATOM', 'TAG_FEED_RSS',\r\n 'TRANSLATION_FEED_ATOM', 'TRANSLATION_FEED_RSS',\r\n ]\r\n\r\n if any(settings.get(k) for k in feed_keys):\r\n if not settings.get('SITEURL'):\r\n logger.warning('Feeds generated without SITEURL set properly may'\r\n ' not be valid')\r\n\r\n if not 'TIMEZONE' in settings:\r\n logger.warning(\r\n 'No timezone information specified in the settings. Assuming'\r\n ' your timezone is UTC for feed generation. Check '\r\n 'http://docs.getpelican.com/en/latest/settings.html#timezone '\r\n 'for more information')\r\n\r\n # fix up pagination rules\r\n from pelican.paginator import PaginationRule\r\n pagination_rules = [\r\n PaginationRule(*r) for r in settings.get(\r\n 'PAGINATION_PATTERNS',\r\n DEFAULT_CONFIG['PAGINATION_PATTERNS'],\r\n )\r\n ]\r\n settings['PAGINATION_PATTERNS'] = sorted(\r\n pagination_rules,\r\n key=lambda r: r[0],\r\n )\r\n\r\n # Save people from accidentally setting a string rather than a list\r\n path_keys = (\r\n 'ARTICLE_EXCLUDES',\r\n 'DEFAULT_METADATA',\r\n 'DIRECT_TEMPLATES',\r\n 'EXTRA_TEMPLATES_PATHS',\r\n 'FILES_TO_COPY',\r\n 'IGNORE_FILES',\r\n 'JINJA_EXTENSIONS',\r\n 'PAGINATED_DIRECT_TEMPLATES',\r\n 'PLUGINS',\r\n 'STATIC_PATHS',\r\n 'THEME_STATIC_PATHS',\r\n )\r\n for PATH_KEY in filter(lambda k: k in settings, path_keys):\r\n if isinstance(settings[PATH_KEY], six.string_types):\r\n logger.warning(\"Detected misconfiguration with %s setting \"\r\n \"(must be a list), falling back to the default\"\r\n % PATH_KEY)\r\n settings[PATH_KEY] = DEFAULT_CONFIG[PATH_KEY]\r\n\r\n for old, new, doc in [\r\n ('LESS_GENERATOR', 'the Webassets plugin', None),\r\n ('FILES_TO_COPY', 'STATIC_PATHS and EXTRA_PATH_METADATA',\r\n 'https://github.com/getpelican/pelican/blob/master/docs/settings.rst#path-metadata'),\r\n ]:\r\n if old in settings:\r\n message = 'The {} setting has been removed in favor of {}'.format(\r\n old, new)\r\n if doc:\r\n message += ', see {} for details'.format(doc)\r\n logger.warning(message)\r\n\r\n return settings","def configure(self):\r\n pass","def config(ctx):\n return","def configure(self, options, config):\n Plugin.configure(self, options, config)\n self.config = config\n if self.enabled:\n self.xunitstream = globalxunitstream\n self.xunitstats = globalxunitstats\n for i in range(4):\n self.xunitstats[i] = 0\n self.xunit_file = options.xunit_file\n self.xunit_header = options.xunit_header","def configure(self) -> None:","def __import(self):\n configured_plugins = self.config.get('plugins', {}).copy()\n plugin_module_files = self.__find_plugin_modules(configured_plugins)\n self.__initialize_plugins(configured_plugins, plugin_module_files)","def write_plugin(config: Config) -> Config:\n with open(config.path, \"r\") as input_file:\n lines = input_file.read().split(\"\\n\")\n\n lines_computed = []\n\n ignore_lines = False\n id_section = False\n\n for line in lines:\n # id section\n if line.startswith(\"#----begin_id_section----\"):\n id_section = True\n\n lines_computed.append(COMMENT_PYTHON + PREFIX)\n\n continue\n\n if line.startswith(\"#----end_id_section----\"):\n id_section = False\n\n continue\n\n if id_section:\n if line.startswith(\"#\"):\n continue\n\n if not line:\n continue\n\n variables = [x.strip() for x in line.split(\"=\")]\n\n if variables:\n variable_name = variables[0]\n\n lines_computed.append(\n \"{} = {}\".format(\n variable_name,\n getattr(config.module, variable_name)\n )\n )\n\n continue\n\n # skip bootstrap4c4d lines\n if line.startswith(\"#----begin\"):\n ignore_lines = True\n\n continue\n\n if line.startswith(\"#----end\"):\n ignore_lines = False\n\n continue\n\n if not ignore_lines:\n lines_computed.append(line)\n\n compiled_plugin_file = os.path.join(\n config.destination, \"{}.pyp\".format(config.name)\n )\n\n assert_directories(compiled_plugin_file, True)\n\n with open(compiled_plugin_file, \"w\") as output_file:\n output_file.write(\"\\n\".join(lines_computed))\n\n return config","def process_config(self, filename):\n \n self.log_message(\"processing config file: \"+filename)\n parser = SafeConfigParser()\n parser.optionxform = str\n parser.read(filename)\n self.source_files[filename] = parser\n \n sections = parser.sections()\n for section in sections:\n \n options = parser.options(section)\n params = {}\n non_std = {}\n for option in options:\n ## any option that ends with the word \"password\" will be encrypted and will automatically be decrypted upon\n ## processing \n if option in self.standard_options:\n params[option] = self.get_value(option, parser.get(section, option))\n else:\n non_std[option] = self.get_value(option, parser.get(section, option))\n\n params['non_std'] = non_std\n params['source_file'] = filename\n params['name']=section\n params['run_date']=self.run_date\n c_entry = ConfigEntry(params)\n if c_entry.ready: \n entry_num = c_entry.get_entry_type()\n self.entries[self.entry_types[entry_num]].append(c_entry)\n self.entry_dict[section] = {'source':filename,'entry':c_entry}\n self.log_message(\"Loaded Config Entry: \"+section)\n else:\n self.log_message(\"Failed to load config entry: \"+section)\n\n return self.entries","def configure(self):\n\n pass","def configfile(self, fp):\n if not self.modifier.skip_configfile:\n if os.path.exists(fp):\n self.configfiles.append(fp)\n c = snakemake.io.load_configfile(fp)\n update_config(self.config, c)\n if self.overwrite_config:\n logger.info(\n \"Config file {} is extended by additional config specified via the command line.\".format(\n fp\n )\n )\n update_config(self.config, self.overwrite_config)\n elif not self.overwrite_configfiles:\n fp_full = os.path.abspath(fp)\n raise WorkflowError(\n f\"Workflow defines configfile {fp} but it is not present or accessible (full checked path: {fp_full}).\"\n )\n else:\n # CLI configfiles have been specified, do not throw an error but update with their values\n update_config(self.config, self.overwrite_config)","def initialize_from_config(self):","def main(args):\n\n with open(args.cfg_fn, 'r') as cfg_fd:\n config = cfg_fd.read().split(\"\\n\")\n\n with open(args.opt_fn, 'r') as opt_fd:\n for oline in opt_fd:\n option, value = oline.strip().split(\"=\")\n\n conf_addition = \"%s=%s\" % (option, value)\n added = False\n for line_nr, line in enumerate(config):\n if \"# %s is not set\" % option in line or \\\n \"%s=\" % option in line:\n config[line_nr] = conf_addition\n added = True\n break\n\n if not added:\n config.append(conf_addition)\n\n with open(args.cfg_fn, 'w') as cfg_fd:\n cfg_fd.write(\"\\n\".join(config))","def run(self):\n write_config(self.filename)\n print('Wrote default config to', self.filename)","def init_config(self):\n super().init_config()\n for param in self.parameters():\n if param.name == 'source':\n continue\n self.add_config_item(param.name,\n saver=lambda p=param: getattr(p, \"value\"),\n loader=lambda x, p=param: setattr(p, \"value\", x),\n default=param.default)","def _overwrite_with_config(self, new_cfg):\n for section in new_cfg.sections():\n for key, val in new_cfg.items(section):\n self.config.set(section, key, val)","def _apply_settings(self):\n if 'fixed_delta_seconds' in self.dict_settings:\n self.settings.fixed_delta_seconds = self.dict_settings['fixed_delta_seconds']\n\n self.world.apply_settings(self.settings)","def _configure(self):\n pass","def change_settings(new_settings={}, file=None):\n gl = globals()\n if file is not None:\n execfile(file)\n gl.update(locals())\n gl.update(new_settings)\n # Here you can add some code to check that the new configuration\n # values are valid.","def parse(self, config_file):\n\t\tself.options = yaml.load(open(config_file))","def configure(self, options):\n if 'config_file' in options and options['config_file']:\n path = options['config_file']\n if not ( os.path.isfile(path) and os.access(path, os.R_OK) ):\n self.__logger.error('Configuration file does not exist or is not readable')\n return False\n try:\n if not self.cp.read(path):\n raise configparser.Error('Unable to load from configuration file')\n except configparser.Error as e:\n self.__logger.error('Unable to load from configuration file : %s', str(e).replace('\\n', ''))\n return False\n\n self.__logger.debug('advanced configuration successfully loaded')\n return True","def conf(config_file):\n\n global cf\n\n cf_parser = SafeConfigParser()\n\n # etc dir at the same level of the bin dir containing this script\n close_etc_path = os.path.realpath( os.path.realpath(os.path.dirname(__file__)) + \"/../etc\" )\n\n # Try to open configuration file (read() can get a list of files as well)\n conf_file_ok = True\n if len(cf_parser.read(config_file)) == 0:\n logging.warning(\"Cannot read configuration file %s\" % config_file)\n conf_file_ok = False\n\n for sec_name,sec_content in cf.iteritems():\n\n for key,val in sec_content.iteritems():\n\n try:\n new_val = cf_parser.get(sec_name, key) # --> [sec_name]\n try:\n new_val = float(new_val)\n except ValueError:\n pass\n cf[sec_name][key] = new_val\n logging.info(\"Configuration: %s.%s = %s (from file)\", sec_name, key, str(new_val))\n except Exception, e:\n logging.info(\"Configuration: %s.%s = %s (default)\", sec_name, key, str(val))\n\n return conf_file_ok","def load_config(self):\n pass","def _set_config():\n\n\tdebug_msg = \"load default config yaml file\"\n\tlogger.debug(debug_msg)\n\n\tconfig_file_parser(paths.CONFIG_FILE, override_options=True)","def update_conf_file():\n filepath = remote_dir + \"/apache2/conf/httpd.conf\"\n fabric.contrib.files.sed(filepath, 'myproject', project_name)","def config(self):\n pass","def config(self):\n pass","def configure(self, *args):\n raise NotImplementedError(self, \"configure\")","def run_plugin():\n # load config\n config = load_config()\n all_resources = []\n\n # load placeholders\n if config.placeholders:\n placeholders = config.placeholders\n else:\n placeholders = {}\n if config.placeholders_file:\n placeholders.update(parse_dotenv(config.placeholders_file))\n\n for resource in yaml.safe_load_all(sys.stdin.read()):\n is_resource_match, resource_metadata = c.resource_match_selectors(resource, config.resource_selectors)\n if is_resource_match:\n for key, value in resource.items():\n # secret is a special case\n if(resource_metadata['kind'] == 'Secret'):\n if 'data' in resource:\n resource['data'] = c.perform_placeholder_replacements(resource['data'], PLACEHOLDER_PROG, c.get_default_replacement_func(placeholders), True)\n if 'tls' in resource:\n resource['tls'] = c.perform_placeholder_replacements(resource['tls'], PLACEHOLDER_PROG, c.get_default_replacement_func(placeholders), True)\n # exclude these top-level fields from placeholder replacement\n elif key not in ('apiVersion', 'kind', 'metadata'):\n resource[key] = c.perform_placeholder_replacements(value, PLACEHOLDER_PROG, c.get_default_replacement_func(placeholders), False)\n\n all_resources.append(resource)\n yaml.dump_all(all_resources, sys.stdout, default_flow_style=False)","def load_settings_from_file(self, cfg_file):\n \n #\n #\n # TODO\n # Missing settings should not cause exceptions\n #\n #\n #\n\n if not os.path.exists(cfg_file): \n raise Exception('Provided config file [%s] does not exist or cannot be read.' % cfg_file)\n\n import ConfigParser\n config = ConfigParser.ConfigParser()\n config.read(cfg_file)\n \n \n self.reference_root = config.get('Paths','reference-root')\n \n self.scratch_root = os.getcwd()\n try:\n self.scratch_root = config.get('Paths','scratch-root')\n except ConfigParser.NoOptionError:\n self.logger.info('Scratch-root setting is missing. Using current directory: %s' % self.scratch_root)\n\n\n if (self.run_folder != None):\n self.run_id = os.path.basename(self.run_folder)\n else:\n raise Exception('Set runfolder with PipelineConfig.set_runfolder() before loading settings')\n \n \n #\n # TODO\n # needs to be updated on update of settings\n #\n self.runs_scratch_dir = os.path.join(self.scratch_root, self.run_id) if self.run_folder != None else self.scratch_root\n self.logger.info('Run\\'s scratch directory: %s' % self.runs_scratch_dir)\n \n # optional results and fastq archive dirs \n self.results_archive = None\n try:\n self.results_archive = config.get('Paths','results-archive')\n except ConfigParser.NoOptionError:\n self.logger.info('No results-archive provided. Results will not be archived outside of the run\\'s scratch directory.')\n \n self.fastq_archive = None\n try:\n self.fastq_archive = config.get('Paths','fastq-archive')\n except ConfigParser.NoOptionError:\n self.logger.info('No fastq-archive provided. Fastq files will not be archived outside of the run\\'s scratch directory.')\n \n \n # optional /tmp dir\n self.tmp_dir = '/tmp'\n try:\n self.tmp_dir = config.get('Paths','tmp-dir')\n except ConfigParser.NoOptionError:\n self.logger.info('No tmp-dir provided. /tmp will be used.')\n \n \n \n \n # reference files\n self.reference = os.path.join(self.reference_root, config.get('Resources','reference-genome'))\n self.capture = os.path.join(self.reference_root, config.get('Resources','capture-regions-bed'))\n self.capture_qualimap = os.path.join(self.reference_root, config.get('Resources','capture-regions-bed-for-qualimap'))\n self.capture_plus = os.path.join(self.reference_root, config.get('Resources', 'capture-plus-regions-bed'))\n self.gene_coordinates = os.path.join(self.reference_root, config.get('Resources', 'gene-coordinates'))\n \n self.adapters = os.path.join(self.reference_root, config.get('Resources', 'adapters-fasta'))\n \n # tools\n self.bcl2fastq = config.get('Tools','bcl2fastq')\n self.trimmomatic = config.get('Tools','trimmomatic') \n self.bwa = config.get('Tools','bwa')\n self.samtools = config.get('Tools','samtools')\n self.picard = config.get('Tools','picard')\n self.gatk = config.get('Tools','gatk')\n self.freebayes = config.get('Tools','freebayes')\n self.bcftools = config.get('Tools','bcftools')\n self.qualimap = config.get('Tools','qualimap')\n \tself.fastqc\t = config.get('Tools','fastqc')\n\n\n # annovar settings\n self.convert_to_annovar = os.path.join(config.get('Annovar','annovar_home'), \n config.get('Annovar','convert_to_annovar'))\n self.annovar_annotate = os.path.join(config.get('Annovar','annovar_home'),\n config.get('Annovar','annovar_annotate'))\n self.table_annovar = os.path.join(config.get('Annovar','annovar_home'), \n config.get('Annovar','table_annovar'))\n self.annovar_human_db = os.path.join(config.get('Annovar','annovar_home'),\n config.get('Annovar','annovar_human_db'))\n self.annovar_1000genomes_eur = config.get('Annovar','annovar_1000genomes_eur')\n self.annovar_1000genomes_eur_maf_cutoff = config.get('Annovar','annovar_1000genomes_eur_maf_cutoff')\n self.annovar_inhouse_dbs = config.get('Annovar','annovar_inhouse_dbs')\n self.omim_gene_phenotype_map_file = config.get('Annovar','omim_gene_phenotype_map_file')","def applyOptions(self, options_file):\n self.settings.res_width = self.res_width.text()\n self.settings.res_height = self.res_height.text()\n \n self.settings.writeSettingsToFile(options_file)\n self.button_apply.setEnabled(False)\n\n self.parent.resize(int(self.settings.res_width),int(self.settings.res_height))","def parse_config(self):\n # TODO: parse config file\n pass","def edit_cfg(config_file):\n\n GUI().cfgEditor(config_file)","def change_pwds(config):\n if not config:\n click.echo(help_msg)\n return\n try:\n user_config = imp.load_source('config', config)\n except IOError as e:\n click.echo(\"File %s not found.\" % config)\n logger.error(\"Invalid path to config file: %s\" % e)\n except Exception as e:\n click.echo(\"Ooups. Something went wrong.\")\n click.echo(e)\n logger.critical(\"%s\" % e)\n else:\n for i in dir(config_f):\n if not i.startswith(\"__\"):\n try:\n user_config.__dict__[i]\n except KeyError:\n user_config.__dict__[i] = config_f.__dict__[i]\n handle_exceptions(main, user_config)","def pyang_plugin_init():\n plugin.register_plugin(OpenConfigPlugin())","def widget_load_config(self, plugman):\r\n pass","def update_config(self, config):\n # add follower public folder to the CKAN's list of public folders\n here = os.path.dirname(__file__)\n public_dir = os.path.join(here, 'public')\n if config.get('extra_public_paths'):\n config['extra_public_paths'] += ',' + public_dir\n else:\n config['extra_public_paths'] = public_dir\n # add follower template folder to the CKAN's list of template folders\n template_dir = os.path.join(here, 'templates')\n if config.get('extra_template_paths'):\n config['extra_template_paths'] += ',' + template_dir\n else:\n config['extra_template_paths'] = template_dir","def config(self, config_dict):\r\n self._cfg.config = config_dict","def config():\n config_django()\n config_svisor()","def update_config(config_file, config_base=None):\n if config_base is None:\n config_base = def_config_file\n assert(os.path.isfile(config_base))\n if not os.path.isfile(config_file):\n shutil.copy(config_base, config_file)\n cp = CisConfigParser()\n cp.read(config_file)\n miss = []\n if platform._is_win: # pragma: windows\n miss += update_config_windows(cp)\n with open(config_file, 'w') as fd:\n cp.write(fd)\n for sect, opt, desc in miss: # pragma: windows\n warnings.warn((\"Could not locate option %s in section %s.\"\n + \"Please set this in %s to: %s\")\n % (opt, sect, config_file, desc))","def load_configuration(self) -> None:\n config_file = self.default_config_file\n if self.config_file:\n config_file = self.config_file\n self.config = configparser.ConfigParser(delimiters=\"=\")\n # mypy is unhappy with us assigning to a method - (monkeypatching?)\n self.config.optionxform = lambda option: option # type: ignore\n self.config.read(config_file)","def __update(self):\n if self.__file:\n target_file = open(self.__file)\n for attr in dir(self):\n if not attr.startswith(\"_\") and \\\n (self.__overwrite or (attr not in self.__exclude)) \\\n and not self.__is_attr_callable(attr):\n try:\n delattr(self, attr)\n except AttributeError:\n pass\n pool = yaml.load(target_file)\n target_file.close()\n if pool: # could be None\n for key, val in pool.iteritems():\n if not key.startswith(\"_\") and \\\n (self.__overwrite or (key not in self.__exclude)) \\\n and not self.__is_attr_callable(key):\n setattr(self, key, val)\n if hasattr(self, 'log_config_file_changes')\\\n and self.log_config_file_changes:\n logging.getLogger(__name__).info(\"Config file has updated.\")","def config(self, **kw):\n group = kw.pop('group', None)\n for k, v in kw.items():\n CONF.set_override(k, v, group)","async def settings(self, ctx: BBContext):\n pass","def configure(**kw):\n from . import conf\n for key, value in kw.items(): \n getattr(conf, key)\n setattr(conf, key, value)"],"string":"[\n \"def use_config_file(self):\\n self.config_file = self.find_config_file()\\n if self.config_file:\\n self.apply_config_file(self.config_file)\",\n \"def apply_config(filename):\\n with open(filename) as config_file:\\n config = json.load(config_file)\\n for setting, value in config.items():\\n CoreConfig.__dict__[setting] = value\",\n \"def configure(self, options, conf):\",\n \"def conf_update(self):\\n pass\",\n \"def update_config(self):\\n if self.integration is None:\\n return\\n self.enabled = self.integration.has_option(self.get_config_name())\\n self.pedantic = self.integration.configuration.get_bool(\\n 'filter.mrproper')\",\n \"def plugin_configure(config):\\n collectd.info('Configuring collectd-mlab plugin.')\\n parse_config(config)\",\n \"def configure(self, options, conf):\\n pass\",\n \"def _configure(self):\\n path = os.path.join(\\n os.path.dirname(os.path.abspath(__file__)), 'config.yml'\\n )\\n\\n with open(path) as file:\\n defaultconfig = yaml.load(file)\\n\\n self.config = merge_dict(self.config, defaultconfig)\\n\\n if 'logging' in self.config:\\n logging.config.dictConfig(self.config['logging'])\\n else:\\n logging.getLogger('sirbot').setLevel('INFO')\",\n \"def update_from_file(self):\\n config_path = os.environ.get('MINDINSIGHT_CONFIG', '')\\n if not config_path:\\n return\\n\\n config_module = None\\n\\n # python:full.path.for.config.module\\n if config_path.startswith('python:'):\\n config_module = import_module(config_path[len('python:'):])\\n\\n # file:full/path/for/config.py\\n elif config_path.startswith('file:'):\\n config_path = config_path[len('file:'):]\\n module_name = '__mindinsightconfig__'\\n config_module = types.ModuleType(module_name)\\n machinery = import_module('importlib.machinery')\\n loader = machinery.SourceFileLoader(module_name, config_path)\\n loader.exec_module(config_module)\\n\\n if config_module is None:\\n return\\n\\n for setting in dir(config_module):\\n if setting.isupper() and setting in self._default_settings:\\n setting_value = getattr(config_module, setting)\\n setattr(self, setting, setting_value)\\n self._explicit_settings.add(setting)\",\n \"def plugin_settings(settings): # pylint: disable=unused-argument\\n pass # lint-amnesty, pylint: disable=unnecessary-pass\",\n \"def update_configs(self, config):\\n for what in self.plugins: # backend, repo etc.\\n for key in self.plugins[what]: # s3, filesystem etc.\\n # print(\\\"Updating configuration of\\\", what, key)\\n self.plugins[what][key].config(what='set', params=config)\\n return\",\n \"def config(ctx, flox: Flox, scope, profile, plugin, without_secrets, without_parameters):\\n if ctx.invoked_subcommand:\\n return\\n\\n if not plugin:\\n raise ConfigurationException(\\\"You need to specify at least one plugin to be configured\\\",\\n extra=\\\"Use flox config --plugin=<plugin-name>\\\")\\n\\n if not flox.initiated and scope == \\\"project\\\":\\n warning(\\\"Unable to use scope project outside of project directory. Changing scope to 'user'\\\")\\n scope = \\\"user\\\"\\n\\n for name in plugin:\\n if not flox.plugins.has(name):\\n raise MissingPluginException(name)\\n\\n info(f\\\"Starting configuration of {name} for '{scope}' scope\\\" + (f\\\" and '{profile}' profile\\\" if profile else \\\"\\\"))\\n\\n if not without_parameters:\\n interactive_parameters(flox, name, flox.plugins.get(name), scope, profile)\\n\\n if not without_secrets:\\n if scope == \\\"system\\\" and not click.confirm(warning(\\\"Flox can't manage secrets on the system level. \\\"\\n \\\"If you like to continue all secrets would be stored at \\\"\\n \\\"user level\\\", no_print=True)):\\n raise Abort\\n interactive_secrets(flox, name, flox.plugins.get(name), scope, profile)\\n\\n execute_stages(\\n flox, \\\"configuration_change\\\", features=[name]\\n )\",\n \"def apply(self) -> None:\\n _ba.apply_config()\",\n \"def apply_settings(self):\\n return True\",\n \"def configure(self, conf):\\n return\",\n \"def setup_plugins(self, cfg, path):\\n\\n if cfg:\\n with open(path, \\\"w\\\") as f:\\n print(\\\"DOCUMENTATION='''\\\", file=f)\\n print(\\\"---\\\", file=f)\\n for key in cfg:\\n print(f\\\"{key}: {cfg[key]}\\\", file=f)\\n print(\\\"'''\\\", file=f)\",\n \"def load_config(self):\\n config = dict([(key, value) for key, value in iteritems(self.options)\\n if key in self.cfg.settings and value is not None])\\n for key, value in iteritems(config):\\n self.cfg.set(key.lower(), value)\",\n \"def apply_configuration(self, properties):\\n\\n (\\n self.__enabled_plugins_for_starting_new_file,\\n self.__enabled_plugins_for_next_token,\\n self.__enabled_plugins_for_next_line,\\n self.__enabled_plugins_for_completed_file,\\n ) = ([], [], [], [])\\n\\n for next_plugin in self.__enabled_plugins:\\n try:\\n plugin_specific_facade = self.__find_configuration_for_plugin(\\n next_plugin, properties, always_return_facade=True\\n )\\n\\n next_plugin.plugin_instance.set_configuration_map(\\n plugin_specific_facade\\n )\\n next_plugin.plugin_instance.initialize_from_config()\\n except Exception as this_exception:\\n raise BadPluginError(\\n next_plugin.plugin_id,\\n inspect.stack()[0].function,\\n cause=this_exception,\\n ) from this_exception\\n\\n if next_plugin.plugin_instance.is_next_token_implemented_in_plugin:\\n self.__enabled_plugins_for_next_token.append(next_plugin)\\n if next_plugin.plugin_instance.is_next_line_implemented_in_plugin:\\n self.__enabled_plugins_for_next_line.append(next_plugin)\\n if next_plugin.plugin_instance.is_completed_file_implemented_in_plugin:\\n self.__enabled_plugins_for_completed_file.append(next_plugin)\\n if next_plugin.plugin_instance.is_starting_new_file_implemented_in_plugin:\\n self.__enabled_plugins_for_starting_new_file.append(next_plugin)\",\n \"def configure(self, args):\\n pass\",\n \"def apply_config_defaults():\\n\\n # don't worry about broken settings, validate_config() will take\\n # care of them\\n\\n if 'pre_action_callbacks' not in nori.cfg:\\n nori.cfg['pre_action_callbacks'] = [\\n (pre_action_drupal_readonly, [], {})\\n ]\\n\\n if 'post_action_callbacks' not in nori.cfg:\\n nori.cfg['post_action_callbacks'] = [\\n (post_action_drupal_readonly, [], {}, True)\\n ]\\n\\n if 'source_type' not in nori.cfg:\\n nori.cfg['source_type'] = 'generic'\\n\\n if 'source_query_func' not in nori.cfg:\\n if nori.core.cfg['source_type'] == 'generic':\\n nori.core.cfg['source_query_func'] = generic_db_query\\n elif nori.core.cfg['source_type'] == 'drupal':\\n nori.core.cfg['source_query_func'] = drupal_db_query\\n\\n if 'source_query_defaulter' not in nori.cfg:\\n if nori.core.cfg['source_type'] == 'generic':\\n nori.core.cfg['source_query_defaulter'] = (\\n apply_generic_arg_defaults\\n )\\n elif nori.core.cfg['source_type'] == 'drupal':\\n nori.core.cfg['source_query_defaulter'] = None\\n\\n if 'source_query_validator' not in nori.cfg:\\n if nori.core.cfg['source_type'] == 'generic':\\n nori.core.cfg['source_query_validator'] = validate_generic_args\\n elif nori.core.cfg['source_type'] == 'drupal':\\n nori.core.cfg['source_query_validator'] = validate_drupal_args\\n\\n if 'source_template_change_callbacks' not in nori.cfg:\\n if nori.core.cfg['source_type'] == 'generic':\\n nori.core.cfg['source_template_change_callbacks'] = []\\n elif nori.core.cfg['source_type'] == 'drupal':\\n nori.core.cfg['source_template_change_callbacks'] = [\\n (drupal_timestamp_callback, [], {})\\n ]\\n\\n if 'source_global_change_callbacks' not in nori.cfg:\\n if nori.core.cfg['source_type'] == 'generic':\\n nori.core.cfg['source_global_change_callbacks'] = []\\n elif nori.core.cfg['source_type'] == 'drupal':\\n nori.core.cfg['source_global_change_callbacks'] = [\\n (drupal_cache_callback, [], {})\\n ]\\n\\n if 'dest_type' not in nori.cfg:\\n nori.cfg['dest_type'] = 'generic'\\n\\n if 'dest_query_func' not in nori.cfg:\\n if nori.core.cfg['dest_type'] == 'generic':\\n nori.core.cfg['dest_query_func'] = generic_db_query\\n elif nori.core.cfg['dest_type'] == 'drupal':\\n nori.core.cfg['dest_query_func'] = drupal_db_query\\n\\n if 'dest_query_defaulter' not in nori.cfg:\\n if nori.core.cfg['dest_type'] == 'generic':\\n nori.core.cfg['dest_query_defaulter'] = (\\n apply_generic_arg_defaults\\n )\\n elif nori.core.cfg['dest_type'] == 'drupal':\\n nori.core.cfg['dest_query_defaulter'] = None\\n\\n if 'dest_query_validator' not in nori.cfg:\\n if nori.core.cfg['dest_type'] == 'generic':\\n nori.core.cfg['dest_query_validator'] = validate_generic_args\\n elif nori.core.cfg['dest_type'] == 'drupal':\\n nori.core.cfg['dest_query_validator'] = validate_drupal_args\\n\\n if 'dest_template_change_callbacks' not in nori.cfg:\\n if nori.core.cfg['dest_type'] == 'generic':\\n nori.core.cfg['dest_template_change_callbacks'] = []\\n elif nori.core.cfg['dest_type'] == 'drupal':\\n nori.core.cfg['dest_template_change_callbacks'] = [\\n (drupal_timestamp_callback, [], {})\\n ]\\n\\n if 'dest_global_change_callbacks' not in nori.cfg:\\n if nori.core.cfg['dest_type'] == 'generic':\\n nori.core.cfg['dest_global_change_callbacks'] = []\\n elif nori.core.cfg['dest_type'] == 'drupal':\\n nori.core.cfg['dest_global_change_callbacks'] = [\\n (drupal_cache_callback, [], {})\\n ]\\n\\n if 'templates' not in nori.core.cfg:\\n return\\n if not isinstance(nori.core.cfg['templates'],\\n nori.core.MAIN_SEQUENCE_TYPES):\\n return\\n\\n for i, template in enumerate(nori.core.cfg['templates']):\\n if not isinstance(nori.core.cfg['templates'][i],\\n nori.core.MAPPING_TYPES):\\n continue\\n\\n if T_MULTIPLE_KEY not in template:\\n nori.core.cfg['templates'][i][T_MULTIPLE_KEY] = False\\n\\n if T_S_QUERY_ARGS_KEY in template:\\n args_t = template[T_S_QUERY_ARGS_KEY]\\n defaulter = nori.core.cfg['source_query_defaulter']\\n if (isinstance(args_t, tuple) and len(args_t) >= 2 and\\n isinstance(args_t[0], nori.core.MAIN_SEQUENCE_TYPES) and\\n isinstance(args_t[1], nori.core.MAPPING_TYPES) and\\n defaulter and callable(defaulter)):\\n defaulter(args_t[0], args_t[1])\\n\\n if T_TO_D_FUNC_KEY not in template:\\n nori.core.cfg['templates'][i][T_TO_D_FUNC_KEY] = None\\n\\n if T_S_NO_REPL_KEY not in template:\\n nori.core.cfg['templates'][i][T_S_NO_REPL_KEY] = False\\n\\n if T_S_CHANGE_CB_KEY not in template:\\n nori.core.cfg['templates'][i][T_S_CHANGE_CB_KEY] = []\\n\\n if T_D_QUERY_ARGS_KEY in template:\\n args_t = template[T_D_QUERY_ARGS_KEY]\\n defaulter = nori.core.cfg['dest_query_defaulter']\\n if (isinstance(args_t, tuple) and len(args_t) >= 2 and\\n isinstance(args_t[0], nori.core.MAIN_SEQUENCE_TYPES) and\\n isinstance(args_t[1], nori.core.MAPPING_TYPES) and\\n defaulter and callable(defaulter)):\\n defaulter(args_t[0], args_t[1])\\n\\n if T_TO_S_FUNC_KEY not in template:\\n nori.core.cfg['templates'][i][T_TO_S_FUNC_KEY] = None\\n\\n if T_D_NO_REPL_KEY not in template:\\n nori.core.cfg['templates'][i][T_D_NO_REPL_KEY] = False\\n\\n if T_D_CHANGE_CB_KEY not in template:\\n nori.core.cfg['templates'][i][T_D_CHANGE_CB_KEY] = []\\n\\n if T_KEY_MODE_KEY not in template:\\n nori.core.cfg['templates'][i][T_KEY_MODE_KEY] = 'all'\\n\\n if T_KEY_LIST_KEY not in template:\\n nori.core.cfg['templates'][i][T_KEY_LIST_KEY] = []\",\n \"def apply_config_file(self, filename):\\n def extractor(template, options):\\n \\\"\\\"\\\"Ignore things that are existing non default values\\\"\\\"\\\"\\n for name, val in options:\\n normalised = self.normalise_key(name)\\n if normalised in self.values and not isinstance(self.values[normalised], Default):\\n continue\\n else:\\n yield name, val\\n\\n items = json.load(open(filename)).items()\\n self.use_options(items, extractor)\",\n \"def configuration():\",\n \"def update_config_file(invoker: AirflowInvoker) -> None:\\n airflow_cfg_path = invoker.files[\\\"config\\\"]\\n logging.debug(f\\\"Generated default '{str(airflow_cfg_path)}'\\\")\\n\\n # open the configuration and update it\\n # now we let's update the config to use our stubs\\n airflow_cfg = configparser.ConfigParser()\\n\\n with airflow_cfg_path.open() as cfg:\\n airflow_cfg.read_file(cfg)\\n logging.debug(f\\\"Loaded '{str(airflow_cfg_path)}'\\\")\\n\\n config = invoker.plugin_config_processed\\n for section, cfg in config.items():\\n airflow_cfg[section].update(cfg)\\n logging.debug(f\\\"\\\\tUpdated section [{section}] with {cfg}\\\")\\n\\n with airflow_cfg_path.open(\\\"w\\\") as cfg:\\n airflow_cfg.write(cfg)\\n logging.debug(f\\\"Saved '{str(airflow_cfg_path)}'\\\")\",\n \"def configure(self, section):\",\n \"def update(self):\\n self.save_config_file()\",\n \"def configure(self, config: dict):\\n self.config.update(config)\",\n \"def configure(self, config_name, action, contents):\\n config = self.default_config.copy()\\n config.update(contents)\\n\\n _log.debug(\\\"Configuring Agent\\\")\\n\\n try:\\n setting1 = int(config[\\\"setting1\\\"])\\n setting2 = config[\\\"setting2\\\"]\\n except ValueError as e:\\n _log.error(\\\"ERROR PROCESSING CONFIGURATION: {}\\\".format(e))\\n return\\n\\n for x in self.setting2:\\n self._create_subscriptions(str(x))\\n print(str(x))\",\n \"def apply_config(self, responsible, paths, arg=None):\\n self.warning(\\\"Reconfiguring NTP server (called with paths %s)\\\" % paths)\\n return self.updateRunningConf(responsible)\",\n \"def _auto_update_configuration(self) -> None:\\n self.config = rasa.utils.train_utils.update_confidence_type(self.config)\\n rasa.utils.train_utils.validate_configuration_settings(self.config)\\n self.config = rasa.utils.train_utils.update_similarity_type(self.config)\\n self.config = rasa.utils.train_utils.update_evaluation_parameters(self.config)\",\n \"def _configure_addon(self):\\n cfg = None\\n try:\\n data_dir = os.path.split(self.props.data_dir)\\n\\n cfg = Configuration(jobtype='Blender', \\n data_path=data_dir[0],\\n log_level=int(self.props.log_level),\\n name=self.props.ini_file,\\n datadir=data_dir[1])\\n \\n except (InvalidConfigException, IndexError) as exp:\\n self.log.warning(\\\"Warning failed to load config file, \\\"\\n \\\"creating new default config.\\\")\\n self.log.warning(str(exp))\\n \\n finally:\\n\\n if not os.path.isdir(self.props.data_dir):\\n raise EnvironmentError(\\\"Data directory not created - \\\"\\n \\\"please ensure you have adequate permissions.\\\")\\n\\n if not cfg:\\n cfg = Configuration(jobtype='Blender', log_level='warning')\\n\\n if self.props.endpoint:\\n cfg = override_config(cfg, endpoint=self.props.endpoint)\\n if self.props.account:\\n cfg = override_config(cfg, account=self.props.account)\\n if self.props.key:\\n cfg = override_config(cfg, key=self.props.key)\\n if self.props.client_id:\\n cfg = override_config(cfg, client_id=self.props.client_id)\\n if self.props.tenant:\\n cfg = override_config(cfg, tenant=self.props.tenant)\\n if self.props.redirect:\\n cfg = override_config(cfg, redirect=self.props.redirect)\\n\\n cfg.save_config()\\n return cfg\",\n \"def plugin_reconfigure(handle, new_config):\\n _LOGGER.info(\\\"Old config for Enviro pHAT plugin {} \\\\n new config {}\\\".format(handle, new_config))\\n new_handle = copy.deepcopy(new_config)\\n return new_handle\",\n \"def apply_config(self, config_path: str) -> None:\\n # pylint: disable=exec-used\\n try:\\n assert self._active_feature_set is None\\n type(self)._active_feature_set = self\\n\\n # Apply both src and dist spinoff configs.\\n exec_context: dict = {}\\n with open(config_path, encoding='utf-8') as infile:\\n config_contents = infile.read()\\n\\n # Use compile here so we can provide a nice file path for\\n # error tracebacks.\\n exec(\\n compile(config_contents, config_path, 'exec'),\\n exec_context,\\n exec_context,\\n )\\n\\n finally:\\n assert type(self)._active_feature_set is self\\n type(self)._active_feature_set = None\",\n \"def config():\",\n \"def config():\",\n \"def configure(self) -> None:\\n self._copy_repo_files()\\n self._install_plugins()\",\n \"def initialize_from_config(self):\\n self.__allow_in_code_blocks = self.plugin_configuration.get_boolean_property(\\n \\\"code_blocks\\\",\\n default_value=True,\\n )\",\n \"def set_lite_plugin_settings(\\n self, config_path: Path, plugin_id: str, settings: Dict[str, Any]\\n ) -> None:\\n whole_file = config = json.loads(config_path.read_text(**UTF8))\\n if config_path.name == JUPYTERLITE_IPYNB:\\n config = whole_file[\\\"metadata\\\"][JUPYTERLITE_METADATA]\\n\\n config.setdefault(JUPYTER_CONFIG_DATA, {}).setdefault(\\n LITE_PLUGIN_SETTINGS, {}\\n ).update({plugin_id: settings})\\n\\n config_path.write_text(json.dumps(whole_file, **JSON_FMT), **UTF8)\\n self.log.debug(\\\"%s wrote settings in %s: %s\\\", plugin_id, config_path, settings)\\n self.maybe_timestamp(config_path)\",\n \"def on_pre_build(self, config):\\n plugin_config = config['plugins']['encryptcontent'].config\\n # Check if global password is set on plugin configuration\\n if 'global_password' in config.keys():\\n global_password = self.config.get('global_password')\\n setattr(self, 'password', global_password)\\n # Check if prefix title is set on plugin configuration to overwrite\\n title_prefix = plugin_config.get('title_prefix')\\n setattr(self, 'title_prefix', title_prefix)\\n # Check if summary description is set on plugin configuration to overwrite\\n summary = plugin_config.get('summary')\\n setattr(self, 'summary', summary)\\n # Check if placeholder description is set on plugin configuration to overwrite\\n placeholder = plugin_config.get('placeholder')\\n setattr(self, 'placeholder', placeholder)\\n # Check if decryption_failure_message description is set on plugin configuration to overwrite\\n decryption_failure_message = plugin_config.get('decryption_failure_message')\\n setattr(self, 'decryption_failure_message', decryption_failure_message)\\n # Check if encryption_info_message description is set on plugin configuration to overwrite\\n encryption_info_message = plugin_config.get('encryption_info_message')\\n setattr(self, 'encryption_info_message', encryption_info_message)\\n # Check if hljs feature need to be enabled, based on theme configuration\\n setattr(self, 'hljs', None)\\n if 'highlightjs' in config['theme']._vars:\\n highlightjs = config['theme']._vars['highlightjs'] \\n if highlightjs:\\n setattr(self, 'hljs', highlightjs)\\n # Check if pymdownx.arithmatex feature need to be enabled, based on markdown_extensions configuration\\n setattr(self, 'arithmatex', None)\\n if 'pymdownx.arithmatex' in config['markdown_extensions']:\\n setattr(self, 'arithmatex', True)\\n # Check if tag_encrypted_page feature is enable: add an extra attribute `encrypted` is add on page object\\n setattr(self, 'tag_encrypted_page', False)\\n if 'tag_encrypted_page' in plugin_config.keys():\\n tag_encrypted_page = self.config.get('tag_encrypted_page')\\n setattr(self, 'tag_encrypted_page', tag_encrypted_page)\\n # Check if cookie_password feature is enable: create a cookie for automatic decryption\\n setattr(self, 'remember_password', False)\\n setattr(self, 'disable_cookie_protection', False)\\n if 'remember_password' in plugin_config.keys():\\n remember_password = self.config.get('remember_password')\\n setattr(self, 'remember_password', remember_password)\\n # Check if cookie protection is disable *not good idea*: remove cookie flag 'Secure' & 'sameStie'\\n setattr(self, 'disable_cookie_protection', False)\\n if 'disable_cookie_protection' in plugin_config.keys():\\n disable_cookie_protection = self.config.get('disable_cookie_protection')\\n setattr(self, 'disable_cookie_protection', disable_cookie_protection)\\n # Check if password_button feature is enable: Add button to trigger decryption process\\n if 'password_button' in plugin_config.keys():\\n password_button = plugin_config.get('password_button')\\n setattr(self, 'password_button', password_button)\\n # Check if password_button_text description is set on plugin configuration to overwrite\\n if 'password_button_text' in plugin_config.keys():\\n password_button_text = plugin_config.get('password_button_text')\\n setattr(self, 'password_button_text', password_button_text)\\n # Check if encrypted_something feature is enable: encrypt each other html tags targets\\n setattr(self, 'encrypted_something', {})\\n if 'encrypted_something' in plugin_config.keys():\\n encrypted_something = self.config.get('encrypted_something')\\n setattr(self, 'encrypted_something', encrypted_something)\",\n \"def configure(self):\",\n \"def configure(self):\",\n \"def configure(self):\",\n \"def configure(self):\",\n \"def edit_cass_conf(self, out, plugin_instance):\\n if config.DEBUG:\\n filepath = '{conf_dir}/{conf_name}'.format(\\n conf_dir=config.PLUGIN_CONF_DIR,\\n conf_name=self.conf_name)\\n else:\\n filepath = '{app_dir}/{conf_dir}/{conf_name}'.format(\\n app_dir=config.APP_DIR,\\n conf_dir=config.PLUGIN_CONF_DIR,\\n conf_name=self.conf_name)\\n\\n try:\\n with open(filepath) as cfile:\\n for line in cfile:\\n url_re = re.search(\\n r'ServiceURL \\\"CHANGE_THIS\\\"', line)\\n if url_re is None:\\n out.write(line)\\n else:\\n out.write(plugin_instance)\\n except (IOError, OSError) as e:\\n utils.eprint('Cannot open {}'.format(filepath))\\n raise Exception(\\n 'Error: {}\\\\n'\\n 'Cannot open {}.'.format(e, filepath))\",\n \"def override_config(self, config_path):\\n self.config = p_config.ProsperConfig(config_path)\",\n \"def setup_configuration_file(self):\\n\\n with open(self.config_path, \\\"w+\\\") as f_config:\\n\\n f_config.write(get_configuration_file_form())\",\n \"def apply_user_configuration(self, config):\\n self.logDisplay.set_logging_level(config['log'].get('logging_level', fallback='Verbose'))\\n\\n # MIDI\\n self.winchMidiInputCombo.select_item(config['midi'].get('winch_midi_input', fallback='<no selection>'))\\n self.midiOutputCombo.select_item(config['midi'].get('midi_output', fallback='<no selection>'))\\n\\n # OSC\\n oscdef = config['osc']\\n self.oscListenerConfig.set_OSC_port(oscdef.get('listener_addr', fallback='localhost'),\\n oscdef.getint('listener_port', fallback=3751))\\n\\n self.oscSenderConfig.set_OSC_port(oscdef.get('sender_addr', fallback='localhost'),\\n oscdef.getint('sender_port', fallback=3752))\\n\\n # DMX\\n self.dmxSelect.select_item(config['dmx'].get('dmx_output_serial_port', fallback='<no selection>'))\\n\\n # winches\\n for i, winchSelect in enumerate(self.winchSelects):\\n key = \\\"winch_%d_output_serial_port\\\" % (i+1)\\n winchSelect.select_item(config['winches'].get(key, fallback = '<no selection>'))\\n return\",\n \"async def _configure_plugins(self) -> None:\\n logger.debug('Configuring plugins')\\n funcs = [\\n info['plugin'].configure(\\n config=info['config'],\\n session=self._session,\\n router=self.app.router\\n )\\n for info in self._plugins.values()\\n ]\\n\\n if funcs:\\n await asyncio.gather(*funcs, loop=self._loop)\\n logger.debug('Plugins configured')\",\n \"def setup_config(self, args=None):\\n self.config_parse(args=args)\",\n \"def apply_settings():\\n\\n scs_globals = _get_scs_globals()\\n\\n # avoid recursion if another apply settings is running already\\n if scs_globals.config_update_lock:\\n return False\\n\\n # NOTE: save file paths in extra variables and apply them on the end\\n # to make sure all of the settings are loaded first.\\n # This is needed as some libraries reading are driven by other values from config file.\\n # For example: \\\"use_infixed\\\"\\n scs_project_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.scs_project_path, scs_globals)\\n shader_presets_filepath = _property_utils.get_by_type(bpy.types.GlobalSCSProps.shader_presets_filepath, scs_globals)\\n trigger_actions_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.trigger_actions_rel_path, scs_globals)\\n sign_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.sign_library_rel_path, scs_globals)\\n tsem_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.tsem_library_rel_path, scs_globals)\\n traffic_rules_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.traffic_rules_library_rel_path, scs_globals)\\n hookup_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.hookup_library_rel_path, scs_globals)\\n matsubs_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.matsubs_library_rel_path, scs_globals)\\n sun_profiles_library_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.sun_profiles_lib_path, scs_globals)\\n conv_hlpr_converters_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.conv_hlpr_converters_path, scs_globals)\\n\\n # NOTE: as dump level is written in same section as config type\\n # applying it directly might take place before we get information about config type\\n # so it has to be saved into variable and applied only if global settings are loaded from config file\\n dump_level = scs_globals.dump_level\\n\\n # lock update now, as we don't want any properties update functions to trigger rewrite of config file\\n # which would lead to unwanted recursion\\n engage_config_lock()\\n\\n config_container = _pix.get_data_from_file(get_config_filepath(), \\\" \\\")\\n\\n # avoid applying process of config if not present (most probably permission problems on config creation)\\n if config_container is not None:\\n\\n settings_file_valid = 0\\n for section in config_container:\\n if settings_file_valid == 2:\\n if section.type == \\\"Paths\\\":\\n for prop in section.props:\\n if prop[0] in (\\\"\\\", \\\"#\\\"):\\n pass\\n elif prop[0] == \\\"ProjectPath\\\":\\n scs_project_path = prop[1]\\n elif prop[0] == \\\"ShaderPresetsFilePath\\\":\\n shader_presets_filepath = prop[1]\\n elif prop[0] == \\\"TriggerActionsRelFilePath\\\":\\n trigger_actions_rel_path = prop[1]\\n elif prop[0] == \\\"TriggerActionsUseInfixed\\\":\\n scs_globals.trigger_actions_use_infixed = prop[1]\\n elif prop[0] == \\\"SignRelFilePath\\\":\\n sign_library_rel_path = prop[1]\\n elif prop[0] == \\\"SignUseInfixed\\\":\\n scs_globals.sign_library_use_infixed = prop[1]\\n elif prop[0] == \\\"TSemProfileRelFilePath\\\":\\n tsem_library_rel_path = prop[1]\\n elif prop[0] == \\\"TSemProfileUseInfixed\\\":\\n scs_globals.tsem_library_use_infixed = prop[1]\\n elif prop[0] == \\\"TrafficRulesRelFilePath\\\":\\n traffic_rules_library_rel_path = prop[1]\\n elif prop[0] == \\\"TrafficRulesUseInfixed\\\":\\n scs_globals.traffic_rules_library_use_infixed = prop[1]\\n elif prop[0] == \\\"HookupRelDirPath\\\":\\n hookup_library_rel_path = prop[1]\\n elif prop[0] == \\\"MatSubsRelFilePath\\\":\\n matsubs_library_rel_path = prop[1]\\n elif prop[0] == \\\"SunProfilesFilePath\\\":\\n sun_profiles_library_path = prop[1]\\n elif prop[0] == \\\"ConvertersPath\\\":\\n conv_hlpr_converters_path = prop[1]\\n elif prop[0] == \\\"UseAlternativeBases\\\":\\n scs_globals.use_alternative_bases = prop[1]\\n else:\\n lprint('W Unrecognised item \\\"%s\\\" has been found in setting file! Skipping...', (str(prop[0]),))\\n elif section.type == \\\"Import\\\":\\n for prop in section.props:\\n if prop[0] in (\\\"\\\", \\\"#\\\"):\\n pass\\n elif prop[0] == \\\"ImportScale\\\":\\n scs_globals.import_scale = float(prop[1])\\n elif prop[0] == \\\"PreservePathForExport\\\":\\n scs_globals.import_preserve_path_for_export = prop[1]\\n elif prop[0] == \\\"ImportPimFile\\\":\\n scs_globals.import_pim_file = prop[1]\\n elif prop[0] == \\\"UseWelding\\\":\\n scs_globals.import_use_welding = prop[1]\\n elif prop[0] == \\\"WeldingPrecision\\\":\\n scs_globals.import_welding_precision = prop[1]\\n elif prop[0] == \\\"UseNormals\\\":\\n scs_globals.import_use_normals = prop[1]\\n elif prop[0] == \\\"ImportPitFile\\\":\\n scs_globals.import_pit_file = prop[1]\\n elif prop[0] == \\\"LoadTextures\\\":\\n scs_globals.import_load_textures = prop[1]\\n elif prop[0] == \\\"ImportPicFile\\\":\\n scs_globals.import_pic_file = prop[1]\\n elif prop[0] == \\\"ImportPipFile\\\":\\n scs_globals.import_pip_file = prop[1]\\n elif prop[0] == \\\"ImportPisFile\\\":\\n scs_globals.import_pis_file = prop[1]\\n elif prop[0] == \\\"ConnectedBones\\\":\\n scs_globals.import_connected_bones = prop[1]\\n elif prop[0] == \\\"BoneImportScale\\\":\\n scs_globals.import_bone_scale = float(prop[1])\\n elif prop[0] == \\\"ImportPiaFile\\\":\\n scs_globals.import_pia_file = prop[1]\\n elif prop[0] == \\\"IncludeSubdirsForPia\\\":\\n scs_globals.import_include_subdirs_for_pia = prop[1]\\n elif section.type == \\\"Export\\\":\\n for prop in section.props:\\n if prop[0] in (\\\"\\\", \\\"#\\\"):\\n pass\\n elif prop[0] == \\\"ExportScale\\\":\\n scs_globals.export_scale = float(prop[1])\\n elif prop[0] == \\\"ApplyModifiers\\\":\\n scs_globals.export_apply_modifiers = prop[1]\\n elif prop[0] == \\\"ExcludeEdgesplit\\\":\\n scs_globals.export_exclude_edgesplit = prop[1]\\n elif prop[0] == \\\"IncludeEdgesplit\\\":\\n scs_globals.export_include_edgesplit = prop[1]\\n elif prop[0] == \\\"ActiveUVOnly\\\":\\n scs_globals.export_active_uv_only = prop[1]\\n elif prop[0] == \\\"ExportVertexGroups\\\":\\n scs_globals.export_vertex_groups = prop[1]\\n elif prop[0] == \\\"ExportVertexColor\\\":\\n scs_globals.export_vertex_color = prop[1]\\n elif prop[0] == \\\"ExportVertexColorType\\\":\\n scs_globals.export_vertex_color_type = str(prop[1])\\n elif prop[0] == \\\"ExportVertexColorType7\\\":\\n scs_globals.export_vertex_color_type_7 = str(prop[1])\\n elif prop[0] == \\\"ExportPimFile\\\":\\n scs_globals.export_pim_file = prop[1]\\n elif prop[0] == \\\"OutputType\\\":\\n scs_globals.export_output_type = prop[1]\\n elif prop[0] == \\\"ExportPitFile\\\":\\n scs_globals.export_pit_file = prop[1]\\n elif prop[0] == \\\"ExportPicFile\\\":\\n scs_globals.export_pic_file = prop[1]\\n elif prop[0] == \\\"ExportPipFile\\\":\\n scs_globals.export_pip_file = prop[1]\\n elif prop[0] == \\\"SignExport\\\":\\n scs_globals.export_write_signature = prop[1]\\n elif section.type == \\\"GlobalDisplay\\\":\\n for prop in section.props:\\n if prop[0] in (\\\"\\\", \\\"#\\\"):\\n pass\\n elif prop[0] == \\\"DisplayLocators\\\":\\n scs_globals.display_locators = prop[1]\\n elif prop[0] == \\\"LocatorSize\\\":\\n scs_globals.locator_size = float(prop[1])\\n elif prop[0] == \\\"LocatorEmptySize\\\":\\n scs_globals.locator_empty_size = float(prop[1])\\n elif prop[0] == \\\"DisplayConnections\\\":\\n scs_globals.display_connections = prop[1]\\n elif prop[0] == \\\"CurveSegments\\\":\\n scs_globals.curve_segments = prop[1]\\n elif prop[0] == \\\"OptimizedConnsDrawing\\\":\\n scs_globals.optimized_connections_drawing = prop[1]\\n elif prop[0] == \\\"DisplayTextInfo\\\":\\n scs_globals.display_info = prop[1]\\n else:\\n lprint('W Unrecognised item \\\"%s\\\" has been found in setting file! Skipping...', (str(prop[0]),))\\n elif section.type == \\\"GlobalColors\\\":\\n for prop in section.props:\\n if prop[0] in (\\\"\\\", \\\"#\\\"):\\n pass\\n elif prop[0] == \\\"PrefabLocatorsWire\\\":\\n scs_globals.locator_prefab_wire_color = prop[1]\\n elif prop[0] == \\\"ModelLocatorsWire\\\":\\n scs_globals.locator_model_wire_color = prop[1]\\n elif prop[0] == \\\"ColliderLocatorsWire\\\":\\n scs_globals.locator_coll_wire_color = prop[1]\\n elif prop[0] == \\\"ColliderLocatorsFace\\\":\\n scs_globals.locator_coll_face_color = prop[1]\\n elif prop[0] == \\\"NavigationCurveBase\\\":\\n scs_globals.np_connection_base_color = prop[1]\\n elif prop[0] == \\\"MapLineBase\\\":\\n scs_globals.mp_connection_base_color = prop[1]\\n elif prop[0] == \\\"TriggerLineBase\\\":\\n scs_globals.tp_connection_base_color = prop[1]\\n elif prop[0] == \\\"InfoText\\\":\\n scs_globals.info_text_color = prop[1]\\n elif prop[0] == \\\"BasePaint\\\":\\n scs_globals.base_paint_color = prop[1]\\n else:\\n lprint('W Unrecognised item \\\"%s\\\" has been found in setting file! Skipping...', (str(prop[0]),))\\n elif section.type == \\\"Header\\\":\\n for prop in section.props:\\n if prop[0] == \\\"FormatVersion\\\":\\n if prop[1] == 1:\\n settings_file_valid += 1\\n elif prop[0] == \\\"Type\\\":\\n if prop[1] == \\\"Configuration\\\":\\n settings_file_valid += 1\\n elif prop[0] == \\\"DumpLevel\\\":\\n dump_level = prop[1]\\n elif prop[0] == \\\"ConfigStoragePlace\\\":\\n scs_globals.config_storage_place = prop[1]\\n\\n # if settings are read directly from blend file,\\n # release update lock and don't search/apply any settings further\\n if prop[1] == \\\"BlendFile\\\":\\n settings_file_valid += 1\\n\\n # as dump level can be read already (it can be placed above config storage place property),\\n # reset local variable back to value that was saved with blend file\\n dump_level = scs_globals.dump_level\\n\\n break # to avoid further reading of header properties, so dump_level won't be overwritten unintentionally\\n\\n scs_globals.dump_level = dump_level\\n\\n # now as last apply all of the file paths\\n # NOTE: applying paths is crucial for libraries\\n # (they are reloaded/initiated in property update functions).\\n if bpy.app.background: # if blender runs without UI then apply libraries directly as async operator is UI depended\\n\\n scs_globals.scs_project_path = scs_project_path\\n scs_globals.shader_presets_filepath = shader_presets_filepath\\n scs_globals.trigger_actions_rel_path = trigger_actions_rel_path\\n scs_globals.sign_library_rel_path = sign_library_rel_path\\n scs_globals.tsem_library_rel_path = tsem_library_rel_path\\n scs_globals.traffic_rules_library_rel_path = traffic_rules_library_rel_path\\n scs_globals.hookup_library_rel_path = hookup_library_rel_path\\n scs_globals.matsubs_library_rel_path = matsubs_library_rel_path\\n scs_globals.sun_profiles_lib_path = sun_profiles_library_path\\n scs_globals.conv_hlpr_converters_path = conv_hlpr_converters_path\\n\\n else: # if blender is started normally use asynchronous operator to reload libraries\\n\\n bpy.ops.world.scs_paths_initialization('INVOKE_DEFAULT', paths_list=[\\n {\\\"name\\\": \\\"project base path\\\", \\\"attr\\\": \\\"scs_project_path\\\", \\\"path\\\": scs_project_path},\\n {\\\"name\\\": \\\"shader presets\\\", \\\"attr\\\": \\\"shader_presets_filepath\\\", \\\"path\\\": shader_presets_filepath},\\n {\\\"name\\\": \\\"trigger actions library\\\", \\\"attr\\\": \\\"trigger_actions_rel_path\\\", \\\"path\\\": trigger_actions_rel_path},\\n {\\\"name\\\": \\\"sign library\\\", \\\"attr\\\": \\\"sign_library_rel_path\\\", \\\"path\\\": sign_library_rel_path},\\n {\\\"name\\\": \\\"traffic semaphore library\\\", \\\"attr\\\": \\\"tsem_library_rel_path\\\", \\\"path\\\": tsem_library_rel_path},\\n {\\\"name\\\": \\\"traffic rules library\\\", \\\"attr\\\": \\\"traffic_rules_library_rel_path\\\", \\\"path\\\": traffic_rules_library_rel_path},\\n {\\\"name\\\": \\\"hookups library\\\", \\\"attr\\\": \\\"hookup_library_rel_path\\\", \\\"path\\\": hookup_library_rel_path},\\n {\\\"name\\\": \\\"material substance library\\\", \\\"attr\\\": \\\"matsubs_library_rel_path\\\", \\\"path\\\": matsubs_library_rel_path},\\n {\\\"name\\\": \\\"sun profiles library\\\", \\\"attr\\\": \\\"sun_profiles_lib_path\\\", \\\"path\\\": sun_profiles_library_path},\\n {\\\"name\\\": \\\"converters file path\\\", \\\"attr\\\": \\\"conv_hlpr_converters_path\\\", \\\"path\\\": conv_hlpr_converters_path},\\n ])\\n\\n # release lock as properties are applied\\n release_config_lock(use_paths_init_callback=not bpy.app.background)\\n\\n return True\",\n \"def config_init(self):\\n\\n game_opts = [\\n\\n # Execution Options\\n ('debug',False), # Toggle Debug Messaging\\n ('log_path',False), # Turn on logging (w/path)\\n ('log_lvl',logging.DEBUG), # Set log level\\n\\n # World Generation Options\\n ('flex_limit',3) # Sets the maximum variance\\n\\n ]\\n\\n # Attempts to pull each value from the configuration\\n # if not in config, the default value defined above\\n # is set instead\\n for opt in game_opts:\\n try:\\n setattr(self,opt[0],self.conf.conf_dict[opt[0]])\\n except:\\n setattr(self,opt[0],opt[1])\\n continue\",\n \"def updateSettings(self):\\n self.parser.read(self.file)\\n self.showTicker = self.parser.getboolean('Settings', 'showTicker')\\n self.verbose = self.parser.getboolean('Settings', 'verbose')\\n self.sleepTime = self.parser.getint('Settings', 'sleeptime')\\n self.saveGraph = self.parser.getboolean('Settings', 'saveGraph')\\n self.graphDPI = self.parser.getint('Settings', 'graphDPI')\",\n \"def configure(self, options, config):\\n Plugin.configure(self, options, config)\\n self.config = config\\n if self.enabled:\\n self.jinja = Environment(\\n loader=FileSystemLoader(os.path.join(os.path.dirname(__file__), 'templates')),\\n trim_blocks=True,\\n lstrip_blocks=True\\n )\\n self.stats = {'errors': 0, 'failures': 0, 'passes': 0, 'skipped': 0}\\n self.report_data = defaultdict(Group)\\n self.report_file = codecs.open(options.html_file, 'w', self.encoding, 'replace')\",\n \"def configure(self):\\n pass\",\n \"def configure(self):\\n pass\",\n \"def config( **kwargs ):\",\n \"def __writeConfig(self):\\n page = None\\n\\n #TODO: get values of configurations here\\n particles = \\\"#f\\\" if not base.particleMgrEnabled else \\\"#t\\\"\\n volume = str(round(base.musicManager.getVolume(), 2))\\n mute = \\\"#f\\\" if base.AppHasAudioFocus else \\\"#t\\\"\\n #TODO: add any configuration variable name that you have added\\n customConfigVariables = [\\n \\\"\\\", \\\"particles-enabled\\\", \\\"audio-mute\\\", \\\"audio-volume\\\"]\\n if os.path.exists(prcFile):\\n # open the config file and change values according to current\\n # application settings\\n page = loadPrcFile(Filename.fromOsSpecific(prcFile))\\n removeDecls = []\\n for dec in range(page.getNumDeclarations()):\\n # Check if our variables are given.\\n # NOTE: This check has to be done to not loose our base or other\\n # manual config changes by the user\\n if page.getVariableName(dec) in customConfigVariables:\\n decl = page.modifyDeclaration(dec)\\n removeDecls.append(decl)\\n for dec in removeDecls:\\n page.deleteDeclaration(dec)\\n # NOTE: particles-enabled and audio-mute are custom variables and\\n # have to be loaded by hand at startup\\n # Particles\\n page.makeDeclaration(\\\"particles-enabled\\\", particles)\\n # audio\\n page.makeDeclaration(\\\"audio-volume\\\", volume)\\n page.makeDeclaration(\\\"audio-mute\\\", mute)\\n else:\\n # Create a config file and set default values\\n cpMgr = ConfigPageManager.getGlobalPtr()\\n page = cpMgr.makeExplicitPage(\\\"%s Pandaconfig\\\"%appName)\\n # set OpenGL to be the default\\n page.makeDeclaration(\\\"load-display\\\", \\\"pandagl\\\")\\n # get the displays width and height\\n w = self.pipe.getDisplayWidth()\\n h = self.pipe.getDisplayHeight()\\n # set the window size in the config file\\n page.makeDeclaration(\\\"win-size\\\", \\\"%d %d\\\"%(w, h))\\n # set the default to fullscreen in the config file\\n page.makeDeclaration(\\\"fullscreen\\\", \\\"1\\\")\\n # particles\\n page.makeDeclaration(\\\"particles-enabled\\\", \\\"#t\\\")\\n # audio\\n page.makeDeclaration(\\\"audio-volume\\\", volume)\\n page.makeDeclaration(\\\"audio-mute\\\", \\\"#f\\\")\\n # create a stream to the specified config file\\n configfile = OFileStream(prcFile)\\n # and now write it out\\n page.write(configfile)\\n # close the stream\\n configfile.close()\",\n \"def configure_settings(settings):\\r\\n if not 'PATH' in settings or not os.path.isdir(settings['PATH']):\\r\\n raise Exception('You need to specify a path containing the content'\\r\\n ' (see pelican --help for more information)')\\r\\n\\r\\n # specify the log messages to be ignored\\r\\n LimitFilter.ignore.update(set(settings.get('LOG_FILTER',\\r\\n DEFAULT_CONFIG['LOG_FILTER'])))\\r\\n\\r\\n # lookup the theme in \\\"pelican/themes\\\" if the given one doesn't exist\\r\\n if not os.path.isdir(settings['THEME']):\\r\\n theme_path = os.path.join(\\r\\n os.path.dirname(os.path.abspath(__file__)),\\r\\n 'themes',\\r\\n settings['THEME'])\\r\\n if os.path.exists(theme_path):\\r\\n settings['THEME'] = theme_path\\r\\n else:\\r\\n raise Exception(\\\"Could not find the theme %s\\\"\\r\\n % settings['THEME'])\\r\\n\\r\\n # make paths selected for writing absolute if necessary\\r\\n settings['WRITE_SELECTED'] = [\\r\\n os.path.abspath(path) for path in\\r\\n settings.get('WRITE_SELECTED', DEFAULT_CONFIG['WRITE_SELECTED'])\\r\\n ]\\r\\n\\r\\n # standardize strings to lowercase strings\\r\\n for key in [\\r\\n 'DEFAULT_LANG',\\r\\n ]:\\r\\n if key in settings:\\r\\n settings[key] = settings[key].lower()\\r\\n\\r\\n # standardize strings to lists\\r\\n for key in [\\r\\n 'LOCALE',\\r\\n ]:\\r\\n if key in settings and isinstance(settings[key], six.string_types):\\r\\n settings[key] = [settings[key]]\\r\\n\\r\\n # check settings that must be a particular type\\r\\n for key, types in [\\r\\n ('OUTPUT_SOURCES_EXTENSION', six.string_types),\\r\\n ('FILENAME_METADATA', six.string_types),\\r\\n ]:\\r\\n if key in settings and not isinstance(settings[key], types):\\r\\n value = settings.pop(key)\\r\\n logger.warn(\\r\\n 'Detected misconfigured {} ({}), '\\r\\n 'falling back to the default ({})'.format(\\r\\n key, value, DEFAULT_CONFIG[key]))\\r\\n\\r\\n # try to set the different locales, fallback on the default.\\r\\n locales = settings.get('LOCALE', DEFAULT_CONFIG['LOCALE'])\\r\\n\\r\\n for locale_ in locales:\\r\\n try:\\r\\n locale.setlocale(locale.LC_ALL, str(locale_))\\r\\n break # break if it is successful\\r\\n except locale.Error:\\r\\n pass\\r\\n else:\\r\\n logger.warning(\\\"LOCALE option doesn't contain a correct value\\\")\\r\\n\\r\\n if ('SITEURL' in settings):\\r\\n # If SITEURL has a trailing slash, remove it and provide a warning\\r\\n siteurl = settings['SITEURL']\\r\\n if (siteurl.endswith('/')):\\r\\n settings['SITEURL'] = siteurl[:-1]\\r\\n logger.warning(\\\"Removed extraneous trailing slash from SITEURL.\\\")\\r\\n # If SITEURL is defined but FEED_DOMAIN isn't,\\r\\n # set FEED_DOMAIN to SITEURL\\r\\n if not 'FEED_DOMAIN' in settings:\\r\\n settings['FEED_DOMAIN'] = settings['SITEURL']\\r\\n\\r\\n # check content caching layer and warn of incompatibilities\\r\\n if (settings.get('CACHE_CONTENT', False) and\\r\\n settings.get('CONTENT_CACHING_LAYER', '') == 'generator' and\\r\\n settings.get('WITH_FUTURE_DATES', DEFAULT_CONFIG['WITH_FUTURE_DATES'])):\\r\\n logger.warning('WITH_FUTURE_DATES conflicts with '\\r\\n \\\"CONTENT_CACHING_LAYER set to 'generator', \\\"\\r\\n \\\"use 'reader' layer instead\\\")\\r\\n\\r\\n # Warn if feeds are generated with both SITEURL & FEED_DOMAIN undefined\\r\\n feed_keys = [\\r\\n 'FEED_ATOM', 'FEED_RSS',\\r\\n 'FEED_ALL_ATOM', 'FEED_ALL_RSS',\\r\\n 'CATEGORY_FEED_ATOM', 'CATEGORY_FEED_RSS',\\r\\n 'AUTHOR_FEED_ATOM', 'AUTHOR_FEED_RSS',\\r\\n 'TAG_FEED_ATOM', 'TAG_FEED_RSS',\\r\\n 'TRANSLATION_FEED_ATOM', 'TRANSLATION_FEED_RSS',\\r\\n ]\\r\\n\\r\\n if any(settings.get(k) for k in feed_keys):\\r\\n if not settings.get('SITEURL'):\\r\\n logger.warning('Feeds generated without SITEURL set properly may'\\r\\n ' not be valid')\\r\\n\\r\\n if not 'TIMEZONE' in settings:\\r\\n logger.warning(\\r\\n 'No timezone information specified in the settings. Assuming'\\r\\n ' your timezone is UTC for feed generation. Check '\\r\\n 'http://docs.getpelican.com/en/latest/settings.html#timezone '\\r\\n 'for more information')\\r\\n\\r\\n # fix up pagination rules\\r\\n from pelican.paginator import PaginationRule\\r\\n pagination_rules = [\\r\\n PaginationRule(*r) for r in settings.get(\\r\\n 'PAGINATION_PATTERNS',\\r\\n DEFAULT_CONFIG['PAGINATION_PATTERNS'],\\r\\n )\\r\\n ]\\r\\n settings['PAGINATION_PATTERNS'] = sorted(\\r\\n pagination_rules,\\r\\n key=lambda r: r[0],\\r\\n )\\r\\n\\r\\n # Save people from accidentally setting a string rather than a list\\r\\n path_keys = (\\r\\n 'ARTICLE_EXCLUDES',\\r\\n 'DEFAULT_METADATA',\\r\\n 'DIRECT_TEMPLATES',\\r\\n 'EXTRA_TEMPLATES_PATHS',\\r\\n 'FILES_TO_COPY',\\r\\n 'IGNORE_FILES',\\r\\n 'JINJA_EXTENSIONS',\\r\\n 'PAGINATED_DIRECT_TEMPLATES',\\r\\n 'PLUGINS',\\r\\n 'STATIC_PATHS',\\r\\n 'THEME_STATIC_PATHS',\\r\\n )\\r\\n for PATH_KEY in filter(lambda k: k in settings, path_keys):\\r\\n if isinstance(settings[PATH_KEY], six.string_types):\\r\\n logger.warning(\\\"Detected misconfiguration with %s setting \\\"\\r\\n \\\"(must be a list), falling back to the default\\\"\\r\\n % PATH_KEY)\\r\\n settings[PATH_KEY] = DEFAULT_CONFIG[PATH_KEY]\\r\\n\\r\\n for old, new, doc in [\\r\\n ('LESS_GENERATOR', 'the Webassets plugin', None),\\r\\n ('FILES_TO_COPY', 'STATIC_PATHS and EXTRA_PATH_METADATA',\\r\\n 'https://github.com/getpelican/pelican/blob/master/docs/settings.rst#path-metadata'),\\r\\n ]:\\r\\n if old in settings:\\r\\n message = 'The {} setting has been removed in favor of {}'.format(\\r\\n old, new)\\r\\n if doc:\\r\\n message += ', see {} for details'.format(doc)\\r\\n logger.warning(message)\\r\\n\\r\\n return settings\",\n \"def configure(self):\\r\\n pass\",\n \"def config(ctx):\\n return\",\n \"def configure(self, options, config):\\n Plugin.configure(self, options, config)\\n self.config = config\\n if self.enabled:\\n self.xunitstream = globalxunitstream\\n self.xunitstats = globalxunitstats\\n for i in range(4):\\n self.xunitstats[i] = 0\\n self.xunit_file = options.xunit_file\\n self.xunit_header = options.xunit_header\",\n \"def configure(self) -> None:\",\n \"def __import(self):\\n configured_plugins = self.config.get('plugins', {}).copy()\\n plugin_module_files = self.__find_plugin_modules(configured_plugins)\\n self.__initialize_plugins(configured_plugins, plugin_module_files)\",\n \"def write_plugin(config: Config) -> Config:\\n with open(config.path, \\\"r\\\") as input_file:\\n lines = input_file.read().split(\\\"\\\\n\\\")\\n\\n lines_computed = []\\n\\n ignore_lines = False\\n id_section = False\\n\\n for line in lines:\\n # id section\\n if line.startswith(\\\"#----begin_id_section----\\\"):\\n id_section = True\\n\\n lines_computed.append(COMMENT_PYTHON + PREFIX)\\n\\n continue\\n\\n if line.startswith(\\\"#----end_id_section----\\\"):\\n id_section = False\\n\\n continue\\n\\n if id_section:\\n if line.startswith(\\\"#\\\"):\\n continue\\n\\n if not line:\\n continue\\n\\n variables = [x.strip() for x in line.split(\\\"=\\\")]\\n\\n if variables:\\n variable_name = variables[0]\\n\\n lines_computed.append(\\n \\\"{} = {}\\\".format(\\n variable_name,\\n getattr(config.module, variable_name)\\n )\\n )\\n\\n continue\\n\\n # skip bootstrap4c4d lines\\n if line.startswith(\\\"#----begin\\\"):\\n ignore_lines = True\\n\\n continue\\n\\n if line.startswith(\\\"#----end\\\"):\\n ignore_lines = False\\n\\n continue\\n\\n if not ignore_lines:\\n lines_computed.append(line)\\n\\n compiled_plugin_file = os.path.join(\\n config.destination, \\\"{}.pyp\\\".format(config.name)\\n )\\n\\n assert_directories(compiled_plugin_file, True)\\n\\n with open(compiled_plugin_file, \\\"w\\\") as output_file:\\n output_file.write(\\\"\\\\n\\\".join(lines_computed))\\n\\n return config\",\n \"def process_config(self, filename):\\n \\n self.log_message(\\\"processing config file: \\\"+filename)\\n parser = SafeConfigParser()\\n parser.optionxform = str\\n parser.read(filename)\\n self.source_files[filename] = parser\\n \\n sections = parser.sections()\\n for section in sections:\\n \\n options = parser.options(section)\\n params = {}\\n non_std = {}\\n for option in options:\\n ## any option that ends with the word \\\"password\\\" will be encrypted and will automatically be decrypted upon\\n ## processing \\n if option in self.standard_options:\\n params[option] = self.get_value(option, parser.get(section, option))\\n else:\\n non_std[option] = self.get_value(option, parser.get(section, option))\\n\\n params['non_std'] = non_std\\n params['source_file'] = filename\\n params['name']=section\\n params['run_date']=self.run_date\\n c_entry = ConfigEntry(params)\\n if c_entry.ready: \\n entry_num = c_entry.get_entry_type()\\n self.entries[self.entry_types[entry_num]].append(c_entry)\\n self.entry_dict[section] = {'source':filename,'entry':c_entry}\\n self.log_message(\\\"Loaded Config Entry: \\\"+section)\\n else:\\n self.log_message(\\\"Failed to load config entry: \\\"+section)\\n\\n return self.entries\",\n \"def configure(self):\\n\\n pass\",\n \"def configfile(self, fp):\\n if not self.modifier.skip_configfile:\\n if os.path.exists(fp):\\n self.configfiles.append(fp)\\n c = snakemake.io.load_configfile(fp)\\n update_config(self.config, c)\\n if self.overwrite_config:\\n logger.info(\\n \\\"Config file {} is extended by additional config specified via the command line.\\\".format(\\n fp\\n )\\n )\\n update_config(self.config, self.overwrite_config)\\n elif not self.overwrite_configfiles:\\n fp_full = os.path.abspath(fp)\\n raise WorkflowError(\\n f\\\"Workflow defines configfile {fp} but it is not present or accessible (full checked path: {fp_full}).\\\"\\n )\\n else:\\n # CLI configfiles have been specified, do not throw an error but update with their values\\n update_config(self.config, self.overwrite_config)\",\n \"def initialize_from_config(self):\",\n \"def main(args):\\n\\n with open(args.cfg_fn, 'r') as cfg_fd:\\n config = cfg_fd.read().split(\\\"\\\\n\\\")\\n\\n with open(args.opt_fn, 'r') as opt_fd:\\n for oline in opt_fd:\\n option, value = oline.strip().split(\\\"=\\\")\\n\\n conf_addition = \\\"%s=%s\\\" % (option, value)\\n added = False\\n for line_nr, line in enumerate(config):\\n if \\\"# %s is not set\\\" % option in line or \\\\\\n \\\"%s=\\\" % option in line:\\n config[line_nr] = conf_addition\\n added = True\\n break\\n\\n if not added:\\n config.append(conf_addition)\\n\\n with open(args.cfg_fn, 'w') as cfg_fd:\\n cfg_fd.write(\\\"\\\\n\\\".join(config))\",\n \"def run(self):\\n write_config(self.filename)\\n print('Wrote default config to', self.filename)\",\n \"def init_config(self):\\n super().init_config()\\n for param in self.parameters():\\n if param.name == 'source':\\n continue\\n self.add_config_item(param.name,\\n saver=lambda p=param: getattr(p, \\\"value\\\"),\\n loader=lambda x, p=param: setattr(p, \\\"value\\\", x),\\n default=param.default)\",\n \"def _overwrite_with_config(self, new_cfg):\\n for section in new_cfg.sections():\\n for key, val in new_cfg.items(section):\\n self.config.set(section, key, val)\",\n \"def _apply_settings(self):\\n if 'fixed_delta_seconds' in self.dict_settings:\\n self.settings.fixed_delta_seconds = self.dict_settings['fixed_delta_seconds']\\n\\n self.world.apply_settings(self.settings)\",\n \"def _configure(self):\\n pass\",\n \"def change_settings(new_settings={}, file=None):\\n gl = globals()\\n if file is not None:\\n execfile(file)\\n gl.update(locals())\\n gl.update(new_settings)\\n # Here you can add some code to check that the new configuration\\n # values are valid.\",\n \"def parse(self, config_file):\\n\\t\\tself.options = yaml.load(open(config_file))\",\n \"def configure(self, options):\\n if 'config_file' in options and options['config_file']:\\n path = options['config_file']\\n if not ( os.path.isfile(path) and os.access(path, os.R_OK) ):\\n self.__logger.error('Configuration file does not exist or is not readable')\\n return False\\n try:\\n if not self.cp.read(path):\\n raise configparser.Error('Unable to load from configuration file')\\n except configparser.Error as e:\\n self.__logger.error('Unable to load from configuration file : %s', str(e).replace('\\\\n', ''))\\n return False\\n\\n self.__logger.debug('advanced configuration successfully loaded')\\n return True\",\n \"def conf(config_file):\\n\\n global cf\\n\\n cf_parser = SafeConfigParser()\\n\\n # etc dir at the same level of the bin dir containing this script\\n close_etc_path = os.path.realpath( os.path.realpath(os.path.dirname(__file__)) + \\\"/../etc\\\" )\\n\\n # Try to open configuration file (read() can get a list of files as well)\\n conf_file_ok = True\\n if len(cf_parser.read(config_file)) == 0:\\n logging.warning(\\\"Cannot read configuration file %s\\\" % config_file)\\n conf_file_ok = False\\n\\n for sec_name,sec_content in cf.iteritems():\\n\\n for key,val in sec_content.iteritems():\\n\\n try:\\n new_val = cf_parser.get(sec_name, key) # --> [sec_name]\\n try:\\n new_val = float(new_val)\\n except ValueError:\\n pass\\n cf[sec_name][key] = new_val\\n logging.info(\\\"Configuration: %s.%s = %s (from file)\\\", sec_name, key, str(new_val))\\n except Exception, e:\\n logging.info(\\\"Configuration: %s.%s = %s (default)\\\", sec_name, key, str(val))\\n\\n return conf_file_ok\",\n \"def load_config(self):\\n pass\",\n \"def _set_config():\\n\\n\\tdebug_msg = \\\"load default config yaml file\\\"\\n\\tlogger.debug(debug_msg)\\n\\n\\tconfig_file_parser(paths.CONFIG_FILE, override_options=True)\",\n \"def update_conf_file():\\n filepath = remote_dir + \\\"/apache2/conf/httpd.conf\\\"\\n fabric.contrib.files.sed(filepath, 'myproject', project_name)\",\n \"def config(self):\\n pass\",\n \"def config(self):\\n pass\",\n \"def configure(self, *args):\\n raise NotImplementedError(self, \\\"configure\\\")\",\n \"def run_plugin():\\n # load config\\n config = load_config()\\n all_resources = []\\n\\n # load placeholders\\n if config.placeholders:\\n placeholders = config.placeholders\\n else:\\n placeholders = {}\\n if config.placeholders_file:\\n placeholders.update(parse_dotenv(config.placeholders_file))\\n\\n for resource in yaml.safe_load_all(sys.stdin.read()):\\n is_resource_match, resource_metadata = c.resource_match_selectors(resource, config.resource_selectors)\\n if is_resource_match:\\n for key, value in resource.items():\\n # secret is a special case\\n if(resource_metadata['kind'] == 'Secret'):\\n if 'data' in resource:\\n resource['data'] = c.perform_placeholder_replacements(resource['data'], PLACEHOLDER_PROG, c.get_default_replacement_func(placeholders), True)\\n if 'tls' in resource:\\n resource['tls'] = c.perform_placeholder_replacements(resource['tls'], PLACEHOLDER_PROG, c.get_default_replacement_func(placeholders), True)\\n # exclude these top-level fields from placeholder replacement\\n elif key not in ('apiVersion', 'kind', 'metadata'):\\n resource[key] = c.perform_placeholder_replacements(value, PLACEHOLDER_PROG, c.get_default_replacement_func(placeholders), False)\\n\\n all_resources.append(resource)\\n yaml.dump_all(all_resources, sys.stdout, default_flow_style=False)\",\n \"def load_settings_from_file(self, cfg_file):\\n \\n #\\n #\\n # TODO\\n # Missing settings should not cause exceptions\\n #\\n #\\n #\\n\\n if not os.path.exists(cfg_file): \\n raise Exception('Provided config file [%s] does not exist or cannot be read.' % cfg_file)\\n\\n import ConfigParser\\n config = ConfigParser.ConfigParser()\\n config.read(cfg_file)\\n \\n \\n self.reference_root = config.get('Paths','reference-root')\\n \\n self.scratch_root = os.getcwd()\\n try:\\n self.scratch_root = config.get('Paths','scratch-root')\\n except ConfigParser.NoOptionError:\\n self.logger.info('Scratch-root setting is missing. Using current directory: %s' % self.scratch_root)\\n\\n\\n if (self.run_folder != None):\\n self.run_id = os.path.basename(self.run_folder)\\n else:\\n raise Exception('Set runfolder with PipelineConfig.set_runfolder() before loading settings')\\n \\n \\n #\\n # TODO\\n # needs to be updated on update of settings\\n #\\n self.runs_scratch_dir = os.path.join(self.scratch_root, self.run_id) if self.run_folder != None else self.scratch_root\\n self.logger.info('Run\\\\'s scratch directory: %s' % self.runs_scratch_dir)\\n \\n # optional results and fastq archive dirs \\n self.results_archive = None\\n try:\\n self.results_archive = config.get('Paths','results-archive')\\n except ConfigParser.NoOptionError:\\n self.logger.info('No results-archive provided. Results will not be archived outside of the run\\\\'s scratch directory.')\\n \\n self.fastq_archive = None\\n try:\\n self.fastq_archive = config.get('Paths','fastq-archive')\\n except ConfigParser.NoOptionError:\\n self.logger.info('No fastq-archive provided. Fastq files will not be archived outside of the run\\\\'s scratch directory.')\\n \\n \\n # optional /tmp dir\\n self.tmp_dir = '/tmp'\\n try:\\n self.tmp_dir = config.get('Paths','tmp-dir')\\n except ConfigParser.NoOptionError:\\n self.logger.info('No tmp-dir provided. /tmp will be used.')\\n \\n \\n \\n \\n # reference files\\n self.reference = os.path.join(self.reference_root, config.get('Resources','reference-genome'))\\n self.capture = os.path.join(self.reference_root, config.get('Resources','capture-regions-bed'))\\n self.capture_qualimap = os.path.join(self.reference_root, config.get('Resources','capture-regions-bed-for-qualimap'))\\n self.capture_plus = os.path.join(self.reference_root, config.get('Resources', 'capture-plus-regions-bed'))\\n self.gene_coordinates = os.path.join(self.reference_root, config.get('Resources', 'gene-coordinates'))\\n \\n self.adapters = os.path.join(self.reference_root, config.get('Resources', 'adapters-fasta'))\\n \\n # tools\\n self.bcl2fastq = config.get('Tools','bcl2fastq')\\n self.trimmomatic = config.get('Tools','trimmomatic') \\n self.bwa = config.get('Tools','bwa')\\n self.samtools = config.get('Tools','samtools')\\n self.picard = config.get('Tools','picard')\\n self.gatk = config.get('Tools','gatk')\\n self.freebayes = config.get('Tools','freebayes')\\n self.bcftools = config.get('Tools','bcftools')\\n self.qualimap = config.get('Tools','qualimap')\\n \\tself.fastqc\\t = config.get('Tools','fastqc')\\n\\n\\n # annovar settings\\n self.convert_to_annovar = os.path.join(config.get('Annovar','annovar_home'), \\n config.get('Annovar','convert_to_annovar'))\\n self.annovar_annotate = os.path.join(config.get('Annovar','annovar_home'),\\n config.get('Annovar','annovar_annotate'))\\n self.table_annovar = os.path.join(config.get('Annovar','annovar_home'), \\n config.get('Annovar','table_annovar'))\\n self.annovar_human_db = os.path.join(config.get('Annovar','annovar_home'),\\n config.get('Annovar','annovar_human_db'))\\n self.annovar_1000genomes_eur = config.get('Annovar','annovar_1000genomes_eur')\\n self.annovar_1000genomes_eur_maf_cutoff = config.get('Annovar','annovar_1000genomes_eur_maf_cutoff')\\n self.annovar_inhouse_dbs = config.get('Annovar','annovar_inhouse_dbs')\\n self.omim_gene_phenotype_map_file = config.get('Annovar','omim_gene_phenotype_map_file')\",\n \"def applyOptions(self, options_file):\\n self.settings.res_width = self.res_width.text()\\n self.settings.res_height = self.res_height.text()\\n \\n self.settings.writeSettingsToFile(options_file)\\n self.button_apply.setEnabled(False)\\n\\n self.parent.resize(int(self.settings.res_width),int(self.settings.res_height))\",\n \"def parse_config(self):\\n # TODO: parse config file\\n pass\",\n \"def edit_cfg(config_file):\\n\\n GUI().cfgEditor(config_file)\",\n \"def change_pwds(config):\\n if not config:\\n click.echo(help_msg)\\n return\\n try:\\n user_config = imp.load_source('config', config)\\n except IOError as e:\\n click.echo(\\\"File %s not found.\\\" % config)\\n logger.error(\\\"Invalid path to config file: %s\\\" % e)\\n except Exception as e:\\n click.echo(\\\"Ooups. Something went wrong.\\\")\\n click.echo(e)\\n logger.critical(\\\"%s\\\" % e)\\n else:\\n for i in dir(config_f):\\n if not i.startswith(\\\"__\\\"):\\n try:\\n user_config.__dict__[i]\\n except KeyError:\\n user_config.__dict__[i] = config_f.__dict__[i]\\n handle_exceptions(main, user_config)\",\n \"def pyang_plugin_init():\\n plugin.register_plugin(OpenConfigPlugin())\",\n \"def widget_load_config(self, plugman):\\r\\n pass\",\n \"def update_config(self, config):\\n # add follower public folder to the CKAN's list of public folders\\n here = os.path.dirname(__file__)\\n public_dir = os.path.join(here, 'public')\\n if config.get('extra_public_paths'):\\n config['extra_public_paths'] += ',' + public_dir\\n else:\\n config['extra_public_paths'] = public_dir\\n # add follower template folder to the CKAN's list of template folders\\n template_dir = os.path.join(here, 'templates')\\n if config.get('extra_template_paths'):\\n config['extra_template_paths'] += ',' + template_dir\\n else:\\n config['extra_template_paths'] = template_dir\",\n \"def config(self, config_dict):\\r\\n self._cfg.config = config_dict\",\n \"def config():\\n config_django()\\n config_svisor()\",\n \"def update_config(config_file, config_base=None):\\n if config_base is None:\\n config_base = def_config_file\\n assert(os.path.isfile(config_base))\\n if not os.path.isfile(config_file):\\n shutil.copy(config_base, config_file)\\n cp = CisConfigParser()\\n cp.read(config_file)\\n miss = []\\n if platform._is_win: # pragma: windows\\n miss += update_config_windows(cp)\\n with open(config_file, 'w') as fd:\\n cp.write(fd)\\n for sect, opt, desc in miss: # pragma: windows\\n warnings.warn((\\\"Could not locate option %s in section %s.\\\"\\n + \\\"Please set this in %s to: %s\\\")\\n % (opt, sect, config_file, desc))\",\n \"def load_configuration(self) -> None:\\n config_file = self.default_config_file\\n if self.config_file:\\n config_file = self.config_file\\n self.config = configparser.ConfigParser(delimiters=\\\"=\\\")\\n # mypy is unhappy with us assigning to a method - (monkeypatching?)\\n self.config.optionxform = lambda option: option # type: ignore\\n self.config.read(config_file)\",\n \"def __update(self):\\n if self.__file:\\n target_file = open(self.__file)\\n for attr in dir(self):\\n if not attr.startswith(\\\"_\\\") and \\\\\\n (self.__overwrite or (attr not in self.__exclude)) \\\\\\n and not self.__is_attr_callable(attr):\\n try:\\n delattr(self, attr)\\n except AttributeError:\\n pass\\n pool = yaml.load(target_file)\\n target_file.close()\\n if pool: # could be None\\n for key, val in pool.iteritems():\\n if not key.startswith(\\\"_\\\") and \\\\\\n (self.__overwrite or (key not in self.__exclude)) \\\\\\n and not self.__is_attr_callable(key):\\n setattr(self, key, val)\\n if hasattr(self, 'log_config_file_changes')\\\\\\n and self.log_config_file_changes:\\n logging.getLogger(__name__).info(\\\"Config file has updated.\\\")\",\n \"def config(self, **kw):\\n group = kw.pop('group', None)\\n for k, v in kw.items():\\n CONF.set_override(k, v, group)\",\n \"async def settings(self, ctx: BBContext):\\n pass\",\n \"def configure(**kw):\\n from . import conf\\n for key, value in kw.items(): \\n getattr(conf, key)\\n setattr(conf, key, value)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67779297","0.6747643","0.66346806","0.6428851","0.6423092","0.6381086","0.63534784","0.6292545","0.62646264","0.6239537","0.6237905","0.6227397","0.6210529","0.6172642","0.61720854","0.6128758","0.60786307","0.6069815","0.60622776","0.6050749","0.6043863","0.60065943","0.599283","0.59613764","0.5952286","0.59340423","0.5918914","0.59161264","0.591283","0.59114","0.59094065","0.59008026","0.5895109","0.5895109","0.5885051","0.58844596","0.5880512","0.5874457","0.5865933","0.5865933","0.5865933","0.5865933","0.58481574","0.58338547","0.5829485","0.582138","0.5819514","0.58051944","0.58048004","0.5796261","0.5784915","0.5770211","0.575435","0.575435","0.5748124","0.5743484","0.5741276","0.5728136","0.5713867","0.57058364","0.56981856","0.569807","0.56827044","0.5681759","0.56718624","0.5663207","0.56483686","0.5646552","0.5637152","0.5630069","0.5626966","0.5626623","0.5625695","0.5625559","0.5625367","0.5619644","0.56051475","0.56045157","0.55955905","0.5588799","0.5578894","0.5578894","0.55764514","0.5572091","0.55681247","0.5561316","0.5560077","0.555623","0.55524725","0.5543819","0.5537003","0.5527336","0.55237585","0.5518663","0.5513903","0.55106646","0.5504373","0.5497974","0.5491736","0.549052"],"string":"[\n \"0.67779297\",\n \"0.6747643\",\n \"0.66346806\",\n \"0.6428851\",\n \"0.6423092\",\n \"0.6381086\",\n \"0.63534784\",\n \"0.6292545\",\n \"0.62646264\",\n \"0.6239537\",\n \"0.6237905\",\n \"0.6227397\",\n \"0.6210529\",\n \"0.6172642\",\n \"0.61720854\",\n \"0.6128758\",\n \"0.60786307\",\n \"0.6069815\",\n \"0.60622776\",\n \"0.6050749\",\n \"0.6043863\",\n \"0.60065943\",\n \"0.599283\",\n \"0.59613764\",\n \"0.5952286\",\n \"0.59340423\",\n \"0.5918914\",\n \"0.59161264\",\n \"0.591283\",\n \"0.59114\",\n \"0.59094065\",\n \"0.59008026\",\n \"0.5895109\",\n \"0.5895109\",\n \"0.5885051\",\n \"0.58844596\",\n \"0.5880512\",\n \"0.5874457\",\n \"0.5865933\",\n \"0.5865933\",\n \"0.5865933\",\n \"0.5865933\",\n \"0.58481574\",\n \"0.58338547\",\n \"0.5829485\",\n \"0.582138\",\n \"0.5819514\",\n \"0.58051944\",\n \"0.58048004\",\n \"0.5796261\",\n \"0.5784915\",\n \"0.5770211\",\n \"0.575435\",\n \"0.575435\",\n \"0.5748124\",\n \"0.5743484\",\n \"0.5741276\",\n \"0.5728136\",\n \"0.5713867\",\n \"0.57058364\",\n \"0.56981856\",\n \"0.569807\",\n \"0.56827044\",\n \"0.5681759\",\n \"0.56718624\",\n \"0.5663207\",\n \"0.56483686\",\n \"0.5646552\",\n \"0.5637152\",\n \"0.5630069\",\n \"0.5626966\",\n \"0.5626623\",\n \"0.5625695\",\n \"0.5625559\",\n \"0.5625367\",\n \"0.5619644\",\n \"0.56051475\",\n \"0.56045157\",\n \"0.55955905\",\n \"0.5588799\",\n \"0.5578894\",\n \"0.5578894\",\n \"0.55764514\",\n \"0.5572091\",\n \"0.55681247\",\n \"0.5561316\",\n \"0.5560077\",\n \"0.555623\",\n \"0.55524725\",\n \"0.5543819\",\n \"0.5537003\",\n \"0.5527336\",\n \"0.55237585\",\n \"0.5518663\",\n \"0.5513903\",\n \"0.55106646\",\n \"0.5504373\",\n \"0.5497974\",\n \"0.5491736\",\n \"0.549052\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7636843"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21984,"cells":{"query":{"kind":"string","value":"Used to display the basic/home page for logged in user."},"document":{"kind":"string","value":"def view_profile(request, user_id=None):\r\n\r\n requesting_user = request.user\r\n\r\n if user_id:\r\n requested_user = get_object_or_404(User, pk=user_id)\r\n else:\r\n requested_user = requesting_user\r\n\r\n profile = Profile.objects.for_user(requested_user)\r\n\r\n datasets = DataSet.objects.active().filter(creator=requested_user).order_by('-created_at')\r\n projects = Project.objects.active().filter(creator=requested_user).order_by('-created_at')\r\n datarequests = \\\r\n DataRequest.objects.active(). \\\r\n filter(creator=requested_user). \\\r\n exclude(status='C'). \\\r\n order_by('-created_at')\r\n\r\n render_to_response_data = {\r\n 'datarequests': datarequests,\r\n 'datasets': datasets,\r\n 'profile': profile,\r\n 'projects': projects\r\n }\r\n\r\n return render_to_response(\r\n 'core/view_profile.html',\r\n render_to_response_data,\r\n context_instance=RequestContext(request))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def home():\n\n # sets the page to load depending on the type of user\n # if none specified the login screen will be displayed\n pageName = ''\n userType = session.get('UserType', None)\n if userType == None:\n pageName = 'anonHome.jade'\n elif userType == 'Seeker':\n pageName = 'indexJob.jade'\n elif userType == 'Manager':\n pageName = 'indexManager.jade'\n\n frogHop = url_for('static', filename='loop frog.gif')\n uName = session.get('UserName', 'Unknown') # load a default value if retrieval fails\n return render_template(\n pageName,\n title='Home',\n name=uName,\n getFrog=frogHop,\n year=datetime.now().year,\n )","def index(self):\n\n # try and pull the user's data\n user = get_active_user_data()\n\n if not user:\n # they are not logged in give them the login form\n return render('/login_form.html')\n\n # they are logged in, pass them to the home page\n redirect('/')","def get(self):\n if self.user:\n self.render('welcome.html', username = self.user.name)\n else:\n self.redirect('/signup')","def get(self):\n if self.logged_in:\n self.render('home.html', {\n 'name': self.current_user.name,\n 'server': self.current_user.server,\n 'faction': factions.get(self.current_user.faction),\n 'home': True,\n 'page_id': 'home'\n })\n else:\n self.render('home.html', {\n 'servers': servers,\n 'factions': factions,\n 'destination_url': '/settings',\n 'home': True,\n 'page_id': 'home'\n })","def get(self):\n user = self.get_active_user()\n if user:\n self.render_newpage(user=user)\n else:\n self.redirect('/login')","def home_page():\n if not g.user:\n flash(\"Please login to view.\", \"warning\")\n return redirect('/login')\n return render_template('index.html')","def home(request):\n if request.user.is_authenticated():\n domain = request.get_host()\n profile_picture = request.user.default_profile_picture\n full_name = request.user.full_name\n phone_number = request.user.phone_number\n context = {\n 'domain': domain,\n 'profile_picture': profile_picture,\n 'full_name': full_name,\n 'phone_number': phone_number,\n }\n return render(request, 'home.html', context)\n return render(request, 'home.html', {})","def home(result=None):\n print(inspect.stack()[1][3])\n\n if not session.get('logged_in') and not result:\n return render_template('login.html')\n else:\n # Based on the user_id passed, print Details, URLS and all.\n # return render_template('dashboard.html', username=result.name, user_id=result.user_type)\n return render_template('webpage/index1.html', username=result.name, user_id=result.user_type)","def homepage():\n if g.user:\n return redirect(f\"/user/{g.user.id}\")\n else:\n return redirect(\"/landing\")","def index():\n is_admin = dbhandler.is_admin(current_user())\n return render_template('./welcome.html', username=current_user(), is_admin=is_admin)","def user_home(request, user_name):\n query = User.objects.filter(username=user_name)\n if query.count() == 0:\n raise Http404(\"Can't find a user named: %s\" % user_name)\n else:\n user = query[0]\n if UserProfile.objects.filter(user=user):\n user_profile = UserProfile.objects.filter(user=user)[0]\n groups = get_user_groups(user)\n return render_to_response('user_home.html', locals())","def home(request):\n if request.user.is_authenticated:\n return redirect('/start')\n return render(request, 'home/home.html')","def user_homepage(user_id):\n\n # prevents the public for accessing user specific information\n if not session.get(\"user_id\") or session[\"user_id\"] != user_id:\n return redirect(\"/\")\n\n # retreiving user id and all moods and activities to be able to use in a form\n user = User.query.get(user_id)\n moods = Mood.query.all()\n activities = Activity_Category.query.all()\n\n # generating today's date to display on the page\n now = datetime.datetime.today().strftime(\"%A, %B %d, %Y\")\n\n # query to find all brain dumps\n brain_dumps = User_Brain_Dump.query.filter_by(user_id=user.user_id).all()\n\n return render_template(\n \"user-homepage.html\",\n user=user,\n moods=moods,\n activities=activities,\n now=now,\n brain_dumps=brain_dumps,\n )","def home(request):\n assert isinstance(request, HttpRequest)\n iscapable =False\n if request.user.username in get_librarians():\n iscapable=True;\n\n return render(\n request,\n 'app/index.html',\n {\n 'title':'Home Page',\n 'iscapable':iscapable,\n 'year':datetime.now().year,\n }\n )","def home():\n if not session.get('logged_in'):\n return redirect(url_for('welcome'))\n return render_template('home.html', filename=\"yarg.jpg\")","def home(request):\n if request.user.is_authenticated():\n return HttpResponseRedirect('done')\n else:\n return render_to_response('home.html', RequestContext(request))","def index():\n if current_user.is_authenticated:\n return redirect(url_for('home'))\n return render_template('index.html')","def home(request):\n if request.user.is_authenticated():\n return HttpResponseRedirect('logged-in')\n else:\n home_view = 1\n return render_to_response('content/home.html', {'version': version, \"home_view\":home_view},\n RequestContext(request))","def home():\n session_id = request.args.get('session-id', None)\n user_id = request.args.get('user-id', None)\n if check_authentication(session_id, user_id):\n return render_template('home.html', cars_list=get_cars_preview(), news_list=get_news_list(), user=user_id,\n session_id=session_id, authjs=True, preview_length=get_cars_preview().__len__())\n else:\n return render_template('home.html', cars_list=get_cars_preview(), news_list=get_news_list(), authjs=True,\n preview_length=get_cars_preview().__len__(), del_session_cookie=True)","def homepage():\n\treturn render_template(\"home/a_homepage.html\", title=\"Welcome\")","def welcome(self):\n if self.user:\n return self.render('welcome.html')\n self.redirect('/register')","def home():\n\n\treturn render_template('index.html', title='Home Page',\n\t\t\t\t\t\t year=datetime.now().year)","def home(request):\n\treturn render(request, \"compta/home.html\")","def home_page(request):\r\n return render(request, 'ez_main/home_page.html')","def home():\n return render_template('home.html',\n face=session.get(app.config['SESSION_KEY'], None))","def homepage(request):\n\treturn render(request, 'core/homepage.html')","def home():\n # if session.get('username'):\n # return redirect(url_for('categories'))\n # else:\n return render_template('home.html')","def index():\n if (session_get_int(\"user_id\") is not None):\n return render_template(\"dashboard.html\")\n else:\n return render_template(\"index.html\")","def home():\n return render_template(\n 'index.html',\n title='Automation Center',\n year=datetime.now().year,\n message='Welcome to the Automation Center'\n )","def home():\n return render_template(\n 'home.html',\n title='Home Page',\n year=datetime.now().year,\n )","def show_home_page():\n\n login_form = LoginForm()\n # create register form instance to go in modal\n register_form = UserAddForm()\n\n # handle login form validation\n if login_form.validate_on_submit():\n email = login_form.email.data\n password = login_form.password.data\n\n user = User.authenticate(email, password)\n\n # handle use case for a user being returned with valid password entered\n if user and user != 'invalid password':\n do_login(user)\n flash(f'Hello, {user.username}!', 'secondary')\n return render_template('home.html', user=user)\n # handle invalid password entry\n elif user == 'invalid password':\n login_form.password.errors = [\"Incorrect Password.\"]\n return render_template('home_anon.html', login_form=login_form, register_form=register_form)\n # handle user being not found\n else:\n login_form.email.errors = [\n 'Invalid Credentials. Please check email/password and try again']\n return render_template('home_anon.html', login_form=login_form, register_form=register_form)\n if CURRENT_USER_KEY in session:\n user = User.query.get(session[CURRENT_USER_KEY])\n if user:\n return render_template('home.html', user=user, home_active='active')\n\n # redirect to sign in page if no user is logged in\n\n return render_template('home_anon.html', login_form=login_form, register_form=register_form, img_cls='hidden')","def home():\n\n return render_template('home_page.html')","def home(request):\n return render(request, 'users/dashboard.html')","def home():\r\n return render_template(\r\n 'index.html',\r\n title='Home Page',\r\n year=datetime.now().year,\r\n )","def display_homepage(user_id):\n\n user_inv = (UserInv.query.filter_by(user_id=user_id)).all()\n\n return render_template('user-homepage.html',\n user_inv=user_inv)","def a_homepage():\n\n\treturn render_template('home/a_homepage.html', title=\"Homepage Admin\")","def home():\n\n\treturn render_template('solai.html')","def home():\n return render_template('login.html')","def home(request):\n return render_template('core/home.html')","def show_index():\r\n if 'username' in flask.session:\r\n return flask.redirect(flask.url_for('home')) # Need to fix redirect\r\n\r\n return flask.render_template(\"index.html\")","def home(request):\n if request.user.is_authenticated():\n return HttpResponse(\"{0} <a href='/accounts/logout'>exit</a>\".format(request.user))\n else:\n return HttpResponse(\"<a href='/login/vk-oauth2/'>login with VK</a>\")","def root():\n users = Record.query.all() # SQL equivalent: `SELECT * FROM user;\n return render_template(\"base.html\", title='Home', users=users)","def user():\r\n return render_base_template(\"user.html\", user=current_user)","def homepage(request):\n return render_to_response('h1ds_core/homepage.html', \n context_instance=RequestContext(request))","def homepage():\n return render_template(\"home/index.html\", title=\"Welcome\")","def homepage():\n return render_template('home/index.html', title=\"Welcome\")","def homepage():\n return render_template('home/index.html', title=\"Welcome\")","def root(request):\n\n return render(request, 'users/index.html')","def index(request):\n\n\tif request.user.is_authenticated:\n\t\treturn HttpResponseRedirect('home')\n\treturn HttpResponseRedirect('login')","def home():\n return render_template('home.html', title=\"Home\")","def homepage():\n return render_template('home/index.html', \n title=\"Bem vindo!\")","def home_page() -> str:\r\n return render_template(\"home.html\")","def home():\n return render_template('homepage.html')","def main():\n if 'username' in session:\n flash(f'Logged in as {session[\"username\"]}')\n else:\n flash('You are not logged in.')\n return render_template(\"main.html\", title=\"Main\")","def show_user_account_home():\n\n user = User.query.filter_by(user_id=int(session['user_id'])).one()\n print user\n\n return render_template(\"base.html\")\n # return render_template(\"user_account.html\", user_id=user.user_id, name=user.first_name)\n #, user_id=user.user_id, email=email, name=first_name)","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home(request):\n if request.user.is_authenticated:\n return render(request, 'wantedly_app/home.html')\n\n # Execute the below if the user is not authenticated.\n if request.method == 'POST':\n user = authenticate(username=request.POST['username'], password=request.POST['password'])\n\n # If the user exists in the DB,\n if user is not None:\n\n # If the user is active,\n if user.is_active:\n auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend')\n messages.add_message(request, messages.SUCCESS, 'ログインしました！')\n return redirect('home')\n\n # If the user is not active,\n else:\n messages.add_message(request, messages.ERROR, 'ユーザーのアクティベーションがまだ完了していません。')\n\n # If the user does not exists in the DB,\n else:\n messages.add_message(request, messages.ERROR, 'ログインに失敗しました。ユーザーが存在しないかパスワードが間違っています。')\n\n context = {'login_form': LoginForm()}\n return render(request, 'wantedly_app/top.html', context)","def user_home(request):\n # crop = Crop.objects.get(user=request.user)\n return render(request, 'user_home.html', locals())","def get(self):\n user = self.get_active_user()\n if not user:\n self.render(\"login_signupbase.html\",\n login=self.LOGIN_FORM,\n main_heading=self.MAIN_HEADING)\n else:\n self.render(\"redirect_in_8.html\",\n message=\"\"\"You are already signed in! <a href='/logout'>\n Log out</a> before signing in with a new\n account or return to the\n <a href='/'>front page</a>.\"\"\")","def home():\n\n return render_template(\"home.html\")","def about():\n session_id = request.args.get('session-id', None)\n user_id = request.args.get('user-id', None)\n if check_authentication(session_id, user_id):\n return render_template('about.html', user=user_id, session_id=session_id)\n else:\n return render_template('about.html')","def home(request):\n return render_to_response('home.html', {}, RequestContext(request))","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year\n )","def get(self):\n\n self.response.out.write(template.render('templates/home.html', None))","def user(self):\n try:\n data_definitions = self.get_data_definitions(current_user.scheme_id)\n user_data = self.get_all_user_data(current_user.scheme_id, current_user.k_number)\n\n return render_template(\"user/dashboard_page.html\", title=\"Your Profile\", user_data=user_data)\n\n except Exception as e:\n self._log.exception(\"Could not execute get user logic\")\n return abort(500)","def ShowLogin():\n current_user = helpers.get_current_user()\n if current_user is None:\n return render_template('login.html')\n else:\n return redirect('/')","def home():\n return render_template('Main_Page.html')","def home():\n return render_template(\"home.html\")","def home():\n return render_template(\"home.html\")","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home(request):\r\n return render(request, 'home.html')","def homepage():\n return render_template('home/index.html', title=\"Home\")","def home_page():\n return \"<h4>Welcome !</h4><br><a href='/fetch'>View Results</a>\"","def index(request):\n if request.user.is_authenticated:\n return redirect('/dashboard')\n else:\n context = {'client_id': settings.OPENHUMANS_CLIENT_ID,\n 'oh_proj_page': settings.OH_ACTIVITY_PAGE}\n\n return render(request, 'main/index.html', context=context)","def homepage():\n\n return render_template('rosemead_homepage.html')","def home(request):\n\n user = request.authenticated_userid\n return {'user': user}","def home(request):\n # if request.user.is_authenticated():\n # return redirect('/fastapp')\n return context()"],"string":"[\n \"def home():\\n\\n # sets the page to load depending on the type of user\\n # if none specified the login screen will be displayed\\n pageName = ''\\n userType = session.get('UserType', None)\\n if userType == None:\\n pageName = 'anonHome.jade'\\n elif userType == 'Seeker':\\n pageName = 'indexJob.jade'\\n elif userType == 'Manager':\\n pageName = 'indexManager.jade'\\n\\n frogHop = url_for('static', filename='loop frog.gif')\\n uName = session.get('UserName', 'Unknown') # load a default value if retrieval fails\\n return render_template(\\n pageName,\\n title='Home',\\n name=uName,\\n getFrog=frogHop,\\n year=datetime.now().year,\\n )\",\n \"def index(self):\\n\\n # try and pull the user's data\\n user = get_active_user_data()\\n\\n if not user:\\n # they are not logged in give them the login form\\n return render('/login_form.html')\\n\\n # they are logged in, pass them to the home page\\n redirect('/')\",\n \"def get(self):\\n if self.user:\\n self.render('welcome.html', username = self.user.name)\\n else:\\n self.redirect('/signup')\",\n \"def get(self):\\n if self.logged_in:\\n self.render('home.html', {\\n 'name': self.current_user.name,\\n 'server': self.current_user.server,\\n 'faction': factions.get(self.current_user.faction),\\n 'home': True,\\n 'page_id': 'home'\\n })\\n else:\\n self.render('home.html', {\\n 'servers': servers,\\n 'factions': factions,\\n 'destination_url': '/settings',\\n 'home': True,\\n 'page_id': 'home'\\n })\",\n \"def get(self):\\n user = self.get_active_user()\\n if user:\\n self.render_newpage(user=user)\\n else:\\n self.redirect('/login')\",\n \"def home_page():\\n if not g.user:\\n flash(\\\"Please login to view.\\\", \\\"warning\\\")\\n return redirect('/login')\\n return render_template('index.html')\",\n \"def home(request):\\n if request.user.is_authenticated():\\n domain = request.get_host()\\n profile_picture = request.user.default_profile_picture\\n full_name = request.user.full_name\\n phone_number = request.user.phone_number\\n context = {\\n 'domain': domain,\\n 'profile_picture': profile_picture,\\n 'full_name': full_name,\\n 'phone_number': phone_number,\\n }\\n return render(request, 'home.html', context)\\n return render(request, 'home.html', {})\",\n \"def home(result=None):\\n print(inspect.stack()[1][3])\\n\\n if not session.get('logged_in') and not result:\\n return render_template('login.html')\\n else:\\n # Based on the user_id passed, print Details, URLS and all.\\n # return render_template('dashboard.html', username=result.name, user_id=result.user_type)\\n return render_template('webpage/index1.html', username=result.name, user_id=result.user_type)\",\n \"def homepage():\\n if g.user:\\n return redirect(f\\\"/user/{g.user.id}\\\")\\n else:\\n return redirect(\\\"/landing\\\")\",\n \"def index():\\n is_admin = dbhandler.is_admin(current_user())\\n return render_template('./welcome.html', username=current_user(), is_admin=is_admin)\",\n \"def user_home(request, user_name):\\n query = User.objects.filter(username=user_name)\\n if query.count() == 0:\\n raise Http404(\\\"Can't find a user named: %s\\\" % user_name)\\n else:\\n user = query[0]\\n if UserProfile.objects.filter(user=user):\\n user_profile = UserProfile.objects.filter(user=user)[0]\\n groups = get_user_groups(user)\\n return render_to_response('user_home.html', locals())\",\n \"def home(request):\\n if request.user.is_authenticated:\\n return redirect('/start')\\n return render(request, 'home/home.html')\",\n \"def user_homepage(user_id):\\n\\n # prevents the public for accessing user specific information\\n if not session.get(\\\"user_id\\\") or session[\\\"user_id\\\"] != user_id:\\n return redirect(\\\"/\\\")\\n\\n # retreiving user id and all moods and activities to be able to use in a form\\n user = User.query.get(user_id)\\n moods = Mood.query.all()\\n activities = Activity_Category.query.all()\\n\\n # generating today's date to display on the page\\n now = datetime.datetime.today().strftime(\\\"%A, %B %d, %Y\\\")\\n\\n # query to find all brain dumps\\n brain_dumps = User_Brain_Dump.query.filter_by(user_id=user.user_id).all()\\n\\n return render_template(\\n \\\"user-homepage.html\\\",\\n user=user,\\n moods=moods,\\n activities=activities,\\n now=now,\\n brain_dumps=brain_dumps,\\n )\",\n \"def home(request):\\n assert isinstance(request, HttpRequest)\\n iscapable =False\\n if request.user.username in get_librarians():\\n iscapable=True;\\n\\n return render(\\n request,\\n 'app/index.html',\\n {\\n 'title':'Home Page',\\n 'iscapable':iscapable,\\n 'year':datetime.now().year,\\n }\\n )\",\n \"def home():\\n if not session.get('logged_in'):\\n return redirect(url_for('welcome'))\\n return render_template('home.html', filename=\\\"yarg.jpg\\\")\",\n \"def home(request):\\n if request.user.is_authenticated():\\n return HttpResponseRedirect('done')\\n else:\\n return render_to_response('home.html', RequestContext(request))\",\n \"def index():\\n if current_user.is_authenticated:\\n return redirect(url_for('home'))\\n return render_template('index.html')\",\n \"def home(request):\\n if request.user.is_authenticated():\\n return HttpResponseRedirect('logged-in')\\n else:\\n home_view = 1\\n return render_to_response('content/home.html', {'version': version, \\\"home_view\\\":home_view},\\n RequestContext(request))\",\n \"def home():\\n session_id = request.args.get('session-id', None)\\n user_id = request.args.get('user-id', None)\\n if check_authentication(session_id, user_id):\\n return render_template('home.html', cars_list=get_cars_preview(), news_list=get_news_list(), user=user_id,\\n session_id=session_id, authjs=True, preview_length=get_cars_preview().__len__())\\n else:\\n return render_template('home.html', cars_list=get_cars_preview(), news_list=get_news_list(), authjs=True,\\n preview_length=get_cars_preview().__len__(), del_session_cookie=True)\",\n \"def homepage():\\n\\treturn render_template(\\\"home/a_homepage.html\\\", title=\\\"Welcome\\\")\",\n \"def welcome(self):\\n if self.user:\\n return self.render('welcome.html')\\n self.redirect('/register')\",\n \"def home():\\n\\n\\treturn render_template('index.html', title='Home Page',\\n\\t\\t\\t\\t\\t\\t year=datetime.now().year)\",\n \"def home(request):\\n\\treturn render(request, \\\"compta/home.html\\\")\",\n \"def home_page(request):\\r\\n return render(request, 'ez_main/home_page.html')\",\n \"def home():\\n return render_template('home.html',\\n face=session.get(app.config['SESSION_KEY'], None))\",\n \"def homepage(request):\\n\\treturn render(request, 'core/homepage.html')\",\n \"def home():\\n # if session.get('username'):\\n # return redirect(url_for('categories'))\\n # else:\\n return render_template('home.html')\",\n \"def index():\\n if (session_get_int(\\\"user_id\\\") is not None):\\n return render_template(\\\"dashboard.html\\\")\\n else:\\n return render_template(\\\"index.html\\\")\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Automation Center',\\n year=datetime.now().year,\\n message='Welcome to the Automation Center'\\n )\",\n \"def home():\\n return render_template(\\n 'home.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def show_home_page():\\n\\n login_form = LoginForm()\\n # create register form instance to go in modal\\n register_form = UserAddForm()\\n\\n # handle login form validation\\n if login_form.validate_on_submit():\\n email = login_form.email.data\\n password = login_form.password.data\\n\\n user = User.authenticate(email, password)\\n\\n # handle use case for a user being returned with valid password entered\\n if user and user != 'invalid password':\\n do_login(user)\\n flash(f'Hello, {user.username}!', 'secondary')\\n return render_template('home.html', user=user)\\n # handle invalid password entry\\n elif user == 'invalid password':\\n login_form.password.errors = [\\\"Incorrect Password.\\\"]\\n return render_template('home_anon.html', login_form=login_form, register_form=register_form)\\n # handle user being not found\\n else:\\n login_form.email.errors = [\\n 'Invalid Credentials. Please check email/password and try again']\\n return render_template('home_anon.html', login_form=login_form, register_form=register_form)\\n if CURRENT_USER_KEY in session:\\n user = User.query.get(session[CURRENT_USER_KEY])\\n if user:\\n return render_template('home.html', user=user, home_active='active')\\n\\n # redirect to sign in page if no user is logged in\\n\\n return render_template('home_anon.html', login_form=login_form, register_form=register_form, img_cls='hidden')\",\n \"def home():\\n\\n return render_template('home_page.html')\",\n \"def home(request):\\n return render(request, 'users/dashboard.html')\",\n \"def home():\\r\\n return render_template(\\r\\n 'index.html',\\r\\n title='Home Page',\\r\\n year=datetime.now().year,\\r\\n )\",\n \"def display_homepage(user_id):\\n\\n user_inv = (UserInv.query.filter_by(user_id=user_id)).all()\\n\\n return render_template('user-homepage.html',\\n user_inv=user_inv)\",\n \"def a_homepage():\\n\\n\\treturn render_template('home/a_homepage.html', title=\\\"Homepage Admin\\\")\",\n \"def home():\\n\\n\\treturn render_template('solai.html')\",\n \"def home():\\n return render_template('login.html')\",\n \"def home(request):\\n return render_template('core/home.html')\",\n \"def show_index():\\r\\n if 'username' in flask.session:\\r\\n return flask.redirect(flask.url_for('home')) # Need to fix redirect\\r\\n\\r\\n return flask.render_template(\\\"index.html\\\")\",\n \"def home(request):\\n if request.user.is_authenticated():\\n return HttpResponse(\\\"{0} <a href='/accounts/logout'>exit</a>\\\".format(request.user))\\n else:\\n return HttpResponse(\\\"<a href='/login/vk-oauth2/'>login with VK</a>\\\")\",\n \"def root():\\n users = Record.query.all() # SQL equivalent: `SELECT * FROM user;\\n return render_template(\\\"base.html\\\", title='Home', users=users)\",\n \"def user():\\r\\n return render_base_template(\\\"user.html\\\", user=current_user)\",\n \"def homepage(request):\\n return render_to_response('h1ds_core/homepage.html', \\n context_instance=RequestContext(request))\",\n \"def homepage():\\n return render_template(\\\"home/index.html\\\", title=\\\"Welcome\\\")\",\n \"def homepage():\\n return render_template('home/index.html', title=\\\"Welcome\\\")\",\n \"def homepage():\\n return render_template('home/index.html', title=\\\"Welcome\\\")\",\n \"def root(request):\\n\\n return render(request, 'users/index.html')\",\n \"def index(request):\\n\\n\\tif request.user.is_authenticated:\\n\\t\\treturn HttpResponseRedirect('home')\\n\\treturn HttpResponseRedirect('login')\",\n \"def home():\\n return render_template('home.html', title=\\\"Home\\\")\",\n \"def homepage():\\n return render_template('home/index.html', \\n title=\\\"Bem vindo!\\\")\",\n \"def home_page() -> str:\\r\\n return render_template(\\\"home.html\\\")\",\n \"def home():\\n return render_template('homepage.html')\",\n \"def main():\\n if 'username' in session:\\n flash(f'Logged in as {session[\\\"username\\\"]}')\\n else:\\n flash('You are not logged in.')\\n return render_template(\\\"main.html\\\", title=\\\"Main\\\")\",\n \"def show_user_account_home():\\n\\n user = User.query.filter_by(user_id=int(session['user_id'])).one()\\n print user\\n\\n return render_template(\\\"base.html\\\")\\n # return render_template(\\\"user_account.html\\\", user_id=user.user_id, name=user.first_name)\\n #, user_id=user.user_id, email=email, name=first_name)\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home(request):\\n if request.user.is_authenticated:\\n return render(request, 'wantedly_app/home.html')\\n\\n # Execute the below if the user is not authenticated.\\n if request.method == 'POST':\\n user = authenticate(username=request.POST['username'], password=request.POST['password'])\\n\\n # If the user exists in the DB,\\n if user is not None:\\n\\n # If the user is active,\\n if user.is_active:\\n auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend')\\n messages.add_message(request, messages.SUCCESS, 'ログインしました！')\\n return redirect('home')\\n\\n # If the user is not active,\\n else:\\n messages.add_message(request, messages.ERROR, 'ユーザーのアクティベーションがまだ完了していません。')\\n\\n # If the user does not exists in the DB,\\n else:\\n messages.add_message(request, messages.ERROR, 'ログインに失敗しました。ユーザーが存在しないかパスワードが間違っています。')\\n\\n context = {'login_form': LoginForm()}\\n return render(request, 'wantedly_app/top.html', context)\",\n \"def user_home(request):\\n # crop = Crop.objects.get(user=request.user)\\n return render(request, 'user_home.html', locals())\",\n \"def get(self):\\n user = self.get_active_user()\\n if not user:\\n self.render(\\\"login_signupbase.html\\\",\\n login=self.LOGIN_FORM,\\n main_heading=self.MAIN_HEADING)\\n else:\\n self.render(\\\"redirect_in_8.html\\\",\\n message=\\\"\\\"\\\"You are already signed in! <a href='/logout'>\\n Log out</a> before signing in with a new\\n account or return to the\\n <a href='/'>front page</a>.\\\"\\\"\\\")\",\n \"def home():\\n\\n return render_template(\\\"home.html\\\")\",\n \"def about():\\n session_id = request.args.get('session-id', None)\\n user_id = request.args.get('user-id', None)\\n if check_authentication(session_id, user_id):\\n return render_template('about.html', user=user_id, session_id=session_id)\\n else:\\n return render_template('about.html')\",\n \"def home(request):\\n return render_to_response('home.html', {}, RequestContext(request))\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year\\n )\",\n \"def get(self):\\n\\n self.response.out.write(template.render('templates/home.html', None))\",\n \"def user(self):\\n try:\\n data_definitions = self.get_data_definitions(current_user.scheme_id)\\n user_data = self.get_all_user_data(current_user.scheme_id, current_user.k_number)\\n\\n return render_template(\\\"user/dashboard_page.html\\\", title=\\\"Your Profile\\\", user_data=user_data)\\n\\n except Exception as e:\\n self._log.exception(\\\"Could not execute get user logic\\\")\\n return abort(500)\",\n \"def ShowLogin():\\n current_user = helpers.get_current_user()\\n if current_user is None:\\n return render_template('login.html')\\n else:\\n return redirect('/')\",\n \"def home():\\n return render_template('Main_Page.html')\",\n \"def home():\\n return render_template(\\\"home.html\\\")\",\n \"def home():\\n return render_template(\\\"home.html\\\")\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home(request):\\r\\n return render(request, 'home.html')\",\n \"def homepage():\\n return render_template('home/index.html', title=\\\"Home\\\")\",\n \"def home_page():\\n return \\\"<h4>Welcome !</h4><br><a href='/fetch'>View Results</a>\\\"\",\n \"def index(request):\\n if request.user.is_authenticated:\\n return redirect('/dashboard')\\n else:\\n context = {'client_id': settings.OPENHUMANS_CLIENT_ID,\\n 'oh_proj_page': settings.OH_ACTIVITY_PAGE}\\n\\n return render(request, 'main/index.html', context=context)\",\n \"def homepage():\\n\\n return render_template('rosemead_homepage.html')\",\n \"def home(request):\\n\\n user = request.authenticated_userid\\n return {'user': user}\",\n \"def home(request):\\n # if request.user.is_authenticated():\\n # return redirect('/fastapp')\\n return context()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8019861","0.7620225","0.75773484","0.7534236","0.7531676","0.7529761","0.7448983","0.7423995","0.73834974","0.72934496","0.72723556","0.7247265","0.72185725","0.7184802","0.71762604","0.71736443","0.7173331","0.71588814","0.71466374","0.70936805","0.7089231","0.70646596","0.7043858","0.7043703","0.7041348","0.7039814","0.70259833","0.7025243","0.70245016","0.7013954","0.70136046","0.7005305","0.6996469","0.6991513","0.69883573","0.69790566","0.69786143","0.69740134","0.6971584","0.69703025","0.6969448","0.6962111","0.6956936","0.6956295","0.6955261","0.69542396","0.69542396","0.69221264","0.6920835","0.69185364","0.69055575","0.69034594","0.69015974","0.6900311","0.6893491","0.68892086","0.68892086","0.68892086","0.68892086","0.68892086","0.68892086","0.68892086","0.68892086","0.68892086","0.68892086","0.6877217","0.68734026","0.6872141","0.6868736","0.68648076","0.68643254","0.6863641","0.68498445","0.6829437","0.682633","0.6821484","0.6811835","0.6811835","0.6809463","0.6809463","0.6809463","0.6809463","0.6809463","0.6809463","0.6809463","0.6809463","0.6809463","0.6809463","0.6809463","0.6809463","0.6809463","0.6809463","0.6809463","0.6809463","0.68066895","0.67895734","0.6786961","0.67858666","0.67858267","0.6784537","0.677802"],"string":"[\n \"0.8019861\",\n \"0.7620225\",\n \"0.75773484\",\n \"0.7534236\",\n \"0.7531676\",\n \"0.7529761\",\n \"0.7448983\",\n \"0.7423995\",\n \"0.73834974\",\n \"0.72934496\",\n \"0.72723556\",\n \"0.7247265\",\n \"0.72185725\",\n \"0.7184802\",\n \"0.71762604\",\n \"0.71736443\",\n \"0.7173331\",\n \"0.71588814\",\n \"0.71466374\",\n \"0.70936805\",\n \"0.7089231\",\n \"0.70646596\",\n \"0.7043858\",\n \"0.7043703\",\n \"0.7041348\",\n \"0.7039814\",\n \"0.70259833\",\n \"0.7025243\",\n \"0.70245016\",\n \"0.7013954\",\n \"0.70136046\",\n \"0.7005305\",\n \"0.6996469\",\n \"0.6991513\",\n \"0.69883573\",\n \"0.69790566\",\n \"0.69786143\",\n \"0.69740134\",\n \"0.6971584\",\n \"0.69703025\",\n \"0.6969448\",\n \"0.6962111\",\n \"0.6956936\",\n \"0.6956295\",\n \"0.6955261\",\n \"0.69542396\",\n \"0.69542396\",\n \"0.69221264\",\n \"0.6920835\",\n \"0.69185364\",\n \"0.69055575\",\n \"0.69034594\",\n \"0.69015974\",\n \"0.6900311\",\n \"0.6893491\",\n \"0.68892086\",\n \"0.68892086\",\n \"0.68892086\",\n \"0.68892086\",\n \"0.68892086\",\n \"0.68892086\",\n \"0.68892086\",\n \"0.68892086\",\n \"0.68892086\",\n \"0.68892086\",\n \"0.6877217\",\n \"0.68734026\",\n \"0.6872141\",\n \"0.6868736\",\n \"0.68648076\",\n \"0.68643254\",\n \"0.6863641\",\n \"0.68498445\",\n \"0.6829437\",\n \"0.682633\",\n \"0.6821484\",\n \"0.6811835\",\n \"0.6811835\",\n \"0.6809463\",\n \"0.6809463\",\n \"0.6809463\",\n \"0.6809463\",\n \"0.6809463\",\n \"0.6809463\",\n \"0.6809463\",\n \"0.6809463\",\n \"0.6809463\",\n \"0.6809463\",\n \"0.6809463\",\n \"0.6809463\",\n \"0.6809463\",\n \"0.6809463\",\n \"0.6809463\",\n \"0.6809463\",\n \"0.68066895\",\n \"0.67895734\",\n \"0.6786961\",\n \"0.67858666\",\n \"0.67858267\",\n \"0.6784537\",\n \"0.677802\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21985,"cells":{"query":{"kind":"string","value":"Used to allow a user to edit their own profile."},"document":{"kind":"string","value":"def edit_profile(request):\r\n\r\n user = request.user\r\n profile = Profile.objects.for_user(user)\r\n\r\n if request.method != 'POST':\r\n profile_form = ProfileForm(instance=profile)\r\n user_form = UserForm(instance=user)\r\n else:\r\n profile_form = ProfileForm(request.POST, instance=profile)\r\n user_form = UserForm(request.POST, instance=user)\r\n\r\n if profile_form.is_valid() and user_form.is_valid():\r\n profile_form.save()\r\n user_form.save()\r\n\r\n return HttpResponseRedirect(reverse('epic.core.views.view_profile', kwargs={}))\r\n\r\n return render_to_response(\r\n 'core/edit_profile.html',\r\n {'profile_form': profile_form, 'user_form': user_form,},\r\n context_instance=RequestContext(request))"},"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 edit_profile(self, name, username, email):\n return self.app.post('/_editProfile', data = dict(\n name = name,\n username = username,\n email = email\n ), follow_redirects = True)","def edit_user():\n if CURR_USER_KEY in session:\n user = g.user\n form = ProfileEditForm(obj=user)\n\n if form.validate_on_submit():\n user.first_name = form.first_name.data\n user.last_name = form.last_name.data\n user.description = form.description.data\n user.email = form.email.data\n user.image_url = form.image_url.data or \"/static/images/default-pic.png\"\n\n db.session.commit()\n\n flash(\"Profile edited.\")\n return redirect(\"/profile\")\n\n return render_template('/profile/edit-form.html', form=form)\n else:\n return redirect('/login')","def edit_profile(request, pk=None):\n profiledetails = UserProfile.objects.filter(user=request.user).first()\n if UserProfile.objects.filter(user=request.user or request.user.is_superuser):\n\n if request.method == \"POST\":\n profile_details_form = UserProfileForm(request.POST, request.FILES, instance=profiledetails)\n if profile_details_form.is_valid():\n profiledetails = profile_details_form.save()\n messages.success(request, 'Your profile has been updated!')\n return redirect(user_profile)\n else:\n profile_details_form = UserProfileForm(instance=profiledetails)\n else:\n return HttpResponseForbidden()\n \n return render(request, 'newprofiledetails.html', {'profile_details_form': profile_details_form})","def edit_profile(request):\n if request.method == 'POST':\n form = EditProfileForm(request.POST, instance=request.user)\n\n if form.is_valid():\n form.save()\n messages.success(request, 'Profile updated successfully.')\n return redirect('profile')\n\n else:\n messages.error(request, 'Invalid entry, please try again.')\n return redirect('edit_profile')\n else:\n form = EditProfileForm(instance=request.user)\n return render(request, 'accounts/edit_profile.html', {'form': form})","def viewprofile():\n user = current_user\n form = UserUpdateForm(obj=user)\n form.populate_obj(user)\n if form.validate_on_submit():\n form.populate_obj(user)\n\n db.session.commit()\n\n flash('You have successfully edited your profile!')\n return render_template('user/user.html', title=\"View Profile\",\n user=user, form=form, action='Edit')","def view_profile():\n user_id = session.get(\"user_id\")\n \n user = User.query.get(session[\"user_id\"])\n \n return render_template(\"editable_profile_page.html\", user=user)","def edit_profile(profile_id):\n # This check is in place to avoid users trying to edit a profile via the dashboard\n # when they have not created one. If not the option is not displayed\n user = mongo.db.user.find_one({'username': session['username']})\n chck = mongo.db.profiles.find_one_or_404({'user_id': user['_id']})\n if chck: \n profile = mongo.db.profiles.find_one(\n {'_id': ObjectId(profile_id)})\n \n form=ProfileForm()\n form.headline.data = profile['headline']\n form.bio.data = profile['bio']\n form.xp.data = profile['xp']\n form.interests.data = profile['interests']\n form.stack.data = profile['stack']\n form.languages.data = profile['languages']\n form.frameworks.data = profile['frameworks']\n form.github.data = profile['github']\n form.linkedin.data = profile['linkedin']\n \n return render_template('pages/editprofile.html', form=form, profile=profile, legend='Edit your Profile')","def edit_profile(request):\n profile_to_edit = get_object_or_404(UserProfile, user=request.user)\n if request.method == \"POST\":\n form = UserProfileForm(request.POST, instance=profile_to_edit)\n if form.is_valid:\n form.save()\n messages.success(request, \"Profile updated succesfully\")\n return redirect('profile')\n else:\n messages.error(request, \"Updated failed. \\\n Please ensure the form is valid\")\n else:\n profile_form = UserProfileForm(instance=profile_to_edit)\n template = 'profiles/edit_profile.html'\n context = {\n 'form': profile_form,\n }\n return render(request, template, context)","def profile():\n\n if not g.user:\n flash(\"Access unauthorized.\", \"danger\")\n return redirect(\"/\")\n\n form = UserEditForm(obj=g.user)\n\n if form.validate_on_submit():\n if not User.authenticate(g.user.username, form.data[\"password\"]):\n flash(\"Invalid password.\", \"danger\")\n return render_template('/users/edit.html', form=form) \n # data = {k:v for k,v in form.data.items() if k != \"csrf_token\"}\n # data[\"image_url\"] = data[\"image_url\"] or None\n # data[\"header_image_url\"] = data[\"header_image_url\"] or None\n\n g.user.username = form.data[\"username\"]\n g.user.email = form.data[\"email\"]\n g.user.image_url = form.data[\"image_url\"] or None\n g.user.header_image_url = form.data[\"header_image_url\"] or None\n g.user.bio = form.data[\"bio\"]\n\n db.session.commit()\n\n flash(\"Profile edited!\", \"success\")\n return redirect(f'/users/{g.user.id}')\n\n return render_template('/users/edit.html', form=form)","def test_that_a_user_can_edit_their_profile(self):\n self.authorize_user(self.user_login_details)\n url = self.profiles_url + \\\n '{}'.format(self.user['user']['username']) + \"/\"\n response = self.client.patch(url, data=self.user_bio)\n self.assertEqual(response.data['bio'], \"You are a peculiar man.\")\n self.assertEqual(response.status_code, status.HTTP_200_OK)","def profile():\n\n form = EditUserForm(obj=g.user)\n\n if form.validate_on_submit():\n if User.authenticate(g.user.username, form.password.data):\n g.user.username = form.username.data\n g.user.email = form.email.data\n g.user.image_url = form.image_url.data\n g.user.header_image_url = form.header_image_url.data\n g.user.bio = form.bio.data\n g.user.private = form.private.data\n db.session.commit()\n return redirect(f'/users/{g.user.id}')\n flash('Incorrect password', 'danger')\n return render_template('users/edit.html', user_id=g.user.id, form=form)","def can_edit_profile(user: User, owner: User) -> bool:\n\n return has_permission(user, \"edit_profiles\") or user == owner","def profile_edit():\n form = ProfileForm(obj=current_user)\n\n if form.validate_on_submit():\n form.populate_obj(current_user)\n\n try:\n correct = True\n db.session.commit()\n\n flash(_('Profile updated correctly'), 'success')\n\n return render_template('admin/profile/edit.html', form=form)\n\n except IntegrityError:\n # Email already exists\n correct = False\n form.errors.email.append(_('Email is already registered'))\n\n return render_template('admin/profile/edit.html', form=form)\n\n except Exception:\n # Catch anything unknown\n correct = False\n\n flash(_('Failed to update profile, contact an administrator'), 'error')\n\n return render_template('admin/profile/edit.html', form=form)\n\n finally:\n if not correct:\n db.session.rollback()\n\n return render_template('admin/profile/edit.html', form=form)","def edit_profile(request, userid):\n woofer_user = User.objects.get(id=userid)\n current_profile = Profile.objects.get(user=woofer_user)\n if woofer_user.id != request.user.id:\n return HttpResponseRedirect(reverse('view-profile', args=[userid]))\n\n if request.method == 'POST':\n form = ProfileForm(request.POST)\n if form.is_valid():\n new_profile = form.save(commit=False)\n # copy the ID of the User's current profile to the new profile so\n # Django performs an update when we call .save()\n new_profile.id = current_profile.id\n new_profile.user = woofer_user\n new_profile.save()\n return HttpResponseRedirect(reverse('view-profile', args=[userid]))\n else:\n form = ProfileForm(instance=current_profile)\n\n return render(request, 'woofer/show_form.html', {\n 'form' : form,\n 'message' : None,\n 'form_action' : reverse('edit-profile', args=[userid]),\n 'title' : \"Edit Profile\"\n })","def edit_profile(request):\n profile = request.user.profile\n form = forms.ProfileForm(instance=profile)\n\n if request.method == 'POST':\n if settings.SYSTEM_MAINTENANCE_NO_UPLOAD:\n # Allow submitting the form, but do not allow the photo to\n # be modified.\n if 'delete_photo' in request.POST or request.FILES:\n raise ServiceUnavailable()\n\n if 'edit_profile' in request.POST:\n # Update the profile and return to the same page. Place a message\n # at the top of the page: 'your profile has been updated'\n form = forms.ProfileForm(data=request.POST, files=request.FILES,\n instance=profile)\n if form.is_valid():\n form.save()\n messages.success(request, 'Your profile has been updated.')\n elif 'delete_photo' in request.POST:\n profile.delete_photo()\n messages.success(request, 'Your profile photo has been deleted.')\n\n if not form.errors:\n form = forms.ProfileForm(instance=profile)\n\n return render(request, 'user/edit_profile.html', {'form':form})","def edit_profile(request):\n form = ProfileForm(instance=request.user.profile)\n if request.method == \"POST\":\n form = ProfileForm(data=request.POST, files=request.FILES,\n instance=request.user.profile)\n if form.is_valid():\n form.save()\n return redirect('profile')\n return render(request, 'accounts/forms.html', {'form': form})","def edit_user_profile(request):\n user = request.user\n user_profile = UserProfile.objects.filter(user=user)[0]\n if request.method == 'POST':\n form = MemberProfileForm(request.POST)\n additional_form = MemberAdditionalProfileForm(request.POST)\n if form.is_valid() and additional_form.is_valid():\n cd = form.cleaned_data\n user.first_name = cd['first_name']\n user.last_name = cd['last_name']\n user.email = cd['email']\n user.save()\n if 'picture' in request.FILES:\n file = request.FILES['picture']\n user_profile.picture.save(file.name, file, save=True)\n user_profile.gravatar = additional_form.cleaned_data['gravatar']\n user_profile.save()\n return HttpResponseRedirect('/')\n else:\n form = MemberProfileForm(instance=request.user)\n additional_form = MemberAdditionalProfileForm(instance=user_profile)\n return render_to_response('edit_profile.html', locals())","def edit_profile():\n form = EditProfileForm()\n if request.method == 'GET':\n form.first_name.data = current_user.first_name\n form.first_name.data = current_user.first_name\n form.last_name.data = current_user.last_name\n form.email.data = current_user.email\n form.address_1.data = current_user.address_1\n form.address_2.data = current_user.address_2\n form.city.data = current_user.city\n form.state.data = current_user.state\n form.zipcode.data = current_user.zipcode\n form.telephone.data = current_user.telephone\n if form.validate_on_submit():\n form.last_name.data = form.last_name.data\n current_user.first_name = form.first_name.data\n current_user.last_name = form.last_name.data\n current_user.email = form.email.data\n current_user.address_1 = form.address_1.data\n current_user.address_2 = form.address_2.data\n current_user.city = form.city.data\n current_user.state = form.state.data\n current_user.zipcode = form.zipcode.data\n current_user.telephone = form.telephone.data\n db.session.commit()\n flash(('Your changes have been saved.'))\n\n return redirect(url_for('edit_profile'))\n\n return render_template('edit_profile.html', title=('Edit Profile'),\n form=form)","def edit_basic_info(request):\n if request.POST:\n request.user.first_name = request.POST['first_name']\n request.user.last_name = request.POST['last_name']\n request.user.email = request.POST['email']\n request.user.save()\n request.user.userprofile.phone_number = request.POST['phone']\n request.user.userprofile.save()\n messages.add_message(request, messages.SUCCESS, 'Your changes have been saved.')\n return redirect('base_dashboard')\n\n return render(request, 'edit_basic_info.html', {'the_user': request.user})","def home_edituser():\n\tpass","def profile_edit(request):\n if request.user.is_authenticated:\n u = request.user\n context = ProfileContext(u).get_context_with_form()\n context = calculate_char_in_textarea(context)\n return render(request, 'wantedly_app/profile_edit.html', context)\n else:\n return redirect('home')","def profile(request):\n profile = request.user.profile\n return render(request, 'accounts/profile.html', {'profile': profile})","def edit_profile_post(request, pk=None):\n profilepost = get_object_or_404(ProfilePost, pk=pk) \n if (request.user == profilepost.user or\n request.user.is_superuser):\n if request.method == \"POST\":\n profile_post_form = ProfilePostForm(request.POST, request.FILES, instance=profilepost)\n if profile_post_form.is_valid():\n profilepost = profile_post_form.save()\n messages.success(request, 'Your post has been updated!') \n return redirect(reverse('profile'))\n else:\n profile_post_form = ProfilePostForm(instance=profilepost)\n else:\n return HttpResponseForbidden()\n\n return render(request, 'newprofilepost.html', {'profile_post_form': profile_post_form})","def show_profile(request, profile_uuid):\n context = context_assign_user(request.user)\n context['profile_form'] = ProfileForm(instance=context['current_user'])\n if request.method == 'POST':\n form = ProfileForm(request.POST)\n if form.is_valid():\n Profile.objects.filter(pk=context['current_user'].id).update(bio=request.POST['bio'], palette=request.POST['palette'], iex_api_key=request.POST['iex_api_key'])\n messages.success(request, 'Your settings have been saved.')\n return redirect('dash:dashboard')\n errors = form.errors\n form = ProfileForm(request, request.POST)\n messages.warning(request, f\"There's a problem with the form: {errors}\")\n return render(request, 'dash/users/show_profile.html', context)","def user_view(cls, user, profile):\r\n pass","def user_profile():\n user = current_user\n user_is_valid = True\n if not user.active:\n flash('This user account is under review. Please update your profile '\n + ' and contact the organizing team to access all functions of '\n + 'this platform.', 'warning')\n\n form = UserForm(obj=user, next=request.args.get('next'))\n form.roles.choices = [(r.id, r.name) for r in Role.query.order_by('name')]\n\n # Check conflicting PKs\n if form.email.data != user.email:\n if User.query.filter_by(email=form.email.data).first() is not None:\n flash('This e-mail address is already registered.', 'error')\n user_is_valid = False\n\n if user.sso_id:\n # Do not allow changing password on SSO\n del form.password\n\n # Validation has passed\n if form.is_submitted() and form.validate() and user_is_valid:\n # Assign roles\n user.roles = [Role.query.filter_by(\n id=r).first() for r in form.roles.data]\n del form.roles\n\n # Sanitize username\n user.username = sanitize_input(form.username.data)\n del form.username\n\n # Assign password if changed\n originalhash = user.password\n form.populate_obj(user)\n # Do not allow changing password on SSO\n if not user.sso_id:\n if form.password.data:\n user.set_password(form.password.data)\n else:\n user.password = originalhash\n\n user.updated_at = datetime.utcnow()\n db.session.add(user)\n db.session.commit()\n user.socialize()\n flash('Profile updated.', 'success')\n return redirect(url_for('public.user', username=user.username))\n\n if not form.roles.choices:\n del form.roles\n else:\n form.roles.data = [(r.id) for r in user.roles]\n return render_template('public/useredit.html',\n oauth_type=oauth_type(),\n user=user, form=form,\n active='profile')","def edit_user(request, user_id):\n profile = get_object_or_404(UserProfile, user=request.user)\n\n # make sure only managers and admins can add a team\n if profile.level == 'admin' or profile.level == 'manager':\n\n user = get_object_or_404(UserProfile, pk=user_id)\n if request.method == 'POST':\n form = UserProfileForm(request.POST, request.FILES, instance=user)\n if form.is_valid():\n form.save()\n messages.success(request, 'User edited successfully')\n\n users = UserProfile.objects.filter(company_id=profile.company_id)\n template = 'profiles/user_management.html'\n context = {\n 'users': users,\n 'profile': profile\n }\n return render(request, template, context)\n\n else:\n print(\"failed\")\n else:\n form = UserProfileForm(instance=user)\n\n template = 'profiles/profile.html'\n context = {\n 'form': form,\n 'profile': user,\n }\n\n return render(request, template, context)\n\n else:\n messages.info(request, \"Sorry, you are not authorized to edit users. Ask a Manager or Admin.\")\n\n return redirect(reverse('planning', ))","def profile():\n if g.user:\n return render_template('profile.html', user=g.user)\n return redirect(url_for('login'))","def user_view(cls, user, profile):\n pass","def test_user_edit_profile(self):\n with self.client as c:\n with c.session_transaction() as sess:\n sess[CURR_USER_KEY] = self.testuser_id\n\n address = \"1215 Brookview Ave, Kettering, Ohio 45409\"\n\n resp = c.get(f\"/users/8989/\")\n html = resp.get_data(as_text=True)\n\n self.assertEqual(resp.status_code, 200)\n self.assertIn(\n '<h1 class=\"Display-4 text-center mt-3\"><b>Profile Information:</b></h1>',\n html,\n )\n self.assertIn(\"<p>testuser</p>\", html)\n self.assertIn(\"<p>test@test.com</p>\", html)\n self.assertIn(\"<p>662-996-3356</p>\", html)\n self.assertIn(\n '<a class=\"font-weight-bold btn winter-neva-gradient color-block btn-block my-4 waves-effect z-depth-0\" href=\"/users/8989/edit\">Edit Profile</a>',\n html,\n )","def edit_profile_view(request, user_id=0):\n\tuser = User.objects.filter(id=user_id)[0]\n\tstalker = request.user\n\tif stalker != user:\n\t\treturn HttpResponse(\"Go away guys, nothing to see here!\")\n\telse:\n\t\tuser_indicator = 0 # Used to check if the user is logged in \n\t\tif (stalker.is_authenticated()):\n\t\t\tuser_indicator = 1\n\t\telse:\n\t\t\tuser_indicator = 0\n\t\t# show a form with data from database for 'GET' request\n\t\tif request.method == 'GET':\n\t\t\tperson = Person.objects.filter(user=user)[0]\n\t\t\taccount_form = AccountDetailForm(initial={\n\t\t\t\t'user_name': user.username,\n\t\t\t\t'user_email': user.email,\n\t\t\t\t'user_faculty': person.faculty,\n\t\t\t}) # Display user account detail\n\t\t\taccount_form.fields['user_name'].disabled = False\n\t\t\taccount_form.fields['user_email'].disabled = False\n\t\t\taccount_form.fields['user_faculty'].disabled = False\n\n\t\t\tlocation_form = LocationForm() # Display location box for user to type into\n\n\t\t\tlive_update_list = LiveUpdate.objects.all().order_by('date_time') # Display live update list\n\n\t\t\tfriend_update_list = FriendUpdate.objects.filter(receiver=user).order_by('date_time') # Display friend update list\n\n\t\t\tfriend_request_list = FriendRequest.objects.filter(receiver=user).order_by('-date_time') # Display friend request list\n\n\t\t\tfriend_list = person.friends.all() # Display all friends list\n\n\t\t\taddfriend_indicator = 0 # Help decide the status of the add friend button\n\t\t\tperson_2 = Person.objects.filter(user=stalker)[0]\n\t\t\tif (person_2 in friend_list):\n\t\t\t\taddfriend_indicator = 2 # stalker and user whose profile being shown are friends\n\t\t\telse:\n\t\t\t\trelevant_request = FriendRequest.objects.filter(sender=stalker,receiver=user)\n\t\t\t\tif len(relevant_request) == 0:\n\t\t\t\t\taddfriend_indicator = 0 # stalker has not added user whose profile is being shown as a friend\n\t\t\t\telse:\n\t\t\t\t\taddfriend_indicator = 1 # stalker has added user whose profile is being shown as a friend\n\n\t\t\treturn render(request, 'mugspot/userprofile_edit.html', {\n\t\t\t\t\t'live_update_list':live_update_list,\n\t\t\t\t\t'friend_update_list': friend_update_list,\n\t\t\t\t\t'location_form': location_form,\n\t\t\t\t\t'account_form': account_form,\n\t\t\t\t\t'friend_list': friend_list,\n\t\t\t\t\t'friend_request_list': friend_request_list,\n\t\t\t\t\t'user_prof': user,\n\t\t\t\t\t'stalker': stalker,\n\t\t\t\t\t'user_indicator': user_indicator,\n\t\t\t\t\t'addfriend_indicator': addfriend_indicator,\n\t\t\t\t})","def edit_user(request, username):\n context = {}\n detail = IMPUser.objects.all().filter(username = username)\n if detail:\n context = {'username':username,\n 'display_name':detail[0].display_name,\n 'tel':detail[0].tel,\n 'mobile':detail[0].mobile,\n 'office':detail[0].office,\n 'num':detail[0].num}\n return render(request, \"account/edit_user.html\", context)","def test_that_a_user_cannot_edit_another_users_profile(self):\n self.authorize_user(self.user_login_details)\n self.register_user(self.user2)\n url = self.profiles_url + \\\n '{}'.format(self.user2['user']['username']) + \"/\"\n response = self.client.patch(url, data=self.user_bio)\n message = \"You don't have permission to edit this profile\"\n self.assertEqual(response.data['message'], message)\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)","def edit_profile():\n # handle pre-flight for browsers CORS access\n if request.method == \"OPTIONS\":\n return generate_response()\n # part1: verify that user has logged in and the request is legit\n checked_and_verified, response = check_verify_token(request,login_session)\n if checked_and_verified != True: return response\n # handle the edge case where user is authorized to perform create user but not other method\n if not is_loggedin(login_session):\n response = generate_message(MESSAGE_USER_NOT_LOGGED_IN,401)\n return response\n # part2: check json\n checked_json, response, requested_json = check_json_form(request,MESSAGE_BAD_JSON,MESSAGE_CREATE_USER_NO_JSON)\n if checked_json != True: return response\n # part3: verify json data\n try:\n user_email = login_session[\"login_user_email\"]\n except KeyError:\n # key error means we are offline til this far\n user_email = requested_json[\"email\"]\n # design decision: if there are invalid field names, only update the valid fields.\n # check updates keys and formats\n try:\n update_pairs = convert_to_underscore(requested_json[\"updates\"])\n \n if isinstance(update_pairs,dict) != True:\n response = generate_message(MESSAGE_UPDATE_PROFILE_NON_DICT,400)\n else:\n correct_format,valid_update_pairs, response = process_request_json(User,update_pairs)\n if correct_format == True: \n update_field(User, session, {\"email\": user_email},valid_update_pairs)\n response = generate_message(MESSAGE_UPDATE_PROFILE_SUCCESS,200)\n except KeyError:\n response = generate_message(MESSAGE_UPDATE_PROFILE_NO_ENTRY,400)\n return response","def __profileChanged(self, inst, topic, value):\n\n old, new = value\n\n if new is orthoeditprofile.OrthoEditProfile:\n self.__addEditMenu()\n elif old is orthoeditprofile.OrthoEditProfile:\n self.__removeEditMenu()","def edit_user_profile(user_id):\n if CURRENT_USER_KEY not in session or session[CURRENT_USER_KEY] != user_id:\n raise Unauthorized()\n\n user = User.query.get_or_404(user_id)\n\n form = UserEditForm(obj=user)\n\n if form.validate_on_submit():\n try:\n user.email = form.email.data\n user.username = form.username.data\n user.first_name = form.first_name.data.capitalize()\n user.last_name = form.last_name.data.capitalize()\n user.image_url = form.image_url.data or User.image_url.default.arg\n user.cover_url = form.cover_url.data or User.cover_url.default.arg\n user.bio = form.bio.data\n\n db.session.commit()\n except IntegrityError:\n db.session.rollback()\n flash(\n \"Email or Username already taken!! Please try again\", 'danger')\n return render_template('edit_profile.html', form=form, user=user, img_src=user.image_url)\n\n flash('Profile Successfully Updated!', 'success')\n return redirect(url_for('show_user_profile', user_id=user.id))\n return render_template('edit_profile.html', form=form, user=user, img_src=user.image_url)","def test_edit_profile(self):\n \n LOGGER.debug(\"Test GET /rango/edit/ for anon user\")\n anon_edit_response = self.client.get('/rango/edit/')\n # redirected to login page\n self.assertEquals(302, anon_edit_response.status_code)\n self.assertRedirects(anon_edit_response, \"http://testserver/accounts/login/?next=/rango/edit/\")\n\n LOGGER.debug(\"Test GET /rango/edit/ for logged in user\")\n self.client.login(username='leothelion', password='rawr')\n logged_in_edit_response = self.client.get('/rango/edit/')\n self.assertContains(logged_in_edit_response, \"leo\")","def allow_edit_by(self, user2_compare):\n if user2_compare.is_superuser:\n return True\n\n if user2_compare == self.user:\n return True\n\n if (self.creator and self.creator == user2_compare) or \\\n (self.owner and self.owner == user2_compare):\n if self.status:\n return True\n\n if user2_compare.has_perm('profiles.change_profile', self):\n return True\n\n return False","def user_can_edit(self, user):\n return user == self.owner","def edit_user(request, email):\n if not email:\n if request.POST and request.POST['email']:\n url = urlresolvers.reverse('views.admin.edit_user',\n args=[request.POST['email']])\n return http.HttpResponseRedirect(url)\n else:\n return utility.respond(request, 'admin/edit_user', {'title': 'Edit user'})\n\n profile = models.UserProfile.load(email)\n if not profile:\n return utility.page_not_found(request)\n title = 'Edit user: ' + email\n\n return utility.edit_instance(request, models.UserProfile, forms.UserEditForm,\n 'admin/edit_user',\n urlresolvers.reverse('views.admin.index'),\n profile.key().id(), title=title, profile=profile)","def user_settings(request):\n return redirect('edit_profile')","def __str__(self):\n return self.user.username + \"'s Profile\"","def edit_profile(request, userId):\n try:\n try:\n user = User.objects.get(pk=userId)\n profile = Profile.objects.get(user_id=userId)\n user.first_name = request.data['first_name'] if 'first_name' in request.data else user.first_name\n user.last_name = request.data['last_name'] if 'last_name' in request.data else user.last_name\n user.email = request.data['email'] if 'email' in request.data else user.email\n profile.phone = request.data['phone'] if 'phone' in request.data else profile.phone\n profile.profile_img_path = request.data['profile_img_path'] if 'profile_img_path' in request.data else profile.profile_img_path\n profile.information = request.data['information'] if 'information' in request.data else profile.information\n user.save()\n profile.save()\n return JsonResponse({\n \"statusCode\": 200,\n \"statusText\": \"Success\",\n \"message\": \"Save profile success\",\n \"error\": False\n })\n\n except ObjectDoesNotExist:\n return JsonResponse({\n \"statusCode\": 404,\n \"statusText\": \"Not Found\",\n \"message\": \"User Not Exist\",\n \"error\": True\n })\n except:\n return JsonResponse({\n \"statusCode\": 500,\n \"statusText\": \"Internal Server\",\n \"message\": \"Internal Server\",\n \"error\": True\n })","def editProfile():\n form = EditProfileForm(request.form)\n if request.method == \"GET\":\n return render_template(\"/pages/editprofile.html\", form=form)\n else:\n choose = True\n section = form.category.data\n return redirect(url_for(\"editProfileSection\", section=section))","def user_profile():\n if CURR_USER_KEY in session:\n return render_template('/profile/detail.html')\n else:\n return redirect('/login')","def profile(request, info=\"\", error_msg=\"\", messages=\"\"):\r\n try:\r\n user = _validate_and_get_geniuser(request)\r\n except LoggedInButFailedGetGeniUserError:\r\n return _show_failed_get_geniuser_page(request)\r\n\r\n email_form = forms.gen_edit_user_form(instance=user)\r\n affiliation_form = forms.gen_edit_user_form(instance=user)\r\n password_form = forms.EditUserPasswordForm()\r\n\r\n if request.method == 'POST':\r\n if 'affiliation' in request.POST:\r\n affiliation_form = forms.gen_edit_user_form(('affiliation',), request.POST, instance=user)\r\n if affiliation_form.is_valid():\r\n new_affiliation = affiliation_form.cleaned_data['affiliation']\r\n interface.change_user_affiliation(user, new_affiliation)\r\n info =\"Affiliation has been successfully changed to %s.\" % (user.affiliation)\r\n elif 'email' in request.POST:\r\n email_form = forms.gen_edit_user_form(('email',), request.POST, instance=user)\r\n if email_form.is_valid():\r\n new_email = email_form.cleaned_data['email']\r\n interface.change_user_email(user, new_email)\r\n info =\"Email has been successfully changed to %s.\" % (user.email)\r\n elif 'password1' in request.POST:\r\n password_form = forms.EditUserPasswordForm( request.POST, instance=user)\r\n if password_form.is_valid():\r\n new_password = password_form.cleaned_data['password1']\r\n interface.change_user_password(user, new_password)\r\n info =\"Password has been successfully changed\"\r\n\r\n username = user.username\r\n affiliation = user.affiliation\r\n email = user.email\r\n port = user.usable_vessel_port\r\n has_privkey = user.user_privkey != None\r\n #currently not used, needed if editing user port is allowed\r\n #port_range = interface.get_useable_ports()\r\n #port_range_min = port_range[0]\r\n #port_range_max = port_range[-1]\r\n\r\n return render_to_response('control/profile.html',\r\n {'email_form' : email_form,\r\n 'affiliation_form' : affiliation_form,\r\n 'password_form' : password_form,\r\n 'username' : username,\r\n 'affiliation' : affiliation,\r\n 'email' : email,\r\n 'port' : port,\r\n 'api_key' : user.api_key,\r\n 'has_privkey' : has_privkey,\r\n #'port_range_min' : port_range_min,\r\n #'port_range_max' : port_range_max,\r\n 'info' : info,\r\n 'error_msg' : error_msg,\r\n 'messages' : messages},\r\n context_instance=RequestContext(request))","def edit_user(self):\n from editWindow import EditPlayer\n self.edit = EditPlayer(self.lang, self.result_table.currentItem().text())\n self.edit.show()","def edit_user(user_id):\n user = User.query.get_or_404(user_id)\n return render_template('/users/edit_page.html', user=user)","def getEditUser(self, request):\n\n userForm = UserEditForm(instance=request.user)\n profileForm = ProfileEditForm(instance=request.user.profile)\n return (userForm, profileForm)","def edit_show_user(user_id):\n edited_user = User.query.get_or_404(user_id)\n\n edited_user.first_name = request.form['first_name']\n edited_user.last_name = request.form['last_name']\n edited_user.image_url = request.form['image_url']\n\n db.session.add(edited_user)\n db.session.commit()\n\n return redirect('/')","def profile(request):\n if request.user.is_authenticated():\n obj = get_object_or_404(TolaUser, user=request.user)\n form = RegistrationForm(request.POST or None, instance=obj, initial={'username': request.user})\n\n if request.method == 'POST':\n if form.is_valid():\n form.save()\n messages.error(request, 'Your profile has been updated.', fail_silently=False)\n\n return render(request, \"registration/profile.html\", {\n 'form': form, 'helper': RegistrationForm.helper\n })\n else:\n return HttpResponseRedirect(\"/accounts/register\")","def update_user_profile(request):\n if request.method == 'POST':\n form = UserProfileForm(request.POST)\n\n if form.is_valid():\n user = get_object_or_404(User, pk=request.user.pk)\n user.first_name = request.POST['first_name']\n user.last_name = request.POST['last_name']\n user.profile_picture = request.POST['profile_picture']\n user.save()\n messages.success(request, 'Your profile has been updated!')\n else:\n messages.error(\n request, 'Unable to update your profile. Please try again later.')\n\n return HttpResponseRedirect(request.META.get('HTTP_REFERER', reverse('dev_panel')))","def display_profile(self):\n print(f\"Id: {self._id}\")\n print(f\"username: {self.username}\")\n print(f\"name: {self.name}\")\n print(f\"contact: {self.contact}\")\n print(f\"address: {self.address}\")","def profile(request, id):\n u = get_object_or_404(User, pk=id)\n context = ProfileContext(u).get_context()\n return render(request, 'wantedly_app/profile.html', context)","def current_profile(request):\n if not request.user.is_authenticated():\n return HttpResponseRedirect(reverse('login'))\n return profile(request, request.user.username)","def current_profile(request):\n if not request.user.is_authenticated():\n return HttpResponseRedirect(reverse('login'))\n return profile(request, request.user.username)","def test_onchange_user_profile(self):\n admin = self.env.ref('base.user_root').id\n with self.assertRaises(ValidationError):\n self.env['res.users'].browse(\n self.user.id).write({'user_profile_id': admin})","def edit_user(request, userid):\n if request.method == 'POST':\n form = UserDetailsForm(request.POST)\n if form.is_valid():\n # we're going to update the first_name, last_name, and email fields of this object\n user = request.user\n user.first_name = form.cleaned_data['first_name']\n user.last_name = form.cleaned_data['last_name']\n user.email = form.cleaned_data['email']\n user.save()\n return HttpResponseRedirect(reverse('view-profile', args=[userid]))\n else:\n form = UserDetailsForm(instance=request.user)\n\n return render(request, 'woofer/show_form.html', {\n 'form' : form,\n 'message' : None,\n 'form_action' : reverse('edit-user', args=[userid]),\n 'title' : \"Edit Account\"\n })","def edit_userprofile(request):\n \n try:\n parsed_data = get_json_data(request) \n # authentication\n if not authenticate_user(parsed_data):\n ret = Response(AUTHENTICATION_FAIL, error_code[AUTHENTICATION_FAIL])\n return HttpResponse(ret.serialize(f))\n user = User.objects.get(username=parsed_data[\"username\"]) \n user.appuser.phone = parsed_data[\"phne\"],\n user.appuser.state = parsed_data[\"state\"],\n user.appuser.city = parsed_data[\"city\"],\n user.appuser.address = parsed_data[\"address\"],\n user.appuser.usertype = parsed_data[\"usertype\"]\n user.save()\n user.appuser.save()\n ret = Response(SUCCESS, error_code[SUCCESS])\n except KeyError as e:\n ret = Response(EMPTY_COLUMN, error_code[EMPTY_COLUMN].format(e.message)) \n except ObjectDoesNotExist as e:\n ret = Response(NONEXIST_DATA, error_code[NONEXIST_DATA].format(e.message))\n except ValueError as e:\n ret = Response(INPUT_FORMAT, error_code[INPUT_FORMAT])\n except:\n ret = Response(UNKNOWN_ERROR, error_code[UNKNOWN_ERROR])\n return HttpResponse(ret.serialize(f))","def edit_email(request):\n form = EmailForm(instance=request.user.profile)\n if request.method == \"POST\":\n form = EmailForm(data=request.POST, instance=request.user.profile)\n if form.is_valid():\n form.save()\n return redirect('profile')\n return render(request, 'accounts/forms.html', {'form': form})","def profile():\r\n user_data = load_user(current_user.id, current_user)\r\n if user_data is not None:\r\n user, followers, following = user_data\r\n\r\n return render_base_template(\"profile.html\", profile=user, followers=followers,\r\n following=following,\r\n os_projects=[])\r\n\r\n return abort(404)","def edit_user(user_id):\n user = User.query.get_or_404(user_id)\n\n return render_template('edit-user.html', user=user)","def allow_to_edit(user):\n return allow_to_edit_well(user)","def profile_edit_view(request):\n if request.method == 'POST':\n user_model_form = UserModelForm(\n request.POST,\n prefix=\"user\",\n instance=request.user\n )\n profile_model_form = ProfileSignupForm(\n request.POST,\n prefix=\"profile\",\n instance=request.user.profile\n )\n forms = [user_model_form, profile_model_form]\n\n if request.user.profile.is_mentor():\n mentor_form = MentorForm(\n request.POST,\n prefix=\"mentor\",\n instance=request.user.profile.mentor\n )\n forms.append(mentor_form)\n\n if request.user.profile.is_mentee():\n mentee_form = MenteeForm(\n request.POST,\n prefix=\"mentee\",\n instance=request.user.profile.mentee\n )\n forms.append(mentee_form)\n\n forms_is_valid_list = []\n for form in forms:\n forms_is_valid_list.append(form.is_valid())\n\n if all(forms_is_valid_list):\n for form in forms:\n form.save()\n return redirect(\"private_profile\")\n\n elif request.method == 'GET':\n forms = [\n UserModelForm(\n instance=request.user,\n prefix=\"user\"\n ),\n ProfileSignupForm(\n instance=request.user.profile,\n prefix=\"profile\"\n )\n ]\n\n if request.user.profile.is_mentor():\n forms.append(\n MentorForm(\n instance=request.user.profile.mentor,\n prefix=\"mentor\"\n )\n )\n\n if request.user.profile.is_mentee():\n forms.append(\n MenteeForm(\n instance=request.user.profile.mentee,\n prefix=\"mentee\"\n )\n )\n\n return render(\n request,\n 'mentorship_profile/profile_edit.html',\n {\n \"forms\": forms\n }\n )","def profile():\n \n return render_template(\"profile.html\")","def edit_user(user_id):\n if request.method == 'GET':\n # init form with current user:\n form = ProfileForm(\n nickname = session[Session.PROFILE][\"nickname\"], \n location = session[Session.PROFILE][\"location\"],\n about_me = session[Session.PROFILE][\"about_me\"]\n )\n if request.method == 'POST': \n # init form with POSTed form:\n form = ProfileForm(request.form)\n\n if form.validate(): \n # update backend:\n response = service_user_management.patch(\n id = f'auth0|{user_id}', \n nickname = form.nickname.data, \n location = form.location.data,\n about_me = form.about_me.data\n )\n\n # success:\n if 'identities' in response: \n try:\n # update db:\n delegated_user = DelegatedUser.query.get_or_404(\n user_id, \n description='There is no user with id={}'.format(user_id)\n )\n delegated_user.nickname = form.nickname.data\n # update:\n db.session.add(delegated_user)\n # write\n db.session.commit()\n\n # update session:\n session[Session.PROFILE][\"nickname\"] = form.nickname.data\n session[Session.PROFILE][\"location\"] = form.location.data\n session[Session.PROFILE][\"about_me\"] = form.about_me.data\n \n # on successful profile update, flash success\n flash('Your profile was successfully updated.')\n\n return redirect(url_for('.show_user', user_id = user_id))\n except:\n db.session.rollback()\n # on unsuccessful registration, flash an error instead.\n flash('An error occurred. New account could not be created.')\n finally:\n db.session.close()\n # failure:\n else:\n flash(response['message']) \n else:\n # for debugging only:\n flash(form.errors)\n \n return render_template('users/forms/user.html', form=form, user_id=user_id)","def edit_user(user_id):\n user = User.query.get_or_404(user_id)\n return render_template(\"users/edit_user.html\", user=user)","def test_editProfile(self):\n\t\turl = \"/profiles/1/\"\n\t\tdata = { \"name\" : \"testName\", \"surname\" : \"testSurname\" }\n\t\tresponse = self.client.patch(url, data, format='json')\n\t\tself.assertEqual(response.status_code, status.HTTP_200_OK)\n\t\tself.assertEqual(response.data[\"name\"], \"testName\")\n\t\tself.assertEqual(response.data[\"surname\"], \"testSurname\")","def update_profile(name):\r\n user = User.query.filter_by(name=name).first()\r\n if not user:\r\n return abort(404)\r\n if current_user.id != user.id:\r\n return abort(403)\r\n show_passwd_form = True\r\n if user.twitter_user_id or user.google_user_id or user.facebook_user_id:\r\n show_passwd_form = False\r\n usr, apps, apps_created = cached_users.get_user_summary(name)\r\n # Extend the values\r\n current_user.rank = usr.get('rank')\r\n current_user.score = usr.get('score')\r\n # Title page\r\n title_msg = \"Update your profile: %s\" % current_user.fullname\r\n # Creation of forms\r\n update_form = UpdateProfileForm(obj=user)\r\n update_form.set_locales(current_app.config['LOCALES'])\r\n avatar_form = AvatarUploadForm()\r\n password_form = ChangePasswordForm()\r\n external_form = update_form\r\n\r\n\r\n if request.method == 'GET':\r\n return render_template('account/update.html',\r\n title=title_msg,\r\n user=usr,\r\n form=update_form,\r\n upload_form=avatar_form,\r\n password_form=password_form,\r\n external_form=external_form,\r\n show_passwd_form=show_passwd_form)\r\n else:\r\n # Update user avatar\r\n if request.form.get('btn') == 'Upload':\r\n avatar_form = AvatarUploadForm()\r\n if avatar_form.validate_on_submit():\r\n file = request.files['avatar']\r\n coordinates = (avatar_form.x1.data, avatar_form.y1.data,\r\n avatar_form.x2.data, avatar_form.y2.data)\r\n prefix = time.time()\r\n file.filename = \"%s_avatar.png\" % prefix\r\n container = \"user_%s\" % current_user.id\r\n uploader.upload_file(file,\r\n container=container,\r\n coordinates=coordinates)\r\n # Delete previous avatar from storage\r\n if current_user.info.get('avatar'):\r\n uploader.delete_file(current_user.info['avatar'], container)\r\n current_user.info = {'avatar': file.filename,\r\n 'container': container}\r\n db.session.commit()\r\n cached_users.delete_user_summary(current_user.name)\r\n flash(gettext('Your avatar has been updated! It may \\\r\n take some minutes to refresh...'), 'success')\r\n return redirect(url_for('.update_profile', name=current_user.name))\r\n else:\r\n flash(\"You have to provide an image file to update your avatar\",\r\n \"error\")\r\n return render_template('/account/update.html',\r\n form=update_form,\r\n upload_form=avatar_form,\r\n password_form=password_form,\r\n external_form=external_form,\r\n title=title_msg,\r\n show_passwd_form=show_passwd_form)\r\n # Update user profile\r\n elif request.form.get('btn') == 'Profile':\r\n update_form = UpdateProfileForm()\r\n update_form.set_locales(current_app.config['LOCALES'])\r\n if update_form.validate():\r\n current_user.id = update_form.id.data\r\n current_user.fullname = update_form.fullname.data\r\n current_user.name = update_form.name.data\r\n current_user.email_addr = update_form.email_addr.data\r\n current_user.privacy_mode = update_form.privacy_mode.data\r\n current_user.locale = update_form.locale.data\r\n db.session.commit()\r\n cached_users.delete_user_summary(current_user.name)\r\n flash(gettext('Your profile has been updated!'), 'success')\r\n return redirect(url_for('.update_profile', name=current_user.name))\r\n else:\r\n flash(gettext('Please correct the errors'), 'error')\r\n title_msg = 'Update your profile: %s' % current_user.fullname\r\n return render_template('/account/update.html',\r\n form=update_form,\r\n upload_form=avatar_form,\r\n password_form=password_form,\r\n external_form=external_form,\r\n title=title_msg,\r\n show_passwd_form=show_passwd_form)\r\n\r\n # Update user password\r\n elif request.form.get('btn') == 'Password':\r\n # Update the data because passing it in the constructor does not work\r\n update_form.name.data = user.name\r\n update_form.fullname.data = user.fullname\r\n update_form.email_addr.data = user.email_addr\r\n update_form.ckan_api.data = user.ckan_api\r\n external_form = update_form\r\n if password_form.validate_on_submit():\r\n user = db.session.query(model.user.User).get(current_user.id)\r\n if user.check_password(password_form.current_password.data):\r\n user.set_password(password_form.new_password.data)\r\n db.session.add(user)\r\n db.session.commit()\r\n flash(gettext('Yay, you changed your password succesfully!'),\r\n 'success')\r\n return redirect(url_for('.update_profile', name=name))\r\n else:\r\n msg = gettext(\"Your current password doesn't match the \"\r\n \"one in our records\")\r\n flash(msg, 'error')\r\n return render_template('/account/update.html',\r\n form=update_form,\r\n upload_form=avatar_form,\r\n password_form=password_form,\r\n external_form=external_form,\r\n title=title_msg,\r\n show_passwd_form=show_passwd_form)\r\n else:\r\n flash(gettext('Please correct the errors'), 'error')\r\n return render_template('/account/update.html',\r\n form=update_form,\r\n upload_form=avatar_form,\r\n password_form=password_form,\r\n external_form=external_form,\r\n title=title_msg,\r\n show_passwd_form=show_passwd_form)\r\n # Update user external services\r\n elif request.form.get('btn') == 'External':\r\n del external_form.locale\r\n del external_form.email_addr\r\n del external_form.fullname\r\n del external_form.name\r\n if external_form.validate():\r\n current_user.ckan_api = external_form.ckan_api.data or None\r\n db.session.commit()\r\n cached_users.delete_user_summary(current_user.name)\r\n flash(gettext('Your profile has been updated!'), 'success')\r\n return redirect(url_for('.update_profile', name=current_user.name))\r\n else:\r\n flash(gettext('Please correct the errors'), 'error')\r\n title_msg = 'Update your profile: %s' % current_user.fullname\r\n return render_template('/account/update.html',\r\n form=update_form,\r\n upload_form=avatar_form,\r\n password_form=password_form,\r\n external_form=external_form,\r\n title=title_msg,\r\n show_passwd_form=show_passwd_form)\r\n # Otherwise return 415\r\n else:\r\n return abort(415)","def edit_user(user_id):\n\n user = User.query.get_or_404(user_id)\n return render_template('users/edit.html', user=user)","def edit(request, pk):\n\n try:\n object = User.objects.get(pk=pk)\n except:\n object = User()\n\n if request.method == 'POST': # If the form has been submitted...\n form = UserForm(request.POST, instance=object)\n\n if form.is_valid(): # If the form is valid\n object = form.save()\n\n messages.success(request, _('The user has been saved.'))\n\n return redirect('users.views.list')\n else:\n form = UserForm(instance=object)\n\n return render(request, 'users/users/edit.html', {'form': form})","def _edit_user(self):\n users = fileIO.load_json(\"users.json\")\n print(\"The list of users is as follows: \")\n for i in users:\n print(users[i][\"name\"])\n #List specific user's settings and get user id\n userID = self._list_user_settings(users)\n #Loop until valid option given\n option = False\n while not option:\n option = input(\"Please enter the setting you would like to change: \")\n if option not in users[userID]:\n option = False\n print(\"That setting is not valid.\")\n #Get input for new setting\n args = input(\"Please enter what you would like to change that setting to: \")\n #Output\n command = \"edit_user {0} {1} {2}\\r\\n\".format(userID, option, args)\n return(command)","def user_profile():\n\n # Make sure users are logged in to access there profile\n if 'logged' in session:\n user = session['username']\n users_recipes = mongo.db.recipes.find({'username': user})\n return render_template('my_profile.html', recipes=users_recipes,\n title=\"My Profile\", user=user)\n # If the user isn't logged but somehow managed to click 'my profie'\n else:\n flash('Only logged in users can see there profile, please log in',\n 'danger')\n return redirect(url_for('login'))","def profile(request):\n profile = get_object_or_404(User, username=request.user)\n\n if request.method == 'POST':\n form = SignupForm(request.POST, instance=profile)\n if form.is_valid():\n form.save()\n messages.success(request, 'Profile updated successfully')\n\n form = SignupForm()\n\n template = 'profiles/profile.html'\n context = {\n 'form': form,\n 'page': 'account',\n }\n\n return render(request, template, context)","def edit(self):\n\n pass","def edit_person(self, pk):","def edit_allowed(self):\n account = Account.current_user_account\n if account is None:\n return False\n return self.user_can_edit(account.user)","def update_profile(request, id):\n username = request.POST.get(\"username\")\n first_name, last_name = request.POST.get(\"fullname\").split()\n email = request.POST.get(\"email\")\n phone = request.POST.get(\"phone\")\n address = request.POST.get(\"address\")\n\n userObj = User.objects.get(id=id)\n userObj.first_name = first_name\n userObj.last_name= last_name\n userObj.username= username\n userObj.email = email\n userObj.phone = phone\n userObj.address = address\n userObj.save()\n messages.success(request, \"Your profile is successfully update.\", fail_silently=False)\n return redirect(\"user_profile\", id)","def user_edit(request):\n DEBUG = False\n\n if not has_permission('editUser', request.context, request):\n #print \"NOT has_permission !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\"\n request.message = \"You do not have permissions to edit this user!\"\n raise HTTPForbidden\n\n # if no user_id in URL and not logged in, tell user to login\n\n try:\n user_id = request.matchdict['user_id']\n except KeyError, ke:\n #print ke\n return HTTPFound(location=request.route_url('not_found'))\n\n user = User.get_by_user_id(user_id)\n\n if user is None:\n msg = \"User was not founf in database.\"\n return HTTPFound(location=request.route_url('not_found'))\n\n form = Form(request, schema=UserSettingsSchema, obj=user)\n\n if 'form.submitted' in request.POST and not form.validate():\n # form didn't validate\n request.session.flash('Please check the form below for errors!')\n if DEBUG: # pragma: no cover\n print \"submitted but not validated!\"\n\n if 'form.submitted' in request.POST and form.validate():\n # ready for changing database entries!\n request.session.flash('form validated!')\n if DEBUG: # pragma: no cover\n print \"the form was submitted and validated.\"\n\n if form.data['surname'] != user.surname:\n if DEBUG: # pragma: no cover\n request.session.flash('surname was not same --> changing')\n print \"changing surname\"\n user.surname = form.data['surname']\n if form.data['lastname'] != user.lastname:\n if DEBUG: # pragma: no cover\n request.session.flash('lastname was not same --> changing')\n print \"changing lastname\"\n user.lastname = form.data['lastname']\n if form.data['email'] != user.email:\n request.session.flash('email was not same --> changing')\n user.email = form.data['email']\n if form.data['phone'] != user.phone:\n request.session.flash('phone was not same --> changing')\n user.phone = form.data['phone']\n if form.data['fax'] != user.fax:\n request.session.flash('fax was not same --> changing')\n user.fax = form.data['fax']\n if form.data['street'] != user.street:\n request.session.flash('street was not same --> changing')\n user.street = form.data['street']\n if form.data['number'] != user.number:\n request.session.flash('number was not same --> changing')\n user.number = form.data['number']\n if form.data['city'] != user.city:\n request.session.flash('city was not same --> changing')\n user.city = form.data['city']\n if form.data['postcode'] != user.postcode:\n request.session.flash('postcode was not same --> changing')\n user.postcode = form.data['postcode']\n if form.data['country'] != user.country:\n request.session.flash('country was not same --> changing')\n user.country = form.data['country']\n\n if DEBUG: # pragma: no cover\n print \"returning the form\"\n return {\n 'the_user_id': user_id,\n 'the_username': user.username,\n 'form': FormRenderer(form),\n }","def edit_user(user_id):\n\n user = User.query.get_or_404(user_id)\n \n first = request.form['first_name']\n last = request.form['last_name']\n image = request.form['image_url']\n \n if not first or not last:\n flash(\"Please enter first and last name.\")\n return redirect(f\"/users/{user.id}/edit\")\n \n user.first_name = first\n user.last_name = last\n \n if image:\n user.image_url = image\n\n db.session.add(user)\n db.session.commit()\n\n return redirect(\"/users\")","def can_edit(self, user):\n return self.author_id == user.id or user.is_staff","def add_profile_details(request):\n\n if request.method == 'POST':\n try:\n profile = Profile.objects.get(user=request.user)\n edit_profile = EditProfileForm(request.POST, instance=profile)\n if edit_profile.is_valid():\n profile.save()\n messages.success(request, 'Your profile has been updated')\n if profile.user_type == 'dismantler':\n return redirect(reverse('addlisting'))\n else:\n return redirect(reverse('listings'))\n except ObjectDoesNotExist:\n profile_form = EditProfileForm(request.POST)\n if profile_form.is_valid():\n profile = Profile.objects.create(\n user=request.user,\n user_type=profile_form.cleaned_data['user_type'],\n business_name=profile_form.cleaned_data['business_name'],\n phone=profile_form.cleaned_data['phone'],\n postcode=profile_form.cleaned_data['postcode'],\n city=profile_form.cleaned_data['city'],\n street_address=profile_form.cleaned_data['street_address'],\n street_address2=profile_form.cleaned_data[\n 'street_address2'],\n county=profile_form.cleaned_data['county'],\n country=profile_form.cleaned_data['country'],\n )\n profile.save()\n messages.success(request, 'Your profile has been saved')\n if profile.user_type == 'dismantler':\n return redirect(reverse('addlisting'))\n else:\n return redirect(reverse('listings'))\n else:\n try:\n profile = Profile.objects.get(user=request.user)\n profile_form = EditProfileForm(instance=profile)\n context = {\n 'profile': profile,\n 'profile_form': profile_form,\n }\n except ObjectDoesNotExist:\n profile_form = EditProfileForm()\n context = {\n 'profile_form': profile_form,\n }\n\n return render(request, 'profile.html', context)","def edit_user(user_id):\n\n db_user = User.query.get_or_404(user_id)\n\n return render_template(\"edit_user.html\",\n headline=f\"Edit Blogly {db_user.get_full_name()}\",\n user=db_user)","def user_profile(request):\n instance = Profile.objects.get(pk=request.user.pk)\n if request.method == \"POST\":\n\n form = ProfileForm(request.POST, request.FILES, instance=instance)\n form.save()\n return redirect(reverse('index'))\n messages.error(request, \"Profile Updated\")\n\n profile = ProfileForm(instance=instance)\n return render(request, 'profile.html', {'profile': profile, 'instance': instance})","def profile(request):\n profile = get_object_or_404(UserProfile, user=request.user)\n\n # Date format to get todays games from Gameline model\n todays_date = datetime.datetime.now(pytz.timezone('America/Los_Angeles'))\n date_LA = todays_date.strftime('%B %-d, %Y')\n\n # Get all objects in MLBGameLine model\n all_games = MLBGameLine.objects.all()\n\n if request.method == \"POST\":\n form = EditProfileInfo(request.POST, instance=profile)\n if form.is_valid():\n form.save()\n messages.success(request, 'Successfully updated profile!')\n return redirect(reverse('profile'))\n else:\n messages.error(request,\n \"Failed to update profile.\")\n else:\n form = EditProfileInfo(instance=profile)\n\n template = \"profiles/profile.html\"\n context = {\n 'profile': profile,\n 'all_games': all_games,\n 'date_LA': date_LA,\n 'form': form,\n }\n\n return render(request, template, context)","def view_user_edit(self):\n\n logged_in = authenticated_userid(self.request)\n message = ''\n form = Form(self.request, schema=UserEditSchema,\n state=State(request=self.request))\n if form.validate():\n password = self.request.params['password']\n if self.context.validate_password(password):\n if self.request.params['new_password']:\n password = self.request.params['new_password']\n message = 'Successfully saved'\n email = self.request.params['email']\n self.context.edit(password, email)\n else:\n message = msg['password_invalid']\n return {\n 'message': message,\n 'project': '',\n 'username': self.context.username,\n 'logged_in': logged_in,\n 'form': FormRenderer(form),\n 'email': self.context.email\n }","def edit_profile(request):\n\n template = 'edit_profile.html'\n if request.method == 'POST': # If the form has been submitted...\n form = PatientEditForm(request.POST, instance=request.user.patient) # A form bound to the POST data\n if form.is_valid(): # All validation rules pass\n # Process the data in form.cleaned_data\n # ...\n form.save()\n return HttpResponseRedirect(reverse('index')) # Redirect after POST\n\n else:\n form = PatientEditForm(instance=request.user.patient)\n\n return TemplateResponse(request, template, {'form': form})","def user_edit(request):\n\n if request.method != 'POST':\n return HttpResponseNotAllowed(['POST'])\n\n data = json.loads(request.body.decode('utf-8'))\n\n auth_token = str(data.get('auth_token', ''))\n edit_user_info = data.get('edit_user_info', '')\n username = str(edit_user_info.get('username', ''))\n\n try:\n if not verify_admin(auth_token):\n raise PlantalyticsAuthException(ADMIN_INVALID)\n\n message = (\n 'Attempting to edit info for user: {}.'\n ).format(username)\n logger.info(message)\n check_user_parameters(edit_user_info)\n cassy.edit_user(edit_user_info)\n message = (\n 'Successfully edited info for user: {}.'\n ).format(username)\n logger.info(message)\n body = {\n 'errors': {}\n }\n return HttpResponse(\n json.dumps(body),\n content_type='application/json'\n )\n except PlantalyticsException as e:\n message = (\n 'Error attempting to edit user info. Error code: {}'\n ).format(str(e))\n logger.warn(message)\n error = custom_error(str(e))\n return HttpResponseForbidden(error, content_type='application/json')\n except Exception as e:\n message = (\n 'Unknown error occurred while attempting to edit user info:'\n )\n logger.exception(message)\n error = custom_error(UNKNOWN, str(e))\n return HttpResponseServerError(error, content_type='application/json')","def update_profile(username):\n\n description = request.json.get('description')\n token = request.headers.get('token')\n\n if description is None:\n return jsonify({'message': 'New description not provided'}), 404\n\n # Token Validation\n token_valid, response = is_token_valid(token)\n if not token_valid:\n return response\n token_username = response\n\n # Privilege handling\n if token_username != username:\n return jsonify({'message': \"You may not edit others profiles\"}), 404\n\n if username not in Profiles.keys():\n return jsonify({'message': 'User {} not found'.format(username)}), 404\n\n Profiles[username]['description'] = description\n return Profiles[username]","def profile(request):\n profile = get_object_or_404(UserProfile, user=request.user)\n\n if request.method == 'POST':\n form = UserProfileForm(request.POST, instance=profile)\n user_email = UserForm(instance=request.user)\n if form.is_valid():\n form.save()\n messages.success(request, 'Profile updated successfully')\n else:\n messages.error(request, 'Update failed. Please ensure the form is valid.')\n # doesnt work yet: Email is not saved:\n\n if user_email.is_valid():\n user_email.save()\n messages.success(request, 'Profile updated successfully')\n else:\n messages.error(request, 'Update failed. Please ensure the form is valid.')\n else:\n form = UserProfileForm(instance=profile)\n user_email = UserForm(instance=request.user)\n\n template = 'profiles/profile.html'\n context = {\n 'form': form,\n 'user_email': user_email,\n 'on_profile_page': True,\n 'profile': profile\n }\n\n return render(request, template, context)","def edit(user_id):\n if user_id != current_user.id:\n return abort(403)\n\n user = get_user(user_id)\n form = EditForm(obj=user)\n form.email.data = user.email\n\n if form.validate_on_submit():\n password = form.password.data\n username = form.username.data\n\n save_result = edit_user(user_id, password, username, user.active)\n user = save_result['entry']\n form = EditForm(request.form, obj=save_result['entry'])\n form.email.data = user.email\n return redirect(url_for('.index'))\n \n return render_template('users/edit.html'\n ,form=form\n ,user=user\n ,t=t\n ,m=m)","def test_change_username_changes_profile(self):\n user = self.users[0]\n profile = user.profile\n user.profile.bio = 'bio'\n user.profile.save()\n self.assertEquals(user.profile.bio, profile.bio)","def manage_myprofile(request):\n profile = request.user.get_profile()\n users_image = profile.users_image\n if not profile:\n raise Http404\n if request.method == 'POST':\n profile_form = MyProfileForm(request.POST, instance = profile)\n address_contact_form = AddressForm(request.POST,\n instance = profile.address_contact, prefix = 'contact')\n address_permanent_form = AddressForm(request.POST,\n instance = profile.address_permanent, prefix = 'permanent')\n\n if profile_form.is_valid() and address_contact_form.is_valid() \\\n and address_permanent_form.is_valid():\n address_contact = address_contact_form.save()\n address_permanent = address_permanent_form.save()\n\n profile_form.save(address_contact = address_contact,\n address_permanent = address_permanent)\n messages.success(request,\n _('your profile details saved sucessfully'))\n else:\n profile_form = MyProfileForm(instance = profile)\n address_contact_form = AddressForm(instance = profile.address_contact,\n prefix = 'contact')\n address_permanent_form = AddressForm(instance\n = profile.address_permanent, prefix = 'permanent')\n\n return render(request, 'myprofile.html', {\n 'profile_form': profile_form,\n 'address_contact_form': address_contact_form,\n 'address_permanent_form': address_permanent_form,\n 'users_image': users_image\n },\n )# Create your views here.","def add_profile():\n \n form=ProfileForm() \n if 'username' in session:\n user = mongo.db.user.find_one({'username': session['username']})\n pro = mongo.db.profiles.find_one({'user_id': user['_id']})\n if pro:\n flash('Sorry, only one profile per user permitted. You can update your profile on your dashboard under the profile tab.', 'info')\n return redirect(url_for('dashboard'))\n \n if request.method == 'POST':\n if form.validate_on_submit():\n \n mongo.db.profiles.insert_one({'user_id': user['_id'],\n 'headline': form.headline.data,\n 'bio': form.bio.data,\n 'username': session['username'],\n 'date': datetime.utcnow(),\n 'xp': form.xp.data,\n 'interests': form.interests.data,\n 'stack': form.stack.data,\n 'languages': form.languages.data,\n 'frameworks': form.frameworks.data,\n 'github': form.github.data,\n 'linkedin': form.linkedin.data\n })\n flash('Your profile has been created.', 'success')\n return redirect('profiles')\n \n return render_template('pages/addprofile.html', title='Post',\n form=form, legend='Create your profile')\n \n flash('You need to be logged in to post any content.', 'info')\n return redirect(url_for('login'))","def user_update_profile():\n \n if 'userid' and 'email' not in request.forms:\n return {'status':'Failure','message':'User Id is missing,please try with correct data.'}\n \n data = user_obj.user_update_profile(request.forms)\n return data","def putProfile(profileType,value):\n # PUT /profile/$profileType\n pass","def _doProfile(self, save_request=None):\n prof = self._getProfileFromUser()\n # If saveProfile(), process user-modifyable fields\n if save_request:\n for field in ('displayName', 'teeShirtSize'):\n if hasattr(save_request, field):\n val = getattr(save_request, field)\n if val:\n print(val)\n setattr(prof, field, str(val))\n prof.put()\n # Return ProfileForm\n return self._copyProfileToForm(prof)","def get(self, request):\n user = YouYodaUser.objects.get(auth_token=request.headers['Authorization'].replace('Token ', ''))\n serializer = ProfileEditSerializer(user)\n return Response(serializer.data)","def account_profile(request):\n get_or_creat(request)\n return redirect(\"/\")","def profile_url(self):\n return reverse(\"auth_profile\", args=[self.user.username])"],"string":"[\n \"def edit_profile(self, name, username, email):\\n return self.app.post('/_editProfile', data = dict(\\n name = name,\\n username = username,\\n email = email\\n ), follow_redirects = True)\",\n \"def edit_user():\\n if CURR_USER_KEY in session:\\n user = g.user\\n form = ProfileEditForm(obj=user)\\n\\n if form.validate_on_submit():\\n user.first_name = form.first_name.data\\n user.last_name = form.last_name.data\\n user.description = form.description.data\\n user.email = form.email.data\\n user.image_url = form.image_url.data or \\\"/static/images/default-pic.png\\\"\\n\\n db.session.commit()\\n\\n flash(\\\"Profile edited.\\\")\\n return redirect(\\\"/profile\\\")\\n\\n return render_template('/profile/edit-form.html', form=form)\\n else:\\n return redirect('/login')\",\n \"def edit_profile(request, pk=None):\\n profiledetails = UserProfile.objects.filter(user=request.user).first()\\n if UserProfile.objects.filter(user=request.user or request.user.is_superuser):\\n\\n if request.method == \\\"POST\\\":\\n profile_details_form = UserProfileForm(request.POST, request.FILES, instance=profiledetails)\\n if profile_details_form.is_valid():\\n profiledetails = profile_details_form.save()\\n messages.success(request, 'Your profile has been updated!')\\n return redirect(user_profile)\\n else:\\n profile_details_form = UserProfileForm(instance=profiledetails)\\n else:\\n return HttpResponseForbidden()\\n \\n return render(request, 'newprofiledetails.html', {'profile_details_form': profile_details_form})\",\n \"def edit_profile(request):\\n if request.method == 'POST':\\n form = EditProfileForm(request.POST, instance=request.user)\\n\\n if form.is_valid():\\n form.save()\\n messages.success(request, 'Profile updated successfully.')\\n return redirect('profile')\\n\\n else:\\n messages.error(request, 'Invalid entry, please try again.')\\n return redirect('edit_profile')\\n else:\\n form = EditProfileForm(instance=request.user)\\n return render(request, 'accounts/edit_profile.html', {'form': form})\",\n \"def viewprofile():\\n user = current_user\\n form = UserUpdateForm(obj=user)\\n form.populate_obj(user)\\n if form.validate_on_submit():\\n form.populate_obj(user)\\n\\n db.session.commit()\\n\\n flash('You have successfully edited your profile!')\\n return render_template('user/user.html', title=\\\"View Profile\\\",\\n user=user, form=form, action='Edit')\",\n \"def view_profile():\\n user_id = session.get(\\\"user_id\\\")\\n \\n user = User.query.get(session[\\\"user_id\\\"])\\n \\n return render_template(\\\"editable_profile_page.html\\\", user=user)\",\n \"def edit_profile(profile_id):\\n # This check is in place to avoid users trying to edit a profile via the dashboard\\n # when they have not created one. If not the option is not displayed\\n user = mongo.db.user.find_one({'username': session['username']})\\n chck = mongo.db.profiles.find_one_or_404({'user_id': user['_id']})\\n if chck: \\n profile = mongo.db.profiles.find_one(\\n {'_id': ObjectId(profile_id)})\\n \\n form=ProfileForm()\\n form.headline.data = profile['headline']\\n form.bio.data = profile['bio']\\n form.xp.data = profile['xp']\\n form.interests.data = profile['interests']\\n form.stack.data = profile['stack']\\n form.languages.data = profile['languages']\\n form.frameworks.data = profile['frameworks']\\n form.github.data = profile['github']\\n form.linkedin.data = profile['linkedin']\\n \\n return render_template('pages/editprofile.html', form=form, profile=profile, legend='Edit your Profile')\",\n \"def edit_profile(request):\\n profile_to_edit = get_object_or_404(UserProfile, user=request.user)\\n if request.method == \\\"POST\\\":\\n form = UserProfileForm(request.POST, instance=profile_to_edit)\\n if form.is_valid:\\n form.save()\\n messages.success(request, \\\"Profile updated succesfully\\\")\\n return redirect('profile')\\n else:\\n messages.error(request, \\\"Updated failed. \\\\\\n Please ensure the form is valid\\\")\\n else:\\n profile_form = UserProfileForm(instance=profile_to_edit)\\n template = 'profiles/edit_profile.html'\\n context = {\\n 'form': profile_form,\\n }\\n return render(request, template, context)\",\n \"def profile():\\n\\n if not g.user:\\n flash(\\\"Access unauthorized.\\\", \\\"danger\\\")\\n return redirect(\\\"/\\\")\\n\\n form = UserEditForm(obj=g.user)\\n\\n if form.validate_on_submit():\\n if not User.authenticate(g.user.username, form.data[\\\"password\\\"]):\\n flash(\\\"Invalid password.\\\", \\\"danger\\\")\\n return render_template('/users/edit.html', form=form) \\n # data = {k:v for k,v in form.data.items() if k != \\\"csrf_token\\\"}\\n # data[\\\"image_url\\\"] = data[\\\"image_url\\\"] or None\\n # data[\\\"header_image_url\\\"] = data[\\\"header_image_url\\\"] or None\\n\\n g.user.username = form.data[\\\"username\\\"]\\n g.user.email = form.data[\\\"email\\\"]\\n g.user.image_url = form.data[\\\"image_url\\\"] or None\\n g.user.header_image_url = form.data[\\\"header_image_url\\\"] or None\\n g.user.bio = form.data[\\\"bio\\\"]\\n\\n db.session.commit()\\n\\n flash(\\\"Profile edited!\\\", \\\"success\\\")\\n return redirect(f'/users/{g.user.id}')\\n\\n return render_template('/users/edit.html', form=form)\",\n \"def test_that_a_user_can_edit_their_profile(self):\\n self.authorize_user(self.user_login_details)\\n url = self.profiles_url + \\\\\\n '{}'.format(self.user['user']['username']) + \\\"/\\\"\\n response = self.client.patch(url, data=self.user_bio)\\n self.assertEqual(response.data['bio'], \\\"You are a peculiar man.\\\")\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\",\n \"def profile():\\n\\n form = EditUserForm(obj=g.user)\\n\\n if form.validate_on_submit():\\n if User.authenticate(g.user.username, form.password.data):\\n g.user.username = form.username.data\\n g.user.email = form.email.data\\n g.user.image_url = form.image_url.data\\n g.user.header_image_url = form.header_image_url.data\\n g.user.bio = form.bio.data\\n g.user.private = form.private.data\\n db.session.commit()\\n return redirect(f'/users/{g.user.id}')\\n flash('Incorrect password', 'danger')\\n return render_template('users/edit.html', user_id=g.user.id, form=form)\",\n \"def can_edit_profile(user: User, owner: User) -> bool:\\n\\n return has_permission(user, \\\"edit_profiles\\\") or user == owner\",\n \"def profile_edit():\\n form = ProfileForm(obj=current_user)\\n\\n if form.validate_on_submit():\\n form.populate_obj(current_user)\\n\\n try:\\n correct = True\\n db.session.commit()\\n\\n flash(_('Profile updated correctly'), 'success')\\n\\n return render_template('admin/profile/edit.html', form=form)\\n\\n except IntegrityError:\\n # Email already exists\\n correct = False\\n form.errors.email.append(_('Email is already registered'))\\n\\n return render_template('admin/profile/edit.html', form=form)\\n\\n except Exception:\\n # Catch anything unknown\\n correct = False\\n\\n flash(_('Failed to update profile, contact an administrator'), 'error')\\n\\n return render_template('admin/profile/edit.html', form=form)\\n\\n finally:\\n if not correct:\\n db.session.rollback()\\n\\n return render_template('admin/profile/edit.html', form=form)\",\n \"def edit_profile(request, userid):\\n woofer_user = User.objects.get(id=userid)\\n current_profile = Profile.objects.get(user=woofer_user)\\n if woofer_user.id != request.user.id:\\n return HttpResponseRedirect(reverse('view-profile', args=[userid]))\\n\\n if request.method == 'POST':\\n form = ProfileForm(request.POST)\\n if form.is_valid():\\n new_profile = form.save(commit=False)\\n # copy the ID of the User's current profile to the new profile so\\n # Django performs an update when we call .save()\\n new_profile.id = current_profile.id\\n new_profile.user = woofer_user\\n new_profile.save()\\n return HttpResponseRedirect(reverse('view-profile', args=[userid]))\\n else:\\n form = ProfileForm(instance=current_profile)\\n\\n return render(request, 'woofer/show_form.html', {\\n 'form' : form,\\n 'message' : None,\\n 'form_action' : reverse('edit-profile', args=[userid]),\\n 'title' : \\\"Edit Profile\\\"\\n })\",\n \"def edit_profile(request):\\n profile = request.user.profile\\n form = forms.ProfileForm(instance=profile)\\n\\n if request.method == 'POST':\\n if settings.SYSTEM_MAINTENANCE_NO_UPLOAD:\\n # Allow submitting the form, but do not allow the photo to\\n # be modified.\\n if 'delete_photo' in request.POST or request.FILES:\\n raise ServiceUnavailable()\\n\\n if 'edit_profile' in request.POST:\\n # Update the profile and return to the same page. Place a message\\n # at the top of the page: 'your profile has been updated'\\n form = forms.ProfileForm(data=request.POST, files=request.FILES,\\n instance=profile)\\n if form.is_valid():\\n form.save()\\n messages.success(request, 'Your profile has been updated.')\\n elif 'delete_photo' in request.POST:\\n profile.delete_photo()\\n messages.success(request, 'Your profile photo has been deleted.')\\n\\n if not form.errors:\\n form = forms.ProfileForm(instance=profile)\\n\\n return render(request, 'user/edit_profile.html', {'form':form})\",\n \"def edit_profile(request):\\n form = ProfileForm(instance=request.user.profile)\\n if request.method == \\\"POST\\\":\\n form = ProfileForm(data=request.POST, files=request.FILES,\\n instance=request.user.profile)\\n if form.is_valid():\\n form.save()\\n return redirect('profile')\\n return render(request, 'accounts/forms.html', {'form': form})\",\n \"def edit_user_profile(request):\\n user = request.user\\n user_profile = UserProfile.objects.filter(user=user)[0]\\n if request.method == 'POST':\\n form = MemberProfileForm(request.POST)\\n additional_form = MemberAdditionalProfileForm(request.POST)\\n if form.is_valid() and additional_form.is_valid():\\n cd = form.cleaned_data\\n user.first_name = cd['first_name']\\n user.last_name = cd['last_name']\\n user.email = cd['email']\\n user.save()\\n if 'picture' in request.FILES:\\n file = request.FILES['picture']\\n user_profile.picture.save(file.name, file, save=True)\\n user_profile.gravatar = additional_form.cleaned_data['gravatar']\\n user_profile.save()\\n return HttpResponseRedirect('/')\\n else:\\n form = MemberProfileForm(instance=request.user)\\n additional_form = MemberAdditionalProfileForm(instance=user_profile)\\n return render_to_response('edit_profile.html', locals())\",\n \"def edit_profile():\\n form = EditProfileForm()\\n if request.method == 'GET':\\n form.first_name.data = current_user.first_name\\n form.first_name.data = current_user.first_name\\n form.last_name.data = current_user.last_name\\n form.email.data = current_user.email\\n form.address_1.data = current_user.address_1\\n form.address_2.data = current_user.address_2\\n form.city.data = current_user.city\\n form.state.data = current_user.state\\n form.zipcode.data = current_user.zipcode\\n form.telephone.data = current_user.telephone\\n if form.validate_on_submit():\\n form.last_name.data = form.last_name.data\\n current_user.first_name = form.first_name.data\\n current_user.last_name = form.last_name.data\\n current_user.email = form.email.data\\n current_user.address_1 = form.address_1.data\\n current_user.address_2 = form.address_2.data\\n current_user.city = form.city.data\\n current_user.state = form.state.data\\n current_user.zipcode = form.zipcode.data\\n current_user.telephone = form.telephone.data\\n db.session.commit()\\n flash(('Your changes have been saved.'))\\n\\n return redirect(url_for('edit_profile'))\\n\\n return render_template('edit_profile.html', title=('Edit Profile'),\\n form=form)\",\n \"def edit_basic_info(request):\\n if request.POST:\\n request.user.first_name = request.POST['first_name']\\n request.user.last_name = request.POST['last_name']\\n request.user.email = request.POST['email']\\n request.user.save()\\n request.user.userprofile.phone_number = request.POST['phone']\\n request.user.userprofile.save()\\n messages.add_message(request, messages.SUCCESS, 'Your changes have been saved.')\\n return redirect('base_dashboard')\\n\\n return render(request, 'edit_basic_info.html', {'the_user': request.user})\",\n \"def home_edituser():\\n\\tpass\",\n \"def profile_edit(request):\\n if request.user.is_authenticated:\\n u = request.user\\n context = ProfileContext(u).get_context_with_form()\\n context = calculate_char_in_textarea(context)\\n return render(request, 'wantedly_app/profile_edit.html', context)\\n else:\\n return redirect('home')\",\n \"def profile(request):\\n profile = request.user.profile\\n return render(request, 'accounts/profile.html', {'profile': profile})\",\n \"def edit_profile_post(request, pk=None):\\n profilepost = get_object_or_404(ProfilePost, pk=pk) \\n if (request.user == profilepost.user or\\n request.user.is_superuser):\\n if request.method == \\\"POST\\\":\\n profile_post_form = ProfilePostForm(request.POST, request.FILES, instance=profilepost)\\n if profile_post_form.is_valid():\\n profilepost = profile_post_form.save()\\n messages.success(request, 'Your post has been updated!') \\n return redirect(reverse('profile'))\\n else:\\n profile_post_form = ProfilePostForm(instance=profilepost)\\n else:\\n return HttpResponseForbidden()\\n\\n return render(request, 'newprofilepost.html', {'profile_post_form': profile_post_form})\",\n \"def show_profile(request, profile_uuid):\\n context = context_assign_user(request.user)\\n context['profile_form'] = ProfileForm(instance=context['current_user'])\\n if request.method == 'POST':\\n form = ProfileForm(request.POST)\\n if form.is_valid():\\n Profile.objects.filter(pk=context['current_user'].id).update(bio=request.POST['bio'], palette=request.POST['palette'], iex_api_key=request.POST['iex_api_key'])\\n messages.success(request, 'Your settings have been saved.')\\n return redirect('dash:dashboard')\\n errors = form.errors\\n form = ProfileForm(request, request.POST)\\n messages.warning(request, f\\\"There's a problem with the form: {errors}\\\")\\n return render(request, 'dash/users/show_profile.html', context)\",\n \"def user_view(cls, user, profile):\\r\\n pass\",\n \"def user_profile():\\n user = current_user\\n user_is_valid = True\\n if not user.active:\\n flash('This user account is under review. Please update your profile '\\n + ' and contact the organizing team to access all functions of '\\n + 'this platform.', 'warning')\\n\\n form = UserForm(obj=user, next=request.args.get('next'))\\n form.roles.choices = [(r.id, r.name) for r in Role.query.order_by('name')]\\n\\n # Check conflicting PKs\\n if form.email.data != user.email:\\n if User.query.filter_by(email=form.email.data).first() is not None:\\n flash('This e-mail address is already registered.', 'error')\\n user_is_valid = False\\n\\n if user.sso_id:\\n # Do not allow changing password on SSO\\n del form.password\\n\\n # Validation has passed\\n if form.is_submitted() and form.validate() and user_is_valid:\\n # Assign roles\\n user.roles = [Role.query.filter_by(\\n id=r).first() for r in form.roles.data]\\n del form.roles\\n\\n # Sanitize username\\n user.username = sanitize_input(form.username.data)\\n del form.username\\n\\n # Assign password if changed\\n originalhash = user.password\\n form.populate_obj(user)\\n # Do not allow changing password on SSO\\n if not user.sso_id:\\n if form.password.data:\\n user.set_password(form.password.data)\\n else:\\n user.password = originalhash\\n\\n user.updated_at = datetime.utcnow()\\n db.session.add(user)\\n db.session.commit()\\n user.socialize()\\n flash('Profile updated.', 'success')\\n return redirect(url_for('public.user', username=user.username))\\n\\n if not form.roles.choices:\\n del form.roles\\n else:\\n form.roles.data = [(r.id) for r in user.roles]\\n return render_template('public/useredit.html',\\n oauth_type=oauth_type(),\\n user=user, form=form,\\n active='profile')\",\n \"def edit_user(request, user_id):\\n profile = get_object_or_404(UserProfile, user=request.user)\\n\\n # make sure only managers and admins can add a team\\n if profile.level == 'admin' or profile.level == 'manager':\\n\\n user = get_object_or_404(UserProfile, pk=user_id)\\n if request.method == 'POST':\\n form = UserProfileForm(request.POST, request.FILES, instance=user)\\n if form.is_valid():\\n form.save()\\n messages.success(request, 'User edited successfully')\\n\\n users = UserProfile.objects.filter(company_id=profile.company_id)\\n template = 'profiles/user_management.html'\\n context = {\\n 'users': users,\\n 'profile': profile\\n }\\n return render(request, template, context)\\n\\n else:\\n print(\\\"failed\\\")\\n else:\\n form = UserProfileForm(instance=user)\\n\\n template = 'profiles/profile.html'\\n context = {\\n 'form': form,\\n 'profile': user,\\n }\\n\\n return render(request, template, context)\\n\\n else:\\n messages.info(request, \\\"Sorry, you are not authorized to edit users. Ask a Manager or Admin.\\\")\\n\\n return redirect(reverse('planning', ))\",\n \"def profile():\\n if g.user:\\n return render_template('profile.html', user=g.user)\\n return redirect(url_for('login'))\",\n \"def user_view(cls, user, profile):\\n pass\",\n \"def test_user_edit_profile(self):\\n with self.client as c:\\n with c.session_transaction() as sess:\\n sess[CURR_USER_KEY] = self.testuser_id\\n\\n address = \\\"1215 Brookview Ave, Kettering, Ohio 45409\\\"\\n\\n resp = c.get(f\\\"/users/8989/\\\")\\n html = resp.get_data(as_text=True)\\n\\n self.assertEqual(resp.status_code, 200)\\n self.assertIn(\\n '<h1 class=\\\"Display-4 text-center mt-3\\\"><b>Profile Information:</b></h1>',\\n html,\\n )\\n self.assertIn(\\\"<p>testuser</p>\\\", html)\\n self.assertIn(\\\"<p>test@test.com</p>\\\", html)\\n self.assertIn(\\\"<p>662-996-3356</p>\\\", html)\\n self.assertIn(\\n '<a class=\\\"font-weight-bold btn winter-neva-gradient color-block btn-block my-4 waves-effect z-depth-0\\\" href=\\\"/users/8989/edit\\\">Edit Profile</a>',\\n html,\\n )\",\n \"def edit_profile_view(request, user_id=0):\\n\\tuser = User.objects.filter(id=user_id)[0]\\n\\tstalker = request.user\\n\\tif stalker != user:\\n\\t\\treturn HttpResponse(\\\"Go away guys, nothing to see here!\\\")\\n\\telse:\\n\\t\\tuser_indicator = 0 # Used to check if the user is logged in \\n\\t\\tif (stalker.is_authenticated()):\\n\\t\\t\\tuser_indicator = 1\\n\\t\\telse:\\n\\t\\t\\tuser_indicator = 0\\n\\t\\t# show a form with data from database for 'GET' request\\n\\t\\tif request.method == 'GET':\\n\\t\\t\\tperson = Person.objects.filter(user=user)[0]\\n\\t\\t\\taccount_form = AccountDetailForm(initial={\\n\\t\\t\\t\\t'user_name': user.username,\\n\\t\\t\\t\\t'user_email': user.email,\\n\\t\\t\\t\\t'user_faculty': person.faculty,\\n\\t\\t\\t}) # Display user account detail\\n\\t\\t\\taccount_form.fields['user_name'].disabled = False\\n\\t\\t\\taccount_form.fields['user_email'].disabled = False\\n\\t\\t\\taccount_form.fields['user_faculty'].disabled = False\\n\\n\\t\\t\\tlocation_form = LocationForm() # Display location box for user to type into\\n\\n\\t\\t\\tlive_update_list = LiveUpdate.objects.all().order_by('date_time') # Display live update list\\n\\n\\t\\t\\tfriend_update_list = FriendUpdate.objects.filter(receiver=user).order_by('date_time') # Display friend update list\\n\\n\\t\\t\\tfriend_request_list = FriendRequest.objects.filter(receiver=user).order_by('-date_time') # Display friend request list\\n\\n\\t\\t\\tfriend_list = person.friends.all() # Display all friends list\\n\\n\\t\\t\\taddfriend_indicator = 0 # Help decide the status of the add friend button\\n\\t\\t\\tperson_2 = Person.objects.filter(user=stalker)[0]\\n\\t\\t\\tif (person_2 in friend_list):\\n\\t\\t\\t\\taddfriend_indicator = 2 # stalker and user whose profile being shown are friends\\n\\t\\t\\telse:\\n\\t\\t\\t\\trelevant_request = FriendRequest.objects.filter(sender=stalker,receiver=user)\\n\\t\\t\\t\\tif len(relevant_request) == 0:\\n\\t\\t\\t\\t\\taddfriend_indicator = 0 # stalker has not added user whose profile is being shown as a friend\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\taddfriend_indicator = 1 # stalker has added user whose profile is being shown as a friend\\n\\n\\t\\t\\treturn render(request, 'mugspot/userprofile_edit.html', {\\n\\t\\t\\t\\t\\t'live_update_list':live_update_list,\\n\\t\\t\\t\\t\\t'friend_update_list': friend_update_list,\\n\\t\\t\\t\\t\\t'location_form': location_form,\\n\\t\\t\\t\\t\\t'account_form': account_form,\\n\\t\\t\\t\\t\\t'friend_list': friend_list,\\n\\t\\t\\t\\t\\t'friend_request_list': friend_request_list,\\n\\t\\t\\t\\t\\t'user_prof': user,\\n\\t\\t\\t\\t\\t'stalker': stalker,\\n\\t\\t\\t\\t\\t'user_indicator': user_indicator,\\n\\t\\t\\t\\t\\t'addfriend_indicator': addfriend_indicator,\\n\\t\\t\\t\\t})\",\n \"def edit_user(request, username):\\n context = {}\\n detail = IMPUser.objects.all().filter(username = username)\\n if detail:\\n context = {'username':username,\\n 'display_name':detail[0].display_name,\\n 'tel':detail[0].tel,\\n 'mobile':detail[0].mobile,\\n 'office':detail[0].office,\\n 'num':detail[0].num}\\n return render(request, \\\"account/edit_user.html\\\", context)\",\n \"def test_that_a_user_cannot_edit_another_users_profile(self):\\n self.authorize_user(self.user_login_details)\\n self.register_user(self.user2)\\n url = self.profiles_url + \\\\\\n '{}'.format(self.user2['user']['username']) + \\\"/\\\"\\n response = self.client.patch(url, data=self.user_bio)\\n message = \\\"You don't have permission to edit this profile\\\"\\n self.assertEqual(response.data['message'], message)\\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)\",\n \"def edit_profile():\\n # handle pre-flight for browsers CORS access\\n if request.method == \\\"OPTIONS\\\":\\n return generate_response()\\n # part1: verify that user has logged in and the request is legit\\n checked_and_verified, response = check_verify_token(request,login_session)\\n if checked_and_verified != True: return response\\n # handle the edge case where user is authorized to perform create user but not other method\\n if not is_loggedin(login_session):\\n response = generate_message(MESSAGE_USER_NOT_LOGGED_IN,401)\\n return response\\n # part2: check json\\n checked_json, response, requested_json = check_json_form(request,MESSAGE_BAD_JSON,MESSAGE_CREATE_USER_NO_JSON)\\n if checked_json != True: return response\\n # part3: verify json data\\n try:\\n user_email = login_session[\\\"login_user_email\\\"]\\n except KeyError:\\n # key error means we are offline til this far\\n user_email = requested_json[\\\"email\\\"]\\n # design decision: if there are invalid field names, only update the valid fields.\\n # check updates keys and formats\\n try:\\n update_pairs = convert_to_underscore(requested_json[\\\"updates\\\"])\\n \\n if isinstance(update_pairs,dict) != True:\\n response = generate_message(MESSAGE_UPDATE_PROFILE_NON_DICT,400)\\n else:\\n correct_format,valid_update_pairs, response = process_request_json(User,update_pairs)\\n if correct_format == True: \\n update_field(User, session, {\\\"email\\\": user_email},valid_update_pairs)\\n response = generate_message(MESSAGE_UPDATE_PROFILE_SUCCESS,200)\\n except KeyError:\\n response = generate_message(MESSAGE_UPDATE_PROFILE_NO_ENTRY,400)\\n return response\",\n \"def __profileChanged(self, inst, topic, value):\\n\\n old, new = value\\n\\n if new is orthoeditprofile.OrthoEditProfile:\\n self.__addEditMenu()\\n elif old is orthoeditprofile.OrthoEditProfile:\\n self.__removeEditMenu()\",\n \"def edit_user_profile(user_id):\\n if CURRENT_USER_KEY not in session or session[CURRENT_USER_KEY] != user_id:\\n raise Unauthorized()\\n\\n user = User.query.get_or_404(user_id)\\n\\n form = UserEditForm(obj=user)\\n\\n if form.validate_on_submit():\\n try:\\n user.email = form.email.data\\n user.username = form.username.data\\n user.first_name = form.first_name.data.capitalize()\\n user.last_name = form.last_name.data.capitalize()\\n user.image_url = form.image_url.data or User.image_url.default.arg\\n user.cover_url = form.cover_url.data or User.cover_url.default.arg\\n user.bio = form.bio.data\\n\\n db.session.commit()\\n except IntegrityError:\\n db.session.rollback()\\n flash(\\n \\\"Email or Username already taken!! Please try again\\\", 'danger')\\n return render_template('edit_profile.html', form=form, user=user, img_src=user.image_url)\\n\\n flash('Profile Successfully Updated!', 'success')\\n return redirect(url_for('show_user_profile', user_id=user.id))\\n return render_template('edit_profile.html', form=form, user=user, img_src=user.image_url)\",\n \"def test_edit_profile(self):\\n \\n LOGGER.debug(\\\"Test GET /rango/edit/ for anon user\\\")\\n anon_edit_response = self.client.get('/rango/edit/')\\n # redirected to login page\\n self.assertEquals(302, anon_edit_response.status_code)\\n self.assertRedirects(anon_edit_response, \\\"http://testserver/accounts/login/?next=/rango/edit/\\\")\\n\\n LOGGER.debug(\\\"Test GET /rango/edit/ for logged in user\\\")\\n self.client.login(username='leothelion', password='rawr')\\n logged_in_edit_response = self.client.get('/rango/edit/')\\n self.assertContains(logged_in_edit_response, \\\"leo\\\")\",\n \"def allow_edit_by(self, user2_compare):\\n if user2_compare.is_superuser:\\n return True\\n\\n if user2_compare == self.user:\\n return True\\n\\n if (self.creator and self.creator == user2_compare) or \\\\\\n (self.owner and self.owner == user2_compare):\\n if self.status:\\n return True\\n\\n if user2_compare.has_perm('profiles.change_profile', self):\\n return True\\n\\n return False\",\n \"def user_can_edit(self, user):\\n return user == self.owner\",\n \"def edit_user(request, email):\\n if not email:\\n if request.POST and request.POST['email']:\\n url = urlresolvers.reverse('views.admin.edit_user',\\n args=[request.POST['email']])\\n return http.HttpResponseRedirect(url)\\n else:\\n return utility.respond(request, 'admin/edit_user', {'title': 'Edit user'})\\n\\n profile = models.UserProfile.load(email)\\n if not profile:\\n return utility.page_not_found(request)\\n title = 'Edit user: ' + email\\n\\n return utility.edit_instance(request, models.UserProfile, forms.UserEditForm,\\n 'admin/edit_user',\\n urlresolvers.reverse('views.admin.index'),\\n profile.key().id(), title=title, profile=profile)\",\n \"def user_settings(request):\\n return redirect('edit_profile')\",\n \"def __str__(self):\\n return self.user.username + \\\"'s Profile\\\"\",\n \"def edit_profile(request, userId):\\n try:\\n try:\\n user = User.objects.get(pk=userId)\\n profile = Profile.objects.get(user_id=userId)\\n user.first_name = request.data['first_name'] if 'first_name' in request.data else user.first_name\\n user.last_name = request.data['last_name'] if 'last_name' in request.data else user.last_name\\n user.email = request.data['email'] if 'email' in request.data else user.email\\n profile.phone = request.data['phone'] if 'phone' in request.data else profile.phone\\n profile.profile_img_path = request.data['profile_img_path'] if 'profile_img_path' in request.data else profile.profile_img_path\\n profile.information = request.data['information'] if 'information' in request.data else profile.information\\n user.save()\\n profile.save()\\n return JsonResponse({\\n \\\"statusCode\\\": 200,\\n \\\"statusText\\\": \\\"Success\\\",\\n \\\"message\\\": \\\"Save profile success\\\",\\n \\\"error\\\": False\\n })\\n\\n except ObjectDoesNotExist:\\n return JsonResponse({\\n \\\"statusCode\\\": 404,\\n \\\"statusText\\\": \\\"Not Found\\\",\\n \\\"message\\\": \\\"User Not Exist\\\",\\n \\\"error\\\": True\\n })\\n except:\\n return JsonResponse({\\n \\\"statusCode\\\": 500,\\n \\\"statusText\\\": \\\"Internal Server\\\",\\n \\\"message\\\": \\\"Internal Server\\\",\\n \\\"error\\\": True\\n })\",\n \"def editProfile():\\n form = EditProfileForm(request.form)\\n if request.method == \\\"GET\\\":\\n return render_template(\\\"/pages/editprofile.html\\\", form=form)\\n else:\\n choose = True\\n section = form.category.data\\n return redirect(url_for(\\\"editProfileSection\\\", section=section))\",\n \"def user_profile():\\n if CURR_USER_KEY in session:\\n return render_template('/profile/detail.html')\\n else:\\n return redirect('/login')\",\n \"def profile(request, info=\\\"\\\", error_msg=\\\"\\\", messages=\\\"\\\"):\\r\\n try:\\r\\n user = _validate_and_get_geniuser(request)\\r\\n except LoggedInButFailedGetGeniUserError:\\r\\n return _show_failed_get_geniuser_page(request)\\r\\n\\r\\n email_form = forms.gen_edit_user_form(instance=user)\\r\\n affiliation_form = forms.gen_edit_user_form(instance=user)\\r\\n password_form = forms.EditUserPasswordForm()\\r\\n\\r\\n if request.method == 'POST':\\r\\n if 'affiliation' in request.POST:\\r\\n affiliation_form = forms.gen_edit_user_form(('affiliation',), request.POST, instance=user)\\r\\n if affiliation_form.is_valid():\\r\\n new_affiliation = affiliation_form.cleaned_data['affiliation']\\r\\n interface.change_user_affiliation(user, new_affiliation)\\r\\n info =\\\"Affiliation has been successfully changed to %s.\\\" % (user.affiliation)\\r\\n elif 'email' in request.POST:\\r\\n email_form = forms.gen_edit_user_form(('email',), request.POST, instance=user)\\r\\n if email_form.is_valid():\\r\\n new_email = email_form.cleaned_data['email']\\r\\n interface.change_user_email(user, new_email)\\r\\n info =\\\"Email has been successfully changed to %s.\\\" % (user.email)\\r\\n elif 'password1' in request.POST:\\r\\n password_form = forms.EditUserPasswordForm( request.POST, instance=user)\\r\\n if password_form.is_valid():\\r\\n new_password = password_form.cleaned_data['password1']\\r\\n interface.change_user_password(user, new_password)\\r\\n info =\\\"Password has been successfully changed\\\"\\r\\n\\r\\n username = user.username\\r\\n affiliation = user.affiliation\\r\\n email = user.email\\r\\n port = user.usable_vessel_port\\r\\n has_privkey = user.user_privkey != None\\r\\n #currently not used, needed if editing user port is allowed\\r\\n #port_range = interface.get_useable_ports()\\r\\n #port_range_min = port_range[0]\\r\\n #port_range_max = port_range[-1]\\r\\n\\r\\n return render_to_response('control/profile.html',\\r\\n {'email_form' : email_form,\\r\\n 'affiliation_form' : affiliation_form,\\r\\n 'password_form' : password_form,\\r\\n 'username' : username,\\r\\n 'affiliation' : affiliation,\\r\\n 'email' : email,\\r\\n 'port' : port,\\r\\n 'api_key' : user.api_key,\\r\\n 'has_privkey' : has_privkey,\\r\\n #'port_range_min' : port_range_min,\\r\\n #'port_range_max' : port_range_max,\\r\\n 'info' : info,\\r\\n 'error_msg' : error_msg,\\r\\n 'messages' : messages},\\r\\n context_instance=RequestContext(request))\",\n \"def edit_user(self):\\n from editWindow import EditPlayer\\n self.edit = EditPlayer(self.lang, self.result_table.currentItem().text())\\n self.edit.show()\",\n \"def edit_user(user_id):\\n user = User.query.get_or_404(user_id)\\n return render_template('/users/edit_page.html', user=user)\",\n \"def getEditUser(self, request):\\n\\n userForm = UserEditForm(instance=request.user)\\n profileForm = ProfileEditForm(instance=request.user.profile)\\n return (userForm, profileForm)\",\n \"def edit_show_user(user_id):\\n edited_user = User.query.get_or_404(user_id)\\n\\n edited_user.first_name = request.form['first_name']\\n edited_user.last_name = request.form['last_name']\\n edited_user.image_url = request.form['image_url']\\n\\n db.session.add(edited_user)\\n db.session.commit()\\n\\n return redirect('/')\",\n \"def profile(request):\\n if request.user.is_authenticated():\\n obj = get_object_or_404(TolaUser, user=request.user)\\n form = RegistrationForm(request.POST or None, instance=obj, initial={'username': request.user})\\n\\n if request.method == 'POST':\\n if form.is_valid():\\n form.save()\\n messages.error(request, 'Your profile has been updated.', fail_silently=False)\\n\\n return render(request, \\\"registration/profile.html\\\", {\\n 'form': form, 'helper': RegistrationForm.helper\\n })\\n else:\\n return HttpResponseRedirect(\\\"/accounts/register\\\")\",\n \"def update_user_profile(request):\\n if request.method == 'POST':\\n form = UserProfileForm(request.POST)\\n\\n if form.is_valid():\\n user = get_object_or_404(User, pk=request.user.pk)\\n user.first_name = request.POST['first_name']\\n user.last_name = request.POST['last_name']\\n user.profile_picture = request.POST['profile_picture']\\n user.save()\\n messages.success(request, 'Your profile has been updated!')\\n else:\\n messages.error(\\n request, 'Unable to update your profile. Please try again later.')\\n\\n return HttpResponseRedirect(request.META.get('HTTP_REFERER', reverse('dev_panel')))\",\n \"def display_profile(self):\\n print(f\\\"Id: {self._id}\\\")\\n print(f\\\"username: {self.username}\\\")\\n print(f\\\"name: {self.name}\\\")\\n print(f\\\"contact: {self.contact}\\\")\\n print(f\\\"address: {self.address}\\\")\",\n \"def profile(request, id):\\n u = get_object_or_404(User, pk=id)\\n context = ProfileContext(u).get_context()\\n return render(request, 'wantedly_app/profile.html', context)\",\n \"def current_profile(request):\\n if not request.user.is_authenticated():\\n return HttpResponseRedirect(reverse('login'))\\n return profile(request, request.user.username)\",\n \"def current_profile(request):\\n if not request.user.is_authenticated():\\n return HttpResponseRedirect(reverse('login'))\\n return profile(request, request.user.username)\",\n \"def test_onchange_user_profile(self):\\n admin = self.env.ref('base.user_root').id\\n with self.assertRaises(ValidationError):\\n self.env['res.users'].browse(\\n self.user.id).write({'user_profile_id': admin})\",\n \"def edit_user(request, userid):\\n if request.method == 'POST':\\n form = UserDetailsForm(request.POST)\\n if form.is_valid():\\n # we're going to update the first_name, last_name, and email fields of this object\\n user = request.user\\n user.first_name = form.cleaned_data['first_name']\\n user.last_name = form.cleaned_data['last_name']\\n user.email = form.cleaned_data['email']\\n user.save()\\n return HttpResponseRedirect(reverse('view-profile', args=[userid]))\\n else:\\n form = UserDetailsForm(instance=request.user)\\n\\n return render(request, 'woofer/show_form.html', {\\n 'form' : form,\\n 'message' : None,\\n 'form_action' : reverse('edit-user', args=[userid]),\\n 'title' : \\\"Edit Account\\\"\\n })\",\n \"def edit_userprofile(request):\\n \\n try:\\n parsed_data = get_json_data(request) \\n # authentication\\n if not authenticate_user(parsed_data):\\n ret = Response(AUTHENTICATION_FAIL, error_code[AUTHENTICATION_FAIL])\\n return HttpResponse(ret.serialize(f))\\n user = User.objects.get(username=parsed_data[\\\"username\\\"]) \\n user.appuser.phone = parsed_data[\\\"phne\\\"],\\n user.appuser.state = parsed_data[\\\"state\\\"],\\n user.appuser.city = parsed_data[\\\"city\\\"],\\n user.appuser.address = parsed_data[\\\"address\\\"],\\n user.appuser.usertype = parsed_data[\\\"usertype\\\"]\\n user.save()\\n user.appuser.save()\\n ret = Response(SUCCESS, error_code[SUCCESS])\\n except KeyError as e:\\n ret = Response(EMPTY_COLUMN, error_code[EMPTY_COLUMN].format(e.message)) \\n except ObjectDoesNotExist as e:\\n ret = Response(NONEXIST_DATA, error_code[NONEXIST_DATA].format(e.message))\\n except ValueError as e:\\n ret = Response(INPUT_FORMAT, error_code[INPUT_FORMAT])\\n except:\\n ret = Response(UNKNOWN_ERROR, error_code[UNKNOWN_ERROR])\\n return HttpResponse(ret.serialize(f))\",\n \"def edit_email(request):\\n form = EmailForm(instance=request.user.profile)\\n if request.method == \\\"POST\\\":\\n form = EmailForm(data=request.POST, instance=request.user.profile)\\n if form.is_valid():\\n form.save()\\n return redirect('profile')\\n return render(request, 'accounts/forms.html', {'form': form})\",\n \"def profile():\\r\\n user_data = load_user(current_user.id, current_user)\\r\\n if user_data is not None:\\r\\n user, followers, following = user_data\\r\\n\\r\\n return render_base_template(\\\"profile.html\\\", profile=user, followers=followers,\\r\\n following=following,\\r\\n os_projects=[])\\r\\n\\r\\n return abort(404)\",\n \"def edit_user(user_id):\\n user = User.query.get_or_404(user_id)\\n\\n return render_template('edit-user.html', user=user)\",\n \"def allow_to_edit(user):\\n return allow_to_edit_well(user)\",\n \"def profile_edit_view(request):\\n if request.method == 'POST':\\n user_model_form = UserModelForm(\\n request.POST,\\n prefix=\\\"user\\\",\\n instance=request.user\\n )\\n profile_model_form = ProfileSignupForm(\\n request.POST,\\n prefix=\\\"profile\\\",\\n instance=request.user.profile\\n )\\n forms = [user_model_form, profile_model_form]\\n\\n if request.user.profile.is_mentor():\\n mentor_form = MentorForm(\\n request.POST,\\n prefix=\\\"mentor\\\",\\n instance=request.user.profile.mentor\\n )\\n forms.append(mentor_form)\\n\\n if request.user.profile.is_mentee():\\n mentee_form = MenteeForm(\\n request.POST,\\n prefix=\\\"mentee\\\",\\n instance=request.user.profile.mentee\\n )\\n forms.append(mentee_form)\\n\\n forms_is_valid_list = []\\n for form in forms:\\n forms_is_valid_list.append(form.is_valid())\\n\\n if all(forms_is_valid_list):\\n for form in forms:\\n form.save()\\n return redirect(\\\"private_profile\\\")\\n\\n elif request.method == 'GET':\\n forms = [\\n UserModelForm(\\n instance=request.user,\\n prefix=\\\"user\\\"\\n ),\\n ProfileSignupForm(\\n instance=request.user.profile,\\n prefix=\\\"profile\\\"\\n )\\n ]\\n\\n if request.user.profile.is_mentor():\\n forms.append(\\n MentorForm(\\n instance=request.user.profile.mentor,\\n prefix=\\\"mentor\\\"\\n )\\n )\\n\\n if request.user.profile.is_mentee():\\n forms.append(\\n MenteeForm(\\n instance=request.user.profile.mentee,\\n prefix=\\\"mentee\\\"\\n )\\n )\\n\\n return render(\\n request,\\n 'mentorship_profile/profile_edit.html',\\n {\\n \\\"forms\\\": forms\\n }\\n )\",\n \"def profile():\\n \\n return render_template(\\\"profile.html\\\")\",\n \"def edit_user(user_id):\\n if request.method == 'GET':\\n # init form with current user:\\n form = ProfileForm(\\n nickname = session[Session.PROFILE][\\\"nickname\\\"], \\n location = session[Session.PROFILE][\\\"location\\\"],\\n about_me = session[Session.PROFILE][\\\"about_me\\\"]\\n )\\n if request.method == 'POST': \\n # init form with POSTed form:\\n form = ProfileForm(request.form)\\n\\n if form.validate(): \\n # update backend:\\n response = service_user_management.patch(\\n id = f'auth0|{user_id}', \\n nickname = form.nickname.data, \\n location = form.location.data,\\n about_me = form.about_me.data\\n )\\n\\n # success:\\n if 'identities' in response: \\n try:\\n # update db:\\n delegated_user = DelegatedUser.query.get_or_404(\\n user_id, \\n description='There is no user with id={}'.format(user_id)\\n )\\n delegated_user.nickname = form.nickname.data\\n # update:\\n db.session.add(delegated_user)\\n # write\\n db.session.commit()\\n\\n # update session:\\n session[Session.PROFILE][\\\"nickname\\\"] = form.nickname.data\\n session[Session.PROFILE][\\\"location\\\"] = form.location.data\\n session[Session.PROFILE][\\\"about_me\\\"] = form.about_me.data\\n \\n # on successful profile update, flash success\\n flash('Your profile was successfully updated.')\\n\\n return redirect(url_for('.show_user', user_id = user_id))\\n except:\\n db.session.rollback()\\n # on unsuccessful registration, flash an error instead.\\n flash('An error occurred. New account could not be created.')\\n finally:\\n db.session.close()\\n # failure:\\n else:\\n flash(response['message']) \\n else:\\n # for debugging only:\\n flash(form.errors)\\n \\n return render_template('users/forms/user.html', form=form, user_id=user_id)\",\n \"def edit_user(user_id):\\n user = User.query.get_or_404(user_id)\\n return render_template(\\\"users/edit_user.html\\\", user=user)\",\n \"def test_editProfile(self):\\n\\t\\turl = \\\"/profiles/1/\\\"\\n\\t\\tdata = { \\\"name\\\" : \\\"testName\\\", \\\"surname\\\" : \\\"testSurname\\\" }\\n\\t\\tresponse = self.client.patch(url, data, format='json')\\n\\t\\tself.assertEqual(response.status_code, status.HTTP_200_OK)\\n\\t\\tself.assertEqual(response.data[\\\"name\\\"], \\\"testName\\\")\\n\\t\\tself.assertEqual(response.data[\\\"surname\\\"], \\\"testSurname\\\")\",\n \"def update_profile(name):\\r\\n user = User.query.filter_by(name=name).first()\\r\\n if not user:\\r\\n return abort(404)\\r\\n if current_user.id != user.id:\\r\\n return abort(403)\\r\\n show_passwd_form = True\\r\\n if user.twitter_user_id or user.google_user_id or user.facebook_user_id:\\r\\n show_passwd_form = False\\r\\n usr, apps, apps_created = cached_users.get_user_summary(name)\\r\\n # Extend the values\\r\\n current_user.rank = usr.get('rank')\\r\\n current_user.score = usr.get('score')\\r\\n # Title page\\r\\n title_msg = \\\"Update your profile: %s\\\" % current_user.fullname\\r\\n # Creation of forms\\r\\n update_form = UpdateProfileForm(obj=user)\\r\\n update_form.set_locales(current_app.config['LOCALES'])\\r\\n avatar_form = AvatarUploadForm()\\r\\n password_form = ChangePasswordForm()\\r\\n external_form = update_form\\r\\n\\r\\n\\r\\n if request.method == 'GET':\\r\\n return render_template('account/update.html',\\r\\n title=title_msg,\\r\\n user=usr,\\r\\n form=update_form,\\r\\n upload_form=avatar_form,\\r\\n password_form=password_form,\\r\\n external_form=external_form,\\r\\n show_passwd_form=show_passwd_form)\\r\\n else:\\r\\n # Update user avatar\\r\\n if request.form.get('btn') == 'Upload':\\r\\n avatar_form = AvatarUploadForm()\\r\\n if avatar_form.validate_on_submit():\\r\\n file = request.files['avatar']\\r\\n coordinates = (avatar_form.x1.data, avatar_form.y1.data,\\r\\n avatar_form.x2.data, avatar_form.y2.data)\\r\\n prefix = time.time()\\r\\n file.filename = \\\"%s_avatar.png\\\" % prefix\\r\\n container = \\\"user_%s\\\" % current_user.id\\r\\n uploader.upload_file(file,\\r\\n container=container,\\r\\n coordinates=coordinates)\\r\\n # Delete previous avatar from storage\\r\\n if current_user.info.get('avatar'):\\r\\n uploader.delete_file(current_user.info['avatar'], container)\\r\\n current_user.info = {'avatar': file.filename,\\r\\n 'container': container}\\r\\n db.session.commit()\\r\\n cached_users.delete_user_summary(current_user.name)\\r\\n flash(gettext('Your avatar has been updated! It may \\\\\\r\\n take some minutes to refresh...'), 'success')\\r\\n return redirect(url_for('.update_profile', name=current_user.name))\\r\\n else:\\r\\n flash(\\\"You have to provide an image file to update your avatar\\\",\\r\\n \\\"error\\\")\\r\\n return render_template('/account/update.html',\\r\\n form=update_form,\\r\\n upload_form=avatar_form,\\r\\n password_form=password_form,\\r\\n external_form=external_form,\\r\\n title=title_msg,\\r\\n show_passwd_form=show_passwd_form)\\r\\n # Update user profile\\r\\n elif request.form.get('btn') == 'Profile':\\r\\n update_form = UpdateProfileForm()\\r\\n update_form.set_locales(current_app.config['LOCALES'])\\r\\n if update_form.validate():\\r\\n current_user.id = update_form.id.data\\r\\n current_user.fullname = update_form.fullname.data\\r\\n current_user.name = update_form.name.data\\r\\n current_user.email_addr = update_form.email_addr.data\\r\\n current_user.privacy_mode = update_form.privacy_mode.data\\r\\n current_user.locale = update_form.locale.data\\r\\n db.session.commit()\\r\\n cached_users.delete_user_summary(current_user.name)\\r\\n flash(gettext('Your profile has been updated!'), 'success')\\r\\n return redirect(url_for('.update_profile', name=current_user.name))\\r\\n else:\\r\\n flash(gettext('Please correct the errors'), 'error')\\r\\n title_msg = 'Update your profile: %s' % current_user.fullname\\r\\n return render_template('/account/update.html',\\r\\n form=update_form,\\r\\n upload_form=avatar_form,\\r\\n password_form=password_form,\\r\\n external_form=external_form,\\r\\n title=title_msg,\\r\\n show_passwd_form=show_passwd_form)\\r\\n\\r\\n # Update user password\\r\\n elif request.form.get('btn') == 'Password':\\r\\n # Update the data because passing it in the constructor does not work\\r\\n update_form.name.data = user.name\\r\\n update_form.fullname.data = user.fullname\\r\\n update_form.email_addr.data = user.email_addr\\r\\n update_form.ckan_api.data = user.ckan_api\\r\\n external_form = update_form\\r\\n if password_form.validate_on_submit():\\r\\n user = db.session.query(model.user.User).get(current_user.id)\\r\\n if user.check_password(password_form.current_password.data):\\r\\n user.set_password(password_form.new_password.data)\\r\\n db.session.add(user)\\r\\n db.session.commit()\\r\\n flash(gettext('Yay, you changed your password succesfully!'),\\r\\n 'success')\\r\\n return redirect(url_for('.update_profile', name=name))\\r\\n else:\\r\\n msg = gettext(\\\"Your current password doesn't match the \\\"\\r\\n \\\"one in our records\\\")\\r\\n flash(msg, 'error')\\r\\n return render_template('/account/update.html',\\r\\n form=update_form,\\r\\n upload_form=avatar_form,\\r\\n password_form=password_form,\\r\\n external_form=external_form,\\r\\n title=title_msg,\\r\\n show_passwd_form=show_passwd_form)\\r\\n else:\\r\\n flash(gettext('Please correct the errors'), 'error')\\r\\n return render_template('/account/update.html',\\r\\n form=update_form,\\r\\n upload_form=avatar_form,\\r\\n password_form=password_form,\\r\\n external_form=external_form,\\r\\n title=title_msg,\\r\\n show_passwd_form=show_passwd_form)\\r\\n # Update user external services\\r\\n elif request.form.get('btn') == 'External':\\r\\n del external_form.locale\\r\\n del external_form.email_addr\\r\\n del external_form.fullname\\r\\n del external_form.name\\r\\n if external_form.validate():\\r\\n current_user.ckan_api = external_form.ckan_api.data or None\\r\\n db.session.commit()\\r\\n cached_users.delete_user_summary(current_user.name)\\r\\n flash(gettext('Your profile has been updated!'), 'success')\\r\\n return redirect(url_for('.update_profile', name=current_user.name))\\r\\n else:\\r\\n flash(gettext('Please correct the errors'), 'error')\\r\\n title_msg = 'Update your profile: %s' % current_user.fullname\\r\\n return render_template('/account/update.html',\\r\\n form=update_form,\\r\\n upload_form=avatar_form,\\r\\n password_form=password_form,\\r\\n external_form=external_form,\\r\\n title=title_msg,\\r\\n show_passwd_form=show_passwd_form)\\r\\n # Otherwise return 415\\r\\n else:\\r\\n return abort(415)\",\n \"def edit_user(user_id):\\n\\n user = User.query.get_or_404(user_id)\\n return render_template('users/edit.html', user=user)\",\n \"def edit(request, pk):\\n\\n try:\\n object = User.objects.get(pk=pk)\\n except:\\n object = User()\\n\\n if request.method == 'POST': # If the form has been submitted...\\n form = UserForm(request.POST, instance=object)\\n\\n if form.is_valid(): # If the form is valid\\n object = form.save()\\n\\n messages.success(request, _('The user has been saved.'))\\n\\n return redirect('users.views.list')\\n else:\\n form = UserForm(instance=object)\\n\\n return render(request, 'users/users/edit.html', {'form': form})\",\n \"def _edit_user(self):\\n users = fileIO.load_json(\\\"users.json\\\")\\n print(\\\"The list of users is as follows: \\\")\\n for i in users:\\n print(users[i][\\\"name\\\"])\\n #List specific user's settings and get user id\\n userID = self._list_user_settings(users)\\n #Loop until valid option given\\n option = False\\n while not option:\\n option = input(\\\"Please enter the setting you would like to change: \\\")\\n if option not in users[userID]:\\n option = False\\n print(\\\"That setting is not valid.\\\")\\n #Get input for new setting\\n args = input(\\\"Please enter what you would like to change that setting to: \\\")\\n #Output\\n command = \\\"edit_user {0} {1} {2}\\\\r\\\\n\\\".format(userID, option, args)\\n return(command)\",\n \"def user_profile():\\n\\n # Make sure users are logged in to access there profile\\n if 'logged' in session:\\n user = session['username']\\n users_recipes = mongo.db.recipes.find({'username': user})\\n return render_template('my_profile.html', recipes=users_recipes,\\n title=\\\"My Profile\\\", user=user)\\n # If the user isn't logged but somehow managed to click 'my profie'\\n else:\\n flash('Only logged in users can see there profile, please log in',\\n 'danger')\\n return redirect(url_for('login'))\",\n \"def profile(request):\\n profile = get_object_or_404(User, username=request.user)\\n\\n if request.method == 'POST':\\n form = SignupForm(request.POST, instance=profile)\\n if form.is_valid():\\n form.save()\\n messages.success(request, 'Profile updated successfully')\\n\\n form = SignupForm()\\n\\n template = 'profiles/profile.html'\\n context = {\\n 'form': form,\\n 'page': 'account',\\n }\\n\\n return render(request, template, context)\",\n \"def edit(self):\\n\\n pass\",\n \"def edit_person(self, pk):\",\n \"def edit_allowed(self):\\n account = Account.current_user_account\\n if account is None:\\n return False\\n return self.user_can_edit(account.user)\",\n \"def update_profile(request, id):\\n username = request.POST.get(\\\"username\\\")\\n first_name, last_name = request.POST.get(\\\"fullname\\\").split()\\n email = request.POST.get(\\\"email\\\")\\n phone = request.POST.get(\\\"phone\\\")\\n address = request.POST.get(\\\"address\\\")\\n\\n userObj = User.objects.get(id=id)\\n userObj.first_name = first_name\\n userObj.last_name= last_name\\n userObj.username= username\\n userObj.email = email\\n userObj.phone = phone\\n userObj.address = address\\n userObj.save()\\n messages.success(request, \\\"Your profile is successfully update.\\\", fail_silently=False)\\n return redirect(\\\"user_profile\\\", id)\",\n \"def user_edit(request):\\n DEBUG = False\\n\\n if not has_permission('editUser', request.context, request):\\n #print \\\"NOT has_permission !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\\\"\\n request.message = \\\"You do not have permissions to edit this user!\\\"\\n raise HTTPForbidden\\n\\n # if no user_id in URL and not logged in, tell user to login\\n\\n try:\\n user_id = request.matchdict['user_id']\\n except KeyError, ke:\\n #print ke\\n return HTTPFound(location=request.route_url('not_found'))\\n\\n user = User.get_by_user_id(user_id)\\n\\n if user is None:\\n msg = \\\"User was not founf in database.\\\"\\n return HTTPFound(location=request.route_url('not_found'))\\n\\n form = Form(request, schema=UserSettingsSchema, obj=user)\\n\\n if 'form.submitted' in request.POST and not form.validate():\\n # form didn't validate\\n request.session.flash('Please check the form below for errors!')\\n if DEBUG: # pragma: no cover\\n print \\\"submitted but not validated!\\\"\\n\\n if 'form.submitted' in request.POST and form.validate():\\n # ready for changing database entries!\\n request.session.flash('form validated!')\\n if DEBUG: # pragma: no cover\\n print \\\"the form was submitted and validated.\\\"\\n\\n if form.data['surname'] != user.surname:\\n if DEBUG: # pragma: no cover\\n request.session.flash('surname was not same --> changing')\\n print \\\"changing surname\\\"\\n user.surname = form.data['surname']\\n if form.data['lastname'] != user.lastname:\\n if DEBUG: # pragma: no cover\\n request.session.flash('lastname was not same --> changing')\\n print \\\"changing lastname\\\"\\n user.lastname = form.data['lastname']\\n if form.data['email'] != user.email:\\n request.session.flash('email was not same --> changing')\\n user.email = form.data['email']\\n if form.data['phone'] != user.phone:\\n request.session.flash('phone was not same --> changing')\\n user.phone = form.data['phone']\\n if form.data['fax'] != user.fax:\\n request.session.flash('fax was not same --> changing')\\n user.fax = form.data['fax']\\n if form.data['street'] != user.street:\\n request.session.flash('street was not same --> changing')\\n user.street = form.data['street']\\n if form.data['number'] != user.number:\\n request.session.flash('number was not same --> changing')\\n user.number = form.data['number']\\n if form.data['city'] != user.city:\\n request.session.flash('city was not same --> changing')\\n user.city = form.data['city']\\n if form.data['postcode'] != user.postcode:\\n request.session.flash('postcode was not same --> changing')\\n user.postcode = form.data['postcode']\\n if form.data['country'] != user.country:\\n request.session.flash('country was not same --> changing')\\n user.country = form.data['country']\\n\\n if DEBUG: # pragma: no cover\\n print \\\"returning the form\\\"\\n return {\\n 'the_user_id': user_id,\\n 'the_username': user.username,\\n 'form': FormRenderer(form),\\n }\",\n \"def edit_user(user_id):\\n\\n user = User.query.get_or_404(user_id)\\n \\n first = request.form['first_name']\\n last = request.form['last_name']\\n image = request.form['image_url']\\n \\n if not first or not last:\\n flash(\\\"Please enter first and last name.\\\")\\n return redirect(f\\\"/users/{user.id}/edit\\\")\\n \\n user.first_name = first\\n user.last_name = last\\n \\n if image:\\n user.image_url = image\\n\\n db.session.add(user)\\n db.session.commit()\\n\\n return redirect(\\\"/users\\\")\",\n \"def can_edit(self, user):\\n return self.author_id == user.id or user.is_staff\",\n \"def add_profile_details(request):\\n\\n if request.method == 'POST':\\n try:\\n profile = Profile.objects.get(user=request.user)\\n edit_profile = EditProfileForm(request.POST, instance=profile)\\n if edit_profile.is_valid():\\n profile.save()\\n messages.success(request, 'Your profile has been updated')\\n if profile.user_type == 'dismantler':\\n return redirect(reverse('addlisting'))\\n else:\\n return redirect(reverse('listings'))\\n except ObjectDoesNotExist:\\n profile_form = EditProfileForm(request.POST)\\n if profile_form.is_valid():\\n profile = Profile.objects.create(\\n user=request.user,\\n user_type=profile_form.cleaned_data['user_type'],\\n business_name=profile_form.cleaned_data['business_name'],\\n phone=profile_form.cleaned_data['phone'],\\n postcode=profile_form.cleaned_data['postcode'],\\n city=profile_form.cleaned_data['city'],\\n street_address=profile_form.cleaned_data['street_address'],\\n street_address2=profile_form.cleaned_data[\\n 'street_address2'],\\n county=profile_form.cleaned_data['county'],\\n country=profile_form.cleaned_data['country'],\\n )\\n profile.save()\\n messages.success(request, 'Your profile has been saved')\\n if profile.user_type == 'dismantler':\\n return redirect(reverse('addlisting'))\\n else:\\n return redirect(reverse('listings'))\\n else:\\n try:\\n profile = Profile.objects.get(user=request.user)\\n profile_form = EditProfileForm(instance=profile)\\n context = {\\n 'profile': profile,\\n 'profile_form': profile_form,\\n }\\n except ObjectDoesNotExist:\\n profile_form = EditProfileForm()\\n context = {\\n 'profile_form': profile_form,\\n }\\n\\n return render(request, 'profile.html', context)\",\n \"def edit_user(user_id):\\n\\n db_user = User.query.get_or_404(user_id)\\n\\n return render_template(\\\"edit_user.html\\\",\\n headline=f\\\"Edit Blogly {db_user.get_full_name()}\\\",\\n user=db_user)\",\n \"def user_profile(request):\\n instance = Profile.objects.get(pk=request.user.pk)\\n if request.method == \\\"POST\\\":\\n\\n form = ProfileForm(request.POST, request.FILES, instance=instance)\\n form.save()\\n return redirect(reverse('index'))\\n messages.error(request, \\\"Profile Updated\\\")\\n\\n profile = ProfileForm(instance=instance)\\n return render(request, 'profile.html', {'profile': profile, 'instance': instance})\",\n \"def profile(request):\\n profile = get_object_or_404(UserProfile, user=request.user)\\n\\n # Date format to get todays games from Gameline model\\n todays_date = datetime.datetime.now(pytz.timezone('America/Los_Angeles'))\\n date_LA = todays_date.strftime('%B %-d, %Y')\\n\\n # Get all objects in MLBGameLine model\\n all_games = MLBGameLine.objects.all()\\n\\n if request.method == \\\"POST\\\":\\n form = EditProfileInfo(request.POST, instance=profile)\\n if form.is_valid():\\n form.save()\\n messages.success(request, 'Successfully updated profile!')\\n return redirect(reverse('profile'))\\n else:\\n messages.error(request,\\n \\\"Failed to update profile.\\\")\\n else:\\n form = EditProfileInfo(instance=profile)\\n\\n template = \\\"profiles/profile.html\\\"\\n context = {\\n 'profile': profile,\\n 'all_games': all_games,\\n 'date_LA': date_LA,\\n 'form': form,\\n }\\n\\n return render(request, template, context)\",\n \"def view_user_edit(self):\\n\\n logged_in = authenticated_userid(self.request)\\n message = ''\\n form = Form(self.request, schema=UserEditSchema,\\n state=State(request=self.request))\\n if form.validate():\\n password = self.request.params['password']\\n if self.context.validate_password(password):\\n if self.request.params['new_password']:\\n password = self.request.params['new_password']\\n message = 'Successfully saved'\\n email = self.request.params['email']\\n self.context.edit(password, email)\\n else:\\n message = msg['password_invalid']\\n return {\\n 'message': message,\\n 'project': '',\\n 'username': self.context.username,\\n 'logged_in': logged_in,\\n 'form': FormRenderer(form),\\n 'email': self.context.email\\n }\",\n \"def edit_profile(request):\\n\\n template = 'edit_profile.html'\\n if request.method == 'POST': # If the form has been submitted...\\n form = PatientEditForm(request.POST, instance=request.user.patient) # A form bound to the POST data\\n if form.is_valid(): # All validation rules pass\\n # Process the data in form.cleaned_data\\n # ...\\n form.save()\\n return HttpResponseRedirect(reverse('index')) # Redirect after POST\\n\\n else:\\n form = PatientEditForm(instance=request.user.patient)\\n\\n return TemplateResponse(request, template, {'form': form})\",\n \"def user_edit(request):\\n\\n if request.method != 'POST':\\n return HttpResponseNotAllowed(['POST'])\\n\\n data = json.loads(request.body.decode('utf-8'))\\n\\n auth_token = str(data.get('auth_token', ''))\\n edit_user_info = data.get('edit_user_info', '')\\n username = str(edit_user_info.get('username', ''))\\n\\n try:\\n if not verify_admin(auth_token):\\n raise PlantalyticsAuthException(ADMIN_INVALID)\\n\\n message = (\\n 'Attempting to edit info for user: {}.'\\n ).format(username)\\n logger.info(message)\\n check_user_parameters(edit_user_info)\\n cassy.edit_user(edit_user_info)\\n message = (\\n 'Successfully edited info for user: {}.'\\n ).format(username)\\n logger.info(message)\\n body = {\\n 'errors': {}\\n }\\n return HttpResponse(\\n json.dumps(body),\\n content_type='application/json'\\n )\\n except PlantalyticsException as e:\\n message = (\\n 'Error attempting to edit user info. Error code: {}'\\n ).format(str(e))\\n logger.warn(message)\\n error = custom_error(str(e))\\n return HttpResponseForbidden(error, content_type='application/json')\\n except Exception as e:\\n message = (\\n 'Unknown error occurred while attempting to edit user info:'\\n )\\n logger.exception(message)\\n error = custom_error(UNKNOWN, str(e))\\n return HttpResponseServerError(error, content_type='application/json')\",\n \"def update_profile(username):\\n\\n description = request.json.get('description')\\n token = request.headers.get('token')\\n\\n if description is None:\\n return jsonify({'message': 'New description not provided'}), 404\\n\\n # Token Validation\\n token_valid, response = is_token_valid(token)\\n if not token_valid:\\n return response\\n token_username = response\\n\\n # Privilege handling\\n if token_username != username:\\n return jsonify({'message': \\\"You may not edit others profiles\\\"}), 404\\n\\n if username not in Profiles.keys():\\n return jsonify({'message': 'User {} not found'.format(username)}), 404\\n\\n Profiles[username]['description'] = description\\n return Profiles[username]\",\n \"def profile(request):\\n profile = get_object_or_404(UserProfile, user=request.user)\\n\\n if request.method == 'POST':\\n form = UserProfileForm(request.POST, instance=profile)\\n user_email = UserForm(instance=request.user)\\n if form.is_valid():\\n form.save()\\n messages.success(request, 'Profile updated successfully')\\n else:\\n messages.error(request, 'Update failed. Please ensure the form is valid.')\\n # doesnt work yet: Email is not saved:\\n\\n if user_email.is_valid():\\n user_email.save()\\n messages.success(request, 'Profile updated successfully')\\n else:\\n messages.error(request, 'Update failed. Please ensure the form is valid.')\\n else:\\n form = UserProfileForm(instance=profile)\\n user_email = UserForm(instance=request.user)\\n\\n template = 'profiles/profile.html'\\n context = {\\n 'form': form,\\n 'user_email': user_email,\\n 'on_profile_page': True,\\n 'profile': profile\\n }\\n\\n return render(request, template, context)\",\n \"def edit(user_id):\\n if user_id != current_user.id:\\n return abort(403)\\n\\n user = get_user(user_id)\\n form = EditForm(obj=user)\\n form.email.data = user.email\\n\\n if form.validate_on_submit():\\n password = form.password.data\\n username = form.username.data\\n\\n save_result = edit_user(user_id, password, username, user.active)\\n user = save_result['entry']\\n form = EditForm(request.form, obj=save_result['entry'])\\n form.email.data = user.email\\n return redirect(url_for('.index'))\\n \\n return render_template('users/edit.html'\\n ,form=form\\n ,user=user\\n ,t=t\\n ,m=m)\",\n \"def test_change_username_changes_profile(self):\\n user = self.users[0]\\n profile = user.profile\\n user.profile.bio = 'bio'\\n user.profile.save()\\n self.assertEquals(user.profile.bio, profile.bio)\",\n \"def manage_myprofile(request):\\n profile = request.user.get_profile()\\n users_image = profile.users_image\\n if not profile:\\n raise Http404\\n if request.method == 'POST':\\n profile_form = MyProfileForm(request.POST, instance = profile)\\n address_contact_form = AddressForm(request.POST,\\n instance = profile.address_contact, prefix = 'contact')\\n address_permanent_form = AddressForm(request.POST,\\n instance = profile.address_permanent, prefix = 'permanent')\\n\\n if profile_form.is_valid() and address_contact_form.is_valid() \\\\\\n and address_permanent_form.is_valid():\\n address_contact = address_contact_form.save()\\n address_permanent = address_permanent_form.save()\\n\\n profile_form.save(address_contact = address_contact,\\n address_permanent = address_permanent)\\n messages.success(request,\\n _('your profile details saved sucessfully'))\\n else:\\n profile_form = MyProfileForm(instance = profile)\\n address_contact_form = AddressForm(instance = profile.address_contact,\\n prefix = 'contact')\\n address_permanent_form = AddressForm(instance\\n = profile.address_permanent, prefix = 'permanent')\\n\\n return render(request, 'myprofile.html', {\\n 'profile_form': profile_form,\\n 'address_contact_form': address_contact_form,\\n 'address_permanent_form': address_permanent_form,\\n 'users_image': users_image\\n },\\n )# Create your views here.\",\n \"def add_profile():\\n \\n form=ProfileForm() \\n if 'username' in session:\\n user = mongo.db.user.find_one({'username': session['username']})\\n pro = mongo.db.profiles.find_one({'user_id': user['_id']})\\n if pro:\\n flash('Sorry, only one profile per user permitted. You can update your profile on your dashboard under the profile tab.', 'info')\\n return redirect(url_for('dashboard'))\\n \\n if request.method == 'POST':\\n if form.validate_on_submit():\\n \\n mongo.db.profiles.insert_one({'user_id': user['_id'],\\n 'headline': form.headline.data,\\n 'bio': form.bio.data,\\n 'username': session['username'],\\n 'date': datetime.utcnow(),\\n 'xp': form.xp.data,\\n 'interests': form.interests.data,\\n 'stack': form.stack.data,\\n 'languages': form.languages.data,\\n 'frameworks': form.frameworks.data,\\n 'github': form.github.data,\\n 'linkedin': form.linkedin.data\\n })\\n flash('Your profile has been created.', 'success')\\n return redirect('profiles')\\n \\n return render_template('pages/addprofile.html', title='Post',\\n form=form, legend='Create your profile')\\n \\n flash('You need to be logged in to post any content.', 'info')\\n return redirect(url_for('login'))\",\n \"def user_update_profile():\\n \\n if 'userid' and 'email' not in request.forms:\\n return {'status':'Failure','message':'User Id is missing,please try with correct data.'}\\n \\n data = user_obj.user_update_profile(request.forms)\\n return data\",\n \"def putProfile(profileType,value):\\n # PUT /profile/$profileType\\n pass\",\n \"def _doProfile(self, save_request=None):\\n prof = self._getProfileFromUser()\\n # If saveProfile(), process user-modifyable fields\\n if save_request:\\n for field in ('displayName', 'teeShirtSize'):\\n if hasattr(save_request, field):\\n val = getattr(save_request, field)\\n if val:\\n print(val)\\n setattr(prof, field, str(val))\\n prof.put()\\n # Return ProfileForm\\n return self._copyProfileToForm(prof)\",\n \"def get(self, request):\\n user = YouYodaUser.objects.get(auth_token=request.headers['Authorization'].replace('Token ', ''))\\n serializer = ProfileEditSerializer(user)\\n return Response(serializer.data)\",\n \"def account_profile(request):\\n get_or_creat(request)\\n return redirect(\\\"/\\\")\",\n \"def profile_url(self):\\n return reverse(\\\"auth_profile\\\", args=[self.user.username])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7839375","0.76361674","0.75991297","0.757305","0.7543597","0.74999654","0.7481396","0.74729866","0.7393925","0.73854417","0.7290376","0.7259955","0.7223237","0.72067004","0.72060645","0.7162687","0.7130685","0.7072604","0.7040199","0.70098627","0.6973461","0.6972686","0.69697833","0.6929408","0.69286853","0.68818706","0.68772167","0.6828612","0.6822478","0.67614275","0.675606","0.67524886","0.6747228","0.67407346","0.6734828","0.67254764","0.6674939","0.66590506","0.66394085","0.6628163","0.6602466","0.6575382","0.6572263","0.65699464","0.65569496","0.6551339","0.65383786","0.65317476","0.65179175","0.6489333","0.6483788","0.6473747","0.6469546","0.64626735","0.6450329","0.6450329","0.6446137","0.64435184","0.64407116","0.64394605","0.6432209","0.642592","0.6425245","0.6417007","0.64038193","0.6392382","0.63867444","0.6370678","0.6363792","0.6348526","0.63339686","0.6330443","0.6309305","0.62970394","0.62906206","0.6280009","0.6278956","0.6271356","0.62501556","0.62450135","0.6243664","0.6236143","0.62328553","0.62310416","0.6225443","0.62102985","0.62036735","0.61654323","0.61648923","0.61584806","0.6156557","0.61477166","0.6135395","0.6123801","0.6119522","0.61183107","0.6117855","0.61138487","0.6113093","0.6112403"],"string":"[\n \"0.7839375\",\n \"0.76361674\",\n \"0.75991297\",\n \"0.757305\",\n \"0.7543597\",\n \"0.74999654\",\n \"0.7481396\",\n \"0.74729866\",\n \"0.7393925\",\n \"0.73854417\",\n \"0.7290376\",\n \"0.7259955\",\n \"0.7223237\",\n \"0.72067004\",\n \"0.72060645\",\n \"0.7162687\",\n \"0.7130685\",\n \"0.7072604\",\n \"0.7040199\",\n \"0.70098627\",\n \"0.6973461\",\n \"0.6972686\",\n \"0.69697833\",\n \"0.6929408\",\n \"0.69286853\",\n \"0.68818706\",\n \"0.68772167\",\n \"0.6828612\",\n \"0.6822478\",\n \"0.67614275\",\n \"0.675606\",\n \"0.67524886\",\n \"0.6747228\",\n \"0.67407346\",\n \"0.6734828\",\n \"0.67254764\",\n \"0.6674939\",\n \"0.66590506\",\n \"0.66394085\",\n \"0.6628163\",\n \"0.6602466\",\n \"0.6575382\",\n \"0.6572263\",\n \"0.65699464\",\n \"0.65569496\",\n \"0.6551339\",\n \"0.65383786\",\n \"0.65317476\",\n \"0.65179175\",\n \"0.6489333\",\n \"0.6483788\",\n \"0.6473747\",\n \"0.6469546\",\n \"0.64626735\",\n \"0.6450329\",\n \"0.6450329\",\n \"0.6446137\",\n \"0.64435184\",\n \"0.64407116\",\n \"0.64394605\",\n \"0.6432209\",\n \"0.642592\",\n \"0.6425245\",\n \"0.6417007\",\n \"0.64038193\",\n \"0.6392382\",\n \"0.63867444\",\n \"0.6370678\",\n \"0.6363792\",\n \"0.6348526\",\n \"0.63339686\",\n \"0.6330443\",\n \"0.6309305\",\n \"0.62970394\",\n \"0.62906206\",\n \"0.6280009\",\n \"0.6278956\",\n \"0.6271356\",\n \"0.62501556\",\n \"0.62450135\",\n \"0.6243664\",\n \"0.6236143\",\n \"0.62328553\",\n \"0.62310416\",\n \"0.6225443\",\n \"0.62102985\",\n \"0.62036735\",\n \"0.61654323\",\n \"0.61648923\",\n \"0.61584806\",\n \"0.6156557\",\n \"0.61477166\",\n \"0.6135395\",\n \"0.6123801\",\n \"0.6119522\",\n \"0.61183107\",\n \"0.6117855\",\n \"0.61138487\",\n \"0.6113093\",\n \"0.6112403\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7651815"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":21986,"cells":{"query":{"kind":"string","value":"Write experiment config to file"},"document":{"kind":"string","value":"def save_experiment_config(self):\n\n if (self.use_dist and dist.get_rank() == 0) or not self.use_dist:\n logfile = os.path.join(self.experiment_dir, 'parameters.txt')\n log_file = open(logfile, 'w')\n log_file.write('\\n')\n json.dump(self.args.__dict__, log_file, indent=2)\n log_file.write('\\n')\n log_file.close()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def write(self, fn):\n with open(fn, 'w') as f:\n self.config.write(f)","def __write_config(self):\n with open(self.config_file, 'w') as data_file:\n config = {\"ibooks_doc_root\":self.ibooks_doc_root,\n \"library_folder\":self.library_folder,\n \"annotation_folder\":self.annotation_folder,\n \"tmp_dir\":self.tmp_dir\n } \n data = json.dumps(config, ensure_ascii=False)\n data_file.write(data)","def write_config_file(config, args):\n config_filename = 'testsuite_cfg.json'\n args.config = config_filename\n config_file = open(config_filename, 'w')\n config_file.write(str(json.dumps(config)))\n config_file.close()","def write_config_file(self):\n for opt, opt_desc in self.opt_dict.iteritems():\n if 'permanent' in opt_desc and opt_desc['permanent'] == True:\n enabled = 'Always'\n else:\n enabled = opt_desc['enabled'].__str__()\n\n self.file_parser.set(opt, 'enabled', enabled)\n self.file_parser.set(opt, 'implementation',\n opt_desc['selected_imp'])\n self.file_parser.set(opt, 'optype', opt_desc['imptype'])\n\n for config, config_desc in self.config_dict.iteritems():\n enabled = config_desc['enabled'].__str__()\n self.file_parser.set(config, 'enabled', enabled)\n\n scratch_file = self.config_filename + '.scratch'\n with open(scratch_file, 'w') as cfile:\n for config in sorted(self.config_dict.keys()):\n self.write_section(cfile, config)\n\n for opt in sorted(self.opt_dict.keys()):\n self.write_section(cfile, opt)\n\n for imp in sorted(self.imp2opt_dict.keys()):\n self.write_section(cfile, imp)\n\n cfile.write(\"\\n\")\n\n os.rename(scratch_file, self.config_filename)","def write_config(self, fname, data):\n with open(fname, 'w') as fhandle:\n fhandle.write(data)","def write_config_file():\n\tif not config_parser:\n\t\tprint \"Config module not loaded. I don't save anything.\"\n\t\treturn\n\n\tf = file(config_file, \"w\")\n\tconfig_parser.write(f)\n\tf.close()","def write_config(self, filename):\n self.config.filename = filename\n self.config.write()","def write_config(self):\n logging.debug(\"Writing configuration file: %s\" % self.config_file)\n f = open(self.config_file, \"w\")\n self.config.write(f)\n f.close()","def _write_config_file(self, config_data, indent=2):\r\n with open(self.config, 'w') as f:\r\n json.dump(config_data, f, indent=indent)","def save_config_file(self):\n wkdir = Path(self.config_dict[\"outputdir\"])\n config_filename = str(wkdir / f\"{self.config_dict['name']}.json\")\n save_config(self.config_dict, config_filename)","def save(self):\n file = open(self.path, 'w')\n self.config.write(file)\n file.close()","def write(self, path):\n with open(path, \"w\") as fh_:\n fh_.write(self.config())","def write(self, path):\n with open(path, \"w\") as fh_:\n fh_.write(self.config())","def write_config(self, config_file):\n \n # write root paths\n \n # write reference data\n \n # write tool paths\n \n pass","def write(self, filename: str):\n obj = self.to_dict(self)\n config.write(obj, filename)","def write_configuration_file(self, content):\n with open(self.configuration_file_path, 'w') as configuration_file:\n configuration_file.write(content)","def save(self):\r\n with open(self.filename, 'wb') as configfile:\r\n self.write(configfile)","def save_config_file(self):\n with open(self.config_file_name, 'w',encoding='utf-8') as outfile:\n json.dump(self._config, outfile,indent=2)","def write_config(self):\n xshear_conf=XShearConfig(self['run'])\n xshear_conf.write()","def save_config() -> None:\n with open(_config_file, \"w\", newline=\"\") as config_file:\n json.dump(_config, config_file, indent=4)\n config_file.truncate()","def write_config():\n\n e = Element(\"Configuration\")\n r = SubElement(e, \"RepositoryList\")\n r = SubElement(r, \"Repository\", name = \"default\")\n SubElement(r, \"Module\").text = args.driver\n SubElement(r, \"TokenLabel\").text = args.token_label\n SubElement(r, \"PIN\").text = args.pin\n ElementTree(e).write(args.write_config)\n args.write_config.flush()","def write(self):\n cfgpath = os.path.join(self.config_dir, CONFIG_FILENAME)\n ofile = open(cfgpath, 'w')\n if ofile:\n log.debug( \"Write config: %s\" % cfgpath )\n cfg = yaml.dump(self.yaml, default_flow_style=False)\n log.debug( \"Config:\\n%s\" % cfg)\n ofile.write(cfg)\n ofile.close()","def save():\n with open(CONFIG_FILE, 'w') as f:\n json.dump(config, f, indent=4, sort_keys=True)","def write_config(self):\r\n obj = [\r\n [self.ip,\r\n self.gate,\r\n self.mask,\r\n self.name,\r\n self.time]\r\n ]\r\n with open('config.json', 'wt') as jsonfile:\r\n json.dump(obj, jsonfile)","def write_config(config):\n config_path = os.path.join(CONFIG_PATH, CONFIG_FILE)\n\n with open(config_path, \"w\") as config_file:\n json.dump(config, config_file)","def save_config(self):\n with open(self.config_file, 'w') as fout:\n json.dump({'name_dict': self._name_dict, 'metric_dict': self._metric_dict, 'credential_path': self.credential_path, 'path_for_worksheet_name': self.path_for_worksheet_name}, fout)","def saveConfig():\n with open(_CONFIG_FNM, 'w') as configfile:\n CONFIG_DICT.write(configfile,\n space_around_delimiters=True)","def save(self):\n for p, c in self.configs_:\n c.write(p)","def write_config(self, config: dict):\n if self.config_in_use():\n raise BaseConfigInUseError()\n\n for conf_name, conf in create_config(\n self.config_dir, self.data_dir, config\n ).items():\n with open(abspath(join(self.config_dir, conf_name)), \"w\") as f:\n f.write(conf)","def _write_params_file(model_config: base_model_params.BaseModelParams,\n job_log_dir: str) -> None:\n if jax.process_index() == 0:\n params_fpath = os.path.join(job_log_dir, 'model_params.txt')\n if not tf.io.gfile.exists(job_log_dir):\n tf.io.gfile.makedirs(job_log_dir)\n with tf.io.gfile.GFile(params_fpath, 'w') as params_file:\n datasets = model_config.datasets()\n for dataset in datasets:\n params_file.write(dataset.ToText())\n params_file.write('\\n\\n')\n params_file.write(model_config.task().ToText())","def setup_configuration_file(self):\n\n with open(self.config_path, \"w+\") as f_config:\n\n f_config.write(get_configuration_file_form())","def write_config_updater(path: Path, config: ConfigUpdater) -> None:\n to_write_config = copy.deepcopy(config)\n with os.fdopen(os.open(path.as_posix(), os.O_WRONLY | os.O_CREAT, 0o600), \"w\") as fh:\n to_write_config.write(fh)","def save_config(config_path: str, data: dict):\n with open(config_path, 'w') as j:\n dump(data,j)","def save_to_file(self):\n check_path(self.config_path)\n\n with open(self.settings_file, 'w') as settings_file:\n options = self._get_options()\n json.dump(options,\n \t settings_file,\n \t indent=4,\n \t separators=(',', ': '))","def write(self, config_path=CONFIG_PATH):\n\n with open(self.full_path(config_path), 'w') as conf_fh:\n conf_fh.write(self.local_config)","def save(self):\r\n with open(self.filename, 'w') as f:\r\n if self.pretty:\r\n json.dump(self.__config, f, sort_keys=False,\r\n indent=4, separators=(',', ': '))\r\n else:\r\n json.dump(self.__config, f)","def _write_config(self, config_path: Path):\n with open(config_path, \"w\") as f:\n json.dump(self.config_overrides, f)","def save_config(self):\n data = json.dumps(self.cfg)\n\n try:\n file = open(self.cfg_file_name, 'w')\n file.write(data)\n except OSError as err:\n print(\"can't save property: {0}\".format(err))\n else:\n file.close()","def write_config(self,file_path):\r\n with open(file_path,\"w\",encoding=\"utf-8\") as fw:\r\n\r\n json_data = dict()\r\n json_data[\"mode\"] = self.mode\r\n json_data[\"client_num\"] = self.client_num\r\n json_data[\"class_num_for_client\"] = self.class_num_for_client\r\n json_data[\"dataset_name\"] = self.dataset_name\r\n json_data[\"model_name\"] = self.model_name\r\n json_data[\"communication_round\"] = self.communication_round\r\n json_data[\"local_epoch\"] = self.local_epoch\r\n json_data[\"batch_size\"] = self.batch_size\r\n json_data[\"use_server\"] = self.use_server\r\n json.dump(json_data,fw,ensure_ascii=False)","def save(self):\n try:\n with open(self._filename, 'w') as conf_file:\n conf_file.write(json.dumps(self._data))\n except OSError:\n _LOGGER.exception(\"Can't store config in %s\", self._filename)","def writeto(self, filename=None):\n if filename is None:\n if self.fileout is not None:\n filename = self.fileout\n else:\n raise IOError(\"filename is None and no self.fileout set.\")\n \n with open(filename, \"w\") as f:\n f.writelines(\"\\n\".join(self.get_config(\"configfile\")))","def save():\n\n env.config.save(env.config_file)","def _write_config(parser):\n with open(PRAW_FILE_PATH, \"w\") as c_file:\n parser.write(c_file)","def save():\n print(\"Saving config file..\")\n\n res = yaml.round_trip_dump(_conf, indent=2, block_seq_indent=1)\n\n with open(__config_file, 'w', encoding='utf-8') as stream:\n stream.write(res)","def write_config(self):\n cfg = {\n 'ALERT_API_KEY':self.api_key,\n 'APP_NAME':self.title,\n 'alertes':self.alertes\n }\n write_conf(self.CONF_FILE,cfg)","def write(self, config_path=CONFIG_PATH):\n\n peers_file = self.peers_full_path(config_path)\n\n with open(self.full_path(config_path), 'w') as conf_fh:\n conf_fh.write(self.interface)\n conf_fh.write(f'PostUp = wg addconf %i {peers_file}')\n\n with open(peers_file, 'w') as peers_fh:\n peers_fh.write(self.peers)","def write_config(config, config_template, config_path):\n with open(config_path, 'wb') as cfg_file:\n cfg_file.write(\n config_template.render(**config).encode(\"utf-8\")\n )","def _createConfigFile(self):\n configFile = self._configFile()\n try:\n with open(configFile) as fh:\n pass\n except IOError:\n try:\n with open(configFile, 'w') as fh:\n fh.write(\"[settings]\\n\")\n fh.write(\"debug = false\\n\")\n fh.write(\"hidefilenames = false\\n\")\n except IOError:\n pass","def create_config_file():\n working_dir = get_working_dir()\n with open('config.txt', 'w') as config_file:\n config_file.write(working_dir + os.sep + 'LevelProgress.xlsx')","def write_config(self, data):\n logger.debug(\"[%s] Writing config\", self.name)\n self.config.write(data)","def test_write_config(self):\n config = Config()\n config.config = test_config\n config.config_file = \"./config\"\n config.write_config()\n with open(config.config_file) as config_file:\n data = config_file.read()\n self.assertTrue(data)\n os.remove(config.config_file)","def write_config(resultsdir, configdict, message, filename=\"modelconfig.cfg\"):\n f = open(resultsdir + filename, \"w\")\n for key in configdict:\n f.write(\"{}: {}\\n\".format(key, configdict[key]))\n f.write(\"message:\" + message)","def write(filename):\n log.msg(\"Saving configuration information to \\\"\" + filename + \"\\\"\", lvl='i', ss='ss_configfile')\n\n f = open(filename, 'w')\n cp = ConfigParser.SafeConfigParser()\n #a little string hacking because our section names are un-normalized\n #this builds a list of all the sections names\n sectionslst = []\n sections = []\n for k in _loaded.keys():\n sectionslst.append(k.split('.')[0])\n #get unique entries\n sections = _uniquer(sectionslst)\n for sec in sections:\n log.msg(\"\\tCompiling section \\\"\" + sec + \"\\\"\",\n lvl='d3', ss='ss_configfile')\n #make the headers\n cp.add_section(sec)\n #for each item in my dictionary\n #it splits the key in two and uses that for the first and second \"set\" args\n #then it uses the item.value for the 3rd arg\n # from 'section.option:value'\n \n for k in _loaded.items():\n cp.set(str(k[0]).split('.')[0], str(k[0]).split('.')[1], str(k[1]))\n cp.write(f)\n f.close()","def save_config(self):\n\n if not self.__conf.has_section(self.section):\n self.__conf.add_section(self.section)\n\n for key in self._params:\n val = self._params[key]\n self.__conf.set(self.section, key, val)\n\n with open(self.conf_path, 'w') as f:\n self.__conf.write(f)","def save_config(logfolder, file_name = \"configuration\"):\n print(\"Save configuration to: \", logfolder)\n root = ET.Element(\"conf\")\n flg = ET.SubElement(root, \"flags\")\n \n flags_dict = FLAGS.__dict__['__flags']\n for f in flags_dict:\n #print f, flags_dict[f]\n ET.SubElement(flg, f, name=f).text = str(flags_dict[f])\n tree = ET.ElementTree(root)\n tree.write(os.path.join(logfolder,file_name+\".xml\"), encoding=\"us-ascii\", xml_declaration=True, method=\"xml\")","def write_config_file(batch_size, resize_to, train_prop):\n config = ConfigParser()\n config.read('config.ini')\n\n # Add model parameters; will add new section and create config file if it does not already exist\n if not config.has_section('model params'):\n config.add_section('model params')\n\n config.set('model params', 'batch_size', str(batch_size))\n config.set('model params', 'resize_to', str(resize_to))\n config.set('model params', 'train_prop', str(train_prop))\n\n # Write the file\n with open('config.ini', 'w') as f:\n config.write(f)\n\n return","def write_config(config_filename, config=default_config):\n comments=\"\"\n if config==default_config:\n comments+=\"# %s \\n\" % version.version_string\n comments+=\"# This is the default config file\\n\"\n comments+=\"# Generated on %s \\n\" % time.strftime('%x %X %Z')\n comments+=\"# Visit %s for more informations \\n\" % version.project_url\n c=SafeConfigParser()\n f=open(config_filename,'w')\n f.write(comments+\"\\n\")\n for section in config.items():\n name=section[0]\n values=section[1]\n c.add_section(name)\n for value in values.items():\n c.set(name, value[0], value[1])\n c.write(f)\n f.flush()\n f.close()","def save_config(self):\n config.save_config(self.config, self.config_file)","def write_config(self):\n\n #Before writing to file we must convert underscores to dashes, moreover _id must be written as id, and _type as type\n\n if not os.path.exists(NetworkManager_conf_dir):\n os.makedirs(NetworkManager_conf_dir, mode=0755)\n\n profile_path = os.path.join(\"%s\" % NetworkManager_conf_dir, self.connection._id)\n with open(profile_path, \"wb\") as configfile:\n self.cfg.write(configfile)","def _save_config_log(self, data):\n config_path = os.path.join(self.runtime.working_dir, '.config')\n with open(config_path, 'w') as f:\n yaml.safe_dump(data, f, default_flow_style=False)","def save_configuration(config):\n with open(cwd + '/configuration.pickle', 'wb') as handle:\n pickle.dump(config, handle, protocol=pickle.HIGHEST_PROTOCOL)","def writeConfig(self):\n\n qU.writeConfig(quickLogger=self.logger,\n\t\t curveDictionary=self.curveConf,\n\t\t likelihoodDictionary=self.likelihoodConf,\n commonDictionary=self.commonConf,\n analysisDictionary=self.analysisConf)","def save(self):\n with open(self._config, 'w') as f:\n json.dump(self.data, f, indent=2, sort_keys=True)","def write_config(filename, parser, mode='w'):\n with open(filename, mode) as config_file:\n parser.write(config_file)\n logging.info(f'Wrote config file \\'{filename}\\'.')","def writeShREEKConfig(self, filename):\n self._ShREEKConfig.save(filename)\n return","def _write_elasticluster_config(config, out_file):\n orig_file = os.path.join(sys.prefix, \"share\", \"bcbio-vm\", \"elasticluster\", \"config\")\n if not os.path.exists(os.path.dirname(out_file)):\n os.makedirs(os.path.dirname(out_file))\n if os.path.exists(out_file):\n bak_file = out_file + \".bak%s\" % datetime.datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\")\n shutil.move(out_file, bak_file)\n with open(orig_file) as in_handle:\n with open(out_file, \"w\") as out_handle:\n for line in in_handle:\n if line.startswith(tuple(config.keys())):\n name, val = line.strip().split(\"=\")\n out_handle.write(\"%s=%s\\n\" % (name, config[name]))\n else:\n out_handle.write(line)\n return out_file","def save_config(self):\n if not os.path.exists(self._conf_dir):\n os.makedirs(self._conf_dir)\n conf_file = os.path.join(self._conf_dir, \"dql.json\")\n with open(conf_file, \"w\") as ofile:\n json.dump(self.conf, ofile, indent=2)","def write(cls, experiment: Experiment):\n cls.__mutex.acquire()\n os.makedirs('./temp', exist_ok=True)\n worksheet = cls.__workbook.add_worksheet(experiment.name)\n for i, value in enumerate(experiment.values.items()):\n worksheet.write(0, i, value[0])\n worksheet.write_column(1, i, value[1])\n if experiment.model == 'accuracy':\n # cls.__add_accuracy_plot(worksheet, value)\n cls.test(worksheet, value)\n\n pass\n\n if experiment.model == 'performance':\n cls.test(worksheet, value)\n pass\n # cls.__add_accuracy_plot(worksheet, value)\n\n cls.__mutex.release()","def saveConfig(self):\r\n self.config[\"Settings\"] = {}\r\n settings = self.config[\"Settings\"]\r\n settings[\"datapath\"] = self.dataPath\r\n settings[\"videopath\"] = self.videoPath\r\n settings[\"dataoffset\"] = str(self.dataOffset)\r\n settings[\"colblindmode\"] = str(self.colBlindMode)\r\n with open(self.CONFIG_FILE,\"w\") as file:\r\n self.config.write(file)","def save_config(logdir, config):\n with open(os.path.join(logdir, 'config.yml'), 'w') as f:\n yaml.dump(config.__dict__, f)","def save_config(log_dir, config):\n if not os.path.exists(log_dir):\n os.makedirs(log_dir)\n shutil.copy(config, os.path.join(log_dir, 'config.gin'))","def dump_config_and_makefile(_config):\n experiment_dir = Path(_config['trainer']['storage_dir'])\n makefile_path = Path(experiment_dir) / \"Makefile\"\n\n if not makefile_path.exists():\n from padertorch.contrib.examples.source_separation.tasnet.templates import \\\n MAKEFILE_TEMPLATE_TRAIN\n\n config_path = experiment_dir / \"config.json\"\n pt.io.dump_config(_config, config_path)\n\n makefile_path.write_text(\n MAKEFILE_TEMPLATE_TRAIN.format(\n main_python_path=pt.configurable.resolve_main_python_path(),\n experiment_name=experiment_name,\n eval_python_path=('.'.join(\n pt.configurable.resolve_main_python_path().split('.')[:-1]\n ) + '.evaluate')\n )\n )","def save_config(self, path):\n if os.path.isdir(path):\n path = os.path.join(path, 'config.json')\n print('Save config to {}'.format(path))\n with open(path, 'w', encoding='utf-8') as w:\n w.write(json.dumps(self.to_dict(), indent=2,\n sort_keys=True))","def write_config(configs,configfile=None):\n\n if not configfile:\n configfile=default_configfile()\n\n with open(configfile,\"w\") as cfh:\n configs.write(cfh)","def tofile(self, file_like):\n cfg = configparser.SafeConfigParser()\n cfg.add_section('header')\n for key, val in self.header.items():\n cfg.set('header', key, str(val))\n cfg.add_section('params')\n for param_str in self.param_strs():\n cfg.set('params', param_str[0], '%s ; %s (%s)' % param_str[1:])\n cfg.write(file_like)","def WriteConfigTo(self, fich):\n try:\n #peter.zhang, for cygwin\n fich = fich.replace('\\\\', '/')\n fich = fich.replace('/cygdrive/', '')\n if fich.find(':/') < 0:\n fich = fich.replace('/', ':/', 1)\n open(fich, 'w').write(self._content)\n except IOError, msg:\n self._mess(ufmt(_(u'No write access to %s'), fich), '<F>_ERROR')","def run(self):\n write_config(self.filename)\n print('Wrote default config to', self.filename)","def write_config(profile, values):\n p = Path(CONFIG_FILE_PATH).expanduser()\n p.parent.mkdir(parents=True, exist_ok=True)\n config = configparser.ConfigParser()\n config.read(str(p))\n config[profile] = values\n with p.open(\"w\") as f:\n config.write(f)\n print(\"write config to\", p)","def _save_cfg_to_file(self, server_id, cfg):\n\t\tfile = self.SettingsFolder + '{}.yml'.format(server_id)\n\t\twith open(file, 'w') as f:\n\t\t\tyaml.dump(cfg, f, default_flow_style=False)","def create_settings_file():\n with open('./cfg/settings.cfg'.replace(\"/\", os.path.sep), 'w') as cfg:\n cfg.write('[report]\\nlogo = ./cfg/logo.png\\ncompany =\\nrecord =\\nunit =\\nexaminer =\\nnotes =\\n\\n[auth]\\ngmail = alias@gmail.com\\npassw = yourpassword\\ndevid = 1234567887654321\\ncelnumbr = BackupPhoneNunmber\\n\\n[app]\\npkg = com.whatsapp\\nsig = 38a0f7d505fe18fec64fbf343ecaaaf310dbd799\\n\\n[client]\\npkg = com.google.android.gms\\nsig = 38918a453d07199354f8b19af05ec6562ced5788\\nver = 9877000'.replace(\"/\", os.path.sep))","def save_config(conf, save_path):\n with open(os.path.join(save_path), \"w\") as f:\n f.write(yaml.dump({'param': conf}, default_flow_style=False))","def save(config, filename=None):\n filename = add_directory(filename or 'configure.json')\n directory = os.path.dirname(filename)\n if not os.path.exists(directory):\n os.makedirs(directory, 0o700)\n with open(filename, \"w\") as f:\n json.dump(config, f, indent=2, sort_keys=True)","def save_config(_config, simulation_dir):\n with open(os.path.join(simulation_dir, 'config.yaml'), 'w') as f:\n yaml.dump(_config, f, default_flow_style=False)","def save_conf(self, name=None):\n \n if name:\n filename = name\n \n else:\n filename = \"conf_\" + str(self.conf[\"device\"]) + \"_\" + datetime.today().strftime('%Y-%m-%d') + \".txt\"\n \n path = \"./source/_0_time_series_class/configuration/\"\n filename = path + filename\n \n with open(filename, \"w\") as file:\n json.dump(self.conf, file)","def save_config(self, filename: str=None):\n if not filename:\n filename = self.config_file\n with open(filename, \"w\") as file_object:\n json.dump(self.config, file_object, indent=4, sort_keys=True)","def write_config(self):\n cfg = {\n 'channel':self.channel,\n 'seuil_min':self.seuil_min,\n 'last_level':self.last_level,\n 'last_level_date':self.last_level_date\n }\n write_conf(self.CONF_FILE,cfg)","def test_config_write(get_config, default_config):\n cfg = get_config(Config, default_config('sys'))\n\n try:\n cfg.write()\n except Exception as e:\n pytest.fail(f'exception raised as\\n{e}')","def log_exp_config(xp_path, dataset):\n\n log_file = \"{}/log.txt\".format(xp_path)\n log = open(log_file, \"a\")\n\n log.write(\"Experiment configuration\\n\")\n log.write(\"Dataset: {}\\n\".format(dataset))\n log.write(\"Seed: {}\\n\".format(Cfg.seed))\n log.write(\"Fraction of Outliers: {}\\n\".format(Cfg.out_frac))\n log.write(\"First layer weight init by dictionary: {}\\n\".format(Cfg.weight_dict_init))\n log.write(\"PCA pre-processing? {}\\n\".format(Cfg.pca))\n log.write(\"Norm used: {}\\n\".format(Cfg.unit_norm_used))\n log.write(\"Global contrast normalization? {}\\n\".format(Cfg.gcn))\n log.write(\"ZCA Whitening? {}\\n\".format(Cfg.zca_whitening))\n log.write(\"Number of centroids? {}\\n\".format(Cfg.n_cluster))\n\n if dataset == 'mnist':\n str_normal = str(Cfg.mnist_normal)\n str_outlier = str(Cfg.mnist_outlier)\n if Cfg.mnist_normal == -1:\n str_normal = \"all\"\n if Cfg.mnist_outlier == -1:\n str_outlier = \"all\"\n log.write(\"MNIST classes: {} vs. {}\\n\".format(str_normal, str_outlier))\n log.write(\"MNIST representation dimensionality: {}\\n\".format(Cfg.mnist_rep_dim))\n log.write(\"MNIST Network with bias terms? {}\\n\".format(Cfg.mnist_bias))\n\n if dataset == 'cifar10':\n str_normal = str(Cfg.cifar10_normal)\n str_outlier = str(Cfg.cifar10_outlier)\n if Cfg.cifar10_normal == -1:\n str_normal = \"all\"\n if Cfg.cifar10_outlier == -1:\n str_outlier = \"all\"\n log.write(\"CIFAR-10 classes: {} vs. {}\\n\".format(str_normal, str_outlier))\n log.write(\"CIFAR-10 representation dimensionality: {}\\n\".format(Cfg.cifar10_rep_dim))\n log.write(\"CIFAR-10 Network with bias terms? {}\\n\".format(Cfg.cifar10_bias))\n\n if dataset == 'mobifall':\n str_normal = str(Cfg.mobiFall_normal)\n str_outlier = str(Cfg.mobiFall_outlier)\n log.write(\"MobiFall classes: {} vs. {}\\n\".format(str_normal, str_outlier))\n log.write(\"MobiFall representation dimensionality: {}\\n\".format(Cfg.mobiFall_rep_dim))\n log.write(\"MobiFall Network with bias terms? {}\\n\".format(Cfg.mobiFall_bias))\n\n log.write(\"\\n\\n\")\n log.close()","def save_config(config, filename=None):\n if filename is None:\n filename = CONFIG_FN\n with open(filename, \"w\", encoding=\"utf-8\") as fh:\n json.dump(\n config,\n fh,\n sort_keys=True,\n indent=4,\n separators=(\",\", \": \"),\n )","def writeConfig(self):\n targetFile = \"%s/%s\" % (self.workingDir, self.merge_pset_file)\n handle = open(targetFile, 'w')\n handle.write(self.mergeConfig())\n handle.close()\n return","def write_config(self, cfg, slot):\n pass","def saveConfig(config):\n global SW_CONFIG\n cf = ConfigParser.ConfigParser()\n cf.add_section(\"dir_config\")\n cf.set(\"dir_config\", \"7zpath\", config['7zpath'])\n cf.set(\"dir_config\", \"sharefolder\", config['sharefolder'])\n cf.set(\"dir_config\", \"distpath\", config['distpath'])\n cf.add_section(\"sw_config\")\n cf.set(\"sw_config\", \"version\", config['sw_version'])\n cf.set(\"sw_config\", \"startup\", config['startup'])\n cf.add_section(\"run_config\")\n cf.set(\"run_config\", \"pop\", False)\n cf.set(\"run_config\", \"backup\", False)\n fp = open(CONFIG_FILE, \"w\")\n cf.write(fp)\n fp.close()\n SW_CONFIG = config","def createConfig():\n\twith open(configPath, 'w', encoding='utf-8') as file:\n\t\tjson.dump(default_config, file, indent=3)","def save_config_to_json(config, filename):\n with open(filename, 'w+') as f:\n json.dump(vars(config), f)","def save(self, config_file: typing.TextIO):\n json.dump(self.to_dict(), config_file, indent=4)","def dump_config_to_json_file(output_path: str, config: dict) -> None:\n with open(output_path, \"w\") as f:\n f.write(json.dumps(config, indent=4))","def save(self):\n with open(self._CONFIG_FILE_PATH, 'w') as config_file:\n json.dump(vars(self), config_file)\n return self._CONFIG_FILE_PATH","def save( self ):\n ini = codecs.open(self.filename,\"w\",\"utf-8\",errors=\"replace\",buffering=0)\n for (name,value) in self.conf.items():\n print >>ini, name, \"=\", value\n ini.close()","def save_to_config(self) -> None:\n config_path = os.path.join(self.base_path, \"config.json\")\n\n with open(config_path, \"r\") as _json:\n c_dict = json.load(_json)\n\n c_dict[\"mean_similarity_error\"] = self.ME\n c_dict[\"similarity_correlation\"] = self.pearson_corr\n c_dict[\"similarity_spearman_correlation\"] = self.spearman_corr\n\n with open(config_path, \"w\") as _json:\n json.dump(c_dict, _json)","def process_config(json_file):\n config, _ = get_config_from_json(json_file)\n print(\" THE Configuration of your experiment ..\")\n pprint(config)\n print(\" *************************************** \")\n try:\n config.summary_dir = os.path.join(\"experiments\", config.exp_name, \"summaries/\")\n config.checkpoint_dir = os.path.join(\"experiments\", config.exp_name, \"checkpoints/\")\n config.out_dir = os.path.join(\"experiments\", config.exp_name, \"out/\")\n create_dirs([config.summary_dir, config.checkpoint_dir, config.out_dir])\n except AttributeError as e:\n print(\"ERROR!!..Please provide the exp_name in json file..\")\n exit(-1)\n return config"],"string":"[\n \"def write(self, fn):\\n with open(fn, 'w') as f:\\n self.config.write(f)\",\n \"def __write_config(self):\\n with open(self.config_file, 'w') as data_file:\\n config = {\\\"ibooks_doc_root\\\":self.ibooks_doc_root,\\n \\\"library_folder\\\":self.library_folder,\\n \\\"annotation_folder\\\":self.annotation_folder,\\n \\\"tmp_dir\\\":self.tmp_dir\\n } \\n data = json.dumps(config, ensure_ascii=False)\\n data_file.write(data)\",\n \"def write_config_file(config, args):\\n config_filename = 'testsuite_cfg.json'\\n args.config = config_filename\\n config_file = open(config_filename, 'w')\\n config_file.write(str(json.dumps(config)))\\n config_file.close()\",\n \"def write_config_file(self):\\n for opt, opt_desc in self.opt_dict.iteritems():\\n if 'permanent' in opt_desc and opt_desc['permanent'] == True:\\n enabled = 'Always'\\n else:\\n enabled = opt_desc['enabled'].__str__()\\n\\n self.file_parser.set(opt, 'enabled', enabled)\\n self.file_parser.set(opt, 'implementation',\\n opt_desc['selected_imp'])\\n self.file_parser.set(opt, 'optype', opt_desc['imptype'])\\n\\n for config, config_desc in self.config_dict.iteritems():\\n enabled = config_desc['enabled'].__str__()\\n self.file_parser.set(config, 'enabled', enabled)\\n\\n scratch_file = self.config_filename + '.scratch'\\n with open(scratch_file, 'w') as cfile:\\n for config in sorted(self.config_dict.keys()):\\n self.write_section(cfile, config)\\n\\n for opt in sorted(self.opt_dict.keys()):\\n self.write_section(cfile, opt)\\n\\n for imp in sorted(self.imp2opt_dict.keys()):\\n self.write_section(cfile, imp)\\n\\n cfile.write(\\\"\\\\n\\\")\\n\\n os.rename(scratch_file, self.config_filename)\",\n \"def write_config(self, fname, data):\\n with open(fname, 'w') as fhandle:\\n fhandle.write(data)\",\n \"def write_config_file():\\n\\tif not config_parser:\\n\\t\\tprint \\\"Config module not loaded. I don't save anything.\\\"\\n\\t\\treturn\\n\\n\\tf = file(config_file, \\\"w\\\")\\n\\tconfig_parser.write(f)\\n\\tf.close()\",\n \"def write_config(self, filename):\\n self.config.filename = filename\\n self.config.write()\",\n \"def write_config(self):\\n logging.debug(\\\"Writing configuration file: %s\\\" % self.config_file)\\n f = open(self.config_file, \\\"w\\\")\\n self.config.write(f)\\n f.close()\",\n \"def _write_config_file(self, config_data, indent=2):\\r\\n with open(self.config, 'w') as f:\\r\\n json.dump(config_data, f, indent=indent)\",\n \"def save_config_file(self):\\n wkdir = Path(self.config_dict[\\\"outputdir\\\"])\\n config_filename = str(wkdir / f\\\"{self.config_dict['name']}.json\\\")\\n save_config(self.config_dict, config_filename)\",\n \"def save(self):\\n file = open(self.path, 'w')\\n self.config.write(file)\\n file.close()\",\n \"def write(self, path):\\n with open(path, \\\"w\\\") as fh_:\\n fh_.write(self.config())\",\n \"def write(self, path):\\n with open(path, \\\"w\\\") as fh_:\\n fh_.write(self.config())\",\n \"def write_config(self, config_file):\\n \\n # write root paths\\n \\n # write reference data\\n \\n # write tool paths\\n \\n pass\",\n \"def write(self, filename: str):\\n obj = self.to_dict(self)\\n config.write(obj, filename)\",\n \"def write_configuration_file(self, content):\\n with open(self.configuration_file_path, 'w') as configuration_file:\\n configuration_file.write(content)\",\n \"def save(self):\\r\\n with open(self.filename, 'wb') as configfile:\\r\\n self.write(configfile)\",\n \"def save_config_file(self):\\n with open(self.config_file_name, 'w',encoding='utf-8') as outfile:\\n json.dump(self._config, outfile,indent=2)\",\n \"def write_config(self):\\n xshear_conf=XShearConfig(self['run'])\\n xshear_conf.write()\",\n \"def save_config() -> None:\\n with open(_config_file, \\\"w\\\", newline=\\\"\\\") as config_file:\\n json.dump(_config, config_file, indent=4)\\n config_file.truncate()\",\n \"def write_config():\\n\\n e = Element(\\\"Configuration\\\")\\n r = SubElement(e, \\\"RepositoryList\\\")\\n r = SubElement(r, \\\"Repository\\\", name = \\\"default\\\")\\n SubElement(r, \\\"Module\\\").text = args.driver\\n SubElement(r, \\\"TokenLabel\\\").text = args.token_label\\n SubElement(r, \\\"PIN\\\").text = args.pin\\n ElementTree(e).write(args.write_config)\\n args.write_config.flush()\",\n \"def write(self):\\n cfgpath = os.path.join(self.config_dir, CONFIG_FILENAME)\\n ofile = open(cfgpath, 'w')\\n if ofile:\\n log.debug( \\\"Write config: %s\\\" % cfgpath )\\n cfg = yaml.dump(self.yaml, default_flow_style=False)\\n log.debug( \\\"Config:\\\\n%s\\\" % cfg)\\n ofile.write(cfg)\\n ofile.close()\",\n \"def save():\\n with open(CONFIG_FILE, 'w') as f:\\n json.dump(config, f, indent=4, sort_keys=True)\",\n \"def write_config(self):\\r\\n obj = [\\r\\n [self.ip,\\r\\n self.gate,\\r\\n self.mask,\\r\\n self.name,\\r\\n self.time]\\r\\n ]\\r\\n with open('config.json', 'wt') as jsonfile:\\r\\n json.dump(obj, jsonfile)\",\n \"def write_config(config):\\n config_path = os.path.join(CONFIG_PATH, CONFIG_FILE)\\n\\n with open(config_path, \\\"w\\\") as config_file:\\n json.dump(config, config_file)\",\n \"def save_config(self):\\n with open(self.config_file, 'w') as fout:\\n json.dump({'name_dict': self._name_dict, 'metric_dict': self._metric_dict, 'credential_path': self.credential_path, 'path_for_worksheet_name': self.path_for_worksheet_name}, fout)\",\n \"def saveConfig():\\n with open(_CONFIG_FNM, 'w') as configfile:\\n CONFIG_DICT.write(configfile,\\n space_around_delimiters=True)\",\n \"def save(self):\\n for p, c in self.configs_:\\n c.write(p)\",\n \"def write_config(self, config: dict):\\n if self.config_in_use():\\n raise BaseConfigInUseError()\\n\\n for conf_name, conf in create_config(\\n self.config_dir, self.data_dir, config\\n ).items():\\n with open(abspath(join(self.config_dir, conf_name)), \\\"w\\\") as f:\\n f.write(conf)\",\n \"def _write_params_file(model_config: base_model_params.BaseModelParams,\\n job_log_dir: str) -> None:\\n if jax.process_index() == 0:\\n params_fpath = os.path.join(job_log_dir, 'model_params.txt')\\n if not tf.io.gfile.exists(job_log_dir):\\n tf.io.gfile.makedirs(job_log_dir)\\n with tf.io.gfile.GFile(params_fpath, 'w') as params_file:\\n datasets = model_config.datasets()\\n for dataset in datasets:\\n params_file.write(dataset.ToText())\\n params_file.write('\\\\n\\\\n')\\n params_file.write(model_config.task().ToText())\",\n \"def setup_configuration_file(self):\\n\\n with open(self.config_path, \\\"w+\\\") as f_config:\\n\\n f_config.write(get_configuration_file_form())\",\n \"def write_config_updater(path: Path, config: ConfigUpdater) -> None:\\n to_write_config = copy.deepcopy(config)\\n with os.fdopen(os.open(path.as_posix(), os.O_WRONLY | os.O_CREAT, 0o600), \\\"w\\\") as fh:\\n to_write_config.write(fh)\",\n \"def save_config(config_path: str, data: dict):\\n with open(config_path, 'w') as j:\\n dump(data,j)\",\n \"def save_to_file(self):\\n check_path(self.config_path)\\n\\n with open(self.settings_file, 'w') as settings_file:\\n options = self._get_options()\\n json.dump(options,\\n \\t settings_file,\\n \\t indent=4,\\n \\t separators=(',', ': '))\",\n \"def write(self, config_path=CONFIG_PATH):\\n\\n with open(self.full_path(config_path), 'w') as conf_fh:\\n conf_fh.write(self.local_config)\",\n \"def save(self):\\r\\n with open(self.filename, 'w') as f:\\r\\n if self.pretty:\\r\\n json.dump(self.__config, f, sort_keys=False,\\r\\n indent=4, separators=(',', ': '))\\r\\n else:\\r\\n json.dump(self.__config, f)\",\n \"def _write_config(self, config_path: Path):\\n with open(config_path, \\\"w\\\") as f:\\n json.dump(self.config_overrides, f)\",\n \"def save_config(self):\\n data = json.dumps(self.cfg)\\n\\n try:\\n file = open(self.cfg_file_name, 'w')\\n file.write(data)\\n except OSError as err:\\n print(\\\"can't save property: {0}\\\".format(err))\\n else:\\n file.close()\",\n \"def write_config(self,file_path):\\r\\n with open(file_path,\\\"w\\\",encoding=\\\"utf-8\\\") as fw:\\r\\n\\r\\n json_data = dict()\\r\\n json_data[\\\"mode\\\"] = self.mode\\r\\n json_data[\\\"client_num\\\"] = self.client_num\\r\\n json_data[\\\"class_num_for_client\\\"] = self.class_num_for_client\\r\\n json_data[\\\"dataset_name\\\"] = self.dataset_name\\r\\n json_data[\\\"model_name\\\"] = self.model_name\\r\\n json_data[\\\"communication_round\\\"] = self.communication_round\\r\\n json_data[\\\"local_epoch\\\"] = self.local_epoch\\r\\n json_data[\\\"batch_size\\\"] = self.batch_size\\r\\n json_data[\\\"use_server\\\"] = self.use_server\\r\\n json.dump(json_data,fw,ensure_ascii=False)\",\n \"def save(self):\\n try:\\n with open(self._filename, 'w') as conf_file:\\n conf_file.write(json.dumps(self._data))\\n except OSError:\\n _LOGGER.exception(\\\"Can't store config in %s\\\", self._filename)\",\n \"def writeto(self, filename=None):\\n if filename is None:\\n if self.fileout is not None:\\n filename = self.fileout\\n else:\\n raise IOError(\\\"filename is None and no self.fileout set.\\\")\\n \\n with open(filename, \\\"w\\\") as f:\\n f.writelines(\\\"\\\\n\\\".join(self.get_config(\\\"configfile\\\")))\",\n \"def save():\\n\\n env.config.save(env.config_file)\",\n \"def _write_config(parser):\\n with open(PRAW_FILE_PATH, \\\"w\\\") as c_file:\\n parser.write(c_file)\",\n \"def save():\\n print(\\\"Saving config file..\\\")\\n\\n res = yaml.round_trip_dump(_conf, indent=2, block_seq_indent=1)\\n\\n with open(__config_file, 'w', encoding='utf-8') as stream:\\n stream.write(res)\",\n \"def write_config(self):\\n cfg = {\\n 'ALERT_API_KEY':self.api_key,\\n 'APP_NAME':self.title,\\n 'alertes':self.alertes\\n }\\n write_conf(self.CONF_FILE,cfg)\",\n \"def write(self, config_path=CONFIG_PATH):\\n\\n peers_file = self.peers_full_path(config_path)\\n\\n with open(self.full_path(config_path), 'w') as conf_fh:\\n conf_fh.write(self.interface)\\n conf_fh.write(f'PostUp = wg addconf %i {peers_file}')\\n\\n with open(peers_file, 'w') as peers_fh:\\n peers_fh.write(self.peers)\",\n \"def write_config(config, config_template, config_path):\\n with open(config_path, 'wb') as cfg_file:\\n cfg_file.write(\\n config_template.render(**config).encode(\\\"utf-8\\\")\\n )\",\n \"def _createConfigFile(self):\\n configFile = self._configFile()\\n try:\\n with open(configFile) as fh:\\n pass\\n except IOError:\\n try:\\n with open(configFile, 'w') as fh:\\n fh.write(\\\"[settings]\\\\n\\\")\\n fh.write(\\\"debug = false\\\\n\\\")\\n fh.write(\\\"hidefilenames = false\\\\n\\\")\\n except IOError:\\n pass\",\n \"def create_config_file():\\n working_dir = get_working_dir()\\n with open('config.txt', 'w') as config_file:\\n config_file.write(working_dir + os.sep + 'LevelProgress.xlsx')\",\n \"def write_config(self, data):\\n logger.debug(\\\"[%s] Writing config\\\", self.name)\\n self.config.write(data)\",\n \"def test_write_config(self):\\n config = Config()\\n config.config = test_config\\n config.config_file = \\\"./config\\\"\\n config.write_config()\\n with open(config.config_file) as config_file:\\n data = config_file.read()\\n self.assertTrue(data)\\n os.remove(config.config_file)\",\n \"def write_config(resultsdir, configdict, message, filename=\\\"modelconfig.cfg\\\"):\\n f = open(resultsdir + filename, \\\"w\\\")\\n for key in configdict:\\n f.write(\\\"{}: {}\\\\n\\\".format(key, configdict[key]))\\n f.write(\\\"message:\\\" + message)\",\n \"def write(filename):\\n log.msg(\\\"Saving configuration information to \\\\\\\"\\\" + filename + \\\"\\\\\\\"\\\", lvl='i', ss='ss_configfile')\\n\\n f = open(filename, 'w')\\n cp = ConfigParser.SafeConfigParser()\\n #a little string hacking because our section names are un-normalized\\n #this builds a list of all the sections names\\n sectionslst = []\\n sections = []\\n for k in _loaded.keys():\\n sectionslst.append(k.split('.')[0])\\n #get unique entries\\n sections = _uniquer(sectionslst)\\n for sec in sections:\\n log.msg(\\\"\\\\tCompiling section \\\\\\\"\\\" + sec + \\\"\\\\\\\"\\\",\\n lvl='d3', ss='ss_configfile')\\n #make the headers\\n cp.add_section(sec)\\n #for each item in my dictionary\\n #it splits the key in two and uses that for the first and second \\\"set\\\" args\\n #then it uses the item.value for the 3rd arg\\n # from 'section.option:value'\\n \\n for k in _loaded.items():\\n cp.set(str(k[0]).split('.')[0], str(k[0]).split('.')[1], str(k[1]))\\n cp.write(f)\\n f.close()\",\n \"def save_config(self):\\n\\n if not self.__conf.has_section(self.section):\\n self.__conf.add_section(self.section)\\n\\n for key in self._params:\\n val = self._params[key]\\n self.__conf.set(self.section, key, val)\\n\\n with open(self.conf_path, 'w') as f:\\n self.__conf.write(f)\",\n \"def save_config(logfolder, file_name = \\\"configuration\\\"):\\n print(\\\"Save configuration to: \\\", logfolder)\\n root = ET.Element(\\\"conf\\\")\\n flg = ET.SubElement(root, \\\"flags\\\")\\n \\n flags_dict = FLAGS.__dict__['__flags']\\n for f in flags_dict:\\n #print f, flags_dict[f]\\n ET.SubElement(flg, f, name=f).text = str(flags_dict[f])\\n tree = ET.ElementTree(root)\\n tree.write(os.path.join(logfolder,file_name+\\\".xml\\\"), encoding=\\\"us-ascii\\\", xml_declaration=True, method=\\\"xml\\\")\",\n \"def write_config_file(batch_size, resize_to, train_prop):\\n config = ConfigParser()\\n config.read('config.ini')\\n\\n # Add model parameters; will add new section and create config file if it does not already exist\\n if not config.has_section('model params'):\\n config.add_section('model params')\\n\\n config.set('model params', 'batch_size', str(batch_size))\\n config.set('model params', 'resize_to', str(resize_to))\\n config.set('model params', 'train_prop', str(train_prop))\\n\\n # Write the file\\n with open('config.ini', 'w') as f:\\n config.write(f)\\n\\n return\",\n \"def write_config(config_filename, config=default_config):\\n comments=\\\"\\\"\\n if config==default_config:\\n comments+=\\\"# %s \\\\n\\\" % version.version_string\\n comments+=\\\"# This is the default config file\\\\n\\\"\\n comments+=\\\"# Generated on %s \\\\n\\\" % time.strftime('%x %X %Z')\\n comments+=\\\"# Visit %s for more informations \\\\n\\\" % version.project_url\\n c=SafeConfigParser()\\n f=open(config_filename,'w')\\n f.write(comments+\\\"\\\\n\\\")\\n for section in config.items():\\n name=section[0]\\n values=section[1]\\n c.add_section(name)\\n for value in values.items():\\n c.set(name, value[0], value[1])\\n c.write(f)\\n f.flush()\\n f.close()\",\n \"def save_config(self):\\n config.save_config(self.config, self.config_file)\",\n \"def write_config(self):\\n\\n #Before writing to file we must convert underscores to dashes, moreover _id must be written as id, and _type as type\\n\\n if not os.path.exists(NetworkManager_conf_dir):\\n os.makedirs(NetworkManager_conf_dir, mode=0755)\\n\\n profile_path = os.path.join(\\\"%s\\\" % NetworkManager_conf_dir, self.connection._id)\\n with open(profile_path, \\\"wb\\\") as configfile:\\n self.cfg.write(configfile)\",\n \"def _save_config_log(self, data):\\n config_path = os.path.join(self.runtime.working_dir, '.config')\\n with open(config_path, 'w') as f:\\n yaml.safe_dump(data, f, default_flow_style=False)\",\n \"def save_configuration(config):\\n with open(cwd + '/configuration.pickle', 'wb') as handle:\\n pickle.dump(config, handle, protocol=pickle.HIGHEST_PROTOCOL)\",\n \"def writeConfig(self):\\n\\n qU.writeConfig(quickLogger=self.logger,\\n\\t\\t curveDictionary=self.curveConf,\\n\\t\\t likelihoodDictionary=self.likelihoodConf,\\n commonDictionary=self.commonConf,\\n analysisDictionary=self.analysisConf)\",\n \"def save(self):\\n with open(self._config, 'w') as f:\\n json.dump(self.data, f, indent=2, sort_keys=True)\",\n \"def write_config(filename, parser, mode='w'):\\n with open(filename, mode) as config_file:\\n parser.write(config_file)\\n logging.info(f'Wrote config file \\\\'{filename}\\\\'.')\",\n \"def writeShREEKConfig(self, filename):\\n self._ShREEKConfig.save(filename)\\n return\",\n \"def _write_elasticluster_config(config, out_file):\\n orig_file = os.path.join(sys.prefix, \\\"share\\\", \\\"bcbio-vm\\\", \\\"elasticluster\\\", \\\"config\\\")\\n if not os.path.exists(os.path.dirname(out_file)):\\n os.makedirs(os.path.dirname(out_file))\\n if os.path.exists(out_file):\\n bak_file = out_file + \\\".bak%s\\\" % datetime.datetime.now().strftime(\\\"%Y-%m-%d-%H-%M-%S\\\")\\n shutil.move(out_file, bak_file)\\n with open(orig_file) as in_handle:\\n with open(out_file, \\\"w\\\") as out_handle:\\n for line in in_handle:\\n if line.startswith(tuple(config.keys())):\\n name, val = line.strip().split(\\\"=\\\")\\n out_handle.write(\\\"%s=%s\\\\n\\\" % (name, config[name]))\\n else:\\n out_handle.write(line)\\n return out_file\",\n \"def save_config(self):\\n if not os.path.exists(self._conf_dir):\\n os.makedirs(self._conf_dir)\\n conf_file = os.path.join(self._conf_dir, \\\"dql.json\\\")\\n with open(conf_file, \\\"w\\\") as ofile:\\n json.dump(self.conf, ofile, indent=2)\",\n \"def write(cls, experiment: Experiment):\\n cls.__mutex.acquire()\\n os.makedirs('./temp', exist_ok=True)\\n worksheet = cls.__workbook.add_worksheet(experiment.name)\\n for i, value in enumerate(experiment.values.items()):\\n worksheet.write(0, i, value[0])\\n worksheet.write_column(1, i, value[1])\\n if experiment.model == 'accuracy':\\n # cls.__add_accuracy_plot(worksheet, value)\\n cls.test(worksheet, value)\\n\\n pass\\n\\n if experiment.model == 'performance':\\n cls.test(worksheet, value)\\n pass\\n # cls.__add_accuracy_plot(worksheet, value)\\n\\n cls.__mutex.release()\",\n \"def saveConfig(self):\\r\\n self.config[\\\"Settings\\\"] = {}\\r\\n settings = self.config[\\\"Settings\\\"]\\r\\n settings[\\\"datapath\\\"] = self.dataPath\\r\\n settings[\\\"videopath\\\"] = self.videoPath\\r\\n settings[\\\"dataoffset\\\"] = str(self.dataOffset)\\r\\n settings[\\\"colblindmode\\\"] = str(self.colBlindMode)\\r\\n with open(self.CONFIG_FILE,\\\"w\\\") as file:\\r\\n self.config.write(file)\",\n \"def save_config(logdir, config):\\n with open(os.path.join(logdir, 'config.yml'), 'w') as f:\\n yaml.dump(config.__dict__, f)\",\n \"def save_config(log_dir, config):\\n if not os.path.exists(log_dir):\\n os.makedirs(log_dir)\\n shutil.copy(config, os.path.join(log_dir, 'config.gin'))\",\n \"def dump_config_and_makefile(_config):\\n experiment_dir = Path(_config['trainer']['storage_dir'])\\n makefile_path = Path(experiment_dir) / \\\"Makefile\\\"\\n\\n if not makefile_path.exists():\\n from padertorch.contrib.examples.source_separation.tasnet.templates import \\\\\\n MAKEFILE_TEMPLATE_TRAIN\\n\\n config_path = experiment_dir / \\\"config.json\\\"\\n pt.io.dump_config(_config, config_path)\\n\\n makefile_path.write_text(\\n MAKEFILE_TEMPLATE_TRAIN.format(\\n main_python_path=pt.configurable.resolve_main_python_path(),\\n experiment_name=experiment_name,\\n eval_python_path=('.'.join(\\n pt.configurable.resolve_main_python_path().split('.')[:-1]\\n ) + '.evaluate')\\n )\\n )\",\n \"def save_config(self, path):\\n if os.path.isdir(path):\\n path = os.path.join(path, 'config.json')\\n print('Save config to {}'.format(path))\\n with open(path, 'w', encoding='utf-8') as w:\\n w.write(json.dumps(self.to_dict(), indent=2,\\n sort_keys=True))\",\n \"def write_config(configs,configfile=None):\\n\\n if not configfile:\\n configfile=default_configfile()\\n\\n with open(configfile,\\\"w\\\") as cfh:\\n configs.write(cfh)\",\n \"def tofile(self, file_like):\\n cfg = configparser.SafeConfigParser()\\n cfg.add_section('header')\\n for key, val in self.header.items():\\n cfg.set('header', key, str(val))\\n cfg.add_section('params')\\n for param_str in self.param_strs():\\n cfg.set('params', param_str[0], '%s ; %s (%s)' % param_str[1:])\\n cfg.write(file_like)\",\n \"def WriteConfigTo(self, fich):\\n try:\\n #peter.zhang, for cygwin\\n fich = fich.replace('\\\\\\\\', '/')\\n fich = fich.replace('/cygdrive/', '')\\n if fich.find(':/') < 0:\\n fich = fich.replace('/', ':/', 1)\\n open(fich, 'w').write(self._content)\\n except IOError, msg:\\n self._mess(ufmt(_(u'No write access to %s'), fich), '<F>_ERROR')\",\n \"def run(self):\\n write_config(self.filename)\\n print('Wrote default config to', self.filename)\",\n \"def write_config(profile, values):\\n p = Path(CONFIG_FILE_PATH).expanduser()\\n p.parent.mkdir(parents=True, exist_ok=True)\\n config = configparser.ConfigParser()\\n config.read(str(p))\\n config[profile] = values\\n with p.open(\\\"w\\\") as f:\\n config.write(f)\\n print(\\\"write config to\\\", p)\",\n \"def _save_cfg_to_file(self, server_id, cfg):\\n\\t\\tfile = self.SettingsFolder + '{}.yml'.format(server_id)\\n\\t\\twith open(file, 'w') as f:\\n\\t\\t\\tyaml.dump(cfg, f, default_flow_style=False)\",\n \"def create_settings_file():\\n with open('./cfg/settings.cfg'.replace(\\\"/\\\", os.path.sep), 'w') as cfg:\\n cfg.write('[report]\\\\nlogo = ./cfg/logo.png\\\\ncompany =\\\\nrecord =\\\\nunit =\\\\nexaminer =\\\\nnotes =\\\\n\\\\n[auth]\\\\ngmail = alias@gmail.com\\\\npassw = yourpassword\\\\ndevid = 1234567887654321\\\\ncelnumbr = BackupPhoneNunmber\\\\n\\\\n[app]\\\\npkg = com.whatsapp\\\\nsig = 38a0f7d505fe18fec64fbf343ecaaaf310dbd799\\\\n\\\\n[client]\\\\npkg = com.google.android.gms\\\\nsig = 38918a453d07199354f8b19af05ec6562ced5788\\\\nver = 9877000'.replace(\\\"/\\\", os.path.sep))\",\n \"def save_config(conf, save_path):\\n with open(os.path.join(save_path), \\\"w\\\") as f:\\n f.write(yaml.dump({'param': conf}, default_flow_style=False))\",\n \"def save(config, filename=None):\\n filename = add_directory(filename or 'configure.json')\\n directory = os.path.dirname(filename)\\n if not os.path.exists(directory):\\n os.makedirs(directory, 0o700)\\n with open(filename, \\\"w\\\") as f:\\n json.dump(config, f, indent=2, sort_keys=True)\",\n \"def save_config(_config, simulation_dir):\\n with open(os.path.join(simulation_dir, 'config.yaml'), 'w') as f:\\n yaml.dump(_config, f, default_flow_style=False)\",\n \"def save_conf(self, name=None):\\n \\n if name:\\n filename = name\\n \\n else:\\n filename = \\\"conf_\\\" + str(self.conf[\\\"device\\\"]) + \\\"_\\\" + datetime.today().strftime('%Y-%m-%d') + \\\".txt\\\"\\n \\n path = \\\"./source/_0_time_series_class/configuration/\\\"\\n filename = path + filename\\n \\n with open(filename, \\\"w\\\") as file:\\n json.dump(self.conf, file)\",\n \"def save_config(self, filename: str=None):\\n if not filename:\\n filename = self.config_file\\n with open(filename, \\\"w\\\") as file_object:\\n json.dump(self.config, file_object, indent=4, sort_keys=True)\",\n \"def write_config(self):\\n cfg = {\\n 'channel':self.channel,\\n 'seuil_min':self.seuil_min,\\n 'last_level':self.last_level,\\n 'last_level_date':self.last_level_date\\n }\\n write_conf(self.CONF_FILE,cfg)\",\n \"def test_config_write(get_config, default_config):\\n cfg = get_config(Config, default_config('sys'))\\n\\n try:\\n cfg.write()\\n except Exception as e:\\n pytest.fail(f'exception raised as\\\\n{e}')\",\n \"def log_exp_config(xp_path, dataset):\\n\\n log_file = \\\"{}/log.txt\\\".format(xp_path)\\n log = open(log_file, \\\"a\\\")\\n\\n log.write(\\\"Experiment configuration\\\\n\\\")\\n log.write(\\\"Dataset: {}\\\\n\\\".format(dataset))\\n log.write(\\\"Seed: {}\\\\n\\\".format(Cfg.seed))\\n log.write(\\\"Fraction of Outliers: {}\\\\n\\\".format(Cfg.out_frac))\\n log.write(\\\"First layer weight init by dictionary: {}\\\\n\\\".format(Cfg.weight_dict_init))\\n log.write(\\\"PCA pre-processing? {}\\\\n\\\".format(Cfg.pca))\\n log.write(\\\"Norm used: {}\\\\n\\\".format(Cfg.unit_norm_used))\\n log.write(\\\"Global contrast normalization? {}\\\\n\\\".format(Cfg.gcn))\\n log.write(\\\"ZCA Whitening? {}\\\\n\\\".format(Cfg.zca_whitening))\\n log.write(\\\"Number of centroids? {}\\\\n\\\".format(Cfg.n_cluster))\\n\\n if dataset == 'mnist':\\n str_normal = str(Cfg.mnist_normal)\\n str_outlier = str(Cfg.mnist_outlier)\\n if Cfg.mnist_normal == -1:\\n str_normal = \\\"all\\\"\\n if Cfg.mnist_outlier == -1:\\n str_outlier = \\\"all\\\"\\n log.write(\\\"MNIST classes: {} vs. {}\\\\n\\\".format(str_normal, str_outlier))\\n log.write(\\\"MNIST representation dimensionality: {}\\\\n\\\".format(Cfg.mnist_rep_dim))\\n log.write(\\\"MNIST Network with bias terms? {}\\\\n\\\".format(Cfg.mnist_bias))\\n\\n if dataset == 'cifar10':\\n str_normal = str(Cfg.cifar10_normal)\\n str_outlier = str(Cfg.cifar10_outlier)\\n if Cfg.cifar10_normal == -1:\\n str_normal = \\\"all\\\"\\n if Cfg.cifar10_outlier == -1:\\n str_outlier = \\\"all\\\"\\n log.write(\\\"CIFAR-10 classes: {} vs. {}\\\\n\\\".format(str_normal, str_outlier))\\n log.write(\\\"CIFAR-10 representation dimensionality: {}\\\\n\\\".format(Cfg.cifar10_rep_dim))\\n log.write(\\\"CIFAR-10 Network with bias terms? {}\\\\n\\\".format(Cfg.cifar10_bias))\\n\\n if dataset == 'mobifall':\\n str_normal = str(Cfg.mobiFall_normal)\\n str_outlier = str(Cfg.mobiFall_outlier)\\n log.write(\\\"MobiFall classes: {} vs. {}\\\\n\\\".format(str_normal, str_outlier))\\n log.write(\\\"MobiFall representation dimensionality: {}\\\\n\\\".format(Cfg.mobiFall_rep_dim))\\n log.write(\\\"MobiFall Network with bias terms? {}\\\\n\\\".format(Cfg.mobiFall_bias))\\n\\n log.write(\\\"\\\\n\\\\n\\\")\\n log.close()\",\n \"def save_config(config, filename=None):\\n if filename is None:\\n filename = CONFIG_FN\\n with open(filename, \\\"w\\\", encoding=\\\"utf-8\\\") as fh:\\n json.dump(\\n config,\\n fh,\\n sort_keys=True,\\n indent=4,\\n separators=(\\\",\\\", \\\": \\\"),\\n )\",\n \"def writeConfig(self):\\n targetFile = \\\"%s/%s\\\" % (self.workingDir, self.merge_pset_file)\\n handle = open(targetFile, 'w')\\n handle.write(self.mergeConfig())\\n handle.close()\\n return\",\n \"def write_config(self, cfg, slot):\\n pass\",\n \"def saveConfig(config):\\n global SW_CONFIG\\n cf = ConfigParser.ConfigParser()\\n cf.add_section(\\\"dir_config\\\")\\n cf.set(\\\"dir_config\\\", \\\"7zpath\\\", config['7zpath'])\\n cf.set(\\\"dir_config\\\", \\\"sharefolder\\\", config['sharefolder'])\\n cf.set(\\\"dir_config\\\", \\\"distpath\\\", config['distpath'])\\n cf.add_section(\\\"sw_config\\\")\\n cf.set(\\\"sw_config\\\", \\\"version\\\", config['sw_version'])\\n cf.set(\\\"sw_config\\\", \\\"startup\\\", config['startup'])\\n cf.add_section(\\\"run_config\\\")\\n cf.set(\\\"run_config\\\", \\\"pop\\\", False)\\n cf.set(\\\"run_config\\\", \\\"backup\\\", False)\\n fp = open(CONFIG_FILE, \\\"w\\\")\\n cf.write(fp)\\n fp.close()\\n SW_CONFIG = config\",\n \"def createConfig():\\n\\twith open(configPath, 'w', encoding='utf-8') as file:\\n\\t\\tjson.dump(default_config, file, indent=3)\",\n \"def save_config_to_json(config, filename):\\n with open(filename, 'w+') as f:\\n json.dump(vars(config), f)\",\n \"def save(self, config_file: typing.TextIO):\\n json.dump(self.to_dict(), config_file, indent=4)\",\n \"def dump_config_to_json_file(output_path: str, config: dict) -> None:\\n with open(output_path, \\\"w\\\") as f:\\n f.write(json.dumps(config, indent=4))\",\n \"def save(self):\\n with open(self._CONFIG_FILE_PATH, 'w') as config_file:\\n json.dump(vars(self), config_file)\\n return self._CONFIG_FILE_PATH\",\n \"def save( self ):\\n ini = codecs.open(self.filename,\\\"w\\\",\\\"utf-8\\\",errors=\\\"replace\\\",buffering=0)\\n for (name,value) in self.conf.items():\\n print >>ini, name, \\\"=\\\", value\\n ini.close()\",\n \"def save_to_config(self) -> None:\\n config_path = os.path.join(self.base_path, \\\"config.json\\\")\\n\\n with open(config_path, \\\"r\\\") as _json:\\n c_dict = json.load(_json)\\n\\n c_dict[\\\"mean_similarity_error\\\"] = self.ME\\n c_dict[\\\"similarity_correlation\\\"] = self.pearson_corr\\n c_dict[\\\"similarity_spearman_correlation\\\"] = self.spearman_corr\\n\\n with open(config_path, \\\"w\\\") as _json:\\n json.dump(c_dict, _json)\",\n \"def process_config(json_file):\\n config, _ = get_config_from_json(json_file)\\n print(\\\" THE Configuration of your experiment ..\\\")\\n pprint(config)\\n print(\\\" *************************************** \\\")\\n try:\\n config.summary_dir = os.path.join(\\\"experiments\\\", config.exp_name, \\\"summaries/\\\")\\n config.checkpoint_dir = os.path.join(\\\"experiments\\\", config.exp_name, \\\"checkpoints/\\\")\\n config.out_dir = os.path.join(\\\"experiments\\\", config.exp_name, \\\"out/\\\")\\n create_dirs([config.summary_dir, config.checkpoint_dir, config.out_dir])\\n except AttributeError as e:\\n print(\\\"ERROR!!..Please provide the exp_name in json file..\\\")\\n exit(-1)\\n return config\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7415516","0.73900247","0.7218968","0.72177714","0.71523476","0.70878863","0.70843565","0.7062435","0.6997892","0.6982512","0.6912694","0.6897209","0.6897209","0.6863159","0.6842561","0.67937106","0.6761959","0.67610425","0.6752727","0.67474806","0.67445403","0.67359155","0.6716864","0.6715711","0.67080563","0.66980153","0.66714865","0.6630717","0.6628451","0.66147834","0.6612824","0.66099656","0.65723234","0.6571725","0.6567229","0.6539516","0.65310854","0.64976335","0.6484784","0.64777166","0.645864","0.64438385","0.6410984","0.6398083","0.63975644","0.63800937","0.6378702","0.636467","0.636418","0.63506556","0.6345462","0.63274455","0.6310256","0.6309139","0.6295632","0.62908316","0.62457585","0.62311906","0.6217417","0.61891264","0.6179165","0.616965","0.6168656","0.6163945","0.61602306","0.6155656","0.615475","0.61523813","0.61376286","0.6137123","0.61355555","0.6126577","0.612601","0.6123655","0.61105937","0.6110277","0.6099836","0.6098969","0.60967666","0.6092215","0.60867995","0.6086285","0.6079056","0.6068033","0.60656655","0.6057948","0.6053864","0.6024602","0.6024118","0.60224235","0.60166407","0.6016498","0.6016107","0.601548","0.6007916","0.5993857","0.59864694","0.59858155","0.5983763","0.59783024"],"string":"[\n \"0.7415516\",\n \"0.73900247\",\n \"0.7218968\",\n \"0.72177714\",\n \"0.71523476\",\n \"0.70878863\",\n \"0.70843565\",\n \"0.7062435\",\n \"0.6997892\",\n \"0.6982512\",\n \"0.6912694\",\n \"0.6897209\",\n \"0.6897209\",\n \"0.6863159\",\n \"0.6842561\",\n \"0.67937106\",\n \"0.6761959\",\n \"0.67610425\",\n \"0.6752727\",\n \"0.67474806\",\n \"0.67445403\",\n \"0.67359155\",\n \"0.6716864\",\n \"0.6715711\",\n \"0.67080563\",\n \"0.66980153\",\n \"0.66714865\",\n \"0.6630717\",\n \"0.6628451\",\n \"0.66147834\",\n \"0.6612824\",\n \"0.66099656\",\n \"0.65723234\",\n \"0.6571725\",\n \"0.6567229\",\n \"0.6539516\",\n \"0.65310854\",\n \"0.64976335\",\n \"0.6484784\",\n \"0.64777166\",\n \"0.645864\",\n \"0.64438385\",\n \"0.6410984\",\n \"0.6398083\",\n \"0.63975644\",\n \"0.63800937\",\n \"0.6378702\",\n \"0.636467\",\n \"0.636418\",\n \"0.63506556\",\n \"0.6345462\",\n \"0.63274455\",\n \"0.6310256\",\n \"0.6309139\",\n \"0.6295632\",\n \"0.62908316\",\n \"0.62457585\",\n \"0.62311906\",\n \"0.6217417\",\n \"0.61891264\",\n \"0.6179165\",\n \"0.616965\",\n \"0.6168656\",\n \"0.6163945\",\n \"0.61602306\",\n \"0.6155656\",\n \"0.615475\",\n \"0.61523813\",\n \"0.61376286\",\n \"0.6137123\",\n \"0.61355555\",\n \"0.6126577\",\n \"0.612601\",\n \"0.6123655\",\n \"0.61105937\",\n \"0.6110277\",\n \"0.6099836\",\n \"0.6098969\",\n \"0.60967666\",\n \"0.6092215\",\n \"0.60867995\",\n \"0.6086285\",\n \"0.6079056\",\n \"0.6068033\",\n \"0.60656655\",\n \"0.6057948\",\n \"0.6053864\",\n \"0.6024602\",\n \"0.6024118\",\n \"0.60224235\",\n \"0.60166407\",\n \"0.6016498\",\n \"0.6016107\",\n \"0.601548\",\n \"0.6007916\",\n \"0.5993857\",\n \"0.59864694\",\n \"0.59858155\",\n \"0.5983763\",\n \"0.59783024\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7216942"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":21987,"cells":{"query":{"kind":"string","value":"Return three Keras HDF5Matrix instances for the input, groundtruth density map and groundtruth segmentation mask in a compact TrainingSet"},"document":{"kind":"string","value":"def get_matrices(training_set_path):\n if os.path.isfile(training_set_path):\n X = HDF5Matrix(training_set_path, 'input/input')\n y = HDF5Matrix(training_set_path, 'target/target')\n y_seg = HDF5Matrix(training_set_path, 'seg_map/seg_map')\n return X, y, y_seg\n else:\n raise Exception('Training set file not found.')"},"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 transform_to_h5():\n # this took about 10 minutes for set1\n for setname in ['set1', 'set2']:\n filename = os.path.join(ltrc_dirname, '{}.h5'.format(setname))\n f = h5py.File(filename, 'w')\n\n for name in ['train', 'valid', 'test']:\n g = f.create_group(name)\n filename = os.path.join(ltrc_dirname, '{}.{}.txt'.format(setname, name))\n X, y, q = load_svmlight_file(filename, query_id=True)\n g.create_dataset('X', data=X.todense(), compression='gzip')\n g.create_dataset('y', data=y, compression='gzip')\n g.create_dataset('q', data=q, compression='gzip')\n f.close()\n # Now you can do this\n # f['/valid/X'].shape\n # Out[24]: (71083, 699)","def create_dev_matrix(self):\n if os.path.exists(self.dev_matrix_h5_path):\n print(\"[LOGGING]: \" + self.dev_matrix_h5_path + \" exists!\")\n return\n\n with h5py.File(self.dev_matrix_h5_path, 'w') as f:\n\n for mode in ['train', 'test']:\n for device in ['a', 'b', 'c']:\n grp = f.create_group(mode + '/' + device)\n grp['data'], grp['label'] = self.extract_npy(mode=mode, devices=device)\n # add parallel data as separate device p\n grp = f.create_group(mode + '/p')\n grp['data'], grp['label'] = self.extrac_para_npy(mode=mode)\n\n # add neg parallel data as device A\n grp = f.create_group(mode + '/A')\n grp['data'], grp['label'] = self.extract_neg_para_npy(mode=mode)\n f.close()","def build_model():\n mdl = Sequential()\n\n # normalization\n mdl.add(Lambda(lambda x: x/128. - 1, input_shape=IMAGE_SHAPE, name=\"input\"))\n\n # trim image\n mdl.add(Lambda(lambda x: x[:, 10:-10, :, :]))\n\n # convolutions\n mdl.add(Convolution2D(24, 5, 5, subsample=(2, 2), border_mode='same',))\n mdl.add(MaxPooling2D(pool_size=(2, 2)))\n mdl.add((Dropout(0.5)))\n mdl.add(Activation('relu'))\n\n mdl.add(Convolution2D(36, 5, 5, subsample=(2, 2), border_mode='same',))\n mdl.add(MaxPooling2D(pool_size=(2, 2)))\n mdl.add((Dropout(0.5)))\n mdl.add(Activation('relu'))\n\n mdl.add(Convolution2D(48, 5, 5, subsample=(2, 2), border_mode='same',))\n mdl.add(MaxPooling2D(pool_size=(2, 2)))\n mdl.add((Dropout(0.5)))\n mdl.add(Activation('relu'))\n\n mdl.add(Convolution2D(64, 3, 3, subsample=(1, 1), border_mode='same',))\n mdl.add((Dropout(0.5)))\n mdl.add(Activation('relu'))\n\n mdl.add(Convolution2D(64, 3, 3, subsample=(1, 1), border_mode='same',))\n mdl.add((Dropout(0.5)))\n mdl.add(Activation('relu'))\n\n mdl.add(Flatten())\n\n mdl.add(Dense(128, activation='relu'))\n mdl.add(Dense(64, activation='relu'))\n mdl.add(Dense(1, name=\"output\"))\n\n mdl.summary()\n\n return mdl","def buildDataSet():\n (x_train_origin, y_train_origin), (x_test_origin, y_test_origin) = mnist.load_data()\n\n assert K.image_data_format() == 'channels_last'\n x_train_origin = x_train_origin.reshape(x_train_origin.shape[0], h, w, 1)\n x_test_origin = x_test_origin.reshape(x_test_origin.shape[0], h, w, 1)\n\n dataset_train = []\n dataset_test = []\n\n #Sorting images by classes and normalize values 0=>1\n for n in range(nb_classes):\n images_class_n = np.asarray([row for idx,row in enumerate(x_train_origin) if y_train_origin[idx]==n])\n dataset_train.append(images_class_n/255)\n\n images_class_n = np.asarray([row for idx,row in enumerate(x_test_origin) if y_test_origin[idx]==n])\n dataset_test.append(images_class_n/255)\n\n return dataset_train,dataset_test,x_train_origin,y_train_origin,x_test_origin,y_test_origin","def test_hdf5_design_matrix():\n skip_if_no_h5py()\n import h5py\n\n # save random data to HDF5\n handle, filename = tempfile.mkstemp()\n dataset = random_one_hot_dense_design_matrix(np.random.RandomState(1),\n num_examples=10, dim=5,\n num_classes=3)\n with h5py.File(filename, 'w') as f:\n f.create_dataset('X', data=dataset.get_design_matrix())\n f.create_dataset('y', data=dataset.get_targets())\n\n # instantiate Train object\n trainer = yaml_parse.load(design_matrix_yaml % {'filename': filename})\n trainer.main_loop()\n\n # cleanup\n os.remove(filename)","def data_split():\n x_train = np.load(os.path.join(svhn.DEFAULT_PREPROCESSED_DATA_FOLDER, svhn.TRAIN, \"images.npy\"))\n y_train = np.load(os.path.join(svhn.DEFAULT_PREPROCESSED_DATA_FOLDER, svhn.TRAIN, \"label.npy\"))\n x_test = np.load(os.path.join(svhn.DEFAULT_PREPROCESSED_DATA_FOLDER, svhn.TEST, \"images.npy\"))\n y_test = np.load(os.path.join(svhn.DEFAULT_PREPROCESSED_DATA_FOLDER, svhn.TEST, \"label.npy\"))\n\n print(x_train.shape)\n print(x_test.shape)\n\n img_rows, img_cols = x_train.shape[1], x_train.shape[2]\n num_classes = 10 # starts with 1 not 0\n\n y_test1 = y_test.reshape((y_test.shape[0],))\n y_test1 = [y - 1 for y in y_test1]\n\n y_train1 = y_train.reshape((y_train.shape[0],))\n y_train1 = [y - 1 for y in y_train1]\n\n input_shape = (img_rows, img_cols, 3)\n\n X_train = x_train.astype('float32')\n X_test = x_test.astype('float32')\n\n X_train /= 255\n X_test /= 255\n print('x_train shape:', X_train.shape)\n print(X_train.shape[0], 'train samples')\n print(X_test.shape[0], 'test samples')\n\n # convert class vectors to binary class matrices\n y_train2 = keras.utils.to_categorical(y_train1, num_classes)\n y_test2 = keras.utils.to_categorical(y_test1, num_classes)\n\n y_train2 = y_train2.astype('int32')\n y_test2 = y_test2.astype('int32')\n\n print(\n \"after process: X train shape: {}, X test shape: {}, y train shape: {}, y test shape: {}\".format(x_train.shape,\n x_test.shape,\n y_train2.shape,\n y_test2.shape))\n return input_shape, X_train, X_test, y_train2, y_test2","def training_data_generation(DATA_DIR, img_height_size, img_width_size, label_list):\r\n \r\n img_ms_files = glob.glob(DATA_DIR + '\\\\Train_MS' + '\\\\Train_*.tif')\r\n img_pan_files = glob.glob(DATA_DIR + '\\\\Train_Pan' + '\\\\Train_*.tif')\r\n polygon_files = glob.glob(DATA_DIR + '\\\\Train_Polygons' + '\\\\Train_*.geojson')\r\n \r\n img_ms_array_list = []\r\n img_pan_array_list = []\r\n mask_array_list = []\r\n \r\n for file in range(len(img_ms_files)):\r\n with rasterio.open(img_ms_files[file]) as f:\r\n metadata = f.profile\r\n img_ms = np.transpose(f.read(tuple(np.arange(metadata['count']) + 1)), [1, 2, 0])\r\n \r\n with rasterio.open(img_pan_files[file]) as g:\r\n metadata_pan = g.profile\r\n img_pan = np.expand_dims(g.read(1), axis = 2)\r\n \r\n ms_to_pan_ratio = metadata['transform'][0] / metadata_pan['transform'][0]\r\n \r\n if (img_height_size % ms_to_pan_ratio) != 0 or (img_width_size % ms_to_pan_ratio) != 0:\r\n raise ValueError('Please make sure that both img_height_size and img_width_size can be divided by {}'.format(int(ms_to_pan_ratio)))\r\n \r\n mask = training_mask_generation(img_pan_files[file], polygon_files[file], labels = label_list)\r\n \r\n img_ms_array, img_pan_array, mask_array = image_clip_to_segment_and_convert(img_ms, img_pan, mask, ms_to_pan_ratio, \r\n img_height_size, img_width_size)\r\n \r\n img_ms_array_list.append(img_ms_array)\r\n img_pan_array_list.append(img_pan_array)\r\n mask_array_list.append(mask_array)\r\n \r\n img_ms_full_array = np.concatenate(img_ms_array_list, axis = 0)\r\n img_pan_full_array = np.concatenate(img_pan_array_list, axis = 0)\r\n mask_full_array = to_categorical(np.concatenate(mask_array_list, axis = 0), num_classes = len(label_list))\r\n \r\n return img_ms_full_array, img_pan_full_array, mask_full_array","def build_deepsets_joint_representation_model():\n # We first create the embedding model\n test_input = tf.keras.layers.Input(shape=(_NUM_INPUTS.value,))\n train_input = tf.keras.layers.Input(shape=(_NUM_INPUTS.value,))\n train_label = tf.keras.layers.Input(shape=(1,))\n\n # Obtain a mask variable. Output dimension [1, _NUM_INPUTS.value]\n mask = tf.ones((1, _NUM_INPUTS.value))\n one_row = tf.reshape(tf.gather(train_input, [0], axis=0), [-1])\n mask = mask * tf.cast(tf.not_equal(one_row, _PAD_VALUE.value), tf.float32)\n\n # Calibrate input if haven't done so\n calibrated_train_input = train_input\n calibrated_test_input = test_input\n calibration = tfl.layers.PWLCalibration(\n input_keypoints=np.linspace(0.0, 1.0, _NUM_CALIB_KEYS.value),\n units=_NUM_INPUTS.value,\n output_min=0.0,\n output_max=1.0,\n impute_missing=True,\n missing_input_value=_MISSING_VALUE.value,\n name=\"input_calibration\")\n calibrated_train_input = calibration(train_input)\n calibrated_test_input = calibration(test_input)\n\n # Reshape the input to pair-wise format.\n # Output dimension [_BATCH_SIZE.value, _NUM_INPUTS.value**2, 2]\n pairwise_train_input = get_pairwise_inputs(calibrated_train_input)\n pairwise_test_input = get_pairwise_inputs(calibrated_test_input)\n\n # Obtain pairwise masks. Output dimesion [_NUM_INPUTS.value**2,]\n pairwise_mask = get_pairwise_inputs(mask)\n pairwise_mask = tf.reshape(tf.reduce_prod(pairwise_mask, axis=-1), [-1])\n\n # Obtain pairwise labels.\n # Output dimension\n # [_BATCH_SIZE.value, _NUM_INPUTS.value**2, _MAX_NUM_CLASSES.value]\n one_hot_train_label = tf.one_hot(\n tf.cast(train_label, tf.int32), _MAX_NUM_CLASSES.value)\n pairwise_train_label = tf.tile(one_hot_train_label,\n tf.constant([1, _NUM_INPUTS.value**2, 1]))\n\n # Concatenate pairwise inputs and labels.\n # Output dimension\n # [_BATCH_SIZE.value, _NUM_INPUTS.value**2, _MAX_NUM_CLASSES.value + 2]\n pairwise_train_input = tf.concat([pairwise_train_input, pairwise_train_label],\n axis=-1)\n\n # Obtain distribution representation. Output dimension\n # [_BATCH_SIZE.value, _NUM_INPUTS.value**2,\n # _DISTRIBUTION_REPRESENTATION_DIM.value]\n batch_embedding = tf.keras.layers.Dense(\n _DISTRIBUTION_REPRESENTATION_DIM.value, activation=\"relu\")(\n pairwise_train_input)\n for _ in range(_HIDDEN_LAYER.value - 1):\n batch_embedding = tf.keras.layers.Dense(\n _DISTRIBUTION_REPRESENTATION_DIM.value, activation=\"relu\")(\n batch_embedding)\n\n # Average embeddings over the batch. Output dimension\n # [_NUM_INPUTS.value**2, _DISTRIBUTION_REPRESENTATION_DIM.value].\n mean_distribution_embedding = tf.reduce_mean(batch_embedding, axis=0)\n\n outputs = []\n for pairwise_input in [pairwise_test_input, pairwise_train_input]:\n # [_NUM_INPUTS.value**2, _DISTRIBUTION_REPRESENTATION_DIM.value] ->\n # [_BATCH_SIZE.value, _NUM_INPUTS.value**2,\n # _DISTRIBUTION_REPRESENTATION_DIM.value] via repetition.\n distribution_embedding = tf.tile(\n [mean_distribution_embedding],\n tf.stack([tf.shape(pairwise_input)[0],\n tf.constant(1),\n tf.constant(1)]))\n # Concatenate pairwise inputs and embeddings. Output shape\n # [_BATCH_SIZE.value, _NUM_INPUTS.value**2,\n # 2 + _DISTRIBUTION_REPRESENTATION_DIM.value]\n concat_input = tf.concat([pairwise_input, distribution_embedding], axis=-1)\n\n # Apply a common function to each pair. Output shape\n # [_BATCH_SIZE.value, _NUM_INPUTS.value**2, _DEEPSETS_LAYER_UNITS.value]\n pairwise_output = tf.keras.layers.Dense(\n _DEEPSETS_LAYER_UNITS.value, activation=\"relu\")(\n concat_input)\n for _ in range(_HIDDEN_LAYER.value - 1):\n pairwise_output = tf.keras.layers.Dense(\n _DEEPSETS_LAYER_UNITS.value, activation=\"relu\")(\n pairwise_output)\n\n # Average pair-wise outputs across valid pairs.\n # Output shape [_BATCH_SIZE.value, _DEEPSETS_LAYER_UNITS.value]\n average_outputs = tf.tensordot(pairwise_mask, pairwise_output, [[0], [1]])\n average_outputs = average_outputs / tf.reduce_sum(pairwise_mask)\n\n # Use several dense layers to get the final output\n final_output = tf.keras.layers.Dense(\n _OUTPUT_LAYER_UNITS.value, activation=\"relu\")(\n average_outputs)\n for i in range(_HIDDEN_LAYER.value - 1):\n final_output = tf.keras.layers.Dense(\n _OUTPUT_LAYER_UNITS.value, activation=\"relu\")(\n final_output)\n outputs.append(final_output)\n\n test_outputs = tf.math.l2_normalize(outputs[0], axis=1)\n train_outputs = tf.math.l2_normalize(outputs[1], axis=1)\n similarity_matrix = tf.exp(\n tf.matmul(test_outputs, tf.transpose(train_outputs)))\n\n similarity_list = []\n for i in range(_MAX_NUM_CLASSES.value):\n mask = tf.cast(tf.squeeze(tf.equal(train_label, i)), tf.float32)\n similarity_list.append(similarity_matrix * mask)\n\n similarity = [\n tf.reduce_mean(s, axis=1, keepdims=True) for s in similarity_list\n ]\n sum_similarity = tf.reduce_sum(\n tf.concat(similarity, axis=1), axis=1, keepdims=True)\n final_output = [similarity / sum_similarity for similarity in similarity_list]\n final_output = tf.concat(final_output, axis=1)\n\n keras_model = tf.keras.models.Model(\n inputs=[test_input, train_input, train_label], outputs=final_output)\n compile_keras_model(keras_model)\n return keras_model","def create_training_matrices(experiment, sample_times):\n # Labels:\n location_labels = read_location_labels(experiment)\n locations = get_location_of_persons_at_samples(location_labels, sample_times, experiment)\n\n p1_scene_features = read_roi_scene_recognitions_for_person(experiment, \"P1\")\n p2_scene_features = read_roi_scene_recognitions_for_person(experiment, \"P2\")\n p3_scene_features = read_roi_scene_recognitions_for_person(experiment, \"P3\")\n p4_scene_features = read_roi_scene_recognitions_for_person(experiment, \"P4\")\n\n print(p1_scene_features.loc[0]['predictions'].shape[0])\n print(len(p1_scene_features['predictions'][0]))\n data = {\n \"P1\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\n \"P2\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\n \"P3\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\n \"P4\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0]))\n }\n\n for index, loc_label in enumerate(locations):\n t = loc_label[0]\n\n t_et = convert_timestamps(exp_root, t, \"video\", \"P1_eyetracker\")\n p1 = np.mean(p1_scene_features[p1_scene_features['timestamp'].between(t_et - sample_step/2, t_et + sample_step/2)]['predictions'].as_matrix(), axis=0)\n\n\n t_et = convert_timestamps(exp_root, t, \"video\", \"P2_eyetracker\")\n p2 = np.mean(\n p2_scene_features[p2_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\n 'predictions'].as_matrix(), axis=0)\n\n t_et = convert_timestamps(exp_root, t, \"video\", \"P3_eyetracker\")\n p3 = np.mean(\n p3_scene_features[p3_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\n 'predictions'].as_matrix(), axis=0)\n\n t_et = convert_timestamps(exp_root, t, \"video\", \"P4_eyetracker\")\n p4 = np.mean(\n p4_scene_features[p4_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\n 'predictions'].as_matrix(), axis=0)\n\n data[\"P1\"][index, 0] = t\n data[\"P1\"][index, 1:-1] = p1\n data[\"P1\"][index, -1] = loc_label[1]\n\n data[\"P2\"][index, 0] = t\n data[\"P2\"][index, 1:-1] = p2\n data[\"P2\"][index, -1] = loc_label[2]\n\n data[\"P3\"][index, 0] = t\n data[\"P3\"][index, 1:-1] = p3\n data[\"P3\"][index, -1] = loc_label[3]\n\n data[\"P4\"][index, 0] = t\n data[\"P4\"][index, 1:-1] = p4\n data[\"P4\"][index, -1] = loc_label[4]\n\n return data","def get_ky_mat_pack(hyps: np.ndarray, name: str,\n s1: int, e1: int, s2: int, e2: int,\n same: bool, kernel, cutoffs, hyps_mask):\n\n\n # initialize matrices\n training_data = _global_training_data[name]\n size1 = (e1-s1)*3\n size2 = (e2-s2)*3\n k_mat = np.zeros([size1, size2])\n\n ds = [1, 2, 3]\n\n # calculate elements\n args = from_mask_to_args(hyps, hyps_mask, cutoffs)\n\n for m_index in range(size1):\n x_1 = training_data[int(math.floor(m_index / 3))+s1]\n d_1 = ds[m_index % 3]\n if (same):\n lowbound = m_index\n else:\n lowbound = 0\n for n_index in range(lowbound, size2):\n x_2 = training_data[int(math.floor(n_index / 3))+s2]\n d_2 = ds[n_index % 3]\n kern_curr = kernel(x_1, x_2, d_1, d_2, *args)\n # store kernel value\n k_mat[m_index, n_index] = kern_curr\n if (same):\n k_mat[n_index, m_index] = kern_curr\n\n return k_mat","def prepare_metadata(devkit_archive, test_groundtruth_path):\n # Read what's necessary from the development kit.\n synsets, cost_matrix, raw_valid_groundtruth = read_devkit(devkit_archive)\n\n # Mapping to take WordNet IDs to our internal 0-999 encoding.\n wnid_map = dict(zip((s.decode('utf8') for s in synsets['WNID']),\n xrange(1000)))\n\n # Map the 'ILSVRC2010 ID' to our zero-based ID.\n ilsvrc_id_to_zero_based = dict(zip(synsets['ILSVRC2010_ID'],\n xrange(len(synsets))))\n\n # Map the validation set groundtruth to 0-999 labels.\n valid_groundtruth = [ilsvrc_id_to_zero_based[id_]\n for id_ in raw_valid_groundtruth]\n\n # Raw test data groundtruth, ILSVRC2010 IDs.\n raw_test_groundtruth = numpy.loadtxt(test_groundtruth_path,\n dtype=numpy.int16)\n\n # Map the test set groundtruth to 0-999 labels.\n test_groundtruth = [ilsvrc_id_to_zero_based[id_]\n for id_ in raw_test_groundtruth]\n\n # Ascertain the number of filenames to prepare appropriate sized\n # arrays.\n n_train = int(synsets['num_train_images'].sum())\n log.info('Training set: {} images'.format(n_train))\n log.info('Validation set: {} images'.format(len(valid_groundtruth)))\n log.info('Test set: {} images'.format(len(test_groundtruth)))\n n_total = n_train + len(valid_groundtruth) + len(test_groundtruth)\n log.info('Total (train/valid/test): {} images'.format(n_total))\n return n_train, valid_groundtruth, test_groundtruth, wnid_map","def create_dataset(img_rows=128, img_cols=128):\n print('Creating original dataset from the raw data')\n # first, get the patients directory names located in the data/ directory. These names (e.g. 'patient0001') will\n # be used for indexing (also avoid hidden files & folders)\n patients = [name for name in os.listdir(os.path.join(os.curdir, 'data/')) if not name.startswith('.')]\n\n # We sort this list to get the patients id in increasing order\n patients.sort(key=lambda s: s[-3:]) # sort according to last 3 characters\n\n # create an empty numpy.ndarray which will contain the images (resized to (img_rows, img_cols))\n images = np.ndarray((2 * len(patients), img_rows, img_cols), dtype=np.uint8) # 2 images per patient\n masks = np.ndarray((2 * len(patients), img_rows, img_cols), dtype=np.uint8) # 2 masks per patient\n\n # we now go through each patient's directory :\n idx = 0\n for patient in patients:\n\n for phase in ['ED', 'ES']:\n\n # read image & mask\n img, _, _, _ = load_mhd_data('data/{pa}/{pa}_4CH_{ph}.mhd'.format(pa=patient, ph=phase))\n mask, _, _, _ = load_mhd_data('data/{pa}/{pa}_4CH_{ph}_gt.mhd'.format(pa=patient, ph=phase))\n\n # resize the img & the mask to (img_rows, img_cols) to keep the network input manageable\n img = resize(img, (img_cols, img_rows), mode='reflect', preserve_range=True)\n mask = resize(mask, (img_cols, img_rows), mode='reflect', preserve_range=True)\n\n # now, save the resized image to the images np.ndarray\n images[idx] = img\n\n # save the corresponding mask to masks np.ndarray (at the same index)\n masks[idx] = mask\n\n idx += 1\n\n print('Created 2 np.ndarrays containing images & masks.')\n\n # Create directory to store files.\n directory = os.path.join(os.getcwd(), 'output/processed_data/')\n if not os.path.exists(directory):\n os.makedirs(directory)\n\n # save all ndarrays to a .npy files (for faster loading later)\n np.save('output/processed_data/images.npy', images)\n np.save('output/processed_data/masks.npy', masks)\n print('Saving to .npy files done: see files\\noutput/processed_data/images.npy & \\noutput/processed_data/masks.npy.')","def _generate_dataset(self):\n # create train images\n train_path = os.path.join(self.root_dir, \"shapes\", \"train\", \"good\")\n os.makedirs(train_path, exist_ok=True)\n for i in range(self.num_train):\n result = generate_random_anomaly_image(\n image_width=self.image_width,\n image_height=self.image_height,\n shapes=self.train_shapes,\n generate_mask=False,\n )\n image = result[\"image\"]\n imsave(os.path.join(train_path, f\"{i:03}.png\"), image, check_contrast=False)\n\n # create test images\n for test_category in self.test_shapes:\n test_path = os.path.join(self.root_dir, \"shapes\", \"test\", test_category)\n mask_path = os.path.join(self.root_dir, \"shapes\", \"ground_truth\", test_category)\n os.makedirs(test_path, exist_ok=True)\n os.makedirs(mask_path, exist_ok=True)\n # anomaly and masks. The idea is to superimpose anomalous shapes on top of correct ones\n for i in range(self.num_test):\n correct_shapes = generate_random_anomaly_image(\n image_width=self.image_width,\n image_height=self.image_height,\n shapes=self.train_shapes,\n generate_mask=False,\n )\n result = generate_random_anomaly_image(\n image_width=self.image_width,\n image_height=self.image_height,\n shapes=[test_category],\n generate_mask=True,\n )\n correct_shapes = correct_shapes[\"image\"]\n image, mask = result[\"image\"], result[\"mask\"]\n image = np.minimum(image, correct_shapes) # since 255 is white\n imsave(os.path.join(test_path, f\"{i:03}.png\"), image, check_contrast=False)\n imsave(os.path.join(mask_path, f\"{i:03}_mask.png\"), mask, check_contrast=False)\n # good test\n test_good = os.path.join(self.root_dir, \"shapes\", \"test\", \"good\")\n os.makedirs(test_good, exist_ok=True)\n for i in range(self.num_test):\n result = generate_random_anomaly_image(\n image_width=self.image_width,\n image_height=self.image_height,\n shapes=self.train_shapes,\n )\n image = result[\"image\"]\n imsave(os.path.join(test_good, f\"{i:03}.png\"), image, check_contrast=False)","def GetDataset():\n x_train = []\n x_test = []\n y_train = []\n y_test = []\n\n classes1 = set()\n classes2 = set()\n for f in GetInputFiles():\n class1, class2, fold, fname = f.split('\\\\')[-4:]\n classes1.add(class1)\n classes2.add(class2)\n class1 = class1.split('_')[0]\n class2 = class2.split('_')[0]\n\n x = ReadAndTokenize(f)\n y = [int(class1 == 'positive'), int(class2 == 'truthful')]\n if fold == 'fold4':\n x_test.append(x)\n y_test.append(y)\n else:\n x_train.append(x)\n y_train.append(y)\n\n ### Make numpy arrays.\n x_test = MakeDesignMatrix(x_test)\n x_train = MakeDesignMatrix(x_train)\n y_test = numpy.array(y_test, dtype='float32')\n y_train = numpy.array(y_train, dtype='float32')\n\n dataset = (x_train, y_train, x_test, y_test)\n with open('dataset.pkl', 'wb') as fout:\n pickle.dump(dataset, fout)\n return dataset","def preprocessing(train_raw_, test_raw_):\n \n undef = np.float64(-999.0)\n pred_dict = {'s':'1','b':'0', '?':'-1'}\n # drop 1st column (Id) and also 1st row with column names (\"[1:,\") \n train_raw = train_raw_[1:, :]\n test_raw = test_raw_[1:, :] \n \n # Change s(signal) and b(background) for s:1 and b:0, and change '?' for -1\n train_raw[:,1] = np.vectorize(pred_dict.get)(train_raw[:,1].astype(str))\n test_raw[:,1] = np.vectorize(pred_dict.get)(test_raw[:,1].astype(str))\n \n # Divide the dataset in four according to PRI_jet_num feature and cast to float\n train_data_jets = divide_dataset_by_jet(train_raw)\n test_data_jets = divide_dataset_by_jet(test_raw)\n \n # Remove columns with nan values or with standard deviation of 0\n test_data_jets, train_data_jets = clean_features(test_data_jets, train_data_jets, undef)\n \n # Standardize train and test sets to have mean=0 and std=1\n train_data_jets, test_data_jets = standardize(train_data_jets, test_data_jets)\n \n # Replace remaining undefined values by mean, median or zero\n train_data_mean, train_data_median, train_data_null = replace_nan(train_data_jets)\n test_data_mean, test_data_median, test_data_null = replace_nan(test_data_jets)\n \n return train_data_mean, train_data_median, train_data_null, test_data_mean, test_data_median, test_data_null","def load_data():\r\n train_dataset = h5py.File('train_catvnoncat.h5', \"r\") # Change the directory as per your system\r\n train_set_x_orig = np.array(train_dataset[\"train_set_x\"][:]) # your train set features\r\n train_set_y_orig = np.array(train_dataset[\"train_set_y\"][:]) # your train set labels\r\n\r\n test_dataset = h5py.File('test_catvnoncat.h5', \"r\") # Change the directory as per your system\r\n test_set_x_orig = np.array(test_dataset[\"test_set_x\"][:]) # your test set features\r\n test_set_y_orig = np.array(test_dataset[\"test_set_y\"][:]) # your test set labels\r\n\r\n classes = np.array(test_dataset[\"list_classes\"][:]) # the list of classes\r\n \r\n train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\r\n test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\r\n \r\n return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes","def create_GT_masks(root_dir, background_dir, intrinsic_matrix,classes):\n list_all_images = load_obj(root_dir + \"all_images_adr\")\n training_images_idx = load_obj(root_dir + \"train_images_indices\")\n for i in range(len(training_images_idx)):\n img_adr = list_all_images[training_images_idx[i]]\n label = os.path.split(os.path.split(os.path.dirname(img_adr))[0])[1]\n regex = re.compile(r'\\d+')\n idx = regex.findall(os.path.split(img_adr)[1])[0]\n\n if i % 1000 == 0:\n print(str(i) + \"/\" + str(len(training_images_idx)) + \" finished!\")\n\n image = cv2.imread(img_adr)\n ID_mask = np.zeros((image.shape[0], image.shape[1]))\n U_mask = np.zeros((image.shape[0], image.shape[1]))\n V_mask = np.zeros((image.shape[0], image.shape[1]))\n\n ID_mask_file = root_dir + label + \\\n \"/ground_truth/IDmasks/color\" + str(idx) + \".png\"\n U_mask_file = root_dir + label + \\\n \"/ground_truth/Umasks/color\" + str(idx) + \".png\"\n V_mask_file = root_dir + label + \\\n \"/ground_truth/Vmasks/color\" + str(idx) + \".png\"\n\n tra_adr = root_dir + label + \"/data/tra\" + str(idx) + \".tra\"\n rot_adr = root_dir + label + \"/data/rot\" + str(idx) + \".rot\"\n rigid_transformation = get_rot_tra(rot_adr, tra_adr)\n\n # Read point Point Cloud Data\n ptcld_file = root_dir + label + \"/object.xyz\"\n pt_cld_data = np.loadtxt(ptcld_file, skiprows=1, usecols=(0, 1, 2))\n ones = np.ones((pt_cld_data.shape[0], 1))\n homogenous_coordinate = np.append(pt_cld_data[:, :3], ones, axis=1)\n\n # Perspective Projection to obtain 2D coordinates for masks\n homogenous_2D = intrinsic_matrix @ (rigid_transformation @ homogenous_coordinate.T)\n coord_2D = homogenous_2D[:2, :] / homogenous_2D[2, :]\n coord_2D = ((np.floor(coord_2D)).T).astype(int)\n x_2d = np.clip(coord_2D[:, 0], 0, 639)\n y_2d = np.clip(coord_2D[:, 1], 0, 479)\n ID_mask[y_2d, x_2d] = classes[label]\n\n if i % 100 != 0: # change background for every 99/100 images\n background_img_adr = background_dir + random.choice(os.listdir(background_dir))\n background_img = cv2.imread(background_img_adr)\n background_img = cv2.resize(background_img, (image.shape[1], image.shape[0]), interpolation=cv2.INTER_AREA)\n background_img[y_2d, x_2d, :] = image[y_2d, x_2d, :]\n background_adr = root_dir + label + \"/changed_background/color\" + str(idx) + \".png\"\n mpimg.imsave(background_adr, background_img)\n\n # Generate Ground Truth UV Maps\n centre = np.mean(pt_cld_data, axis=0)\n length = np.sqrt((centre[0]-pt_cld_data[:, 0])**2 + (centre[1] -\n pt_cld_data[:, 1])**2 + (centre[2]-pt_cld_data[:, 2])**2)\n unit_vector = [(pt_cld_data[:, 0]-centre[0])/length, (pt_cld_data[:,\n 1]-centre[1])/length, (pt_cld_data[:, 2]-centre[2])/length]\n U = 0.5 + (np.arctan2(unit_vector[2], unit_vector[0])/(2*np.pi))\n V = 0.5 - (np.arcsin(unit_vector[1])/np.pi)\n U_mask[y_2d, x_2d] = U\n V_mask[y_2d, x_2d] = V\n\n # Saving ID, U and V masks after using the fill holes function\n ID_mask, U_mask, V_mask = fill_holes(ID_mask, U_mask, V_mask)\n cv2.imwrite(ID_mask_file, ID_mask)\n mpimg.imsave(U_mask_file, U_mask, cmap='gray')\n mpimg.imsave(V_mask_file, V_mask, cmap='gray')","def setUp(self):\n output = np.zeros((1, 5, 2))\n target = np.zeros((1, 5, 2))\n # first channel\n output[0, 0] = [10, 4]\n target[0, 0] = [10, 0]\n # second channel\n output[0, 1] = [10, 18]\n target[0, 1] = [10, 10]\n # third channel\n output[0, 2] = [0, 0]\n target[0, 2] = [0, -1]\n # fourth channel\n output[0, 3] = [40, 40]\n target[0, 3] = [30, 30]\n # fifth channel\n output[0, 4] = [20, 10]\n target[0, 4] = [0, 10]\n\n gt_instances = InstanceData()\n gt_instances.keypoints = target\n gt_instances.keypoints_visible = np.array(\n [[True, True, False, True, True]])\n\n pred_instances = InstanceData()\n pred_instances.keypoints = output\n\n data = {'inputs': None}\n data_sample = {\n 'gt_instances': gt_instances.to_dict(),\n 'pred_instances': pred_instances.to_dict()\n }\n\n self.data_batch = [data]\n self.data_samples = [data_sample]","def train():\n\n # Load camera parameters\n rcams = cameras.load_cameras()\n\n # Load 3d data and 2d projections\n full_train_set_3d, full_test_set_3d, data_mean_3d, data_std_3d, dim_to_ignore_3d, dim_to_use_3d =\\\n data_utils.read_3d_data( FLAGS.camera_frame, rcams, FLAGS.origin_bc, FLAGS.augment_data,\n FLAGS.procrustes, FLAGS.lowpass )\n \n # Read stacked hourglass 2D predictions\n full_train_set_2d, full_test_set_2d, data_mean_2d, data_std_2d, dim_to_ignore_2d, dim_to_use_2d = \\\n data_utils.read_2d_predictions( FLAGS.origin_bc, FLAGS.augment_data )\n \n print(\"\\n[+] done reading and normalizing data\")\n # Getting the number of training and test subjects\n tr_subj = 0\n for v in full_train_set_3d.values():\n tr_subj += v.shape[0]\n te_subj = 0\n for v in full_test_set_3d.values():\n te_subj += v.shape[0]\n print(\"{0} training subjects, {1} test subjects\".format(tr_subj, te_subj))\n print(dim_to_use_2d)\n print(dim_to_use_3d)\n # Un-normalizing data for visualizations\n unNorm_ftrs2d = data_utils.unNormalize_dic(full_train_set_2d, data_mean_2d, data_std_2d, dim_to_use_2d)\n unNorm_ftrs3d = data_utils.unNormalize_dic(full_train_set_3d, data_mean_3d, data_std_3d, dim_to_use_3d)\n unNorm_ftes3d = data_utils.unNormalize_dic(full_test_set_3d, data_mean_3d, data_std_3d, dim_to_use_3d)\n # Visualize the data\n viz.visualize_train_sample(unNorm_ftrs2d, unNorm_ftrs3d, FLAGS.camera_frame)\n viz.visualize_files_oneatatime(unNorm_ftrs3d, unNorm_ftes3d)\n\n # Getting only the dimensions to use (get rid of body coxas, other limb, antennas, abdomen\n train_set_3d, train_set_2d, test_set_3d, test_set_2d = {}, {}, {}, {}\n for k in full_train_set_3d:\n (f, c) = k\n train_set_3d[k] = full_train_set_3d[k][:, dim_to_use_3d]\n train_set_2d[(f, data_utils.CAMERA_TO_USE)] =\\\n full_train_set_2d[(f, data_utils.CAMERA_TO_USE)][:, dim_to_use_2d]\n for k in full_test_set_3d:\n (f, c) = k\n test_set_3d[k] = full_test_set_3d[k][:, dim_to_use_3d]\n test_set_2d[(f, data_utils.CAMERA_TO_USE)] =\\\n full_test_set_2d[(f, data_utils.CAMERA_TO_USE)][:, dim_to_use_2d]\n \n print(\"3D data mean:\")\n print(data_mean_3d)\n print(\"3D data std:\")\n print(data_std_3d)\n\n print(\"2D data mean:\")\n print(data_mean_2d)\n print(\"2D data std:\")\n print(data_std_2d)\n \n input(\"Press Enter to continue...\")\n\n # Avoid using the GPU if requested\n device_count = {\"GPU\": 0} if FLAGS.use_cpu else {\"GPU\": 1}\n with tf.compat.v1.Session(config=tf.compat.v1.ConfigProto(\n device_count=device_count,\n allow_soft_placement=True )) as sess:\n\n # === Create the model ===\n print(\"[*] creating %d bi-layers of %d units.\" % (FLAGS.num_layers, FLAGS.linear_size))\n model = create_model( sess, FLAGS.batch_size )\n model.train_writer.add_graph( sess.graph )\n print(\"[+] model created\")\n \n #=== This is the training loop ===\n step_time, loss, val_loss = 0.0, 0.0, 0.0\n current_step = 0 if FLAGS.load <= 0 else FLAGS.load + 1\n previous_losses = []\n\n step_time, loss = 0, 0\n current_epoch = 0\n log_every_n_batches = 100\n losses, errors, joint_errors = [], [], []\n for _ in range( FLAGS.epochs ):\n current_epoch = current_epoch + 1\n\n # === Load training batches for one epoch ===\n encoder_inputs, decoder_outputs =\\\n model.get_all_batches( train_set_2d, train_set_3d, FLAGS.camera_frame, training=True )\n nbatches = len( encoder_inputs )\n print(\"[*] there are {0} train batches\".format( nbatches ))\n start_time, loss = time.time(), 0.\n # === Loop through all the training batches ===\n for i in range( nbatches ):\n\n if (i+1) % log_every_n_batches == 0:\n # Print progress every log_every_n_batches batches\n print(\"Working on epoch {0}, batch {1} / {2}...\".format( current_epoch, i+1, nbatches),end=\"\" )\n\n enc_in, dec_out = encoder_inputs[i], decoder_outputs[i]\n step_loss, loss_summary, lr_summary, _ =\\\n model.step( sess, enc_in, dec_out, FLAGS.dropout, isTraining=True )\n\n if (i+1) % log_every_n_batches == 0:\n # Log and print progress every log_every_n_batches batchespixels = pixels / pixels[2,:]\n model.train_writer.add_summary( loss_summary, current_step )\n model.train_writer.add_summary( lr_summary, current_step )\n step_time = (time.time() - start_time)\n start_time = time.time()\n print(\"done in {0:.2f} ms\".format( 1000*step_time / log_every_n_batches ) )\n\n loss += step_loss\n current_step += 1\n # === end looping through training batches ===\n\n loss = loss / nbatches\n losses.append(loss)\n print(\"=============================\\n\"\n \"Global step: %d\\n\"\n \"Learning rate: %.2e\\n\"\n \"Train loss avg: %.4f\\n\"\n \"=============================\" % (model.global_step.eval(),\n model.learning_rate.eval(), loss) )\n # === End training for an epoch ===\n\n # === Testing after this epoch ===\n isTraining = False\n \n n_joints = len(data_utils.DIMENSIONS_TO_USE)\n if FLAGS.origin_bc:\n n_joints -= len(data_utils.ROOT_POSITIONS)\n\n encoder_inputs, decoder_outputs =\\\n model.get_all_batches( test_set_2d, test_set_3d, FLAGS.camera_frame, training=False)\n\n total_err, coordwise_err, joint_err, step_time, loss = evaluate_batches( sess, model,\n data_mean_3d, data_std_3d, dim_to_use_3d, dim_to_ignore_3d,\n data_mean_2d, data_std_2d, dim_to_use_2d, dim_to_ignore_2d,\n current_step, encoder_inputs, decoder_outputs, current_epoch )\n\n print(\"=============================\\n\"\n \"Step-time (ms): %.4f\\n\"\n \"Val loss avg: %.4f\\n\"\n \"Val error avg (mm): %.2f (%.2f, %.2f, %.2f)\\n\"\n \"=============================\" % ( 1000*step_time, loss, total_err,\n coordwise_err[0], coordwise_err[1], coordwise_err[2] ))\n\n for i in range(n_joints):\n # 6 spaces, right-aligned, 5 decimal places\n print(\"Error in joint {0:02d} (mm): {1:>5.2f}\".format(i+1, joint_err[i]))\n print(\"=============================\")\n errors.append(coordwise_err)\n joint_errors.append(joint_err)\n # Log the error to tensorboard\n summaries = sess.run( model.err_mm_summary, {model.err_mm: total_err} )\n model.test_writer.add_summary( summaries, current_step )\n\n # Save the model\n print( \"Saving the model... \", end=\"\" )\n start_time = time.time()\n model.saver.save(sess, os.path.join(train_dir, 'checkpoint'), global_step=current_step )\n print( \"done in {0:.2f} ms\".format(1000*(time.time() - start_time)) )\n\n # Reset global time and loss\n step_time, loss = 0, 0\n\n sys.stdout.flush()\n # Save losses for future plots\n def print_list_tofile(l, filename):\n with open(filename, 'wb') as f:\n pickle.dump(l, f)\n print_list_tofile(losses, train_dir+\"/losses.pkl\")\n print_list_tofile(errors, train_dir+\"/errors.pkl\")\n print_list_tofile(joint_errors, train_dir+\"/joint_errors.pkl\")","def load_dataset():\n\n train_dataset = h5py.File('datasets/train_catvnoncat.h5', \"r\")\n train_set_x_orig = np.array(train_dataset[\"train_set_x\"][:]) # your train set features\n train_set_y_orig = np.array(train_dataset[\"train_set_y\"][:]) # your train set labels\n\n test_dataset = h5py.File('datasets/test_catvnoncat.h5', \"r\")\n test_set_x_orig = np.array(test_dataset[\"test_set_x\"][:]) # your test set features\n test_set_y_orig = np.array(test_dataset[\"test_set_y\"][:]) # your test set labels\n\n classes = np.array(test_dataset[\"list_classes\"][:]) # the list of classes\n \n train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\n test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\n \n return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes","def main(seed, filter_, num_classes, setup, model_name, images_dir, precision_mode, test):\n f1, f2 = filter_\n model_name = 'flex_random_seed_{}_resnet_manual_highres_center_only_f1_{}_f2_{}'.format(seed, f1, f2)\n frozen_graph_filepath = './Models/Frozen_graphs/{}_{}/'.format(f1,f2) + model_name + '_frozen_graph.pb'\n frozen_graph, x_tensor, y_tensor = trt_frozen_graph_and_tensors(\n model_name=model_name, \n frozen_graph_filepath=frozen_graph_filepath, \n precision_mode=precision_mode\n )\n\n elapsed_time_full_dataset = []\n sum_of_confusion_matrices = np.zeros((6, 6))\n \n with tf.compat.v1.Session(graph=frozen_graph) as sess:\n for image_file in [img for img in os.listdir(images_dir) if img.endswith('.JPG')]:\n\n img = Image.open(images_dir + image_file)\n sx,sy = img.size\n\n print(\"Image size is %i x %i\" % (sx,sy)) # sx = 4912, sy = 3264\n print(\"Loading image %s\" % image_file)\n\n img_np = np.array(img)/255.0\n del img\n\n print(\"Predicting for image %s (%i x %i pixel)\" % (image_file,sx,sy))\n\n start = time.time()\n predictions_flex = sess.run(y_tensor, feed_dict={x_tensor:np.expand_dims(img_np, 0)})\n elapsed = time.time() - start\n elapsed_time_full_dataset.append(elapsed)\n del img_np #deleting afterwards to not take the deleting time into account\n\n print(\"Prediction took %f seconds (inference on full image)\" % elapsed)\n print(\"Merging predictions\")\n # merge the predictions on the quarter images\n predictions_flex_combined = np.zeros(predictions_flex.shape)\n\n elapsed = time.time()-start\n if embedded_version:\n print(\"Prediction took %f seconds (inference on split up image)\" % elapsed)\n\n if embedded_version:\n predictions_flex = predictions_flex_combined\n\n if save_annotations:\n print(\"Computing annotations...\")\n annotations = []\n d = 4\n for x in range(100, sx-101, d):\n for y in range(100, sy-101, d):\n x0 = int(round(float(x-100)/4) + 15)\n y0 = int(round(float(y-100)/4) + 15)\n probs_flex = np.squeeze(predictions_flex[0, y0, x0, :])\n annotations.append((probs_flex, x, y))\n\n if test: # add a prefix for test to not replace real experiments\n model_name = 'TEST_' + model_name\n\n # saving annotations\n annotation_dir = images_dir.replace('Data', 'Results/seeds/annotations_trt') + image_file\n annotate_and_save(annotations, d, annotation_dir, model_name, precision_mode)\n classes_image = annotate_and_save_per_class(\n annotations, \n d, \n annotation_dir, \n model_name, \n precision_mode\n )\n\n labels = load_labels(annotation_dir)\n confusion_matrix = np.zeros((num_classes, num_classes))\n for (c_name, x, y) in labels:\n if 100 <= x < sx-101 and 100 <= y < sy-101:\n x0 = int(round(float(x-100)/4) + 15 )\n y0 = int(round(float(y-100)/4) + 15)\n probs_flex = np.squeeze(predictions_flex[0, y0, x0, :])\n\n predicted_class = np.argmax(probs_flex)\n c = train_model.get_classes().index(c_name)\n confusion_matrix[c, predicted_class] += 1\n print(confusion_matrix)\n sum_of_confusion_matrices += confusion_matrix\n\n print(sum_of_confusion_matrices)\n sum_of_cm_fp = './Results/seeds/preds_trt/{}/{}_{}/sum_of_cm_'\\\n .format(precision_mode.lower(), f1,f2) + model_name + '_fp32.npy'\n elapsed_time_fp = './Results/seeds/elapsed_trt/{}/{}_{}/time_taken_'\\\n .format(precision_mode.lower(), f1,f2) + model_name + '_fp32.npy'\n\n\n np.save(sum_of_cm_fp, sum_of_confusion_matrices)\n np.save(elapsed_time_fp, elapsed_time_full_dataset)\n tf.reset_default_graph()","def process_dataset(self):\n\n logger.info('\\n')\n logger.info('=' * 40)\n logger.info('=\\t DeepRank Data Set')\n logger.info('=')\n logger.info('=\\t Training data')\n for f in self.train_database:\n logger.info(f'=\\t -> {f}')\n logger.info('=')\n if self.valid_database:\n logger.info('=\\t Validation data')\n for f in self.valid_database:\n logger.info(f'=\\t -> {f}')\n logger.info('=')\n if self.test_database:\n logger.info('=\\t Test data')\n for f in self.test_database:\n logger.info(f'=\\t -> {f}')\n logger.info('=')\n logger.info('=' * 40 + '\\n')\n sys.stdout.flush()\n\n # check if the files are ok\n self.check_hdf5_files(self.train_database)\n\n if self.valid_database:\n self.valid_database = self.check_hdf5_files(\n self.valid_database)\n\n if self.test_database:\n self.test_database = self.check_hdf5_files(\n self.test_database)\n\n # create the indexing system\n # alows to associate each mol to an index\n # and get fname and mol name from the index\n self.create_index_molecules()\n\n # get the actual feature name\n if self.mapfly:\n self.get_raw_feature_name()\n else:\n self.get_mapped_feature_name()\n\n # get the pairing\n self.get_pairing_feature()\n\n # get grid shape\n self.get_grid_shape()\n\n # get the input shape\n self.get_input_shape()\n\n # get renormalization factor\n if self.normalize_features or self.normalize_targets or self.clip_features:\n if self.mapfly:\n self.compute_norm()\n else:\n self.get_norm()\n\n logger.info('\\n')\n logger.info(\" Data Set Info:\")\n logger.info(\n f' Augmentation : {self.use_rotation} rotations')\n logger.info(\n f' Training set : {self.ntrain} conformations')\n logger.info(\n f' Validation set : {self.nvalid} conformations')\n logger.info(\n f' Test set : {self.ntest} conformations')\n logger.info(f' Number of channels : {self.input_shape[0]}')\n logger.info(f' Grid Size : {self.data_shape[1]}, '\n f'{self.data_shape[2]}, {self.data_shape[3]}')\n sys.stdout.flush()","def build_model(input_classes,output_classes):\n dimensions = 20\n inputs = []\n embedded_outputs = []\n for i in input_classes:\n input_layer = Input((1,))\n inputs.append(input_layer)\n embedder = Embedding(input_dim=i,output_dim=dimensions,input_length=1,embeddings_constraint=UnitNorm(axis=0))\n embedded_layer = embedder(input_layer)\n embedded_outputs.append(embedded_layer)\n\n embedded_concats = Concatenate()(embedded_outputs)\n flatten_layer = Flatten()\n\n dense_layer = Dense(output_classes)\n\n flattened_output = flatten_layer(embedded_concats)\n dense_output = dense_layer(flattened_output)\n\n # dense_output = dense_layer(embedded_concats)\n\n model = Model(inputs,dense_output)\n print(model.summary())\n model.compile(loss='sparse_categorical_crossentropy', optimizer='adam')\n\n return model","def classify_lenet5(batch_size=500, output_size=20):\n\n rng = numpy.random.RandomState(23455)\n\n\n # start-snippet-1\n x = T.matrix('x') # the data is presented as rasterized images\n ######################\n # BUILD ACTUAL MODEL #\n ######################\n print '... building the model'\n\n # Reshape matrix of rasterized images of shape (batch_size, 28 * 28)\n # to a 4D tensor, compatible with our LeNetConvPoolLayer\n # (28, 28) is the size of MNIST images.\n layer0_input = x.reshape((batch_size, 1, 37, 23))\n\n # Construct the first convolutional pooling layer:\n # filtering reduces the image size to (28-5+1 , 28-5+1) = (24, 24)\n # maxpooling reduces this further to (24/2, 24/2) = (12, 12)\n # 4D output tensor is thus of shape (batch_size, nkerns[0], 12, 12)\n layer0 = LeNetConvPoolLayer(\n rng,\n input=layer0_input,\n image_shape=(batch_size, 1, 37, 23),\n filter_shape=(20, 1, 4, 2),\n poolsize=(2, 2),\n )\n\n # layer1 = LeNetConvPoolLayer(\n # rng,\n # input=layer0.output,\n # image_shape=(batch_size, 20, 17, 11),\n # filter_shape=(50, 20, 4, 2),\n # poolsize=(2, 2),\n # )\n #\n # layer4 = LeNetConvPoolLayer(\n # rng,\n # input=layer1.output,\n # image_shape=(batch_size, 50, 7, 5),\n # filter_shape=(100, 50, 4, 2),\n # poolsize=(2, 2),\n # )\n\n layer2_input = layer0.output.flatten(2)\n\n # construct a fully-connected sigmoidal layer\n layer2 = HiddenLayer(\n rng,\n input=layer2_input,\n n_in=3740,\n n_out=output_size,\n activation=T.tanh,\n use_bias=True\n )\n\n # layer5 = HiddenLayer(\n # rng,\n # input=layer2.output,\n # n_in=200,\n # n_out=output_size,\n # activation=T.tanh,\n # use_bias=True\n # )\n\n # classify the values of the fully-connected sigmoidal layer\n layer3 = LogisticRegression(input=layer2.output, n_in=output_size, n_out=2)\n\n model_params = pickle.load(open('../model/cnn_dist_'+str(output_size)+'.pkl'))\n #\n layer0.W = theano.shared(\n value=numpy.array(\n model_params[2].get_value(True),\n dtype=theano.config.floatX\n ),\n name='W',\n borrow=True\n )\n\n layer0.b = theano.shared(\n value=numpy.array(\n model_params[3].get_value(True),\n dtype=theano.config.floatX\n ),\n name='b',\n borrow=True\n )\n\n # layer1.W = theano.shared(\n # value=numpy.array(\n # model_params[-4].get_value(True),\n # dtype=theano.config.floatX\n # ),\n # name='W',\n # borrow=True\n # )\n #\n # layer1.b = theano.shared(\n # value=numpy.array(\n # model_params[-3].get_value(True),\n # dtype=theano.config.floatX\n # ),\n # name='b',\n # borrow=True\n # )\n #\n # layer4.W = theano.shared(\n # value=numpy.array(\n # model_params[-6].get_value(True),\n # dtype=theano.config.floatX\n # ),\n # name='W',\n # borrow=True\n # )\n #\n # layer4.b = theano.shared(\n # value=numpy.array(\n # model_params[-5].get_value(True),\n # dtype=theano.config.floatX\n # ),\n # name='b',\n # borrow=True\n # )\n\n layer2.W = theano.shared(\n value=numpy.array(\n model_params[0].get_value(True),\n dtype=theano.config.floatX\n ),\n name='W',\n borrow=True\n )\n\n layer2.b = theano.shared(\n value=numpy.array(\n model_params[1].get_value(True),\n dtype=theano.config.floatX\n ),\n name='b',\n borrow=True\n )\n\n # layer5.W = theano.shared(\n # value=numpy.array(\n # model_params[-10].get_value(True),\n # dtype=theano.config.floatX\n # ),\n # name='W',\n # borrow=True\n # )\n #\n # layer5.b = theano.shared(\n # value=numpy.array(\n # model_params[-9].get_value(True),\n # dtype=theano.config.floatX\n # ),\n # name='b',\n # borrow=True\n # )\n\n layer3.W = theano.shared(\n value=numpy.array(\n model_params[4].get_value(True),\n dtype=theano.config.floatX\n ),\n name='W',\n borrow=True\n )\n\n layer3.b = theano.shared(\n value=numpy.array(\n model_params[5].get_value(True),\n dtype=theano.config.floatX\n ),\n name='b',\n borrow=True\n )\n\n # params = layer3.params + layer5.params + layer2.params + layer4.params + layer1.params + layer0.params\n\n datasets = load_data(None)\n\n sets = ['train', 'dev', 'test']\n dimension = [20000, 20000, 20000]\n for k in range(3):\n if k == 0:\n classify_set_x, classify_set_y, classify_set_z, classify_set_m, classify_set_c, classify_set_b= datasets[k]\n else:\n classify_set_x, classify_set_y, classify_set_z= datasets[k]\n\n # compute number of minibatches for training, validation and testing\n n_classify_batches = classify_set_x.get_value(borrow=True).shape[0]\n n_classify_batches /= batch_size\n\n # allocate symbolic variables for the data\n index = T.lscalar() # index to a [mini]batch\n classify = theano.function(\n [index],\n layer2.output,\n givens={\n x: classify_set_x[index * batch_size: (index + 1) * batch_size],\n }\n )\n\n r = []\n\n for i in xrange(n_classify_batches):\n m = classify(i)\n r.extend(m)\n r = np.array(r)\n print r.shape\n r = np.append(r, np.reshape(classify_set_y.eval(),(dimension[k], 1)), 1)\n numpy.savetxt('../extractedInformation/cnn_dist_'+str(output_size)+'/'+sets[k]+'.csv', r, delimiter=\",\")","def data_set_maker():\n\n # crate a folder in your code directory and name it: \"files\". put the .npy files iside that folder\n\n x_all = np.load(path + '/files/tinyX.npy', 'r') # reads the input file\n y_all = np.load(path + '/files/tinyY.npy', 'r') # reads the input file\n\n # split the data into 10% validation-set and 90% training set\n raw_train, raw_valid, y_train, y_valid = train_test_split(x_all, y_all, test_size=0.2, random_state=43)\n return raw_train, raw_valid, y_train, y_valid","def build_dataset(self):\n print(\"reading data of images currently , please wait......\")\n x_train, y_train, _ = get_images(self.train_directory)\n x_test, y_test, _ = get_images(self.test_directory)\n x_train, y_train = image_subset(self.num_classes, x_train, y_train)\n x_test, y_test = image_subset(self.num_classes, x_test, y_test)\n x_train = x_train.astype('float32')\n x_test = x_test.astype('float32')\n self.x_train = x_train / 255\n self.x_test = x_test / 255\n self.y_train = utils.to_categorical(y_train, self.num_classes)\n self.y_test = utils.to_categorical(y_test, self.num_classes)","def get_models(self, offset=0, sum_=False):\n \n self.models = {}\n self.predict = pd.DataFrame()\n min_value = min(self.conf[\"w_sizes\"].values())\n \n output_width = int(30/self.conf[\"time_step\"])\n \n \n for name in self.conf[\"w_sizes\"].keys():\n \n size = self.conf[\"w_sizes\"][name]\n self.create_train_test(name=name, f_size=size, offset=offset, output_width=output_width, sum_=sum_)\n model, loss, val_loss = get_model(name, self.trainX, self.trainY)\n \n pred = pd.DataFrame({name: model.predict(self.testX).tolist()},\n index=range(size-min_value, len(self.testY)+(size-min_value)))\n \n pred[name] = pred[name].apply(lambda x: np.array(x))\n \n self.predict = pd.concat([self.predict, pred], axis=1)\n \n self.models[name] = model\n \n del model, pred\n \n self.create_train_test(name=\"CNN\", f_size=min_value, offset=offset, output_width=output_width, sum_=sum_)\n self.predict[\"test\"] = self.testY.tolist()\n self.create_train_test(name=\"MLP\", f_size=min_value, offset=offset, output_width=output_width, sum_=sum_)\n self.predict[\"test_dis\"] = self.testY.tolist()\n \n self.predict.dropna(inplace=True)","def load_data5():\n# dirname = 'cifar-10-batches-py'\n# origin = 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz'\n# path = get_file(dirname, origin=origin, untar=True)\n# path= './cifar-10-batches-py'\n (x_train, y_train), (x_test, y_test) = cifar10.load_data()\n# Below shows a test class has 999 examples instead of the claimed 1000\n# tclasscount=np.zeros((10,), dtype=int)\n# for i in range(0, len(y_test)-1):\n# tclasscount[y_test[i][0]]= tclasscount[y_test[i][0]] + 1\n# print('Test class count',tclasscount)\n num_train_samples = 50000\n num_5_class = 25000\n num_5_test = 4999 # should be 5000 if all the categories had 1000 in them but they do not. One is missing.\n print('x_train shape orig:', x_train.shape)\n print('More:', x_train.shape[1:])\n print('y_test shape',y_test.shape)\n\n x5_train = np.empty((num_5_class, 32, 32, 3), dtype='uint8')\n y5_train = np.empty((num_5_class,), dtype='uint8')\n\n count=0\n\n for i in range(0, len(y_train)-1):\n if (y_train[i][0] == 2) or (y_train[i][0] == 3) or (y_train[i][0] == 4) or (y_train[i][0] == 5) or (y_train[i][0] == 7):\n x5_train[count]=x_train[i]\n y5_train[count]=y_train[i]\n count=count+1\n \n # find test data of interest\n count=0\n x5_test=np.empty((num_5_test, 32, 32, 3), dtype='uint8')\n y5_test= np.empty((num_5_test,), dtype='uint8')\n\n for i in range(0, len(y_test)-1):\n if (y_test[i][0] == 2) or (y_test[i][0] == 3) or (y_test[i][0] == 4) or (y_test[i][0] == 5) or (y_test[i][0] == 7):\n x5_test[count]=x_test[i]\n y5_test[count]=y_test[i]\n count=count+1\n# Below shows class 7 is only 999 and not 1000 examples!!! One horse got away it seems.\n# if(y_test[i][0] == 2):\n# c2=c2+1\n# if(y_test[i][0] == 3):\n# c3=c3+1\n# if(y_test[i][0] == 4):\n# c4=c4+1\n# if(y_test[i][0] == 5):\n# c5=c5+1\n# if(y_test[i][0] == 7):\n# c7=c7+1\n# print('c2count, c3count, c4count, c5count, c7count',c2,c3,c3,c5,c7)\n# print('y5tstshape',y5_test.shape, count)\n# print('y5tst',y5_test)\n# return (x_train, y_train), (x_test, y_test)\n return (x5_train, y5_train), (x5_test, y5_test)","def __init__(self, device=\"cuda:0\", *args, **kwargs):\n source_file_wtsd = \"/g/kreshuk/data/leptin/sourabh_data_v1/Segmentation_results_fused_tp_1_ch_0_Masked_WatershedBoundariesMergeTreeFilter_Out1.tif\"\n source_file_wtsd = \"/g/kreshuk/hilt/projects/data/leptin_fused_tp1_ch_0/Masked_WatershedBoundariesMergeTreeFilter_Out1.h5\"\n # wtsd = torch.from_numpy(np.array(imread(source_file_wtsd).astype(np.long))).to(device)\n wtsd = torch.from_numpy(h5py.File(source_file_wtsd, \"r\")[\"data\"][:].astype(np.long)).to(device)\n slices = [0, 157, 316]\n label_1 = [1359, 886, 1240]\n label_2 = [1172, 748, 807]\n label_3 = [364, 1148, 1447]\n m1, m2, m3, m4, m5 = [], [], [], [], []\n self.outer_cntr_ds, self.inner_cntr_ds, self.celltype_1_ds, self.celltype_2_ds, self.celltype_3_ds = [], [], [], [], []\n for slc, l1, l2, l3 in zip(slices, label_1, label_2, label_3):\n bg = wtsd[:, slc, :] == 1\n bg_cnt = find_contours(bg.cpu().numpy(), level=0)\n cnt1 = bg_cnt[0] if bg_cnt[0].shape[0] > bg_cnt[1].shape[0] else bg_cnt[1]\n cnt2 = bg_cnt[1] if bg_cnt[0].shape[0] > bg_cnt[1].shape[0] else bg_cnt[0]\n for m, cnt in zip([m1, m2], [cnt1, cnt2]):\n mask = torch.zeros_like(wtsd[:, slc, :]).cpu()\n mask[np.round(cnt[:, 0]), np.round(cnt[:, 1])] = 1\n m.append(torch.from_numpy(binary_fill_holes(mask.long().cpu().numpy())).to(device).sum().item())\n\n mask = wtsd[:, slc, :] == l1\n m3.append(mask.long().sum().item())\n cnt3 = find_contours(mask.cpu().numpy(), level=0)[0]\n mask = wtsd[:, slc, :] == l2\n m4.append(mask.long().sum().item())\n cnt4 = find_contours(mask.cpu().numpy(), level=0)[0]\n mask = wtsd[:, slc, :] == l3\n m5.append(mask.long().sum().item())\n cnt5 = find_contours(mask.cpu().numpy(), level=0)[0]\n\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\n # img[cnt1[:, 0], cnt1[:, 1]] = 1\n # plt.imshow(img);plt.show()\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\n # img[cnt2[:, 0], cnt2[:, 1]] = 1\n # plt.imshow(img);plt.show()\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\n # img[cnt3[:, 0], cnt3[:, 1]] = 1\n # plt.imshow(img);plt.show()\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\n # img[cnt4[:, 0], cnt4[:, 1]] = 1\n # plt.imshow(img);plt.show()\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\n # img[cnt5[:, 0], cnt5[:, 1]] = 1\n # plt.imshow(img);plt.show()\n\n self.outer_cntr_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt1, tolerance=1.2)).to(device)))\n self.inner_cntr_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt2, tolerance=1.2)).to(device)))\n self.celltype_1_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt3, tolerance=1.2)).to(device)))\n self.celltype_2_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt4, tolerance=1.2)).to(device)))\n self.celltype_3_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt5, tolerance=1.2)).to(device)))\n\n self.masses = [np.array(m1).mean(), np.array(m2).mean(), np.array(m3 + m4 + m5).mean()]\n self.fg_shape_descriptors = self.celltype_1_ds + self.celltype_2_ds + self.celltype_3_ds","def build_multi_blocks_models(feature_dim, feat_group_start_end_dict, output_scheme=\"regression\", num_classes=num_classes):\n\tdivan_feat_dim = feature_dim\n\tfor k in feat_group_start_end_dict:\n\t\tdivan_feat_dim = divan_feat_dim - feat_group_start_end_dict[k][2]\n\tinput_atac = keras.layers.Input(shape=[feat_group_start_end_dict['atac'][2]], name=\"atac_input\")\n\tinput_rnaseq = keras.layers.Input(shape=[feat_group_start_end_dict['rnaseq'][2]], name=\"rnaseq_input\")\n\tinput_wgbs = keras.layers.Input(shape=[feat_group_start_end_dict['wgbs'][2]], name=\"wgbs_input\")\n\tinput_divan = keras.layers.Input(shape=[divan_feat_dim], name=\"divan_input\")\n\n\thidden_atac = keras.layers.Dense(30, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(input_atac)\n\thidden_rnaseq = keras.layers.Dense(100, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(input_rnaseq)\n\thidden_wgbs = keras.layers.Dense(60, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(input_wgbs)\n\thidden_divan_1 = keras.layers.Dense(800, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(input_divan)\n\tdropout1 = keras.layers.AlphaDropout(rate=0.5)(hidden_divan_1)\n\thidden_divan_2 = keras.layers.Dense(200, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout1)\n\tconcat = keras.layers.concatenate([hidden_atac, hidden_rnaseq, hidden_wgbs, hidden_divan_2])\n\thidden3 = keras.layers.Dense(200, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout1)\n\t# trait-specific network\n\thidden_trait_1 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(concat)\n\thidden_trait_2 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(concat)\n\thidden_trait_3 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(concat)\n\thidden_trait_4 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(concat)\n\thidden_trait_5 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(concat)\n\t#bn3 = keras.layers.BatchNormalization()(hidden3)\n\tif (output_scheme==\"regression\"):\n\t\t#outputs = [keras.layers.Dense(1, hidden3) for i in range(5)] #\n\t\tout1 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out1\")(hidden_trait_1)\n\t\tout2 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out2\")(hidden_trait_2)\n\t\tout3 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out3\")(hidden_trait_3)\n\t\tout4 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out4\")(hidden_trait_4)\n\t\tout5 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out5\")(hidden_trait_5)\n\telif (output_scheme == \"ordinal_clf\"):\n\t\tout1 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out1\")(hidden_trait_1)\n\t\tout2 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out2\")(hidden_trait_2)\n\t\tout3 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out3\")(hidden_trait_3)\n\t\tout4 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out4\")(hidden_trait_4)\n\t\tout5 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out5\")(hidden_trait_5)\n\tmodel = keras.models.Model(inputs=[input_atac, input_rnaseq, input_wgbs, input_divan],\n\t\t\t\t\t\t\t outputs=[out1, out2, out3, out4, out5])\n\tif (output_scheme == \"regression\"):\n\t\tmodel.compile(loss=\"mse\", \n\t\t\t\t\t optimizer=tf.keras.optimizers.Adam(0.0001),\n\t\t\t\t\t metrics=['mae', custom_r2_metric])\n\telif (output_scheme == \"ordinal_clf\"):\n\t\tmodel.compile(loss=tf.keras.losses.CategoricalCrossentropy(), \n\t\t\t\t\t optimizer=tf.keras.optimizers.Adam(0.001))\n\tprint(model.summary())\n\treturn model","def _demo_mm_inputs(input_shape, num_classes):\n (N, C, H, W) = input_shape\n rng = np.random.RandomState(0)\n imgs = rng.rand(*input_shape)\n segs = rng.randint(\n low=0, high=num_classes - 1, size=(N, 1, H, W)).astype(np.uint8)\n img_metas = [{\n 'img_shape': (H, W, C),\n 'ori_shape': (H, W, C),\n 'pad_shape': (H, W, C),\n 'filename': '<demo>.png',\n 'scale_factor': 1.0,\n 'flip': False,\n } for _ in range(N)]\n mm_inputs = {\n 'imgs': torch.FloatTensor(imgs).requires_grad_(True),\n 'img_metas': img_metas,\n 'gt_semantic_seg': torch.LongTensor(segs)\n }\n return mm_inputs","def get_data_simple_models(measurements: list, dimension: int = 62, return_sequences: bool = True, sequence_length: int = 45,\n masking_value: float = 100.,\n batch_size: int = 1,\n classes_dict: dict = None,\n data_type: DataType = DataType.HIGH_PASS) -> (np.ndarray, np.ndarray):\n if classes_dict == None:\n classes_list = ['acetone', 'isopropanol', 'orange_juice', 'pinot_noir', 'raisin', 'wodka']\n classes_dict = {}\n for i, c in enumerate(classes_list):\n classes_dict[c] = i\n\n padding = batch_size - len(measurements)%batch_size\n\n if padding == batch_size:\n padding = 0\n\n full_length = len(measurements) + padding\n\n full_data = np.ones(shape=(full_length, sequence_length, dimension)) * masking_value\n\n if return_sequences:\n full_labels = np.zeros(shape=(full_length, sequence_length, 1), dtype=int)\n else:\n full_labels = np.zeros(shape=(full_length, 1), dtype=int)\n labels_shape = full_labels.shape[1:]\n\n for i, m in enumerate(measurements):\n d = m.get_data_as(data_type)\n if d.shape[1] != dimension:\n raise ValueError(\"Dimension mismatch\")\n if d.shape[0] < sequence_length:\n raise ValueError(\"Measurement too short!\")\n full_data[i] = m.get_data_as(data_type)[:sequence_length, :]\n full_labels[i] = np.ones(shape=labels_shape, dtype=int)*classes_dict[m.label]\n\n return full_data, full_labels","def make_data(self, which_set, p, center=False, variance_normalize=False,\n shuffle=False, save_dummy=False):\n\n print \"Making h5 file for %s\" % which_set #TODO(dhjelm): switch to logging.\n\n if which_set == 'train':\n source_path = serial.preprocess(p + 'train.npy')\n data_path = serial.preprocess(p + 'train.h5')\n label_path = serial.preprocess(p + 'train_labels.npy')\n else:\n assert which_set == 'test'\n source_path = serial.preprocess(p + 'test.npy')\n data_path = serial.preprocess(p + 'test.h5')\n label_path = serial.preprocess(p + 'test_labels.npy')\n\n data_path = \"\".join(data_path.split(\".\")[0] + '_dummy.h5')\n\n # Get the topological view and labels.\n topo_view = np.load(source_path)\n y = np.load(label_path)\n num_labels = np.amax(y) + 1\n\n # Shape information and mask.\n samples, rows, columns, depth = topo_view.shape\n if self.mask is not None:\n assert self.mask.shape == (rows, columns, depth)\n size = len(np.where(self.mask.flatten() == 1)[0].tolist())\n else:\n size = rows * columns * depth\n\n self.view_converter = MRIViewConverter((rows, columns, depth))\n X = self.view_converter.topo_view_to_design_mat(topo_view, self.mask)\n\n # TODO(dhjelm): one_hot is going away.\n one_hot = np.zeros((size, num_labels), dtype=config.floatX)\n for i in xrange(y.shape[0]):\n one_hot[i, y[i] - 1] = 1.\n\n if center:\n X -= X.mean(axis=0)\n\n if variance_normalize:\n X /= X.std(axis=0)\n\n rng = make_np_rng(None, 322, which_method=\"shuffle\")\n if shuffle:\n index = range(samples)\n rng.shuffle(index)\n X = X[index, :]\n one_hot = one_hot[index, :]\n\n assert not np.any(np.isnan(X))\n\n h5file, node = self.init_hdf5(data_path, ([samples, size], [samples, num_labels]))\n MRI_Big.fill_hdf5(h5file, X, one_hot, node)\n h5file.close()","def get_training_data(self):\n\n # this actually never was a set\n # src_set = self.target['src'].values\n # dst_set = self.target['dst'].values\n\n # train_negative = self.get_negative_edges(src_set, dst_set, self.train_ind.shape[0]) # * self.K)\n # test_negative = self.get_negative_edges(src_set, dst_set, self.test_ind.shape[0])\n\n train_positive = self.target.iloc[self.train_edge_ind].values\n test_positive = self.target.iloc[self.test_edge_ind].values\n\n # # print(train_positive.shape, train_negative.shape, test_positive.shape, test_negative.shape)\n # print(f\"Working with {train_positive.shape[0]} positive and {train_negative.shape[0]} negative samples in the train set, {test_positive.shape[0]} and {test_negative.shape[0]} - in test set\")\n\n X_train = train_positive\n X_test = test_positive\n\n y_train = np.ones((self.train_edge_ind.shape[0],))\n y_test = np.ones((self.test_edge_ind.shape[0],))\n\n # X_train = np.vstack([\n # train_positive,\n # train_negative\n # ])\n\n # X_test = np.vstack([\n # test_positive,\n # test_negative\n # ])\n\n # y_train = np.concatenate([np.ones((self.train_ind.shape[0],)), np.zeros((self.train_ind.shape[0]),)]) # self.train_ind.shape[0]) * self.K\n # y_test = np.concatenate([np.ones((self.test_ind.shape[0],)), np.zeros((self.test_ind.shape[0],))])\n\n assert X_train.shape[0] == y_train.shape[0]\n assert X_test.shape[0] == y_test.shape[0]\n\n def shuffle(X, y):\n ind_shuffle = np.arange(0, X.shape[0])\n np.random.shuffle(ind_shuffle)\n return X[ind_shuffle], y[ind_shuffle]\n\n self.X_train, self.y_train = shuffle(X_train, y_train)\n self.X_test, self.y_test = shuffle(X_test, y_test)\n\n print(f\"Splitting into {self.X_train.shape[0]} train and {self.X_test.shape[0]} test samples\")\n\n # return X_train, X_test, y_train, y_test","def createDataset_detection(outputPath, imagePathList, box_x_list, box_y_list,\n labelList, region_mask_list, pixel_mask_list):\n assert (len(imagePathList) == len(box_x_list) == len(box_y_list))\n nSamples = len(imagePathList)\n if not os.path.exists(outputPath):\n os.mkdir(outputPath)\n env = lmdb.open(outputPath, map_size=1099511627776)\n cache = {}\n cnt = 1\n for i in range(nSamples):\n imagePath = imagePathList[i]\n box_x = box_x_list[i]\n box_y = box_y_list[i]\n if len(box_x) == 0:\n continue\n if not os.path.exists(imagePath):\n print('%s does not exist' % imagePath)\n continue\n with open(imagePath, 'rb') as f:\n imageBin = f.read()\n\n imageKey = 'image-%09d' % cnt\n cache[imageKey] = imageBin\n box_x_Key = 'boxes_x-%09d' % cnt\n box_y_Key = 'boxes_y-%09d' % cnt\n cache[box_x_Key] = box_x.encode()\n cache[box_y_Key] = box_y.encode()\n\n if labelList:\n labelKey = 'label-%09d' % cnt\n cache[labelKey] = labelList[i].encode()\n if region_mask_list:\n region_mask_Key = 'region_mask-%09d' % cnt\n cache[region_mask_Key] = open(region_mask_list[i], 'rb').read()\n if pixel_mask_list:\n pixel_mask_Key = 'pixel_mask-%09d' % cnt\n cache[pixel_mask_Key] = open(pixel_mask_list[i], 'rb').read()\n # embed()\n if cnt % 1000 == 0:\n writeCache(env, cache)\n cache = {}\n print('Written %d / %d' % (cnt, nSamples))\n cnt += 1\n nSamples = cnt - 1\n cache['num-samples'] = str(nSamples).encode()\n writeCache(env, cache)\n print('Created dataset with %d samples' % nSamples)","def setUpClass(cls):\n cls.test_file_1 = \"/tmp/test_data_loader_dummy_1.pkl\"\n cls.test_file_2 = \"/tmp/test_data_loader_dummy_2.pkl\"\n cls.in_cols = [\"file\", \"id\", \"len\", \"seq\", \"phyche\", \"pssm\", \"logits\",\n \"ss\", \"h_0\", \"h_1\", \"h_2\", \"lm_logits\"]\n cls.out_cols = [\"dataset\", \"id\", \"len\", \"position\", \"amino\",\n \"phyche\", \"pssm\", \"logits\", \"ss\", \"h_0\", \"h_1\", \"h_2\",\n \"lm_logits\"]\n\n seq = np.array([[0., 0., 1.],\n [1., 0., 0.]])\n phyche = np.array([[0., 0.], # phyche\n [1., 0.]])\n pssm = np.array([[0., 0., .8], # pssm\n [.8, 0., 0.]])\n logits = np.array([[0.1, 0., 0.9], # logits\n [0.9, 0., 0.1]])\n ss = np.array([[0., 0., 1.], # ss\n [1., 0., 0.]])\n h_0 = np.array([[0., 0., 1., 0.],\n [1., 0., 0., 0.]])\n h_1 = np.array([[0., 0., 1., 0.],\n [1., 0., 0., 0.]])\n h_2 = np.array([[0., 0., 1., 0.], # h_2\n [1., 0., 0., 0.]])\n lm_logits = np.array([[0., 0., 1.], # lm_logits\n [1., 0., 0.]])\n\n ex_1_in = (\"dummy_train.tfrecords\", # file\n \"id1\", # id\n 2, # len\n seq,\n phyche,\n pssm,\n logits,\n ss,\n h_0,\n h_1,\n h_2,\n lm_logits,\n )\n ex_1_out = [tuple([\"train\", ex_1_in[1], ex_1_in[2], j] + [ex_1_in[i][j, :] for i in range(3, len(ex_1_in))]) for j in range(2)]\n\n in_df = pd.DataFrame.from_records(data=[ex_1_in], columns=cls.in_cols)\n # write to file\n in_df.to_pickle(cls.test_file_1)\n\n cls.out_df = pd.DataFrame.from_records(data=ex_1_out, columns=cls.out_cols)","def _demo_cid_inputs(input_shape=(1, 3, 512, 512)):\n (N, C, H, W) = input_shape\n\n rng = np.random.RandomState(0)\n\n imgs = rng.rand(*input_shape)\n multi_heatmap = np.zeros([N, 18, H // 4, W // 4], dtype=np.float32)\n multi_mask = np.ones([N, 1, H // 4, W // 4], dtype=np.float32)\n instance_coord = np.zeros([N, 30, 2], dtype=int)\n instance_heatmap = np.zeros([N, 30, 17, H // 4, W // 4], dtype=np.float32)\n instance_mask = np.ones([N, 30, 17, 1, 1], dtype=np.float32)\n instance_valid = np.ones([N, 30], dtype=int)\n\n img_metas = [{\n 'image_file':\n 'test.jpg',\n 'aug_data': [torch.zeros(1, 3, 512, 512)],\n 'test_scale_factor': [1],\n 'base_size': (256, 256),\n 'center':\n np.array([256, 256]),\n 'scale':\n np.array([1.28, 1.28]),\n 'flip_index':\n [0, 2, 1, 4, 3, 6, 5, 8, 7, 10, 9, 12, 11, 14, 13, 16, 15]\n } for _ in range(N)]\n\n cid_inputs = {\n 'imgs': torch.FloatTensor(imgs).requires_grad_(True),\n 'multi_heatmap': torch.FloatTensor(multi_heatmap),\n 'multi_mask': torch.FloatTensor(multi_mask),\n 'instance_coord': torch.FloatTensor(instance_coord),\n 'instance_heatmap': torch.FloatTensor(instance_heatmap),\n 'instance_mask': torch.FloatTensor(instance_mask),\n 'instance_valid': torch.FloatTensor(instance_valid),\n 'img_metas': img_metas\n }\n return cid_inputs","def get_data(data_dir, hdf5):\r\n\r\n # Get the filenames of the lists containing image paths and labels.\r\n train_file, val_file = build_dataset_index(data_dir)\r\n\r\n # Check if (creating and) loading from hdf5 database is desired.\r\n if hdf5:\r\n # Create folder to store dataset.\r\n if not os.path.exists('hdf5'):\r\n os.makedirs('hdf5')\r\n # Check if hdf5 databases already exist and create them if not.\r\n if not os.path.exists('hdf5/tiny-imagenet_train.h5'):\r\n from tflearn.data_utils import build_hdf5_image_dataset\r\n print ' Creating hdf5 train dataset.'\r\n build_hdf5_image_dataset(train_file, image_shape=(64, 64), mode='file', output_path='hdf5/tiny-imagenet_train.h5', categorical_labels=True, normalize=True)\r\n\r\n if not os.path.exists('hdf5/tiny-imagenet_val.h5'):\r\n from tflearn.data_utils import build_hdf5_image_dataset\r\n print ' Creating hdf5 val dataset.'\r\n build_hdf5_image_dataset(val_file, image_shape=(64, 64), mode='file', output_path='hdf5/tiny-imagenet_val.h5', categorical_labels=True, normalize=True)\r\n\r\n # Load training data from hdf5 dataset.\r\n h5f = h5py.File('hdf5/tiny-imagenet_train.h5', 'r')\r\n X = h5f['X']\r\n Y = h5f['Y']\r\n\r\n # Load validation data.\r\n h5f = h5py.File('hdf5/tiny-imagenet_val.h5', 'r')\r\n X_test = h5f['X']\r\n Y_test = h5f['Y'] \r\n\r\n # Load images directly from disk when they are required.\r\n else:\r\n from tflearn.data_utils import image_preloader\r\n X, Y = image_preloader(train_file, image_shape=(64, 64), mode='file', categorical_labels=True, normalize=True, filter_channel=True)\r\n X_test, Y_test = image_preloader(val_file, image_shape=(64, 64), mode='file', categorical_labels=True, normalize=True, filter_channel=True)\r\n\r\n # Randomly shuffle the dataset.\r\n X, Y = shuffle(X, Y)\r\n\r\n return X, Y, X_test, Y_test","def test_hdf5_load_all():\n skip_if_no_h5py()\n import h5py\n\n # save random data to HDF5\n handle, filename = tempfile.mkstemp()\n dataset = random_one_hot_dense_design_matrix(np.random.RandomState(1),\n num_examples=10, dim=5,\n num_classes=3)\n with h5py.File(filename, 'w') as f:\n f.create_dataset('X', data=dataset.get_design_matrix())\n f.create_dataset('y', data=dataset.get_targets())\n\n # instantiate Train object\n trainer = yaml_parse.load(load_all_yaml % {'filename': filename})\n trainer.main_loop()\n\n # cleanup\n os.remove(filename)","def make_mnv_data_dict(list_of_groups):\n # eventids are really (in the hdf5) uint64, planecodes are really uint16;\n # use tf.{int64,int32,uint8} because these are the dtypes that one-hot\n # supports (_not_ int16 or uint16, at least in TF v1.2); use int64 instead\n # of unit64 because reshape supports int64 (and not uint64).\n data_list = []\n for g in list_of_groups:\n if g in VALID_SET_OF_GROUPS:\n if g == EVENT_DATA:\n data_list.extend([\n (EVENTIDS, tf.int64, g),\n ])\n if g == VTX_DATA:\n data_list.extend([\n (PLANECODES, tf.int32, g),\n (SEGMENTS, tf.uint8, g),\n (ZS, tf.float32, g),\n ])\n if g == IMG_DATA:\n data_list.extend([\n (HITIMESU, tf.float32, g),\n (HITIMESV, tf.float32, g),\n (HITIMESX, tf.float32, g),\n ])\n if g == GEN_DATA:\n data_list.extend([\n (QSQRD, tf.float32, g),\n (WINV, tf.float32, g),\n (XBJ, tf.float32, g),\n (YBJ, tf.float32, g),\n (CURRENT, tf.int32, g),\n (INT_TYPE, tf.int32, g),\n (TARGETZ, tf.int32, g),\n ])\n if g == HADRO_DATA:\n data_list.extend([\n (ESUM_CHGDKAONS, tf.float32, g),\n (ESUM_CHGDPIONS, tf.float32, g),\n (ESUM_HADMULTMEAS, tf.float32, g),\n (ESUM_NEUTPIONS, tf.float32, g),\n (ESUM_NEUTRONS, tf.float32, g),\n (ESUM_OTHERS, tf.float32, g),\n (ESUM_PROTONS, tf.float32, g),\n (N_CHGDKAONS, tf.int32, g),\n (N_CHGDPIONS, tf.int32, g),\n (N_HADMULTMEAS, tf.int32, g),\n (N_NEUTPIONS, tf.int32, g),\n (N_NEUTRONS, tf.int32, g),\n (N_OTHERS, tf.int32, g),\n (N_PROTONS, tf.int32, g),\n ])\n if g == LEPTO_DATA:\n data_list.extend([\n (ESUM_ELECTRONS, tf.float32, g),\n (ESUM_MUONS, tf.float32, g),\n (ESUM_TAUS, tf.float32, g),\n (N_ELECTRONS, tf.int32, g),\n (N_MUONS, tf.int32, g),\n (N_TAUS, tf.int32, g),\n ])\n else:\n raise ValueError('Unrecognized group')\n mnv_data = {}\n for datum in data_list:\n mnv_data[datum[0]] = {}\n mnv_data[datum[0]]['dtype'] = datum[1]\n mnv_data[datum[0]]['byte_data'] = None\n mnv_data[datum[0]]['group'] = datum[2]\n\n return mnv_data","def create_dataset(data_path, is_training=True, is_shuffle=True, batch_size=1, repeat_size=1,\n device_num=1, rank=0, num_parallel_workers=24):\n dataset = HED_Dataset_t(data_path, is_training)\n print(\"total patch numbers per epoch\", len(dataset))\n if is_training:\n trans1 = [\n C2.Normalize(mean=[104.00698793, 116.66876762, 122.67891434], std=[1, 1, 1]),\n C2.HWC2CHW(),\n C.TypeCast(mindspore.float32)\n ]\n dataloader = ds.GeneratorDataset(dataset, ['image', 'label', 'mask'], num_parallel_workers=num_parallel_workers,\n shuffle=is_shuffle, num_shards=device_num, shard_id=rank)\n # apply map operations on images\n dataloader = dataloader.map(input_columns='image', operations=trans1,\n num_parallel_workers=num_parallel_workers)\n dataloader = dataloader.map(input_columns='label', operations=C.TypeCast(mindspore.float32),\n num_parallel_workers=num_parallel_workers)\n dataloader = dataloader.map(input_columns='mask', operations=C.TypeCast(mindspore.float32),\n num_parallel_workers=num_parallel_workers)\n dataloader = dataloader.batch(batch_size, drop_remainder=True)\n else:\n dataset = HED_Dataset_e(data_path, is_training)\n dataloader = ds.GeneratorDataset(dataset, ['test', 'label'], num_parallel_workers=8, shuffle=is_shuffle)\n dataloader = dataloader.map(input_columns='test', operations=C.TypeCast(mindspore.float32))\n dataloader = dataloader.batch(batch_size, drop_remainder=False)\n\n # apply DatasetOps\n dataloader = dataloader.repeat(repeat_size)\n\n return dataloader","def get_training_and_testing_sets(data, Y):\r\n data = pd.concat([data, Y], axis=1)\r\n x,y=data.shape\r\n train_X_sub1=data[0:x//6]\r\n dev_X_sub1 = data[x//6:x//6 + x//12]\r\n test_X_sub1 = data[x//6 + x//12:x//3]\r\n\r\n train_X_sub2 = data[x//3:x//3+x//6]\r\n dev_X_sub2 = data[x//6 + x//3:x//3 + x//6 + x//12]\r\n test_X_sub2 = data[x//3 + x//6 + x//12:2*x//3]\r\n\r\n train_X_sub3 = data[2*x//3:(2*x//3) +x//6]\r\n dev_X_sub3 = data[x//6 + 2*x//3: (2*x//3) + x//6 + x//12]\r\n test_X_sub3 = data[2*x//3 + x//6 + x//12:x]\r\n\r\n train_X=train_X_sub1.append(train_X_sub2,ignore_index = True)\r\n train_X =train_X.append(train_X_sub3,ignore_index = True)\r\n dev_X= dev_X_sub1.append(dev_X_sub2,ignore_index = True)\r\n dev_X = dev_X.append(dev_X_sub3,ignore_index = True)\r\n test_X = test_X_sub1.append(test_X_sub2,ignore_index = True)\r\n test_X = test_X.append(test_X_sub3,ignore_index = True)\r\n\r\n\r\n train_X = util.shuffle(train_X)\r\n train_X = train_X.reset_index(drop=True)\r\n\r\n dev_X = util.shuffle(dev_X)\r\n dev_X = dev_X.reset_index(drop=True)\r\n\r\n test_X = util.shuffle(test_X)\r\n test_X = test_X.reset_index(drop=True)\r\n\r\n train_X_final=train_X\r\n dev_X_final = dev_X\r\n test_X_final = test_X\r\n x, y = train_X_final.shape\r\n train_X = train_X_final.iloc[:, 0:y - 1]\r\n train_Y = train_X_final.iloc[:, y - 1]\r\n\r\n x, y = test_X_final.shape\r\n test_X = test_X_final.iloc[:, 0:y - 1]\r\n test_Y = test_X_final.iloc[:, y - 1]\r\n\r\n x, y = dev_X_final.shape\r\n dev_X = dev_X_final.iloc[:, 0:y - 1]\r\n dev_Y = dev_X_final.iloc[:, y - 1]\r\n\r\n return train_X, train_Y, dev_X,dev_Y,test_X, test_Y","def get_model_1(parameters):\n # Parameters\n n1 = parameters['n1']\n k1 = parameters['k1']\n n2 = parameters['n2']\n n3 = parameters['n3']\n k2 = parameters['k2']\n n4 = parameters['n4']\n n5 = parameters['n5']\n NUM_FILTERS_C1 = 20\n \n # Sequential model\n model = keras.models.Sequential()\n \n # Add C1 layer\n # ------------\n # Input_shape (batch, rows, cols, channels) = (-, n1, 1, 1)\n # Output_shape (batch, rows, cols, channels) = (-, n2, 1, NUM_FILTERS_C1)\n model.add(keras.layers.Conv2D(filters=NUM_FILTERS_C1,\n kernel_size=(k1, 1),\n padding='valid',\n data_format=\"channels_last\",\n activation='tanh',\n kernel_initializer='random_uniform',\n bias_initializer='random_uniform',\n input_shape=(n1,1,1)))\n \n # Add M2 layer\n # ------------\n # Input_shape (batch, rows, cols, channels) = (-, n2, 1, NUM_FILTERS_C1)\n # Output_shape (batch, rows, cols, channels) = (-, n3, 1, NUM_FILTERS_C1)\n model.add(keras.layers.MaxPooling2D(pool_size=(k2, 1),\n padding='same',\n data_format=\"channels_last\"))\n \n # Flatten before dense layer\n model.add(keras.layers.Flatten())\n \n # Add F3 layer\n # ------------\n # Intput_shape (batch, rows, cols, channels) = (-, n3 x 1 x NUM_FILTERS_C1)\n # Output_shape (batch, dim) = (-, n4)\n model.add(keras.layers.Dense(units=n4,\n activation='tanh',\n kernel_initializer='random_uniform',\n bias_initializer='random_uniform'))\n \n # Add F4 layer\n # ------------\n # Intput_shape (batch, dim) = (1, n4)\n # Output_shape (batch, dim) = (1, n5)\n model.add(keras.layers.Dense(units=n5,\n activation='softmax',\n kernel_initializer='random_uniform',\n bias_initializer='random_uniform'))\n \n # Compile model\n model.compile(optimizer='sgd',\n loss='mean_squared_error',\n metrics=['accuracy'])\n \n # Print the model summary to output file\n # To print to stdout: model.summary()\n with open(OUTPUT_FILE, 'a') as f:\n # Pass the file handle in as a lambda function to make it callable\n model.summary(print_fn=lambda x: f.write(x + '\\n'))\n \n # Return the model\n return model","def build_matrix(self):\n self.lb_make = LabelEncoder()\n self.lb_make.fit(self.Y_train)\n tokenizer = Tokenizer(num_words=2000)\n x_array_train = numpy.asarray(self.train['text'])\n x_array_test = numpy.asarray(self.test['text'])\n tokenizer.fit_on_texts(x_array_train)\n x_train_matrix = tokenizer.texts_to_matrix(x_array_train, mode='count')\n x_test_matrix = tokenizer.texts_to_matrix(x_array_test, mode='count')\n y_train_numbers = self.lb_make.transform(self.Y_train)\n y_test_numbers = self.lb_make.transform(self.Y_test)\n y_train_matrix = keras.utils.to_categorical(y_train_numbers, 3)\n y_test_matrix = keras.utils.to_categorical(y_test_numbers, 3)\n self.tokenizer = tokenizer\n return x_train_matrix, x_test_matrix, y_train_matrix, y_test_matrix","def createDataset(sources,output,labels,sparse):\n global has_joblib\n out_path = str(output)\n # delete the output file\n if os.path.exists(os.path.abspath(out_path)):\n os.remove(os.path.abspath(out_path))\n \n # first, list the source files\n fpaths_src, fnames_src = utils.listFiles(directory=os.path.abspath(sources), ext='png')\n \n label_map={}\n \n # read the label file\n if not (labels == None):\n label_map = utils.readLabelMap(labels)\n # check that the numbers match\n print(\"Number of images in label map : %s\"%str(len(label_map.keys())-1))\n print(\"Number of images in source dir: %s\"%str(len(fpaths_src)))\n assert len(label_map.keys())-1 == len(fpaths_src)\n \n # generate KNN classifier\n if not (args.codebook == 'None' or args.codebook == None):\n args.knn = getKNNClassifier() \n else:\n args.knn = None\n \n # precompute number of images\n n_imgs = len(fpaths_src)\n \n # preallocate array\n # if augmentation, calculate (9*4+1)*n samples\n all_features_list = []\n \n # parallel implementation (default, if joblib available)\n if has_joblib:\n image_features = Parallel(n_jobs=args.njobs,verbose=5) (delayed(processImage)(fpaths_src, label_map, fnames_src, img_idx) for img_idx in range(n_imgs))\n # collect all images into a single matrix\n image_features = np.concatenate(image_features, axis=0)\n all_features_list.append(image_features)\n else:\n for img_idx in xrange(n_imgs):\n image_features = processImage(fpaths_src, label_map, fnames_src, img_idx)\n all_features_list.append(image_features)\n \n # make a 2D matrix from the list of features (stack all images vertically)\n feat_matrix = np.concatenate(all_features_list, axis=0).astype(np.float32) \n \n # do scaling of each feature dimension \n #if False:\n if not (args.scale == 0):\n print \"Scaling data...\"\n \n # preserve the labels\n label_vec = feat_matrix[:,0]\n feat_matrix = np.delete(feat_matrix,0,1)\n \n featurestats = np.zeros((2,feat_matrix.shape[1]))\n \n # use soft-normalization (zero-mean, unit var whitening)\n if (args.scale == 1):\n # if we specified featurestats from a training set, use them\n if not (args.featurestats == None):\n # load the statistics\n featurestats = loadFeatureStats()\n # featurestats contains 2 rows, first row = mean, second row = std\n # and n feature dimensions\n assert feat_matrix.shape[1]==featurestats.shape[1]\n else:\n pass\n \n \n # use hard-normalization \n elif (args.scale == 2):\n # if we specified featurestats from a training set, use them\n if not (args.featurestats == None):\n # load the statistics\n featurestats = loadFeatureStats()\n # the featurestats contains 2 rows, first row = min, second row = max \n # and n feature dimensions\n assert feat_matrix.shape[1]==featurestats.shape[1]\n else:\n pass\n \n \n # normalize each feature dimension\n for feat_idx in xrange(feat_matrix.shape[1]):\n feat_vec = feat_matrix[:,feat_idx]\n \n # soft-normalization (zero-mean, approx. unit variance)\n if (args.scale == 1): \n # if feature statistics are specified\n if not (args.featurestats == None):\n feat_mean = featurestats[0,feat_idx]\n feat_std = featurestats[1,feat_idx]\n else:\n # compute them from the data\n feat_mean = feat_vec.mean()\n feat_std = (feat_vec.std() + 1e-10)\n # store them \n featurestats[0,feat_idx] = feat_mean\n featurestats[1,feat_idx] = feat_std\n \n # shift to zero mean and (unit) variance\n feat_vec_scaled = (feat_vec - feat_mean) / (1.*feat_std)\n \n \n # hard-normalization (min/max = borders estimated from the (training) dataset)\n elif (args.scale == 2):\n if not (args.featurestats == None):\n feat_min = featurestats[0,feat_idx]\n feat_max = featurestats[1,feat_idx]\n else:\n # compute them freshly\n feat_min = np.min(feat_vec)\n feat_max = np.max(feat_vec)\n # store them \n featurestats[0,feat_idx] = feat_min\n featurestats[1,feat_idx] = feat_max\n \n # standardize/normalize between 0 and 1\n feat_vec_std = (feat_vec - feat_min) / (feat_max - feat_min + 1e-10) \n \n # linearly scale between -1 and 1 \n feat_vec_scaled = (1.0*feat_vec_std * (1 - -1)) - 1\n \n \n # set column back to matrix\n feat_matrix[:,feat_idx] = feat_vec_scaled\n \n # finally prepend the label_vec again\n feat_matrix = np.concatenate((np.reshape(label_vec,(feat_matrix.shape[0],1)),feat_matrix), axis=1)\n \n print \"Done.\"\n else:\n print \"Data may not be properly scaled, use the 'svm-scale' implementation of libsvm.\"\n \n if not (args.savefeaturestats == None):\n saveFeatureStats(featurestats) \n\n #Parallel(n_jobs=args.njobs, verbose=5)(delayed(function)(params) for i in range(10))\n # open the output file\n output_file = open(os.path.abspath(out_path), 'wb')\n\n # run through the feature matrix \n print \"Writing %s rows and %s cols to file...\"%(feat_matrix.shape)\n # parallel implementation (default, if joblib available)\n if has_joblib:\n lines = Parallel(n_jobs=args.njobs, verbose=5)(delayed(writeLine)(i, feat_matrix) for i in range(feat_matrix.shape[0]))\n output_file.writelines(lines) \n else:\n for i in xrange(feat_matrix.shape[0]):\n line = writeLine(i, feat_matrix)\n output_file.writelines(line)\n \n output_file.close()\n \n return 0","def _load20news_miao():\n DIR = os.path.dirname(os.path.realpath(__file__)).split('vae_sparse')[0]+'vae_sparse/optvaedatasets'\n DIR += '/20news_miao'\n h5file = DIR+'/miao.h5'\n if not os.path.exists(h5file):\n flen = len(open(DIR+'/vocab').readlines())\n print 'DIM: ',flen\n np.random.seed(1)\n TRAIN_VALID_MAT = readSparseFile(DIR+'/train.feat', flen, zeroIndexed=False)\n idx = np.random.permutation(TRAIN_VALID_MAT.shape[0])\n VALIDMAT = TRAIN_VALID_MAT[idx[:500]]\n TRAINMAT = TRAIN_VALID_MAT[idx[500:]]\n TESTMAT = readSparseFile(DIR+'/test.feat', flen, zeroIndexed=False) \n saveSparseHDF5(TRAINMAT,'train', h5file)\n saveSparseHDF5(VALIDMAT,'valid', h5file)\n saveSparseHDF5(TESTMAT, 'test' , h5file)\n dset = {}\n dset['vocabulary']= [k.strip().split(' ')[0] for k in open(DIR+'/vocab').readlines()]\n dset['train'] = loadSparseHDF5('train',h5file)\n dset['valid'] = loadSparseHDF5('valid',h5file)\n dset['test'] = loadSparseHDF5('test',h5file)\n dset['dim_observations'] = dset['train'].shape[1]\n dset['data_type'] = 'bow'\n return dset","def mtf_unitransformer_all_layers_tiny():\n hparams = mtf_unitransformer_tiny()\n hparams.moe_num_experts = 4\n hparams.moe_expert_x = 4\n hparams.moe_expert_y = 4\n hparams.moe_hidden_size = 512\n hparams.layers = [\"self_att\", \"local_self_att\", \"moe_1d\", \"moe_2d\", \"drd\"]\n return hparams","def get_prediction_files(test_path, joint_model_path_mapping, \n mapping_file, column_mapping, erosion_cols, narrowing_cols,\n image_batch_array):\n final_prediction_file = pd.DataFrame()\n for joint_type in joint_model_path_mapping.keys():\n #Dependency\n def rmse (y_true, y_pred):\n return K.sqrt(K.mean(K.square(y_pred -y_true), axis=-1))\n\n # from keras_radam import RAdam\n model_weights = joint_model_path_mapping[joint_type]\n\n if joint_type in ['Foot_finger_none', 'Hand_finger_narrowing']:\n joint_preds = pd.DataFrame()\n for sub_model in model_weights.keys():\n weight = model_weights[sub_model][0][0]\n sub_model_path = model_weights[sub_model][1][0]\n print(weight, sub_model_path)\n\n mapping_type = \"_\".join(sub_model.split(\"_\")[:-1])\n\n loaded_model = load_model(sub_model_path, custom_objects={'rmse': rmse})\n print(\"Model loaded succesfully -> \" + mapping_type)\n\n #Loading the image array for prediction\n # print(image_batch_array[mapping_type][0].shape)\n\n preds = pd.DataFrame(weight * loaded_model.predict(image_batch_array[mapping_type][0]))\n preds.columns = ['labels_'+ str(i) for i in range(preds.shape[1])]\n\n joint_preds = pd.concat([joint_preds, preds], axis = 1)\n\n joint_preds = joint_preds.groupby(lambda x:x, axis=1).sum()\n # print(joint_preds.head(10)) \n\n \n #Predictions from model\n joint_type_df = pd.DataFrame(joint_preds)\n joint_type_df.columns = ['labels_'+ str(i) for i in range(joint_type_df.shape[1])]\n\n # print([img.split(\".\")[0] for img in image_batch_array[mapping_type][1]])\n\n joint_type_df['Joint_image_ID'] = [img.split(\".\")[0] for img in image_batch_array[mapping_type][1]]\n print(\"Predictions generated \")\n\n # Getting the prediction type \n prediction_type = joint_type.split(\"_\")[-1]\n # print(prediction_type)\n # Unique patients in test set\n patient_id_list = sorted(list(np.unique([img.split(\".\")[0].split(\"-\")[0] for img in os.listdir(test_path) if img != 'desktop'])))\n\n #Calling the prediciton file generator function\n temp = get_final_submission_file(joint_type_df, \"_\".join(joint_type.split(\"_\")[:-1]), prediction_type, mapping_file, patient_id_list)\n # print(temp.head())\n\n final_prediction_file = pd.concat([final_prediction_file, temp], axis = 1)\n # print(final_prediction_file)\n print(\"All steps for {} completed succesfully \".format(joint_type))\n\n else:\n joint_preds = pd.DataFrame()\n for weight , model_path in zip(model_weights[0], model_weights[1]):\n\n print(weight, model_path)\n loaded_model = load_model(model_path, custom_objects={'rmse': rmse})\n print(\"Model loaded succesfully -> \" + \"_\".join(joint_type.split(\"_\")[:-1]))\n\n # print(image_batch_array[\"_\".join(joint_type.split(\"_\")[:-1])][0].shape)\n preds = pd.DataFrame(weight * loaded_model.predict(image_batch_array[\"_\".join(joint_type.split(\"_\")[:-1])][0]))\n preds.columns = ['labels_'+ str(i) for i in range(preds.shape[1])]\n \n # print(image_batch_array['Hand_finger_erosion'][0].shape)\n # preds = pd.DataFrame(weight * loaded_model.predict(image_batch_array['Hand_finger_erosion'][0]))\n # preds.columns = ['labels_'+ str(i) for i in range(preds.shape[1])]\n\n # print(preds)\n joint_preds = pd.concat([joint_preds, preds], axis = 1)\n \n joint_preds = joint_preds.groupby(lambda x:x, axis=1).sum()\n # print(joint_preds.head(10)) \n\n #Predictions from model\n joint_type_df = pd.DataFrame(joint_preds)\n joint_type_df.columns = ['labels_'+ str(i) for i in range(joint_type_df.shape[1])]\n\n # print([img.split(\".\")[0] for img in image_batch_array[\"_\".join(joint_type.split(\"_\")[:-1])][1]])\n\n joint_type_df['Joint_image_ID'] = [img.split(\".\")[0] for img in image_batch_array[\"_\".join(joint_type.split(\"_\")[:-1])][1]]\n # print(\"Predictions generated \")\n\n # Getting the prediction type \n prediction_type = joint_type.split(\"_\")[-1]\n # print(prediction_type)\n # Unique patients in test set\n patient_id_list = sorted(list(np.unique([img.split(\".\")[0].split(\"-\")[0] for img in os.listdir(test_path) if img != 'desktop'])))\n\n #Calling the prediciton file generator function\n temp = get_final_submission_file(joint_type_df, \"_\".join(joint_type.split(\"_\")[:-1]), prediction_type, mapping_file, patient_id_list)\n\n final_prediction_file = pd.concat([final_prediction_file, temp], axis = 1)\n # \n # print(final_prediction_file)\n # print(final_prediction_file.columns)\n\n print(\"All steps for {} completed succesfully \".format(joint_type))\n\n #Final prediction file\n \n final_prediction_file = final_prediction_file .loc[:,~final_prediction_file .columns.duplicated()]\n final_prediction_file.to_csv(\"error_file.csv\")\n final_prediction_file['Overall_Tol'] = np.sum(final_prediction_file[erosion_cols + narrowing_cols], axis = 1)\n final_prediction_file['Overall_erosion'] = np.sum(final_prediction_file[erosion_cols], axis = 1)\n final_prediction_file['Overall_narrowing'] = np.sum(final_prediction_file[narrowing_cols], axis = 1)\n\n print(final_prediction_file.shape)\n return final_prediction_file[['Patient_ID', 'Overall_Tol', 'Overall_erosion', 'Overall_narrowing'] + column_mapping]","def preprocess():\n\n # Read Training and Test Data\n train_df = pd.read_csv(configs.TRAIN_DATA_PATH)\n test_df = pd.read_csv(configs.TEST_DATA_PATH)\n\n # Data Exploration and Preprocessing\n user_ids = train_df['userId']\n movie_ids = train_df['movieId']\n ratings = train_df['rating']\n\n # Create the mapping and save it for later usage in testing\n all_users = create_mapping(pd.concat([train_df['userId'], test_df['userId']], axis = 0))\n all_movies = create_mapping(pd.concat([train_df['movieId'], test_df['movieId']], axis = 0))\n\n\n # Save the mapping arrays for users and movies\n with open(configs.USER_IDS_PATH, \"wb\") as f:\n np.save(f, all_users)\n\n with open(configs.MOVIE_IDS_PATH, \"wb\") as f:\n np.save(f, all_movies)\n\n\n # Resetting the ids of training data to [0-n]\n user_ids = map_ids(user_ids, users = True)\n movie_ids = map_ids(movie_ids, users = False)\n\n\n # Resetting the ids of test data\n test_user_ids = map_ids(test_df['userId'], users = True)\n test_movie_ids = map_ids(test_df['movieId'], users = False)\n test_ratings = test_df['rating']\n\n # Statistics of training data\n # Number of users and movies can be extracted from the array of mapped ids\n n_users = np.max(user_ids) + 1\n n_movies = np.max(movie_ids) + 1\n\n # Statistics of test data\n test_n_users = np.max(test_user_ids) + 1\n test_n_movies = np.max(test_movie_ids) + 1\n\n # Returning the indices back can be done using unmap_ids function\n # Example\n # unmap_ids(movie_ids, users = False)\n # unmap_ids(user_ids, users = True)\n\n # Define the training rating matrix as sparse matrix\n\n # Sparse rating matrix from training data\n R = sparse.coo_matrix(\n (ratings, (user_ids, movie_ids)),\n shape=(n_users, n_movies),\n dtype=np.float\n )\n\n\n\n # Save the rating matrix for training data\n sparse.save_npz(configs.R_TRAIN_MATRIX_PATH, R)\n\n # Sparse rating matrix from test data\n R2 = sparse.coo_matrix(\n (test_ratings, (test_user_ids, test_movie_ids)),\n shape=(test_n_users, test_n_movies),\n dtype=np.float\n )\n\n # Save the rating matrix for test data\n sparse.save_npz(configs.R_TEST_MATRIX_PATH, R2)\n\n # return user_ids, movie_ids, ratings, n_users, n_movies, R, R2\n return R, R2","def main():\n feature_extraction_model = \"HOG\"\n # feature_extraction_models = [\"CM\", \"HOG\"]\n feature_extraction_model_1 = \"CM\"\n dimension_reduction_model = \"PCA\"\n k_value = 10\n dim_k_value = 40\n # K_value = 20\n # lab_folder = \"Dataset3/Labelled/Set1\"\n # unlab_folder = \"Dataset3/Unlabelled/Set 2\"\n lab_folder = get_input_folder(\"Labelled Folder\")\n unlab_folder = get_input_folder(\"Classify\")\n start = time.time()\n # ================================================================================================================\n # labelled Images\n dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value,\n folder_metadata=lab_folder,\n metadata_collection=\"labelled\")\n obj_feat_lab = dim_red.get_object_feature_matrix()\n features_list_lab = np.array(obj_feat_lab['featureVector'].tolist())\n images_list_lab = np.array(obj_feat_lab['imageId'])\n # filtering the labelled set\n dorsal_list, palmar_list = filter_images_by_label(images_list_lab)\n\n # unlabelled images\n dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value,\n folder_metadata=unlab_folder,\n metadata_collection=\"unlabelled\")\n obj_feat_unlab = dim_red.get_object_feature_matrix()\n features_list_unlab = np.array(obj_feat_unlab['featureVector'].tolist())\n images_list_unlab = np.array(obj_feat_unlab['imageId'])\n\n # ================================================================================================================\n # labelled Images\n dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value,\n folder_metadata=lab_folder,\n metadata_collection=\"labelled\")\n obj_feat_lab_1 = dim_red.get_object_feature_matrix()\n features_list_lab_1 = np.array(obj_feat_lab_1['featureVector'].tolist())\n # images_list_lab = np.array(obj_feat_lab_1['imageId'])\n # filtering the labelled set\n\n\n # unlabelled images\n dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value,\n folder_metadata=unlab_folder,\n metadata_collection=\"unlabelled\")\n obj_feat_unlab_1 = dim_red.get_object_feature_matrix()\n features_list_unlab_1 = np.array(obj_feat_unlab_1['featureVector'].tolist())\n # images_list_unlab = np.array(obj_feat_unlab['imageId'])\n features_list_lab = np.concatenate((features_list_lab, features_list_lab_1), axis=1)\n features_list_unlab = np.concatenate((features_list_unlab, features_list_unlab_1), axis=1)\n\n # ================================================================================================================\n\n dorsal_list, palmar_list = filter_images_by_label(images_list_lab)\n features_list = np.concatenate((features_list_lab, features_list_unlab))\n images_list = np.concatenate((images_list_lab, images_list_unlab))\n images_list = list(images_list)\n # Finding Similarity Matrix\n cos_sim = cosine_similarity(features_list)\n sim_graph = np.empty((0, len(cos_sim)))\n for row in cos_sim:\n k_largest = np.argsort(-np.array(row))[1:k_value + 1]\n sim_graph_row = [d if i in k_largest else 0 for i, d in enumerate(row)]\n sim_graph = np.append(sim_graph, np.array([sim_graph_row]), axis=0)\n\n row_sums = sim_graph.sum(axis=1)\n sim_graph = sim_graph / row_sums[:, np.newaxis]\n idx = 0\n results_dorsal = ppr(sim_graph, images_list, dorsal_list)\n results_palmar = ppr(sim_graph, images_list, palmar_list)\n final_results = {}\n\n for img in images_list_unlab:\n if results_dorsal[img] < results_palmar[img]:\n final_results[img] = \"dorsal\"\n else:\n final_results[img] = \"palmar\"\n\n actual_labels = fetch_actual_labels(images_list_unlab)\n print(\"Classification\")\n no_correct = 0\n correctly_classified = []\n incorrectly_classified = []\n print(\"| ImageId | Prediction | Actual |\")\n for r in final_results:\n print(\"| {} | {} | {} |\".format(r, final_results[r], actual_labels[r]))\n if final_results[r] == actual_labels[r]:\n correctly_classified.append(r)\n no_correct += 1\n else:\n incorrectly_classified.append(r)\n\n print(\"Correctly classified: {}\\n\".format(correctly_classified))\n print(\"InCorrectly classified: {}\\n\".format(incorrectly_classified))\n\n print(\"Classification Accuracy: {}%\".format(no_correct / len(images_list_unlab) * 100))\n print(\"Execution time: {} seconds\".format(time.time() - start))","def test_hdf5_convert_to_one_hot():\n skip_if_no_h5py()\n import h5py\n\n # save random data to HDF5\n handle, filename = tempfile.mkstemp()\n dataset = random_dense_design_matrix(np.random.RandomState(1),\n num_examples=10, dim=5, num_classes=3)\n with h5py.File(filename, 'w') as f:\n f.create_dataset('X', data=dataset.get_design_matrix())\n f.create_dataset('y', data=dataset.get_targets())\n\n # instantiate Train object\n trainer = yaml_parse.load(convert_to_one_hot_yaml % {'filename': filename})\n trainer.main_loop()\n\n # cleanup\n os.remove(filename)","def process_train_set(hdf5_file, train_archive, patch_archive, n_train,\n wnid_map, shuffle_seed=None):\n producer = partial(train_set_producer, train_archive=train_archive,\n patch_archive=patch_archive, wnid_map=wnid_map)\n consumer = partial(image_consumer, hdf5_file=hdf5_file,\n num_expected=n_train, shuffle_seed=shuffle_seed)\n producer_consumer(producer, consumer)","def input_setup(config):\n print(config.is_train)\n # Load data path\n if config.is_train:\n data, label = prepare_data(dataset=\"Train/DoF_Images (2)\")\n else:\n data, label = prepare_data(dataset=\"Test\")\n\n sub_input_sequence = []\n sub_label_sequence = []\n padding = abs(config.image_size - config.label_size) / 2 # 6\n nx = ny = 0\n\n if config.is_train:\n for i in range(len(data)):\n input_, label_ = preprocess(data[i], label[i], config.scale)\n\n if len(input_.shape) == 3:\n h, w, c = input_.shape\n else:\n h, w = input_.shape\n\n for x in range(0, h-config.image_size+1, config.stride):\n if i == 0:\n nx += 1; ny = 0\n for y in range(0, w-config.image_size+1, config.stride):\n if i == 0:\n ny += 1\n\n sub_input = input_[x:x+config.image_size, y:y+config.image_size] # [33 x 33]\n sub_label = label_[x+int(padding):x+int(padding)+config.label_size\n , y+int(padding):y+int(padding)+config.label_size] # [21 x 21]\n # print(sub_input.shape)\n # print(sub_label.shape)\n # Make channel value\n sub_input = sub_input.reshape([config.image_size, config.image_size, 3])\n sub_label = sub_label.reshape([config.label_size, config.label_size, 3])\n\n sub_input_sequence.append(sub_input)\n sub_label_sequence.append(sub_label)\n\n else:\n nx_l = []\n ny_l = []\n for i in range(len(data)):\n input_, label_ = preprocess(data[i], label[i], config.scale)\n\n if len(input_.shape) == 3:\n h, w, c = input_.shape\n else:\n h, w = input_.shape\n\n if w >= 4000 or h > 4000:\n input_ = cv2.resize(input_, dsize=(int(w/2), int(h/2)), interpolation=cv2.INTER_AREA)\n label_ = cv2.resize(label_, dsize=(int(w/2), int(h/2)), interpolation=cv2.INTER_AREA)\n w = int(w/2)\n h = int(h/2)\n\n # Numbers of sub-images in height and width of image are needed to compute merge operation.\n\n nx = ny = 0\n for x in range(0, h-config.image_size+1, config.stride):\n nx += 1; ny = 0\n for y in range(0, w-config.image_size+1, config.stride):\n ny += 1\n sub_input = input_[x:x+config.image_size, y:y+config.image_size] # [33 x 33]\n sub_label = label_[x+int(padding):x+int(padding)+config.label_size, y+int(padding):y+int(padding)+config.label_size] # [21 x 21]\n\n sub_input = sub_input.reshape([config.image_size, config.image_size, 3])\n sub_label = sub_label.reshape([config.label_size, config.label_size, 3])\n\n sub_input_sequence.append(sub_input)\n sub_label_sequence.append(sub_label)\n #print(\"nx: %d ny: %d\" % (nx, ny))\n nx_l.append(nx)\n ny_l.append(ny)\n \"\"\"\n len(sub_input_sequence) : the number of sub_input (33 x 33 x ch) in one image\n (sub_input_sequence[0]).shape : (33, 33, 1)\n \"\"\"\n # Make list to numpy array. With this transform\n arrdata = np.asarray(sub_input_sequence) # [?, 33, 33, 3]\n arrlabel = np.asarray(sub_label_sequence) # [?, 21, 21, 3]\n\n make_data(config, arrdata, arrlabel)\n print(\"make_data success\")\n if config.is_train:\n return nx, ny\n else:\n return nx_l, ny_l, len(data)","def initSets(self):\n data_frame = pd.read_csv(self.train_file, header=None)\n data_frame = data_frame.drop(columns=self.drop_cols)\n features = data_frame.iloc[:, :-1].values\n labels = data_frame.iloc[:, -1].values\n if self.test_file is None:\n self.train_feat, self.test_feat, self.train_labl, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\n else:\n data_frame = pd.read_csv(self.test_file, header=None)\n data_frame = data_frame.drop(columns=self.drop_cols)\n self.train_feat, _, self.train_labl, _ = train_test_split(features, labels, test_size=self.test_size)\n features = data_frame.iloc[:, :-1].values\n labels = data_frame.iloc[:, -1].values\n _, self.test_feat, _, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\n # kfold = KFold(n_splits=3)\n # self.train_index, self.test_index = kfold.split(features,labels)","def test_function_kg(test_loader, model, settype, S, lk, bk, num_iters, epsilon, num_classes, topk):\r\n\r\n det_boxes = []\r\n det_labels = []\r\n det_scores = []\r\n true_boxes = []\r\n true_labels = []\r\n true_difficulties = []\r\n true_areas = []\r\n\r\n with torch.no_grad():\r\n for i, (images, targets) in enumerate(test_loader):\r\n\r\n # Move to default device.\r\n images = [im.to(device) for im in images]\r\n\r\n # Some (1021) images of COCO contain no objects at all. These are filtered out in the data loader, but\r\n # return an empty list, which raises an error in the model, so they are skipped.\r\n if len(images) == 0:\r\n continue\r\n\r\n prediction = model(images)\r\n\r\n for p in range(len(prediction)-1):\r\n true_boxes.append(targets[p]['boxes'].to(device))\r\n true_labels.append(targets[p]['labels'].to(device))\r\n\r\n if settype == 'voc':\r\n true_difficulties.append(targets[p]['difficulties'].to(device))\r\n # true_difficulties.append(torch.zeros(len(targets[p]['boxes'])).to(device))\r\n true_areas.append(torch.zeros(len(targets[p]['boxes'])).to(device))\r\n else:\r\n true_difficulties.append(torch.zeros(len(targets[p]['boxes'])).to(device))\r\n true_areas.append(targets[p]['areas'].to(device))\r\n\r\n boxes_temp = prediction[1][0]['boxes']\r\n labels_temp = prediction[1][0]['labels']\r\n scores_temp = prediction[1][0]['scores']\r\n\r\n new_predictions = torch.zeros((boxes_temp.shape[0], num_classes)).to(device)\r\n\r\n for l in range(new_predictions.shape[0]):\r\n label = labels_temp[l] - 1\r\n new_predictions[l, label] = scores_temp[l]\r\n\r\n p_hat = find_p_hat(boxes_temp, new_predictions, bk, lk, S, num_iters, epsilon)\r\n\r\n predk, boxk, labk, scok = find_top_k(p_hat, boxes_temp, topk)\r\n\r\n det_boxes.append(boxk)\r\n det_labels.append(labk)\r\n det_scores.append(scok)\r\n\r\n del prediction\r\n torch.cuda.empty_cache()\r\n\r\n return det_boxes, det_labels, det_scores, true_boxes, true_labels, true_difficulties, true_areas","def create_train_validate_test_sets(self,X,Y):\n\n\t\tprint \"Size of the original images\"\n\n\t\tX = np.asarray(X, dtype=theano.config.floatX)\n\t\t\n\t\ttrain_length = int(round(len(X) * 0.60))\n\t\tvalid_length = int(round(len(X) * 0.20))\n\t\ttest_length = int(round(len(X) * 0.20))\n\n\t\tX_train = X[0:train_length]\n\t\tX_valid = X[train_length: (train_length + valid_length)]\n\t\tX_test = X[-test_length:]\n\n\t\t# sample = X_train[0].reshape(64,64)\n\n\t\t# X_train = X_train.transpose(0, 3, 1, 2)\n\t\t# X_valid = X_valid.transpose(0, 3, 1, 2)\n\t\t# X_test = X_test.transpose(0, 3, 1, 2)\n\n\t\t# X = X.transpose(0, 3, 1, 2)\n\n\t\tX_train = map(self.flaten_aux, X_train)\n\t\tX_valid = map(self.flaten_aux, X_valid)\n\t\tX_test = map(self.flaten_aux, X_test)\n\n\t\t# X = map(self.flaten_aux, X)\n\n\t\t#print X_train.shape\n\t\t#X = X.transpose(0, 3, 1, 2)\n\t\t# X = np.asarray(X, dtype=theano.config.floatX)\n\t\t# X = X.reshape((21, 3, 64, 64))\n\t\t# print X.shape\n\t\t# #X_train = X_train.transpose(0, 3, 1, 2)\n\t\t# #print X[0].\n\t\t# im = Image.fromarray(X[0],mode=\"RGB\")\n\t\t# im.show()\n\t\t#self.reconstructImage(X[0]).show()\n\t\t# sample = X_train[0].reshape(64,64)\n\t\t# Image.fromarray(sample,mode=\"L\").show()\n\n\t\t#X = map(self.flaten_aux, X)\n\n\t\t# X_train = X[0:train_length]\n\t\t# X_valid = X[train_length: (train_length + valid_length)]\n\t\t# X_test = X[-test_length:]\n\n\t\tY_train = Y[0:train_length]\n\t\tY_valid = Y[train_length:(train_length + valid_length)]\n\t\tY_test = Y[-test_length:]\n\n\t\t#pkl_file = open( '../data/lb.pkl', 'rb')\n\t\t#lb = cPickle.load(pkl_file)\n\n\t\t#arr = np.array(np.round((X_train[0] * 256).reshape((64,64))),dtype=np.uint8)\n\t\t# Image.fromarray(arr,mode=\"L\").show()\n\t\t# print lb.classes_\n\t\t# print Y_train[0]\n\n\t\ttrain_set = [X_train,Y_train]\n\t\tvalid_set = [X_valid,Y_valid]\n\t\ttest_set = [X_test,Y_test]\n\t\tinput = [X,Y]\n\n\t\tif self.verbose:\n\t\t\tprint \"X_train {} X_validation {} X_test {}\".format(len(X_train),len(X_valid),len(X_test))\n\t\t\tprint \"Y_train {} Y_validation {} Y_test {}\".format(len(Y_train),len(Y_valid),len(Y_test))\n\n\t\toutput = open(self.data_path + 'train_set.pkl', 'wb')\n\t\tcPickle.dump(train_set, output,protocol=-1)\n\t\toutput.close()\n\n\t\toutput = open(self.data_path + 'valid_set.pkl', 'wb')\n\t\tcPickle.dump(valid_set, output,protocol=-1)\n\t\toutput.close()\n\n\t\toutput = open(self.data_path + 'test_set.pkl', 'wb')\n\t\tcPickle.dump(test_set, output,protocol=-1)\n\t\toutput.close()\n\t\t\n\t\treturn train_set,valid_set,test_set","def __init__(self, args):\n\n self.args = args\n\n \"\"\"class args:\n rows=16\n cols=640\n baseinfo=10\n hps = 128\n hpdist = 33\n \"\"\"\n\n inputs = KK.layers.Input(shape=(args.rows,args.cols,args.baseinfo))\n x = KK.layers.Conv2D(64, kernel_size= (1, 6), strides=(1,5), activation='relu')(inputs)\n x = KK.layers.Conv2D(64, (16, 1), activation='relu')(x)\n bottle = KK.layers.Flatten()(x) # This is now the bottleneck\n\n self.model = KK.models.Model(inputs=inputs, outputs=[bottle])\n self.model.summary()\n\n ################################\n # predict hp lengths\n predsHPLEN = []\n for ii in range( args.hps ):\n tmp = KK.layers.Dense(args.hpdist, activation='softmax')(bottle)\n # print(\"tmp\",tmp.shape) # tmp (N, 33)\n predsHPLEN.append(tmp)\n\n # # stack into one array yielding (128,N,33)\n predsHPLEN2 = KK.backend.stack(predsHPLEN)\n print(\"predsHPLEN2.shape\", predsHPLEN2.shape)\n\n # # permute to yield (N,128,33) to compare against truth\n predictionsHPLEN = KK.backend.permute_dimensions(predsHPLEN2,(1,0,2))\n print(\"predictionsHPLEN.shape\",predictionsHPLEN.shape) # predictions.shape (?, 128, 33)\n\n ################################\n # predict hp base IDentity\n predsHPID = []\n for ii in range( args.hps ):\n tmp = KK.layers.Dense(4, activation='softmax')(bottle)\n # print(\"tmp\",tmp.shape) # tmp (N, 4)\n predsHPID.append(tmp)\n\n # # stack into one array yielding (128,N,4)\n predsHPID2 = KK.backend.stack(predsHPID)\n print(\"predsHPID2.shape\", predsHPID2.shape)\n\n # # permute to yield (N,128,4) to compare against truth\n predictionsHPID = KK.backend.permute_dimensions(predsHPID2,(1,0,2))\n print(\"predictionsHPID.shape\",predictionsHPID.shape) # predictions.shape (?, 128, 4)\n\n ################################\n self.model = KK.models.Model(inputs=inputs, outputs=[predictionsHPID,predictionsHPLEN])\n\n #self.model.summary()\n # # ValueError: You tried to call `count_params` on stack, but the layer isn't built. You can build it manually via: `stack.build(batch_input_shape)`.\n\n self.model.compile(optimizer=\"adam\", loss=\"categorical_crossentropy\", metrics=[\"categorical_accuracy\",\"kullback_leibler_divergence\"])\n\n # # instrument tensorboard\n # tf.summary.histogram('output', self.output)\n # tf.summary.histogram('softmax_w', softmax_w)\n # tf.summary.histogram('logits', self.logits)\n # tf.summary.histogram('probs', self.probs)\n # tf.summary.scalar('train_loss', self.cost)","def get_model_2(parameters):\n # Parameters\n BANDS = parameters['num_features']\n CLASSES = parameters['num_classes']\n \n # Sequential model\n model = keras.models.Sequential()\n \n # Add convolution (1)\n # -------------------\n # Input_shape (batch, rows, cols, channels) = (-, 9, BANDS, 1)\n # Output_shape (batch, rows, cols, channels) = (-, BANDS - 15, 1, 32)\n model.add(keras.layers.Conv2D(filters=32,\n kernel_size=(9, 16),\n padding='same',\n data_format=\"channels_last\",\n activation='tanh',\n input_shape=(9, BANDS,1)))\n \n # Add convolution (2)\n # -------------------\n # Input_shape (batch, rows, cols, channels) = (-, BANDS - 15, 1, 32)\n # Output_shape (batch, rows, cols, channels) = (-, BANDS - 30, 1, 32)\n model.add(keras.layers.Conv2D(filters=32,\n kernel_size=(1, 16),\n padding='same',\n data_format=\"channels_last\",\n activation='tanh'))\n \n # Add convolution (3)\n # -------------------\n # Input_shape (batch, rows, cols, channels) = (-, BANDS - 30, 1, 32)\n # Output_shape (batch, rows, cols, channels) = (-, BANDS - 45, 1, 32)\n model.add(keras.layers.Conv2D(filters=32,\n kernel_size=(1, 16),\n padding='same',\n data_format=\"channels_last\",\n activation='tanh'))\n \n # Flatten before dense layer\n model.add(keras.layers.Flatten())\n \n # Add fully connected (4)\n # -----------------------\n # Intput_shape (batch, rows, cols, channels) = (-, (BANDS - 45) x 1 x 32)\n # Output_shape (batch, dim) = (-, 800)\n model.add(keras.layers.Dense(units=800,\n activation='tanh'))\n \n # Add fully connected (5)\n # -----------------------\n # Intput_shape (batch, dim) = (-, 800)\n # Output_shape (batch, dim) = (-, 800)\n model.add(keras.layers.Dense(units=800,\n activation='softmax'))\n \n # Add fully connected to reduce to number of categories\n # -----------------------------------------------------\n # Intput_shape (batch, dim) = (-, 800)\n # Output_shape (batch, dim) = (-, CLASSES)\n model.add(keras.layers.Dense(units=CLASSES,\n activation='softmax'))\n \n # Compile model\n model.compile(optimizer='adam',\n loss='categorical_crossentropy',\n metrics=['accuracy'])\n \n # Print the model summary to output file\n # To print to stdout: model.summary()\n with open(OUTPUT_FILE, 'a') as f:\n # Pass the file handle in as a lambda function to make it callable\n model.summary(print_fn=lambda x: f.write(x + '\\n'))\n \n # Return the model\n return model","def data_set_maker():\n\n # crate a folder in your code directory and name it: \"files\". put the .npy files iside that folder\n path = os.getcwd() # reads the current path\n x_train = np.load(path + '/files/tinyX.npy', 'r') # reads the input file\n y_train = np.load(path + '/files/tinyY.npy', 'r') # reads the input file\n x_test = np.load(path + '/files/tinyX_test.npy', 'r') # reads the input file\n x_train, y_train = shuffle(x_train, y_train)\n\n return x_train, y_train, x_test","def index_subset(subset, numTestClasses=3, randomSeed=123):\n print(\"datasets.py is ingesting the DF dataset from data/DC.npz\")\n npzfile = np.load(\"data/DC.npz\", allow_pickle=True)\n data = npzfile[\"data\"]\n labels = npzfile[\"labels\"]\n npzfile.close()\n distinctLabelCount= len(set(labels))\n \n #print(\"data\", data.shape)\n #print(\"labels\", labels.shape)\n #print(\"distinctLabelCount\", distinctLabelCount)\n \n #random.seed(randomSeed)\n testClasses = random.sample(range(0,distinctLabelCount),numTestClasses)\n testClasses = [np.float64(i) for i in testClasses]\n \n \n mask = np.isin(labels,testClasses)\n\n X_test = data[np.where(mask)]\n X_train = data[np.where(~mask)]\n y_test = labels[np.where(mask)]\n y_train = labels[np.where(~mask)]\n \n if subset==\"background\":\n print(\"Current working directory is \", os.getcwd())\n X = X_train\n y = y_train\n print(\"DC background data shape\", X.shape)\n elif subset==\"evaluation\":\n X = X_test\n y = y_test\n print(\"DC evaluation data shape\", X.shape)\n images = []\n \n #print(\"y shape\", y.shape)\n \n \n for i in range(y.shape[0]):\n images.append({\n 'subset': subset,\n 'class_name': y[i],\n 'data': X[i].reshape(1,X[1].shape[0]) # This is the shape needed for Matching Networks\n #'data': X[i] #.reshape(X[1].shape[0]) # This is the shape needed for MAML\n })\n \n return images","def create_dummy_data():\n data = loadmat(join(project_root, './data/lungs.mat'))['seq']\n nx, ny, nt = data.shape\n ny_red = 8\n sl = ny//ny_red\n data_t = np.transpose(data, (2, 0, 1))\n\n data_t[:, :, :sl*4]\n train_slice = data_t[:, :, :sl*4]\n validate_slice = data_t[:, :, ny//2:ny//2+ny//4]\n test_slice = data_t[:, :, ny//2+ny//4]\n\n # Synthesize data by extracting patches\n train = np.array([data_t[..., i:i+sl] for i in np.random.randint(0, sl*3, 20)])\n validate = np.array([data_t[..., i:i+sl] for i in (sl*4, sl*5)])\n test = np.array([data_t[..., i:i+sl] for i in (sl*6, sl*7)])\n\n return train, validate, test","def _demo_mm_inputs(input_shape: tuple, num_classes: int):\n (N, C, H, W) = input_shape\n rng = np.random.RandomState(0)\n imgs = rng.rand(*input_shape)\n gt_labels = rng.randint(\n low=0, high=num_classes, size=(N, 1)).astype(np.uint8)\n mm_inputs = {\n 'imgs': torch.FloatTensor(imgs).requires_grad_(False),\n 'gt_labels': torch.LongTensor(gt_labels),\n }\n return mm_inputs","def prepare_data(self):\n data = self._get_dataset(self.hparams.dataset_path)\n label_encoder = data[\"label_encoder\"]\n del data[\"label_encoder\"]\n\n click.secho(\"Building inputs and labels.\", fg=\"yellow\")\n datasets = {\n \"train\": defaultdict(list),\n \"valid\": defaultdict(list),\n \"test\": defaultdict(list),\n }\n for dataset_name, dataset in data.items():\n for sample in dataset:\n instance = self.build_input(\n self.tokenizer, sample[\"text\"], label_encoder, sample[\"label\"]\n )\n for input_name, input_array in instance.items():\n datasets[dataset_name][input_name].append(input_array)\n\n click.secho(\"Padding inputs and building tensors.\", fg=\"yellow\")\n tensor_datasets = {\"train\": [], \"valid\": [], \"test\": []}\n for dataset_name, dataset in datasets.items():\n dataset = self.pad_dataset(dataset, padding=self.tokenizer.pad_index)\n for input_name in MODEL_INPUTS:\n if input_name == \"labels\":\n tensor = torch.tensor(dataset[input_name], dtype=torch.float32)\n else:\n tensor = torch.tensor(dataset[input_name])\n tensor_datasets[dataset_name].append(tensor)\n\n self.train_dataset = TensorDataset(*tensor_datasets[\"train\"])\n self.valid_dataset = TensorDataset(*tensor_datasets[\"valid\"])\n self.test_dataset = TensorDataset(*tensor_datasets[\"test\"])\n click.secho(\n \"Train dataset (Batch, Candidates, Seq length): {}\".format(\n self.train_dataset.tensors[0].shape\n ),\n fg=\"yellow\",\n )\n click.secho(\n \"Valid dataset (Batch, Candidates, Seq length): {}\".format(\n self.valid_dataset.tensors[0].shape\n ),\n fg=\"yellow\",\n )\n click.secho(\n \"Test dataset (Batch, Candidates, Seq length): {}\".format(\n self.test_dataset.tensors[0].shape\n ),\n fg=\"yellow\",\n )","def output_rule_feature_matrices():\n with open(config.data_path + config.sentiment_seed, 'rb') as input_file:\n sentiment_dict = pickle.load(input_file)\n seed_sentiments = set(sentiment_dict.keys())\n \n for i in range(len(config.file_names)):\n if i is 5:\n print('processing ', config.file_names[i])\n fname = config.file_names[i]\n feature_x, feature_y, opinion_x, opinion_y = text_to_matrix(\n fname, seed_sentiments)\n feature_x = np.transpose(feature_x)\n opinion_x = np.transpose(opinion_x)\n with open('../results/' + fname + '_rule_feature_matrix.pickle', 'wb') as f:\n pickle.dump(feature_x, f)\n with open('../results/' + fname + '_rule_opinion_matrix.pickle', 'wb') as f:\n pickle.dump(opinion_x, f)\n\n with open('../results/' + fname + '_feature_label.pickle', 'wb') as f:\n pickle.dump(feature_y.ravel(), f)\n with open('../results/' + fname + '_opinion_label.pickle', 'wb') as f:\n pickle.dump(opinion_y.ravel(), f)","def create_train_test_sets(conform_shape=True, indi_proportion=0.50, incl_group_imgs=True):\r\n X_train_indi, y_train_indi = build_dataframe('Individual_Training_Images',\r\n img_input_shape, conform_shape=conform_shape)\r\n X_test_indi, y_test_indi = build_dataframe('Individual_Test_Images',\r\n img_input_shape, conform_shape=conform_shape)\r\n \r\n X_train_group, y_train_group = build_dataframe('Group_Training_Images',\r\n img_input_shape, conform_shape=conform_shape)\r\n X_test_group, y_test_group = build_dataframe('Group_Test_Images',\r\n img_input_shape, conform_shape=conform_shape)\r\n \r\n X_train_indi, y_train_indi = subsample_dataframe(X_train_indi, y_train_indi,indi_proportion)\r\n \r\n if incl_group_imgs:\r\n X_train = np.concatenate([X_train_indi,X_train_group])\r\n y_train = np.concatenate([y_train_indi,y_train_group])\r\n else: \r\n X_train = X_train_indi.copy()\r\n y_train = y_train_indi.copy()\r\n\r\n return X_train, y_train, X_test_indi, y_test_indi, X_test_group, y_test_group","def train(\n train_sets: tuple,\n test_sets: tuple,\n input_shape: tuple = (1, 128, 128, 1),\n model_version=\"1.0.0\",\n epochs: int = 100,\n classes: int = 2,\n batch_size: int = 1,\n verbose=1,\n out_dir: str = \"saved_models\"):\n (x_train, y_train), (x_test, y_test) = train_sets, test_sets\n y_train = keras.utils.to_categorical(y_train, classes)\n y_test = keras.utils.to_categorical(y_test, classes)\n m = get_model(model_version)\n if not m:\n return\n model = m.build_model(input_shape)\n model.compile(\n loss=BinaryCrossentropy(),\n optimizer=RMSprop(learning_rate=0.0001),\n metrics=['accuracy']\n )\n saver = ModelSaver(out_dir)\n csv_logger = CSVLogger(\n \"%s/%s/log.csv\" %\n (out_dir, datetime.datetime.now().date().strftime(\"%Y_%m_%d\")),\n append=True,\n separator=','\n )\n history = model.fit(\n x_train,\n y_train,\n batch_size=batch_size,\n epochs=epochs,\n verbose=verbose,\n validation_data=(x_test, y_test),\n callbacks=[saver, csv_logger]\n )\n model.save(\"%s/%s/final.hd5\" %\n (out_dir, datetime.datetime.now().date().strftime(\"%Y_%m_%d\")))\n print(\"Model saved in %s as final.hd5\" % out_dir)\n plot_results(\n history,\n epochs,\n out_dir\n )","def __init__(\n self,\n numpy_rng,\n train_set_x,\n train_set_y,\n hidden_layers_sizes,\n n_ins=784,\n n_outs=10\n ):\n\n self.sigmoid_layers = []\n self.AE_layers = []\n self.params = []\n self.n_layers = len(hidden_layers_sizes)\n self.train_set_x = train_set_x\n self.train_set_y = train_set_y\n\n assert self.n_layers > 0\n\n self.x = T.matrix('x') # the data is presented as rasterized images\n self.y = T.ivector('y') # the labels are presented as 1D vector of\n\n for i in xrange(self.n_layers): # used to be n layers\n\n # construct the sigmoid layer = encoder stack\n if i == 0:\n layer_input = self.x\n else:\n layer_input = self.sigmoid_layers[-1].output\n\n sigmoid_layer = HiddenLayer(rng=numpy_rng,\n input=layer_input,\n n_in=(n_ins if i == 0 else\n hidden_layers_sizes[i-1]),\n n_out=hidden_layers_sizes[i],\n activation=T.nnet.sigmoid)\n\n # add the layer to our list of layers\n self.sigmoid_layers.append(sigmoid_layer)\n self.params.extend(sigmoid_layer.params)\n\n # init the DA_layer, takes weights from sigmoid layer\n AE_layer = AutoEncoder(\n numpy_rng=numpy_rng,\n input=layer_input,\n n_visible=(n_ins if i == 0 else hidden_layers_sizes[i-1]),\n n_hidden=hidden_layers_sizes[i],\n W=sigmoid_layer.W,\n bhid=sigmoid_layer.b)\n\n self.AE_layers.append(AE_layer)\n\n # on top of the layers\n # log layer for fine-tuning\n self.logLayer = LogisticRegression(\n input=self.sigmoid_layers[-1].output,\n n_in=hidden_layers_sizes[-1],\n n_out=n_outs\n )\n self.params.extend(self.logLayer.params)\n self.finetune_cost = self.logLayer.negative_log_likelihood(self.y)\n self.errors = self.logLayer.errors(self.y)","def createDataset_inpainting(outputPath, imagePathList, labelList):\n assert (len(imagePathList) == len(box_x_list) == len(box_y_list))\n nSamples = len(imagePathList)\n if not os.path.exists(outputPath):\n os.mkdir(outputPath)\n env = lmdb.open(outputPath, map_size=1099511627776)\n cache = {}\n cnt = 1\n for i in range(nSamples):\n imagePath = imagePathList[i]\n box_x = box_x_list[i]\n box_y = box_y_list[i]\n if len(box_x) == 0:\n continue\n if not os.path.exists(imagePath):\n print('%s does not exist' % imagePath)\n continue\n with open(imagePath, 'rb') as f:\n imageBin = f.read()\n\n imageKey = 'image-%09d' % cnt\n cache[imageKey] = imageBin\n box_x_Key = 'boxes_x-%09d' % cnt\n box_y_Key = 'boxes_y-%09d' % cnt\n cache[box_x_Key] = box_x.encode()\n cache[box_y_Key] = box_y.encode()\n\n if labelList:\n labelKey = 'label-%09d' % cnt\n cache[labelKey] = labelList[i].encode()\n if region_mask_list:\n region_mask_Key = 'region_mask-%09d' % cnt\n cache[region_mask_Key] = open(region_mask_list[i], 'rb').read()\n if pixel_mask_list:\n pixel_mask_Key = 'pixel_mask-%09d' % cnt\n cache[pixel_mask_Key] = open(pixel_mask_list[i], 'rb').read()\n # embed()\n if cnt % 1000 == 0:\n writeCache(env, cache)\n cache = {}\n print('Written %d / %d' % (cnt, nSamples))\n cnt += 1\n nSamples = cnt - 1\n cache['num-samples'] = str(nSamples).encode()\n writeCache(env, cache)\n print('Created dataset with %d samples' % nSamples)","def build_full_trainset(self):\n\n return self.construct_trainset(self.raw_ratings)","def make_dataset(\n *,\n k_size: int = 5,\n j_size: int,\n i_size: int,\n time_size: int = 4,\n grid_type: Type[ShocGridGenerator] = DiagonalShocGrid,\n corner_size: int = 0,\n) -> xarray.Dataset:\n coordinate_centre_mask = numpy.full((j_size, i_size), True)\n # Cut a chunk out of the corner where the coordinates will not be defined.\n if corner_size > 1:\n coordinate_centre_mask[-(corner_size - 1):, :+(corner_size - 1)] = False\n\n # SHOC files have a 1-cell border around the outside where the cells have\n # coordinates, but no data.\n wet_centre_mask = numpy.full((j_size, i_size), True)\n if corner_size > 0:\n wet_centre_mask[-corner_size:, :+corner_size] = False\n wet_centre_mask[-corner_size:, -corner_size:] = False\n wet_centre_mask[:+1, :] = False\n wet_centre_mask[-1:, :] = False\n wet_centre_mask[:, :+1] = False\n wet_centre_mask[:, -1:] = False\n wet_mask = c_mask_from_centres(wet_centre_mask, {\n ArakawaCGridKind.face: ('j_centre', 'i_centre'),\n ArakawaCGridKind.back: ('j_back', 'i_back'),\n ArakawaCGridKind.left: ('j_left', 'i_left'),\n ArakawaCGridKind.node: ('j_node', 'i_node'),\n })\n\n # These DataArrays are the long/lats of the grid corners. The centres are\n # derived from these by averaging the surrounding four corners.\n grid = grid_type(j=j_size, i=i_size, face_mask=coordinate_centre_mask)\n layers = ShocLayerGenerator(k=k_size)\n\n t = xarray.DataArray(\n # Note: Using pandas.date_range() directly here will lead to strange\n # behaviours, where the `record` dimension becomes a data variable with\n # a datetime64 dtype. Using a list of datetimes instead seems to avoid\n # this, resulting in record simply being a dimension.\n data=list(pandas.date_range(\"2021-11-11\", periods=time_size)),\n dims=[\"record\"],\n attrs={\n \"long_name\": \"Time\",\n \"standard_name\": \"time\",\n \"coordinate_type\": \"time\",\n },\n )\n # Note: xarray will reformat this in to 1990-01-01T00:00:00+10:00, which\n # EMS fails to parse. There is no way around this using xarray natively,\n # you have to adjust it with nctool after saving it.\n t.encoding[\"units\"] = \"days since 1990-01-01 00:00:00 +10\"\n\n botz = xarray.DataArray(\n data=numpy.random.random((j_size, i_size)) * 10 + 50,\n dims=wet_mask[\"face_mask\"].dims,\n attrs={\n \"units\": \"metre\",\n \"long_name\": \"Z coordinate at sea-bed at cell centre\",\n \"standard_name\": \"depth\",\n \"positive\": \"down\",\n \"outside\": \"9999\",\n \"missing_value\": -99.,\n }\n ).where(wet_mask.data_vars[\"face_mask\"])\n botz.values[1, 1] = -99.\n\n eta = xarray.DataArray(\n data=numpy.random.normal(0, 0.2, (time_size, j_size, i_size)),\n dims=[\"record\", *wet_mask[\"face_mask\"].dims],\n attrs={\n \"units\": \"metre\",\n \"long_name\": \"Surface elevation\",\n \"standard_name\": \"sea_surface_height_above_geoid\",\n }\n ).where(wet_mask.data_vars[\"face_mask\"])\n temp = xarray.DataArray(\n data=numpy.random.normal(12, 0.5, (time_size, k_size, j_size, i_size)),\n dims=[\"record\", \"k_centre\", *wet_mask[\"face_mask\"].dims],\n attrs={\n \"units\": \"degrees C\",\n \"long_name\": \"Temperature\",\n },\n ).where(wet_mask.data_vars[\"face_mask\"])\n\n u1 = xarray.DataArray(\n data=numpy.random.normal(0, 2, (time_size, k_size, j_size, i_size + 1)),\n dims=[\"record\", \"k_centre\", *wet_mask.data_vars[\"left_mask\"].dims],\n attrs={\n \"units\": \"metre second-1\",\n \"long_name\": \"I component of current at left face\",\n }\n )\n u2 = xarray.DataArray(\n data=numpy.random.normal(0, 2, (time_size, k_size, j_size + 1, i_size)),\n dims=[\"record\", \"k_centre\", *wet_mask.data_vars[\"back_mask\"].dims],\n attrs={\n \"units\": \"metre per second\",\n \"long_name\": \"I component of current at back face\",\n }\n )\n flag = xarray.DataArray(\n data=numpy.random.randint(0, 256, (time_size, k_size, j_size + 1, i_size + 1)),\n dims=[\"record\", \"k_centre\", *wet_mask.data_vars[\"node_mask\"].dims],\n attrs={\"long_name\": \"SHOC masking flags\"},\n )\n\n dataset = xarray.Dataset(\n data_vars={\n **layers.standard_vars,\n **grid.standard_vars,\n \"botz\": botz,\n \"t\": t,\n \"eta\": eta,\n \"temp\": temp,\n \"u1\": u1,\n \"u2\": u2,\n \"flag\": flag,\n },\n attrs={\n \"title\": \"Example SHOC dataset\",\n \"ems_version\": \"v1.2.3 fake\",\n \"Conventions\": \"CMR/Timeseries/SHOC\",\n \"nce1\": j_size,\n \"nce2\": i_size,\n \"nfe1\": j_size + 1,\n \"nfe2\": i_size + 1,\n \"gridtype\": \"NUMERICAL\",\n },\n )\n dataset.encoding[\"unlimited_dims\"] = {\"record\"}\n return dataset","def get_P5(self):\n msk = self.load_mask()\n dimtgt = sum(1-v for v in msk)\n dimsrc = self.vs.get_dimension() if self.vs.is_valid() else 0\n M = matrix(dimtgt, dimsrc, sparse = True)\n j = 0\n for (i, v) in enumerate(msk):\n if v == 0:\n M[j, i] = 1\n j=j+1\n return M","def _build_model(self):\n\n with tf.variable_scope(\"Matchnet\", reuse=tf.AUTO_REUSE):\n # For determining the runtime shape\n x_shp = tf.shape(self.x_in)\n\n # -------------------- Network archintecture --------------------\n # Build graph\n print(\"Building Graph\")\n self.logits = build_graph(self.x_in, self.is_training, self.config)\n # ---------------------------------------------------------------\n\n # Turn into weights for each sample\n weights = tf.nn.relu(tf.tanh(self.logits))\n\n # Make input data (num_img_pair x num_corr x 4)\n xx = tf.transpose(tf.reshape(\n self.x_in, (x_shp[0], x_shp[2], 4)), (0, 2, 1))\n\n # Create the matrix to be used for the eight-point algorithm\n X = tf.transpose(tf.stack([\n xx[:, 2] * xx[:, 0], xx[:, 2] * xx[:, 1], xx[:, 2],\n xx[:, 3] * xx[:, 0], xx[:, 3] * xx[:, 1], xx[:, 3],\n xx[:, 0], xx[:, 1], tf.ones_like(xx[:, 0])\n ], axis=1), (0, 2, 1))\n print(\"X shape = {}\".format(X.shape))\n wX = tf.reshape(weights, (x_shp[0], x_shp[2], 1)) * X\n print(\"wX shape = {}\".format(wX.shape))\n XwX = tf.matmul(tf.transpose(X, (0, 2, 1)), wX)\n print(\"XwX shape = {}\".format(XwX.shape))\n\n # Recover essential matrix from self-adjoing eigen\n e, v = tf.self_adjoint_eig(XwX)\n self.e_hat = tf.reshape(v[:, :, 0], (x_shp[0], 9))\n # Make unit norm just in case\n self.e_hat /= tf.norm(self.e_hat, axis=1, keep_dims=True)","def test_filter(self):\n file_name = \"test_filter.hdf5\"\n dataset_file_filter = h5py.File(os.path.join(tmp_path, file_name), \"w\")\n for view_index, (view_name, view, is_sparse) in enumerate(\n zip(self.view_names, self.views, self.are_sparse)):\n view_dataset = dataset_file_filter.create_dataset(\n \"View\" + str(view_index),\n view.shape,\n data=view)\n view_dataset.attrs[\"name\"] = view_name\n view_dataset.attrs[\"sparse\"] = is_sparse\n labels_dataset = dataset_file_filter.create_dataset(\"Labels\",\n shape=self.labels.shape,\n data=self.labels)\n labels_dataset.attrs[\"names\"] = [label_name.encode()\n for label_name in self.labels_names]\n meta_data_grp = dataset_file_filter.create_group(\"Metadata\")\n meta_data_grp.attrs[\"nbView\"] = len(self.views)\n meta_data_grp.attrs[\"nbClass\"] = len(np.unique(self.labels))\n meta_data_grp.attrs[\"datasetLength\"] = len(self.labels)\n dataset_object = dataset.HDF5Dataset(hdf5_file=dataset_file_filter)\n dataset_object.filter(np.array([0, 1, 0]), [\"0\", \"1\"], [1, 2, 3],\n [\"ViewN0\"], tmp_path)\n self.assertEqual(dataset_object.nb_view, 1)\n np.testing.assert_array_equal(dataset_object.get_labels(), [0, 1, 0])\n dataset_object.dataset.close()\n os.remove(os.path.join(tmp_path, \"test_filter_temp_filter.hdf5\"))\n os.remove(os.path.join(tmp_path, \"test_filter.hdf5\"))","def _create_projection_datasets(self):\n # First grab the spectroscopic indices and values and position indices\n self._sho_spec_inds = self.h5_main.h5_spec_inds\n self._sho_spec_vals = self.h5_main.h5_spec_vals\n self._sho_pos_inds = self.h5_main.h5_pos_inds\n\n fit_dim_ind = self.h5_main.spec_dim_labels.index(self._fit_dim_name)\n\n self._fit_spec_index = fit_dim_ind\n self._fit_offset_index = 1 + fit_dim_ind\n\n # Calculate the number of loops per position\n cycle_start_inds = np.argwhere(self._sho_spec_inds[fit_dim_ind, :] == 0).flatten()\n tot_cycles = cycle_start_inds.size\n\n # Make the results group\n self._h5_group = create_results_group(self.h5_main, 'Loop_Fit')\n write_simple_attrs(self._h5_group, {'projection_method': 'pycroscopy BE loop model'})\n\n # Write datasets\n self.h5_projected_loops = create_empty_dataset(self.h5_main, np.float32, 'Projected_Loops',\n h5_group=self._h5_group)\n\n h5_loop_met_spec_inds, h5_loop_met_spec_vals = write_reduced_spec_dsets(self._h5_group, self._sho_spec_inds,\n self._sho_spec_vals, self._fit_dim_name,\n basename='Loop_Metrics')\n\n self.h5_loop_metrics = write_main_dataset(self._h5_group, (self.h5_main.shape[0], tot_cycles), 'Loop_Metrics',\n 'Metrics', 'compound', None, None, dtype=loop_metrics32,\n h5_pos_inds=self.h5_main.h5_pos_inds,\n h5_pos_vals=self.h5_main.h5_pos_vals,\n h5_spec_inds=h5_loop_met_spec_inds,\n h5_spec_vals=h5_loop_met_spec_vals)\n\n # Copy region reference:\n copy_region_refs(self.h5_main, self.h5_projected_loops)\n copy_region_refs(self.h5_main, self.h5_loop_metrics)\n\n self.h5_main.file.flush()\n self._met_spec_inds = self.h5_loop_metrics.h5_spec_inds\n\n return","def setUp(self):\n self.batch_size = 8\n num_keypoints = 16\n self.data_batch = []\n self.data_samples = []\n\n for i in range(self.batch_size):\n gt_instances = InstanceData()\n keypoints = np.zeros((1, num_keypoints, 2))\n keypoints[0, i] = [0.5 * i, 0.5 * i]\n gt_instances.keypoints = keypoints + 1.0\n gt_instances.keypoints_visible = np.ones(\n (1, num_keypoints, 1)).astype(bool)\n gt_instances.keypoints_visible[0, (2 * i) % 8, 0] = False\n gt_instances.bboxes = np.random.random((1, 4)) * 20 * i\n gt_instances.head_size = np.random.random((1, 1)) * 10 * i\n\n pred_instances = InstanceData()\n pred_instances.keypoints = keypoints\n\n data = {'inputs': None}\n data_sample = {\n 'gt_instances': gt_instances.to_dict(),\n 'pred_instances': pred_instances.to_dict(),\n }\n\n self.data_batch.append(data)\n self.data_samples.append(data_sample)","def build():\n if not os.path.exists(ZIP_DATASET_PATH):\n raise RuntimeError('Unable to find the zip dataset at %s' % ZIP_DATASET_PATH)\n\n # Extracting\n extract_dir = os.path.join(os.path.dirname(ZIP_DATASET_PATH), 'zip_dataset')\n if not os.path.exists(extract_dir):\n LOGGER.info('... Extracting files from zip dataset.')\n with zipfile.ZipFile(ZIP_DATASET_PATH, 'r') as zip_dataset:\n zip_dataset.extractall(extract_dir)\n\n # Additional information we also want to store\n map_object = Map()\n all_powers = get_map_powers(map_object)\n sc_to_win = len(map_object.scs) // 2 + 1\n\n hash_table = {} # zobrist_hash: [{game_id}/{phase_name}]\n moves = {} # Moves frequency: {move: [nb_no_press, nb_press]}\n nb_phases = OrderedDict() # Nb of phases per game\n end_scs = {'press': {power_name: {nb_sc: [] for nb_sc in range(0, sc_to_win + 1)} for power_name in all_powers},\n 'no_press': {power_name: {nb_sc: [] for nb_sc in range(0, sc_to_win + 1)} for power_name in all_powers}}\n\n # Building\n dataset_index = {}\n LOGGER.info('... Building HDF5 dataset.')\n with multiprocessing.Pool() as pool:\n with h5py.File(DATASET_PATH, 'w') as hdf5_dataset, open(PROTO_DATASET_PATH, 'wb') as proto_dataset:\n\n for json_file_path in glob.glob(extract_dir + '/*.jsonl'):\n LOGGER.info('... Processing: %s', json_file_path)\n category = json_file_path.split('/')[-1].split('.')[0]\n dataset_index[category] = set()\n\n # Processing file using pool\n with open(json_file_path, 'r') as json_file:\n lines = json_file.read().splitlines()\n for game_id, saved_game_zlib in tqdm(pool.imap_unordered(process_game, lines), total=len(lines)):\n if game_id is None:\n continue\n saved_game_proto = zlib_to_proto(saved_game_zlib, SavedGameProto)\n\n # Saving to disk\n hdf5_dataset[game_id] = np.void(saved_game_zlib)\n write_proto_to_file(proto_dataset, saved_game_proto, compressed=False)\n dataset_index[category].add(game_id)\n\n # Recording additional info\n get_end_scs_info(saved_game_proto, game_id, all_powers, sc_to_win, end_scs)\n get_moves_info(saved_game_proto, moves)\n nb_phases[game_id] = len(saved_game_proto.phases)\n\n # Recording hash of each phase\n for phase in saved_game_proto.phases:\n hash_table.setdefault(phase.state.zobrist_hash, [])\n hash_table[phase.state.zobrist_hash] += ['%s/%s' % (game_id, phase.name)]\n\n # Storing info to disk\n with open(DATASET_INDEX_PATH, 'wb') as file:\n pickle.dump(dataset_index, file, pickle.HIGHEST_PROTOCOL)\n with open(END_SCS_DATASET_PATH, 'wb') as file:\n pickle.dump(end_scs, file, pickle.HIGHEST_PROTOCOL)\n with open(HASH_DATASET_PATH, 'wb') as file:\n pickle.dump(hash_table, file, pickle.HIGHEST_PROTOCOL)\n with open(MOVES_COUNT_DATASET_PATH, 'wb') as file:\n pickle.dump(moves, file, pickle.HIGHEST_PROTOCOL)\n with open(PHASES_COUNT_DATASET_PATH, 'wb') as file:\n pickle.dump(nb_phases, file, pickle.HIGHEST_PROTOCOL)\n\n # Deleting extract_dir\n LOGGER.info('... Deleting extracted files.')\n if os.path.exists(extract_dir):\n shutil.rmtree(extract_dir, ignore_errors=True)\n LOGGER.info('... Done building HDF5 dataset.')","def Train_data():\n print (\"loading train data ...\")\n time_start = time.time()\n data_root = '/media/keziwen/86AA9651AA963E1D'\n with h5py.File(join(data_root, './data/train_real2.h5')) as f:\n data_real = f['train_real'][:]\n num, nt, ny, nx = data_real.shape\n data_real = np.transpose(data_real, (0, 1, 3, 2))\n with h5py.File(join(data_root, './data/train_imag2.h5')) as f:\n data_imag = f['train_imag'][:]\n num, nt, ny, nx = data_imag.shape\n data_imag = np.transpose(data_imag, (0, 1, 3, 2))\n data = data_real+1j*data_imag\n num_train = 15000\n num_validate = 2000\n train_data = data[0:num_train]\n validate_data = data[num_train:num_train+num_validate]\n\n train_data = np.random.permutation(train_data)\n\n time_end = time.time()\n print ('dataset has been created using {}s'.format(time_end-time_start))\n return train_data, validate_data","def training_data():\n global _MEAN # pylint: disable=global-statement\n _np.random.seed(1)\n view = _skdc10.view.OfficialImageClassificationTask()\n permutation = _np.random.permutation(range(50000))\n if _MEAN is None:\n _MEAN = view.train.x.reshape((50000 * 32 * 32, 3)).mean(axis=0)\n return ((view.train.x[:50000, :][permutation, :] - _MEAN).\n transpose((0, 3, 1, 2)).astype('float32'),\n view.train.y[:50000][permutation].reshape((50000, 1)).astype('float32'))","def build_dataset(self):\n\n print('begin to build data set...')\n\n # build dictionary\n for e in self.lst_entity:\n self.dictionary_entity[e] = len(self.dictionary_entity)\n\n for r in self.lst_relation:\n self.dictionary_relation[r] = len(self.dictionary_relation)\n\n self.reverse_dictionary_entity = dict(zip(self.dictionary_entity.values(), self.dictionary_entity.keys()))\n self.reverse_dictionary_relation = dict(zip(self.dictionary_relation.values(), self.dictionary_relation.keys()))\n\n # build data map\n self.lst_entity_map = [self.dictionary_entity[e] for e in self.lst_entity]\n self.lst_relation_map = [self.dictionary_relation[r] for r in self.lst_relation]\n self.lst_triplet_train_map = self.map_triplet(self.lst_triplet_train)\n\n # build corrupted candidates for (h,r,~) and (~,r,t)\n for (h, r, t) in self.lst_triplet_train_map:\n if r not in self.dict_tofh:\n self.dict_tofh[r] = {h: [t]}\n else:\n if h not in self.dict_tofh[r]:\n self.dict_tofh[r][h] = [t]\n else:\n self.dict_tofh[r][h].append(t)\n\n if r not in self.dict_hoft:\n self.dict_hoft[r] = {t: [h]}\n else:\n if t not in self.dict_hoft[r]:\n self.dict_hoft[r][t] = [h]\n else:\n self.dict_hoft[r][t].append(h)\n\n for r in self.dict_tofh:\n self.lst_triplet_corrupted_tail[r] = dict()\n for h in self.dict_tofh[r]:\n set_tail_corrupted_all = set(self.lst_entity_map) - set(self.dict_tofh[r][h])\n lst_tail_corrupted_choose = random.sample(set_tail_corrupted_all, 5*len(self.dict_tofh[r][h]))\n self.lst_triplet_corrupted_tail[r][h] = lst_tail_corrupted_choose\n\n for r in self.dict_hoft:\n self.lst_triplet_corrupted_head[r] = dict()\n for t in self.dict_hoft[r]:\n lst_head_corrupted_all = set(self.lst_entity_map) - set(self.dict_hoft[r][t])\n lst_head_corrupted_choose = random.sample(lst_head_corrupted_all, 5*len(self.dict_hoft[r][t]))\n self.lst_triplet_corrupted_head[r][t] = lst_head_corrupted_choose\n\n print('data set has been built successfully!')","def construct_model():\n # model = Sequential()\n # model.add(Dense(units=64, activation='relu', input_dim=100))\n # model.add(Dense(units=10, activation='softmax'))\n # model.compile(loss='categorical_crossentropy',\n # optimizer='sgd',\n # metrics=['accuracy'])\n # return model\n\n model = Sequential()\n # Input Layer\n model.add(Conv2D(64, 3, data_format='channels_last', activation='relu', padding='same',\n input_shape=(img_width, img_height, 3)))\n model.add(MaxPool2D(pool_size=2, strides=2))\n # Hidden Layer 1\n model.add(Conv2D(64, 3, activation='relu', padding='same'))\n model.add(MaxPool2D(pool_size=2, strides=2))\n\n # Hidden Layer 2\n model.add(Conv2D(128, 3, activation='relu', padding='same'))\n model.add(Conv2D(128, 3, activation='relu', padding='same', strides=2))\n model.add(MaxPool2D(pool_size=2, strides=2))\n\n # Hidden Layer 3\n model.add(Conv2D(256, 3, activation='relu', padding='same'))\n model.add(Conv2D(256, 3, activation='relu', padding='same'))\n model.add(Conv2D(256, 3, activation='relu', padding='same', strides=2))\n model.add(MaxPool2D(pool_size=2, strides=2))\n\n\n # Fully Connected Layer\n model.add(Flatten())\n # 512 Neuron Layer\n model.add(Dense(512, activation='relu'))\n model.add(Dropout(0.5))\n # Output Layer\n model.add(Dense(num_of_classes))\n model.add(Activation('softmax'))\n model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n return model","def get_model(summary=False):\n\timage_input=Input(shape=(220,220,5),name='image_input')\n\tbranch1_conv1=Conv2D(64, kernel_size=(3, 3), border_mode='same', input_shape=(220,220,5), activation='relu')(image_input)\n\tbranch1_conv2=Conv2D(64, kernel_size=(1, 1), border_mode='same', activation='relu')(branch1_conv1)\t\n\tbranch1_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch1_conv1)\n\tbranch2_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch1_pool1)\n\tbranch2_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch2_conv1)\t\n\tbranch2_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch2_conv2)\n\tbranch3_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch2_pool1)\n\tbranch3_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch3_conv1)\t\n\tbranch3_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch3_conv2)\n\tbranch4_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch3_pool1)\n\tbranch4_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch4_conv1)\t\n\tbranch4_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch4_conv2)\n\tbranch5_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch4_pool1)\n\tbranch5_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch5_conv1)\t\n\tbranch5_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch5_conv2)\n\tbranch6_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch5_pool1)\n\tbranch6_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch6_conv1)\t\n\tbranch6_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch6_conv2)\n\tbranch1_flat=Flatten()(branch6_pool1)\n\tdrop=Dropout(.3)(branch1_flat)\n\t# FC layers group\n\tdense1=Dense(512, activation='relu', name='fc1')(drop)\n\tdrop1=Dropout(.3)(dense1)\n\tdense2=Dense(256, activation='relu', name='fc2')(drop1)\n\tdrop3=Dropout(.3)(dense2)\n\tout=Dense(2, activation='softmax', name='fc4')(drop3)\n\tmodel=Model(inputs=image_input,outputs=out)\n\treturn model","def call(self, inputs, padding_mask, training):\n query = reference = self._layernorm_mha(inputs)\n outputs = self._mha(query, reference, padding_mask, training)\n ffn_inputs = self._dropout_mha(outputs, training=training) + inputs\n\n outputs = self._layernorm_ffn(ffn_inputs)\n outputs = self._ffn(outputs, training)\n outputs = self._dropout_ffn(outputs, training=training) + ffn_inputs\n return outputs","def input_fn(data_dir,\n subset,\n num_shards,\n batch_size,\n seq_length=4,\n use_distortion_for_training=True):\n with tf.device('/gpu:0' if num_shards >= 1 else '/cpu:0'):\n use_distortion = subset == 'train' and use_distortion_for_training\n dataset = data_parser.DataSet(data_dir, subset, use_distortion, seq_length)\n image_batch, label_batch, occlusion_batch, depth_batch = dataset.make_batch(batch_size)\n\n # Note that passing num=batch_size is safe here, even though\n # dataset.batch(batch_size) can, in some cases, return fewer than batch_size\n # examples. This is because it does so only when repeating for a limited\n # number of epochs, but our dataset repeats forever.\n image_batch = tf.unstack(image_batch, num=batch_size, axis=0)\n label_batch = tf.unstack(label_batch, num=batch_size, axis=0)\n occlusion_batch = tf.unstack(occlusion_batch, num=batch_size, axis=0)\n depth_batch = tf.unstack(depth_batch, num=batch_size, axis=0)\n feature_shards = [[] for i in range(num_shards)]\n label_shards = [[] for i in range(num_shards)]\n occlusion_shards = [[] for i in range(num_shards)]\n depth_shards = [[] for i in range(num_shards)]\n skip = batch_size/num_shards\n for idx in range(num_shards):\n feature_shards[idx].append(tf.parallel_stack(image_batch[idx*skip:(idx+1)*skip]))\n label_shards[idx].append([[tf.parallel_stack(label_batch[idx*skip:(idx+1)*skip])], [tf.parallel_stack(occlusion_batch[idx*skip:(idx+1)*skip])], [tf.parallel_stack(depth_batch[idx*skip:(idx+1)*skip])]])\n\n return feature_shards, label_shards","def __data_generation(self, list_IDs_temp: list) -> (np.array, np.array):\n\n # Initialization\n X = np.empty((self.batch_size, *self.dim))\n # three channels fro three classes (one hot encoding)\n M = np.empty((self.batch_size, *self.dim[:-1], 3))\n\n # Generate data\n for i, ID in enumerate(list_IDs_temp):\n # load sample\n x = np.load(self.image_data_path + ID, allow_pickle=True)\n m = np.load(self.mask_data_path + ID, allow_pickle=True)\n\n # pre processing\n x, m = self._preprocessing_(x, m)\n X[i,] = x\n M[i,] = m\n\n return X, M","def Segmentation(WorkingDirectory, ListTrainingDataFile, ListImageName, modelname, noiseReduction, numberOfClasses, classesNamesList, ROI, ListAreaNames, fusionClassesY_N, maskY_N, imageY_N, InfoY_N, NFMaskY_N, BiggestBlobY_N, chosenArea, ReferencePicture):\n ### Create the folder where the output will be saved \n if maskY_N=='Y':\n if not os.path.exists(WorkingDirectory+'/Masks'): \n os.mkdir(WorkingDirectory+'/Masks')\n if imageY_N=='Y':\n if not os.path.exists(WorkingDirectory+'/MaskedImages'): \n os.mkdir(WorkingDirectory+'/MaskedImages')\n if NFMaskY_N=='Y':\n if not os.path.exists(WorkingDirectory+'/NonFilteredMasks'): \n os.mkdir(WorkingDirectory+'/NonFilteredMasks')\n\n \n ### Import and format the training data from the training data files.\n trainDataTab=np.array([[0,0,0,0,0,0,0,0,0,0,0,0,0]])\n for file in ListTrainingDataFile: \n f=open(file,\"r\",newline='') \n TrainData = list(csv.reader(f))\n f.close()\n TrainData.remove(['Class', 'Image', 'x','y','B','G','R','H','S','V','L','a','b'])\n TrainData=np.asarray(TrainData) \n trainDataTab=np.concatenate((trainDataTab, TrainData), axis=0)\n trainDataTab=np.delete(trainDataTab, (0), axis=0)\n if len(ListTrainingDataFile)>1: # if the user choose more than one file, a new file is saved combining all the selected files.\n np.savetxt(WorkingDirectory+'/trainData_'+str(numberOfClasses)+'classes.csv', trainDataTab, delimiter=\",\",header='Class,Image,x,y,B,G,R,H,S,V,L,a,b', comments='',fmt='%s')\n trainDataTab=np.delete(trainDataTab,1, 1)\n trainDataTab=np.delete(trainDataTab,1, 1)\n trainDataTab=np.delete(trainDataTab,1, 1)\n\n ### Format the list of ROI \n if ROI!='Whole pictures':\n ROI=ast.literal_eval(ROI)\n\n \n ### Train the model \n model=TrainModel(trainDataTab, modelname,classesNamesList) \n\n \n \n ### Get the size of the reference picture with a 1 pixel difference to avoid any resizing issue\n FirstImage=cv2.imread(ReferencePicture)\n ShapeFirstImage=np.shape(FirstImage)\n a=ShapeFirstImage[0]\n b=ShapeFirstImage[1]\n c=ShapeFirstImage[2]\n ShapeFirstImage2=(a+1,b,c)\n ShapeFirstImage3=(a+1,b+1,c)\n ShapeFirstImage4=(a+1,b-1,c)\n ShapeFirstImage5=(a,b,c)\n ShapeFirstImage6=(a,b+1,c)\n ShapeFirstImage7=(a,b-1,c) \n ShapeFirstImage8=(a-1,b,c)\n ShapeFirstImage9=(a-1,b+1,c)\n ShapeFirstImage10=(a-1,b-1,c) \n\n ### List initialization \n ListImageWrongSize=[]\n ListRunningTimes=[]\n ListTestDataTimes=[]\n ListApplyModelTimes=[]\n ListSaveOutputTimes=[]\n \n if BiggestBlobY_N=='Y':\n ListAirs=np.array([['Area/Plant','Image Name','Surface','Coverage', 'Aspect Ratio','Extent','Solidity', 'Equivalent Diameter', 'Main axe', 'Secondary axe']]) \n else:\n ListAirs=np.array([['Area/Plant','Image Name','Surface','Coverage']]) \n \n ### Main loop on the image list.\n for i in ListImageName:\n start_time = time.monotonic() \n TestImageBGR=cv2.imread(i) \n ImageName=i.split('/')\n ImageName=ImageName[-1] \n ImageName=ImageName.split('.')\n ImageName=ImageName[0] \n ######################################THESE THREE LINES CAN BE USED TO ADD a TIME FILTER ( only keep the pictures between certain hours)\n# hour=float(ImageName[8:10]) #get the time the picture was taken from the name of the file\n hour=float(10)\n if 8<hour<16: # apply a time condition \n ######################################\n if ROI!='Whole pictures':\n if np.shape(TestImageBGR)==ShapeFirstImage or np.shape(TestImageBGR)==ShapeFirstImage2 or np.shape(TestImageBGR)==ShapeFirstImage3 or np.shape(TestImageBGR)==ShapeFirstImage4 or np.shape(TestImageBGR)==ShapeFirstImage5 or np.shape(TestImageBGR)==ShapeFirstImage6 or np.shape(TestImageBGR)==ShapeFirstImage7 or np.shape(TestImageBGR)==ShapeFirstImage8 or np.shape(TestImageBGR)==ShapeFirstImage9 or np.shape(TestImageBGR)==ShapeFirstImage10 : # Test the size of the picture\n for j in range(len(ROI)): \n #Crop the picture for each ROI\n x1,y1,x2,y2=ROI[j]\n if x1>x2:\n a=x1\n x1=x2\n x2=a\n if y1>y2:\n a=y1\n y1=y2\n y2=a \n croppedImagej=TestImageBGR[y1:y2,x1:x2] \n \n NameArea=ListAreaNames[j] \n #Initialize the output names\n OutputMaskName=''\n OutputimageName=''\n OutputNFMaskName=''\n \n #Create the output names and folders\n if maskY_N=='Y': \n croppedMaskDirectoryArea=WorkingDirectory+'/Masks/'+NameArea \n if not os.path.exists(croppedMaskDirectoryArea): \n os.mkdir(croppedMaskDirectoryArea)\n OutputMaskName=croppedMaskDirectoryArea+'/'+ImageName+'_crop_'+NameArea+'_mask.png'\n \n if imageY_N=='Y': \n croppedMaskedImagesDirectoryArea=WorkingDirectory+'/MaskedImages/'+NameArea \n if not os.path.exists(croppedMaskedImagesDirectoryArea): \n os.mkdir(croppedMaskedImagesDirectoryArea) \n OutputimageName=croppedMaskedImagesDirectoryArea+'/'+ImageName+'_crop_'+NameArea+'_maskedImage.png'\n \n if NFMaskY_N=='Y':\n croppedNonFilteredMaskDirectoryArea=WorkingDirectory+'/NonFilteredMasks/'+NameArea \n if not os.path.exists(croppedNonFilteredMaskDirectoryArea): \n os.mkdir(croppedNonFilteredMaskDirectoryArea) \n OutputNFMaskName=croppedNonFilteredMaskDirectoryArea+'/'+ImageName+'_crop_'+NameArea+'_NFMask.png'\n \n # Segment the image with the function ApplyModelAndSaveOutput\n ListAirs, ListTestDataTimes,ListApplyModelTimes,ListSaveOutputTimes=ApplyModelAndSaveOutput(model, modelname, croppedImagej, ImageName, NameArea, noiseReduction, numberOfClasses, classesNamesList, fusionClassesY_N, maskY_N, InfoY_N, imageY_N, NFMaskY_N, BiggestBlobY_N, chosenArea, OutputMaskName, OutputimageName, OutputNFMaskName, ListAirs, ListTestDataTimes,ListApplyModelTimes,ListSaveOutputTimes)\n \n \n print(str(ImageName)+' '+str(NameArea)+' Done!') \n else: #if the picture is not the right size \n ListImageWrongSize.append(i) \n print(str(ImageName)+' Wrong size')\n \n else: #if the user wants to use the whole pictures\n #Create the output names\n OutputMaskName=WorkingDirectory+'/Masks/'+ImageName+'_mask.png'\n OutputimageName=WorkingDirectory+'/MaskedImages/'+ImageName+'_maskedImage.png'\n OutputNFMaskName=WorkingDirectory+'/NonFilteredMasks/'+ImageName+'_NFMask.png'\n \n # Segment the image with the function ApplyModelAndSaveOutput\n ListAirs, ListTestDataTimes,ListApplyModelTimes,ListSaveOutputTimes=ApplyModelAndSaveOutput(model, modelname, TestImageBGR, ImageName, '', noiseReduction, numberOfClasses, classesNamesList, fusionClassesY_N, maskY_N, InfoY_N, imageY_N, NFMaskY_N, BiggestBlobY_N, chosenArea, OutputMaskName, OutputimageName, OutputNFMaskName, ListAirs, ListTestDataTimes,ListApplyModelTimes,ListSaveOutputTimes)\n \n \n print(str(ImageName)+' Done!')\n \n end_time = time.monotonic()\n RunningTime=timedelta(seconds=end_time - start_time)\n sec=float(RunningTime.days*86400+RunningTime.seconds+RunningTime.microseconds/1000000)\n \n if i==ListImageName[0]: # get an estimation of the running time after the first picture is done\n print('Running time for 1 image =', RunningTime)\n print('Total running time estimation =', RunningTime*len(ListImageName))\n ListRunningTimes.append(sec) \n \n \n else: # usefull only if you apply a time filter \n ListImageWrongSize.append(i) \n print(str(ImageName)+' Wrong time')\n \n # Save the info file \n if len(ListAirs)>1:\n np.savetxt(WorkingDirectory+'/'+'InformationFile.csv', ListAirs, delimiter=\",\", comments='', fmt='%s') \n \n return ListImageWrongSize,ListRunningTimes, ListTestDataTimes,ListApplyModelTimes,ListSaveOutputTimes","def concatenate_datasets(filenames_list, img_rows=128, img_cols=128):\n print('Concatenating the datasets created by data augmentation into a single one')\n print('Using the following pairs of images / masks datasets: ')\n print(filenames_list)\n print('\\n')\n\n # total number of images\n n_samples = 600 * len(filenames_list)\n\n # create np.ndarrays for the images and the targets: xCenter, yCenter, xOrientation, yOrientation\n images_dataset = np.ndarray((n_samples, img_rows, img_cols), dtype=np.uint8)\n targets_dataset = np.ndarray((n_samples, 4), dtype=np.float32)\n\n for ds, (img, mask) in enumerate(filenames_list):\n print(\" Processing {}\".format(img))\n images = np.load(\"output/augmented_data/{}.npy\".format(img))\n masks = np.load(\"output/augmented_data/{}.npy\".format(mask))\n\n for idx, mat in enumerate(masks):\n\n # get the center coordinates of the left ventricle (on the resized image)\n row, col = findCenter(img=mat, pixelvalue=1)\n\n # get the orientation of the left ventricle (on the resized image)\n x_v1, y_v1 = findMainOrientation(img=mat, pixelvalue=1)\n\n # save the center coordinates & orientation to the y dataframe (which will be the output of the network)\n targets_dataset[ds*600 + idx] = np.array([row, col, x_v1, y_v1])\n\n # save image in main dataset file\n images_dataset[ds*600 + idx] = images[idx]\n\n print('Concatenated all datasets into one & created target values for (center, orientation)')\n\n print('Splitting the dataset into 70% training & 30% testing')\n images_train, images_test, targets_train, targets_test = train_test_split(images_dataset, targets_dataset,\n test_size=0.3,\n random_state=42,\n shuffle=True)\n\n # save all ndarrays to a .npy files (for faster loading later)\n # Create directory to store files.\n directory = os.path.join(os.getcwd(), 'output/processed_data/')\n if not os.path.exists(directory):\n os.makedirs(directory)\n\n # save training set to file\n np.save('output/processed_data/images_train.npy', images_train)\n np.save('output/processed_data/targets_train.npy', targets_train)\n\n # save testing set to file\n np.save('output/processed_data/images_test.npy', images_test)\n np.save('output/processed_data/targets_test.npy', targets_test)\n print('Saving to .npy files done. See files: ')\n print('output/processed_data/images_train.npy')\n print('output/processed_data/targets_train.npy')\n print('output/processed_data/images_test.npy')\n print('output/processed_data/targets_test.npy')","def _build_datasets_sis3305(self):\n bc_arr = np.where(self._active_brdch[\"SIS 3305\"])\n\n for board, channel in zip(bc_arr[0], bc_arr[1]):\n brd = board + 1\n ch = channel + 1\n slot = self.get_slot(brd, \"SIS 3305\")\n if 1 <= ch <= 4:\n fpga_str = \"FPGA 1\"\n else:\n fpga_str = \"FPGA 2\"\n ch = ch - 4\n\n for cname in self._active_config:\n # create main dataset\n dset_name = f\"{cname} [Slot {slot}: SIS 3305 {fpga_str} ch {ch}]\"\n shape = (self._sn_size, self._nt)\n data = np.empty(shape=shape, dtype=np.int16)\n self.create_dataset(dset_name, data=data)\n\n # create header dataset\n hdset_name = f\"{dset_name} headers\"\n shape = (self._sn_size,)\n dtype = np.dtype(\n [\n (\"Shot number\", np.int32),\n (\"Scale\", np.float32),\n (\"Offset\", np.float32),\n (\"Min\", np.uint16),\n (\"Max\", np.uint16),\n (\"Clipped\", np.int8),\n ]\n )\n dheader = np.empty(shape=shape, dtype=dtype)\n dheader[\"Shot number\"] = np.arange(\n 1, shape[0] + 1, 1, dtype=dheader[\"Shot number\"].dtype\n )\n dheader[\"Scale\"] = 0.0019550342\n dheader[\"Offset\"] = -1.0\n dheader[\"Min\"] = data.min(axis=1)\n dheader[\"Max\"] = data.max(axis=1)\n dheader[\"Clipped\"] = 0\n self.create_dataset(hdset_name, data=dheader)","def gene_h5_train_file(data_path, h5_name):\n img = []\n y_cls_mask = []\n y_reg_cls_mask = []\n os.chdir(data_path)\n jpgfiles = glob.glob('*.jpg')\n idx = 1\n # the position of generator objector is very important\n gene_obj = image_output_pair(data_path, 1/255.0)\n while True:\n if idx == len(jpgfiles):\n break\n print '\\t{0}/{1}'.format(idx, len(jpgfiles))\n # the position of generator objector is very important\n # gene_obj = image_output_pair(data_path, 1/255.0)\n img_it, y_cls_mask_it, y_reg_cls_mask_it = gene_obj.next()\n img.append(img_it)\n y_cls_mask.append(y_cls_mask_it)\n y_reg_cls_mask.append(y_reg_cls_mask_it)\n idx += 1\n\n # img => (320, 320, 3)\n # after np.stack => (19041, 320, 320, 3)\n img_input = np.stack(img, axis=0)\n y_cls = np.stack(y_cls_mask, axis=0)\n y_reg = np.stack(y_reg_cls_mask, axis=0)\n print 'input data shape is {0}'.format(img_input.shape)\n print 'y_cls data shape is {0}'.format(y_cls.shape)\n print 'y_reg data shape is {0}'.format(y_reg.shape)\n \n # wirte data\n h5 = '/home/yuquanjie/Documents/train_' + h5_name\n file_write = h5py.File(h5, 'w')\n file_write.create_dataset('X_train', data=img_input)\n file_write.create_dataset('Y_train_cls', data=y_cls)\n file_write.create_dataset('Y_train_merge', data=y_reg)\n file_write.close()","def build_data_set(self):\n if not self.assert_data_correct():\n self.download_all_data()\n self.unpack_rename_data()\n self.split_data_characters()\n self.clean_data_fragments()\n self.create_font_data()\n if not self.assert_train_augmented():\n self.augment_train_data()\n if not self.assert_style_data_correct():\n self.download_style_data()\n self.unpack_rename_data()","def setUp(self):\n self.batch_size = 8\n num_keypoints = 15\n self.data_batch = []\n self.data_samples = []\n\n for i in range(self.batch_size):\n gt_instances = InstanceData()\n keypoints = np.zeros((1, num_keypoints, 2))\n keypoints[0, i] = [0.5 * i, 0.5 * i]\n gt_instances.keypoints = keypoints\n gt_instances.keypoints_visible = np.ones(\n (1, num_keypoints, 1)).astype(bool)\n gt_instances.keypoints_visible[0, (2 * i) % 8, 0] = False\n gt_instances.bboxes = np.random.random((1, 4)) * 20 * i\n gt_instances.head_size = np.random.random((1, 1)) * 10 * i\n\n pred_instances = InstanceData()\n pred_instances.keypoints = keypoints\n\n data = {'inputs': None}\n data_sample = {\n 'gt_instances': gt_instances.to_dict(),\n 'pred_instances': pred_instances.to_dict(),\n }\n\n self.data_batch.append(data)\n self.data_samples.append(data_sample)","def setUp(self):\n self.batch_size = 8\n num_keypoints = 15\n self.data_batch = []\n self.data_samples = []\n\n for i in range(self.batch_size):\n gt_instances = InstanceData()\n keypoints = np.zeros((1, num_keypoints, 2))\n keypoints[0, i] = [0.5 * i, 0.5 * i]\n gt_instances.keypoints = keypoints\n gt_instances.keypoints_visible = np.ones(\n (1, num_keypoints, 1)).astype(bool)\n gt_instances.keypoints_visible[0, (2 * i) % 8, 0] = False\n gt_instances.bboxes = np.random.random((1, 4)) * 20 * i\n gt_instances.head_size = np.random.random((1, 1)) * 10 * i\n\n pred_instances = InstanceData()\n pred_instances.keypoints = keypoints\n\n data = {'inputs': None}\n data_sample = {\n 'gt_instances': gt_instances.to_dict(),\n 'pred_instances': pred_instances.to_dict(),\n }\n\n self.data_batch.append(data)\n self.data_samples.append(data_sample)","def _load_data(self):\n pickle_in = open(\"X_train.pickle\", \"rb\")\n self.X = pickle.load(pickle_in)\n pickle_in = open(\"y_train.pickle\", \"rb\")\n self.Y = pickle.load(pickle_in)\n\n pickle_in = open(\"X_test.pickle\", \"rb\")\n self.X_final = pickle.load(pickle_in)\n pickle_in = open(\"y_test.pickle\", \"rb\")\n self.Y_final = pickle.load(pickle_in)\n\n # Set input shape:\n if K.image_data_format() == 'channels_first':\n self.input_shape = (3, self.img_rows, self.img_cols)\n else:\n self.input_shape = (self.img_rows, self.img_cols, 3)\n\n self.X = self.X.astype('float32')\n self.X /= 255\n self.X_final = self.X_final.astype('float32')\n self.X_final /= 255\n print('X shape:', self.X.shape)\n print(self.X.shape[0], 'Samples')\n\n num_datapoints = 3000\n self.X = self.X[0:num_datapoints]\n self.Y = self.Y[0:num_datapoints]\n\n num_datapoints = 2000\n self.X_final = self.X_final[0:num_datapoints]\n self.Y_final = self.Y_final[0:num_datapoints]\n\n self.Y_final = to_categorical(self.Y_final, self.num_classes)\n\n # Initialize Data\n kfold = StratifiedKFold(n_splits=self.nFolds, shuffle=True)\n\n if self.b_eval_advanced:\n # Loop through the indices the split() method returns\n for index, (train_indices, test_indices) in enumerate(kfold.split(self.X, self.Y)):\n if index == 0:\n self.Y = to_categorical(self.Y, self.num_classes)\n\n # Generate batches from indices\n xtrain, xtest = self.X[train_indices], self.X[test_indices]\n ytrain, ytest = self.Y[train_indices], self.Y[test_indices]\n\n self.data.append(tuple([xtrain, xtest, ytrain, ytest]))\n\n if not self.b_eval_advanced:\n self.Y = to_categorical(self.Y, self.num_classes)\n\n #print(np.asarray(self.data).shape)\n #print(self.data)\n print(\"Y_final Shape\", self.Y_final.shape)","def get_unet():\n inputs = Input((img_rows, img_cols, 1))\n conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(inputs)\n conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(conv1)\n pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)\n\n conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(pool1)\n conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv2)\n pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)\n\n conv3 = Conv2D(128, (3, 3), activation='relu', padding='same')(pool2)\n conv3 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv3)\n pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)\n\n conv4 = Conv2D(256, (3, 3), activation='relu', padding='same')(pool3)\n conv4 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv4)\n pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)\n\n conv5 = Conv2D(512, (3, 3), activation='relu', padding='same')(pool4)\n conv5 = Conv2D(512, (3, 3), activation='relu', padding='same')(conv5)\n\n up6 = concatenate([Conv2DTranspose(256, (2, 2), strides=(2, 2),\n padding='same')(conv5), conv4], axis=3)\n conv6 = Conv2D(256, (3, 3), activation='relu', padding='same')(up6)\n conv6 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv6)\n\n up7 = concatenate([Conv2DTranspose(128, (2, 2), strides=(2, 2),\n padding='same')(conv6), conv3], axis=3)\n conv7 = Conv2D(128, (3, 3), activation='relu', padding='same')(up7)\n conv7 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv7)\n\n up8 = concatenate([Conv2DTranspose(64, (2, 2), strides=(2, 2),\n padding='same')(conv7), conv2], axis=3)\n conv8 = Conv2D(64, (3, 3), activation='relu', padding='same')(up8)\n conv8 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv8)\n\n up9 = concatenate([Conv2DTranspose(32, (2, 2), strides=(2, 2),\n padding='same')(conv8), conv1], axis=3)\n conv9 = Conv2D(32, (3, 3), activation='relu', padding='same')(up9)\n conv9 = Conv2D(32, (3, 3), activation='relu', padding='same')(conv9)\n\n conv10 = Conv2D(1, (1, 1), activation='sigmoid')(conv9)\n\n model = Model(inputs=[inputs], outputs=[conv10])\n\n model.compile(optimizer=Adam(lr=1e-4), loss=dice_coef_loss,\n metrics=[dice_coef])\n\n return model","def build_all_connected_models(feature_dim, output_scheme=\"regression\", num_classes=num_classes):\n\tinput_layer = keras.layers.Input(shape=[feature_dim])\n\thidden1 = keras.layers.Dense(800, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(input_layer)\n\t#bn1 = keras.layers.BatchNormalization()(hidden1)\n\tdropout1 = keras.layers.AlphaDropout(rate=0.5)(hidden1)\n\t#hidden2 = keras.layers.Dense(500, activation='relu', \n\t#\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t#\tkernel_initializer=\"he_uniform\")(dropout1)\n\t#bn2 = keras.layers.BatchNormalization()(hidden2)\n\t#dropout2 = keras.layers.AlphaDropout(rate=0.5)(hidden2)\n\thidden3 = keras.layers.Dense(200, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout1)\n\tdropout3 = keras.layers.AlphaDropout(rate=0.3)(hidden3)\n\t# trait-specific network\n\thidden4_1 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout3)\n\thidden4_2 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout3)\n\thidden4_3 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout3)\n\thidden4_4 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout3)\n\thidden4_5 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout3)\n\t#bn3 = keras.layers.BatchNormalization()(hidden3)\n\tif (output_scheme==\"regression\"):\n\t\t#outputs = [keras.layers.Dense(1, hidden3) for i in range(5)] #\n\t\tout1 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out1\")(hidden4_1)\n\t\tout2 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out2\")(hidden4_2)\n\t\tout3 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out3\")(hidden4_3)\n\t\tout4 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out4\")(hidden4_4)\n\t\tout5 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out5\")(hidden4_5)\n\telif (output_scheme == \"ordinal_clf\"):\n\t\tout1 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out1\")(hidden4_1)\n\t\tout2 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out2\")(hidden4_2)\n\t\tout3 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out3\")(hidden4_3)\n\t\tout4 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out4\")(hidden4_4)\n\t\tout5 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out5\")(hidden4_5)\n\tmodel = keras.models.Model(inputs=[input_layer],\n\t\t\t\t\t\t\t outputs=[out1, out2, out3, out4, out5])\n\tif (output_scheme == \"regression\"):\n\t\tmodel.compile(loss=\"mse\", \n\t\t\t\t\t optimizer=tf.keras.optimizers.Adam(0.0001),\n\t\t\t\t\t metrics=['mae', custom_r2_metric])\n\telif (output_scheme == \"ordinal_clf\"):\n\t\tmodel.compile(loss=tf.keras.losses.CategoricalCrossentropy(), \n\t\t\t\t\t optimizer=tf.keras.optimizers.Adam(0.001))\n\tprint(model.summary())\n\treturn model","def _prepare_sets(self):\n\n ds_images, ds_labels = self._load_images_labels()\n\n ds_images_2 = ds_images.take(self.val_count)\n ds_labels_2 = ds_labels.take(self.val_count)\n ds_images_1 = ds_images.skip(self.val_count)\n ds_labels_1 = ds_labels.skip(self.val_count)\n\n ds_1 = (ds_images_1, ds_labels_1)\n ds_2 = (ds_images_2, ds_labels_2)\n\n return ds_1, ds_2","def build_model_mobilenet(num_classes):","def index_subset(subset, numTestClasses=7, randomSeed=123 ):\n print(\"datasets.py is ingesting the DF dataset from data/SETA.npz\")\n npzfile = np.load(\"data/SETA.npz\", allow_pickle=True)\n data = npzfile[\"data\"]\n labels = npzfile[\"labels\"]\n npzfile.close()\n distinctLabelCount= len(set(labels))\n \n\n #print(\"distinctLabelCount\", distinctLabelCount)\n \n #random.seed(randomSeed)\n testClasses = random.sample(range(0,distinctLabelCount),numTestClasses)\n\n # Test the overrides \n \n # WORST \n #testClasses = np.array([18.0,16.0,14.0,11.0,10.0,9.0,7.0]).tolist()\n # BEST\n #testClasses = np.array([5.0,6.0,8.0,12.0,13.0,14.0,19.0]).tolist()\n \n testClasses = [np.float64(i) for i in testClasses]\n\n mask = np.isin(labels,testClasses)\n \n \n X_test = data[np.where(mask)]\n X_train = data[np.where(~mask)]\n y_test = labels[np.where(mask)]\n y_train = labels[np.where(~mask)]\n \n if subset==\"background\":\n \n print(\"SETA data\", data.shape)\n print(\"labels\", labels.shape)\n print(testClasses)\n \n print(\"Current working directory is \", os.getcwd())\n X = X_train\n y = y_train\n print(\"SETA background data shape\", X.shape)\n elif subset==\"evaluation\":\n X = X_test\n y = y_test\n print(\"SETA evaluation data shape\", X.shape)\n images = []\n \n #print(\"y shape\", y.shape)\n \n \n for i in range(y.shape[0]):\n images.append({\n 'subset': subset,\n 'class_name': y[i],\n 'data': X[i].reshape(1,X[1].shape[0]) # This is the shape needed for Matching Networks\n #'data': X[i] #.reshape(X[1].shape[0]) # This is the shape needed for MAML\n })\n \n return images","def matrix(self):\n \n dataCount = self.subset.count('1')\n dataNames = sorted(glob.glob(self.fullPath + '/*.tif'))\n dataNames = dataNames[0:dataCount]\n subsetInt = [int(s) for s in self.subset.split() if s.isdigit()] \n \n DC = np.empty(shape = (self.rows*self.columns*self.observations,0)) \n DCs = np.empty(shape = (self.rows*self.columns*self.observations, subsetInt.count(1))) \n \n for i in range(dataCount):\n name = str(dataNames[i])\n dataList = sorted(glob.glob(self.fullPath + '/*' + name[-10:-4] + '.tif')) \n bandDC = np.empty((0, 1)) \n for b in dataList:\n data = gdal.Open(str(b), GA_ReadOnly).ReadAsArray()\n vec = data.reshape((self.rows*self.columns, 1))\n bandDC = np.append(bandDC, vec, axis = 0) \n DC = np.append(DC, bandDC, axis = 1) \n del vec, bandDC, data\n \n #apply fill values \n if self.dataset == 'MOD15A2.005' or self.dataset == 'MOD17A2.005':\n DC[DC>self.fillValue] = 9999.0 \n if self.dataset == 'MOD11A2.005':\n DC[:,0][DC[:,0] == self.fillValue] = 9999.0 #this should have fixed it!\n else:\n DC[DC == self.fillValue] = 9999.0 \n \n \n #scale dataset\n count = 0 \n for i in range(len(subsetInt)):\n if subsetInt[i] == 1:\n DCs[:,count] = np.multiply(DC[:,count], self.scale[i])\n count += 1\n DCs[DC == 9999.0] = 9999.0\n self.DC = DCs\n del DC\n \n #metadata function \n with open(self.fullPath + '/' + 'metadata_' + self.dataset + '.txt', 'w') as f:\n f.write(' '.join([\"self.%s = %s\" % (k,v) for k,v in self.__dict__.iteritems()]))\n \n logger.log('SUCCESS', 'The %s data was transformed into an array with dimensions %d rows by %d columns. No data value set to 9999. A metadata file with object attributes was created. To access the matrix, simply call object.DC' % (str(self.outformat), self.DC.shape[0], self.DC.shape[1]))\n\n tif = sorted(glob.glob(self.fullPath + '/*.tif'))\n for t in tif:\n os.remove(t)","def index_subset(subset, numTestClasses=33, randomSeed=123):\n print(\"datasets.py is ingesting the DF dataset from data/DF.npz\")\n npzfile = np.load(\"data/DF.npz\", allow_pickle=True)\n data = npzfile[\"data\"]\n labels = npzfile[\"labels\"]\n npzfile.close()\n distinctLabelCount= len(set(labels))\n \n print(\"\\ndata\", data.shape)\n print(\"labels\", labels.shape)\n print(\"Total distinct class labels in the DF.npz dataset: \", distinctLabelCount)\n \n #random.seed(randomSeed)\n testClasses = random.sample(range(0,distinctLabelCount),numTestClasses)\n testClasses = [np.float64(i) for i in testClasses]\n \n \n mask = np.isin(labels,testClasses)\n\n X_test = data[np.where(mask)]\n X_train = data[np.where(~mask)]\n y_test = labels[np.where(mask)]\n y_train = labels[np.where(~mask)]\n \n if subset==\"background\":\n print(\"Current working directory is \", os.getcwd())\n X = X_train\n y = y_train\n print(\"DF background data shape\", X.shape)\n elif subset==\"evaluation\":\n X = X_test\n y = y_test\n print(\"DF evaluation data shape\", X.shape)\n images = []\n \n #print(\"y shape\", y.shape)\n \n \n for i in range(y.shape[0]):\n images.append({\n 'subset': subset,\n 'class_name': y[i],\n 'data': X[i].reshape(1,X[1].shape[0]) # This is the shape needed for Matching Networks\n #'data': X[i] #.reshape(X[1].shape[0]) # This is the shape needed for MAML\n })\n \n return images","def __generate_input_data(self):\n if not len(self.input_data) == 0:\n return\n\n try:\n self.input_data = s.load(open('output/input_data.p', 'rb'))\n self.class_indices = s.load(open('output/class_indices.p', 'rb'))\n if not self.classes_to_visualise == None:\n self.__filter_input_data(self.classes_to_visualise)\n except:\n self.input_data = generate_input_data_list(training=False) if self.testing else generate_input_data_list()\n self.class_indices = get_all_class_indices(training=False) if self.testing else get_all_class_indices()\n if not self.classes_to_visualise == None:\n self.__filter_input_data(self.classes_to_visualise)\n s.dump([input.tolist() for input in self.input_data], open('output/input_data.p', 'wb'))\n s.dump(self.class_indices, open('output/class_indices.p', 'wb'))\n\n self.legend = get_class_names_for_class_indices(list(set(sorted(self.class_indices))))"],"string":"[\n \"def transform_to_h5():\\n # this took about 10 minutes for set1\\n for setname in ['set1', 'set2']:\\n filename = os.path.join(ltrc_dirname, '{}.h5'.format(setname))\\n f = h5py.File(filename, 'w')\\n\\n for name in ['train', 'valid', 'test']:\\n g = f.create_group(name)\\n filename = os.path.join(ltrc_dirname, '{}.{}.txt'.format(setname, name))\\n X, y, q = load_svmlight_file(filename, query_id=True)\\n g.create_dataset('X', data=X.todense(), compression='gzip')\\n g.create_dataset('y', data=y, compression='gzip')\\n g.create_dataset('q', data=q, compression='gzip')\\n f.close()\\n # Now you can do this\\n # f['/valid/X'].shape\\n # Out[24]: (71083, 699)\",\n \"def create_dev_matrix(self):\\n if os.path.exists(self.dev_matrix_h5_path):\\n print(\\\"[LOGGING]: \\\" + self.dev_matrix_h5_path + \\\" exists!\\\")\\n return\\n\\n with h5py.File(self.dev_matrix_h5_path, 'w') as f:\\n\\n for mode in ['train', 'test']:\\n for device in ['a', 'b', 'c']:\\n grp = f.create_group(mode + '/' + device)\\n grp['data'], grp['label'] = self.extract_npy(mode=mode, devices=device)\\n # add parallel data as separate device p\\n grp = f.create_group(mode + '/p')\\n grp['data'], grp['label'] = self.extrac_para_npy(mode=mode)\\n\\n # add neg parallel data as device A\\n grp = f.create_group(mode + '/A')\\n grp['data'], grp['label'] = self.extract_neg_para_npy(mode=mode)\\n f.close()\",\n \"def build_model():\\n mdl = Sequential()\\n\\n # normalization\\n mdl.add(Lambda(lambda x: x/128. - 1, input_shape=IMAGE_SHAPE, name=\\\"input\\\"))\\n\\n # trim image\\n mdl.add(Lambda(lambda x: x[:, 10:-10, :, :]))\\n\\n # convolutions\\n mdl.add(Convolution2D(24, 5, 5, subsample=(2, 2), border_mode='same',))\\n mdl.add(MaxPooling2D(pool_size=(2, 2)))\\n mdl.add((Dropout(0.5)))\\n mdl.add(Activation('relu'))\\n\\n mdl.add(Convolution2D(36, 5, 5, subsample=(2, 2), border_mode='same',))\\n mdl.add(MaxPooling2D(pool_size=(2, 2)))\\n mdl.add((Dropout(0.5)))\\n mdl.add(Activation('relu'))\\n\\n mdl.add(Convolution2D(48, 5, 5, subsample=(2, 2), border_mode='same',))\\n mdl.add(MaxPooling2D(pool_size=(2, 2)))\\n mdl.add((Dropout(0.5)))\\n mdl.add(Activation('relu'))\\n\\n mdl.add(Convolution2D(64, 3, 3, subsample=(1, 1), border_mode='same',))\\n mdl.add((Dropout(0.5)))\\n mdl.add(Activation('relu'))\\n\\n mdl.add(Convolution2D(64, 3, 3, subsample=(1, 1), border_mode='same',))\\n mdl.add((Dropout(0.5)))\\n mdl.add(Activation('relu'))\\n\\n mdl.add(Flatten())\\n\\n mdl.add(Dense(128, activation='relu'))\\n mdl.add(Dense(64, activation='relu'))\\n mdl.add(Dense(1, name=\\\"output\\\"))\\n\\n mdl.summary()\\n\\n return mdl\",\n \"def buildDataSet():\\n (x_train_origin, y_train_origin), (x_test_origin, y_test_origin) = mnist.load_data()\\n\\n assert K.image_data_format() == 'channels_last'\\n x_train_origin = x_train_origin.reshape(x_train_origin.shape[0], h, w, 1)\\n x_test_origin = x_test_origin.reshape(x_test_origin.shape[0], h, w, 1)\\n\\n dataset_train = []\\n dataset_test = []\\n\\n #Sorting images by classes and normalize values 0=>1\\n for n in range(nb_classes):\\n images_class_n = np.asarray([row for idx,row in enumerate(x_train_origin) if y_train_origin[idx]==n])\\n dataset_train.append(images_class_n/255)\\n\\n images_class_n = np.asarray([row for idx,row in enumerate(x_test_origin) if y_test_origin[idx]==n])\\n dataset_test.append(images_class_n/255)\\n\\n return dataset_train,dataset_test,x_train_origin,y_train_origin,x_test_origin,y_test_origin\",\n \"def test_hdf5_design_matrix():\\n skip_if_no_h5py()\\n import h5py\\n\\n # save random data to HDF5\\n handle, filename = tempfile.mkstemp()\\n dataset = random_one_hot_dense_design_matrix(np.random.RandomState(1),\\n num_examples=10, dim=5,\\n num_classes=3)\\n with h5py.File(filename, 'w') as f:\\n f.create_dataset('X', data=dataset.get_design_matrix())\\n f.create_dataset('y', data=dataset.get_targets())\\n\\n # instantiate Train object\\n trainer = yaml_parse.load(design_matrix_yaml % {'filename': filename})\\n trainer.main_loop()\\n\\n # cleanup\\n os.remove(filename)\",\n \"def data_split():\\n x_train = np.load(os.path.join(svhn.DEFAULT_PREPROCESSED_DATA_FOLDER, svhn.TRAIN, \\\"images.npy\\\"))\\n y_train = np.load(os.path.join(svhn.DEFAULT_PREPROCESSED_DATA_FOLDER, svhn.TRAIN, \\\"label.npy\\\"))\\n x_test = np.load(os.path.join(svhn.DEFAULT_PREPROCESSED_DATA_FOLDER, svhn.TEST, \\\"images.npy\\\"))\\n y_test = np.load(os.path.join(svhn.DEFAULT_PREPROCESSED_DATA_FOLDER, svhn.TEST, \\\"label.npy\\\"))\\n\\n print(x_train.shape)\\n print(x_test.shape)\\n\\n img_rows, img_cols = x_train.shape[1], x_train.shape[2]\\n num_classes = 10 # starts with 1 not 0\\n\\n y_test1 = y_test.reshape((y_test.shape[0],))\\n y_test1 = [y - 1 for y in y_test1]\\n\\n y_train1 = y_train.reshape((y_train.shape[0],))\\n y_train1 = [y - 1 for y in y_train1]\\n\\n input_shape = (img_rows, img_cols, 3)\\n\\n X_train = x_train.astype('float32')\\n X_test = x_test.astype('float32')\\n\\n X_train /= 255\\n X_test /= 255\\n print('x_train shape:', X_train.shape)\\n print(X_train.shape[0], 'train samples')\\n print(X_test.shape[0], 'test samples')\\n\\n # convert class vectors to binary class matrices\\n y_train2 = keras.utils.to_categorical(y_train1, num_classes)\\n y_test2 = keras.utils.to_categorical(y_test1, num_classes)\\n\\n y_train2 = y_train2.astype('int32')\\n y_test2 = y_test2.astype('int32')\\n\\n print(\\n \\\"after process: X train shape: {}, X test shape: {}, y train shape: {}, y test shape: {}\\\".format(x_train.shape,\\n x_test.shape,\\n y_train2.shape,\\n y_test2.shape))\\n return input_shape, X_train, X_test, y_train2, y_test2\",\n \"def training_data_generation(DATA_DIR, img_height_size, img_width_size, label_list):\\r\\n \\r\\n img_ms_files = glob.glob(DATA_DIR + '\\\\\\\\Train_MS' + '\\\\\\\\Train_*.tif')\\r\\n img_pan_files = glob.glob(DATA_DIR + '\\\\\\\\Train_Pan' + '\\\\\\\\Train_*.tif')\\r\\n polygon_files = glob.glob(DATA_DIR + '\\\\\\\\Train_Polygons' + '\\\\\\\\Train_*.geojson')\\r\\n \\r\\n img_ms_array_list = []\\r\\n img_pan_array_list = []\\r\\n mask_array_list = []\\r\\n \\r\\n for file in range(len(img_ms_files)):\\r\\n with rasterio.open(img_ms_files[file]) as f:\\r\\n metadata = f.profile\\r\\n img_ms = np.transpose(f.read(tuple(np.arange(metadata['count']) + 1)), [1, 2, 0])\\r\\n \\r\\n with rasterio.open(img_pan_files[file]) as g:\\r\\n metadata_pan = g.profile\\r\\n img_pan = np.expand_dims(g.read(1), axis = 2)\\r\\n \\r\\n ms_to_pan_ratio = metadata['transform'][0] / metadata_pan['transform'][0]\\r\\n \\r\\n if (img_height_size % ms_to_pan_ratio) != 0 or (img_width_size % ms_to_pan_ratio) != 0:\\r\\n raise ValueError('Please make sure that both img_height_size and img_width_size can be divided by {}'.format(int(ms_to_pan_ratio)))\\r\\n \\r\\n mask = training_mask_generation(img_pan_files[file], polygon_files[file], labels = label_list)\\r\\n \\r\\n img_ms_array, img_pan_array, mask_array = image_clip_to_segment_and_convert(img_ms, img_pan, mask, ms_to_pan_ratio, \\r\\n img_height_size, img_width_size)\\r\\n \\r\\n img_ms_array_list.append(img_ms_array)\\r\\n img_pan_array_list.append(img_pan_array)\\r\\n mask_array_list.append(mask_array)\\r\\n \\r\\n img_ms_full_array = np.concatenate(img_ms_array_list, axis = 0)\\r\\n img_pan_full_array = np.concatenate(img_pan_array_list, axis = 0)\\r\\n mask_full_array = to_categorical(np.concatenate(mask_array_list, axis = 0), num_classes = len(label_list))\\r\\n \\r\\n return img_ms_full_array, img_pan_full_array, mask_full_array\",\n \"def build_deepsets_joint_representation_model():\\n # We first create the embedding model\\n test_input = tf.keras.layers.Input(shape=(_NUM_INPUTS.value,))\\n train_input = tf.keras.layers.Input(shape=(_NUM_INPUTS.value,))\\n train_label = tf.keras.layers.Input(shape=(1,))\\n\\n # Obtain a mask variable. Output dimension [1, _NUM_INPUTS.value]\\n mask = tf.ones((1, _NUM_INPUTS.value))\\n one_row = tf.reshape(tf.gather(train_input, [0], axis=0), [-1])\\n mask = mask * tf.cast(tf.not_equal(one_row, _PAD_VALUE.value), tf.float32)\\n\\n # Calibrate input if haven't done so\\n calibrated_train_input = train_input\\n calibrated_test_input = test_input\\n calibration = tfl.layers.PWLCalibration(\\n input_keypoints=np.linspace(0.0, 1.0, _NUM_CALIB_KEYS.value),\\n units=_NUM_INPUTS.value,\\n output_min=0.0,\\n output_max=1.0,\\n impute_missing=True,\\n missing_input_value=_MISSING_VALUE.value,\\n name=\\\"input_calibration\\\")\\n calibrated_train_input = calibration(train_input)\\n calibrated_test_input = calibration(test_input)\\n\\n # Reshape the input to pair-wise format.\\n # Output dimension [_BATCH_SIZE.value, _NUM_INPUTS.value**2, 2]\\n pairwise_train_input = get_pairwise_inputs(calibrated_train_input)\\n pairwise_test_input = get_pairwise_inputs(calibrated_test_input)\\n\\n # Obtain pairwise masks. Output dimesion [_NUM_INPUTS.value**2,]\\n pairwise_mask = get_pairwise_inputs(mask)\\n pairwise_mask = tf.reshape(tf.reduce_prod(pairwise_mask, axis=-1), [-1])\\n\\n # Obtain pairwise labels.\\n # Output dimension\\n # [_BATCH_SIZE.value, _NUM_INPUTS.value**2, _MAX_NUM_CLASSES.value]\\n one_hot_train_label = tf.one_hot(\\n tf.cast(train_label, tf.int32), _MAX_NUM_CLASSES.value)\\n pairwise_train_label = tf.tile(one_hot_train_label,\\n tf.constant([1, _NUM_INPUTS.value**2, 1]))\\n\\n # Concatenate pairwise inputs and labels.\\n # Output dimension\\n # [_BATCH_SIZE.value, _NUM_INPUTS.value**2, _MAX_NUM_CLASSES.value + 2]\\n pairwise_train_input = tf.concat([pairwise_train_input, pairwise_train_label],\\n axis=-1)\\n\\n # Obtain distribution representation. Output dimension\\n # [_BATCH_SIZE.value, _NUM_INPUTS.value**2,\\n # _DISTRIBUTION_REPRESENTATION_DIM.value]\\n batch_embedding = tf.keras.layers.Dense(\\n _DISTRIBUTION_REPRESENTATION_DIM.value, activation=\\\"relu\\\")(\\n pairwise_train_input)\\n for _ in range(_HIDDEN_LAYER.value - 1):\\n batch_embedding = tf.keras.layers.Dense(\\n _DISTRIBUTION_REPRESENTATION_DIM.value, activation=\\\"relu\\\")(\\n batch_embedding)\\n\\n # Average embeddings over the batch. Output dimension\\n # [_NUM_INPUTS.value**2, _DISTRIBUTION_REPRESENTATION_DIM.value].\\n mean_distribution_embedding = tf.reduce_mean(batch_embedding, axis=0)\\n\\n outputs = []\\n for pairwise_input in [pairwise_test_input, pairwise_train_input]:\\n # [_NUM_INPUTS.value**2, _DISTRIBUTION_REPRESENTATION_DIM.value] ->\\n # [_BATCH_SIZE.value, _NUM_INPUTS.value**2,\\n # _DISTRIBUTION_REPRESENTATION_DIM.value] via repetition.\\n distribution_embedding = tf.tile(\\n [mean_distribution_embedding],\\n tf.stack([tf.shape(pairwise_input)[0],\\n tf.constant(1),\\n tf.constant(1)]))\\n # Concatenate pairwise inputs and embeddings. Output shape\\n # [_BATCH_SIZE.value, _NUM_INPUTS.value**2,\\n # 2 + _DISTRIBUTION_REPRESENTATION_DIM.value]\\n concat_input = tf.concat([pairwise_input, distribution_embedding], axis=-1)\\n\\n # Apply a common function to each pair. Output shape\\n # [_BATCH_SIZE.value, _NUM_INPUTS.value**2, _DEEPSETS_LAYER_UNITS.value]\\n pairwise_output = tf.keras.layers.Dense(\\n _DEEPSETS_LAYER_UNITS.value, activation=\\\"relu\\\")(\\n concat_input)\\n for _ in range(_HIDDEN_LAYER.value - 1):\\n pairwise_output = tf.keras.layers.Dense(\\n _DEEPSETS_LAYER_UNITS.value, activation=\\\"relu\\\")(\\n pairwise_output)\\n\\n # Average pair-wise outputs across valid pairs.\\n # Output shape [_BATCH_SIZE.value, _DEEPSETS_LAYER_UNITS.value]\\n average_outputs = tf.tensordot(pairwise_mask, pairwise_output, [[0], [1]])\\n average_outputs = average_outputs / tf.reduce_sum(pairwise_mask)\\n\\n # Use several dense layers to get the final output\\n final_output = tf.keras.layers.Dense(\\n _OUTPUT_LAYER_UNITS.value, activation=\\\"relu\\\")(\\n average_outputs)\\n for i in range(_HIDDEN_LAYER.value - 1):\\n final_output = tf.keras.layers.Dense(\\n _OUTPUT_LAYER_UNITS.value, activation=\\\"relu\\\")(\\n final_output)\\n outputs.append(final_output)\\n\\n test_outputs = tf.math.l2_normalize(outputs[0], axis=1)\\n train_outputs = tf.math.l2_normalize(outputs[1], axis=1)\\n similarity_matrix = tf.exp(\\n tf.matmul(test_outputs, tf.transpose(train_outputs)))\\n\\n similarity_list = []\\n for i in range(_MAX_NUM_CLASSES.value):\\n mask = tf.cast(tf.squeeze(tf.equal(train_label, i)), tf.float32)\\n similarity_list.append(similarity_matrix * mask)\\n\\n similarity = [\\n tf.reduce_mean(s, axis=1, keepdims=True) for s in similarity_list\\n ]\\n sum_similarity = tf.reduce_sum(\\n tf.concat(similarity, axis=1), axis=1, keepdims=True)\\n final_output = [similarity / sum_similarity for similarity in similarity_list]\\n final_output = tf.concat(final_output, axis=1)\\n\\n keras_model = tf.keras.models.Model(\\n inputs=[test_input, train_input, train_label], outputs=final_output)\\n compile_keras_model(keras_model)\\n return keras_model\",\n \"def create_training_matrices(experiment, sample_times):\\n # Labels:\\n location_labels = read_location_labels(experiment)\\n locations = get_location_of_persons_at_samples(location_labels, sample_times, experiment)\\n\\n p1_scene_features = read_roi_scene_recognitions_for_person(experiment, \\\"P1\\\")\\n p2_scene_features = read_roi_scene_recognitions_for_person(experiment, \\\"P2\\\")\\n p3_scene_features = read_roi_scene_recognitions_for_person(experiment, \\\"P3\\\")\\n p4_scene_features = read_roi_scene_recognitions_for_person(experiment, \\\"P4\\\")\\n\\n print(p1_scene_features.loc[0]['predictions'].shape[0])\\n print(len(p1_scene_features['predictions'][0]))\\n data = {\\n \\\"P1\\\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\\n \\\"P2\\\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\\n \\\"P3\\\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\\n \\\"P4\\\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0]))\\n }\\n\\n for index, loc_label in enumerate(locations):\\n t = loc_label[0]\\n\\n t_et = convert_timestamps(exp_root, t, \\\"video\\\", \\\"P1_eyetracker\\\")\\n p1 = np.mean(p1_scene_features[p1_scene_features['timestamp'].between(t_et - sample_step/2, t_et + sample_step/2)]['predictions'].as_matrix(), axis=0)\\n\\n\\n t_et = convert_timestamps(exp_root, t, \\\"video\\\", \\\"P2_eyetracker\\\")\\n p2 = np.mean(\\n p2_scene_features[p2_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\\n 'predictions'].as_matrix(), axis=0)\\n\\n t_et = convert_timestamps(exp_root, t, \\\"video\\\", \\\"P3_eyetracker\\\")\\n p3 = np.mean(\\n p3_scene_features[p3_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\\n 'predictions'].as_matrix(), axis=0)\\n\\n t_et = convert_timestamps(exp_root, t, \\\"video\\\", \\\"P4_eyetracker\\\")\\n p4 = np.mean(\\n p4_scene_features[p4_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\\n 'predictions'].as_matrix(), axis=0)\\n\\n data[\\\"P1\\\"][index, 0] = t\\n data[\\\"P1\\\"][index, 1:-1] = p1\\n data[\\\"P1\\\"][index, -1] = loc_label[1]\\n\\n data[\\\"P2\\\"][index, 0] = t\\n data[\\\"P2\\\"][index, 1:-1] = p2\\n data[\\\"P2\\\"][index, -1] = loc_label[2]\\n\\n data[\\\"P3\\\"][index, 0] = t\\n data[\\\"P3\\\"][index, 1:-1] = p3\\n data[\\\"P3\\\"][index, -1] = loc_label[3]\\n\\n data[\\\"P4\\\"][index, 0] = t\\n data[\\\"P4\\\"][index, 1:-1] = p4\\n data[\\\"P4\\\"][index, -1] = loc_label[4]\\n\\n return data\",\n \"def get_ky_mat_pack(hyps: np.ndarray, name: str,\\n s1: int, e1: int, s2: int, e2: int,\\n same: bool, kernel, cutoffs, hyps_mask):\\n\\n\\n # initialize matrices\\n training_data = _global_training_data[name]\\n size1 = (e1-s1)*3\\n size2 = (e2-s2)*3\\n k_mat = np.zeros([size1, size2])\\n\\n ds = [1, 2, 3]\\n\\n # calculate elements\\n args = from_mask_to_args(hyps, hyps_mask, cutoffs)\\n\\n for m_index in range(size1):\\n x_1 = training_data[int(math.floor(m_index / 3))+s1]\\n d_1 = ds[m_index % 3]\\n if (same):\\n lowbound = m_index\\n else:\\n lowbound = 0\\n for n_index in range(lowbound, size2):\\n x_2 = training_data[int(math.floor(n_index / 3))+s2]\\n d_2 = ds[n_index % 3]\\n kern_curr = kernel(x_1, x_2, d_1, d_2, *args)\\n # store kernel value\\n k_mat[m_index, n_index] = kern_curr\\n if (same):\\n k_mat[n_index, m_index] = kern_curr\\n\\n return k_mat\",\n \"def prepare_metadata(devkit_archive, test_groundtruth_path):\\n # Read what's necessary from the development kit.\\n synsets, cost_matrix, raw_valid_groundtruth = read_devkit(devkit_archive)\\n\\n # Mapping to take WordNet IDs to our internal 0-999 encoding.\\n wnid_map = dict(zip((s.decode('utf8') for s in synsets['WNID']),\\n xrange(1000)))\\n\\n # Map the 'ILSVRC2010 ID' to our zero-based ID.\\n ilsvrc_id_to_zero_based = dict(zip(synsets['ILSVRC2010_ID'],\\n xrange(len(synsets))))\\n\\n # Map the validation set groundtruth to 0-999 labels.\\n valid_groundtruth = [ilsvrc_id_to_zero_based[id_]\\n for id_ in raw_valid_groundtruth]\\n\\n # Raw test data groundtruth, ILSVRC2010 IDs.\\n raw_test_groundtruth = numpy.loadtxt(test_groundtruth_path,\\n dtype=numpy.int16)\\n\\n # Map the test set groundtruth to 0-999 labels.\\n test_groundtruth = [ilsvrc_id_to_zero_based[id_]\\n for id_ in raw_test_groundtruth]\\n\\n # Ascertain the number of filenames to prepare appropriate sized\\n # arrays.\\n n_train = int(synsets['num_train_images'].sum())\\n log.info('Training set: {} images'.format(n_train))\\n log.info('Validation set: {} images'.format(len(valid_groundtruth)))\\n log.info('Test set: {} images'.format(len(test_groundtruth)))\\n n_total = n_train + len(valid_groundtruth) + len(test_groundtruth)\\n log.info('Total (train/valid/test): {} images'.format(n_total))\\n return n_train, valid_groundtruth, test_groundtruth, wnid_map\",\n \"def create_dataset(img_rows=128, img_cols=128):\\n print('Creating original dataset from the raw data')\\n # first, get the patients directory names located in the data/ directory. These names (e.g. 'patient0001') will\\n # be used for indexing (also avoid hidden files & folders)\\n patients = [name for name in os.listdir(os.path.join(os.curdir, 'data/')) if not name.startswith('.')]\\n\\n # We sort this list to get the patients id in increasing order\\n patients.sort(key=lambda s: s[-3:]) # sort according to last 3 characters\\n\\n # create an empty numpy.ndarray which will contain the images (resized to (img_rows, img_cols))\\n images = np.ndarray((2 * len(patients), img_rows, img_cols), dtype=np.uint8) # 2 images per patient\\n masks = np.ndarray((2 * len(patients), img_rows, img_cols), dtype=np.uint8) # 2 masks per patient\\n\\n # we now go through each patient's directory :\\n idx = 0\\n for patient in patients:\\n\\n for phase in ['ED', 'ES']:\\n\\n # read image & mask\\n img, _, _, _ = load_mhd_data('data/{pa}/{pa}_4CH_{ph}.mhd'.format(pa=patient, ph=phase))\\n mask, _, _, _ = load_mhd_data('data/{pa}/{pa}_4CH_{ph}_gt.mhd'.format(pa=patient, ph=phase))\\n\\n # resize the img & the mask to (img_rows, img_cols) to keep the network input manageable\\n img = resize(img, (img_cols, img_rows), mode='reflect', preserve_range=True)\\n mask = resize(mask, (img_cols, img_rows), mode='reflect', preserve_range=True)\\n\\n # now, save the resized image to the images np.ndarray\\n images[idx] = img\\n\\n # save the corresponding mask to masks np.ndarray (at the same index)\\n masks[idx] = mask\\n\\n idx += 1\\n\\n print('Created 2 np.ndarrays containing images & masks.')\\n\\n # Create directory to store files.\\n directory = os.path.join(os.getcwd(), 'output/processed_data/')\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n\\n # save all ndarrays to a .npy files (for faster loading later)\\n np.save('output/processed_data/images.npy', images)\\n np.save('output/processed_data/masks.npy', masks)\\n print('Saving to .npy files done: see files\\\\noutput/processed_data/images.npy & \\\\noutput/processed_data/masks.npy.')\",\n \"def _generate_dataset(self):\\n # create train images\\n train_path = os.path.join(self.root_dir, \\\"shapes\\\", \\\"train\\\", \\\"good\\\")\\n os.makedirs(train_path, exist_ok=True)\\n for i in range(self.num_train):\\n result = generate_random_anomaly_image(\\n image_width=self.image_width,\\n image_height=self.image_height,\\n shapes=self.train_shapes,\\n generate_mask=False,\\n )\\n image = result[\\\"image\\\"]\\n imsave(os.path.join(train_path, f\\\"{i:03}.png\\\"), image, check_contrast=False)\\n\\n # create test images\\n for test_category in self.test_shapes:\\n test_path = os.path.join(self.root_dir, \\\"shapes\\\", \\\"test\\\", test_category)\\n mask_path = os.path.join(self.root_dir, \\\"shapes\\\", \\\"ground_truth\\\", test_category)\\n os.makedirs(test_path, exist_ok=True)\\n os.makedirs(mask_path, exist_ok=True)\\n # anomaly and masks. The idea is to superimpose anomalous shapes on top of correct ones\\n for i in range(self.num_test):\\n correct_shapes = generate_random_anomaly_image(\\n image_width=self.image_width,\\n image_height=self.image_height,\\n shapes=self.train_shapes,\\n generate_mask=False,\\n )\\n result = generate_random_anomaly_image(\\n image_width=self.image_width,\\n image_height=self.image_height,\\n shapes=[test_category],\\n generate_mask=True,\\n )\\n correct_shapes = correct_shapes[\\\"image\\\"]\\n image, mask = result[\\\"image\\\"], result[\\\"mask\\\"]\\n image = np.minimum(image, correct_shapes) # since 255 is white\\n imsave(os.path.join(test_path, f\\\"{i:03}.png\\\"), image, check_contrast=False)\\n imsave(os.path.join(mask_path, f\\\"{i:03}_mask.png\\\"), mask, check_contrast=False)\\n # good test\\n test_good = os.path.join(self.root_dir, \\\"shapes\\\", \\\"test\\\", \\\"good\\\")\\n os.makedirs(test_good, exist_ok=True)\\n for i in range(self.num_test):\\n result = generate_random_anomaly_image(\\n image_width=self.image_width,\\n image_height=self.image_height,\\n shapes=self.train_shapes,\\n )\\n image = result[\\\"image\\\"]\\n imsave(os.path.join(test_good, f\\\"{i:03}.png\\\"), image, check_contrast=False)\",\n \"def GetDataset():\\n x_train = []\\n x_test = []\\n y_train = []\\n y_test = []\\n\\n classes1 = set()\\n classes2 = set()\\n for f in GetInputFiles():\\n class1, class2, fold, fname = f.split('\\\\\\\\')[-4:]\\n classes1.add(class1)\\n classes2.add(class2)\\n class1 = class1.split('_')[0]\\n class2 = class2.split('_')[0]\\n\\n x = ReadAndTokenize(f)\\n y = [int(class1 == 'positive'), int(class2 == 'truthful')]\\n if fold == 'fold4':\\n x_test.append(x)\\n y_test.append(y)\\n else:\\n x_train.append(x)\\n y_train.append(y)\\n\\n ### Make numpy arrays.\\n x_test = MakeDesignMatrix(x_test)\\n x_train = MakeDesignMatrix(x_train)\\n y_test = numpy.array(y_test, dtype='float32')\\n y_train = numpy.array(y_train, dtype='float32')\\n\\n dataset = (x_train, y_train, x_test, y_test)\\n with open('dataset.pkl', 'wb') as fout:\\n pickle.dump(dataset, fout)\\n return dataset\",\n \"def preprocessing(train_raw_, test_raw_):\\n \\n undef = np.float64(-999.0)\\n pred_dict = {'s':'1','b':'0', '?':'-1'}\\n # drop 1st column (Id) and also 1st row with column names (\\\"[1:,\\\") \\n train_raw = train_raw_[1:, :]\\n test_raw = test_raw_[1:, :] \\n \\n # Change s(signal) and b(background) for s:1 and b:0, and change '?' for -1\\n train_raw[:,1] = np.vectorize(pred_dict.get)(train_raw[:,1].astype(str))\\n test_raw[:,1] = np.vectorize(pred_dict.get)(test_raw[:,1].astype(str))\\n \\n # Divide the dataset in four according to PRI_jet_num feature and cast to float\\n train_data_jets = divide_dataset_by_jet(train_raw)\\n test_data_jets = divide_dataset_by_jet(test_raw)\\n \\n # Remove columns with nan values or with standard deviation of 0\\n test_data_jets, train_data_jets = clean_features(test_data_jets, train_data_jets, undef)\\n \\n # Standardize train and test sets to have mean=0 and std=1\\n train_data_jets, test_data_jets = standardize(train_data_jets, test_data_jets)\\n \\n # Replace remaining undefined values by mean, median or zero\\n train_data_mean, train_data_median, train_data_null = replace_nan(train_data_jets)\\n test_data_mean, test_data_median, test_data_null = replace_nan(test_data_jets)\\n \\n return train_data_mean, train_data_median, train_data_null, test_data_mean, test_data_median, test_data_null\",\n \"def load_data():\\r\\n train_dataset = h5py.File('train_catvnoncat.h5', \\\"r\\\") # Change the directory as per your system\\r\\n train_set_x_orig = np.array(train_dataset[\\\"train_set_x\\\"][:]) # your train set features\\r\\n train_set_y_orig = np.array(train_dataset[\\\"train_set_y\\\"][:]) # your train set labels\\r\\n\\r\\n test_dataset = h5py.File('test_catvnoncat.h5', \\\"r\\\") # Change the directory as per your system\\r\\n test_set_x_orig = np.array(test_dataset[\\\"test_set_x\\\"][:]) # your test set features\\r\\n test_set_y_orig = np.array(test_dataset[\\\"test_set_y\\\"][:]) # your test set labels\\r\\n\\r\\n classes = np.array(test_dataset[\\\"list_classes\\\"][:]) # the list of classes\\r\\n \\r\\n train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\\r\\n test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\\r\\n \\r\\n return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes\",\n \"def create_GT_masks(root_dir, background_dir, intrinsic_matrix,classes):\\n list_all_images = load_obj(root_dir + \\\"all_images_adr\\\")\\n training_images_idx = load_obj(root_dir + \\\"train_images_indices\\\")\\n for i in range(len(training_images_idx)):\\n img_adr = list_all_images[training_images_idx[i]]\\n label = os.path.split(os.path.split(os.path.dirname(img_adr))[0])[1]\\n regex = re.compile(r'\\\\d+')\\n idx = regex.findall(os.path.split(img_adr)[1])[0]\\n\\n if i % 1000 == 0:\\n print(str(i) + \\\"/\\\" + str(len(training_images_idx)) + \\\" finished!\\\")\\n\\n image = cv2.imread(img_adr)\\n ID_mask = np.zeros((image.shape[0], image.shape[1]))\\n U_mask = np.zeros((image.shape[0], image.shape[1]))\\n V_mask = np.zeros((image.shape[0], image.shape[1]))\\n\\n ID_mask_file = root_dir + label + \\\\\\n \\\"/ground_truth/IDmasks/color\\\" + str(idx) + \\\".png\\\"\\n U_mask_file = root_dir + label + \\\\\\n \\\"/ground_truth/Umasks/color\\\" + str(idx) + \\\".png\\\"\\n V_mask_file = root_dir + label + \\\\\\n \\\"/ground_truth/Vmasks/color\\\" + str(idx) + \\\".png\\\"\\n\\n tra_adr = root_dir + label + \\\"/data/tra\\\" + str(idx) + \\\".tra\\\"\\n rot_adr = root_dir + label + \\\"/data/rot\\\" + str(idx) + \\\".rot\\\"\\n rigid_transformation = get_rot_tra(rot_adr, tra_adr)\\n\\n # Read point Point Cloud Data\\n ptcld_file = root_dir + label + \\\"/object.xyz\\\"\\n pt_cld_data = np.loadtxt(ptcld_file, skiprows=1, usecols=(0, 1, 2))\\n ones = np.ones((pt_cld_data.shape[0], 1))\\n homogenous_coordinate = np.append(pt_cld_data[:, :3], ones, axis=1)\\n\\n # Perspective Projection to obtain 2D coordinates for masks\\n homogenous_2D = intrinsic_matrix @ (rigid_transformation @ homogenous_coordinate.T)\\n coord_2D = homogenous_2D[:2, :] / homogenous_2D[2, :]\\n coord_2D = ((np.floor(coord_2D)).T).astype(int)\\n x_2d = np.clip(coord_2D[:, 0], 0, 639)\\n y_2d = np.clip(coord_2D[:, 1], 0, 479)\\n ID_mask[y_2d, x_2d] = classes[label]\\n\\n if i % 100 != 0: # change background for every 99/100 images\\n background_img_adr = background_dir + random.choice(os.listdir(background_dir))\\n background_img = cv2.imread(background_img_adr)\\n background_img = cv2.resize(background_img, (image.shape[1], image.shape[0]), interpolation=cv2.INTER_AREA)\\n background_img[y_2d, x_2d, :] = image[y_2d, x_2d, :]\\n background_adr = root_dir + label + \\\"/changed_background/color\\\" + str(idx) + \\\".png\\\"\\n mpimg.imsave(background_adr, background_img)\\n\\n # Generate Ground Truth UV Maps\\n centre = np.mean(pt_cld_data, axis=0)\\n length = np.sqrt((centre[0]-pt_cld_data[:, 0])**2 + (centre[1] -\\n pt_cld_data[:, 1])**2 + (centre[2]-pt_cld_data[:, 2])**2)\\n unit_vector = [(pt_cld_data[:, 0]-centre[0])/length, (pt_cld_data[:,\\n 1]-centre[1])/length, (pt_cld_data[:, 2]-centre[2])/length]\\n U = 0.5 + (np.arctan2(unit_vector[2], unit_vector[0])/(2*np.pi))\\n V = 0.5 - (np.arcsin(unit_vector[1])/np.pi)\\n U_mask[y_2d, x_2d] = U\\n V_mask[y_2d, x_2d] = V\\n\\n # Saving ID, U and V masks after using the fill holes function\\n ID_mask, U_mask, V_mask = fill_holes(ID_mask, U_mask, V_mask)\\n cv2.imwrite(ID_mask_file, ID_mask)\\n mpimg.imsave(U_mask_file, U_mask, cmap='gray')\\n mpimg.imsave(V_mask_file, V_mask, cmap='gray')\",\n \"def setUp(self):\\n output = np.zeros((1, 5, 2))\\n target = np.zeros((1, 5, 2))\\n # first channel\\n output[0, 0] = [10, 4]\\n target[0, 0] = [10, 0]\\n # second channel\\n output[0, 1] = [10, 18]\\n target[0, 1] = [10, 10]\\n # third channel\\n output[0, 2] = [0, 0]\\n target[0, 2] = [0, -1]\\n # fourth channel\\n output[0, 3] = [40, 40]\\n target[0, 3] = [30, 30]\\n # fifth channel\\n output[0, 4] = [20, 10]\\n target[0, 4] = [0, 10]\\n\\n gt_instances = InstanceData()\\n gt_instances.keypoints = target\\n gt_instances.keypoints_visible = np.array(\\n [[True, True, False, True, True]])\\n\\n pred_instances = InstanceData()\\n pred_instances.keypoints = output\\n\\n data = {'inputs': None}\\n data_sample = {\\n 'gt_instances': gt_instances.to_dict(),\\n 'pred_instances': pred_instances.to_dict()\\n }\\n\\n self.data_batch = [data]\\n self.data_samples = [data_sample]\",\n \"def train():\\n\\n # Load camera parameters\\n rcams = cameras.load_cameras()\\n\\n # Load 3d data and 2d projections\\n full_train_set_3d, full_test_set_3d, data_mean_3d, data_std_3d, dim_to_ignore_3d, dim_to_use_3d =\\\\\\n data_utils.read_3d_data( FLAGS.camera_frame, rcams, FLAGS.origin_bc, FLAGS.augment_data,\\n FLAGS.procrustes, FLAGS.lowpass )\\n \\n # Read stacked hourglass 2D predictions\\n full_train_set_2d, full_test_set_2d, data_mean_2d, data_std_2d, dim_to_ignore_2d, dim_to_use_2d = \\\\\\n data_utils.read_2d_predictions( FLAGS.origin_bc, FLAGS.augment_data )\\n \\n print(\\\"\\\\n[+] done reading and normalizing data\\\")\\n # Getting the number of training and test subjects\\n tr_subj = 0\\n for v in full_train_set_3d.values():\\n tr_subj += v.shape[0]\\n te_subj = 0\\n for v in full_test_set_3d.values():\\n te_subj += v.shape[0]\\n print(\\\"{0} training subjects, {1} test subjects\\\".format(tr_subj, te_subj))\\n print(dim_to_use_2d)\\n print(dim_to_use_3d)\\n # Un-normalizing data for visualizations\\n unNorm_ftrs2d = data_utils.unNormalize_dic(full_train_set_2d, data_mean_2d, data_std_2d, dim_to_use_2d)\\n unNorm_ftrs3d = data_utils.unNormalize_dic(full_train_set_3d, data_mean_3d, data_std_3d, dim_to_use_3d)\\n unNorm_ftes3d = data_utils.unNormalize_dic(full_test_set_3d, data_mean_3d, data_std_3d, dim_to_use_3d)\\n # Visualize the data\\n viz.visualize_train_sample(unNorm_ftrs2d, unNorm_ftrs3d, FLAGS.camera_frame)\\n viz.visualize_files_oneatatime(unNorm_ftrs3d, unNorm_ftes3d)\\n\\n # Getting only the dimensions to use (get rid of body coxas, other limb, antennas, abdomen\\n train_set_3d, train_set_2d, test_set_3d, test_set_2d = {}, {}, {}, {}\\n for k in full_train_set_3d:\\n (f, c) = k\\n train_set_3d[k] = full_train_set_3d[k][:, dim_to_use_3d]\\n train_set_2d[(f, data_utils.CAMERA_TO_USE)] =\\\\\\n full_train_set_2d[(f, data_utils.CAMERA_TO_USE)][:, dim_to_use_2d]\\n for k in full_test_set_3d:\\n (f, c) = k\\n test_set_3d[k] = full_test_set_3d[k][:, dim_to_use_3d]\\n test_set_2d[(f, data_utils.CAMERA_TO_USE)] =\\\\\\n full_test_set_2d[(f, data_utils.CAMERA_TO_USE)][:, dim_to_use_2d]\\n \\n print(\\\"3D data mean:\\\")\\n print(data_mean_3d)\\n print(\\\"3D data std:\\\")\\n print(data_std_3d)\\n\\n print(\\\"2D data mean:\\\")\\n print(data_mean_2d)\\n print(\\\"2D data std:\\\")\\n print(data_std_2d)\\n \\n input(\\\"Press Enter to continue...\\\")\\n\\n # Avoid using the GPU if requested\\n device_count = {\\\"GPU\\\": 0} if FLAGS.use_cpu else {\\\"GPU\\\": 1}\\n with tf.compat.v1.Session(config=tf.compat.v1.ConfigProto(\\n device_count=device_count,\\n allow_soft_placement=True )) as sess:\\n\\n # === Create the model ===\\n print(\\\"[*] creating %d bi-layers of %d units.\\\" % (FLAGS.num_layers, FLAGS.linear_size))\\n model = create_model( sess, FLAGS.batch_size )\\n model.train_writer.add_graph( sess.graph )\\n print(\\\"[+] model created\\\")\\n \\n #=== This is the training loop ===\\n step_time, loss, val_loss = 0.0, 0.0, 0.0\\n current_step = 0 if FLAGS.load <= 0 else FLAGS.load + 1\\n previous_losses = []\\n\\n step_time, loss = 0, 0\\n current_epoch = 0\\n log_every_n_batches = 100\\n losses, errors, joint_errors = [], [], []\\n for _ in range( FLAGS.epochs ):\\n current_epoch = current_epoch + 1\\n\\n # === Load training batches for one epoch ===\\n encoder_inputs, decoder_outputs =\\\\\\n model.get_all_batches( train_set_2d, train_set_3d, FLAGS.camera_frame, training=True )\\n nbatches = len( encoder_inputs )\\n print(\\\"[*] there are {0} train batches\\\".format( nbatches ))\\n start_time, loss = time.time(), 0.\\n # === Loop through all the training batches ===\\n for i in range( nbatches ):\\n\\n if (i+1) % log_every_n_batches == 0:\\n # Print progress every log_every_n_batches batches\\n print(\\\"Working on epoch {0}, batch {1} / {2}...\\\".format( current_epoch, i+1, nbatches),end=\\\"\\\" )\\n\\n enc_in, dec_out = encoder_inputs[i], decoder_outputs[i]\\n step_loss, loss_summary, lr_summary, _ =\\\\\\n model.step( sess, enc_in, dec_out, FLAGS.dropout, isTraining=True )\\n\\n if (i+1) % log_every_n_batches == 0:\\n # Log and print progress every log_every_n_batches batchespixels = pixels / pixels[2,:]\\n model.train_writer.add_summary( loss_summary, current_step )\\n model.train_writer.add_summary( lr_summary, current_step )\\n step_time = (time.time() - start_time)\\n start_time = time.time()\\n print(\\\"done in {0:.2f} ms\\\".format( 1000*step_time / log_every_n_batches ) )\\n\\n loss += step_loss\\n current_step += 1\\n # === end looping through training batches ===\\n\\n loss = loss / nbatches\\n losses.append(loss)\\n print(\\\"=============================\\\\n\\\"\\n \\\"Global step: %d\\\\n\\\"\\n \\\"Learning rate: %.2e\\\\n\\\"\\n \\\"Train loss avg: %.4f\\\\n\\\"\\n \\\"=============================\\\" % (model.global_step.eval(),\\n model.learning_rate.eval(), loss) )\\n # === End training for an epoch ===\\n\\n # === Testing after this epoch ===\\n isTraining = False\\n \\n n_joints = len(data_utils.DIMENSIONS_TO_USE)\\n if FLAGS.origin_bc:\\n n_joints -= len(data_utils.ROOT_POSITIONS)\\n\\n encoder_inputs, decoder_outputs =\\\\\\n model.get_all_batches( test_set_2d, test_set_3d, FLAGS.camera_frame, training=False)\\n\\n total_err, coordwise_err, joint_err, step_time, loss = evaluate_batches( sess, model,\\n data_mean_3d, data_std_3d, dim_to_use_3d, dim_to_ignore_3d,\\n data_mean_2d, data_std_2d, dim_to_use_2d, dim_to_ignore_2d,\\n current_step, encoder_inputs, decoder_outputs, current_epoch )\\n\\n print(\\\"=============================\\\\n\\\"\\n \\\"Step-time (ms): %.4f\\\\n\\\"\\n \\\"Val loss avg: %.4f\\\\n\\\"\\n \\\"Val error avg (mm): %.2f (%.2f, %.2f, %.2f)\\\\n\\\"\\n \\\"=============================\\\" % ( 1000*step_time, loss, total_err,\\n coordwise_err[0], coordwise_err[1], coordwise_err[2] ))\\n\\n for i in range(n_joints):\\n # 6 spaces, right-aligned, 5 decimal places\\n print(\\\"Error in joint {0:02d} (mm): {1:>5.2f}\\\".format(i+1, joint_err[i]))\\n print(\\\"=============================\\\")\\n errors.append(coordwise_err)\\n joint_errors.append(joint_err)\\n # Log the error to tensorboard\\n summaries = sess.run( model.err_mm_summary, {model.err_mm: total_err} )\\n model.test_writer.add_summary( summaries, current_step )\\n\\n # Save the model\\n print( \\\"Saving the model... \\\", end=\\\"\\\" )\\n start_time = time.time()\\n model.saver.save(sess, os.path.join(train_dir, 'checkpoint'), global_step=current_step )\\n print( \\\"done in {0:.2f} ms\\\".format(1000*(time.time() - start_time)) )\\n\\n # Reset global time and loss\\n step_time, loss = 0, 0\\n\\n sys.stdout.flush()\\n # Save losses for future plots\\n def print_list_tofile(l, filename):\\n with open(filename, 'wb') as f:\\n pickle.dump(l, f)\\n print_list_tofile(losses, train_dir+\\\"/losses.pkl\\\")\\n print_list_tofile(errors, train_dir+\\\"/errors.pkl\\\")\\n print_list_tofile(joint_errors, train_dir+\\\"/joint_errors.pkl\\\")\",\n \"def load_dataset():\\n\\n train_dataset = h5py.File('datasets/train_catvnoncat.h5', \\\"r\\\")\\n train_set_x_orig = np.array(train_dataset[\\\"train_set_x\\\"][:]) # your train set features\\n train_set_y_orig = np.array(train_dataset[\\\"train_set_y\\\"][:]) # your train set labels\\n\\n test_dataset = h5py.File('datasets/test_catvnoncat.h5', \\\"r\\\")\\n test_set_x_orig = np.array(test_dataset[\\\"test_set_x\\\"][:]) # your test set features\\n test_set_y_orig = np.array(test_dataset[\\\"test_set_y\\\"][:]) # your test set labels\\n\\n classes = np.array(test_dataset[\\\"list_classes\\\"][:]) # the list of classes\\n \\n train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\\n test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\\n \\n return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes\",\n \"def main(seed, filter_, num_classes, setup, model_name, images_dir, precision_mode, test):\\n f1, f2 = filter_\\n model_name = 'flex_random_seed_{}_resnet_manual_highres_center_only_f1_{}_f2_{}'.format(seed, f1, f2)\\n frozen_graph_filepath = './Models/Frozen_graphs/{}_{}/'.format(f1,f2) + model_name + '_frozen_graph.pb'\\n frozen_graph, x_tensor, y_tensor = trt_frozen_graph_and_tensors(\\n model_name=model_name, \\n frozen_graph_filepath=frozen_graph_filepath, \\n precision_mode=precision_mode\\n )\\n\\n elapsed_time_full_dataset = []\\n sum_of_confusion_matrices = np.zeros((6, 6))\\n \\n with tf.compat.v1.Session(graph=frozen_graph) as sess:\\n for image_file in [img for img in os.listdir(images_dir) if img.endswith('.JPG')]:\\n\\n img = Image.open(images_dir + image_file)\\n sx,sy = img.size\\n\\n print(\\\"Image size is %i x %i\\\" % (sx,sy)) # sx = 4912, sy = 3264\\n print(\\\"Loading image %s\\\" % image_file)\\n\\n img_np = np.array(img)/255.0\\n del img\\n\\n print(\\\"Predicting for image %s (%i x %i pixel)\\\" % (image_file,sx,sy))\\n\\n start = time.time()\\n predictions_flex = sess.run(y_tensor, feed_dict={x_tensor:np.expand_dims(img_np, 0)})\\n elapsed = time.time() - start\\n elapsed_time_full_dataset.append(elapsed)\\n del img_np #deleting afterwards to not take the deleting time into account\\n\\n print(\\\"Prediction took %f seconds (inference on full image)\\\" % elapsed)\\n print(\\\"Merging predictions\\\")\\n # merge the predictions on the quarter images\\n predictions_flex_combined = np.zeros(predictions_flex.shape)\\n\\n elapsed = time.time()-start\\n if embedded_version:\\n print(\\\"Prediction took %f seconds (inference on split up image)\\\" % elapsed)\\n\\n if embedded_version:\\n predictions_flex = predictions_flex_combined\\n\\n if save_annotations:\\n print(\\\"Computing annotations...\\\")\\n annotations = []\\n d = 4\\n for x in range(100, sx-101, d):\\n for y in range(100, sy-101, d):\\n x0 = int(round(float(x-100)/4) + 15)\\n y0 = int(round(float(y-100)/4) + 15)\\n probs_flex = np.squeeze(predictions_flex[0, y0, x0, :])\\n annotations.append((probs_flex, x, y))\\n\\n if test: # add a prefix for test to not replace real experiments\\n model_name = 'TEST_' + model_name\\n\\n # saving annotations\\n annotation_dir = images_dir.replace('Data', 'Results/seeds/annotations_trt') + image_file\\n annotate_and_save(annotations, d, annotation_dir, model_name, precision_mode)\\n classes_image = annotate_and_save_per_class(\\n annotations, \\n d, \\n annotation_dir, \\n model_name, \\n precision_mode\\n )\\n\\n labels = load_labels(annotation_dir)\\n confusion_matrix = np.zeros((num_classes, num_classes))\\n for (c_name, x, y) in labels:\\n if 100 <= x < sx-101 and 100 <= y < sy-101:\\n x0 = int(round(float(x-100)/4) + 15 )\\n y0 = int(round(float(y-100)/4) + 15)\\n probs_flex = np.squeeze(predictions_flex[0, y0, x0, :])\\n\\n predicted_class = np.argmax(probs_flex)\\n c = train_model.get_classes().index(c_name)\\n confusion_matrix[c, predicted_class] += 1\\n print(confusion_matrix)\\n sum_of_confusion_matrices += confusion_matrix\\n\\n print(sum_of_confusion_matrices)\\n sum_of_cm_fp = './Results/seeds/preds_trt/{}/{}_{}/sum_of_cm_'\\\\\\n .format(precision_mode.lower(), f1,f2) + model_name + '_fp32.npy'\\n elapsed_time_fp = './Results/seeds/elapsed_trt/{}/{}_{}/time_taken_'\\\\\\n .format(precision_mode.lower(), f1,f2) + model_name + '_fp32.npy'\\n\\n\\n np.save(sum_of_cm_fp, sum_of_confusion_matrices)\\n np.save(elapsed_time_fp, elapsed_time_full_dataset)\\n tf.reset_default_graph()\",\n \"def process_dataset(self):\\n\\n logger.info('\\\\n')\\n logger.info('=' * 40)\\n logger.info('=\\\\t DeepRank Data Set')\\n logger.info('=')\\n logger.info('=\\\\t Training data')\\n for f in self.train_database:\\n logger.info(f'=\\\\t -> {f}')\\n logger.info('=')\\n if self.valid_database:\\n logger.info('=\\\\t Validation data')\\n for f in self.valid_database:\\n logger.info(f'=\\\\t -> {f}')\\n logger.info('=')\\n if self.test_database:\\n logger.info('=\\\\t Test data')\\n for f in self.test_database:\\n logger.info(f'=\\\\t -> {f}')\\n logger.info('=')\\n logger.info('=' * 40 + '\\\\n')\\n sys.stdout.flush()\\n\\n # check if the files are ok\\n self.check_hdf5_files(self.train_database)\\n\\n if self.valid_database:\\n self.valid_database = self.check_hdf5_files(\\n self.valid_database)\\n\\n if self.test_database:\\n self.test_database = self.check_hdf5_files(\\n self.test_database)\\n\\n # create the indexing system\\n # alows to associate each mol to an index\\n # and get fname and mol name from the index\\n self.create_index_molecules()\\n\\n # get the actual feature name\\n if self.mapfly:\\n self.get_raw_feature_name()\\n else:\\n self.get_mapped_feature_name()\\n\\n # get the pairing\\n self.get_pairing_feature()\\n\\n # get grid shape\\n self.get_grid_shape()\\n\\n # get the input shape\\n self.get_input_shape()\\n\\n # get renormalization factor\\n if self.normalize_features or self.normalize_targets or self.clip_features:\\n if self.mapfly:\\n self.compute_norm()\\n else:\\n self.get_norm()\\n\\n logger.info('\\\\n')\\n logger.info(\\\" Data Set Info:\\\")\\n logger.info(\\n f' Augmentation : {self.use_rotation} rotations')\\n logger.info(\\n f' Training set : {self.ntrain} conformations')\\n logger.info(\\n f' Validation set : {self.nvalid} conformations')\\n logger.info(\\n f' Test set : {self.ntest} conformations')\\n logger.info(f' Number of channels : {self.input_shape[0]}')\\n logger.info(f' Grid Size : {self.data_shape[1]}, '\\n f'{self.data_shape[2]}, {self.data_shape[3]}')\\n sys.stdout.flush()\",\n \"def build_model(input_classes,output_classes):\\n dimensions = 20\\n inputs = []\\n embedded_outputs = []\\n for i in input_classes:\\n input_layer = Input((1,))\\n inputs.append(input_layer)\\n embedder = Embedding(input_dim=i,output_dim=dimensions,input_length=1,embeddings_constraint=UnitNorm(axis=0))\\n embedded_layer = embedder(input_layer)\\n embedded_outputs.append(embedded_layer)\\n\\n embedded_concats = Concatenate()(embedded_outputs)\\n flatten_layer = Flatten()\\n\\n dense_layer = Dense(output_classes)\\n\\n flattened_output = flatten_layer(embedded_concats)\\n dense_output = dense_layer(flattened_output)\\n\\n # dense_output = dense_layer(embedded_concats)\\n\\n model = Model(inputs,dense_output)\\n print(model.summary())\\n model.compile(loss='sparse_categorical_crossentropy', optimizer='adam')\\n\\n return model\",\n \"def classify_lenet5(batch_size=500, output_size=20):\\n\\n rng = numpy.random.RandomState(23455)\\n\\n\\n # start-snippet-1\\n x = T.matrix('x') # the data is presented as rasterized images\\n ######################\\n # BUILD ACTUAL MODEL #\\n ######################\\n print '... building the model'\\n\\n # Reshape matrix of rasterized images of shape (batch_size, 28 * 28)\\n # to a 4D tensor, compatible with our LeNetConvPoolLayer\\n # (28, 28) is the size of MNIST images.\\n layer0_input = x.reshape((batch_size, 1, 37, 23))\\n\\n # Construct the first convolutional pooling layer:\\n # filtering reduces the image size to (28-5+1 , 28-5+1) = (24, 24)\\n # maxpooling reduces this further to (24/2, 24/2) = (12, 12)\\n # 4D output tensor is thus of shape (batch_size, nkerns[0], 12, 12)\\n layer0 = LeNetConvPoolLayer(\\n rng,\\n input=layer0_input,\\n image_shape=(batch_size, 1, 37, 23),\\n filter_shape=(20, 1, 4, 2),\\n poolsize=(2, 2),\\n )\\n\\n # layer1 = LeNetConvPoolLayer(\\n # rng,\\n # input=layer0.output,\\n # image_shape=(batch_size, 20, 17, 11),\\n # filter_shape=(50, 20, 4, 2),\\n # poolsize=(2, 2),\\n # )\\n #\\n # layer4 = LeNetConvPoolLayer(\\n # rng,\\n # input=layer1.output,\\n # image_shape=(batch_size, 50, 7, 5),\\n # filter_shape=(100, 50, 4, 2),\\n # poolsize=(2, 2),\\n # )\\n\\n layer2_input = layer0.output.flatten(2)\\n\\n # construct a fully-connected sigmoidal layer\\n layer2 = HiddenLayer(\\n rng,\\n input=layer2_input,\\n n_in=3740,\\n n_out=output_size,\\n activation=T.tanh,\\n use_bias=True\\n )\\n\\n # layer5 = HiddenLayer(\\n # rng,\\n # input=layer2.output,\\n # n_in=200,\\n # n_out=output_size,\\n # activation=T.tanh,\\n # use_bias=True\\n # )\\n\\n # classify the values of the fully-connected sigmoidal layer\\n layer3 = LogisticRegression(input=layer2.output, n_in=output_size, n_out=2)\\n\\n model_params = pickle.load(open('../model/cnn_dist_'+str(output_size)+'.pkl'))\\n #\\n layer0.W = theano.shared(\\n value=numpy.array(\\n model_params[2].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='W',\\n borrow=True\\n )\\n\\n layer0.b = theano.shared(\\n value=numpy.array(\\n model_params[3].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='b',\\n borrow=True\\n )\\n\\n # layer1.W = theano.shared(\\n # value=numpy.array(\\n # model_params[-4].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='W',\\n # borrow=True\\n # )\\n #\\n # layer1.b = theano.shared(\\n # value=numpy.array(\\n # model_params[-3].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='b',\\n # borrow=True\\n # )\\n #\\n # layer4.W = theano.shared(\\n # value=numpy.array(\\n # model_params[-6].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='W',\\n # borrow=True\\n # )\\n #\\n # layer4.b = theano.shared(\\n # value=numpy.array(\\n # model_params[-5].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='b',\\n # borrow=True\\n # )\\n\\n layer2.W = theano.shared(\\n value=numpy.array(\\n model_params[0].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='W',\\n borrow=True\\n )\\n\\n layer2.b = theano.shared(\\n value=numpy.array(\\n model_params[1].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='b',\\n borrow=True\\n )\\n\\n # layer5.W = theano.shared(\\n # value=numpy.array(\\n # model_params[-10].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='W',\\n # borrow=True\\n # )\\n #\\n # layer5.b = theano.shared(\\n # value=numpy.array(\\n # model_params[-9].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='b',\\n # borrow=True\\n # )\\n\\n layer3.W = theano.shared(\\n value=numpy.array(\\n model_params[4].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='W',\\n borrow=True\\n )\\n\\n layer3.b = theano.shared(\\n value=numpy.array(\\n model_params[5].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='b',\\n borrow=True\\n )\\n\\n # params = layer3.params + layer5.params + layer2.params + layer4.params + layer1.params + layer0.params\\n\\n datasets = load_data(None)\\n\\n sets = ['train', 'dev', 'test']\\n dimension = [20000, 20000, 20000]\\n for k in range(3):\\n if k == 0:\\n classify_set_x, classify_set_y, classify_set_z, classify_set_m, classify_set_c, classify_set_b= datasets[k]\\n else:\\n classify_set_x, classify_set_y, classify_set_z= datasets[k]\\n\\n # compute number of minibatches for training, validation and testing\\n n_classify_batches = classify_set_x.get_value(borrow=True).shape[0]\\n n_classify_batches /= batch_size\\n\\n # allocate symbolic variables for the data\\n index = T.lscalar() # index to a [mini]batch\\n classify = theano.function(\\n [index],\\n layer2.output,\\n givens={\\n x: classify_set_x[index * batch_size: (index + 1) * batch_size],\\n }\\n )\\n\\n r = []\\n\\n for i in xrange(n_classify_batches):\\n m = classify(i)\\n r.extend(m)\\n r = np.array(r)\\n print r.shape\\n r = np.append(r, np.reshape(classify_set_y.eval(),(dimension[k], 1)), 1)\\n numpy.savetxt('../extractedInformation/cnn_dist_'+str(output_size)+'/'+sets[k]+'.csv', r, delimiter=\\\",\\\")\",\n \"def data_set_maker():\\n\\n # crate a folder in your code directory and name it: \\\"files\\\". put the .npy files iside that folder\\n\\n x_all = np.load(path + '/files/tinyX.npy', 'r') # reads the input file\\n y_all = np.load(path + '/files/tinyY.npy', 'r') # reads the input file\\n\\n # split the data into 10% validation-set and 90% training set\\n raw_train, raw_valid, y_train, y_valid = train_test_split(x_all, y_all, test_size=0.2, random_state=43)\\n return raw_train, raw_valid, y_train, y_valid\",\n \"def build_dataset(self):\\n print(\\\"reading data of images currently , please wait......\\\")\\n x_train, y_train, _ = get_images(self.train_directory)\\n x_test, y_test, _ = get_images(self.test_directory)\\n x_train, y_train = image_subset(self.num_classes, x_train, y_train)\\n x_test, y_test = image_subset(self.num_classes, x_test, y_test)\\n x_train = x_train.astype('float32')\\n x_test = x_test.astype('float32')\\n self.x_train = x_train / 255\\n self.x_test = x_test / 255\\n self.y_train = utils.to_categorical(y_train, self.num_classes)\\n self.y_test = utils.to_categorical(y_test, self.num_classes)\",\n \"def get_models(self, offset=0, sum_=False):\\n \\n self.models = {}\\n self.predict = pd.DataFrame()\\n min_value = min(self.conf[\\\"w_sizes\\\"].values())\\n \\n output_width = int(30/self.conf[\\\"time_step\\\"])\\n \\n \\n for name in self.conf[\\\"w_sizes\\\"].keys():\\n \\n size = self.conf[\\\"w_sizes\\\"][name]\\n self.create_train_test(name=name, f_size=size, offset=offset, output_width=output_width, sum_=sum_)\\n model, loss, val_loss = get_model(name, self.trainX, self.trainY)\\n \\n pred = pd.DataFrame({name: model.predict(self.testX).tolist()},\\n index=range(size-min_value, len(self.testY)+(size-min_value)))\\n \\n pred[name] = pred[name].apply(lambda x: np.array(x))\\n \\n self.predict = pd.concat([self.predict, pred], axis=1)\\n \\n self.models[name] = model\\n \\n del model, pred\\n \\n self.create_train_test(name=\\\"CNN\\\", f_size=min_value, offset=offset, output_width=output_width, sum_=sum_)\\n self.predict[\\\"test\\\"] = self.testY.tolist()\\n self.create_train_test(name=\\\"MLP\\\", f_size=min_value, offset=offset, output_width=output_width, sum_=sum_)\\n self.predict[\\\"test_dis\\\"] = self.testY.tolist()\\n \\n self.predict.dropna(inplace=True)\",\n \"def load_data5():\\n# dirname = 'cifar-10-batches-py'\\n# origin = 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz'\\n# path = get_file(dirname, origin=origin, untar=True)\\n# path= './cifar-10-batches-py'\\n (x_train, y_train), (x_test, y_test) = cifar10.load_data()\\n# Below shows a test class has 999 examples instead of the claimed 1000\\n# tclasscount=np.zeros((10,), dtype=int)\\n# for i in range(0, len(y_test)-1):\\n# tclasscount[y_test[i][0]]= tclasscount[y_test[i][0]] + 1\\n# print('Test class count',tclasscount)\\n num_train_samples = 50000\\n num_5_class = 25000\\n num_5_test = 4999 # should be 5000 if all the categories had 1000 in them but they do not. One is missing.\\n print('x_train shape orig:', x_train.shape)\\n print('More:', x_train.shape[1:])\\n print('y_test shape',y_test.shape)\\n\\n x5_train = np.empty((num_5_class, 32, 32, 3), dtype='uint8')\\n y5_train = np.empty((num_5_class,), dtype='uint8')\\n\\n count=0\\n\\n for i in range(0, len(y_train)-1):\\n if (y_train[i][0] == 2) or (y_train[i][0] == 3) or (y_train[i][0] == 4) or (y_train[i][0] == 5) or (y_train[i][0] == 7):\\n x5_train[count]=x_train[i]\\n y5_train[count]=y_train[i]\\n count=count+1\\n \\n # find test data of interest\\n count=0\\n x5_test=np.empty((num_5_test, 32, 32, 3), dtype='uint8')\\n y5_test= np.empty((num_5_test,), dtype='uint8')\\n\\n for i in range(0, len(y_test)-1):\\n if (y_test[i][0] == 2) or (y_test[i][0] == 3) or (y_test[i][0] == 4) or (y_test[i][0] == 5) or (y_test[i][0] == 7):\\n x5_test[count]=x_test[i]\\n y5_test[count]=y_test[i]\\n count=count+1\\n# Below shows class 7 is only 999 and not 1000 examples!!! One horse got away it seems.\\n# if(y_test[i][0] == 2):\\n# c2=c2+1\\n# if(y_test[i][0] == 3):\\n# c3=c3+1\\n# if(y_test[i][0] == 4):\\n# c4=c4+1\\n# if(y_test[i][0] == 5):\\n# c5=c5+1\\n# if(y_test[i][0] == 7):\\n# c7=c7+1\\n# print('c2count, c3count, c4count, c5count, c7count',c2,c3,c3,c5,c7)\\n# print('y5tstshape',y5_test.shape, count)\\n# print('y5tst',y5_test)\\n# return (x_train, y_train), (x_test, y_test)\\n return (x5_train, y5_train), (x5_test, y5_test)\",\n \"def __init__(self, device=\\\"cuda:0\\\", *args, **kwargs):\\n source_file_wtsd = \\\"/g/kreshuk/data/leptin/sourabh_data_v1/Segmentation_results_fused_tp_1_ch_0_Masked_WatershedBoundariesMergeTreeFilter_Out1.tif\\\"\\n source_file_wtsd = \\\"/g/kreshuk/hilt/projects/data/leptin_fused_tp1_ch_0/Masked_WatershedBoundariesMergeTreeFilter_Out1.h5\\\"\\n # wtsd = torch.from_numpy(np.array(imread(source_file_wtsd).astype(np.long))).to(device)\\n wtsd = torch.from_numpy(h5py.File(source_file_wtsd, \\\"r\\\")[\\\"data\\\"][:].astype(np.long)).to(device)\\n slices = [0, 157, 316]\\n label_1 = [1359, 886, 1240]\\n label_2 = [1172, 748, 807]\\n label_3 = [364, 1148, 1447]\\n m1, m2, m3, m4, m5 = [], [], [], [], []\\n self.outer_cntr_ds, self.inner_cntr_ds, self.celltype_1_ds, self.celltype_2_ds, self.celltype_3_ds = [], [], [], [], []\\n for slc, l1, l2, l3 in zip(slices, label_1, label_2, label_3):\\n bg = wtsd[:, slc, :] == 1\\n bg_cnt = find_contours(bg.cpu().numpy(), level=0)\\n cnt1 = bg_cnt[0] if bg_cnt[0].shape[0] > bg_cnt[1].shape[0] else bg_cnt[1]\\n cnt2 = bg_cnt[1] if bg_cnt[0].shape[0] > bg_cnt[1].shape[0] else bg_cnt[0]\\n for m, cnt in zip([m1, m2], [cnt1, cnt2]):\\n mask = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n mask[np.round(cnt[:, 0]), np.round(cnt[:, 1])] = 1\\n m.append(torch.from_numpy(binary_fill_holes(mask.long().cpu().numpy())).to(device).sum().item())\\n\\n mask = wtsd[:, slc, :] == l1\\n m3.append(mask.long().sum().item())\\n cnt3 = find_contours(mask.cpu().numpy(), level=0)[0]\\n mask = wtsd[:, slc, :] == l2\\n m4.append(mask.long().sum().item())\\n cnt4 = find_contours(mask.cpu().numpy(), level=0)[0]\\n mask = wtsd[:, slc, :] == l3\\n m5.append(mask.long().sum().item())\\n cnt5 = find_contours(mask.cpu().numpy(), level=0)[0]\\n\\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n # img[cnt1[:, 0], cnt1[:, 1]] = 1\\n # plt.imshow(img);plt.show()\\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n # img[cnt2[:, 0], cnt2[:, 1]] = 1\\n # plt.imshow(img);plt.show()\\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n # img[cnt3[:, 0], cnt3[:, 1]] = 1\\n # plt.imshow(img);plt.show()\\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n # img[cnt4[:, 0], cnt4[:, 1]] = 1\\n # plt.imshow(img);plt.show()\\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n # img[cnt5[:, 0], cnt5[:, 1]] = 1\\n # plt.imshow(img);plt.show()\\n\\n self.outer_cntr_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt1, tolerance=1.2)).to(device)))\\n self.inner_cntr_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt2, tolerance=1.2)).to(device)))\\n self.celltype_1_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt3, tolerance=1.2)).to(device)))\\n self.celltype_2_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt4, tolerance=1.2)).to(device)))\\n self.celltype_3_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt5, tolerance=1.2)).to(device)))\\n\\n self.masses = [np.array(m1).mean(), np.array(m2).mean(), np.array(m3 + m4 + m5).mean()]\\n self.fg_shape_descriptors = self.celltype_1_ds + self.celltype_2_ds + self.celltype_3_ds\",\n \"def build_multi_blocks_models(feature_dim, feat_group_start_end_dict, output_scheme=\\\"regression\\\", num_classes=num_classes):\\n\\tdivan_feat_dim = feature_dim\\n\\tfor k in feat_group_start_end_dict:\\n\\t\\tdivan_feat_dim = divan_feat_dim - feat_group_start_end_dict[k][2]\\n\\tinput_atac = keras.layers.Input(shape=[feat_group_start_end_dict['atac'][2]], name=\\\"atac_input\\\")\\n\\tinput_rnaseq = keras.layers.Input(shape=[feat_group_start_end_dict['rnaseq'][2]], name=\\\"rnaseq_input\\\")\\n\\tinput_wgbs = keras.layers.Input(shape=[feat_group_start_end_dict['wgbs'][2]], name=\\\"wgbs_input\\\")\\n\\tinput_divan = keras.layers.Input(shape=[divan_feat_dim], name=\\\"divan_input\\\")\\n\\n\\thidden_atac = keras.layers.Dense(30, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(input_atac)\\n\\thidden_rnaseq = keras.layers.Dense(100, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(input_rnaseq)\\n\\thidden_wgbs = keras.layers.Dense(60, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(input_wgbs)\\n\\thidden_divan_1 = keras.layers.Dense(800, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(input_divan)\\n\\tdropout1 = keras.layers.AlphaDropout(rate=0.5)(hidden_divan_1)\\n\\thidden_divan_2 = keras.layers.Dense(200, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout1)\\n\\tconcat = keras.layers.concatenate([hidden_atac, hidden_rnaseq, hidden_wgbs, hidden_divan_2])\\n\\thidden3 = keras.layers.Dense(200, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout1)\\n\\t# trait-specific network\\n\\thidden_trait_1 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(concat)\\n\\thidden_trait_2 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(concat)\\n\\thidden_trait_3 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(concat)\\n\\thidden_trait_4 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(concat)\\n\\thidden_trait_5 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(concat)\\n\\t#bn3 = keras.layers.BatchNormalization()(hidden3)\\n\\tif (output_scheme==\\\"regression\\\"):\\n\\t\\t#outputs = [keras.layers.Dense(1, hidden3) for i in range(5)] #\\n\\t\\tout1 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out1\\\")(hidden_trait_1)\\n\\t\\tout2 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out2\\\")(hidden_trait_2)\\n\\t\\tout3 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out3\\\")(hidden_trait_3)\\n\\t\\tout4 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out4\\\")(hidden_trait_4)\\n\\t\\tout5 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out5\\\")(hidden_trait_5)\\n\\telif (output_scheme == \\\"ordinal_clf\\\"):\\n\\t\\tout1 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out1\\\")(hidden_trait_1)\\n\\t\\tout2 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out2\\\")(hidden_trait_2)\\n\\t\\tout3 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out3\\\")(hidden_trait_3)\\n\\t\\tout4 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out4\\\")(hidden_trait_4)\\n\\t\\tout5 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out5\\\")(hidden_trait_5)\\n\\tmodel = keras.models.Model(inputs=[input_atac, input_rnaseq, input_wgbs, input_divan],\\n\\t\\t\\t\\t\\t\\t\\t outputs=[out1, out2, out3, out4, out5])\\n\\tif (output_scheme == \\\"regression\\\"):\\n\\t\\tmodel.compile(loss=\\\"mse\\\", \\n\\t\\t\\t\\t\\t optimizer=tf.keras.optimizers.Adam(0.0001),\\n\\t\\t\\t\\t\\t metrics=['mae', custom_r2_metric])\\n\\telif (output_scheme == \\\"ordinal_clf\\\"):\\n\\t\\tmodel.compile(loss=tf.keras.losses.CategoricalCrossentropy(), \\n\\t\\t\\t\\t\\t optimizer=tf.keras.optimizers.Adam(0.001))\\n\\tprint(model.summary())\\n\\treturn model\",\n \"def _demo_mm_inputs(input_shape, num_classes):\\n (N, C, H, W) = input_shape\\n rng = np.random.RandomState(0)\\n imgs = rng.rand(*input_shape)\\n segs = rng.randint(\\n low=0, high=num_classes - 1, size=(N, 1, H, W)).astype(np.uint8)\\n img_metas = [{\\n 'img_shape': (H, W, C),\\n 'ori_shape': (H, W, C),\\n 'pad_shape': (H, W, C),\\n 'filename': '<demo>.png',\\n 'scale_factor': 1.0,\\n 'flip': False,\\n } for _ in range(N)]\\n mm_inputs = {\\n 'imgs': torch.FloatTensor(imgs).requires_grad_(True),\\n 'img_metas': img_metas,\\n 'gt_semantic_seg': torch.LongTensor(segs)\\n }\\n return mm_inputs\",\n \"def get_data_simple_models(measurements: list, dimension: int = 62, return_sequences: bool = True, sequence_length: int = 45,\\n masking_value: float = 100.,\\n batch_size: int = 1,\\n classes_dict: dict = None,\\n data_type: DataType = DataType.HIGH_PASS) -> (np.ndarray, np.ndarray):\\n if classes_dict == None:\\n classes_list = ['acetone', 'isopropanol', 'orange_juice', 'pinot_noir', 'raisin', 'wodka']\\n classes_dict = {}\\n for i, c in enumerate(classes_list):\\n classes_dict[c] = i\\n\\n padding = batch_size - len(measurements)%batch_size\\n\\n if padding == batch_size:\\n padding = 0\\n\\n full_length = len(measurements) + padding\\n\\n full_data = np.ones(shape=(full_length, sequence_length, dimension)) * masking_value\\n\\n if return_sequences:\\n full_labels = np.zeros(shape=(full_length, sequence_length, 1), dtype=int)\\n else:\\n full_labels = np.zeros(shape=(full_length, 1), dtype=int)\\n labels_shape = full_labels.shape[1:]\\n\\n for i, m in enumerate(measurements):\\n d = m.get_data_as(data_type)\\n if d.shape[1] != dimension:\\n raise ValueError(\\\"Dimension mismatch\\\")\\n if d.shape[0] < sequence_length:\\n raise ValueError(\\\"Measurement too short!\\\")\\n full_data[i] = m.get_data_as(data_type)[:sequence_length, :]\\n full_labels[i] = np.ones(shape=labels_shape, dtype=int)*classes_dict[m.label]\\n\\n return full_data, full_labels\",\n \"def make_data(self, which_set, p, center=False, variance_normalize=False,\\n shuffle=False, save_dummy=False):\\n\\n print \\\"Making h5 file for %s\\\" % which_set #TODO(dhjelm): switch to logging.\\n\\n if which_set == 'train':\\n source_path = serial.preprocess(p + 'train.npy')\\n data_path = serial.preprocess(p + 'train.h5')\\n label_path = serial.preprocess(p + 'train_labels.npy')\\n else:\\n assert which_set == 'test'\\n source_path = serial.preprocess(p + 'test.npy')\\n data_path = serial.preprocess(p + 'test.h5')\\n label_path = serial.preprocess(p + 'test_labels.npy')\\n\\n data_path = \\\"\\\".join(data_path.split(\\\".\\\")[0] + '_dummy.h5')\\n\\n # Get the topological view and labels.\\n topo_view = np.load(source_path)\\n y = np.load(label_path)\\n num_labels = np.amax(y) + 1\\n\\n # Shape information and mask.\\n samples, rows, columns, depth = topo_view.shape\\n if self.mask is not None:\\n assert self.mask.shape == (rows, columns, depth)\\n size = len(np.where(self.mask.flatten() == 1)[0].tolist())\\n else:\\n size = rows * columns * depth\\n\\n self.view_converter = MRIViewConverter((rows, columns, depth))\\n X = self.view_converter.topo_view_to_design_mat(topo_view, self.mask)\\n\\n # TODO(dhjelm): one_hot is going away.\\n one_hot = np.zeros((size, num_labels), dtype=config.floatX)\\n for i in xrange(y.shape[0]):\\n one_hot[i, y[i] - 1] = 1.\\n\\n if center:\\n X -= X.mean(axis=0)\\n\\n if variance_normalize:\\n X /= X.std(axis=0)\\n\\n rng = make_np_rng(None, 322, which_method=\\\"shuffle\\\")\\n if shuffle:\\n index = range(samples)\\n rng.shuffle(index)\\n X = X[index, :]\\n one_hot = one_hot[index, :]\\n\\n assert not np.any(np.isnan(X))\\n\\n h5file, node = self.init_hdf5(data_path, ([samples, size], [samples, num_labels]))\\n MRI_Big.fill_hdf5(h5file, X, one_hot, node)\\n h5file.close()\",\n \"def get_training_data(self):\\n\\n # this actually never was a set\\n # src_set = self.target['src'].values\\n # dst_set = self.target['dst'].values\\n\\n # train_negative = self.get_negative_edges(src_set, dst_set, self.train_ind.shape[0]) # * self.K)\\n # test_negative = self.get_negative_edges(src_set, dst_set, self.test_ind.shape[0])\\n\\n train_positive = self.target.iloc[self.train_edge_ind].values\\n test_positive = self.target.iloc[self.test_edge_ind].values\\n\\n # # print(train_positive.shape, train_negative.shape, test_positive.shape, test_negative.shape)\\n # print(f\\\"Working with {train_positive.shape[0]} positive and {train_negative.shape[0]} negative samples in the train set, {test_positive.shape[0]} and {test_negative.shape[0]} - in test set\\\")\\n\\n X_train = train_positive\\n X_test = test_positive\\n\\n y_train = np.ones((self.train_edge_ind.shape[0],))\\n y_test = np.ones((self.test_edge_ind.shape[0],))\\n\\n # X_train = np.vstack([\\n # train_positive,\\n # train_negative\\n # ])\\n\\n # X_test = np.vstack([\\n # test_positive,\\n # test_negative\\n # ])\\n\\n # y_train = np.concatenate([np.ones((self.train_ind.shape[0],)), np.zeros((self.train_ind.shape[0]),)]) # self.train_ind.shape[0]) * self.K\\n # y_test = np.concatenate([np.ones((self.test_ind.shape[0],)), np.zeros((self.test_ind.shape[0],))])\\n\\n assert X_train.shape[0] == y_train.shape[0]\\n assert X_test.shape[0] == y_test.shape[0]\\n\\n def shuffle(X, y):\\n ind_shuffle = np.arange(0, X.shape[0])\\n np.random.shuffle(ind_shuffle)\\n return X[ind_shuffle], y[ind_shuffle]\\n\\n self.X_train, self.y_train = shuffle(X_train, y_train)\\n self.X_test, self.y_test = shuffle(X_test, y_test)\\n\\n print(f\\\"Splitting into {self.X_train.shape[0]} train and {self.X_test.shape[0]} test samples\\\")\\n\\n # return X_train, X_test, y_train, y_test\",\n \"def createDataset_detection(outputPath, imagePathList, box_x_list, box_y_list,\\n labelList, region_mask_list, pixel_mask_list):\\n assert (len(imagePathList) == len(box_x_list) == len(box_y_list))\\n nSamples = len(imagePathList)\\n if not os.path.exists(outputPath):\\n os.mkdir(outputPath)\\n env = lmdb.open(outputPath, map_size=1099511627776)\\n cache = {}\\n cnt = 1\\n for i in range(nSamples):\\n imagePath = imagePathList[i]\\n box_x = box_x_list[i]\\n box_y = box_y_list[i]\\n if len(box_x) == 0:\\n continue\\n if not os.path.exists(imagePath):\\n print('%s does not exist' % imagePath)\\n continue\\n with open(imagePath, 'rb') as f:\\n imageBin = f.read()\\n\\n imageKey = 'image-%09d' % cnt\\n cache[imageKey] = imageBin\\n box_x_Key = 'boxes_x-%09d' % cnt\\n box_y_Key = 'boxes_y-%09d' % cnt\\n cache[box_x_Key] = box_x.encode()\\n cache[box_y_Key] = box_y.encode()\\n\\n if labelList:\\n labelKey = 'label-%09d' % cnt\\n cache[labelKey] = labelList[i].encode()\\n if region_mask_list:\\n region_mask_Key = 'region_mask-%09d' % cnt\\n cache[region_mask_Key] = open(region_mask_list[i], 'rb').read()\\n if pixel_mask_list:\\n pixel_mask_Key = 'pixel_mask-%09d' % cnt\\n cache[pixel_mask_Key] = open(pixel_mask_list[i], 'rb').read()\\n # embed()\\n if cnt % 1000 == 0:\\n writeCache(env, cache)\\n cache = {}\\n print('Written %d / %d' % (cnt, nSamples))\\n cnt += 1\\n nSamples = cnt - 1\\n cache['num-samples'] = str(nSamples).encode()\\n writeCache(env, cache)\\n print('Created dataset with %d samples' % nSamples)\",\n \"def setUpClass(cls):\\n cls.test_file_1 = \\\"/tmp/test_data_loader_dummy_1.pkl\\\"\\n cls.test_file_2 = \\\"/tmp/test_data_loader_dummy_2.pkl\\\"\\n cls.in_cols = [\\\"file\\\", \\\"id\\\", \\\"len\\\", \\\"seq\\\", \\\"phyche\\\", \\\"pssm\\\", \\\"logits\\\",\\n \\\"ss\\\", \\\"h_0\\\", \\\"h_1\\\", \\\"h_2\\\", \\\"lm_logits\\\"]\\n cls.out_cols = [\\\"dataset\\\", \\\"id\\\", \\\"len\\\", \\\"position\\\", \\\"amino\\\",\\n \\\"phyche\\\", \\\"pssm\\\", \\\"logits\\\", \\\"ss\\\", \\\"h_0\\\", \\\"h_1\\\", \\\"h_2\\\",\\n \\\"lm_logits\\\"]\\n\\n seq = np.array([[0., 0., 1.],\\n [1., 0., 0.]])\\n phyche = np.array([[0., 0.], # phyche\\n [1., 0.]])\\n pssm = np.array([[0., 0., .8], # pssm\\n [.8, 0., 0.]])\\n logits = np.array([[0.1, 0., 0.9], # logits\\n [0.9, 0., 0.1]])\\n ss = np.array([[0., 0., 1.], # ss\\n [1., 0., 0.]])\\n h_0 = np.array([[0., 0., 1., 0.],\\n [1., 0., 0., 0.]])\\n h_1 = np.array([[0., 0., 1., 0.],\\n [1., 0., 0., 0.]])\\n h_2 = np.array([[0., 0., 1., 0.], # h_2\\n [1., 0., 0., 0.]])\\n lm_logits = np.array([[0., 0., 1.], # lm_logits\\n [1., 0., 0.]])\\n\\n ex_1_in = (\\\"dummy_train.tfrecords\\\", # file\\n \\\"id1\\\", # id\\n 2, # len\\n seq,\\n phyche,\\n pssm,\\n logits,\\n ss,\\n h_0,\\n h_1,\\n h_2,\\n lm_logits,\\n )\\n ex_1_out = [tuple([\\\"train\\\", ex_1_in[1], ex_1_in[2], j] + [ex_1_in[i][j, :] for i in range(3, len(ex_1_in))]) for j in range(2)]\\n\\n in_df = pd.DataFrame.from_records(data=[ex_1_in], columns=cls.in_cols)\\n # write to file\\n in_df.to_pickle(cls.test_file_1)\\n\\n cls.out_df = pd.DataFrame.from_records(data=ex_1_out, columns=cls.out_cols)\",\n \"def _demo_cid_inputs(input_shape=(1, 3, 512, 512)):\\n (N, C, H, W) = input_shape\\n\\n rng = np.random.RandomState(0)\\n\\n imgs = rng.rand(*input_shape)\\n multi_heatmap = np.zeros([N, 18, H // 4, W // 4], dtype=np.float32)\\n multi_mask = np.ones([N, 1, H // 4, W // 4], dtype=np.float32)\\n instance_coord = np.zeros([N, 30, 2], dtype=int)\\n instance_heatmap = np.zeros([N, 30, 17, H // 4, W // 4], dtype=np.float32)\\n instance_mask = np.ones([N, 30, 17, 1, 1], dtype=np.float32)\\n instance_valid = np.ones([N, 30], dtype=int)\\n\\n img_metas = [{\\n 'image_file':\\n 'test.jpg',\\n 'aug_data': [torch.zeros(1, 3, 512, 512)],\\n 'test_scale_factor': [1],\\n 'base_size': (256, 256),\\n 'center':\\n np.array([256, 256]),\\n 'scale':\\n np.array([1.28, 1.28]),\\n 'flip_index':\\n [0, 2, 1, 4, 3, 6, 5, 8, 7, 10, 9, 12, 11, 14, 13, 16, 15]\\n } for _ in range(N)]\\n\\n cid_inputs = {\\n 'imgs': torch.FloatTensor(imgs).requires_grad_(True),\\n 'multi_heatmap': torch.FloatTensor(multi_heatmap),\\n 'multi_mask': torch.FloatTensor(multi_mask),\\n 'instance_coord': torch.FloatTensor(instance_coord),\\n 'instance_heatmap': torch.FloatTensor(instance_heatmap),\\n 'instance_mask': torch.FloatTensor(instance_mask),\\n 'instance_valid': torch.FloatTensor(instance_valid),\\n 'img_metas': img_metas\\n }\\n return cid_inputs\",\n \"def get_data(data_dir, hdf5):\\r\\n\\r\\n # Get the filenames of the lists containing image paths and labels.\\r\\n train_file, val_file = build_dataset_index(data_dir)\\r\\n\\r\\n # Check if (creating and) loading from hdf5 database is desired.\\r\\n if hdf5:\\r\\n # Create folder to store dataset.\\r\\n if not os.path.exists('hdf5'):\\r\\n os.makedirs('hdf5')\\r\\n # Check if hdf5 databases already exist and create them if not.\\r\\n if not os.path.exists('hdf5/tiny-imagenet_train.h5'):\\r\\n from tflearn.data_utils import build_hdf5_image_dataset\\r\\n print ' Creating hdf5 train dataset.'\\r\\n build_hdf5_image_dataset(train_file, image_shape=(64, 64), mode='file', output_path='hdf5/tiny-imagenet_train.h5', categorical_labels=True, normalize=True)\\r\\n\\r\\n if not os.path.exists('hdf5/tiny-imagenet_val.h5'):\\r\\n from tflearn.data_utils import build_hdf5_image_dataset\\r\\n print ' Creating hdf5 val dataset.'\\r\\n build_hdf5_image_dataset(val_file, image_shape=(64, 64), mode='file', output_path='hdf5/tiny-imagenet_val.h5', categorical_labels=True, normalize=True)\\r\\n\\r\\n # Load training data from hdf5 dataset.\\r\\n h5f = h5py.File('hdf5/tiny-imagenet_train.h5', 'r')\\r\\n X = h5f['X']\\r\\n Y = h5f['Y']\\r\\n\\r\\n # Load validation data.\\r\\n h5f = h5py.File('hdf5/tiny-imagenet_val.h5', 'r')\\r\\n X_test = h5f['X']\\r\\n Y_test = h5f['Y'] \\r\\n\\r\\n # Load images directly from disk when they are required.\\r\\n else:\\r\\n from tflearn.data_utils import image_preloader\\r\\n X, Y = image_preloader(train_file, image_shape=(64, 64), mode='file', categorical_labels=True, normalize=True, filter_channel=True)\\r\\n X_test, Y_test = image_preloader(val_file, image_shape=(64, 64), mode='file', categorical_labels=True, normalize=True, filter_channel=True)\\r\\n\\r\\n # Randomly shuffle the dataset.\\r\\n X, Y = shuffle(X, Y)\\r\\n\\r\\n return X, Y, X_test, Y_test\",\n \"def test_hdf5_load_all():\\n skip_if_no_h5py()\\n import h5py\\n\\n # save random data to HDF5\\n handle, filename = tempfile.mkstemp()\\n dataset = random_one_hot_dense_design_matrix(np.random.RandomState(1),\\n num_examples=10, dim=5,\\n num_classes=3)\\n with h5py.File(filename, 'w') as f:\\n f.create_dataset('X', data=dataset.get_design_matrix())\\n f.create_dataset('y', data=dataset.get_targets())\\n\\n # instantiate Train object\\n trainer = yaml_parse.load(load_all_yaml % {'filename': filename})\\n trainer.main_loop()\\n\\n # cleanup\\n os.remove(filename)\",\n \"def make_mnv_data_dict(list_of_groups):\\n # eventids are really (in the hdf5) uint64, planecodes are really uint16;\\n # use tf.{int64,int32,uint8} because these are the dtypes that one-hot\\n # supports (_not_ int16 or uint16, at least in TF v1.2); use int64 instead\\n # of unit64 because reshape supports int64 (and not uint64).\\n data_list = []\\n for g in list_of_groups:\\n if g in VALID_SET_OF_GROUPS:\\n if g == EVENT_DATA:\\n data_list.extend([\\n (EVENTIDS, tf.int64, g),\\n ])\\n if g == VTX_DATA:\\n data_list.extend([\\n (PLANECODES, tf.int32, g),\\n (SEGMENTS, tf.uint8, g),\\n (ZS, tf.float32, g),\\n ])\\n if g == IMG_DATA:\\n data_list.extend([\\n (HITIMESU, tf.float32, g),\\n (HITIMESV, tf.float32, g),\\n (HITIMESX, tf.float32, g),\\n ])\\n if g == GEN_DATA:\\n data_list.extend([\\n (QSQRD, tf.float32, g),\\n (WINV, tf.float32, g),\\n (XBJ, tf.float32, g),\\n (YBJ, tf.float32, g),\\n (CURRENT, tf.int32, g),\\n (INT_TYPE, tf.int32, g),\\n (TARGETZ, tf.int32, g),\\n ])\\n if g == HADRO_DATA:\\n data_list.extend([\\n (ESUM_CHGDKAONS, tf.float32, g),\\n (ESUM_CHGDPIONS, tf.float32, g),\\n (ESUM_HADMULTMEAS, tf.float32, g),\\n (ESUM_NEUTPIONS, tf.float32, g),\\n (ESUM_NEUTRONS, tf.float32, g),\\n (ESUM_OTHERS, tf.float32, g),\\n (ESUM_PROTONS, tf.float32, g),\\n (N_CHGDKAONS, tf.int32, g),\\n (N_CHGDPIONS, tf.int32, g),\\n (N_HADMULTMEAS, tf.int32, g),\\n (N_NEUTPIONS, tf.int32, g),\\n (N_NEUTRONS, tf.int32, g),\\n (N_OTHERS, tf.int32, g),\\n (N_PROTONS, tf.int32, g),\\n ])\\n if g == LEPTO_DATA:\\n data_list.extend([\\n (ESUM_ELECTRONS, tf.float32, g),\\n (ESUM_MUONS, tf.float32, g),\\n (ESUM_TAUS, tf.float32, g),\\n (N_ELECTRONS, tf.int32, g),\\n (N_MUONS, tf.int32, g),\\n (N_TAUS, tf.int32, g),\\n ])\\n else:\\n raise ValueError('Unrecognized group')\\n mnv_data = {}\\n for datum in data_list:\\n mnv_data[datum[0]] = {}\\n mnv_data[datum[0]]['dtype'] = datum[1]\\n mnv_data[datum[0]]['byte_data'] = None\\n mnv_data[datum[0]]['group'] = datum[2]\\n\\n return mnv_data\",\n \"def create_dataset(data_path, is_training=True, is_shuffle=True, batch_size=1, repeat_size=1,\\n device_num=1, rank=0, num_parallel_workers=24):\\n dataset = HED_Dataset_t(data_path, is_training)\\n print(\\\"total patch numbers per epoch\\\", len(dataset))\\n if is_training:\\n trans1 = [\\n C2.Normalize(mean=[104.00698793, 116.66876762, 122.67891434], std=[1, 1, 1]),\\n C2.HWC2CHW(),\\n C.TypeCast(mindspore.float32)\\n ]\\n dataloader = ds.GeneratorDataset(dataset, ['image', 'label', 'mask'], num_parallel_workers=num_parallel_workers,\\n shuffle=is_shuffle, num_shards=device_num, shard_id=rank)\\n # apply map operations on images\\n dataloader = dataloader.map(input_columns='image', operations=trans1,\\n num_parallel_workers=num_parallel_workers)\\n dataloader = dataloader.map(input_columns='label', operations=C.TypeCast(mindspore.float32),\\n num_parallel_workers=num_parallel_workers)\\n dataloader = dataloader.map(input_columns='mask', operations=C.TypeCast(mindspore.float32),\\n num_parallel_workers=num_parallel_workers)\\n dataloader = dataloader.batch(batch_size, drop_remainder=True)\\n else:\\n dataset = HED_Dataset_e(data_path, is_training)\\n dataloader = ds.GeneratorDataset(dataset, ['test', 'label'], num_parallel_workers=8, shuffle=is_shuffle)\\n dataloader = dataloader.map(input_columns='test', operations=C.TypeCast(mindspore.float32))\\n dataloader = dataloader.batch(batch_size, drop_remainder=False)\\n\\n # apply DatasetOps\\n dataloader = dataloader.repeat(repeat_size)\\n\\n return dataloader\",\n \"def get_training_and_testing_sets(data, Y):\\r\\n data = pd.concat([data, Y], axis=1)\\r\\n x,y=data.shape\\r\\n train_X_sub1=data[0:x//6]\\r\\n dev_X_sub1 = data[x//6:x//6 + x//12]\\r\\n test_X_sub1 = data[x//6 + x//12:x//3]\\r\\n\\r\\n train_X_sub2 = data[x//3:x//3+x//6]\\r\\n dev_X_sub2 = data[x//6 + x//3:x//3 + x//6 + x//12]\\r\\n test_X_sub2 = data[x//3 + x//6 + x//12:2*x//3]\\r\\n\\r\\n train_X_sub3 = data[2*x//3:(2*x//3) +x//6]\\r\\n dev_X_sub3 = data[x//6 + 2*x//3: (2*x//3) + x//6 + x//12]\\r\\n test_X_sub3 = data[2*x//3 + x//6 + x//12:x]\\r\\n\\r\\n train_X=train_X_sub1.append(train_X_sub2,ignore_index = True)\\r\\n train_X =train_X.append(train_X_sub3,ignore_index = True)\\r\\n dev_X= dev_X_sub1.append(dev_X_sub2,ignore_index = True)\\r\\n dev_X = dev_X.append(dev_X_sub3,ignore_index = True)\\r\\n test_X = test_X_sub1.append(test_X_sub2,ignore_index = True)\\r\\n test_X = test_X.append(test_X_sub3,ignore_index = True)\\r\\n\\r\\n\\r\\n train_X = util.shuffle(train_X)\\r\\n train_X = train_X.reset_index(drop=True)\\r\\n\\r\\n dev_X = util.shuffle(dev_X)\\r\\n dev_X = dev_X.reset_index(drop=True)\\r\\n\\r\\n test_X = util.shuffle(test_X)\\r\\n test_X = test_X.reset_index(drop=True)\\r\\n\\r\\n train_X_final=train_X\\r\\n dev_X_final = dev_X\\r\\n test_X_final = test_X\\r\\n x, y = train_X_final.shape\\r\\n train_X = train_X_final.iloc[:, 0:y - 1]\\r\\n train_Y = train_X_final.iloc[:, y - 1]\\r\\n\\r\\n x, y = test_X_final.shape\\r\\n test_X = test_X_final.iloc[:, 0:y - 1]\\r\\n test_Y = test_X_final.iloc[:, y - 1]\\r\\n\\r\\n x, y = dev_X_final.shape\\r\\n dev_X = dev_X_final.iloc[:, 0:y - 1]\\r\\n dev_Y = dev_X_final.iloc[:, y - 1]\\r\\n\\r\\n return train_X, train_Y, dev_X,dev_Y,test_X, test_Y\",\n \"def get_model_1(parameters):\\n # Parameters\\n n1 = parameters['n1']\\n k1 = parameters['k1']\\n n2 = parameters['n2']\\n n3 = parameters['n3']\\n k2 = parameters['k2']\\n n4 = parameters['n4']\\n n5 = parameters['n5']\\n NUM_FILTERS_C1 = 20\\n \\n # Sequential model\\n model = keras.models.Sequential()\\n \\n # Add C1 layer\\n # ------------\\n # Input_shape (batch, rows, cols, channels) = (-, n1, 1, 1)\\n # Output_shape (batch, rows, cols, channels) = (-, n2, 1, NUM_FILTERS_C1)\\n model.add(keras.layers.Conv2D(filters=NUM_FILTERS_C1,\\n kernel_size=(k1, 1),\\n padding='valid',\\n data_format=\\\"channels_last\\\",\\n activation='tanh',\\n kernel_initializer='random_uniform',\\n bias_initializer='random_uniform',\\n input_shape=(n1,1,1)))\\n \\n # Add M2 layer\\n # ------------\\n # Input_shape (batch, rows, cols, channels) = (-, n2, 1, NUM_FILTERS_C1)\\n # Output_shape (batch, rows, cols, channels) = (-, n3, 1, NUM_FILTERS_C1)\\n model.add(keras.layers.MaxPooling2D(pool_size=(k2, 1),\\n padding='same',\\n data_format=\\\"channels_last\\\"))\\n \\n # Flatten before dense layer\\n model.add(keras.layers.Flatten())\\n \\n # Add F3 layer\\n # ------------\\n # Intput_shape (batch, rows, cols, channels) = (-, n3 x 1 x NUM_FILTERS_C1)\\n # Output_shape (batch, dim) = (-, n4)\\n model.add(keras.layers.Dense(units=n4,\\n activation='tanh',\\n kernel_initializer='random_uniform',\\n bias_initializer='random_uniform'))\\n \\n # Add F4 layer\\n # ------------\\n # Intput_shape (batch, dim) = (1, n4)\\n # Output_shape (batch, dim) = (1, n5)\\n model.add(keras.layers.Dense(units=n5,\\n activation='softmax',\\n kernel_initializer='random_uniform',\\n bias_initializer='random_uniform'))\\n \\n # Compile model\\n model.compile(optimizer='sgd',\\n loss='mean_squared_error',\\n metrics=['accuracy'])\\n \\n # Print the model summary to output file\\n # To print to stdout: model.summary()\\n with open(OUTPUT_FILE, 'a') as f:\\n # Pass the file handle in as a lambda function to make it callable\\n model.summary(print_fn=lambda x: f.write(x + '\\\\n'))\\n \\n # Return the model\\n return model\",\n \"def build_matrix(self):\\n self.lb_make = LabelEncoder()\\n self.lb_make.fit(self.Y_train)\\n tokenizer = Tokenizer(num_words=2000)\\n x_array_train = numpy.asarray(self.train['text'])\\n x_array_test = numpy.asarray(self.test['text'])\\n tokenizer.fit_on_texts(x_array_train)\\n x_train_matrix = tokenizer.texts_to_matrix(x_array_train, mode='count')\\n x_test_matrix = tokenizer.texts_to_matrix(x_array_test, mode='count')\\n y_train_numbers = self.lb_make.transform(self.Y_train)\\n y_test_numbers = self.lb_make.transform(self.Y_test)\\n y_train_matrix = keras.utils.to_categorical(y_train_numbers, 3)\\n y_test_matrix = keras.utils.to_categorical(y_test_numbers, 3)\\n self.tokenizer = tokenizer\\n return x_train_matrix, x_test_matrix, y_train_matrix, y_test_matrix\",\n \"def createDataset(sources,output,labels,sparse):\\n global has_joblib\\n out_path = str(output)\\n # delete the output file\\n if os.path.exists(os.path.abspath(out_path)):\\n os.remove(os.path.abspath(out_path))\\n \\n # first, list the source files\\n fpaths_src, fnames_src = utils.listFiles(directory=os.path.abspath(sources), ext='png')\\n \\n label_map={}\\n \\n # read the label file\\n if not (labels == None):\\n label_map = utils.readLabelMap(labels)\\n # check that the numbers match\\n print(\\\"Number of images in label map : %s\\\"%str(len(label_map.keys())-1))\\n print(\\\"Number of images in source dir: %s\\\"%str(len(fpaths_src)))\\n assert len(label_map.keys())-1 == len(fpaths_src)\\n \\n # generate KNN classifier\\n if not (args.codebook == 'None' or args.codebook == None):\\n args.knn = getKNNClassifier() \\n else:\\n args.knn = None\\n \\n # precompute number of images\\n n_imgs = len(fpaths_src)\\n \\n # preallocate array\\n # if augmentation, calculate (9*4+1)*n samples\\n all_features_list = []\\n \\n # parallel implementation (default, if joblib available)\\n if has_joblib:\\n image_features = Parallel(n_jobs=args.njobs,verbose=5) (delayed(processImage)(fpaths_src, label_map, fnames_src, img_idx) for img_idx in range(n_imgs))\\n # collect all images into a single matrix\\n image_features = np.concatenate(image_features, axis=0)\\n all_features_list.append(image_features)\\n else:\\n for img_idx in xrange(n_imgs):\\n image_features = processImage(fpaths_src, label_map, fnames_src, img_idx)\\n all_features_list.append(image_features)\\n \\n # make a 2D matrix from the list of features (stack all images vertically)\\n feat_matrix = np.concatenate(all_features_list, axis=0).astype(np.float32) \\n \\n # do scaling of each feature dimension \\n #if False:\\n if not (args.scale == 0):\\n print \\\"Scaling data...\\\"\\n \\n # preserve the labels\\n label_vec = feat_matrix[:,0]\\n feat_matrix = np.delete(feat_matrix,0,1)\\n \\n featurestats = np.zeros((2,feat_matrix.shape[1]))\\n \\n # use soft-normalization (zero-mean, unit var whitening)\\n if (args.scale == 1):\\n # if we specified featurestats from a training set, use them\\n if not (args.featurestats == None):\\n # load the statistics\\n featurestats = loadFeatureStats()\\n # featurestats contains 2 rows, first row = mean, second row = std\\n # and n feature dimensions\\n assert feat_matrix.shape[1]==featurestats.shape[1]\\n else:\\n pass\\n \\n \\n # use hard-normalization \\n elif (args.scale == 2):\\n # if we specified featurestats from a training set, use them\\n if not (args.featurestats == None):\\n # load the statistics\\n featurestats = loadFeatureStats()\\n # the featurestats contains 2 rows, first row = min, second row = max \\n # and n feature dimensions\\n assert feat_matrix.shape[1]==featurestats.shape[1]\\n else:\\n pass\\n \\n \\n # normalize each feature dimension\\n for feat_idx in xrange(feat_matrix.shape[1]):\\n feat_vec = feat_matrix[:,feat_idx]\\n \\n # soft-normalization (zero-mean, approx. unit variance)\\n if (args.scale == 1): \\n # if feature statistics are specified\\n if not (args.featurestats == None):\\n feat_mean = featurestats[0,feat_idx]\\n feat_std = featurestats[1,feat_idx]\\n else:\\n # compute them from the data\\n feat_mean = feat_vec.mean()\\n feat_std = (feat_vec.std() + 1e-10)\\n # store them \\n featurestats[0,feat_idx] = feat_mean\\n featurestats[1,feat_idx] = feat_std\\n \\n # shift to zero mean and (unit) variance\\n feat_vec_scaled = (feat_vec - feat_mean) / (1.*feat_std)\\n \\n \\n # hard-normalization (min/max = borders estimated from the (training) dataset)\\n elif (args.scale == 2):\\n if not (args.featurestats == None):\\n feat_min = featurestats[0,feat_idx]\\n feat_max = featurestats[1,feat_idx]\\n else:\\n # compute them freshly\\n feat_min = np.min(feat_vec)\\n feat_max = np.max(feat_vec)\\n # store them \\n featurestats[0,feat_idx] = feat_min\\n featurestats[1,feat_idx] = feat_max\\n \\n # standardize/normalize between 0 and 1\\n feat_vec_std = (feat_vec - feat_min) / (feat_max - feat_min + 1e-10) \\n \\n # linearly scale between -1 and 1 \\n feat_vec_scaled = (1.0*feat_vec_std * (1 - -1)) - 1\\n \\n \\n # set column back to matrix\\n feat_matrix[:,feat_idx] = feat_vec_scaled\\n \\n # finally prepend the label_vec again\\n feat_matrix = np.concatenate((np.reshape(label_vec,(feat_matrix.shape[0],1)),feat_matrix), axis=1)\\n \\n print \\\"Done.\\\"\\n else:\\n print \\\"Data may not be properly scaled, use the 'svm-scale' implementation of libsvm.\\\"\\n \\n if not (args.savefeaturestats == None):\\n saveFeatureStats(featurestats) \\n\\n #Parallel(n_jobs=args.njobs, verbose=5)(delayed(function)(params) for i in range(10))\\n # open the output file\\n output_file = open(os.path.abspath(out_path), 'wb')\\n\\n # run through the feature matrix \\n print \\\"Writing %s rows and %s cols to file...\\\"%(feat_matrix.shape)\\n # parallel implementation (default, if joblib available)\\n if has_joblib:\\n lines = Parallel(n_jobs=args.njobs, verbose=5)(delayed(writeLine)(i, feat_matrix) for i in range(feat_matrix.shape[0]))\\n output_file.writelines(lines) \\n else:\\n for i in xrange(feat_matrix.shape[0]):\\n line = writeLine(i, feat_matrix)\\n output_file.writelines(line)\\n \\n output_file.close()\\n \\n return 0\",\n \"def _load20news_miao():\\n DIR = os.path.dirname(os.path.realpath(__file__)).split('vae_sparse')[0]+'vae_sparse/optvaedatasets'\\n DIR += '/20news_miao'\\n h5file = DIR+'/miao.h5'\\n if not os.path.exists(h5file):\\n flen = len(open(DIR+'/vocab').readlines())\\n print 'DIM: ',flen\\n np.random.seed(1)\\n TRAIN_VALID_MAT = readSparseFile(DIR+'/train.feat', flen, zeroIndexed=False)\\n idx = np.random.permutation(TRAIN_VALID_MAT.shape[0])\\n VALIDMAT = TRAIN_VALID_MAT[idx[:500]]\\n TRAINMAT = TRAIN_VALID_MAT[idx[500:]]\\n TESTMAT = readSparseFile(DIR+'/test.feat', flen, zeroIndexed=False) \\n saveSparseHDF5(TRAINMAT,'train', h5file)\\n saveSparseHDF5(VALIDMAT,'valid', h5file)\\n saveSparseHDF5(TESTMAT, 'test' , h5file)\\n dset = {}\\n dset['vocabulary']= [k.strip().split(' ')[0] for k in open(DIR+'/vocab').readlines()]\\n dset['train'] = loadSparseHDF5('train',h5file)\\n dset['valid'] = loadSparseHDF5('valid',h5file)\\n dset['test'] = loadSparseHDF5('test',h5file)\\n dset['dim_observations'] = dset['train'].shape[1]\\n dset['data_type'] = 'bow'\\n return dset\",\n \"def mtf_unitransformer_all_layers_tiny():\\n hparams = mtf_unitransformer_tiny()\\n hparams.moe_num_experts = 4\\n hparams.moe_expert_x = 4\\n hparams.moe_expert_y = 4\\n hparams.moe_hidden_size = 512\\n hparams.layers = [\\\"self_att\\\", \\\"local_self_att\\\", \\\"moe_1d\\\", \\\"moe_2d\\\", \\\"drd\\\"]\\n return hparams\",\n \"def get_prediction_files(test_path, joint_model_path_mapping, \\n mapping_file, column_mapping, erosion_cols, narrowing_cols,\\n image_batch_array):\\n final_prediction_file = pd.DataFrame()\\n for joint_type in joint_model_path_mapping.keys():\\n #Dependency\\n def rmse (y_true, y_pred):\\n return K.sqrt(K.mean(K.square(y_pred -y_true), axis=-1))\\n\\n # from keras_radam import RAdam\\n model_weights = joint_model_path_mapping[joint_type]\\n\\n if joint_type in ['Foot_finger_none', 'Hand_finger_narrowing']:\\n joint_preds = pd.DataFrame()\\n for sub_model in model_weights.keys():\\n weight = model_weights[sub_model][0][0]\\n sub_model_path = model_weights[sub_model][1][0]\\n print(weight, sub_model_path)\\n\\n mapping_type = \\\"_\\\".join(sub_model.split(\\\"_\\\")[:-1])\\n\\n loaded_model = load_model(sub_model_path, custom_objects={'rmse': rmse})\\n print(\\\"Model loaded succesfully -> \\\" + mapping_type)\\n\\n #Loading the image array for prediction\\n # print(image_batch_array[mapping_type][0].shape)\\n\\n preds = pd.DataFrame(weight * loaded_model.predict(image_batch_array[mapping_type][0]))\\n preds.columns = ['labels_'+ str(i) for i in range(preds.shape[1])]\\n\\n joint_preds = pd.concat([joint_preds, preds], axis = 1)\\n\\n joint_preds = joint_preds.groupby(lambda x:x, axis=1).sum()\\n # print(joint_preds.head(10)) \\n\\n \\n #Predictions from model\\n joint_type_df = pd.DataFrame(joint_preds)\\n joint_type_df.columns = ['labels_'+ str(i) for i in range(joint_type_df.shape[1])]\\n\\n # print([img.split(\\\".\\\")[0] for img in image_batch_array[mapping_type][1]])\\n\\n joint_type_df['Joint_image_ID'] = [img.split(\\\".\\\")[0] for img in image_batch_array[mapping_type][1]]\\n print(\\\"Predictions generated \\\")\\n\\n # Getting the prediction type \\n prediction_type = joint_type.split(\\\"_\\\")[-1]\\n # print(prediction_type)\\n # Unique patients in test set\\n patient_id_list = sorted(list(np.unique([img.split(\\\".\\\")[0].split(\\\"-\\\")[0] for img in os.listdir(test_path) if img != 'desktop'])))\\n\\n #Calling the prediciton file generator function\\n temp = get_final_submission_file(joint_type_df, \\\"_\\\".join(joint_type.split(\\\"_\\\")[:-1]), prediction_type, mapping_file, patient_id_list)\\n # print(temp.head())\\n\\n final_prediction_file = pd.concat([final_prediction_file, temp], axis = 1)\\n # print(final_prediction_file)\\n print(\\\"All steps for {} completed succesfully \\\".format(joint_type))\\n\\n else:\\n joint_preds = pd.DataFrame()\\n for weight , model_path in zip(model_weights[0], model_weights[1]):\\n\\n print(weight, model_path)\\n loaded_model = load_model(model_path, custom_objects={'rmse': rmse})\\n print(\\\"Model loaded succesfully -> \\\" + \\\"_\\\".join(joint_type.split(\\\"_\\\")[:-1]))\\n\\n # print(image_batch_array[\\\"_\\\".join(joint_type.split(\\\"_\\\")[:-1])][0].shape)\\n preds = pd.DataFrame(weight * loaded_model.predict(image_batch_array[\\\"_\\\".join(joint_type.split(\\\"_\\\")[:-1])][0]))\\n preds.columns = ['labels_'+ str(i) for i in range(preds.shape[1])]\\n \\n # print(image_batch_array['Hand_finger_erosion'][0].shape)\\n # preds = pd.DataFrame(weight * loaded_model.predict(image_batch_array['Hand_finger_erosion'][0]))\\n # preds.columns = ['labels_'+ str(i) for i in range(preds.shape[1])]\\n\\n # print(preds)\\n joint_preds = pd.concat([joint_preds, preds], axis = 1)\\n \\n joint_preds = joint_preds.groupby(lambda x:x, axis=1).sum()\\n # print(joint_preds.head(10)) \\n\\n #Predictions from model\\n joint_type_df = pd.DataFrame(joint_preds)\\n joint_type_df.columns = ['labels_'+ str(i) for i in range(joint_type_df.shape[1])]\\n\\n # print([img.split(\\\".\\\")[0] for img in image_batch_array[\\\"_\\\".join(joint_type.split(\\\"_\\\")[:-1])][1]])\\n\\n joint_type_df['Joint_image_ID'] = [img.split(\\\".\\\")[0] for img in image_batch_array[\\\"_\\\".join(joint_type.split(\\\"_\\\")[:-1])][1]]\\n # print(\\\"Predictions generated \\\")\\n\\n # Getting the prediction type \\n prediction_type = joint_type.split(\\\"_\\\")[-1]\\n # print(prediction_type)\\n # Unique patients in test set\\n patient_id_list = sorted(list(np.unique([img.split(\\\".\\\")[0].split(\\\"-\\\")[0] for img in os.listdir(test_path) if img != 'desktop'])))\\n\\n #Calling the prediciton file generator function\\n temp = get_final_submission_file(joint_type_df, \\\"_\\\".join(joint_type.split(\\\"_\\\")[:-1]), prediction_type, mapping_file, patient_id_list)\\n\\n final_prediction_file = pd.concat([final_prediction_file, temp], axis = 1)\\n # \\n # print(final_prediction_file)\\n # print(final_prediction_file.columns)\\n\\n print(\\\"All steps for {} completed succesfully \\\".format(joint_type))\\n\\n #Final prediction file\\n \\n final_prediction_file = final_prediction_file .loc[:,~final_prediction_file .columns.duplicated()]\\n final_prediction_file.to_csv(\\\"error_file.csv\\\")\\n final_prediction_file['Overall_Tol'] = np.sum(final_prediction_file[erosion_cols + narrowing_cols], axis = 1)\\n final_prediction_file['Overall_erosion'] = np.sum(final_prediction_file[erosion_cols], axis = 1)\\n final_prediction_file['Overall_narrowing'] = np.sum(final_prediction_file[narrowing_cols], axis = 1)\\n\\n print(final_prediction_file.shape)\\n return final_prediction_file[['Patient_ID', 'Overall_Tol', 'Overall_erosion', 'Overall_narrowing'] + column_mapping]\",\n \"def preprocess():\\n\\n # Read Training and Test Data\\n train_df = pd.read_csv(configs.TRAIN_DATA_PATH)\\n test_df = pd.read_csv(configs.TEST_DATA_PATH)\\n\\n # Data Exploration and Preprocessing\\n user_ids = train_df['userId']\\n movie_ids = train_df['movieId']\\n ratings = train_df['rating']\\n\\n # Create the mapping and save it for later usage in testing\\n all_users = create_mapping(pd.concat([train_df['userId'], test_df['userId']], axis = 0))\\n all_movies = create_mapping(pd.concat([train_df['movieId'], test_df['movieId']], axis = 0))\\n\\n\\n # Save the mapping arrays for users and movies\\n with open(configs.USER_IDS_PATH, \\\"wb\\\") as f:\\n np.save(f, all_users)\\n\\n with open(configs.MOVIE_IDS_PATH, \\\"wb\\\") as f:\\n np.save(f, all_movies)\\n\\n\\n # Resetting the ids of training data to [0-n]\\n user_ids = map_ids(user_ids, users = True)\\n movie_ids = map_ids(movie_ids, users = False)\\n\\n\\n # Resetting the ids of test data\\n test_user_ids = map_ids(test_df['userId'], users = True)\\n test_movie_ids = map_ids(test_df['movieId'], users = False)\\n test_ratings = test_df['rating']\\n\\n # Statistics of training data\\n # Number of users and movies can be extracted from the array of mapped ids\\n n_users = np.max(user_ids) + 1\\n n_movies = np.max(movie_ids) + 1\\n\\n # Statistics of test data\\n test_n_users = np.max(test_user_ids) + 1\\n test_n_movies = np.max(test_movie_ids) + 1\\n\\n # Returning the indices back can be done using unmap_ids function\\n # Example\\n # unmap_ids(movie_ids, users = False)\\n # unmap_ids(user_ids, users = True)\\n\\n # Define the training rating matrix as sparse matrix\\n\\n # Sparse rating matrix from training data\\n R = sparse.coo_matrix(\\n (ratings, (user_ids, movie_ids)),\\n shape=(n_users, n_movies),\\n dtype=np.float\\n )\\n\\n\\n\\n # Save the rating matrix for training data\\n sparse.save_npz(configs.R_TRAIN_MATRIX_PATH, R)\\n\\n # Sparse rating matrix from test data\\n R2 = sparse.coo_matrix(\\n (test_ratings, (test_user_ids, test_movie_ids)),\\n shape=(test_n_users, test_n_movies),\\n dtype=np.float\\n )\\n\\n # Save the rating matrix for test data\\n sparse.save_npz(configs.R_TEST_MATRIX_PATH, R2)\\n\\n # return user_ids, movie_ids, ratings, n_users, n_movies, R, R2\\n return R, R2\",\n \"def main():\\n feature_extraction_model = \\\"HOG\\\"\\n # feature_extraction_models = [\\\"CM\\\", \\\"HOG\\\"]\\n feature_extraction_model_1 = \\\"CM\\\"\\n dimension_reduction_model = \\\"PCA\\\"\\n k_value = 10\\n dim_k_value = 40\\n # K_value = 20\\n # lab_folder = \\\"Dataset3/Labelled/Set1\\\"\\n # unlab_folder = \\\"Dataset3/Unlabelled/Set 2\\\"\\n lab_folder = get_input_folder(\\\"Labelled Folder\\\")\\n unlab_folder = get_input_folder(\\\"Classify\\\")\\n start = time.time()\\n # ================================================================================================================\\n # labelled Images\\n dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value,\\n folder_metadata=lab_folder,\\n metadata_collection=\\\"labelled\\\")\\n obj_feat_lab = dim_red.get_object_feature_matrix()\\n features_list_lab = np.array(obj_feat_lab['featureVector'].tolist())\\n images_list_lab = np.array(obj_feat_lab['imageId'])\\n # filtering the labelled set\\n dorsal_list, palmar_list = filter_images_by_label(images_list_lab)\\n\\n # unlabelled images\\n dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value,\\n folder_metadata=unlab_folder,\\n metadata_collection=\\\"unlabelled\\\")\\n obj_feat_unlab = dim_red.get_object_feature_matrix()\\n features_list_unlab = np.array(obj_feat_unlab['featureVector'].tolist())\\n images_list_unlab = np.array(obj_feat_unlab['imageId'])\\n\\n # ================================================================================================================\\n # labelled Images\\n dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value,\\n folder_metadata=lab_folder,\\n metadata_collection=\\\"labelled\\\")\\n obj_feat_lab_1 = dim_red.get_object_feature_matrix()\\n features_list_lab_1 = np.array(obj_feat_lab_1['featureVector'].tolist())\\n # images_list_lab = np.array(obj_feat_lab_1['imageId'])\\n # filtering the labelled set\\n\\n\\n # unlabelled images\\n dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value,\\n folder_metadata=unlab_folder,\\n metadata_collection=\\\"unlabelled\\\")\\n obj_feat_unlab_1 = dim_red.get_object_feature_matrix()\\n features_list_unlab_1 = np.array(obj_feat_unlab_1['featureVector'].tolist())\\n # images_list_unlab = np.array(obj_feat_unlab['imageId'])\\n features_list_lab = np.concatenate((features_list_lab, features_list_lab_1), axis=1)\\n features_list_unlab = np.concatenate((features_list_unlab, features_list_unlab_1), axis=1)\\n\\n # ================================================================================================================\\n\\n dorsal_list, palmar_list = filter_images_by_label(images_list_lab)\\n features_list = np.concatenate((features_list_lab, features_list_unlab))\\n images_list = np.concatenate((images_list_lab, images_list_unlab))\\n images_list = list(images_list)\\n # Finding Similarity Matrix\\n cos_sim = cosine_similarity(features_list)\\n sim_graph = np.empty((0, len(cos_sim)))\\n for row in cos_sim:\\n k_largest = np.argsort(-np.array(row))[1:k_value + 1]\\n sim_graph_row = [d if i in k_largest else 0 for i, d in enumerate(row)]\\n sim_graph = np.append(sim_graph, np.array([sim_graph_row]), axis=0)\\n\\n row_sums = sim_graph.sum(axis=1)\\n sim_graph = sim_graph / row_sums[:, np.newaxis]\\n idx = 0\\n results_dorsal = ppr(sim_graph, images_list, dorsal_list)\\n results_palmar = ppr(sim_graph, images_list, palmar_list)\\n final_results = {}\\n\\n for img in images_list_unlab:\\n if results_dorsal[img] < results_palmar[img]:\\n final_results[img] = \\\"dorsal\\\"\\n else:\\n final_results[img] = \\\"palmar\\\"\\n\\n actual_labels = fetch_actual_labels(images_list_unlab)\\n print(\\\"Classification\\\")\\n no_correct = 0\\n correctly_classified = []\\n incorrectly_classified = []\\n print(\\\"| ImageId | Prediction | Actual |\\\")\\n for r in final_results:\\n print(\\\"| {} | {} | {} |\\\".format(r, final_results[r], actual_labels[r]))\\n if final_results[r] == actual_labels[r]:\\n correctly_classified.append(r)\\n no_correct += 1\\n else:\\n incorrectly_classified.append(r)\\n\\n print(\\\"Correctly classified: {}\\\\n\\\".format(correctly_classified))\\n print(\\\"InCorrectly classified: {}\\\\n\\\".format(incorrectly_classified))\\n\\n print(\\\"Classification Accuracy: {}%\\\".format(no_correct / len(images_list_unlab) * 100))\\n print(\\\"Execution time: {} seconds\\\".format(time.time() - start))\",\n \"def test_hdf5_convert_to_one_hot():\\n skip_if_no_h5py()\\n import h5py\\n\\n # save random data to HDF5\\n handle, filename = tempfile.mkstemp()\\n dataset = random_dense_design_matrix(np.random.RandomState(1),\\n num_examples=10, dim=5, num_classes=3)\\n with h5py.File(filename, 'w') as f:\\n f.create_dataset('X', data=dataset.get_design_matrix())\\n f.create_dataset('y', data=dataset.get_targets())\\n\\n # instantiate Train object\\n trainer = yaml_parse.load(convert_to_one_hot_yaml % {'filename': filename})\\n trainer.main_loop()\\n\\n # cleanup\\n os.remove(filename)\",\n \"def process_train_set(hdf5_file, train_archive, patch_archive, n_train,\\n wnid_map, shuffle_seed=None):\\n producer = partial(train_set_producer, train_archive=train_archive,\\n patch_archive=patch_archive, wnid_map=wnid_map)\\n consumer = partial(image_consumer, hdf5_file=hdf5_file,\\n num_expected=n_train, shuffle_seed=shuffle_seed)\\n producer_consumer(producer, consumer)\",\n \"def input_setup(config):\\n print(config.is_train)\\n # Load data path\\n if config.is_train:\\n data, label = prepare_data(dataset=\\\"Train/DoF_Images (2)\\\")\\n else:\\n data, label = prepare_data(dataset=\\\"Test\\\")\\n\\n sub_input_sequence = []\\n sub_label_sequence = []\\n padding = abs(config.image_size - config.label_size) / 2 # 6\\n nx = ny = 0\\n\\n if config.is_train:\\n for i in range(len(data)):\\n input_, label_ = preprocess(data[i], label[i], config.scale)\\n\\n if len(input_.shape) == 3:\\n h, w, c = input_.shape\\n else:\\n h, w = input_.shape\\n\\n for x in range(0, h-config.image_size+1, config.stride):\\n if i == 0:\\n nx += 1; ny = 0\\n for y in range(0, w-config.image_size+1, config.stride):\\n if i == 0:\\n ny += 1\\n\\n sub_input = input_[x:x+config.image_size, y:y+config.image_size] # [33 x 33]\\n sub_label = label_[x+int(padding):x+int(padding)+config.label_size\\n , y+int(padding):y+int(padding)+config.label_size] # [21 x 21]\\n # print(sub_input.shape)\\n # print(sub_label.shape)\\n # Make channel value\\n sub_input = sub_input.reshape([config.image_size, config.image_size, 3])\\n sub_label = sub_label.reshape([config.label_size, config.label_size, 3])\\n\\n sub_input_sequence.append(sub_input)\\n sub_label_sequence.append(sub_label)\\n\\n else:\\n nx_l = []\\n ny_l = []\\n for i in range(len(data)):\\n input_, label_ = preprocess(data[i], label[i], config.scale)\\n\\n if len(input_.shape) == 3:\\n h, w, c = input_.shape\\n else:\\n h, w = input_.shape\\n\\n if w >= 4000 or h > 4000:\\n input_ = cv2.resize(input_, dsize=(int(w/2), int(h/2)), interpolation=cv2.INTER_AREA)\\n label_ = cv2.resize(label_, dsize=(int(w/2), int(h/2)), interpolation=cv2.INTER_AREA)\\n w = int(w/2)\\n h = int(h/2)\\n\\n # Numbers of sub-images in height and width of image are needed to compute merge operation.\\n\\n nx = ny = 0\\n for x in range(0, h-config.image_size+1, config.stride):\\n nx += 1; ny = 0\\n for y in range(0, w-config.image_size+1, config.stride):\\n ny += 1\\n sub_input = input_[x:x+config.image_size, y:y+config.image_size] # [33 x 33]\\n sub_label = label_[x+int(padding):x+int(padding)+config.label_size, y+int(padding):y+int(padding)+config.label_size] # [21 x 21]\\n\\n sub_input = sub_input.reshape([config.image_size, config.image_size, 3])\\n sub_label = sub_label.reshape([config.label_size, config.label_size, 3])\\n\\n sub_input_sequence.append(sub_input)\\n sub_label_sequence.append(sub_label)\\n #print(\\\"nx: %d ny: %d\\\" % (nx, ny))\\n nx_l.append(nx)\\n ny_l.append(ny)\\n \\\"\\\"\\\"\\n len(sub_input_sequence) : the number of sub_input (33 x 33 x ch) in one image\\n (sub_input_sequence[0]).shape : (33, 33, 1)\\n \\\"\\\"\\\"\\n # Make list to numpy array. With this transform\\n arrdata = np.asarray(sub_input_sequence) # [?, 33, 33, 3]\\n arrlabel = np.asarray(sub_label_sequence) # [?, 21, 21, 3]\\n\\n make_data(config, arrdata, arrlabel)\\n print(\\\"make_data success\\\")\\n if config.is_train:\\n return nx, ny\\n else:\\n return nx_l, ny_l, len(data)\",\n \"def initSets(self):\\n data_frame = pd.read_csv(self.train_file, header=None)\\n data_frame = data_frame.drop(columns=self.drop_cols)\\n features = data_frame.iloc[:, :-1].values\\n labels = data_frame.iloc[:, -1].values\\n if self.test_file is None:\\n self.train_feat, self.test_feat, self.train_labl, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\\n else:\\n data_frame = pd.read_csv(self.test_file, header=None)\\n data_frame = data_frame.drop(columns=self.drop_cols)\\n self.train_feat, _, self.train_labl, _ = train_test_split(features, labels, test_size=self.test_size)\\n features = data_frame.iloc[:, :-1].values\\n labels = data_frame.iloc[:, -1].values\\n _, self.test_feat, _, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\\n # kfold = KFold(n_splits=3)\\n # self.train_index, self.test_index = kfold.split(features,labels)\",\n \"def test_function_kg(test_loader, model, settype, S, lk, bk, num_iters, epsilon, num_classes, topk):\\r\\n\\r\\n det_boxes = []\\r\\n det_labels = []\\r\\n det_scores = []\\r\\n true_boxes = []\\r\\n true_labels = []\\r\\n true_difficulties = []\\r\\n true_areas = []\\r\\n\\r\\n with torch.no_grad():\\r\\n for i, (images, targets) in enumerate(test_loader):\\r\\n\\r\\n # Move to default device.\\r\\n images = [im.to(device) for im in images]\\r\\n\\r\\n # Some (1021) images of COCO contain no objects at all. These are filtered out in the data loader, but\\r\\n # return an empty list, which raises an error in the model, so they are skipped.\\r\\n if len(images) == 0:\\r\\n continue\\r\\n\\r\\n prediction = model(images)\\r\\n\\r\\n for p in range(len(prediction)-1):\\r\\n true_boxes.append(targets[p]['boxes'].to(device))\\r\\n true_labels.append(targets[p]['labels'].to(device))\\r\\n\\r\\n if settype == 'voc':\\r\\n true_difficulties.append(targets[p]['difficulties'].to(device))\\r\\n # true_difficulties.append(torch.zeros(len(targets[p]['boxes'])).to(device))\\r\\n true_areas.append(torch.zeros(len(targets[p]['boxes'])).to(device))\\r\\n else:\\r\\n true_difficulties.append(torch.zeros(len(targets[p]['boxes'])).to(device))\\r\\n true_areas.append(targets[p]['areas'].to(device))\\r\\n\\r\\n boxes_temp = prediction[1][0]['boxes']\\r\\n labels_temp = prediction[1][0]['labels']\\r\\n scores_temp = prediction[1][0]['scores']\\r\\n\\r\\n new_predictions = torch.zeros((boxes_temp.shape[0], num_classes)).to(device)\\r\\n\\r\\n for l in range(new_predictions.shape[0]):\\r\\n label = labels_temp[l] - 1\\r\\n new_predictions[l, label] = scores_temp[l]\\r\\n\\r\\n p_hat = find_p_hat(boxes_temp, new_predictions, bk, lk, S, num_iters, epsilon)\\r\\n\\r\\n predk, boxk, labk, scok = find_top_k(p_hat, boxes_temp, topk)\\r\\n\\r\\n det_boxes.append(boxk)\\r\\n det_labels.append(labk)\\r\\n det_scores.append(scok)\\r\\n\\r\\n del prediction\\r\\n torch.cuda.empty_cache()\\r\\n\\r\\n return det_boxes, det_labels, det_scores, true_boxes, true_labels, true_difficulties, true_areas\",\n \"def create_train_validate_test_sets(self,X,Y):\\n\\n\\t\\tprint \\\"Size of the original images\\\"\\n\\n\\t\\tX = np.asarray(X, dtype=theano.config.floatX)\\n\\t\\t\\n\\t\\ttrain_length = int(round(len(X) * 0.60))\\n\\t\\tvalid_length = int(round(len(X) * 0.20))\\n\\t\\ttest_length = int(round(len(X) * 0.20))\\n\\n\\t\\tX_train = X[0:train_length]\\n\\t\\tX_valid = X[train_length: (train_length + valid_length)]\\n\\t\\tX_test = X[-test_length:]\\n\\n\\t\\t# sample = X_train[0].reshape(64,64)\\n\\n\\t\\t# X_train = X_train.transpose(0, 3, 1, 2)\\n\\t\\t# X_valid = X_valid.transpose(0, 3, 1, 2)\\n\\t\\t# X_test = X_test.transpose(0, 3, 1, 2)\\n\\n\\t\\t# X = X.transpose(0, 3, 1, 2)\\n\\n\\t\\tX_train = map(self.flaten_aux, X_train)\\n\\t\\tX_valid = map(self.flaten_aux, X_valid)\\n\\t\\tX_test = map(self.flaten_aux, X_test)\\n\\n\\t\\t# X = map(self.flaten_aux, X)\\n\\n\\t\\t#print X_train.shape\\n\\t\\t#X = X.transpose(0, 3, 1, 2)\\n\\t\\t# X = np.asarray(X, dtype=theano.config.floatX)\\n\\t\\t# X = X.reshape((21, 3, 64, 64))\\n\\t\\t# print X.shape\\n\\t\\t# #X_train = X_train.transpose(0, 3, 1, 2)\\n\\t\\t# #print X[0].\\n\\t\\t# im = Image.fromarray(X[0],mode=\\\"RGB\\\")\\n\\t\\t# im.show()\\n\\t\\t#self.reconstructImage(X[0]).show()\\n\\t\\t# sample = X_train[0].reshape(64,64)\\n\\t\\t# Image.fromarray(sample,mode=\\\"L\\\").show()\\n\\n\\t\\t#X = map(self.flaten_aux, X)\\n\\n\\t\\t# X_train = X[0:train_length]\\n\\t\\t# X_valid = X[train_length: (train_length + valid_length)]\\n\\t\\t# X_test = X[-test_length:]\\n\\n\\t\\tY_train = Y[0:train_length]\\n\\t\\tY_valid = Y[train_length:(train_length + valid_length)]\\n\\t\\tY_test = Y[-test_length:]\\n\\n\\t\\t#pkl_file = open( '../data/lb.pkl', 'rb')\\n\\t\\t#lb = cPickle.load(pkl_file)\\n\\n\\t\\t#arr = np.array(np.round((X_train[0] * 256).reshape((64,64))),dtype=np.uint8)\\n\\t\\t# Image.fromarray(arr,mode=\\\"L\\\").show()\\n\\t\\t# print lb.classes_\\n\\t\\t# print Y_train[0]\\n\\n\\t\\ttrain_set = [X_train,Y_train]\\n\\t\\tvalid_set = [X_valid,Y_valid]\\n\\t\\ttest_set = [X_test,Y_test]\\n\\t\\tinput = [X,Y]\\n\\n\\t\\tif self.verbose:\\n\\t\\t\\tprint \\\"X_train {} X_validation {} X_test {}\\\".format(len(X_train),len(X_valid),len(X_test))\\n\\t\\t\\tprint \\\"Y_train {} Y_validation {} Y_test {}\\\".format(len(Y_train),len(Y_valid),len(Y_test))\\n\\n\\t\\toutput = open(self.data_path + 'train_set.pkl', 'wb')\\n\\t\\tcPickle.dump(train_set, output,protocol=-1)\\n\\t\\toutput.close()\\n\\n\\t\\toutput = open(self.data_path + 'valid_set.pkl', 'wb')\\n\\t\\tcPickle.dump(valid_set, output,protocol=-1)\\n\\t\\toutput.close()\\n\\n\\t\\toutput = open(self.data_path + 'test_set.pkl', 'wb')\\n\\t\\tcPickle.dump(test_set, output,protocol=-1)\\n\\t\\toutput.close()\\n\\t\\t\\n\\t\\treturn train_set,valid_set,test_set\",\n \"def __init__(self, args):\\n\\n self.args = args\\n\\n \\\"\\\"\\\"class args:\\n rows=16\\n cols=640\\n baseinfo=10\\n hps = 128\\n hpdist = 33\\n \\\"\\\"\\\"\\n\\n inputs = KK.layers.Input(shape=(args.rows,args.cols,args.baseinfo))\\n x = KK.layers.Conv2D(64, kernel_size= (1, 6), strides=(1,5), activation='relu')(inputs)\\n x = KK.layers.Conv2D(64, (16, 1), activation='relu')(x)\\n bottle = KK.layers.Flatten()(x) # This is now the bottleneck\\n\\n self.model = KK.models.Model(inputs=inputs, outputs=[bottle])\\n self.model.summary()\\n\\n ################################\\n # predict hp lengths\\n predsHPLEN = []\\n for ii in range( args.hps ):\\n tmp = KK.layers.Dense(args.hpdist, activation='softmax')(bottle)\\n # print(\\\"tmp\\\",tmp.shape) # tmp (N, 33)\\n predsHPLEN.append(tmp)\\n\\n # # stack into one array yielding (128,N,33)\\n predsHPLEN2 = KK.backend.stack(predsHPLEN)\\n print(\\\"predsHPLEN2.shape\\\", predsHPLEN2.shape)\\n\\n # # permute to yield (N,128,33) to compare against truth\\n predictionsHPLEN = KK.backend.permute_dimensions(predsHPLEN2,(1,0,2))\\n print(\\\"predictionsHPLEN.shape\\\",predictionsHPLEN.shape) # predictions.shape (?, 128, 33)\\n\\n ################################\\n # predict hp base IDentity\\n predsHPID = []\\n for ii in range( args.hps ):\\n tmp = KK.layers.Dense(4, activation='softmax')(bottle)\\n # print(\\\"tmp\\\",tmp.shape) # tmp (N, 4)\\n predsHPID.append(tmp)\\n\\n # # stack into one array yielding (128,N,4)\\n predsHPID2 = KK.backend.stack(predsHPID)\\n print(\\\"predsHPID2.shape\\\", predsHPID2.shape)\\n\\n # # permute to yield (N,128,4) to compare against truth\\n predictionsHPID = KK.backend.permute_dimensions(predsHPID2,(1,0,2))\\n print(\\\"predictionsHPID.shape\\\",predictionsHPID.shape) # predictions.shape (?, 128, 4)\\n\\n ################################\\n self.model = KK.models.Model(inputs=inputs, outputs=[predictionsHPID,predictionsHPLEN])\\n\\n #self.model.summary()\\n # # ValueError: You tried to call `count_params` on stack, but the layer isn't built. You can build it manually via: `stack.build(batch_input_shape)`.\\n\\n self.model.compile(optimizer=\\\"adam\\\", loss=\\\"categorical_crossentropy\\\", metrics=[\\\"categorical_accuracy\\\",\\\"kullback_leibler_divergence\\\"])\\n\\n # # instrument tensorboard\\n # tf.summary.histogram('output', self.output)\\n # tf.summary.histogram('softmax_w', softmax_w)\\n # tf.summary.histogram('logits', self.logits)\\n # tf.summary.histogram('probs', self.probs)\\n # tf.summary.scalar('train_loss', self.cost)\",\n \"def get_model_2(parameters):\\n # Parameters\\n BANDS = parameters['num_features']\\n CLASSES = parameters['num_classes']\\n \\n # Sequential model\\n model = keras.models.Sequential()\\n \\n # Add convolution (1)\\n # -------------------\\n # Input_shape (batch, rows, cols, channels) = (-, 9, BANDS, 1)\\n # Output_shape (batch, rows, cols, channels) = (-, BANDS - 15, 1, 32)\\n model.add(keras.layers.Conv2D(filters=32,\\n kernel_size=(9, 16),\\n padding='same',\\n data_format=\\\"channels_last\\\",\\n activation='tanh',\\n input_shape=(9, BANDS,1)))\\n \\n # Add convolution (2)\\n # -------------------\\n # Input_shape (batch, rows, cols, channels) = (-, BANDS - 15, 1, 32)\\n # Output_shape (batch, rows, cols, channels) = (-, BANDS - 30, 1, 32)\\n model.add(keras.layers.Conv2D(filters=32,\\n kernel_size=(1, 16),\\n padding='same',\\n data_format=\\\"channels_last\\\",\\n activation='tanh'))\\n \\n # Add convolution (3)\\n # -------------------\\n # Input_shape (batch, rows, cols, channels) = (-, BANDS - 30, 1, 32)\\n # Output_shape (batch, rows, cols, channels) = (-, BANDS - 45, 1, 32)\\n model.add(keras.layers.Conv2D(filters=32,\\n kernel_size=(1, 16),\\n padding='same',\\n data_format=\\\"channels_last\\\",\\n activation='tanh'))\\n \\n # Flatten before dense layer\\n model.add(keras.layers.Flatten())\\n \\n # Add fully connected (4)\\n # -----------------------\\n # Intput_shape (batch, rows, cols, channels) = (-, (BANDS - 45) x 1 x 32)\\n # Output_shape (batch, dim) = (-, 800)\\n model.add(keras.layers.Dense(units=800,\\n activation='tanh'))\\n \\n # Add fully connected (5)\\n # -----------------------\\n # Intput_shape (batch, dim) = (-, 800)\\n # Output_shape (batch, dim) = (-, 800)\\n model.add(keras.layers.Dense(units=800,\\n activation='softmax'))\\n \\n # Add fully connected to reduce to number of categories\\n # -----------------------------------------------------\\n # Intput_shape (batch, dim) = (-, 800)\\n # Output_shape (batch, dim) = (-, CLASSES)\\n model.add(keras.layers.Dense(units=CLASSES,\\n activation='softmax'))\\n \\n # Compile model\\n model.compile(optimizer='adam',\\n loss='categorical_crossentropy',\\n metrics=['accuracy'])\\n \\n # Print the model summary to output file\\n # To print to stdout: model.summary()\\n with open(OUTPUT_FILE, 'a') as f:\\n # Pass the file handle in as a lambda function to make it callable\\n model.summary(print_fn=lambda x: f.write(x + '\\\\n'))\\n \\n # Return the model\\n return model\",\n \"def data_set_maker():\\n\\n # crate a folder in your code directory and name it: \\\"files\\\". put the .npy files iside that folder\\n path = os.getcwd() # reads the current path\\n x_train = np.load(path + '/files/tinyX.npy', 'r') # reads the input file\\n y_train = np.load(path + '/files/tinyY.npy', 'r') # reads the input file\\n x_test = np.load(path + '/files/tinyX_test.npy', 'r') # reads the input file\\n x_train, y_train = shuffle(x_train, y_train)\\n\\n return x_train, y_train, x_test\",\n \"def index_subset(subset, numTestClasses=3, randomSeed=123):\\n print(\\\"datasets.py is ingesting the DF dataset from data/DC.npz\\\")\\n npzfile = np.load(\\\"data/DC.npz\\\", allow_pickle=True)\\n data = npzfile[\\\"data\\\"]\\n labels = npzfile[\\\"labels\\\"]\\n npzfile.close()\\n distinctLabelCount= len(set(labels))\\n \\n #print(\\\"data\\\", data.shape)\\n #print(\\\"labels\\\", labels.shape)\\n #print(\\\"distinctLabelCount\\\", distinctLabelCount)\\n \\n #random.seed(randomSeed)\\n testClasses = random.sample(range(0,distinctLabelCount),numTestClasses)\\n testClasses = [np.float64(i) for i in testClasses]\\n \\n \\n mask = np.isin(labels,testClasses)\\n\\n X_test = data[np.where(mask)]\\n X_train = data[np.where(~mask)]\\n y_test = labels[np.where(mask)]\\n y_train = labels[np.where(~mask)]\\n \\n if subset==\\\"background\\\":\\n print(\\\"Current working directory is \\\", os.getcwd())\\n X = X_train\\n y = y_train\\n print(\\\"DC background data shape\\\", X.shape)\\n elif subset==\\\"evaluation\\\":\\n X = X_test\\n y = y_test\\n print(\\\"DC evaluation data shape\\\", X.shape)\\n images = []\\n \\n #print(\\\"y shape\\\", y.shape)\\n \\n \\n for i in range(y.shape[0]):\\n images.append({\\n 'subset': subset,\\n 'class_name': y[i],\\n 'data': X[i].reshape(1,X[1].shape[0]) # This is the shape needed for Matching Networks\\n #'data': X[i] #.reshape(X[1].shape[0]) # This is the shape needed for MAML\\n })\\n \\n return images\",\n \"def create_dummy_data():\\n data = loadmat(join(project_root, './data/lungs.mat'))['seq']\\n nx, ny, nt = data.shape\\n ny_red = 8\\n sl = ny//ny_red\\n data_t = np.transpose(data, (2, 0, 1))\\n\\n data_t[:, :, :sl*4]\\n train_slice = data_t[:, :, :sl*4]\\n validate_slice = data_t[:, :, ny//2:ny//2+ny//4]\\n test_slice = data_t[:, :, ny//2+ny//4]\\n\\n # Synthesize data by extracting patches\\n train = np.array([data_t[..., i:i+sl] for i in np.random.randint(0, sl*3, 20)])\\n validate = np.array([data_t[..., i:i+sl] for i in (sl*4, sl*5)])\\n test = np.array([data_t[..., i:i+sl] for i in (sl*6, sl*7)])\\n\\n return train, validate, test\",\n \"def _demo_mm_inputs(input_shape: tuple, num_classes: int):\\n (N, C, H, W) = input_shape\\n rng = np.random.RandomState(0)\\n imgs = rng.rand(*input_shape)\\n gt_labels = rng.randint(\\n low=0, high=num_classes, size=(N, 1)).astype(np.uint8)\\n mm_inputs = {\\n 'imgs': torch.FloatTensor(imgs).requires_grad_(False),\\n 'gt_labels': torch.LongTensor(gt_labels),\\n }\\n return mm_inputs\",\n \"def prepare_data(self):\\n data = self._get_dataset(self.hparams.dataset_path)\\n label_encoder = data[\\\"label_encoder\\\"]\\n del data[\\\"label_encoder\\\"]\\n\\n click.secho(\\\"Building inputs and labels.\\\", fg=\\\"yellow\\\")\\n datasets = {\\n \\\"train\\\": defaultdict(list),\\n \\\"valid\\\": defaultdict(list),\\n \\\"test\\\": defaultdict(list),\\n }\\n for dataset_name, dataset in data.items():\\n for sample in dataset:\\n instance = self.build_input(\\n self.tokenizer, sample[\\\"text\\\"], label_encoder, sample[\\\"label\\\"]\\n )\\n for input_name, input_array in instance.items():\\n datasets[dataset_name][input_name].append(input_array)\\n\\n click.secho(\\\"Padding inputs and building tensors.\\\", fg=\\\"yellow\\\")\\n tensor_datasets = {\\\"train\\\": [], \\\"valid\\\": [], \\\"test\\\": []}\\n for dataset_name, dataset in datasets.items():\\n dataset = self.pad_dataset(dataset, padding=self.tokenizer.pad_index)\\n for input_name in MODEL_INPUTS:\\n if input_name == \\\"labels\\\":\\n tensor = torch.tensor(dataset[input_name], dtype=torch.float32)\\n else:\\n tensor = torch.tensor(dataset[input_name])\\n tensor_datasets[dataset_name].append(tensor)\\n\\n self.train_dataset = TensorDataset(*tensor_datasets[\\\"train\\\"])\\n self.valid_dataset = TensorDataset(*tensor_datasets[\\\"valid\\\"])\\n self.test_dataset = TensorDataset(*tensor_datasets[\\\"test\\\"])\\n click.secho(\\n \\\"Train dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.train_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\\n click.secho(\\n \\\"Valid dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.valid_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\\n click.secho(\\n \\\"Test dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.test_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\",\n \"def output_rule_feature_matrices():\\n with open(config.data_path + config.sentiment_seed, 'rb') as input_file:\\n sentiment_dict = pickle.load(input_file)\\n seed_sentiments = set(sentiment_dict.keys())\\n \\n for i in range(len(config.file_names)):\\n if i is 5:\\n print('processing ', config.file_names[i])\\n fname = config.file_names[i]\\n feature_x, feature_y, opinion_x, opinion_y = text_to_matrix(\\n fname, seed_sentiments)\\n feature_x = np.transpose(feature_x)\\n opinion_x = np.transpose(opinion_x)\\n with open('../results/' + fname + '_rule_feature_matrix.pickle', 'wb') as f:\\n pickle.dump(feature_x, f)\\n with open('../results/' + fname + '_rule_opinion_matrix.pickle', 'wb') as f:\\n pickle.dump(opinion_x, f)\\n\\n with open('../results/' + fname + '_feature_label.pickle', 'wb') as f:\\n pickle.dump(feature_y.ravel(), f)\\n with open('../results/' + fname + '_opinion_label.pickle', 'wb') as f:\\n pickle.dump(opinion_y.ravel(), f)\",\n \"def create_train_test_sets(conform_shape=True, indi_proportion=0.50, incl_group_imgs=True):\\r\\n X_train_indi, y_train_indi = build_dataframe('Individual_Training_Images',\\r\\n img_input_shape, conform_shape=conform_shape)\\r\\n X_test_indi, y_test_indi = build_dataframe('Individual_Test_Images',\\r\\n img_input_shape, conform_shape=conform_shape)\\r\\n \\r\\n X_train_group, y_train_group = build_dataframe('Group_Training_Images',\\r\\n img_input_shape, conform_shape=conform_shape)\\r\\n X_test_group, y_test_group = build_dataframe('Group_Test_Images',\\r\\n img_input_shape, conform_shape=conform_shape)\\r\\n \\r\\n X_train_indi, y_train_indi = subsample_dataframe(X_train_indi, y_train_indi,indi_proportion)\\r\\n \\r\\n if incl_group_imgs:\\r\\n X_train = np.concatenate([X_train_indi,X_train_group])\\r\\n y_train = np.concatenate([y_train_indi,y_train_group])\\r\\n else: \\r\\n X_train = X_train_indi.copy()\\r\\n y_train = y_train_indi.copy()\\r\\n\\r\\n return X_train, y_train, X_test_indi, y_test_indi, X_test_group, y_test_group\",\n \"def train(\\n train_sets: tuple,\\n test_sets: tuple,\\n input_shape: tuple = (1, 128, 128, 1),\\n model_version=\\\"1.0.0\\\",\\n epochs: int = 100,\\n classes: int = 2,\\n batch_size: int = 1,\\n verbose=1,\\n out_dir: str = \\\"saved_models\\\"):\\n (x_train, y_train), (x_test, y_test) = train_sets, test_sets\\n y_train = keras.utils.to_categorical(y_train, classes)\\n y_test = keras.utils.to_categorical(y_test, classes)\\n m = get_model(model_version)\\n if not m:\\n return\\n model = m.build_model(input_shape)\\n model.compile(\\n loss=BinaryCrossentropy(),\\n optimizer=RMSprop(learning_rate=0.0001),\\n metrics=['accuracy']\\n )\\n saver = ModelSaver(out_dir)\\n csv_logger = CSVLogger(\\n \\\"%s/%s/log.csv\\\" %\\n (out_dir, datetime.datetime.now().date().strftime(\\\"%Y_%m_%d\\\")),\\n append=True,\\n separator=','\\n )\\n history = model.fit(\\n x_train,\\n y_train,\\n batch_size=batch_size,\\n epochs=epochs,\\n verbose=verbose,\\n validation_data=(x_test, y_test),\\n callbacks=[saver, csv_logger]\\n )\\n model.save(\\\"%s/%s/final.hd5\\\" %\\n (out_dir, datetime.datetime.now().date().strftime(\\\"%Y_%m_%d\\\")))\\n print(\\\"Model saved in %s as final.hd5\\\" % out_dir)\\n plot_results(\\n history,\\n epochs,\\n out_dir\\n )\",\n \"def __init__(\\n self,\\n numpy_rng,\\n train_set_x,\\n train_set_y,\\n hidden_layers_sizes,\\n n_ins=784,\\n n_outs=10\\n ):\\n\\n self.sigmoid_layers = []\\n self.AE_layers = []\\n self.params = []\\n self.n_layers = len(hidden_layers_sizes)\\n self.train_set_x = train_set_x\\n self.train_set_y = train_set_y\\n\\n assert self.n_layers > 0\\n\\n self.x = T.matrix('x') # the data is presented as rasterized images\\n self.y = T.ivector('y') # the labels are presented as 1D vector of\\n\\n for i in xrange(self.n_layers): # used to be n layers\\n\\n # construct the sigmoid layer = encoder stack\\n if i == 0:\\n layer_input = self.x\\n else:\\n layer_input = self.sigmoid_layers[-1].output\\n\\n sigmoid_layer = HiddenLayer(rng=numpy_rng,\\n input=layer_input,\\n n_in=(n_ins if i == 0 else\\n hidden_layers_sizes[i-1]),\\n n_out=hidden_layers_sizes[i],\\n activation=T.nnet.sigmoid)\\n\\n # add the layer to our list of layers\\n self.sigmoid_layers.append(sigmoid_layer)\\n self.params.extend(sigmoid_layer.params)\\n\\n # init the DA_layer, takes weights from sigmoid layer\\n AE_layer = AutoEncoder(\\n numpy_rng=numpy_rng,\\n input=layer_input,\\n n_visible=(n_ins if i == 0 else hidden_layers_sizes[i-1]),\\n n_hidden=hidden_layers_sizes[i],\\n W=sigmoid_layer.W,\\n bhid=sigmoid_layer.b)\\n\\n self.AE_layers.append(AE_layer)\\n\\n # on top of the layers\\n # log layer for fine-tuning\\n self.logLayer = LogisticRegression(\\n input=self.sigmoid_layers[-1].output,\\n n_in=hidden_layers_sizes[-1],\\n n_out=n_outs\\n )\\n self.params.extend(self.logLayer.params)\\n self.finetune_cost = self.logLayer.negative_log_likelihood(self.y)\\n self.errors = self.logLayer.errors(self.y)\",\n \"def createDataset_inpainting(outputPath, imagePathList, labelList):\\n assert (len(imagePathList) == len(box_x_list) == len(box_y_list))\\n nSamples = len(imagePathList)\\n if not os.path.exists(outputPath):\\n os.mkdir(outputPath)\\n env = lmdb.open(outputPath, map_size=1099511627776)\\n cache = {}\\n cnt = 1\\n for i in range(nSamples):\\n imagePath = imagePathList[i]\\n box_x = box_x_list[i]\\n box_y = box_y_list[i]\\n if len(box_x) == 0:\\n continue\\n if not os.path.exists(imagePath):\\n print('%s does not exist' % imagePath)\\n continue\\n with open(imagePath, 'rb') as f:\\n imageBin = f.read()\\n\\n imageKey = 'image-%09d' % cnt\\n cache[imageKey] = imageBin\\n box_x_Key = 'boxes_x-%09d' % cnt\\n box_y_Key = 'boxes_y-%09d' % cnt\\n cache[box_x_Key] = box_x.encode()\\n cache[box_y_Key] = box_y.encode()\\n\\n if labelList:\\n labelKey = 'label-%09d' % cnt\\n cache[labelKey] = labelList[i].encode()\\n if region_mask_list:\\n region_mask_Key = 'region_mask-%09d' % cnt\\n cache[region_mask_Key] = open(region_mask_list[i], 'rb').read()\\n if pixel_mask_list:\\n pixel_mask_Key = 'pixel_mask-%09d' % cnt\\n cache[pixel_mask_Key] = open(pixel_mask_list[i], 'rb').read()\\n # embed()\\n if cnt % 1000 == 0:\\n writeCache(env, cache)\\n cache = {}\\n print('Written %d / %d' % (cnt, nSamples))\\n cnt += 1\\n nSamples = cnt - 1\\n cache['num-samples'] = str(nSamples).encode()\\n writeCache(env, cache)\\n print('Created dataset with %d samples' % nSamples)\",\n \"def build_full_trainset(self):\\n\\n return self.construct_trainset(self.raw_ratings)\",\n \"def make_dataset(\\n *,\\n k_size: int = 5,\\n j_size: int,\\n i_size: int,\\n time_size: int = 4,\\n grid_type: Type[ShocGridGenerator] = DiagonalShocGrid,\\n corner_size: int = 0,\\n) -> xarray.Dataset:\\n coordinate_centre_mask = numpy.full((j_size, i_size), True)\\n # Cut a chunk out of the corner where the coordinates will not be defined.\\n if corner_size > 1:\\n coordinate_centre_mask[-(corner_size - 1):, :+(corner_size - 1)] = False\\n\\n # SHOC files have a 1-cell border around the outside where the cells have\\n # coordinates, but no data.\\n wet_centre_mask = numpy.full((j_size, i_size), True)\\n if corner_size > 0:\\n wet_centre_mask[-corner_size:, :+corner_size] = False\\n wet_centre_mask[-corner_size:, -corner_size:] = False\\n wet_centre_mask[:+1, :] = False\\n wet_centre_mask[-1:, :] = False\\n wet_centre_mask[:, :+1] = False\\n wet_centre_mask[:, -1:] = False\\n wet_mask = c_mask_from_centres(wet_centre_mask, {\\n ArakawaCGridKind.face: ('j_centre', 'i_centre'),\\n ArakawaCGridKind.back: ('j_back', 'i_back'),\\n ArakawaCGridKind.left: ('j_left', 'i_left'),\\n ArakawaCGridKind.node: ('j_node', 'i_node'),\\n })\\n\\n # These DataArrays are the long/lats of the grid corners. The centres are\\n # derived from these by averaging the surrounding four corners.\\n grid = grid_type(j=j_size, i=i_size, face_mask=coordinate_centre_mask)\\n layers = ShocLayerGenerator(k=k_size)\\n\\n t = xarray.DataArray(\\n # Note: Using pandas.date_range() directly here will lead to strange\\n # behaviours, where the `record` dimension becomes a data variable with\\n # a datetime64 dtype. Using a list of datetimes instead seems to avoid\\n # this, resulting in record simply being a dimension.\\n data=list(pandas.date_range(\\\"2021-11-11\\\", periods=time_size)),\\n dims=[\\\"record\\\"],\\n attrs={\\n \\\"long_name\\\": \\\"Time\\\",\\n \\\"standard_name\\\": \\\"time\\\",\\n \\\"coordinate_type\\\": \\\"time\\\",\\n },\\n )\\n # Note: xarray will reformat this in to 1990-01-01T00:00:00+10:00, which\\n # EMS fails to parse. There is no way around this using xarray natively,\\n # you have to adjust it with nctool after saving it.\\n t.encoding[\\\"units\\\"] = \\\"days since 1990-01-01 00:00:00 +10\\\"\\n\\n botz = xarray.DataArray(\\n data=numpy.random.random((j_size, i_size)) * 10 + 50,\\n dims=wet_mask[\\\"face_mask\\\"].dims,\\n attrs={\\n \\\"units\\\": \\\"metre\\\",\\n \\\"long_name\\\": \\\"Z coordinate at sea-bed at cell centre\\\",\\n \\\"standard_name\\\": \\\"depth\\\",\\n \\\"positive\\\": \\\"down\\\",\\n \\\"outside\\\": \\\"9999\\\",\\n \\\"missing_value\\\": -99.,\\n }\\n ).where(wet_mask.data_vars[\\\"face_mask\\\"])\\n botz.values[1, 1] = -99.\\n\\n eta = xarray.DataArray(\\n data=numpy.random.normal(0, 0.2, (time_size, j_size, i_size)),\\n dims=[\\\"record\\\", *wet_mask[\\\"face_mask\\\"].dims],\\n attrs={\\n \\\"units\\\": \\\"metre\\\",\\n \\\"long_name\\\": \\\"Surface elevation\\\",\\n \\\"standard_name\\\": \\\"sea_surface_height_above_geoid\\\",\\n }\\n ).where(wet_mask.data_vars[\\\"face_mask\\\"])\\n temp = xarray.DataArray(\\n data=numpy.random.normal(12, 0.5, (time_size, k_size, j_size, i_size)),\\n dims=[\\\"record\\\", \\\"k_centre\\\", *wet_mask[\\\"face_mask\\\"].dims],\\n attrs={\\n \\\"units\\\": \\\"degrees C\\\",\\n \\\"long_name\\\": \\\"Temperature\\\",\\n },\\n ).where(wet_mask.data_vars[\\\"face_mask\\\"])\\n\\n u1 = xarray.DataArray(\\n data=numpy.random.normal(0, 2, (time_size, k_size, j_size, i_size + 1)),\\n dims=[\\\"record\\\", \\\"k_centre\\\", *wet_mask.data_vars[\\\"left_mask\\\"].dims],\\n attrs={\\n \\\"units\\\": \\\"metre second-1\\\",\\n \\\"long_name\\\": \\\"I component of current at left face\\\",\\n }\\n )\\n u2 = xarray.DataArray(\\n data=numpy.random.normal(0, 2, (time_size, k_size, j_size + 1, i_size)),\\n dims=[\\\"record\\\", \\\"k_centre\\\", *wet_mask.data_vars[\\\"back_mask\\\"].dims],\\n attrs={\\n \\\"units\\\": \\\"metre per second\\\",\\n \\\"long_name\\\": \\\"I component of current at back face\\\",\\n }\\n )\\n flag = xarray.DataArray(\\n data=numpy.random.randint(0, 256, (time_size, k_size, j_size + 1, i_size + 1)),\\n dims=[\\\"record\\\", \\\"k_centre\\\", *wet_mask.data_vars[\\\"node_mask\\\"].dims],\\n attrs={\\\"long_name\\\": \\\"SHOC masking flags\\\"},\\n )\\n\\n dataset = xarray.Dataset(\\n data_vars={\\n **layers.standard_vars,\\n **grid.standard_vars,\\n \\\"botz\\\": botz,\\n \\\"t\\\": t,\\n \\\"eta\\\": eta,\\n \\\"temp\\\": temp,\\n \\\"u1\\\": u1,\\n \\\"u2\\\": u2,\\n \\\"flag\\\": flag,\\n },\\n attrs={\\n \\\"title\\\": \\\"Example SHOC dataset\\\",\\n \\\"ems_version\\\": \\\"v1.2.3 fake\\\",\\n \\\"Conventions\\\": \\\"CMR/Timeseries/SHOC\\\",\\n \\\"nce1\\\": j_size,\\n \\\"nce2\\\": i_size,\\n \\\"nfe1\\\": j_size + 1,\\n \\\"nfe2\\\": i_size + 1,\\n \\\"gridtype\\\": \\\"NUMERICAL\\\",\\n },\\n )\\n dataset.encoding[\\\"unlimited_dims\\\"] = {\\\"record\\\"}\\n return dataset\",\n \"def get_P5(self):\\n msk = self.load_mask()\\n dimtgt = sum(1-v for v in msk)\\n dimsrc = self.vs.get_dimension() if self.vs.is_valid() else 0\\n M = matrix(dimtgt, dimsrc, sparse = True)\\n j = 0\\n for (i, v) in enumerate(msk):\\n if v == 0:\\n M[j, i] = 1\\n j=j+1\\n return M\",\n \"def _build_model(self):\\n\\n with tf.variable_scope(\\\"Matchnet\\\", reuse=tf.AUTO_REUSE):\\n # For determining the runtime shape\\n x_shp = tf.shape(self.x_in)\\n\\n # -------------------- Network archintecture --------------------\\n # Build graph\\n print(\\\"Building Graph\\\")\\n self.logits = build_graph(self.x_in, self.is_training, self.config)\\n # ---------------------------------------------------------------\\n\\n # Turn into weights for each sample\\n weights = tf.nn.relu(tf.tanh(self.logits))\\n\\n # Make input data (num_img_pair x num_corr x 4)\\n xx = tf.transpose(tf.reshape(\\n self.x_in, (x_shp[0], x_shp[2], 4)), (0, 2, 1))\\n\\n # Create the matrix to be used for the eight-point algorithm\\n X = tf.transpose(tf.stack([\\n xx[:, 2] * xx[:, 0], xx[:, 2] * xx[:, 1], xx[:, 2],\\n xx[:, 3] * xx[:, 0], xx[:, 3] * xx[:, 1], xx[:, 3],\\n xx[:, 0], xx[:, 1], tf.ones_like(xx[:, 0])\\n ], axis=1), (0, 2, 1))\\n print(\\\"X shape = {}\\\".format(X.shape))\\n wX = tf.reshape(weights, (x_shp[0], x_shp[2], 1)) * X\\n print(\\\"wX shape = {}\\\".format(wX.shape))\\n XwX = tf.matmul(tf.transpose(X, (0, 2, 1)), wX)\\n print(\\\"XwX shape = {}\\\".format(XwX.shape))\\n\\n # Recover essential matrix from self-adjoing eigen\\n e, v = tf.self_adjoint_eig(XwX)\\n self.e_hat = tf.reshape(v[:, :, 0], (x_shp[0], 9))\\n # Make unit norm just in case\\n self.e_hat /= tf.norm(self.e_hat, axis=1, keep_dims=True)\",\n \"def test_filter(self):\\n file_name = \\\"test_filter.hdf5\\\"\\n dataset_file_filter = h5py.File(os.path.join(tmp_path, file_name), \\\"w\\\")\\n for view_index, (view_name, view, is_sparse) in enumerate(\\n zip(self.view_names, self.views, self.are_sparse)):\\n view_dataset = dataset_file_filter.create_dataset(\\n \\\"View\\\" + str(view_index),\\n view.shape,\\n data=view)\\n view_dataset.attrs[\\\"name\\\"] = view_name\\n view_dataset.attrs[\\\"sparse\\\"] = is_sparse\\n labels_dataset = dataset_file_filter.create_dataset(\\\"Labels\\\",\\n shape=self.labels.shape,\\n data=self.labels)\\n labels_dataset.attrs[\\\"names\\\"] = [label_name.encode()\\n for label_name in self.labels_names]\\n meta_data_grp = dataset_file_filter.create_group(\\\"Metadata\\\")\\n meta_data_grp.attrs[\\\"nbView\\\"] = len(self.views)\\n meta_data_grp.attrs[\\\"nbClass\\\"] = len(np.unique(self.labels))\\n meta_data_grp.attrs[\\\"datasetLength\\\"] = len(self.labels)\\n dataset_object = dataset.HDF5Dataset(hdf5_file=dataset_file_filter)\\n dataset_object.filter(np.array([0, 1, 0]), [\\\"0\\\", \\\"1\\\"], [1, 2, 3],\\n [\\\"ViewN0\\\"], tmp_path)\\n self.assertEqual(dataset_object.nb_view, 1)\\n np.testing.assert_array_equal(dataset_object.get_labels(), [0, 1, 0])\\n dataset_object.dataset.close()\\n os.remove(os.path.join(tmp_path, \\\"test_filter_temp_filter.hdf5\\\"))\\n os.remove(os.path.join(tmp_path, \\\"test_filter.hdf5\\\"))\",\n \"def _create_projection_datasets(self):\\n # First grab the spectroscopic indices and values and position indices\\n self._sho_spec_inds = self.h5_main.h5_spec_inds\\n self._sho_spec_vals = self.h5_main.h5_spec_vals\\n self._sho_pos_inds = self.h5_main.h5_pos_inds\\n\\n fit_dim_ind = self.h5_main.spec_dim_labels.index(self._fit_dim_name)\\n\\n self._fit_spec_index = fit_dim_ind\\n self._fit_offset_index = 1 + fit_dim_ind\\n\\n # Calculate the number of loops per position\\n cycle_start_inds = np.argwhere(self._sho_spec_inds[fit_dim_ind, :] == 0).flatten()\\n tot_cycles = cycle_start_inds.size\\n\\n # Make the results group\\n self._h5_group = create_results_group(self.h5_main, 'Loop_Fit')\\n write_simple_attrs(self._h5_group, {'projection_method': 'pycroscopy BE loop model'})\\n\\n # Write datasets\\n self.h5_projected_loops = create_empty_dataset(self.h5_main, np.float32, 'Projected_Loops',\\n h5_group=self._h5_group)\\n\\n h5_loop_met_spec_inds, h5_loop_met_spec_vals = write_reduced_spec_dsets(self._h5_group, self._sho_spec_inds,\\n self._sho_spec_vals, self._fit_dim_name,\\n basename='Loop_Metrics')\\n\\n self.h5_loop_metrics = write_main_dataset(self._h5_group, (self.h5_main.shape[0], tot_cycles), 'Loop_Metrics',\\n 'Metrics', 'compound', None, None, dtype=loop_metrics32,\\n h5_pos_inds=self.h5_main.h5_pos_inds,\\n h5_pos_vals=self.h5_main.h5_pos_vals,\\n h5_spec_inds=h5_loop_met_spec_inds,\\n h5_spec_vals=h5_loop_met_spec_vals)\\n\\n # Copy region reference:\\n copy_region_refs(self.h5_main, self.h5_projected_loops)\\n copy_region_refs(self.h5_main, self.h5_loop_metrics)\\n\\n self.h5_main.file.flush()\\n self._met_spec_inds = self.h5_loop_metrics.h5_spec_inds\\n\\n return\",\n \"def setUp(self):\\n self.batch_size = 8\\n num_keypoints = 16\\n self.data_batch = []\\n self.data_samples = []\\n\\n for i in range(self.batch_size):\\n gt_instances = InstanceData()\\n keypoints = np.zeros((1, num_keypoints, 2))\\n keypoints[0, i] = [0.5 * i, 0.5 * i]\\n gt_instances.keypoints = keypoints + 1.0\\n gt_instances.keypoints_visible = np.ones(\\n (1, num_keypoints, 1)).astype(bool)\\n gt_instances.keypoints_visible[0, (2 * i) % 8, 0] = False\\n gt_instances.bboxes = np.random.random((1, 4)) * 20 * i\\n gt_instances.head_size = np.random.random((1, 1)) * 10 * i\\n\\n pred_instances = InstanceData()\\n pred_instances.keypoints = keypoints\\n\\n data = {'inputs': None}\\n data_sample = {\\n 'gt_instances': gt_instances.to_dict(),\\n 'pred_instances': pred_instances.to_dict(),\\n }\\n\\n self.data_batch.append(data)\\n self.data_samples.append(data_sample)\",\n \"def build():\\n if not os.path.exists(ZIP_DATASET_PATH):\\n raise RuntimeError('Unable to find the zip dataset at %s' % ZIP_DATASET_PATH)\\n\\n # Extracting\\n extract_dir = os.path.join(os.path.dirname(ZIP_DATASET_PATH), 'zip_dataset')\\n if not os.path.exists(extract_dir):\\n LOGGER.info('... Extracting files from zip dataset.')\\n with zipfile.ZipFile(ZIP_DATASET_PATH, 'r') as zip_dataset:\\n zip_dataset.extractall(extract_dir)\\n\\n # Additional information we also want to store\\n map_object = Map()\\n all_powers = get_map_powers(map_object)\\n sc_to_win = len(map_object.scs) // 2 + 1\\n\\n hash_table = {} # zobrist_hash: [{game_id}/{phase_name}]\\n moves = {} # Moves frequency: {move: [nb_no_press, nb_press]}\\n nb_phases = OrderedDict() # Nb of phases per game\\n end_scs = {'press': {power_name: {nb_sc: [] for nb_sc in range(0, sc_to_win + 1)} for power_name in all_powers},\\n 'no_press': {power_name: {nb_sc: [] for nb_sc in range(0, sc_to_win + 1)} for power_name in all_powers}}\\n\\n # Building\\n dataset_index = {}\\n LOGGER.info('... Building HDF5 dataset.')\\n with multiprocessing.Pool() as pool:\\n with h5py.File(DATASET_PATH, 'w') as hdf5_dataset, open(PROTO_DATASET_PATH, 'wb') as proto_dataset:\\n\\n for json_file_path in glob.glob(extract_dir + '/*.jsonl'):\\n LOGGER.info('... Processing: %s', json_file_path)\\n category = json_file_path.split('/')[-1].split('.')[0]\\n dataset_index[category] = set()\\n\\n # Processing file using pool\\n with open(json_file_path, 'r') as json_file:\\n lines = json_file.read().splitlines()\\n for game_id, saved_game_zlib in tqdm(pool.imap_unordered(process_game, lines), total=len(lines)):\\n if game_id is None:\\n continue\\n saved_game_proto = zlib_to_proto(saved_game_zlib, SavedGameProto)\\n\\n # Saving to disk\\n hdf5_dataset[game_id] = np.void(saved_game_zlib)\\n write_proto_to_file(proto_dataset, saved_game_proto, compressed=False)\\n dataset_index[category].add(game_id)\\n\\n # Recording additional info\\n get_end_scs_info(saved_game_proto, game_id, all_powers, sc_to_win, end_scs)\\n get_moves_info(saved_game_proto, moves)\\n nb_phases[game_id] = len(saved_game_proto.phases)\\n\\n # Recording hash of each phase\\n for phase in saved_game_proto.phases:\\n hash_table.setdefault(phase.state.zobrist_hash, [])\\n hash_table[phase.state.zobrist_hash] += ['%s/%s' % (game_id, phase.name)]\\n\\n # Storing info to disk\\n with open(DATASET_INDEX_PATH, 'wb') as file:\\n pickle.dump(dataset_index, file, pickle.HIGHEST_PROTOCOL)\\n with open(END_SCS_DATASET_PATH, 'wb') as file:\\n pickle.dump(end_scs, file, pickle.HIGHEST_PROTOCOL)\\n with open(HASH_DATASET_PATH, 'wb') as file:\\n pickle.dump(hash_table, file, pickle.HIGHEST_PROTOCOL)\\n with open(MOVES_COUNT_DATASET_PATH, 'wb') as file:\\n pickle.dump(moves, file, pickle.HIGHEST_PROTOCOL)\\n with open(PHASES_COUNT_DATASET_PATH, 'wb') as file:\\n pickle.dump(nb_phases, file, pickle.HIGHEST_PROTOCOL)\\n\\n # Deleting extract_dir\\n LOGGER.info('... Deleting extracted files.')\\n if os.path.exists(extract_dir):\\n shutil.rmtree(extract_dir, ignore_errors=True)\\n LOGGER.info('... Done building HDF5 dataset.')\",\n \"def Train_data():\\n print (\\\"loading train data ...\\\")\\n time_start = time.time()\\n data_root = '/media/keziwen/86AA9651AA963E1D'\\n with h5py.File(join(data_root, './data/train_real2.h5')) as f:\\n data_real = f['train_real'][:]\\n num, nt, ny, nx = data_real.shape\\n data_real = np.transpose(data_real, (0, 1, 3, 2))\\n with h5py.File(join(data_root, './data/train_imag2.h5')) as f:\\n data_imag = f['train_imag'][:]\\n num, nt, ny, nx = data_imag.shape\\n data_imag = np.transpose(data_imag, (0, 1, 3, 2))\\n data = data_real+1j*data_imag\\n num_train = 15000\\n num_validate = 2000\\n train_data = data[0:num_train]\\n validate_data = data[num_train:num_train+num_validate]\\n\\n train_data = np.random.permutation(train_data)\\n\\n time_end = time.time()\\n print ('dataset has been created using {}s'.format(time_end-time_start))\\n return train_data, validate_data\",\n \"def training_data():\\n global _MEAN # pylint: disable=global-statement\\n _np.random.seed(1)\\n view = _skdc10.view.OfficialImageClassificationTask()\\n permutation = _np.random.permutation(range(50000))\\n if _MEAN is None:\\n _MEAN = view.train.x.reshape((50000 * 32 * 32, 3)).mean(axis=0)\\n return ((view.train.x[:50000, :][permutation, :] - _MEAN).\\n transpose((0, 3, 1, 2)).astype('float32'),\\n view.train.y[:50000][permutation].reshape((50000, 1)).astype('float32'))\",\n \"def build_dataset(self):\\n\\n print('begin to build data set...')\\n\\n # build dictionary\\n for e in self.lst_entity:\\n self.dictionary_entity[e] = len(self.dictionary_entity)\\n\\n for r in self.lst_relation:\\n self.dictionary_relation[r] = len(self.dictionary_relation)\\n\\n self.reverse_dictionary_entity = dict(zip(self.dictionary_entity.values(), self.dictionary_entity.keys()))\\n self.reverse_dictionary_relation = dict(zip(self.dictionary_relation.values(), self.dictionary_relation.keys()))\\n\\n # build data map\\n self.lst_entity_map = [self.dictionary_entity[e] for e in self.lst_entity]\\n self.lst_relation_map = [self.dictionary_relation[r] for r in self.lst_relation]\\n self.lst_triplet_train_map = self.map_triplet(self.lst_triplet_train)\\n\\n # build corrupted candidates for (h,r,~) and (~,r,t)\\n for (h, r, t) in self.lst_triplet_train_map:\\n if r not in self.dict_tofh:\\n self.dict_tofh[r] = {h: [t]}\\n else:\\n if h not in self.dict_tofh[r]:\\n self.dict_tofh[r][h] = [t]\\n else:\\n self.dict_tofh[r][h].append(t)\\n\\n if r not in self.dict_hoft:\\n self.dict_hoft[r] = {t: [h]}\\n else:\\n if t not in self.dict_hoft[r]:\\n self.dict_hoft[r][t] = [h]\\n else:\\n self.dict_hoft[r][t].append(h)\\n\\n for r in self.dict_tofh:\\n self.lst_triplet_corrupted_tail[r] = dict()\\n for h in self.dict_tofh[r]:\\n set_tail_corrupted_all = set(self.lst_entity_map) - set(self.dict_tofh[r][h])\\n lst_tail_corrupted_choose = random.sample(set_tail_corrupted_all, 5*len(self.dict_tofh[r][h]))\\n self.lst_triplet_corrupted_tail[r][h] = lst_tail_corrupted_choose\\n\\n for r in self.dict_hoft:\\n self.lst_triplet_corrupted_head[r] = dict()\\n for t in self.dict_hoft[r]:\\n lst_head_corrupted_all = set(self.lst_entity_map) - set(self.dict_hoft[r][t])\\n lst_head_corrupted_choose = random.sample(lst_head_corrupted_all, 5*len(self.dict_hoft[r][t]))\\n self.lst_triplet_corrupted_head[r][t] = lst_head_corrupted_choose\\n\\n print('data set has been built successfully!')\",\n \"def construct_model():\\n # model = Sequential()\\n # model.add(Dense(units=64, activation='relu', input_dim=100))\\n # model.add(Dense(units=10, activation='softmax'))\\n # model.compile(loss='categorical_crossentropy',\\n # optimizer='sgd',\\n # metrics=['accuracy'])\\n # return model\\n\\n model = Sequential()\\n # Input Layer\\n model.add(Conv2D(64, 3, data_format='channels_last', activation='relu', padding='same',\\n input_shape=(img_width, img_height, 3)))\\n model.add(MaxPool2D(pool_size=2, strides=2))\\n # Hidden Layer 1\\n model.add(Conv2D(64, 3, activation='relu', padding='same'))\\n model.add(MaxPool2D(pool_size=2, strides=2))\\n\\n # Hidden Layer 2\\n model.add(Conv2D(128, 3, activation='relu', padding='same'))\\n model.add(Conv2D(128, 3, activation='relu', padding='same', strides=2))\\n model.add(MaxPool2D(pool_size=2, strides=2))\\n\\n # Hidden Layer 3\\n model.add(Conv2D(256, 3, activation='relu', padding='same'))\\n model.add(Conv2D(256, 3, activation='relu', padding='same'))\\n model.add(Conv2D(256, 3, activation='relu', padding='same', strides=2))\\n model.add(MaxPool2D(pool_size=2, strides=2))\\n\\n\\n # Fully Connected Layer\\n model.add(Flatten())\\n # 512 Neuron Layer\\n model.add(Dense(512, activation='relu'))\\n model.add(Dropout(0.5))\\n # Output Layer\\n model.add(Dense(num_of_classes))\\n model.add(Activation('softmax'))\\n model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\\n return model\",\n \"def get_model(summary=False):\\n\\timage_input=Input(shape=(220,220,5),name='image_input')\\n\\tbranch1_conv1=Conv2D(64, kernel_size=(3, 3), border_mode='same', input_shape=(220,220,5), activation='relu')(image_input)\\n\\tbranch1_conv2=Conv2D(64, kernel_size=(1, 1), border_mode='same', activation='relu')(branch1_conv1)\\t\\n\\tbranch1_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch1_conv1)\\n\\tbranch2_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch1_pool1)\\n\\tbranch2_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch2_conv1)\\t\\n\\tbranch2_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch2_conv2)\\n\\tbranch3_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch2_pool1)\\n\\tbranch3_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch3_conv1)\\t\\n\\tbranch3_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch3_conv2)\\n\\tbranch4_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch3_pool1)\\n\\tbranch4_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch4_conv1)\\t\\n\\tbranch4_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch4_conv2)\\n\\tbranch5_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch4_pool1)\\n\\tbranch5_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch5_conv1)\\t\\n\\tbranch5_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch5_conv2)\\n\\tbranch6_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch5_pool1)\\n\\tbranch6_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch6_conv1)\\t\\n\\tbranch6_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch6_conv2)\\n\\tbranch1_flat=Flatten()(branch6_pool1)\\n\\tdrop=Dropout(.3)(branch1_flat)\\n\\t# FC layers group\\n\\tdense1=Dense(512, activation='relu', name='fc1')(drop)\\n\\tdrop1=Dropout(.3)(dense1)\\n\\tdense2=Dense(256, activation='relu', name='fc2')(drop1)\\n\\tdrop3=Dropout(.3)(dense2)\\n\\tout=Dense(2, activation='softmax', name='fc4')(drop3)\\n\\tmodel=Model(inputs=image_input,outputs=out)\\n\\treturn model\",\n \"def call(self, inputs, padding_mask, training):\\n query = reference = self._layernorm_mha(inputs)\\n outputs = self._mha(query, reference, padding_mask, training)\\n ffn_inputs = self._dropout_mha(outputs, training=training) + inputs\\n\\n outputs = self._layernorm_ffn(ffn_inputs)\\n outputs = self._ffn(outputs, training)\\n outputs = self._dropout_ffn(outputs, training=training) + ffn_inputs\\n return outputs\",\n \"def input_fn(data_dir,\\n subset,\\n num_shards,\\n batch_size,\\n seq_length=4,\\n use_distortion_for_training=True):\\n with tf.device('/gpu:0' if num_shards >= 1 else '/cpu:0'):\\n use_distortion = subset == 'train' and use_distortion_for_training\\n dataset = data_parser.DataSet(data_dir, subset, use_distortion, seq_length)\\n image_batch, label_batch, occlusion_batch, depth_batch = dataset.make_batch(batch_size)\\n\\n # Note that passing num=batch_size is safe here, even though\\n # dataset.batch(batch_size) can, in some cases, return fewer than batch_size\\n # examples. This is because it does so only when repeating for a limited\\n # number of epochs, but our dataset repeats forever.\\n image_batch = tf.unstack(image_batch, num=batch_size, axis=0)\\n label_batch = tf.unstack(label_batch, num=batch_size, axis=0)\\n occlusion_batch = tf.unstack(occlusion_batch, num=batch_size, axis=0)\\n depth_batch = tf.unstack(depth_batch, num=batch_size, axis=0)\\n feature_shards = [[] for i in range(num_shards)]\\n label_shards = [[] for i in range(num_shards)]\\n occlusion_shards = [[] for i in range(num_shards)]\\n depth_shards = [[] for i in range(num_shards)]\\n skip = batch_size/num_shards\\n for idx in range(num_shards):\\n feature_shards[idx].append(tf.parallel_stack(image_batch[idx*skip:(idx+1)*skip]))\\n label_shards[idx].append([[tf.parallel_stack(label_batch[idx*skip:(idx+1)*skip])], [tf.parallel_stack(occlusion_batch[idx*skip:(idx+1)*skip])], [tf.parallel_stack(depth_batch[idx*skip:(idx+1)*skip])]])\\n\\n return feature_shards, label_shards\",\n \"def __data_generation(self, list_IDs_temp: list) -> (np.array, np.array):\\n\\n # Initialization\\n X = np.empty((self.batch_size, *self.dim))\\n # three channels fro three classes (one hot encoding)\\n M = np.empty((self.batch_size, *self.dim[:-1], 3))\\n\\n # Generate data\\n for i, ID in enumerate(list_IDs_temp):\\n # load sample\\n x = np.load(self.image_data_path + ID, allow_pickle=True)\\n m = np.load(self.mask_data_path + ID, allow_pickle=True)\\n\\n # pre processing\\n x, m = self._preprocessing_(x, m)\\n X[i,] = x\\n M[i,] = m\\n\\n return X, M\",\n \"def Segmentation(WorkingDirectory, ListTrainingDataFile, ListImageName, modelname, noiseReduction, numberOfClasses, classesNamesList, ROI, ListAreaNames, fusionClassesY_N, maskY_N, imageY_N, InfoY_N, NFMaskY_N, BiggestBlobY_N, chosenArea, ReferencePicture):\\n ### Create the folder where the output will be saved \\n if maskY_N=='Y':\\n if not os.path.exists(WorkingDirectory+'/Masks'): \\n os.mkdir(WorkingDirectory+'/Masks')\\n if imageY_N=='Y':\\n if not os.path.exists(WorkingDirectory+'/MaskedImages'): \\n os.mkdir(WorkingDirectory+'/MaskedImages')\\n if NFMaskY_N=='Y':\\n if not os.path.exists(WorkingDirectory+'/NonFilteredMasks'): \\n os.mkdir(WorkingDirectory+'/NonFilteredMasks')\\n\\n \\n ### Import and format the training data from the training data files.\\n trainDataTab=np.array([[0,0,0,0,0,0,0,0,0,0,0,0,0]])\\n for file in ListTrainingDataFile: \\n f=open(file,\\\"r\\\",newline='') \\n TrainData = list(csv.reader(f))\\n f.close()\\n TrainData.remove(['Class', 'Image', 'x','y','B','G','R','H','S','V','L','a','b'])\\n TrainData=np.asarray(TrainData) \\n trainDataTab=np.concatenate((trainDataTab, TrainData), axis=0)\\n trainDataTab=np.delete(trainDataTab, (0), axis=0)\\n if len(ListTrainingDataFile)>1: # if the user choose more than one file, a new file is saved combining all the selected files.\\n np.savetxt(WorkingDirectory+'/trainData_'+str(numberOfClasses)+'classes.csv', trainDataTab, delimiter=\\\",\\\",header='Class,Image,x,y,B,G,R,H,S,V,L,a,b', comments='',fmt='%s')\\n trainDataTab=np.delete(trainDataTab,1, 1)\\n trainDataTab=np.delete(trainDataTab,1, 1)\\n trainDataTab=np.delete(trainDataTab,1, 1)\\n\\n ### Format the list of ROI \\n if ROI!='Whole pictures':\\n ROI=ast.literal_eval(ROI)\\n\\n \\n ### Train the model \\n model=TrainModel(trainDataTab, modelname,classesNamesList) \\n\\n \\n \\n ### Get the size of the reference picture with a 1 pixel difference to avoid any resizing issue\\n FirstImage=cv2.imread(ReferencePicture)\\n ShapeFirstImage=np.shape(FirstImage)\\n a=ShapeFirstImage[0]\\n b=ShapeFirstImage[1]\\n c=ShapeFirstImage[2]\\n ShapeFirstImage2=(a+1,b,c)\\n ShapeFirstImage3=(a+1,b+1,c)\\n ShapeFirstImage4=(a+1,b-1,c)\\n ShapeFirstImage5=(a,b,c)\\n ShapeFirstImage6=(a,b+1,c)\\n ShapeFirstImage7=(a,b-1,c) \\n ShapeFirstImage8=(a-1,b,c)\\n ShapeFirstImage9=(a-1,b+1,c)\\n ShapeFirstImage10=(a-1,b-1,c) \\n\\n ### List initialization \\n ListImageWrongSize=[]\\n ListRunningTimes=[]\\n ListTestDataTimes=[]\\n ListApplyModelTimes=[]\\n ListSaveOutputTimes=[]\\n \\n if BiggestBlobY_N=='Y':\\n ListAirs=np.array([['Area/Plant','Image Name','Surface','Coverage', 'Aspect Ratio','Extent','Solidity', 'Equivalent Diameter', 'Main axe', 'Secondary axe']]) \\n else:\\n ListAirs=np.array([['Area/Plant','Image Name','Surface','Coverage']]) \\n \\n ### Main loop on the image list.\\n for i in ListImageName:\\n start_time = time.monotonic() \\n TestImageBGR=cv2.imread(i) \\n ImageName=i.split('/')\\n ImageName=ImageName[-1] \\n ImageName=ImageName.split('.')\\n ImageName=ImageName[0] \\n ######################################THESE THREE LINES CAN BE USED TO ADD a TIME FILTER ( only keep the pictures between certain hours)\\n# hour=float(ImageName[8:10]) #get the time the picture was taken from the name of the file\\n hour=float(10)\\n if 8<hour<16: # apply a time condition \\n ######################################\\n if ROI!='Whole pictures':\\n if np.shape(TestImageBGR)==ShapeFirstImage or np.shape(TestImageBGR)==ShapeFirstImage2 or np.shape(TestImageBGR)==ShapeFirstImage3 or np.shape(TestImageBGR)==ShapeFirstImage4 or np.shape(TestImageBGR)==ShapeFirstImage5 or np.shape(TestImageBGR)==ShapeFirstImage6 or np.shape(TestImageBGR)==ShapeFirstImage7 or np.shape(TestImageBGR)==ShapeFirstImage8 or np.shape(TestImageBGR)==ShapeFirstImage9 or np.shape(TestImageBGR)==ShapeFirstImage10 : # Test the size of the picture\\n for j in range(len(ROI)): \\n #Crop the picture for each ROI\\n x1,y1,x2,y2=ROI[j]\\n if x1>x2:\\n a=x1\\n x1=x2\\n x2=a\\n if y1>y2:\\n a=y1\\n y1=y2\\n y2=a \\n croppedImagej=TestImageBGR[y1:y2,x1:x2] \\n \\n NameArea=ListAreaNames[j] \\n #Initialize the output names\\n OutputMaskName=''\\n OutputimageName=''\\n OutputNFMaskName=''\\n \\n #Create the output names and folders\\n if maskY_N=='Y': \\n croppedMaskDirectoryArea=WorkingDirectory+'/Masks/'+NameArea \\n if not os.path.exists(croppedMaskDirectoryArea): \\n os.mkdir(croppedMaskDirectoryArea)\\n OutputMaskName=croppedMaskDirectoryArea+'/'+ImageName+'_crop_'+NameArea+'_mask.png'\\n \\n if imageY_N=='Y': \\n croppedMaskedImagesDirectoryArea=WorkingDirectory+'/MaskedImages/'+NameArea \\n if not os.path.exists(croppedMaskedImagesDirectoryArea): \\n os.mkdir(croppedMaskedImagesDirectoryArea) \\n OutputimageName=croppedMaskedImagesDirectoryArea+'/'+ImageName+'_crop_'+NameArea+'_maskedImage.png'\\n \\n if NFMaskY_N=='Y':\\n croppedNonFilteredMaskDirectoryArea=WorkingDirectory+'/NonFilteredMasks/'+NameArea \\n if not os.path.exists(croppedNonFilteredMaskDirectoryArea): \\n os.mkdir(croppedNonFilteredMaskDirectoryArea) \\n OutputNFMaskName=croppedNonFilteredMaskDirectoryArea+'/'+ImageName+'_crop_'+NameArea+'_NFMask.png'\\n \\n # Segment the image with the function ApplyModelAndSaveOutput\\n ListAirs, ListTestDataTimes,ListApplyModelTimes,ListSaveOutputTimes=ApplyModelAndSaveOutput(model, modelname, croppedImagej, ImageName, NameArea, noiseReduction, numberOfClasses, classesNamesList, fusionClassesY_N, maskY_N, InfoY_N, imageY_N, NFMaskY_N, BiggestBlobY_N, chosenArea, OutputMaskName, OutputimageName, OutputNFMaskName, ListAirs, ListTestDataTimes,ListApplyModelTimes,ListSaveOutputTimes)\\n \\n \\n print(str(ImageName)+' '+str(NameArea)+' Done!') \\n else: #if the picture is not the right size \\n ListImageWrongSize.append(i) \\n print(str(ImageName)+' Wrong size')\\n \\n else: #if the user wants to use the whole pictures\\n #Create the output names\\n OutputMaskName=WorkingDirectory+'/Masks/'+ImageName+'_mask.png'\\n OutputimageName=WorkingDirectory+'/MaskedImages/'+ImageName+'_maskedImage.png'\\n OutputNFMaskName=WorkingDirectory+'/NonFilteredMasks/'+ImageName+'_NFMask.png'\\n \\n # Segment the image with the function ApplyModelAndSaveOutput\\n ListAirs, ListTestDataTimes,ListApplyModelTimes,ListSaveOutputTimes=ApplyModelAndSaveOutput(model, modelname, TestImageBGR, ImageName, '', noiseReduction, numberOfClasses, classesNamesList, fusionClassesY_N, maskY_N, InfoY_N, imageY_N, NFMaskY_N, BiggestBlobY_N, chosenArea, OutputMaskName, OutputimageName, OutputNFMaskName, ListAirs, ListTestDataTimes,ListApplyModelTimes,ListSaveOutputTimes)\\n \\n \\n print(str(ImageName)+' Done!')\\n \\n end_time = time.monotonic()\\n RunningTime=timedelta(seconds=end_time - start_time)\\n sec=float(RunningTime.days*86400+RunningTime.seconds+RunningTime.microseconds/1000000)\\n \\n if i==ListImageName[0]: # get an estimation of the running time after the first picture is done\\n print('Running time for 1 image =', RunningTime)\\n print('Total running time estimation =', RunningTime*len(ListImageName))\\n ListRunningTimes.append(sec) \\n \\n \\n else: # usefull only if you apply a time filter \\n ListImageWrongSize.append(i) \\n print(str(ImageName)+' Wrong time')\\n \\n # Save the info file \\n if len(ListAirs)>1:\\n np.savetxt(WorkingDirectory+'/'+'InformationFile.csv', ListAirs, delimiter=\\\",\\\", comments='', fmt='%s') \\n \\n return ListImageWrongSize,ListRunningTimes, ListTestDataTimes,ListApplyModelTimes,ListSaveOutputTimes\",\n \"def concatenate_datasets(filenames_list, img_rows=128, img_cols=128):\\n print('Concatenating the datasets created by data augmentation into a single one')\\n print('Using the following pairs of images / masks datasets: ')\\n print(filenames_list)\\n print('\\\\n')\\n\\n # total number of images\\n n_samples = 600 * len(filenames_list)\\n\\n # create np.ndarrays for the images and the targets: xCenter, yCenter, xOrientation, yOrientation\\n images_dataset = np.ndarray((n_samples, img_rows, img_cols), dtype=np.uint8)\\n targets_dataset = np.ndarray((n_samples, 4), dtype=np.float32)\\n\\n for ds, (img, mask) in enumerate(filenames_list):\\n print(\\\" Processing {}\\\".format(img))\\n images = np.load(\\\"output/augmented_data/{}.npy\\\".format(img))\\n masks = np.load(\\\"output/augmented_data/{}.npy\\\".format(mask))\\n\\n for idx, mat in enumerate(masks):\\n\\n # get the center coordinates of the left ventricle (on the resized image)\\n row, col = findCenter(img=mat, pixelvalue=1)\\n\\n # get the orientation of the left ventricle (on the resized image)\\n x_v1, y_v1 = findMainOrientation(img=mat, pixelvalue=1)\\n\\n # save the center coordinates & orientation to the y dataframe (which will be the output of the network)\\n targets_dataset[ds*600 + idx] = np.array([row, col, x_v1, y_v1])\\n\\n # save image in main dataset file\\n images_dataset[ds*600 + idx] = images[idx]\\n\\n print('Concatenated all datasets into one & created target values for (center, orientation)')\\n\\n print('Splitting the dataset into 70% training & 30% testing')\\n images_train, images_test, targets_train, targets_test = train_test_split(images_dataset, targets_dataset,\\n test_size=0.3,\\n random_state=42,\\n shuffle=True)\\n\\n # save all ndarrays to a .npy files (for faster loading later)\\n # Create directory to store files.\\n directory = os.path.join(os.getcwd(), 'output/processed_data/')\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n\\n # save training set to file\\n np.save('output/processed_data/images_train.npy', images_train)\\n np.save('output/processed_data/targets_train.npy', targets_train)\\n\\n # save testing set to file\\n np.save('output/processed_data/images_test.npy', images_test)\\n np.save('output/processed_data/targets_test.npy', targets_test)\\n print('Saving to .npy files done. See files: ')\\n print('output/processed_data/images_train.npy')\\n print('output/processed_data/targets_train.npy')\\n print('output/processed_data/images_test.npy')\\n print('output/processed_data/targets_test.npy')\",\n \"def _build_datasets_sis3305(self):\\n bc_arr = np.where(self._active_brdch[\\\"SIS 3305\\\"])\\n\\n for board, channel in zip(bc_arr[0], bc_arr[1]):\\n brd = board + 1\\n ch = channel + 1\\n slot = self.get_slot(brd, \\\"SIS 3305\\\")\\n if 1 <= ch <= 4:\\n fpga_str = \\\"FPGA 1\\\"\\n else:\\n fpga_str = \\\"FPGA 2\\\"\\n ch = ch - 4\\n\\n for cname in self._active_config:\\n # create main dataset\\n dset_name = f\\\"{cname} [Slot {slot}: SIS 3305 {fpga_str} ch {ch}]\\\"\\n shape = (self._sn_size, self._nt)\\n data = np.empty(shape=shape, dtype=np.int16)\\n self.create_dataset(dset_name, data=data)\\n\\n # create header dataset\\n hdset_name = f\\\"{dset_name} headers\\\"\\n shape = (self._sn_size,)\\n dtype = np.dtype(\\n [\\n (\\\"Shot number\\\", np.int32),\\n (\\\"Scale\\\", np.float32),\\n (\\\"Offset\\\", np.float32),\\n (\\\"Min\\\", np.uint16),\\n (\\\"Max\\\", np.uint16),\\n (\\\"Clipped\\\", np.int8),\\n ]\\n )\\n dheader = np.empty(shape=shape, dtype=dtype)\\n dheader[\\\"Shot number\\\"] = np.arange(\\n 1, shape[0] + 1, 1, dtype=dheader[\\\"Shot number\\\"].dtype\\n )\\n dheader[\\\"Scale\\\"] = 0.0019550342\\n dheader[\\\"Offset\\\"] = -1.0\\n dheader[\\\"Min\\\"] = data.min(axis=1)\\n dheader[\\\"Max\\\"] = data.max(axis=1)\\n dheader[\\\"Clipped\\\"] = 0\\n self.create_dataset(hdset_name, data=dheader)\",\n \"def gene_h5_train_file(data_path, h5_name):\\n img = []\\n y_cls_mask = []\\n y_reg_cls_mask = []\\n os.chdir(data_path)\\n jpgfiles = glob.glob('*.jpg')\\n idx = 1\\n # the position of generator objector is very important\\n gene_obj = image_output_pair(data_path, 1/255.0)\\n while True:\\n if idx == len(jpgfiles):\\n break\\n print '\\\\t{0}/{1}'.format(idx, len(jpgfiles))\\n # the position of generator objector is very important\\n # gene_obj = image_output_pair(data_path, 1/255.0)\\n img_it, y_cls_mask_it, y_reg_cls_mask_it = gene_obj.next()\\n img.append(img_it)\\n y_cls_mask.append(y_cls_mask_it)\\n y_reg_cls_mask.append(y_reg_cls_mask_it)\\n idx += 1\\n\\n # img => (320, 320, 3)\\n # after np.stack => (19041, 320, 320, 3)\\n img_input = np.stack(img, axis=0)\\n y_cls = np.stack(y_cls_mask, axis=0)\\n y_reg = np.stack(y_reg_cls_mask, axis=0)\\n print 'input data shape is {0}'.format(img_input.shape)\\n print 'y_cls data shape is {0}'.format(y_cls.shape)\\n print 'y_reg data shape is {0}'.format(y_reg.shape)\\n \\n # wirte data\\n h5 = '/home/yuquanjie/Documents/train_' + h5_name\\n file_write = h5py.File(h5, 'w')\\n file_write.create_dataset('X_train', data=img_input)\\n file_write.create_dataset('Y_train_cls', data=y_cls)\\n file_write.create_dataset('Y_train_merge', data=y_reg)\\n file_write.close()\",\n \"def build_data_set(self):\\n if not self.assert_data_correct():\\n self.download_all_data()\\n self.unpack_rename_data()\\n self.split_data_characters()\\n self.clean_data_fragments()\\n self.create_font_data()\\n if not self.assert_train_augmented():\\n self.augment_train_data()\\n if not self.assert_style_data_correct():\\n self.download_style_data()\\n self.unpack_rename_data()\",\n \"def setUp(self):\\n self.batch_size = 8\\n num_keypoints = 15\\n self.data_batch = []\\n self.data_samples = []\\n\\n for i in range(self.batch_size):\\n gt_instances = InstanceData()\\n keypoints = np.zeros((1, num_keypoints, 2))\\n keypoints[0, i] = [0.5 * i, 0.5 * i]\\n gt_instances.keypoints = keypoints\\n gt_instances.keypoints_visible = np.ones(\\n (1, num_keypoints, 1)).astype(bool)\\n gt_instances.keypoints_visible[0, (2 * i) % 8, 0] = False\\n gt_instances.bboxes = np.random.random((1, 4)) * 20 * i\\n gt_instances.head_size = np.random.random((1, 1)) * 10 * i\\n\\n pred_instances = InstanceData()\\n pred_instances.keypoints = keypoints\\n\\n data = {'inputs': None}\\n data_sample = {\\n 'gt_instances': gt_instances.to_dict(),\\n 'pred_instances': pred_instances.to_dict(),\\n }\\n\\n self.data_batch.append(data)\\n self.data_samples.append(data_sample)\",\n \"def setUp(self):\\n self.batch_size = 8\\n num_keypoints = 15\\n self.data_batch = []\\n self.data_samples = []\\n\\n for i in range(self.batch_size):\\n gt_instances = InstanceData()\\n keypoints = np.zeros((1, num_keypoints, 2))\\n keypoints[0, i] = [0.5 * i, 0.5 * i]\\n gt_instances.keypoints = keypoints\\n gt_instances.keypoints_visible = np.ones(\\n (1, num_keypoints, 1)).astype(bool)\\n gt_instances.keypoints_visible[0, (2 * i) % 8, 0] = False\\n gt_instances.bboxes = np.random.random((1, 4)) * 20 * i\\n gt_instances.head_size = np.random.random((1, 1)) * 10 * i\\n\\n pred_instances = InstanceData()\\n pred_instances.keypoints = keypoints\\n\\n data = {'inputs': None}\\n data_sample = {\\n 'gt_instances': gt_instances.to_dict(),\\n 'pred_instances': pred_instances.to_dict(),\\n }\\n\\n self.data_batch.append(data)\\n self.data_samples.append(data_sample)\",\n \"def _load_data(self):\\n pickle_in = open(\\\"X_train.pickle\\\", \\\"rb\\\")\\n self.X = pickle.load(pickle_in)\\n pickle_in = open(\\\"y_train.pickle\\\", \\\"rb\\\")\\n self.Y = pickle.load(pickle_in)\\n\\n pickle_in = open(\\\"X_test.pickle\\\", \\\"rb\\\")\\n self.X_final = pickle.load(pickle_in)\\n pickle_in = open(\\\"y_test.pickle\\\", \\\"rb\\\")\\n self.Y_final = pickle.load(pickle_in)\\n\\n # Set input shape:\\n if K.image_data_format() == 'channels_first':\\n self.input_shape = (3, self.img_rows, self.img_cols)\\n else:\\n self.input_shape = (self.img_rows, self.img_cols, 3)\\n\\n self.X = self.X.astype('float32')\\n self.X /= 255\\n self.X_final = self.X_final.astype('float32')\\n self.X_final /= 255\\n print('X shape:', self.X.shape)\\n print(self.X.shape[0], 'Samples')\\n\\n num_datapoints = 3000\\n self.X = self.X[0:num_datapoints]\\n self.Y = self.Y[0:num_datapoints]\\n\\n num_datapoints = 2000\\n self.X_final = self.X_final[0:num_datapoints]\\n self.Y_final = self.Y_final[0:num_datapoints]\\n\\n self.Y_final = to_categorical(self.Y_final, self.num_classes)\\n\\n # Initialize Data\\n kfold = StratifiedKFold(n_splits=self.nFolds, shuffle=True)\\n\\n if self.b_eval_advanced:\\n # Loop through the indices the split() method returns\\n for index, (train_indices, test_indices) in enumerate(kfold.split(self.X, self.Y)):\\n if index == 0:\\n self.Y = to_categorical(self.Y, self.num_classes)\\n\\n # Generate batches from indices\\n xtrain, xtest = self.X[train_indices], self.X[test_indices]\\n ytrain, ytest = self.Y[train_indices], self.Y[test_indices]\\n\\n self.data.append(tuple([xtrain, xtest, ytrain, ytest]))\\n\\n if not self.b_eval_advanced:\\n self.Y = to_categorical(self.Y, self.num_classes)\\n\\n #print(np.asarray(self.data).shape)\\n #print(self.data)\\n print(\\\"Y_final Shape\\\", self.Y_final.shape)\",\n \"def get_unet():\\n inputs = Input((img_rows, img_cols, 1))\\n conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(inputs)\\n conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(conv1)\\n pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)\\n\\n conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(pool1)\\n conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv2)\\n pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)\\n\\n conv3 = Conv2D(128, (3, 3), activation='relu', padding='same')(pool2)\\n conv3 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv3)\\n pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)\\n\\n conv4 = Conv2D(256, (3, 3), activation='relu', padding='same')(pool3)\\n conv4 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv4)\\n pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)\\n\\n conv5 = Conv2D(512, (3, 3), activation='relu', padding='same')(pool4)\\n conv5 = Conv2D(512, (3, 3), activation='relu', padding='same')(conv5)\\n\\n up6 = concatenate([Conv2DTranspose(256, (2, 2), strides=(2, 2),\\n padding='same')(conv5), conv4], axis=3)\\n conv6 = Conv2D(256, (3, 3), activation='relu', padding='same')(up6)\\n conv6 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv6)\\n\\n up7 = concatenate([Conv2DTranspose(128, (2, 2), strides=(2, 2),\\n padding='same')(conv6), conv3], axis=3)\\n conv7 = Conv2D(128, (3, 3), activation='relu', padding='same')(up7)\\n conv7 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv7)\\n\\n up8 = concatenate([Conv2DTranspose(64, (2, 2), strides=(2, 2),\\n padding='same')(conv7), conv2], axis=3)\\n conv8 = Conv2D(64, (3, 3), activation='relu', padding='same')(up8)\\n conv8 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv8)\\n\\n up9 = concatenate([Conv2DTranspose(32, (2, 2), strides=(2, 2),\\n padding='same')(conv8), conv1], axis=3)\\n conv9 = Conv2D(32, (3, 3), activation='relu', padding='same')(up9)\\n conv9 = Conv2D(32, (3, 3), activation='relu', padding='same')(conv9)\\n\\n conv10 = Conv2D(1, (1, 1), activation='sigmoid')(conv9)\\n\\n model = Model(inputs=[inputs], outputs=[conv10])\\n\\n model.compile(optimizer=Adam(lr=1e-4), loss=dice_coef_loss,\\n metrics=[dice_coef])\\n\\n return model\",\n \"def build_all_connected_models(feature_dim, output_scheme=\\\"regression\\\", num_classes=num_classes):\\n\\tinput_layer = keras.layers.Input(shape=[feature_dim])\\n\\thidden1 = keras.layers.Dense(800, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(input_layer)\\n\\t#bn1 = keras.layers.BatchNormalization()(hidden1)\\n\\tdropout1 = keras.layers.AlphaDropout(rate=0.5)(hidden1)\\n\\t#hidden2 = keras.layers.Dense(500, activation='relu', \\n\\t#\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t#\\tkernel_initializer=\\\"he_uniform\\\")(dropout1)\\n\\t#bn2 = keras.layers.BatchNormalization()(hidden2)\\n\\t#dropout2 = keras.layers.AlphaDropout(rate=0.5)(hidden2)\\n\\thidden3 = keras.layers.Dense(200, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout1)\\n\\tdropout3 = keras.layers.AlphaDropout(rate=0.3)(hidden3)\\n\\t# trait-specific network\\n\\thidden4_1 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout3)\\n\\thidden4_2 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout3)\\n\\thidden4_3 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout3)\\n\\thidden4_4 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout3)\\n\\thidden4_5 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout3)\\n\\t#bn3 = keras.layers.BatchNormalization()(hidden3)\\n\\tif (output_scheme==\\\"regression\\\"):\\n\\t\\t#outputs = [keras.layers.Dense(1, hidden3) for i in range(5)] #\\n\\t\\tout1 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out1\\\")(hidden4_1)\\n\\t\\tout2 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out2\\\")(hidden4_2)\\n\\t\\tout3 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out3\\\")(hidden4_3)\\n\\t\\tout4 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out4\\\")(hidden4_4)\\n\\t\\tout5 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out5\\\")(hidden4_5)\\n\\telif (output_scheme == \\\"ordinal_clf\\\"):\\n\\t\\tout1 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out1\\\")(hidden4_1)\\n\\t\\tout2 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out2\\\")(hidden4_2)\\n\\t\\tout3 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out3\\\")(hidden4_3)\\n\\t\\tout4 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out4\\\")(hidden4_4)\\n\\t\\tout5 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out5\\\")(hidden4_5)\\n\\tmodel = keras.models.Model(inputs=[input_layer],\\n\\t\\t\\t\\t\\t\\t\\t outputs=[out1, out2, out3, out4, out5])\\n\\tif (output_scheme == \\\"regression\\\"):\\n\\t\\tmodel.compile(loss=\\\"mse\\\", \\n\\t\\t\\t\\t\\t optimizer=tf.keras.optimizers.Adam(0.0001),\\n\\t\\t\\t\\t\\t metrics=['mae', custom_r2_metric])\\n\\telif (output_scheme == \\\"ordinal_clf\\\"):\\n\\t\\tmodel.compile(loss=tf.keras.losses.CategoricalCrossentropy(), \\n\\t\\t\\t\\t\\t optimizer=tf.keras.optimizers.Adam(0.001))\\n\\tprint(model.summary())\\n\\treturn model\",\n \"def _prepare_sets(self):\\n\\n ds_images, ds_labels = self._load_images_labels()\\n\\n ds_images_2 = ds_images.take(self.val_count)\\n ds_labels_2 = ds_labels.take(self.val_count)\\n ds_images_1 = ds_images.skip(self.val_count)\\n ds_labels_1 = ds_labels.skip(self.val_count)\\n\\n ds_1 = (ds_images_1, ds_labels_1)\\n ds_2 = (ds_images_2, ds_labels_2)\\n\\n return ds_1, ds_2\",\n \"def build_model_mobilenet(num_classes):\",\n \"def index_subset(subset, numTestClasses=7, randomSeed=123 ):\\n print(\\\"datasets.py is ingesting the DF dataset from data/SETA.npz\\\")\\n npzfile = np.load(\\\"data/SETA.npz\\\", allow_pickle=True)\\n data = npzfile[\\\"data\\\"]\\n labels = npzfile[\\\"labels\\\"]\\n npzfile.close()\\n distinctLabelCount= len(set(labels))\\n \\n\\n #print(\\\"distinctLabelCount\\\", distinctLabelCount)\\n \\n #random.seed(randomSeed)\\n testClasses = random.sample(range(0,distinctLabelCount),numTestClasses)\\n\\n # Test the overrides \\n \\n # WORST \\n #testClasses = np.array([18.0,16.0,14.0,11.0,10.0,9.0,7.0]).tolist()\\n # BEST\\n #testClasses = np.array([5.0,6.0,8.0,12.0,13.0,14.0,19.0]).tolist()\\n \\n testClasses = [np.float64(i) for i in testClasses]\\n\\n mask = np.isin(labels,testClasses)\\n \\n \\n X_test = data[np.where(mask)]\\n X_train = data[np.where(~mask)]\\n y_test = labels[np.where(mask)]\\n y_train = labels[np.where(~mask)]\\n \\n if subset==\\\"background\\\":\\n \\n print(\\\"SETA data\\\", data.shape)\\n print(\\\"labels\\\", labels.shape)\\n print(testClasses)\\n \\n print(\\\"Current working directory is \\\", os.getcwd())\\n X = X_train\\n y = y_train\\n print(\\\"SETA background data shape\\\", X.shape)\\n elif subset==\\\"evaluation\\\":\\n X = X_test\\n y = y_test\\n print(\\\"SETA evaluation data shape\\\", X.shape)\\n images = []\\n \\n #print(\\\"y shape\\\", y.shape)\\n \\n \\n for i in range(y.shape[0]):\\n images.append({\\n 'subset': subset,\\n 'class_name': y[i],\\n 'data': X[i].reshape(1,X[1].shape[0]) # This is the shape needed for Matching Networks\\n #'data': X[i] #.reshape(X[1].shape[0]) # This is the shape needed for MAML\\n })\\n \\n return images\",\n \"def matrix(self):\\n \\n dataCount = self.subset.count('1')\\n dataNames = sorted(glob.glob(self.fullPath + '/*.tif'))\\n dataNames = dataNames[0:dataCount]\\n subsetInt = [int(s) for s in self.subset.split() if s.isdigit()] \\n \\n DC = np.empty(shape = (self.rows*self.columns*self.observations,0)) \\n DCs = np.empty(shape = (self.rows*self.columns*self.observations, subsetInt.count(1))) \\n \\n for i in range(dataCount):\\n name = str(dataNames[i])\\n dataList = sorted(glob.glob(self.fullPath + '/*' + name[-10:-4] + '.tif')) \\n bandDC = np.empty((0, 1)) \\n for b in dataList:\\n data = gdal.Open(str(b), GA_ReadOnly).ReadAsArray()\\n vec = data.reshape((self.rows*self.columns, 1))\\n bandDC = np.append(bandDC, vec, axis = 0) \\n DC = np.append(DC, bandDC, axis = 1) \\n del vec, bandDC, data\\n \\n #apply fill values \\n if self.dataset == 'MOD15A2.005' or self.dataset == 'MOD17A2.005':\\n DC[DC>self.fillValue] = 9999.0 \\n if self.dataset == 'MOD11A2.005':\\n DC[:,0][DC[:,0] == self.fillValue] = 9999.0 #this should have fixed it!\\n else:\\n DC[DC == self.fillValue] = 9999.0 \\n \\n \\n #scale dataset\\n count = 0 \\n for i in range(len(subsetInt)):\\n if subsetInt[i] == 1:\\n DCs[:,count] = np.multiply(DC[:,count], self.scale[i])\\n count += 1\\n DCs[DC == 9999.0] = 9999.0\\n self.DC = DCs\\n del DC\\n \\n #metadata function \\n with open(self.fullPath + '/' + 'metadata_' + self.dataset + '.txt', 'w') as f:\\n f.write(' '.join([\\\"self.%s = %s\\\" % (k,v) for k,v in self.__dict__.iteritems()]))\\n \\n logger.log('SUCCESS', 'The %s data was transformed into an array with dimensions %d rows by %d columns. No data value set to 9999. A metadata file with object attributes was created. To access the matrix, simply call object.DC' % (str(self.outformat), self.DC.shape[0], self.DC.shape[1]))\\n\\n tif = sorted(glob.glob(self.fullPath + '/*.tif'))\\n for t in tif:\\n os.remove(t)\",\n \"def index_subset(subset, numTestClasses=33, randomSeed=123):\\n print(\\\"datasets.py is ingesting the DF dataset from data/DF.npz\\\")\\n npzfile = np.load(\\\"data/DF.npz\\\", allow_pickle=True)\\n data = npzfile[\\\"data\\\"]\\n labels = npzfile[\\\"labels\\\"]\\n npzfile.close()\\n distinctLabelCount= len(set(labels))\\n \\n print(\\\"\\\\ndata\\\", data.shape)\\n print(\\\"labels\\\", labels.shape)\\n print(\\\"Total distinct class labels in the DF.npz dataset: \\\", distinctLabelCount)\\n \\n #random.seed(randomSeed)\\n testClasses = random.sample(range(0,distinctLabelCount),numTestClasses)\\n testClasses = [np.float64(i) for i in testClasses]\\n \\n \\n mask = np.isin(labels,testClasses)\\n\\n X_test = data[np.where(mask)]\\n X_train = data[np.where(~mask)]\\n y_test = labels[np.where(mask)]\\n y_train = labels[np.where(~mask)]\\n \\n if subset==\\\"background\\\":\\n print(\\\"Current working directory is \\\", os.getcwd())\\n X = X_train\\n y = y_train\\n print(\\\"DF background data shape\\\", X.shape)\\n elif subset==\\\"evaluation\\\":\\n X = X_test\\n y = y_test\\n print(\\\"DF evaluation data shape\\\", X.shape)\\n images = []\\n \\n #print(\\\"y shape\\\", y.shape)\\n \\n \\n for i in range(y.shape[0]):\\n images.append({\\n 'subset': subset,\\n 'class_name': y[i],\\n 'data': X[i].reshape(1,X[1].shape[0]) # This is the shape needed for Matching Networks\\n #'data': X[i] #.reshape(X[1].shape[0]) # This is the shape needed for MAML\\n })\\n \\n return images\",\n \"def __generate_input_data(self):\\n if not len(self.input_data) == 0:\\n return\\n\\n try:\\n self.input_data = s.load(open('output/input_data.p', 'rb'))\\n self.class_indices = s.load(open('output/class_indices.p', 'rb'))\\n if not self.classes_to_visualise == None:\\n self.__filter_input_data(self.classes_to_visualise)\\n except:\\n self.input_data = generate_input_data_list(training=False) if self.testing else generate_input_data_list()\\n self.class_indices = get_all_class_indices(training=False) if self.testing else get_all_class_indices()\\n if not self.classes_to_visualise == None:\\n self.__filter_input_data(self.classes_to_visualise)\\n s.dump([input.tolist() for input in self.input_data], open('output/input_data.p', 'wb'))\\n s.dump(self.class_indices, open('output/class_indices.p', 'wb'))\\n\\n self.legend = get_class_names_for_class_indices(list(set(sorted(self.class_indices))))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60946685","0.5913993","0.58595705","0.5826413","0.58137065","0.5807853","0.5747172","0.5703104","0.5692386","0.56754106","0.56699955","0.56411266","0.56325924","0.5626313","0.56190795","0.5594807","0.5573859","0.55735236","0.5554242","0.5549842","0.5542786","0.5533272","0.55326915","0.55195916","0.5512725","0.55043864","0.5494706","0.54869723","0.5476328","0.5462396","0.5462209","0.54619694","0.54519755","0.54337615","0.54314816","0.54266727","0.5423622","0.54056805","0.540539","0.54006225","0.5396632","0.5395471","0.5386035","0.53840727","0.53840303","0.5379071","0.53697026","0.53684294","0.5367748","0.5365559","0.53608865","0.53551203","0.53508234","0.5341165","0.5337459","0.53363097","0.5332675","0.5329383","0.53276724","0.532726","0.53263646","0.5314676","0.531463","0.5304247","0.53034884","0.5300351","0.5295849","0.52936286","0.52933496","0.52928406","0.52920294","0.52905834","0.52812546","0.5271576","0.5269718","0.5256197","0.5247226","0.52466124","0.52457535","0.5245492","0.5245059","0.5244781","0.5241368","0.5238382","0.5236427","0.5236388","0.5224394","0.5224186","0.5222239","0.52199465","0.52199465","0.52165204","0.5214505","0.52143157","0.5213482","0.5211402","0.5208139","0.52074075","0.520506","0.5203703"],"string":"[\n \"0.60946685\",\n \"0.5913993\",\n \"0.58595705\",\n \"0.5826413\",\n \"0.58137065\",\n \"0.5807853\",\n \"0.5747172\",\n \"0.5703104\",\n \"0.5692386\",\n \"0.56754106\",\n \"0.56699955\",\n \"0.56411266\",\n \"0.56325924\",\n \"0.5626313\",\n \"0.56190795\",\n \"0.5594807\",\n \"0.5573859\",\n \"0.55735236\",\n \"0.5554242\",\n \"0.5549842\",\n \"0.5542786\",\n \"0.5533272\",\n \"0.55326915\",\n \"0.55195916\",\n \"0.5512725\",\n \"0.55043864\",\n \"0.5494706\",\n \"0.54869723\",\n \"0.5476328\",\n \"0.5462396\",\n \"0.5462209\",\n \"0.54619694\",\n \"0.54519755\",\n \"0.54337615\",\n \"0.54314816\",\n \"0.54266727\",\n \"0.5423622\",\n \"0.54056805\",\n \"0.540539\",\n \"0.54006225\",\n \"0.5396632\",\n \"0.5395471\",\n \"0.5386035\",\n \"0.53840727\",\n \"0.53840303\",\n \"0.5379071\",\n \"0.53697026\",\n \"0.53684294\",\n \"0.5367748\",\n \"0.5365559\",\n \"0.53608865\",\n \"0.53551203\",\n \"0.53508234\",\n \"0.5341165\",\n \"0.5337459\",\n \"0.53363097\",\n \"0.5332675\",\n \"0.5329383\",\n \"0.53276724\",\n \"0.532726\",\n \"0.53263646\",\n \"0.5314676\",\n \"0.531463\",\n \"0.5304247\",\n \"0.53034884\",\n \"0.5300351\",\n \"0.5295849\",\n \"0.52936286\",\n \"0.52933496\",\n \"0.52928406\",\n \"0.52920294\",\n \"0.52905834\",\n \"0.52812546\",\n \"0.5271576\",\n \"0.5269718\",\n \"0.5256197\",\n \"0.5247226\",\n \"0.52466124\",\n \"0.52457535\",\n \"0.5245492\",\n \"0.5245059\",\n \"0.5244781\",\n \"0.5241368\",\n \"0.5238382\",\n \"0.5236427\",\n \"0.5236388\",\n \"0.5224394\",\n \"0.5224186\",\n \"0.5222239\",\n \"0.52199465\",\n \"0.52199465\",\n \"0.52165204\",\n \"0.5214505\",\n \"0.52143157\",\n \"0.5213482\",\n \"0.5211402\",\n \"0.5208139\",\n \"0.52074075\",\n \"0.520506\",\n \"0.5203703\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.63189304"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21988,"cells":{"query":{"kind":"string","value":"Generate outputs from a noncompact TrainingSet to use with Keras' 'fit_generator' function. If 'n_crops' is nonzero, the Iterator crops n_crops 20x20 regions from each image before feeding them."},"document":{"kind":"string","value":"def flow(self, batch_size=32, output='both', crops=0):\n while True:\n for dataset in self.input_sets:\n X = self.training_set['input/'+dataset]\n y = self.training_set['target/'+dataset]\n y_seg = self.training_set['seg_map/'+dataset]\n\n for i in range(int(math.ceil(X.shape[0]/2000))):\n index = list(range(0,X.shape[0]))\n sample = random.sample(index, batch_size)\n sample.sort()\n X_batch = X[sample, ...]\n y_batch = y[sample, ...]\n y_seg_batch = y_seg[sample, ...]\n X_batch = self.augment(X_batch)\n\n if crops > 0:\n (X_batch, y_batch,\n y_seg_batch) = _augmentors.random_crops(\n X_batch, y_batch, y_seg_batch, n_crops=crops, crop_dim=20)\n\n if output=='both':\n yield (X_batch, [y_batch, y_seg_batch])\n elif output=='seg':\n yield (X_batch, y_seg)\n elif output=='density':\n yield (X_batch, y_batch)\n else:\n raise Exception('output must be \"density\", \"seg\" or \"both\"')"},"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 crop_generator(batches, crop_length):\n while True:\n batch_x, batch_y = next(batches)\n batch_crops = np.zeros((batch_x.shape[0], crop_length, crop_length, 3))\n for i in range(batch_x.shape[0]):\n batch_crops[i] = random_crop(batch_x[i], (crop_length, crop_length))\n yield (batch_crops, batch_y)","def generate_transformed_data(self):\n for each_class in self.classes:\n class_directory = \"data/test/test_folder/\"\n class_directory += each_class\n class_directory += \"_test.jpg\"\n test_image = keras.preprocessing.image.load_img(class_directory)\n image_set = keras.preprocessing.image.img_to_array(test_image)\n image_set = image_set.reshape((1,) + image_set.shape)\n i = 0\n for each_batch in self.transformed_data_generator.flow(image_set, batch_size=1,\n save_to_dir=\"data/test_transformed/test_folder\", save_prefix=each_class, save_format=\"jpeg\"):\n i += 1\n if i > 20:\n break","def two_step_generator(classes: list, paths_list: list, imgs_per_class: int, shape: tuple,\n nb_win: int, greys: bool, nb_to_gen: int, img_gen: ImageDataGenerator) -> list:\n \n datawin = list() \n datagen = list()\n \n for class_ in classes:\n print(class_)\n \n # Images paths list\n class_imgs_path = [paths_list[k] for k in range(len(paths_list)) if class_ in paths_list[k]]\n\n # Randomly choose images\n class_imgs_subset = np.random.choice(class_imgs_path, size=imgs_per_class, replace=False)\n\n # Get images\n class_imgs = get_imgs(class_imgs_subset)\n\n # Step 1: resize and crop on sliding windows\n class_new_imgs = create_windows_imgs(class_imgs, shape=shape, nb_win=nb_win, greys=greys)\n class_new_imgs = np.array(flat_list(class_new_imgs))\n datawin.append(class_new_imgs)\n \n # Step 2: DataGenerator\n class_datagen = datagen_class(class_new_imgs, nb_to_gen, img_gen)\n class_datagen = class_datagen.astype(int)\n\n datagen.append(class_datagen)\n \n return datawin, datagen","def random_crop_generator(batches, crop_length):\n while True:\n batch_x, batch_y = next(batches)\n batch_crops = np.zeros((batch_x.shape[0], crop_length, crop_length, 3))\n for i in range(batch_x.shape[0]):\n batch_crops[i] = random_crop(batch_x[i], (crop_length, crop_length))\n yield (batch_crops, batch_y)","def toy_preprocess_scans(self, scan_ids, width, height, depth, clipping=True, loop=False,\n seed=42, shuffle=False):\n # Initialize image transformer\n kwds_generator = {'rotation_range': 5,\n 'width_shift_range': 0.03,\n 'height_shift_range': 0.03,\n 'zoom_range': 0.03,\n 'data_format': \"channels_first\", # z axis is first\n }\n image_gen = image_prep.ImageDataGenerator(**kwds_generator)\n\n scan_gen = self.preprocess_scans(scan_ids, width, height, depth, clipping, loop, shuffle)\n for ct_scan, origin, spacing in scan_gen:\n yield ct_scan, origin, spacing\n transformed_scan = image_gen.random_transform(ct_scan, seed=seed)\n if seed is not None:\n seed += 1\n yield transformed_scan, origin, spacing","def generate_n_augmented_images(data_dirname: str, root_dirname: str, n=20) -> None:\n augmentor = set_augmentor()\n preprocessing_fun = lambda *args: pre_processing_function(*args, augmentor=augmentor)\n generator = set_generator_classifier(data_dirname, preprocessing_fun, batch_size=1, number_of_images=n)\n generator.not_batch = True\n # NOTICE: This generator can be used for keras and pytorch in case that instead of saving images one desires to\n # augment images on the fly. Use a number larger than 1 for the batch size when training directly a CNN.\n\n # Save the new generated images\n counter_labels = {}\n for image, label in generator:\n counter = counter_labels.get(label, 0)\n output_filename = label + '_' + str(counter_labels.get(label, 0)) + '.jpg'\n save_dirname = os.path.join(root_dirname, label)\n if not os.path.isdir(save_dirname):\n os.makedirs(save_dirname)\n\n filename = os.path.join(save_dirname, output_filename)\n imsave(filename, image.astype(np.uint8))\n counter_labels[label] = counter + 1\n\n print(f'Finished image generation. The output images were saved in {root_dirname}')","def build_generator(self):\n noise_shape = (self.dimensions_noise,)\n\n # This block of code can be a little daunting, but essentially it automatically calculates the required starting\n # array size that will be correctly upscaled to our desired image size.\n #\n # We have 5 Upsample2D layers which each double the images width and height, so we can determine the starting\n # x size by taking (x / 2^upsample_count) So for our target image size, 256x192, we do the following:\n # x = (192 / 2^5), y = (256 / 2^5) [x and y are reversed within the model]\n # We also need a 3rd dimension which is chosen relatively arbitrarily, in this case it's 64.\n model = Sequential()\n model.add(\n Dense(\n self.starting_filters\n * (self.img_size[0] // (2 ** self.upsample_layers))\n * (self.img_size[1] // (2 ** self.upsample_layers)),\n activation=\"relu\",\n input_shape=noise_shape,\n )\n )\n model.add(\n Reshape(\n (\n (self.img_size[0] // (2 ** self.upsample_layers)),\n (self.img_size[1] // (2 ** self.upsample_layers)),\n self.starting_filters,\n )\n )\n )\n model.add(BatchNormalization(momentum=0.8))\n\n model.add(UpSampling2D()) # 6x8 -> 12x16\n model.add(Conv2D(1024, kernel_size=self.kernel_size, padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(momentum=0.8))\n\n model.add(UpSampling2D()) # 12x16 -> 24x32\n model.add(Conv2D(512, kernel_size=self.kernel_size, padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(momentum=0.8))\n\n model.add(UpSampling2D()) # 24x32 -> 48x64\n model.add(Conv2D(256, kernel_size=self.kernel_size, padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(momentum=0.8))\n\n model.add(UpSampling2D()) # 48x64 -> 96x128\n model.add(Conv2D(128, kernel_size=self.kernel_size, padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(momentum=0.8))\n\n model.add(UpSampling2D()) # 96x128 -> 192x256\n model.add(Conv2D(64, kernel_size=self.kernel_size, padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(momentum=0.8))\n\n model.add(Conv2D(32, kernel_size=self.kernel_size, padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(momentum=0.8))\n\n model.add(Conv2D(self.channels, kernel_size=self.kernel_size, padding=\"same\"))\n model.add(Activation(\"tanh\"))\n\n model.summary()\n\n noise = Input(shape=noise_shape)\n img = model(noise)\n\n return Model(noise, img)","def get_crops(x_train, y_train, offset=4):\n\ttopleft = iaa.Sequential([\n\t\tiaa.Crop(px=(4 - offset, offset, offset, 4 - offset)),\n\t\tiaa.Affine(scale=1.166666667)\n\t])\n\ttopright = iaa.Sequential([\n\t\tiaa.Crop(px=(4 - offset, 4 - offset, offset, offset)),\n\t\tiaa.Affine(scale=1.166666667)\n\t])\n\tbotleft = iaa.Sequential([\n\t\tiaa.Crop(px=(offset, offset, 4 - offset, 4 - offset)),\n\t\tiaa.Affine(scale=1.166666667)\n\t])\n\tbotright = iaa.Sequential([\n\t\tiaa.Crop(px=(offset, 4 - offset, 4 - offset, offset)),\n\t\tiaa.Affine(scale=1.166666667)\n\t])\n\tcenter = iaa.Sequential([\n\t\tiaa.Crop(px=(2, 2, 2, 2)),\n\t\tiaa.Affine(scale=1.166666667)\n\t])\n\taugs = [topleft, topright, botleft, botright, center]\n\n\taug_imgs = []\n\tfor aug in tqdm(augs):\n\t\taug_imgs.append(aug.augment_images(x_train * 255))\n\n\taug_x_train = [item for sublist in aug_imgs for item in sublist]\n\taug_y_train = y_train * 5\n\n\treturn aug_x_train, aug_y_train","def genTrainingSet(set_of_CSVs, file_to_classify, train_size = 5):\n set_of_csvs_minus_target = copy.copy(set_of_CSVs)\n # remove the file we want to classify\n set_of_csvs_minus_target.remove(file_to_classify)\n\n # extract out the random noise files\n # first, set the seed\n random.seed(time.time())\n # now sample\n return_list = random.sample(set_of_csvs_minus_target, train_size)\n return return_list","def __call__(self):\n if self.numbatches is None:\n pool = self.pooler()\n if self.batchsize is None:\n self.batchsize = self.pooler.nInPool()\n self.numbatches = self.pooler.nInPool()//self.batchsize\n for i in xrange(self.numbatches):\n pool = self.pooler()\n self._reset_batch()\n if self.samplemethod == 'balance' and len(self.keysamplers)>0:\n batchinds,keyids = self._samplebalanced(pool)\n elif self.samplemethod == 'uniform':\n batchinds,keyids = self._sampleuniform(pool)\n else:\n batchinds,keyids = self._samplesequential(i)\n batch = self._extractInds(pool,batchinds,keyids)\n for k in batch:\n batch[k][np.isnan(batch[k])] = self.nanreplacement\n yield batch","def generate_one(self, n_images, min_correct=None, p_correct=0.5, n_correct=None, n_caps_per_image=1, configs=None):\n random.seed() # For multiprocessing (TODO: can we avoid this?)\n imgs = np.zeros((n_images, 3, c.DIM, c.DIM), dtype=np.uint8)\n labels = np.zeros((n_images, ), dtype=np.uint8)\n if configs is not None:\n cfg_idx = random.choice(len(configs))\n target_cfg = configs[cfg_idx]\n else:\n # FIXME: Make this OOP to avoid these if statements\n if self.img_type == 'spatial':\n target_cfg = self.random_config_spatial()\n elif self.img_type == 'single':\n target_cfg = self.random_config_single()\n\n if self.data_type == 'concept':\n if n_correct is not None:\n # Fixed number of targets and distractors\n n_target = n_correct\n n_distract = n_images - n_target\n elif min_correct is not None:\n # Minimum number of targets, otherwise sample whatever\n # TODO: combine min_correct and min_incorrect\n n_target = min_correct\n n_distract = 0\n else:\n # Minimum of 2 targets and distractors each\n n_target = 2\n n_distract = 2\n else:\n n_target = 1\n n_distract = n_images # Never run out of distractors\n\n cfgs = []\n shapes = []\n cfgs_to_cap = []\n for i in range(n_images):\n if n_target > 0:\n label = 1\n n_target -= 1\n elif n_distract > 0:\n label = 0\n n_distract -= 1\n else:\n label = (random.random() < p_correct)\n\n if self.img_type == 'spatial':\n new_cfg, new_shapes, cfg_to_cap = self.generate_spatial(target_cfg, label, n_caps_per_image)\n elif self.img_type == 'single':\n new_cfg, new_shapes = self.generate_single(target_cfg, label)\n\n # Create image and draw shapes\n img = self.create_image(new_shapes)\n imgs[i] = img\n labels[i] = label\n cfgs.append(new_cfg)\n shapes.append(new_shapes)\n cfgs_to_cap.append(cfg_to_cap)\n\n return imgs, labels, target_cfg, cfgs, cfgs_to_cap, shapes","def rand_crop_whole_ct(image, label, res_s, out_s,\n apply_data_aug, augment_times=2):\n if image.shape != (res_s, res_s, res_s) or \\\n label.shape != (res_s, res_s, res_s):\n logging.info(\"Unexpected shapes. \"\n \"image.shape: %s, label.shape: %s\",\n image.shape, label.shape)\n return\n\n if not apply_data_aug:\n # Do not augment data.\n idx = (res_s - out_s) // 2\n image = image[idx:idx + out_s, idx:idx + out_s, idx:idx + out_s]\n label = label[idx:idx + out_s, idx:idx + out_s, idx:idx + out_s]\n yield image, label\n else:\n cut = res_s - out_s\n for _ in range(augment_times):\n for i in [0, cut // 2, cut]:\n for j in [0, cut // 2, cut]:\n for k in [0, cut // 2, cut]:\n image_aug = image[i:i + out_s, j:j + out_s, k:k + out_s].copy()\n label_aug = label[i:i + out_s, j:j + out_s, k:k + out_s].copy()\n image_aug = intensity_change(image_aug)\n yield image_aug, label_aug","def generate_observations(self, eval_mode, augment_frames=None):\n episode_idx = 0\n augment_frames = (\n augment_frames if augment_frames is not None\n else self._augment_frames and not eval_mode)\n for t, obs in enumerate(self._flat_observations):\n if augment_frames:\n obs = image_utils.random_crop_image(obs)\n if self._split_by_episodes:\n yield obs, episode_idx\n else:\n yield obs\n if self._is_terminal[t]:\n episode_idx += 1","def gen_test_output(sess, logits, image_folder, image_pl, data_folder,\n learning_phase, image_shape, nw_shape):\n image_paths = glob(os.path.join(data_folder, image_folder, '*.png'))\n for image_file in image_paths[:5]:\n\n in_image = scipy.misc.imread(image_file, mode='RGB')\n image = scipy.misc.imresize(in_image, image_shape)\n\n street_im = get_seg_img(sess, logits, image_pl, image, image_shape,\n nw_shape, learning_phase)\n\n street_im = scipy.misc.imresize(street_im, in_image.shape)\n yield os.path.basename(image_file), np.array(street_im)","def s2s_data_generator(s2s_df=duplets, all_catalog=catalog_images, batch_size=None):\n orig_index_list = duplets.index.tolist()\n all_shop_index_list = catalog_images.index.tolist()\n dummy = np.zeros((1, 3 * N))\n\n while True:\n \n q_list = list()\n p_list = list()\n n_list = list()\n dummy_list = list()\n \n index_list = copy.copy(orig_index_list)\n \n while len(index_list) > 0:\n\n index = random.choice(index_list)\n product_id = duplets.loc[index, 'product_id']\n \n q_temp = duplets.loc[index, 'street_images']\n q_img = os.path.join(Path, q_temp + '.jpeg')\n \n p_temp = duplets.loc[index, 'shop_images']\n p_img = os.path.join(Path, p_temp + '.jpeg')\n\n while True:\n idx = random.choice(all_shop_index_list)\n prod_idx = catalog_images.loc[idx, 'product_id']\n\n if prod_idx != product_id:\n temp = random.choice(catalog_images.loc[idx, 'shop_images'])\n n_img = os.path.join(Path, temp + '.jpeg')\n\n q_img = os.path.join(Path, q_index + '.jpeg')\n p_img = os.path.join(Path, p_index + '.jpeg')\n n_img = os.path.join(Path, n_index + '.jpeg')\n\n res = bbox_mappings[q_index]\n\n left = res['left']\n top = res['top']\n right = left + res['width']\n bottom = top + res['height']\n\n\n query_img = Image.open(q_img)\n query_crop = query_img.crop((left, top, right, bottom))\n positive_img = Image.open(p_img)\n negative_img = Image.open(n_img)\n\n \n query = np.array(query_crop.resize((300,300), Image.NEAREST))\n positive = np.array(positive_img.resize((300,300), Image.NEAREST))\n negative = np.array(negative_img.resize((300,300), Image.NEAREST))\n \n \n q_list.append(query_array)\n p_list.append(positive_array)\n n_list.append(negative_array)\n dummy_list.append(dummy)\n\n \n index_list.remove(index)\n\n if len(q_list) == batch_size or (len(index_list) == 0 and len(q_list) > 0):\n yield convert_data(q_list, p_list, n_list, dummy_list)\n q_list = list()\n p_list = list()\n n_list = list()\n dummy_list = list()","def __init__(self, dataset, width=512, height=512, pictures=10, generate_classes=True, generate_objects=True):\n super().__init__(dataset)\n\n cropper = Cropper(width=width, height=height)\n\n dir_name = \"tmp-data-{}x{}-from-{}-pictures\".format(width, height, pictures)\n origins = os.path.join(dir_name, \"origins\")\n classes = os.path.join(dir_name, \"classes\")\n origins_classes_v_join = os.path.join(dir_name, \"origin-classes-v-join\")\n objects = os.path.join(dir_name, \"objects\")\n origins_objects_v_join = os.path.join(dir_name, \"origin-objects-v-join\")\n\n if not os.path.exists(origins):\n os.makedirs(origins)\n\n trains = self.get_iterable_trains()\n vals = self.get_iterable_evals()\n\n selection_set = []\n for _, val in enumerate(trains):\n origin, class_v, object_v = self.get_train_triple(val)\n selection_set.append((origin, class_v, object_v))\n for _, val in enumerate(vals):\n origin, class_v, object_v = self.get_val_triple(val)\n selection_set.append((origin, class_v, object_v))\n\n final_set = random.sample(selection_set, pictures)\n\n if generate_classes:\n if not os.path.exists(classes):\n os.makedirs(classes)\n if not os.path.exists(origins_classes_v_join):\n os.makedirs(origins_classes_v_join)\n\n if generate_objects:\n if not os.path.exists(objects):\n os.makedirs(objects)\n if not os.path.exists(origins_objects_v_join):\n os.makedirs(origins_objects_v_join)\n\n for _, (origin, class_v, object_v) in enumerate(final_set):\n print(\"Processing {}, {}, {}\".format(origin, class_v, object_v))\n cropper.set_imgs(origin, class_v, object_v, add_randomly=5)\n counter = 1\n while not cropper.is_finished:\n origin_i, class_i, object_i = cropper.next_crop()\n # Check that classes are involved\n finded = False\n for l in class_i:\n for pix in l:\n for c in pix:\n if c != 0:\n finded = True\n break\n if finded:\n break\n if finded:\n break\n if not finded:\n continue\n path = \"{}-{}.png\".format(get_origin_name(origin), counter)\n # print(\"Writing: {}\".format(os.path.join(origins, path)))\n cv2.imwrite(os.path.join(origins, path), origin_i)\n if generate_classes:\n cv2.imwrite(os.path.join(classes, path), class_i)\n cv2.imwrite(os.path.join(origins_classes_v_join, path), cv2.hconcat([origin_i, class_i]))\n if generate_objects:\n cv2.imwrite(os.path.join(objects, path), object_i)\n cv2.imwrite(os.path.join(origins_objects_v_join, path), cv2.hconcat([origin_i, object_i]))\n counter += 1\n\n print(\"Generating of {}-pictures-subset done. You find it in: {}\".format(pictures, dir_name))","def get_generators(patch_size, batch_size, preprocess_func, output_reshape_func, num_validation, train_processes,\n train_cache, train_data_dir='data/train/'):\n\n dirs = util.get_data_list(train_data_dir)\n labels = util.parse_labels_months()\n train_paths, validation_paths = util.train_validation_split(dirs, labels)\n # generate train batch loader\n train_data_loader = CTBatchLoader(train_paths, batch_size, patch_size, num_threads_in_multithreaded=1,\n preprocess_func=preprocess_func)\n\n train_transforms = get_train_transform(patch_size)\n train_data_generator = MultiThreadedAugmenter(train_data_loader, train_transforms, num_processes=train_processes,\n num_cached_per_queue=train_cache, seeds=None, pin_memory=False)\n\n # wrapper to be compatible with keras\n train_generator_keras = KerasGenerator(train_data_generator, output_reshapefunc=output_reshape_func)\n\n # generate validation batch loader\n valid_data_loader = CTBatchLoader(validation_paths, num_validation, patch_size,\n num_threads_in_multithreaded=1, preprocess_func=preprocess_func)\n valid_transforms = get_valid_transform(patch_size)\n valid_data_generator = MultiThreadedAugmenter(valid_data_loader, valid_transforms, num_processes=1,\n num_cached_per_queue=1, seeds=None, pin_memory=False)\n # wrapper to be compatible with keras\n valid_generator_keras = KerasGenerator(valid_data_generator, output_reshape_func, 1)\n\n return train_generator_keras, valid_generator_keras","def image_generator(df,batch_size,plab,augment=True):\n rng = np.random.RandomState(290615)\n if_train = 1 if plab < 1. else 0\n bi,b_list = 0,df.groupby('business_id').apply(get_biz_id,if_train,batch_size)\n b_list = b_list[b_list!=0]\n b_order = rng.permutation(b_list.index)\n pi,p_list = 0, df[df.iloc[:,-1]==0]['photo_id']\n p_order = rng.permutation(p_list.index)\n while True:\n if rng.rand(1)[0] < plab:\n # aggregate biz_id with outdoor-seating\n biz_id_i = b_list.ix[b_order[bi]]\n photo_train = df[df['business_id']==biz_id_i]['photo_id']\n y_batch = np.asarray(df[df['business_id']==biz_id_i].iloc[:,-1])\n # increase/loop indices for next iteration\n if bi < len(b_list)-1:\n bi += 1\n else:\n bi,b_order = 0,rng.permutation(b_list.index)\n else:\n # pic 32 random non-outdoor-seating pictures\n photo_train = p_list[p_order[pi:(pi+batch_size)]]\n y_batch = np.repeat(0, repeats=len(photo_train), axis=0)\n # increase/loop indices for next iteration\n if pi < len(p_list)-1-batch_size:\n pi += batch_size\n else:\n pi,p_order = 0,rng.permutation(p_list.index)\n batch_size_i = len(photo_train)\n # read and augment photos\n X_batch = np.empty((batch_size_i,h,w,ch))\n for i_ in range(batch_size_i):\n f_ = 'data/train_photos/' + str(photo_train.iloc[i_]) + '.jpg'\n im = Image.open(os.path.realpath(f_))\n im_sml = im.resize((w,h))\n # scale inputs [-1,+1]\n xi = np.asarray(im_sml)/128.-1\n if augment:\n # flip coords horizontally (but not vertically)\n if rng.rand(1)[0] > 0.5:\n xi = np.fliplr(xi)\n # rescale slightly within a random range\n jit = w*0.2\n if rng.rand(1)[0] > 0.1:\n xl,xr = rng.uniform(0,jit,1),rng.uniform(w-jit,w,1)\n yu,yd = rng.uniform(0,jit,1),rng.uniform(h-jit,h,1)\n pts1 = np.float32([[xl,yu],[xr,yu],[xl,yd],[xr,yd]])\n pts2 = np.float32([[0,0],[w,0],[0,h],[w,h]])\n M = cv2.getPerspectiveTransform(pts1,pts2)\n xi = cv2.warpPerspective(xi,M,(w,h))\n # save individual image to X_batch\n X_batch[i_,:,:,:] = xi\n# plt.imsave('data/aug_%i' % i_,(xi+1)/2);plt.close()\n yield([X_batch],y_batch)","def reconstructions_sample(self, n=()):\n self.assert_sampled()\n return [[j.sample(sample_shape=n, seed=self.randint).numpy()\n for j in i]\n for i in self._reconstructions]","def data_generator(dataset, config, shuffle=True, augmentation=None,\n random_rois=0, batch_size=1, detection_targets=False,\n diverse=0, no_augmentation_sources=None):\n b = 0 # batch item index\n image_index = -1\n image_ids = np.copy(dataset.image_ids)\n error_count = 0\n no_augmentation_sources = no_augmentation_sources or []\n\n # Anchors\n # [anchor_count, (y1, x1, y2, x2)]\n backbone_shapes = compute_backbone_shapes(config, config.IMAGE_SHAPE)\n anchors = utils.generate_pyramid_anchors(config.RPN_ANCHOR_SCALES,\n config.RPN_ANCHOR_RATIOS,\n backbone_shapes,\n config.BACKBONE_STRIDES,\n config.RPN_ANCHOR_STRIDE)\n\n # Keras requires a generator to run indefinitely.\n while True:\n try:\n # Increment index to pick next image. Shuffle if at the start of an epoch.\n image_index = (image_index + 1) % len(image_ids)\n if shuffle and image_index == 0:\n np.random.shuffle(image_ids)\n\n # Get GT bounding boxes and masks for image.\n image_id = image_ids[image_index]\n # If the image source is not to be augmented pass None as augmentation\n if dataset.image_info[image_id]['source'] in no_augmentation_sources: augmentation = None\n image, image_meta, gt_class_ids, gt_class_ids2, gt_boxes, gt_rboxes, gt_global_mask, \\\n gt_masks, gt_mask_score, gt_text_embeds, gt_embed_lengths = load_image_gt(dataset, config, image_id,\n augmentation=augmentation)\n\n \n # Skip images that have no instances. This can happen in cases\n # where we train on a subset of classes and the image doesn't\n # have any of the classes we care about.\n if not np.any(gt_class_ids > 0):\n continue\n\n # Use only positive class_ids\n categories = np.unique(gt_class_ids)\n _idx = categories > 0\n categories = categories[_idx]\n \n if config.MODEL == \"smrcnn\":\n # Use only active classes\n active_categories = []\n for c in categories:\n if any(c == dataset.ACTIVE_CLASSES):\n active_categories.append(c)\n \n # Skiop image if it contains no instance of any active class \n if not np.any(np.array(active_categories) > 0):\n continue\n # Randomly select category\n category = np.random.choice(active_categories)\n \n # NOTE for siamese\n # Generate siamese target crop\n targets = []\n for i in range(config.NUM_TARGETS):\n targets.append(get_one_target(category, dataset, config, augmentation=augmentation))\n # target = np.stack(target, axis=0)\n \n # print(target_class_id)\n target_class_id = category\n target_class_ids = np.array([target_class_id])\n \n idx = gt_class_ids == target_class_id\n siamese_class_ids = idx.astype('int8')\n # print(idx)\n # print(gt_boxes.shape, gt_masks.shape)\n siamese_class_ids = siamese_class_ids[idx]\n gt_class_ids = gt_class_ids[idx]\n gt_boxes = gt_boxes[idx,:]\n gt_masks = gt_masks[:,:,idx]\n image_meta = image_meta[:15] # TODO\n # --------------------------------------------------------------\n\n # RPN Targets\n # if rpn have muiltple label, rewrite here\n rpn_match, rpn_bbox = build_rpn_targets(image.shape, anchors,\n gt_class_ids, gt_boxes, config)\n\n # Mask R-CNN Targets\n if random_rois:\n rpn_rois = generate_random_rois(image.shape, random_rois, gt_class_ids, gt_boxes)\n if detection_targets:\n rois, mrcnn_class_ids, mrcnn_class_ids2, mrcnn_bbox, mrcnn_rbbox, mrcnn_mask,\\\n mrcnn_text_embeds, mrcnn_embed_lengths = build_detection_targets(\n rpn_rois, gt_class_ids, gt_boxes, gt_rboxes, gt_masks, gt_mask_score, gt_class_ids2, config)\n\n # Init batch arrays\n if b == 0:\n batch_image_meta = np.zeros((batch_size,) + image_meta.shape, dtype=image_meta.dtype)\n batch_rpn_match = np.zeros([batch_size, anchors.shape[0], 1], dtype=rpn_match.dtype)\n batch_rpn_bbox = np.zeros([batch_size, config.RPN_TRAIN_ANCHORS_PER_IMAGE, 4], dtype=rpn_bbox.dtype)\n batch_images = np.zeros((batch_size,) + image.shape, dtype=np.float32)\n batch_gt_class_ids = np.zeros((batch_size, config.MAX_GT_INSTANCES), dtype=np.int32)\n batch_gt_boxes = np.zeros((batch_size, config.MAX_GT_INSTANCES, 4), dtype=np.int32)\n batch_gt_rboxes = np.zeros((batch_size, config.MAX_GT_INSTANCES, 5), dtype=np.float32)\n if config.MODEL == \"smrcnn\":\n batch_targets = np.zeros((batch_size, config.NUM_TARGETS) + targets[0].shape, dtype=np.float32)\n batch_gt_masks = np.zeros((batch_size, gt_masks.shape[0], gt_masks.shape[1],\n config.MAX_GT_INSTANCES), dtype=gt_masks.dtype)\n batch_gt_class_ids2 = np.zeros((batch_size, config.MAX_GT_INSTANCES), dtype=np.int32)\n batch_gt_text_embeds = np.zeros((batch_size, config.MAX_GT_INSTANCES, config.MAX_LABEL_LENGTH), dtype=np.int32)\n batch_gt_embed_lengths = np.zeros((batch_size, config.MAX_GT_INSTANCES), dtype=np.int32)\n if random_rois:\n batch_rpn_rois = np.zeros((batch_size, rpn_rois.shape[0], 4), dtype=rpn_rois.dtype)\n if detection_targets:\n batch_rois = np.zeros((batch_size,) + rois.shape, dtype=rois.dtype)\n batch_mrcnn_class_ids = np.zeros((batch_size,) + mrcnn_class_ids.shape, dtype=mrcnn_class_ids.dtype)\n \n # ************************* NOTE for 2 label dataset\n if config.NUM_CLASSES2 > 2:\n batch_mrcnn_class_ids2 = np.zeros(\n (batch_size,) + mrcnn_class_ids2.shape, dtype=mrcnn_class_ids.dtype)\n # ************************* NOTE for ocr\n if config.READ:\n batch_mrcnn_text_embeds = np.zeros(\n (batch_size,) + mrcnn_text_embeds.shape, dtype=mrcnn_text_embeds.dtype)\n batch_mrcnn_embed_lengths = np.zeros(\n (batch_size,) + mrcnn_embed_lengths.shape, dtype=mrcnn_text_embeds.dtype)\n batch_mrcnn_bbox = np.zeros((batch_size,) + mrcnn_bbox.shape, dtype=mrcnn_bbox.dtype)\n batch_mrcnn_rbbox = np.zeros((batch_size,) + mrcnn_rbbox.shape, dtype=mrcnn_rbbox.dtype)\n batch_mrcnn_mask = np.zeros((batch_size,) + mrcnn_mask.shape, dtype=mrcnn_mask.dtype)\n\n # If more instances than fits in the array, sub-sample from them.\n if gt_boxes.shape[0] > config.MAX_GT_INSTANCES:\n ids = np.random.choice(\n np.arange(gt_boxes.shape[0]), config.MAX_GT_INSTANCES, replace=False)\n gt_class_ids = gt_class_ids[ids]\n siamese_class_ids = siamese_class_ids[ids] # NOTE\n gt_boxes = gt_boxes[ids]\n gt_rboxes = gt_rboxes[ids]\n gt_masks = gt_masks[:, :, ids]\n gt_class_ids2 = gt_class_ids2[ids]\n gt_text_embeds = gt_text_embeds[ids]\n gt_embed_lengths = gt_embed_lengths[ids]\n\n # Add to batch\n batch_image_meta[b] = image_meta\n batch_rpn_match[b] = rpn_match[:, np.newaxis]\n batch_rpn_bbox[b] = rpn_bbox\n batch_images[b] = mold_image(image.astype(np.float32), config)\n # NOTE for siamese\n if config.MODEL == \"smrcnn\":\n batch_targets[b] = np.stack([mold_image(target.astype(np.float32), config) for target in targets], axis=0)\n batch_gt_class_ids[b, :siamese_class_ids.shape[0]] = siamese_class_ids\n else:\n batch_gt_class_ids[b, :gt_class_ids.shape[0]] = gt_class_ids\n batch_gt_boxes[b, :gt_boxes.shape[0]] = gt_boxes\n batch_gt_rboxes[b, :gt_rboxes.shape[0]] = gt_rboxes\n batch_gt_masks[b, :, :, :gt_masks.shape[-1]] = gt_masks\n batch_gt_class_ids2[b, :gt_class_ids2.shape[0]] = gt_class_ids2\n batch_gt_text_embeds[b, :gt_text_embeds.shape[0], :gt_text_embeds.shape[1]] = gt_text_embeds\n batch_gt_embed_lengths[b, :gt_embed_lengths.shape[0]] = gt_embed_lengths\n if random_rois:\n batch_rpn_rois[b] = rpn_rois\n if detection_targets:\n batch_rois[b] = rois\n batch_mrcnn_class_ids[b] = mrcnn_class_ids\n batch_mrcnn_bbox[b] = mrcnn_bbox\n batch_mrcnn_rbbox[b] = mrcnn_rbbox\n batch_mrcnn_mask[b] = mrcnn_mask\n batch_mrcnn_class_ids2[b] = mrcnn_class_ids2\n batch_mrcnn_text_embeds[b] = mrcnn_text_embeds\n batch_mrcnn_embed_lengths[b] = mrcnn_embed_lengths\n b += 1\n # Batch full?\n if b >= batch_size:\n \n\n # NOTE for siamese\n if config.MODEL == \"smrcnn\":\n inputs = [batch_images, batch_image_meta, batch_targets, batch_rpn_match, batch_rpn_bbox,\n batch_gt_class_ids, batch_gt_class_ids2, batch_gt_boxes, batch_gt_rboxes, batch_gt_masks,\n batch_gt_text_embeds, batch_gt_embed_lengths]\n else:\n inputs = [batch_images, batch_image_meta, batch_rpn_match, batch_rpn_bbox,\n batch_gt_class_ids, batch_gt_class_ids2, batch_gt_boxes, batch_gt_rboxes, batch_gt_masks,\n batch_gt_text_embeds, batch_gt_embed_lengths]\n outputs = []\n if random_rois:\n inputs.extend([batch_rpn_rois])\n if detection_targets:\n inputs.extend([batch_rois])\n # Keras requires that output and targets have the same number of dimensions\n batch_mrcnn_class_ids = np.expand_dims(batch_mrcnn_class_ids, -1) \n \n # ************************* NOTE for 2 label dataset\n # ************************* NOTE for ocr\n if config.RBOX and config.READ and config.HAVE_LABEL2:\n batch_mrcnn_class_ids2 = np.expand_dims(batch_mrcnn_class_ids2, -1)\n batch_mrcnn_text_embeds = np.expand_dims(batch_mrcnn_text_embeds, -1)\n batch_mrcnn_embed_lengths = np.expand_dims(batch_mrcnn_embed_lengths, -1)\n outputs.extend(\n [batch_mrcnn_class_ids, batch_mrcnn_class_ids2, batch_mrcnn_bbox,\\\n batch_mrcnn_rbbox, batch_mrcnn_mask,\n batch_mrcnn_text_embeds, batch_mrcnn_embed_lengths])\n elif config.RBOX and config.READ and not config.HAVE_LABEL2:\n batch_mrcnn_text_embeds = np.expand_dims(batch_mrcnn_text_embeds, -1)\n batch_mrcnn_embed_lengths = np.expand_dims(batch_mrcnn_embed_lengths, -1)\n outputs.extend(\n [batch_mrcnn_class_ids, batch_mrcnn_bbox, batch_mrcnn_rbbox, batch_mrcnn_mask,\n batch_mrcnn_text_embeds, batch_mrcnn_embed_lengths])\n elif config.RBOX and not config.READ and config.HAVE_LABEL2:\n batch_mrcnn_class_ids2 = np.expand_dims(batch_mrcnn_class_ids2, -1) \n outputs.extend(\n [batch_mrcnn_class_ids, batch_mrcnn_class_ids2, batch_mrcnn_bbox,\\\n batch_mrcnn_rbbox, batch_mrcnn_mask])\n elif config.RBOX and not config.READ and not config.HAVE_LABEL2:\n outputs.extend(\n [batch_mrcnn_class_ids, batch_mrcnn_bbox, batch_mrcnn_rbbox, batch_mrcnn_mask])\n elif not config.RBOX and config.READ and config.HAVE_LABEL2:\n batch_mrcnn_class_ids2 = np.expand_dims(batch_mrcnn_class_ids2, -1)\n batch_mrcnn_text_embeds = np.expand_dims(batch_mrcnn_text_embeds, -1)\n batch_mrcnn_embed_lengths = np.expand_dims(batch_mrcnn_embed_lengths, -1)\n outputs.extend(\n [batch_mrcnn_class_ids, batch_mrcnn_class_ids2, batch_mrcnn_bbox,\\\n batch_mrcnn_mask,\n batch_mrcnn_text_embeds, batch_mrcnn_embed_lengths])\n elif not config.RBOX and config.READ and not config.HAVE_LABEL2:\n batch_mrcnn_text_embeds = np.expand_dims(batch_mrcnn_text_embeds, -1)\n batch_mrcnn_embed_lengths = np.expand_dims(batch_mrcnn_embed_lengths, -1)\n outputs.extend(\n [batch_mrcnn_class_ids, batch_mrcnn_bbox, batch_mrcnn_mask,\n batch_mrcnn_text_embeds, batch_mrcnn_embed_lengths])\n elif not config.RBOX and not config.READ and config.HAVE_LABEL2:\n batch_mrcnn_class_ids2 = np.expand_dims(batch_mrcnn_class_ids2, -1) \n outputs.extend(\n [batch_mrcnn_class_ids, batch_mrcnn_class_ids2, batch_mrcnn_bbox,\\\n batch_mrcnn_mask])\n elif not config.RBOX and not config.READ and not config.HAVE_LABEL2:\n outputs.extend(\n [batch_mrcnn_class_ids, batch_mrcnn_bbox, batch_mrcnn_mask])\n\n yield inputs, outputs\n\n # start a new batch\n b = 0\n except (GeneratorExit, KeyboardInterrupt):\n raise\n except:\n # Log it and skip the image\n logging.exception(f\"Error processing image {dataset.image_info[image_id]}\")\n error_count += 1\n if error_count > 5:\n raise","def generate_batch_1(batch_size, img_shape, itm_size, n_itms, prob_type = 'SD'):\n # np.random.seed(100)\n # Change `problem_type` to SR for spatial relation labels\n data_parameters = {'problem_type': prob_type,\n 'item_size': [itm_size[0],itm_size[1]],\n 'box_extent': [img_shape[0], img_shape[1]],\n 'num_items': n_itms,\n 'num_item_pixel_values': 1,\n 'SD_portion': 0,\n 'SR_portion': 1,\n 'full_size': 2, #whether ground label should be a full-size masked image or concatenated patches from the original image. 0 = merged patches, 1 = masked image, 2 = both\n 'mask': True, #This parameter is introduced in order to generate label of the image as 1 where patch is and 0 else where.\n 'display': False}\n\n\n data_generator = psvrt.psvrt(raw_input_size=img_shape, batch_size=batch_size) # Load generator\n data_generator.initialize_vars(**data_parameters) # Initialize it with image parameters\n\n data = data_generator.single_batch() # Fetch a single batch\n\n stimuli = np.array(data[0]) # Images\n labels = np.array(data[1]) # Labels\n label_positions = np.array(data[2])\n all_items = np.asarray(data[3])\n\n labels_temp = np.array(np.squeeze(labels[:, 0, 0, 0]), np.int64)\n train_data = np.reshape(stimuli, [stimuli.shape[0], stimuli.shape[1] * stimuli.shape[2] * stimuli.shape[3]])\n mask_labels = rgb2grey(np.array([items[0] for items in all_items]))\n\n ret_lbls = np.zeros([batch_size, 2])\n indices_1 = np.where(labels_temp == 1)\n indices_0 = np.where(labels_temp == 0)\n\n ret_lbls[indices_0] = [1,0]\n ret_lbls[indices_1] = [0,1]\n mask_labels = np.reshape(mask_labels, [mask_labels.shape[0], mask_labels.shape[1] * mask_labels.shape[2]])\n # left_mask, right_mask = sep_boxes(img_shape, itm_size, n_itms, mask_labels, labels_temp)\n # left_mask = np.reshape(left_mask, [batch_size,img_shape[0] * img_shape[1]])\n # right_mask = np.reshape(right_mask, [batch_size, img_shape[0] * img_shape[1]])\n\n\n return train_data, mask_labels, ret_lbls","def resnet_6blocks(pretrained=False, **kwargs):\n return ResnetGenerator(\n 6, **kwargs\n )","def __init__(self, input_nc, output_nc, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, n_blocks=6,\n padding_type='reflect'):\n assert (n_blocks >= 0)\n super(ResnetGenerator, self).__init__()\n if type(norm_layer) == functools.partial:\n use_bias = norm_layer.func == nn.InstanceNorm2d\n else:\n use_bias = norm_layer == nn.InstanceNorm2d\n\n model = [nn.ReflectionPad2d(3),\n nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0, bias=use_bias),\n norm_layer(ngf),\n nn.ReLU(True)]\n\n n_downsampling = 2\n for i in range(n_downsampling): # add downsampling layers\n mult = 2 ** i\n model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3, stride=2, padding=1, bias=use_bias),\n norm_layer(ngf * mult * 2),\n nn.ReLU(True)]\n\n mult = 2 ** n_downsampling\n for i in range(n_blocks): # add ResNet blocks\n\n model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout,\n use_bias=use_bias)]\n\n for i in range(n_downsampling): # add upsampling layers\n mult = 2 ** (n_downsampling - i)\n model += [nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2),\n kernel_size=3, stride=2,\n padding=1, output_padding=1,\n bias=use_bias),\n norm_layer(int(ngf * mult / 2)),\n nn.ReLU(True)]\n model += [nn.ReflectionPad2d(3)]\n model += [nn.Conv2d(ngf, output_nc, kernel_size=7, padding=0)]\n # model += [nn.Tanh()]\n model += [nn.Sigmoid()]\n\n self.model = nn.Sequential(*model)","def generate_batch(batch_size, img_shape, itm_size, n_itms, prob_type = 'SD'):\n\t# Change `problem_type` to SR for spatial relation labels\n\tdata_parameters = {'problem_type': prob_type,\n\t\t\t 'item_size': [itm_size[0],itm_size[1]],\n\t\t\t 'box_extent': [img_shape[0], img_shape[1]],\n\t\t\t 'num_items': n_itms,\n\t\t\t 'num_item_pixel_values': 1,\n\t\t\t 'SD_portion': 0,\n\t\t\t 'SR_portion': 1,\n\t\t\t\t'full_size': 2, #whether ground label should be a full-size masked image or concatenated patches from the original image. 0 = merged patches, 1 = masked image, 2 = both\n\t\t\t\t'mask': True, #This parameter is introduced in order to generate label of the image as 1 where patch is and 0 else where.\n\t\t\t 'display': False}\n\n\n\tdata_generator = psvrt.psvrt(raw_input_size=img_shape, batch_size=batch_size) # Load generator\n\tdata_generator.initialize_vars(**data_parameters) # Initialize it with image parameters\n\n\tdata = data_generator.single_batch() # Fetch a single batch\n\n\tstimuli = np.array(data[0]) # Images\n\tlabels = np.array(data[1]) # Labels\n\tlabel_positions = np.array(data[2])\n\tall_items = np.asarray(data[3])\n\n\tlabels_temp = np.array(np.squeeze(labels[:, 0, 0, 0]), np.int64)\n\ttrain_data = np.reshape(stimuli, [stimuli.shape[0], stimuli.shape[1] * stimuli.shape[2] * stimuli.shape[3]])\n\tmask_labels = rgb2grey(np.array([items[0] for items in all_items]))\n\n\tret_lbls = np.zeros([batch_size, 2])\n\tindices_1 = np.where(labels_temp == 1)\n\tindices_0 = np.where(labels_temp == 0)\n\n\tret_lbls[indices_0] = [1,0]\n\tret_lbls[indices_1] = [0,1]\n\n\tleft_mask, right_mask = sep_boxes(img_shape, itm_size, n_itms, mask_labels, labels_temp)\n\n\t\"\"\"This part of the code is written to add 2 dimensions for every pixel, whether that pixel is 0 or 1.\"\"\"\n\t# ret_lmask = np.zeros([batch_size, img_shape[0] * img_shape[1], 2])\n\t# ret_rmask = np.zeros([batch_size, img_shape[0] * img_shape[1], 2])\n\n\tleft_mask = np.reshape(left_mask, [batch_size,img_shape[0] * img_shape[1]])\n\t# indices_lmask_1 = np.where(left_mask == 1)\n\t# indices_lmask_0 = np.where(left_mask == 0)\n\t#\n\t#\n\t# ret_lmask[indices_lmask_0] = [1.,0.]\n\t# ret_lmask[indices_lmask_1] = [0.,1.]\n\n\t# print(ret_lmask)\n\t# left_mask[0, indices_lmask_1] = [0.,1.]\n\n\n\tright_mask = np.reshape(right_mask, [batch_size, img_shape[0] * img_shape[1]])\n\n\t# indices_rmask_1 = np.where(right_mask == 1)\n\t# indices_rmask_0 = np.where(right_mask == 0)\n\t#\n\t# ret_rmask[indices_rmask_0] = [1.,0.]\n\t# ret_rmask[indices_rmask_1] = [0.,1.]\n\n\t# print(left_mask)\n\t# print(right_mask)\n\n\treturn train_data, mask_labels, left_mask, right_mask, ret_lbls","def generate_images_pred(self, inputs, outputs):\n for scale in self.scales:\n disp = outputs[(\"disp\", scale)]\n disp = F.interpolate(\n disp, [self.height, self.width], mode=\"bilinear\", align_corners=False)\n source_scale = 0\n\n _, depth = disp_to_depth(disp, self.min_depth, self.max_depth)\n\n outputs[(\"depth\", 0, scale)] = depth\n\n for i, frame_id in enumerate(self.frame_ids[1:]):\n\n T = outputs[(\"cam_T_cam\", 0, frame_id)]\n\n # from the authors of https://arxiv.org/abs/1712.00175\n # mean-normalized inverse depth from [62] to discourage shrinking of the estimated depth\n\n axisangle = outputs[(\"axisangle\", 0, frame_id)]\n translation = outputs[(\"translation\", 0, frame_id)]\n\n inv_depth = 1 / depth\n mean_inv_depth = inv_depth.mean(3, True).mean(2, True)\n\n T = transformation_from_parameters(\n axisangle[:, 0], translation[:, 0] * mean_inv_depth[:, 0], frame_id < 0)\n\n cam_points = self.backproject_depth[source_scale](\n depth, inputs[(\"inv_K\", source_scale)])\n pix_coords = self.project_3d[source_scale](\n cam_points, inputs[(\"K\", source_scale)], T)\n\n outputs[(\"sample\", frame_id, scale)] = pix_coords\n\n outputs[(\"color\", frame_id, scale)] = F.grid_sample(\n inputs[(\"color\", frame_id, source_scale)],\n outputs[(\"sample\", frame_id, scale)],\n padding_mode=\"border\")\n\n outputs[(\"color_identity\", frame_id, scale)] = \\\n inputs[(\"color\", frame_id, source_scale)]","def _yield_testing(self, batch_index):\n samples_start = batch_index % self.num_samples\n samples_end = (batch_index+1) % self.num_samples\n if samples_start < samples_end:\n batch_samples = self.test_data[samples_start:samples_end]\n else:\n batch_samples = self.test_data[samples_start:]\n batch_samples.extend(self.test_data[:samples_end])\n images = []\n rois = []\n for sample in batch_samples:\n # 'sample' has this structure:\n # {path: {\n # 'roi_origin_x': test_sample[1]['roi_origin_x'],\n # 'roi_origin_y': test_sample[1]['roi_origin_y'],\n # 'roi_width': test_sample[1]['roi_width'],\n # 'roi_height': test_sample[1]['roi_height'] \n # } \n # }\n img_path = os.path.join(self.dataset_root_path, list(sample.keys())[0])\n img = cv2.imread(img_path) # watch out for slashes (/)\n # if the path does not exist or there are problems while reading the image\n if img is None:\n print('[DATA LOADER ERROR] cannot find image at path: ', img_path)\n continue\n roi_data = list(sample.values())[0]\n roi = {\n 'upper_left_x': roi_data['roi_origin_x'],\n 'upper_left_y': roi_data['roi_origin_y'],\n 'width': roi_data['roi_width'],\n 'height': roi_data['roi_height']\n }\n img = img.astype('float32')\n images.append(img)\n rois.append(roi)\n return images, rois","def preprocess_scans(self, scan_ids, width, height, depth, clipping=True, loop=False,\n shuffle=False):\n while True:\n if shuffle:\n random.shuffle(scan_ids)\n for scan_id in scan_ids:\n ct_scan, origin, spacing = self.get_scan(scan_id, resample=True)\n if clipping:\n scan, origin, spacing = self.rescale_scan(\n ct_scan, origin, spacing, width, height, depth, normalize=True\n )\n yield self.clip_scan(scan), origin, spacing\n else:\n yield self.rescale_scan(\n ct_scan, origin, spacing, width, height, depth, normalize=True\n )\n if not loop:\n break","def gen_batches_functions(data_folder, image_paths, image_shape, out_shape,\n label_folder):\n\n def get_batches_fn(batch_size):\n \"\"\"\n Create batches of training data\n :param batch_size: Batch Size\n :return: Batches of training data\n \"\"\"\n id_road = 7\n id_lane = 6\n id_car = 10\n\n for batch_i in range(0, len(image_paths), batch_size):\n images = []\n gt_images = []\n for image_file in image_paths[batch_i:batch_i + batch_size]:\n # Get corresponding label img path\n gt_image_file = image_file.replace('CameraRGB', 'CameraSeg')\n # Read rgb and label images\n img_in = scipy.misc.imread(image_file, mode='RGB')\n gt_in = scipy.misc.imread(gt_image_file)\n # Crop sky part of the image\n image = img_in[-out_shape[0]:, :]\n gt_image = gt_in[-out_shape[0]:, :, 0]\n # Obtain labels\n gt_road = ((gt_image == id_road) | (gt_image == id_lane))\n gt_car = (gt_image == id_car)\n gt_car[-105:, :] = False\n gt_bg = np.invert(gt_car | gt_road)\n # Augmentation\n if bool(random.getrandbits(1)):\n image, gt_bg, gt_car, gt_road = flip_img(\n image, gt_bg, gt_car, gt_road)\n\n gt_bg = gt_bg.reshape(*gt_bg.shape, 1)\n gt_car = gt_car.reshape(*gt_car.shape, 1)\n gt_road = gt_road.reshape(*gt_road.shape, 1)\n\n gt_image = np.concatenate((gt_bg, gt_car, gt_road), axis=2)\n\n images.append(image)\n gt_images.append(gt_image)\n\n yield np.array(images), np.array(gt_images)\n\n return get_batches_fn","def _train_aug(self, results):\n img = results['img']\n h, w, c = img.shape\n boxes = results['gt_bboxes']\n while True:\n scale = random.choice(self.ratios)\n new_h = int(self.crop_size[0] * scale)\n new_w = int(self.crop_size[1] * scale)\n h_border = self._get_border(self.border, h)\n w_border = self._get_border(self.border, w)\n\n for i in range(50):\n center_x = random.randint(low=w_border, high=w - w_border)\n center_y = random.randint(low=h_border, high=h - h_border)\n\n cropped_img, border, patch = self._crop_image_and_paste(\n img, [center_y, center_x], [new_h, new_w])\n\n mask = self._filter_boxes(patch, boxes)\n # if image do not have valid bbox, any crop patch is valid.\n if not mask.any() and len(boxes) > 0:\n continue\n\n results['img'] = cropped_img\n results['img_shape'] = cropped_img.shape\n results['pad_shape'] = cropped_img.shape\n\n x0, y0, x1, y1 = patch\n\n left_w, top_h = center_x - x0, center_y - y0\n cropped_center_x, cropped_center_y = new_w // 2, new_h // 2\n\n # crop bboxes accordingly and clip to the image boundary\n for key in results.get('bbox_fields', []):\n mask = self._filter_boxes(patch, results[key])\n bboxes = results[key][mask]\n bboxes[:, 0:4:2] += cropped_center_x - left_w - x0\n bboxes[:, 1:4:2] += cropped_center_y - top_h - y0\n if self.bbox_clip_border:\n bboxes[:, 0:4:2] = np.clip(bboxes[:, 0:4:2], 0, new_w)\n bboxes[:, 1:4:2] = np.clip(bboxes[:, 1:4:2], 0, new_h)\n keep = (bboxes[:, 2] > bboxes[:, 0]) & (\n bboxes[:, 3] > bboxes[:, 1])\n bboxes = bboxes[keep]\n results[key] = bboxes\n if key in ['gt_bboxes']:\n if 'gt_labels' in results:\n labels = results['gt_labels'][mask]\n labels = labels[keep]\n results['gt_labels'] = labels\n if 'gt_masks' in results:\n raise NotImplementedError(\n 'RandomCenterCropPad only supports bbox.')\n\n # crop semantic seg\n for key in results.get('seg_fields', []):\n raise NotImplementedError(\n 'RandomCenterCropPad only supports bbox.')\n return results","def batch_generator(labels_df, set_kind):\n # Generate training batches\n if set_kind == \"train\" and (labels_df.shape[0] == 32384 or labels_df.shape[0] == 3120 or labels_df.shape[0] == 64):\n while 1:\n\n for i in range(labels_df.shape[0]//8):\n x_train = np.load('data/train-npy/npdatasetX{}.npy'.format(i))\n y_train = np.load('data/train-npy/npdatasetY{}.npy'.format(i))\n\n for j in range(1):\n x_trainj = x_train[j*8:j*8-1,:]\n y_trainj = y_train[j*8:j*8-1,:]\n\n yield (x_trainj, y_trainj)\n\n\n # Generate validation batches\n if set_kind == \"valid\" and (labels_df.shape[0] == 8080 or labels_df.shape[0] == 1920 or labels_df.shape[0] == 8):\n while 1:\n\n for i in range(labels_df.shape[0]//4): \n x_valid = np.load('data/valid-npy/npdatasetX{}.npy'.format(i))\n y_valid = np.load('data/valid-npy/npdatasetY{}.npy'.format(i))\n\n for j in range(1): \n x_validj = x_valid[j*4:j*4-1,:]\n y_validj = y_valid[j*4:j*4-1,:]\n\n yield (x_validj, y_validj)\n\n\n # Generate test batches\n if set_kind == \"test\" and labels_df.shape[0] == 40669:\n while 1:\n\n for i in range(labels_df.shape[0]//4): #REPLACE 1 by 3\n x_valid = np.load('data/valid-npy/npdatasetX{}.npy'.format(i))\n\n for j in range(1): #REPLACE 2 by 2816\n x_validj = x_valid[j*4:j*4-1,:]\n \n yield (x_validj, y_validj)\n\n if set_kind == \"test\" and (labels_df.shape[0] == 8080 or labels_df.shape[0] == 8):\n while 1:\n\n for i in range(labels_df.shape[0]//8): #REPLACE 1 by 3\n x_valid = np.load('data/valid-npy/npdatasetX{}.npy'.format(i))\n\n for j in range(2): #REPLACE 2 by 2816\n x_validj = x_valid[j*4:j*4-1,:]\n\n yield x_validj","def __call__(self, results):\n\n if 'img_fields' in results:\n assert results['img_fields'] == ['img'], \\\n 'Only single img_fields is allowed'\n img = results['img']\n assert 'bbox_fields' in results\n boxes = [results[key] for key in results['bbox_fields']]\n boxes = np.concatenate(boxes, 0)\n h, w, c = img.shape\n while True:\n mode = random.choice(self.sample_mode)\n self.mode = mode\n if mode == 1:\n return results\n\n min_iou = mode\n for i in range(50):\n new_w = random.uniform(self.min_crop_size * w, w)\n new_h = random.uniform(self.min_crop_size * h, h)\n\n # h / w in [0.5, 2]\n if new_h / new_w < 0.5 or new_h / new_w > 2:\n continue\n\n left = random.uniform(w - new_w)\n top = random.uniform(h - new_h)\n\n patch = np.array(\n (int(left), int(top), int(left + new_w), int(top + new_h)))\n # Line or point crop is not allowed\n if patch[2] == patch[0] or patch[3] == patch[1]:\n continue\n overlaps = bbox_overlaps(\n patch.reshape(-1, 4), boxes.reshape(-1, 4)).reshape(-1)\n if len(overlaps) > 0 and overlaps.min() < min_iou:\n continue\n\n # center of boxes should inside the crop img\n # only adjust boxes and instance masks when the gt is not empty\n if len(overlaps) > 0:\n # adjust boxes\n def is_center_of_bboxes_in_patch(boxes, patch):\n center = (boxes[:, :2] + boxes[:, 2:]) / 2\n mask = ((center[:, 0] > patch[0]) *\n (center[:, 1] > patch[1]) *\n (center[:, 0] < patch[2]) *\n (center[:, 1] < patch[3]))\n return mask\n\n mask = is_center_of_bboxes_in_patch(boxes, patch)\n if not mask.any():\n continue\n for key in results.get('bbox_fields', []):\n boxes = results[key].copy()\n mask = is_center_of_bboxes_in_patch(boxes, patch)\n boxes = boxes[mask]\n if self.bbox_clip_border:\n boxes[:, 2:] = boxes[:, 2:].clip(max=patch[2:])\n boxes[:, :2] = boxes[:, :2].clip(min=patch[:2])\n boxes -= np.tile(patch[:2], 2)\n\n results[key] = boxes\n # labels\n label_key = self.bbox2label.get(key)\n if label_key in results:\n results[label_key] = results[label_key][mask]\n\n # mask fields\n mask_key = self.bbox2mask.get(key)\n if mask_key in results:\n results[mask_key] = results[mask_key][\n mask.nonzero()[0]].crop(patch)\n # adjust the img no matter whether the gt is empty before crop\n img = img[patch[1]:patch[3], patch[0]:patch[2]]\n results['img'] = img\n results['img_shape'] = img.shape\n\n # seg fields\n for key in results.get('seg_fields', []):\n results[key] = results[key][patch[1]:patch[3],\n patch[0]:patch[2]]\n return results","def train_batches_with_generated_images(gen, x_train_input, X_train, disc_batch_size):\n # output of gen is input of disc\n image_input_batch = x_train_input[np.random.randint(0, X_train.shape[0], size=disc_batch_size), :, :, :]\n noise_X = np.random.uniform(0, 1, size=[disc_batch_size, 100])\n generated_images = gen.predict([image_input_batch, noise_X])\n train_batches(0)","def _get_train_generator(self):\n while(True):\n random.shuffle(self.train)\n for data_element in self.train:\n if self.debug: \n print(\"training on: {}\".format(data_element))\n\n image, heatmap = self._generate_input_tuple(data_element)\n\n if self.debug: \n print(\"yields: {}\".format(data_element))\n\n yield (image, heatmap)","def rand_crop_liver(image, label, res_s, out_s,\n apply_data_aug, augment_times=54):\n if image.shape != (res_s, res_s, res_s) or \\\n label.shape != (res_s, res_s, res_s):\n logging.info(\"Unexpected shapes. \"\n \"image.shape: %s, label.shape: %s\",\n image.shape, label.shape)\n return\n\n rough_liver_label = 1\n x, y, z = np.where(label == rough_liver_label)\n bbox_center = [(x.min() + x.max()) // 2,\n (y.min() + y.max()) // 2,\n (z.min() + z.max()) // 2]\n\n def in_range_check(c):\n c = max(c, out_s // 2)\n c = min(c, res_s - out_s // 2)\n return c\n\n for _ in range(augment_times):\n rand_c = []\n for c in bbox_center:\n sigma = out_s // 6\n truncate_rad = out_s // 4\n c += np.clip(np.random.randn() * sigma, -truncate_rad, truncate_rad)\n rand_c.append(int(in_range_check(c)))\n\n image_aug = image[rand_c[0] - out_s // 2:rand_c[0] + out_s // 2,\n rand_c[1] - out_s // 2:rand_c[1] + out_s // 2,\n rand_c[2] - out_s // 2:rand_c[2] + out_s // 2].copy()\n label_aug = label[rand_c[0] - out_s // 2:rand_c[0] + out_s // 2,\n rand_c[1] - out_s // 2:rand_c[1] + out_s // 2,\n rand_c[2] - out_s // 2:rand_c[2] + out_s // 2].copy()\n\n if apply_data_aug:\n image_aug = intensity_change(image_aug)\n\n yield image_aug, label_aug","def generate_batch_1(batch_size, img_shape, itm_size, n_itms, prob_type = 'SD'):\n\t# np.random.seed(100)\n\t# Change `problem_type` to SR for spatial relation labels\n\tdata_parameters = {'problem_type': prob_type,\n\t\t\t 'item_size': [itm_size[0],itm_size[1]],\n\t\t\t 'box_extent': [img_shape[0], img_shape[1]],\n\t\t\t 'num_items': n_itms,\n\t\t\t 'num_item_pixel_values': 1,\n\t\t\t 'SD_portion': 0,\n\t\t\t 'SR_portion': 1,\n\t\t\t\t'full_size': 2, #whether ground label should be a full-size masked image or concatenated patches from the original image. 0 = merged patches, 1 = masked image, 2 = both\n\t\t\t\t'mask': True, #This parameter is introduced in order to generate label of the image as 1 where patch is and 0 else where.\n\t\t\t 'display': False}\n\n\n\tdata_generator = psvrt.psvrt(raw_input_size=img_shape, batch_size=batch_size) # Load generator\n\tdata_generator.initialize_vars(**data_parameters) # Initialize it with image parameters\n\n\tdata = data_generator.single_batch() # Fetch a single batch\n\n\tstimuli = np.array(data[0]) # Images\n\tlabels = np.array(data[1]) # Labels\n\tlabel_positions = np.array(data[2])\n\tall_items = np.asarray(data[3])\n\n\tlabels_temp = np.array(np.squeeze(labels[:, 0, 0, 0]), np.int64)\n\ttrain_data = np.reshape(stimuli, [stimuli.shape[0], stimuli.shape[1] * stimuli.shape[2] * stimuli.shape[3]])\n\tmask_labels = rgb2grey(np.array([items[0] for items in all_items]))\n\n\tret_lbls = np.zeros([batch_size, 2])\n\tindices_1 = np.where(labels_temp == 1)\n\tindices_0 = np.where(labels_temp == 0)\n\n\tret_lbls[indices_0] = [1,0]\n\tret_lbls[indices_1] = [0,1]\n\tmask_labels = np.reshape(mask_labels, [mask_labels.shape[0], mask_labels.shape[1] * mask_labels.shape[2]])\n\t# left_mask, right_mask = sep_boxes(img_shape, itm_size, n_itms, mask_labels, labels_temp)\n\t# left_mask = np.reshape(left_mask, [batch_size,img_shape[0] * img_shape[1]])\n\t# right_mask = np.reshape(right_mask, [batch_size, img_shape[0] * img_shape[1]])\n\n\n\treturn train_data, mask_labels, ret_lbls","def resnet_v1_generator(block_fn,\n num_blocks,\n num_classes,\n pruning_method='baseline',\n init_method='baseline',\n width=1.,\n prune_first_layer=True,\n prune_last_layer=True,\n data_format='channels_first',\n end_sparsity=0.,\n weight_decay=0.,\n name=None):\n\n def model(inputs, is_training):\n \"\"\"Creation of the model graph.\"\"\"\n with tf.variable_scope(name, 'resnet_model'):\n inputs = conv2d_fixed_padding(\n inputs=inputs,\n filters=int(64 * width),\n kernel_size=7,\n strides=2,\n pruning_method=pruning_method if prune_first_layer else 'baseline',\n init_method=init_method if prune_first_layer else 'baseline',\n data_format=data_format,\n end_sparsity=end_sparsity,\n weight_decay=weight_decay,\n name='initial_conv')\n\n inputs = tf.identity(inputs, 'initial_conv')\n inputs = batch_norm_relu(\n inputs, is_training, data_format=data_format)\n\n inputs = tf.layers.max_pooling2d(\n inputs=inputs,\n pool_size=3,\n strides=2,\n padding='SAME',\n data_format=data_format,\n name='initial_max_pool')\n inputs = tf.identity(inputs, 'initial_max_pool')\n\n inputs = block_group(\n inputs=inputs,\n filters=int(64 * width),\n block_fn=block_fn,\n blocks=num_blocks[0],\n strides=1,\n is_training=is_training,\n name='block_group1',\n pruning_method=pruning_method,\n init_method=init_method,\n data_format=data_format,\n end_sparsity=end_sparsity,\n weight_decay=weight_decay)\n inputs = block_group(\n inputs=inputs,\n filters=int(128 * width),\n block_fn=block_fn,\n blocks=num_blocks[1],\n strides=2,\n is_training=is_training,\n name='block_group2',\n pruning_method=pruning_method,\n init_method=init_method,\n data_format=data_format,\n end_sparsity=end_sparsity,\n weight_decay=weight_decay)\n inputs = block_group(\n inputs=inputs,\n filters=int(256 * width),\n block_fn=block_fn,\n blocks=num_blocks[2],\n strides=2,\n is_training=is_training,\n name='block_group3',\n pruning_method=pruning_method,\n init_method=init_method,\n data_format=data_format,\n end_sparsity=end_sparsity,\n weight_decay=weight_decay)\n inputs = block_group(\n inputs=inputs,\n filters=int(512 * width),\n block_fn=block_fn,\n blocks=num_blocks[3],\n strides=2,\n is_training=is_training,\n name='block_group4',\n pruning_method=pruning_method,\n init_method=init_method,\n data_format=data_format,\n end_sparsity=end_sparsity,\n weight_decay=weight_decay)\n\n pool_size = (inputs.shape[1], inputs.shape[2])\n inputs = tf.layers.average_pooling2d(\n inputs=inputs,\n pool_size=pool_size,\n strides=1,\n padding='VALID',\n data_format=data_format,\n name='final_avg_pool')\n inputs = tf.identity(inputs, 'final_avg_pool')\n multiplier = 4 if block_fn is bottleneck_block_ else 1\n fc_units = multiplier * int(512 * width)\n inputs = tf.reshape(inputs, [-1, fc_units])\n kernel_initializer = tf.random_normal_initializer(stddev=.01)\n # If init_method==sparse and not pruning, skip.\n if init_method != 'sparse' or prune_last_layer:\n kernel_initializer = _pick_initializer(kernel_initializer, init_method,\n pruning_method, end_sparsity)\n kernel_regularizer = contrib_layers.l2_regularizer(weight_decay)\n inputs = sparse_fully_connected(\n x=inputs,\n units=num_classes,\n sparsity_technique=pruning_method if prune_last_layer else 'baseline',\n kernel_initializer=kernel_initializer,\n kernel_regularizer=kernel_regularizer,\n name='final_dense')\n\n inputs = tf.identity(inputs, 'final_dense')\n return inputs\n\n model.default_image_size = 224\n return model","def patchGenerator(gen, patch_size=128, patch_batch_size=1):\n \n for imgs, masks in gen: # For each batch\n img_list = []\n mask_list = []\n for i in range(0, imgs.shape[0]): # For each image in a batch\n patch_x = patchify(imgs[i], (patch_size, patch_size, imgs[i].shape[-1]), step=patch_size) # split image into 4*4 small 128*128 patches.\n img_p = patch_x.reshape(-1, *patch_x.shape[-3:])\n img_list.append(img_p)\n\n mask_y = patchify(masks[i], (patch_size, patch_size, 1), step=patch_size) # split mask into 4*4 small 128*128 patches.\n mask_p = mask_y.reshape(-1, *mask_y.shape[-3:])\n mask_list.append(mask_p)\n \n if (patch_batch_size == 1):\n for j in range(0, img_p.shape[0]): # For each patch in a image\n yield img_p[j][np.newaxis, :], mask_p[j][np.newaxis, :]\n \n if (patch_batch_size > 1):\n image_patches = np.concatenate(img_list)\n mask_patches = np.concatenate(mask_list)\n patch_batch_counter = 0\n for idx in range(0, patch_batch_size):\n image_patch_batch = image_patches[patch_batch_counter:patch_batch_counter + patch_batch_size]\n mask_patch_batch = mask_patches[patch_batch_counter:patch_batch_counter + patch_batch_size]\n shuffled_images, shuffled_masks = randomize(image_patch_batch, mask_patch_batch)\n yield shuffled_images, shuffled_masks","def trainingBatchGenerator(data_folder, image_shape):\n def get_batches_fn(batch_size):\n \"\"\"\n Create batches of training data\n :param batch_size: Batch Size\n :return: Batches of training data\n \"\"\"\n image_paths = glob(os.path.join(data_folder, 'image_2', '*.png'))\n label_paths = {\n re.sub(r'_(lane|road)_', '_', os.path.basename(path)): path\n for path in glob(os.path.join(data_folder, 'gt_image_2', '*_road_*.png'))}\n background_color = np.array([255, 0, 0])\n\n random.shuffle(image_paths)\n for batch_i in range(0, len(image_paths), batch_size):\n images = []\n gt_images = []\n for image_file in image_paths[batch_i:batch_i+batch_size]:\n gt_image_file = label_paths[os.path.basename(image_file)]\n\n image = scipy.misc.imresize(scipy.misc.imread(image_file), image_shape)\n gt_image = scipy.misc.imresize(scipy.misc.imread(gt_image_file), image_shape)\n\n gt_bg = np.all(gt_image == background_color, axis=2)\n gt_bg = gt_bg.reshape(*gt_bg.shape, 1)\n gt_image = np.concatenate((gt_bg, np.invert(gt_bg)), axis=2)\n\n images.append(image)\n gt_images.append(gt_image)\n\n yield np.array(images), np.array(gt_images)\n return get_batches_fn","def generate_images(self, count):\n # Generate images from the currently loaded model\n noise = np.random.normal(0, 1, (count, self.dimensions_noise))\n return self.generator.predict(noise)","def generator(samples, batch_size=32):\n num_samples = len(samples)\n while 1: # Loop forever so the generator never terminates\n sklearn.utils.shuffle(samples)\n for offset in range(0, num_samples, batch_size):\n batch_samples = samples[offset:offset+batch_size]\n images = []\n angles = []\n for batch_sample in batch_samples:\n # append center image\n name = 'Sample_data/IMG/'+batch_sample[0].split('/')[-1]\n center_image = cv2.imread(name)\n center_angle = float(batch_sample[3])\n images.append(center_image)\n angles.append(center_angle)\n correction = 0.30 # shift angle commands\n # append left camera image\n left_angle = center_angle + correction\n lname = 'Sample_data/IMG/'+batch_sample[1].split('/')[-1]\n left_image = cv2.imread(lname)\n images.append(left_image)\n angles.append(left_angle)\n \n # append right camera image\n right_angle = center_angle + correction\n rname = 'Sample_data/IMG/'+batch_sample[1].split('/')[-1]\n right_image = cv2.imread(rname)\n images.append(right_image)\n angles.append(right_angle)\n\n # flip image to augment data\n Nsample = len(angles)\n for i in range(len(angles)):\n images.append(np.fliplr(images[i]))\n angles.append(-angles[i])\n\n # trim image to only see section with road\n X_train = np.array(images)\n y_train = np.array(angles)\n yield sklearn.utils.shuffle(X_train, y_train)","def make_generators():\n \n # All images will be rescaled by 1./255\n train_datagen = ImageDataGenerator(rescale=1./255)\n test_datagen = ImageDataGenerator(rescale=1./255)\n\n \n train_generator = train_datagen.flow_from_directory(\n TRAIN_DATA_PATH,\n target_size= (150, 150),\n batch_size= 20,\n class_mode= 'sparse')\n\n validation_generator = test_datagen.flow_from_directory(\n VAL_DATA_PATH,\n target_size= (150, 150),\n batch_size= 20,\n class_mode= 'sparse')\n\n return train_generator, validation_generator","def generate_examples(gen, truncation=0.7, n=100):\n gen.eval()\n alpha = 1.0\n for i in range(n):\n with torch.no_grad():\n noise = torch.tensor(truncnorm.rvs(-truncation, truncation, size=(1, config.Z_DIM, 1, 1)), device=config.DEVICE, dtype=torch.float32)\n img = gen(noise, alpha, 279)\n save_image(img*0.5+0.5, f\"saved_examples/{i+2000}.jpg\")","def __init__(self, input_nc, output_nc, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, padding_type='zero'):\n super(ResnetGenerator, self).__init__()\n use_bias = True\n\n model = [nn.ReflectionPad2d(3),\n nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0, bias=use_bias),\n norm_layer(ngf),\n nn.ReLU(True)]\n\n n_downsampling = 2\n for i in range(n_downsampling): # add downsampling layers\n mult = 2 ** i\n model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3, stride=2, padding=1, bias=use_bias),\n norm_layer(ngf * mult * 2),\n nn.ReLU(True)]\n\n mult = 2 ** n_downsampling\n for i in range(9): # add ResNet blocks\n\n model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout, use_bias=use_bias)]\n\n for i in range(n_downsampling): # add upsampling layers\n mult = 2 ** (n_downsampling - i)\n model += [nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2),\n kernel_size=3, stride=2,\n padding=1, output_padding=1,\n bias=use_bias),\n norm_layer(int(ngf * mult / 2)),\n nn.ReLU(True)]\n model += [nn.ReflectionPad2d(3)]\n model += [nn.Conv2d(ngf, output_nc, kernel_size=7, padding=0)]\n model += [nn.Tanh()]\n\n self.model = nn.Sequential(*model)","def get_training_examples(self, n: int = None, apply_representations: bool = True):\n pass","def generate(self):\n z_sample = np.random.normal(0, 1,[self.batch_size, self.n_z])\n gen_images = self.sess.run(self.gen_img, feed_dict={self.z: z_sample})\n return gen_images","def build_generator(self):\n\n def _make_divisible(v, divisor, min_value=None):\n if min_value is None:\n min_value = divisor\n new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)\n # Make sure that round down does not go down by more than 10%.\n if new_v < 0.9 * v:\n new_v += divisor\n return new_v\n\n def residual_block(inputs, filters, block_id, expansion=6, stride=1, alpha=1.0):\n \n channel_axis = 1 if tf.keras.backend.image_data_format() == 'channels_first' else -1\n\n in_channels = tf.keras.backend.int_shape(inputs)[channel_axis]\n pointwise_conv_filters = int(filters * alpha)\n pointwise_filters = _make_divisible(pointwise_conv_filters, 8)\n x = inputs\n prefix = 'block_{}_'.format(block_id)\n\n if block_id:\n # Expand\n x = tf.keras.layers.Conv2D(expansion * in_channels,\n kernel_size=1,\n padding='same',\n use_bias=True,\n activation=None,\n name=prefix + 'expand')(x)\n x = tf.keras.layers.BatchNormalization(axis=channel_axis,\n epsilon=1e-3,\n momentum=0.999,\n name=prefix + 'expand_BN')(x)\n x = tf.keras.layers.Activation('relu', name=prefix + 'expand_relu')(x)\n else:\n prefix = 'expanded_conv_'\n\n # Depthwise\n x = tf.keras.layers.DepthwiseConv2D(kernel_size=3,\n strides=stride,\n activation=None,\n use_bias=True,\n padding='same' if stride == 1 else 'valid',\n name=prefix + 'depthwise')(x)\n x = tf.keras.layers.BatchNormalization(axis=channel_axis,\n epsilon=1e-3,\n momentum=0.999,\n name=prefix + 'depthwise_BN')(x)\n\n x = tf.keras.layers.Activation('relu', name=prefix + 'depthwise_relu')(x)\n\n # Project\n x = tf.keras.layers.Conv2D(pointwise_filters,\n kernel_size=1,\n padding='same',\n use_bias=True,\n activation=None,\n name=prefix + 'project')(x)\n x = tf.keras.layers.BatchNormalization(axis=channel_axis,\n epsilon=1e-3,\n momentum=0.999,\n name=prefix + 'project_BN')(x)\n\n if in_channels == pointwise_filters and stride == 1:\n return tf.keras.layers.Add(name=prefix + 'add')([inputs, x])\n return x\n\n def deconv2d(layer_input):\n\n u = tf.keras.layers.UpSampling2D(size=2, interpolation='bilinear')(layer_input)\n u = tf.keras.layers.Conv2D(self.gf, kernel_size=3, strides=1, padding='same')(u)\n u = tf.keras.layers.PReLU(shared_axes=[1, 2])(u)\n return u\n\n # Low resolution image input\n img_lr = tf.keras.Input(shape=self.lr_shape)\n\n # Pre-residual block\n c1 = tf.keras.layers.Conv2D(self.gf, kernel_size=3, strides=1, padding='same')(img_lr)\n c1 = tf.keras.layers.BatchNormalization()(c1)\n c1 = tf.keras.layers.PReLU(shared_axes=[1, 2])(c1)\n\n # Propogate through residual blocks\n r = residual_block(c1, self.gf, 0)\n for idx in range(1, self.n_residual_blocks):\n r = residual_block(r, self.gf, idx)\n\n # Post-residual block\n c2 = tf.keras.layers.Conv2D(self.gf, kernel_size=3, strides=1, padding='same')(r)\n c2 = tf.keras.layers.BatchNormalization()(c2)\n c2 = tf.keras.layers.Add()([c2, c1])\n \n # Upsampling\n u1 = deconv2d(c2)\n u2 = deconv2d(u1)\n\n # Generate high resolution output\n gen_hr = tf.keras.layers.Conv2D(3, kernel_size=3, strides=1, padding='same', activation='tanh')(u2)\n\n return tf.keras.models.Model(img_lr, gen_hr)","def process_train_set(hdf5_file, train_archive, patch_archive, n_train,\n wnid_map, shuffle_seed=None):\n producer = partial(train_set_producer, train_archive=train_archive,\n patch_archive=patch_archive, wnid_map=wnid_map)\n consumer = partial(image_consumer, hdf5_file=hdf5_file,\n num_expected=n_train, shuffle_seed=shuffle_seed)\n producer_consumer(producer, consumer)","def n_random_crop(img, height, width, n):\n crops = []\n img_width, img_height = img.shape\n for i in range(n):\n x = np.random.randint(0, img_width - width)\n y = np.random.randint(0, img_height - height)\n crops.append(img[x:x + height, y:y + width])\n return np.array(crops)","def get_one_shot_batch(self, support_set_size, is_validation):\n\n # Set some variables that will be different for validation and evaluation sets\n if is_validation:\n alphabets = self._validation_alphabets\n current_alphabet_index = self._current_validation_alphabet_index\n image_folder_name = 'images_background'\n dictionary = self.train_dictionary\n else:\n alphabets = self._evaluation_alphabets\n current_alphabet_index = self._current_evaluation_alphabet_index\n image_folder_name = 'images_evaluation'\n dictionary = self.evaluation_dictionary\n\n current_alphabet = alphabets[current_alphabet_index]\n available_characters = list(dictionary[current_alphabet].keys())\n number_of_characters = len(available_characters)\n\n bacth_images_path = []\n\n test_character_index = random.sample(\n range(0, number_of_characters), 1)\n\n # Get test image\n current_character = available_characters[test_character_index[0]]\n\n available_images = (dictionary[current_alphabet])[current_character]\n\n image_indexes = random.sample(range(0, 20), 2)\n image_path = os.path.join(\n self.dataset_path, image_folder_name, current_alphabet, current_character)\n\n test_image = os.path.join(\n image_path, available_images[image_indexes[0]])\n bacth_images_path.append(test_image)\n image = os.path.join(\n image_path, available_images[image_indexes[1]])\n bacth_images_path.append(image)\n\n # Let's get our test image and a pair corresponding to\n if support_set_size == -1:\n number_of_support_characters = number_of_characters\n else:\n number_of_support_characters = support_set_size\n\n different_characters = available_characters[:]\n different_characters.pop(test_character_index[0])\n\n # There may be some alphabets with less than 20 characters\n if number_of_characters < number_of_support_characters:\n number_of_support_characters = number_of_characters\n\n support_characters_indexes = random.sample(\n range(0, number_of_characters - 1), number_of_support_characters - 1)\n\n for index in support_characters_indexes:\n current_character = different_characters[index]\n available_images = (dictionary[current_alphabet])[\n current_character]\n image_path = os.path.join(\n self.dataset_path, image_folder_name, current_alphabet, current_character)\n\n image_indexes = random.sample(range(0, 20), 1)\n image = os.path.join(\n image_path, available_images[image_indexes[0]])\n bacth_images_path.append(test_image)\n bacth_images_path.append(image)\n\n images, labels = self._convert_path_list_to_images_and_labels(\n bacth_images_path, is_one_shot_task=True)\n\n return images, labels","def get_test_and_valid_generator(valid_df, test_df, train_df, image_dir, x_col, y_cols, sample_size=500, batch_size=32,\r\n seed=1, target_w=256, target_h=256):\r\n # print(\"getting train and valid generators...\")\r\n # # get generator to sample dataset\r\n # raw_train_generator = ImageDataGenerator().flow_from_dataframe(\r\n # dataframe=train_df,\r\n # directory=image_dir,\r\n # x_col=x_col,\r\n # y_col=y_cols,\r\n # class_mode=\"raw\",\r\n # batch_size=sample_size,\r\n # color_mode='grayscale',\r\n # shuffle=True,\r\n # target_size=(target_w, target_h))\r\n #\r\n # # get data sample\r\n # batch = raw_train_generator.next()\r\n # data_sample = batch[0]\r\n #\r\n # # use sample to fit mean and std for test set generator\r\n # image_generator = ImageDataGenerator(\r\n # featurewise_center=True,\r\n # featurewise_std_normalization=True)\r\n\r\n # # fit generator to sample from training data\r\n # image_generator.fit(data_sample)\r\n # print('Data Generator mean=%.3f, std=%.3f' % (image_generator.mean, image_generator.std))\r\n\r\n # Add this to output the values to a json file\r\n # print(\"[INFO] serializing means...\")\r\n # D = {\"R\": np.mean(R), \"G\": np.mean(G), \"B\": np.mean(B)}\r\n # f = open(config.DATASET_MEAN, \"w\")\r\n # f.write(json.dumps(D))\r\n # f.close()\r\n\r\n image_generator = ImageDataGenerator(rescale=1.0/255.0)\r\n\r\n # get test generator\r\n valid_generator = image_generator.flow_from_dataframe(\r\n dataframe=valid_df,\r\n directory=image_dir,\r\n x_col=x_col,\r\n y_col=y_cols,\r\n class_mode=\"raw\",\r\n batch_size=batch_size,\r\n shuffle=False,\r\n color_mode='grayscale',\r\n seed=seed,\r\n target_size=(target_w, target_h))\r\n\r\n test_generator = image_generator.flow_from_dataframe(\r\n dataframe=test_df,\r\n directory=image_dir,\r\n x_col=x_col,\r\n y_col=y_cols,\r\n class_mode=\"raw\",\r\n batch_size=6000,\r\n color_mode='grayscale',\r\n shuffle=False,\r\n seed=seed,\r\n target_size=(target_w, target_h))\r\n return valid_generator, test_generator","def representations_sample(self, n=()):\n self.assert_sampled()\n return [\n z.sample(sample_shape=n, seed=self.randint).numpy()\n for z in self.representations\n ]","def run_cropping(self, list_of_files, overwrite_existing=False, output_folder=None):\n if output_folder is not None:\n self.output_folder = output_folder\n\n output_folder_gt = os.path.join(self.output_folder, \"gt_segmentations\")\n maybe_mkdir_p(output_folder_gt)\n for j, case in enumerate(list_of_files):\n if case[-1] is not None:\n shutil.copy(case[-1], output_folder_gt)\n\n list_of_args = []\n for j, case in enumerate(list_of_files):\n case_identifier = get_case_identifier(case)\n list_of_args.append((case, case_identifier, overwrite_existing))\n\n p = Pool(self.num_threads)\n p.starmap(self.load_crop_save, list_of_args)\n p.close()\n p.join()","def gen_test_output(sess, logits, keep_prob, image_pl, data_folder, image_shape, samples_limit=None):\n\n image_paths = glob(os.path.join(data_folder, 'image_2', '*.png'))\n\n if samples_limit:\n image_paths = image_paths[0:samples_limit]\n\n for image_file in tqdm(image_paths, desc='Processing: ', unit='images', total=len(image_paths)):\n yield process_image_file(image_file, sess, logits, keep_prob, image_pl, image_shape)","def next(self):\n\n if self.index - self.batch_size <= 0:\n if not self.repeater:\n raise StopIteration\n else:\n self.index = self.dataset.shape[0] - 1\n self.index = self.index - self.batch_size\n\n # loading features(images)\n features = imread(self.dataset.loc[:, 'image'].iat[0])[:, :, :3]\n\n if self.output_shape is None:\n output_shape = features.shape[:2]\n else:\n output_shape = self.output_shape\n\n # 1) Resize image to match a certain size.\n # 2) Also the input image is converted (from 8-bit integer)\n # to 64-bit floating point(->preserve_range=False).\n # 3) [:, :, :3] -> to remove 4th channel in png\n features = np.array([\n resize(image=imread(self.dataset.loc[:, 'image'].iat[i])[:, :, :3],\n output_shape=output_shape,\n mode='constant',\n preserve_range=False,\n anti_aliasing=True)\n for i in range(self.index, self.index + self.batch_size)\n ])\n\n if self.data_type is 'float32':\n features = img_as_float32(features)\n\n # loading labels(segmentation)\n if 'segmentation' in self.label_type:\n # 1) Resize segmentation to match a certain size.\n # 2) [:, :, :3] -> to remove 4th channel in png\n segmentation = np.array([\n imread(self.dataset.loc[:, 'segmentation'].iat[i])[:, :, :3]\n for i in range(self.index, self.index + self.batch_size)\n ])\n\n # resize(image=,\n # output_shape=output_shape,\n # mode='constant',\n # preserve_range=True,\n # anti_aliasing=True)\n\n # new_segmentation = np.zeros(\n # shape=(self.batch_size, output_shape[0], output_shape[1],\n # len(self.seg_dic)))\n # for i in range(self.batch_size):\n # for j in range(output_shape[0]):\n # for k in range(output_shape[1]):\n # new_segmentation[i, j, k,\n # self.seg_dic[\n # tuple(segmentation[i, j, k]) ][0]] = 1\n # segmentation = new_segmentation\n\n if self.data_type is 'float32':\n segmentation = img_as_float32(segmentation)\n else:\n segmentation = img_as_float64(segmentation)\n\n # if self.label_type == 'depth':\n # labels = np.array(\n # np.array([\n # resize(\n # image=imread(self.dataset.iloc[i, 1]),\n # output_shape=(480, 640))\n # for i in range(self.index, self.index + self.batch_size)\n # ]),\n # dtype=np.int32)\n # labels = (labels[:, :, :, 0] + labels[:, :, :, 1] * 256 +\n # labels[:, :, :, 2] * 256 * 256) / ((256 * 256 * 256) - 1)\n\n # elif self.label_type == 'segmentation':\n # labels = np.array(\n # np.array([\n # resize(\n # image=imread(self.dataset.iloc[i, 2])[:, :, 0],\n # output_shape=(480, 640))\n # for i in range(self.index, self.index + self.batch_size)\n # ]))\n\n # new_segmentation = np.ndarray(shape=(self.batch_size, 480, 640, 22))\n # for i in range(self.batch_size):\n # for j in range(480):\n # for k in range(640):\n # if labels[i, j, k] < 22:\n # new_segmentation[i, j, k, int(labels[i, j, k])] = 1\n # labels = new_segmentation\n # labels = np.array(labels, dtype=np.float32)\n # else:\n # raise ValueError('invalid label type')\n\n # return features, labels\n return features, segmentation","def _get_test_generator(self):\n for data_element in self.test:\n image, heatmap = self._generate_input_tuple(data_element)\n \n yield (image, heatmap)","def image_generator_not_random(list_of_files, crop_size=320, scale=1):\n while True:\n text_region = []\n for jpgname in list_of_files:\n print jpgname\n # jpgname = np.random.choice(list_of_files)\n img = cv2.imread(jpgname)\n pattern = re.compile('jpg')\n txtname = pattern.sub('txt', jpgname)\n if not os.path.isfile(txtname):\n continue\n cropped_image = img\n with open(txtname, 'r') as f:\n for line in f:\n line_split = line.strip().split(',')\n print line_split\n # clockwise\n (x1, y1, x2, y2) = line_split[0:4]\n (x3, y3, x4, y4) = line_split[4:8]\n text_region.append([string.atof(x1), string.atof(y1), string.atof(x2), string.atof(y2),\n string.atof(x3), string.atof(y3), string.atof(x4), string.atof(y4)])\n if cropped_image is None or text_region is None or \\\n cropped_image.shape[0] != crop_size or cropped_image.shape[1] != crop_size:\n continue\n yield [scale * cropped_image, text_region]","def cropNwriteBBs(img, digitCnts,writeToFile=False,folderName='outcome',cropW=20,cropH=30):\r\n d = 0\r\n for contour in digitCnts:\r\n # https://stackoverflow.com/questions/50331025/how-to-crop-a-bounding-box-out-of-an-image\r\n (x, y, w, h) = cv2.boundingRect(contour)\r\n\r\n ext_left = tuple(contour[contour[:, :, 0].argmin()][0])\r\n ext_right = tuple(contour[contour[:, :, 0].argmax()][0])\r\n ext_top = tuple(contour[contour[:, :, 1].argmin()][0])\r\n ext_bot = tuple(contour[contour[:, :, 1].argmax()][0])\r\n\r\n img1 = img.copy()\r\n img2 = img.copy()\r\n cv2.rectangle(img1, (x, y), (x + w, y + h), (0, 255, 0), 2)\r\n\r\n cropped_image = img2[ext_top[1]:ext_bot[1], ext_left[0]:ext_right[0]]\r\n cropped_image = cv2.resize(cropped_image, (cropW, cropH))\r\n filename = os.path.join(os.path.join(BASE_PATH,folderName),'output_%d'%d+'.jpg')\r\n d += 1\r\n if writeToFile:\r\n cv2.imwrite(filename, cropped_image)\r\n cv2.waitKey(0)\r\n yield cropped_image,(x,y,w,h),contour","def _yield_training_validation(self, batch_index):\n # print(f'requested batch with index: {batch_index}') # DEBUG\n num_identities = len(self.identities)\n num_ids_to_resample = 0\n # manage identities in a circular way \n ids_start = (batch_index*self.batch_size)%num_identities # identities' batch start\n ids_end = ((batch_index+1)*self.batch_size)%num_identities # identities' batch end\n # Manage the indetities array in a circular manner\n #batch_identities = self.identities[ids_start:ids_end] if ids_start < ids_end else self.identities[ids_start:].append(self.identities[:ids_end])\n if ids_start < ids_end:\n batch_identities = self.identities[ids_start:ids_end]\n else:\n batch_identities = self.identities[ids_start:]\n batch_identities.extend(self.identities[:ids_end])\n samples_batch = []\n labels_batch = []\n roi_batch = []\n for identity in batch_identities:\n identity_data = self.groundtruth_metadata[identity]\n # if there are images available for that identity\n if identity_data['index'] < len(identity_data['metadata']):\n # read the image and the necessary metadata\n img_info = identity_data['metadata'][identity_data['index']]\n img_path = os.path.join(self.dataset_root_path, img_info['path'])\n img = cv2.imread(img_path) # watch out for slashes (/)\n # if OpenCV is unable to read an image, it returns None\n if img is None:\n print('[DATA LOADER ERROR] cannot find image at path: ', img_path)\n # increase the index, in order to avoid this path when building subsequent batches with this identity\n identity_data['index'] += 1\n # sample another image from another identity to replace this one in the batch\n num_ids_to_resample += 1\n continue\n #batch.append(AgeEstimationSample(img, img_info['roi'], img_info['age'], 'BGR')) # cv2 reads as BGR\n img = img.astype('float32')\n samples_batch.append(img)\n labels_batch.append(img_info['age'])\n roi_batch.append(img_info['roi'])\n # increase the index, because another sample for that identity has been used\n identity_data['index'] += 1\n else:\n num_ids_to_resample += 1\n\n # if for some identities there weren't available images, take them from other identities\n # note that this mechanism solves also the problems arising when less than batch_size identities are available, by\n # picking multiple images from the available entities\n # the __len__ method in the data generator associated to this data loader is responsible for avoiding that this\n # method is called when less than batch_size \"fresh\" images are available\n last_taken_identity_index = ids_end \n num_samples_when_last_taken = num_ids_to_resample\n while(num_ids_to_resample > 0):\n identity = self.identities[ids_end] # remeber that slicing at previous step excludes upper limit\n identity_data = self.groundtruth_metadata[identity]\n if identity_data['index'] < len(identity_data['metadata']):\n last_taken_identity_index = ids_end\n num_samples_when_last_taken = num_ids_to_resample\n # read the image and the necessary metadata\n img_info = identity_data['metadata'][identity_data['index']]\n img_path = os.path.join(self.dataset_root_path, img_info['path'])\n img = cv2.imread(img_path) # watch out for slashes (/)\n # if the path does not exist or there are problems while reading the image\n if img is None:\n print('[DATA LOADER ERROR] cannot find image at path: ', img_path)\n # increase the index, in order to avoid this path when building subsequent batches with this identity\n identity_data['index'] += 1\n continue\n #batch.append(AgeEstimationSample(img, img_info['roi'], img_info['age'], 'BGR')) # cv2 reads as BGR\n img = img.astype('float32')\n samples_batch.append(img)\n labels_batch.append(img_info['age'])\n roi_batch.append(img_info['roi'])\n\n num_ids_to_resample -= 1\n identity_data['index'] += 1\n \n ids_end = ((ids_end+1)%num_identities)\n if ids_end == last_taken_identity_index and num_ids_to_resample == num_samples_when_last_taken and identity_data['index'] == len(identity_data['metadata']):\n raise Exception(f'No more images available, missing {num_ids_to_resample} images!')\n\n # cannot return numpy arrays since images in batch have different sizes\n return samples_batch, labels_batch, roi_batch\n #return batch","def generate_batch(self, batch_size=8, shuffle=True):\n if self._contour_dicom_folder:\n contour_files = glob(os.path.join(self._contour_dicom_folder, \"*.h5\"))\n if shuffle:\n contour_files = np.random.permutation(contour_files)\n contours_generator = self._contour_folder_gen(contour_files)\n else:\n contours_generator = self._contour_dicom_generator\n\n x_batch, y_batch, sources_batch = [], [], []\n batch_idx = 0\n for idx, (dataset, sources) in enumerate(contours_generator):\n if batch_idx > 0 and batch_idx % batch_size == 0:\n if self._include_sources:\n yield sources_batch, np.array(x_batch), np.array(y_batch)\n else:\n yield np.array(x_batch), np.array(y_batch)\n x_batch, y_batch, sources_batch = [], [], []\n batch_idx = 0\n try:\n x_data = self._parse_channels(dataset, self.x_channels)\n y_data = self._parse_channels(dataset, self.y_channels)\n x_batch.append(x_data)\n y_batch.append(y_data)\n sources_batch.append(sources)\n batch_idx += 1\n except ValueError:\n # Log Error\n err_msg = \"Missing all channels in {}\".format(sources[\"filename\"])\n self._log_error(err_msg)\n\n if self._include_sources:\n yield sources_batch, np.array(x_batch), np.array(y_batch)\n else:\n yield np.array(x_batch), np.array(y_batch)","def generate(batch, size=32):\n\n # Using the data Augmentation in traning data\n ptrain = 'data224/train'\n pval = 'data224/test'\n\n datagen1 = ImageDataGenerator(\n samplewise_center=True,\n samplewise_std_normalization=True,\n shear_range=0.2,\n zoom_range=0.2,\n rotation_range=90,\n width_shift_range=0.2,\n height_shift_range=0.2,\n horizontal_flip=True)\n\n datagen2 = ImageDataGenerator(samplewise_center=True,\n samplewise_std_normalization=True,)\n\n train_generator = datagen1.flow_from_directory(\n ptrain,\n target_size=(size, size),\n batch_size=batch,\n class_mode='categorical')\n\n validation_generator = datagen2.flow_from_directory(\n pval,\n target_size=(size, size),\n batch_size=batch,\n class_mode='categorical')\n\n count1 = 0\n for root, dirs, files in os.walk(ptrain):\n for each in files:\n count1 += 1\n\n count2 = 0\n for root, dirs, files in os.walk(pval):\n for each in files:\n count2 += 1\n\n return train_generator, validation_generator, count1, count2","def train_cupy(n, training_data_list, onodes=10, epochs=5):\n\n print(\"Training...\")\n\n # epochs is the number of times the training data set is used for training\n epochs = 5\n\n for e in range(epochs):\n print(\"Epoch:\", e)\n # go through all records in the training data set\n for record in training_data_list:\n # split the tecord by the ',' commas\n all_values = record.split(',')\n temp = list(map(eval, all_values[1:]))\n # scale and shift the inputs\n inputs = (cupy.asarray(temp) / 255 * 0.99) + 0.01\n # create the target output values (all 0.01, except the desired lavel which is 0.99)\n targets = cupy.zeros(onodes) + 0.01\n # all_values[0] is the target lavel for this record\n targets[int(all_values[0])] = 0.99\n n.train(inputs, targets)\n\n # create rotated variations\n # rotated anticlockwise by x degrees\n inputs_plusx_img = cupyx.scipy.ndimage.interpolation.rotate(\n inputs.reshape(28, 28), 10, cval=0.01, order=1, reshape=False)\n n.train(inputs_plusx_img.reshape(784), targets)\n # rotated clockwise by x degrees\n inputs_minusx_img = cupyx.scipy.ndimage.interpolation.rotate(\n inputs.reshape(28, 28), -10, cval=0.01, order=1, reshape=False)\n n.train(inputs_minusx_img.reshape(784), targets)\n\n return n","def flow(self, batch_size=32):\n nb_batches = int(len(self.image_ids_in_subset) / batch_size) + 1\n while True:\n # Before each epoch we shuffle the images' ids\n random.shuffle(self.image_ids_in_subset)\n\n for i in range(nb_batches):\n # We first get all the image ids for the next batch\n current_bach = self.image_ids_in_subset[i*batch_size:(i+1)*batch_size]\n X_batch = []\n Y_batch = []\n\n for image_id in current_bach:\n # Load the image and resize it. We get a PIL Image object\n img = image.load_img(self.get_img_path(int(image_id)), grayscale=False, target_size=(cfg.IMAGE.IMG_SIZE, cfg.IMAGE.IMG_SIZE))\n # Cast the Image object to a numpy array and put the channel has the last dimension\n img_arr = image.img_to_array(img, data_format='channels_last')\n X_batch.append(img_arr)\n # Y_batch.append(self.id_to_label[image_id])\n Y_batch.append(self.get_labels(image_id))\n\n # resize X_batch in (batch_size, IMG_HEIGHT, IMG_WIDTH, 3)\n X_batch = np.reshape(X_batch, (-1, cfg.IMAGE.IMG_SIZE, cfg.IMAGE.IMG_SIZE, 3))\n # resize Y_batch in (None, nb_classes)\n Y_batch = np.reshape(Y_batch, (-1, self.nb_classes))\n\n # substract mean values from imagenet\n X_batch = preprocess_input(X_batch, data_format='channels_last')\n yield(X_batch, Y_batch)","def trainingset(self, batchsize=None, flatten=True):\n if batchsize is None:\n batchsize = self.batchsize\n\n if self.x_train is None:\n raise AttributeError('No fold initialized... Try calling next_leaveout')\n\n return self.GENERATOR(self.x_train, self.y_train, batchsize, flatten=flatten, evaluate=False)","def as_generator(self, shuffle=False, n_workers=0):\n\n data_loader = DataLoader(\n dataset=self, shuffle=shuffle, num_workers=n_workers\n )\n for sample in cycle(data_loader):\n sample_batch_dim_removed = {}\n for key, val in sample.items():\n sample_batch_dim_removed[key] = val[0]\n yield sample_batch_dim_removed","def clarifruit_train_val_generators(self, aug_flag=True):\n\n aug_dict = self.data_gen_args if aug_flag else None\n\n image_train_generator, image_val_generator = self.train_val_generators(\n batch_size=self.batch_size,\n src_path=self.train_path,\n folder=self.x_folder_name,\n input_aug_dict=aug_dict,\n color_mode=self.color_mode,\n save_prefix=self.x_folder_name,\n save_to_dir=self.save_to_dir,\n target_size=self.target_size,\n seed=self.seed,\n validation_split=self.validation_split)\n\n mask_train_generator, mask_val_generator = self.train_val_generators(\n batch_size=self.batch_size,\n src_path=self.train_path,\n folder=self.y_folder_name,\n input_aug_dict=aug_dict,\n color_mode='grayscale',\n save_prefix=self.y_folder_name,\n save_to_dir=self.save_to_dir,\n target_size=self.target_size,\n seed=self.seed,\n validation_split=self.validation_split)\n\n train_generator = zip(image_train_generator, mask_train_generator)\n val_generator = zip(image_val_generator, mask_val_generator)\n\n return train_generator, val_generator","def _automatic_training_set(self, n_cutouts=100):\n dstl = Load_DSTL()\n np.random.seed(42)\n for ii in range(n_cutouts):\n # Get region around a shape\n triples, mask, ind_shape, img_dim = dstl.extract_region(object_class=self.class_type, image_id='6120_2_2', buffer_size=10)\n if self.radius is not None:\n triples, mask = self._sliding_window(triples.reshape(*img_dim, 3), mask.reshape(img_dim), window_radius=self.radius)\n # Add to Feature Matrix\n if ii == 0:\n features = triples\n labels = mask\n else:\n features = np.vstack([features, triples])\n labels = np.hstack([labels, mask])\n return features, labels","def my_generator(batch_size, img_dir):\n cat_dirs = glob.glob(img_dir + \"/*\")\n counter = 0\n while True:\n input_images = np.zeros(\n (batch_size, config.height, config.width, 3 * 5))\n output_images = np.zeros((batch_size, config.height, config.width, 3))\n random.shuffle(cat_dirs)\n if (counter+batch_size >= len(cat_dirs)):\n counter = 0\n for i in range(batch_size):\n input_imgs = glob.glob(cat_dirs[counter + i] + \"/cat_[0-4]*\") \n imgs = [Image.open(img) for img in sorted(input_imgs)]\n input_images[i] = np.concatenate(imgs, axis=2)\n output_imgs = glob.glob(cat_dirs[counter + i] + \"/cat_[5-7]*\")\n imgs = [Image.open(img) for img in sorted(output_imgs)]\n output_images[i] = np.concatenate(imgs, axis=1)\n input_images[i] /= 255.\n output_images[i] /= 255.\n yield (input_images, output_images)\n counter += batch_size","def generate(self, batch_size=None):\n nb = self.batch_size\n if batch_size is not None:\n nb = batch_size\n with tf.compat.v1.Session() as sess:\n self.saver.restore(sess, \"data/\" + self.name + \".ckpt\")\n return self.X_fake.eval(feed_dict={self.z: self.noise(nb, self.z_dim), self.is_training: False})","def test_generator(self, test_path):\n\n img_list = os.scandir(test_path)\n for img_entry in img_list:\n\n img = cv2.imread(img_entry.path, COLOR_TO_OPENCV[self.color_mode])\n if img.shape[-1] == 3:\n orig_shape = img.shape[-2::-1]\n else:\n orig_shape = img.shape[::-1]\n\n\n img = cv2.resize(img, tuple(self.target_size))\n img = img / 255\n if self.color_mode == \"grayscale\":\n img = np.reshape(img, img.shape + (1,))\n img = np.reshape(img, (1,) + img.shape)\n yield img, img_entry, orig_shape","def batch_generator(batch_size):\n\n # Infinite loop.\n while True:\n # Get a list of random indices for images in the training-set.\n idx = np.random.randint(100,size=batch_size)\n \n # Get the pre-computed transfer-values for those images.\n # These are the outputs of the pre-trained image-model.\n transf_values = np.array([transfer_values[_] for _ in idx])\n\n # For each of the randomly chosen images there are\n # at least 5 captions describing the contents of the image.\n # Select one of those captions at random and get the\n # associated sequence of integer-tokens.\n tokens = [caps_markedwords[_] for _ in idx]\n\n # Count the number of tokens in all these token-sequences.\n num_tokens = [len(t) for t in tokens]\n \n # Max number of tokens.\n max_tokens = np.max(num_tokens)\n # Pad all the other token-sequences with zeros\n # so they all have the same length and can be\n # input to the neural network as a numpy array.\n tokens_padded = pad_sequences(tokens,\n maxlen=max_tokens,\n padding='post',\n truncating='post')\n \n # Further prepare the token-sequences.\n # The decoder-part of the neural network\n # will try to map the token-sequences to\n # themselves shifted one time-step.\n decoder_input_data = tokens_padded[:, 0:-1]\n decoder_output_data = tokens_padded[:, 1:]\n\n # Dict for the input-data. Because we have\n # several inputs, we use a named dict to\n # ensure that the data is assigned correctly.\n x_data = \\\n {\n 'decoder_input': decoder_input_data,\n 'transfer_values_input': transf_values\n }\n\n\n # Dict for the output-data.\n y_data = \\\n {\n 'decoder_output': decoder_output_data\n }\n \n yield (x_data, y_data)","def training_data_generation(DATA_DIR, img_height_size, img_width_size, label_list):\r\n \r\n img_ms_files = glob.glob(DATA_DIR + '\\\\Train_MS' + '\\\\Train_*.tif')\r\n img_pan_files = glob.glob(DATA_DIR + '\\\\Train_Pan' + '\\\\Train_*.tif')\r\n polygon_files = glob.glob(DATA_DIR + '\\\\Train_Polygons' + '\\\\Train_*.geojson')\r\n \r\n img_ms_array_list = []\r\n img_pan_array_list = []\r\n mask_array_list = []\r\n \r\n for file in range(len(img_ms_files)):\r\n with rasterio.open(img_ms_files[file]) as f:\r\n metadata = f.profile\r\n img_ms = np.transpose(f.read(tuple(np.arange(metadata['count']) + 1)), [1, 2, 0])\r\n \r\n with rasterio.open(img_pan_files[file]) as g:\r\n metadata_pan = g.profile\r\n img_pan = np.expand_dims(g.read(1), axis = 2)\r\n \r\n ms_to_pan_ratio = metadata['transform'][0] / metadata_pan['transform'][0]\r\n \r\n if (img_height_size % ms_to_pan_ratio) != 0 or (img_width_size % ms_to_pan_ratio) != 0:\r\n raise ValueError('Please make sure that both img_height_size and img_width_size can be divided by {}'.format(int(ms_to_pan_ratio)))\r\n \r\n mask = training_mask_generation(img_pan_files[file], polygon_files[file], labels = label_list)\r\n \r\n img_ms_array, img_pan_array, mask_array = image_clip_to_segment_and_convert(img_ms, img_pan, mask, ms_to_pan_ratio, \r\n img_height_size, img_width_size)\r\n \r\n img_ms_array_list.append(img_ms_array)\r\n img_pan_array_list.append(img_pan_array)\r\n mask_array_list.append(mask_array)\r\n \r\n img_ms_full_array = np.concatenate(img_ms_array_list, axis = 0)\r\n img_pan_full_array = np.concatenate(img_pan_array_list, axis = 0)\r\n mask_full_array = to_categorical(np.concatenate(mask_array_list, axis = 0), num_classes = len(label_list))\r\n \r\n return img_ms_full_array, img_pan_full_array, mask_full_array","def generator(numbers, number_labels, batch_size=32):\n while True: # Loop forever so the generator never terminates\n\n images = []\n labels = []\n\n for batch_sample in range(batch_size):\n img, label = create_numbers(numbers, number_labels, return_label=True)\n\n # Here we will convert the label to a format that Keras API can process:\n n_label = np.zeros((5, 11), dtype='int')\n for i, digit in enumerate(label):\n if digit == \".\":\n n_digit = 10\n else:\n n_digit = int(digit)\n\n n_label[i][n_digit] = 1\n\n images.append(img)\n # labels.append(label)\n labels.append(n_label)\n\n X_train = np.array(images)\n if len(X_train.shape) == 3:\n X_train = np.expand_dims(X_train, -1)\n\n y_temp = np.array(labels)\n\n y1 = y_temp[:, 0, :]\n y2 = y_temp[:, 1, :]\n y3 = y_temp[:, 2, :]\n y4 = y_temp[:, 3, :]\n y5 = y_temp[:, 4, :]\n\n yield X_train, [y1, y2, y3, y4, y5]","def visualize_network_samples(net,\n outputs_per_example=5,\n color_map=\"gray\",\n setsize=[1, 6],\n f_ext=\"pdf\"):\n n_examples = net.batch_size\n if net.name == \"cifar\":\n inputs, targets = generate_training_data(\n None,\n None,\n dataset=net.dataset,\n train_test=\"test\",\n conv=True,\n data_dir=net.trainingset_dir)[0:2]\n inputs, targets = net.get_batch(inputs, targets, None)[0:2]\n sig = True # For predicting decisions\n elif net.name == \"fruits\":\n inputs, recall_targets = net.generate_batch(\"test\")\n targets = inputs\n sig = True\n elif net.name == \"popout\":\n inputs, recall_targets = net.generate_training_data(n_examples)\n targets = inputs\n sig = False\n else:\n inputs = generate_training_data(\n n_examples,\n net.image_width,\n task_weights=net.task_weights,\n dataset=net.dataset,\n conv=net.layer_type == \"conv\",\n data_dir=net.trainingset_dir,\n setsize=setsize,\n mean=net.input_mean,\n std=net.input_std,\n dim=net.input_distribution_dim)[0]\n targets = inputs\n sig = False\n if net.image_channels > 1:\n shp = [net.image_width, net.image_width, net.image_channels]\n else:\n shp = [net.image_width, net.image_width]\n preds0, dec0 = zip(*[\n net.predict_both(\n inputs, np.zeros_like(inputs), sigmoid=sig, keep_session=True)\n for i in range(outputs_per_example)\n ])\n preds1 = np.array(preds0)\n preds2 = preds1.swapaxes(0, 1)\n preds = preds2.reshape([n_examples, outputs_per_example] + shp)\n preds = preds.clip(0, 1)\n # dec = np.array(dec0).swapaxes(0, 1)\n # print(\"decisions: \", dec)\n # print(dec)\n save_dir = make_memnet_checkpoint_dir(\n Path(\"plots/vis_memnet_samples/\"), net)\n if not save_dir.exists():\n save_dir.makedirs()\n print(\"Saving images to: \", save_dir)\n for i in range(n_examples):\n fig, axes = plt.subplots(\n nrows=1, ncols=outputs_per_example + 1, figsize=(45, 10))\n if net.RGB:\n axes[0].imshow(targets[i], cmap=color_map)\n else:\n axes[0].imshow(\n targets[i].reshape(net.image_width, net.image_width),\n cmap=color_map)\n [\n axes[j + 1].imshow(preds[i][j], cmap=color_map)\n for j in range(outputs_per_example)\n ]\n [ax.set_aspect('equal') for ax in axes]\n xlabs = [\"Target\"] + [\n \"Sample {}\".format(j) for j in range(1, outputs_per_example + 1)\n ]\n [ax.set_xlabel(l, size=50) for ax, l in zip(axes, xlabs)]\n for ax in axes:\n ax.set_xticks([])\n ax.set_xticklabels(\"\")\n ax.set_yticks([])\n ax.set_yticklabels(\"\")\n plt.tight_layout()\n plt.savefig(\n save_dir.joinpath('setsize_{}_sample{}.{}'.format(\n \"_\".join([str(x) for x in setsize]),\n str(i).zfill(2), f_ext)))","def _make_batches(self, n_batches: int) -> Iterable[Dict[Any, Any]]:\n batch_iters = []\n for problem in self.problems:\n service = problem.problem_service\n it = service.batch_iter(self.batch_size_per_problem, n_batches)\n batch_iters.append(it)\n combined = zip(*batch_iters)\n # yield a complete feed dict\n for combined_batch in combined:\n assert len(combined_batch) == len(self.problems)\n yield_val = {}\n for problem, batch in zip(self.problems, combined_batch):\n ph_obs_var, ph_q_values = self.obs_qv_inputs[problem.name]\n obs_tensor, qv_tensor = to_local(batch)\n yield_val[ph_obs_var] = obs_tensor\n yield_val[ph_q_values] = qv_tensor\n yield yield_val","def reconstruct_missing(self, \n num_iters, \n recon_images, \n which_pixels):\n \n N = recon_images.shape[0]\n \n if self.num_hidden == 0:\n \n tE = -self.compute_energy(self.x, 1)\n \n elif self.num_hidden > 0:\n \n tE = -self.compute_free_energy(self.x)\n \n do_computation = theano.function(inputs =[self.x], outputs = tE)\n \n for xi in range(N):\n \n print(\"Reconstructing test image --- %d\"%xi)\n \n for iter_ind in range(num_iters):\n \n permuted_nodes = list(np.random.permutation(self.num_vars))\n \n for d in permuted_nodes:\n \n if which_pixels[xi,d]:\n \n recon_images[xi, d] = 1\n \n E1 = do_computation([recon_images[xi, :]])\n \n recon_images[xi, d] = 0\n \n E0 = do_computation([recon_images[xi, :]])\n \n if E1>E0:\n recon_images[xi, d] = 1\n else:\n recon_images[xi, d] = 0","def testGenerator(self,):\n return tf.data.Dataset.from_generator(self.testData, \\\n output_types=(tf.float32, tf.float32, tf.float32), \\\n output_shapes=(tf.TensorShape(self.config_model[\"input_shape\"]), \\\n tf.TensorShape(list(self.headoutput_shape[1:4]) + \\\n [len(self.anchor_boxes), \\\n 7+len(self.config_data[\"all_classes\"])]), \\\n tf.TensorShape([self.config_data[\"max_boxes_per_frame\"], 7]) \\\n ), )","def _generate_validation_fold(self):\n\n for offset in range(self.nb_folds):\n # Load all the data from cache (do this to save memory)\n with open(self.data_cache_path_str + \"data_cache.pkl\", \"rb\") as f:\n data_df, target_df = pickle.load(f)\n\n # Generate train and test sets\n data_dates_lst = data_df[\"date\"].drop_duplicates().sort_values().tolist()\n train_start_day = len(data_dates_lst) - ((self.nb_folds - offset) * self.test_nb_days + self.train_nb_days)\n train_end_day = train_start_day + self.train_nb_days\n test_start_day = train_end_day\n test_end_day = test_start_day + self.test_nb_days\n\n train_dates_lst = data_dates_lst[train_start_day:train_end_day]\n test_dates_lst = data_dates_lst[test_start_day:test_end_day]\n\n # Generate train and test labels\n training_set_df = data_df.loc[data_df[\"date\"].isin(train_dates_lst)].reset_index(drop = True)\n testing_set_df = data_df.loc[data_df[\"date\"].isin(test_dates_lst)].reset_index(drop = True)\n new_target_df = target_df.loc[data_df[\"date\"].isin(train_dates_lst)].reset_index(drop = True)\n truth_df = target_df.loc[data_df[\"date\"].isin(test_dates_lst)].reset_index(drop = True)\n\n # Reduce memory usage\n del data_df, target_df\n gc.collect()\n\n # Return result\n yield (training_set_df, testing_set_df, new_target_df, truth_df)","def custom_data_generator(img_paths, final_height, final_width):\n for img_path in img_paths:\n image = Image.open(img_path)\n resized_image = image.resize((final_width, final_height), Image.ANTIALIAS) # Image.LANCZOS\n img = np.array(resized_image)\n img = tf.image.convert_image_dtype(img, tf.float32)\n yield img, tf.constant([[]], dtype=tf.float32), tf.constant([], dtype=tf.int32)","def get_batches_fn(batch_size):\n id_road = 7\n id_lane = 6\n id_car = 10\n\n for batch_i in range(0, len(image_paths), batch_size):\n images = []\n gt_images = []\n for image_file in image_paths[batch_i:batch_i + batch_size]:\n # Get corresponding label img path\n gt_image_file = image_file.replace('CameraRGB', 'CameraSeg')\n # Read rgb and label images\n img_in = scipy.misc.imread(image_file, mode='RGB')\n gt_in = scipy.misc.imread(gt_image_file)\n # Crop sky part of the image\n image = img_in[-out_shape[0]:, :]\n gt_image = gt_in[-out_shape[0]:, :, 0]\n # Obtain labels\n gt_road = ((gt_image == id_road) | (gt_image == id_lane))\n gt_car = (gt_image == id_car)\n gt_car[-105:, :] = False\n gt_bg = np.invert(gt_car | gt_road)\n # Augmentation\n if bool(random.getrandbits(1)):\n image, gt_bg, gt_car, gt_road = flip_img(\n image, gt_bg, gt_car, gt_road)\n\n gt_bg = gt_bg.reshape(*gt_bg.shape, 1)\n gt_car = gt_car.reshape(*gt_car.shape, 1)\n gt_road = gt_road.reshape(*gt_road.shape, 1)\n\n gt_image = np.concatenate((gt_bg, gt_car, gt_road), axis=2)\n\n images.append(image)\n gt_images.append(gt_image)\n\n yield np.array(images), np.array(gt_images)","def __call__(self, batch_size=20, shuffle=True, augment=True):\r\n\r\n if batch_size < 1:\r\n raise ValueError(\"batch_size must be more than 1.\")\r\n if shuffle:\r\n self.shuffle()\r\n\r\n for start in range(0, self.length, batch_size):\r\n batch = self.perm(start, start+batch_size)\r\n if augment:\r\n assert self._augmenter is not None, \"you have to set an augmenter.\"\r\n yield self._augmenter.augment_dataset(batch, method=[ia.ImageAugmenter.NONE, ia.ImageAugmenter.FLIP])\r\n else:\r\n yield batch","def rslices(n, allow_empty=False):\n for _ in range(5):\n yield rslice(n, allow_empty)","def rslices(n, allow_empty=False):\n for _ in range(5):\n yield rslice(n, allow_empty)","def get_batch_gen(self, split, config):\n config.augment_scale_anisotropic = True\n config.augment_scale_min = 0.9\n config.augment_scale_max = 1.1\n config.augment_noise = 0.001\n config.augment_color = 1.0\n config.augment_rotation = 'vertical'\n\n if split == 'training':\n config.augment_symmetries = [True, False, False]\n else:\n config.augment_symmetries = [False, False, False]\n\n if split == 'training':\n epoch_n = config.epoch_steps * config.batch_size\n elif split == 'validation':\n epoch_n = config.validation_size * config.batch_size\n elif split == 'test':\n epoch_n = config.validation_size * config.batch_size\n else:\n raise ValueError('Split argument in data generator should be \"training\", \"validation\" or \"test\"')\n\n # Initiate potentials for regular generation\n if not hasattr(self, 'potentials'):\n self.potentials = {}\n self.min_potentials = {}\n\n data_split = split\n\n # Reset potentials\n def reset_potentials():\n self.potentials[split] = []\n self.min_potentials[split] = []\n\n for i, tree in enumerate(self.input_trees[data_split]):\n self.potentials[split] += [np.random.rand(tree.data.shape[0]) * 1e-3]\n self.min_potentials[split] += [float(np.min(self.potentials[split][-1]))]\n\n reset_potentials()\n\n def spatially_regular_gen():\n for i in range(epoch_n):\n cloud_ind = int(np.argmin(self.min_potentials[split]))\n point_ind = np.argmin(self.potentials[split][cloud_ind])\n points = np.array(self.input_trees[data_split][cloud_ind].data, copy=False)\n center_point = points[point_ind, :].reshape(1, -1)\n noise = np.random.normal(scale=0.35, size=center_point.shape)\n pick_point = center_point + noise.astype(center_point.dtype)\n\n if config.in_radius > 0:\n input_inds = self.input_trees[split][cloud_ind].query_radius(pick_point, r=config.in_radius)[0]\n else:\n buffer = self.buffer+np.random.randint(0,self.buffer//4)\n if len(points) < self.npoint+buffer:\n input_inds = self.input_trees[split][cloud_ind].query(pick_point, k=len(points))[1][0]\n else:\n input_inds = self.input_trees[split][cloud_ind].query(pick_point, k=self.npoint+buffer)[1][0]\n\n input_inds = self.shuffle_idx(input_inds)\n input_inds = input_inds[:self.npoint]\n\n # Number collected\n n = input_inds.shape[0]\n if n == 0:\n # Reset potentials\n reset_potentials()\n return\n # Safe check for very dense areas\n\n # Update potentials\n dists = np.sum(np.square((points[input_inds] - pick_point).astype(np.float32)), axis=1)\n delta = np.square(1 - dists / np.max(dists))\n self.potentials[split][cloud_ind][input_inds] += delta\n self.min_potentials[split][cloud_ind] = float(np.min(self.potentials[split][cloud_ind]))\n n = input_inds.shape[0]\n\n # Collect points and colors\n input_points = (points[input_inds] - pick_point).astype(np.float32)\n input_colors = self.input_colors[data_split][cloud_ind][input_inds]\n\n if split == 'test':\n input_labels = np.zeros(input_points.shape[0])\n else:\n input_labels = self.input_labels[data_split][cloud_ind][input_inds]\n input_labels = np.array([self.label_to_idx[l] for l in input_labels])\n\n if split in ['test', 'validation']:\n label_weights = np.zeros(input_points.shape[0])\n else:\n label_weights = self.label_weights[input_labels]\n\n if len(input_inds) < self.npoint:\n input_points, input_colors, input_inds, label_weights, input_labels = \\\n self.data_rep(input_points, input_colors, input_labels, input_inds, label_weights, self.npoint)\n\n # Add yield data\n if n > 0:\n yield input_points, np.hstack((input_colors, input_points + pick_point)), input_labels, \\\n [input_points.shape[0]], input_inds, cloud_ind, label_weights\n\n # Define the generator that should be used for this split\n gen_func = spatially_regular_gen\n\n # Define generated types and shapes\n gen_types = (tf.float32, tf.float32, tf.int32, tf.int32, tf.int32, tf.int32, tf.float32)\n gen_shapes = ([self.npoint, 3], [self.npoint, 6], [self.npoint], [1], [self.npoint], [], [self.npoint])\n\n return gen_func, gen_types, gen_shapes","def get_test_and_valid_generator(valid_df, test_df, train_df, image_dir, x_col, y_cols, sample_size=100, batch_size=8, seed=1, target_w = 320, target_h = 320):\n print(\"getting train and valid generators...\")\n # get generator to sample dataset\n raw_train_generator = ImageDataGenerator().flow_from_dataframe(\n dataframe=train_df, \n directory=IMAGE_DIR, \n x_col=\"Image\", \n y_col=labels, \n class_mode=\"raw\", \n batch_size=sample_size, \n shuffle=True, \n target_size=(target_w, target_h))\n \n # get data sample\n batch = raw_train_generator.next()\n data_sample = batch[0]\n\n # use sample to fit mean and std for test set generator\n image_generator = ImageDataGenerator(\n featurewise_center=True,\n featurewise_std_normalization= True)\n \n # fit generator to sample from training data\n image_generator.fit(data_sample)\n\n # get test generator\n valid_generator = image_generator.flow_from_dataframe(\n dataframe=valid_df,\n directory=image_dir,\n x_col=x_col,\n y_col=y_cols,\n class_mode=\"raw\",\n batch_size=batch_size,\n shuffle=False,\n seed=seed,\n target_size=(target_w,target_h))\n\n test_generator = image_generator.flow_from_dataframe(\n dataframe=test_df,\n directory=image_dir,\n x_col=x_col,\n y_col=y_cols,\n class_mode=\"raw\",\n batch_size=batch_size,\n shuffle=False,\n seed=seed,\n target_size=(target_w,target_h))\n return valid_generator, test_generator","def get_test_and_valid_generator(valid_df, test_df, train_df, image_dir, x_col, y_cols, sample_size=100, batch_size=32, seed=1, target_w = 320, target_h = 320):\n print(\"getting train and valid generators...\")\n # get generator to sample dataset\n raw_train_generator = ImageDataGenerator().flow_from_dataframe(\n dataframe=train_df, \n directory=IMAGE_DIR, \n x_col=\"images\", \n y_col=labels, \n class_mode=\"raw\", \n batch_size=sample_size, \n shuffle=True, \n target_size=(target_w, target_h))\n \n # get data sample\n batch = raw_train_generator.next()\n data_sample = batch[0]\n\n # use sample to fit mean and std for test set generator\n image_generator = ImageDataGenerator(\n featurewise_center=True,\n featurewise_std_normalization= True)\n \n # fit generator to sample from training data\n image_generator.fit(data_sample)\n\n # get test generator\n valid_generator = image_generator.flow_from_dataframe(\n dataframe=valid_df,\n directory=image_dir,\n x_col=x_col,\n y_col=y_cols,\n class_mode=\"raw\",\n batch_size=batch_size,\n shuffle=False,\n seed=seed,\n target_size=(target_w,target_h))\n\n test_generator = image_generator.flow_from_dataframe(\n dataframe=test_df,\n directory=image_dir,\n x_col=x_col,\n y_col=y_cols,\n class_mode=\"raw\",\n batch_size=batch_size,\n shuffle=False,\n seed=seed,\n target_size=(target_w,target_h))\n return valid_generator, test_generator","def make_checkerboard_training_set(num_points=0, noise=0.0, randomize=True,\n x_min=0.0, x_max=1.0, y_min=0.0, y_max=1.0):\n log.out.info(\"Generating target data.\")\n # Select coordinates to do an XOR like operation on\n coords = []\n bools = []\n if randomize:\n for i in range(num_points):\n # Add num_points randomly\n coord_point = np.random.random(2)\n coord_point[0] = coord_point[0] * (x_max - x_min) + x_min\n coord_point[1] = coord_point[1] * (y_max - y_min) + y_min\n coords.append(coord_point)\n else:\n x_points = np.linspace(x_min, x_max, int(np.sqrt(num_points)))\n y_points = np.linspace(y_min, y_max, int(np.sqrt(num_points)))\n for i in range(int(np.sqrt(num_points))):\n for j in range(int(np.sqrt(num_points))):\n # Add num_points randomly\n coord_point = [x_points[i], y_points[j]]\n coords.append(coord_point)\n # Assign an xor boolean value to the coordinates\n for coord_point in coords:\n bool_point = np.array([np.round(coord_point[0]) % 2, np.round(coord_point[1]) % 2]).astype(bool)\n bools.append(np.logical_xor(bool_point[0], bool_point[1]))\n # If noisy then bit flip\n if noise > 0.0:\n for i in enumerate(bools):\n if np.random.random() < noise:\n bools[i] = np.logical_not(bools[i])\n # Build training vectors\n train_in = None\n train_out = None\n for i, coord in enumerate(coords):\n # Need to initialize the arrays\n if i == 0:\n train_in = np.array([coord])\n train_out = np.array([[bools[i]]])\n else:\n train_in = np.append(train_in, np.array([coord]), axis=0)\n train_out = np.append(train_out, np.array([[bools[i]]]), axis=1)\n\n train_out = train_out.T\n return train_in, train_out","def build_generators(folder_path, train_batch_size, val_batch_size, height, width):\n train_image_generator, train_mask_generator = create_train_generator(folder_path,\n train_batch_size,\n (height, width),\n preprocessing_masks)\n val_image_generator, val_mask_generator = create_validation_generator(folder_path,\n val_batch_size,\n (height, width),\n preprocessing_masks)\n my_train_generator = my_image_mask_generator(train_image_generator, train_mask_generator)\n my_val_generator = my_image_mask_generator(val_image_generator, val_mask_generator)\n\n return my_train_generator, my_val_generator","def _generate_crop_images(\n crop_boxes, image, points_grid, layer_idxs, target_size, original_size, input_data_format=None\n):\n cropped_images = []\n total_points_per_crop = []\n for i, crop_box in enumerate(crop_boxes):\n left, top, right, bottom = crop_box\n\n channel_dim = infer_channel_dimension_format(image, input_data_format)\n if channel_dim == ChannelDimension.LAST:\n cropped_im = image[top:bottom, left:right, :]\n else:\n cropped_im = image[:, top:bottom, left:right]\n\n cropped_images.append(cropped_im)\n\n cropped_im_size = get_image_size(cropped_im, channel_dim)\n points_scale = np.array(cropped_im_size)[None, ::-1]\n\n points = points_grid[layer_idxs[i]] * points_scale\n normalized_points = _normalize_coordinates(target_size, points, original_size)\n total_points_per_crop.append(normalized_points)\n\n return cropped_images, total_points_per_crop","def generate_leave_one_run_out(n_samples, run_onsets, random_state=None,\n n_runs_out=1):\n random_state = check_random_state(random_state)\n\n n_runs = len(run_onsets)\n # With permutations, we are sure that all runs are used as validation runs.\n # However here for n_runs_out > 1, a run can be chosen twice as validation\n # in the same split.\n all_val_runs = np.array(\n [random_state.permutation(n_runs) for _ in range(n_runs_out)])\n\n all_samples = np.arange(n_samples)\n runs = np.split(all_samples, run_onsets[1:])\n if any(len(run) == 0 for run in runs):\n raise ValueError(\"Some runs have no samples. Check that run_onsets \"\n \"does not include any repeated index, nor the last \"\n \"index.\")\n\n for val_runs in all_val_runs.T:\n train = np.hstack(\n [runs[jj] for jj in range(n_runs) if jj not in val_runs])\n val = np.hstack([runs[jj] for jj in range(n_runs) if jj in val_runs])\n yield train, val","def next_simple_dataset(dataset, batch_size: int, datatype):\n while True:\n x_batch = []\n y_batch = []\n for i in range(batch_size):\n try:\n x, y, data_unit, index = create_xy(dataset, datatype)\n # x = normalize(x)\n x_batch.append(x)\n y_batch.append(y)\n except StopIteration:\n break\n x_batch, y_batch = np.array(x_batch), np.array(y_batch)\n if datatype != DataType.test:\n x_batch = SEQ_CVXTZ.augment_images(x_batch).astype(\"float32\")\n x_batch = np.array([normalize(x) for x in x_batch])\n # org_shape = x_batch.shape\n # org_width = x_batch.shape[1]\n # corner = int((org_width - ROI_IMAGE_SIZE) // 2)\n # print(f\"0: org_shape:{org_shape} x_batch:{x_batch.shape} corner:{corner}\")\n # x_batch = x_batch[:, corner:(org_width - corner), corner:(org_width - corner), :]\n # resized_x_batch = []\n # for x in x_batch:\n # img = Image.fromarray(np.uint8(x))\n # img = img.resize((IMAGE_SIZE, IMAGE_SIZE), Image.LANCZOS)\n # resized_x_batch.append(normalize(np.array(img)))\n # print(f\"1: org_shape:{org_shape} corner:{corner} x_batch:{x_batch.shape}\")\n # yield np.array(resized_x_batch), y_batch\n yield np.array(x_batch), y_batch","def modelnet40_generator(subset, src_dir=DEFAULT_SRCDIR, single=True, target_size=DEFAULT_TARGET_SIZE, repeats=None, shuffle=True, verbose=0, frac=1.0, class_array=True, preprocess=preprocess_input):\n viewL = modelnet40_filenames(subset, src_dir)\n def generator_func():\n repeat = 0\n while repeats is None or repeat < repeats:\n if shuffle:\n random.shuffle(viewL)\n for (i, view) in enumerate(viewL[:int(len(viewL)*frac)]):\n if verbose == 1 and i % 100 == 0:\n print('Loading %s data: %.1f%%' % (subset, i*100.0/(len(viewL)*frac)))\n (cls, view) = view\n if verbose == 2:\n print('Loading data point %d, cls = %d' % (i, cls))\n if class_array:\n cls_array = numpy.zeros((1, nclasses), 'float32')\n cls_array[0, cls] = 1.0\n cls = cls_array\n if single:\n filename = random.choice(view)\n yield (read_image(filename, target_size, preprocess), cls)\n else:\n yield ([read_image(view_elem, target_size, preprocess) for view_elem in view], cls)\n repeat += 1 \n return (generator_func(), len(viewL))","def generate_crop_boxes(\n self,\n image,\n target_size,\n crop_n_layers: int = 0,\n overlap_ratio: float = 512 / 1500,\n points_per_crop: Optional[int] = 32,\n crop_n_points_downscale_factor: Optional[List[int]] = 1,\n device: Optional[\"torch.device\"] = None,\n input_data_format: Optional[Union[str, ChannelDimension]] = None,\n return_tensors: str = \"pt\",\n ):\n crop_boxes, points_per_crop, cropped_images, input_labels = _generate_crop_boxes(\n image,\n target_size,\n crop_n_layers,\n overlap_ratio,\n points_per_crop,\n crop_n_points_downscale_factor,\n input_data_format,\n )\n if return_tensors == \"pt\":\n if device is None:\n device = torch.device(\"cpu\")\n crop_boxes = torch.tensor(crop_boxes, device=device)\n points_per_crop = torch.tensor(points_per_crop, device=device)\n # cropped_images stays as np\n input_labels = torch.tensor(input_labels, device=device)\n\n elif return_tensors == \"tf\":\n if device is not None:\n raise ValueError(\"device is not a supported argument when return_tensors is tf!\")\n crop_boxes = tf.convert_to_tensor(crop_boxes)\n points_per_crop = tf.convert_to_tensor(points_per_crop)\n # cropped_images stays as np\n input_labels = tf.convert_to_tensor(input_labels)\n else:\n raise ValueError(\"return_tensors must be either 'pt' or 'tf'.\")\n return crop_boxes, points_per_crop, cropped_images, input_labels","def cv_index_partitions(n: int, s: int):\n indices = np.arange(n)\n np.random.shuffle(indices)\n val_size = n // s # size of validation set\n for i in range(s):\n training = np.concatenate(\n (indices[0:i*val_size], indices[(i+1)*val_size:])\n )\n validation = indices[i*val_size:(i+1)*val_size]\n yield training, validation","def __iter__(self):\n batch = []\n for i_batch in range(self.episode_num):\n classes = torch.randperm(len(self.idx_list))[: self.way_num]\n for c in classes:\n idxes = self.idx_list[c.item()]\n pos = torch.randperm(idxes.size(0))[: self.image_num]\n batch.append(idxes[pos])\n if len(batch) == self.episode_size * self.way_num:\n batch = torch.stack(batch).reshape(-1)\n yield batch\n batch = []","def get_test_generator(patch_size, batch_size, preprocess_func, output_reshape_func, test_data_dir='data/test/'):\n\n test_paths = util.get_data_list(test_data_dir)\n\n # generate train batch loader\n test_data_loader = CTBatchLoader(test_paths, batch_size, patch_size, num_threads_in_multithreaded=1,\n preprocess_func=preprocess_func, infinite=False)\n\n # wrapper to be compatible with keras\n return KerasGenerator(test_data_loader, output_reshapefunc=output_reshape_func,\n n=int(len(test_data_loader.indices) / batch_size))","def generate_images(generator_model, output_dir, epoch, n_class, batch_size=128):\n label = np.random.randint(0, n_class, size=(batch_size, 1))\n label = np_utils.to_categorical(label, num_classes=n_class)\n test_image_stack = generator_model.predict([np.random.rand(10, 100), label])\n test_image_stack = (test_image_stack * 127.5) + 127.5\n test_image_stack = np.squeeze(np.round(test_image_stack).astype(np.uint8))\n tiled_output = tile_images(test_image_stack)\n tiled_output = Image.fromarray(tiled_output, mode='L') # L specifies greyscale\n outfile = os.path.join(output_dir, 'epoch_{}.png'.format(epoch))\n tiled_output.save(outfile)","def generating(\n self,\n prompt,\n width=512,\n height=512,\n guidance_scale=7.5,\n num_images_per_prompt=1,\n num_inference_steps=50,\n generator=None,\n **kwargs,\n ):\n pipe = self.get_pipe(\"generate\")\n images = pipe(\n prompt=prompt,\n width=width,\n height=height,\n guidance_scale=guidance_scale,\n num_images_per_prompt=num_images_per_prompt,\n num_inference_steps=num_inference_steps,\n generator=generator,\n **kwargs,\n ).images\n return images","def data_generator(dataset, config, shuffle=True, augment=False, augmentation=None, batch_size=1):\n b = 0 # batch item index\n image_index = -1\n image_ids = np.copy(dataset.image_ids)\n error_count = 0\n\n # Keras requires a generator to run indefinately.\n while True:\n try:\n # Increment index to pick next image. Shuffle if at the start of an epoch.\n image_index = (image_index + 1) % len(image_ids)\n if shuffle and image_index == 0:\n np.random.shuffle(image_ids)\n\n # Get GT bounding boxes and masks for image.\n image_id = image_ids[image_index]\n image, gt_class_ids = load_image_gt(dataset, config, image_id, augment=augment,\n augmentation=augmentation)\n\n # Init batch arrays\n if b == 0:\n batch_images = np.zeros(\n (batch_size,) + image.shape, dtype=np.float32)\n batch_gt_class_ids = np.zeros(\n (batch_size, config.MAX_GT_INSTANCES), dtype=np.int32)\n\n # Add to batch\n batch_images[b] = mold_image(image.astype(np.float32), config)\n batch_gt_class_ids[b, gt_class_ids] = 1\n b += 1\n\n # Batch full?\n if b >= batch_size:\n inputs = [batch_images, batch_gt_class_ids]\n outputs = []\n\n yield inputs, outputs\n\n # start a new batch\n b = 0\n except (GeneratorExit, KeyboardInterrupt):\n raise\n except:\n # Log it and skip the image\n logging.exception(\"Error processing image {}\".format(\n dataset.image_info[image_id]))\n error_count += 1\n if error_count > 5:\n raise","def next_batch(self):\n next_train_index = self.curr_train_index + self.hparams.batch_size\n if next_train_index > self.num_train:\n # Increase epoch number\n epoch = self.epochs + 1\n self.reset()\n self.epochs = epoch\n batched_data = (\n self.train_images[self.curr_train_index:self.curr_train_index +\n self.hparams.batch_size],\n self.train_labels[self.curr_train_index:self.curr_train_index +\n self.hparams.batch_size])\n final_imgs = []\n images, labels = batched_data\n if self.hparams.augment_type == 'mixup':\n images, labels = augmentation_transforms.mixup_batch(\n images, labels, self.hparams.mixup_alpha)\n elif self.hparams.augment_type == 'image_freq':\n images, labels = augmentation_transforms.freq_augment(\n images,\n labels,\n amplitude=self.hparams.freq_augment_amplitude,\n magnitude=self.hparams.augmentation_magnitude,\n proportion_f=self.hparams.freq_augment_ffrac,\n probability=self.hparams.augmentation_probability)\n for data in images:\n if self.hparams.augment_type == 'autoaugment':\n epoch_policy = self.good_policies[np.random.choice(\n len(self.good_policies))]\n final_img = augmentation_transforms.apply_policy(epoch_policy, data)\n elif self.hparams.augment_type == 'random':\n epoch_policy = found_policies.random_policy(\n self.hparams.num_augmentation_layers,\n self.hparams.augmentation_magnitude,\n self.hparams.augmentation_probability)\n final_img = augmentation_transforms.apply_policy(epoch_policy, data)\n else:\n final_img = np.copy(data)\n if self.hparams.apply_flip_crop:\n final_img = augmentation_transforms.random_flip(\n augmentation_transforms.zero_pad_and_crop(data, 4))\n # Apply cutout\n if self.hparams.apply_cutout:\n final_img = augmentation_transforms.cutout_numpy(final_img)\n\n final_imgs.append(final_img)\n final_imgs = np.array(final_imgs, np.float32)\n if self.hparams.noise_type == 'radial':\n labels = augmentation_transforms.add_radial_noise(\n final_imgs, labels, self.hparams.frequency, self.hparams.amplitude,\n self.hparams.noise_class, self.hparams.normalize_amplitude)\n elif self.hparams.noise_type == 'random' or self.hparams.noise_type == 'fourier' or self.hparams.noise_type == 'f' or self.hparams.noise_type == '1/f':\n labels = augmentation_transforms.add_sinusoidal_noise(\n final_imgs, labels, self.hparams.frequency, self.hparams.amplitude,\n self.direction, self.hparams.noise_class,\n self.hparams.normalize_amplitude)\n elif self.hparams.noise_type == 'uniform':\n labels = augmentation_transforms.add_uniform_noise(\n labels, self.hparams.amplitude, self.hparams.noise_class)\n\n batched_data = (final_imgs, labels)\n self.curr_train_index += self.hparams.batch_size\n return batched_data","def test_cropping(self, scaffold_res=9):\n device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n func = self._get_simple_implicit_function(scaffold_res=scaffold_res).to(device)\n\n assert scaffold_res >= 8\n div = (scaffold_res - 1) / 2\n true_min_point = torch.tensor(\n [-3 / div, 0 / div, -3 / div],\n device=device,\n )\n true_max_point = torch.tensor(\n [1 / div, 2 / div, 3 / div],\n device=device,\n )\n\n def new_scaffold(points):\n # 1 if between true_min and true_max point else 0\n # return points.new_ones((*points.shape[:-1], 1))\n return (\n torch.logical_and(true_min_point <= points, points <= true_max_point)\n .all(dim=-1)\n .float()[..., None]\n )\n\n called_crop = []\n\n def assert_min_max_points(min_point, max_point):\n called_crop.append(1)\n self.assertClose(min_point, true_min_point)\n self.assertClose(max_point, true_max_point)\n\n func.voxel_grid_density.crop_self = assert_min_max_points\n func.voxel_grid_color.crop_self = assert_min_max_points\n func.voxel_grid_scaffold.forward = new_scaffold\n func._scaffold_ready = True\n func._crop(epoch=0)\n assert len(called_crop) == 2"],"string":"[\n \"def crop_generator(batches, crop_length):\\n while True:\\n batch_x, batch_y = next(batches)\\n batch_crops = np.zeros((batch_x.shape[0], crop_length, crop_length, 3))\\n for i in range(batch_x.shape[0]):\\n batch_crops[i] = random_crop(batch_x[i], (crop_length, crop_length))\\n yield (batch_crops, batch_y)\",\n \"def generate_transformed_data(self):\\n for each_class in self.classes:\\n class_directory = \\\"data/test/test_folder/\\\"\\n class_directory += each_class\\n class_directory += \\\"_test.jpg\\\"\\n test_image = keras.preprocessing.image.load_img(class_directory)\\n image_set = keras.preprocessing.image.img_to_array(test_image)\\n image_set = image_set.reshape((1,) + image_set.shape)\\n i = 0\\n for each_batch in self.transformed_data_generator.flow(image_set, batch_size=1,\\n save_to_dir=\\\"data/test_transformed/test_folder\\\", save_prefix=each_class, save_format=\\\"jpeg\\\"):\\n i += 1\\n if i > 20:\\n break\",\n \"def two_step_generator(classes: list, paths_list: list, imgs_per_class: int, shape: tuple,\\n nb_win: int, greys: bool, nb_to_gen: int, img_gen: ImageDataGenerator) -> list:\\n \\n datawin = list() \\n datagen = list()\\n \\n for class_ in classes:\\n print(class_)\\n \\n # Images paths list\\n class_imgs_path = [paths_list[k] for k in range(len(paths_list)) if class_ in paths_list[k]]\\n\\n # Randomly choose images\\n class_imgs_subset = np.random.choice(class_imgs_path, size=imgs_per_class, replace=False)\\n\\n # Get images\\n class_imgs = get_imgs(class_imgs_subset)\\n\\n # Step 1: resize and crop on sliding windows\\n class_new_imgs = create_windows_imgs(class_imgs, shape=shape, nb_win=nb_win, greys=greys)\\n class_new_imgs = np.array(flat_list(class_new_imgs))\\n datawin.append(class_new_imgs)\\n \\n # Step 2: DataGenerator\\n class_datagen = datagen_class(class_new_imgs, nb_to_gen, img_gen)\\n class_datagen = class_datagen.astype(int)\\n\\n datagen.append(class_datagen)\\n \\n return datawin, datagen\",\n \"def random_crop_generator(batches, crop_length):\\n while True:\\n batch_x, batch_y = next(batches)\\n batch_crops = np.zeros((batch_x.shape[0], crop_length, crop_length, 3))\\n for i in range(batch_x.shape[0]):\\n batch_crops[i] = random_crop(batch_x[i], (crop_length, crop_length))\\n yield (batch_crops, batch_y)\",\n \"def toy_preprocess_scans(self, scan_ids, width, height, depth, clipping=True, loop=False,\\n seed=42, shuffle=False):\\n # Initialize image transformer\\n kwds_generator = {'rotation_range': 5,\\n 'width_shift_range': 0.03,\\n 'height_shift_range': 0.03,\\n 'zoom_range': 0.03,\\n 'data_format': \\\"channels_first\\\", # z axis is first\\n }\\n image_gen = image_prep.ImageDataGenerator(**kwds_generator)\\n\\n scan_gen = self.preprocess_scans(scan_ids, width, height, depth, clipping, loop, shuffle)\\n for ct_scan, origin, spacing in scan_gen:\\n yield ct_scan, origin, spacing\\n transformed_scan = image_gen.random_transform(ct_scan, seed=seed)\\n if seed is not None:\\n seed += 1\\n yield transformed_scan, origin, spacing\",\n \"def generate_n_augmented_images(data_dirname: str, root_dirname: str, n=20) -> None:\\n augmentor = set_augmentor()\\n preprocessing_fun = lambda *args: pre_processing_function(*args, augmentor=augmentor)\\n generator = set_generator_classifier(data_dirname, preprocessing_fun, batch_size=1, number_of_images=n)\\n generator.not_batch = True\\n # NOTICE: This generator can be used for keras and pytorch in case that instead of saving images one desires to\\n # augment images on the fly. Use a number larger than 1 for the batch size when training directly a CNN.\\n\\n # Save the new generated images\\n counter_labels = {}\\n for image, label in generator:\\n counter = counter_labels.get(label, 0)\\n output_filename = label + '_' + str(counter_labels.get(label, 0)) + '.jpg'\\n save_dirname = os.path.join(root_dirname, label)\\n if not os.path.isdir(save_dirname):\\n os.makedirs(save_dirname)\\n\\n filename = os.path.join(save_dirname, output_filename)\\n imsave(filename, image.astype(np.uint8))\\n counter_labels[label] = counter + 1\\n\\n print(f'Finished image generation. The output images were saved in {root_dirname}')\",\n \"def build_generator(self):\\n noise_shape = (self.dimensions_noise,)\\n\\n # This block of code can be a little daunting, but essentially it automatically calculates the required starting\\n # array size that will be correctly upscaled to our desired image size.\\n #\\n # We have 5 Upsample2D layers which each double the images width and height, so we can determine the starting\\n # x size by taking (x / 2^upsample_count) So for our target image size, 256x192, we do the following:\\n # x = (192 / 2^5), y = (256 / 2^5) [x and y are reversed within the model]\\n # We also need a 3rd dimension which is chosen relatively arbitrarily, in this case it's 64.\\n model = Sequential()\\n model.add(\\n Dense(\\n self.starting_filters\\n * (self.img_size[0] // (2 ** self.upsample_layers))\\n * (self.img_size[1] // (2 ** self.upsample_layers)),\\n activation=\\\"relu\\\",\\n input_shape=noise_shape,\\n )\\n )\\n model.add(\\n Reshape(\\n (\\n (self.img_size[0] // (2 ** self.upsample_layers)),\\n (self.img_size[1] // (2 ** self.upsample_layers)),\\n self.starting_filters,\\n )\\n )\\n )\\n model.add(BatchNormalization(momentum=0.8))\\n\\n model.add(UpSampling2D()) # 6x8 -> 12x16\\n model.add(Conv2D(1024, kernel_size=self.kernel_size, padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(momentum=0.8))\\n\\n model.add(UpSampling2D()) # 12x16 -> 24x32\\n model.add(Conv2D(512, kernel_size=self.kernel_size, padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(momentum=0.8))\\n\\n model.add(UpSampling2D()) # 24x32 -> 48x64\\n model.add(Conv2D(256, kernel_size=self.kernel_size, padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(momentum=0.8))\\n\\n model.add(UpSampling2D()) # 48x64 -> 96x128\\n model.add(Conv2D(128, kernel_size=self.kernel_size, padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(momentum=0.8))\\n\\n model.add(UpSampling2D()) # 96x128 -> 192x256\\n model.add(Conv2D(64, kernel_size=self.kernel_size, padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(momentum=0.8))\\n\\n model.add(Conv2D(32, kernel_size=self.kernel_size, padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(momentum=0.8))\\n\\n model.add(Conv2D(self.channels, kernel_size=self.kernel_size, padding=\\\"same\\\"))\\n model.add(Activation(\\\"tanh\\\"))\\n\\n model.summary()\\n\\n noise = Input(shape=noise_shape)\\n img = model(noise)\\n\\n return Model(noise, img)\",\n \"def get_crops(x_train, y_train, offset=4):\\n\\ttopleft = iaa.Sequential([\\n\\t\\tiaa.Crop(px=(4 - offset, offset, offset, 4 - offset)),\\n\\t\\tiaa.Affine(scale=1.166666667)\\n\\t])\\n\\ttopright = iaa.Sequential([\\n\\t\\tiaa.Crop(px=(4 - offset, 4 - offset, offset, offset)),\\n\\t\\tiaa.Affine(scale=1.166666667)\\n\\t])\\n\\tbotleft = iaa.Sequential([\\n\\t\\tiaa.Crop(px=(offset, offset, 4 - offset, 4 - offset)),\\n\\t\\tiaa.Affine(scale=1.166666667)\\n\\t])\\n\\tbotright = iaa.Sequential([\\n\\t\\tiaa.Crop(px=(offset, 4 - offset, 4 - offset, offset)),\\n\\t\\tiaa.Affine(scale=1.166666667)\\n\\t])\\n\\tcenter = iaa.Sequential([\\n\\t\\tiaa.Crop(px=(2, 2, 2, 2)),\\n\\t\\tiaa.Affine(scale=1.166666667)\\n\\t])\\n\\taugs = [topleft, topright, botleft, botright, center]\\n\\n\\taug_imgs = []\\n\\tfor aug in tqdm(augs):\\n\\t\\taug_imgs.append(aug.augment_images(x_train * 255))\\n\\n\\taug_x_train = [item for sublist in aug_imgs for item in sublist]\\n\\taug_y_train = y_train * 5\\n\\n\\treturn aug_x_train, aug_y_train\",\n \"def genTrainingSet(set_of_CSVs, file_to_classify, train_size = 5):\\n set_of_csvs_minus_target = copy.copy(set_of_CSVs)\\n # remove the file we want to classify\\n set_of_csvs_minus_target.remove(file_to_classify)\\n\\n # extract out the random noise files\\n # first, set the seed\\n random.seed(time.time())\\n # now sample\\n return_list = random.sample(set_of_csvs_minus_target, train_size)\\n return return_list\",\n \"def __call__(self):\\n if self.numbatches is None:\\n pool = self.pooler()\\n if self.batchsize is None:\\n self.batchsize = self.pooler.nInPool()\\n self.numbatches = self.pooler.nInPool()//self.batchsize\\n for i in xrange(self.numbatches):\\n pool = self.pooler()\\n self._reset_batch()\\n if self.samplemethod == 'balance' and len(self.keysamplers)>0:\\n batchinds,keyids = self._samplebalanced(pool)\\n elif self.samplemethod == 'uniform':\\n batchinds,keyids = self._sampleuniform(pool)\\n else:\\n batchinds,keyids = self._samplesequential(i)\\n batch = self._extractInds(pool,batchinds,keyids)\\n for k in batch:\\n batch[k][np.isnan(batch[k])] = self.nanreplacement\\n yield batch\",\n \"def generate_one(self, n_images, min_correct=None, p_correct=0.5, n_correct=None, n_caps_per_image=1, configs=None):\\n random.seed() # For multiprocessing (TODO: can we avoid this?)\\n imgs = np.zeros((n_images, 3, c.DIM, c.DIM), dtype=np.uint8)\\n labels = np.zeros((n_images, ), dtype=np.uint8)\\n if configs is not None:\\n cfg_idx = random.choice(len(configs))\\n target_cfg = configs[cfg_idx]\\n else:\\n # FIXME: Make this OOP to avoid these if statements\\n if self.img_type == 'spatial':\\n target_cfg = self.random_config_spatial()\\n elif self.img_type == 'single':\\n target_cfg = self.random_config_single()\\n\\n if self.data_type == 'concept':\\n if n_correct is not None:\\n # Fixed number of targets and distractors\\n n_target = n_correct\\n n_distract = n_images - n_target\\n elif min_correct is not None:\\n # Minimum number of targets, otherwise sample whatever\\n # TODO: combine min_correct and min_incorrect\\n n_target = min_correct\\n n_distract = 0\\n else:\\n # Minimum of 2 targets and distractors each\\n n_target = 2\\n n_distract = 2\\n else:\\n n_target = 1\\n n_distract = n_images # Never run out of distractors\\n\\n cfgs = []\\n shapes = []\\n cfgs_to_cap = []\\n for i in range(n_images):\\n if n_target > 0:\\n label = 1\\n n_target -= 1\\n elif n_distract > 0:\\n label = 0\\n n_distract -= 1\\n else:\\n label = (random.random() < p_correct)\\n\\n if self.img_type == 'spatial':\\n new_cfg, new_shapes, cfg_to_cap = self.generate_spatial(target_cfg, label, n_caps_per_image)\\n elif self.img_type == 'single':\\n new_cfg, new_shapes = self.generate_single(target_cfg, label)\\n\\n # Create image and draw shapes\\n img = self.create_image(new_shapes)\\n imgs[i] = img\\n labels[i] = label\\n cfgs.append(new_cfg)\\n shapes.append(new_shapes)\\n cfgs_to_cap.append(cfg_to_cap)\\n\\n return imgs, labels, target_cfg, cfgs, cfgs_to_cap, shapes\",\n \"def rand_crop_whole_ct(image, label, res_s, out_s,\\n apply_data_aug, augment_times=2):\\n if image.shape != (res_s, res_s, res_s) or \\\\\\n label.shape != (res_s, res_s, res_s):\\n logging.info(\\\"Unexpected shapes. \\\"\\n \\\"image.shape: %s, label.shape: %s\\\",\\n image.shape, label.shape)\\n return\\n\\n if not apply_data_aug:\\n # Do not augment data.\\n idx = (res_s - out_s) // 2\\n image = image[idx:idx + out_s, idx:idx + out_s, idx:idx + out_s]\\n label = label[idx:idx + out_s, idx:idx + out_s, idx:idx + out_s]\\n yield image, label\\n else:\\n cut = res_s - out_s\\n for _ in range(augment_times):\\n for i in [0, cut // 2, cut]:\\n for j in [0, cut // 2, cut]:\\n for k in [0, cut // 2, cut]:\\n image_aug = image[i:i + out_s, j:j + out_s, k:k + out_s].copy()\\n label_aug = label[i:i + out_s, j:j + out_s, k:k + out_s].copy()\\n image_aug = intensity_change(image_aug)\\n yield image_aug, label_aug\",\n \"def generate_observations(self, eval_mode, augment_frames=None):\\n episode_idx = 0\\n augment_frames = (\\n augment_frames if augment_frames is not None\\n else self._augment_frames and not eval_mode)\\n for t, obs in enumerate(self._flat_observations):\\n if augment_frames:\\n obs = image_utils.random_crop_image(obs)\\n if self._split_by_episodes:\\n yield obs, episode_idx\\n else:\\n yield obs\\n if self._is_terminal[t]:\\n episode_idx += 1\",\n \"def gen_test_output(sess, logits, image_folder, image_pl, data_folder,\\n learning_phase, image_shape, nw_shape):\\n image_paths = glob(os.path.join(data_folder, image_folder, '*.png'))\\n for image_file in image_paths[:5]:\\n\\n in_image = scipy.misc.imread(image_file, mode='RGB')\\n image = scipy.misc.imresize(in_image, image_shape)\\n\\n street_im = get_seg_img(sess, logits, image_pl, image, image_shape,\\n nw_shape, learning_phase)\\n\\n street_im = scipy.misc.imresize(street_im, in_image.shape)\\n yield os.path.basename(image_file), np.array(street_im)\",\n \"def s2s_data_generator(s2s_df=duplets, all_catalog=catalog_images, batch_size=None):\\n orig_index_list = duplets.index.tolist()\\n all_shop_index_list = catalog_images.index.tolist()\\n dummy = np.zeros((1, 3 * N))\\n\\n while True:\\n \\n q_list = list()\\n p_list = list()\\n n_list = list()\\n dummy_list = list()\\n \\n index_list = copy.copy(orig_index_list)\\n \\n while len(index_list) > 0:\\n\\n index = random.choice(index_list)\\n product_id = duplets.loc[index, 'product_id']\\n \\n q_temp = duplets.loc[index, 'street_images']\\n q_img = os.path.join(Path, q_temp + '.jpeg')\\n \\n p_temp = duplets.loc[index, 'shop_images']\\n p_img = os.path.join(Path, p_temp + '.jpeg')\\n\\n while True:\\n idx = random.choice(all_shop_index_list)\\n prod_idx = catalog_images.loc[idx, 'product_id']\\n\\n if prod_idx != product_id:\\n temp = random.choice(catalog_images.loc[idx, 'shop_images'])\\n n_img = os.path.join(Path, temp + '.jpeg')\\n\\n q_img = os.path.join(Path, q_index + '.jpeg')\\n p_img = os.path.join(Path, p_index + '.jpeg')\\n n_img = os.path.join(Path, n_index + '.jpeg')\\n\\n res = bbox_mappings[q_index]\\n\\n left = res['left']\\n top = res['top']\\n right = left + res['width']\\n bottom = top + res['height']\\n\\n\\n query_img = Image.open(q_img)\\n query_crop = query_img.crop((left, top, right, bottom))\\n positive_img = Image.open(p_img)\\n negative_img = Image.open(n_img)\\n\\n \\n query = np.array(query_crop.resize((300,300), Image.NEAREST))\\n positive = np.array(positive_img.resize((300,300), Image.NEAREST))\\n negative = np.array(negative_img.resize((300,300), Image.NEAREST))\\n \\n \\n q_list.append(query_array)\\n p_list.append(positive_array)\\n n_list.append(negative_array)\\n dummy_list.append(dummy)\\n\\n \\n index_list.remove(index)\\n\\n if len(q_list) == batch_size or (len(index_list) == 0 and len(q_list) > 0):\\n yield convert_data(q_list, p_list, n_list, dummy_list)\\n q_list = list()\\n p_list = list()\\n n_list = list()\\n dummy_list = list()\",\n \"def __init__(self, dataset, width=512, height=512, pictures=10, generate_classes=True, generate_objects=True):\\n super().__init__(dataset)\\n\\n cropper = Cropper(width=width, height=height)\\n\\n dir_name = \\\"tmp-data-{}x{}-from-{}-pictures\\\".format(width, height, pictures)\\n origins = os.path.join(dir_name, \\\"origins\\\")\\n classes = os.path.join(dir_name, \\\"classes\\\")\\n origins_classes_v_join = os.path.join(dir_name, \\\"origin-classes-v-join\\\")\\n objects = os.path.join(dir_name, \\\"objects\\\")\\n origins_objects_v_join = os.path.join(dir_name, \\\"origin-objects-v-join\\\")\\n\\n if not os.path.exists(origins):\\n os.makedirs(origins)\\n\\n trains = self.get_iterable_trains()\\n vals = self.get_iterable_evals()\\n\\n selection_set = []\\n for _, val in enumerate(trains):\\n origin, class_v, object_v = self.get_train_triple(val)\\n selection_set.append((origin, class_v, object_v))\\n for _, val in enumerate(vals):\\n origin, class_v, object_v = self.get_val_triple(val)\\n selection_set.append((origin, class_v, object_v))\\n\\n final_set = random.sample(selection_set, pictures)\\n\\n if generate_classes:\\n if not os.path.exists(classes):\\n os.makedirs(classes)\\n if not os.path.exists(origins_classes_v_join):\\n os.makedirs(origins_classes_v_join)\\n\\n if generate_objects:\\n if not os.path.exists(objects):\\n os.makedirs(objects)\\n if not os.path.exists(origins_objects_v_join):\\n os.makedirs(origins_objects_v_join)\\n\\n for _, (origin, class_v, object_v) in enumerate(final_set):\\n print(\\\"Processing {}, {}, {}\\\".format(origin, class_v, object_v))\\n cropper.set_imgs(origin, class_v, object_v, add_randomly=5)\\n counter = 1\\n while not cropper.is_finished:\\n origin_i, class_i, object_i = cropper.next_crop()\\n # Check that classes are involved\\n finded = False\\n for l in class_i:\\n for pix in l:\\n for c in pix:\\n if c != 0:\\n finded = True\\n break\\n if finded:\\n break\\n if finded:\\n break\\n if not finded:\\n continue\\n path = \\\"{}-{}.png\\\".format(get_origin_name(origin), counter)\\n # print(\\\"Writing: {}\\\".format(os.path.join(origins, path)))\\n cv2.imwrite(os.path.join(origins, path), origin_i)\\n if generate_classes:\\n cv2.imwrite(os.path.join(classes, path), class_i)\\n cv2.imwrite(os.path.join(origins_classes_v_join, path), cv2.hconcat([origin_i, class_i]))\\n if generate_objects:\\n cv2.imwrite(os.path.join(objects, path), object_i)\\n cv2.imwrite(os.path.join(origins_objects_v_join, path), cv2.hconcat([origin_i, object_i]))\\n counter += 1\\n\\n print(\\\"Generating of {}-pictures-subset done. You find it in: {}\\\".format(pictures, dir_name))\",\n \"def get_generators(patch_size, batch_size, preprocess_func, output_reshape_func, num_validation, train_processes,\\n train_cache, train_data_dir='data/train/'):\\n\\n dirs = util.get_data_list(train_data_dir)\\n labels = util.parse_labels_months()\\n train_paths, validation_paths = util.train_validation_split(dirs, labels)\\n # generate train batch loader\\n train_data_loader = CTBatchLoader(train_paths, batch_size, patch_size, num_threads_in_multithreaded=1,\\n preprocess_func=preprocess_func)\\n\\n train_transforms = get_train_transform(patch_size)\\n train_data_generator = MultiThreadedAugmenter(train_data_loader, train_transforms, num_processes=train_processes,\\n num_cached_per_queue=train_cache, seeds=None, pin_memory=False)\\n\\n # wrapper to be compatible with keras\\n train_generator_keras = KerasGenerator(train_data_generator, output_reshapefunc=output_reshape_func)\\n\\n # generate validation batch loader\\n valid_data_loader = CTBatchLoader(validation_paths, num_validation, patch_size,\\n num_threads_in_multithreaded=1, preprocess_func=preprocess_func)\\n valid_transforms = get_valid_transform(patch_size)\\n valid_data_generator = MultiThreadedAugmenter(valid_data_loader, valid_transforms, num_processes=1,\\n num_cached_per_queue=1, seeds=None, pin_memory=False)\\n # wrapper to be compatible with keras\\n valid_generator_keras = KerasGenerator(valid_data_generator, output_reshape_func, 1)\\n\\n return train_generator_keras, valid_generator_keras\",\n \"def image_generator(df,batch_size,plab,augment=True):\\n rng = np.random.RandomState(290615)\\n if_train = 1 if plab < 1. else 0\\n bi,b_list = 0,df.groupby('business_id').apply(get_biz_id,if_train,batch_size)\\n b_list = b_list[b_list!=0]\\n b_order = rng.permutation(b_list.index)\\n pi,p_list = 0, df[df.iloc[:,-1]==0]['photo_id']\\n p_order = rng.permutation(p_list.index)\\n while True:\\n if rng.rand(1)[0] < plab:\\n # aggregate biz_id with outdoor-seating\\n biz_id_i = b_list.ix[b_order[bi]]\\n photo_train = df[df['business_id']==biz_id_i]['photo_id']\\n y_batch = np.asarray(df[df['business_id']==biz_id_i].iloc[:,-1])\\n # increase/loop indices for next iteration\\n if bi < len(b_list)-1:\\n bi += 1\\n else:\\n bi,b_order = 0,rng.permutation(b_list.index)\\n else:\\n # pic 32 random non-outdoor-seating pictures\\n photo_train = p_list[p_order[pi:(pi+batch_size)]]\\n y_batch = np.repeat(0, repeats=len(photo_train), axis=0)\\n # increase/loop indices for next iteration\\n if pi < len(p_list)-1-batch_size:\\n pi += batch_size\\n else:\\n pi,p_order = 0,rng.permutation(p_list.index)\\n batch_size_i = len(photo_train)\\n # read and augment photos\\n X_batch = np.empty((batch_size_i,h,w,ch))\\n for i_ in range(batch_size_i):\\n f_ = 'data/train_photos/' + str(photo_train.iloc[i_]) + '.jpg'\\n im = Image.open(os.path.realpath(f_))\\n im_sml = im.resize((w,h))\\n # scale inputs [-1,+1]\\n xi = np.asarray(im_sml)/128.-1\\n if augment:\\n # flip coords horizontally (but not vertically)\\n if rng.rand(1)[0] > 0.5:\\n xi = np.fliplr(xi)\\n # rescale slightly within a random range\\n jit = w*0.2\\n if rng.rand(1)[0] > 0.1:\\n xl,xr = rng.uniform(0,jit,1),rng.uniform(w-jit,w,1)\\n yu,yd = rng.uniform(0,jit,1),rng.uniform(h-jit,h,1)\\n pts1 = np.float32([[xl,yu],[xr,yu],[xl,yd],[xr,yd]])\\n pts2 = np.float32([[0,0],[w,0],[0,h],[w,h]])\\n M = cv2.getPerspectiveTransform(pts1,pts2)\\n xi = cv2.warpPerspective(xi,M,(w,h))\\n # save individual image to X_batch\\n X_batch[i_,:,:,:] = xi\\n# plt.imsave('data/aug_%i' % i_,(xi+1)/2);plt.close()\\n yield([X_batch],y_batch)\",\n \"def reconstructions_sample(self, n=()):\\n self.assert_sampled()\\n return [[j.sample(sample_shape=n, seed=self.randint).numpy()\\n for j in i]\\n for i in self._reconstructions]\",\n \"def data_generator(dataset, config, shuffle=True, augmentation=None,\\n random_rois=0, batch_size=1, detection_targets=False,\\n diverse=0, no_augmentation_sources=None):\\n b = 0 # batch item index\\n image_index = -1\\n image_ids = np.copy(dataset.image_ids)\\n error_count = 0\\n no_augmentation_sources = no_augmentation_sources or []\\n\\n # Anchors\\n # [anchor_count, (y1, x1, y2, x2)]\\n backbone_shapes = compute_backbone_shapes(config, config.IMAGE_SHAPE)\\n anchors = utils.generate_pyramid_anchors(config.RPN_ANCHOR_SCALES,\\n config.RPN_ANCHOR_RATIOS,\\n backbone_shapes,\\n config.BACKBONE_STRIDES,\\n config.RPN_ANCHOR_STRIDE)\\n\\n # Keras requires a generator to run indefinitely.\\n while True:\\n try:\\n # Increment index to pick next image. Shuffle if at the start of an epoch.\\n image_index = (image_index + 1) % len(image_ids)\\n if shuffle and image_index == 0:\\n np.random.shuffle(image_ids)\\n\\n # Get GT bounding boxes and masks for image.\\n image_id = image_ids[image_index]\\n # If the image source is not to be augmented pass None as augmentation\\n if dataset.image_info[image_id]['source'] in no_augmentation_sources: augmentation = None\\n image, image_meta, gt_class_ids, gt_class_ids2, gt_boxes, gt_rboxes, gt_global_mask, \\\\\\n gt_masks, gt_mask_score, gt_text_embeds, gt_embed_lengths = load_image_gt(dataset, config, image_id,\\n augmentation=augmentation)\\n\\n \\n # Skip images that have no instances. This can happen in cases\\n # where we train on a subset of classes and the image doesn't\\n # have any of the classes we care about.\\n if not np.any(gt_class_ids > 0):\\n continue\\n\\n # Use only positive class_ids\\n categories = np.unique(gt_class_ids)\\n _idx = categories > 0\\n categories = categories[_idx]\\n \\n if config.MODEL == \\\"smrcnn\\\":\\n # Use only active classes\\n active_categories = []\\n for c in categories:\\n if any(c == dataset.ACTIVE_CLASSES):\\n active_categories.append(c)\\n \\n # Skiop image if it contains no instance of any active class \\n if not np.any(np.array(active_categories) > 0):\\n continue\\n # Randomly select category\\n category = np.random.choice(active_categories)\\n \\n # NOTE for siamese\\n # Generate siamese target crop\\n targets = []\\n for i in range(config.NUM_TARGETS):\\n targets.append(get_one_target(category, dataset, config, augmentation=augmentation))\\n # target = np.stack(target, axis=0)\\n \\n # print(target_class_id)\\n target_class_id = category\\n target_class_ids = np.array([target_class_id])\\n \\n idx = gt_class_ids == target_class_id\\n siamese_class_ids = idx.astype('int8')\\n # print(idx)\\n # print(gt_boxes.shape, gt_masks.shape)\\n siamese_class_ids = siamese_class_ids[idx]\\n gt_class_ids = gt_class_ids[idx]\\n gt_boxes = gt_boxes[idx,:]\\n gt_masks = gt_masks[:,:,idx]\\n image_meta = image_meta[:15] # TODO\\n # --------------------------------------------------------------\\n\\n # RPN Targets\\n # if rpn have muiltple label, rewrite here\\n rpn_match, rpn_bbox = build_rpn_targets(image.shape, anchors,\\n gt_class_ids, gt_boxes, config)\\n\\n # Mask R-CNN Targets\\n if random_rois:\\n rpn_rois = generate_random_rois(image.shape, random_rois, gt_class_ids, gt_boxes)\\n if detection_targets:\\n rois, mrcnn_class_ids, mrcnn_class_ids2, mrcnn_bbox, mrcnn_rbbox, mrcnn_mask,\\\\\\n mrcnn_text_embeds, mrcnn_embed_lengths = build_detection_targets(\\n rpn_rois, gt_class_ids, gt_boxes, gt_rboxes, gt_masks, gt_mask_score, gt_class_ids2, config)\\n\\n # Init batch arrays\\n if b == 0:\\n batch_image_meta = np.zeros((batch_size,) + image_meta.shape, dtype=image_meta.dtype)\\n batch_rpn_match = np.zeros([batch_size, anchors.shape[0], 1], dtype=rpn_match.dtype)\\n batch_rpn_bbox = np.zeros([batch_size, config.RPN_TRAIN_ANCHORS_PER_IMAGE, 4], dtype=rpn_bbox.dtype)\\n batch_images = np.zeros((batch_size,) + image.shape, dtype=np.float32)\\n batch_gt_class_ids = np.zeros((batch_size, config.MAX_GT_INSTANCES), dtype=np.int32)\\n batch_gt_boxes = np.zeros((batch_size, config.MAX_GT_INSTANCES, 4), dtype=np.int32)\\n batch_gt_rboxes = np.zeros((batch_size, config.MAX_GT_INSTANCES, 5), dtype=np.float32)\\n if config.MODEL == \\\"smrcnn\\\":\\n batch_targets = np.zeros((batch_size, config.NUM_TARGETS) + targets[0].shape, dtype=np.float32)\\n batch_gt_masks = np.zeros((batch_size, gt_masks.shape[0], gt_masks.shape[1],\\n config.MAX_GT_INSTANCES), dtype=gt_masks.dtype)\\n batch_gt_class_ids2 = np.zeros((batch_size, config.MAX_GT_INSTANCES), dtype=np.int32)\\n batch_gt_text_embeds = np.zeros((batch_size, config.MAX_GT_INSTANCES, config.MAX_LABEL_LENGTH), dtype=np.int32)\\n batch_gt_embed_lengths = np.zeros((batch_size, config.MAX_GT_INSTANCES), dtype=np.int32)\\n if random_rois:\\n batch_rpn_rois = np.zeros((batch_size, rpn_rois.shape[0], 4), dtype=rpn_rois.dtype)\\n if detection_targets:\\n batch_rois = np.zeros((batch_size,) + rois.shape, dtype=rois.dtype)\\n batch_mrcnn_class_ids = np.zeros((batch_size,) + mrcnn_class_ids.shape, dtype=mrcnn_class_ids.dtype)\\n \\n # ************************* NOTE for 2 label dataset\\n if config.NUM_CLASSES2 > 2:\\n batch_mrcnn_class_ids2 = np.zeros(\\n (batch_size,) + mrcnn_class_ids2.shape, dtype=mrcnn_class_ids.dtype)\\n # ************************* NOTE for ocr\\n if config.READ:\\n batch_mrcnn_text_embeds = np.zeros(\\n (batch_size,) + mrcnn_text_embeds.shape, dtype=mrcnn_text_embeds.dtype)\\n batch_mrcnn_embed_lengths = np.zeros(\\n (batch_size,) + mrcnn_embed_lengths.shape, dtype=mrcnn_text_embeds.dtype)\\n batch_mrcnn_bbox = np.zeros((batch_size,) + mrcnn_bbox.shape, dtype=mrcnn_bbox.dtype)\\n batch_mrcnn_rbbox = np.zeros((batch_size,) + mrcnn_rbbox.shape, dtype=mrcnn_rbbox.dtype)\\n batch_mrcnn_mask = np.zeros((batch_size,) + mrcnn_mask.shape, dtype=mrcnn_mask.dtype)\\n\\n # If more instances than fits in the array, sub-sample from them.\\n if gt_boxes.shape[0] > config.MAX_GT_INSTANCES:\\n ids = np.random.choice(\\n np.arange(gt_boxes.shape[0]), config.MAX_GT_INSTANCES, replace=False)\\n gt_class_ids = gt_class_ids[ids]\\n siamese_class_ids = siamese_class_ids[ids] # NOTE\\n gt_boxes = gt_boxes[ids]\\n gt_rboxes = gt_rboxes[ids]\\n gt_masks = gt_masks[:, :, ids]\\n gt_class_ids2 = gt_class_ids2[ids]\\n gt_text_embeds = gt_text_embeds[ids]\\n gt_embed_lengths = gt_embed_lengths[ids]\\n\\n # Add to batch\\n batch_image_meta[b] = image_meta\\n batch_rpn_match[b] = rpn_match[:, np.newaxis]\\n batch_rpn_bbox[b] = rpn_bbox\\n batch_images[b] = mold_image(image.astype(np.float32), config)\\n # NOTE for siamese\\n if config.MODEL == \\\"smrcnn\\\":\\n batch_targets[b] = np.stack([mold_image(target.astype(np.float32), config) for target in targets], axis=0)\\n batch_gt_class_ids[b, :siamese_class_ids.shape[0]] = siamese_class_ids\\n else:\\n batch_gt_class_ids[b, :gt_class_ids.shape[0]] = gt_class_ids\\n batch_gt_boxes[b, :gt_boxes.shape[0]] = gt_boxes\\n batch_gt_rboxes[b, :gt_rboxes.shape[0]] = gt_rboxes\\n batch_gt_masks[b, :, :, :gt_masks.shape[-1]] = gt_masks\\n batch_gt_class_ids2[b, :gt_class_ids2.shape[0]] = gt_class_ids2\\n batch_gt_text_embeds[b, :gt_text_embeds.shape[0], :gt_text_embeds.shape[1]] = gt_text_embeds\\n batch_gt_embed_lengths[b, :gt_embed_lengths.shape[0]] = gt_embed_lengths\\n if random_rois:\\n batch_rpn_rois[b] = rpn_rois\\n if detection_targets:\\n batch_rois[b] = rois\\n batch_mrcnn_class_ids[b] = mrcnn_class_ids\\n batch_mrcnn_bbox[b] = mrcnn_bbox\\n batch_mrcnn_rbbox[b] = mrcnn_rbbox\\n batch_mrcnn_mask[b] = mrcnn_mask\\n batch_mrcnn_class_ids2[b] = mrcnn_class_ids2\\n batch_mrcnn_text_embeds[b] = mrcnn_text_embeds\\n batch_mrcnn_embed_lengths[b] = mrcnn_embed_lengths\\n b += 1\\n # Batch full?\\n if b >= batch_size:\\n \\n\\n # NOTE for siamese\\n if config.MODEL == \\\"smrcnn\\\":\\n inputs = [batch_images, batch_image_meta, batch_targets, batch_rpn_match, batch_rpn_bbox,\\n batch_gt_class_ids, batch_gt_class_ids2, batch_gt_boxes, batch_gt_rboxes, batch_gt_masks,\\n batch_gt_text_embeds, batch_gt_embed_lengths]\\n else:\\n inputs = [batch_images, batch_image_meta, batch_rpn_match, batch_rpn_bbox,\\n batch_gt_class_ids, batch_gt_class_ids2, batch_gt_boxes, batch_gt_rboxes, batch_gt_masks,\\n batch_gt_text_embeds, batch_gt_embed_lengths]\\n outputs = []\\n if random_rois:\\n inputs.extend([batch_rpn_rois])\\n if detection_targets:\\n inputs.extend([batch_rois])\\n # Keras requires that output and targets have the same number of dimensions\\n batch_mrcnn_class_ids = np.expand_dims(batch_mrcnn_class_ids, -1) \\n \\n # ************************* NOTE for 2 label dataset\\n # ************************* NOTE for ocr\\n if config.RBOX and config.READ and config.HAVE_LABEL2:\\n batch_mrcnn_class_ids2 = np.expand_dims(batch_mrcnn_class_ids2, -1)\\n batch_mrcnn_text_embeds = np.expand_dims(batch_mrcnn_text_embeds, -1)\\n batch_mrcnn_embed_lengths = np.expand_dims(batch_mrcnn_embed_lengths, -1)\\n outputs.extend(\\n [batch_mrcnn_class_ids, batch_mrcnn_class_ids2, batch_mrcnn_bbox,\\\\\\n batch_mrcnn_rbbox, batch_mrcnn_mask,\\n batch_mrcnn_text_embeds, batch_mrcnn_embed_lengths])\\n elif config.RBOX and config.READ and not config.HAVE_LABEL2:\\n batch_mrcnn_text_embeds = np.expand_dims(batch_mrcnn_text_embeds, -1)\\n batch_mrcnn_embed_lengths = np.expand_dims(batch_mrcnn_embed_lengths, -1)\\n outputs.extend(\\n [batch_mrcnn_class_ids, batch_mrcnn_bbox, batch_mrcnn_rbbox, batch_mrcnn_mask,\\n batch_mrcnn_text_embeds, batch_mrcnn_embed_lengths])\\n elif config.RBOX and not config.READ and config.HAVE_LABEL2:\\n batch_mrcnn_class_ids2 = np.expand_dims(batch_mrcnn_class_ids2, -1) \\n outputs.extend(\\n [batch_mrcnn_class_ids, batch_mrcnn_class_ids2, batch_mrcnn_bbox,\\\\\\n batch_mrcnn_rbbox, batch_mrcnn_mask])\\n elif config.RBOX and not config.READ and not config.HAVE_LABEL2:\\n outputs.extend(\\n [batch_mrcnn_class_ids, batch_mrcnn_bbox, batch_mrcnn_rbbox, batch_mrcnn_mask])\\n elif not config.RBOX and config.READ and config.HAVE_LABEL2:\\n batch_mrcnn_class_ids2 = np.expand_dims(batch_mrcnn_class_ids2, -1)\\n batch_mrcnn_text_embeds = np.expand_dims(batch_mrcnn_text_embeds, -1)\\n batch_mrcnn_embed_lengths = np.expand_dims(batch_mrcnn_embed_lengths, -1)\\n outputs.extend(\\n [batch_mrcnn_class_ids, batch_mrcnn_class_ids2, batch_mrcnn_bbox,\\\\\\n batch_mrcnn_mask,\\n batch_mrcnn_text_embeds, batch_mrcnn_embed_lengths])\\n elif not config.RBOX and config.READ and not config.HAVE_LABEL2:\\n batch_mrcnn_text_embeds = np.expand_dims(batch_mrcnn_text_embeds, -1)\\n batch_mrcnn_embed_lengths = np.expand_dims(batch_mrcnn_embed_lengths, -1)\\n outputs.extend(\\n [batch_mrcnn_class_ids, batch_mrcnn_bbox, batch_mrcnn_mask,\\n batch_mrcnn_text_embeds, batch_mrcnn_embed_lengths])\\n elif not config.RBOX and not config.READ and config.HAVE_LABEL2:\\n batch_mrcnn_class_ids2 = np.expand_dims(batch_mrcnn_class_ids2, -1) \\n outputs.extend(\\n [batch_mrcnn_class_ids, batch_mrcnn_class_ids2, batch_mrcnn_bbox,\\\\\\n batch_mrcnn_mask])\\n elif not config.RBOX and not config.READ and not config.HAVE_LABEL2:\\n outputs.extend(\\n [batch_mrcnn_class_ids, batch_mrcnn_bbox, batch_mrcnn_mask])\\n\\n yield inputs, outputs\\n\\n # start a new batch\\n b = 0\\n except (GeneratorExit, KeyboardInterrupt):\\n raise\\n except:\\n # Log it and skip the image\\n logging.exception(f\\\"Error processing image {dataset.image_info[image_id]}\\\")\\n error_count += 1\\n if error_count > 5:\\n raise\",\n \"def generate_batch_1(batch_size, img_shape, itm_size, n_itms, prob_type = 'SD'):\\n # np.random.seed(100)\\n # Change `problem_type` to SR for spatial relation labels\\n data_parameters = {'problem_type': prob_type,\\n 'item_size': [itm_size[0],itm_size[1]],\\n 'box_extent': [img_shape[0], img_shape[1]],\\n 'num_items': n_itms,\\n 'num_item_pixel_values': 1,\\n 'SD_portion': 0,\\n 'SR_portion': 1,\\n 'full_size': 2, #whether ground label should be a full-size masked image or concatenated patches from the original image. 0 = merged patches, 1 = masked image, 2 = both\\n 'mask': True, #This parameter is introduced in order to generate label of the image as 1 where patch is and 0 else where.\\n 'display': False}\\n\\n\\n data_generator = psvrt.psvrt(raw_input_size=img_shape, batch_size=batch_size) # Load generator\\n data_generator.initialize_vars(**data_parameters) # Initialize it with image parameters\\n\\n data = data_generator.single_batch() # Fetch a single batch\\n\\n stimuli = np.array(data[0]) # Images\\n labels = np.array(data[1]) # Labels\\n label_positions = np.array(data[2])\\n all_items = np.asarray(data[3])\\n\\n labels_temp = np.array(np.squeeze(labels[:, 0, 0, 0]), np.int64)\\n train_data = np.reshape(stimuli, [stimuli.shape[0], stimuli.shape[1] * stimuli.shape[2] * stimuli.shape[3]])\\n mask_labels = rgb2grey(np.array([items[0] for items in all_items]))\\n\\n ret_lbls = np.zeros([batch_size, 2])\\n indices_1 = np.where(labels_temp == 1)\\n indices_0 = np.where(labels_temp == 0)\\n\\n ret_lbls[indices_0] = [1,0]\\n ret_lbls[indices_1] = [0,1]\\n mask_labels = np.reshape(mask_labels, [mask_labels.shape[0], mask_labels.shape[1] * mask_labels.shape[2]])\\n # left_mask, right_mask = sep_boxes(img_shape, itm_size, n_itms, mask_labels, labels_temp)\\n # left_mask = np.reshape(left_mask, [batch_size,img_shape[0] * img_shape[1]])\\n # right_mask = np.reshape(right_mask, [batch_size, img_shape[0] * img_shape[1]])\\n\\n\\n return train_data, mask_labels, ret_lbls\",\n \"def resnet_6blocks(pretrained=False, **kwargs):\\n return ResnetGenerator(\\n 6, **kwargs\\n )\",\n \"def __init__(self, input_nc, output_nc, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, n_blocks=6,\\n padding_type='reflect'):\\n assert (n_blocks >= 0)\\n super(ResnetGenerator, self).__init__()\\n if type(norm_layer) == functools.partial:\\n use_bias = norm_layer.func == nn.InstanceNorm2d\\n else:\\n use_bias = norm_layer == nn.InstanceNorm2d\\n\\n model = [nn.ReflectionPad2d(3),\\n nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0, bias=use_bias),\\n norm_layer(ngf),\\n nn.ReLU(True)]\\n\\n n_downsampling = 2\\n for i in range(n_downsampling): # add downsampling layers\\n mult = 2 ** i\\n model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3, stride=2, padding=1, bias=use_bias),\\n norm_layer(ngf * mult * 2),\\n nn.ReLU(True)]\\n\\n mult = 2 ** n_downsampling\\n for i in range(n_blocks): # add ResNet blocks\\n\\n model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout,\\n use_bias=use_bias)]\\n\\n for i in range(n_downsampling): # add upsampling layers\\n mult = 2 ** (n_downsampling - i)\\n model += [nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2),\\n kernel_size=3, stride=2,\\n padding=1, output_padding=1,\\n bias=use_bias),\\n norm_layer(int(ngf * mult / 2)),\\n nn.ReLU(True)]\\n model += [nn.ReflectionPad2d(3)]\\n model += [nn.Conv2d(ngf, output_nc, kernel_size=7, padding=0)]\\n # model += [nn.Tanh()]\\n model += [nn.Sigmoid()]\\n\\n self.model = nn.Sequential(*model)\",\n \"def generate_batch(batch_size, img_shape, itm_size, n_itms, prob_type = 'SD'):\\n\\t# Change `problem_type` to SR for spatial relation labels\\n\\tdata_parameters = {'problem_type': prob_type,\\n\\t\\t\\t 'item_size': [itm_size[0],itm_size[1]],\\n\\t\\t\\t 'box_extent': [img_shape[0], img_shape[1]],\\n\\t\\t\\t 'num_items': n_itms,\\n\\t\\t\\t 'num_item_pixel_values': 1,\\n\\t\\t\\t 'SD_portion': 0,\\n\\t\\t\\t 'SR_portion': 1,\\n\\t\\t\\t\\t'full_size': 2, #whether ground label should be a full-size masked image or concatenated patches from the original image. 0 = merged patches, 1 = masked image, 2 = both\\n\\t\\t\\t\\t'mask': True, #This parameter is introduced in order to generate label of the image as 1 where patch is and 0 else where.\\n\\t\\t\\t 'display': False}\\n\\n\\n\\tdata_generator = psvrt.psvrt(raw_input_size=img_shape, batch_size=batch_size) # Load generator\\n\\tdata_generator.initialize_vars(**data_parameters) # Initialize it with image parameters\\n\\n\\tdata = data_generator.single_batch() # Fetch a single batch\\n\\n\\tstimuli = np.array(data[0]) # Images\\n\\tlabels = np.array(data[1]) # Labels\\n\\tlabel_positions = np.array(data[2])\\n\\tall_items = np.asarray(data[3])\\n\\n\\tlabels_temp = np.array(np.squeeze(labels[:, 0, 0, 0]), np.int64)\\n\\ttrain_data = np.reshape(stimuli, [stimuli.shape[0], stimuli.shape[1] * stimuli.shape[2] * stimuli.shape[3]])\\n\\tmask_labels = rgb2grey(np.array([items[0] for items in all_items]))\\n\\n\\tret_lbls = np.zeros([batch_size, 2])\\n\\tindices_1 = np.where(labels_temp == 1)\\n\\tindices_0 = np.where(labels_temp == 0)\\n\\n\\tret_lbls[indices_0] = [1,0]\\n\\tret_lbls[indices_1] = [0,1]\\n\\n\\tleft_mask, right_mask = sep_boxes(img_shape, itm_size, n_itms, mask_labels, labels_temp)\\n\\n\\t\\\"\\\"\\\"This part of the code is written to add 2 dimensions for every pixel, whether that pixel is 0 or 1.\\\"\\\"\\\"\\n\\t# ret_lmask = np.zeros([batch_size, img_shape[0] * img_shape[1], 2])\\n\\t# ret_rmask = np.zeros([batch_size, img_shape[0] * img_shape[1], 2])\\n\\n\\tleft_mask = np.reshape(left_mask, [batch_size,img_shape[0] * img_shape[1]])\\n\\t# indices_lmask_1 = np.where(left_mask == 1)\\n\\t# indices_lmask_0 = np.where(left_mask == 0)\\n\\t#\\n\\t#\\n\\t# ret_lmask[indices_lmask_0] = [1.,0.]\\n\\t# ret_lmask[indices_lmask_1] = [0.,1.]\\n\\n\\t# print(ret_lmask)\\n\\t# left_mask[0, indices_lmask_1] = [0.,1.]\\n\\n\\n\\tright_mask = np.reshape(right_mask, [batch_size, img_shape[0] * img_shape[1]])\\n\\n\\t# indices_rmask_1 = np.where(right_mask == 1)\\n\\t# indices_rmask_0 = np.where(right_mask == 0)\\n\\t#\\n\\t# ret_rmask[indices_rmask_0] = [1.,0.]\\n\\t# ret_rmask[indices_rmask_1] = [0.,1.]\\n\\n\\t# print(left_mask)\\n\\t# print(right_mask)\\n\\n\\treturn train_data, mask_labels, left_mask, right_mask, ret_lbls\",\n \"def generate_images_pred(self, inputs, outputs):\\n for scale in self.scales:\\n disp = outputs[(\\\"disp\\\", scale)]\\n disp = F.interpolate(\\n disp, [self.height, self.width], mode=\\\"bilinear\\\", align_corners=False)\\n source_scale = 0\\n\\n _, depth = disp_to_depth(disp, self.min_depth, self.max_depth)\\n\\n outputs[(\\\"depth\\\", 0, scale)] = depth\\n\\n for i, frame_id in enumerate(self.frame_ids[1:]):\\n\\n T = outputs[(\\\"cam_T_cam\\\", 0, frame_id)]\\n\\n # from the authors of https://arxiv.org/abs/1712.00175\\n # mean-normalized inverse depth from [62] to discourage shrinking of the estimated depth\\n\\n axisangle = outputs[(\\\"axisangle\\\", 0, frame_id)]\\n translation = outputs[(\\\"translation\\\", 0, frame_id)]\\n\\n inv_depth = 1 / depth\\n mean_inv_depth = inv_depth.mean(3, True).mean(2, True)\\n\\n T = transformation_from_parameters(\\n axisangle[:, 0], translation[:, 0] * mean_inv_depth[:, 0], frame_id < 0)\\n\\n cam_points = self.backproject_depth[source_scale](\\n depth, inputs[(\\\"inv_K\\\", source_scale)])\\n pix_coords = self.project_3d[source_scale](\\n cam_points, inputs[(\\\"K\\\", source_scale)], T)\\n\\n outputs[(\\\"sample\\\", frame_id, scale)] = pix_coords\\n\\n outputs[(\\\"color\\\", frame_id, scale)] = F.grid_sample(\\n inputs[(\\\"color\\\", frame_id, source_scale)],\\n outputs[(\\\"sample\\\", frame_id, scale)],\\n padding_mode=\\\"border\\\")\\n\\n outputs[(\\\"color_identity\\\", frame_id, scale)] = \\\\\\n inputs[(\\\"color\\\", frame_id, source_scale)]\",\n \"def _yield_testing(self, batch_index):\\n samples_start = batch_index % self.num_samples\\n samples_end = (batch_index+1) % self.num_samples\\n if samples_start < samples_end:\\n batch_samples = self.test_data[samples_start:samples_end]\\n else:\\n batch_samples = self.test_data[samples_start:]\\n batch_samples.extend(self.test_data[:samples_end])\\n images = []\\n rois = []\\n for sample in batch_samples:\\n # 'sample' has this structure:\\n # {path: {\\n # 'roi_origin_x': test_sample[1]['roi_origin_x'],\\n # 'roi_origin_y': test_sample[1]['roi_origin_y'],\\n # 'roi_width': test_sample[1]['roi_width'],\\n # 'roi_height': test_sample[1]['roi_height'] \\n # } \\n # }\\n img_path = os.path.join(self.dataset_root_path, list(sample.keys())[0])\\n img = cv2.imread(img_path) # watch out for slashes (/)\\n # if the path does not exist or there are problems while reading the image\\n if img is None:\\n print('[DATA LOADER ERROR] cannot find image at path: ', img_path)\\n continue\\n roi_data = list(sample.values())[0]\\n roi = {\\n 'upper_left_x': roi_data['roi_origin_x'],\\n 'upper_left_y': roi_data['roi_origin_y'],\\n 'width': roi_data['roi_width'],\\n 'height': roi_data['roi_height']\\n }\\n img = img.astype('float32')\\n images.append(img)\\n rois.append(roi)\\n return images, rois\",\n \"def preprocess_scans(self, scan_ids, width, height, depth, clipping=True, loop=False,\\n shuffle=False):\\n while True:\\n if shuffle:\\n random.shuffle(scan_ids)\\n for scan_id in scan_ids:\\n ct_scan, origin, spacing = self.get_scan(scan_id, resample=True)\\n if clipping:\\n scan, origin, spacing = self.rescale_scan(\\n ct_scan, origin, spacing, width, height, depth, normalize=True\\n )\\n yield self.clip_scan(scan), origin, spacing\\n else:\\n yield self.rescale_scan(\\n ct_scan, origin, spacing, width, height, depth, normalize=True\\n )\\n if not loop:\\n break\",\n \"def gen_batches_functions(data_folder, image_paths, image_shape, out_shape,\\n label_folder):\\n\\n def get_batches_fn(batch_size):\\n \\\"\\\"\\\"\\n Create batches of training data\\n :param batch_size: Batch Size\\n :return: Batches of training data\\n \\\"\\\"\\\"\\n id_road = 7\\n id_lane = 6\\n id_car = 10\\n\\n for batch_i in range(0, len(image_paths), batch_size):\\n images = []\\n gt_images = []\\n for image_file in image_paths[batch_i:batch_i + batch_size]:\\n # Get corresponding label img path\\n gt_image_file = image_file.replace('CameraRGB', 'CameraSeg')\\n # Read rgb and label images\\n img_in = scipy.misc.imread(image_file, mode='RGB')\\n gt_in = scipy.misc.imread(gt_image_file)\\n # Crop sky part of the image\\n image = img_in[-out_shape[0]:, :]\\n gt_image = gt_in[-out_shape[0]:, :, 0]\\n # Obtain labels\\n gt_road = ((gt_image == id_road) | (gt_image == id_lane))\\n gt_car = (gt_image == id_car)\\n gt_car[-105:, :] = False\\n gt_bg = np.invert(gt_car | gt_road)\\n # Augmentation\\n if bool(random.getrandbits(1)):\\n image, gt_bg, gt_car, gt_road = flip_img(\\n image, gt_bg, gt_car, gt_road)\\n\\n gt_bg = gt_bg.reshape(*gt_bg.shape, 1)\\n gt_car = gt_car.reshape(*gt_car.shape, 1)\\n gt_road = gt_road.reshape(*gt_road.shape, 1)\\n\\n gt_image = np.concatenate((gt_bg, gt_car, gt_road), axis=2)\\n\\n images.append(image)\\n gt_images.append(gt_image)\\n\\n yield np.array(images), np.array(gt_images)\\n\\n return get_batches_fn\",\n \"def _train_aug(self, results):\\n img = results['img']\\n h, w, c = img.shape\\n boxes = results['gt_bboxes']\\n while True:\\n scale = random.choice(self.ratios)\\n new_h = int(self.crop_size[0] * scale)\\n new_w = int(self.crop_size[1] * scale)\\n h_border = self._get_border(self.border, h)\\n w_border = self._get_border(self.border, w)\\n\\n for i in range(50):\\n center_x = random.randint(low=w_border, high=w - w_border)\\n center_y = random.randint(low=h_border, high=h - h_border)\\n\\n cropped_img, border, patch = self._crop_image_and_paste(\\n img, [center_y, center_x], [new_h, new_w])\\n\\n mask = self._filter_boxes(patch, boxes)\\n # if image do not have valid bbox, any crop patch is valid.\\n if not mask.any() and len(boxes) > 0:\\n continue\\n\\n results['img'] = cropped_img\\n results['img_shape'] = cropped_img.shape\\n results['pad_shape'] = cropped_img.shape\\n\\n x0, y0, x1, y1 = patch\\n\\n left_w, top_h = center_x - x0, center_y - y0\\n cropped_center_x, cropped_center_y = new_w // 2, new_h // 2\\n\\n # crop bboxes accordingly and clip to the image boundary\\n for key in results.get('bbox_fields', []):\\n mask = self._filter_boxes(patch, results[key])\\n bboxes = results[key][mask]\\n bboxes[:, 0:4:2] += cropped_center_x - left_w - x0\\n bboxes[:, 1:4:2] += cropped_center_y - top_h - y0\\n if self.bbox_clip_border:\\n bboxes[:, 0:4:2] = np.clip(bboxes[:, 0:4:2], 0, new_w)\\n bboxes[:, 1:4:2] = np.clip(bboxes[:, 1:4:2], 0, new_h)\\n keep = (bboxes[:, 2] > bboxes[:, 0]) & (\\n bboxes[:, 3] > bboxes[:, 1])\\n bboxes = bboxes[keep]\\n results[key] = bboxes\\n if key in ['gt_bboxes']:\\n if 'gt_labels' in results:\\n labels = results['gt_labels'][mask]\\n labels = labels[keep]\\n results['gt_labels'] = labels\\n if 'gt_masks' in results:\\n raise NotImplementedError(\\n 'RandomCenterCropPad only supports bbox.')\\n\\n # crop semantic seg\\n for key in results.get('seg_fields', []):\\n raise NotImplementedError(\\n 'RandomCenterCropPad only supports bbox.')\\n return results\",\n \"def batch_generator(labels_df, set_kind):\\n # Generate training batches\\n if set_kind == \\\"train\\\" and (labels_df.shape[0] == 32384 or labels_df.shape[0] == 3120 or labels_df.shape[0] == 64):\\n while 1:\\n\\n for i in range(labels_df.shape[0]//8):\\n x_train = np.load('data/train-npy/npdatasetX{}.npy'.format(i))\\n y_train = np.load('data/train-npy/npdatasetY{}.npy'.format(i))\\n\\n for j in range(1):\\n x_trainj = x_train[j*8:j*8-1,:]\\n y_trainj = y_train[j*8:j*8-1,:]\\n\\n yield (x_trainj, y_trainj)\\n\\n\\n # Generate validation batches\\n if set_kind == \\\"valid\\\" and (labels_df.shape[0] == 8080 or labels_df.shape[0] == 1920 or labels_df.shape[0] == 8):\\n while 1:\\n\\n for i in range(labels_df.shape[0]//4): \\n x_valid = np.load('data/valid-npy/npdatasetX{}.npy'.format(i))\\n y_valid = np.load('data/valid-npy/npdatasetY{}.npy'.format(i))\\n\\n for j in range(1): \\n x_validj = x_valid[j*4:j*4-1,:]\\n y_validj = y_valid[j*4:j*4-1,:]\\n\\n yield (x_validj, y_validj)\\n\\n\\n # Generate test batches\\n if set_kind == \\\"test\\\" and labels_df.shape[0] == 40669:\\n while 1:\\n\\n for i in range(labels_df.shape[0]//4): #REPLACE 1 by 3\\n x_valid = np.load('data/valid-npy/npdatasetX{}.npy'.format(i))\\n\\n for j in range(1): #REPLACE 2 by 2816\\n x_validj = x_valid[j*4:j*4-1,:]\\n \\n yield (x_validj, y_validj)\\n\\n if set_kind == \\\"test\\\" and (labels_df.shape[0] == 8080 or labels_df.shape[0] == 8):\\n while 1:\\n\\n for i in range(labels_df.shape[0]//8): #REPLACE 1 by 3\\n x_valid = np.load('data/valid-npy/npdatasetX{}.npy'.format(i))\\n\\n for j in range(2): #REPLACE 2 by 2816\\n x_validj = x_valid[j*4:j*4-1,:]\\n\\n yield x_validj\",\n \"def __call__(self, results):\\n\\n if 'img_fields' in results:\\n assert results['img_fields'] == ['img'], \\\\\\n 'Only single img_fields is allowed'\\n img = results['img']\\n assert 'bbox_fields' in results\\n boxes = [results[key] for key in results['bbox_fields']]\\n boxes = np.concatenate(boxes, 0)\\n h, w, c = img.shape\\n while True:\\n mode = random.choice(self.sample_mode)\\n self.mode = mode\\n if mode == 1:\\n return results\\n\\n min_iou = mode\\n for i in range(50):\\n new_w = random.uniform(self.min_crop_size * w, w)\\n new_h = random.uniform(self.min_crop_size * h, h)\\n\\n # h / w in [0.5, 2]\\n if new_h / new_w < 0.5 or new_h / new_w > 2:\\n continue\\n\\n left = random.uniform(w - new_w)\\n top = random.uniform(h - new_h)\\n\\n patch = np.array(\\n (int(left), int(top), int(left + new_w), int(top + new_h)))\\n # Line or point crop is not allowed\\n if patch[2] == patch[0] or patch[3] == patch[1]:\\n continue\\n overlaps = bbox_overlaps(\\n patch.reshape(-1, 4), boxes.reshape(-1, 4)).reshape(-1)\\n if len(overlaps) > 0 and overlaps.min() < min_iou:\\n continue\\n\\n # center of boxes should inside the crop img\\n # only adjust boxes and instance masks when the gt is not empty\\n if len(overlaps) > 0:\\n # adjust boxes\\n def is_center_of_bboxes_in_patch(boxes, patch):\\n center = (boxes[:, :2] + boxes[:, 2:]) / 2\\n mask = ((center[:, 0] > patch[0]) *\\n (center[:, 1] > patch[1]) *\\n (center[:, 0] < patch[2]) *\\n (center[:, 1] < patch[3]))\\n return mask\\n\\n mask = is_center_of_bboxes_in_patch(boxes, patch)\\n if not mask.any():\\n continue\\n for key in results.get('bbox_fields', []):\\n boxes = results[key].copy()\\n mask = is_center_of_bboxes_in_patch(boxes, patch)\\n boxes = boxes[mask]\\n if self.bbox_clip_border:\\n boxes[:, 2:] = boxes[:, 2:].clip(max=patch[2:])\\n boxes[:, :2] = boxes[:, :2].clip(min=patch[:2])\\n boxes -= np.tile(patch[:2], 2)\\n\\n results[key] = boxes\\n # labels\\n label_key = self.bbox2label.get(key)\\n if label_key in results:\\n results[label_key] = results[label_key][mask]\\n\\n # mask fields\\n mask_key = self.bbox2mask.get(key)\\n if mask_key in results:\\n results[mask_key] = results[mask_key][\\n mask.nonzero()[0]].crop(patch)\\n # adjust the img no matter whether the gt is empty before crop\\n img = img[patch[1]:patch[3], patch[0]:patch[2]]\\n results['img'] = img\\n results['img_shape'] = img.shape\\n\\n # seg fields\\n for key in results.get('seg_fields', []):\\n results[key] = results[key][patch[1]:patch[3],\\n patch[0]:patch[2]]\\n return results\",\n \"def train_batches_with_generated_images(gen, x_train_input, X_train, disc_batch_size):\\n # output of gen is input of disc\\n image_input_batch = x_train_input[np.random.randint(0, X_train.shape[0], size=disc_batch_size), :, :, :]\\n noise_X = np.random.uniform(0, 1, size=[disc_batch_size, 100])\\n generated_images = gen.predict([image_input_batch, noise_X])\\n train_batches(0)\",\n \"def _get_train_generator(self):\\n while(True):\\n random.shuffle(self.train)\\n for data_element in self.train:\\n if self.debug: \\n print(\\\"training on: {}\\\".format(data_element))\\n\\n image, heatmap = self._generate_input_tuple(data_element)\\n\\n if self.debug: \\n print(\\\"yields: {}\\\".format(data_element))\\n\\n yield (image, heatmap)\",\n \"def rand_crop_liver(image, label, res_s, out_s,\\n apply_data_aug, augment_times=54):\\n if image.shape != (res_s, res_s, res_s) or \\\\\\n label.shape != (res_s, res_s, res_s):\\n logging.info(\\\"Unexpected shapes. \\\"\\n \\\"image.shape: %s, label.shape: %s\\\",\\n image.shape, label.shape)\\n return\\n\\n rough_liver_label = 1\\n x, y, z = np.where(label == rough_liver_label)\\n bbox_center = [(x.min() + x.max()) // 2,\\n (y.min() + y.max()) // 2,\\n (z.min() + z.max()) // 2]\\n\\n def in_range_check(c):\\n c = max(c, out_s // 2)\\n c = min(c, res_s - out_s // 2)\\n return c\\n\\n for _ in range(augment_times):\\n rand_c = []\\n for c in bbox_center:\\n sigma = out_s // 6\\n truncate_rad = out_s // 4\\n c += np.clip(np.random.randn() * sigma, -truncate_rad, truncate_rad)\\n rand_c.append(int(in_range_check(c)))\\n\\n image_aug = image[rand_c[0] - out_s // 2:rand_c[0] + out_s // 2,\\n rand_c[1] - out_s // 2:rand_c[1] + out_s // 2,\\n rand_c[2] - out_s // 2:rand_c[2] + out_s // 2].copy()\\n label_aug = label[rand_c[0] - out_s // 2:rand_c[0] + out_s // 2,\\n rand_c[1] - out_s // 2:rand_c[1] + out_s // 2,\\n rand_c[2] - out_s // 2:rand_c[2] + out_s // 2].copy()\\n\\n if apply_data_aug:\\n image_aug = intensity_change(image_aug)\\n\\n yield image_aug, label_aug\",\n \"def generate_batch_1(batch_size, img_shape, itm_size, n_itms, prob_type = 'SD'):\\n\\t# np.random.seed(100)\\n\\t# Change `problem_type` to SR for spatial relation labels\\n\\tdata_parameters = {'problem_type': prob_type,\\n\\t\\t\\t 'item_size': [itm_size[0],itm_size[1]],\\n\\t\\t\\t 'box_extent': [img_shape[0], img_shape[1]],\\n\\t\\t\\t 'num_items': n_itms,\\n\\t\\t\\t 'num_item_pixel_values': 1,\\n\\t\\t\\t 'SD_portion': 0,\\n\\t\\t\\t 'SR_portion': 1,\\n\\t\\t\\t\\t'full_size': 2, #whether ground label should be a full-size masked image or concatenated patches from the original image. 0 = merged patches, 1 = masked image, 2 = both\\n\\t\\t\\t\\t'mask': True, #This parameter is introduced in order to generate label of the image as 1 where patch is and 0 else where.\\n\\t\\t\\t 'display': False}\\n\\n\\n\\tdata_generator = psvrt.psvrt(raw_input_size=img_shape, batch_size=batch_size) # Load generator\\n\\tdata_generator.initialize_vars(**data_parameters) # Initialize it with image parameters\\n\\n\\tdata = data_generator.single_batch() # Fetch a single batch\\n\\n\\tstimuli = np.array(data[0]) # Images\\n\\tlabels = np.array(data[1]) # Labels\\n\\tlabel_positions = np.array(data[2])\\n\\tall_items = np.asarray(data[3])\\n\\n\\tlabels_temp = np.array(np.squeeze(labels[:, 0, 0, 0]), np.int64)\\n\\ttrain_data = np.reshape(stimuli, [stimuli.shape[0], stimuli.shape[1] * stimuli.shape[2] * stimuli.shape[3]])\\n\\tmask_labels = rgb2grey(np.array([items[0] for items in all_items]))\\n\\n\\tret_lbls = np.zeros([batch_size, 2])\\n\\tindices_1 = np.where(labels_temp == 1)\\n\\tindices_0 = np.where(labels_temp == 0)\\n\\n\\tret_lbls[indices_0] = [1,0]\\n\\tret_lbls[indices_1] = [0,1]\\n\\tmask_labels = np.reshape(mask_labels, [mask_labels.shape[0], mask_labels.shape[1] * mask_labels.shape[2]])\\n\\t# left_mask, right_mask = sep_boxes(img_shape, itm_size, n_itms, mask_labels, labels_temp)\\n\\t# left_mask = np.reshape(left_mask, [batch_size,img_shape[0] * img_shape[1]])\\n\\t# right_mask = np.reshape(right_mask, [batch_size, img_shape[0] * img_shape[1]])\\n\\n\\n\\treturn train_data, mask_labels, ret_lbls\",\n \"def resnet_v1_generator(block_fn,\\n num_blocks,\\n num_classes,\\n pruning_method='baseline',\\n init_method='baseline',\\n width=1.,\\n prune_first_layer=True,\\n prune_last_layer=True,\\n data_format='channels_first',\\n end_sparsity=0.,\\n weight_decay=0.,\\n name=None):\\n\\n def model(inputs, is_training):\\n \\\"\\\"\\\"Creation of the model graph.\\\"\\\"\\\"\\n with tf.variable_scope(name, 'resnet_model'):\\n inputs = conv2d_fixed_padding(\\n inputs=inputs,\\n filters=int(64 * width),\\n kernel_size=7,\\n strides=2,\\n pruning_method=pruning_method if prune_first_layer else 'baseline',\\n init_method=init_method if prune_first_layer else 'baseline',\\n data_format=data_format,\\n end_sparsity=end_sparsity,\\n weight_decay=weight_decay,\\n name='initial_conv')\\n\\n inputs = tf.identity(inputs, 'initial_conv')\\n inputs = batch_norm_relu(\\n inputs, is_training, data_format=data_format)\\n\\n inputs = tf.layers.max_pooling2d(\\n inputs=inputs,\\n pool_size=3,\\n strides=2,\\n padding='SAME',\\n data_format=data_format,\\n name='initial_max_pool')\\n inputs = tf.identity(inputs, 'initial_max_pool')\\n\\n inputs = block_group(\\n inputs=inputs,\\n filters=int(64 * width),\\n block_fn=block_fn,\\n blocks=num_blocks[0],\\n strides=1,\\n is_training=is_training,\\n name='block_group1',\\n pruning_method=pruning_method,\\n init_method=init_method,\\n data_format=data_format,\\n end_sparsity=end_sparsity,\\n weight_decay=weight_decay)\\n inputs = block_group(\\n inputs=inputs,\\n filters=int(128 * width),\\n block_fn=block_fn,\\n blocks=num_blocks[1],\\n strides=2,\\n is_training=is_training,\\n name='block_group2',\\n pruning_method=pruning_method,\\n init_method=init_method,\\n data_format=data_format,\\n end_sparsity=end_sparsity,\\n weight_decay=weight_decay)\\n inputs = block_group(\\n inputs=inputs,\\n filters=int(256 * width),\\n block_fn=block_fn,\\n blocks=num_blocks[2],\\n strides=2,\\n is_training=is_training,\\n name='block_group3',\\n pruning_method=pruning_method,\\n init_method=init_method,\\n data_format=data_format,\\n end_sparsity=end_sparsity,\\n weight_decay=weight_decay)\\n inputs = block_group(\\n inputs=inputs,\\n filters=int(512 * width),\\n block_fn=block_fn,\\n blocks=num_blocks[3],\\n strides=2,\\n is_training=is_training,\\n name='block_group4',\\n pruning_method=pruning_method,\\n init_method=init_method,\\n data_format=data_format,\\n end_sparsity=end_sparsity,\\n weight_decay=weight_decay)\\n\\n pool_size = (inputs.shape[1], inputs.shape[2])\\n inputs = tf.layers.average_pooling2d(\\n inputs=inputs,\\n pool_size=pool_size,\\n strides=1,\\n padding='VALID',\\n data_format=data_format,\\n name='final_avg_pool')\\n inputs = tf.identity(inputs, 'final_avg_pool')\\n multiplier = 4 if block_fn is bottleneck_block_ else 1\\n fc_units = multiplier * int(512 * width)\\n inputs = tf.reshape(inputs, [-1, fc_units])\\n kernel_initializer = tf.random_normal_initializer(stddev=.01)\\n # If init_method==sparse and not pruning, skip.\\n if init_method != 'sparse' or prune_last_layer:\\n kernel_initializer = _pick_initializer(kernel_initializer, init_method,\\n pruning_method, end_sparsity)\\n kernel_regularizer = contrib_layers.l2_regularizer(weight_decay)\\n inputs = sparse_fully_connected(\\n x=inputs,\\n units=num_classes,\\n sparsity_technique=pruning_method if prune_last_layer else 'baseline',\\n kernel_initializer=kernel_initializer,\\n kernel_regularizer=kernel_regularizer,\\n name='final_dense')\\n\\n inputs = tf.identity(inputs, 'final_dense')\\n return inputs\\n\\n model.default_image_size = 224\\n return model\",\n \"def patchGenerator(gen, patch_size=128, patch_batch_size=1):\\n \\n for imgs, masks in gen: # For each batch\\n img_list = []\\n mask_list = []\\n for i in range(0, imgs.shape[0]): # For each image in a batch\\n patch_x = patchify(imgs[i], (patch_size, patch_size, imgs[i].shape[-1]), step=patch_size) # split image into 4*4 small 128*128 patches.\\n img_p = patch_x.reshape(-1, *patch_x.shape[-3:])\\n img_list.append(img_p)\\n\\n mask_y = patchify(masks[i], (patch_size, patch_size, 1), step=patch_size) # split mask into 4*4 small 128*128 patches.\\n mask_p = mask_y.reshape(-1, *mask_y.shape[-3:])\\n mask_list.append(mask_p)\\n \\n if (patch_batch_size == 1):\\n for j in range(0, img_p.shape[0]): # For each patch in a image\\n yield img_p[j][np.newaxis, :], mask_p[j][np.newaxis, :]\\n \\n if (patch_batch_size > 1):\\n image_patches = np.concatenate(img_list)\\n mask_patches = np.concatenate(mask_list)\\n patch_batch_counter = 0\\n for idx in range(0, patch_batch_size):\\n image_patch_batch = image_patches[patch_batch_counter:patch_batch_counter + patch_batch_size]\\n mask_patch_batch = mask_patches[patch_batch_counter:patch_batch_counter + patch_batch_size]\\n shuffled_images, shuffled_masks = randomize(image_patch_batch, mask_patch_batch)\\n yield shuffled_images, shuffled_masks\",\n \"def trainingBatchGenerator(data_folder, image_shape):\\n def get_batches_fn(batch_size):\\n \\\"\\\"\\\"\\n Create batches of training data\\n :param batch_size: Batch Size\\n :return: Batches of training data\\n \\\"\\\"\\\"\\n image_paths = glob(os.path.join(data_folder, 'image_2', '*.png'))\\n label_paths = {\\n re.sub(r'_(lane|road)_', '_', os.path.basename(path)): path\\n for path in glob(os.path.join(data_folder, 'gt_image_2', '*_road_*.png'))}\\n background_color = np.array([255, 0, 0])\\n\\n random.shuffle(image_paths)\\n for batch_i in range(0, len(image_paths), batch_size):\\n images = []\\n gt_images = []\\n for image_file in image_paths[batch_i:batch_i+batch_size]:\\n gt_image_file = label_paths[os.path.basename(image_file)]\\n\\n image = scipy.misc.imresize(scipy.misc.imread(image_file), image_shape)\\n gt_image = scipy.misc.imresize(scipy.misc.imread(gt_image_file), image_shape)\\n\\n gt_bg = np.all(gt_image == background_color, axis=2)\\n gt_bg = gt_bg.reshape(*gt_bg.shape, 1)\\n gt_image = np.concatenate((gt_bg, np.invert(gt_bg)), axis=2)\\n\\n images.append(image)\\n gt_images.append(gt_image)\\n\\n yield np.array(images), np.array(gt_images)\\n return get_batches_fn\",\n \"def generate_images(self, count):\\n # Generate images from the currently loaded model\\n noise = np.random.normal(0, 1, (count, self.dimensions_noise))\\n return self.generator.predict(noise)\",\n \"def generator(samples, batch_size=32):\\n num_samples = len(samples)\\n while 1: # Loop forever so the generator never terminates\\n sklearn.utils.shuffle(samples)\\n for offset in range(0, num_samples, batch_size):\\n batch_samples = samples[offset:offset+batch_size]\\n images = []\\n angles = []\\n for batch_sample in batch_samples:\\n # append center image\\n name = 'Sample_data/IMG/'+batch_sample[0].split('/')[-1]\\n center_image = cv2.imread(name)\\n center_angle = float(batch_sample[3])\\n images.append(center_image)\\n angles.append(center_angle)\\n correction = 0.30 # shift angle commands\\n # append left camera image\\n left_angle = center_angle + correction\\n lname = 'Sample_data/IMG/'+batch_sample[1].split('/')[-1]\\n left_image = cv2.imread(lname)\\n images.append(left_image)\\n angles.append(left_angle)\\n \\n # append right camera image\\n right_angle = center_angle + correction\\n rname = 'Sample_data/IMG/'+batch_sample[1].split('/')[-1]\\n right_image = cv2.imread(rname)\\n images.append(right_image)\\n angles.append(right_angle)\\n\\n # flip image to augment data\\n Nsample = len(angles)\\n for i in range(len(angles)):\\n images.append(np.fliplr(images[i]))\\n angles.append(-angles[i])\\n\\n # trim image to only see section with road\\n X_train = np.array(images)\\n y_train = np.array(angles)\\n yield sklearn.utils.shuffle(X_train, y_train)\",\n \"def make_generators():\\n \\n # All images will be rescaled by 1./255\\n train_datagen = ImageDataGenerator(rescale=1./255)\\n test_datagen = ImageDataGenerator(rescale=1./255)\\n\\n \\n train_generator = train_datagen.flow_from_directory(\\n TRAIN_DATA_PATH,\\n target_size= (150, 150),\\n batch_size= 20,\\n class_mode= 'sparse')\\n\\n validation_generator = test_datagen.flow_from_directory(\\n VAL_DATA_PATH,\\n target_size= (150, 150),\\n batch_size= 20,\\n class_mode= 'sparse')\\n\\n return train_generator, validation_generator\",\n \"def generate_examples(gen, truncation=0.7, n=100):\\n gen.eval()\\n alpha = 1.0\\n for i in range(n):\\n with torch.no_grad():\\n noise = torch.tensor(truncnorm.rvs(-truncation, truncation, size=(1, config.Z_DIM, 1, 1)), device=config.DEVICE, dtype=torch.float32)\\n img = gen(noise, alpha, 279)\\n save_image(img*0.5+0.5, f\\\"saved_examples/{i+2000}.jpg\\\")\",\n \"def __init__(self, input_nc, output_nc, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, padding_type='zero'):\\n super(ResnetGenerator, self).__init__()\\n use_bias = True\\n\\n model = [nn.ReflectionPad2d(3),\\n nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0, bias=use_bias),\\n norm_layer(ngf),\\n nn.ReLU(True)]\\n\\n n_downsampling = 2\\n for i in range(n_downsampling): # add downsampling layers\\n mult = 2 ** i\\n model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3, stride=2, padding=1, bias=use_bias),\\n norm_layer(ngf * mult * 2),\\n nn.ReLU(True)]\\n\\n mult = 2 ** n_downsampling\\n for i in range(9): # add ResNet blocks\\n\\n model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout, use_bias=use_bias)]\\n\\n for i in range(n_downsampling): # add upsampling layers\\n mult = 2 ** (n_downsampling - i)\\n model += [nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2),\\n kernel_size=3, stride=2,\\n padding=1, output_padding=1,\\n bias=use_bias),\\n norm_layer(int(ngf * mult / 2)),\\n nn.ReLU(True)]\\n model += [nn.ReflectionPad2d(3)]\\n model += [nn.Conv2d(ngf, output_nc, kernel_size=7, padding=0)]\\n model += [nn.Tanh()]\\n\\n self.model = nn.Sequential(*model)\",\n \"def get_training_examples(self, n: int = None, apply_representations: bool = True):\\n pass\",\n \"def generate(self):\\n z_sample = np.random.normal(0, 1,[self.batch_size, self.n_z])\\n gen_images = self.sess.run(self.gen_img, feed_dict={self.z: z_sample})\\n return gen_images\",\n \"def build_generator(self):\\n\\n def _make_divisible(v, divisor, min_value=None):\\n if min_value is None:\\n min_value = divisor\\n new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)\\n # Make sure that round down does not go down by more than 10%.\\n if new_v < 0.9 * v:\\n new_v += divisor\\n return new_v\\n\\n def residual_block(inputs, filters, block_id, expansion=6, stride=1, alpha=1.0):\\n \\n channel_axis = 1 if tf.keras.backend.image_data_format() == 'channels_first' else -1\\n\\n in_channels = tf.keras.backend.int_shape(inputs)[channel_axis]\\n pointwise_conv_filters = int(filters * alpha)\\n pointwise_filters = _make_divisible(pointwise_conv_filters, 8)\\n x = inputs\\n prefix = 'block_{}_'.format(block_id)\\n\\n if block_id:\\n # Expand\\n x = tf.keras.layers.Conv2D(expansion * in_channels,\\n kernel_size=1,\\n padding='same',\\n use_bias=True,\\n activation=None,\\n name=prefix + 'expand')(x)\\n x = tf.keras.layers.BatchNormalization(axis=channel_axis,\\n epsilon=1e-3,\\n momentum=0.999,\\n name=prefix + 'expand_BN')(x)\\n x = tf.keras.layers.Activation('relu', name=prefix + 'expand_relu')(x)\\n else:\\n prefix = 'expanded_conv_'\\n\\n # Depthwise\\n x = tf.keras.layers.DepthwiseConv2D(kernel_size=3,\\n strides=stride,\\n activation=None,\\n use_bias=True,\\n padding='same' if stride == 1 else 'valid',\\n name=prefix + 'depthwise')(x)\\n x = tf.keras.layers.BatchNormalization(axis=channel_axis,\\n epsilon=1e-3,\\n momentum=0.999,\\n name=prefix + 'depthwise_BN')(x)\\n\\n x = tf.keras.layers.Activation('relu', name=prefix + 'depthwise_relu')(x)\\n\\n # Project\\n x = tf.keras.layers.Conv2D(pointwise_filters,\\n kernel_size=1,\\n padding='same',\\n use_bias=True,\\n activation=None,\\n name=prefix + 'project')(x)\\n x = tf.keras.layers.BatchNormalization(axis=channel_axis,\\n epsilon=1e-3,\\n momentum=0.999,\\n name=prefix + 'project_BN')(x)\\n\\n if in_channels == pointwise_filters and stride == 1:\\n return tf.keras.layers.Add(name=prefix + 'add')([inputs, x])\\n return x\\n\\n def deconv2d(layer_input):\\n\\n u = tf.keras.layers.UpSampling2D(size=2, interpolation='bilinear')(layer_input)\\n u = tf.keras.layers.Conv2D(self.gf, kernel_size=3, strides=1, padding='same')(u)\\n u = tf.keras.layers.PReLU(shared_axes=[1, 2])(u)\\n return u\\n\\n # Low resolution image input\\n img_lr = tf.keras.Input(shape=self.lr_shape)\\n\\n # Pre-residual block\\n c1 = tf.keras.layers.Conv2D(self.gf, kernel_size=3, strides=1, padding='same')(img_lr)\\n c1 = tf.keras.layers.BatchNormalization()(c1)\\n c1 = tf.keras.layers.PReLU(shared_axes=[1, 2])(c1)\\n\\n # Propogate through residual blocks\\n r = residual_block(c1, self.gf, 0)\\n for idx in range(1, self.n_residual_blocks):\\n r = residual_block(r, self.gf, idx)\\n\\n # Post-residual block\\n c2 = tf.keras.layers.Conv2D(self.gf, kernel_size=3, strides=1, padding='same')(r)\\n c2 = tf.keras.layers.BatchNormalization()(c2)\\n c2 = tf.keras.layers.Add()([c2, c1])\\n \\n # Upsampling\\n u1 = deconv2d(c2)\\n u2 = deconv2d(u1)\\n\\n # Generate high resolution output\\n gen_hr = tf.keras.layers.Conv2D(3, kernel_size=3, strides=1, padding='same', activation='tanh')(u2)\\n\\n return tf.keras.models.Model(img_lr, gen_hr)\",\n \"def process_train_set(hdf5_file, train_archive, patch_archive, n_train,\\n wnid_map, shuffle_seed=None):\\n producer = partial(train_set_producer, train_archive=train_archive,\\n patch_archive=patch_archive, wnid_map=wnid_map)\\n consumer = partial(image_consumer, hdf5_file=hdf5_file,\\n num_expected=n_train, shuffle_seed=shuffle_seed)\\n producer_consumer(producer, consumer)\",\n \"def n_random_crop(img, height, width, n):\\n crops = []\\n img_width, img_height = img.shape\\n for i in range(n):\\n x = np.random.randint(0, img_width - width)\\n y = np.random.randint(0, img_height - height)\\n crops.append(img[x:x + height, y:y + width])\\n return np.array(crops)\",\n \"def get_one_shot_batch(self, support_set_size, is_validation):\\n\\n # Set some variables that will be different for validation and evaluation sets\\n if is_validation:\\n alphabets = self._validation_alphabets\\n current_alphabet_index = self._current_validation_alphabet_index\\n image_folder_name = 'images_background'\\n dictionary = self.train_dictionary\\n else:\\n alphabets = self._evaluation_alphabets\\n current_alphabet_index = self._current_evaluation_alphabet_index\\n image_folder_name = 'images_evaluation'\\n dictionary = self.evaluation_dictionary\\n\\n current_alphabet = alphabets[current_alphabet_index]\\n available_characters = list(dictionary[current_alphabet].keys())\\n number_of_characters = len(available_characters)\\n\\n bacth_images_path = []\\n\\n test_character_index = random.sample(\\n range(0, number_of_characters), 1)\\n\\n # Get test image\\n current_character = available_characters[test_character_index[0]]\\n\\n available_images = (dictionary[current_alphabet])[current_character]\\n\\n image_indexes = random.sample(range(0, 20), 2)\\n image_path = os.path.join(\\n self.dataset_path, image_folder_name, current_alphabet, current_character)\\n\\n test_image = os.path.join(\\n image_path, available_images[image_indexes[0]])\\n bacth_images_path.append(test_image)\\n image = os.path.join(\\n image_path, available_images[image_indexes[1]])\\n bacth_images_path.append(image)\\n\\n # Let's get our test image and a pair corresponding to\\n if support_set_size == -1:\\n number_of_support_characters = number_of_characters\\n else:\\n number_of_support_characters = support_set_size\\n\\n different_characters = available_characters[:]\\n different_characters.pop(test_character_index[0])\\n\\n # There may be some alphabets with less than 20 characters\\n if number_of_characters < number_of_support_characters:\\n number_of_support_characters = number_of_characters\\n\\n support_characters_indexes = random.sample(\\n range(0, number_of_characters - 1), number_of_support_characters - 1)\\n\\n for index in support_characters_indexes:\\n current_character = different_characters[index]\\n available_images = (dictionary[current_alphabet])[\\n current_character]\\n image_path = os.path.join(\\n self.dataset_path, image_folder_name, current_alphabet, current_character)\\n\\n image_indexes = random.sample(range(0, 20), 1)\\n image = os.path.join(\\n image_path, available_images[image_indexes[0]])\\n bacth_images_path.append(test_image)\\n bacth_images_path.append(image)\\n\\n images, labels = self._convert_path_list_to_images_and_labels(\\n bacth_images_path, is_one_shot_task=True)\\n\\n return images, labels\",\n \"def get_test_and_valid_generator(valid_df, test_df, train_df, image_dir, x_col, y_cols, sample_size=500, batch_size=32,\\r\\n seed=1, target_w=256, target_h=256):\\r\\n # print(\\\"getting train and valid generators...\\\")\\r\\n # # get generator to sample dataset\\r\\n # raw_train_generator = ImageDataGenerator().flow_from_dataframe(\\r\\n # dataframe=train_df,\\r\\n # directory=image_dir,\\r\\n # x_col=x_col,\\r\\n # y_col=y_cols,\\r\\n # class_mode=\\\"raw\\\",\\r\\n # batch_size=sample_size,\\r\\n # color_mode='grayscale',\\r\\n # shuffle=True,\\r\\n # target_size=(target_w, target_h))\\r\\n #\\r\\n # # get data sample\\r\\n # batch = raw_train_generator.next()\\r\\n # data_sample = batch[0]\\r\\n #\\r\\n # # use sample to fit mean and std for test set generator\\r\\n # image_generator = ImageDataGenerator(\\r\\n # featurewise_center=True,\\r\\n # featurewise_std_normalization=True)\\r\\n\\r\\n # # fit generator to sample from training data\\r\\n # image_generator.fit(data_sample)\\r\\n # print('Data Generator mean=%.3f, std=%.3f' % (image_generator.mean, image_generator.std))\\r\\n\\r\\n # Add this to output the values to a json file\\r\\n # print(\\\"[INFO] serializing means...\\\")\\r\\n # D = {\\\"R\\\": np.mean(R), \\\"G\\\": np.mean(G), \\\"B\\\": np.mean(B)}\\r\\n # f = open(config.DATASET_MEAN, \\\"w\\\")\\r\\n # f.write(json.dumps(D))\\r\\n # f.close()\\r\\n\\r\\n image_generator = ImageDataGenerator(rescale=1.0/255.0)\\r\\n\\r\\n # get test generator\\r\\n valid_generator = image_generator.flow_from_dataframe(\\r\\n dataframe=valid_df,\\r\\n directory=image_dir,\\r\\n x_col=x_col,\\r\\n y_col=y_cols,\\r\\n class_mode=\\\"raw\\\",\\r\\n batch_size=batch_size,\\r\\n shuffle=False,\\r\\n color_mode='grayscale',\\r\\n seed=seed,\\r\\n target_size=(target_w, target_h))\\r\\n\\r\\n test_generator = image_generator.flow_from_dataframe(\\r\\n dataframe=test_df,\\r\\n directory=image_dir,\\r\\n x_col=x_col,\\r\\n y_col=y_cols,\\r\\n class_mode=\\\"raw\\\",\\r\\n batch_size=6000,\\r\\n color_mode='grayscale',\\r\\n shuffle=False,\\r\\n seed=seed,\\r\\n target_size=(target_w, target_h))\\r\\n return valid_generator, test_generator\",\n \"def representations_sample(self, n=()):\\n self.assert_sampled()\\n return [\\n z.sample(sample_shape=n, seed=self.randint).numpy()\\n for z in self.representations\\n ]\",\n \"def run_cropping(self, list_of_files, overwrite_existing=False, output_folder=None):\\n if output_folder is not None:\\n self.output_folder = output_folder\\n\\n output_folder_gt = os.path.join(self.output_folder, \\\"gt_segmentations\\\")\\n maybe_mkdir_p(output_folder_gt)\\n for j, case in enumerate(list_of_files):\\n if case[-1] is not None:\\n shutil.copy(case[-1], output_folder_gt)\\n\\n list_of_args = []\\n for j, case in enumerate(list_of_files):\\n case_identifier = get_case_identifier(case)\\n list_of_args.append((case, case_identifier, overwrite_existing))\\n\\n p = Pool(self.num_threads)\\n p.starmap(self.load_crop_save, list_of_args)\\n p.close()\\n p.join()\",\n \"def gen_test_output(sess, logits, keep_prob, image_pl, data_folder, image_shape, samples_limit=None):\\n\\n image_paths = glob(os.path.join(data_folder, 'image_2', '*.png'))\\n\\n if samples_limit:\\n image_paths = image_paths[0:samples_limit]\\n\\n for image_file in tqdm(image_paths, desc='Processing: ', unit='images', total=len(image_paths)):\\n yield process_image_file(image_file, sess, logits, keep_prob, image_pl, image_shape)\",\n \"def next(self):\\n\\n if self.index - self.batch_size <= 0:\\n if not self.repeater:\\n raise StopIteration\\n else:\\n self.index = self.dataset.shape[0] - 1\\n self.index = self.index - self.batch_size\\n\\n # loading features(images)\\n features = imread(self.dataset.loc[:, 'image'].iat[0])[:, :, :3]\\n\\n if self.output_shape is None:\\n output_shape = features.shape[:2]\\n else:\\n output_shape = self.output_shape\\n\\n # 1) Resize image to match a certain size.\\n # 2) Also the input image is converted (from 8-bit integer)\\n # to 64-bit floating point(->preserve_range=False).\\n # 3) [:, :, :3] -> to remove 4th channel in png\\n features = np.array([\\n resize(image=imread(self.dataset.loc[:, 'image'].iat[i])[:, :, :3],\\n output_shape=output_shape,\\n mode='constant',\\n preserve_range=False,\\n anti_aliasing=True)\\n for i in range(self.index, self.index + self.batch_size)\\n ])\\n\\n if self.data_type is 'float32':\\n features = img_as_float32(features)\\n\\n # loading labels(segmentation)\\n if 'segmentation' in self.label_type:\\n # 1) Resize segmentation to match a certain size.\\n # 2) [:, :, :3] -> to remove 4th channel in png\\n segmentation = np.array([\\n imread(self.dataset.loc[:, 'segmentation'].iat[i])[:, :, :3]\\n for i in range(self.index, self.index + self.batch_size)\\n ])\\n\\n # resize(image=,\\n # output_shape=output_shape,\\n # mode='constant',\\n # preserve_range=True,\\n # anti_aliasing=True)\\n\\n # new_segmentation = np.zeros(\\n # shape=(self.batch_size, output_shape[0], output_shape[1],\\n # len(self.seg_dic)))\\n # for i in range(self.batch_size):\\n # for j in range(output_shape[0]):\\n # for k in range(output_shape[1]):\\n # new_segmentation[i, j, k,\\n # self.seg_dic[\\n # tuple(segmentation[i, j, k]) ][0]] = 1\\n # segmentation = new_segmentation\\n\\n if self.data_type is 'float32':\\n segmentation = img_as_float32(segmentation)\\n else:\\n segmentation = img_as_float64(segmentation)\\n\\n # if self.label_type == 'depth':\\n # labels = np.array(\\n # np.array([\\n # resize(\\n # image=imread(self.dataset.iloc[i, 1]),\\n # output_shape=(480, 640))\\n # for i in range(self.index, self.index + self.batch_size)\\n # ]),\\n # dtype=np.int32)\\n # labels = (labels[:, :, :, 0] + labels[:, :, :, 1] * 256 +\\n # labels[:, :, :, 2] * 256 * 256) / ((256 * 256 * 256) - 1)\\n\\n # elif self.label_type == 'segmentation':\\n # labels = np.array(\\n # np.array([\\n # resize(\\n # image=imread(self.dataset.iloc[i, 2])[:, :, 0],\\n # output_shape=(480, 640))\\n # for i in range(self.index, self.index + self.batch_size)\\n # ]))\\n\\n # new_segmentation = np.ndarray(shape=(self.batch_size, 480, 640, 22))\\n # for i in range(self.batch_size):\\n # for j in range(480):\\n # for k in range(640):\\n # if labels[i, j, k] < 22:\\n # new_segmentation[i, j, k, int(labels[i, j, k])] = 1\\n # labels = new_segmentation\\n # labels = np.array(labels, dtype=np.float32)\\n # else:\\n # raise ValueError('invalid label type')\\n\\n # return features, labels\\n return features, segmentation\",\n \"def _get_test_generator(self):\\n for data_element in self.test:\\n image, heatmap = self._generate_input_tuple(data_element)\\n \\n yield (image, heatmap)\",\n \"def image_generator_not_random(list_of_files, crop_size=320, scale=1):\\n while True:\\n text_region = []\\n for jpgname in list_of_files:\\n print jpgname\\n # jpgname = np.random.choice(list_of_files)\\n img = cv2.imread(jpgname)\\n pattern = re.compile('jpg')\\n txtname = pattern.sub('txt', jpgname)\\n if not os.path.isfile(txtname):\\n continue\\n cropped_image = img\\n with open(txtname, 'r') as f:\\n for line in f:\\n line_split = line.strip().split(',')\\n print line_split\\n # clockwise\\n (x1, y1, x2, y2) = line_split[0:4]\\n (x3, y3, x4, y4) = line_split[4:8]\\n text_region.append([string.atof(x1), string.atof(y1), string.atof(x2), string.atof(y2),\\n string.atof(x3), string.atof(y3), string.atof(x4), string.atof(y4)])\\n if cropped_image is None or text_region is None or \\\\\\n cropped_image.shape[0] != crop_size or cropped_image.shape[1] != crop_size:\\n continue\\n yield [scale * cropped_image, text_region]\",\n \"def cropNwriteBBs(img, digitCnts,writeToFile=False,folderName='outcome',cropW=20,cropH=30):\\r\\n d = 0\\r\\n for contour in digitCnts:\\r\\n # https://stackoverflow.com/questions/50331025/how-to-crop-a-bounding-box-out-of-an-image\\r\\n (x, y, w, h) = cv2.boundingRect(contour)\\r\\n\\r\\n ext_left = tuple(contour[contour[:, :, 0].argmin()][0])\\r\\n ext_right = tuple(contour[contour[:, :, 0].argmax()][0])\\r\\n ext_top = tuple(contour[contour[:, :, 1].argmin()][0])\\r\\n ext_bot = tuple(contour[contour[:, :, 1].argmax()][0])\\r\\n\\r\\n img1 = img.copy()\\r\\n img2 = img.copy()\\r\\n cv2.rectangle(img1, (x, y), (x + w, y + h), (0, 255, 0), 2)\\r\\n\\r\\n cropped_image = img2[ext_top[1]:ext_bot[1], ext_left[0]:ext_right[0]]\\r\\n cropped_image = cv2.resize(cropped_image, (cropW, cropH))\\r\\n filename = os.path.join(os.path.join(BASE_PATH,folderName),'output_%d'%d+'.jpg')\\r\\n d += 1\\r\\n if writeToFile:\\r\\n cv2.imwrite(filename, cropped_image)\\r\\n cv2.waitKey(0)\\r\\n yield cropped_image,(x,y,w,h),contour\",\n \"def _yield_training_validation(self, batch_index):\\n # print(f'requested batch with index: {batch_index}') # DEBUG\\n num_identities = len(self.identities)\\n num_ids_to_resample = 0\\n # manage identities in a circular way \\n ids_start = (batch_index*self.batch_size)%num_identities # identities' batch start\\n ids_end = ((batch_index+1)*self.batch_size)%num_identities # identities' batch end\\n # Manage the indetities array in a circular manner\\n #batch_identities = self.identities[ids_start:ids_end] if ids_start < ids_end else self.identities[ids_start:].append(self.identities[:ids_end])\\n if ids_start < ids_end:\\n batch_identities = self.identities[ids_start:ids_end]\\n else:\\n batch_identities = self.identities[ids_start:]\\n batch_identities.extend(self.identities[:ids_end])\\n samples_batch = []\\n labels_batch = []\\n roi_batch = []\\n for identity in batch_identities:\\n identity_data = self.groundtruth_metadata[identity]\\n # if there are images available for that identity\\n if identity_data['index'] < len(identity_data['metadata']):\\n # read the image and the necessary metadata\\n img_info = identity_data['metadata'][identity_data['index']]\\n img_path = os.path.join(self.dataset_root_path, img_info['path'])\\n img = cv2.imread(img_path) # watch out for slashes (/)\\n # if OpenCV is unable to read an image, it returns None\\n if img is None:\\n print('[DATA LOADER ERROR] cannot find image at path: ', img_path)\\n # increase the index, in order to avoid this path when building subsequent batches with this identity\\n identity_data['index'] += 1\\n # sample another image from another identity to replace this one in the batch\\n num_ids_to_resample += 1\\n continue\\n #batch.append(AgeEstimationSample(img, img_info['roi'], img_info['age'], 'BGR')) # cv2 reads as BGR\\n img = img.astype('float32')\\n samples_batch.append(img)\\n labels_batch.append(img_info['age'])\\n roi_batch.append(img_info['roi'])\\n # increase the index, because another sample for that identity has been used\\n identity_data['index'] += 1\\n else:\\n num_ids_to_resample += 1\\n\\n # if for some identities there weren't available images, take them from other identities\\n # note that this mechanism solves also the problems arising when less than batch_size identities are available, by\\n # picking multiple images from the available entities\\n # the __len__ method in the data generator associated to this data loader is responsible for avoiding that this\\n # method is called when less than batch_size \\\"fresh\\\" images are available\\n last_taken_identity_index = ids_end \\n num_samples_when_last_taken = num_ids_to_resample\\n while(num_ids_to_resample > 0):\\n identity = self.identities[ids_end] # remeber that slicing at previous step excludes upper limit\\n identity_data = self.groundtruth_metadata[identity]\\n if identity_data['index'] < len(identity_data['metadata']):\\n last_taken_identity_index = ids_end\\n num_samples_when_last_taken = num_ids_to_resample\\n # read the image and the necessary metadata\\n img_info = identity_data['metadata'][identity_data['index']]\\n img_path = os.path.join(self.dataset_root_path, img_info['path'])\\n img = cv2.imread(img_path) # watch out for slashes (/)\\n # if the path does not exist or there are problems while reading the image\\n if img is None:\\n print('[DATA LOADER ERROR] cannot find image at path: ', img_path)\\n # increase the index, in order to avoid this path when building subsequent batches with this identity\\n identity_data['index'] += 1\\n continue\\n #batch.append(AgeEstimationSample(img, img_info['roi'], img_info['age'], 'BGR')) # cv2 reads as BGR\\n img = img.astype('float32')\\n samples_batch.append(img)\\n labels_batch.append(img_info['age'])\\n roi_batch.append(img_info['roi'])\\n\\n num_ids_to_resample -= 1\\n identity_data['index'] += 1\\n \\n ids_end = ((ids_end+1)%num_identities)\\n if ids_end == last_taken_identity_index and num_ids_to_resample == num_samples_when_last_taken and identity_data['index'] == len(identity_data['metadata']):\\n raise Exception(f'No more images available, missing {num_ids_to_resample} images!')\\n\\n # cannot return numpy arrays since images in batch have different sizes\\n return samples_batch, labels_batch, roi_batch\\n #return batch\",\n \"def generate_batch(self, batch_size=8, shuffle=True):\\n if self._contour_dicom_folder:\\n contour_files = glob(os.path.join(self._contour_dicom_folder, \\\"*.h5\\\"))\\n if shuffle:\\n contour_files = np.random.permutation(contour_files)\\n contours_generator = self._contour_folder_gen(contour_files)\\n else:\\n contours_generator = self._contour_dicom_generator\\n\\n x_batch, y_batch, sources_batch = [], [], []\\n batch_idx = 0\\n for idx, (dataset, sources) in enumerate(contours_generator):\\n if batch_idx > 0 and batch_idx % batch_size == 0:\\n if self._include_sources:\\n yield sources_batch, np.array(x_batch), np.array(y_batch)\\n else:\\n yield np.array(x_batch), np.array(y_batch)\\n x_batch, y_batch, sources_batch = [], [], []\\n batch_idx = 0\\n try:\\n x_data = self._parse_channels(dataset, self.x_channels)\\n y_data = self._parse_channels(dataset, self.y_channels)\\n x_batch.append(x_data)\\n y_batch.append(y_data)\\n sources_batch.append(sources)\\n batch_idx += 1\\n except ValueError:\\n # Log Error\\n err_msg = \\\"Missing all channels in {}\\\".format(sources[\\\"filename\\\"])\\n self._log_error(err_msg)\\n\\n if self._include_sources:\\n yield sources_batch, np.array(x_batch), np.array(y_batch)\\n else:\\n yield np.array(x_batch), np.array(y_batch)\",\n \"def generate(batch, size=32):\\n\\n # Using the data Augmentation in traning data\\n ptrain = 'data224/train'\\n pval = 'data224/test'\\n\\n datagen1 = ImageDataGenerator(\\n samplewise_center=True,\\n samplewise_std_normalization=True,\\n shear_range=0.2,\\n zoom_range=0.2,\\n rotation_range=90,\\n width_shift_range=0.2,\\n height_shift_range=0.2,\\n horizontal_flip=True)\\n\\n datagen2 = ImageDataGenerator(samplewise_center=True,\\n samplewise_std_normalization=True,)\\n\\n train_generator = datagen1.flow_from_directory(\\n ptrain,\\n target_size=(size, size),\\n batch_size=batch,\\n class_mode='categorical')\\n\\n validation_generator = datagen2.flow_from_directory(\\n pval,\\n target_size=(size, size),\\n batch_size=batch,\\n class_mode='categorical')\\n\\n count1 = 0\\n for root, dirs, files in os.walk(ptrain):\\n for each in files:\\n count1 += 1\\n\\n count2 = 0\\n for root, dirs, files in os.walk(pval):\\n for each in files:\\n count2 += 1\\n\\n return train_generator, validation_generator, count1, count2\",\n \"def train_cupy(n, training_data_list, onodes=10, epochs=5):\\n\\n print(\\\"Training...\\\")\\n\\n # epochs is the number of times the training data set is used for training\\n epochs = 5\\n\\n for e in range(epochs):\\n print(\\\"Epoch:\\\", e)\\n # go through all records in the training data set\\n for record in training_data_list:\\n # split the tecord by the ',' commas\\n all_values = record.split(',')\\n temp = list(map(eval, all_values[1:]))\\n # scale and shift the inputs\\n inputs = (cupy.asarray(temp) / 255 * 0.99) + 0.01\\n # create the target output values (all 0.01, except the desired lavel which is 0.99)\\n targets = cupy.zeros(onodes) + 0.01\\n # all_values[0] is the target lavel for this record\\n targets[int(all_values[0])] = 0.99\\n n.train(inputs, targets)\\n\\n # create rotated variations\\n # rotated anticlockwise by x degrees\\n inputs_plusx_img = cupyx.scipy.ndimage.interpolation.rotate(\\n inputs.reshape(28, 28), 10, cval=0.01, order=1, reshape=False)\\n n.train(inputs_plusx_img.reshape(784), targets)\\n # rotated clockwise by x degrees\\n inputs_minusx_img = cupyx.scipy.ndimage.interpolation.rotate(\\n inputs.reshape(28, 28), -10, cval=0.01, order=1, reshape=False)\\n n.train(inputs_minusx_img.reshape(784), targets)\\n\\n return n\",\n \"def flow(self, batch_size=32):\\n nb_batches = int(len(self.image_ids_in_subset) / batch_size) + 1\\n while True:\\n # Before each epoch we shuffle the images' ids\\n random.shuffle(self.image_ids_in_subset)\\n\\n for i in range(nb_batches):\\n # We first get all the image ids for the next batch\\n current_bach = self.image_ids_in_subset[i*batch_size:(i+1)*batch_size]\\n X_batch = []\\n Y_batch = []\\n\\n for image_id in current_bach:\\n # Load the image and resize it. We get a PIL Image object\\n img = image.load_img(self.get_img_path(int(image_id)), grayscale=False, target_size=(cfg.IMAGE.IMG_SIZE, cfg.IMAGE.IMG_SIZE))\\n # Cast the Image object to a numpy array and put the channel has the last dimension\\n img_arr = image.img_to_array(img, data_format='channels_last')\\n X_batch.append(img_arr)\\n # Y_batch.append(self.id_to_label[image_id])\\n Y_batch.append(self.get_labels(image_id))\\n\\n # resize X_batch in (batch_size, IMG_HEIGHT, IMG_WIDTH, 3)\\n X_batch = np.reshape(X_batch, (-1, cfg.IMAGE.IMG_SIZE, cfg.IMAGE.IMG_SIZE, 3))\\n # resize Y_batch in (None, nb_classes)\\n Y_batch = np.reshape(Y_batch, (-1, self.nb_classes))\\n\\n # substract mean values from imagenet\\n X_batch = preprocess_input(X_batch, data_format='channels_last')\\n yield(X_batch, Y_batch)\",\n \"def trainingset(self, batchsize=None, flatten=True):\\n if batchsize is None:\\n batchsize = self.batchsize\\n\\n if self.x_train is None:\\n raise AttributeError('No fold initialized... Try calling next_leaveout')\\n\\n return self.GENERATOR(self.x_train, self.y_train, batchsize, flatten=flatten, evaluate=False)\",\n \"def as_generator(self, shuffle=False, n_workers=0):\\n\\n data_loader = DataLoader(\\n dataset=self, shuffle=shuffle, num_workers=n_workers\\n )\\n for sample in cycle(data_loader):\\n sample_batch_dim_removed = {}\\n for key, val in sample.items():\\n sample_batch_dim_removed[key] = val[0]\\n yield sample_batch_dim_removed\",\n \"def clarifruit_train_val_generators(self, aug_flag=True):\\n\\n aug_dict = self.data_gen_args if aug_flag else None\\n\\n image_train_generator, image_val_generator = self.train_val_generators(\\n batch_size=self.batch_size,\\n src_path=self.train_path,\\n folder=self.x_folder_name,\\n input_aug_dict=aug_dict,\\n color_mode=self.color_mode,\\n save_prefix=self.x_folder_name,\\n save_to_dir=self.save_to_dir,\\n target_size=self.target_size,\\n seed=self.seed,\\n validation_split=self.validation_split)\\n\\n mask_train_generator, mask_val_generator = self.train_val_generators(\\n batch_size=self.batch_size,\\n src_path=self.train_path,\\n folder=self.y_folder_name,\\n input_aug_dict=aug_dict,\\n color_mode='grayscale',\\n save_prefix=self.y_folder_name,\\n save_to_dir=self.save_to_dir,\\n target_size=self.target_size,\\n seed=self.seed,\\n validation_split=self.validation_split)\\n\\n train_generator = zip(image_train_generator, mask_train_generator)\\n val_generator = zip(image_val_generator, mask_val_generator)\\n\\n return train_generator, val_generator\",\n \"def _automatic_training_set(self, n_cutouts=100):\\n dstl = Load_DSTL()\\n np.random.seed(42)\\n for ii in range(n_cutouts):\\n # Get region around a shape\\n triples, mask, ind_shape, img_dim = dstl.extract_region(object_class=self.class_type, image_id='6120_2_2', buffer_size=10)\\n if self.radius is not None:\\n triples, mask = self._sliding_window(triples.reshape(*img_dim, 3), mask.reshape(img_dim), window_radius=self.radius)\\n # Add to Feature Matrix\\n if ii == 0:\\n features = triples\\n labels = mask\\n else:\\n features = np.vstack([features, triples])\\n labels = np.hstack([labels, mask])\\n return features, labels\",\n \"def my_generator(batch_size, img_dir):\\n cat_dirs = glob.glob(img_dir + \\\"/*\\\")\\n counter = 0\\n while True:\\n input_images = np.zeros(\\n (batch_size, config.height, config.width, 3 * 5))\\n output_images = np.zeros((batch_size, config.height, config.width, 3))\\n random.shuffle(cat_dirs)\\n if (counter+batch_size >= len(cat_dirs)):\\n counter = 0\\n for i in range(batch_size):\\n input_imgs = glob.glob(cat_dirs[counter + i] + \\\"/cat_[0-4]*\\\") \\n imgs = [Image.open(img) for img in sorted(input_imgs)]\\n input_images[i] = np.concatenate(imgs, axis=2)\\n output_imgs = glob.glob(cat_dirs[counter + i] + \\\"/cat_[5-7]*\\\")\\n imgs = [Image.open(img) for img in sorted(output_imgs)]\\n output_images[i] = np.concatenate(imgs, axis=1)\\n input_images[i] /= 255.\\n output_images[i] /= 255.\\n yield (input_images, output_images)\\n counter += batch_size\",\n \"def generate(self, batch_size=None):\\n nb = self.batch_size\\n if batch_size is not None:\\n nb = batch_size\\n with tf.compat.v1.Session() as sess:\\n self.saver.restore(sess, \\\"data/\\\" + self.name + \\\".ckpt\\\")\\n return self.X_fake.eval(feed_dict={self.z: self.noise(nb, self.z_dim), self.is_training: False})\",\n \"def test_generator(self, test_path):\\n\\n img_list = os.scandir(test_path)\\n for img_entry in img_list:\\n\\n img = cv2.imread(img_entry.path, COLOR_TO_OPENCV[self.color_mode])\\n if img.shape[-1] == 3:\\n orig_shape = img.shape[-2::-1]\\n else:\\n orig_shape = img.shape[::-1]\\n\\n\\n img = cv2.resize(img, tuple(self.target_size))\\n img = img / 255\\n if self.color_mode == \\\"grayscale\\\":\\n img = np.reshape(img, img.shape + (1,))\\n img = np.reshape(img, (1,) + img.shape)\\n yield img, img_entry, orig_shape\",\n \"def batch_generator(batch_size):\\n\\n # Infinite loop.\\n while True:\\n # Get a list of random indices for images in the training-set.\\n idx = np.random.randint(100,size=batch_size)\\n \\n # Get the pre-computed transfer-values for those images.\\n # These are the outputs of the pre-trained image-model.\\n transf_values = np.array([transfer_values[_] for _ in idx])\\n\\n # For each of the randomly chosen images there are\\n # at least 5 captions describing the contents of the image.\\n # Select one of those captions at random and get the\\n # associated sequence of integer-tokens.\\n tokens = [caps_markedwords[_] for _ in idx]\\n\\n # Count the number of tokens in all these token-sequences.\\n num_tokens = [len(t) for t in tokens]\\n \\n # Max number of tokens.\\n max_tokens = np.max(num_tokens)\\n # Pad all the other token-sequences with zeros\\n # so they all have the same length and can be\\n # input to the neural network as a numpy array.\\n tokens_padded = pad_sequences(tokens,\\n maxlen=max_tokens,\\n padding='post',\\n truncating='post')\\n \\n # Further prepare the token-sequences.\\n # The decoder-part of the neural network\\n # will try to map the token-sequences to\\n # themselves shifted one time-step.\\n decoder_input_data = tokens_padded[:, 0:-1]\\n decoder_output_data = tokens_padded[:, 1:]\\n\\n # Dict for the input-data. Because we have\\n # several inputs, we use a named dict to\\n # ensure that the data is assigned correctly.\\n x_data = \\\\\\n {\\n 'decoder_input': decoder_input_data,\\n 'transfer_values_input': transf_values\\n }\\n\\n\\n # Dict for the output-data.\\n y_data = \\\\\\n {\\n 'decoder_output': decoder_output_data\\n }\\n \\n yield (x_data, y_data)\",\n \"def training_data_generation(DATA_DIR, img_height_size, img_width_size, label_list):\\r\\n \\r\\n img_ms_files = glob.glob(DATA_DIR + '\\\\\\\\Train_MS' + '\\\\\\\\Train_*.tif')\\r\\n img_pan_files = glob.glob(DATA_DIR + '\\\\\\\\Train_Pan' + '\\\\\\\\Train_*.tif')\\r\\n polygon_files = glob.glob(DATA_DIR + '\\\\\\\\Train_Polygons' + '\\\\\\\\Train_*.geojson')\\r\\n \\r\\n img_ms_array_list = []\\r\\n img_pan_array_list = []\\r\\n mask_array_list = []\\r\\n \\r\\n for file in range(len(img_ms_files)):\\r\\n with rasterio.open(img_ms_files[file]) as f:\\r\\n metadata = f.profile\\r\\n img_ms = np.transpose(f.read(tuple(np.arange(metadata['count']) + 1)), [1, 2, 0])\\r\\n \\r\\n with rasterio.open(img_pan_files[file]) as g:\\r\\n metadata_pan = g.profile\\r\\n img_pan = np.expand_dims(g.read(1), axis = 2)\\r\\n \\r\\n ms_to_pan_ratio = metadata['transform'][0] / metadata_pan['transform'][0]\\r\\n \\r\\n if (img_height_size % ms_to_pan_ratio) != 0 or (img_width_size % ms_to_pan_ratio) != 0:\\r\\n raise ValueError('Please make sure that both img_height_size and img_width_size can be divided by {}'.format(int(ms_to_pan_ratio)))\\r\\n \\r\\n mask = training_mask_generation(img_pan_files[file], polygon_files[file], labels = label_list)\\r\\n \\r\\n img_ms_array, img_pan_array, mask_array = image_clip_to_segment_and_convert(img_ms, img_pan, mask, ms_to_pan_ratio, \\r\\n img_height_size, img_width_size)\\r\\n \\r\\n img_ms_array_list.append(img_ms_array)\\r\\n img_pan_array_list.append(img_pan_array)\\r\\n mask_array_list.append(mask_array)\\r\\n \\r\\n img_ms_full_array = np.concatenate(img_ms_array_list, axis = 0)\\r\\n img_pan_full_array = np.concatenate(img_pan_array_list, axis = 0)\\r\\n mask_full_array = to_categorical(np.concatenate(mask_array_list, axis = 0), num_classes = len(label_list))\\r\\n \\r\\n return img_ms_full_array, img_pan_full_array, mask_full_array\",\n \"def generator(numbers, number_labels, batch_size=32):\\n while True: # Loop forever so the generator never terminates\\n\\n images = []\\n labels = []\\n\\n for batch_sample in range(batch_size):\\n img, label = create_numbers(numbers, number_labels, return_label=True)\\n\\n # Here we will convert the label to a format that Keras API can process:\\n n_label = np.zeros((5, 11), dtype='int')\\n for i, digit in enumerate(label):\\n if digit == \\\".\\\":\\n n_digit = 10\\n else:\\n n_digit = int(digit)\\n\\n n_label[i][n_digit] = 1\\n\\n images.append(img)\\n # labels.append(label)\\n labels.append(n_label)\\n\\n X_train = np.array(images)\\n if len(X_train.shape) == 3:\\n X_train = np.expand_dims(X_train, -1)\\n\\n y_temp = np.array(labels)\\n\\n y1 = y_temp[:, 0, :]\\n y2 = y_temp[:, 1, :]\\n y3 = y_temp[:, 2, :]\\n y4 = y_temp[:, 3, :]\\n y5 = y_temp[:, 4, :]\\n\\n yield X_train, [y1, y2, y3, y4, y5]\",\n \"def visualize_network_samples(net,\\n outputs_per_example=5,\\n color_map=\\\"gray\\\",\\n setsize=[1, 6],\\n f_ext=\\\"pdf\\\"):\\n n_examples = net.batch_size\\n if net.name == \\\"cifar\\\":\\n inputs, targets = generate_training_data(\\n None,\\n None,\\n dataset=net.dataset,\\n train_test=\\\"test\\\",\\n conv=True,\\n data_dir=net.trainingset_dir)[0:2]\\n inputs, targets = net.get_batch(inputs, targets, None)[0:2]\\n sig = True # For predicting decisions\\n elif net.name == \\\"fruits\\\":\\n inputs, recall_targets = net.generate_batch(\\\"test\\\")\\n targets = inputs\\n sig = True\\n elif net.name == \\\"popout\\\":\\n inputs, recall_targets = net.generate_training_data(n_examples)\\n targets = inputs\\n sig = False\\n else:\\n inputs = generate_training_data(\\n n_examples,\\n net.image_width,\\n task_weights=net.task_weights,\\n dataset=net.dataset,\\n conv=net.layer_type == \\\"conv\\\",\\n data_dir=net.trainingset_dir,\\n setsize=setsize,\\n mean=net.input_mean,\\n std=net.input_std,\\n dim=net.input_distribution_dim)[0]\\n targets = inputs\\n sig = False\\n if net.image_channels > 1:\\n shp = [net.image_width, net.image_width, net.image_channels]\\n else:\\n shp = [net.image_width, net.image_width]\\n preds0, dec0 = zip(*[\\n net.predict_both(\\n inputs, np.zeros_like(inputs), sigmoid=sig, keep_session=True)\\n for i in range(outputs_per_example)\\n ])\\n preds1 = np.array(preds0)\\n preds2 = preds1.swapaxes(0, 1)\\n preds = preds2.reshape([n_examples, outputs_per_example] + shp)\\n preds = preds.clip(0, 1)\\n # dec = np.array(dec0).swapaxes(0, 1)\\n # print(\\\"decisions: \\\", dec)\\n # print(dec)\\n save_dir = make_memnet_checkpoint_dir(\\n Path(\\\"plots/vis_memnet_samples/\\\"), net)\\n if not save_dir.exists():\\n save_dir.makedirs()\\n print(\\\"Saving images to: \\\", save_dir)\\n for i in range(n_examples):\\n fig, axes = plt.subplots(\\n nrows=1, ncols=outputs_per_example + 1, figsize=(45, 10))\\n if net.RGB:\\n axes[0].imshow(targets[i], cmap=color_map)\\n else:\\n axes[0].imshow(\\n targets[i].reshape(net.image_width, net.image_width),\\n cmap=color_map)\\n [\\n axes[j + 1].imshow(preds[i][j], cmap=color_map)\\n for j in range(outputs_per_example)\\n ]\\n [ax.set_aspect('equal') for ax in axes]\\n xlabs = [\\\"Target\\\"] + [\\n \\\"Sample {}\\\".format(j) for j in range(1, outputs_per_example + 1)\\n ]\\n [ax.set_xlabel(l, size=50) for ax, l in zip(axes, xlabs)]\\n for ax in axes:\\n ax.set_xticks([])\\n ax.set_xticklabels(\\\"\\\")\\n ax.set_yticks([])\\n ax.set_yticklabels(\\\"\\\")\\n plt.tight_layout()\\n plt.savefig(\\n save_dir.joinpath('setsize_{}_sample{}.{}'.format(\\n \\\"_\\\".join([str(x) for x in setsize]),\\n str(i).zfill(2), f_ext)))\",\n \"def _make_batches(self, n_batches: int) -> Iterable[Dict[Any, Any]]:\\n batch_iters = []\\n for problem in self.problems:\\n service = problem.problem_service\\n it = service.batch_iter(self.batch_size_per_problem, n_batches)\\n batch_iters.append(it)\\n combined = zip(*batch_iters)\\n # yield a complete feed dict\\n for combined_batch in combined:\\n assert len(combined_batch) == len(self.problems)\\n yield_val = {}\\n for problem, batch in zip(self.problems, combined_batch):\\n ph_obs_var, ph_q_values = self.obs_qv_inputs[problem.name]\\n obs_tensor, qv_tensor = to_local(batch)\\n yield_val[ph_obs_var] = obs_tensor\\n yield_val[ph_q_values] = qv_tensor\\n yield yield_val\",\n \"def reconstruct_missing(self, \\n num_iters, \\n recon_images, \\n which_pixels):\\n \\n N = recon_images.shape[0]\\n \\n if self.num_hidden == 0:\\n \\n tE = -self.compute_energy(self.x, 1)\\n \\n elif self.num_hidden > 0:\\n \\n tE = -self.compute_free_energy(self.x)\\n \\n do_computation = theano.function(inputs =[self.x], outputs = tE)\\n \\n for xi in range(N):\\n \\n print(\\\"Reconstructing test image --- %d\\\"%xi)\\n \\n for iter_ind in range(num_iters):\\n \\n permuted_nodes = list(np.random.permutation(self.num_vars))\\n \\n for d in permuted_nodes:\\n \\n if which_pixels[xi,d]:\\n \\n recon_images[xi, d] = 1\\n \\n E1 = do_computation([recon_images[xi, :]])\\n \\n recon_images[xi, d] = 0\\n \\n E0 = do_computation([recon_images[xi, :]])\\n \\n if E1>E0:\\n recon_images[xi, d] = 1\\n else:\\n recon_images[xi, d] = 0\",\n \"def testGenerator(self,):\\n return tf.data.Dataset.from_generator(self.testData, \\\\\\n output_types=(tf.float32, tf.float32, tf.float32), \\\\\\n output_shapes=(tf.TensorShape(self.config_model[\\\"input_shape\\\"]), \\\\\\n tf.TensorShape(list(self.headoutput_shape[1:4]) + \\\\\\n [len(self.anchor_boxes), \\\\\\n 7+len(self.config_data[\\\"all_classes\\\"])]), \\\\\\n tf.TensorShape([self.config_data[\\\"max_boxes_per_frame\\\"], 7]) \\\\\\n ), )\",\n \"def _generate_validation_fold(self):\\n\\n for offset in range(self.nb_folds):\\n # Load all the data from cache (do this to save memory)\\n with open(self.data_cache_path_str + \\\"data_cache.pkl\\\", \\\"rb\\\") as f:\\n data_df, target_df = pickle.load(f)\\n\\n # Generate train and test sets\\n data_dates_lst = data_df[\\\"date\\\"].drop_duplicates().sort_values().tolist()\\n train_start_day = len(data_dates_lst) - ((self.nb_folds - offset) * self.test_nb_days + self.train_nb_days)\\n train_end_day = train_start_day + self.train_nb_days\\n test_start_day = train_end_day\\n test_end_day = test_start_day + self.test_nb_days\\n\\n train_dates_lst = data_dates_lst[train_start_day:train_end_day]\\n test_dates_lst = data_dates_lst[test_start_day:test_end_day]\\n\\n # Generate train and test labels\\n training_set_df = data_df.loc[data_df[\\\"date\\\"].isin(train_dates_lst)].reset_index(drop = True)\\n testing_set_df = data_df.loc[data_df[\\\"date\\\"].isin(test_dates_lst)].reset_index(drop = True)\\n new_target_df = target_df.loc[data_df[\\\"date\\\"].isin(train_dates_lst)].reset_index(drop = True)\\n truth_df = target_df.loc[data_df[\\\"date\\\"].isin(test_dates_lst)].reset_index(drop = True)\\n\\n # Reduce memory usage\\n del data_df, target_df\\n gc.collect()\\n\\n # Return result\\n yield (training_set_df, testing_set_df, new_target_df, truth_df)\",\n \"def custom_data_generator(img_paths, final_height, final_width):\\n for img_path in img_paths:\\n image = Image.open(img_path)\\n resized_image = image.resize((final_width, final_height), Image.ANTIALIAS) # Image.LANCZOS\\n img = np.array(resized_image)\\n img = tf.image.convert_image_dtype(img, tf.float32)\\n yield img, tf.constant([[]], dtype=tf.float32), tf.constant([], dtype=tf.int32)\",\n \"def get_batches_fn(batch_size):\\n id_road = 7\\n id_lane = 6\\n id_car = 10\\n\\n for batch_i in range(0, len(image_paths), batch_size):\\n images = []\\n gt_images = []\\n for image_file in image_paths[batch_i:batch_i + batch_size]:\\n # Get corresponding label img path\\n gt_image_file = image_file.replace('CameraRGB', 'CameraSeg')\\n # Read rgb and label images\\n img_in = scipy.misc.imread(image_file, mode='RGB')\\n gt_in = scipy.misc.imread(gt_image_file)\\n # Crop sky part of the image\\n image = img_in[-out_shape[0]:, :]\\n gt_image = gt_in[-out_shape[0]:, :, 0]\\n # Obtain labels\\n gt_road = ((gt_image == id_road) | (gt_image == id_lane))\\n gt_car = (gt_image == id_car)\\n gt_car[-105:, :] = False\\n gt_bg = np.invert(gt_car | gt_road)\\n # Augmentation\\n if bool(random.getrandbits(1)):\\n image, gt_bg, gt_car, gt_road = flip_img(\\n image, gt_bg, gt_car, gt_road)\\n\\n gt_bg = gt_bg.reshape(*gt_bg.shape, 1)\\n gt_car = gt_car.reshape(*gt_car.shape, 1)\\n gt_road = gt_road.reshape(*gt_road.shape, 1)\\n\\n gt_image = np.concatenate((gt_bg, gt_car, gt_road), axis=2)\\n\\n images.append(image)\\n gt_images.append(gt_image)\\n\\n yield np.array(images), np.array(gt_images)\",\n \"def __call__(self, batch_size=20, shuffle=True, augment=True):\\r\\n\\r\\n if batch_size < 1:\\r\\n raise ValueError(\\\"batch_size must be more than 1.\\\")\\r\\n if shuffle:\\r\\n self.shuffle()\\r\\n\\r\\n for start in range(0, self.length, batch_size):\\r\\n batch = self.perm(start, start+batch_size)\\r\\n if augment:\\r\\n assert self._augmenter is not None, \\\"you have to set an augmenter.\\\"\\r\\n yield self._augmenter.augment_dataset(batch, method=[ia.ImageAugmenter.NONE, ia.ImageAugmenter.FLIP])\\r\\n else:\\r\\n yield batch\",\n \"def rslices(n, allow_empty=False):\\n for _ in range(5):\\n yield rslice(n, allow_empty)\",\n \"def rslices(n, allow_empty=False):\\n for _ in range(5):\\n yield rslice(n, allow_empty)\",\n \"def get_batch_gen(self, split, config):\\n config.augment_scale_anisotropic = True\\n config.augment_scale_min = 0.9\\n config.augment_scale_max = 1.1\\n config.augment_noise = 0.001\\n config.augment_color = 1.0\\n config.augment_rotation = 'vertical'\\n\\n if split == 'training':\\n config.augment_symmetries = [True, False, False]\\n else:\\n config.augment_symmetries = [False, False, False]\\n\\n if split == 'training':\\n epoch_n = config.epoch_steps * config.batch_size\\n elif split == 'validation':\\n epoch_n = config.validation_size * config.batch_size\\n elif split == 'test':\\n epoch_n = config.validation_size * config.batch_size\\n else:\\n raise ValueError('Split argument in data generator should be \\\"training\\\", \\\"validation\\\" or \\\"test\\\"')\\n\\n # Initiate potentials for regular generation\\n if not hasattr(self, 'potentials'):\\n self.potentials = {}\\n self.min_potentials = {}\\n\\n data_split = split\\n\\n # Reset potentials\\n def reset_potentials():\\n self.potentials[split] = []\\n self.min_potentials[split] = []\\n\\n for i, tree in enumerate(self.input_trees[data_split]):\\n self.potentials[split] += [np.random.rand(tree.data.shape[0]) * 1e-3]\\n self.min_potentials[split] += [float(np.min(self.potentials[split][-1]))]\\n\\n reset_potentials()\\n\\n def spatially_regular_gen():\\n for i in range(epoch_n):\\n cloud_ind = int(np.argmin(self.min_potentials[split]))\\n point_ind = np.argmin(self.potentials[split][cloud_ind])\\n points = np.array(self.input_trees[data_split][cloud_ind].data, copy=False)\\n center_point = points[point_ind, :].reshape(1, -1)\\n noise = np.random.normal(scale=0.35, size=center_point.shape)\\n pick_point = center_point + noise.astype(center_point.dtype)\\n\\n if config.in_radius > 0:\\n input_inds = self.input_trees[split][cloud_ind].query_radius(pick_point, r=config.in_radius)[0]\\n else:\\n buffer = self.buffer+np.random.randint(0,self.buffer//4)\\n if len(points) < self.npoint+buffer:\\n input_inds = self.input_trees[split][cloud_ind].query(pick_point, k=len(points))[1][0]\\n else:\\n input_inds = self.input_trees[split][cloud_ind].query(pick_point, k=self.npoint+buffer)[1][0]\\n\\n input_inds = self.shuffle_idx(input_inds)\\n input_inds = input_inds[:self.npoint]\\n\\n # Number collected\\n n = input_inds.shape[0]\\n if n == 0:\\n # Reset potentials\\n reset_potentials()\\n return\\n # Safe check for very dense areas\\n\\n # Update potentials\\n dists = np.sum(np.square((points[input_inds] - pick_point).astype(np.float32)), axis=1)\\n delta = np.square(1 - dists / np.max(dists))\\n self.potentials[split][cloud_ind][input_inds] += delta\\n self.min_potentials[split][cloud_ind] = float(np.min(self.potentials[split][cloud_ind]))\\n n = input_inds.shape[0]\\n\\n # Collect points and colors\\n input_points = (points[input_inds] - pick_point).astype(np.float32)\\n input_colors = self.input_colors[data_split][cloud_ind][input_inds]\\n\\n if split == 'test':\\n input_labels = np.zeros(input_points.shape[0])\\n else:\\n input_labels = self.input_labels[data_split][cloud_ind][input_inds]\\n input_labels = np.array([self.label_to_idx[l] for l in input_labels])\\n\\n if split in ['test', 'validation']:\\n label_weights = np.zeros(input_points.shape[0])\\n else:\\n label_weights = self.label_weights[input_labels]\\n\\n if len(input_inds) < self.npoint:\\n input_points, input_colors, input_inds, label_weights, input_labels = \\\\\\n self.data_rep(input_points, input_colors, input_labels, input_inds, label_weights, self.npoint)\\n\\n # Add yield data\\n if n > 0:\\n yield input_points, np.hstack((input_colors, input_points + pick_point)), input_labels, \\\\\\n [input_points.shape[0]], input_inds, cloud_ind, label_weights\\n\\n # Define the generator that should be used for this split\\n gen_func = spatially_regular_gen\\n\\n # Define generated types and shapes\\n gen_types = (tf.float32, tf.float32, tf.int32, tf.int32, tf.int32, tf.int32, tf.float32)\\n gen_shapes = ([self.npoint, 3], [self.npoint, 6], [self.npoint], [1], [self.npoint], [], [self.npoint])\\n\\n return gen_func, gen_types, gen_shapes\",\n \"def get_test_and_valid_generator(valid_df, test_df, train_df, image_dir, x_col, y_cols, sample_size=100, batch_size=8, seed=1, target_w = 320, target_h = 320):\\n print(\\\"getting train and valid generators...\\\")\\n # get generator to sample dataset\\n raw_train_generator = ImageDataGenerator().flow_from_dataframe(\\n dataframe=train_df, \\n directory=IMAGE_DIR, \\n x_col=\\\"Image\\\", \\n y_col=labels, \\n class_mode=\\\"raw\\\", \\n batch_size=sample_size, \\n shuffle=True, \\n target_size=(target_w, target_h))\\n \\n # get data sample\\n batch = raw_train_generator.next()\\n data_sample = batch[0]\\n\\n # use sample to fit mean and std for test set generator\\n image_generator = ImageDataGenerator(\\n featurewise_center=True,\\n featurewise_std_normalization= True)\\n \\n # fit generator to sample from training data\\n image_generator.fit(data_sample)\\n\\n # get test generator\\n valid_generator = image_generator.flow_from_dataframe(\\n dataframe=valid_df,\\n directory=image_dir,\\n x_col=x_col,\\n y_col=y_cols,\\n class_mode=\\\"raw\\\",\\n batch_size=batch_size,\\n shuffle=False,\\n seed=seed,\\n target_size=(target_w,target_h))\\n\\n test_generator = image_generator.flow_from_dataframe(\\n dataframe=test_df,\\n directory=image_dir,\\n x_col=x_col,\\n y_col=y_cols,\\n class_mode=\\\"raw\\\",\\n batch_size=batch_size,\\n shuffle=False,\\n seed=seed,\\n target_size=(target_w,target_h))\\n return valid_generator, test_generator\",\n \"def get_test_and_valid_generator(valid_df, test_df, train_df, image_dir, x_col, y_cols, sample_size=100, batch_size=32, seed=1, target_w = 320, target_h = 320):\\n print(\\\"getting train and valid generators...\\\")\\n # get generator to sample dataset\\n raw_train_generator = ImageDataGenerator().flow_from_dataframe(\\n dataframe=train_df, \\n directory=IMAGE_DIR, \\n x_col=\\\"images\\\", \\n y_col=labels, \\n class_mode=\\\"raw\\\", \\n batch_size=sample_size, \\n shuffle=True, \\n target_size=(target_w, target_h))\\n \\n # get data sample\\n batch = raw_train_generator.next()\\n data_sample = batch[0]\\n\\n # use sample to fit mean and std for test set generator\\n image_generator = ImageDataGenerator(\\n featurewise_center=True,\\n featurewise_std_normalization= True)\\n \\n # fit generator to sample from training data\\n image_generator.fit(data_sample)\\n\\n # get test generator\\n valid_generator = image_generator.flow_from_dataframe(\\n dataframe=valid_df,\\n directory=image_dir,\\n x_col=x_col,\\n y_col=y_cols,\\n class_mode=\\\"raw\\\",\\n batch_size=batch_size,\\n shuffle=False,\\n seed=seed,\\n target_size=(target_w,target_h))\\n\\n test_generator = image_generator.flow_from_dataframe(\\n dataframe=test_df,\\n directory=image_dir,\\n x_col=x_col,\\n y_col=y_cols,\\n class_mode=\\\"raw\\\",\\n batch_size=batch_size,\\n shuffle=False,\\n seed=seed,\\n target_size=(target_w,target_h))\\n return valid_generator, test_generator\",\n \"def make_checkerboard_training_set(num_points=0, noise=0.0, randomize=True,\\n x_min=0.0, x_max=1.0, y_min=0.0, y_max=1.0):\\n log.out.info(\\\"Generating target data.\\\")\\n # Select coordinates to do an XOR like operation on\\n coords = []\\n bools = []\\n if randomize:\\n for i in range(num_points):\\n # Add num_points randomly\\n coord_point = np.random.random(2)\\n coord_point[0] = coord_point[0] * (x_max - x_min) + x_min\\n coord_point[1] = coord_point[1] * (y_max - y_min) + y_min\\n coords.append(coord_point)\\n else:\\n x_points = np.linspace(x_min, x_max, int(np.sqrt(num_points)))\\n y_points = np.linspace(y_min, y_max, int(np.sqrt(num_points)))\\n for i in range(int(np.sqrt(num_points))):\\n for j in range(int(np.sqrt(num_points))):\\n # Add num_points randomly\\n coord_point = [x_points[i], y_points[j]]\\n coords.append(coord_point)\\n # Assign an xor boolean value to the coordinates\\n for coord_point in coords:\\n bool_point = np.array([np.round(coord_point[0]) % 2, np.round(coord_point[1]) % 2]).astype(bool)\\n bools.append(np.logical_xor(bool_point[0], bool_point[1]))\\n # If noisy then bit flip\\n if noise > 0.0:\\n for i in enumerate(bools):\\n if np.random.random() < noise:\\n bools[i] = np.logical_not(bools[i])\\n # Build training vectors\\n train_in = None\\n train_out = None\\n for i, coord in enumerate(coords):\\n # Need to initialize the arrays\\n if i == 0:\\n train_in = np.array([coord])\\n train_out = np.array([[bools[i]]])\\n else:\\n train_in = np.append(train_in, np.array([coord]), axis=0)\\n train_out = np.append(train_out, np.array([[bools[i]]]), axis=1)\\n\\n train_out = train_out.T\\n return train_in, train_out\",\n \"def build_generators(folder_path, train_batch_size, val_batch_size, height, width):\\n train_image_generator, train_mask_generator = create_train_generator(folder_path,\\n train_batch_size,\\n (height, width),\\n preprocessing_masks)\\n val_image_generator, val_mask_generator = create_validation_generator(folder_path,\\n val_batch_size,\\n (height, width),\\n preprocessing_masks)\\n my_train_generator = my_image_mask_generator(train_image_generator, train_mask_generator)\\n my_val_generator = my_image_mask_generator(val_image_generator, val_mask_generator)\\n\\n return my_train_generator, my_val_generator\",\n \"def _generate_crop_images(\\n crop_boxes, image, points_grid, layer_idxs, target_size, original_size, input_data_format=None\\n):\\n cropped_images = []\\n total_points_per_crop = []\\n for i, crop_box in enumerate(crop_boxes):\\n left, top, right, bottom = crop_box\\n\\n channel_dim = infer_channel_dimension_format(image, input_data_format)\\n if channel_dim == ChannelDimension.LAST:\\n cropped_im = image[top:bottom, left:right, :]\\n else:\\n cropped_im = image[:, top:bottom, left:right]\\n\\n cropped_images.append(cropped_im)\\n\\n cropped_im_size = get_image_size(cropped_im, channel_dim)\\n points_scale = np.array(cropped_im_size)[None, ::-1]\\n\\n points = points_grid[layer_idxs[i]] * points_scale\\n normalized_points = _normalize_coordinates(target_size, points, original_size)\\n total_points_per_crop.append(normalized_points)\\n\\n return cropped_images, total_points_per_crop\",\n \"def generate_leave_one_run_out(n_samples, run_onsets, random_state=None,\\n n_runs_out=1):\\n random_state = check_random_state(random_state)\\n\\n n_runs = len(run_onsets)\\n # With permutations, we are sure that all runs are used as validation runs.\\n # However here for n_runs_out > 1, a run can be chosen twice as validation\\n # in the same split.\\n all_val_runs = np.array(\\n [random_state.permutation(n_runs) for _ in range(n_runs_out)])\\n\\n all_samples = np.arange(n_samples)\\n runs = np.split(all_samples, run_onsets[1:])\\n if any(len(run) == 0 for run in runs):\\n raise ValueError(\\\"Some runs have no samples. Check that run_onsets \\\"\\n \\\"does not include any repeated index, nor the last \\\"\\n \\\"index.\\\")\\n\\n for val_runs in all_val_runs.T:\\n train = np.hstack(\\n [runs[jj] for jj in range(n_runs) if jj not in val_runs])\\n val = np.hstack([runs[jj] for jj in range(n_runs) if jj in val_runs])\\n yield train, val\",\n \"def next_simple_dataset(dataset, batch_size: int, datatype):\\n while True:\\n x_batch = []\\n y_batch = []\\n for i in range(batch_size):\\n try:\\n x, y, data_unit, index = create_xy(dataset, datatype)\\n # x = normalize(x)\\n x_batch.append(x)\\n y_batch.append(y)\\n except StopIteration:\\n break\\n x_batch, y_batch = np.array(x_batch), np.array(y_batch)\\n if datatype != DataType.test:\\n x_batch = SEQ_CVXTZ.augment_images(x_batch).astype(\\\"float32\\\")\\n x_batch = np.array([normalize(x) for x in x_batch])\\n # org_shape = x_batch.shape\\n # org_width = x_batch.shape[1]\\n # corner = int((org_width - ROI_IMAGE_SIZE) // 2)\\n # print(f\\\"0: org_shape:{org_shape} x_batch:{x_batch.shape} corner:{corner}\\\")\\n # x_batch = x_batch[:, corner:(org_width - corner), corner:(org_width - corner), :]\\n # resized_x_batch = []\\n # for x in x_batch:\\n # img = Image.fromarray(np.uint8(x))\\n # img = img.resize((IMAGE_SIZE, IMAGE_SIZE), Image.LANCZOS)\\n # resized_x_batch.append(normalize(np.array(img)))\\n # print(f\\\"1: org_shape:{org_shape} corner:{corner} x_batch:{x_batch.shape}\\\")\\n # yield np.array(resized_x_batch), y_batch\\n yield np.array(x_batch), y_batch\",\n \"def modelnet40_generator(subset, src_dir=DEFAULT_SRCDIR, single=True, target_size=DEFAULT_TARGET_SIZE, repeats=None, shuffle=True, verbose=0, frac=1.0, class_array=True, preprocess=preprocess_input):\\n viewL = modelnet40_filenames(subset, src_dir)\\n def generator_func():\\n repeat = 0\\n while repeats is None or repeat < repeats:\\n if shuffle:\\n random.shuffle(viewL)\\n for (i, view) in enumerate(viewL[:int(len(viewL)*frac)]):\\n if verbose == 1 and i % 100 == 0:\\n print('Loading %s data: %.1f%%' % (subset, i*100.0/(len(viewL)*frac)))\\n (cls, view) = view\\n if verbose == 2:\\n print('Loading data point %d, cls = %d' % (i, cls))\\n if class_array:\\n cls_array = numpy.zeros((1, nclasses), 'float32')\\n cls_array[0, cls] = 1.0\\n cls = cls_array\\n if single:\\n filename = random.choice(view)\\n yield (read_image(filename, target_size, preprocess), cls)\\n else:\\n yield ([read_image(view_elem, target_size, preprocess) for view_elem in view], cls)\\n repeat += 1 \\n return (generator_func(), len(viewL))\",\n \"def generate_crop_boxes(\\n self,\\n image,\\n target_size,\\n crop_n_layers: int = 0,\\n overlap_ratio: float = 512 / 1500,\\n points_per_crop: Optional[int] = 32,\\n crop_n_points_downscale_factor: Optional[List[int]] = 1,\\n device: Optional[\\\"torch.device\\\"] = None,\\n input_data_format: Optional[Union[str, ChannelDimension]] = None,\\n return_tensors: str = \\\"pt\\\",\\n ):\\n crop_boxes, points_per_crop, cropped_images, input_labels = _generate_crop_boxes(\\n image,\\n target_size,\\n crop_n_layers,\\n overlap_ratio,\\n points_per_crop,\\n crop_n_points_downscale_factor,\\n input_data_format,\\n )\\n if return_tensors == \\\"pt\\\":\\n if device is None:\\n device = torch.device(\\\"cpu\\\")\\n crop_boxes = torch.tensor(crop_boxes, device=device)\\n points_per_crop = torch.tensor(points_per_crop, device=device)\\n # cropped_images stays as np\\n input_labels = torch.tensor(input_labels, device=device)\\n\\n elif return_tensors == \\\"tf\\\":\\n if device is not None:\\n raise ValueError(\\\"device is not a supported argument when return_tensors is tf!\\\")\\n crop_boxes = tf.convert_to_tensor(crop_boxes)\\n points_per_crop = tf.convert_to_tensor(points_per_crop)\\n # cropped_images stays as np\\n input_labels = tf.convert_to_tensor(input_labels)\\n else:\\n raise ValueError(\\\"return_tensors must be either 'pt' or 'tf'.\\\")\\n return crop_boxes, points_per_crop, cropped_images, input_labels\",\n \"def cv_index_partitions(n: int, s: int):\\n indices = np.arange(n)\\n np.random.shuffle(indices)\\n val_size = n // s # size of validation set\\n for i in range(s):\\n training = np.concatenate(\\n (indices[0:i*val_size], indices[(i+1)*val_size:])\\n )\\n validation = indices[i*val_size:(i+1)*val_size]\\n yield training, validation\",\n \"def __iter__(self):\\n batch = []\\n for i_batch in range(self.episode_num):\\n classes = torch.randperm(len(self.idx_list))[: self.way_num]\\n for c in classes:\\n idxes = self.idx_list[c.item()]\\n pos = torch.randperm(idxes.size(0))[: self.image_num]\\n batch.append(idxes[pos])\\n if len(batch) == self.episode_size * self.way_num:\\n batch = torch.stack(batch).reshape(-1)\\n yield batch\\n batch = []\",\n \"def get_test_generator(patch_size, batch_size, preprocess_func, output_reshape_func, test_data_dir='data/test/'):\\n\\n test_paths = util.get_data_list(test_data_dir)\\n\\n # generate train batch loader\\n test_data_loader = CTBatchLoader(test_paths, batch_size, patch_size, num_threads_in_multithreaded=1,\\n preprocess_func=preprocess_func, infinite=False)\\n\\n # wrapper to be compatible with keras\\n return KerasGenerator(test_data_loader, output_reshapefunc=output_reshape_func,\\n n=int(len(test_data_loader.indices) / batch_size))\",\n \"def generate_images(generator_model, output_dir, epoch, n_class, batch_size=128):\\n label = np.random.randint(0, n_class, size=(batch_size, 1))\\n label = np_utils.to_categorical(label, num_classes=n_class)\\n test_image_stack = generator_model.predict([np.random.rand(10, 100), label])\\n test_image_stack = (test_image_stack * 127.5) + 127.5\\n test_image_stack = np.squeeze(np.round(test_image_stack).astype(np.uint8))\\n tiled_output = tile_images(test_image_stack)\\n tiled_output = Image.fromarray(tiled_output, mode='L') # L specifies greyscale\\n outfile = os.path.join(output_dir, 'epoch_{}.png'.format(epoch))\\n tiled_output.save(outfile)\",\n \"def generating(\\n self,\\n prompt,\\n width=512,\\n height=512,\\n guidance_scale=7.5,\\n num_images_per_prompt=1,\\n num_inference_steps=50,\\n generator=None,\\n **kwargs,\\n ):\\n pipe = self.get_pipe(\\\"generate\\\")\\n images = pipe(\\n prompt=prompt,\\n width=width,\\n height=height,\\n guidance_scale=guidance_scale,\\n num_images_per_prompt=num_images_per_prompt,\\n num_inference_steps=num_inference_steps,\\n generator=generator,\\n **kwargs,\\n ).images\\n return images\",\n \"def data_generator(dataset, config, shuffle=True, augment=False, augmentation=None, batch_size=1):\\n b = 0 # batch item index\\n image_index = -1\\n image_ids = np.copy(dataset.image_ids)\\n error_count = 0\\n\\n # Keras requires a generator to run indefinately.\\n while True:\\n try:\\n # Increment index to pick next image. Shuffle if at the start of an epoch.\\n image_index = (image_index + 1) % len(image_ids)\\n if shuffle and image_index == 0:\\n np.random.shuffle(image_ids)\\n\\n # Get GT bounding boxes and masks for image.\\n image_id = image_ids[image_index]\\n image, gt_class_ids = load_image_gt(dataset, config, image_id, augment=augment,\\n augmentation=augmentation)\\n\\n # Init batch arrays\\n if b == 0:\\n batch_images = np.zeros(\\n (batch_size,) + image.shape, dtype=np.float32)\\n batch_gt_class_ids = np.zeros(\\n (batch_size, config.MAX_GT_INSTANCES), dtype=np.int32)\\n\\n # Add to batch\\n batch_images[b] = mold_image(image.astype(np.float32), config)\\n batch_gt_class_ids[b, gt_class_ids] = 1\\n b += 1\\n\\n # Batch full?\\n if b >= batch_size:\\n inputs = [batch_images, batch_gt_class_ids]\\n outputs = []\\n\\n yield inputs, outputs\\n\\n # start a new batch\\n b = 0\\n except (GeneratorExit, KeyboardInterrupt):\\n raise\\n except:\\n # Log it and skip the image\\n logging.exception(\\\"Error processing image {}\\\".format(\\n dataset.image_info[image_id]))\\n error_count += 1\\n if error_count > 5:\\n raise\",\n \"def next_batch(self):\\n next_train_index = self.curr_train_index + self.hparams.batch_size\\n if next_train_index > self.num_train:\\n # Increase epoch number\\n epoch = self.epochs + 1\\n self.reset()\\n self.epochs = epoch\\n batched_data = (\\n self.train_images[self.curr_train_index:self.curr_train_index +\\n self.hparams.batch_size],\\n self.train_labels[self.curr_train_index:self.curr_train_index +\\n self.hparams.batch_size])\\n final_imgs = []\\n images, labels = batched_data\\n if self.hparams.augment_type == 'mixup':\\n images, labels = augmentation_transforms.mixup_batch(\\n images, labels, self.hparams.mixup_alpha)\\n elif self.hparams.augment_type == 'image_freq':\\n images, labels = augmentation_transforms.freq_augment(\\n images,\\n labels,\\n amplitude=self.hparams.freq_augment_amplitude,\\n magnitude=self.hparams.augmentation_magnitude,\\n proportion_f=self.hparams.freq_augment_ffrac,\\n probability=self.hparams.augmentation_probability)\\n for data in images:\\n if self.hparams.augment_type == 'autoaugment':\\n epoch_policy = self.good_policies[np.random.choice(\\n len(self.good_policies))]\\n final_img = augmentation_transforms.apply_policy(epoch_policy, data)\\n elif self.hparams.augment_type == 'random':\\n epoch_policy = found_policies.random_policy(\\n self.hparams.num_augmentation_layers,\\n self.hparams.augmentation_magnitude,\\n self.hparams.augmentation_probability)\\n final_img = augmentation_transforms.apply_policy(epoch_policy, data)\\n else:\\n final_img = np.copy(data)\\n if self.hparams.apply_flip_crop:\\n final_img = augmentation_transforms.random_flip(\\n augmentation_transforms.zero_pad_and_crop(data, 4))\\n # Apply cutout\\n if self.hparams.apply_cutout:\\n final_img = augmentation_transforms.cutout_numpy(final_img)\\n\\n final_imgs.append(final_img)\\n final_imgs = np.array(final_imgs, np.float32)\\n if self.hparams.noise_type == 'radial':\\n labels = augmentation_transforms.add_radial_noise(\\n final_imgs, labels, self.hparams.frequency, self.hparams.amplitude,\\n self.hparams.noise_class, self.hparams.normalize_amplitude)\\n elif self.hparams.noise_type == 'random' or self.hparams.noise_type == 'fourier' or self.hparams.noise_type == 'f' or self.hparams.noise_type == '1/f':\\n labels = augmentation_transforms.add_sinusoidal_noise(\\n final_imgs, labels, self.hparams.frequency, self.hparams.amplitude,\\n self.direction, self.hparams.noise_class,\\n self.hparams.normalize_amplitude)\\n elif self.hparams.noise_type == 'uniform':\\n labels = augmentation_transforms.add_uniform_noise(\\n labels, self.hparams.amplitude, self.hparams.noise_class)\\n\\n batched_data = (final_imgs, labels)\\n self.curr_train_index += self.hparams.batch_size\\n return batched_data\",\n \"def test_cropping(self, scaffold_res=9):\\n device = \\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\"\\n func = self._get_simple_implicit_function(scaffold_res=scaffold_res).to(device)\\n\\n assert scaffold_res >= 8\\n div = (scaffold_res - 1) / 2\\n true_min_point = torch.tensor(\\n [-3 / div, 0 / div, -3 / div],\\n device=device,\\n )\\n true_max_point = torch.tensor(\\n [1 / div, 2 / div, 3 / div],\\n device=device,\\n )\\n\\n def new_scaffold(points):\\n # 1 if between true_min and true_max point else 0\\n # return points.new_ones((*points.shape[:-1], 1))\\n return (\\n torch.logical_and(true_min_point <= points, points <= true_max_point)\\n .all(dim=-1)\\n .float()[..., None]\\n )\\n\\n called_crop = []\\n\\n def assert_min_max_points(min_point, max_point):\\n called_crop.append(1)\\n self.assertClose(min_point, true_min_point)\\n self.assertClose(max_point, true_max_point)\\n\\n func.voxel_grid_density.crop_self = assert_min_max_points\\n func.voxel_grid_color.crop_self = assert_min_max_points\\n func.voxel_grid_scaffold.forward = new_scaffold\\n func._scaffold_ready = True\\n func._crop(epoch=0)\\n assert len(called_crop) == 2\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.58771247","0.57928264","0.57725567","0.5747757","0.5570905","0.5488688","0.5483506","0.5471397","0.5459297","0.5440349","0.54253316","0.54131067","0.5412875","0.54017425","0.5401398","0.5400203","0.53945994","0.5369897","0.5358676","0.53234917","0.53224057","0.53115916","0.5304172","0.53022957","0.52911717","0.5286568","0.5269146","0.52498746","0.52493995","0.52396595","0.5237978","0.52285534","0.5224655","0.5201862","0.5193518","0.51905924","0.51764727","0.5168997","0.5141399","0.5139416","0.5129645","0.51272124","0.5116323","0.5113516","0.51128894","0.51109856","0.5109169","0.509832","0.5088193","0.50726056","0.5063736","0.50575995","0.5053642","0.50493675","0.50470614","0.5043403","0.50356776","0.5034325","0.50331897","0.50328207","0.5030275","0.5030061","0.50263387","0.50237846","0.50202626","0.5019802","0.50169945","0.5014104","0.50125146","0.5007764","0.5006442","0.50004387","0.499862","0.49985516","0.49985448","0.49950624","0.49916038","0.49895415","0.49790445","0.49774477","0.49735272","0.49735272","0.49723563","0.4971741","0.49698174","0.49695978","0.49647725","0.49624208","0.49590203","0.49557137","0.4952673","0.49489608","0.49433336","0.49414897","0.4938364","0.49352977","0.4935217","0.4935151","0.49349958","0.49343327"],"string":"[\n \"0.58771247\",\n \"0.57928264\",\n \"0.57725567\",\n \"0.5747757\",\n \"0.5570905\",\n \"0.5488688\",\n \"0.5483506\",\n \"0.5471397\",\n \"0.5459297\",\n \"0.5440349\",\n \"0.54253316\",\n \"0.54131067\",\n \"0.5412875\",\n \"0.54017425\",\n \"0.5401398\",\n \"0.5400203\",\n \"0.53945994\",\n \"0.5369897\",\n \"0.5358676\",\n \"0.53234917\",\n \"0.53224057\",\n \"0.53115916\",\n \"0.5304172\",\n \"0.53022957\",\n \"0.52911717\",\n \"0.5286568\",\n \"0.5269146\",\n \"0.52498746\",\n \"0.52493995\",\n \"0.52396595\",\n \"0.5237978\",\n \"0.52285534\",\n \"0.5224655\",\n \"0.5201862\",\n \"0.5193518\",\n \"0.51905924\",\n \"0.51764727\",\n \"0.5168997\",\n \"0.5141399\",\n \"0.5139416\",\n \"0.5129645\",\n \"0.51272124\",\n \"0.5116323\",\n \"0.5113516\",\n \"0.51128894\",\n \"0.51109856\",\n \"0.5109169\",\n \"0.509832\",\n \"0.5088193\",\n \"0.50726056\",\n \"0.5063736\",\n \"0.50575995\",\n \"0.5053642\",\n \"0.50493675\",\n \"0.50470614\",\n \"0.5043403\",\n \"0.50356776\",\n \"0.5034325\",\n \"0.50331897\",\n \"0.50328207\",\n \"0.5030275\",\n \"0.5030061\",\n \"0.50263387\",\n \"0.50237846\",\n \"0.50202626\",\n \"0.5019802\",\n \"0.50169945\",\n \"0.5014104\",\n \"0.50125146\",\n \"0.5007764\",\n \"0.5006442\",\n \"0.50004387\",\n \"0.499862\",\n \"0.49985516\",\n \"0.49985448\",\n \"0.49950624\",\n \"0.49916038\",\n \"0.49895415\",\n \"0.49790445\",\n \"0.49774477\",\n \"0.49735272\",\n \"0.49735272\",\n \"0.49723563\",\n \"0.4971741\",\n \"0.49698174\",\n \"0.49695978\",\n \"0.49647725\",\n \"0.49624208\",\n \"0.49590203\",\n \"0.49557137\",\n \"0.4952673\",\n \"0.49489608\",\n \"0.49433336\",\n \"0.49414897\",\n \"0.4938364\",\n \"0.49352977\",\n \"0.4935217\",\n \"0.4935151\",\n \"0.49349958\",\n \"0.49343327\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6750257"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21989,"cells":{"query":{"kind":"string","value":"generate upstream cherrypick patch files"},"document":{"kind":"string","value":"def generate_patch_files(sha_list: List[str], start_version: int) -> PatchList:\n upstream_dir = paths.TOOLCHAIN_LLVM_PATH\n fetch_upstream_once()\n result = PatchList()\n for sha in sha_list:\n if len(sha) < 40:\n sha = get_full_sha(upstream_dir, sha)\n file_path = paths.SCRIPTS_DIR / 'patches' / 'cherry' / f'{sha}.patch'\n assert not file_path.exists(), f'{file_path} already exists'\n with open(file_path, 'w') as fh:\n check_call(f'git format-patch -1 {sha} --stdout',\n stdout=fh, shell=True, cwd=upstream_dir)\n\n commit_subject = check_output(\n f'git log -n1 --format=%s {sha}', shell=True, cwd=upstream_dir)\n comment = '[UPSTREAM] ' + commit_subject.strip()\n rel_patch_path = f'cherry/{sha}.patch'\n end_version = sha_to_revision(sha)\n result.append(PatchItem(comment, rel_patch_path, start_version, end_version))\n return result"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def do_genpatch(self, argv):\n #TODO:\n # - Would an optional [<files> ...] argument be useful or is\n # that overkill? E.g. 'p4 genpatch ./...' (I think that that\n # would be very useful.\n # - Could add '-f' option to only warn on 'out of sync'.\n # - Could add '-d<flag>' option to control to diff format.\n # Context and unified allowed.\n # - Handling binary files that cannot be diff'd\n # - Option to be able to control the base dir so the patch -p#\n # number can be controlled. Dunno what form that should\n # take.\n\n # Process options.\n diffFormat = 'u'\n if diffFormat == 'u':\n prefixes = ('---', '+++')\n elif diffFormat == 'c':\n prefixes = ('***', '---')\n\n # Process args.\n if not argv[1:]:\n change = 'default'\n elif len(argv[1:]) == 1:\n change = argv[1]\n try:\n change = int(change)\n except ValueError: \n # Stupidly, p4win's new Tool %c interpolation will use\n # \"Default\", on which the normal p4.exe client will die.\n change = change.lower()\n if change != 'default':\n sys.stderr.write(\"Invalid changelist number '%s'.\\n\"\\\n % change)\n return 1\n else:\n sys.stderr.write(\"Usage: genpatch [<changelist#>]\\n\")\n sys.stderr.write(\"Missing/wrong number of arguments.\\n\")\n return 1\n\n # Validate the given change number.\n p4 = p4lib.P4( **p4lib.parseOptv(self.__p4optv) )\n submitted = [c['change'] for c in p4.changes(status='submitted')]\n pending = [c['change'] for c in p4.changes(status='pending')]\n if change in submitted:\n status = 'submitted'\n elif change in pending+['default']:\n status = 'pending'\n else:\n sys.stderr.write(\"Change %s unknown.\" % change)\n return 1\n\n # Get list of files to include in patch.\n if status == 'submitted':\n d = p4.describe(change, diffFormat='u')\n desc = d['description']\n files = d['files']\n diffs = d['diff']\n elif status == 'pending':\n files = p4.opened(change=change)\n if change == 'default':\n desc = None\n else:\n desc = p4.change(change=change)['description']\n if files:\n diffs = p4.diff([f['depotFile'] for f in files],\n diffFormat='u')\n else:\n diffs = []\n\n # Make a single string from 'diffs' with appropriate delimiters\n # for the \"patch\" program.\n diffstr = ''\n timestamp = time.asctime()\n for diff in diffs:\n # Perforce std header, e.g.:\n # ==== //depot/apps/px/ReadMe.txt#5 (text) ====\n # or\n # ==== //depot/foo.doc#42 - c:\\trentm\\foo.doc ==== (binary)\n if diff.has_key('localFile'):\n diffstr += \"==== %(depotFile)s#%(rev)s - %(localFile)s ====\"\\\n % diff\n if diff['binary']:\n diffstr += \" (binary)\"\n diffstr += \"\\n\"\n else:\n diffstr += \"==== %(depotFile)s#%(rev)s (%(type)s) ====\\n\"\\\n % diff\n # Patch header, e.g. for unified diffs:\n # Index: apps/px/test/ToDo.txt\n # --- apps/px/test/ToDo.txt.~1~ Fri May 31 21:17:17 2002\n # +++ apps/px/test/ToDo.txt Fri May 31 21:17:17 2002\n # or for context diffs:\n # Index: apps/px/test/ToDo.txt\n # *** apps/px/test/ToDo.txt.~1~ Fri May 31 21:26:47 2002\n # --- apps/px/test/ToDo.txt Fri May 31 21:26:47 2002\n fname = diff['depotFile'][len('//depot/'):]\n\n if diff.has_key('text'):\n diffstr += \"Index: %s\\n\" % fname\n diffstr += \"%s %s.~1~\\t%s\\n\" % (prefixes[0], fname, timestamp)\n diffstr += \"%s %s\\t%s\\n\" % (prefixes[1], fname, timestamp)\n # The diff text.\n diffstr += ''.join(diff['text'])\n if diffstr[-1] != '\\n':\n diffstr += \"\\n\\\\ No newline at end of file\\n\"\n\n # Inline added files into the diff.\n addedfiles = [f for f in files if f['action'] in ('add', 'branch')]\n for f in addedfiles:\n # May have to get file type from 'p4 files'.\n if status == 'submitted':\n f['type'] = p4.files(f['depotFile'])[0]['type']\n # Skip file if it is binary.\n if f['type'].startswith('binary'):\n log.warn(\"Cannot inline '%s' because it is binary.\"\\\n % f['depotFile'])\n continue\n # Get the file contents.\n if status == \"pending\":\n # Read the file contents from disk.\n localFile = p4.where(f['depotFile'])[0]['localFile']\n if not os.path.exists(localFile):\n continue\n lines = open(localFile, 'r').readlines()\n else:\n # Get the file contents via 'p4 print'.\n fnameRev = \"%s#%s\" % (f['depotFile'], f['rev'])\n lines = p4.print_(fnameRev)[0]['text'].split('\\n')\n if not lines[-1]: lines = lines[:-1] # drop empty last line\n lines = [line+'\\n' for line in lines]\n # Inline the file.\n diffstr += \"\\n==== %(depotFile)s#%(rev)s (%(type)s) ====\\n\" % f\n if len(lines) < 2:\n ln = \"\"\n else:\n ln = \",\" + str(len(lines))\n fname = f['depotFile'][len('//depot/'):]\n diffstr += \"Index: %s\\n\" % fname\n diffstr += \"%s %s.~1~\\t%s\\n\" % (prefixes[0], fname, timestamp)\n diffstr += \"%s %s\\t%s\\n\" % (prefixes[1], fname, timestamp)\n diffstr += \"@@ -0,0 +1%s @@\\n\" % ln\n diffstr += '+' + '+'.join(lines)\n if diffstr[-1] != '\\n':\n diffstr += \"\\n\\\\ No newline at end of file\\n\"\n \n if diffstr: # std patch terminator\n diffstr += \"End of Patch.\"\n\n patch = p4lib.makeForm(description=desc, files=files,\n differences=diffstr)\n if patch: # ViM-specific hack to have it colorize patches as diffs.\n patch = \"diff\\n\" + patch\n\n sys.stdout.write(patch)","def git_upgraded_pkgs(self):\n\n self.extract_from_cachedir()\n self.etc_commits.added.commit()\n\n cherry_pick_sha = None\n if self.etc_commits.cherry_pick.rpaths:\n self.etc_commits.cherry_pick.commit()\n cherry_pick_sha = self.repo.git_cmd('rev-list -1 HEAD --')\n\n # Clean the working area of the files that are not under version\n # control.\n self.repo.git_cmd('clean -d -x -f')\n\n # Update the master-tmp branch with new files.\n if self.master_commits.added.rpaths:\n self.repo.checkout('master-tmp')\n for rpath in self.master_commits.added.rpaths:\n repo_file = os.path.join(self.repodir, rpath)\n if os.path.lexists(repo_file):\n warn('adding %s to the master-tmp branch but this file'\n ' already exists' % rpath)\n copy_file(rpath, self.root_dir, self.repodir,\n repo_file=repo_file)\n self.master_commits.added.commit()\n\n return cherry_pick_sha","def cherryPickChange(self):\n rev = io.getNumber('Revision number to cherry-pick:')\n bug = io.getNumber('Issue fixed by this change:')\n\n diff = subversion.diff(self.upstream_repos + '/trunk', rev)\n if not diff.strip():\n raise error.ExpectationFailed(\n 'Retrieved diff is empty. '\n 'Did you accidentally cherry-pick a branch change?')\n util.run(['patch', '-p0'], cwd=self.wc.path(self.branch_dir), stdin=diff)\n self.wc.addRemove(self.branch_dir)\n\n yaml_path = self.wc.path(self._branchPath('app/app.yaml'))\n out = []\n updated_patchlevel = False\n for line in io.fileToLines(yaml_path):\n if line.strip().startswith('version: '):\n version = line.strip().split()[-1]\n base, patch = line.rsplit('g', 1)\n new_version = '%sg%d' % (base, int(patch) + 1)\n message = ('Cherry-picked r%d from /p/soc/ to fix issue %d' %\n (rev, bug))\n out.append('version: ' + new_version)\n out.append('# * ' + message)\n updated_patchlevel = True\n else:\n out.append(line)\n\n if not updated_patchlevel:\n log.error('Failed to update Google patch revision')\n log.error('Cherry-picking failed')\n\n io.linesToFile(yaml_path, out)\n\n log.info('Check the diff about to be committed with:')\n log.info('svn diff ' + self.wc.path(self.branch_dir))\n if not io.confirm('Commit this change?'):\n raise error.AbortedByUser('Cherry-pick aborted')\n self.wc.commit(message)\n log.info('Cherry-picked r%d from the Melange trunk.' % rev)","def cmd_apply_patch(patchfile):\n return ['git', 'apply', patchfile]","def write_tmp_patches(diffs):\n files = []\n for idx, diff in enumerate(diffs):\n prefix = 'cugit-%s-' % str(idx).zfill(5)\n suffix = '-patch'\n filename = mkstemp(suffix, prefix)[1]\n write_tmp_patch(diff, filename)\n files.append(filename)\n return files","def copy_patches(root_directory, dist_directory, sdk_directory,\n cpus, families, boards):\n\n def _process(when, contexts):\n for context in contexts:\n for patch in configuration.PATCHES:\n if patch[\"when\"] == when:\n context.update({\n \"root\": root_directory,\n \"sdk\": sdk_directory,\n \"dist\": dist_directory\n })\n\n source = templates.from_string(patch[\"source\"], context)\n target = templates.from_string(patch[\"target\"], context)\n target = os.path.join(dist_directory, target)\n\n # Perform the action.\n sys.stdout.write(\"Patching '%s'\\n\" % source)\n\n if patch[\"type\"] == \"file\":\n with open(source, \"r\") as fp:\n content = fp.read()\n\n for method in patch[\"methods\"]:\n content = method(source, content)\n\n with open(target, \"w\") as fp:\n fp.write(content)\n elif patch[\"type\"] == \"glob\":\n for source_file in glob.glob(source):\n if os.path.isfile(source_file):\n target_file = os.path.join(\n target, os.path.basename(source_file))\n\n with open(source_file, \"r\") as fp:\n content = fp.read()\n\n for method in patch[\"methods\"]:\n content = method(source, content)\n\n with open(target_file, \"w\") as fp:\n fp.write(content)\n else:\n raise Exception(\"Not supported\")\n\n _process(\"per_family\", families)\n _process(\"per_cpu\", cpus)\n _process(\"per_board\", boards)\n _process(\"per_once\", [{\n \"families\": [family[\"family\"] for family in families],\n \"cpus\": [cpu[\"cpu\"] for cpu in cpus],\n \"boards\": [board[\"board\"] for board in boards]\n }])","def bump_upstream_sources(**kwargs):\n\n # Find out current tracking branch to bump\n # the services matching the branch:\n oa_folder = kwargs['workdir'] + '/openstack-ansible'\n try:\n remote_branch = tracking_branch_name(oa_folder)\n except ValueError as verr:\n raise SystemExit(verr)\n\n LOGGER.info(\"Each file can take a while to update.\")\n prevline = {}\n reporegex = re.compile('(?P<project>.*)_git_repo: (?P<remote>.*)')\n branchregex = re.compile(('(?P<project>.*)_git_install_branch: '\n '(?P<sha>[0-9a-f]{40}) '\n '# HEAD of \"(?P<branch>.*)\" '\n 'as of .*'))\n\n update_files = glob.glob(\n \"{}/playbooks/defaults/repo_packages/*.yml\".format(oa_folder))\n\n stable_branch_skips = [\n \"openstack_testing.yml\",\n \"nova_consoles.yml\",\n ]\n\n for filename in update_files:\n if remote_branch.startswith(\"stable/\") and \\\n os.path.basename(filename) in stable_branch_skips:\n LOGGER.info(\"Skipping {} for stable branch\".format(filename))\n continue\n LOGGER.info(\"Updating {}\".format(filename))\n for line in fileinput.input(filename, inplace=True):\n rrm = reporegex.match(line)\n if rrm:\n # Extract info of repo line (previous line)\n # for branch line (current line)\n prevline['project'] = rrm.group('project')\n prevline['remote'] = rrm.group('remote')\n print(branchregex.sub(\n lambda x: bump_project_sha_with_comments(x, prevline), line)),\n\n LOGGER.info(\"All files patched !\")\n msg = (\"Update all SHAs for {next_release}\\n\\n\"\n \"This patch updates all the roles to the latest available stable \\n\"\n \"SHA's, copies the release notes from the updated roles into the \\n\"\n \"integrated repo, updates all the OpenStack Service SHA's, and \\n\"\n \"updates the appropriate python requirements pins. \\n\\n\"\n \"Depends-On: {release_changeid}\").format(\n next_release=os.environ.get('next_release', '<NEW VERSION>'),\n release_changeid=os.environ.get('release_changeid', '<TODO>'),)\n if kwargs['commit']:\n repo = Repo(oa_folder)\n repo.git.add('.')\n repo.index.commit(msg)\n click.echo(\"Commit done. Please verify before review.\")\n else:\n click.echo(\"Here is a commit message you could use:\\n\")\n click.echo(msg)","def patch_files():\n args = parser.parse_args()\n doc = json.load(args.ORIGINAL)\n patch = json.load(args.PATCH)\n result = jsonpatch.apply_patch(doc, patch)\n print(json.dumps(result, indent=args.indent))","def createPatch(self):\n\n if not CraftCore.cache.findApplication(\"diff\"):\n CraftCore.log.critical(\"could not find diff tool, please run 'craft diffutils'\")\n return False\n\n # get the file paths of the tarballs\n filenames = self.localFileNames()\n\n destdir = self.workDir()\n\n # it makes no sense to make a diff against nothing\n if not os.path.exists(self.sourceDir()):\n CraftCore.log.error(\"source directory doesn't exist, please run unpack first\")\n return False\n\n CraftCore.log.debug(\"unpacking files into work root %s\" % destdir)\n\n # make a temporary directory so the original packages don't overwrite the already existing ones\n with tempfile.TemporaryDirectory() as tmpdir:\n _patchName = f\"{self.package.name}-{self.buildTarget}-{str(datetime.date.today()).replace('-', '')}.diff\"\n\n # unpack all packages\n for filename in filenames:\n CraftCore.log.debug(f\"unpacking this file: {filename}\")\n if not utils.unpackFile(self.__downloadDir, filename, tmpdir):\n return False\n\n patches = self.subinfo.patchesToApply()\n if not isinstance(patches, list):\n patches = [patches]\n for fileName, patchdepth in patches:\n if os.path.basename(fileName) == _patchName:\n CraftCore.log.info(f\"skipping patch {fileName} with patchlevel: {patchdepth}\")\n continue\n CraftCore.log.info(f\"applying patch {fileName} with patchlevel: {patchdepth}\")\n if not self.applyPatch(\n fileName,\n patchdepth,\n os.path.join(tmpdir, os.path.relpath(self.sourceDir(), self.workDir())),\n ):\n return False\n\n srcSubDir = os.path.relpath(self.sourceDir(), self.workDir())\n tmpSourceDir = os.path.join(tmpdir, srcSubDir)\n with io.BytesIO() as out:\n ignores = []\n for x in [\n \"*~\",\n r\"*\\.rej\",\n r\"*\\.orig\",\n r\"*\\.o\",\n r\"*\\.pyc\",\n \"CMakeLists.txt.user\",\n ]:\n ignores += [\"-x\", x]\n\n # TODO: actually we should not accept code 2\n if not utils.system(\n [\"diff\", \"-Nrub\"] + ignores + [tmpSourceDir, self.sourceDir()],\n stdout=out,\n acceptableExitCodes=[0, 1, 2],\n cwd=destdir,\n ):\n return False\n patchContent = out.getvalue()\n # make the patch a -p1 patch\n patchContent = patchContent.replace(tmpSourceDir.encode(), f\"{srcSubDir}.orig\".encode())\n patchContent = patchContent.replace(str(self.sourceDir()).encode(), srcSubDir.encode())\n patchPath = os.path.join(self.packageDir(), _patchName)\n with open(patchPath, \"wb\") as out:\n out.write(patchContent)\n\n CraftCore.log.info(f'Patch created {patchPath} self.patchToApply[\"{self.buildTarget}\"] = [(\"{_patchName}\", 1)]')\n return True","def push_mockups():\n local('cd ../../cts-ui && grunt')\n local('cp ../../cts-ui/mockups/css/*.css ../../mockups/cts-ui/css/.')\n local('cp -R ../../cts-ui/mockups/css/bootstrap ../../mockups/cts-ui/css/bootstrap')\n local('cp -R ../../cts-ui/mockups/img ../../mockups/cts-ui/img')\n local('cp ../../cts-ui/mockups/*.html ../../mockups/cts-ui/.')\n local('cd ../../mockups/cts-ui && git add *.html')\n local('cd ../../mockups/cts-ui/css && git add *.css')\n local('cd ../../mockups/cts-ui/css && git add bootstrap/*')\n local('cd ../../mockups/cts-ui && git add img/*')\n local('cd ../../mockups && git commit -am \"New cts-ui mockups [fabfile]\"')\n local('cd ../../mockups && git push origin master')","def apply_patch(self, patch):\n # Remove Chromium WPT directory prefix.\n patch = patch.replace(RELATIVE_WPT_TESTS, '')\n try:\n self.run(['git', 'apply', '-'], input=patch)\n self.run(['git', 'add', '.'])\n except ScriptError as error:\n return error.message\n return ''","def createPatch(self):\n CraftCore.debug.trace(\"GitSource createPatch\")\n patchFileName = os.path.join(\n self.packageDir(),\n \"%s-%s.patch\" % (self.package.name, str(datetime.date.today()).replace(\"-\", \"\")),\n )\n CraftCore.log.debug(\"git diff %s\" % patchFileName)\n with open(patchFileName, \"wt+\") as patchFile:\n return self.__git(\"diff\", stdout=patchFile)","def patch_repos(self):","def platformify(self):\n actions = ['rsync -aP {0} {1}'.format(\n os.path.join(TEMPLATEDIR, self.name, 'files/'), self.builddir\n )]\n patches = glob(os.path.join(TEMPLATEDIR, self.name, \"*.patch\"))\n for patch in patches:\n actions.append('cd {0}/web && patch -p1 < {1}'.format(\n self.builddir, patch)\n )\n\n # In some cases the package updater needs to be run after we've platform-ified the\n # template, so run it a second time. Worst case it's a bit slower to build but doesn't\n # hurt anything.\n actions.extend(self.package_update_actions())\n\n return actions","def clpatch(ui, repo, clname, **opts):\n\tcl, patch, err = DownloadCL(ui, repo, clname)\n\targv = [\"hgpatch\"]\n\tif opts[\"no_incoming\"]:\n\t\targv += [\"--checksync=false\"]\n\tif err != \"\":\n\t\treturn err\n\ttry:\n\t\tcmd = subprocess.Popen(argv, shell=False, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=None, close_fds=True)\n\texcept:\n\t\treturn \"hgpatch: \" + ExceptionDetail()\n\tif os.fork() == 0:\n\t\tcmd.stdin.write(patch)\n\t\tos._exit(0)\n\tcmd.stdin.close()\n\tout = cmd.stdout.read()\n\tif cmd.wait() != 0:\n\t\treturn \"hgpatch failed\"\n\tcl.local = True\n\tcl.files = out.strip().split()\n\tfiles = ChangedFiles(ui, repo, [], opts)\n\textra = Sub(cl.files, files)\n\tif extra:\n\t\tui.warn(\"warning: these files were listed in the patch but not changed:\\n\\t\" + \"\\n\\t\".join(extra) + \"\\n\")\n\tcl.Flush(ui, repo)\n\tui.write(cl.PendingText() + \"\\n\")","def maybe_apply_patches(input_dir, patch_files=None):\n if not patch_files:\n return\n old_dir = os.getcwd()\n os.chdir(input_dir)\n for patch_file in patch_files:\n with open(patch_file) as patch_in:\n patch_proc = subprocess.Popen(['git', 'am', '--3way'],\n stdin=patch_in)\n status = patch_proc.wait()\n if status != 0:\n raise RuntimeError('Patch failed; git output: %s' % status)\n logging.info(\"Finished applying patch %s\", patch_file)\n os.chdir(old_dir)","def port_patches(\n default_prior_dir,\n default_post_dir,\n resource_prior_patches_dir,\n resource_post_patches_dir,\n resource_post_dir,\n resource_prior_dir=None,\n default_post_patches_dir=None,\n action=None,\n all_patch=False):\n\n default_prior_dir = os.path.expanduser(default_prior_dir)\n default_post_dir = os.path.expanduser(default_post_dir)\n resource_prior_patches_dir = os.path.expanduser(resource_prior_patches_dir)\n resource_post_patches_dir = os.path.expanduser(resource_post_patches_dir)\n resource_post_dir = os.path.expanduser(resource_post_dir)\n if resource_prior_dir:\n resource_prior_dir = os.path.expanduser(resource_prior_dir)\n if default_post_patches_dir:\n default_post_patches_dir = os.path.expanduser(default_post_patches_dir)\n\n os.makedirs(resource_post_patches_dir, exist_ok=True)\n os.makedirs(resource_post_dir, exist_ok=True)\n\n resource_prior_patch_map = {}\n resource_prior_patch_map_path = os.path.join(resource_prior_dir, \"patch_map.json\")\n if os.path.isfile(resource_prior_patch_map_path):\n with open(resource_prior_patch_map_path, \"r\") as resource_prior_patch_map_file:\n resource_prior_patch_map = json.load(resource_prior_patch_map_file)\n\n resource_post_patch_map = {}\n resource_post_patch_map_path = os.path.join(resource_post_dir, \"patch_map.json\")\n if os.path.isfile(resource_post_patch_map_path):\n with open(resource_post_patch_map_path, \"r\") as resource_post_patch_map_file:\n resource_post_patch_map = json.load(resource_post_patch_map_file)\n\n default_post_patch_map = {}\n default_post_patch_map_path = os.path.join(default_post_dir, \"patch_map.json\")\n if os.path.isfile(default_post_patch_map_path):\n with open(default_post_patch_map_path, \"r\") as default_post_patch_map_file:\n default_post_patch_map = json.load(default_post_patch_map_file)\n\n image_hashes = hash_images(default_prior_dir, resource_prior_patches_dir)\n\n # used for printing completion state during long-running task\n file_count = 0\n file_checkpoint = 0\n file_total = sum(len(files) for _, _, files in os.walk(default_post_dir))\n\n # attempt to texture everything in the merged output space\n for file_dir, _, file_names in os.walk(default_post_dir):\n for file_name in file_names:\n file_count += 1\n if file_count / file_total > file_checkpoint:\n print(f\"Remapping status: {file_checkpoint:.0%}\")\n file_checkpoint += .05\n\n # .mcmeta files are also ported when the associated .png is ported\n if not file_name.endswith(\".png\"):\n continue\n\n file_path = os.path.join(file_dir, file_name)\n relative_path = file_path.replace(default_post_dir, \"\")\n\n # full path to the file in the output merged space\n merged_post_resource_path = os.path.join(resource_post_dir, *relative_path.split(os.sep))\n\n # skip if already textured\n if action != 'copy-overwrite' and os.path.exists(merged_post_resource_path):\n continue\n\n # retrieve paths to all resource pack textures for this target image\n with open(file_path, 'rb') as image_file:\n image_hash = hashlib.md5(image_file.read()).hexdigest()\n matches = image_hashes.get(image_hash)\n\n if matches is None:\n continue\n # TODO: evaluate fitness of each match, and choose the best? seems very situational\n best_match = matches[0]\n\n if all_patch:\n default_patch_name, patch_name = 'All', 'All'\n else:\n default_patch_name, patch_name = infer_resource_patch_name(\n default_post_patches_dir,\n resource_post_patches_dir,\n default_post_patch_map,\n resource_prior_patch_map,\n resource_post_patch_map,\n relative_path,\n matches)\n\n if patch_name is None:\n continue\n\n # full path to the file in the output patch space\n post_resource_path = os.path.join(resource_post_patches_dir, patch_name, *relative_path.split(os.sep))\n\n # if source is same as target, then this is a no-op\n prior_resource_path = os.path.join(resource_prior_patches_dir, best_match)\n if prior_resource_path == post_resource_path:\n continue\n\n if os.path.exists(post_resource_path) and action != 'copy-overwrite':\n continue\n\n print()\n if len(matches) > 1:\n print(f\"Multiple matches found ({len(matches)}). Mapping from first:\")\n\n print(f'{action}: {best_match}\\n'\n f' -> {os.path.join(patch_name, *relative_path.split(os.sep))}')\n\n os.makedirs(os.path.dirname(post_resource_path), exist_ok=True)\n\n # move or copy the file\n perform_action(prior_resource_path, post_resource_path, action)\n\n prior_resource_meta_path = prior_resource_path + '.mcmeta'\n if os.path.exists(prior_resource_meta_path):\n print(f'{action}: {prior_resource_meta_path.replace(resource_prior_patches_dir, \"\")}\\n'\n f' -> {os.path.join(*post_resource_path.replace(resource_post_patches_dir, \"\").split(os.sep))}.mcmeta')\n\n perform_action(prior_resource_meta_path, post_resource_path + '.mcmeta', action)\n\n if not all_patch:\n update_mod_json(\n default_post_patches_dir,\n resource_prior_patches_dir,\n resource_post_patches_dir,\n relative_path,\n default_patch_name,\n patch_name)\n\n if os.path.exists(os.path.join(resource_post_patches_dir, UNKNOWN_PATCH_NAME)):\n print(\"Check the _UNKNOWN folder for textures ported into domains that did not belong to a previous patch.\")","def mspatchc_CreatePatchFile(jitter, get_str, set_str):\n ret_ad, args = jitter.func_args_stdcall([\"OldFileName\", \"NewFileName\", \"PatchFileName\", \"OptionFlags\", \"OptionData\"])\n raise RuntimeError('API not implemented')\n jitter.func_ret_stdcall(ret_ad, ret_value)","def cherry_pick_change(branch, revision, parent_repo, dry_run, verbose=False):\n drover = _Drover(branch, revision, parent_repo, dry_run, verbose)\n drover.run()","def test_resetcherrypick_removes_added_files(\n repository: Repository, paths: Iterator[Path]\n) -> None:\n main = repository.head\n update, _ = createbranches(repository, \"update\", \"latest\")\n path1, path2 = next(paths), next(paths)\n\n repository.checkout(update)\n updatefiles({path1: \"a\", path2: \"\"})\n\n repository.checkout(main)\n updatefile(path1, \"b\")\n\n with pytest.raises(MergeConflictError, match=path1.name):\n repository.cherrypick(update.commit)\n\n repository.resetcherrypick()\n\n assert not path2.exists()","def update(filepath, github_account):\n repo = _git.clone_from_github(\n _REPO_PATH, join(filepath, _REPO_NAME), github_account=github_account)\n _install_dependencies(repo)\n added, deleted, updated = _generate_all_clients(repo)\n if not any([added, deleted, updated]):\n return\n _run_tests(repo)\n commitmsg = _commit_message.build(added, deleted, updated)\n repo.add(['api_names_out.yaml', 'generated'])\n repo.commit(commitmsg, github_account.name, github_account.email)\n repo.push()","def prep( c ):\n\n copytree( \"vendor\", \"dist/please_respond/timezonefinder\" )","def test_resetcherrypick_keeps_unrelated_additions(\n repository: Repository, paths: Iterator[Path]\n) -> None:\n main = repository.head\n update, _ = createbranches(repository, \"update\", \"latest\")\n path1, path2 = next(paths), next(paths)\n\n repository.checkout(update)\n updatefile(path1, \"a\")\n\n repository.checkout(main)\n updatefile(path1, \"b\")\n\n path2.touch()\n\n with pytest.raises(MergeConflictError, match=path1.name):\n repository.cherrypick(update.commit)\n\n repository.resetcherrypick()\n\n assert path2.exists()","def package():\n \n hou.hipFile.save()\n currentHip = hou.expandString(hou.hipFile.name())\n\n # create a temp directory we are going to fill with crap\n tempFilePath = tempfile.mkdtemp()\n \n otls = os.path.join(tempFilePath, \"otls\")\n os.mkdir(otls)\n files = os.path.join(tempFilePath, \"files\")\n os.mkdir(files)\n \n # Get all the external references to the hipfile\n fileOnDisk = hou.fileReferences()\n\n # loop and do what comes natural.\n for _file in fileOnDisk:\n\n parm = _file[0]\n filepath = _file[1]\n \n # if its a otl we need to store it.\n if filepath.endswith(\".otl\"):\n \n shutil.copy(hou.expandString(filepath), otls)\n \n else:\n \n if not os.path.isfile(hou.expandString(filepath)): \n \n continue\n \n # create a directory in files and save 1 file to that location\n tmpFileName = os.path.basename(hou.expandString(filepath))\n tmpFileDir = os.path.basename(os.path.dirname(hou.expandString(filepath)))\n path = os.path.join(files, tmpFileDir)\n \n if not os.path.isdir(path):\n \n os.mkdir(path)\n\n shutil.copy(hou.expandString(filepath), os.path.join(path, os.path.basename(hou.expandString(filepath))))\n\n try:\n \n if not parm.node().isLocked():\n \n parm.set(os.path.join(path.replace(tempFilePath, \"$HIP\"), tmpFileName))\n \n except hou.PermissionError: \n \n logging.warning(\"Error hardening parm :\" + str(parm.name()) + \"on node \" +parm.node().path())\n\n hou.hipFile.save(os.path.join(tempFilePath, os.path.basename(hou.expandString(hou.hipFile.name()))))\n # Load the source hipfile\n hou.hipFile.load(currentHip)\n \n # create a zipfile and package everything. then copy it to the home.\n zipfileLoc = zipdir(tempFilePath)\n shutil.move(zipfileLoc, os.path.join(hou.expandString(\"~\"), \"package.zip\"))\n shutil.rmtree(tempFilePath)","def _applyGooglePatches(self):\n # Edit the base template to point users to the Google fork\n # of the Melange codebase instead of the vanilla release.\n tmpl_file = self.wc.path(\n self._branchPath('app/soc/templates/soc/base.html'))\n tmpl = io.fileToLines(tmpl_file)\n for i, line in enumerate(tmpl):\n if 'http://code.google.com/p/soc/source/browse/tags/' in line:\n tmpl[i] = line.replace('/p/soc/', '/p/soc-google/')\n break\n else:\n raise error.ExpectationFailed(\n 'No source code link found in base.html')\n io.linesToFile(tmpl_file, tmpl)\n\n self.wc.commit(\n 'Customize the Melange release link in the sidebar menu')","def sync_from_upstream(self):\n if not self.missing_branches:\n self.log(f\"All branches are synced, nothing to do here.\")\n return\n\n with tempfile.TemporaryDirectory() as tmpdir:\n src_path = Path(tmpdir) / self.deb_model.src\n self.deb_model.base.clone(cwd=tmpdir)\n for branch in self.missing_branches:\n self.log(f\"Processing branch {branch}\")\n self.deb_model.base.checkout(branch, new_branch=True, cwd=str(src_path))\n\n changelog_fn = src_path / \"debian/changelog\"\n changelog_fn_tpl = src_path / \"debian/changelog.in\"\n\n k8s_major_minor = semver.VersionInfo.parse(branch.lstrip(\"v\"))\n\n changelog_context = {\n \"deb_version\": f\"{str(k8s_major_minor)}-0\",\n }\n\n self.log(f\"Writing template vars {changelog_context}\")\n changelog_out = changelog_fn_tpl.read_text()\n changelog_out = self.render(changelog_fn_tpl, changelog_context)\n changelog_fn.write_text(changelog_out)\n\n self.log(f\"Committing {branch}\")\n self.deb_model.base.add([str(changelog_fn)], cwd=str(src_path))\n self.deb_model.base.commit(\n f\"Creating branch {branch}\", cwd=str(src_path)\n )\n self.deb_model.base.push(ref=branch, cwd=str(src_path))","def regenerate():\n local('pelican -o {} -r -s pelicanconf.py'.format(env.deploy_path))","def createPatch(self):\n craftDebug.trace(\"HgSource.createPatch called\")\n ret = False\n if self.enableHg:\n os.chdir(self.sourceDir())\n patchFile = os.path.join(self.packageDir(),\n \"%s-%s.patch\" % (self.package, str(datetime.date.today()).replace('-', '')))\n ret = self.system(self.sourceDir(), \"%s diff > %s\" % (self.hgExecutable, patchFile))\n return ret","def mspatchc_CreatePatchFileByHandles(jitter):\n ret_ad, args = jitter.func_args_stdcall([\"OldFileHandle\", \"NewFileHandle\", \"PatchFileHandle\", \"OptionFlags\", \"OptionData\"])\n raise RuntimeError('API not implemented')\n jitter.func_ret_stdcall(ret_ad, ret_value)","def test_resetcherrypick_keeps_unrelated_changes(\n repository: Repository, paths: Iterator[Path]\n) -> None:\n main = repository.head\n update, _ = createbranches(repository, \"update\", \"latest\")\n path1, path2 = next(paths), next(paths)\n\n repository.checkout(update)\n updatefile(path1, \"a\")\n\n repository.checkout(main)\n updatefile(path1, \"b\")\n updatefile(path2)\n\n path2.write_text(\"c\")\n\n with pytest.raises(MergeConflictError, match=path1.name):\n repository.cherrypick(update.commit)\n\n repository.resetcherrypick()\n\n assert path2.read_text() == \"c\"","def main(args):\n\n try:\n repo = RpmGitRepository(args.gitdir)\n except GitRepositoryError, err:\n raise GbsError(str(err))\n\n packaging_dir = get_packaging_dir(args)\n changes_file_list = glob.glob(\"%s/%s/*.changes\" % (repo.path,\n packaging_dir))\n\n if args.spec or not changes_file_list:\n # Create .changes file with the same name as a spec\n specfile = os.path.basename(guess_spec(repo.path,\n packaging_dir, args.spec)[0])\n fn_changes = os.path.splitext(specfile)[0] + \".changes\"\n fn_changes = os.path.join(repo.path, packaging_dir, fn_changes)\n else:\n fn_changes = changes_file_list[0]\n if len(changes_file_list) > 1:\n log.warning(\"Found more than one changes files, %s is taken \"\n % (changes_file_list[0]))\n\n # get the commit start from the args.since\n commitid_since = get_first_commit(repo, fn_changes, args.since)\n\n commits = repo.get_commits(commitid_since, 'HEAD')\n if not commits:\n raise GbsError(\"Nothing found between %s and HEAD\" % commitid_since)\n\n if args.message:\n author = repo.get_author_info()\n lines = [\"- %s\" % line for line in args.message.split(os.linesep) \\\n if line.strip()]\n new_entries = [\"* %s %s <%s> %s\" % \\\n (datetime.datetime.now().strftime(\"%a %b %d %Y\"),\n author.name, author.email,\n get_version(repo, commits[0]))]\n new_entries.extend(lines)\n else:\n new_entries = make_log_entries(commits, repo)\n\n content = get_all_entries(fn_changes, new_entries)\n if edit_file(fn_changes, content):\n log.info(\"Change log has been updated.\")\n else:\n log.info(\"Change log has not been updated\")","def apply_patches():\n # Set USERNAME if needed\n try:\n getpass.getuser()\n except: # pylint: disable=W0702\n os.environ[\"USERNAME\"] = \"git\"\n # Patch dulwich to work without valid UID/GID\n repo._get_default_identity = patched_repo_get_default_identity(repo._get_default_identity) # pylint: disable=W0212\n # Patch dulwich to use paramiko SSH client\n client.get_ssh_vendor = ParamikoSSHVendor\n # Patch paramiko to skip key verification\n paramiko.transport.Transport._verify_key = patched_paramiko_transport_verify_key # pylint: disable=W0212\n # Patch paramiko to support direct pkey usage\n paramiko.client.SSHClient._auth = patched_paramiko_client_SSHClient_auth(paramiko.client.SSHClient._auth) # pylint: disable=C0301,W0212","def gen_versioned_files(self, wave=1):\n if self.file:\n yield self.file\n else:\n py_files = ['setup.cfg', 'setup.py', '*/__init__.py']\n js_files = ['bower.json', 'package.json', 'component.json']\n php_files = ['composer.json']\n misc_files = ['*.spec', '*.php', '*.py', '*.xml', '*.json']\n wave_one = py_files + js_files + php_files\n switch = {1: wave_one, 2: misc_files}\n\n for git_file in self.files:\n if any(fnmatch(git_file, file_) for file_ in switch[wave]):\n yield git_file","def extract_patch(opts, patch_start, patch_length, ucode_file, ucode_level):\n cwd = os.getcwd()\n\n if not os.path.exists(opts.extract):\n os.makedirs(opts.extract)\n\n os.chdir(opts.extract)\n\n ucode_file.seek(patch_start, 0)\n out_file_name = \"mc_patch_0%x.bin\" % (ucode_level)\n out_file = open(out_file_name, \"wb\")\n out_file.write(ucode_file.read(patch_length))\n out_file.close()\n\n print(\" Patch extracted to %s/%s\" % (os.getcwd(), out_file_name))\n\n os.chdir(cwd)","def stage_changes(c):\n c.run(f\"git add -u\")","def generate_apidoc_patches(self):\n base_path = self.paths[\"api_doc_dir\"]\n from django_swagger_utils.core.utils.mk_dirs import MkDirs\n MkDirs().mk_dir_if_not_exits(file_name=base_path + \"/\")\n\n from django_swagger_utils.apidoc_gen.generators.patch_generator import PatchGenerator\n\n patch_generator = PatchGenerator(self.app_name, self.parser, self.paths, base_path)\n # generating api docs\n patch_generator.generate_json_patch()","def _gen_diff_patch(self, git_object_a, git_object_b, src_alias, dst_alias,\n cwd, deps_rev):\n # The prefixes used in the command below are used to find and replace the\n # tree-ish git object id's on the diff output more easily.\n cmd = 'diff %s %s --src-prefix=IAMSRC: --dst-prefix=IAMDST:'\n cmd %= (git_object_a, git_object_b)\n cmd = cmd.split(' ')\n stdout = self.api.m.raw_io.output()\n step_name = 'Generating patch for %s to %s' % (git_object_a, deps_rev)\n step_result = self.api.m.git(*cmd, cwd=cwd, stdout=stdout, name=step_name)\n patch_text = step_result.stdout\n src_string = 'IAMSRC:' + git_object_a\n dst_string = 'IAMDST:' + git_object_b\n patch_text = patch_text.replace(src_string, src_alias)\n patch_text = patch_text.replace(dst_string, dst_alias)\n return patch_text","def cmd_generate_requirements(): \n \n for env in ('dev', 'test'):\n source = Path(ROOT, \"requirements\", f\"{env}.txt\")\n target = Path(ROOT, \"requirements\", f\"{env}.in\")\n os.system(f\"pip-compile --output-file={source} {target}\")","def cmd_generate_requirements(): \n \n for env in ('dev', 'test'):\n source = Path(ROOT, \"requirements\", f\"{env}.txt\")\n target = Path(ROOT, \"requirements\", f\"{env}.in\")\n os.system(f\"pip-compile --output-file={source} {target}\")","def bump_upstream_repos_shas(path):\n filelist = find_yaml_files(path)\n for filename in filelist:\n print(\"Working on %s\" % filename)\n bump_upstream_repos_sha_file(filename)","def install_step(self):\n\n# if LooseVersion(self.version) < LooseVersion('2012-10-05'):\n\tif (False):\n self.inchworm()\n self.chrysalis()\n self.kmer()\n self.butterfly()\n\n bwapluginver = self.cfg['bwapluginver']\n if bwapluginver:\n self.trinityplugin('bwa-%s-patched_multi_map' % bwapluginver)\n\n if self.cfg['RSEMmod']:\n self.trinityplugin('RSEM-mod', cc=os.getenv('CXX'))\n\n else:\n self.jellyfish()\n\n inchworm_flags = self.inchworm(run=False)\n chrysalis_flags = self.chrysalis(run=False)\n\n cc = os.getenv('CC')\n cxx = os.getenv('CXX')\n\n lib_flags = \"\"\n for lib in ['ncurses', 'zlib']:\n libroot = get_software_root(lib)\n if libroot:\n lib_flags += \" -L%s/lib\" % libroot\n\n fn = \"Makefile\"\n for line in fileinput.input(fn, inplace=1, backup='.orig.eb'):\n\n line = re.sub(r'^(INCHWORM_CONFIGURE_FLAGS\\s*=\\s*).*$', r'\\1%s' % inchworm_flags, line)\n line = re.sub(r'^(CHRYSALIS_MAKE_FLAGS\\s*=\\s*).*$', r'\\1%s' % chrysalis_flags, line)\n line = re.sub(r'(/rsem && \\$\\(MAKE\\))\\s*$',\n r'\\1 CC=%s CXX=\"%s %s\" CFLAGS_EXTRA=\"%s\"\\n' % (cc, cxx, lib_flags, lib_flags), line)\n line = re.sub(r'(/fastool && \\$\\(MAKE\\))\\s*$',\n r'\\1 CC=\"%s -std=c99\" CFLAGS=\"%s ${CFLAGS}\"\\n' % (cc, lib_flags), line)\n\n sys.stdout.write(line)\n\n trinity_compiler = None\n comp_fam = self.toolchain.comp_family()\n if comp_fam in [toolchain.INTELCOMP]:\n trinity_compiler = \"intel\"\n elif comp_fam in [toolchain.GCC]:\n trinity_compiler = \"gcc\"\n else:\n self.log.error(\"Don't know how to set TRINITY_COMPILER for %s compiler\" % comp_fam)\n\n cmd = \"make TRINITY_COMPILER=%s\" % trinity_compiler\n run_cmd(cmd)\n\n # butterfly is not included in standard build\n self.butterfly()\n\n # remove sample data if desired\n if not self.cfg['withsampledata']:\n try:\n shutil.rmtree(os.path.join(self.cfg['start_dir'], 'sample_data'))\n except OSError, err:\n self.log.error(\"Failed to remove sample data: %s\" % err)","def setup_files(args):\n postfix = 'reinforce'\n has_value_model = False\n if args.baseline:\n postfix = \"reinforce-baseline\"\n has_value_model = True\n elif args.actor_critic:\n postfix = \"actor-critic\"\n has_value_model = True\n elif args.a2c:\n postfix = \"a2c\"\n has_value_model = True\n elif args.random:\n postfix = \"random\"\n\n # create the folder for log files\n try:\n os.mkdir(postfix)\n except FileExistsError:\n print(postfix, \" folder exists\")\n\n fileid = \"%s-%d\" % (postfix, int(time.time()))\n actor_weights = \"actor_weights-%s.h5\" % fileid\n actor_weights = os.path.join(postfix, actor_weights)\n encoder_weights = \"encoder_weights-%s.h5\" % fileid\n encoder_weights = os.path.join(postfix, encoder_weights)\n value_weights = None\n if has_value_model:\n value_weights = \"value_weights-%s.h5\" % fileid\n value_weights = os.path.join(postfix, value_weights)\n\n outdir = \"/tmp/%s\" % postfix\n\n misc = (postfix, fileid, outdir, has_value_model)\n weights = (actor_weights, encoder_weights, value_weights)\n\n return weights, misc","def rewrite_jaraco(pkg_files, new_root):\n for file in pkg_files.glob('*.py'):\n text = file.read_text()\n text = re.sub(r' (more_itertools)', rf' {new_root}.\\1', text)\n file.write_text(text)\n # required for zip-packaged setuptools #3084\n pkg_files.joinpath('__init__.py').write_text('')","def uncrustify(ui, repo, *patterns, **options):\n if options[\"diff\"] and options[\"modify\"]:\n raise util.Abort(\"cannot specify --diff and --modify at the same time\")\n\n if options[\"diff\"]:\n mode = \"diff\"\n elif options[\"modify\"]:\n mode = \"modify\"\n else:\n mode = \"status\"\n\n no_backup = options[\"no_backup\"]\n show_clean = options[\"show_clean\"]\n\n paths = [path for path in _get_files(repo, patterns, options)\n if path.endswith((\".cc\", \".h\"))]\n\n\n uncrustify_cfg = repo.pathto(\".uncrustify.cfg\")\n relpaths = [repo.pathto(path) for path in paths]\n if not os.path.exists(uncrustify_cfg):\n raise util.Abort(\"could not find .uncrustify.cfg in repository root\")\n _run_uncrustify(uncrustify_cfg, relpaths)\n\n ctx = repo[None]\n for path in paths:\n relpath = repo.pathto(path)\n uncr_path = path + SUFFIX\n uncr_relpath = relpath + SUFFIX\n have_changes = (ctx[path].data() != ctx[uncr_path].data())\n\n if have_changes:\n if mode == \"status\":\n ui.write(\"M %s\\n\" % relpath, label=\"status.modified\")\n util.unlink(uncr_relpath)\n elif mode == \"diff\":\n _run_diff(relpath, uncr_relpath)\n util.unlink(uncr_relpath)\n elif mode == \"modify\":\n if not no_backup:\n util.rename(relpath, relpath + \".crusty\")\n util.rename(uncr_relpath, relpath)\n if not ui.quiet:\n ui.write(\"%s uncrustified\\n\" % relpath)\n else:\n if show_clean:\n if mode == \"status\":\n ui.write(\"C %s\\n\" % relpath, label=\"status.clean\")\n elif mode == \"modify\":\n ui.write(\"%s is clean\\n\" % relpath)\n util.unlink(uncr_relpath)","def test_cherrypick_adds_file(repository: Repository, path: Path) -> None:\n main = repository.head\n branch = repository.heads.create(\"branch\")\n\n repository.checkout(branch)\n updatefile(path)\n\n repository.checkout(main)\n assert not path.is_file()\n\n repository.cherrypick(branch.commit)\n assert path.is_file()","def add_uppers():\n for filename, requirements in _sync():\n LOG.info(\"Obtaining latest versions of packages for %s.\", filename)\n for req in requirements:\n if isinstance(req, Requirement):\n if isinstance(req.version, dict) and not req.version[\"max\"]:\n req.sync_max_version_with_pypy()\n _write_requirements(filename, requirements)","def generatePlans(update):\n out.header(\"%r\\n\" % (update))\n \n # Make sure we need to create this chute (does it already exist)\n # TODO\n\n# # Check if the chute is new\n# # if(not old):\n# # convert cpu cgroups and add to lxcconfig (cached, key: 'cpuConfig')\n# chutePlan.addPlans(new, plangraph.RESOURCE_GET_VIRT_CPU, (new.getCpuConfigString, None))\n# \n# # convert mem cgroups and add to lxcconfig (cached, key: 'memConfig')\n# chutePlan.addPlans(new, plangraph.RESOURCE_GET_VIRT_MEM, (new.getMemConfigString, None))\n\n# # Generate a config file for wshaper, put in cache (key: 'osResourceConfig')\n# chutePlan.addPlans(new, plangraph.RESOURCE_GET_OS_CONFIG, (new.getOSResourceConfig, None))\n\n# # Make calls to configure the wshaper UCI file\n# todoPlan = (new.setOSResourceConfig, old)\n# abtPlan = (new.resetOSResourceConfig, None) \n# chutePlan.addPlans(new, plangraph.RESOURCE_SET_VIRT_QOS, todoPlan, abtPlan)\n# \n# # Once all changes are made into UCI system, reload the wshaper daemon\n# todoPlan = (osenv.reloadQos, (chuteStor, new, True)) \n# abtPlan = [(new.resetOSResourceConfig, None), (osenv.reloadQos, (chuteStor, new, False))]\n# chutePlan.addPlans(new, plangraph.RESOURCE_RELOAD_QOS, todoPlan, abtPlan)\n\n return None","def generate_project_files(specs_path, dst_path):\n hm_generator = HookManGenerator(hook_spec_file_path=specs_path)\n hm_generator.generate_project_files(Path(dst_path))\n return 0","def test_squash_patches_by_name(source_git_repo: git.Repo, dist_git_repo: git.Repo):\n local_project = flexmock(\n git_repo=source_git_repo, ref=\"HEAD\", working_dir=source_git_repo.working_dir\n )\n\n create_commits_to_squash(source_git_repo)\n\n patch_generator = PatchGenerator(local_project)\n patch_list = patch_generator.create_patches(\n git_ref=\"0.1.0\", destination=dist_git_repo.working_dir\n )\n assert len(patch_list) == 3\n assert patch_list[1].path == Path(dist_git_repo.working_dir, \"distro.patch\")\n assert patch_list[1].name == \"distro.patch\"\n assert sorted(dist_git_repo.untracked_files) == [\n \"0001-Add-a-standalone-patch.patch\",\n \"0004-Add-another-standalone-patch.patch\",\n \"distro.patch\",\n ]\n patch = Path(dist_git_repo.working_dir, \"distro.patch\").read_text()\n assert \"+The first commit of the second patch.\" in patch\n assert \"+The second commit of the second patch.\" in patch","def mspatchc_CreatePatchFileEx(jitter, get_str, set_str):\n ret_ad, args = jitter.func_args_stdcall([\"OldFileCount\", \"OldFileInfoArray\", \"NewFileName\", \"PatchFileName\", \"OptionFlags\", \"OptionData\", \"ProgressCallback\", \"CallbackContext\"])\n raise RuntimeError('API not implemented')\n jitter.func_ret_stdcall(ret_ad, ret_value)","def update_module(cwd, name, conf):\n target = cwd / name\n source = conf['source']\n\n # Support modules on the local filesystem.\n if source.startswith('./') or source.startswith('../') or source.startswith('/'):\n print('Copying {}/{}'.format(cwd, name))\n # Paths must be relative to the Terrafile directory.\n source = cwd / source\n shutil.rmtree(target, ignore_errors=True)\n shutil.copytree(source, target)\n return\n\n version = conf['version']\n # Support Terraform Registry sources.\n if is_valid_registry_source(source):\n print('Checking {}/{}'.format(cwd, name))\n source, version = get_source_from_registry(source, version)\n\n # add token to the source url if exists\n if 'GITHUB_TOKEN' in os.environ:\n source = add_github_token(source, os.getenv('GITHUB_TOKEN'))\n # Delete the old directory and clone it from scratch.\n print('Fetching {}'.format(target))\n shutil.rmtree(target, ignore_errors=True)\n repo = repository.Repo(path=target, origin=source, version=version)\n output, returncode = repo.clone()\n if returncode != 0:\n sys.stderr.write(bytes.decode(output))\n sys.exit(returncode)\n if conf.get(\"patches\") or conf.get(\"patches_file\"):\n quilt = Patch(target, root=cwd)\n i = 0\n for i, patch in enumerate(conf.get(\"patches\", list())):\n quilt.import_patch(name=f'patch_{i}.patch', content=patch)\n for i, patch in enumerate(conf.get(\"patches_file\", list()), start=i+1):\n quilt.import_patch(name=f'patch_{i}.patch', file_path=patch)\n status = quilt.push_all()\n if status != 0:\n raise SystemError(\"Error to push patches\")","def _patch_pip(obuffer, updates, **options):\n\n seen = []\n\n def patched_parse_requirements(*args, **kwargs):\n if not options['no_recursive']:\n filename = args[0]\n if filename not in seen:\n if os.path.isfile(filename):\n seen.append(filename)\n buf = StringIO()\n _internal_update_requirements(\n buf, updates,\n input_file=filename,\n output_file=options['output_file'],\n force=options['force'],\n interactive=options['interactive'],\n skip=options['skip'],\n only=options['only'],\n minor=options['minor'],\n patch=options['patch'],\n pre=options['pre'],\n dry_run=options['dry_run'],\n no_recursive=options['no_recursive'],\n echo=options['echo'],\n index_urls=options['index_urls'],\n verify=options['verify'],\n )\n if not options['dry_run']:\n if options['output_file']:\n obuffer.write(buf.getvalue())\n else:\n with open(filename, 'w') as output:\n output.write(buf.getvalue())\n buf.close()\n return []\n req_file.parse_requirements = patched_parse_requirements","def test_prereleases(tmp_path_factory: pytest.TempPathFactory) -> None:\n src, dst = map(tmp_path_factory.mktemp, (\"src\", \"dst\"))\n with local.cwd(src):\n # Build template in v1.0.0\n build_file_tree(\n {\n \"version.txt\": \"v1.0.0\",\n \"[[ _copier_conf.answers_file ]].jinja\": \"[[_copier_answers|to_nice_yaml]]\",\n \"copier.yaml\": (\n f\"\"\"\\\n _envops: {BRACKET_ENVOPS_JSON}\n _migrations:\n - version: v1.9\n before:\n - [python, -c, \"import pathlib; pathlib.Path('v1.9').touch()\"]\n - version: v2.dev0\n before:\n - [python, -c, \"import pathlib; pathlib.Path('v2.dev0').touch()\"]\n - version: v2.dev2\n before:\n - [python, -c, \"import pathlib; pathlib.Path('v2.dev2').touch()\"]\n - version: v2.a1\n before:\n - [python, -c, \"import pathlib; pathlib.Path('v2.a1').touch()\"]\n - version: v2.a2\n before:\n - [python, -c, \"import pathlib; pathlib.Path('v2.a2').touch()\"]\n \"\"\"\n ),\n }\n )\n git(\"init\")\n git(\"add\", \".\")\n git(\"commit\", \"-mv1\")\n git(\"tag\", \"v1.0.0\")\n # Evolve template to v2.0.0.dev1\n build_file_tree({\"version.txt\": \"v2.0.0.dev1\"})\n git(\"commit\", \"-amv2dev1\")\n git(\"tag\", \"v2.0.0.dev1\")\n # Evolve template to v2.0.0.alpha1\n build_file_tree({\"version.txt\": \"v2.0.0.alpha1\"})\n git(\"commit\", \"-amv2a1\")\n git(\"tag\", \"v2.0.0.alpha1\")\n # Copying with use_prereleases=False copies v1\n run_copy(src_path=str(src), dst_path=dst, defaults=True, overwrite=True)\n answers = yaml.safe_load((dst / \".copier-answers.yml\").read_text())\n assert answers[\"_commit\"] == \"v1.0.0\"\n assert (dst / \"version.txt\").read_text() == \"v1.0.0\"\n assert not (dst / \"v1.9\").exists()\n assert not (dst / \"v2.dev0\").exists()\n assert not (dst / \"v2.dev2\").exists()\n assert not (dst / \"v2.a1\").exists()\n assert not (dst / \"v2.a2\").exists()\n with local.cwd(dst):\n # Commit subproject\n git(\"init\")\n git(\"add\", \".\")\n git(\"commit\", \"-mv1\")\n # Update it without prereleases; nothing changes\n run_update(defaults=True, overwrite=True)\n assert not git(\"status\", \"--porcelain\")\n assert not (dst / \"v1.9\").exists()\n assert not (dst / \"v2.dev0\").exists()\n assert not (dst / \"v2.dev2\").exists()\n assert not (dst / \"v2.a1\").exists()\n assert not (dst / \"v2.a2\").exists()\n # Update it with prereleases\n run_update(\n dst_path=dst, defaults=True, overwrite=True, use_prereleases=True, unsafe=True\n )\n answers = yaml.safe_load((dst / \".copier-answers.yml\").read_text())\n assert answers[\"_commit\"] == \"v2.0.0.alpha1\"\n assert (dst / \"version.txt\").read_text() == \"v2.0.0.alpha1\"\n assert (dst / \"v1.9\").exists()\n assert (dst / \"v2.dev0\").exists()\n assert (dst / \"v2.dev2\").exists()\n assert (dst / \"v2.a1\").exists()\n assert not (dst / \"v2.a2\").exists()\n # It should fail if downgrading\n with pytest.raises(UserMessageError):\n run_update(dst_path=dst, defaults=True, overwrite=True)","def gen_buildrequests(self, daemon, repository, dist, suite_option):\n # Extra check on all DSC/source package files\n # - Check md5 against possible pool files.\n # - Add missing from pool (i.e., orig.tar.gz).\n # - make sure all files from dsc are actually available\n files_from_pool = []\n with open(self.dsc_file_name) as dsc_file:\n dsc = debian.deb822.Dsc(dsc_file)\n\n for f in dsc[\"Files\"]:\n in_changes = f[\"name\"] in self.get_files(key=\"name\")\n from_pool = False\n for p in glob.glob(os.path.join(repository.mbd_get_path(), \"pool\", \"*\", \"*\", self[\"Source\"], f[\"name\"])):\n if f[\"md5sum\"] == mini_buildd.misc.md5_of_file(p):\n if not in_changes:\n files_from_pool.append(p)\n from_pool = True\n LOG.info(\"Buildrequest: File added from pool: {f}\".format(f=p))\n else:\n raise Exception(\"MD5 mismatch in uploaded dsc vs. pool: {f}\".format(f=f[\"name\"]))\n\n # Check that this file is available\n if not in_changes and not from_pool:\n raise Exception(\"Missing file '{f}' neither in upload, nor in pool (use '-sa' for uploads with new upstream)\".format(f=f[\"name\"]))\n\n breq_dict = {}\n for ao in dist.architectureoption_set.all():\n path = os.path.join(self.get_spool_dir(), ao.architecture.name)\n\n breq = Changes(os.path.join(path,\n self.gen_file_name(ao.architecture.name, self.TYPE_BREQ)))\n\n if breq.is_new():\n distribution = mini_buildd.misc.Distribution(mini_buildd.models.repository.map_incoming_distribution(self[\"Distribution\"]))\n breq[\"Distribution\"] = distribution.get()\n for v in [\"Source\", \"Version\"]:\n breq[v] = self[v]\n\n # Generate files\n chroot_setup_script = os.path.join(path, \"chroot_setup_script\")\n with mini_buildd.misc.open_utf8(os.path.join(path, \"apt_sources.list\"), \"w\") as asl, \\\n mini_buildd.misc.open_utf8(os.path.join(path, \"apt_preferences\"), \"w\") as ap, \\\n mini_buildd.misc.open_utf8(os.path.join(path, \"apt_keys\"), \"w\") as ak, \\\n mini_buildd.misc.open_utf8(os.path.join(path, \"ssl_cert\"), \"w\") as ssl_cert, \\\n mini_buildd.misc.open_utf8(chroot_setup_script, \"w\") as css, \\\n mini_buildd.misc.open_utf8(os.path.join(path, \"sbuildrc_snippet\"), \"w\") as src:\n asl.write(dist.mbd_get_apt_sources_list(repository, suite_option))\n ap.write(dist.mbd_get_apt_preferences(repository, suite_option, self.options.get(\"internal-apt-priority\")))\n ak.write(repository.mbd_get_apt_keys(dist))\n ssl_cert.write(mini_buildd.config.HTTPD_ENDPOINTS[0].get_certificate())\n css.write(mini_buildd.misc.fromdos(dist.chroot_setup_script)) # Note: For some reason (python, django sqlite, browser?) the text field may be in DOS mode.\n os.chmod(chroot_setup_script, stat.S_IRWXU)\n src.write(dist.mbd_get_sbuildrc_snippet(ao.architecture.name))\n\n # Generate tar from original changes\n self.tar(tar_path=breq.file_path + \".tar\",\n add_files=[os.path.join(path, \"apt_sources.list\"),\n os.path.join(path, \"apt_preferences\"),\n os.path.join(path, \"apt_keys\"),\n os.path.join(path, \"ssl_cert\"),\n chroot_setup_script,\n os.path.join(path, \"sbuildrc_snippet\")] + files_from_pool,\n exclude_globs=[\"*.deb\", \"*.changes\", \"*.buildinfo\"])\n breq.add_file(breq.file_path + \".tar\")\n\n breq[\"Upload-Result-To\"] = daemon.mbd_get_ftp_endpoint().hopo()\n breq[\"Base-Distribution\"] = dist.base_source.codename\n breq[\"Architecture\"] = ao.architecture.name\n if ao.build_architecture_all:\n breq[\"Arch-All\"] = \"Yes\"\n breq[\"Build-Dep-Resolver\"] = dist.get_build_dep_resolver_display()\n breq[\"Apt-Allow-Unauthenticated\"] = \"1\" if dist.apt_allow_unauthenticated else \"0\"\n if dist.lintian_mode != dist.LINTIAN_DISABLED and self.options.get(\"run-lintian\", alt=ao.architecture.name, default=True):\n # Generate lintian options\n modeargs = {\n dist.LINTIAN_DISABLED: \"\",\n dist.LINTIAN_RUN_ONLY: \"\",\n dist.LINTIAN_FAIL_ON_ERROR: \"\",\n dist.LINTIAN_FAIL_ON_WARNING: \"--fail-on-warning\"}\n breq[\"Run-Lintian\"] = modeargs[dist.lintian_mode] + \" \" + dist.lintian_extra_options\n breq[\"Deb-Build-Options\"] = dist.mbd_get_extra_option(\"Deb-Build-Options\", \"\")\n\n breq.save(daemon.mbd_gnupg)\n else:\n LOG.info(\"Re-using existing buildrequest: {b}\".format(b=breq.file_name))\n breq_dict[ao.architecture.name] = breq\n\n return breq_dict","def test_resetcherrypick_restores_files_with_conflicts(\n repository: Repository, path: Path\n) -> None:\n createconflict(repository, path, ours=\"a\", theirs=\"b\")\n repository.resetcherrypick()\n\n assert path.read_text() == \"a\"","def applyPatch(self, fileName, patchdepth, unusedSrcDir=None):\n craftDebug.trace(\"HgSource.applyPatches called\")\n if fileName and self.enableHg:\n patchfile = os.path.join(self.packageDir(), fileName)\n os.chdir(self.sourceDir())\n return self.system('\"%s\" import -p %s \"%s\"' % (self.hgExecutable, patchdepth, patchfile))\n return True","def rewrite(self):\n for f in self.files:\n metadata = dict()\n metadata[\"description\"] = f.metadata.get(\"desc\", \"Unknown\")\n metadata[\"script\"] = os.path.basename(f.filename)\n metadata[\"requires\"] = []\n for package, component in f.requires:\n if package == self.key:\n metadata[\"requires\"].append(\"/\" + component)\n else:\n metadata[\"requires\"].append(package + \"/\" + component)\n metadata[\"provides\"] = [ p[1] for p in f.provides ]\n # Resolve symlinks\n real_filename = os.path.realpath(f.filename)\n LOG.info(\"Editing: \" + real_filename)\n new_filename = f.filename + \".new\"\n new = file(new_filename, \"w\")\n new.write(\"/*\\n---\\n\")\n new.write(yaml.dump(metadata))\n new.write(\"\\n...\\n*/\\n\")\n new.write(file(f.filename).read())\n new.close()\n os.rename(new_filename, real_filename)\n\n package_data = dict()\n package_data[\"name\"] = self.key\n package_data[\"sources\"] = []\n package_data[\"version\"] = \"Unknown\"\n package_data[\"copyright\"] = \"Unknown\"\n package_data[\"description\"] = \"Unknown\"\n target_dir = os.path.dirname(self.scripts_json_filename)\n # package.yml is typically in the parent of the scripts.json dir\n if os.path.basename(target_dir) == \"Source\":\n target_dir = os.path.dirname(target_dir)\n target_filename = os.path.join(target_dir, \"package.yml\")\n for f in self.files:\n common = os.path.commonprefix([target_filename, f.filename])\n source_file = f.filename[len(common):]\n package_data[\"sources\"].append(source_file)\n LOG.info(\"Writing: \" + target_filename)\n out = file(target_filename, \"w\")\n out.write(yaml.dump(package_data))\n out.close()","def update_openblock():\n\n tf = tempfile.mktemp(suffix='-openblock')\n local('git clone git://github.com/openplans/openblock.git {0}'.format(tf))\n dest = os.path.join(PROJECT_ROOT, 'requirements', 'sdists')\n for name in ('obadmin', 'ebdata', 'ebpub'):\n package = os.path.join(tf, name)\n os.chdir(package)\n local('pip install -e {source} -d {dest}'.format(source=package,\n dest=dest))\n shutil.rmtree(tf)","def compress_feats(self):\n mkpath(os.path.join(self.base_update_path,'comp_features'))\n mkpath(os.path.join(self.base_update_path,'comp_idx'))\n args = [self.base_update_path+'/', str(self.features_dim), '1', self.master_update_file, str(self.bits_num)]\n subprocess_command = [self.hashing_execpath+\"compress_feats\"] + args\n # this will work only if features to be compressed are present in self.base_update_path/features\n proc = subprocess.Popen(subprocess_command, stdout=subprocess.PIPE)\n print \"[HasherSwig.compress_feats: log] running command: {}\".format(subprocess_command)\n (out, err) = proc.communicate()\n print \"[HasherSwig.compress_feats: log] program output:\", out\n print \"[HasherSwig.compress_feats: log] program error:\", err","def generate_patch_build(self, domain):\n # TODO change name of def\n base_path = self.paths[\"api_doc_dir\"]\n self.generate_apidoc_patches()\n from django_swagger_utils.apidoc_gen.generators.patch_generator import PatchGenerator\n patch_generator = PatchGenerator(self.app_name, self.parser, self.paths, base_path)\n patch_generator.filter_for_deleted_apis()\n\n process = subprocess.Popen(['which', 'apidoc'], stdout=subprocess.PIPE)\n\n output = process.communicate()[0]\n if output:\n\n with open(self.paths[\"base_dir\"] + \"/apidoc.json\", 'w') as outfile:\n apidoc_content = {\"url\": \"https://ib-backend-dev.apigateway.in\",\n \"version\": \"0.0.1\",\n \"description\": \"\",\n \"name\": \"iBHubs_backend API Documentation\",\n \"title\": \"iBHubs_backend Documenation\"}\n json.dump(apidoc_content, outfile, indent=4)\n # by default we assume user is working at no specific branch so we fix\n # url to default above url as above , then we check if any specific parametr is given\n # and replace url with required url\n if domain != '' and domain:\n with open(self.paths[\"apidoc\"]) as src_json:\n apidoc_content = json.load(src_json)\n apidoc_content['url'] = \"https://\" + domain\n with open(self.paths[\"apidoc\"], 'w') as outfile:\n json.dump(apidoc_content, outfile, indent=4)\n try:\n os.mkdir(\"docs\")\n except OSError:\n pass\n # the below command is responsible for creating docs\n process = subprocess.Popen(['apidoc', '-i', self.base_dir,\n '-o', os.path.join(self.base_dir, 'docs'),\n '-e', 'django_swagger_utils/*',\n '-e', 'static/*',\n ], stdout=subprocess.PIPE)\n print process.communicate()[0]\n ################################################\n # hosting apidoc\n ################################################\n # obtaining the path of static folder of django-swagger-utils\n # django_swagger_utils_path = os.path.abspath(os.path.join(os.path.dirname(__file__), \"../..\"))\n # static_folder_path = os.path.join(django_swagger_utils_path, \"static\")\n # import shutil\n # # create a folder apidoc , delete if previously exists\n # if os.path.exists(os.path.join(static_folder_path, \"apidoc\")):\n # shutil.rmtree(os.path.join(static_folder_path, \"apidoc\"))\n # apidoc_path = os.path.join(static_folder_path, \"apidoc\")\n #\n # os.mkdir(apidoc_path)\n\n # from distutils.dir_util import copy_tree\n # copydocs from docs to apidoc in swagger utils\n # try:\n # copy_tree(os.path.join(self.base_dir, 'docs'), apidoc_path)\n # except Exception as err:\n # print err\n\n # browse to localhost:<port>/static/apidoc/index.html\n\n else:\n raise CommandError(\"Help: Install apidoc: [ sudo npm install -g apidoc ]\")","def apply_patches(ctx, patches, branch, die_on_fail=True):\n ctx.runprocess(['git', 'checkout',\n '%s/%s' % (ctx.config['remote'], branch)])\n for patch in patches:\n print('Applying to %s: %s' % (branch, patch.subject))\n res = ctx.runprocess(\n ['git', 'am', '--3way'],\n stdin_string=''.join(patch.lines),\n check_returncode=0 if die_on_fail else None,\n )\n if not die_on_fail and res.returncode:\n raise RuntimeError(res.stderr)\n sha1 = ctx.runprocess(['git', 'rev-parse', 'HEAD']).stdout.strip()\n if ctx.verbosity:\n print('Resulting hash: %s' % sha1)\n return sha1","def test_cherrypick_simple(self):\n import evoware.fileutil as F\n \n options = {'i': F.testRoot('targetlist_PCR.xls'), \n 'src': [F.testRoot('primers.xls'), \n F.testRoot('partslist_simple.xls')],\n 'o': 'cherrypicking_simple.gwl',\n 'p': self.f_project,\n 'columns' : ['primer1', 'primer2', 'template']\n }\n self.generictest(options)","def do_base_setup(run_as_user, branch, base_path, dist_path):\n #install some necessary base deps\n runcmd(\"apt-get update\")\n runcmd(\"apt-get -y install git-core software-properties-common python-software-properties build-essential ssl-cert\")\n runcmd(\"apt-get update\")\n #node-gyp building for insight has ...issues out of the box on Ubuntu... use Chris Lea's nodejs build instead, which is newer\n runcmd(\"apt-get -y remove nodejs npm gyp\")\n runcmd(\"add-apt-repository -y ppa:chris-lea/node.js\")\n runcmd(\"apt-get update\")\n runcmd(\"apt-get -y install nodejs\") #includes npm\n\n #Create xcp user (to run bitcoind, counterpartyd, counterblockd) if not already made\n try:\n pwd.getpwnam(USERNAME)\n except:\n logging.info(\"Creating user '%s' ...\" % USERNAME)\n runcmd(\"adduser --system --disabled-password --shell /bin/bash --group %s\" % USERNAME)\n \n #add the run_as_user to the xcp group\n runcmd(\"adduser %s %s\" % (run_as_user, USERNAME))\n \n #Check out counterpartyd-build repo under this user's home dir and use that for the build\n git_repo_clone(branch, \"counterpartyd_build\", \"https://github.com/CounterpartyXCP/counterpartyd_build.git\", run_as_user)","def generate_patches(self):\n sets = os.listdir(self.__data_dir)\n import re\n sets = [a_set for a_set in sets if re.match(r'[0-9a-zA-Z_]+', a_set)]\n total = len(sets)\n count = 1\n for a_set in sets:\n print('\\r', 'slicing {0}/{1}'.format(count, total).ljust(20), end='')\n self.__generate_slices_a_set(a_set)\n count += 1","def update(\n project_dir: Path = Path(\".\"),\n cookiecutter_input: bool = False,\n skip_apply_ask: bool = True,\n skip_update: bool = False,\n checkout: Optional[str] = None,\n strict: bool = True,\n) -> bool:\n pyproject_file = project_dir / \"pyproject.toml\"\n cruft_file = get_cruft_file(project_dir)\n\n # If the project dir is a git repository, we ensure\n # that the user has a clean working directory before proceeding.\n if not _is_project_repo_clean(project_dir):\n typer.secho(\n \"Cruft cannot apply updates on an unclean git project.\"\n \" Please make sure your git working tree is clean before proceeding.\",\n fg=typer.colors.RED,\n )\n return False\n\n cruft_state = json.loads(cruft_file.read_text())\n\n with TemporaryDirectory() as compare_directory_str:\n # Initial setup\n compare_directory = Path(compare_directory_str)\n template_dir = compare_directory / \"template\"\n repo = get_cookiecutter_repo(cruft_state[\"template\"], template_dir, checkout)\n directory = cruft_state.get(\"directory\", None)\n if directory:\n template_dir = template_dir / directory\n last_commit = repo.head.object.hexsha\n\n # Bail early if the repo is already up to date\n if is_project_updated(repo, cruft_state[\"commit\"], last_commit, strict):\n typer.secho(\n \"Nothing to do, project's cruft is already up to date!\", fg=typer.colors.GREEN\n )\n return True\n\n # Generate clean outputs via the cookiecutter\n # from the current cruft state commit of the cookiectter and the updated\n # cookiecutter.\n old_main_directory, new_main_directory, new_context = _generate_project_updates(\n compare_directory, cruft_state, template_dir, cookiecutter_input, repo\n )\n\n # Get all paths that we are supposed to skip before generating the diff and applying updates\n skip_paths = _get_skip_paths(cruft_state, pyproject_file)\n # We also get the list of paths that were deleted from the project\n # directory but were present in the template that the project is linked against\n # This is to avoid introducing changes that won't apply cleanly to the current project.\n deleted_paths = _get_deleted_files(old_main_directory, project_dir)\n # We now remove both the skipped and deleted paths from the new and old project\n _remove_paths(old_main_directory, new_main_directory, skip_paths | deleted_paths)\n # Given the two versions of the cookiecutter outputs based\n # on the current project's context we calculate the diff and\n # apply the updates to the current project.\n if _apply_project_updates(\n old_main_directory, new_main_directory, project_dir, skip_update, skip_apply_ask\n ):\n\n # Update the cruft state and dump the new state\n # to the cruft file\n cruft_state[\"commit\"] = last_commit\n cruft_state[\"context\"] = new_context\n cruft_state[\"directory\"] = directory\n cruft_file.write_text(json_dumps(cruft_state))\n typer.secho(\n \"Good work! Project's cruft has been updated and is as clean as possible!\",\n fg=typer.colors.GREEN,\n )\n return True","def check_patch_files(version, cfg):\n\n logger = logging.getLogger('check_patch_files')\n\n # Patches should live in /srv/patches/[version]\n patch_path = cfg['patch_path']\n if patch_path is None:\n return\n\n version_base = os.path.join(patch_path, version)\n\n ext_dir = os.path.join(version_base, 'extensions')\n _, extensions, _ = os.walk(ext_dir).next()\n\n patches = utils.get_patches(['core'], version_base)\n patches.update(utils.get_patches(extensions, ext_dir))\n\n git_patch_check = ['/usr/bin/git', 'apply', '--check', '--reverse']\n version_dir = 'php-{}'.format(version)\n apply_dir = os.path.join(cfg['stage_dir'], version_dir)\n\n for extension, diffs in patches.iteritems():\n diff = '\\n'.join(diffs)\n\n if extension != 'core':\n apply_dir = os.path.join(apply_dir, 'extensions', extension)\n\n with utils.cd(apply_dir):\n p = subprocess.Popen(\n git_patch_check, stdin=subprocess.PIPE, stdout=subprocess.PIPE)\n\n p.communicate(diff)\n\n if p.returncode > 0:\n logger.warn(\n 'Patch(s) for {} have not been applied.'.format(apply_dir))","def main():\n # top-level parser\n parser = argparse.ArgumentParser(description=\"sinkhole\")\n parser.add_argument(\"--revision\", action=\"store\")\n parser.add_argument(\"--config\", action=\"store\", required=True)\n subparsers = parser.add_subparsers(dest=\"subcommand\")\n subparsers.required = True\n\n # reposync\n parser_reposync = subparsers.add_parser(\"reposync\",\n help=\"Sync repositories\")\n parser_reposync.add_argument(\"--destdir\", action=\"store\", required=True)\n parser_reposync.add_argument(\"--repofile\", action=\"append\", dest=\"repofns\",\n required=True)\n parser_reposync.add_argument(\"--include\", action=\"append\", default=None)\n parser_reposync.add_argument(\"--exclude\", action=\"append\", default=None)\n\n # kojidownload\n parser_koji = subparsers.add_parser(\"kojidownload\",\n help=\"Download builds from Koji\")\n parser_koji.add_argument(\"--profile\", action=\"store\", default=\"koji\",\n help=\"Koji instance to retrieve builds from\")\n parser_koji.add_argument(\"--arch\", action=\"store\", nargs=\"+\",\n default=None)\n parser_koji.add_argument(\"--builds\", action=\"store\", nargs=\"+\",\n required=True)\n parser_koji.add_argument(\"--destdir\", action=\"store\", required=True)\n\n # config_file\n parser_config = subparsers.add_parser(\"config_file\",\n help=\"Use config file\")\n\n # Run appropriate command\n args = parser.parse_args()\n\n config = Config.read_config(args.config) if args.config else Config()\n\n if args.subcommand == \"reposync\":\n config.output_dir = args.destdir\n reposync = Reposync(args.repofns, args.include, args.exclude)\n reposync.run()\n elif args.subcommand == \"kojidownload\":\n config.output_dir = args.destdir\n kojid = KojiDownloader(args.profile, args.builds, args.arch)\n kojid.run()\n else:\n sources = SourceBuilder.build()\n for source in sources:\n source.run()\n rm = RepoMasher(config.output_dir, revision=args.revision)\n rm.run()","def patches(*args):\n with cros_build_lib.ContextManagerStack() as stack:\n for arg in args:\n stack.Add(lambda ret=arg: ret)\n yield","def generate(repo_dir, context, update):\n\n result = generate_files(\n repo_dir=repo_dir,\n context=context,\n overwrite_if_exists=update,\n skip_if_file_exists=not update,\n output_dir='.',\n )\n return result","def do_base_setup(run_as_user, branch, base_path, dist_path):\n #change time to UTC\n runcmd(\"ln -sf /usr/share/zoneinfo/UTC /etc/localtime\")\n\n #install some necessary base deps\n runcmd(\"apt-get update\")\n runcmd(\"apt-get -y install git-core software-properties-common python-software-properties build-essential ssl-cert ntp runit\")\n \n #install node-js\n #node-gyp building has ...issues out of the box on Ubuntu... use Chris Lea's nodejs build instead, which is newer\n runcmd(\"apt-get -y remove nodejs npm gyp\")\n runcmd(\"add-apt-repository -y ppa:chris-lea/node.js\")\n runcmd(\"apt-get update\")\n runcmd(\"apt-get -y install nodejs\") #includes npm\n gypdir = None\n try:\n import gyp\n gypdir = os.path.dirname(gyp.__file__)\n except:\n pass\n else:\n runcmd(\"mv %s %s_bkup\" % (gypdir, gypdir))\n #^ fix for https://github.com/TooTallNate/node-gyp/issues/363\n\n #Create xcp user, under which the files will be stored, and who will own the files, etc\n try:\n pwd.getpwnam(USERNAME)\n except:\n logging.info(\"Creating user '%s' ...\" % USERNAME)\n runcmd(\"adduser --system --disabled-password --shell /bin/false --group %s\" % USERNAME)\n \n #Create xcpd user (to run counterpartyd, counterblockd, insight, bitcoind, nginx) if not already made\n try:\n pwd.getpwnam(DAEMON_USERNAME)\n except:\n logging.info(\"Creating user '%s' ...\" % DAEMON_USERNAME)\n runcmd(\"adduser --system --disabled-password --shell /bin/false --ingroup nogroup --home %s %s\" % (USER_HOMEDIR, DAEMON_USERNAME))\n \n #add the run_as_user to the xcp group\n runcmd(\"adduser %s %s\" % (run_as_user, USERNAME))\n \n #Check out counterpartyd-build repo under this user's home dir and use that for the build\n git_repo_clone(\"counterpartyd_build\", \"https://github.com/CounterpartyXCP/counterpartyd_build.git\",\n os.path.join(USER_HOMEDIR, \"counterpartyd_build\"), branch, for_user=run_as_user)\n\n #enhance fd limits for the xcpd user\n runcmd(\"cp -af %s/linux/other/xcpd_security_limits.conf /etc/security/limits.d/\" % dist_path)","def main():\n parser = argparse.ArgumentParser(description='Create packaged set of modulefiles for deployment on OASIS.')\n parser.add_argument('--location', dest='location', default=None,\n help='Location directory to place files in')\n parser.add_argument('--tarfile', dest='tarfile', default=None,\n help='Name of tarfile to generate')\n args = parser.parse_args(sys.argv[1:])\n if args.location is None:\n args.location = tempfile.mkdtemp()\n elif os.path.exists(args.location):\n overwrite = raw_input(\"{0} exists, overwrite? \".format(args.location))\n if overwrite.lower().strip() != 'y':\n sys.stderr.write(\"Exiting...\")\n sys.exit(0)\n shutil.rmtree(args.location)\n os.mkdir(args.location)\n else:\n os.mkdir(args.location)\n location = checkout_repo(args.location) \n if location is None:\n sys.stderr.write(\"Can't checkout modulefiles to {0}!\\n\".format(args.location))\n package_files(location)\n if args.tarfile is None:\n args.tarfile = \"/tmp/moduleupdate.tar.gz\"\n if tar_files(location, args.tarfile) is None:\n sys.stderr.write(\"Error generating tarfile, exiting\\n\")\n sys.exit(1)\n shutil.rmtree(location)\n sys.stdout.write(\"Packaged files located at {0}\\n\".format(args.tarfile))","def applyPatch(self, fileName, patchdepth, unusedSrcDir=None):\n CraftCore.debug.trace(\"GitSource \")\n patchfile = self.packageDir() / fileName\n if os.path.isdir(patchfile):\n # apply a whole dir of patches\n out = True\n with os.scandir(patchfile) as scan:\n for patch in scan:\n if patch.is_file() and not patch.name.startswith(\".\"):\n out = self.applyPatch(patchfile / patch, patchdepth=patchdepth) and out\n return out\n return self.__git(\n \"apply\",\n [\"--ignore-space-change\", \"-p\", str(patchdepth), patchfile],\n logCommand=True,\n )","def update_role_files(**kwargs):\n\n # Finds out which tracking branch you are on\n # Generates a commit in OA and each of its roles\n # Generates a git show output\n # Asks before triggering git review\n\n # Example commit message\n # Update all SHAs for 15.1.8\n # This patch updates all the roles to the latest available stable\n # SHA's, copies the release notes from the updated roles into the\n # integrated repo, updates all the OpenStack Service SHA's, and\n # updates the appropriate python requirements pins.\n click.echo(\"Not implemented yet\")","def tarball(request):\n\n patches = (models.Patch\n .query(models.Patch.patchset_key == request.patchset.key)\n .order(models.Patch.filename)\n .fetch(1000))\n\n temp = tempfile.TemporaryFile()\n tar = tarfile.open(mode=\"w|bz2\", fileobj=temp)\n\n def add_entry(prefix, content):\n data = content.data\n if data is None:\n data = content.text\n if isinstance(data, unicode):\n data = data.encode(\"utf-8\", \"replace\")\n if data is None:\n return\n info = tarfile.TarInfo(prefix + patch.filename)\n info.size = len(data)\n # TODO(adonovan): set SYMTYPE/0755 when Rietveld supports symlinks.\n info.type = tarfile.REGTYPE\n info.mode = 0644\n # datetime->time_t\n delta = request.patchset.modified - datetime.datetime(1970, 1, 1)\n info.mtime = int(delta.days * 86400 + delta.seconds)\n tar.addfile(info, fileobj=StringIO(data))\n\n for patch in patches:\n if not patch.no_base_file:\n try:\n add_entry('a/', patch.get_content()) # before\n except FetchError: # I/O problem?\n logging.exception('tarball: patch(%s, %s).get_content failed' %\n (patch.key.id(), patch.filename))\n try:\n add_entry('b/', patch.get_patched_content()) # after\n except FetchError: # file deletion? I/O problem?\n logging.exception('tarball: patch(%s, %s).get_patched_content failed' %\n (patch.key.id(), patch.filename))\n\n tar.close()\n temp.flush()\n\n wrapper = FileWrapper(temp)\n response = HttpResponse(wrapper, mimetype='application/x-gtar')\n response['Content-Disposition'] = (\n 'attachment; filename=patch%s_%s.tar.bz2' % (request.issue.key.id(),\n request.patchset.key.id()))\n response['Content-Length'] = temp.tell()\n temp.seek(0)\n return response","def patch_arr_pm(self):\n self._copyin('build_scripts/file.rb',\n '/usr/lib/ruby/gems/1.8/gems/arr-pm-0.0.7/lib/arr-pm/file.rb')\n self._copyin('build_scripts/rpm.rb',\n '/usr/lib/ruby/gems/1.8/gems/fpm-0.4.24/lib/fpm/package/rpm.rb')","def main(args):\n write_files = args.no_write is False\n ffiles = _open(args)\n ffiles = update_bpms(ffiles)\n if write_files:\n _write_files(ffiles, args.prefix, args.clobber)\n\n return","def test_pnictogen():\n for template in templates:\n template_prefix, extension = os.path.splitext(template)\n for xyz_file in example_xyz_files:\n input_prefix, xyz_file_extension = os.path.splitext(xyz_file)\n\n mol = Atoms(\n cclib.bridge.cclib2openbabel.readfile(xyz_file, xyz_file_extension[1:])\n )\n written_files = pnictogen(mol, input_prefix, template, extension[1:])\n\n assert_equals(type(written_files), list)\n for written_file in written_files:\n assert_equals(type(written_file), str)\n\n written_files2 = pnictogen(mol, input_prefix, template)\n assert_equals(written_files, written_files2)\n\n # Allow use of template in the parent directory\n with cd(\"pnictogen/repo\"):\n mol = Atoms(\n cclib.bridge.cclib2openbabel.readfile(\"../../data/water-dimer.xyz\", \"xyz\")\n )\n written_files = pnictogen(mol, \"../../data/water-dimer\", \"ADF.in\", \"in\")\n\n assert_equals(written_files, [\"../../data/water-dimer.in\"])\n\n main([\"-g\", \"/tmp/hello.world.ORCA.inp\"])\n mol = Atoms(cclib.bridge.cclib2openbabel.readfile(\"data/co.xyz\", \"xyz\"))\n written_files = pnictogen(mol, \"data/co\", \"/tmp/hello.world.ORCA.inp\", foo=\"bar\")\n\n assert_equals(written_files, [\"data/co.inp\"])","def pack():\n clean_local()\n build()\n copy_json()\n optimize()\n tarball()","def main(template_initial_path, template_grown_path, step, total_steps, hydrogen_to_replace, core_atom_linker,\n tmpl_out_path, null_charges=False, growing_mode=\"SoftcoreLike\"):\n lambda_to_reduce = float(step/(total_steps+1))\n templ_ini = TemplateImpact(template_initial_path)\n \n for bond in templ_ini.list_of_bonds:\n key, bond_cont = bond\n templ_grw = TemplateImpact(template_grown_path)\n fragment_atoms, core_atoms_in, core_atoms_grown = detect_atoms(template_initial=templ_ini, \n template_grown=templ_grw,\n hydrogen_to_replace=hydrogen_to_replace)\n set_fragment_atoms(list_of_fragment_atoms=fragment_atoms)\n set_connecting_atom(template_grown=templ_grw, pdb_atom_name=core_atom_linker)\n fragment_bonds = detect_fragment_bonds(list_of_fragment_atoms=fragment_atoms, template_grown=templ_grw)\n set_fragment_bonds(list_of_fragment_bonds=fragment_bonds)\n set_linker_bond(templ_grw)\n if growing_mode == \"SoftcoreLike\":\n modify_core_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, exp_charges=True,\n null_charges=null_charges)\n reduce_fragment_parameters_linearly(templ_grw, lambda_to_reduce, exp_charges=True, \n null_charges=null_charges)\n \n modify_linkers_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, hydrogen_to_replace)\n elif growing_mode == \"AllLinear\":\n modify_core_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, exp_charges=False)\n reduce_fragment_parameters_linearly(templ_grw, lambda_to_reduce, exp_charges=False,\n null_charges=False)\n modify_linkers_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, hydrogen_to_replace)\n elif growing_mode == \"SpreadHcharge\":\n if step > 1:\n reduce_fragment_parameters_originaly(templ_grw, templ_ini, lambda_to_reduce, \n hydrogen=hydrogen_to_replace, n_GS=total_steps)\n modify_linkers_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, hydrogen_to_replace)\n else:\n reduce_fragment_parameters_spreading_H(templ_grw, templ_ini, lambda_to_reduce, \n hydrogen=hydrogen_to_replace, n_GS=total_steps)\n else:\n raise ValueError(\"Growing mode Not valid. Choose between: 'SoftcoreLike', 'SpreadHcharge', 'AllLinear'.\")\n templ_grw.write_template_to_file(template_new_name=tmpl_out_path)\n return [atom.pdb_atom_name for atom in fragment_atoms], \\\n [atom.pdb_atom_name for atom in core_atoms_grown]","def refresh_cts():\n local('cd ../../cts-js && grunt')\n local('cp ../../cts-js/release/cts.js ../static/hotlink/cts.js')\n local('cd ../../cts-ui && grunt')\n local('cp ../../cts-ui/release/cts-ui.js ../static/hotlink/cts-ui.js')\n local('git add ../static/hotlink/cts.js')\n local('git add ../static/hotlink/cts-ui.js')\n local('git commit -m \"refreshing CTS JS and UI [fabfile]\"')\n local('git push origin master')","def _subprocess_pack_charms(\n charms: Mapping[str, pathlib.Path],\n command_args: Collection[str],\n) -> Dict[str, pathlib.Path]:\n if charms:\n charm_str = humanize_list(charms.keys(), \"and\")\n emit.progress(f\"Packing charms: {charm_str}...\")\n cwd = pathlib.Path(os.getcwd()).resolve()\n generated_charms = {}\n with tempfile.TemporaryDirectory(prefix=\"charmcraft-bundle-\", dir=cwd) as temp_dir:\n temp_dir = pathlib.Path(temp_dir)\n try:\n # Put all the charms in this temporary directory.\n os.chdir(temp_dir)\n for charm, project_dir in charms.items():\n full_command = [*command_args, f\"--project-dir={project_dir}\"]\n with emit.open_stream(f\"Packing charm {charm}...\") as stream:\n subprocess.check_call(full_command, stdout=stream, stderr=stream)\n duplicate_charms = {}\n for charm_file in temp_dir.glob(\"*.charm\"):\n charm_name = charm_file.name.partition(\"_\")[0]\n if charm_name not in charms:\n emit.debug(f\"Unknown charm file generated: {charm_file.name}\")\n continue\n if charm_name in generated_charms:\n if charm_name not in duplicate_charms:\n duplicate_charms[charm_name] = temp_dir.glob(f\"{charm_name}_*.charm\")\n continue\n generated_charms[charm_name] = charm_file\n if duplicate_charms:\n raise errors.DuplicateCharmsError(duplicate_charms)\n for charm, charm_file in generated_charms.items():\n destination = cwd / charm_file.name\n destination.unlink(missing_ok=True)\n generated_charms[charm] = shutil.move(charm_file, destination)\n finally:\n os.chdir(cwd)\n return generated_charms","def bump(repo, configsToBump, configsToOverride):\n # First pass. Bump variables in configsToBump.\n configs = ['%s/%s' % (repo, x) for x in configsToBump.keys()]\n cmd = ['python', BUMP_SCRIPT, '--bump-version', '--revision=tip']\n cmd.extend(configs)\n run_cmd(cmd)\n # Second pass. Append override files to configsToBump and\n # configsToOverride.\n for config, overrides in \\\n configsToBump.items() + configsToOverride.items():\n newContent = cat([path.join(repo, config)] +\n [path.join(repo, x) for x in overrides])\n fh = open(path.join(repo, config), 'wb')\n fh.write(newContent)\n fh.close()\n run_cmd(['hg', 'commit', '-m', 'Automatic config bump'],\n cwd=repo)","def extract_from_cachedir(self):\n\n # Extract the configuration files from each new package into the\n # etc-tmp branch.\n master_tracked = self.repo.tracked_files('master-tmp')\n etc_tracked = self.repo.tracked_files('etc-tmp')\n packages = self.list_new_packages(self.cache_dir)\n print('Extracting configuration files from %d new package files' %\n len(packages), end='')\n if self.aur_dir is not None:\n aur_packages = self.list_new_packages(self.aur_dir)\n print(' and %d new AUR package files' % len(aur_packages))\n packages = itertools.chain(packages, aur_packages)\n else:\n print()\n self.repo.checkout('etc-tmp')\n original_files = self.extract(packages, etc_tracked)\n\n for rpath in original_files:\n new = EtcPath(self.repodir, rpath)\n current = EtcPath(self.root_dir, rpath)\n if current.digest == b'':\n path = current.path\n exists = True\n try:\n if not path.exists():\n exists = False\n except PermissionError:\n pass\n if not exists:\n # Do not warn on 'create' subcommand to avoid the noise of\n # all the /etc files removed after packages removal while\n # their package file is still present in pacman CacheDir.\n if self.cmd != 'create':\n warn('skip %s does not exist' % path)\n else:\n warn('skip %s not readable' % path)\n continue\n\n # A new package has been installed.\n if rpath not in etc_tracked:\n # Add the file to the etc-tmp branch.\n self.etc_commits.added.rpaths.append(rpath)\n if new != current:\n # Case 6.\n # Add the file name to the list of files to add to the\n # master-tmp branch (from /etc).\n self.master_commits.added.rpaths.append(rpath)\n # A package upgrade.\n else:\n if new == current:\n if new != original_files[rpath]:\n # Case 2 and 4.\n # Stage the file in the etc-tmp branch.\n self.etc_commits.added.rpaths.append(rpath)\n if rpath in master_tracked:\n warn('%s should not exist in the master branch'\n % rpath)\n else:\n # Case 1.\n pass\n else:\n # Case 5.\n # A specific commit is used for the configuration files\n # whose changes must be cherry-picked into the master\n # branch.\n if new != original_files[rpath]:\n self.etc_commits.cherry_pick.rpaths.append(rpath)\n else:\n # Case 3.\n pass","def do_package(package):\n\tn_ucr = extFile(package, 'univention-config-registry')\n\tif not os.path.exists(n_ucr):\n\t\treturn\n\n\tf_ucr = open(n_ucr, 'r')\n\n\tfor item in univention.config_registry.parseRfc822(f_ucr.read()):\n\t\ttyp = item['Type'][0]\n\t\tif typ == 'file':\n\t\t\tf = item['File'][0]\n\t\t\tdoIt('install', '-d', destDir(f, package))\n\t\t\tdoIt('cp', '-a', srcPath(f), destPath(f, package))\n\t\t\tfor key in ('Preinst', 'Postinst'):\n\t\t\t\tif key in item:\n\t\t\t\t\tmod = item[key][0]\n\t\t\t\t\tdoIt('install', '-d', destDir(mod, package, 'modules'))\n\t\t\t\t\tdoIt('cp', '-a', srcPath(mod), destPath(mod, package, 'modules'))\n\t\telif typ == 'subfile':\n\t\t\tf = item['Subfile'][0]\n\t\t\tdoIt('install', '-d', destDir(f, package))\n\t\t\tdoIt('cp', '-a', srcPath(f), destPath(f, package))\n\t\telif typ == 'multifile':\n\t\t\tf = item['Multifile'][0]\n\t\t\tif os.path.exists(f):\n\t\t\t\tdoIt('install', '-d', destDir(f, package))\n\t\t\t\tdoIt('cp', '-a', srcPath(f), destPath(f, package))\n\t\t\tfor key in ('Preinst', 'Postinst'):\n\t\t\t\tif key in item:\n\t\t\t\t\tmod = item[key][0]\n\t\t\t\t\tdoIt('install', '-d', destDir(mod, package, 'modules'))\n\t\t\t\t\tdoIt('cp', '-a', srcPath(mod), destPath(mod, package, 'modules'))\n\t\telif typ == 'script':\n\t\t\tf = item['Script'][0]\n\t\t\tdoIt('install', '-d', destDir(f, package, 'scripts'))\n\t\t\tdoIt('cp', '-a', srcPath(f), destPath(f, package, 'scripts'))\n\t\t\tdoIt('chmod', 'a+x', destPath(f, package, 'scripts'))\n\t\telif typ == 'module':\n\t\t\tf = item['Module'][0]\n\t\t\tdoIt('install', '-d', destDir(f, package, 'modules'))\n\t\t\tdoIt('cp', '-a', srcPath(f), destPath(f, package, 'modules'))\n\t\telse:\n\t\t\tprint >>sys.stderr, 'Unknown type: %s' % typ\n\t\t\treturn\n\n\tf_ucr.close()\n\n\tdoIt('install', '-d', destDir('', package, 'info'))\n\tdoIt('install', '-m644', n_ucr, destPath(package+'.info', package, 'info'))\n\tmapping_file = extFile( package, 'univention-config-registry-mapping')\n\tif os.path.exists(mapping_file):\n\t\tdoIt('install', '-d', destDir('', package, 'mapping'))\n\t\tdoIt('install', '-m644', mapping_file, destPath(package+'.univention-config-registry-mapping', package, 'mapping'))\n\n\tdata = {\n\t\t\t'pkg': quote(package),\n\t\t\t'info': quote(\"/etc/univention/templates/info/%s.info\" % package),\n\t\t\t'removed': quote(\"/etc/univention/templates/removed/%s.info\" % package),\n\t\t\t}\n\n\tf_preinst = open(extFile(package, 'preinst.debhelper'), 'a')\n\tf_preinst.write('# Automatically added by univention-install-config-registry\\n')\n\tf_preinst.write('if [ \"$1\" = \"install\" ] ; then\\n')\n\tf_preinst.write(' [ -e %(removed)s ] && [ ! -e %(info)s ] && mv %(removed)s %(info)s || true\\n' % data)\n\tf_preinst.write('fi\\n')\n\tf_preinst.write('# End automatically added section\\n')\n\tf_preinst.close()\n\n\tf_postinst = open(extFile(package, 'postinst.debhelper'), 'a')\n\tf_postinst.write('# Automatically added by univention-install-config-registry\\n')\n\tf_postinst.write('if [ \"$1\" = \"abort-remove\" ]; then\\n')\n\tf_postinst.write(' [ -e %(removed)s ] && mv %(removed)s %(info)s || true\\n' % data)\n\tf_postinst.write('fi\\n')\n\tf_postinst.write('[ -x /usr/sbin/univention-config-registry ] && univention-config-registry register %(pkg)s || true\\n' % data)\n\tf_postinst.write('# End automatically added section\\n')\n\tf_postinst.close()\n\n\tf_prerm = open(extFile(package, 'prerm.debhelper'), 'a')\n\tf_prerm.write('# Automatically added by univention-install-config-registry\\n')\n\tf_prerm.write('if [ \"$1\" = \"remove\" ] && [ -e %(info)s ] ; then\\n' % data)\n\tf_prerm.write(' [ -x /usr/sbin/univention-config-registry ] && univention-config-registry unregister %(pkg)s || true\\n' % data)\n\tf_prerm.write(' mv %(info)s %(removed)s || true\\n' % data)\n\tf_prerm.write('fi\\n')\n\tf_prerm.write('# End automatically added section\\n')\n\tf_prerm.close()\n\n\tdoIt('perl', '-e', 'use Debian::Debhelper::Dh_Lib;addsubstvar(\"%s\", \"misc:Depends\", \"univention-config (>= 7.0.25)\");' % package)","def make_deps_sha_file(self, deps_sha):\n return _DEPS_SHA_PATCH % {'deps_sha': deps_sha}","def do_counterparty_setup(run_as_user, branch, base_path, dist_path, run_mode, bitcoind_rpc_password, bitcoind_rpc_password_testnet):\n counterpartyd_rpc_password = pass_generator()\n counterpartyd_rpc_password_testnet = pass_generator()\n \n #Run setup.py (as the XCP user, who runs it sudoed) to install and set up counterpartyd, counterblockd\n # as -y is specified, this will auto install counterblockd full node (mongo and redis) as well as setting\n # counterpartyd/counterblockd to start up at startup for both mainnet and testnet (we will override this as necessary\n # based on run_mode later in this function)\n runcmd(\"~%s/counterpartyd_build/setup.py -y --with-counterblockd --with-testnet --for-user=%s\" % (USERNAME, USERNAME))\n runcmd(\"cd ~%s/counterpartyd_build && git config core.sharedRepository group && find ~%s/counterpartyd_build -type d -print0 | xargs -0 chmod g+s\" % (\n USERNAME, USERNAME)) #to allow for group git actions \n runcmd(\"chown -R %s:%s ~%s/counterpartyd_build\" % (USERNAME, USERNAME, USERNAME)) #hacky, probably not necessary \n runcmd(\"chmod -R g+rw ~%s/counterpartyd_build\" % USERNAME) #hacky\n\n #modify the default stored bitcoind passwords in counterpartyd.conf and counterblockd.conf\n runcmd(r\"\"\"sed -ri \"s/^bitcoind\\-rpc\\-password=.*?$/bitcoind-rpc-password=%s/g\" ~%s/.config/counterpartyd/counterpartyd.conf\"\"\" % (\n bitcoind_rpc_password, USERNAME))\n runcmd(r\"\"\"sed -ri \"s/^bitcoind\\-rpc\\-password=.*?$/bitcoind-rpc-password=%s/g\" ~%s/.config/counterpartyd-testnet/counterpartyd.conf\"\"\" % (\n bitcoind_rpc_password_testnet, USERNAME))\n runcmd(r\"\"\"sed -ri \"s/^bitcoind\\-rpc\\-password=.*?$/bitcoind-rpc-password=%s/g\" ~%s/.config/counterblockd/counterblockd.conf\"\"\" % (\n bitcoind_rpc_password, USERNAME))\n runcmd(r\"\"\"sed -ri \"s/^bitcoind\\-rpc\\-password=.*?$/bitcoind-rpc-password=%s/g\" ~%s/.config/counterblockd-testnet/counterblockd.conf\"\"\" % (\n bitcoind_rpc_password_testnet, USERNAME))\n \n #modify the counterpartyd API rpc password in both counterpartyd and counterblockd\n runcmd(r\"\"\"sed -ri \"s/^rpc\\-password=.*?$/rpc-password=%s/g\" ~%s/.config/counterpartyd/counterpartyd.conf\"\"\" % (\n counterpartyd_rpc_password, USERNAME))\n runcmd(r\"\"\"sed -ri \"s/^rpc\\-password=.*?$/rpc-password=%s/g\" ~%s/.config/counterpartyd-testnet/counterpartyd.conf\"\"\" % (\n counterpartyd_rpc_password_testnet, USERNAME))\n runcmd(r\"\"\"sed -ri \"s/^counterpartyd\\-rpc\\-password=.*?$/counterpartyd-rpc-password=%s/g\" ~%s/.config/counterblockd/counterblockd.conf\"\"\" % (\n counterpartyd_rpc_password, USERNAME))\n runcmd(r\"\"\"sed -ri \"s/^counterpartyd\\-rpc\\-password=.*?$/counterpartyd-rpc-password=%s/g\" ~%s/.config/counterblockd-testnet/counterblockd.conf\"\"\" % (\n counterpartyd_rpc_password_testnet, USERNAME))\n \n #disable upstart scripts from autostarting on system boot if necessary\n if run_mode == 't': #disable mainnet daemons from autostarting\n runcmd(r\"\"\"bash -c \"echo 'manual' >> /etc/init/counterpartyd.override\" \"\"\")\n runcmd(r\"\"\"bash -c \"echo 'manual' >> /etc/init/counterblockd.override\" \"\"\")\n else:\n runcmd(\"rm -f /etc/init/counterpartyd.override /etc/init/counterblockd.override\")\n if run_mode == 'm': #disable testnet daemons from autostarting\n runcmd(r\"\"\"bash -c \"echo 'manual' >> /etc/init/counterpartyd-testnet.override\" \"\"\")\n runcmd(r\"\"\"bash -c \"echo 'manual' >> /etc/init/counterblockd-testnet.override\" \"\"\")\n else:\n runcmd(\"rm -f /etc/init/counterpartyd-testnet.override /etc/init/counterblockd-testnet.override\")\n \n #append insight enablement param and API performance params to counterpartyd's configs\n for cfgFilename in [\n os.path.join(os.path.expanduser('~'+USERNAME), \".config\", \"counterpartyd\", \"counterpartyd.conf\"),\n os.path.join(os.path.expanduser('~'+USERNAME), \".config\", \"counterpartyd-testnet\", \"counterpartyd.conf\") ]:\n f = open(cfgFilename, 'r')\n content = f.read()\n f.close()\n if content[-1] != '\\n':\n content += '\\n'\n if not re.search(r'^insight\\-enable', content, re.MULTILINE):\n content += 'insight-enable=1\\n'\n if not re.search(r'^api\\-num\\-threads', content, re.MULTILINE):\n content += 'api-num-threads=100\\n'\n if not re.search(r'^api\\-request\\-queue\\-size', content, re.MULTILINE):\n content += 'api-request-queue-size=500\\n'\n f = open(cfgFilename, 'w')\n f.write(content)\n f.close()\n\n #change ownership\n runcmd(\"chown -R %s:%s ~%s/.bitcoin ~%s/.config/counterpartyd ~%s/.config/counterblockd\" % (\n USERNAME, USERNAME, USERNAME, USERNAME, USERNAME))\n runcmd(\"chown -R %s:%s ~%s/.bitcoin-testnet ~%s/.config/counterpartyd-testnet ~%s/.config/counterblockd-testnet\" % (\n USERNAME, USERNAME, USERNAME, USERNAME, USERNAME))","def finish(c):\n files_to_commit = [os.path.relpath(path, start=os.curdir) for path in [CHANGELOG_ABSPATH, SETTINGS_PATH]]\n version: VersionStructure = VersionStructure.from_settings()\n\n c.run(f\"git add %s\" % \" \".join(files_to_commit))\n c.run(f'git commit -m \"version {version}\" --no-verify')\n c.run(f\"git tag {version}\")","def test_9_dryruns(self):\n\n f = fmri.PkgFmri(self.published[3], None)\n\n rpth = tempfile.mkdtemp(dir=self.test_root)\n self.pkgrepo(\"create {0}\".format(rpth))\n expected = [\"pkg5.repository\"]\n self.pkgrecv(self.durl1, \"-n -d {0} {1}\".format(rpth, f))\n self.assertEqualDiff(expected, os.listdir(rpth))\n\n self.pkgrecv(self.durl1, \"-r -n -d {0} {1}\".format(rpth, f))\n self.assertEqualDiff(expected, os.listdir(rpth))\n\n self.pkgrecv(self.durl1, \"--clone -n -p '*' -d {0}\".format(rpth))\n self.assertEqualDiff(expected, os.listdir(rpth))\n\n arc_path = os.path.join(self.test_root, \"test.p5p\")\n self.pkgrecv(self.durl1, \"-a -n -d {0} \\*\".format(arc_path))\n self.assert_(not os.path.exists(arc_path))\n\n # --raw actually populates the destination with manifests even\n # with -n, so just check that it exits 0.\n self.pkgrecv(self.durl1, \"--raw -n -d {0} {1}\".format(\n self.tempdir, f))\n\n # --raw actually populates the destination with manifests even\n # with -n, so just check that it exits 0.\n self.pkgrecv(self.durl1, \"--raw -r -n -d {0} {1}\".format(\n self.tempdir, f))","def tarball(request):\n\n patches = (models.Patch\n .query(ancestor=request.patchset.key)\n .order(models.Patch.filename)\n .fetch(1000))\n\n temp = tempfile.TemporaryFile()\n tar = tarfile.open(mode=\"w|bz2\", fileobj=temp)\n\n def add_entry(prefix, content, patch):\n data = content.data\n if data is None:\n data = content.text\n if isinstance(data, unicode):\n data = data.encode(\"utf-8\", \"replace\")\n if data is None:\n return\n info = tarfile.TarInfo(prefix + patch.filename)\n info.size = len(data)\n # TODO(adonovan): set SYMTYPE/0755 when Rietveld supports symlinks.\n info.type = tarfile.REGTYPE\n info.mode = 0644\n # datetime->time_t\n delta = request.patchset.modified - datetime.datetime(1970, 1, 1)\n info.mtime = int(delta.days * 86400 + delta.seconds)\n tar.addfile(info, fileobj=StringIO(data))\n\n for patch in patches:\n if not patch.no_base_file:\n try:\n add_entry('a/', patch.get_content(), patch) # before\n except FetchError: # I/O problem?\n logging.exception('tarball: patch(%s, %s).get_content failed' %\n (patch.key.id(), patch.filename))\n try:\n add_entry('b/', patch.get_patched_content(), patch) # after\n except FetchError: # file deletion? I/O problem?\n logging.exception('tarball: patch(%s, %s).get_patched_content failed' %\n (patch.key.id(), patch.filename))\n\n tar.close()\n temp.flush()\n\n wrapper = FileWrapper(temp)\n response = HttpResponse(wrapper, mimetype='application/x-gtar')\n response['Content-Disposition'] = (\n 'attachment; filename=patch%s_%s.tar.bz2' % (request.issue.key.id(),\n request.patchset.key.id()))\n response['Content-Length'] = temp.tell()\n temp.seek(0)\n return response","def MakeRecoveryPatch(input_tmp, output_zip, recovery_img, boot_img):\n\n diff_program = [\"imgdiff\"]\n path = os.path.join(input_tmp, \"SYSTEM\", \"etc\", \"recovery-resource.dat\")\n if os.path.exists(path):\n diff_program.append(\"-b\")\n diff_program.append(path)\n bonus_args = \"-b /system/etc/recovery-resource.dat\"\n else:\n bonus_args = \"\"\n\n d = common.Difference(recovery_img, boot_img, diff_program=diff_program)\n _, _, patch = d.ComputePatch()\n common.ZipWriteStr(output_zip, \"recovery/recovery-from-boot.p\", patch)\n Item.Get(\"system/recovery-from-boot.p\", dir=False)\n\n boot_type, boot_device = common.GetTypeAndDevice(\"/boot\", OPTIONS.info_dict)\n recovery_type, recovery_device = common.GetTypeAndDevice(\"/recovery\", OPTIONS.info_dict)\n\n sh = \"\"\"#!/system/bin/sh\nif ! applypatch -c %(recovery_type)s:%(recovery_device)s:%(recovery_size)d:%(recovery_sha1)s; then\n log -t recovery \"Installing new recovery image\"\n applypatch %(bonus_args)s %(boot_type)s:%(boot_device)s:%(boot_size)d:%(boot_sha1)s %(recovery_type)s:%(recovery_device)s %(recovery_sha1)s %(recovery_size)d %(boot_sha1)s:/system/recovery-from-boot.p\nelse\n log -t recovery \"Recovery image already installed\"\nfi\n\"\"\" % { 'boot_size': boot_img.size,\n 'boot_sha1': boot_img.sha1,\n 'recovery_size': recovery_img.size,\n 'recovery_sha1': recovery_img.sha1,\n 'boot_type': boot_type,\n 'boot_device': boot_device,\n 'recovery_type': recovery_type,\n 'recovery_device': recovery_device,\n 'bonus_args': bonus_args,\n }\n common.ZipWriteStr(output_zip, \"recovery/etc/install-recovery.sh\", sh)\n return Item.Get(\"system/etc/install-recovery.sh\", dir=False)","def rewrite_importlib_resources(pkg_files, new_root):\n for file in pkg_files.glob('*.py'):\n text = file.read_text().replace('importlib_resources.abc', '.abc')\n text = text.replace('zipp', '..zipp')\n file.write_text(text)","def mspatchc_CreatePatchFileByHandlesEx(jitter):\n ret_ad, args = jitter.func_args_stdcall([\"OldFileCount\", \"OldFileInfoArray\", \"NewFileHandle\", \"PatchFileHandle\", \"OptionFlags\", \"OptionData\", \"ProgressCallback\", \"CallbackContext\"])\n raise RuntimeError('API not implemented')\n jitter.func_ret_stdcall(ret_ad, ret_value)","def test_7_cancer(install_test_files, data_dir):\n with make_workdir() as workdir:\n cl = [\"bcbio_nextgen.py\",\n get_post_process_yaml(data_dir, workdir),\n os.path.join(data_dir, \"run_info-cancer.yaml\")]\n subprocess.check_call(cl)","def test_resetcherrypick_keeps_unrelated_deletions(\n repository: Repository, paths: Iterator[Path]\n) -> None:\n main = repository.head\n update, _ = createbranches(repository, \"update\", \"latest\")\n path1, path2 = next(paths), next(paths)\n\n repository.checkout(update)\n updatefile(path1, \"a\")\n\n repository.checkout(main)\n updatefile(path1, \"b\")\n updatefile(path2)\n\n path2.unlink()\n\n with pytest.raises(MergeConflictError, match=path1.name):\n repository.cherrypick(update.commit)\n\n repository.resetcherrypick()\n\n assert not path2.exists()","def run(self):\n self._make_lib_file_symbolic_links()\n self._copy_each_include_files_to_include_dir()\n self._make_dep_lib_file_sym_links_and_copy_include_files()\n self.setup_py.add_patchs_to_build_without_pkg_config(\n self.rpm.lib_dir, self.rpm.include_dir\n )\n self.setup_py.apply_and_save()\n self._build_and_install()","def test_8_template(install_test_files, data_dir):\n fc_dir = os.path.join(data_dir, os.pardir, \"100326_FC6107FAAXX\")\n with make_workdir():\n cl = [\"bcbio_nextgen.py\", \"-w\", \"template\", \"--only-metadata\",\n \"freebayes-variant\",\n os.path.join(fc_dir, \"100326.csv\"),\n os.path.join(fc_dir, \"7_100326_FC6107FAAXX_1_fastq.txt\"),\n os.path.join(fc_dir, \"7_100326_FC6107FAAXX_2_fastq.txt\"),\n os.path.join(fc_dir, \"8_100326_FC6107FAAXX.bam\")]\n subprocess.check_call(cl)","def __gitCherryPick(self):\n pfile = self.project.getProjectFile()\n lastModified = QFileInfo(pfile).lastModified().toString()\n shouldReopen = (\n self.vcs.gitCherryPick(self.project.getProjectPath()) or\n QFileInfo(pfile).lastModified().toString() != lastModified\n )\n if shouldReopen:\n res = E5MessageBox.yesNo(\n None,\n self.tr(\"Copy Commits\"),\n self.tr(\"\"\"The project should be reread. Do this now?\"\"\"),\n yesDefault=True)\n if res:\n self.project.reopenProject()","def test_cherrypick_committer(\n repository: Repository, monkeypatch: pytest.MonkeyPatch\n) -> None:\n main = repository.head\n branch = repository.heads.create(\"branch\")\n committer = pygit2.Signature(\"committer\", \"committer@example.com\")\n\n repository.checkout(branch)\n (repository.path / \"a\").touch()\n repository.commit(committer=committer)\n\n cherrypicker = pygit2.Signature(\"cherrypicker\", \"cherrypicker@example.com\")\n monkeypatch.setenv(\"GIT_AUTHOR_NAME\", cherrypicker.name)\n monkeypatch.setenv(\"GIT_AUTHOR_EMAIL\", cherrypicker.email)\n\n repository.checkout(main)\n repository.cherrypick(branch.commit)\n\n assert cherrypicker.email == repository.head.commit.committer.email","def test_call_sh_files(self):\n def structs():\n \"\"\"Mockups for called scripts.\"\"\"\n server = MockUCSHttpServer('server')\n struct_r = U.UCSRepoPool(major=MAJOR, minor=MINOR, part=PART, patchlevel=PATCH, arch=ARCH)\n preup_r = struct_r.path('preup.sh')\n postup_r = struct_r.path('postup.sh')\n struct_c = U.UCSRepoPool(major=MAJOR, minor=MINOR, part='%s/component' % (PART,), patch='c', arch=ARCH)\n preup_c = struct_c.path('preup.sh')\n postup_c = struct_c.path('postup.sh')\n\n yield (server, struct_r, 'preup', preup_r, 'r_pre')\n yield (server, struct_r, 'postup', postup_r, 'r_post')\n yield (server, struct_c, 'preup', preup_c, 'c_pre')\n yield (server, struct_c, 'postup', postup_c, 'c_post')\n tmp = NamedTemporaryFile()\n\n gen = self.u.call_sh_files(structs(), tmp.name, 'arg')\n\n # The Updater only yields the intent, the content is only available after the next step\n self.assertEqual(('update', 'pre'), gen.next()) # download\n self.assertEqual([], MockPopen.mock_get())\n self.assertEqual(('preup', 'pre'), gen.next()) # pre\n self.assertEqual([], MockPopen.mock_get())\n self.assertEqual(('preup', 'main'), gen.next())\n self.assertEqual(('pre', 'arg', 'c_pre'), MockPopen.mock_get()[0][1:])\n self.assertEqual(('preup', 'post'), gen.next())\n self.assertEqual(('arg', 'r_pre'), MockPopen.mock_get()[0][1:])\n self.assertEqual(('update', 'main'), gen.next()) # update\n self.assertEqual(('post', 'arg', 'c_pre'), MockPopen.mock_get()[0][1:])\n self.assertEqual(('postup', 'pre'), gen.next()) # post\n self.assertEqual([], MockPopen.mock_get())\n self.assertEqual(('postup', 'main'), gen.next())\n self.assertEqual(('pre', 'arg', 'c_post'), MockPopen.mock_get()[0][1:])\n self.assertEqual(('postup', 'post'), gen.next())\n self.assertEqual(('arg', 'r_post'), MockPopen.mock_get()[0][1:])\n self.assertEqual(('update', 'post'), gen.next())\n self.assertEqual(('post', 'arg', 'c_post'), MockPopen.mock_get()[0][1:])\n self.assertRaises(StopIteration, gen.next) # done\n self.assertEqual([], MockPopen.mock_get())","def generate_all_files():\n for (name, fn) in lang_module.targets.items():\n path = of_g.options.install_dir + '/' + name\n os.system(\"mkdir -p %s\" % os.path.dirname(path))\n with open(path, \"w\") as outfile:\n fn(outfile, os.path.basename(name))\n print(\"Wrote contents for \" + name)"],"string":"[\n \"def do_genpatch(self, argv):\\n #TODO:\\n # - Would an optional [<files> ...] argument be useful or is\\n # that overkill? E.g. 'p4 genpatch ./...' (I think that that\\n # would be very useful.\\n # - Could add '-f' option to only warn on 'out of sync'.\\n # - Could add '-d<flag>' option to control to diff format.\\n # Context and unified allowed.\\n # - Handling binary files that cannot be diff'd\\n # - Option to be able to control the base dir so the patch -p#\\n # number can be controlled. Dunno what form that should\\n # take.\\n\\n # Process options.\\n diffFormat = 'u'\\n if diffFormat == 'u':\\n prefixes = ('---', '+++')\\n elif diffFormat == 'c':\\n prefixes = ('***', '---')\\n\\n # Process args.\\n if not argv[1:]:\\n change = 'default'\\n elif len(argv[1:]) == 1:\\n change = argv[1]\\n try:\\n change = int(change)\\n except ValueError: \\n # Stupidly, p4win's new Tool %c interpolation will use\\n # \\\"Default\\\", on which the normal p4.exe client will die.\\n change = change.lower()\\n if change != 'default':\\n sys.stderr.write(\\\"Invalid changelist number '%s'.\\\\n\\\"\\\\\\n % change)\\n return 1\\n else:\\n sys.stderr.write(\\\"Usage: genpatch [<changelist#>]\\\\n\\\")\\n sys.stderr.write(\\\"Missing/wrong number of arguments.\\\\n\\\")\\n return 1\\n\\n # Validate the given change number.\\n p4 = p4lib.P4( **p4lib.parseOptv(self.__p4optv) )\\n submitted = [c['change'] for c in p4.changes(status='submitted')]\\n pending = [c['change'] for c in p4.changes(status='pending')]\\n if change in submitted:\\n status = 'submitted'\\n elif change in pending+['default']:\\n status = 'pending'\\n else:\\n sys.stderr.write(\\\"Change %s unknown.\\\" % change)\\n return 1\\n\\n # Get list of files to include in patch.\\n if status == 'submitted':\\n d = p4.describe(change, diffFormat='u')\\n desc = d['description']\\n files = d['files']\\n diffs = d['diff']\\n elif status == 'pending':\\n files = p4.opened(change=change)\\n if change == 'default':\\n desc = None\\n else:\\n desc = p4.change(change=change)['description']\\n if files:\\n diffs = p4.diff([f['depotFile'] for f in files],\\n diffFormat='u')\\n else:\\n diffs = []\\n\\n # Make a single string from 'diffs' with appropriate delimiters\\n # for the \\\"patch\\\" program.\\n diffstr = ''\\n timestamp = time.asctime()\\n for diff in diffs:\\n # Perforce std header, e.g.:\\n # ==== //depot/apps/px/ReadMe.txt#5 (text) ====\\n # or\\n # ==== //depot/foo.doc#42 - c:\\\\trentm\\\\foo.doc ==== (binary)\\n if diff.has_key('localFile'):\\n diffstr += \\\"==== %(depotFile)s#%(rev)s - %(localFile)s ====\\\"\\\\\\n % diff\\n if diff['binary']:\\n diffstr += \\\" (binary)\\\"\\n diffstr += \\\"\\\\n\\\"\\n else:\\n diffstr += \\\"==== %(depotFile)s#%(rev)s (%(type)s) ====\\\\n\\\"\\\\\\n % diff\\n # Patch header, e.g. for unified diffs:\\n # Index: apps/px/test/ToDo.txt\\n # --- apps/px/test/ToDo.txt.~1~ Fri May 31 21:17:17 2002\\n # +++ apps/px/test/ToDo.txt Fri May 31 21:17:17 2002\\n # or for context diffs:\\n # Index: apps/px/test/ToDo.txt\\n # *** apps/px/test/ToDo.txt.~1~ Fri May 31 21:26:47 2002\\n # --- apps/px/test/ToDo.txt Fri May 31 21:26:47 2002\\n fname = diff['depotFile'][len('//depot/'):]\\n\\n if diff.has_key('text'):\\n diffstr += \\\"Index: %s\\\\n\\\" % fname\\n diffstr += \\\"%s %s.~1~\\\\t%s\\\\n\\\" % (prefixes[0], fname, timestamp)\\n diffstr += \\\"%s %s\\\\t%s\\\\n\\\" % (prefixes[1], fname, timestamp)\\n # The diff text.\\n diffstr += ''.join(diff['text'])\\n if diffstr[-1] != '\\\\n':\\n diffstr += \\\"\\\\n\\\\\\\\ No newline at end of file\\\\n\\\"\\n\\n # Inline added files into the diff.\\n addedfiles = [f for f in files if f['action'] in ('add', 'branch')]\\n for f in addedfiles:\\n # May have to get file type from 'p4 files'.\\n if status == 'submitted':\\n f['type'] = p4.files(f['depotFile'])[0]['type']\\n # Skip file if it is binary.\\n if f['type'].startswith('binary'):\\n log.warn(\\\"Cannot inline '%s' because it is binary.\\\"\\\\\\n % f['depotFile'])\\n continue\\n # Get the file contents.\\n if status == \\\"pending\\\":\\n # Read the file contents from disk.\\n localFile = p4.where(f['depotFile'])[0]['localFile']\\n if not os.path.exists(localFile):\\n continue\\n lines = open(localFile, 'r').readlines()\\n else:\\n # Get the file contents via 'p4 print'.\\n fnameRev = \\\"%s#%s\\\" % (f['depotFile'], f['rev'])\\n lines = p4.print_(fnameRev)[0]['text'].split('\\\\n')\\n if not lines[-1]: lines = lines[:-1] # drop empty last line\\n lines = [line+'\\\\n' for line in lines]\\n # Inline the file.\\n diffstr += \\\"\\\\n==== %(depotFile)s#%(rev)s (%(type)s) ====\\\\n\\\" % f\\n if len(lines) < 2:\\n ln = \\\"\\\"\\n else:\\n ln = \\\",\\\" + str(len(lines))\\n fname = f['depotFile'][len('//depot/'):]\\n diffstr += \\\"Index: %s\\\\n\\\" % fname\\n diffstr += \\\"%s %s.~1~\\\\t%s\\\\n\\\" % (prefixes[0], fname, timestamp)\\n diffstr += \\\"%s %s\\\\t%s\\\\n\\\" % (prefixes[1], fname, timestamp)\\n diffstr += \\\"@@ -0,0 +1%s @@\\\\n\\\" % ln\\n diffstr += '+' + '+'.join(lines)\\n if diffstr[-1] != '\\\\n':\\n diffstr += \\\"\\\\n\\\\\\\\ No newline at end of file\\\\n\\\"\\n \\n if diffstr: # std patch terminator\\n diffstr += \\\"End of Patch.\\\"\\n\\n patch = p4lib.makeForm(description=desc, files=files,\\n differences=diffstr)\\n if patch: # ViM-specific hack to have it colorize patches as diffs.\\n patch = \\\"diff\\\\n\\\" + patch\\n\\n sys.stdout.write(patch)\",\n \"def git_upgraded_pkgs(self):\\n\\n self.extract_from_cachedir()\\n self.etc_commits.added.commit()\\n\\n cherry_pick_sha = None\\n if self.etc_commits.cherry_pick.rpaths:\\n self.etc_commits.cherry_pick.commit()\\n cherry_pick_sha = self.repo.git_cmd('rev-list -1 HEAD --')\\n\\n # Clean the working area of the files that are not under version\\n # control.\\n self.repo.git_cmd('clean -d -x -f')\\n\\n # Update the master-tmp branch with new files.\\n if self.master_commits.added.rpaths:\\n self.repo.checkout('master-tmp')\\n for rpath in self.master_commits.added.rpaths:\\n repo_file = os.path.join(self.repodir, rpath)\\n if os.path.lexists(repo_file):\\n warn('adding %s to the master-tmp branch but this file'\\n ' already exists' % rpath)\\n copy_file(rpath, self.root_dir, self.repodir,\\n repo_file=repo_file)\\n self.master_commits.added.commit()\\n\\n return cherry_pick_sha\",\n \"def cherryPickChange(self):\\n rev = io.getNumber('Revision number to cherry-pick:')\\n bug = io.getNumber('Issue fixed by this change:')\\n\\n diff = subversion.diff(self.upstream_repos + '/trunk', rev)\\n if not diff.strip():\\n raise error.ExpectationFailed(\\n 'Retrieved diff is empty. '\\n 'Did you accidentally cherry-pick a branch change?')\\n util.run(['patch', '-p0'], cwd=self.wc.path(self.branch_dir), stdin=diff)\\n self.wc.addRemove(self.branch_dir)\\n\\n yaml_path = self.wc.path(self._branchPath('app/app.yaml'))\\n out = []\\n updated_patchlevel = False\\n for line in io.fileToLines(yaml_path):\\n if line.strip().startswith('version: '):\\n version = line.strip().split()[-1]\\n base, patch = line.rsplit('g', 1)\\n new_version = '%sg%d' % (base, int(patch) + 1)\\n message = ('Cherry-picked r%d from /p/soc/ to fix issue %d' %\\n (rev, bug))\\n out.append('version: ' + new_version)\\n out.append('# * ' + message)\\n updated_patchlevel = True\\n else:\\n out.append(line)\\n\\n if not updated_patchlevel:\\n log.error('Failed to update Google patch revision')\\n log.error('Cherry-picking failed')\\n\\n io.linesToFile(yaml_path, out)\\n\\n log.info('Check the diff about to be committed with:')\\n log.info('svn diff ' + self.wc.path(self.branch_dir))\\n if not io.confirm('Commit this change?'):\\n raise error.AbortedByUser('Cherry-pick aborted')\\n self.wc.commit(message)\\n log.info('Cherry-picked r%d from the Melange trunk.' % rev)\",\n \"def cmd_apply_patch(patchfile):\\n return ['git', 'apply', patchfile]\",\n \"def write_tmp_patches(diffs):\\n files = []\\n for idx, diff in enumerate(diffs):\\n prefix = 'cugit-%s-' % str(idx).zfill(5)\\n suffix = '-patch'\\n filename = mkstemp(suffix, prefix)[1]\\n write_tmp_patch(diff, filename)\\n files.append(filename)\\n return files\",\n \"def copy_patches(root_directory, dist_directory, sdk_directory,\\n cpus, families, boards):\\n\\n def _process(when, contexts):\\n for context in contexts:\\n for patch in configuration.PATCHES:\\n if patch[\\\"when\\\"] == when:\\n context.update({\\n \\\"root\\\": root_directory,\\n \\\"sdk\\\": sdk_directory,\\n \\\"dist\\\": dist_directory\\n })\\n\\n source = templates.from_string(patch[\\\"source\\\"], context)\\n target = templates.from_string(patch[\\\"target\\\"], context)\\n target = os.path.join(dist_directory, target)\\n\\n # Perform the action.\\n sys.stdout.write(\\\"Patching '%s'\\\\n\\\" % source)\\n\\n if patch[\\\"type\\\"] == \\\"file\\\":\\n with open(source, \\\"r\\\") as fp:\\n content = fp.read()\\n\\n for method in patch[\\\"methods\\\"]:\\n content = method(source, content)\\n\\n with open(target, \\\"w\\\") as fp:\\n fp.write(content)\\n elif patch[\\\"type\\\"] == \\\"glob\\\":\\n for source_file in glob.glob(source):\\n if os.path.isfile(source_file):\\n target_file = os.path.join(\\n target, os.path.basename(source_file))\\n\\n with open(source_file, \\\"r\\\") as fp:\\n content = fp.read()\\n\\n for method in patch[\\\"methods\\\"]:\\n content = method(source, content)\\n\\n with open(target_file, \\\"w\\\") as fp:\\n fp.write(content)\\n else:\\n raise Exception(\\\"Not supported\\\")\\n\\n _process(\\\"per_family\\\", families)\\n _process(\\\"per_cpu\\\", cpus)\\n _process(\\\"per_board\\\", boards)\\n _process(\\\"per_once\\\", [{\\n \\\"families\\\": [family[\\\"family\\\"] for family in families],\\n \\\"cpus\\\": [cpu[\\\"cpu\\\"] for cpu in cpus],\\n \\\"boards\\\": [board[\\\"board\\\"] for board in boards]\\n }])\",\n \"def bump_upstream_sources(**kwargs):\\n\\n # Find out current tracking branch to bump\\n # the services matching the branch:\\n oa_folder = kwargs['workdir'] + '/openstack-ansible'\\n try:\\n remote_branch = tracking_branch_name(oa_folder)\\n except ValueError as verr:\\n raise SystemExit(verr)\\n\\n LOGGER.info(\\\"Each file can take a while to update.\\\")\\n prevline = {}\\n reporegex = re.compile('(?P<project>.*)_git_repo: (?P<remote>.*)')\\n branchregex = re.compile(('(?P<project>.*)_git_install_branch: '\\n '(?P<sha>[0-9a-f]{40}) '\\n '# HEAD of \\\"(?P<branch>.*)\\\" '\\n 'as of .*'))\\n\\n update_files = glob.glob(\\n \\\"{}/playbooks/defaults/repo_packages/*.yml\\\".format(oa_folder))\\n\\n stable_branch_skips = [\\n \\\"openstack_testing.yml\\\",\\n \\\"nova_consoles.yml\\\",\\n ]\\n\\n for filename in update_files:\\n if remote_branch.startswith(\\\"stable/\\\") and \\\\\\n os.path.basename(filename) in stable_branch_skips:\\n LOGGER.info(\\\"Skipping {} for stable branch\\\".format(filename))\\n continue\\n LOGGER.info(\\\"Updating {}\\\".format(filename))\\n for line in fileinput.input(filename, inplace=True):\\n rrm = reporegex.match(line)\\n if rrm:\\n # Extract info of repo line (previous line)\\n # for branch line (current line)\\n prevline['project'] = rrm.group('project')\\n prevline['remote'] = rrm.group('remote')\\n print(branchregex.sub(\\n lambda x: bump_project_sha_with_comments(x, prevline), line)),\\n\\n LOGGER.info(\\\"All files patched !\\\")\\n msg = (\\\"Update all SHAs for {next_release}\\\\n\\\\n\\\"\\n \\\"This patch updates all the roles to the latest available stable \\\\n\\\"\\n \\\"SHA's, copies the release notes from the updated roles into the \\\\n\\\"\\n \\\"integrated repo, updates all the OpenStack Service SHA's, and \\\\n\\\"\\n \\\"updates the appropriate python requirements pins. \\\\n\\\\n\\\"\\n \\\"Depends-On: {release_changeid}\\\").format(\\n next_release=os.environ.get('next_release', '<NEW VERSION>'),\\n release_changeid=os.environ.get('release_changeid', '<TODO>'),)\\n if kwargs['commit']:\\n repo = Repo(oa_folder)\\n repo.git.add('.')\\n repo.index.commit(msg)\\n click.echo(\\\"Commit done. Please verify before review.\\\")\\n else:\\n click.echo(\\\"Here is a commit message you could use:\\\\n\\\")\\n click.echo(msg)\",\n \"def patch_files():\\n args = parser.parse_args()\\n doc = json.load(args.ORIGINAL)\\n patch = json.load(args.PATCH)\\n result = jsonpatch.apply_patch(doc, patch)\\n print(json.dumps(result, indent=args.indent))\",\n \"def createPatch(self):\\n\\n if not CraftCore.cache.findApplication(\\\"diff\\\"):\\n CraftCore.log.critical(\\\"could not find diff tool, please run 'craft diffutils'\\\")\\n return False\\n\\n # get the file paths of the tarballs\\n filenames = self.localFileNames()\\n\\n destdir = self.workDir()\\n\\n # it makes no sense to make a diff against nothing\\n if not os.path.exists(self.sourceDir()):\\n CraftCore.log.error(\\\"source directory doesn't exist, please run unpack first\\\")\\n return False\\n\\n CraftCore.log.debug(\\\"unpacking files into work root %s\\\" % destdir)\\n\\n # make a temporary directory so the original packages don't overwrite the already existing ones\\n with tempfile.TemporaryDirectory() as tmpdir:\\n _patchName = f\\\"{self.package.name}-{self.buildTarget}-{str(datetime.date.today()).replace('-', '')}.diff\\\"\\n\\n # unpack all packages\\n for filename in filenames:\\n CraftCore.log.debug(f\\\"unpacking this file: {filename}\\\")\\n if not utils.unpackFile(self.__downloadDir, filename, tmpdir):\\n return False\\n\\n patches = self.subinfo.patchesToApply()\\n if not isinstance(patches, list):\\n patches = [patches]\\n for fileName, patchdepth in patches:\\n if os.path.basename(fileName) == _patchName:\\n CraftCore.log.info(f\\\"skipping patch {fileName} with patchlevel: {patchdepth}\\\")\\n continue\\n CraftCore.log.info(f\\\"applying patch {fileName} with patchlevel: {patchdepth}\\\")\\n if not self.applyPatch(\\n fileName,\\n patchdepth,\\n os.path.join(tmpdir, os.path.relpath(self.sourceDir(), self.workDir())),\\n ):\\n return False\\n\\n srcSubDir = os.path.relpath(self.sourceDir(), self.workDir())\\n tmpSourceDir = os.path.join(tmpdir, srcSubDir)\\n with io.BytesIO() as out:\\n ignores = []\\n for x in [\\n \\\"*~\\\",\\n r\\\"*\\\\.rej\\\",\\n r\\\"*\\\\.orig\\\",\\n r\\\"*\\\\.o\\\",\\n r\\\"*\\\\.pyc\\\",\\n \\\"CMakeLists.txt.user\\\",\\n ]:\\n ignores += [\\\"-x\\\", x]\\n\\n # TODO: actually we should not accept code 2\\n if not utils.system(\\n [\\\"diff\\\", \\\"-Nrub\\\"] + ignores + [tmpSourceDir, self.sourceDir()],\\n stdout=out,\\n acceptableExitCodes=[0, 1, 2],\\n cwd=destdir,\\n ):\\n return False\\n patchContent = out.getvalue()\\n # make the patch a -p1 patch\\n patchContent = patchContent.replace(tmpSourceDir.encode(), f\\\"{srcSubDir}.orig\\\".encode())\\n patchContent = patchContent.replace(str(self.sourceDir()).encode(), srcSubDir.encode())\\n patchPath = os.path.join(self.packageDir(), _patchName)\\n with open(patchPath, \\\"wb\\\") as out:\\n out.write(patchContent)\\n\\n CraftCore.log.info(f'Patch created {patchPath} self.patchToApply[\\\"{self.buildTarget}\\\"] = [(\\\"{_patchName}\\\", 1)]')\\n return True\",\n \"def push_mockups():\\n local('cd ../../cts-ui && grunt')\\n local('cp ../../cts-ui/mockups/css/*.css ../../mockups/cts-ui/css/.')\\n local('cp -R ../../cts-ui/mockups/css/bootstrap ../../mockups/cts-ui/css/bootstrap')\\n local('cp -R ../../cts-ui/mockups/img ../../mockups/cts-ui/img')\\n local('cp ../../cts-ui/mockups/*.html ../../mockups/cts-ui/.')\\n local('cd ../../mockups/cts-ui && git add *.html')\\n local('cd ../../mockups/cts-ui/css && git add *.css')\\n local('cd ../../mockups/cts-ui/css && git add bootstrap/*')\\n local('cd ../../mockups/cts-ui && git add img/*')\\n local('cd ../../mockups && git commit -am \\\"New cts-ui mockups [fabfile]\\\"')\\n local('cd ../../mockups && git push origin master')\",\n \"def apply_patch(self, patch):\\n # Remove Chromium WPT directory prefix.\\n patch = patch.replace(RELATIVE_WPT_TESTS, '')\\n try:\\n self.run(['git', 'apply', '-'], input=patch)\\n self.run(['git', 'add', '.'])\\n except ScriptError as error:\\n return error.message\\n return ''\",\n \"def createPatch(self):\\n CraftCore.debug.trace(\\\"GitSource createPatch\\\")\\n patchFileName = os.path.join(\\n self.packageDir(),\\n \\\"%s-%s.patch\\\" % (self.package.name, str(datetime.date.today()).replace(\\\"-\\\", \\\"\\\")),\\n )\\n CraftCore.log.debug(\\\"git diff %s\\\" % patchFileName)\\n with open(patchFileName, \\\"wt+\\\") as patchFile:\\n return self.__git(\\\"diff\\\", stdout=patchFile)\",\n \"def patch_repos(self):\",\n \"def platformify(self):\\n actions = ['rsync -aP {0} {1}'.format(\\n os.path.join(TEMPLATEDIR, self.name, 'files/'), self.builddir\\n )]\\n patches = glob(os.path.join(TEMPLATEDIR, self.name, \\\"*.patch\\\"))\\n for patch in patches:\\n actions.append('cd {0}/web && patch -p1 < {1}'.format(\\n self.builddir, patch)\\n )\\n\\n # In some cases the package updater needs to be run after we've platform-ified the\\n # template, so run it a second time. Worst case it's a bit slower to build but doesn't\\n # hurt anything.\\n actions.extend(self.package_update_actions())\\n\\n return actions\",\n \"def clpatch(ui, repo, clname, **opts):\\n\\tcl, patch, err = DownloadCL(ui, repo, clname)\\n\\targv = [\\\"hgpatch\\\"]\\n\\tif opts[\\\"no_incoming\\\"]:\\n\\t\\targv += [\\\"--checksync=false\\\"]\\n\\tif err != \\\"\\\":\\n\\t\\treturn err\\n\\ttry:\\n\\t\\tcmd = subprocess.Popen(argv, shell=False, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=None, close_fds=True)\\n\\texcept:\\n\\t\\treturn \\\"hgpatch: \\\" + ExceptionDetail()\\n\\tif os.fork() == 0:\\n\\t\\tcmd.stdin.write(patch)\\n\\t\\tos._exit(0)\\n\\tcmd.stdin.close()\\n\\tout = cmd.stdout.read()\\n\\tif cmd.wait() != 0:\\n\\t\\treturn \\\"hgpatch failed\\\"\\n\\tcl.local = True\\n\\tcl.files = out.strip().split()\\n\\tfiles = ChangedFiles(ui, repo, [], opts)\\n\\textra = Sub(cl.files, files)\\n\\tif extra:\\n\\t\\tui.warn(\\\"warning: these files were listed in the patch but not changed:\\\\n\\\\t\\\" + \\\"\\\\n\\\\t\\\".join(extra) + \\\"\\\\n\\\")\\n\\tcl.Flush(ui, repo)\\n\\tui.write(cl.PendingText() + \\\"\\\\n\\\")\",\n \"def maybe_apply_patches(input_dir, patch_files=None):\\n if not patch_files:\\n return\\n old_dir = os.getcwd()\\n os.chdir(input_dir)\\n for patch_file in patch_files:\\n with open(patch_file) as patch_in:\\n patch_proc = subprocess.Popen(['git', 'am', '--3way'],\\n stdin=patch_in)\\n status = patch_proc.wait()\\n if status != 0:\\n raise RuntimeError('Patch failed; git output: %s' % status)\\n logging.info(\\\"Finished applying patch %s\\\", patch_file)\\n os.chdir(old_dir)\",\n \"def port_patches(\\n default_prior_dir,\\n default_post_dir,\\n resource_prior_patches_dir,\\n resource_post_patches_dir,\\n resource_post_dir,\\n resource_prior_dir=None,\\n default_post_patches_dir=None,\\n action=None,\\n all_patch=False):\\n\\n default_prior_dir = os.path.expanduser(default_prior_dir)\\n default_post_dir = os.path.expanduser(default_post_dir)\\n resource_prior_patches_dir = os.path.expanduser(resource_prior_patches_dir)\\n resource_post_patches_dir = os.path.expanduser(resource_post_patches_dir)\\n resource_post_dir = os.path.expanduser(resource_post_dir)\\n if resource_prior_dir:\\n resource_prior_dir = os.path.expanduser(resource_prior_dir)\\n if default_post_patches_dir:\\n default_post_patches_dir = os.path.expanduser(default_post_patches_dir)\\n\\n os.makedirs(resource_post_patches_dir, exist_ok=True)\\n os.makedirs(resource_post_dir, exist_ok=True)\\n\\n resource_prior_patch_map = {}\\n resource_prior_patch_map_path = os.path.join(resource_prior_dir, \\\"patch_map.json\\\")\\n if os.path.isfile(resource_prior_patch_map_path):\\n with open(resource_prior_patch_map_path, \\\"r\\\") as resource_prior_patch_map_file:\\n resource_prior_patch_map = json.load(resource_prior_patch_map_file)\\n\\n resource_post_patch_map = {}\\n resource_post_patch_map_path = os.path.join(resource_post_dir, \\\"patch_map.json\\\")\\n if os.path.isfile(resource_post_patch_map_path):\\n with open(resource_post_patch_map_path, \\\"r\\\") as resource_post_patch_map_file:\\n resource_post_patch_map = json.load(resource_post_patch_map_file)\\n\\n default_post_patch_map = {}\\n default_post_patch_map_path = os.path.join(default_post_dir, \\\"patch_map.json\\\")\\n if os.path.isfile(default_post_patch_map_path):\\n with open(default_post_patch_map_path, \\\"r\\\") as default_post_patch_map_file:\\n default_post_patch_map = json.load(default_post_patch_map_file)\\n\\n image_hashes = hash_images(default_prior_dir, resource_prior_patches_dir)\\n\\n # used for printing completion state during long-running task\\n file_count = 0\\n file_checkpoint = 0\\n file_total = sum(len(files) for _, _, files in os.walk(default_post_dir))\\n\\n # attempt to texture everything in the merged output space\\n for file_dir, _, file_names in os.walk(default_post_dir):\\n for file_name in file_names:\\n file_count += 1\\n if file_count / file_total > file_checkpoint:\\n print(f\\\"Remapping status: {file_checkpoint:.0%}\\\")\\n file_checkpoint += .05\\n\\n # .mcmeta files are also ported when the associated .png is ported\\n if not file_name.endswith(\\\".png\\\"):\\n continue\\n\\n file_path = os.path.join(file_dir, file_name)\\n relative_path = file_path.replace(default_post_dir, \\\"\\\")\\n\\n # full path to the file in the output merged space\\n merged_post_resource_path = os.path.join(resource_post_dir, *relative_path.split(os.sep))\\n\\n # skip if already textured\\n if action != 'copy-overwrite' and os.path.exists(merged_post_resource_path):\\n continue\\n\\n # retrieve paths to all resource pack textures for this target image\\n with open(file_path, 'rb') as image_file:\\n image_hash = hashlib.md5(image_file.read()).hexdigest()\\n matches = image_hashes.get(image_hash)\\n\\n if matches is None:\\n continue\\n # TODO: evaluate fitness of each match, and choose the best? seems very situational\\n best_match = matches[0]\\n\\n if all_patch:\\n default_patch_name, patch_name = 'All', 'All'\\n else:\\n default_patch_name, patch_name = infer_resource_patch_name(\\n default_post_patches_dir,\\n resource_post_patches_dir,\\n default_post_patch_map,\\n resource_prior_patch_map,\\n resource_post_patch_map,\\n relative_path,\\n matches)\\n\\n if patch_name is None:\\n continue\\n\\n # full path to the file in the output patch space\\n post_resource_path = os.path.join(resource_post_patches_dir, patch_name, *relative_path.split(os.sep))\\n\\n # if source is same as target, then this is a no-op\\n prior_resource_path = os.path.join(resource_prior_patches_dir, best_match)\\n if prior_resource_path == post_resource_path:\\n continue\\n\\n if os.path.exists(post_resource_path) and action != 'copy-overwrite':\\n continue\\n\\n print()\\n if len(matches) > 1:\\n print(f\\\"Multiple matches found ({len(matches)}). Mapping from first:\\\")\\n\\n print(f'{action}: {best_match}\\\\n'\\n f' -> {os.path.join(patch_name, *relative_path.split(os.sep))}')\\n\\n os.makedirs(os.path.dirname(post_resource_path), exist_ok=True)\\n\\n # move or copy the file\\n perform_action(prior_resource_path, post_resource_path, action)\\n\\n prior_resource_meta_path = prior_resource_path + '.mcmeta'\\n if os.path.exists(prior_resource_meta_path):\\n print(f'{action}: {prior_resource_meta_path.replace(resource_prior_patches_dir, \\\"\\\")}\\\\n'\\n f' -> {os.path.join(*post_resource_path.replace(resource_post_patches_dir, \\\"\\\").split(os.sep))}.mcmeta')\\n\\n perform_action(prior_resource_meta_path, post_resource_path + '.mcmeta', action)\\n\\n if not all_patch:\\n update_mod_json(\\n default_post_patches_dir,\\n resource_prior_patches_dir,\\n resource_post_patches_dir,\\n relative_path,\\n default_patch_name,\\n patch_name)\\n\\n if os.path.exists(os.path.join(resource_post_patches_dir, UNKNOWN_PATCH_NAME)):\\n print(\\\"Check the _UNKNOWN folder for textures ported into domains that did not belong to a previous patch.\\\")\",\n \"def mspatchc_CreatePatchFile(jitter, get_str, set_str):\\n ret_ad, args = jitter.func_args_stdcall([\\\"OldFileName\\\", \\\"NewFileName\\\", \\\"PatchFileName\\\", \\\"OptionFlags\\\", \\\"OptionData\\\"])\\n raise RuntimeError('API not implemented')\\n jitter.func_ret_stdcall(ret_ad, ret_value)\",\n \"def cherry_pick_change(branch, revision, parent_repo, dry_run, verbose=False):\\n drover = _Drover(branch, revision, parent_repo, dry_run, verbose)\\n drover.run()\",\n \"def test_resetcherrypick_removes_added_files(\\n repository: Repository, paths: Iterator[Path]\\n) -> None:\\n main = repository.head\\n update, _ = createbranches(repository, \\\"update\\\", \\\"latest\\\")\\n path1, path2 = next(paths), next(paths)\\n\\n repository.checkout(update)\\n updatefiles({path1: \\\"a\\\", path2: \\\"\\\"})\\n\\n repository.checkout(main)\\n updatefile(path1, \\\"b\\\")\\n\\n with pytest.raises(MergeConflictError, match=path1.name):\\n repository.cherrypick(update.commit)\\n\\n repository.resetcherrypick()\\n\\n assert not path2.exists()\",\n \"def update(filepath, github_account):\\n repo = _git.clone_from_github(\\n _REPO_PATH, join(filepath, _REPO_NAME), github_account=github_account)\\n _install_dependencies(repo)\\n added, deleted, updated = _generate_all_clients(repo)\\n if not any([added, deleted, updated]):\\n return\\n _run_tests(repo)\\n commitmsg = _commit_message.build(added, deleted, updated)\\n repo.add(['api_names_out.yaml', 'generated'])\\n repo.commit(commitmsg, github_account.name, github_account.email)\\n repo.push()\",\n \"def prep( c ):\\n\\n copytree( \\\"vendor\\\", \\\"dist/please_respond/timezonefinder\\\" )\",\n \"def test_resetcherrypick_keeps_unrelated_additions(\\n repository: Repository, paths: Iterator[Path]\\n) -> None:\\n main = repository.head\\n update, _ = createbranches(repository, \\\"update\\\", \\\"latest\\\")\\n path1, path2 = next(paths), next(paths)\\n\\n repository.checkout(update)\\n updatefile(path1, \\\"a\\\")\\n\\n repository.checkout(main)\\n updatefile(path1, \\\"b\\\")\\n\\n path2.touch()\\n\\n with pytest.raises(MergeConflictError, match=path1.name):\\n repository.cherrypick(update.commit)\\n\\n repository.resetcherrypick()\\n\\n assert path2.exists()\",\n \"def package():\\n \\n hou.hipFile.save()\\n currentHip = hou.expandString(hou.hipFile.name())\\n\\n # create a temp directory we are going to fill with crap\\n tempFilePath = tempfile.mkdtemp()\\n \\n otls = os.path.join(tempFilePath, \\\"otls\\\")\\n os.mkdir(otls)\\n files = os.path.join(tempFilePath, \\\"files\\\")\\n os.mkdir(files)\\n \\n # Get all the external references to the hipfile\\n fileOnDisk = hou.fileReferences()\\n\\n # loop and do what comes natural.\\n for _file in fileOnDisk:\\n\\n parm = _file[0]\\n filepath = _file[1]\\n \\n # if its a otl we need to store it.\\n if filepath.endswith(\\\".otl\\\"):\\n \\n shutil.copy(hou.expandString(filepath), otls)\\n \\n else:\\n \\n if not os.path.isfile(hou.expandString(filepath)): \\n \\n continue\\n \\n # create a directory in files and save 1 file to that location\\n tmpFileName = os.path.basename(hou.expandString(filepath))\\n tmpFileDir = os.path.basename(os.path.dirname(hou.expandString(filepath)))\\n path = os.path.join(files, tmpFileDir)\\n \\n if not os.path.isdir(path):\\n \\n os.mkdir(path)\\n\\n shutil.copy(hou.expandString(filepath), os.path.join(path, os.path.basename(hou.expandString(filepath))))\\n\\n try:\\n \\n if not parm.node().isLocked():\\n \\n parm.set(os.path.join(path.replace(tempFilePath, \\\"$HIP\\\"), tmpFileName))\\n \\n except hou.PermissionError: \\n \\n logging.warning(\\\"Error hardening parm :\\\" + str(parm.name()) + \\\"on node \\\" +parm.node().path())\\n\\n hou.hipFile.save(os.path.join(tempFilePath, os.path.basename(hou.expandString(hou.hipFile.name()))))\\n # Load the source hipfile\\n hou.hipFile.load(currentHip)\\n \\n # create a zipfile and package everything. then copy it to the home.\\n zipfileLoc = zipdir(tempFilePath)\\n shutil.move(zipfileLoc, os.path.join(hou.expandString(\\\"~\\\"), \\\"package.zip\\\"))\\n shutil.rmtree(tempFilePath)\",\n \"def _applyGooglePatches(self):\\n # Edit the base template to point users to the Google fork\\n # of the Melange codebase instead of the vanilla release.\\n tmpl_file = self.wc.path(\\n self._branchPath('app/soc/templates/soc/base.html'))\\n tmpl = io.fileToLines(tmpl_file)\\n for i, line in enumerate(tmpl):\\n if 'http://code.google.com/p/soc/source/browse/tags/' in line:\\n tmpl[i] = line.replace('/p/soc/', '/p/soc-google/')\\n break\\n else:\\n raise error.ExpectationFailed(\\n 'No source code link found in base.html')\\n io.linesToFile(tmpl_file, tmpl)\\n\\n self.wc.commit(\\n 'Customize the Melange release link in the sidebar menu')\",\n \"def sync_from_upstream(self):\\n if not self.missing_branches:\\n self.log(f\\\"All branches are synced, nothing to do here.\\\")\\n return\\n\\n with tempfile.TemporaryDirectory() as tmpdir:\\n src_path = Path(tmpdir) / self.deb_model.src\\n self.deb_model.base.clone(cwd=tmpdir)\\n for branch in self.missing_branches:\\n self.log(f\\\"Processing branch {branch}\\\")\\n self.deb_model.base.checkout(branch, new_branch=True, cwd=str(src_path))\\n\\n changelog_fn = src_path / \\\"debian/changelog\\\"\\n changelog_fn_tpl = src_path / \\\"debian/changelog.in\\\"\\n\\n k8s_major_minor = semver.VersionInfo.parse(branch.lstrip(\\\"v\\\"))\\n\\n changelog_context = {\\n \\\"deb_version\\\": f\\\"{str(k8s_major_minor)}-0\\\",\\n }\\n\\n self.log(f\\\"Writing template vars {changelog_context}\\\")\\n changelog_out = changelog_fn_tpl.read_text()\\n changelog_out = self.render(changelog_fn_tpl, changelog_context)\\n changelog_fn.write_text(changelog_out)\\n\\n self.log(f\\\"Committing {branch}\\\")\\n self.deb_model.base.add([str(changelog_fn)], cwd=str(src_path))\\n self.deb_model.base.commit(\\n f\\\"Creating branch {branch}\\\", cwd=str(src_path)\\n )\\n self.deb_model.base.push(ref=branch, cwd=str(src_path))\",\n \"def regenerate():\\n local('pelican -o {} -r -s pelicanconf.py'.format(env.deploy_path))\",\n \"def createPatch(self):\\n craftDebug.trace(\\\"HgSource.createPatch called\\\")\\n ret = False\\n if self.enableHg:\\n os.chdir(self.sourceDir())\\n patchFile = os.path.join(self.packageDir(),\\n \\\"%s-%s.patch\\\" % (self.package, str(datetime.date.today()).replace('-', '')))\\n ret = self.system(self.sourceDir(), \\\"%s diff > %s\\\" % (self.hgExecutable, patchFile))\\n return ret\",\n \"def mspatchc_CreatePatchFileByHandles(jitter):\\n ret_ad, args = jitter.func_args_stdcall([\\\"OldFileHandle\\\", \\\"NewFileHandle\\\", \\\"PatchFileHandle\\\", \\\"OptionFlags\\\", \\\"OptionData\\\"])\\n raise RuntimeError('API not implemented')\\n jitter.func_ret_stdcall(ret_ad, ret_value)\",\n \"def test_resetcherrypick_keeps_unrelated_changes(\\n repository: Repository, paths: Iterator[Path]\\n) -> None:\\n main = repository.head\\n update, _ = createbranches(repository, \\\"update\\\", \\\"latest\\\")\\n path1, path2 = next(paths), next(paths)\\n\\n repository.checkout(update)\\n updatefile(path1, \\\"a\\\")\\n\\n repository.checkout(main)\\n updatefile(path1, \\\"b\\\")\\n updatefile(path2)\\n\\n path2.write_text(\\\"c\\\")\\n\\n with pytest.raises(MergeConflictError, match=path1.name):\\n repository.cherrypick(update.commit)\\n\\n repository.resetcherrypick()\\n\\n assert path2.read_text() == \\\"c\\\"\",\n \"def main(args):\\n\\n try:\\n repo = RpmGitRepository(args.gitdir)\\n except GitRepositoryError, err:\\n raise GbsError(str(err))\\n\\n packaging_dir = get_packaging_dir(args)\\n changes_file_list = glob.glob(\\\"%s/%s/*.changes\\\" % (repo.path,\\n packaging_dir))\\n\\n if args.spec or not changes_file_list:\\n # Create .changes file with the same name as a spec\\n specfile = os.path.basename(guess_spec(repo.path,\\n packaging_dir, args.spec)[0])\\n fn_changes = os.path.splitext(specfile)[0] + \\\".changes\\\"\\n fn_changes = os.path.join(repo.path, packaging_dir, fn_changes)\\n else:\\n fn_changes = changes_file_list[0]\\n if len(changes_file_list) > 1:\\n log.warning(\\\"Found more than one changes files, %s is taken \\\"\\n % (changes_file_list[0]))\\n\\n # get the commit start from the args.since\\n commitid_since = get_first_commit(repo, fn_changes, args.since)\\n\\n commits = repo.get_commits(commitid_since, 'HEAD')\\n if not commits:\\n raise GbsError(\\\"Nothing found between %s and HEAD\\\" % commitid_since)\\n\\n if args.message:\\n author = repo.get_author_info()\\n lines = [\\\"- %s\\\" % line for line in args.message.split(os.linesep) \\\\\\n if line.strip()]\\n new_entries = [\\\"* %s %s <%s> %s\\\" % \\\\\\n (datetime.datetime.now().strftime(\\\"%a %b %d %Y\\\"),\\n author.name, author.email,\\n get_version(repo, commits[0]))]\\n new_entries.extend(lines)\\n else:\\n new_entries = make_log_entries(commits, repo)\\n\\n content = get_all_entries(fn_changes, new_entries)\\n if edit_file(fn_changes, content):\\n log.info(\\\"Change log has been updated.\\\")\\n else:\\n log.info(\\\"Change log has not been updated\\\")\",\n \"def apply_patches():\\n # Set USERNAME if needed\\n try:\\n getpass.getuser()\\n except: # pylint: disable=W0702\\n os.environ[\\\"USERNAME\\\"] = \\\"git\\\"\\n # Patch dulwich to work without valid UID/GID\\n repo._get_default_identity = patched_repo_get_default_identity(repo._get_default_identity) # pylint: disable=W0212\\n # Patch dulwich to use paramiko SSH client\\n client.get_ssh_vendor = ParamikoSSHVendor\\n # Patch paramiko to skip key verification\\n paramiko.transport.Transport._verify_key = patched_paramiko_transport_verify_key # pylint: disable=W0212\\n # Patch paramiko to support direct pkey usage\\n paramiko.client.SSHClient._auth = patched_paramiko_client_SSHClient_auth(paramiko.client.SSHClient._auth) # pylint: disable=C0301,W0212\",\n \"def gen_versioned_files(self, wave=1):\\n if self.file:\\n yield self.file\\n else:\\n py_files = ['setup.cfg', 'setup.py', '*/__init__.py']\\n js_files = ['bower.json', 'package.json', 'component.json']\\n php_files = ['composer.json']\\n misc_files = ['*.spec', '*.php', '*.py', '*.xml', '*.json']\\n wave_one = py_files + js_files + php_files\\n switch = {1: wave_one, 2: misc_files}\\n\\n for git_file in self.files:\\n if any(fnmatch(git_file, file_) for file_ in switch[wave]):\\n yield git_file\",\n \"def extract_patch(opts, patch_start, patch_length, ucode_file, ucode_level):\\n cwd = os.getcwd()\\n\\n if not os.path.exists(opts.extract):\\n os.makedirs(opts.extract)\\n\\n os.chdir(opts.extract)\\n\\n ucode_file.seek(patch_start, 0)\\n out_file_name = \\\"mc_patch_0%x.bin\\\" % (ucode_level)\\n out_file = open(out_file_name, \\\"wb\\\")\\n out_file.write(ucode_file.read(patch_length))\\n out_file.close()\\n\\n print(\\\" Patch extracted to %s/%s\\\" % (os.getcwd(), out_file_name))\\n\\n os.chdir(cwd)\",\n \"def stage_changes(c):\\n c.run(f\\\"git add -u\\\")\",\n \"def generate_apidoc_patches(self):\\n base_path = self.paths[\\\"api_doc_dir\\\"]\\n from django_swagger_utils.core.utils.mk_dirs import MkDirs\\n MkDirs().mk_dir_if_not_exits(file_name=base_path + \\\"/\\\")\\n\\n from django_swagger_utils.apidoc_gen.generators.patch_generator import PatchGenerator\\n\\n patch_generator = PatchGenerator(self.app_name, self.parser, self.paths, base_path)\\n # generating api docs\\n patch_generator.generate_json_patch()\",\n \"def _gen_diff_patch(self, git_object_a, git_object_b, src_alias, dst_alias,\\n cwd, deps_rev):\\n # The prefixes used in the command below are used to find and replace the\\n # tree-ish git object id's on the diff output more easily.\\n cmd = 'diff %s %s --src-prefix=IAMSRC: --dst-prefix=IAMDST:'\\n cmd %= (git_object_a, git_object_b)\\n cmd = cmd.split(' ')\\n stdout = self.api.m.raw_io.output()\\n step_name = 'Generating patch for %s to %s' % (git_object_a, deps_rev)\\n step_result = self.api.m.git(*cmd, cwd=cwd, stdout=stdout, name=step_name)\\n patch_text = step_result.stdout\\n src_string = 'IAMSRC:' + git_object_a\\n dst_string = 'IAMDST:' + git_object_b\\n patch_text = patch_text.replace(src_string, src_alias)\\n patch_text = patch_text.replace(dst_string, dst_alias)\\n return patch_text\",\n \"def cmd_generate_requirements(): \\n \\n for env in ('dev', 'test'):\\n source = Path(ROOT, \\\"requirements\\\", f\\\"{env}.txt\\\")\\n target = Path(ROOT, \\\"requirements\\\", f\\\"{env}.in\\\")\\n os.system(f\\\"pip-compile --output-file={source} {target}\\\")\",\n \"def cmd_generate_requirements(): \\n \\n for env in ('dev', 'test'):\\n source = Path(ROOT, \\\"requirements\\\", f\\\"{env}.txt\\\")\\n target = Path(ROOT, \\\"requirements\\\", f\\\"{env}.in\\\")\\n os.system(f\\\"pip-compile --output-file={source} {target}\\\")\",\n \"def bump_upstream_repos_shas(path):\\n filelist = find_yaml_files(path)\\n for filename in filelist:\\n print(\\\"Working on %s\\\" % filename)\\n bump_upstream_repos_sha_file(filename)\",\n \"def install_step(self):\\n\\n# if LooseVersion(self.version) < LooseVersion('2012-10-05'):\\n\\tif (False):\\n self.inchworm()\\n self.chrysalis()\\n self.kmer()\\n self.butterfly()\\n\\n bwapluginver = self.cfg['bwapluginver']\\n if bwapluginver:\\n self.trinityplugin('bwa-%s-patched_multi_map' % bwapluginver)\\n\\n if self.cfg['RSEMmod']:\\n self.trinityplugin('RSEM-mod', cc=os.getenv('CXX'))\\n\\n else:\\n self.jellyfish()\\n\\n inchworm_flags = self.inchworm(run=False)\\n chrysalis_flags = self.chrysalis(run=False)\\n\\n cc = os.getenv('CC')\\n cxx = os.getenv('CXX')\\n\\n lib_flags = \\\"\\\"\\n for lib in ['ncurses', 'zlib']:\\n libroot = get_software_root(lib)\\n if libroot:\\n lib_flags += \\\" -L%s/lib\\\" % libroot\\n\\n fn = \\\"Makefile\\\"\\n for line in fileinput.input(fn, inplace=1, backup='.orig.eb'):\\n\\n line = re.sub(r'^(INCHWORM_CONFIGURE_FLAGS\\\\s*=\\\\s*).*$', r'\\\\1%s' % inchworm_flags, line)\\n line = re.sub(r'^(CHRYSALIS_MAKE_FLAGS\\\\s*=\\\\s*).*$', r'\\\\1%s' % chrysalis_flags, line)\\n line = re.sub(r'(/rsem && \\\\$\\\\(MAKE\\\\))\\\\s*$',\\n r'\\\\1 CC=%s CXX=\\\"%s %s\\\" CFLAGS_EXTRA=\\\"%s\\\"\\\\n' % (cc, cxx, lib_flags, lib_flags), line)\\n line = re.sub(r'(/fastool && \\\\$\\\\(MAKE\\\\))\\\\s*$',\\n r'\\\\1 CC=\\\"%s -std=c99\\\" CFLAGS=\\\"%s ${CFLAGS}\\\"\\\\n' % (cc, lib_flags), line)\\n\\n sys.stdout.write(line)\\n\\n trinity_compiler = None\\n comp_fam = self.toolchain.comp_family()\\n if comp_fam in [toolchain.INTELCOMP]:\\n trinity_compiler = \\\"intel\\\"\\n elif comp_fam in [toolchain.GCC]:\\n trinity_compiler = \\\"gcc\\\"\\n else:\\n self.log.error(\\\"Don't know how to set TRINITY_COMPILER for %s compiler\\\" % comp_fam)\\n\\n cmd = \\\"make TRINITY_COMPILER=%s\\\" % trinity_compiler\\n run_cmd(cmd)\\n\\n # butterfly is not included in standard build\\n self.butterfly()\\n\\n # remove sample data if desired\\n if not self.cfg['withsampledata']:\\n try:\\n shutil.rmtree(os.path.join(self.cfg['start_dir'], 'sample_data'))\\n except OSError, err:\\n self.log.error(\\\"Failed to remove sample data: %s\\\" % err)\",\n \"def setup_files(args):\\n postfix = 'reinforce'\\n has_value_model = False\\n if args.baseline:\\n postfix = \\\"reinforce-baseline\\\"\\n has_value_model = True\\n elif args.actor_critic:\\n postfix = \\\"actor-critic\\\"\\n has_value_model = True\\n elif args.a2c:\\n postfix = \\\"a2c\\\"\\n has_value_model = True\\n elif args.random:\\n postfix = \\\"random\\\"\\n\\n # create the folder for log files\\n try:\\n os.mkdir(postfix)\\n except FileExistsError:\\n print(postfix, \\\" folder exists\\\")\\n\\n fileid = \\\"%s-%d\\\" % (postfix, int(time.time()))\\n actor_weights = \\\"actor_weights-%s.h5\\\" % fileid\\n actor_weights = os.path.join(postfix, actor_weights)\\n encoder_weights = \\\"encoder_weights-%s.h5\\\" % fileid\\n encoder_weights = os.path.join(postfix, encoder_weights)\\n value_weights = None\\n if has_value_model:\\n value_weights = \\\"value_weights-%s.h5\\\" % fileid\\n value_weights = os.path.join(postfix, value_weights)\\n\\n outdir = \\\"/tmp/%s\\\" % postfix\\n\\n misc = (postfix, fileid, outdir, has_value_model)\\n weights = (actor_weights, encoder_weights, value_weights)\\n\\n return weights, misc\",\n \"def rewrite_jaraco(pkg_files, new_root):\\n for file in pkg_files.glob('*.py'):\\n text = file.read_text()\\n text = re.sub(r' (more_itertools)', rf' {new_root}.\\\\1', text)\\n file.write_text(text)\\n # required for zip-packaged setuptools #3084\\n pkg_files.joinpath('__init__.py').write_text('')\",\n \"def uncrustify(ui, repo, *patterns, **options):\\n if options[\\\"diff\\\"] and options[\\\"modify\\\"]:\\n raise util.Abort(\\\"cannot specify --diff and --modify at the same time\\\")\\n\\n if options[\\\"diff\\\"]:\\n mode = \\\"diff\\\"\\n elif options[\\\"modify\\\"]:\\n mode = \\\"modify\\\"\\n else:\\n mode = \\\"status\\\"\\n\\n no_backup = options[\\\"no_backup\\\"]\\n show_clean = options[\\\"show_clean\\\"]\\n\\n paths = [path for path in _get_files(repo, patterns, options)\\n if path.endswith((\\\".cc\\\", \\\".h\\\"))]\\n\\n\\n uncrustify_cfg = repo.pathto(\\\".uncrustify.cfg\\\")\\n relpaths = [repo.pathto(path) for path in paths]\\n if not os.path.exists(uncrustify_cfg):\\n raise util.Abort(\\\"could not find .uncrustify.cfg in repository root\\\")\\n _run_uncrustify(uncrustify_cfg, relpaths)\\n\\n ctx = repo[None]\\n for path in paths:\\n relpath = repo.pathto(path)\\n uncr_path = path + SUFFIX\\n uncr_relpath = relpath + SUFFIX\\n have_changes = (ctx[path].data() != ctx[uncr_path].data())\\n\\n if have_changes:\\n if mode == \\\"status\\\":\\n ui.write(\\\"M %s\\\\n\\\" % relpath, label=\\\"status.modified\\\")\\n util.unlink(uncr_relpath)\\n elif mode == \\\"diff\\\":\\n _run_diff(relpath, uncr_relpath)\\n util.unlink(uncr_relpath)\\n elif mode == \\\"modify\\\":\\n if not no_backup:\\n util.rename(relpath, relpath + \\\".crusty\\\")\\n util.rename(uncr_relpath, relpath)\\n if not ui.quiet:\\n ui.write(\\\"%s uncrustified\\\\n\\\" % relpath)\\n else:\\n if show_clean:\\n if mode == \\\"status\\\":\\n ui.write(\\\"C %s\\\\n\\\" % relpath, label=\\\"status.clean\\\")\\n elif mode == \\\"modify\\\":\\n ui.write(\\\"%s is clean\\\\n\\\" % relpath)\\n util.unlink(uncr_relpath)\",\n \"def test_cherrypick_adds_file(repository: Repository, path: Path) -> None:\\n main = repository.head\\n branch = repository.heads.create(\\\"branch\\\")\\n\\n repository.checkout(branch)\\n updatefile(path)\\n\\n repository.checkout(main)\\n assert not path.is_file()\\n\\n repository.cherrypick(branch.commit)\\n assert path.is_file()\",\n \"def add_uppers():\\n for filename, requirements in _sync():\\n LOG.info(\\\"Obtaining latest versions of packages for %s.\\\", filename)\\n for req in requirements:\\n if isinstance(req, Requirement):\\n if isinstance(req.version, dict) and not req.version[\\\"max\\\"]:\\n req.sync_max_version_with_pypy()\\n _write_requirements(filename, requirements)\",\n \"def generatePlans(update):\\n out.header(\\\"%r\\\\n\\\" % (update))\\n \\n # Make sure we need to create this chute (does it already exist)\\n # TODO\\n\\n# # Check if the chute is new\\n# # if(not old):\\n# # convert cpu cgroups and add to lxcconfig (cached, key: 'cpuConfig')\\n# chutePlan.addPlans(new, plangraph.RESOURCE_GET_VIRT_CPU, (new.getCpuConfigString, None))\\n# \\n# # convert mem cgroups and add to lxcconfig (cached, key: 'memConfig')\\n# chutePlan.addPlans(new, plangraph.RESOURCE_GET_VIRT_MEM, (new.getMemConfigString, None))\\n\\n# # Generate a config file for wshaper, put in cache (key: 'osResourceConfig')\\n# chutePlan.addPlans(new, plangraph.RESOURCE_GET_OS_CONFIG, (new.getOSResourceConfig, None))\\n\\n# # Make calls to configure the wshaper UCI file\\n# todoPlan = (new.setOSResourceConfig, old)\\n# abtPlan = (new.resetOSResourceConfig, None) \\n# chutePlan.addPlans(new, plangraph.RESOURCE_SET_VIRT_QOS, todoPlan, abtPlan)\\n# \\n# # Once all changes are made into UCI system, reload the wshaper daemon\\n# todoPlan = (osenv.reloadQos, (chuteStor, new, True)) \\n# abtPlan = [(new.resetOSResourceConfig, None), (osenv.reloadQos, (chuteStor, new, False))]\\n# chutePlan.addPlans(new, plangraph.RESOURCE_RELOAD_QOS, todoPlan, abtPlan)\\n\\n return None\",\n \"def generate_project_files(specs_path, dst_path):\\n hm_generator = HookManGenerator(hook_spec_file_path=specs_path)\\n hm_generator.generate_project_files(Path(dst_path))\\n return 0\",\n \"def test_squash_patches_by_name(source_git_repo: git.Repo, dist_git_repo: git.Repo):\\n local_project = flexmock(\\n git_repo=source_git_repo, ref=\\\"HEAD\\\", working_dir=source_git_repo.working_dir\\n )\\n\\n create_commits_to_squash(source_git_repo)\\n\\n patch_generator = PatchGenerator(local_project)\\n patch_list = patch_generator.create_patches(\\n git_ref=\\\"0.1.0\\\", destination=dist_git_repo.working_dir\\n )\\n assert len(patch_list) == 3\\n assert patch_list[1].path == Path(dist_git_repo.working_dir, \\\"distro.patch\\\")\\n assert patch_list[1].name == \\\"distro.patch\\\"\\n assert sorted(dist_git_repo.untracked_files) == [\\n \\\"0001-Add-a-standalone-patch.patch\\\",\\n \\\"0004-Add-another-standalone-patch.patch\\\",\\n \\\"distro.patch\\\",\\n ]\\n patch = Path(dist_git_repo.working_dir, \\\"distro.patch\\\").read_text()\\n assert \\\"+The first commit of the second patch.\\\" in patch\\n assert \\\"+The second commit of the second patch.\\\" in patch\",\n \"def mspatchc_CreatePatchFileEx(jitter, get_str, set_str):\\n ret_ad, args = jitter.func_args_stdcall([\\\"OldFileCount\\\", \\\"OldFileInfoArray\\\", \\\"NewFileName\\\", \\\"PatchFileName\\\", \\\"OptionFlags\\\", \\\"OptionData\\\", \\\"ProgressCallback\\\", \\\"CallbackContext\\\"])\\n raise RuntimeError('API not implemented')\\n jitter.func_ret_stdcall(ret_ad, ret_value)\",\n \"def update_module(cwd, name, conf):\\n target = cwd / name\\n source = conf['source']\\n\\n # Support modules on the local filesystem.\\n if source.startswith('./') or source.startswith('../') or source.startswith('/'):\\n print('Copying {}/{}'.format(cwd, name))\\n # Paths must be relative to the Terrafile directory.\\n source = cwd / source\\n shutil.rmtree(target, ignore_errors=True)\\n shutil.copytree(source, target)\\n return\\n\\n version = conf['version']\\n # Support Terraform Registry sources.\\n if is_valid_registry_source(source):\\n print('Checking {}/{}'.format(cwd, name))\\n source, version = get_source_from_registry(source, version)\\n\\n # add token to the source url if exists\\n if 'GITHUB_TOKEN' in os.environ:\\n source = add_github_token(source, os.getenv('GITHUB_TOKEN'))\\n # Delete the old directory and clone it from scratch.\\n print('Fetching {}'.format(target))\\n shutil.rmtree(target, ignore_errors=True)\\n repo = repository.Repo(path=target, origin=source, version=version)\\n output, returncode = repo.clone()\\n if returncode != 0:\\n sys.stderr.write(bytes.decode(output))\\n sys.exit(returncode)\\n if conf.get(\\\"patches\\\") or conf.get(\\\"patches_file\\\"):\\n quilt = Patch(target, root=cwd)\\n i = 0\\n for i, patch in enumerate(conf.get(\\\"patches\\\", list())):\\n quilt.import_patch(name=f'patch_{i}.patch', content=patch)\\n for i, patch in enumerate(conf.get(\\\"patches_file\\\", list()), start=i+1):\\n quilt.import_patch(name=f'patch_{i}.patch', file_path=patch)\\n status = quilt.push_all()\\n if status != 0:\\n raise SystemError(\\\"Error to push patches\\\")\",\n \"def _patch_pip(obuffer, updates, **options):\\n\\n seen = []\\n\\n def patched_parse_requirements(*args, **kwargs):\\n if not options['no_recursive']:\\n filename = args[0]\\n if filename not in seen:\\n if os.path.isfile(filename):\\n seen.append(filename)\\n buf = StringIO()\\n _internal_update_requirements(\\n buf, updates,\\n input_file=filename,\\n output_file=options['output_file'],\\n force=options['force'],\\n interactive=options['interactive'],\\n skip=options['skip'],\\n only=options['only'],\\n minor=options['minor'],\\n patch=options['patch'],\\n pre=options['pre'],\\n dry_run=options['dry_run'],\\n no_recursive=options['no_recursive'],\\n echo=options['echo'],\\n index_urls=options['index_urls'],\\n verify=options['verify'],\\n )\\n if not options['dry_run']:\\n if options['output_file']:\\n obuffer.write(buf.getvalue())\\n else:\\n with open(filename, 'w') as output:\\n output.write(buf.getvalue())\\n buf.close()\\n return []\\n req_file.parse_requirements = patched_parse_requirements\",\n \"def test_prereleases(tmp_path_factory: pytest.TempPathFactory) -> None:\\n src, dst = map(tmp_path_factory.mktemp, (\\\"src\\\", \\\"dst\\\"))\\n with local.cwd(src):\\n # Build template in v1.0.0\\n build_file_tree(\\n {\\n \\\"version.txt\\\": \\\"v1.0.0\\\",\\n \\\"[[ _copier_conf.answers_file ]].jinja\\\": \\\"[[_copier_answers|to_nice_yaml]]\\\",\\n \\\"copier.yaml\\\": (\\n f\\\"\\\"\\\"\\\\\\n _envops: {BRACKET_ENVOPS_JSON}\\n _migrations:\\n - version: v1.9\\n before:\\n - [python, -c, \\\"import pathlib; pathlib.Path('v1.9').touch()\\\"]\\n - version: v2.dev0\\n before:\\n - [python, -c, \\\"import pathlib; pathlib.Path('v2.dev0').touch()\\\"]\\n - version: v2.dev2\\n before:\\n - [python, -c, \\\"import pathlib; pathlib.Path('v2.dev2').touch()\\\"]\\n - version: v2.a1\\n before:\\n - [python, -c, \\\"import pathlib; pathlib.Path('v2.a1').touch()\\\"]\\n - version: v2.a2\\n before:\\n - [python, -c, \\\"import pathlib; pathlib.Path('v2.a2').touch()\\\"]\\n \\\"\\\"\\\"\\n ),\\n }\\n )\\n git(\\\"init\\\")\\n git(\\\"add\\\", \\\".\\\")\\n git(\\\"commit\\\", \\\"-mv1\\\")\\n git(\\\"tag\\\", \\\"v1.0.0\\\")\\n # Evolve template to v2.0.0.dev1\\n build_file_tree({\\\"version.txt\\\": \\\"v2.0.0.dev1\\\"})\\n git(\\\"commit\\\", \\\"-amv2dev1\\\")\\n git(\\\"tag\\\", \\\"v2.0.0.dev1\\\")\\n # Evolve template to v2.0.0.alpha1\\n build_file_tree({\\\"version.txt\\\": \\\"v2.0.0.alpha1\\\"})\\n git(\\\"commit\\\", \\\"-amv2a1\\\")\\n git(\\\"tag\\\", \\\"v2.0.0.alpha1\\\")\\n # Copying with use_prereleases=False copies v1\\n run_copy(src_path=str(src), dst_path=dst, defaults=True, overwrite=True)\\n answers = yaml.safe_load((dst / \\\".copier-answers.yml\\\").read_text())\\n assert answers[\\\"_commit\\\"] == \\\"v1.0.0\\\"\\n assert (dst / \\\"version.txt\\\").read_text() == \\\"v1.0.0\\\"\\n assert not (dst / \\\"v1.9\\\").exists()\\n assert not (dst / \\\"v2.dev0\\\").exists()\\n assert not (dst / \\\"v2.dev2\\\").exists()\\n assert not (dst / \\\"v2.a1\\\").exists()\\n assert not (dst / \\\"v2.a2\\\").exists()\\n with local.cwd(dst):\\n # Commit subproject\\n git(\\\"init\\\")\\n git(\\\"add\\\", \\\".\\\")\\n git(\\\"commit\\\", \\\"-mv1\\\")\\n # Update it without prereleases; nothing changes\\n run_update(defaults=True, overwrite=True)\\n assert not git(\\\"status\\\", \\\"--porcelain\\\")\\n assert not (dst / \\\"v1.9\\\").exists()\\n assert not (dst / \\\"v2.dev0\\\").exists()\\n assert not (dst / \\\"v2.dev2\\\").exists()\\n assert not (dst / \\\"v2.a1\\\").exists()\\n assert not (dst / \\\"v2.a2\\\").exists()\\n # Update it with prereleases\\n run_update(\\n dst_path=dst, defaults=True, overwrite=True, use_prereleases=True, unsafe=True\\n )\\n answers = yaml.safe_load((dst / \\\".copier-answers.yml\\\").read_text())\\n assert answers[\\\"_commit\\\"] == \\\"v2.0.0.alpha1\\\"\\n assert (dst / \\\"version.txt\\\").read_text() == \\\"v2.0.0.alpha1\\\"\\n assert (dst / \\\"v1.9\\\").exists()\\n assert (dst / \\\"v2.dev0\\\").exists()\\n assert (dst / \\\"v2.dev2\\\").exists()\\n assert (dst / \\\"v2.a1\\\").exists()\\n assert not (dst / \\\"v2.a2\\\").exists()\\n # It should fail if downgrading\\n with pytest.raises(UserMessageError):\\n run_update(dst_path=dst, defaults=True, overwrite=True)\",\n \"def gen_buildrequests(self, daemon, repository, dist, suite_option):\\n # Extra check on all DSC/source package files\\n # - Check md5 against possible pool files.\\n # - Add missing from pool (i.e., orig.tar.gz).\\n # - make sure all files from dsc are actually available\\n files_from_pool = []\\n with open(self.dsc_file_name) as dsc_file:\\n dsc = debian.deb822.Dsc(dsc_file)\\n\\n for f in dsc[\\\"Files\\\"]:\\n in_changes = f[\\\"name\\\"] in self.get_files(key=\\\"name\\\")\\n from_pool = False\\n for p in glob.glob(os.path.join(repository.mbd_get_path(), \\\"pool\\\", \\\"*\\\", \\\"*\\\", self[\\\"Source\\\"], f[\\\"name\\\"])):\\n if f[\\\"md5sum\\\"] == mini_buildd.misc.md5_of_file(p):\\n if not in_changes:\\n files_from_pool.append(p)\\n from_pool = True\\n LOG.info(\\\"Buildrequest: File added from pool: {f}\\\".format(f=p))\\n else:\\n raise Exception(\\\"MD5 mismatch in uploaded dsc vs. pool: {f}\\\".format(f=f[\\\"name\\\"]))\\n\\n # Check that this file is available\\n if not in_changes and not from_pool:\\n raise Exception(\\\"Missing file '{f}' neither in upload, nor in pool (use '-sa' for uploads with new upstream)\\\".format(f=f[\\\"name\\\"]))\\n\\n breq_dict = {}\\n for ao in dist.architectureoption_set.all():\\n path = os.path.join(self.get_spool_dir(), ao.architecture.name)\\n\\n breq = Changes(os.path.join(path,\\n self.gen_file_name(ao.architecture.name, self.TYPE_BREQ)))\\n\\n if breq.is_new():\\n distribution = mini_buildd.misc.Distribution(mini_buildd.models.repository.map_incoming_distribution(self[\\\"Distribution\\\"]))\\n breq[\\\"Distribution\\\"] = distribution.get()\\n for v in [\\\"Source\\\", \\\"Version\\\"]:\\n breq[v] = self[v]\\n\\n # Generate files\\n chroot_setup_script = os.path.join(path, \\\"chroot_setup_script\\\")\\n with mini_buildd.misc.open_utf8(os.path.join(path, \\\"apt_sources.list\\\"), \\\"w\\\") as asl, \\\\\\n mini_buildd.misc.open_utf8(os.path.join(path, \\\"apt_preferences\\\"), \\\"w\\\") as ap, \\\\\\n mini_buildd.misc.open_utf8(os.path.join(path, \\\"apt_keys\\\"), \\\"w\\\") as ak, \\\\\\n mini_buildd.misc.open_utf8(os.path.join(path, \\\"ssl_cert\\\"), \\\"w\\\") as ssl_cert, \\\\\\n mini_buildd.misc.open_utf8(chroot_setup_script, \\\"w\\\") as css, \\\\\\n mini_buildd.misc.open_utf8(os.path.join(path, \\\"sbuildrc_snippet\\\"), \\\"w\\\") as src:\\n asl.write(dist.mbd_get_apt_sources_list(repository, suite_option))\\n ap.write(dist.mbd_get_apt_preferences(repository, suite_option, self.options.get(\\\"internal-apt-priority\\\")))\\n ak.write(repository.mbd_get_apt_keys(dist))\\n ssl_cert.write(mini_buildd.config.HTTPD_ENDPOINTS[0].get_certificate())\\n css.write(mini_buildd.misc.fromdos(dist.chroot_setup_script)) # Note: For some reason (python, django sqlite, browser?) the text field may be in DOS mode.\\n os.chmod(chroot_setup_script, stat.S_IRWXU)\\n src.write(dist.mbd_get_sbuildrc_snippet(ao.architecture.name))\\n\\n # Generate tar from original changes\\n self.tar(tar_path=breq.file_path + \\\".tar\\\",\\n add_files=[os.path.join(path, \\\"apt_sources.list\\\"),\\n os.path.join(path, \\\"apt_preferences\\\"),\\n os.path.join(path, \\\"apt_keys\\\"),\\n os.path.join(path, \\\"ssl_cert\\\"),\\n chroot_setup_script,\\n os.path.join(path, \\\"sbuildrc_snippet\\\")] + files_from_pool,\\n exclude_globs=[\\\"*.deb\\\", \\\"*.changes\\\", \\\"*.buildinfo\\\"])\\n breq.add_file(breq.file_path + \\\".tar\\\")\\n\\n breq[\\\"Upload-Result-To\\\"] = daemon.mbd_get_ftp_endpoint().hopo()\\n breq[\\\"Base-Distribution\\\"] = dist.base_source.codename\\n breq[\\\"Architecture\\\"] = ao.architecture.name\\n if ao.build_architecture_all:\\n breq[\\\"Arch-All\\\"] = \\\"Yes\\\"\\n breq[\\\"Build-Dep-Resolver\\\"] = dist.get_build_dep_resolver_display()\\n breq[\\\"Apt-Allow-Unauthenticated\\\"] = \\\"1\\\" if dist.apt_allow_unauthenticated else \\\"0\\\"\\n if dist.lintian_mode != dist.LINTIAN_DISABLED and self.options.get(\\\"run-lintian\\\", alt=ao.architecture.name, default=True):\\n # Generate lintian options\\n modeargs = {\\n dist.LINTIAN_DISABLED: \\\"\\\",\\n dist.LINTIAN_RUN_ONLY: \\\"\\\",\\n dist.LINTIAN_FAIL_ON_ERROR: \\\"\\\",\\n dist.LINTIAN_FAIL_ON_WARNING: \\\"--fail-on-warning\\\"}\\n breq[\\\"Run-Lintian\\\"] = modeargs[dist.lintian_mode] + \\\" \\\" + dist.lintian_extra_options\\n breq[\\\"Deb-Build-Options\\\"] = dist.mbd_get_extra_option(\\\"Deb-Build-Options\\\", \\\"\\\")\\n\\n breq.save(daemon.mbd_gnupg)\\n else:\\n LOG.info(\\\"Re-using existing buildrequest: {b}\\\".format(b=breq.file_name))\\n breq_dict[ao.architecture.name] = breq\\n\\n return breq_dict\",\n \"def test_resetcherrypick_restores_files_with_conflicts(\\n repository: Repository, path: Path\\n) -> None:\\n createconflict(repository, path, ours=\\\"a\\\", theirs=\\\"b\\\")\\n repository.resetcherrypick()\\n\\n assert path.read_text() == \\\"a\\\"\",\n \"def applyPatch(self, fileName, patchdepth, unusedSrcDir=None):\\n craftDebug.trace(\\\"HgSource.applyPatches called\\\")\\n if fileName and self.enableHg:\\n patchfile = os.path.join(self.packageDir(), fileName)\\n os.chdir(self.sourceDir())\\n return self.system('\\\"%s\\\" import -p %s \\\"%s\\\"' % (self.hgExecutable, patchdepth, patchfile))\\n return True\",\n \"def rewrite(self):\\n for f in self.files:\\n metadata = dict()\\n metadata[\\\"description\\\"] = f.metadata.get(\\\"desc\\\", \\\"Unknown\\\")\\n metadata[\\\"script\\\"] = os.path.basename(f.filename)\\n metadata[\\\"requires\\\"] = []\\n for package, component in f.requires:\\n if package == self.key:\\n metadata[\\\"requires\\\"].append(\\\"/\\\" + component)\\n else:\\n metadata[\\\"requires\\\"].append(package + \\\"/\\\" + component)\\n metadata[\\\"provides\\\"] = [ p[1] for p in f.provides ]\\n # Resolve symlinks\\n real_filename = os.path.realpath(f.filename)\\n LOG.info(\\\"Editing: \\\" + real_filename)\\n new_filename = f.filename + \\\".new\\\"\\n new = file(new_filename, \\\"w\\\")\\n new.write(\\\"/*\\\\n---\\\\n\\\")\\n new.write(yaml.dump(metadata))\\n new.write(\\\"\\\\n...\\\\n*/\\\\n\\\")\\n new.write(file(f.filename).read())\\n new.close()\\n os.rename(new_filename, real_filename)\\n\\n package_data = dict()\\n package_data[\\\"name\\\"] = self.key\\n package_data[\\\"sources\\\"] = []\\n package_data[\\\"version\\\"] = \\\"Unknown\\\"\\n package_data[\\\"copyright\\\"] = \\\"Unknown\\\"\\n package_data[\\\"description\\\"] = \\\"Unknown\\\"\\n target_dir = os.path.dirname(self.scripts_json_filename)\\n # package.yml is typically in the parent of the scripts.json dir\\n if os.path.basename(target_dir) == \\\"Source\\\":\\n target_dir = os.path.dirname(target_dir)\\n target_filename = os.path.join(target_dir, \\\"package.yml\\\")\\n for f in self.files:\\n common = os.path.commonprefix([target_filename, f.filename])\\n source_file = f.filename[len(common):]\\n package_data[\\\"sources\\\"].append(source_file)\\n LOG.info(\\\"Writing: \\\" + target_filename)\\n out = file(target_filename, \\\"w\\\")\\n out.write(yaml.dump(package_data))\\n out.close()\",\n \"def update_openblock():\\n\\n tf = tempfile.mktemp(suffix='-openblock')\\n local('git clone git://github.com/openplans/openblock.git {0}'.format(tf))\\n dest = os.path.join(PROJECT_ROOT, 'requirements', 'sdists')\\n for name in ('obadmin', 'ebdata', 'ebpub'):\\n package = os.path.join(tf, name)\\n os.chdir(package)\\n local('pip install -e {source} -d {dest}'.format(source=package,\\n dest=dest))\\n shutil.rmtree(tf)\",\n \"def compress_feats(self):\\n mkpath(os.path.join(self.base_update_path,'comp_features'))\\n mkpath(os.path.join(self.base_update_path,'comp_idx'))\\n args = [self.base_update_path+'/', str(self.features_dim), '1', self.master_update_file, str(self.bits_num)]\\n subprocess_command = [self.hashing_execpath+\\\"compress_feats\\\"] + args\\n # this will work only if features to be compressed are present in self.base_update_path/features\\n proc = subprocess.Popen(subprocess_command, stdout=subprocess.PIPE)\\n print \\\"[HasherSwig.compress_feats: log] running command: {}\\\".format(subprocess_command)\\n (out, err) = proc.communicate()\\n print \\\"[HasherSwig.compress_feats: log] program output:\\\", out\\n print \\\"[HasherSwig.compress_feats: log] program error:\\\", err\",\n \"def generate_patch_build(self, domain):\\n # TODO change name of def\\n base_path = self.paths[\\\"api_doc_dir\\\"]\\n self.generate_apidoc_patches()\\n from django_swagger_utils.apidoc_gen.generators.patch_generator import PatchGenerator\\n patch_generator = PatchGenerator(self.app_name, self.parser, self.paths, base_path)\\n patch_generator.filter_for_deleted_apis()\\n\\n process = subprocess.Popen(['which', 'apidoc'], stdout=subprocess.PIPE)\\n\\n output = process.communicate()[0]\\n if output:\\n\\n with open(self.paths[\\\"base_dir\\\"] + \\\"/apidoc.json\\\", 'w') as outfile:\\n apidoc_content = {\\\"url\\\": \\\"https://ib-backend-dev.apigateway.in\\\",\\n \\\"version\\\": \\\"0.0.1\\\",\\n \\\"description\\\": \\\"\\\",\\n \\\"name\\\": \\\"iBHubs_backend API Documentation\\\",\\n \\\"title\\\": \\\"iBHubs_backend Documenation\\\"}\\n json.dump(apidoc_content, outfile, indent=4)\\n # by default we assume user is working at no specific branch so we fix\\n # url to default above url as above , then we check if any specific parametr is given\\n # and replace url with required url\\n if domain != '' and domain:\\n with open(self.paths[\\\"apidoc\\\"]) as src_json:\\n apidoc_content = json.load(src_json)\\n apidoc_content['url'] = \\\"https://\\\" + domain\\n with open(self.paths[\\\"apidoc\\\"], 'w') as outfile:\\n json.dump(apidoc_content, outfile, indent=4)\\n try:\\n os.mkdir(\\\"docs\\\")\\n except OSError:\\n pass\\n # the below command is responsible for creating docs\\n process = subprocess.Popen(['apidoc', '-i', self.base_dir,\\n '-o', os.path.join(self.base_dir, 'docs'),\\n '-e', 'django_swagger_utils/*',\\n '-e', 'static/*',\\n ], stdout=subprocess.PIPE)\\n print process.communicate()[0]\\n ################################################\\n # hosting apidoc\\n ################################################\\n # obtaining the path of static folder of django-swagger-utils\\n # django_swagger_utils_path = os.path.abspath(os.path.join(os.path.dirname(__file__), \\\"../..\\\"))\\n # static_folder_path = os.path.join(django_swagger_utils_path, \\\"static\\\")\\n # import shutil\\n # # create a folder apidoc , delete if previously exists\\n # if os.path.exists(os.path.join(static_folder_path, \\\"apidoc\\\")):\\n # shutil.rmtree(os.path.join(static_folder_path, \\\"apidoc\\\"))\\n # apidoc_path = os.path.join(static_folder_path, \\\"apidoc\\\")\\n #\\n # os.mkdir(apidoc_path)\\n\\n # from distutils.dir_util import copy_tree\\n # copydocs from docs to apidoc in swagger utils\\n # try:\\n # copy_tree(os.path.join(self.base_dir, 'docs'), apidoc_path)\\n # except Exception as err:\\n # print err\\n\\n # browse to localhost:<port>/static/apidoc/index.html\\n\\n else:\\n raise CommandError(\\\"Help: Install apidoc: [ sudo npm install -g apidoc ]\\\")\",\n \"def apply_patches(ctx, patches, branch, die_on_fail=True):\\n ctx.runprocess(['git', 'checkout',\\n '%s/%s' % (ctx.config['remote'], branch)])\\n for patch in patches:\\n print('Applying to %s: %s' % (branch, patch.subject))\\n res = ctx.runprocess(\\n ['git', 'am', '--3way'],\\n stdin_string=''.join(patch.lines),\\n check_returncode=0 if die_on_fail else None,\\n )\\n if not die_on_fail and res.returncode:\\n raise RuntimeError(res.stderr)\\n sha1 = ctx.runprocess(['git', 'rev-parse', 'HEAD']).stdout.strip()\\n if ctx.verbosity:\\n print('Resulting hash: %s' % sha1)\\n return sha1\",\n \"def test_cherrypick_simple(self):\\n import evoware.fileutil as F\\n \\n options = {'i': F.testRoot('targetlist_PCR.xls'), \\n 'src': [F.testRoot('primers.xls'), \\n F.testRoot('partslist_simple.xls')],\\n 'o': 'cherrypicking_simple.gwl',\\n 'p': self.f_project,\\n 'columns' : ['primer1', 'primer2', 'template']\\n }\\n self.generictest(options)\",\n \"def do_base_setup(run_as_user, branch, base_path, dist_path):\\n #install some necessary base deps\\n runcmd(\\\"apt-get update\\\")\\n runcmd(\\\"apt-get -y install git-core software-properties-common python-software-properties build-essential ssl-cert\\\")\\n runcmd(\\\"apt-get update\\\")\\n #node-gyp building for insight has ...issues out of the box on Ubuntu... use Chris Lea's nodejs build instead, which is newer\\n runcmd(\\\"apt-get -y remove nodejs npm gyp\\\")\\n runcmd(\\\"add-apt-repository -y ppa:chris-lea/node.js\\\")\\n runcmd(\\\"apt-get update\\\")\\n runcmd(\\\"apt-get -y install nodejs\\\") #includes npm\\n\\n #Create xcp user (to run bitcoind, counterpartyd, counterblockd) if not already made\\n try:\\n pwd.getpwnam(USERNAME)\\n except:\\n logging.info(\\\"Creating user '%s' ...\\\" % USERNAME)\\n runcmd(\\\"adduser --system --disabled-password --shell /bin/bash --group %s\\\" % USERNAME)\\n \\n #add the run_as_user to the xcp group\\n runcmd(\\\"adduser %s %s\\\" % (run_as_user, USERNAME))\\n \\n #Check out counterpartyd-build repo under this user's home dir and use that for the build\\n git_repo_clone(branch, \\\"counterpartyd_build\\\", \\\"https://github.com/CounterpartyXCP/counterpartyd_build.git\\\", run_as_user)\",\n \"def generate_patches(self):\\n sets = os.listdir(self.__data_dir)\\n import re\\n sets = [a_set for a_set in sets if re.match(r'[0-9a-zA-Z_]+', a_set)]\\n total = len(sets)\\n count = 1\\n for a_set in sets:\\n print('\\\\r', 'slicing {0}/{1}'.format(count, total).ljust(20), end='')\\n self.__generate_slices_a_set(a_set)\\n count += 1\",\n \"def update(\\n project_dir: Path = Path(\\\".\\\"),\\n cookiecutter_input: bool = False,\\n skip_apply_ask: bool = True,\\n skip_update: bool = False,\\n checkout: Optional[str] = None,\\n strict: bool = True,\\n) -> bool:\\n pyproject_file = project_dir / \\\"pyproject.toml\\\"\\n cruft_file = get_cruft_file(project_dir)\\n\\n # If the project dir is a git repository, we ensure\\n # that the user has a clean working directory before proceeding.\\n if not _is_project_repo_clean(project_dir):\\n typer.secho(\\n \\\"Cruft cannot apply updates on an unclean git project.\\\"\\n \\\" Please make sure your git working tree is clean before proceeding.\\\",\\n fg=typer.colors.RED,\\n )\\n return False\\n\\n cruft_state = json.loads(cruft_file.read_text())\\n\\n with TemporaryDirectory() as compare_directory_str:\\n # Initial setup\\n compare_directory = Path(compare_directory_str)\\n template_dir = compare_directory / \\\"template\\\"\\n repo = get_cookiecutter_repo(cruft_state[\\\"template\\\"], template_dir, checkout)\\n directory = cruft_state.get(\\\"directory\\\", None)\\n if directory:\\n template_dir = template_dir / directory\\n last_commit = repo.head.object.hexsha\\n\\n # Bail early if the repo is already up to date\\n if is_project_updated(repo, cruft_state[\\\"commit\\\"], last_commit, strict):\\n typer.secho(\\n \\\"Nothing to do, project's cruft is already up to date!\\\", fg=typer.colors.GREEN\\n )\\n return True\\n\\n # Generate clean outputs via the cookiecutter\\n # from the current cruft state commit of the cookiectter and the updated\\n # cookiecutter.\\n old_main_directory, new_main_directory, new_context = _generate_project_updates(\\n compare_directory, cruft_state, template_dir, cookiecutter_input, repo\\n )\\n\\n # Get all paths that we are supposed to skip before generating the diff and applying updates\\n skip_paths = _get_skip_paths(cruft_state, pyproject_file)\\n # We also get the list of paths that were deleted from the project\\n # directory but were present in the template that the project is linked against\\n # This is to avoid introducing changes that won't apply cleanly to the current project.\\n deleted_paths = _get_deleted_files(old_main_directory, project_dir)\\n # We now remove both the skipped and deleted paths from the new and old project\\n _remove_paths(old_main_directory, new_main_directory, skip_paths | deleted_paths)\\n # Given the two versions of the cookiecutter outputs based\\n # on the current project's context we calculate the diff and\\n # apply the updates to the current project.\\n if _apply_project_updates(\\n old_main_directory, new_main_directory, project_dir, skip_update, skip_apply_ask\\n ):\\n\\n # Update the cruft state and dump the new state\\n # to the cruft file\\n cruft_state[\\\"commit\\\"] = last_commit\\n cruft_state[\\\"context\\\"] = new_context\\n cruft_state[\\\"directory\\\"] = directory\\n cruft_file.write_text(json_dumps(cruft_state))\\n typer.secho(\\n \\\"Good work! Project's cruft has been updated and is as clean as possible!\\\",\\n fg=typer.colors.GREEN,\\n )\\n return True\",\n \"def check_patch_files(version, cfg):\\n\\n logger = logging.getLogger('check_patch_files')\\n\\n # Patches should live in /srv/patches/[version]\\n patch_path = cfg['patch_path']\\n if patch_path is None:\\n return\\n\\n version_base = os.path.join(patch_path, version)\\n\\n ext_dir = os.path.join(version_base, 'extensions')\\n _, extensions, _ = os.walk(ext_dir).next()\\n\\n patches = utils.get_patches(['core'], version_base)\\n patches.update(utils.get_patches(extensions, ext_dir))\\n\\n git_patch_check = ['/usr/bin/git', 'apply', '--check', '--reverse']\\n version_dir = 'php-{}'.format(version)\\n apply_dir = os.path.join(cfg['stage_dir'], version_dir)\\n\\n for extension, diffs in patches.iteritems():\\n diff = '\\\\n'.join(diffs)\\n\\n if extension != 'core':\\n apply_dir = os.path.join(apply_dir, 'extensions', extension)\\n\\n with utils.cd(apply_dir):\\n p = subprocess.Popen(\\n git_patch_check, stdin=subprocess.PIPE, stdout=subprocess.PIPE)\\n\\n p.communicate(diff)\\n\\n if p.returncode > 0:\\n logger.warn(\\n 'Patch(s) for {} have not been applied.'.format(apply_dir))\",\n \"def main():\\n # top-level parser\\n parser = argparse.ArgumentParser(description=\\\"sinkhole\\\")\\n parser.add_argument(\\\"--revision\\\", action=\\\"store\\\")\\n parser.add_argument(\\\"--config\\\", action=\\\"store\\\", required=True)\\n subparsers = parser.add_subparsers(dest=\\\"subcommand\\\")\\n subparsers.required = True\\n\\n # reposync\\n parser_reposync = subparsers.add_parser(\\\"reposync\\\",\\n help=\\\"Sync repositories\\\")\\n parser_reposync.add_argument(\\\"--destdir\\\", action=\\\"store\\\", required=True)\\n parser_reposync.add_argument(\\\"--repofile\\\", action=\\\"append\\\", dest=\\\"repofns\\\",\\n required=True)\\n parser_reposync.add_argument(\\\"--include\\\", action=\\\"append\\\", default=None)\\n parser_reposync.add_argument(\\\"--exclude\\\", action=\\\"append\\\", default=None)\\n\\n # kojidownload\\n parser_koji = subparsers.add_parser(\\\"kojidownload\\\",\\n help=\\\"Download builds from Koji\\\")\\n parser_koji.add_argument(\\\"--profile\\\", action=\\\"store\\\", default=\\\"koji\\\",\\n help=\\\"Koji instance to retrieve builds from\\\")\\n parser_koji.add_argument(\\\"--arch\\\", action=\\\"store\\\", nargs=\\\"+\\\",\\n default=None)\\n parser_koji.add_argument(\\\"--builds\\\", action=\\\"store\\\", nargs=\\\"+\\\",\\n required=True)\\n parser_koji.add_argument(\\\"--destdir\\\", action=\\\"store\\\", required=True)\\n\\n # config_file\\n parser_config = subparsers.add_parser(\\\"config_file\\\",\\n help=\\\"Use config file\\\")\\n\\n # Run appropriate command\\n args = parser.parse_args()\\n\\n config = Config.read_config(args.config) if args.config else Config()\\n\\n if args.subcommand == \\\"reposync\\\":\\n config.output_dir = args.destdir\\n reposync = Reposync(args.repofns, args.include, args.exclude)\\n reposync.run()\\n elif args.subcommand == \\\"kojidownload\\\":\\n config.output_dir = args.destdir\\n kojid = KojiDownloader(args.profile, args.builds, args.arch)\\n kojid.run()\\n else:\\n sources = SourceBuilder.build()\\n for source in sources:\\n source.run()\\n rm = RepoMasher(config.output_dir, revision=args.revision)\\n rm.run()\",\n \"def patches(*args):\\n with cros_build_lib.ContextManagerStack() as stack:\\n for arg in args:\\n stack.Add(lambda ret=arg: ret)\\n yield\",\n \"def generate(repo_dir, context, update):\\n\\n result = generate_files(\\n repo_dir=repo_dir,\\n context=context,\\n overwrite_if_exists=update,\\n skip_if_file_exists=not update,\\n output_dir='.',\\n )\\n return result\",\n \"def do_base_setup(run_as_user, branch, base_path, dist_path):\\n #change time to UTC\\n runcmd(\\\"ln -sf /usr/share/zoneinfo/UTC /etc/localtime\\\")\\n\\n #install some necessary base deps\\n runcmd(\\\"apt-get update\\\")\\n runcmd(\\\"apt-get -y install git-core software-properties-common python-software-properties build-essential ssl-cert ntp runit\\\")\\n \\n #install node-js\\n #node-gyp building has ...issues out of the box on Ubuntu... use Chris Lea's nodejs build instead, which is newer\\n runcmd(\\\"apt-get -y remove nodejs npm gyp\\\")\\n runcmd(\\\"add-apt-repository -y ppa:chris-lea/node.js\\\")\\n runcmd(\\\"apt-get update\\\")\\n runcmd(\\\"apt-get -y install nodejs\\\") #includes npm\\n gypdir = None\\n try:\\n import gyp\\n gypdir = os.path.dirname(gyp.__file__)\\n except:\\n pass\\n else:\\n runcmd(\\\"mv %s %s_bkup\\\" % (gypdir, gypdir))\\n #^ fix for https://github.com/TooTallNate/node-gyp/issues/363\\n\\n #Create xcp user, under which the files will be stored, and who will own the files, etc\\n try:\\n pwd.getpwnam(USERNAME)\\n except:\\n logging.info(\\\"Creating user '%s' ...\\\" % USERNAME)\\n runcmd(\\\"adduser --system --disabled-password --shell /bin/false --group %s\\\" % USERNAME)\\n \\n #Create xcpd user (to run counterpartyd, counterblockd, insight, bitcoind, nginx) if not already made\\n try:\\n pwd.getpwnam(DAEMON_USERNAME)\\n except:\\n logging.info(\\\"Creating user '%s' ...\\\" % DAEMON_USERNAME)\\n runcmd(\\\"adduser --system --disabled-password --shell /bin/false --ingroup nogroup --home %s %s\\\" % (USER_HOMEDIR, DAEMON_USERNAME))\\n \\n #add the run_as_user to the xcp group\\n runcmd(\\\"adduser %s %s\\\" % (run_as_user, USERNAME))\\n \\n #Check out counterpartyd-build repo under this user's home dir and use that for the build\\n git_repo_clone(\\\"counterpartyd_build\\\", \\\"https://github.com/CounterpartyXCP/counterpartyd_build.git\\\",\\n os.path.join(USER_HOMEDIR, \\\"counterpartyd_build\\\"), branch, for_user=run_as_user)\\n\\n #enhance fd limits for the xcpd user\\n runcmd(\\\"cp -af %s/linux/other/xcpd_security_limits.conf /etc/security/limits.d/\\\" % dist_path)\",\n \"def main():\\n parser = argparse.ArgumentParser(description='Create packaged set of modulefiles for deployment on OASIS.')\\n parser.add_argument('--location', dest='location', default=None,\\n help='Location directory to place files in')\\n parser.add_argument('--tarfile', dest='tarfile', default=None,\\n help='Name of tarfile to generate')\\n args = parser.parse_args(sys.argv[1:])\\n if args.location is None:\\n args.location = tempfile.mkdtemp()\\n elif os.path.exists(args.location):\\n overwrite = raw_input(\\\"{0} exists, overwrite? \\\".format(args.location))\\n if overwrite.lower().strip() != 'y':\\n sys.stderr.write(\\\"Exiting...\\\")\\n sys.exit(0)\\n shutil.rmtree(args.location)\\n os.mkdir(args.location)\\n else:\\n os.mkdir(args.location)\\n location = checkout_repo(args.location) \\n if location is None:\\n sys.stderr.write(\\\"Can't checkout modulefiles to {0}!\\\\n\\\".format(args.location))\\n package_files(location)\\n if args.tarfile is None:\\n args.tarfile = \\\"/tmp/moduleupdate.tar.gz\\\"\\n if tar_files(location, args.tarfile) is None:\\n sys.stderr.write(\\\"Error generating tarfile, exiting\\\\n\\\")\\n sys.exit(1)\\n shutil.rmtree(location)\\n sys.stdout.write(\\\"Packaged files located at {0}\\\\n\\\".format(args.tarfile))\",\n \"def applyPatch(self, fileName, patchdepth, unusedSrcDir=None):\\n CraftCore.debug.trace(\\\"GitSource \\\")\\n patchfile = self.packageDir() / fileName\\n if os.path.isdir(patchfile):\\n # apply a whole dir of patches\\n out = True\\n with os.scandir(patchfile) as scan:\\n for patch in scan:\\n if patch.is_file() and not patch.name.startswith(\\\".\\\"):\\n out = self.applyPatch(patchfile / patch, patchdepth=patchdepth) and out\\n return out\\n return self.__git(\\n \\\"apply\\\",\\n [\\\"--ignore-space-change\\\", \\\"-p\\\", str(patchdepth), patchfile],\\n logCommand=True,\\n )\",\n \"def update_role_files(**kwargs):\\n\\n # Finds out which tracking branch you are on\\n # Generates a commit in OA and each of its roles\\n # Generates a git show output\\n # Asks before triggering git review\\n\\n # Example commit message\\n # Update all SHAs for 15.1.8\\n # This patch updates all the roles to the latest available stable\\n # SHA's, copies the release notes from the updated roles into the\\n # integrated repo, updates all the OpenStack Service SHA's, and\\n # updates the appropriate python requirements pins.\\n click.echo(\\\"Not implemented yet\\\")\",\n \"def tarball(request):\\n\\n patches = (models.Patch\\n .query(models.Patch.patchset_key == request.patchset.key)\\n .order(models.Patch.filename)\\n .fetch(1000))\\n\\n temp = tempfile.TemporaryFile()\\n tar = tarfile.open(mode=\\\"w|bz2\\\", fileobj=temp)\\n\\n def add_entry(prefix, content):\\n data = content.data\\n if data is None:\\n data = content.text\\n if isinstance(data, unicode):\\n data = data.encode(\\\"utf-8\\\", \\\"replace\\\")\\n if data is None:\\n return\\n info = tarfile.TarInfo(prefix + patch.filename)\\n info.size = len(data)\\n # TODO(adonovan): set SYMTYPE/0755 when Rietveld supports symlinks.\\n info.type = tarfile.REGTYPE\\n info.mode = 0644\\n # datetime->time_t\\n delta = request.patchset.modified - datetime.datetime(1970, 1, 1)\\n info.mtime = int(delta.days * 86400 + delta.seconds)\\n tar.addfile(info, fileobj=StringIO(data))\\n\\n for patch in patches:\\n if not patch.no_base_file:\\n try:\\n add_entry('a/', patch.get_content()) # before\\n except FetchError: # I/O problem?\\n logging.exception('tarball: patch(%s, %s).get_content failed' %\\n (patch.key.id(), patch.filename))\\n try:\\n add_entry('b/', patch.get_patched_content()) # after\\n except FetchError: # file deletion? I/O problem?\\n logging.exception('tarball: patch(%s, %s).get_patched_content failed' %\\n (patch.key.id(), patch.filename))\\n\\n tar.close()\\n temp.flush()\\n\\n wrapper = FileWrapper(temp)\\n response = HttpResponse(wrapper, mimetype='application/x-gtar')\\n response['Content-Disposition'] = (\\n 'attachment; filename=patch%s_%s.tar.bz2' % (request.issue.key.id(),\\n request.patchset.key.id()))\\n response['Content-Length'] = temp.tell()\\n temp.seek(0)\\n return response\",\n \"def patch_arr_pm(self):\\n self._copyin('build_scripts/file.rb',\\n '/usr/lib/ruby/gems/1.8/gems/arr-pm-0.0.7/lib/arr-pm/file.rb')\\n self._copyin('build_scripts/rpm.rb',\\n '/usr/lib/ruby/gems/1.8/gems/fpm-0.4.24/lib/fpm/package/rpm.rb')\",\n \"def main(args):\\n write_files = args.no_write is False\\n ffiles = _open(args)\\n ffiles = update_bpms(ffiles)\\n if write_files:\\n _write_files(ffiles, args.prefix, args.clobber)\\n\\n return\",\n \"def test_pnictogen():\\n for template in templates:\\n template_prefix, extension = os.path.splitext(template)\\n for xyz_file in example_xyz_files:\\n input_prefix, xyz_file_extension = os.path.splitext(xyz_file)\\n\\n mol = Atoms(\\n cclib.bridge.cclib2openbabel.readfile(xyz_file, xyz_file_extension[1:])\\n )\\n written_files = pnictogen(mol, input_prefix, template, extension[1:])\\n\\n assert_equals(type(written_files), list)\\n for written_file in written_files:\\n assert_equals(type(written_file), str)\\n\\n written_files2 = pnictogen(mol, input_prefix, template)\\n assert_equals(written_files, written_files2)\\n\\n # Allow use of template in the parent directory\\n with cd(\\\"pnictogen/repo\\\"):\\n mol = Atoms(\\n cclib.bridge.cclib2openbabel.readfile(\\\"../../data/water-dimer.xyz\\\", \\\"xyz\\\")\\n )\\n written_files = pnictogen(mol, \\\"../../data/water-dimer\\\", \\\"ADF.in\\\", \\\"in\\\")\\n\\n assert_equals(written_files, [\\\"../../data/water-dimer.in\\\"])\\n\\n main([\\\"-g\\\", \\\"/tmp/hello.world.ORCA.inp\\\"])\\n mol = Atoms(cclib.bridge.cclib2openbabel.readfile(\\\"data/co.xyz\\\", \\\"xyz\\\"))\\n written_files = pnictogen(mol, \\\"data/co\\\", \\\"/tmp/hello.world.ORCA.inp\\\", foo=\\\"bar\\\")\\n\\n assert_equals(written_files, [\\\"data/co.inp\\\"])\",\n \"def pack():\\n clean_local()\\n build()\\n copy_json()\\n optimize()\\n tarball()\",\n \"def main(template_initial_path, template_grown_path, step, total_steps, hydrogen_to_replace, core_atom_linker,\\n tmpl_out_path, null_charges=False, growing_mode=\\\"SoftcoreLike\\\"):\\n lambda_to_reduce = float(step/(total_steps+1))\\n templ_ini = TemplateImpact(template_initial_path)\\n \\n for bond in templ_ini.list_of_bonds:\\n key, bond_cont = bond\\n templ_grw = TemplateImpact(template_grown_path)\\n fragment_atoms, core_atoms_in, core_atoms_grown = detect_atoms(template_initial=templ_ini, \\n template_grown=templ_grw,\\n hydrogen_to_replace=hydrogen_to_replace)\\n set_fragment_atoms(list_of_fragment_atoms=fragment_atoms)\\n set_connecting_atom(template_grown=templ_grw, pdb_atom_name=core_atom_linker)\\n fragment_bonds = detect_fragment_bonds(list_of_fragment_atoms=fragment_atoms, template_grown=templ_grw)\\n set_fragment_bonds(list_of_fragment_bonds=fragment_bonds)\\n set_linker_bond(templ_grw)\\n if growing_mode == \\\"SoftcoreLike\\\":\\n modify_core_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, exp_charges=True,\\n null_charges=null_charges)\\n reduce_fragment_parameters_linearly(templ_grw, lambda_to_reduce, exp_charges=True, \\n null_charges=null_charges)\\n \\n modify_linkers_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, hydrogen_to_replace)\\n elif growing_mode == \\\"AllLinear\\\":\\n modify_core_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, exp_charges=False)\\n reduce_fragment_parameters_linearly(templ_grw, lambda_to_reduce, exp_charges=False,\\n null_charges=False)\\n modify_linkers_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, hydrogen_to_replace)\\n elif growing_mode == \\\"SpreadHcharge\\\":\\n if step > 1:\\n reduce_fragment_parameters_originaly(templ_grw, templ_ini, lambda_to_reduce, \\n hydrogen=hydrogen_to_replace, n_GS=total_steps)\\n modify_linkers_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, hydrogen_to_replace)\\n else:\\n reduce_fragment_parameters_spreading_H(templ_grw, templ_ini, lambda_to_reduce, \\n hydrogen=hydrogen_to_replace, n_GS=total_steps)\\n else:\\n raise ValueError(\\\"Growing mode Not valid. Choose between: 'SoftcoreLike', 'SpreadHcharge', 'AllLinear'.\\\")\\n templ_grw.write_template_to_file(template_new_name=tmpl_out_path)\\n return [atom.pdb_atom_name for atom in fragment_atoms], \\\\\\n [atom.pdb_atom_name for atom in core_atoms_grown]\",\n \"def refresh_cts():\\n local('cd ../../cts-js && grunt')\\n local('cp ../../cts-js/release/cts.js ../static/hotlink/cts.js')\\n local('cd ../../cts-ui && grunt')\\n local('cp ../../cts-ui/release/cts-ui.js ../static/hotlink/cts-ui.js')\\n local('git add ../static/hotlink/cts.js')\\n local('git add ../static/hotlink/cts-ui.js')\\n local('git commit -m \\\"refreshing CTS JS and UI [fabfile]\\\"')\\n local('git push origin master')\",\n \"def _subprocess_pack_charms(\\n charms: Mapping[str, pathlib.Path],\\n command_args: Collection[str],\\n) -> Dict[str, pathlib.Path]:\\n if charms:\\n charm_str = humanize_list(charms.keys(), \\\"and\\\")\\n emit.progress(f\\\"Packing charms: {charm_str}...\\\")\\n cwd = pathlib.Path(os.getcwd()).resolve()\\n generated_charms = {}\\n with tempfile.TemporaryDirectory(prefix=\\\"charmcraft-bundle-\\\", dir=cwd) as temp_dir:\\n temp_dir = pathlib.Path(temp_dir)\\n try:\\n # Put all the charms in this temporary directory.\\n os.chdir(temp_dir)\\n for charm, project_dir in charms.items():\\n full_command = [*command_args, f\\\"--project-dir={project_dir}\\\"]\\n with emit.open_stream(f\\\"Packing charm {charm}...\\\") as stream:\\n subprocess.check_call(full_command, stdout=stream, stderr=stream)\\n duplicate_charms = {}\\n for charm_file in temp_dir.glob(\\\"*.charm\\\"):\\n charm_name = charm_file.name.partition(\\\"_\\\")[0]\\n if charm_name not in charms:\\n emit.debug(f\\\"Unknown charm file generated: {charm_file.name}\\\")\\n continue\\n if charm_name in generated_charms:\\n if charm_name not in duplicate_charms:\\n duplicate_charms[charm_name] = temp_dir.glob(f\\\"{charm_name}_*.charm\\\")\\n continue\\n generated_charms[charm_name] = charm_file\\n if duplicate_charms:\\n raise errors.DuplicateCharmsError(duplicate_charms)\\n for charm, charm_file in generated_charms.items():\\n destination = cwd / charm_file.name\\n destination.unlink(missing_ok=True)\\n generated_charms[charm] = shutil.move(charm_file, destination)\\n finally:\\n os.chdir(cwd)\\n return generated_charms\",\n \"def bump(repo, configsToBump, configsToOverride):\\n # First pass. Bump variables in configsToBump.\\n configs = ['%s/%s' % (repo, x) for x in configsToBump.keys()]\\n cmd = ['python', BUMP_SCRIPT, '--bump-version', '--revision=tip']\\n cmd.extend(configs)\\n run_cmd(cmd)\\n # Second pass. Append override files to configsToBump and\\n # configsToOverride.\\n for config, overrides in \\\\\\n configsToBump.items() + configsToOverride.items():\\n newContent = cat([path.join(repo, config)] +\\n [path.join(repo, x) for x in overrides])\\n fh = open(path.join(repo, config), 'wb')\\n fh.write(newContent)\\n fh.close()\\n run_cmd(['hg', 'commit', '-m', 'Automatic config bump'],\\n cwd=repo)\",\n \"def extract_from_cachedir(self):\\n\\n # Extract the configuration files from each new package into the\\n # etc-tmp branch.\\n master_tracked = self.repo.tracked_files('master-tmp')\\n etc_tracked = self.repo.tracked_files('etc-tmp')\\n packages = self.list_new_packages(self.cache_dir)\\n print('Extracting configuration files from %d new package files' %\\n len(packages), end='')\\n if self.aur_dir is not None:\\n aur_packages = self.list_new_packages(self.aur_dir)\\n print(' and %d new AUR package files' % len(aur_packages))\\n packages = itertools.chain(packages, aur_packages)\\n else:\\n print()\\n self.repo.checkout('etc-tmp')\\n original_files = self.extract(packages, etc_tracked)\\n\\n for rpath in original_files:\\n new = EtcPath(self.repodir, rpath)\\n current = EtcPath(self.root_dir, rpath)\\n if current.digest == b'':\\n path = current.path\\n exists = True\\n try:\\n if not path.exists():\\n exists = False\\n except PermissionError:\\n pass\\n if not exists:\\n # Do not warn on 'create' subcommand to avoid the noise of\\n # all the /etc files removed after packages removal while\\n # their package file is still present in pacman CacheDir.\\n if self.cmd != 'create':\\n warn('skip %s does not exist' % path)\\n else:\\n warn('skip %s not readable' % path)\\n continue\\n\\n # A new package has been installed.\\n if rpath not in etc_tracked:\\n # Add the file to the etc-tmp branch.\\n self.etc_commits.added.rpaths.append(rpath)\\n if new != current:\\n # Case 6.\\n # Add the file name to the list of files to add to the\\n # master-tmp branch (from /etc).\\n self.master_commits.added.rpaths.append(rpath)\\n # A package upgrade.\\n else:\\n if new == current:\\n if new != original_files[rpath]:\\n # Case 2 and 4.\\n # Stage the file in the etc-tmp branch.\\n self.etc_commits.added.rpaths.append(rpath)\\n if rpath in master_tracked:\\n warn('%s should not exist in the master branch'\\n % rpath)\\n else:\\n # Case 1.\\n pass\\n else:\\n # Case 5.\\n # A specific commit is used for the configuration files\\n # whose changes must be cherry-picked into the master\\n # branch.\\n if new != original_files[rpath]:\\n self.etc_commits.cherry_pick.rpaths.append(rpath)\\n else:\\n # Case 3.\\n pass\",\n \"def do_package(package):\\n\\tn_ucr = extFile(package, 'univention-config-registry')\\n\\tif not os.path.exists(n_ucr):\\n\\t\\treturn\\n\\n\\tf_ucr = open(n_ucr, 'r')\\n\\n\\tfor item in univention.config_registry.parseRfc822(f_ucr.read()):\\n\\t\\ttyp = item['Type'][0]\\n\\t\\tif typ == 'file':\\n\\t\\t\\tf = item['File'][0]\\n\\t\\t\\tdoIt('install', '-d', destDir(f, package))\\n\\t\\t\\tdoIt('cp', '-a', srcPath(f), destPath(f, package))\\n\\t\\t\\tfor key in ('Preinst', 'Postinst'):\\n\\t\\t\\t\\tif key in item:\\n\\t\\t\\t\\t\\tmod = item[key][0]\\n\\t\\t\\t\\t\\tdoIt('install', '-d', destDir(mod, package, 'modules'))\\n\\t\\t\\t\\t\\tdoIt('cp', '-a', srcPath(mod), destPath(mod, package, 'modules'))\\n\\t\\telif typ == 'subfile':\\n\\t\\t\\tf = item['Subfile'][0]\\n\\t\\t\\tdoIt('install', '-d', destDir(f, package))\\n\\t\\t\\tdoIt('cp', '-a', srcPath(f), destPath(f, package))\\n\\t\\telif typ == 'multifile':\\n\\t\\t\\tf = item['Multifile'][0]\\n\\t\\t\\tif os.path.exists(f):\\n\\t\\t\\t\\tdoIt('install', '-d', destDir(f, package))\\n\\t\\t\\t\\tdoIt('cp', '-a', srcPath(f), destPath(f, package))\\n\\t\\t\\tfor key in ('Preinst', 'Postinst'):\\n\\t\\t\\t\\tif key in item:\\n\\t\\t\\t\\t\\tmod = item[key][0]\\n\\t\\t\\t\\t\\tdoIt('install', '-d', destDir(mod, package, 'modules'))\\n\\t\\t\\t\\t\\tdoIt('cp', '-a', srcPath(mod), destPath(mod, package, 'modules'))\\n\\t\\telif typ == 'script':\\n\\t\\t\\tf = item['Script'][0]\\n\\t\\t\\tdoIt('install', '-d', destDir(f, package, 'scripts'))\\n\\t\\t\\tdoIt('cp', '-a', srcPath(f), destPath(f, package, 'scripts'))\\n\\t\\t\\tdoIt('chmod', 'a+x', destPath(f, package, 'scripts'))\\n\\t\\telif typ == 'module':\\n\\t\\t\\tf = item['Module'][0]\\n\\t\\t\\tdoIt('install', '-d', destDir(f, package, 'modules'))\\n\\t\\t\\tdoIt('cp', '-a', srcPath(f), destPath(f, package, 'modules'))\\n\\t\\telse:\\n\\t\\t\\tprint >>sys.stderr, 'Unknown type: %s' % typ\\n\\t\\t\\treturn\\n\\n\\tf_ucr.close()\\n\\n\\tdoIt('install', '-d', destDir('', package, 'info'))\\n\\tdoIt('install', '-m644', n_ucr, destPath(package+'.info', package, 'info'))\\n\\tmapping_file = extFile( package, 'univention-config-registry-mapping')\\n\\tif os.path.exists(mapping_file):\\n\\t\\tdoIt('install', '-d', destDir('', package, 'mapping'))\\n\\t\\tdoIt('install', '-m644', mapping_file, destPath(package+'.univention-config-registry-mapping', package, 'mapping'))\\n\\n\\tdata = {\\n\\t\\t\\t'pkg': quote(package),\\n\\t\\t\\t'info': quote(\\\"/etc/univention/templates/info/%s.info\\\" % package),\\n\\t\\t\\t'removed': quote(\\\"/etc/univention/templates/removed/%s.info\\\" % package),\\n\\t\\t\\t}\\n\\n\\tf_preinst = open(extFile(package, 'preinst.debhelper'), 'a')\\n\\tf_preinst.write('# Automatically added by univention-install-config-registry\\\\n')\\n\\tf_preinst.write('if [ \\\"$1\\\" = \\\"install\\\" ] ; then\\\\n')\\n\\tf_preinst.write(' [ -e %(removed)s ] && [ ! -e %(info)s ] && mv %(removed)s %(info)s || true\\\\n' % data)\\n\\tf_preinst.write('fi\\\\n')\\n\\tf_preinst.write('# End automatically added section\\\\n')\\n\\tf_preinst.close()\\n\\n\\tf_postinst = open(extFile(package, 'postinst.debhelper'), 'a')\\n\\tf_postinst.write('# Automatically added by univention-install-config-registry\\\\n')\\n\\tf_postinst.write('if [ \\\"$1\\\" = \\\"abort-remove\\\" ]; then\\\\n')\\n\\tf_postinst.write(' [ -e %(removed)s ] && mv %(removed)s %(info)s || true\\\\n' % data)\\n\\tf_postinst.write('fi\\\\n')\\n\\tf_postinst.write('[ -x /usr/sbin/univention-config-registry ] && univention-config-registry register %(pkg)s || true\\\\n' % data)\\n\\tf_postinst.write('# End automatically added section\\\\n')\\n\\tf_postinst.close()\\n\\n\\tf_prerm = open(extFile(package, 'prerm.debhelper'), 'a')\\n\\tf_prerm.write('# Automatically added by univention-install-config-registry\\\\n')\\n\\tf_prerm.write('if [ \\\"$1\\\" = \\\"remove\\\" ] && [ -e %(info)s ] ; then\\\\n' % data)\\n\\tf_prerm.write(' [ -x /usr/sbin/univention-config-registry ] && univention-config-registry unregister %(pkg)s || true\\\\n' % data)\\n\\tf_prerm.write(' mv %(info)s %(removed)s || true\\\\n' % data)\\n\\tf_prerm.write('fi\\\\n')\\n\\tf_prerm.write('# End automatically added section\\\\n')\\n\\tf_prerm.close()\\n\\n\\tdoIt('perl', '-e', 'use Debian::Debhelper::Dh_Lib;addsubstvar(\\\"%s\\\", \\\"misc:Depends\\\", \\\"univention-config (>= 7.0.25)\\\");' % package)\",\n \"def make_deps_sha_file(self, deps_sha):\\n return _DEPS_SHA_PATCH % {'deps_sha': deps_sha}\",\n \"def do_counterparty_setup(run_as_user, branch, base_path, dist_path, run_mode, bitcoind_rpc_password, bitcoind_rpc_password_testnet):\\n counterpartyd_rpc_password = pass_generator()\\n counterpartyd_rpc_password_testnet = pass_generator()\\n \\n #Run setup.py (as the XCP user, who runs it sudoed) to install and set up counterpartyd, counterblockd\\n # as -y is specified, this will auto install counterblockd full node (mongo and redis) as well as setting\\n # counterpartyd/counterblockd to start up at startup for both mainnet and testnet (we will override this as necessary\\n # based on run_mode later in this function)\\n runcmd(\\\"~%s/counterpartyd_build/setup.py -y --with-counterblockd --with-testnet --for-user=%s\\\" % (USERNAME, USERNAME))\\n runcmd(\\\"cd ~%s/counterpartyd_build && git config core.sharedRepository group && find ~%s/counterpartyd_build -type d -print0 | xargs -0 chmod g+s\\\" % (\\n USERNAME, USERNAME)) #to allow for group git actions \\n runcmd(\\\"chown -R %s:%s ~%s/counterpartyd_build\\\" % (USERNAME, USERNAME, USERNAME)) #hacky, probably not necessary \\n runcmd(\\\"chmod -R g+rw ~%s/counterpartyd_build\\\" % USERNAME) #hacky\\n\\n #modify the default stored bitcoind passwords in counterpartyd.conf and counterblockd.conf\\n runcmd(r\\\"\\\"\\\"sed -ri \\\"s/^bitcoind\\\\-rpc\\\\-password=.*?$/bitcoind-rpc-password=%s/g\\\" ~%s/.config/counterpartyd/counterpartyd.conf\\\"\\\"\\\" % (\\n bitcoind_rpc_password, USERNAME))\\n runcmd(r\\\"\\\"\\\"sed -ri \\\"s/^bitcoind\\\\-rpc\\\\-password=.*?$/bitcoind-rpc-password=%s/g\\\" ~%s/.config/counterpartyd-testnet/counterpartyd.conf\\\"\\\"\\\" % (\\n bitcoind_rpc_password_testnet, USERNAME))\\n runcmd(r\\\"\\\"\\\"sed -ri \\\"s/^bitcoind\\\\-rpc\\\\-password=.*?$/bitcoind-rpc-password=%s/g\\\" ~%s/.config/counterblockd/counterblockd.conf\\\"\\\"\\\" % (\\n bitcoind_rpc_password, USERNAME))\\n runcmd(r\\\"\\\"\\\"sed -ri \\\"s/^bitcoind\\\\-rpc\\\\-password=.*?$/bitcoind-rpc-password=%s/g\\\" ~%s/.config/counterblockd-testnet/counterblockd.conf\\\"\\\"\\\" % (\\n bitcoind_rpc_password_testnet, USERNAME))\\n \\n #modify the counterpartyd API rpc password in both counterpartyd and counterblockd\\n runcmd(r\\\"\\\"\\\"sed -ri \\\"s/^rpc\\\\-password=.*?$/rpc-password=%s/g\\\" ~%s/.config/counterpartyd/counterpartyd.conf\\\"\\\"\\\" % (\\n counterpartyd_rpc_password, USERNAME))\\n runcmd(r\\\"\\\"\\\"sed -ri \\\"s/^rpc\\\\-password=.*?$/rpc-password=%s/g\\\" ~%s/.config/counterpartyd-testnet/counterpartyd.conf\\\"\\\"\\\" % (\\n counterpartyd_rpc_password_testnet, USERNAME))\\n runcmd(r\\\"\\\"\\\"sed -ri \\\"s/^counterpartyd\\\\-rpc\\\\-password=.*?$/counterpartyd-rpc-password=%s/g\\\" ~%s/.config/counterblockd/counterblockd.conf\\\"\\\"\\\" % (\\n counterpartyd_rpc_password, USERNAME))\\n runcmd(r\\\"\\\"\\\"sed -ri \\\"s/^counterpartyd\\\\-rpc\\\\-password=.*?$/counterpartyd-rpc-password=%s/g\\\" ~%s/.config/counterblockd-testnet/counterblockd.conf\\\"\\\"\\\" % (\\n counterpartyd_rpc_password_testnet, USERNAME))\\n \\n #disable upstart scripts from autostarting on system boot if necessary\\n if run_mode == 't': #disable mainnet daemons from autostarting\\n runcmd(r\\\"\\\"\\\"bash -c \\\"echo 'manual' >> /etc/init/counterpartyd.override\\\" \\\"\\\"\\\")\\n runcmd(r\\\"\\\"\\\"bash -c \\\"echo 'manual' >> /etc/init/counterblockd.override\\\" \\\"\\\"\\\")\\n else:\\n runcmd(\\\"rm -f /etc/init/counterpartyd.override /etc/init/counterblockd.override\\\")\\n if run_mode == 'm': #disable testnet daemons from autostarting\\n runcmd(r\\\"\\\"\\\"bash -c \\\"echo 'manual' >> /etc/init/counterpartyd-testnet.override\\\" \\\"\\\"\\\")\\n runcmd(r\\\"\\\"\\\"bash -c \\\"echo 'manual' >> /etc/init/counterblockd-testnet.override\\\" \\\"\\\"\\\")\\n else:\\n runcmd(\\\"rm -f /etc/init/counterpartyd-testnet.override /etc/init/counterblockd-testnet.override\\\")\\n \\n #append insight enablement param and API performance params to counterpartyd's configs\\n for cfgFilename in [\\n os.path.join(os.path.expanduser('~'+USERNAME), \\\".config\\\", \\\"counterpartyd\\\", \\\"counterpartyd.conf\\\"),\\n os.path.join(os.path.expanduser('~'+USERNAME), \\\".config\\\", \\\"counterpartyd-testnet\\\", \\\"counterpartyd.conf\\\") ]:\\n f = open(cfgFilename, 'r')\\n content = f.read()\\n f.close()\\n if content[-1] != '\\\\n':\\n content += '\\\\n'\\n if not re.search(r'^insight\\\\-enable', content, re.MULTILINE):\\n content += 'insight-enable=1\\\\n'\\n if not re.search(r'^api\\\\-num\\\\-threads', content, re.MULTILINE):\\n content += 'api-num-threads=100\\\\n'\\n if not re.search(r'^api\\\\-request\\\\-queue\\\\-size', content, re.MULTILINE):\\n content += 'api-request-queue-size=500\\\\n'\\n f = open(cfgFilename, 'w')\\n f.write(content)\\n f.close()\\n\\n #change ownership\\n runcmd(\\\"chown -R %s:%s ~%s/.bitcoin ~%s/.config/counterpartyd ~%s/.config/counterblockd\\\" % (\\n USERNAME, USERNAME, USERNAME, USERNAME, USERNAME))\\n runcmd(\\\"chown -R %s:%s ~%s/.bitcoin-testnet ~%s/.config/counterpartyd-testnet ~%s/.config/counterblockd-testnet\\\" % (\\n USERNAME, USERNAME, USERNAME, USERNAME, USERNAME))\",\n \"def finish(c):\\n files_to_commit = [os.path.relpath(path, start=os.curdir) for path in [CHANGELOG_ABSPATH, SETTINGS_PATH]]\\n version: VersionStructure = VersionStructure.from_settings()\\n\\n c.run(f\\\"git add %s\\\" % \\\" \\\".join(files_to_commit))\\n c.run(f'git commit -m \\\"version {version}\\\" --no-verify')\\n c.run(f\\\"git tag {version}\\\")\",\n \"def test_9_dryruns(self):\\n\\n f = fmri.PkgFmri(self.published[3], None)\\n\\n rpth = tempfile.mkdtemp(dir=self.test_root)\\n self.pkgrepo(\\\"create {0}\\\".format(rpth))\\n expected = [\\\"pkg5.repository\\\"]\\n self.pkgrecv(self.durl1, \\\"-n -d {0} {1}\\\".format(rpth, f))\\n self.assertEqualDiff(expected, os.listdir(rpth))\\n\\n self.pkgrecv(self.durl1, \\\"-r -n -d {0} {1}\\\".format(rpth, f))\\n self.assertEqualDiff(expected, os.listdir(rpth))\\n\\n self.pkgrecv(self.durl1, \\\"--clone -n -p '*' -d {0}\\\".format(rpth))\\n self.assertEqualDiff(expected, os.listdir(rpth))\\n\\n arc_path = os.path.join(self.test_root, \\\"test.p5p\\\")\\n self.pkgrecv(self.durl1, \\\"-a -n -d {0} \\\\*\\\".format(arc_path))\\n self.assert_(not os.path.exists(arc_path))\\n\\n # --raw actually populates the destination with manifests even\\n # with -n, so just check that it exits 0.\\n self.pkgrecv(self.durl1, \\\"--raw -n -d {0} {1}\\\".format(\\n self.tempdir, f))\\n\\n # --raw actually populates the destination with manifests even\\n # with -n, so just check that it exits 0.\\n self.pkgrecv(self.durl1, \\\"--raw -r -n -d {0} {1}\\\".format(\\n self.tempdir, f))\",\n \"def tarball(request):\\n\\n patches = (models.Patch\\n .query(ancestor=request.patchset.key)\\n .order(models.Patch.filename)\\n .fetch(1000))\\n\\n temp = tempfile.TemporaryFile()\\n tar = tarfile.open(mode=\\\"w|bz2\\\", fileobj=temp)\\n\\n def add_entry(prefix, content, patch):\\n data = content.data\\n if data is None:\\n data = content.text\\n if isinstance(data, unicode):\\n data = data.encode(\\\"utf-8\\\", \\\"replace\\\")\\n if data is None:\\n return\\n info = tarfile.TarInfo(prefix + patch.filename)\\n info.size = len(data)\\n # TODO(adonovan): set SYMTYPE/0755 when Rietveld supports symlinks.\\n info.type = tarfile.REGTYPE\\n info.mode = 0644\\n # datetime->time_t\\n delta = request.patchset.modified - datetime.datetime(1970, 1, 1)\\n info.mtime = int(delta.days * 86400 + delta.seconds)\\n tar.addfile(info, fileobj=StringIO(data))\\n\\n for patch in patches:\\n if not patch.no_base_file:\\n try:\\n add_entry('a/', patch.get_content(), patch) # before\\n except FetchError: # I/O problem?\\n logging.exception('tarball: patch(%s, %s).get_content failed' %\\n (patch.key.id(), patch.filename))\\n try:\\n add_entry('b/', patch.get_patched_content(), patch) # after\\n except FetchError: # file deletion? I/O problem?\\n logging.exception('tarball: patch(%s, %s).get_patched_content failed' %\\n (patch.key.id(), patch.filename))\\n\\n tar.close()\\n temp.flush()\\n\\n wrapper = FileWrapper(temp)\\n response = HttpResponse(wrapper, mimetype='application/x-gtar')\\n response['Content-Disposition'] = (\\n 'attachment; filename=patch%s_%s.tar.bz2' % (request.issue.key.id(),\\n request.patchset.key.id()))\\n response['Content-Length'] = temp.tell()\\n temp.seek(0)\\n return response\",\n \"def MakeRecoveryPatch(input_tmp, output_zip, recovery_img, boot_img):\\n\\n diff_program = [\\\"imgdiff\\\"]\\n path = os.path.join(input_tmp, \\\"SYSTEM\\\", \\\"etc\\\", \\\"recovery-resource.dat\\\")\\n if os.path.exists(path):\\n diff_program.append(\\\"-b\\\")\\n diff_program.append(path)\\n bonus_args = \\\"-b /system/etc/recovery-resource.dat\\\"\\n else:\\n bonus_args = \\\"\\\"\\n\\n d = common.Difference(recovery_img, boot_img, diff_program=diff_program)\\n _, _, patch = d.ComputePatch()\\n common.ZipWriteStr(output_zip, \\\"recovery/recovery-from-boot.p\\\", patch)\\n Item.Get(\\\"system/recovery-from-boot.p\\\", dir=False)\\n\\n boot_type, boot_device = common.GetTypeAndDevice(\\\"/boot\\\", OPTIONS.info_dict)\\n recovery_type, recovery_device = common.GetTypeAndDevice(\\\"/recovery\\\", OPTIONS.info_dict)\\n\\n sh = \\\"\\\"\\\"#!/system/bin/sh\\nif ! applypatch -c %(recovery_type)s:%(recovery_device)s:%(recovery_size)d:%(recovery_sha1)s; then\\n log -t recovery \\\"Installing new recovery image\\\"\\n applypatch %(bonus_args)s %(boot_type)s:%(boot_device)s:%(boot_size)d:%(boot_sha1)s %(recovery_type)s:%(recovery_device)s %(recovery_sha1)s %(recovery_size)d %(boot_sha1)s:/system/recovery-from-boot.p\\nelse\\n log -t recovery \\\"Recovery image already installed\\\"\\nfi\\n\\\"\\\"\\\" % { 'boot_size': boot_img.size,\\n 'boot_sha1': boot_img.sha1,\\n 'recovery_size': recovery_img.size,\\n 'recovery_sha1': recovery_img.sha1,\\n 'boot_type': boot_type,\\n 'boot_device': boot_device,\\n 'recovery_type': recovery_type,\\n 'recovery_device': recovery_device,\\n 'bonus_args': bonus_args,\\n }\\n common.ZipWriteStr(output_zip, \\\"recovery/etc/install-recovery.sh\\\", sh)\\n return Item.Get(\\\"system/etc/install-recovery.sh\\\", dir=False)\",\n \"def rewrite_importlib_resources(pkg_files, new_root):\\n for file in pkg_files.glob('*.py'):\\n text = file.read_text().replace('importlib_resources.abc', '.abc')\\n text = text.replace('zipp', '..zipp')\\n file.write_text(text)\",\n \"def mspatchc_CreatePatchFileByHandlesEx(jitter):\\n ret_ad, args = jitter.func_args_stdcall([\\\"OldFileCount\\\", \\\"OldFileInfoArray\\\", \\\"NewFileHandle\\\", \\\"PatchFileHandle\\\", \\\"OptionFlags\\\", \\\"OptionData\\\", \\\"ProgressCallback\\\", \\\"CallbackContext\\\"])\\n raise RuntimeError('API not implemented')\\n jitter.func_ret_stdcall(ret_ad, ret_value)\",\n \"def test_7_cancer(install_test_files, data_dir):\\n with make_workdir() as workdir:\\n cl = [\\\"bcbio_nextgen.py\\\",\\n get_post_process_yaml(data_dir, workdir),\\n os.path.join(data_dir, \\\"run_info-cancer.yaml\\\")]\\n subprocess.check_call(cl)\",\n \"def test_resetcherrypick_keeps_unrelated_deletions(\\n repository: Repository, paths: Iterator[Path]\\n) -> None:\\n main = repository.head\\n update, _ = createbranches(repository, \\\"update\\\", \\\"latest\\\")\\n path1, path2 = next(paths), next(paths)\\n\\n repository.checkout(update)\\n updatefile(path1, \\\"a\\\")\\n\\n repository.checkout(main)\\n updatefile(path1, \\\"b\\\")\\n updatefile(path2)\\n\\n path2.unlink()\\n\\n with pytest.raises(MergeConflictError, match=path1.name):\\n repository.cherrypick(update.commit)\\n\\n repository.resetcherrypick()\\n\\n assert not path2.exists()\",\n \"def run(self):\\n self._make_lib_file_symbolic_links()\\n self._copy_each_include_files_to_include_dir()\\n self._make_dep_lib_file_sym_links_and_copy_include_files()\\n self.setup_py.add_patchs_to_build_without_pkg_config(\\n self.rpm.lib_dir, self.rpm.include_dir\\n )\\n self.setup_py.apply_and_save()\\n self._build_and_install()\",\n \"def test_8_template(install_test_files, data_dir):\\n fc_dir = os.path.join(data_dir, os.pardir, \\\"100326_FC6107FAAXX\\\")\\n with make_workdir():\\n cl = [\\\"bcbio_nextgen.py\\\", \\\"-w\\\", \\\"template\\\", \\\"--only-metadata\\\",\\n \\\"freebayes-variant\\\",\\n os.path.join(fc_dir, \\\"100326.csv\\\"),\\n os.path.join(fc_dir, \\\"7_100326_FC6107FAAXX_1_fastq.txt\\\"),\\n os.path.join(fc_dir, \\\"7_100326_FC6107FAAXX_2_fastq.txt\\\"),\\n os.path.join(fc_dir, \\\"8_100326_FC6107FAAXX.bam\\\")]\\n subprocess.check_call(cl)\",\n \"def __gitCherryPick(self):\\n pfile = self.project.getProjectFile()\\n lastModified = QFileInfo(pfile).lastModified().toString()\\n shouldReopen = (\\n self.vcs.gitCherryPick(self.project.getProjectPath()) or\\n QFileInfo(pfile).lastModified().toString() != lastModified\\n )\\n if shouldReopen:\\n res = E5MessageBox.yesNo(\\n None,\\n self.tr(\\\"Copy Commits\\\"),\\n self.tr(\\\"\\\"\\\"The project should be reread. Do this now?\\\"\\\"\\\"),\\n yesDefault=True)\\n if res:\\n self.project.reopenProject()\",\n \"def test_cherrypick_committer(\\n repository: Repository, monkeypatch: pytest.MonkeyPatch\\n) -> None:\\n main = repository.head\\n branch = repository.heads.create(\\\"branch\\\")\\n committer = pygit2.Signature(\\\"committer\\\", \\\"committer@example.com\\\")\\n\\n repository.checkout(branch)\\n (repository.path / \\\"a\\\").touch()\\n repository.commit(committer=committer)\\n\\n cherrypicker = pygit2.Signature(\\\"cherrypicker\\\", \\\"cherrypicker@example.com\\\")\\n monkeypatch.setenv(\\\"GIT_AUTHOR_NAME\\\", cherrypicker.name)\\n monkeypatch.setenv(\\\"GIT_AUTHOR_EMAIL\\\", cherrypicker.email)\\n\\n repository.checkout(main)\\n repository.cherrypick(branch.commit)\\n\\n assert cherrypicker.email == repository.head.commit.committer.email\",\n \"def test_call_sh_files(self):\\n def structs():\\n \\\"\\\"\\\"Mockups for called scripts.\\\"\\\"\\\"\\n server = MockUCSHttpServer('server')\\n struct_r = U.UCSRepoPool(major=MAJOR, minor=MINOR, part=PART, patchlevel=PATCH, arch=ARCH)\\n preup_r = struct_r.path('preup.sh')\\n postup_r = struct_r.path('postup.sh')\\n struct_c = U.UCSRepoPool(major=MAJOR, minor=MINOR, part='%s/component' % (PART,), patch='c', arch=ARCH)\\n preup_c = struct_c.path('preup.sh')\\n postup_c = struct_c.path('postup.sh')\\n\\n yield (server, struct_r, 'preup', preup_r, 'r_pre')\\n yield (server, struct_r, 'postup', postup_r, 'r_post')\\n yield (server, struct_c, 'preup', preup_c, 'c_pre')\\n yield (server, struct_c, 'postup', postup_c, 'c_post')\\n tmp = NamedTemporaryFile()\\n\\n gen = self.u.call_sh_files(structs(), tmp.name, 'arg')\\n\\n # The Updater only yields the intent, the content is only available after the next step\\n self.assertEqual(('update', 'pre'), gen.next()) # download\\n self.assertEqual([], MockPopen.mock_get())\\n self.assertEqual(('preup', 'pre'), gen.next()) # pre\\n self.assertEqual([], MockPopen.mock_get())\\n self.assertEqual(('preup', 'main'), gen.next())\\n self.assertEqual(('pre', 'arg', 'c_pre'), MockPopen.mock_get()[0][1:])\\n self.assertEqual(('preup', 'post'), gen.next())\\n self.assertEqual(('arg', 'r_pre'), MockPopen.mock_get()[0][1:])\\n self.assertEqual(('update', 'main'), gen.next()) # update\\n self.assertEqual(('post', 'arg', 'c_pre'), MockPopen.mock_get()[0][1:])\\n self.assertEqual(('postup', 'pre'), gen.next()) # post\\n self.assertEqual([], MockPopen.mock_get())\\n self.assertEqual(('postup', 'main'), gen.next())\\n self.assertEqual(('pre', 'arg', 'c_post'), MockPopen.mock_get()[0][1:])\\n self.assertEqual(('postup', 'post'), gen.next())\\n self.assertEqual(('arg', 'r_post'), MockPopen.mock_get()[0][1:])\\n self.assertEqual(('update', 'post'), gen.next())\\n self.assertEqual(('post', 'arg', 'c_post'), MockPopen.mock_get()[0][1:])\\n self.assertRaises(StopIteration, gen.next) # done\\n self.assertEqual([], MockPopen.mock_get())\",\n \"def generate_all_files():\\n for (name, fn) in lang_module.targets.items():\\n path = of_g.options.install_dir + '/' + name\\n os.system(\\\"mkdir -p %s\\\" % os.path.dirname(path))\\n with open(path, \\\"w\\\") as outfile:\\n fn(outfile, os.path.basename(name))\\n print(\\\"Wrote contents for \\\" + name)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6193804","0.61185837","0.60817057","0.587971","0.5735855","0.57174575","0.5645524","0.55588645","0.5523853","0.5493776","0.54873055","0.5407881","0.53941137","0.5388479","0.5378879","0.53761584","0.5310182","0.52620775","0.52522963","0.52342397","0.52270097","0.5216815","0.5192205","0.5188725","0.5174338","0.51693624","0.515936","0.51499003","0.5139899","0.5139076","0.51332533","0.5107567","0.507124","0.50590914","0.504449","0.5043489","0.5042243","0.50338423","0.50338423","0.5033124","0.50327855","0.50243855","0.50208807","0.5018975","0.5012167","0.5007162","0.50056654","0.4992331","0.49815103","0.49773702","0.4973663","0.49635717","0.4963157","0.49478984","0.49369583","0.49320433","0.491729","0.49106562","0.4907259","0.48957","0.4875026","0.4874325","0.48714066","0.48693088","0.48679194","0.4855423","0.48483443","0.48441172","0.48433444","0.4841438","0.48407522","0.48402572","0.48389187","0.4838052","0.48331314","0.48321846","0.4830651","0.4829156","0.48189497","0.48128825","0.4812641","0.48088074","0.47987443","0.47973785","0.4787922","0.478568","0.47794014","0.4776306","0.47712556","0.47712538","0.47638988","0.47528598","0.4750701","0.47412503","0.47368795","0.4732462","0.47289124","0.4727358","0.472669","0.4726211"],"string":"[\n \"0.6193804\",\n \"0.61185837\",\n \"0.60817057\",\n \"0.587971\",\n \"0.5735855\",\n \"0.57174575\",\n \"0.5645524\",\n \"0.55588645\",\n \"0.5523853\",\n \"0.5493776\",\n \"0.54873055\",\n \"0.5407881\",\n \"0.53941137\",\n \"0.5388479\",\n \"0.5378879\",\n \"0.53761584\",\n \"0.5310182\",\n \"0.52620775\",\n \"0.52522963\",\n \"0.52342397\",\n \"0.52270097\",\n \"0.5216815\",\n \"0.5192205\",\n \"0.5188725\",\n \"0.5174338\",\n \"0.51693624\",\n \"0.515936\",\n \"0.51499003\",\n \"0.5139899\",\n \"0.5139076\",\n \"0.51332533\",\n \"0.5107567\",\n \"0.507124\",\n \"0.50590914\",\n \"0.504449\",\n \"0.5043489\",\n \"0.5042243\",\n \"0.50338423\",\n \"0.50338423\",\n \"0.5033124\",\n \"0.50327855\",\n \"0.50243855\",\n \"0.50208807\",\n \"0.5018975\",\n \"0.5012167\",\n \"0.5007162\",\n \"0.50056654\",\n \"0.4992331\",\n \"0.49815103\",\n \"0.49773702\",\n \"0.4973663\",\n \"0.49635717\",\n \"0.4963157\",\n \"0.49478984\",\n \"0.49369583\",\n \"0.49320433\",\n \"0.491729\",\n \"0.49106562\",\n \"0.4907259\",\n \"0.48957\",\n \"0.4875026\",\n \"0.4874325\",\n \"0.48714066\",\n \"0.48693088\",\n \"0.48679194\",\n \"0.4855423\",\n \"0.48483443\",\n \"0.48441172\",\n \"0.48433444\",\n \"0.4841438\",\n \"0.48407522\",\n \"0.48402572\",\n \"0.48389187\",\n \"0.4838052\",\n \"0.48331314\",\n \"0.48321846\",\n \"0.4830651\",\n \"0.4829156\",\n \"0.48189497\",\n \"0.48128825\",\n \"0.4812641\",\n \"0.48088074\",\n \"0.47987443\",\n \"0.47973785\",\n \"0.4787922\",\n \"0.478568\",\n \"0.47794014\",\n \"0.4776306\",\n \"0.47712556\",\n \"0.47712538\",\n \"0.47638988\",\n \"0.47528598\",\n \"0.4750701\",\n \"0.47412503\",\n \"0.47368795\",\n \"0.4732462\",\n \"0.47289124\",\n \"0.4727358\",\n \"0.472669\",\n \"0.4726211\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6612873"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21990,"cells":{"query":{"kind":"string","value":"Use the userprovided CLI arguments to find Rez packages."},"document":{"kind":"string","value":"def __gather_package_data(arguments):\n ignore_patterns, packages_path, search_packages_path = _resolve_arguments(\n arguments.ignore_patterns,\n arguments.packages_path,\n arguments.search_packages_path,\n )\n rez_packages = set(arguments.rez_packages)\n\n package_finder = registry.get_package_finder(arguments.command)\n\n found_packages = []\n packages, invalid_packages, skips = package_finder(\n paths=packages_path + search_packages_path\n )\n\n for package in packages:\n if rez_packages and package.name not in rez_packages:\n skips.append(package)\n else:\n found_packages.append(package)\n\n ignored_packages, other_packages = _split_the_ignored_packages(\n found_packages, ignore_patterns\n )\n\n other_packages = sorted(other_packages, key=operator.attrgetter(\"name\"))\n\n return ignored_packages, other_packages, invalid_packages, skips"},"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 cli(args): # noqa; pylint: disable=unused-argument","def main(args):\n cli = CLI()\n # Check arguments\n cli.parse_arguments(args)","def main(args):","def main(args):","def main():\n licensify(_parse_args())","def main(args=None):","def main(args=None):","def query_cmdline():","def main(args, fLOG=print):\n try:\n from .parsers.folders import read_folder\n except ImportError: # pragma: no cover\n from manydataapi.parsers.folders import read_folder\n\n fcts = dict(read_folder=read_folder)\n from pyquickhelper.cli import cli_main_helper\n return cli_main_helper(fcts, args=args, fLOG=fLOG)","def _parse_arguments(text):\n parser = argparse.ArgumentParser(\n description=\"Build Python-based Rez packages in just a single command.\",\n )\n\n parser.add_argument(\n \"--hdas\",\n nargs=\"+\",\n help=\"The relative paths to each folder containing VCS-style Houdini HDAs.\",\n )\n\n parser.add_argument(\n \"-i\",\n \"--items\",\n nargs=\"+\",\n help=\"The relative paths to each file/folder to copy / install.\",\n )\n\n parser.add_argument(\n \"-e\",\n \"--eggs\",\n nargs=\"+\",\n help=\"The relative paths to each file/folder to make into a .egg file.\",\n )\n\n parser.add_argument(\n \"--symlink\",\n action=\"store_true\",\n default=linker.must_symlink(),\n help=\"If True, symlink everything back to the source Rez package.\",\n )\n\n parser.add_argument(\n \"--symlink-files\",\n action=\"store_true\",\n default=linker.must_symlink_files(),\n help=\"If True, symlink files back to the source Rez package.\",\n )\n\n parser.add_argument(\n \"--symlink-folders\",\n action=\"store_true\",\n default=linker.must_symlink_folders(),\n help=\"If True, symlink folders back to the source Rez package.\",\n )\n\n known, _ = parser.parse_known_args(text)\n\n return known","def parse_command_line_arguments():\n parser = argparse.ArgumentParser(\n description=\"Convert dependency files into list of GitHub links.\",\n epilog=\"For help with this program, contact John Speed at jmeyers@iqt.org.\",\n )\n parser.add_argument(\n \"--python\",\n default=False, # default value is False\n help=\"Convert requirements.txt file into GitHub links.\",\n )\n return parser.parse_args()","def package_finder(argv):\n # We instantiate an InstallCommand and then use some of its private\n # machinery--its arg parser--for our own purposes, like a virus. This\n # approach is portable across many pip versions, where more fine-grained\n # ones are not. Ignoring options that don't exist on the parser (for\n # instance, --use-wheel) gives us a straightforward method of backward\n # compatibility.\n try:\n command = InstallCommand()\n except TypeError:\n # This is likely pip 1.3.0's \"__init__() takes exactly 2 arguments (1\n # given)\" error. In that version, InstallCommand takes a top=level\n # parser passed in from outside.\n from pip.baseparser import create_main_parser\n command = InstallCommand(create_main_parser())\n # The downside is that it essentially ruins the InstallCommand class for\n # further use. Calling out to pip.main() within the same interpreter, for\n # example, would result in arguments parsed this time turning up there.\n # Thus, we deepcopy the arg parser so we don't trash its singletons. Of\n # course, deepcopy doesn't work on these objects, because they contain\n # uncopyable regex patterns, so we pickle and unpickle instead. Fun!\n options, _ = loads(dumps(command.parser)).parse_args(argv)\n\n # Carry over PackageFinder kwargs that have [about] the same names as\n # options attr names:\n possible_options = [\n 'find_links', 'use_wheel', 'allow_external', 'allow_unverified',\n 'allow_all_external', ('allow_all_prereleases', 'pre'),\n 'process_dependency_links']\n kwargs = {}\n for option in possible_options:\n kw, attr = option if isinstance(option, tuple) else (option, option)\n value = getattr(options, attr, MARKER)\n if value is not MARKER:\n kwargs[kw] = value\n\n # Figure out index_urls:\n index_urls = [options.index_url] + options.extra_index_urls\n if options.no_index:\n index_urls = []\n index_urls += getattr(options, 'mirrors', [])\n\n # If pip is new enough to have a PipSession, initialize one, since\n # PackageFinder requires it:\n if hasattr(command, '_build_session'):\n kwargs['session'] = command._build_session(options)\n\n return PackageFinder(index_urls=index_urls, **kwargs)","def get_cli_arguments(self):\n pass","def main(self):\n\n argprs = argvparse.Argparse()\n\n lines = []\n\n if not argprs.files:\n self.read_user_input()\n lines.append(self.commandline)\n self.send_lines_to_finditer(argprs.regex, lines,\n argprs.underscore, argprs.color, argprs.machine)\n else:\n # print argprs.files\n for fl in argprs.files:\n try:\n filerd = fileread.Fileread(fl)\n self.send_lines_to_finditer(argprs.regex, filerd.lines,\n argprs.underscore, argprs.color, argprs.machine,\n filerd.shortfilename)\n except Exception as e:\n print str(e), \"\\n\"","def parse_command_line(argv):\n import argparse\n parser = argparse.ArgumentParser(\n description=\"\"\"\\\nShow information about a list of scales in Neuroglancer \"info\" JSON file format\n\"\"\")\n parser.add_argument(\"info_file\", nargs=\"?\", default=\"./info\",\n help=\"JSON file containing the information\")\n args = parser.parse_args(argv[1:])\n return args","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def cli():","def parse_args(argv: list[str]) -> argparse.Namespace:\n os_release = platform.freedesktop_os_release()\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"-c\",\n \"--chroot\",\n default=os_release[\"VERSION_CODENAME\"],\n help=\"Specify a chroot or active session to use. (default: use current distribution\"\n \" codename '%(default)s')\",\n )\n parser.add_argument(\n \"-d\",\n \"--directory\",\n default=os.getcwd(),\n help=\"Change to directory inside the chroot before running the command or login shell.\"\n \" Use the current directory if it exists in the chroot. Otherwise fall back to the user's\"\n \" home directory (and create the directory if it is missing).\",\n )\n parser.add_argument(\n \"-u\",\n \"--user\",\n default=getpass.getuser(),\n help=\"Run as a different user. The default is to run as %(default)s and fallback to root\"\n \" if that user does not exist in the chroot.\",\n )\n parser.add_argument(\n \"-p\",\n \"--packages\",\n default=[],\n action=\"append\",\n help=\"List of comma- or space-separated packages that should be installed\"\n \" without recommends. Can be specified multiple times.\",\n )\n parser.add_argument(\n \"--ppa\",\n default=[],\n action=\"append\",\n help=\"PPA APT sources that should be added. Can be specified multiple times.\",\n )\n parser.add_argument(\n \"-e\", \"--enable-proposed\", action=\"store_true\", help=\"Enable -proposed pocket.\"\n )\n parser.add_argument(\n \"--proposed-uri\",\n default=\"http://archive.ubuntu.com/ubuntu\",\n help=\"Sources list URI to use for -proposed (default: %(default)s)\",\n )\n parser.add_argument(\n \"--proposed-components\",\n default=\"main,universe\",\n help=\"List of comma- or space-separated components to use for -proposed\"\n \" (default: %(default)s)\",\n )\n\n args = parser.parse_args(argv)\n args.packages = [p for packages in args.packages for p in re.split(\"[, ]\", packages)]\n args.proposed_components = re.split(\"[, ]\", args.proposed_components)\n\n return args","def parse_cli_args():\r\n parser = argparse.ArgumentParser(\r\n description=\"list all installed packages\")\r\n\r\n parser.add_argument(\"-v\", \"--verbose\",\r\n help=\"increase output verbosity\",\r\n action=\"store_true\")\r\n\r\n parser.add_argument(\"-d\", \"--debug\",\r\n help=\"enable debug output\",\r\n action=\"store_true\")\r\n\r\n parser.add_argument(\"-N\", \"--dry-run\",\r\n help=\"Do not perform any actions, only simulate them.\",\r\n action=\"store_true\")\r\n\r\n args = parser.parse_args()\r\n\r\n # set debug log state\r\n DebugLog.enabled = args.debug\r\n\r\n with DebugLogScopedPush(\"cli arguments:\"):\r\n DebugLog.print(str(args))\r\n\r\n return args","def main():\n args = parse_args()\n process_args(args)","def command_line_arguments():\n\n try:\n parser = argparse.ArgumentParser(description='Log Handler/Cleaner/Copier for Idemia DocAuth')\n\n # Add required arguments.\n parser.add_argument('action', choices=['clean', 'download'], type=str, help='clean or download')\n\n # Parse the arguments\n args = parser.parse_args()\n\n return args\n\n except Exception as err:\n print(err)\n return","def parse_command_line():\n parser = argparse.ArgumentParser(description='Parses ID\\'s from the DDI compendium search results, and then downloads the html and puts them into a sqlite database.')\n parser.add_argument('-f', '--file', dest='file',\n action='store',\n help='Filenname to be read')\n arg_manager = parser.parse_args()\n return arg_manager","def cli(**_) -> None:\n pass","def _ParseCommandArguments():\n arg_parser = argparse.ArgumentParser()\n arg_parser.usage = __doc__\n\n arg_parser.add_argument('--download-dir',\n type=str,\n required=True,\n help='Directory into which corpora are downloaded.')\n arg_parser.add_argument('--build-dir',\n required=True,\n type=str,\n help='Directory where fuzzers were built.')\n args = arg_parser.parse_args()\n return args","def cli():\n config, auth, execute_now = read_command_line_arguments()\n main(config, auth, execute_now)","def cli_options():\n\n parser = argparse.ArgumentParser(\n description='c[apirca]grep',\n formatter_class=argparse.RawTextHelpFormatter\n )\n\n parser.add_argument('-d', '--def', dest='defs',\n help='Network Definitions directory location. \\n',\n default='./def')\n\n # -i and -t can be used together, but not with any other option.\n ip_group = parser.add_argument_group()\n # take 1 or more IPs\n ip_group.add_argument('-i', '--ip', dest='ip', nargs='+', type=is_valid_ip,\n help='Return list of definitions containing the '\n 'IP(s).\\nMultiple IPs permitted.')\n\n ip_group.add_argument('-t', '--token', dest='token',\n help=('See if an IP is contained within the given '\n 'token.\\nMust be used in conjunction with '\n '-i/--ip [addr].'))\n\n exclusive_group = parser.add_mutually_exclusive_group()\n # the rest of the arguments are mutually exclusive with each other,\n # and -i / -t\n exclusive_group.add_argument('-c', '--cmp', dest='cmp', nargs=2,\n metavar=('OBJ', 'OBJ'),\n help=('Compare the two given network '\n 'definition tokens'))\n\n exclusive_group.add_argument('-g', '--gmp', dest='gmp', nargs=2,\n type=is_valid_ip, metavar=('IP', 'IP'),\n help=('Diff the network objects to'\n ' which the given IP(s) belong'))\n\n exclusive_group.add_argument('-o', '--obj', dest='obj', nargs='+',\n help=('Return list of IP(s) contained within '\n 'the given token(s)'))\n\n exclusive_group.add_argument('-s', '--svc', dest='svc', nargs='+',\n help=('Return list of port(s) contained '\n 'within given token(s)'))\n\n exclusive_group.add_argument('-p', '--port', dest='port', nargs=2,\n metavar=('PORT', 'PROTO'),\n help=('Returns a list of tokens containing '\n 'the given port and protocol'))\n\n return parser","def cmd_user(args):","def parse_arguments(args):","def setup():\n try:\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--rows\", type=int, default=10, help=\"Number of rows to generate in demo file\")\n parser.add_argument(\"--filename\", type=str, default=\"..//data//demo.csv\", help=\"Filename of demo data\")\n parser.add_argument(\"--search_term\", type=str, default=\"Street\", help=\"Search term to look for in address info\")\n args = parser.parse_args()\n # generate_data_file(args.filename, args.rows)\n return args\n except Exception as e:\n print(e)\n exit(-1)","def cli() -> None:","def cli() -> None:","def main():\n if len(sys.argv) == 1:\n print(\"Usage:\", sys.argv[0], \"<PyPI project name(s)>\")\n return\n # Things I want to resolve.\n reqs = sys.argv[1:]\n requirements = [Requirement(r) for r in reqs]\n\n # Create the (reusable) resolver.\n provider = PyPIProvider()\n reporter = BaseReporter()\n resolver = Resolver(provider, reporter)\n\n # Kick off the resolution process, and get the final result.\n print(\"Resolving\", \", \".join(reqs))\n result = resolver.resolve(requirements)\n display_resolution(result)","def setup_cmd_args():\n parser = argparse.ArgumentParser(description=\"This program will query G-POD and COPHUB on the same datasets, in order to obtain the number of data results, compare them compile a report with the differences.\", formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n # parser.add_argument(\"root_dir\", help=\"The root directory containing data to check\")\n # parser.add_argument(\"--workspace\", help=\"Set Workspace manually\")\n parser.add_argument(\"--outputlist\", help=\"Folder to write the output lists with the un-synced products.\", default=\"c:\\\\temp\\\\\")\n parser.add_argument(\"--daysback\", help=\"Report with a given number of days back from today\", default=0)\n parser.add_argument(\"--dataset\", help=\"Set which dataset to query (chose S3A_SR_1_SRA_A_PREOPS or S3B_SR_1_SRA_A_NTC)\")\n parser.add_argument(\"--startdate\", help=\" The Start Date (format: YYYY-MM-DD) \", default=\"2016-06-01\")\n parser.add_argument(\"--enddate\",help=\" The End Date (format: YYYY-MM-DD)\")\n parser.add_argument(\"--cphubuser\",help=\"COPHUB username\", required=True)\n parser.add_argument(\"--cphubpw\",help=\"COPHUB password\", required=True)\n parser.add_argument(\"-email\", type=str, help=\"Email to send the results\", action=\"append\")\n parser.add_argument('-t', action='store_true', help=\"Today as enddate. Otherwise the last day of the previous month is considered.\")\n parser.add_argument('-n', action='store_true', help=\"Normal numeric check\")\n parser.add_argument('-m', action='store_true', help=\"Monthly check with product listing.\")\n return parser.parse_args()","def parse_cli(argv):\n possible_remits = ['pandoc', 'panzer', 'diff']\n sourcelist = list()\n remit = None\n if len(argv) < 2 or argv[1] not in possible_remits:\n print(__doc__)\n sys.exit(1)\n if len(argv) >= 2:\n remit = argv[1]\n if len(argv) > 2:\n sourcelist = argv[2:]\n return remit, sourcelist","def cli():\n ...","def get_args():\n parser = argparse.ArgumentParser(\n description=\"Sets up package within the pheeno's directory.\"\n )\n\n # Required arguments\n parser.add_argument(\"-x\", \"--execute\", action=\"execute\", required=True,\n help=\"something\", default=False)\n\n # Optional arguments\n parser.add_argument(\"-s\", \"--save\", action=\"store\", required=False,\n help=\"something\", default=False)","def get_args():\n parser = argparse.ArgumentParser('Find a featureclass, database, mxd, or service in ArcGIS Server',\n epilog='For search strings inlcuding spaces, enclose the query in double-quotes')\n parser.add_argument('name', help='string for which to search (blank returns info on all services)',\n nargs='?', default='')\n parser.add_argument('-q', '--quiet', help='only display service names and URLs', action='store_true')\n parser.add_argument('-qq', '--veryquiet', help='only display service URLs, comma delimited', action='store_true')\n parser.add_argument('-cs', '--configstore', help='explicitly provide full path to config store', action='store')\n parser.add_argument('-csv', '--tocsv', help='create csv output', action='store_true')\n parser.add_argument('-md', '--markdown', help='create Markdown output', action='store_true')\n return parser.parse_args()","def get_cli(argv):\n\n global list_of_microRNAs\n global priority \n global size\n global list_of_sequence\n global distance\n\n try:\n opts, args = getopt.getopt(argv, \"hl:p:s:q:d:\", ['help', 'list_of_microRNAs=', 'priority=', 'size=', 'list_of_sequence=', 'distance=' ])\n except getopt.GetoptError as err:\n print_help()\n print str(err)\n sys.exit(1)\n \n # parse the provided cli options\n \n for opt, arg in opts:\n print opt, arg\n if opt in ('-h', '--help'):\n print_help()\n sys.exit(0)\n elif opt in ( '-l', '--list_of_microRNAs'):\n list_of_microRNAs = arg\n elif opt in ('-p', '--priority'):\n priority = arg\n elif opt in ('-s', '--size'):\n size = int(arg)\n elif opt in ('-q', '--list_of_sequence='):\n list_of_sequence = arg\n elif opt in ('-d', '--distance='):\n distance = int(arg)\n\n # check wether or not all mandatory parameters have been provided\n if not os.path.isfile(list_of_microRNAs) and os.path.isfile(priority) :\n print_help()\n print \"key missing\"\n print \"Arguments given :\", list_of_microRNAs, priority\n sys.exit(1)\n \n\n \n return","def main(given_args):\n opts = parse_args(given_args)\n RUN_OPTS.opts = opts\n\n if 'debug' in opts:\n RUN_OPTS.debug = opts['debug']\n print_debug('debug enabled')\n\n # force interactive mode if no album(s) given\n if len(opts['albums']) == 0 and not opts['interactive']:\n print_debug(\"forcing interactive mode on\")\n opts['interactive'] = True\n\n if opts['grep']:\n try:\n RUN_OPTS.title_pattern = re.compile(opts['grep'])\n except Exception as error: # pylint: disable=broad-except\n print(f\"ignoring invalid regex \\\"{opts['grep']}\\\": {error}\")\n\n nbr_albums = len(opts['albums'])\n\n print_debug(f\"{nbr_albums} album(s) given\")\n\n for album_id in opts['albums']:\n if not album_id.isdigit():\n print(\"albumId must be numeric\")\n continue\n if nbr_albums > 1:\n print(f\"### album id {album_id} ###\")\n\n photos = get_photos(album_id)\n\n display_photos(photos)\n\n if opts['interactive']:\n interactive_prompts()","def parse_command_line(argv):\n flags = 0\n\n usage = \"usage: %prog [options] name\"\n\n parser = optparse.OptionParser(add_help_option=False, usage=usage)\n parser.add_option(\"-a\", \"--arin\", action=\"store_const\",\n const=NICClient.ANICHOST, dest=\"whoishost\",\n help=\"Lookup using host \" + NICClient.ANICHOST)\n parser.add_option(\"-A\", \"--apnic\", action=\"store_const\",\n const=NICClient.PNICHOST, dest=\"whoishost\",\n help=\"Lookup using host \" + NICClient.PNICHOST)\n parser.add_option(\"-b\", \"--abuse\", action=\"store_const\",\n const=NICClient.ABUSEHOST, dest=\"whoishost\",\n help=\"Lookup using host \" + NICClient.ABUSEHOST)\n parser.add_option(\"-c\", \"--country\", action=\"store\",\n type=\"string\", dest=\"country\",\n help=\"Lookup using country-specific NIC\")\n parser.add_option(\"-d\", \"--mil\", action=\"store_const\",\n const=NICClient.DNICHOST, dest=\"whoishost\",\n help=\"Lookup using host \" + NICClient.DNICHOST)\n parser.add_option(\"-g\", \"--gov\", action=\"store_const\",\n const=NICClient.GNICHOST, dest=\"whoishost\",\n help=\"Lookup using host \" + NICClient.GNICHOST)\n parser.add_option(\"-h\", \"--host\", action=\"store\",\n type=\"string\", dest=\"whoishost\",\n help=\"Lookup using specified whois host\")\n parser.add_option(\"-i\", \"--nws\", action=\"store_const\",\n const=NICClient.INICHOST, dest=\"whoishost\",\n help=\"Lookup using host \" + NICClient.INICHOST)\n parser.add_option(\"-I\", \"--iana\", action=\"store_const\",\n const=NICClient.IANAHOST, dest=\"whoishost\",\n help=\"Lookup using host \" + NICClient.IANAHOST)\n parser.add_option(\"-l\", \"--lcanic\", action=\"store_const\",\n const=NICClient.LNICHOST, dest=\"whoishost\",\n help=\"Lookup using host \" + NICClient.LNICHOST)\n parser.add_option(\"-m\", \"--ra\", action=\"store_const\",\n const=NICClient.MNICHOST, dest=\"whoishost\",\n help=\"Lookup using host \" + NICClient.MNICHOST)\n parser.add_option(\"-p\", \"--port\", action=\"store\",\n type=\"int\", dest=\"port\",\n help=\"Lookup using specified tcp port\")\n parser.add_option(\"-Q\", \"--quick\", action=\"store_true\",\n dest=\"b_quicklookup\",\n help=\"Perform quick lookup\")\n parser.add_option(\"-r\", \"--ripe\", action=\"store_const\",\n const=NICClient.RNICHOST, dest=\"whoishost\",\n help=\"Lookup using host \" + NICClient.RNICHOST)\n parser.add_option(\"-R\", \"--ru\", action=\"store_const\",\n const=\"ru\", dest=\"country\",\n help=\"Lookup Russian NIC\")\n parser.add_option(\"-6\", \"--6bone\", action=\"store_const\",\n const=NICClient.SNICHOST, dest=\"whoishost\",\n help=\"Lookup using host \" + NICClient.SNICHOST)\n parser.add_option(\"-n\", \"--ina\", action=\"store_const\",\n const=NICClient.PANDIHOST, dest=\"whoishost\",\n help=\"Lookup using host \" + NICClient.PANDIHOST)\n parser.add_option(\"-?\", \"--help\", action=\"help\")\n\n return parser.parse_args(argv)","def main():\n parser = argparse.ArgumentParser(description=\"\"\"Tester for YT Data API and different inputs\"\"\")\n parser.add_argument('-a', '--analytics', help='Performs a basic analytics lookup for the user\\'s channel entered')\n parser.add_argument('-c', '--comments', help='Performs a lookup of comments for the video id entered')\n args = parser.parse_args()\n\n if args.analytics:\n analytics = args.analytics\n analyt(analytics)\n\n if args.comments:\n comments = args.comments\n get_comments(comments)","def main(args):\n return add_command(args.directory, args.name, args.type, args.command, args.env_spec, args.supports_http_options)","def cli():\n return","def cli():\n\n pass","def _add_arguments(parser):\n parser.add_argument(\n \"command\",\n help='The plugin to run. e.g. \"shell\".',\n choices=sorted(registry.get_command_keys()),\n )\n\n parser.add_argument(\n \"-x\",\n \"--maximum-repositories\",\n default=sys.maxsize,\n type=int,\n help='If a value of `2` is used, it means \"Only search 2 repositories '\n 'for Rez packages to run on, at most\".',\n )\n\n parser.add_argument(\n \"-z\",\n \"--maximum-rez-packages\",\n default=sys.maxsize,\n type=int,\n help='If a value of `2` is used, it means \"Only search for 2 Rez packages '\n 'to run some comm on, at most\".',\n )\n\n parser.add_argument(\n \"-p\",\n \"--packages-path\",\n default=[config.release_packages_path], # pylint: disable=no-member\n help=\"A `{os.pathsep}` separated list of paths that report/run will be run on. \"\n \"If not defined, `rez.config.config.release_packages_path` is used, instead.\".format(\n os=os\n ),\n )\n\n parser.add_argument(\n \"-s\",\n \"--search-packages-path\",\n default=[config.release_packages_path], # pylint: disable=no-member\n help=\"A `{os.pathsep}` separated list of paths to search for Rez package dependencies. \"\n \"If not defined, `rez.config.config.release_packages_path` is used, instead.\".format(\n os=os\n ),\n )\n\n parser.add_argument(\n \"-i\",\n \"--ignore-patterns\",\n default=[],\n nargs=\"*\",\n help=\"A set of glob expressions or a file to a set of glob expressions. \"\n \"If a Rez package name matches one of \"\n \"these, it will not be run on.\",\n )\n\n parser.add_argument(\n \"-k\",\n \"--keep-temporary-files\",\n action=\"store_true\",\n help=\"If added, do not delete any temporary files that are generated during this run.\",\n )\n\n parser.add_argument(\n \"-r\",\n \"--rez-packages\",\n default=set(),\n nargs=\"+\",\n help=\"The names of Rez packages to process. If no names are given, \"\n \"every Rez package that is found will be processed.\",\n )\n\n parser.add_argument(\n \"-t\",\n \"--temporary-directory\",\n help=\"A folder on-disk that will be used to clone git repositories.\",\n )","def __main__():\n parser = argparse.ArgumentParser(description='Facebook ID Finder')\n parser.add_argument('--username', '-u', dest='username', help='Username to search for')\n parser.add_argument('--version', '-v', action='version', version='%(prog)s 0.1')\n args = parser.parse_args()\n ausername = args.username\n\n if not args.username:\n sys.exit(parser.print_help())\n else:\n search_username(ausername)","def treatCmdOpts(argv):\n helpTxt = os.path.basename(__file__) + ' reads RINEX observation files and lists available information'\n\n # create the parser for command line arguments\n parser = argparse.ArgumentParser(description=helpTxt)\n\n parser.add_argument('-r', '--obsRnx', help='rinex observation file', required=True, type=str)\n parser.add_argument('-d', '--dirRnx', help='Directory of RINEX file (default {:s})'.format(colored('./', 'green')), required=False, default='.', type=str)\n parser.add_argument('-i', '--interval', help='interval in sec for scanning observation file (default {interval:s} s)'.format(interval=colored(600, 'green')), default=600, type=int, required=False, action=interval_action)\n\n # parser.add_argument('-o', '--obs_type', help='select observation types to plot (default {:s})'.format(colored('C', 'green')), default='C', choices=['C', 'S', 'D', 'L'], nargs='+', type=str)\n # parser.add_argument('-s', '--sat_syst', help='select GNNSs (default to {:s})'.format(colored('E', 'green')), default='E', choices=['E', 'G'], nargs='+', type=str)\n # parser.add_argument('-f', '--freqs', help='select frequency bands (default to {:s})'.format(colored('all', 'green')), default='all', nargs='+', action=freq_action)\n # parser.add_argument('-p', '--prn', help='select PRNs (default {:s})'.format(colored('all', 'green')), default='all', action=prn_action, nargs='+')\n\n parser.add_argument('-l', '--logging', help='specify logging level console/file (default {:s})'.format(colored('INFO DEBUG', 'green')), nargs=2, required=False, default=['INFO', 'DEBUG'], action=logging_action)\n\n # parser.add_argument('-l', '--logging', help='specify logging level console/file (default {:s})'.format(colored('INFO DEBUG', 'green')), nargs=2, required=False, default=['INFO', 'DEBUG'], choices=['CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG', 'NOTSET'])\n\n args = parser.parse_args()\n\n return args.obsRnx, args.dirRnx, args.interval, args.logging","def main(argv: Optional[List[str]] = None) -> None: # pragma: no cover, proxy\n if argv is None:\n argv = sys.argv[1:]\n\n app = reducto.Reducto()\n app.run(argv)","def parse_args():\n parser = argparse.ArgumentParser(description=\"Bandits algorithms on a click-through \"\n \"rate dataset.\")\n parser.add_argument('--plot', action='store_true')\n return parser.parse_args()","def handle_args():\n parser = argparse.ArgumentParser(\n description=\"\"\"Script to download archives from the NLM public\n FTP server.\n \"\"\")\n # Server settings\n server_settings = parser.add_argument_group('FTP SERVER SETTINGS', '')\n server_settings.add_argument(\n '-n', '--netrc', default='~/.netrc',\n help=\"\"\"netrc file containing login parameters for the NLM\n server. See `man 5 netrc` for details on generating this\n file or read nlm_data_import/netrc/example.netrc.\n \"\"\")\n server_settings.add_argument(\n 'server_data_dir',\n help='Directory containing desired files on the NLM FTP server')\n server_settings.add_argument(\n '-l', '--limit', type=int, default=0,\n help='Only download LIMIT files.')\n\n # Download settings\n local_settings = parser.add_argument_group('LOCAL SETTINGS', '')\n local_settings.add_argument(\n '-d', '--download_database', default='~/.ftp_download_db',\n help='Path to SQLite database detailing past downloads')\n local_settings.add_argument(\n '-o', '--output_dir', default='~/medline_data',\n help='Directory where downloads will be saved')\n local_settings.add_argument(\n '-x', '--export_dir', default='~/medline_data_exports',\n help=\"\"\"Directory where data to be retrieved by the\n `hypothesis_graph application server are staged.\n \"\"\")\n # Sending debug emails (requires the send_ses_messages module - see\n # setup.py)\n debugging_settings = parser.add_argument_group('DEBUGGING SETTINGS', '')\n debugging_settings.add_argument(\n '--email_debugging', default=False, action='store_true',\n help=\"Send debugging emails. Defaults to FALSE.\")\n debugging_settings.add_argument(\n '--from_email', required=False, help=\"FROM field for debugging emails\")\n debugging_settings.add_argument(\n '--to_email', required=False, help=\"TO field for debugging emails\")\n\n return parser.parse_args()","def launch_cli() -> None:\n app.run(main, flags_parser=_parse_flags)","def main(args=None):\n pass","def libdoc_cli(arguments):\n LibDoc().execute_cli(arguments)","def parse_arguments(text):\n text, needs_subparser_help = _process_help(text)\n\n parser = argparse.ArgumentParser(\n description=\"Find Rez packages to change using a command.\"\n )\n parser.add_argument(\n \"-v\",\n \"--verbose\",\n action=\"store_true\",\n help=\"Print debug messages when this flag is included.\",\n )\n\n sub_parsers = parser.add_subparsers(\n title=\"commands\", description=\"The available command that can be run.\"\n )\n\n reporter = sub_parsers.add_parser(\"report\")\n reporter.set_defaults(execute=__report)\n _add_arguments(reporter)\n\n runner = sub_parsers.add_parser(\"run\")\n runner.set_defaults(execute=__run)\n _add_arguments(runner)\n\n git_users_command = sub_parsers.add_parser(\"make-git-users\")\n git_users_command.set_defaults(execute=__make_git_users)\n git_users_command.add_argument(\n \"token\",\n help=\"The authentication token to the remote git repository (GitHub, bitbucket, etc).\",\n )\n git_users_command.add_argument(\n \"path\", help=\"The found users will be written to this JSON file path.\"\n )\n git_users_command.add_argument(\n \"-m\",\n \"--maximum-users\",\n default=sys.maxsize,\n type=int,\n help=\"This integer represents that maximum number of users to query. \"\n \"Set this value low to avoid long wait times.\",\n )\n git_users_command.add_argument(\n \"-b\",\n \"--base-url\",\n help=\"If you are authenticating to a non-standard remote \"\n \"(e.g. GitHub enterprise), use this flag to provide the URL.\",\n )\n git_users_command.add_argument(\n \"-s\", \"--ssl-no-verify\", action=\"store_false\", help=\"Disable SSL verification\"\n )\n\n arguments, unknown_arguments = parser.parse_known_args(text)\n\n if arguments.execute == __make_git_users:\n if needs_subparser_help:\n # display the help message for make-git-users\n parser.parse_known_args(text + [\"--help\"])\n\n sys.exit(0)\n\n # Run make-git-users\n arguments.execute(arguments)\n\n sys.exit(0)\n\n command_parser = registry.get_command(arguments.command)\n\n if not command_parser:\n print(\n 'Command \"{arguments.command}\" was not found. Options were \"{options}\".'\n \"\".format(arguments=arguments, options=sorted(registry.get_command_keys()))\n )\n\n sys.exit(cli_constant.NO_COMMAND_FOUND)\n\n if needs_subparser_help:\n unknown_arguments = unknown_arguments + [\"--help\"]\n\n command_arguments = command_parser.parse_arguments(unknown_arguments)\n\n return arguments, command_arguments","def cli():\n pass","def cli():\n pass","def cli():\n pass","def cli():\n pass","def cli():\n pass","def cli():\n pass","def cli():\n pass","def cli():\n pass","def cli():\n pass","def cli():\n pass","def cli():\n pass","def cli():\n pass","def cli():\n pass","def cli():\n pass","def cli():\n pass","def cli():\n pass","def cli():\n pass","def cli():\n pass","def cli():\n pass","def cli():\n pass","def cli():\n pass"],"string":"[\n \"def cli(args): # noqa; pylint: disable=unused-argument\",\n \"def main(args):\\n cli = CLI()\\n # Check arguments\\n cli.parse_arguments(args)\",\n \"def main(args):\",\n \"def main(args):\",\n \"def main():\\n licensify(_parse_args())\",\n \"def main(args=None):\",\n \"def main(args=None):\",\n \"def query_cmdline():\",\n \"def main(args, fLOG=print):\\n try:\\n from .parsers.folders import read_folder\\n except ImportError: # pragma: no cover\\n from manydataapi.parsers.folders import read_folder\\n\\n fcts = dict(read_folder=read_folder)\\n from pyquickhelper.cli import cli_main_helper\\n return cli_main_helper(fcts, args=args, fLOG=fLOG)\",\n \"def _parse_arguments(text):\\n parser = argparse.ArgumentParser(\\n description=\\\"Build Python-based Rez packages in just a single command.\\\",\\n )\\n\\n parser.add_argument(\\n \\\"--hdas\\\",\\n nargs=\\\"+\\\",\\n help=\\\"The relative paths to each folder containing VCS-style Houdini HDAs.\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-i\\\",\\n \\\"--items\\\",\\n nargs=\\\"+\\\",\\n help=\\\"The relative paths to each file/folder to copy / install.\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-e\\\",\\n \\\"--eggs\\\",\\n nargs=\\\"+\\\",\\n help=\\\"The relative paths to each file/folder to make into a .egg file.\\\",\\n )\\n\\n parser.add_argument(\\n \\\"--symlink\\\",\\n action=\\\"store_true\\\",\\n default=linker.must_symlink(),\\n help=\\\"If True, symlink everything back to the source Rez package.\\\",\\n )\\n\\n parser.add_argument(\\n \\\"--symlink-files\\\",\\n action=\\\"store_true\\\",\\n default=linker.must_symlink_files(),\\n help=\\\"If True, symlink files back to the source Rez package.\\\",\\n )\\n\\n parser.add_argument(\\n \\\"--symlink-folders\\\",\\n action=\\\"store_true\\\",\\n default=linker.must_symlink_folders(),\\n help=\\\"If True, symlink folders back to the source Rez package.\\\",\\n )\\n\\n known, _ = parser.parse_known_args(text)\\n\\n return known\",\n \"def parse_command_line_arguments():\\n parser = argparse.ArgumentParser(\\n description=\\\"Convert dependency files into list of GitHub links.\\\",\\n epilog=\\\"For help with this program, contact John Speed at jmeyers@iqt.org.\\\",\\n )\\n parser.add_argument(\\n \\\"--python\\\",\\n default=False, # default value is False\\n help=\\\"Convert requirements.txt file into GitHub links.\\\",\\n )\\n return parser.parse_args()\",\n \"def package_finder(argv):\\n # We instantiate an InstallCommand and then use some of its private\\n # machinery--its arg parser--for our own purposes, like a virus. This\\n # approach is portable across many pip versions, where more fine-grained\\n # ones are not. Ignoring options that don't exist on the parser (for\\n # instance, --use-wheel) gives us a straightforward method of backward\\n # compatibility.\\n try:\\n command = InstallCommand()\\n except TypeError:\\n # This is likely pip 1.3.0's \\\"__init__() takes exactly 2 arguments (1\\n # given)\\\" error. In that version, InstallCommand takes a top=level\\n # parser passed in from outside.\\n from pip.baseparser import create_main_parser\\n command = InstallCommand(create_main_parser())\\n # The downside is that it essentially ruins the InstallCommand class for\\n # further use. Calling out to pip.main() within the same interpreter, for\\n # example, would result in arguments parsed this time turning up there.\\n # Thus, we deepcopy the arg parser so we don't trash its singletons. Of\\n # course, deepcopy doesn't work on these objects, because they contain\\n # uncopyable regex patterns, so we pickle and unpickle instead. Fun!\\n options, _ = loads(dumps(command.parser)).parse_args(argv)\\n\\n # Carry over PackageFinder kwargs that have [about] the same names as\\n # options attr names:\\n possible_options = [\\n 'find_links', 'use_wheel', 'allow_external', 'allow_unverified',\\n 'allow_all_external', ('allow_all_prereleases', 'pre'),\\n 'process_dependency_links']\\n kwargs = {}\\n for option in possible_options:\\n kw, attr = option if isinstance(option, tuple) else (option, option)\\n value = getattr(options, attr, MARKER)\\n if value is not MARKER:\\n kwargs[kw] = value\\n\\n # Figure out index_urls:\\n index_urls = [options.index_url] + options.extra_index_urls\\n if options.no_index:\\n index_urls = []\\n index_urls += getattr(options, 'mirrors', [])\\n\\n # If pip is new enough to have a PipSession, initialize one, since\\n # PackageFinder requires it:\\n if hasattr(command, '_build_session'):\\n kwargs['session'] = command._build_session(options)\\n\\n return PackageFinder(index_urls=index_urls, **kwargs)\",\n \"def get_cli_arguments(self):\\n pass\",\n \"def main(self):\\n\\n argprs = argvparse.Argparse()\\n\\n lines = []\\n\\n if not argprs.files:\\n self.read_user_input()\\n lines.append(self.commandline)\\n self.send_lines_to_finditer(argprs.regex, lines,\\n argprs.underscore, argprs.color, argprs.machine)\\n else:\\n # print argprs.files\\n for fl in argprs.files:\\n try:\\n filerd = fileread.Fileread(fl)\\n self.send_lines_to_finditer(argprs.regex, filerd.lines,\\n argprs.underscore, argprs.color, argprs.machine,\\n filerd.shortfilename)\\n except Exception as e:\\n print str(e), \\\"\\\\n\\\"\",\n \"def parse_command_line(argv):\\n import argparse\\n parser = argparse.ArgumentParser(\\n description=\\\"\\\"\\\"\\\\\\nShow information about a list of scales in Neuroglancer \\\"info\\\" JSON file format\\n\\\"\\\"\\\")\\n parser.add_argument(\\\"info_file\\\", nargs=\\\"?\\\", default=\\\"./info\\\",\\n help=\\\"JSON file containing the information\\\")\\n args = parser.parse_args(argv[1:])\\n return args\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def cli():\",\n \"def parse_args(argv: list[str]) -> argparse.Namespace:\\n os_release = platform.freedesktop_os_release()\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n \\\"-c\\\",\\n \\\"--chroot\\\",\\n default=os_release[\\\"VERSION_CODENAME\\\"],\\n help=\\\"Specify a chroot or active session to use. (default: use current distribution\\\"\\n \\\" codename '%(default)s')\\\",\\n )\\n parser.add_argument(\\n \\\"-d\\\",\\n \\\"--directory\\\",\\n default=os.getcwd(),\\n help=\\\"Change to directory inside the chroot before running the command or login shell.\\\"\\n \\\" Use the current directory if it exists in the chroot. Otherwise fall back to the user's\\\"\\n \\\" home directory (and create the directory if it is missing).\\\",\\n )\\n parser.add_argument(\\n \\\"-u\\\",\\n \\\"--user\\\",\\n default=getpass.getuser(),\\n help=\\\"Run as a different user. The default is to run as %(default)s and fallback to root\\\"\\n \\\" if that user does not exist in the chroot.\\\",\\n )\\n parser.add_argument(\\n \\\"-p\\\",\\n \\\"--packages\\\",\\n default=[],\\n action=\\\"append\\\",\\n help=\\\"List of comma- or space-separated packages that should be installed\\\"\\n \\\" without recommends. Can be specified multiple times.\\\",\\n )\\n parser.add_argument(\\n \\\"--ppa\\\",\\n default=[],\\n action=\\\"append\\\",\\n help=\\\"PPA APT sources that should be added. Can be specified multiple times.\\\",\\n )\\n parser.add_argument(\\n \\\"-e\\\", \\\"--enable-proposed\\\", action=\\\"store_true\\\", help=\\\"Enable -proposed pocket.\\\"\\n )\\n parser.add_argument(\\n \\\"--proposed-uri\\\",\\n default=\\\"http://archive.ubuntu.com/ubuntu\\\",\\n help=\\\"Sources list URI to use for -proposed (default: %(default)s)\\\",\\n )\\n parser.add_argument(\\n \\\"--proposed-components\\\",\\n default=\\\"main,universe\\\",\\n help=\\\"List of comma- or space-separated components to use for -proposed\\\"\\n \\\" (default: %(default)s)\\\",\\n )\\n\\n args = parser.parse_args(argv)\\n args.packages = [p for packages in args.packages for p in re.split(\\\"[, ]\\\", packages)]\\n args.proposed_components = re.split(\\\"[, ]\\\", args.proposed_components)\\n\\n return args\",\n \"def parse_cli_args():\\r\\n parser = argparse.ArgumentParser(\\r\\n description=\\\"list all installed packages\\\")\\r\\n\\r\\n parser.add_argument(\\\"-v\\\", \\\"--verbose\\\",\\r\\n help=\\\"increase output verbosity\\\",\\r\\n action=\\\"store_true\\\")\\r\\n\\r\\n parser.add_argument(\\\"-d\\\", \\\"--debug\\\",\\r\\n help=\\\"enable debug output\\\",\\r\\n action=\\\"store_true\\\")\\r\\n\\r\\n parser.add_argument(\\\"-N\\\", \\\"--dry-run\\\",\\r\\n help=\\\"Do not perform any actions, only simulate them.\\\",\\r\\n action=\\\"store_true\\\")\\r\\n\\r\\n args = parser.parse_args()\\r\\n\\r\\n # set debug log state\\r\\n DebugLog.enabled = args.debug\\r\\n\\r\\n with DebugLogScopedPush(\\\"cli arguments:\\\"):\\r\\n DebugLog.print(str(args))\\r\\n\\r\\n return args\",\n \"def main():\\n args = parse_args()\\n process_args(args)\",\n \"def command_line_arguments():\\n\\n try:\\n parser = argparse.ArgumentParser(description='Log Handler/Cleaner/Copier for Idemia DocAuth')\\n\\n # Add required arguments.\\n parser.add_argument('action', choices=['clean', 'download'], type=str, help='clean or download')\\n\\n # Parse the arguments\\n args = parser.parse_args()\\n\\n return args\\n\\n except Exception as err:\\n print(err)\\n return\",\n \"def parse_command_line():\\n parser = argparse.ArgumentParser(description='Parses ID\\\\'s from the DDI compendium search results, and then downloads the html and puts them into a sqlite database.')\\n parser.add_argument('-f', '--file', dest='file',\\n action='store',\\n help='Filenname to be read')\\n arg_manager = parser.parse_args()\\n return arg_manager\",\n \"def cli(**_) -> None:\\n pass\",\n \"def _ParseCommandArguments():\\n arg_parser = argparse.ArgumentParser()\\n arg_parser.usage = __doc__\\n\\n arg_parser.add_argument('--download-dir',\\n type=str,\\n required=True,\\n help='Directory into which corpora are downloaded.')\\n arg_parser.add_argument('--build-dir',\\n required=True,\\n type=str,\\n help='Directory where fuzzers were built.')\\n args = arg_parser.parse_args()\\n return args\",\n \"def cli():\\n config, auth, execute_now = read_command_line_arguments()\\n main(config, auth, execute_now)\",\n \"def cli_options():\\n\\n parser = argparse.ArgumentParser(\\n description='c[apirca]grep',\\n formatter_class=argparse.RawTextHelpFormatter\\n )\\n\\n parser.add_argument('-d', '--def', dest='defs',\\n help='Network Definitions directory location. \\\\n',\\n default='./def')\\n\\n # -i and -t can be used together, but not with any other option.\\n ip_group = parser.add_argument_group()\\n # take 1 or more IPs\\n ip_group.add_argument('-i', '--ip', dest='ip', nargs='+', type=is_valid_ip,\\n help='Return list of definitions containing the '\\n 'IP(s).\\\\nMultiple IPs permitted.')\\n\\n ip_group.add_argument('-t', '--token', dest='token',\\n help=('See if an IP is contained within the given '\\n 'token.\\\\nMust be used in conjunction with '\\n '-i/--ip [addr].'))\\n\\n exclusive_group = parser.add_mutually_exclusive_group()\\n # the rest of the arguments are mutually exclusive with each other,\\n # and -i / -t\\n exclusive_group.add_argument('-c', '--cmp', dest='cmp', nargs=2,\\n metavar=('OBJ', 'OBJ'),\\n help=('Compare the two given network '\\n 'definition tokens'))\\n\\n exclusive_group.add_argument('-g', '--gmp', dest='gmp', nargs=2,\\n type=is_valid_ip, metavar=('IP', 'IP'),\\n help=('Diff the network objects to'\\n ' which the given IP(s) belong'))\\n\\n exclusive_group.add_argument('-o', '--obj', dest='obj', nargs='+',\\n help=('Return list of IP(s) contained within '\\n 'the given token(s)'))\\n\\n exclusive_group.add_argument('-s', '--svc', dest='svc', nargs='+',\\n help=('Return list of port(s) contained '\\n 'within given token(s)'))\\n\\n exclusive_group.add_argument('-p', '--port', dest='port', nargs=2,\\n metavar=('PORT', 'PROTO'),\\n help=('Returns a list of tokens containing '\\n 'the given port and protocol'))\\n\\n return parser\",\n \"def cmd_user(args):\",\n \"def parse_arguments(args):\",\n \"def setup():\\n try:\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--rows\\\", type=int, default=10, help=\\\"Number of rows to generate in demo file\\\")\\n parser.add_argument(\\\"--filename\\\", type=str, default=\\\"..//data//demo.csv\\\", help=\\\"Filename of demo data\\\")\\n parser.add_argument(\\\"--search_term\\\", type=str, default=\\\"Street\\\", help=\\\"Search term to look for in address info\\\")\\n args = parser.parse_args()\\n # generate_data_file(args.filename, args.rows)\\n return args\\n except Exception as e:\\n print(e)\\n exit(-1)\",\n \"def cli() -> None:\",\n \"def cli() -> None:\",\n \"def main():\\n if len(sys.argv) == 1:\\n print(\\\"Usage:\\\", sys.argv[0], \\\"<PyPI project name(s)>\\\")\\n return\\n # Things I want to resolve.\\n reqs = sys.argv[1:]\\n requirements = [Requirement(r) for r in reqs]\\n\\n # Create the (reusable) resolver.\\n provider = PyPIProvider()\\n reporter = BaseReporter()\\n resolver = Resolver(provider, reporter)\\n\\n # Kick off the resolution process, and get the final result.\\n print(\\\"Resolving\\\", \\\", \\\".join(reqs))\\n result = resolver.resolve(requirements)\\n display_resolution(result)\",\n \"def setup_cmd_args():\\n parser = argparse.ArgumentParser(description=\\\"This program will query G-POD and COPHUB on the same datasets, in order to obtain the number of data results, compare them compile a report with the differences.\\\", formatter_class=argparse.ArgumentDefaultsHelpFormatter)\\n # parser.add_argument(\\\"root_dir\\\", help=\\\"The root directory containing data to check\\\")\\n # parser.add_argument(\\\"--workspace\\\", help=\\\"Set Workspace manually\\\")\\n parser.add_argument(\\\"--outputlist\\\", help=\\\"Folder to write the output lists with the un-synced products.\\\", default=\\\"c:\\\\\\\\temp\\\\\\\\\\\")\\n parser.add_argument(\\\"--daysback\\\", help=\\\"Report with a given number of days back from today\\\", default=0)\\n parser.add_argument(\\\"--dataset\\\", help=\\\"Set which dataset to query (chose S3A_SR_1_SRA_A_PREOPS or S3B_SR_1_SRA_A_NTC)\\\")\\n parser.add_argument(\\\"--startdate\\\", help=\\\" The Start Date (format: YYYY-MM-DD) \\\", default=\\\"2016-06-01\\\")\\n parser.add_argument(\\\"--enddate\\\",help=\\\" The End Date (format: YYYY-MM-DD)\\\")\\n parser.add_argument(\\\"--cphubuser\\\",help=\\\"COPHUB username\\\", required=True)\\n parser.add_argument(\\\"--cphubpw\\\",help=\\\"COPHUB password\\\", required=True)\\n parser.add_argument(\\\"-email\\\", type=str, help=\\\"Email to send the results\\\", action=\\\"append\\\")\\n parser.add_argument('-t', action='store_true', help=\\\"Today as enddate. Otherwise the last day of the previous month is considered.\\\")\\n parser.add_argument('-n', action='store_true', help=\\\"Normal numeric check\\\")\\n parser.add_argument('-m', action='store_true', help=\\\"Monthly check with product listing.\\\")\\n return parser.parse_args()\",\n \"def parse_cli(argv):\\n possible_remits = ['pandoc', 'panzer', 'diff']\\n sourcelist = list()\\n remit = None\\n if len(argv) < 2 or argv[1] not in possible_remits:\\n print(__doc__)\\n sys.exit(1)\\n if len(argv) >= 2:\\n remit = argv[1]\\n if len(argv) > 2:\\n sourcelist = argv[2:]\\n return remit, sourcelist\",\n \"def cli():\\n ...\",\n \"def get_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"Sets up package within the pheeno's directory.\\\"\\n )\\n\\n # Required arguments\\n parser.add_argument(\\\"-x\\\", \\\"--execute\\\", action=\\\"execute\\\", required=True,\\n help=\\\"something\\\", default=False)\\n\\n # Optional arguments\\n parser.add_argument(\\\"-s\\\", \\\"--save\\\", action=\\\"store\\\", required=False,\\n help=\\\"something\\\", default=False)\",\n \"def get_args():\\n parser = argparse.ArgumentParser('Find a featureclass, database, mxd, or service in ArcGIS Server',\\n epilog='For search strings inlcuding spaces, enclose the query in double-quotes')\\n parser.add_argument('name', help='string for which to search (blank returns info on all services)',\\n nargs='?', default='')\\n parser.add_argument('-q', '--quiet', help='only display service names and URLs', action='store_true')\\n parser.add_argument('-qq', '--veryquiet', help='only display service URLs, comma delimited', action='store_true')\\n parser.add_argument('-cs', '--configstore', help='explicitly provide full path to config store', action='store')\\n parser.add_argument('-csv', '--tocsv', help='create csv output', action='store_true')\\n parser.add_argument('-md', '--markdown', help='create Markdown output', action='store_true')\\n return parser.parse_args()\",\n \"def get_cli(argv):\\n\\n global list_of_microRNAs\\n global priority \\n global size\\n global list_of_sequence\\n global distance\\n\\n try:\\n opts, args = getopt.getopt(argv, \\\"hl:p:s:q:d:\\\", ['help', 'list_of_microRNAs=', 'priority=', 'size=', 'list_of_sequence=', 'distance=' ])\\n except getopt.GetoptError as err:\\n print_help()\\n print str(err)\\n sys.exit(1)\\n \\n # parse the provided cli options\\n \\n for opt, arg in opts:\\n print opt, arg\\n if opt in ('-h', '--help'):\\n print_help()\\n sys.exit(0)\\n elif opt in ( '-l', '--list_of_microRNAs'):\\n list_of_microRNAs = arg\\n elif opt in ('-p', '--priority'):\\n priority = arg\\n elif opt in ('-s', '--size'):\\n size = int(arg)\\n elif opt in ('-q', '--list_of_sequence='):\\n list_of_sequence = arg\\n elif opt in ('-d', '--distance='):\\n distance = int(arg)\\n\\n # check wether or not all mandatory parameters have been provided\\n if not os.path.isfile(list_of_microRNAs) and os.path.isfile(priority) :\\n print_help()\\n print \\\"key missing\\\"\\n print \\\"Arguments given :\\\", list_of_microRNAs, priority\\n sys.exit(1)\\n \\n\\n \\n return\",\n \"def main(given_args):\\n opts = parse_args(given_args)\\n RUN_OPTS.opts = opts\\n\\n if 'debug' in opts:\\n RUN_OPTS.debug = opts['debug']\\n print_debug('debug enabled')\\n\\n # force interactive mode if no album(s) given\\n if len(opts['albums']) == 0 and not opts['interactive']:\\n print_debug(\\\"forcing interactive mode on\\\")\\n opts['interactive'] = True\\n\\n if opts['grep']:\\n try:\\n RUN_OPTS.title_pattern = re.compile(opts['grep'])\\n except Exception as error: # pylint: disable=broad-except\\n print(f\\\"ignoring invalid regex \\\\\\\"{opts['grep']}\\\\\\\": {error}\\\")\\n\\n nbr_albums = len(opts['albums'])\\n\\n print_debug(f\\\"{nbr_albums} album(s) given\\\")\\n\\n for album_id in opts['albums']:\\n if not album_id.isdigit():\\n print(\\\"albumId must be numeric\\\")\\n continue\\n if nbr_albums > 1:\\n print(f\\\"### album id {album_id} ###\\\")\\n\\n photos = get_photos(album_id)\\n\\n display_photos(photos)\\n\\n if opts['interactive']:\\n interactive_prompts()\",\n \"def parse_command_line(argv):\\n flags = 0\\n\\n usage = \\\"usage: %prog [options] name\\\"\\n\\n parser = optparse.OptionParser(add_help_option=False, usage=usage)\\n parser.add_option(\\\"-a\\\", \\\"--arin\\\", action=\\\"store_const\\\",\\n const=NICClient.ANICHOST, dest=\\\"whoishost\\\",\\n help=\\\"Lookup using host \\\" + NICClient.ANICHOST)\\n parser.add_option(\\\"-A\\\", \\\"--apnic\\\", action=\\\"store_const\\\",\\n const=NICClient.PNICHOST, dest=\\\"whoishost\\\",\\n help=\\\"Lookup using host \\\" + NICClient.PNICHOST)\\n parser.add_option(\\\"-b\\\", \\\"--abuse\\\", action=\\\"store_const\\\",\\n const=NICClient.ABUSEHOST, dest=\\\"whoishost\\\",\\n help=\\\"Lookup using host \\\" + NICClient.ABUSEHOST)\\n parser.add_option(\\\"-c\\\", \\\"--country\\\", action=\\\"store\\\",\\n type=\\\"string\\\", dest=\\\"country\\\",\\n help=\\\"Lookup using country-specific NIC\\\")\\n parser.add_option(\\\"-d\\\", \\\"--mil\\\", action=\\\"store_const\\\",\\n const=NICClient.DNICHOST, dest=\\\"whoishost\\\",\\n help=\\\"Lookup using host \\\" + NICClient.DNICHOST)\\n parser.add_option(\\\"-g\\\", \\\"--gov\\\", action=\\\"store_const\\\",\\n const=NICClient.GNICHOST, dest=\\\"whoishost\\\",\\n help=\\\"Lookup using host \\\" + NICClient.GNICHOST)\\n parser.add_option(\\\"-h\\\", \\\"--host\\\", action=\\\"store\\\",\\n type=\\\"string\\\", dest=\\\"whoishost\\\",\\n help=\\\"Lookup using specified whois host\\\")\\n parser.add_option(\\\"-i\\\", \\\"--nws\\\", action=\\\"store_const\\\",\\n const=NICClient.INICHOST, dest=\\\"whoishost\\\",\\n help=\\\"Lookup using host \\\" + NICClient.INICHOST)\\n parser.add_option(\\\"-I\\\", \\\"--iana\\\", action=\\\"store_const\\\",\\n const=NICClient.IANAHOST, dest=\\\"whoishost\\\",\\n help=\\\"Lookup using host \\\" + NICClient.IANAHOST)\\n parser.add_option(\\\"-l\\\", \\\"--lcanic\\\", action=\\\"store_const\\\",\\n const=NICClient.LNICHOST, dest=\\\"whoishost\\\",\\n help=\\\"Lookup using host \\\" + NICClient.LNICHOST)\\n parser.add_option(\\\"-m\\\", \\\"--ra\\\", action=\\\"store_const\\\",\\n const=NICClient.MNICHOST, dest=\\\"whoishost\\\",\\n help=\\\"Lookup using host \\\" + NICClient.MNICHOST)\\n parser.add_option(\\\"-p\\\", \\\"--port\\\", action=\\\"store\\\",\\n type=\\\"int\\\", dest=\\\"port\\\",\\n help=\\\"Lookup using specified tcp port\\\")\\n parser.add_option(\\\"-Q\\\", \\\"--quick\\\", action=\\\"store_true\\\",\\n dest=\\\"b_quicklookup\\\",\\n help=\\\"Perform quick lookup\\\")\\n parser.add_option(\\\"-r\\\", \\\"--ripe\\\", action=\\\"store_const\\\",\\n const=NICClient.RNICHOST, dest=\\\"whoishost\\\",\\n help=\\\"Lookup using host \\\" + NICClient.RNICHOST)\\n parser.add_option(\\\"-R\\\", \\\"--ru\\\", action=\\\"store_const\\\",\\n const=\\\"ru\\\", dest=\\\"country\\\",\\n help=\\\"Lookup Russian NIC\\\")\\n parser.add_option(\\\"-6\\\", \\\"--6bone\\\", action=\\\"store_const\\\",\\n const=NICClient.SNICHOST, dest=\\\"whoishost\\\",\\n help=\\\"Lookup using host \\\" + NICClient.SNICHOST)\\n parser.add_option(\\\"-n\\\", \\\"--ina\\\", action=\\\"store_const\\\",\\n const=NICClient.PANDIHOST, dest=\\\"whoishost\\\",\\n help=\\\"Lookup using host \\\" + NICClient.PANDIHOST)\\n parser.add_option(\\\"-?\\\", \\\"--help\\\", action=\\\"help\\\")\\n\\n return parser.parse_args(argv)\",\n \"def main():\\n parser = argparse.ArgumentParser(description=\\\"\\\"\\\"Tester for YT Data API and different inputs\\\"\\\"\\\")\\n parser.add_argument('-a', '--analytics', help='Performs a basic analytics lookup for the user\\\\'s channel entered')\\n parser.add_argument('-c', '--comments', help='Performs a lookup of comments for the video id entered')\\n args = parser.parse_args()\\n\\n if args.analytics:\\n analytics = args.analytics\\n analyt(analytics)\\n\\n if args.comments:\\n comments = args.comments\\n get_comments(comments)\",\n \"def main(args):\\n return add_command(args.directory, args.name, args.type, args.command, args.env_spec, args.supports_http_options)\",\n \"def cli():\\n return\",\n \"def cli():\\n\\n pass\",\n \"def _add_arguments(parser):\\n parser.add_argument(\\n \\\"command\\\",\\n help='The plugin to run. e.g. \\\"shell\\\".',\\n choices=sorted(registry.get_command_keys()),\\n )\\n\\n parser.add_argument(\\n \\\"-x\\\",\\n \\\"--maximum-repositories\\\",\\n default=sys.maxsize,\\n type=int,\\n help='If a value of `2` is used, it means \\\"Only search 2 repositories '\\n 'for Rez packages to run on, at most\\\".',\\n )\\n\\n parser.add_argument(\\n \\\"-z\\\",\\n \\\"--maximum-rez-packages\\\",\\n default=sys.maxsize,\\n type=int,\\n help='If a value of `2` is used, it means \\\"Only search for 2 Rez packages '\\n 'to run some comm on, at most\\\".',\\n )\\n\\n parser.add_argument(\\n \\\"-p\\\",\\n \\\"--packages-path\\\",\\n default=[config.release_packages_path], # pylint: disable=no-member\\n help=\\\"A `{os.pathsep}` separated list of paths that report/run will be run on. \\\"\\n \\\"If not defined, `rez.config.config.release_packages_path` is used, instead.\\\".format(\\n os=os\\n ),\\n )\\n\\n parser.add_argument(\\n \\\"-s\\\",\\n \\\"--search-packages-path\\\",\\n default=[config.release_packages_path], # pylint: disable=no-member\\n help=\\\"A `{os.pathsep}` separated list of paths to search for Rez package dependencies. \\\"\\n \\\"If not defined, `rez.config.config.release_packages_path` is used, instead.\\\".format(\\n os=os\\n ),\\n )\\n\\n parser.add_argument(\\n \\\"-i\\\",\\n \\\"--ignore-patterns\\\",\\n default=[],\\n nargs=\\\"*\\\",\\n help=\\\"A set of glob expressions or a file to a set of glob expressions. \\\"\\n \\\"If a Rez package name matches one of \\\"\\n \\\"these, it will not be run on.\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-k\\\",\\n \\\"--keep-temporary-files\\\",\\n action=\\\"store_true\\\",\\n help=\\\"If added, do not delete any temporary files that are generated during this run.\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-r\\\",\\n \\\"--rez-packages\\\",\\n default=set(),\\n nargs=\\\"+\\\",\\n help=\\\"The names of Rez packages to process. If no names are given, \\\"\\n \\\"every Rez package that is found will be processed.\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-t\\\",\\n \\\"--temporary-directory\\\",\\n help=\\\"A folder on-disk that will be used to clone git repositories.\\\",\\n )\",\n \"def __main__():\\n parser = argparse.ArgumentParser(description='Facebook ID Finder')\\n parser.add_argument('--username', '-u', dest='username', help='Username to search for')\\n parser.add_argument('--version', '-v', action='version', version='%(prog)s 0.1')\\n args = parser.parse_args()\\n ausername = args.username\\n\\n if not args.username:\\n sys.exit(parser.print_help())\\n else:\\n search_username(ausername)\",\n \"def treatCmdOpts(argv):\\n helpTxt = os.path.basename(__file__) + ' reads RINEX observation files and lists available information'\\n\\n # create the parser for command line arguments\\n parser = argparse.ArgumentParser(description=helpTxt)\\n\\n parser.add_argument('-r', '--obsRnx', help='rinex observation file', required=True, type=str)\\n parser.add_argument('-d', '--dirRnx', help='Directory of RINEX file (default {:s})'.format(colored('./', 'green')), required=False, default='.', type=str)\\n parser.add_argument('-i', '--interval', help='interval in sec for scanning observation file (default {interval:s} s)'.format(interval=colored(600, 'green')), default=600, type=int, required=False, action=interval_action)\\n\\n # parser.add_argument('-o', '--obs_type', help='select observation types to plot (default {:s})'.format(colored('C', 'green')), default='C', choices=['C', 'S', 'D', 'L'], nargs='+', type=str)\\n # parser.add_argument('-s', '--sat_syst', help='select GNNSs (default to {:s})'.format(colored('E', 'green')), default='E', choices=['E', 'G'], nargs='+', type=str)\\n # parser.add_argument('-f', '--freqs', help='select frequency bands (default to {:s})'.format(colored('all', 'green')), default='all', nargs='+', action=freq_action)\\n # parser.add_argument('-p', '--prn', help='select PRNs (default {:s})'.format(colored('all', 'green')), default='all', action=prn_action, nargs='+')\\n\\n parser.add_argument('-l', '--logging', help='specify logging level console/file (default {:s})'.format(colored('INFO DEBUG', 'green')), nargs=2, required=False, default=['INFO', 'DEBUG'], action=logging_action)\\n\\n # parser.add_argument('-l', '--logging', help='specify logging level console/file (default {:s})'.format(colored('INFO DEBUG', 'green')), nargs=2, required=False, default=['INFO', 'DEBUG'], choices=['CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG', 'NOTSET'])\\n\\n args = parser.parse_args()\\n\\n return args.obsRnx, args.dirRnx, args.interval, args.logging\",\n \"def main(argv: Optional[List[str]] = None) -> None: # pragma: no cover, proxy\\n if argv is None:\\n argv = sys.argv[1:]\\n\\n app = reducto.Reducto()\\n app.run(argv)\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"Bandits algorithms on a click-through \\\"\\n \\\"rate dataset.\\\")\\n parser.add_argument('--plot', action='store_true')\\n return parser.parse_args()\",\n \"def handle_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"\\\"\\\"Script to download archives from the NLM public\\n FTP server.\\n \\\"\\\"\\\")\\n # Server settings\\n server_settings = parser.add_argument_group('FTP SERVER SETTINGS', '')\\n server_settings.add_argument(\\n '-n', '--netrc', default='~/.netrc',\\n help=\\\"\\\"\\\"netrc file containing login parameters for the NLM\\n server. See `man 5 netrc` for details on generating this\\n file or read nlm_data_import/netrc/example.netrc.\\n \\\"\\\"\\\")\\n server_settings.add_argument(\\n 'server_data_dir',\\n help='Directory containing desired files on the NLM FTP server')\\n server_settings.add_argument(\\n '-l', '--limit', type=int, default=0,\\n help='Only download LIMIT files.')\\n\\n # Download settings\\n local_settings = parser.add_argument_group('LOCAL SETTINGS', '')\\n local_settings.add_argument(\\n '-d', '--download_database', default='~/.ftp_download_db',\\n help='Path to SQLite database detailing past downloads')\\n local_settings.add_argument(\\n '-o', '--output_dir', default='~/medline_data',\\n help='Directory where downloads will be saved')\\n local_settings.add_argument(\\n '-x', '--export_dir', default='~/medline_data_exports',\\n help=\\\"\\\"\\\"Directory where data to be retrieved by the\\n `hypothesis_graph application server are staged.\\n \\\"\\\"\\\")\\n # Sending debug emails (requires the send_ses_messages module - see\\n # setup.py)\\n debugging_settings = parser.add_argument_group('DEBUGGING SETTINGS', '')\\n debugging_settings.add_argument(\\n '--email_debugging', default=False, action='store_true',\\n help=\\\"Send debugging emails. Defaults to FALSE.\\\")\\n debugging_settings.add_argument(\\n '--from_email', required=False, help=\\\"FROM field for debugging emails\\\")\\n debugging_settings.add_argument(\\n '--to_email', required=False, help=\\\"TO field for debugging emails\\\")\\n\\n return parser.parse_args()\",\n \"def launch_cli() -> None:\\n app.run(main, flags_parser=_parse_flags)\",\n \"def main(args=None):\\n pass\",\n \"def libdoc_cli(arguments):\\n LibDoc().execute_cli(arguments)\",\n \"def parse_arguments(text):\\n text, needs_subparser_help = _process_help(text)\\n\\n parser = argparse.ArgumentParser(\\n description=\\\"Find Rez packages to change using a command.\\\"\\n )\\n parser.add_argument(\\n \\\"-v\\\",\\n \\\"--verbose\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Print debug messages when this flag is included.\\\",\\n )\\n\\n sub_parsers = parser.add_subparsers(\\n title=\\\"commands\\\", description=\\\"The available command that can be run.\\\"\\n )\\n\\n reporter = sub_parsers.add_parser(\\\"report\\\")\\n reporter.set_defaults(execute=__report)\\n _add_arguments(reporter)\\n\\n runner = sub_parsers.add_parser(\\\"run\\\")\\n runner.set_defaults(execute=__run)\\n _add_arguments(runner)\\n\\n git_users_command = sub_parsers.add_parser(\\\"make-git-users\\\")\\n git_users_command.set_defaults(execute=__make_git_users)\\n git_users_command.add_argument(\\n \\\"token\\\",\\n help=\\\"The authentication token to the remote git repository (GitHub, bitbucket, etc).\\\",\\n )\\n git_users_command.add_argument(\\n \\\"path\\\", help=\\\"The found users will be written to this JSON file path.\\\"\\n )\\n git_users_command.add_argument(\\n \\\"-m\\\",\\n \\\"--maximum-users\\\",\\n default=sys.maxsize,\\n type=int,\\n help=\\\"This integer represents that maximum number of users to query. \\\"\\n \\\"Set this value low to avoid long wait times.\\\",\\n )\\n git_users_command.add_argument(\\n \\\"-b\\\",\\n \\\"--base-url\\\",\\n help=\\\"If you are authenticating to a non-standard remote \\\"\\n \\\"(e.g. GitHub enterprise), use this flag to provide the URL.\\\",\\n )\\n git_users_command.add_argument(\\n \\\"-s\\\", \\\"--ssl-no-verify\\\", action=\\\"store_false\\\", help=\\\"Disable SSL verification\\\"\\n )\\n\\n arguments, unknown_arguments = parser.parse_known_args(text)\\n\\n if arguments.execute == __make_git_users:\\n if needs_subparser_help:\\n # display the help message for make-git-users\\n parser.parse_known_args(text + [\\\"--help\\\"])\\n\\n sys.exit(0)\\n\\n # Run make-git-users\\n arguments.execute(arguments)\\n\\n sys.exit(0)\\n\\n command_parser = registry.get_command(arguments.command)\\n\\n if not command_parser:\\n print(\\n 'Command \\\"{arguments.command}\\\" was not found. Options were \\\"{options}\\\".'\\n \\\"\\\".format(arguments=arguments, options=sorted(registry.get_command_keys()))\\n )\\n\\n sys.exit(cli_constant.NO_COMMAND_FOUND)\\n\\n if needs_subparser_help:\\n unknown_arguments = unknown_arguments + [\\\"--help\\\"]\\n\\n command_arguments = command_parser.parse_arguments(unknown_arguments)\\n\\n return arguments, command_arguments\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\",\n \"def cli():\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67388576","0.66946054","0.6388412","0.6388412","0.63570476","0.62585646","0.62585646","0.62556493","0.6208808","0.62030077","0.61873835","0.61870766","0.6160379","0.6157867","0.6155319","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.60664207","0.605335","0.604796","0.60141855","0.5987668","0.5986255","0.5962663","0.5951987","0.59324104","0.59234667","0.5920498","0.59201634","0.5919225","0.5896708","0.5896708","0.5895509","0.587566","0.5869073","0.58581436","0.5848123","0.58432573","0.5843087","0.58004665","0.57906806","0.57862866","0.578617","0.57826054","0.57677287","0.5765601","0.5765586","0.5761109","0.5740085","0.5733313","0.5730273","0.5729654","0.57204956","0.5716233","0.5715859","0.57130295","0.5708892","0.5708892","0.5708892","0.5708892","0.5708892","0.5708892","0.5708892","0.5708892","0.5708892","0.5708892","0.5708892","0.5708892","0.5708892","0.5708892","0.5708892","0.5708892","0.5708892","0.5708892","0.5708892","0.5708892"],"string":"[\n \"0.67388576\",\n \"0.66946054\",\n \"0.6388412\",\n \"0.6388412\",\n \"0.63570476\",\n \"0.62585646\",\n \"0.62585646\",\n \"0.62556493\",\n \"0.6208808\",\n \"0.62030077\",\n \"0.61873835\",\n \"0.61870766\",\n \"0.6160379\",\n \"0.6157867\",\n \"0.6155319\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.60664207\",\n \"0.605335\",\n \"0.604796\",\n \"0.60141855\",\n \"0.5987668\",\n \"0.5986255\",\n \"0.5962663\",\n \"0.5951987\",\n \"0.59324104\",\n \"0.59234667\",\n \"0.5920498\",\n \"0.59201634\",\n \"0.5919225\",\n \"0.5896708\",\n \"0.5896708\",\n \"0.5895509\",\n \"0.587566\",\n \"0.5869073\",\n \"0.58581436\",\n \"0.5848123\",\n \"0.58432573\",\n \"0.5843087\",\n \"0.58004665\",\n \"0.57906806\",\n \"0.57862866\",\n \"0.578617\",\n \"0.57826054\",\n \"0.57677287\",\n \"0.5765601\",\n \"0.5765586\",\n \"0.5761109\",\n \"0.5740085\",\n \"0.5733313\",\n \"0.5730273\",\n \"0.5729654\",\n \"0.57204956\",\n \"0.5716233\",\n \"0.5715859\",\n \"0.57130295\",\n \"0.5708892\",\n \"0.5708892\",\n \"0.5708892\",\n \"0.5708892\",\n \"0.5708892\",\n \"0.5708892\",\n \"0.5708892\",\n \"0.5708892\",\n \"0.5708892\",\n \"0.5708892\",\n \"0.5708892\",\n \"0.5708892\",\n \"0.5708892\",\n \"0.5708892\",\n \"0.5708892\",\n \"0.5708892\",\n \"0.5708892\",\n \"0.5708892\",\n \"0.5708892\",\n \"0.5708892\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21991,"cells":{"query":{"kind":"string","value":"Print out every package and its status information. This function prints out Packages that were found as \"invalid\" Packages that were skipped automatically Packages that were ignored explicitly (by the user)"},"document":{"kind":"string","value":"def __report(arguments, _):\n ignored_packages, other_packages, invalid_packages, skips = __gather_package_data(\n arguments\n )\n\n packages, invalids = worker.report(\n other_packages,\n maximum_repositories=arguments.maximum_repositories,\n maximum_rez_packages=arguments.maximum_rez_packages,\n )\n\n invalids.extend(invalid_packages)\n\n _print_ignored(ignored_packages)\n print(\"\\n\")\n _print_skips(skips, arguments.verbose)\n print(\"\\n\")\n _print_invalids(invalids, arguments.verbose)\n print(\"\\n\")\n _print_missing(packages, arguments.verbose)\n\n sys.exit(0)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _print_missing(packages, verbose):\n if not packages:\n print(\"## No Rez packages were found.\")\n print(\"No data found\")\n\n return\n\n print(\"## Your command affects these Rez packages.\")\n\n template = \"{package.name}\"\n\n if verbose:\n template = \"{package.name}: {path}\"\n\n for line in sorted(\n template.format(package=package, path=finder.get_package_root(package))\n for package in packages\n ):\n print(line)","def _print_ignored(packages):\n if not packages:\n print(\"## No Rez package was set to be ignored\")\n print(\"No data found\")\n\n return\n\n print(\"## Every package in this list was explicitly set to ignored by the user\")\n\n for package, pattern in sorted(packages, key=_get_package_name):\n print(\n 'Package: {package.name} - Pattern: \"{pattern}\"'.format(\n package=package, pattern=pattern\n )\n )","def _print_skips(skips, verbose):\n if not skips:\n print(\"## No packages were skipped\")\n print(\"Every found Rez package can be processed by the command.\")\n\n return\n\n print(\"## Packages were skipped from running a command. Here's the full list:\")\n\n template = \"{issue.package.name}: {issue.reason}\"\n\n if verbose:\n template = \"{issue.package.name}: {issue.path}: {issue.reason}\"\n\n for issue in skips:\n print(template.format(issue=issue))","def _print_invalids(invalids, verbose):\n if not invalids:\n print(\"## No Rez package was set as invalid.\")\n print(\"Nothing is invalid. Which is a good thing!\")\n\n return\n\n print(\"## Some packages were marked as invalid. Here's why:\")\n\n template = \"{package.name}: {message}\"\n\n if verbose:\n template = \"{package.name}: {path} {message}: {full}\"\n\n for message in sorted(\n (\n template.format(\n package=error.get_package(),\n path=error.get_path(),\n message=str(error),\n full=error.get_full_message(),\n )\n for error in invalids\n )\n ):\n print(message)","def show_missing():\n if missing_modules:\n info(\"The following modules are currently not installed and would enable additional tasks:\")\n for pkg_name in missing_modules:\n info(' ' + pkg_name)","def report(*packages):\n accepted_commands = ['python','conda']\n for package in packages:\n loc = \"not installed in this environment\"\n ver = \"unknown\"\n\n try:\n module = importlib.import_module(package)\n loc = os.path.dirname(module.__file__)\n\n try:\n ver = str(module.__version__)\n except Exception:\n pass\n \n except (ImportError, ModuleNotFoundError):\n if package in accepted_commands:\n try:\n # See if there is a command by that name and check its --version if so\n try:\n loc = subprocess.check_output(['command','-v', package]).decode().splitlines()[0].strip()\n except:\n # .exe in case powershell (otherwise wouldn't need it)\n loc = subprocess.check_output(['where.exe', package]).decode().splitlines()[0].strip() \n out = \"\"\n try:\n out = subprocess.check_output([package, '--version'], stderr=subprocess.STDOUT)\n except subprocess.CalledProcessError as e:\n out = e.output\n\n # Assume first word in output with a period and digits is the version\n for s in out.decode().split():\n if '.' in s and str.isdigit(s[0]) and sum(str.isdigit(c) for c in s)>=2:\n ver=s.strip()\n break\n except:\n pass\n elif package == 'system':\n try:\n ver = platform.platform(terse=True)\n loc = \"OS: \" + platform.platform()\n except Exception:\n pass\n else:\n pass\n \n print(\"{0:30} # {1}\".format(package + \"=\" + ver,loc))","def test_packages(self):\n for pkg in self.expected_packages:\n status, output = commands.getstatusoutput('pkg_info -qx %s' % pkg)\n assert status == 0","def list_packages(self):\n for tag, pkg in PACKAGES.iteritems():\n print \"{tag} - {label}\".format(tag=tag, label=pkg['label'])","def print_test_deps_not_in_package_deps(self):\n extras = []\n for key, rec_deps in self.recursive_pkg_deps.items():\n any = self.test_imports.get(key, set()).difference(rec_deps, set([key]))\n if any:\n extras.append((key, any))\n\n if extras:\n print(\"Packages whose tests have extra dependencies not listed in `go list -f {{.Deps}}`:\")\n for pkg, deps in extras:\n print(\"\\t{0}: {1}\".format(pkg, \", \".join(deps)))\n print(\"\\n\")","def check(force, verbose, packages):\n code = 0\n packages = CFG.package_specs(packages)\n if not packages:\n print(\"No packages installed\")\n sys.exit(0)\n\n for pspec in packages:\n desired = pspec.get_desired_version_info(force=force)\n dv = runez.bold(desired.version)\n manifest = pspec.get_manifest()\n if desired.problem:\n msg = desired.problem\n code = 1\n\n elif not manifest or not manifest.version:\n msg = \"v%s is not installed\" % dv\n code = 1\n\n elif manifest.version == desired.version:\n msg = \"v%s is installed\" % dv\n\n else:\n action = \"upgraded to\" if desired.source == \"latest\" else \"caught up to %s\" % desired.source\n msg = \"v%s installed, can be %s v%s\" % (runez.dim(manifest.version), action, dv)\n\n print(\"%s: %s\" % (pspec.dashed, msg))\n\n sys.exit(code)","def show_packagelist(user, repo, packages, distro=False, version=False,\n name=False, match=False, pkgtype=False):\n\n print('Currently {}/{} contains these matching packages:'.format(\n user, repo))\n\n numpkgs = 0\n for package in packages:\n if (distro and not package['distro_version'] == distro) or \\\n (version and not package['version'] == version) or \\\n (name and not package['name'] == name) or \\\n (pkgtype and not package['type'] == pkgtype) or \\\n (match and match not in package['filename']):\n continue\n\n print(fmt_pkg(user, repo, package))\n numpkgs += 1\n\n print(\"Repo contains {} matching packages.\".format(numpkgs))","def troubleshoot():\n libraries = (sys, pd, openpyxl, matplotlib, pip)\n for i in libraries:\n try:\n print(str(i), 'version:', i.__version__)\n except AttributeError:\n pass\n except ModuleNotFoundError:\n print('You do not have', str(i), 'installed.')\n print('You can do so via your interpreter or:')\n print('py -m pip install', '-' + str(i))\n print('in command prompt')","def _list_all(root_pkg, prog):\n res = \"\\n\".join(\n sorted(\n pkinspect.package_module_names(_import(root_pkg)),\n key=str.lower,\n ),\n )\n sys.stderr.write(f\"usage: {prog} module command [args...]\\nModules:\\n{res}\\n\")\n return 1","def log_imported_packages(self):\n imported_packages_dict = self.get_imported_packages()\n\n res_str = \"\\n\".join(f\"{module}: {version_num}\" for module, version_num\n in imported_packages_dict[\"results\"].items())\n no_res_str = \"\\n\".join(f\"{module}: {version_num}\" for module, version_num\n in imported_packages_dict[\"no_results\"].items())\n errs_res_str = \"\\n\".join(f\"{module}: {version_num}\" for module, version_num\n in imported_packages_dict[\"errors\"].items())\n\n msg = f\"Imported modules:\\n {res_str}\\n {no_res_str}\\n {errs_res_str}\"\n logger.info(msg)","def getMissingPackages(self, language=None, all=False, packages=None, showInstalled=False):\n if self._cache.broken_count > 0:\n raise SoftwareIndexBroken\n \n self.langpack_locales = {}\n self.pkg_translations = {}\n self.pkg_writing = {}\n filter_list = {}\n blacklist = []\n show = []\n self.missing = set()\n self.installed = set()\n self.system_pkgcode = ''\n \n for l in open(self.BLACKLIST):\n l = l.strip()\n if not l.startswith('#'):\n blacklist.append(l)\n \n for l in open(self.LANGCODE_TO_LOCALE):\n try:\n l = l.rstrip()\n if ':' in l:\n (pkgcode, locale) = l.split(':')\n else:\n pkgcode = l\n locale = l\n except ValueError:\n continue\n self.langpack_locales[locale] = pkgcode\n \n for l in open(self.PACKAGE_DEPENDS):\n if l.startswith('#'):\n continue\n try:\n l = l.rstrip()\n # sort out comments\n if l.find('#') >= 0:\n continue\n (c, lc, k, v) = l.split(':')\n except ValueError:\n continue\n if (c == 'tr' and lc == ''):\n filter_list[v] = k\n elif (c == 'wa' and lc != ''):\n if '|' in lc:\n for l in lc.split('|'):\n if not l in self.pkg_writing:\n self.pkg_writing[l] = []\n self.pkg_writing[l].append((\"%s\" % k, \"%s\" % v))\n else:\n if not lc in self.pkg_writing:\n self.pkg_writing[lc] = []\n self.pkg_writing[lc].append((\"%s\" % k, \"%s\" % v))\n\n # get list of all packages available on the system and filter them\n for item in self._cache.keys():\n if item in blacklist: \n continue\n for x in filter_list.keys():\n if item.startswith(x) and not item.endswith('-base'):\n # parse language code\n langcode = item.replace(x, '')\n #print \"%s\\t%s\" % (item, langcode)\n if langcode == 'zh':\n # special case: zh langpack split\n for langcode in ['zh-hans', 'zh-hant']:\n if not langcode in self.pkg_translations:\n self.pkg_translations[langcode] = []\n self.pkg_translations[langcode].append((\"%s\" % filter_list[x], \"%s\" % item))\n elif langcode in self.langpack_locales.values():\n # langcode == pkgcode\n if not langcode in self.pkg_translations:\n self.pkg_translations[langcode] = []\n self.pkg_translations[langcode].append((\"%s\" % filter_list[x], \"%s\" % item))\n #print self.pkg_translations[langcode]\n else:\n # need to scan for LL-CC and LL-VARIANT codes\n for locale in self.langpack_locales.keys():\n if '_' in locale or '@' in locale:\n if '@' in locale:\n (locale, variant) = locale.split('@')\n else:\n variant = ''\n (lcode, ccode) = locale.split('_')\n if langcode in [\"%s-%s\" % (lcode, ccode.lower()),\n \"%s%s\" % (lcode, ccode.lower()),\n \"%s-%s\" % (lcode, variant),\n \"%s%s\" % (lcode, variant),\n \"%s-latn\" % lcode,\n \"%slatn\" % lcode,\n \"%s-%s-%s\" % (lcode, ccode.lower(), variant),\n \"%s%s%s\" % (lcode, ccode.lower(), variant)]:\n # match found, get matching pkgcode\n langcode = self.langpack_locales[locale]\n if not langcode in self.pkg_translations:\n self.pkg_translations[langcode] = []\n self.pkg_translations[langcode].append((\"%s\" % filter_list[x], \"%s\" % item))\n #print self.pkg_translations[langcode]\n break\n\n if language:\n pkgcode = ''\n if language == 'zh-hans' or language == 'zh-hant':\n self.system_pkgcode = language\n elif language in self.langpack_locales:\n self.system_pkgcode = self.langpack_locales[language]\n else:\n # pkgcode = ll\n if '_' in language:\n (self.system_pkgcode) = language.split('_')[0]\n elif '@' in language:\n (self.system_pkgcode) = language.split('@')[0]\n else:\n self.system_pkgcode = language\n\n if packages:\n self.findPackages(self.system_pkgcode, packages)\n else:\n self.findPackages(self.system_pkgcode)\n \n elif all:\n # try all available languages\n pkgcodes = []\n for item in self._cache.keys():\n if item in blacklist:\n continue\n if item.startswith('language-pack-') and \\\n not item.startswith('language-pack-gnome') and \\\n not item.startswith('language-pack-kde') and \\\n not item.endswith('-base'):\n pkgcode = item.replace('language-pack-', '')\n pkgcodes.append(pkgcode)\n\n for pkgcode in pkgcodes:\n if packages:\n self.findPackages(pkgcode, packages)\n else:\n self.findPackages(pkgcode)\n\n else:\n # get a list of language-packs we have already installed or are going to install\n # 1. system locale\n system_langcode = self._localeinfo.getSystemDefaultLanguage()[0]\n if system_langcode == None:\n system_langcode = 'en_US'\n if system_langcode in self.langpack_locales:\n self.system_pkgcode = self.langpack_locales[system_langcode]\n # 2. installed language-packs\n pkgcodes = []\n for item in self._cache.keys():\n if item in blacklist: \n continue\n if item.startswith('language-pack-') and \\\n not item.startswith('language-pack-gnome') and \\\n not item.startswith('language-pack-kde') and \\\n not item.endswith('-base') and \\\n (self._cache[item].is_installed or \\\n self._cache[item].marked_install):\n pkgcode = item.replace('language-pack-', '')\n pkgcodes.append(pkgcode)\n if self.system_pkgcode and \\\n not self.system_pkgcode in pkgcodes:\n pkgcodes.append(self.system_pkgcode)\n \n for pkgcode in pkgcodes:\n if packages:\n self.findPackages(pkgcode, packages)\n else:\n self.findPackages(pkgcode)\n \n if showInstalled:\n show = self.missing | self.installed\n else:\n show = self.missing\n\n return show","def show_everything():\n \n #print(\"WARNING: This may take awhile. . .\\n\")\n # Need to find all hostgroups, and make sure there are no deuplicate machines in this calculation.\n print(\"This feature is still under construction. Check back soon!\")\n sys.exit(0)","def main():\n\n local_pkgs = set(os.listdir(GIT_FOLDER))\n local_pkgs = set([it.replace('.git', '') for it in local_pkgs])\n\n pkgdb_info = pkgdb_pkg_branch()\n\n pkgdb_pkgs = set(pkgdb_info.keys())\n\n ## Commented out as we keep the git of retired packages while they won't\n ## show up in the information retrieved from pkgdb.\n\n #if (local_pkgs - pkgdb_pkgs):\n #print 'Some packages are present locally but not on pkgdb:'\n #print ', '.join(sorted(local_pkgs - pkgdb_pkgs))\n\n if (pkgdb_pkgs - local_pkgs):\n print 'Some packages are present in pkgdb but not locally:'\n print ', '.join(sorted(pkgdb_pkgs - local_pkgs))\n\n tofix = set()\n for pkg in sorted(pkgdb_info):\n pkgdb_branches = pkgdb_info[pkg]\n git_branches = get_git_branch(pkg)\n diff = (pkgdb_branches - git_branches)\n if diff:\n print '%s missing: %s' % (pkg, ','.join(sorted(diff)))\n tofix.add(pkg)\n branch_package(pkg, diff)\n\n if tofix:\n print 'Packages fixed (%s): %s' % (\n len(tofix), ', '.join(sorted(tofix)))","def print_package_info(package):\r\n print(\"******************\")\r\n print(\"Product: %s\" % package[0]['description'])\r\n print(\"Price: %s$ monthly\" % package[0]['prices'][0]['recurringFee'])\r\n print(\"******************\")\r\n return","def _list_dependencies_info(\n out: Callable, ljust: int, package: str, dependencies: List[Requirement]\n):\n unicode = sys.stdout.encoding.lower().startswith(\"utf\")\n if unicode:\n ljust += 1\n\n not_found: List[Requirement] = list()\n for dep in dependencies:\n if dep.name == package:\n continue\n try:\n version_ = version(dep.name)\n except Exception:\n not_found.append(dep)\n continue\n\n # build the output string step by step\n output = f\"✔︎ {dep.name}\" if unicode else dep.name\n # handle version specifiers\n if len(dep.specifier) != 0:\n output += f\" ({str(dep.specifier)})\"\n output += \":\"\n output = output.ljust(ljust) + version_\n\n # handle special dependencies with backends, C dep, ..\n if dep.name in (\"matplotlib\", \"seaborn\") and version_ != \"Not found.\":\n try:\n from matplotlib import pyplot as plt\n\n backend = plt.get_backend()\n except Exception:\n backend = \"Not found\"\n\n output += f\" (backend: {backend})\"\n out(output + \"\\n\")\n\n if len(not_found) != 0:\n not_found = [\n f\"{dep.name} ({str(dep.specifier)})\"\n if len(dep.specifier) != 0\n else dep.name\n for dep in not_found\n ]\n if unicode:\n out(f\"✘ Not installed: {', '.join(not_found)}\\n\")\n else:\n out(f\"Not installed: {', '.join(not_found)}\\n\")","def verify_package_status(self):\n pass","def verify_package_status(self):\n pass","def pkg_not_found_mess(pkgname: str, reponame: str) -> None:\n meta = MainData()\n print(('{0}Package {1}{2} {0}not found in \\'{3}\\' '\n 'repository.{4}').format(meta.clrs['red'],\n meta.clrs['lcyan'],\n pkgname,\n reponame,\n meta.clrs['reset']))","def test_correctness_of_installed_rpm_packages(self):\n not_installed_packages = get_not_installed_rpm_packages()\n error_msg = linesep + 'List of not installed packages: '\n for package in not_installed_packages:\n error_msg += linesep + package\n self.assertFalse(not_installed_packages, error_msg)","def sort_packages(self) -> None:\n self.recommended_packages = []\n self.required_packages = []\n for package in self.repository_packages:\n try:\n output = self.guest.execute(Command('rpm', '-q', package), silent=True)\n assert output.stdout\n self.debug(f\"Package '{output.stdout.strip()}' already installed.\")\n except tmt.utils.RunError:\n if self.skip_missing:\n self.recommended_packages.append(package)\n else:\n self.required_packages.append(package)","def print_dependencies(pkg):\n\n for deptype in (\"build\", \"link\", \"run\"):\n color.cprint(\"\")\n color.cprint(section_title(\"%s Dependencies:\" % deptype.capitalize()))\n deps = sorted(pkg.dependencies_of_type(deptype))\n if deps:\n colify(deps, indent=4)\n else:\n color.cprint(\" None\")","def main():\n parser = setup_parser()\n args = parser.parse_args()\n\n global LOG\n if args.debug:\n LOG.setLevel(logging.DEBUG)\n\n changes = retrieve_pkgdb_change()\n LOG.debug('%s changes retrieved' % len(changes))\n orphaned = {}\n unorphaned = {}\n changed = {}\n for change in changes:\n pkg_name = change['msg']['package_listing']['package']['name']\n owner = change['msg']['package_listing']['owner']\n branch = change['msg']['package_listing']['collection']['branchname']\n user = change['msg']['agent']\n LOG.debug('%s changed to %s by %s on %s' % (\n pkg_name, owner, user, branch))\n pkg = PkgChange(\n name=pkg_name,\n summary=change['msg']['package_listing']['package']['summary'],\n branch=branch,\n new_owner=owner,\n user=user,\n )\n\n if owner == 'orphan':\n if pkg_name in orphaned:\n orphaned[pkg_name].add_branch(branch)\n else:\n orphaned[pkg_name] = pkg\n elif owner == user:\n if pkg_name in orphaned:\n del(orphaned[pkg_name])\n\n if pkg_name in unorphaned:\n unorphaned[pkg_name].add_branch(branch)\n else:\n unorphaned[pkg_name] = pkg\n else:\n if pkg_name in orphaned:\n del(orphaned[pkg_name])\n\n if pkg_name in changed:\n changed[pkg_name].add_branch(branch)\n else:\n changed[pkg_name] = pkg\n\n # Orphaned packages might have been deprecated:\n retired_info = retrieve_pkgdb_retired()\n retired = {}\n for pkg in retired_info:\n pkg_name = pkg['msg']['package_listing']['package']['name']\n LOG.debug('Retired: %s' % (pkg_name))\n if pkg_name in orphaned:\n pkg = orphaned[pkg_name]\n del(orphaned[pkg_name])\n pkg.new_owner = 'retired'\n retired[pkg_name] = pkg\n\n hours = int(DELTA) / 3600\n report = 'Change in ownership over the last %s hours\\n' % hours\n report += '=' * (40 + len(str(hours))) + '\\n'\n\n report += '\\n%s packages were orphaned\\n' % len(orphaned)\n report += '-' * (len(str(len(orphaned))) + 23) + '\\n'\n for pkg in orphaned:\n report += orphaned[pkg].to_string() + '\\n'\n report += ' ' * 5 + orphaned[pkg].summary + '\\n'\n report += ' ' * 5 + 'https://admin.fedoraproject.org/pkgdb/'\\\n 'acls/name/%s\\n' % orphaned[pkg].name\n\n report += '\\n%s packages unorphaned\\n' % len(unorphaned)\n report += '-' * (len(str(len(unorphaned))) + 20) + '\\n'\n for pkg in unorphaned:\n if unorphaned[pkg].unorphaned():\n report += unorphaned[pkg].to_string() + '\\n'\n\n report += '\\n%s packages were retired\\n' % len(retired)\n report += '-' * (len(str(len(retired))) + 23) + '\\n'\n for pkg in retired:\n report += retired[pkg].to_string() + '\\n'\n report += ' ' * 5 + retired[pkg].summary + '\\n'\n report += ' ' * 5 + 'https://admin.fedoraproject.org/pkgdb/'\\\n 'acls/name/%s\\n' % retired[pkg].name\n\n report += '\\n%s packages changed owner\\n' % len(changed)\n report += '-' * (len(str(len(changed))) + 23) + '\\n'\n for pkg in changed:\n if not changed[pkg].unorphaned():\n report += changed[pkg].to_string() + '\\n'\n\n report += '\\n\\nSources: https://github.com/pypingou/fedora-owner-change'\n\n if args.nomail:\n print report\n else:\n send_report(report)","def show_all(only_fails=True):\n\n if not MASTER.exists():\n os.makedirs(MASTER)\n members = inspect.getmembers(sys.modules[__name__])\n members = [f for f in members if 'test_' in f[0]]\n for member in members:\n print('Running %s...' % member[0], end='')\n if only_fails:\n try:\n member[1]()\n except AssertionError:\n member[1](show=True)\n db()\n else:\n member[1](show=True)\n db()","def show_all(only_fails=True):\n\n if not MASTER.exists():\n os.makedirs(MASTER)\n members = inspect.getmembers(sys.modules[__name__])\n members = [f for f in members if 'test_' in f[0]]\n for member in members:\n print('Running %s...' % member[0], end='')\n if only_fails:\n try:\n member[1]()\n except AssertionError:\n member[1](show=True)\n db()\n else:\n member[1](show=True)\n db()","def show_errors(self):\n\n if self.errors:\n print('Clean error in:')\n for file in self.errors:\n print(' %s' % file)","def checkPackageSummaries(root, level='class'):\n\n if level != 'class' and level != 'package' and level != 'method' and level != 'none':\n print('unsupported level: %s, must be \"class\" or \"package\" or \"method\" or \"none\"' % level)\n sys.exit(1)\n \n #for dirPath, dirNames, fileNames in os.walk('%s/lucene/build/docs/api' % root):\n\n if False:\n os.chdir(root)\n print()\n print('Run \"ant javadocs\" > javadocs.log...')\n if os.system('ant javadocs > javadocs.log 2>&1'):\n print(' FAILED')\n sys.exit(1)\n \n anyMissing = False\n if not os.path.isdir(root):\n checkClassSummaries(root)\n checkClassDetails(root)\n sys.exit(0)\n \n for dirPath, dirNames, fileNames in os.walk(root):\n\n if dirPath.find('/all/') != -1:\n # These are dups (this is a bit risk, eg, root IS this /all/ directory..)\n continue\n\n if 'package-summary.html' in fileNames:\n if (level == 'class' or level == 'method') and checkSummary('%s/package-summary.html' % dirPath):\n anyMissing = True\n for fileName in fileNames:\n fullPath = '%s/%s' % (dirPath, fileName)\n if not fileName.startswith('package-') and fileName.endswith('.html') and os.path.isfile(fullPath):\n if level == 'method':\n if checkClassSummaries(fullPath):\n anyMissing = True\n # always look for broken html, regardless of level supplied\n if checkClassDetails(fullPath):\n anyMissing = True\n \n if 'overview-summary.html' in fileNames: \n if level != 'none' and checkSummary('%s/overview-summary.html' % dirPath):\n anyMissing = True\n\n return anyMissing","def self_check(self):\n out = \"Loaded components\\n\"\n for package_name, package in sorted(self.packages.items()):\n out += \"\\t%s:\\n\" % package_name\n for c, fd in sorted(package.components.iteritems()):\n out += \"\\t\\t%s (%s)\\n\" % (c, fd.filename)\n\n LOG.info(out)\n\n for p in self.packages.values():\n for f in p.files:\n for id in f.requires:\n # This throws if it doesn't find something.\n try:\n self.get(id)\n except:\n LOG.exception(\"Error in: \" + f.filename)\n raise","def print_string(self):\n for x in self.minimal:\n print(\"min: %s\" % x)\n for x in self.also_installed:\n print(\"als: %s\" % x)\n for x in self.uninstalled:\n print(\"uni: %s\" % x)","def list_package(all: bool = False) -> List[List[str]]:\n if not all:\n pkgs_info = read_installation_records()\n else:\n pkgs_info = []\n for pkg in pkg_resources.working_set:\n pkgs_info.append([pkg.project_name, pkg.version])\n\n return pkgs_info","def status_all(self):\n output = (\n '[ + ] acpid',\n '[ - ] alsa-utils',\n '[ + ] anacron',\n '[ + ] apparmor',\n '[ + ] apport',\n '[ + ] avahi-daemon',\n '[ + ] bluetooth',\n '[ - ] bootmisc.sh',\n '[ - ] brltty',\n '[ - ] checkfs.sh',\n '[ - ] checkroot-bootclean.sh',\n '[ - ] checkroot.sh',\n '[ + ] console-setup',\n '[ + ] cron',\n '[ + ] cups',\n '[ + ] cups-browsed',\n '[ + ] dbus',\n '[ - ] dns-clean',\n '[ + ] grub-common',\n '[ - ] hostname.sh',\n '[ - ] hwclock.sh',\n '[ + ] irqbalance',\n '[ - ] kerneloops',\n '[ - ] killprocs',\n '[ + ] kmod',\n '[ + ] lightdm',\n '[ - ] mountall-bootclean.sh',\n '[ - ] mountall.sh',\n '[ - ] mountdevsubfs.sh',\n '[ - ] mountkernfs.sh',\n '[ - ] mountnfs-bootclean.sh',\n '[ - ] mountnfs.sh',\n '[ + ] network-manager',\n '[ + ] networking',\n '[ + ] ondemand',\n '[ + ] open-vm-tools',\n '[ - ] plymouth',\n '[ - ] plymouth-log',\n '[ - ] pppd-dns',\n '[ + ] procps',\n '[ - ] rc.local',\n '[ + ] resolvconf',\n '[ - ] rsync',\n '[ + ] rsyslog',\n '[ - ] saned',\n '[ - ] sendsigs',\n '[ + ] speech-dispatcher',\n '[ + ] thermald',\n '[ + ] udev',\n '[ + ] ufw',\n '[ - ] umountfs',\n '[ - ] umountnfs.sh',\n '[ - ] umountroot',\n '[ - ] unattended-upgrades',\n '[ + ] urandom',\n '[ - ] uuidd',\n '[ + ] whoopsie',\n '[ - ] x11-common')\n for l in output:\n self.write(l + '\\n')","def reCheckPackage(self, pid):\n data = self.db.getPackageData(pid)\n\n urls = []\n\n for pyfile in data.itervalues():\n if pyfile.status not in (DS.NA, DS.Finished, DS.Skipped):\n urls.append((pyfile.url, pyfile.pluginname))\n\n self.core.threadManager.createInfoThread(urls, pid)","def print_untested(self,result,cause=False):\n untested = result.get_untested()\n if untested:\n print ('=== UNTESTED '+('='*59))\n for u in untested:\n print (u.id)\n if cause:\n print (' ',u.get_cause())","def have_package_lists():\n return 'Filename:' in execute('apt-cache', 'show', 'python', check=False, capture=True)","def cli(paths, ignore, exit, debug, out_file):\n if ignore:\n ignore = ignore.split(\",\")\n\n package_issues = {}\n futures = []\n paths_glob = []\n for path in paths:\n glob_paths = glob(os.path.expanduser(path))\n if not glob_paths:\n print(\"Error: path spec %s didn't match any files\" % path)\n sys.exit(1)\n paths_glob.extend(glob_paths)\n with (DummyExecutor if debug else ProcessPoolExecutor)() as executor:\n for path in paths_glob:\n meta_file = os.path.join(path, \"meta.yaml\")\n if os.path.isfile(meta_file):\n futures.extend(_submit_verify_recipe(path, executor, ignore))\n elif path.endswith((\".tar.bz2\", \".tar\", \".conda\")):\n futures.append(executor.submit(_submit_verify_package, path, ignore))\n for f in tqdm.tqdm(as_completed(futures), total=len(futures), leave=False):\n path, issues = f.result()\n if issues:\n package_issues[path] = issues\n\n if out_file:\n with open(out_file, \"w\") as f:\n json.dump(package_issues, f)\n print(\"saved to %s\" % out_file)\n else:\n for path, issues in package_issues.items():\n print(\"-\" * len(path))\n print(path)\n print(\"-\" * len(path))\n for check in sorted(issues):\n try:\n print(check, file=sys.stderr)\n except UnicodeEncodeError:\n print(\n \"Could not print message for error code {} due to unicode error\".format(\n check.code\n ),\n file=sys.stderr,\n )\n\n if exit and package_issues:\n sys.exit(1)","def missing_tests(session):\n print('The following samples do not have tests:')\n for sample in set(ALL_SAMPLE_DIRECTORIES) - set(ALL_TESTED_SAMPLES):\n print('* {}'.format(sample))","async def diagnostic_report(d):\n msg = \"Diagnostic Report\\n\\n\"\n msg += \"All of the following programs must be installed (✔) on your computer before you can use Proof Wallet.\\n\\n\"\n for k, v in d.items():\n msg += f\"{k}: {'✔' if v else 'X'}\\n\"\n msg += \"\\nOnce all the programs are installed, press ENTER to proceed.\"\n return await ux_show_story(msg, ['\\r'])","def missing_requirements_command(args, packages=None, exit_on_failure=True):\n requirements_files = (\n args.requirements or Config.requirements_files or []\n )\n ignore_list = (\n args.ignore or Config.ignore_list or []\n )\n\n printer = Printer()\n if not validate_files(\n files=requirements_files,\n printer=printer,\n exit_on_failure=exit_on_failure):\n return False\n\n requirements = RequirementCollection()\n for requirements_file in requirements_files:\n requirements.extend(\n RequirementCollection.from_file(filepath=requirements_file)\n )\n\n packages = (\n packages or dependency_list(ignore_list=ignore_list)\n )\n\n missing = [\n (package, required_by)\n for package, required_by\n in missing_requirements(\n packages=packages,\n requirements=requirements,\n ignore_list=ignore_list\n )\n ]\n\n headers = [\n messages.PACKAGE,\n messages.REQUIRED,\n messages.REQUIRED_BY,\n ]\n\n tabular_data = []\n for package, requirers in missing:\n if requirers:\n for required_by, required_version in requirers:\n tabular_data.append([\n printer.colored_message(\n message=package.key,\n message_color=printer.color_package\n ),\n required_version,\n required_by.key,\n ])\n else:\n tabular_data.append([\n printer.colored_message(\n message=package.key,\n message_color=printer.color_package\n ),\n package.version.specifier,\n \"Requirements\",\n ])\n\n if tabular_data:\n printer.error(messages.MISSING_FOUND)\n printer.table(headers=headers, tabular_data=tabular_data)\n if exit_on_failure:\n sys.exit(1)\n return False\n\n printer.success(messages.MISSING_OK)\n return True","def list_cmd(repo):\n click.echo('Packages and scripts installed through pipsi:')\n for venv, scripts in repo.list_everything():\n if not scripts:\n continue\n click.echo(' Package \"%s\":' % venv)\n for script in scripts:\n click.echo(' ' + script)","def check_puppet_logs_ubuntu(self):\n\n remote = self.env.get_admin_remote()\n\n err_start = 'The following packages have unmet dependencies:'\n err_end = ('Unable to correct problems,'\n ' you have held broken packages.')\n cmd = ('fgrep -h -e \" Depends: \" -e \"{0}\" -e \"{1}\" '\n '/var/log/docker-logs/remote/node-*/'\n 'puppet*.log'.format(err_start, err_end))\n result = remote.execute(cmd)['stdout']\n\n err_deps = {}\n err_deps_key = ''\n err_deps_flag = False\n\n # Forming a dictionary of package names\n # with sets of required packages.\n for res_str in result:\n if err_deps_flag:\n if err_end in res_str:\n err_deps_flag = False\n elif \": Depends:\" in res_str:\n str0, str1, str2 = res_str.partition(': Depends:')\n err_deps_key = ''.join(str0.split()[-1:])\n if err_deps_key not in err_deps:\n err_deps[err_deps_key] = set()\n if 'but it is not' in str2 or 'is to be installed' in str2:\n err_deps[err_deps_key].add('Depends:{0}'\n .format(str2))\n elif 'Depends:' in res_str and err_deps_key:\n str0, str1, str2 = res_str.partition('Depends:')\n if 'but it is not' in str2 or 'is to be installed' in str2:\n err_deps[err_deps_key].add(str1 + str2)\n else:\n err_deps_key = ''\n elif err_start in res_str:\n err_deps_flag = True\n\n return err_deps","def required_packages(cls) -> List[Text]:\n return []","def recheck_conts_package(conts_dict, si_result):\n print('######## BEGIN CHECKING PACKAGES ? ########')\n packages = si_result.get('packages', True)\n description = si_result.get('description_of_goods', False)\n pUnit = None\n print(packages == description)\n\n if packages == description:\n conts_package = []\n for unit in current_app.config['CONTAINER_PACKAGE_UNITS']:\n re_unit = re.compile(\n r'(\\d+\\W*(' +\n unit + r'(s|S)?\\s?(\\Ws\\W|\\WS\\W)?' +\n r')\\W*)|(\\W*(' +\n unit + r'(s|S)?\\s?(\\Ws\\W|\\WS\\W)?' +\n r')\\W*\\d+)')\n units_result = re.findall(re_unit, packages)\n\n if (\n len(units_result) == len(conts_dict)\n ) or (\n len(units_result) == len(conts_dict) + 1\n ):\n for result in units_result:\n print(result)\n if len(result[0]) > len(unit):\n print('result[0]', result[0])\n conts_package.append(\n re.sub(r'[^\\d]+', '', result[0]))\n elif len(result[4]) > len(unit):\n print('result[4]', result[4])\n conts_package.append(\n re.sub(r'[^\\d]+', '', result[4]))\n\n if unit.isupper():\n pUnit = unit + 'S'\n else:\n pUnit = unit + 's'\n\n break\n\n if len(conts_package) >= len(conts_dict):\n for i, cont in enumerate(conts_dict):\n cont['packages'] = str(conts_package[i]) + ' ' + pUnit\n\n return conts_dict","def check(self, quiet=False, exclude=None):\n\n exclude = exclude if exclude else []\n missing = set()\n pkg_types = set()\n python_interpreters = set()\n vcs_types = set()\n\n # package-defined requirements check\n for pkg in self.pkgs:\n if pkg.type not in exclude:\n pkg_types.add(pkg.type)\n if pkg.vcs_type not in exclude:\n vcs_types.add(pkg.vcs_type)\n\n if pkg.type == PackageType.AUTOTOOLS:\n if pkg.autotools_autoreconf:\n if AUTORECONF_COMMAND not in exclude:\n if AUTORECONF.exists():\n self._verbose_exists(AUTORECONF)\n else:\n missing.add(AUTORECONF.tool)\n\n elif pkg.type == PackageType.PYTHON:\n if pkg.python_interpreter:\n if pkg.python_interpreter not in exclude:\n python_tool = PythonTool(pkg.python_interpreter)\n python_interpreters.add(python_tool)\n else:\n python_interpreters.add(PYTHON)\n\n if PackageType.AUTOTOOLS in pkg_types or PackageType.MAKE in pkg_types:\n if MAKE.exists():\n self._verbose_exists(MAKE)\n else:\n missing.add(MAKE.tool)\n\n if PackageType.CMAKE in pkg_types:\n if CMAKE.exists():\n self._verbose_exists(CMAKE)\n else:\n missing.add(CMAKE.tool)\n\n if PackageType.MESON in pkg_types:\n if MESON.exists():\n self._verbose_exists(MESON)\n else:\n missing.add(MESON.tool)\n\n if PackageType.PYTHON in pkg_types:\n for interpreter in python_interpreters:\n if interpreter.exists():\n self._verbose_exists(interpreter)\n else:\n missing.add(interpreter.tool)\n\n if PackageType.SCONS in pkg_types:\n if SCONS.exists():\n self._verbose_exists(SCONS)\n else:\n missing.add(SCONS.tool)\n\n if VcsType.BZR in vcs_types:\n if BZR.exists():\n self._verbose_exists(BZR)\n else:\n missing.add(BZR.tool)\n\n if VcsType.CVS in vcs_types:\n if CVS.exists():\n self._verbose_exists(CVS)\n else:\n missing.add(CVS.tool)\n\n if VcsType.GIT in vcs_types:\n if GIT.exists():\n self._verbose_exists(GIT)\n else:\n missing.add(GIT.tool)\n\n if VcsType.HG in vcs_types:\n if HG.exists():\n self._verbose_exists(HG)\n else:\n missing.add(HG.tool)\n\n if VcsType.PERFORCE in vcs_types:\n if GIT.exists():\n self._verbose_exists(GIT)\n else:\n missing.add(GIT.tool)\n\n if VcsType.RSYNC in vcs_types:\n if RSYNC.exists():\n self._verbose_exists(RSYNC)\n else:\n missing.add(RSYNC.tool)\n\n if VcsType.SCP in vcs_types:\n if SCP.exists():\n self._verbose_exists(SCP)\n else:\n missing.add(SCP.tool)\n\n if VcsType.SVN in vcs_types:\n if SVN.exists():\n self._verbose_exists(SVN)\n else:\n missing.add(SVN.tool)\n\n # project-provided tools check\n for tool in self.tools:\n if tool not in exclude:\n if which(tool):\n verbose('prerequisite exists: ' + tool)\n else:\n missing.add(tool)\n\n if missing and not quiet:\n sorted_missing = list(missing)\n sorted_missing.sort()\n\n msg = 'missing the following host tools for this project:'\n msg += '\\n'\n msg += '\\n'\n for entry in sorted_missing:\n msg += ' ' + entry + '\\n'\n err(msg)\n\n return len(missing) == 0","def package_info(self, package, repo):\n\n cmd_output = admin_tasks.yum_info(package, repo)\n if cmd_output:\n self.log.info(\"%s package exists\" % package)\n print(\"Command output: \\n\" + cmd_output)\n else:\n self.log.error(\"%s package was not found\" % package)\n sys.exit(1)","def getAllInstalledPackages(installedPkgPath):\n allPkgVers = []\n if os.path.exists(installedPkgPath):\n for pkg in os.listdir(installedPkgPath):\n pkgVersions = os.listdir(os.path.join(installedPkgPath, pkg))\n for pkgVersion in pkgVersions:\n pkgPath = os.path.join(installedPkgPath, pkg)\n if not fnmatch.fnmatch(pkgVersion, '*.inprogress'):\n allPkgVers.append(os.path.join(pkgPath, pkgVersion))\n return allPkgVers","def showerrors():\n errorMessages = middleware.ixn.showErrorMessage(silentMode=True)\n if errorMessages:\n print(errorMessages)\n print()","def test_all_package_avail(self):\n # Add 2 course packages to the table\n args = ('Best package', '10', '2020-04-04', '2023-05-06', '200.01')\n query = self.generate_query('add_course_package', args)\n res = self.execute_query(query)\n args = ('Best package2', '10', '2020-04-04', '2023-05-06', '200.01')\n query = self.generate_query('add_course_package', args)\n res = self.execute_query(query)\n\n # Check if there are 2 course package\n q = self.generate_query(\"get_available_course_packages\", ())\n res = self.execute_query(q)\n\n assert (\n len(res) == 2\n ), \"There should be 2 course packages available\"\n expected =set((('(\\\"Best package\\\",10,2023-05-06,200.01)',), ('(\\\"Best package2\\\",10,2023-05-06,200.01)',)))\n assert set(res) == expected, f'\\nOutput: {res}\\nExpected: {expected}'","def _info():\n\n emitter.publish(default_command_info(\"package\"))\n return 0","def log_installed_modules(self):\n\n # Get python modules installed locally\n\n installed_packages = pkg_resources.working_set\n\n python_str = f'python:{sys.version}\\n'\n print_str = \"\\n\".join(f\"{package.key}: {package.version}\" for package in installed_packages)\n msg = f\"Installed packages:\\n{python_str+print_str}\"\n logger.info(msg)","def report():\n\n global COUNTER\n \n if COUNTER > 0:\n print('\\n\\n')\n\n print('Searched {0} files'.format(SEARCHED))\n print('Found {0} TODOs in {1} files'.format(COUNTER, F_COUNTER))","def print_tests(pkg):\n\n # Some built-in base packages (e.g., Autotools) define callback (e.g.,\n # check) inherited by descendant packages. These checks may not result\n # in build-time testing if the package's build does not implement the\n # expected functionality (e.g., a 'check' or 'test' targets).\n #\n # So the presence of a callback in Spack does not necessarily correspond\n # to the actual presence of built-time tests for a package.\n for callbacks, phase in [\n (pkg.build_time_test_callbacks, \"Build\"),\n (pkg.install_time_test_callbacks, \"Install\"),\n ]:\n color.cprint(\"\")\n color.cprint(section_title(\"Available {0} Phase Test Methods:\".format(phase)))\n names = []\n if callbacks:\n for name in callbacks:\n if getattr(pkg, name, False):\n names.append(name)\n\n if names:\n colify(sorted(names), indent=4)\n else:\n color.cprint(\" None\")\n\n # PackageBase defines an empty install/smoke test but we want to know\n # if it has been overridden and, therefore, assumed to be implemented.\n color.cprint(\"\")\n color.cprint(section_title(\"Stand-Alone/Smoke Test Methods:\"))\n names = []\n pkg_cls = pkg if inspect.isclass(pkg) else pkg.__class__\n if has_test_method(pkg_cls):\n pkg_base = spack.package_base.PackageBase\n test_pkgs = [\n str(cls.test)\n for cls in inspect.getmro(pkg_cls)\n if issubclass(cls, pkg_base) and cls.test != pkg_base.test\n ]\n test_pkgs = list(set(test_pkgs))\n names.extend([(test.split()[1]).lower() for test in test_pkgs])\n\n # TODO Refactor START\n # Use code from package_base.py's test_process IF this functionality is\n # accepted.\n v_names = list(set([vspec.name for vspec in pkg.virtuals_provided]))\n\n # hack for compilers that are not dependencies (yet)\n # TODO: this all eventually goes away\n c_names = (\"gcc\", \"intel\", \"intel-parallel-studio\", \"pgi\")\n if pkg.name in c_names:\n v_names.extend([\"c\", \"cxx\", \"fortran\"])\n if pkg.spec.satisfies(\"llvm+clang\"):\n v_names.extend([\"c\", \"cxx\"])\n # TODO Refactor END\n\n v_specs = [spack.spec.Spec(v_name) for v_name in v_names]\n for v_spec in v_specs:\n try:\n pkg_cls = spack.repo.path.get_pkg_class(v_spec.name)\n if has_test_method(pkg_cls):\n names.append(\"{0}.test\".format(pkg_cls.name.lower()))\n except spack.repo.UnknownPackageError:\n pass\n\n if names:\n colify(sorted(names), indent=4)\n else:\n color.cprint(\" None\")","def check_import():\n print('[GenHub] Checking Python modules.')\n\n basemod = [('yaml', 'pyyaml'), ('pycurl', 'pycurl')]\n devmod = ['pep8', 'pytest', 'pytest-cov', 'coverage']\n\n packages = dict()\n for importname, packagename in basemod:\n try:\n importlib.import_module(importname)\n packages[packagename] = True\n except ImportError:\n packages[packagename] = False\n for packagename in devmod:\n try:\n importlib.import_module(packagename)\n packages[packagename] = True\n except ImportError:\n packages[packagename] = False\n\n rundep = False\n for pkg in packages:\n char = '+'\n msg = 'Installed.'\n if packages[pkg] is False:\n char = '-'\n msg = 'Not installed!'\n rundep = True\n print('%c package %-12s: %s' % (char, pkg, msg))\n if rundep is True:\n print('Please install these dependencies before proceding')\n print('')","def get_other_updates(self):\n self.composite_logger.log(\"\\nDiscovering 'other' packages...\")\n other_packages = []\n other_package_versions = []\n\n all_packages, all_package_versions = self.get_all_updates(True)\n security_packages, security_package_versions = self.get_security_updates()\n if len(security_packages) == 0 and 'CentOS' in str(self.env_layer.platform.linux_distribution()): # deliberately terminal - erring on the side of caution to avoid dissat in uninformed customers\n self.composite_logger.log_error(\"Please review patch management documentation for information on classification-based patching on YUM.\")\n error_msg = \"Classification-based patching is only supported on YUM if the computer is independently configured to receive classification information.\" \\\n \"Please remove classifications from update deployments to CentOS machines to bypass this error.\"\n self.status_handler.add_error_to_status(error_msg, Constants.PatchOperationErrorCodes.PACKAGE_MANAGER_FAILURE)\n raise Exception(error_msg, \"[{0}]\".format(Constants.ERROR_ADDED_TO_STATUS))\n\n for index, package in enumerate(all_packages):\n if package not in security_packages:\n other_packages.append(package)\n other_package_versions.append(all_package_versions[index])\n\n self.composite_logger.log(\"Discovered \" + str(len(other_packages)) + \" 'other' package entries.\")\n return other_packages, other_package_versions","def print_notices(cls, settings: Settings):\n if settings.get(\"wallet.type\", \"in_memory\").lower() == \"indy\":\n with Banner(border=\":\", length=80, file=sys.stderr) as banner:\n banner.centered(\"⚠ DEPRECATION NOTICE: ⚠\")\n banner.hr()\n banner.print(\n \"The Indy wallet type is deprecated, use Askar instead; see: \"\n \"https://aca-py.org/main/deploying/IndySDKtoAskarMigration/\",\n )\n print()","def report(self):\n print()\n print(\"%-15s %-25s %s\" % (\"Class\", \"Name\", \"File\"))\n print(\"%-15s %-25s %s\" % (\"-----\", \"----\", \"----\"))\n for m in sorted(self.flatten(), key=lambda n: n.identifier):\n print(\"%-15s %-25s %s\" % (type(m).__name__, m.identifier, m.filename or \"\"))","def _get_all_pkg_info(self):\n all_pkgs = self._filter_pkgs(self._go_list(\"./...\"))\n # for every package, list the deps, the test files, the test imports, and the external package test imports\n big_list = self._go_list(\n \"-f\", \"{{.ImportPath}}:{{.Deps}}:{{.TestImports}}:{{.XTestImports}}\", *all_pkgs)\n recursive_deps = {}\n test_imports = {}\n\n for line in big_list:\n tokens = [token.strip().lstrip('[').rstrip(']').strip() for token in line.split(\":\", 3)]\n pkg = tokens[0].strip()\n\n recursive_deps[pkg] = set(self._filter_pkgs(tokens[1].split() + [pkg]))\n if tokens[2] or tokens[3]:\n test_imports[pkg] = set(\n self._filter_pkgs(tokens[2].split()) + self._filter_pkgs(tokens[3].split()))\n\n return recursive_deps, test_imports","def result_printer(self):\n for i in self.output:\n for item, value in i.items():\n if not isinstance(value, list) and \"http://\" not in value:\n print(f\"{item} : {value}\")\n print(20 * '-')","def populate_package(package_count: int) -> None:\n logging.info(f\"Fetching {package_count} packages\")\n response = CurlController.send_get_request(url=CONFIG.EXTERNAL_API.ALL_PACKAGES)\n get_version = False\n count = 0\n temp_dir = filestore.generate_temp_dir()\n # Local Testing\n # response_arr = ['Package: A3', 'Version: 1.0.0', 'Depends: R (>= 2.15.0), xtable, pbapply', 'Suggests: randomForest, e1071', 'License: GPL (>= 2)', 'MD5sum: 027ebdd8affce8f0effaecfcd5f5ade2', 'NeedsCompilation: no', '', 'Package: aaSEA', 'Version: 1.1.0', 'Depends: R(>= 3.4.0)', 'Imports: DT(>= 0.4), networkD3(>= 0.4), shiny(>= 1.0.5),', ' shinydashboard(>= 0.7.0), magrittr(>= 1.5), Bios2cor(>= 2.0),', ' seqinr(>= 3.4-5), plotly(>= 4.7.1), Hmisc(>= 4.1-1)', 'Suggests: knitr, rmarkdown', 'License: GPL-3', 'MD5sum: 0f9aaefc1f1cf18b6167f85dab3180d8', 'NeedsCompilation: no', '', 'Package: AATtools', 'Version: 0.0.1', 'Depends: R (>= 3.6.0)', 'Imports: magrittr, dplyr, doParallel, foreach', 'License: GPL-3', 'MD5sum: 3bd92dbd94573afb17ebc5eab23473cb', 'NeedsCompilation: no', '', 'Package: ABACUS', 'Version: 1.0.0', 'Depends: R (>= 3.1.0)', 'Imports: ggplot2 (>= 3.1.0), shiny (>= 1.3.1),', 'Suggests: rmarkdown (>= 1.13), knitr (>= 1.22)', 'License: GPL-3', 'MD5sum: 50c54c4da09307cb95a70aaaa54b9fbd', 'NeedsCompilation: no', '', 'Package: abbyyR', 'Version: 0.5.5', 'Depends: R (>= 3.2.0)', 'Imports: httr, XML, curl, readr, plyr, progress', 'Suggests: testthat, rmarkdown, knitr (>= 1.11), lintr', 'License: MIT + file LICENSE', 'MD5sum: e048a3bca6ea32126e6c367415c0bfaf', 'NeedsCompilation: no', '', 'Package: abc', 'Version: 2.1', 'Depends: R (>= 2.10), abc.data, nnet, quantreg, MASS, locfit', 'License: GPL (>= 3)', 'MD5sum: c9fffe4334c178917f762735aba59653', 'NeedsCompilation: no', '', 'Package: abc.data', 'Version: 1.0', 'Depends: R (>= 2.10)', 'License: GPL (>= 3)', 'MD5sum: 799079dbbdd0cfc9d9c61c3e35241806', 'NeedsCompilation: no', '', 'Package: ABC.RAP', 'Version: 0.9.0', 'Depends: R (>= 3.1.0)', 'Imports: graphics, stats, utils', 'Suggests: knitr, rmarkdown', 'License: GPL-3', 'MD5sum: 38c65a7251d28ef2462ee430ded95700', 'NeedsCompilation: no', '', 'Package: abcADM', 'Version: 1.0', 'Imports: Rcpp (>= 1.0.1)', 'LinkingTo: Rcpp, BH', 'License: GPL-3', 'MD5sum: 8134f67912b506194e3dab4ccd6e75f7', 'NeedsCompilation: yes', '', 'Package: ABCanalysis', 'Version: 1.2.1', 'Depends: R (>= 2.10)', 'Imports: plotrix', 'License: GPL-3', 'MD5sum: 678e03837e25a922bf71bafe1f8de617', 'NeedsCompilation: no', '', 'Package: abcdeFBA', 'Version: 0.4', 'Depends: Rglpk,rgl,corrplot,lattice,R (>= 2.10)', 'Suggests: LIM,sybil', 'License: GPL-2', 'MD5sum: c84d45a85d8ab6bbe517365e8845db83', 'NeedsCompilation: no', '', 'Package: ABCoptim', 'Version: 0.15.0', 'Imports: Rcpp, graphics, stats, utils', 'LinkingTo: Rcpp', 'Suggests: testthat, covr', 'License: MIT + file LICENSE', 'MD5sum: a62ed03650273c09899655065437078f', 'NeedsCompilation: yes', '', 'Package: ABCp2', 'Version: 1.2', 'Depends: MASS', 'License: GPL-2', 'MD5sum: e920282d5a369df71e15241be40cb60e', 'NeedsCompilation: no', '', 'Package: abcrf', 'Version: 1.8.1', 'Depends: R(>= 3.1)', 'Imports: readr, MASS, matrixStats, ranger, doParallel, parallel,', ' foreach, stringr, Rcpp (>= 0.11.2)', 'LinkingTo: Rcpp, RcppArmadillo', 'License: GPL (>= 2)', 'MD5sum: 4d5a304f46d117226791523cef4e2427', 'NeedsCompilation: yes', '', 'Package: abcrlda', 'Version: 1.0.3', 'Imports: stats', 'License: GPL-3', 'MD5sum: 651e6e18e08916b443aaf011b5a63525', 'NeedsCompilation: no', '', 'Package: abctools', 'Version: 1.1.3', 'Depends: R (>= 2.10), abc, abind, parallel, plyr, Hmisc', 'Suggests: ggplot2, abc.data', 'License: GPL (>= 2)', 'MD5sum: c5937b65837ef7e6bfbe141cea257f40', 'NeedsCompilation: yes', '', 'Package: abd', 'Version: 0.2-8', 'Depends: R (>= 3.0), nlme, lattice, grid, mosaic', 'Suggests: boot, car, ggplot2, plyr, HH, ICC, vcd, Hmisc', 'License: GPL-2', 'MD5sum: 1913d76a0fbc44222709381f63f385b9', 'NeedsCompilation: no', '', 'Package: abdiv', 'Version: 0.2.0', 'Imports: ape', 'Suggests: testthat (>= 2.1.0), vegan', 'License: MIT + file LICENSE', 'MD5sum: 80931c0ca85ba5386000bf617552c5ce', 'NeedsCompilation: no', '', 'Package: abe', 'Version: 3.0.1', 'License: GPL (>= 2)', 'MD5sum: 9c151db5397422c8927dee41dabfbfab', 'NeedsCompilation: no', '', 'Package: abess', 'Version: 0.3.0', 'Depends: R (>= 3.1.0)', 'Imports: Rcpp, MASS, methods, Matrix', 'LinkingTo: Rcpp, RcppEigen', 'Suggests: testthat, knitr, rmarkdown', 'License: GPL (>= 3) | file LICENSE', 'MD5sum: e0ea7d068147c49c011c7135ab290bd3', 'NeedsCompilation: yes', '', 'Package: abf2', 'Version: 0.7-1', 'License: Artistic-2.0', 'MD5sum: 6792a51c6fb3e239165d69aa8a71d3cd', 'NeedsCompilation: no', '', 'Package: abglasso', 'Version: 0.1.1', 'Imports: MASS, pracma, stats, statmod', 'Suggests: testthat', 'License: GPL-3', 'MD5sum: 18bd0759cd005c5ac6fb515799b3f3d8', 'NeedsCompilation: no', '', 'Package: ABHgenotypeR', 'Version: 1.0.1', 'Imports: ggplot2, reshape2, utils', 'Suggests: knitr, rmarkdown', 'License: GPL-3', 'MD5sum: ca4397ba7390c0e0a3728c0cda864494', 'NeedsCompilation: no', '', 'Package: abind', 'Version: 1.4-5', 'Depends: R (>= 1.5.0)', 'Imports: methods, utils', 'License: LGPL (>= 2)', 'MD5sum: 136f981e1c4f618b64a87faaa7797c97', 'NeedsCompilation: no', '', 'Package: abjutils', 'Version: 0.3.1', 'Depends: R (>= 4.0)', 'Imports: dplyr, magrittr, purrr, rlang, rstudioapi, stringi, stringr,', ' tidyr', 'Suggests: testthat', 'License: MIT + file LICENSE', 'MD5sum: a596c07aaa7f82e5d123b2f7354e5b55', 'NeedsCompilation: no', '', 'Package: abmR', 'Version: 1.0.2', 'Depends: R (>= 3.5)', 'Imports: sp, rgdal, table1, googledrive, swfscMisc, geosphere,', ' kableExtra, gtsummary, ggplot2, gstat, purrr, rnaturalearth,', ' rnaturalearthdata, sf, tmap, raster, utils, stats, methods,', ' rgeos', 'Suggests: jpeg, knitr', 'License: GPL (>= 3)', 'MD5sum: cf96d']\n response_arr = response.decode(\"utf-8\").split(\"\\n\")\n with temp_dir:\n for item in response_arr:\n if count >= package_count:\n break\n if get_version:\n # Fetching the version, once we have the package name\n package_version = Command.get_package_version(item=item)\n if package_version:\n # Generating the required URL for the package to fetch the details\n package_url = Template(\n CONFIG.EXTERNAL_API.PACKAGE_DETAIL\n ).substitute(\n package_name=package_name,\n separator=\"_\",\n package_version=package_version,\n )\n logging.info(f\"Downloading {package_url}\")\n # Downloading the details of the package and extracting the DESCRIPTION file\n extract_file_path = filestore.join_paths(\n prefix=package_name,\n suffix=CONFIG.EXTERNAL_API.DETAIL_FILE_NAME,\n )\n target_dir = filestore.download_file(\n url=package_url,\n temp_dir=temp_dir,\n extract_file_path=extract_file_path,\n )\n # Reading contents of DESCRIPTION file\n package_details = filestore.join_paths(\n prefix=temp_dir.name,\n suffix=extract_file_path,\n )\n with open(package_details) as details_file:\n for line in details_file:\n if line.startswith(PackageInfoPrefix.PUBLICATION_DATE):\n publication_time_str = (\n Command.get_publication_timestamp(line)\n )\n publication_timestamp = (\n datetime_util.string_to_datetime(\n publication_time_str\n )\n )\n elif line.startswith(PackageInfoPrefix.TITLE):\n title = Command.get_package_title(line)\n elif line.startswith(PackageInfoPrefix.DESCRIPTION):\n description = Command.get_package_description(line)\n elif line.startswith(PackageInfoPrefix.AUTHOR):\n (\n author_name,\n author_email,\n ) = Command.get_package_author(line)\n elif line.startswith(PackageInfoPrefix.MAINTAINER):\n (\n maintainer_name,\n maintainer_email,\n ) = Command.get_package_maintainer(line)\n\n package_info_dict = {\n \"name\": package_name,\n \"version\": package_version,\n \"publication_timestamp\": publication_timestamp,\n \"title\": title,\n \"description\": description,\n \"author_name\": author_name,\n \"author_email\": author_email,\n \"maintainer_name\": maintainer_name,\n \"maintainer_email\": maintainer_email,\n }\n logging.info(package_info_dict)\n obj = PackageManager.create_object(\n create_data=package_info_dict\n )\n if obj == CONFIG.DB.FAILURE:\n raise Exception(f\"Could not insert package in DB\")\n count += 1\n get_version = False\n # Fetching the package name\n package_name = Command.get_package_name(item=item)\n if package_name:\n get_version = True","def report(self):\n\t\tprint()\n\t\tprint(\"**************************************************\")\n\t\tif not self.host_and_ports:\n\t\t\tprint(\"No hosts have been scanned or loaded yet\")\n\t\t\treturn\n\t\tprint(\"Here are all open ports found for all hosts scanned: \")\n\t\tfor h in self.host_and_ports.keys():\n\t\t\tprint(\"HOST: %s\" % h)\n\t\t\tif not self.host_and_ports[h]:\n\t\t\t\tprint(\"No open ports found for this host yet\")\n\t\t\tfor p in self.host_and_ports[h]:\n\t\t\t\tprint(\"Open: %d\" % p)\n\t\tprint(\"**************************************************\")\n\t\tprint()","def show_solution_differences_to_user(self, solution: List['Package'], upstream_system: 'System',\n noconfirm: bool, deep_search: bool, solution_way: bool):\n\n # needed strings\n package_to_install = aurman_note(\n \"The following {} package(s) are getting {}:\".format(\n \"{}\", Colors.BOLD(Colors.LIGHT_CYAN(\"installed\"))\n ), True, False\n )\n packages_to_uninstall = aurman_note(\n \"The following {} package(s) are predicted to get {}:\".format(\n \"{}\", Colors.BOLD(Colors.LIGHT_CYAN(\"removed\"))\n ), True, False\n )\n packages_to_upgrade = aurman_note(\n \"The following {} package(s) are getting {}:\".format(\n \"{}\", Colors.BOLD(Colors.LIGHT_CYAN(\"updated\"))\n ), True, False\n )\n packages_to_reinstall = aurman_note(\n \"The following {} package(s) are getting {}:\".format(\n \"{}\", Colors.BOLD(Colors.LIGHT_CYAN(\"reinstalled\"))\n ), True, False\n )\n user_question = \"Do you want to continue?\"\n\n new_system = self.hypothetical_append_packages_to_system(solution)\n differences_to_this_system_tuple = self.differences_between_systems((new_system,))[0]\n\n to_install_names = set([package.name for package in differences_to_this_system_tuple[0]])\n to_uninstall_names = set([package.name for package in differences_to_this_system_tuple[1]])\n to_upgrade_names = to_install_names & to_uninstall_names\n to_install_names -= to_upgrade_names\n to_uninstall_names -= to_upgrade_names\n just_reinstall_names = set(\n [package.name for package in solution if package.name in new_system.all_packages_dict]\n ) - set.union(\n *[to_upgrade_names, to_install_names, to_uninstall_names]\n )\n\n # colored names + repos\n print_to_install_names = set([upstream_system.repo_of_package(name) for name in to_install_names])\n print_to_uninstall_names = set([upstream_system.repo_of_package(name) for name in to_uninstall_names])\n print_to_upgrade_names = set([upstream_system.repo_of_package(name) for name in to_upgrade_names])\n print_just_reinstall_names = set([upstream_system.repo_of_package(name) for name in just_reinstall_names])\n\n # calculate some needed values\n max_package_name_length = max(\n [\n len(name) for name in\n set(print_to_install_names |\n print_to_uninstall_names |\n print_to_upgrade_names |\n print_just_reinstall_names)\n ],\n default=0\n )\n\n max_left_side_version_length = max(\n [\n len(self.all_packages_dict[package_name].version) for package_name in\n set(to_uninstall_names | to_upgrade_names | just_reinstall_names)\n ],\n default=1\n )\n\n if to_install_names:\n print(package_to_install.format(len(to_install_names)))\n for package_name in sorted(list(to_install_names)):\n string_to_print = \" {} {} -> {}\".format(\n upstream_system.repo_of_package(package_name).ljust(max_package_name_length),\n Colors.RED(\"/\").ljust(max_left_side_version_length + 10),\n Colors.GREEN(new_system.all_packages_dict[package_name].version)\n )\n\n print(string_to_print)\n\n if to_upgrade_names:\n print(packages_to_upgrade.format(len(to_upgrade_names)))\n for package_name in sorted(list(to_upgrade_names)):\n string_to_print = \" {} {} -> {}\".format(\n upstream_system.repo_of_package(package_name).ljust(max_package_name_length),\n Colors.RED(self.all_packages_dict[package_name].version).ljust(max_left_side_version_length + 10),\n Colors.GREEN(new_system.all_packages_dict[package_name].version)\n )\n\n print(string_to_print)\n\n if just_reinstall_names and not deep_search:\n print(packages_to_reinstall.format(len(just_reinstall_names)))\n for package_name in sorted(list(just_reinstall_names)):\n string_to_print = \" {} {} -> {}\".format(\n upstream_system.repo_of_package(package_name).ljust(max_package_name_length),\n Colors.LIGHT_MAGENTA(self.all_packages_dict[package_name].version).ljust(\n max_left_side_version_length + 10\n ),\n Colors.LIGHT_MAGENTA(new_system.all_packages_dict[package_name].version)\n )\n\n print(string_to_print)\n\n if to_uninstall_names:\n print(packages_to_uninstall.format(len(to_uninstall_names)))\n for package_name in sorted(list(to_uninstall_names)):\n string_to_print = \" {} {} -> {}\".format(\n upstream_system.repo_of_package(package_name).ljust(max_package_name_length),\n Colors.GREEN(self.all_packages_dict[package_name].version).ljust(max_left_side_version_length + 10),\n Colors.RED(\"/\")\n )\n\n print(string_to_print)\n\n # print why those packages have to be uninstalled\n self.hypothetical_append_packages_to_system(solution, packages_names_print_reason=to_uninstall_names)\n\n # check if no dependency breakage happens\n if not solution_way:\n self.hypothetical_append_packages_to_system(solution, check_if_possible=True)\n\n if solution_way:\n aurman_status(\"The following will be done:\", new_line=True)\n if deep_search:\n aurman_note(\"You are using {}, hence {} is active.\".format(\n Colors.BOLD(\"--deep_search\"), Colors.BOLD(\"--needed\")\n ))\n aurman_note(\"That means packages to be reinstalled will not actually be reinstalled.\")\n self.hypothetical_append_packages_to_system(solution, print_way=True)\n\n if not noconfirm and not ask_user(user_question, True, True):\n raise InvalidInput()","def print_dependencies(_run):\n print('Sources:')\n for source, digest in _run.experiment_info['sources']:\n print(' {:<43} {}'.format(source, digest))\n\n print('\\nDependencies:')\n for pack, version in _run.experiment_info['dependencies']:\n print(' {:<20} >= {}'.format(pack, version))","def check_packages(options):\n print '\\033[1;33m# Checking direct VIKI dependencies\\033[1;m'\n installed_ok = dependencies.check_installed_packages()\n print '\\n\\033[1;33m# Checking second level ROS dependencies, using rosdep\\033[1;m'\n second_level_ok = dependencies.get_second_level_dependencies()\n\n if installed_ok and second_level_ok:\n print '\\033[1;32mAll dependencies satisfied!\\033[1;m'\n else:\n print '\\033[1;31mTry running [viki install-dependencies] to install the dependencies\\033[1;m'","def show_versions():\n sys_info = _get_sys_info()\n deps_info = _get_deps_info()\n\n print(\"\\nSystem:\")\n for k, stat in sys_info.items():\n print(\"{k:>10}: {stat}\".format(k=k, stat=stat))\n\n print(\"\\nPython dependencies:\")\n for k, stat in deps_info.items():\n print(\"{k:>13}: {stat}\".format(k=k, stat=stat))","def print_deps(self):\n\t\tprint self.deps, '\\n'","def info_software(modules: list[str] = DEFAULT_MODULES):\n\n # Python Environment\n env = getattr(sys, \"base_prefix\", None) or getattr(sys, \"real_prefix\", None) or sys.prefix\n print(f\"\\nENV:\\t{env}\")\n\n python_version = sys.version\n print(f\"\\nPYTHON:\\t{python_version}\")\n\n if modules is None:\n modules = DEFAULT_MODULES\n\n for i in modules:\n if i in installed_packages_dict:\n print(f\"{i:<25}{installed_packages_dict.get(i):>10}\")\n else:\n print(f\"{i:<25}: {'--NO--':>10}\")\n print()","def show_completed_models(completed_models):\r\n print(\"\\nThe following models have been printed:\")\r\n for completed_model in completed_models:\r\n print(completed_model)","def test_print_version_repositories_SKIP(self):\n self._uri({\n '%d.%d/maintained/%d.%d-%d/%s/Packages.gz' % (MAJOR, MINOR, MAJOR, MINOR, 0, 'all'): DATA,\n '%d.%d/maintained/%d.%d-%d/%s/Packages.gz' % (MAJOR, MINOR, MAJOR, MINOR, 0, ARCH): DATA,\n })\n tmp = self.u.print_version_repositories()\n self.assertEqual(set((\n 'deb file:///mock/%d.%d/maintained/ %d.%d-%d/%s/' % (MAJOR, MINOR, MAJOR, MINOR, 0, 'all'),\n 'deb file:///mock/%d.%d/maintained/ %d.%d-%d/%s/' % (MAJOR, MINOR, MAJOR, MINOR, 0, ARCH),\n )), set(tmp.splitlines()))","def show_keep(self, command=\"show-keep\"):\n # execute pkgin\n popen = Popen([self.pkgin_bin, \"-P\", command], stdout=PIPE, stderr=PIPE)\n # retrieve output streams\n (stdoutdata, stderrdata) = popen.communicate()\n # if pkgin error\n if(stderrdata):\n # remove the line feed\n error = stderrdata[0:-1]\n raise PykginError(error)\n # retrieve output\n output = stdoutdata\n # create a list which contain each packages\n output_whole_list = output.split('\\n')\n # remove last element (due to the last \\n)\n output_whole_list.pop()\n # create a new list in which package informations are separate\n output_list = []\n for pkg in output_whole_list:\n current = pkg.split(' ', 1)\n output_list.append(self.__extract_package_version(current[0]))\n\n return output_list","def print_results(self):\n for test_cases in self._tests:\n for test_case in test_cases:\n print('{} ...ok'.format(test_case.get_name()))\n return 0","def all(\n command,\n):\n # If we get to this point all tests listed in 'pre' have passed\n # unless we have run the task with the --warn flag\n if not command.config.run.warn:\n print(\n \"\"\"\nAll Checks Passed Successfully\n==========================================\n\"\"\"\n )","def print_summary(self):\n #outcomes = self.get_outcomes()\n #passes = 'Passes: %i' % sum(1 for outcome in outcomes if outcome == Result.PASS)\n #untested = 'Untested: %i' % sum(1 for outcome in outcomes if outcome == Result.UNTESTED)\n #errors = 'Errors: %i' % sum(1 for outcome in outcomes if outcome == Result.ERROR)\n #fails = 'Fails: %i' % sum(1 for outcome in outcomes if outcome == Result.FAIL)\n print('')\n print ('Passes: %i' % self.get_pass_count())\n print ('Fails: %i' % self.get_fail_count())\n print ('Errors: %i' % self.get_error_count())\n print ('Untested: %i' % self.get_untested_count())\n print ('Skipped: %i' % self.get_skipped_count())","def show_completed_design(completed_design):\n print(\"\\nThe following models have been printed:\")\n for completed_designs in completed_design:\n print(completed_designs)","def test_collect_playbooks_dependencies_skip_unavailable(self, module_repo):\n expected_result = {\n # playbooks:\n (\"Slack\", False),\n (\"Indeni\", True),\n # integrations:\n (\"FeedAlienVault\", False),\n (\"ipinfo\", True),\n (\"FeedAutofocus\", True),\n # scripts:\n (\"GetServerURL\", False),\n (\"HelloWorld\", True),\n }\n test_input = [\n {\n \"Dummy Playbook\": {\n \"name\": \"Dummy Playbook\",\n \"file_path\": \"dummy_path\",\n \"fromversion\": \"dummy_version\",\n \"implementing_scripts\": [\n \"GetServerURL\",\n \"HelloWorldScript\",\n ],\n \"implementing_playbooks\": [\n \"Failed Login Playbook - Slack v2\",\n \"Indeni Demo\",\n ],\n \"command_to_integration\": {\n \"alienvault-get-indicators\": \"\",\n \"ip\": \"ipinfo\",\n \"autofocus-get-indicators\": \"\",\n },\n \"tests\": [\"dummy_playbook\"],\n \"pack\": \"dummy_pack\",\n \"incident_fields\": [],\n \"skippable_tasks\": [\n \"Print\",\n \"Failed Login Playbook - Slack v2\",\n \"alienvault-get-indicators\",\n \"GetServerURL\",\n ],\n }\n },\n ]\n\n found_result = PackDependencies._collect_playbooks_dependencies(\n pack_playbooks=test_input,\n id_set=module_repo.id_set.read_json_as_dict(),\n )\n\n assert set(found_result) == set(expected_result)","def report_not_up_to_date(self):\n print \"Build is not up-to-date:\"\n print self.banner('STDOUT ')\n print self.stdout()\n stderr = self.stderr()\n if stderr:\n print self.banner('STDERR ')\n print stderr","def print_detectable(pkg):\n\n color.cprint(\"\")\n color.cprint(section_title(\"Externally Detectable: \"))\n\n # If the package has an 'executables' of 'libraries' field, it\n # can detect an installation\n if hasattr(pkg, \"executables\") or hasattr(pkg, \"libraries\"):\n find_attributes = []\n if hasattr(pkg, \"determine_version\"):\n find_attributes.append(\"version\")\n\n if hasattr(pkg, \"determine_variants\"):\n find_attributes.append(\"variants\")\n\n # If the package does not define 'determine_version' nor\n # 'determine_variants', then it must use some custom detection\n # mechanism. In this case, just inform the user it's detectable somehow.\n color.cprint(\n \" True{0}\".format(\n \" (\" + \", \".join(find_attributes) + \")\" if find_attributes else \"\"\n )\n )\n else:\n color.cprint(\" False\")","def show_completed_models(completed_models):\n print(\"\\nThe following models have been printed:\")\n for completed_model in completed_models:\n print(completed_model)","def show_completed_models(completed_models):\n print(\"\\nThe following models have been printed:\")\n for completed_model in completed_models:\n print(completed_model)","def show_completed_models(completed_models):\n print(\"\\nThe following models have been printed:\")\n for completed_model in completed_models:\n print(completed_model)","def show_completed_models(completed_models):\n\tprint(\"\\n The following models has been printed \")\n\tfor completed_model in completed_models:\n\t\tprint(completed_model)","def _show_summary(self):\n print 'Summary:'\n print ' Reports downloaded successfully: %d' % self.counts\n print ' Reports not downloaded: %d\\n' % self.failed","def print_warning_msgs():\n for err in TypeWarning.warnings:\n print err","def show_completed_models(completed_models):\n\tprint(\"\\nThe following models have been printed:\")\n\tfor completed_model in completed_models:\n\t\tprint(completed_model)","def check_missing_dep():\n global MISSING_PACKAGES, INSTALLED_PACKAGES, ENABLE_CUDA\n if ENABLE_CUDA and IS_MACOS:\n REQUIRED_PACKAGES.extend(MACOS_REQUIRED_PACKAGES)\n MISSING_PACKAGES = []\n for pkg in REQUIRED_PACKAGES:\n key = pkg.split(\"==\")[0]\n if key not in INSTALLED_PACKAGES:\n MISSING_PACKAGES.append(pkg)\n continue\n else:\n if len(pkg.split(\"==\")) > 1:\n if pkg.split(\"==\")[1] != INSTALLED_PACKAGES.get(key):\n MISSING_PACKAGES.append(pkg)\n continue","def blankOutputFiles():\n print(\"Checking for blank output files\")\n find_output = re.compile(r\"/\\* Output:(.*)\\*/\", re.DOTALL)\n for java in config.example_dir.rglob(\"*.java\"):\n with java.open() as codeFile:\n output = find_output.search(codeFile.read())\n if output:\n # print(output.group(1))\n if not output.group(1).strip():\n print(java)","def _show_missing_code_main(config: Config, session: Session) -> None:\n tw = TerminalWriter()\n session.perform_collect()\n\n fm = session._fixturemanager\n\n if config.option.features is None:\n tw.line(\"The --feature parameter is required.\", red=True)\n session.exitstatus = 100\n return\n\n features, scenarios, steps = parse_feature_files(config.option.features)\n\n for item in session.items:\n scenario = getattr(item.obj, \"__scenario__\", None)\n if scenario:\n if scenario in scenarios:\n scenarios.remove(scenario)\n for step in scenario.steps:\n fixturedefs = _find_step_fixturedef(fm, item, step=step)\n if fixturedefs:\n try:\n steps.remove(step)\n except ValueError:\n pass\n for scenario in scenarios:\n for step in scenario.steps:\n if step.background is None:\n steps.remove(step)\n grouped_steps = group_steps(steps)\n print_missing_code(scenarios, grouped_steps)\n\n if scenarios or steps:\n session.exitstatus = 100","def display_nornir_results(nr_result):\n print(menu('Interface Update'))\n for host in nr_result:\n if not nr_result[host].failed:\n if nr_result[host].changed:\n print(Fore.YELLOW + f'{host}: True')\n else:\n print(Fore.GREEN + f'{host}: False')\n else:\n print(Fore.RED + f'{host}: FAILED')","def printErrors(self):\n if self.dots:\n self.stream.writeln()\n\n # Skipped Test Report\n if not self.args.no_skip_report:\n for test, reason in self.skipped:\n self.stream.writeln(\n \"\\n{} {} - {}\".format(\n self.colors.blue(\"Skipped\"),\n self.colors.bold(test.dotted_name),\n reason,\n )\n )\n\n # Captured output for non-failing tests\n if not self.args.quiet_stdout:\n failing_tests = {x[0] for x in self.all_errors}\n for test in list(self.stdout_output) + list(self.stderr_errput):\n if test not in failing_tests:\n self.displayStdout(test)\n self.displayStderr(test)\n\n # Actual tracebacks and captured output for failing tests\n for test, color_func, outcome, err in self.all_errors:\n # Header Line\n self.stream.writeln(\n f\"\\n{color_func(outcome)} in {self.colors.bold(test.dotted_name)}\"\n )\n\n # Traceback\n if not self.args.no_tracebacks:\n relevant_frames = []\n for i, frame in enumerate(err.traceback_lines):\n # Python2 tracebacks containing unicode need some special handling\n # This doesn't always make it readable, but at least it doesn't\n # crash\n if sys.version_info[0] == 2: # pragma: no cover\n try:\n \"\".join([frame]) # intentionally trigger exceptions\n except UnicodeDecodeError:\n frame = frame.decode(\"utf-8\")\n debug(\n \"\\n\"\n f\"{'*' * 30}Frame {i}:{'*' * 30}\\n\" + self.colors.yellow(frame),\n level=3,\n )\n # Ignore useless frames\n if self.verbose < 4:\n if frame.strip() == \"Traceback (most recent call last):\":\n continue\n # Done with this frame, capture it.\n relevant_frames.append(frame)\n self.stream.write(\"\".join(relevant_frames))\n\n # Captured output for failing tests\n self.displayStdout(test)\n self.displayStderr(test)","def cli(env, keyword, package_type):\n manager = ordering.OrderingManager(env.client)\n table = formatting.Table(COLUMNS)\n\n _filter = {'type': {'keyName': {'operation': '!= BLUEMIX_SERVICE'}}}\n if keyword:\n _filter['name'] = {'operation': '*= %s' % keyword}\n if package_type:\n _filter['type'] = {'keyName': {'operation': package_type}}\n\n packages = manager.list_packages(filter=_filter)\n\n for package in packages:\n table.add_row([\n package['id'],\n package['name'],\n package['keyName'],\n package['type']['keyName']\n ])\n env.fout(table)","def print_skipped(self,result,cause=False):\n skipped = result.get_skipped()\n if skipped:\n print ('=== SKIPPED '+('='*59))\n for u in skipped:\n print (u.id)\n if cause:\n print (' ',u.get_cause())","def report_unused_cycle_suppressions(self, reporter):\n for module in self.get_modules():\n for dep in module.get_dependencies():\n if not dep.suppression_used:\n reporter.cyclic_issue(\"unused cycle suppression: {0} -> {1}\".format(module.get_name()[7:], dep.get_other_module().get_name()[7:]))","def print_all_separation_algorithms():\n from ..separation import all_separation_algorithms\n print('\\n'.join([a.__name__ for a in all_separation_algorithms]))","def show_linting_results(self, linting_results):\n attribute_results = []\n lint_results_by_outcome = {}\n for result in linting_results:\n if result.result == charmcraft.linters.IGNORED:\n continue\n if result.check_type == charmcraft.linters.CheckType.attribute:\n attribute_results.append(result)\n else:\n lint_results_by_outcome.setdefault(result.result, []).append(result)\n\n # show attribute results\n for result in attribute_results:\n emit.verbose(\n f\"Check result: {result.name} [{result.check_type}] {result.result} \"\n f\"({result.text}; see more at {result.url}).\",\n )\n\n # show warnings (if any), then errors (if any)\n template = \"- {0.name}: {0.text} ({0.url})\"\n if charmcraft.linters.WARNINGS in lint_results_by_outcome:\n emit.progress(\"Lint Warnings:\", permanent=True)\n for result in lint_results_by_outcome[charmcraft.linters.WARNINGS]:\n emit.progress(template.format(result), permanent=True)\n if charmcraft.linters.ERRORS in lint_results_by_outcome:\n emit.progress(\"Lint Errors:\", permanent=True)\n for result in lint_results_by_outcome[charmcraft.linters.ERRORS]:\n emit.progress(template.format(result), permanent=True)\n if self.force_packing:\n emit.progress(\"Packing anyway as requested.\", permanent=True)\n else:\n raise CraftError(\n \"Aborting due to lint errors (use --force to override).\", retcode=2\n )","def test_component_update_get_packages(self):\n MockPopen.mock_stdout = 'Inst a [old] (new from)\\nInst b (new from)\\nRemv c (old PKG)\\nRemv d PKG'\n installed, upgraded, removed = self.u.component_update_get_packages()\n self.assertEqual([('b', 'new')], installed)\n self.assertEqual([('a', 'old', 'new')], upgraded)\n self.assertEqual([('c', 'old'), ('d', 'unknown')], removed)","def print_drivers():\n driver_info_dict = get_all_driver_infos()\n keys = sorted(driver_info_dict)\n print \"%-25s%-15s%-9s%-25s\" % (\n \"Module name\", \"Driver name\", \"Version\", \"Status\")\n for d in keys:\n print \" %(module_name)-25s%(driver_name)-15s%(version)-9s%(status)-25s\" % driver_info_dict[d]","def run(self):\n logging.debug('List Installed Programs')\n if self.short:\n print(' '.join([ent for ent in pakit.conf.IDB]))\n return\n\n nchars = 12\n fmt = str(nchars).join(['{prog:', '} {repo:',\n '} {hash:', '} {date}'])\n installed = ['Program Repo Hash Date']\n for prog in pakit.conf.IDB:\n entry = pakit.conf.IDB[prog]\n installed.append(fmt.format(prog=prog[0:nchars],\n repo=entry['repo'][0:nchars],\n date=entry['date'],\n hash=entry['hash'][0:nchars]))\n\n msg = 'Installed Programs:'\n msg += PREFIX + PREFIX.join(installed)\n print(msg)\n return msg","def recheck_total_packages(conts_dict, si_result):\n print('######## HOW ABOUT TOTAL PACKAGES ########')\n need_recheck = False\n total = ''\n if len(conts_dict) > 0:\n if 'packages' in conts_dict[0]:\n total_pkgs = si_result.get('total_packages', True)\n desctip = si_result.get('description_of_goods', False)\n if total_pkgs == desctip:\n need_recheck = True\n\n print('need_recheck:', need_recheck)\n print(\"=========================conts_dict: \",conts_dict)\n if need_recheck:\n sum_packages = sum([\n int(re.sub(r'[^\\d]+', '', detail.get('packages', '0')))\n for detail in conts_dict\n if floatable(detail.get('packages', '0'))\n ])\n\n print('sum_packages:', sum_packages)\n unit = re.sub(r'[^a-zA-Z]+', '', conts_dict[0].get('packages', ''))\n\n total = str(sum_packages) + ' ' + unit\n\n return total, need_recheck","def display_available_items(self):\n count = 0\n print(\"Available Items:\")\n for item in self.item_list.values():\n if item.check_availability():\n count += 1\n print(item)\n if count == 0:\n print(\"No items are available\")"],"string":"[\n \"def _print_missing(packages, verbose):\\n if not packages:\\n print(\\\"## No Rez packages were found.\\\")\\n print(\\\"No data found\\\")\\n\\n return\\n\\n print(\\\"## Your command affects these Rez packages.\\\")\\n\\n template = \\\"{package.name}\\\"\\n\\n if verbose:\\n template = \\\"{package.name}: {path}\\\"\\n\\n for line in sorted(\\n template.format(package=package, path=finder.get_package_root(package))\\n for package in packages\\n ):\\n print(line)\",\n \"def _print_ignored(packages):\\n if not packages:\\n print(\\\"## No Rez package was set to be ignored\\\")\\n print(\\\"No data found\\\")\\n\\n return\\n\\n print(\\\"## Every package in this list was explicitly set to ignored by the user\\\")\\n\\n for package, pattern in sorted(packages, key=_get_package_name):\\n print(\\n 'Package: {package.name} - Pattern: \\\"{pattern}\\\"'.format(\\n package=package, pattern=pattern\\n )\\n )\",\n \"def _print_skips(skips, verbose):\\n if not skips:\\n print(\\\"## No packages were skipped\\\")\\n print(\\\"Every found Rez package can be processed by the command.\\\")\\n\\n return\\n\\n print(\\\"## Packages were skipped from running a command. Here's the full list:\\\")\\n\\n template = \\\"{issue.package.name}: {issue.reason}\\\"\\n\\n if verbose:\\n template = \\\"{issue.package.name}: {issue.path}: {issue.reason}\\\"\\n\\n for issue in skips:\\n print(template.format(issue=issue))\",\n \"def _print_invalids(invalids, verbose):\\n if not invalids:\\n print(\\\"## No Rez package was set as invalid.\\\")\\n print(\\\"Nothing is invalid. Which is a good thing!\\\")\\n\\n return\\n\\n print(\\\"## Some packages were marked as invalid. Here's why:\\\")\\n\\n template = \\\"{package.name}: {message}\\\"\\n\\n if verbose:\\n template = \\\"{package.name}: {path} {message}: {full}\\\"\\n\\n for message in sorted(\\n (\\n template.format(\\n package=error.get_package(),\\n path=error.get_path(),\\n message=str(error),\\n full=error.get_full_message(),\\n )\\n for error in invalids\\n )\\n ):\\n print(message)\",\n \"def show_missing():\\n if missing_modules:\\n info(\\\"The following modules are currently not installed and would enable additional tasks:\\\")\\n for pkg_name in missing_modules:\\n info(' ' + pkg_name)\",\n \"def report(*packages):\\n accepted_commands = ['python','conda']\\n for package in packages:\\n loc = \\\"not installed in this environment\\\"\\n ver = \\\"unknown\\\"\\n\\n try:\\n module = importlib.import_module(package)\\n loc = os.path.dirname(module.__file__)\\n\\n try:\\n ver = str(module.__version__)\\n except Exception:\\n pass\\n \\n except (ImportError, ModuleNotFoundError):\\n if package in accepted_commands:\\n try:\\n # See if there is a command by that name and check its --version if so\\n try:\\n loc = subprocess.check_output(['command','-v', package]).decode().splitlines()[0].strip()\\n except:\\n # .exe in case powershell (otherwise wouldn't need it)\\n loc = subprocess.check_output(['where.exe', package]).decode().splitlines()[0].strip() \\n out = \\\"\\\"\\n try:\\n out = subprocess.check_output([package, '--version'], stderr=subprocess.STDOUT)\\n except subprocess.CalledProcessError as e:\\n out = e.output\\n\\n # Assume first word in output with a period and digits is the version\\n for s in out.decode().split():\\n if '.' in s and str.isdigit(s[0]) and sum(str.isdigit(c) for c in s)>=2:\\n ver=s.strip()\\n break\\n except:\\n pass\\n elif package == 'system':\\n try:\\n ver = platform.platform(terse=True)\\n loc = \\\"OS: \\\" + platform.platform()\\n except Exception:\\n pass\\n else:\\n pass\\n \\n print(\\\"{0:30} # {1}\\\".format(package + \\\"=\\\" + ver,loc))\",\n \"def test_packages(self):\\n for pkg in self.expected_packages:\\n status, output = commands.getstatusoutput('pkg_info -qx %s' % pkg)\\n assert status == 0\",\n \"def list_packages(self):\\n for tag, pkg in PACKAGES.iteritems():\\n print \\\"{tag} - {label}\\\".format(tag=tag, label=pkg['label'])\",\n \"def print_test_deps_not_in_package_deps(self):\\n extras = []\\n for key, rec_deps in self.recursive_pkg_deps.items():\\n any = self.test_imports.get(key, set()).difference(rec_deps, set([key]))\\n if any:\\n extras.append((key, any))\\n\\n if extras:\\n print(\\\"Packages whose tests have extra dependencies not listed in `go list -f {{.Deps}}`:\\\")\\n for pkg, deps in extras:\\n print(\\\"\\\\t{0}: {1}\\\".format(pkg, \\\", \\\".join(deps)))\\n print(\\\"\\\\n\\\")\",\n \"def check(force, verbose, packages):\\n code = 0\\n packages = CFG.package_specs(packages)\\n if not packages:\\n print(\\\"No packages installed\\\")\\n sys.exit(0)\\n\\n for pspec in packages:\\n desired = pspec.get_desired_version_info(force=force)\\n dv = runez.bold(desired.version)\\n manifest = pspec.get_manifest()\\n if desired.problem:\\n msg = desired.problem\\n code = 1\\n\\n elif not manifest or not manifest.version:\\n msg = \\\"v%s is not installed\\\" % dv\\n code = 1\\n\\n elif manifest.version == desired.version:\\n msg = \\\"v%s is installed\\\" % dv\\n\\n else:\\n action = \\\"upgraded to\\\" if desired.source == \\\"latest\\\" else \\\"caught up to %s\\\" % desired.source\\n msg = \\\"v%s installed, can be %s v%s\\\" % (runez.dim(manifest.version), action, dv)\\n\\n print(\\\"%s: %s\\\" % (pspec.dashed, msg))\\n\\n sys.exit(code)\",\n \"def show_packagelist(user, repo, packages, distro=False, version=False,\\n name=False, match=False, pkgtype=False):\\n\\n print('Currently {}/{} contains these matching packages:'.format(\\n user, repo))\\n\\n numpkgs = 0\\n for package in packages:\\n if (distro and not package['distro_version'] == distro) or \\\\\\n (version and not package['version'] == version) or \\\\\\n (name and not package['name'] == name) or \\\\\\n (pkgtype and not package['type'] == pkgtype) or \\\\\\n (match and match not in package['filename']):\\n continue\\n\\n print(fmt_pkg(user, repo, package))\\n numpkgs += 1\\n\\n print(\\\"Repo contains {} matching packages.\\\".format(numpkgs))\",\n \"def troubleshoot():\\n libraries = (sys, pd, openpyxl, matplotlib, pip)\\n for i in libraries:\\n try:\\n print(str(i), 'version:', i.__version__)\\n except AttributeError:\\n pass\\n except ModuleNotFoundError:\\n print('You do not have', str(i), 'installed.')\\n print('You can do so via your interpreter or:')\\n print('py -m pip install', '-' + str(i))\\n print('in command prompt')\",\n \"def _list_all(root_pkg, prog):\\n res = \\\"\\\\n\\\".join(\\n sorted(\\n pkinspect.package_module_names(_import(root_pkg)),\\n key=str.lower,\\n ),\\n )\\n sys.stderr.write(f\\\"usage: {prog} module command [args...]\\\\nModules:\\\\n{res}\\\\n\\\")\\n return 1\",\n \"def log_imported_packages(self):\\n imported_packages_dict = self.get_imported_packages()\\n\\n res_str = \\\"\\\\n\\\".join(f\\\"{module}: {version_num}\\\" for module, version_num\\n in imported_packages_dict[\\\"results\\\"].items())\\n no_res_str = \\\"\\\\n\\\".join(f\\\"{module}: {version_num}\\\" for module, version_num\\n in imported_packages_dict[\\\"no_results\\\"].items())\\n errs_res_str = \\\"\\\\n\\\".join(f\\\"{module}: {version_num}\\\" for module, version_num\\n in imported_packages_dict[\\\"errors\\\"].items())\\n\\n msg = f\\\"Imported modules:\\\\n {res_str}\\\\n {no_res_str}\\\\n {errs_res_str}\\\"\\n logger.info(msg)\",\n \"def getMissingPackages(self, language=None, all=False, packages=None, showInstalled=False):\\n if self._cache.broken_count > 0:\\n raise SoftwareIndexBroken\\n \\n self.langpack_locales = {}\\n self.pkg_translations = {}\\n self.pkg_writing = {}\\n filter_list = {}\\n blacklist = []\\n show = []\\n self.missing = set()\\n self.installed = set()\\n self.system_pkgcode = ''\\n \\n for l in open(self.BLACKLIST):\\n l = l.strip()\\n if not l.startswith('#'):\\n blacklist.append(l)\\n \\n for l in open(self.LANGCODE_TO_LOCALE):\\n try:\\n l = l.rstrip()\\n if ':' in l:\\n (pkgcode, locale) = l.split(':')\\n else:\\n pkgcode = l\\n locale = l\\n except ValueError:\\n continue\\n self.langpack_locales[locale] = pkgcode\\n \\n for l in open(self.PACKAGE_DEPENDS):\\n if l.startswith('#'):\\n continue\\n try:\\n l = l.rstrip()\\n # sort out comments\\n if l.find('#') >= 0:\\n continue\\n (c, lc, k, v) = l.split(':')\\n except ValueError:\\n continue\\n if (c == 'tr' and lc == ''):\\n filter_list[v] = k\\n elif (c == 'wa' and lc != ''):\\n if '|' in lc:\\n for l in lc.split('|'):\\n if not l in self.pkg_writing:\\n self.pkg_writing[l] = []\\n self.pkg_writing[l].append((\\\"%s\\\" % k, \\\"%s\\\" % v))\\n else:\\n if not lc in self.pkg_writing:\\n self.pkg_writing[lc] = []\\n self.pkg_writing[lc].append((\\\"%s\\\" % k, \\\"%s\\\" % v))\\n\\n # get list of all packages available on the system and filter them\\n for item in self._cache.keys():\\n if item in blacklist: \\n continue\\n for x in filter_list.keys():\\n if item.startswith(x) and not item.endswith('-base'):\\n # parse language code\\n langcode = item.replace(x, '')\\n #print \\\"%s\\\\t%s\\\" % (item, langcode)\\n if langcode == 'zh':\\n # special case: zh langpack split\\n for langcode in ['zh-hans', 'zh-hant']:\\n if not langcode in self.pkg_translations:\\n self.pkg_translations[langcode] = []\\n self.pkg_translations[langcode].append((\\\"%s\\\" % filter_list[x], \\\"%s\\\" % item))\\n elif langcode in self.langpack_locales.values():\\n # langcode == pkgcode\\n if not langcode in self.pkg_translations:\\n self.pkg_translations[langcode] = []\\n self.pkg_translations[langcode].append((\\\"%s\\\" % filter_list[x], \\\"%s\\\" % item))\\n #print self.pkg_translations[langcode]\\n else:\\n # need to scan for LL-CC and LL-VARIANT codes\\n for locale in self.langpack_locales.keys():\\n if '_' in locale or '@' in locale:\\n if '@' in locale:\\n (locale, variant) = locale.split('@')\\n else:\\n variant = ''\\n (lcode, ccode) = locale.split('_')\\n if langcode in [\\\"%s-%s\\\" % (lcode, ccode.lower()),\\n \\\"%s%s\\\" % (lcode, ccode.lower()),\\n \\\"%s-%s\\\" % (lcode, variant),\\n \\\"%s%s\\\" % (lcode, variant),\\n \\\"%s-latn\\\" % lcode,\\n \\\"%slatn\\\" % lcode,\\n \\\"%s-%s-%s\\\" % (lcode, ccode.lower(), variant),\\n \\\"%s%s%s\\\" % (lcode, ccode.lower(), variant)]:\\n # match found, get matching pkgcode\\n langcode = self.langpack_locales[locale]\\n if not langcode in self.pkg_translations:\\n self.pkg_translations[langcode] = []\\n self.pkg_translations[langcode].append((\\\"%s\\\" % filter_list[x], \\\"%s\\\" % item))\\n #print self.pkg_translations[langcode]\\n break\\n\\n if language:\\n pkgcode = ''\\n if language == 'zh-hans' or language == 'zh-hant':\\n self.system_pkgcode = language\\n elif language in self.langpack_locales:\\n self.system_pkgcode = self.langpack_locales[language]\\n else:\\n # pkgcode = ll\\n if '_' in language:\\n (self.system_pkgcode) = language.split('_')[0]\\n elif '@' in language:\\n (self.system_pkgcode) = language.split('@')[0]\\n else:\\n self.system_pkgcode = language\\n\\n if packages:\\n self.findPackages(self.system_pkgcode, packages)\\n else:\\n self.findPackages(self.system_pkgcode)\\n \\n elif all:\\n # try all available languages\\n pkgcodes = []\\n for item in self._cache.keys():\\n if item in blacklist:\\n continue\\n if item.startswith('language-pack-') and \\\\\\n not item.startswith('language-pack-gnome') and \\\\\\n not item.startswith('language-pack-kde') and \\\\\\n not item.endswith('-base'):\\n pkgcode = item.replace('language-pack-', '')\\n pkgcodes.append(pkgcode)\\n\\n for pkgcode in pkgcodes:\\n if packages:\\n self.findPackages(pkgcode, packages)\\n else:\\n self.findPackages(pkgcode)\\n\\n else:\\n # get a list of language-packs we have already installed or are going to install\\n # 1. system locale\\n system_langcode = self._localeinfo.getSystemDefaultLanguage()[0]\\n if system_langcode == None:\\n system_langcode = 'en_US'\\n if system_langcode in self.langpack_locales:\\n self.system_pkgcode = self.langpack_locales[system_langcode]\\n # 2. installed language-packs\\n pkgcodes = []\\n for item in self._cache.keys():\\n if item in blacklist: \\n continue\\n if item.startswith('language-pack-') and \\\\\\n not item.startswith('language-pack-gnome') and \\\\\\n not item.startswith('language-pack-kde') and \\\\\\n not item.endswith('-base') and \\\\\\n (self._cache[item].is_installed or \\\\\\n self._cache[item].marked_install):\\n pkgcode = item.replace('language-pack-', '')\\n pkgcodes.append(pkgcode)\\n if self.system_pkgcode and \\\\\\n not self.system_pkgcode in pkgcodes:\\n pkgcodes.append(self.system_pkgcode)\\n \\n for pkgcode in pkgcodes:\\n if packages:\\n self.findPackages(pkgcode, packages)\\n else:\\n self.findPackages(pkgcode)\\n \\n if showInstalled:\\n show = self.missing | self.installed\\n else:\\n show = self.missing\\n\\n return show\",\n \"def show_everything():\\n \\n #print(\\\"WARNING: This may take awhile. . .\\\\n\\\")\\n # Need to find all hostgroups, and make sure there are no deuplicate machines in this calculation.\\n print(\\\"This feature is still under construction. Check back soon!\\\")\\n sys.exit(0)\",\n \"def main():\\n\\n local_pkgs = set(os.listdir(GIT_FOLDER))\\n local_pkgs = set([it.replace('.git', '') for it in local_pkgs])\\n\\n pkgdb_info = pkgdb_pkg_branch()\\n\\n pkgdb_pkgs = set(pkgdb_info.keys())\\n\\n ## Commented out as we keep the git of retired packages while they won't\\n ## show up in the information retrieved from pkgdb.\\n\\n #if (local_pkgs - pkgdb_pkgs):\\n #print 'Some packages are present locally but not on pkgdb:'\\n #print ', '.join(sorted(local_pkgs - pkgdb_pkgs))\\n\\n if (pkgdb_pkgs - local_pkgs):\\n print 'Some packages are present in pkgdb but not locally:'\\n print ', '.join(sorted(pkgdb_pkgs - local_pkgs))\\n\\n tofix = set()\\n for pkg in sorted(pkgdb_info):\\n pkgdb_branches = pkgdb_info[pkg]\\n git_branches = get_git_branch(pkg)\\n diff = (pkgdb_branches - git_branches)\\n if diff:\\n print '%s missing: %s' % (pkg, ','.join(sorted(diff)))\\n tofix.add(pkg)\\n branch_package(pkg, diff)\\n\\n if tofix:\\n print 'Packages fixed (%s): %s' % (\\n len(tofix), ', '.join(sorted(tofix)))\",\n \"def print_package_info(package):\\r\\n print(\\\"******************\\\")\\r\\n print(\\\"Product: %s\\\" % package[0]['description'])\\r\\n print(\\\"Price: %s$ monthly\\\" % package[0]['prices'][0]['recurringFee'])\\r\\n print(\\\"******************\\\")\\r\\n return\",\n \"def _list_dependencies_info(\\n out: Callable, ljust: int, package: str, dependencies: List[Requirement]\\n):\\n unicode = sys.stdout.encoding.lower().startswith(\\\"utf\\\")\\n if unicode:\\n ljust += 1\\n\\n not_found: List[Requirement] = list()\\n for dep in dependencies:\\n if dep.name == package:\\n continue\\n try:\\n version_ = version(dep.name)\\n except Exception:\\n not_found.append(dep)\\n continue\\n\\n # build the output string step by step\\n output = f\\\"✔︎ {dep.name}\\\" if unicode else dep.name\\n # handle version specifiers\\n if len(dep.specifier) != 0:\\n output += f\\\" ({str(dep.specifier)})\\\"\\n output += \\\":\\\"\\n output = output.ljust(ljust) + version_\\n\\n # handle special dependencies with backends, C dep, ..\\n if dep.name in (\\\"matplotlib\\\", \\\"seaborn\\\") and version_ != \\\"Not found.\\\":\\n try:\\n from matplotlib import pyplot as plt\\n\\n backend = plt.get_backend()\\n except Exception:\\n backend = \\\"Not found\\\"\\n\\n output += f\\\" (backend: {backend})\\\"\\n out(output + \\\"\\\\n\\\")\\n\\n if len(not_found) != 0:\\n not_found = [\\n f\\\"{dep.name} ({str(dep.specifier)})\\\"\\n if len(dep.specifier) != 0\\n else dep.name\\n for dep in not_found\\n ]\\n if unicode:\\n out(f\\\"✘ Not installed: {', '.join(not_found)}\\\\n\\\")\\n else:\\n out(f\\\"Not installed: {', '.join(not_found)}\\\\n\\\")\",\n \"def verify_package_status(self):\\n pass\",\n \"def verify_package_status(self):\\n pass\",\n \"def pkg_not_found_mess(pkgname: str, reponame: str) -> None:\\n meta = MainData()\\n print(('{0}Package {1}{2} {0}not found in \\\\'{3}\\\\' '\\n 'repository.{4}').format(meta.clrs['red'],\\n meta.clrs['lcyan'],\\n pkgname,\\n reponame,\\n meta.clrs['reset']))\",\n \"def test_correctness_of_installed_rpm_packages(self):\\n not_installed_packages = get_not_installed_rpm_packages()\\n error_msg = linesep + 'List of not installed packages: '\\n for package in not_installed_packages:\\n error_msg += linesep + package\\n self.assertFalse(not_installed_packages, error_msg)\",\n \"def sort_packages(self) -> None:\\n self.recommended_packages = []\\n self.required_packages = []\\n for package in self.repository_packages:\\n try:\\n output = self.guest.execute(Command('rpm', '-q', package), silent=True)\\n assert output.stdout\\n self.debug(f\\\"Package '{output.stdout.strip()}' already installed.\\\")\\n except tmt.utils.RunError:\\n if self.skip_missing:\\n self.recommended_packages.append(package)\\n else:\\n self.required_packages.append(package)\",\n \"def print_dependencies(pkg):\\n\\n for deptype in (\\\"build\\\", \\\"link\\\", \\\"run\\\"):\\n color.cprint(\\\"\\\")\\n color.cprint(section_title(\\\"%s Dependencies:\\\" % deptype.capitalize()))\\n deps = sorted(pkg.dependencies_of_type(deptype))\\n if deps:\\n colify(deps, indent=4)\\n else:\\n color.cprint(\\\" None\\\")\",\n \"def main():\\n parser = setup_parser()\\n args = parser.parse_args()\\n\\n global LOG\\n if args.debug:\\n LOG.setLevel(logging.DEBUG)\\n\\n changes = retrieve_pkgdb_change()\\n LOG.debug('%s changes retrieved' % len(changes))\\n orphaned = {}\\n unorphaned = {}\\n changed = {}\\n for change in changes:\\n pkg_name = change['msg']['package_listing']['package']['name']\\n owner = change['msg']['package_listing']['owner']\\n branch = change['msg']['package_listing']['collection']['branchname']\\n user = change['msg']['agent']\\n LOG.debug('%s changed to %s by %s on %s' % (\\n pkg_name, owner, user, branch))\\n pkg = PkgChange(\\n name=pkg_name,\\n summary=change['msg']['package_listing']['package']['summary'],\\n branch=branch,\\n new_owner=owner,\\n user=user,\\n )\\n\\n if owner == 'orphan':\\n if pkg_name in orphaned:\\n orphaned[pkg_name].add_branch(branch)\\n else:\\n orphaned[pkg_name] = pkg\\n elif owner == user:\\n if pkg_name in orphaned:\\n del(orphaned[pkg_name])\\n\\n if pkg_name in unorphaned:\\n unorphaned[pkg_name].add_branch(branch)\\n else:\\n unorphaned[pkg_name] = pkg\\n else:\\n if pkg_name in orphaned:\\n del(orphaned[pkg_name])\\n\\n if pkg_name in changed:\\n changed[pkg_name].add_branch(branch)\\n else:\\n changed[pkg_name] = pkg\\n\\n # Orphaned packages might have been deprecated:\\n retired_info = retrieve_pkgdb_retired()\\n retired = {}\\n for pkg in retired_info:\\n pkg_name = pkg['msg']['package_listing']['package']['name']\\n LOG.debug('Retired: %s' % (pkg_name))\\n if pkg_name in orphaned:\\n pkg = orphaned[pkg_name]\\n del(orphaned[pkg_name])\\n pkg.new_owner = 'retired'\\n retired[pkg_name] = pkg\\n\\n hours = int(DELTA) / 3600\\n report = 'Change in ownership over the last %s hours\\\\n' % hours\\n report += '=' * (40 + len(str(hours))) + '\\\\n'\\n\\n report += '\\\\n%s packages were orphaned\\\\n' % len(orphaned)\\n report += '-' * (len(str(len(orphaned))) + 23) + '\\\\n'\\n for pkg in orphaned:\\n report += orphaned[pkg].to_string() + '\\\\n'\\n report += ' ' * 5 + orphaned[pkg].summary + '\\\\n'\\n report += ' ' * 5 + 'https://admin.fedoraproject.org/pkgdb/'\\\\\\n 'acls/name/%s\\\\n' % orphaned[pkg].name\\n\\n report += '\\\\n%s packages unorphaned\\\\n' % len(unorphaned)\\n report += '-' * (len(str(len(unorphaned))) + 20) + '\\\\n'\\n for pkg in unorphaned:\\n if unorphaned[pkg].unorphaned():\\n report += unorphaned[pkg].to_string() + '\\\\n'\\n\\n report += '\\\\n%s packages were retired\\\\n' % len(retired)\\n report += '-' * (len(str(len(retired))) + 23) + '\\\\n'\\n for pkg in retired:\\n report += retired[pkg].to_string() + '\\\\n'\\n report += ' ' * 5 + retired[pkg].summary + '\\\\n'\\n report += ' ' * 5 + 'https://admin.fedoraproject.org/pkgdb/'\\\\\\n 'acls/name/%s\\\\n' % retired[pkg].name\\n\\n report += '\\\\n%s packages changed owner\\\\n' % len(changed)\\n report += '-' * (len(str(len(changed))) + 23) + '\\\\n'\\n for pkg in changed:\\n if not changed[pkg].unorphaned():\\n report += changed[pkg].to_string() + '\\\\n'\\n\\n report += '\\\\n\\\\nSources: https://github.com/pypingou/fedora-owner-change'\\n\\n if args.nomail:\\n print report\\n else:\\n send_report(report)\",\n \"def show_all(only_fails=True):\\n\\n if not MASTER.exists():\\n os.makedirs(MASTER)\\n members = inspect.getmembers(sys.modules[__name__])\\n members = [f for f in members if 'test_' in f[0]]\\n for member in members:\\n print('Running %s...' % member[0], end='')\\n if only_fails:\\n try:\\n member[1]()\\n except AssertionError:\\n member[1](show=True)\\n db()\\n else:\\n member[1](show=True)\\n db()\",\n \"def show_all(only_fails=True):\\n\\n if not MASTER.exists():\\n os.makedirs(MASTER)\\n members = inspect.getmembers(sys.modules[__name__])\\n members = [f for f in members if 'test_' in f[0]]\\n for member in members:\\n print('Running %s...' % member[0], end='')\\n if only_fails:\\n try:\\n member[1]()\\n except AssertionError:\\n member[1](show=True)\\n db()\\n else:\\n member[1](show=True)\\n db()\",\n \"def show_errors(self):\\n\\n if self.errors:\\n print('Clean error in:')\\n for file in self.errors:\\n print(' %s' % file)\",\n \"def checkPackageSummaries(root, level='class'):\\n\\n if level != 'class' and level != 'package' and level != 'method' and level != 'none':\\n print('unsupported level: %s, must be \\\"class\\\" or \\\"package\\\" or \\\"method\\\" or \\\"none\\\"' % level)\\n sys.exit(1)\\n \\n #for dirPath, dirNames, fileNames in os.walk('%s/lucene/build/docs/api' % root):\\n\\n if False:\\n os.chdir(root)\\n print()\\n print('Run \\\"ant javadocs\\\" > javadocs.log...')\\n if os.system('ant javadocs > javadocs.log 2>&1'):\\n print(' FAILED')\\n sys.exit(1)\\n \\n anyMissing = False\\n if not os.path.isdir(root):\\n checkClassSummaries(root)\\n checkClassDetails(root)\\n sys.exit(0)\\n \\n for dirPath, dirNames, fileNames in os.walk(root):\\n\\n if dirPath.find('/all/') != -1:\\n # These are dups (this is a bit risk, eg, root IS this /all/ directory..)\\n continue\\n\\n if 'package-summary.html' in fileNames:\\n if (level == 'class' or level == 'method') and checkSummary('%s/package-summary.html' % dirPath):\\n anyMissing = True\\n for fileName in fileNames:\\n fullPath = '%s/%s' % (dirPath, fileName)\\n if not fileName.startswith('package-') and fileName.endswith('.html') and os.path.isfile(fullPath):\\n if level == 'method':\\n if checkClassSummaries(fullPath):\\n anyMissing = True\\n # always look for broken html, regardless of level supplied\\n if checkClassDetails(fullPath):\\n anyMissing = True\\n \\n if 'overview-summary.html' in fileNames: \\n if level != 'none' and checkSummary('%s/overview-summary.html' % dirPath):\\n anyMissing = True\\n\\n return anyMissing\",\n \"def self_check(self):\\n out = \\\"Loaded components\\\\n\\\"\\n for package_name, package in sorted(self.packages.items()):\\n out += \\\"\\\\t%s:\\\\n\\\" % package_name\\n for c, fd in sorted(package.components.iteritems()):\\n out += \\\"\\\\t\\\\t%s (%s)\\\\n\\\" % (c, fd.filename)\\n\\n LOG.info(out)\\n\\n for p in self.packages.values():\\n for f in p.files:\\n for id in f.requires:\\n # This throws if it doesn't find something.\\n try:\\n self.get(id)\\n except:\\n LOG.exception(\\\"Error in: \\\" + f.filename)\\n raise\",\n \"def print_string(self):\\n for x in self.minimal:\\n print(\\\"min: %s\\\" % x)\\n for x in self.also_installed:\\n print(\\\"als: %s\\\" % x)\\n for x in self.uninstalled:\\n print(\\\"uni: %s\\\" % x)\",\n \"def list_package(all: bool = False) -> List[List[str]]:\\n if not all:\\n pkgs_info = read_installation_records()\\n else:\\n pkgs_info = []\\n for pkg in pkg_resources.working_set:\\n pkgs_info.append([pkg.project_name, pkg.version])\\n\\n return pkgs_info\",\n \"def status_all(self):\\n output = (\\n '[ + ] acpid',\\n '[ - ] alsa-utils',\\n '[ + ] anacron',\\n '[ + ] apparmor',\\n '[ + ] apport',\\n '[ + ] avahi-daemon',\\n '[ + ] bluetooth',\\n '[ - ] bootmisc.sh',\\n '[ - ] brltty',\\n '[ - ] checkfs.sh',\\n '[ - ] checkroot-bootclean.sh',\\n '[ - ] checkroot.sh',\\n '[ + ] console-setup',\\n '[ + ] cron',\\n '[ + ] cups',\\n '[ + ] cups-browsed',\\n '[ + ] dbus',\\n '[ - ] dns-clean',\\n '[ + ] grub-common',\\n '[ - ] hostname.sh',\\n '[ - ] hwclock.sh',\\n '[ + ] irqbalance',\\n '[ - ] kerneloops',\\n '[ - ] killprocs',\\n '[ + ] kmod',\\n '[ + ] lightdm',\\n '[ - ] mountall-bootclean.sh',\\n '[ - ] mountall.sh',\\n '[ - ] mountdevsubfs.sh',\\n '[ - ] mountkernfs.sh',\\n '[ - ] mountnfs-bootclean.sh',\\n '[ - ] mountnfs.sh',\\n '[ + ] network-manager',\\n '[ + ] networking',\\n '[ + ] ondemand',\\n '[ + ] open-vm-tools',\\n '[ - ] plymouth',\\n '[ - ] plymouth-log',\\n '[ - ] pppd-dns',\\n '[ + ] procps',\\n '[ - ] rc.local',\\n '[ + ] resolvconf',\\n '[ - ] rsync',\\n '[ + ] rsyslog',\\n '[ - ] saned',\\n '[ - ] sendsigs',\\n '[ + ] speech-dispatcher',\\n '[ + ] thermald',\\n '[ + ] udev',\\n '[ + ] ufw',\\n '[ - ] umountfs',\\n '[ - ] umountnfs.sh',\\n '[ - ] umountroot',\\n '[ - ] unattended-upgrades',\\n '[ + ] urandom',\\n '[ - ] uuidd',\\n '[ + ] whoopsie',\\n '[ - ] x11-common')\\n for l in output:\\n self.write(l + '\\\\n')\",\n \"def reCheckPackage(self, pid):\\n data = self.db.getPackageData(pid)\\n\\n urls = []\\n\\n for pyfile in data.itervalues():\\n if pyfile.status not in (DS.NA, DS.Finished, DS.Skipped):\\n urls.append((pyfile.url, pyfile.pluginname))\\n\\n self.core.threadManager.createInfoThread(urls, pid)\",\n \"def print_untested(self,result,cause=False):\\n untested = result.get_untested()\\n if untested:\\n print ('=== UNTESTED '+('='*59))\\n for u in untested:\\n print (u.id)\\n if cause:\\n print (' ',u.get_cause())\",\n \"def have_package_lists():\\n return 'Filename:' in execute('apt-cache', 'show', 'python', check=False, capture=True)\",\n \"def cli(paths, ignore, exit, debug, out_file):\\n if ignore:\\n ignore = ignore.split(\\\",\\\")\\n\\n package_issues = {}\\n futures = []\\n paths_glob = []\\n for path in paths:\\n glob_paths = glob(os.path.expanduser(path))\\n if not glob_paths:\\n print(\\\"Error: path spec %s didn't match any files\\\" % path)\\n sys.exit(1)\\n paths_glob.extend(glob_paths)\\n with (DummyExecutor if debug else ProcessPoolExecutor)() as executor:\\n for path in paths_glob:\\n meta_file = os.path.join(path, \\\"meta.yaml\\\")\\n if os.path.isfile(meta_file):\\n futures.extend(_submit_verify_recipe(path, executor, ignore))\\n elif path.endswith((\\\".tar.bz2\\\", \\\".tar\\\", \\\".conda\\\")):\\n futures.append(executor.submit(_submit_verify_package, path, ignore))\\n for f in tqdm.tqdm(as_completed(futures), total=len(futures), leave=False):\\n path, issues = f.result()\\n if issues:\\n package_issues[path] = issues\\n\\n if out_file:\\n with open(out_file, \\\"w\\\") as f:\\n json.dump(package_issues, f)\\n print(\\\"saved to %s\\\" % out_file)\\n else:\\n for path, issues in package_issues.items():\\n print(\\\"-\\\" * len(path))\\n print(path)\\n print(\\\"-\\\" * len(path))\\n for check in sorted(issues):\\n try:\\n print(check, file=sys.stderr)\\n except UnicodeEncodeError:\\n print(\\n \\\"Could not print message for error code {} due to unicode error\\\".format(\\n check.code\\n ),\\n file=sys.stderr,\\n )\\n\\n if exit and package_issues:\\n sys.exit(1)\",\n \"def missing_tests(session):\\n print('The following samples do not have tests:')\\n for sample in set(ALL_SAMPLE_DIRECTORIES) - set(ALL_TESTED_SAMPLES):\\n print('* {}'.format(sample))\",\n \"async def diagnostic_report(d):\\n msg = \\\"Diagnostic Report\\\\n\\\\n\\\"\\n msg += \\\"All of the following programs must be installed (✔) on your computer before you can use Proof Wallet.\\\\n\\\\n\\\"\\n for k, v in d.items():\\n msg += f\\\"{k}: {'✔' if v else 'X'}\\\\n\\\"\\n msg += \\\"\\\\nOnce all the programs are installed, press ENTER to proceed.\\\"\\n return await ux_show_story(msg, ['\\\\r'])\",\n \"def missing_requirements_command(args, packages=None, exit_on_failure=True):\\n requirements_files = (\\n args.requirements or Config.requirements_files or []\\n )\\n ignore_list = (\\n args.ignore or Config.ignore_list or []\\n )\\n\\n printer = Printer()\\n if not validate_files(\\n files=requirements_files,\\n printer=printer,\\n exit_on_failure=exit_on_failure):\\n return False\\n\\n requirements = RequirementCollection()\\n for requirements_file in requirements_files:\\n requirements.extend(\\n RequirementCollection.from_file(filepath=requirements_file)\\n )\\n\\n packages = (\\n packages or dependency_list(ignore_list=ignore_list)\\n )\\n\\n missing = [\\n (package, required_by)\\n for package, required_by\\n in missing_requirements(\\n packages=packages,\\n requirements=requirements,\\n ignore_list=ignore_list\\n )\\n ]\\n\\n headers = [\\n messages.PACKAGE,\\n messages.REQUIRED,\\n messages.REQUIRED_BY,\\n ]\\n\\n tabular_data = []\\n for package, requirers in missing:\\n if requirers:\\n for required_by, required_version in requirers:\\n tabular_data.append([\\n printer.colored_message(\\n message=package.key,\\n message_color=printer.color_package\\n ),\\n required_version,\\n required_by.key,\\n ])\\n else:\\n tabular_data.append([\\n printer.colored_message(\\n message=package.key,\\n message_color=printer.color_package\\n ),\\n package.version.specifier,\\n \\\"Requirements\\\",\\n ])\\n\\n if tabular_data:\\n printer.error(messages.MISSING_FOUND)\\n printer.table(headers=headers, tabular_data=tabular_data)\\n if exit_on_failure:\\n sys.exit(1)\\n return False\\n\\n printer.success(messages.MISSING_OK)\\n return True\",\n \"def list_cmd(repo):\\n click.echo('Packages and scripts installed through pipsi:')\\n for venv, scripts in repo.list_everything():\\n if not scripts:\\n continue\\n click.echo(' Package \\\"%s\\\":' % venv)\\n for script in scripts:\\n click.echo(' ' + script)\",\n \"def check_puppet_logs_ubuntu(self):\\n\\n remote = self.env.get_admin_remote()\\n\\n err_start = 'The following packages have unmet dependencies:'\\n err_end = ('Unable to correct problems,'\\n ' you have held broken packages.')\\n cmd = ('fgrep -h -e \\\" Depends: \\\" -e \\\"{0}\\\" -e \\\"{1}\\\" '\\n '/var/log/docker-logs/remote/node-*/'\\n 'puppet*.log'.format(err_start, err_end))\\n result = remote.execute(cmd)['stdout']\\n\\n err_deps = {}\\n err_deps_key = ''\\n err_deps_flag = False\\n\\n # Forming a dictionary of package names\\n # with sets of required packages.\\n for res_str in result:\\n if err_deps_flag:\\n if err_end in res_str:\\n err_deps_flag = False\\n elif \\\": Depends:\\\" in res_str:\\n str0, str1, str2 = res_str.partition(': Depends:')\\n err_deps_key = ''.join(str0.split()[-1:])\\n if err_deps_key not in err_deps:\\n err_deps[err_deps_key] = set()\\n if 'but it is not' in str2 or 'is to be installed' in str2:\\n err_deps[err_deps_key].add('Depends:{0}'\\n .format(str2))\\n elif 'Depends:' in res_str and err_deps_key:\\n str0, str1, str2 = res_str.partition('Depends:')\\n if 'but it is not' in str2 or 'is to be installed' in str2:\\n err_deps[err_deps_key].add(str1 + str2)\\n else:\\n err_deps_key = ''\\n elif err_start in res_str:\\n err_deps_flag = True\\n\\n return err_deps\",\n \"def required_packages(cls) -> List[Text]:\\n return []\",\n \"def recheck_conts_package(conts_dict, si_result):\\n print('######## BEGIN CHECKING PACKAGES ? ########')\\n packages = si_result.get('packages', True)\\n description = si_result.get('description_of_goods', False)\\n pUnit = None\\n print(packages == description)\\n\\n if packages == description:\\n conts_package = []\\n for unit in current_app.config['CONTAINER_PACKAGE_UNITS']:\\n re_unit = re.compile(\\n r'(\\\\d+\\\\W*(' +\\n unit + r'(s|S)?\\\\s?(\\\\Ws\\\\W|\\\\WS\\\\W)?' +\\n r')\\\\W*)|(\\\\W*(' +\\n unit + r'(s|S)?\\\\s?(\\\\Ws\\\\W|\\\\WS\\\\W)?' +\\n r')\\\\W*\\\\d+)')\\n units_result = re.findall(re_unit, packages)\\n\\n if (\\n len(units_result) == len(conts_dict)\\n ) or (\\n len(units_result) == len(conts_dict) + 1\\n ):\\n for result in units_result:\\n print(result)\\n if len(result[0]) > len(unit):\\n print('result[0]', result[0])\\n conts_package.append(\\n re.sub(r'[^\\\\d]+', '', result[0]))\\n elif len(result[4]) > len(unit):\\n print('result[4]', result[4])\\n conts_package.append(\\n re.sub(r'[^\\\\d]+', '', result[4]))\\n\\n if unit.isupper():\\n pUnit = unit + 'S'\\n else:\\n pUnit = unit + 's'\\n\\n break\\n\\n if len(conts_package) >= len(conts_dict):\\n for i, cont in enumerate(conts_dict):\\n cont['packages'] = str(conts_package[i]) + ' ' + pUnit\\n\\n return conts_dict\",\n \"def check(self, quiet=False, exclude=None):\\n\\n exclude = exclude if exclude else []\\n missing = set()\\n pkg_types = set()\\n python_interpreters = set()\\n vcs_types = set()\\n\\n # package-defined requirements check\\n for pkg in self.pkgs:\\n if pkg.type not in exclude:\\n pkg_types.add(pkg.type)\\n if pkg.vcs_type not in exclude:\\n vcs_types.add(pkg.vcs_type)\\n\\n if pkg.type == PackageType.AUTOTOOLS:\\n if pkg.autotools_autoreconf:\\n if AUTORECONF_COMMAND not in exclude:\\n if AUTORECONF.exists():\\n self._verbose_exists(AUTORECONF)\\n else:\\n missing.add(AUTORECONF.tool)\\n\\n elif pkg.type == PackageType.PYTHON:\\n if pkg.python_interpreter:\\n if pkg.python_interpreter not in exclude:\\n python_tool = PythonTool(pkg.python_interpreter)\\n python_interpreters.add(python_tool)\\n else:\\n python_interpreters.add(PYTHON)\\n\\n if PackageType.AUTOTOOLS in pkg_types or PackageType.MAKE in pkg_types:\\n if MAKE.exists():\\n self._verbose_exists(MAKE)\\n else:\\n missing.add(MAKE.tool)\\n\\n if PackageType.CMAKE in pkg_types:\\n if CMAKE.exists():\\n self._verbose_exists(CMAKE)\\n else:\\n missing.add(CMAKE.tool)\\n\\n if PackageType.MESON in pkg_types:\\n if MESON.exists():\\n self._verbose_exists(MESON)\\n else:\\n missing.add(MESON.tool)\\n\\n if PackageType.PYTHON in pkg_types:\\n for interpreter in python_interpreters:\\n if interpreter.exists():\\n self._verbose_exists(interpreter)\\n else:\\n missing.add(interpreter.tool)\\n\\n if PackageType.SCONS in pkg_types:\\n if SCONS.exists():\\n self._verbose_exists(SCONS)\\n else:\\n missing.add(SCONS.tool)\\n\\n if VcsType.BZR in vcs_types:\\n if BZR.exists():\\n self._verbose_exists(BZR)\\n else:\\n missing.add(BZR.tool)\\n\\n if VcsType.CVS in vcs_types:\\n if CVS.exists():\\n self._verbose_exists(CVS)\\n else:\\n missing.add(CVS.tool)\\n\\n if VcsType.GIT in vcs_types:\\n if GIT.exists():\\n self._verbose_exists(GIT)\\n else:\\n missing.add(GIT.tool)\\n\\n if VcsType.HG in vcs_types:\\n if HG.exists():\\n self._verbose_exists(HG)\\n else:\\n missing.add(HG.tool)\\n\\n if VcsType.PERFORCE in vcs_types:\\n if GIT.exists():\\n self._verbose_exists(GIT)\\n else:\\n missing.add(GIT.tool)\\n\\n if VcsType.RSYNC in vcs_types:\\n if RSYNC.exists():\\n self._verbose_exists(RSYNC)\\n else:\\n missing.add(RSYNC.tool)\\n\\n if VcsType.SCP in vcs_types:\\n if SCP.exists():\\n self._verbose_exists(SCP)\\n else:\\n missing.add(SCP.tool)\\n\\n if VcsType.SVN in vcs_types:\\n if SVN.exists():\\n self._verbose_exists(SVN)\\n else:\\n missing.add(SVN.tool)\\n\\n # project-provided tools check\\n for tool in self.tools:\\n if tool not in exclude:\\n if which(tool):\\n verbose('prerequisite exists: ' + tool)\\n else:\\n missing.add(tool)\\n\\n if missing and not quiet:\\n sorted_missing = list(missing)\\n sorted_missing.sort()\\n\\n msg = 'missing the following host tools for this project:'\\n msg += '\\\\n'\\n msg += '\\\\n'\\n for entry in sorted_missing:\\n msg += ' ' + entry + '\\\\n'\\n err(msg)\\n\\n return len(missing) == 0\",\n \"def package_info(self, package, repo):\\n\\n cmd_output = admin_tasks.yum_info(package, repo)\\n if cmd_output:\\n self.log.info(\\\"%s package exists\\\" % package)\\n print(\\\"Command output: \\\\n\\\" + cmd_output)\\n else:\\n self.log.error(\\\"%s package was not found\\\" % package)\\n sys.exit(1)\",\n \"def getAllInstalledPackages(installedPkgPath):\\n allPkgVers = []\\n if os.path.exists(installedPkgPath):\\n for pkg in os.listdir(installedPkgPath):\\n pkgVersions = os.listdir(os.path.join(installedPkgPath, pkg))\\n for pkgVersion in pkgVersions:\\n pkgPath = os.path.join(installedPkgPath, pkg)\\n if not fnmatch.fnmatch(pkgVersion, '*.inprogress'):\\n allPkgVers.append(os.path.join(pkgPath, pkgVersion))\\n return allPkgVers\",\n \"def showerrors():\\n errorMessages = middleware.ixn.showErrorMessage(silentMode=True)\\n if errorMessages:\\n print(errorMessages)\\n print()\",\n \"def test_all_package_avail(self):\\n # Add 2 course packages to the table\\n args = ('Best package', '10', '2020-04-04', '2023-05-06', '200.01')\\n query = self.generate_query('add_course_package', args)\\n res = self.execute_query(query)\\n args = ('Best package2', '10', '2020-04-04', '2023-05-06', '200.01')\\n query = self.generate_query('add_course_package', args)\\n res = self.execute_query(query)\\n\\n # Check if there are 2 course package\\n q = self.generate_query(\\\"get_available_course_packages\\\", ())\\n res = self.execute_query(q)\\n\\n assert (\\n len(res) == 2\\n ), \\\"There should be 2 course packages available\\\"\\n expected =set((('(\\\\\\\"Best package\\\\\\\",10,2023-05-06,200.01)',), ('(\\\\\\\"Best package2\\\\\\\",10,2023-05-06,200.01)',)))\\n assert set(res) == expected, f'\\\\nOutput: {res}\\\\nExpected: {expected}'\",\n \"def _info():\\n\\n emitter.publish(default_command_info(\\\"package\\\"))\\n return 0\",\n \"def log_installed_modules(self):\\n\\n # Get python modules installed locally\\n\\n installed_packages = pkg_resources.working_set\\n\\n python_str = f'python:{sys.version}\\\\n'\\n print_str = \\\"\\\\n\\\".join(f\\\"{package.key}: {package.version}\\\" for package in installed_packages)\\n msg = f\\\"Installed packages:\\\\n{python_str+print_str}\\\"\\n logger.info(msg)\",\n \"def report():\\n\\n global COUNTER\\n \\n if COUNTER > 0:\\n print('\\\\n\\\\n')\\n\\n print('Searched {0} files'.format(SEARCHED))\\n print('Found {0} TODOs in {1} files'.format(COUNTER, F_COUNTER))\",\n \"def print_tests(pkg):\\n\\n # Some built-in base packages (e.g., Autotools) define callback (e.g.,\\n # check) inherited by descendant packages. These checks may not result\\n # in build-time testing if the package's build does not implement the\\n # expected functionality (e.g., a 'check' or 'test' targets).\\n #\\n # So the presence of a callback in Spack does not necessarily correspond\\n # to the actual presence of built-time tests for a package.\\n for callbacks, phase in [\\n (pkg.build_time_test_callbacks, \\\"Build\\\"),\\n (pkg.install_time_test_callbacks, \\\"Install\\\"),\\n ]:\\n color.cprint(\\\"\\\")\\n color.cprint(section_title(\\\"Available {0} Phase Test Methods:\\\".format(phase)))\\n names = []\\n if callbacks:\\n for name in callbacks:\\n if getattr(pkg, name, False):\\n names.append(name)\\n\\n if names:\\n colify(sorted(names), indent=4)\\n else:\\n color.cprint(\\\" None\\\")\\n\\n # PackageBase defines an empty install/smoke test but we want to know\\n # if it has been overridden and, therefore, assumed to be implemented.\\n color.cprint(\\\"\\\")\\n color.cprint(section_title(\\\"Stand-Alone/Smoke Test Methods:\\\"))\\n names = []\\n pkg_cls = pkg if inspect.isclass(pkg) else pkg.__class__\\n if has_test_method(pkg_cls):\\n pkg_base = spack.package_base.PackageBase\\n test_pkgs = [\\n str(cls.test)\\n for cls in inspect.getmro(pkg_cls)\\n if issubclass(cls, pkg_base) and cls.test != pkg_base.test\\n ]\\n test_pkgs = list(set(test_pkgs))\\n names.extend([(test.split()[1]).lower() for test in test_pkgs])\\n\\n # TODO Refactor START\\n # Use code from package_base.py's test_process IF this functionality is\\n # accepted.\\n v_names = list(set([vspec.name for vspec in pkg.virtuals_provided]))\\n\\n # hack for compilers that are not dependencies (yet)\\n # TODO: this all eventually goes away\\n c_names = (\\\"gcc\\\", \\\"intel\\\", \\\"intel-parallel-studio\\\", \\\"pgi\\\")\\n if pkg.name in c_names:\\n v_names.extend([\\\"c\\\", \\\"cxx\\\", \\\"fortran\\\"])\\n if pkg.spec.satisfies(\\\"llvm+clang\\\"):\\n v_names.extend([\\\"c\\\", \\\"cxx\\\"])\\n # TODO Refactor END\\n\\n v_specs = [spack.spec.Spec(v_name) for v_name in v_names]\\n for v_spec in v_specs:\\n try:\\n pkg_cls = spack.repo.path.get_pkg_class(v_spec.name)\\n if has_test_method(pkg_cls):\\n names.append(\\\"{0}.test\\\".format(pkg_cls.name.lower()))\\n except spack.repo.UnknownPackageError:\\n pass\\n\\n if names:\\n colify(sorted(names), indent=4)\\n else:\\n color.cprint(\\\" None\\\")\",\n \"def check_import():\\n print('[GenHub] Checking Python modules.')\\n\\n basemod = [('yaml', 'pyyaml'), ('pycurl', 'pycurl')]\\n devmod = ['pep8', 'pytest', 'pytest-cov', 'coverage']\\n\\n packages = dict()\\n for importname, packagename in basemod:\\n try:\\n importlib.import_module(importname)\\n packages[packagename] = True\\n except ImportError:\\n packages[packagename] = False\\n for packagename in devmod:\\n try:\\n importlib.import_module(packagename)\\n packages[packagename] = True\\n except ImportError:\\n packages[packagename] = False\\n\\n rundep = False\\n for pkg in packages:\\n char = '+'\\n msg = 'Installed.'\\n if packages[pkg] is False:\\n char = '-'\\n msg = 'Not installed!'\\n rundep = True\\n print('%c package %-12s: %s' % (char, pkg, msg))\\n if rundep is True:\\n print('Please install these dependencies before proceding')\\n print('')\",\n \"def get_other_updates(self):\\n self.composite_logger.log(\\\"\\\\nDiscovering 'other' packages...\\\")\\n other_packages = []\\n other_package_versions = []\\n\\n all_packages, all_package_versions = self.get_all_updates(True)\\n security_packages, security_package_versions = self.get_security_updates()\\n if len(security_packages) == 0 and 'CentOS' in str(self.env_layer.platform.linux_distribution()): # deliberately terminal - erring on the side of caution to avoid dissat in uninformed customers\\n self.composite_logger.log_error(\\\"Please review patch management documentation for information on classification-based patching on YUM.\\\")\\n error_msg = \\\"Classification-based patching is only supported on YUM if the computer is independently configured to receive classification information.\\\" \\\\\\n \\\"Please remove classifications from update deployments to CentOS machines to bypass this error.\\\"\\n self.status_handler.add_error_to_status(error_msg, Constants.PatchOperationErrorCodes.PACKAGE_MANAGER_FAILURE)\\n raise Exception(error_msg, \\\"[{0}]\\\".format(Constants.ERROR_ADDED_TO_STATUS))\\n\\n for index, package in enumerate(all_packages):\\n if package not in security_packages:\\n other_packages.append(package)\\n other_package_versions.append(all_package_versions[index])\\n\\n self.composite_logger.log(\\\"Discovered \\\" + str(len(other_packages)) + \\\" 'other' package entries.\\\")\\n return other_packages, other_package_versions\",\n \"def print_notices(cls, settings: Settings):\\n if settings.get(\\\"wallet.type\\\", \\\"in_memory\\\").lower() == \\\"indy\\\":\\n with Banner(border=\\\":\\\", length=80, file=sys.stderr) as banner:\\n banner.centered(\\\"⚠ DEPRECATION NOTICE: ⚠\\\")\\n banner.hr()\\n banner.print(\\n \\\"The Indy wallet type is deprecated, use Askar instead; see: \\\"\\n \\\"https://aca-py.org/main/deploying/IndySDKtoAskarMigration/\\\",\\n )\\n print()\",\n \"def report(self):\\n print()\\n print(\\\"%-15s %-25s %s\\\" % (\\\"Class\\\", \\\"Name\\\", \\\"File\\\"))\\n print(\\\"%-15s %-25s %s\\\" % (\\\"-----\\\", \\\"----\\\", \\\"----\\\"))\\n for m in sorted(self.flatten(), key=lambda n: n.identifier):\\n print(\\\"%-15s %-25s %s\\\" % (type(m).__name__, m.identifier, m.filename or \\\"\\\"))\",\n \"def _get_all_pkg_info(self):\\n all_pkgs = self._filter_pkgs(self._go_list(\\\"./...\\\"))\\n # for every package, list the deps, the test files, the test imports, and the external package test imports\\n big_list = self._go_list(\\n \\\"-f\\\", \\\"{{.ImportPath}}:{{.Deps}}:{{.TestImports}}:{{.XTestImports}}\\\", *all_pkgs)\\n recursive_deps = {}\\n test_imports = {}\\n\\n for line in big_list:\\n tokens = [token.strip().lstrip('[').rstrip(']').strip() for token in line.split(\\\":\\\", 3)]\\n pkg = tokens[0].strip()\\n\\n recursive_deps[pkg] = set(self._filter_pkgs(tokens[1].split() + [pkg]))\\n if tokens[2] or tokens[3]:\\n test_imports[pkg] = set(\\n self._filter_pkgs(tokens[2].split()) + self._filter_pkgs(tokens[3].split()))\\n\\n return recursive_deps, test_imports\",\n \"def result_printer(self):\\n for i in self.output:\\n for item, value in i.items():\\n if not isinstance(value, list) and \\\"http://\\\" not in value:\\n print(f\\\"{item} : {value}\\\")\\n print(20 * '-')\",\n \"def populate_package(package_count: int) -> None:\\n logging.info(f\\\"Fetching {package_count} packages\\\")\\n response = CurlController.send_get_request(url=CONFIG.EXTERNAL_API.ALL_PACKAGES)\\n get_version = False\\n count = 0\\n temp_dir = filestore.generate_temp_dir()\\n # Local Testing\\n # response_arr = ['Package: A3', 'Version: 1.0.0', 'Depends: R (>= 2.15.0), xtable, pbapply', 'Suggests: randomForest, e1071', 'License: GPL (>= 2)', 'MD5sum: 027ebdd8affce8f0effaecfcd5f5ade2', 'NeedsCompilation: no', '', 'Package: aaSEA', 'Version: 1.1.0', 'Depends: R(>= 3.4.0)', 'Imports: DT(>= 0.4), networkD3(>= 0.4), shiny(>= 1.0.5),', ' shinydashboard(>= 0.7.0), magrittr(>= 1.5), Bios2cor(>= 2.0),', ' seqinr(>= 3.4-5), plotly(>= 4.7.1), Hmisc(>= 4.1-1)', 'Suggests: knitr, rmarkdown', 'License: GPL-3', 'MD5sum: 0f9aaefc1f1cf18b6167f85dab3180d8', 'NeedsCompilation: no', '', 'Package: AATtools', 'Version: 0.0.1', 'Depends: R (>= 3.6.0)', 'Imports: magrittr, dplyr, doParallel, foreach', 'License: GPL-3', 'MD5sum: 3bd92dbd94573afb17ebc5eab23473cb', 'NeedsCompilation: no', '', 'Package: ABACUS', 'Version: 1.0.0', 'Depends: R (>= 3.1.0)', 'Imports: ggplot2 (>= 3.1.0), shiny (>= 1.3.1),', 'Suggests: rmarkdown (>= 1.13), knitr (>= 1.22)', 'License: GPL-3', 'MD5sum: 50c54c4da09307cb95a70aaaa54b9fbd', 'NeedsCompilation: no', '', 'Package: abbyyR', 'Version: 0.5.5', 'Depends: R (>= 3.2.0)', 'Imports: httr, XML, curl, readr, plyr, progress', 'Suggests: testthat, rmarkdown, knitr (>= 1.11), lintr', 'License: MIT + file LICENSE', 'MD5sum: e048a3bca6ea32126e6c367415c0bfaf', 'NeedsCompilation: no', '', 'Package: abc', 'Version: 2.1', 'Depends: R (>= 2.10), abc.data, nnet, quantreg, MASS, locfit', 'License: GPL (>= 3)', 'MD5sum: c9fffe4334c178917f762735aba59653', 'NeedsCompilation: no', '', 'Package: abc.data', 'Version: 1.0', 'Depends: R (>= 2.10)', 'License: GPL (>= 3)', 'MD5sum: 799079dbbdd0cfc9d9c61c3e35241806', 'NeedsCompilation: no', '', 'Package: ABC.RAP', 'Version: 0.9.0', 'Depends: R (>= 3.1.0)', 'Imports: graphics, stats, utils', 'Suggests: knitr, rmarkdown', 'License: GPL-3', 'MD5sum: 38c65a7251d28ef2462ee430ded95700', 'NeedsCompilation: no', '', 'Package: abcADM', 'Version: 1.0', 'Imports: Rcpp (>= 1.0.1)', 'LinkingTo: Rcpp, BH', 'License: GPL-3', 'MD5sum: 8134f67912b506194e3dab4ccd6e75f7', 'NeedsCompilation: yes', '', 'Package: ABCanalysis', 'Version: 1.2.1', 'Depends: R (>= 2.10)', 'Imports: plotrix', 'License: GPL-3', 'MD5sum: 678e03837e25a922bf71bafe1f8de617', 'NeedsCompilation: no', '', 'Package: abcdeFBA', 'Version: 0.4', 'Depends: Rglpk,rgl,corrplot,lattice,R (>= 2.10)', 'Suggests: LIM,sybil', 'License: GPL-2', 'MD5sum: c84d45a85d8ab6bbe517365e8845db83', 'NeedsCompilation: no', '', 'Package: ABCoptim', 'Version: 0.15.0', 'Imports: Rcpp, graphics, stats, utils', 'LinkingTo: Rcpp', 'Suggests: testthat, covr', 'License: MIT + file LICENSE', 'MD5sum: a62ed03650273c09899655065437078f', 'NeedsCompilation: yes', '', 'Package: ABCp2', 'Version: 1.2', 'Depends: MASS', 'License: GPL-2', 'MD5sum: e920282d5a369df71e15241be40cb60e', 'NeedsCompilation: no', '', 'Package: abcrf', 'Version: 1.8.1', 'Depends: R(>= 3.1)', 'Imports: readr, MASS, matrixStats, ranger, doParallel, parallel,', ' foreach, stringr, Rcpp (>= 0.11.2)', 'LinkingTo: Rcpp, RcppArmadillo', 'License: GPL (>= 2)', 'MD5sum: 4d5a304f46d117226791523cef4e2427', 'NeedsCompilation: yes', '', 'Package: abcrlda', 'Version: 1.0.3', 'Imports: stats', 'License: GPL-3', 'MD5sum: 651e6e18e08916b443aaf011b5a63525', 'NeedsCompilation: no', '', 'Package: abctools', 'Version: 1.1.3', 'Depends: R (>= 2.10), abc, abind, parallel, plyr, Hmisc', 'Suggests: ggplot2, abc.data', 'License: GPL (>= 2)', 'MD5sum: c5937b65837ef7e6bfbe141cea257f40', 'NeedsCompilation: yes', '', 'Package: abd', 'Version: 0.2-8', 'Depends: R (>= 3.0), nlme, lattice, grid, mosaic', 'Suggests: boot, car, ggplot2, plyr, HH, ICC, vcd, Hmisc', 'License: GPL-2', 'MD5sum: 1913d76a0fbc44222709381f63f385b9', 'NeedsCompilation: no', '', 'Package: abdiv', 'Version: 0.2.0', 'Imports: ape', 'Suggests: testthat (>= 2.1.0), vegan', 'License: MIT + file LICENSE', 'MD5sum: 80931c0ca85ba5386000bf617552c5ce', 'NeedsCompilation: no', '', 'Package: abe', 'Version: 3.0.1', 'License: GPL (>= 2)', 'MD5sum: 9c151db5397422c8927dee41dabfbfab', 'NeedsCompilation: no', '', 'Package: abess', 'Version: 0.3.0', 'Depends: R (>= 3.1.0)', 'Imports: Rcpp, MASS, methods, Matrix', 'LinkingTo: Rcpp, RcppEigen', 'Suggests: testthat, knitr, rmarkdown', 'License: GPL (>= 3) | file LICENSE', 'MD5sum: e0ea7d068147c49c011c7135ab290bd3', 'NeedsCompilation: yes', '', 'Package: abf2', 'Version: 0.7-1', 'License: Artistic-2.0', 'MD5sum: 6792a51c6fb3e239165d69aa8a71d3cd', 'NeedsCompilation: no', '', 'Package: abglasso', 'Version: 0.1.1', 'Imports: MASS, pracma, stats, statmod', 'Suggests: testthat', 'License: GPL-3', 'MD5sum: 18bd0759cd005c5ac6fb515799b3f3d8', 'NeedsCompilation: no', '', 'Package: ABHgenotypeR', 'Version: 1.0.1', 'Imports: ggplot2, reshape2, utils', 'Suggests: knitr, rmarkdown', 'License: GPL-3', 'MD5sum: ca4397ba7390c0e0a3728c0cda864494', 'NeedsCompilation: no', '', 'Package: abind', 'Version: 1.4-5', 'Depends: R (>= 1.5.0)', 'Imports: methods, utils', 'License: LGPL (>= 2)', 'MD5sum: 136f981e1c4f618b64a87faaa7797c97', 'NeedsCompilation: no', '', 'Package: abjutils', 'Version: 0.3.1', 'Depends: R (>= 4.0)', 'Imports: dplyr, magrittr, purrr, rlang, rstudioapi, stringi, stringr,', ' tidyr', 'Suggests: testthat', 'License: MIT + file LICENSE', 'MD5sum: a596c07aaa7f82e5d123b2f7354e5b55', 'NeedsCompilation: no', '', 'Package: abmR', 'Version: 1.0.2', 'Depends: R (>= 3.5)', 'Imports: sp, rgdal, table1, googledrive, swfscMisc, geosphere,', ' kableExtra, gtsummary, ggplot2, gstat, purrr, rnaturalearth,', ' rnaturalearthdata, sf, tmap, raster, utils, stats, methods,', ' rgeos', 'Suggests: jpeg, knitr', 'License: GPL (>= 3)', 'MD5sum: cf96d']\\n response_arr = response.decode(\\\"utf-8\\\").split(\\\"\\\\n\\\")\\n with temp_dir:\\n for item in response_arr:\\n if count >= package_count:\\n break\\n if get_version:\\n # Fetching the version, once we have the package name\\n package_version = Command.get_package_version(item=item)\\n if package_version:\\n # Generating the required URL for the package to fetch the details\\n package_url = Template(\\n CONFIG.EXTERNAL_API.PACKAGE_DETAIL\\n ).substitute(\\n package_name=package_name,\\n separator=\\\"_\\\",\\n package_version=package_version,\\n )\\n logging.info(f\\\"Downloading {package_url}\\\")\\n # Downloading the details of the package and extracting the DESCRIPTION file\\n extract_file_path = filestore.join_paths(\\n prefix=package_name,\\n suffix=CONFIG.EXTERNAL_API.DETAIL_FILE_NAME,\\n )\\n target_dir = filestore.download_file(\\n url=package_url,\\n temp_dir=temp_dir,\\n extract_file_path=extract_file_path,\\n )\\n # Reading contents of DESCRIPTION file\\n package_details = filestore.join_paths(\\n prefix=temp_dir.name,\\n suffix=extract_file_path,\\n )\\n with open(package_details) as details_file:\\n for line in details_file:\\n if line.startswith(PackageInfoPrefix.PUBLICATION_DATE):\\n publication_time_str = (\\n Command.get_publication_timestamp(line)\\n )\\n publication_timestamp = (\\n datetime_util.string_to_datetime(\\n publication_time_str\\n )\\n )\\n elif line.startswith(PackageInfoPrefix.TITLE):\\n title = Command.get_package_title(line)\\n elif line.startswith(PackageInfoPrefix.DESCRIPTION):\\n description = Command.get_package_description(line)\\n elif line.startswith(PackageInfoPrefix.AUTHOR):\\n (\\n author_name,\\n author_email,\\n ) = Command.get_package_author(line)\\n elif line.startswith(PackageInfoPrefix.MAINTAINER):\\n (\\n maintainer_name,\\n maintainer_email,\\n ) = Command.get_package_maintainer(line)\\n\\n package_info_dict = {\\n \\\"name\\\": package_name,\\n \\\"version\\\": package_version,\\n \\\"publication_timestamp\\\": publication_timestamp,\\n \\\"title\\\": title,\\n \\\"description\\\": description,\\n \\\"author_name\\\": author_name,\\n \\\"author_email\\\": author_email,\\n \\\"maintainer_name\\\": maintainer_name,\\n \\\"maintainer_email\\\": maintainer_email,\\n }\\n logging.info(package_info_dict)\\n obj = PackageManager.create_object(\\n create_data=package_info_dict\\n )\\n if obj == CONFIG.DB.FAILURE:\\n raise Exception(f\\\"Could not insert package in DB\\\")\\n count += 1\\n get_version = False\\n # Fetching the package name\\n package_name = Command.get_package_name(item=item)\\n if package_name:\\n get_version = True\",\n \"def report(self):\\n\\t\\tprint()\\n\\t\\tprint(\\\"**************************************************\\\")\\n\\t\\tif not self.host_and_ports:\\n\\t\\t\\tprint(\\\"No hosts have been scanned or loaded yet\\\")\\n\\t\\t\\treturn\\n\\t\\tprint(\\\"Here are all open ports found for all hosts scanned: \\\")\\n\\t\\tfor h in self.host_and_ports.keys():\\n\\t\\t\\tprint(\\\"HOST: %s\\\" % h)\\n\\t\\t\\tif not self.host_and_ports[h]:\\n\\t\\t\\t\\tprint(\\\"No open ports found for this host yet\\\")\\n\\t\\t\\tfor p in self.host_and_ports[h]:\\n\\t\\t\\t\\tprint(\\\"Open: %d\\\" % p)\\n\\t\\tprint(\\\"**************************************************\\\")\\n\\t\\tprint()\",\n \"def show_solution_differences_to_user(self, solution: List['Package'], upstream_system: 'System',\\n noconfirm: bool, deep_search: bool, solution_way: bool):\\n\\n # needed strings\\n package_to_install = aurman_note(\\n \\\"The following {} package(s) are getting {}:\\\".format(\\n \\\"{}\\\", Colors.BOLD(Colors.LIGHT_CYAN(\\\"installed\\\"))\\n ), True, False\\n )\\n packages_to_uninstall = aurman_note(\\n \\\"The following {} package(s) are predicted to get {}:\\\".format(\\n \\\"{}\\\", Colors.BOLD(Colors.LIGHT_CYAN(\\\"removed\\\"))\\n ), True, False\\n )\\n packages_to_upgrade = aurman_note(\\n \\\"The following {} package(s) are getting {}:\\\".format(\\n \\\"{}\\\", Colors.BOLD(Colors.LIGHT_CYAN(\\\"updated\\\"))\\n ), True, False\\n )\\n packages_to_reinstall = aurman_note(\\n \\\"The following {} package(s) are getting {}:\\\".format(\\n \\\"{}\\\", Colors.BOLD(Colors.LIGHT_CYAN(\\\"reinstalled\\\"))\\n ), True, False\\n )\\n user_question = \\\"Do you want to continue?\\\"\\n\\n new_system = self.hypothetical_append_packages_to_system(solution)\\n differences_to_this_system_tuple = self.differences_between_systems((new_system,))[0]\\n\\n to_install_names = set([package.name for package in differences_to_this_system_tuple[0]])\\n to_uninstall_names = set([package.name for package in differences_to_this_system_tuple[1]])\\n to_upgrade_names = to_install_names & to_uninstall_names\\n to_install_names -= to_upgrade_names\\n to_uninstall_names -= to_upgrade_names\\n just_reinstall_names = set(\\n [package.name for package in solution if package.name in new_system.all_packages_dict]\\n ) - set.union(\\n *[to_upgrade_names, to_install_names, to_uninstall_names]\\n )\\n\\n # colored names + repos\\n print_to_install_names = set([upstream_system.repo_of_package(name) for name in to_install_names])\\n print_to_uninstall_names = set([upstream_system.repo_of_package(name) for name in to_uninstall_names])\\n print_to_upgrade_names = set([upstream_system.repo_of_package(name) for name in to_upgrade_names])\\n print_just_reinstall_names = set([upstream_system.repo_of_package(name) for name in just_reinstall_names])\\n\\n # calculate some needed values\\n max_package_name_length = max(\\n [\\n len(name) for name in\\n set(print_to_install_names |\\n print_to_uninstall_names |\\n print_to_upgrade_names |\\n print_just_reinstall_names)\\n ],\\n default=0\\n )\\n\\n max_left_side_version_length = max(\\n [\\n len(self.all_packages_dict[package_name].version) for package_name in\\n set(to_uninstall_names | to_upgrade_names | just_reinstall_names)\\n ],\\n default=1\\n )\\n\\n if to_install_names:\\n print(package_to_install.format(len(to_install_names)))\\n for package_name in sorted(list(to_install_names)):\\n string_to_print = \\\" {} {} -> {}\\\".format(\\n upstream_system.repo_of_package(package_name).ljust(max_package_name_length),\\n Colors.RED(\\\"/\\\").ljust(max_left_side_version_length + 10),\\n Colors.GREEN(new_system.all_packages_dict[package_name].version)\\n )\\n\\n print(string_to_print)\\n\\n if to_upgrade_names:\\n print(packages_to_upgrade.format(len(to_upgrade_names)))\\n for package_name in sorted(list(to_upgrade_names)):\\n string_to_print = \\\" {} {} -> {}\\\".format(\\n upstream_system.repo_of_package(package_name).ljust(max_package_name_length),\\n Colors.RED(self.all_packages_dict[package_name].version).ljust(max_left_side_version_length + 10),\\n Colors.GREEN(new_system.all_packages_dict[package_name].version)\\n )\\n\\n print(string_to_print)\\n\\n if just_reinstall_names and not deep_search:\\n print(packages_to_reinstall.format(len(just_reinstall_names)))\\n for package_name in sorted(list(just_reinstall_names)):\\n string_to_print = \\\" {} {} -> {}\\\".format(\\n upstream_system.repo_of_package(package_name).ljust(max_package_name_length),\\n Colors.LIGHT_MAGENTA(self.all_packages_dict[package_name].version).ljust(\\n max_left_side_version_length + 10\\n ),\\n Colors.LIGHT_MAGENTA(new_system.all_packages_dict[package_name].version)\\n )\\n\\n print(string_to_print)\\n\\n if to_uninstall_names:\\n print(packages_to_uninstall.format(len(to_uninstall_names)))\\n for package_name in sorted(list(to_uninstall_names)):\\n string_to_print = \\\" {} {} -> {}\\\".format(\\n upstream_system.repo_of_package(package_name).ljust(max_package_name_length),\\n Colors.GREEN(self.all_packages_dict[package_name].version).ljust(max_left_side_version_length + 10),\\n Colors.RED(\\\"/\\\")\\n )\\n\\n print(string_to_print)\\n\\n # print why those packages have to be uninstalled\\n self.hypothetical_append_packages_to_system(solution, packages_names_print_reason=to_uninstall_names)\\n\\n # check if no dependency breakage happens\\n if not solution_way:\\n self.hypothetical_append_packages_to_system(solution, check_if_possible=True)\\n\\n if solution_way:\\n aurman_status(\\\"The following will be done:\\\", new_line=True)\\n if deep_search:\\n aurman_note(\\\"You are using {}, hence {} is active.\\\".format(\\n Colors.BOLD(\\\"--deep_search\\\"), Colors.BOLD(\\\"--needed\\\")\\n ))\\n aurman_note(\\\"That means packages to be reinstalled will not actually be reinstalled.\\\")\\n self.hypothetical_append_packages_to_system(solution, print_way=True)\\n\\n if not noconfirm and not ask_user(user_question, True, True):\\n raise InvalidInput()\",\n \"def print_dependencies(_run):\\n print('Sources:')\\n for source, digest in _run.experiment_info['sources']:\\n print(' {:<43} {}'.format(source, digest))\\n\\n print('\\\\nDependencies:')\\n for pack, version in _run.experiment_info['dependencies']:\\n print(' {:<20} >= {}'.format(pack, version))\",\n \"def check_packages(options):\\n print '\\\\033[1;33m# Checking direct VIKI dependencies\\\\033[1;m'\\n installed_ok = dependencies.check_installed_packages()\\n print '\\\\n\\\\033[1;33m# Checking second level ROS dependencies, using rosdep\\\\033[1;m'\\n second_level_ok = dependencies.get_second_level_dependencies()\\n\\n if installed_ok and second_level_ok:\\n print '\\\\033[1;32mAll dependencies satisfied!\\\\033[1;m'\\n else:\\n print '\\\\033[1;31mTry running [viki install-dependencies] to install the dependencies\\\\033[1;m'\",\n \"def show_versions():\\n sys_info = _get_sys_info()\\n deps_info = _get_deps_info()\\n\\n print(\\\"\\\\nSystem:\\\")\\n for k, stat in sys_info.items():\\n print(\\\"{k:>10}: {stat}\\\".format(k=k, stat=stat))\\n\\n print(\\\"\\\\nPython dependencies:\\\")\\n for k, stat in deps_info.items():\\n print(\\\"{k:>13}: {stat}\\\".format(k=k, stat=stat))\",\n \"def print_deps(self):\\n\\t\\tprint self.deps, '\\\\n'\",\n \"def info_software(modules: list[str] = DEFAULT_MODULES):\\n\\n # Python Environment\\n env = getattr(sys, \\\"base_prefix\\\", None) or getattr(sys, \\\"real_prefix\\\", None) or sys.prefix\\n print(f\\\"\\\\nENV:\\\\t{env}\\\")\\n\\n python_version = sys.version\\n print(f\\\"\\\\nPYTHON:\\\\t{python_version}\\\")\\n\\n if modules is None:\\n modules = DEFAULT_MODULES\\n\\n for i in modules:\\n if i in installed_packages_dict:\\n print(f\\\"{i:<25}{installed_packages_dict.get(i):>10}\\\")\\n else:\\n print(f\\\"{i:<25}: {'--NO--':>10}\\\")\\n print()\",\n \"def show_completed_models(completed_models):\\r\\n print(\\\"\\\\nThe following models have been printed:\\\")\\r\\n for completed_model in completed_models:\\r\\n print(completed_model)\",\n \"def test_print_version_repositories_SKIP(self):\\n self._uri({\\n '%d.%d/maintained/%d.%d-%d/%s/Packages.gz' % (MAJOR, MINOR, MAJOR, MINOR, 0, 'all'): DATA,\\n '%d.%d/maintained/%d.%d-%d/%s/Packages.gz' % (MAJOR, MINOR, MAJOR, MINOR, 0, ARCH): DATA,\\n })\\n tmp = self.u.print_version_repositories()\\n self.assertEqual(set((\\n 'deb file:///mock/%d.%d/maintained/ %d.%d-%d/%s/' % (MAJOR, MINOR, MAJOR, MINOR, 0, 'all'),\\n 'deb file:///mock/%d.%d/maintained/ %d.%d-%d/%s/' % (MAJOR, MINOR, MAJOR, MINOR, 0, ARCH),\\n )), set(tmp.splitlines()))\",\n \"def show_keep(self, command=\\\"show-keep\\\"):\\n # execute pkgin\\n popen = Popen([self.pkgin_bin, \\\"-P\\\", command], stdout=PIPE, stderr=PIPE)\\n # retrieve output streams\\n (stdoutdata, stderrdata) = popen.communicate()\\n # if pkgin error\\n if(stderrdata):\\n # remove the line feed\\n error = stderrdata[0:-1]\\n raise PykginError(error)\\n # retrieve output\\n output = stdoutdata\\n # create a list which contain each packages\\n output_whole_list = output.split('\\\\n')\\n # remove last element (due to the last \\\\n)\\n output_whole_list.pop()\\n # create a new list in which package informations are separate\\n output_list = []\\n for pkg in output_whole_list:\\n current = pkg.split(' ', 1)\\n output_list.append(self.__extract_package_version(current[0]))\\n\\n return output_list\",\n \"def print_results(self):\\n for test_cases in self._tests:\\n for test_case in test_cases:\\n print('{} ...ok'.format(test_case.get_name()))\\n return 0\",\n \"def all(\\n command,\\n):\\n # If we get to this point all tests listed in 'pre' have passed\\n # unless we have run the task with the --warn flag\\n if not command.config.run.warn:\\n print(\\n \\\"\\\"\\\"\\nAll Checks Passed Successfully\\n==========================================\\n\\\"\\\"\\\"\\n )\",\n \"def print_summary(self):\\n #outcomes = self.get_outcomes()\\n #passes = 'Passes: %i' % sum(1 for outcome in outcomes if outcome == Result.PASS)\\n #untested = 'Untested: %i' % sum(1 for outcome in outcomes if outcome == Result.UNTESTED)\\n #errors = 'Errors: %i' % sum(1 for outcome in outcomes if outcome == Result.ERROR)\\n #fails = 'Fails: %i' % sum(1 for outcome in outcomes if outcome == Result.FAIL)\\n print('')\\n print ('Passes: %i' % self.get_pass_count())\\n print ('Fails: %i' % self.get_fail_count())\\n print ('Errors: %i' % self.get_error_count())\\n print ('Untested: %i' % self.get_untested_count())\\n print ('Skipped: %i' % self.get_skipped_count())\",\n \"def show_completed_design(completed_design):\\n print(\\\"\\\\nThe following models have been printed:\\\")\\n for completed_designs in completed_design:\\n print(completed_designs)\",\n \"def test_collect_playbooks_dependencies_skip_unavailable(self, module_repo):\\n expected_result = {\\n # playbooks:\\n (\\\"Slack\\\", False),\\n (\\\"Indeni\\\", True),\\n # integrations:\\n (\\\"FeedAlienVault\\\", False),\\n (\\\"ipinfo\\\", True),\\n (\\\"FeedAutofocus\\\", True),\\n # scripts:\\n (\\\"GetServerURL\\\", False),\\n (\\\"HelloWorld\\\", True),\\n }\\n test_input = [\\n {\\n \\\"Dummy Playbook\\\": {\\n \\\"name\\\": \\\"Dummy Playbook\\\",\\n \\\"file_path\\\": \\\"dummy_path\\\",\\n \\\"fromversion\\\": \\\"dummy_version\\\",\\n \\\"implementing_scripts\\\": [\\n \\\"GetServerURL\\\",\\n \\\"HelloWorldScript\\\",\\n ],\\n \\\"implementing_playbooks\\\": [\\n \\\"Failed Login Playbook - Slack v2\\\",\\n \\\"Indeni Demo\\\",\\n ],\\n \\\"command_to_integration\\\": {\\n \\\"alienvault-get-indicators\\\": \\\"\\\",\\n \\\"ip\\\": \\\"ipinfo\\\",\\n \\\"autofocus-get-indicators\\\": \\\"\\\",\\n },\\n \\\"tests\\\": [\\\"dummy_playbook\\\"],\\n \\\"pack\\\": \\\"dummy_pack\\\",\\n \\\"incident_fields\\\": [],\\n \\\"skippable_tasks\\\": [\\n \\\"Print\\\",\\n \\\"Failed Login Playbook - Slack v2\\\",\\n \\\"alienvault-get-indicators\\\",\\n \\\"GetServerURL\\\",\\n ],\\n }\\n },\\n ]\\n\\n found_result = PackDependencies._collect_playbooks_dependencies(\\n pack_playbooks=test_input,\\n id_set=module_repo.id_set.read_json_as_dict(),\\n )\\n\\n assert set(found_result) == set(expected_result)\",\n \"def report_not_up_to_date(self):\\n print \\\"Build is not up-to-date:\\\"\\n print self.banner('STDOUT ')\\n print self.stdout()\\n stderr = self.stderr()\\n if stderr:\\n print self.banner('STDERR ')\\n print stderr\",\n \"def print_detectable(pkg):\\n\\n color.cprint(\\\"\\\")\\n color.cprint(section_title(\\\"Externally Detectable: \\\"))\\n\\n # If the package has an 'executables' of 'libraries' field, it\\n # can detect an installation\\n if hasattr(pkg, \\\"executables\\\") or hasattr(pkg, \\\"libraries\\\"):\\n find_attributes = []\\n if hasattr(pkg, \\\"determine_version\\\"):\\n find_attributes.append(\\\"version\\\")\\n\\n if hasattr(pkg, \\\"determine_variants\\\"):\\n find_attributes.append(\\\"variants\\\")\\n\\n # If the package does not define 'determine_version' nor\\n # 'determine_variants', then it must use some custom detection\\n # mechanism. In this case, just inform the user it's detectable somehow.\\n color.cprint(\\n \\\" True{0}\\\".format(\\n \\\" (\\\" + \\\", \\\".join(find_attributes) + \\\")\\\" if find_attributes else \\\"\\\"\\n )\\n )\\n else:\\n color.cprint(\\\" False\\\")\",\n \"def show_completed_models(completed_models):\\n print(\\\"\\\\nThe following models have been printed:\\\")\\n for completed_model in completed_models:\\n print(completed_model)\",\n \"def show_completed_models(completed_models):\\n print(\\\"\\\\nThe following models have been printed:\\\")\\n for completed_model in completed_models:\\n print(completed_model)\",\n \"def show_completed_models(completed_models):\\n print(\\\"\\\\nThe following models have been printed:\\\")\\n for completed_model in completed_models:\\n print(completed_model)\",\n \"def show_completed_models(completed_models):\\n\\tprint(\\\"\\\\n The following models has been printed \\\")\\n\\tfor completed_model in completed_models:\\n\\t\\tprint(completed_model)\",\n \"def _show_summary(self):\\n print 'Summary:'\\n print ' Reports downloaded successfully: %d' % self.counts\\n print ' Reports not downloaded: %d\\\\n' % self.failed\",\n \"def print_warning_msgs():\\n for err in TypeWarning.warnings:\\n print err\",\n \"def show_completed_models(completed_models):\\n\\tprint(\\\"\\\\nThe following models have been printed:\\\")\\n\\tfor completed_model in completed_models:\\n\\t\\tprint(completed_model)\",\n \"def check_missing_dep():\\n global MISSING_PACKAGES, INSTALLED_PACKAGES, ENABLE_CUDA\\n if ENABLE_CUDA and IS_MACOS:\\n REQUIRED_PACKAGES.extend(MACOS_REQUIRED_PACKAGES)\\n MISSING_PACKAGES = []\\n for pkg in REQUIRED_PACKAGES:\\n key = pkg.split(\\\"==\\\")[0]\\n if key not in INSTALLED_PACKAGES:\\n MISSING_PACKAGES.append(pkg)\\n continue\\n else:\\n if len(pkg.split(\\\"==\\\")) > 1:\\n if pkg.split(\\\"==\\\")[1] != INSTALLED_PACKAGES.get(key):\\n MISSING_PACKAGES.append(pkg)\\n continue\",\n \"def blankOutputFiles():\\n print(\\\"Checking for blank output files\\\")\\n find_output = re.compile(r\\\"/\\\\* Output:(.*)\\\\*/\\\", re.DOTALL)\\n for java in config.example_dir.rglob(\\\"*.java\\\"):\\n with java.open() as codeFile:\\n output = find_output.search(codeFile.read())\\n if output:\\n # print(output.group(1))\\n if not output.group(1).strip():\\n print(java)\",\n \"def _show_missing_code_main(config: Config, session: Session) -> None:\\n tw = TerminalWriter()\\n session.perform_collect()\\n\\n fm = session._fixturemanager\\n\\n if config.option.features is None:\\n tw.line(\\\"The --feature parameter is required.\\\", red=True)\\n session.exitstatus = 100\\n return\\n\\n features, scenarios, steps = parse_feature_files(config.option.features)\\n\\n for item in session.items:\\n scenario = getattr(item.obj, \\\"__scenario__\\\", None)\\n if scenario:\\n if scenario in scenarios:\\n scenarios.remove(scenario)\\n for step in scenario.steps:\\n fixturedefs = _find_step_fixturedef(fm, item, step=step)\\n if fixturedefs:\\n try:\\n steps.remove(step)\\n except ValueError:\\n pass\\n for scenario in scenarios:\\n for step in scenario.steps:\\n if step.background is None:\\n steps.remove(step)\\n grouped_steps = group_steps(steps)\\n print_missing_code(scenarios, grouped_steps)\\n\\n if scenarios or steps:\\n session.exitstatus = 100\",\n \"def display_nornir_results(nr_result):\\n print(menu('Interface Update'))\\n for host in nr_result:\\n if not nr_result[host].failed:\\n if nr_result[host].changed:\\n print(Fore.YELLOW + f'{host}: True')\\n else:\\n print(Fore.GREEN + f'{host}: False')\\n else:\\n print(Fore.RED + f'{host}: FAILED')\",\n \"def printErrors(self):\\n if self.dots:\\n self.stream.writeln()\\n\\n # Skipped Test Report\\n if not self.args.no_skip_report:\\n for test, reason in self.skipped:\\n self.stream.writeln(\\n \\\"\\\\n{} {} - {}\\\".format(\\n self.colors.blue(\\\"Skipped\\\"),\\n self.colors.bold(test.dotted_name),\\n reason,\\n )\\n )\\n\\n # Captured output for non-failing tests\\n if not self.args.quiet_stdout:\\n failing_tests = {x[0] for x in self.all_errors}\\n for test in list(self.stdout_output) + list(self.stderr_errput):\\n if test not in failing_tests:\\n self.displayStdout(test)\\n self.displayStderr(test)\\n\\n # Actual tracebacks and captured output for failing tests\\n for test, color_func, outcome, err in self.all_errors:\\n # Header Line\\n self.stream.writeln(\\n f\\\"\\\\n{color_func(outcome)} in {self.colors.bold(test.dotted_name)}\\\"\\n )\\n\\n # Traceback\\n if not self.args.no_tracebacks:\\n relevant_frames = []\\n for i, frame in enumerate(err.traceback_lines):\\n # Python2 tracebacks containing unicode need some special handling\\n # This doesn't always make it readable, but at least it doesn't\\n # crash\\n if sys.version_info[0] == 2: # pragma: no cover\\n try:\\n \\\"\\\".join([frame]) # intentionally trigger exceptions\\n except UnicodeDecodeError:\\n frame = frame.decode(\\\"utf-8\\\")\\n debug(\\n \\\"\\\\n\\\"\\n f\\\"{'*' * 30}Frame {i}:{'*' * 30}\\\\n\\\" + self.colors.yellow(frame),\\n level=3,\\n )\\n # Ignore useless frames\\n if self.verbose < 4:\\n if frame.strip() == \\\"Traceback (most recent call last):\\\":\\n continue\\n # Done with this frame, capture it.\\n relevant_frames.append(frame)\\n self.stream.write(\\\"\\\".join(relevant_frames))\\n\\n # Captured output for failing tests\\n self.displayStdout(test)\\n self.displayStderr(test)\",\n \"def cli(env, keyword, package_type):\\n manager = ordering.OrderingManager(env.client)\\n table = formatting.Table(COLUMNS)\\n\\n _filter = {'type': {'keyName': {'operation': '!= BLUEMIX_SERVICE'}}}\\n if keyword:\\n _filter['name'] = {'operation': '*= %s' % keyword}\\n if package_type:\\n _filter['type'] = {'keyName': {'operation': package_type}}\\n\\n packages = manager.list_packages(filter=_filter)\\n\\n for package in packages:\\n table.add_row([\\n package['id'],\\n package['name'],\\n package['keyName'],\\n package['type']['keyName']\\n ])\\n env.fout(table)\",\n \"def print_skipped(self,result,cause=False):\\n skipped = result.get_skipped()\\n if skipped:\\n print ('=== SKIPPED '+('='*59))\\n for u in skipped:\\n print (u.id)\\n if cause:\\n print (' ',u.get_cause())\",\n \"def report_unused_cycle_suppressions(self, reporter):\\n for module in self.get_modules():\\n for dep in module.get_dependencies():\\n if not dep.suppression_used:\\n reporter.cyclic_issue(\\\"unused cycle suppression: {0} -> {1}\\\".format(module.get_name()[7:], dep.get_other_module().get_name()[7:]))\",\n \"def print_all_separation_algorithms():\\n from ..separation import all_separation_algorithms\\n print('\\\\n'.join([a.__name__ for a in all_separation_algorithms]))\",\n \"def show_linting_results(self, linting_results):\\n attribute_results = []\\n lint_results_by_outcome = {}\\n for result in linting_results:\\n if result.result == charmcraft.linters.IGNORED:\\n continue\\n if result.check_type == charmcraft.linters.CheckType.attribute:\\n attribute_results.append(result)\\n else:\\n lint_results_by_outcome.setdefault(result.result, []).append(result)\\n\\n # show attribute results\\n for result in attribute_results:\\n emit.verbose(\\n f\\\"Check result: {result.name} [{result.check_type}] {result.result} \\\"\\n f\\\"({result.text}; see more at {result.url}).\\\",\\n )\\n\\n # show warnings (if any), then errors (if any)\\n template = \\\"- {0.name}: {0.text} ({0.url})\\\"\\n if charmcraft.linters.WARNINGS in lint_results_by_outcome:\\n emit.progress(\\\"Lint Warnings:\\\", permanent=True)\\n for result in lint_results_by_outcome[charmcraft.linters.WARNINGS]:\\n emit.progress(template.format(result), permanent=True)\\n if charmcraft.linters.ERRORS in lint_results_by_outcome:\\n emit.progress(\\\"Lint Errors:\\\", permanent=True)\\n for result in lint_results_by_outcome[charmcraft.linters.ERRORS]:\\n emit.progress(template.format(result), permanent=True)\\n if self.force_packing:\\n emit.progress(\\\"Packing anyway as requested.\\\", permanent=True)\\n else:\\n raise CraftError(\\n \\\"Aborting due to lint errors (use --force to override).\\\", retcode=2\\n )\",\n \"def test_component_update_get_packages(self):\\n MockPopen.mock_stdout = 'Inst a [old] (new from)\\\\nInst b (new from)\\\\nRemv c (old PKG)\\\\nRemv d PKG'\\n installed, upgraded, removed = self.u.component_update_get_packages()\\n self.assertEqual([('b', 'new')], installed)\\n self.assertEqual([('a', 'old', 'new')], upgraded)\\n self.assertEqual([('c', 'old'), ('d', 'unknown')], removed)\",\n \"def print_drivers():\\n driver_info_dict = get_all_driver_infos()\\n keys = sorted(driver_info_dict)\\n print \\\"%-25s%-15s%-9s%-25s\\\" % (\\n \\\"Module name\\\", \\\"Driver name\\\", \\\"Version\\\", \\\"Status\\\")\\n for d in keys:\\n print \\\" %(module_name)-25s%(driver_name)-15s%(version)-9s%(status)-25s\\\" % driver_info_dict[d]\",\n \"def run(self):\\n logging.debug('List Installed Programs')\\n if self.short:\\n print(' '.join([ent for ent in pakit.conf.IDB]))\\n return\\n\\n nchars = 12\\n fmt = str(nchars).join(['{prog:', '} {repo:',\\n '} {hash:', '} {date}'])\\n installed = ['Program Repo Hash Date']\\n for prog in pakit.conf.IDB:\\n entry = pakit.conf.IDB[prog]\\n installed.append(fmt.format(prog=prog[0:nchars],\\n repo=entry['repo'][0:nchars],\\n date=entry['date'],\\n hash=entry['hash'][0:nchars]))\\n\\n msg = 'Installed Programs:'\\n msg += PREFIX + PREFIX.join(installed)\\n print(msg)\\n return msg\",\n \"def recheck_total_packages(conts_dict, si_result):\\n print('######## HOW ABOUT TOTAL PACKAGES ########')\\n need_recheck = False\\n total = ''\\n if len(conts_dict) > 0:\\n if 'packages' in conts_dict[0]:\\n total_pkgs = si_result.get('total_packages', True)\\n desctip = si_result.get('description_of_goods', False)\\n if total_pkgs == desctip:\\n need_recheck = True\\n\\n print('need_recheck:', need_recheck)\\n print(\\\"=========================conts_dict: \\\",conts_dict)\\n if need_recheck:\\n sum_packages = sum([\\n int(re.sub(r'[^\\\\d]+', '', detail.get('packages', '0')))\\n for detail in conts_dict\\n if floatable(detail.get('packages', '0'))\\n ])\\n\\n print('sum_packages:', sum_packages)\\n unit = re.sub(r'[^a-zA-Z]+', '', conts_dict[0].get('packages', ''))\\n\\n total = str(sum_packages) + ' ' + unit\\n\\n return total, need_recheck\",\n \"def display_available_items(self):\\n count = 0\\n print(\\\"Available Items:\\\")\\n for item in self.item_list.values():\\n if item.check_availability():\\n count += 1\\n print(item)\\n if count == 0:\\n print(\\\"No items are available\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75528216","0.734317","0.70231634","0.6996778","0.6639634","0.65396285","0.63859266","0.63610005","0.6253691","0.6054543","0.60348654","0.5987873","0.59685683","0.59673953","0.59105027","0.57375103","0.5688907","0.56304795","0.5588385","0.55742896","0.55742896","0.54993343","0.5492298","0.5432511","0.54299366","0.54283357","0.5423913","0.5423913","0.5418732","0.5395811","0.5385223","0.534002","0.5275689","0.5271236","0.52641195","0.5263983","0.52613634","0.5246322","0.5228907","0.52265984","0.5219258","0.5164178","0.5158143","0.51519054","0.514587","0.51426226","0.5129829","0.512497","0.5122705","0.51128864","0.5105606","0.5103488","0.5098761","0.5068141","0.5063378","0.5057608","0.5054927","0.50519717","0.5050353","0.50430185","0.50424606","0.50282353","0.5027244","0.5020531","0.50159013","0.50126153","0.5007904","0.50073844","0.499713","0.49795508","0.49759275","0.49650285","0.49599576","0.4956166","0.49533787","0.49495712","0.4943127","0.49403363","0.49255747","0.49255747","0.49255747","0.4925442","0.4921955","0.49202448","0.49197698","0.4919145","0.49188414","0.4917561","0.49069518","0.4901911","0.49002302","0.48977706","0.48972356","0.48874432","0.4885022","0.48822773","0.48804495","0.48750132","0.4874051","0.48728278"],"string":"[\n \"0.75528216\",\n \"0.734317\",\n \"0.70231634\",\n \"0.6996778\",\n \"0.6639634\",\n \"0.65396285\",\n \"0.63859266\",\n \"0.63610005\",\n \"0.6253691\",\n \"0.6054543\",\n \"0.60348654\",\n \"0.5987873\",\n \"0.59685683\",\n \"0.59673953\",\n \"0.59105027\",\n \"0.57375103\",\n \"0.5688907\",\n \"0.56304795\",\n \"0.5588385\",\n \"0.55742896\",\n \"0.55742896\",\n \"0.54993343\",\n \"0.5492298\",\n \"0.5432511\",\n \"0.54299366\",\n \"0.54283357\",\n \"0.5423913\",\n \"0.5423913\",\n \"0.5418732\",\n \"0.5395811\",\n \"0.5385223\",\n \"0.534002\",\n \"0.5275689\",\n \"0.5271236\",\n \"0.52641195\",\n \"0.5263983\",\n \"0.52613634\",\n \"0.5246322\",\n \"0.5228907\",\n \"0.52265984\",\n \"0.5219258\",\n \"0.5164178\",\n \"0.5158143\",\n \"0.51519054\",\n \"0.514587\",\n \"0.51426226\",\n \"0.5129829\",\n \"0.512497\",\n \"0.5122705\",\n \"0.51128864\",\n \"0.5105606\",\n \"0.5103488\",\n \"0.5098761\",\n \"0.5068141\",\n \"0.5063378\",\n \"0.5057608\",\n \"0.5054927\",\n \"0.50519717\",\n \"0.5050353\",\n \"0.50430185\",\n \"0.50424606\",\n \"0.50282353\",\n \"0.5027244\",\n \"0.5020531\",\n \"0.50159013\",\n \"0.50126153\",\n \"0.5007904\",\n \"0.50073844\",\n \"0.499713\",\n \"0.49795508\",\n \"0.49759275\",\n \"0.49650285\",\n \"0.49599576\",\n \"0.4956166\",\n \"0.49533787\",\n \"0.49495712\",\n \"0.4943127\",\n \"0.49403363\",\n \"0.49255747\",\n \"0.49255747\",\n \"0.49255747\",\n \"0.4925442\",\n \"0.4921955\",\n \"0.49202448\",\n \"0.49197698\",\n \"0.4919145\",\n \"0.49188414\",\n \"0.4917561\",\n \"0.49069518\",\n \"0.4901911\",\n \"0.49002302\",\n \"0.48977706\",\n \"0.48972356\",\n \"0.48874432\",\n \"0.4885022\",\n \"0.48822773\",\n \"0.48804495\",\n \"0.48750132\",\n \"0.4874051\",\n \"0.48728278\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5926434"},"document_rank":{"kind":"string","value":"14"}}},{"rowIdx":21992,"cells":{"query":{"kind":"string","value":"Execute a plugin command on any package that needs it."},"document":{"kind":"string","value":"def __run(arguments, command_arguments): # pylint: disable=too-many-locals\n ignored_packages, other_packages, invalid_packages, skips = __gather_package_data(\n arguments\n )\n\n command = registry.get_command(arguments.command)\n\n packages, un_ran, invalids = worker.run(\n functools.partial(command.run, arguments=command_arguments),\n other_packages,\n maximum_repositories=arguments.maximum_repositories,\n maximum_rez_packages=arguments.maximum_rez_packages,\n keep_temporary_files=arguments.keep_temporary_files,\n temporary_directory=arguments.temporary_directory,\n )\n\n invalids.extend(invalid_packages)\n\n # TODO : Change `Skip` into a class and make it the same interface as an exception\n # so that I can easily print both types at the same time, here\n #\n bads = invalids + skips\n\n if bads:\n print(\"Some packages are invalid or had to be skipped.\")\n print(\"\\n\")\n print(sorted(error.get_package().name for error in bads))\n\n if un_ran:\n print(\"These packages could not be run on:\")\n\n for package, error in sorted(un_ran, key=_get_package_name):\n print(\n \"{package.name}: {error}\".format(\n package=package, error=str(error) or \"No found error message\"\n )\n )\n\n sys.exit(cli_constant.UN_RAN_PACKAGES_FOUND)\n\n if packages:\n print(\"These packages were modified successfully:\")\n\n for package in sorted(packages, key=operator.attrgetter(\"name\")):\n print(package.name)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def init_plugins(group):\n package = sys.modules[__name__]\n\n for (importer, module_name, ispkg) in pkgutil.iter_modules(package.__path__):\n if not ispkg:\n try:\n module = importlib.import_module(package.__name__ + '.' + module_name)\n\n if 'run' not in module.__dict__:\n print_fail('Plugin command \"%s\" doesn\\'t provide a \"run\" method. Aborting.' % (module_name))\n # sys.exit(-1)\n else:\n group.add_command(module.run)\n except Exception, e:\n print_fail('[%s] %s' % (module_name, str(e) + str(type(e))))","def main():\n PLUGIN_ENTRY().run(\"\")","def execute(self):\n rc = self.rc\n try:\n for plugin in self.plugins:\n plugin.execute(rc)\n except Exception as e:\n self.exit(e)","def run_plugin(argv):\n\treturn subprocess.Popen(argv, stdout=subprocess.PIPE)","def do_plugin(self, args):\n #TODO GET A LIST OF PARAMETERS FROM THE PLUGIN\n lex_parser = shlex.shlex(args.strip(), posix=True)\n lex_parser.whitespace += \"=\"\n lex_parser.escapedquotes = \"\"\n lex_parser.wordchars += \"~-./*?=\"\n tokens = [token for token in lex_parser]\n\n _MOD_LOGGER.debug(\"Plugin tokens: %s\", tokens)\n\n if len(tokens) < 1:\n print(\"Error, invalid command.\")\n return\n\n if tokens[0] == \"list\":\n self.print_plugin_list()\n elif tokens[0] == \"set\":\n self.set_plugin(tokens[1:])\n else:\n print(\"Error, invalid command.\")","def load_plugins(self):\n self.__doing('load_plugins')\n self.__do_if_not_done('bootstrap')\n if self.env.mode in ('dummy', 'unit_test'):\n return\n for package in self.packages:\n self.add_package(package)","def main():\n\n cwd = os.path.realpath(__file__)\n plugin_dir = os.path.join(os.path.dirname(cwd), 'plugins')\n plugins = {\n name.replace('greet_', ''): importlib.import_module('plugins.' + name)\n for _, name, _ in pkgutil.iter_modules(path=[plugin_dir])\n if name.startswith('greet_')\n }\n\n args = get_args(plugins)\n\n print(plugins[args.language].greet(args.name))","def discover_all_plugins(self):\n for v in pkg_resources.iter_entry_points('dgit.plugins'):\n m = v.load()\n m.setup(self)","def run(self, plugin: T_Plugin, *args: Any, **kwargs: Any) -> None:\n pass","def run(self, plugin: T_Plugin, *args: Any, **kwargs: Any) -> None:\n return plugin.run(*args, **kwargs)","def python_plugin(path, name):\n require.directory(_uwsgi.UWSGI_PLUGINS_LOCATION, use_sudo=True)\n if not _uwsgi.plugin_exists(name):\n with cd(_uwsgi.UWSGI_INSTALLATION_DIR):\n cmd = \"PYTHON={path} ./uwsgi --build-plugin \\\"plugins/python {name}\\\"\"\n sudo(cmd.format(**locals()))\n files.move(\n \"{0}_plugin.so\".format(name), _uwsgi.UWSGI_PLUGINS_LOCATION,\n use_sudo=True\n )","def package_plugin(specs_path: str, package_name: str, plugin_dir: str, dst_path: Path):\n hm_generator = HookManGenerator(hook_spec_file_path=specs_path)\n hm_generator.generate_plugin_package(\n package_name=package_name, plugin_dir=plugin_dir, dst_path=Path(dst_path)\n )\n return 0","def test_plugin_command(node_factory):\n n = node_factory.get_node()\n\n # Make sure that the 'hello' command from the helloworld.py plugin\n # is not available.\n cmd = [hlp for hlp in n.rpc.help()[\"help\"] if \"hello\" in hlp[\"command\"]]\n assert(len(cmd) == 0)\n\n # Add the 'contrib/plugins' test dir\n n.rpc.plugin_startdir(directory=os.path.join(os.getcwd(), \"contrib/plugins\"))\n # Make sure that the 'hello' command from the helloworld.py plugin\n # is now available.\n cmd = [hlp for hlp in n.rpc.help()[\"help\"] if \"hello\" in hlp[\"command\"]]\n assert(len(cmd) == 1)\n\n # Make sure 'rescan' and 'list' subcommands dont crash\n n.rpc.plugin_rescan()\n n.rpc.plugin_list()\n\n # Make sure the plugin behaves normally after stop and restart\n assert(\"Successfully stopped helloworld.py.\" == n.rpc.plugin_stop(plugin=\"helloworld.py\")[''])\n n.daemon.wait_for_log(r\"Killing plugin: helloworld.py\")\n n.rpc.plugin_start(plugin=os.path.join(os.getcwd(), \"contrib/plugins/helloworld.py\"))\n n.daemon.wait_for_log(r\"Plugin helloworld.py initialized\")\n assert(\"Hello world\" == n.rpc.call(method=\"hello\"))\n\n # Now stop the helloworld plugin\n assert(\"Successfully stopped helloworld.py.\" == n.rpc.plugin_stop(plugin=\"helloworld.py\")[''])\n n.daemon.wait_for_log(r\"Killing plugin: helloworld.py\")\n # Make sure that the 'hello' command from the helloworld.py plugin\n # is not available anymore.\n cmd = [hlp for hlp in n.rpc.help()[\"help\"] if \"hello\" in hlp[\"command\"]]\n assert(len(cmd) == 0)\n\n # Test that we cannot start a plugin with 'dynamic' set to False in\n # getmanifest\n with pytest.raises(RpcError, match=r\"Not a dynamic plugin\"):\n n.rpc.plugin_start(plugin=os.path.join(os.getcwd(), \"tests/plugins/static.py\"))\n\n # Test that we cannot stop a started plugin with 'dynamic' flag set to\n # False\n n2 = node_factory.get_node(options={\n \"plugin\": os.path.join(os.getcwd(), \"tests/plugins/static.py\")\n })\n with pytest.raises(RpcError, match=r\"static.py cannot be managed when lightningd is up\"):\n n2.rpc.plugin_stop(plugin=\"static.py\")\n\n # Test that we don't crash when starting a broken plugin\n with pytest.raises(RpcError, match=r\"Timed out while waiting for plugin response\"):\n n2.rpc.plugin_start(plugin=os.path.join(os.getcwd(), \"tests/plugins/broken.py\"))","def setup(self):\n rc = self.rc\n try:\n for plugin in self.plugins:\n plugin.setup(rc)\n except Exception as e:\n self.exit(e)","def _package_plugins(ctx):\n print(\"\\n\\n-- Creating Zip Files \\n\")\n\n project_dir = Path(__file__).parent\n plugins_projects = [\n x for x in (project_dir / \"build/build_directory_for_tests/\").iterdir() if x.is_dir()\n ]\n artifacts_dir = project_dir / \"build/artifacts\"\n\n plugins_zip = project_dir / \"build/plugin_zip\"\n if plugins_zip.exists():\n shutil.rmtree(plugins_zip)\n\n plugins_zip.mkdir()\n\n for project in plugins_projects:\n plugins_dirs = [\n x for x in (project / \"plugin\").iterdir() if x.is_dir() and (x / \"assets\").exists()\n ]\n hm_generator = HookManGenerator(\n hook_spec_file_path=project_dir / f\"tests/plugins/{project.name}/hook_specs.py\"\n )\n\n for plugin in plugins_dirs:\n (plugin / \"artifacts\").mkdir()\n if sys.platform == \"win32\":\n shutil.copy2(src=artifacts_dir / f\"{plugin.name}.dll\", dst=plugin / \"artifacts\")\n else:\n shutil.copy2(src=artifacts_dir / f\"lib{plugin.name}.so\", dst=plugin / \"artifacts\")\n\n hm_generator.generate_plugin_package(\n package_name=plugin.name, plugin_dir=plugin, dst_path=plugins_zip\n )","def _run_plugin(plugin_class, plugin_config: typing.Dict, exit_event: multiprocessing.Event):\n plugin_instance = plugin_class(plugin_config, exit_event)\n plugin_instance.run_plugin()","def invoke(\n project: Project,\n plugin_type: str,\n dump: str,\n list_commands: bool,\n plugin_name: str,\n plugin_args: Tuple[str, ...],\n):\n try:\n plugin_name, command_name = plugin_name.split(\":\")\n except ValueError:\n command_name = None\n\n plugin_type = PluginType.from_cli_argument(plugin_type) if plugin_type else None\n\n _, Session = project_engine(project)\n session = Session()\n plugins_service = ProjectPluginsService(project)\n plugin = plugins_service.find_plugin(\n plugin_name, plugin_type=plugin_type, invokable=True\n )\n\n if list_commands:\n do_list_commands(plugin)\n return\n\n invoker = invoker_factory(project, plugin, plugins_service=plugins_service)\n exit_code = run_async(\n _invoke(invoker, project, plugin_name, plugin_args, session, dump, command_name)\n )\n sys.exit(exit_code)","def install_celery_plugin(plugin):\n\n plugin_url = plugin[\"url\"]\n\n plugin_name = extract_plugin_name(plugin_url)\n\n module_paths = extract_module_paths(plugin_name)\n\n # this will install the plugin and\n # its dependencies into the python installation\n command = \"{0} install --process-dependency-links {1}\"\\\n .format(get_pip(), plugin_url)\n run_command(command)\n logger.debug(\"installed plugin {0} and \"\n \"dependencies into python installation {1}\"\n .format(plugin_name, get_python()))\n\n write_to_includes(\",\".join(module_paths))","def run(args, plugins):\n\n # This has to happen before we parse the args, otherwise we might\n # get subcommand not found.\n for name, instance in plugins.items():\n if isinstance(instance, SubCommandPlugin):\n logging.debug('Adding SubCommandPlugin %s' % name)\n try:\n instance.register(subparsers.add_parser, configuration.add_defaults)\n logging.debug('Done adding SubCommandPlugin %s' % name)\n name = instance.name()\n if name in actions:\n raise Exception('SubCommandPlugin %s clashes with an existing subcommand.' % name)\n actions[name] = instance.run\n except Exception as e:\n print('Failed to load SubCommandPlugin %s: %s' % (name, e), file=sys.stderr)\n\n args = vars(parser.parse_args(args))\n\n util.silent = args.pop('silent')\n verbose = args.pop('verbose') and not util.silent\n\n log_format = '%(asctime)s [%(levelname)s] [%(name)s] %(message)s'\n if verbose:\n logging.getLogger('').handlers = []\n logging.basicConfig(format=log_format, level=logging.DEBUG)\n else:\n logging.disable(logging.FATAL)\n\n logging.debug('args: %s', args)\n\n action = args.pop('action')\n config_path = args.pop('config')\n cluster = args.pop('cluster')\n url = args.pop('url')\n pool_name = args.get('pool-name')\n\n if action is None:\n parser.print_help()\n else:\n _, config_map = configuration.load_config_with_defaults(config_path)\n try:\n metrics.initialize(config_map)\n # measure the number of times users specify each cluster, including when none is specified\n metrics.inc('command.%s.runs' % action, additional_tags={'cluster': (cluster or 'default')})\n http.configure(config_map, plugins)\n cook.plugins.configure(plugins)\n args = {k: v for k, v in args.items() if v is not None}\n defaults = config_map.get('defaults')\n action_defaults = (defaults.get(action) if defaults else None) or {}\n # load_target_clusters needs to be aware if there are any action-specific cluster defaults\n # We want to treat cluster, pool and url as a tuple here, so if any are specified on the cli,\n # we will override the defaults.\n # Additionally, we must `pop` to remove the disallowed 'cluster' key, regardless of\n # whether we use the action_defaults or the cli flags\n if action_defaults:\n action_default_cluster = action_defaults.pop(\"cluster\", None)\n action_default_url = action_defaults.pop(\"url\", None)\n if cluster or pool_name or url:\n action_defaults.pop(\"pool-name\", None)\n else:\n cluster = action_default_cluster\n url = action_default_url\n clusters = load_target_clusters(config_map, url=url, cluster=cluster)\n logging.debug('going to execute % action' % action)\n result = actions[action](clusters, deep_merge(action_defaults, args), config_path)\n logging.debug('result: %s' % result)\n return result\n finally:\n metrics.close()\n\n return None","def add_package(self, package):\n package_name = package.__name__\n package_file = package.__file__\n package_dir = path.dirname(path.abspath(package_file))\n\n parent = sys.modules[package_name.rpartition('.')[0]]\n parent_dir = path.dirname(path.abspath(parent.__file__))\n if parent_dir == package_dir:\n raise errors.PluginsPackageError(\n name=package_name, file=package_file\n )\n\n logger.debug(\"importing all plugin modules in %s...\", package_name)\n modules = getattr(package, 'modules', find_modules_in_dir(package_dir))\n modules = ['.'.join((package_name, mname)) for mname in modules]\n\n for name in modules:\n logger.debug(\"importing plugin module %s\", name)\n try:\n module = importlib.import_module(name)\n except errors.SkipPluginModule as e:\n logger.debug(\"skipping plugin module %s: %s\", name, e.reason)\n continue\n except Exception as e:\n if self.env.startup_traceback:\n logger.exception(\"could not load plugin module %s\", name)\n raise\n\n try:\n self.add_module(module)\n except errors.PluginModuleError as e:\n logger.debug(\"%s\", e)","def __xcall__(self, cmd):\n\n return call_pkgconfig(cmd + [self.name], self.paths)","def cli(ctx: click.Context) -> None:\n pkg = read_package_from_file(PACKAGE_PATH)\n ctx.obj = pkg","def main(ctx: typer.Context):\n LOG.debug(F\"COVIDAP: executing command: {ctx.invoked_subcommand}\")","def execute_setuptools(self, *cmd, **options):\n version = options.get('version')\n if version not in self._setuptools:\n self._lock.acquire()\n try:\n if version not in self._setuptools:\n self._setuptools[version] = find_setuptools(\n self, version=version)\n finally:\n self._lock.release()\n\n if self._setuptools[version] is not None:\n options.setdefault('environ', {})\n options['environ']['PYTHONPATH'] = self._setuptools[version]\n options['python_options'] = ['-S']\n return self.execute_module(setuptoolize, *cmd, **options)","def main(command: Optional[str] = None) -> int:\n package_registrar.import_and_register_cli_extension_packages()\n\n if VERSION_FLAG in sys.argv or (command and VERSION_FLAG in command):\n logger.info(f\"Gazoo Device Manager {gazoo_device.version}\")\n package_versions = extensions.get_registered_package_info()\n logger.info(f\"Registered extension packages: {package_versions}\")\n return 0\n\n return execute_command(command)","def plugins():\n pass","def load_commands():\n register_plugin(configure_client_details)\n register_plugin(search_venues)","def load(cls, name):\n try:\n return importlib.import_module(cls._plugins[name])\n except Exception as err:\n print(\"** could not load command [%s]:\\n%s\" % (name, err))","def main():\n if len(sys.argv) < 2:\n print(\"PM endpoint needed as first argument.\")\n exit(1)\n ENDPOINT = sys.argv[1]\n uuid_list = pmc.plugin_list(ENDPOINT)\n print(uuid_list)\n for uuid in uuid_list:\n info = pmc.plugin_info(uuid, ENDPOINT)\n print(info)\n if info.get(\"name\") == \"son-plugin.TestPlugin\":\n # found an old test plugin record, remove it!\n print(\"REMOVE: %r\" % uuid)\n pmc.plugin_remove(uuid, ENDPOINT)","def main(text):\n _register_plugins()\n\n arguments, command_arguments = parse_arguments(text)\n\n if arguments.verbose:\n _LOGGER.setLevel(logging.DEBUG)\n\n arguments.execute(arguments, command_arguments)","def plugin_import(plugin):\n\n return importlib.import_module(plugin, package=\"directord\")","def auto_import_commands():\n import re,os\n import topo\n import __main__\n\n # CEBALERT: this kind of thing (topo.__file__) won't work with\n # py2exe and similar tools\n topo_path = os.path.join(os.path.split(topo.__file__)[0],\"command\")\n for f in os.listdir(topo_path):\n if re.match('^[^_.].*\\.py$',f):\n modulename = re.sub('\\.py$','',f)\n exec \"from topo.command.\"+modulename+\" import *\" in __main__.__dict__\n exec \"from topo.command import *\" in __main__.__dict__","def test_setup_package(self):\n pluggable_package.setup(self._test_package)\n self._test_setup(self._test_package)","def cli(ctx):\n if not ctx.invoked_subcommand:\n auto()","def test_override_plugin(self):\n plugin_name = 'Stdout'\n source = os.path.join(self.current_dir, 'classes', plugin_name)\n target = os.path.join(expanduser('~'), '.drupdates', 'plugins', plugin_name)\n shutil.copytree(source, target)\n plugins = Plugin.get_plugins()\n assert plugins[plugin_name]['info'][1] == os.path.join(target, '__init__.py')","def run_plugin(self, plugin_name: str):\n if plugin_name not in self.name_to_plugin_class:\n logger.error(\"Plugin %s DNE\", plugin_name)\n return\n\n if not self.name_to_enabled[plugin_name]:\n logger.error(\"Can not run disabled plugin\")\n\n def _run_plugin(plugin_class, plugin_config: typing.Dict, exit_event: multiprocessing.Event):\n \"\"\"Inner function that acts as target to multiprocess constructor\"\"\"\n plugin_instance = plugin_class(plugin_config, exit_event)\n plugin_instance.run_plugin()\n\n plugin_class = self.name_to_plugin_class[plugin_name]\n exit_event = multiprocessing.Event()\n process = multiprocessing.Process(target=_run_plugin, args=(plugin_class, self.config, exit_event))\n process.start()\n self.name_to_process[plugin_name] = process\n self.name_to_exit_event[plugin_name] = exit_event","def test_plugin_with_no_plugin_class(conf):\n # For fun, we pass in a system library\n installed_apps_before = conf.config[\"INSTALLED_APPS\"][:]\n cli.plugin(\"os.path\")\n assert installed_apps_before == conf.config[\"INSTALLED_APPS\"]","def load_commands(name, settings, action='deploy'):\n def install_packages():\n # only working for apt\n with hide('stdout'):\n # Need a new line after sources.list, which sometimes doesn't end\n # with one, easiest option: awk.\n apt_txt = run('find /etc/apt/sources.list{,.d} -type f '\n '-exec awk \\'FNR==1{print \"\"}1\\' {} \\;')\n\n force_update = False\n for package in packages:\n if package.needs_additional_repo(apt_txt):\n package.install_additional_repo()\n force_update = True\n\n package_manager.run_update(force_update)\n\n for package in packages:\n package.install()\n\n module = __import__('depl.deploy.' + name, globals(), locals(), [name], -1)\n commands = getattr(module, action)(settings)\n packages = set([p for p in commands if isinstance(p, Package)])\n commands = tuple([p for p in commands if not isinstance(p, Package)])\n\n return (install_packages,) + commands","def prepare_plugin(self, plugin_path):\n # This method does not exist in MOS 7.0\n if not hasattr(self.env.admin_actions, 'upload_plugin'):\n mos7_upload_plugin(plugin=plugin_path, source=self.env.d_env)\n mos7_install_plugin(\n plugin_file_name=os.path.basename(plugin_path),\n source=self.env.d_env)\n else:\n self.env.admin_actions.upload_plugin(plugin=plugin_path)\n self.env.admin_actions.install_plugin(\n plugin_file_name=os.path.basename(plugin_path))","def run_plugin(self, plugin_name, *args, nb_path=None, **kwargs):\n nb_path = self._resolve_nb_path(nb_path)\n if plugin_name in self._plugin_collections:\n pc = self._plugin_collections[plugin_name]\n else:\n pc = PluginCollection([plugin_name], nb_path, {})\n self._plugin_collections[plugin_name] = pc\n pc.run(\"from_notebook\", *args, **kwargs)","def loadPlugin(filename):\n\n name = op.splitext(op.basename(filename))[0]\n modname = 'fsleyes_plugin_{}'.format(name)\n distname = 'fsleyes-plugin-{}'.format(name)\n\n if distname in listPlugins():\n log.debug('Plugin %s is already in environment - skipping', distname)\n return\n\n log.debug('Loading plugin %s [dist name %s]', filename, distname)\n\n dist = pkg_resources.Distribution(\n project_name=distname,\n location=op.dirname(filename),\n version='0.0.0')\n\n entryPoints = _findEntryPoints(filename, modname)\n\n # Here I'm relying on the fact that\n # Distribution.get_entry_map returns\n # the actual dict that it uses to\n # store entry points.\n entryMap = dist.get_entry_map()\n\n for group, entries in entryPoints.items():\n entryMap[group] = {}\n\n for name, item in entries.items():\n ep = '{} = {}:{}'.format(name, modname, name)\n ep = pkg_resources.EntryPoint.parse(ep, dist=dist)\n entryMap[group][name] = ep\n\n pkg_resources.working_set.add(dist)","def _provision_package(self):","def PluginInstall(self, pluginName, pluginPath):\n pass","def test(self, plugin):\n plug = plugin_source.load_plugin(plugin)\n plug.test()","def test_specific_plugin_installed(self):\n self._add_plugin(self.jigconfig, 'plugin01')\n set_jigconfig(self.gitrepodir, config=self.jigconfig)\n\n # Create staged\n self.commit(self.gitrepodir, 'a.txt', 'a')\n self.stage(self.gitrepodir, 'b.txt', 'b')\n\n with nested(\n patch('jig.runner.sys'),\n self.assertRaises(SystemExit)\n ) as (r_sys, ec):\n # Raise the error to halt execution like the real sys.exit would\n r_sys.exit.side_effect = SystemExit\n\n self.run_command('--plugin plugin01 {0}'.format(self.gitrepodir))\n\n self.assertResults(u\"\"\"\n ▾ plugin01\n\n ⚠ line 1: b.txt\n b is +\n\n {0} Jig ran 1 plugin\n Info 0 Warn 1 Stop 0\n \"\"\".format(ATTENTION), self.output)","def add_commands(subparsers, path):\n log.debug('importing %s', path)\n try:\n del sys.modules[path]\n except KeyError:\n pass\n try:\n package = importlib.import_module(path)\n except Exception as e:\n log.warning('failed to import commands package %s',\n path, exc_info=True)\n return\n log.debug('commands package: %s', path)\n for (finder, name, ispkg) in pkgutil.iter_modules(package.__path__):\n if ispkg:\n continue\n try:\n command = importlib.import_module('.' + name, path)\n except Exception as e:\n log.warning('failed to import %s command: %s',\n path, name, exc_info=True)\n continue\n if not getattr(command, 'run', None):\n log.warning('skipping command module without run function: %s',\n name)\n continue\n log.debug('command: %s'%(name))\n name = command.__name__.split('.')[-1]\n parser_help = getattr(command, 'parser_help', None)\n if parser_help is None:\n log.warning('command %s missing help text'%(command.__name__))\n parser = subparsers.add_parser(name, help=parser_help)\n command.add_arguments(parser)\n parser.set_defaults(run=command.run)","def package():\n pass","def load_plugin():\n return HostTestPluginCopyMethod_Shell()","def _resolve_commands(parser):\n from .plugin import list as list_plugins\n\n # create a subparser\n subparsers = parser.add_subparsers(dest='cmd')\n\n default_command = None\n\n for command in list_plugins('command'):\n _log.info('add command ' + command.id)\n if hasattr(command, 'isDefault') and command.isDefault:\n default_command = command.id\n\n # create a argument parser for the command\n cmdparser = subparsers.add_parser(command.id)\n _log.info('loading and initializing the command: ' + command.id)\n\n # use the phovea extension point loading mechanism.\n # pass the parser as argument to the factory method so that the extension point (i.e., command)\n # can add further arguments to the parser (e.g., the address or port of the server).\n # the factory must return a launcher function, which gets the previously defined parser arguments as parameter.\n instance = command.load().factory(cmdparser)\n\n # register the instance as argument `launcher` and the command as `launcherid` to the command parser\n _log.info('add command instance to parser')\n cmdparser.set_defaults(launcher=instance, launcherid=command.id)\n\n return default_command","def handle_loadall(bot, ievent):\n plugs.loadall(plugin_packages, force=True)\n ievent.done()","def core_plugin(self):\n pass","def cli_load_plugin(self, args) -> str:\n plugin_name = args.plugin_name\n current_dir = os.path.dirname(os.path.realpath(__file__))\n if not os.path.isfile(\"{}/{}.py\".format(current_dir, plugin_name)):\n return error(\"Plugin {} DNE\".format(plugin_name))\n\n # First, let's see if this is already imported\n module_name = \"plugins.{}\".format(plugin_name)\n if module_name in sys.modules:\n self.cli_unload_plugin(plugin_name)\n mod = sys.modules[module_name]\n importlib.reload(mod)\n self.register_plugin(get_class(mod, plugin_name))\n return ok(\"Plugin {} reloaded\".format(plugin_name))\n\n importlib.invalidate_caches()\n mod = importlib.import_module(module_name)\n self.register_plugin(get_class(mod, plugin_name))\n return ok(\"Plugin {} loaded\".format(plugin_name))","def install(ctx, plugins, **kwargs):\n global logger\n logger = ctx.logger\n\n for plugin in plugins:\n ctx.logger.info(\"Installing plugin {0}\".format(plugin['name']))\n\n if plugin['name'] == 'default_workflows':\n # special handling for the default workflows plugin, as it does not\n # currently sit on the file server and is not under a blueprint\n # context\n plugin['url'] = '/opt/manager/cloudify-manager-{}/workflows'\\\n .format(manager_branch)\n install_celery_plugin(plugin)\n continue\n\n if \"folder\" in plugin:\n\n # convert the folder into a url inside the file server\n\n management_ip = get_cosmo_properties()[\"management_ip\"]\n if management_ip:\n plugin[\"url\"] = \\\n \"http://{0}:53229/blueprints/{1}/plugins/{2}.zip\"\\\n .format(management_ip, ctx.blueprint_id, plugin['folder'])\n\n ctx.logger.info(\"Installing plugin from URL --> {0}\"\n .format(plugin['url']))\n install_celery_plugin(plugin)","def test_remote_plugin(self):\n plugin_name = 'Slack'\n Plugin.download_plugin(plugin_name)\n target = os.path.join(expanduser('~'), '.drupdates', 'plugins', plugin_name)\n plugins = Plugin.get_plugins()\n assert plugins[plugin_name]['info'][1] == os.path.join(target, '__init__.py')","def run(plugin_name: str, namespace: str = \"\"):\n namespace = namespace if namespace else gget(\"namespace\")\n plugin_name = str(plugin_name)\n pf = gget(f\"{namespace}.pf\")\n gpf = gget(f\"general.pf\")\n if (plugin_name in gpf):\n pf = gpf\n namespace = \"general\"\n if(pf.load(plugin_name)):\n print(f'\\n{color.green(f\"Reload {namespace}.{plugin_name} success\")}\\n')\n else:\n print(f'\\n{color.red(pf.get_message(plugin_name))}\\n')","def main():\n parser = ap.ArgumentParser()\n parser.add_argument(\n 'plugins_file',\n type=ap.FileType(),\n help='file holding paths to plugins on GitHub'\n )\n args = parser.parse_args()\n contents = args.plugins_file.read()\n raw_path_list = contents.split('\\n')\n path_list = (pl.Path(raw_path) for raw_path in raw_path_list)\n customizer = VimCustomizer(path_list)\n customizer.configure()","def test_custom_plugin(self):\n plugin_name = 'Druptest'\n source = os.path.join(self.current_dir, 'classes', plugin_name)\n target = os.path.join(expanduser('~'), '.drupdates', 'plugins', plugin_name)\n shutil.copytree(source, target)\n plugins = Plugin.get_plugins()\n assert plugins[plugin_name]['name'] == plugin_name","def request_plugins(self):","def run_all_plugins(self):\n logger.info(\"Starting all plugins\")\n for name in self.name_to_plugin_class:\n if self.name_to_enabled[name]:\n self.run_plugin(name)","def verun(cmd):\n run('pew in {0} {1}'.format(package_name(), cmd))","def get_plugin(self, name):","def register_target_commands():\n for plugin_cls in env.plugins.values():\n # Add target group to root commands. E.g. create `nursery vbox`\n cli.add_command(plugin_cls.cli_entry_func, plugin_cls.cli_entry_func.name)\n\n for cmd in TargetPlugin.root_actions:\n if cmd in plugin_cls.root_command_map:\n # Find the corresponding group in this module to add the target's\n # command group to. E.g. Find `nursery up` and add `vbox` to it.\n globals()[f\"{cmd}_cmd\"].add_command(\n plugin_cls.root_command_map[cmd], plugin_cls.cli_entry_func.name\n )","def _install(package_name, package_version, options_path, app_id, cli, app,\n yes):\n\n if cli is False and app is False:\n # Install both if neither flag is specified\n cli = app = True\n\n # Expand ~ in the options file path\n if options_path:\n options_path = os.path.expanduser(options_path)\n user_options = _user_options(options_path)\n\n package_manager = _get_package_manager()\n pkg = package_manager.get_package_version(package_name, package_version)\n\n pkg_json = pkg.package_json()\n pre_install_notes = pkg_json.get('preInstallNotes')\n if app and pre_install_notes:\n emitter.publish(pre_install_notes)\n if not _confirm('Continue installing?', yes):\n emitter.publish('Exiting installation.')\n return 0\n\n if app and pkg.has_mustache_definition():\n\n # render options before start installation\n options = pkg.options(user_options)\n\n # Install in Marathon\n msg = 'Installing Marathon app for package [{}] version [{}]'.format(\n pkg.name(), pkg.version())\n if app_id is not None:\n msg += ' with app id [{}]'.format(app_id)\n\n emitter.publish(msg)\n\n package_manager.install_app(\n pkg,\n options,\n app_id)\n\n if cli and pkg.has_cli_definition():\n # Install subcommand\n msg = 'Installing CLI subcommand for package [{}] version [{}]'.format(\n pkg.name(), pkg.version())\n emitter.publish(msg)\n\n subcommand.install(pkg)\n\n subcommand_paths = subcommand.get_package_commands(package_name)\n new_commands = [os.path.basename(p).replace('-', ' ', 1)\n for p in subcommand_paths]\n\n if new_commands:\n commands = ', '.join(new_commands)\n plural = \"s\" if len(new_commands) > 1 else \"\"\n emitter.publish(\"New command{} available: {}\".format(plural,\n commands))\n\n post_install_notes = pkg_json.get('postInstallNotes')\n if app and post_install_notes:\n emitter.publish(post_install_notes)\n\n return 0","def cli():\n pass # do nothing here, it just defines the name for other subcommands","def use_plugin(image_path, plugin_name):\n\n import_str = 'from processor.{} import SewingMachine'.format(plugin_name)\n exec(import_str, globals())\n conf = get_conf('processor/{}.toml'.format(plugin_name))\n machine = SewingMachine(image_path, conf)\n return machine.process()","def package():\n call([sys.executable, \"setup.py\", \"clean\", \"--all\", \"bdist_egg\"], cwd=\"src\")\n call([sys.executable, \"setup.py\", \"clean\", \"--all\", \"bdist_wheel\"], cwd=\"src\")","def _import_plugins(self) -> None:\n logger.debug('Importing plugins')\n self._pm = pluggy.PluginManager('sirbot')\n self._pm.add_hookspecs(hookspecs)\n\n for plugin in self.config['sirbot']['plugins']:\n try:\n p = importlib.import_module(plugin)\n except (ModuleNotFoundError, ):\n if os.getcwd() not in sys.path:\n sys.path.append(os.getcwd())\n p = importlib.import_module(plugin)\n else:\n raise\n self._pm.register(p)","def dataComponent_pluginRun(self, **kwargs):\n str_outputPath = '/plugin'\n str_inputPath = '/dataView/files'\n\n str_plugin = 'mri_convert'\n for key,val in kwargs.iteritems():\n if key == 'plugin': str_plugin = val\n if key == 'inputPath': str_inputPath = val\n if key == 'outputPath': str_outputPath = val\n\n s = self.contents\n\n s.cd('/plugins/run')\n rand_date = self.fake.date_time_this_decade()\n str_timestamp = rand_date.isoformat()\n s.mkcd('%s-mri_convert' % str_timestamp)\n\n output = data()\n output.contents_build_1(SeriesFilesCount = 10)\n o = output.contents\n s.graft(o, '/dataView')\n s.graft(o, '/plugins')\n\n # o.tree_metaData_print(False)\n # print(o)\n\n #\n # if s.cd(str_outputPath)['status']:\n # rand_date = self.fake.date_time_this_decade()\n # str_timestamp = rand_date.isoformat()\n # l_run = s.lstr_lsnode()\n # str_newRun = str(len(l_run))\n # s.mkcd(str_newRun)\n # s.touch('timestamp', str_timestamp)\n # s.mknode(['parameters', 'results', 'info'])\n # s.touch('info/detail', {\n # str_plugin: data._dict_plugin[str_plugin]\n # })\n # s.touch('parameters/input', {\n # str_plugin: '<some dictionary of all input parameters>'\n # })\n # s.cd('results')\n # str_outputPath = s.cwd()\n # if str_plugin.lower() != 'pacspull' and str_plugin.lower() != 'mri_convert':\n # self.dataComponent_build(\n # path = s.cwd(),\n # plugin = str_plugin\n # )\n # if str_plugin.lower() == 'mri_convert':\n # inputTree = C_snode.C_stree()\n # inputTree.cd('/')\n # inputTree.graft(s, str_inputPath)\n #\n # self.dataComponent_build(\n # path = str_outputPath,\n # plugin = str_plugin,\n # tree_convertFrom = inputTree,\n # type_convertTo = \"nii\"\n # )","def run_plugin():\n config = load_config()\n all_resources = []\n\n try:\n for resource in config.resources:\n all_resources = all_resources + get_resource(resource['url'], resource.get('sha256'), resource.get('patches'))\n except yaml.YAMLError as e:\n c.eprint(\"%s: invalid yaml\" % url)\n if hasattr(e, 'problem_mark'):\n c.eprint(e.problem_mark)\n c.eprint(e.problem)\n if e.context is not None:\n c.eprint(e.context)\n raise e\n except HTTPError as e:\n c.eprint(\"%s: %s %s\" % (url, e.code, e.reason))\n raise e\n except URLError as e:\n c.eprint(\"%s: %s\" % (url, e.reason))\n raise e\n yaml.dump_all(all_resources, sys.stdout, default_flow_style=False)","def develop():\n# Install package in development mode\n sh('python setup.py develop')","def _install_cli(self, package_name):\n self.logger.info('Installing CLI')\n self._execute_command('rpm -i {0}'.format(package_name), sudo=True)","def do_install(self, args):\n if args:\n try:\n plugin_name, file_path = args.split()[0], args.split()[1]\n except Exception as e:\n return print(display_messages(\"the argument is invalid please type ?install for more information\", error=True))\n if not path.isfile(file_path):\n return print(\n display_messages(\n \"the file {} not found \".format(file_path), error=True\n )\n )\n head, tail = os.path.split(file_path)\n dest = copyfile(file_path, \"{}/{}\".format(self.temp_path, tail))\n print(display_messages(\"copy content file .zip to {}\".format(dest), info=True))\n \n path_to_zip_file = tempfile.gettempdir() + \"/{}\".format(tail)\n with ZipFile(path_to_zip_file, \"r\") as zip_ref:\n zip_ref.extractall(tempfile.gettempdir())\n temp_path_file_extracted = \"{}/{}.py\".format(self.temp_path, plugin_name)\n print(\n display_messages(\n \"extracted files on : {}\".format(temp_path_file_extracted), info=True\n )\n )\n if not path.isfile(temp_path_file_extracted):\n return print(\n display_messages(\n \"the file {} not found \".format(temp_path_file_extracted), error=True\n )\n )\n temp_templates_path = \"{}/{}\".format(self.temp_path, plugin_name)\n if not path.isdir(temp_templates_path):\n return print(\n display_messages(\n \"the directory template {} not found \".format(temp_templates_path), error=True\n )\n )\n source = temp_path_file_extracted\n destination = \"{}/{}.py\".format(self.captiveflask_setup_path, plugin_name)\n dest = copyfile(source, destination)\n print(display_messages(\"copy content file to {}\".format(dest), info=True))\n\n copy_tree(\n temp_templates_path, C.user_config_dir + \"/config/templates/{}\".format(plugin_name)\n )\n print(\n display_messages(\n \"plugin {} install {}\".format( plugin_name,setcolor(\"sucessful\", color=\"green\")),\n info=True,\n )\n )\n return \n print(\n display_messages(\"unknown command: {} \".format(args), error=True)\n )","def installPlugin(filename):\n\n basename = op.splitext(op.basename(filename))[0]\n dest = 'plugins/{}.py'.format(basename)\n\n log.debug('Installing plugin %s', filename)\n\n with open(filename, 'rt') as inf, \\\n fslsettings.writeFile(dest) as outf:\n outf.write(inf.read())\n\n dest = fslsettings.filePath(dest)\n\n try:\n loadPlugin(dest)\n except Exception:\n fslsettings.deleteFile(dest)\n raise","def uninstall_celery_plugin(plugin_name):\n\n # this will uninstall the plugin\n command = \"{0} uninstall -y {1}\".format(get_pip(), plugin_name)\n run_command(command)\n logger.debug(\"uninstalled plugin {0} from \"\n \"python installation {1}\"\n .format(plugin_name, get_python()))","def main():\n\n addon_url = sys.argv[0]\n addon_handle = int(sys.argv[1])\n addon_args = urlparse.parse_qs(sys.argv[2][1:])\n\n # Route request to action.\n Plugin(addon_url, addon_handle, addon_args).route()","def handle_command_line():\n commands = scan_for_commands()\n parser = argparse.ArgumentParser(\n description=\"A set of utilities to ease the installation of Modoboa.\",\n epilog=\"\"\"Available commands:\n%s\n\"\"\" % \"\\n\".join([\"\\t%s\" % c for c in sorted(commands)]))\n parser.add_argument(\"--verbose\", action=\"store_true\",\n help=\"Activate verbose output\")\n parser.add_argument(\"command\", type=str,\n help=\"A valid command name\")\n (args, remaining) = parser.parse_known_args()\n\n if args.command not in commands:\n print(\"Unknown command '%s'\" % args.command, file=sys.stderr)\n sys.exit(1)\n\n commands[args.command](commands, verbose=args.verbose).run(remaining)","def do_package(package):\n\tn_ucr = extFile(package, 'univention-config-registry')\n\tif not os.path.exists(n_ucr):\n\t\treturn\n\n\tf_ucr = open(n_ucr, 'r')\n\n\tfor item in univention.config_registry.parseRfc822(f_ucr.read()):\n\t\ttyp = item['Type'][0]\n\t\tif typ == 'file':\n\t\t\tf = item['File'][0]\n\t\t\tdoIt('install', '-d', destDir(f, package))\n\t\t\tdoIt('cp', '-a', srcPath(f), destPath(f, package))\n\t\t\tfor key in ('Preinst', 'Postinst'):\n\t\t\t\tif key in item:\n\t\t\t\t\tmod = item[key][0]\n\t\t\t\t\tdoIt('install', '-d', destDir(mod, package, 'modules'))\n\t\t\t\t\tdoIt('cp', '-a', srcPath(mod), destPath(mod, package, 'modules'))\n\t\telif typ == 'subfile':\n\t\t\tf = item['Subfile'][0]\n\t\t\tdoIt('install', '-d', destDir(f, package))\n\t\t\tdoIt('cp', '-a', srcPath(f), destPath(f, package))\n\t\telif typ == 'multifile':\n\t\t\tf = item['Multifile'][0]\n\t\t\tif os.path.exists(f):\n\t\t\t\tdoIt('install', '-d', destDir(f, package))\n\t\t\t\tdoIt('cp', '-a', srcPath(f), destPath(f, package))\n\t\t\tfor key in ('Preinst', 'Postinst'):\n\t\t\t\tif key in item:\n\t\t\t\t\tmod = item[key][0]\n\t\t\t\t\tdoIt('install', '-d', destDir(mod, package, 'modules'))\n\t\t\t\t\tdoIt('cp', '-a', srcPath(mod), destPath(mod, package, 'modules'))\n\t\telif typ == 'script':\n\t\t\tf = item['Script'][0]\n\t\t\tdoIt('install', '-d', destDir(f, package, 'scripts'))\n\t\t\tdoIt('cp', '-a', srcPath(f), destPath(f, package, 'scripts'))\n\t\t\tdoIt('chmod', 'a+x', destPath(f, package, 'scripts'))\n\t\telif typ == 'module':\n\t\t\tf = item['Module'][0]\n\t\t\tdoIt('install', '-d', destDir(f, package, 'modules'))\n\t\t\tdoIt('cp', '-a', srcPath(f), destPath(f, package, 'modules'))\n\t\telse:\n\t\t\tprint >>sys.stderr, 'Unknown type: %s' % typ\n\t\t\treturn\n\n\tf_ucr.close()\n\n\tdoIt('install', '-d', destDir('', package, 'info'))\n\tdoIt('install', '-m644', n_ucr, destPath(package+'.info', package, 'info'))\n\tmapping_file = extFile( package, 'univention-config-registry-mapping')\n\tif os.path.exists(mapping_file):\n\t\tdoIt('install', '-d', destDir('', package, 'mapping'))\n\t\tdoIt('install', '-m644', mapping_file, destPath(package+'.univention-config-registry-mapping', package, 'mapping'))\n\n\tdata = {\n\t\t\t'pkg': quote(package),\n\t\t\t'info': quote(\"/etc/univention/templates/info/%s.info\" % package),\n\t\t\t'removed': quote(\"/etc/univention/templates/removed/%s.info\" % package),\n\t\t\t}\n\n\tf_preinst = open(extFile(package, 'preinst.debhelper'), 'a')\n\tf_preinst.write('# Automatically added by univention-install-config-registry\\n')\n\tf_preinst.write('if [ \"$1\" = \"install\" ] ; then\\n')\n\tf_preinst.write(' [ -e %(removed)s ] && [ ! -e %(info)s ] && mv %(removed)s %(info)s || true\\n' % data)\n\tf_preinst.write('fi\\n')\n\tf_preinst.write('# End automatically added section\\n')\n\tf_preinst.close()\n\n\tf_postinst = open(extFile(package, 'postinst.debhelper'), 'a')\n\tf_postinst.write('# Automatically added by univention-install-config-registry\\n')\n\tf_postinst.write('if [ \"$1\" = \"abort-remove\" ]; then\\n')\n\tf_postinst.write(' [ -e %(removed)s ] && mv %(removed)s %(info)s || true\\n' % data)\n\tf_postinst.write('fi\\n')\n\tf_postinst.write('[ -x /usr/sbin/univention-config-registry ] && univention-config-registry register %(pkg)s || true\\n' % data)\n\tf_postinst.write('# End automatically added section\\n')\n\tf_postinst.close()\n\n\tf_prerm = open(extFile(package, 'prerm.debhelper'), 'a')\n\tf_prerm.write('# Automatically added by univention-install-config-registry\\n')\n\tf_prerm.write('if [ \"$1\" = \"remove\" ] && [ -e %(info)s ] ; then\\n' % data)\n\tf_prerm.write(' [ -x /usr/sbin/univention-config-registry ] && univention-config-registry unregister %(pkg)s || true\\n' % data)\n\tf_prerm.write(' mv %(info)s %(removed)s || true\\n' % data)\n\tf_prerm.write('fi\\n')\n\tf_prerm.write('# End automatically added section\\n')\n\tf_prerm.close()\n\n\tdoIt('perl', '-e', 'use Debian::Debhelper::Dh_Lib;addsubstvar(\"%s\", \"misc:Depends\", \"univention-config (>= 7.0.25)\");' % package)","def package_cmd(self):\n return 'zypper'","def on_package_parse(self, ctx):\n return None","def new_plugin(ctx, **defaults):\n from .quickstart import plugin_quickstart\n\n project = ctx.get_project(silent=True)\n plugin_quickstart(defaults, project=project)","def main():\n\n # Load all the commands\n commands = {}\n for entry_point in pkg_resources.iter_entry_points('nagare.commands'):\n try:\n commands[entry_point.name] = entry_point.load()\n except ImportError:\n print \"Warning: the command '%s' can't be imported\" % entry_point.name\n raise\n\n parser = optparse.OptionParser(usage='\\n'.join(usage(commands)))\n\n if (len(sys.argv) == 1) or (sys.argv[1] == '-h') or (sys.argv[1] == '--help'):\n parser.print_usage(sys.stderr)\n parser.exit()\n\n command_name = sys.argv[1]\n command = commands.get(command_name)\n if command is None:\n parser.error(\"command '%s' not found\" % command_name)\n\n parser.usage = '%%prog %s [options]' % command_name\n\n argv = command.set_options(parser) # Let the command register its command line options\n (options, args) = parser.parse_args((argv if argv is not None else sys.argv)[2:]) # Parse the command line\n\n command.run(parser, options, args) # Run the command","def execute(self):\n # Preprocess options to extract --settings and --pythonpath.\n # These options could affect the commands that are available, so they\n # must be processed early.\n parser = LaxOptionParser(usage=\"%prog subcommand [options] [args]\",\n version=magpy.get_version(),\n option_list=BaseCommand.option_list)\n self.autocomplete()\n try:\n options, args = parser.parse_args(self.argv)\n handle_default_options(options)\n except:\n # Ignore any option errors at this point.\n pass # pylint: disable-msg=W0702\n\n try:\n subcommand = self.argv[1]\n except IndexError:\n subcommand = 'help' # Display help if no arguments were given.\n\n if subcommand == 'help':\n if len(args) <= 2:\n parser.print_lax_help()\n sys.stdout.write(self.main_help_text() + '\\n')\n elif args[2] == '--commands':\n sys.stdout.write(\n self.main_help_text(commands_only=True) + '\\n')\n else:\n self.fetch_command(args[2]).print_help(self.prog_name, args[2])\n elif subcommand == 'version':\n sys.stdout.write(parser.get_version() + '\\n')\n # Special-cases: We want 'django-admin.py --version' and\n # 'django-admin.py --help' to work, for backwards compatibility.\n elif self.argv[1:] == ['--version']:\n # LaxOptionParser already takes care of printing the version.\n pass\n elif self.argv[1:] in (['--help'], ['-h']):\n parser.print_lax_help()\n sys.stdout.write(self.main_help_text() + '\\n')\n else:\n self.fetch_command(subcommand).run_from_argv(self.argv)","def load_plugins(self) -> None:\n import importlib\n import pkgutil\n import stactools\n\n # From https://packaging.python.org/guides/creating-and-discovering-plugins/#using-namespace-packages # noqa\n def iter_namespace(ns_pkg: ModuleType) -> Iterator[ModuleInfo]:\n # Specifying the second argument (prefix) to iter_modules makes the\n # returned name an absolute name instead of a relative one. This allows\n # import_module to work without having to do additional modification to\n # the name.\n return pkgutil.iter_modules(\n ns_pkg.__path__, # type: ignore # mypy issue #1422\n ns_pkg.__name__ + '.')\n\n discovered_plugins = {\n name: importlib.import_module(name)\n for finder, name, ispkg in iter_namespace(stactools)\n }\n\n for name, module in discovered_plugins.items():\n register_plugin = getattr(module, 'register_plugin', None)\n if register_plugin:\n register_plugin(self)","def do_command(self, args):\n pass","def _get_commands(package_name):\n # pylint: disable=line-too-long\n def lookup(cmd, dct):\n if not cmd:\n return dct\n if len(cmd) == 1:\n return dct[cmd[0]]\n return lookup(cmd[1:], dct[cmd[0]])\n\n def walking_import(module, cmd, dct):\n car, cdr = cmd[0], cmd[1:]\n if cdr:\n walking_import(module, cdr, dct[car])\n elif car not in dct:\n __import__(module)\n dct.setdefault(car, {})['__module__'] = sys.modules[module]\n\n __import__(COMMANDS_PACKAGE_NAME)\n command_module = sys.modules[COMMANDS_PACKAGE_NAME]\n for _, module, _ in pkgutil.walk_packages(command_module.__path__, prefix=command_module.__name__+'.'):\n if not (module.endswith('__main__') or '.tests' in module):\n try:\n lookup(_command_as_list(module), _COMMANDS)\n except KeyError:\n walking_import(module, _command_as_list(module), _COMMANDS)\n return lookup(_command_as_list(package_name), _COMMANDS)","def _install(self):\n # Default implementation\n for pm_name, package in self._provider_package.items():\n if helpers[pm_name]:\n helpers[pm_name].install_package(package)\n return\n raise self.unsure_how_to_install()","def _add_arguments(parser):\n parser.add_argument(\n \"command\",\n help='The plugin to run. e.g. \"shell\".',\n choices=sorted(registry.get_command_keys()),\n )\n\n parser.add_argument(\n \"-x\",\n \"--maximum-repositories\",\n default=sys.maxsize,\n type=int,\n help='If a value of `2` is used, it means \"Only search 2 repositories '\n 'for Rez packages to run on, at most\".',\n )\n\n parser.add_argument(\n \"-z\",\n \"--maximum-rez-packages\",\n default=sys.maxsize,\n type=int,\n help='If a value of `2` is used, it means \"Only search for 2 Rez packages '\n 'to run some comm on, at most\".',\n )\n\n parser.add_argument(\n \"-p\",\n \"--packages-path\",\n default=[config.release_packages_path], # pylint: disable=no-member\n help=\"A `{os.pathsep}` separated list of paths that report/run will be run on. \"\n \"If not defined, `rez.config.config.release_packages_path` is used, instead.\".format(\n os=os\n ),\n )\n\n parser.add_argument(\n \"-s\",\n \"--search-packages-path\",\n default=[config.release_packages_path], # pylint: disable=no-member\n help=\"A `{os.pathsep}` separated list of paths to search for Rez package dependencies. \"\n \"If not defined, `rez.config.config.release_packages_path` is used, instead.\".format(\n os=os\n ),\n )\n\n parser.add_argument(\n \"-i\",\n \"--ignore-patterns\",\n default=[],\n nargs=\"*\",\n help=\"A set of glob expressions or a file to a set of glob expressions. \"\n \"If a Rez package name matches one of \"\n \"these, it will not be run on.\",\n )\n\n parser.add_argument(\n \"-k\",\n \"--keep-temporary-files\",\n action=\"store_true\",\n help=\"If added, do not delete any temporary files that are generated during this run.\",\n )\n\n parser.add_argument(\n \"-r\",\n \"--rez-packages\",\n default=set(),\n nargs=\"+\",\n help=\"The names of Rez packages to process. If no names are given, \"\n \"every Rez package that is found will be processed.\",\n )\n\n parser.add_argument(\n \"-t\",\n \"--temporary-directory\",\n help=\"A folder on-disk that will be used to clone git repositories.\",\n )","def do(self):\r\n parameters = ParametersParserStr(self.args_parameters).get()\r\n self.core.install(self.product_names, parameters, with_dependencies=True)","def test_setup_module(self):\n pluggable_package.setup(self._test_module)\n self._test_setup(self._test_module)","def test_install_terraform_plugin_1(monkeypatch):\n monkeypatch.setattr(os, 'listdir', lambda path: [\n 'terraform-provider-terraform_v0.11.2_x4'])\n monkeypatch.setattr(os, 'remove', lambda path: True)\n monkeypatch.setattr(os, 'chmod', lambda path, permissions: True)\n\n monkeypatch.setattr(shutil, 'copy2', lambda src, dest: True)\n\n def mp_check_output(cmd):\n if cmd == ['which', 'terraform']:\n return b'/usr/local/bin/terraform\\n'\n\n if cmd == ['terraform', '-v']:\n return b'Terraform v0.11.3\\n\\n'\n\n raise Exception('Unmocked command: %s' % cmd)\n\n monkeypatch.setattr(subprocess, 'check_output', mp_check_output)\n\n install_terraform_plugin('/tmp/stone-burner_plugins')","def getCommands():\n return getPlugins(ICommand, plugins)","def execute_tool(description, *args):\n command_line = list(args) + files_and_directories\n click.echo(f\"{description}: {' '.join(command_line)}\")\n rv = call(command_line)\n if rv != 0:\n exit(rv)","def main(ctx, debug, config, index, python, delivery, packager):\n global PACKAGER\n PACKAGER = PexPackager if packager == \"pex\" else VenvPackager\n\n runez.system.AbortException = SystemExit\n if ctx.invoked_subcommand != \"package\":\n cli = TrackedSettings(delivery, index, python)\n base = find_base()\n CFG.set_base(base, config_path=config, cli=cli)\n\n runez.log.setup(\n debug=debug,\n console_format=\"%(levelname)s %(message)s\" if debug else \"%(message)s\",\n console_level=logging.WARNING,\n console_stream=sys.stderr,\n locations=None,\n )","def setup(self):\n\n if self.has_setup():\n self.logger.info(\"%s has a pre-flight setup routine. Running now.\" % self.plugin_dict_name)\n self._module.setup(self, self.versions)","def execute(self):\n\n options, args = self.parser.parse_args(self.argv)\n\n try:\n subcommand_name = self.argv[1]\n except IndexError:\n subcommand_name = 'help'\n\n if subcommand_name == 'help':\n if len(args) <= 2:\n self.print_help()\n else:\n self.fetch_subcommand(self.argv[2]).print_help()\n elif subcommand_name == 'version':\n self.print_version()\n else:\n self.fetch_subcommand(subcommand_name).execute()","def work(self):\n\n cmd = self.options.command\n cmdargs = self.options.args\n\n # find function\n fname = \"cmd_\" + cmd.replace('-', '_')\n if not hasattr(self, fname):\n self.log.error('bad subcommand, see --help for usage')\n sys.exit(1)\n fn = getattr(self, fname)\n\n b = inspect.signature(fn).bind(*cmdargs)\n\n fn(*b.args, **b.kwargs)","def resolve(name: str) -> Iterator[Plugin]:\n sys.path.append(getcwd())\n module = importlib.import_module(name)\n\n yield from load_plugins_from_module(module)","def load_plugin(name, plugin_context, globals_=None):\n \n # remap friendly names to actual implementation. this is a bit of\n # abstraction leakage and should instead be dynamically registered\n # (though much more expensive).\n\n #TODO: this is a hack until rosh_testing is a proper framework/plugin\"\n if name == 'rosh.impl.testing':\n import rosh.impl.testing\n rosh.impl.testing.load_rosh_plugin('rosh.impl.ros_testing', plugin_context, globals_)\n return\n \n try:\n # make sure plugin exists for accurate error reporting\n roslib.packages.get_pkg_dir(name)\n except roslib.packages.InvalidROSPkgException, e:\n raise NoPlugin(\"invalid plugin [%s]: no ROS package named [%s]\"%(name, name))\n try:\n roslib.load_manifest(name)\n except roslib.packages.InvalidROSPkgException, e:\n raise InvalidPlugin(\"Failed to locate dependencies of plugin [%s]: \\n[%s]\"%(name, str(e)))\n try:\n m = __import__(name)\n except ImportError:\n raise InvalidPlugin(\"invalid plugin [%s]: python module [%s] import failed\"%(name, name))\n try:\n loader = getattr(m, 'rosh_plugin_load')\n except AttributeError, e:\n raise InvalidPlugin(\"invalid plugin [%s]: plugin is missing rosh_plugin_load() entry point\"%(name))\n\n try:\n plugin_data = loader(plugin_context, globals_)\n except Exception, e:\n raise InvalidPlugin(\"invalid plugin [%s]: plugin raised Exception on load: %s\"%(name, e))\n errors = []\n if plugin_data is not None:\n \n # Wire up plugins. Although the plugins could do this\n # themselves, de-coupling provides better protection against\n # future implementation changes and is also easier to write\n # tests for.\n\n # - We load as much as we can, record the errors, then\n # re-raise at the end.\n for plugin_api_id, callback in plugin_data.apis.iteritems():\n try:\n plugin_context._register_api(plugin_api_id, callback)\n except Exception, e:\n errors.append(e)\n\n for plugin_api_id, args in plugin_data.handlers.iteritems():\n try:\n plugin_context._register_handler(plugin_api_id, args)\n except Exception, e:\n errors.append(e)\n\n if errors:\n error_str = [str(e) for e in errors]\n raise ROSHException(\"errors loading plugin [%s]: \\n%s\"%(name, '\\n'.join(error_str)))","def enablePackageInternal(self, *args):\n return _libsbml.MultiASTPlugin_enablePackageInternal(self, *args)","def test_plugin_cannot_be_imported_disable(conf):\n plugin_name = \"giraffe.horse\"\n conf.config[\"INSTALLED_APPS\"].append(plugin_name)\n conf.save()\n cli.plugin(plugin_name, disable=True)\n assert plugin_name not in conf.config[\"INSTALLED_APPS\"]","def test_discover_and_install_1(monkeypatch):\n monkeypatch.setattr(subprocess, 'check_call', lambda cmd: True)\n monkeypatch.setattr(os, 'getcwd', lambda: '/tmp')\n monkeypatch.setattr(os, 'chdir', lambda path: True)\n monkeypatch.setattr(os, 'walk', lambda path: [\n ('root', ['d1', 'd2'], ['f1', 'f2']), ])\n monkeypatch.setattr(tempfile, 'mkdtemp', lambda: '/tmp/tempdir')\n monkeypatch.setattr(shutil, 'move', lambda src, dest: True)\n monkeypatch.setattr(shutil, 'rmtree', lambda path: True)\n\n discover_and_install(\n '/tmp/stone-burner_plugins',\n 'p1',\n ['c1', 'c2', 'c3'],\n SAMPLE_CONFIG,\n ['c1', 'c2'],\n )"],"string":"[\n \"def init_plugins(group):\\n package = sys.modules[__name__]\\n\\n for (importer, module_name, ispkg) in pkgutil.iter_modules(package.__path__):\\n if not ispkg:\\n try:\\n module = importlib.import_module(package.__name__ + '.' + module_name)\\n\\n if 'run' not in module.__dict__:\\n print_fail('Plugin command \\\"%s\\\" doesn\\\\'t provide a \\\"run\\\" method. Aborting.' % (module_name))\\n # sys.exit(-1)\\n else:\\n group.add_command(module.run)\\n except Exception, e:\\n print_fail('[%s] %s' % (module_name, str(e) + str(type(e))))\",\n \"def main():\\n PLUGIN_ENTRY().run(\\\"\\\")\",\n \"def execute(self):\\n rc = self.rc\\n try:\\n for plugin in self.plugins:\\n plugin.execute(rc)\\n except Exception as e:\\n self.exit(e)\",\n \"def run_plugin(argv):\\n\\treturn subprocess.Popen(argv, stdout=subprocess.PIPE)\",\n \"def do_plugin(self, args):\\n #TODO GET A LIST OF PARAMETERS FROM THE PLUGIN\\n lex_parser = shlex.shlex(args.strip(), posix=True)\\n lex_parser.whitespace += \\\"=\\\"\\n lex_parser.escapedquotes = \\\"\\\"\\n lex_parser.wordchars += \\\"~-./*?=\\\"\\n tokens = [token for token in lex_parser]\\n\\n _MOD_LOGGER.debug(\\\"Plugin tokens: %s\\\", tokens)\\n\\n if len(tokens) < 1:\\n print(\\\"Error, invalid command.\\\")\\n return\\n\\n if tokens[0] == \\\"list\\\":\\n self.print_plugin_list()\\n elif tokens[0] == \\\"set\\\":\\n self.set_plugin(tokens[1:])\\n else:\\n print(\\\"Error, invalid command.\\\")\",\n \"def load_plugins(self):\\n self.__doing('load_plugins')\\n self.__do_if_not_done('bootstrap')\\n if self.env.mode in ('dummy', 'unit_test'):\\n return\\n for package in self.packages:\\n self.add_package(package)\",\n \"def main():\\n\\n cwd = os.path.realpath(__file__)\\n plugin_dir = os.path.join(os.path.dirname(cwd), 'plugins')\\n plugins = {\\n name.replace('greet_', ''): importlib.import_module('plugins.' + name)\\n for _, name, _ in pkgutil.iter_modules(path=[plugin_dir])\\n if name.startswith('greet_')\\n }\\n\\n args = get_args(plugins)\\n\\n print(plugins[args.language].greet(args.name))\",\n \"def discover_all_plugins(self):\\n for v in pkg_resources.iter_entry_points('dgit.plugins'):\\n m = v.load()\\n m.setup(self)\",\n \"def run(self, plugin: T_Plugin, *args: Any, **kwargs: Any) -> None:\\n pass\",\n \"def run(self, plugin: T_Plugin, *args: Any, **kwargs: Any) -> None:\\n return plugin.run(*args, **kwargs)\",\n \"def python_plugin(path, name):\\n require.directory(_uwsgi.UWSGI_PLUGINS_LOCATION, use_sudo=True)\\n if not _uwsgi.plugin_exists(name):\\n with cd(_uwsgi.UWSGI_INSTALLATION_DIR):\\n cmd = \\\"PYTHON={path} ./uwsgi --build-plugin \\\\\\\"plugins/python {name}\\\\\\\"\\\"\\n sudo(cmd.format(**locals()))\\n files.move(\\n \\\"{0}_plugin.so\\\".format(name), _uwsgi.UWSGI_PLUGINS_LOCATION,\\n use_sudo=True\\n )\",\n \"def package_plugin(specs_path: str, package_name: str, plugin_dir: str, dst_path: Path):\\n hm_generator = HookManGenerator(hook_spec_file_path=specs_path)\\n hm_generator.generate_plugin_package(\\n package_name=package_name, plugin_dir=plugin_dir, dst_path=Path(dst_path)\\n )\\n return 0\",\n \"def test_plugin_command(node_factory):\\n n = node_factory.get_node()\\n\\n # Make sure that the 'hello' command from the helloworld.py plugin\\n # is not available.\\n cmd = [hlp for hlp in n.rpc.help()[\\\"help\\\"] if \\\"hello\\\" in hlp[\\\"command\\\"]]\\n assert(len(cmd) == 0)\\n\\n # Add the 'contrib/plugins' test dir\\n n.rpc.plugin_startdir(directory=os.path.join(os.getcwd(), \\\"contrib/plugins\\\"))\\n # Make sure that the 'hello' command from the helloworld.py plugin\\n # is now available.\\n cmd = [hlp for hlp in n.rpc.help()[\\\"help\\\"] if \\\"hello\\\" in hlp[\\\"command\\\"]]\\n assert(len(cmd) == 1)\\n\\n # Make sure 'rescan' and 'list' subcommands dont crash\\n n.rpc.plugin_rescan()\\n n.rpc.plugin_list()\\n\\n # Make sure the plugin behaves normally after stop and restart\\n assert(\\\"Successfully stopped helloworld.py.\\\" == n.rpc.plugin_stop(plugin=\\\"helloworld.py\\\")[''])\\n n.daemon.wait_for_log(r\\\"Killing plugin: helloworld.py\\\")\\n n.rpc.plugin_start(plugin=os.path.join(os.getcwd(), \\\"contrib/plugins/helloworld.py\\\"))\\n n.daemon.wait_for_log(r\\\"Plugin helloworld.py initialized\\\")\\n assert(\\\"Hello world\\\" == n.rpc.call(method=\\\"hello\\\"))\\n\\n # Now stop the helloworld plugin\\n assert(\\\"Successfully stopped helloworld.py.\\\" == n.rpc.plugin_stop(plugin=\\\"helloworld.py\\\")[''])\\n n.daemon.wait_for_log(r\\\"Killing plugin: helloworld.py\\\")\\n # Make sure that the 'hello' command from the helloworld.py plugin\\n # is not available anymore.\\n cmd = [hlp for hlp in n.rpc.help()[\\\"help\\\"] if \\\"hello\\\" in hlp[\\\"command\\\"]]\\n assert(len(cmd) == 0)\\n\\n # Test that we cannot start a plugin with 'dynamic' set to False in\\n # getmanifest\\n with pytest.raises(RpcError, match=r\\\"Not a dynamic plugin\\\"):\\n n.rpc.plugin_start(plugin=os.path.join(os.getcwd(), \\\"tests/plugins/static.py\\\"))\\n\\n # Test that we cannot stop a started plugin with 'dynamic' flag set to\\n # False\\n n2 = node_factory.get_node(options={\\n \\\"plugin\\\": os.path.join(os.getcwd(), \\\"tests/plugins/static.py\\\")\\n })\\n with pytest.raises(RpcError, match=r\\\"static.py cannot be managed when lightningd is up\\\"):\\n n2.rpc.plugin_stop(plugin=\\\"static.py\\\")\\n\\n # Test that we don't crash when starting a broken plugin\\n with pytest.raises(RpcError, match=r\\\"Timed out while waiting for plugin response\\\"):\\n n2.rpc.plugin_start(plugin=os.path.join(os.getcwd(), \\\"tests/plugins/broken.py\\\"))\",\n \"def setup(self):\\n rc = self.rc\\n try:\\n for plugin in self.plugins:\\n plugin.setup(rc)\\n except Exception as e:\\n self.exit(e)\",\n \"def _package_plugins(ctx):\\n print(\\\"\\\\n\\\\n-- Creating Zip Files \\\\n\\\")\\n\\n project_dir = Path(__file__).parent\\n plugins_projects = [\\n x for x in (project_dir / \\\"build/build_directory_for_tests/\\\").iterdir() if x.is_dir()\\n ]\\n artifacts_dir = project_dir / \\\"build/artifacts\\\"\\n\\n plugins_zip = project_dir / \\\"build/plugin_zip\\\"\\n if plugins_zip.exists():\\n shutil.rmtree(plugins_zip)\\n\\n plugins_zip.mkdir()\\n\\n for project in plugins_projects:\\n plugins_dirs = [\\n x for x in (project / \\\"plugin\\\").iterdir() if x.is_dir() and (x / \\\"assets\\\").exists()\\n ]\\n hm_generator = HookManGenerator(\\n hook_spec_file_path=project_dir / f\\\"tests/plugins/{project.name}/hook_specs.py\\\"\\n )\\n\\n for plugin in plugins_dirs:\\n (plugin / \\\"artifacts\\\").mkdir()\\n if sys.platform == \\\"win32\\\":\\n shutil.copy2(src=artifacts_dir / f\\\"{plugin.name}.dll\\\", dst=plugin / \\\"artifacts\\\")\\n else:\\n shutil.copy2(src=artifacts_dir / f\\\"lib{plugin.name}.so\\\", dst=plugin / \\\"artifacts\\\")\\n\\n hm_generator.generate_plugin_package(\\n package_name=plugin.name, plugin_dir=plugin, dst_path=plugins_zip\\n )\",\n \"def _run_plugin(plugin_class, plugin_config: typing.Dict, exit_event: multiprocessing.Event):\\n plugin_instance = plugin_class(plugin_config, exit_event)\\n plugin_instance.run_plugin()\",\n \"def invoke(\\n project: Project,\\n plugin_type: str,\\n dump: str,\\n list_commands: bool,\\n plugin_name: str,\\n plugin_args: Tuple[str, ...],\\n):\\n try:\\n plugin_name, command_name = plugin_name.split(\\\":\\\")\\n except ValueError:\\n command_name = None\\n\\n plugin_type = PluginType.from_cli_argument(plugin_type) if plugin_type else None\\n\\n _, Session = project_engine(project)\\n session = Session()\\n plugins_service = ProjectPluginsService(project)\\n plugin = plugins_service.find_plugin(\\n plugin_name, plugin_type=plugin_type, invokable=True\\n )\\n\\n if list_commands:\\n do_list_commands(plugin)\\n return\\n\\n invoker = invoker_factory(project, plugin, plugins_service=plugins_service)\\n exit_code = run_async(\\n _invoke(invoker, project, plugin_name, plugin_args, session, dump, command_name)\\n )\\n sys.exit(exit_code)\",\n \"def install_celery_plugin(plugin):\\n\\n plugin_url = plugin[\\\"url\\\"]\\n\\n plugin_name = extract_plugin_name(plugin_url)\\n\\n module_paths = extract_module_paths(plugin_name)\\n\\n # this will install the plugin and\\n # its dependencies into the python installation\\n command = \\\"{0} install --process-dependency-links {1}\\\"\\\\\\n .format(get_pip(), plugin_url)\\n run_command(command)\\n logger.debug(\\\"installed plugin {0} and \\\"\\n \\\"dependencies into python installation {1}\\\"\\n .format(plugin_name, get_python()))\\n\\n write_to_includes(\\\",\\\".join(module_paths))\",\n \"def run(args, plugins):\\n\\n # This has to happen before we parse the args, otherwise we might\\n # get subcommand not found.\\n for name, instance in plugins.items():\\n if isinstance(instance, SubCommandPlugin):\\n logging.debug('Adding SubCommandPlugin %s' % name)\\n try:\\n instance.register(subparsers.add_parser, configuration.add_defaults)\\n logging.debug('Done adding SubCommandPlugin %s' % name)\\n name = instance.name()\\n if name in actions:\\n raise Exception('SubCommandPlugin %s clashes with an existing subcommand.' % name)\\n actions[name] = instance.run\\n except Exception as e:\\n print('Failed to load SubCommandPlugin %s: %s' % (name, e), file=sys.stderr)\\n\\n args = vars(parser.parse_args(args))\\n\\n util.silent = args.pop('silent')\\n verbose = args.pop('verbose') and not util.silent\\n\\n log_format = '%(asctime)s [%(levelname)s] [%(name)s] %(message)s'\\n if verbose:\\n logging.getLogger('').handlers = []\\n logging.basicConfig(format=log_format, level=logging.DEBUG)\\n else:\\n logging.disable(logging.FATAL)\\n\\n logging.debug('args: %s', args)\\n\\n action = args.pop('action')\\n config_path = args.pop('config')\\n cluster = args.pop('cluster')\\n url = args.pop('url')\\n pool_name = args.get('pool-name')\\n\\n if action is None:\\n parser.print_help()\\n else:\\n _, config_map = configuration.load_config_with_defaults(config_path)\\n try:\\n metrics.initialize(config_map)\\n # measure the number of times users specify each cluster, including when none is specified\\n metrics.inc('command.%s.runs' % action, additional_tags={'cluster': (cluster or 'default')})\\n http.configure(config_map, plugins)\\n cook.plugins.configure(plugins)\\n args = {k: v for k, v in args.items() if v is not None}\\n defaults = config_map.get('defaults')\\n action_defaults = (defaults.get(action) if defaults else None) or {}\\n # load_target_clusters needs to be aware if there are any action-specific cluster defaults\\n # We want to treat cluster, pool and url as a tuple here, so if any are specified on the cli,\\n # we will override the defaults.\\n # Additionally, we must `pop` to remove the disallowed 'cluster' key, regardless of\\n # whether we use the action_defaults or the cli flags\\n if action_defaults:\\n action_default_cluster = action_defaults.pop(\\\"cluster\\\", None)\\n action_default_url = action_defaults.pop(\\\"url\\\", None)\\n if cluster or pool_name or url:\\n action_defaults.pop(\\\"pool-name\\\", None)\\n else:\\n cluster = action_default_cluster\\n url = action_default_url\\n clusters = load_target_clusters(config_map, url=url, cluster=cluster)\\n logging.debug('going to execute % action' % action)\\n result = actions[action](clusters, deep_merge(action_defaults, args), config_path)\\n logging.debug('result: %s' % result)\\n return result\\n finally:\\n metrics.close()\\n\\n return None\",\n \"def add_package(self, package):\\n package_name = package.__name__\\n package_file = package.__file__\\n package_dir = path.dirname(path.abspath(package_file))\\n\\n parent = sys.modules[package_name.rpartition('.')[0]]\\n parent_dir = path.dirname(path.abspath(parent.__file__))\\n if parent_dir == package_dir:\\n raise errors.PluginsPackageError(\\n name=package_name, file=package_file\\n )\\n\\n logger.debug(\\\"importing all plugin modules in %s...\\\", package_name)\\n modules = getattr(package, 'modules', find_modules_in_dir(package_dir))\\n modules = ['.'.join((package_name, mname)) for mname in modules]\\n\\n for name in modules:\\n logger.debug(\\\"importing plugin module %s\\\", name)\\n try:\\n module = importlib.import_module(name)\\n except errors.SkipPluginModule as e:\\n logger.debug(\\\"skipping plugin module %s: %s\\\", name, e.reason)\\n continue\\n except Exception as e:\\n if self.env.startup_traceback:\\n logger.exception(\\\"could not load plugin module %s\\\", name)\\n raise\\n\\n try:\\n self.add_module(module)\\n except errors.PluginModuleError as e:\\n logger.debug(\\\"%s\\\", e)\",\n \"def __xcall__(self, cmd):\\n\\n return call_pkgconfig(cmd + [self.name], self.paths)\",\n \"def cli(ctx: click.Context) -> None:\\n pkg = read_package_from_file(PACKAGE_PATH)\\n ctx.obj = pkg\",\n \"def main(ctx: typer.Context):\\n LOG.debug(F\\\"COVIDAP: executing command: {ctx.invoked_subcommand}\\\")\",\n \"def execute_setuptools(self, *cmd, **options):\\n version = options.get('version')\\n if version not in self._setuptools:\\n self._lock.acquire()\\n try:\\n if version not in self._setuptools:\\n self._setuptools[version] = find_setuptools(\\n self, version=version)\\n finally:\\n self._lock.release()\\n\\n if self._setuptools[version] is not None:\\n options.setdefault('environ', {})\\n options['environ']['PYTHONPATH'] = self._setuptools[version]\\n options['python_options'] = ['-S']\\n return self.execute_module(setuptoolize, *cmd, **options)\",\n \"def main(command: Optional[str] = None) -> int:\\n package_registrar.import_and_register_cli_extension_packages()\\n\\n if VERSION_FLAG in sys.argv or (command and VERSION_FLAG in command):\\n logger.info(f\\\"Gazoo Device Manager {gazoo_device.version}\\\")\\n package_versions = extensions.get_registered_package_info()\\n logger.info(f\\\"Registered extension packages: {package_versions}\\\")\\n return 0\\n\\n return execute_command(command)\",\n \"def plugins():\\n pass\",\n \"def load_commands():\\n register_plugin(configure_client_details)\\n register_plugin(search_venues)\",\n \"def load(cls, name):\\n try:\\n return importlib.import_module(cls._plugins[name])\\n except Exception as err:\\n print(\\\"** could not load command [%s]:\\\\n%s\\\" % (name, err))\",\n \"def main():\\n if len(sys.argv) < 2:\\n print(\\\"PM endpoint needed as first argument.\\\")\\n exit(1)\\n ENDPOINT = sys.argv[1]\\n uuid_list = pmc.plugin_list(ENDPOINT)\\n print(uuid_list)\\n for uuid in uuid_list:\\n info = pmc.plugin_info(uuid, ENDPOINT)\\n print(info)\\n if info.get(\\\"name\\\") == \\\"son-plugin.TestPlugin\\\":\\n # found an old test plugin record, remove it!\\n print(\\\"REMOVE: %r\\\" % uuid)\\n pmc.plugin_remove(uuid, ENDPOINT)\",\n \"def main(text):\\n _register_plugins()\\n\\n arguments, command_arguments = parse_arguments(text)\\n\\n if arguments.verbose:\\n _LOGGER.setLevel(logging.DEBUG)\\n\\n arguments.execute(arguments, command_arguments)\",\n \"def plugin_import(plugin):\\n\\n return importlib.import_module(plugin, package=\\\"directord\\\")\",\n \"def auto_import_commands():\\n import re,os\\n import topo\\n import __main__\\n\\n # CEBALERT: this kind of thing (topo.__file__) won't work with\\n # py2exe and similar tools\\n topo_path = os.path.join(os.path.split(topo.__file__)[0],\\\"command\\\")\\n for f in os.listdir(topo_path):\\n if re.match('^[^_.].*\\\\.py$',f):\\n modulename = re.sub('\\\\.py$','',f)\\n exec \\\"from topo.command.\\\"+modulename+\\\" import *\\\" in __main__.__dict__\\n exec \\\"from topo.command import *\\\" in __main__.__dict__\",\n \"def test_setup_package(self):\\n pluggable_package.setup(self._test_package)\\n self._test_setup(self._test_package)\",\n \"def cli(ctx):\\n if not ctx.invoked_subcommand:\\n auto()\",\n \"def test_override_plugin(self):\\n plugin_name = 'Stdout'\\n source = os.path.join(self.current_dir, 'classes', plugin_name)\\n target = os.path.join(expanduser('~'), '.drupdates', 'plugins', plugin_name)\\n shutil.copytree(source, target)\\n plugins = Plugin.get_plugins()\\n assert plugins[plugin_name]['info'][1] == os.path.join(target, '__init__.py')\",\n \"def run_plugin(self, plugin_name: str):\\n if plugin_name not in self.name_to_plugin_class:\\n logger.error(\\\"Plugin %s DNE\\\", plugin_name)\\n return\\n\\n if not self.name_to_enabled[plugin_name]:\\n logger.error(\\\"Can not run disabled plugin\\\")\\n\\n def _run_plugin(plugin_class, plugin_config: typing.Dict, exit_event: multiprocessing.Event):\\n \\\"\\\"\\\"Inner function that acts as target to multiprocess constructor\\\"\\\"\\\"\\n plugin_instance = plugin_class(plugin_config, exit_event)\\n plugin_instance.run_plugin()\\n\\n plugin_class = self.name_to_plugin_class[plugin_name]\\n exit_event = multiprocessing.Event()\\n process = multiprocessing.Process(target=_run_plugin, args=(plugin_class, self.config, exit_event))\\n process.start()\\n self.name_to_process[plugin_name] = process\\n self.name_to_exit_event[plugin_name] = exit_event\",\n \"def test_plugin_with_no_plugin_class(conf):\\n # For fun, we pass in a system library\\n installed_apps_before = conf.config[\\\"INSTALLED_APPS\\\"][:]\\n cli.plugin(\\\"os.path\\\")\\n assert installed_apps_before == conf.config[\\\"INSTALLED_APPS\\\"]\",\n \"def load_commands(name, settings, action='deploy'):\\n def install_packages():\\n # only working for apt\\n with hide('stdout'):\\n # Need a new line after sources.list, which sometimes doesn't end\\n # with one, easiest option: awk.\\n apt_txt = run('find /etc/apt/sources.list{,.d} -type f '\\n '-exec awk \\\\'FNR==1{print \\\"\\\"}1\\\\' {} \\\\;')\\n\\n force_update = False\\n for package in packages:\\n if package.needs_additional_repo(apt_txt):\\n package.install_additional_repo()\\n force_update = True\\n\\n package_manager.run_update(force_update)\\n\\n for package in packages:\\n package.install()\\n\\n module = __import__('depl.deploy.' + name, globals(), locals(), [name], -1)\\n commands = getattr(module, action)(settings)\\n packages = set([p for p in commands if isinstance(p, Package)])\\n commands = tuple([p for p in commands if not isinstance(p, Package)])\\n\\n return (install_packages,) + commands\",\n \"def prepare_plugin(self, plugin_path):\\n # This method does not exist in MOS 7.0\\n if not hasattr(self.env.admin_actions, 'upload_plugin'):\\n mos7_upload_plugin(plugin=plugin_path, source=self.env.d_env)\\n mos7_install_plugin(\\n plugin_file_name=os.path.basename(plugin_path),\\n source=self.env.d_env)\\n else:\\n self.env.admin_actions.upload_plugin(plugin=plugin_path)\\n self.env.admin_actions.install_plugin(\\n plugin_file_name=os.path.basename(plugin_path))\",\n \"def run_plugin(self, plugin_name, *args, nb_path=None, **kwargs):\\n nb_path = self._resolve_nb_path(nb_path)\\n if plugin_name in self._plugin_collections:\\n pc = self._plugin_collections[plugin_name]\\n else:\\n pc = PluginCollection([plugin_name], nb_path, {})\\n self._plugin_collections[plugin_name] = pc\\n pc.run(\\\"from_notebook\\\", *args, **kwargs)\",\n \"def loadPlugin(filename):\\n\\n name = op.splitext(op.basename(filename))[0]\\n modname = 'fsleyes_plugin_{}'.format(name)\\n distname = 'fsleyes-plugin-{}'.format(name)\\n\\n if distname in listPlugins():\\n log.debug('Plugin %s is already in environment - skipping', distname)\\n return\\n\\n log.debug('Loading plugin %s [dist name %s]', filename, distname)\\n\\n dist = pkg_resources.Distribution(\\n project_name=distname,\\n location=op.dirname(filename),\\n version='0.0.0')\\n\\n entryPoints = _findEntryPoints(filename, modname)\\n\\n # Here I'm relying on the fact that\\n # Distribution.get_entry_map returns\\n # the actual dict that it uses to\\n # store entry points.\\n entryMap = dist.get_entry_map()\\n\\n for group, entries in entryPoints.items():\\n entryMap[group] = {}\\n\\n for name, item in entries.items():\\n ep = '{} = {}:{}'.format(name, modname, name)\\n ep = pkg_resources.EntryPoint.parse(ep, dist=dist)\\n entryMap[group][name] = ep\\n\\n pkg_resources.working_set.add(dist)\",\n \"def _provision_package(self):\",\n \"def PluginInstall(self, pluginName, pluginPath):\\n pass\",\n \"def test(self, plugin):\\n plug = plugin_source.load_plugin(plugin)\\n plug.test()\",\n \"def test_specific_plugin_installed(self):\\n self._add_plugin(self.jigconfig, 'plugin01')\\n set_jigconfig(self.gitrepodir, config=self.jigconfig)\\n\\n # Create staged\\n self.commit(self.gitrepodir, 'a.txt', 'a')\\n self.stage(self.gitrepodir, 'b.txt', 'b')\\n\\n with nested(\\n patch('jig.runner.sys'),\\n self.assertRaises(SystemExit)\\n ) as (r_sys, ec):\\n # Raise the error to halt execution like the real sys.exit would\\n r_sys.exit.side_effect = SystemExit\\n\\n self.run_command('--plugin plugin01 {0}'.format(self.gitrepodir))\\n\\n self.assertResults(u\\\"\\\"\\\"\\n ▾ plugin01\\n\\n ⚠ line 1: b.txt\\n b is +\\n\\n {0} Jig ran 1 plugin\\n Info 0 Warn 1 Stop 0\\n \\\"\\\"\\\".format(ATTENTION), self.output)\",\n \"def add_commands(subparsers, path):\\n log.debug('importing %s', path)\\n try:\\n del sys.modules[path]\\n except KeyError:\\n pass\\n try:\\n package = importlib.import_module(path)\\n except Exception as e:\\n log.warning('failed to import commands package %s',\\n path, exc_info=True)\\n return\\n log.debug('commands package: %s', path)\\n for (finder, name, ispkg) in pkgutil.iter_modules(package.__path__):\\n if ispkg:\\n continue\\n try:\\n command = importlib.import_module('.' + name, path)\\n except Exception as e:\\n log.warning('failed to import %s command: %s',\\n path, name, exc_info=True)\\n continue\\n if not getattr(command, 'run', None):\\n log.warning('skipping command module without run function: %s',\\n name)\\n continue\\n log.debug('command: %s'%(name))\\n name = command.__name__.split('.')[-1]\\n parser_help = getattr(command, 'parser_help', None)\\n if parser_help is None:\\n log.warning('command %s missing help text'%(command.__name__))\\n parser = subparsers.add_parser(name, help=parser_help)\\n command.add_arguments(parser)\\n parser.set_defaults(run=command.run)\",\n \"def package():\\n pass\",\n \"def load_plugin():\\n return HostTestPluginCopyMethod_Shell()\",\n \"def _resolve_commands(parser):\\n from .plugin import list as list_plugins\\n\\n # create a subparser\\n subparsers = parser.add_subparsers(dest='cmd')\\n\\n default_command = None\\n\\n for command in list_plugins('command'):\\n _log.info('add command ' + command.id)\\n if hasattr(command, 'isDefault') and command.isDefault:\\n default_command = command.id\\n\\n # create a argument parser for the command\\n cmdparser = subparsers.add_parser(command.id)\\n _log.info('loading and initializing the command: ' + command.id)\\n\\n # use the phovea extension point loading mechanism.\\n # pass the parser as argument to the factory method so that the extension point (i.e., command)\\n # can add further arguments to the parser (e.g., the address or port of the server).\\n # the factory must return a launcher function, which gets the previously defined parser arguments as parameter.\\n instance = command.load().factory(cmdparser)\\n\\n # register the instance as argument `launcher` and the command as `launcherid` to the command parser\\n _log.info('add command instance to parser')\\n cmdparser.set_defaults(launcher=instance, launcherid=command.id)\\n\\n return default_command\",\n \"def handle_loadall(bot, ievent):\\n plugs.loadall(plugin_packages, force=True)\\n ievent.done()\",\n \"def core_plugin(self):\\n pass\",\n \"def cli_load_plugin(self, args) -> str:\\n plugin_name = args.plugin_name\\n current_dir = os.path.dirname(os.path.realpath(__file__))\\n if not os.path.isfile(\\\"{}/{}.py\\\".format(current_dir, plugin_name)):\\n return error(\\\"Plugin {} DNE\\\".format(plugin_name))\\n\\n # First, let's see if this is already imported\\n module_name = \\\"plugins.{}\\\".format(plugin_name)\\n if module_name in sys.modules:\\n self.cli_unload_plugin(plugin_name)\\n mod = sys.modules[module_name]\\n importlib.reload(mod)\\n self.register_plugin(get_class(mod, plugin_name))\\n return ok(\\\"Plugin {} reloaded\\\".format(plugin_name))\\n\\n importlib.invalidate_caches()\\n mod = importlib.import_module(module_name)\\n self.register_plugin(get_class(mod, plugin_name))\\n return ok(\\\"Plugin {} loaded\\\".format(plugin_name))\",\n \"def install(ctx, plugins, **kwargs):\\n global logger\\n logger = ctx.logger\\n\\n for plugin in plugins:\\n ctx.logger.info(\\\"Installing plugin {0}\\\".format(plugin['name']))\\n\\n if plugin['name'] == 'default_workflows':\\n # special handling for the default workflows plugin, as it does not\\n # currently sit on the file server and is not under a blueprint\\n # context\\n plugin['url'] = '/opt/manager/cloudify-manager-{}/workflows'\\\\\\n .format(manager_branch)\\n install_celery_plugin(plugin)\\n continue\\n\\n if \\\"folder\\\" in plugin:\\n\\n # convert the folder into a url inside the file server\\n\\n management_ip = get_cosmo_properties()[\\\"management_ip\\\"]\\n if management_ip:\\n plugin[\\\"url\\\"] = \\\\\\n \\\"http://{0}:53229/blueprints/{1}/plugins/{2}.zip\\\"\\\\\\n .format(management_ip, ctx.blueprint_id, plugin['folder'])\\n\\n ctx.logger.info(\\\"Installing plugin from URL --> {0}\\\"\\n .format(plugin['url']))\\n install_celery_plugin(plugin)\",\n \"def test_remote_plugin(self):\\n plugin_name = 'Slack'\\n Plugin.download_plugin(plugin_name)\\n target = os.path.join(expanduser('~'), '.drupdates', 'plugins', plugin_name)\\n plugins = Plugin.get_plugins()\\n assert plugins[plugin_name]['info'][1] == os.path.join(target, '__init__.py')\",\n \"def run(plugin_name: str, namespace: str = \\\"\\\"):\\n namespace = namespace if namespace else gget(\\\"namespace\\\")\\n plugin_name = str(plugin_name)\\n pf = gget(f\\\"{namespace}.pf\\\")\\n gpf = gget(f\\\"general.pf\\\")\\n if (plugin_name in gpf):\\n pf = gpf\\n namespace = \\\"general\\\"\\n if(pf.load(plugin_name)):\\n print(f'\\\\n{color.green(f\\\"Reload {namespace}.{plugin_name} success\\\")}\\\\n')\\n else:\\n print(f'\\\\n{color.red(pf.get_message(plugin_name))}\\\\n')\",\n \"def main():\\n parser = ap.ArgumentParser()\\n parser.add_argument(\\n 'plugins_file',\\n type=ap.FileType(),\\n help='file holding paths to plugins on GitHub'\\n )\\n args = parser.parse_args()\\n contents = args.plugins_file.read()\\n raw_path_list = contents.split('\\\\n')\\n path_list = (pl.Path(raw_path) for raw_path in raw_path_list)\\n customizer = VimCustomizer(path_list)\\n customizer.configure()\",\n \"def test_custom_plugin(self):\\n plugin_name = 'Druptest'\\n source = os.path.join(self.current_dir, 'classes', plugin_name)\\n target = os.path.join(expanduser('~'), '.drupdates', 'plugins', plugin_name)\\n shutil.copytree(source, target)\\n plugins = Plugin.get_plugins()\\n assert plugins[plugin_name]['name'] == plugin_name\",\n \"def request_plugins(self):\",\n \"def run_all_plugins(self):\\n logger.info(\\\"Starting all plugins\\\")\\n for name in self.name_to_plugin_class:\\n if self.name_to_enabled[name]:\\n self.run_plugin(name)\",\n \"def verun(cmd):\\n run('pew in {0} {1}'.format(package_name(), cmd))\",\n \"def get_plugin(self, name):\",\n \"def register_target_commands():\\n for plugin_cls in env.plugins.values():\\n # Add target group to root commands. E.g. create `nursery vbox`\\n cli.add_command(plugin_cls.cli_entry_func, plugin_cls.cli_entry_func.name)\\n\\n for cmd in TargetPlugin.root_actions:\\n if cmd in plugin_cls.root_command_map:\\n # Find the corresponding group in this module to add the target's\\n # command group to. E.g. Find `nursery up` and add `vbox` to it.\\n globals()[f\\\"{cmd}_cmd\\\"].add_command(\\n plugin_cls.root_command_map[cmd], plugin_cls.cli_entry_func.name\\n )\",\n \"def _install(package_name, package_version, options_path, app_id, cli, app,\\n yes):\\n\\n if cli is False and app is False:\\n # Install both if neither flag is specified\\n cli = app = True\\n\\n # Expand ~ in the options file path\\n if options_path:\\n options_path = os.path.expanduser(options_path)\\n user_options = _user_options(options_path)\\n\\n package_manager = _get_package_manager()\\n pkg = package_manager.get_package_version(package_name, package_version)\\n\\n pkg_json = pkg.package_json()\\n pre_install_notes = pkg_json.get('preInstallNotes')\\n if app and pre_install_notes:\\n emitter.publish(pre_install_notes)\\n if not _confirm('Continue installing?', yes):\\n emitter.publish('Exiting installation.')\\n return 0\\n\\n if app and pkg.has_mustache_definition():\\n\\n # render options before start installation\\n options = pkg.options(user_options)\\n\\n # Install in Marathon\\n msg = 'Installing Marathon app for package [{}] version [{}]'.format(\\n pkg.name(), pkg.version())\\n if app_id is not None:\\n msg += ' with app id [{}]'.format(app_id)\\n\\n emitter.publish(msg)\\n\\n package_manager.install_app(\\n pkg,\\n options,\\n app_id)\\n\\n if cli and pkg.has_cli_definition():\\n # Install subcommand\\n msg = 'Installing CLI subcommand for package [{}] version [{}]'.format(\\n pkg.name(), pkg.version())\\n emitter.publish(msg)\\n\\n subcommand.install(pkg)\\n\\n subcommand_paths = subcommand.get_package_commands(package_name)\\n new_commands = [os.path.basename(p).replace('-', ' ', 1)\\n for p in subcommand_paths]\\n\\n if new_commands:\\n commands = ', '.join(new_commands)\\n plural = \\\"s\\\" if len(new_commands) > 1 else \\\"\\\"\\n emitter.publish(\\\"New command{} available: {}\\\".format(plural,\\n commands))\\n\\n post_install_notes = pkg_json.get('postInstallNotes')\\n if app and post_install_notes:\\n emitter.publish(post_install_notes)\\n\\n return 0\",\n \"def cli():\\n pass # do nothing here, it just defines the name for other subcommands\",\n \"def use_plugin(image_path, plugin_name):\\n\\n import_str = 'from processor.{} import SewingMachine'.format(plugin_name)\\n exec(import_str, globals())\\n conf = get_conf('processor/{}.toml'.format(plugin_name))\\n machine = SewingMachine(image_path, conf)\\n return machine.process()\",\n \"def package():\\n call([sys.executable, \\\"setup.py\\\", \\\"clean\\\", \\\"--all\\\", \\\"bdist_egg\\\"], cwd=\\\"src\\\")\\n call([sys.executable, \\\"setup.py\\\", \\\"clean\\\", \\\"--all\\\", \\\"bdist_wheel\\\"], cwd=\\\"src\\\")\",\n \"def _import_plugins(self) -> None:\\n logger.debug('Importing plugins')\\n self._pm = pluggy.PluginManager('sirbot')\\n self._pm.add_hookspecs(hookspecs)\\n\\n for plugin in self.config['sirbot']['plugins']:\\n try:\\n p = importlib.import_module(plugin)\\n except (ModuleNotFoundError, ):\\n if os.getcwd() not in sys.path:\\n sys.path.append(os.getcwd())\\n p = importlib.import_module(plugin)\\n else:\\n raise\\n self._pm.register(p)\",\n \"def dataComponent_pluginRun(self, **kwargs):\\n str_outputPath = '/plugin'\\n str_inputPath = '/dataView/files'\\n\\n str_plugin = 'mri_convert'\\n for key,val in kwargs.iteritems():\\n if key == 'plugin': str_plugin = val\\n if key == 'inputPath': str_inputPath = val\\n if key == 'outputPath': str_outputPath = val\\n\\n s = self.contents\\n\\n s.cd('/plugins/run')\\n rand_date = self.fake.date_time_this_decade()\\n str_timestamp = rand_date.isoformat()\\n s.mkcd('%s-mri_convert' % str_timestamp)\\n\\n output = data()\\n output.contents_build_1(SeriesFilesCount = 10)\\n o = output.contents\\n s.graft(o, '/dataView')\\n s.graft(o, '/plugins')\\n\\n # o.tree_metaData_print(False)\\n # print(o)\\n\\n #\\n # if s.cd(str_outputPath)['status']:\\n # rand_date = self.fake.date_time_this_decade()\\n # str_timestamp = rand_date.isoformat()\\n # l_run = s.lstr_lsnode()\\n # str_newRun = str(len(l_run))\\n # s.mkcd(str_newRun)\\n # s.touch('timestamp', str_timestamp)\\n # s.mknode(['parameters', 'results', 'info'])\\n # s.touch('info/detail', {\\n # str_plugin: data._dict_plugin[str_plugin]\\n # })\\n # s.touch('parameters/input', {\\n # str_plugin: '<some dictionary of all input parameters>'\\n # })\\n # s.cd('results')\\n # str_outputPath = s.cwd()\\n # if str_plugin.lower() != 'pacspull' and str_plugin.lower() != 'mri_convert':\\n # self.dataComponent_build(\\n # path = s.cwd(),\\n # plugin = str_plugin\\n # )\\n # if str_plugin.lower() == 'mri_convert':\\n # inputTree = C_snode.C_stree()\\n # inputTree.cd('/')\\n # inputTree.graft(s, str_inputPath)\\n #\\n # self.dataComponent_build(\\n # path = str_outputPath,\\n # plugin = str_plugin,\\n # tree_convertFrom = inputTree,\\n # type_convertTo = \\\"nii\\\"\\n # )\",\n \"def run_plugin():\\n config = load_config()\\n all_resources = []\\n\\n try:\\n for resource in config.resources:\\n all_resources = all_resources + get_resource(resource['url'], resource.get('sha256'), resource.get('patches'))\\n except yaml.YAMLError as e:\\n c.eprint(\\\"%s: invalid yaml\\\" % url)\\n if hasattr(e, 'problem_mark'):\\n c.eprint(e.problem_mark)\\n c.eprint(e.problem)\\n if e.context is not None:\\n c.eprint(e.context)\\n raise e\\n except HTTPError as e:\\n c.eprint(\\\"%s: %s %s\\\" % (url, e.code, e.reason))\\n raise e\\n except URLError as e:\\n c.eprint(\\\"%s: %s\\\" % (url, e.reason))\\n raise e\\n yaml.dump_all(all_resources, sys.stdout, default_flow_style=False)\",\n \"def develop():\\n# Install package in development mode\\n sh('python setup.py develop')\",\n \"def _install_cli(self, package_name):\\n self.logger.info('Installing CLI')\\n self._execute_command('rpm -i {0}'.format(package_name), sudo=True)\",\n \"def do_install(self, args):\\n if args:\\n try:\\n plugin_name, file_path = args.split()[0], args.split()[1]\\n except Exception as e:\\n return print(display_messages(\\\"the argument is invalid please type ?install for more information\\\", error=True))\\n if not path.isfile(file_path):\\n return print(\\n display_messages(\\n \\\"the file {} not found \\\".format(file_path), error=True\\n )\\n )\\n head, tail = os.path.split(file_path)\\n dest = copyfile(file_path, \\\"{}/{}\\\".format(self.temp_path, tail))\\n print(display_messages(\\\"copy content file .zip to {}\\\".format(dest), info=True))\\n \\n path_to_zip_file = tempfile.gettempdir() + \\\"/{}\\\".format(tail)\\n with ZipFile(path_to_zip_file, \\\"r\\\") as zip_ref:\\n zip_ref.extractall(tempfile.gettempdir())\\n temp_path_file_extracted = \\\"{}/{}.py\\\".format(self.temp_path, plugin_name)\\n print(\\n display_messages(\\n \\\"extracted files on : {}\\\".format(temp_path_file_extracted), info=True\\n )\\n )\\n if not path.isfile(temp_path_file_extracted):\\n return print(\\n display_messages(\\n \\\"the file {} not found \\\".format(temp_path_file_extracted), error=True\\n )\\n )\\n temp_templates_path = \\\"{}/{}\\\".format(self.temp_path, plugin_name)\\n if not path.isdir(temp_templates_path):\\n return print(\\n display_messages(\\n \\\"the directory template {} not found \\\".format(temp_templates_path), error=True\\n )\\n )\\n source = temp_path_file_extracted\\n destination = \\\"{}/{}.py\\\".format(self.captiveflask_setup_path, plugin_name)\\n dest = copyfile(source, destination)\\n print(display_messages(\\\"copy content file to {}\\\".format(dest), info=True))\\n\\n copy_tree(\\n temp_templates_path, C.user_config_dir + \\\"/config/templates/{}\\\".format(plugin_name)\\n )\\n print(\\n display_messages(\\n \\\"plugin {} install {}\\\".format( plugin_name,setcolor(\\\"sucessful\\\", color=\\\"green\\\")),\\n info=True,\\n )\\n )\\n return \\n print(\\n display_messages(\\\"unknown command: {} \\\".format(args), error=True)\\n )\",\n \"def installPlugin(filename):\\n\\n basename = op.splitext(op.basename(filename))[0]\\n dest = 'plugins/{}.py'.format(basename)\\n\\n log.debug('Installing plugin %s', filename)\\n\\n with open(filename, 'rt') as inf, \\\\\\n fslsettings.writeFile(dest) as outf:\\n outf.write(inf.read())\\n\\n dest = fslsettings.filePath(dest)\\n\\n try:\\n loadPlugin(dest)\\n except Exception:\\n fslsettings.deleteFile(dest)\\n raise\",\n \"def uninstall_celery_plugin(plugin_name):\\n\\n # this will uninstall the plugin\\n command = \\\"{0} uninstall -y {1}\\\".format(get_pip(), plugin_name)\\n run_command(command)\\n logger.debug(\\\"uninstalled plugin {0} from \\\"\\n \\\"python installation {1}\\\"\\n .format(plugin_name, get_python()))\",\n \"def main():\\n\\n addon_url = sys.argv[0]\\n addon_handle = int(sys.argv[1])\\n addon_args = urlparse.parse_qs(sys.argv[2][1:])\\n\\n # Route request to action.\\n Plugin(addon_url, addon_handle, addon_args).route()\",\n \"def handle_command_line():\\n commands = scan_for_commands()\\n parser = argparse.ArgumentParser(\\n description=\\\"A set of utilities to ease the installation of Modoboa.\\\",\\n epilog=\\\"\\\"\\\"Available commands:\\n%s\\n\\\"\\\"\\\" % \\\"\\\\n\\\".join([\\\"\\\\t%s\\\" % c for c in sorted(commands)]))\\n parser.add_argument(\\\"--verbose\\\", action=\\\"store_true\\\",\\n help=\\\"Activate verbose output\\\")\\n parser.add_argument(\\\"command\\\", type=str,\\n help=\\\"A valid command name\\\")\\n (args, remaining) = parser.parse_known_args()\\n\\n if args.command not in commands:\\n print(\\\"Unknown command '%s'\\\" % args.command, file=sys.stderr)\\n sys.exit(1)\\n\\n commands[args.command](commands, verbose=args.verbose).run(remaining)\",\n \"def do_package(package):\\n\\tn_ucr = extFile(package, 'univention-config-registry')\\n\\tif not os.path.exists(n_ucr):\\n\\t\\treturn\\n\\n\\tf_ucr = open(n_ucr, 'r')\\n\\n\\tfor item in univention.config_registry.parseRfc822(f_ucr.read()):\\n\\t\\ttyp = item['Type'][0]\\n\\t\\tif typ == 'file':\\n\\t\\t\\tf = item['File'][0]\\n\\t\\t\\tdoIt('install', '-d', destDir(f, package))\\n\\t\\t\\tdoIt('cp', '-a', srcPath(f), destPath(f, package))\\n\\t\\t\\tfor key in ('Preinst', 'Postinst'):\\n\\t\\t\\t\\tif key in item:\\n\\t\\t\\t\\t\\tmod = item[key][0]\\n\\t\\t\\t\\t\\tdoIt('install', '-d', destDir(mod, package, 'modules'))\\n\\t\\t\\t\\t\\tdoIt('cp', '-a', srcPath(mod), destPath(mod, package, 'modules'))\\n\\t\\telif typ == 'subfile':\\n\\t\\t\\tf = item['Subfile'][0]\\n\\t\\t\\tdoIt('install', '-d', destDir(f, package))\\n\\t\\t\\tdoIt('cp', '-a', srcPath(f), destPath(f, package))\\n\\t\\telif typ == 'multifile':\\n\\t\\t\\tf = item['Multifile'][0]\\n\\t\\t\\tif os.path.exists(f):\\n\\t\\t\\t\\tdoIt('install', '-d', destDir(f, package))\\n\\t\\t\\t\\tdoIt('cp', '-a', srcPath(f), destPath(f, package))\\n\\t\\t\\tfor key in ('Preinst', 'Postinst'):\\n\\t\\t\\t\\tif key in item:\\n\\t\\t\\t\\t\\tmod = item[key][0]\\n\\t\\t\\t\\t\\tdoIt('install', '-d', destDir(mod, package, 'modules'))\\n\\t\\t\\t\\t\\tdoIt('cp', '-a', srcPath(mod), destPath(mod, package, 'modules'))\\n\\t\\telif typ == 'script':\\n\\t\\t\\tf = item['Script'][0]\\n\\t\\t\\tdoIt('install', '-d', destDir(f, package, 'scripts'))\\n\\t\\t\\tdoIt('cp', '-a', srcPath(f), destPath(f, package, 'scripts'))\\n\\t\\t\\tdoIt('chmod', 'a+x', destPath(f, package, 'scripts'))\\n\\t\\telif typ == 'module':\\n\\t\\t\\tf = item['Module'][0]\\n\\t\\t\\tdoIt('install', '-d', destDir(f, package, 'modules'))\\n\\t\\t\\tdoIt('cp', '-a', srcPath(f), destPath(f, package, 'modules'))\\n\\t\\telse:\\n\\t\\t\\tprint >>sys.stderr, 'Unknown type: %s' % typ\\n\\t\\t\\treturn\\n\\n\\tf_ucr.close()\\n\\n\\tdoIt('install', '-d', destDir('', package, 'info'))\\n\\tdoIt('install', '-m644', n_ucr, destPath(package+'.info', package, 'info'))\\n\\tmapping_file = extFile( package, 'univention-config-registry-mapping')\\n\\tif os.path.exists(mapping_file):\\n\\t\\tdoIt('install', '-d', destDir('', package, 'mapping'))\\n\\t\\tdoIt('install', '-m644', mapping_file, destPath(package+'.univention-config-registry-mapping', package, 'mapping'))\\n\\n\\tdata = {\\n\\t\\t\\t'pkg': quote(package),\\n\\t\\t\\t'info': quote(\\\"/etc/univention/templates/info/%s.info\\\" % package),\\n\\t\\t\\t'removed': quote(\\\"/etc/univention/templates/removed/%s.info\\\" % package),\\n\\t\\t\\t}\\n\\n\\tf_preinst = open(extFile(package, 'preinst.debhelper'), 'a')\\n\\tf_preinst.write('# Automatically added by univention-install-config-registry\\\\n')\\n\\tf_preinst.write('if [ \\\"$1\\\" = \\\"install\\\" ] ; then\\\\n')\\n\\tf_preinst.write(' [ -e %(removed)s ] && [ ! -e %(info)s ] && mv %(removed)s %(info)s || true\\\\n' % data)\\n\\tf_preinst.write('fi\\\\n')\\n\\tf_preinst.write('# End automatically added section\\\\n')\\n\\tf_preinst.close()\\n\\n\\tf_postinst = open(extFile(package, 'postinst.debhelper'), 'a')\\n\\tf_postinst.write('# Automatically added by univention-install-config-registry\\\\n')\\n\\tf_postinst.write('if [ \\\"$1\\\" = \\\"abort-remove\\\" ]; then\\\\n')\\n\\tf_postinst.write(' [ -e %(removed)s ] && mv %(removed)s %(info)s || true\\\\n' % data)\\n\\tf_postinst.write('fi\\\\n')\\n\\tf_postinst.write('[ -x /usr/sbin/univention-config-registry ] && univention-config-registry register %(pkg)s || true\\\\n' % data)\\n\\tf_postinst.write('# End automatically added section\\\\n')\\n\\tf_postinst.close()\\n\\n\\tf_prerm = open(extFile(package, 'prerm.debhelper'), 'a')\\n\\tf_prerm.write('# Automatically added by univention-install-config-registry\\\\n')\\n\\tf_prerm.write('if [ \\\"$1\\\" = \\\"remove\\\" ] && [ -e %(info)s ] ; then\\\\n' % data)\\n\\tf_prerm.write(' [ -x /usr/sbin/univention-config-registry ] && univention-config-registry unregister %(pkg)s || true\\\\n' % data)\\n\\tf_prerm.write(' mv %(info)s %(removed)s || true\\\\n' % data)\\n\\tf_prerm.write('fi\\\\n')\\n\\tf_prerm.write('# End automatically added section\\\\n')\\n\\tf_prerm.close()\\n\\n\\tdoIt('perl', '-e', 'use Debian::Debhelper::Dh_Lib;addsubstvar(\\\"%s\\\", \\\"misc:Depends\\\", \\\"univention-config (>= 7.0.25)\\\");' % package)\",\n \"def package_cmd(self):\\n return 'zypper'\",\n \"def on_package_parse(self, ctx):\\n return None\",\n \"def new_plugin(ctx, **defaults):\\n from .quickstart import plugin_quickstart\\n\\n project = ctx.get_project(silent=True)\\n plugin_quickstart(defaults, project=project)\",\n \"def main():\\n\\n # Load all the commands\\n commands = {}\\n for entry_point in pkg_resources.iter_entry_points('nagare.commands'):\\n try:\\n commands[entry_point.name] = entry_point.load()\\n except ImportError:\\n print \\\"Warning: the command '%s' can't be imported\\\" % entry_point.name\\n raise\\n\\n parser = optparse.OptionParser(usage='\\\\n'.join(usage(commands)))\\n\\n if (len(sys.argv) == 1) or (sys.argv[1] == '-h') or (sys.argv[1] == '--help'):\\n parser.print_usage(sys.stderr)\\n parser.exit()\\n\\n command_name = sys.argv[1]\\n command = commands.get(command_name)\\n if command is None:\\n parser.error(\\\"command '%s' not found\\\" % command_name)\\n\\n parser.usage = '%%prog %s [options]' % command_name\\n\\n argv = command.set_options(parser) # Let the command register its command line options\\n (options, args) = parser.parse_args((argv if argv is not None else sys.argv)[2:]) # Parse the command line\\n\\n command.run(parser, options, args) # Run the command\",\n \"def execute(self):\\n # Preprocess options to extract --settings and --pythonpath.\\n # These options could affect the commands that are available, so they\\n # must be processed early.\\n parser = LaxOptionParser(usage=\\\"%prog subcommand [options] [args]\\\",\\n version=magpy.get_version(),\\n option_list=BaseCommand.option_list)\\n self.autocomplete()\\n try:\\n options, args = parser.parse_args(self.argv)\\n handle_default_options(options)\\n except:\\n # Ignore any option errors at this point.\\n pass # pylint: disable-msg=W0702\\n\\n try:\\n subcommand = self.argv[1]\\n except IndexError:\\n subcommand = 'help' # Display help if no arguments were given.\\n\\n if subcommand == 'help':\\n if len(args) <= 2:\\n parser.print_lax_help()\\n sys.stdout.write(self.main_help_text() + '\\\\n')\\n elif args[2] == '--commands':\\n sys.stdout.write(\\n self.main_help_text(commands_only=True) + '\\\\n')\\n else:\\n self.fetch_command(args[2]).print_help(self.prog_name, args[2])\\n elif subcommand == 'version':\\n sys.stdout.write(parser.get_version() + '\\\\n')\\n # Special-cases: We want 'django-admin.py --version' and\\n # 'django-admin.py --help' to work, for backwards compatibility.\\n elif self.argv[1:] == ['--version']:\\n # LaxOptionParser already takes care of printing the version.\\n pass\\n elif self.argv[1:] in (['--help'], ['-h']):\\n parser.print_lax_help()\\n sys.stdout.write(self.main_help_text() + '\\\\n')\\n else:\\n self.fetch_command(subcommand).run_from_argv(self.argv)\",\n \"def load_plugins(self) -> None:\\n import importlib\\n import pkgutil\\n import stactools\\n\\n # From https://packaging.python.org/guides/creating-and-discovering-plugins/#using-namespace-packages # noqa\\n def iter_namespace(ns_pkg: ModuleType) -> Iterator[ModuleInfo]:\\n # Specifying the second argument (prefix) to iter_modules makes the\\n # returned name an absolute name instead of a relative one. This allows\\n # import_module to work without having to do additional modification to\\n # the name.\\n return pkgutil.iter_modules(\\n ns_pkg.__path__, # type: ignore # mypy issue #1422\\n ns_pkg.__name__ + '.')\\n\\n discovered_plugins = {\\n name: importlib.import_module(name)\\n for finder, name, ispkg in iter_namespace(stactools)\\n }\\n\\n for name, module in discovered_plugins.items():\\n register_plugin = getattr(module, 'register_plugin', None)\\n if register_plugin:\\n register_plugin(self)\",\n \"def do_command(self, args):\\n pass\",\n \"def _get_commands(package_name):\\n # pylint: disable=line-too-long\\n def lookup(cmd, dct):\\n if not cmd:\\n return dct\\n if len(cmd) == 1:\\n return dct[cmd[0]]\\n return lookup(cmd[1:], dct[cmd[0]])\\n\\n def walking_import(module, cmd, dct):\\n car, cdr = cmd[0], cmd[1:]\\n if cdr:\\n walking_import(module, cdr, dct[car])\\n elif car not in dct:\\n __import__(module)\\n dct.setdefault(car, {})['__module__'] = sys.modules[module]\\n\\n __import__(COMMANDS_PACKAGE_NAME)\\n command_module = sys.modules[COMMANDS_PACKAGE_NAME]\\n for _, module, _ in pkgutil.walk_packages(command_module.__path__, prefix=command_module.__name__+'.'):\\n if not (module.endswith('__main__') or '.tests' in module):\\n try:\\n lookup(_command_as_list(module), _COMMANDS)\\n except KeyError:\\n walking_import(module, _command_as_list(module), _COMMANDS)\\n return lookup(_command_as_list(package_name), _COMMANDS)\",\n \"def _install(self):\\n # Default implementation\\n for pm_name, package in self._provider_package.items():\\n if helpers[pm_name]:\\n helpers[pm_name].install_package(package)\\n return\\n raise self.unsure_how_to_install()\",\n \"def _add_arguments(parser):\\n parser.add_argument(\\n \\\"command\\\",\\n help='The plugin to run. e.g. \\\"shell\\\".',\\n choices=sorted(registry.get_command_keys()),\\n )\\n\\n parser.add_argument(\\n \\\"-x\\\",\\n \\\"--maximum-repositories\\\",\\n default=sys.maxsize,\\n type=int,\\n help='If a value of `2` is used, it means \\\"Only search 2 repositories '\\n 'for Rez packages to run on, at most\\\".',\\n )\\n\\n parser.add_argument(\\n \\\"-z\\\",\\n \\\"--maximum-rez-packages\\\",\\n default=sys.maxsize,\\n type=int,\\n help='If a value of `2` is used, it means \\\"Only search for 2 Rez packages '\\n 'to run some comm on, at most\\\".',\\n )\\n\\n parser.add_argument(\\n \\\"-p\\\",\\n \\\"--packages-path\\\",\\n default=[config.release_packages_path], # pylint: disable=no-member\\n help=\\\"A `{os.pathsep}` separated list of paths that report/run will be run on. \\\"\\n \\\"If not defined, `rez.config.config.release_packages_path` is used, instead.\\\".format(\\n os=os\\n ),\\n )\\n\\n parser.add_argument(\\n \\\"-s\\\",\\n \\\"--search-packages-path\\\",\\n default=[config.release_packages_path], # pylint: disable=no-member\\n help=\\\"A `{os.pathsep}` separated list of paths to search for Rez package dependencies. \\\"\\n \\\"If not defined, `rez.config.config.release_packages_path` is used, instead.\\\".format(\\n os=os\\n ),\\n )\\n\\n parser.add_argument(\\n \\\"-i\\\",\\n \\\"--ignore-patterns\\\",\\n default=[],\\n nargs=\\\"*\\\",\\n help=\\\"A set of glob expressions or a file to a set of glob expressions. \\\"\\n \\\"If a Rez package name matches one of \\\"\\n \\\"these, it will not be run on.\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-k\\\",\\n \\\"--keep-temporary-files\\\",\\n action=\\\"store_true\\\",\\n help=\\\"If added, do not delete any temporary files that are generated during this run.\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-r\\\",\\n \\\"--rez-packages\\\",\\n default=set(),\\n nargs=\\\"+\\\",\\n help=\\\"The names of Rez packages to process. If no names are given, \\\"\\n \\\"every Rez package that is found will be processed.\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-t\\\",\\n \\\"--temporary-directory\\\",\\n help=\\\"A folder on-disk that will be used to clone git repositories.\\\",\\n )\",\n \"def do(self):\\r\\n parameters = ParametersParserStr(self.args_parameters).get()\\r\\n self.core.install(self.product_names, parameters, with_dependencies=True)\",\n \"def test_setup_module(self):\\n pluggable_package.setup(self._test_module)\\n self._test_setup(self._test_module)\",\n \"def test_install_terraform_plugin_1(monkeypatch):\\n monkeypatch.setattr(os, 'listdir', lambda path: [\\n 'terraform-provider-terraform_v0.11.2_x4'])\\n monkeypatch.setattr(os, 'remove', lambda path: True)\\n monkeypatch.setattr(os, 'chmod', lambda path, permissions: True)\\n\\n monkeypatch.setattr(shutil, 'copy2', lambda src, dest: True)\\n\\n def mp_check_output(cmd):\\n if cmd == ['which', 'terraform']:\\n return b'/usr/local/bin/terraform\\\\n'\\n\\n if cmd == ['terraform', '-v']:\\n return b'Terraform v0.11.3\\\\n\\\\n'\\n\\n raise Exception('Unmocked command: %s' % cmd)\\n\\n monkeypatch.setattr(subprocess, 'check_output', mp_check_output)\\n\\n install_terraform_plugin('/tmp/stone-burner_plugins')\",\n \"def getCommands():\\n return getPlugins(ICommand, plugins)\",\n \"def execute_tool(description, *args):\\n command_line = list(args) + files_and_directories\\n click.echo(f\\\"{description}: {' '.join(command_line)}\\\")\\n rv = call(command_line)\\n if rv != 0:\\n exit(rv)\",\n \"def main(ctx, debug, config, index, python, delivery, packager):\\n global PACKAGER\\n PACKAGER = PexPackager if packager == \\\"pex\\\" else VenvPackager\\n\\n runez.system.AbortException = SystemExit\\n if ctx.invoked_subcommand != \\\"package\\\":\\n cli = TrackedSettings(delivery, index, python)\\n base = find_base()\\n CFG.set_base(base, config_path=config, cli=cli)\\n\\n runez.log.setup(\\n debug=debug,\\n console_format=\\\"%(levelname)s %(message)s\\\" if debug else \\\"%(message)s\\\",\\n console_level=logging.WARNING,\\n console_stream=sys.stderr,\\n locations=None,\\n )\",\n \"def setup(self):\\n\\n if self.has_setup():\\n self.logger.info(\\\"%s has a pre-flight setup routine. Running now.\\\" % self.plugin_dict_name)\\n self._module.setup(self, self.versions)\",\n \"def execute(self):\\n\\n options, args = self.parser.parse_args(self.argv)\\n\\n try:\\n subcommand_name = self.argv[1]\\n except IndexError:\\n subcommand_name = 'help'\\n\\n if subcommand_name == 'help':\\n if len(args) <= 2:\\n self.print_help()\\n else:\\n self.fetch_subcommand(self.argv[2]).print_help()\\n elif subcommand_name == 'version':\\n self.print_version()\\n else:\\n self.fetch_subcommand(subcommand_name).execute()\",\n \"def work(self):\\n\\n cmd = self.options.command\\n cmdargs = self.options.args\\n\\n # find function\\n fname = \\\"cmd_\\\" + cmd.replace('-', '_')\\n if not hasattr(self, fname):\\n self.log.error('bad subcommand, see --help for usage')\\n sys.exit(1)\\n fn = getattr(self, fname)\\n\\n b = inspect.signature(fn).bind(*cmdargs)\\n\\n fn(*b.args, **b.kwargs)\",\n \"def resolve(name: str) -> Iterator[Plugin]:\\n sys.path.append(getcwd())\\n module = importlib.import_module(name)\\n\\n yield from load_plugins_from_module(module)\",\n \"def load_plugin(name, plugin_context, globals_=None):\\n \\n # remap friendly names to actual implementation. this is a bit of\\n # abstraction leakage and should instead be dynamically registered\\n # (though much more expensive).\\n\\n #TODO: this is a hack until rosh_testing is a proper framework/plugin\\\"\\n if name == 'rosh.impl.testing':\\n import rosh.impl.testing\\n rosh.impl.testing.load_rosh_plugin('rosh.impl.ros_testing', plugin_context, globals_)\\n return\\n \\n try:\\n # make sure plugin exists for accurate error reporting\\n roslib.packages.get_pkg_dir(name)\\n except roslib.packages.InvalidROSPkgException, e:\\n raise NoPlugin(\\\"invalid plugin [%s]: no ROS package named [%s]\\\"%(name, name))\\n try:\\n roslib.load_manifest(name)\\n except roslib.packages.InvalidROSPkgException, e:\\n raise InvalidPlugin(\\\"Failed to locate dependencies of plugin [%s]: \\\\n[%s]\\\"%(name, str(e)))\\n try:\\n m = __import__(name)\\n except ImportError:\\n raise InvalidPlugin(\\\"invalid plugin [%s]: python module [%s] import failed\\\"%(name, name))\\n try:\\n loader = getattr(m, 'rosh_plugin_load')\\n except AttributeError, e:\\n raise InvalidPlugin(\\\"invalid plugin [%s]: plugin is missing rosh_plugin_load() entry point\\\"%(name))\\n\\n try:\\n plugin_data = loader(plugin_context, globals_)\\n except Exception, e:\\n raise InvalidPlugin(\\\"invalid plugin [%s]: plugin raised Exception on load: %s\\\"%(name, e))\\n errors = []\\n if plugin_data is not None:\\n \\n # Wire up plugins. Although the plugins could do this\\n # themselves, de-coupling provides better protection against\\n # future implementation changes and is also easier to write\\n # tests for.\\n\\n # - We load as much as we can, record the errors, then\\n # re-raise at the end.\\n for plugin_api_id, callback in plugin_data.apis.iteritems():\\n try:\\n plugin_context._register_api(plugin_api_id, callback)\\n except Exception, e:\\n errors.append(e)\\n\\n for plugin_api_id, args in plugin_data.handlers.iteritems():\\n try:\\n plugin_context._register_handler(plugin_api_id, args)\\n except Exception, e:\\n errors.append(e)\\n\\n if errors:\\n error_str = [str(e) for e in errors]\\n raise ROSHException(\\\"errors loading plugin [%s]: \\\\n%s\\\"%(name, '\\\\n'.join(error_str)))\",\n \"def enablePackageInternal(self, *args):\\n return _libsbml.MultiASTPlugin_enablePackageInternal(self, *args)\",\n \"def test_plugin_cannot_be_imported_disable(conf):\\n plugin_name = \\\"giraffe.horse\\\"\\n conf.config[\\\"INSTALLED_APPS\\\"].append(plugin_name)\\n conf.save()\\n cli.plugin(plugin_name, disable=True)\\n assert plugin_name not in conf.config[\\\"INSTALLED_APPS\\\"]\",\n \"def test_discover_and_install_1(monkeypatch):\\n monkeypatch.setattr(subprocess, 'check_call', lambda cmd: True)\\n monkeypatch.setattr(os, 'getcwd', lambda: '/tmp')\\n monkeypatch.setattr(os, 'chdir', lambda path: True)\\n monkeypatch.setattr(os, 'walk', lambda path: [\\n ('root', ['d1', 'd2'], ['f1', 'f2']), ])\\n monkeypatch.setattr(tempfile, 'mkdtemp', lambda: '/tmp/tempdir')\\n monkeypatch.setattr(shutil, 'move', lambda src, dest: True)\\n monkeypatch.setattr(shutil, 'rmtree', lambda path: True)\\n\\n discover_and_install(\\n '/tmp/stone-burner_plugins',\\n 'p1',\\n ['c1', 'c2', 'c3'],\\n SAMPLE_CONFIG,\\n ['c1', 'c2'],\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6978726","0.6254254","0.6242243","0.6231577","0.5971375","0.5952955","0.595294","0.5947213","0.5931876","0.5922034","0.59098864","0.5870987","0.5864653","0.5852075","0.58266354","0.58263","0.5813188","0.57689124","0.5759055","0.57544816","0.573416","0.5714736","0.56839794","0.5683494","0.56699353","0.56430936","0.563702","0.5631636","0.56256074","0.56103337","0.5603777","0.5576757","0.55592126","0.5546407","0.5539519","0.5513661","0.548884","0.5482599","0.54573715","0.5429712","0.54105765","0.5406921","0.5401392","0.5396346","0.53961337","0.5390624","0.5367871","0.534292","0.5337473","0.5325349","0.5312107","0.53025347","0.5298178","0.5288825","0.52862185","0.52851546","0.52721363","0.52577007","0.5254223","0.5245244","0.52259654","0.5215702","0.51981","0.5189865","0.5180521","0.51731706","0.51715064","0.5165511","0.5142933","0.514284","0.51419914","0.5139103","0.5138035","0.5137577","0.5118104","0.51166743","0.51107407","0.51011753","0.5099961","0.5098278","0.5095659","0.50921893","0.5091097","0.5089307","0.50875396","0.5084518","0.50767505","0.50692874","0.5059542","0.5058195","0.5054726","0.50518924","0.50503683","0.5049981","0.5046383","0.5041072","0.5035311","0.503395","0.50298214","0.5025895","0.5025526"],"string":"[\n \"0.6978726\",\n \"0.6254254\",\n \"0.6242243\",\n \"0.6231577\",\n \"0.5971375\",\n \"0.5952955\",\n \"0.595294\",\n \"0.5947213\",\n \"0.5931876\",\n \"0.5922034\",\n \"0.59098864\",\n \"0.5870987\",\n \"0.5864653\",\n \"0.5852075\",\n \"0.58266354\",\n \"0.58263\",\n \"0.5813188\",\n \"0.57689124\",\n \"0.5759055\",\n \"0.57544816\",\n \"0.573416\",\n \"0.5714736\",\n \"0.56839794\",\n \"0.5683494\",\n \"0.56699353\",\n \"0.56430936\",\n \"0.563702\",\n \"0.5631636\",\n \"0.56256074\",\n \"0.56103337\",\n \"0.5603777\",\n \"0.5576757\",\n \"0.55592126\",\n \"0.5546407\",\n \"0.5539519\",\n \"0.5513661\",\n \"0.548884\",\n \"0.5482599\",\n \"0.54573715\",\n \"0.5429712\",\n \"0.54105765\",\n \"0.5406921\",\n \"0.5401392\",\n \"0.5396346\",\n \"0.53961337\",\n \"0.5390624\",\n \"0.5367871\",\n \"0.534292\",\n \"0.5337473\",\n \"0.5325349\",\n \"0.5312107\",\n \"0.53025347\",\n \"0.5298178\",\n \"0.5288825\",\n \"0.52862185\",\n \"0.52851546\",\n \"0.52721363\",\n \"0.52577007\",\n \"0.5254223\",\n \"0.5245244\",\n \"0.52259654\",\n \"0.5215702\",\n \"0.51981\",\n \"0.5189865\",\n \"0.5180521\",\n \"0.51731706\",\n \"0.51715064\",\n \"0.5165511\",\n \"0.5142933\",\n \"0.514284\",\n \"0.51419914\",\n \"0.5139103\",\n \"0.5138035\",\n \"0.5137577\",\n \"0.5118104\",\n \"0.51166743\",\n \"0.51107407\",\n \"0.51011753\",\n \"0.5099961\",\n \"0.5098278\",\n \"0.5095659\",\n \"0.50921893\",\n \"0.5091097\",\n \"0.5089307\",\n \"0.50875396\",\n \"0.5084518\",\n \"0.50767505\",\n \"0.50692874\",\n \"0.5059542\",\n \"0.5058195\",\n \"0.5054726\",\n \"0.50518924\",\n \"0.50503683\",\n \"0.5049981\",\n \"0.5046383\",\n \"0.5041072\",\n \"0.5035311\",\n \"0.503395\",\n \"0.50298214\",\n \"0.5025895\",\n \"0.5025526\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21993,"cells":{"query":{"kind":"string","value":"Write a cache of GitHub users todisk."},"document":{"kind":"string","value":"def __make_git_users(arguments):\n github_user.write_cache(\n arguments.path,\n arguments.token,\n base_url=arguments.base_url,\n verify=arguments.ssl_no_verify,\n maximum=arguments.maximum_users,\n )\n\n print(\n 'GitHub users were written to \"{arguments.path}\" successfully.'\n \"\".format(arguments=arguments)\n )\n\n sys.exit(0)"},"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 saveCacheFile(self):\n with open(self.cachePath, 'w', encoding='utf-8') as outfile:\n json.dump(self.cacheData, outfile)","def save_cache(cache_key, version, data):\n\n # Save these results for the next run. Include the version information and nest the user\n # information inside a \"users\" key from the start, because experience says if we don't do this\n # then the next release will add a feature that requires a change in the data layout, and then\n # we'll have to write a data migration or something.\n\n cache_data = {cache_key: data, \"version\": version}\n\n cache_file(cache_key).write_text(json.dumps(cache_data, indent=2))","def write_cache(feed):\n if ARGV.get(NOCACHE_OPT):\n return\n CACHE['feed'] = feed\n CACHE['last-request'] = str(time.time())\n CACHE['max-age'] = feed.headers['Cache-Control'].split('=')[1]\n save_datfile()","def save_users(users):\n with open(STORAGE_PATH, \"wb\") as fp:\n pickle.dump(users, fp)","def _write_cache_file(self, data):\n\n with open(self.cache_file, mode='wb') as f:\n f.write(data)\n\n self.log.info(f\"Cached facilities at {self.cache_file}\")","def _write_cache(url, j):\n\n m = hashlib.md5()\n m.update(url)\n with open('.cache.%s' % m.hexdigest(), 'wb') as outfile:\n json.dump(j, outfile)","def write_cache(self):\n self.__config.open_file(\n self.__cache_file, \"w\", lambda f: json.dump(self.cache, f)\n )\n self.__dirty = False","def write_to_cache(self, data, filename):\n json_data = self.json_format_dict(data, True)\n cache = open(filename, 'w')\n cache.write(json_data)\n cache.close()","def save_cache(self):\n with open(self.get_cache_filename(), 'wb+') as f:\n out = dict()\n out['timestamp'] = self.get_last_update()\n out['cache'] = self.cache\n f.write(pickle.dumps(out))","def export_cache_file(conn, cache_file):\n with conn:\n c = conn.cursor()\n with open(cache_file, \"w\") as fo:\n c.execute(\"SELECT project FROM projects ORDER BY called DESC, project\")\n rows = c.fetchall()\n [fo.write(x[0] + \"\\n\") for x in rows]","def save_cache(self, data, URL):\n\n cache_file = self.get_cache_file_path(URL)\n\n if cache_file.parent.exists():\n with open(cache_file, 'wb') as f:\n f.write(data)\n else:\n os.mkdir(cache_file.parent)\n with open(cache_file, 'wb') as f:\n f.write(data)","def write_cache(self, write_cache: SmartSsdReadLookahead):\n\n self._write_cache = write_cache","def write_cache(self, filename=None):\n with open(self._cache_filename(filename), \"wb\") as fh:\n pickle.dump(self, fh)","def save(self):\n if self._cache is not None:\n with open(self.cache_path, 'w') as cache_file:\n json.dump(self._cache, cache_file)","def store_cache(base_url, data, path=\"logs/\"):\n\n # Convert URL to filename and write html content into that file\n url_filename = url_to_filename(base_url)\n filename = f\"{path}CACHE-{url_filename}.html\"\n f = open(filename, \"w+\")\n f.write(data)\n f.close()","def _write_cache(self, path, text):\n if self._cache:\n cache_path = os.path.join(self._cache, path)\n\n folder = os.path.split(cache_path)[0]\n\n if not os.path.exists(folder):\n os.makedirs(folder)\n\n with io.open(cache_path, 'w', encoding='utf-8') as f:\n f.write(text)","def _write_buckets_cache_file(metadata, cache_file):\n if os.path.isfile(cache_file):\n os.remove(cache_file)\n\n log.debug(\"Writing buckets cache file\")\n\n with salt.utils.files.fopen(cache_file, \"wb\") as fp_:\n pickle.dump(metadata, fp_)","def save_data(self):\n with open(self.storage_path, 'w') as cache_file:\n json.dump(self.data, cache_file)","def write_cache(cache_dict):\n try:\n with open(CACHE_FILENAME, 'w', encoding=\"utf-8\") as cache_file:\n cache_file.write(json.dumps(cache_dict))\n except:\n print(\"error when executing write_cache()\")","def save_cache(self, cache_dir):\n if not self.is_numeric:\n raise ValueError(\"No need to save if not numeric\")\n if self.is_supervised:\n raise NotImplementedError(\"Caching not yet implemented for supervised views\")\n\n os.makedirs(cache_dir, exist_ok=True)\n # Adjacencies\n adj_path = os.path.join(cache_dir, \"adjlist.txt\")\n nx.readwrite.adjlist.write_adjlist(self.graph, adj_path)\n ndata_path = os.path.join(cache_dir, \"ndata.csv\")\n self.ndata.to_csv(ndata_path, index=True)","def write_to_cache(self):\n data = {'data': self.data, 'inventory': self.inventory}\n json_data = json.dumps(data, indent=2)\n\n with open(self.cache_filename, 'w') as cache:\n cache.write(json_data)","def write_data_cache(self, data):\n assert data, 'Must input a non-empty dictionary.'\n with open(self.cache_filename, 'w') as file_cache:\n json.dump(data, file_cache, sort_keys=True, indent=4, ensure_ascii=False)\n self.data = data # must assign the new data or risk problems","def save_player(user):\n with shelve.open('myfile') as savefile:\n savefile[user.name] = user","def saveGameToCache(self, theKey, theGame):\n if theGame == None:\n return\n theGameFile = File(self.theCacheDirectory, theKey + \".zip\")\n try:\n theGameFile.createNewFile()\n pw.print_(theGame.serializeToJSON())\n pw.flush()\n pw.close()\n gOut.close()\n fOut.close()\n except Exception as e:\n e.printStackTrace()","async def save_to_cache(self, item: T):\n path = self._build_cache_path(\n **{a: getattr(item, a) for a in self._unique_attribues}\n )\n if path.is_file():\n raise ValueError(f\"Trying to overwrite cache at {str(path)}\")\n path.parent.mkdir(parents=True, exist_ok=True)\n async with aiofiles.open(str(path), \"w\") as file:\n await file.write(item.to_json())","def save_output_in_cache(name, filename, output):\n cache_filename = _get_cache_filename(name, filename)\n with _open_for_write(cache_filename) as f:\n f.write(output)","def update_cache():\n total = isic.get_image_count()\n df = pd.DataFrame()\n for meta in tqdm(isic.get_image_meta(), total=total, desc=\"Updating image list cache\", unit=\"img\"):\n _meta = json_normalize(meta)\n # File name and directory will be named after dataset.name.\n # Make it file system friendly. e.g. remove chars like /\n # Todo: This append stuff is painfully slow... Do something about it\n _meta[\"dataset.name\"] = slugify(_meta[\"dataset.name\"][0])\n df = df.append(_meta, ignore_index=True)\n df.to_csv(cache_file, index=False)","def _save_fingerprint(self):\n path = os.path.join(self._cache_path, '%s.fingerprint' % self._name)\n\n if not os.path.exists(self._cache_path):\n os.makedirs(self._cache_path)\n\n with open(path, 'w') as f:\n f.write(self._fingerprint())","def __saveCacheTokens(self):\n self.orgConf[self.cacheSection] = {\n self.ACCESS_TOKEN: self.accessToken,\n self.REFRESH_TOKEN: self.refreshToken\n }\n with open(self.configFile, \"w\") as f:\n self.orgConf.write(f)","def cache_data(name, data):\n cache_path = get_cachefile('%s.cache' % name)\n with open(cache_path, 'wb') as f:\n pickle.dump(data, f)","def save_servers(self):\n\n\t\tfor serv in self.servers:\n\t\t\ta = serv.cache.hash_map\n\t\t\twith open('cache.pickle', 'wb') as handle:\n\t\t\t\tpickle.dump(a, handle, protocol=pickle.HIGHEST_PROTOCOL)","def __write_cache(self, fileName, returnVal):\n # Cache miss\n if self.__log:\n self.__logger.info(f\"Cache miss: {fileName}\")\n self.__handle_cache_size()\n\n with open(fileName, \"wb\") as f:\n packed = pickle.dumps(returnVal)\n final = self.__handle_compression(packed)\n f.write(final)\n\n node = os.path.relpath(fileName, \"cache\")\n self.__recentAccessed.insert(0, node)","def save_users(user_list):\n with open(user_path, \"w\") as outfile:\n json.dump(user_list, outfile)","def sync(self):\n\t\tmanagers.storage.write_object_async(VDOM_CONFIG[\"USER-MANAGER-STORAGE-RECORD\"], self.users)","def storeAllOnDisk(self, path):\n # fetch meta data\n urls = list()\n y_data = self.data_dict.labels\n ids = self.data_dict.unique_ids\n urls = self.data_dict.paths\n\n # save in chunks of 1000 images\n cuts = [x for x in range(0, self.n_observations, 1000)]\n if cuts[-1] < self.n_observations:\n cuts.append(self.n_observations)\n\n # convert batch sizes to integers\n cuts = [int(x) for x in cuts]\n\n for i in range(0, (len(cuts) - 1)):\n\n idx = [x for x in range(cuts[i], cuts[i+1])]\n\n current_ids = [ids[z] for z in idx]\n current_urls = [urls[z] for z in idx]\n current_y = [y_data[z] for z in idx]\n\n # invoke asynchronous read\n binary_images = self.imageLoader.getImages(current_urls)\n\n # store on disk\n img_id = 0\n for c_id, c_y in zip(current_ids, current_y):\n # check directory\n if not os.path.isdir(path + str(c_y)):\n os.mkdir(path + str(c_y))\n # define path\n path_img = path + str(c_y) + \"/\" + \\\n str(c_id) + \".jpeg\"\n img = binary_images[img_id]\n img = img.resize(self.image_size)\n img.save(path_img)\n img_id += 1\n return None","def _store_cache(self):\n assert self._already_generated, \"Must generate before storing to cache\"\n\n if self.variant_unit is not None:\n logger.warning(\"Cannot cache once variant_unit has been set\")\n return\n\n try:\n os.mkdir(os.path.dirname(self._cache_key))\n except FileExistsError:\n # Easier than checking and risking race conditions\n pass\n\n with open(self._cache_key, 'w') as f:\n json.dump(self.rows, f)\n\n logger.debug(\"Stored cache to {}\".format(self._cache_key))","def save_hash_file(self):\n\n cid = time.time()\n '''\n f = open(self.file_hash_name, 'w+')\n f.write(str(cid))\n f.close()\n '''\n\n with open(self.file_hash_name, \"w\") as f:\n logger.debug('CID salvo file {}'.format(cid))\n fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)\n f.write(str(cid))\n fcntl.flock(f, fcntl.LOCK_UN)\n\n self.set_cache_hash(cid)","def save_user_archive_to_file(user):\n filename = str(user).__add__('-tweets.json')\n with open(filename, \"w\") as f:\n archive_generator = rest.fetch_user_archive(user)\n for page in archive_generator:\n for tweet in page:\n f.write(json.dumps(tweet) + \"\\n\")\n logging.warning(u\"Wrote tweets from the user\")","def backup_users_dict(users_dict: dict) -> None:\n with open('users.json', 'w') as usrs:\n json.dump(users_dict, usrs)","def store_cache(value, name, typ=\"pkl\"):\n if not os.path.exists(CACHE_DIR):\n os.mkdir(CACHE_DIR, mode=0o775)\n filename = cache_name(name, typ)\n if typ == \"str\":\n with open(filename, 'w') as fout:\n fout.write(value)\n elif typ == \"pkl\":\n with open(filename, 'wb') as fout:\n pickle.dump(value, fout)\n elif typ == \"h5\":\n value.save(filename)\n else:\n raise ValueError(\"Invalid type '{}'.\".format(typ))","def add_to_cache(filename: str, entry: str) -> None:\n\n with open(filename, \"a\") as f:\n f.write(entry.strip())\n f.write(\"\\n\")","def _save_drafts(self):\n ##logging.info('SAVING: %s -> %s', self.email, self._drafts)\n memcache.set('user_drafts:' + self.email, self._drafts, 3600)","def save(self, path=None):\n if path is None:\n path = self.path\n try:\n with open(path, 'w') as fd:\n for entry in self:\n fd.write('{}\\n'.format(entry))\n except Exception as e:\n raise SSHKeyError('Error writing {}: {}'.format(path, e))","def write_cache(\n entries: Sequence[Union[BaseIndexEntry, \"IndexEntry\"]],\n stream: IO[bytes],\n extension_data: Union[None, bytes] = None,\n ShaStreamCls: Type[IndexFileSHA1Writer] = IndexFileSHA1Writer,\n) -> None:\n # wrap the stream into a compatible writer\n stream_sha = ShaStreamCls(stream)\n\n tell = stream_sha.tell\n write = stream_sha.write\n\n # header\n version = 2\n write(b\"DIRC\")\n write(pack(\">LL\", version, len(entries)))\n\n # body\n for entry in entries:\n beginoffset = tell()\n write(entry.ctime_bytes) # ctime\n write(entry.mtime_bytes) # mtime\n path_str = str(entry.path)\n path: bytes = force_bytes(path_str, encoding=defenc)\n plen = len(path) & CE_NAMEMASK # path length\n assert plen == len(path), \"Path %s too long to fit into index\" % entry.path\n flags = plen | (entry.flags & CE_NAMEMASK_INV) # clear possible previous values\n write(\n pack(\n \">LLLLLL20sH\",\n entry.dev,\n entry.inode,\n entry.mode,\n entry.uid,\n entry.gid,\n entry.size,\n entry.binsha,\n flags,\n )\n )\n write(path)\n real_size = (tell() - beginoffset + 8) & ~7\n write(b\"\\0\" * ((beginoffset + real_size) - tell()))\n # END for each entry\n\n # write previously cached extensions data\n if extension_data is not None:\n stream_sha.write(extension_data)\n\n # write the sha over the content\n stream_sha.write_sha()","def flush(self):\n if not self.noFlush:\n if self.filename is not None:\n L = self.users.items()\n L.sort()\n fd = utils.file.AtomicFile(self.filename)\n for (id, u) in L:\n fd.write('user %s' % id)\n fd.write(os.linesep)\n u.preserve(fd, indent=' ')\n fd.close()\n else:\n log.error('UsersDictionary.flush called with no filename.')\n else:\n log.debug('Not flushing UsersDictionary because of noFlush.')","def cache_session(self):\n # always save (to update timeout)\n self.i('Cache Session')\n with open(self.cache_file_path, \"wb\") as file:\n pickle.dump(self, file)","def s3_store_data(self):\n\n USERHOMEDIR = os.path.expanduser('~')\n TESTFILEPATH = \"%s/3MBFILE\" % USERHOMEDIR\n if not os.path.exists(TESTFILEPATH):\n with open(TESTFILEPATH, \"wb\") as out:\n out.truncate(1024 * 1024 * 3)\n self.k.set_contents_from_filename(TESTFILEPATH)","def _save_users_data_to_json(self):\n with open(self._users_numbers_json_path, 'wb') as f:\n json.dump(dict(self._users_numbers), f)","def cache_produce () :\n\n \"\"\"\n list for movie\n each entry is the sum and count of all ratings received by each movie, which will be used later to calculate the user offset\n \"\"\"\n mcache = movie_read(open('/u/downing/cs/netflix/movie_titles.txt', 'r', encoding = \"ISO-8859-1\"))\n\n \"\"\"\n dictionaries for user caches\n each entry contain the sum and count of all ratings given by each user, which will be used later to calculate the user offset\n mean is the average of all ratings from all movies\n \"\"\"\n ucache, mean = user_read(mcache, \"/u/downing/cs/netflix/training_set\")\n\n cal_offset(mcache, mean)\n cal_offset(ucache, mean)\n\n mcache.append(mean)\n\n output_cache(ucache, open('/u/wc6892/Documents/cs373-netflix/wc6892-ucacheoff.txt', 'w'))\n output_cache(mcache, open('/u/wc6892/Documents/cs373-netflix/wc6892-mcacheoff.txt', 'w'))","async def fix_cache(self, ctx):\n self.initial_config(ctx.message.server.id)\n self.settings[server.id]['usercache'] = []\n self.save_json()","def savecache(self, obj, cachepath):\n try:\n os.makedirs(os.path.dirname(cachepath))\n except OSError:\n pass\n tmpfname = cachepath+'.tmp-%d' % (int(time.time()*1000))\n f = open(tmpfname, 'wb')\n if self.serializer == 'json':\n json.dump(obj, f, indent=2, sort_keys=1)\n elif self.serializer == 'pickle':\n pickle.dump(obj, f, -1)\n try:\n os.rename(tmpfname, cachepath)\n size = os.stat(cachepath).st_size\n except Exception:\n print 'Savecache rename failed from %s to %s' % (tmpfname, cachepath)\n raise\n return size","def save(self):\r\n # os.mkdirs(DATADIR, exist_ok=True)\r\n savefile = os.path.join(wg.DATADIR, str(self.guild.id) + \".json\")\r\n\r\n savedata = {\r\n 'userchars': {id:self.usercharacters[id].to_data() for id in self.usercharacters},\r\n 'guildid': self.guild.id,\r\n 'last_known_name': self.guild.name,\r\n }\r\n\r\n with tempfile.NamedTemporaryFile(mode=\"w\", dir=wg.DATADIR) as outf:\r\n json.dump(savedata, outf, indent=1)\r\n if os.path.exists(savefile):\r\n os.unlink(savefile)\r\n os.link(outf.name, savefile)\r\n\r\n wg.log.info(f'Guild {debug_id(guild=self.guild)} saved. '\r\n f'{len(self.usercharacters)} user chars and {len(self.npcs)} npcs.')\r\n\r\n pass","def save_users(self, path):\n os.makedirs(path, exist_ok=True)\n np.save(os.path.join(path, 'ids'), self.user_ids)","def update(self, cache_key):\r\n self._write_sha(cache_key)","def fetch_user_animes(jikan, username, force):\n user_fpath = os.path.join(USERDIR, f\"{username}.json\")\n cache_exists = os.path.exists(user_fpath) and os.path.isfile(user_fpath)\n\n if force or not cache_exists:\n print(f\"Pulling userdata for {username}\")\n userdata = jikan.user(username=username, request=\"animelist\")\n user_animes = userdata[\"anime\"]\n\n print(f\"Caching at:\\n\\t{user_fpath}\")\n with open(user_fpath, \"w\") as fptr:\n json.dump(user_animes, fptr)\n else:\n print(f\"Using cached data located at:\\n\\t{user_fpath}\")\n with open(user_fpath, \"r\") as fptr:\n user_animes = json.load(fptr)\n\n return user_animes","def write_to_cache(self):\n return False","def save(self):\n with open(DEFAULT_DATA_FILE, \"r\") as f:\n data = json.load(f)\n\n if self.user.is_valid_index():\n data['users'][self.user.data_index]['balance'] = self.user.balance\n if self.user.record:\n for i in self.user.record:\n data['users'][self.user.data_index]['record'].append(i)\n data['isLocked'] = self.locked\n with open(DEFAULT_DATA_FILE, \"w\") as f:\n json.dump(data, f, indent=4)","def save_user_cards(wallet, user_data):\n for card in wallet.get_cards():\n user_data.write(card.__repr__() + \"\\n\")","def download(name, cache_dir=os.path.join('..', 'data')):\n assert name in DATA_HUB, f\"{name} does not exist in {DATA_HUB}.\"\n url, sha1_hash = DATA_HUB[name]\n os.makedirs(cache_dir, exist_ok=True)\n fname = os.path.join(cache_dir, url.split('/')[-1])\n if os.path.exists(fname):\n sha1 = hashlib.sha1()\n with open(fname, 'rb') as f:\n while True:\n data = f.read(1048576)\n if not data:\n break\n sha1.update(data)\n if sha1.hexdigest() == sha1_hash:\n return fname # Hit cache\n print(f'Downloading {fname} from {url}...')\n r = requests.get(url, stream=True, verify=True)\n with open(fname, 'wb') as f:\n f.write(r.content)\n return fname","def __clear_db_github_file(self):\n logger.get_logger().info(\"Clearing the github repos cached file collection for %s\", self.__github_account_login)\n\n DbGithubFSNodeClient().remove(\n self.__github_account_login\n )","def store_credentials(user, access_token, access_secret):\n with open(\"access.json\", \"w\") as f:\n json.dump({user : {\"access_token\": access_token, \n \"access_secret\": access_secret} }, f)","async def save(self):\n self.logger.debug(\"auto-save\")\n if self.path_prefix:\n path = join(self.path_prefix, 'cluster_status.json')\n cluster_status = self.cluster_status.copy()\n if cluster_status:\n self.logger.debug(\"saving status cache to {0}\".format(path))\n async with aiofiles.open(path, 'w') as handle:\n await handle.write(json.dumps(cluster_status, cls=CronEncoder))\n else:\n self.logger.debug(\"cluster status empty, not saving it.\")\n path = join(self.path_prefix, 'cluster_jobs.json')\n cluster_jobs = self.cluster_jobs.copy()\n if cluster_jobs:\n self.logger.debug(\"saving job cache to {0}\".format(path))\n async with aiofiles.open(path, 'w') as handle:\n await handle.write(json.dumps(cluster_jobs, cls=CronEncoder))\n else:\n self.logger.debug(\"cluster jobs empty, not saving it.\")\n else:\n self.logger.warning(\"no path specified for cache, cannot save\")\n await asyncio.sleep(0.1)","def StoreOrUpdateInCache(self, filename, data):\n try:\n if not memcache.add('%s%s' % (self.CACHE_PREFIX, filename), data):\n memcache.replace('%s%s' % (self.CACHE_PREFIX, filename), data)\n except (ValueError), err:\n logging.warning('Data size too large to cache\\n%s' % err)","def StoreOrUpdateInCache(self, filename, data):\n try:\n if not memcache.add('%s%s' % (self.CACHE_PREFIX, filename), data):\n memcache.replace('%s%s' % (self.CACHE_PREFIX, filename), data)\n except (ValueError), err:\n logging.warning('Data size too large to cache\\n%s' % err)","def _append_to_cache_directory(key: str, value: str) -> None:\n directory_json_path = os.path.join(\n CacheManagerSingleton.CACHE_PATH, \"directory.json\"\n )\n with open(directory_json_path, \"r\") as directory_file_read:\n directory_json = json.loads(directory_file_read.read())\n directory_file_read.close()\n directory_json[key] = value\n new_directory_json = json.dumps(directory_json, indent=2)\n with open(directory_json_path, \"w\") as directory_file_write:\n directory_file_write.write(new_directory_json)\n directory_file_write.close()","def cache_download(url, path):\n # Prep cache path and make necessary dirs\n cache_path = os.path.join(CAMD_CACHE, path)\n\n # Download and write file\n if not os.path.isfile(cache_path):\n makedirs_p(os.path.split(cache_path)[0])\n r = requests.get(url, stream=True)\n total_size = int(r.headers.get('content-length', 0))\n block_size = 1024 # 1 Kibibyte\n t = tqdm(total=total_size, unit='iB', unit_scale=True)\n with open(cache_path, 'wb') as f:\n for data in r.iter_content(block_size):\n t.update(len(data))\n f.write(data)","def update_stats():\r\n\turl = \"https://www.pathofexile.com/\" + \"api/trade/data/stats\"\r\n\tsave_path = \"data/stats.json\"\r\n\tr = requests.get(url)\r\n\twith open(save_path, \"w\") as fileID:\r\n\t\tfileID.write(r.text)","def SaveToJSON(self):\n import json\n\n f = open(f\"/Cache/{self.symbol}.JSON\", \"w\")\n j = {\"name\": self.name, \"symbol\": self.symbol}\n\n f.write(\"{\\\"name\\\":\\\"\" + str(self.name) + \"\\\", \")\n f.write(json.dumps(j))\n f.close()\n\n print(\"Warning: SaveToJSON not fully implemented.\")","def _save_data(self, filename):\n if not os.path.isdir(os.path.dirname(filename)):\n return False\n with open(filename, 'w') as f:\n f.truncate()\n pickle.dump({\n 'user_data': self.user_data,\n 'api_data': self.api_data,\n 'profiles': self.profiles\n }, f)","def cache_save(item: str, obj: object) -> None:\n\titem = str(item)\n\tcache = \"Cached/\" + item\n\n\tcache_create()\n\n\tpickle.dump(obj, open(cache, \"wb\"))\n\tuux.show_debug(\"Cached object to \" + cache)","def _write(self):\n raw_data = {'file_version': 1}\n raw_creds = []\n raw_data['data'] = raw_creds\n for (cred_key, cred) in self._data.items():\n raw_key = dict(cred_key)\n raw_cred = json.loads(cred.to_json())\n raw_creds.append({'key': raw_key, 'credential': raw_cred})\n self._locked_json_write(raw_data)","def save(self):\n path = self.user.get_session_path()\n with open(path, 'a', encoding='utf8') as file:\n self.write(file=file)","def write_filter_cache_scratch(filter_cache, cache_dir=None, skip_keys=None):\n if skip_keys is None:\n skip_keys = []\n # if the keys_before instantiation wasn't a list, then\n # keys_before would just be the current keys of cache and we\n # wouldn't have any new keys.\n new_filters = {k: filter_cache[k] for k in filter_cache if k not in skip_keys}\n if len(new_filters) > 0:\n # generate new file name\n if cache_dir is None:\n cache_dir = os.getcwd()\n cache_file_name = '%032x' % random.getrandbits(128) + '.filter_cache'\n cfile = open(os.path.join(cache_dir, cache_file_name), 'ab')\n pickle.dump(new_filters, cfile)\n else:\n warnings.warn(\"No new keys provided. No cache file written.\")","def save(self):\n settings_path = os.path.join(self.file_path, \"__file_data.json\")\n f = open( settings_path, 'w' )\n f.write( simplejson.dumps( self.fileList ) )\n f.close()\n\n settings_path = os.path.join(self.file_path, \"__user_data.json\")\n f = open( settings_path, 'w' )\n f.write( simplejson.dumps( self.userList ) )\n f.close()","def cache_and_save(self):\n if self.url and not self.photo:\n result = urllib.urlretrieve(self.url)\n self.photo.save(\n os.path.basename(self.url),\n File(open(result[0], 'rb')),\n )\n self.save()","def download(name, cache_dir=os.path.join('..', 'data')): #@save\n assert name in DATA_HUB, f\"{name} does not exist in {DATA_HUB}.\"\n url, sha1_hash = DATA_HUB[name]\n d2l.mkdir_if_not_exist(cache_dir)\n fname = os.path.join(cache_dir, url.split('/')[-1])\n if os.path.exists(fname):\n sha1 = hashlib.sha1()\n with open(fname, 'rb') as f:\n while True:\n data = f.read(1048576)\n if not data:\n break\n sha1.update(data)\n if sha1.hexdigest() == sha1_hash:\n return fname # Hit cache\n print(f'Downloading {fname} from {url}...')\n r = requests.get(url, stream=True, verify=True)\n with open(fname, 'wb') as f:\n f.write(r.content)\n return fname","def write_data(data):\r\n\r\n db = open(os.getcwd() + \"/www/access_list.txt\", 'w')\r\n json.dump(dict(data), db)","def flush_to_disk(self):\n logger.info(\"Flushing %s queries from in-memory cache to disk\", len(self.batch_writes))\n rows = self.memory_connection.execute(f\"\"\"\n SELECT hash_id, query, raw_query, domain, intent FROM queries\n WHERE rowid IN ({\",\".join(self.batch_writes)});\n \"\"\")\n self.disk_connection.executemany(\"\"\"\n INSERT OR IGNORE into queries values (?, ?, ?, ?, ?);\n \"\"\", rows)\n self.disk_connection.commit()\n self.batch_writes = []","def save_to_users(self):\n Data.add_data(self.user_data())","def save_public_keys(self, user, path=None):\n # Redis has an end_cursor if we've collected this data before\n end_cursor = self.redis.get(''.join(['gh:', user.login, ':publicKeys:endCursor']))\n if end_cursor:\n end_cursor = end_cursor.decode('utf-8')\n end_cursor = ''.join(['\"', end_cursor, '\"'])\n public_keys = u.publicKeys(first=100, after=end_cursor)\n else:\n public_keys = u.publicKeys(first=100)\n\n if not public_keys:\n return False\n\n while True:\n if public_keys['data']['user']['publicKeys']['edges']:\n index = ''.join(['gh_public_keys-', self.timestamp])\n self._write_to_datastore(index=index,\n doc_type='GithubPublicKeys',\n document=public_keys,\n login=user.login,\n path=path)\n has_next_page = public_keys['data']['user']['publicKeys']['pageInfo']['hasNextPage']\n end_cursor = public_keys['data']['user']['publicKeys']['pageInfo']['endCursor']\n if has_next_page:\n public_keys = u.publicKeys(first=100, after=end_cursor)\n else:\n # Cache the end_cursor where we last collected data\n self.redis.set(''.join(['gh:', u.login, ':publicKeys:endCursor']), end_cursor)\n break\n else:\n break\n\n return True","def cleanPMUserCache(cache):\n\n removeUser = []\n now = int(time.time())\n\n for user, utime in cache.items():\n if now > utime:\n log.debug(\"removing author %s from recent list\", user)\n removeUser.append(user)\n\n for ku in removeUser:\n del cache[ku]","def SaveData(self):\n \n try:\n with open(self.users_file, 'r+') as outfile:\n json.dump(self.user_db, outfile, indent=4)\n outfile.truncate()\n except:\n messagebox.showerror('Error',\n f'{self.users_file} could not be accessed.' \\\n 'New user information won\\'t be saved')","def prepare_cache_data() -> None:\n logger.debug(\"Downloading chromium\")\n if os.path.exists(LOCAL_CHROMIUM_PATH):\n return None\n s3 = S3()\n logger.debug(\"Check that remote folder exists:\")\n if not s3.is_exists(bucket=CACHE_BUCKET, key=\"local-chromium\"):\n s3.download_directory(bucket=CACHE_BUCKET,\n key=\"local-chromium\",\n dst=os.path.dirname(LOCAL_CHROMIUM_PATH))\n logger.debug(\"Downloading Done!!!\")","def write_new():\n if User.new_users:\n print(\"Creando nuevos usuarios {}\".format(User.new_users))\n with open(User.get_users_path(), 'a', encoding='utf8') as file:\n for username, user in User.new_users.items():\n print(\" Usuario {}\".format(user))\n user.create_user_file()\n user.write(file=file)","def __cache_chords(song_name, artist, UG_song_name, UG_artist, UG_url, UG_chords):\n # Cache the results\n with open(__cache_path(song_name, artist), \"w+\") as cache_file:\n cache_dump = {\n \"UltimateGuitar-song_name\": UG_song_name,\n \"UltimateGuitar-artist\": UG_artist,\n \"UltimageGuitar-song_url\": UG_url,\n \"Chords\": UG_chords\n }\n json.dump(cache_dump, cache_file, indent=4)","def write_data(self):\n\n data_string = \"%s, %d, %d, %s\\n\" % (\n self.name, self.repos, self.members, self.created)\n\n file_path = os.path.join(os.path.dirname(__file__), self.data_file)\n\n with open(os.path.abspath(file_path), 'a') as f:\n f.write(data_string)","def save_redis_to_file() -> None:\n with get_redis_instance() as redis:\n try:\n collected = json.loads(redis.get('corona-database').decode())\n except AttributeError:\n return\n write_to_csv(collected)","def flush_cache(self):\n if self.cache_modified:\n self.cache_manager.write(self.cache_file, self.cache)","def write_cache_file_list(self, file_list=None):\n if file_list:\n self.add_filelist_to_cache(file_list)\n cache_list = []\n for finfo in self.cache_file_list_dict.values():\n cache_list.append(finfo.output_cache_tuple())\n return self.write_pickle_object_to_file(tuple(cache_list))","def write_user_data(accounts, budget):\n\n print('Your Accounts\\n------------------------\\n\\n')\n\n for idx, account in enumerate(accounts):\n account_values = {\n 'idx': idx,\n 'name': account['accountName'],\n 'display_name': account['fiLoginDisplayName'],\n 'currentBalance': account['currentBalance']\n }\n print('{idx}: {name} ({display_name}) {currentBalance}'.format_map(account_values))\n\n account_indicies = input('\\n\\nSelect an account by number. Use commas for multiple accounts (e.g. 1, 9): ')\n\n print('\\nYour current expense budget (from Mint): {0}\\n\\n'.format(int(get_expenses(budget))))\n monthly_expenses = input('\\nInput your monthly expenses: ')\n account_indicies = map(lambda x: int(x), account_indicies.split(','))\n monthly_expenses = float(monthly_expenses)\n\n user_data = {\n 'account_ids': [accounts[idx]['accountId'] for idx in account_indicies],\n 'monthly_expenses': monthly_expenses\n }\n\n with open(get_user_data_path(), 'w') as outfile:\n json.dump(user_data, outfile)\n\n return user_data","def save_watching(self, user, path=None):\n # Redis has an end_cursor if we've collected this data before\n end_cursor = self.redis.get(''.join(['gh:', user.login, ':watching:endCursor']))\n if end_cursor:\n end_cursor = end_cursor.decode('utf-8')\n end_cursor = ''.join(['\"', end_cursor, '\"'])\n watching = u.watching(first=100,\n after=end_cursor,\n orderBy='{direction: DESC, field: CREATED_AT}')\n else:\n watching = u.watching(first=100,\n orderBy='{direction: DESC, field: CREATED_AT}')\n\n if not watching:\n return False\n\n while True:\n if watching['data']['user']['watching']['edges']:\n index = ''.join(['gh_watching-', self.timestamp])\n self._write_to_datastore(index=index,\n doc_type='GithubWatching',\n document=watching,\n login=user.login,\n path=path)\n has_next_page = watching['data']['user']['watching']['pageInfo']['hasNextPage']\n end_cursor = watching['data']['user']['watching']['pageInfo']['endCursor']\n if has_next_page:\n watching = u.watching(first=100,\n after=end_cursor,\n orderBy='{direction: DESC, field: CREATED_AT}')\n else:\n # Cache the end_cursor where we last collected data\n self.redis.set(''.join(['gh:', u.login, ':watching:endCursor']), end_cursor)\n break\n else:\n break\n\n return True","def save_user(username, data):\n\n hashed_username = base64.b64encode(Cryptography.hash(username).digest()).decode()\n\n file = open(getcwd() + Database.__DB_FILENAME, 'a')\n iv, ciphered_data = Cryptography.cipher(Cryptography.get_passphrase(), data)\n file.write(hashed_username + ':' + ciphered_data.hex() + '.' + iv.hex() + '\\n')\n file.flush()\n file.close()","def cache_sweep_results(\n sr: Union[OSweepResults, OMultiSweepResult], file_name: str\n ):\n if not file_name.endswith(\".json\"):\n file_name += \".json\"\n\n if not os.path.exists(CacheManagerSingleton.SWEEP_RESULTS_PATH):\n os.mkdir(CacheManagerSingleton.SWEEP_RESULTS_PATH)\n\n if sr.sweep_args is not None:\n sr.sweep_args = None\n\n with open(\n os.path.join(CacheManagerSingleton.SWEEP_RESULTS_PATH, file_name), \"w\"\n ) as f:\n f.write(sr.json(indent=2))","def fetch_anime_metadata(jikan, user_animes, force, rate_limit):\n for anime in user_animes:\n metadata_fpath = os.path.join(ANIMEDIR, f\"{anime['mal_id']}.json\")\n cache_exists = os.path.exists(metadata_fpath) and os.path.isfile(metadata_fpath)\n if force or not cache_exists:\n print(f\"Saving metadata for: {anime['title']}\")\n anime_metadata = jikan.anime(anime[\"mal_id\"])\n with open(metadata_fpath, \"w\") as fptr:\n json.dump(anime_metadata, fptr)\n time.sleep(rate_limit)\n else:\n print(f\"Skipping already cached metadata for: {anime['title']}\")","def flush_all_owners_data_cache():\n from base import get_group_database\n \n group_db = get_group_database()\n \n for group_id, group in group_db.root.iteritems():\n for user in group.owners:\n flush_user_data_cache(user)","def _mock_write_cache(self, pipeline, values, cache_key):\n labels = ['full', cache_key]\n\n # Usually, the pcoder will be inferred from `pcoll.element_type`\n pcoder = coders.registry.get_coder(object)\n cache_manager = ie.current_env().get_cache_manager(pipeline)\n cache_manager.save_pcoder(pcoder, *labels)\n cache_manager.write(values, *labels)","def save(searches):\n # type: (list) -> None\n with Cache(CACHE_URI) as c:\n c.set(SAVED_SEARCH, json.dumps(searches, ensure_ascii=False))","def cache_file(self, repo):\n token = blake2b(repo.location.encode()).hexdigest()[:10]\n dirname = f\"{repo.repo_id.lstrip(os.sep)}-{token}\"\n return pjoin(self.options.cache_dir, \"repos\", dirname, self.cache.file)","def cache_matrio_data(filename):\n prefix = \"https://data.matr.io/3/api/v1/file\"\n key = MATRIO_DATA_KEYS[filename]\n if not os.path.isfile(filename):\n cache_download(\"{}/{}/download\".format(prefix, key), filename)","def setup_cache(self):\n train_cache_path = self.cache.get_cache_path_and_check(TRAIN_STR, self.task_name)\n dev_cache_path = self.cache.get_cache_path_and_check(DEV_STR, self.task_name)\n test_cache_path = self.cache.get_cache_path_and_check(TEST_STR, self.task_name)\n\n self.train_cache_writer = None\n self.dev_cache_writer = None\n self.test_cache_writer = None\n\n if os.path.exists(train_cache_path):\n f = h5py.File(train_cache_path, 'r')\n self.train_cache = (torch.tensor(f[str(i)][()]) for i in range(len(f.keys())))\n else:\n self.train_cache_writer = h5py.File(train_cache_path, 'w')\n if os.path.exists(dev_cache_path):\n f2 = h5py.File(dev_cache_path, 'r')\n self.dev_cache = (torch.tensor(f2[str(i)][()]) for i in range(len(f2.keys())))\n else:\n self.dev_cache_writer = h5py.File(dev_cache_path, 'w')\n if os.path.exists(test_cache_path):\n f3 = h5py.File(test_cache_path, 'r')\n self.test_cache = (torch.tensor(f3[str(i)][()]) for i in range(len(f3.keys())))\n else:\n self.test_cache_writer = h5py.File(test_cache_path, 'w')"],"string":"[\n \"def saveCacheFile(self):\\n with open(self.cachePath, 'w', encoding='utf-8') as outfile:\\n json.dump(self.cacheData, outfile)\",\n \"def save_cache(cache_key, version, data):\\n\\n # Save these results for the next run. Include the version information and nest the user\\n # information inside a \\\"users\\\" key from the start, because experience says if we don't do this\\n # then the next release will add a feature that requires a change in the data layout, and then\\n # we'll have to write a data migration or something.\\n\\n cache_data = {cache_key: data, \\\"version\\\": version}\\n\\n cache_file(cache_key).write_text(json.dumps(cache_data, indent=2))\",\n \"def write_cache(feed):\\n if ARGV.get(NOCACHE_OPT):\\n return\\n CACHE['feed'] = feed\\n CACHE['last-request'] = str(time.time())\\n CACHE['max-age'] = feed.headers['Cache-Control'].split('=')[1]\\n save_datfile()\",\n \"def save_users(users):\\n with open(STORAGE_PATH, \\\"wb\\\") as fp:\\n pickle.dump(users, fp)\",\n \"def _write_cache_file(self, data):\\n\\n with open(self.cache_file, mode='wb') as f:\\n f.write(data)\\n\\n self.log.info(f\\\"Cached facilities at {self.cache_file}\\\")\",\n \"def _write_cache(url, j):\\n\\n m = hashlib.md5()\\n m.update(url)\\n with open('.cache.%s' % m.hexdigest(), 'wb') as outfile:\\n json.dump(j, outfile)\",\n \"def write_cache(self):\\n self.__config.open_file(\\n self.__cache_file, \\\"w\\\", lambda f: json.dump(self.cache, f)\\n )\\n self.__dirty = False\",\n \"def write_to_cache(self, data, filename):\\n json_data = self.json_format_dict(data, True)\\n cache = open(filename, 'w')\\n cache.write(json_data)\\n cache.close()\",\n \"def save_cache(self):\\n with open(self.get_cache_filename(), 'wb+') as f:\\n out = dict()\\n out['timestamp'] = self.get_last_update()\\n out['cache'] = self.cache\\n f.write(pickle.dumps(out))\",\n \"def export_cache_file(conn, cache_file):\\n with conn:\\n c = conn.cursor()\\n with open(cache_file, \\\"w\\\") as fo:\\n c.execute(\\\"SELECT project FROM projects ORDER BY called DESC, project\\\")\\n rows = c.fetchall()\\n [fo.write(x[0] + \\\"\\\\n\\\") for x in rows]\",\n \"def save_cache(self, data, URL):\\n\\n cache_file = self.get_cache_file_path(URL)\\n\\n if cache_file.parent.exists():\\n with open(cache_file, 'wb') as f:\\n f.write(data)\\n else:\\n os.mkdir(cache_file.parent)\\n with open(cache_file, 'wb') as f:\\n f.write(data)\",\n \"def write_cache(self, write_cache: SmartSsdReadLookahead):\\n\\n self._write_cache = write_cache\",\n \"def write_cache(self, filename=None):\\n with open(self._cache_filename(filename), \\\"wb\\\") as fh:\\n pickle.dump(self, fh)\",\n \"def save(self):\\n if self._cache is not None:\\n with open(self.cache_path, 'w') as cache_file:\\n json.dump(self._cache, cache_file)\",\n \"def store_cache(base_url, data, path=\\\"logs/\\\"):\\n\\n # Convert URL to filename and write html content into that file\\n url_filename = url_to_filename(base_url)\\n filename = f\\\"{path}CACHE-{url_filename}.html\\\"\\n f = open(filename, \\\"w+\\\")\\n f.write(data)\\n f.close()\",\n \"def _write_cache(self, path, text):\\n if self._cache:\\n cache_path = os.path.join(self._cache, path)\\n\\n folder = os.path.split(cache_path)[0]\\n\\n if not os.path.exists(folder):\\n os.makedirs(folder)\\n\\n with io.open(cache_path, 'w', encoding='utf-8') as f:\\n f.write(text)\",\n \"def _write_buckets_cache_file(metadata, cache_file):\\n if os.path.isfile(cache_file):\\n os.remove(cache_file)\\n\\n log.debug(\\\"Writing buckets cache file\\\")\\n\\n with salt.utils.files.fopen(cache_file, \\\"wb\\\") as fp_:\\n pickle.dump(metadata, fp_)\",\n \"def save_data(self):\\n with open(self.storage_path, 'w') as cache_file:\\n json.dump(self.data, cache_file)\",\n \"def write_cache(cache_dict):\\n try:\\n with open(CACHE_FILENAME, 'w', encoding=\\\"utf-8\\\") as cache_file:\\n cache_file.write(json.dumps(cache_dict))\\n except:\\n print(\\\"error when executing write_cache()\\\")\",\n \"def save_cache(self, cache_dir):\\n if not self.is_numeric:\\n raise ValueError(\\\"No need to save if not numeric\\\")\\n if self.is_supervised:\\n raise NotImplementedError(\\\"Caching not yet implemented for supervised views\\\")\\n\\n os.makedirs(cache_dir, exist_ok=True)\\n # Adjacencies\\n adj_path = os.path.join(cache_dir, \\\"adjlist.txt\\\")\\n nx.readwrite.adjlist.write_adjlist(self.graph, adj_path)\\n ndata_path = os.path.join(cache_dir, \\\"ndata.csv\\\")\\n self.ndata.to_csv(ndata_path, index=True)\",\n \"def write_to_cache(self):\\n data = {'data': self.data, 'inventory': self.inventory}\\n json_data = json.dumps(data, indent=2)\\n\\n with open(self.cache_filename, 'w') as cache:\\n cache.write(json_data)\",\n \"def write_data_cache(self, data):\\n assert data, 'Must input a non-empty dictionary.'\\n with open(self.cache_filename, 'w') as file_cache:\\n json.dump(data, file_cache, sort_keys=True, indent=4, ensure_ascii=False)\\n self.data = data # must assign the new data or risk problems\",\n \"def save_player(user):\\n with shelve.open('myfile') as savefile:\\n savefile[user.name] = user\",\n \"def saveGameToCache(self, theKey, theGame):\\n if theGame == None:\\n return\\n theGameFile = File(self.theCacheDirectory, theKey + \\\".zip\\\")\\n try:\\n theGameFile.createNewFile()\\n pw.print_(theGame.serializeToJSON())\\n pw.flush()\\n pw.close()\\n gOut.close()\\n fOut.close()\\n except Exception as e:\\n e.printStackTrace()\",\n \"async def save_to_cache(self, item: T):\\n path = self._build_cache_path(\\n **{a: getattr(item, a) for a in self._unique_attribues}\\n )\\n if path.is_file():\\n raise ValueError(f\\\"Trying to overwrite cache at {str(path)}\\\")\\n path.parent.mkdir(parents=True, exist_ok=True)\\n async with aiofiles.open(str(path), \\\"w\\\") as file:\\n await file.write(item.to_json())\",\n \"def save_output_in_cache(name, filename, output):\\n cache_filename = _get_cache_filename(name, filename)\\n with _open_for_write(cache_filename) as f:\\n f.write(output)\",\n \"def update_cache():\\n total = isic.get_image_count()\\n df = pd.DataFrame()\\n for meta in tqdm(isic.get_image_meta(), total=total, desc=\\\"Updating image list cache\\\", unit=\\\"img\\\"):\\n _meta = json_normalize(meta)\\n # File name and directory will be named after dataset.name.\\n # Make it file system friendly. e.g. remove chars like /\\n # Todo: This append stuff is painfully slow... Do something about it\\n _meta[\\\"dataset.name\\\"] = slugify(_meta[\\\"dataset.name\\\"][0])\\n df = df.append(_meta, ignore_index=True)\\n df.to_csv(cache_file, index=False)\",\n \"def _save_fingerprint(self):\\n path = os.path.join(self._cache_path, '%s.fingerprint' % self._name)\\n\\n if not os.path.exists(self._cache_path):\\n os.makedirs(self._cache_path)\\n\\n with open(path, 'w') as f:\\n f.write(self._fingerprint())\",\n \"def __saveCacheTokens(self):\\n self.orgConf[self.cacheSection] = {\\n self.ACCESS_TOKEN: self.accessToken,\\n self.REFRESH_TOKEN: self.refreshToken\\n }\\n with open(self.configFile, \\\"w\\\") as f:\\n self.orgConf.write(f)\",\n \"def cache_data(name, data):\\n cache_path = get_cachefile('%s.cache' % name)\\n with open(cache_path, 'wb') as f:\\n pickle.dump(data, f)\",\n \"def save_servers(self):\\n\\n\\t\\tfor serv in self.servers:\\n\\t\\t\\ta = serv.cache.hash_map\\n\\t\\t\\twith open('cache.pickle', 'wb') as handle:\\n\\t\\t\\t\\tpickle.dump(a, handle, protocol=pickle.HIGHEST_PROTOCOL)\",\n \"def __write_cache(self, fileName, returnVal):\\n # Cache miss\\n if self.__log:\\n self.__logger.info(f\\\"Cache miss: {fileName}\\\")\\n self.__handle_cache_size()\\n\\n with open(fileName, \\\"wb\\\") as f:\\n packed = pickle.dumps(returnVal)\\n final = self.__handle_compression(packed)\\n f.write(final)\\n\\n node = os.path.relpath(fileName, \\\"cache\\\")\\n self.__recentAccessed.insert(0, node)\",\n \"def save_users(user_list):\\n with open(user_path, \\\"w\\\") as outfile:\\n json.dump(user_list, outfile)\",\n \"def sync(self):\\n\\t\\tmanagers.storage.write_object_async(VDOM_CONFIG[\\\"USER-MANAGER-STORAGE-RECORD\\\"], self.users)\",\n \"def storeAllOnDisk(self, path):\\n # fetch meta data\\n urls = list()\\n y_data = self.data_dict.labels\\n ids = self.data_dict.unique_ids\\n urls = self.data_dict.paths\\n\\n # save in chunks of 1000 images\\n cuts = [x for x in range(0, self.n_observations, 1000)]\\n if cuts[-1] < self.n_observations:\\n cuts.append(self.n_observations)\\n\\n # convert batch sizes to integers\\n cuts = [int(x) for x in cuts]\\n\\n for i in range(0, (len(cuts) - 1)):\\n\\n idx = [x for x in range(cuts[i], cuts[i+1])]\\n\\n current_ids = [ids[z] for z in idx]\\n current_urls = [urls[z] for z in idx]\\n current_y = [y_data[z] for z in idx]\\n\\n # invoke asynchronous read\\n binary_images = self.imageLoader.getImages(current_urls)\\n\\n # store on disk\\n img_id = 0\\n for c_id, c_y in zip(current_ids, current_y):\\n # check directory\\n if not os.path.isdir(path + str(c_y)):\\n os.mkdir(path + str(c_y))\\n # define path\\n path_img = path + str(c_y) + \\\"/\\\" + \\\\\\n str(c_id) + \\\".jpeg\\\"\\n img = binary_images[img_id]\\n img = img.resize(self.image_size)\\n img.save(path_img)\\n img_id += 1\\n return None\",\n \"def _store_cache(self):\\n assert self._already_generated, \\\"Must generate before storing to cache\\\"\\n\\n if self.variant_unit is not None:\\n logger.warning(\\\"Cannot cache once variant_unit has been set\\\")\\n return\\n\\n try:\\n os.mkdir(os.path.dirname(self._cache_key))\\n except FileExistsError:\\n # Easier than checking and risking race conditions\\n pass\\n\\n with open(self._cache_key, 'w') as f:\\n json.dump(self.rows, f)\\n\\n logger.debug(\\\"Stored cache to {}\\\".format(self._cache_key))\",\n \"def save_hash_file(self):\\n\\n cid = time.time()\\n '''\\n f = open(self.file_hash_name, 'w+')\\n f.write(str(cid))\\n f.close()\\n '''\\n\\n with open(self.file_hash_name, \\\"w\\\") as f:\\n logger.debug('CID salvo file {}'.format(cid))\\n fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)\\n f.write(str(cid))\\n fcntl.flock(f, fcntl.LOCK_UN)\\n\\n self.set_cache_hash(cid)\",\n \"def save_user_archive_to_file(user):\\n filename = str(user).__add__('-tweets.json')\\n with open(filename, \\\"w\\\") as f:\\n archive_generator = rest.fetch_user_archive(user)\\n for page in archive_generator:\\n for tweet in page:\\n f.write(json.dumps(tweet) + \\\"\\\\n\\\")\\n logging.warning(u\\\"Wrote tweets from the user\\\")\",\n \"def backup_users_dict(users_dict: dict) -> None:\\n with open('users.json', 'w') as usrs:\\n json.dump(users_dict, usrs)\",\n \"def store_cache(value, name, typ=\\\"pkl\\\"):\\n if not os.path.exists(CACHE_DIR):\\n os.mkdir(CACHE_DIR, mode=0o775)\\n filename = cache_name(name, typ)\\n if typ == \\\"str\\\":\\n with open(filename, 'w') as fout:\\n fout.write(value)\\n elif typ == \\\"pkl\\\":\\n with open(filename, 'wb') as fout:\\n pickle.dump(value, fout)\\n elif typ == \\\"h5\\\":\\n value.save(filename)\\n else:\\n raise ValueError(\\\"Invalid type '{}'.\\\".format(typ))\",\n \"def add_to_cache(filename: str, entry: str) -> None:\\n\\n with open(filename, \\\"a\\\") as f:\\n f.write(entry.strip())\\n f.write(\\\"\\\\n\\\")\",\n \"def _save_drafts(self):\\n ##logging.info('SAVING: %s -> %s', self.email, self._drafts)\\n memcache.set('user_drafts:' + self.email, self._drafts, 3600)\",\n \"def save(self, path=None):\\n if path is None:\\n path = self.path\\n try:\\n with open(path, 'w') as fd:\\n for entry in self:\\n fd.write('{}\\\\n'.format(entry))\\n except Exception as e:\\n raise SSHKeyError('Error writing {}: {}'.format(path, e))\",\n \"def write_cache(\\n entries: Sequence[Union[BaseIndexEntry, \\\"IndexEntry\\\"]],\\n stream: IO[bytes],\\n extension_data: Union[None, bytes] = None,\\n ShaStreamCls: Type[IndexFileSHA1Writer] = IndexFileSHA1Writer,\\n) -> None:\\n # wrap the stream into a compatible writer\\n stream_sha = ShaStreamCls(stream)\\n\\n tell = stream_sha.tell\\n write = stream_sha.write\\n\\n # header\\n version = 2\\n write(b\\\"DIRC\\\")\\n write(pack(\\\">LL\\\", version, len(entries)))\\n\\n # body\\n for entry in entries:\\n beginoffset = tell()\\n write(entry.ctime_bytes) # ctime\\n write(entry.mtime_bytes) # mtime\\n path_str = str(entry.path)\\n path: bytes = force_bytes(path_str, encoding=defenc)\\n plen = len(path) & CE_NAMEMASK # path length\\n assert plen == len(path), \\\"Path %s too long to fit into index\\\" % entry.path\\n flags = plen | (entry.flags & CE_NAMEMASK_INV) # clear possible previous values\\n write(\\n pack(\\n \\\">LLLLLL20sH\\\",\\n entry.dev,\\n entry.inode,\\n entry.mode,\\n entry.uid,\\n entry.gid,\\n entry.size,\\n entry.binsha,\\n flags,\\n )\\n )\\n write(path)\\n real_size = (tell() - beginoffset + 8) & ~7\\n write(b\\\"\\\\0\\\" * ((beginoffset + real_size) - tell()))\\n # END for each entry\\n\\n # write previously cached extensions data\\n if extension_data is not None:\\n stream_sha.write(extension_data)\\n\\n # write the sha over the content\\n stream_sha.write_sha()\",\n \"def flush(self):\\n if not self.noFlush:\\n if self.filename is not None:\\n L = self.users.items()\\n L.sort()\\n fd = utils.file.AtomicFile(self.filename)\\n for (id, u) in L:\\n fd.write('user %s' % id)\\n fd.write(os.linesep)\\n u.preserve(fd, indent=' ')\\n fd.close()\\n else:\\n log.error('UsersDictionary.flush called with no filename.')\\n else:\\n log.debug('Not flushing UsersDictionary because of noFlush.')\",\n \"def cache_session(self):\\n # always save (to update timeout)\\n self.i('Cache Session')\\n with open(self.cache_file_path, \\\"wb\\\") as file:\\n pickle.dump(self, file)\",\n \"def s3_store_data(self):\\n\\n USERHOMEDIR = os.path.expanduser('~')\\n TESTFILEPATH = \\\"%s/3MBFILE\\\" % USERHOMEDIR\\n if not os.path.exists(TESTFILEPATH):\\n with open(TESTFILEPATH, \\\"wb\\\") as out:\\n out.truncate(1024 * 1024 * 3)\\n self.k.set_contents_from_filename(TESTFILEPATH)\",\n \"def _save_users_data_to_json(self):\\n with open(self._users_numbers_json_path, 'wb') as f:\\n json.dump(dict(self._users_numbers), f)\",\n \"def cache_produce () :\\n\\n \\\"\\\"\\\"\\n list for movie\\n each entry is the sum and count of all ratings received by each movie, which will be used later to calculate the user offset\\n \\\"\\\"\\\"\\n mcache = movie_read(open('/u/downing/cs/netflix/movie_titles.txt', 'r', encoding = \\\"ISO-8859-1\\\"))\\n\\n \\\"\\\"\\\"\\n dictionaries for user caches\\n each entry contain the sum and count of all ratings given by each user, which will be used later to calculate the user offset\\n mean is the average of all ratings from all movies\\n \\\"\\\"\\\"\\n ucache, mean = user_read(mcache, \\\"/u/downing/cs/netflix/training_set\\\")\\n\\n cal_offset(mcache, mean)\\n cal_offset(ucache, mean)\\n\\n mcache.append(mean)\\n\\n output_cache(ucache, open('/u/wc6892/Documents/cs373-netflix/wc6892-ucacheoff.txt', 'w'))\\n output_cache(mcache, open('/u/wc6892/Documents/cs373-netflix/wc6892-mcacheoff.txt', 'w'))\",\n \"async def fix_cache(self, ctx):\\n self.initial_config(ctx.message.server.id)\\n self.settings[server.id]['usercache'] = []\\n self.save_json()\",\n \"def savecache(self, obj, cachepath):\\n try:\\n os.makedirs(os.path.dirname(cachepath))\\n except OSError:\\n pass\\n tmpfname = cachepath+'.tmp-%d' % (int(time.time()*1000))\\n f = open(tmpfname, 'wb')\\n if self.serializer == 'json':\\n json.dump(obj, f, indent=2, sort_keys=1)\\n elif self.serializer == 'pickle':\\n pickle.dump(obj, f, -1)\\n try:\\n os.rename(tmpfname, cachepath)\\n size = os.stat(cachepath).st_size\\n except Exception:\\n print 'Savecache rename failed from %s to %s' % (tmpfname, cachepath)\\n raise\\n return size\",\n \"def save(self):\\r\\n # os.mkdirs(DATADIR, exist_ok=True)\\r\\n savefile = os.path.join(wg.DATADIR, str(self.guild.id) + \\\".json\\\")\\r\\n\\r\\n savedata = {\\r\\n 'userchars': {id:self.usercharacters[id].to_data() for id in self.usercharacters},\\r\\n 'guildid': self.guild.id,\\r\\n 'last_known_name': self.guild.name,\\r\\n }\\r\\n\\r\\n with tempfile.NamedTemporaryFile(mode=\\\"w\\\", dir=wg.DATADIR) as outf:\\r\\n json.dump(savedata, outf, indent=1)\\r\\n if os.path.exists(savefile):\\r\\n os.unlink(savefile)\\r\\n os.link(outf.name, savefile)\\r\\n\\r\\n wg.log.info(f'Guild {debug_id(guild=self.guild)} saved. '\\r\\n f'{len(self.usercharacters)} user chars and {len(self.npcs)} npcs.')\\r\\n\\r\\n pass\",\n \"def save_users(self, path):\\n os.makedirs(path, exist_ok=True)\\n np.save(os.path.join(path, 'ids'), self.user_ids)\",\n \"def update(self, cache_key):\\r\\n self._write_sha(cache_key)\",\n \"def fetch_user_animes(jikan, username, force):\\n user_fpath = os.path.join(USERDIR, f\\\"{username}.json\\\")\\n cache_exists = os.path.exists(user_fpath) and os.path.isfile(user_fpath)\\n\\n if force or not cache_exists:\\n print(f\\\"Pulling userdata for {username}\\\")\\n userdata = jikan.user(username=username, request=\\\"animelist\\\")\\n user_animes = userdata[\\\"anime\\\"]\\n\\n print(f\\\"Caching at:\\\\n\\\\t{user_fpath}\\\")\\n with open(user_fpath, \\\"w\\\") as fptr:\\n json.dump(user_animes, fptr)\\n else:\\n print(f\\\"Using cached data located at:\\\\n\\\\t{user_fpath}\\\")\\n with open(user_fpath, \\\"r\\\") as fptr:\\n user_animes = json.load(fptr)\\n\\n return user_animes\",\n \"def write_to_cache(self):\\n return False\",\n \"def save(self):\\n with open(DEFAULT_DATA_FILE, \\\"r\\\") as f:\\n data = json.load(f)\\n\\n if self.user.is_valid_index():\\n data['users'][self.user.data_index]['balance'] = self.user.balance\\n if self.user.record:\\n for i in self.user.record:\\n data['users'][self.user.data_index]['record'].append(i)\\n data['isLocked'] = self.locked\\n with open(DEFAULT_DATA_FILE, \\\"w\\\") as f:\\n json.dump(data, f, indent=4)\",\n \"def save_user_cards(wallet, user_data):\\n for card in wallet.get_cards():\\n user_data.write(card.__repr__() + \\\"\\\\n\\\")\",\n \"def download(name, cache_dir=os.path.join('..', 'data')):\\n assert name in DATA_HUB, f\\\"{name} does not exist in {DATA_HUB}.\\\"\\n url, sha1_hash = DATA_HUB[name]\\n os.makedirs(cache_dir, exist_ok=True)\\n fname = os.path.join(cache_dir, url.split('/')[-1])\\n if os.path.exists(fname):\\n sha1 = hashlib.sha1()\\n with open(fname, 'rb') as f:\\n while True:\\n data = f.read(1048576)\\n if not data:\\n break\\n sha1.update(data)\\n if sha1.hexdigest() == sha1_hash:\\n return fname # Hit cache\\n print(f'Downloading {fname} from {url}...')\\n r = requests.get(url, stream=True, verify=True)\\n with open(fname, 'wb') as f:\\n f.write(r.content)\\n return fname\",\n \"def __clear_db_github_file(self):\\n logger.get_logger().info(\\\"Clearing the github repos cached file collection for %s\\\", self.__github_account_login)\\n\\n DbGithubFSNodeClient().remove(\\n self.__github_account_login\\n )\",\n \"def store_credentials(user, access_token, access_secret):\\n with open(\\\"access.json\\\", \\\"w\\\") as f:\\n json.dump({user : {\\\"access_token\\\": access_token, \\n \\\"access_secret\\\": access_secret} }, f)\",\n \"async def save(self):\\n self.logger.debug(\\\"auto-save\\\")\\n if self.path_prefix:\\n path = join(self.path_prefix, 'cluster_status.json')\\n cluster_status = self.cluster_status.copy()\\n if cluster_status:\\n self.logger.debug(\\\"saving status cache to {0}\\\".format(path))\\n async with aiofiles.open(path, 'w') as handle:\\n await handle.write(json.dumps(cluster_status, cls=CronEncoder))\\n else:\\n self.logger.debug(\\\"cluster status empty, not saving it.\\\")\\n path = join(self.path_prefix, 'cluster_jobs.json')\\n cluster_jobs = self.cluster_jobs.copy()\\n if cluster_jobs:\\n self.logger.debug(\\\"saving job cache to {0}\\\".format(path))\\n async with aiofiles.open(path, 'w') as handle:\\n await handle.write(json.dumps(cluster_jobs, cls=CronEncoder))\\n else:\\n self.logger.debug(\\\"cluster jobs empty, not saving it.\\\")\\n else:\\n self.logger.warning(\\\"no path specified for cache, cannot save\\\")\\n await asyncio.sleep(0.1)\",\n \"def StoreOrUpdateInCache(self, filename, data):\\n try:\\n if not memcache.add('%s%s' % (self.CACHE_PREFIX, filename), data):\\n memcache.replace('%s%s' % (self.CACHE_PREFIX, filename), data)\\n except (ValueError), err:\\n logging.warning('Data size too large to cache\\\\n%s' % err)\",\n \"def StoreOrUpdateInCache(self, filename, data):\\n try:\\n if not memcache.add('%s%s' % (self.CACHE_PREFIX, filename), data):\\n memcache.replace('%s%s' % (self.CACHE_PREFIX, filename), data)\\n except (ValueError), err:\\n logging.warning('Data size too large to cache\\\\n%s' % err)\",\n \"def _append_to_cache_directory(key: str, value: str) -> None:\\n directory_json_path = os.path.join(\\n CacheManagerSingleton.CACHE_PATH, \\\"directory.json\\\"\\n )\\n with open(directory_json_path, \\\"r\\\") as directory_file_read:\\n directory_json = json.loads(directory_file_read.read())\\n directory_file_read.close()\\n directory_json[key] = value\\n new_directory_json = json.dumps(directory_json, indent=2)\\n with open(directory_json_path, \\\"w\\\") as directory_file_write:\\n directory_file_write.write(new_directory_json)\\n directory_file_write.close()\",\n \"def cache_download(url, path):\\n # Prep cache path and make necessary dirs\\n cache_path = os.path.join(CAMD_CACHE, path)\\n\\n # Download and write file\\n if not os.path.isfile(cache_path):\\n makedirs_p(os.path.split(cache_path)[0])\\n r = requests.get(url, stream=True)\\n total_size = int(r.headers.get('content-length', 0))\\n block_size = 1024 # 1 Kibibyte\\n t = tqdm(total=total_size, unit='iB', unit_scale=True)\\n with open(cache_path, 'wb') as f:\\n for data in r.iter_content(block_size):\\n t.update(len(data))\\n f.write(data)\",\n \"def update_stats():\\r\\n\\turl = \\\"https://www.pathofexile.com/\\\" + \\\"api/trade/data/stats\\\"\\r\\n\\tsave_path = \\\"data/stats.json\\\"\\r\\n\\tr = requests.get(url)\\r\\n\\twith open(save_path, \\\"w\\\") as fileID:\\r\\n\\t\\tfileID.write(r.text)\",\n \"def SaveToJSON(self):\\n import json\\n\\n f = open(f\\\"/Cache/{self.symbol}.JSON\\\", \\\"w\\\")\\n j = {\\\"name\\\": self.name, \\\"symbol\\\": self.symbol}\\n\\n f.write(\\\"{\\\\\\\"name\\\\\\\":\\\\\\\"\\\" + str(self.name) + \\\"\\\\\\\", \\\")\\n f.write(json.dumps(j))\\n f.close()\\n\\n print(\\\"Warning: SaveToJSON not fully implemented.\\\")\",\n \"def _save_data(self, filename):\\n if not os.path.isdir(os.path.dirname(filename)):\\n return False\\n with open(filename, 'w') as f:\\n f.truncate()\\n pickle.dump({\\n 'user_data': self.user_data,\\n 'api_data': self.api_data,\\n 'profiles': self.profiles\\n }, f)\",\n \"def cache_save(item: str, obj: object) -> None:\\n\\titem = str(item)\\n\\tcache = \\\"Cached/\\\" + item\\n\\n\\tcache_create()\\n\\n\\tpickle.dump(obj, open(cache, \\\"wb\\\"))\\n\\tuux.show_debug(\\\"Cached object to \\\" + cache)\",\n \"def _write(self):\\n raw_data = {'file_version': 1}\\n raw_creds = []\\n raw_data['data'] = raw_creds\\n for (cred_key, cred) in self._data.items():\\n raw_key = dict(cred_key)\\n raw_cred = json.loads(cred.to_json())\\n raw_creds.append({'key': raw_key, 'credential': raw_cred})\\n self._locked_json_write(raw_data)\",\n \"def save(self):\\n path = self.user.get_session_path()\\n with open(path, 'a', encoding='utf8') as file:\\n self.write(file=file)\",\n \"def write_filter_cache_scratch(filter_cache, cache_dir=None, skip_keys=None):\\n if skip_keys is None:\\n skip_keys = []\\n # if the keys_before instantiation wasn't a list, then\\n # keys_before would just be the current keys of cache and we\\n # wouldn't have any new keys.\\n new_filters = {k: filter_cache[k] for k in filter_cache if k not in skip_keys}\\n if len(new_filters) > 0:\\n # generate new file name\\n if cache_dir is None:\\n cache_dir = os.getcwd()\\n cache_file_name = '%032x' % random.getrandbits(128) + '.filter_cache'\\n cfile = open(os.path.join(cache_dir, cache_file_name), 'ab')\\n pickle.dump(new_filters, cfile)\\n else:\\n warnings.warn(\\\"No new keys provided. No cache file written.\\\")\",\n \"def save(self):\\n settings_path = os.path.join(self.file_path, \\\"__file_data.json\\\")\\n f = open( settings_path, 'w' )\\n f.write( simplejson.dumps( self.fileList ) )\\n f.close()\\n\\n settings_path = os.path.join(self.file_path, \\\"__user_data.json\\\")\\n f = open( settings_path, 'w' )\\n f.write( simplejson.dumps( self.userList ) )\\n f.close()\",\n \"def cache_and_save(self):\\n if self.url and not self.photo:\\n result = urllib.urlretrieve(self.url)\\n self.photo.save(\\n os.path.basename(self.url),\\n File(open(result[0], 'rb')),\\n )\\n self.save()\",\n \"def download(name, cache_dir=os.path.join('..', 'data')): #@save\\n assert name in DATA_HUB, f\\\"{name} does not exist in {DATA_HUB}.\\\"\\n url, sha1_hash = DATA_HUB[name]\\n d2l.mkdir_if_not_exist(cache_dir)\\n fname = os.path.join(cache_dir, url.split('/')[-1])\\n if os.path.exists(fname):\\n sha1 = hashlib.sha1()\\n with open(fname, 'rb') as f:\\n while True:\\n data = f.read(1048576)\\n if not data:\\n break\\n sha1.update(data)\\n if sha1.hexdigest() == sha1_hash:\\n return fname # Hit cache\\n print(f'Downloading {fname} from {url}...')\\n r = requests.get(url, stream=True, verify=True)\\n with open(fname, 'wb') as f:\\n f.write(r.content)\\n return fname\",\n \"def write_data(data):\\r\\n\\r\\n db = open(os.getcwd() + \\\"/www/access_list.txt\\\", 'w')\\r\\n json.dump(dict(data), db)\",\n \"def flush_to_disk(self):\\n logger.info(\\\"Flushing %s queries from in-memory cache to disk\\\", len(self.batch_writes))\\n rows = self.memory_connection.execute(f\\\"\\\"\\\"\\n SELECT hash_id, query, raw_query, domain, intent FROM queries\\n WHERE rowid IN ({\\\",\\\".join(self.batch_writes)});\\n \\\"\\\"\\\")\\n self.disk_connection.executemany(\\\"\\\"\\\"\\n INSERT OR IGNORE into queries values (?, ?, ?, ?, ?);\\n \\\"\\\"\\\", rows)\\n self.disk_connection.commit()\\n self.batch_writes = []\",\n \"def save_to_users(self):\\n Data.add_data(self.user_data())\",\n \"def save_public_keys(self, user, path=None):\\n # Redis has an end_cursor if we've collected this data before\\n end_cursor = self.redis.get(''.join(['gh:', user.login, ':publicKeys:endCursor']))\\n if end_cursor:\\n end_cursor = end_cursor.decode('utf-8')\\n end_cursor = ''.join(['\\\"', end_cursor, '\\\"'])\\n public_keys = u.publicKeys(first=100, after=end_cursor)\\n else:\\n public_keys = u.publicKeys(first=100)\\n\\n if not public_keys:\\n return False\\n\\n while True:\\n if public_keys['data']['user']['publicKeys']['edges']:\\n index = ''.join(['gh_public_keys-', self.timestamp])\\n self._write_to_datastore(index=index,\\n doc_type='GithubPublicKeys',\\n document=public_keys,\\n login=user.login,\\n path=path)\\n has_next_page = public_keys['data']['user']['publicKeys']['pageInfo']['hasNextPage']\\n end_cursor = public_keys['data']['user']['publicKeys']['pageInfo']['endCursor']\\n if has_next_page:\\n public_keys = u.publicKeys(first=100, after=end_cursor)\\n else:\\n # Cache the end_cursor where we last collected data\\n self.redis.set(''.join(['gh:', u.login, ':publicKeys:endCursor']), end_cursor)\\n break\\n else:\\n break\\n\\n return True\",\n \"def cleanPMUserCache(cache):\\n\\n removeUser = []\\n now = int(time.time())\\n\\n for user, utime in cache.items():\\n if now > utime:\\n log.debug(\\\"removing author %s from recent list\\\", user)\\n removeUser.append(user)\\n\\n for ku in removeUser:\\n del cache[ku]\",\n \"def SaveData(self):\\n \\n try:\\n with open(self.users_file, 'r+') as outfile:\\n json.dump(self.user_db, outfile, indent=4)\\n outfile.truncate()\\n except:\\n messagebox.showerror('Error',\\n f'{self.users_file} could not be accessed.' \\\\\\n 'New user information won\\\\'t be saved')\",\n \"def prepare_cache_data() -> None:\\n logger.debug(\\\"Downloading chromium\\\")\\n if os.path.exists(LOCAL_CHROMIUM_PATH):\\n return None\\n s3 = S3()\\n logger.debug(\\\"Check that remote folder exists:\\\")\\n if not s3.is_exists(bucket=CACHE_BUCKET, key=\\\"local-chromium\\\"):\\n s3.download_directory(bucket=CACHE_BUCKET,\\n key=\\\"local-chromium\\\",\\n dst=os.path.dirname(LOCAL_CHROMIUM_PATH))\\n logger.debug(\\\"Downloading Done!!!\\\")\",\n \"def write_new():\\n if User.new_users:\\n print(\\\"Creando nuevos usuarios {}\\\".format(User.new_users))\\n with open(User.get_users_path(), 'a', encoding='utf8') as file:\\n for username, user in User.new_users.items():\\n print(\\\" Usuario {}\\\".format(user))\\n user.create_user_file()\\n user.write(file=file)\",\n \"def __cache_chords(song_name, artist, UG_song_name, UG_artist, UG_url, UG_chords):\\n # Cache the results\\n with open(__cache_path(song_name, artist), \\\"w+\\\") as cache_file:\\n cache_dump = {\\n \\\"UltimateGuitar-song_name\\\": UG_song_name,\\n \\\"UltimateGuitar-artist\\\": UG_artist,\\n \\\"UltimageGuitar-song_url\\\": UG_url,\\n \\\"Chords\\\": UG_chords\\n }\\n json.dump(cache_dump, cache_file, indent=4)\",\n \"def write_data(self):\\n\\n data_string = \\\"%s, %d, %d, %s\\\\n\\\" % (\\n self.name, self.repos, self.members, self.created)\\n\\n file_path = os.path.join(os.path.dirname(__file__), self.data_file)\\n\\n with open(os.path.abspath(file_path), 'a') as f:\\n f.write(data_string)\",\n \"def save_redis_to_file() -> None:\\n with get_redis_instance() as redis:\\n try:\\n collected = json.loads(redis.get('corona-database').decode())\\n except AttributeError:\\n return\\n write_to_csv(collected)\",\n \"def flush_cache(self):\\n if self.cache_modified:\\n self.cache_manager.write(self.cache_file, self.cache)\",\n \"def write_cache_file_list(self, file_list=None):\\n if file_list:\\n self.add_filelist_to_cache(file_list)\\n cache_list = []\\n for finfo in self.cache_file_list_dict.values():\\n cache_list.append(finfo.output_cache_tuple())\\n return self.write_pickle_object_to_file(tuple(cache_list))\",\n \"def write_user_data(accounts, budget):\\n\\n print('Your Accounts\\\\n------------------------\\\\n\\\\n')\\n\\n for idx, account in enumerate(accounts):\\n account_values = {\\n 'idx': idx,\\n 'name': account['accountName'],\\n 'display_name': account['fiLoginDisplayName'],\\n 'currentBalance': account['currentBalance']\\n }\\n print('{idx}: {name} ({display_name}) {currentBalance}'.format_map(account_values))\\n\\n account_indicies = input('\\\\n\\\\nSelect an account by number. Use commas for multiple accounts (e.g. 1, 9): ')\\n\\n print('\\\\nYour current expense budget (from Mint): {0}\\\\n\\\\n'.format(int(get_expenses(budget))))\\n monthly_expenses = input('\\\\nInput your monthly expenses: ')\\n account_indicies = map(lambda x: int(x), account_indicies.split(','))\\n monthly_expenses = float(monthly_expenses)\\n\\n user_data = {\\n 'account_ids': [accounts[idx]['accountId'] for idx in account_indicies],\\n 'monthly_expenses': monthly_expenses\\n }\\n\\n with open(get_user_data_path(), 'w') as outfile:\\n json.dump(user_data, outfile)\\n\\n return user_data\",\n \"def save_watching(self, user, path=None):\\n # Redis has an end_cursor if we've collected this data before\\n end_cursor = self.redis.get(''.join(['gh:', user.login, ':watching:endCursor']))\\n if end_cursor:\\n end_cursor = end_cursor.decode('utf-8')\\n end_cursor = ''.join(['\\\"', end_cursor, '\\\"'])\\n watching = u.watching(first=100,\\n after=end_cursor,\\n orderBy='{direction: DESC, field: CREATED_AT}')\\n else:\\n watching = u.watching(first=100,\\n orderBy='{direction: DESC, field: CREATED_AT}')\\n\\n if not watching:\\n return False\\n\\n while True:\\n if watching['data']['user']['watching']['edges']:\\n index = ''.join(['gh_watching-', self.timestamp])\\n self._write_to_datastore(index=index,\\n doc_type='GithubWatching',\\n document=watching,\\n login=user.login,\\n path=path)\\n has_next_page = watching['data']['user']['watching']['pageInfo']['hasNextPage']\\n end_cursor = watching['data']['user']['watching']['pageInfo']['endCursor']\\n if has_next_page:\\n watching = u.watching(first=100,\\n after=end_cursor,\\n orderBy='{direction: DESC, field: CREATED_AT}')\\n else:\\n # Cache the end_cursor where we last collected data\\n self.redis.set(''.join(['gh:', u.login, ':watching:endCursor']), end_cursor)\\n break\\n else:\\n break\\n\\n return True\",\n \"def save_user(username, data):\\n\\n hashed_username = base64.b64encode(Cryptography.hash(username).digest()).decode()\\n\\n file = open(getcwd() + Database.__DB_FILENAME, 'a')\\n iv, ciphered_data = Cryptography.cipher(Cryptography.get_passphrase(), data)\\n file.write(hashed_username + ':' + ciphered_data.hex() + '.' + iv.hex() + '\\\\n')\\n file.flush()\\n file.close()\",\n \"def cache_sweep_results(\\n sr: Union[OSweepResults, OMultiSweepResult], file_name: str\\n ):\\n if not file_name.endswith(\\\".json\\\"):\\n file_name += \\\".json\\\"\\n\\n if not os.path.exists(CacheManagerSingleton.SWEEP_RESULTS_PATH):\\n os.mkdir(CacheManagerSingleton.SWEEP_RESULTS_PATH)\\n\\n if sr.sweep_args is not None:\\n sr.sweep_args = None\\n\\n with open(\\n os.path.join(CacheManagerSingleton.SWEEP_RESULTS_PATH, file_name), \\\"w\\\"\\n ) as f:\\n f.write(sr.json(indent=2))\",\n \"def fetch_anime_metadata(jikan, user_animes, force, rate_limit):\\n for anime in user_animes:\\n metadata_fpath = os.path.join(ANIMEDIR, f\\\"{anime['mal_id']}.json\\\")\\n cache_exists = os.path.exists(metadata_fpath) and os.path.isfile(metadata_fpath)\\n if force or not cache_exists:\\n print(f\\\"Saving metadata for: {anime['title']}\\\")\\n anime_metadata = jikan.anime(anime[\\\"mal_id\\\"])\\n with open(metadata_fpath, \\\"w\\\") as fptr:\\n json.dump(anime_metadata, fptr)\\n time.sleep(rate_limit)\\n else:\\n print(f\\\"Skipping already cached metadata for: {anime['title']}\\\")\",\n \"def flush_all_owners_data_cache():\\n from base import get_group_database\\n \\n group_db = get_group_database()\\n \\n for group_id, group in group_db.root.iteritems():\\n for user in group.owners:\\n flush_user_data_cache(user)\",\n \"def _mock_write_cache(self, pipeline, values, cache_key):\\n labels = ['full', cache_key]\\n\\n # Usually, the pcoder will be inferred from `pcoll.element_type`\\n pcoder = coders.registry.get_coder(object)\\n cache_manager = ie.current_env().get_cache_manager(pipeline)\\n cache_manager.save_pcoder(pcoder, *labels)\\n cache_manager.write(values, *labels)\",\n \"def save(searches):\\n # type: (list) -> None\\n with Cache(CACHE_URI) as c:\\n c.set(SAVED_SEARCH, json.dumps(searches, ensure_ascii=False))\",\n \"def cache_file(self, repo):\\n token = blake2b(repo.location.encode()).hexdigest()[:10]\\n dirname = f\\\"{repo.repo_id.lstrip(os.sep)}-{token}\\\"\\n return pjoin(self.options.cache_dir, \\\"repos\\\", dirname, self.cache.file)\",\n \"def cache_matrio_data(filename):\\n prefix = \\\"https://data.matr.io/3/api/v1/file\\\"\\n key = MATRIO_DATA_KEYS[filename]\\n if not os.path.isfile(filename):\\n cache_download(\\\"{}/{}/download\\\".format(prefix, key), filename)\",\n \"def setup_cache(self):\\n train_cache_path = self.cache.get_cache_path_and_check(TRAIN_STR, self.task_name)\\n dev_cache_path = self.cache.get_cache_path_and_check(DEV_STR, self.task_name)\\n test_cache_path = self.cache.get_cache_path_and_check(TEST_STR, self.task_name)\\n\\n self.train_cache_writer = None\\n self.dev_cache_writer = None\\n self.test_cache_writer = None\\n\\n if os.path.exists(train_cache_path):\\n f = h5py.File(train_cache_path, 'r')\\n self.train_cache = (torch.tensor(f[str(i)][()]) for i in range(len(f.keys())))\\n else:\\n self.train_cache_writer = h5py.File(train_cache_path, 'w')\\n if os.path.exists(dev_cache_path):\\n f2 = h5py.File(dev_cache_path, 'r')\\n self.dev_cache = (torch.tensor(f2[str(i)][()]) for i in range(len(f2.keys())))\\n else:\\n self.dev_cache_writer = h5py.File(dev_cache_path, 'w')\\n if os.path.exists(test_cache_path):\\n f3 = h5py.File(test_cache_path, 'r')\\n self.test_cache = (torch.tensor(f3[str(i)][()]) for i in range(len(f3.keys())))\\n else:\\n self.test_cache_writer = h5py.File(test_cache_path, 'w')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65254027","0.6457006","0.6325532","0.6226892","0.61698765","0.6146631","0.6111177","0.6007813","0.5938739","0.59114945","0.58837384","0.5855156","0.57993","0.5761495","0.57532364","0.57507557","0.5726013","0.5722801","0.57184774","0.57181704","0.57024366","0.5657278","0.5621519","0.5583784","0.55503136","0.5545596","0.5535168","0.550273","0.54963475","0.5488452","0.54867226","0.54830277","0.5444101","0.54235893","0.54103553","0.53956664","0.5383457","0.53816223","0.5340716","0.5331928","0.53106064","0.52945346","0.52932125","0.529182","0.5216447","0.5195884","0.5188599","0.51860565","0.51718366","0.51635617","0.51630056","0.5159203","0.5144856","0.51424503","0.5134334","0.51307","0.5114248","0.511035","0.51044124","0.51019484","0.50984347","0.5093819","0.5087512","0.5087512","0.5069911","0.50500727","0.50464135","0.50440514","0.50429976","0.504111","0.50400156","0.5025113","0.5019105","0.5007408","0.5003419","0.5001113","0.4997366","0.49845827","0.49823833","0.4982195","0.4969001","0.49591383","0.4955316","0.49529216","0.4950051","0.49484026","0.4945159","0.49369296","0.49366322","0.4908154","0.4905354","0.49000695","0.48933992","0.48912448","0.48907748","0.48905346","0.48783627","0.48726553","0.4871078","0.48685566"],"string":"[\n \"0.65254027\",\n \"0.6457006\",\n \"0.6325532\",\n \"0.6226892\",\n \"0.61698765\",\n \"0.6146631\",\n \"0.6111177\",\n \"0.6007813\",\n \"0.5938739\",\n \"0.59114945\",\n \"0.58837384\",\n \"0.5855156\",\n \"0.57993\",\n \"0.5761495\",\n \"0.57532364\",\n \"0.57507557\",\n \"0.5726013\",\n \"0.5722801\",\n \"0.57184774\",\n \"0.57181704\",\n \"0.57024366\",\n \"0.5657278\",\n \"0.5621519\",\n \"0.5583784\",\n \"0.55503136\",\n \"0.5545596\",\n \"0.5535168\",\n \"0.550273\",\n \"0.54963475\",\n \"0.5488452\",\n \"0.54867226\",\n \"0.54830277\",\n \"0.5444101\",\n \"0.54235893\",\n \"0.54103553\",\n \"0.53956664\",\n \"0.5383457\",\n \"0.53816223\",\n \"0.5340716\",\n \"0.5331928\",\n \"0.53106064\",\n \"0.52945346\",\n \"0.52932125\",\n \"0.529182\",\n \"0.5216447\",\n \"0.5195884\",\n \"0.5188599\",\n \"0.51860565\",\n \"0.51718366\",\n \"0.51635617\",\n \"0.51630056\",\n \"0.5159203\",\n \"0.5144856\",\n \"0.51424503\",\n \"0.5134334\",\n \"0.51307\",\n \"0.5114248\",\n \"0.511035\",\n \"0.51044124\",\n \"0.51019484\",\n \"0.50984347\",\n \"0.5093819\",\n \"0.5087512\",\n \"0.5087512\",\n \"0.5069911\",\n \"0.50500727\",\n \"0.50464135\",\n \"0.50440514\",\n \"0.50429976\",\n \"0.504111\",\n \"0.50400156\",\n \"0.5025113\",\n \"0.5019105\",\n \"0.5007408\",\n \"0.5003419\",\n \"0.5001113\",\n \"0.4997366\",\n \"0.49845827\",\n \"0.49823833\",\n \"0.4982195\",\n \"0.4969001\",\n \"0.49591383\",\n \"0.4955316\",\n \"0.49529216\",\n \"0.4950051\",\n \"0.49484026\",\n \"0.4945159\",\n \"0.49369296\",\n \"0.49366322\",\n \"0.4908154\",\n \"0.4905354\",\n \"0.49000695\",\n \"0.48933992\",\n \"0.48912448\",\n \"0.48907748\",\n \"0.48905346\",\n \"0.48783627\",\n \"0.48726553\",\n \"0.4871078\",\n \"0.48685566\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60137564"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":21994,"cells":{"query":{"kind":"string","value":"Get the \"userignored\" Rez packages."},"document":{"kind":"string","value":"def _split_the_ignored_packages(packages, patterns):\n ignored = set()\n non_ignored = set()\n\n for package in packages:\n for pattern in patterns:\n if fnmatch.fnmatch(package.name, pattern):\n ignored.add((package, pattern))\n\n break\n else:\n non_ignored.add(package)\n\n return ignored, non_ignored"},"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 getusersitepackages():\n\tpass","def packages(self):\n return []","def user_packages(self, host: (str), user: (str)) -> Any:\n return search_api(\"user_packages\", host, user)","def get_packages():\n\n packages = find_packages()\n packages = ['{}.{}'.format('uniq', package) for package in packages]\n packages.append('uniq')\n return packages","def _print_ignored(packages):\n if not packages:\n print(\"## No Rez package was set to be ignored\")\n print(\"No data found\")\n\n return\n\n print(\"## Every package in this list was explicitly set to ignored by the user\")\n\n for package, pattern in sorted(packages, key=_get_package_name):\n print(\n 'Package: {package.name} - Pattern: \"{pattern}\"'.format(\n package=package, pattern=pattern\n )\n )","def ignore_from_package(self, project, package, arch, ignore):\n for binary in binary_list(self.apiurl, project, 'standard', arch, package):\n ignore.add(binary.name)\n\n return ignore","def get_not_installed_rpm_packages():\n def is_installed(elem):\n return elem in PMDK_TOOLS and elem in listdir('/usr/bin/') or\\\n elem == \"pmdk\" or elem + '.so' in listdir('/usr/lib64/')\n\n elements = get_libraries_names()\n not_installed_packages = []\n for elem in elements:\n if not is_installed(elem):\n not_installed_packages.append(elem)\n return not_installed_packages","def getIgnoredPlugins(self):\n return self.yaml.getIgnoredPlugins()","def packages(self):\r\n return self._packages","def GetUnknownFiles(self):\n args = []\n status = RunShell([\"hg\", \"status\", \"--rev\", self.base_rev, \"-u\", \".\"],\n silent_ok=True)\n unknown_files = []\n for line in status.splitlines():\n st, fn = line.split(\" \", 1)\n if st == \"?\":\n unknown_files.append(fn)\n return unknown_files","def GetUnknownFiles(self):\r\n args = []\r\n status = RunShell([\"hg\", \"status\", \"--rev\", self.base_rev, \"-u\", \".\"],\r\n silent_ok=True)\r\n unknown_files = []\r\n for line in status.splitlines():\r\n st, fn = line.split(\" \", 1)\r\n if st == \"?\":\r\n unknown_files.append(fn)\r\n return unknown_files","def _filter_pkgs(self, pkgs):\n pkgs = [pkg.strip() for pkg in pkgs]\n return [\n pkg for pkg in pkgs\n if pkg.startswith(self.base_pkg) and not pkg.startswith(os.path.join(self.base_pkg, \"vendor/\"))\n ]","def get_package_list():\n pip_freeze = subprocess.check_output(('pip', 'freeze')).decode('utf8')\n package_list = [x.strip().split('==') for x in pip_freeze.split('\\n') if x.find('==') != -1]\n package_list = [(x[0].lower(), x[1]) for x in package_list]\n return package_list","def get_ignored_packages_names(ign_packages_names: Sequence[str], ign_groups_names: Sequence[str],\n upstream_system: 'System', installed_system: 'System',\n do_everything: bool = False) -> Set[str]:\n handler = PacmanConfig(conf=\"/etc/pacman.conf\").initialize_alpm()\n\n # ignored packages names - may contain glob patterns\n names_to_ignore = set(handler.ignorepkgs)\n for ign_packages_name in ign_packages_names:\n for name in ign_packages_name.split(\",\"):\n names_to_ignore.add(name)\n\n # ignored groups names\n ignored_groups_names = set(handler.ignoregrps)\n for ign_groups_name in ign_groups_names:\n for name in ign_groups_name.split(\",\"):\n ignored_groups_names.add(name)\n\n # contains the concrete packages names to ignore\n return_set = set()\n\n # check globbing\n packages_names = [package_name for package_name in upstream_system.all_packages_dict]\n for possible_glob in names_to_ignore:\n return_set |= set(fnmatch.filter(packages_names, possible_glob))\n # allow non upstream packages to be ignored, too - needed for correct replaces behavior\n if do_everything:\n packages_names = [package_name for package_name in installed_system.all_packages_dict]\n for possible_glob in names_to_ignore:\n return_set |= set(fnmatch.filter(packages_names, possible_glob))\n\n if not ignored_groups_names:\n return return_set\n\n # fetch packages names of groups to ignore\n for package_name in packages_names:\n package = upstream_system.all_packages_dict[package_name]\n # check groups\n for package_group in package.groups:\n if package_group in ignored_groups_names:\n return_set.add(package_name)\n\n return return_set","def getsitepackages():\n\tpass","def ignore_services(self) -> List[str]:\n return self.data.get(\"ignore_services\", [])","def _extract_r_remove_package_names(log):\n start = \"remove.packages(c(\"\n i_start = log.find(start) + len(start)\n i_end = log.find(\")\", i_start)\n package_names = [name.strip('\"') for name in log[i_start:i_end].split(\",\")]\n return package_names","def ignore_from_repo(self, directory, ignore):\n for filename in os.listdir(directory):\n if not filename.endswith('.rpm'):\n continue\n _, basename = filename.split('-', 1)\n ignore.add(basename[:-4])","def getInstalledPackages():\n reqs = subprocess.check_output([sys.executable,\n '-m', 'pip', 'freeze'])\n installed_packages = [r.decode().split('==')[0]\n for r in reqs.split()]\n return installed_packages","def list_packages():\n\n shelf_dir = settings.shelf_dir\n\n package_list = os.listdir(shelf_dir)\n\n package_list.sort()\n\n return package_list","def _get_ignore_list(self) -> List[str]:\n if not self.exists():\n return []\n if self._file_exists():\n with open(self._path, \"r\", encoding=DefaultOpenEncoding.READ) as fh:\n return [line.rstrip() for line in fh if line]\n return []","def available_modules(self, user):\n return [sitecomp for sitecomp in self.enabled_modules() if sitecomp.has_perm(user)]","def isIgnoredPkg(self, *args):\n return _libsbml.SBMLDocument_isIgnoredPkg(self, *args)","def ignores(self):\n return self._ignores","def __gather_package_data(arguments):\n ignore_patterns, packages_path, search_packages_path = _resolve_arguments(\n arguments.ignore_patterns,\n arguments.packages_path,\n arguments.search_packages_path,\n )\n rez_packages = set(arguments.rez_packages)\n\n package_finder = registry.get_package_finder(arguments.command)\n\n found_packages = []\n packages, invalid_packages, skips = package_finder(\n paths=packages_path + search_packages_path\n )\n\n for package in packages:\n if rez_packages and package.name not in rez_packages:\n skips.append(package)\n else:\n found_packages.append(package)\n\n ignored_packages, other_packages = _split_the_ignored_packages(\n found_packages, ignore_patterns\n )\n\n other_packages = sorted(other_packages, key=operator.attrgetter(\"name\"))\n\n return ignored_packages, other_packages, invalid_packages, skips","def get_packages(self):\n packages = []\n for obj in self.objects_used:\n packages.extend(obj.get_packages())\n # Remove duplicates (not necessary but it's cleaner)\n packages = list(set(packages))\n return packages","def _filter_installed_packages(self, packages):\n filtered_packages = []\n for package in packages:\n name = package.name\n for installed in self._top_installed_repository.find_packages(name):\n if installed.key == package.key:\n break\n else:\n filtered_packages.append(package)\n return filtered_packages","def installed_nginx_packages(self):\n result = {}\n dpkg_grep_nginx_out, _ = subp.call(\"dpkg -l | grep nginx\")\n for line in dpkg_grep_nginx_out:\n gwe = re.match(self.dpkg_l_re, line)\n if gwe:\n if gwe.group(2).startswith('nginx'):\n result[gwe.group(2)] = gwe.group(3)\n return result","def get_packages_with_prefixes():\n return get_resources('packages')","def get_suspect_packages():\n with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'gistfile1.txt'), 'r') as f:\n return map(lambda line: line.strip(), f.readlines())","def ignore(ui, repo, *user_files, **opts):\n # The doc string below will show up in hg help.\n\n use_glob = opts.get('globs')\n # Use HG API call to get all files in state \"unknown\". Those are relative to the repo root\n unknown_files = repo.status(unknown=True)[4]\n # Bring user-given file names into the \"relative-to-HG-root\" format\n files_absolute = [ os.path.realpath(p) for p in user_files ]\n files = [ os.path.relpath(p, repo.root) for p in files_absolute ]\n\n # Check if ignore file exists, otherwise create it\n ignore_filename = os.path.normpath(os.path.join(repo.root, \".hgignore\"))\n try:\n with open(ignore_filename, \"a\") as f: pass\n except:\n with open(ignore_filename, \"w\") as f: f.write()\n\n # Check if the files given on the command line are really unknown to HG\n already_ignored = set()\n if use_glob:\n for f in files:\n if is_already_ignored(f, ignore_filename):\n ui.write(\"Pattern %s is already active.\\n\" % (f,))\n already_ignored.add(f)\n else:\n for f in files:\n if os.path.isdir(f):\n # Directories are not tracked, but we want to add them to .hgignore, anyway. \n continue\n if f not in unknown_files:\n if is_already_ignored(f, ignore_filename):\n ui.write(\"File %s is already ignored.\\n\" % (f,))\n already_ignored.add(f)\n else:\n raise util.Abort(\"File %s is not in state UNKNOWN.\" % (f,))\n\n # Prepare list of files to be ignored in .hgignore line-by-line syntax\n ignores = \"\"\n for f in (set(files) - already_ignored):\n ignores += f\n ignores += '\\n'\n if len(ignores):\n ui.write(\"Ignored:\\n%s\" % (ignores,))\n\n # Search for the glob section in .hgignore; when found, insert filenames after\n found_glob_section = False\n for line in fileinput.input(ignore_filename, inplace=True, mode=\"rU\"):\n if re.match(\"^syntax:.*glob\", line):\n sys.stdout.write(line)\n sys.stdout.write(ignores)\n found_glob_section = True\n else:\n sys.stdout.write(line)\n\n # No \"syntax: glob\" section in .hgignore file found -> create one\n if not found_glob_section:\n with open(ignore_filename, \"a\") as ignore_file:\n ignore_file.write(\"syntax: glob\\n\")\n ignore_file.write(ignores)","def getMissingLangPacks(self):\n missing = []\n for langInfo in self._cache.getLanguageInformation():\n #print langInfo.languageCode\n trans_package = \"language-pack-%s\" % langInfo.languageCode\n # we have a langpack installed, see if we have all of them\n if (self._cache.has_key(trans_package) and \n self._cache[trans_package].isInstalled):\n #print \"IsInstalled: %s \" % trans_package\n for (pkg, translation) in self._cache.pkg_translations:\n missing += self.missingTranslationPkgs(pkg, translation+langInfo.languageCode)\n\n # now check for a missing default language support\n default_lang = self.getSystemDefaultLanguage()\n # if there is no default lang, return early\n if default_lang is None:\n return missing\n if \"_\" in default_lang:\n default_lang = default_lang.split(\"_\")[0]\n trans_package = \"language-pack-%s\" % default_lang\n if (self._cache.has_key(trans_package) and \n not self._cache[trans_package].isInstalled):\n missing += [trans_package]\n for (pkg, translation) in self._cache.pkg_translations:\n missing += self.missingTranslationPkgs(pkg, translation+default_lang)\n support_packages = LanguageSelectorPkgCache._getPkgList(self._cache, default_lang)\n for support_package in support_packages:\n if (self._cache.has_key(support_package) and \n not self._cache[support_package].isInstalled):\n missing.append(support_package)\n\n return missing","def get_blocked_usernames_list():\n return []","def get_ignored_dirs(ci_ignore_path):\n with open(ci_ignore_path, 'r') as ignore_file:\n return set([\n normpath(line.strip())\n for line in ignore_file.readlines()\n if not line.startswith('#') and not is_blank(line)\n ])","def _get_ignored_payloads():\n ignored_payloads = os.environ.get('EPSAGON_PAYLOADS_TO_IGNORE')\n if ignored_payloads:\n return json.loads(ignored_payloads)\n\n return []","def get_packages(package):\n return [str(path.parent) for path in Path(package).glob(\"**/__init__.py\")]","def _remove_extra_packages(frozen_pkgs, ret, **kwargs):\n pkgs = __salt__[\"pkg.list_pkgs\"](**kwargs)\n extra_pkgs = set(pkgs) - set(frozen_pkgs)\n for pkg in extra_pkgs:\n try:\n __salt__[\"pkg.remove\"](name=pkg, **kwargs)\n ret[\"pkgs\"][\"remove\"].append(pkg)\n log.info(\"Removed extra package %s\", pkg)\n except Exception as e: # pylint: disable=broad-except\n msg = \"Error removing %s package: %s\"\n log.error(msg, pkg, e)\n ret[\"comment\"].append(msg % (pkg, e))","def get_packages_in_current_dir() -> list:\n from os import listdir\n\n pkgs = []\n ext = ('.tgz', '.txz')\n for file_in_current_dir in sorted(listdir()):\n if file_in_current_dir.endswith(ext):\n pkgs.append(file_in_current_dir)\n\n return pkgs","def getMissingPackages(self, language=None, all=False, packages=None, showInstalled=False):\n if self._cache.broken_count > 0:\n raise SoftwareIndexBroken\n \n self.langpack_locales = {}\n self.pkg_translations = {}\n self.pkg_writing = {}\n filter_list = {}\n blacklist = []\n show = []\n self.missing = set()\n self.installed = set()\n self.system_pkgcode = ''\n \n for l in open(self.BLACKLIST):\n l = l.strip()\n if not l.startswith('#'):\n blacklist.append(l)\n \n for l in open(self.LANGCODE_TO_LOCALE):\n try:\n l = l.rstrip()\n if ':' in l:\n (pkgcode, locale) = l.split(':')\n else:\n pkgcode = l\n locale = l\n except ValueError:\n continue\n self.langpack_locales[locale] = pkgcode\n \n for l in open(self.PACKAGE_DEPENDS):\n if l.startswith('#'):\n continue\n try:\n l = l.rstrip()\n # sort out comments\n if l.find('#') >= 0:\n continue\n (c, lc, k, v) = l.split(':')\n except ValueError:\n continue\n if (c == 'tr' and lc == ''):\n filter_list[v] = k\n elif (c == 'wa' and lc != ''):\n if '|' in lc:\n for l in lc.split('|'):\n if not l in self.pkg_writing:\n self.pkg_writing[l] = []\n self.pkg_writing[l].append((\"%s\" % k, \"%s\" % v))\n else:\n if not lc in self.pkg_writing:\n self.pkg_writing[lc] = []\n self.pkg_writing[lc].append((\"%s\" % k, \"%s\" % v))\n\n # get list of all packages available on the system and filter them\n for item in self._cache.keys():\n if item in blacklist: \n continue\n for x in filter_list.keys():\n if item.startswith(x) and not item.endswith('-base'):\n # parse language code\n langcode = item.replace(x, '')\n #print \"%s\\t%s\" % (item, langcode)\n if langcode == 'zh':\n # special case: zh langpack split\n for langcode in ['zh-hans', 'zh-hant']:\n if not langcode in self.pkg_translations:\n self.pkg_translations[langcode] = []\n self.pkg_translations[langcode].append((\"%s\" % filter_list[x], \"%s\" % item))\n elif langcode in self.langpack_locales.values():\n # langcode == pkgcode\n if not langcode in self.pkg_translations:\n self.pkg_translations[langcode] = []\n self.pkg_translations[langcode].append((\"%s\" % filter_list[x], \"%s\" % item))\n #print self.pkg_translations[langcode]\n else:\n # need to scan for LL-CC and LL-VARIANT codes\n for locale in self.langpack_locales.keys():\n if '_' in locale or '@' in locale:\n if '@' in locale:\n (locale, variant) = locale.split('@')\n else:\n variant = ''\n (lcode, ccode) = locale.split('_')\n if langcode in [\"%s-%s\" % (lcode, ccode.lower()),\n \"%s%s\" % (lcode, ccode.lower()),\n \"%s-%s\" % (lcode, variant),\n \"%s%s\" % (lcode, variant),\n \"%s-latn\" % lcode,\n \"%slatn\" % lcode,\n \"%s-%s-%s\" % (lcode, ccode.lower(), variant),\n \"%s%s%s\" % (lcode, ccode.lower(), variant)]:\n # match found, get matching pkgcode\n langcode = self.langpack_locales[locale]\n if not langcode in self.pkg_translations:\n self.pkg_translations[langcode] = []\n self.pkg_translations[langcode].append((\"%s\" % filter_list[x], \"%s\" % item))\n #print self.pkg_translations[langcode]\n break\n\n if language:\n pkgcode = ''\n if language == 'zh-hans' or language == 'zh-hant':\n self.system_pkgcode = language\n elif language in self.langpack_locales:\n self.system_pkgcode = self.langpack_locales[language]\n else:\n # pkgcode = ll\n if '_' in language:\n (self.system_pkgcode) = language.split('_')[0]\n elif '@' in language:\n (self.system_pkgcode) = language.split('@')[0]\n else:\n self.system_pkgcode = language\n\n if packages:\n self.findPackages(self.system_pkgcode, packages)\n else:\n self.findPackages(self.system_pkgcode)\n \n elif all:\n # try all available languages\n pkgcodes = []\n for item in self._cache.keys():\n if item in blacklist:\n continue\n if item.startswith('language-pack-') and \\\n not item.startswith('language-pack-gnome') and \\\n not item.startswith('language-pack-kde') and \\\n not item.endswith('-base'):\n pkgcode = item.replace('language-pack-', '')\n pkgcodes.append(pkgcode)\n\n for pkgcode in pkgcodes:\n if packages:\n self.findPackages(pkgcode, packages)\n else:\n self.findPackages(pkgcode)\n\n else:\n # get a list of language-packs we have already installed or are going to install\n # 1. system locale\n system_langcode = self._localeinfo.getSystemDefaultLanguage()[0]\n if system_langcode == None:\n system_langcode = 'en_US'\n if system_langcode in self.langpack_locales:\n self.system_pkgcode = self.langpack_locales[system_langcode]\n # 2. installed language-packs\n pkgcodes = []\n for item in self._cache.keys():\n if item in blacklist: \n continue\n if item.startswith('language-pack-') and \\\n not item.startswith('language-pack-gnome') and \\\n not item.startswith('language-pack-kde') and \\\n not item.endswith('-base') and \\\n (self._cache[item].is_installed or \\\n self._cache[item].marked_install):\n pkgcode = item.replace('language-pack-', '')\n pkgcodes.append(pkgcode)\n if self.system_pkgcode and \\\n not self.system_pkgcode in pkgcodes:\n pkgcodes.append(self.system_pkgcode)\n \n for pkgcode in pkgcodes:\n if packages:\n self.findPackages(pkgcode, packages)\n else:\n self.findPackages(pkgcode)\n \n if showInstalled:\n show = self.missing | self.installed\n else:\n show = self.missing\n\n return show","def getuserrepos_keys(gh, user):\n repos = getuserrepos(gh, user)\n return repos[0].keys()","def get_incompatible_packages():\n pkgconfig_directory = '/usr/lib64/pkgconfig/'\n incompatibe_packages = []\n libraries = get_libraries_names() - set(NO_PKG_CONFIGS)\n for library in libraries:\n with open(pkgconfig_directory + library + '.pc') as f:\n out = f.readlines()\n for line in out:\n if 'version=' in line:\n version = line.split('=')[1].strip(linesep)\n if not version in PMDK_VERSION.replace('~', '-'):\n incompatibe_packages.append(library)\n return incompatibe_packages","def extra_removed_packages(self, index: int) -> Packages:\n log = self[index]\n if (\n not log.startswith(\"conda remove\")\n and not log.startswith(\"pip uninstall\")\n and not (log.startswith(R_COMMAND) and \"remove.packages\" in log)\n ):\n raise CondaEnvTrackerParseHistoryError(\n f\"The log at index {index} is not a remove statement: {self[index]}.\"\n )\n if log.startswith(\"conda remove\"):\n package_names = self._extract_conda_remove_package_names(log)\n elif log.startswith(\"pip uninstall\"):\n package_names = log.replace(\"pip uninstall \", \"\").split()\n else:\n package_names = self._extract_r_remove_package_names(log)\n return Packages.from_specs(package_names)","def get_installed_packages() -> List['Package']:\n repo_packages_names = set(expac(\"-S\", ['n'], []))\n\n # packages the user wants to install from aur\n aur_names = packages_from_other_sources()[0]\n repo_packages_names -= aur_names\n\n installed_packages_names = set(expac(\"-Q\", ['n'], []))\n installed_repo_packages_names = installed_packages_names & repo_packages_names\n unclassified_installed_names = installed_packages_names - installed_repo_packages_names\n\n return_list = []\n\n # installed repo packages\n if installed_repo_packages_names:\n return_list.extend(\n Package.get_packages_from_expac(\"-Q\", list(installed_repo_packages_names), PossibleTypes.REPO_PACKAGE)\n )\n\n # installed aur packages\n installed_aur_packages_names = set(\n [package.name for package in Package.get_packages_from_aur(list(unclassified_installed_names))]\n )\n\n # package names the user gave us must be in the aur\n for name in aur_names:\n if name not in installed_aur_packages_names:\n aurman_error(\"Package {} not found in AUR!\".format(Colors.BOLD(Colors.LIGHT_MAGENTA(name))))\n raise InvalidInput(\"Package {} not found in AUR!\".format(Colors.BOLD(Colors.LIGHT_MAGENTA(name))))\n\n if installed_aur_packages_names:\n return_list.extend(\n Package.get_packages_from_expac(\"-Q\", list(installed_aur_packages_names), PossibleTypes.AUR_PACKAGE)\n )\n\n unclassified_installed_names -= installed_aur_packages_names\n\n # installed not repo not aur packages\n if unclassified_installed_names:\n return_list.extend(\n Package.get_packages_from_expac(\n \"-Q\", list(unclassified_installed_names),\n PossibleTypes.PACKAGE_NOT_REPO_NOT_AUR\n )\n )\n\n return return_list","def get_user_icons(user):\n\tuser_perms = UserPermissions(user)\n\tuser_perms.build_permissions()\n\n\tfrom frappe.boot import get_allowed_pages\n\n\tallowed_pages = get_allowed_pages()\n\n\ticons = []\n\tfor icon in get_desktop_icons(user):\n\t\tadd = True\n\t\tif icon.hidden_in_standard:\n\t\t\tadd = False\n\n\t\tif not icon.custom:\n\t\t\tif icon.module_name == [\"Help\", \"Settings\"]:\n\t\t\t\tpass\n\n\t\t\telif icon.type == \"page\" and icon.link not in allowed_pages:\n\t\t\t\tadd = False\n\n\t\t\telif icon.type == \"module\" and icon.module_name not in user_perms.allow_modules:\n\t\t\t\tadd = False\n\n\t\tif add:\n\t\t\ticons.append(icon)\n\n\treturn icons","def users_excludeds(self) -> pulumi.Output[Optional[Sequence[str]]]:\n return pulumi.get(self, \"users_excludeds\")","def get_default_packages(rootfs, include_essential=False,\n include_priorities=None):\n if include_priorities is None:\n include_priorities = []\n\n package_list = set()\n\n list_dir = os.path.join(rootfs, 'var/lib/apt/lists')\n for filename in os.listdir(list_dir):\n if not filename.endswith('_Packages'):\n continue\n\n with open(os.path.join(list_dir, filename)) as infile:\n for pkg in rfc822_parse(infile):\n if 'Essential' in pkg and include_essential:\n package_list.add(pkg['Package'])\n continue\n if 'Priority' not in pkg:\n continue\n\n if pkg['Priority'] in include_priorities:\n package_list.add(pkg['Package'])\n\n return list(sorted(package_list))","def getAllInstalledPackages(installedPkgPath):\n allPkgVers = []\n if os.path.exists(installedPkgPath):\n for pkg in os.listdir(installedPkgPath):\n pkgVersions = os.listdir(os.path.join(installedPkgPath, pkg))\n for pkgVersion in pkgVersions:\n pkgPath = os.path.join(installedPkgPath, pkg)\n if not fnmatch.fnmatch(pkgVersion, '*.inprogress'):\n allPkgVers.append(os.path.join(pkgPath, pkgVersion))\n return allPkgVers","def retrieveIgnoredWords(self):\n words = self.con.getIgnoredWords()\n guilds = self.con.getGuildsInfo()\n\n for item in guilds:\n self.ignored[item.split(',')[0]] = []\n\n for word in words:\n data = word.split(',')\n self.ignored[data[0]].append(data[1])","def get_vul_info(vul_info):\n packages = []\n if vul_info.get('fixes') is None:\n return packages\n for fixes in vul_info['fixes']:\n packages.extend(get_package_os(fixes))\n return packages","def _extract_conda_remove_package_names(log):\n names = log.split(\"--name\")[-1].split()\n return names[1:]","def get_packages(root):\n root = os.path.realpath(root)\n proot = parent(root) + \"/\"\n py_files = [file.rsplit(proot)[1] for file in listfiles(root)]\n packages = list(np.unique([parent(file).replace(\"/\", \".\") for file in py_files]))\n # return list(np.unique([parent(file).replace(\"/\", \".\").split(\".{name_root}.\".format(name_root=name(root)))[1]\n # for file in py_files]))\n return packages","def getRpmBlacklist():\n global index\n enabledRpms = set()\n for stream in enabledStreams.values():\n enabledRpms = enabledRpms.union(stream.get_rpm_artifacts())\n\n allRpms = set()\n for name in index.get_module_names():\n module = index.get_module(name)\n for stream in module.get_all_streams():\n allRpms = allRpms.union(stream.get_rpm_artifacts())\n\n return list(allRpms.difference(enabledRpms))","def ignored_lists(self) -> List[str]:\n return self.__lists_to_ignore","def get_repo_packages() -> List['Package']:\n return Package.get_packages_from_expac(\"-S\", [], PossibleTypes.REPO_PACKAGE)","def get_installed_packages(cache=False,\n output_dir='.',\n output_filename='installed.pkgs.txt'):\n output = os.path.join(output_dir, output_filename)\n cmd = '''aptitude search '~i !~M' -F '%%p' | sort -u > %r''' % (\n output)\n ensure_file(cmd, output, shell=True, overwrite=not(cache))\n installed = list(read_lines(output))\n return installed","def get_fallback_packages(request, package_name):\n dists = request.locator.get_project(package_name)\n pkgs = {}\n for version, url_set in six.iteritems(dists.get('urls', {})):\n dist = dists[version]\n for url in url_set:\n filename = posixpath.basename(url)\n url = request.app_url('api', 'package', dist.name, filename)\n pkgs[filename] = url\n return pkgs","def get_non_vendor_package_path(aea_project_path: Path) -> Set[Path]:\n result: Set[Path] = set()\n for item_type_plural in ComponentType.plurals():\n nonvendor_package_dir_of_type = aea_project_path / item_type_plural\n result = result.union(\n {p for p in nonvendor_package_dir_of_type.iterdir() if p.is_dir()}\n if nonvendor_package_dir_of_type.exists()\n else {}\n )\n return result","def get_meals_user_disliked(username):\n meals_user_disliked = []\n user_disliked = Rating.objects.filter(member__username=username, like=False)\n for ratting in user_disliked:\n meals_user_disliked.append(ratting.meal)\n return meals_user_disliked","def get_all_package_ids(self):\n return self._package_cache.keys()","def libraries(self):\n\n status, stdout, stderr = self.__xcall__(['--libs-only-l'])\n\n if status != 0:\n raise RuntimeError(\"error querying --libs-only-l for package `%s': %s\" % (self.name, stderr))\n\n retval = []\n for token in stdout.split():\n retval.append(token[2:])\n\n return uniq(retval)","def get_all_packages(self):\n return self._package_cache.values()","def required_packages(cls) -> List[Text]:\n return []","def get_required_packages(self) -> list:\n\t\tret = []\n\t\tlocal_packages = ChocoInfo.get_local_packages(\n\t\t\tPUSHED_PACKAGES_PATH)\n\n\t\tprint(\"local_packages\", local_packages)\n\n\t\treturn [c_package for c_package in self._community_packages if c_package not in local_packages]","def user_dependencies(self, host, user):\n return search_api(\"user_dependencies\", host, user)","def getIgnoredDict(self):\n return self.ignored","def packages():","def get_packages(package):\n return [dirpath\n for dirpath, dirnames, filenames in os.walk(package)\n if os.path.exists(os.path.join(dirpath, '__init__.py'))]","def get_packages(package):\n return [dirpath\n for dirpath, dirnames, filenames in os.walk(package)\n if os.path.exists(os.path.join(dirpath, '__init__.py'))]","def get_packages(package):\n return [dirpath\n for dirpath, dirnames, filenames in os.walk(package)\n if os.path.exists(os.path.join(dirpath, '__init__.py'))]","def removeIgnore(self, hostmask):\n assert ircutils.isUserHostmask(hostmask), 'got %s' % hostmask\n return self.ignores.pop(hostmask)","def isIgnoredPackage(self, *args):\n return _libsbml.SBMLDocument_isIgnoredPackage(self, *args)","def get_installed_jre_packages():\n # Convert to a set and back to a list again to uniqueify.\n return sorted(list(set(rpm_query_whatprovides('java', 'java7', 'jdk'))))","def get_packages(package):\n return [\n dirpath\n for dirpath, dirnames, filenames in os.walk(package)\n if os.path.exists(os.path.join(dirpath, '__init__.py'))\n ]","def missing_dependencies_by_extra(package=\"sunpy\", exclude_extras=None):\n exclude_extras = exclude_extras or []\n requirements = get_requirements(package)\n missing_dependencies = {}\n for group in requirements.keys():\n if group in exclude_extras:\n continue\n missing_dependencies[group] = find_dependencies(package, [group])[0]\n return missing_dependencies","def get_whitelisted_packages() -> Mapping[str, Union[str, None]]:\n with (here / WHITELISTED_PACKAGES_FILE).open() as fh:\n package_data = json.load(fh)\n return {\n key.upper().strip(): val.upper().strip() if val else val\n for key, val in package_data.items()\n }","def GetPackages(self, package_target):\n return self._packages.get(package_target, None)","def disableUnusedPackages(self, *args):\n return _libsbml.SBMLExtensionRegistry_disableUnusedPackages(self, *args)","def get_theme_base_dirs_unchecked():\n theme_dirs = getattr(settings, \"COMPREHENSIVE_THEME_DIRS\", None)\n\n return get_theme_base_dirs_from_settings(theme_dirs)","def get_hook_root_info ( self, nonlinked_only=False ):\n if nonlinked_only:\n return [\n ( script.name, [] )\n for script, user_scripts in self.hook_root.iter_linked()\n if not user_scripts\n ]\n else:\n return [\n (\n script.name,\n [ ( s.event or \"undef\", s.priority ) for s in user_scripts ]\n )\n for script, user_scripts in self.hook_root.iter_linked()\n ]","def pkg_service_blacklist(klass, pkg):\n return klass._pkg_service_blacklist.get(pkg.name, [])","def isDisabledIgnoredPackage(self, *args):\n return _libsbml.SBMLDocument_isDisabledIgnoredPackage(self, *args)","def get_lb_pkgs(self):\r\n\r\n lb_filter = '*Load Balancer*'\r\n _filter = NestedDict({})\r\n _filter['items']['description'] = query_filter(lb_filter)\r\n\r\n kwargs = NestedDict({})\r\n kwargs['id'] = 0 # look at package id 0\r\n kwargs['filter'] = _filter.to_dict()\r\n packages = self.prod_pkg.getItems(**kwargs)\r\n pkgs = []\r\n for package in packages:\r\n if not package['description'].startswith('Global'):\r\n pkgs.append(package)\r\n return pkgs","def packages(self):\n\n if self._packages:\n return self._packages\n\n self._load()\n return self._packages","def get_user_ids() -> List[str]:\n listOfFiles = os.listdir('public_dataset')\n listOfFiles.remove('data_description.pdf')\n try:\n listOfFiles.remove('.DS_Store')\n except:\n pass\n return listOfFiles","def have_package_lists():\n return 'Filename:' in execute('apt-cache', 'show', 'python', check=False, capture=True)","def __dir__():\n import pkgutil\n\n names = [\n name\n for importer, name, ispkg in pkgutil.iter_modules(__path__)\n if not ispkg and name != \"base\"\n ]\n return names + [\"custom\", \"noData\"]","def fake_get_user_repo_names_and_locations(self):\n self._get_user_repo_names_and_locations()","def get_repos_user(user='xmonader'):\n u = ghclient.get_user(login=user)\n repos = u.get_repos()\n repos_list = []\n for i in range(20):\n page = repos.get_page(i)\n if len(page) == 0:\n break\n repos_list.extend(repos.get_page(i))\n return repos_list","def get_outdated_packages(self, pip_path=\"pip\"):\n output_re = [re.compile(r) for r in [\n # newer pip\n r'^(.+) \\(Current: (.+) Latest: (.+)\\)$',\n # old pip\n r'^(.+) \\((.+)\\) - Latest: (.+) .*$',\n ]]\n pkgs = {}\n out = self.check_output(\"%s list -o\", pip_path)\n for line in out.splitlines():\n # Warning: cannot find svn location for rst2pdf==0.93.dev-r0\n # Could not find any downloads that satisfy the requirement iotop\n if line.startswith('Warning: ') or line.startswith('Could not '):\n continue\n for out_re in output_re:\n match = out_re.match(line)\n if match:\n name, current, latest = match.groups()\n pkgs[name] = {'current': current, 'latest': latest}\n break\n else:\n raise RuntimeError(\"could not parse {0}\".format(repr(line)))\n return pkgs","def get_disabled_plugins(self):\n return self._disabled_plugins","def ignore(self) -> list[str] | list[None]:\n if self._ignore is None:\n print(self.__class__.ignore.__doc__)\n raise SilSubProblemError(\n \"The *ignore* property has not been set (see above).\"\n )\n return self._ignore","def missingTranslationPkgs(self, pkg, translation_pkg):\n\n # FIXME: this function is called too often and it's too slow\n # -> see ../TODO for ideas how to fix it\n missing = []\n # check if the pkg itself is available and installed\n if not self._cache.has_key(pkg):\n return missing\n if not self._cache[pkg].isInstalled:\n return missing\n\n # match every packages that looks similar to translation_pkg\n # \n for pkg in self._cache:\n if (pkg.name == translation_pkg or\n pkg.name.startswith(translation_pkg+\"-\")):\n if not pkg.isInstalled and pkg.candidateVersion != None:\n missing.append(pkg.name)\n return missing","def user_site_packages() -> str:\n if os.name == 'nt':\n return os.path.join(user_plugin_dir(), 'Lib', 'site-packages')\n\n python_dir = f'python{sys.version_info.major}.{sys.version_info.minor}'\n return os.path.join(user_plugin_dir(), 'lib', python_dir, 'site-packages')","def remove_packages_ignored_since(days, paths=None, dry_run=False, verbose=False):\n num_removed = 0\n\n for path in (paths or config.packages_path):\n repo = package_repository_manager.get_repository(path)\n\n if verbose:\n print_info(\"Searching %s...\", repo)\n\n num_removed += repo.remove_ignored_since(\n days=days,\n dry_run=dry_run,\n verbose=verbose\n )\n\n return num_removed","def import_packages_global():\n return \"\"","def repositories(self, user_name=None):\n user_name = user_name if user_name else self._auth[0]\n data = self._request('GET', 'users', user_name)\n return data.repositories\n #ret_val = []\n #for repository in data.repositories:\n # ret_val.append(repository.name)\n # #print 'repo', repository['name'] # can use as dict or as object\n #return ret_val","def getImportList():\n\timports = []\n\tfor line in vim.current.buffer:\n\t\twords = string.split(line)\n\t\tif (len(words)>0 and (words[0]=='import' or words[0]=='from')):\n\t\t\tif words[1] not in imports:\n\t\t\t\timports.append(words[1])\n\treturn imports","def locked(user):\n\n cmd = \"lsuser -a account_locked {}\".format(user)\n cmd += ' | grep \"account_locked=true\"'\n out = __salt__[\"cmd.run_all\"](cmd, output_loglevel=\"trace\", python_shell=True)\n\n ret = []\n\n lines = out[\"stdout\"].splitlines()\n for line in lines:\n ret.append(line.split()[0])\n\n return ret","def get_site_packages():\n # Another hack...\n # Relies on the fact that os.py is in the dir above site_packages\n os_location = os.path.dirname(os.__file__)\n site_packages = []\n # Consider Debian/Ubuntu custom\n for site in [\"site-packages\", \"dist-packages\"]:\n site_path = os.path.join(os_location, site)\n if os.path.isdir(site_path):\n site_packages.append(site_path)\n return site_packages","def remove_packages(self, packages):"],"string":"[\n \"def getusersitepackages():\\n\\tpass\",\n \"def packages(self):\\n return []\",\n \"def user_packages(self, host: (str), user: (str)) -> Any:\\n return search_api(\\\"user_packages\\\", host, user)\",\n \"def get_packages():\\n\\n packages = find_packages()\\n packages = ['{}.{}'.format('uniq', package) for package in packages]\\n packages.append('uniq')\\n return packages\",\n \"def _print_ignored(packages):\\n if not packages:\\n print(\\\"## No Rez package was set to be ignored\\\")\\n print(\\\"No data found\\\")\\n\\n return\\n\\n print(\\\"## Every package in this list was explicitly set to ignored by the user\\\")\\n\\n for package, pattern in sorted(packages, key=_get_package_name):\\n print(\\n 'Package: {package.name} - Pattern: \\\"{pattern}\\\"'.format(\\n package=package, pattern=pattern\\n )\\n )\",\n \"def ignore_from_package(self, project, package, arch, ignore):\\n for binary in binary_list(self.apiurl, project, 'standard', arch, package):\\n ignore.add(binary.name)\\n\\n return ignore\",\n \"def get_not_installed_rpm_packages():\\n def is_installed(elem):\\n return elem in PMDK_TOOLS and elem in listdir('/usr/bin/') or\\\\\\n elem == \\\"pmdk\\\" or elem + '.so' in listdir('/usr/lib64/')\\n\\n elements = get_libraries_names()\\n not_installed_packages = []\\n for elem in elements:\\n if not is_installed(elem):\\n not_installed_packages.append(elem)\\n return not_installed_packages\",\n \"def getIgnoredPlugins(self):\\n return self.yaml.getIgnoredPlugins()\",\n \"def packages(self):\\r\\n return self._packages\",\n \"def GetUnknownFiles(self):\\n args = []\\n status = RunShell([\\\"hg\\\", \\\"status\\\", \\\"--rev\\\", self.base_rev, \\\"-u\\\", \\\".\\\"],\\n silent_ok=True)\\n unknown_files = []\\n for line in status.splitlines():\\n st, fn = line.split(\\\" \\\", 1)\\n if st == \\\"?\\\":\\n unknown_files.append(fn)\\n return unknown_files\",\n \"def GetUnknownFiles(self):\\r\\n args = []\\r\\n status = RunShell([\\\"hg\\\", \\\"status\\\", \\\"--rev\\\", self.base_rev, \\\"-u\\\", \\\".\\\"],\\r\\n silent_ok=True)\\r\\n unknown_files = []\\r\\n for line in status.splitlines():\\r\\n st, fn = line.split(\\\" \\\", 1)\\r\\n if st == \\\"?\\\":\\r\\n unknown_files.append(fn)\\r\\n return unknown_files\",\n \"def _filter_pkgs(self, pkgs):\\n pkgs = [pkg.strip() for pkg in pkgs]\\n return [\\n pkg for pkg in pkgs\\n if pkg.startswith(self.base_pkg) and not pkg.startswith(os.path.join(self.base_pkg, \\\"vendor/\\\"))\\n ]\",\n \"def get_package_list():\\n pip_freeze = subprocess.check_output(('pip', 'freeze')).decode('utf8')\\n package_list = [x.strip().split('==') for x in pip_freeze.split('\\\\n') if x.find('==') != -1]\\n package_list = [(x[0].lower(), x[1]) for x in package_list]\\n return package_list\",\n \"def get_ignored_packages_names(ign_packages_names: Sequence[str], ign_groups_names: Sequence[str],\\n upstream_system: 'System', installed_system: 'System',\\n do_everything: bool = False) -> Set[str]:\\n handler = PacmanConfig(conf=\\\"/etc/pacman.conf\\\").initialize_alpm()\\n\\n # ignored packages names - may contain glob patterns\\n names_to_ignore = set(handler.ignorepkgs)\\n for ign_packages_name in ign_packages_names:\\n for name in ign_packages_name.split(\\\",\\\"):\\n names_to_ignore.add(name)\\n\\n # ignored groups names\\n ignored_groups_names = set(handler.ignoregrps)\\n for ign_groups_name in ign_groups_names:\\n for name in ign_groups_name.split(\\\",\\\"):\\n ignored_groups_names.add(name)\\n\\n # contains the concrete packages names to ignore\\n return_set = set()\\n\\n # check globbing\\n packages_names = [package_name for package_name in upstream_system.all_packages_dict]\\n for possible_glob in names_to_ignore:\\n return_set |= set(fnmatch.filter(packages_names, possible_glob))\\n # allow non upstream packages to be ignored, too - needed for correct replaces behavior\\n if do_everything:\\n packages_names = [package_name for package_name in installed_system.all_packages_dict]\\n for possible_glob in names_to_ignore:\\n return_set |= set(fnmatch.filter(packages_names, possible_glob))\\n\\n if not ignored_groups_names:\\n return return_set\\n\\n # fetch packages names of groups to ignore\\n for package_name in packages_names:\\n package = upstream_system.all_packages_dict[package_name]\\n # check groups\\n for package_group in package.groups:\\n if package_group in ignored_groups_names:\\n return_set.add(package_name)\\n\\n return return_set\",\n \"def getsitepackages():\\n\\tpass\",\n \"def ignore_services(self) -> List[str]:\\n return self.data.get(\\\"ignore_services\\\", [])\",\n \"def _extract_r_remove_package_names(log):\\n start = \\\"remove.packages(c(\\\"\\n i_start = log.find(start) + len(start)\\n i_end = log.find(\\\")\\\", i_start)\\n package_names = [name.strip('\\\"') for name in log[i_start:i_end].split(\\\",\\\")]\\n return package_names\",\n \"def ignore_from_repo(self, directory, ignore):\\n for filename in os.listdir(directory):\\n if not filename.endswith('.rpm'):\\n continue\\n _, basename = filename.split('-', 1)\\n ignore.add(basename[:-4])\",\n \"def getInstalledPackages():\\n reqs = subprocess.check_output([sys.executable,\\n '-m', 'pip', 'freeze'])\\n installed_packages = [r.decode().split('==')[0]\\n for r in reqs.split()]\\n return installed_packages\",\n \"def list_packages():\\n\\n shelf_dir = settings.shelf_dir\\n\\n package_list = os.listdir(shelf_dir)\\n\\n package_list.sort()\\n\\n return package_list\",\n \"def _get_ignore_list(self) -> List[str]:\\n if not self.exists():\\n return []\\n if self._file_exists():\\n with open(self._path, \\\"r\\\", encoding=DefaultOpenEncoding.READ) as fh:\\n return [line.rstrip() for line in fh if line]\\n return []\",\n \"def available_modules(self, user):\\n return [sitecomp for sitecomp in self.enabled_modules() if sitecomp.has_perm(user)]\",\n \"def isIgnoredPkg(self, *args):\\n return _libsbml.SBMLDocument_isIgnoredPkg(self, *args)\",\n \"def ignores(self):\\n return self._ignores\",\n \"def __gather_package_data(arguments):\\n ignore_patterns, packages_path, search_packages_path = _resolve_arguments(\\n arguments.ignore_patterns,\\n arguments.packages_path,\\n arguments.search_packages_path,\\n )\\n rez_packages = set(arguments.rez_packages)\\n\\n package_finder = registry.get_package_finder(arguments.command)\\n\\n found_packages = []\\n packages, invalid_packages, skips = package_finder(\\n paths=packages_path + search_packages_path\\n )\\n\\n for package in packages:\\n if rez_packages and package.name not in rez_packages:\\n skips.append(package)\\n else:\\n found_packages.append(package)\\n\\n ignored_packages, other_packages = _split_the_ignored_packages(\\n found_packages, ignore_patterns\\n )\\n\\n other_packages = sorted(other_packages, key=operator.attrgetter(\\\"name\\\"))\\n\\n return ignored_packages, other_packages, invalid_packages, skips\",\n \"def get_packages(self):\\n packages = []\\n for obj in self.objects_used:\\n packages.extend(obj.get_packages())\\n # Remove duplicates (not necessary but it's cleaner)\\n packages = list(set(packages))\\n return packages\",\n \"def _filter_installed_packages(self, packages):\\n filtered_packages = []\\n for package in packages:\\n name = package.name\\n for installed in self._top_installed_repository.find_packages(name):\\n if installed.key == package.key:\\n break\\n else:\\n filtered_packages.append(package)\\n return filtered_packages\",\n \"def installed_nginx_packages(self):\\n result = {}\\n dpkg_grep_nginx_out, _ = subp.call(\\\"dpkg -l | grep nginx\\\")\\n for line in dpkg_grep_nginx_out:\\n gwe = re.match(self.dpkg_l_re, line)\\n if gwe:\\n if gwe.group(2).startswith('nginx'):\\n result[gwe.group(2)] = gwe.group(3)\\n return result\",\n \"def get_packages_with_prefixes():\\n return get_resources('packages')\",\n \"def get_suspect_packages():\\n with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'gistfile1.txt'), 'r') as f:\\n return map(lambda line: line.strip(), f.readlines())\",\n \"def ignore(ui, repo, *user_files, **opts):\\n # The doc string below will show up in hg help.\\n\\n use_glob = opts.get('globs')\\n # Use HG API call to get all files in state \\\"unknown\\\". Those are relative to the repo root\\n unknown_files = repo.status(unknown=True)[4]\\n # Bring user-given file names into the \\\"relative-to-HG-root\\\" format\\n files_absolute = [ os.path.realpath(p) for p in user_files ]\\n files = [ os.path.relpath(p, repo.root) for p in files_absolute ]\\n\\n # Check if ignore file exists, otherwise create it\\n ignore_filename = os.path.normpath(os.path.join(repo.root, \\\".hgignore\\\"))\\n try:\\n with open(ignore_filename, \\\"a\\\") as f: pass\\n except:\\n with open(ignore_filename, \\\"w\\\") as f: f.write()\\n\\n # Check if the files given on the command line are really unknown to HG\\n already_ignored = set()\\n if use_glob:\\n for f in files:\\n if is_already_ignored(f, ignore_filename):\\n ui.write(\\\"Pattern %s is already active.\\\\n\\\" % (f,))\\n already_ignored.add(f)\\n else:\\n for f in files:\\n if os.path.isdir(f):\\n # Directories are not tracked, but we want to add them to .hgignore, anyway. \\n continue\\n if f not in unknown_files:\\n if is_already_ignored(f, ignore_filename):\\n ui.write(\\\"File %s is already ignored.\\\\n\\\" % (f,))\\n already_ignored.add(f)\\n else:\\n raise util.Abort(\\\"File %s is not in state UNKNOWN.\\\" % (f,))\\n\\n # Prepare list of files to be ignored in .hgignore line-by-line syntax\\n ignores = \\\"\\\"\\n for f in (set(files) - already_ignored):\\n ignores += f\\n ignores += '\\\\n'\\n if len(ignores):\\n ui.write(\\\"Ignored:\\\\n%s\\\" % (ignores,))\\n\\n # Search for the glob section in .hgignore; when found, insert filenames after\\n found_glob_section = False\\n for line in fileinput.input(ignore_filename, inplace=True, mode=\\\"rU\\\"):\\n if re.match(\\\"^syntax:.*glob\\\", line):\\n sys.stdout.write(line)\\n sys.stdout.write(ignores)\\n found_glob_section = True\\n else:\\n sys.stdout.write(line)\\n\\n # No \\\"syntax: glob\\\" section in .hgignore file found -> create one\\n if not found_glob_section:\\n with open(ignore_filename, \\\"a\\\") as ignore_file:\\n ignore_file.write(\\\"syntax: glob\\\\n\\\")\\n ignore_file.write(ignores)\",\n \"def getMissingLangPacks(self):\\n missing = []\\n for langInfo in self._cache.getLanguageInformation():\\n #print langInfo.languageCode\\n trans_package = \\\"language-pack-%s\\\" % langInfo.languageCode\\n # we have a langpack installed, see if we have all of them\\n if (self._cache.has_key(trans_package) and \\n self._cache[trans_package].isInstalled):\\n #print \\\"IsInstalled: %s \\\" % trans_package\\n for (pkg, translation) in self._cache.pkg_translations:\\n missing += self.missingTranslationPkgs(pkg, translation+langInfo.languageCode)\\n\\n # now check for a missing default language support\\n default_lang = self.getSystemDefaultLanguage()\\n # if there is no default lang, return early\\n if default_lang is None:\\n return missing\\n if \\\"_\\\" in default_lang:\\n default_lang = default_lang.split(\\\"_\\\")[0]\\n trans_package = \\\"language-pack-%s\\\" % default_lang\\n if (self._cache.has_key(trans_package) and \\n not self._cache[trans_package].isInstalled):\\n missing += [trans_package]\\n for (pkg, translation) in self._cache.pkg_translations:\\n missing += self.missingTranslationPkgs(pkg, translation+default_lang)\\n support_packages = LanguageSelectorPkgCache._getPkgList(self._cache, default_lang)\\n for support_package in support_packages:\\n if (self._cache.has_key(support_package) and \\n not self._cache[support_package].isInstalled):\\n missing.append(support_package)\\n\\n return missing\",\n \"def get_blocked_usernames_list():\\n return []\",\n \"def get_ignored_dirs(ci_ignore_path):\\n with open(ci_ignore_path, 'r') as ignore_file:\\n return set([\\n normpath(line.strip())\\n for line in ignore_file.readlines()\\n if not line.startswith('#') and not is_blank(line)\\n ])\",\n \"def _get_ignored_payloads():\\n ignored_payloads = os.environ.get('EPSAGON_PAYLOADS_TO_IGNORE')\\n if ignored_payloads:\\n return json.loads(ignored_payloads)\\n\\n return []\",\n \"def get_packages(package):\\n return [str(path.parent) for path in Path(package).glob(\\\"**/__init__.py\\\")]\",\n \"def _remove_extra_packages(frozen_pkgs, ret, **kwargs):\\n pkgs = __salt__[\\\"pkg.list_pkgs\\\"](**kwargs)\\n extra_pkgs = set(pkgs) - set(frozen_pkgs)\\n for pkg in extra_pkgs:\\n try:\\n __salt__[\\\"pkg.remove\\\"](name=pkg, **kwargs)\\n ret[\\\"pkgs\\\"][\\\"remove\\\"].append(pkg)\\n log.info(\\\"Removed extra package %s\\\", pkg)\\n except Exception as e: # pylint: disable=broad-except\\n msg = \\\"Error removing %s package: %s\\\"\\n log.error(msg, pkg, e)\\n ret[\\\"comment\\\"].append(msg % (pkg, e))\",\n \"def get_packages_in_current_dir() -> list:\\n from os import listdir\\n\\n pkgs = []\\n ext = ('.tgz', '.txz')\\n for file_in_current_dir in sorted(listdir()):\\n if file_in_current_dir.endswith(ext):\\n pkgs.append(file_in_current_dir)\\n\\n return pkgs\",\n \"def getMissingPackages(self, language=None, all=False, packages=None, showInstalled=False):\\n if self._cache.broken_count > 0:\\n raise SoftwareIndexBroken\\n \\n self.langpack_locales = {}\\n self.pkg_translations = {}\\n self.pkg_writing = {}\\n filter_list = {}\\n blacklist = []\\n show = []\\n self.missing = set()\\n self.installed = set()\\n self.system_pkgcode = ''\\n \\n for l in open(self.BLACKLIST):\\n l = l.strip()\\n if not l.startswith('#'):\\n blacklist.append(l)\\n \\n for l in open(self.LANGCODE_TO_LOCALE):\\n try:\\n l = l.rstrip()\\n if ':' in l:\\n (pkgcode, locale) = l.split(':')\\n else:\\n pkgcode = l\\n locale = l\\n except ValueError:\\n continue\\n self.langpack_locales[locale] = pkgcode\\n \\n for l in open(self.PACKAGE_DEPENDS):\\n if l.startswith('#'):\\n continue\\n try:\\n l = l.rstrip()\\n # sort out comments\\n if l.find('#') >= 0:\\n continue\\n (c, lc, k, v) = l.split(':')\\n except ValueError:\\n continue\\n if (c == 'tr' and lc == ''):\\n filter_list[v] = k\\n elif (c == 'wa' and lc != ''):\\n if '|' in lc:\\n for l in lc.split('|'):\\n if not l in self.pkg_writing:\\n self.pkg_writing[l] = []\\n self.pkg_writing[l].append((\\\"%s\\\" % k, \\\"%s\\\" % v))\\n else:\\n if not lc in self.pkg_writing:\\n self.pkg_writing[lc] = []\\n self.pkg_writing[lc].append((\\\"%s\\\" % k, \\\"%s\\\" % v))\\n\\n # get list of all packages available on the system and filter them\\n for item in self._cache.keys():\\n if item in blacklist: \\n continue\\n for x in filter_list.keys():\\n if item.startswith(x) and not item.endswith('-base'):\\n # parse language code\\n langcode = item.replace(x, '')\\n #print \\\"%s\\\\t%s\\\" % (item, langcode)\\n if langcode == 'zh':\\n # special case: zh langpack split\\n for langcode in ['zh-hans', 'zh-hant']:\\n if not langcode in self.pkg_translations:\\n self.pkg_translations[langcode] = []\\n self.pkg_translations[langcode].append((\\\"%s\\\" % filter_list[x], \\\"%s\\\" % item))\\n elif langcode in self.langpack_locales.values():\\n # langcode == pkgcode\\n if not langcode in self.pkg_translations:\\n self.pkg_translations[langcode] = []\\n self.pkg_translations[langcode].append((\\\"%s\\\" % filter_list[x], \\\"%s\\\" % item))\\n #print self.pkg_translations[langcode]\\n else:\\n # need to scan for LL-CC and LL-VARIANT codes\\n for locale in self.langpack_locales.keys():\\n if '_' in locale or '@' in locale:\\n if '@' in locale:\\n (locale, variant) = locale.split('@')\\n else:\\n variant = ''\\n (lcode, ccode) = locale.split('_')\\n if langcode in [\\\"%s-%s\\\" % (lcode, ccode.lower()),\\n \\\"%s%s\\\" % (lcode, ccode.lower()),\\n \\\"%s-%s\\\" % (lcode, variant),\\n \\\"%s%s\\\" % (lcode, variant),\\n \\\"%s-latn\\\" % lcode,\\n \\\"%slatn\\\" % lcode,\\n \\\"%s-%s-%s\\\" % (lcode, ccode.lower(), variant),\\n \\\"%s%s%s\\\" % (lcode, ccode.lower(), variant)]:\\n # match found, get matching pkgcode\\n langcode = self.langpack_locales[locale]\\n if not langcode in self.pkg_translations:\\n self.pkg_translations[langcode] = []\\n self.pkg_translations[langcode].append((\\\"%s\\\" % filter_list[x], \\\"%s\\\" % item))\\n #print self.pkg_translations[langcode]\\n break\\n\\n if language:\\n pkgcode = ''\\n if language == 'zh-hans' or language == 'zh-hant':\\n self.system_pkgcode = language\\n elif language in self.langpack_locales:\\n self.system_pkgcode = self.langpack_locales[language]\\n else:\\n # pkgcode = ll\\n if '_' in language:\\n (self.system_pkgcode) = language.split('_')[0]\\n elif '@' in language:\\n (self.system_pkgcode) = language.split('@')[0]\\n else:\\n self.system_pkgcode = language\\n\\n if packages:\\n self.findPackages(self.system_pkgcode, packages)\\n else:\\n self.findPackages(self.system_pkgcode)\\n \\n elif all:\\n # try all available languages\\n pkgcodes = []\\n for item in self._cache.keys():\\n if item in blacklist:\\n continue\\n if item.startswith('language-pack-') and \\\\\\n not item.startswith('language-pack-gnome') and \\\\\\n not item.startswith('language-pack-kde') and \\\\\\n not item.endswith('-base'):\\n pkgcode = item.replace('language-pack-', '')\\n pkgcodes.append(pkgcode)\\n\\n for pkgcode in pkgcodes:\\n if packages:\\n self.findPackages(pkgcode, packages)\\n else:\\n self.findPackages(pkgcode)\\n\\n else:\\n # get a list of language-packs we have already installed or are going to install\\n # 1. system locale\\n system_langcode = self._localeinfo.getSystemDefaultLanguage()[0]\\n if system_langcode == None:\\n system_langcode = 'en_US'\\n if system_langcode in self.langpack_locales:\\n self.system_pkgcode = self.langpack_locales[system_langcode]\\n # 2. installed language-packs\\n pkgcodes = []\\n for item in self._cache.keys():\\n if item in blacklist: \\n continue\\n if item.startswith('language-pack-') and \\\\\\n not item.startswith('language-pack-gnome') and \\\\\\n not item.startswith('language-pack-kde') and \\\\\\n not item.endswith('-base') and \\\\\\n (self._cache[item].is_installed or \\\\\\n self._cache[item].marked_install):\\n pkgcode = item.replace('language-pack-', '')\\n pkgcodes.append(pkgcode)\\n if self.system_pkgcode and \\\\\\n not self.system_pkgcode in pkgcodes:\\n pkgcodes.append(self.system_pkgcode)\\n \\n for pkgcode in pkgcodes:\\n if packages:\\n self.findPackages(pkgcode, packages)\\n else:\\n self.findPackages(pkgcode)\\n \\n if showInstalled:\\n show = self.missing | self.installed\\n else:\\n show = self.missing\\n\\n return show\",\n \"def getuserrepos_keys(gh, user):\\n repos = getuserrepos(gh, user)\\n return repos[0].keys()\",\n \"def get_incompatible_packages():\\n pkgconfig_directory = '/usr/lib64/pkgconfig/'\\n incompatibe_packages = []\\n libraries = get_libraries_names() - set(NO_PKG_CONFIGS)\\n for library in libraries:\\n with open(pkgconfig_directory + library + '.pc') as f:\\n out = f.readlines()\\n for line in out:\\n if 'version=' in line:\\n version = line.split('=')[1].strip(linesep)\\n if not version in PMDK_VERSION.replace('~', '-'):\\n incompatibe_packages.append(library)\\n return incompatibe_packages\",\n \"def extra_removed_packages(self, index: int) -> Packages:\\n log = self[index]\\n if (\\n not log.startswith(\\\"conda remove\\\")\\n and not log.startswith(\\\"pip uninstall\\\")\\n and not (log.startswith(R_COMMAND) and \\\"remove.packages\\\" in log)\\n ):\\n raise CondaEnvTrackerParseHistoryError(\\n f\\\"The log at index {index} is not a remove statement: {self[index]}.\\\"\\n )\\n if log.startswith(\\\"conda remove\\\"):\\n package_names = self._extract_conda_remove_package_names(log)\\n elif log.startswith(\\\"pip uninstall\\\"):\\n package_names = log.replace(\\\"pip uninstall \\\", \\\"\\\").split()\\n else:\\n package_names = self._extract_r_remove_package_names(log)\\n return Packages.from_specs(package_names)\",\n \"def get_installed_packages() -> List['Package']:\\n repo_packages_names = set(expac(\\\"-S\\\", ['n'], []))\\n\\n # packages the user wants to install from aur\\n aur_names = packages_from_other_sources()[0]\\n repo_packages_names -= aur_names\\n\\n installed_packages_names = set(expac(\\\"-Q\\\", ['n'], []))\\n installed_repo_packages_names = installed_packages_names & repo_packages_names\\n unclassified_installed_names = installed_packages_names - installed_repo_packages_names\\n\\n return_list = []\\n\\n # installed repo packages\\n if installed_repo_packages_names:\\n return_list.extend(\\n Package.get_packages_from_expac(\\\"-Q\\\", list(installed_repo_packages_names), PossibleTypes.REPO_PACKAGE)\\n )\\n\\n # installed aur packages\\n installed_aur_packages_names = set(\\n [package.name for package in Package.get_packages_from_aur(list(unclassified_installed_names))]\\n )\\n\\n # package names the user gave us must be in the aur\\n for name in aur_names:\\n if name not in installed_aur_packages_names:\\n aurman_error(\\\"Package {} not found in AUR!\\\".format(Colors.BOLD(Colors.LIGHT_MAGENTA(name))))\\n raise InvalidInput(\\\"Package {} not found in AUR!\\\".format(Colors.BOLD(Colors.LIGHT_MAGENTA(name))))\\n\\n if installed_aur_packages_names:\\n return_list.extend(\\n Package.get_packages_from_expac(\\\"-Q\\\", list(installed_aur_packages_names), PossibleTypes.AUR_PACKAGE)\\n )\\n\\n unclassified_installed_names -= installed_aur_packages_names\\n\\n # installed not repo not aur packages\\n if unclassified_installed_names:\\n return_list.extend(\\n Package.get_packages_from_expac(\\n \\\"-Q\\\", list(unclassified_installed_names),\\n PossibleTypes.PACKAGE_NOT_REPO_NOT_AUR\\n )\\n )\\n\\n return return_list\",\n \"def get_user_icons(user):\\n\\tuser_perms = UserPermissions(user)\\n\\tuser_perms.build_permissions()\\n\\n\\tfrom frappe.boot import get_allowed_pages\\n\\n\\tallowed_pages = get_allowed_pages()\\n\\n\\ticons = []\\n\\tfor icon in get_desktop_icons(user):\\n\\t\\tadd = True\\n\\t\\tif icon.hidden_in_standard:\\n\\t\\t\\tadd = False\\n\\n\\t\\tif not icon.custom:\\n\\t\\t\\tif icon.module_name == [\\\"Help\\\", \\\"Settings\\\"]:\\n\\t\\t\\t\\tpass\\n\\n\\t\\t\\telif icon.type == \\\"page\\\" and icon.link not in allowed_pages:\\n\\t\\t\\t\\tadd = False\\n\\n\\t\\t\\telif icon.type == \\\"module\\\" and icon.module_name not in user_perms.allow_modules:\\n\\t\\t\\t\\tadd = False\\n\\n\\t\\tif add:\\n\\t\\t\\ticons.append(icon)\\n\\n\\treturn icons\",\n \"def users_excludeds(self) -> pulumi.Output[Optional[Sequence[str]]]:\\n return pulumi.get(self, \\\"users_excludeds\\\")\",\n \"def get_default_packages(rootfs, include_essential=False,\\n include_priorities=None):\\n if include_priorities is None:\\n include_priorities = []\\n\\n package_list = set()\\n\\n list_dir = os.path.join(rootfs, 'var/lib/apt/lists')\\n for filename in os.listdir(list_dir):\\n if not filename.endswith('_Packages'):\\n continue\\n\\n with open(os.path.join(list_dir, filename)) as infile:\\n for pkg in rfc822_parse(infile):\\n if 'Essential' in pkg and include_essential:\\n package_list.add(pkg['Package'])\\n continue\\n if 'Priority' not in pkg:\\n continue\\n\\n if pkg['Priority'] in include_priorities:\\n package_list.add(pkg['Package'])\\n\\n return list(sorted(package_list))\",\n \"def getAllInstalledPackages(installedPkgPath):\\n allPkgVers = []\\n if os.path.exists(installedPkgPath):\\n for pkg in os.listdir(installedPkgPath):\\n pkgVersions = os.listdir(os.path.join(installedPkgPath, pkg))\\n for pkgVersion in pkgVersions:\\n pkgPath = os.path.join(installedPkgPath, pkg)\\n if not fnmatch.fnmatch(pkgVersion, '*.inprogress'):\\n allPkgVers.append(os.path.join(pkgPath, pkgVersion))\\n return allPkgVers\",\n \"def retrieveIgnoredWords(self):\\n words = self.con.getIgnoredWords()\\n guilds = self.con.getGuildsInfo()\\n\\n for item in guilds:\\n self.ignored[item.split(',')[0]] = []\\n\\n for word in words:\\n data = word.split(',')\\n self.ignored[data[0]].append(data[1])\",\n \"def get_vul_info(vul_info):\\n packages = []\\n if vul_info.get('fixes') is None:\\n return packages\\n for fixes in vul_info['fixes']:\\n packages.extend(get_package_os(fixes))\\n return packages\",\n \"def _extract_conda_remove_package_names(log):\\n names = log.split(\\\"--name\\\")[-1].split()\\n return names[1:]\",\n \"def get_packages(root):\\n root = os.path.realpath(root)\\n proot = parent(root) + \\\"/\\\"\\n py_files = [file.rsplit(proot)[1] for file in listfiles(root)]\\n packages = list(np.unique([parent(file).replace(\\\"/\\\", \\\".\\\") for file in py_files]))\\n # return list(np.unique([parent(file).replace(\\\"/\\\", \\\".\\\").split(\\\".{name_root}.\\\".format(name_root=name(root)))[1]\\n # for file in py_files]))\\n return packages\",\n \"def getRpmBlacklist():\\n global index\\n enabledRpms = set()\\n for stream in enabledStreams.values():\\n enabledRpms = enabledRpms.union(stream.get_rpm_artifacts())\\n\\n allRpms = set()\\n for name in index.get_module_names():\\n module = index.get_module(name)\\n for stream in module.get_all_streams():\\n allRpms = allRpms.union(stream.get_rpm_artifacts())\\n\\n return list(allRpms.difference(enabledRpms))\",\n \"def ignored_lists(self) -> List[str]:\\n return self.__lists_to_ignore\",\n \"def get_repo_packages() -> List['Package']:\\n return Package.get_packages_from_expac(\\\"-S\\\", [], PossibleTypes.REPO_PACKAGE)\",\n \"def get_installed_packages(cache=False,\\n output_dir='.',\\n output_filename='installed.pkgs.txt'):\\n output = os.path.join(output_dir, output_filename)\\n cmd = '''aptitude search '~i !~M' -F '%%p' | sort -u > %r''' % (\\n output)\\n ensure_file(cmd, output, shell=True, overwrite=not(cache))\\n installed = list(read_lines(output))\\n return installed\",\n \"def get_fallback_packages(request, package_name):\\n dists = request.locator.get_project(package_name)\\n pkgs = {}\\n for version, url_set in six.iteritems(dists.get('urls', {})):\\n dist = dists[version]\\n for url in url_set:\\n filename = posixpath.basename(url)\\n url = request.app_url('api', 'package', dist.name, filename)\\n pkgs[filename] = url\\n return pkgs\",\n \"def get_non_vendor_package_path(aea_project_path: Path) -> Set[Path]:\\n result: Set[Path] = set()\\n for item_type_plural in ComponentType.plurals():\\n nonvendor_package_dir_of_type = aea_project_path / item_type_plural\\n result = result.union(\\n {p for p in nonvendor_package_dir_of_type.iterdir() if p.is_dir()}\\n if nonvendor_package_dir_of_type.exists()\\n else {}\\n )\\n return result\",\n \"def get_meals_user_disliked(username):\\n meals_user_disliked = []\\n user_disliked = Rating.objects.filter(member__username=username, like=False)\\n for ratting in user_disliked:\\n meals_user_disliked.append(ratting.meal)\\n return meals_user_disliked\",\n \"def get_all_package_ids(self):\\n return self._package_cache.keys()\",\n \"def libraries(self):\\n\\n status, stdout, stderr = self.__xcall__(['--libs-only-l'])\\n\\n if status != 0:\\n raise RuntimeError(\\\"error querying --libs-only-l for package `%s': %s\\\" % (self.name, stderr))\\n\\n retval = []\\n for token in stdout.split():\\n retval.append(token[2:])\\n\\n return uniq(retval)\",\n \"def get_all_packages(self):\\n return self._package_cache.values()\",\n \"def required_packages(cls) -> List[Text]:\\n return []\",\n \"def get_required_packages(self) -> list:\\n\\t\\tret = []\\n\\t\\tlocal_packages = ChocoInfo.get_local_packages(\\n\\t\\t\\tPUSHED_PACKAGES_PATH)\\n\\n\\t\\tprint(\\\"local_packages\\\", local_packages)\\n\\n\\t\\treturn [c_package for c_package in self._community_packages if c_package not in local_packages]\",\n \"def user_dependencies(self, host, user):\\n return search_api(\\\"user_dependencies\\\", host, user)\",\n \"def getIgnoredDict(self):\\n return self.ignored\",\n \"def packages():\",\n \"def get_packages(package):\\n return [dirpath\\n for dirpath, dirnames, filenames in os.walk(package)\\n if os.path.exists(os.path.join(dirpath, '__init__.py'))]\",\n \"def get_packages(package):\\n return [dirpath\\n for dirpath, dirnames, filenames in os.walk(package)\\n if os.path.exists(os.path.join(dirpath, '__init__.py'))]\",\n \"def get_packages(package):\\n return [dirpath\\n for dirpath, dirnames, filenames in os.walk(package)\\n if os.path.exists(os.path.join(dirpath, '__init__.py'))]\",\n \"def removeIgnore(self, hostmask):\\n assert ircutils.isUserHostmask(hostmask), 'got %s' % hostmask\\n return self.ignores.pop(hostmask)\",\n \"def isIgnoredPackage(self, *args):\\n return _libsbml.SBMLDocument_isIgnoredPackage(self, *args)\",\n \"def get_installed_jre_packages():\\n # Convert to a set and back to a list again to uniqueify.\\n return sorted(list(set(rpm_query_whatprovides('java', 'java7', 'jdk'))))\",\n \"def get_packages(package):\\n return [\\n dirpath\\n for dirpath, dirnames, filenames in os.walk(package)\\n if os.path.exists(os.path.join(dirpath, '__init__.py'))\\n ]\",\n \"def missing_dependencies_by_extra(package=\\\"sunpy\\\", exclude_extras=None):\\n exclude_extras = exclude_extras or []\\n requirements = get_requirements(package)\\n missing_dependencies = {}\\n for group in requirements.keys():\\n if group in exclude_extras:\\n continue\\n missing_dependencies[group] = find_dependencies(package, [group])[0]\\n return missing_dependencies\",\n \"def get_whitelisted_packages() -> Mapping[str, Union[str, None]]:\\n with (here / WHITELISTED_PACKAGES_FILE).open() as fh:\\n package_data = json.load(fh)\\n return {\\n key.upper().strip(): val.upper().strip() if val else val\\n for key, val in package_data.items()\\n }\",\n \"def GetPackages(self, package_target):\\n return self._packages.get(package_target, None)\",\n \"def disableUnusedPackages(self, *args):\\n return _libsbml.SBMLExtensionRegistry_disableUnusedPackages(self, *args)\",\n \"def get_theme_base_dirs_unchecked():\\n theme_dirs = getattr(settings, \\\"COMPREHENSIVE_THEME_DIRS\\\", None)\\n\\n return get_theme_base_dirs_from_settings(theme_dirs)\",\n \"def get_hook_root_info ( self, nonlinked_only=False ):\\n if nonlinked_only:\\n return [\\n ( script.name, [] )\\n for script, user_scripts in self.hook_root.iter_linked()\\n if not user_scripts\\n ]\\n else:\\n return [\\n (\\n script.name,\\n [ ( s.event or \\\"undef\\\", s.priority ) for s in user_scripts ]\\n )\\n for script, user_scripts in self.hook_root.iter_linked()\\n ]\",\n \"def pkg_service_blacklist(klass, pkg):\\n return klass._pkg_service_blacklist.get(pkg.name, [])\",\n \"def isDisabledIgnoredPackage(self, *args):\\n return _libsbml.SBMLDocument_isDisabledIgnoredPackage(self, *args)\",\n \"def get_lb_pkgs(self):\\r\\n\\r\\n lb_filter = '*Load Balancer*'\\r\\n _filter = NestedDict({})\\r\\n _filter['items']['description'] = query_filter(lb_filter)\\r\\n\\r\\n kwargs = NestedDict({})\\r\\n kwargs['id'] = 0 # look at package id 0\\r\\n kwargs['filter'] = _filter.to_dict()\\r\\n packages = self.prod_pkg.getItems(**kwargs)\\r\\n pkgs = []\\r\\n for package in packages:\\r\\n if not package['description'].startswith('Global'):\\r\\n pkgs.append(package)\\r\\n return pkgs\",\n \"def packages(self):\\n\\n if self._packages:\\n return self._packages\\n\\n self._load()\\n return self._packages\",\n \"def get_user_ids() -> List[str]:\\n listOfFiles = os.listdir('public_dataset')\\n listOfFiles.remove('data_description.pdf')\\n try:\\n listOfFiles.remove('.DS_Store')\\n except:\\n pass\\n return listOfFiles\",\n \"def have_package_lists():\\n return 'Filename:' in execute('apt-cache', 'show', 'python', check=False, capture=True)\",\n \"def __dir__():\\n import pkgutil\\n\\n names = [\\n name\\n for importer, name, ispkg in pkgutil.iter_modules(__path__)\\n if not ispkg and name != \\\"base\\\"\\n ]\\n return names + [\\\"custom\\\", \\\"noData\\\"]\",\n \"def fake_get_user_repo_names_and_locations(self):\\n self._get_user_repo_names_and_locations()\",\n \"def get_repos_user(user='xmonader'):\\n u = ghclient.get_user(login=user)\\n repos = u.get_repos()\\n repos_list = []\\n for i in range(20):\\n page = repos.get_page(i)\\n if len(page) == 0:\\n break\\n repos_list.extend(repos.get_page(i))\\n return repos_list\",\n \"def get_outdated_packages(self, pip_path=\\\"pip\\\"):\\n output_re = [re.compile(r) for r in [\\n # newer pip\\n r'^(.+) \\\\(Current: (.+) Latest: (.+)\\\\)$',\\n # old pip\\n r'^(.+) \\\\((.+)\\\\) - Latest: (.+) .*$',\\n ]]\\n pkgs = {}\\n out = self.check_output(\\\"%s list -o\\\", pip_path)\\n for line in out.splitlines():\\n # Warning: cannot find svn location for rst2pdf==0.93.dev-r0\\n # Could not find any downloads that satisfy the requirement iotop\\n if line.startswith('Warning: ') or line.startswith('Could not '):\\n continue\\n for out_re in output_re:\\n match = out_re.match(line)\\n if match:\\n name, current, latest = match.groups()\\n pkgs[name] = {'current': current, 'latest': latest}\\n break\\n else:\\n raise RuntimeError(\\\"could not parse {0}\\\".format(repr(line)))\\n return pkgs\",\n \"def get_disabled_plugins(self):\\n return self._disabled_plugins\",\n \"def ignore(self) -> list[str] | list[None]:\\n if self._ignore is None:\\n print(self.__class__.ignore.__doc__)\\n raise SilSubProblemError(\\n \\\"The *ignore* property has not been set (see above).\\\"\\n )\\n return self._ignore\",\n \"def missingTranslationPkgs(self, pkg, translation_pkg):\\n\\n # FIXME: this function is called too often and it's too slow\\n # -> see ../TODO for ideas how to fix it\\n missing = []\\n # check if the pkg itself is available and installed\\n if not self._cache.has_key(pkg):\\n return missing\\n if not self._cache[pkg].isInstalled:\\n return missing\\n\\n # match every packages that looks similar to translation_pkg\\n # \\n for pkg in self._cache:\\n if (pkg.name == translation_pkg or\\n pkg.name.startswith(translation_pkg+\\\"-\\\")):\\n if not pkg.isInstalled and pkg.candidateVersion != None:\\n missing.append(pkg.name)\\n return missing\",\n \"def user_site_packages() -> str:\\n if os.name == 'nt':\\n return os.path.join(user_plugin_dir(), 'Lib', 'site-packages')\\n\\n python_dir = f'python{sys.version_info.major}.{sys.version_info.minor}'\\n return os.path.join(user_plugin_dir(), 'lib', python_dir, 'site-packages')\",\n \"def remove_packages_ignored_since(days, paths=None, dry_run=False, verbose=False):\\n num_removed = 0\\n\\n for path in (paths or config.packages_path):\\n repo = package_repository_manager.get_repository(path)\\n\\n if verbose:\\n print_info(\\\"Searching %s...\\\", repo)\\n\\n num_removed += repo.remove_ignored_since(\\n days=days,\\n dry_run=dry_run,\\n verbose=verbose\\n )\\n\\n return num_removed\",\n \"def import_packages_global():\\n return \\\"\\\"\",\n \"def repositories(self, user_name=None):\\n user_name = user_name if user_name else self._auth[0]\\n data = self._request('GET', 'users', user_name)\\n return data.repositories\\n #ret_val = []\\n #for repository in data.repositories:\\n # ret_val.append(repository.name)\\n # #print 'repo', repository['name'] # can use as dict or as object\\n #return ret_val\",\n \"def getImportList():\\n\\timports = []\\n\\tfor line in vim.current.buffer:\\n\\t\\twords = string.split(line)\\n\\t\\tif (len(words)>0 and (words[0]=='import' or words[0]=='from')):\\n\\t\\t\\tif words[1] not in imports:\\n\\t\\t\\t\\timports.append(words[1])\\n\\treturn imports\",\n \"def locked(user):\\n\\n cmd = \\\"lsuser -a account_locked {}\\\".format(user)\\n cmd += ' | grep \\\"account_locked=true\\\"'\\n out = __salt__[\\\"cmd.run_all\\\"](cmd, output_loglevel=\\\"trace\\\", python_shell=True)\\n\\n ret = []\\n\\n lines = out[\\\"stdout\\\"].splitlines()\\n for line in lines:\\n ret.append(line.split()[0])\\n\\n return ret\",\n \"def get_site_packages():\\n # Another hack...\\n # Relies on the fact that os.py is in the dir above site_packages\\n os_location = os.path.dirname(os.__file__)\\n site_packages = []\\n # Consider Debian/Ubuntu custom\\n for site in [\\\"site-packages\\\", \\\"dist-packages\\\"]:\\n site_path = os.path.join(os_location, site)\\n if os.path.isdir(site_path):\\n site_packages.append(site_path)\\n return site_packages\",\n \"def remove_packages(self, packages):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70381504","0.60557246","0.6004433","0.599181","0.59327734","0.5899515","0.5897012","0.58251196","0.56858665","0.5647229","0.56442803","0.5642458","0.56385034","0.5618204","0.55391264","0.5537971","0.5523503","0.54886055","0.54812515","0.5385388","0.53471607","0.5343567","0.5323355","0.5312438","0.5310096","0.5282628","0.5269992","0.5269389","0.5263653","0.52494454","0.5236585","0.5223805","0.5221316","0.5207234","0.52061796","0.5201467","0.5200008","0.5197159","0.5192414","0.51719886","0.51676434","0.51633227","0.5161296","0.51532376","0.5149886","0.5149413","0.5136569","0.51084375","0.5104233","0.51015633","0.508361","0.50818026","0.507831","0.507046","0.5070028","0.5068598","0.50615716","0.5057659","0.5055331","0.50532764","0.50521636","0.50483525","0.5047626","0.5042793","0.5036464","0.5027595","0.50130755","0.50130755","0.50130755","0.50081235","0.50075084","0.5005604","0.5002179","0.49999753","0.49915594","0.49909717","0.49884403","0.4988009","0.4982285","0.4978867","0.49738917","0.49666128","0.49638325","0.49557695","0.49557474","0.49546388","0.49542502","0.49402535","0.49374247","0.49369204","0.49276268","0.49231443","0.49212217","0.49150333","0.49122903","0.4908893","0.4908227","0.4895763","0.4894614","0.48892713"],"string":"[\n \"0.70381504\",\n \"0.60557246\",\n \"0.6004433\",\n \"0.599181\",\n \"0.59327734\",\n \"0.5899515\",\n \"0.5897012\",\n \"0.58251196\",\n \"0.56858665\",\n \"0.5647229\",\n \"0.56442803\",\n \"0.5642458\",\n \"0.56385034\",\n \"0.5618204\",\n \"0.55391264\",\n \"0.5537971\",\n \"0.5523503\",\n \"0.54886055\",\n \"0.54812515\",\n \"0.5385388\",\n \"0.53471607\",\n \"0.5343567\",\n \"0.5323355\",\n \"0.5312438\",\n \"0.5310096\",\n \"0.5282628\",\n \"0.5269992\",\n \"0.5269389\",\n \"0.5263653\",\n \"0.52494454\",\n \"0.5236585\",\n \"0.5223805\",\n \"0.5221316\",\n \"0.5207234\",\n \"0.52061796\",\n \"0.5201467\",\n \"0.5200008\",\n \"0.5197159\",\n \"0.5192414\",\n \"0.51719886\",\n \"0.51676434\",\n \"0.51633227\",\n \"0.5161296\",\n \"0.51532376\",\n \"0.5149886\",\n \"0.5149413\",\n \"0.5136569\",\n \"0.51084375\",\n \"0.5104233\",\n \"0.51015633\",\n \"0.508361\",\n \"0.50818026\",\n \"0.507831\",\n \"0.507046\",\n \"0.5070028\",\n \"0.5068598\",\n \"0.50615716\",\n \"0.5057659\",\n \"0.5055331\",\n \"0.50532764\",\n \"0.50521636\",\n \"0.50483525\",\n \"0.5047626\",\n \"0.5042793\",\n \"0.5036464\",\n \"0.5027595\",\n \"0.50130755\",\n \"0.50130755\",\n \"0.50130755\",\n \"0.50081235\",\n \"0.50075084\",\n \"0.5005604\",\n \"0.5002179\",\n \"0.49999753\",\n \"0.49915594\",\n \"0.49909717\",\n \"0.49884403\",\n \"0.4988009\",\n \"0.4982285\",\n \"0.4978867\",\n \"0.49738917\",\n \"0.49666128\",\n \"0.49638325\",\n \"0.49557695\",\n \"0.49557474\",\n \"0.49546388\",\n \"0.49542502\",\n \"0.49402535\",\n \"0.49374247\",\n \"0.49369204\",\n \"0.49276268\",\n \"0.49231443\",\n \"0.49212217\",\n \"0.49150333\",\n \"0.49122903\",\n \"0.4908893\",\n \"0.4908227\",\n \"0.4895763\",\n \"0.4894614\",\n \"0.48892713\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.51812875"},"document_rank":{"kind":"string","value":"39"}}},{"rowIdx":21995,"cells":{"query":{"kind":"string","value":"Convert userprovided data into glob expressions."},"document":{"kind":"string","value":"def _resolve_arguments(patterns, packages_path, search_packages_path):\n\n def _read_patterns(path):\n try:\n with open(path, \"r\") as handler:\n return set(handler.read().splitlines())\n except IOError:\n return set()\n\n ignore_patterns = set()\n\n for item in patterns:\n if os.path.isfile(item) or os.path.isabs(item):\n # This happens in 2 scenarios\n # 1. The user-given pattern is actually a path on-disk\n # 2. The user does bash process substitution (e.g.\n # `rez-batch-process report --ignore-patterns <(cat patterns.txt)`)\n #\n ignore_patterns.update(_read_patterns(item))\n else:\n ignore_patterns.add(item)\n\n if isinstance(packages_path, six.string_types):\n packages_path = packages_path.split(os.pathsep)\n\n if isinstance(search_packages_path, six.string_types):\n search_packages_path = search_packages_path.split(os.pathsep)\n\n return ignore_patterns, packages_path, search_packages_path"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def to_globs(self, build_patterns: Iterable[str]) -> Tuple[str, ...]:","def glob2re(glob: str) -> str: # pylint: disable=too-many-branches\n index = 0\n size = len(glob)\n results: List[str] = []\n\n while index < size:\n char = glob[index]\n index += 1\n\n if char == \"*\":\n if index < size and glob[index] == \"*\":\n index += 1\n if results and results[-1] == \"/\" and index < size and glob[index] == \"/\":\n results.append(\"(.*/)?\")\n index += 1\n else:\n results.append(\".*\")\n else:\n results.append(\"[^/]*\")\n\n elif char == \"?\":\n results.append(\"[^/]\")\n\n elif char == \"[\":\n end_index = index\n while end_index < size and glob[end_index] != \"]\":\n end_index += 1\n\n if end_index >= size:\n results.append(\"\\\\[\")\n\n else:\n characters = glob[index:end_index].replace(\"\\\\\", \"\\\\\\\\\")\n index = end_index + 1\n\n results.append(\"[\")\n\n if characters[0] == \"!\":\n results.append(\"^/\")\n characters = characters[1:]\n elif characters[0] == \"^\":\n results.append(\"\\\\\")\n\n results.append(characters)\n results.append(\"]\")\n\n elif char in \"{}/\":\n results.append(char)\n\n else:\n results.append(re.escape(char))\n\n return \"\".join(results)","def to_glob(self) -> str:","def glob_paths(self, name, source, pattern, test_data=()):\n assert isinstance(source, config_types.Path)\n result = self._run(\n name, ['glob', source, pattern],\n lambda: self.test_api.glob_paths(test_data),\n self.m.raw_io.output_text())\n ret = [source.join(*x.split(self.m.path.sep))\n for x in result.stdout.splitlines()]\n result.presentation.logs[\"glob\"] = map(str, ret)\n return ret","def glob_patterns(separator=os.path.sep, **kwargs):\n terms = [kwargs.pop(field, '*')\n for field in NormalizedSceneId.tuple_type._fields]\n assert not kwargs, 'Unrecognized field names: {}'.format(kwargs)\n\n # terms which are not str are assumed to contain choices (list of str)\n choice_inds = [i for i, val in enumerate(terms) if not isinstance(val, str)]\n val_lists = [terms[i][:] for i in choice_inds]\n\n patterns = []\n for values in it.product(*val_lists):\n for i, ind in enumerate(choice_inds):\n terms[ind] = values[i]\n patterns.append(separator.join(terms))\n return patterns","def glob_to_regex(glob):\n res = \"\"\n for c in glob:\n if c == \"*\":\n res = res + \".*\"\n elif c == \"?\":\n res = res + \".\"\n else:\n res = res + re.escape(c)\n\n # \\A anchors at start of string, \\Z at end of string\n return re.compile(r\"\\A\" + res + r\"\\Z\", re.IGNORECASE)","def getGlobArgs(self):\n dirname,pattern = '/tmp','trash2*.txt'\n return dirname, pattern","def glob(patterns: list[str]) -> Table:\n for val in _ensure_list(patterns):\n fol, _, pat = val.partition(\"/*\")\n folder = Path(fol)\n for file in folder.glob(\"*\" + pat):\n yield {\"file\": str(file)}","def _glob_to_sql(self, string):\n\n # What's with the chr(1) and chr(2) nonsense? It's a trick to\n # hide \\* and \\? from the * and ? substitutions. This trick\n # depends on the substitutiones being done in order. chr(1)\n # and chr(2) were picked because I know those characters\n # almost certainly won't be in the input string\n table = ((r'\\\\', chr(1)), (r'\\*', chr(2)), (r'\\?', chr(3)),\n (r'%', r'\\%'), (r'?', '_'), (r'*', '%'),\n (chr(1), r'\\\\'), (chr(2), r'\\*'), (chr(3), r'\\?'))\n\n for (a, b) in table:\n string = string.replace(a,b)\n\n string = string[1:] if string.startswith(\"^\") else \"%\" + string\n string = string[:-1] if string.endswith(\"$\") else string + \"%\"\n\n return string","def _get_data_glob(split, fake_data, glob_dir=None):\n if fake_data:\n return flags.FLAGS.criteo_dummy_path_for_test\n\n if glob_dir is None:\n glob_path = {'train': flags.FLAGS.criteo_train_glob,\n 'test': flags.FLAGS.criteo_test_glob,\n 'valid': flags.FLAGS.criteo_valid_glob}[split]\n if glob_path is None:\n raise ValueError('One of glob_dir or FLAGS.criteo_split_glob',\n 'needs to be specified')\n else:\n return glob_path\n else:\n return glob_dir","def glob(self):\n self._deduplicate()\n result = []\n for entry in self._entries:\n pp = entry.posix_path()\n if GLOBBABLE_REGEX.search(pp):\n try:\n globs = glob.glob(entry.posix_path())\n result += globs\n except re.error:\n result.append(pp)\n else:\n result.append(pp)\n self._entries = [Path(g) for g in result]\n self._clean = False\n self._current = 0","def insensitive_glob(pattern):\n def either(c):\n return '[%s%s]' % (c.lower(), c.upper()) if c.isalpha() else c\n\n file_list = sorted(glob.glob(''.join(map(either, pattern))))\n\n return file_list","def uvm_glob_to_re(_str):\n if _str is None or _str == \"\":\n return \"\"\n if _str[0] == \"/\" and _str[-1] == \"/\":\n return _str\n # TODO replace * with .*\n res = _str.replace('.', '\\\\.')\n res = res.replace('*', '.*')\n res = res.replace('[', '\\\\[')\n res = res.replace(']', '\\\\]')\n res = res.replace('?', '.')\n # TODO add more substitutions\n return res","def split_and_glob(s: str = None) -> list:\n ret = []\n if s is not None:\n for glob in s.split(','):\n if glob != '':\n ret.append(partial(fnmatch, glob))\n return ret","def GetInputFilenameGlob(pattern):\n if not indir:\n return glob.glob(fname)\n files = []\n for dirname in indir:\n pathname = os.path.join(dirname, pattern)\n files += glob.glob(pathname)\n return sorted(files)","def test_glob_pattern(self):\n glob_pattern = GlobPattern()\n det_name = 'R22_S11'\n self.assertEqual(glob_pattern('fe55', det_name),\n 'fe55_fe55_*/*_{}.fits'.format(det_name))\n self.assertEqual(glob_pattern('cte_low', det_name),\n 'sflat_*_flat_*L*/*_{}.fits'.format(det_name))","def glob(adapts):\n def decorate(func):\n frame = sys._getframe(1)\n name = '__zeit_edit_globs__'\n globs = frame.f_locals.get(name, None)\n if globs is None:\n frame.f_locals[name] = globs = []\n globs.append((func, adapts))\n return func\n return decorate","def expand(self, path_list):\n path_list2 = []\n for path in path_list:\n if glob.has_magic(path):\n iterator = glob.iglob(path)\n path_list2.extend(iterator)\n else:\n path_list2.append(path)\n return path_list2","def get_glob_strings(subdirglob):\n dirname = path.dirname(subdirglob)\n basename = path.basename(subdirglob)\n assert (((\"_M1_\" in subdirglob) or (\"_M2_\" in subdirglob)) or (\"_S_\" in subdirglob)), \\\n (\"_M1_ or _M2_ not in subdirglob, cant differentiate between M1 and M2, aborting.\"\n f\"glob: {subdirglob}\")\n if (\"*\" not in subdirglob) and (\"_S_\" not in basename):\n newbasename = basename.replace(\"_M2_\", \"_M1_\"), basename.replace(\"_M1_\", \"_M2_\")\n return path.join(dirname, newbasename[0]), path.join(dirname, newbasename[1])\n elif (\"_M1_\" or \"_M2_\") in basename:\n newbasename = basename.replace(\"_M2_\", \"_M1_\"), basename.replace(\"_M1_\", \"_M2_\")\n return path.join(dirname, newbasename[0]), path.join(dirname, newbasename[1])\n elif \"_S_\" in basename:\n return basename","def to_pattern(obj):\n if isinstance(obj, Pattern):\n return obj\n return Glob(str(obj))","def glob_fmt(pattern: str, *templates: Strings) -> List[str]:\n results: List[str] = []\n for wildcards in glob_extract(pattern):\n for template in each_string(*templates):\n results.append(copy_annotations(template, template.format(**wildcards)))\n return results","def glob1(self, dirname, pattern):\n names = self.listdir(dirname)\n if pattern[0] != '.':\n names = filter(lambda x: x[0] != '.',names)\n return fnmatch.filter(names, pattern)","def test_get_files(self):\n glob_manager = GlobManager(['*'])\n self.assertCountEqual(\n glob_manager.get_files(),\n {\n 'bob.py', 'dave.txt', 'fred.txt.py', 'geoff.py', 'jim.py.txt',\n 'rob.txt'\n })\n\n glob_manager = GlobManager(['*.py'])\n self.assertCountEqual(\n glob_manager.get_files(), {'bob.py', 'fred.txt.py', 'geoff.py'})\n\n glob_manager = GlobManager(['*.py', '*.txt'])\n self.assertCountEqual(\n glob_manager.get_files(),\n {\n 'bob.py', 'dave.txt', 'fred.txt.py', 'geoff.py', 'jim.py.txt',\n 'rob.txt'\n })\n\n glob_manager = GlobManager(['**/*.py'])\n self.assertCountEqual(\n glob_manager.get_files(),\n {\n 'bob.py',\n 'fred.txt.py',\n 'geoff.py',\n 'animals/dog.py',\n 'animals/mouse.txt.py',\n 'animals/sheep.py',\n 'animals/vehicles/bus.py',\n 'animals/vehicles/aeroplane.txt.py',\n 'animals/vehicles/tractor.py'\n })\n\n glob_manager = GlobManager(['bob.py'])\n self.assertCountEqual(glob_manager.get_files(), {'bob.py'})\n\n glob_manager = GlobManager(['bob.py', 'bob.py'])\n self.assertCountEqual(glob_manager.get_files(), {'bob.py'})\n\n glob_manager = GlobManager(\n [os.path.join(self.temp_dir.name, file_name) for file_name in [\n 'bob.py', 'geoff.py']])\n self.assertCountEqual(glob_manager.get_files(), {'bob.py', 'geoff.py'})","def glob(url, separator=','):\n patterns = [url] if separator is None else url.split(separator)\n result = []\n for pattern in patterns:\n result.extend(_glob.glob(os.path.expanduser(pattern.strip())))\n return result","def glob(self, pathname, with_matches=False):\r\n return list(self.iglob(pathname, with_matches))","def _filenames(self, dir_or_file):\n if os.path.isdir(dir_or_file):\n return glob(os.path.join(dir_or_file, \"*.txt\"))\n else:\n return [dir_or_file]","def _data_filter(data: str) -> list:\n\n return PROXIES_DATA_REGEX.findall(str(data))","def glob_fs(self):\n\n found_files = []\n for pattern in self.glob_patterns:\n found_files += [PathString(present_file)\n for present_file in glob.glob(pattern)]\n return found_files","def glob_datasets(glob_paths: Sequence[str]):\n if len(glob_paths) == 0:\n raise ValueError(\"No dataset path provided.\")\n\n # Apply glob:\n paths = tuple(glob.glob(glob_path) for glob_path in glob_paths)\n\n if len(paths) == 0:\n raise ValueError(\"Could not find any dataset with provided paths\", glob_paths)\n\n # concatenate list of paths:\n paths = reduce(lambda u, v: u + v, paths)\n\n # remove empty paths:\n paths = (path.strip() for path in paths)\n\n # remove empty paths:\n paths = (path for path in paths if len(path) > 0)\n\n # sort paths:\n paths = sorted(list(paths))\n\n return open_joined_datasets(paths), paths","def infile_list(args):\n infiles = []\n for arg in args:\n infiles += glob.glob(arg)\n infiles = [pipes.quote(f) for f in infiles]\n return infiles","def set_in_files():\r\n\tindatadir = '/nobackup/ejblom/reddit'\r\n\tcom_dir = '/comments'\r\n\tsubm_dir = '/submissions'\r\n\tglob_end = '/filtered*'\r\n\tcom_glob_str = indatadir + com_dir + glob_end\r\n\tsubm_glob_str = indatadir + subm_dir + glob_end\r\n\tinfilenames = sorted(glob.glob(com_glob_str)) + sorted(glob.glob(subm_glob_str))\r\n\treturn infilenames","def resolveShellPatternToFilenames(pattern):\n\n if \"**\" in pattern:\n if python_version >= 0x350:\n result = glob.glob(pattern, recursive=True)\n else:\n glob2 = importFromInlineCopy(\"glob2\", must_exist=False)\n\n if glob2 is None:\n options_logger.sysexit(\n \"Using pattern with '**' is not supported before Python 3.5 unless glob2 is installed.\"\n )\n\n result = glob2.glob(pattern)\n else:\n result = glob.glob(pattern)\n\n result = [os.path.normpath(filename) for filename in result]\n result.sort()\n return result","def recursive_glob(path):\n if \"*\" not in path:\n # Glob isn't needed.\n return [path]\n elif \"**\" not in path:\n # Recursive glob isn't needed.\n return path_utils.glob(path)\n else:\n return path_utils.glob(path, recursive=True)","def _find_data_files(pattern: str) -> List[str]:\n file_list = glob.glob(pattern)\n if not file_list:\n raise ValueError('No files found matching: ' + str(pattern))\n sorted_file_list = sorted(file_list, key=numerical_sort)\n return sorted_file_list","def filenamePatterns(self):\n return ['*.'+e for e in self.filenameExtensions]","def _iglob(pathname):\n dirname, basename = os.path.split(pathname)\n if not _glob.has_magic(pathname):\n if basename:\n if os.path.lexists(pathname):\n yield pathname\n else:\n raise FileNotFoundError\n else:\n if os.path.isdir(dirname):\n yield pathname\n else:\n raise NotADirectoryError\n return\n if not dirname:\n if basename == '**':\n for name in _glob2(dirname, basename):\n yield name\n else:\n for name in _glob.glob1(dirname, basename):\n yield name\n return\n if dirname != pathname and _glob.has_magic(dirname):\n dirs = _iglob(dirname)\n else:\n dirs = [dirname]\n if _glob.has_magic(basename):\n if basename == '**':\n glob_in_dir = _glob2\n else:\n glob_in_dir = _glob.glob1\n else:\n glob_in_dir = _glob.glob0(dirname, basename)\n for dirname in dirs:\n for name in glob_in_dir(dirname, basename):\n yield os.path.join(dirname, name)","def glob_xpcs_datasets(path: str = None, regex: str = None, extensions: Tuple = None, **data) -> List[str]:\n from pathlib import Path\n\n def walk(path): \n for p in Path(path).iterdir(): \n if p.is_dir(): \n yield from walk(p)\n continue\n yield p.resolve()\n\n \n\n datasets = [str(p) for p in walk(path) if\n (not regex or p.match(regex)) and \n (not extensions or p.suffix in extensions)]\n metadata_files = []\n for d in datasets:\n hdf_file = None\n dataset_dir = Path(d).parent\n for f in dataset_dir.iterdir():\n if f.suffix == '.hdf':\n hdf_file = f\n metadata_files.append(hdf_file)\n\n return [(str(d), str(q)) for d, q in zip(datasets, metadata_files) if d and q]","def globfiles(path, pattern):\n return Path(path).glob(pattern)","def expand_path(__file__, path_with_globs):\n return glob.glob(relative_path(__file__, path_with_globs))","def zglobs(cls, *globspecs, **kw):\r\n root = kw.pop('root', os.curdir)\r\n patterns = [(os.path.basename(spec).startswith('*'),\r\n re.compile(fnmatch_translate_extended(spec))) for spec in globspecs]\r\n\r\n def matcher(path):\r\n for no_hidden, pattern in patterns:\r\n # Ignore hidden files when globbing wildcards.\r\n if not (no_hidden and os.path.basename(path).startswith('.')):\r\n if pattern.match(path):\r\n return True\r\n return False\r\n\r\n return cls(lambda: set(cls._do_rglob(matcher, allow_dirs=True, root=root, **kw)))","def glob(glob_pattern: str, directoryname: str) -> List[str]:\n matches = []\n for root, dirnames, filenames in os.walk(directoryname):\n for filename in fnmatch.filter(filenames, glob_pattern):\n absolute_filepath = os.path.join(root, filename)\n matches.append(absolute_filepath)\n return matches","def globs(cls, *globspecs, **kw):\r\n root = kw.pop('root', os.curdir)\r\n def relative_glob(globspec):\r\n for fn in glob.glob(os.path.join(root, globspec)):\r\n yield os.path.relpath(fn, root)\r\n def combine(files, globspec):\r\n return files ^ set(relative_glob(globspec))\r\n return cls(lambda: reduce(combine, globspecs, set()))","def _glob_files(directories, extensions):\n pwd = Path(__file__).resolve().parent\n open3d_root_dir = pwd.parent\n\n file_paths = []\n for directory in directories:\n directory = open3d_root_dir / directory\n for extension in extensions:\n extension_regex = \"*.\" + extension\n file_paths.extend(directory.rglob(extension_regex))\n file_paths = [str(file_path) for file_path in file_paths]\n file_paths = sorted(list(set(file_paths)))\n return file_paths","def match_glob(pathname):\n # type: (six.text_type) -> List[six.text_type]\n if sys.version_info >= (3, 5):\n result = glob.glob(pathname, recursive=True)\n else:\n # use the third party glob library to handle a recursive glob.\n result = glob2.glob(pathname)\n return result","def glob(path: str) -> list[str]:\n fs, relative_path = url_to_fs(path)\n return cast(list[str], fs.glob(relative_path))","def _input_as_string(self,data):\n inputFiles = ' '.join(data)\n self._input_filename = data\n return inputFiles","def pairof_MOGUK_search_filepaths(date_string, n_hour, data_basepath=default_data_basepath):\n hr_string = \"%02d\" % n_hour\n glob_spec_strs = [data_basepath + date_string + hr_string + t_s for t_s in ('*speed10mmean.grib','*dir10mmean.grib')]\n return glob_spec_strs","def globits(patt):\n files = glob(patt)\n pre,suf = patt.split('*')\n its = []\n for file in files:\n s = re.sub(r'^' + re.escape(pre), '', file)\n s = re.sub(re.escape(suf) + r'$', '', s)\n s = re.sub(r'^0*', '', s)\n its.append(int(s))\n\n its.sort()\n return its","def read_data(path, glob_ptrn, germeval=False):\n if os.path.isdir(path):\n return read_dir(iglob(os.path.join(path, glob_ptrn)), germeval)\n return read_file(path, germeval)","def decompose_data_path(data_path):\n ns = {\"base\": _TokenizeDataPath(())}\n return list(eval(\"base\" + data_path, ns, ns))","def find_data_files(pattern: str) -> List[str]:\n file_list = glob.glob(pattern)\n if not file_list:\n raise ValueError('No files found matching: ' + str(pattern))\n sorted_file_list = sorted(file_list, key=numerical_sort)\n return sorted_file_list","def populate(self, dr=None):\n if dr is not None: self.directory = dr\n \n for k in OM.glob_strings:\n string =self.directory+\"/\"+OM.glob_strings[k]\n print(\"OM::populate -- Checking \",k,\" (\",string,\")\", end=\"\")\n fnames = glob.glob(string)\n print(\"... found\",len(fnames), \"files\")\n setattr(self, k, fnames)\n #print(k, lst)","def expand_paths(__file__, paths_with_globs):\n if isinstance(paths_with_globs, str):\n return expand_path(__file__, paths_with_globs)\n else:\n expanded_globs = [\n expand_path(__file__, path) for path in paths_with_globs\n ]\n # Flatten\n return list(itertools.chain.from_iterable(expanded_globs))","def find_data_files_distutils(self, package, src_dir):\n from glob import glob\n import os\n from distutils.util import convert_path\n\n globs = (self.package_data.get('', [])\n + self.package_data.get(package, []))\n files = []\n for pattern in globs:\n # Each pattern has to be converted to a platform-specific path\n filelist = glob(os.path.join(src_dir, convert_path(pattern)))\n # Files that match more than one pattern are only added once\n files.extend([fn for fn in filelist if fn not in files\n and (os.path.isfile(fn) or os.path.islink(fn))])\n return files","def data_files(self, pattern=None, regex=None):\n return self._files_in_subdir(self.data_dir, pattern, regex)","def buildListOfFiles(searchGlob):\n return [fpath for fpath in glob2.iglob(searchGlob) if os.path.isfile(fpath)]","def glob_escape(pathname):\n # Escaping is done by wrapping any of \"*?[\" between square brackets.\n # Metacharacters do not work in the drive part and shouldn't be escaped.\n drive, pathname = os.path.splitdrive(pathname)\n if isinstance(pathname, bytes):\n pathname = _magic_check_bytes.sub(br'[\\1]', pathname)\n else:\n pathname = _magic_check.sub(r'[\\1]', pathname)\n return drive + pathname","def eval(self):\n if self.and_or == 'or':\n return self.files\n return ' '.join(self.files)","def glob_precip_stats(reanalysis):\n\n globpath = _glob_precip_stats_dirpath(reanalysis)\n globfile = _glob_precip_stats_fname(reanalysis)\n #fileList = glob.glob( os.path.join( globpath, globfile) )\n return os.path.join( globpath, globfile)","def _get_all_files(self):\n file_pattern = _FILE_PATTERN\n file_pattern = os.path.join(self.dataset_dir,\n file_pattern % self.split_name)\n return tf.gfile.Glob(file_pattern)","def input_files_from_path(path):\n import glob\n input_files = None\n if type(path) is list:\n input_files = []\n for p in path:\n if '*' in p:\n input_files.extend(glob.glob(p))\n else: # neither wildcard nor comma separated list\n input_files.append(p)\n else:\n if ',' in path:\n input_files = path.split(',')\n elif '*' in path:\n input_files = glob.glob(path)\n else: # neither wildcard nor comma separated list\n input_files = [path]\n input_files = [os.path.abspath(f) for f in input_files]\n return [f for f in input_files if os.path.exists(f) or f.startswith('/store')]","def rglobs(cls, *globspecs, **kw):\r\n root = kw.pop('root', os.curdir)\r\n\r\n def matcher(path):\r\n for globspec in globspecs:\r\n # Ignore hidden files when globbing wildcards.\r\n if not (globspec.startswith('*') and os.path.basename(path).startswith('.')):\r\n if fnmatch.fnmatch(path, globspec):\r\n return True\r\n return False\r\n\r\n return cls(lambda: set(cls._do_rglob(matcher, allow_dirs=False, root=root, **kw)))","def to_build_file_globs(self, build_patterns: Iterable[str]) -> set[str]:\n return {\n os.path.join(f, pattern)\n for pattern in build_patterns\n for f in recursive_dirname(self.directory)\n }","def load_glob(self, match):\n\t\tpluginlist = []\n\t\tfor m in match.split(','):\n\t\t\tfor path in glob.glob(m):\n\t\t\t\tif not \"__plugin__.py\" in path and not \"__init__.py\" in path:\n\t\t\t\t\tpluginlist.append(self.load(path))\n\t\treturn pluginlist","def sglob(files_pattern):\n return sorted(glob.glob(files_pattern))","def find_data_files(source, target, patterns):\r\n if glob.has_magic(source) or glob.has_magic(target):\r\n raise ValueError(\"Magic not allowed in src, target\")\r\n ret = {}\r\n for pattern in patterns:\r\n pattern = os.path.join(source, pattern)\r\n for filename in glob.glob(pattern):\r\n if os.path.isfile(filename):\r\n targetpath = os.path.join(target, os.path.relpath(filename,source))\r\n path = os.path.dirname(targetpath)\r\n ret.setdefault(path, []).append(filename)\r\n return sorted(ret.items())","def returnFiles(input_data, fmt=IMAGE_FORMATS):\r\n if type(input_data) is list:\r\n return [returnFiles(element) for element in input_data]\r\n else:\r\n if not os.path.exists(input_data):\r\n raise OSError(\"invalid input path: {}\".format(input_data))\r\n return [pjoin(input_data, name) for name in os.listdir(\r\n input_data) if os.path.splitext(name)[1][1:] in fmt]","def get_data_files():\n data_files = []\n\n # Walk through the data directory, adding all files\n data_generator = os.walk('pypeit/data')\n for path, directories, files in data_generator:\n for f in files:\n data_path = '/'.join(path.split('/')[1:])\n data_files.append(os.path.join(data_path, f))\n\n # Add pipeline and spectrograph settings\n settings = glob.glob('pypeit/settings/settings.*')\n settings = ['/'.join(path.split('/')[1:]) for path in settings]\n data_files.extend(settings)\n\n return data_files","def glob(pattern: str) -> List[str]:\n\n path = clean_path(pattern)\n result = Stat._cache.get(path)\n\n if isinstance(result, BaseException):\n return []\n\n if result is None:\n paths = glob_files(pattern, recursive=True)\n if paths != [pattern]:\n return [clean_path(path) for path in paths]\n result = Stat._result(pattern, throw=False)\n assert not isinstance(result, BaseException)\n\n return [pattern]","def glob(self, pattern, lazy=False):\n def iterator():\n for filename in self.walk(lazy=lazy):\n if fnmatch(filename, pattern):\n yield self.__class__(filename)\n\n return lazy and iterator() or list(iterator())","def capture2glob(capture: str) -> str: # pylint: disable=too-many-statements\n index = 0\n size = len(capture)\n results: List[str] = []\n\n def _is_next(expected: str) -> bool:\n nonlocal capture, index, size\n return index < size and capture[index] == expected\n\n def _invalid(reason: str = \"\") -> None:\n nonlocal capture, index\n no_additional_complaints()\n raise RuntimeError(f'Invalid capture pattern:\\n{capture}\\n{index * \" \"}^ {reason}')\n\n def _parse_glob(glob: str, terminators: str) -> None:\n nonlocal capture, index, size\n while index < size and capture[index] not in terminators:\n index += 1\n if index < size and capture[index] == \":\":\n index += 1\n start_index = index\n while index < size and capture[index] != \"}\":\n index += 1\n glob = capture[start_index:index]\n if not _is_next(\"}\"):\n _invalid(\"missing }\")\n index += 1\n results.append(glob)\n\n while index < size:\n char = capture[index]\n index += 1\n\n if char == \"}\" and _is_next(\"}\"):\n results.append(\"}\")\n index += 1\n\n elif char == \"{\" and _is_next(\"{\"):\n results.append(\"{\")\n index += 1\n\n elif char == \"{\" and _is_next(\"*\"):\n index += 1\n if _is_next(\"*\"):\n index += 1\n _parse_glob(\"**\", \"}\")\n else:\n _parse_glob(\"*\", \":}\")\n\n else:\n results.append(char)\n\n return \"\".join(results)","def _collect_files(folders, extention='Default'):\r\n if isinstance(extention, str):\r\n if extention.lower() == 'default':\r\n extention = ['.*']\r\n else:\r\n extention = [extention]\r\n files = []\r\n for f in folders:\r\n for e in extention:\r\n files += glob(os.path.join(f, f'*{e}'))\r\n return files","def _glob_list(pattern, full_path=False):\n if full_path:\n return sorted(glob.glob(pattern))\n else:\n return sorted([os.path.basename(fpath) for fpath in glob.glob(pattern)])","def recursive_glob(stem, file_pattern):\n\n if sys.version_info >= (3, 5):\n return glob(stem + \"/**/\" + file_pattern, recursive=True)\n else:\n # gh-316: this will avoid invalid unicode comparisons in Python 2.x\n if stem == str(\"*\"):\n stem = \".\"\n matches = []\n for root, dirnames, filenames in os.walk(stem):\n for filename in fnmatch.filter(filenames, file_pattern):\n matches.append(path_join_robust(root, filename))\n return matches","def get_available_patterns() -> list:\n path_folder = os.path.join(config.ROOT_PATH, config.FOLDER_PATTERNS)\n return [f.replace(\".cells\", \"\") for f in os.listdir(path_folder) if os.path.isfile(os.path.join(path_folder, f)) and f.endswith(\".cells\")]","def generate_regex(self, pattern_to_glob):\n\n # First thing, replace '.' with '\\.' and make sure we're going\n # to match the start and the end of the pattern string.\n pattern_to_glob = re.sub(r\"\\.\", r\"\\.\", pattern_to_glob)\n pattern_to_glob = r\"^\" + pattern_to_glob + r\"$\"\n\n found_values = []\n new_val = pattern_to_glob\n\n # Find all the named attributes\n all_matches = re.findall(r\"%.+?%\", pattern_to_glob)\n\n for match_thing in all_matches:\n name = match_thing[1:-1]\n\n if match_thing not in found_values:\n # Change to a named group.\n group_string = r\"(?P<\" + name + r\">.+?)\"\n new_val = re.sub(match_thing, group_string, new_val, count=1)\n found_values.append(match_thing)\n else:\n # Use the existing group.\n group_string = r\"(?P=\" + name + r\")\"\n new_val = re.sub(match_thing, group_string, new_val, count=1)\n\n return new_val","def _populate_gitignore_items(self):\n\n # Reset the include_regexps and exclude_regexps.\n self.include_regexps = []\n self.exclude_regexps = [re.compile('.*\\.git/.*\\.lock'),\n re.compile('.*\\.baboon-timestamp'),\n re.compile('.*baboon.*')]\n\n # If there's a .gitignore file in the watched directory.\n if os.path.exists(self.gitignore_path):\n # Parse the gitignore.\n ignores = self._parse_gitignore()\n if ignores is not None:\n # Populate the regexps list with the ignores result.\n self.include_regexps += [re.compile(x) for x in ignores[0]]\n self.exclude_regexps += [re.compile(x) for x in ignores[1]]","def convertPatterns(path, sign):\r\n filters = []\r\n f = open(path, \"r\")\r\n while 1:\r\n pattern = f.readline()\r\n if not pattern:\r\n break\r\n if pattern[-1] == \"\\n\":\r\n pattern = pattern[:-1]\r\n\r\n if re.match(\"[\\t ]*$\", pattern):\r\n continue\r\n if pattern[0] == \"#\":\r\n continue\r\n filters = filters + [convertPattern(pattern, sign)]\r\n f.close()\r\n return filters","def resolve_pattern(self, dirname, pattern, globstar_with_root):\r\n\r\n if isinstance(pattern, six.text_type) and not isinstance(dirname, six.text_type):\r\n dirname = six.u(dirname, sys.getfilesystemencoding() or\r\n sys.getdefaultencoding())\r\n\r\n # If no magic, short-circuit, only check for existence\r\n if not has_magic(pattern):\r\n if pattern == '':\r\n if self.isdir(dirname):\r\n return [(pattern, ())]\r\n else:\r\n if self.exists(os.path.join(dirname, pattern)):\r\n return [(pattern, ())]\r\n return []\r\n\r\n if not dirname:\r\n dirname = os.curdir\r\n\r\n try:\r\n if pattern == '**':\r\n # Include the current directory in **, if asked; by adding\r\n # an empty string as opposed to '.', be spare ourselves\r\n # having to deal with os.path.normpath() later.\r\n names = [''] if globstar_with_root else []\r\n for top, entries in self.walk(dirname):\r\n _mkabs = lambda s: os.path.join(top[len(dirname)+1:], s)\r\n names.extend(map(_mkabs, entries))\r\n # Reset pattern so that fnmatch(), which does not understand\r\n # ** specifically, will only return a single group match.\r\n pattern = '*'\r\n else:\r\n names = self.listdir(dirname)\r\n except os.error:\r\n return []\r\n\r\n if pattern[0] != '.':\r\n # Remove hidden files by default, but take care to ensure\r\n # that the empty string we may have added earlier remains.\r\n # Do not filter out the '' that we might have added earlier\r\n names = filter(lambda x: not x or x[0] != '.', names)\r\n return fnmatch_filter(names, pattern)","def glob(self, glob_expr: str) -> Iterator[NicePath]:\n for path in self._root.glob(glob_expr):\n relative_path = path.relative_to(self._root)\n if not self._match_include(relative_path):\n continue\n if self._match_exclude(relative_path):\n continue\n\n yield NicePath(path)","def fn_to_reg(self, searchItems):\n return [re.compile(fnmatch.translate(s)) for s in searchItems]","def eval(self):\n if self.magic:\n return self.magic\n if not self.filename:\n return file_pattern.format(self.alias)\n return self.path","def getGlobusFiles(self):\n\t\treturn self.transfer_client.operation_ls(self.transfer_client.endpoint_search(DATA_ENDPOINT_NAME)[0]['name'])","def incognita(data):\n incognita =['*' for i in data]\n return incognita","def collect_feeds(args):\n\tfor arg in args:\n\t\tfor feedpath in glob.iglob(os.path.abspath(arg)):\n\t\t\tyield feedpath","def test_glob(tmp_path: Path) -> None:\n sample_original = Path(__file__).parent.joinpath(\"sample.txt\")\n\n tmp_sample1 = tmp_path.joinpath(\"sample1.txt\")\n shutil.copyfile(sample_original, tmp_sample1)\n tmp_sample2 = tmp_path.joinpath(\"sample2.txt\")\n shutil.copyfile(sample_original, tmp_sample2)\n\n tmp_sub_dir = tmp_path.joinpath(\"subdir\")\n tmp_sub_dir.mkdir()\n tmp_sample3 = tmp_sub_dir.joinpath(\"sample3.txt\")\n shutil.copyfile(sample_original, tmp_sample3)\n\n files: List[str] = glob.glob(str(tmp_path.joinpath(\"**/*.txt\")), recursive=True)\n assert files == [str(tmp_sample1), str(tmp_sample2), str(tmp_sample3)]\n\n # pathlib.Path equivalent\n file_paths: Generator[Path, None, None] = tmp_path.glob(\"**/*.txt\")\n assert [str(path) for path in file_paths] == files","def globbed(gname=None):\n def decorator(func):\n name = gname if gname is not None else f\"_{func.__name__}\"\n @wraps(func)\n def wrapped_func(*args, **kwargs):\n res = func(*args, **kwargs)\n res = glob(**{name: res})\n return res\n return wrapped_func\n return decorator","def get_input_files(self, action):\n\n def input_function(wildcards):\n \"\"\"Helper rapper function\"\"\"\n return expand(\n self.base_path_in.format(wildcards=wildcards),\n postproc=[self._get_postproc_token()],\n ext=self.extensions,\n )\n\n assert action == \"run\", \"Unsupported action\"\n return input_function","def json_fpaths() -> [str]:\n return glob.glob(f\"{RECIPES_DIRPATH}/*.json\")","def get_filenames(level, pattern=None, env='stage', ext='.fits.gz',\n iterator=True):\n if pattern is None:\n pattern = '*'\n else:\n pattern = '*' + pattern + '*'\n path = get_data_path(level, env)\n if not os.access(str(path), os.R_OK):\n raise PathNotReadableError(path)\n result = map(str, path.glob(pattern + ext))\n return result if iterator else list(result)","def to_path_globs(self, glob_match_error_behavior: GlobMatchErrorBehavior) -> PathGlobs:\n return self._generate_path_globs((*self.includes, *self.ignores), glob_match_error_behavior)","def file_matches(self, text):\n \n #print 'Completer->file_matches: <%s>' % text # dbg\n\n # chars that require escaping with backslash - i.e. chars\n # that readline treats incorrectly as delimiters, but we\n # don't want to treat as delimiters in filename matching\n # when escaped with backslash\n \n protectables = ' ()[]{}'\n\n def protect_filename(s):\n return \"\".join([(ch in protectables and '\\\\' + ch or ch)\n for ch in s])\n\n lbuf = self.get_line_buffer()[:self.readline.get_endidx()]\n open_quotes = 0 # track strings with open quotes\n try:\n lsplit = shlex_split(lbuf)[-1]\n except ValueError:\n # typically an unmatched \", or backslash without escaped char.\n if lbuf.count('\"')==1:\n open_quotes = 1\n lsplit = lbuf.split('\"')[-1]\n elif lbuf.count(\"'\")==1:\n open_quotes = 1\n lsplit = lbuf.split(\"'\")[-1]\n else:\n return None\n except IndexError:\n # tab pressed on empty line\n lsplit = \"\"\n\n if lsplit != protect_filename(lsplit):\n # if protectables are found, do matching on the whole escaped\n # name\n has_protectables = 1\n text0,text = text,lsplit\n else:\n has_protectables = 0\n text = os.path.expanduser(text)\n \n if text == \"\":\n return [protect_filename(f) for f in self.glob(\"*\")]\n\n m0 = self.clean_glob(text.replace('\\\\',''))\n if has_protectables:\n # If we had protectables, we need to revert our changes to the\n # beginning of filename so that we don't double-write the part\n # of the filename we have so far\n len_lsplit = len(lsplit)\n matches = [text0 + protect_filename(f[len_lsplit:]) for f in m0]\n else:\n if open_quotes:\n # if we have a string with an open quote, we don't need to\n # protect the names at all (and we _shouldn't_, as it\n # would cause bugs when the filesystem call is made).\n matches = m0\n else:\n matches = [protect_filename(f) for f in m0]\n if len(matches) == 1 and os.path.isdir(matches[0]):\n # Takes care of links to directories also. Use '/'\n # explicitly, even under Windows, so that name completions\n # don't end up escaped.\n matches[0] += '/'\n return matches","def get_all_filenames_from_dir(directory,suffex, filename_allowed_list = None):\n\n files_list = list()\n if filename_allowed_list == None:\n for item in glob.glob(directory+'*'+suffex): # Example /datasets/Stock_dataset/Stocks/*.txt\n files_list.append(item) \n else:\n filename_allowed_list = [v.lower() for v in filename_allowed_list] # To avoid case sensitve\n for item in glob.glob(directory+'*'+suffex):\n if item.split(\"/\")[-1].split('.')[0].lower() in filename_allowed_list: # Since linux is case sensitive, then so is this function, make sure the names match correctly\n files_list.append(item)\n if not len(files_list) == len(filename_allowed_list):\n print 'Some Stocks files are missing'\n return files_list","def _handle_supplemental_data(self):\n\n [data.copy(self.build_directory) for data in self.supplemental_data]","def compare_ra_sigs_inputs_wc(wildcards):\n in_wc = [x.format(**wildcards) for x in compare_ra_sigs_inputs]\n in_wc = [\"/%s\"%(x) for x in in_wc]\n in_wc = \" \".join(in_wc)\n return in_wc","def _get_files(\n self,\n data_root,\n data_subset=\"full/*0\",\n signal_subset=\"*\",\n noise_subset=\"*\",\n data_type=\"raw\",\n noise_type=\"stationary\",\n noise_type_sim=None,\n mask_type=\"hitsmask_tailored\",\n signal_type=\"r0p03\",\n signal_type_sim=None,\n signal_transfer_type=None,\n suffix=\"\",\n foreground_type_sim=None,\n template_type=None,\n sub_planck=False,\n ):\n\n if signal_transfer_type is None:\n signal_transfer_type = signal_type\n\n # regularize data root\n if not os.path.exists(data_root):\n raise OSError(\"Missing data root {}\".format(data_root))\n\n # find all map files\n map_root = os.path.join(data_root, \"data_{}\".format(data_type))\n map_files = []\n data_subset = data_subset.split(\",\")\n for f in np.atleast_1d(data_subset):\n files = glob.glob(os.path.join(map_root, \"{}.fits\".format(f)))\n if not len(files):\n raise OSError(\"Missing files in data subset {}\".format(f))\n map_files.extend(files)\n data_subset = \",\".join(data_subset)\n map_files = sorted(map_files)\n map_files = [f for f in map_files if os.path.basename(f).startswith(\"map_\")]\n map_tags = [\n os.path.splitext(os.path.basename(f))[0].split(\"_\", 1)[1] for f in map_files\n ]\n map_freqs = []\n for t in map_tags:\n # if map tag is not a plain frequency, extract plain frequency\n map_freqs.append(self.dict_freqs[t])\n self.log(\"Found {} map files in {}\".format(len(map_files), map_root), \"info\")\n self.log(\"Map files: {}\".format(map_files), \"debug\")\n self.log(\"Map freqs: {}\".format(map_freqs), \"debug\")\n\n raw_root = None\n raw_files = None\n # find all corresponding signal sims\n signal_root = os.path.join(data_root, \"signal_{}\".format(signal_type))\n num_signal = None\n signal_files = []\n for f in map_files:\n sfiles = sorted(\n glob.glob(\n f.replace(map_root, signal_root).replace(\n \".fits\", \"_{}.fits\".format(signal_subset)\n )\n )\n )\n nsims1 = len(sfiles)\n if not nsims1:\n raise OSError(\"Missing signal sims for {}\".format(f))\n if num_signal is None:\n num_signal = nsims1\n else:\n if nsims1 != num_signal:\n raise OSError(\n \"Found {} signal sims for map {}, expected {}\".format(\n nsims1, f, num_signal\n )\n )\n num_signal = min(num_signal, nsims1)\n signal_files.append(sfiles)\n signal_files = np.asarray([x[:num_signal] for x in signal_files])\n self.log(\"Found {} signal sims in {}\".format(num_signal, signal_root), \"info\")\n self.log(\n \"First signal sim files: {}\".format(signal_files[:, 0].tolist()), \"debug\"\n )\n\n # find all corresponding signal transfer function sims\n signal_transfer_root = os.path.join(\n data_root, \"signal_{}\".format(signal_transfer_type)\n )\n num_signal_transfer = None\n signal_transfer_files = []\n for f in map_files:\n sfiles = sorted(\n glob.glob(\n f.replace(map_root, signal_transfer_root).replace(\n \".fits\", \"_{}.fits\".format(signal_subset)\n )\n )\n )\n nsims1 = len(sfiles)\n if not nsims1:\n raise OSError(\"Missing signal sims for {}\".format(f))\n if num_signal_transfer is None:\n num_signal_transfer = nsims1\n else:\n if nsims1 != num_signal_transfer:\n raise OSError(\n \"Found {} signal_transfer sims for map {}, expected {}\".format(\n nsims1, f, num_signal_transfer\n )\n )\n num_signal_transfer = min(num_signal_transfer, nsims1)\n signal_transfer_files.append(sfiles)\n signal_transfer_files = np.asarray(\n [x[:num_signal_transfer] for x in signal_transfer_files]\n )\n self.log(\n \"Found {} signal transfer sims in {}\".format(\n num_signal_transfer, signal_transfer_root\n ),\n \"info\",\n )\n self.log(\n \"First signal transfer sim files: {}\".format(\n signal_transfer_files[:, 0].tolist()\n ),\n \"debug\",\n )\n\n # find all corresponding noise sims\n if noise_type is not None:\n noise_root = os.path.join(data_root, \"noise_{}\".format(noise_type))\n num_noise = None\n noise_files = []\n for f in map_files:\n nfiles = sorted(\n glob.glob(\n f.replace(map_root, noise_root).replace(\n \".fits\", \"_{}.fits\".format(noise_subset)\n )\n )\n )\n nsims1 = len(nfiles)\n if not nsims1:\n raise OSError(\"Missing noise sims for {}\".format(f))\n if num_noise is None:\n num_noise = nsims1\n else:\n if nsims1 != num_noise:\n raise OSError(\n \"Found {} noise sims for map {}, expected {}\".format(\n nsims1, f, num_noise\n )\n )\n num_noise = min(num_noise, nsims1)\n noise_files.append(nfiles)\n noise_files = np.asarray([x[:num_noise] for x in noise_files])\n self.log(\"Found {} noise sims in {}\".format(num_noise, noise_root), \"info\")\n self.log(\n \"First noise sim files: {}\".format(noise_files[:, 0].tolist()), \"debug\"\n )\n else:\n noise_root = None\n noise_files = None\n\n # find all corresponding noise sims for sim_index run\n if noise_type_sim is not None:\n noise_root_sim = os.path.join(data_root, \"noise_{}\".format(noise_type_sim))\n num_noise_sim = None\n noise_files_sim = []\n for f in map_files:\n nfiles = sorted(\n glob.glob(\n f.replace(map_root, noise_root_sim).replace(\n \".fits\", \"_{}.fits\".format(noise_subset)\n )\n )\n )\n nsims1 = len(nfiles)\n if not nsims1:\n raise OSError(\"Missing noise sims for {}\".format(f))\n if num_noise_sim is None:\n num_noise_sim = nsims1\n else:\n if nsims1 != num_noise_sim:\n raise OSError(\n \"Found {} noise sims for map {}, expected {}\".format(\n nsims1, f, num_noise_sim\n )\n )\n num_noise_sim = min(num_noise_sim, nsims1)\n noise_files_sim.append(nfiles)\n noise_files_sim = np.asarray(noise_files_sim)\n self.log(\n \"Found {} noise sims in {}\".format(num_noise_sim, noise_root_sim),\n \"info\",\n )\n self.log(\n \"First noise sim files: {}\".format(noise_files_sim[:, 0].tolist()),\n \"debug\",\n )\n else:\n noise_root_sim = noise_root\n noise_files_sim = noise_files\n\n # find all corresponding signal sims for sim_index run\n if signal_type_sim is not None:\n signal_root_sim = os.path.join(\n data_root, \"signal_{}\".format(signal_type_sim)\n )\n num_signal_sim = None\n signal_files_sim = []\n for f in map_files:\n nfiles = sorted(\n glob.glob(\n f.replace(map_root, signal_root_sim).replace(\n \".fits\", \"_{}.fits\".format(signal_subset)\n )\n )\n )\n nsims1 = len(nfiles)\n if not nsims1:\n raise OSError(\"Missing signal sims for {}\".format(f))\n if num_signal_sim is None:\n num_signal_sim = nsims1\n else:\n if nsims1 != num_signal_sim:\n raise OSError(\n \"Found {} signal sims for map {}, expected {}\".format(\n nsims1, f, num_signal_sim\n )\n )\n num_signal_sim = min(num_signal_sim, nsims1)\n signal_files_sim.append(nfiles)\n signal_files_sim = np.asarray(signal_files_sim)\n self.log(\n \"Found {} signal sims in {}\".format(num_signal_sim, signal_root_sim),\n \"info\",\n )\n self.log(\n \"First signal sim files: {}\".format(signal_files_sim[:, 0].tolist()),\n \"debug\",\n )\n else:\n signal_root_sim = signal_root\n signal_files_sim = signal_files\n\n # find all corresponding foreground sims for sim_index run\n if foreground_type_sim is not None:\n foreground_root = os.path.join(\n data_root, \"foreground_{}\".format(foreground_type_sim)\n )\n num_foreground_sim = None\n foreground_files = []\n for f in map_files:\n nfiles = sorted(\n glob.glob(\n f.replace(map_root, foreground_root).replace(\".fits\", \"_*.fits\")\n )\n )\n nsims1 = len(nfiles)\n if not nsims1:\n raise OSError(\"Missing foreground sims for {}\".format(f))\n if num_foreground_sim is None:\n num_foreground_sim = nsims1\n else:\n if nsims1 != num_foreground_sim:\n raise OSError(\n \"Found {} foreground sims for map {}, expected {}\".format(\n nsims1, f, num_foreground_sim\n )\n )\n num_foreground_sim = min(num_foreground_sim, nsims1)\n foreground_files.append(nfiles)\n foreground_files = np.asarray(\n [x[:num_foreground_sim] for x in foreground_files]\n )\n self.log(\n \"Found {} foreground sims in {}\".format(\n num_foreground_sim, foreground_root\n ),\n \"info\",\n )\n self.log(\n \"First foreground sim files: {}\".format(\n foreground_files[:, 0].tolist()\n ),\n \"debug\",\n )\n else:\n foreground_root = None\n foreground_files = None\n\n # find all corresponding masks\n if mask_type is None:\n raise ValueError(\"Argument mask_type required\")\n # If mask is a fits file, use the same mask for all maps\n if os.path.splitext(mask_type)[1] == \".fits\":\n if os.path.exists(mask_type):\n # it's an absolute path\n mask_files = np.tile(mask_type, len(map_tags))\n mask_root = os.path.dirname(mask_type)\n else:\n # it's relative to base directory structure\n mask_files = np.tile(os.path.join(data_root, mask_type), len(map_tags))\n mask_root = os.path.dirname(os.path.join(data_root, mask_type))\n else:\n mask_root = os.path.join(data_root, \"masks_{}\".format(mask_type))\n # XXX Do this smarter\n mask_files = [\n os.path.join(mask_root, \"mask_map_{}.fits\".format(tag))\n for tag in map_tags\n ]\n for f in mask_files:\n if not os.path.exists(f):\n raise OSError(\"Missing mask file {}\".format(f))\n self.log(\"Found {} masks in {}\".format(len(mask_files), mask_root), \"info\")\n self.log(\"Mask files: {}\".format(mask_files), \"debug\")\n\n # Also need a list of unique map tags for populating dictionaries\n # in data structures\n map_tags_orig = list(map_tags) # copy\n map_tags = pt.unique_tags(map_tags)\n\n # make a list of names corresponding to the order of the cross spectra\n map_pairs = pt.tag_pairs(map_tags)\n map_pairs_orig = pt.tag_pairs(map_tags, index=map_tags_orig)\n\n # make a dictionary of map freqs for each unique map tag\n map_freqs_dict = {}\n for im0, m0 in enumerate(map_tags):\n map_freqs_dict[m0] = map_freqs[im0]\n map_freqs = map_freqs_dict\n\n fields = [\n \"data_root\",\n \"data_subset\",\n \"map_root\",\n \"map_files\",\n \"map_tags\",\n \"map_pairs\",\n \"map_tags_orig\",\n \"map_pairs_orig\",\n \"map_freqs\",\n \"raw_root\",\n \"raw_files\",\n \"signal_root\",\n \"signal_files\",\n \"signal_root_sim\",\n \"signal_files_sim\",\n \"signal_transfer_root\",\n \"signal_transfer_files\",\n \"noise_root\",\n \"noise_files\",\n \"noise_root_sim\",\n \"noise_files_sim\",\n \"mask_root\",\n \"mask_files\",\n \"foreground_root\",\n \"foreground_files\",\n ]\n out = dict()\n local = locals()\n for f in fields:\n out[f + suffix] = local[f]\n return out","async def glob(self):\n # get the path string up to the wildcards\n try:\n pi1 = self._path.index(\"*\")\n except ValueError:\n pi1 = len(self._path)\n try:\n pi2 = self._path.index(\"?\")\n except ValueError:\n pi2 = len(self._path)\n pi = min(pi1, pi2)\n # using the prefix will cut down on the search space\n prefix = self._path[:pi]\n # get the wildcard\n wildcard = self._path[pi:]\n # set up the paginator\n paginator = self._conn_obj.conn.get_paginator(\"list_objects_v2\")\n parameters = {\n 'Bucket': self._bucket,\n 'Prefix': prefix\n }\n page_iterator = paginator.paginate(**parameters)\n files = []\n async for page in page_iterator:\n for item in page.get('Contents', []):\n fname = item['Key']\n # check that it matches against wildcard\n if fnmatch(fname, wildcard):\n files.append(item['Key'])\n return files","def compile_filename_patterns(pattern_list):\n\n pats=list(pattern_list)\n for i in range(len(pats)):\n if isinstance(pats[i],str):\n if pats[i].startswith('re:'):\n pats[i]=pats[i][3:]\n else:\n pats[i]=fnmatch.translate(pats[i])\n pats[i]=re.compile(pats[i])\n return pats","def _collect_bams(self, wildcards, library_name):\n folder_name = get_ngs_library_folder_name(self.parent.sheets, wildcards.library_name)\n for _, path_infix, filename in self.path_gen.run(folder_name, (\"bam\",)):\n yield os.path.join(self.base_path_in, path_infix, filename).format(**wildcards)","def create_src_file_exts_str(input_exts: list[str] = []) -> Pattern[str]:\n import re\n\n input_exts = [re.escape(ext) for ext in input_exts]\n return create_src_file_exts_regex(input_exts)","def expand_globpaths(globpaths, cwd=None):\n with cd(cwd):\n paths = sum((recursive_glob(p) for p in globpaths), [])\n return expand_paths(paths, cwd)"],"string":"[\n \"def to_globs(self, build_patterns: Iterable[str]) -> Tuple[str, ...]:\",\n \"def glob2re(glob: str) -> str: # pylint: disable=too-many-branches\\n index = 0\\n size = len(glob)\\n results: List[str] = []\\n\\n while index < size:\\n char = glob[index]\\n index += 1\\n\\n if char == \\\"*\\\":\\n if index < size and glob[index] == \\\"*\\\":\\n index += 1\\n if results and results[-1] == \\\"/\\\" and index < size and glob[index] == \\\"/\\\":\\n results.append(\\\"(.*/)?\\\")\\n index += 1\\n else:\\n results.append(\\\".*\\\")\\n else:\\n results.append(\\\"[^/]*\\\")\\n\\n elif char == \\\"?\\\":\\n results.append(\\\"[^/]\\\")\\n\\n elif char == \\\"[\\\":\\n end_index = index\\n while end_index < size and glob[end_index] != \\\"]\\\":\\n end_index += 1\\n\\n if end_index >= size:\\n results.append(\\\"\\\\\\\\[\\\")\\n\\n else:\\n characters = glob[index:end_index].replace(\\\"\\\\\\\\\\\", \\\"\\\\\\\\\\\\\\\\\\\")\\n index = end_index + 1\\n\\n results.append(\\\"[\\\")\\n\\n if characters[0] == \\\"!\\\":\\n results.append(\\\"^/\\\")\\n characters = characters[1:]\\n elif characters[0] == \\\"^\\\":\\n results.append(\\\"\\\\\\\\\\\")\\n\\n results.append(characters)\\n results.append(\\\"]\\\")\\n\\n elif char in \\\"{}/\\\":\\n results.append(char)\\n\\n else:\\n results.append(re.escape(char))\\n\\n return \\\"\\\".join(results)\",\n \"def to_glob(self) -> str:\",\n \"def glob_paths(self, name, source, pattern, test_data=()):\\n assert isinstance(source, config_types.Path)\\n result = self._run(\\n name, ['glob', source, pattern],\\n lambda: self.test_api.glob_paths(test_data),\\n self.m.raw_io.output_text())\\n ret = [source.join(*x.split(self.m.path.sep))\\n for x in result.stdout.splitlines()]\\n result.presentation.logs[\\\"glob\\\"] = map(str, ret)\\n return ret\",\n \"def glob_patterns(separator=os.path.sep, **kwargs):\\n terms = [kwargs.pop(field, '*')\\n for field in NormalizedSceneId.tuple_type._fields]\\n assert not kwargs, 'Unrecognized field names: {}'.format(kwargs)\\n\\n # terms which are not str are assumed to contain choices (list of str)\\n choice_inds = [i for i, val in enumerate(terms) if not isinstance(val, str)]\\n val_lists = [terms[i][:] for i in choice_inds]\\n\\n patterns = []\\n for values in it.product(*val_lists):\\n for i, ind in enumerate(choice_inds):\\n terms[ind] = values[i]\\n patterns.append(separator.join(terms))\\n return patterns\",\n \"def glob_to_regex(glob):\\n res = \\\"\\\"\\n for c in glob:\\n if c == \\\"*\\\":\\n res = res + \\\".*\\\"\\n elif c == \\\"?\\\":\\n res = res + \\\".\\\"\\n else:\\n res = res + re.escape(c)\\n\\n # \\\\A anchors at start of string, \\\\Z at end of string\\n return re.compile(r\\\"\\\\A\\\" + res + r\\\"\\\\Z\\\", re.IGNORECASE)\",\n \"def getGlobArgs(self):\\n dirname,pattern = '/tmp','trash2*.txt'\\n return dirname, pattern\",\n \"def glob(patterns: list[str]) -> Table:\\n for val in _ensure_list(patterns):\\n fol, _, pat = val.partition(\\\"/*\\\")\\n folder = Path(fol)\\n for file in folder.glob(\\\"*\\\" + pat):\\n yield {\\\"file\\\": str(file)}\",\n \"def _glob_to_sql(self, string):\\n\\n # What's with the chr(1) and chr(2) nonsense? It's a trick to\\n # hide \\\\* and \\\\? from the * and ? substitutions. This trick\\n # depends on the substitutiones being done in order. chr(1)\\n # and chr(2) were picked because I know those characters\\n # almost certainly won't be in the input string\\n table = ((r'\\\\\\\\', chr(1)), (r'\\\\*', chr(2)), (r'\\\\?', chr(3)),\\n (r'%', r'\\\\%'), (r'?', '_'), (r'*', '%'),\\n (chr(1), r'\\\\\\\\'), (chr(2), r'\\\\*'), (chr(3), r'\\\\?'))\\n\\n for (a, b) in table:\\n string = string.replace(a,b)\\n\\n string = string[1:] if string.startswith(\\\"^\\\") else \\\"%\\\" + string\\n string = string[:-1] if string.endswith(\\\"$\\\") else string + \\\"%\\\"\\n\\n return string\",\n \"def _get_data_glob(split, fake_data, glob_dir=None):\\n if fake_data:\\n return flags.FLAGS.criteo_dummy_path_for_test\\n\\n if glob_dir is None:\\n glob_path = {'train': flags.FLAGS.criteo_train_glob,\\n 'test': flags.FLAGS.criteo_test_glob,\\n 'valid': flags.FLAGS.criteo_valid_glob}[split]\\n if glob_path is None:\\n raise ValueError('One of glob_dir or FLAGS.criteo_split_glob',\\n 'needs to be specified')\\n else:\\n return glob_path\\n else:\\n return glob_dir\",\n \"def glob(self):\\n self._deduplicate()\\n result = []\\n for entry in self._entries:\\n pp = entry.posix_path()\\n if GLOBBABLE_REGEX.search(pp):\\n try:\\n globs = glob.glob(entry.posix_path())\\n result += globs\\n except re.error:\\n result.append(pp)\\n else:\\n result.append(pp)\\n self._entries = [Path(g) for g in result]\\n self._clean = False\\n self._current = 0\",\n \"def insensitive_glob(pattern):\\n def either(c):\\n return '[%s%s]' % (c.lower(), c.upper()) if c.isalpha() else c\\n\\n file_list = sorted(glob.glob(''.join(map(either, pattern))))\\n\\n return file_list\",\n \"def uvm_glob_to_re(_str):\\n if _str is None or _str == \\\"\\\":\\n return \\\"\\\"\\n if _str[0] == \\\"/\\\" and _str[-1] == \\\"/\\\":\\n return _str\\n # TODO replace * with .*\\n res = _str.replace('.', '\\\\\\\\.')\\n res = res.replace('*', '.*')\\n res = res.replace('[', '\\\\\\\\[')\\n res = res.replace(']', '\\\\\\\\]')\\n res = res.replace('?', '.')\\n # TODO add more substitutions\\n return res\",\n \"def split_and_glob(s: str = None) -> list:\\n ret = []\\n if s is not None:\\n for glob in s.split(','):\\n if glob != '':\\n ret.append(partial(fnmatch, glob))\\n return ret\",\n \"def GetInputFilenameGlob(pattern):\\n if not indir:\\n return glob.glob(fname)\\n files = []\\n for dirname in indir:\\n pathname = os.path.join(dirname, pattern)\\n files += glob.glob(pathname)\\n return sorted(files)\",\n \"def test_glob_pattern(self):\\n glob_pattern = GlobPattern()\\n det_name = 'R22_S11'\\n self.assertEqual(glob_pattern('fe55', det_name),\\n 'fe55_fe55_*/*_{}.fits'.format(det_name))\\n self.assertEqual(glob_pattern('cte_low', det_name),\\n 'sflat_*_flat_*L*/*_{}.fits'.format(det_name))\",\n \"def glob(adapts):\\n def decorate(func):\\n frame = sys._getframe(1)\\n name = '__zeit_edit_globs__'\\n globs = frame.f_locals.get(name, None)\\n if globs is None:\\n frame.f_locals[name] = globs = []\\n globs.append((func, adapts))\\n return func\\n return decorate\",\n \"def expand(self, path_list):\\n path_list2 = []\\n for path in path_list:\\n if glob.has_magic(path):\\n iterator = glob.iglob(path)\\n path_list2.extend(iterator)\\n else:\\n path_list2.append(path)\\n return path_list2\",\n \"def get_glob_strings(subdirglob):\\n dirname = path.dirname(subdirglob)\\n basename = path.basename(subdirglob)\\n assert (((\\\"_M1_\\\" in subdirglob) or (\\\"_M2_\\\" in subdirglob)) or (\\\"_S_\\\" in subdirglob)), \\\\\\n (\\\"_M1_ or _M2_ not in subdirglob, cant differentiate between M1 and M2, aborting.\\\"\\n f\\\"glob: {subdirglob}\\\")\\n if (\\\"*\\\" not in subdirglob) and (\\\"_S_\\\" not in basename):\\n newbasename = basename.replace(\\\"_M2_\\\", \\\"_M1_\\\"), basename.replace(\\\"_M1_\\\", \\\"_M2_\\\")\\n return path.join(dirname, newbasename[0]), path.join(dirname, newbasename[1])\\n elif (\\\"_M1_\\\" or \\\"_M2_\\\") in basename:\\n newbasename = basename.replace(\\\"_M2_\\\", \\\"_M1_\\\"), basename.replace(\\\"_M1_\\\", \\\"_M2_\\\")\\n return path.join(dirname, newbasename[0]), path.join(dirname, newbasename[1])\\n elif \\\"_S_\\\" in basename:\\n return basename\",\n \"def to_pattern(obj):\\n if isinstance(obj, Pattern):\\n return obj\\n return Glob(str(obj))\",\n \"def glob_fmt(pattern: str, *templates: Strings) -> List[str]:\\n results: List[str] = []\\n for wildcards in glob_extract(pattern):\\n for template in each_string(*templates):\\n results.append(copy_annotations(template, template.format(**wildcards)))\\n return results\",\n \"def glob1(self, dirname, pattern):\\n names = self.listdir(dirname)\\n if pattern[0] != '.':\\n names = filter(lambda x: x[0] != '.',names)\\n return fnmatch.filter(names, pattern)\",\n \"def test_get_files(self):\\n glob_manager = GlobManager(['*'])\\n self.assertCountEqual(\\n glob_manager.get_files(),\\n {\\n 'bob.py', 'dave.txt', 'fred.txt.py', 'geoff.py', 'jim.py.txt',\\n 'rob.txt'\\n })\\n\\n glob_manager = GlobManager(['*.py'])\\n self.assertCountEqual(\\n glob_manager.get_files(), {'bob.py', 'fred.txt.py', 'geoff.py'})\\n\\n glob_manager = GlobManager(['*.py', '*.txt'])\\n self.assertCountEqual(\\n glob_manager.get_files(),\\n {\\n 'bob.py', 'dave.txt', 'fred.txt.py', 'geoff.py', 'jim.py.txt',\\n 'rob.txt'\\n })\\n\\n glob_manager = GlobManager(['**/*.py'])\\n self.assertCountEqual(\\n glob_manager.get_files(),\\n {\\n 'bob.py',\\n 'fred.txt.py',\\n 'geoff.py',\\n 'animals/dog.py',\\n 'animals/mouse.txt.py',\\n 'animals/sheep.py',\\n 'animals/vehicles/bus.py',\\n 'animals/vehicles/aeroplane.txt.py',\\n 'animals/vehicles/tractor.py'\\n })\\n\\n glob_manager = GlobManager(['bob.py'])\\n self.assertCountEqual(glob_manager.get_files(), {'bob.py'})\\n\\n glob_manager = GlobManager(['bob.py', 'bob.py'])\\n self.assertCountEqual(glob_manager.get_files(), {'bob.py'})\\n\\n glob_manager = GlobManager(\\n [os.path.join(self.temp_dir.name, file_name) for file_name in [\\n 'bob.py', 'geoff.py']])\\n self.assertCountEqual(glob_manager.get_files(), {'bob.py', 'geoff.py'})\",\n \"def glob(url, separator=','):\\n patterns = [url] if separator is None else url.split(separator)\\n result = []\\n for pattern in patterns:\\n result.extend(_glob.glob(os.path.expanduser(pattern.strip())))\\n return result\",\n \"def glob(self, pathname, with_matches=False):\\r\\n return list(self.iglob(pathname, with_matches))\",\n \"def _filenames(self, dir_or_file):\\n if os.path.isdir(dir_or_file):\\n return glob(os.path.join(dir_or_file, \\\"*.txt\\\"))\\n else:\\n return [dir_or_file]\",\n \"def _data_filter(data: str) -> list:\\n\\n return PROXIES_DATA_REGEX.findall(str(data))\",\n \"def glob_fs(self):\\n\\n found_files = []\\n for pattern in self.glob_patterns:\\n found_files += [PathString(present_file)\\n for present_file in glob.glob(pattern)]\\n return found_files\",\n \"def glob_datasets(glob_paths: Sequence[str]):\\n if len(glob_paths) == 0:\\n raise ValueError(\\\"No dataset path provided.\\\")\\n\\n # Apply glob:\\n paths = tuple(glob.glob(glob_path) for glob_path in glob_paths)\\n\\n if len(paths) == 0:\\n raise ValueError(\\\"Could not find any dataset with provided paths\\\", glob_paths)\\n\\n # concatenate list of paths:\\n paths = reduce(lambda u, v: u + v, paths)\\n\\n # remove empty paths:\\n paths = (path.strip() for path in paths)\\n\\n # remove empty paths:\\n paths = (path for path in paths if len(path) > 0)\\n\\n # sort paths:\\n paths = sorted(list(paths))\\n\\n return open_joined_datasets(paths), paths\",\n \"def infile_list(args):\\n infiles = []\\n for arg in args:\\n infiles += glob.glob(arg)\\n infiles = [pipes.quote(f) for f in infiles]\\n return infiles\",\n \"def set_in_files():\\r\\n\\tindatadir = '/nobackup/ejblom/reddit'\\r\\n\\tcom_dir = '/comments'\\r\\n\\tsubm_dir = '/submissions'\\r\\n\\tglob_end = '/filtered*'\\r\\n\\tcom_glob_str = indatadir + com_dir + glob_end\\r\\n\\tsubm_glob_str = indatadir + subm_dir + glob_end\\r\\n\\tinfilenames = sorted(glob.glob(com_glob_str)) + sorted(glob.glob(subm_glob_str))\\r\\n\\treturn infilenames\",\n \"def resolveShellPatternToFilenames(pattern):\\n\\n if \\\"**\\\" in pattern:\\n if python_version >= 0x350:\\n result = glob.glob(pattern, recursive=True)\\n else:\\n glob2 = importFromInlineCopy(\\\"glob2\\\", must_exist=False)\\n\\n if glob2 is None:\\n options_logger.sysexit(\\n \\\"Using pattern with '**' is not supported before Python 3.5 unless glob2 is installed.\\\"\\n )\\n\\n result = glob2.glob(pattern)\\n else:\\n result = glob.glob(pattern)\\n\\n result = [os.path.normpath(filename) for filename in result]\\n result.sort()\\n return result\",\n \"def recursive_glob(path):\\n if \\\"*\\\" not in path:\\n # Glob isn't needed.\\n return [path]\\n elif \\\"**\\\" not in path:\\n # Recursive glob isn't needed.\\n return path_utils.glob(path)\\n else:\\n return path_utils.glob(path, recursive=True)\",\n \"def _find_data_files(pattern: str) -> List[str]:\\n file_list = glob.glob(pattern)\\n if not file_list:\\n raise ValueError('No files found matching: ' + str(pattern))\\n sorted_file_list = sorted(file_list, key=numerical_sort)\\n return sorted_file_list\",\n \"def filenamePatterns(self):\\n return ['*.'+e for e in self.filenameExtensions]\",\n \"def _iglob(pathname):\\n dirname, basename = os.path.split(pathname)\\n if not _glob.has_magic(pathname):\\n if basename:\\n if os.path.lexists(pathname):\\n yield pathname\\n else:\\n raise FileNotFoundError\\n else:\\n if os.path.isdir(dirname):\\n yield pathname\\n else:\\n raise NotADirectoryError\\n return\\n if not dirname:\\n if basename == '**':\\n for name in _glob2(dirname, basename):\\n yield name\\n else:\\n for name in _glob.glob1(dirname, basename):\\n yield name\\n return\\n if dirname != pathname and _glob.has_magic(dirname):\\n dirs = _iglob(dirname)\\n else:\\n dirs = [dirname]\\n if _glob.has_magic(basename):\\n if basename == '**':\\n glob_in_dir = _glob2\\n else:\\n glob_in_dir = _glob.glob1\\n else:\\n glob_in_dir = _glob.glob0(dirname, basename)\\n for dirname in dirs:\\n for name in glob_in_dir(dirname, basename):\\n yield os.path.join(dirname, name)\",\n \"def glob_xpcs_datasets(path: str = None, regex: str = None, extensions: Tuple = None, **data) -> List[str]:\\n from pathlib import Path\\n\\n def walk(path): \\n for p in Path(path).iterdir(): \\n if p.is_dir(): \\n yield from walk(p)\\n continue\\n yield p.resolve()\\n\\n \\n\\n datasets = [str(p) for p in walk(path) if\\n (not regex or p.match(regex)) and \\n (not extensions or p.suffix in extensions)]\\n metadata_files = []\\n for d in datasets:\\n hdf_file = None\\n dataset_dir = Path(d).parent\\n for f in dataset_dir.iterdir():\\n if f.suffix == '.hdf':\\n hdf_file = f\\n metadata_files.append(hdf_file)\\n\\n return [(str(d), str(q)) for d, q in zip(datasets, metadata_files) if d and q]\",\n \"def globfiles(path, pattern):\\n return Path(path).glob(pattern)\",\n \"def expand_path(__file__, path_with_globs):\\n return glob.glob(relative_path(__file__, path_with_globs))\",\n \"def zglobs(cls, *globspecs, **kw):\\r\\n root = kw.pop('root', os.curdir)\\r\\n patterns = [(os.path.basename(spec).startswith('*'),\\r\\n re.compile(fnmatch_translate_extended(spec))) for spec in globspecs]\\r\\n\\r\\n def matcher(path):\\r\\n for no_hidden, pattern in patterns:\\r\\n # Ignore hidden files when globbing wildcards.\\r\\n if not (no_hidden and os.path.basename(path).startswith('.')):\\r\\n if pattern.match(path):\\r\\n return True\\r\\n return False\\r\\n\\r\\n return cls(lambda: set(cls._do_rglob(matcher, allow_dirs=True, root=root, **kw)))\",\n \"def glob(glob_pattern: str, directoryname: str) -> List[str]:\\n matches = []\\n for root, dirnames, filenames in os.walk(directoryname):\\n for filename in fnmatch.filter(filenames, glob_pattern):\\n absolute_filepath = os.path.join(root, filename)\\n matches.append(absolute_filepath)\\n return matches\",\n \"def globs(cls, *globspecs, **kw):\\r\\n root = kw.pop('root', os.curdir)\\r\\n def relative_glob(globspec):\\r\\n for fn in glob.glob(os.path.join(root, globspec)):\\r\\n yield os.path.relpath(fn, root)\\r\\n def combine(files, globspec):\\r\\n return files ^ set(relative_glob(globspec))\\r\\n return cls(lambda: reduce(combine, globspecs, set()))\",\n \"def _glob_files(directories, extensions):\\n pwd = Path(__file__).resolve().parent\\n open3d_root_dir = pwd.parent\\n\\n file_paths = []\\n for directory in directories:\\n directory = open3d_root_dir / directory\\n for extension in extensions:\\n extension_regex = \\\"*.\\\" + extension\\n file_paths.extend(directory.rglob(extension_regex))\\n file_paths = [str(file_path) for file_path in file_paths]\\n file_paths = sorted(list(set(file_paths)))\\n return file_paths\",\n \"def match_glob(pathname):\\n # type: (six.text_type) -> List[six.text_type]\\n if sys.version_info >= (3, 5):\\n result = glob.glob(pathname, recursive=True)\\n else:\\n # use the third party glob library to handle a recursive glob.\\n result = glob2.glob(pathname)\\n return result\",\n \"def glob(path: str) -> list[str]:\\n fs, relative_path = url_to_fs(path)\\n return cast(list[str], fs.glob(relative_path))\",\n \"def _input_as_string(self,data):\\n inputFiles = ' '.join(data)\\n self._input_filename = data\\n return inputFiles\",\n \"def pairof_MOGUK_search_filepaths(date_string, n_hour, data_basepath=default_data_basepath):\\n hr_string = \\\"%02d\\\" % n_hour\\n glob_spec_strs = [data_basepath + date_string + hr_string + t_s for t_s in ('*speed10mmean.grib','*dir10mmean.grib')]\\n return glob_spec_strs\",\n \"def globits(patt):\\n files = glob(patt)\\n pre,suf = patt.split('*')\\n its = []\\n for file in files:\\n s = re.sub(r'^' + re.escape(pre), '', file)\\n s = re.sub(re.escape(suf) + r'$', '', s)\\n s = re.sub(r'^0*', '', s)\\n its.append(int(s))\\n\\n its.sort()\\n return its\",\n \"def read_data(path, glob_ptrn, germeval=False):\\n if os.path.isdir(path):\\n return read_dir(iglob(os.path.join(path, glob_ptrn)), germeval)\\n return read_file(path, germeval)\",\n \"def decompose_data_path(data_path):\\n ns = {\\\"base\\\": _TokenizeDataPath(())}\\n return list(eval(\\\"base\\\" + data_path, ns, ns))\",\n \"def find_data_files(pattern: str) -> List[str]:\\n file_list = glob.glob(pattern)\\n if not file_list:\\n raise ValueError('No files found matching: ' + str(pattern))\\n sorted_file_list = sorted(file_list, key=numerical_sort)\\n return sorted_file_list\",\n \"def populate(self, dr=None):\\n if dr is not None: self.directory = dr\\n \\n for k in OM.glob_strings:\\n string =self.directory+\\\"/\\\"+OM.glob_strings[k]\\n print(\\\"OM::populate -- Checking \\\",k,\\\" (\\\",string,\\\")\\\", end=\\\"\\\")\\n fnames = glob.glob(string)\\n print(\\\"... found\\\",len(fnames), \\\"files\\\")\\n setattr(self, k, fnames)\\n #print(k, lst)\",\n \"def expand_paths(__file__, paths_with_globs):\\n if isinstance(paths_with_globs, str):\\n return expand_path(__file__, paths_with_globs)\\n else:\\n expanded_globs = [\\n expand_path(__file__, path) for path in paths_with_globs\\n ]\\n # Flatten\\n return list(itertools.chain.from_iterable(expanded_globs))\",\n \"def find_data_files_distutils(self, package, src_dir):\\n from glob import glob\\n import os\\n from distutils.util import convert_path\\n\\n globs = (self.package_data.get('', [])\\n + self.package_data.get(package, []))\\n files = []\\n for pattern in globs:\\n # Each pattern has to be converted to a platform-specific path\\n filelist = glob(os.path.join(src_dir, convert_path(pattern)))\\n # Files that match more than one pattern are only added once\\n files.extend([fn for fn in filelist if fn not in files\\n and (os.path.isfile(fn) or os.path.islink(fn))])\\n return files\",\n \"def data_files(self, pattern=None, regex=None):\\n return self._files_in_subdir(self.data_dir, pattern, regex)\",\n \"def buildListOfFiles(searchGlob):\\n return [fpath for fpath in glob2.iglob(searchGlob) if os.path.isfile(fpath)]\",\n \"def glob_escape(pathname):\\n # Escaping is done by wrapping any of \\\"*?[\\\" between square brackets.\\n # Metacharacters do not work in the drive part and shouldn't be escaped.\\n drive, pathname = os.path.splitdrive(pathname)\\n if isinstance(pathname, bytes):\\n pathname = _magic_check_bytes.sub(br'[\\\\1]', pathname)\\n else:\\n pathname = _magic_check.sub(r'[\\\\1]', pathname)\\n return drive + pathname\",\n \"def eval(self):\\n if self.and_or == 'or':\\n return self.files\\n return ' '.join(self.files)\",\n \"def glob_precip_stats(reanalysis):\\n\\n globpath = _glob_precip_stats_dirpath(reanalysis)\\n globfile = _glob_precip_stats_fname(reanalysis)\\n #fileList = glob.glob( os.path.join( globpath, globfile) )\\n return os.path.join( globpath, globfile)\",\n \"def _get_all_files(self):\\n file_pattern = _FILE_PATTERN\\n file_pattern = os.path.join(self.dataset_dir,\\n file_pattern % self.split_name)\\n return tf.gfile.Glob(file_pattern)\",\n \"def input_files_from_path(path):\\n import glob\\n input_files = None\\n if type(path) is list:\\n input_files = []\\n for p in path:\\n if '*' in p:\\n input_files.extend(glob.glob(p))\\n else: # neither wildcard nor comma separated list\\n input_files.append(p)\\n else:\\n if ',' in path:\\n input_files = path.split(',')\\n elif '*' in path:\\n input_files = glob.glob(path)\\n else: # neither wildcard nor comma separated list\\n input_files = [path]\\n input_files = [os.path.abspath(f) for f in input_files]\\n return [f for f in input_files if os.path.exists(f) or f.startswith('/store')]\",\n \"def rglobs(cls, *globspecs, **kw):\\r\\n root = kw.pop('root', os.curdir)\\r\\n\\r\\n def matcher(path):\\r\\n for globspec in globspecs:\\r\\n # Ignore hidden files when globbing wildcards.\\r\\n if not (globspec.startswith('*') and os.path.basename(path).startswith('.')):\\r\\n if fnmatch.fnmatch(path, globspec):\\r\\n return True\\r\\n return False\\r\\n\\r\\n return cls(lambda: set(cls._do_rglob(matcher, allow_dirs=False, root=root, **kw)))\",\n \"def to_build_file_globs(self, build_patterns: Iterable[str]) -> set[str]:\\n return {\\n os.path.join(f, pattern)\\n for pattern in build_patterns\\n for f in recursive_dirname(self.directory)\\n }\",\n \"def load_glob(self, match):\\n\\t\\tpluginlist = []\\n\\t\\tfor m in match.split(','):\\n\\t\\t\\tfor path in glob.glob(m):\\n\\t\\t\\t\\tif not \\\"__plugin__.py\\\" in path and not \\\"__init__.py\\\" in path:\\n\\t\\t\\t\\t\\tpluginlist.append(self.load(path))\\n\\t\\treturn pluginlist\",\n \"def sglob(files_pattern):\\n return sorted(glob.glob(files_pattern))\",\n \"def find_data_files(source, target, patterns):\\r\\n if glob.has_magic(source) or glob.has_magic(target):\\r\\n raise ValueError(\\\"Magic not allowed in src, target\\\")\\r\\n ret = {}\\r\\n for pattern in patterns:\\r\\n pattern = os.path.join(source, pattern)\\r\\n for filename in glob.glob(pattern):\\r\\n if os.path.isfile(filename):\\r\\n targetpath = os.path.join(target, os.path.relpath(filename,source))\\r\\n path = os.path.dirname(targetpath)\\r\\n ret.setdefault(path, []).append(filename)\\r\\n return sorted(ret.items())\",\n \"def returnFiles(input_data, fmt=IMAGE_FORMATS):\\r\\n if type(input_data) is list:\\r\\n return [returnFiles(element) for element in input_data]\\r\\n else:\\r\\n if not os.path.exists(input_data):\\r\\n raise OSError(\\\"invalid input path: {}\\\".format(input_data))\\r\\n return [pjoin(input_data, name) for name in os.listdir(\\r\\n input_data) if os.path.splitext(name)[1][1:] in fmt]\",\n \"def get_data_files():\\n data_files = []\\n\\n # Walk through the data directory, adding all files\\n data_generator = os.walk('pypeit/data')\\n for path, directories, files in data_generator:\\n for f in files:\\n data_path = '/'.join(path.split('/')[1:])\\n data_files.append(os.path.join(data_path, f))\\n\\n # Add pipeline and spectrograph settings\\n settings = glob.glob('pypeit/settings/settings.*')\\n settings = ['/'.join(path.split('/')[1:]) for path in settings]\\n data_files.extend(settings)\\n\\n return data_files\",\n \"def glob(pattern: str) -> List[str]:\\n\\n path = clean_path(pattern)\\n result = Stat._cache.get(path)\\n\\n if isinstance(result, BaseException):\\n return []\\n\\n if result is None:\\n paths = glob_files(pattern, recursive=True)\\n if paths != [pattern]:\\n return [clean_path(path) for path in paths]\\n result = Stat._result(pattern, throw=False)\\n assert not isinstance(result, BaseException)\\n\\n return [pattern]\",\n \"def glob(self, pattern, lazy=False):\\n def iterator():\\n for filename in self.walk(lazy=lazy):\\n if fnmatch(filename, pattern):\\n yield self.__class__(filename)\\n\\n return lazy and iterator() or list(iterator())\",\n \"def capture2glob(capture: str) -> str: # pylint: disable=too-many-statements\\n index = 0\\n size = len(capture)\\n results: List[str] = []\\n\\n def _is_next(expected: str) -> bool:\\n nonlocal capture, index, size\\n return index < size and capture[index] == expected\\n\\n def _invalid(reason: str = \\\"\\\") -> None:\\n nonlocal capture, index\\n no_additional_complaints()\\n raise RuntimeError(f'Invalid capture pattern:\\\\n{capture}\\\\n{index * \\\" \\\"}^ {reason}')\\n\\n def _parse_glob(glob: str, terminators: str) -> None:\\n nonlocal capture, index, size\\n while index < size and capture[index] not in terminators:\\n index += 1\\n if index < size and capture[index] == \\\":\\\":\\n index += 1\\n start_index = index\\n while index < size and capture[index] != \\\"}\\\":\\n index += 1\\n glob = capture[start_index:index]\\n if not _is_next(\\\"}\\\"):\\n _invalid(\\\"missing }\\\")\\n index += 1\\n results.append(glob)\\n\\n while index < size:\\n char = capture[index]\\n index += 1\\n\\n if char == \\\"}\\\" and _is_next(\\\"}\\\"):\\n results.append(\\\"}\\\")\\n index += 1\\n\\n elif char == \\\"{\\\" and _is_next(\\\"{\\\"):\\n results.append(\\\"{\\\")\\n index += 1\\n\\n elif char == \\\"{\\\" and _is_next(\\\"*\\\"):\\n index += 1\\n if _is_next(\\\"*\\\"):\\n index += 1\\n _parse_glob(\\\"**\\\", \\\"}\\\")\\n else:\\n _parse_glob(\\\"*\\\", \\\":}\\\")\\n\\n else:\\n results.append(char)\\n\\n return \\\"\\\".join(results)\",\n \"def _collect_files(folders, extention='Default'):\\r\\n if isinstance(extention, str):\\r\\n if extention.lower() == 'default':\\r\\n extention = ['.*']\\r\\n else:\\r\\n extention = [extention]\\r\\n files = []\\r\\n for f in folders:\\r\\n for e in extention:\\r\\n files += glob(os.path.join(f, f'*{e}'))\\r\\n return files\",\n \"def _glob_list(pattern, full_path=False):\\n if full_path:\\n return sorted(glob.glob(pattern))\\n else:\\n return sorted([os.path.basename(fpath) for fpath in glob.glob(pattern)])\",\n \"def recursive_glob(stem, file_pattern):\\n\\n if sys.version_info >= (3, 5):\\n return glob(stem + \\\"/**/\\\" + file_pattern, recursive=True)\\n else:\\n # gh-316: this will avoid invalid unicode comparisons in Python 2.x\\n if stem == str(\\\"*\\\"):\\n stem = \\\".\\\"\\n matches = []\\n for root, dirnames, filenames in os.walk(stem):\\n for filename in fnmatch.filter(filenames, file_pattern):\\n matches.append(path_join_robust(root, filename))\\n return matches\",\n \"def get_available_patterns() -> list:\\n path_folder = os.path.join(config.ROOT_PATH, config.FOLDER_PATTERNS)\\n return [f.replace(\\\".cells\\\", \\\"\\\") for f in os.listdir(path_folder) if os.path.isfile(os.path.join(path_folder, f)) and f.endswith(\\\".cells\\\")]\",\n \"def generate_regex(self, pattern_to_glob):\\n\\n # First thing, replace '.' with '\\\\.' and make sure we're going\\n # to match the start and the end of the pattern string.\\n pattern_to_glob = re.sub(r\\\"\\\\.\\\", r\\\"\\\\.\\\", pattern_to_glob)\\n pattern_to_glob = r\\\"^\\\" + pattern_to_glob + r\\\"$\\\"\\n\\n found_values = []\\n new_val = pattern_to_glob\\n\\n # Find all the named attributes\\n all_matches = re.findall(r\\\"%.+?%\\\", pattern_to_glob)\\n\\n for match_thing in all_matches:\\n name = match_thing[1:-1]\\n\\n if match_thing not in found_values:\\n # Change to a named group.\\n group_string = r\\\"(?P<\\\" + name + r\\\">.+?)\\\"\\n new_val = re.sub(match_thing, group_string, new_val, count=1)\\n found_values.append(match_thing)\\n else:\\n # Use the existing group.\\n group_string = r\\\"(?P=\\\" + name + r\\\")\\\"\\n new_val = re.sub(match_thing, group_string, new_val, count=1)\\n\\n return new_val\",\n \"def _populate_gitignore_items(self):\\n\\n # Reset the include_regexps and exclude_regexps.\\n self.include_regexps = []\\n self.exclude_regexps = [re.compile('.*\\\\.git/.*\\\\.lock'),\\n re.compile('.*\\\\.baboon-timestamp'),\\n re.compile('.*baboon.*')]\\n\\n # If there's a .gitignore file in the watched directory.\\n if os.path.exists(self.gitignore_path):\\n # Parse the gitignore.\\n ignores = self._parse_gitignore()\\n if ignores is not None:\\n # Populate the regexps list with the ignores result.\\n self.include_regexps += [re.compile(x) for x in ignores[0]]\\n self.exclude_regexps += [re.compile(x) for x in ignores[1]]\",\n \"def convertPatterns(path, sign):\\r\\n filters = []\\r\\n f = open(path, \\\"r\\\")\\r\\n while 1:\\r\\n pattern = f.readline()\\r\\n if not pattern:\\r\\n break\\r\\n if pattern[-1] == \\\"\\\\n\\\":\\r\\n pattern = pattern[:-1]\\r\\n\\r\\n if re.match(\\\"[\\\\t ]*$\\\", pattern):\\r\\n continue\\r\\n if pattern[0] == \\\"#\\\":\\r\\n continue\\r\\n filters = filters + [convertPattern(pattern, sign)]\\r\\n f.close()\\r\\n return filters\",\n \"def resolve_pattern(self, dirname, pattern, globstar_with_root):\\r\\n\\r\\n if isinstance(pattern, six.text_type) and not isinstance(dirname, six.text_type):\\r\\n dirname = six.u(dirname, sys.getfilesystemencoding() or\\r\\n sys.getdefaultencoding())\\r\\n\\r\\n # If no magic, short-circuit, only check for existence\\r\\n if not has_magic(pattern):\\r\\n if pattern == '':\\r\\n if self.isdir(dirname):\\r\\n return [(pattern, ())]\\r\\n else:\\r\\n if self.exists(os.path.join(dirname, pattern)):\\r\\n return [(pattern, ())]\\r\\n return []\\r\\n\\r\\n if not dirname:\\r\\n dirname = os.curdir\\r\\n\\r\\n try:\\r\\n if pattern == '**':\\r\\n # Include the current directory in **, if asked; by adding\\r\\n # an empty string as opposed to '.', be spare ourselves\\r\\n # having to deal with os.path.normpath() later.\\r\\n names = [''] if globstar_with_root else []\\r\\n for top, entries in self.walk(dirname):\\r\\n _mkabs = lambda s: os.path.join(top[len(dirname)+1:], s)\\r\\n names.extend(map(_mkabs, entries))\\r\\n # Reset pattern so that fnmatch(), which does not understand\\r\\n # ** specifically, will only return a single group match.\\r\\n pattern = '*'\\r\\n else:\\r\\n names = self.listdir(dirname)\\r\\n except os.error:\\r\\n return []\\r\\n\\r\\n if pattern[0] != '.':\\r\\n # Remove hidden files by default, but take care to ensure\\r\\n # that the empty string we may have added earlier remains.\\r\\n # Do not filter out the '' that we might have added earlier\\r\\n names = filter(lambda x: not x or x[0] != '.', names)\\r\\n return fnmatch_filter(names, pattern)\",\n \"def glob(self, glob_expr: str) -> Iterator[NicePath]:\\n for path in self._root.glob(glob_expr):\\n relative_path = path.relative_to(self._root)\\n if not self._match_include(relative_path):\\n continue\\n if self._match_exclude(relative_path):\\n continue\\n\\n yield NicePath(path)\",\n \"def fn_to_reg(self, searchItems):\\n return [re.compile(fnmatch.translate(s)) for s in searchItems]\",\n \"def eval(self):\\n if self.magic:\\n return self.magic\\n if not self.filename:\\n return file_pattern.format(self.alias)\\n return self.path\",\n \"def getGlobusFiles(self):\\n\\t\\treturn self.transfer_client.operation_ls(self.transfer_client.endpoint_search(DATA_ENDPOINT_NAME)[0]['name'])\",\n \"def incognita(data):\\n incognita =['*' for i in data]\\n return incognita\",\n \"def collect_feeds(args):\\n\\tfor arg in args:\\n\\t\\tfor feedpath in glob.iglob(os.path.abspath(arg)):\\n\\t\\t\\tyield feedpath\",\n \"def test_glob(tmp_path: Path) -> None:\\n sample_original = Path(__file__).parent.joinpath(\\\"sample.txt\\\")\\n\\n tmp_sample1 = tmp_path.joinpath(\\\"sample1.txt\\\")\\n shutil.copyfile(sample_original, tmp_sample1)\\n tmp_sample2 = tmp_path.joinpath(\\\"sample2.txt\\\")\\n shutil.copyfile(sample_original, tmp_sample2)\\n\\n tmp_sub_dir = tmp_path.joinpath(\\\"subdir\\\")\\n tmp_sub_dir.mkdir()\\n tmp_sample3 = tmp_sub_dir.joinpath(\\\"sample3.txt\\\")\\n shutil.copyfile(sample_original, tmp_sample3)\\n\\n files: List[str] = glob.glob(str(tmp_path.joinpath(\\\"**/*.txt\\\")), recursive=True)\\n assert files == [str(tmp_sample1), str(tmp_sample2), str(tmp_sample3)]\\n\\n # pathlib.Path equivalent\\n file_paths: Generator[Path, None, None] = tmp_path.glob(\\\"**/*.txt\\\")\\n assert [str(path) for path in file_paths] == files\",\n \"def globbed(gname=None):\\n def decorator(func):\\n name = gname if gname is not None else f\\\"_{func.__name__}\\\"\\n @wraps(func)\\n def wrapped_func(*args, **kwargs):\\n res = func(*args, **kwargs)\\n res = glob(**{name: res})\\n return res\\n return wrapped_func\\n return decorator\",\n \"def get_input_files(self, action):\\n\\n def input_function(wildcards):\\n \\\"\\\"\\\"Helper rapper function\\\"\\\"\\\"\\n return expand(\\n self.base_path_in.format(wildcards=wildcards),\\n postproc=[self._get_postproc_token()],\\n ext=self.extensions,\\n )\\n\\n assert action == \\\"run\\\", \\\"Unsupported action\\\"\\n return input_function\",\n \"def json_fpaths() -> [str]:\\n return glob.glob(f\\\"{RECIPES_DIRPATH}/*.json\\\")\",\n \"def get_filenames(level, pattern=None, env='stage', ext='.fits.gz',\\n iterator=True):\\n if pattern is None:\\n pattern = '*'\\n else:\\n pattern = '*' + pattern + '*'\\n path = get_data_path(level, env)\\n if not os.access(str(path), os.R_OK):\\n raise PathNotReadableError(path)\\n result = map(str, path.glob(pattern + ext))\\n return result if iterator else list(result)\",\n \"def to_path_globs(self, glob_match_error_behavior: GlobMatchErrorBehavior) -> PathGlobs:\\n return self._generate_path_globs((*self.includes, *self.ignores), glob_match_error_behavior)\",\n \"def file_matches(self, text):\\n \\n #print 'Completer->file_matches: <%s>' % text # dbg\\n\\n # chars that require escaping with backslash - i.e. chars\\n # that readline treats incorrectly as delimiters, but we\\n # don't want to treat as delimiters in filename matching\\n # when escaped with backslash\\n \\n protectables = ' ()[]{}'\\n\\n def protect_filename(s):\\n return \\\"\\\".join([(ch in protectables and '\\\\\\\\' + ch or ch)\\n for ch in s])\\n\\n lbuf = self.get_line_buffer()[:self.readline.get_endidx()]\\n open_quotes = 0 # track strings with open quotes\\n try:\\n lsplit = shlex_split(lbuf)[-1]\\n except ValueError:\\n # typically an unmatched \\\", or backslash without escaped char.\\n if lbuf.count('\\\"')==1:\\n open_quotes = 1\\n lsplit = lbuf.split('\\\"')[-1]\\n elif lbuf.count(\\\"'\\\")==1:\\n open_quotes = 1\\n lsplit = lbuf.split(\\\"'\\\")[-1]\\n else:\\n return None\\n except IndexError:\\n # tab pressed on empty line\\n lsplit = \\\"\\\"\\n\\n if lsplit != protect_filename(lsplit):\\n # if protectables are found, do matching on the whole escaped\\n # name\\n has_protectables = 1\\n text0,text = text,lsplit\\n else:\\n has_protectables = 0\\n text = os.path.expanduser(text)\\n \\n if text == \\\"\\\":\\n return [protect_filename(f) for f in self.glob(\\\"*\\\")]\\n\\n m0 = self.clean_glob(text.replace('\\\\\\\\',''))\\n if has_protectables:\\n # If we had protectables, we need to revert our changes to the\\n # beginning of filename so that we don't double-write the part\\n # of the filename we have so far\\n len_lsplit = len(lsplit)\\n matches = [text0 + protect_filename(f[len_lsplit:]) for f in m0]\\n else:\\n if open_quotes:\\n # if we have a string with an open quote, we don't need to\\n # protect the names at all (and we _shouldn't_, as it\\n # would cause bugs when the filesystem call is made).\\n matches = m0\\n else:\\n matches = [protect_filename(f) for f in m0]\\n if len(matches) == 1 and os.path.isdir(matches[0]):\\n # Takes care of links to directories also. Use '/'\\n # explicitly, even under Windows, so that name completions\\n # don't end up escaped.\\n matches[0] += '/'\\n return matches\",\n \"def get_all_filenames_from_dir(directory,suffex, filename_allowed_list = None):\\n\\n files_list = list()\\n if filename_allowed_list == None:\\n for item in glob.glob(directory+'*'+suffex): # Example /datasets/Stock_dataset/Stocks/*.txt\\n files_list.append(item) \\n else:\\n filename_allowed_list = [v.lower() for v in filename_allowed_list] # To avoid case sensitve\\n for item in glob.glob(directory+'*'+suffex):\\n if item.split(\\\"/\\\")[-1].split('.')[0].lower() in filename_allowed_list: # Since linux is case sensitive, then so is this function, make sure the names match correctly\\n files_list.append(item)\\n if not len(files_list) == len(filename_allowed_list):\\n print 'Some Stocks files are missing'\\n return files_list\",\n \"def _handle_supplemental_data(self):\\n\\n [data.copy(self.build_directory) for data in self.supplemental_data]\",\n \"def compare_ra_sigs_inputs_wc(wildcards):\\n in_wc = [x.format(**wildcards) for x in compare_ra_sigs_inputs]\\n in_wc = [\\\"/%s\\\"%(x) for x in in_wc]\\n in_wc = \\\" \\\".join(in_wc)\\n return in_wc\",\n \"def _get_files(\\n self,\\n data_root,\\n data_subset=\\\"full/*0\\\",\\n signal_subset=\\\"*\\\",\\n noise_subset=\\\"*\\\",\\n data_type=\\\"raw\\\",\\n noise_type=\\\"stationary\\\",\\n noise_type_sim=None,\\n mask_type=\\\"hitsmask_tailored\\\",\\n signal_type=\\\"r0p03\\\",\\n signal_type_sim=None,\\n signal_transfer_type=None,\\n suffix=\\\"\\\",\\n foreground_type_sim=None,\\n template_type=None,\\n sub_planck=False,\\n ):\\n\\n if signal_transfer_type is None:\\n signal_transfer_type = signal_type\\n\\n # regularize data root\\n if not os.path.exists(data_root):\\n raise OSError(\\\"Missing data root {}\\\".format(data_root))\\n\\n # find all map files\\n map_root = os.path.join(data_root, \\\"data_{}\\\".format(data_type))\\n map_files = []\\n data_subset = data_subset.split(\\\",\\\")\\n for f in np.atleast_1d(data_subset):\\n files = glob.glob(os.path.join(map_root, \\\"{}.fits\\\".format(f)))\\n if not len(files):\\n raise OSError(\\\"Missing files in data subset {}\\\".format(f))\\n map_files.extend(files)\\n data_subset = \\\",\\\".join(data_subset)\\n map_files = sorted(map_files)\\n map_files = [f for f in map_files if os.path.basename(f).startswith(\\\"map_\\\")]\\n map_tags = [\\n os.path.splitext(os.path.basename(f))[0].split(\\\"_\\\", 1)[1] for f in map_files\\n ]\\n map_freqs = []\\n for t in map_tags:\\n # if map tag is not a plain frequency, extract plain frequency\\n map_freqs.append(self.dict_freqs[t])\\n self.log(\\\"Found {} map files in {}\\\".format(len(map_files), map_root), \\\"info\\\")\\n self.log(\\\"Map files: {}\\\".format(map_files), \\\"debug\\\")\\n self.log(\\\"Map freqs: {}\\\".format(map_freqs), \\\"debug\\\")\\n\\n raw_root = None\\n raw_files = None\\n # find all corresponding signal sims\\n signal_root = os.path.join(data_root, \\\"signal_{}\\\".format(signal_type))\\n num_signal = None\\n signal_files = []\\n for f in map_files:\\n sfiles = sorted(\\n glob.glob(\\n f.replace(map_root, signal_root).replace(\\n \\\".fits\\\", \\\"_{}.fits\\\".format(signal_subset)\\n )\\n )\\n )\\n nsims1 = len(sfiles)\\n if not nsims1:\\n raise OSError(\\\"Missing signal sims for {}\\\".format(f))\\n if num_signal is None:\\n num_signal = nsims1\\n else:\\n if nsims1 != num_signal:\\n raise OSError(\\n \\\"Found {} signal sims for map {}, expected {}\\\".format(\\n nsims1, f, num_signal\\n )\\n )\\n num_signal = min(num_signal, nsims1)\\n signal_files.append(sfiles)\\n signal_files = np.asarray([x[:num_signal] for x in signal_files])\\n self.log(\\\"Found {} signal sims in {}\\\".format(num_signal, signal_root), \\\"info\\\")\\n self.log(\\n \\\"First signal sim files: {}\\\".format(signal_files[:, 0].tolist()), \\\"debug\\\"\\n )\\n\\n # find all corresponding signal transfer function sims\\n signal_transfer_root = os.path.join(\\n data_root, \\\"signal_{}\\\".format(signal_transfer_type)\\n )\\n num_signal_transfer = None\\n signal_transfer_files = []\\n for f in map_files:\\n sfiles = sorted(\\n glob.glob(\\n f.replace(map_root, signal_transfer_root).replace(\\n \\\".fits\\\", \\\"_{}.fits\\\".format(signal_subset)\\n )\\n )\\n )\\n nsims1 = len(sfiles)\\n if not nsims1:\\n raise OSError(\\\"Missing signal sims for {}\\\".format(f))\\n if num_signal_transfer is None:\\n num_signal_transfer = nsims1\\n else:\\n if nsims1 != num_signal_transfer:\\n raise OSError(\\n \\\"Found {} signal_transfer sims for map {}, expected {}\\\".format(\\n nsims1, f, num_signal_transfer\\n )\\n )\\n num_signal_transfer = min(num_signal_transfer, nsims1)\\n signal_transfer_files.append(sfiles)\\n signal_transfer_files = np.asarray(\\n [x[:num_signal_transfer] for x in signal_transfer_files]\\n )\\n self.log(\\n \\\"Found {} signal transfer sims in {}\\\".format(\\n num_signal_transfer, signal_transfer_root\\n ),\\n \\\"info\\\",\\n )\\n self.log(\\n \\\"First signal transfer sim files: {}\\\".format(\\n signal_transfer_files[:, 0].tolist()\\n ),\\n \\\"debug\\\",\\n )\\n\\n # find all corresponding noise sims\\n if noise_type is not None:\\n noise_root = os.path.join(data_root, \\\"noise_{}\\\".format(noise_type))\\n num_noise = None\\n noise_files = []\\n for f in map_files:\\n nfiles = sorted(\\n glob.glob(\\n f.replace(map_root, noise_root).replace(\\n \\\".fits\\\", \\\"_{}.fits\\\".format(noise_subset)\\n )\\n )\\n )\\n nsims1 = len(nfiles)\\n if not nsims1:\\n raise OSError(\\\"Missing noise sims for {}\\\".format(f))\\n if num_noise is None:\\n num_noise = nsims1\\n else:\\n if nsims1 != num_noise:\\n raise OSError(\\n \\\"Found {} noise sims for map {}, expected {}\\\".format(\\n nsims1, f, num_noise\\n )\\n )\\n num_noise = min(num_noise, nsims1)\\n noise_files.append(nfiles)\\n noise_files = np.asarray([x[:num_noise] for x in noise_files])\\n self.log(\\\"Found {} noise sims in {}\\\".format(num_noise, noise_root), \\\"info\\\")\\n self.log(\\n \\\"First noise sim files: {}\\\".format(noise_files[:, 0].tolist()), \\\"debug\\\"\\n )\\n else:\\n noise_root = None\\n noise_files = None\\n\\n # find all corresponding noise sims for sim_index run\\n if noise_type_sim is not None:\\n noise_root_sim = os.path.join(data_root, \\\"noise_{}\\\".format(noise_type_sim))\\n num_noise_sim = None\\n noise_files_sim = []\\n for f in map_files:\\n nfiles = sorted(\\n glob.glob(\\n f.replace(map_root, noise_root_sim).replace(\\n \\\".fits\\\", \\\"_{}.fits\\\".format(noise_subset)\\n )\\n )\\n )\\n nsims1 = len(nfiles)\\n if not nsims1:\\n raise OSError(\\\"Missing noise sims for {}\\\".format(f))\\n if num_noise_sim is None:\\n num_noise_sim = nsims1\\n else:\\n if nsims1 != num_noise_sim:\\n raise OSError(\\n \\\"Found {} noise sims for map {}, expected {}\\\".format(\\n nsims1, f, num_noise_sim\\n )\\n )\\n num_noise_sim = min(num_noise_sim, nsims1)\\n noise_files_sim.append(nfiles)\\n noise_files_sim = np.asarray(noise_files_sim)\\n self.log(\\n \\\"Found {} noise sims in {}\\\".format(num_noise_sim, noise_root_sim),\\n \\\"info\\\",\\n )\\n self.log(\\n \\\"First noise sim files: {}\\\".format(noise_files_sim[:, 0].tolist()),\\n \\\"debug\\\",\\n )\\n else:\\n noise_root_sim = noise_root\\n noise_files_sim = noise_files\\n\\n # find all corresponding signal sims for sim_index run\\n if signal_type_sim is not None:\\n signal_root_sim = os.path.join(\\n data_root, \\\"signal_{}\\\".format(signal_type_sim)\\n )\\n num_signal_sim = None\\n signal_files_sim = []\\n for f in map_files:\\n nfiles = sorted(\\n glob.glob(\\n f.replace(map_root, signal_root_sim).replace(\\n \\\".fits\\\", \\\"_{}.fits\\\".format(signal_subset)\\n )\\n )\\n )\\n nsims1 = len(nfiles)\\n if not nsims1:\\n raise OSError(\\\"Missing signal sims for {}\\\".format(f))\\n if num_signal_sim is None:\\n num_signal_sim = nsims1\\n else:\\n if nsims1 != num_signal_sim:\\n raise OSError(\\n \\\"Found {} signal sims for map {}, expected {}\\\".format(\\n nsims1, f, num_signal_sim\\n )\\n )\\n num_signal_sim = min(num_signal_sim, nsims1)\\n signal_files_sim.append(nfiles)\\n signal_files_sim = np.asarray(signal_files_sim)\\n self.log(\\n \\\"Found {} signal sims in {}\\\".format(num_signal_sim, signal_root_sim),\\n \\\"info\\\",\\n )\\n self.log(\\n \\\"First signal sim files: {}\\\".format(signal_files_sim[:, 0].tolist()),\\n \\\"debug\\\",\\n )\\n else:\\n signal_root_sim = signal_root\\n signal_files_sim = signal_files\\n\\n # find all corresponding foreground sims for sim_index run\\n if foreground_type_sim is not None:\\n foreground_root = os.path.join(\\n data_root, \\\"foreground_{}\\\".format(foreground_type_sim)\\n )\\n num_foreground_sim = None\\n foreground_files = []\\n for f in map_files:\\n nfiles = sorted(\\n glob.glob(\\n f.replace(map_root, foreground_root).replace(\\\".fits\\\", \\\"_*.fits\\\")\\n )\\n )\\n nsims1 = len(nfiles)\\n if not nsims1:\\n raise OSError(\\\"Missing foreground sims for {}\\\".format(f))\\n if num_foreground_sim is None:\\n num_foreground_sim = nsims1\\n else:\\n if nsims1 != num_foreground_sim:\\n raise OSError(\\n \\\"Found {} foreground sims for map {}, expected {}\\\".format(\\n nsims1, f, num_foreground_sim\\n )\\n )\\n num_foreground_sim = min(num_foreground_sim, nsims1)\\n foreground_files.append(nfiles)\\n foreground_files = np.asarray(\\n [x[:num_foreground_sim] for x in foreground_files]\\n )\\n self.log(\\n \\\"Found {} foreground sims in {}\\\".format(\\n num_foreground_sim, foreground_root\\n ),\\n \\\"info\\\",\\n )\\n self.log(\\n \\\"First foreground sim files: {}\\\".format(\\n foreground_files[:, 0].tolist()\\n ),\\n \\\"debug\\\",\\n )\\n else:\\n foreground_root = None\\n foreground_files = None\\n\\n # find all corresponding masks\\n if mask_type is None:\\n raise ValueError(\\\"Argument mask_type required\\\")\\n # If mask is a fits file, use the same mask for all maps\\n if os.path.splitext(mask_type)[1] == \\\".fits\\\":\\n if os.path.exists(mask_type):\\n # it's an absolute path\\n mask_files = np.tile(mask_type, len(map_tags))\\n mask_root = os.path.dirname(mask_type)\\n else:\\n # it's relative to base directory structure\\n mask_files = np.tile(os.path.join(data_root, mask_type), len(map_tags))\\n mask_root = os.path.dirname(os.path.join(data_root, mask_type))\\n else:\\n mask_root = os.path.join(data_root, \\\"masks_{}\\\".format(mask_type))\\n # XXX Do this smarter\\n mask_files = [\\n os.path.join(mask_root, \\\"mask_map_{}.fits\\\".format(tag))\\n for tag in map_tags\\n ]\\n for f in mask_files:\\n if not os.path.exists(f):\\n raise OSError(\\\"Missing mask file {}\\\".format(f))\\n self.log(\\\"Found {} masks in {}\\\".format(len(mask_files), mask_root), \\\"info\\\")\\n self.log(\\\"Mask files: {}\\\".format(mask_files), \\\"debug\\\")\\n\\n # Also need a list of unique map tags for populating dictionaries\\n # in data structures\\n map_tags_orig = list(map_tags) # copy\\n map_tags = pt.unique_tags(map_tags)\\n\\n # make a list of names corresponding to the order of the cross spectra\\n map_pairs = pt.tag_pairs(map_tags)\\n map_pairs_orig = pt.tag_pairs(map_tags, index=map_tags_orig)\\n\\n # make a dictionary of map freqs for each unique map tag\\n map_freqs_dict = {}\\n for im0, m0 in enumerate(map_tags):\\n map_freqs_dict[m0] = map_freqs[im0]\\n map_freqs = map_freqs_dict\\n\\n fields = [\\n \\\"data_root\\\",\\n \\\"data_subset\\\",\\n \\\"map_root\\\",\\n \\\"map_files\\\",\\n \\\"map_tags\\\",\\n \\\"map_pairs\\\",\\n \\\"map_tags_orig\\\",\\n \\\"map_pairs_orig\\\",\\n \\\"map_freqs\\\",\\n \\\"raw_root\\\",\\n \\\"raw_files\\\",\\n \\\"signal_root\\\",\\n \\\"signal_files\\\",\\n \\\"signal_root_sim\\\",\\n \\\"signal_files_sim\\\",\\n \\\"signal_transfer_root\\\",\\n \\\"signal_transfer_files\\\",\\n \\\"noise_root\\\",\\n \\\"noise_files\\\",\\n \\\"noise_root_sim\\\",\\n \\\"noise_files_sim\\\",\\n \\\"mask_root\\\",\\n \\\"mask_files\\\",\\n \\\"foreground_root\\\",\\n \\\"foreground_files\\\",\\n ]\\n out = dict()\\n local = locals()\\n for f in fields:\\n out[f + suffix] = local[f]\\n return out\",\n \"async def glob(self):\\n # get the path string up to the wildcards\\n try:\\n pi1 = self._path.index(\\\"*\\\")\\n except ValueError:\\n pi1 = len(self._path)\\n try:\\n pi2 = self._path.index(\\\"?\\\")\\n except ValueError:\\n pi2 = len(self._path)\\n pi = min(pi1, pi2)\\n # using the prefix will cut down on the search space\\n prefix = self._path[:pi]\\n # get the wildcard\\n wildcard = self._path[pi:]\\n # set up the paginator\\n paginator = self._conn_obj.conn.get_paginator(\\\"list_objects_v2\\\")\\n parameters = {\\n 'Bucket': self._bucket,\\n 'Prefix': prefix\\n }\\n page_iterator = paginator.paginate(**parameters)\\n files = []\\n async for page in page_iterator:\\n for item in page.get('Contents', []):\\n fname = item['Key']\\n # check that it matches against wildcard\\n if fnmatch(fname, wildcard):\\n files.append(item['Key'])\\n return files\",\n \"def compile_filename_patterns(pattern_list):\\n\\n pats=list(pattern_list)\\n for i in range(len(pats)):\\n if isinstance(pats[i],str):\\n if pats[i].startswith('re:'):\\n pats[i]=pats[i][3:]\\n else:\\n pats[i]=fnmatch.translate(pats[i])\\n pats[i]=re.compile(pats[i])\\n return pats\",\n \"def _collect_bams(self, wildcards, library_name):\\n folder_name = get_ngs_library_folder_name(self.parent.sheets, wildcards.library_name)\\n for _, path_infix, filename in self.path_gen.run(folder_name, (\\\"bam\\\",)):\\n yield os.path.join(self.base_path_in, path_infix, filename).format(**wildcards)\",\n \"def create_src_file_exts_str(input_exts: list[str] = []) -> Pattern[str]:\\n import re\\n\\n input_exts = [re.escape(ext) for ext in input_exts]\\n return create_src_file_exts_regex(input_exts)\",\n \"def expand_globpaths(globpaths, cwd=None):\\n with cd(cwd):\\n paths = sum((recursive_glob(p) for p in globpaths), [])\\n return expand_paths(paths, cwd)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64430857","0.63578635","0.6261387","0.60944086","0.5796563","0.57915723","0.56762636","0.5663169","0.56547064","0.5645","0.56442356","0.56302255","0.5625942","0.56170833","0.55723745","0.5567273","0.550928","0.5502115","0.5493355","0.5465679","0.5431877","0.5431138","0.54032373","0.53886306","0.5381457","0.5368743","0.53509206","0.53491825","0.5342639","0.5321555","0.5300477","0.53004366","0.52948004","0.52895284","0.52836496","0.5280921","0.52626485","0.5256492","0.52557105","0.5255165","0.52467716","0.52416617","0.5214857","0.516767","0.5162601","0.5141091","0.51391","0.51094335","0.51015174","0.51006067","0.50968796","0.5092401","0.50902283","0.5083945","0.5079167","0.50706345","0.5065707","0.50597394","0.505912","0.50582325","0.5041793","0.5037266","0.5033112","0.5029666","0.50156355","0.50037783","0.5002383","0.49960265","0.49940354","0.4983369","0.49814552","0.49807027","0.49733457","0.49568027","0.4954784","0.49450314","0.49446714","0.49389648","0.49363515","0.49343252","0.49323747","0.49320063","0.49279746","0.4919843","0.49185508","0.49170023","0.4911474","0.49100783","0.49035856","0.48991448","0.488885","0.4873309","0.48701948","0.48681188","0.4856094","0.48515037","0.48500252","0.48484248","0.48465264","0.48425025","0.4834103"],"string":"[\n \"0.64430857\",\n \"0.63578635\",\n \"0.6261387\",\n \"0.60944086\",\n \"0.5796563\",\n \"0.57915723\",\n \"0.56762636\",\n \"0.5663169\",\n \"0.56547064\",\n \"0.5645\",\n \"0.56442356\",\n \"0.56302255\",\n \"0.5625942\",\n \"0.56170833\",\n \"0.55723745\",\n \"0.5567273\",\n \"0.550928\",\n \"0.5502115\",\n \"0.5493355\",\n \"0.5465679\",\n \"0.5431877\",\n \"0.5431138\",\n \"0.54032373\",\n \"0.53886306\",\n \"0.5381457\",\n \"0.5368743\",\n \"0.53509206\",\n \"0.53491825\",\n \"0.5342639\",\n \"0.5321555\",\n \"0.5300477\",\n \"0.53004366\",\n \"0.52948004\",\n \"0.52895284\",\n \"0.52836496\",\n \"0.5280921\",\n \"0.52626485\",\n \"0.5256492\",\n \"0.52557105\",\n \"0.5255165\",\n \"0.52467716\",\n \"0.52416617\",\n \"0.5214857\",\n \"0.516767\",\n \"0.5162601\",\n \"0.5141091\",\n \"0.51391\",\n \"0.51094335\",\n \"0.51015174\",\n \"0.51006067\",\n \"0.50968796\",\n \"0.5092401\",\n \"0.50902283\",\n \"0.5083945\",\n \"0.5079167\",\n \"0.50706345\",\n \"0.5065707\",\n \"0.50597394\",\n \"0.505912\",\n \"0.50582325\",\n \"0.5041793\",\n \"0.5037266\",\n \"0.5033112\",\n \"0.5029666\",\n \"0.50156355\",\n \"0.50037783\",\n \"0.5002383\",\n \"0.49960265\",\n \"0.49940354\",\n \"0.4983369\",\n \"0.49814552\",\n \"0.49807027\",\n \"0.49733457\",\n \"0.49568027\",\n \"0.4954784\",\n \"0.49450314\",\n \"0.49446714\",\n \"0.49389648\",\n \"0.49363515\",\n \"0.49343252\",\n \"0.49323747\",\n \"0.49320063\",\n \"0.49279746\",\n \"0.4919843\",\n \"0.49185508\",\n \"0.49170023\",\n \"0.4911474\",\n \"0.49100783\",\n \"0.49035856\",\n \"0.48991448\",\n \"0.488885\",\n \"0.4873309\",\n \"0.48701948\",\n \"0.48681188\",\n \"0.4856094\",\n \"0.48515037\",\n \"0.48500252\",\n \"0.48484248\",\n \"0.48465264\",\n \"0.48425025\",\n \"0.4834103\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21996,"cells":{"query":{"kind":"string","value":"Print every package as \"ignored\"."},"document":{"kind":"string","value":"def _print_ignored(packages):\n if not packages:\n print(\"## No Rez package was set to be ignored\")\n print(\"No data found\")\n\n return\n\n print(\"## Every package in this list was explicitly set to ignored by the user\")\n\n for package, pattern in sorted(packages, key=_get_package_name):\n print(\n 'Package: {package.name} - Pattern: \"{pattern}\"'.format(\n package=package, pattern=pattern\n )\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _print_missing(packages, verbose):\n if not packages:\n print(\"## No Rez packages were found.\")\n print(\"No data found\")\n\n return\n\n print(\"## Your command affects these Rez packages.\")\n\n template = \"{package.name}\"\n\n if verbose:\n template = \"{package.name}: {path}\"\n\n for line in sorted(\n template.format(package=package, path=finder.get_package_root(package))\n for package in packages\n ):\n print(line)","def _print_skips(skips, verbose):\n if not skips:\n print(\"## No packages were skipped\")\n print(\"Every found Rez package can be processed by the command.\")\n\n return\n\n print(\"## Packages were skipped from running a command. Here's the full list:\")\n\n template = \"{issue.package.name}: {issue.reason}\"\n\n if verbose:\n template = \"{issue.package.name}: {issue.path}: {issue.reason}\"\n\n for issue in skips:\n print(template.format(issue=issue))","def list_packages(self):\n for tag, pkg in PACKAGES.iteritems():\n print \"{tag} - {label}\".format(tag=tag, label=pkg['label'])","def print_test_deps_not_in_package_deps(self):\n extras = []\n for key, rec_deps in self.recursive_pkg_deps.items():\n any = self.test_imports.get(key, set()).difference(rec_deps, set([key]))\n if any:\n extras.append((key, any))\n\n if extras:\n print(\"Packages whose tests have extra dependencies not listed in `go list -f {{.Deps}}`:\")\n for pkg, deps in extras:\n print(\"\\t{0}: {1}\".format(pkg, \", \".join(deps)))\n print(\"\\n\")","def ignore_from_package(self, project, package, arch, ignore):\n for binary in binary_list(self.apiurl, project, 'standard', arch, package):\n ignore.add(binary.name)\n\n return ignore","def output_ignored(self) -> List[str]:\n output = list()\n for ignored in sorted(self.ignored):\n if len(ignored) == 2:\n line = f\"{ignored[0]} - Ignored {ignored[1]}!\"\n else:\n line = f\"{ignored[0]} - {ignored[1]}: Ignored {ignored[2]}!\"\n logger.info(line)\n output.append(line)\n return output","def _list_all(root_pkg, prog):\n res = \"\\n\".join(\n sorted(\n pkinspect.package_module_names(_import(root_pkg)),\n key=str.lower,\n ),\n )\n sys.stderr.write(f\"usage: {prog} module command [args...]\\nModules:\\n{res}\\n\")\n return 1","def show_missing():\n if missing_modules:\n info(\"The following modules are currently not installed and would enable additional tasks:\")\n for pkg_name in missing_modules:\n info(' ' + pkg_name)","def _filter_pkgs(self, pkgs):\n pkgs = [pkg.strip() for pkg in pkgs]\n return [\n pkg for pkg in pkgs\n if pkg.startswith(self.base_pkg) and not pkg.startswith(os.path.join(self.base_pkg, \"vendor/\"))\n ]","def ignores(self):\n pass # make ignore_tags unaccessible","def isIgnoredPackage(self, *args):\n return _libsbml.SBMLDocument_isIgnoredPackage(self, *args)","def remove_packages(self, packages):","def disableUnusedPackages(self, *args):\n return _libsbml.SBMLExtensionRegistry_disableUnusedPackages(self, *args)","def isIgnoredPkg(self, *args):\n return _libsbml.SBMLDocument_isIgnoredPkg(self, *args)","def suppress(self):\n pass","def ignore_pyc(root,names):\n return [name for name in names if name.endswith('pyc')]","def printImported():\r\n ll = sorted([mod for mod in sys.modules if mod.find('pubsub') >= 0])\r\n\r\n py2and3.print_('\\n'.join(ll))","def gitIgnoreContent( self, pars, directory ):\n\n name = pars['name']\n\n return f\"\"\"\\\n{name}-*.pkg*\nsrc/\npkg/\n\"\"\"","def cleanup_import(package_name):\n\n for k in list(sys.modules):\n if not isinstance(k, str):\n # Some things will actually do this =_=\n continue\n elif k.startswith('astropy_helpers.tests'):\n # Don't delete imported test modules or else the tests will break,\n # badly\n continue\n if k == package_name or k.startswith(package_name + '.'):\n del sys.modules[k]","def report_unused_cycle_suppressions(self, reporter):\n for module in self.get_modules():\n for dep in module.get_dependencies():\n if not dep.suppression_used:\n reporter.cyclic_issue(\"unused cycle suppression: {0} -> {1}\".format(module.get_name()[7:], dep.get_other_module().get_name()[7:]))","def ignore_all(self):\n # type: () -> bool\n return False","def print_all_separation_algorithms():\n from ..separation import all_separation_algorithms\n print('\\n'.join([a.__name__ for a in all_separation_algorithms]))","def ignored(*exceptions):\n import logging\n import pprint\n try:\n yield\n except exceptions:\n logging.warning(pprint.pformat(exceptions[0]))\n pass","def have_package_lists():\n return 'Filename:' in execute('apt-cache', 'show', 'python', check=False, capture=True)","def ignore_from_repo(self, directory, ignore):\n for filename in os.listdir(directory):\n if not filename.endswith('.rpm'):\n continue\n _, basename = filename.split('-', 1)\n ignore.add(basename[:-4])","def packages(self):\n return []","def no_additional_complaints() -> None:\n logging.getLogger(\"asyncio\").setLevel(\"CRITICAL\")\n warnings.simplefilter(\"ignore\")","def clearWarnings():\n for name, mod in list(sys.modules.items()):\n try:\n reg = getattr(mod, \"__warningregistry__\", None)\n except ImportError:\n continue\n if reg:\n reg.clear()","def strip_blocks(self):\n print_content = False\n if self.exclude_blocks and len(self.exclude_blocks) > 0:\n for package_name, package in self.packages.items():\n for c, fd in package.components.iteritems():\n for block in self.exclude_blocks:\n JS_BLOCKS = re.compile(r'/[/*]\\s*<' + block + '>.+?<\\/' + block + '>(?:\\s*\\*/)?(?s)', re.MULTILINE)\n fd.content = JS_BLOCKS.sub('/* compat block ' + block + ' removed */', fd.content)\n print_content = True\n if print_content:\n print fd.content","def show_packagelist(user, repo, packages, distro=False, version=False,\n name=False, match=False, pkgtype=False):\n\n print('Currently {}/{} contains these matching packages:'.format(\n user, repo))\n\n numpkgs = 0\n for package in packages:\n if (distro and not package['distro_version'] == distro) or \\\n (version and not package['version'] == version) or \\\n (name and not package['name'] == name) or \\\n (pkgtype and not package['type'] == pkgtype) or \\\n (match and match not in package['filename']):\n continue\n\n print(fmt_pkg(user, repo, package))\n numpkgs += 1\n\n print(\"Repo contains {} matching packages.\".format(numpkgs))","def suppressMessages():\n dislin.unit(0)","def list_providers_packages():\n providers = get_all_providers()\n # if provider needs to be not considered in release add it here\n # this is useful for cases where provider is WIP for a long period thus we don't want to release it yet.\n providers_to_remove_from_release = []\n for provider in providers:\n if provider in providers_to_remove_from_release:\n continue\n console.print(provider)","def _print_invalids(invalids, verbose):\n if not invalids:\n print(\"## No Rez package was set as invalid.\")\n print(\"Nothing is invalid. Which is a good thing!\")\n\n return\n\n print(\"## Some packages were marked as invalid. Here's why:\")\n\n template = \"{package.name}: {message}\"\n\n if verbose:\n template = \"{package.name}: {path} {message}: {full}\"\n\n for message in sorted(\n (\n template.format(\n package=error.get_package(),\n path=error.get_path(),\n message=str(error),\n full=error.get_full_message(),\n )\n for error in invalids\n )\n ):\n print(message)","def stripPackage(self, *args):\n return _libsbml.ASTBasePlugin_stripPackage(self, *args)","def missing_ltihooks(finder, caller):\n caller.IgnoreName(\"ltihooks\")","def list_package(all: bool = False) -> List[List[str]]:\n if not all:\n pkgs_info = read_installation_records()\n else:\n pkgs_info = []\n for pkg in pkg_resources.working_set:\n pkgs_info.append([pkg.project_name, pkg.version])\n\n return pkgs_info","def dump(self):\n\n\t\treturn [\n\t\t\tpkg.dump()\n\t\t\tfor pkg in self._packages.values()\n\t\t]","def getMissingPackages(self, language=None, all=False, packages=None, showInstalled=False):\n if self._cache.broken_count > 0:\n raise SoftwareIndexBroken\n \n self.langpack_locales = {}\n self.pkg_translations = {}\n self.pkg_writing = {}\n filter_list = {}\n blacklist = []\n show = []\n self.missing = set()\n self.installed = set()\n self.system_pkgcode = ''\n \n for l in open(self.BLACKLIST):\n l = l.strip()\n if not l.startswith('#'):\n blacklist.append(l)\n \n for l in open(self.LANGCODE_TO_LOCALE):\n try:\n l = l.rstrip()\n if ':' in l:\n (pkgcode, locale) = l.split(':')\n else:\n pkgcode = l\n locale = l\n except ValueError:\n continue\n self.langpack_locales[locale] = pkgcode\n \n for l in open(self.PACKAGE_DEPENDS):\n if l.startswith('#'):\n continue\n try:\n l = l.rstrip()\n # sort out comments\n if l.find('#') >= 0:\n continue\n (c, lc, k, v) = l.split(':')\n except ValueError:\n continue\n if (c == 'tr' and lc == ''):\n filter_list[v] = k\n elif (c == 'wa' and lc != ''):\n if '|' in lc:\n for l in lc.split('|'):\n if not l in self.pkg_writing:\n self.pkg_writing[l] = []\n self.pkg_writing[l].append((\"%s\" % k, \"%s\" % v))\n else:\n if not lc in self.pkg_writing:\n self.pkg_writing[lc] = []\n self.pkg_writing[lc].append((\"%s\" % k, \"%s\" % v))\n\n # get list of all packages available on the system and filter them\n for item in self._cache.keys():\n if item in blacklist: \n continue\n for x in filter_list.keys():\n if item.startswith(x) and not item.endswith('-base'):\n # parse language code\n langcode = item.replace(x, '')\n #print \"%s\\t%s\" % (item, langcode)\n if langcode == 'zh':\n # special case: zh langpack split\n for langcode in ['zh-hans', 'zh-hant']:\n if not langcode in self.pkg_translations:\n self.pkg_translations[langcode] = []\n self.pkg_translations[langcode].append((\"%s\" % filter_list[x], \"%s\" % item))\n elif langcode in self.langpack_locales.values():\n # langcode == pkgcode\n if not langcode in self.pkg_translations:\n self.pkg_translations[langcode] = []\n self.pkg_translations[langcode].append((\"%s\" % filter_list[x], \"%s\" % item))\n #print self.pkg_translations[langcode]\n else:\n # need to scan for LL-CC and LL-VARIANT codes\n for locale in self.langpack_locales.keys():\n if '_' in locale or '@' in locale:\n if '@' in locale:\n (locale, variant) = locale.split('@')\n else:\n variant = ''\n (lcode, ccode) = locale.split('_')\n if langcode in [\"%s-%s\" % (lcode, ccode.lower()),\n \"%s%s\" % (lcode, ccode.lower()),\n \"%s-%s\" % (lcode, variant),\n \"%s%s\" % (lcode, variant),\n \"%s-latn\" % lcode,\n \"%slatn\" % lcode,\n \"%s-%s-%s\" % (lcode, ccode.lower(), variant),\n \"%s%s%s\" % (lcode, ccode.lower(), variant)]:\n # match found, get matching pkgcode\n langcode = self.langpack_locales[locale]\n if not langcode in self.pkg_translations:\n self.pkg_translations[langcode] = []\n self.pkg_translations[langcode].append((\"%s\" % filter_list[x], \"%s\" % item))\n #print self.pkg_translations[langcode]\n break\n\n if language:\n pkgcode = ''\n if language == 'zh-hans' or language == 'zh-hant':\n self.system_pkgcode = language\n elif language in self.langpack_locales:\n self.system_pkgcode = self.langpack_locales[language]\n else:\n # pkgcode = ll\n if '_' in language:\n (self.system_pkgcode) = language.split('_')[0]\n elif '@' in language:\n (self.system_pkgcode) = language.split('@')[0]\n else:\n self.system_pkgcode = language\n\n if packages:\n self.findPackages(self.system_pkgcode, packages)\n else:\n self.findPackages(self.system_pkgcode)\n \n elif all:\n # try all available languages\n pkgcodes = []\n for item in self._cache.keys():\n if item in blacklist:\n continue\n if item.startswith('language-pack-') and \\\n not item.startswith('language-pack-gnome') and \\\n not item.startswith('language-pack-kde') and \\\n not item.endswith('-base'):\n pkgcode = item.replace('language-pack-', '')\n pkgcodes.append(pkgcode)\n\n for pkgcode in pkgcodes:\n if packages:\n self.findPackages(pkgcode, packages)\n else:\n self.findPackages(pkgcode)\n\n else:\n # get a list of language-packs we have already installed or are going to install\n # 1. system locale\n system_langcode = self._localeinfo.getSystemDefaultLanguage()[0]\n if system_langcode == None:\n system_langcode = 'en_US'\n if system_langcode in self.langpack_locales:\n self.system_pkgcode = self.langpack_locales[system_langcode]\n # 2. installed language-packs\n pkgcodes = []\n for item in self._cache.keys():\n if item in blacklist: \n continue\n if item.startswith('language-pack-') and \\\n not item.startswith('language-pack-gnome') and \\\n not item.startswith('language-pack-kde') and \\\n not item.endswith('-base') and \\\n (self._cache[item].is_installed or \\\n self._cache[item].marked_install):\n pkgcode = item.replace('language-pack-', '')\n pkgcodes.append(pkgcode)\n if self.system_pkgcode and \\\n not self.system_pkgcode in pkgcodes:\n pkgcodes.append(self.system_pkgcode)\n \n for pkgcode in pkgcodes:\n if packages:\n self.findPackages(pkgcode, packages)\n else:\n self.findPackages(pkgcode)\n \n if showInstalled:\n show = self.missing | self.installed\n else:\n show = self.missing\n\n return show","def isDisabledIgnoredPackage(self, *args):\n return _libsbml.SBMLDocument_isDisabledIgnoredPackage(self, *args)","def isStripAllUnrecognizedPackages(self):\n return _libsbml.SBMLStripPackageConverter_isStripAllUnrecognizedPackages(self)","def filter_warnings():\n warnings.simplefilter(\"ignore\", category=UserWarning)\n warnings.simplefilter(\"ignore\", category=LightningDeprecationWarning)","def _extract_r_remove_package_names(log):\n start = \"remove.packages(c(\"\n i_start = log.find(start) + len(start)\n i_end = log.find(\")\", i_start)\n package_names = [name.strip('\"') for name in log[i_start:i_end].split(\",\")]\n return package_names","def test_ignores(self, tmpdir):\n from pytest_flake8 import Ignorer\n ignores = [\"E203\", \"b/?.py E204 W205\", \"z.py ALL\", \"*.py E300\"]\n ign = Ignorer(ignores)\n assert ign(tmpdir.join(\"a/b/x.py\")) == \"E203 E204 W205 E300\".split()\n assert ign(tmpdir.join(\"a/y.py\")) == \"E203 E300\".split()\n assert ign(tmpdir.join(\"a/z.py\")) is None","def stripPackage(self, *args):\n return _libsbml.SBasePlugin_stripPackage(self, *args)","def freeze_includes() -> List[str]:\n import _pytest\n\n result = list(_iter_all_modules(_pytest))\n return result","def missing_tests(session):\n print('The following samples do not have tests:')\n for sample in set(ALL_SAMPLE_DIRECTORIES) - set(ALL_TESTED_SAMPLES):\n print('* {}'.format(sample))","def get_packages(package):\n return [str(path.parent) for path in Path(package).glob(\"**/__init__.py\")]","def _suppress_warnings():\n import warnings\n import sys\n import os\n if os.path.basename(sys.argv[0]) != \"trial\":\n warnings.simplefilter(\"ignore\")","def main():\n\n local_pkgs = set(os.listdir(GIT_FOLDER))\n local_pkgs = set([it.replace('.git', '') for it in local_pkgs])\n\n pkgdb_info = pkgdb_pkg_branch()\n\n pkgdb_pkgs = set(pkgdb_info.keys())\n\n ## Commented out as we keep the git of retired packages while they won't\n ## show up in the information retrieved from pkgdb.\n\n #if (local_pkgs - pkgdb_pkgs):\n #print 'Some packages are present locally but not on pkgdb:'\n #print ', '.join(sorted(local_pkgs - pkgdb_pkgs))\n\n if (pkgdb_pkgs - local_pkgs):\n print 'Some packages are present in pkgdb but not locally:'\n print ', '.join(sorted(pkgdb_pkgs - local_pkgs))\n\n tofix = set()\n for pkg in sorted(pkgdb_info):\n pkgdb_branches = pkgdb_info[pkg]\n git_branches = get_git_branch(pkg)\n diff = (pkgdb_branches - git_branches)\n if diff:\n print '%s missing: %s' % (pkg, ','.join(sorted(diff)))\n tofix.add(pkg)\n branch_package(pkg, diff)\n\n if tofix:\n print 'Packages fixed (%s): %s' % (\n len(tofix), ', '.join(sorted(tofix)))","def log_unused(self, error=True):\n have_unused = False\n log = get_logger().error if error else get_logger().info\n for name in self._all_names:\n current_set = getattr(self, name, None)\n if current_set:\n log('Unused from %s: %s', name.upper(), current_set)\n have_unused = True\n return have_unused","def log_imported_packages(self):\n imported_packages_dict = self.get_imported_packages()\n\n res_str = \"\\n\".join(f\"{module}: {version_num}\" for module, version_num\n in imported_packages_dict[\"results\"].items())\n no_res_str = \"\\n\".join(f\"{module}: {version_num}\" for module, version_num\n in imported_packages_dict[\"no_results\"].items())\n errs_res_str = \"\\n\".join(f\"{module}: {version_num}\" for module, version_num\n in imported_packages_dict[\"errors\"].items())\n\n msg = f\"Imported modules:\\n {res_str}\\n {no_res_str}\\n {errs_res_str}\"\n logger.info(msg)","def required_packages(cls) -> List[Text]:\n return []","def test_ignores_all(self, testdir):\n testdir.makeini(\"\"\"\n [pytest]\n markers = flake8\n flake8-ignore = E203\n *.py E300\n tests/*.py ALL E203 # something\n \"\"\")\n testdir.tmpdir.ensure(\"xy.py\")\n testdir.tmpdir.ensure(\"tests/hello.py\")\n result = testdir.runpytest(\"--flake8\", \"-s\")\n result.assert_outcomes(passed=1)\n result.stdout.fnmatch_lines([\n \"*collected 1*\",\n \"*xy.py .*\",\n \"*1 passed*\",\n ])","def packages():","def disableCLangLogger(self):\n pass","def test_print_version_repositories_SKIP(self):\n self._uri({\n '%d.%d/maintained/%d.%d-%d/%s/Packages.gz' % (MAJOR, MINOR, MAJOR, MINOR, 0, 'all'): DATA,\n '%d.%d/maintained/%d.%d-%d/%s/Packages.gz' % (MAJOR, MINOR, MAJOR, MINOR, 0, ARCH): DATA,\n })\n tmp = self.u.print_version_repositories()\n self.assertEqual(set((\n 'deb file:///mock/%d.%d/maintained/ %d.%d-%d/%s/' % (MAJOR, MINOR, MAJOR, MINOR, 0, 'all'),\n 'deb file:///mock/%d.%d/maintained/ %d.%d-%d/%s/' % (MAJOR, MINOR, MAJOR, MINOR, 0, ARCH),\n )), set(tmp.splitlines()))","def get_packages(package):\n return [dirpath\n for dirpath, dirnames, filenames in os.walk(package)\n if os.path.exists(os.path.join(dirpath, '__init__.py'))]","def get_packages(package):\n return [dirpath\n for dirpath, dirnames, filenames in os.walk(package)\n if os.path.exists(os.path.join(dirpath, '__init__.py'))]","def get_packages(package):\n return [dirpath\n for dirpath, dirnames, filenames in os.walk(package)\n if os.path.exists(os.path.join(dirpath, '__init__.py'))]","def silent():\n GLOBAL['VERBOSE'] = False","def _filter_installed_packages(self, packages):\n filtered_packages = []\n for package in packages:\n name = package.name\n for installed in self._top_installed_repository.find_packages(name):\n if installed.key == package.key:\n break\n else:\n filtered_packages.append(package)\n return filtered_packages","def list_packages(self):\n\n # First extract loaded module names from sys.modules\n sys_modules = sys.modules.keys()\n\n packages = {}\n\n # First add moduels in sys.modules (built-ins,\n # preloads and already loaded ones)\n for name in sys_modules:\n d = self.find_package(name)\n if not d: continue\n try:\n pkginfo = packages[d['type']]\n pkginfo[d['name']] = d['path']\n except Exception, e:\n packages[d['type']] = { d['name'] : d['path'] }\n\n #import site\n # Loop through all directories in sys.path and check for modules\n # Dont iterate through <prefix>/lib directory\n libdir = os.path.join(sys.prefix, 'lib')\n\n walked = []\n for top_level in self.paths:\n if not os.path.isdir(top_level):\n continue\n\n # Dont iterate through libdir\n if os.path.abspath(top_level) == os.path.abspath(libdir):\n continue\n\n walked.append(top_level)\n for item in os.listdir(top_level):\n\n fullpath = os.path.join(top_level, item)\n if fullpath in walked: continue\n\n walked.append(fullpath)\n # Remove the extension\n idx = item.find('.')\n if idx != -1: item = item[:idx]\n d = self.find_package(item)\n if not d: continue\n try:\n pkginfo = packages[d['type']]\n pkginfo[d['name']] = d['path']\n except Exception, e:\n packages[d['type']] = { d['name'] : d['path'] } \n\n for key,item in packages.items():\n print\n print self.pkgTypeInfo(key)\n print\n\n # Print sorted\n listofitems = item.keys()\n listofitems.sort()\n\n for key2 in listofitems:\n print key2,':',item[key2]","def list_packages ( self, name_only=False ):\n if name_only:\n for name, subdir in self._subdirs.items():\n if not subdir.empty():\n yield name\n else:\n for name, subdir in self._subdirs.items():\n if not subdir.empty():\n yield self.name + os.sep + name","def output_boilerplate(stream=sys.stdout, other_imports=None):\n print(_module_docstring, file=stream)\n print(file=stream)\n print(f\"from hikaru.meta import {HikaruBase.__name__}, \"\n f\"{HikaruDocumentBase.__name__}, {KubernetesException.__name__}, \"\n f\"{WatcherDescriptor.__name__}\",\n file=stream)\n print(\"from hikaru.generate import get_clean_dict\", file=stream)\n print(\"from hikaru.utils import Response\", file=stream)\n print(\"from typing import Dict, List, Optional, Any\", file=stream)\n print(\"from dataclasses import dataclass, field, InitVar\", file=stream)\n print(\"from kubernetes.client import CoreV1Api\", file=stream)\n if other_imports is not None:\n for line in other_imports:\n print(line, file=stream)\n print(file=stream)","def get_packages():\n\n packages = find_packages()\n packages = ['{}.{}'.format('uniq', package) for package in packages]\n packages.append('uniq')\n return packages","def disable_default_logging():\n for module in _verbose_modules:\n _logging.getLogger(__name__+'.'+module).removeHandler(_default_log_handler)","def report(*packages):\n accepted_commands = ['python','conda']\n for package in packages:\n loc = \"not installed in this environment\"\n ver = \"unknown\"\n\n try:\n module = importlib.import_module(package)\n loc = os.path.dirname(module.__file__)\n\n try:\n ver = str(module.__version__)\n except Exception:\n pass\n \n except (ImportError, ModuleNotFoundError):\n if package in accepted_commands:\n try:\n # See if there is a command by that name and check its --version if so\n try:\n loc = subprocess.check_output(['command','-v', package]).decode().splitlines()[0].strip()\n except:\n # .exe in case powershell (otherwise wouldn't need it)\n loc = subprocess.check_output(['where.exe', package]).decode().splitlines()[0].strip() \n out = \"\"\n try:\n out = subprocess.check_output([package, '--version'], stderr=subprocess.STDOUT)\n except subprocess.CalledProcessError as e:\n out = e.output\n\n # Assume first word in output with a period and digits is the version\n for s in out.decode().split():\n if '.' in s and str.isdigit(s[0]) and sum(str.isdigit(c) for c in s)>=2:\n ver=s.strip()\n break\n except:\n pass\n elif package == 'system':\n try:\n ver = platform.platform(terse=True)\n loc = \"OS: \" + platform.platform()\n except Exception:\n pass\n else:\n pass\n \n print(\"{0:30} # {1}\".format(package + \"=\" + ver,loc))","def test_packages(self):\n for pkg in self.expected_packages:\n status, output = commands.getstatusoutput('pkg_info -qx %s' % pkg)\n assert status == 0","def SBMLExtensionRegistry_disablePackage(*args):\n return _libsbml.SBMLExtensionRegistry_disablePackage(*args)","def get_ignored_packages_names(ign_packages_names: Sequence[str], ign_groups_names: Sequence[str],\n upstream_system: 'System', installed_system: 'System',\n do_everything: bool = False) -> Set[str]:\n handler = PacmanConfig(conf=\"/etc/pacman.conf\").initialize_alpm()\n\n # ignored packages names - may contain glob patterns\n names_to_ignore = set(handler.ignorepkgs)\n for ign_packages_name in ign_packages_names:\n for name in ign_packages_name.split(\",\"):\n names_to_ignore.add(name)\n\n # ignored groups names\n ignored_groups_names = set(handler.ignoregrps)\n for ign_groups_name in ign_groups_names:\n for name in ign_groups_name.split(\",\"):\n ignored_groups_names.add(name)\n\n # contains the concrete packages names to ignore\n return_set = set()\n\n # check globbing\n packages_names = [package_name for package_name in upstream_system.all_packages_dict]\n for possible_glob in names_to_ignore:\n return_set |= set(fnmatch.filter(packages_names, possible_glob))\n # allow non upstream packages to be ignored, too - needed for correct replaces behavior\n if do_everything:\n packages_names = [package_name for package_name in installed_system.all_packages_dict]\n for possible_glob in names_to_ignore:\n return_set |= set(fnmatch.filter(packages_names, possible_glob))\n\n if not ignored_groups_names:\n return return_set\n\n # fetch packages names of groups to ignore\n for package_name in packages_names:\n package = upstream_system.all_packages_dict[package_name]\n # check groups\n for package_group in package.groups:\n if package_group in ignored_groups_names:\n return_set.add(package_name)\n\n return return_set","def show_keep(self, command=\"show-keep\"):\n # execute pkgin\n popen = Popen([self.pkgin_bin, \"-P\", command], stdout=PIPE, stderr=PIPE)\n # retrieve output streams\n (stdoutdata, stderrdata) = popen.communicate()\n # if pkgin error\n if(stderrdata):\n # remove the line feed\n error = stderrdata[0:-1]\n raise PykginError(error)\n # retrieve output\n output = stdoutdata\n # create a list which contain each packages\n output_whole_list = output.split('\\n')\n # remove last element (due to the last \\n)\n output_whole_list.pop()\n # create a new list in which package informations are separate\n output_list = []\n for pkg in output_whole_list:\n current = pkg.split(' ', 1)\n output_list.append(self.__extract_package_version(current[0]))\n\n return output_list","def print_all():\n for i in flags:\n print(i)","def go_quiet():\n my_logger = logging.getLogger(__name__)\n my_logger.setLevel(LEVELS['WARNING'])","def get_hidden_imports(imports):\n\n hidden_imports = []\n for i in imports:\n hidden_imports.append('--hidden-import=%s' % i)\n return hidden_imports","def show_everything():\n \n #print(\"WARNING: This may take awhile. . .\\n\")\n # Need to find all hostgroups, and make sure there are no deuplicate machines in this calculation.\n print(\"This feature is still under construction. Check back soon!\")\n sys.exit(0)","def scrub_from_sys_modules():\n for k, m in sys.modules.items():\n if k in sys_modules_whitelist:\n continue\n\n if hasattr(m, '__file__') and m.__file__ is not None:\n mp = pathlib.Path(m.__file__)\n if pex_root in mp.parents:\n yield k","def troubleshoot():\n libraries = (sys, pd, openpyxl, matplotlib, pip)\n for i in libraries:\n try:\n print(str(i), 'version:', i.__version__)\n except AttributeError:\n pass\n except ModuleNotFoundError:\n print('You do not have', str(i), 'installed.')\n print('You can do so via your interpreter or:')\n print('py -m pip install', '-' + str(i))\n print('in command prompt')","def hide_messages():\n\n print(\"Keep uncertainty data?\")\n print(\"NewDatabase(..., keep_uncertainty_data=True)\")\n print(\"\")\n print(\"Hide these messages?\")\n print(\"NewDatabase(..., quiet=True)\")","def get_packages(package):\n return [\n dirpath\n for dirpath, dirnames, filenames in os.walk(package)\n if os.path.exists(os.path.join(dirpath, '__init__.py'))\n ]","def is_ignored(self):","def _remove_extra_packages(frozen_pkgs, ret, **kwargs):\n pkgs = __salt__[\"pkg.list_pkgs\"](**kwargs)\n extra_pkgs = set(pkgs) - set(frozen_pkgs)\n for pkg in extra_pkgs:\n try:\n __salt__[\"pkg.remove\"](name=pkg, **kwargs)\n ret[\"pkgs\"][\"remove\"].append(pkg)\n log.info(\"Removed extra package %s\", pkg)\n except Exception as e: # pylint: disable=broad-except\n msg = \"Error removing %s package: %s\"\n log.error(msg, pkg, e)\n ret[\"comment\"].append(msg % (pkg, e))","def list_cmd(repo):\n click.echo('Packages and scripts installed through pipsi:')\n for venv, scripts in repo.list_everything():\n if not scripts:\n continue\n click.echo(' Package \"%s\":' % venv)\n for script in scripts:\n click.echo(' ' + script)","def lint():\n toolkit.lint(exclude=[\"__init__.py\"])","def print_package_info(package):\r\n print(\"******************\")\r\n print(\"Product: %s\" % package[0]['description'])\r\n print(\"Price: %s$ monthly\" % package[0]['prices'][0]['recurringFee'])\r\n print(\"******************\")\r\n return","def add_ignore_module(modules: List[Any]):\n global BUILTIN_LIKELY_MODULES\n for module in modules:\n if module not in BUILTIN_LIKELY_MODULES:\n BUILTIN_LIKELY_MODULES.append(module)","def print_notices(cls, settings: Settings):\n if settings.get(\"wallet.type\", \"in_memory\").lower() == \"indy\":\n with Banner(border=\":\", length=80, file=sys.stderr) as banner:\n banner.centered(\"⚠ DEPRECATION NOTICE: ⚠\")\n banner.hr()\n banner.print(\n \"The Indy wallet type is deprecated, use Askar instead; see: \"\n \"https://aca-py.org/main/deploying/IndySDKtoAskarMigration/\",\n )\n print()","def package(self):\n\t\tsys.stderr.write(\"Base class method called: package() This souldn't happen.\\n\")","def disablePyLangLogger(self):\n pass","def log_installed_modules(self):\n\n # Get python modules installed locally\n\n installed_packages = pkg_resources.working_set\n\n python_str = f'python:{sys.version}\\n'\n print_str = \"\\n\".join(f\"{package.key}: {package.version}\" for package in installed_packages)\n msg = f\"Installed packages:\\n{python_str+print_str}\"\n logger.info(msg)","def find_packages( root ):\n for path, directories, files in os.walk( root ):\n if is_package( path ):\n yield path.replace( '/','.' )","def debug(self, key, rows):\n for row in rows:\n yield log('pkgdb: %r' % row.package.pkgdb)\n yield log('rawhide: %r' % (row.package.rawhide,))\n yield log('upstream: %r' % row.package.upstream)","def __dir__():\n import pkgutil\n\n names = [\n name\n for importer, name, ispkg in pkgutil.iter_modules(__path__)\n if not ispkg and name != \"base\"\n ]\n return names + [\"custom\", \"noData\"]","def _split_the_ignored_packages(packages, patterns):\n ignored = set()\n non_ignored = set()\n\n for package in packages:\n for pattern in patterns:\n if fnmatch.fnmatch(package.name, pattern):\n ignored.add((package, pattern))\n\n break\n else:\n non_ignored.add(package)\n\n return ignored, non_ignored","def list(self):\n for dir in subdirs('plugins'):\n print dir.replace('plugins/', '')","def auto_omit():\n\tpass","def show ( self, **show_kw ):\n for package in self._subdirs.values():\n package.show ( **show_kw )","def list_package_ids(self):\n raise NotImplementedError","def ignores(self):\n return self._ignores","def missing_gdk(finder, caller):\n caller.IgnoreName(\"gdk\")","def getIgnoredPlugins(self):\n return self.yaml.getIgnoredPlugins()"],"string":"[\n \"def _print_missing(packages, verbose):\\n if not packages:\\n print(\\\"## No Rez packages were found.\\\")\\n print(\\\"No data found\\\")\\n\\n return\\n\\n print(\\\"## Your command affects these Rez packages.\\\")\\n\\n template = \\\"{package.name}\\\"\\n\\n if verbose:\\n template = \\\"{package.name}: {path}\\\"\\n\\n for line in sorted(\\n template.format(package=package, path=finder.get_package_root(package))\\n for package in packages\\n ):\\n print(line)\",\n \"def _print_skips(skips, verbose):\\n if not skips:\\n print(\\\"## No packages were skipped\\\")\\n print(\\\"Every found Rez package can be processed by the command.\\\")\\n\\n return\\n\\n print(\\\"## Packages were skipped from running a command. Here's the full list:\\\")\\n\\n template = \\\"{issue.package.name}: {issue.reason}\\\"\\n\\n if verbose:\\n template = \\\"{issue.package.name}: {issue.path}: {issue.reason}\\\"\\n\\n for issue in skips:\\n print(template.format(issue=issue))\",\n \"def list_packages(self):\\n for tag, pkg in PACKAGES.iteritems():\\n print \\\"{tag} - {label}\\\".format(tag=tag, label=pkg['label'])\",\n \"def print_test_deps_not_in_package_deps(self):\\n extras = []\\n for key, rec_deps in self.recursive_pkg_deps.items():\\n any = self.test_imports.get(key, set()).difference(rec_deps, set([key]))\\n if any:\\n extras.append((key, any))\\n\\n if extras:\\n print(\\\"Packages whose tests have extra dependencies not listed in `go list -f {{.Deps}}`:\\\")\\n for pkg, deps in extras:\\n print(\\\"\\\\t{0}: {1}\\\".format(pkg, \\\", \\\".join(deps)))\\n print(\\\"\\\\n\\\")\",\n \"def ignore_from_package(self, project, package, arch, ignore):\\n for binary in binary_list(self.apiurl, project, 'standard', arch, package):\\n ignore.add(binary.name)\\n\\n return ignore\",\n \"def output_ignored(self) -> List[str]:\\n output = list()\\n for ignored in sorted(self.ignored):\\n if len(ignored) == 2:\\n line = f\\\"{ignored[0]} - Ignored {ignored[1]}!\\\"\\n else:\\n line = f\\\"{ignored[0]} - {ignored[1]}: Ignored {ignored[2]}!\\\"\\n logger.info(line)\\n output.append(line)\\n return output\",\n \"def _list_all(root_pkg, prog):\\n res = \\\"\\\\n\\\".join(\\n sorted(\\n pkinspect.package_module_names(_import(root_pkg)),\\n key=str.lower,\\n ),\\n )\\n sys.stderr.write(f\\\"usage: {prog} module command [args...]\\\\nModules:\\\\n{res}\\\\n\\\")\\n return 1\",\n \"def show_missing():\\n if missing_modules:\\n info(\\\"The following modules are currently not installed and would enable additional tasks:\\\")\\n for pkg_name in missing_modules:\\n info(' ' + pkg_name)\",\n \"def _filter_pkgs(self, pkgs):\\n pkgs = [pkg.strip() for pkg in pkgs]\\n return [\\n pkg for pkg in pkgs\\n if pkg.startswith(self.base_pkg) and not pkg.startswith(os.path.join(self.base_pkg, \\\"vendor/\\\"))\\n ]\",\n \"def ignores(self):\\n pass # make ignore_tags unaccessible\",\n \"def isIgnoredPackage(self, *args):\\n return _libsbml.SBMLDocument_isIgnoredPackage(self, *args)\",\n \"def remove_packages(self, packages):\",\n \"def disableUnusedPackages(self, *args):\\n return _libsbml.SBMLExtensionRegistry_disableUnusedPackages(self, *args)\",\n \"def isIgnoredPkg(self, *args):\\n return _libsbml.SBMLDocument_isIgnoredPkg(self, *args)\",\n \"def suppress(self):\\n pass\",\n \"def ignore_pyc(root,names):\\n return [name for name in names if name.endswith('pyc')]\",\n \"def printImported():\\r\\n ll = sorted([mod for mod in sys.modules if mod.find('pubsub') >= 0])\\r\\n\\r\\n py2and3.print_('\\\\n'.join(ll))\",\n \"def gitIgnoreContent( self, pars, directory ):\\n\\n name = pars['name']\\n\\n return f\\\"\\\"\\\"\\\\\\n{name}-*.pkg*\\nsrc/\\npkg/\\n\\\"\\\"\\\"\",\n \"def cleanup_import(package_name):\\n\\n for k in list(sys.modules):\\n if not isinstance(k, str):\\n # Some things will actually do this =_=\\n continue\\n elif k.startswith('astropy_helpers.tests'):\\n # Don't delete imported test modules or else the tests will break,\\n # badly\\n continue\\n if k == package_name or k.startswith(package_name + '.'):\\n del sys.modules[k]\",\n \"def report_unused_cycle_suppressions(self, reporter):\\n for module in self.get_modules():\\n for dep in module.get_dependencies():\\n if not dep.suppression_used:\\n reporter.cyclic_issue(\\\"unused cycle suppression: {0} -> {1}\\\".format(module.get_name()[7:], dep.get_other_module().get_name()[7:]))\",\n \"def ignore_all(self):\\n # type: () -> bool\\n return False\",\n \"def print_all_separation_algorithms():\\n from ..separation import all_separation_algorithms\\n print('\\\\n'.join([a.__name__ for a in all_separation_algorithms]))\",\n \"def ignored(*exceptions):\\n import logging\\n import pprint\\n try:\\n yield\\n except exceptions:\\n logging.warning(pprint.pformat(exceptions[0]))\\n pass\",\n \"def have_package_lists():\\n return 'Filename:' in execute('apt-cache', 'show', 'python', check=False, capture=True)\",\n \"def ignore_from_repo(self, directory, ignore):\\n for filename in os.listdir(directory):\\n if not filename.endswith('.rpm'):\\n continue\\n _, basename = filename.split('-', 1)\\n ignore.add(basename[:-4])\",\n \"def packages(self):\\n return []\",\n \"def no_additional_complaints() -> None:\\n logging.getLogger(\\\"asyncio\\\").setLevel(\\\"CRITICAL\\\")\\n warnings.simplefilter(\\\"ignore\\\")\",\n \"def clearWarnings():\\n for name, mod in list(sys.modules.items()):\\n try:\\n reg = getattr(mod, \\\"__warningregistry__\\\", None)\\n except ImportError:\\n continue\\n if reg:\\n reg.clear()\",\n \"def strip_blocks(self):\\n print_content = False\\n if self.exclude_blocks and len(self.exclude_blocks) > 0:\\n for package_name, package in self.packages.items():\\n for c, fd in package.components.iteritems():\\n for block in self.exclude_blocks:\\n JS_BLOCKS = re.compile(r'/[/*]\\\\s*<' + block + '>.+?<\\\\/' + block + '>(?:\\\\s*\\\\*/)?(?s)', re.MULTILINE)\\n fd.content = JS_BLOCKS.sub('/* compat block ' + block + ' removed */', fd.content)\\n print_content = True\\n if print_content:\\n print fd.content\",\n \"def show_packagelist(user, repo, packages, distro=False, version=False,\\n name=False, match=False, pkgtype=False):\\n\\n print('Currently {}/{} contains these matching packages:'.format(\\n user, repo))\\n\\n numpkgs = 0\\n for package in packages:\\n if (distro and not package['distro_version'] == distro) or \\\\\\n (version and not package['version'] == version) or \\\\\\n (name and not package['name'] == name) or \\\\\\n (pkgtype and not package['type'] == pkgtype) or \\\\\\n (match and match not in package['filename']):\\n continue\\n\\n print(fmt_pkg(user, repo, package))\\n numpkgs += 1\\n\\n print(\\\"Repo contains {} matching packages.\\\".format(numpkgs))\",\n \"def suppressMessages():\\n dislin.unit(0)\",\n \"def list_providers_packages():\\n providers = get_all_providers()\\n # if provider needs to be not considered in release add it here\\n # this is useful for cases where provider is WIP for a long period thus we don't want to release it yet.\\n providers_to_remove_from_release = []\\n for provider in providers:\\n if provider in providers_to_remove_from_release:\\n continue\\n console.print(provider)\",\n \"def _print_invalids(invalids, verbose):\\n if not invalids:\\n print(\\\"## No Rez package was set as invalid.\\\")\\n print(\\\"Nothing is invalid. Which is a good thing!\\\")\\n\\n return\\n\\n print(\\\"## Some packages were marked as invalid. Here's why:\\\")\\n\\n template = \\\"{package.name}: {message}\\\"\\n\\n if verbose:\\n template = \\\"{package.name}: {path} {message}: {full}\\\"\\n\\n for message in sorted(\\n (\\n template.format(\\n package=error.get_package(),\\n path=error.get_path(),\\n message=str(error),\\n full=error.get_full_message(),\\n )\\n for error in invalids\\n )\\n ):\\n print(message)\",\n \"def stripPackage(self, *args):\\n return _libsbml.ASTBasePlugin_stripPackage(self, *args)\",\n \"def missing_ltihooks(finder, caller):\\n caller.IgnoreName(\\\"ltihooks\\\")\",\n \"def list_package(all: bool = False) -> List[List[str]]:\\n if not all:\\n pkgs_info = read_installation_records()\\n else:\\n pkgs_info = []\\n for pkg in pkg_resources.working_set:\\n pkgs_info.append([pkg.project_name, pkg.version])\\n\\n return pkgs_info\",\n \"def dump(self):\\n\\n\\t\\treturn [\\n\\t\\t\\tpkg.dump()\\n\\t\\t\\tfor pkg in self._packages.values()\\n\\t\\t]\",\n \"def getMissingPackages(self, language=None, all=False, packages=None, showInstalled=False):\\n if self._cache.broken_count > 0:\\n raise SoftwareIndexBroken\\n \\n self.langpack_locales = {}\\n self.pkg_translations = {}\\n self.pkg_writing = {}\\n filter_list = {}\\n blacklist = []\\n show = []\\n self.missing = set()\\n self.installed = set()\\n self.system_pkgcode = ''\\n \\n for l in open(self.BLACKLIST):\\n l = l.strip()\\n if not l.startswith('#'):\\n blacklist.append(l)\\n \\n for l in open(self.LANGCODE_TO_LOCALE):\\n try:\\n l = l.rstrip()\\n if ':' in l:\\n (pkgcode, locale) = l.split(':')\\n else:\\n pkgcode = l\\n locale = l\\n except ValueError:\\n continue\\n self.langpack_locales[locale] = pkgcode\\n \\n for l in open(self.PACKAGE_DEPENDS):\\n if l.startswith('#'):\\n continue\\n try:\\n l = l.rstrip()\\n # sort out comments\\n if l.find('#') >= 0:\\n continue\\n (c, lc, k, v) = l.split(':')\\n except ValueError:\\n continue\\n if (c == 'tr' and lc == ''):\\n filter_list[v] = k\\n elif (c == 'wa' and lc != ''):\\n if '|' in lc:\\n for l in lc.split('|'):\\n if not l in self.pkg_writing:\\n self.pkg_writing[l] = []\\n self.pkg_writing[l].append((\\\"%s\\\" % k, \\\"%s\\\" % v))\\n else:\\n if not lc in self.pkg_writing:\\n self.pkg_writing[lc] = []\\n self.pkg_writing[lc].append((\\\"%s\\\" % k, \\\"%s\\\" % v))\\n\\n # get list of all packages available on the system and filter them\\n for item in self._cache.keys():\\n if item in blacklist: \\n continue\\n for x in filter_list.keys():\\n if item.startswith(x) and not item.endswith('-base'):\\n # parse language code\\n langcode = item.replace(x, '')\\n #print \\\"%s\\\\t%s\\\" % (item, langcode)\\n if langcode == 'zh':\\n # special case: zh langpack split\\n for langcode in ['zh-hans', 'zh-hant']:\\n if not langcode in self.pkg_translations:\\n self.pkg_translations[langcode] = []\\n self.pkg_translations[langcode].append((\\\"%s\\\" % filter_list[x], \\\"%s\\\" % item))\\n elif langcode in self.langpack_locales.values():\\n # langcode == pkgcode\\n if not langcode in self.pkg_translations:\\n self.pkg_translations[langcode] = []\\n self.pkg_translations[langcode].append((\\\"%s\\\" % filter_list[x], \\\"%s\\\" % item))\\n #print self.pkg_translations[langcode]\\n else:\\n # need to scan for LL-CC and LL-VARIANT codes\\n for locale in self.langpack_locales.keys():\\n if '_' in locale or '@' in locale:\\n if '@' in locale:\\n (locale, variant) = locale.split('@')\\n else:\\n variant = ''\\n (lcode, ccode) = locale.split('_')\\n if langcode in [\\\"%s-%s\\\" % (lcode, ccode.lower()),\\n \\\"%s%s\\\" % (lcode, ccode.lower()),\\n \\\"%s-%s\\\" % (lcode, variant),\\n \\\"%s%s\\\" % (lcode, variant),\\n \\\"%s-latn\\\" % lcode,\\n \\\"%slatn\\\" % lcode,\\n \\\"%s-%s-%s\\\" % (lcode, ccode.lower(), variant),\\n \\\"%s%s%s\\\" % (lcode, ccode.lower(), variant)]:\\n # match found, get matching pkgcode\\n langcode = self.langpack_locales[locale]\\n if not langcode in self.pkg_translations:\\n self.pkg_translations[langcode] = []\\n self.pkg_translations[langcode].append((\\\"%s\\\" % filter_list[x], \\\"%s\\\" % item))\\n #print self.pkg_translations[langcode]\\n break\\n\\n if language:\\n pkgcode = ''\\n if language == 'zh-hans' or language == 'zh-hant':\\n self.system_pkgcode = language\\n elif language in self.langpack_locales:\\n self.system_pkgcode = self.langpack_locales[language]\\n else:\\n # pkgcode = ll\\n if '_' in language:\\n (self.system_pkgcode) = language.split('_')[0]\\n elif '@' in language:\\n (self.system_pkgcode) = language.split('@')[0]\\n else:\\n self.system_pkgcode = language\\n\\n if packages:\\n self.findPackages(self.system_pkgcode, packages)\\n else:\\n self.findPackages(self.system_pkgcode)\\n \\n elif all:\\n # try all available languages\\n pkgcodes = []\\n for item in self._cache.keys():\\n if item in blacklist:\\n continue\\n if item.startswith('language-pack-') and \\\\\\n not item.startswith('language-pack-gnome') and \\\\\\n not item.startswith('language-pack-kde') and \\\\\\n not item.endswith('-base'):\\n pkgcode = item.replace('language-pack-', '')\\n pkgcodes.append(pkgcode)\\n\\n for pkgcode in pkgcodes:\\n if packages:\\n self.findPackages(pkgcode, packages)\\n else:\\n self.findPackages(pkgcode)\\n\\n else:\\n # get a list of language-packs we have already installed or are going to install\\n # 1. system locale\\n system_langcode = self._localeinfo.getSystemDefaultLanguage()[0]\\n if system_langcode == None:\\n system_langcode = 'en_US'\\n if system_langcode in self.langpack_locales:\\n self.system_pkgcode = self.langpack_locales[system_langcode]\\n # 2. installed language-packs\\n pkgcodes = []\\n for item in self._cache.keys():\\n if item in blacklist: \\n continue\\n if item.startswith('language-pack-') and \\\\\\n not item.startswith('language-pack-gnome') and \\\\\\n not item.startswith('language-pack-kde') and \\\\\\n not item.endswith('-base') and \\\\\\n (self._cache[item].is_installed or \\\\\\n self._cache[item].marked_install):\\n pkgcode = item.replace('language-pack-', '')\\n pkgcodes.append(pkgcode)\\n if self.system_pkgcode and \\\\\\n not self.system_pkgcode in pkgcodes:\\n pkgcodes.append(self.system_pkgcode)\\n \\n for pkgcode in pkgcodes:\\n if packages:\\n self.findPackages(pkgcode, packages)\\n else:\\n self.findPackages(pkgcode)\\n \\n if showInstalled:\\n show = self.missing | self.installed\\n else:\\n show = self.missing\\n\\n return show\",\n \"def isDisabledIgnoredPackage(self, *args):\\n return _libsbml.SBMLDocument_isDisabledIgnoredPackage(self, *args)\",\n \"def isStripAllUnrecognizedPackages(self):\\n return _libsbml.SBMLStripPackageConverter_isStripAllUnrecognizedPackages(self)\",\n \"def filter_warnings():\\n warnings.simplefilter(\\\"ignore\\\", category=UserWarning)\\n warnings.simplefilter(\\\"ignore\\\", category=LightningDeprecationWarning)\",\n \"def _extract_r_remove_package_names(log):\\n start = \\\"remove.packages(c(\\\"\\n i_start = log.find(start) + len(start)\\n i_end = log.find(\\\")\\\", i_start)\\n package_names = [name.strip('\\\"') for name in log[i_start:i_end].split(\\\",\\\")]\\n return package_names\",\n \"def test_ignores(self, tmpdir):\\n from pytest_flake8 import Ignorer\\n ignores = [\\\"E203\\\", \\\"b/?.py E204 W205\\\", \\\"z.py ALL\\\", \\\"*.py E300\\\"]\\n ign = Ignorer(ignores)\\n assert ign(tmpdir.join(\\\"a/b/x.py\\\")) == \\\"E203 E204 W205 E300\\\".split()\\n assert ign(tmpdir.join(\\\"a/y.py\\\")) == \\\"E203 E300\\\".split()\\n assert ign(tmpdir.join(\\\"a/z.py\\\")) is None\",\n \"def stripPackage(self, *args):\\n return _libsbml.SBasePlugin_stripPackage(self, *args)\",\n \"def freeze_includes() -> List[str]:\\n import _pytest\\n\\n result = list(_iter_all_modules(_pytest))\\n return result\",\n \"def missing_tests(session):\\n print('The following samples do not have tests:')\\n for sample in set(ALL_SAMPLE_DIRECTORIES) - set(ALL_TESTED_SAMPLES):\\n print('* {}'.format(sample))\",\n \"def get_packages(package):\\n return [str(path.parent) for path in Path(package).glob(\\\"**/__init__.py\\\")]\",\n \"def _suppress_warnings():\\n import warnings\\n import sys\\n import os\\n if os.path.basename(sys.argv[0]) != \\\"trial\\\":\\n warnings.simplefilter(\\\"ignore\\\")\",\n \"def main():\\n\\n local_pkgs = set(os.listdir(GIT_FOLDER))\\n local_pkgs = set([it.replace('.git', '') for it in local_pkgs])\\n\\n pkgdb_info = pkgdb_pkg_branch()\\n\\n pkgdb_pkgs = set(pkgdb_info.keys())\\n\\n ## Commented out as we keep the git of retired packages while they won't\\n ## show up in the information retrieved from pkgdb.\\n\\n #if (local_pkgs - pkgdb_pkgs):\\n #print 'Some packages are present locally but not on pkgdb:'\\n #print ', '.join(sorted(local_pkgs - pkgdb_pkgs))\\n\\n if (pkgdb_pkgs - local_pkgs):\\n print 'Some packages are present in pkgdb but not locally:'\\n print ', '.join(sorted(pkgdb_pkgs - local_pkgs))\\n\\n tofix = set()\\n for pkg in sorted(pkgdb_info):\\n pkgdb_branches = pkgdb_info[pkg]\\n git_branches = get_git_branch(pkg)\\n diff = (pkgdb_branches - git_branches)\\n if diff:\\n print '%s missing: %s' % (pkg, ','.join(sorted(diff)))\\n tofix.add(pkg)\\n branch_package(pkg, diff)\\n\\n if tofix:\\n print 'Packages fixed (%s): %s' % (\\n len(tofix), ', '.join(sorted(tofix)))\",\n \"def log_unused(self, error=True):\\n have_unused = False\\n log = get_logger().error if error else get_logger().info\\n for name in self._all_names:\\n current_set = getattr(self, name, None)\\n if current_set:\\n log('Unused from %s: %s', name.upper(), current_set)\\n have_unused = True\\n return have_unused\",\n \"def log_imported_packages(self):\\n imported_packages_dict = self.get_imported_packages()\\n\\n res_str = \\\"\\\\n\\\".join(f\\\"{module}: {version_num}\\\" for module, version_num\\n in imported_packages_dict[\\\"results\\\"].items())\\n no_res_str = \\\"\\\\n\\\".join(f\\\"{module}: {version_num}\\\" for module, version_num\\n in imported_packages_dict[\\\"no_results\\\"].items())\\n errs_res_str = \\\"\\\\n\\\".join(f\\\"{module}: {version_num}\\\" for module, version_num\\n in imported_packages_dict[\\\"errors\\\"].items())\\n\\n msg = f\\\"Imported modules:\\\\n {res_str}\\\\n {no_res_str}\\\\n {errs_res_str}\\\"\\n logger.info(msg)\",\n \"def required_packages(cls) -> List[Text]:\\n return []\",\n \"def test_ignores_all(self, testdir):\\n testdir.makeini(\\\"\\\"\\\"\\n [pytest]\\n markers = flake8\\n flake8-ignore = E203\\n *.py E300\\n tests/*.py ALL E203 # something\\n \\\"\\\"\\\")\\n testdir.tmpdir.ensure(\\\"xy.py\\\")\\n testdir.tmpdir.ensure(\\\"tests/hello.py\\\")\\n result = testdir.runpytest(\\\"--flake8\\\", \\\"-s\\\")\\n result.assert_outcomes(passed=1)\\n result.stdout.fnmatch_lines([\\n \\\"*collected 1*\\\",\\n \\\"*xy.py .*\\\",\\n \\\"*1 passed*\\\",\\n ])\",\n \"def packages():\",\n \"def disableCLangLogger(self):\\n pass\",\n \"def test_print_version_repositories_SKIP(self):\\n self._uri({\\n '%d.%d/maintained/%d.%d-%d/%s/Packages.gz' % (MAJOR, MINOR, MAJOR, MINOR, 0, 'all'): DATA,\\n '%d.%d/maintained/%d.%d-%d/%s/Packages.gz' % (MAJOR, MINOR, MAJOR, MINOR, 0, ARCH): DATA,\\n })\\n tmp = self.u.print_version_repositories()\\n self.assertEqual(set((\\n 'deb file:///mock/%d.%d/maintained/ %d.%d-%d/%s/' % (MAJOR, MINOR, MAJOR, MINOR, 0, 'all'),\\n 'deb file:///mock/%d.%d/maintained/ %d.%d-%d/%s/' % (MAJOR, MINOR, MAJOR, MINOR, 0, ARCH),\\n )), set(tmp.splitlines()))\",\n \"def get_packages(package):\\n return [dirpath\\n for dirpath, dirnames, filenames in os.walk(package)\\n if os.path.exists(os.path.join(dirpath, '__init__.py'))]\",\n \"def get_packages(package):\\n return [dirpath\\n for dirpath, dirnames, filenames in os.walk(package)\\n if os.path.exists(os.path.join(dirpath, '__init__.py'))]\",\n \"def get_packages(package):\\n return [dirpath\\n for dirpath, dirnames, filenames in os.walk(package)\\n if os.path.exists(os.path.join(dirpath, '__init__.py'))]\",\n \"def silent():\\n GLOBAL['VERBOSE'] = False\",\n \"def _filter_installed_packages(self, packages):\\n filtered_packages = []\\n for package in packages:\\n name = package.name\\n for installed in self._top_installed_repository.find_packages(name):\\n if installed.key == package.key:\\n break\\n else:\\n filtered_packages.append(package)\\n return filtered_packages\",\n \"def list_packages(self):\\n\\n # First extract loaded module names from sys.modules\\n sys_modules = sys.modules.keys()\\n\\n packages = {}\\n\\n # First add moduels in sys.modules (built-ins,\\n # preloads and already loaded ones)\\n for name in sys_modules:\\n d = self.find_package(name)\\n if not d: continue\\n try:\\n pkginfo = packages[d['type']]\\n pkginfo[d['name']] = d['path']\\n except Exception, e:\\n packages[d['type']] = { d['name'] : d['path'] }\\n\\n #import site\\n # Loop through all directories in sys.path and check for modules\\n # Dont iterate through <prefix>/lib directory\\n libdir = os.path.join(sys.prefix, 'lib')\\n\\n walked = []\\n for top_level in self.paths:\\n if not os.path.isdir(top_level):\\n continue\\n\\n # Dont iterate through libdir\\n if os.path.abspath(top_level) == os.path.abspath(libdir):\\n continue\\n\\n walked.append(top_level)\\n for item in os.listdir(top_level):\\n\\n fullpath = os.path.join(top_level, item)\\n if fullpath in walked: continue\\n\\n walked.append(fullpath)\\n # Remove the extension\\n idx = item.find('.')\\n if idx != -1: item = item[:idx]\\n d = self.find_package(item)\\n if not d: continue\\n try:\\n pkginfo = packages[d['type']]\\n pkginfo[d['name']] = d['path']\\n except Exception, e:\\n packages[d['type']] = { d['name'] : d['path'] } \\n\\n for key,item in packages.items():\\n print\\n print self.pkgTypeInfo(key)\\n print\\n\\n # Print sorted\\n listofitems = item.keys()\\n listofitems.sort()\\n\\n for key2 in listofitems:\\n print key2,':',item[key2]\",\n \"def list_packages ( self, name_only=False ):\\n if name_only:\\n for name, subdir in self._subdirs.items():\\n if not subdir.empty():\\n yield name\\n else:\\n for name, subdir in self._subdirs.items():\\n if not subdir.empty():\\n yield self.name + os.sep + name\",\n \"def output_boilerplate(stream=sys.stdout, other_imports=None):\\n print(_module_docstring, file=stream)\\n print(file=stream)\\n print(f\\\"from hikaru.meta import {HikaruBase.__name__}, \\\"\\n f\\\"{HikaruDocumentBase.__name__}, {KubernetesException.__name__}, \\\"\\n f\\\"{WatcherDescriptor.__name__}\\\",\\n file=stream)\\n print(\\\"from hikaru.generate import get_clean_dict\\\", file=stream)\\n print(\\\"from hikaru.utils import Response\\\", file=stream)\\n print(\\\"from typing import Dict, List, Optional, Any\\\", file=stream)\\n print(\\\"from dataclasses import dataclass, field, InitVar\\\", file=stream)\\n print(\\\"from kubernetes.client import CoreV1Api\\\", file=stream)\\n if other_imports is not None:\\n for line in other_imports:\\n print(line, file=stream)\\n print(file=stream)\",\n \"def get_packages():\\n\\n packages = find_packages()\\n packages = ['{}.{}'.format('uniq', package) for package in packages]\\n packages.append('uniq')\\n return packages\",\n \"def disable_default_logging():\\n for module in _verbose_modules:\\n _logging.getLogger(__name__+'.'+module).removeHandler(_default_log_handler)\",\n \"def report(*packages):\\n accepted_commands = ['python','conda']\\n for package in packages:\\n loc = \\\"not installed in this environment\\\"\\n ver = \\\"unknown\\\"\\n\\n try:\\n module = importlib.import_module(package)\\n loc = os.path.dirname(module.__file__)\\n\\n try:\\n ver = str(module.__version__)\\n except Exception:\\n pass\\n \\n except (ImportError, ModuleNotFoundError):\\n if package in accepted_commands:\\n try:\\n # See if there is a command by that name and check its --version if so\\n try:\\n loc = subprocess.check_output(['command','-v', package]).decode().splitlines()[0].strip()\\n except:\\n # .exe in case powershell (otherwise wouldn't need it)\\n loc = subprocess.check_output(['where.exe', package]).decode().splitlines()[0].strip() \\n out = \\\"\\\"\\n try:\\n out = subprocess.check_output([package, '--version'], stderr=subprocess.STDOUT)\\n except subprocess.CalledProcessError as e:\\n out = e.output\\n\\n # Assume first word in output with a period and digits is the version\\n for s in out.decode().split():\\n if '.' in s and str.isdigit(s[0]) and sum(str.isdigit(c) for c in s)>=2:\\n ver=s.strip()\\n break\\n except:\\n pass\\n elif package == 'system':\\n try:\\n ver = platform.platform(terse=True)\\n loc = \\\"OS: \\\" + platform.platform()\\n except Exception:\\n pass\\n else:\\n pass\\n \\n print(\\\"{0:30} # {1}\\\".format(package + \\\"=\\\" + ver,loc))\",\n \"def test_packages(self):\\n for pkg in self.expected_packages:\\n status, output = commands.getstatusoutput('pkg_info -qx %s' % pkg)\\n assert status == 0\",\n \"def SBMLExtensionRegistry_disablePackage(*args):\\n return _libsbml.SBMLExtensionRegistry_disablePackage(*args)\",\n \"def get_ignored_packages_names(ign_packages_names: Sequence[str], ign_groups_names: Sequence[str],\\n upstream_system: 'System', installed_system: 'System',\\n do_everything: bool = False) -> Set[str]:\\n handler = PacmanConfig(conf=\\\"/etc/pacman.conf\\\").initialize_alpm()\\n\\n # ignored packages names - may contain glob patterns\\n names_to_ignore = set(handler.ignorepkgs)\\n for ign_packages_name in ign_packages_names:\\n for name in ign_packages_name.split(\\\",\\\"):\\n names_to_ignore.add(name)\\n\\n # ignored groups names\\n ignored_groups_names = set(handler.ignoregrps)\\n for ign_groups_name in ign_groups_names:\\n for name in ign_groups_name.split(\\\",\\\"):\\n ignored_groups_names.add(name)\\n\\n # contains the concrete packages names to ignore\\n return_set = set()\\n\\n # check globbing\\n packages_names = [package_name for package_name in upstream_system.all_packages_dict]\\n for possible_glob in names_to_ignore:\\n return_set |= set(fnmatch.filter(packages_names, possible_glob))\\n # allow non upstream packages to be ignored, too - needed for correct replaces behavior\\n if do_everything:\\n packages_names = [package_name for package_name in installed_system.all_packages_dict]\\n for possible_glob in names_to_ignore:\\n return_set |= set(fnmatch.filter(packages_names, possible_glob))\\n\\n if not ignored_groups_names:\\n return return_set\\n\\n # fetch packages names of groups to ignore\\n for package_name in packages_names:\\n package = upstream_system.all_packages_dict[package_name]\\n # check groups\\n for package_group in package.groups:\\n if package_group in ignored_groups_names:\\n return_set.add(package_name)\\n\\n return return_set\",\n \"def show_keep(self, command=\\\"show-keep\\\"):\\n # execute pkgin\\n popen = Popen([self.pkgin_bin, \\\"-P\\\", command], stdout=PIPE, stderr=PIPE)\\n # retrieve output streams\\n (stdoutdata, stderrdata) = popen.communicate()\\n # if pkgin error\\n if(stderrdata):\\n # remove the line feed\\n error = stderrdata[0:-1]\\n raise PykginError(error)\\n # retrieve output\\n output = stdoutdata\\n # create a list which contain each packages\\n output_whole_list = output.split('\\\\n')\\n # remove last element (due to the last \\\\n)\\n output_whole_list.pop()\\n # create a new list in which package informations are separate\\n output_list = []\\n for pkg in output_whole_list:\\n current = pkg.split(' ', 1)\\n output_list.append(self.__extract_package_version(current[0]))\\n\\n return output_list\",\n \"def print_all():\\n for i in flags:\\n print(i)\",\n \"def go_quiet():\\n my_logger = logging.getLogger(__name__)\\n my_logger.setLevel(LEVELS['WARNING'])\",\n \"def get_hidden_imports(imports):\\n\\n hidden_imports = []\\n for i in imports:\\n hidden_imports.append('--hidden-import=%s' % i)\\n return hidden_imports\",\n \"def show_everything():\\n \\n #print(\\\"WARNING: This may take awhile. . .\\\\n\\\")\\n # Need to find all hostgroups, and make sure there are no deuplicate machines in this calculation.\\n print(\\\"This feature is still under construction. Check back soon!\\\")\\n sys.exit(0)\",\n \"def scrub_from_sys_modules():\\n for k, m in sys.modules.items():\\n if k in sys_modules_whitelist:\\n continue\\n\\n if hasattr(m, '__file__') and m.__file__ is not None:\\n mp = pathlib.Path(m.__file__)\\n if pex_root in mp.parents:\\n yield k\",\n \"def troubleshoot():\\n libraries = (sys, pd, openpyxl, matplotlib, pip)\\n for i in libraries:\\n try:\\n print(str(i), 'version:', i.__version__)\\n except AttributeError:\\n pass\\n except ModuleNotFoundError:\\n print('You do not have', str(i), 'installed.')\\n print('You can do so via your interpreter or:')\\n print('py -m pip install', '-' + str(i))\\n print('in command prompt')\",\n \"def hide_messages():\\n\\n print(\\\"Keep uncertainty data?\\\")\\n print(\\\"NewDatabase(..., keep_uncertainty_data=True)\\\")\\n print(\\\"\\\")\\n print(\\\"Hide these messages?\\\")\\n print(\\\"NewDatabase(..., quiet=True)\\\")\",\n \"def get_packages(package):\\n return [\\n dirpath\\n for dirpath, dirnames, filenames in os.walk(package)\\n if os.path.exists(os.path.join(dirpath, '__init__.py'))\\n ]\",\n \"def is_ignored(self):\",\n \"def _remove_extra_packages(frozen_pkgs, ret, **kwargs):\\n pkgs = __salt__[\\\"pkg.list_pkgs\\\"](**kwargs)\\n extra_pkgs = set(pkgs) - set(frozen_pkgs)\\n for pkg in extra_pkgs:\\n try:\\n __salt__[\\\"pkg.remove\\\"](name=pkg, **kwargs)\\n ret[\\\"pkgs\\\"][\\\"remove\\\"].append(pkg)\\n log.info(\\\"Removed extra package %s\\\", pkg)\\n except Exception as e: # pylint: disable=broad-except\\n msg = \\\"Error removing %s package: %s\\\"\\n log.error(msg, pkg, e)\\n ret[\\\"comment\\\"].append(msg % (pkg, e))\",\n \"def list_cmd(repo):\\n click.echo('Packages and scripts installed through pipsi:')\\n for venv, scripts in repo.list_everything():\\n if not scripts:\\n continue\\n click.echo(' Package \\\"%s\\\":' % venv)\\n for script in scripts:\\n click.echo(' ' + script)\",\n \"def lint():\\n toolkit.lint(exclude=[\\\"__init__.py\\\"])\",\n \"def print_package_info(package):\\r\\n print(\\\"******************\\\")\\r\\n print(\\\"Product: %s\\\" % package[0]['description'])\\r\\n print(\\\"Price: %s$ monthly\\\" % package[0]['prices'][0]['recurringFee'])\\r\\n print(\\\"******************\\\")\\r\\n return\",\n \"def add_ignore_module(modules: List[Any]):\\n global BUILTIN_LIKELY_MODULES\\n for module in modules:\\n if module not in BUILTIN_LIKELY_MODULES:\\n BUILTIN_LIKELY_MODULES.append(module)\",\n \"def print_notices(cls, settings: Settings):\\n if settings.get(\\\"wallet.type\\\", \\\"in_memory\\\").lower() == \\\"indy\\\":\\n with Banner(border=\\\":\\\", length=80, file=sys.stderr) as banner:\\n banner.centered(\\\"⚠ DEPRECATION NOTICE: ⚠\\\")\\n banner.hr()\\n banner.print(\\n \\\"The Indy wallet type is deprecated, use Askar instead; see: \\\"\\n \\\"https://aca-py.org/main/deploying/IndySDKtoAskarMigration/\\\",\\n )\\n print()\",\n \"def package(self):\\n\\t\\tsys.stderr.write(\\\"Base class method called: package() This souldn't happen.\\\\n\\\")\",\n \"def disablePyLangLogger(self):\\n pass\",\n \"def log_installed_modules(self):\\n\\n # Get python modules installed locally\\n\\n installed_packages = pkg_resources.working_set\\n\\n python_str = f'python:{sys.version}\\\\n'\\n print_str = \\\"\\\\n\\\".join(f\\\"{package.key}: {package.version}\\\" for package in installed_packages)\\n msg = f\\\"Installed packages:\\\\n{python_str+print_str}\\\"\\n logger.info(msg)\",\n \"def find_packages( root ):\\n for path, directories, files in os.walk( root ):\\n if is_package( path ):\\n yield path.replace( '/','.' )\",\n \"def debug(self, key, rows):\\n for row in rows:\\n yield log('pkgdb: %r' % row.package.pkgdb)\\n yield log('rawhide: %r' % (row.package.rawhide,))\\n yield log('upstream: %r' % row.package.upstream)\",\n \"def __dir__():\\n import pkgutil\\n\\n names = [\\n name\\n for importer, name, ispkg in pkgutil.iter_modules(__path__)\\n if not ispkg and name != \\\"base\\\"\\n ]\\n return names + [\\\"custom\\\", \\\"noData\\\"]\",\n \"def _split_the_ignored_packages(packages, patterns):\\n ignored = set()\\n non_ignored = set()\\n\\n for package in packages:\\n for pattern in patterns:\\n if fnmatch.fnmatch(package.name, pattern):\\n ignored.add((package, pattern))\\n\\n break\\n else:\\n non_ignored.add(package)\\n\\n return ignored, non_ignored\",\n \"def list(self):\\n for dir in subdirs('plugins'):\\n print dir.replace('plugins/', '')\",\n \"def auto_omit():\\n\\tpass\",\n \"def show ( self, **show_kw ):\\n for package in self._subdirs.values():\\n package.show ( **show_kw )\",\n \"def list_package_ids(self):\\n raise NotImplementedError\",\n \"def ignores(self):\\n return self._ignores\",\n \"def missing_gdk(finder, caller):\\n caller.IgnoreName(\\\"gdk\\\")\",\n \"def getIgnoredPlugins(self):\\n return self.yaml.getIgnoredPlugins()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6896404","0.65300035","0.64506","0.6380679","0.6243997","0.6215631","0.6034081","0.60240585","0.58716226","0.5729593","0.57106125","0.5704774","0.56812304","0.5655815","0.565425","0.5575963","0.5534667","0.550217","0.5492941","0.54724574","0.547046","0.5437451","0.5379577","0.5352382","0.5352162","0.534097","0.5330411","0.5326467","0.5326147","0.5318716","0.5317619","0.5312216","0.5310384","0.53037375","0.5293695","0.5289106","0.52745456","0.5250639","0.5237693","0.5228378","0.52199775","0.52176464","0.5204989","0.51958","0.51852345","0.51789814","0.5174743","0.5168315","0.51384485","0.5136923","0.51290756","0.51235735","0.5117742","0.51134115","0.51080203","0.51060945","0.5104666","0.5104666","0.5104666","0.51015615","0.5098515","0.509037","0.508826","0.50835633","0.5082836","0.5073629","0.50716686","0.5069938","0.5057591","0.5055505","0.5045448","0.503905","0.50366193","0.50333","0.50313723","0.50265074","0.5025459","0.50197953","0.5010447","0.50046176","0.50042826","0.5001563","0.49910787","0.4990888","0.49888587","0.49886277","0.4985512","0.49777937","0.49714136","0.49574077","0.49561283","0.49550158","0.4953071","0.49457744","0.49450156","0.49435192","0.4941427","0.49295774","0.49242848","0.49170443"],"string":"[\n \"0.6896404\",\n \"0.65300035\",\n \"0.64506\",\n \"0.6380679\",\n \"0.6243997\",\n \"0.6215631\",\n \"0.6034081\",\n \"0.60240585\",\n \"0.58716226\",\n \"0.5729593\",\n \"0.57106125\",\n \"0.5704774\",\n \"0.56812304\",\n \"0.5655815\",\n \"0.565425\",\n \"0.5575963\",\n \"0.5534667\",\n \"0.550217\",\n \"0.5492941\",\n \"0.54724574\",\n \"0.547046\",\n \"0.5437451\",\n \"0.5379577\",\n \"0.5352382\",\n \"0.5352162\",\n \"0.534097\",\n \"0.5330411\",\n \"0.5326467\",\n \"0.5326147\",\n \"0.5318716\",\n \"0.5317619\",\n \"0.5312216\",\n \"0.5310384\",\n \"0.53037375\",\n \"0.5293695\",\n \"0.5289106\",\n \"0.52745456\",\n \"0.5250639\",\n \"0.5237693\",\n \"0.5228378\",\n \"0.52199775\",\n \"0.52176464\",\n \"0.5204989\",\n \"0.51958\",\n \"0.51852345\",\n \"0.51789814\",\n \"0.5174743\",\n \"0.5168315\",\n \"0.51384485\",\n \"0.5136923\",\n \"0.51290756\",\n \"0.51235735\",\n \"0.5117742\",\n \"0.51134115\",\n \"0.51080203\",\n \"0.51060945\",\n \"0.5104666\",\n \"0.5104666\",\n \"0.5104666\",\n \"0.51015615\",\n \"0.5098515\",\n \"0.509037\",\n \"0.508826\",\n \"0.50835633\",\n \"0.5082836\",\n \"0.5073629\",\n \"0.50716686\",\n \"0.5069938\",\n \"0.5057591\",\n \"0.5055505\",\n \"0.5045448\",\n \"0.503905\",\n \"0.50366193\",\n \"0.50333\",\n \"0.50313723\",\n \"0.50265074\",\n \"0.5025459\",\n \"0.50197953\",\n \"0.5010447\",\n \"0.50046176\",\n \"0.50042826\",\n \"0.5001563\",\n \"0.49910787\",\n \"0.4990888\",\n \"0.49888587\",\n \"0.49886277\",\n \"0.4985512\",\n \"0.49777937\",\n \"0.49714136\",\n \"0.49574077\",\n \"0.49561283\",\n \"0.49550158\",\n \"0.4953071\",\n \"0.49457744\",\n \"0.49450156\",\n \"0.49435192\",\n \"0.4941427\",\n \"0.49295774\",\n \"0.49242848\",\n \"0.49170443\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.83495414"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21997,"cells":{"query":{"kind":"string","value":"Print out the errors that were found."},"document":{"kind":"string","value":"def _print_invalids(invalids, verbose):\n if not invalids:\n print(\"## No Rez package was set as invalid.\")\n print(\"Nothing is invalid. Which is a good thing!\")\n\n return\n\n print(\"## Some packages were marked as invalid. Here's why:\")\n\n template = \"{package.name}: {message}\"\n\n if verbose:\n template = \"{package.name}: {path} {message}: {full}\"\n\n for message in sorted(\n (\n template.format(\n package=error.get_package(),\n path=error.get_path(),\n message=str(error),\n full=error.get_full_message(),\n )\n for error in invalids\n )\n ):\n print(message)"},"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 show_errors(self):\n\n if self.errors:\n print('Clean error in:')\n for file in self.errors:\n print(' %s' % file)","def showerrors():\n errorMessages = middleware.ixn.showErrorMessage(silentMode=True)\n if errorMessages:\n print(errorMessages)\n print()","def print_errors(errors):\n print() # Add newline after character-results.\n if errors:\n print(\"\\n({}) Error{}:\".format(len(errors),\n \"s\" if len(errors) != 1 else \"\"))\n for e in errors:\n print(\"[{}:{}] In {}: {}\".format(\n e.filename, e.lineno, e.case, e.data\n ))\n print()","def printError(queryResults):\n print (queryResults[1])\n # For loop created for the httpErrors array\n for results in queryResults[0]:\n print (\n results[0], \"-\",\n str(results[1]) + \"% errors\")","def check_errors():\n\n for error in errors:\n ERROR('%s' % str(error))\n\n if len(errors) != 0:\n sys.exit(1)","def print_errors(self,result,cause=False,detail=False):\n errors = result.get_errors()\n if errors:\n print ('=== ERRORS '+('='*59))\n for error in errors:\n print (error.id)\n if cause:\n print (' ',error.get_cause())\n if detail:\n for key in (k for k in error.keys() if k not in [Result.START_TIME,\n Result.END_TIME,\n Result.CAUSE]):\n print ('-' * 70)\n print ('%s:' % key)\n print (as_utf8(error[key]))","def printErrors(self, *args):\n return _libsbml.SBMLDocument_printErrors(self, *args)","def output_errors(self) -> List[str]:\n output = list()\n for error in sorted(self.errors):\n if len(error) == 2:\n line = f\"{error[0]} - Could not find {error[1]} in map names!\"\n else:\n line = f\"{error[0]} - {error[1]}: Could not find {error[2]} in map names!\"\n logger.error(line)\n output.append(line)\n return output","def print_errors():\n\n create_view_total_requests = (\n \"CREATE VIEW total_requests AS \" +\n \"SELECT date(time), count(status) as count \" +\n \"FROM log GROUP BY date;\")\n create_view_error_requests = (\n \"CREATE VIEW error_requests AS \" +\n \"SELECT date(time), count(status) as count \" +\n \"FROM log WHERE status LIKE '404%' GROUP BY date;\")\n calculate_error_percentage = (\n \"SELECT total_requests.date, ROUND(\" +\n \"(CAST(error_requests.count as decimal)/\" +\n \"total_requests.count*100.00),2) as percent \" +\n \"FROM total_requests, error_requests \" +\n \"WHERE total_requests.date=error_requests.date AND \" +\n \"(CAST(error_requests.count as decimal)/\" +\n \"total_requests.count*100.00)>1 ORDER BY percent DESC;\")\n\n print(\"\\nRunning Task: \" + print_errors.__doc__ + \"\\n\")\n\n conn, cur = connect()\n cur.execute(create_view_total_requests)\n cur.execute(create_view_error_requests)\n cur.execute(calculate_error_percentage)\n results = cur.fetchall()\n\n for result in results:\n print('\\t{0:%B %d, %Y} - {1}% errors'.format(result[0], result[1]))\n\n disconnect(conn, cur)","def printErrors(self, *args):\n return _libsbml.XMLErrorLog_printErrors(self, *args)","def printErrors(self):\n if self.dots:\n self.stream.writeln()\n\n # Skipped Test Report\n if not self.args.no_skip_report:\n for test, reason in self.skipped:\n self.stream.writeln(\n \"\\n{} {} - {}\".format(\n self.colors.blue(\"Skipped\"),\n self.colors.bold(test.dotted_name),\n reason,\n )\n )\n\n # Captured output for non-failing tests\n if not self.args.quiet_stdout:\n failing_tests = {x[0] for x in self.all_errors}\n for test in list(self.stdout_output) + list(self.stderr_errput):\n if test not in failing_tests:\n self.displayStdout(test)\n self.displayStderr(test)\n\n # Actual tracebacks and captured output for failing tests\n for test, color_func, outcome, err in self.all_errors:\n # Header Line\n self.stream.writeln(\n f\"\\n{color_func(outcome)} in {self.colors.bold(test.dotted_name)}\"\n )\n\n # Traceback\n if not self.args.no_tracebacks:\n relevant_frames = []\n for i, frame in enumerate(err.traceback_lines):\n # Python2 tracebacks containing unicode need some special handling\n # This doesn't always make it readable, but at least it doesn't\n # crash\n if sys.version_info[0] == 2: # pragma: no cover\n try:\n \"\".join([frame]) # intentionally trigger exceptions\n except UnicodeDecodeError:\n frame = frame.decode(\"utf-8\")\n debug(\n \"\\n\"\n f\"{'*' * 30}Frame {i}:{'*' * 30}\\n\" + self.colors.yellow(frame),\n level=3,\n )\n # Ignore useless frames\n if self.verbose < 4:\n if frame.strip() == \"Traceback (most recent call last):\":\n continue\n # Done with this frame, capture it.\n relevant_frames.append(frame)\n self.stream.write(\"\".join(relevant_frames))\n\n # Captured output for failing tests\n self.displayStdout(test)\n self.displayStderr(test)","def errors(conf, daemon):\n # persisted dict interface for long term memory\n errors = Shove('file://{0}'.format(conf.app.errors), protocol=2, flag='r')\n if any(errors):\n print(\"errors found\")\n for path, error in six.iteritems(errors):\n pp(error)\n errors.close()\n exit(1)\n # ⏏ exit the program with an error\n else:\n print(\"no errors found - OK\")\n print()\n errors.close()","def printerror():\n print(traceback.format_exc())","def do_get_error(self):\n if self._last_exception is None:\n print('no errors')\n else:\n traceback.print_exception(*self._last_exception)","def display_error_messages(error_list):\n print('\\n', \"----------------ERROR LIST------------------\")\n if len(error_list) > 0:\n print(\"The following files have been ignored:\")\n for f in error_list:\n print(\"-\", f[0], \": \", f[1]) # File name + error\n else:\n print(\"No errors were found\")","def report_errors(errors):\n if len(errors) > 0:\n for error in errors:\n logger.debug(error)\n sys.exit(0)","def display_results_for_errors(result):\n i = 0\n for r in result:\n print('\\t'+str(result[i][0])+' ---> '+str(result[i][1])+' %\\n')\n i = i + 1","def errors():\n return THE_LOGGER.errors","def select(self):\n for elem in self.errorLog:\n print elem","def select(self):\n for elem in self.errorLog:\n print elem","def check_errors(self):\n\n errors = []\n while True:\n err = self.values(\"SYST:ERR?\")\n if int(err[0]) != 0:\n errmsg = \"Agilent 5313xA: {0}: {1}\".format(err[0], err[1])\n log.error(errmsg + '\\n')\n errors.append(errmsg)\n else:\n break\n\n return errors","def display_errors(self):\r\n\r\n def format_name(field_name):\r\n \"\"\"Formats field names for error display\"\"\"\r\n if field_name == \"celebration_tier\":\r\n return \"{wLargesse{n\"\r\n return \"{w%s{n\" % field_name.capitalize()\r\n\r\n msg = \"Please correct the following errors:\\n\"\r\n msg += \"\\n\".join(\r\n \"%s: {r%s{n\" % (format_name(field), \", \".join(errs))\r\n for field, errs in self.errors.items()\r\n )\r\n return msg","def eprint(errmsg):\n print(errmsg, file=STDERR)","def print_err(self, *lst):\n self.print2file(self.stderr, False, True, *lst)","def check_errors(self) -> None:","def print_std_error(self):\n print(self.std_error)\n sys.exit()","def get_errors(cursor):\n while True:\n message = cursor.lpop(\"errors\")\n if message is None:\n print(\"There are no errors more\")\n return None\n print(message)","def print_error():\n print(\"Incorrect Selection, try again!\\n\")","def error(self, *lines):\n if self.__debug_level >= DEBUG_LEVELS['error']:\n self.print_lines(self.colored(('red', 'bold'), lines))","def processErrors(self):\n e = self.formatErrors()\n if not self.config.nologtostdout:\n if e:\n print e\n else:\n print \"No errors\"\n if self.config.logtomail:\n if e:\n m = xeputils.mail.LogMail(self.config, e)\n m.send()\n if self.config.logtofile:\n f = open(self.config.logtofile, 'a')\n f.write(\"\\n===================\\n\")\n f.write(datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\"))\n f.write(\"\\n===================\\n\")\n if e:\n f.write(e)\n else:\n f.write(\"No errors\")\n f.close()","def display(self):\n print self.careErrors\n\n\n return self.exec_()","def error(message):\n print(message, file=sys.stderr)","def degsOutput(err, globalNameSpace):\n lineNumber = err.lineNumber\n columnNumber = err.columnNumber\n err.msg = '\\n' + err.msg + '\\n'\n print(err.msg, file=sys.stderr)\n if not lineNumber == None:\n positionReference = [\"Error caused at line %(lineNumber)i\" % locals()]\n if not columnNumber == None:\n positionReference.append(\", column %(columnNumber)i\" % locals())\n positionReference.append(\":\\n\")\n positionReference.append(globalNameSpace['inputScript'].splitlines(True)[lineNumber-1])\n if not columnNumber == None:\n positionReference.append(\" \"*(columnNumber-1) + \"^~~ here.\")\n print(''.join(positionReference) + '\\n', file=sys.stderr)\n if err.element:\n print(\"In element: \" + err.element.userUnderstandableXPath(), file=sys.stderr)\n else:\n print(\"Unknown element. Please report this error to %s\" % globalNameSpace['bugReportAddress'], file=sys.stderr)","def collect_errors_and_warnings(self) -> str:\n # Complete error message\n message = \"----------------ERRORS----------------\\n\"\n if self.errors == \"\":\n message = \"YOUR FILE IS VALIDATED!\\n\"\n logger.info(message)\n else:\n for error in self.errors.split(\"\\n\"):\n if error != \"\":\n logger.error(error)\n message += self.errors\n if self.warnings != \"\":\n for warning in self.warnings.split(\"\\n\"):\n if warning != \"\":\n logger.warning(warning)\n message += \"-------------WARNINGS-------------\\n\" + self.warnings\n return message","def print_messages(self):\n if self.messages:\n self.messages.append(\"\")\n sys.stderr.write(os.linesep.join(self.messages))","def get_short_errors(self):\n if not self.was_successful():\n for traceback in self.data.traceback.split(\n CaseData.TB_SEPARATOR):\n\n traceback = traceback.strip(\" \\n\")\n bottom_line = traceback.rsplit(\"\\n\", 1)[-1].strip()\n yield \"{}: {}\".format(self.data.name, bottom_line)","def print_fails(self,result,cause=False,detail=False):\n fails = result.get_fails()\n if fails:\n print ('=== FAILS '+('='*60))\n for fail in fails:\n print (fail.id)\n if cause:\n print (' ',fail.get_cause())\n if detail:\n for key in ['ISQL_stripped_diff','Python_stripped_diff',\n 'ISQL_stderr_stripped_diff',\n 'Python_stderr_stripped_diff']:\n if fail.has_key(key):\n print ('-' * 70)\n print ('%s:' % key)\n print (as_utf8(fail[key]))\n print ()","def table_print_errors(errors, somconfs):\n print \"-SOM index \\t SOM conf \"\n for i, label in enumerate(somconfs):\n print str(i).center(10),\"\\t\",label\n\n table = np.zeros((len(somconfs)+1, len(somconfs)+1))\n \n for i in np.arange(1, table.shape[0]):\n table[i, 0] = table[0, i] = i-1\n for j in np.arange(i+1, table.shape[0]):\n err = \"%.3f\"%ttest_rel(errors[i-1, :], errors[j-1, :])[1]\n table[i,j] = err\n print 'T-test p-values'\n print_table(table.tolist())","def error(self, message):\n print message","def print_bq_insert_errors(rows, errors):\n logger.error(\"The following errors have been detected:\")\n stopped_rows = 0\n for item in errors:\n index = item[\"index\"]\n row_errors = item[\"errors\"]\n for error in row_errors:\n if error[\"reason\"] != \"stopped\":\n logger.error(\"Row number: %d, Row data: %s, Error: %s\", index,\n rows[index], error)\n else:\n stopped_rows += 1\n if stopped_rows:\n logger.error(\n \"Also, %d rows were stopped (not inserted) due to the errors \"\n \"above.\", stopped_rows)","def _find_errors_in_page(self, response):\n if response.status_code == 403:\n return \"Could not check for errors, as response was a 403 response\\\n forbidden. User asking for this url did not have permission.\"\n \n \n errors = re.search('<ul class=\"errorlist\">(.*)</ul>', \n response.content, \n re.IGNORECASE)\n\n if errors: \n #show a little around the actual error to scan for variables that\n # might have caused it\n span = errors.span()\n wide_start = max(span[0]-200,0)\n wide_end = min(span[1]+200,len(response.content)) \n wide_error = response.content[wide_start:wide_end]\n return wide_error\n \n return \"\"","def errors(self):\n return self.args[1]","def print_log_message(error_msg):\r\n for msg in error_msg:\r\n print(msg)","def error(message):\n print str(message)","def formatErrors(self):\n errorlist = []\n xepsWithErrors = sorted(\n set(self.getParseErrors() + self.getBuildErrors()),\n key=lambda x: str(x))\n if self.getErrors() or xepsWithErrors:\n if self.getErrors():\n errorlist.append(\"********** Read errors **********\")\n for error in self.getErrors():\n errorlist.append(error)\n for xep in xepsWithErrors:\n errorlist.append(\n \"********** Error report for {} **********\".format(str(xep)))\n if xep.parseErrors:\n errorlist.append(\"********** Parsing Errors **********\")\n errors = list(set(xep.parseErrors))\n for error in errors:\n errorlist.append(error)\n if xep.buildErrors:\n errorlist.append(\"********** Build Errors **********\")\n for error in xep.buildErrors:\n if len(error.splitlines()) > 4:\n error = ''.join(error.splitlines()[:4])\n errorlist.append(error)\n return '\\n'.join(errorlist)\n else:\n return None","def errprint(msg):\n\n print('!! *** ERROR: %s' % msg)","def print_error_message(message):\r\n return print('ERROR:',message)","def show_errors(self, view, output):\n errors = self.compiler_variant.errors_from_output(output)\n self.error_vis.generate(view, errors)\n self.error_vis.show_regions(view)","def display_error():\n clear_screen()\n line = '#' * 20\n print(f'{line}\\n# CONNECTION ERROR #\\n{line}')\n exit(1)","def _show_err(self, msg, lineno, lexpos):\n # get the entire string we just tried to parse\n data = self.lexerObj.lexer.lexdata\n s = data.split('\\n')\n\n col = _find_column(data, lexpos)\n line = s[lineno-1]\n\n leader = 3*' '\n print \"-\"*72\n print \"cvx4py error on line %s:\" % lineno\n print leader, \"\"\">> %s \"\"\" % line.strip()\n print leader, \" \" + (\" \"*(col-1)) + \"^\"\n print\n print \"ERROR:\", msg\n print \"-\"*72","def print_error_data(error_data):\n\n print('\\nDays when there were more than 1% errors in HTTP :\\n')\n for day in error_data:\n print(str(day[0]) + '\\t-\\t' + str(day[1]) + '% \\n')\n print('-------------------------------------------------------\\n')","def show_error(self):\n print('LSE Error : {}'.format(self._error))","def errors(self) -> List[Error]:","def _on_error(self, error):\n print(error + \" for \" + self.session_name)","def _display_error(message: str) -> None:\n print()\n print(message, end='\\n\\n')","def show_error(title, message, print_message=False):\n\n pass","def check_and_print_if_error(self): # pragma: no cover\n dupes, empties, not_detected = self._get_aberrations()\n if dupes:\n print 'duplicate entries for:'\n for dup, matches in dupes:\n print ' %s: %s' % (dup, [f.func_name for f in matches])\n if empties:\n print 'empty entries for:'\n for empty in empties:\n print ' ' + str(empty)\n if not_detected:\n print 'dimensions not detected:'\n for n_d in not_detected:\n print ' ' + str(n_d)\n return self.is_correct","def handle_error():\n print \"An error occurred. Trace:\\n\"\n traceback.print_exc()","def print_failed(self):\n # Construct the message dynamically based on the instance_type\n msg = colored(\"FAIL\", \"red\") + f\" | [ERROR] {self.message}\"\n if self.instance_type == \"FILE\":\n msg += f\" [{self.instance_type}] {self.instance_location}/{self.instance_name}\"\n\n elif self.instance_type == \"HOST\":\n msg += f\" [{self.instance_type}] {self.instance_hostname}\"\n\n msg += f\" [PROPERTY] {':'.join(str(item) for item in self.absolute_path)}\"\n\n # print the msg\n print(msg)","def log_error(err):\n print(err)","def get_error(self) -> List[str]:\n return []","def get_error(self) -> List[str]:\n return []","def print_errors(res, ctx):\n\n if _has_error_code(res):\n return res.get('msg', '')\n return None","def error(*args, **kwargs):\n print(*args, file=sys.stderr, **kwargs)","def display_form_errors(form):\n\n for fieldname, errors in form.errors.items():\n for error in errors:\n err_str = 'Error in field <' + fieldname + '>: ' + error\n flash(err_str, 'error')","def query_errors():\r\n conn, cur = connect()\r\n query3 = (\"select * from errors where error >1\")\r\n cur.execute(query3)\r\n res3 = cur.fetchall()\r\n conn.close()\r\n print(\"\\nDays with more than 1% of requests lead to errors:\\n\")\r\n for i in range(0, len(res3), 1):\r\n print(str(res3[i][0]) + \" --> \" + str(round(res3[i][1], 2))+\" %errors\")","def report(self):\r\n print(\"\".join(self.memory), self.error, self.steps)","def check_errors(self) -> None:\n # TODO check the manual for error codes & interpert them.\n return self.send(self.cmd.GET_GLOBALSTATUS_CURRENTERROR)","def _print_batch_exception(batch_exception):\n print(\"-------------------------------------------\")\n print(\"Exception encountered:\")\n if (\n batch_exception.error\n and batch_exception.error.message\n and batch_exception.error.message.value\n ):\n print(batch_exception.error.message.value)\n if batch_exception.error.values:\n print()\n for mesg in batch_exception.error.values:\n print(\"{}:\\t{}\".format(mesg.key, mesg.value))\n print(\"-------------------------------------------\")","def print_failures(failures):\n if failures:\n print(\"\\n({}) Failure{}:\".format(len(failures),\n \"s\" if len(failures) != 1 else \"\"))\n for f in failures:\n print(\"[{}:{}] In {}: {}\".format(\n f.filename, f.lineno, f.case, f.data),\n end='')\n print(\" (\\\"{}\\\")\".format(f.alt) if f.alt else \"\")\n print()","def err(msg):\n print(colored.red(\"[ERROR]: {0}\".format(msg)))","def print_error(message):\n from sys import stderr\n print(\"\\033[1;31;40m \" + message + \"\\033[0;37;40m\", file=stderr)","def error(self) -> list:\n return self.__err","def print_error_analysis(self, to_stdout = True):\n message = ''\n message += 'Error report for LGH\\n'\n message += '|{:5}|{:20}|{:15}|{:8}|{:8}|{:8}|{:8}|\\n'.format(\n 'Nr','Name','E_DFT','Err_LGH','per_ads','Err_noLI','per_ads')\n\n merr_LGH = 0.0\n sumerrLGH = 0.0\n imerr_LGH = 0\n\n merr_noLI = 0.0\n sumerrnoLI = 0.0\n imerr_noLI = 0\n\n mepa_LGH = 0.0\n sumepaLGH = 0.0\n imepa_LGH = 0\n\n mepa_noLI = 0.0\n sumepanoLI = 0.0\n imepa_noLI = 0\n\n tot_nads = 0\n\n for ic, config in enumerate(self.config_list):\n Err_LGH = self.energy(ic)-config.Eref\n Err_noLI = (self.energy(ic,np.zeros(len(self.free)))-config.Eref)\n nads = config.nvector.sum()\n message +='|{:5}|{:20}|{:15.03f}|{:8.03f}|{:8.03f}|{:8.03f}|{:8.03f}|\\n'.format(\n ic,\n config.name,\n config.Eref,\n Err_LGH,\n Err_LGH / nads,\n Err_noLI,\n Err_noLI / nads,\n )\n if abs(Err_LGH) > abs(merr_LGH):\n merr_LGH = Err_LGH\n imerr_LGH = ic\n if abs(Err_LGH/nads) > abs(mepa_LGH):\n mepa_LGH = Err_LGH / nads\n imepa_LGH = ic\n if abs(Err_noLI) > abs(merr_noLI):\n merr_noLI = Err_noLI\n imerr_noLI = ic\n if abs(Err_noLI/nads) > abs(mepa_noLI):\n mepa_noLI = Err_noLI / nads\n imepa_noLI = ic\n\n sumerrLGH += abs(Err_LGH)\n sumerrnoLI += abs(Err_noLI)\n tot_nads += nads\n\n\n\n message += 'Maximum LGH error : {:03f} (conf {})\\n'.format(merr_LGH,imerr_LGH)\n message += 'Maximum LGH err. per adsorbate: {:03f} (conf {})\\n'.format(mepa_LGH,imepa_LGH)\n message += 'Avg. LGH error : {:03f}\\n'.format(sumerrLGH / (ic+1))\n message += 'Avg. LGH err. per adsorbate: {:03f}\\n'.format(sumerrLGH / tot_nads)\n message += 'Maximum noLI error : {:03f} (conf {})\\n'.format(merr_noLI,imerr_noLI)\n message += 'Maximum noLI er. per adsorbate: {:03f} (conf {})\\n'.format(mepa_noLI,imepa_noLI)\n message += 'Avg. noLI error : {:03f}\\n'.format(sumerrnoLI / (ic+1))\n message += 'Avg. noLI err. per adsorbate: {:03f}\\n'.format(sumerrnoLI / tot_nads)\n\n if to_stdout:\n print(message)\n return message","def print_error_metrics(expected, actual, description=None):\n\n\timport statistics\n\n\tprint()\n\tif description:\n\t\tprint(\"Error report for %s:\" % description)\n\n\tresidual = [e-a for e,a in zip(expected,actual)]\n\tmean = statistics.mean(residual)\n\tstddev = statistics.pstdev(residual, mean)\n\n\tprint(\"error mean=%0.3fem stddev=%0.3fem\" %\n\t (.001*mean, .001*stddev))\n\n\tresidual = [abs(e-a)/e for e,a in zip(expected,actual) if e]\n\tmean = statistics.mean(residual)\n\tstddev = statistics.pstdev(residual, mean)\n\tprint(\"abs-error mean=%4.1f%% stddev=%4.1f%%\" %\n\t (100*mean, 100*stddev))\n\n\tprint()","def error_mess():\n print(\"Sorry, I didn't understand that.\")","def errors(self) -> str:\n return self.job_errors() + self.analysis_errors()","def analysis_errors(self) -> str:\n errors = []\n\n # Get any callback errors\n for cid, callback in self._analysis_callbacks.items():\n if callback.status == AnalysisStatus.ERROR:\n errors.append(f\"\\n[Analysis Callback ID: {cid}]: {callback.error_msg}\")\n\n return \"\".join(errors)","def print_unknown_error_occurred(cls, exception):\n print(f\"{cls.ERROR_PREFIX} {cls.UNKNOWN_ERROR_OCCURRED}\")\n print(exception)","def print_err(self, *args):\r\n strings = []\r\n for arg in args:\r\n strings.append(str(arg))\r\n self.stderr.write(\",\".join(strings))","def print_error(filename, error):\n with open(filename, 'r') as f:\n lines = f.readlines()\n for row in range(error.line - 5, error.line + 5):\n if row - 1 in range(len(lines)):\n line = lines[row - 1].strip()\n print('{:5}: {}'.format(row, line))\n if row == error.line:\n padding = ' '*(error.col + 6)\n print('{}^ {}'.format(padding, error))","def error(cls, message):\n print('[ERROR] {0}'.format(message))","def show_error(self):\n logging.error('=> ', self.test_script_source.line)\n total_len = 0\n i = 0\n if self.test_script_source.current_pos <= self.test_script_source.total_num_seg:\n if i < self.test_script_source.current_pos - 1:\n total_len = total_len + len(self.test_script_source.line_segments[i])\n i += 1\n else:\n total_len = len(self.test_script_source.line)\n\n if self.test_script_source.current_pos > 1:\n logging.error('=> ', (' ' * (total_len + 1)) + '^')\n else:\n logging.error('=> ', (' ' * total_len) + '^')","def print_results(self):\n pass","def errors(self):\n raise NotImplementedError","def error(self, *args, **kwargs):\n if len(args) == 3:\n print(f\"ERROR: {args[1]}\")\n else:\n print(f\"ERROR: {args[0]}\")","def finish(self):\n for msg, info in self.errors.iteritems():\n hosts = [ self.job_to_str_func(job) for job in info['jobs'] ]\n\n max_jobs_num = self.max_jobs_num\n if max_jobs_num < 0 or max_jobs_num > len(hosts):\n hosts_msg = ': %s' % ' '.join(hosts)\n elif max_jobs_num == 0:\n hosts_msg = ''\n else:\n hosts_msg = ': %s (and %s more)' % (' '.join(sorted(hosts)[:self.max_jobs_num]), \\\n len(hosts) - self.max_jobs_num)\n\n ex = info['exception']\n msg = '%s.%s: %s' % (ex.__class__.__module__, \\\n ex.__class__.__name__, \\\n str(ex).split('\\n')[0])\n print >> self.outfile, \"Exception '%s' in %s jobs%s.\" % (msg, len(hosts), hosts_msg)\n print >> self.outfile, exception_description(ex).strip()\n if info['trace'] != None:\n print >> self.outfile, 'Traceback:'\n print >> self.outfile, ''.join(info['trace'])\n\n print >> self.outfile","def log_error(e):\n\tprint(e)","def log_error(e):\n\tprint(e)","def _display_syntax_error(self, errorid):\n\n # For total error count\n self.syntax_errors_list.append(errorid)\n\n if errorid == \"start\":\n self.scanner.print_error(self.symbol, self.symbol)\n print(\"Expected START.\")\n elif errorid == self.scanner.END_ID:\n self.scanner.print_error(self.symbol, self.symbol)\n print(\"Expected END.\")\n elif errorid == self.scanner.DEVICES_ID:\n self.scanner.print_error(self.symbol, self.symbol)\n print(\"Expected DEVICES.\")\n elif errorid == self.scanner.CONNECTIONS_ID:\n self.scanner.print_error(self.symbol, self.symbol)\n print(\"Expected CONNECTIONS.\")\n elif errorid == self.scanner.MONITORS_ID:\n self.scanner.print_error(self.symbol, self.symbol)\n print(\"Expected MONITORS.\")\n\n elif errorid == \"devicename\":\n self.scanner.print_error(self.symbol, self.symbol)\n print(\"Invalid device name.\")\n elif errorid == \"devicetype\":\n self.scanner.print_error(self.symbol, self.symbol)\n print(\"Invalid device type.\")\n elif errorid == \"parameter\":\n self.scanner.print_error(self.symbol, self.symbol)\n print(\"Invalid parameter type.\")\n elif errorid == \"semicoloncomma\":\n self.scanner.print_error(self.symbol, self.symbol)\n print(\"Expected a semicolon or a comma.\")\n elif errorid == \"number\":\n self.scanner.print_error(self.symbol, self.symbol)\n print(\"Invalid input number.\")\n elif errorid == \"doutput\":\n self.scanner.print_error(self.symbol, self.symbol)\n print(\"Only DTypes can specify an output. \\\n Either an invalid DType output or should not have an output.\")\n elif errorid == \"arrowperiod\":\n self.scanner.print_error(self.symbol, self.symbol)\n print(\"Expected either an arrow or a DType output\")\n\n elif errorid == \"semicolon\":\n self.scanner.print_error(self.symbol, self.symbol)\n print(\"Expected a semicolon.\")\n elif errorid == \"equal\":\n self.scanner.print_error(self.symbol, self.symbol)\n print(\"Expected an equal sign.\")\n elif errorid == \"comma\":\n self.scanner.print_error(self.symbol, self.symbol)\n print(\"Expected a comma.\")\n elif errorid == \"period\":\n self.scanner.print_error(self.symbol, self.symbol)\n print(\"Expected a period.\")\n elif errorid == \"arrow\":\n self.scanner.print_error(self.symbol, self.symbol)\n print(\"Expected an arrow ->.\")\n elif errorid == \"input\":\n self.scanner.print_error(self.symbol, self.symbol)\n print(\"Inputs must either start with I or be \\\n DATA, CLK, SET, CLEAR.\")\n\n return None","def error(*args, **kwargs): # pragma: nocover\n kwargs['file'] = sys.stderr\n print(\"\\n\\tERROR:\", *args, **kwargs)\n if args and args[0].startswith(\"[Errno 2] No such file or directory\"):\n print(\"\\t(Did you forget to include an __init__.py?)\")\n sys.exit(1)","def print_diagnostics(self, logfile, message):\n\n color_stdout(message, schema='error')\n print_tail_n(logfile, 10)","def get_errors(self):\n errors = []\n\n if not self.title:\n msg = 'Title not found: {0}'.format(self.number)\n print(msg)\n errors.append(msg)\n\n if not self.ref:\n msg = 'Ref not found: {0}'.format(self.number)\n print(msg)\n errors.append(msg)\n\n chapter_index = int(self.number) - 1\n\n # get the expected number of frames for this chapter\n expected_frame_count = chapters_and_frames.frame_counts[chapter_index]\n\n for x in range(1, expected_frame_count + 1):\n\n # frame id is formatted like '01-01'\n frame_id = '{0}-{1}'.format(self.number.zfill(2), str(x).zfill(2))\n\n # get the next frame\n frame = next((f for f in self.frames if f['id'] == frame_id), None) # type: dict\n if not frame:\n msg = 'Frame not found: {0}'.format(frame_id)\n print(msg)\n errors.append(msg)\n else:\n # check the frame img and values\n if 'img' not in frame or not frame['img']:\n msg = 'Attribute \"img\" is missing for frame {0}'.format(frame_id)\n print(msg)\n errors.append(msg)\n\n if 'text' not in frame or not frame['text']:\n msg = 'Attribute \"text\" is missing for frame {0}'.format(frame_id)\n print(msg)\n errors.append(msg)\n\n return errors","def error(context, *infos):\n messages = [\"An error occurred when when \" + context + \":\"]\n messages.extend(infos)\n print(\"\\n\\t\".join(map(str, messages)))\n return 1","def errprint(*args):\n sys.stderr.write(' '.join(map(str,args)) + '\\n')","def error(message):\n if DEBUG:\n with print_lock:\n print((Colours.FAIL + 'ERROR: ' + Colours.END_COLOUR + message).strip())","def test_display_failed():\n cmd_list = [NETMIKO_GREP] + ['interface', 'all']\n (output, std_err) = subprocess_handler(cmd_list)\n assert \"Failed devices\" in output\n failed_devices = output.split(\"Failed devices:\")[1]\n failed_devices = failed_devices.strip().split(\"\\n\")\n failed_devices = [x.strip() for x in failed_devices]\n assert len(failed_devices) == 2\n assert \"bad_device\" in failed_devices\n assert \"bad_port\" in failed_devices","def on_error(self, exception):\n traceback.print_exc()","def error(msg):\n print(msg, file=sys.stderr)\n sys.exit()","def printDaysWithErrors():\n cursor = connection.cursor()\n query = \"\"\"\n SELECT * FROM\n (SELECT daily_error_view.day,\n (daily_error_view.errors * 100.0)\n /\n (daily_traffic_view.views * 100.0)\n AS error_rate\n FROM daily_error_view JOIN daily_traffic_view\n ON daily_error_view.day = daily_traffic_view.day)\n AS daily_error_rate\n WHERE daily_error_rate.error_rate > 0.01;\n \"\"\"\n cursor.execute(query)\n results = cursor.fetchall()\n print(\"\\nDays with greater than 1 percent error rate:\")\n for result in results:\n print(\"{:%B %d, %Y} - {:.2%} errors\".format(result[0], result[1]))"],"string":"[\n \"def show_errors(self):\\n\\n if self.errors:\\n print('Clean error in:')\\n for file in self.errors:\\n print(' %s' % file)\",\n \"def showerrors():\\n errorMessages = middleware.ixn.showErrorMessage(silentMode=True)\\n if errorMessages:\\n print(errorMessages)\\n print()\",\n \"def print_errors(errors):\\n print() # Add newline after character-results.\\n if errors:\\n print(\\\"\\\\n({}) Error{}:\\\".format(len(errors),\\n \\\"s\\\" if len(errors) != 1 else \\\"\\\"))\\n for e in errors:\\n print(\\\"[{}:{}] In {}: {}\\\".format(\\n e.filename, e.lineno, e.case, e.data\\n ))\\n print()\",\n \"def printError(queryResults):\\n print (queryResults[1])\\n # For loop created for the httpErrors array\\n for results in queryResults[0]:\\n print (\\n results[0], \\\"-\\\",\\n str(results[1]) + \\\"% errors\\\")\",\n \"def check_errors():\\n\\n for error in errors:\\n ERROR('%s' % str(error))\\n\\n if len(errors) != 0:\\n sys.exit(1)\",\n \"def print_errors(self,result,cause=False,detail=False):\\n errors = result.get_errors()\\n if errors:\\n print ('=== ERRORS '+('='*59))\\n for error in errors:\\n print (error.id)\\n if cause:\\n print (' ',error.get_cause())\\n if detail:\\n for key in (k for k in error.keys() if k not in [Result.START_TIME,\\n Result.END_TIME,\\n Result.CAUSE]):\\n print ('-' * 70)\\n print ('%s:' % key)\\n print (as_utf8(error[key]))\",\n \"def printErrors(self, *args):\\n return _libsbml.SBMLDocument_printErrors(self, *args)\",\n \"def output_errors(self) -> List[str]:\\n output = list()\\n for error in sorted(self.errors):\\n if len(error) == 2:\\n line = f\\\"{error[0]} - Could not find {error[1]} in map names!\\\"\\n else:\\n line = f\\\"{error[0]} - {error[1]}: Could not find {error[2]} in map names!\\\"\\n logger.error(line)\\n output.append(line)\\n return output\",\n \"def print_errors():\\n\\n create_view_total_requests = (\\n \\\"CREATE VIEW total_requests AS \\\" +\\n \\\"SELECT date(time), count(status) as count \\\" +\\n \\\"FROM log GROUP BY date;\\\")\\n create_view_error_requests = (\\n \\\"CREATE VIEW error_requests AS \\\" +\\n \\\"SELECT date(time), count(status) as count \\\" +\\n \\\"FROM log WHERE status LIKE '404%' GROUP BY date;\\\")\\n calculate_error_percentage = (\\n \\\"SELECT total_requests.date, ROUND(\\\" +\\n \\\"(CAST(error_requests.count as decimal)/\\\" +\\n \\\"total_requests.count*100.00),2) as percent \\\" +\\n \\\"FROM total_requests, error_requests \\\" +\\n \\\"WHERE total_requests.date=error_requests.date AND \\\" +\\n \\\"(CAST(error_requests.count as decimal)/\\\" +\\n \\\"total_requests.count*100.00)>1 ORDER BY percent DESC;\\\")\\n\\n print(\\\"\\\\nRunning Task: \\\" + print_errors.__doc__ + \\\"\\\\n\\\")\\n\\n conn, cur = connect()\\n cur.execute(create_view_total_requests)\\n cur.execute(create_view_error_requests)\\n cur.execute(calculate_error_percentage)\\n results = cur.fetchall()\\n\\n for result in results:\\n print('\\\\t{0:%B %d, %Y} - {1}% errors'.format(result[0], result[1]))\\n\\n disconnect(conn, cur)\",\n \"def printErrors(self, *args):\\n return _libsbml.XMLErrorLog_printErrors(self, *args)\",\n \"def printErrors(self):\\n if self.dots:\\n self.stream.writeln()\\n\\n # Skipped Test Report\\n if not self.args.no_skip_report:\\n for test, reason in self.skipped:\\n self.stream.writeln(\\n \\\"\\\\n{} {} - {}\\\".format(\\n self.colors.blue(\\\"Skipped\\\"),\\n self.colors.bold(test.dotted_name),\\n reason,\\n )\\n )\\n\\n # Captured output for non-failing tests\\n if not self.args.quiet_stdout:\\n failing_tests = {x[0] for x in self.all_errors}\\n for test in list(self.stdout_output) + list(self.stderr_errput):\\n if test not in failing_tests:\\n self.displayStdout(test)\\n self.displayStderr(test)\\n\\n # Actual tracebacks and captured output for failing tests\\n for test, color_func, outcome, err in self.all_errors:\\n # Header Line\\n self.stream.writeln(\\n f\\\"\\\\n{color_func(outcome)} in {self.colors.bold(test.dotted_name)}\\\"\\n )\\n\\n # Traceback\\n if not self.args.no_tracebacks:\\n relevant_frames = []\\n for i, frame in enumerate(err.traceback_lines):\\n # Python2 tracebacks containing unicode need some special handling\\n # This doesn't always make it readable, but at least it doesn't\\n # crash\\n if sys.version_info[0] == 2: # pragma: no cover\\n try:\\n \\\"\\\".join([frame]) # intentionally trigger exceptions\\n except UnicodeDecodeError:\\n frame = frame.decode(\\\"utf-8\\\")\\n debug(\\n \\\"\\\\n\\\"\\n f\\\"{'*' * 30}Frame {i}:{'*' * 30}\\\\n\\\" + self.colors.yellow(frame),\\n level=3,\\n )\\n # Ignore useless frames\\n if self.verbose < 4:\\n if frame.strip() == \\\"Traceback (most recent call last):\\\":\\n continue\\n # Done with this frame, capture it.\\n relevant_frames.append(frame)\\n self.stream.write(\\\"\\\".join(relevant_frames))\\n\\n # Captured output for failing tests\\n self.displayStdout(test)\\n self.displayStderr(test)\",\n \"def errors(conf, daemon):\\n # persisted dict interface for long term memory\\n errors = Shove('file://{0}'.format(conf.app.errors), protocol=2, flag='r')\\n if any(errors):\\n print(\\\"errors found\\\")\\n for path, error in six.iteritems(errors):\\n pp(error)\\n errors.close()\\n exit(1)\\n # ⏏ exit the program with an error\\n else:\\n print(\\\"no errors found - OK\\\")\\n print()\\n errors.close()\",\n \"def printerror():\\n print(traceback.format_exc())\",\n \"def do_get_error(self):\\n if self._last_exception is None:\\n print('no errors')\\n else:\\n traceback.print_exception(*self._last_exception)\",\n \"def display_error_messages(error_list):\\n print('\\\\n', \\\"----------------ERROR LIST------------------\\\")\\n if len(error_list) > 0:\\n print(\\\"The following files have been ignored:\\\")\\n for f in error_list:\\n print(\\\"-\\\", f[0], \\\": \\\", f[1]) # File name + error\\n else:\\n print(\\\"No errors were found\\\")\",\n \"def report_errors(errors):\\n if len(errors) > 0:\\n for error in errors:\\n logger.debug(error)\\n sys.exit(0)\",\n \"def display_results_for_errors(result):\\n i = 0\\n for r in result:\\n print('\\\\t'+str(result[i][0])+' ---> '+str(result[i][1])+' %\\\\n')\\n i = i + 1\",\n \"def errors():\\n return THE_LOGGER.errors\",\n \"def select(self):\\n for elem in self.errorLog:\\n print elem\",\n \"def select(self):\\n for elem in self.errorLog:\\n print elem\",\n \"def check_errors(self):\\n\\n errors = []\\n while True:\\n err = self.values(\\\"SYST:ERR?\\\")\\n if int(err[0]) != 0:\\n errmsg = \\\"Agilent 5313xA: {0}: {1}\\\".format(err[0], err[1])\\n log.error(errmsg + '\\\\n')\\n errors.append(errmsg)\\n else:\\n break\\n\\n return errors\",\n \"def display_errors(self):\\r\\n\\r\\n def format_name(field_name):\\r\\n \\\"\\\"\\\"Formats field names for error display\\\"\\\"\\\"\\r\\n if field_name == \\\"celebration_tier\\\":\\r\\n return \\\"{wLargesse{n\\\"\\r\\n return \\\"{w%s{n\\\" % field_name.capitalize()\\r\\n\\r\\n msg = \\\"Please correct the following errors:\\\\n\\\"\\r\\n msg += \\\"\\\\n\\\".join(\\r\\n \\\"%s: {r%s{n\\\" % (format_name(field), \\\", \\\".join(errs))\\r\\n for field, errs in self.errors.items()\\r\\n )\\r\\n return msg\",\n \"def eprint(errmsg):\\n print(errmsg, file=STDERR)\",\n \"def print_err(self, *lst):\\n self.print2file(self.stderr, False, True, *lst)\",\n \"def check_errors(self) -> None:\",\n \"def print_std_error(self):\\n print(self.std_error)\\n sys.exit()\",\n \"def get_errors(cursor):\\n while True:\\n message = cursor.lpop(\\\"errors\\\")\\n if message is None:\\n print(\\\"There are no errors more\\\")\\n return None\\n print(message)\",\n \"def print_error():\\n print(\\\"Incorrect Selection, try again!\\\\n\\\")\",\n \"def error(self, *lines):\\n if self.__debug_level >= DEBUG_LEVELS['error']:\\n self.print_lines(self.colored(('red', 'bold'), lines))\",\n \"def processErrors(self):\\n e = self.formatErrors()\\n if not self.config.nologtostdout:\\n if e:\\n print e\\n else:\\n print \\\"No errors\\\"\\n if self.config.logtomail:\\n if e:\\n m = xeputils.mail.LogMail(self.config, e)\\n m.send()\\n if self.config.logtofile:\\n f = open(self.config.logtofile, 'a')\\n f.write(\\\"\\\\n===================\\\\n\\\")\\n f.write(datetime.datetime.now().strftime(\\\"%Y-%m-%d %H:%M:%S\\\"))\\n f.write(\\\"\\\\n===================\\\\n\\\")\\n if e:\\n f.write(e)\\n else:\\n f.write(\\\"No errors\\\")\\n f.close()\",\n \"def display(self):\\n print self.careErrors\\n\\n\\n return self.exec_()\",\n \"def error(message):\\n print(message, file=sys.stderr)\",\n \"def degsOutput(err, globalNameSpace):\\n lineNumber = err.lineNumber\\n columnNumber = err.columnNumber\\n err.msg = '\\\\n' + err.msg + '\\\\n'\\n print(err.msg, file=sys.stderr)\\n if not lineNumber == None:\\n positionReference = [\\\"Error caused at line %(lineNumber)i\\\" % locals()]\\n if not columnNumber == None:\\n positionReference.append(\\\", column %(columnNumber)i\\\" % locals())\\n positionReference.append(\\\":\\\\n\\\")\\n positionReference.append(globalNameSpace['inputScript'].splitlines(True)[lineNumber-1])\\n if not columnNumber == None:\\n positionReference.append(\\\" \\\"*(columnNumber-1) + \\\"^~~ here.\\\")\\n print(''.join(positionReference) + '\\\\n', file=sys.stderr)\\n if err.element:\\n print(\\\"In element: \\\" + err.element.userUnderstandableXPath(), file=sys.stderr)\\n else:\\n print(\\\"Unknown element. Please report this error to %s\\\" % globalNameSpace['bugReportAddress'], file=sys.stderr)\",\n \"def collect_errors_and_warnings(self) -> str:\\n # Complete error message\\n message = \\\"----------------ERRORS----------------\\\\n\\\"\\n if self.errors == \\\"\\\":\\n message = \\\"YOUR FILE IS VALIDATED!\\\\n\\\"\\n logger.info(message)\\n else:\\n for error in self.errors.split(\\\"\\\\n\\\"):\\n if error != \\\"\\\":\\n logger.error(error)\\n message += self.errors\\n if self.warnings != \\\"\\\":\\n for warning in self.warnings.split(\\\"\\\\n\\\"):\\n if warning != \\\"\\\":\\n logger.warning(warning)\\n message += \\\"-------------WARNINGS-------------\\\\n\\\" + self.warnings\\n return message\",\n \"def print_messages(self):\\n if self.messages:\\n self.messages.append(\\\"\\\")\\n sys.stderr.write(os.linesep.join(self.messages))\",\n \"def get_short_errors(self):\\n if not self.was_successful():\\n for traceback in self.data.traceback.split(\\n CaseData.TB_SEPARATOR):\\n\\n traceback = traceback.strip(\\\" \\\\n\\\")\\n bottom_line = traceback.rsplit(\\\"\\\\n\\\", 1)[-1].strip()\\n yield \\\"{}: {}\\\".format(self.data.name, bottom_line)\",\n \"def print_fails(self,result,cause=False,detail=False):\\n fails = result.get_fails()\\n if fails:\\n print ('=== FAILS '+('='*60))\\n for fail in fails:\\n print (fail.id)\\n if cause:\\n print (' ',fail.get_cause())\\n if detail:\\n for key in ['ISQL_stripped_diff','Python_stripped_diff',\\n 'ISQL_stderr_stripped_diff',\\n 'Python_stderr_stripped_diff']:\\n if fail.has_key(key):\\n print ('-' * 70)\\n print ('%s:' % key)\\n print (as_utf8(fail[key]))\\n print ()\",\n \"def table_print_errors(errors, somconfs):\\n print \\\"-SOM index \\\\t SOM conf \\\"\\n for i, label in enumerate(somconfs):\\n print str(i).center(10),\\\"\\\\t\\\",label\\n\\n table = np.zeros((len(somconfs)+1, len(somconfs)+1))\\n \\n for i in np.arange(1, table.shape[0]):\\n table[i, 0] = table[0, i] = i-1\\n for j in np.arange(i+1, table.shape[0]):\\n err = \\\"%.3f\\\"%ttest_rel(errors[i-1, :], errors[j-1, :])[1]\\n table[i,j] = err\\n print 'T-test p-values'\\n print_table(table.tolist())\",\n \"def error(self, message):\\n print message\",\n \"def print_bq_insert_errors(rows, errors):\\n logger.error(\\\"The following errors have been detected:\\\")\\n stopped_rows = 0\\n for item in errors:\\n index = item[\\\"index\\\"]\\n row_errors = item[\\\"errors\\\"]\\n for error in row_errors:\\n if error[\\\"reason\\\"] != \\\"stopped\\\":\\n logger.error(\\\"Row number: %d, Row data: %s, Error: %s\\\", index,\\n rows[index], error)\\n else:\\n stopped_rows += 1\\n if stopped_rows:\\n logger.error(\\n \\\"Also, %d rows were stopped (not inserted) due to the errors \\\"\\n \\\"above.\\\", stopped_rows)\",\n \"def _find_errors_in_page(self, response):\\n if response.status_code == 403:\\n return \\\"Could not check for errors, as response was a 403 response\\\\\\n forbidden. User asking for this url did not have permission.\\\"\\n \\n \\n errors = re.search('<ul class=\\\"errorlist\\\">(.*)</ul>', \\n response.content, \\n re.IGNORECASE)\\n\\n if errors: \\n #show a little around the actual error to scan for variables that\\n # might have caused it\\n span = errors.span()\\n wide_start = max(span[0]-200,0)\\n wide_end = min(span[1]+200,len(response.content)) \\n wide_error = response.content[wide_start:wide_end]\\n return wide_error\\n \\n return \\\"\\\"\",\n \"def errors(self):\\n return self.args[1]\",\n \"def print_log_message(error_msg):\\r\\n for msg in error_msg:\\r\\n print(msg)\",\n \"def error(message):\\n print str(message)\",\n \"def formatErrors(self):\\n errorlist = []\\n xepsWithErrors = sorted(\\n set(self.getParseErrors() + self.getBuildErrors()),\\n key=lambda x: str(x))\\n if self.getErrors() or xepsWithErrors:\\n if self.getErrors():\\n errorlist.append(\\\"********** Read errors **********\\\")\\n for error in self.getErrors():\\n errorlist.append(error)\\n for xep in xepsWithErrors:\\n errorlist.append(\\n \\\"********** Error report for {} **********\\\".format(str(xep)))\\n if xep.parseErrors:\\n errorlist.append(\\\"********** Parsing Errors **********\\\")\\n errors = list(set(xep.parseErrors))\\n for error in errors:\\n errorlist.append(error)\\n if xep.buildErrors:\\n errorlist.append(\\\"********** Build Errors **********\\\")\\n for error in xep.buildErrors:\\n if len(error.splitlines()) > 4:\\n error = ''.join(error.splitlines()[:4])\\n errorlist.append(error)\\n return '\\\\n'.join(errorlist)\\n else:\\n return None\",\n \"def errprint(msg):\\n\\n print('!! *** ERROR: %s' % msg)\",\n \"def print_error_message(message):\\r\\n return print('ERROR:',message)\",\n \"def show_errors(self, view, output):\\n errors = self.compiler_variant.errors_from_output(output)\\n self.error_vis.generate(view, errors)\\n self.error_vis.show_regions(view)\",\n \"def display_error():\\n clear_screen()\\n line = '#' * 20\\n print(f'{line}\\\\n# CONNECTION ERROR #\\\\n{line}')\\n exit(1)\",\n \"def _show_err(self, msg, lineno, lexpos):\\n # get the entire string we just tried to parse\\n data = self.lexerObj.lexer.lexdata\\n s = data.split('\\\\n')\\n\\n col = _find_column(data, lexpos)\\n line = s[lineno-1]\\n\\n leader = 3*' '\\n print \\\"-\\\"*72\\n print \\\"cvx4py error on line %s:\\\" % lineno\\n print leader, \\\"\\\"\\\">> %s \\\"\\\"\\\" % line.strip()\\n print leader, \\\" \\\" + (\\\" \\\"*(col-1)) + \\\"^\\\"\\n print\\n print \\\"ERROR:\\\", msg\\n print \\\"-\\\"*72\",\n \"def print_error_data(error_data):\\n\\n print('\\\\nDays when there were more than 1% errors in HTTP :\\\\n')\\n for day in error_data:\\n print(str(day[0]) + '\\\\t-\\\\t' + str(day[1]) + '% \\\\n')\\n print('-------------------------------------------------------\\\\n')\",\n \"def show_error(self):\\n print('LSE Error : {}'.format(self._error))\",\n \"def errors(self) -> List[Error]:\",\n \"def _on_error(self, error):\\n print(error + \\\" for \\\" + self.session_name)\",\n \"def _display_error(message: str) -> None:\\n print()\\n print(message, end='\\\\n\\\\n')\",\n \"def show_error(title, message, print_message=False):\\n\\n pass\",\n \"def check_and_print_if_error(self): # pragma: no cover\\n dupes, empties, not_detected = self._get_aberrations()\\n if dupes:\\n print 'duplicate entries for:'\\n for dup, matches in dupes:\\n print ' %s: %s' % (dup, [f.func_name for f in matches])\\n if empties:\\n print 'empty entries for:'\\n for empty in empties:\\n print ' ' + str(empty)\\n if not_detected:\\n print 'dimensions not detected:'\\n for n_d in not_detected:\\n print ' ' + str(n_d)\\n return self.is_correct\",\n \"def handle_error():\\n print \\\"An error occurred. Trace:\\\\n\\\"\\n traceback.print_exc()\",\n \"def print_failed(self):\\n # Construct the message dynamically based on the instance_type\\n msg = colored(\\\"FAIL\\\", \\\"red\\\") + f\\\" | [ERROR] {self.message}\\\"\\n if self.instance_type == \\\"FILE\\\":\\n msg += f\\\" [{self.instance_type}] {self.instance_location}/{self.instance_name}\\\"\\n\\n elif self.instance_type == \\\"HOST\\\":\\n msg += f\\\" [{self.instance_type}] {self.instance_hostname}\\\"\\n\\n msg += f\\\" [PROPERTY] {':'.join(str(item) for item in self.absolute_path)}\\\"\\n\\n # print the msg\\n print(msg)\",\n \"def log_error(err):\\n print(err)\",\n \"def get_error(self) -> List[str]:\\n return []\",\n \"def get_error(self) -> List[str]:\\n return []\",\n \"def print_errors(res, ctx):\\n\\n if _has_error_code(res):\\n return res.get('msg', '')\\n return None\",\n \"def error(*args, **kwargs):\\n print(*args, file=sys.stderr, **kwargs)\",\n \"def display_form_errors(form):\\n\\n for fieldname, errors in form.errors.items():\\n for error in errors:\\n err_str = 'Error in field <' + fieldname + '>: ' + error\\n flash(err_str, 'error')\",\n \"def query_errors():\\r\\n conn, cur = connect()\\r\\n query3 = (\\\"select * from errors where error >1\\\")\\r\\n cur.execute(query3)\\r\\n res3 = cur.fetchall()\\r\\n conn.close()\\r\\n print(\\\"\\\\nDays with more than 1% of requests lead to errors:\\\\n\\\")\\r\\n for i in range(0, len(res3), 1):\\r\\n print(str(res3[i][0]) + \\\" --> \\\" + str(round(res3[i][1], 2))+\\\" %errors\\\")\",\n \"def report(self):\\r\\n print(\\\"\\\".join(self.memory), self.error, self.steps)\",\n \"def check_errors(self) -> None:\\n # TODO check the manual for error codes & interpert them.\\n return self.send(self.cmd.GET_GLOBALSTATUS_CURRENTERROR)\",\n \"def _print_batch_exception(batch_exception):\\n print(\\\"-------------------------------------------\\\")\\n print(\\\"Exception encountered:\\\")\\n if (\\n batch_exception.error\\n and batch_exception.error.message\\n and batch_exception.error.message.value\\n ):\\n print(batch_exception.error.message.value)\\n if batch_exception.error.values:\\n print()\\n for mesg in batch_exception.error.values:\\n print(\\\"{}:\\\\t{}\\\".format(mesg.key, mesg.value))\\n print(\\\"-------------------------------------------\\\")\",\n \"def print_failures(failures):\\n if failures:\\n print(\\\"\\\\n({}) Failure{}:\\\".format(len(failures),\\n \\\"s\\\" if len(failures) != 1 else \\\"\\\"))\\n for f in failures:\\n print(\\\"[{}:{}] In {}: {}\\\".format(\\n f.filename, f.lineno, f.case, f.data),\\n end='')\\n print(\\\" (\\\\\\\"{}\\\\\\\")\\\".format(f.alt) if f.alt else \\\"\\\")\\n print()\",\n \"def err(msg):\\n print(colored.red(\\\"[ERROR]: {0}\\\".format(msg)))\",\n \"def print_error(message):\\n from sys import stderr\\n print(\\\"\\\\033[1;31;40m \\\" + message + \\\"\\\\033[0;37;40m\\\", file=stderr)\",\n \"def error(self) -> list:\\n return self.__err\",\n \"def print_error_analysis(self, to_stdout = True):\\n message = ''\\n message += 'Error report for LGH\\\\n'\\n message += '|{:5}|{:20}|{:15}|{:8}|{:8}|{:8}|{:8}|\\\\n'.format(\\n 'Nr','Name','E_DFT','Err_LGH','per_ads','Err_noLI','per_ads')\\n\\n merr_LGH = 0.0\\n sumerrLGH = 0.0\\n imerr_LGH = 0\\n\\n merr_noLI = 0.0\\n sumerrnoLI = 0.0\\n imerr_noLI = 0\\n\\n mepa_LGH = 0.0\\n sumepaLGH = 0.0\\n imepa_LGH = 0\\n\\n mepa_noLI = 0.0\\n sumepanoLI = 0.0\\n imepa_noLI = 0\\n\\n tot_nads = 0\\n\\n for ic, config in enumerate(self.config_list):\\n Err_LGH = self.energy(ic)-config.Eref\\n Err_noLI = (self.energy(ic,np.zeros(len(self.free)))-config.Eref)\\n nads = config.nvector.sum()\\n message +='|{:5}|{:20}|{:15.03f}|{:8.03f}|{:8.03f}|{:8.03f}|{:8.03f}|\\\\n'.format(\\n ic,\\n config.name,\\n config.Eref,\\n Err_LGH,\\n Err_LGH / nads,\\n Err_noLI,\\n Err_noLI / nads,\\n )\\n if abs(Err_LGH) > abs(merr_LGH):\\n merr_LGH = Err_LGH\\n imerr_LGH = ic\\n if abs(Err_LGH/nads) > abs(mepa_LGH):\\n mepa_LGH = Err_LGH / nads\\n imepa_LGH = ic\\n if abs(Err_noLI) > abs(merr_noLI):\\n merr_noLI = Err_noLI\\n imerr_noLI = ic\\n if abs(Err_noLI/nads) > abs(mepa_noLI):\\n mepa_noLI = Err_noLI / nads\\n imepa_noLI = ic\\n\\n sumerrLGH += abs(Err_LGH)\\n sumerrnoLI += abs(Err_noLI)\\n tot_nads += nads\\n\\n\\n\\n message += 'Maximum LGH error : {:03f} (conf {})\\\\n'.format(merr_LGH,imerr_LGH)\\n message += 'Maximum LGH err. per adsorbate: {:03f} (conf {})\\\\n'.format(mepa_LGH,imepa_LGH)\\n message += 'Avg. LGH error : {:03f}\\\\n'.format(sumerrLGH / (ic+1))\\n message += 'Avg. LGH err. per adsorbate: {:03f}\\\\n'.format(sumerrLGH / tot_nads)\\n message += 'Maximum noLI error : {:03f} (conf {})\\\\n'.format(merr_noLI,imerr_noLI)\\n message += 'Maximum noLI er. per adsorbate: {:03f} (conf {})\\\\n'.format(mepa_noLI,imepa_noLI)\\n message += 'Avg. noLI error : {:03f}\\\\n'.format(sumerrnoLI / (ic+1))\\n message += 'Avg. noLI err. per adsorbate: {:03f}\\\\n'.format(sumerrnoLI / tot_nads)\\n\\n if to_stdout:\\n print(message)\\n return message\",\n \"def print_error_metrics(expected, actual, description=None):\\n\\n\\timport statistics\\n\\n\\tprint()\\n\\tif description:\\n\\t\\tprint(\\\"Error report for %s:\\\" % description)\\n\\n\\tresidual = [e-a for e,a in zip(expected,actual)]\\n\\tmean = statistics.mean(residual)\\n\\tstddev = statistics.pstdev(residual, mean)\\n\\n\\tprint(\\\"error mean=%0.3fem stddev=%0.3fem\\\" %\\n\\t (.001*mean, .001*stddev))\\n\\n\\tresidual = [abs(e-a)/e for e,a in zip(expected,actual) if e]\\n\\tmean = statistics.mean(residual)\\n\\tstddev = statistics.pstdev(residual, mean)\\n\\tprint(\\\"abs-error mean=%4.1f%% stddev=%4.1f%%\\\" %\\n\\t (100*mean, 100*stddev))\\n\\n\\tprint()\",\n \"def error_mess():\\n print(\\\"Sorry, I didn't understand that.\\\")\",\n \"def errors(self) -> str:\\n return self.job_errors() + self.analysis_errors()\",\n \"def analysis_errors(self) -> str:\\n errors = []\\n\\n # Get any callback errors\\n for cid, callback in self._analysis_callbacks.items():\\n if callback.status == AnalysisStatus.ERROR:\\n errors.append(f\\\"\\\\n[Analysis Callback ID: {cid}]: {callback.error_msg}\\\")\\n\\n return \\\"\\\".join(errors)\",\n \"def print_unknown_error_occurred(cls, exception):\\n print(f\\\"{cls.ERROR_PREFIX} {cls.UNKNOWN_ERROR_OCCURRED}\\\")\\n print(exception)\",\n \"def print_err(self, *args):\\r\\n strings = []\\r\\n for arg in args:\\r\\n strings.append(str(arg))\\r\\n self.stderr.write(\\\",\\\".join(strings))\",\n \"def print_error(filename, error):\\n with open(filename, 'r') as f:\\n lines = f.readlines()\\n for row in range(error.line - 5, error.line + 5):\\n if row - 1 in range(len(lines)):\\n line = lines[row - 1].strip()\\n print('{:5}: {}'.format(row, line))\\n if row == error.line:\\n padding = ' '*(error.col + 6)\\n print('{}^ {}'.format(padding, error))\",\n \"def error(cls, message):\\n print('[ERROR] {0}'.format(message))\",\n \"def show_error(self):\\n logging.error('=> ', self.test_script_source.line)\\n total_len = 0\\n i = 0\\n if self.test_script_source.current_pos <= self.test_script_source.total_num_seg:\\n if i < self.test_script_source.current_pos - 1:\\n total_len = total_len + len(self.test_script_source.line_segments[i])\\n i += 1\\n else:\\n total_len = len(self.test_script_source.line)\\n\\n if self.test_script_source.current_pos > 1:\\n logging.error('=> ', (' ' * (total_len + 1)) + '^')\\n else:\\n logging.error('=> ', (' ' * total_len) + '^')\",\n \"def print_results(self):\\n pass\",\n \"def errors(self):\\n raise NotImplementedError\",\n \"def error(self, *args, **kwargs):\\n if len(args) == 3:\\n print(f\\\"ERROR: {args[1]}\\\")\\n else:\\n print(f\\\"ERROR: {args[0]}\\\")\",\n \"def finish(self):\\n for msg, info in self.errors.iteritems():\\n hosts = [ self.job_to_str_func(job) for job in info['jobs'] ]\\n\\n max_jobs_num = self.max_jobs_num\\n if max_jobs_num < 0 or max_jobs_num > len(hosts):\\n hosts_msg = ': %s' % ' '.join(hosts)\\n elif max_jobs_num == 0:\\n hosts_msg = ''\\n else:\\n hosts_msg = ': %s (and %s more)' % (' '.join(sorted(hosts)[:self.max_jobs_num]), \\\\\\n len(hosts) - self.max_jobs_num)\\n\\n ex = info['exception']\\n msg = '%s.%s: %s' % (ex.__class__.__module__, \\\\\\n ex.__class__.__name__, \\\\\\n str(ex).split('\\\\n')[0])\\n print >> self.outfile, \\\"Exception '%s' in %s jobs%s.\\\" % (msg, len(hosts), hosts_msg)\\n print >> self.outfile, exception_description(ex).strip()\\n if info['trace'] != None:\\n print >> self.outfile, 'Traceback:'\\n print >> self.outfile, ''.join(info['trace'])\\n\\n print >> self.outfile\",\n \"def log_error(e):\\n\\tprint(e)\",\n \"def log_error(e):\\n\\tprint(e)\",\n \"def _display_syntax_error(self, errorid):\\n\\n # For total error count\\n self.syntax_errors_list.append(errorid)\\n\\n if errorid == \\\"start\\\":\\n self.scanner.print_error(self.symbol, self.symbol)\\n print(\\\"Expected START.\\\")\\n elif errorid == self.scanner.END_ID:\\n self.scanner.print_error(self.symbol, self.symbol)\\n print(\\\"Expected END.\\\")\\n elif errorid == self.scanner.DEVICES_ID:\\n self.scanner.print_error(self.symbol, self.symbol)\\n print(\\\"Expected DEVICES.\\\")\\n elif errorid == self.scanner.CONNECTIONS_ID:\\n self.scanner.print_error(self.symbol, self.symbol)\\n print(\\\"Expected CONNECTIONS.\\\")\\n elif errorid == self.scanner.MONITORS_ID:\\n self.scanner.print_error(self.symbol, self.symbol)\\n print(\\\"Expected MONITORS.\\\")\\n\\n elif errorid == \\\"devicename\\\":\\n self.scanner.print_error(self.symbol, self.symbol)\\n print(\\\"Invalid device name.\\\")\\n elif errorid == \\\"devicetype\\\":\\n self.scanner.print_error(self.symbol, self.symbol)\\n print(\\\"Invalid device type.\\\")\\n elif errorid == \\\"parameter\\\":\\n self.scanner.print_error(self.symbol, self.symbol)\\n print(\\\"Invalid parameter type.\\\")\\n elif errorid == \\\"semicoloncomma\\\":\\n self.scanner.print_error(self.symbol, self.symbol)\\n print(\\\"Expected a semicolon or a comma.\\\")\\n elif errorid == \\\"number\\\":\\n self.scanner.print_error(self.symbol, self.symbol)\\n print(\\\"Invalid input number.\\\")\\n elif errorid == \\\"doutput\\\":\\n self.scanner.print_error(self.symbol, self.symbol)\\n print(\\\"Only DTypes can specify an output. \\\\\\n Either an invalid DType output or should not have an output.\\\")\\n elif errorid == \\\"arrowperiod\\\":\\n self.scanner.print_error(self.symbol, self.symbol)\\n print(\\\"Expected either an arrow or a DType output\\\")\\n\\n elif errorid == \\\"semicolon\\\":\\n self.scanner.print_error(self.symbol, self.symbol)\\n print(\\\"Expected a semicolon.\\\")\\n elif errorid == \\\"equal\\\":\\n self.scanner.print_error(self.symbol, self.symbol)\\n print(\\\"Expected an equal sign.\\\")\\n elif errorid == \\\"comma\\\":\\n self.scanner.print_error(self.symbol, self.symbol)\\n print(\\\"Expected a comma.\\\")\\n elif errorid == \\\"period\\\":\\n self.scanner.print_error(self.symbol, self.symbol)\\n print(\\\"Expected a period.\\\")\\n elif errorid == \\\"arrow\\\":\\n self.scanner.print_error(self.symbol, self.symbol)\\n print(\\\"Expected an arrow ->.\\\")\\n elif errorid == \\\"input\\\":\\n self.scanner.print_error(self.symbol, self.symbol)\\n print(\\\"Inputs must either start with I or be \\\\\\n DATA, CLK, SET, CLEAR.\\\")\\n\\n return None\",\n \"def error(*args, **kwargs): # pragma: nocover\\n kwargs['file'] = sys.stderr\\n print(\\\"\\\\n\\\\tERROR:\\\", *args, **kwargs)\\n if args and args[0].startswith(\\\"[Errno 2] No such file or directory\\\"):\\n print(\\\"\\\\t(Did you forget to include an __init__.py?)\\\")\\n sys.exit(1)\",\n \"def print_diagnostics(self, logfile, message):\\n\\n color_stdout(message, schema='error')\\n print_tail_n(logfile, 10)\",\n \"def get_errors(self):\\n errors = []\\n\\n if not self.title:\\n msg = 'Title not found: {0}'.format(self.number)\\n print(msg)\\n errors.append(msg)\\n\\n if not self.ref:\\n msg = 'Ref not found: {0}'.format(self.number)\\n print(msg)\\n errors.append(msg)\\n\\n chapter_index = int(self.number) - 1\\n\\n # get the expected number of frames for this chapter\\n expected_frame_count = chapters_and_frames.frame_counts[chapter_index]\\n\\n for x in range(1, expected_frame_count + 1):\\n\\n # frame id is formatted like '01-01'\\n frame_id = '{0}-{1}'.format(self.number.zfill(2), str(x).zfill(2))\\n\\n # get the next frame\\n frame = next((f for f in self.frames if f['id'] == frame_id), None) # type: dict\\n if not frame:\\n msg = 'Frame not found: {0}'.format(frame_id)\\n print(msg)\\n errors.append(msg)\\n else:\\n # check the frame img and values\\n if 'img' not in frame or not frame['img']:\\n msg = 'Attribute \\\"img\\\" is missing for frame {0}'.format(frame_id)\\n print(msg)\\n errors.append(msg)\\n\\n if 'text' not in frame or not frame['text']:\\n msg = 'Attribute \\\"text\\\" is missing for frame {0}'.format(frame_id)\\n print(msg)\\n errors.append(msg)\\n\\n return errors\",\n \"def error(context, *infos):\\n messages = [\\\"An error occurred when when \\\" + context + \\\":\\\"]\\n messages.extend(infos)\\n print(\\\"\\\\n\\\\t\\\".join(map(str, messages)))\\n return 1\",\n \"def errprint(*args):\\n sys.stderr.write(' '.join(map(str,args)) + '\\\\n')\",\n \"def error(message):\\n if DEBUG:\\n with print_lock:\\n print((Colours.FAIL + 'ERROR: ' + Colours.END_COLOUR + message).strip())\",\n \"def test_display_failed():\\n cmd_list = [NETMIKO_GREP] + ['interface', 'all']\\n (output, std_err) = subprocess_handler(cmd_list)\\n assert \\\"Failed devices\\\" in output\\n failed_devices = output.split(\\\"Failed devices:\\\")[1]\\n failed_devices = failed_devices.strip().split(\\\"\\\\n\\\")\\n failed_devices = [x.strip() for x in failed_devices]\\n assert len(failed_devices) == 2\\n assert \\\"bad_device\\\" in failed_devices\\n assert \\\"bad_port\\\" in failed_devices\",\n \"def on_error(self, exception):\\n traceback.print_exc()\",\n \"def error(msg):\\n print(msg, file=sys.stderr)\\n sys.exit()\",\n \"def printDaysWithErrors():\\n cursor = connection.cursor()\\n query = \\\"\\\"\\\"\\n SELECT * FROM\\n (SELECT daily_error_view.day,\\n (daily_error_view.errors * 100.0)\\n /\\n (daily_traffic_view.views * 100.0)\\n AS error_rate\\n FROM daily_error_view JOIN daily_traffic_view\\n ON daily_error_view.day = daily_traffic_view.day)\\n AS daily_error_rate\\n WHERE daily_error_rate.error_rate > 0.01;\\n \\\"\\\"\\\"\\n cursor.execute(query)\\n results = cursor.fetchall()\\n print(\\\"\\\\nDays with greater than 1 percent error rate:\\\")\\n for result in results:\\n print(\\\"{:%B %d, %Y} - {:.2%} errors\\\".format(result[0], result[1]))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.79570866","0.76505107","0.7556986","0.7181456","0.7115748","0.70891637","0.698253","0.6980931","0.69472224","0.6878406","0.6876207","0.68568164","0.6730276","0.66749024","0.6658213","0.6623326","0.6581947","0.65270984","0.6495916","0.6495916","0.6464373","0.64572376","0.64173263","0.64038193","0.63998526","0.6386051","0.637253","0.63533545","0.63484794","0.6344626","0.63255113","0.6303188","0.62636924","0.62570506","0.62486595","0.6241832","0.6196225","0.61948085","0.6179032","0.61703706","0.6169482","0.61536497","0.61534345","0.61528176","0.6150811","0.6132977","0.61234313","0.61212224","0.61041605","0.6099661","0.60947156","0.60939485","0.6050462","0.6044194","0.6035975","0.6021239","0.6017723","0.6016829","0.6007873","0.5998525","0.5987405","0.5987405","0.597118","0.5945707","0.593953","0.59281856","0.5911731","0.5905737","0.5904403","0.59010965","0.5887067","0.58863693","0.58862907","0.58779824","0.5875582","0.5873117","0.5866534","0.5855642","0.5851301","0.5849289","0.58463097","0.584577","0.5829096","0.5828649","0.5823208","0.5822296","0.58190733","0.5816829","0.5816829","0.579271","0.5789915","0.5782229","0.57812566","0.57746536","0.5774311","0.5771935","0.57700914","0.5766497","0.5764796","0.5760885"],"string":"[\n \"0.79570866\",\n \"0.76505107\",\n \"0.7556986\",\n \"0.7181456\",\n \"0.7115748\",\n \"0.70891637\",\n \"0.698253\",\n \"0.6980931\",\n \"0.69472224\",\n \"0.6878406\",\n \"0.6876207\",\n \"0.68568164\",\n \"0.6730276\",\n \"0.66749024\",\n \"0.6658213\",\n \"0.6623326\",\n \"0.6581947\",\n \"0.65270984\",\n \"0.6495916\",\n \"0.6495916\",\n \"0.6464373\",\n \"0.64572376\",\n \"0.64173263\",\n \"0.64038193\",\n \"0.63998526\",\n \"0.6386051\",\n \"0.637253\",\n \"0.63533545\",\n \"0.63484794\",\n \"0.6344626\",\n \"0.63255113\",\n \"0.6303188\",\n \"0.62636924\",\n \"0.62570506\",\n \"0.62486595\",\n \"0.6241832\",\n \"0.6196225\",\n \"0.61948085\",\n \"0.6179032\",\n \"0.61703706\",\n \"0.6169482\",\n \"0.61536497\",\n \"0.61534345\",\n \"0.61528176\",\n \"0.6150811\",\n \"0.6132977\",\n \"0.61234313\",\n \"0.61212224\",\n \"0.61041605\",\n \"0.6099661\",\n \"0.60947156\",\n \"0.60939485\",\n \"0.6050462\",\n \"0.6044194\",\n \"0.6035975\",\n \"0.6021239\",\n \"0.6017723\",\n \"0.6016829\",\n \"0.6007873\",\n \"0.5998525\",\n \"0.5987405\",\n \"0.5987405\",\n \"0.597118\",\n \"0.5945707\",\n \"0.593953\",\n \"0.59281856\",\n \"0.5911731\",\n \"0.5905737\",\n \"0.5904403\",\n \"0.59010965\",\n \"0.5887067\",\n \"0.58863693\",\n \"0.58862907\",\n \"0.58779824\",\n \"0.5875582\",\n \"0.5873117\",\n \"0.5866534\",\n \"0.5855642\",\n \"0.5851301\",\n \"0.5849289\",\n \"0.58463097\",\n \"0.584577\",\n \"0.5829096\",\n \"0.5828649\",\n \"0.5823208\",\n \"0.5822296\",\n \"0.58190733\",\n \"0.5816829\",\n \"0.5816829\",\n \"0.579271\",\n \"0.5789915\",\n \"0.5782229\",\n \"0.57812566\",\n \"0.57746536\",\n \"0.5774311\",\n \"0.5771935\",\n \"0.57700914\",\n \"0.5766497\",\n \"0.5764796\",\n \"0.5760885\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6638913"},"document_rank":{"kind":"string","value":"15"}}},{"rowIdx":21998,"cells":{"query":{"kind":"string","value":"Print all Rez packages that should be run on."},"document":{"kind":"string","value":"def _print_missing(packages, verbose):\n if not packages:\n print(\"## No Rez packages were found.\")\n print(\"No data found\")\n\n return\n\n print(\"## Your command affects these Rez packages.\")\n\n template = \"{package.name}\"\n\n if verbose:\n template = \"{package.name}: {path}\"\n\n for line in sorted(\n template.format(package=package, path=finder.get_package_root(package))\n for package in packages\n ):\n print(line)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def list_packages(self):\n for tag, pkg in PACKAGES.iteritems():\n print \"{tag} - {label}\".format(tag=tag, label=pkg['label'])","def _print_ignored(packages):\n if not packages:\n print(\"## No Rez package was set to be ignored\")\n print(\"No data found\")\n\n return\n\n print(\"## Every package in this list was explicitly set to ignored by the user\")\n\n for package, pattern in sorted(packages, key=_get_package_name):\n print(\n 'Package: {package.name} - Pattern: \"{pattern}\"'.format(\n package=package, pattern=pattern\n )\n )","def packages():","def print_dependencies(pkg):\n\n for deptype in (\"build\", \"link\", \"run\"):\n color.cprint(\"\")\n color.cprint(section_title(\"%s Dependencies:\" % deptype.capitalize()))\n deps = sorted(pkg.dependencies_of_type(deptype))\n if deps:\n colify(deps, indent=4)\n else:\n color.cprint(\" None\")","def print_dependencies(_run):\n print('Sources:')\n for source, digest in _run.experiment_info['sources']:\n print(' {:<43} {}'.format(source, digest))\n\n print('\\nDependencies:')\n for pack, version in _run.experiment_info['dependencies']:\n print(' {:<20} >= {}'.format(pack, version))","def _list_all(root_pkg, prog):\n res = \"\\n\".join(\n sorted(\n pkinspect.package_module_names(_import(root_pkg)),\n key=str.lower,\n ),\n )\n sys.stderr.write(f\"usage: {prog} module command [args...]\\nModules:\\n{res}\\n\")\n return 1","def print_deps(self):\n\t\tprint self.deps, '\\n'","def printall():\n print listAll()","def show_versions():\n sys_info = _get_sys_info()\n deps_info = _get_deps_info()\n\n print(\"\\nSystem:\")\n for k, stat in sys_info.items():\n print(\"{k:>10}: {stat}\".format(k=k, stat=stat))\n\n print(\"\\nPython dependencies:\")\n for k, stat in deps_info.items():\n print(\"{k:>13}: {stat}\".format(k=k, stat=stat))","def print(self):\n print(\"Repository list: \")\n for repo in self.list:\n print(\"- \" + repo.name)","def report(*packages):\n accepted_commands = ['python','conda']\n for package in packages:\n loc = \"not installed in this environment\"\n ver = \"unknown\"\n\n try:\n module = importlib.import_module(package)\n loc = os.path.dirname(module.__file__)\n\n try:\n ver = str(module.__version__)\n except Exception:\n pass\n \n except (ImportError, ModuleNotFoundError):\n if package in accepted_commands:\n try:\n # See if there is a command by that name and check its --version if so\n try:\n loc = subprocess.check_output(['command','-v', package]).decode().splitlines()[0].strip()\n except:\n # .exe in case powershell (otherwise wouldn't need it)\n loc = subprocess.check_output(['where.exe', package]).decode().splitlines()[0].strip() \n out = \"\"\n try:\n out = subprocess.check_output([package, '--version'], stderr=subprocess.STDOUT)\n except subprocess.CalledProcessError as e:\n out = e.output\n\n # Assume first word in output with a period and digits is the version\n for s in out.decode().split():\n if '.' in s and str.isdigit(s[0]) and sum(str.isdigit(c) for c in s)>=2:\n ver=s.strip()\n break\n except:\n pass\n elif package == 'system':\n try:\n ver = platform.platform(terse=True)\n loc = \"OS: \" + platform.platform()\n except Exception:\n pass\n else:\n pass\n \n print(\"{0:30} # {1}\".format(package + \"=\" + ver,loc))","def show ( self, **show_kw ):\n for package in self._subdirs.values():\n package.show ( **show_kw )","def show_all(self):\n cmodules.showModuleData(\n Options.Author,\n Options.Name,\n Options.Call,\n Options.Category,\n Options.Type,\n Options.Version,\n Options.Description,\n Options.License,\n Options.Datecreation,\n Options.Lastmodified\n )\n self.show_commands()\n self.show_opt()","def show_packagelist(user, repo, packages, distro=False, version=False,\n name=False, match=False, pkgtype=False):\n\n print('Currently {}/{} contains these matching packages:'.format(\n user, repo))\n\n numpkgs = 0\n for package in packages:\n if (distro and not package['distro_version'] == distro) or \\\n (version and not package['version'] == version) or \\\n (name and not package['name'] == name) or \\\n (pkgtype and not package['type'] == pkgtype) or \\\n (match and match not in package['filename']):\n continue\n\n print(fmt_pkg(user, repo, package))\n numpkgs += 1\n\n print(\"Repo contains {} matching packages.\".format(numpkgs))","def main():\n for dev in Discover.discover().values():\n print(dev)","def show_versions():\n sys_info = _get_sys_info()\n versions = _get_autogluon_versions()\n sorted_keys = sorted(versions.keys(), key=lambda x: x.lower())\n\n maxlen = 0 if len(versions) == 0 else max(len(x) for x in versions)\n print(\"\\nINSTALLED VERSIONS\")\n print(\"------------------\")\n for k, v in sys_info.items():\n print(f\"{k:<{maxlen}}: {v}\")\n print(\"\")\n for k in sorted_keys:\n print(f\"{k:<{maxlen}}: {versions[k]}\")","def _print_skips(skips, verbose):\n if not skips:\n print(\"## No packages were skipped\")\n print(\"Every found Rez package can be processed by the command.\")\n\n return\n\n print(\"## Packages were skipped from running a command. Here's the full list:\")\n\n template = \"{issue.package.name}: {issue.reason}\"\n\n if verbose:\n template = \"{issue.package.name}: {issue.path}: {issue.reason}\"\n\n for issue in skips:\n print(template.format(issue=issue))","def print_drivers():\n driver_info_dict = get_all_driver_infos()\n keys = sorted(driver_info_dict)\n print \"%-25s%-15s%-9s%-25s\" % (\n \"Module name\", \"Driver name\", \"Version\", \"Status\")\n for d in keys:\n print \" %(module_name)-25s%(driver_name)-15s%(version)-9s%(status)-25s\" % driver_info_dict[d]","def print_package_info(package):\r\n print(\"******************\")\r\n print(\"Product: %s\" % package[0]['description'])\r\n print(\"Price: %s$ monthly\" % package[0]['prices'][0]['recurringFee'])\r\n print(\"******************\")\r\n return","def list_packages(self):\n\n # First extract loaded module names from sys.modules\n sys_modules = sys.modules.keys()\n\n packages = {}\n\n # First add moduels in sys.modules (built-ins,\n # preloads and already loaded ones)\n for name in sys_modules:\n d = self.find_package(name)\n if not d: continue\n try:\n pkginfo = packages[d['type']]\n pkginfo[d['name']] = d['path']\n except Exception, e:\n packages[d['type']] = { d['name'] : d['path'] }\n\n #import site\n # Loop through all directories in sys.path and check for modules\n # Dont iterate through <prefix>/lib directory\n libdir = os.path.join(sys.prefix, 'lib')\n\n walked = []\n for top_level in self.paths:\n if not os.path.isdir(top_level):\n continue\n\n # Dont iterate through libdir\n if os.path.abspath(top_level) == os.path.abspath(libdir):\n continue\n\n walked.append(top_level)\n for item in os.listdir(top_level):\n\n fullpath = os.path.join(top_level, item)\n if fullpath in walked: continue\n\n walked.append(fullpath)\n # Remove the extension\n idx = item.find('.')\n if idx != -1: item = item[:idx]\n d = self.find_package(item)\n if not d: continue\n try:\n pkginfo = packages[d['type']]\n pkginfo[d['name']] = d['path']\n except Exception, e:\n packages[d['type']] = { d['name'] : d['path'] } \n\n for key,item in packages.items():\n print\n print self.pkgTypeInfo(key)\n print\n\n # Print sorted\n listofitems = item.keys()\n listofitems.sort()\n\n for key2 in listofitems:\n print key2,':',item[key2]","def list_package(all: bool = False) -> List[List[str]]:\n if not all:\n pkgs_info = read_installation_records()\n else:\n pkgs_info = []\n for pkg in pkg_resources.working_set:\n pkgs_info.append([pkg.project_name, pkg.version])\n\n return pkgs_info","def print_paths():\n print(f\"~: {HOME}\")\n print(f\"PYTHON: {PYTHON}\")\n print(f\"IDEAS: {IDEAS}\")\n print(f\"SITE-PACKAGES {SITE_PACKAGES}\")\n if os.path.exists(TESTS):\n print(f\"TESTS: {TESTS}\")","def troubleshoot():\n libraries = (sys, pd, openpyxl, matplotlib, pip)\n for i in libraries:\n try:\n print(str(i), 'version:', i.__version__)\n except AttributeError:\n pass\n except ModuleNotFoundError:\n print('You do not have', str(i), 'installed.')\n print('You can do so via your interpreter or:')\n print('py -m pip install', '-' + str(i))\n print('in command prompt')","def printImported():\r\n ll = sorted([mod for mod in sys.modules if mod.find('pubsub') >= 0])\r\n\r\n py2and3.print_('\\n'.join(ll))","def main():\n\n local_pkgs = set(os.listdir(GIT_FOLDER))\n local_pkgs = set([it.replace('.git', '') for it in local_pkgs])\n\n pkgdb_info = pkgdb_pkg_branch()\n\n pkgdb_pkgs = set(pkgdb_info.keys())\n\n ## Commented out as we keep the git of retired packages while they won't\n ## show up in the information retrieved from pkgdb.\n\n #if (local_pkgs - pkgdb_pkgs):\n #print 'Some packages are present locally but not on pkgdb:'\n #print ', '.join(sorted(local_pkgs - pkgdb_pkgs))\n\n if (pkgdb_pkgs - local_pkgs):\n print 'Some packages are present in pkgdb but not locally:'\n print ', '.join(sorted(pkgdb_pkgs - local_pkgs))\n\n tofix = set()\n for pkg in sorted(pkgdb_info):\n pkgdb_branches = pkgdb_info[pkg]\n git_branches = get_git_branch(pkg)\n diff = (pkgdb_branches - git_branches)\n if diff:\n print '%s missing: %s' % (pkg, ','.join(sorted(diff)))\n tofix.add(pkg)\n branch_package(pkg, diff)\n\n if tofix:\n print 'Packages fixed (%s): %s' % (\n len(tofix), ', '.join(sorted(tofix)))","def list():\n\n click.secho('List of libraries in SJSU-Dev2\\n', fg='white', bold=True)\n package_registry = GetListOfSJSUDev2Repos()\n library_list = [f'{x : <20}: {package_registry[x]}'\n for x in package_registry if x.startswith('lib')]\n print('\\n'.join(library_list))","def print_versions():\n\n print('-=' * 38)\n print(\"PyTables version: %s\" % tb.__version__)\n print(\"HDF5 version: %s\" % tb.which_lib_version(\"hdf5\")[1])\n print(\"NumPy version: %s\" % np.__version__)\n tinfo = tb.which_lib_version(\"zlib\")\n if ne.use_vml:\n # Get only the main version number and strip out all the rest\n vml_version = ne.get_vml_version()\n vml_version = re.findall(\"[0-9.]+\", vml_version)[0]\n vml_avail = \"using VML/MKL %s\" % vml_version\n else:\n vml_avail = \"not using Intel's VML/MKL\"\n print(f\"Numexpr version: {ne.__version__} ({vml_avail})\")\n if tinfo is not None:\n print(f\"Zlib version: {tinfo[1]} (in Python interpreter)\")\n tinfo = tb.which_lib_version(\"lzo\")\n if tinfo is not None:\n print(\"LZO version: {} ({})\".format(tinfo[1], tinfo[2]))\n tinfo = tb.which_lib_version(\"bzip2\")\n if tinfo is not None:\n print(\"BZIP2 version: {} ({})\".format(tinfo[1], tinfo[2]))\n tinfo = tb.which_lib_version(\"blosc\")\n if tinfo is not None:\n blosc_date = tinfo[2].split()[1]\n print(\"Blosc version: {} ({})\".format(tinfo[1], blosc_date))\n blosc_cinfo = tb.blosc_get_complib_info()\n blosc_cinfo = [\n \"{} ({})\".format(k, v[1]) for k, v in sorted(blosc_cinfo.items())\n ]\n print(\"Blosc compressors: %s\" % ', '.join(blosc_cinfo))\n blosc_finfo = ['shuffle', 'bitshuffle']\n print(\"Blosc filters: %s\" % ', '.join(blosc_finfo))\n tinfo = tb.which_lib_version(\"blosc2\")\n if tinfo is not None:\n blosc2_date = tinfo[2].split()[1]\n print(\"Blosc2 version: {} ({})\".format(tinfo[1], blosc2_date))\n blosc2_cinfo = tb.blosc2_get_complib_info()\n blosc2_cinfo = [\n \"{} ({})\".format(k, v[1]) for k, v in sorted(blosc2_cinfo.items())\n ]\n print(\"Blosc2 compressors: %s\" % ', '.join(blosc2_cinfo))\n blosc2_finfo = ['shuffle', 'bitshuffle']\n print(\"Blosc2 filters: %s\" % ', '.join(blosc2_finfo))\n try:\n from Cython import __version__ as cython_version\n print('Cython version: %s' % cython_version)\n except Exception:\n pass\n print('Python version: %s' % sys.version)\n print('Platform: %s' % platform.platform())\n # if os.name == 'posix':\n # (sysname, nodename, release, version, machine) = os.uname()\n # print('Platform: %s-%s' % (sys.platform, machine))\n print('Byte-ordering: %s' % sys.byteorder)\n print('Detected cores: %s' % tb.utils.detect_number_of_cores())\n print('Default encoding: %s' % sys.getdefaultencoding())\n print('Default FS encoding: %s' % sys.getfilesystemencoding())\n print('Default locale: (%s, %s)' % locale.getdefaultlocale())\n print('-=' * 38)\n\n # This should improve readability whan tests are run by CI tools\n sys.stdout.flush()","def dump(self):\n\n\t\treturn [\n\t\t\tpkg.dump()\n\t\t\tfor pkg in self._packages.values()\n\t\t]","def init():\n print(\"Installed everything under {0} \"\n \"virtual environment\".format(package_name()))","def packages(self):\n return []","def print_all_separation_algorithms():\n from ..separation import all_separation_algorithms\n print('\\n'.join([a.__name__ for a in all_separation_algorithms]))","def print_environment():\n print(f\"python version: {sys.version}\")\n\n # sys.argv will *always* contain 1 element, depending on how the script was\n # executed.\n #\n # If executed as a script (python simple.py), sys.argv[0] == \"simple.py\"\n # If executed as a module, (python -m simple), sys.argv[0] is the full path\n # to the script. (i.e., sys.argv[0] == \"/Users/dra/projects/python-examples/simple.py\"\n\n logger.info(f\"argv len={len(sys.argv)} = {sys.argv}\")\n\n # The module search path is the list of:\n # * Current directory\n # * $PYTHONPATH environment variable. Takes same format as $PATH (/usr/local:/usr/bin).\n # * Installation dependent default\n logger.info(f\"path == {str(sys.path)}\")\n logger.info(f\"platform == {sys.platform}\")\n\n print(\"--- packages ---\")\n print(sorted([f\"{i.key} = {i.version}\" for i in pkg_resources.working_set]))\n print(\"--- END packages ---\")","def print_config(self):\n for pod in self.pods:\n for lb in pod.limbs:\n print '%s limb %s ' % (pod.name, lb.name)\n for br in lb.branches:\n br.printInfo()\n sys.stdout.flush()","def print_all():\n for i in flags:\n print(i)","def list_cmd(repo):\n click.echo('Packages and scripts installed through pipsi:')\n for venv, scripts in repo.list_everything():\n if not scripts:\n continue\n click.echo(' Package \"%s\":' % venv)\n for script in scripts:\n click.echo(' ' + script)","def log_installed_modules(self):\n\n # Get python modules installed locally\n\n installed_packages = pkg_resources.working_set\n\n python_str = f'python:{sys.version}\\n'\n print_str = \"\\n\".join(f\"{package.key}: {package.version}\" for package in installed_packages)\n msg = f\"Installed packages:\\n{python_str+print_str}\"\n logger.info(msg)","def print_modules(self):\n\t\tshutit_global.shutit_global_object.yield_to_draw()\n\t\tcfg = self.cfg\n\t\tmodule_string = ''\n\t\tmodule_string += 'Modules: \\n'\n\t\tmodule_string += ' Run order Build Remove Module ID\\n'\n\t\tfor module_id in self.module_ids():\n\t\t\tmodule_string += ' ' + str(self.shutit_map[module_id].run_order) + ' ' + str(\n\t\t\t\tcfg[module_id]['shutit.core.module.build']) + ' ' + str(\n\t\t\t\tcfg[module_id]['shutit.core.module.remove']) + ' ' + module_id + '\\n'\n\t\treturn module_string","def show_missing():\n if missing_modules:\n info(\"The following modules are currently not installed and would enable additional tasks:\")\n for pkg_name in missing_modules:\n info(' ' + pkg_name)","def show_rev_deps(self, package):\n return self.show_deps(package, \"show-rev-deps\")","def show_tools():\n print(\"\"\"\n List the tools available in this package:\n create_date_features(df, date) #TODO\n create_date_feature_bisiness_quater(df = None, date = None)\n create_date_feature_daytime(df = None, date = None)\n create_date_feature_is_public_holiday(df, date, start, end, country = 'US')\n create_date_feature_is_month_end(df = None, date = None, last = 1)\n create_date_feature_is_weekend(df = None, date = None)\n create_date_feature_is_weekday(df = None, date = None)\n create_date_feature_season(df = None, date = None)\n create_grid(df, keys, target) #TODO\n create_lag_features_with_time_feature(df, cols, time, n = 5, fillna = True)\n create_lag_features_ohne_time_feature(df, cols, n = 5, fillna = True)\n create_window_feature(df, cols = None, col2 = None, win_size = 2, win_type = None, min_periods = 1, agg = 'mean')\n mean_encoder(df, cols, tg)\n \"\"\")","def test_packages(self):\n for pkg in self.expected_packages:\n status, output = commands.getstatusoutput('pkg_info -qx %s' % pkg)\n assert status == 0","def print_results(self):\n pass","def show_versions():\n\n print(\n f\"Version info: \"\n f\"autodoc_pydantic: {get_version('sphinxcontrib.autodoc_pydantic')} | \"\n f\"pydantic: {get_version_special('pydantic')} | \"\n f\"sphinx: {get_version('sphinx')} | \"\n f\"sphinx_rtd_theme: {get_version('sphinx_rtd_theme')} | \"\n f\"sphinx_tabs: {get_version('sphinx_tabs')}\")","def run(self):\n logging.debug('List Available Recipes')\n if self.short:\n print(' '.join(pakit.recipe.RDB.names(desc=False)))\n return\n\n available = ['Program Description']\n available.extend(pakit.recipe.RDB.names(desc=True))\n\n msg = 'Available Recipes:'\n msg += PREFIX + PREFIX.join(available)\n print(msg)\n return msg","def print_string(self):\n for x in self.minimal:\n print(\"min: %s\" % x)\n for x in self.also_installed:\n print(\"als: %s\" % x)\n for x in self.uninstalled:\n print(\"uni: %s\" % x)","def print_out():\n pass","def _list_dependencies_info(\n out: Callable, ljust: int, package: str, dependencies: List[Requirement]\n):\n unicode = sys.stdout.encoding.lower().startswith(\"utf\")\n if unicode:\n ljust += 1\n\n not_found: List[Requirement] = list()\n for dep in dependencies:\n if dep.name == package:\n continue\n try:\n version_ = version(dep.name)\n except Exception:\n not_found.append(dep)\n continue\n\n # build the output string step by step\n output = f\"✔︎ {dep.name}\" if unicode else dep.name\n # handle version specifiers\n if len(dep.specifier) != 0:\n output += f\" ({str(dep.specifier)})\"\n output += \":\"\n output = output.ljust(ljust) + version_\n\n # handle special dependencies with backends, C dep, ..\n if dep.name in (\"matplotlib\", \"seaborn\") and version_ != \"Not found.\":\n try:\n from matplotlib import pyplot as plt\n\n backend = plt.get_backend()\n except Exception:\n backend = \"Not found\"\n\n output += f\" (backend: {backend})\"\n out(output + \"\\n\")\n\n if len(not_found) != 0:\n not_found = [\n f\"{dep.name} ({str(dep.specifier)})\"\n if len(dep.specifier) != 0\n else dep.name\n for dep in not_found\n ]\n if unicode:\n out(f\"✘ Not installed: {', '.join(not_found)}\\n\")\n else:\n out(f\"Not installed: {', '.join(not_found)}\\n\")","def print_everything(self):\n def print_service(service):\n print\n print '====[ %s ]==== ' % service.__repr__(path_only=True)\n print\n\n print 'Actions:'\n for name, action in service.get_actions():\n print ' - ', name, action\n print\n\n for name, subservice in service.get_subservices():\n print_service(subservice)\n\n print_service(self.root)","def show_polymers():\n appnames = tuple(all_registered_appnames())\n appcount = len(appnames)\n plural = (appcount == 1) and \"app\" or \"apps\"\n print(f\"POLYMERS ({appcount} {plural} total):\")\n \n for appname in appnames:\n perapp = polymers[appname]\n modcount = len(perapp.modules)\n modplural = (modcount == 1) and \"module\" or \"modules\"\n string = pformat(perapp.__dict__, indent=4, width=consts.SEPARATOR_WIDTH)\n print()\n print(f\" «{appname}» ({modcount} {modplural}):\")\n print(f\"{string}\")","def status_all(self):\n output = (\n '[ + ] acpid',\n '[ - ] alsa-utils',\n '[ + ] anacron',\n '[ + ] apparmor',\n '[ + ] apport',\n '[ + ] avahi-daemon',\n '[ + ] bluetooth',\n '[ - ] bootmisc.sh',\n '[ - ] brltty',\n '[ - ] checkfs.sh',\n '[ - ] checkroot-bootclean.sh',\n '[ - ] checkroot.sh',\n '[ + ] console-setup',\n '[ + ] cron',\n '[ + ] cups',\n '[ + ] cups-browsed',\n '[ + ] dbus',\n '[ - ] dns-clean',\n '[ + ] grub-common',\n '[ - ] hostname.sh',\n '[ - ] hwclock.sh',\n '[ + ] irqbalance',\n '[ - ] kerneloops',\n '[ - ] killprocs',\n '[ + ] kmod',\n '[ + ] lightdm',\n '[ - ] mountall-bootclean.sh',\n '[ - ] mountall.sh',\n '[ - ] mountdevsubfs.sh',\n '[ - ] mountkernfs.sh',\n '[ - ] mountnfs-bootclean.sh',\n '[ - ] mountnfs.sh',\n '[ + ] network-manager',\n '[ + ] networking',\n '[ + ] ondemand',\n '[ + ] open-vm-tools',\n '[ - ] plymouth',\n '[ - ] plymouth-log',\n '[ - ] pppd-dns',\n '[ + ] procps',\n '[ - ] rc.local',\n '[ + ] resolvconf',\n '[ - ] rsync',\n '[ + ] rsyslog',\n '[ - ] saned',\n '[ - ] sendsigs',\n '[ + ] speech-dispatcher',\n '[ + ] thermald',\n '[ + ] udev',\n '[ + ] ufw',\n '[ - ] umountfs',\n '[ - ] umountnfs.sh',\n '[ - ] umountroot',\n '[ - ] unattended-upgrades',\n '[ + ] urandom',\n '[ - ] uuidd',\n '[ + ] whoopsie',\n '[ - ] x11-common')\n for l in output:\n self.write(l + '\\n')","def print_test_deps_not_in_package_deps(self):\n extras = []\n for key, rec_deps in self.recursive_pkg_deps.items():\n any = self.test_imports.get(key, set()).difference(rec_deps, set([key]))\n if any:\n extras.append((key, any))\n\n if extras:\n print(\"Packages whose tests have extra dependencies not listed in `go list -f {{.Deps}}`:\")\n for pkg, deps in extras:\n print(\"\\t{0}: {1}\".format(pkg, \", \".join(deps)))\n print(\"\\n\")","def show_everything():\n \n #print(\"WARNING: This may take awhile. . .\\n\")\n # Need to find all hostgroups, and make sure there are no deuplicate machines in this calculation.\n print(\"This feature is still under construction. Check back soon!\")\n sys.exit(0)","def svn_fs_print_modules(*args):\r\n return _fs.svn_fs_print_modules(*args)","def printLinks(self):\n self.browsed.sort()\n sys.stderr.write(\"\\n+ \" + _(\"URLs\") + \":\\n\")\n for lien in self.browsed:\n print(lien)","def log_imported_packages(self):\n imported_packages_dict = self.get_imported_packages()\n\n res_str = \"\\n\".join(f\"{module}: {version_num}\" for module, version_num\n in imported_packages_dict[\"results\"].items())\n no_res_str = \"\\n\".join(f\"{module}: {version_num}\" for module, version_num\n in imported_packages_dict[\"no_results\"].items())\n errs_res_str = \"\\n\".join(f\"{module}: {version_num}\" for module, version_num\n in imported_packages_dict[\"errors\"].items())\n\n msg = f\"Imported modules:\\n {res_str}\\n {no_res_str}\\n {errs_res_str}\"\n logger.info(msg)","def list_providers_packages():\n providers = get_all_providers()\n # if provider needs to be not considered in release add it here\n # this is useful for cases where provider is WIP for a long period thus we don't want to release it yet.\n providers_to_remove_from_release = []\n for provider in providers:\n if provider in providers_to_remove_from_release:\n continue\n console.print(provider)","def print_drinks(self):\n for beverage in self.drinks:\n print(beverage.get_name())","def info_software(modules: list[str] = DEFAULT_MODULES):\n\n # Python Environment\n env = getattr(sys, \"base_prefix\", None) or getattr(sys, \"real_prefix\", None) or sys.prefix\n print(f\"\\nENV:\\t{env}\")\n\n python_version = sys.version\n print(f\"\\nPYTHON:\\t{python_version}\")\n\n if modules is None:\n modules = DEFAULT_MODULES\n\n for i in modules:\n if i in installed_packages_dict:\n print(f\"{i:<25}{installed_packages_dict.get(i):>10}\")\n else:\n print(f\"{i:<25}: {'--NO--':>10}\")\n print()","def ShowUpdatedDEPS(options, versions):\n for flavor, value in sorted(GetUpdatedDEPS(options, versions).iteritems()):\n keyname = HashKey(flavor)\n print '%s=%s' % (keyname, value)\n sys.stdout.flush()","def show_all(only_fails=True):\n\n if not MASTER.exists():\n os.makedirs(MASTER)\n members = inspect.getmembers(sys.modules[__name__])\n members = [f for f in members if 'test_' in f[0]]\n for member in members:\n print('Running %s...' % member[0], end='')\n if only_fails:\n try:\n member[1]()\n except AssertionError:\n member[1](show=True)\n db()\n else:\n member[1](show=True)\n db()","def show_all(only_fails=True):\n\n if not MASTER.exists():\n os.makedirs(MASTER)\n members = inspect.getmembers(sys.modules[__name__])\n members = [f for f in members if 'test_' in f[0]]\n for member in members:\n print('Running %s...' % member[0], end='')\n if only_fails:\n try:\n member[1]()\n except AssertionError:\n member[1](show=True)\n db()\n else:\n member[1](show=True)\n db()","def _print_donors():\n print('Current donors: ' + ', '.join(_get_donor_names()))","def ls():\n cfgmgr = ConfigManager()\n apps = cfgmgr['apps']\n for i in apps:\n print(fc(\"- {g}{appname}{rst}\", appname=i))","def print_catalog(self):\n for book in self.books.keys():\n print(book)","def print_catalog(self):\n for book in self.books.keys():\n print(book)","def info():\n\n print('Maptool\\n--------\\n')\n print('Version: ' + __version__)\n print('Path: ' + __path__[0])\n print('Date: ' + __date__)\n print()\n\n import sys\n print('Python version=' + sys.version + '\\n')\n\n try:\n mm = __import__('pymongo')\n print('%10s %10s %s' % ('pymongo', mm.version, mm.__path__[0]))\n except ImportError:\n print('pymongo Not Found')\n\n for modui in ['numpy', 'scipy', 'mayavi', 'matplotlib', 'tqdm',\n 'future', 'nose', 'coverage', 'spglib', 'pyhull', 'pymatgen', 'qmpy', ]:\n try:\n mm = __import__(modui)\n print('%10s %10s %s' % (modui, mm.__version__, mm.__path__[0]))\n except ImportError:\n print('%10s %10s Not Found' % (modui, ''))\n\n if ASE:\n import ase\n #from ase import version as ase_version\n print('%10s %10s %s' % ('ase', ase.__version__, ase.__path__[0]))\n else:\n print('%10s %10s Not Found' % ('ase', ''))","def print_help():\n print(sys.modules[__name__].__doc__)","def print_all(self):\r\n for e in self.channels:\r\n e.print()","def dump_packages(self, package_name='com.sagas.dss'):\n model_reader = oc.delegator.getModelReader()\n tree_map = model_reader.getEntitiesByPackage(None, None)\n # print(tree_map)\n py_tree_map={trim_prefix(k):to_list(vals) for (k,vals) in tree_map.items() }\n for (k,vals) in py_tree_map.items():\n print(k, vals)\n\n json_str=json.dumps(py_tree_map, ensure_ascii=False, indent=2)\n io_utils.write_to_file(\"dump_pkgs.json\", json_str)","def listPrinters(self):\n raise NotImplementedError(\"listPrinters not implemented\")","def debug(c, force=None):\n for sp_ns in ns_foreach_task_subdir(c):\n print('!!!', sp_ns.tasks.build.__module__)\n print(' ', sp_ns.tasks.__module__)\n print(' ', sp_ns.__module__)","def dumps(self):\n result = []\n pkg_options_dumps = self._package_options.dumps()\n if pkg_options_dumps:\n result.append(pkg_options_dumps)\n for pkg_pattern, pkg_option in sorted(self._deps_package_options.items()):\n dep_pkg_option = pkg_option.dumps(scope=pkg_pattern)\n if dep_pkg_option:\n result.append(dep_pkg_option)\n return \"\\n\".join(result)","def list_packages():\n\n shelf_dir = settings.shelf_dir\n\n package_list = os.listdir(shelf_dir)\n\n package_list.sort()\n\n return package_list","def print_tables(self):\n print \"------------------\\nTables\\n------------------\"\n cnt = 0\n for x in self.show_tables():\n cnt += 1\n print (\"{0}.) {1}\".format(cnt, x[0]))","def print_augmentation_functions(self):\n for func in self.augmentation_functions:\n print(func.__name__)","def print_driver_list(outfile=None):\n if not outfile:\n outfile = sys.stdout\n print(\"List of output drivers:\", file=outfile)\n for drv in sorted(GenericDriver.drivers):\n print(\" \", \"driver\", drv, file=outfile)\n formats = GenericDriver.drivers[drv].driver_formats\n default_fmt = formats[0]\n for fmt in sorted(formats):\n if fmt == default_fmt:\n print(\" \", \" \", \"format\", fmt, '(driver default)', file=outfile)\n else:\n print(\" \", \" \", \"format\", fmt, file=outfile)","def _PrintHelp(matches=None):\n if not matches:\n print(FLAGS)\n else:\n flags_by_module = FLAGS.flags_by_module_dict()\n modules = sorted(flags_by_module)\n regex = re.compile(matches)\n for module_name in modules:\n if regex.search(module_name):\n print(FLAGS.module_help(module_name))","def log_installed_python_prereqs():\n sh(\"pip freeze > {}\".format(Env.GEN_LOG_DIR + \"/pip_freeze.log\"))","def printhelp_01():\n print('Convert simba3d report output from npz to .mat, or .json')\n print('simba3d-convertion --ext_out [.mat, .json, .txt, or .pdb] <list of files>')","def list_packages(pretty=False) -> Dict:\n\n packages = dict()\n lp = Commands._list_packages()\n inst_packages = lp.stdout.split('\\n')[:-1]\n\n for package in inst_packages:\n name, version = package.split('==')[0], package.split('==')[1]\n packages[name] = version\n \n if pretty:\n import json\n return json.dumps(packages, sort_keys=True, indent=4)\n return packages","def print_all_tables(self):\n conn = self.connect()\n cursor = conn.cursor()\n cursor.execute(\"SELECT name FROM sqlite_master WHERE type='table';\")\n print(cursor.fetchall())","def print_version():\n print(FULMAR_VERSION_STR)\n return","def _get_all_pkg_info(self):\n all_pkgs = self._filter_pkgs(self._go_list(\"./...\"))\n # for every package, list the deps, the test files, the test imports, and the external package test imports\n big_list = self._go_list(\n \"-f\", \"{{.ImportPath}}:{{.Deps}}:{{.TestImports}}:{{.XTestImports}}\", *all_pkgs)\n recursive_deps = {}\n test_imports = {}\n\n for line in big_list:\n tokens = [token.strip().lstrip('[').rstrip(']').strip() for token in line.split(\":\", 3)]\n pkg = tokens[0].strip()\n\n recursive_deps[pkg] = set(self._filter_pkgs(tokens[1].split() + [pkg]))\n if tokens[2] or tokens[3]:\n test_imports[pkg] = set(\n self._filter_pkgs(tokens[2].split()) + self._filter_pkgs(tokens[3].split()))\n\n return recursive_deps, test_imports","def print_products(self):\n for f in self.files:\n sys.stdout.write(\n 'Detected File <{0}> {1} (EPSG: {2}){3}'.format(str(f), '1' if self.__check_projection(f) else '0',\n str(self.__raster_epsg(f)), os.linesep))","def print_products(self):\n for f in self.files:\n sys.stdout.write(\n 'Detected File <{0}> {1} (EPSG: {2}){3}'.format(str(f), '1' if self.__check_projection(f) else '0',\n str(self.__raster_epsg(f)), os.linesep))","def test_print_version_repositories_SKIP(self):\n self._uri({\n '%d.%d/maintained/%d.%d-%d/%s/Packages.gz' % (MAJOR, MINOR, MAJOR, MINOR, 0, 'all'): DATA,\n '%d.%d/maintained/%d.%d-%d/%s/Packages.gz' % (MAJOR, MINOR, MAJOR, MINOR, 0, ARCH): DATA,\n })\n tmp = self.u.print_version_repositories()\n self.assertEqual(set((\n 'deb file:///mock/%d.%d/maintained/ %d.%d-%d/%s/' % (MAJOR, MINOR, MAJOR, MINOR, 0, 'all'),\n 'deb file:///mock/%d.%d/maintained/ %d.%d-%d/%s/' % (MAJOR, MINOR, MAJOR, MINOR, 0, ARCH),\n )), set(tmp.splitlines()))","def main():\n# logging.basicConfig(level=logging.DEBUG)\n try:\n user = sys.ARGV[1]\n except:\n user = 'hmm01i'\n repos = getRepos(user)\n print(\"%i Personal Repos\" % len(repos))\n logging.debug(repos)\n #print(\"Repo,[size, last update]\")\n #for k in repos.keys():\n # print(str(k),repos[k])","def list():\n project_root = get_project_root()\n config_file = os.path.join(project_root, CONFIG_DIR, CONFIG_FILE)\n if os.path.exists(config_file):\n kwargs = load_yaml_file(config_file)\n if PACKAGE_INDEX_KEY in kwargs:\n packages = load_yaml_url(kwargs[PACKAGE_INDEX_KEY])\n # Should update and look in .carme/config\n else:\n packages = load_yaml_url(PACKAGE_INDEX)\n\n ruamel.yaml.dump(packages, sys.stdout, Dumper=ruamel.yaml.RoundTripDumper)","def display_flavors(self):\n for flavor in self.flavors:\n print(f\"- {flavor}\")","def have_package_lists():\n return 'Filename:' in execute('apt-cache', 'show', 'python', check=False, capture=True)","def getusersitepackages():\n\tpass","def print_all(self) -> None:\n\n print(\"title: \" + str(self.title))\n print(\"simple_title: \" + str(self.simple_title))\n print(\"info: \" + str(self.info))\n print(\"exists: \" + str(self.exists))\n print(\"categories: \" + str(self.categories))\n print(\"content: \" + str(self.content))","def print_formulas(self):\n for formula in self.formulas:\n if formula:\n print(formula)","def getSetupPackages(self):\n e = eups.Eups()\n setupProducts = e.getSetupProducts()\n a = \"\"\n\n # create a new list will all products and versions\n allProducts = {}\n for i in setupProducts:\n allProducts[i.name] = i.version\n\n # replace any existing products that we saw on the command line, adding\n # them if they're not already there.\n if self.opts.setup is not None:\n for i, pkg in enumerate(self.opts.setup):\n name = pkg[0]\n version = pkg[1]\n print(\"name = %s, version = %s\" % (name, version))\n allProducts[name] = version\n\n # write out all products, except those that are setup locally.\n for name in allProducts:\n version = allProducts[name]\n if self.platform == \"lsst\":\n a = a + \"setup -j %s %s\\\\n\\\\\\n\" % (name, version)\n else:\n if not version.startswith(\"LOCAL:\"):\n a = a + \"setup -j %s %s\\\\n\\\\\\n\" % (name, version)\n return a","def print_info(args):\n print(banner_small)\n display_config_info()\n\n print(\"\")\n print(\"Python Configuration\")\n print(\"-\" * 25)\n print(\"\")\n info_calls = [\"which python3\", \"python3 --version\", \"which pip3\", \"pip3 --version\"]\n info_str = \"\"\n for x in info_calls:\n info_str += 'echo \" $ ' + x + '\" && ' + x + \"\\n\"\n info_str += \"echo \\n\"\n info_str += r\"echo \\\"echo \\$PYTHONPATH\\\" && echo $PYTHONPATH\"\n _ = subprocess.run(info_str, shell=True)\n print(\"\")","def print_all_descendants(self):\n #self._print_all_descendants_rec(self, 0) # stdout version \n string = \"|---\" + str(self) + \"\\n\"\n return self._return_string_all_descendants_rec(self, string, 0)","def get_installations():\n github_app = get_default_app()\n pprint(github_app.get_installations())","def print_networks(self, verbose: bool) -> None:\n print('---------- Networks initialized -------------')\n for name, module in self.modules.items():\n num_params = 0\n for param in module.parameters():\n num_params += param.numel()\n if verbose:\n print(module)\n print('[Network %s] Total number of parameters: %.3f M' % (name, num_params / 1e6))\n print('-----------------------------------------------')\n return","def showtopologies():\n middleware.protocolObj.showTopologies()","def print_networks(networks):\r\n\tlogging.info('-'*80)\r\n\tfor network in networks:\r\n\t\tprint(network)"],"string":"[\n \"def list_packages(self):\\n for tag, pkg in PACKAGES.iteritems():\\n print \\\"{tag} - {label}\\\".format(tag=tag, label=pkg['label'])\",\n \"def _print_ignored(packages):\\n if not packages:\\n print(\\\"## No Rez package was set to be ignored\\\")\\n print(\\\"No data found\\\")\\n\\n return\\n\\n print(\\\"## Every package in this list was explicitly set to ignored by the user\\\")\\n\\n for package, pattern in sorted(packages, key=_get_package_name):\\n print(\\n 'Package: {package.name} - Pattern: \\\"{pattern}\\\"'.format(\\n package=package, pattern=pattern\\n )\\n )\",\n \"def packages():\",\n \"def print_dependencies(pkg):\\n\\n for deptype in (\\\"build\\\", \\\"link\\\", \\\"run\\\"):\\n color.cprint(\\\"\\\")\\n color.cprint(section_title(\\\"%s Dependencies:\\\" % deptype.capitalize()))\\n deps = sorted(pkg.dependencies_of_type(deptype))\\n if deps:\\n colify(deps, indent=4)\\n else:\\n color.cprint(\\\" None\\\")\",\n \"def print_dependencies(_run):\\n print('Sources:')\\n for source, digest in _run.experiment_info['sources']:\\n print(' {:<43} {}'.format(source, digest))\\n\\n print('\\\\nDependencies:')\\n for pack, version in _run.experiment_info['dependencies']:\\n print(' {:<20} >= {}'.format(pack, version))\",\n \"def _list_all(root_pkg, prog):\\n res = \\\"\\\\n\\\".join(\\n sorted(\\n pkinspect.package_module_names(_import(root_pkg)),\\n key=str.lower,\\n ),\\n )\\n sys.stderr.write(f\\\"usage: {prog} module command [args...]\\\\nModules:\\\\n{res}\\\\n\\\")\\n return 1\",\n \"def print_deps(self):\\n\\t\\tprint self.deps, '\\\\n'\",\n \"def printall():\\n print listAll()\",\n \"def show_versions():\\n sys_info = _get_sys_info()\\n deps_info = _get_deps_info()\\n\\n print(\\\"\\\\nSystem:\\\")\\n for k, stat in sys_info.items():\\n print(\\\"{k:>10}: {stat}\\\".format(k=k, stat=stat))\\n\\n print(\\\"\\\\nPython dependencies:\\\")\\n for k, stat in deps_info.items():\\n print(\\\"{k:>13}: {stat}\\\".format(k=k, stat=stat))\",\n \"def print(self):\\n print(\\\"Repository list: \\\")\\n for repo in self.list:\\n print(\\\"- \\\" + repo.name)\",\n \"def report(*packages):\\n accepted_commands = ['python','conda']\\n for package in packages:\\n loc = \\\"not installed in this environment\\\"\\n ver = \\\"unknown\\\"\\n\\n try:\\n module = importlib.import_module(package)\\n loc = os.path.dirname(module.__file__)\\n\\n try:\\n ver = str(module.__version__)\\n except Exception:\\n pass\\n \\n except (ImportError, ModuleNotFoundError):\\n if package in accepted_commands:\\n try:\\n # See if there is a command by that name and check its --version if so\\n try:\\n loc = subprocess.check_output(['command','-v', package]).decode().splitlines()[0].strip()\\n except:\\n # .exe in case powershell (otherwise wouldn't need it)\\n loc = subprocess.check_output(['where.exe', package]).decode().splitlines()[0].strip() \\n out = \\\"\\\"\\n try:\\n out = subprocess.check_output([package, '--version'], stderr=subprocess.STDOUT)\\n except subprocess.CalledProcessError as e:\\n out = e.output\\n\\n # Assume first word in output with a period and digits is the version\\n for s in out.decode().split():\\n if '.' in s and str.isdigit(s[0]) and sum(str.isdigit(c) for c in s)>=2:\\n ver=s.strip()\\n break\\n except:\\n pass\\n elif package == 'system':\\n try:\\n ver = platform.platform(terse=True)\\n loc = \\\"OS: \\\" + platform.platform()\\n except Exception:\\n pass\\n else:\\n pass\\n \\n print(\\\"{0:30} # {1}\\\".format(package + \\\"=\\\" + ver,loc))\",\n \"def show ( self, **show_kw ):\\n for package in self._subdirs.values():\\n package.show ( **show_kw )\",\n \"def show_all(self):\\n cmodules.showModuleData(\\n Options.Author,\\n Options.Name,\\n Options.Call,\\n Options.Category,\\n Options.Type,\\n Options.Version,\\n Options.Description,\\n Options.License,\\n Options.Datecreation,\\n Options.Lastmodified\\n )\\n self.show_commands()\\n self.show_opt()\",\n \"def show_packagelist(user, repo, packages, distro=False, version=False,\\n name=False, match=False, pkgtype=False):\\n\\n print('Currently {}/{} contains these matching packages:'.format(\\n user, repo))\\n\\n numpkgs = 0\\n for package in packages:\\n if (distro and not package['distro_version'] == distro) or \\\\\\n (version and not package['version'] == version) or \\\\\\n (name and not package['name'] == name) or \\\\\\n (pkgtype and not package['type'] == pkgtype) or \\\\\\n (match and match not in package['filename']):\\n continue\\n\\n print(fmt_pkg(user, repo, package))\\n numpkgs += 1\\n\\n print(\\\"Repo contains {} matching packages.\\\".format(numpkgs))\",\n \"def main():\\n for dev in Discover.discover().values():\\n print(dev)\",\n \"def show_versions():\\n sys_info = _get_sys_info()\\n versions = _get_autogluon_versions()\\n sorted_keys = sorted(versions.keys(), key=lambda x: x.lower())\\n\\n maxlen = 0 if len(versions) == 0 else max(len(x) for x in versions)\\n print(\\\"\\\\nINSTALLED VERSIONS\\\")\\n print(\\\"------------------\\\")\\n for k, v in sys_info.items():\\n print(f\\\"{k:<{maxlen}}: {v}\\\")\\n print(\\\"\\\")\\n for k in sorted_keys:\\n print(f\\\"{k:<{maxlen}}: {versions[k]}\\\")\",\n \"def _print_skips(skips, verbose):\\n if not skips:\\n print(\\\"## No packages were skipped\\\")\\n print(\\\"Every found Rez package can be processed by the command.\\\")\\n\\n return\\n\\n print(\\\"## Packages were skipped from running a command. Here's the full list:\\\")\\n\\n template = \\\"{issue.package.name}: {issue.reason}\\\"\\n\\n if verbose:\\n template = \\\"{issue.package.name}: {issue.path}: {issue.reason}\\\"\\n\\n for issue in skips:\\n print(template.format(issue=issue))\",\n \"def print_drivers():\\n driver_info_dict = get_all_driver_infos()\\n keys = sorted(driver_info_dict)\\n print \\\"%-25s%-15s%-9s%-25s\\\" % (\\n \\\"Module name\\\", \\\"Driver name\\\", \\\"Version\\\", \\\"Status\\\")\\n for d in keys:\\n print \\\" %(module_name)-25s%(driver_name)-15s%(version)-9s%(status)-25s\\\" % driver_info_dict[d]\",\n \"def print_package_info(package):\\r\\n print(\\\"******************\\\")\\r\\n print(\\\"Product: %s\\\" % package[0]['description'])\\r\\n print(\\\"Price: %s$ monthly\\\" % package[0]['prices'][0]['recurringFee'])\\r\\n print(\\\"******************\\\")\\r\\n return\",\n \"def list_packages(self):\\n\\n # First extract loaded module names from sys.modules\\n sys_modules = sys.modules.keys()\\n\\n packages = {}\\n\\n # First add moduels in sys.modules (built-ins,\\n # preloads and already loaded ones)\\n for name in sys_modules:\\n d = self.find_package(name)\\n if not d: continue\\n try:\\n pkginfo = packages[d['type']]\\n pkginfo[d['name']] = d['path']\\n except Exception, e:\\n packages[d['type']] = { d['name'] : d['path'] }\\n\\n #import site\\n # Loop through all directories in sys.path and check for modules\\n # Dont iterate through <prefix>/lib directory\\n libdir = os.path.join(sys.prefix, 'lib')\\n\\n walked = []\\n for top_level in self.paths:\\n if not os.path.isdir(top_level):\\n continue\\n\\n # Dont iterate through libdir\\n if os.path.abspath(top_level) == os.path.abspath(libdir):\\n continue\\n\\n walked.append(top_level)\\n for item in os.listdir(top_level):\\n\\n fullpath = os.path.join(top_level, item)\\n if fullpath in walked: continue\\n\\n walked.append(fullpath)\\n # Remove the extension\\n idx = item.find('.')\\n if idx != -1: item = item[:idx]\\n d = self.find_package(item)\\n if not d: continue\\n try:\\n pkginfo = packages[d['type']]\\n pkginfo[d['name']] = d['path']\\n except Exception, e:\\n packages[d['type']] = { d['name'] : d['path'] } \\n\\n for key,item in packages.items():\\n print\\n print self.pkgTypeInfo(key)\\n print\\n\\n # Print sorted\\n listofitems = item.keys()\\n listofitems.sort()\\n\\n for key2 in listofitems:\\n print key2,':',item[key2]\",\n \"def list_package(all: bool = False) -> List[List[str]]:\\n if not all:\\n pkgs_info = read_installation_records()\\n else:\\n pkgs_info = []\\n for pkg in pkg_resources.working_set:\\n pkgs_info.append([pkg.project_name, pkg.version])\\n\\n return pkgs_info\",\n \"def print_paths():\\n print(f\\\"~: {HOME}\\\")\\n print(f\\\"PYTHON: {PYTHON}\\\")\\n print(f\\\"IDEAS: {IDEAS}\\\")\\n print(f\\\"SITE-PACKAGES {SITE_PACKAGES}\\\")\\n if os.path.exists(TESTS):\\n print(f\\\"TESTS: {TESTS}\\\")\",\n \"def troubleshoot():\\n libraries = (sys, pd, openpyxl, matplotlib, pip)\\n for i in libraries:\\n try:\\n print(str(i), 'version:', i.__version__)\\n except AttributeError:\\n pass\\n except ModuleNotFoundError:\\n print('You do not have', str(i), 'installed.')\\n print('You can do so via your interpreter or:')\\n print('py -m pip install', '-' + str(i))\\n print('in command prompt')\",\n \"def printImported():\\r\\n ll = sorted([mod for mod in sys.modules if mod.find('pubsub') >= 0])\\r\\n\\r\\n py2and3.print_('\\\\n'.join(ll))\",\n \"def main():\\n\\n local_pkgs = set(os.listdir(GIT_FOLDER))\\n local_pkgs = set([it.replace('.git', '') for it in local_pkgs])\\n\\n pkgdb_info = pkgdb_pkg_branch()\\n\\n pkgdb_pkgs = set(pkgdb_info.keys())\\n\\n ## Commented out as we keep the git of retired packages while they won't\\n ## show up in the information retrieved from pkgdb.\\n\\n #if (local_pkgs - pkgdb_pkgs):\\n #print 'Some packages are present locally but not on pkgdb:'\\n #print ', '.join(sorted(local_pkgs - pkgdb_pkgs))\\n\\n if (pkgdb_pkgs - local_pkgs):\\n print 'Some packages are present in pkgdb but not locally:'\\n print ', '.join(sorted(pkgdb_pkgs - local_pkgs))\\n\\n tofix = set()\\n for pkg in sorted(pkgdb_info):\\n pkgdb_branches = pkgdb_info[pkg]\\n git_branches = get_git_branch(pkg)\\n diff = (pkgdb_branches - git_branches)\\n if diff:\\n print '%s missing: %s' % (pkg, ','.join(sorted(diff)))\\n tofix.add(pkg)\\n branch_package(pkg, diff)\\n\\n if tofix:\\n print 'Packages fixed (%s): %s' % (\\n len(tofix), ', '.join(sorted(tofix)))\",\n \"def list():\\n\\n click.secho('List of libraries in SJSU-Dev2\\\\n', fg='white', bold=True)\\n package_registry = GetListOfSJSUDev2Repos()\\n library_list = [f'{x : <20}: {package_registry[x]}'\\n for x in package_registry if x.startswith('lib')]\\n print('\\\\n'.join(library_list))\",\n \"def print_versions():\\n\\n print('-=' * 38)\\n print(\\\"PyTables version: %s\\\" % tb.__version__)\\n print(\\\"HDF5 version: %s\\\" % tb.which_lib_version(\\\"hdf5\\\")[1])\\n print(\\\"NumPy version: %s\\\" % np.__version__)\\n tinfo = tb.which_lib_version(\\\"zlib\\\")\\n if ne.use_vml:\\n # Get only the main version number and strip out all the rest\\n vml_version = ne.get_vml_version()\\n vml_version = re.findall(\\\"[0-9.]+\\\", vml_version)[0]\\n vml_avail = \\\"using VML/MKL %s\\\" % vml_version\\n else:\\n vml_avail = \\\"not using Intel's VML/MKL\\\"\\n print(f\\\"Numexpr version: {ne.__version__} ({vml_avail})\\\")\\n if tinfo is not None:\\n print(f\\\"Zlib version: {tinfo[1]} (in Python interpreter)\\\")\\n tinfo = tb.which_lib_version(\\\"lzo\\\")\\n if tinfo is not None:\\n print(\\\"LZO version: {} ({})\\\".format(tinfo[1], tinfo[2]))\\n tinfo = tb.which_lib_version(\\\"bzip2\\\")\\n if tinfo is not None:\\n print(\\\"BZIP2 version: {} ({})\\\".format(tinfo[1], tinfo[2]))\\n tinfo = tb.which_lib_version(\\\"blosc\\\")\\n if tinfo is not None:\\n blosc_date = tinfo[2].split()[1]\\n print(\\\"Blosc version: {} ({})\\\".format(tinfo[1], blosc_date))\\n blosc_cinfo = tb.blosc_get_complib_info()\\n blosc_cinfo = [\\n \\\"{} ({})\\\".format(k, v[1]) for k, v in sorted(blosc_cinfo.items())\\n ]\\n print(\\\"Blosc compressors: %s\\\" % ', '.join(blosc_cinfo))\\n blosc_finfo = ['shuffle', 'bitshuffle']\\n print(\\\"Blosc filters: %s\\\" % ', '.join(blosc_finfo))\\n tinfo = tb.which_lib_version(\\\"blosc2\\\")\\n if tinfo is not None:\\n blosc2_date = tinfo[2].split()[1]\\n print(\\\"Blosc2 version: {} ({})\\\".format(tinfo[1], blosc2_date))\\n blosc2_cinfo = tb.blosc2_get_complib_info()\\n blosc2_cinfo = [\\n \\\"{} ({})\\\".format(k, v[1]) for k, v in sorted(blosc2_cinfo.items())\\n ]\\n print(\\\"Blosc2 compressors: %s\\\" % ', '.join(blosc2_cinfo))\\n blosc2_finfo = ['shuffle', 'bitshuffle']\\n print(\\\"Blosc2 filters: %s\\\" % ', '.join(blosc2_finfo))\\n try:\\n from Cython import __version__ as cython_version\\n print('Cython version: %s' % cython_version)\\n except Exception:\\n pass\\n print('Python version: %s' % sys.version)\\n print('Platform: %s' % platform.platform())\\n # if os.name == 'posix':\\n # (sysname, nodename, release, version, machine) = os.uname()\\n # print('Platform: %s-%s' % (sys.platform, machine))\\n print('Byte-ordering: %s' % sys.byteorder)\\n print('Detected cores: %s' % tb.utils.detect_number_of_cores())\\n print('Default encoding: %s' % sys.getdefaultencoding())\\n print('Default FS encoding: %s' % sys.getfilesystemencoding())\\n print('Default locale: (%s, %s)' % locale.getdefaultlocale())\\n print('-=' * 38)\\n\\n # This should improve readability whan tests are run by CI tools\\n sys.stdout.flush()\",\n \"def dump(self):\\n\\n\\t\\treturn [\\n\\t\\t\\tpkg.dump()\\n\\t\\t\\tfor pkg in self._packages.values()\\n\\t\\t]\",\n \"def init():\\n print(\\\"Installed everything under {0} \\\"\\n \\\"virtual environment\\\".format(package_name()))\",\n \"def packages(self):\\n return []\",\n \"def print_all_separation_algorithms():\\n from ..separation import all_separation_algorithms\\n print('\\\\n'.join([a.__name__ for a in all_separation_algorithms]))\",\n \"def print_environment():\\n print(f\\\"python version: {sys.version}\\\")\\n\\n # sys.argv will *always* contain 1 element, depending on how the script was\\n # executed.\\n #\\n # If executed as a script (python simple.py), sys.argv[0] == \\\"simple.py\\\"\\n # If executed as a module, (python -m simple), sys.argv[0] is the full path\\n # to the script. (i.e., sys.argv[0] == \\\"/Users/dra/projects/python-examples/simple.py\\\"\\n\\n logger.info(f\\\"argv len={len(sys.argv)} = {sys.argv}\\\")\\n\\n # The module search path is the list of:\\n # * Current directory\\n # * $PYTHONPATH environment variable. Takes same format as $PATH (/usr/local:/usr/bin).\\n # * Installation dependent default\\n logger.info(f\\\"path == {str(sys.path)}\\\")\\n logger.info(f\\\"platform == {sys.platform}\\\")\\n\\n print(\\\"--- packages ---\\\")\\n print(sorted([f\\\"{i.key} = {i.version}\\\" for i in pkg_resources.working_set]))\\n print(\\\"--- END packages ---\\\")\",\n \"def print_config(self):\\n for pod in self.pods:\\n for lb in pod.limbs:\\n print '%s limb %s ' % (pod.name, lb.name)\\n for br in lb.branches:\\n br.printInfo()\\n sys.stdout.flush()\",\n \"def print_all():\\n for i in flags:\\n print(i)\",\n \"def list_cmd(repo):\\n click.echo('Packages and scripts installed through pipsi:')\\n for venv, scripts in repo.list_everything():\\n if not scripts:\\n continue\\n click.echo(' Package \\\"%s\\\":' % venv)\\n for script in scripts:\\n click.echo(' ' + script)\",\n \"def log_installed_modules(self):\\n\\n # Get python modules installed locally\\n\\n installed_packages = pkg_resources.working_set\\n\\n python_str = f'python:{sys.version}\\\\n'\\n print_str = \\\"\\\\n\\\".join(f\\\"{package.key}: {package.version}\\\" for package in installed_packages)\\n msg = f\\\"Installed packages:\\\\n{python_str+print_str}\\\"\\n logger.info(msg)\",\n \"def print_modules(self):\\n\\t\\tshutit_global.shutit_global_object.yield_to_draw()\\n\\t\\tcfg = self.cfg\\n\\t\\tmodule_string = ''\\n\\t\\tmodule_string += 'Modules: \\\\n'\\n\\t\\tmodule_string += ' Run order Build Remove Module ID\\\\n'\\n\\t\\tfor module_id in self.module_ids():\\n\\t\\t\\tmodule_string += ' ' + str(self.shutit_map[module_id].run_order) + ' ' + str(\\n\\t\\t\\t\\tcfg[module_id]['shutit.core.module.build']) + ' ' + str(\\n\\t\\t\\t\\tcfg[module_id]['shutit.core.module.remove']) + ' ' + module_id + '\\\\n'\\n\\t\\treturn module_string\",\n \"def show_missing():\\n if missing_modules:\\n info(\\\"The following modules are currently not installed and would enable additional tasks:\\\")\\n for pkg_name in missing_modules:\\n info(' ' + pkg_name)\",\n \"def show_rev_deps(self, package):\\n return self.show_deps(package, \\\"show-rev-deps\\\")\",\n \"def show_tools():\\n print(\\\"\\\"\\\"\\n List the tools available in this package:\\n create_date_features(df, date) #TODO\\n create_date_feature_bisiness_quater(df = None, date = None)\\n create_date_feature_daytime(df = None, date = None)\\n create_date_feature_is_public_holiday(df, date, start, end, country = 'US')\\n create_date_feature_is_month_end(df = None, date = None, last = 1)\\n create_date_feature_is_weekend(df = None, date = None)\\n create_date_feature_is_weekday(df = None, date = None)\\n create_date_feature_season(df = None, date = None)\\n create_grid(df, keys, target) #TODO\\n create_lag_features_with_time_feature(df, cols, time, n = 5, fillna = True)\\n create_lag_features_ohne_time_feature(df, cols, n = 5, fillna = True)\\n create_window_feature(df, cols = None, col2 = None, win_size = 2, win_type = None, min_periods = 1, agg = 'mean')\\n mean_encoder(df, cols, tg)\\n \\\"\\\"\\\")\",\n \"def test_packages(self):\\n for pkg in self.expected_packages:\\n status, output = commands.getstatusoutput('pkg_info -qx %s' % pkg)\\n assert status == 0\",\n \"def print_results(self):\\n pass\",\n \"def show_versions():\\n\\n print(\\n f\\\"Version info: \\\"\\n f\\\"autodoc_pydantic: {get_version('sphinxcontrib.autodoc_pydantic')} | \\\"\\n f\\\"pydantic: {get_version_special('pydantic')} | \\\"\\n f\\\"sphinx: {get_version('sphinx')} | \\\"\\n f\\\"sphinx_rtd_theme: {get_version('sphinx_rtd_theme')} | \\\"\\n f\\\"sphinx_tabs: {get_version('sphinx_tabs')}\\\")\",\n \"def run(self):\\n logging.debug('List Available Recipes')\\n if self.short:\\n print(' '.join(pakit.recipe.RDB.names(desc=False)))\\n return\\n\\n available = ['Program Description']\\n available.extend(pakit.recipe.RDB.names(desc=True))\\n\\n msg = 'Available Recipes:'\\n msg += PREFIX + PREFIX.join(available)\\n print(msg)\\n return msg\",\n \"def print_string(self):\\n for x in self.minimal:\\n print(\\\"min: %s\\\" % x)\\n for x in self.also_installed:\\n print(\\\"als: %s\\\" % x)\\n for x in self.uninstalled:\\n print(\\\"uni: %s\\\" % x)\",\n \"def print_out():\\n pass\",\n \"def _list_dependencies_info(\\n out: Callable, ljust: int, package: str, dependencies: List[Requirement]\\n):\\n unicode = sys.stdout.encoding.lower().startswith(\\\"utf\\\")\\n if unicode:\\n ljust += 1\\n\\n not_found: List[Requirement] = list()\\n for dep in dependencies:\\n if dep.name == package:\\n continue\\n try:\\n version_ = version(dep.name)\\n except Exception:\\n not_found.append(dep)\\n continue\\n\\n # build the output string step by step\\n output = f\\\"✔︎ {dep.name}\\\" if unicode else dep.name\\n # handle version specifiers\\n if len(dep.specifier) != 0:\\n output += f\\\" ({str(dep.specifier)})\\\"\\n output += \\\":\\\"\\n output = output.ljust(ljust) + version_\\n\\n # handle special dependencies with backends, C dep, ..\\n if dep.name in (\\\"matplotlib\\\", \\\"seaborn\\\") and version_ != \\\"Not found.\\\":\\n try:\\n from matplotlib import pyplot as plt\\n\\n backend = plt.get_backend()\\n except Exception:\\n backend = \\\"Not found\\\"\\n\\n output += f\\\" (backend: {backend})\\\"\\n out(output + \\\"\\\\n\\\")\\n\\n if len(not_found) != 0:\\n not_found = [\\n f\\\"{dep.name} ({str(dep.specifier)})\\\"\\n if len(dep.specifier) != 0\\n else dep.name\\n for dep in not_found\\n ]\\n if unicode:\\n out(f\\\"✘ Not installed: {', '.join(not_found)}\\\\n\\\")\\n else:\\n out(f\\\"Not installed: {', '.join(not_found)}\\\\n\\\")\",\n \"def print_everything(self):\\n def print_service(service):\\n print\\n print '====[ %s ]==== ' % service.__repr__(path_only=True)\\n print\\n\\n print 'Actions:'\\n for name, action in service.get_actions():\\n print ' - ', name, action\\n print\\n\\n for name, subservice in service.get_subservices():\\n print_service(subservice)\\n\\n print_service(self.root)\",\n \"def show_polymers():\\n appnames = tuple(all_registered_appnames())\\n appcount = len(appnames)\\n plural = (appcount == 1) and \\\"app\\\" or \\\"apps\\\"\\n print(f\\\"POLYMERS ({appcount} {plural} total):\\\")\\n \\n for appname in appnames:\\n perapp = polymers[appname]\\n modcount = len(perapp.modules)\\n modplural = (modcount == 1) and \\\"module\\\" or \\\"modules\\\"\\n string = pformat(perapp.__dict__, indent=4, width=consts.SEPARATOR_WIDTH)\\n print()\\n print(f\\\" «{appname}» ({modcount} {modplural}):\\\")\\n print(f\\\"{string}\\\")\",\n \"def status_all(self):\\n output = (\\n '[ + ] acpid',\\n '[ - ] alsa-utils',\\n '[ + ] anacron',\\n '[ + ] apparmor',\\n '[ + ] apport',\\n '[ + ] avahi-daemon',\\n '[ + ] bluetooth',\\n '[ - ] bootmisc.sh',\\n '[ - ] brltty',\\n '[ - ] checkfs.sh',\\n '[ - ] checkroot-bootclean.sh',\\n '[ - ] checkroot.sh',\\n '[ + ] console-setup',\\n '[ + ] cron',\\n '[ + ] cups',\\n '[ + ] cups-browsed',\\n '[ + ] dbus',\\n '[ - ] dns-clean',\\n '[ + ] grub-common',\\n '[ - ] hostname.sh',\\n '[ - ] hwclock.sh',\\n '[ + ] irqbalance',\\n '[ - ] kerneloops',\\n '[ - ] killprocs',\\n '[ + ] kmod',\\n '[ + ] lightdm',\\n '[ - ] mountall-bootclean.sh',\\n '[ - ] mountall.sh',\\n '[ - ] mountdevsubfs.sh',\\n '[ - ] mountkernfs.sh',\\n '[ - ] mountnfs-bootclean.sh',\\n '[ - ] mountnfs.sh',\\n '[ + ] network-manager',\\n '[ + ] networking',\\n '[ + ] ondemand',\\n '[ + ] open-vm-tools',\\n '[ - ] plymouth',\\n '[ - ] plymouth-log',\\n '[ - ] pppd-dns',\\n '[ + ] procps',\\n '[ - ] rc.local',\\n '[ + ] resolvconf',\\n '[ - ] rsync',\\n '[ + ] rsyslog',\\n '[ - ] saned',\\n '[ - ] sendsigs',\\n '[ + ] speech-dispatcher',\\n '[ + ] thermald',\\n '[ + ] udev',\\n '[ + ] ufw',\\n '[ - ] umountfs',\\n '[ - ] umountnfs.sh',\\n '[ - ] umountroot',\\n '[ - ] unattended-upgrades',\\n '[ + ] urandom',\\n '[ - ] uuidd',\\n '[ + ] whoopsie',\\n '[ - ] x11-common')\\n for l in output:\\n self.write(l + '\\\\n')\",\n \"def print_test_deps_not_in_package_deps(self):\\n extras = []\\n for key, rec_deps in self.recursive_pkg_deps.items():\\n any = self.test_imports.get(key, set()).difference(rec_deps, set([key]))\\n if any:\\n extras.append((key, any))\\n\\n if extras:\\n print(\\\"Packages whose tests have extra dependencies not listed in `go list -f {{.Deps}}`:\\\")\\n for pkg, deps in extras:\\n print(\\\"\\\\t{0}: {1}\\\".format(pkg, \\\", \\\".join(deps)))\\n print(\\\"\\\\n\\\")\",\n \"def show_everything():\\n \\n #print(\\\"WARNING: This may take awhile. . .\\\\n\\\")\\n # Need to find all hostgroups, and make sure there are no deuplicate machines in this calculation.\\n print(\\\"This feature is still under construction. Check back soon!\\\")\\n sys.exit(0)\",\n \"def svn_fs_print_modules(*args):\\r\\n return _fs.svn_fs_print_modules(*args)\",\n \"def printLinks(self):\\n self.browsed.sort()\\n sys.stderr.write(\\\"\\\\n+ \\\" + _(\\\"URLs\\\") + \\\":\\\\n\\\")\\n for lien in self.browsed:\\n print(lien)\",\n \"def log_imported_packages(self):\\n imported_packages_dict = self.get_imported_packages()\\n\\n res_str = \\\"\\\\n\\\".join(f\\\"{module}: {version_num}\\\" for module, version_num\\n in imported_packages_dict[\\\"results\\\"].items())\\n no_res_str = \\\"\\\\n\\\".join(f\\\"{module}: {version_num}\\\" for module, version_num\\n in imported_packages_dict[\\\"no_results\\\"].items())\\n errs_res_str = \\\"\\\\n\\\".join(f\\\"{module}: {version_num}\\\" for module, version_num\\n in imported_packages_dict[\\\"errors\\\"].items())\\n\\n msg = f\\\"Imported modules:\\\\n {res_str}\\\\n {no_res_str}\\\\n {errs_res_str}\\\"\\n logger.info(msg)\",\n \"def list_providers_packages():\\n providers = get_all_providers()\\n # if provider needs to be not considered in release add it here\\n # this is useful for cases where provider is WIP for a long period thus we don't want to release it yet.\\n providers_to_remove_from_release = []\\n for provider in providers:\\n if provider in providers_to_remove_from_release:\\n continue\\n console.print(provider)\",\n \"def print_drinks(self):\\n for beverage in self.drinks:\\n print(beverage.get_name())\",\n \"def info_software(modules: list[str] = DEFAULT_MODULES):\\n\\n # Python Environment\\n env = getattr(sys, \\\"base_prefix\\\", None) or getattr(sys, \\\"real_prefix\\\", None) or sys.prefix\\n print(f\\\"\\\\nENV:\\\\t{env}\\\")\\n\\n python_version = sys.version\\n print(f\\\"\\\\nPYTHON:\\\\t{python_version}\\\")\\n\\n if modules is None:\\n modules = DEFAULT_MODULES\\n\\n for i in modules:\\n if i in installed_packages_dict:\\n print(f\\\"{i:<25}{installed_packages_dict.get(i):>10}\\\")\\n else:\\n print(f\\\"{i:<25}: {'--NO--':>10}\\\")\\n print()\",\n \"def ShowUpdatedDEPS(options, versions):\\n for flavor, value in sorted(GetUpdatedDEPS(options, versions).iteritems()):\\n keyname = HashKey(flavor)\\n print '%s=%s' % (keyname, value)\\n sys.stdout.flush()\",\n \"def show_all(only_fails=True):\\n\\n if not MASTER.exists():\\n os.makedirs(MASTER)\\n members = inspect.getmembers(sys.modules[__name__])\\n members = [f for f in members if 'test_' in f[0]]\\n for member in members:\\n print('Running %s...' % member[0], end='')\\n if only_fails:\\n try:\\n member[1]()\\n except AssertionError:\\n member[1](show=True)\\n db()\\n else:\\n member[1](show=True)\\n db()\",\n \"def show_all(only_fails=True):\\n\\n if not MASTER.exists():\\n os.makedirs(MASTER)\\n members = inspect.getmembers(sys.modules[__name__])\\n members = [f for f in members if 'test_' in f[0]]\\n for member in members:\\n print('Running %s...' % member[0], end='')\\n if only_fails:\\n try:\\n member[1]()\\n except AssertionError:\\n member[1](show=True)\\n db()\\n else:\\n member[1](show=True)\\n db()\",\n \"def _print_donors():\\n print('Current donors: ' + ', '.join(_get_donor_names()))\",\n \"def ls():\\n cfgmgr = ConfigManager()\\n apps = cfgmgr['apps']\\n for i in apps:\\n print(fc(\\\"- {g}{appname}{rst}\\\", appname=i))\",\n \"def print_catalog(self):\\n for book in self.books.keys():\\n print(book)\",\n \"def print_catalog(self):\\n for book in self.books.keys():\\n print(book)\",\n \"def info():\\n\\n print('Maptool\\\\n--------\\\\n')\\n print('Version: ' + __version__)\\n print('Path: ' + __path__[0])\\n print('Date: ' + __date__)\\n print()\\n\\n import sys\\n print('Python version=' + sys.version + '\\\\n')\\n\\n try:\\n mm = __import__('pymongo')\\n print('%10s %10s %s' % ('pymongo', mm.version, mm.__path__[0]))\\n except ImportError:\\n print('pymongo Not Found')\\n\\n for modui in ['numpy', 'scipy', 'mayavi', 'matplotlib', 'tqdm',\\n 'future', 'nose', 'coverage', 'spglib', 'pyhull', 'pymatgen', 'qmpy', ]:\\n try:\\n mm = __import__(modui)\\n print('%10s %10s %s' % (modui, mm.__version__, mm.__path__[0]))\\n except ImportError:\\n print('%10s %10s Not Found' % (modui, ''))\\n\\n if ASE:\\n import ase\\n #from ase import version as ase_version\\n print('%10s %10s %s' % ('ase', ase.__version__, ase.__path__[0]))\\n else:\\n print('%10s %10s Not Found' % ('ase', ''))\",\n \"def print_help():\\n print(sys.modules[__name__].__doc__)\",\n \"def print_all(self):\\r\\n for e in self.channels:\\r\\n e.print()\",\n \"def dump_packages(self, package_name='com.sagas.dss'):\\n model_reader = oc.delegator.getModelReader()\\n tree_map = model_reader.getEntitiesByPackage(None, None)\\n # print(tree_map)\\n py_tree_map={trim_prefix(k):to_list(vals) for (k,vals) in tree_map.items() }\\n for (k,vals) in py_tree_map.items():\\n print(k, vals)\\n\\n json_str=json.dumps(py_tree_map, ensure_ascii=False, indent=2)\\n io_utils.write_to_file(\\\"dump_pkgs.json\\\", json_str)\",\n \"def listPrinters(self):\\n raise NotImplementedError(\\\"listPrinters not implemented\\\")\",\n \"def debug(c, force=None):\\n for sp_ns in ns_foreach_task_subdir(c):\\n print('!!!', sp_ns.tasks.build.__module__)\\n print(' ', sp_ns.tasks.__module__)\\n print(' ', sp_ns.__module__)\",\n \"def dumps(self):\\n result = []\\n pkg_options_dumps = self._package_options.dumps()\\n if pkg_options_dumps:\\n result.append(pkg_options_dumps)\\n for pkg_pattern, pkg_option in sorted(self._deps_package_options.items()):\\n dep_pkg_option = pkg_option.dumps(scope=pkg_pattern)\\n if dep_pkg_option:\\n result.append(dep_pkg_option)\\n return \\\"\\\\n\\\".join(result)\",\n \"def list_packages():\\n\\n shelf_dir = settings.shelf_dir\\n\\n package_list = os.listdir(shelf_dir)\\n\\n package_list.sort()\\n\\n return package_list\",\n \"def print_tables(self):\\n print \\\"------------------\\\\nTables\\\\n------------------\\\"\\n cnt = 0\\n for x in self.show_tables():\\n cnt += 1\\n print (\\\"{0}.) {1}\\\".format(cnt, x[0]))\",\n \"def print_augmentation_functions(self):\\n for func in self.augmentation_functions:\\n print(func.__name__)\",\n \"def print_driver_list(outfile=None):\\n if not outfile:\\n outfile = sys.stdout\\n print(\\\"List of output drivers:\\\", file=outfile)\\n for drv in sorted(GenericDriver.drivers):\\n print(\\\" \\\", \\\"driver\\\", drv, file=outfile)\\n formats = GenericDriver.drivers[drv].driver_formats\\n default_fmt = formats[0]\\n for fmt in sorted(formats):\\n if fmt == default_fmt:\\n print(\\\" \\\", \\\" \\\", \\\"format\\\", fmt, '(driver default)', file=outfile)\\n else:\\n print(\\\" \\\", \\\" \\\", \\\"format\\\", fmt, file=outfile)\",\n \"def _PrintHelp(matches=None):\\n if not matches:\\n print(FLAGS)\\n else:\\n flags_by_module = FLAGS.flags_by_module_dict()\\n modules = sorted(flags_by_module)\\n regex = re.compile(matches)\\n for module_name in modules:\\n if regex.search(module_name):\\n print(FLAGS.module_help(module_name))\",\n \"def log_installed_python_prereqs():\\n sh(\\\"pip freeze > {}\\\".format(Env.GEN_LOG_DIR + \\\"/pip_freeze.log\\\"))\",\n \"def printhelp_01():\\n print('Convert simba3d report output from npz to .mat, or .json')\\n print('simba3d-convertion --ext_out [.mat, .json, .txt, or .pdb] <list of files>')\",\n \"def list_packages(pretty=False) -> Dict:\\n\\n packages = dict()\\n lp = Commands._list_packages()\\n inst_packages = lp.stdout.split('\\\\n')[:-1]\\n\\n for package in inst_packages:\\n name, version = package.split('==')[0], package.split('==')[1]\\n packages[name] = version\\n \\n if pretty:\\n import json\\n return json.dumps(packages, sort_keys=True, indent=4)\\n return packages\",\n \"def print_all_tables(self):\\n conn = self.connect()\\n cursor = conn.cursor()\\n cursor.execute(\\\"SELECT name FROM sqlite_master WHERE type='table';\\\")\\n print(cursor.fetchall())\",\n \"def print_version():\\n print(FULMAR_VERSION_STR)\\n return\",\n \"def _get_all_pkg_info(self):\\n all_pkgs = self._filter_pkgs(self._go_list(\\\"./...\\\"))\\n # for every package, list the deps, the test files, the test imports, and the external package test imports\\n big_list = self._go_list(\\n \\\"-f\\\", \\\"{{.ImportPath}}:{{.Deps}}:{{.TestImports}}:{{.XTestImports}}\\\", *all_pkgs)\\n recursive_deps = {}\\n test_imports = {}\\n\\n for line in big_list:\\n tokens = [token.strip().lstrip('[').rstrip(']').strip() for token in line.split(\\\":\\\", 3)]\\n pkg = tokens[0].strip()\\n\\n recursive_deps[pkg] = set(self._filter_pkgs(tokens[1].split() + [pkg]))\\n if tokens[2] or tokens[3]:\\n test_imports[pkg] = set(\\n self._filter_pkgs(tokens[2].split()) + self._filter_pkgs(tokens[3].split()))\\n\\n return recursive_deps, test_imports\",\n \"def print_products(self):\\n for f in self.files:\\n sys.stdout.write(\\n 'Detected File <{0}> {1} (EPSG: {2}){3}'.format(str(f), '1' if self.__check_projection(f) else '0',\\n str(self.__raster_epsg(f)), os.linesep))\",\n \"def print_products(self):\\n for f in self.files:\\n sys.stdout.write(\\n 'Detected File <{0}> {1} (EPSG: {2}){3}'.format(str(f), '1' if self.__check_projection(f) else '0',\\n str(self.__raster_epsg(f)), os.linesep))\",\n \"def test_print_version_repositories_SKIP(self):\\n self._uri({\\n '%d.%d/maintained/%d.%d-%d/%s/Packages.gz' % (MAJOR, MINOR, MAJOR, MINOR, 0, 'all'): DATA,\\n '%d.%d/maintained/%d.%d-%d/%s/Packages.gz' % (MAJOR, MINOR, MAJOR, MINOR, 0, ARCH): DATA,\\n })\\n tmp = self.u.print_version_repositories()\\n self.assertEqual(set((\\n 'deb file:///mock/%d.%d/maintained/ %d.%d-%d/%s/' % (MAJOR, MINOR, MAJOR, MINOR, 0, 'all'),\\n 'deb file:///mock/%d.%d/maintained/ %d.%d-%d/%s/' % (MAJOR, MINOR, MAJOR, MINOR, 0, ARCH),\\n )), set(tmp.splitlines()))\",\n \"def main():\\n# logging.basicConfig(level=logging.DEBUG)\\n try:\\n user = sys.ARGV[1]\\n except:\\n user = 'hmm01i'\\n repos = getRepos(user)\\n print(\\\"%i Personal Repos\\\" % len(repos))\\n logging.debug(repos)\\n #print(\\\"Repo,[size, last update]\\\")\\n #for k in repos.keys():\\n # print(str(k),repos[k])\",\n \"def list():\\n project_root = get_project_root()\\n config_file = os.path.join(project_root, CONFIG_DIR, CONFIG_FILE)\\n if os.path.exists(config_file):\\n kwargs = load_yaml_file(config_file)\\n if PACKAGE_INDEX_KEY in kwargs:\\n packages = load_yaml_url(kwargs[PACKAGE_INDEX_KEY])\\n # Should update and look in .carme/config\\n else:\\n packages = load_yaml_url(PACKAGE_INDEX)\\n\\n ruamel.yaml.dump(packages, sys.stdout, Dumper=ruamel.yaml.RoundTripDumper)\",\n \"def display_flavors(self):\\n for flavor in self.flavors:\\n print(f\\\"- {flavor}\\\")\",\n \"def have_package_lists():\\n return 'Filename:' in execute('apt-cache', 'show', 'python', check=False, capture=True)\",\n \"def getusersitepackages():\\n\\tpass\",\n \"def print_all(self) -> None:\\n\\n print(\\\"title: \\\" + str(self.title))\\n print(\\\"simple_title: \\\" + str(self.simple_title))\\n print(\\\"info: \\\" + str(self.info))\\n print(\\\"exists: \\\" + str(self.exists))\\n print(\\\"categories: \\\" + str(self.categories))\\n print(\\\"content: \\\" + str(self.content))\",\n \"def print_formulas(self):\\n for formula in self.formulas:\\n if formula:\\n print(formula)\",\n \"def getSetupPackages(self):\\n e = eups.Eups()\\n setupProducts = e.getSetupProducts()\\n a = \\\"\\\"\\n\\n # create a new list will all products and versions\\n allProducts = {}\\n for i in setupProducts:\\n allProducts[i.name] = i.version\\n\\n # replace any existing products that we saw on the command line, adding\\n # them if they're not already there.\\n if self.opts.setup is not None:\\n for i, pkg in enumerate(self.opts.setup):\\n name = pkg[0]\\n version = pkg[1]\\n print(\\\"name = %s, version = %s\\\" % (name, version))\\n allProducts[name] = version\\n\\n # write out all products, except those that are setup locally.\\n for name in allProducts:\\n version = allProducts[name]\\n if self.platform == \\\"lsst\\\":\\n a = a + \\\"setup -j %s %s\\\\\\\\n\\\\\\\\\\\\n\\\" % (name, version)\\n else:\\n if not version.startswith(\\\"LOCAL:\\\"):\\n a = a + \\\"setup -j %s %s\\\\\\\\n\\\\\\\\\\\\n\\\" % (name, version)\\n return a\",\n \"def print_info(args):\\n print(banner_small)\\n display_config_info()\\n\\n print(\\\"\\\")\\n print(\\\"Python Configuration\\\")\\n print(\\\"-\\\" * 25)\\n print(\\\"\\\")\\n info_calls = [\\\"which python3\\\", \\\"python3 --version\\\", \\\"which pip3\\\", \\\"pip3 --version\\\"]\\n info_str = \\\"\\\"\\n for x in info_calls:\\n info_str += 'echo \\\" $ ' + x + '\\\" && ' + x + \\\"\\\\n\\\"\\n info_str += \\\"echo \\\\n\\\"\\n info_str += r\\\"echo \\\\\\\"echo \\\\$PYTHONPATH\\\\\\\" && echo $PYTHONPATH\\\"\\n _ = subprocess.run(info_str, shell=True)\\n print(\\\"\\\")\",\n \"def print_all_descendants(self):\\n #self._print_all_descendants_rec(self, 0) # stdout version \\n string = \\\"|---\\\" + str(self) + \\\"\\\\n\\\"\\n return self._return_string_all_descendants_rec(self, string, 0)\",\n \"def get_installations():\\n github_app = get_default_app()\\n pprint(github_app.get_installations())\",\n \"def print_networks(self, verbose: bool) -> None:\\n print('---------- Networks initialized -------------')\\n for name, module in self.modules.items():\\n num_params = 0\\n for param in module.parameters():\\n num_params += param.numel()\\n if verbose:\\n print(module)\\n print('[Network %s] Total number of parameters: %.3f M' % (name, num_params / 1e6))\\n print('-----------------------------------------------')\\n return\",\n \"def showtopologies():\\n middleware.protocolObj.showTopologies()\",\n \"def print_networks(networks):\\r\\n\\tlogging.info('-'*80)\\r\\n\\tfor network in networks:\\r\\n\\t\\tprint(network)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6903446","0.6681349","0.64860743","0.6483986","0.64436895","0.63718176","0.6362368","0.62700814","0.62351704","0.6204767","0.6189284","0.61830366","0.61695254","0.6160334","0.6057463","0.6053403","0.6039349","0.5968796","0.5965892","0.5961952","0.59532803","0.5946831","0.59426504","0.59075403","0.58807504","0.58419687","0.5835895","0.5812998","0.5797266","0.579549","0.5774143","0.57402676","0.57305324","0.57273495","0.5710357","0.5705807","0.57038766","0.5684046","0.56827575","0.5655397","0.56140625","0.5613823","0.56074136","0.5600593","0.5568726","0.55608284","0.55569214","0.5540467","0.5539622","0.5527045","0.5526976","0.5489924","0.548602","0.54751676","0.54684275","0.54633456","0.5446159","0.5441936","0.5438888","0.5434751","0.5434751","0.54238665","0.54109037","0.5404349","0.5404349","0.53977543","0.53940463","0.53822845","0.5373328","0.5356859","0.53412354","0.53403974","0.5336817","0.5334906","0.5334439","0.5330402","0.5329276","0.5322632","0.53186995","0.5314473","0.53072625","0.52883065","0.5283222","0.528177","0.528177","0.5279185","0.5279156","0.5266333","0.526302","0.5251985","0.5251903","0.5247745","0.52311873","0.5221814","0.52182657","0.52173823","0.52137756","0.5207993","0.52072465","0.52037627"],"string":"[\n \"0.6903446\",\n \"0.6681349\",\n \"0.64860743\",\n \"0.6483986\",\n \"0.64436895\",\n \"0.63718176\",\n \"0.6362368\",\n \"0.62700814\",\n \"0.62351704\",\n \"0.6204767\",\n \"0.6189284\",\n \"0.61830366\",\n \"0.61695254\",\n \"0.6160334\",\n \"0.6057463\",\n \"0.6053403\",\n \"0.6039349\",\n \"0.5968796\",\n \"0.5965892\",\n \"0.5961952\",\n \"0.59532803\",\n \"0.5946831\",\n \"0.59426504\",\n \"0.59075403\",\n \"0.58807504\",\n \"0.58419687\",\n \"0.5835895\",\n \"0.5812998\",\n \"0.5797266\",\n \"0.579549\",\n \"0.5774143\",\n \"0.57402676\",\n \"0.57305324\",\n \"0.57273495\",\n \"0.5710357\",\n \"0.5705807\",\n \"0.57038766\",\n \"0.5684046\",\n \"0.56827575\",\n \"0.5655397\",\n \"0.56140625\",\n \"0.5613823\",\n \"0.56074136\",\n \"0.5600593\",\n \"0.5568726\",\n \"0.55608284\",\n \"0.55569214\",\n \"0.5540467\",\n \"0.5539622\",\n \"0.5527045\",\n \"0.5526976\",\n \"0.5489924\",\n \"0.548602\",\n \"0.54751676\",\n \"0.54684275\",\n \"0.54633456\",\n \"0.5446159\",\n \"0.5441936\",\n \"0.5438888\",\n \"0.5434751\",\n \"0.5434751\",\n \"0.54238665\",\n \"0.54109037\",\n \"0.5404349\",\n \"0.5404349\",\n \"0.53977543\",\n \"0.53940463\",\n \"0.53822845\",\n \"0.5373328\",\n \"0.5356859\",\n \"0.53412354\",\n \"0.53403974\",\n \"0.5336817\",\n \"0.5334906\",\n \"0.5334439\",\n \"0.5330402\",\n \"0.5329276\",\n \"0.5322632\",\n \"0.53186995\",\n \"0.5314473\",\n \"0.53072625\",\n \"0.52883065\",\n \"0.5283222\",\n \"0.528177\",\n \"0.528177\",\n \"0.5279185\",\n \"0.5279156\",\n \"0.5266333\",\n \"0.526302\",\n \"0.5251985\",\n \"0.5251903\",\n \"0.5247745\",\n \"0.52311873\",\n \"0.5221814\",\n \"0.52182657\",\n \"0.52173823\",\n \"0.52137756\",\n \"0.5207993\",\n \"0.52072465\",\n \"0.52037627\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7438773"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21999,"cells":{"query":{"kind":"string","value":"Print the Rez packages that were skipped automatically by this tool. Skipped packages differ from \"invalid\" packages in that they are \"valid Rez packages but just don't need the command run on\". Ignored packages are Rez packages that the user explicitly said to not process. Skipped packages are packages that the user may have meant to process but this tool could not (for some reason or another)."},"document":{"kind":"string","value":"def _print_skips(skips, verbose):\n if not skips:\n print(\"## No packages were skipped\")\n print(\"Every found Rez package can be processed by the command.\")\n\n return\n\n print(\"## Packages were skipped from running a command. Here's the full list:\")\n\n template = \"{issue.package.name}: {issue.reason}\"\n\n if verbose:\n template = \"{issue.package.name}: {issue.path}: {issue.reason}\"\n\n for issue in skips:\n print(template.format(issue=issue))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _print_ignored(packages):\n if not packages:\n print(\"## No Rez package was set to be ignored\")\n print(\"No data found\")\n\n return\n\n print(\"## Every package in this list was explicitly set to ignored by the user\")\n\n for package, pattern in sorted(packages, key=_get_package_name):\n print(\n 'Package: {package.name} - Pattern: \"{pattern}\"'.format(\n package=package, pattern=pattern\n )\n )","def _print_missing(packages, verbose):\n if not packages:\n print(\"## No Rez packages were found.\")\n print(\"No data found\")\n\n return\n\n print(\"## Your command affects these Rez packages.\")\n\n template = \"{package.name}\"\n\n if verbose:\n template = \"{package.name}: {path}\"\n\n for line in sorted(\n template.format(package=package, path=finder.get_package_root(package))\n for package in packages\n ):\n print(line)","def print_test_deps_not_in_package_deps(self):\n extras = []\n for key, rec_deps in self.recursive_pkg_deps.items():\n any = self.test_imports.get(key, set()).difference(rec_deps, set([key]))\n if any:\n extras.append((key, any))\n\n if extras:\n print(\"Packages whose tests have extra dependencies not listed in `go list -f {{.Deps}}`:\")\n for pkg, deps in extras:\n print(\"\\t{0}: {1}\".format(pkg, \", \".join(deps)))\n print(\"\\n\")","def show_missing():\n if missing_modules:\n info(\"The following modules are currently not installed and would enable additional tasks:\")\n for pkg_name in missing_modules:\n info(' ' + pkg_name)","def sort_packages(self) -> None:\n self.recommended_packages = []\n self.required_packages = []\n for package in self.repository_packages:\n try:\n output = self.guest.execute(Command('rpm', '-q', package), silent=True)\n assert output.stdout\n self.debug(f\"Package '{output.stdout.strip()}' already installed.\")\n except tmt.utils.RunError:\n if self.skip_missing:\n self.recommended_packages.append(package)\n else:\n self.required_packages.append(package)","def missing_requirements_command(args, packages=None, exit_on_failure=True):\n requirements_files = (\n args.requirements or Config.requirements_files or []\n )\n ignore_list = (\n args.ignore or Config.ignore_list or []\n )\n\n printer = Printer()\n if not validate_files(\n files=requirements_files,\n printer=printer,\n exit_on_failure=exit_on_failure):\n return False\n\n requirements = RequirementCollection()\n for requirements_file in requirements_files:\n requirements.extend(\n RequirementCollection.from_file(filepath=requirements_file)\n )\n\n packages = (\n packages or dependency_list(ignore_list=ignore_list)\n )\n\n missing = [\n (package, required_by)\n for package, required_by\n in missing_requirements(\n packages=packages,\n requirements=requirements,\n ignore_list=ignore_list\n )\n ]\n\n headers = [\n messages.PACKAGE,\n messages.REQUIRED,\n messages.REQUIRED_BY,\n ]\n\n tabular_data = []\n for package, requirers in missing:\n if requirers:\n for required_by, required_version in requirers:\n tabular_data.append([\n printer.colored_message(\n message=package.key,\n message_color=printer.color_package\n ),\n required_version,\n required_by.key,\n ])\n else:\n tabular_data.append([\n printer.colored_message(\n message=package.key,\n message_color=printer.color_package\n ),\n package.version.specifier,\n \"Requirements\",\n ])\n\n if tabular_data:\n printer.error(messages.MISSING_FOUND)\n printer.table(headers=headers, tabular_data=tabular_data)\n if exit_on_failure:\n sys.exit(1)\n return False\n\n printer.success(messages.MISSING_OK)\n return True","def test_print_version_repositories_SKIP(self):\n self._uri({\n '%d.%d/maintained/%d.%d-%d/%s/Packages.gz' % (MAJOR, MINOR, MAJOR, MINOR, 0, 'all'): DATA,\n '%d.%d/maintained/%d.%d-%d/%s/Packages.gz' % (MAJOR, MINOR, MAJOR, MINOR, 0, ARCH): DATA,\n })\n tmp = self.u.print_version_repositories()\n self.assertEqual(set((\n 'deb file:///mock/%d.%d/maintained/ %d.%d-%d/%s/' % (MAJOR, MINOR, MAJOR, MINOR, 0, 'all'),\n 'deb file:///mock/%d.%d/maintained/ %d.%d-%d/%s/' % (MAJOR, MINOR, MAJOR, MINOR, 0, ARCH),\n )), set(tmp.splitlines()))","def test_collect_playbooks_dependencies_skip_unavailable(self, module_repo):\n expected_result = {\n # playbooks:\n (\"Slack\", False),\n (\"Indeni\", True),\n # integrations:\n (\"FeedAlienVault\", False),\n (\"ipinfo\", True),\n (\"FeedAutofocus\", True),\n # scripts:\n (\"GetServerURL\", False),\n (\"HelloWorld\", True),\n }\n test_input = [\n {\n \"Dummy Playbook\": {\n \"name\": \"Dummy Playbook\",\n \"file_path\": \"dummy_path\",\n \"fromversion\": \"dummy_version\",\n \"implementing_scripts\": [\n \"GetServerURL\",\n \"HelloWorldScript\",\n ],\n \"implementing_playbooks\": [\n \"Failed Login Playbook - Slack v2\",\n \"Indeni Demo\",\n ],\n \"command_to_integration\": {\n \"alienvault-get-indicators\": \"\",\n \"ip\": \"ipinfo\",\n \"autofocus-get-indicators\": \"\",\n },\n \"tests\": [\"dummy_playbook\"],\n \"pack\": \"dummy_pack\",\n \"incident_fields\": [],\n \"skippable_tasks\": [\n \"Print\",\n \"Failed Login Playbook - Slack v2\",\n \"alienvault-get-indicators\",\n \"GetServerURL\",\n ],\n }\n },\n ]\n\n found_result = PackDependencies._collect_playbooks_dependencies(\n pack_playbooks=test_input,\n id_set=module_repo.id_set.read_json_as_dict(),\n )\n\n assert set(found_result) == set(expected_result)","def show_packagelist(user, repo, packages, distro=False, version=False,\n name=False, match=False, pkgtype=False):\n\n print('Currently {}/{} contains these matching packages:'.format(\n user, repo))\n\n numpkgs = 0\n for package in packages:\n if (distro and not package['distro_version'] == distro) or \\\n (version and not package['version'] == version) or \\\n (name and not package['name'] == name) or \\\n (pkgtype and not package['type'] == pkgtype) or \\\n (match and match not in package['filename']):\n continue\n\n print(fmt_pkg(user, repo, package))\n numpkgs += 1\n\n print(\"Repo contains {} matching packages.\".format(numpkgs))","def get_not_installed_rpm_packages():\n def is_installed(elem):\n return elem in PMDK_TOOLS and elem in listdir('/usr/bin/') or\\\n elem == \"pmdk\" or elem + '.so' in listdir('/usr/lib64/')\n\n elements = get_libraries_names()\n not_installed_packages = []\n for elem in elements:\n if not is_installed(elem):\n not_installed_packages.append(elem)\n return not_installed_packages","def __report(arguments, _):\n ignored_packages, other_packages, invalid_packages, skips = __gather_package_data(\n arguments\n )\n\n packages, invalids = worker.report(\n other_packages,\n maximum_repositories=arguments.maximum_repositories,\n maximum_rez_packages=arguments.maximum_rez_packages,\n )\n\n invalids.extend(invalid_packages)\n\n _print_ignored(ignored_packages)\n print(\"\\n\")\n _print_skips(skips, arguments.verbose)\n print(\"\\n\")\n _print_invalids(invalids, arguments.verbose)\n print(\"\\n\")\n _print_missing(packages, arguments.verbose)\n\n sys.exit(0)","def _print_invalids(invalids, verbose):\n if not invalids:\n print(\"## No Rez package was set as invalid.\")\n print(\"Nothing is invalid. Which is a good thing!\")\n\n return\n\n print(\"## Some packages were marked as invalid. Here's why:\")\n\n template = \"{package.name}: {message}\"\n\n if verbose:\n template = \"{package.name}: {path} {message}: {full}\"\n\n for message in sorted(\n (\n template.format(\n package=error.get_package(),\n path=error.get_path(),\n message=str(error),\n full=error.get_full_message(),\n )\n for error in invalids\n )\n ):\n print(message)","def test_packages(self):\n for pkg in self.expected_packages:\n status, output = commands.getstatusoutput('pkg_info -qx %s' % pkg)\n assert status == 0","def getMissingPackages(self, language=None, all=False, packages=None, showInstalled=False):\n if self._cache.broken_count > 0:\n raise SoftwareIndexBroken\n \n self.langpack_locales = {}\n self.pkg_translations = {}\n self.pkg_writing = {}\n filter_list = {}\n blacklist = []\n show = []\n self.missing = set()\n self.installed = set()\n self.system_pkgcode = ''\n \n for l in open(self.BLACKLIST):\n l = l.strip()\n if not l.startswith('#'):\n blacklist.append(l)\n \n for l in open(self.LANGCODE_TO_LOCALE):\n try:\n l = l.rstrip()\n if ':' in l:\n (pkgcode, locale) = l.split(':')\n else:\n pkgcode = l\n locale = l\n except ValueError:\n continue\n self.langpack_locales[locale] = pkgcode\n \n for l in open(self.PACKAGE_DEPENDS):\n if l.startswith('#'):\n continue\n try:\n l = l.rstrip()\n # sort out comments\n if l.find('#') >= 0:\n continue\n (c, lc, k, v) = l.split(':')\n except ValueError:\n continue\n if (c == 'tr' and lc == ''):\n filter_list[v] = k\n elif (c == 'wa' and lc != ''):\n if '|' in lc:\n for l in lc.split('|'):\n if not l in self.pkg_writing:\n self.pkg_writing[l] = []\n self.pkg_writing[l].append((\"%s\" % k, \"%s\" % v))\n else:\n if not lc in self.pkg_writing:\n self.pkg_writing[lc] = []\n self.pkg_writing[lc].append((\"%s\" % k, \"%s\" % v))\n\n # get list of all packages available on the system and filter them\n for item in self._cache.keys():\n if item in blacklist: \n continue\n for x in filter_list.keys():\n if item.startswith(x) and not item.endswith('-base'):\n # parse language code\n langcode = item.replace(x, '')\n #print \"%s\\t%s\" % (item, langcode)\n if langcode == 'zh':\n # special case: zh langpack split\n for langcode in ['zh-hans', 'zh-hant']:\n if not langcode in self.pkg_translations:\n self.pkg_translations[langcode] = []\n self.pkg_translations[langcode].append((\"%s\" % filter_list[x], \"%s\" % item))\n elif langcode in self.langpack_locales.values():\n # langcode == pkgcode\n if not langcode in self.pkg_translations:\n self.pkg_translations[langcode] = []\n self.pkg_translations[langcode].append((\"%s\" % filter_list[x], \"%s\" % item))\n #print self.pkg_translations[langcode]\n else:\n # need to scan for LL-CC and LL-VARIANT codes\n for locale in self.langpack_locales.keys():\n if '_' in locale or '@' in locale:\n if '@' in locale:\n (locale, variant) = locale.split('@')\n else:\n variant = ''\n (lcode, ccode) = locale.split('_')\n if langcode in [\"%s-%s\" % (lcode, ccode.lower()),\n \"%s%s\" % (lcode, ccode.lower()),\n \"%s-%s\" % (lcode, variant),\n \"%s%s\" % (lcode, variant),\n \"%s-latn\" % lcode,\n \"%slatn\" % lcode,\n \"%s-%s-%s\" % (lcode, ccode.lower(), variant),\n \"%s%s%s\" % (lcode, ccode.lower(), variant)]:\n # match found, get matching pkgcode\n langcode = self.langpack_locales[locale]\n if not langcode in self.pkg_translations:\n self.pkg_translations[langcode] = []\n self.pkg_translations[langcode].append((\"%s\" % filter_list[x], \"%s\" % item))\n #print self.pkg_translations[langcode]\n break\n\n if language:\n pkgcode = ''\n if language == 'zh-hans' or language == 'zh-hant':\n self.system_pkgcode = language\n elif language in self.langpack_locales:\n self.system_pkgcode = self.langpack_locales[language]\n else:\n # pkgcode = ll\n if '_' in language:\n (self.system_pkgcode) = language.split('_')[0]\n elif '@' in language:\n (self.system_pkgcode) = language.split('@')[0]\n else:\n self.system_pkgcode = language\n\n if packages:\n self.findPackages(self.system_pkgcode, packages)\n else:\n self.findPackages(self.system_pkgcode)\n \n elif all:\n # try all available languages\n pkgcodes = []\n for item in self._cache.keys():\n if item in blacklist:\n continue\n if item.startswith('language-pack-') and \\\n not item.startswith('language-pack-gnome') and \\\n not item.startswith('language-pack-kde') and \\\n not item.endswith('-base'):\n pkgcode = item.replace('language-pack-', '')\n pkgcodes.append(pkgcode)\n\n for pkgcode in pkgcodes:\n if packages:\n self.findPackages(pkgcode, packages)\n else:\n self.findPackages(pkgcode)\n\n else:\n # get a list of language-packs we have already installed or are going to install\n # 1. system locale\n system_langcode = self._localeinfo.getSystemDefaultLanguage()[0]\n if system_langcode == None:\n system_langcode = 'en_US'\n if system_langcode in self.langpack_locales:\n self.system_pkgcode = self.langpack_locales[system_langcode]\n # 2. installed language-packs\n pkgcodes = []\n for item in self._cache.keys():\n if item in blacklist: \n continue\n if item.startswith('language-pack-') and \\\n not item.startswith('language-pack-gnome') and \\\n not item.startswith('language-pack-kde') and \\\n not item.endswith('-base') and \\\n (self._cache[item].is_installed or \\\n self._cache[item].marked_install):\n pkgcode = item.replace('language-pack-', '')\n pkgcodes.append(pkgcode)\n if self.system_pkgcode and \\\n not self.system_pkgcode in pkgcodes:\n pkgcodes.append(self.system_pkgcode)\n \n for pkgcode in pkgcodes:\n if packages:\n self.findPackages(pkgcode, packages)\n else:\n self.findPackages(pkgcode)\n \n if showInstalled:\n show = self.missing | self.installed\n else:\n show = self.missing\n\n return show","def have_package_lists():\n return 'Filename:' in execute('apt-cache', 'show', 'python', check=False, capture=True)","def required_packages(cls) -> List[Text]:\n return []","def _list_dependencies_info(\n out: Callable, ljust: int, package: str, dependencies: List[Requirement]\n):\n unicode = sys.stdout.encoding.lower().startswith(\"utf\")\n if unicode:\n ljust += 1\n\n not_found: List[Requirement] = list()\n for dep in dependencies:\n if dep.name == package:\n continue\n try:\n version_ = version(dep.name)\n except Exception:\n not_found.append(dep)\n continue\n\n # build the output string step by step\n output = f\"✔︎ {dep.name}\" if unicode else dep.name\n # handle version specifiers\n if len(dep.specifier) != 0:\n output += f\" ({str(dep.specifier)})\"\n output += \":\"\n output = output.ljust(ljust) + version_\n\n # handle special dependencies with backends, C dep, ..\n if dep.name in (\"matplotlib\", \"seaborn\") and version_ != \"Not found.\":\n try:\n from matplotlib import pyplot as plt\n\n backend = plt.get_backend()\n except Exception:\n backend = \"Not found\"\n\n output += f\" (backend: {backend})\"\n out(output + \"\\n\")\n\n if len(not_found) != 0:\n not_found = [\n f\"{dep.name} ({str(dep.specifier)})\"\n if len(dep.specifier) != 0\n else dep.name\n for dep in not_found\n ]\n if unicode:\n out(f\"✘ Not installed: {', '.join(not_found)}\\n\")\n else:\n out(f\"Not installed: {', '.join(not_found)}\\n\")","def test_correctness_of_installed_rpm_packages(self):\n not_installed_packages = get_not_installed_rpm_packages()\n error_msg = linesep + 'List of not installed packages: '\n for package in not_installed_packages:\n error_msg += linesep + package\n self.assertFalse(not_installed_packages, error_msg)","def unsatisfied_requirements(buildout, package, working_set):\n\n # read all lines from \"requirements.txt\"\n specs = [k.strip() for k in package_readlines(package, 'requirements.txt')]\n\n # discard empty lines and comments\n specs = [k for k in specs if k and k[0] not in ('#', '-')]\n\n # do not consider packages which are already installed, with a reasonable\n # version matching the user specification, either on the current working\n # set, the installed eggs or the system paths\n newest = bool_option(buildout, 'newest', 'true')\n\n left_over = []\n for k in specs:\n if requirement_is_satisfied(k, working_set, newest):\n dist = working_set.require(k)[0]\n logger.info(\"taking requirement `%s' (%s) from `%s'\", dist.key,\n dist.version, dist.location)\n else:\n left_over.append(k)\n specs = left_over\n\n return left_over","def check_missing_dep():\n global MISSING_PACKAGES, INSTALLED_PACKAGES, ENABLE_CUDA\n if ENABLE_CUDA and IS_MACOS:\n REQUIRED_PACKAGES.extend(MACOS_REQUIRED_PACKAGES)\n MISSING_PACKAGES = []\n for pkg in REQUIRED_PACKAGES:\n key = pkg.split(\"==\")[0]\n if key not in INSTALLED_PACKAGES:\n MISSING_PACKAGES.append(pkg)\n continue\n else:\n if len(pkg.split(\"==\")) > 1:\n if pkg.split(\"==\")[1] != INSTALLED_PACKAGES.get(key):\n MISSING_PACKAGES.append(pkg)\n continue","def do_seeSkipList(self, args):\n sl.showList()","def show_keep(self, command=\"show-keep\"):\n # execute pkgin\n popen = Popen([self.pkgin_bin, \"-P\", command], stdout=PIPE, stderr=PIPE)\n # retrieve output streams\n (stdoutdata, stderrdata) = popen.communicate()\n # if pkgin error\n if(stderrdata):\n # remove the line feed\n error = stderrdata[0:-1]\n raise PykginError(error)\n # retrieve output\n output = stdoutdata\n # create a list which contain each packages\n output_whole_list = output.split('\\n')\n # remove last element (due to the last \\n)\n output_whole_list.pop()\n # create a new list in which package informations are separate\n output_list = []\n for pkg in output_whole_list:\n current = pkg.split(' ', 1)\n output_list.append(self.__extract_package_version(current[0]))\n\n return output_list","def main():\n\n local_pkgs = set(os.listdir(GIT_FOLDER))\n local_pkgs = set([it.replace('.git', '') for it in local_pkgs])\n\n pkgdb_info = pkgdb_pkg_branch()\n\n pkgdb_pkgs = set(pkgdb_info.keys())\n\n ## Commented out as we keep the git of retired packages while they won't\n ## show up in the information retrieved from pkgdb.\n\n #if (local_pkgs - pkgdb_pkgs):\n #print 'Some packages are present locally but not on pkgdb:'\n #print ', '.join(sorted(local_pkgs - pkgdb_pkgs))\n\n if (pkgdb_pkgs - local_pkgs):\n print 'Some packages are present in pkgdb but not locally:'\n print ', '.join(sorted(pkgdb_pkgs - local_pkgs))\n\n tofix = set()\n for pkg in sorted(pkgdb_info):\n pkgdb_branches = pkgdb_info[pkg]\n git_branches = get_git_branch(pkg)\n diff = (pkgdb_branches - git_branches)\n if diff:\n print '%s missing: %s' % (pkg, ','.join(sorted(diff)))\n tofix.add(pkg)\n branch_package(pkg, diff)\n\n if tofix:\n print 'Packages fixed (%s): %s' % (\n len(tofix), ', '.join(sorted(tofix)))","def skip_check():\n if os.getenv('LEAPP_DEVEL_SKIP_CHECK_OS_RELEASE'):\n reporting.create_report([\n reporting.Title('Skipped OS release check'),\n reporting.Summary('Source RHEL release check skipped via LEAPP_DEVEL_SKIP_CHECK_OS_RELEASE env var.'),\n reporting.Severity(reporting.Severity.HIGH),\n reporting.Groups(COMMON_REPORT_TAGS)\n ] + related)\n\n return True\n return False","def print_dependencies(_run):\n print('Sources:')\n for source, digest in _run.experiment_info['sources']:\n print(' {:<43} {}'.format(source, digest))\n\n print('\\nDependencies:')\n for pack, version in _run.experiment_info['dependencies']:\n print(' {:<20} >= {}'.format(pack, version))","def print_dependencies(pkg):\n\n for deptype in (\"build\", \"link\", \"run\"):\n color.cprint(\"\")\n color.cprint(section_title(\"%s Dependencies:\" % deptype.capitalize()))\n deps = sorted(pkg.dependencies_of_type(deptype))\n if deps:\n colify(deps, indent=4)\n else:\n color.cprint(\" None\")","def run_skip(self):\n pass","def missing_tests(session):\n print('The following samples do not have tests:')\n for sample in set(ALL_SAMPLE_DIRECTORIES) - set(ALL_TESTED_SAMPLES):\n print('* {}'.format(sample))","def CheckForUnknownFiles(self):\n unknown_files = self.GetUnknownFiles()\n if unknown_files:\n print \"The following files are not added to version control:\"\n for line in unknown_files:\n print line\n prompt = \"Are you sure to continue?(y/N) \"\n answer = raw_input(prompt).strip()\n if answer != \"y\":\n ErrorExit(\"User aborted\")","def FindMissingBinaries(needed_tools):\n return [binary for binary in needed_tools if Which(binary) is None]","def print_skipped(self,result,cause=False):\n skipped = result.get_skipped()\n if skipped:\n print ('=== SKIPPED '+('='*59))\n for u in skipped:\n print (u.id)\n if cause:\n print (' ',u.get_cause())","def skip_test(reason):\n global test_name_text\n print \"SKIP {}: {}\\n\".format(test_name_text, reason)\n sys.exit(0)","def list_packages(self):\n for tag, pkg in PACKAGES.iteritems():\n print \"{tag} - {label}\".format(tag=tag, label=pkg['label'])","def __gather_package_data(arguments):\n ignore_patterns, packages_path, search_packages_path = _resolve_arguments(\n arguments.ignore_patterns,\n arguments.packages_path,\n arguments.search_packages_path,\n )\n rez_packages = set(arguments.rez_packages)\n\n package_finder = registry.get_package_finder(arguments.command)\n\n found_packages = []\n packages, invalid_packages, skips = package_finder(\n paths=packages_path + search_packages_path\n )\n\n for package in packages:\n if rez_packages and package.name not in rez_packages:\n skips.append(package)\n else:\n found_packages.append(package)\n\n ignored_packages, other_packages = _split_the_ignored_packages(\n found_packages, ignore_patterns\n )\n\n other_packages = sorted(other_packages, key=operator.attrgetter(\"name\"))\n\n return ignored_packages, other_packages, invalid_packages, skips","def report(*packages):\n accepted_commands = ['python','conda']\n for package in packages:\n loc = \"not installed in this environment\"\n ver = \"unknown\"\n\n try:\n module = importlib.import_module(package)\n loc = os.path.dirname(module.__file__)\n\n try:\n ver = str(module.__version__)\n except Exception:\n pass\n \n except (ImportError, ModuleNotFoundError):\n if package in accepted_commands:\n try:\n # See if there is a command by that name and check its --version if so\n try:\n loc = subprocess.check_output(['command','-v', package]).decode().splitlines()[0].strip()\n except:\n # .exe in case powershell (otherwise wouldn't need it)\n loc = subprocess.check_output(['where.exe', package]).decode().splitlines()[0].strip() \n out = \"\"\n try:\n out = subprocess.check_output([package, '--version'], stderr=subprocess.STDOUT)\n except subprocess.CalledProcessError as e:\n out = e.output\n\n # Assume first word in output with a period and digits is the version\n for s in out.decode().split():\n if '.' in s and str.isdigit(s[0]) and sum(str.isdigit(c) for c in s)>=2:\n ver=s.strip()\n break\n except:\n pass\n elif package == 'system':\n try:\n ver = platform.platform(terse=True)\n loc = \"OS: \" + platform.platform()\n except Exception:\n pass\n else:\n pass\n \n print(\"{0:30} # {1}\".format(package + \"=\" + ver,loc))","def missing_dependencies_by_extra(package=\"sunpy\", exclude_extras=None):\n exclude_extras = exclude_extras or []\n requirements = get_requirements(package)\n missing_dependencies = {}\n for group in requirements.keys():\n if group in exclude_extras:\n continue\n missing_dependencies[group] = find_dependencies(package, [group])[0]\n return missing_dependencies","def missing_required(self):\n outstanding = list(set(self.required).difference(list(self._runopts.keys())))\n return outstanding","def __run(arguments, command_arguments): # pylint: disable=too-many-locals\n ignored_packages, other_packages, invalid_packages, skips = __gather_package_data(\n arguments\n )\n\n command = registry.get_command(arguments.command)\n\n packages, un_ran, invalids = worker.run(\n functools.partial(command.run, arguments=command_arguments),\n other_packages,\n maximum_repositories=arguments.maximum_repositories,\n maximum_rez_packages=arguments.maximum_rez_packages,\n keep_temporary_files=arguments.keep_temporary_files,\n temporary_directory=arguments.temporary_directory,\n )\n\n invalids.extend(invalid_packages)\n\n # TODO : Change `Skip` into a class and make it the same interface as an exception\n # so that I can easily print both types at the same time, here\n #\n bads = invalids + skips\n\n if bads:\n print(\"Some packages are invalid or had to be skipped.\")\n print(\"\\n\")\n print(sorted(error.get_package().name for error in bads))\n\n if un_ran:\n print(\"These packages could not be run on:\")\n\n for package, error in sorted(un_ran, key=_get_package_name):\n print(\n \"{package.name}: {error}\".format(\n package=package, error=str(error) or \"No found error message\"\n )\n )\n\n sys.exit(cli_constant.UN_RAN_PACKAGES_FOUND)\n\n if packages:\n print(\"These packages were modified successfully:\")\n\n for package in sorted(packages, key=operator.attrgetter(\"name\")):\n print(package.name)","def get_labels_to_skip(self):\n def _labels_from_question(question):\n ret = {\n question.get('label_ref'),\n question.get('constraintMsg_ref'),\n }\n if question.get('options'):\n for option in question['options']:\n ret.add(option.get('label_ref'))\n return ret\n\n labels_to_skip = defaultdict(set)\n necessary_labels = defaultdict(set)\n\n for module in self.app.get_modules():\n for form in module.get_forms():\n questions = form.get_questions(self.app.langs, include_triggers=True,\n include_groups=True, include_translations=True)\n for question in questions:\n if not question.get('label_ref'):\n continue\n if question['comment'] and SKIP_TRANSFEX_STRING in question['comment']:\n labels_to_skip[form.unique_id] |= _labels_from_question(question)\n else:\n necessary_labels[form.unique_id] |= _labels_from_question(question)\n\n for form_id in labels_to_skip.keys():\n labels_to_skip[form_id] = labels_to_skip[form_id] - necessary_labels[form_id]\n\n return labels_to_skip","def check_dependencies(work_dir, fits_dir, fitsbase):\n # Print to screen what processing steps have been selected\n print \"The following processing steps have been selected:\\n\"\n if params.do_rfifind:\n print \" - PRESTO rfifind (RFI mitigation tools)\"\n if params.do_prepsub:\n print \" - PRESTO prepsubband (dedispersion)\"\n if params.do_candsearch:\n print \" - PRESTO acceleration search and candidate sifting\"\n if params.do_presto_sp:\n print \" - PRESTO singlepulse search (singlepulse.py)\"\n # Print to screen what processing steps are being skipped\n print \"\\nThe following processing steps are being skipped:\\n\"\n if params.do_rfifind == 0:\n print \" - PRESTO rfifind (RFI mitigation tools)\"\n if params.do_prepsub == 0:\n print \" - PRESTO prepsubband (dedispersion)\"\n if params.do_candsearch == 0:\n print \" - PRESTO acceleration search and candidate sifting\"\n if params.do_presto_sp == 0:\n print \" - PRESTO singlepulse search (singlepulse.py)\"\n print \"\\nChecking dependencies...\\n\"\n # There must be at least one .fits file in the fits directory\n fl = glob(fits_dir + '/%s*.fits' %fitsbase)\n if len(fl):\n print \" Found %d file(s) in %s:\\n\" %(len(fl), fits_dir)\n for i in fl:\n print \" %s\\n\" %(i.split('/')[-1])\n else:\n print \" No %s*.fits files found in %s !\\n Exiting...\\n\" %(fitsbase, fits_dir)\n sys.exit(0)\n # If skipping the RFIFIND step in processing but want to do\n # processing steps further down the line, then there must be a\n # rfi_products folder in the results directory with a .mask file\n # in it\n if params.do_rfifind == 0 and params.use_mask and \\\n (params.do_prepsub or params.do_candsearch or params.do_presto_sp):\n mlist = glob(work_dir + '/rfi_products/*.mask')\n if len(mlist):\n print \" Using RFI .mask:\\n %s\\n\" %(mlist[0])\n else:\n print \" No RFI .mask found in %s/rfi_products!\\n Exiting...\\n\"\\\n %(work_dir)\n sys.exit(0)\n # If skipping the PREPSUBBAND step in processing but want to\n # do processing steps further down the line, then there must be\n # de-dispersed time series files in the results directory of\n # the form basename*DM*.dat and basename*DM*.inf\n if params.do_prepsub == 0 and (params.do_candsearch or \n params.do_presto_sp):\n dats = glob(work_dir + '/*DM*dat')\n infs = glob(work_dir + '/*DM*inf')\n if not (len(dats) and len(infs)):\n print \" No .dat and/or .inf files in %s!\\n Exiting...\\n\" %(work_dir)\n sys.exit(0)\n # If we haven't exited by now, then things should be good\n print \"\\nLooks good...\\n\\n\"\n # Pause for a few seconds so you can actually read the output\n time.sleep(5)","def CheckForUnknownFiles(self):\r\n unknown_files = self.GetUnknownFiles()\r\n if unknown_files:\r\n print \"The following files are not added to version control:\"\r\n for line in unknown_files:\r\n print line\r\n prompt = \"Are you sure to continue?(y/N) \"\r\n answer = raw_input(prompt).strip()\r\n if answer != \"y\":\r\n ErrorExit(\"User aborted\")","def getMissingLangPacks(self):\n missing = []\n for langInfo in self._cache.getLanguageInformation():\n #print langInfo.languageCode\n trans_package = \"language-pack-%s\" % langInfo.languageCode\n # we have a langpack installed, see if we have all of them\n if (self._cache.has_key(trans_package) and \n self._cache[trans_package].isInstalled):\n #print \"IsInstalled: %s \" % trans_package\n for (pkg, translation) in self._cache.pkg_translations:\n missing += self.missingTranslationPkgs(pkg, translation+langInfo.languageCode)\n\n # now check for a missing default language support\n default_lang = self.getSystemDefaultLanguage()\n # if there is no default lang, return early\n if default_lang is None:\n return missing\n if \"_\" in default_lang:\n default_lang = default_lang.split(\"_\")[0]\n trans_package = \"language-pack-%s\" % default_lang\n if (self._cache.has_key(trans_package) and \n not self._cache[trans_package].isInstalled):\n missing += [trans_package]\n for (pkg, translation) in self._cache.pkg_translations:\n missing += self.missingTranslationPkgs(pkg, translation+default_lang)\n support_packages = LanguageSelectorPkgCache._getPkgList(self._cache, default_lang)\n for support_package in support_packages:\n if (self._cache.has_key(support_package) and \n not self._cache[support_package].isInstalled):\n missing.append(support_package)\n\n return missing","def calculate_missing(base_pkg, missing, file_deps, use_test_depends=False):\n rospack = rospkg.RosPack()\n for launch_file in file_deps.keys():\n pkg = rospkg.get_package_name(os.path.dirname(os.path.abspath(launch_file)))\n\n if pkg is None: #cannot determine package\n print(\"ERROR: cannot determine package for [%s]\"%pkg, file=sys.stderr)\n continue\n m = rospack.get_manifest(pkg)\n d_pkgs = set([d.name for d in m.depends])\n if m.is_catkin:\n # for catkin packages consider the run dependencies instead\n # else not released packages will not appear in the dependency list\n # since rospkg does uses rosdep to decide which dependencies to return\n from catkin_pkg.package import parse_package\n p = parse_package(os.path.dirname(m.filename))\n d_pkgs = set([d.name for d in p.run_depends])\n if use_test_depends:\n for d in p.test_depends:\n d_pkgs.add(d.name)\n # make sure we don't count ourselves as a dep\n d_pkgs.add(pkg)\n\n diff = list(set(file_deps[launch_file].pkgs) - d_pkgs)\n if not pkg in missing:\n missing[pkg] = set()\n missing[pkg].update(diff)\n return missing","def exclude_opts(cls) -> Tuple[str, ...]:\n return \"required\", \"print_config\", \"config\", \"ngpu\"","def troubleshoot():\n libraries = (sys, pd, openpyxl, matplotlib, pip)\n for i in libraries:\n try:\n print(str(i), 'version:', i.__version__)\n except AttributeError:\n pass\n except ModuleNotFoundError:\n print('You do not have', str(i), 'installed.')\n print('You can do so via your interpreter or:')\n print('py -m pip install', '-' + str(i))\n print('in command prompt')","def pkg_not_found_mess(pkgname: str, reponame: str) -> None:\n meta = MainData()\n print(('{0}Package {1}{2} {0}not found in \\'{3}\\' '\n 'repository.{4}').format(meta.clrs['red'],\n meta.clrs['lcyan'],\n pkgname,\n reponame,\n meta.clrs['reset']))","def _filter_pkgs(self, pkgs):\n pkgs = [pkg.strip() for pkg in pkgs]\n return [\n pkg for pkg in pkgs\n if pkg.startswith(self.base_pkg) and not pkg.startswith(os.path.join(self.base_pkg, \"vendor/\"))\n ]","def report_unused_cycle_suppressions(self, reporter):\n for module in self.get_modules():\n for dep in module.get_dependencies():\n if not dep.suppression_used:\n reporter.cyclic_issue(\"unused cycle suppression: {0} -> {1}\".format(module.get_name()[7:], dep.get_other_module().get_name()[7:]))","def unusedFromKDOTDataPreparation():","def _getDepends(self, pkg):\r\n vals = self._rp.get_depends(pkg, implicit=True)\r\n return [v for v in vals if not self._rp.get_manifest(v).is_catkin]","def check(force, verbose, packages):\n code = 0\n packages = CFG.package_specs(packages)\n if not packages:\n print(\"No packages installed\")\n sys.exit(0)\n\n for pspec in packages:\n desired = pspec.get_desired_version_info(force=force)\n dv = runez.bold(desired.version)\n manifest = pspec.get_manifest()\n if desired.problem:\n msg = desired.problem\n code = 1\n\n elif not manifest or not manifest.version:\n msg = \"v%s is not installed\" % dv\n code = 1\n\n elif manifest.version == desired.version:\n msg = \"v%s is installed\" % dv\n\n else:\n action = \"upgraded to\" if desired.source == \"latest\" else \"caught up to %s\" % desired.source\n msg = \"v%s installed, can be %s v%s\" % (runez.dim(manifest.version), action, dv)\n\n print(\"%s: %s\" % (pspec.dashed, msg))\n\n sys.exit(code)","def addSkip(self, test, err=\"\"):\n\n self.logger.info(\"\\r\\x1b[33;1mSKIP\\x1b[0m \" + test.shortDescription() + \"\\n\")\n if err: self.logger.info(\"\\t\\t%s\\n\" % err)","def check_req_utils():\n utils = (['dmenu', 'gpg', 'pass', 'xclip', 'exo-open', 'pkill'])\n for util in utils:\n if find_executable(util) is None:\n print(\"ERROR: Util '{}' is missing, install it before proceeding! Exiting!\".format(util))\n sys.exit(1)","def _list_all(root_pkg, prog):\n res = \"\\n\".join(\n sorted(\n pkinspect.package_module_names(_import(root_pkg)),\n key=str.lower,\n ),\n )\n sys.stderr.write(f\"usage: {prog} module command [args...]\\nModules:\\n{res}\\n\")\n return 1","def lookup_packages(lines, skip_till=\"--+--\"):\n packages = []\n skip_index = None\n\n lines = [line.strip() for line in lines]\n for index in range(len(lines)):\n if skip_till in lines[index]:\n skip_index = index + 1\n break\n\n if skip_index:\n for line in lines[skip_index:]:\n items = line.strip(' \\t\\n\\r').split('|')\n packages.append([items[1].strip(), items[3].strip(), items[5].strip()])\n\n return packages","def _remove_extra_packages(frozen_pkgs, ret, **kwargs):\n pkgs = __salt__[\"pkg.list_pkgs\"](**kwargs)\n extra_pkgs = set(pkgs) - set(frozen_pkgs)\n for pkg in extra_pkgs:\n try:\n __salt__[\"pkg.remove\"](name=pkg, **kwargs)\n ret[\"pkgs\"][\"remove\"].append(pkg)\n log.info(\"Removed extra package %s\", pkg)\n except Exception as e: # pylint: disable=broad-except\n msg = \"Error removing %s package: %s\"\n log.error(msg, pkg, e)\n ret[\"comment\"].append(msg % (pkg, e))","def get_incompatible_packages():\n pkgconfig_directory = '/usr/lib64/pkgconfig/'\n incompatibe_packages = []\n libraries = get_libraries_names() - set(NO_PKG_CONFIGS)\n for library in libraries:\n with open(pkgconfig_directory + library + '.pc') as f:\n out = f.readlines()\n for line in out:\n if 'version=' in line:\n version = line.split('=')[1].strip(linesep)\n if not version in PMDK_VERSION.replace('~', '-'):\n incompatibe_packages.append(library)\n return incompatibe_packages","def packages(self):\n return []","def print_deps(self):\n\t\tprint self.deps, '\\n'","def skip_package(self, package, reason):\n with self._conn.begin():\n self._conn.execute(\n \"VALUES (skip_package(%s, %s))\", (package, reason))","def output_ignored(self) -> List[str]:\n output = list()\n for ignored in sorted(self.ignored):\n if len(ignored) == 2:\n line = f\"{ignored[0]} - Ignored {ignored[1]}!\"\n else:\n line = f\"{ignored[0]} - {ignored[1]}: Ignored {ignored[2]}!\"\n logger.info(line)\n output.append(line)\n return output","def is_notebook_skipped(notebook, skip_args):\n # These notebooks run end-to-end because they use Local Mode optionally.\n # They execute even in the presence of docker commands, so we will explicitly not skip them\n if str(notebook) in get_lm_optional_nb_names():\n return False\n\n # Otherwise, check for presence of docker, local mode, efs, fsx or other reasons to skip\n return is_skip_reason_other(notebook) or uses_unsupported_feature_or_framework(notebook, skip_args)","def print_notices(cls, settings: Settings):\n if settings.get(\"wallet.type\", \"in_memory\").lower() == \"indy\":\n with Banner(border=\":\", length=80, file=sys.stderr) as banner:\n banner.centered(\"⚠ DEPRECATION NOTICE: ⚠\")\n banner.hr()\n banner.print(\n \"The Indy wallet type is deprecated, use Askar instead; see: \"\n \"https://aca-py.org/main/deploying/IndySDKtoAskarMigration/\",\n )\n print()","def load_skip_fail():\n\n if os.path.exists('SKIP_TARGETS'):\n with open('SKIP_TARGETS') as fp:\n skip_targets = fp.readlines()\n skip_targets = [name.strip() for name in skip_targets if not name.startswith('#')]\n print(f'Loaded {len(skip_targets)} target names to skip from SKIP_TARGETS')\n else:\n print('No file called SKIP_TARGETS')\n skip_targets = []\n\n if os.path.exists('FAILED_TARGETS'):\n nfail = 0\n with open('FAILED_TARGETS') as fp:\n for line in fp:\n if not line.startswith('#'):\n arr = line.split()\n target = arr[0].replace('~',' ')\n skip_targets.append(target.replace('~',' '))\n nfail += 1\n\n print(f'Loaded {nfail} target names from FAILED_TARGETS')\n else:\n print('No file called FAILED_TARGETS')\n\n return skip_targets","def check(self, quiet=False, exclude=None):\n\n exclude = exclude if exclude else []\n missing = set()\n pkg_types = set()\n python_interpreters = set()\n vcs_types = set()\n\n # package-defined requirements check\n for pkg in self.pkgs:\n if pkg.type not in exclude:\n pkg_types.add(pkg.type)\n if pkg.vcs_type not in exclude:\n vcs_types.add(pkg.vcs_type)\n\n if pkg.type == PackageType.AUTOTOOLS:\n if pkg.autotools_autoreconf:\n if AUTORECONF_COMMAND not in exclude:\n if AUTORECONF.exists():\n self._verbose_exists(AUTORECONF)\n else:\n missing.add(AUTORECONF.tool)\n\n elif pkg.type == PackageType.PYTHON:\n if pkg.python_interpreter:\n if pkg.python_interpreter not in exclude:\n python_tool = PythonTool(pkg.python_interpreter)\n python_interpreters.add(python_tool)\n else:\n python_interpreters.add(PYTHON)\n\n if PackageType.AUTOTOOLS in pkg_types or PackageType.MAKE in pkg_types:\n if MAKE.exists():\n self._verbose_exists(MAKE)\n else:\n missing.add(MAKE.tool)\n\n if PackageType.CMAKE in pkg_types:\n if CMAKE.exists():\n self._verbose_exists(CMAKE)\n else:\n missing.add(CMAKE.tool)\n\n if PackageType.MESON in pkg_types:\n if MESON.exists():\n self._verbose_exists(MESON)\n else:\n missing.add(MESON.tool)\n\n if PackageType.PYTHON in pkg_types:\n for interpreter in python_interpreters:\n if interpreter.exists():\n self._verbose_exists(interpreter)\n else:\n missing.add(interpreter.tool)\n\n if PackageType.SCONS in pkg_types:\n if SCONS.exists():\n self._verbose_exists(SCONS)\n else:\n missing.add(SCONS.tool)\n\n if VcsType.BZR in vcs_types:\n if BZR.exists():\n self._verbose_exists(BZR)\n else:\n missing.add(BZR.tool)\n\n if VcsType.CVS in vcs_types:\n if CVS.exists():\n self._verbose_exists(CVS)\n else:\n missing.add(CVS.tool)\n\n if VcsType.GIT in vcs_types:\n if GIT.exists():\n self._verbose_exists(GIT)\n else:\n missing.add(GIT.tool)\n\n if VcsType.HG in vcs_types:\n if HG.exists():\n self._verbose_exists(HG)\n else:\n missing.add(HG.tool)\n\n if VcsType.PERFORCE in vcs_types:\n if GIT.exists():\n self._verbose_exists(GIT)\n else:\n missing.add(GIT.tool)\n\n if VcsType.RSYNC in vcs_types:\n if RSYNC.exists():\n self._verbose_exists(RSYNC)\n else:\n missing.add(RSYNC.tool)\n\n if VcsType.SCP in vcs_types:\n if SCP.exists():\n self._verbose_exists(SCP)\n else:\n missing.add(SCP.tool)\n\n if VcsType.SVN in vcs_types:\n if SVN.exists():\n self._verbose_exists(SVN)\n else:\n missing.add(SVN.tool)\n\n # project-provided tools check\n for tool in self.tools:\n if tool not in exclude:\n if which(tool):\n verbose('prerequisite exists: ' + tool)\n else:\n missing.add(tool)\n\n if missing and not quiet:\n sorted_missing = list(missing)\n sorted_missing.sort()\n\n msg = 'missing the following host tools for this project:'\n msg += '\\n'\n msg += '\\n'\n for entry in sorted_missing:\n msg += ' ' + entry + '\\n'\n err(msg)\n\n return len(missing) == 0","def required_tool_results():\n raise NotImplementedError()","def check_packages(options):\n print '\\033[1;33m# Checking direct VIKI dependencies\\033[1;m'\n installed_ok = dependencies.check_installed_packages()\n print '\\n\\033[1;33m# Checking second level ROS dependencies, using rosdep\\033[1;m'\n second_level_ok = dependencies.get_second_level_dependencies()\n\n if installed_ok and second_level_ok:\n print '\\033[1;32mAll dependencies satisfied!\\033[1;m'\n else:\n print '\\033[1;31mTry running [viki install-dependencies] to install the dependencies\\033[1;m'","def test_DEPRECATION_PROCESS(self):\n self.verify_references_to_prerequisites(processes.DEPRECATION_PROCESS)","def skip_dti_tests():\n return True","def remove_packages(self, packages):","def test_collect_detection_of_optional_dependencies_in_playbooks(\n self, integration_command, module_repo\n ):\n test_input = [\n {\n \"Dummy Playbook\": {\n \"name\": \"Dummy Playbook\",\n \"file_path\": \"dummy_path\",\n \"fromversion\": \"dummy_version\",\n \"implementing_scripts\": [],\n \"implementing_playbooks\": [],\n \"command_to_integration\": {integration_command: \"\"},\n \"tests\": [\"dummy_playbook\"],\n \"pack\": \"dummy_pack\",\n }\n }\n ]\n\n found_result_set = PackDependencies._collect_playbooks_dependencies(\n pack_playbooks=test_input,\n id_set=module_repo.id_set.read_json_as_dict(),\n )\n\n assert len(found_result_set) == 0","def check_puppet_logs_ubuntu(self):\n\n remote = self.env.get_admin_remote()\n\n err_start = 'The following packages have unmet dependencies:'\n err_end = ('Unable to correct problems,'\n ' you have held broken packages.')\n cmd = ('fgrep -h -e \" Depends: \" -e \"{0}\" -e \"{1}\" '\n '/var/log/docker-logs/remote/node-*/'\n 'puppet*.log'.format(err_start, err_end))\n result = remote.execute(cmd)['stdout']\n\n err_deps = {}\n err_deps_key = ''\n err_deps_flag = False\n\n # Forming a dictionary of package names\n # with sets of required packages.\n for res_str in result:\n if err_deps_flag:\n if err_end in res_str:\n err_deps_flag = False\n elif \": Depends:\" in res_str:\n str0, str1, str2 = res_str.partition(': Depends:')\n err_deps_key = ''.join(str0.split()[-1:])\n if err_deps_key not in err_deps:\n err_deps[err_deps_key] = set()\n if 'but it is not' in str2 or 'is to be installed' in str2:\n err_deps[err_deps_key].add('Depends:{0}'\n .format(str2))\n elif 'Depends:' in res_str and err_deps_key:\n str0, str1, str2 = res_str.partition('Depends:')\n if 'but it is not' in str2 or 'is to be installed' in str2:\n err_deps[err_deps_key].add(str1 + str2)\n else:\n err_deps_key = ''\n elif err_start in res_str:\n err_deps_flag = True\n\n return err_deps","def isIgnoredPkg(self, *args):\n return _libsbml.SBMLDocument_isIgnoredPkg(self, *args)","def ask_continue():\n i = input(\"Please ensure your System Dependencies are met. Continue? [y/N] \")\n if i in (\"\", \"N\", \"n\"):\n out_error(\"Please install system dependencies to continue\")\n exit(1)","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","def remove_packages_ignored_since(days, paths=None, dry_run=False, verbose=False):\n num_removed = 0\n\n for path in (paths or config.packages_path):\n repo = package_repository_manager.get_repository(path)\n\n if verbose:\n print_info(\"Searching %s...\", repo)\n\n num_removed += repo.remove_ignored_since(\n days=days,\n dry_run=dry_run,\n verbose=verbose\n )\n\n return num_removed","def checkOptionalDependencies(self):\n \n # skip dependency check for downloading only\n if( self.downloadOnly ):\n return\n\n # soft dependencies\n failed = []\n for opt in self.optmodules:\n mod = self.parent.module(opt)\n if( mod == None ):\n failed.append(opt)\n \n # remove soft dependencies that were not found\n self.buildWithout(failed)","def cleanup(self):\n results = run_command(\"gppkg -q --all\")\n gppkgs = results.split('\\n')[self.start_output:self.end_output] #The first line is 'Starting gppkg with args', which we want to ignore.\n\n for gppkg in gppkgs:\n run_command(\"gppkg --remove \" + gppkg)","def _missing_symbol_to_skipped_tests(self):\n return {\n \"MathMLElement\": [\"mathml\"],\n \"GraphicsLayer\": [\"compositing\"],\n \"WebCoreHas3DRendering\": [\"animations/3d\", \"transforms/3d\"],\n \"WebGLShader\": [\"fast/canvas/webgl\", \"compositing/webgl\", \"http/tests/canvas/webgl\"],\n \"MHTMLArchive\": [\"mhtml\"],\n }","def log_installed_python_prereqs():\n sh(\"pip freeze > {}\".format(Env.GEN_LOG_DIR + \"/pip_freeze.log\"))","def missingTranslationPkgs(self, pkg, translation_pkg):\n\n # FIXME: this function is called too often and it's too slow\n # -> see ../TODO for ideas how to fix it\n missing = []\n # check if the pkg itself is available and installed\n if not self._cache.has_key(pkg):\n return missing\n if not self._cache[pkg].isInstalled:\n return missing\n\n # match every packages that looks similar to translation_pkg\n # \n for pkg in self._cache:\n if (pkg.name == translation_pkg or\n pkg.name.startswith(translation_pkg+\"-\")):\n if not pkg.isInstalled and pkg.candidateVersion != None:\n missing.append(pkg.name)\n return missing","def extra_removed_packages(self, index: int) -> Packages:\n log = self[index]\n if (\n not log.startswith(\"conda remove\")\n and not log.startswith(\"pip uninstall\")\n and not (log.startswith(R_COMMAND) and \"remove.packages\" in log)\n ):\n raise CondaEnvTrackerParseHistoryError(\n f\"The log at index {index} is not a remove statement: {self[index]}.\"\n )\n if log.startswith(\"conda remove\"):\n package_names = self._extract_conda_remove_package_names(log)\n elif log.startswith(\"pip uninstall\"):\n package_names = log.replace(\"pip uninstall \", \"\").split()\n else:\n package_names = self._extract_r_remove_package_names(log)\n return Packages.from_specs(package_names)","def list_missing_for_deposit(self, needs: Tuple) -> List[int]:\n missing = []\n for item in needs:\n if not any(self.needed_keywords_list(item)):\n missing.append(item)\n return missing","def test_missing_proteins():\n\n rv, out = getstatusoutput(f'{prg} -p {proteins}')\n assert rv > 0\n assert re.search('the following arguments are required: -c/--cdhit', out)","def list_providers_packages():\n providers = get_all_providers()\n # if provider needs to be not considered in release add it here\n # this is useful for cases where provider is WIP for a long period thus we don't want to release it yet.\n providers_to_remove_from_release = []\n for provider in providers:\n if provider in providers_to_remove_from_release:\n continue\n console.print(provider)","def list_cmd(repo):\n click.echo('Packages and scripts installed through pipsi:')\n for venv, scripts in repo.list_everything():\n if not scripts:\n continue\n click.echo(' Package \"%s\":' % venv)\n for script in scripts:\n click.echo(' ' + script)","def requirement_missing(script):\n if \"requires\" in script:\n if script[\"requires\"] is None:\n return False\n for package in script[\"requires\"].split():\n try:\n pkg_resources.working_set.require(package)\n except Exception:\n return True\n return False","def isDisabledIgnoredPackage(self, *args):\n return _libsbml.SBMLDocument_isDisabledIgnoredPackage(self, *args)","def prompt_for_exclusions(skip_prompt):\n\n prompt = (\n \"Do you want to exclude any domains?\\n\"\n \"For example, hulu.com video streaming must be able to access \"\n \"its tracking and ad servers in order to play video.\"\n )\n\n if not skip_prompt:\n if query_yes_no(prompt):\n return True\n else:\n print(\"OK, we'll only exclude domains in the whitelist.\")\n\n return False","def ignore_from_package(self, project, package, arch, ignore):\n for binary in binary_list(self.apiurl, project, 'standard', arch, package):\n ignore.add(binary.name)\n\n return ignore","def optional_packages():\n with open(r\"tests/input.yml\") as file:\n inputs = yaml.load(file, Loader=yaml.FullLoader)\n return inputs[\"optional_packages\"]","def show_rev_deps(self, package):\n return self.show_deps(package, \"show-rev-deps\")","def missing_in_gyp_by_file(self):\n return self._missing_gyp_files","def test_list_upgrades_absent(self):\n pkg_cmd = MagicMock(return_value=\"\")\n\n with patch.dict(pkgng.__salt__, {\"cmd.run_stdout\": pkg_cmd}):\n result = pkgng.list_upgrades(refresh=False)\n self.assertDictEqual(result, {})\n pkg_cmd.assert_called_with(\n [\"pkg\", \"upgrade\", \"--dry-run\", \"--quiet\", \"--no-repo-update\"],\n output_loglevel=\"trace\",\n python_shell=False,\n ignore_retcode=True,\n )","def getNonInstallableProfiles(self):\n return [\n 'onlyoffice.plone:uninstall',\n ]","def log_imported_packages(self):\n imported_packages_dict = self.get_imported_packages()\n\n res_str = \"\\n\".join(f\"{module}: {version_num}\" for module, version_num\n in imported_packages_dict[\"results\"].items())\n no_res_str = \"\\n\".join(f\"{module}: {version_num}\" for module, version_num\n in imported_packages_dict[\"no_results\"].items())\n errs_res_str = \"\\n\".join(f\"{module}: {version_num}\" for module, version_num\n in imported_packages_dict[\"errors\"].items())\n\n msg = f\"Imported modules:\\n {res_str}\\n {no_res_str}\\n {errs_res_str}\"\n logger.info(msg)","def test_compatibility_of_version_of_installed_rpm_packages(self):\n incompatible_packages = get_incompatible_packages()\n error_msg = linesep + 'List of incompatible packages: '\n for package in incompatible_packages:\n error_msg += linesep + package\n self.assertFalse(incompatible_packages, error_msg)","def missing_ltihooks(finder, caller):\n caller.IgnoreName(\"ltihooks\")","def show_solution_differences_to_user(self, solution: List['Package'], upstream_system: 'System',\n noconfirm: bool, deep_search: bool, solution_way: bool):\n\n # needed strings\n package_to_install = aurman_note(\n \"The following {} package(s) are getting {}:\".format(\n \"{}\", Colors.BOLD(Colors.LIGHT_CYAN(\"installed\"))\n ), True, False\n )\n packages_to_uninstall = aurman_note(\n \"The following {} package(s) are predicted to get {}:\".format(\n \"{}\", Colors.BOLD(Colors.LIGHT_CYAN(\"removed\"))\n ), True, False\n )\n packages_to_upgrade = aurman_note(\n \"The following {} package(s) are getting {}:\".format(\n \"{}\", Colors.BOLD(Colors.LIGHT_CYAN(\"updated\"))\n ), True, False\n )\n packages_to_reinstall = aurman_note(\n \"The following {} package(s) are getting {}:\".format(\n \"{}\", Colors.BOLD(Colors.LIGHT_CYAN(\"reinstalled\"))\n ), True, False\n )\n user_question = \"Do you want to continue?\"\n\n new_system = self.hypothetical_append_packages_to_system(solution)\n differences_to_this_system_tuple = self.differences_between_systems((new_system,))[0]\n\n to_install_names = set([package.name for package in differences_to_this_system_tuple[0]])\n to_uninstall_names = set([package.name for package in differences_to_this_system_tuple[1]])\n to_upgrade_names = to_install_names & to_uninstall_names\n to_install_names -= to_upgrade_names\n to_uninstall_names -= to_upgrade_names\n just_reinstall_names = set(\n [package.name for package in solution if package.name in new_system.all_packages_dict]\n ) - set.union(\n *[to_upgrade_names, to_install_names, to_uninstall_names]\n )\n\n # colored names + repos\n print_to_install_names = set([upstream_system.repo_of_package(name) for name in to_install_names])\n print_to_uninstall_names = set([upstream_system.repo_of_package(name) for name in to_uninstall_names])\n print_to_upgrade_names = set([upstream_system.repo_of_package(name) for name in to_upgrade_names])\n print_just_reinstall_names = set([upstream_system.repo_of_package(name) for name in just_reinstall_names])\n\n # calculate some needed values\n max_package_name_length = max(\n [\n len(name) for name in\n set(print_to_install_names |\n print_to_uninstall_names |\n print_to_upgrade_names |\n print_just_reinstall_names)\n ],\n default=0\n )\n\n max_left_side_version_length = max(\n [\n len(self.all_packages_dict[package_name].version) for package_name in\n set(to_uninstall_names | to_upgrade_names | just_reinstall_names)\n ],\n default=1\n )\n\n if to_install_names:\n print(package_to_install.format(len(to_install_names)))\n for package_name in sorted(list(to_install_names)):\n string_to_print = \" {} {} -> {}\".format(\n upstream_system.repo_of_package(package_name).ljust(max_package_name_length),\n Colors.RED(\"/\").ljust(max_left_side_version_length + 10),\n Colors.GREEN(new_system.all_packages_dict[package_name].version)\n )\n\n print(string_to_print)\n\n if to_upgrade_names:\n print(packages_to_upgrade.format(len(to_upgrade_names)))\n for package_name in sorted(list(to_upgrade_names)):\n string_to_print = \" {} {} -> {}\".format(\n upstream_system.repo_of_package(package_name).ljust(max_package_name_length),\n Colors.RED(self.all_packages_dict[package_name].version).ljust(max_left_side_version_length + 10),\n Colors.GREEN(new_system.all_packages_dict[package_name].version)\n )\n\n print(string_to_print)\n\n if just_reinstall_names and not deep_search:\n print(packages_to_reinstall.format(len(just_reinstall_names)))\n for package_name in sorted(list(just_reinstall_names)):\n string_to_print = \" {} {} -> {}\".format(\n upstream_system.repo_of_package(package_name).ljust(max_package_name_length),\n Colors.LIGHT_MAGENTA(self.all_packages_dict[package_name].version).ljust(\n max_left_side_version_length + 10\n ),\n Colors.LIGHT_MAGENTA(new_system.all_packages_dict[package_name].version)\n )\n\n print(string_to_print)\n\n if to_uninstall_names:\n print(packages_to_uninstall.format(len(to_uninstall_names)))\n for package_name in sorted(list(to_uninstall_names)):\n string_to_print = \" {} {} -> {}\".format(\n upstream_system.repo_of_package(package_name).ljust(max_package_name_length),\n Colors.GREEN(self.all_packages_dict[package_name].version).ljust(max_left_side_version_length + 10),\n Colors.RED(\"/\")\n )\n\n print(string_to_print)\n\n # print why those packages have to be uninstalled\n self.hypothetical_append_packages_to_system(solution, packages_names_print_reason=to_uninstall_names)\n\n # check if no dependency breakage happens\n if not solution_way:\n self.hypothetical_append_packages_to_system(solution, check_if_possible=True)\n\n if solution_way:\n aurman_status(\"The following will be done:\", new_line=True)\n if deep_search:\n aurman_note(\"You are using {}, hence {} is active.\".format(\n Colors.BOLD(\"--deep_search\"), Colors.BOLD(\"--needed\")\n ))\n aurman_note(\"That means packages to be reinstalled will not actually be reinstalled.\")\n self.hypothetical_append_packages_to_system(solution, print_way=True)\n\n if not noconfirm and not ask_user(user_question, True, True):\n raise InvalidInput()","def skip_project_message():\n\n return ' - Skip project'"],"string":"[\n \"def _print_ignored(packages):\\n if not packages:\\n print(\\\"## No Rez package was set to be ignored\\\")\\n print(\\\"No data found\\\")\\n\\n return\\n\\n print(\\\"## Every package in this list was explicitly set to ignored by the user\\\")\\n\\n for package, pattern in sorted(packages, key=_get_package_name):\\n print(\\n 'Package: {package.name} - Pattern: \\\"{pattern}\\\"'.format(\\n package=package, pattern=pattern\\n )\\n )\",\n \"def _print_missing(packages, verbose):\\n if not packages:\\n print(\\\"## No Rez packages were found.\\\")\\n print(\\\"No data found\\\")\\n\\n return\\n\\n print(\\\"## Your command affects these Rez packages.\\\")\\n\\n template = \\\"{package.name}\\\"\\n\\n if verbose:\\n template = \\\"{package.name}: {path}\\\"\\n\\n for line in sorted(\\n template.format(package=package, path=finder.get_package_root(package))\\n for package in packages\\n ):\\n print(line)\",\n \"def print_test_deps_not_in_package_deps(self):\\n extras = []\\n for key, rec_deps in self.recursive_pkg_deps.items():\\n any = self.test_imports.get(key, set()).difference(rec_deps, set([key]))\\n if any:\\n extras.append((key, any))\\n\\n if extras:\\n print(\\\"Packages whose tests have extra dependencies not listed in `go list -f {{.Deps}}`:\\\")\\n for pkg, deps in extras:\\n print(\\\"\\\\t{0}: {1}\\\".format(pkg, \\\", \\\".join(deps)))\\n print(\\\"\\\\n\\\")\",\n \"def show_missing():\\n if missing_modules:\\n info(\\\"The following modules are currently not installed and would enable additional tasks:\\\")\\n for pkg_name in missing_modules:\\n info(' ' + pkg_name)\",\n \"def sort_packages(self) -> None:\\n self.recommended_packages = []\\n self.required_packages = []\\n for package in self.repository_packages:\\n try:\\n output = self.guest.execute(Command('rpm', '-q', package), silent=True)\\n assert output.stdout\\n self.debug(f\\\"Package '{output.stdout.strip()}' already installed.\\\")\\n except tmt.utils.RunError:\\n if self.skip_missing:\\n self.recommended_packages.append(package)\\n else:\\n self.required_packages.append(package)\",\n \"def missing_requirements_command(args, packages=None, exit_on_failure=True):\\n requirements_files = (\\n args.requirements or Config.requirements_files or []\\n )\\n ignore_list = (\\n args.ignore or Config.ignore_list or []\\n )\\n\\n printer = Printer()\\n if not validate_files(\\n files=requirements_files,\\n printer=printer,\\n exit_on_failure=exit_on_failure):\\n return False\\n\\n requirements = RequirementCollection()\\n for requirements_file in requirements_files:\\n requirements.extend(\\n RequirementCollection.from_file(filepath=requirements_file)\\n )\\n\\n packages = (\\n packages or dependency_list(ignore_list=ignore_list)\\n )\\n\\n missing = [\\n (package, required_by)\\n for package, required_by\\n in missing_requirements(\\n packages=packages,\\n requirements=requirements,\\n ignore_list=ignore_list\\n )\\n ]\\n\\n headers = [\\n messages.PACKAGE,\\n messages.REQUIRED,\\n messages.REQUIRED_BY,\\n ]\\n\\n tabular_data = []\\n for package, requirers in missing:\\n if requirers:\\n for required_by, required_version in requirers:\\n tabular_data.append([\\n printer.colored_message(\\n message=package.key,\\n message_color=printer.color_package\\n ),\\n required_version,\\n required_by.key,\\n ])\\n else:\\n tabular_data.append([\\n printer.colored_message(\\n message=package.key,\\n message_color=printer.color_package\\n ),\\n package.version.specifier,\\n \\\"Requirements\\\",\\n ])\\n\\n if tabular_data:\\n printer.error(messages.MISSING_FOUND)\\n printer.table(headers=headers, tabular_data=tabular_data)\\n if exit_on_failure:\\n sys.exit(1)\\n return False\\n\\n printer.success(messages.MISSING_OK)\\n return True\",\n \"def test_print_version_repositories_SKIP(self):\\n self._uri({\\n '%d.%d/maintained/%d.%d-%d/%s/Packages.gz' % (MAJOR, MINOR, MAJOR, MINOR, 0, 'all'): DATA,\\n '%d.%d/maintained/%d.%d-%d/%s/Packages.gz' % (MAJOR, MINOR, MAJOR, MINOR, 0, ARCH): DATA,\\n })\\n tmp = self.u.print_version_repositories()\\n self.assertEqual(set((\\n 'deb file:///mock/%d.%d/maintained/ %d.%d-%d/%s/' % (MAJOR, MINOR, MAJOR, MINOR, 0, 'all'),\\n 'deb file:///mock/%d.%d/maintained/ %d.%d-%d/%s/' % (MAJOR, MINOR, MAJOR, MINOR, 0, ARCH),\\n )), set(tmp.splitlines()))\",\n \"def test_collect_playbooks_dependencies_skip_unavailable(self, module_repo):\\n expected_result = {\\n # playbooks:\\n (\\\"Slack\\\", False),\\n (\\\"Indeni\\\", True),\\n # integrations:\\n (\\\"FeedAlienVault\\\", False),\\n (\\\"ipinfo\\\", True),\\n (\\\"FeedAutofocus\\\", True),\\n # scripts:\\n (\\\"GetServerURL\\\", False),\\n (\\\"HelloWorld\\\", True),\\n }\\n test_input = [\\n {\\n \\\"Dummy Playbook\\\": {\\n \\\"name\\\": \\\"Dummy Playbook\\\",\\n \\\"file_path\\\": \\\"dummy_path\\\",\\n \\\"fromversion\\\": \\\"dummy_version\\\",\\n \\\"implementing_scripts\\\": [\\n \\\"GetServerURL\\\",\\n \\\"HelloWorldScript\\\",\\n ],\\n \\\"implementing_playbooks\\\": [\\n \\\"Failed Login Playbook - Slack v2\\\",\\n \\\"Indeni Demo\\\",\\n ],\\n \\\"command_to_integration\\\": {\\n \\\"alienvault-get-indicators\\\": \\\"\\\",\\n \\\"ip\\\": \\\"ipinfo\\\",\\n \\\"autofocus-get-indicators\\\": \\\"\\\",\\n },\\n \\\"tests\\\": [\\\"dummy_playbook\\\"],\\n \\\"pack\\\": \\\"dummy_pack\\\",\\n \\\"incident_fields\\\": [],\\n \\\"skippable_tasks\\\": [\\n \\\"Print\\\",\\n \\\"Failed Login Playbook - Slack v2\\\",\\n \\\"alienvault-get-indicators\\\",\\n \\\"GetServerURL\\\",\\n ],\\n }\\n },\\n ]\\n\\n found_result = PackDependencies._collect_playbooks_dependencies(\\n pack_playbooks=test_input,\\n id_set=module_repo.id_set.read_json_as_dict(),\\n )\\n\\n assert set(found_result) == set(expected_result)\",\n \"def show_packagelist(user, repo, packages, distro=False, version=False,\\n name=False, match=False, pkgtype=False):\\n\\n print('Currently {}/{} contains these matching packages:'.format(\\n user, repo))\\n\\n numpkgs = 0\\n for package in packages:\\n if (distro and not package['distro_version'] == distro) or \\\\\\n (version and not package['version'] == version) or \\\\\\n (name and not package['name'] == name) or \\\\\\n (pkgtype and not package['type'] == pkgtype) or \\\\\\n (match and match not in package['filename']):\\n continue\\n\\n print(fmt_pkg(user, repo, package))\\n numpkgs += 1\\n\\n print(\\\"Repo contains {} matching packages.\\\".format(numpkgs))\",\n \"def get_not_installed_rpm_packages():\\n def is_installed(elem):\\n return elem in PMDK_TOOLS and elem in listdir('/usr/bin/') or\\\\\\n elem == \\\"pmdk\\\" or elem + '.so' in listdir('/usr/lib64/')\\n\\n elements = get_libraries_names()\\n not_installed_packages = []\\n for elem in elements:\\n if not is_installed(elem):\\n not_installed_packages.append(elem)\\n return not_installed_packages\",\n \"def __report(arguments, _):\\n ignored_packages, other_packages, invalid_packages, skips = __gather_package_data(\\n arguments\\n )\\n\\n packages, invalids = worker.report(\\n other_packages,\\n maximum_repositories=arguments.maximum_repositories,\\n maximum_rez_packages=arguments.maximum_rez_packages,\\n )\\n\\n invalids.extend(invalid_packages)\\n\\n _print_ignored(ignored_packages)\\n print(\\\"\\\\n\\\")\\n _print_skips(skips, arguments.verbose)\\n print(\\\"\\\\n\\\")\\n _print_invalids(invalids, arguments.verbose)\\n print(\\\"\\\\n\\\")\\n _print_missing(packages, arguments.verbose)\\n\\n sys.exit(0)\",\n \"def _print_invalids(invalids, verbose):\\n if not invalids:\\n print(\\\"## No Rez package was set as invalid.\\\")\\n print(\\\"Nothing is invalid. Which is a good thing!\\\")\\n\\n return\\n\\n print(\\\"## Some packages were marked as invalid. Here's why:\\\")\\n\\n template = \\\"{package.name}: {message}\\\"\\n\\n if verbose:\\n template = \\\"{package.name}: {path} {message}: {full}\\\"\\n\\n for message in sorted(\\n (\\n template.format(\\n package=error.get_package(),\\n path=error.get_path(),\\n message=str(error),\\n full=error.get_full_message(),\\n )\\n for error in invalids\\n )\\n ):\\n print(message)\",\n \"def test_packages(self):\\n for pkg in self.expected_packages:\\n status, output = commands.getstatusoutput('pkg_info -qx %s' % pkg)\\n assert status == 0\",\n \"def getMissingPackages(self, language=None, all=False, packages=None, showInstalled=False):\\n if self._cache.broken_count > 0:\\n raise SoftwareIndexBroken\\n \\n self.langpack_locales = {}\\n self.pkg_translations = {}\\n self.pkg_writing = {}\\n filter_list = {}\\n blacklist = []\\n show = []\\n self.missing = set()\\n self.installed = set()\\n self.system_pkgcode = ''\\n \\n for l in open(self.BLACKLIST):\\n l = l.strip()\\n if not l.startswith('#'):\\n blacklist.append(l)\\n \\n for l in open(self.LANGCODE_TO_LOCALE):\\n try:\\n l = l.rstrip()\\n if ':' in l:\\n (pkgcode, locale) = l.split(':')\\n else:\\n pkgcode = l\\n locale = l\\n except ValueError:\\n continue\\n self.langpack_locales[locale] = pkgcode\\n \\n for l in open(self.PACKAGE_DEPENDS):\\n if l.startswith('#'):\\n continue\\n try:\\n l = l.rstrip()\\n # sort out comments\\n if l.find('#') >= 0:\\n continue\\n (c, lc, k, v) = l.split(':')\\n except ValueError:\\n continue\\n if (c == 'tr' and lc == ''):\\n filter_list[v] = k\\n elif (c == 'wa' and lc != ''):\\n if '|' in lc:\\n for l in lc.split('|'):\\n if not l in self.pkg_writing:\\n self.pkg_writing[l] = []\\n self.pkg_writing[l].append((\\\"%s\\\" % k, \\\"%s\\\" % v))\\n else:\\n if not lc in self.pkg_writing:\\n self.pkg_writing[lc] = []\\n self.pkg_writing[lc].append((\\\"%s\\\" % k, \\\"%s\\\" % v))\\n\\n # get list of all packages available on the system and filter them\\n for item in self._cache.keys():\\n if item in blacklist: \\n continue\\n for x in filter_list.keys():\\n if item.startswith(x) and not item.endswith('-base'):\\n # parse language code\\n langcode = item.replace(x, '')\\n #print \\\"%s\\\\t%s\\\" % (item, langcode)\\n if langcode == 'zh':\\n # special case: zh langpack split\\n for langcode in ['zh-hans', 'zh-hant']:\\n if not langcode in self.pkg_translations:\\n self.pkg_translations[langcode] = []\\n self.pkg_translations[langcode].append((\\\"%s\\\" % filter_list[x], \\\"%s\\\" % item))\\n elif langcode in self.langpack_locales.values():\\n # langcode == pkgcode\\n if not langcode in self.pkg_translations:\\n self.pkg_translations[langcode] = []\\n self.pkg_translations[langcode].append((\\\"%s\\\" % filter_list[x], \\\"%s\\\" % item))\\n #print self.pkg_translations[langcode]\\n else:\\n # need to scan for LL-CC and LL-VARIANT codes\\n for locale in self.langpack_locales.keys():\\n if '_' in locale or '@' in locale:\\n if '@' in locale:\\n (locale, variant) = locale.split('@')\\n else:\\n variant = ''\\n (lcode, ccode) = locale.split('_')\\n if langcode in [\\\"%s-%s\\\" % (lcode, ccode.lower()),\\n \\\"%s%s\\\" % (lcode, ccode.lower()),\\n \\\"%s-%s\\\" % (lcode, variant),\\n \\\"%s%s\\\" % (lcode, variant),\\n \\\"%s-latn\\\" % lcode,\\n \\\"%slatn\\\" % lcode,\\n \\\"%s-%s-%s\\\" % (lcode, ccode.lower(), variant),\\n \\\"%s%s%s\\\" % (lcode, ccode.lower(), variant)]:\\n # match found, get matching pkgcode\\n langcode = self.langpack_locales[locale]\\n if not langcode in self.pkg_translations:\\n self.pkg_translations[langcode] = []\\n self.pkg_translations[langcode].append((\\\"%s\\\" % filter_list[x], \\\"%s\\\" % item))\\n #print self.pkg_translations[langcode]\\n break\\n\\n if language:\\n pkgcode = ''\\n if language == 'zh-hans' or language == 'zh-hant':\\n self.system_pkgcode = language\\n elif language in self.langpack_locales:\\n self.system_pkgcode = self.langpack_locales[language]\\n else:\\n # pkgcode = ll\\n if '_' in language:\\n (self.system_pkgcode) = language.split('_')[0]\\n elif '@' in language:\\n (self.system_pkgcode) = language.split('@')[0]\\n else:\\n self.system_pkgcode = language\\n\\n if packages:\\n self.findPackages(self.system_pkgcode, packages)\\n else:\\n self.findPackages(self.system_pkgcode)\\n \\n elif all:\\n # try all available languages\\n pkgcodes = []\\n for item in self._cache.keys():\\n if item in blacklist:\\n continue\\n if item.startswith('language-pack-') and \\\\\\n not item.startswith('language-pack-gnome') and \\\\\\n not item.startswith('language-pack-kde') and \\\\\\n not item.endswith('-base'):\\n pkgcode = item.replace('language-pack-', '')\\n pkgcodes.append(pkgcode)\\n\\n for pkgcode in pkgcodes:\\n if packages:\\n self.findPackages(pkgcode, packages)\\n else:\\n self.findPackages(pkgcode)\\n\\n else:\\n # get a list of language-packs we have already installed or are going to install\\n # 1. system locale\\n system_langcode = self._localeinfo.getSystemDefaultLanguage()[0]\\n if system_langcode == None:\\n system_langcode = 'en_US'\\n if system_langcode in self.langpack_locales:\\n self.system_pkgcode = self.langpack_locales[system_langcode]\\n # 2. installed language-packs\\n pkgcodes = []\\n for item in self._cache.keys():\\n if item in blacklist: \\n continue\\n if item.startswith('language-pack-') and \\\\\\n not item.startswith('language-pack-gnome') and \\\\\\n not item.startswith('language-pack-kde') and \\\\\\n not item.endswith('-base') and \\\\\\n (self._cache[item].is_installed or \\\\\\n self._cache[item].marked_install):\\n pkgcode = item.replace('language-pack-', '')\\n pkgcodes.append(pkgcode)\\n if self.system_pkgcode and \\\\\\n not self.system_pkgcode in pkgcodes:\\n pkgcodes.append(self.system_pkgcode)\\n \\n for pkgcode in pkgcodes:\\n if packages:\\n self.findPackages(pkgcode, packages)\\n else:\\n self.findPackages(pkgcode)\\n \\n if showInstalled:\\n show = self.missing | self.installed\\n else:\\n show = self.missing\\n\\n return show\",\n \"def have_package_lists():\\n return 'Filename:' in execute('apt-cache', 'show', 'python', check=False, capture=True)\",\n \"def required_packages(cls) -> List[Text]:\\n return []\",\n \"def _list_dependencies_info(\\n out: Callable, ljust: int, package: str, dependencies: List[Requirement]\\n):\\n unicode = sys.stdout.encoding.lower().startswith(\\\"utf\\\")\\n if unicode:\\n ljust += 1\\n\\n not_found: List[Requirement] = list()\\n for dep in dependencies:\\n if dep.name == package:\\n continue\\n try:\\n version_ = version(dep.name)\\n except Exception:\\n not_found.append(dep)\\n continue\\n\\n # build the output string step by step\\n output = f\\\"✔︎ {dep.name}\\\" if unicode else dep.name\\n # handle version specifiers\\n if len(dep.specifier) != 0:\\n output += f\\\" ({str(dep.specifier)})\\\"\\n output += \\\":\\\"\\n output = output.ljust(ljust) + version_\\n\\n # handle special dependencies with backends, C dep, ..\\n if dep.name in (\\\"matplotlib\\\", \\\"seaborn\\\") and version_ != \\\"Not found.\\\":\\n try:\\n from matplotlib import pyplot as plt\\n\\n backend = plt.get_backend()\\n except Exception:\\n backend = \\\"Not found\\\"\\n\\n output += f\\\" (backend: {backend})\\\"\\n out(output + \\\"\\\\n\\\")\\n\\n if len(not_found) != 0:\\n not_found = [\\n f\\\"{dep.name} ({str(dep.specifier)})\\\"\\n if len(dep.specifier) != 0\\n else dep.name\\n for dep in not_found\\n ]\\n if unicode:\\n out(f\\\"✘ Not installed: {', '.join(not_found)}\\\\n\\\")\\n else:\\n out(f\\\"Not installed: {', '.join(not_found)}\\\\n\\\")\",\n \"def test_correctness_of_installed_rpm_packages(self):\\n not_installed_packages = get_not_installed_rpm_packages()\\n error_msg = linesep + 'List of not installed packages: '\\n for package in not_installed_packages:\\n error_msg += linesep + package\\n self.assertFalse(not_installed_packages, error_msg)\",\n \"def unsatisfied_requirements(buildout, package, working_set):\\n\\n # read all lines from \\\"requirements.txt\\\"\\n specs = [k.strip() for k in package_readlines(package, 'requirements.txt')]\\n\\n # discard empty lines and comments\\n specs = [k for k in specs if k and k[0] not in ('#', '-')]\\n\\n # do not consider packages which are already installed, with a reasonable\\n # version matching the user specification, either on the current working\\n # set, the installed eggs or the system paths\\n newest = bool_option(buildout, 'newest', 'true')\\n\\n left_over = []\\n for k in specs:\\n if requirement_is_satisfied(k, working_set, newest):\\n dist = working_set.require(k)[0]\\n logger.info(\\\"taking requirement `%s' (%s) from `%s'\\\", dist.key,\\n dist.version, dist.location)\\n else:\\n left_over.append(k)\\n specs = left_over\\n\\n return left_over\",\n \"def check_missing_dep():\\n global MISSING_PACKAGES, INSTALLED_PACKAGES, ENABLE_CUDA\\n if ENABLE_CUDA and IS_MACOS:\\n REQUIRED_PACKAGES.extend(MACOS_REQUIRED_PACKAGES)\\n MISSING_PACKAGES = []\\n for pkg in REQUIRED_PACKAGES:\\n key = pkg.split(\\\"==\\\")[0]\\n if key not in INSTALLED_PACKAGES:\\n MISSING_PACKAGES.append(pkg)\\n continue\\n else:\\n if len(pkg.split(\\\"==\\\")) > 1:\\n if pkg.split(\\\"==\\\")[1] != INSTALLED_PACKAGES.get(key):\\n MISSING_PACKAGES.append(pkg)\\n continue\",\n \"def do_seeSkipList(self, args):\\n sl.showList()\",\n \"def show_keep(self, command=\\\"show-keep\\\"):\\n # execute pkgin\\n popen = Popen([self.pkgin_bin, \\\"-P\\\", command], stdout=PIPE, stderr=PIPE)\\n # retrieve output streams\\n (stdoutdata, stderrdata) = popen.communicate()\\n # if pkgin error\\n if(stderrdata):\\n # remove the line feed\\n error = stderrdata[0:-1]\\n raise PykginError(error)\\n # retrieve output\\n output = stdoutdata\\n # create a list which contain each packages\\n output_whole_list = output.split('\\\\n')\\n # remove last element (due to the last \\\\n)\\n output_whole_list.pop()\\n # create a new list in which package informations are separate\\n output_list = []\\n for pkg in output_whole_list:\\n current = pkg.split(' ', 1)\\n output_list.append(self.__extract_package_version(current[0]))\\n\\n return output_list\",\n \"def main():\\n\\n local_pkgs = set(os.listdir(GIT_FOLDER))\\n local_pkgs = set([it.replace('.git', '') for it in local_pkgs])\\n\\n pkgdb_info = pkgdb_pkg_branch()\\n\\n pkgdb_pkgs = set(pkgdb_info.keys())\\n\\n ## Commented out as we keep the git of retired packages while they won't\\n ## show up in the information retrieved from pkgdb.\\n\\n #if (local_pkgs - pkgdb_pkgs):\\n #print 'Some packages are present locally but not on pkgdb:'\\n #print ', '.join(sorted(local_pkgs - pkgdb_pkgs))\\n\\n if (pkgdb_pkgs - local_pkgs):\\n print 'Some packages are present in pkgdb but not locally:'\\n print ', '.join(sorted(pkgdb_pkgs - local_pkgs))\\n\\n tofix = set()\\n for pkg in sorted(pkgdb_info):\\n pkgdb_branches = pkgdb_info[pkg]\\n git_branches = get_git_branch(pkg)\\n diff = (pkgdb_branches - git_branches)\\n if diff:\\n print '%s missing: %s' % (pkg, ','.join(sorted(diff)))\\n tofix.add(pkg)\\n branch_package(pkg, diff)\\n\\n if tofix:\\n print 'Packages fixed (%s): %s' % (\\n len(tofix), ', '.join(sorted(tofix)))\",\n \"def skip_check():\\n if os.getenv('LEAPP_DEVEL_SKIP_CHECK_OS_RELEASE'):\\n reporting.create_report([\\n reporting.Title('Skipped OS release check'),\\n reporting.Summary('Source RHEL release check skipped via LEAPP_DEVEL_SKIP_CHECK_OS_RELEASE env var.'),\\n reporting.Severity(reporting.Severity.HIGH),\\n reporting.Groups(COMMON_REPORT_TAGS)\\n ] + related)\\n\\n return True\\n return False\",\n \"def print_dependencies(_run):\\n print('Sources:')\\n for source, digest in _run.experiment_info['sources']:\\n print(' {:<43} {}'.format(source, digest))\\n\\n print('\\\\nDependencies:')\\n for pack, version in _run.experiment_info['dependencies']:\\n print(' {:<20} >= {}'.format(pack, version))\",\n \"def print_dependencies(pkg):\\n\\n for deptype in (\\\"build\\\", \\\"link\\\", \\\"run\\\"):\\n color.cprint(\\\"\\\")\\n color.cprint(section_title(\\\"%s Dependencies:\\\" % deptype.capitalize()))\\n deps = sorted(pkg.dependencies_of_type(deptype))\\n if deps:\\n colify(deps, indent=4)\\n else:\\n color.cprint(\\\" None\\\")\",\n \"def run_skip(self):\\n pass\",\n \"def missing_tests(session):\\n print('The following samples do not have tests:')\\n for sample in set(ALL_SAMPLE_DIRECTORIES) - set(ALL_TESTED_SAMPLES):\\n print('* {}'.format(sample))\",\n \"def CheckForUnknownFiles(self):\\n unknown_files = self.GetUnknownFiles()\\n if unknown_files:\\n print \\\"The following files are not added to version control:\\\"\\n for line in unknown_files:\\n print line\\n prompt = \\\"Are you sure to continue?(y/N) \\\"\\n answer = raw_input(prompt).strip()\\n if answer != \\\"y\\\":\\n ErrorExit(\\\"User aborted\\\")\",\n \"def FindMissingBinaries(needed_tools):\\n return [binary for binary in needed_tools if Which(binary) is None]\",\n \"def print_skipped(self,result,cause=False):\\n skipped = result.get_skipped()\\n if skipped:\\n print ('=== SKIPPED '+('='*59))\\n for u in skipped:\\n print (u.id)\\n if cause:\\n print (' ',u.get_cause())\",\n \"def skip_test(reason):\\n global test_name_text\\n print \\\"SKIP {}: {}\\\\n\\\".format(test_name_text, reason)\\n sys.exit(0)\",\n \"def list_packages(self):\\n for tag, pkg in PACKAGES.iteritems():\\n print \\\"{tag} - {label}\\\".format(tag=tag, label=pkg['label'])\",\n \"def __gather_package_data(arguments):\\n ignore_patterns, packages_path, search_packages_path = _resolve_arguments(\\n arguments.ignore_patterns,\\n arguments.packages_path,\\n arguments.search_packages_path,\\n )\\n rez_packages = set(arguments.rez_packages)\\n\\n package_finder = registry.get_package_finder(arguments.command)\\n\\n found_packages = []\\n packages, invalid_packages, skips = package_finder(\\n paths=packages_path + search_packages_path\\n )\\n\\n for package in packages:\\n if rez_packages and package.name not in rez_packages:\\n skips.append(package)\\n else:\\n found_packages.append(package)\\n\\n ignored_packages, other_packages = _split_the_ignored_packages(\\n found_packages, ignore_patterns\\n )\\n\\n other_packages = sorted(other_packages, key=operator.attrgetter(\\\"name\\\"))\\n\\n return ignored_packages, other_packages, invalid_packages, skips\",\n \"def report(*packages):\\n accepted_commands = ['python','conda']\\n for package in packages:\\n loc = \\\"not installed in this environment\\\"\\n ver = \\\"unknown\\\"\\n\\n try:\\n module = importlib.import_module(package)\\n loc = os.path.dirname(module.__file__)\\n\\n try:\\n ver = str(module.__version__)\\n except Exception:\\n pass\\n \\n except (ImportError, ModuleNotFoundError):\\n if package in accepted_commands:\\n try:\\n # See if there is a command by that name and check its --version if so\\n try:\\n loc = subprocess.check_output(['command','-v', package]).decode().splitlines()[0].strip()\\n except:\\n # .exe in case powershell (otherwise wouldn't need it)\\n loc = subprocess.check_output(['where.exe', package]).decode().splitlines()[0].strip() \\n out = \\\"\\\"\\n try:\\n out = subprocess.check_output([package, '--version'], stderr=subprocess.STDOUT)\\n except subprocess.CalledProcessError as e:\\n out = e.output\\n\\n # Assume first word in output with a period and digits is the version\\n for s in out.decode().split():\\n if '.' in s and str.isdigit(s[0]) and sum(str.isdigit(c) for c in s)>=2:\\n ver=s.strip()\\n break\\n except:\\n pass\\n elif package == 'system':\\n try:\\n ver = platform.platform(terse=True)\\n loc = \\\"OS: \\\" + platform.platform()\\n except Exception:\\n pass\\n else:\\n pass\\n \\n print(\\\"{0:30} # {1}\\\".format(package + \\\"=\\\" + ver,loc))\",\n \"def missing_dependencies_by_extra(package=\\\"sunpy\\\", exclude_extras=None):\\n exclude_extras = exclude_extras or []\\n requirements = get_requirements(package)\\n missing_dependencies = {}\\n for group in requirements.keys():\\n if group in exclude_extras:\\n continue\\n missing_dependencies[group] = find_dependencies(package, [group])[0]\\n return missing_dependencies\",\n \"def missing_required(self):\\n outstanding = list(set(self.required).difference(list(self._runopts.keys())))\\n return outstanding\",\n \"def __run(arguments, command_arguments): # pylint: disable=too-many-locals\\n ignored_packages, other_packages, invalid_packages, skips = __gather_package_data(\\n arguments\\n )\\n\\n command = registry.get_command(arguments.command)\\n\\n packages, un_ran, invalids = worker.run(\\n functools.partial(command.run, arguments=command_arguments),\\n other_packages,\\n maximum_repositories=arguments.maximum_repositories,\\n maximum_rez_packages=arguments.maximum_rez_packages,\\n keep_temporary_files=arguments.keep_temporary_files,\\n temporary_directory=arguments.temporary_directory,\\n )\\n\\n invalids.extend(invalid_packages)\\n\\n # TODO : Change `Skip` into a class and make it the same interface as an exception\\n # so that I can easily print both types at the same time, here\\n #\\n bads = invalids + skips\\n\\n if bads:\\n print(\\\"Some packages are invalid or had to be skipped.\\\")\\n print(\\\"\\\\n\\\")\\n print(sorted(error.get_package().name for error in bads))\\n\\n if un_ran:\\n print(\\\"These packages could not be run on:\\\")\\n\\n for package, error in sorted(un_ran, key=_get_package_name):\\n print(\\n \\\"{package.name}: {error}\\\".format(\\n package=package, error=str(error) or \\\"No found error message\\\"\\n )\\n )\\n\\n sys.exit(cli_constant.UN_RAN_PACKAGES_FOUND)\\n\\n if packages:\\n print(\\\"These packages were modified successfully:\\\")\\n\\n for package in sorted(packages, key=operator.attrgetter(\\\"name\\\")):\\n print(package.name)\",\n \"def get_labels_to_skip(self):\\n def _labels_from_question(question):\\n ret = {\\n question.get('label_ref'),\\n question.get('constraintMsg_ref'),\\n }\\n if question.get('options'):\\n for option in question['options']:\\n ret.add(option.get('label_ref'))\\n return ret\\n\\n labels_to_skip = defaultdict(set)\\n necessary_labels = defaultdict(set)\\n\\n for module in self.app.get_modules():\\n for form in module.get_forms():\\n questions = form.get_questions(self.app.langs, include_triggers=True,\\n include_groups=True, include_translations=True)\\n for question in questions:\\n if not question.get('label_ref'):\\n continue\\n if question['comment'] and SKIP_TRANSFEX_STRING in question['comment']:\\n labels_to_skip[form.unique_id] |= _labels_from_question(question)\\n else:\\n necessary_labels[form.unique_id] |= _labels_from_question(question)\\n\\n for form_id in labels_to_skip.keys():\\n labels_to_skip[form_id] = labels_to_skip[form_id] - necessary_labels[form_id]\\n\\n return labels_to_skip\",\n \"def check_dependencies(work_dir, fits_dir, fitsbase):\\n # Print to screen what processing steps have been selected\\n print \\\"The following processing steps have been selected:\\\\n\\\"\\n if params.do_rfifind:\\n print \\\" - PRESTO rfifind (RFI mitigation tools)\\\"\\n if params.do_prepsub:\\n print \\\" - PRESTO prepsubband (dedispersion)\\\"\\n if params.do_candsearch:\\n print \\\" - PRESTO acceleration search and candidate sifting\\\"\\n if params.do_presto_sp:\\n print \\\" - PRESTO singlepulse search (singlepulse.py)\\\"\\n # Print to screen what processing steps are being skipped\\n print \\\"\\\\nThe following processing steps are being skipped:\\\\n\\\"\\n if params.do_rfifind == 0:\\n print \\\" - PRESTO rfifind (RFI mitigation tools)\\\"\\n if params.do_prepsub == 0:\\n print \\\" - PRESTO prepsubband (dedispersion)\\\"\\n if params.do_candsearch == 0:\\n print \\\" - PRESTO acceleration search and candidate sifting\\\"\\n if params.do_presto_sp == 0:\\n print \\\" - PRESTO singlepulse search (singlepulse.py)\\\"\\n print \\\"\\\\nChecking dependencies...\\\\n\\\"\\n # There must be at least one .fits file in the fits directory\\n fl = glob(fits_dir + '/%s*.fits' %fitsbase)\\n if len(fl):\\n print \\\" Found %d file(s) in %s:\\\\n\\\" %(len(fl), fits_dir)\\n for i in fl:\\n print \\\" %s\\\\n\\\" %(i.split('/')[-1])\\n else:\\n print \\\" No %s*.fits files found in %s !\\\\n Exiting...\\\\n\\\" %(fitsbase, fits_dir)\\n sys.exit(0)\\n # If skipping the RFIFIND step in processing but want to do\\n # processing steps further down the line, then there must be a\\n # rfi_products folder in the results directory with a .mask file\\n # in it\\n if params.do_rfifind == 0 and params.use_mask and \\\\\\n (params.do_prepsub or params.do_candsearch or params.do_presto_sp):\\n mlist = glob(work_dir + '/rfi_products/*.mask')\\n if len(mlist):\\n print \\\" Using RFI .mask:\\\\n %s\\\\n\\\" %(mlist[0])\\n else:\\n print \\\" No RFI .mask found in %s/rfi_products!\\\\n Exiting...\\\\n\\\"\\\\\\n %(work_dir)\\n sys.exit(0)\\n # If skipping the PREPSUBBAND step in processing but want to\\n # do processing steps further down the line, then there must be\\n # de-dispersed time series files in the results directory of\\n # the form basename*DM*.dat and basename*DM*.inf\\n if params.do_prepsub == 0 and (params.do_candsearch or \\n params.do_presto_sp):\\n dats = glob(work_dir + '/*DM*dat')\\n infs = glob(work_dir + '/*DM*inf')\\n if not (len(dats) and len(infs)):\\n print \\\" No .dat and/or .inf files in %s!\\\\n Exiting...\\\\n\\\" %(work_dir)\\n sys.exit(0)\\n # If we haven't exited by now, then things should be good\\n print \\\"\\\\nLooks good...\\\\n\\\\n\\\"\\n # Pause for a few seconds so you can actually read the output\\n time.sleep(5)\",\n \"def CheckForUnknownFiles(self):\\r\\n unknown_files = self.GetUnknownFiles()\\r\\n if unknown_files:\\r\\n print \\\"The following files are not added to version control:\\\"\\r\\n for line in unknown_files:\\r\\n print line\\r\\n prompt = \\\"Are you sure to continue?(y/N) \\\"\\r\\n answer = raw_input(prompt).strip()\\r\\n if answer != \\\"y\\\":\\r\\n ErrorExit(\\\"User aborted\\\")\",\n \"def getMissingLangPacks(self):\\n missing = []\\n for langInfo in self._cache.getLanguageInformation():\\n #print langInfo.languageCode\\n trans_package = \\\"language-pack-%s\\\" % langInfo.languageCode\\n # we have a langpack installed, see if we have all of them\\n if (self._cache.has_key(trans_package) and \\n self._cache[trans_package].isInstalled):\\n #print \\\"IsInstalled: %s \\\" % trans_package\\n for (pkg, translation) in self._cache.pkg_translations:\\n missing += self.missingTranslationPkgs(pkg, translation+langInfo.languageCode)\\n\\n # now check for a missing default language support\\n default_lang = self.getSystemDefaultLanguage()\\n # if there is no default lang, return early\\n if default_lang is None:\\n return missing\\n if \\\"_\\\" in default_lang:\\n default_lang = default_lang.split(\\\"_\\\")[0]\\n trans_package = \\\"language-pack-%s\\\" % default_lang\\n if (self._cache.has_key(trans_package) and \\n not self._cache[trans_package].isInstalled):\\n missing += [trans_package]\\n for (pkg, translation) in self._cache.pkg_translations:\\n missing += self.missingTranslationPkgs(pkg, translation+default_lang)\\n support_packages = LanguageSelectorPkgCache._getPkgList(self._cache, default_lang)\\n for support_package in support_packages:\\n if (self._cache.has_key(support_package) and \\n not self._cache[support_package].isInstalled):\\n missing.append(support_package)\\n\\n return missing\",\n \"def calculate_missing(base_pkg, missing, file_deps, use_test_depends=False):\\n rospack = rospkg.RosPack()\\n for launch_file in file_deps.keys():\\n pkg = rospkg.get_package_name(os.path.dirname(os.path.abspath(launch_file)))\\n\\n if pkg is None: #cannot determine package\\n print(\\\"ERROR: cannot determine package for [%s]\\\"%pkg, file=sys.stderr)\\n continue\\n m = rospack.get_manifest(pkg)\\n d_pkgs = set([d.name for d in m.depends])\\n if m.is_catkin:\\n # for catkin packages consider the run dependencies instead\\n # else not released packages will not appear in the dependency list\\n # since rospkg does uses rosdep to decide which dependencies to return\\n from catkin_pkg.package import parse_package\\n p = parse_package(os.path.dirname(m.filename))\\n d_pkgs = set([d.name for d in p.run_depends])\\n if use_test_depends:\\n for d in p.test_depends:\\n d_pkgs.add(d.name)\\n # make sure we don't count ourselves as a dep\\n d_pkgs.add(pkg)\\n\\n diff = list(set(file_deps[launch_file].pkgs) - d_pkgs)\\n if not pkg in missing:\\n missing[pkg] = set()\\n missing[pkg].update(diff)\\n return missing\",\n \"def exclude_opts(cls) -> Tuple[str, ...]:\\n return \\\"required\\\", \\\"print_config\\\", \\\"config\\\", \\\"ngpu\\\"\",\n \"def troubleshoot():\\n libraries = (sys, pd, openpyxl, matplotlib, pip)\\n for i in libraries:\\n try:\\n print(str(i), 'version:', i.__version__)\\n except AttributeError:\\n pass\\n except ModuleNotFoundError:\\n print('You do not have', str(i), 'installed.')\\n print('You can do so via your interpreter or:')\\n print('py -m pip install', '-' + str(i))\\n print('in command prompt')\",\n \"def pkg_not_found_mess(pkgname: str, reponame: str) -> None:\\n meta = MainData()\\n print(('{0}Package {1}{2} {0}not found in \\\\'{3}\\\\' '\\n 'repository.{4}').format(meta.clrs['red'],\\n meta.clrs['lcyan'],\\n pkgname,\\n reponame,\\n meta.clrs['reset']))\",\n \"def _filter_pkgs(self, pkgs):\\n pkgs = [pkg.strip() for pkg in pkgs]\\n return [\\n pkg for pkg in pkgs\\n if pkg.startswith(self.base_pkg) and not pkg.startswith(os.path.join(self.base_pkg, \\\"vendor/\\\"))\\n ]\",\n \"def report_unused_cycle_suppressions(self, reporter):\\n for module in self.get_modules():\\n for dep in module.get_dependencies():\\n if not dep.suppression_used:\\n reporter.cyclic_issue(\\\"unused cycle suppression: {0} -> {1}\\\".format(module.get_name()[7:], dep.get_other_module().get_name()[7:]))\",\n \"def unusedFromKDOTDataPreparation():\",\n \"def _getDepends(self, pkg):\\r\\n vals = self._rp.get_depends(pkg, implicit=True)\\r\\n return [v for v in vals if not self._rp.get_manifest(v).is_catkin]\",\n \"def check(force, verbose, packages):\\n code = 0\\n packages = CFG.package_specs(packages)\\n if not packages:\\n print(\\\"No packages installed\\\")\\n sys.exit(0)\\n\\n for pspec in packages:\\n desired = pspec.get_desired_version_info(force=force)\\n dv = runez.bold(desired.version)\\n manifest = pspec.get_manifest()\\n if desired.problem:\\n msg = desired.problem\\n code = 1\\n\\n elif not manifest or not manifest.version:\\n msg = \\\"v%s is not installed\\\" % dv\\n code = 1\\n\\n elif manifest.version == desired.version:\\n msg = \\\"v%s is installed\\\" % dv\\n\\n else:\\n action = \\\"upgraded to\\\" if desired.source == \\\"latest\\\" else \\\"caught up to %s\\\" % desired.source\\n msg = \\\"v%s installed, can be %s v%s\\\" % (runez.dim(manifest.version), action, dv)\\n\\n print(\\\"%s: %s\\\" % (pspec.dashed, msg))\\n\\n sys.exit(code)\",\n \"def addSkip(self, test, err=\\\"\\\"):\\n\\n self.logger.info(\\\"\\\\r\\\\x1b[33;1mSKIP\\\\x1b[0m \\\" + test.shortDescription() + \\\"\\\\n\\\")\\n if err: self.logger.info(\\\"\\\\t\\\\t%s\\\\n\\\" % err)\",\n \"def check_req_utils():\\n utils = (['dmenu', 'gpg', 'pass', 'xclip', 'exo-open', 'pkill'])\\n for util in utils:\\n if find_executable(util) is None:\\n print(\\\"ERROR: Util '{}' is missing, install it before proceeding! Exiting!\\\".format(util))\\n sys.exit(1)\",\n \"def _list_all(root_pkg, prog):\\n res = \\\"\\\\n\\\".join(\\n sorted(\\n pkinspect.package_module_names(_import(root_pkg)),\\n key=str.lower,\\n ),\\n )\\n sys.stderr.write(f\\\"usage: {prog} module command [args...]\\\\nModules:\\\\n{res}\\\\n\\\")\\n return 1\",\n \"def lookup_packages(lines, skip_till=\\\"--+--\\\"):\\n packages = []\\n skip_index = None\\n\\n lines = [line.strip() for line in lines]\\n for index in range(len(lines)):\\n if skip_till in lines[index]:\\n skip_index = index + 1\\n break\\n\\n if skip_index:\\n for line in lines[skip_index:]:\\n items = line.strip(' \\\\t\\\\n\\\\r').split('|')\\n packages.append([items[1].strip(), items[3].strip(), items[5].strip()])\\n\\n return packages\",\n \"def _remove_extra_packages(frozen_pkgs, ret, **kwargs):\\n pkgs = __salt__[\\\"pkg.list_pkgs\\\"](**kwargs)\\n extra_pkgs = set(pkgs) - set(frozen_pkgs)\\n for pkg in extra_pkgs:\\n try:\\n __salt__[\\\"pkg.remove\\\"](name=pkg, **kwargs)\\n ret[\\\"pkgs\\\"][\\\"remove\\\"].append(pkg)\\n log.info(\\\"Removed extra package %s\\\", pkg)\\n except Exception as e: # pylint: disable=broad-except\\n msg = \\\"Error removing %s package: %s\\\"\\n log.error(msg, pkg, e)\\n ret[\\\"comment\\\"].append(msg % (pkg, e))\",\n \"def get_incompatible_packages():\\n pkgconfig_directory = '/usr/lib64/pkgconfig/'\\n incompatibe_packages = []\\n libraries = get_libraries_names() - set(NO_PKG_CONFIGS)\\n for library in libraries:\\n with open(pkgconfig_directory + library + '.pc') as f:\\n out = f.readlines()\\n for line in out:\\n if 'version=' in line:\\n version = line.split('=')[1].strip(linesep)\\n if not version in PMDK_VERSION.replace('~', '-'):\\n incompatibe_packages.append(library)\\n return incompatibe_packages\",\n \"def packages(self):\\n return []\",\n \"def print_deps(self):\\n\\t\\tprint self.deps, '\\\\n'\",\n \"def skip_package(self, package, reason):\\n with self._conn.begin():\\n self._conn.execute(\\n \\\"VALUES (skip_package(%s, %s))\\\", (package, reason))\",\n \"def output_ignored(self) -> List[str]:\\n output = list()\\n for ignored in sorted(self.ignored):\\n if len(ignored) == 2:\\n line = f\\\"{ignored[0]} - Ignored {ignored[1]}!\\\"\\n else:\\n line = f\\\"{ignored[0]} - {ignored[1]}: Ignored {ignored[2]}!\\\"\\n logger.info(line)\\n output.append(line)\\n return output\",\n \"def is_notebook_skipped(notebook, skip_args):\\n # These notebooks run end-to-end because they use Local Mode optionally.\\n # They execute even in the presence of docker commands, so we will explicitly not skip them\\n if str(notebook) in get_lm_optional_nb_names():\\n return False\\n\\n # Otherwise, check for presence of docker, local mode, efs, fsx or other reasons to skip\\n return is_skip_reason_other(notebook) or uses_unsupported_feature_or_framework(notebook, skip_args)\",\n \"def print_notices(cls, settings: Settings):\\n if settings.get(\\\"wallet.type\\\", \\\"in_memory\\\").lower() == \\\"indy\\\":\\n with Banner(border=\\\":\\\", length=80, file=sys.stderr) as banner:\\n banner.centered(\\\"⚠ DEPRECATION NOTICE: ⚠\\\")\\n banner.hr()\\n banner.print(\\n \\\"The Indy wallet type is deprecated, use Askar instead; see: \\\"\\n \\\"https://aca-py.org/main/deploying/IndySDKtoAskarMigration/\\\",\\n )\\n print()\",\n \"def load_skip_fail():\\n\\n if os.path.exists('SKIP_TARGETS'):\\n with open('SKIP_TARGETS') as fp:\\n skip_targets = fp.readlines()\\n skip_targets = [name.strip() for name in skip_targets if not name.startswith('#')]\\n print(f'Loaded {len(skip_targets)} target names to skip from SKIP_TARGETS')\\n else:\\n print('No file called SKIP_TARGETS')\\n skip_targets = []\\n\\n if os.path.exists('FAILED_TARGETS'):\\n nfail = 0\\n with open('FAILED_TARGETS') as fp:\\n for line in fp:\\n if not line.startswith('#'):\\n arr = line.split()\\n target = arr[0].replace('~',' ')\\n skip_targets.append(target.replace('~',' '))\\n nfail += 1\\n\\n print(f'Loaded {nfail} target names from FAILED_TARGETS')\\n else:\\n print('No file called FAILED_TARGETS')\\n\\n return skip_targets\",\n \"def check(self, quiet=False, exclude=None):\\n\\n exclude = exclude if exclude else []\\n missing = set()\\n pkg_types = set()\\n python_interpreters = set()\\n vcs_types = set()\\n\\n # package-defined requirements check\\n for pkg in self.pkgs:\\n if pkg.type not in exclude:\\n pkg_types.add(pkg.type)\\n if pkg.vcs_type not in exclude:\\n vcs_types.add(pkg.vcs_type)\\n\\n if pkg.type == PackageType.AUTOTOOLS:\\n if pkg.autotools_autoreconf:\\n if AUTORECONF_COMMAND not in exclude:\\n if AUTORECONF.exists():\\n self._verbose_exists(AUTORECONF)\\n else:\\n missing.add(AUTORECONF.tool)\\n\\n elif pkg.type == PackageType.PYTHON:\\n if pkg.python_interpreter:\\n if pkg.python_interpreter not in exclude:\\n python_tool = PythonTool(pkg.python_interpreter)\\n python_interpreters.add(python_tool)\\n else:\\n python_interpreters.add(PYTHON)\\n\\n if PackageType.AUTOTOOLS in pkg_types or PackageType.MAKE in pkg_types:\\n if MAKE.exists():\\n self._verbose_exists(MAKE)\\n else:\\n missing.add(MAKE.tool)\\n\\n if PackageType.CMAKE in pkg_types:\\n if CMAKE.exists():\\n self._verbose_exists(CMAKE)\\n else:\\n missing.add(CMAKE.tool)\\n\\n if PackageType.MESON in pkg_types:\\n if MESON.exists():\\n self._verbose_exists(MESON)\\n else:\\n missing.add(MESON.tool)\\n\\n if PackageType.PYTHON in pkg_types:\\n for interpreter in python_interpreters:\\n if interpreter.exists():\\n self._verbose_exists(interpreter)\\n else:\\n missing.add(interpreter.tool)\\n\\n if PackageType.SCONS in pkg_types:\\n if SCONS.exists():\\n self._verbose_exists(SCONS)\\n else:\\n missing.add(SCONS.tool)\\n\\n if VcsType.BZR in vcs_types:\\n if BZR.exists():\\n self._verbose_exists(BZR)\\n else:\\n missing.add(BZR.tool)\\n\\n if VcsType.CVS in vcs_types:\\n if CVS.exists():\\n self._verbose_exists(CVS)\\n else:\\n missing.add(CVS.tool)\\n\\n if VcsType.GIT in vcs_types:\\n if GIT.exists():\\n self._verbose_exists(GIT)\\n else:\\n missing.add(GIT.tool)\\n\\n if VcsType.HG in vcs_types:\\n if HG.exists():\\n self._verbose_exists(HG)\\n else:\\n missing.add(HG.tool)\\n\\n if VcsType.PERFORCE in vcs_types:\\n if GIT.exists():\\n self._verbose_exists(GIT)\\n else:\\n missing.add(GIT.tool)\\n\\n if VcsType.RSYNC in vcs_types:\\n if RSYNC.exists():\\n self._verbose_exists(RSYNC)\\n else:\\n missing.add(RSYNC.tool)\\n\\n if VcsType.SCP in vcs_types:\\n if SCP.exists():\\n self._verbose_exists(SCP)\\n else:\\n missing.add(SCP.tool)\\n\\n if VcsType.SVN in vcs_types:\\n if SVN.exists():\\n self._verbose_exists(SVN)\\n else:\\n missing.add(SVN.tool)\\n\\n # project-provided tools check\\n for tool in self.tools:\\n if tool not in exclude:\\n if which(tool):\\n verbose('prerequisite exists: ' + tool)\\n else:\\n missing.add(tool)\\n\\n if missing and not quiet:\\n sorted_missing = list(missing)\\n sorted_missing.sort()\\n\\n msg = 'missing the following host tools for this project:'\\n msg += '\\\\n'\\n msg += '\\\\n'\\n for entry in sorted_missing:\\n msg += ' ' + entry + '\\\\n'\\n err(msg)\\n\\n return len(missing) == 0\",\n \"def required_tool_results():\\n raise NotImplementedError()\",\n \"def check_packages(options):\\n print '\\\\033[1;33m# Checking direct VIKI dependencies\\\\033[1;m'\\n installed_ok = dependencies.check_installed_packages()\\n print '\\\\n\\\\033[1;33m# Checking second level ROS dependencies, using rosdep\\\\033[1;m'\\n second_level_ok = dependencies.get_second_level_dependencies()\\n\\n if installed_ok and second_level_ok:\\n print '\\\\033[1;32mAll dependencies satisfied!\\\\033[1;m'\\n else:\\n print '\\\\033[1;31mTry running [viki install-dependencies] to install the dependencies\\\\033[1;m'\",\n \"def test_DEPRECATION_PROCESS(self):\\n self.verify_references_to_prerequisites(processes.DEPRECATION_PROCESS)\",\n \"def skip_dti_tests():\\n return True\",\n \"def remove_packages(self, packages):\",\n \"def test_collect_detection_of_optional_dependencies_in_playbooks(\\n self, integration_command, module_repo\\n ):\\n test_input = [\\n {\\n \\\"Dummy Playbook\\\": {\\n \\\"name\\\": \\\"Dummy Playbook\\\",\\n \\\"file_path\\\": \\\"dummy_path\\\",\\n \\\"fromversion\\\": \\\"dummy_version\\\",\\n \\\"implementing_scripts\\\": [],\\n \\\"implementing_playbooks\\\": [],\\n \\\"command_to_integration\\\": {integration_command: \\\"\\\"},\\n \\\"tests\\\": [\\\"dummy_playbook\\\"],\\n \\\"pack\\\": \\\"dummy_pack\\\",\\n }\\n }\\n ]\\n\\n found_result_set = PackDependencies._collect_playbooks_dependencies(\\n pack_playbooks=test_input,\\n id_set=module_repo.id_set.read_json_as_dict(),\\n )\\n\\n assert len(found_result_set) == 0\",\n \"def check_puppet_logs_ubuntu(self):\\n\\n remote = self.env.get_admin_remote()\\n\\n err_start = 'The following packages have unmet dependencies:'\\n err_end = ('Unable to correct problems,'\\n ' you have held broken packages.')\\n cmd = ('fgrep -h -e \\\" Depends: \\\" -e \\\"{0}\\\" -e \\\"{1}\\\" '\\n '/var/log/docker-logs/remote/node-*/'\\n 'puppet*.log'.format(err_start, err_end))\\n result = remote.execute(cmd)['stdout']\\n\\n err_deps = {}\\n err_deps_key = ''\\n err_deps_flag = False\\n\\n # Forming a dictionary of package names\\n # with sets of required packages.\\n for res_str in result:\\n if err_deps_flag:\\n if err_end in res_str:\\n err_deps_flag = False\\n elif \\\": Depends:\\\" in res_str:\\n str0, str1, str2 = res_str.partition(': Depends:')\\n err_deps_key = ''.join(str0.split()[-1:])\\n if err_deps_key not in err_deps:\\n err_deps[err_deps_key] = set()\\n if 'but it is not' in str2 or 'is to be installed' in str2:\\n err_deps[err_deps_key].add('Depends:{0}'\\n .format(str2))\\n elif 'Depends:' in res_str and err_deps_key:\\n str0, str1, str2 = res_str.partition('Depends:')\\n if 'but it is not' in str2 or 'is to be installed' in str2:\\n err_deps[err_deps_key].add(str1 + str2)\\n else:\\n err_deps_key = ''\\n elif err_start in res_str:\\n err_deps_flag = True\\n\\n return err_deps\",\n \"def isIgnoredPkg(self, *args):\\n return _libsbml.SBMLDocument_isIgnoredPkg(self, *args)\",\n \"def ask_continue():\\n i = input(\\\"Please ensure your System Dependencies are met. Continue? [y/N] \\\")\\n if i in (\\\"\\\", \\\"N\\\", \\\"n\\\"):\\n out_error(\\\"Please install system dependencies to continue\\\")\\n exit(1)\",\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 remove_packages_ignored_since(days, paths=None, dry_run=False, verbose=False):\\n num_removed = 0\\n\\n for path in (paths or config.packages_path):\\n repo = package_repository_manager.get_repository(path)\\n\\n if verbose:\\n print_info(\\\"Searching %s...\\\", repo)\\n\\n num_removed += repo.remove_ignored_since(\\n days=days,\\n dry_run=dry_run,\\n verbose=verbose\\n )\\n\\n return num_removed\",\n \"def checkOptionalDependencies(self):\\n \\n # skip dependency check for downloading only\\n if( self.downloadOnly ):\\n return\\n\\n # soft dependencies\\n failed = []\\n for opt in self.optmodules:\\n mod = self.parent.module(opt)\\n if( mod == None ):\\n failed.append(opt)\\n \\n # remove soft dependencies that were not found\\n self.buildWithout(failed)\",\n \"def cleanup(self):\\n results = run_command(\\\"gppkg -q --all\\\")\\n gppkgs = results.split('\\\\n')[self.start_output:self.end_output] #The first line is 'Starting gppkg with args', which we want to ignore.\\n\\n for gppkg in gppkgs:\\n run_command(\\\"gppkg --remove \\\" + gppkg)\",\n \"def _missing_symbol_to_skipped_tests(self):\\n return {\\n \\\"MathMLElement\\\": [\\\"mathml\\\"],\\n \\\"GraphicsLayer\\\": [\\\"compositing\\\"],\\n \\\"WebCoreHas3DRendering\\\": [\\\"animations/3d\\\", \\\"transforms/3d\\\"],\\n \\\"WebGLShader\\\": [\\\"fast/canvas/webgl\\\", \\\"compositing/webgl\\\", \\\"http/tests/canvas/webgl\\\"],\\n \\\"MHTMLArchive\\\": [\\\"mhtml\\\"],\\n }\",\n \"def log_installed_python_prereqs():\\n sh(\\\"pip freeze > {}\\\".format(Env.GEN_LOG_DIR + \\\"/pip_freeze.log\\\"))\",\n \"def missingTranslationPkgs(self, pkg, translation_pkg):\\n\\n # FIXME: this function is called too often and it's too slow\\n # -> see ../TODO for ideas how to fix it\\n missing = []\\n # check if the pkg itself is available and installed\\n if not self._cache.has_key(pkg):\\n return missing\\n if not self._cache[pkg].isInstalled:\\n return missing\\n\\n # match every packages that looks similar to translation_pkg\\n # \\n for pkg in self._cache:\\n if (pkg.name == translation_pkg or\\n pkg.name.startswith(translation_pkg+\\\"-\\\")):\\n if not pkg.isInstalled and pkg.candidateVersion != None:\\n missing.append(pkg.name)\\n return missing\",\n \"def extra_removed_packages(self, index: int) -> Packages:\\n log = self[index]\\n if (\\n not log.startswith(\\\"conda remove\\\")\\n and not log.startswith(\\\"pip uninstall\\\")\\n and not (log.startswith(R_COMMAND) and \\\"remove.packages\\\" in log)\\n ):\\n raise CondaEnvTrackerParseHistoryError(\\n f\\\"The log at index {index} is not a remove statement: {self[index]}.\\\"\\n )\\n if log.startswith(\\\"conda remove\\\"):\\n package_names = self._extract_conda_remove_package_names(log)\\n elif log.startswith(\\\"pip uninstall\\\"):\\n package_names = log.replace(\\\"pip uninstall \\\", \\\"\\\").split()\\n else:\\n package_names = self._extract_r_remove_package_names(log)\\n return Packages.from_specs(package_names)\",\n \"def list_missing_for_deposit(self, needs: Tuple) -> List[int]:\\n missing = []\\n for item in needs:\\n if not any(self.needed_keywords_list(item)):\\n missing.append(item)\\n return missing\",\n \"def test_missing_proteins():\\n\\n rv, out = getstatusoutput(f'{prg} -p {proteins}')\\n assert rv > 0\\n assert re.search('the following arguments are required: -c/--cdhit', out)\",\n \"def list_providers_packages():\\n providers = get_all_providers()\\n # if provider needs to be not considered in release add it here\\n # this is useful for cases where provider is WIP for a long period thus we don't want to release it yet.\\n providers_to_remove_from_release = []\\n for provider in providers:\\n if provider in providers_to_remove_from_release:\\n continue\\n console.print(provider)\",\n \"def list_cmd(repo):\\n click.echo('Packages and scripts installed through pipsi:')\\n for venv, scripts in repo.list_everything():\\n if not scripts:\\n continue\\n click.echo(' Package \\\"%s\\\":' % venv)\\n for script in scripts:\\n click.echo(' ' + script)\",\n \"def requirement_missing(script):\\n if \\\"requires\\\" in script:\\n if script[\\\"requires\\\"] is None:\\n return False\\n for package in script[\\\"requires\\\"].split():\\n try:\\n pkg_resources.working_set.require(package)\\n except Exception:\\n return True\\n return False\",\n \"def isDisabledIgnoredPackage(self, *args):\\n return _libsbml.SBMLDocument_isDisabledIgnoredPackage(self, *args)\",\n \"def prompt_for_exclusions(skip_prompt):\\n\\n prompt = (\\n \\\"Do you want to exclude any domains?\\\\n\\\"\\n \\\"For example, hulu.com video streaming must be able to access \\\"\\n \\\"its tracking and ad servers in order to play video.\\\"\\n )\\n\\n if not skip_prompt:\\n if query_yes_no(prompt):\\n return True\\n else:\\n print(\\\"OK, we'll only exclude domains in the whitelist.\\\")\\n\\n return False\",\n \"def ignore_from_package(self, project, package, arch, ignore):\\n for binary in binary_list(self.apiurl, project, 'standard', arch, package):\\n ignore.add(binary.name)\\n\\n return ignore\",\n \"def optional_packages():\\n with open(r\\\"tests/input.yml\\\") as file:\\n inputs = yaml.load(file, Loader=yaml.FullLoader)\\n return inputs[\\\"optional_packages\\\"]\",\n \"def show_rev_deps(self, package):\\n return self.show_deps(package, \\\"show-rev-deps\\\")\",\n \"def missing_in_gyp_by_file(self):\\n return self._missing_gyp_files\",\n \"def test_list_upgrades_absent(self):\\n pkg_cmd = MagicMock(return_value=\\\"\\\")\\n\\n with patch.dict(pkgng.__salt__, {\\\"cmd.run_stdout\\\": pkg_cmd}):\\n result = pkgng.list_upgrades(refresh=False)\\n self.assertDictEqual(result, {})\\n pkg_cmd.assert_called_with(\\n [\\\"pkg\\\", \\\"upgrade\\\", \\\"--dry-run\\\", \\\"--quiet\\\", \\\"--no-repo-update\\\"],\\n output_loglevel=\\\"trace\\\",\\n python_shell=False,\\n ignore_retcode=True,\\n )\",\n \"def getNonInstallableProfiles(self):\\n return [\\n 'onlyoffice.plone:uninstall',\\n ]\",\n \"def log_imported_packages(self):\\n imported_packages_dict = self.get_imported_packages()\\n\\n res_str = \\\"\\\\n\\\".join(f\\\"{module}: {version_num}\\\" for module, version_num\\n in imported_packages_dict[\\\"results\\\"].items())\\n no_res_str = \\\"\\\\n\\\".join(f\\\"{module}: {version_num}\\\" for module, version_num\\n in imported_packages_dict[\\\"no_results\\\"].items())\\n errs_res_str = \\\"\\\\n\\\".join(f\\\"{module}: {version_num}\\\" for module, version_num\\n in imported_packages_dict[\\\"errors\\\"].items())\\n\\n msg = f\\\"Imported modules:\\\\n {res_str}\\\\n {no_res_str}\\\\n {errs_res_str}\\\"\\n logger.info(msg)\",\n \"def test_compatibility_of_version_of_installed_rpm_packages(self):\\n incompatible_packages = get_incompatible_packages()\\n error_msg = linesep + 'List of incompatible packages: '\\n for package in incompatible_packages:\\n error_msg += linesep + package\\n self.assertFalse(incompatible_packages, error_msg)\",\n \"def missing_ltihooks(finder, caller):\\n caller.IgnoreName(\\\"ltihooks\\\")\",\n \"def show_solution_differences_to_user(self, solution: List['Package'], upstream_system: 'System',\\n noconfirm: bool, deep_search: bool, solution_way: bool):\\n\\n # needed strings\\n package_to_install = aurman_note(\\n \\\"The following {} package(s) are getting {}:\\\".format(\\n \\\"{}\\\", Colors.BOLD(Colors.LIGHT_CYAN(\\\"installed\\\"))\\n ), True, False\\n )\\n packages_to_uninstall = aurman_note(\\n \\\"The following {} package(s) are predicted to get {}:\\\".format(\\n \\\"{}\\\", Colors.BOLD(Colors.LIGHT_CYAN(\\\"removed\\\"))\\n ), True, False\\n )\\n packages_to_upgrade = aurman_note(\\n \\\"The following {} package(s) are getting {}:\\\".format(\\n \\\"{}\\\", Colors.BOLD(Colors.LIGHT_CYAN(\\\"updated\\\"))\\n ), True, False\\n )\\n packages_to_reinstall = aurman_note(\\n \\\"The following {} package(s) are getting {}:\\\".format(\\n \\\"{}\\\", Colors.BOLD(Colors.LIGHT_CYAN(\\\"reinstalled\\\"))\\n ), True, False\\n )\\n user_question = \\\"Do you want to continue?\\\"\\n\\n new_system = self.hypothetical_append_packages_to_system(solution)\\n differences_to_this_system_tuple = self.differences_between_systems((new_system,))[0]\\n\\n to_install_names = set([package.name for package in differences_to_this_system_tuple[0]])\\n to_uninstall_names = set([package.name for package in differences_to_this_system_tuple[1]])\\n to_upgrade_names = to_install_names & to_uninstall_names\\n to_install_names -= to_upgrade_names\\n to_uninstall_names -= to_upgrade_names\\n just_reinstall_names = set(\\n [package.name for package in solution if package.name in new_system.all_packages_dict]\\n ) - set.union(\\n *[to_upgrade_names, to_install_names, to_uninstall_names]\\n )\\n\\n # colored names + repos\\n print_to_install_names = set([upstream_system.repo_of_package(name) for name in to_install_names])\\n print_to_uninstall_names = set([upstream_system.repo_of_package(name) for name in to_uninstall_names])\\n print_to_upgrade_names = set([upstream_system.repo_of_package(name) for name in to_upgrade_names])\\n print_just_reinstall_names = set([upstream_system.repo_of_package(name) for name in just_reinstall_names])\\n\\n # calculate some needed values\\n max_package_name_length = max(\\n [\\n len(name) for name in\\n set(print_to_install_names |\\n print_to_uninstall_names |\\n print_to_upgrade_names |\\n print_just_reinstall_names)\\n ],\\n default=0\\n )\\n\\n max_left_side_version_length = max(\\n [\\n len(self.all_packages_dict[package_name].version) for package_name in\\n set(to_uninstall_names | to_upgrade_names | just_reinstall_names)\\n ],\\n default=1\\n )\\n\\n if to_install_names:\\n print(package_to_install.format(len(to_install_names)))\\n for package_name in sorted(list(to_install_names)):\\n string_to_print = \\\" {} {} -> {}\\\".format(\\n upstream_system.repo_of_package(package_name).ljust(max_package_name_length),\\n Colors.RED(\\\"/\\\").ljust(max_left_side_version_length + 10),\\n Colors.GREEN(new_system.all_packages_dict[package_name].version)\\n )\\n\\n print(string_to_print)\\n\\n if to_upgrade_names:\\n print(packages_to_upgrade.format(len(to_upgrade_names)))\\n for package_name in sorted(list(to_upgrade_names)):\\n string_to_print = \\\" {} {} -> {}\\\".format(\\n upstream_system.repo_of_package(package_name).ljust(max_package_name_length),\\n Colors.RED(self.all_packages_dict[package_name].version).ljust(max_left_side_version_length + 10),\\n Colors.GREEN(new_system.all_packages_dict[package_name].version)\\n )\\n\\n print(string_to_print)\\n\\n if just_reinstall_names and not deep_search:\\n print(packages_to_reinstall.format(len(just_reinstall_names)))\\n for package_name in sorted(list(just_reinstall_names)):\\n string_to_print = \\\" {} {} -> {}\\\".format(\\n upstream_system.repo_of_package(package_name).ljust(max_package_name_length),\\n Colors.LIGHT_MAGENTA(self.all_packages_dict[package_name].version).ljust(\\n max_left_side_version_length + 10\\n ),\\n Colors.LIGHT_MAGENTA(new_system.all_packages_dict[package_name].version)\\n )\\n\\n print(string_to_print)\\n\\n if to_uninstall_names:\\n print(packages_to_uninstall.format(len(to_uninstall_names)))\\n for package_name in sorted(list(to_uninstall_names)):\\n string_to_print = \\\" {} {} -> {}\\\".format(\\n upstream_system.repo_of_package(package_name).ljust(max_package_name_length),\\n Colors.GREEN(self.all_packages_dict[package_name].version).ljust(max_left_side_version_length + 10),\\n Colors.RED(\\\"/\\\")\\n )\\n\\n print(string_to_print)\\n\\n # print why those packages have to be uninstalled\\n self.hypothetical_append_packages_to_system(solution, packages_names_print_reason=to_uninstall_names)\\n\\n # check if no dependency breakage happens\\n if not solution_way:\\n self.hypothetical_append_packages_to_system(solution, check_if_possible=True)\\n\\n if solution_way:\\n aurman_status(\\\"The following will be done:\\\", new_line=True)\\n if deep_search:\\n aurman_note(\\\"You are using {}, hence {} is active.\\\".format(\\n Colors.BOLD(\\\"--deep_search\\\"), Colors.BOLD(\\\"--needed\\\")\\n ))\\n aurman_note(\\\"That means packages to be reinstalled will not actually be reinstalled.\\\")\\n self.hypothetical_append_packages_to_system(solution, print_way=True)\\n\\n if not noconfirm and not ask_user(user_question, True, True):\\n raise InvalidInput()\",\n \"def skip_project_message():\\n\\n return ' - Skip project'\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7548334","0.75025696","0.6658978","0.64952445","0.59089476","0.58754075","0.5860346","0.5699727","0.5639692","0.5637996","0.5636697","0.5571671","0.5533277","0.55121475","0.54966754","0.5486724","0.5446966","0.54336095","0.53756714","0.53676933","0.53107494","0.5305312","0.52908194","0.52864367","0.526763","0.52527773","0.5222709","0.5217873","0.52129894","0.5205187","0.52023757","0.5199799","0.5195615","0.5187358","0.51812387","0.51755327","0.51632196","0.5161849","0.51277936","0.5125914","0.5105642","0.5101416","0.50944316","0.5092622","0.5091721","0.5067457","0.5046173","0.5044897","0.5023837","0.5017794","0.49817008","0.49810112","0.49790984","0.4972742","0.49698642","0.4937681","0.49351013","0.4934194","0.49333385","0.4932202","0.4931558","0.49308607","0.49301046","0.4929862","0.49281114","0.49185622","0.49164087","0.49159992","0.4912117","0.49011335","0.48966014","0.48901623","0.4889736","0.48851597","0.48734578","0.48720208","0.48649728","0.48615843","0.48555705","0.4853387","0.48521405","0.48278335","0.48246884","0.48154598","0.48110223","0.48052797","0.47946987","0.47932217","0.47929463","0.47922957","0.47890642","0.47857615","0.47854012","0.47823495","0.4778799","0.47722605","0.47605294","0.47538447","0.47516465","0.47494292"],"string":"[\n \"0.7548334\",\n \"0.75025696\",\n \"0.6658978\",\n \"0.64952445\",\n \"0.59089476\",\n \"0.58754075\",\n \"0.5860346\",\n \"0.5699727\",\n \"0.5639692\",\n \"0.5637996\",\n \"0.5636697\",\n \"0.5571671\",\n \"0.5533277\",\n \"0.55121475\",\n \"0.54966754\",\n \"0.5486724\",\n \"0.5446966\",\n \"0.54336095\",\n \"0.53756714\",\n \"0.53676933\",\n \"0.53107494\",\n \"0.5305312\",\n \"0.52908194\",\n \"0.52864367\",\n \"0.526763\",\n \"0.52527773\",\n \"0.5222709\",\n \"0.5217873\",\n \"0.52129894\",\n \"0.5205187\",\n \"0.52023757\",\n \"0.5199799\",\n \"0.5195615\",\n \"0.5187358\",\n \"0.51812387\",\n \"0.51755327\",\n \"0.51632196\",\n \"0.5161849\",\n \"0.51277936\",\n \"0.5125914\",\n \"0.5105642\",\n \"0.5101416\",\n \"0.50944316\",\n \"0.5092622\",\n \"0.5091721\",\n \"0.5067457\",\n \"0.5046173\",\n \"0.5044897\",\n \"0.5023837\",\n \"0.5017794\",\n \"0.49817008\",\n \"0.49810112\",\n \"0.49790984\",\n \"0.4972742\",\n \"0.49698642\",\n \"0.4937681\",\n \"0.49351013\",\n \"0.4934194\",\n \"0.49333385\",\n \"0.4932202\",\n \"0.4931558\",\n \"0.49308607\",\n \"0.49301046\",\n \"0.4929862\",\n \"0.49281114\",\n \"0.49185622\",\n \"0.49164087\",\n \"0.49159992\",\n \"0.4912117\",\n \"0.49011335\",\n \"0.48966014\",\n \"0.48901623\",\n \"0.4889736\",\n \"0.48851597\",\n \"0.48734578\",\n \"0.48720208\",\n \"0.48649728\",\n \"0.48615843\",\n \"0.48555705\",\n \"0.4853387\",\n \"0.48521405\",\n \"0.48278335\",\n \"0.48246884\",\n \"0.48154598\",\n \"0.48110223\",\n \"0.48052797\",\n \"0.47946987\",\n \"0.47932217\",\n \"0.47929463\",\n \"0.47922957\",\n \"0.47890642\",\n \"0.47857615\",\n \"0.47854012\",\n \"0.47823495\",\n \"0.4778799\",\n \"0.47722605\",\n \"0.47605294\",\n \"0.47538447\",\n \"0.47516465\",\n \"0.47494292\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.80562556"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":219,"numItemsPerPage":100,"numTotalItems":95772,"offset":21900,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjYzMTMxMCwianRpIjoiYTJmNTRjYWEtNjhjOS00MDEzLTkyMDQtMDA5MjcwNmQwZmIyIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY2MzQ5MTAsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.kfrsXKxDmKKjdaWp1PTDFvCRO1ZN9zjM6N6VLXsMzeSZmDJ5EZZQlG77H3AVzbuWZX4hAqVLs2LqgP8qfo0LBA","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 |
|---|---|---|---|---|---|---|
homepage for a user after they've logged in | def user_home(request):
# crop = Crop.objects.get(user=request.user)
return render(request, 'user_home.html', locals()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def homepage():\n if g.user:\n return redirect(f\"/user/{g.user.id}\")\n else:\n return redirect(\"/landing\")",
"def index(self):\n\n # try and pull the user's data\n user = get_active_user_data()\n\n if not user:\n # they are not logged in give them the login... | [
"0.81222904",
"0.7832682",
"0.75567484",
"0.75296766",
"0.7426215",
"0.742084",
"0.74105",
"0.7408028",
"0.7394464",
"0.73910797",
"0.7343856",
"0.7277008",
"0.72597903",
"0.72444713",
"0.7223275",
"0.7219461",
"0.7183288",
"0.7182784",
"0.71827203",
"0.71667844",
"0.71570003... | 0.69481254 | 38 |
Obtient la Tactic de chaque robot et fait progresser la FSM. | def exec(self):
for player_id in range(0, 6):
ai_command = self.info_manager.get_player_tactic(player_id).exec()
self.info_manager.set_player_next_action(player_id, ai_command) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move2goal(self):\n vel_msg = Twist()\n\n # Linear velocity in the x-axis.\n vel_msg.linear.x = 0.4 # m/s\n vel_msg.linear.y = 0\n vel_msg.linear.z = 0\n\n # Angular velocity in the z-axis.\n vel_msg.angular.x = 0\n vel_msg.angular.y = 0\n vel_msg.a... | [
"0.65182215",
"0.62783974",
"0.62494963",
"0.62122065",
"0.6137736",
"0.6120038",
"0.60663146",
"0.6011599",
"0.59987426",
"0.59779406",
"0.5975645",
"0.59697425",
"0.59690607",
"0.59598845",
"0.5932181",
"0.59319246",
"0.5931754",
"0.5907128",
"0.5897831",
"0.58944696",
"0.5... | 0.0 | -1 |
Construct a new NAdam / Adam / AdamW / NAdamW optimizer. | def __init__(
self,
learning_rate=None,
beta1=0.9,
beta2=0.999,
epsilon=1e-8,
adamw_weight_decay=0.0,
l2_weight_decay=0.0,
use_nesterov=False,
use_bias_correction=True,
constant_fraction=1.0,
warmup_fraction=0.0,
min_learning_rate_mult=1.0,
t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_model_optimizer(net,alpha):\n optimizer = chainer.optimizers.Adam(alpha=alpha)\n optimizer.setup(net)\n return optimizer",
"def build_optimizer(model: nn.Module, args: Namespace) -> Optimizer:\n params = [{'params': model.parameters(), 'lr': args.init_lr, 'weight_decay': 0}]\n\n return ... | [
"0.6872795",
"0.68105716",
"0.68094224",
"0.6398735",
"0.6390516",
"0.6375885",
"0.6327188",
"0.62951666",
"0.62668395",
"0.6203197",
"0.6187571",
"0.61425275",
"0.6135006",
"0.6104655",
"0.60901296",
"0.60718906",
"0.60455495",
"0.6041876",
"0.60281724",
"0.59510404",
"0.593... | 0.59131265 | 21 |
Get a OptimizerDef for the given configuration and training_steps. | def optimizer_for_idx(idx, training_steps):
config = common.get_optimizer_config(idx)
config['training_steps'] = training_steps
return NAdamWCosineDecay(**config) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_optimizer(\n batch_size: int,\n steps_per_epoch: int,\n lr_name: Text = defaults.LR_NAME_DEFAULT,\n optimizer_name: Text = defaults.OP_NAME_DEFAULT,\n lr_params: Dict[Text, Any] = defaults.LR_CONFIG_DEFAULT,\n optimizer_params: Dict[Text, Any] = defaults.OP_CONFIG_DEFAULT,\n) -> tf.keras... | [
"0.56548405",
"0.5534678",
"0.5419",
"0.53470206",
"0.53421885",
"0.5340555",
"0.53079665",
"0.511747",
"0.50874454",
"0.50743484",
"0.5059995",
"0.5049988",
"0.50252277",
"0.5016428",
"0.50158036",
"0.49935558",
"0.498744",
"0.49774894",
"0.49573946",
"0.49332434",
"0.491900... | 0.5022623 | 13 |
Continuously read lines from the given file, note that the file will have to be reopend and read from again if the application writing to the file stops and reopens the file for writing. | def tail(self, file):
line=''
while self.running:
tmp = file.readline()
if tmp:
line += tmp
if line.endswith("\n"):
yield line
line = ''
else:
time.sleep(0.5) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_lines(self, file_path, empty_lines=False, signal_ready=True):\n file_handler, file_id = self._get_file(file_path)\n file_handler.seek(0, os.SEEK_END)\n\n if signal_ready:\n self.signal_ready()\n\n while self.thread_server.is_alive():\n line = six.text_type... | [
"0.6835908",
"0.68097013",
"0.63850206",
"0.63652855",
"0.6350695",
"0.63241774",
"0.62548393",
"0.6244439",
"0.6220739",
"0.6167783",
"0.6144125",
"0.6113636",
"0.6090018",
"0.6064431",
"0.6017879",
"0.5972722",
"0.5907144",
"0.5901055",
"0.5857637",
"0.58532095",
"0.5850574... | 0.6530146 | 2 |
Start the thread running | def run(self):
for line in self.tail(self.opened_file):
self.log_line.emit(line.strip('\n')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start(self):\n \n self.thread.start()\n self.state = \"running\"",
"def start(self):\n self.thread.start()",
"def start_thread(self):\n self.stop_thread()\n self.running = True\n self.run_thread = threading.Thread(target=self.run, daemon=True)\n self.... | [
"0.84637225",
"0.8462581",
"0.8356644",
"0.8344301",
"0.8142931",
"0.8071529",
"0.8020542",
"0.7930717",
"0.7900409",
"0.77552056",
"0.7620005",
"0.7588421",
"0.75637186",
"0.7521533",
"0.74996144",
"0.74370766",
"0.7424744",
"0.7424744",
"0.7391063",
"0.73651403",
"0.7357051... | 0.0 | -1 |
Begins the alien and defines its initial postition. | def __init__(self, ai_settings, screen):
super(Alien, self).__init__()
self.screen = screen
self.ai_settings = ai_settings
# Loads the alien's image and defines its rect attribute
self.image = pygame.image.load('images/alien.bmp')
self.rect = self.image.get_rect()
# Begins each new alien close to th... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def begin(self):\n pass",
"def initiate(self, DNA, Pol, Hel):",
"def begin_auto_resting(self):\n self.state = 'autoresting'\n self.index = 1\n self.x_vel = self.y_vel = 0\n self.move_timer = self.current_time",
"def enter(self):\n # lets not immediately run the anima... | [
"0.587834",
"0.57635504",
"0.5745311",
"0.56670755",
"0.55616534",
"0.5551754",
"0.552442",
"0.5503704",
"0.54616594",
"0.5354884",
"0.5354872",
"0.5354763",
"0.53459424",
"0.5313377",
"0.5265768",
"0.5263633",
"0.5236484",
"0.5232484",
"0.52293867",
"0.52149266",
"0.5199032"... | 0.52787346 | 14 |
Draws the alien on its current position. | def blitme(self):
self.screen.blit(self.image, self.rect) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw():\n screen.fill((0, 0, 0))\n alien.draw()",
"def draw_a(self):\r\n pen.down()\r\n pen.left(90)\r\n pen.forward(40)\r\n pen.right(90)\r\n pen.forward(40)\r\n pen.right(90)\r\n pen.forward(40)\r\n pen.up()\r\n pen.back(20)\r\n pen.... | [
"0.7508646",
"0.73021597",
"0.71425086",
"0.70783895",
"0.7015024",
"0.7002362",
"0.7001692",
"0.6818366",
"0.6578184",
"0.6490179",
"0.64296824",
"0.638066",
"0.6345341",
"0.6289084",
"0.6260745",
"0.62555075",
"0.62202793",
"0.6213915",
"0.6207679",
"0.6192816",
"0.61897635... | 0.0 | -1 |
Returns True is the alien is in the scree's edge. | def check_edges(self):
screen_rect = self.screen.get_rect()
if self.rect.right >= screen_rect.right:
return True
elif self.rect.left <= 0:
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isEdge(self,x,y):\n\t\treturn y in self._dict[x]",
"def isEdge(self,x,y):\n\t\treturn y in self._dictOut[x]",
"def containsEdge(self, e):\n return any(e.nvt in [self.vertices[i-2], self.vertices[i]] and self.vertices[i-1] == e.pvt for i in range(len(self.vertices)))",
"def __contains__(self, edge)... | [
"0.67390007",
"0.6689531",
"0.66346663",
"0.65844536",
"0.6580659",
"0.6557901",
"0.65327895",
"0.64890575",
"0.6484122",
"0.6412592",
"0.6396653",
"0.63721454",
"0.63186455",
"0.6302562",
"0.6260699",
"0.6248611",
"0.6222273",
"0.6212628",
"0.6211989",
"0.620916",
"0.6201092... | 0.59922844 | 36 |
Moves the alien to the right or left. | def update(self):
self.x += (self.ai_settings.alien_speed_factor *
self.ai_settings.fleet_direction)
self.rect.x = self.x | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def right(self):\n self.move(1,0)",
"def go_right(self):\n self.change_x = 6\n self.direction = \"R\"",
"def move_right(self):\n if self.change_valid(dx=1):\n self.x += 1",
"def turn_right(self):\n temp = self.direction[0]\n self.direction[0] = -self.direc... | [
"0.7879658",
"0.74682367",
"0.728294",
"0.7279964",
"0.7238093",
"0.7197162",
"0.7197162",
"0.7176678",
"0.71191716",
"0.7107606",
"0.7102793",
"0.7050394",
"0.7011423",
"0.70082074",
"0.6980706",
"0.6903258",
"0.68720716",
"0.6852404",
"0.6848053",
"0.6828298",
"0.67738813",... | 0.0 | -1 |
Per period utility function | def utility(consumption_vector, gamma):
if gamma == 1:
U = np.log(consumption_vector)
else:
U = (consumption_vector ** (1 - gamma)) / (1 - gamma)
return U | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def period(self) -> int:",
"def periodCheck(data):",
"def period(self, value: int, /) -> None:",
"def define_period():\n\n def_period = {'lt': 5820, # 97 minutes\n 'lon': 6240, # 104 minutes\n 'angle': 5820}\n\n return def_period",
"def _calculate_period(vals):\n\t... | [
"0.79746",
"0.7556614",
"0.7253997",
"0.65491265",
"0.6545026",
"0.6387055",
"0.63736975",
"0.6269186",
"0.61849684",
"0.6146609",
"0.6124873",
"0.6111358",
"0.61068165",
"0.6098242",
"0.6062583",
"0.59767157",
"0.5947993",
"0.59476095",
"0.5931257",
"0.59171796",
"0.5906297"... | 0.0 | -1 |
Return stats for all stored urls, including age and hit count | def stats():
return jsonify(shorten.get_stats(get_db(), app.config['MINI_URL_BASE'])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetStats(self):\r\n\t\tArg1 = self.href\r\n\t\treturn self._execute('GetStats', payload=locals(), response_object=None)",
"def get_statistics(self):\n statistics = {\n 'entry': 0,\n 'bandwidth': 0,\n 'exit': 0,\n 'pages': 0\n }\n downloads = st... | [
"0.6812998",
"0.678329",
"0.6618755",
"0.64406484",
"0.6318793",
"0.63116807",
"0.6304703",
"0.62987965",
"0.6284246",
"0.62530524",
"0.6160197",
"0.61364985",
"0.61012554",
"0.60908496",
"0.6088024",
"0.6030725",
"0.59980816",
"0.5970426",
"0.59362936",
"0.5923684",
"0.58960... | 0.60651094 | 15 |
Plot population size as a function of time for each deme in the graph. | def size_history(
graph: demes.Graph,
ax: matplotlib.axes.Axes = None,
inf_ratio: float = 0.1,
inf_label: bool = False,
invert_x: bool = False,
annotate_epochs: bool = False,
colours: utils.ColourOrColourMapping = None,
log_time: bool = False,
log_size: bool = False,
title: str =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GraphTimeVsSize(data, args, cmd):\n p = data[args][cmd]\n vers = sorted(p)\n sizes = sorted(p[vers[0]])\n for ver in vers:\n times = [p[ver][size][0] for size in sizes]\n plt.plot(sizes, times, label=ver)\n ax = plt.gca()\n if cmd == 'delta':\n ax.yaxis.set_major_locator(MultipleLocator(60))\n ... | [
"0.6297834",
"0.61414975",
"0.6136835",
"0.6074017",
"0.60201573",
"0.5937706",
"0.5821276",
"0.57505625",
"0.57206315",
"0.5704849",
"0.5693089",
"0.56632227",
"0.5652069",
"0.5646763",
"0.5641537",
"0.560283",
"0.5573585",
"0.5535666",
"0.55110645",
"0.54786867",
"0.5442298... | 0.0 | -1 |
Find by primary key. | def find(self, id):
return self._select_one('''
select
*
from
{table}
where
{primary_key} = %s
'''.format(table=self.__class__._table,
primary_key=self.__class__._primary_key), [id]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find(self, primary_key):\n sql = '{} WHERE {} = %s'.format(self._select(), self.PRIMARY_KEY)\n cursor = yield self._pool.execute(sql, [primary_key])\n result = cursor.fetchmany(1)\n return self.convert_result_to_object(result)",
"async def find_by_id(self, _id: int) -> Record:\n ... | [
"0.8381468",
"0.76889473",
"0.76515317",
"0.7415496",
"0.7158401",
"0.7099071",
"0.7044322",
"0.7039672",
"0.6811109",
"0.6696825",
"0.66701585",
"0.6627701",
"0.6615898",
"0.65716875",
"0.65695727",
"0.6552014",
"0.6518707",
"0.64597976",
"0.64076394",
"0.64000124",
"0.63941... | 0.7143446 | 5 |
Initialization of the attributes. | def __init__(self, address_name, logger):
# keep a reference to the common logger
self.logger = logger
# attributes
self.address_name = address_name
self._state = AddressStates.UNKNOWN
self.remote_time = 0
self.local_time = 0
self.processes = {} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_attrs(self):\n raise NotImplementedError",
"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 'bannerAbbreviat... | [
"0.85431945",
"0.82513285",
"0.7581295",
"0.7557976",
"0.75490177",
"0.7533591",
"0.7438523",
"0.73479736",
"0.733841",
"0.7301527",
"0.72799546",
"0.7268253",
"0.7224906",
"0.7224906",
"0.7192972",
"0.71733683",
"0.71668434",
"0.7158894",
"0.70884913",
"0.7027825",
"0.702172... | 0.0 | -1 |
Property for the 'state' attribute. | def state(self):
return self._state | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def state(self) -> \"StateEnum\":\n return StateEnum.from_value(self._attrs.get(\"state\"))",
"def state(self) -> \"StatusState\":\n return StatusState.from_value(self._attrs.get(\"state\"))",
"def state(self, state: \"str\"):\n if isinstance(state, Enum):\n self._attrs[\"state\... | [
"0.78809613",
"0.7727035",
"0.77251655",
"0.77194494",
"0.77194494",
"0.75788736",
"0.75365645",
"0.7527081",
"0.7366093",
"0.7366093",
"0.7334735",
"0.73292303",
"0.73292303",
"0.73172617",
"0.72892934",
"0.7278215",
"0.7278215",
"0.7278215",
"0.7274344",
"0.7274344",
"0.727... | 0.0 | -1 |
Return a serializable form of the AddressStatus. | def serial(self):
return {'address_name': self.address_name,
'statecode': self.state,
'statename': self.state_string(),
'remote_time': capped_int(self.remote_time),
'local_time': capped_int(self.local_time),
'loading': self.loading(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def state_string(self):\n return AddressStates._to_string(self.state)",
"def get_receipt_address_status(self):\n return self.get_document_status_choice(self.receipt_address_status)",
"def status(self):\n return status_dict[self._get_property_(self.STATUS).upper()]",
"def summary(self):\n... | [
"0.65376735",
"0.6407179",
"0.6125908",
"0.61190885",
"0.6088738",
"0.5990919",
"0.5974651",
"0.59298563",
"0.590801",
"0.590526",
"0.58993244",
"0.5894258",
"0.58879745",
"0.5871039",
"0.5828656",
"0.5824285",
"0.5814415",
"0.5784133",
"0.5779725",
"0.5777793",
"0.57745993",... | 0.5553306 | 48 |
Return the application state as a string. | def state_string(self):
return AddressStates._to_string(self.state) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stateString(self):\n return self._mdp.stateString(self._cur_state);",
"def state(self):\n\n\t\treturn str(self)",
"def state(self):\n return str(self)",
"def state(self):\r\n return str(self)",
"def state(self) -> str:",
"def application_state(self) -> Optional[str]:\n ret... | [
"0.78867906",
"0.7547796",
"0.7517714",
"0.74153733",
"0.7372526",
"0.7339068",
"0.73365414",
"0.73365414",
"0.73365414",
"0.73365414",
"0.73365414",
"0.73365414",
"0.73365414",
"0.73365414",
"0.73365414",
"0.73365414",
"0.73365414",
"0.73365414",
"0.7271128",
"0.7271128",
"0... | 0.7158514 | 44 |
Return True if the Supvisors instance is in isolation. | def in_isolation(self):
return self.state in [AddressStates.ISOLATING, AddressStates.ISOLATED] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def singularity_exists(self):\n instances = Client.instances(quiet=self.quiet)\n for instance in instances:\n if self.pid in instance.name:\n return True\n return False",
"def isup(self):\n if self.cloudserver:\n # print self.cloudserver.status\n ... | [
"0.6635373",
"0.6507393",
"0.64624596",
"0.64520085",
"0.6421391",
"0.64169216",
"0.64154315",
"0.64154315",
"0.64154315",
"0.64154315",
"0.64154315",
"0.64154315",
"0.64154315",
"0.64154315",
"0.64154315",
"0.64154315",
"0.64154315",
"0.64154315",
"0.64154315",
"0.64154315",
... | 0.0 | -1 |
Update the last times attributes of the AddressStatus and of all the processes running on it. | def update_times(self, remote_time, local_time):
self.remote_time = remote_time
self.local_time = local_time
for process in self.processes.values():
process.update_times(self.address_name, remote_time) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _UpdateProcessingStatus(self, pid, process_status, used_memory):",
"def update_status(self):\n\n # Memory information can be found in status and statm /proc/PID files\n # status file VmRSS equivalent to top's RES column\n # statm disagrees with status VmRSS, I think it may not include\n ... | [
"0.63074714",
"0.61598605",
"0.5967854",
"0.587815",
"0.5851434",
"0.5803371",
"0.57687116",
"0.5440648",
"0.5423083",
"0.5397243",
"0.5386455",
"0.5369842",
"0.5331419",
"0.5302193",
"0.52979624",
"0.5289811",
"0.52506447",
"0.5244542",
"0.52427137",
"0.5232442",
"0.5212697"... | 0.6196417 | 1 |
Check that the state transition is valid. | def check_transition(self, new_state):
return new_state in self._Transitions[self.state] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_transition_sanity(self):\n for trans in crest.get_all_transitions(self.model):\n assert trans._name is not None, f\"There is a transition in {trans._parent._name} ({trans._parent.__class__.__name__}) whose name is 'None'\"\n assert trans._name != \"\", f\"There is a transitio... | [
"0.7781572",
"0.76222646",
"0.7428737",
"0.7234154",
"0.71804106",
"0.71731484",
"0.71228576",
"0.70903534",
"0.6999822",
"0.685391",
"0.6806832",
"0.6755866",
"0.67439497",
"0.674357",
"0.6709216",
"0.67011845",
"0.666854",
"0.6649904",
"0.66231894",
"0.6604144",
"0.6574667"... | 0.74631035 | 2 |
Add a new process to the process list. | def add_process(self, process):
self.processes[process.namespec()] = process | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_process(self):\n process_id = str(self.processBox.currentText())\n\n arguments = {}\n\n for row in range(0, self.processTableWidget.rowCount()):\n p_id = \"\"\n val = None\n\n if self.processTableWidget.item(row, 0):\n p_id = self.process... | [
"0.76126385",
"0.7507758",
"0.7315577",
"0.72722274",
"0.72574365",
"0.71727246",
"0.68514043",
"0.6843939",
"0.6840627",
"0.6770633",
"0.6737064",
"0.67065763",
"0.6432417",
"0.6367946",
"0.63575804",
"0.6237238",
"0.61873573",
"0.61138415",
"0.61019224",
"0.6021345",
"0.601... | 0.83901864 | 0 |
Return the process running on the address. Here, 'running' means that the process state is in Supervisor RUNNING_STATES. | def running_processes(self):
return [process for process in self.processes.values()
if process.running_on(self.address_name)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def running(self):\n info = self.info()\n return info['running']",
"def is_process_running(name):\n if not hasattr(is_process_running, \"proc\"):\n is_process_running.proc = None # it doesn't exist yet, so init it\n\n if is_process_running.proc:\n if is_process_running.proc.i... | [
"0.61827284",
"0.605477",
"0.5984106",
"0.59605074",
"0.5830705",
"0.5814387",
"0.57667416",
"0.57487637",
"0.57090694",
"0.5694411",
"0.5676516",
"0.5661446",
"0.5649374",
"0.5617451",
"0.56060237",
"0.55911523",
"0.55796784",
"0.5576243",
"0.55739254",
"0.55647177",
"0.5558... | 0.6297126 | 0 |
Return the process running on the address and having a pid. Different from running_processes_on because it excludes the states STARTING and BACKOFF | def pid_processes(self):
return [(process.namespec(), process.infos[self.address_name]['pid'])
for process in self.processes.values()
if process.pid_running_on(self.address_name)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_process(self, pid):\n return self.processes.get(pid, None)",
"def running_processes(self):\n return [process for process in self.processes.values()\n if process.running_on(self.address_name)]",
"def get_process_pid(robot_name):\n\n try:\n result = check_output(['p... | [
"0.7015587",
"0.670613",
"0.6585871",
"0.6583493",
"0.64844155",
"0.64499414",
"0.6438885",
"0.64362067",
"0.6434716",
"0.63813657",
"0.63745505",
"0.63590276",
"0.63359684",
"0.6330875",
"0.63202155",
"0.62983465",
"0.62884915",
"0.62884915",
"0.6279087",
"0.62753826",
"0.62... | 0.70801574 | 0 |
Return the loading of the address, by summing the declared loading of the processes running on that address | def loading(self):
loading = sum(process.rules.expected_loading
for process in self.running_processes())
self.logger.debug('address={} loading={}'.
format(self.address_name, loading))
return loading | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def current_load(self):\n nn = [p.n for p in self._procs]\n return sum(nn), min(nn)",
"def get_load_data():\n proc_stat = open(\"/proc/stat\", \"r\")\n ret = []\n #times_since_startup = proc_stat.readline().strip().split()[1:]\n for line in proc_stat:\n line_split = line.strip().... | [
"0.62994903",
"0.5876818",
"0.577103",
"0.5671219",
"0.56705534",
"0.56662524",
"0.55867136",
"0.55307513",
"0.54727614",
"0.5392582",
"0.5365475",
"0.533915",
"0.5335333",
"0.5271789",
"0.52094007",
"0.5200593",
"0.519389",
"0.5176355",
"0.51122624",
"0.51087445",
"0.5093616... | 0.7182065 | 0 |
Log that an object has been successfully changed. The default implementation creates an admin LogEntry object. | def history_log(self, user, action=CHANGE, message=''):
LogEntry.objects.log_action(
user_id=user.pk,
content_type_id=ContentType.objects.get_for_model(self).pk,
object_id=self.pk,
object_repr=force_text(self),
action_flag=action,
change_me... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_change(request, object, message):\n from django.contrib.admin.models import LogEntry, CHANGE\n from django.contrib.contenttypes.models import ContentType\n from django.utils.encoding import force_unicode\n\n LogEntry.objects.log_action(\n user_id=request.user.pk,\n content_type_id... | [
"0.70133215",
"0.69674075",
"0.6594732",
"0.6459646",
"0.62252766",
"0.61523455",
"0.5846429",
"0.58451456",
"0.57111967",
"0.5708252",
"0.568097",
"0.56665975",
"0.5649899",
"0.56148577",
"0.55948657",
"0.5571661",
"0.5556302",
"0.5527434",
"0.5515551",
"0.5488312",
"0.54780... | 0.5314031 | 33 |
Returns two lists with the ids of grec_seq_rec and seq_reserva | def get_seq_lists(dataframe_bookings):
seq_rec = dataframe_bookings.select('operative_incoming').collect()
seq_reserva = dataframe_bookings.select('booking_id').collect()
seq_rec = [val[0] for val in list(seq_rec)]
seq_reserva = [val[0] for val in list(seq_reserva)]
return seq_rec, seq_reserva | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def seq_xref_ids(entry):\n\n xref_ids = []\n exon_data = exons(entry)\n for ids in xref_data(entry).values():\n for exon in exon_data:\n for xref_id in ids:\n key = \"{xref_id}-{gene_id}-{chr}:{start}..{stop}\".format(\n xref_id=xref_id,\n ... | [
"0.6269399",
"0.61774325",
"0.60897326",
"0.5778329",
"0.5776383",
"0.5763285",
"0.5730644",
"0.5721721",
"0.57183284",
"0.568632",
"0.5685907",
"0.56623137",
"0.55932146",
"0.5542651",
"0.5516142",
"0.5515765",
"0.5473292",
"0.5469163",
"0.54488885",
"0.5432289",
"0.5427406"... | 0.6646673 | 0 |
It calculates the subquery for the field Tax_Sales_Transfer_pricing | def sub_tax_sales_transfer_pricing(manager, df_fields, seq_recs, seq_reservas):
# df_hotel = manager.get_dataframe(tables['dwc_bok_t_canco_hotel'])
# df_circuit = manager.get_dataframe(tables['dwc_bok_t_canco_hotel_circuit'])
# df_other = manager.get_dataframe(tables['dwc_bok_t_canco_other'])
# df_trans... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sub_tax_cost_transfer_pricing(manager, df_fields, seq_recs, seq_reservas):\n # df_hotel = manager.get_dataframe(tables[\"dwc_bok_t_canco_hotel\"])\n # df_circuit = manager.get_dataframe(tables[\"dwc_bok_t_canco_hotel_circuit\"])\n # df_other = manager.get_dataframe(tables[\"dwc_bok_t_canco_other\"])\n... | [
"0.6498725",
"0.637397",
"0.63043004",
"0.62905616",
"0.6242464",
"0.59541345",
"0.5881588",
"0.5839122",
"0.5801799",
"0.57798594",
"0.5711908",
"0.5685891",
"0.5622643",
"0.55404156",
"0.5537151",
"0.5537049",
"0.5476859",
"0.5469033",
"0.5468134",
"0.5453045",
"0.54431385"... | 0.66625917 | 0 |
It calculates the subquery for the field Transfer_pricing | def sub_transfer_pricing(manager, df_fields, seq_recs, seq_reservas):
# df_hotel = manager.get_dataframe(tables["dwc_bok_t_canco_hotel"])
# df_circuit = manager.get_dataframe(tables["dwc_bok_t_canco_hotel_circuit"])
# df_other = manager.get_dataframe(tables["dwc_bok_t_canco_other"])
# df_transfer = mana... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sub_tax_cost_transfer_pricing(manager, df_fields, seq_recs, seq_reservas):\n # df_hotel = manager.get_dataframe(tables[\"dwc_bok_t_canco_hotel\"])\n # df_circuit = manager.get_dataframe(tables[\"dwc_bok_t_canco_hotel_circuit\"])\n # df_other = manager.get_dataframe(tables[\"dwc_bok_t_canco_other\"])\n... | [
"0.66143847",
"0.65671605",
"0.6538647",
"0.64082414",
"0.58227384",
"0.57171154",
"0.5707997",
"0.57049704",
"0.56700575",
"0.56570375",
"0.5582287",
"0.55250686",
"0.5522433",
"0.55135524",
"0.5483422",
"0.5448324",
"0.5421551",
"0.5415142",
"0.5378908",
"0.5364118",
"0.533... | 0.65184456 | 3 |
It calculates the subquery for the field Tax_Cost_Transfer_pricing | def sub_tax_cost_transfer_pricing(manager, df_fields, seq_recs, seq_reservas):
# df_hotel = manager.get_dataframe(tables["dwc_bok_t_canco_hotel"])
# df_circuit = manager.get_dataframe(tables["dwc_bok_t_canco_hotel_circuit"])
# df_other = manager.get_dataframe(tables["dwc_bok_t_canco_other"])
# df_transf... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sub_tax_cost_transfer_pricing_eur(manager, df_fields, seq_recs, seq_reservas):\n # df_hotel = manager.get_dataframe(tables[\"dwc_bok_t_canco_hotel\"])\n # df_circuit = manager.get_dataframe(tables[\"dwc_bok_t_canco_hotel_circuit\"])\n # df_other = manager.get_dataframe(tables[\"dwc_bok_t_canco_other\"... | [
"0.65499413",
"0.6401581",
"0.62985355",
"0.6264737",
"0.6263573",
"0.6209262",
"0.5951682",
"0.59322137",
"0.5912796",
"0.58500355",
"0.5839168",
"0.5828151",
"0.57621986",
"0.56807303",
"0.5652692",
"0.5645219",
"0.5632515",
"0.5612633",
"0.55991054",
"0.5577054",
"0.556269... | 0.6695558 | 0 |
It calculates the subquery for the field Tax_Transfer_pricing_EUR | def sub_tax_transfer_pricing_eur(manager, df_fields, seq_recs, seq_reservas):
# df_hotel = manager.get_dataframe(tables["dwc_bok_t_canco_hotel"])
# df_circuit = manager.get_dataframe(tables["dwc_bok_t_canco_hotel_circuit"])
# df_other = manager.get_dataframe(tables["dwc_bok_t_canco_other"])
# df_transfe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sub_tax_cost_transfer_pricing_eur(manager, df_fields, seq_recs, seq_reservas):\n # df_hotel = manager.get_dataframe(tables[\"dwc_bok_t_canco_hotel\"])\n # df_circuit = manager.get_dataframe(tables[\"dwc_bok_t_canco_hotel_circuit\"])\n # df_other = manager.get_dataframe(tables[\"dwc_bok_t_canco_other\"... | [
"0.65058285",
"0.6245366",
"0.62209433",
"0.60142535",
"0.601361",
"0.588141",
"0.5866098",
"0.5865709",
"0.5844462",
"0.5841258",
"0.5803155",
"0.5662047",
"0.56258506",
"0.5612775",
"0.5599036",
"0.55835426",
"0.556036",
"0.5547852",
"0.5484853",
"0.5466989",
"0.545998",
... | 0.6462657 | 1 |
It calculates the subquery for the field Tax_Cost_Transfer_pricing_EUR | def sub_tax_cost_transfer_pricing_eur(manager, df_fields, seq_recs, seq_reservas):
# df_hotel = manager.get_dataframe(tables["dwc_bok_t_canco_hotel"])
# df_circuit = manager.get_dataframe(tables["dwc_bok_t_canco_hotel_circuit"])
# df_other = manager.get_dataframe(tables["dwc_bok_t_canco_other"])
# df_tr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sub_tax_cost_transfer_pricing(manager, df_fields, seq_recs, seq_reservas):\n # df_hotel = manager.get_dataframe(tables[\"dwc_bok_t_canco_hotel\"])\n # df_circuit = manager.get_dataframe(tables[\"dwc_bok_t_canco_hotel_circuit\"])\n # df_other = manager.get_dataframe(tables[\"dwc_bok_t_canco_other\"])\n... | [
"0.64423364",
"0.6376252",
"0.6182043",
"0.61586916",
"0.6076942",
"0.6071446",
"0.59395057",
"0.5931084",
"0.586201",
"0.5850323",
"0.5799269",
"0.57859534",
"0.5713411",
"0.5647553",
"0.5607687",
"0.5596589",
"0.5572917",
"0.5561368",
"0.5530456",
"0.5508553",
"0.5498966",
... | 0.66247785 | 0 |
Run a single epoch of training | def train(model, optimizer, loss_function, loader, device, log_every_n=10):
model.train() # Run model in training mode
loss_history = []
running_loss = 0.
running_loss_history = []
for i, batch in tqdm(enumerate(loader)):
optimizer.zero_grad() # Always set gradient to 0 before computin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_one_epoch(self):\n raise NotImplementedError",
"def train_one_epoch(self):\n\t\tself.model.train()\n\t\ttrain_loss = 0\n\n\t\tfor batch_idx, data in enumerate(self.data_loader.train_loader):\n\t\t\tInput = data[0].float().to(self.device)\n\t\t\tOutput = data[1].float().to(self.device)\n\n\t\t\ts... | [
"0.82089",
"0.7736836",
"0.77296716",
"0.7690409",
"0.7672777",
"0.7601996",
"0.76006347",
"0.75574315",
"0.75574315",
"0.75574315",
"0.75574315",
"0.7480733",
"0.7478019",
"0.74223953",
"0.74209774",
"0.7369879",
"0.73666525",
"0.73666525",
"0.73537654",
"0.72843677",
"0.726... | 0.0 | -1 |
Evaluate the model on a validation set | def evaluate(model, optimizer, loss_function, loader, device, labels, log_every_n=10):
model.eval()
batch_wise_true_labels = []
batch_wise_predictions = []
loss_history = []
running_loss = 0.
running_loss_history = []
with torch.no_grad(): # Disable gradient computation - required only ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate(self):\n self.set_model_mode('eval')\n self.evaluator.reset()\n losses = MetricMeter()\n\n print('Do evaluation on {} set'.format('valid set'))\n data_loader = self.val_loader\n assert data_loader is not None\n for batch_idx, batch in enumerate(data_loa... | [
"0.7376902",
"0.68664986",
"0.6861883",
"0.6753435",
"0.66626984",
"0.6649241",
"0.6634646",
"0.6592691",
"0.65147567",
"0.6488397",
"0.642826",
"0.63554084",
"0.63379616",
"0.6291245",
"0.62727004",
"0.62590766",
"0.6258152",
"0.62362754",
"0.6216052",
"0.61982185",
"0.61916... | 0.0 | -1 |
This function constructs the integrator to be suitable with casadi environment, for the equations of the model and the objective function with variable time step. | def integrator_system(self):
xd, xa, u, ODEeq, Aeq, states, algebraics, inputs = self.DAE_system()
VV = Function('vfcn', [xa, u], [vertcat(*Aeq)], ['w0', 'u'], ['w'])
solver = rootfinder('solver', 'newton', VV)
return solver | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def integrator_model(self):\n\n xd, xa, u, uncertainty, ODEeq, Aeq, u_min, u_max, states, algebraics, inputs, nd, na, nu, nmp, modparval \\\n = self.DAE_system()\n ODEeq_ = vertcat(*ODEeq)\n\n self.ODEeq = Function('f', [xd, u], [vertcat(*ODEeq)], ['x0', 'p'], ['xdot'])\n\n d... | [
"0.69306874",
"0.6824473",
"0.6824473",
"0.5993993",
"0.5799238",
"0.5743481",
"0.5707509",
"0.56789947",
"0.56719893",
"0.5662057",
"0.56536293",
"0.5639711",
"0.55976707",
"0.55896133",
"0.5583953",
"0.5581527",
"0.5541686",
"0.5530698",
"0.55166656",
"0.5509524",
"0.550152... | 0.55018413 | 20 |
This function constructs the integrator to be suitable with casadi environment, for the equations of the model and the objective function with variable time step. | def integrator_model(self):
xd, xa, u, ODEeq, Aeq, states, algebraics, inputs = self.DAE_model()
VV = Function('vfcn', [xa, u], [vertcat(*Aeq)], ['w0', 'u'], ['w'])
solver = rootfinder('solver', 'newton', VV)
# model = functools.partial(solver, np.zeros(np.shape(xa)))
return so... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def integrator_model(self):\n\n xd, xa, u, uncertainty, ODEeq, Aeq, u_min, u_max, states, algebraics, inputs, nd, na, nu, nmp, modparval \\\n = self.DAE_system()\n ODEeq_ = vertcat(*ODEeq)\n\n self.ODEeq = Function('f', [xd, u], [vertcat(*ODEeq)], ['x0', 'p'], ['xdot'])\n\n d... | [
"0.69307363",
"0.68243206",
"0.68243206",
"0.59948397",
"0.57976073",
"0.5744459",
"0.57058465",
"0.56784093",
"0.56733394",
"0.5661514",
"0.5653307",
"0.5638662",
"0.5595214",
"0.5589865",
"0.55837965",
"0.5579946",
"0.5539479",
"0.5530106",
"0.55158114",
"0.5508561",
"0.550... | 0.5479345 | 26 |
This function constructs the integrator to be suitable with casadi environment, for the equations of the model and the objective function with variable time step. | def integrator_model(self):
xd, xa, u, uncertainty, ODEeq, Aeq, u_min, u_max, states, algebraics, inputs, nd, na, nu, nmp, modparval \
= self.DAE_system()
dae = {'x': vertcat(xd), 'z': vertcat(xa), 'p': vertcat(u),
'ode': vertcat(*ODEeq), 'alg': vertcat(*Aeq)}
opts =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def integrator_model(self):\n\n xd, xa, u, uncertainty, ODEeq, Aeq, u_min, u_max, states, algebraics, inputs, nd, na, nu, nmp, modparval \\\n = self.DAE_system()\n ODEeq_ = vertcat(*ODEeq)\n\n self.ODEeq = Function('f', [xd, u], [vertcat(*ODEeq)], ['x0', 'p'], ['xdot'])\n\n d... | [
"0.69303405",
"0.59939796",
"0.57994497",
"0.57433486",
"0.57079077",
"0.5678165",
"0.56725657",
"0.5661507",
"0.56537825",
"0.56398034",
"0.5597277",
"0.55902517",
"0.55843586",
"0.55814993",
"0.55416745",
"0.5530678",
"0.5516298",
"0.5508994",
"0.55017346",
"0.55017346",
"0... | 0.68241906 | 1 |
This function constructs the integrator to be suitable with casadi environment, for the equations of the model and the objective function with variable time step. | def integrator_model(self):
xd, xa, u, uncertainty, ODEeq, Aeq, u_min, u_max, states, algebraics, inputs, nd, na, nu, nmp, modparval \
= self.DAE_system()
dae = {'x': vertcat(xd), 'z': vertcat(xa), 'p': vertcat(u),
'ode': vertcat(*ODEeq), 'alg': vertcat(*Aeq)}
opts =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def integrator_model(self):\n\n xd, xa, u, uncertainty, ODEeq, Aeq, u_min, u_max, states, algebraics, inputs, nd, na, nu, nmp, modparval \\\n = self.DAE_system()\n ODEeq_ = vertcat(*ODEeq)\n\n self.ODEeq = Function('f', [xd, u], [vertcat(*ODEeq)], ['x0', 'p'], ['xdot'])\n\n d... | [
"0.69318324",
"0.59953165",
"0.57986635",
"0.5745706",
"0.57091874",
"0.56788397",
"0.5672505",
"0.566161",
"0.5654902",
"0.563956",
"0.55981153",
"0.55905986",
"0.55837876",
"0.55810785",
"0.5542895",
"0.5530973",
"0.5517672",
"0.5509622",
"0.5504029",
"0.5504029",
"0.550402... | 0.682522 | 2 |
This function constructs the integrator to be suitable with casadi environment, for the equations of the model and the objective function with variable time step. | def integrator_model(self):
xd, xa, u, uncertainty, ODEeq, Aeq, u_min, u_max, states, algebraics, inputs, nd, na, nu, nmp, modparval \
= self.DAE_system()
ODEeq_ = vertcat(*ODEeq)
self.ODEeq = Function('f', [xd, u], [vertcat(*ODEeq)], ['x0', 'p'], ['xdot'])
dae = {'x': ver... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def integrator_model(self):\n\n xd, xa, u, uncertainty, ODEeq, Aeq, u_min, u_max, states, algebraics, inputs, nd, na, nu, nmp, modparval \\\n = self.DAE_system()\n\n dae = {'x': vertcat(xd), 'z': vertcat(xa), 'p': vertcat(u),\n 'ode': vertcat(*ODEeq), 'alg': vertcat(*Aeq)}\n ... | [
"0.6824473",
"0.6824473",
"0.5993993",
"0.5799238",
"0.5743481",
"0.5707509",
"0.56789947",
"0.56719893",
"0.5662057",
"0.56536293",
"0.5639711",
"0.55976707",
"0.55896133",
"0.5583953",
"0.5581527",
"0.5541686",
"0.5530698",
"0.55166656",
"0.5509524",
"0.55018413",
"0.550184... | 0.69306874 | 0 |
This function constructs the integrator to be suitable with casadi environment, for the equations of the model and the objective function with variable time step. | def integrator_system(self):
xd, xa, u, ODEeq, Aeq, states, algebraics, inputs = self.DAE_system()
VV = Function('vfcn', [xa, u], [vertcat(*Aeq)], ['w0', 'u'], ['w'])
solver = rootfinder('solver', 'newton', VV)
return solver | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def integrator_model(self):\n\n xd, xa, u, uncertainty, ODEeq, Aeq, u_min, u_max, states, algebraics, inputs, nd, na, nu, nmp, modparval \\\n = self.DAE_system()\n ODEeq_ = vertcat(*ODEeq)\n\n self.ODEeq = Function('f', [xd, u], [vertcat(*ODEeq)], ['x0', 'p'], ['xdot'])\n\n d... | [
"0.69307363",
"0.68243206",
"0.68243206",
"0.59948397",
"0.57976073",
"0.5744459",
"0.57058465",
"0.56784093",
"0.56733394",
"0.5661514",
"0.5653307",
"0.5638662",
"0.5595214",
"0.5589865",
"0.55837965",
"0.5579946",
"0.5539479",
"0.5530106",
"0.55158114",
"0.5508561",
"0.549... | 0.550293 | 23 |
This function constructs the integrator to be suitable with casadi environment, for the equations of the model and the objective function with variable time step. | def integrator_system(self):
xd, xa, u, ODEeq, Aeq, states, algebraics, inputs = self.DAE_system()
VV = Function('vfcn', [xa, u], [vertcat(*Aeq)], ['w0', 'u'], ['w'])
solver = rootfinder('solver', 'newton', VV)
return solver | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def integrator_model(self):\n\n xd, xa, u, uncertainty, ODEeq, Aeq, u_min, u_max, states, algebraics, inputs, nd, na, nu, nmp, modparval \\\n = self.DAE_system()\n ODEeq_ = vertcat(*ODEeq)\n\n self.ODEeq = Function('f', [xd, u], [vertcat(*ODEeq)], ['x0', 'p'], ['xdot'])\n\n d... | [
"0.69303405",
"0.68241906",
"0.68241906",
"0.59939796",
"0.57994497",
"0.57433486",
"0.57079077",
"0.5678165",
"0.56725657",
"0.5661507",
"0.56537825",
"0.56398034",
"0.5597277",
"0.55902517",
"0.55843586",
"0.55814993",
"0.55416745",
"0.5530678",
"0.5516298",
"0.5508994",
"0... | 0.55017346 | 21 |
This function constructs the integrator to be suitable with casadi environment, for the equations of the model and the objective function with variable time step. | def integrator_system(self):
xd, xa, u, ODEeq, Aeq, states, algebraics, inputs = self.DAE_system()
VV = Function('vfcn', [xa, u], [vertcat(*Aeq)], ['w0', 'u'], ['w'])
solver = rootfinder('solver', 'newton', VV)#, {'error_on_fail':False})
return solver | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def integrator_model(self):\n\n xd, xa, u, uncertainty, ODEeq, Aeq, u_min, u_max, states, algebraics, inputs, nd, na, nu, nmp, modparval \\\n = self.DAE_system()\n ODEeq_ = vertcat(*ODEeq)\n\n self.ODEeq = Function('f', [xd, u], [vertcat(*ODEeq)], ['x0', 'p'], ['xdot'])\n\n d... | [
"0.69318324",
"0.682522",
"0.682522",
"0.59953165",
"0.57986635",
"0.57091874",
"0.56788397",
"0.5672505",
"0.566161",
"0.5654902",
"0.563956",
"0.55981153",
"0.55905986",
"0.55837876",
"0.55810785",
"0.5542895",
"0.5530973",
"0.5517672",
"0.5509622",
"0.5504029",
"0.5504029"... | 0.5745706 | 5 |
This function constructs the integrator to be suitable with casadi environment, for the equations of the model and the objective function with variable time step. | def integrator_system(self):
xd, xa, u, ODEeq, Aeq, states, algebraics, inputs = self.DAE_system()
VV = Function('vfcn', [xa, u], [vertcat(*Aeq)], ['w0', 'u'], ['w'])
solver = rootfinder('solver', 'newton', VV)
return solver | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def integrator_model(self):\n\n xd, xa, u, uncertainty, ODEeq, Aeq, u_min, u_max, states, algebraics, inputs, nd, na, nu, nmp, modparval \\\n = self.DAE_system()\n ODEeq_ = vertcat(*ODEeq)\n\n self.ODEeq = Function('f', [xd, u], [vertcat(*ODEeq)], ['x0', 'p'], ['xdot'])\n\n d... | [
"0.69306874",
"0.6824473",
"0.6824473",
"0.5993993",
"0.5799238",
"0.5743481",
"0.5707509",
"0.56789947",
"0.56719893",
"0.5662057",
"0.56536293",
"0.5639711",
"0.55976707",
"0.55896133",
"0.5583953",
"0.5581527",
"0.5541686",
"0.5530698",
"0.55166656",
"0.5509524",
"0.550152... | 0.55018413 | 22 |
Assert that inference works without warnings or errors. | def assert_ok(model, *args, **kwargs):
pyro.get_param_store().clear()
kernel = infer.NUTS(model)
mcmc = infer.MCMC(kernel, num_samples=2, warmup_steps=2)
mcmc.run(*args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_advance_ast_avaliable():\n assert _test_advanced_ast_presence()",
"def test_active_inference_SPM_1b(self):",
"def inference(model, data, diagnostics, seed, extra_fitting_args):\n pass",
"def test_no_coercion():\n\n @type_checked(coerce=False)\n def _run_test(something:str): pass\n\n w... | [
"0.6586008",
"0.6114658",
"0.6114165",
"0.60875183",
"0.6073362",
"0.60102546",
"0.5987372",
"0.5982912",
"0.58770275",
"0.5850032",
"0.5844257",
"0.58348143",
"0.5827149",
"0.58189166",
"0.5785292",
"0.5770235",
"0.57519215",
"0.57359266",
"0.5735409",
"0.57095784",
"0.56565... | 0.5215149 | 71 |
Given a thresholded image of the scene (ideally, the first frame), | def get_rectangles_mask(self, thresh: np.ndarray) -> np.ndarray:
contours = cv.findContours(thresh, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)[0]
mask = np.zeros(thresh.shape, np.uint8)
good_contours = sorted(
[cnt for cnt in contours if 100000 < cv.contourArea(cnt) < 200000],
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def threshold(self):\n self.frame = cv.adaptiveThreshold(self.frame, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY_INV, self.thresh, 2)",
"def thresholdImage(frame, binarizationThreshold=30):\n return cv2.threshold(frame, binarizationThreshold, 255, cv2.THRESH_BINARY)[1]",
"def threshold(img, ... | [
"0.6743112",
"0.65433484",
"0.6437061",
"0.63945776",
"0.6316842",
"0.628868",
"0.62694985",
"0.62595356",
"0.6242952",
"0.62253326",
"0.6183402",
"0.61699784",
"0.61520195",
"0.61465746",
"0.61196035",
"0.60966796",
"0.60767764",
"0.606645",
"0.6040267",
"0.6039766",
"0.6038... | 0.0 | -1 |
Sort the 4 corners clockwise of a rectangle so that the topleft corner is the first one. | def sort_corners(self, corners: np.ndarray):
center = np.sum(corners, axis=0) / 4
sorted_corners = sorted(
corners,
key=lambda p: math.atan2(p[0][0] - center[0][0], p[0][1] - center[0][1]),
reverse=True,
)
return np.roll(sorted_corners, 1, axis=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sort_corners(corners):\n col_sorted = corners[np.argsort(corners[:, 1])] # sort on the value in column\n\n # sort on the value in rows. a, b are the indexes\n a = np.argsort(col_sorted[:2, 0])\n b = np.argsort(col_sorted[2:, 0]) + 2\n\n return col_sorted[np.hstack((a, b))]",
"def order_rect(pt... | [
"0.6854596",
"0.66109776",
"0.6415772",
"0.63892233",
"0.62674105",
"0.62512946",
"0.6234069",
"0.6007216",
"0.6000448",
"0.59593153",
"0.5874499",
"0.58601785",
"0.58035123",
"0.57796407",
"0.5720378",
"0.5702618",
"0.5701921",
"0.5618068",
"0.56109095",
"0.5608352",
"0.5567... | 0.7108666 | 0 |
Given a thresholded image of the scene and a mask representing the two known rectangles, return the corners of those rectangles (8 in total) with subpixel accuracy. The corners returned are already sorted. | def get_desk_wall_corners(
self, thresh: np.ndarray
) -> Tuple[np.ndarray, np.ndarray]:
mask = self.get_rectangles_mask(thresh)
assert thresh.shape[:2] == mask.shape[:2]
corners = cv.goodFeaturesToTrack(
thresh,
maxCorners=8,
qualityLevel=0... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_corners(image):\n\n corners = []\n\n for side in range(4):\n corners.append(_find_corner(image, side))\n return corners",
"def get_rectangles_mask(self, thresh: np.ndarray) -> np.ndarray:\r\n contours = cv.findContours(thresh, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)[0]\r\n ma... | [
"0.6949092",
"0.69425696",
"0.68686926",
"0.67287797",
"0.64953494",
"0.6441506",
"0.6436643",
"0.6417351",
"0.64081156",
"0.64081156",
"0.6387981",
"0.6385469",
"0.6330147",
"0.63082325",
"0.6270925",
"0.62597865",
"0.62439096",
"0.62070817",
"0.618108",
"0.61800426",
"0.617... | 0.66609186 | 4 |
Given 4 sorted corners, compute the homography between the corners and the rectangle's ground truth and return the information on the mapped plane. In other words, this function returns information on a plane (in particular, the desk's or wall's). The plane's origin is in the topleft corner of the rectangle, and the no... | def get_H_R_t(self, corners: np.ndarray) -> Plane:
H = cv.findHomography(self.inner_rectangle, corners)[0]
result = self.K_inv @ H
result /= cv.norm(result[:, 1])
r0, r1, t = np.hsplit(result, 3)
r2 = np.cross(r0.T, r1.T).T
_, u, vt = cv.SVDecomp(np.hstack([r0, r1, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _prepare_plane(self):\n verticies = [\n # main plane - note that the mainplane is scaled so the mat_plane\n # matrix will it transform to the correct coordinates\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\n -self.i... | [
"0.58668405",
"0.58515084",
"0.5808322",
"0.5808322",
"0.5799701",
"0.5799701",
"0.5593243",
"0.55419457",
"0.5481281",
"0.5459112",
"0.54404145",
"0.5418466",
"0.541714",
"0.53940755",
"0.53733194",
"0.5373061",
"0.5357221",
"0.5352762",
"0.5341513",
"0.53396374",
"0.5331517... | 0.6981937 | 0 |
Given the corners of the rectangles on the wall and on the desk, return the coordinates for a tight bounding box of the area between the two rectangles. | def get_extreme_points(
self, wall_corners: np.ndarray, desk_corners: np.ndarray
) -> ExtremePoints:
ymin_wall = int(np.min(wall_corners[:, :, 1]))
ymax_wall = int(np.max(wall_corners[:, :, 1]))
ymin_desk = int(np.min(desk_corners[:, :, 1]))
ymax_desk = int(np.max(desk_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _find_bboxes_on_rect_edge(bboxes, left, bottom, right, top):\n bboxes_left = _find_bboxes_in_rect(bboxes, left, bottom, left, top)\n bboxes_right = _find_bboxes_in_rect(bboxes, right, bottom, right, top)\n bboxes_top = _find_bboxes_in_rect(bboxes, left, top, right, top)\n bboxes_bottom = _find_bbox... | [
"0.6642179",
"0.65772635",
"0.6567798",
"0.654517",
"0.6451509",
"0.64079404",
"0.638755",
"0.631571",
"0.63061756",
"0.62954104",
"0.627549",
"0.6271331",
"0.6248824",
"0.62457526",
"0.6232513",
"0.6218351",
"0.620274",
"0.62003404",
"0.61986816",
"0.6196619",
"0.6195557",
... | 0.0 | -1 |
Given an image and a rectangle defining a region, return the laser points in that region. In case we are considering the wall or the desk, require at least 30 points for better accuracy. | def get_laser_points_in_region(
self, image: np.ndarray, region: Rectangle, is_obj: bool = False,
) -> Optional[np.ndarray]:
top_left = region.top_left
bottom_right = region.bottom_right
region_image = image[top_left.y : bottom_right.y, top_left.x : bottom_right.x]
imag... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_laser_points(\r\n self,\r\n original_image: np.ndarray,\r\n image: np.ndarray,\r\n extreme_points: ExtremePoints,\r\n ) -> Tuple[\r\n Optional[np.ndarray],\r\n Optional[np.ndarray],\r\n Optional[np.ndarray],\r\n Optional[np.ndarray],\r\n ]:\r\n ... | [
"0.6679829",
"0.634663",
"0.62997025",
"0.6223093",
"0.621849",
"0.6095733",
"0.60441035",
"0.59959286",
"0.59956324",
"0.5957144",
"0.59263897",
"0.5916754",
"0.5900934",
"0.587384",
"0.58581173",
"0.5833918",
"0.5820731",
"0.58049595",
"0.5782126",
"0.5764281",
"0.575516",
... | 0.7383569 | 0 |
Given a region of an image and a point, offset the region by that point. | def offset_points(self, points: np.ndarray, offset: Point) -> np.ndarray:
points[:, :, 0] += offset.x
points[:, :, 1] += offset.y
return points | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def offset(img, y_s, y_e, x_s, x_e):\n if y_s < 0:\n y_s = 0\n if y_e > img.shape[0]:\n y_e = img.shape[0]\n if x_s < 0:\n x_s = 0\n if x_e > img.shape[1]:\n x_e = img.shape[1]\n new_img = img[y_s:y_e, x_s:x_e]\n return new_img",
"def translate_point(point, y_offset=... | [
"0.67617077",
"0.6400637",
"0.6341007",
"0.6277429",
"0.6178488",
"0.6159662",
"0.59187955",
"0.5902416",
"0.5882912",
"0.58361304",
"0.5823998",
"0.5792503",
"0.5726029",
"0.5705936",
"0.5686741",
"0.5674328",
"0.55382186",
"0.5523029",
"0.55119634",
"0.54766566",
"0.5442412... | 0.5824192 | 10 |
Given some points, convert them to homogeneous coordinates, i.e. add a trailing [1]. | def make_homogeneous(self, points: np.ndarray) -> np.ndarray:
return np.hstack((points[:, 0], np.ones(points.shape[0]).reshape(-1, 1),)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_homogeneous(points):\n return np.hstack((points, np.ones((points.shape[0], 1))))",
"def apply(self, points):\n pshape = numpy.shape(points)\n homogeneous = 1\n if len(pshape) == 1:\n if pshape[0] == 3:\n points = numpy.array(numpy.concatenate((points, nu... | [
"0.6712065",
"0.664639",
"0.625883",
"0.625883",
"0.6245449",
"0.6173878",
"0.6092858",
"0.6045913",
"0.5934989",
"0.59325945",
"0.59301716",
"0.5921763",
"0.5899959",
"0.5861943",
"0.5852588",
"0.581696",
"0.5782078",
"0.57674307",
"0.5756495",
"0.5741904",
"0.56922007",
"... | 0.6574593 | 2 |
Use the DBSCAN clustering algorithm in order to remove possible outliers from the points detected as laser in the object. We are basically enforcing continuity in the laser line on the object, i.e. looking for a dense cluster of pixels. Interesting points are the ones whose label is not 1, i.e. the ones belonging to a ... | def remove_obj_outliers(self, points: np.ndarray) -> Optional[np.ndarray]:
dbscan_result = self.dbscan.fit(points[:, 0])
mask = dbscan_result.labels_ != -1
return np.expand_dims(points[:, 0][mask], axis=1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def DBSCAN(M, eps, min_points):\n colors = ['r', 'g', 'b', 'y', 'c', 'm'] # tablica kolorow - inny kolor dla kazdego clustera\n checked = np.zeros(M.shape[\n 0]) # tablica sprawdzonych punktow wypelniona zerami jesli punkt zostal sprawdzony zmieniana jest wartosc na 1print(checked... | [
"0.6458574",
"0.62219197",
"0.6213678",
"0.61207443",
"0.6074292",
"0.6022414",
"0.5965475",
"0.5942092",
"0.5927346",
"0.5881949",
"0.57391447",
"0.5729232",
"0.56970525",
"0.5679967",
"0.5674256",
"0.5669259",
"0.5664249",
"0.5654197",
"0.56165564",
"0.5572699",
"0.555027",... | 0.6430791 | 1 |
Given an image and a list of coordinates of shape (n_points, 1, 2), return the RGB colors of those coordinates in the (0...1) range. Notice that OpenCV uses BGR instead of RGB by default, thus we need to flip the columns. | def get_colors(self, image: np.ndarray, coordinates: np.ndarray) -> np.ndarray:
x = coordinates.squeeze(1)
return np.flip(image[x[:, 1], x[:, 0]].astype(np.float64) / 255.0, axis=1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def split_image(img):\n xs = [] # positions\n ys = [] # colors\n for row_i in range(img.shape[0]):\n for col_i in range(img.shape[1]):\n xs.append([row_i, col_i])\n ys.append(img[row_i, col_i])\n \n xs = np.array(xs)\n ys = np.array(ys)\n return xs, ys",
... | [
"0.6468485",
"0.6468485",
"0.6345939",
"0.62494427",
"0.61467564",
"0.61461294",
"0.59144837",
"0.59094536",
"0.58901876",
"0.5879799",
"0.58757746",
"0.58628285",
"0.5841417",
"0.5825361",
"0.58153236",
"0.5774531",
"0.57576954",
"0.5743293",
"0.57418716",
"0.5741592",
"0.57... | 0.702163 | 0 |
Given the interesting region of an image, containing the wall and desk planes | def get_laser_points(
self,
original_image: np.ndarray,
image: np.ndarray,
extreme_points: ExtremePoints,
) -> Tuple[
Optional[np.ndarray],
Optional[np.ndarray],
Optional[np.ndarray],
Optional[np.ndarray],
]:
height, width = imag... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_plane(img_plane):\n img_plane = despeckle_by_opening(img_plane)\n img_plane = pseudo_flatfield(img_plane)\n return img_plane",
"def vision(image):\n vis_map = resize(image, alpha, beta)\n print(\"Resized map from the blue mask\")\n\n world = rotate(vis_map)\n\n plt.figure()\n p... | [
"0.65809894",
"0.6464048",
"0.6390743",
"0.63287824",
"0.62113917",
"0.62051076",
"0.617314",
"0.61421067",
"0.6071303",
"0.59273034",
"0.5899224",
"0.58911043",
"0.5882506",
"0.5850462",
"0.58404744",
"0.5821716",
"0.5817986",
"0.5805731",
"0.5789838",
"0.5780241",
"0.577984... | 0.0 | -1 |
Given points in the 3D world, save the PLY file representing the point cloud. This function saves both the original file and a version to which an outlier removal process has been applied. | def save_3d_render(
self, points: List[np.ndarray], colors: List[np.ndarray]
) -> None:
pcd = o3d.geometry.PointCloud()
pcd.points = o3d.utility.Vector3dVector(np.vstack(points).astype(np.float64))
pcd.colors = o3d.utility.Vector3dVector(np.vstack(colors))
if self.debug... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self, filename):\n if len(self.interpolated_points) > 0:\n red, green, blue = zip(*self.interpolated_points)\n red = [np.asscalar(x) for x in red]\n green = [np.asscalar(x) for x in green]\n blue = [np.asscalar(x) for x in blue]\n output_type =... | [
"0.6294344",
"0.62656236",
"0.60348487",
"0.5977392",
"0.5924391",
"0.58835065",
"0.58382964",
"0.5795747",
"0.5772745",
"0.5762645",
"0.5722541",
"0.5684895",
"0.56516",
"0.5644123",
"0.56439006",
"0.5636157",
"0.56341565",
"0.56338894",
"0.5624714",
"0.56098646",
"0.5586971... | 0.639831 | 0 |
Read a frame from the cap. Return None if there is no frame left. | def read_frame(self, cap) -> Optional[np.ndarray]:
frame_raw = cap.read()[1]
if frame_raw is None:
cv.destroyAllWindows()
return None
return cv.undistort(frame_raw, self.K, self.dist) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read(self):\n\n # if self.deque and self.online:\n if self.online:\n # Grab latest frame\n if self.enable_camera_reader_thread:\n frame = self.deque[-1]\n else:\n _, frame = self.cap.read()\n return frame\n else:\n ... | [
"0.7615841",
"0.7613714",
"0.7210717",
"0.7086903",
"0.7004125",
"0.69384205",
"0.68672734",
"0.68494064",
"0.6765152",
"0.6765152",
"0.67489",
"0.67320615",
"0.67314106",
"0.6676311",
"0.664866",
"0.6638468",
"0.661803",
"0.6612942",
"0.6570604",
"0.6548034",
"0.6513184",
... | 0.67918265 | 8 |
Given a plane represented by its origin and a normal and a list of rays, compute the intersections between the plane and the rays. | def compute_intersections(
self, plane: Plane, directions: List[np.ndarray]
) -> List[np.ndarray]:
return [
line_plane_intersection(
plane_origin=plane.origin,
plane_normal=plane.normal,
line_direction=direction,
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def intersects(self, ray):\n theta = 45\n H = 512\n W = 512\n A = self.origin\n B = Point(W, A.y, A.z)\n C = Point(B.x, (int)(H * math.sin(theta * math.pi / 180)), (int)(H * math.cos(math.pi * theta / 180)))\n D = Point(A.x, (int)(H * math.sin(theta * math.pi / 180)... | [
"0.7197938",
"0.6904024",
"0.6653329",
"0.6607719",
"0.65378755",
"0.6519269",
"0.6485377",
"0.6441739",
"0.6334094",
"0.6284775",
"0.6276811",
"0.6276351",
"0.6261968",
"0.62611717",
"0.62223566",
"0.6186185",
"0.61805207",
"0.6166154",
"0.60925084",
"0.60659647",
"0.6016266... | 0.7335776 | 0 |
Build command string from parameters passed to object. Usage of paramter h in options is going to be ignored. | def build_command_string(self):
if self._regex_helper.search_compiled(W._re_h, self.options):
if self._regex_helper.group("SOLO"):
self.options = self.options.replace('-h', '')
else:
self.options = self.options.replace('h', '')
cmd = "{} {}".f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gen_command(process):\n cmd = \"{} \".format(process.name)\n for o in process.options.opt_list:\n i = 0\n opt = \"\"\n for el in o: \n if el and el != \"input\" and el != \"output\" and i != 3:\n opt += str(el)\n if opt[-1] != \"=\" and opt[-1... | [
"0.6516497",
"0.64271504",
"0.6422479",
"0.63904124",
"0.6238994",
"0.6229805",
"0.62154454",
"0.6114734",
"0.6070556",
"0.5986263",
"0.59837586",
"0.5973345",
"0.59382427",
"0.5915507",
"0.5883363",
"0.5877054",
"0.58658147",
"0.58613133",
"0.58564746",
"0.585302",
"0.583697... | 0.7719122 | 0 |
Put your parsing code here. | def on_new_line(self, line, is_full_line):
try:
if is_full_line:
self._parse_v_option(line)
self._parse_general_info(line)
self._parse_header(line)
except ParsingDone:
pass # line has been fully parsed by one of above parse-methods... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse(self):\n pass",
"def parse(self):",
"def parse(self):\n pass",
"def parse(self):\n pass",
"def parse(self):\n pass",
"def parse(self):\n pass",
"def parse(self) -> None:\n pass",
"def run(self, parsed):",
"def parse(self, input):\n pass",
... | [
"0.7996566",
"0.7783249",
"0.76065314",
"0.76065314",
"0.76065314",
"0.76065314",
"0.7285606",
"0.7165976",
"0.70817536",
"0.7069374",
"0.70202744",
"0.6931129",
"0.6881782",
"0.68361986",
"0.6675497",
"0.6673735",
"0.6653678",
"0.66311437",
"0.65552753",
"0.6510659",
"0.6476... | 0.0 | -1 |
Parse general information in line and update it to GENERAL_INFO dictionary. | def _parse_general_info(self, line):
if self._regex_helper.search_compiled(W._re_general_info, line):
self.current_ret['GENERAL_INFO'].update({
'time': datetime.datetime.strptime(self._regex_helper.group("TIME"), '%H:%M:%S').time(),
'uptime': self._regex_helper.group(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_line(self, line):\n fields = line.split('|', 4) # stop splitting after fourth | found\n line_info = {'raw_message': line}\n if len(fields) == 5:\n line_info.update(dict(zip(self._fieldnames, fields)))\n return line_info",
"def _parse_general_info_V4X(par, parfil... | [
"0.6655572",
"0.65438634",
"0.61774",
"0.6080733",
"0.6014996",
"0.59691495",
"0.5966504",
"0.5905911",
"0.58785135",
"0.583794",
"0.5830027",
"0.57280356",
"0.5722466",
"0.56339806",
"0.562032",
"0.5615857",
"0.5602782",
"0.5572568",
"0.5570758",
"0.5545635",
"0.5519029",
... | 0.8499883 | 0 |
Parse V option output in line and append it to RESULT list. | def _parse_v_option(self, line):
if self._regex_helper.search_compiled(W._re_v_option, line):
self.current_ret['RESULT'].append(self._regex_helper.group("V_OPTION"))
raise ParsingDone | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def processOption (self, line) :\n ll = line.split ('=')\n if len (ll) < 2:\n print \"Cannot parse option \" , line\n sys.exit()\n result = (ll[0].strip() , ll[1].strip())\n return result",
"def _parse_results(self):\n for line in self.file_dic['output'].s... | [
"0.6423425",
"0.5811027",
"0.580129",
"0.5655842",
"0.55434406",
"0.533609",
"0.53108877",
"0.53000253",
"0.5271251",
"0.5269717",
"0.5203191",
"0.51964784",
"0.5171904",
"0.5154556",
"0.5100387",
"0.5036834",
"0.5026639",
"0.5026215",
"0.5009487",
"0.49926525",
"0.49875903",... | 0.8179622 | 0 |
Parse headers and entries in line, create dictionary and append it to RESULT list. | def _parse_header(self, line):
if self._regex_helper.search_compiled(W._re_header, line):
if not self.headers:
for value in re.findall(W._re_header, line):
self.headers.append(value[0])
raise ParsingDone
else:
# Dictiona... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_line(self, line):\n find_result = re.findall(LINE_REGEX, line)\n line_data = {r[0]: r[1] for r in find_result}\n self.process_url(line_data.get('request_to'))\n self.process_status_code(line_data.get('response_status'))",
"def process_line(line):\n\n name_comp_list ... | [
"0.66752446",
"0.6504577",
"0.63924736",
"0.6246586",
"0.60992664",
"0.60275394",
"0.59553164",
"0.5938524",
"0.58829117",
"0.58815986",
"0.58645564",
"0.5864273",
"0.5848218",
"0.5842252",
"0.58342505",
"0.58329415",
"0.5803412",
"0.5788858",
"0.57804203",
"0.5771522",
"0.57... | 0.7336327 | 0 |
We need to find the halfedge h that is incident to u and is on the face that contains the diagonal uv. To find it, we test every pair of halfedges incident to u and v until we find a pair belonging to the same face. | def referenceEdge(u,v):
v1 = u
v2 = v
e1 = u.getEdge().getPrev()
e2 = v.getEdge().getPrev()
aux = None #aux is an half-edge incident to u
while aux != e1:
if aux is None: aux = e1
aux2 = None #aux2 is an half-edge incident to v
while aux2 != e2:
if aux2... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve_homography(u, v):\r\n N = u.shape[0]\r\n H = None\r\n\r\n if v.shape[0] is not N:\r\n print('u and v should have the same size')\r\n return None\r\n if N < 4:\r\n print('At least 4 points should be given')\r\n\r\n # TODO: 1.forming A\r\n A = np.zeros((2*N, 8))\r\n ... | [
"0.60242623",
"0.5956021",
"0.58149",
"0.5760208",
"0.56859523",
"0.5671715",
"0.56677574",
"0.5637607",
"0.5518257",
"0.54610336",
"0.54298204",
"0.5412329",
"0.5374091",
"0.53719383",
"0.53666955",
"0.53609663",
"0.53559095",
"0.5352723",
"0.5348312",
"0.5332194",
"0.531307... | 0.62999815 | 0 |
FNV1 64bit hash function Implement this, and/or DJB2. | def fnv1(self, key):
# hash = 0xff
hash = 0xcbf29ce484222325
for n in key.encode():
# print(n)
hash = hash ^ n
hash = hash * 0x100000001b3
# print(hash)
return hash | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fnv1(self, key, seed=0):\n # def fnv1(self, key):\n\n # Your code here\n \"\"\"\n Returns: The FNV-1 hash (64-bit) of a given string. \n \"\"\"\n #Constants : Fails the tests\n # FNV_prime = 1099511628211\n # offset_basis = 14695981039346656037\n\n # #... | [
"0.7850084",
"0.72370136",
"0.7108986",
"0.705044",
"0.6990908",
"0.691239",
"0.67458034",
"0.6731104",
"0.6608719",
"0.6538066",
"0.65314394",
"0.6447355",
"0.6440217",
"0.6417119",
"0.63966304",
"0.6386951",
"0.63631225",
"0.6338462",
"0.6330434",
"0.63016164",
"0.62938416"... | 0.75328153 | 1 |
DJB2 32bit hash function Implement this, and/or FNV1. | def djb2(self, key):
hash = 5381
for n in key.encode():
# hash = ((hash << 5) + hash) + n
hash = hash * 33 + n
return hash
# return hash & 0xFFFFFFFF | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _hash_djb2(self, key):\n # OPTIONAL STRETCH: Research and implement DJB2\n hash_grotto = 5381\n for k in key:\n hash_grotto = ((hash_grotto << 5) + hash_grotto) + ord(k)\n return hash_grotto & 0xFFFFFFFF",
"def HashAlgorithm(self) -> _n_7_t_0:",
"def get_num_slots(sel... | [
"0.75013524",
"0.73342395",
"0.6955384",
"0.6919217",
"0.6897323",
"0.6879067",
"0.684995",
"0.68333465",
"0.68108124",
"0.6808085",
"0.6805619",
"0.67863303",
"0.6743211",
"0.65885407",
"0.6543602",
"0.65120983",
"0.65104103",
"0.6497235",
"0.6493313",
"0.6491135",
"0.649005... | 0.685876 | 6 |
Take an arbitrary key and return a valid integer index between within the storage capacity of the hash table. | def hash_index(self, key):
# return self.fnv1(key) % self.capacity
return self.djb2(key) % self.capacity | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_index(self, key):\r\n\t\tindex = self._hash_function(key) % self.capacity\r\n\t\treturn index",
"def _get_index(self, key):\n return self._hash_function(key) % self.capacity",
"def find(self, key: T) -> int:\n\n try:\n # passes check with primary hashing function\n i... | [
"0.82723343",
"0.8059556",
"0.7425421",
"0.7415482",
"0.7330069",
"0.7317209",
"0.7286038",
"0.72367275",
"0.72197723",
"0.7199164",
"0.71206874",
"0.7113054",
"0.71044403",
"0.7025496",
"0.6955795",
"0.690559",
"0.6811699",
"0.6794608",
"0.6751182",
"0.6741437",
"0.6739836",... | 0.7555435 | 3 |
Store the value with the given key. Hash collisions should be handled with Linked List Chaining. Implement this. | def put(self, key, value):
hi = self.hash_index(key)
if self.storage[hi]:
current = self.storage[hi]
while current.next and current.key != key:
current = current.next
if current.key == key:
current.value = value
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def put(self, key, value):\n ha = self.myhash(key)\n if key not in self.hashmap[ha][0]:\n self.hashmap[ha][0].append(key)\n self.hashmap[ha][1].append(value)\n else:\n self.hashmap[ha][1][self.hashmap[ha][0].index(key)] = value",
"def put(self, key, value):\n... | [
"0.81106144",
"0.80772465",
"0.8076398",
"0.80682015",
"0.8036524",
"0.8018422",
"0.79838794",
"0.7905589",
"0.7890816",
"0.7876302",
"0.78534526",
"0.781982",
"0.77786344",
"0.77710927",
"0.77464396",
"0.76788867",
"0.7675746",
"0.7673336",
"0.7644221",
"0.76339984",
"0.7602... | 0.8438726 | 0 |
Remove the value stored with the given key. Print a warning if the key is not found. Implement this. | def delete(self, key):
hi = self.hash_index(key)
# if that hi is empty ignore
# if self.storage[hi] is None:
# print("WARNING: no key")
# return
current = self.storage[hi]
prev = self.storage[hi]
while current and current.key != key:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_value(self, key: str) -> None:\n raise NotImplementedError",
"def remove(self, key):\n\n index = self._get_hash(key)\n\n if self.table[index] is not None:\n for i, pair in enumerate(self.table[index]):\n if key == pair[0]:\n del self.ta... | [
"0.8015489",
"0.7890396",
"0.78630865",
"0.77276903",
"0.7694492",
"0.7658495",
"0.75991946",
"0.7547378",
"0.7540013",
"0.75382787",
"0.7528272",
"0.7514823",
"0.74924624",
"0.74631125",
"0.74571407",
"0.74240434",
"0.7404178",
"0.740016",
"0.7383215",
"0.7339205",
"0.731292... | 0.0 | -1 |
Retrieve the value stored with the given key. Returns None if the key is not found. Implement this. | def get(self, key):
hi = self.hash_index(key)
if (self.storage[hi]):
if(self.storage[hi].next):
current = self.storage[hi]
while current.next and current.key != key:
current = current.next
return current.value
el... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def retrieve(self, key):\n index = self._hash_mod(key)\n node = self.storage[index]\n while node is not None:\n if node.key == key:\n return node.value\n node = node.next\n return None",
"def get(self, key):\n\n node = self._get_node(key) #... | [
"0.8208157",
"0.8203918",
"0.8190829",
"0.8146119",
"0.8118441",
"0.8083434",
"0.80767083",
"0.80651796",
"0.7955004",
"0.7951158",
"0.7878939",
"0.787848",
"0.7858636",
"0.7857246",
"0.78159803",
"0.78017765",
"0.7784482",
"0.77715313",
"0.77582735",
"0.7758255",
"0.77547365... | 0.79671395 | 8 |
Doubles the capacity of the hash table and rehash all key/value pairs. Implement this. | def resize(self, factor=2):
self.capacity = round(self.capacity*factor)
newarr = [None] * self.capacity
for i, v in enumerate(self.storage):
while v:
hi = self.hash_index(v.key)
if newarr[hi]:
current = newarr[hi]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rehash(self):\n new_cap = self._get_new_capacity() # Choose not to handle the ValueError thrown by _get_new_capacity()\n new_table = HashTable(new_cap) # Create a new hash table directly\n for i in range(self.size):\n if self.keys[i] is not None: # Only put() when there exist... | [
"0.81800413",
"0.80060524",
"0.78790945",
"0.720138",
"0.7163807",
"0.7084468",
"0.70818853",
"0.68698233",
"0.68121934",
"0.6672545",
"0.66696256",
"0.6579458",
"0.64621586",
"0.6386414",
"0.62088525",
"0.61762494",
"0.59902906",
"0.5952233",
"0.581466",
"0.5799071",
"0.5767... | 0.6915366 | 7 |
Write a program that takes as input a BST and an interger k, and returns the k largest elements in the BST in decreasing order. | def find_k_largest_in_bst_recursively(tree, k):
def find_k_largest_in_bst_helper(tree):
if tree and len(k_largest_elements) < k: # Smart: Recursion iff we don't have K largest elements collected
find_k_largest_in_bst_helper(tree.right)
if len(k_largest_elements) < k:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def findKthLargest(self, nums: List[int], k: int) -> int:\n return sorted(nums)[-k]",
"def _get_k_largest(lst, k):\n sorted_lst = sorted([(val, index) for index, val in enumerate(lst)])\n return list(reversed(sorted_lst[-k:]))",
"def kth_largest(arr: list, k: int):\n # Do not search if k is lar... | [
"0.7045558",
"0.701398",
"0.6677336",
"0.6673362",
"0.66666937",
"0.65226465",
"0.65028167",
"0.646503",
"0.6402724",
"0.63980407",
"0.6357561",
"0.6304622",
"0.617777",
"0.61401814",
"0.6116958",
"0.6113665",
"0.6077666",
"0.60618454",
"0.60614383",
"0.60428995",
"0.60170496... | 0.8523908 | 0 |
Calculate upper percentile MCP cutoff for avoiding Andor saturation Andor begins saturating at ~5000 for 'signal' value. Set percentile cutoff of incident fluence (mcp) to the percentile where Andor reaches 4000, well before saturation. If that is greater than the 99.9th percentile, set percentile cutoff to 99.9 to eli... | def _calculate_percentile_cutoff(run_numbers):
mcp_values = []
andor_values = []
for run_number in run_numbers:
current_data_path = ''.join([DATA_PATH, 'run', str(run_number), 'allevts.h5'])
f = h5py.File(current_data_path, 'r')
current_phot = _get_photon_energy(f, run_number)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cut_spectrum(input_spectrum, desired_frequency_range):\n channels_ip = []\n for ip in input_spectrum.GetChannels():\n channel_ip = []\n channel_op = []\n for n, i in enumerate(ip):\n if n > desired_frequency_range[0] / input_spectrum.GetResolution() and n < desired_frequen... | [
"0.5653417",
"0.5633713",
"0.5491142",
"0.54786575",
"0.54064196",
"0.53240645",
"0.52246594",
"0.52203375",
"0.52071315",
"0.51993823",
"0.5179031",
"0.51522595",
"0.51460844",
"0.51184833",
"0.50988865",
"0.5083905",
"0.5054955",
"0.5052072",
"0.50464624",
"0.50445575",
"0.... | 0.59004277 | 0 |
Calculate polynomial to correct slight nonlinearity in MCP response | def do_mcp_nonlinearity_calibration():
no_sample_data_path = ''.join([DATA_PATH, 'run108allevts.h5'])
f = h5py.File(no_sample_data_path)
phot = _get_photon_energy(f, 108)
mcp = np.array(f['Acqiris2']['acq'])
andor = np.array(f['Andor']['signal']-f['Andor']['reference'])
# Subtract dark signals:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_polynomial():\n degree = numpy.random.choice(range(3, 7))\n x = numpy.linspace(-10, 10, 1000)\n coefficients = numpy.random.chisquare(3, size=degree) + 1\n coefficients *= numpy.random.choice([-1, 1], size=coefficients.shape)\n coefficients *= 0.5\n y = numpy.polyval(coefficients, x)... | [
"0.66424847",
"0.65410674",
"0.65383047",
"0.6523504",
"0.6429001",
"0.63814205",
"0.6350041",
"0.6323735",
"0.62960255",
"0.6285092",
"0.6248639",
"0.6246817",
"0.6244223",
"0.6241529",
"0.62292457",
"0.6215943",
"0.6210995",
"0.6187557",
"0.61658406",
"0.6146332",
"0.611326... | 0.59670556 | 38 |
hash file 'filename', return a sha1 object | def hash_file ( filename ):
sha1 = hashlib.sha1()
with open( filename, 'rb' ) as f:
while True:
buf = f.read(65536) # read by 64kb buffers size
if not buf:
break
sha1.update(buf)
return sha1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hash_file(filename):\r\n\r\n # make a hash object\r\n h = hashlib.sha1()\r\n\r\n # open file for reading in binary mode\r\n with open(filename,'rb') as file:\r\n\r\n # loop till the end of the file\r\n chunk = 0\r\n while chunk != b'':\r\n # read only 1024 bytes at a time\r\... | [
"0.86476487",
"0.8624012",
"0.8624012",
"0.8598889",
"0.85914165",
"0.85725063",
"0.8362854",
"0.82423913",
"0.82207185",
"0.8157332",
"0.81049347",
"0.80176985",
"0.8006898",
"0.7986033",
"0.79686046",
"0.7901671",
"0.7900068",
"0.7896424",
"0.78734815",
"0.77931935",
"0.776... | 0.85206515 | 6 |
Determine the length of the shortest path from start cloud to end cloud while avoiding clouds with value 1. Jumps can be of length 1 or 2, although jumps must be made through the consequtive clouds. | def jumping_on_the_clouds(clouds):
index_clouds = [index for index, v in enumerate(clouds) if v == 0]
for cloud in index_clouds:
if index_clouds.index(cloud) == len(index_clouds) - 1:
break
if index_clouds[index_clouds.index(cloud) - 1] == cloud - 1 and \
index_clouds[index_c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shortest_path_lengths(self, g, src):\n d = {} # d[v] is upper bound from s to v\n cloud = {} # map reachable v to its d[v] value\n pq = AdaptableHeapPriorityQueue() # vertex v will have key d[v]\n pqlocato... | [
"0.61706465",
"0.57521135",
"0.5744518",
"0.568371",
"0.55816853",
"0.5577766",
"0.55322653",
"0.55223036",
"0.5512849",
"0.55110043",
"0.55074567",
"0.5502363",
"0.54598504",
"0.5440564",
"0.54400444",
"0.54284394",
"0.53597796",
"0.5335412",
"0.5313877",
"0.5312186",
"0.530... | 0.5281062 | 21 |
Receives input from stdin, provides output to stdout. | def main():
raw_input()
clouds = map(int, raw_input().split(' '))
print jumping_on_the_clouds(clouds) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stdin(self):\n pass",
"def read_input():\n\n read = sys.stdin.readlines()\n\n text = ''\n for line in read:\n text += line\n\n return text",
"def read_stdin():\n return \"\".join(sys.stdin.readlines()).strip()",
"def _input(str=''):\n print(str, end='',... | [
"0.699605",
"0.6673594",
"0.6417195",
"0.641211",
"0.63803685",
"0.63787425",
"0.63246727",
"0.628672",
"0.6164965",
"0.6164865",
"0.6141185",
"0.6102546",
"0.6100803",
"0.59521854",
"0.5943102",
"0.58946633",
"0.58735377",
"0.58601946",
"0.5853264",
"0.58521783",
"0.5836183"... | 0.0 | -1 |
Return the widget to give focus to when this plugin's dockwidget is raised on toplevel | def get_focus_widget(self):
return self.datatree | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_focus_widget(self):\r\n return self.shell",
"def XPGetWidgetWithFocus():\n pass",
"def get_focus(self):\n\n self.activateWindow()\n self.setFocus()",
"def get_focus_widget(self):\n # TODO - focus on channel list\n# self.combo.lineEdit().selectAll()\n# retu... | [
"0.7704666",
"0.7102243",
"0.69277894",
"0.68596774",
"0.6834897",
"0.67454267",
"0.6497104",
"0.64854103",
"0.64425933",
"0.6428573",
"0.6415316",
"0.6415316",
"0.63931817",
"0.63340354",
"0.6328461",
"0.6324133",
"0.630882",
"0.6146666",
"0.61402094",
"0.6127258",
"0.606946... | 0.67533296 | 5 |
Return a list of actions related to plugin | def get_plugin_actions(self):
return [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getActions():\n return getPlugins(IRenamingAction, plugins)",
"def get_actions(self):\n return []",
"def get_list_of_actions(self):\n return self.actions",
"def actions(self):\n return self._action_list",
"def actions(self):\n from moztrap.view.lists.actions import action... | [
"0.8130526",
"0.76124007",
"0.7425578",
"0.73972076",
"0.72777",
"0.7205521",
"0.7205521",
"0.7205521",
"0.7167486",
"0.7161599",
"0.7116936",
"0.7075639",
"0.70122087",
"0.68798953",
"0.67999965",
"0.6772967",
"0.6758088",
"0.67547417",
"0.6751595",
"0.6751595",
"0.67393315"... | 0.8701119 | 1 |
Action to be performed on first plugin registration | def on_first_registration(self):
self.main.tabify_plugins(self.main.help, self)
self.dockwidget.hide() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_first_registration(self):\n pass",
"def plugin_loaded():\n events.broadcast(\"plugin_loaded\")",
"def init():\n g.registerHandler('new', new_hook)\n g.registerHandler('create-node', create_node_hook)\n g.registerHandler('select1', select1_hook)\n g.plugin_signon(__name__)\n retu... | [
"0.7602643",
"0.731127",
"0.69100946",
"0.6785684",
"0.67597336",
"0.67597336",
"0.6756247",
"0.6613261",
"0.658728",
"0.65075296",
"0.6474666",
"0.64614034",
"0.64464325",
"0.6428728",
"0.6416666",
"0.63851625",
"0.6381655",
"0.63470215",
"0.6346777",
"0.6321743",
"0.6249476... | 0.7290536 | 2 |
Register plugin in Spyder's main window | def register_plugin(self):
self.edit_goto.connect(self.main.editor.load)
self.redirect_stdio.connect(self.main.redirect_internalshell_stdio)
self.main.add_dockwidget(self)
unittesting_act = create_action(self, _("Run unit tests"),
icon=get_icon('p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_plugin(self):\n self.create_toggle_view_action()\n\n self.main.add_dockwidget(self)",
"def test_addplugin(self):\n app = QApplication(sys.argv)\n data = (np.random.rand(30, 31, 32) * 100).astype(np.int)\n data[15:40, 13:20, 10:18] += 50\n se = seededitorqt.Q... | [
"0.69762045",
"0.60747755",
"0.58828604",
"0.5874758",
"0.58635104",
"0.57819545",
"0.5741525",
"0.5716186",
"0.5689403",
"0.56821126",
"0.5669613",
"0.56537426",
"0.55752265",
"0.5545013",
"0.55267227",
"0.55135757",
"0.5477841",
"0.546501",
"0.5450378",
"0.54207486",
"0.536... | 0.65753347 | 1 |
Refresh unit testing widget | def refresh_plugin(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testRefresh(self):\n \n pass",
"def test_update(self):\n # this is tested graphically, as it is UI\n pass",
"def updateWidget(self):\n pass",
"def refresh(self):\n\t\tself.driver.refresh()",
"def test_visualisations_perform_visualisation_render_data_refresh_synchronously(... | [
"0.77160954",
"0.6853362",
"0.6844457",
"0.6520042",
"0.64972293",
"0.6480656",
"0.6453007",
"0.64422596",
"0.6441096",
"0.64315104",
"0.64105207",
"0.640197",
"0.63611436",
"0.63520265",
"0.63520265",
"0.6331086",
"0.6330639",
"0.6268165",
"0.6268165",
"0.6268165",
"0.622601... | 0.5928176 | 32 |
Perform actions before parent main window is closed | def closing_plugin(self, cancelable=False):
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __onclosing(self):\n self.window.destroy()",
"def __window_close(self):\n pass",
"def onCloseWindow(self, event):\r\n\r\n self.Destroy()",
"def close(self):\n self.parent.activate()",
"def close(self):\n self.state = False\n self.mainwindow.sendMessage('a')\n ... | [
"0.8200261",
"0.8100803",
"0.7912978",
"0.78707916",
"0.78692687",
"0.78053725",
"0.76622653",
"0.7656516",
"0.7632609",
"0.7623432",
"0.76179266",
"0.7617525",
"0.7596765",
"0.75940526",
"0.75664365",
"0.75600374",
"0.7546721",
"0.7520903",
"0.7520903",
"0.7520903",
"0.75209... | 0.0 | -1 |
Apply configuration file's plugin settings | def apply_plugin_settings(self, options):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def use_config_file(self):\n self.config_file = self.find_config_file()\n if self.config_file:\n self.apply_config_file(self.config_file)",
"def apply_config(filename):\n with open(filename) as config_file:\n config = json.load(config_file)\n for setting, val... | [
"0.67779297",
"0.6747643",
"0.66346806",
"0.6428851",
"0.6423092",
"0.6381086",
"0.63534784",
"0.6292545",
"0.62646264",
"0.6239537",
"0.6237905",
"0.6227397",
"0.6210529",
"0.6172642",
"0.61720854",
"0.6128758",
"0.60786307",
"0.6069815",
"0.60622776",
"0.6050749",
"0.604386... | 0.7636843 | 0 |
Used to display the basic/home page for logged in user. | def view_profile(request, user_id=None):
requesting_user = request.user
if user_id:
requested_user = get_object_or_404(User, pk=user_id)
else:
requested_user = requesting_user
profile = Profile.objects.for_user(requested_user)
datasets = DataSet.objects.active().filter... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def home():\n\n # sets the page to load depending on the type of user\n # if none specified the login screen will be displayed\n pageName = ''\n userType = session.get('UserType', None)\n if userType == None:\n pageName = 'anonHome.jade'\n elif userType == 'Seeker':\n pageName = 'in... | [
"0.8019861",
"0.7620225",
"0.75773484",
"0.7534236",
"0.7531676",
"0.7529761",
"0.7448983",
"0.7423995",
"0.73834974",
"0.72934496",
"0.72723556",
"0.7247265",
"0.72185725",
"0.7184802",
"0.71762604",
"0.71736443",
"0.7173331",
"0.71588814",
"0.71466374",
"0.70936805",
"0.708... | 0.0 | -1 |
Used to allow a user to edit their own profile. | def edit_profile(request):
user = request.user
profile = Profile.objects.for_user(user)
if request.method != 'POST':
profile_form = ProfileForm(instance=profile)
user_form = UserForm(instance=user)
else:
profile_form = ProfileForm(request.POST, instance=profile)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def edit_profile(self, name, username, email):\n return self.app.post('/_editProfile', data = dict(\n name = name,\n username = username,\n email = email\n ), follow_redirects = True)",
"def edit_user():\n if CURR_USER_KEY in session:\n user = g.user\n... | [
"0.7839375",
"0.76361674",
"0.75991297",
"0.757305",
"0.7543597",
"0.74999654",
"0.7481396",
"0.74729866",
"0.7393925",
"0.73854417",
"0.7290376",
"0.7259955",
"0.7223237",
"0.72067004",
"0.72060645",
"0.7162687",
"0.7130685",
"0.7072604",
"0.7040199",
"0.70098627",
"0.697346... | 0.7651815 | 1 |
Write experiment config to file | def save_experiment_config(self):
if (self.use_dist and dist.get_rank() == 0) or not self.use_dist:
logfile = os.path.join(self.experiment_dir, 'parameters.txt')
log_file = open(logfile, 'w')
log_file.write('\n')
json.dump(self.args.__dict__, log_file, indent=2)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write(self, fn):\n with open(fn, 'w') as f:\n self.config.write(f)",
"def __write_config(self):\n with open(self.config_file, 'w') as data_file:\n config = {\"ibooks_doc_root\":self.ibooks_doc_root,\n \"library_folder\":self.library_folder,\n \"annota... | [
"0.7415516",
"0.73900247",
"0.7218968",
"0.72177714",
"0.71523476",
"0.70878863",
"0.70843565",
"0.7062435",
"0.6997892",
"0.6982512",
"0.6912694",
"0.6897209",
"0.6897209",
"0.6863159",
"0.6842561",
"0.67937106",
"0.6761959",
"0.67610425",
"0.6752727",
"0.67474806",
"0.67445... | 0.7216942 | 4 |
Return three Keras HDF5Matrix instances for the input, groundtruth density map and groundtruth segmentation mask in a compact TrainingSet | def get_matrices(training_set_path):
if os.path.isfile(training_set_path):
X = HDF5Matrix(training_set_path, 'input/input')
y = HDF5Matrix(training_set_path, 'target/target')
y_seg = HDF5Matrix(training_set_path, 'seg_map/seg_map')
return X, y, y_seg
else:
raise Exception... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transform_to_h5():\n # this took about 10 minutes for set1\n for setname in ['set1', 'set2']:\n filename = os.path.join(ltrc_dirname, '{}.h5'.format(setname))\n f = h5py.File(filename, 'w')\n\n for name in ['train', 'valid', 'test']:\n g = f.create_group(name)\n ... | [
"0.60946685",
"0.5913993",
"0.58595705",
"0.5826413",
"0.58137065",
"0.5807853",
"0.5747172",
"0.5703104",
"0.5692386",
"0.56754106",
"0.56699955",
"0.56411266",
"0.56325924",
"0.5626313",
"0.56190795",
"0.5594807",
"0.5573859",
"0.55735236",
"0.5554242",
"0.5549842",
"0.5542... | 0.63189304 | 0 |
Generate outputs from a noncompact TrainingSet to use with Keras' 'fit_generator' function. If 'n_crops' is nonzero, the Iterator crops n_crops 20x20 regions from each image before feeding them. | def flow(self, batch_size=32, output='both', crops=0):
while True:
for dataset in self.input_sets:
X = self.training_set['input/'+dataset]
y = self.training_set['target/'+dataset]
y_seg = self.training_set['seg_map/'+dataset]
for i in ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def crop_generator(batches, crop_length):\n while True:\n batch_x, batch_y = next(batches)\n batch_crops = np.zeros((batch_x.shape[0], crop_length, crop_length, 3))\n for i in range(batch_x.shape[0]):\n batch_crops[i] = random_crop(batch_x[i], (crop_length, crop_length))\n ... | [
"0.58771247",
"0.57928264",
"0.57725567",
"0.5747757",
"0.5570905",
"0.5488688",
"0.5483506",
"0.5471397",
"0.5459297",
"0.5440349",
"0.54253316",
"0.54131067",
"0.5412875",
"0.54017425",
"0.5401398",
"0.5400203",
"0.53945994",
"0.5369897",
"0.5358676",
"0.53234917",
"0.53224... | 0.6750257 | 0 |
generate upstream cherrypick patch files | def generate_patch_files(sha_list: List[str], start_version: int) -> PatchList:
upstream_dir = paths.TOOLCHAIN_LLVM_PATH
fetch_upstream_once()
result = PatchList()
for sha in sha_list:
if len(sha) < 40:
sha = get_full_sha(upstream_dir, sha)
file_path = paths.SCRIPTS_DIR / 'pa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_genpatch(self, argv):\n #TODO:\n # - Would an optional [<files> ...] argument be useful or is\n # that overkill? E.g. 'p4 genpatch ./...' (I think that that\n # would be very useful.\n # - Could add '-f' option to only warn on 'out of sync'.\n # - Coul... | [
"0.6193804",
"0.61185837",
"0.60817057",
"0.587971",
"0.5735855",
"0.57174575",
"0.5645524",
"0.55588645",
"0.5523853",
"0.5493776",
"0.54873055",
"0.5407881",
"0.53941137",
"0.5388479",
"0.5378879",
"0.53761584",
"0.5310182",
"0.52620775",
"0.52522963",
"0.52342397",
"0.5227... | 0.6612873 | 0 |
Use the userprovided CLI arguments to find Rez packages. | def __gather_package_data(arguments):
ignore_patterns, packages_path, search_packages_path = _resolve_arguments(
arguments.ignore_patterns,
arguments.packages_path,
arguments.search_packages_path,
)
rez_packages = set(arguments.rez_packages)
package_finder = registry.get_package... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cli(args): # noqa; pylint: disable=unused-argument",
"def main(args):\n cli = CLI()\n # Check arguments\n cli.parse_arguments(args)",
"def main(args):",
"def main(args):",
"def main():\n licensify(_parse_args())",
"def main(args=None):",
"def main(args=None):",
"def query_cmdline():"... | [
"0.67388576",
"0.66946054",
"0.6388412",
"0.6388412",
"0.63570476",
"0.62585646",
"0.62585646",
"0.62556493",
"0.6208808",
"0.62030077",
"0.61873835",
"0.61870766",
"0.6160379",
"0.6157867",
"0.6155319",
"0.60664207",
"0.60664207",
"0.60664207",
"0.60664207",
"0.60664207",
"0... | 0.0 | -1 |
Print out every package and its status information. This function prints out Packages that were found as "invalid" Packages that were skipped automatically Packages that were ignored explicitly (by the user) | def __report(arguments, _):
ignored_packages, other_packages, invalid_packages, skips = __gather_package_data(
arguments
)
packages, invalids = worker.report(
other_packages,
maximum_repositories=arguments.maximum_repositories,
maximum_rez_packages=arguments.maximum_rez_pack... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _print_missing(packages, verbose):\n if not packages:\n print(\"## No Rez packages were found.\")\n print(\"No data found\")\n\n return\n\n print(\"## Your command affects these Rez packages.\")\n\n template = \"{package.name}\"\n\n if verbose:\n template = \"{package.na... | [
"0.75528216",
"0.734317",
"0.70231634",
"0.6996778",
"0.6639634",
"0.65396285",
"0.63859266",
"0.63610005",
"0.6253691",
"0.6054543",
"0.60348654",
"0.5987873",
"0.59685683",
"0.59673953",
"0.59105027",
"0.57375103",
"0.5688907",
"0.56304795",
"0.5588385",
"0.55742896",
"0.55... | 0.5926434 | 14 |
Execute a plugin command on any package that needs it. | def __run(arguments, command_arguments): # pylint: disable=too-many-locals
ignored_packages, other_packages, invalid_packages, skips = __gather_package_data(
arguments
)
command = registry.get_command(arguments.command)
packages, un_ran, invalids = worker.run(
functools.partial(comman... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_plugins(group):\n package = sys.modules[__name__]\n\n for (importer, module_name, ispkg) in pkgutil.iter_modules(package.__path__):\n if not ispkg:\n try:\n module = importlib.import_module(package.__name__ + '.' + module_name)\n\n if 'run' not in modu... | [
"0.6978726",
"0.6254254",
"0.6242243",
"0.6231577",
"0.5971375",
"0.5952955",
"0.595294",
"0.5947213",
"0.5931876",
"0.5922034",
"0.59098864",
"0.5870987",
"0.5864653",
"0.5852075",
"0.58266354",
"0.58263",
"0.5813188",
"0.57689124",
"0.5759055",
"0.57544816",
"0.573416",
"... | 0.0 | -1 |
Write a cache of GitHub users todisk. | def __make_git_users(arguments):
github_user.write_cache(
arguments.path,
arguments.token,
base_url=arguments.base_url,
verify=arguments.ssl_no_verify,
maximum=arguments.maximum_users,
)
print(
'GitHub users were written to "{arguments.path}" successfully.'
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def saveCacheFile(self):\n with open(self.cachePath, 'w', encoding='utf-8') as outfile:\n json.dump(self.cacheData, outfile)",
"def save_cache(cache_key, version, data):\n\n # Save these results for the next run. Include the version information and nest the user\n # information inside a \"users\" k... | [
"0.65254027",
"0.6457006",
"0.6325532",
"0.6226892",
"0.61698765",
"0.6146631",
"0.6111177",
"0.6007813",
"0.5938739",
"0.59114945",
"0.58837384",
"0.5855156",
"0.57993",
"0.5761495",
"0.57532364",
"0.57507557",
"0.5726013",
"0.5722801",
"0.57184774",
"0.57181704",
"0.5702436... | 0.60137564 | 7 |
Get the "userignored" Rez packages. | def _split_the_ignored_packages(packages, patterns):
ignored = set()
non_ignored = set()
for package in packages:
for pattern in patterns:
if fnmatch.fnmatch(package.name, pattern):
ignored.add((package, pattern))
break
else:
non_igno... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getusersitepackages():\n\tpass",
"def packages(self):\n return []",
"def user_packages(self, host: (str), user: (str)) -> Any:\n return search_api(\"user_packages\", host, user)",
"def get_packages():\n\n packages = find_packages()\n packages = ['{}.{}'.format('uniq', package) for pac... | [
"0.70381504",
"0.60557246",
"0.6004433",
"0.599181",
"0.59327734",
"0.5899515",
"0.5897012",
"0.58251196",
"0.56858665",
"0.5647229",
"0.56442803",
"0.5642458",
"0.56385034",
"0.5618204",
"0.55391264",
"0.5537971",
"0.5523503",
"0.54886055",
"0.54812515",
"0.5385388",
"0.5347... | 0.51812875 | 39 |
Convert userprovided data into glob expressions. | def _resolve_arguments(patterns, packages_path, search_packages_path):
def _read_patterns(path):
try:
with open(path, "r") as handler:
return set(handler.read().splitlines())
except IOError:
return set()
ignore_patterns = set()
for item in patterns:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_globs(self, build_patterns: Iterable[str]) -> Tuple[str, ...]:",
"def glob2re(glob: str) -> str: # pylint: disable=too-many-branches\n index = 0\n size = len(glob)\n results: List[str] = []\n\n while index < size:\n char = glob[index]\n index += 1\n\n if char == \"*\":\n ... | [
"0.64430857",
"0.63578635",
"0.6261387",
"0.60944086",
"0.5796563",
"0.57915723",
"0.56762636",
"0.5663169",
"0.56547064",
"0.5645",
"0.56442356",
"0.56302255",
"0.5625942",
"0.56170833",
"0.55723745",
"0.5567273",
"0.550928",
"0.5502115",
"0.5493355",
"0.5465679",
"0.5431877... | 0.0 | -1 |
Print every package as "ignored". | def _print_ignored(packages):
if not packages:
print("## No Rez package was set to be ignored")
print("No data found")
return
print("## Every package in this list was explicitly set to ignored by the user")
for package, pattern in sorted(packages, key=_get_package_name):
p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _print_missing(packages, verbose):\n if not packages:\n print(\"## No Rez packages were found.\")\n print(\"No data found\")\n\n return\n\n print(\"## Your command affects these Rez packages.\")\n\n template = \"{package.name}\"\n\n if verbose:\n template = \"{package.na... | [
"0.6896404",
"0.65300035",
"0.64506",
"0.6380679",
"0.6243997",
"0.6215631",
"0.6034081",
"0.60240585",
"0.58716226",
"0.5729593",
"0.57106125",
"0.5704774",
"0.56812304",
"0.5655815",
"0.565425",
"0.5575963",
"0.5534667",
"0.550217",
"0.5492941",
"0.54724574",
"0.547046",
... | 0.83495414 | 0 |
Print out the errors that were found. | def _print_invalids(invalids, verbose):
if not invalids:
print("## No Rez package was set as invalid.")
print("Nothing is invalid. Which is a good thing!")
return
print("## Some packages were marked as invalid. Here's why:")
template = "{package.name}: {message}"
if verbose:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_errors(self):\n\n if self.errors:\n print('Clean error in:')\n for file in self.errors:\n print(' %s' % file)",
"def showerrors():\n errorMessages = middleware.ixn.showErrorMessage(silentMode=True)\n if errorMessages:\n print(errorMe... | [
"0.79570866",
"0.76505107",
"0.7556986",
"0.7181456",
"0.7115748",
"0.70891637",
"0.698253",
"0.6980931",
"0.69472224",
"0.6878406",
"0.6876207",
"0.68568164",
"0.6730276",
"0.66749024",
"0.6658213",
"0.6623326",
"0.6581947",
"0.65270984",
"0.6495916",
"0.6495916",
"0.6464373... | 0.6638913 | 15 |
Print all Rez packages that should be run on. | def _print_missing(packages, verbose):
if not packages:
print("## No Rez packages were found.")
print("No data found")
return
print("## Your command affects these Rez packages.")
template = "{package.name}"
if verbose:
template = "{package.name}: {path}"
for line... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_packages(self):\n for tag, pkg in PACKAGES.iteritems():\n print \"{tag} - {label}\".format(tag=tag, label=pkg['label'])",
"def _print_ignored(packages):\n if not packages:\n print(\"## No Rez package was set to be ignored\")\n print(\"No data found\")\n\n return... | [
"0.6903446",
"0.6681349",
"0.64860743",
"0.6483986",
"0.64436895",
"0.63718176",
"0.6362368",
"0.62700814",
"0.62351704",
"0.6204767",
"0.6189284",
"0.61830366",
"0.61695254",
"0.6160334",
"0.6057463",
"0.6053403",
"0.6039349",
"0.5968796",
"0.5965892",
"0.5961952",
"0.595328... | 0.7438773 | 0 |
Print the Rez packages that were skipped automatically by this tool. Skipped packages differ from "invalid" packages in that they are "valid Rez packages but just don't need the command run on". Ignored packages are Rez packages that the user explicitly said to not process. Skipped packages are packages that the user m... | def _print_skips(skips, verbose):
if not skips:
print("## No packages were skipped")
print("Every found Rez package can be processed by the command.")
return
print("## Packages were skipped from running a command. Here's the full list:")
template = "{issue.package.name}: {issue.re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _print_ignored(packages):\n if not packages:\n print(\"## No Rez package was set to be ignored\")\n print(\"No data found\")\n\n return\n\n print(\"## Every package in this list was explicitly set to ignored by the user\")\n\n for package, pattern in sorted(packages, key=_get_pack... | [
"0.7548334",
"0.75025696",
"0.6658978",
"0.64952445",
"0.59089476",
"0.58754075",
"0.5860346",
"0.5699727",
"0.5639692",
"0.5637996",
"0.5636697",
"0.5571671",
"0.5533277",
"0.55121475",
"0.54966754",
"0.5486724",
"0.5446966",
"0.54336095",
"0.53756714",
"0.53676933",
"0.5310... | 0.80562556 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.