({$shape})});'\\n ).substitute(out_name=out_name, shape=shape)\\n )\\n self.output_meta.append(\\n self.MakeOutputMetaInfo.substitute(out_name=out_name, dtype=dtype, shape=shape)\\n )\\n\\n # Mem allocation & Param copy\\n self.clml_code.append(\\\"// Allocate Tensor Memory and copy params\\\")\\n self.clml_code.append(\\\"runner.AllocateMemAndPopulateParams();\\\")\\n\\n # Meta data preparation\\n self.clml_code.append(\\n self.MakeMetaInfo.substitute(\\n name=self.sub_module_name,\\n input_count=len(self.input_meta),\\n output_count=len(self.output_meta),\\n input_meta=\\\"\\\\\\\\\\\\n\\\".join(self.input_meta),\\n output_meta=\\\"\\\\\\\\\\\\n\\\".join(self.output_meta),\\n )\\n )\\n\\n self.clml_code.append(self.MakeFooter.substitute())\\n return (self.sub_module_name, self.clml_code)\",\n \"def __repr__(self):\\n\\n if not self.output :\\n return \\\"\\\"\\n\\n # if self.is_abstract:\\n # result = \\\"\\\\n # Properties inherited from \\\" + self.class_name + \\\"\\\\n\\\"\\n # if len(self.attributes) > 0:\\n # for attribute_ in self.attributes:\\n # result += repr(attribute_)\\n # # else:\\n # # result += \\\"\\\\n pass\\\"\\n # result += \\\"\\\\n\\\"\\n # result += \\\" # End of properties inherited from \\\" + self.class_name + \\\"\\\\n\\\"\\n # return result.encode('ascii', 'ignore')\\n\\n # Not an abstract class, so output as a full class\\n result = \\\"class \\\"\\n result += self.class_name\\n\\n result += \\\"(Base): # class definition\\\\n\\\"\\n\\n result += \\\" __tablename__ = \\\\'\\\" + self.class_name.lower() + \\\"\\\\'\\\\n\\\\n\\\"\\n result += \\\" id = Column(Integer, primary_key=True)\\\\n\\\"\\n\\n\\n # If this class has a general class, then add a foreign key to it\\n if self.general_class:\\n #result += repr(self.general_class)\\n result += \\\" \\\" + self.general_class_name.lower() + \\\"_id = \\\"\\n result += \\\"Column('\\\" + self.general_class_name.lower() + \\\"_id', \\\"\\n result += \\\"ForeignKey('\\\" + self.general_class_name.lower() + \\\".id'), nullable = True)\\\"\\n\\n if len(self.attributes) > 0:\\n for attribute_ in self.attributes:\\n result += repr(attribute_)\\n # else:\\n # result += \\\"\\\\n pass\\\"\\n\\n result += \\\"\\\\n\\\"\\n\\n return result.encode('ascii', 'ignore')\",\n \"def readEntities(self):\\n entities = {}\\n \\n # Regexes must be greedy to prevent matching outer entity and end_entity strings\\n # Regexes have re.DOTALL to match newlines\\n for m in re.finditer(\\\"ENTITY (.*?)END_ENTITY;\\\", self.data, re.DOTALL):\\n entity = {}\\n raw_entity_str = m.groups()[0]\\n\\n entity[\\\"name\\\"] = re.search(\\\"(.*?)[;|\\\\s]\\\", raw_entity_str).groups()[0].upper()\\n \\n is_supertype = re.search(\\\"SUPERTYPE\\\", raw_entity_str) != None\\n if is_supertype:\\n supertypeofmatch = re.search(\\\".*SUPERTYPE OF \\\\((.*?)\\\\)\\\", raw_entity_str)\\n is_abstract_supertype = re.search(\\\"ABSTRACT SUPERTYPE\\\", raw_entity_str) != None\\n \\n is_subtype = re.search(\\\"SUBTYPE\\\", raw_entity_str) != None\\n\\n if is_supertype and is_subtype:\\n if is_abstract_supertype:\\n # abstract supertype of ... subtype of ... ;\\n match = re.search(\\\".*ABSTRACT SUPERTYPE OF\\\\s+\\\\((.*?)\\\\)\\\\s+SUBTYPE OF\\\\s+\\\\((.*?)\\\\);\\\", raw_entity_str, re.DOTALL)\\n entity[\\\"isabstract\\\"] = True\\n supertypeof,subtypeof = match.groups()\\n entity[\\\"supertype\\\"] = subtypeof.upper()\\n supertypeof = re.sub('\\\\s', '', supertypeof)\\n supertypeofmatch = re.search(\\\".*\\\\((.*?)\\\\)\\\", supertypeof, re.DOTALL)\\n subtypes = supertypeofmatch.groups()[0].upper().split(',')\\n entity[\\\"subtypes\\\"] = subtypes\\n else:\\n # supertype of ... subtype of ... ;\\n match = re.search(\\\".*SUPERTYPE OF\\\\s+\\\\((.*?)\\\\)\\\\s+SUBTYPE OF\\\\s+\\\\((.*?)\\\\);\\\", raw_entity_str, re.DOTALL)\\n entity[\\\"isabstract\\\"] = False\\n supertypeof,subtypeof = match.groups()\\n entity[\\\"supertype\\\"] = subtypeof.upper()\\n supertypeof = re.sub('\\\\s', '', supertypeof)\\n supertypeofmatch = re.search(\\\".*\\\\((.*?)\\\\)\\\", supertypeof, re.DOTALL)\\n subtypes = supertypeofmatch.groups()[0].upper().split(',')\\n entity[\\\"subtypes\\\"] = subtypes\\n elif is_subtype:\\n # subtype of ... ;\\n subtypeofmatch = re.search(\\\".*SUBTYPE OF \\\\((.*?)\\\\);\\\", raw_entity_str)\\n entity[\\\"supertype\\\"] = subtypeofmatch.groups()[0].upper() if subtypeofmatch else None\\n\\n # find the shortest string matched from the end of the entity type header to the\\n # first occurence of a NO_ATTR string (when it occurs on a new line)\\n inner_str = re.search(\\\";(.*?)$\\\", raw_entity_str, re.DOTALL).groups()[0]\\n\\n attrs_str = min([inner_str.partition(\\\"\\\\r\\\\n \\\"+a)[0] for a in self.NO_ATTR])\\n attrs = []\\n for am in re.finditer(\\\"(\\\\S*?) : (.*?);\\\", attrs_str, re.DOTALL):\\n name, attr_type = [s.replace(\\\"\\\\r\\\\n\\\\t\\\",\\\"\\\") for s in am.groups()]\\n attrs.append((name, attr_type))\\n \\n entity[\\\"attributes\\\"] = attrs\\n entities[entity[\\\"name\\\"]] = entity\\n \\n\\n return entities\",\n \"def compile_class(self):\\n\\t\\t\\n\\t\\txml = '<class>\\\\n' + self.tokenizer.keyword() + self.tokenizer.identifier() + self.tokenizer.symbol()\\n\\n\\t\\tself.outfile.write(xml)\",\n \"def build_class_view(self, dotted_name):\\r\\n cls = get_obj(self.dsa, self.pkg, dotted_name)\\r\\n # XXX is this a safe check?\\r\\n try:\\r\\n sourcefile = inspect.getsourcefile(cls)\\r\\n except TypeError:\\r\\n sourcefile = None\\r\\n\\r\\n docstring = cls.__doc__\\r\\n if docstring:\\r\\n docstring = deindent(docstring)\\r\\n if not hasattr(cls, '__name__'):\\r\\n clsname = 'instance of %s' % (cls.__class__.__name__,)\\r\\n else:\\r\\n clsname = cls.__name__\\r\\n bases = self.build_bases(dotted_name)\\r\\n properties = self.build_properties(cls)\\r\\n methods = self.build_methods(dotted_name)\\r\\n\\r\\n if sourcefile is None:\\r\\n sourcelink = H.div('no source available')\\r\\n else:\\r\\n if sourcefile[-1] in ['o', 'c']:\\r\\n sourcefile = sourcefile[:-1]\\r\\n sourcelink = H.div(H.a('view source',\\r\\n href=self.linker.get_lazyhref(sourcefile,\\r\\n self.get_anchor(cls))))\\r\\n\\r\\n snippet = H.ClassDescription(\\r\\n # XXX bases HTML\\r\\n H.ClassDef(clsname, bases, docstring, sourcelink,\\r\\n properties, methods),\\r\\n )\\r\\n\\r\\n return snippet\",\n \"def get_code(self, parent, modname, fqname):\\n\\n if self.verbose:\\n print >> sys.stderr, '-'*78\\n print >> sys.stderr, \\\"Importing %s from the network ...\\\" % fqname\\n print >> sys.stderr, '-'*78\\n\\n\\n out = None\\n for baseurl in self.path:\\n\\n proto_url = '/'.join([baseurl] + fqname.split('.'))\\n\\n\\n # Is this a package?\\n # ==================\\n # If so, we want to look for __init__.py.\\n\\n is_package = self.download(proto_url + '/')\\n if is_package:\\n proto_url += '/__init__'\\n\\n\\n # Try to find some code.\\n # ======================\\n\\n for suffix in imp.get_suffixes():\\n url = proto_url + suffix[0]\\n fp = self.download(url)\\n if fp is not None:\\n\\n # Prepare elements for imputil.Importer.\\n # ======================================\\n\\n mod = imp.load_module(modname, fp, fp.name, suffix)\\n out = (is_package, mod, {})\\n break\\n\\n if out is not None:\\n break\\n\\n return out\",\n \"def createClassFile( p ):\\n create_modules( p[\\\"package\\\"] )\\n name = p[\\\"protocol\\\"][\\\"name\\\"]\\n name.lower()\\n path = os.path.join( *p[\\\"package\\\"].split( \\\".\\\" ) )\\n with open( \\\"./%s/%s.py\\\" % ( path, name ), \\\"w\\\" ) as f:\\n for i in p[\\\"imports\\\"]:\\n createClassFile( i )\\n\\n c = Klass( package=p[\\\"package\\\"], includes=p[\\\"imports\\\"], **p[\\\"protocol\\\"] )\\t\\n\\n f.write( c.generate() )\",\n \"def compile_class(self):\\r\\n self.tokenizer.advance() # ignore 'class' keyword\\r\\n self.class_name = self.tokenizer.identifier()\\r\\n self.tokenizer.advance()\\r\\n self.tokenizer.advance() # ignore '{' symbol\\r\\n while self.tokenizer.curtok < len(self.tokenizer.tokens) - 1:\\r\\n dec = self.tokenizer.key_word()\\r\\n if dec == \\\"field\\\" or dec == \\\"static\\\":\\r\\n self.compile_var_dec()\\r\\n else:\\r\\n self.compile_subroutine()\\r\\n self.tokenizer.advance()\",\n \"def makehxx(self, gen):\\n services = []\\n for serv in self.services:\\n service = \\\" %s %s(\\\" % (corba_rtn_type(serv.ret,gen.module.name),serv.name)\\n service = service+gen.makeArgs(serv)+\\\");\\\"\\n services.append(service)\\n\\n if self.addedmethods:\\n services.append(self.addedmethods)\\n servicesdef = \\\"\\\\n\\\".join(services)\\n\\n inheritedclass=self.inheritedclass\\n if self.inheritedclass:\\n inheritedclass= \\\" public virtual \\\" + self.inheritedclass + \\\",\\\"\\n\\n return hxxCompo.substitute(component=self.name, module=gen.module.name,\\n servicesdef=servicesdef, inheritedclass=inheritedclass,\\n compodefs=self.compodefs)\",\n \"def make_class(attributes, base_classes=()):\\r\\n \\\"*** YOUR CODE HERE ***\\\"\",\n \"def IIAGG(self):\\r\\n logger.info(\\\"IIAGG (Indirect Inheritance AGGregation)\\\")\\r\\n logger.info(\\\"Step1: Get all parent and child classes\\\")\\r\\n inh = self.get_node_by_name(\\\"inheritance\\\")\\r\\n logger.debug(\\\"inheritance: %s\\\" % inh)\\r\\n logger.info(\\\"Step2: Get all Aggregation relation classes\\\")\\r\\n agg = self.get_node_by_name(\\\"aggregation\\\")\\r\\n logger.debug(\\\"aggregation: %s\\\" % agg)\\r\\n return self.__IIAGG_helper(inh, agg)\",\n \"def create(self, the_type):\\n\\n # Get the list of code producing visitors. The hardwired list is\\n # based on the project argument. A different set of visitors can\\n # be assembled by project.\\n\\n project_visitor_list = self._buildVisitorList()\\n\\n # Instance the needed code snippet generator here.\\n\\n if the_type == \\\"initFiles\\\":\\n code_section_generator = InitFiles.InitFiles()\\n elif the_type == \\\"startSource\\\":\\n code_section_generator = StartSource.StartSource()\\n elif the_type == \\\"includes1\\\":\\n code_section_generator = Includes1.Includes1()\\n elif the_type == \\\"includes2\\\":\\n code_section_generator = Includes2.Includes2()\\n elif the_type == \\\"namespace\\\":\\n code_section_generator = Namespace.Namespace()\\n elif the_type == \\\"public\\\":\\n code_section_generator = Public.Public()\\n elif the_type == \\\"protected\\\":\\n code_section_generator = Protected.Protected()\\n elif the_type == \\\"private\\\":\\n code_section_generator = Private.Private()\\n elif the_type == \\\"finishSource\\\":\\n code_section_generator = FinishSource.FinishSource()\\n\\n elif the_type == \\\"DictStart\\\":\\n code_section_generator = DictStart.DictStart()\\n elif the_type == \\\"DictHeader\\\":\\n code_section_generator = DictHeader.DictHeader()\\n elif the_type == \\\"DictBody\\\":\\n code_section_generator = DictBody.DictBody()\\n\\n elif the_type == \\\"InstanceDictStart\\\":\\n code_section_generator = InstanceDictStart.InstanceDictStart()\\n elif the_type == \\\"InstanceDictHeader\\\":\\n code_section_generator = InstanceDictHeader.InstanceDictHeader()\\n elif the_type == \\\"InstanceDictBody\\\":\\n code_section_generator = InstanceDictBody.InstanceDictBody()\\n\\n elif the_type == \\\"HtmlStart\\\":\\n code_section_generator = HtmlStartPage.HtmlStartPage()\\n elif the_type == \\\"HtmlDoc\\\":\\n code_section_generator = HtmlDocPage.HtmlDocPage()\\n\\n elif the_type == \\\"MdStart\\\":\\n code_section_generator = MdStartPage.MdStartPage()\\n elif the_type == \\\"MdDoc\\\":\\n code_section_generator = MdDocPage.MdDocPage()\\n\\n else:\\n print(f\\\"GenFactory: unsupported code section ({the_type}).\\\")\\n return None\\n\\n self._addVisitor(code_section_generator, project_visitor_list)\\n\\n return code_section_generator\",\n \"def calculate_gen(source):\\r\\n\\r\\n with open(source, 'r') as thrift:\\r\\n lines = thrift.readlines()\\r\\n namespaces = {}\\r\\n types = defaultdict(set)\\r\\n for line in lines:\\r\\n match = NAMESPACE_PARSER.match(line)\\r\\n if match:\\r\\n lang = match.group(1)\\r\\n namespace = match.group(2)\\r\\n namespaces[lang] = namespace\\r\\n else:\\r\\n match = TYPE_PARSER.match(line)\\r\\n if match:\\r\\n typename = match.group(1)\\r\\n name = match.group(2)\\r\\n types[typename].add(name)\\r\\n\\r\\n genfiles = defaultdict(set)\\r\\n\\r\\n namespace = namespaces.get('py')\\r\\n if namespace:\\r\\n genfiles['py'].update(calculate_python_genfiles(namespace, types))\\r\\n\\r\\n namespace = namespaces.get('java')\\r\\n if namespace:\\r\\n genfiles['java'].update(calculate_java_genfiles(namespace, types))\\r\\n\\r\\n return types['service'], genfiles\",\n \"def generate(graph: mapry.Graph, py: mapry.Py) -> str:\\n blocks = [\\n mapry.py.generate.WARNING,\\n mapry.py.generate.docstring(\\\"parses JSONable objects.\\\"),\\n _imports(graph=graph, py=py)\\n ]\\n\\n if mapry.needs_type(a_type=graph, query=mapry.Duration):\\n blocks.append(_duration_from_string())\\n\\n nongraph_composites = [] # type: List[Union[mapry.Class, mapry.Embed]]\\n nongraph_composites.extend(graph.classes.values())\\n nongraph_composites.extend(graph.embeds.values())\\n\\n for class_or_embed in nongraph_composites:\\n blocks.append(_parse_composite(composite=class_or_embed, py=py))\\n\\n blocks.append(_parse_graph(graph=graph, py=py))\\n\\n return '\\\\n\\\\n\\\\n'.join(blocks) + '\\\\n'\",\n \"def generate_implements_graph(dataset, tokenizer, output_file=None):\\n if not output_file:\\n output_file = Paths.implements_graph_filename(dataset)\\n \\n # Maps classifier name to its containing code file\\n classifier_to_file_map = FileUtil.read_dict_from_json(Paths.classifier_to_file_map_filename(dataset))\\n implements_graph = {}\\n for file in FileUtil.get_files_in_directory(dataset.code_folder()):\\n code_file_representation = tokenizer.tokenize(file)\\n assert isinstance(code_file_representation, CodeFileRepresentation), \\\"use an appropiate tokenizer to generate a CodeFileRepresentation\\\"\\n super_classes = set()\\n for classifier in code_file_representation.classifiers:\\n for implemented_classifier in classifier.get_implemented_classifiers_plain_list():\\n if not implemented_classifier in classifier_to_file_map:\\n log.info(f\\\"SKIP: Unknown super classifier (probably not part of {dataset.name()}): {implemented_classifier}\\\")\\n continue\\n file_of_super_classifier = classifier_to_file_map[implemented_classifier]\\n super_classes.add(file_of_super_classifier)\\n # Add sub class relation from super class' perspective\\n if file_of_super_classifier in implements_graph:\\n implements_graph[file_of_super_classifier][1].add(code_file_representation.file_name)\\n else: \\n implements_graph[file_of_super_classifier] = (set(), {code_file_representation.file_name})\\n \\n if code_file_representation.file_name in implements_graph:\\n implements_graph[code_file_representation.file_name][0].update(super_classes)\\n else: \\n implements_graph[code_file_representation.file_name] = (super_classes, set())\\n \\n FileUtil.write_dict_to_json(output_file, implements_graph)\",\n \"def calc_plant_uml(self, optimise=False):\\n self.result = \\\"\\\"\\n\\n classnames = list(self.pmodel.classlist.keys())\\n for self.aclass in classnames:\\n self.classentry = self.pmodel.classlist[self.aclass]\\n\\n # Main class output\\n self.result += \\\"\\\\nclass %s {\\\\n\\\" % self.aclass\\n\\n for attrobj in self.classentry.attrs:\\n self.result += \\\" %s\\\\n\\\" % attrobj.attrname\\n\\n for adef in self.classentry.defs:\\n self.result += \\\" %s()\\\\n\\\" % adef\\n\\n # end class\\n self.result += \\\"}\\\\n\\\\n\\\"\\n\\n # class inheritance relationships\\n if self.classentry.classesinheritsfrom:\\n for parentclass in self.classentry.classesinheritsfrom:\\n self.result += \\\"%s <|- %s\\\\n\\\" % (parentclass, self.aclass)\\n\\n # aggregation relationships showing class dependency and composition relationships\\n for attrobj in self.classentry.attrs:\\n compositescreated = self._GetCompositeCreatedClassesFor(attrobj.attrname)\\n for c in compositescreated:\\n if \\\"many\\\" in attrobj.attrtype:\\n line = \\\"*-->\\\"\\n cardinality = \\\"*\\\"\\n else:\\n line = \\\"..>\\\"\\n cardinality = \\\"\\\"\\n if cardinality:\\n connector = '%s \\\"%s\\\"' % (line, cardinality)\\n else:\\n connector = line\\n self.result += \\\"%s %s %s : %s\\\\n\\\" % (self.aclass, connector, c, attrobj.attrname)\",\n \"def init_c_code(self):\\r\\n subd = dict(\\r\\n zip(self.fgraph.inputs,\\r\\n [\\\"%%(i%i)s\\\" % i for i in xrange(len(self.fgraph.inputs))])\\r\\n + zip(self.fgraph.outputs,\\r\\n [\\\"%%(o%i)s\\\" % i for i in xrange(len(self.fgraph.outputs))]))\\r\\n\\r\\n for orphan in self.fgraph.variables: # fgraph.orphans:\\r\\n if orphan.owner is None and orphan not in self.fgraph.inputs:\\r\\n if isinstance(orphan, Constant):\\r\\n subd[orphan] = orphan.type.c_literal(orphan.data)\\r\\n else:\\r\\n raise ValueError(\\r\\n \\\"All orphans in the fgraph to Composite must\\\"\\r\\n \\\" be Constant instances.\\\")\\r\\n\\r\\n _c_code = \\\"{\\\\n\\\"\\r\\n self.nodenames = [\\\"%(nodename)s_\\\" + ('subnode%i' % j)\\r\\n for j, n in enumerate(self.fgraph.toposort())]\\r\\n\\r\\n i = 0\\r\\n for j, node in enumerate(self.fgraph.toposort()):\\r\\n for output in node.outputs:\\r\\n if output not in subd:\\r\\n i += 1\\r\\n name = \\\"V%%(id)s_tmp%i\\\" % i\\r\\n subd[output] = name\\r\\n _c_code += \\\"%s %s;\\\\n\\\" % (\\r\\n output.type.dtype_specs()[1], name)\\r\\n s = node.op.c_code(node,\\r\\n self.nodenames[j],\\r\\n [subd[input] for input in node.inputs],\\r\\n [subd[output] for output in node.outputs],\\r\\n dict(fail=\\\"%(fail)s\\\",\\r\\n id=\\\"%%(id)s_%i\\\" % j))\\r\\n _c_code += s\\r\\n _c_code += \\\"\\\\n\\\"\\r\\n _c_code += \\\"}\\\\n\\\"\\r\\n self._c_code = _c_code\",\n \"def Subclass_finder(cls):\\n\\n subclasses = [] # Create a list to deposit subclasses\\n\\n for subclass in cls.__subclasses__():\\n subclasses.append(subclass) # Add founded subclass\\n subclasses.extend(Subclass_finder(subclass)) # Check if there is a subclass\\n # of a subclass.\\n\\n Output_types = [] # Create a list to deposit final strings\\n for i in range(len(subclasses)): \\n instance = subclasses[i]() # Create an instance for the \\n Output_types.append(instance.kind) # Add them to the output list\\n \\n return Output_types\",\n \"def getPythonWrapper(self):\\n\\n isMC = self.cfg_comp.isMC \\n\\n classes = \\\"\\\"\\n anclass = \\\"\\\"\\n anclass += \\\"from PhysicsTools.HeppyCore.framework.analyzer import Analyzer\\\\n\\\"\\n anclass += \\\"class EventAnalyzer(Analyzer):\\\\n\\\"\\n anclass += \\\" def __init__(self, cfg_ana, cfg_comp, looperName):\\\\n\\\"\\n anclass += \\\" super(EventAnalyzer, self).__init__(cfg_ana, cfg_comp, looperName)\\\\n\\\"\\n\\n anclass += \\\" def process(self, event):\\\\n\\\"\\n\\n for cname, coll in self.collections.items():\\n classes += coll.get_py_wrapper_class(isMC)\\n anclass += \\\" event.{0} = {0}.make_array(event)\\\\n\\\".format(coll.name)\\n\\n return classes + \\\"\\\\n\\\" + anclass\",\n \"def generate_inheritance_graph(dataset, tokenizer, output_file=None):\\n if not output_file:\\n output_file = Paths.inheritance_graph_filename(dataset)\\n \\n # Maps classifier name to its containing code file\\n classifier_to_file_map = FileUtil.read_dict_from_json(Paths.classifier_to_file_map_filename(dataset))\\n inheritance_graph = {}\\n for file in FileUtil.get_files_in_directory(dataset.code_folder()):\\n code_file_representation = tokenizer.tokenize(file)\\n assert isinstance(code_file_representation, CodeFileRepresentation), \\\"use an appropiate tokenizer to generate a CodeFileRepresentation\\\"\\n super_classes = set()\\n for classifier in code_file_representation.classifiers:\\n for extended_classifier in classifier.get_extended_classifiers_plain_list():\\n if not extended_classifier in classifier_to_file_map:\\n log.info(f\\\"SKIP: Unknown super classifier (probably not part of {dataset.name()}): {extended_classifier}\\\")\\n continue\\n file_of_super_class = classifier_to_file_map[extended_classifier]\\n super_classes.add(file_of_super_class)\\n # Add sub class relation from super class' perspective\\n if file_of_super_class in inheritance_graph:\\n inheritance_graph[file_of_super_class][1].add(code_file_representation.file_name)\\n else: \\n inheritance_graph[file_of_super_class] = (set(), {code_file_representation.file_name})\\n \\n if code_file_representation.file_name in inheritance_graph:\\n inheritance_graph[code_file_representation.file_name][0].update(super_classes)\\n else: \\n inheritance_graph[code_file_representation.file_name] = (super_classes, set())\\n \\n FileUtil.write_dict_to_json(output_file, inheritance_graph)\",\n \"def generate(code):\\n name, traits = parseCode(code)\\n return globals()[name](**traits)\",\n \"def main(udb_path, source_package, source_class, method_name, target_classes: list, *args, **kwargs):\\n target_package = source_package\\n source_method = method_name\\n\\n main_file = None\\n source_method_entity = None\\n is_static = False\\n propagation_files = []\\n propagation_classes = []\\n propagation_lines = []\\n children_classes = []\\n children_files = []\\n\\n # Initialize with understand\\n db = und.open(udb_path)\\n methods = db.ents(\\\"Java Method\\\")\\n for mth in methods:\\n if mth.longname() == source_package + \\\".\\\" + source_class + \\\".\\\" + source_method:\\n source_method_entity = mth\\n for child_ref in mth.parent().refs(\\\"Extendby\\\"):\\n child_ref = child_ref.ent()\\n if child_ref.simplename() in target_classes:\\n children_classes.append(child_ref.simplename())\\n children_files.append(child_ref.parent().longname())\\n # print(\\\"mainfile : \\\", mth.parent().parent().longname())\\n is_static = mth.kind().check(\\\"static\\\")\\n main_file = mth.parent().parent().longname()\\n for ref in mth.refs(\\\"Callby\\\"):\\n propagation_files.append(ref.ent().parent().parent().longname())\\n propagation_classes.append(ref.ent().parent().simplename())\\n propagation_lines.append(ref.line())\\n\\n # Check pre-condition\\n if not len(target_classes) == 1:\\n logger.error(f\\\"len(target_classes) is not 1.\\\")\\n db.close()\\n return False\\n\\n if not len(children_classes) == 1:\\n logger.error(f\\\"len(children_classes) is not 1.\\\")\\n db.close()\\n return False\\n\\n if not len(children_files) == 1:\\n logger.error(f\\\"len(children_files) is not 1.\\\")\\n db.close()\\n return False\\n\\n for mth in methods:\\n if mth.simplename() == source_method:\\n if mth.parent().simplename() in target_classes:\\n if mth.type() == source_method_entity.type():\\n if mth.kind() == source_method_entity.kind():\\n if mth.parameters() == source_method_entity.parameters():\\n logger.error(\\\"Duplicated method\\\")\\n db.close()\\n return False\\n\\n for ref in source_method_entity.refs(\\\"use, call\\\"):\\n ref_ent = ref.ent()\\n is_public = ref_ent.kind().check(\\\"public\\\")\\n if not is_public:\\n logger.error(\\\"Has internal dependencies.\\\")\\n db.close()\\n return False\\n\\n # get text\\n method_text = source_method_entity.contents()\\n\\n db.close()\\n\\n # Delete source method\\n stream = FileStream(main_file, encoding='utf8', errors='ignore')\\n lexer = JavaLexer(stream)\\n token_stream = CommonTokenStream(lexer)\\n parser = JavaParserLabeled(token_stream)\\n parser.getTokenStream()\\n parse_tree = parser.compilationUnit()\\n my_listener = DeleteSourceListener(common_token_stream=token_stream, source_method=source_method)\\n walker = ParseTreeWalker()\\n walker.walk(t=parse_tree, listener=my_listener)\\n # print(my_listener.token_stream_rewriter.getDefaultText())\\n with open(main_file, mode='w', encoding='utf-8', newline='') as f:\\n f.write(my_listener.token_stream_rewriter.getDefaultText())\\n\\n # Do the push down\\n for child_file, child_class in zip(children_files, children_classes):\\n stream = FileStream(child_file, encoding='utf8', errors='ignore')\\n lexer = JavaLexer(stream)\\n token_stream = CommonTokenStream(lexer)\\n parser = JavaParserLabeled(token_stream)\\n parser.getTokenStream()\\n parse_tree = parser.compilationUnit()\\n my_listener = PushDownMethodRefactoringListener(common_token_stream=token_stream,\\n source_class=child_class,\\n source_method_text=method_text)\\n walker = ParseTreeWalker()\\n walker.walk(t=parse_tree, listener=my_listener)\\n # print(my_listener.token_stream_rewriter.getDefaultText())\\n with open(child_file, mode='w', encoding='utf8', newline='') as f:\\n f.write(my_listener.token_stream_rewriter.getDefaultText())\\n\\n # Propagation\\n for file, _class, line in zip(propagation_files, propagation_classes, propagation_lines):\\n stream = FileStream(file, encoding='utf8', errors='ignore')\\n lexer = JavaLexer(stream)\\n token_stream = CommonTokenStream(lexer)\\n parser = JavaParserLabeled(token_stream)\\n parser.getTokenStream()\\n parse_tree = parser.compilationUnit()\\n if is_static:\\n my_listener = PropagationStaticListener(common_token_stream=token_stream, source_class=source_class,\\n child_class=children_classes[0], class_name=_class,\\n method_name=source_method,\\n ref_line=line, target_package=target_package)\\n else:\\n my_listener = PropagationNonStaticListener(common_token_stream=token_stream, source_class=source_class,\\n child_class=children_classes[0], class_name=_class,\\n method_name=source_method,\\n ref_line=line, target_package=target_package)\\n walker = ParseTreeWalker()\\n walker.walk(t=parse_tree, listener=my_listener)\\n # print(my_listener.token_stream_rewriter.getDefaultText())\\n with open(file, mode='w', encoding='utf8', errors='ignore', newline='') as f:\\n f.write(my_listener.token_stream_rewriter.getDefaultText())\\n\\n return True\",\n \"def generate(self):\\n try:\\n self._parse_groups()\\n self._parse_types()\\n self._parse_enums()\\n self._parse_features()\\n self._parse_extensions()\\n self._add_extra_enums()\\n self._parse_and_build_commands()\\n self._build_all_enums()\\n self._build_enum_groups()\\n self._generate_files()\\n except Exception as exception:\\n print('Generate failed: {}'.format(str(exception)))\\n raise\",\n \"def derive_class_hierarchy():\\n logger.info('Deriving class hierarchy ...')\\n data = statistics.get_json_data('classes')\\n\\n hierarchy = defaultdict(dict)\\n keys = ['i', 's', 'ai', 'as', 'sc', 'sb', 'r']\\n\\n for cid in data:\\n for key in keys:\\n if key in data[cid] and data[cid][key]:\\n hierarchy[cid][key] = data[cid][key]\\n\\n statistics.update_json_data('classes/hierarchy', hierarchy)\\n statistics.update_split_json_data('classes/hierarchy', hierarchy, 1000)\",\n \"def GenerateHierarchies(self,id_range):\\n classed = []\\n file_list = self.GetFileList(id_range)\\n if file_list:\\n for fl in file_list:\\n cls = self.GetClassesFromFile(fl)\\n if cls:\\n for c in cls:\\n self.classes.append(c)\\n\\n for c in self.classes:\\n if not self.Inherits(c):\\n self.base_cls.append(c)\\n self.classes.remove(c)\\n\\n for c in self.base_cls:\\n kids = self.FindChilds(c)\\n if c not in classed:\\n root = self.AppendItem(self.root,self.CleanName(c))\\n classed.append(c)\\n if kids:\\n for n in kids:\\n root2 = self.AppendItem(root,self.CleanName(n))\\n kids_kids = self.FindChilds(n)\\n i = 0\\n if kids_kids:\\n kids_len = len(kids_kids)\\n while kids_kids:\\n try:\\n kid = kids_kids[i]\\n except: pass\\n has_kid = self.FindChilds(kid)\\n if not has_kid and i == kids_len: break\\n i+=1\\n root3 = self.AppendItem(root2,self.CleanName(kid))\\n\\n\\n self.classes = []\",\n \"def TLBImpGenerator(\\r\\n target\\r\\n , source\\r\\n , env\\r\\n , for_program = 0\\r\\n , for_signature = 0\\r\\n ):\\r\\n\\r\\n src = source[0].children()\\r\\n\\r\\n assert len(src) >= 1, \\\"[.NET] TLBIMP: At least one source is needed. Check your declarations.\\\"\\r\\n\\r\\n cmdline = env['TLBIMP']\\r\\n cmdline += ' '\\r\\n cmdline += env['TLBIMPFLAGS']\\r\\n if env.get('namespace') != None:\\r\\n cmdline += ' /namespace:$namespace'\\r\\n if env.get('key_file') != None:\\r\\n cmdline += ' /keyfile:$key_file'\\r\\n cmdline += ' /out:' + target[0].abspath\\r\\n for refnode in source[1:]:\\r\\n for ref in refnode.children():\\r\\n cmdline += ' /reference:' + ref.abspath\\r\\n cmdline += ' ' + src[0].abspath\\r\\n\\r\\n return [cmdline]\",\n \"def parent_classes(self):\\n response = check_defined(self, inspect.stack()[0][3])\\n if not response:\\n return response\\n root_node = list(nx.topological_sort(self.se.full_class_only_graph))\\n # When a schema is not a tree with only one root node\\n # Set \\\"Thing\\\" as the root node by default\\n if 'http://schema.org/Thing' in root_node:\\n root_node = 'http://schema.org/Thing'\\n else:\\n root_node = root_node[0]\\n paths = nx.all_simple_paths(self.se.full_class_only_graph,\\n source=root_node,\\n target=self.uri)\\n paths = [_path[:-1] for _path in paths]\\n result = restructure_output(self,\\n paths,\\n inspect.stack()[0][3],\\n self.output_type)\\n return result\",\n \"def createInstanceSource(pcol, path, nr_robots, smallest_robot_id):\\n\\n # prevent alphabet related bugs by including e and f objects in alphabet\\n if (\\\"e\\\" not in pcol.A):\\n pcol.A.append(\\\"e\\\")\\n if (\\\"f\\\" not in pcol.A):\\n pcol.A.append(\\\"f\\\")\\n\\n with open(path + \\\".c\\\", \\\"w\\\") as fout:\\n fout.write(\\\"\\\"\\\"#include \\\"%s.h\\\"\\n\\n#ifdef NEEDING_WILDCARD_EXPANSION\\n #include \\\"wild_expand.h\\\"\\n#endif\\n\\n#ifdef PCOL_SIM\\\"\\\"\\\" % path.split(\\\"/\\\")[-1]) #only filename\\n\\n fout.write(\\\"\\\"\\\"\\\\n char* objectNames[] = {[NO_OBJECT] = \\\"no_object\\\", \\\"\\\"\\\")\\n for obj in pcol.A:\\n fout.write(\\\"\\\"\\\"[OBJECT_ID_%s] = \\\"%s\\\", \\\"\\\"\\\" % (obj.upper(), obj))\\n\\n fout.write(\\\"\\\"\\\"};\\n char* agentNames[] = {\\\"\\\"\\\")\\n for ag_name in pcol.B:\\n fout.write(\\\"\\\"\\\"[AGENT_%s] = \\\"%s\\\", \\\"\\\"\\\" % (ag_name.upper(), ag_name))\\n fout.write(\\\"\\\"\\\"};\\n#endif\\n\\n//the smallest kilo_uid from the swarm\\nconst uint16_t smallest_robot_uid = %d;\\n//the number of robots that make up the swarm\\nconst uint16_t nr_swarm_robots = %d;\\n\\nvoid lulu_init(Pcolony_t *pcol) {\\\"\\\"\\\" % (smallest_robot_id, nr_robots) )\\n\\n # call initPcolony()\\n fout.write(\\\"\\\"\\\"\\\\n //init Pcolony with alphabet size = %d, nr of agents = %d, capacity = %d\\n initPcolony(pcol, %d, %d, %d);\\\"\\\"\\\" % (len(pcol.A), len(pcol.B), pcol.n, len(pcol.A), len(pcol.B), pcol.n))\\n fout.write(\\\"\\\"\\\"\\\\n //Pcolony.alphabet = %s\\\"\\\"\\\" % pcol.A)\\n\\n # init environment\\n fout.write(\\\"\\\"\\\"\\\\n\\\\n //init environment\\\"\\\"\\\")\\n counter = 0;\\n for obj, nr in pcol.env.items():\\n #replace %id and * with $id and $ respectively\\n\\n fout.write(\\\"\\\"\\\"\\\\n pcol->env.items[%d].id = OBJECT_ID_%s;\\\"\\\"\\\" % (counter, obj.upper()))\\n fout.write(\\\"\\\"\\\"\\\\n pcol->env.items[%d].nr = %d;\\\\n\\\"\\\"\\\" % (counter, nr))\\n counter += 1\\n fout.write(\\\"\\\"\\\"\\\\n //end init environment\\\"\\\"\\\")\\n\\n fout.write(\\\"\\\"\\\"\\\\n\\\\n //init global pswarm environment\\\"\\\"\\\")\\n if (pcol.parentSwarm == None or len(pcol.parentSwarm.global_env) == 0):\\n fout.write(\\\"\\\"\\\"\\\\n pcol->pswarm.global_env.items[0].id = OBJECT_ID_E;\\\"\\\"\\\")\\n fout.write(\\\"\\\"\\\"\\\\n pcol->pswarm.global_env.items[0].nr = 1;\\\"\\\"\\\")\\n else:\\n counter = 0\\n for obj, nr in pcol.parentSwarm.global_env.items():\\n #replace %id and * with $id and $ respectively\\n\\n fout.write(\\\"\\\"\\\"\\\\n pcol->pswarm.global_env.items[%d].id = OBJECT_ID_%s;\\\"\\\"\\\" % (counter, obj.upper()))\\n fout.write(\\\"\\\"\\\"\\\\n pcol->pswarm.global_env.items[%d].nr = %d;\\\"\\\"\\\" % (counter, nr))\\n counter += 1\\n fout.write(\\\"\\\"\\\"\\\\n //end init global pswarm environment\\\"\\\"\\\")\\n\\n fout.write(\\\"\\\"\\\"\\\\n\\\\n //init INPUT global pswarm environment\\\"\\\"\\\")\\n if (pcol.parentSwarm == None or len(pcol.parentSwarm.in_global_env) == 0):\\n fout.write(\\\"\\\"\\\"\\\\n pcol->pswarm.in_global_env.items[0].id = OBJECT_ID_E;\\\"\\\"\\\")\\n fout.write(\\\"\\\"\\\"\\\\n pcol->pswarm.in_global_env.items[0].nr = 1;\\\"\\\"\\\")\\n else:\\n counter = 0\\n for obj, nr in pcol.parentSwarm.in_global_env.items():\\n #replace %id and * with $id and $ respectively\\n\\n fout.write(\\\"\\\"\\\"\\\\n pcol->pswarm.in_global_env.items[%d].id = OBJECT_ID_%s;\\\"\\\"\\\" % (counter, obj.upper()))\\n fout.write(\\\"\\\"\\\"\\\\n pcol->pswarm.in_global_env.items[%d].nr = %d;\\\"\\\"\\\" % (counter, nr))\\n counter += 1\\n fout.write(\\\"\\\"\\\"\\\\n //end init INPUT global pswarm environment\\\"\\\"\\\")\\n\\n fout.write(\\\"\\\"\\\"\\\\n\\\\n //init OUTPUT global pswarm environment\\\"\\\"\\\")\\n if (pcol.parentSwarm == None or len(pcol.parentSwarm.out_global_env) == 0):\\n fout.write(\\\"\\\"\\\"\\\\n pcol->pswarm.out_global_env.items[0].id = OBJECT_ID_E;\\\"\\\"\\\")\\n fout.write(\\\"\\\"\\\"\\\\n pcol->pswarm.out_global_env.items[0].nr = 1;\\\"\\\"\\\")\\n else:\\n counter = 0\\n for obj, nr in pcol.parentSwarm.out_global_env.items():\\n #replace %id and * with $id and $ respectively\\n\\n fout.write(\\\"\\\"\\\"\\\\n pcol->pswarm.out_global_env.items[%d].id = OBJECT_ID_%s;\\\"\\\"\\\" % (counter, obj.upper()))\\n fout.write(\\\"\\\"\\\"\\\\n pcol->pswarm.out_global_env.items[%d].nr = %d;\\\"\\\"\\\" % (counter, nr))\\n counter += 1\\n fout.write(\\\"\\\"\\\"\\\\n //end init OUTPUT global pswarm environment\\\"\\\"\\\")\\n\\n for ag_name in pcol.B:\\n fout.write(\\\"\\\"\\\"\\\\n\\\\n //init agent %s\\\"\\\"\\\" % ag_name)\\n #fout.write(\\\"\\\"\\\"\\\\n\\\\n initAgent(&pcol->agents[AGENT_%s], pcol, %d);\\\"\\\"\\\" % (ag_name.upper(), len(pcol.agents[ag_name].programs)))\\n fout.write(\\\"\\\"\\\"\\\\n\\\\n initAgent(&pcol->agents[AGENT_%s], pcol, %d);\\\"\\\"\\\" % (ag_name.upper(), getNrOfProgramsAfterExpansion(pcol.agents[ag_name], nr_robots- 1)))\\n\\n fout.write(\\\"\\\"\\\"\\\\n //init obj multiset\\\"\\\"\\\")\\n counter = 0;\\n for obj, nr in pcol.agents[ag_name].obj.items():\\n #replace %id and * with $id and $ respectively\\n\\n for i in range(nr):\\n fout.write(\\\"\\\"\\\"\\\\n pcol->agents[AGENT_%s].obj.items[%d] = OBJECT_ID_%s;\\\"\\\"\\\" % (ag_name.upper(), counter, obj.upper()))\\n counter += 1\\n\\n fout.write(\\\"\\\"\\\"\\\\n\\\\n //init programs\\\"\\\"\\\")\\n for prg_nr, prg in enumerate(pcol.agents[ag_name].programs):\\n fout.write(\\\"\\\"\\\"\\\\n\\\\n initProgram(&pcol->agents[AGENT_%s].programs[%d], %d);\\\"\\\"\\\" % (ag_name.upper(), prg_nr, getNrOfRulesWithoutRepetitions(prg)))\\n fout.write(\\\"\\\"\\\"\\\\n //init program %d: < %s >\\\"\\\"\\\" % (prg_nr, prg.print()))\\n\\n rule_index = 0\\n for rule_nr, rule in enumerate(prg):\\n # skip rules that contain identical operands and thus have no effect\\n if (rule.lhs == rule.rhs and rule.lhs == 'e' and rule.main_type != sim.RuleType.conditional):\\n continue\\n\\n fout.write(\\\"\\\"\\\"\\\\n //init rule %d: %s\\\"\\\"\\\" % (rule_nr, rule.print(toString=True)) )\\n if (rule.main_type != sim.RuleType.conditional):\\n fout.write(\\\"\\\"\\\"\\\\n initRule(&pcol->agents[AGENT_%s].programs[%d].rules[%d], RULE_TYPE_%s, OBJECT_ID_%s, OBJECT_ID_%s, NO_OBJECT, NO_OBJECT);\\\"\\\"\\\" % (ag_name.upper(), prg_nr, rule_index, rule.type.name.upper(), rule.lhs.upper(), rule.rhs.upper()))\\n else:\\n fout.write(\\\"\\\"\\\"\\\\n initRule(&pcol->agents[AGENT_%s].programs[%d].rules[%d], RULE_TYPE_CONDITIONAL_%s_%s, OBJECT_ID_%s, OBJECT_ID_%s, OBJECT_ID_%s, OBJECT_ID_%s);\\\"\\\"\\\" % (ag_name.upper(), prg_nr, rule_index, rule.type.name.upper(), rule.alt_type.name.upper(), rule.lhs.upper(), rule.rhs.upper(), rule.alt_lhs.upper(), rule.alt_rhs.upper()))\\n\\n #increase rule_index\\n rule_index += 1\\n fout.write(\\\"\\\"\\\"\\\\n //end init program %d\\n pcol->agents[AGENT_%s].init_program_nr++;\\\"\\\"\\\" % (prg_nr, ag_name.upper()))\\n fout.write(\\\"\\\"\\\"\\\\n //end init programs\\\"\\\"\\\")\\n\\n fout.write(\\\"\\\"\\\"\\\\n //end init agent %s\\\"\\\"\\\" % ag_name)\\n\\n fout.write(\\\"\\\"\\\"\\\\n}\\\"\\\"\\\")\\n fout.write(\\\"\\\"\\\"\\\\n\\\\nvoid lulu_destroy(Pcolony_t *pcol) {\\n //destroys all of the subcomponents\\n destroyPcolony(pcol);\\n}\\\"\\\"\\\")\\n fout.write(\\\"\\\"\\\"\\\\n\\n#ifdef NEEDING_WILDCARD_EXPANSION\\nuint16_t expand_pcolony(Pcolony_t *pcol, uint16_t my_id) {\\n //used for a cleaner iteration through the P colony\\n //instead of using agents[i] all of the time, we use just agent\\n Agent_t *agent;\\n\\\"\\\"\\\")\\n\\n fout.write(\\\"\\\"\\\"\\\\n uint8_t obj_with_id[] = {\\\"\\\"\\\")\\n obj_with_id_size = 0\\n for obj in pcol.A:\\n if (\\\"_W_ID\\\" in obj):\\n fout.write(\\\"OBJECT_ID_%s, \\\" % obj.upper())\\n obj_with_id_size += 1\\n fout.write(\\\"\\\"\\\"};\\n uint8_t obj_with_id_size = %d;\\\"\\\"\\\" % (obj_with_id_size))\\n\\n fout.write(\\\"\\\"\\\"\\\\n uint8_t obj_with_any[] = {\\\"\\\"\\\")\\n obj_with_any_size = 0\\n is_obj_with_any_followed_by_id = []\\n for i, obj in enumerate(pcol.A):\\n if (obj.endswith(\\\"_W_ALL\\\")):\\n fout.write(\\\"OBJECT_ID_%s, \\\" % obj.upper())\\n # if we are at least 2 objects before the end of the list\\n if (i < len(pcol.A) - 1):\\n # check if this _$ wildcarded object is followed by a _$id object\\n if (\\\"_W_ID\\\" in pcol.A[i+1]):\\n is_obj_with_any_followed_by_id.append(1)\\n else:\\n is_obj_with_any_followed_by_id.append(0)\\n else:\\n # this (_$) object is the last one in the list\\n is_obj_with_any_followed_by_id.append(0)\\n obj_with_any_size += 1\\n fout.write(\\\"\\\"\\\"};\\n uint8_t obj_with_any_size = %d;\\n uint8_t is_obj_with_any_followed_by_id[] = {%s};\\\"\\\"\\\" % (obj_with_any_size,\\n str(is_obj_with_any_followed_by_id).replace(\\\"[\\\", \\\"\\\").replace(\\\"]\\\", \\\"\\\")))\\n\\n fout.write(\\\"\\\"\\\"\\\\n\\\\n uint16_t my_symbolic_id = my_id - smallest_robot_uid;\\n\\n //replace W_ID wildcarded objects with the object corresponding to the symbolic id\\n // e.g.: B_W_ID -> B_0 for my_symbolic_id = 0\\n replacePcolonyWildID(pcol, obj_with_id, obj_with_id_size, my_symbolic_id);\\n\\n //expand each obj_with_any[] element into nr_swarm_robots objects except my_symbolic id.\\n // e.g.: B_W_ALL -> B_0, B_2 for nr_swarm_robots = 3 and my_symbolic_id = 1\\n expandPcolonyWildAny(pcol, obj_with_any, is_obj_with_any_followed_by_id, obj_with_any_size, my_symbolic_id, nr_swarm_robots);\\n\\n return my_symbolic_id;\\n}\\n#endif\\\"\\\"\\\")\",\n \"def to_xml(self):\\n xml_strings = ['<code_object name=\\\"%s\\\">' % self.name]\\n xml_strings.append(' <type value=\\\"%s\\\" />' % self.object_type)\\n xml_strings.append(' <source>')\\n for source_line in self.source:\\n xml_strings.append(source_line[1])\\n xml_strings.append(' </source>')\\n xml_strings.append('</code_object>')\\n return \\\"\\\".join(xml_strings)\",\n \"def generateDerivedData():\\n # Empty all derivied tables, in reverse order that they are populated.\\n PartOfPerspectives.deleteAll()\\n PartOfs.deleteAll()\\n RelationshipsTransitive.deleteAll()\\n\\n # Derive the transitive closure of the relationship graph\\n RelationshipsTransitive.regenerateTable()\\n\\n # Derive the quick tree display\\n PartOfs.regenerateTable()\\n\\n # Derive the part of perspective tree for each perspective\\n PartOfPerspectives.regenerateTable()\\n\\n return\",\n \"def gen_model(children, tree_structure):\\n referenced = False\\n extended = False\\n for child in children:\\n #print child.arg\\n node = dict()\\n extended = False\\n if hasattr(child, 'substmts'):\\n for attribute in child.substmts:\\n # process the 'type' attribute:\\n # Currently integer, enumeration and string are supported.\\n if attribute.keyword == 'type':\\n if len(attribute.arg.split(':'))>1:\\n attribute.arg = attribute.arg.split(':')[-1]\\n # Firstly, it is checked if the attribute type has been previously define in typedefs.\\n if attribute.arg in TYPEDEFS:\\n if TYPEDEFS[attribute.arg]['type'][:3] == 'int':\\n node['type'] = 'integer'\\n node['format'] = TYPEDEFS[attribute.arg]['format']\\n elif TYPEDEFS[attribute.arg]['type'] == 'enumeration':\\n node['type'] = 'string'\\n node['enum'] = [e\\n for e in TYPEDEFS[attribute.arg]['enum']]\\n # map all other types to string\\n else:\\n node['type'] = 'string'\\n elif attribute.arg[:3] == 'int':\\n node['type'] = 'integer'\\n node['format'] = attribute.arg\\n elif attribute.arg == 'decimal64':\\n node['type'] = 'number'\\n node['format'] = 'double'\\n elif attribute.arg == 'boolean':\\n node['type'] = attribute.arg\\n elif attribute.arg == 'enumeration':\\n node['type'] = 'string'\\n node['enum'] = [e[0]\\n for e in attribute.i_type_spec.enums]\\n # map all other types to string\\n else:\\n node['type'] = 'string'\\n elif attribute.keyword == 'mandatory':\\n parent_model = to_upper_camelcase(child.parent.arg)\\n if parent_model not in PARENT_MODELS.keys():\\n PARENT_MODELS[parent_model] = {'models':[],'discriminator':to_lower_camelcase(child.arg)}\\n # Process the reference to another model.\\n # We differentiate between single and array references.\\n elif attribute.keyword == 'uses':\\n if len(attribute.arg.split(':'))>1:\\n attribute.arg = attribute.arg.split(':')[-1]\\n\\n ref = to_upper_camelcase(attribute.arg)\\n ref = '#/definitions/' + ref\\n if str(child.keyword) == 'list':\\n node['items'] = {'$ref': ref}\\n node['type'] = 'array'\\n for attribute in child.substmts:\\n if attribute.keyword == 'key':\\n listkey = to_lower_camelcase(attribute.arg)\\n if listkey:\\n node['x-key'] = listkey\\n referenced = True\\n elif str(child.keyword) == 'grouping':\\n ref = to_upper_camelcase(attribute.arg)\\n if ref in tree_structure:\\n PARENT_MODELS[ref]['models'].append(child.arg)\\n list_properties = [item for item in tree_structure[ref]['properties']]\\n ref = '#/definitions/' + ref\\n node['allOf'] = []\\n node['allOf'].append({'$ref': ref})\\n index = 0\\n for i in range(0, len(child.i_children)):\\n #print len(child.i_children)\\n if to_lower_camelcase(child.i_children[index].arg) in list_properties:\\n del child.i_children[index]\\n else:\\n index+=1\\n extended = True\\n else:\\n pending_models.append(child)\\n else:\\n node['$ref'] = ref\\n referenced = True\\n\\n # When a node contains a referenced model as an attribute the algorithm\\n # does not go deeper into the sub-tree of the referenced model.\\n if not referenced :\\n if not extended:\\n node = gen_model_node(child, node)\\n else:\\n node_ext = dict()\\n node_ext = gen_model_node(child, node_ext)\\n node['allOf'].append( node_ext)\\n extended = False\\n\\n # Leaf-lists need to create arrays.\\n # Copy the 'node' content to 'items' and change the reference\\n if child.keyword == 'leaf-list':\\n ll_node = {'type': 'array', 'items': node}\\n node = ll_node\\n # Groupings are class names and upper camelcase.\\n # All the others are variables and lower camelcase.\\n if child.keyword == 'grouping':\\n tree_structure[to_upper_camelcase(child.arg)] = node\\n else:\\n tree_structure[to_lower_camelcase(child.arg)] = node\\n # TODO: do we really need this return value? We are working on the\\n # reference anyhow.\\n return tree_structure\",\n \"def circuit_to_verilog(c, seq_types=None):\\n inputs = []\\n outputs = []\\n insts = []\\n wires = []\\n defs = set()\\n\\n if seq_types is None:\\n seq_types = default_seq_types\\n\\n def sanitize_name(n):\\n if n.startswith(\\\"\\\\\\\\\\\"):\\n return f\\\"{n} \\\"\\n return n\\n\\n def sanitize_instance(n):\\n if n.startswith(\\\"\\\\\\\\\\\"):\\n n_gate = n.replace(\\\"\\\\\\\\\\\", \\\"\\\")\\n return f\\\"\\\\\\\\g_{n_gate}\\\"\\n else:\\n return f\\\"g_{n}\\\"\\n\\n for n in c.nodes():\\n if c.type(n) in [\\\"xor\\\", \\\"xnor\\\", \\\"buf\\\", \\\"not\\\", \\\"nor\\\", \\\"or\\\", \\\"and\\\", \\\"nand\\\"]:\\n fanin = \\\", \\\".join(sanitize_name(p) for p in c.fanin(n))\\n insts.append(\\n f\\\"{c.type(n)} {sanitize_instance(n)} \\\" f\\\"({sanitize_name(n)}, {fanin})\\\"\\n )\\n if not c.output(n):\\n wires.append(n)\\n elif c.type(n) in [\\\"0\\\", \\\"1\\\"]:\\n insts.append(\\n f\\\"assign {sanitize_name(n)} = 1'b{c.type(n)}\\\"\\n )\\n elif c.type(n) in [\\\"input\\\"]:\\n inputs.append(n)\\n elif c.type(n) in [\\\"ff\\\", \\\"lat\\\"]:\\n if not c.output(n):\\n wires.append(n)\\n\\n # get template\\n for s in seq_types:\\n if s.seq_type == c.type(n):\\n seq = s\\n defs.add(s.code_def)\\n break\\n\\n # connect\\n io = []\\n if c.d(n):\\n d = sanitize_name(c.d(n))\\n io.append(f\\\".{seq.io['d']}({d})\\\")\\n if c.r(n):\\n r = sanitize_name(c.r(n))\\n io.append(f\\\".{seq.io['r']}({r})\\\")\\n if c.s(n):\\n s = sanitize_name(c.s(n))\\n io.append(f\\\".{seq.io['s']}({s})\\\")\\n if c.clk(n):\\n clk = sanitize_name(c.clk(n))\\n io.append(f\\\".{seq.io['clk']}({clk})\\\")\\n io.append(f\\\".{seq.io['q']}({sanitize_name(n)})\\\")\\n insts.append(f\\\"{seq.name} {sanitize_instance(n)} ({', '.join(io)})\\\")\\n\\n else:\\n print(f\\\"unknown gate type: {c.type(n)}\\\")\\n return\\n\\n if c.output(n):\\n outputs.append(n)\\n\\n verilog = f\\\"module {c.name} (\\\"\\n verilog += \\\", \\\".join(sanitize_name(i) for i in inputs + outputs)\\n verilog += \\\");\\\\n\\\"\\n verilog += \\\"\\\".join(f\\\" input {sanitize_name(inp)};\\\\n\\\" for inp in inputs)\\n verilog += \\\"\\\".join(f\\\" output {sanitize_name(out)};\\\\n\\\" for out in outputs)\\n verilog += \\\"\\\\n\\\"\\n verilog += \\\"\\\".join(f\\\" wire {sanitize_name(wire)};\\\\n\\\" for wire in wires)\\n verilog += \\\"\\\\n\\\"\\n verilog += \\\"\\\".join(f\\\" {inst};\\\\n\\\" for inst in insts)\\n verilog += \\\"endmodule\\\\n\\\"\\n verilog += \\\"\\\\n\\\"\\n verilog += \\\"\\\\n\\\".join(defs)\\n\\n return verilog\",\n \"def generate_from(self, module):\\n if module in self.done:\\n return\\n self.done.add(module)\\n subpkg = util.camelize(module.arg)\\n if self.ctx.rootpkg:\\n fullpkg = '.'.join([self.ctx.rootpkg, subpkg])\\n else:\\n fullpkg = subpkg\\n d = os.sep.join(self.d + [subpkg])\\n if not self.ctx.opts.no_classes:\\n # Generate Java classes\\n src = ('module \\\"' + module.arg + '\\\", revision: \\\"' +\\n putil.get_latest_revision(module) + '\\\".')\\n generator = ClassGenerator(module,\\n path=os.sep.join([self.ctx.opts.directory, subpkg]),\\n package=fullpkg, src=src, ctx=self.ctx)\\n generator.generate()\\n\\n if not self.ctx.opts.no_schema:\\n # Generate external schema\\n schema_nodes = ['<schema>']\\n stmts = util.search(module, context.node_stmts)\\n module_root = SchemaNode(self.ctx, module, '/')\\n schema_nodes.extend(module_root.as_list())\\n if self.ctx.opts.verbose:\\n print('Generating schema node \\\"/\\\"...')\\n schema_generator = SchemaGenerator(stmts, '/', self.ctx, fullpkg)\\n schema_nodes.extend(schema_generator.schema_nodes())\\n for i in range(1, len(schema_nodes)):\\n # Indent all but the first and last line\\n if schema_nodes[i] in ('<node>', '</node>'):\\n schema_nodes[i] = ' ' * 4 + schema_nodes[i]\\n else:\\n schema_nodes[i] = ' ' * 8 + schema_nodes[i]\\n schema_nodes.append('</schema>')\\n\\n name = util.normalize(util.search_one(module, 'prefix').arg)\\n\\n # Replace schema files store path\\n s = d\\n if self.ctx.opts.classpath_schema_loading:\\n s = self.ctx.opts.classpath_schema_loading\\n\\n util.write_file(s, name + '.xml', '\\\\n'.join(schema_nodes), self.ctx)\\n print(\\\"- Visiting module '\\\" + name + \\\"'\\\")\\n\\n if not self.ctx.opts.no_pkginfo:\\n # Generate package-info.java for javadoc\\n pkginfo_generator = PackageInfoGenerator(d, module, self.ctx)\\n pkginfo_generator.generate_package_info()\\n\\n if self.ctx.opts.debug or self.ctx.opts.verbose:\\n print('pkg ' + fullpkg + ' generated')\",\n \"def annotation_to_python(name, args, type_, template, sctypes):\\n tab = ' ' * TABSIZE\\n tokens = name.split(' ')\\n pyname = ''.join([x.title() for x in tokens])\\n cls = 'class {}({}):\\\\n'.format(pyname, type_.title())\\n cls += '{}_trigedit_name = \\\"{}\\\"\\\\n'.format(tab, name)\\n # pyargs = [type_to_sc_type(x['type']) for x in args]\\n qparams = [x['type'] for x in args if x['is_quoted']]\\n quoted_fields = '[\\\"{}\\\"]'.format(', '.join(qparams))\\n if not quoted_fields:\\n quoted_fields = ''\\n cls += '{}_quoted_fields = frozenset({})\\\\n\\\\n'.format(tab, quoted_fields)\\n # figure out the argument types\\n imports = []\\n for arg in args:\\n param = arg['type']\\n default = arg['default']\\n if param in sctypes:\\n ptype = type_to_sc_type(param, prefix='sc')\\n imports.append(ptype)\\n else:\\n if re.search('^[0-9]+$', default):\\n ptype = 'int'\\n else:\\n ptype = 'str'\\n arg['pytype'] = ptype\\n if len(args) > 0:\\n typed_params = ', '.join(['{}: {}'.format(x['type'], x['pytype']) for x in args])\\n cls += '{}def __init__(self, {}):\\\\n'.format(tab, typed_params)\\n else:\\n cls += '{}def __init__(self):\\\\n'.format(tab)\\n joiner = '\\\\n{}{}'.format(tab, tab)\\n fields = joiner.join(['self.{} = {}'.format(x['type'], x['type']) for x in args])\\n if len(args) > 0:\\n cls += '{}{}super().__init__()\\\\n{}{}{}'.format(tab, tab, tab, tab, fields)\\n else:\\n cls += '{}{}super().__init__()'.format(tab, tab)\\n return cls, imports\",\n \"def parse_main(self):\\n self.decompiler = self.createDecompiler(self.compilerEnv)\\n self.nf = IRFactory(self)\\n self.currentScriptOrFn = self.nf.createScript()\\n sourceStartOffset = self.decompiler.getCurrentOffset();\\n self.encodedSource = None;\\n self.decompiler.addToken(Token.SCRIPT);\\n \\n self.currentFlaggedToken = Token.EOF;\\n self.syntaxErrorCount = 0;\\n\\n baseLineno = self.ts.getLineno(); #// line number where source starts\\n\\n #/* so we have something to add nodes to until\\n # * we've collected all the source */\\n pn = self.nf.createLeaf(Token.BLOCK);\\n try:\\n while(True):\\n tt = self.peekToken()\\n if (tt <= Token.EOF):\\n break\\n n = None\\n \\n if tt == Token.FUNCTION:\\n self.consumeToken()\\n try: \\n n = self.function( \\\\\\n (FunctionNode.FUNCTION_EXPRESSION,\\\\\\n FunctionNode.FUNCTION_STATEMENT)[self.calledByCompileFunction])\\n except ParserException:\\n raise NotImplementedError()# should this have to raise?\\n break;\\n #raise NotImplementedError <- I think this is now implemented - TW\\n \\n else:\\n n = self.statement()\\n \\n self.nf.addChildToBack(pn, n)\\n \\n \\n except RuntimeError:\\n # Was StackOverflowError\\n raise\\n # TODO: exception handling\\n \\n if (self.syntaxErrorCount != 0) :\\n msg = str(self.syntaxErrorCount)\\n #msg = ScriptRuntime.getMessage1(\\\"msg.got.syntax.errors\\\", msg);\\n #throw errorReporter.runtimeError(msg, sourceURI, baseLineno,\\n # null, 0);\\n\\n self.currentScriptOrFn.setSourceName(self.sourceURI);\\n self.currentScriptOrFn.setBaseLineno(baseLineno);\\n self.currentScriptOrFn.setEndLineno(self.ts.getLineno());\\n\\n sourceEndOffset = self.decompiler.getCurrentOffset();\\n self.currentScriptOrFn.setEncodedSourceBounds(sourceStartOffset,\\n sourceEndOffset);\\n\\n self.nf.initScript(self.currentScriptOrFn, pn);\\n\\n if (self.compilerEnv.isGeneratingSource()):\\n self.encodedSource = self.decompiler.getEncodedSource();\\n \\n del self.decompiler# comment was //\\\"It helps GC\\\" \\n # - can't do any harm on CPython either\\n\\n return self.currentScriptOrFn;\",\n \"def generate_code(self, parts: list):\\n for i in range(len(parts)):\\n\\n if not self._involves_this_party(parts[i][0]):\\n # not our data, skip job\\n continue\\n\\n if parts[i][1] == \\\"python\\\":\\n cg = PythonCodeGen(\\n self.config,\\n parts[i][0],\\n f\\\"{self.config.system_configs['CODEGEN'].workflow_name}-python-job-{i}\\\"\\n )\\n cg.generate()\\n elif parts[i][1] == \\\"jiff\\\":\\n cg = JiffCodeGen(\\n self.config,\\n parts[i][0],\\n f\\\"{self.config.system_configs['CODEGEN'].workflow_name}-jiff-job-{i}\\\"\\n )\\n cg.generate()\\n else:\\n raise Exception(f\\\"Unrecognized backend from partition: {parts[i][1]}.\\\")\",\n \"def instantiate_classes(self, node):\\n clslist = []\\n for cls in node.classes:\\n if cls.wrap_as == \\\"struct\\\":\\n clslist.append(cls)\\n options = cls.options\\n if cls.wrap.python and options.PY_struct_arg == \\\"class\\\":\\n self.add_struct_ctor(cls)\\n self.process_class(node, cls)\\n elif cls.template_arguments:\\n orig_typemap = cls.typemap\\n if orig_typemap.cxx_instantiation is None:\\n orig_typemap.cxx_instantiation = {}\\n # Replace class with new class for each template instantiation.\\n # targs -> ast.TemplateArgument\\n for i, targs in enumerate(cls.template_arguments):\\n newcls = cls.clone()\\n clslist.append(newcls)\\n\\n # If single template argument, use its name; else sequence.\\n # XXX - maybe change to names\\n # i.e. _int_double However <std::string,int> is a problem.\\n if targs.fmtdict and 'template_suffix' in targs.fmtdict:\\n class_suffix = targs.fmtdict['template_suffix']\\n elif len(targs.asts) == 1:\\n ntypemap = targs.asts[0].typemap\\n if ntypemap.template_suffix:\\n class_suffix = ntypemap.template_suffix\\n else:\\n class_suffix = \\\"_\\\" + ntypemap.flat_name\\n else:\\n class_suffix = \\\"_\\\" + str(i)\\n\\n # Update name of class.\\n # name_api - vector_0 or vector_int (Fortran and C names)\\n # name_instantiation - vector<int>\\n if targs.fmtdict and \\\"cxx_class\\\" in targs.fmtdict:\\n newcls.name_api = targs.fmtdict[\\\"cxx_class\\\"]\\n else:\\n newcls.name_api = cls.name + class_suffix\\n newcls.name_instantiation = cls.name + targs.instantiation\\n newcls.scope_file[-1] += class_suffix\\n\\n if targs.fmtdict:\\n newcls.user_fmt.update(targs.fmtdict)\\n if targs.options:\\n newcls.options.update(targs.options)\\n \\n # Remove defaulted attributes then reset with current values.\\n newcls.delete_format_templates()\\n newcls.default_format()\\n\\n newcls.typemap = typemap.create_class_typemap(newcls)\\n if targs.instantiation in orig_typemap.cxx_instantiation:\\n print(\\\"instantiate_classes: {} already in \\\"\\n \\\"typemap.cxx_instantiation\\\".format(targs.instantiation))\\n orig_typemap.cxx_instantiation[targs.instantiation] = newcls.typemap\\n\\n self.template_typedef(newcls, targs)\\n\\n self.push_instantiate_scope(newcls, targs)\\n self.process_class(newcls, newcls)\\n self.pop_instantiate_scope()\\n else:\\n clslist.append(cls)\\n self.process_class(cls, cls)\\n\\n node.classes = clslist\",\n \"def genlangs(self):\\r\\n raise NotImplementedError\",\n \"def logic_program_form(self):\\n global superclasses\\n global instances\\n \\n s = ''\\n for x in self.new_sorts:\\n s = s + 'dom(' + x + ').\\\\nis_a(' + x + ', nodes).\\\\n'\\n sups = []\\n for y in self.supersorts:\\n s = s + 'link(' + x + ', ' + y + ').\\\\n\\\\n'\\n sups.append(y)\\n for z in superclasses[y]:\\n sups.append(z)\\n superclasses[x] = sups\\n instances[x] = set()\\n return s\",\n \"def compile_scad(object):\\n\\t\\n\\t# Regardless of the type of seleectors used, select all parts that are \\\"truthy\\\"\\n\\tselection = Object.compose(lambda x: bool(x), object).get_selection(True)\\n\\t\\n\\tif selection.inverted:\\n\\t\\traise Exception('The top-level node is inverted.')\\n\\t\\n\\tif selection.void:\\n\\t\\traise Exception('The top-level node is void.')\\n\\t\\n\\troot_node = selection.node\\n\\tnodes_set = set() # All nodes in the project\\n\\tnodes_list = [] # All nodes ordered by their appearence. Nodes that depend on other nodes come before their dependees in this list.\\n\\treused_nodes = set() # Nodes that are referenced by other nodes more than once.\\n\\t\\n\\tdef walk_nodes(node):\\n\\t\\tif node in nodes_set:\\n\\t\\t\\treused_nodes.add(node)\\n\\t\\telse:\\n\\t\\t\\tnodes_set.add(node)\\n\\t\\t\\t\\n\\t\\t\\tfor i in node.child_nodes:\\n\\t\\t\\t\\twalk_nodes(i)\\n\\t\\t\\t\\n\\t\\t\\tnodes_list.append(node)\\n\\t\\n\\twalk_nodes(root_node)\\n\\t\\n\\tnode_replacements = { } # by actual node for all noces\\n\\tmodules = [] # Modules for all nodes that are referenced more than once.\\n\\t\\n\\t# Iterate in serversed order so that nodes will be written to the file before their dependees.\\n\\tfor i in reversed(nodes_list):\\n\\t\\tif i in reused_nodes:\\n\\t\\t\\tmodule = _Module('node_{}'.format(len(modules) + 1), i)\\n\\t\\t\\t\\n\\t\\t\\tmodules.append(module)\\n\\t\\t\\treplacement_node = module.reference\\n\\t\\telse:\\n\\t\\t\\treplacement_node = i\\n\\t\\t\\n\\t\\tnode_replacements[i] = replacement_node\\n\\t\\n\\tyield from root_node.iter_lines(node_replacements)\\n\\t\\n\\tfor i in modules:\\n\\t\\tyield '' # An empty line before each module definition\\n\\t\\tyield from i.iter_lines(node_replacements)\",\n \"def get_class_definition(self, file, i):\\n\\n # Run super definition\\n definition = super().get_class_definition(file, i)\\n\\n # Get docstring from definition\\n doc_str = self.get_doc_str(file, i)\\n\\n # Dump unwanted portions\\n definition = definition.split(\\\":\\\", 1)[0]\\n\\n # Define storage lists\\n classes = []\\n interfaces = []\\n super_list = [classes, interfaces]\\n\\n # Check if superclass or interfaces specified\\n if definition.find(\\\"(\\\") != -1:\\n\\n # Extract class name and superclasses from class definition\\n class_name, super_ = definition.split(\\\"(\\\")\\n super_ = super_.split(\\\")\\\", 1)[0]\\n\\n # Store all superclasses and interfaces to list\\n super_split = [part.strip() for part in super_.split(\\\",\\\")]\\n for super_ in super_split:\\n\\n # Set default to super class\\n index = 0\\n\\n # Get superclass or interface name start in docstring\\n for i, line in enumerate(doc_str):\\n loc = line.find(super_)\\n\\n # Check if name found in docstring\\n if loc != -1:\\n\\n # Get location of specification\\n spec_loc = loc + len(super_) + len(\\\": \\\")\\n\\n # Check if interface is specified\\n intr_str = \\\"interface\\\"\\n if line[spec_loc: spec_loc + len(intr_str)] == intr_str:\\n # Change specification to interface\\n index = 1\\n\\n # Add superclass or interface name to appropriate list\\n super_list[index] += [super_]\\n\\n else:\\n\\n # If no superclasses specified, extract only class name\\n class_name = definition\\n\\n # Strip whitespace\\n class_name = class_name.strip()\\n\\n # Define access modifier\\n is_private = class_name.startswith(\\\"__\\\") and class_name.count(\\\"__\\\") < 2\\n access_modifier = \\\"private\\\" if is_private else \\\"public\\\"\\n\\n # Create start and end for class call\\n start = []\\n end = []\\n\\n # Return all variables of class definition\\n return access_modifier, class_name, classes, interfaces, start, end\",\n \"def CreateGeneModels(genes_cmpt, transcripts_cmpt, exons_cmpt, utr3_cmpt, utr5_cmpt, cds_cmpt):\\n gene_counter, gene_models = 1, []\\n for gene_entry in genes_cmpt: ## Figure out the genes and transcripts associated feature \\n if gene_entry in transcripts_cmpt:\\n gene=init_gene() \\n gene['id']=gene_counter\\n gene['name']=gene_entry[1]\\n gene['chr']=genes_cmpt[gene_entry]['chr']\\n gene['source']=genes_cmpt[gene_entry]['source']\\n gene['start']=genes_cmpt[gene_entry]['start']\\n gene['stop']=genes_cmpt[gene_entry]['stop']\\n gene['strand']=genes_cmpt[gene_entry]['strand']\\n if not gene['strand'] in ['+', '-']:\\n gene['strand']='.' # Strand info not known replaced with a dot symbol instead of None, ?, . etc.\\n if len(transcripts_cmpt[gene_entry])>1:\\n gene['is_alt_spliced'] = 1\\n gene['is_alt'] = 1\\n\\t gtype=[]\\n for tids in transcripts_cmpt[gene_entry]: ## transcript section related tags \\n gene['transcripts'].append(tids['ID'])\\n\\t\\tgtype.append(tids['type'])\\n exon_cod, utr5_cod, utr3_cod, cds_cod = [], [], [], []\\n if (gene['chr'], tids['ID']) in exons_cmpt:\\n exon_cod = [[feat_exon['start'], feat_exon['stop']] for feat_exon in exons_cmpt[(gene['chr'], tids['ID'])]]\\n if (gene['chr'], tids['ID']) in utr5_cmpt:\\n utr5_cod = [[feat_utr5['start'], feat_utr5['stop']] for feat_utr5 in utr5_cmpt[(gene['chr'], tids['ID'])]]\\n if (gene['chr'], tids['ID']) in utr3_cmpt:\\n utr3_cod = [[feat_utr3['start'], feat_utr3['stop']] for feat_utr3 in utr3_cmpt[(gene['chr'], tids['ID'])]]\\n if (gene['chr'], tids['ID']) in cds_cmpt:\\n cds_cod = [[feat_cds['start'], feat_cds['stop']] for feat_cds in cds_cmpt[(gene['chr'], tids['ID'])]]\\n if len(exon_cod) == 0: ## build exon coordinates from UTR3, UTR5 and CDS\\n if cds_cod != []:\\n exon_cod=createExon(gene['strand'], utr5_cod, cds_cod, utr3_cod) \\n\\n if gene['strand']=='-': ## general order to coordinates\\n if len(exon_cod) >1:\\n if exon_cod[0][0] > exon_cod[-1][0]:\\n exon_cod.reverse()\\n if len(cds_cod) >1:\\n if cds_cod[0][0] > cds_cod[-1][0]: \\n cds_cod.reverse()\\n if len(utr3_cod) >1:\\n if utr3_cod[0][0] > utr3_cod[-1][0]: \\n utr3_cod.reverse()\\n if len(utr5_cod) >1:\\n if utr5_cod[0][0] > utr5_cod[-1][0]:\\n utr5_cod.reverse()\\n\\n tis, cdsStop, tss, cleave = [], [], [], [] ## speacial sited in the gene region \\n if cds_cod != []:\\n if gene['strand'] == '+':\\n tis = [cds_cod[0][0]]\\n cdsStop = [cds_cod[-1][1]-3]\\n elif gene['strand'] == '-':\\n tis = [cds_cod[-1][1]]\\n cdsStop = [cds_cod[0][0]+3]\\n if utr5_cod != []:\\n if gene['strand'] == '+':\\n tss = [utr5_cod[0][0]]\\n elif gene['strand'] == '-':\\n tss = [utr5_cod[-1][1]]\\n if utr3_cod != []:\\n if gene['strand'] == '+':\\n cleave = [utr3_cod[-1][1]]\\n elif gene['strand'] == '-':\\n cleave = [utr3_cod[0][0]]\\n\\n cds_status, exon_status, utr_status = 0, 0, 0 ## status of the complete elements of the gene\\n if cds_cod != []: ## adding phase to the CDS region \\n cds_cod_phase = addCDSphase(gene['strand'], cds_cod)\\n cds_status = 1\\n gene['cds_exons'].append(cds_cod_phase)\\n\\n if exon_cod != []: \\n exon_status = 1\\n if utr5_cod != [] or utr3_cod != []: \\n utr_status = 1\\n if cds_status != 0 and exon_status != 0 and utr_status != 0:\\n gene['transcript_status'].append(1)\\n else:\\n gene['transcript_status'].append(0)\\n\\n if exon_cod: ## final check point for a valid gene model \\n gene['exons'].append(exon_cod)\\n gene['utr3_exons'].append(utr3_cod)\\n gene['utr5_exons'].append(utr5_cod)\\n gene['tis'].append(tis)\\n gene['cdsStop'].append(cdsStop)\\n gene['tss'].append(tss)\\n gene['cleave'].append(cleave) \\n\\t \\n\\t gtype=list(set(gtype)) ## different types \\n gene['gene_info']=dict(ID=gene_entry[1],\\n\\t\\t\\t\\tSource=genes_cmpt[gene_entry]['source'],\\n\\t\\t\\t\\tType=gtype)\\n gene=FeatureValueFormat(gene) ## get prepare for MAT writing \\n gene_counter+=1\\n gene_models.append(gene)\\n return gene_models\",\n \"def generateIO(self):\\n if self.nodeClass not in ['alias', 'formnode']:\\n tmpCode = None\\n try:\\n tmpCode = self.compileDef(self._definition)\\n except SyntaxError:\\n pass\\n\\n if not tmpCode is None:\\n nameList = self.parseNames(tmpCode)\\n finalList = []\\n for item in nameList:\\n if item and self.model.existNode(item):\\n rxText = \\\"(?<!\\\\\\\\.)\\\\\\\\b(###)\\\\\\\\b(?!={1}(?!={1}))\\\".replace(\\n \\\"###\\\", item)\\n rx = re.compile(rxText)\\n if len(re.findall(rx, self.definition)) > 0:\\n finalList.append(item)\\n self.ioEngine.updateInputs(finalList)\",\n \"def to_typing_code(cls, types_style: Dict[Union['BaseType', Type['BaseType']], dict]) -> Tuple[ImportPathList, str]:\\n cls_name = cls.__name__\\n options = cls.get_options_for_type(cls, types_style)\\n if options.get(cls.TypeStyle.use_actual_type):\\n if cls.actual_type.__module__ != 'builtins':\\n return [(cls.actual_type.__module__, cls.actual_type.__name__)], cls.actual_type.__name__\\n return [], cls.actual_type.__name__\\n return [('json_to_models.dynamic_typing', cls_name)], cls_name\",\n \"def extract_code_objects(pe):\\n script_res = _get_scripts_resource(pe)\\n dump = _resource_dump(pe, script_res)\\n return _get_co_from_dump(dump)\",\n \"def GetFriendAndTemplateClassString():\\n\\n #This essentially defines all the archiving of the ODE system.\\n friend_and_template_string = (translator.AddTabs(1) + \\\"friend class boost::serialization::access;\\\\n\\\" + \\n translator.AddTabs(1) + \\\"template<class Archive>\\\\n\\\" + \\n translator.AddTabs(1) + \\\"void serialize(Archive & archive, const unsigned int version)\\\\n\\\" + \\n translator.AddTabs(1) + \\\"{\\\\n\\\" + \\n translator.AddTabs(2) + \\\"archive & boost::serialization::base_object<AbstractOdeSystem>(*this);\\\\n\\\" + \\n translator.AddTabs(1) + \\\"}\\\\n\\\" + \\n \\\"\\\\n\\\")\\n\\n return friend_and_template_string\",\n \"def gencode(self):\\n\\n fullcode = self.code_cfg\\n variables = codeconfig_getvars(fullcode)\\n if len(variables) > 0:\\n variables.sort(key=lambda x: len(x), reverse=True)\\n for va in variables:\\n if eval(\\\"self.\\\" + va[1:]) is None or eval(\\\"self.\\\" + va[1:]) == \\\"\\\":\\n warnings.warn(\\\"Inserting None for \\\" + va, UserWarning)\\n fullcode = fullcode.replace(va, str(eval(\\\"self.\\\" + va[1:])))\\n # testing for sintax errors\\n #compile(fullcode, \\\"<Test ModelCall Code>\\\\n\\\" + fullcode, 'exec')\\n tmpfile = os.path.join(gettempdir(), \\\"TestModelCallCode.\\\" + self.complexity + \\\".py\\\")\\n with open(tmpfile, \\\"w\\\") as f: f.write(fullcode)\\n compile(fullcode, tmpfile, 'exec')\\n return fullcode\",\n \"def generate_wrapper(self):\\n\\n # If there is an input file, parse it\\n if self.package_info_path is not None:\\n info_parser = PackageInfoParser(self.package_info_path,\\n self.source_root)\\n info_parser.parse()\\n self.package_info = info_parser.package_info\\n else:\\n pass\\n\\n # Generate a header collection\\n self.collect_source_hpp_files()\\n\\n # Attempt to assign source paths to each class, assuming the containing \\n # file name is the class name\\n for eachModule in self.package_info.module_info:\\n for eachClass in eachModule.class_info:\\n for eachPath in self.package_info.source_hpp_files:\\n base = ntpath.basename(eachPath)\\n if eachClass.name == base.split('.')[0]:\\n eachClass.source_file_full_path = eachPath\\n if eachClass.source_file is None:\\n eachClass.source_file = base\\n\\n # Attempt to automatically generate template args for each class\\n for eachModule in self.package_info.module_info:\\n info_generator = CppInfoHelper(eachModule)\\n for eachClass in eachModule.class_info:\\n info_generator.expand_templates(eachClass, \\\"class\\\")\\n\\n # Generate the header collection\\n header_collection_path = self.generate_header_collection()\\n\\n # Parse the header collection\\n self.parse_header_collection(header_collection_path)\\n\\n # Update the Class and Free Function Info from the parsed code\\n self.update_class_info()\\n self.update_free_function_info()\\n self.update_enum_info()\\n\\n # Write the modules\\n for eachModule in self.package_info.module_info:\\n module_writer = CppModuleWrapperWriter(self.global_ns,\\n self.source_ns,\\n eachModule,\\n self.get_wrapper_template(),\\n self.wrapper_root)\\n module_writer.write()\",\n \"def derived_classes(self, what: Union[GDScriptClass, str, int]):\\n base_cls: Optional[GDScriptClass] = None\\n if isinstance(what, GDScriptClass):\\n base_cls = what\\n else:\\n base_cls = self.get_class(what)\\n\\n for cls in self._classes_by_type_id.values():\\n if cls.base == base_cls:\\n yield cls\",\n \"def gen_code(self, compile_unit):\\n self.builder = irutils.Builder()\\n self.ir_var_map = {}\\n self.logger.debug(\\\"Generating IR-code\\\")\\n self.debug_db = debuginfo.DebugDb()\\n ir_mod = ir.Module(\\\"main\\\", debug_db=self.debug_db)\\n self.builder.module = ir_mod\\n\\n # Split declaration into functions and variables:\\n functions = []\\n variables = []\\n for declaration in compile_unit.declarations:\\n assert isinstance(declaration, declarations.CDeclaration)\\n\\n if isinstance(\\n declaration,\\n (declarations.Typedef, declarations.EnumConstantDeclaration),\\n ):\\n pass\\n elif isinstance(declaration, declarations.FunctionDeclaration):\\n functions.append(declaration)\\n elif isinstance(declaration, declarations.VariableDeclaration):\\n variables.append(declaration)\\n else: # pragma: no cover\\n raise NotImplementedError(str(declaration))\\n\\n # Generate code:\\n for variable in variables:\\n self.gen_global_variable(variable)\\n\\n for function in functions:\\n self.create_function(function)\\n\\n for function in functions:\\n self.gen_function(function)\\n\\n self.logger.info(\\\"Finished IR-code generation\\\")\\n return ir_mod\",\n \"def logic_program_form(self):\\n global instances\\n \\n s = ''\\n for x in self.constants:\\n s = s + 'dom(' + x + ').\\\\n'\\n for y in self.sorts:\\n s = s + 'is_a(' + x + ', ' + y + ').\\\\n\\\\n'\\n instances[y].add(x)\\n for z in superclasses[y]:\\n instances[y].add(x)\\n return s\",\n \"def typeMapping(self):\\n statemachines = self.package.getStateMachines()\\n classes = {}\\n for sm in statemachines:\\n workflowId = sm.getCleanName()\\n for klass in sm.getClasses():\\n # We allow to bound a workflow to a <<stub>>\\n if klass.isabstract:\\n continue\\n elif not self.atgenerator._isContentClass(klass) and \\\\\\n not klass.hasStereoType(self.atgenerator.stub_stereotypes):\\n continue\\n name = klass.getTaggedValue('portal_type') or \\\\\\n klass.getCleanName()\\n classes.setdefault(name, []).append(workflowId)\\n\\n classNames = classes.keys()\\n classNames.sort()\\n result = []\\n for id_ in classNames:\\n item = {}\\n item['id'] = id_ # portal type\\n item['workflowIds'] = classes[id_]\\n result.append(item)\\n\\n # no need to check use_workflow, it's already done by xmiparser.XMIModel.associateClassesToStateMachines,\\n # so the sm.getClasses() already returns classes which uses use_workflow tgv.\\n # if you uncomment thoses lines, you will have the bound-workflow twice\\n #handle the use_workflow tgvs\\n #for klass in self.package.getProduct().getClasses(recursive=True):\\n # if klass.hasTaggedValue('use_workflow'):\\n # result.append(dict(id=klass.getCleanName(),workflowId=klass.getTaggedValue('use_workflow')))\\n # remember special case\\n remembertypes = []\\n self.atgenerator.getRememberTypes(remembertypes, self.package)\\n for remembertype in remembertypes:\\n existent = False\\n for type in result:\\n if type['id'] == remembertype['portal_type']:\\n existent = True\\n if existent:\\n continue\\n additionaltype = dict()\\n additionaltype['id'] = remembertype['portal_type']\\n additionaltype['workflowIds'] = [remembertype['workflow']]\\n result.append(additionaltype)\\n\\n # take tgv on state machine itself into account\\n for sm in statemachines:\\n bindings = sm.getTaggedValue('bindings', '')\\n bindings = [b.strip() for b in bindings.split(', ') if b.strip()]\\n for binding in bindings:\\n item = {}\\n item['id'] = binding\\n item['workflowIds'] = [sm.getCleanName()]\\n result.append(item)\\n\\n return result\",\n \"def generate_class_string(typename, props, description, namespace):\\n # TODO _prop_names, _type, _namespace, and available_properties\\n # can be modified by a Dash JS developer via setattr\\n # TODO - Tab out the repr for the repr of these components to make it\\n # look more like a hierarchical tree\\n # TODO - Include \\\"description\\\" \\\"defaultValue\\\" in the repr and docstring\\n #\\n # TODO - Handle \\\"required\\\"\\n #\\n # TODO - How to handle user-given `null` values? I want to include\\n # an expanded docstring like Dropdown(value=None, id=None)\\n # but by templating in those None values, I have no way of knowing\\n # whether a property is None because the user explicitly wanted\\n # it to be `null` or whether that was just the default value.\\n # The solution might be to deal with default values better although\\n # not all component authors will supply those.\\n\\n filtered_props = filter_props(props)\\n prop_keys = list(filtered_props.keys())\\n string_attributes = \\\"\\\"\\n for p in prop_keys:\\n # TODO support wildcard attributes\\n if p[-1] != \\\"*\\\":\\n string_attributes += \\\"has '{}' => (\\\\n is => 'rw'\\\\n);\\\\n\\\".format(p)\\n perl_assets_package_name = _perl_assets_package_name_from_shortname(namespace)\\n common = \\\"my $dash_namespace = '\\\" + namespace + \\\"';\\\\n\\\\nsub DashNamespace {\\\\n return $dash_namespace;\\\\n}\\\\nsub _js_dist {\\\\n return \\\" + perl_assets_package_name + \\\"::_js_dist;\\\\n}\\\\n\\\"\\n return string_attributes + common\",\n \"def generate_script_impl(f):\\n\\n # Open `impl Script` section.\\n f.write(\\\"\\\"\\\"impl Script {\\n\\\"\\\"\\\")\\n\\n # Generate impl of `inner_full_name`.\\n f.write(\\\"\\\"\\\"\\n #[inline]\\n pub(crate) fn inner_full_name(self) -> &'static str {\\n match self {\\n Script::Unknown => \\\"Unknown\\\",\\n Script::Common => \\\"Common\\\",\\n Script::Inherited => \\\"Inherited\\\",\\n\\\"\\\"\\\")\\n for script in script_list:\\n f.write(\\\" Script::%s => \\\\\\\"%s\\\\\\\",\\\\n\\\" % (longforms[script], longforms[script]))\\n f.write(\\\"\\\"\\\" }\\n }\\n\\\"\\\"\\\")\\n\\n # Generate impl of `inner_from_full_name`.\\n f.write(\\\"\\\"\\\"\\n #[inline]\\n pub(crate) fn inner_from_full_name(input: &str) -> Option<Self> {\\n match input {\\n \\\"Unknown\\\" => Some(Script::Unknown),\\n \\\"Common\\\" => Some(Script::Common),\\n \\\"Inherited\\\" => Some(Script::Inherited),\\n\\\"\\\"\\\")\\n for script in script_list:\\n f.write(\\\" \\\\\\\"%s\\\\\\\" => Some(Script::%s),\\\\n\\\" % (longforms[script], longforms[script]))\\n f.write(\\\" _ => None,\\\\n\\\" )\\n f.write(\\\"\\\"\\\" }\\n }\\n\\\"\\\"\\\")\\n\\n # Generate impl of `inner_short_name`\\n f.write(\\\"\\\"\\\"\\n #[inline]\\n pub(crate) fn inner_short_name(self) -> &'static str {\\n match self {\\n Script::Unknown => \\\"\\\",\\n Script::Common => \\\"Zyyy\\\",\\n Script::Inherited => \\\"Zinh\\\",\\n\\\"\\\"\\\")\\n for script in script_list:\\n f.write(\\\" Script::%s => \\\\\\\"%s\\\\\\\",\\\\n\\\" % (longforms[script], script))\\n f.write(\\\"\\\"\\\" }\\n }\\n\\\"\\\"\\\")\\n\\n # Generate impl of `inner_from_short_name`\\n f.write(\\\"\\\"\\\"\\n #[inline]\\n pub(crate) fn inner_from_short_name(input: &str) -> Option<Self> {\\n match input {\\n \\\"Zyyy\\\" => Some(Script::Common),\\n \\\"Zinh\\\" => Some(Script::Inherited),\\n\\\"\\\"\\\")\\n for script in script_list:\\n f.write(\\\" \\\\\\\"%s\\\\\\\" => Some(Script::%s),\\\\n\\\" % (script, longforms[script]))\\n f.write(\\\"\\\"\\\" _ => None,\\\\n\\\"\\\"\\\")\\n f.write(\\\"\\\"\\\" }\\n }\\n\\\"\\\"\\\")\\n\\n # Generate impl of `for_integer`\\n f.write(\\\"\\\"\\\"\\n #[inline]\\n pub(crate) fn for_integer(value: u8) -> Self {\\n match value {\\n\\\"\\\"\\\")\\n for (i, script) in enumerate(script_list):\\n f.write(\\\" %s => Script::%s,\\\\n\\\" % (i, longforms[script]))\\n f.write(\\\"\\\"\\\" _ => unreachable!(),\\n }\\n }\\n\\\"\\\"\\\")\\n\\n # Close `impl Script` section\\n f.write(\\\"\\\"\\\"\\n}\\n\\\"\\\"\\\")\",\n \"def generate_nature(out):\\n\\n check_path(\\n os.path.join(out, BASE),\\n f\\\"The script should automatically generate this file. Something went wrong in the last step.\\\")\\n\\n nature = os.path.join(out, NATURE)\\n shutil.copytree(\\\"evaluation/ablation/nature\\\", nature)\\n shutil.copy(\\\"evaluation/src/utils.h\\\", nature)\",\n \"def generate_proxy(classname, endpoints):\\n # Replace path vars like (?<schemaname>.*) with {schemaname} for Retrofit's annotation\\n var_pattern = re.compile(r\\\"\\\\{(\\\\w+)\\\\}\\\")\\n\\n helper_class = []\\n found_key_array_parameter = False\\n\\n yield \\\"/*\\\"\\n yield \\\" * This file is auto-generated by h2o-3/h2o-bindings/bin/gen_java.py\\\"\\n yield \\\" * Copyright 2016 H2O.ai; Apache License Version 2.0 (see LICENSE for details)\\\"\\n yield \\\" */\\\"\\n yield \\\"package water.bindings.proxies.retrofit;\\\"\\n yield \\\"\\\"\\n yield \\\"import water.bindings.pojos.*;\\\"\\n yield \\\"import retrofit2.*;\\\"\\n yield \\\"import retrofit2.http.*;\\\"\\n yield \\\"import java.util.Map;\\\" if classname == \\\"Grid\\\" or classname == \\\"ModelBuilders\\\" else None\\n yield \\\"\\\"\\n yield \\\"public interface \\\" + classname + \\\" {\\\"\\n yield \\\"\\\"\\n\\n for e in endpoints:\\n method = e[\\\"handler_method\\\"]\\n # should we always use e.api_name ?\\n if method == \\\"exec\\\":\\n method = e[\\\"api_name\\\"]\\n\\n param_strs = []\\n required_param_strs = []\\n for field in e[\\\"input_params\\\"]:\\n fname = field[\\\"name\\\"]\\n if field[\\\"is_path_param\\\"]:\\n ftype = \\\"Path\\\"\\n else:\\n if e[\\\"http_method\\\"] == \\\"GET\\\":\\n ftype = \\\"Query\\\"\\n else:\\n ftype = \\\"Field\\\"\\n ptype = translate_type(field[\\\"type\\\"], field[\\\"schema_name\\\"])\\n if ptype.endswith(\\\"KeyV3\\\") or ptype == \\\"ColSpecifierV3\\\": ptype = \\\"String\\\"\\n if ptype.endswith(\\\"KeyV3[]\\\"): ptype = \\\"String[]\\\"\\n param_str = \\\"@{ftype}(\\\\\\\"{fname}\\\\\\\") {ptype} {fname}\\\".format(**locals())\\n param_strs.append(param_str)\\n if field[\\\"required\\\"]:\\n required_param_strs.append(param_str)\\n if len(param_strs) == len(required_param_strs): required_param_strs = None\\n\\n yield u\\\" /** \\\"\\n yield bi.wrap(e[\\\"summary\\\"], indent=\\\" * \\\")\\n for field in e[\\\"input_params\\\"]:\\n s = \\\" * @param %s \\\" % field[\\\"name\\\"]\\n yield s + bi.wrap(field[\\\"help\\\"], indent=\\\" *\\\" + \\\" \\\" * (len(s) - 4), indent_first=False)\\n yield u\\\" */\\\"\\n # Create 2 versions of each call: first with all input parameters present, and then only with required params\\n for params in [param_strs, required_param_strs]:\\n if params is None: continue\\n yield u\\\" @FormUrlEncoded\\\" if e[\\\"http_method\\\"] == \\\"POST\\\" else None\\n yield u\\\" @{method}(\\\\\\\"{path}\\\\\\\")\\\".format(method=e[\\\"http_method\\\"], path=e[\\\"url_pattern\\\"])\\n if len(params) <= 1:\\n args = params[0] if params else \\\"\\\"\\n yield \\\" Call<{schema}> {method}({args});\\\".format(schema=e[\\\"output_schema\\\"], method=method, args=args)\\n else:\\n yield \\\" Call<{schema}> {method}(\\\".format(schema=e[\\\"output_schema\\\"], method=method)\\n for arg in params:\\n yield \\\" \\\" + arg + (\\\"\\\" if arg == params[-1] else \\\",\\\")\\n yield \\\" );\\\"\\n yield \\\"\\\"\\n\\n # Make special static Helper class for Grid and ModelBuilders.\\n if \\\"algo\\\" in e:\\n # We make two train_ and validate_ methods. One (built here) takes the parameters schema, the other\\n # (built above) takes each parameter.\\n helper_class.append(\\\" /**\\\")\\n helper_class.append(bi.wrap(e[\\\"summary\\\"], indent=\\\" * \\\"))\\n helper_class.append(\\\" */\\\")\\n helper_class.append(\\\" public static Call<{oschema}> {method}({outer_class} z, {ischema} p) {{\\\"\\n .format(ischema=e[\\\"input_schema\\\"], oschema=e[\\\"output_schema\\\"], method=method,\\n outer_class=classname))\\n helper_class.append(\\\" return z.{method}(\\\".format(method=method))\\n for field in e[\\\"input_params\\\"]:\\n ptype = translate_type(field[\\\"type\\\"], field[\\\"schema_name\\\"])\\n pname = translate_name(field[\\\"name\\\"])\\n if ptype.endswith(\\\"KeyV3\\\"):\\n s = \\\"(p.{parm} == null? null : p.{parm}.name)\\\".format(parm=pname)\\n elif ptype.endswith(\\\"KeyV3[]\\\"):\\n found_key_array_parameter = True\\n s = \\\"(p.{parm} == null? null : keyArrayToStringArray(p.{parm}))\\\".format(parm=pname)\\n elif ptype == \\\"ColSpecifierV3\\\":\\n s = \\\"(p.{parm} == null? null : p.{parm}.columnName)\\\".format(parm=pname)\\n else:\\n s = \\\"p.\\\" + pname\\n if field != e[\\\"input_params\\\"][-1]:\\n s += \\\",\\\"\\n helper_class.append(\\\" \\\" + s)\\n helper_class.append(\\\" );\\\")\\n helper_class.append(\\\" }\\\")\\n helper_class.append(\\\"\\\")\\n\\n if helper_class:\\n yield \\\"\\\"\\n yield \\\" @SuppressWarnings(\\\\\\\"unused\\\\\\\")\\\"\\n yield \\\" class Helper {\\\"\\n for line in helper_class:\\n yield line\\n if found_key_array_parameter:\\n yield \\\" /**\\\"\\n yield \\\" * Return an array of Strings for an array of keys.\\\"\\n yield \\\" */\\\"\\n yield \\\" public static String[] keyArrayToStringArray(KeyV3[] keys) {\\\"\\n yield \\\" if (keys == null) return null;\\\"\\n yield \\\" String[] ids = new String[keys.length];\\\"\\n yield \\\" int i = 0;\\\"\\n yield \\\" for (KeyV3 key : keys) ids[i++] = key.name;\\\"\\n yield \\\" return ids;\\\"\\n yield \\\" }\\\"\\n yield \\\" }\\\"\\n yield \\\"\\\"\\n\\n yield \\\"}\\\"\",\n \"def generate(cls):\\n raise NotImplementedError()\",\n \"def GenerateContainer(ctx, \\n container_name=None, \\n container_iname=None,\\n base_interfaces=()\\n ):\\n # create container\\n container_name = container_name or \\\\\\n \\\"%sContainer\\\" % (ctx.domain_model.__name__)\\n \\n # allow passing in dotted python path\\n if isinstance(ctx.container_module, (str, unicode)):\\n ctx.container_module = resolve(ctx.container_module)\\n \\n # if not present use the domain class's module\\n elif ctx.container_module is None:\\n ctx.container_module = resolve(ctx.domain_model.__module__)\\n \\n # sanity check we have a module for the container\\n assert isinstance(ctx.container_module, types.ModuleType), \\\"Invalid Container\\\"\\n \\n # logging variables\\n msg = (ctx.domain_model.__name__, \\n ctx.container_module.__name__, container_name)\\n \\n # if we already have a container class, exit \\n if getattr(ctx.container_module, container_name, None):\\n if ctx.echo:\\n ctx.logger.debug(\\\"%s: found container %s.%s, skipping\\\" % msg)\\n ctx.container_class = getattr(ctx.container_module, container_name)\\n return\\n \\n if ctx.echo:\\n ctx.logger.debug(\\\"%s: generated container %s.%s\\\" % msg)\\n \\n # if we already have a container class, exit\\n container_class = type(container_name,\\n (AlchemistContainer,),\\n dict(_class=ctx.domain_model,\\n __module__=ctx.container_module.__name__)\\n )\\n setattr(ctx.container_module, container_name, container_class)\\n \\n # save container class on catalyst context\\n ctx.container_class = container_class\\n \\n # interface for container\\n container_iname = container_iname or \\\"I%s\\\" % container_name\\n \\n # if the interface module is none, then use the nearest one to the domain class\\n if ctx.interface_module is None:\\n ctx.interface_module = _get_interface_module_for(ctx)\\n\\n msg = (ctx.domain_model.__name__,\\n ctx.container_module.__name__, container_iname)\\n \\n # if we already have a container interface class, skip creation\\n container_interface = getattr(ctx.interface_module, container_iname, None)\\n if container_interface is not None:\\n assert issubclass(container_interface, IAlchemistContainer)\\n if ctx.echo:\\n ctx.logger.debug(\\\"%s: skipping container interface %s.%s for\\\" % msg)\\n else:\\n if ctx.echo:\\n ctx.logger.debug(\\\"%s: generated container interface %s.%s\\\" % msg)\\n # ensure that our base interfaces include alchemist container \\n if base_interfaces:\\n assert isinstance(base_interfaces, tuple)\\n found = False\\n for bi in base_interfaces:\\n found = issubclass(bi, IAlchemistContainer)\\n if found: break\\n if not found:\\n base_interfaces = base_interfaces + (IAlchemistContainer,)\\n else:\\n base_interfaces = (IAlchemistContainer,)\\n \\n # create interface\\n container_interface = interface.interface.InterfaceClass(\\n container_iname,\\n bases=base_interfaces,\\n __module__=ctx.interface_module.__name__\\n )\\n # store container interface for catalyst\\n ctx.container_interface = container_interface\\n setattr(ctx.interface_module, container_iname, container_interface)\\n \\n # setup security\\n for n,d in container_interface.namesAndDescriptions(1):\\n protectName(container_class, n, \\\"zope.Public\\\")\\n \\n if not container_interface.implementedBy(container_class):\\n interface.classImplements(container_class, container_interface)\\n ctx.container_interface = container_interface\",\n \"def __repr__(self) -> str:\\n desc: List[str] = []\\n if classname := self['classname']:\\n desc.append(classname)\\n desc.append('Entity')\\n if name := self['targetname']:\\n desc.append(f'\\\"{name}\\\"({classname})')\\n else:\\n desc.append(classname)\\n if hammerid := self['hammerid']:\\n desc.append(f'#{hammerid}')\\n if origin := self['origin']:\\n desc.append(f'@ ({origin})')\\n return f'<{\\\" \\\".join(desc)}>'\",\n \"def _get_base_class_names(frame):\\n co, lasti = frame.f_code, frame.f_lasti\\n code = co.co_code\\n i = 0\\n extended_arg = 0\\n extends = []\\n while i <= lasti:\\n c = code[i]\\n op = ord(c)\\n i += 1\\n if op >= dis.HAVE_ARGUMENT:\\n oparg = ord(code[i]) + ord(code[i + 1]) * 256 + extended_arg\\n extended_arg = 0\\n i += 2\\n if op == dis.EXTENDED_ARG:\\n extended_arg = oparg * int(65536)\\n if op in dis.hasconst:\\n if type(co.co_consts[oparg]) == str:\\n extends = []\\n elif op in dis.hasname:\\n if dis.opname[op] == 'LOAD_NAME':\\n extends.append(('name', co.co_names[oparg]))\\n if dis.opname[op] == 'LOAD_ATTR':\\n extends.append(('attr', co.co_names[oparg]))\\n items = []\\n previous_item = []\\n for t, s in extends:\\n if t == 'name':\\n if previous_item:\\n items.append(previous_item)\\n previous_item = [s]\\n else:\\n previous_item += [s]\\n if previous_item:\\n items.append(previous_item)\\n return items\",\n \"def ast_class(cl):\\n\\n return cl.__class__.__name__\",\n \"def build_model(xnat_session, extension_types, connection_id):\\n logger = xnat_session.logger\\n debug = xnat_session.debug\\n\\n # Check XNAT version\\n version = xnat_session.xnat_version\\n\\n # Generate module\\n parser = SchemaParser(debug=debug, logger=logger)\\n\\n if xnat_session.xnat_version.startswith('1.6'):\\n logger.info('Found an 1.6 version ({})'.format(version))\\n parse_schemas_16(parser, xnat_session, extension_types=extension_types)\\n elif version.startswith('1.7'):\\n logger.info('Found an 1.7 version ({})'.format(version))\\n parse_schemas_17(parser, xnat_session, extension_types=extension_types)\\n else:\\n logger.critical('Found an unsupported version ({})'.format(version))\\n raise ValueError('Cannot continue on unsupported XNAT version')\\n\\n # Write code to temp file\\n with tempfile.NamedTemporaryFile(mode='w', suffix='_generated_xnat.py', delete=False) as code_file:\\n parser.write(code_file=code_file)\\n\\n logger.debug('Code file written to: {}'.format(code_file.name))\\n\\n # The module is loaded in its private namespace based on the code_file name\\n xnat_module = imp.load_source('xnat_gen_{}'.format(connection_id),\\n code_file.name)\\n xnat_module._SOURCE_CODE_FILE = code_file.name\\n\\n logger.debug('Loaded generated module')\\n\\n # Register all types parsed\\n for cls in parser.class_list.values():\\n if not (cls.name is None or (cls.base_class is not None and cls.base_class.startswith('xs:'))):\\n getattr(xnat_module, cls.writer.python_name).__register__(xnat_module.XNAT_CLASS_LOOKUP)\\n\\n xnat_module.SESSION = xnat_session\\n\\n # Add the required information from the module into the xnat_session object\\n xnat_session.XNAT_CLASS_LOOKUP.update(xnat_module.XNAT_CLASS_LOOKUP)\\n xnat_session.classes = xnat_module\\n xnat_session._source_code_file = code_file.name\",\n \"def _write_model(self, specification, specification_set, output_directory, package_name):\\n template_file = \\\"o11nplugin-core/model.java.tpl\\\"\\n filename = \\\"%s%s.java\\\" % (self._class_prefix, specification.entity_name)\\n\\n override_content = self._extract_override_content(specification.entity_name)\\n superclass_name = \\\"BaseRootObject\\\" if specification.rest_name == self.api_root else \\\"BaseObject\\\"\\n\\n defaults = {}\\n section = specification.entity_name\\n if self.attrs_defaults.has_section(section):\\n for attribute in self.attrs_defaults.options(section):\\n defaults[attribute] = self.attrs_defaults.get(section, attribute)\\n\\n entity_includes = self._get_entity_list_filter(self.inventory_entities, section, \\\"includes\\\")\\n entity_excludes = self._get_entity_list_filter(self.inventory_entities, section, \\\"excludes\\\")\\n entity_name_attr = \\\"id\\\"\\n if self.inventory_entities.has_section(section):\\n if self.inventory_entities.has_option(section, \\\"name\\\"):\\n entity_name_attr = self.inventory_entities.get(section, \\\"name\\\")\\n\\n self.write(destination=output_directory,\\n filename=filename, \\n template_name=template_file,\\n specification=specification,\\n specification_set=specification_set,\\n version=self.api_version,\\n name=self._name,\\n class_prefix=self._class_prefix,\\n product_accronym=self._product_accronym,\\n override_content=override_content,\\n superclass_name=superclass_name,\\n header=self.header_content,\\n version_string=self._api_version_string,\\n package_name=package_name,\\n attribute_defaults=defaults,\\n entity_name_attr=entity_name_attr,\\n root_api=self.api_root,\\n entity_includes=entity_includes,\\n entity_excludes=entity_excludes)\\n\\n return (filename, specification.entity_name)\",\n \"def generate_a_pyrex_source(self, base, ext_name, source, extension):\\n return []\",\n \"def mak(self):\\n #print \\\"entering mak!!!\\\"\\n for cl in self.classes:\\n sage.misc.misc.inject_variable(repr(cl),cl, warn=False)\\n #for long_name_for_class_that_probably_wont_be_in_global_namespace in self.classes:\\n #if long_name_for_class_that_probably_wont_be_in_global_namespace != 0:\\n #exec(repr(long_name_for_class_that_probably_wont_be_in_global_namespace) + \\\" = long_name_for_class_that_probably_wont_be_in_global_namespace\\\", locals(), where)\",\n \"def render_class(c):\\n return java_class_template.render(\\n model=c\\n )\",\n \"def _get_uml_template(*, types: dict, type_mapping: dict, message_mapping: dict) -> str:\\n relationships = []\\n classes = []\\n\\n uml_template = \\\"\\\"\\\"\\n digraph \\\"Protobuf UML class diagram\\\" {\\n fontname = \\\"Bitstream Vera Sans\\\"\\n fontsize = 8\\n\\n node [\\n fontname = \\\"Bitstream Vera Sans\\\"\\n fontsize = 8\\n shape = \\\"record\\\"\\n style=filled\\n fillcolor=gray95\\n ]\\n\\n edge [\\n fontname = \\\"Bitstream Vera Sans\\\"\\n fontsize = 8\\n\\n ]\\n\\n CLASSES\\n\\n RELATIONSHIPS\\n }\\n \\\"\\\"\\\"\\n\\n entry_index = 2\\n for _type, message in types.items():\\n type_template_text = StringIO()\\n type_template_text.write(f\\\"\\\"\\\" {entry_index}[label = \\\"{{{_type}|\\\"\\\"\\\")\\n fields = []\\n for _field in message.fields:\\n message_type = _field.message_type\\n field_type = type_mapping[_field.type] # this will be 'message' if referencing another protobuf message\\n\\n if message_type:\\n this_node = message_mapping[_type]\\n that_node = message_mapping[message_type.name]\\n relationships.append(f\\\" {this_node}->{that_node}\\\")\\n field_type = message_type.name # so we replace the 'message' token by the actual name\\n\\n fields.append(f\\\"+ {_field.name}:{field_type}\\\")\\n\\n # add fields\\n type_template_text.write(\\\"\\\\\\\\n\\\".join(fields))\\n type_template_text.write(\\\"}\\\\\\\"]\\\\n\\\")\\n entry_index += 1\\n classes.append(type_template_text.getvalue())\\n\\n type_template_text.close()\\n\\n uml_template = uml_template.replace(\\\"CLASSES\\\", \\\"\\\\n\\\".join(classes))\\n uml_template = uml_template.replace(\\\"RELATIONSHIPS\\\", \\\"\\\\n\\\".join(relationships))\\n return uml_template\",\n \"def CompileClass(self):\\n\\n ## Go to first token\\n self.Tokenizer.advance()\\n\\n ## Expecting class keyword\\n self._eat('class')\\n self._write_opener('class')\\n self._write_entry('keyword','class')\\n\\n ## Now handle the identifier\\n\\n if not self.Tokenizer.currentTokenType == \\\"IDENTIFIER\\\":\\n raise ValueError(\\\"ERROR_UNEXPECTED_TOKEN: \\\" + self.Tokenizer.currentTokenType + \\\" \\\" + self.Tokenizer.currentToken )\\n else:\\n self._write_entry(self.Tokenizer.currentTokenType.lower(), self.Tokenizer.currentToken)\\n\\n self.Tokenizer.advance()\\n\\n ## Now opening curly bracket\\n self._eat('{')\\n self._write_entry('symbol','{')\\n\\n #self.Tokenizer.advance()\\n\\n\\n # Now expecting 0 or more classVarDec\\n\\n # self.Tokenizer.advance()\\n #\\n # if self.Tokenizer.currentTokenType == \\\"KEYWORD\\\" and self.Tokenizer.currentToken in [\\\"static\\\", \\\"field\\\"]:\\n # self._write_closer('class')\\n # self.outputFile.close()\\n\\n\\n ## Finally the closing brace\\n try:\\n self._eat('}')\\n self._write_entry('symbol', '}')\\n self._write_closer('class')\\n except:\\n print(\\\"waah\\\")\\n\\n self.outputFile.close()\",\n \"def gen_capi(args):\\n\\n if not args.header:\\n return \\\"\\\"\\n\\n cmd = [\\\"ctags\\\", \\\"-x\\\", \\\"--c-kinds=fpsgx\\\", args.header]\\n\\n process = Popen(cmd, stdout=PIPE, stderr=PIPE)\\n out, err = process.communicate()\\n\\n if process.returncode:\\n return \\\"\\\"\\n\\n titles = {\\n \\\"nvm_geo\\\": \\\"Geometry\\\",\\n \\\"nvm_buf\\\": \\\"Buffer Allocation\\\",\\n \\\"nvm_dev\\\": \\\"Device Management\\\",\\n \\\"nvm_addr\\\": \\\"Addressing\\\",\\n \\\"nvm_cmd\\\": \\\"Raw Commands\\\",\\n \\\"nvm_vblk\\\": \\\"Virtual Block\\\",\\n \\\"nvm_bbt\\\": \\\"Bad-Block-Table\\\"\\n }\\n docs = {}\\n\\n lib = {}\\n for line in out.split(\\\"\\\\n\\\"):\\n parts = (\\\" \\\".join(line.split())).split(\\\" \\\")[:2]\\n if len(parts) < 2:\\n continue\\n\\n name, kind = parts\\n ns = \\\"_\\\".join(name.split(\\\"_\\\")[:2])\\n\\n if ns not in lib:\\n lib[ns] = {}\\n\\n if kind not in lib[ns]:\\n lib[ns][kind] = []\\n\\n lib[ns][kind].append(name)\\n\\n for ns in lib:\\n\\n if \\\"prototype\\\" in lib[ns]:\\n ordering = [\\n \\\"bbt_get\\\", \\\"bbt_set\\\", \\\"bbt_mark\\\", \\\"bbt_flush\\\",\\n \\\"addr_erase\\\", \\\"addr_read\\\", \\\"addr_write\\\", \\\"addr_check\\\",\\n \\\"addr_.*2\\\",\\n \\\"vblk_erase\\\", \\\"vblk_p?read\\\", \\\"vblk_p?write\\\", \\\"vblk_pad\\\",\\n \\\"lba_p?read\\\", \\\"lba_p?write\\\",\\n \\\"_alloc\\\", \\\"_fill\\\", \\\"_free\\\", \\\"_pr\\\",\\n \\\"_get_\\\", \\\"_set_\\\"\\n ]\\n\\n ordered = []\\n for order in ordering:\\n for func in lib[ns][\\\"prototype\\\"]:\\n if re.search(order, func):\\n if func not in ordered:\\n ordered.append(func)\\n\\n lib[ns][\\\"prototype\\\"] = list(\\n set(lib[ns][\\\"prototype\\\"]) -\\n set(ordered)\\n ) + ordered\\n\\n title = \\\"%s - %s\\\" % (ns, titles[ns]) if ns in titles else ns\\n\\n rst = \\\"\\\\n\\\".join([\\n \\\".. _sec-capi-%s:\\\" % ns, \\\"\\\",\\n title,\\n \\\"=\\\" * len(title),\\n \\\"\\\", \\\"\\\"\\n ])\\n\\n if \\\"typedefs\\\" in lib[ns]:\\n for typedef in lib[ns][\\\"typedefs\\\"]:\\n rst += \\\"\\\\n\\\".join([\\n typedef,\\n \\\"-\\\" * len(typedef), \\\"\\\",\\n \\\".. doxygentypedef:: %s\\\" % typedef,\\n \\\"\\\", \\\"\\\"\\n ])\\n\\n for mangler in [\\\"struct\\\", \\\"externvar\\\"]:\\n if mangler in lib[ns]:\\n for struct in lib[ns][mangler]:\\n rst += \\\"\\\\n\\\".join([\\n struct,\\n \\\"-\\\" * len(struct), \\\"\\\",\\n \\\".. doxygenstruct:: %s\\\" % struct,\\n \\\" :members:\\\",\\n \\\"\\\", \\\"\\\"\\n ])\\n\\n if \\\"enum\\\" in lib[ns]:\\n for enum in lib[ns][\\\"enum\\\"]:\\n rst += \\\"\\\\n\\\".join([\\n enum,\\n \\\"-\\\" * len(enum), \\\"\\\",\\n \\\".. doxygenenum:: %s\\\" % enum,\\n \\\"\\\", \\\"\\\"\\n ])\\n\\n if \\\"prototype\\\" in lib[ns]:\\n for func in lib[ns][\\\"prototype\\\"]:\\n rst += \\\"\\\\n\\\".join([\\n func,\\n \\\"-\\\" * len(func), \\\"\\\",\\n \\\".. doxygenfunction:: %s\\\" % func,\\n \\\"\\\", \\\"\\\"\\n ])\\n\\n docs[ns] = rst\\n\\n return docs\",\n \"def get_entity_classes(entity, mapping):\\n yago_categories = []\\n lkif_categories = []\\n for category in sorted(entity.categories):\\n if not category in mapping:\\n print('Error, unmapped category {}'.format(category),\\n file=sys.stderr)\\n lkif_parents = mapping.get(category, {'Unknown'})\\n for lkif_parent in lkif_parents:\\n yago_categories.append(category)\\n lkif_categories.append(lkif_parent)\\n return ('|'.join(yago_categories).encode(\\\"utf-8\\\"),\\n '|'.join(lkif_categories).encode(\\\"utf-8\\\"))\",\n \"def ccode(self):\\n from devito.ir.iet.visitors import CGen\\n return CGen().visit(self)\",\n \"def gen_extractors():\\n return [klass() for klass in gen_extractor_classes()]\",\n \"def _get_types(self):\\n\\n db = Database()\\n self.c_built_ins = list(map(lambda tup: tup[0], db.select_built_types()))\\n self.c_built_in_array_types = r'^(' + '|'.join(self.escaped(self.c_built_ins)) + ')\\\\[[0-9]*\\\\]'\\n self.c_types = list(map(lambda tup: tup[0], db.select_types()))\\n self.c_array_types = r'^(' + '|'.join(self.escaped(self.c_types)) + ')\\\\[[0-9]*\\\\]'\\n db.close_connection()\",\n \"def convert_class(self, access_modifier, class_name, classes, interfaces):\\n\\n # Run super definition\\n access_modifier, class_name, classes, interfaces = \\\\\\n super().convert_class(access_modifier, class_name,\\n classes, interfaces)\\n\\n # Merge classes and interfaces both are the same in python\\n super_ = classes + interfaces\\n\\n # Create string to denote super name as interface\\n dnt = \\\": interface\\\"\\n\\n # Create docstring\\n doc_str = [name + dnt for name in interfaces]\\n\\n # Create class template\\n class_template = \\\"class {}{}:\\\"\\n\\n # If super classes are provided, make super classes string\\n super_cls_str = \\\"\\\"\\n if super_:\\n # Create super_classes template\\n super_cls_str = \\\"({})\\\"\\n\\n # Add all super_classes to sting\\n super_cls_str = super_cls_str.format(\\\", \\\".join(super_))\\n\\n # If doc string is not empty add starting and ending quotes to docstring\\n if doc_str:\\n doc_str[0] = '\\\"\\\"\\\"' + doc_str[0]\\n doc_str[-1] += '\\\"\\\"\\\"'\\n\\n # Return processed class definition\\n return [class_template.format(class_name, super_cls_str)] + doc_str, []\",\n \"def _ConstructType(self, type_name, type_contents, filepath, require_guid):\\n\\n description = ''\\n parents = None\\n local_field_names = None\\n opt_local_field_names = None\\n is_abstract = False\\n allow_undefined_fields = False\\n is_canonical = False\\n guid = None\\n\\n expected_keys = set([\\n 'description', 'implements', 'uses', 'opt_uses', 'is_abstract', 'guid',\\n 'is_canonical', 'allow_undefined_fields'\\n ])\\n\\n if 'description' in type_contents:\\n description = type_contents['description']\\n if 'implements' in type_contents:\\n parents = type_contents['implements']\\n if 'uses' in type_contents:\\n local_field_names = type_contents['uses']\\n if 'opt_uses' in type_contents:\\n opt_local_field_names = type_contents['opt_uses']\\n if 'is_abstract' in type_contents:\\n is_abstract = type_contents['is_abstract']\\n if 'allow_undefined_fields' in type_contents:\\n allow_undefined_fields = type_contents['allow_undefined_fields']\\n if 'is_canonical' in type_contents:\\n is_canonical = type_contents['is_canonical']\\n if 'guid' in type_contents:\\n guid = type_contents['guid']\\n\\n # Generate tuples to represent each field\\n fq_lfn = []\\n if local_field_names:\\n self._ConstructField(local_field_names, False, fq_lfn)\\n if opt_local_field_names:\\n self._ConstructField(opt_local_field_names, True, fq_lfn)\\n\\n entity_type = EntityType(\\n filepath=filepath,\\n typename=type_name,\\n description=description,\\n parents=parents,\\n local_field_tuples=fq_lfn,\\n is_abstract=is_abstract,\\n allow_undefined_fields=allow_undefined_fields,\\n inherited_fields_expanded=False,\\n is_canonical=is_canonical,\\n guid=guid,\\n require_guid=require_guid,\\n namespace=self.local_namespace)\\n\\n # Add errors to type if there's anything extra in the block. We add to the\\n # entity type because an extra key here is likely a typo in a real key name\\n # that would result in information being lost from the type.\\n for key in type_contents:\\n if key not in expected_keys:\\n entity_type.AddFinding(\\n findings_lib.UnrecognizedKeyError(key, entity_type.file_context))\\n\\n return entity_type\",\n \"def get_result(self):\\n \\n # Gather any macros.\\n self.get_macros(self.cpp_data.get('functions'))\\n\\n # Walk through all the items, hooking up the appropriate \\n # links by replacing the id tags with the actual objects\\n remove = []\\n #for name, node in self.all.items():\\n # location = getattr(node, 'location', None)\\n # if location is not None:\\n # fil = location.file\\n # #line = location.line\\n # line = 0\\n # #node.location = (self.all[fil].name, int(line))\\n \\n # TODO: fixup not necessary ?\\n\\n # method_name = '_fixup_' + node.__class__.__name__\\n # fixup_method = getattr(self, method_name, None)\\n # if fixup_method is not None:\\n # fixup_method(node)\\n # else:\\n # remove.append(node)\\n # print \\\"remove node\\\", node\\n \\n # # remove any nodes don't have handler methods\\n # for n in remove:\\n # del self.all[n]\\n \\n # sub out any #define'd aliases and collect all the nodes \\n # we're interested in. The interesting nodes are not necessarily\\n # all nodes, but rather the ones that may need to be modified\\n # by the transformations applied later on.\\n interesting = (c_ast.Typedef, c_ast.Struct, c_ast.Enumeration, \\n c_ast.Union, c_ast.Function, c_ast.Variable, \\n c_ast.Namespace, c_ast.File,\\n c_ast.Class,\\n )\\n\\n result = []\\n namespace = {}\\n for node in self.all.values():\\n #for node in self.nodes: #traverse results in parse order\\n if not isinstance(node, interesting):\\n continue\\n name = getattr(node, 'name', None)\\n if name is not None:\\n namespace[name] = node\\n result.append(node)\\n self.get_aliases(self.cpp_data.get('aliases'), namespace)\\n \\n return result\",\n \"def generate_code(spn_id, spn, meta_types, floating_data_type):\\r\\n\\r\\n # make sure we have ids\\r\\n assign_ids(spn)\\r\\n\\r\\n # fill method body according to SPN structure\\r\\n method_body = generate_method_body(spn, spn, floating_data_type, 0)\\r\\n\\r\\n # build parameters used in generated c++ function\\r\\n method_params = []\\r\\n passed_params = []\\r\\n for i, type in enumerate(meta_types):\\r\\n if type == MetaType.DISCRETE:\\r\\n method_params += [f'vector <int> possibleValues{i}', f'int nullValueIdx{i}']\\r\\n passed_params += [f'py::arg(\\\"possibleValues{i}\\\")', f'py::arg(\\\"nullValueIdx{i}\\\")']\\r\\n elif type == MetaType.REAL:\\r\\n method_params += [f'bool inverse{i}', f'bool leftMinusInf{i}', f'float leftCondition{i}',\\r\\n f'bool rightMinusInf{i}', f'float rightCondition{i}', f'bool leftIncluded{i}',\\r\\n f'bool rightIncluded{i}', f'float nullValue{i}']\\r\\n passed_params += [f'py::arg(\\\"inverse{i}\\\")', f'py::arg(\\\"leftMinusInf{i}\\\")', f'py::arg(\\\"leftCondition{i}\\\")',\\r\\n f'py::arg(\\\"rightMinusInf{i}\\\")', f'py::arg(\\\"rightCondition{i}\\\")',\\r\\n f'py::arg(\\\"leftIncluded{i}\\\")', f'py::arg(\\\"rightIncluded{i}\\\")', f'py::arg(\\\"nullValue{i}\\\")']\\r\\n\\r\\n value_dictionary = {\\r\\n 'spn_id': spn_id,\\r\\n 'method_body': method_body,\\r\\n 'method_params': ', '.join(method_params),\\r\\n 'node_count': get_number_of_nodes(spn),\\r\\n 'passed_params': ', '.join(passed_params),\\r\\n 'floating_data_type': floating_data_type\\r\\n }\\r\\n generated_method = replace_template(TemplatePath.METHOD_MASTER, value_dictionary, 0)\\r\\n registrate_method = replace_template(TemplatePath.REGISTRATION_MASTER, value_dictionary, 0)\\r\\n\\r\\n return generated_method, registrate_method\",\n \"def compile(cls, node, filename):\\n compiler = cls(filename)\\n compiler.visit(node)\\n code_ops = compiler.code_ops\\n code = Code(\\n code_ops, [], ['identifiers', 'toolkit'], False, False, True, \\n node.name, filename, node.lineno, node.doc,\\n )\\n return code\",\n \"def parse_bases(self, node, clsobj):\\n bases = []\\n for b in node.bases:\\n if not (isinstance(b, Name) and b.id == KW_PROCESS_DEF):\\n self.current_context = Read(clsobj)\\n bases.append(self.visit(b))\\n if isinstance(clsobj, dast.Process):\\n # try to resolve the base classes:\\n for b in bases:\\n try:\\n pd = self.resolver.find_process_definiton(b)\\n clsobj.merge_scope(pd)\\n except ResolverException as e:\\n self.warn('unable to resolve base class spec, '\\n 'compilation may be incomplete: {}.'\\n .format(e.reason), e.node if e.node else b)\\n return bases\",\n \"def generate(self):\\r\\n raise NotImplementedError\",\n \"def code_gen(blocks):\\r\\n\\r\\n decl = \\\"\\\"\\r\\n head = \\\"\\\"\\r\\n tail = \\\"\\\"\\r\\n for block in blocks:\\r\\n decl += block.declare\\r\\n head = head + (\\\"\\\\n{\\\\n%s\\\" % block.behavior)\\r\\n tail = (\\\"%s\\\\n}\\\\n\\\" % block.cleanup) + tail\\r\\n return decl + head + tail\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6546843","0.6342097","0.61589974","0.61360514","0.58900464","0.55907094","0.55879545","0.5527749","0.54475427","0.54270315","0.540438","0.53865635","0.535935","0.52980083","0.52552074","0.5254086","0.5237905","0.5225976","0.5212285","0.5208125","0.51882744","0.51859933","0.51708686","0.51186377","0.51185083","0.5115658","0.5110685","0.5092058","0.5067585","0.5066708","0.5058084","0.5056511","0.5038256","0.5029105","0.5022079","0.5018984","0.500651","0.49953455","0.49927697","0.49918312","0.49905786","0.49889544","0.49885088","0.49707747","0.49590987","0.49580753","0.49211675","0.4920643","0.49150896","0.4909443","0.4905005","0.49009347","0.48976868","0.48907024","0.4881546","0.48788327","0.48755896","0.48748732","0.48588246","0.4856166","0.48399556","0.48369306","0.4836052","0.4829475","0.48291516","0.4825946","0.48239943","0.48206985","0.48172703","0.48146105","0.48008403","0.48005047","0.47973198","0.47876924","0.47798225","0.47778723","0.47515786","0.47497663","0.47437364","0.47359577","0.47356656","0.47302127","0.4725485","0.47207648","0.4720171","0.47190708","0.47188908","0.47185576","0.47184452","0.47174233","0.47150636","0.47135046","0.4712018","0.4711457","0.47048056","0.47042087","0.46971995","0.4684946","0.46760643","0.46701577"],"string":"[\n \"0.6546843\",\n \"0.6342097\",\n \"0.61589974\",\n \"0.61360514\",\n \"0.58900464\",\n \"0.55907094\",\n \"0.55879545\",\n \"0.5527749\",\n \"0.54475427\",\n \"0.54270315\",\n \"0.540438\",\n \"0.53865635\",\n \"0.535935\",\n \"0.52980083\",\n \"0.52552074\",\n \"0.5254086\",\n \"0.5237905\",\n \"0.5225976\",\n \"0.5212285\",\n \"0.5208125\",\n \"0.51882744\",\n \"0.51859933\",\n \"0.51708686\",\n \"0.51186377\",\n \"0.51185083\",\n \"0.5115658\",\n \"0.5110685\",\n \"0.5092058\",\n \"0.5067585\",\n \"0.5066708\",\n \"0.5058084\",\n \"0.5056511\",\n \"0.5038256\",\n \"0.5029105\",\n \"0.5022079\",\n \"0.5018984\",\n \"0.500651\",\n \"0.49953455\",\n \"0.49927697\",\n \"0.49918312\",\n \"0.49905786\",\n \"0.49889544\",\n \"0.49885088\",\n \"0.49707747\",\n \"0.49590987\",\n \"0.49580753\",\n \"0.49211675\",\n \"0.4920643\",\n \"0.49150896\",\n \"0.4909443\",\n \"0.4905005\",\n \"0.49009347\",\n \"0.48976868\",\n \"0.48907024\",\n \"0.4881546\",\n \"0.48788327\",\n \"0.48755896\",\n \"0.48748732\",\n \"0.48588246\",\n \"0.4856166\",\n \"0.48399556\",\n \"0.48369306\",\n \"0.4836052\",\n \"0.4829475\",\n \"0.48291516\",\n \"0.4825946\",\n \"0.48239943\",\n \"0.48206985\",\n \"0.48172703\",\n \"0.48146105\",\n \"0.48008403\",\n \"0.48005047\",\n \"0.47973198\",\n \"0.47876924\",\n \"0.47798225\",\n \"0.47778723\",\n \"0.47515786\",\n \"0.47497663\",\n \"0.47437364\",\n \"0.47359577\",\n \"0.47356656\",\n \"0.47302127\",\n \"0.4725485\",\n \"0.47207648\",\n \"0.4720171\",\n \"0.47190708\",\n \"0.47188908\",\n \"0.47185576\",\n \"0.47184452\",\n \"0.47174233\",\n \"0.47150636\",\n \"0.47135046\",\n \"0.4712018\",\n \"0.4711457\",\n \"0.47048056\",\n \"0.47042087\",\n \"0.46971995\",\n \"0.4684946\",\n \"0.46760643\",\n \"0.46701577\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.68348277"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":17997,"cells":{"query":{"kind":"string","value":"updates .coveralls.yml file to allow upload of coverage report"},"document":{"kind":"string","value":"def update_coveralls_config(\n path_to_coverage,\n coveralls_token,\n token_key='repo_token',\n):\n try:\n with open(path_to_coverage, 'r') as cover_fh:\n raw_file = cover_fh.read()\n except FileNotFoundError:\n raw_file = ''\n\n # check if repo_token is already in .coveralls.yml\n if token_key in raw_file:\n return # already has coveralls credentials\n # TODO: check if `repo_token` is blank\n\n lines = raw_file.splitlines()\n lines.append(token_key + ': ' + coveralls_token)\n\n with open(path_to_coverage, 'w') as cover_fh:\n cover_fh.writelines(lines)"},"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 cover(ctx, html=False):\n header(cover.__doc__)\n extra = \"--cov-report html\" if html else \"\"\n with ctx.cd(ROOT):\n ctx.run(\n \"pytest --benchmark-skip --cov flask_restx --cov-report term --cov-report xml {0}\".format(\n extra\n ),\n pty=True,\n )","def task_coverage():\n return {\n 'actions': ['py.test --cov nikola --cov-report term-missing tests/'],\n 'verbosity': 2,\n }","def coverage(session) -> None:\n session.install(\".[test]\", \"pytest-cov\")\n session.run(\n \"pytest\", \"-n\", \"auto\", \"--cov=./\", \"--cov-report=xml\", *session.posargs\n )","def cuv(ctx, coverage_fname, exclude, branch):\n if coverage_fname is None:\n coverage_fname = find_coverage_data('.')\n # coverage_fname still could be None\n\n cfg = Config()\n ctx.obj = cfg\n\n cfg.nice_width = min(80, shutil.get_terminal_size()[0])\n cfg.exclude = exclude\n\n cfg.branch = branch\n if coverage_fname is not None:\n cfg.data = coverage.Coverage(data_file=coverage_fname)\n cfg.data.load()\n else:\n raise click.UsageError(\n \"No coverage data. Do you have a .coverage file?\"\n )","def coverage(session):\n session.install(\"coverage[toml]\", \"codecov\")\n session.run(\"coverage\", \"xml\", \"--fail-under=0\")\n session.run(\"codecov\", *session.posargs)","def set_coverage(self, coverage): \n self.coverage = coverage\n if os.path.isfile(TESTS_PATH + \"/\" + self.name):\n os.rename(TESTS_PATH + \"/\" + self.name, TESTS_PATH + \"/\" \\\n + self.app_pkg + \"_\"+self.timestamp + \"_\" \\\n + str(coverage) + \".sh\")\n else:\n f_out = open(TESTS_PATH + \"/\" + self.app_pkg + \"_\"+self.timestamp \\\n + \"_\" + str(coverage) + \".sh\", \"w\")\n f_out.write(self.script)\n f_out.close()\n self.name = self.app_pkg + \"_\" + self.timestamp + \"_\" + str(coverage) + \".sh\"","def upload_coverage(self, name, directory):\n logging.info('Not uploading coverage because no Filestore.')","def coverage(ctx):\n ctx.run(\"coverage run --source {PROJECT_NAME} -m pytest\".format(PROJECT_NAME=PROJECT_NAME))\n ctx.run(\"coverage report -m\")\n ctx.run(\"coverage html\")","def cov():\n cov = coverage.coverage(branch=True, include='project/*')\n cov.start()\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)\n cov.stop()\n cov.save()\n print('Coverage Summary:')\n cov.report()\n basedir = os.path.abspath(os.path.dirname(__file__))\n covdir = os.path.join(basedir, 'tmp/coverage')\n cov.html_report(directory=covdir)\n print('HTML version: file://%s/index.html' % covdir)\n cov.erase()","def cov():\n cov = coverage.coverage(\n branch=True,\n include='project/*',\n omit=\"*/__init__.py\"\n )\n cov.start()\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)\n cov.stop()\n cov.save()\n print 'Coverage Summary:'\n cov.report()\n basedir = os.path.abspath(os.path.dirname(__file__))\n covdir = os.path.join(basedir, 'tmp/coverage')\n cov.html_report(directory=covdir)\n print('HTML version: file://%s/index.html' % covdir)\n cov.erase()","def test(coverage):\n print('success')\n pass","def _update_coverage(self, msg, subtype, by):\n try:\n coverage = self.get_local(msg, \"coverage\")\n except KeyError:\n coverage = defaultdict(int)\n coverage[\"all\"] += by\n coverage[subtype] += by\n self.set_local(msg, \"coverage\", coverage)","def generate_cobertura_xml(self, coverage_data):\n\n dom_impl = minidom.getDOMImplementation()\n doctype = dom_impl.createDocumentType(\"coverage\", None,\n \"http://cobertura.sourceforge.net/xml/coverage-03.dtd\")\n document = dom_impl.createDocument(None, \"coverage\", doctype)\n root = document.documentElement\n summary = coverage_data['summary']\n self._attrs(root, {\n 'branch-rate': self._percent(summary['branches-total'],\n summary['branches-covered']),\n 'branches-covered': str(summary['branches-covered']),\n 'branches-valid': str(summary['branches-total']),\n 'complexity': '0',\n 'line-rate': self._percent(summary['lines-total'],\n summary['lines-covered']),\n 'lines-valid': str(summary['lines-total']),\n 'timestamp': coverage_data['timestamp'],\n 'version': '1.9'\n })\n\n sources = self._el(document, 'sources', {})\n source = self._el(document, 'source', {})\n source.appendChild(document.createTextNode(self.base_dir))\n sources.appendChild(source)\n\n root.appendChild(sources)\n\n packages_el = self._el(document, 'packages', {})\n\n packages = coverage_data['packages']\n for package_name, package_data in list(packages.items()):\n package_el = self._el(document, 'package', {\n 'line-rate': package_data['line-rate'],\n 'branch-rate': package_data['branch-rate'],\n 'name': package_name\n })\n classes_el = self._el(document, 'classes', {})\n for class_name, class_data in list(package_data['classes'].items()):\n class_el = self._el(document, 'class', {\n 'branch-rate': self._percent(class_data['branches-total'],\n class_data['branches-covered']),\n 'complexity': '0',\n 'filename': class_name,\n 'line-rate': self._percent(class_data['lines-total'],\n class_data['lines-covered']),\n 'name': class_data['name']\n })\n\n # Process methods\n methods_el = self._el(document, 'methods', {})\n for method_name, hits in list(class_data['methods'].items()):\n method_el = self._el(document, 'method', {\n 'name': method_name,\n 'signature' : '',\n 'hits': hits\n })\n methods_el.appendChild(method_el)\n\n # Process lines\n lines_el = self._el(document, 'lines', {})\n lines = list(class_data['lines'].keys())\n lines.sort()\n for line_number in lines:\n line_el = self._el(document, 'line', {\n 'branch': class_data['lines'][line_number]['branch'],\n 'hits': str(class_data['lines'][line_number]['hits']),\n 'number': str(line_number)\n })\n if class_data['lines'][line_number]['branch'] == 'true':\n total = int(class_data['lines'][line_number]['branches-total'])\n covered = int(class_data['lines'][line_number]['branches-covered'])\n percentage = int((covered * 100.0) / total)\n line_el.setAttribute('condition-coverage',\n '{0}% ({1}/{2})'.format(\n percentage, covered, total))\n lines_el.appendChild(line_el)\n\n class_el.appendChild(methods_el)\n class_el.appendChild(lines_el)\n classes_el.appendChild(class_el)\n package_el.appendChild(classes_el)\n packages_el.appendChild(package_el)\n root.appendChild(packages_el)\n\n return document.toprettyxml()","def main():\n import coverage\n import nose\n import os\n from shutil import rmtree\n rmtree('./covhtml', ignore_errors=True)\n try:\n os.remove('./.coverage')\n except Exception,e:\n pass\n\n # run nose in its own process because the .coverage file isn't written\n # until the process terminates and we need to read it\n nose.run()","def download_coverage(self, name, dst_directory):\n logging.info('Not downloading coverage because no Filestore.')","def gcov_it(version, num):\n subprocess.run([\"gcov-7\", \"-i\", \"replace.c\"],\n cwd=CWD_PREFIX+str(version))\n gcov = open(\"replace/versions.alt/versions.orig/v\" + str(version) +\n \"/replace.c.gcov\", 'r')\n out = []\n for line in gcov:\n info = line.split(':')[1].split(',')\n if line[0]=='l' and int(info[1]):\n out.append(\"cover(T{},S{})\".format(str(num), info[0]))\n gcov.close()\n subprocess.run([\"rm\", \"replace/versions.alt/versions.orig/v\" +\n str(version) + \"/replace.gcda\"])\n return out","def run(self):\n cmd = 'coverage run setup.py test && coverage report -m'\n check_call(cmd, shell=True)","def coverage(context):\n context.run(\" \".join([\n \"python -m pytest\",\n \"--cov=%s\" % PACKAGE_NAME,\n \"--cov-report html\",\n \"--cov-branch\",\n \"--cov-fail-under=75\"\n ]))","def test_coverage_2(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"coverage-example-selfpay.json\"\n inst = coverage.Coverage.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Coverage\" == inst.resource_type\n\n impl_coverage_2(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Coverage\" == data[\"resourceType\"]\n\n inst2 = coverage.Coverage(**data)\n impl_coverage_2(inst2)","def cov():\n tests = unittest.TestLoader().discover('project/tests')\n result = unittest.TextTestRunner(verbosity=2).run(tests)\n if result.wasSuccessful():\n COV.stop()\n COV.save()\n print('Coverage Summary:')\n COV.report()\n basedir = os.path.abspath(os.path.dirname(__file__))\n covdir = os.path.join(basedir, 'tmp/coverage')\n COV.html_report(directory=covdir)\n print('HTML version: file://%s/index.html' % covdir)\n COV.erase()\n return 0\n return 1","def test_coverage_4(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"coverage-example.json\"\n inst = coverage.Coverage.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Coverage\" == inst.resource_type\n\n impl_coverage_4(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Coverage\" == data[\"resourceType\"]\n\n inst2 = coverage.Coverage(**data)\n impl_coverage_4(inst2)","def coverage():\n print(\"Coverage tests always re-run\")\n with safe_cd(SRC):\n my_env = config_pythonpath()\n # You will need something like this in pytest.ini\n # By default, pytest is VERY restrictive in the file names it will match.\n #\n # [pytest]\n # DJANGO_SETTINGS_MODULE = core.settings\n # python_files = tests.py test_*.py *_tests.py test*_*.py *_test*.py\n if not os.path.exists(\"pytest.ini\") and IS_DJANGO:\n print(\n \"pytest.ini MUST exist for Django test detection or too few tests are found.\"\n )\n exit(-1)\n return\n\n my_env = config_pythonpath()\n command = \"{0} py.test {1} --cov={2} --cov-report html:coverage --cov-fail-under 55 --verbose\".format(\n PIPENV, \"test\", PROJECT_NAME\n )\n execute_with_environment(command, my_env)","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 run_coverage(session):\n set_environment_variables(PYBAMM_ENV, session=session)\n session.run_always(\"pip\", \"install\", \"coverage\")\n session.run_always(\"pip\", \"install\", \"-e\", \".[all]\")\n if sys.platform != \"win32\":\n session.run_always(\"pip\", \"install\", \"-e\", \".[odes]\")\n session.run_always(\"pip\", \"install\", \"-e\", \".[jax]\")\n session.run(\"coverage\", \"run\", \"--rcfile=.coveragerc\", \"run-tests.py\", \"--nosub\")\n session.run(\"coverage\", \"combine\")\n session.run(\"coverage\", \"xml\")","def cov():\n tests = unittest.TestLoader().discover('tests')\n result = unittest.TextTestRunner(verbosity=1).run(tests)\n if result.wasSuccessful():\n COV.stop()\n COV.save()\n print('Coverage Summary:')\n COV.report()\n basedir = os.path.abspath(os.path.dirname(__file__))\n covdir = os.path.join(basedir, 'tmp/coverage')\n COV.html_report(directory=covdir)\n print('HTML version: file://%s/index.html' % covdir)\n COV.erase()\n return 0\n return 1","def test_coverage_1(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"coverage-example-2.json\"\n inst = coverage.Coverage.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Coverage\" == inst.resource_type\n\n impl_coverage_1(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Coverage\" == data[\"resourceType\"]\n\n inst2 = coverage.Coverage(**data)\n impl_coverage_1(inst2)","def cov():\n tests = unittest.TestLoader().discover('project/tests')\n result = unittest.TextTestRunner(verbosity=2).run(tests)\n if result.wasSuccessful():\n COV.stop()\n COV.save()\n print('Coverage Summary:')\n COV.report()\n COV.html_report()\n COV.erase()\n return 0\n return 1","def test_coverage_3(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"coverage-example-ehic.json\"\n inst = coverage.Coverage.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"Coverage\" == inst.resource_type\n\n impl_coverage_3(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"Coverage\" == data[\"resourceType\"]\n\n inst2 = coverage.Coverage(**data)\n impl_coverage_3(inst2)","def coverage_init(reg, options):\n from .coveragepy import CoveragePlugin\n\n reg.add_file_tracer(CoveragePlugin())","def _update_disco(repo: _git.Repository, github_account: accounts.GitHubAccount) -> int:\n with TemporaryDirectory() as gopath:\n os.makedirs(join(gopath, 'src'))\n check_output(['ln', '-s',\n join(repo.filepath, 'src'),\n join(gopath, 'src/discovery-artifact-manager')])\n env = os.environ.copy()\n env['GOPATH'] = gopath\n check_output(['go', 'run', 'src/main/updatedisco/main.go'],\n cwd=repo.filepath,\n env=env)\n repo.add(['discoveries'])\n if not repo.diff_name_status():\n return 0\n repo.commit('Autogenerated Discovery document update',\n github_account.name,\n github_account.email)\n return 1","def _save_coverage_info(self, filename, file_line_info, ignore_missing_files):\n lcov_path = self.project_path('s2e-last', filename)\n\n logger.info('Writing line coverage to %s', lcov_path)\n\n with open(lcov_path, 'w') as f:\n f.write('TN:\\n')\n for src_file in file_line_info.keys():\n if ignore_missing_files and not os.path.exists(src_file):\n logger.warn('%s does not exist, skipping', src_file)\n continue\n else:\n logger.info(src_file)\n\n num_non_zero_lines = 0\n num_instrumented_lines = 0\n\n f.write('SF:%s\\n' % src_file)\n for line, count in file_line_info[src_file].items():\n f.write('DA:%d,%d\\n' % (line, count))\n\n if count:\n num_non_zero_lines += 1\n num_instrumented_lines += 1\n f.write('LH:%d\\n' % num_non_zero_lines)\n f.write('LF:%d\\n' % num_instrumented_lines)\n f.write('end_of_record\\n')\n\n return lcov_path","def test():\n with lcd(BASEDIR):\n local('virtenv/bin/coverage run runtests.py -v2')\n local('virtenv/bin/coverage report -m')","def fix_report(report):\n if not os.path.isfile(report):\n print(\"Error! Coverage report file %s not found!\" % report)\n return\n\n shutil.move(report, report + \".orig\")\n exclude_list = [\n r\"boost\",\n r\"build\\/debug\\/\",\n r\"build\\/coverage\\/\",\n r\"build\\/include\\/\",\n r\"\\/test\",\n r\"usr\\/\",\n ]\n\n modified_lines = []\n lines = []\n with open(report + \".orig\", \"r\") as filep:\n lines = filep.readlines()\n i = -1\n while True:\n i += 1\n if i >= len(lines):\n break\n exclude = False\n for pattern in exclude_list:\n if re.search(pattern, lines[i]):\n exclude = True\n break\n if exclude:\n del modified_lines[len(modified_lines)-1]\n i += 8\n continue\n modified_lines.append(lines[i])\n\n with open(report, \"w\") as filep:\n for line in modified_lines:\n filep.write(line)","def update(self):\n self.save_config_file()","def upload(self, data: dict, replace: bool = False):\n for sample_data in data[\"samples\"]:\n chanjo_sample = self.chanjo_api.sample(sample_data[\"sample\"])\n if chanjo_sample and replace:\n self.chanjo_api.delete_sample(sample_data[\"sample\"])\n elif chanjo_sample:\n LOG.warning(\"sample already loaded, skipping: %s\", sample_data[\"sample\"])\n continue\n\n LOG.debug(\"upload coverage for sample: %s\", sample_data[\"sample\"])\n self.chanjo_api.upload(\n sample_id=sample_data[\"sample\"],\n sample_name=sample_data[\"sample_name\"],\n group_id=data[\"family\"],\n group_name=data[\"family_name\"],\n bed_file=sample_data[\"coverage\"],\n )","def html_it():\n import coverage\n cov = coverage.coverage()\n cov.start()\n import here # pragma: nested\n cov.stop() # pragma: nested\n cov.html_report(directory=\"../html_other\")","def coverage_files() -> Iterable[str]:\n packs_path = CONTENT_PATH / \"Packs\"\n for cov_path in packs_path.glob(\"*/Integrations/*/.coverage\"):\n yield str(cov_path)\n for cov_path in packs_path.glob(\"*/Scripts/*/.coverage\"):\n yield str(cov_path)","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 test_run_coverage(self):\n cmd = GreenTestCommand(Distribution())\n cmd.coverage = True\n cmd.ensure_finalized()\n cmd.run()\n self.assertThat(_subprocess_call_args(), Contains(\"-r\"))","def run_test_coverage(self, build=False):\n\n # print('Running unit tests for package %s' % package)\n if self.is_metapackage:\n self.out = 'This is a metapackage'\n return 0\n\n if not self.has_test:\n self.out = 'No tests defined on CMakeLists.txt'\n return 0\n\n if build:\n self.build_for_coverage() \n\n # Capture initial zero coverage data\n self.run_lcov_cmd('--rc lcov_branch_coverage=' + self.use_branch_coverage + ' --directory build --zerocounters')\n self.run_lcov_cmd('--rc lcov_branch_coverage=' + self.use_branch_coverage + ' --capture --initial --directory build/' + self.name + ' --output-file build/lcov.base')\n\n # Run tests with coverage flags\n extra_parms = '--no-deps --cmake-args -DCMAKE_CXX_FLAGS=\"-g -O0 -Wall -fprofile-arcs -ftest-coverage\" -DCMAKE_EXE_LINKER_FLAGS=\"-fprofile-arcs -ftest-coverage\"'\n cmd = ['catkin', 'run_tests', self.name]\n cmd.extend(shlex.split(extra_parms))\n\n process = subprocess.Popen(cmd,\n stdout=subprocess.PIPE, \n stderr=subprocess.PIPE,\n universal_newlines=True)\n\n self.out , self.err = process.communicate()\n\n self.setSummary(self.get_test_summary())\n self.setExecutionStatus(process.returncode)\n\n if process.returncode != 0:\n return process.returncode\n\n # Capture coverage data after running tests\n self.run_lcov_cmd('--rc lcov_branch_coverage=' + self.use_branch_coverage + ' --no-checksum --directory build/' + self.name + ' --capture --output-file build/lcov.info')\n\n # Add baseline counters\n out, err = self.run_lcov_cmd('--rc lcov_branch_coverage=' + self.use_branch_coverage + ' --add-tracefile build/lcov.base --add-tracefile build/lcov.info --output-file build/lcov.total')\n\n # Remove coverage data for a particular set of files from the tracefile\n out, err = self.run_lcov_cmd('--rc lcov_branch_coverage=' + self.use_branch_coverage + ' --remove build/lcov.total /usr* /opt* */test/* */CMakeFiles/* */build/* --output-file build/lcov.total.cleaned')\n \n # Extract line coverage from output\n if 'lines......:' in out:\n self.coverage = float(out.split('lines......: ')[1].split('%')[0])\n else:\n self.coverage = 0\n\n return 0","def cov(test_class):\n if test_class == 'all':\n tests = unittest.TestLoader().discover('project/tests')\n else:\n # note, test module must be imported above, doing lazily for now\n test_module = globals()[test_class]\n tests = unittest.TestLoader().loadTestsFromTestCase(test_module)\n result = unittest.TextTestRunner(verbosity=2).run(tests)\n if result.wasSuccessful():\n COV.stop()\n COV.save()\n print('Coverage Summary:')\n COV.report()\n basedir = os.path.abspath(os.path.dirname(__file__))\n covdir = os.path.join(basedir, 'tmp/coverage')\n COV.html_report(directory=covdir)\n print('HTML version: file://%s/index.html' % covdir)\n COV.erase()\n return 0\n return 1","def _under_coverage_cmd(self, cmd):\n if self.run_under_coverage:\n cmd.append('--cov')\n cmd.append('--cov-report=')\n\n return cmd","def _under_coverage_cmd(self, cmd):\n if self.run_under_coverage:\n cmd.append('--cov')\n cmd.append('--cov-report=')\n\n return cmd","def _under_coverage_cmd(self, cmd):\n if self.run_under_coverage:\n cmd.append('--cov')\n if self.append_coverage:\n cmd.append('--cov-append')\n cmd.append('--cov-report=')\n\n return cmd","def find_coverage_report(folder, exclude=None, filter_out='.*conda.*'):\r\n regexp = re.compile('data_file=([0-9a-zA-Z_]+)')\r\n regcov = re.compile(\r\n '<h1>Coveragereport:<spanclass=.?pc_cov.?>([0-9]+)%</span>')\r\n regout = re.compile(filter_out) if filter_out else None\r\n covs = {}\r\n subfold = os.listdir(folder)\r\n for sub in subfold:\r\n if exclude is not None and sub in exclude:\r\n continue\r\n full = os.path.join(folder, sub)\r\n keep = []\r\n nn = None\r\n cov = None\r\n for it in explore_folder_iterfile(full):\r\n name = os.path.split(it)[-1]\r\n dt = os.stat(full).st_mtime\r\n if name == 'index.html':\r\n with open(it, 'r') as f:\r\n htd = f.read().replace('\\n', '').replace('\\r', '').replace(' ', '')\r\n cont = regcov.findall(htd)\r\n if len(cont) > 0:\r\n cov = cont[0]\r\n if name == 'covlog.txt':\r\n with open(it, 'r') as f:\r\n logd = f.read()\r\n cont = regexp.findall(logd)\r\n if len(cont) > 0:\r\n nn = cont[0]\r\n if name == '.coverage':\r\n keep.append((dt, it))\r\n if len(keep) == 0:\r\n continue\r\n mx = max(keep)\r\n if regout is not None and regout.search(nn):\r\n continue\r\n covs[sub] = (mx[-1], nn, cov)\r\n return covs","def build_for_coverage(self):\n\n extra_parms = '--cmake-args -DCMAKE_CXX_FLAGS=\"-g -O0 -Wall -fprofile-arcs -ftest-coverage\" -DCMAKE_EXE_LINKER_FLAGS=\"-fprofile-arcs -ftest-coverage\"'\n cmd = ['catkin', 'build', self.name ]\n cmd.extend(shlex.split(extra_parms))\n\n process = subprocess.Popen(cmd,\n stdout=subprocess.PIPE, \n stderr=subprocess.PIPE,\n universal_newlines=True)\n\n process.communicate()\n\n return process.returncode","def define_coverage(self, id=None, units=None, standard_name=None, coverage_dimensions=None):","def covwatch(context):\n context.run(\" \".join([\n \"python -m pytest\",\n \"--cov=%s\" % PACKAGE_NAME,\n \"--cov-branch\",\n \"--cov-fail-under=75\"\n ]))","def update_readme_data(readme_file, **readme_updates):\n\n extensions_key = \"base\"\n extensions = readme_updates[\"extensions\"]\n\n if extensions:\n extensions_key = \"-\".join(extensions)\n\n output_folder = readme_updates[\"outputsubfolder\"]\n generation_data = {\n \"location\": path_join_robust(output_folder, \"\"),\n \"entries\": readme_updates[\"numberofrules\"],\n \"sourcesdata\": readme_updates[\"sourcesdata\"],\n }\n\n with open(readme_file, \"r\") as f:\n readme_data = json.load(f)\n readme_data[extensions_key] = generation_data\n\n for denomination, data in readme_data.copy().items():\n if \"location\" in data and data[\"location\"] and \"\\\\\" in data[\"location\"]:\n # Windows compatibility: #1166\n readme_data[denomination][\"location\"] = data[\"location\"].replace(\"\\\\\", \"/\")\n\n with open(readme_file, \"w\") as f:\n json.dump(readme_data, f)","def run_gcov(filename, coverage, args):\n if args.verbose:\n warn(\"calling:\", 'gcov', '-i', filename)\n stdout = None\n else:\n # gcov is noisy and don't have quit flag so redirect stdout to /dev/null\n stdout = subprocess.DEVNULL\n\n subprocess.check_call(['gcov', '-i', filename], stdout=stdout)\n\n for gcov_file in glob('*.gcov'):\n if args.verbose:\n warn('parsing', gcov_file)\n src_file, count = parse_gcov_file(gcov_file)\n os.remove(gcov_file)\n\n if src_file not in coverage:\n coverage[src_file] = defaultdict(int, count)\n else:\n # sum execution counts\n for line, exe_cnt in count.items():\n coverage[src_file][line] += exe_cnt","def test_update_test_asset(self):\n pass","def update_from_repo():\n\treturn","def test_build_manual_run(self):\n repository = self._create_repository()\n review_request = self.create_review_request(repository=repository)\n diffset = self.create_diffset(review_request=review_request)\n diffset.base_commit_id = '8fd69d70f07b57c21ad8733c1c04ae604d21493f'\n diffset.save()\n\n config = self._create_config()\n self.integration.enable_integration()\n\n status_update = \\\n self.create_status_update(service_id='travis-ci',\n review_request=review_request)\n\n data = self._spy_on_make_request()\n\n status_update_request_run.send(sender=self.__class__,\n status_update=status_update)\n\n self.assertTrue(TravisAPI._make_request.called)\n\n self.assertEqual(\n data['url'],\n 'https://api.travis-ci.org/repo/'\n 'mypublicorg%2Fmypublicorgrepo/requests')\n\n self.assertEqual(\n data['request']['config']['env']['global'],\n [\n 'REVIEWBOARD_STATUS_UPDATE_ID=1',\n 'REVIEWBOARD_TRAVIS_INTEGRATION_CONFIG_ID=%d' % config.pk,\n ])\n\n self.assertEqual(data['request']['message'],\n 'Test Summary\\n\\nTest Description')\n self.assertTrue('git fetch --unshallow origin || true'\n in data['request']['config']['before_install'])\n self.assertTrue('git checkout %s' % diffset.base_commit_id\n in data['request']['config']['before_install'])\n self.assertEqual(data['request']['branch'], 'review-requests')","def add_cover(self):\n self.has_cover = True","def _cmd_coverage(args):\n pset = coverage.do_coverage(\n args.interval,\n args.bam_file,\n args.count,\n args.min_mapq,\n args.processes,\n args.fasta,\n )\n if not args.output:\n # Create an informative but unique name for the coverage output file\n bambase = core.fbase(args.bam_file)\n bedbase = core.fbase(args.interval)\n tgtbase = (\n \"antitargetcoverage\" if \"anti\" in bedbase.lower() else \"targetcoverage\"\n )\n args.output = f\"{bambase}.{tgtbase}.cnn\"\n if os.path.exists(args.output):\n args.output = f\"{bambase}.{bedbase}.cnn\"\n core.ensure_path(args.output)\n tabio.write(pset, args.output)","def test_upload(pytestconfig, pypi):\n #pypi_chishop.restore()\n with PkgTemplate(name='acme.tpi_test_upload') as pkg:\n pkg.create_pypirc(pypi.get_rc())\n pkg.install_package('pytest-cov')\n new_env = copy.copy(pkg.env)\n new_env['HOME'] = pkg.workspace\n print pkg.run_with_coverage(['%s/setup.py' % pkg.trunk_dir, 'sdist', 'register',\n 'upload', '--show-response'],\n pytestconfig, env=new_env, cd=HERE)\n assert os.path.isfile(os.path.join(pypi.workspace, 'chishop/media/dists/a/acme.tpi_test_upload/acme.tpi_test_upload-1.0.0.dev1.tar.gz'))\n\n import tarfile, urllib2, cStringIO\n dist_url = 'http://%s:%s/media/dists/a/acme.tpi_test_upload/acme.tpi_test_upload-1.0.0.dev1.tar.gz' % (pypi_chishop.hostname, pypi_chishop.port)\n response = urllib2.urlopen(dist_url)\n buf = response.read()\n fh = cStringIO.StringIO(buf)\n try:\n tf = tarfile.open(fileobj=fh)\n assert 'acme.tpi_test_upload-1.0.0.dev1/PKG-INFO' in tf.getnames()\n finally:\n tf.close()","def set_cover_path(self, path: str) -> None:\n self.cover_path = path\n # The cover URL is no longer required as a custom cover has been defined.\n self.cover_url = None","def fixit(file):\n with open(file, \"r\") as f:\n config = json.load(f)\n if \"job_status\" in config[\"supply-curve-aggregation\"]:\n del config[\"supply-curve-aggregation\"][\"job_status\"]\n if \"rep-profiles\" in config:\n del config[\"rep-profiles\"]\n fname = os.path.basename(file)\n cname = \"_\".join(fname.split(\"_\")[:-1]) + \"_agg\"\n config[\"supply-curve-aggregation\"][cname][\"job_status\"] = \"successful\"\n\n with open(file, \"w\") as f:\n f.write(json.dumps(config, indent=4))","def gen_svn_updated_lcov_factory(baseURL, configure_opts=[]):\n f = factory.BuildFactory()\n f.addStep(source.SVN(baseURL=baseURL, defaultBranch='trunk', mode=\"update\"))\n f.addStep(Bootstrap())\n f.addStep(shell.Configure(command = [\"sh\", \"configure\", \"--disable-shared\", \"CXXFLAGS=-O0 --coverage\"] + configure_opts, workdir=\"build/xapian-core\"))\n f.addStep(shell.Compile(workdir=\"build/xapian-core\"))\n f.addStep(shell.ShellCommand(command = [\"make\", \"coverage-check\", \"GENHTML_ARGS=--html-gzip\"], workdir=\"build/xapian-core\", haltOnFailure=True))\n f.addStep(shell.ShellCommand(command = [\"chmod\", \"-R\", \"a+rX\", \"lcov\"], workdir=\"build/xapian-core\", haltOnFailure=True))\n f.addStep(shell.ShellCommand(command = 'NOW=`date -u +%Y-%m-%d`; cp -a lcov/. /var/www/\"$NOW\" && ln -sfT \"$NOW\" /var/www/latest', workdir=\"build/xapian-core\", haltOnFailure=True))\n\n return f","def test_should_update(self):\n cutoff = datetime_utc(2016, 1, 1)\n provider = AlwaysSuccessfulCoverageProvider(\n self._db, cutoff_time = cutoff\n )\n identifier = self._identifier()\n\n # If coverage is missing, we should update.\n assert True == provider.should_update(None)\n\n # If coverage is outdated, we should update.\n record, ignore = CoverageRecord.add_for(\n identifier, provider.data_source\n )\n record.timestamp = datetime_utc(2015, 1, 1)\n assert True == provider.should_update(record)\n\n # If coverage is up-to-date, we should not update.\n record.timestamp = cutoff\n assert False == provider.should_update(record)\n\n # If coverage is only 'registered', we should update.\n record.status = CoverageRecord.REGISTERED\n assert True == provider.should_update(record)","def clean_tests(_context):\n _delete_file(COVERAGE_FILE)\n shutil.rmtree(COVERAGE_DIR, ignore_errors=True)","def test_update_asset(self):\n pass","def __fix_baseline(self, coproject):\r\n newprojs = []\r\n _logger.info(\"Looking for new projects in the check out.\")\r\n status = coproject['status']\r\n for subproj in coproject.subprojects:\r\n if subproj['status'] == status:\r\n continue \r\n _logger.info(\"New project detected in the checkout '%s'\" % subproj.objectname)\r\n purpose = None\r\n if self._config.has_key('purpose'):\r\n purpose = self._config['purpose']\r\n _logger.info(\"Using purpose: '%s'\" % purpose)\r\n \r\n version = None\r\n if self._config.has_key('version'):\r\n version = self._config['version']\r\n _logger.info(\"Using version: '%s'\" % version)\r\n\r\n result = subproj.checkout(subproj.session.create(self._config['release']), version=version, purpose=purpose, subprojects=False)\r\n _logger.info('Checkout complete')\r\n if result.project != None and result.project.exists():\r\n newcop = result.project\r\n newprojs.append(newcop)\r\n \r\n _logger.info(\"Setting is_relative to true\") \r\n if \"is_relative\" in newcop.keys():\r\n newcop[\"is_relative\"] = \"TRUE\"\r\n else:\r\n newcop.create_attribute(\"is_relative\", \"boolean\", \"TRUE\")\r\n \r\n if not self._config.get_boolean('use.reconfigure.template', False):\r\n newcop.set_update_method('manual', False)\r\n \r\n _logger.info(\"Setting the baseline to '%s'\" % subproj)\r\n newcop.set_baseline(subproj, True)\r\n \r\n _logger.info(\"Cleaning up update properties\")\r\n self._clean_update_properties(newcop)\r\n \r\n _logger.info(\"Setting update properties.\")\r\n self._set_tasks_and_folders(newcop)\r\n return newprojs","def parse(self):\n\n coverage_data = {\n 'packages': {},\n 'summary': {'lines-total': 0, 'lines-covered': 0,\n 'branches-total': 0, 'branches-covered': 0},\n 'timestamp': str(int(time.time()))\n }\n package = None\n current_file = None\n file_lines_total = 0\n file_lines_covered = 0\n file_lines = {}\n file_methods = {}\n file_branches_total = 0\n file_branches_covered = 0\n\n for line in self.lcov_data.split('\\n'):\n if line.strip() == 'end_of_record':\n if current_file is not None:\n package_dict = coverage_data['packages'][package]\n package_dict['lines-total'] += file_lines_total\n package_dict['lines-covered'] += file_lines_covered\n package_dict['branches-total'] += file_branches_total\n package_dict['branches-covered'] += file_branches_covered\n file_dict = package_dict['classes'][current_file]\n file_dict['lines-total'] = file_lines_total\n file_dict['lines-covered'] = file_lines_covered\n file_dict['lines'] = dict(file_lines)\n file_dict['methods'] = dict(file_methods)\n file_dict['branches-total'] = file_branches_total\n file_dict['branches-covered'] = file_branches_covered\n coverage_data['summary']['lines-total'] += file_lines_total\n coverage_data['summary']['lines-covered'] += file_lines_covered\n coverage_data['summary']['branches-total'] += file_branches_total\n coverage_data['summary']['branches-covered'] += file_branches_covered\n\n line_parts = line.split(':')\n input_type = line_parts[0]\n\n if input_type == 'SF':\n # Get file name\n file_name = line_parts[-1].strip()\n relative_file_name = os.path.relpath(file_name, self.base_dir)\n package = '.'.join(relative_file_name.split(os.path.sep)[0:-1])\n class_name = file_name.split(os.path.sep)[-1]\n if package not in coverage_data['packages']:\n coverage_data['packages'][package] = {\n 'classes': {}, 'lines-total': 0, 'lines-covered': 0,\n 'branches-total': 0, 'branches-covered': 0\n }\n coverage_data['packages'][package]['classes'][\n relative_file_name] = {\n 'name': class_name, 'lines': {}, 'lines-total': 0,\n 'lines-covered': 0, 'branches-total': 0,\n 'branches-covered': 0\n }\n package = package\n current_file = relative_file_name\n file_lines_total = 0\n file_lines_covered = 0\n file_lines.clear()\n file_methods.clear()\n file_branches_total = 0\n file_branches_covered = 0\n elif input_type == 'DA':\n # DA:2,0\n (line_number, line_hits) = line_parts[-1].strip().split(',')\n line_number = int(line_number)\n if line_number not in file_lines:\n file_lines[line_number] = {\n 'branch': 'false', 'branches-total': 0,\n 'branches-covered': 0\n }\n file_lines[line_number]['hits'] = line_hits\n # Increment lines total/covered for class and package\n if int(line_hits) > 0:\n file_lines_covered += 1\n file_lines_total += 1\n elif input_type == 'BRDA':\n # BRDA:1,1,2,0\n (line_number, block_number, branch_number, branch_hits) = line_parts[-1].strip().split(',')\n line_number = int(line_number)\n if line_number not in file_lines:\n file_lines[line_number] = {\n 'branch': 'true', 'branches-total': 0,\n 'branches-covered': 0, 'hits': 0\n }\n file_lines[line_number]['branch'] = 'true'\n file_lines[line_number]['branches-total'] += 1\n file_branches_total += 1\n if branch_hits != '-' and int(branch_hits) > 0:\n file_lines[line_number]['branches-covered'] += 1\n file_branches_covered += 1\n elif input_type == 'BRF':\n file_branches_total = int(line_parts[1])\n elif input_type == 'BRH':\n file_branches_covered = int(line_parts[1])\n elif input_type == 'FN':\n # FN:5,(anonymous_1)\n function_name = line_parts[-1].strip().split(',')[1]\n function_name = self.demangle_function_name(function_name)\n file_methods[function_name] = '0'\n elif input_type == 'FNDA':\n # FNDA:0,(anonymous_1)\n (function_hits, function_name) = line_parts[-1].strip().split(',')\n function_name = self.demangle_function_name(function_name)\n file_methods[function_name] = function_hits\n\n # Exclude packages\n excluded = [x for x in coverage_data['packages'] for e in self.excludes\n if re.match(e, x)]\n for package in excluded:\n del coverage_data['packages'][package]\n\n # Compute line coverage rates\n for package_data in list(coverage_data['packages'].values()):\n package_data['line-rate'] = self._percent(\n package_data['lines-total'],\n package_data['lines-covered'])\n package_data['branch-rate'] = self._percent(\n package_data['branches-total'],\n package_data['branches-covered'])\n\n return coverage_data","def update(self, co_dir):\n self.run_task(' '.join(['svn', 'up', co_dir]))\n pass","def test_update_test_asset_content(self):\n pass","def on_finalize(event, context):\n global gcs\n if not gcs:\n gcs = storage.Client()\n\n print('Processing InSpec report: %s' % event['name'])\n bucket = storage.Bucket(name=event['bucket'], client=gcs)\n blob = bucket.blob(event['name'])\n report_str = blob.download_as_string()\n report = json.loads(report_str)\n\n scc_source = os.environ.get('SCC_SOURCE',\n 'SCC_SOURCE environment variable is not set.')\n _inspec_report_to_scc(report, scc_source)","def test_update_system_asset(self):\n pass","def derive_project_coverage(self) -> None:\n self.get_project_column_description_coverage()\n self.get_project_test_coverage()","def test_update_asset_content(self):\n pass","def update_repo(self):\n utils.render_template_to_file(\n self.repo_template_path,\n self.repo_config_path,\n {\n 'name': '{0}_nailgun'.format(self.version),\n 'baseurl': self.host_system_config['repo_master'],\n 'gpgcheck': 0,\n 'skip_if_unavailable': 0,\n })\n utils.exec_cmd('yum clean all')","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 update_node_coverage(G, node, new_cov):\n if node not in G.nodes(): # nothing to be done, perhaps already removed\n return\n if new_cov == 0:\n G.remove_node(node)\n if rc_node(node) in G.nodes():\n G.remove_node(rc_node(node))\n else:\n G.add_node(node, cov=new_cov)\n if rc_node(node) in G.nodes():\n G.add_node(rc_node(node), cov=new_cov)","def update():\n siteconfig = configparser.RawConfigParser()\n siteconfig.readfp(open(\"/etc/gitzillarc\"))\n sRepo = os.getcwd()\n\n logger = get_logger(siteconfig)\n oBugRegex = get_bug_regex(siteconfig)\n sRefPrefix = get_or_default(siteconfig, sRepo, \"git_ref_prefix\")\n sSeparator = get_or_default(siteconfig, sRepo, \"separator\")\n\n bRequireBugNumber = to_bool(get_or_default(siteconfig, sRepo, \"require_bug_ref\", True))\n asAllowedStatuses = None\n if has_option_or_default(siteconfig, sRepo, \"allowed_bug_states\"):\n asAllowedStatuses = [x.strip() for x in get_or_default(siteconfig, sRepo, \"allowed_bug_states\").split(\",\")]\n\n # and the bugzilla info.\n userconfig = configparser.RawConfigParser()\n userconfig.read(os.path.expanduser(\"~/.gitzillarc\"))\n (sBZUrl, sBZUser, sBZPasswd) = get_bz_data(siteconfig, userconfig)\n\n gitzilla.hooks.update(oBugRegex, asAllowedStatuses, sSeparator, sBZUrl,\n sBZUser, sBZPasswd, logger, None, sRefPrefix,\n bRequireBugNumber)","def qsim_save_coverage(ucdb, region, param):\n \n print(\"ucdb=\" + str(ucdb) + \" region=\" + str(region) + \" param=\" + str(param))\n # Load the UCIS library and initialize the Python\n # interface\n UcdbFactory.load_ucdb_library(\"libucdb.so\")\n \n db = UcdbUCIS(db=ucdb)\n covergroups = CoverageRegistry.inst().covergroup_types()\n save_visitor = CoverageSaveVisitor(db)\n \n save_visitor.save(None, covergroups)\n \n pass","def convert(self):\n coverage_data = self.parse()\n return self.generate_cobertura_xml(coverage_data)","def fill_in_zero_cov(all_coverage, depth_file):\n f_in = open(depth_file, \"r\")\n for line in f_in:\n if line.startswith(\"#\"):\n continue\n if not line.strip():\n continue # if the last line is blank\n # print(depth_filename)\n ref, possition, coverage = line.rstrip(\"\\n\").split(\"\\t\")\n possition = int(possition) - 1\n # assign the correct coverage to the relavent postiton,\n # thus removing the zero value.\n # Or if there is no info, it remains as a zero.\n all_coverage[possition] = int(coverage)\n f_in.close()\n return all_coverage","def task_test():\n return {\n \"actions\": [[\"pytest\", \"--cov=mad_gui\", \"--cov-config=.coveragerc\", \"-vv\"]],\n \"verbosity\": 2,\n }","def test_update_software_asset(self):\n pass","def generate_report():\n if os.path.isdir(\"build/coverage\"):\n shutil.rmtree(\"build/coverage\")\n commands = '''\nscons -uij32 --optimization=coverage controller/cplusplus_test\nlcov --base-directory build/coverage --directory build/coverage -c -o build/coverage/controller_test.info\ngenhtml -o build/coverage/controller/test_coverage -t test --num-spaces 4 build/coverage/controller_test.info\n'''\n for cmd in commands.splitlines():\n cmd_args = cmd.split()\n if (len(cmd_args) == 0):\n continue\n cmd = cmd_args[0]\n cmd_path = find_executable(cmd)\n if not cmd_path:\n continue\n pid = os.fork()\n if pid == 0:\n # Avoid stdout buffering by execing command into child process.\n os.execv(cmd_path, cmd_args)\n os.waitpid(pid, 0)","def saveInGit(file_content, file_name, report_date):\n file_path = \"/\".join([crs_reports_dir,file_name])\n existed = os.path.isfile(file_path) \n if existed:\n # TODO Check that this specific version of this file isn't already\n # in the comment history\n pass\n with open(file_path, 'w') as f: \n f.write(file_content)\n f.close()\n gitAdd(file_name, crs_reports_dir)\n if existed:\n # TODO Set the commit date to be the CRS release date\n gitCommit(file_name, crs_reports_dir, '%s was updated' % file_name,\n report_date)\n else:\n gitCommit(file_name, crs_reports_dir, 'Added %s' % file_name,\n report_date)\n \n \n \n # 1.) If file_name exists:\n # 1.)overwrite it, \n # 2.) Commit an update to the file_name\n # else:\n # 1.) Create and save a new file\n # 2.) Commit the new file","def testUpdateConfigFile(self):\n # Test update project field.\n gcp_setup_runner.UpdateConfigFile(self.cfg_path, \"project\",\n \"test_project\")\n cfg = config.AcloudConfigManager.LoadConfigFromProtocolBuffer(\n open(self.cfg_path, \"r\"), user_config_pb2.UserConfig)\n self.assertEqual(cfg.project, \"test_project\")\n self.assertEqual(cfg.ssh_private_key_path, \"\")\n # Test add ssh key path in config.\n gcp_setup_runner.UpdateConfigFile(self.cfg_path,\n \"ssh_private_key_path\", \"test_path\")\n cfg = config.AcloudConfigManager.LoadConfigFromProtocolBuffer(\n open(self.cfg_path, \"r\"), user_config_pb2.UserConfig)\n self.assertEqual(cfg.project, \"test_project\")\n self.assertEqual(cfg.ssh_private_key_path, \"test_path\")\n # Test config is not a file\n with mock.patch(\"os.path.isfile\") as chkfile:\n chkfile.return_value = False\n gcp_setup_runner.UpdateConfigFile(self.cfg_path, \"project\",\n \"test_project\")\n cfg = config.AcloudConfigManager.LoadConfigFromProtocolBuffer(\n open(self.cfg_path, \"r\"), user_config_pb2.UserConfig)\n self.assertEqual(cfg.project, \"test_project\")","def coverage(self, file, **options):\n\n options['file'] = file\n\n return self._get('coverage', **options)","def generate_coverage_reports(project, output_dir=None):\n outdir = output_dir or os.path.join(project.sdk_directory, \"coverage-results\")\n sdir = project.path\n # Make sure output dir exists and is empty:\n qisys.sh.rm(outdir)\n qisys.sh.mkdir(outdir, recursive=True)\n formats = {\"xml\": [\"--xml\"],\n \"html\": [\"--html\", \"--html-details\"]}\n for fmt, opts in formats.items():\n base_report = os.path.join(outdir, project.name + \".\" + fmt)\n cmd = [\"gcovr\",\n \"--root\", sdir,\n \"--exclude\", \".*test.*\",\n \"--exclude\", \".*external.*\",\n \"--exclude\", \".*example.*\"] + opts + \\\n [\"--output\", base_report]\n qisys.command.call(cmd, cwd=sdir, quiet=True)\n ui.info(ui.green, \"*\", ui.reset, \"Generated\", fmt.upper(),\n \"coverage report in\", ui.reset, ui.bold, base_report)","def report(self, output_dir):","def update_readme():\n\n temp = \"\"\"<head>\n <title>Unittest Results</title>\n <meta charset=\"utf-8\">\n <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n <link rel=\"stylesheet\" href=\"https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css\" integrity=\"sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7\" crossorigin=\"anonymous\">\n</head>\"\"\"\n\n with open(\"README_proxy.md\", \"r\") as old_readme_file:\n old_readme_txt = old_readme_file.read()\n\n with open(\"reports/test_result.html\", \"r\") as html_file:\n html = html_file.read().splitlines()[0:-21]\n html = \"\\n\".join(html).replace(temp, \"\")\n\n with open(\"README.md\", \"w\") as new_readme_file:\n new_readme_file.write(old_readme_txt + \"\\n\\n\\n\" + html + \"</body></html>\")","def update(filepath, github_account):\n repo = _git.clone_from_github(\n _repo_path(), join(filepath, _repo_name()), github_account=github_account)\n if _update_disco(repo, github_account) > 0:\n repo.push()","def _configure(self):\n test_lib.test_config.setdefault('config_files', []).append(\n self.filename)\n self._write_config_content()","def set_cover(self, file_name, content, create_page=True):\n\n # as it is now, it can only be called once\n c0 = EpubCover(file_name=file_name)\n c0.content = content\n self.add_item(c0)\n\n if create_page:\n c1 = EpubCoverHtml(image_name=file_name)\n self.add_item(c1)\n\n self.add_metadata(None, 'meta', '', OrderedDict([('name', 'cover'), ('content', 'cover-img')]))","def generate_url(coverage_pct: float) -> str:\n color = \"yellow\"\n if coverage_pct == 100:\n color = \"brightgreen\"\n elif coverage_pct > 90:\n color = \"green\"\n elif coverage_pct > 70:\n color = \"yellowgreen\"\n elif coverage_pct > 50:\n color = \"yellow\"\n else:\n color = \"orange\"\n\n return f\"https://img.shields.io/badge/coverage-{coverage_pct}%25-{color}\"","def test(coverage, test_names):\n if coverage and not os.environ.get('FLASK_COVERAGE'):\n import subprocess\n os.environ['FLASK_COVERAGE'] = '1'\n sys.exit(subprocess.call(sys.argv))\n\n import unittest\n if test_names:\n tests = unittest.TestLoader().loadTestsFromNames(test_names)\n else:\n tests = unittest.TestLoader().discover('tests')\n unittest.TextTestRunner(verbosity=2).run(tests)\n if COV:\n COV.stop()\n COV.save()\n print('Coverage Summary:')\n COV.report()\n basedir = os.path.abspath(os.path.dirname(__file__))\n covdir = os.path.join(basedir, 'tmp/coverage')\n COV.html_report(directory=covdir)\n print('HTML version: file://%s/index.html' % covdir)\n COV.erase()","def test(conanfile):\n with conanfile_exception_formatter(conanfile, \"test\"):\n with chdir(conanfile.build_folder):\n conanfile.test()","def _ReadCoverageInfoMessage(message):\n\n cov_info = {}\n\n for file_cov_msg in message.file_coverage:\n file_path = os.path.abspath(file_cov_msg.file_name)\n cov_info[file_path] = set(file_cov_msg.covered_lines)\n\n return cov_info","def pytest_sessionfinish(session, exitstatus):\n if not updated_files:\n return\n print('\\n\\nInomaly Complete, Updated these files\\n')\n for filepath in updated_files:\n print('\\t%s' % filepath)","def statusupdate(filepath):\n pass","def test_update_test_asset_impact_level(self):\n pass","def test_update_software_asset_content(self):\n pass","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 test_download_deployment_run_test_report(self):\n pass","def clear_coverage(bv=None):\n if covdb and len(covdb.coverage_files) > 0:\n remove_highlights()\n clear_globals()\n log.log_info(\"[*] Coverage information cleared\")"],"string":"[\n \"def cover(ctx, html=False):\\n header(cover.__doc__)\\n extra = \\\"--cov-report html\\\" if html else \\\"\\\"\\n with ctx.cd(ROOT):\\n ctx.run(\\n \\\"pytest --benchmark-skip --cov flask_restx --cov-report term --cov-report xml {0}\\\".format(\\n extra\\n ),\\n pty=True,\\n )\",\n \"def task_coverage():\\n return {\\n 'actions': ['py.test --cov nikola --cov-report term-missing tests/'],\\n 'verbosity': 2,\\n }\",\n \"def coverage(session) -> None:\\n session.install(\\\".[test]\\\", \\\"pytest-cov\\\")\\n session.run(\\n \\\"pytest\\\", \\\"-n\\\", \\\"auto\\\", \\\"--cov=./\\\", \\\"--cov-report=xml\\\", *session.posargs\\n )\",\n \"def cuv(ctx, coverage_fname, exclude, branch):\\n if coverage_fname is None:\\n coverage_fname = find_coverage_data('.')\\n # coverage_fname still could be None\\n\\n cfg = Config()\\n ctx.obj = cfg\\n\\n cfg.nice_width = min(80, shutil.get_terminal_size()[0])\\n cfg.exclude = exclude\\n\\n cfg.branch = branch\\n if coverage_fname is not None:\\n cfg.data = coverage.Coverage(data_file=coverage_fname)\\n cfg.data.load()\\n else:\\n raise click.UsageError(\\n \\\"No coverage data. Do you have a .coverage file?\\\"\\n )\",\n \"def coverage(session):\\n session.install(\\\"coverage[toml]\\\", \\\"codecov\\\")\\n session.run(\\\"coverage\\\", \\\"xml\\\", \\\"--fail-under=0\\\")\\n session.run(\\\"codecov\\\", *session.posargs)\",\n \"def set_coverage(self, coverage): \\n self.coverage = coverage\\n if os.path.isfile(TESTS_PATH + \\\"/\\\" + self.name):\\n os.rename(TESTS_PATH + \\\"/\\\" + self.name, TESTS_PATH + \\\"/\\\" \\\\\\n + self.app_pkg + \\\"_\\\"+self.timestamp + \\\"_\\\" \\\\\\n + str(coverage) + \\\".sh\\\")\\n else:\\n f_out = open(TESTS_PATH + \\\"/\\\" + self.app_pkg + \\\"_\\\"+self.timestamp \\\\\\n + \\\"_\\\" + str(coverage) + \\\".sh\\\", \\\"w\\\")\\n f_out.write(self.script)\\n f_out.close()\\n self.name = self.app_pkg + \\\"_\\\" + self.timestamp + \\\"_\\\" + str(coverage) + \\\".sh\\\"\",\n \"def upload_coverage(self, name, directory):\\n logging.info('Not uploading coverage because no Filestore.')\",\n \"def coverage(ctx):\\n ctx.run(\\\"coverage run --source {PROJECT_NAME} -m pytest\\\".format(PROJECT_NAME=PROJECT_NAME))\\n ctx.run(\\\"coverage report -m\\\")\\n ctx.run(\\\"coverage html\\\")\",\n \"def cov():\\n cov = coverage.coverage(branch=True, include='project/*')\\n cov.start()\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\\n cov.stop()\\n cov.save()\\n print('Coverage Summary:')\\n cov.report()\\n basedir = os.path.abspath(os.path.dirname(__file__))\\n covdir = os.path.join(basedir, 'tmp/coverage')\\n cov.html_report(directory=covdir)\\n print('HTML version: file://%s/index.html' % covdir)\\n cov.erase()\",\n \"def cov():\\n cov = coverage.coverage(\\n branch=True,\\n include='project/*',\\n omit=\\\"*/__init__.py\\\"\\n )\\n cov.start()\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\\n cov.stop()\\n cov.save()\\n print 'Coverage Summary:'\\n cov.report()\\n basedir = os.path.abspath(os.path.dirname(__file__))\\n covdir = os.path.join(basedir, 'tmp/coverage')\\n cov.html_report(directory=covdir)\\n print('HTML version: file://%s/index.html' % covdir)\\n cov.erase()\",\n \"def test(coverage):\\n print('success')\\n pass\",\n \"def _update_coverage(self, msg, subtype, by):\\n try:\\n coverage = self.get_local(msg, \\\"coverage\\\")\\n except KeyError:\\n coverage = defaultdict(int)\\n coverage[\\\"all\\\"] += by\\n coverage[subtype] += by\\n self.set_local(msg, \\\"coverage\\\", coverage)\",\n \"def generate_cobertura_xml(self, coverage_data):\\n\\n dom_impl = minidom.getDOMImplementation()\\n doctype = dom_impl.createDocumentType(\\\"coverage\\\", None,\\n \\\"http://cobertura.sourceforge.net/xml/coverage-03.dtd\\\")\\n document = dom_impl.createDocument(None, \\\"coverage\\\", doctype)\\n root = document.documentElement\\n summary = coverage_data['summary']\\n self._attrs(root, {\\n 'branch-rate': self._percent(summary['branches-total'],\\n summary['branches-covered']),\\n 'branches-covered': str(summary['branches-covered']),\\n 'branches-valid': str(summary['branches-total']),\\n 'complexity': '0',\\n 'line-rate': self._percent(summary['lines-total'],\\n summary['lines-covered']),\\n 'lines-valid': str(summary['lines-total']),\\n 'timestamp': coverage_data['timestamp'],\\n 'version': '1.9'\\n })\\n\\n sources = self._el(document, 'sources', {})\\n source = self._el(document, 'source', {})\\n source.appendChild(document.createTextNode(self.base_dir))\\n sources.appendChild(source)\\n\\n root.appendChild(sources)\\n\\n packages_el = self._el(document, 'packages', {})\\n\\n packages = coverage_data['packages']\\n for package_name, package_data in list(packages.items()):\\n package_el = self._el(document, 'package', {\\n 'line-rate': package_data['line-rate'],\\n 'branch-rate': package_data['branch-rate'],\\n 'name': package_name\\n })\\n classes_el = self._el(document, 'classes', {})\\n for class_name, class_data in list(package_data['classes'].items()):\\n class_el = self._el(document, 'class', {\\n 'branch-rate': self._percent(class_data['branches-total'],\\n class_data['branches-covered']),\\n 'complexity': '0',\\n 'filename': class_name,\\n 'line-rate': self._percent(class_data['lines-total'],\\n class_data['lines-covered']),\\n 'name': class_data['name']\\n })\\n\\n # Process methods\\n methods_el = self._el(document, 'methods', {})\\n for method_name, hits in list(class_data['methods'].items()):\\n method_el = self._el(document, 'method', {\\n 'name': method_name,\\n 'signature' : '',\\n 'hits': hits\\n })\\n methods_el.appendChild(method_el)\\n\\n # Process lines\\n lines_el = self._el(document, 'lines', {})\\n lines = list(class_data['lines'].keys())\\n lines.sort()\\n for line_number in lines:\\n line_el = self._el(document, 'line', {\\n 'branch': class_data['lines'][line_number]['branch'],\\n 'hits': str(class_data['lines'][line_number]['hits']),\\n 'number': str(line_number)\\n })\\n if class_data['lines'][line_number]['branch'] == 'true':\\n total = int(class_data['lines'][line_number]['branches-total'])\\n covered = int(class_data['lines'][line_number]['branches-covered'])\\n percentage = int((covered * 100.0) / total)\\n line_el.setAttribute('condition-coverage',\\n '{0}% ({1}/{2})'.format(\\n percentage, covered, total))\\n lines_el.appendChild(line_el)\\n\\n class_el.appendChild(methods_el)\\n class_el.appendChild(lines_el)\\n classes_el.appendChild(class_el)\\n package_el.appendChild(classes_el)\\n packages_el.appendChild(package_el)\\n root.appendChild(packages_el)\\n\\n return document.toprettyxml()\",\n \"def main():\\n import coverage\\n import nose\\n import os\\n from shutil import rmtree\\n rmtree('./covhtml', ignore_errors=True)\\n try:\\n os.remove('./.coverage')\\n except Exception,e:\\n pass\\n\\n # run nose in its own process because the .coverage file isn't written\\n # until the process terminates and we need to read it\\n nose.run()\",\n \"def download_coverage(self, name, dst_directory):\\n logging.info('Not downloading coverage because no Filestore.')\",\n \"def gcov_it(version, num):\\n subprocess.run([\\\"gcov-7\\\", \\\"-i\\\", \\\"replace.c\\\"],\\n cwd=CWD_PREFIX+str(version))\\n gcov = open(\\\"replace/versions.alt/versions.orig/v\\\" + str(version) +\\n \\\"/replace.c.gcov\\\", 'r')\\n out = []\\n for line in gcov:\\n info = line.split(':')[1].split(',')\\n if line[0]=='l' and int(info[1]):\\n out.append(\\\"cover(T{},S{})\\\".format(str(num), info[0]))\\n gcov.close()\\n subprocess.run([\\\"rm\\\", \\\"replace/versions.alt/versions.orig/v\\\" +\\n str(version) + \\\"/replace.gcda\\\"])\\n return out\",\n \"def run(self):\\n cmd = 'coverage run setup.py test && coverage report -m'\\n check_call(cmd, shell=True)\",\n \"def coverage(context):\\n context.run(\\\" \\\".join([\\n \\\"python -m pytest\\\",\\n \\\"--cov=%s\\\" % PACKAGE_NAME,\\n \\\"--cov-report html\\\",\\n \\\"--cov-branch\\\",\\n \\\"--cov-fail-under=75\\\"\\n ]))\",\n \"def test_coverage_2(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"coverage-example-selfpay.json\\\"\\n inst = coverage.Coverage.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Coverage\\\" == inst.resource_type\\n\\n impl_coverage_2(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Coverage\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = coverage.Coverage(**data)\\n impl_coverage_2(inst2)\",\n \"def cov():\\n tests = unittest.TestLoader().discover('project/tests')\\n result = unittest.TextTestRunner(verbosity=2).run(tests)\\n if result.wasSuccessful():\\n COV.stop()\\n COV.save()\\n print('Coverage Summary:')\\n COV.report()\\n basedir = os.path.abspath(os.path.dirname(__file__))\\n covdir = os.path.join(basedir, 'tmp/coverage')\\n COV.html_report(directory=covdir)\\n print('HTML version: file://%s/index.html' % covdir)\\n COV.erase()\\n return 0\\n return 1\",\n \"def test_coverage_4(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"coverage-example.json\\\"\\n inst = coverage.Coverage.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Coverage\\\" == inst.resource_type\\n\\n impl_coverage_4(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Coverage\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = coverage.Coverage(**data)\\n impl_coverage_4(inst2)\",\n \"def coverage():\\n print(\\\"Coverage tests always re-run\\\")\\n with safe_cd(SRC):\\n my_env = config_pythonpath()\\n # You will need something like this in pytest.ini\\n # By default, pytest is VERY restrictive in the file names it will match.\\n #\\n # [pytest]\\n # DJANGO_SETTINGS_MODULE = core.settings\\n # python_files = tests.py test_*.py *_tests.py test*_*.py *_test*.py\\n if not os.path.exists(\\\"pytest.ini\\\") and IS_DJANGO:\\n print(\\n \\\"pytest.ini MUST exist for Django test detection or too few tests are found.\\\"\\n )\\n exit(-1)\\n return\\n\\n my_env = config_pythonpath()\\n command = \\\"{0} py.test {1} --cov={2} --cov-report html:coverage --cov-fail-under 55 --verbose\\\".format(\\n PIPENV, \\\"test\\\", PROJECT_NAME\\n )\\n execute_with_environment(command, my_env)\",\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 run_coverage(session):\\n set_environment_variables(PYBAMM_ENV, session=session)\\n session.run_always(\\\"pip\\\", \\\"install\\\", \\\"coverage\\\")\\n session.run_always(\\\"pip\\\", \\\"install\\\", \\\"-e\\\", \\\".[all]\\\")\\n if sys.platform != \\\"win32\\\":\\n session.run_always(\\\"pip\\\", \\\"install\\\", \\\"-e\\\", \\\".[odes]\\\")\\n session.run_always(\\\"pip\\\", \\\"install\\\", \\\"-e\\\", \\\".[jax]\\\")\\n session.run(\\\"coverage\\\", \\\"run\\\", \\\"--rcfile=.coveragerc\\\", \\\"run-tests.py\\\", \\\"--nosub\\\")\\n session.run(\\\"coverage\\\", \\\"combine\\\")\\n session.run(\\\"coverage\\\", \\\"xml\\\")\",\n \"def cov():\\n tests = unittest.TestLoader().discover('tests')\\n result = unittest.TextTestRunner(verbosity=1).run(tests)\\n if result.wasSuccessful():\\n COV.stop()\\n COV.save()\\n print('Coverage Summary:')\\n COV.report()\\n basedir = os.path.abspath(os.path.dirname(__file__))\\n covdir = os.path.join(basedir, 'tmp/coverage')\\n COV.html_report(directory=covdir)\\n print('HTML version: file://%s/index.html' % covdir)\\n COV.erase()\\n return 0\\n return 1\",\n \"def test_coverage_1(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"coverage-example-2.json\\\"\\n inst = coverage.Coverage.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Coverage\\\" == inst.resource_type\\n\\n impl_coverage_1(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Coverage\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = coverage.Coverage(**data)\\n impl_coverage_1(inst2)\",\n \"def cov():\\n tests = unittest.TestLoader().discover('project/tests')\\n result = unittest.TextTestRunner(verbosity=2).run(tests)\\n if result.wasSuccessful():\\n COV.stop()\\n COV.save()\\n print('Coverage Summary:')\\n COV.report()\\n COV.html_report()\\n COV.erase()\\n return 0\\n return 1\",\n \"def test_coverage_3(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"coverage-example-ehic.json\\\"\\n inst = coverage.Coverage.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"Coverage\\\" == inst.resource_type\\n\\n impl_coverage_3(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"Coverage\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = coverage.Coverage(**data)\\n impl_coverage_3(inst2)\",\n \"def coverage_init(reg, options):\\n from .coveragepy import CoveragePlugin\\n\\n reg.add_file_tracer(CoveragePlugin())\",\n \"def _update_disco(repo: _git.Repository, github_account: accounts.GitHubAccount) -> int:\\n with TemporaryDirectory() as gopath:\\n os.makedirs(join(gopath, 'src'))\\n check_output(['ln', '-s',\\n join(repo.filepath, 'src'),\\n join(gopath, 'src/discovery-artifact-manager')])\\n env = os.environ.copy()\\n env['GOPATH'] = gopath\\n check_output(['go', 'run', 'src/main/updatedisco/main.go'],\\n cwd=repo.filepath,\\n env=env)\\n repo.add(['discoveries'])\\n if not repo.diff_name_status():\\n return 0\\n repo.commit('Autogenerated Discovery document update',\\n github_account.name,\\n github_account.email)\\n return 1\",\n \"def _save_coverage_info(self, filename, file_line_info, ignore_missing_files):\\n lcov_path = self.project_path('s2e-last', filename)\\n\\n logger.info('Writing line coverage to %s', lcov_path)\\n\\n with open(lcov_path, 'w') as f:\\n f.write('TN:\\\\n')\\n for src_file in file_line_info.keys():\\n if ignore_missing_files and not os.path.exists(src_file):\\n logger.warn('%s does not exist, skipping', src_file)\\n continue\\n else:\\n logger.info(src_file)\\n\\n num_non_zero_lines = 0\\n num_instrumented_lines = 0\\n\\n f.write('SF:%s\\\\n' % src_file)\\n for line, count in file_line_info[src_file].items():\\n f.write('DA:%d,%d\\\\n' % (line, count))\\n\\n if count:\\n num_non_zero_lines += 1\\n num_instrumented_lines += 1\\n f.write('LH:%d\\\\n' % num_non_zero_lines)\\n f.write('LF:%d\\\\n' % num_instrumented_lines)\\n f.write('end_of_record\\\\n')\\n\\n return lcov_path\",\n \"def test():\\n with lcd(BASEDIR):\\n local('virtenv/bin/coverage run runtests.py -v2')\\n local('virtenv/bin/coverage report -m')\",\n \"def fix_report(report):\\n if not os.path.isfile(report):\\n print(\\\"Error! Coverage report file %s not found!\\\" % report)\\n return\\n\\n shutil.move(report, report + \\\".orig\\\")\\n exclude_list = [\\n r\\\"boost\\\",\\n r\\\"build\\\\/debug\\\\/\\\",\\n r\\\"build\\\\/coverage\\\\/\\\",\\n r\\\"build\\\\/include\\\\/\\\",\\n r\\\"\\\\/test\\\",\\n r\\\"usr\\\\/\\\",\\n ]\\n\\n modified_lines = []\\n lines = []\\n with open(report + \\\".orig\\\", \\\"r\\\") as filep:\\n lines = filep.readlines()\\n i = -1\\n while True:\\n i += 1\\n if i >= len(lines):\\n break\\n exclude = False\\n for pattern in exclude_list:\\n if re.search(pattern, lines[i]):\\n exclude = True\\n break\\n if exclude:\\n del modified_lines[len(modified_lines)-1]\\n i += 8\\n continue\\n modified_lines.append(lines[i])\\n\\n with open(report, \\\"w\\\") as filep:\\n for line in modified_lines:\\n filep.write(line)\",\n \"def update(self):\\n self.save_config_file()\",\n \"def upload(self, data: dict, replace: bool = False):\\n for sample_data in data[\\\"samples\\\"]:\\n chanjo_sample = self.chanjo_api.sample(sample_data[\\\"sample\\\"])\\n if chanjo_sample and replace:\\n self.chanjo_api.delete_sample(sample_data[\\\"sample\\\"])\\n elif chanjo_sample:\\n LOG.warning(\\\"sample already loaded, skipping: %s\\\", sample_data[\\\"sample\\\"])\\n continue\\n\\n LOG.debug(\\\"upload coverage for sample: %s\\\", sample_data[\\\"sample\\\"])\\n self.chanjo_api.upload(\\n sample_id=sample_data[\\\"sample\\\"],\\n sample_name=sample_data[\\\"sample_name\\\"],\\n group_id=data[\\\"family\\\"],\\n group_name=data[\\\"family_name\\\"],\\n bed_file=sample_data[\\\"coverage\\\"],\\n )\",\n \"def html_it():\\n import coverage\\n cov = coverage.coverage()\\n cov.start()\\n import here # pragma: nested\\n cov.stop() # pragma: nested\\n cov.html_report(directory=\\\"../html_other\\\")\",\n \"def coverage_files() -> Iterable[str]:\\n packs_path = CONTENT_PATH / \\\"Packs\\\"\\n for cov_path in packs_path.glob(\\\"*/Integrations/*/.coverage\\\"):\\n yield str(cov_path)\\n for cov_path in packs_path.glob(\\\"*/Scripts/*/.coverage\\\"):\\n yield str(cov_path)\",\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 test_run_coverage(self):\\n cmd = GreenTestCommand(Distribution())\\n cmd.coverage = True\\n cmd.ensure_finalized()\\n cmd.run()\\n self.assertThat(_subprocess_call_args(), Contains(\\\"-r\\\"))\",\n \"def run_test_coverage(self, build=False):\\n\\n # print('Running unit tests for package %s' % package)\\n if self.is_metapackage:\\n self.out = 'This is a metapackage'\\n return 0\\n\\n if not self.has_test:\\n self.out = 'No tests defined on CMakeLists.txt'\\n return 0\\n\\n if build:\\n self.build_for_coverage() \\n\\n # Capture initial zero coverage data\\n self.run_lcov_cmd('--rc lcov_branch_coverage=' + self.use_branch_coverage + ' --directory build --zerocounters')\\n self.run_lcov_cmd('--rc lcov_branch_coverage=' + self.use_branch_coverage + ' --capture --initial --directory build/' + self.name + ' --output-file build/lcov.base')\\n\\n # Run tests with coverage flags\\n extra_parms = '--no-deps --cmake-args -DCMAKE_CXX_FLAGS=\\\"-g -O0 -Wall -fprofile-arcs -ftest-coverage\\\" -DCMAKE_EXE_LINKER_FLAGS=\\\"-fprofile-arcs -ftest-coverage\\\"'\\n cmd = ['catkin', 'run_tests', self.name]\\n cmd.extend(shlex.split(extra_parms))\\n\\n process = subprocess.Popen(cmd,\\n stdout=subprocess.PIPE, \\n stderr=subprocess.PIPE,\\n universal_newlines=True)\\n\\n self.out , self.err = process.communicate()\\n\\n self.setSummary(self.get_test_summary())\\n self.setExecutionStatus(process.returncode)\\n\\n if process.returncode != 0:\\n return process.returncode\\n\\n # Capture coverage data after running tests\\n self.run_lcov_cmd('--rc lcov_branch_coverage=' + self.use_branch_coverage + ' --no-checksum --directory build/' + self.name + ' --capture --output-file build/lcov.info')\\n\\n # Add baseline counters\\n out, err = self.run_lcov_cmd('--rc lcov_branch_coverage=' + self.use_branch_coverage + ' --add-tracefile build/lcov.base --add-tracefile build/lcov.info --output-file build/lcov.total')\\n\\n # Remove coverage data for a particular set of files from the tracefile\\n out, err = self.run_lcov_cmd('--rc lcov_branch_coverage=' + self.use_branch_coverage + ' --remove build/lcov.total /usr* /opt* */test/* */CMakeFiles/* */build/* --output-file build/lcov.total.cleaned')\\n \\n # Extract line coverage from output\\n if 'lines......:' in out:\\n self.coverage = float(out.split('lines......: ')[1].split('%')[0])\\n else:\\n self.coverage = 0\\n\\n return 0\",\n \"def cov(test_class):\\n if test_class == 'all':\\n tests = unittest.TestLoader().discover('project/tests')\\n else:\\n # note, test module must be imported above, doing lazily for now\\n test_module = globals()[test_class]\\n tests = unittest.TestLoader().loadTestsFromTestCase(test_module)\\n result = unittest.TextTestRunner(verbosity=2).run(tests)\\n if result.wasSuccessful():\\n COV.stop()\\n COV.save()\\n print('Coverage Summary:')\\n COV.report()\\n basedir = os.path.abspath(os.path.dirname(__file__))\\n covdir = os.path.join(basedir, 'tmp/coverage')\\n COV.html_report(directory=covdir)\\n print('HTML version: file://%s/index.html' % covdir)\\n COV.erase()\\n return 0\\n return 1\",\n \"def _under_coverage_cmd(self, cmd):\\n if self.run_under_coverage:\\n cmd.append('--cov')\\n cmd.append('--cov-report=')\\n\\n return cmd\",\n \"def _under_coverage_cmd(self, cmd):\\n if self.run_under_coverage:\\n cmd.append('--cov')\\n cmd.append('--cov-report=')\\n\\n return cmd\",\n \"def _under_coverage_cmd(self, cmd):\\n if self.run_under_coverage:\\n cmd.append('--cov')\\n if self.append_coverage:\\n cmd.append('--cov-append')\\n cmd.append('--cov-report=')\\n\\n return cmd\",\n \"def find_coverage_report(folder, exclude=None, filter_out='.*conda.*'):\\r\\n regexp = re.compile('data_file=([0-9a-zA-Z_]+)')\\r\\n regcov = re.compile(\\r\\n '<h1>Coveragereport:<spanclass=.?pc_cov.?>([0-9]+)%</span>')\\r\\n regout = re.compile(filter_out) if filter_out else None\\r\\n covs = {}\\r\\n subfold = os.listdir(folder)\\r\\n for sub in subfold:\\r\\n if exclude is not None and sub in exclude:\\r\\n continue\\r\\n full = os.path.join(folder, sub)\\r\\n keep = []\\r\\n nn = None\\r\\n cov = None\\r\\n for it in explore_folder_iterfile(full):\\r\\n name = os.path.split(it)[-1]\\r\\n dt = os.stat(full).st_mtime\\r\\n if name == 'index.html':\\r\\n with open(it, 'r') as f:\\r\\n htd = f.read().replace('\\\\n', '').replace('\\\\r', '').replace(' ', '')\\r\\n cont = regcov.findall(htd)\\r\\n if len(cont) > 0:\\r\\n cov = cont[0]\\r\\n if name == 'covlog.txt':\\r\\n with open(it, 'r') as f:\\r\\n logd = f.read()\\r\\n cont = regexp.findall(logd)\\r\\n if len(cont) > 0:\\r\\n nn = cont[0]\\r\\n if name == '.coverage':\\r\\n keep.append((dt, it))\\r\\n if len(keep) == 0:\\r\\n continue\\r\\n mx = max(keep)\\r\\n if regout is not None and regout.search(nn):\\r\\n continue\\r\\n covs[sub] = (mx[-1], nn, cov)\\r\\n return covs\",\n \"def build_for_coverage(self):\\n\\n extra_parms = '--cmake-args -DCMAKE_CXX_FLAGS=\\\"-g -O0 -Wall -fprofile-arcs -ftest-coverage\\\" -DCMAKE_EXE_LINKER_FLAGS=\\\"-fprofile-arcs -ftest-coverage\\\"'\\n cmd = ['catkin', 'build', self.name ]\\n cmd.extend(shlex.split(extra_parms))\\n\\n process = subprocess.Popen(cmd,\\n stdout=subprocess.PIPE, \\n stderr=subprocess.PIPE,\\n universal_newlines=True)\\n\\n process.communicate()\\n\\n return process.returncode\",\n \"def define_coverage(self, id=None, units=None, standard_name=None, coverage_dimensions=None):\",\n \"def covwatch(context):\\n context.run(\\\" \\\".join([\\n \\\"python -m pytest\\\",\\n \\\"--cov=%s\\\" % PACKAGE_NAME,\\n \\\"--cov-branch\\\",\\n \\\"--cov-fail-under=75\\\"\\n ]))\",\n \"def update_readme_data(readme_file, **readme_updates):\\n\\n extensions_key = \\\"base\\\"\\n extensions = readme_updates[\\\"extensions\\\"]\\n\\n if extensions:\\n extensions_key = \\\"-\\\".join(extensions)\\n\\n output_folder = readme_updates[\\\"outputsubfolder\\\"]\\n generation_data = {\\n \\\"location\\\": path_join_robust(output_folder, \\\"\\\"),\\n \\\"entries\\\": readme_updates[\\\"numberofrules\\\"],\\n \\\"sourcesdata\\\": readme_updates[\\\"sourcesdata\\\"],\\n }\\n\\n with open(readme_file, \\\"r\\\") as f:\\n readme_data = json.load(f)\\n readme_data[extensions_key] = generation_data\\n\\n for denomination, data in readme_data.copy().items():\\n if \\\"location\\\" in data and data[\\\"location\\\"] and \\\"\\\\\\\\\\\" in data[\\\"location\\\"]:\\n # Windows compatibility: #1166\\n readme_data[denomination][\\\"location\\\"] = data[\\\"location\\\"].replace(\\\"\\\\\\\\\\\", \\\"/\\\")\\n\\n with open(readme_file, \\\"w\\\") as f:\\n json.dump(readme_data, f)\",\n \"def run_gcov(filename, coverage, args):\\n if args.verbose:\\n warn(\\\"calling:\\\", 'gcov', '-i', filename)\\n stdout = None\\n else:\\n # gcov is noisy and don't have quit flag so redirect stdout to /dev/null\\n stdout = subprocess.DEVNULL\\n\\n subprocess.check_call(['gcov', '-i', filename], stdout=stdout)\\n\\n for gcov_file in glob('*.gcov'):\\n if args.verbose:\\n warn('parsing', gcov_file)\\n src_file, count = parse_gcov_file(gcov_file)\\n os.remove(gcov_file)\\n\\n if src_file not in coverage:\\n coverage[src_file] = defaultdict(int, count)\\n else:\\n # sum execution counts\\n for line, exe_cnt in count.items():\\n coverage[src_file][line] += exe_cnt\",\n \"def test_update_test_asset(self):\\n pass\",\n \"def update_from_repo():\\n\\treturn\",\n \"def test_build_manual_run(self):\\n repository = self._create_repository()\\n review_request = self.create_review_request(repository=repository)\\n diffset = self.create_diffset(review_request=review_request)\\n diffset.base_commit_id = '8fd69d70f07b57c21ad8733c1c04ae604d21493f'\\n diffset.save()\\n\\n config = self._create_config()\\n self.integration.enable_integration()\\n\\n status_update = \\\\\\n self.create_status_update(service_id='travis-ci',\\n review_request=review_request)\\n\\n data = self._spy_on_make_request()\\n\\n status_update_request_run.send(sender=self.__class__,\\n status_update=status_update)\\n\\n self.assertTrue(TravisAPI._make_request.called)\\n\\n self.assertEqual(\\n data['url'],\\n 'https://api.travis-ci.org/repo/'\\n 'mypublicorg%2Fmypublicorgrepo/requests')\\n\\n self.assertEqual(\\n data['request']['config']['env']['global'],\\n [\\n 'REVIEWBOARD_STATUS_UPDATE_ID=1',\\n 'REVIEWBOARD_TRAVIS_INTEGRATION_CONFIG_ID=%d' % config.pk,\\n ])\\n\\n self.assertEqual(data['request']['message'],\\n 'Test Summary\\\\n\\\\nTest Description')\\n self.assertTrue('git fetch --unshallow origin || true'\\n in data['request']['config']['before_install'])\\n self.assertTrue('git checkout %s' % diffset.base_commit_id\\n in data['request']['config']['before_install'])\\n self.assertEqual(data['request']['branch'], 'review-requests')\",\n \"def add_cover(self):\\n self.has_cover = True\",\n \"def _cmd_coverage(args):\\n pset = coverage.do_coverage(\\n args.interval,\\n args.bam_file,\\n args.count,\\n args.min_mapq,\\n args.processes,\\n args.fasta,\\n )\\n if not args.output:\\n # Create an informative but unique name for the coverage output file\\n bambase = core.fbase(args.bam_file)\\n bedbase = core.fbase(args.interval)\\n tgtbase = (\\n \\\"antitargetcoverage\\\" if \\\"anti\\\" in bedbase.lower() else \\\"targetcoverage\\\"\\n )\\n args.output = f\\\"{bambase}.{tgtbase}.cnn\\\"\\n if os.path.exists(args.output):\\n args.output = f\\\"{bambase}.{bedbase}.cnn\\\"\\n core.ensure_path(args.output)\\n tabio.write(pset, args.output)\",\n \"def test_upload(pytestconfig, pypi):\\n #pypi_chishop.restore()\\n with PkgTemplate(name='acme.tpi_test_upload') as pkg:\\n pkg.create_pypirc(pypi.get_rc())\\n pkg.install_package('pytest-cov')\\n new_env = copy.copy(pkg.env)\\n new_env['HOME'] = pkg.workspace\\n print pkg.run_with_coverage(['%s/setup.py' % pkg.trunk_dir, 'sdist', 'register',\\n 'upload', '--show-response'],\\n pytestconfig, env=new_env, cd=HERE)\\n assert os.path.isfile(os.path.join(pypi.workspace, 'chishop/media/dists/a/acme.tpi_test_upload/acme.tpi_test_upload-1.0.0.dev1.tar.gz'))\\n\\n import tarfile, urllib2, cStringIO\\n dist_url = 'http://%s:%s/media/dists/a/acme.tpi_test_upload/acme.tpi_test_upload-1.0.0.dev1.tar.gz' % (pypi_chishop.hostname, pypi_chishop.port)\\n response = urllib2.urlopen(dist_url)\\n buf = response.read()\\n fh = cStringIO.StringIO(buf)\\n try:\\n tf = tarfile.open(fileobj=fh)\\n assert 'acme.tpi_test_upload-1.0.0.dev1/PKG-INFO' in tf.getnames()\\n finally:\\n tf.close()\",\n \"def set_cover_path(self, path: str) -> None:\\n self.cover_path = path\\n # The cover URL is no longer required as a custom cover has been defined.\\n self.cover_url = None\",\n \"def fixit(file):\\n with open(file, \\\"r\\\") as f:\\n config = json.load(f)\\n if \\\"job_status\\\" in config[\\\"supply-curve-aggregation\\\"]:\\n del config[\\\"supply-curve-aggregation\\\"][\\\"job_status\\\"]\\n if \\\"rep-profiles\\\" in config:\\n del config[\\\"rep-profiles\\\"]\\n fname = os.path.basename(file)\\n cname = \\\"_\\\".join(fname.split(\\\"_\\\")[:-1]) + \\\"_agg\\\"\\n config[\\\"supply-curve-aggregation\\\"][cname][\\\"job_status\\\"] = \\\"successful\\\"\\n\\n with open(file, \\\"w\\\") as f:\\n f.write(json.dumps(config, indent=4))\",\n \"def gen_svn_updated_lcov_factory(baseURL, configure_opts=[]):\\n f = factory.BuildFactory()\\n f.addStep(source.SVN(baseURL=baseURL, defaultBranch='trunk', mode=\\\"update\\\"))\\n f.addStep(Bootstrap())\\n f.addStep(shell.Configure(command = [\\\"sh\\\", \\\"configure\\\", \\\"--disable-shared\\\", \\\"CXXFLAGS=-O0 --coverage\\\"] + configure_opts, workdir=\\\"build/xapian-core\\\"))\\n f.addStep(shell.Compile(workdir=\\\"build/xapian-core\\\"))\\n f.addStep(shell.ShellCommand(command = [\\\"make\\\", \\\"coverage-check\\\", \\\"GENHTML_ARGS=--html-gzip\\\"], workdir=\\\"build/xapian-core\\\", haltOnFailure=True))\\n f.addStep(shell.ShellCommand(command = [\\\"chmod\\\", \\\"-R\\\", \\\"a+rX\\\", \\\"lcov\\\"], workdir=\\\"build/xapian-core\\\", haltOnFailure=True))\\n f.addStep(shell.ShellCommand(command = 'NOW=`date -u +%Y-%m-%d`; cp -a lcov/. /var/www/\\\"$NOW\\\" && ln -sfT \\\"$NOW\\\" /var/www/latest', workdir=\\\"build/xapian-core\\\", haltOnFailure=True))\\n\\n return f\",\n \"def test_should_update(self):\\n cutoff = datetime_utc(2016, 1, 1)\\n provider = AlwaysSuccessfulCoverageProvider(\\n self._db, cutoff_time = cutoff\\n )\\n identifier = self._identifier()\\n\\n # If coverage is missing, we should update.\\n assert True == provider.should_update(None)\\n\\n # If coverage is outdated, we should update.\\n record, ignore = CoverageRecord.add_for(\\n identifier, provider.data_source\\n )\\n record.timestamp = datetime_utc(2015, 1, 1)\\n assert True == provider.should_update(record)\\n\\n # If coverage is up-to-date, we should not update.\\n record.timestamp = cutoff\\n assert False == provider.should_update(record)\\n\\n # If coverage is only 'registered', we should update.\\n record.status = CoverageRecord.REGISTERED\\n assert True == provider.should_update(record)\",\n \"def clean_tests(_context):\\n _delete_file(COVERAGE_FILE)\\n shutil.rmtree(COVERAGE_DIR, ignore_errors=True)\",\n \"def test_update_asset(self):\\n pass\",\n \"def __fix_baseline(self, coproject):\\r\\n newprojs = []\\r\\n _logger.info(\\\"Looking for new projects in the check out.\\\")\\r\\n status = coproject['status']\\r\\n for subproj in coproject.subprojects:\\r\\n if subproj['status'] == status:\\r\\n continue \\r\\n _logger.info(\\\"New project detected in the checkout '%s'\\\" % subproj.objectname)\\r\\n purpose = None\\r\\n if self._config.has_key('purpose'):\\r\\n purpose = self._config['purpose']\\r\\n _logger.info(\\\"Using purpose: '%s'\\\" % purpose)\\r\\n \\r\\n version = None\\r\\n if self._config.has_key('version'):\\r\\n version = self._config['version']\\r\\n _logger.info(\\\"Using version: '%s'\\\" % version)\\r\\n\\r\\n result = subproj.checkout(subproj.session.create(self._config['release']), version=version, purpose=purpose, subprojects=False)\\r\\n _logger.info('Checkout complete')\\r\\n if result.project != None and result.project.exists():\\r\\n newcop = result.project\\r\\n newprojs.append(newcop)\\r\\n \\r\\n _logger.info(\\\"Setting is_relative to true\\\") \\r\\n if \\\"is_relative\\\" in newcop.keys():\\r\\n newcop[\\\"is_relative\\\"] = \\\"TRUE\\\"\\r\\n else:\\r\\n newcop.create_attribute(\\\"is_relative\\\", \\\"boolean\\\", \\\"TRUE\\\")\\r\\n \\r\\n if not self._config.get_boolean('use.reconfigure.template', False):\\r\\n newcop.set_update_method('manual', False)\\r\\n \\r\\n _logger.info(\\\"Setting the baseline to '%s'\\\" % subproj)\\r\\n newcop.set_baseline(subproj, True)\\r\\n \\r\\n _logger.info(\\\"Cleaning up update properties\\\")\\r\\n self._clean_update_properties(newcop)\\r\\n \\r\\n _logger.info(\\\"Setting update properties.\\\")\\r\\n self._set_tasks_and_folders(newcop)\\r\\n return newprojs\",\n \"def parse(self):\\n\\n coverage_data = {\\n 'packages': {},\\n 'summary': {'lines-total': 0, 'lines-covered': 0,\\n 'branches-total': 0, 'branches-covered': 0},\\n 'timestamp': str(int(time.time()))\\n }\\n package = None\\n current_file = None\\n file_lines_total = 0\\n file_lines_covered = 0\\n file_lines = {}\\n file_methods = {}\\n file_branches_total = 0\\n file_branches_covered = 0\\n\\n for line in self.lcov_data.split('\\\\n'):\\n if line.strip() == 'end_of_record':\\n if current_file is not None:\\n package_dict = coverage_data['packages'][package]\\n package_dict['lines-total'] += file_lines_total\\n package_dict['lines-covered'] += file_lines_covered\\n package_dict['branches-total'] += file_branches_total\\n package_dict['branches-covered'] += file_branches_covered\\n file_dict = package_dict['classes'][current_file]\\n file_dict['lines-total'] = file_lines_total\\n file_dict['lines-covered'] = file_lines_covered\\n file_dict['lines'] = dict(file_lines)\\n file_dict['methods'] = dict(file_methods)\\n file_dict['branches-total'] = file_branches_total\\n file_dict['branches-covered'] = file_branches_covered\\n coverage_data['summary']['lines-total'] += file_lines_total\\n coverage_data['summary']['lines-covered'] += file_lines_covered\\n coverage_data['summary']['branches-total'] += file_branches_total\\n coverage_data['summary']['branches-covered'] += file_branches_covered\\n\\n line_parts = line.split(':')\\n input_type = line_parts[0]\\n\\n if input_type == 'SF':\\n # Get file name\\n file_name = line_parts[-1].strip()\\n relative_file_name = os.path.relpath(file_name, self.base_dir)\\n package = '.'.join(relative_file_name.split(os.path.sep)[0:-1])\\n class_name = file_name.split(os.path.sep)[-1]\\n if package not in coverage_data['packages']:\\n coverage_data['packages'][package] = {\\n 'classes': {}, 'lines-total': 0, 'lines-covered': 0,\\n 'branches-total': 0, 'branches-covered': 0\\n }\\n coverage_data['packages'][package]['classes'][\\n relative_file_name] = {\\n 'name': class_name, 'lines': {}, 'lines-total': 0,\\n 'lines-covered': 0, 'branches-total': 0,\\n 'branches-covered': 0\\n }\\n package = package\\n current_file = relative_file_name\\n file_lines_total = 0\\n file_lines_covered = 0\\n file_lines.clear()\\n file_methods.clear()\\n file_branches_total = 0\\n file_branches_covered = 0\\n elif input_type == 'DA':\\n # DA:2,0\\n (line_number, line_hits) = line_parts[-1].strip().split(',')\\n line_number = int(line_number)\\n if line_number not in file_lines:\\n file_lines[line_number] = {\\n 'branch': 'false', 'branches-total': 0,\\n 'branches-covered': 0\\n }\\n file_lines[line_number]['hits'] = line_hits\\n # Increment lines total/covered for class and package\\n if int(line_hits) > 0:\\n file_lines_covered += 1\\n file_lines_total += 1\\n elif input_type == 'BRDA':\\n # BRDA:1,1,2,0\\n (line_number, block_number, branch_number, branch_hits) = line_parts[-1].strip().split(',')\\n line_number = int(line_number)\\n if line_number not in file_lines:\\n file_lines[line_number] = {\\n 'branch': 'true', 'branches-total': 0,\\n 'branches-covered': 0, 'hits': 0\\n }\\n file_lines[line_number]['branch'] = 'true'\\n file_lines[line_number]['branches-total'] += 1\\n file_branches_total += 1\\n if branch_hits != '-' and int(branch_hits) > 0:\\n file_lines[line_number]['branches-covered'] += 1\\n file_branches_covered += 1\\n elif input_type == 'BRF':\\n file_branches_total = int(line_parts[1])\\n elif input_type == 'BRH':\\n file_branches_covered = int(line_parts[1])\\n elif input_type == 'FN':\\n # FN:5,(anonymous_1)\\n function_name = line_parts[-1].strip().split(',')[1]\\n function_name = self.demangle_function_name(function_name)\\n file_methods[function_name] = '0'\\n elif input_type == 'FNDA':\\n # FNDA:0,(anonymous_1)\\n (function_hits, function_name) = line_parts[-1].strip().split(',')\\n function_name = self.demangle_function_name(function_name)\\n file_methods[function_name] = function_hits\\n\\n # Exclude packages\\n excluded = [x for x in coverage_data['packages'] for e in self.excludes\\n if re.match(e, x)]\\n for package in excluded:\\n del coverage_data['packages'][package]\\n\\n # Compute line coverage rates\\n for package_data in list(coverage_data['packages'].values()):\\n package_data['line-rate'] = self._percent(\\n package_data['lines-total'],\\n package_data['lines-covered'])\\n package_data['branch-rate'] = self._percent(\\n package_data['branches-total'],\\n package_data['branches-covered'])\\n\\n return coverage_data\",\n \"def update(self, co_dir):\\n self.run_task(' '.join(['svn', 'up', co_dir]))\\n pass\",\n \"def test_update_test_asset_content(self):\\n pass\",\n \"def on_finalize(event, context):\\n global gcs\\n if not gcs:\\n gcs = storage.Client()\\n\\n print('Processing InSpec report: %s' % event['name'])\\n bucket = storage.Bucket(name=event['bucket'], client=gcs)\\n blob = bucket.blob(event['name'])\\n report_str = blob.download_as_string()\\n report = json.loads(report_str)\\n\\n scc_source = os.environ.get('SCC_SOURCE',\\n 'SCC_SOURCE environment variable is not set.')\\n _inspec_report_to_scc(report, scc_source)\",\n \"def test_update_system_asset(self):\\n pass\",\n \"def derive_project_coverage(self) -> None:\\n self.get_project_column_description_coverage()\\n self.get_project_test_coverage()\",\n \"def test_update_asset_content(self):\\n pass\",\n \"def update_repo(self):\\n utils.render_template_to_file(\\n self.repo_template_path,\\n self.repo_config_path,\\n {\\n 'name': '{0}_nailgun'.format(self.version),\\n 'baseurl': self.host_system_config['repo_master'],\\n 'gpgcheck': 0,\\n 'skip_if_unavailable': 0,\\n })\\n utils.exec_cmd('yum clean all')\",\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 update_node_coverage(G, node, new_cov):\\n if node not in G.nodes(): # nothing to be done, perhaps already removed\\n return\\n if new_cov == 0:\\n G.remove_node(node)\\n if rc_node(node) in G.nodes():\\n G.remove_node(rc_node(node))\\n else:\\n G.add_node(node, cov=new_cov)\\n if rc_node(node) in G.nodes():\\n G.add_node(rc_node(node), cov=new_cov)\",\n \"def update():\\n siteconfig = configparser.RawConfigParser()\\n siteconfig.readfp(open(\\\"/etc/gitzillarc\\\"))\\n sRepo = os.getcwd()\\n\\n logger = get_logger(siteconfig)\\n oBugRegex = get_bug_regex(siteconfig)\\n sRefPrefix = get_or_default(siteconfig, sRepo, \\\"git_ref_prefix\\\")\\n sSeparator = get_or_default(siteconfig, sRepo, \\\"separator\\\")\\n\\n bRequireBugNumber = to_bool(get_or_default(siteconfig, sRepo, \\\"require_bug_ref\\\", True))\\n asAllowedStatuses = None\\n if has_option_or_default(siteconfig, sRepo, \\\"allowed_bug_states\\\"):\\n asAllowedStatuses = [x.strip() for x in get_or_default(siteconfig, sRepo, \\\"allowed_bug_states\\\").split(\\\",\\\")]\\n\\n # and the bugzilla info.\\n userconfig = configparser.RawConfigParser()\\n userconfig.read(os.path.expanduser(\\\"~/.gitzillarc\\\"))\\n (sBZUrl, sBZUser, sBZPasswd) = get_bz_data(siteconfig, userconfig)\\n\\n gitzilla.hooks.update(oBugRegex, asAllowedStatuses, sSeparator, sBZUrl,\\n sBZUser, sBZPasswd, logger, None, sRefPrefix,\\n bRequireBugNumber)\",\n \"def qsim_save_coverage(ucdb, region, param):\\n \\n print(\\\"ucdb=\\\" + str(ucdb) + \\\" region=\\\" + str(region) + \\\" param=\\\" + str(param))\\n # Load the UCIS library and initialize the Python\\n # interface\\n UcdbFactory.load_ucdb_library(\\\"libucdb.so\\\")\\n \\n db = UcdbUCIS(db=ucdb)\\n covergroups = CoverageRegistry.inst().covergroup_types()\\n save_visitor = CoverageSaveVisitor(db)\\n \\n save_visitor.save(None, covergroups)\\n \\n pass\",\n \"def convert(self):\\n coverage_data = self.parse()\\n return self.generate_cobertura_xml(coverage_data)\",\n \"def fill_in_zero_cov(all_coverage, depth_file):\\n f_in = open(depth_file, \\\"r\\\")\\n for line in f_in:\\n if line.startswith(\\\"#\\\"):\\n continue\\n if not line.strip():\\n continue # if the last line is blank\\n # print(depth_filename)\\n ref, possition, coverage = line.rstrip(\\\"\\\\n\\\").split(\\\"\\\\t\\\")\\n possition = int(possition) - 1\\n # assign the correct coverage to the relavent postiton,\\n # thus removing the zero value.\\n # Or if there is no info, it remains as a zero.\\n all_coverage[possition] = int(coverage)\\n f_in.close()\\n return all_coverage\",\n \"def task_test():\\n return {\\n \\\"actions\\\": [[\\\"pytest\\\", \\\"--cov=mad_gui\\\", \\\"--cov-config=.coveragerc\\\", \\\"-vv\\\"]],\\n \\\"verbosity\\\": 2,\\n }\",\n \"def test_update_software_asset(self):\\n pass\",\n \"def generate_report():\\n if os.path.isdir(\\\"build/coverage\\\"):\\n shutil.rmtree(\\\"build/coverage\\\")\\n commands = '''\\nscons -uij32 --optimization=coverage controller/cplusplus_test\\nlcov --base-directory build/coverage --directory build/coverage -c -o build/coverage/controller_test.info\\ngenhtml -o build/coverage/controller/test_coverage -t test --num-spaces 4 build/coverage/controller_test.info\\n'''\\n for cmd in commands.splitlines():\\n cmd_args = cmd.split()\\n if (len(cmd_args) == 0):\\n continue\\n cmd = cmd_args[0]\\n cmd_path = find_executable(cmd)\\n if not cmd_path:\\n continue\\n pid = os.fork()\\n if pid == 0:\\n # Avoid stdout buffering by execing command into child process.\\n os.execv(cmd_path, cmd_args)\\n os.waitpid(pid, 0)\",\n \"def saveInGit(file_content, file_name, report_date):\\n file_path = \\\"/\\\".join([crs_reports_dir,file_name])\\n existed = os.path.isfile(file_path) \\n if existed:\\n # TODO Check that this specific version of this file isn't already\\n # in the comment history\\n pass\\n with open(file_path, 'w') as f: \\n f.write(file_content)\\n f.close()\\n gitAdd(file_name, crs_reports_dir)\\n if existed:\\n # TODO Set the commit date to be the CRS release date\\n gitCommit(file_name, crs_reports_dir, '%s was updated' % file_name,\\n report_date)\\n else:\\n gitCommit(file_name, crs_reports_dir, 'Added %s' % file_name,\\n report_date)\\n \\n \\n \\n # 1.) If file_name exists:\\n # 1.)overwrite it, \\n # 2.) Commit an update to the file_name\\n # else:\\n # 1.) Create and save a new file\\n # 2.) Commit the new file\",\n \"def testUpdateConfigFile(self):\\n # Test update project field.\\n gcp_setup_runner.UpdateConfigFile(self.cfg_path, \\\"project\\\",\\n \\\"test_project\\\")\\n cfg = config.AcloudConfigManager.LoadConfigFromProtocolBuffer(\\n open(self.cfg_path, \\\"r\\\"), user_config_pb2.UserConfig)\\n self.assertEqual(cfg.project, \\\"test_project\\\")\\n self.assertEqual(cfg.ssh_private_key_path, \\\"\\\")\\n # Test add ssh key path in config.\\n gcp_setup_runner.UpdateConfigFile(self.cfg_path,\\n \\\"ssh_private_key_path\\\", \\\"test_path\\\")\\n cfg = config.AcloudConfigManager.LoadConfigFromProtocolBuffer(\\n open(self.cfg_path, \\\"r\\\"), user_config_pb2.UserConfig)\\n self.assertEqual(cfg.project, \\\"test_project\\\")\\n self.assertEqual(cfg.ssh_private_key_path, \\\"test_path\\\")\\n # Test config is not a file\\n with mock.patch(\\\"os.path.isfile\\\") as chkfile:\\n chkfile.return_value = False\\n gcp_setup_runner.UpdateConfigFile(self.cfg_path, \\\"project\\\",\\n \\\"test_project\\\")\\n cfg = config.AcloudConfigManager.LoadConfigFromProtocolBuffer(\\n open(self.cfg_path, \\\"r\\\"), user_config_pb2.UserConfig)\\n self.assertEqual(cfg.project, \\\"test_project\\\")\",\n \"def coverage(self, file, **options):\\n\\n options['file'] = file\\n\\n return self._get('coverage', **options)\",\n \"def generate_coverage_reports(project, output_dir=None):\\n outdir = output_dir or os.path.join(project.sdk_directory, \\\"coverage-results\\\")\\n sdir = project.path\\n # Make sure output dir exists and is empty:\\n qisys.sh.rm(outdir)\\n qisys.sh.mkdir(outdir, recursive=True)\\n formats = {\\\"xml\\\": [\\\"--xml\\\"],\\n \\\"html\\\": [\\\"--html\\\", \\\"--html-details\\\"]}\\n for fmt, opts in formats.items():\\n base_report = os.path.join(outdir, project.name + \\\".\\\" + fmt)\\n cmd = [\\\"gcovr\\\",\\n \\\"--root\\\", sdir,\\n \\\"--exclude\\\", \\\".*test.*\\\",\\n \\\"--exclude\\\", \\\".*external.*\\\",\\n \\\"--exclude\\\", \\\".*example.*\\\"] + opts + \\\\\\n [\\\"--output\\\", base_report]\\n qisys.command.call(cmd, cwd=sdir, quiet=True)\\n ui.info(ui.green, \\\"*\\\", ui.reset, \\\"Generated\\\", fmt.upper(),\\n \\\"coverage report in\\\", ui.reset, ui.bold, base_report)\",\n \"def report(self, output_dir):\",\n \"def update_readme():\\n\\n temp = \\\"\\\"\\\"<head>\\n <title>Unittest Results</title>\\n <meta charset=\\\"utf-8\\\">\\n <meta name=\\\"viewport\\\" content=\\\"width=device-width, initial-scale=1.0\\\">\\n <link rel=\\\"stylesheet\\\" href=\\\"https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css\\\" integrity=\\\"sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7\\\" crossorigin=\\\"anonymous\\\">\\n</head>\\\"\\\"\\\"\\n\\n with open(\\\"README_proxy.md\\\", \\\"r\\\") as old_readme_file:\\n old_readme_txt = old_readme_file.read()\\n\\n with open(\\\"reports/test_result.html\\\", \\\"r\\\") as html_file:\\n html = html_file.read().splitlines()[0:-21]\\n html = \\\"\\\\n\\\".join(html).replace(temp, \\\"\\\")\\n\\n with open(\\\"README.md\\\", \\\"w\\\") as new_readme_file:\\n new_readme_file.write(old_readme_txt + \\\"\\\\n\\\\n\\\\n\\\" + html + \\\"</body></html>\\\")\",\n \"def update(filepath, github_account):\\n repo = _git.clone_from_github(\\n _repo_path(), join(filepath, _repo_name()), github_account=github_account)\\n if _update_disco(repo, github_account) > 0:\\n repo.push()\",\n \"def _configure(self):\\n test_lib.test_config.setdefault('config_files', []).append(\\n self.filename)\\n self._write_config_content()\",\n \"def set_cover(self, file_name, content, create_page=True):\\n\\n # as it is now, it can only be called once\\n c0 = EpubCover(file_name=file_name)\\n c0.content = content\\n self.add_item(c0)\\n\\n if create_page:\\n c1 = EpubCoverHtml(image_name=file_name)\\n self.add_item(c1)\\n\\n self.add_metadata(None, 'meta', '', OrderedDict([('name', 'cover'), ('content', 'cover-img')]))\",\n \"def generate_url(coverage_pct: float) -> str:\\n color = \\\"yellow\\\"\\n if coverage_pct == 100:\\n color = \\\"brightgreen\\\"\\n elif coverage_pct > 90:\\n color = \\\"green\\\"\\n elif coverage_pct > 70:\\n color = \\\"yellowgreen\\\"\\n elif coverage_pct > 50:\\n color = \\\"yellow\\\"\\n else:\\n color = \\\"orange\\\"\\n\\n return f\\\"https://img.shields.io/badge/coverage-{coverage_pct}%25-{color}\\\"\",\n \"def test(coverage, test_names):\\n if coverage and not os.environ.get('FLASK_COVERAGE'):\\n import subprocess\\n os.environ['FLASK_COVERAGE'] = '1'\\n sys.exit(subprocess.call(sys.argv))\\n\\n import unittest\\n if test_names:\\n tests = unittest.TestLoader().loadTestsFromNames(test_names)\\n else:\\n tests = unittest.TestLoader().discover('tests')\\n unittest.TextTestRunner(verbosity=2).run(tests)\\n if COV:\\n COV.stop()\\n COV.save()\\n print('Coverage Summary:')\\n COV.report()\\n basedir = os.path.abspath(os.path.dirname(__file__))\\n covdir = os.path.join(basedir, 'tmp/coverage')\\n COV.html_report(directory=covdir)\\n print('HTML version: file://%s/index.html' % covdir)\\n COV.erase()\",\n \"def test(conanfile):\\n with conanfile_exception_formatter(conanfile, \\\"test\\\"):\\n with chdir(conanfile.build_folder):\\n conanfile.test()\",\n \"def _ReadCoverageInfoMessage(message):\\n\\n cov_info = {}\\n\\n for file_cov_msg in message.file_coverage:\\n file_path = os.path.abspath(file_cov_msg.file_name)\\n cov_info[file_path] = set(file_cov_msg.covered_lines)\\n\\n return cov_info\",\n \"def pytest_sessionfinish(session, exitstatus):\\n if not updated_files:\\n return\\n print('\\\\n\\\\nInomaly Complete, Updated these files\\\\n')\\n for filepath in updated_files:\\n print('\\\\t%s' % filepath)\",\n \"def statusupdate(filepath):\\n pass\",\n \"def test_update_test_asset_impact_level(self):\\n pass\",\n \"def test_update_software_asset_content(self):\\n pass\",\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 test_download_deployment_run_test_report(self):\\n pass\",\n \"def clear_coverage(bv=None):\\n if covdb and len(covdb.coverage_files) > 0:\\n remove_highlights()\\n clear_globals()\\n log.log_info(\\\"[*] Coverage information cleared\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57402664","0.55637956","0.5521971","0.5499088","0.54615265","0.5441391","0.54214483","0.5401124","0.53201175","0.51842374","0.5157459","0.51465404","0.5143215","0.5136255","0.5116265","0.5108954","0.506716","0.49769455","0.49514818","0.49292338","0.49191287","0.49159703","0.48945257","0.48787403","0.4871899","0.48485205","0.48069066","0.47754508","0.47708666","0.47613415","0.47137958","0.4709626","0.4708118","0.4695008","0.46856153","0.46828815","0.4681943","0.46810815","0.46773797","0.46413264","0.4613695","0.46098253","0.46098253","0.45884928","0.45860454","0.45764244","0.45634922","0.45587933","0.4557216","0.45551154","0.45402512","0.45137486","0.44675764","0.4462738","0.44450092","0.4444711","0.44330066","0.44315398","0.44309878","0.4413051","0.4404833","0.44042102","0.439639","0.43955922","0.43888825","0.43861955","0.4375922","0.43681538","0.43657112","0.43597248","0.43554968","0.4350796","0.43445492","0.4342151","0.4338455","0.43373802","0.4333394","0.43333626","0.43208617","0.43196926","0.43160477","0.43116665","0.4310995","0.43081415","0.4296347","0.42918786","0.4291719","0.42892757","0.42826718","0.42818627","0.42812395","0.4277023","0.42672628","0.42654684","0.42614064","0.4255216","0.42534173","0.42508006","0.4244398","0.423947"],"string":"[\n \"0.57402664\",\n \"0.55637956\",\n \"0.5521971\",\n \"0.5499088\",\n \"0.54615265\",\n \"0.5441391\",\n \"0.54214483\",\n \"0.5401124\",\n \"0.53201175\",\n \"0.51842374\",\n \"0.5157459\",\n \"0.51465404\",\n \"0.5143215\",\n \"0.5136255\",\n \"0.5116265\",\n \"0.5108954\",\n \"0.506716\",\n \"0.49769455\",\n \"0.49514818\",\n \"0.49292338\",\n \"0.49191287\",\n \"0.49159703\",\n \"0.48945257\",\n \"0.48787403\",\n \"0.4871899\",\n \"0.48485205\",\n \"0.48069066\",\n \"0.47754508\",\n \"0.47708666\",\n \"0.47613415\",\n \"0.47137958\",\n \"0.4709626\",\n \"0.4708118\",\n \"0.4695008\",\n \"0.46856153\",\n \"0.46828815\",\n \"0.4681943\",\n \"0.46810815\",\n \"0.46773797\",\n \"0.46413264\",\n \"0.4613695\",\n \"0.46098253\",\n \"0.46098253\",\n \"0.45884928\",\n \"0.45860454\",\n \"0.45764244\",\n \"0.45634922\",\n \"0.45587933\",\n \"0.4557216\",\n \"0.45551154\",\n \"0.45402512\",\n \"0.45137486\",\n \"0.44675764\",\n \"0.4462738\",\n \"0.44450092\",\n \"0.4444711\",\n \"0.44330066\",\n \"0.44315398\",\n \"0.44309878\",\n \"0.4413051\",\n \"0.4404833\",\n \"0.44042102\",\n \"0.439639\",\n \"0.43955922\",\n \"0.43888825\",\n \"0.43861955\",\n \"0.4375922\",\n \"0.43681538\",\n \"0.43657112\",\n \"0.43597248\",\n \"0.43554968\",\n \"0.4350796\",\n \"0.43445492\",\n \"0.4342151\",\n \"0.4338455\",\n \"0.43373802\",\n \"0.4333394\",\n \"0.43333626\",\n \"0.43208617\",\n \"0.43196926\",\n \"0.43160477\",\n \"0.43116665\",\n \"0.4310995\",\n \"0.43081415\",\n \"0.4296347\",\n \"0.42918786\",\n \"0.4291719\",\n \"0.42892757\",\n \"0.42826718\",\n \"0.42818627\",\n \"0.42812395\",\n \"0.4277023\",\n \"0.42672628\",\n \"0.42654684\",\n \"0.42614064\",\n \"0.4255216\",\n \"0.42534173\",\n \"0.42508006\",\n \"0.4244398\",\n \"0.423947\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7289181"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":17998,"cells":{"query":{"kind":"string","value":"turn multiline config entry into a list of commands"},"document":{"kind":"string","value":"def parse_command_list(config_str):\n return [command for command in config_str.splitlines() if command]"},"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 config_changes(cli):\n result = []\n in_config = False\n for line in cli.splitlines():\n if not in_config and line == 'Building configuration...':\n in_config = True\n elif in_config:\n result.append(line)\n\n return '\\n'.join(result)","def get_commands_list() -> list:\n return open(\"data/metadata/commands.list.txt\", \"r\").read().split(\"\\n\")","def config_to_list(config_name=CONFIG_FILE_NAME):\n result = []\n config = configparser.ConfigParser()\n\n if not config.read([config_name]):\n return []\n\n for section in SECTIONS:\n for name, opts in ((n, o) for n, o in SECTIONS[section].items() if config.has_option(section, n)):\n value = config.get(section, name)\n\n if value != '' and value != 'None':\n action = opts.get('action', None)\n\n if action == 'store_true' and value == 'True':\n # Only the key is on the command line for this action\n result.append('--{}'.format(name))\n\n if not action == 'store_true':\n if opts.get('nargs', None) == '+':\n result.append('--{}'.format(name))\n result.extend((v.strip() for v in value.split(',')))\n else:\n result.append('--{}={}'.format(name, value))\n\n return result","def commands(config, names):\n commands = {\n cmd: Command(\n **{minus_to_underscore(k): v for k, v in config.items(cmd)}\n )\n for cmd in config.sections()\n if cmd != 'packages'\n }\n\n try:\n return tuple(commands[x] for x in names)\n except KeyError as e:\n raise RuntimeError(\n 'Section [commands] in the config file does not contain the '\n 'key {.args[0]!r} you requested to execute.'.format(e))","def load_command_list(filename=None):\n contents = None\n if filename:\n logger.debug('Attempting to read commands from \"{}\"'.format(filename))\n with open(filename, 'r') as fp:\n contents = fp.read().strip()\n\n if not contents:\n contents = ''\n\n # Split data as lines (ignore empty)\n return [l.strip().upper() for l in contents.split('\\n') if l.strip() != '']","def add_config(self, config):\n clean=lambda n: n.strip().strip('\"').lower()\n for line in config.split('\\n'):\n items=line.strip().split()\n if items and len(items) >= 3:\n cmd, evt, hnd=items[:3]\n \"\"\" NOTE\n - just 'bind' command expected right now\n - '+' prepended ti the handler means REPEAT (make sense just for keyboard keys actually)\n \"\"\"\n cmd=clean(cmd)\n if cmd in ['bind']:\n evt,hnd=(clean(evt), clean(hnd))\n if not cmd in self.config: self.config[cmd]={}\n repeat=hnd.startswith('+')\n if repeat: hnd=hnd[1:]\n self.config[cmd].update([[evt, [hnd, repeat]]])","def get_config_lines(self, key):\n return \" \".join([key, self._config[key][\"value\"], \"#\", self._config[key][\"comments\"]] if self._config[key][\"comments\"] is not None\n else [key, self._config[key][\"value\"]])","def test_removes_trailing_newline_from_complex_keys(self):\n commands = list(parser.generate_commands(yaml.load(\"\"\"\n - ? >\n Line 1\n Line 2\n : retries: 1\n \"\"\")))\n assert commands == [('Line 1 Line 2', {'retries': 1})]","def parse_commands(command_list: List[str]) -> List[str]:\n return [' '.join(x.split('-')) for x in command_list]","def configToCliArguments(config):\n if not isinstance(config, dict):\n raise TypeError(\"Expected dict for config\")\n\n args = []\n for key, value in config.items():\n if value == None:\n args.append(f\"--{key}\")\n continue\n\n if isinstance(value, list):\n value = \",\".join(value)\n args.append(f\"--{key}={value}\")\n\n return args","def makeConfig (self):\n for line in self.lines :\n ll = line.split ('=', 1)\n if len(ll) < 2 :\n print \"Error in parsing cfg label line: \" , line\n return None\n self.config[(ll[0]).strip()] = ((ll[1]).strip())","def _config_list(res, ctx):\n\n if _has_error_code(res):\n return print_errors(res, ctx)\n\n lines = []\n for config in res['configs']:\n line = '* ' if config['current'] else ' '\n\n if ctx.verbose:\n line += config['mtime'] + ' '\n\n line += config['name']\n lines.append(line)\n\n return \"\\n\".join(lines)","def config(bot, event, cmd=None, *args):\n\n # consume arguments and differentiate beginning of a json array or object\n tokens = list(args)\n parameters = []\n value = []\n state = \"key\"\n for token in tokens:\n if token.startswith((\"{\", \"[\")):\n # apparent start of json array/object, consume into a single list item\n state = \"json\"\n if state == \"key\":\n parameters.append(token)\n elif state == \"json\":\n value.append(token)\n else:\n raise ValueError(\"unknown state\")\n if value:\n parameters.append(\" \".join(value))\n print(\"config {}\".format(parameters))\n\n if cmd == 'get' or cmd is None:\n config_args = list(parameters)\n value = bot.config.get_by_path(config_args) if config_args else dict(bot.config)\n elif cmd == 'set':\n config_args = list(parameters[:-1])\n if len(parameters) >= 2:\n bot.config.set_by_path(config_args, json.loads(parameters[-1]))\n bot.config.save()\n value = bot.config.get_by_path(config_args)\n else:\n yield from command.unknown_command(bot, event)\n return\n elif cmd == 'append':\n config_args = list(parameters[:-1])\n if len(parameters) >= 2:\n value = bot.config.get_by_path(config_args)\n if isinstance(value, list):\n value.append(json.loads(parameters[-1]))\n bot.config.set_by_path(config_args, value)\n bot.config.save()\n else:\n value = _('append failed on non-list')\n else:\n yield from command.unknown_command(bot, event)\n return\n elif cmd == 'remove':\n config_args = list(parameters[:-1])\n if len(parameters) >= 2:\n value = bot.config.get_by_path(config_args)\n if isinstance(value, list):\n value.remove(json.loads(parameters[-1]))\n bot.config.set_by_path(config_args, value)\n bot.config.save()\n else:\n value = _('remove failed on non-list')\n else:\n yield from command.unknown_command(bot, event)\n return\n else:\n yield from command.unknown_command(bot, event)\n return\n\n if value is None:\n value = _('Parameter does not exist!')\n\n config_path = ' '.join(k for k in ['config'] + config_args)\n segments = [hangups.ChatMessageSegment('{}:'.format(config_path),\n is_bold=True),\n hangups.ChatMessageSegment('\\n', hangups.SegmentType.LINE_BREAK)]\n segments.extend(text_to_segments(json.dumps(value, indent=2, sort_keys=True)))\n bot.send_message_segments(event.conv, segments)","def parse(self):\n raw_config_lines = self.load_config()\n self.config_lines_str = raw_config_lines\n self._create_cfg_line_objects()","def process_commands(self, commands: List[str]):","def configDict(config):\n config_dict = {}\n line_number = 0\n if type(config) == str:\n config_object = config.splitlines()\n else:\n return \"ERROR: config not type str\"\n for index, line in enumerate(config_object):\n if not bool(re.match(\"^\\s|!\", line)):\n line_number = index\n config_dict[line] = []\n elif bool(re.match(\"^\\s\", line)):\n config_dict[config_object[line_number]].append(line.strip())\n return config_dict","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 command_groups(self, lines):\n for line in lines:\n match = command_regex.match(line)\n if match:\n if self.current_group:\n yield self.current_group\n groupdict = match.groupdict()\n comm = groupdict['comm']\n param = groupdict['param']\n if param:\n param = param[1:-1]\n data = groupdict['data']\n self.current_group = (comm, param, data)\n self.parse_multiline = True\n elif self.parse_multiline:\n match = cont_regex.match(line)\n if cont_regex.match(line):\n new_data, = match.groups()\n if new_data:\n name, param, data = self.current_group\n data += ' ' + new_data\n self.current_group = (name, param, data)\n else:\n self.parse_multiline = False\n else:\n self.parse_multiline = False\n if self.current_group:\n yield self.current_group\n self.current_group = []","def get_by_name_as_list(cls, name, token=','):\n config = Configuration.get_by_name(name) or []\n if config:\n return [item.strip() for item in config.split(token)]\n else:\n return config","def _config_sections(self):\n data = []\n section_data = []\n for index, line in enumerate(self.running_config):\n if self._nextline_startswith_space(index):\n section_data.append(line)\n else:\n if len(section_data) > 0:\n section_data.append(line)\n data.append(section_data)\n section_data = []\n return data","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 list_config():\n console = Console()\n _config = loadConfig()\n json_data = richJSON.from_data({**asdict(_config)})\n console.print(Panel(json_data, title=\"SubmarineCliConfig\"))","def config(name, config, edit=True):\n\n configs = []\n for entry in config:\n key = next(iter(entry.keys()))\n configs.append(_parse_config(entry[key], key))\n\n # Python auto-correct line endings\n configstext = \"\\n\".join(salt.utils.data.decode(configs))\n if edit:\n with salt.utils.files.fopen(name, \"w\") as configfile:\n configfile.write(\"# This file is managed by Salt.\\n\")\n configfile.write(salt.utils.stringutils.to_str(configstext))\n return configstext","def load_commands(filename):\n lines_out = []\n try:\n with open(filename, \"r\") as inFile:\n for line in inFile.readlines():\n comment = line.find(';') # Don't read comments after ';'\n if comment != -1:\n line = line[:comment]\n line = line.strip()\n if len(line) > 0: # Don't read lines of length 0.\n lines_out.append(line)\n except FileNotFoundError:\n print(f\"File {filename} not found.\")\n return lines_out","def parse_from_string(self, blob: str) -> None:\n\t\tself._entries = []\n\t\tis_not_set_matcher = re.compile(CONFIG_IS_NOT_SET_PATTERN)\n\t\tconfig_matcher = re.compile(CONFIG_PATTERN)\n\t\tfor line in blob.split('\\n'):\n\t\t\tline = line.strip()\n\t\t\tif not line:\n\t\t\t\tcontinue\n\t\t\telif config_matcher.match(line) or is_not_set_matcher.match(line):\n\t\t\t\tself._entries.append(KconfigEntry(line))\n\t\t\telif line[0] == '#':\n\t\t\t\tcontinue\n\t\t\telse:\n\t\t\t\traise KconfigParseError('Failed to parse: ' + line)","def config(ctx):\n if not ctx.invoked_subcommand:\n cfg = ctx.obj['cfg']\n for section in cfg.sections():\n print(\"[\", section, \"]\")\n for option in cfg[section]:\n print(option, \" = \", cfg[section][option])","def parse(self, lines):\n cur_entry = None\n indents = []\n for line in lines:\n kv_ = _key_value(line)\n if len(kv_) > 1:\n key, value = kv_\n if key.lower() == \"host\":\n cur_entry = value\n self.hosts_.add(value)\n else:\n indents.append(_indent(line))\n self.lines_.append(ConfigLine(line=line, host=cur_entry, key=key, value=value))\n else:\n self.lines_.append(ConfigLine(line=line))\n # use most popular indent as indent for file, default ' '\n counter = Counter(indents)\n popular = list(reversed(sorted(counter.items(), key=lambda e: e[1])))\n self.indent = popular[0][0] if len(popular) > 0 else ' '","def config(self):\n return \"\\n\".join([ c.config(True) for p, c in self.configs_ ])","def normalize(self, cfg):\n clean_cfg = []\n\n for line in cfg.splitlines():\n\n if not line.strip():\n # empty line\n continue\n if \"--More--\" in line:\n # pick up anything that may be included after the \"More\"\n line = line[line.find('--More--') + 8:]\n if not line.split():\n # emptied line\n continue\n if line.startswith('#'):\n continue\n if line.startswith('!'):\n continue\n if line.startswith('Current configuration'):\n continue\n if line.rstrip().endswith(\"#\"):\n continue\n if line.split()[0] in self.skip:\n continue\n if self._check_timestamps(line):\n continue\n line = self._check_special_handles(line)\n if line is None:\n continue\n\n clean_cfg.append(line.strip())\n\n return clean_cfg","def config(bot, event, cmd=None, *args):\n\n # consume arguments and differentiate beginning of a json array or object\n tokens = list(args)\n parameters = []\n value = []\n state = \"key\"\n for token in tokens:\n if token.startswith((\"{\", \"[\", '\"', \"'\")):\n # apparent start of json array/object, consume into a single list item\n state = \"json\"\n if state == \"key\":\n parameters.append(token)\n elif state == \"json\":\n value.append(token)\n else:\n raise ValueError(\"unknown state\")\n if value:\n parameters.append(\" \".join(value))\n\n if cmd == 'get' or cmd is None:\n config_args = list(parameters)\n value = bot.config.get_by_path(config_args) if config_args else dict(bot.config)\n\n elif cmd == 'test':\n num_parameters = len(parameters)\n text_parameters = []\n last = num_parameters - 1\n for num, token in enumerate(parameters):\n if num == last:\n try:\n json.loads(token)\n token += \" <b>(valid json)</b>\"\n except ValueError:\n token += \" <em>(INVALID)</em>\"\n text_parameters.append(str(num + 1) + \": \" + token)\n text_parameters.insert(0, \"<b>config test</b>\")\n\n if num_parameters == 1:\n text_parameters.append(_(\"<em>note: testing single parameter as json</em>\"))\n elif num_parameters < 1:\n yield from command.unknown_command(bot, event)\n return\n\n yield from bot.coro_send_message(event.conv, \"<br />\".join(text_parameters))\n return\n\n elif cmd == 'set':\n config_args = list(parameters[:-1])\n if len(parameters) >= 2:\n bot.config.set_by_path(config_args, json.loads(parameters[-1]))\n bot.config.save()\n value = bot.config.get_by_path(config_args)\n else:\n yield from command.unknown_command(bot, event)\n return\n\n elif cmd == 'append':\n config_args = list(parameters[:-1])\n if len(parameters) >= 2:\n value = bot.config.get_by_path(config_args)\n if isinstance(value, list):\n value.append(json.loads(parameters[-1]))\n bot.config.set_by_path(config_args, value)\n bot.config.save()\n else:\n value = _('append failed on non-list')\n else:\n yield from command.unknown_command(bot, event)\n return\n\n elif cmd == 'remove':\n config_args = list(parameters[:-1])\n if len(parameters) >= 2:\n value = bot.config.get_by_path(config_args)\n if isinstance(value, list):\n value.remove(json.loads(parameters[-1]))\n bot.config.set_by_path(config_args, value)\n bot.config.save()\n else:\n value = _('remove failed on non-list')\n else:\n yield from command.unknown_command(bot, event)\n return\n\n else:\n yield from command.unknown_command(bot, event)\n return\n\n if value is None:\n value = _('Parameter does not exist!')\n\n config_path = ' '.join(k for k in ['config'] + config_args)\n segments = [hangups.ChatMessageSegment('{}:'.format(config_path),\n is_bold=True),\n hangups.ChatMessageSegment('\\n', hangups.SegmentType.LINE_BREAK)]\n segments.extend(text_to_segments(json.dumps(value, indent=2, sort_keys=True)))\n yield from bot.coro_send_message(event.conv, segments)","def parse_lines(lines, packages):\n for line in lines:\n x = line.split(' ')\n cmd = x[0].upper()\n #LOG.debug(cmd)\n if 'LIST' in cmd:\n getattr(commands, cmd)(p)\n else:\n getattr(commands, cmd)(line, p)","async def read_config(self, save: str | bool = False) -> list[str]:\n key_value_re = re.compile(\"^(.+?)=(.*)$\")\n\n def parse_line(line):\n k, v = key_value_re.match(line).groups()\n # It seems the GUI replaces / with \\ even if that doesn't seem\n # necessary in the INI format.\n k = k.replace(\"/\", \"\\\\\")\n if \";\" in v or \"=\" in v or \",\" in v:\n v = f'\"{v}\"'\n return k, v\n\n cmd_strs = [f\"RCONFIG{n_line:04X}\" for n_line in range(MAX_CONFIG_LINES)]\n done, failed = await self.send_many(cmd_strs, max_chunk=200, timeout=0.5)\n if len(failed) > 0:\n ff = failed[0]\n status = ff.status.name\n raise ArchonError(f\"An RCONFIG command returned with code {status!r}\")\n\n if any([len(cmd.replies) != 1 for cmd in done]):\n raise ArchonError(\"Some commands did not get any reply.\")\n\n lines = [str(cmd.replies[0]) for cmd in done]\n\n # Trim possible empty lines at the end.\n config = \"\\n\".join(lines).strip().splitlines()\n if not save:\n return config\n\n # The GUI ACF file includes the system information, so we get it.\n system = await self.get_system()\n\n c = configparser.ConfigParser()\n c.optionxform = str # Make it case-sensitive\n c.add_section(\"SYSTEM\")\n for sk, sv in system.items():\n if \"_name\" in sk.lower():\n continue\n sl = f\"{sk.upper()}={sv}\"\n k, v = parse_line(sl)\n c.set(\"SYSTEM\", k, v)\n c.add_section(\"CONFIG\")\n for cl in config:\n k, v = parse_line(cl)\n c.set(\"CONFIG\", k, v)\n\n if isinstance(save, str):\n path = save\n else:\n path = os.path.expanduser(f\"~/archon_{self.name}.acf\")\n with open(path, \"w\") as f:\n c.write(f, space_around_delimiters=False)\n\n return config","def _commands(self) -> Dict[str, List[str]]:\r\n pass","def command(command_list):\n def add_attribute(func):\n if not hasattr(func, \"command\"):\n func.command = []\n func.command.append(command_list)\n return func\n return add_attribute","def _get_commands_list(self, script_obj: dict):\n commands_list = []\n try:\n commands_obj = script_obj.get(\"commands\", {})\n for command in commands_obj:\n commands_list.append(command.get(\"name\", \"\"))\n except Exception:\n logger.debug(\"Failed getting the commands from the yml file\")\n return commands_list","def _parse_commands(self):\n buf = b\"\"\n while True:\n while self._paused or b\"\\n\" not in buf:\n buf += yield\n line, buf = self._extract_line(buf)\n assert line[:1] == b\"*\" # array\n n_fields = int(line[1:-2])\n fields = []\n for i in range(n_fields):\n while b\"\\n\" not in buf:\n buf += yield\n line, buf = self._extract_line(buf)\n assert line[:1] == b\"$\" # string\n length = int(line[1:-2])\n while len(buf) < length + 2:\n buf += yield\n fields.append(buf[:length])\n buf = buf[length + 2:] # +2 to skip the CRLF\n self._process_command(fields)","def get_shell_commands_from_config(\n config: Dict[str, Any],\n) -> Dict[str, ExecutorFuncT]:\n shell_commands = config\\\n .get('generic_command_config', {})\\\n .get('shell_commands', {})\n\n command_dispatch_table = {}\n\n for shell_command in shell_commands:\n name = shell_command.get('name')\n command = shell_command.get('command')\n if not name or not command:\n continue\n\n allow_params = shell_command.get('allow_params', False)\n\n logging.debug(\"Loading command %s\", name)\n command_dispatch_table[name] = partial(\n _run_subprocess,\n command,\n allow_params,\n )\n return command_dispatch_table","def readConfig(file=\"config.ini\"):\n ip_pool = []\n cmd_pool = []\n Config=ConfigParser.ConfigParser()\n Config.read(file)\n machines = Config.items(\"MACHINES\")\n commands = Config.items(\"COMMANDS\")\n for ip in machines:\n ip_pool.append(ip[1])\n for cmd in commands:\n cmd_pool.append(cmd[1])\n print cmd[1]\n return ip_pool,cmd_pool","def get_commands(bot):\n new_commands = []\n\n new_commands.append(Command(\n 'mycommand', subcommands=[\n SubCommand(\n Opt('myoption'),\n doc='This is a simple command with a single required option.'),\n SubCommand(\n Opt('custom', optional=True),\n Opt('attached', optional=True, attached='attached argument'),\n doc='This has two different optional options, one without an attached '\n 'parameter, and the other requiring an attached parameter.'),\n SubCommand(\n Opt('trailing'),\n Arg('arg 1'),\n Arg('arg 2'),\n Arg('arg 3', argtype=ArgTypes.SPLIT, additional='more args'),\n doc='This command requires a lot of trailing arguments.'),\n SubCommand(\n Opt('grouped'),\n Arg('grouped arguments', argtype=ArgTypes.MERGED),\n doc='This will group all given arguments as a single string.'),\n SubCommand(\n Opt('complex', attached='attached'),\n Opt('other', optional=True, attached='also required'),\n Arg('arg 1'),\n Arg('arg 2', argtype=ArgTypes.SPLIT_OPTIONAL, additional='more args'),\n doc='The complex option has a required attached parameter, and the '\n '\\'other\\' option also has a required attached parameter if '\n '\\'other\\' is included. Additionally, there will be a requirement '\n 'of at least 1 trailing argument.'),\n SubCommand(\n Opt('marquee'),\n Arg('text', argtype=ArgTypes.MERGED,\n check=lambda b, m, v, *a: len(v) <= 100,\n check_error=\"Marquee message must be less than 100 characters long.\"),\n doc='Creates a marquee that loops 3 times.')],\n shortcuts=[\n Shortcut(\n 'complex', 'complex {attached} other {other} {arg 1} {arg 2}',\n Arg('attached'), Arg('other'), Arg('arg 1'),\n Arg('arg 2', argtype=ArgTypes.SPLIT_OPTIONAL)),\n Shortcut(\n 'marquee', 'marquee {text}', Arg('text', argtype=ArgTypes.MERGED))],\n description='Your command description here.',\n other='This text is optional - it just shows up after everything '\n 'else. Quick note, all of the commands here can only be used by '\n 'bot moderators or above, as indicated by elevated_level. A '\n 'level of 2 would mean only server owners or above can use the '\n 'command, and a level of 3 would restrict the command to only '\n 'the bot owners.',\n elevated_level=1, category='demo'))\n\n new_commands.append(Command(\n 'myothercommand', subcommands=[\n SubCommand(\n Arg('text', argtype=ArgTypes.MERGED_OPTIONAL),\n doc='This traps all further commands from being executed.'),\n SubCommand(\n Opt('order'), Opt('matters'),\n doc='It is impossible to access this command because the first '\n 'subcommand will always be satisfied first. Order of the '\n 'subcommand matters!'),\n SubCommand(\n Opt('sample'), Opt('foo'), Opt('bar'),\n doc='Also impossible to access. This subcommand just adds some '\n 'keywords to the command.')],\n description='Only bot owners can see this text!',\n other='Note that no shortcuts were defined. They, too, are optional. '\n 'Also, this command is hidden, which means that only the bot '\n 'owners can see this command listed from the help command. '\n 'However, unless the command is configured with an elevated '\n 'permissions level, any user can still execute the command. '\n 'Users still will not be able to see the specific help for this '\n 'command, though. Lastly, this command is disabled in DMs.',\n hidden=True, allow_direct=False, category='demo'))\n\n new_commands.append(Command(\n 'notify', subcommands=[\n SubCommand(\n Arg('text', argtype=ArgTypes.MERGED),\n doc='Notify the owners with some text!')],\n other='This command uses a custom function. It is called with the '\n 'same arguments as get_response. The command will show up to '\n 'all users in the help command, but can only be used by server '\n 'owners, as it is disallowed in direct messages.',\n elevated_level=2, allow_direct=False, function=custom_notify,\n category='demo'))\n\n new_commands.append(Command(\n 'wait', other='Use this command to demo the wait_for functionality', category='demo'))\n\n return new_commands","def cmd_list(args):","def parse_config(cls, fname):\n with open(fname) as f:\n lines = [l.strip() for l in f.read().split('\\n') if l.strip()]\n\n comments = [l.replace('#', '').strip()\n for l in lines if l.startswith('#')]\n lines = [l for l in lines if not l.startswith('#')]\n\n # We use a simple state-machine approach to the parsing\n # in order to deal with multi-line sections.\n parsing = False\n keys = cls.config_guide.keys()\n vars = {var: [] for var in keys}\n for line in lines:\n if not parsing:\n k, csv = line.split(':')\n else:\n csv = line\n\n vars[k].extend([val.strip() for val in csv.split(',')])\n parsing = not line.endswith(';')\n if not parsing:\n vars[k][-1] = vars[k][-1][:-1] # remove semi-colon\n\n # Remove whitespace strings. These may have come from something like:\n # c: this, , that;\n for k in keys:\n vars[k] = [val for val in vars[k] if val] # already stripped\n\n return comments, vars","def parse_commands(self) -> list:\n\n command = self.path.split(\"?\")[1]\n commands = command.split(\"&\")\n\n return commands","def extract_arguments(f: TextIO) -> List[str]:\n args = []\n for line in f.readlines():\n idx = line.find(\"#\")\n if idx != -1:\n line = line[:idx]\n\n args.extend(shlex.split(line))\n return args","def argv(self) -> List[str]:\n if self.command:\n rtn = [utils.strip_quotes(self.command)]\n for cur_token in self.arg_list:\n rtn.append(utils.strip_quotes(cur_token))\n else:\n rtn = []\n\n return rtn","def parse_commandline_args():\n\n epilog = \"\"\"\n The configuration file must contained a JSON-encoded map. Example: \"{\"name\":\"foo\"}\".\n \"\"\"\n\n parser = utils.ConnectionArgumentParser(\n description=\"Update config (key/value pairs) on a board\", epilog=epilog\n )\n parser.add_argument(\n \"-c\",\n \"--config\",\n help=\"JSON file to load config from (default stdin)\",\n type=open,\n default=sys.stdin,\n dest=\"file\",\n )\n parser.add_argument(\n \"ids\", metavar=\"DEVICEID\", nargs=\"+\", type=int, help=\"Device IDs to flash\"\n )\n\n return parser.parse_args()","def parse_config(fpath):\n\n with open(fpath, \"r\") as f:\n # Ignore lines consisting only of whitespace or commented lines.\n lines = [\n line.strip() for line in f.readlines()\n if not (line.isspace() or line.startswith(\"#\"))\n ]\n\n # Each block begins with a line of the form \"[type]\", with the block type\n # (eg, \"convolutional\") enclosed in square brackets. Chunk config text\n # into blocks.\n block_start_lines = [\n line_num for line_num, line in enumerate(lines) if line.startswith(\"[\")\n ]\n block_start_lines.append(len(lines))\n\n text_blocks = []\n for i in range(1, len(block_start_lines)):\n block_start, block_end = block_start_lines[i-1], block_start_lines[i]\n text_blocks.append(lines[block_start:block_end])\n\n def str2type(raw_val):\n \"\"\"\n Helper function to convert a string input to the appropriate\n type (str, int, or float).\n \"\"\"\n try:\n return int(raw_val)\n except ValueError:\n pass\n\n try:\n return float(raw_val)\n except ValueError:\n return raw_val\n\n blocks = []\n net_info = None\n for text_block in text_blocks:\n block = {\"type\": text_block[0][1:-1]}\n for line in text_block[1:]:\n key, raw_val = line.split(\"=\")\n key = key.strip()\n\n # Convert fields with multiple comma-separated values into lists.\n if \",\" in raw_val:\n val = [str2type(item.strip()) for item in raw_val.split(\",\")]\n else:\n val = str2type(raw_val.strip())\n\n # If this is a \"route\" block, its \"layers\" field contains either\n # a single integer or several integers. If single integer, make it\n # a list for consistency.\n if (\n block[\"type\"] == \"route\"\n and key == \"layers\"\n and isinstance(val, int)\n ):\n val = [val]\n\n # If this is a \"yolo\" block, it contains an \"anchors\" field\n # consisting of (anchor width, anchor height) pairs of values;\n # thus, we group anchor values into chunks of two.\n if key == \"anchors\":\n val = [val[i:i+2] for i in range(0, len(val), 2)]\n\n block[key] = val\n\n if block[\"type\"] == \"net\":\n net_info = block\n else:\n blocks.append(block)\n\n return blocks, net_info","def get_quoted_list(self, key, default=None):\n\n things = self.read_config_key(key, default)\n\n quoted_items = []\n for thing in things:\n new_item = '\"' + thing + '\"'\n quoted_items.append(new_item)\n\n return quoted_items","def build_commands(self):\r\n for tag in self.bmark.tags.keys():\r\n # if this tag is a command then return true\r\n if tag in COMMANDLIST:\r\n self.commands.append(tag)","def test_CommandList():\n from paradrop.confd.command import CommandList\n\n clist = CommandList()\n clist.append(20, \"b\")\n clist.append(20, \"c\")\n clist.append(10, \"a\")\n\n commands = list(clist.commands())\n assert commands == [\"a\", \"b\", \"c\"]","def do_config(self, args):\n self.config_command.cmdloop(\"Enter to config mode\")","def extract_commands(file, out=\"commands.sh\",\n wrappers={\"bash\": \"%s\\n\",\n \"python\": \"python -e 'exec(\\\"\\\"\\\"%s\\\"\\\"\\\")'\\n\\n\"}):\n open_tags = {\"```%s\" % lang: lang for lang in wrappers}\n close_tag = \"```\\n\"\n active = False\n start = False\n command = \"\"\n lang = \"\"\n commands = list()\n with open(file, \"r\") as mdfile:\n for line in mdfile:\n start = False\n for tag in open_tags:\n if line.startswith(tag):\n active = start = True\n lang = open_tags[tag]\n if not start and line.startswith(close_tag):\n if active:\n commands.append(wrappers[lang] % command)\n command = \"\"\n active = False\n elif not start and active:\n command += line\n\n with open(out, \"w\") as cmdfile:\n cmdfile.write(\"#!/usr/bin/env bash\\n\")\n cmdfile.write(\"# file: %s\\n\" % file)\n cmdfile.write(\"# extracted %s\\n\\n\" % datetime.today())\n for cmd in commands:\n cmdfile.write(cmd)\n\n return commands","def config(self, *args):\n if len(args) == 1 and args[0].find('.') >= 0:\n return self._client.execute('showconfig', args[0]).strip()\n \n out = self._client.execute('showconfig', args)\n result = {}\n\n for line in out.splitlines():\n ks, v = line.split('=', 1)\n ks = ks.split('.')\n d = result\n for k in ks[:-1]:\n d = d.setdefault(k, {})\n d[ks[-1]] = v.strip()\n\n return result","def commands(self):\n if 'Commands' in self:\n return self['Commands']\n\n text = self['Body']\n commands = []\n cmd = [\"\", \"\"]\n isCmd = False\n isArg = False\n isComment = False\n for i in range(len(text)):\n # don't parse the commented lines\n # ignore everyline starting with '>'\n if text[i] == '>':\n j = i-1\n while text[j] in (' ', '\\t'):\n j -= 1\n if text[j] == '\\n':\n isComment = True\n elif text[i] == '\\n':\n isComment = False\n if isComment:\n if isArg:\n cmd[1] += text[i]\n continue\n\n if text[i-1] != '\\\\' and text[i:i+2] == '._' and (isCmd or isArg):\n isArg = False\n commands.append(cmd)\n cmd = [\"\", \"\"]\n elif isCmd:\n if text[i] == ' ':\n isArg = True\n isCmd = False\n else:\n cmd[0] += text[i]\n elif isArg:\n if text[i:i+3] in ('\\\\._', '\\\\_.'):\n pass\n else:\n cmd[1] += text[i]\n elif text[i-1] != '\\\\' and text[i-1:i+1] == '_.':\n isCmd = True\n\n return commands","def conf_load_par_list(par_def):\n par_def = par_def[1:-1].split(',')\n par_list = list()\n for p in par_def:\n par_list.append(p.strip())\n return par_list","def get_commands_dict() -> dict:\n commands_dict = {}\n f = open(f\"data/metadata/commands.dict.txt\", \"r\", encoding=\"utf-8\").read()\n for command in f.split(\"\\n\"):\n commands_dict[command.split(\":\")[0]] = command.split(\":\")[1]\n return commands_dict","def config_to_args(config):\n result = []\n\n for key, value in iteritems(config):\n if value is False:\n continue\n\n key = '--{0}'.format(key.replace('_', '-'))\n\n if isinstance(value, (list, set, tuple)):\n for item in value:\n result.extend((key, smart_str(item)))\n elif value is not True:\n result.extend((key, smart_str(value)))\n else:\n result.append(key)\n\n return tuple(result)","def parseInputFileList (self):\n filelist = []\n try:\n with open (self.cfgName) as fIn:\n for line in fIn:\n line = (line.split(\"@@@\")[0]).strip()\n if line:\n self.lines.append(line)\n except IOError:\n print \"*** WARNING: label cfg file \" , self.cfgName , \" not found\"\n return","def config_mode(self, config_command=\"config\", pattern=\">config\"):\n return super().config_mode(config_command=config_command, pattern=pattern)","def get_config_list(self, section, option, default=None):\n try:\n r = [value.strip() for value in self.get(section,option).split(',')]\n return r\n except ConfigParser.NoOptionError:\n return default","def commands(self) -> List[Command]:\n return []","def read_task_list(fname):\n tasks = []\n ignores = []\n \n f = open(fname,'r')\n lns = f.readlines()\n f.close()\n \n for l in lns:\n items = [ it.strip() for it in l.split(',') ]\n if len(items)==3:\n tasks.append({\"cwd\" :items[0], # the directory where the command should be ran from\n \"command\" :items[1], # the command to be run\n \"result\" :items[2], # the expected result file (will be used to determine whether we are done)\n \"status\" :\"unknown\"})\n else:\n if len(l.strip())>0:\n ignores.append(\"Ignoring line '%s' in task file, not sure what to do with that.\"%(l.strip()))\n\n return tasks,ignores","async def module_command_config(self, ctx, parsed):\n if parsed.invoker != ctx.owner:\n return\n ccs = ConfigCmdStatus\n results = []\n subcmd = parsed.subcmd\n value = None\n if subcmd.endswith(\"set\"): # set, reset\n key = parsed.args[\"key_path\"]\n name = parsed.args[\"config_file\"]\n try:\n config = self.configs[name]\n except KeyError:\n status = ccs.NO_SUCH_CONFIG\n else:\n try:\n old = config.get(key, None) if key is not None else None\n if subcmd.startswith(\"re\"):\n if parsed.args[\"default\"]:\n config.unset(key)\n else:\n config.reset(key)\n status = ccs.RESET_OK\n if key is not None:\n new = config.get(key, None)\n try:\n await self.module_send_event(\"config_changed\", ctx, name, key, old, new)\n except Exception:\n self.logger.exception(\"Uncaught exception in config_changed handler\")\n else:\n try:\n await self.module_send_event(\"config_reloaded\", ctx, name)\n except Exception:\n self.logger.exception(\"Uncaught exception in config_reloaded handler\")\n else:\n value = parsed.args[\"value\"]\n if value:\n config[key] = value\n status = ccs.SET_OK\n try:\n await self.module_send_event(\"config_changed\", ctx, name, key, old, value)\n except Exception:\n self.logger.exception(\"Uncaught exception in config_changed handler\")\n else:\n value = config.get(key)\n status = ccs.GET_OK\n except KeyError:\n status = ccs.NO_SUCH_KEY\n results.append(ConfigCmdResult(config, status, key, value))\n elif subcmd == \"save\":\n pool = parsed.args[\"config_file\"]\n if not pool:\n pool = self.configs.values()\n for config in pool:\n try:\n config = self.configs[config]\n config.save()\n except KeyError:\n status = ccs.NO_SUCH_CONFIG\n except ZeroBotConfigError as ex:\n self.logger.exception(ex)\n status = ccs.SAVE_FAIL\n else:\n status = ccs.SAVE_OK\n results.append(ConfigCmdResult(config, status))\n elif subcmd == \"savenew\":\n new_path = parsed.args[\"new_path\"]\n try:\n config = self.configs[parsed.args[\"config_file\"]]\n except KeyError:\n status = ccs.NO_SUCH_CONFIG\n else:\n if new_path is not None:\n Path(new_path).parent.mkdir(parents=True, exist_ok=True)\n try:\n config.save(new_path)\n except ZeroBotConfigError as ex:\n self.logger.exception(ex)\n status = ccs.SAVE_FAIL\n else:\n status = ccs.SAVE_OK\n results.append(ConfigCmdResult(config, status, None, None, new_path))\n elif subcmd == \"reload\":\n pool = parsed.args[\"config_file\"]\n if not pool:\n pool = self.configs.keys()\n for name in pool:\n try:\n config = self.configs[name]\n config.load()\n except KeyError:\n status = ccs.NO_SUCH_CONFIG\n except ZeroBotConfigError as ex:\n self.logger.exception(ex)\n status = ccs.RELOAD_FAIL\n else:\n status = ccs.RELOAD_OK\n try:\n await self.module_send_event(\"config_reloaded\", ctx, name)\n except Exception:\n self.logger.exception(\"Uncaught exception in config_reloaded handler\")\n results.append(ConfigCmdResult(config, status))\n await ctx.core_command_config(parsed, results)","def parse_command_line(self):\n return self.command_line_parser.parse()","def parse(filename, symbolDict):\n lineNum = 0\n commands = []\n file = open(filename, \"r\")\n for line in file.readlines():\n # remove comments and spaces from line\n line = \"\".join(line.split(\"//\")[0].split())\n if not line:\n continue\n\n cmdA = Ains(symbolDict)\n cmdC = Cins(symbolDict)\n label = Label(symbolDict)\n\n if cmdA.parse(line, lineNum):\n lineNum += 1\n commands.append(cmdA)\n elif cmdC.parse(line, lineNum):\n lineNum += 1\n commands.append(cmdC)\n elif not label.parse(line, lineNum):\n file.close()\n return []\n\n file.close()\n return commands","def __init__(self, command_line: List[str]) -> None:\n self.command_line = list(command_line)","def _parse(self, content):\n os.environ['ASTER_VERSION_DIR'] = self.dirn\n cfg = {}\n self._content = content\n for l in split_endlines(self._content):\n if not re.search('^[ ]*#', l):\n try:\n typ, nam, ver, val = l.split('|')\n #print '========>', typ, '//', nam, '//', ver, '//', val\n typ = re.sub('^[ ]*', '', re.sub('[ ]*$', '', typ)).strip()\n val = re.sub('^[ ]*', '', re.sub('[ ]*$', '', val)).strip()\n if val != '':\n val = osp.expandvars(val)\n if cfg.has_key(typ):\n cfg[typ].append(val)\n else:\n cfg[typ] = [val]\n except ValueError:\n pass\n return cfg","def config(*subconfig):\n\n with open('configure.yaml', 'r') as stream:\n args = yaml.load(stream)\n\n # Parse command line arguments\n parser = argparse.ArgumentParser(description='')\n parser.add_argument(\n '--node',\n '-n',\n help='The node ID.'\n )\n parser.add_argument(\n '--processes',\n '-p',\n help='The total number of processes.'\n )\n # Store command line arguments in a dict\n cl_args = parser.parse_args()\n cl_args_dict = vars(cl_args)\n # Combine\n args.update(cl_args_dict)\n # Find subconfig if argument is passed\n for s in subconfig:\n try:\n args = args[s]\n except:\n pass\n # Return\n return args","def default(self, line: str) -> None:\n commands = shlex.split(line)\n\n self.main_function(\n [list(command)\n for is_pipe_operator, command in itertools.groupby(commands, lambda word: word == '|')\n if not is_pipe_operator],\n '&' not in commands\n )","def do_configure(self, line):\n items = line.split(' ')\n try:\n node = self.fibbing[items[0]]\n result = node.vtysh(*items[1:], configure=True)\n result = result.strip(' \\n\\t')\n if result:\n log.info(result)\n except KeyError:\n log.error('Unknown node %s', items[0])","def get_commands(steplist):\n commands = []\n for step in steplist:\n if hasattr(step, 'command'):\n cmdhash = {}\n renderables = []\n accumulateClassList(step.__class__, 'renderables', renderables)\n\n for renderable in renderables:\n setattr(step, renderable, step.build.render(getattr(step,\n renderable)))\n\n cmdhash['name'] = step.name\n cmdhash['command'] = step.command\n cmdhash['workdir'] = step.workdir\n if hasattr(step, 'env'):\n cmdhash['env'] = step.env\n else:\n cmdhash['env'] = {}\n if hasattr(step, 'timeout'):\n print \"yay!~\"\n cmdhash['timeout'] = step.timeout\n\n cmdhash['description'] = step.description\n cmdhash['descriptionDone'] = step.descriptionDone\n commands.append(cmdhash)\n return commands","def newline_list(value):\n return value.strip().splitlines()","async def listcommands(self, ctx):\n\t\twith open('custom_commands.json', 'r') as f:\n\t\t\tcommands = json.load(f)\n\t\t\toutput = \", \".join([*commands])\n\t\t\tawait ctx.send(f\"```List of custom commands:\\n{output}```\")","def list_command(env: Optional[str], config: str) -> None:\n layer = Layer.load_from_yaml(config, env)\n amplitude_client.send_event(amplitude_client.LIST_SECRETS_EVENT)\n gen_all(layer)\n _raise_if_no_k8s_cluster_exists(layer)\n\n configure_kubectl(layer)\n load_kube_config()\n v1 = CoreV1Api()\n api_response = v1.read_namespaced_secret(\"secret\", layer.name)\n if api_response.data is None:\n print(\n \"No secrets found, you can make some by adding them in you opta file k8s service\"\n )\n return\n for key in api_response.data:\n print(key)","def parse_arguments():\n custom_config = config.read()\n arguments = docopt(__doc__, version='Montanus %s' % __version__)\n logger.debug(custom_config)\n conf_file = arguments.get('--with-conf')\n if conf_file is not None:\n conf_config = config.read(conf_file)\n\n for (k, v) in conf_config.items():\n if v is not None:\n custom_config[k] = v\n\n logger.debug(arguments)\n command_config = {\n 'templates_path': arguments.get('<templates_path>'),\n 'static_files_path': arguments.get('--with-static-files-path') \\\n if arguments.get('-with-static-files-path') is not None \\\n else arguments.get('<templates_path>'),\n 'delete_source': arguments.get('--delete'),\n 'protocol': arguments.get('--with-protocol'),\n 'domains': arguments.get('--with-domains').split(',') \\\n if arguments.get('--with-domains') is not None \\\n else None,\n 'md5_len': int(arguments.get('--with-md5-len')),\n 'md5_concat_by': arguments.get('--with-md5-concat-by')\n }\n logger.debug(command_config)\n\n for (k, v) in command_config.items():\n if v is not None:\n custom_config[k] = v\n\n logger.debug(custom_config)\n return DictWrapper(custom_config)","def do_list_commands(self):\n result = \"\\n\".join(self.commands.keys())\n return result, True","def commands():","def _parse_cmds(self):\n lst = self.inbuffer.split('\\n')\n # leave trailing text (not terminated by \\n) in inbuffer\n self.inbuffer = lst.pop(-1)\n if lst:\n for cmd in lst:\n self.cmds.append(cmd)","def parse_config(cmdline_opts):\n cmdline_opts.add_argument(\n '-p', '--port', help='Enter port number', default=8001)\n cmdline_opts.add_argument(\n '--host', help='Enter host name', default='localhost')\n cmdline_opts.add_argument(\n '-c', '--config', help='Enter config file', default='config.json')","def process_switch_config(self, switch_list):\n final_switch_list = []\n for _switchentry in switch_list:\n _switcharr = _switchentry.split(':')\n if len(_switcharr) == 2:\n _ports = _switcharr[1]\n _ports = _ports.split(';')\n else:\n _ports = ['none']\n _hostname = _switcharr[0]\n final_switch_list.append({'name': _hostname,\n \"ports\": _ports})\n return final_switch_list","def read_commands_from_console():\n cmds = []\n print 'Please provide commands for REA Robot. One command per line. An empty line finishes the input:'\n while True:\n line = raw_input()\n if line:\n cmds += [line.upper()]\n else:\n break\n\n return cmds","def getCommands(self):","def main_list(args):\n return list_commands(args.directory)","def format_commands(self, ctx, formatter):\n commands = []\n for subcommand in self.list_commands(ctx):\n cmd = self.get_command(ctx, subcommand)\n # What is this, the tool lied about a command. Ignore it\n if cmd is None:\n continue\n if cmd.hidden:\n continue\n\n commands.append((subcommand, cmd))\n\n # allow for 3 times the default spacing\n if len(commands):\n limit = formatter.width - 6 - max(len(cmd[0]) for cmd in commands)\n\n rows = []\n for subcommand, cmd in commands:\n help = cmd.get_short_help_str(limit)\n rows.append((subcommand, help))\n\n if rows:\n formatter.write_dl(rows)","def _create_commands(self, data):\n lines = []\n idone, odone = False, False\n for line in data.split(b'\\n'):\n if line.startswith(b'@intext'):\n if self.inputastext is None:\n self.metadata['inputastext'] = True\n self.inputastext = True\n idone = True\n elif line.startswith(b'@outtext'):\n if self.outputastext is None:\n self.metadata['outputastext'] = True\n self.outputastext = True\n odone = True\n else:\n # remove eventual comment\n m = re.match(br'(.*?);', line)\n if m:\n line = m.group(1)\n line = line.rstrip()\n if line:\n lines.append(line)\n if not idone:\n if self.inputastext:\n self.metadata['inputastext'] = True\n if not odone:\n if self.outputastext:\n self.metadata['outputastext'] = True\n if not lines:\n raise CarError('no source code')\n min_indent = len(lines[0]) # temporary\n for line in lines:\n indent = len(line) - len(line.lstrip())\n if indent == 0:\n break\n if indent < min_indent:\n min_indent = indent\n else:\n lines = tuple(x[min_indent:] for x in lines)\n\n #self.raw_board = '\\n'.join(lines) # for an eventual curses simulator\n\n board = []\n has_car, has_exit = False, False\n y = 0\n for line in lines:\n row = array.array('B')\n x = 0\n for c in line:\n try:\n op = _opcode_to_const_map[c]\n except KeyError:\n op = NOP\n if op == CAR:\n if has_car:\n raise CarError('program can only have one car')\n has_car = True\n car_pos = (x, y)\n row.append(NOP)\n else:\n row.append(op)\n if op == EXIT:\n if has_exit:\n raise CarError('program can only have one exit')\n has_exit = True\n x += 1\n board.append(row)\n y += 1\n if not has_car:\n raise CarError('program must have one car')\n if not has_exit:\n raise CarError('program must have one exit')\n return self._board_to_commands(board, car_pos)","def parse_cfg(cfgfile):\n file = open(cfgfile, \"r\")\n lines = file.read().split(\"\\n\") # store the lines in a list\n lines = [x for x in lines if len(x) > 0] # get read of the empty lines \n lines = [x for x in lines if x[0] != \"#\"] # get rid of comments\n lines = [x.rstrip().lstrip() for x in lines] # get rid of fringe whitespaces\n\n block = {}\n blocks = []\n\n for line in lines:\n if line[0] == \"[\":\n if len(block) != 0:\n blocks.append(block)\n block = {}\n block[\"type\"] = line[1:-1].rstrip()\n else:\n key, value = line.split(\"=\")\n block[key.rstrip()] = value.lstrip()\n blocks.append(block)\n return blocks","def encode_commands(command_list: List[str]) -> List[str]:\n return ['-'.join(x.split(' ')) for x in command_list]","def config(self, filter_includes=False):\n def the_filter(k):\n if filter_includes and k is not None and k.lower() == \"include\":\n return False\n else:\n return True\n \n return \"\\n\".join([x.line for x in self.lines_ if the_filter(x.key)])","def _test_config_generator_list_wrap():\n class Config(config.Config):\n a = config.option_list(str, default=[\"abcdefghijklmnopqrstuvwxyz\" for _ in range(2)], help=\"\")\n b = config.option_list(str, default=[\"abcdefghijklmnopqrstuvwxyz\" for _ in range(5)], help=\"\")\n abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz = config.option_list(str, help=\"\")\n\n return Config, [\n # Shorter than threshold, don't split\n 'a = [\"abcdefghijklmnopqrstuvwxyz\", \"abcdefghijklmnopqrstuvwxyz\"]',\n # Longer than threshold, split\n 'b = [',\n ' \"abcdefghijklmnopqrstuvwxyz\",',\n ' \"abcdefghijklmnopqrstuvwxyz\",',\n ' \"abcdefghijklmnopqrstuvwxyz\",',\n ' \"abcdefghijklmnopqrstuvwxyz\",',\n ' \"abcdefghijklmnopqrstuvwxyz\",',\n ']',\n # Key longer than threshold, but no items, don't split\n 'abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz = []',\n ]","def gen_command_line(self, testcase):\n found_double_at = False\n new_args = []\n\n for arg in self.target_cmdline:\n if arg == '@@':\n found_double_at = True\n new_args.append(testcase)\n else:\n new_args.append(arg)\n\n if found_double_at:\n stdin = None\n else:\n with open(testcase, 'rb') as inf:\n stdin = inf.read()\n\n return new_args, stdin","def getCommands(self):\r\n return [z for x, y, z in self._log if x == 'command']","def create_command_list(device):\n command = XmlApiObject({})\n command.name = \"test\"\n device.commands[command.name] = command","def _separate(self):\n s = self.as_yamlstr()\n self._config = yaml.load(s, Loader=yaml.Loader)\n self._comments = self._extract_comments(self._yaml_config)","def commands(self) -> typing.List[str]:\n return self._values.get(\"commands\")","def parse_config(path):\n #Open the file\n f = open(path)\n section = None\n\n #for each line in file:\n for line in f:\n #Get rid of extra spaces and carridge-returns\n line = line.rstrip('\\r\\n')\n\n #If there is a comment on the line, get rid of everything after the comment symbol and trim whitespace\n #Example: hi there #This is a comment\n if \"#\" in line:\n line, comment = line.split(\"#\", 1)\n line = line.strip()\n\n #If there is a section header on the line, figure out what it's name is, and save it\n if \"[\" in line:\n #Example: [StartupMods]\n section = line.split(\"[\", 1)[1].split(\"]\", 1)[0]\n parsed_config[section] = list()\n\n #If there is no section header, than the line must contian data, so save it under the current section\n else:\n if line is not \"\":\n parsed_config[section].append(line)\n\n #Message the system\n logging.info(\"Finished parsing \" + path)\n return parsed_config","def _command_as_list(module_name):\n parts = module_name.split('.')\n for part in COMMANDS_PACKAGE_NAME.split('.'):\n if parts[0] == part:\n parts = parts[1:]\n return [SCRIPT_COMMAND] + parts","def compile_commands(commands):\n return [ord(char) for char in ''.join([c + '\\n' for c in commands])]","def _parse_and_validate(raw_config_list):\n items = []\n for raw in raw_config_list:\n\n # Validation.\n for key in CONFIGS_REQUIRED:\n if key not in raw or raw[key] is None:\n raise ConfigError(\"must specify '%s' in item config: %s\" % (key, raw))\n\n if \"version_string\" in raw and not _CONFIG_VERSION_RE.match(str(raw[\"version_string\"])):\n raise ConfigError(\"invalid version string: '%s'\" % raw[\"version_string\"])\n if \"version_string\" not in raw and \"version_hashable\" not in raw and \"version_command\" not in raw:\n raise ConfigError(\"must specify 'version_string', 'version_hashable', or 'version_command' in item config: %s\" % raw)\n\n # Validate shell templates.\n # For these, we don't expand environment variables here, but instead do it at once at call time.\n for key in \"upload_command\", \"download_command\":\n try:\n strif.shell_expand_to_popen(raw[key], {\"REMOTE\": \"dummy\", \"LOCAL\": \"dummy\"})\n except ValueError as e:\n raise ConfigError(\"invalid command in config value for %s: %s\" % (key, e))\n\n # Normalize and expand environment variables.\n for key in \"local_path\", \"remote_prefix\", \"remote_path\":\n if key.startswith(\"/\"):\n raise ConfigError(\"currently only support relative paths for local_path and remote_path: %s\" % key)\n raw[key] = raw[key].rstrip(\"/\")\n\n try:\n raw[key] = strif.expand_variables(raw[key], os.environ)\n except ValueError as e:\n raise ConfigError(\"invalid command in config value for %s: %s\" % (key, e))\n\n # Parse enums.\n try:\n raw[\"install_method\"] = InstallMethod[raw[\"install_method\"]]\n except KeyError:\n raise ConfigError(\"invalid install_method: %s\" % raw[\"install_method\"])\n\n # Parse booleans. Values True and False may already be converted.\n try:\n if (type(raw[\"make_backup\"]) is str):\n raw[\"make_backup\"] = raw[\"make_backup\"].lower() in (\"on\", \"t\", \"true\", \"y\", \"yes\")\n except KeyError:\n raise ConfigError(\"invalid make_backup: %s\" % raw[\"make_backup\"])\n\n items.append(Config(**raw))\n\n log.debug(\"final configs: %s\", items)\n return items","def test_by_config(self):\n # addon_executor = AddonExecutor(execute_order, stop_order)\n # self.assertEqual(expected, addon_executor.execute_with_config(addon))\n\n self.run_mgr.by_default(self.cli_inst)\n output = self._get_lines_as_list(sys.stdout)\n\n self.assertTrue(output[0].startswith('Start'))\n self.assertTrue(output[1].startswith('Execute'))\n self.assertTrue(output[2].startswith('Stop'))","async def adding_command_list(self):\n command_aliases=['anime','fun','mod','nekogif'] #This includes the aliases and the cog names\n #NOTE: fun command added\n for i in self.bot.commands:\n self.commands.append(i.name)\n \n for i in command_aliases:\n self.commands.append(i)","def _parse_command(self, cmd):\n if isinstance(cmd, list):\n args = [str(x) for x in cmd]\n assert args\n else:\n args = shlex.split(cmd)\n return args"],"string":"[\n \"def config_changes(cli):\\n result = []\\n in_config = False\\n for line in cli.splitlines():\\n if not in_config and line == 'Building configuration...':\\n in_config = True\\n elif in_config:\\n result.append(line)\\n\\n return '\\\\n'.join(result)\",\n \"def get_commands_list() -> list:\\n return open(\\\"data/metadata/commands.list.txt\\\", \\\"r\\\").read().split(\\\"\\\\n\\\")\",\n \"def config_to_list(config_name=CONFIG_FILE_NAME):\\n result = []\\n config = configparser.ConfigParser()\\n\\n if not config.read([config_name]):\\n return []\\n\\n for section in SECTIONS:\\n for name, opts in ((n, o) for n, o in SECTIONS[section].items() if config.has_option(section, n)):\\n value = config.get(section, name)\\n\\n if value != '' and value != 'None':\\n action = opts.get('action', None)\\n\\n if action == 'store_true' and value == 'True':\\n # Only the key is on the command line for this action\\n result.append('--{}'.format(name))\\n\\n if not action == 'store_true':\\n if opts.get('nargs', None) == '+':\\n result.append('--{}'.format(name))\\n result.extend((v.strip() for v in value.split(',')))\\n else:\\n result.append('--{}={}'.format(name, value))\\n\\n return result\",\n \"def commands(config, names):\\n commands = {\\n cmd: Command(\\n **{minus_to_underscore(k): v for k, v in config.items(cmd)}\\n )\\n for cmd in config.sections()\\n if cmd != 'packages'\\n }\\n\\n try:\\n return tuple(commands[x] for x in names)\\n except KeyError as e:\\n raise RuntimeError(\\n 'Section [commands] in the config file does not contain the '\\n 'key {.args[0]!r} you requested to execute.'.format(e))\",\n \"def load_command_list(filename=None):\\n contents = None\\n if filename:\\n logger.debug('Attempting to read commands from \\\"{}\\\"'.format(filename))\\n with open(filename, 'r') as fp:\\n contents = fp.read().strip()\\n\\n if not contents:\\n contents = ''\\n\\n # Split data as lines (ignore empty)\\n return [l.strip().upper() for l in contents.split('\\\\n') if l.strip() != '']\",\n \"def add_config(self, config):\\n clean=lambda n: n.strip().strip('\\\"').lower()\\n for line in config.split('\\\\n'):\\n items=line.strip().split()\\n if items and len(items) >= 3:\\n cmd, evt, hnd=items[:3]\\n \\\"\\\"\\\" NOTE\\n - just 'bind' command expected right now\\n - '+' prepended ti the handler means REPEAT (make sense just for keyboard keys actually)\\n \\\"\\\"\\\"\\n cmd=clean(cmd)\\n if cmd in ['bind']:\\n evt,hnd=(clean(evt), clean(hnd))\\n if not cmd in self.config: self.config[cmd]={}\\n repeat=hnd.startswith('+')\\n if repeat: hnd=hnd[1:]\\n self.config[cmd].update([[evt, [hnd, repeat]]])\",\n \"def get_config_lines(self, key):\\n return \\\" \\\".join([key, self._config[key][\\\"value\\\"], \\\"#\\\", self._config[key][\\\"comments\\\"]] if self._config[key][\\\"comments\\\"] is not None\\n else [key, self._config[key][\\\"value\\\"]])\",\n \"def test_removes_trailing_newline_from_complex_keys(self):\\n commands = list(parser.generate_commands(yaml.load(\\\"\\\"\\\"\\n - ? >\\n Line 1\\n Line 2\\n : retries: 1\\n \\\"\\\"\\\")))\\n assert commands == [('Line 1 Line 2', {'retries': 1})]\",\n \"def parse_commands(command_list: List[str]) -> List[str]:\\n return [' '.join(x.split('-')) for x in command_list]\",\n \"def configToCliArguments(config):\\n if not isinstance(config, dict):\\n raise TypeError(\\\"Expected dict for config\\\")\\n\\n args = []\\n for key, value in config.items():\\n if value == None:\\n args.append(f\\\"--{key}\\\")\\n continue\\n\\n if isinstance(value, list):\\n value = \\\",\\\".join(value)\\n args.append(f\\\"--{key}={value}\\\")\\n\\n return args\",\n \"def makeConfig (self):\\n for line in self.lines :\\n ll = line.split ('=', 1)\\n if len(ll) < 2 :\\n print \\\"Error in parsing cfg label line: \\\" , line\\n return None\\n self.config[(ll[0]).strip()] = ((ll[1]).strip())\",\n \"def _config_list(res, ctx):\\n\\n if _has_error_code(res):\\n return print_errors(res, ctx)\\n\\n lines = []\\n for config in res['configs']:\\n line = '* ' if config['current'] else ' '\\n\\n if ctx.verbose:\\n line += config['mtime'] + ' '\\n\\n line += config['name']\\n lines.append(line)\\n\\n return \\\"\\\\n\\\".join(lines)\",\n \"def config(bot, event, cmd=None, *args):\\n\\n # consume arguments and differentiate beginning of a json array or object\\n tokens = list(args)\\n parameters = []\\n value = []\\n state = \\\"key\\\"\\n for token in tokens:\\n if token.startswith((\\\"{\\\", \\\"[\\\")):\\n # apparent start of json array/object, consume into a single list item\\n state = \\\"json\\\"\\n if state == \\\"key\\\":\\n parameters.append(token)\\n elif state == \\\"json\\\":\\n value.append(token)\\n else:\\n raise ValueError(\\\"unknown state\\\")\\n if value:\\n parameters.append(\\\" \\\".join(value))\\n print(\\\"config {}\\\".format(parameters))\\n\\n if cmd == 'get' or cmd is None:\\n config_args = list(parameters)\\n value = bot.config.get_by_path(config_args) if config_args else dict(bot.config)\\n elif cmd == 'set':\\n config_args = list(parameters[:-1])\\n if len(parameters) >= 2:\\n bot.config.set_by_path(config_args, json.loads(parameters[-1]))\\n bot.config.save()\\n value = bot.config.get_by_path(config_args)\\n else:\\n yield from command.unknown_command(bot, event)\\n return\\n elif cmd == 'append':\\n config_args = list(parameters[:-1])\\n if len(parameters) >= 2:\\n value = bot.config.get_by_path(config_args)\\n if isinstance(value, list):\\n value.append(json.loads(parameters[-1]))\\n bot.config.set_by_path(config_args, value)\\n bot.config.save()\\n else:\\n value = _('append failed on non-list')\\n else:\\n yield from command.unknown_command(bot, event)\\n return\\n elif cmd == 'remove':\\n config_args = list(parameters[:-1])\\n if len(parameters) >= 2:\\n value = bot.config.get_by_path(config_args)\\n if isinstance(value, list):\\n value.remove(json.loads(parameters[-1]))\\n bot.config.set_by_path(config_args, value)\\n bot.config.save()\\n else:\\n value = _('remove failed on non-list')\\n else:\\n yield from command.unknown_command(bot, event)\\n return\\n else:\\n yield from command.unknown_command(bot, event)\\n return\\n\\n if value is None:\\n value = _('Parameter does not exist!')\\n\\n config_path = ' '.join(k for k in ['config'] + config_args)\\n segments = [hangups.ChatMessageSegment('{}:'.format(config_path),\\n is_bold=True),\\n hangups.ChatMessageSegment('\\\\n', hangups.SegmentType.LINE_BREAK)]\\n segments.extend(text_to_segments(json.dumps(value, indent=2, sort_keys=True)))\\n bot.send_message_segments(event.conv, segments)\",\n \"def parse(self):\\n raw_config_lines = self.load_config()\\n self.config_lines_str = raw_config_lines\\n self._create_cfg_line_objects()\",\n \"def process_commands(self, commands: List[str]):\",\n \"def configDict(config):\\n config_dict = {}\\n line_number = 0\\n if type(config) == str:\\n config_object = config.splitlines()\\n else:\\n return \\\"ERROR: config not type str\\\"\\n for index, line in enumerate(config_object):\\n if not bool(re.match(\\\"^\\\\s|!\\\", line)):\\n line_number = index\\n config_dict[line] = []\\n elif bool(re.match(\\\"^\\\\s\\\", line)):\\n config_dict[config_object[line_number]].append(line.strip())\\n return config_dict\",\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 command_groups(self, lines):\\n for line in lines:\\n match = command_regex.match(line)\\n if match:\\n if self.current_group:\\n yield self.current_group\\n groupdict = match.groupdict()\\n comm = groupdict['comm']\\n param = groupdict['param']\\n if param:\\n param = param[1:-1]\\n data = groupdict['data']\\n self.current_group = (comm, param, data)\\n self.parse_multiline = True\\n elif self.parse_multiline:\\n match = cont_regex.match(line)\\n if cont_regex.match(line):\\n new_data, = match.groups()\\n if new_data:\\n name, param, data = self.current_group\\n data += ' ' + new_data\\n self.current_group = (name, param, data)\\n else:\\n self.parse_multiline = False\\n else:\\n self.parse_multiline = False\\n if self.current_group:\\n yield self.current_group\\n self.current_group = []\",\n \"def get_by_name_as_list(cls, name, token=','):\\n config = Configuration.get_by_name(name) or []\\n if config:\\n return [item.strip() for item in config.split(token)]\\n else:\\n return config\",\n \"def _config_sections(self):\\n data = []\\n section_data = []\\n for index, line in enumerate(self.running_config):\\n if self._nextline_startswith_space(index):\\n section_data.append(line)\\n else:\\n if len(section_data) > 0:\\n section_data.append(line)\\n data.append(section_data)\\n section_data = []\\n return data\",\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 list_config():\\n console = Console()\\n _config = loadConfig()\\n json_data = richJSON.from_data({**asdict(_config)})\\n console.print(Panel(json_data, title=\\\"SubmarineCliConfig\\\"))\",\n \"def config(name, config, edit=True):\\n\\n configs = []\\n for entry in config:\\n key = next(iter(entry.keys()))\\n configs.append(_parse_config(entry[key], key))\\n\\n # Python auto-correct line endings\\n configstext = \\\"\\\\n\\\".join(salt.utils.data.decode(configs))\\n if edit:\\n with salt.utils.files.fopen(name, \\\"w\\\") as configfile:\\n configfile.write(\\\"# This file is managed by Salt.\\\\n\\\")\\n configfile.write(salt.utils.stringutils.to_str(configstext))\\n return configstext\",\n \"def load_commands(filename):\\n lines_out = []\\n try:\\n with open(filename, \\\"r\\\") as inFile:\\n for line in inFile.readlines():\\n comment = line.find(';') # Don't read comments after ';'\\n if comment != -1:\\n line = line[:comment]\\n line = line.strip()\\n if len(line) > 0: # Don't read lines of length 0.\\n lines_out.append(line)\\n except FileNotFoundError:\\n print(f\\\"File {filename} not found.\\\")\\n return lines_out\",\n \"def parse_from_string(self, blob: str) -> None:\\n\\t\\tself._entries = []\\n\\t\\tis_not_set_matcher = re.compile(CONFIG_IS_NOT_SET_PATTERN)\\n\\t\\tconfig_matcher = re.compile(CONFIG_PATTERN)\\n\\t\\tfor line in blob.split('\\\\n'):\\n\\t\\t\\tline = line.strip()\\n\\t\\t\\tif not line:\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\telif config_matcher.match(line) or is_not_set_matcher.match(line):\\n\\t\\t\\t\\tself._entries.append(KconfigEntry(line))\\n\\t\\t\\telif line[0] == '#':\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\telse:\\n\\t\\t\\t\\traise KconfigParseError('Failed to parse: ' + line)\",\n \"def config(ctx):\\n if not ctx.invoked_subcommand:\\n cfg = ctx.obj['cfg']\\n for section in cfg.sections():\\n print(\\\"[\\\", section, \\\"]\\\")\\n for option in cfg[section]:\\n print(option, \\\" = \\\", cfg[section][option])\",\n \"def parse(self, lines):\\n cur_entry = None\\n indents = []\\n for line in lines:\\n kv_ = _key_value(line)\\n if len(kv_) > 1:\\n key, value = kv_\\n if key.lower() == \\\"host\\\":\\n cur_entry = value\\n self.hosts_.add(value)\\n else:\\n indents.append(_indent(line))\\n self.lines_.append(ConfigLine(line=line, host=cur_entry, key=key, value=value))\\n else:\\n self.lines_.append(ConfigLine(line=line))\\n # use most popular indent as indent for file, default ' '\\n counter = Counter(indents)\\n popular = list(reversed(sorted(counter.items(), key=lambda e: e[1])))\\n self.indent = popular[0][0] if len(popular) > 0 else ' '\",\n \"def config(self):\\n return \\\"\\\\n\\\".join([ c.config(True) for p, c in self.configs_ ])\",\n \"def normalize(self, cfg):\\n clean_cfg = []\\n\\n for line in cfg.splitlines():\\n\\n if not line.strip():\\n # empty line\\n continue\\n if \\\"--More--\\\" in line:\\n # pick up anything that may be included after the \\\"More\\\"\\n line = line[line.find('--More--') + 8:]\\n if not line.split():\\n # emptied line\\n continue\\n if line.startswith('#'):\\n continue\\n if line.startswith('!'):\\n continue\\n if line.startswith('Current configuration'):\\n continue\\n if line.rstrip().endswith(\\\"#\\\"):\\n continue\\n if line.split()[0] in self.skip:\\n continue\\n if self._check_timestamps(line):\\n continue\\n line = self._check_special_handles(line)\\n if line is None:\\n continue\\n\\n clean_cfg.append(line.strip())\\n\\n return clean_cfg\",\n \"def config(bot, event, cmd=None, *args):\\n\\n # consume arguments and differentiate beginning of a json array or object\\n tokens = list(args)\\n parameters = []\\n value = []\\n state = \\\"key\\\"\\n for token in tokens:\\n if token.startswith((\\\"{\\\", \\\"[\\\", '\\\"', \\\"'\\\")):\\n # apparent start of json array/object, consume into a single list item\\n state = \\\"json\\\"\\n if state == \\\"key\\\":\\n parameters.append(token)\\n elif state == \\\"json\\\":\\n value.append(token)\\n else:\\n raise ValueError(\\\"unknown state\\\")\\n if value:\\n parameters.append(\\\" \\\".join(value))\\n\\n if cmd == 'get' or cmd is None:\\n config_args = list(parameters)\\n value = bot.config.get_by_path(config_args) if config_args else dict(bot.config)\\n\\n elif cmd == 'test':\\n num_parameters = len(parameters)\\n text_parameters = []\\n last = num_parameters - 1\\n for num, token in enumerate(parameters):\\n if num == last:\\n try:\\n json.loads(token)\\n token += \\\" <b>(valid json)</b>\\\"\\n except ValueError:\\n token += \\\" <em>(INVALID)</em>\\\"\\n text_parameters.append(str(num + 1) + \\\": \\\" + token)\\n text_parameters.insert(0, \\\"<b>config test</b>\\\")\\n\\n if num_parameters == 1:\\n text_parameters.append(_(\\\"<em>note: testing single parameter as json</em>\\\"))\\n elif num_parameters < 1:\\n yield from command.unknown_command(bot, event)\\n return\\n\\n yield from bot.coro_send_message(event.conv, \\\"<br />\\\".join(text_parameters))\\n return\\n\\n elif cmd == 'set':\\n config_args = list(parameters[:-1])\\n if len(parameters) >= 2:\\n bot.config.set_by_path(config_args, json.loads(parameters[-1]))\\n bot.config.save()\\n value = bot.config.get_by_path(config_args)\\n else:\\n yield from command.unknown_command(bot, event)\\n return\\n\\n elif cmd == 'append':\\n config_args = list(parameters[:-1])\\n if len(parameters) >= 2:\\n value = bot.config.get_by_path(config_args)\\n if isinstance(value, list):\\n value.append(json.loads(parameters[-1]))\\n bot.config.set_by_path(config_args, value)\\n bot.config.save()\\n else:\\n value = _('append failed on non-list')\\n else:\\n yield from command.unknown_command(bot, event)\\n return\\n\\n elif cmd == 'remove':\\n config_args = list(parameters[:-1])\\n if len(parameters) >= 2:\\n value = bot.config.get_by_path(config_args)\\n if isinstance(value, list):\\n value.remove(json.loads(parameters[-1]))\\n bot.config.set_by_path(config_args, value)\\n bot.config.save()\\n else:\\n value = _('remove failed on non-list')\\n else:\\n yield from command.unknown_command(bot, event)\\n return\\n\\n else:\\n yield from command.unknown_command(bot, event)\\n return\\n\\n if value is None:\\n value = _('Parameter does not exist!')\\n\\n config_path = ' '.join(k for k in ['config'] + config_args)\\n segments = [hangups.ChatMessageSegment('{}:'.format(config_path),\\n is_bold=True),\\n hangups.ChatMessageSegment('\\\\n', hangups.SegmentType.LINE_BREAK)]\\n segments.extend(text_to_segments(json.dumps(value, indent=2, sort_keys=True)))\\n yield from bot.coro_send_message(event.conv, segments)\",\n \"def parse_lines(lines, packages):\\n for line in lines:\\n x = line.split(' ')\\n cmd = x[0].upper()\\n #LOG.debug(cmd)\\n if 'LIST' in cmd:\\n getattr(commands, cmd)(p)\\n else:\\n getattr(commands, cmd)(line, p)\",\n \"async def read_config(self, save: str | bool = False) -> list[str]:\\n key_value_re = re.compile(\\\"^(.+?)=(.*)$\\\")\\n\\n def parse_line(line):\\n k, v = key_value_re.match(line).groups()\\n # It seems the GUI replaces / with \\\\ even if that doesn't seem\\n # necessary in the INI format.\\n k = k.replace(\\\"/\\\", \\\"\\\\\\\\\\\")\\n if \\\";\\\" in v or \\\"=\\\" in v or \\\",\\\" in v:\\n v = f'\\\"{v}\\\"'\\n return k, v\\n\\n cmd_strs = [f\\\"RCONFIG{n_line:04X}\\\" for n_line in range(MAX_CONFIG_LINES)]\\n done, failed = await self.send_many(cmd_strs, max_chunk=200, timeout=0.5)\\n if len(failed) > 0:\\n ff = failed[0]\\n status = ff.status.name\\n raise ArchonError(f\\\"An RCONFIG command returned with code {status!r}\\\")\\n\\n if any([len(cmd.replies) != 1 for cmd in done]):\\n raise ArchonError(\\\"Some commands did not get any reply.\\\")\\n\\n lines = [str(cmd.replies[0]) for cmd in done]\\n\\n # Trim possible empty lines at the end.\\n config = \\\"\\\\n\\\".join(lines).strip().splitlines()\\n if not save:\\n return config\\n\\n # The GUI ACF file includes the system information, so we get it.\\n system = await self.get_system()\\n\\n c = configparser.ConfigParser()\\n c.optionxform = str # Make it case-sensitive\\n c.add_section(\\\"SYSTEM\\\")\\n for sk, sv in system.items():\\n if \\\"_name\\\" in sk.lower():\\n continue\\n sl = f\\\"{sk.upper()}={sv}\\\"\\n k, v = parse_line(sl)\\n c.set(\\\"SYSTEM\\\", k, v)\\n c.add_section(\\\"CONFIG\\\")\\n for cl in config:\\n k, v = parse_line(cl)\\n c.set(\\\"CONFIG\\\", k, v)\\n\\n if isinstance(save, str):\\n path = save\\n else:\\n path = os.path.expanduser(f\\\"~/archon_{self.name}.acf\\\")\\n with open(path, \\\"w\\\") as f:\\n c.write(f, space_around_delimiters=False)\\n\\n return config\",\n \"def _commands(self) -> Dict[str, List[str]]:\\r\\n pass\",\n \"def command(command_list):\\n def add_attribute(func):\\n if not hasattr(func, \\\"command\\\"):\\n func.command = []\\n func.command.append(command_list)\\n return func\\n return add_attribute\",\n \"def _get_commands_list(self, script_obj: dict):\\n commands_list = []\\n try:\\n commands_obj = script_obj.get(\\\"commands\\\", {})\\n for command in commands_obj:\\n commands_list.append(command.get(\\\"name\\\", \\\"\\\"))\\n except Exception:\\n logger.debug(\\\"Failed getting the commands from the yml file\\\")\\n return commands_list\",\n \"def _parse_commands(self):\\n buf = b\\\"\\\"\\n while True:\\n while self._paused or b\\\"\\\\n\\\" not in buf:\\n buf += yield\\n line, buf = self._extract_line(buf)\\n assert line[:1] == b\\\"*\\\" # array\\n n_fields = int(line[1:-2])\\n fields = []\\n for i in range(n_fields):\\n while b\\\"\\\\n\\\" not in buf:\\n buf += yield\\n line, buf = self._extract_line(buf)\\n assert line[:1] == b\\\"$\\\" # string\\n length = int(line[1:-2])\\n while len(buf) < length + 2:\\n buf += yield\\n fields.append(buf[:length])\\n buf = buf[length + 2:] # +2 to skip the CRLF\\n self._process_command(fields)\",\n \"def get_shell_commands_from_config(\\n config: Dict[str, Any],\\n) -> Dict[str, ExecutorFuncT]:\\n shell_commands = config\\\\\\n .get('generic_command_config', {})\\\\\\n .get('shell_commands', {})\\n\\n command_dispatch_table = {}\\n\\n for shell_command in shell_commands:\\n name = shell_command.get('name')\\n command = shell_command.get('command')\\n if not name or not command:\\n continue\\n\\n allow_params = shell_command.get('allow_params', False)\\n\\n logging.debug(\\\"Loading command %s\\\", name)\\n command_dispatch_table[name] = partial(\\n _run_subprocess,\\n command,\\n allow_params,\\n )\\n return command_dispatch_table\",\n \"def readConfig(file=\\\"config.ini\\\"):\\n ip_pool = []\\n cmd_pool = []\\n Config=ConfigParser.ConfigParser()\\n Config.read(file)\\n machines = Config.items(\\\"MACHINES\\\")\\n commands = Config.items(\\\"COMMANDS\\\")\\n for ip in machines:\\n ip_pool.append(ip[1])\\n for cmd in commands:\\n cmd_pool.append(cmd[1])\\n print cmd[1]\\n return ip_pool,cmd_pool\",\n \"def get_commands(bot):\\n new_commands = []\\n\\n new_commands.append(Command(\\n 'mycommand', subcommands=[\\n SubCommand(\\n Opt('myoption'),\\n doc='This is a simple command with a single required option.'),\\n SubCommand(\\n Opt('custom', optional=True),\\n Opt('attached', optional=True, attached='attached argument'),\\n doc='This has two different optional options, one without an attached '\\n 'parameter, and the other requiring an attached parameter.'),\\n SubCommand(\\n Opt('trailing'),\\n Arg('arg 1'),\\n Arg('arg 2'),\\n Arg('arg 3', argtype=ArgTypes.SPLIT, additional='more args'),\\n doc='This command requires a lot of trailing arguments.'),\\n SubCommand(\\n Opt('grouped'),\\n Arg('grouped arguments', argtype=ArgTypes.MERGED),\\n doc='This will group all given arguments as a single string.'),\\n SubCommand(\\n Opt('complex', attached='attached'),\\n Opt('other', optional=True, attached='also required'),\\n Arg('arg 1'),\\n Arg('arg 2', argtype=ArgTypes.SPLIT_OPTIONAL, additional='more args'),\\n doc='The complex option has a required attached parameter, and the '\\n '\\\\'other\\\\' option also has a required attached parameter if '\\n '\\\\'other\\\\' is included. Additionally, there will be a requirement '\\n 'of at least 1 trailing argument.'),\\n SubCommand(\\n Opt('marquee'),\\n Arg('text', argtype=ArgTypes.MERGED,\\n check=lambda b, m, v, *a: len(v) <= 100,\\n check_error=\\\"Marquee message must be less than 100 characters long.\\\"),\\n doc='Creates a marquee that loops 3 times.')],\\n shortcuts=[\\n Shortcut(\\n 'complex', 'complex {attached} other {other} {arg 1} {arg 2}',\\n Arg('attached'), Arg('other'), Arg('arg 1'),\\n Arg('arg 2', argtype=ArgTypes.SPLIT_OPTIONAL)),\\n Shortcut(\\n 'marquee', 'marquee {text}', Arg('text', argtype=ArgTypes.MERGED))],\\n description='Your command description here.',\\n other='This text is optional - it just shows up after everything '\\n 'else. Quick note, all of the commands here can only be used by '\\n 'bot moderators or above, as indicated by elevated_level. A '\\n 'level of 2 would mean only server owners or above can use the '\\n 'command, and a level of 3 would restrict the command to only '\\n 'the bot owners.',\\n elevated_level=1, category='demo'))\\n\\n new_commands.append(Command(\\n 'myothercommand', subcommands=[\\n SubCommand(\\n Arg('text', argtype=ArgTypes.MERGED_OPTIONAL),\\n doc='This traps all further commands from being executed.'),\\n SubCommand(\\n Opt('order'), Opt('matters'),\\n doc='It is impossible to access this command because the first '\\n 'subcommand will always be satisfied first. Order of the '\\n 'subcommand matters!'),\\n SubCommand(\\n Opt('sample'), Opt('foo'), Opt('bar'),\\n doc='Also impossible to access. This subcommand just adds some '\\n 'keywords to the command.')],\\n description='Only bot owners can see this text!',\\n other='Note that no shortcuts were defined. They, too, are optional. '\\n 'Also, this command is hidden, which means that only the bot '\\n 'owners can see this command listed from the help command. '\\n 'However, unless the command is configured with an elevated '\\n 'permissions level, any user can still execute the command. '\\n 'Users still will not be able to see the specific help for this '\\n 'command, though. Lastly, this command is disabled in DMs.',\\n hidden=True, allow_direct=False, category='demo'))\\n\\n new_commands.append(Command(\\n 'notify', subcommands=[\\n SubCommand(\\n Arg('text', argtype=ArgTypes.MERGED),\\n doc='Notify the owners with some text!')],\\n other='This command uses a custom function. It is called with the '\\n 'same arguments as get_response. The command will show up to '\\n 'all users in the help command, but can only be used by server '\\n 'owners, as it is disallowed in direct messages.',\\n elevated_level=2, allow_direct=False, function=custom_notify,\\n category='demo'))\\n\\n new_commands.append(Command(\\n 'wait', other='Use this command to demo the wait_for functionality', category='demo'))\\n\\n return new_commands\",\n \"def cmd_list(args):\",\n \"def parse_config(cls, fname):\\n with open(fname) as f:\\n lines = [l.strip() for l in f.read().split('\\\\n') if l.strip()]\\n\\n comments = [l.replace('#', '').strip()\\n for l in lines if l.startswith('#')]\\n lines = [l for l in lines if not l.startswith('#')]\\n\\n # We use a simple state-machine approach to the parsing\\n # in order to deal with multi-line sections.\\n parsing = False\\n keys = cls.config_guide.keys()\\n vars = {var: [] for var in keys}\\n for line in lines:\\n if not parsing:\\n k, csv = line.split(':')\\n else:\\n csv = line\\n\\n vars[k].extend([val.strip() for val in csv.split(',')])\\n parsing = not line.endswith(';')\\n if not parsing:\\n vars[k][-1] = vars[k][-1][:-1] # remove semi-colon\\n\\n # Remove whitespace strings. These may have come from something like:\\n # c: this, , that;\\n for k in keys:\\n vars[k] = [val for val in vars[k] if val] # already stripped\\n\\n return comments, vars\",\n \"def parse_commands(self) -> list:\\n\\n command = self.path.split(\\\"?\\\")[1]\\n commands = command.split(\\\"&\\\")\\n\\n return commands\",\n \"def extract_arguments(f: TextIO) -> List[str]:\\n args = []\\n for line in f.readlines():\\n idx = line.find(\\\"#\\\")\\n if idx != -1:\\n line = line[:idx]\\n\\n args.extend(shlex.split(line))\\n return args\",\n \"def argv(self) -> List[str]:\\n if self.command:\\n rtn = [utils.strip_quotes(self.command)]\\n for cur_token in self.arg_list:\\n rtn.append(utils.strip_quotes(cur_token))\\n else:\\n rtn = []\\n\\n return rtn\",\n \"def parse_commandline_args():\\n\\n epilog = \\\"\\\"\\\"\\n The configuration file must contained a JSON-encoded map. Example: \\\"{\\\"name\\\":\\\"foo\\\"}\\\".\\n \\\"\\\"\\\"\\n\\n parser = utils.ConnectionArgumentParser(\\n description=\\\"Update config (key/value pairs) on a board\\\", epilog=epilog\\n )\\n parser.add_argument(\\n \\\"-c\\\",\\n \\\"--config\\\",\\n help=\\\"JSON file to load config from (default stdin)\\\",\\n type=open,\\n default=sys.stdin,\\n dest=\\\"file\\\",\\n )\\n parser.add_argument(\\n \\\"ids\\\", metavar=\\\"DEVICEID\\\", nargs=\\\"+\\\", type=int, help=\\\"Device IDs to flash\\\"\\n )\\n\\n return parser.parse_args()\",\n \"def parse_config(fpath):\\n\\n with open(fpath, \\\"r\\\") as f:\\n # Ignore lines consisting only of whitespace or commented lines.\\n lines = [\\n line.strip() for line in f.readlines()\\n if not (line.isspace() or line.startswith(\\\"#\\\"))\\n ]\\n\\n # Each block begins with a line of the form \\\"[type]\\\", with the block type\\n # (eg, \\\"convolutional\\\") enclosed in square brackets. Chunk config text\\n # into blocks.\\n block_start_lines = [\\n line_num for line_num, line in enumerate(lines) if line.startswith(\\\"[\\\")\\n ]\\n block_start_lines.append(len(lines))\\n\\n text_blocks = []\\n for i in range(1, len(block_start_lines)):\\n block_start, block_end = block_start_lines[i-1], block_start_lines[i]\\n text_blocks.append(lines[block_start:block_end])\\n\\n def str2type(raw_val):\\n \\\"\\\"\\\"\\n Helper function to convert a string input to the appropriate\\n type (str, int, or float).\\n \\\"\\\"\\\"\\n try:\\n return int(raw_val)\\n except ValueError:\\n pass\\n\\n try:\\n return float(raw_val)\\n except ValueError:\\n return raw_val\\n\\n blocks = []\\n net_info = None\\n for text_block in text_blocks:\\n block = {\\\"type\\\": text_block[0][1:-1]}\\n for line in text_block[1:]:\\n key, raw_val = line.split(\\\"=\\\")\\n key = key.strip()\\n\\n # Convert fields with multiple comma-separated values into lists.\\n if \\\",\\\" in raw_val:\\n val = [str2type(item.strip()) for item in raw_val.split(\\\",\\\")]\\n else:\\n val = str2type(raw_val.strip())\\n\\n # If this is a \\\"route\\\" block, its \\\"layers\\\" field contains either\\n # a single integer or several integers. If single integer, make it\\n # a list for consistency.\\n if (\\n block[\\\"type\\\"] == \\\"route\\\"\\n and key == \\\"layers\\\"\\n and isinstance(val, int)\\n ):\\n val = [val]\\n\\n # If this is a \\\"yolo\\\" block, it contains an \\\"anchors\\\" field\\n # consisting of (anchor width, anchor height) pairs of values;\\n # thus, we group anchor values into chunks of two.\\n if key == \\\"anchors\\\":\\n val = [val[i:i+2] for i in range(0, len(val), 2)]\\n\\n block[key] = val\\n\\n if block[\\\"type\\\"] == \\\"net\\\":\\n net_info = block\\n else:\\n blocks.append(block)\\n\\n return blocks, net_info\",\n \"def get_quoted_list(self, key, default=None):\\n\\n things = self.read_config_key(key, default)\\n\\n quoted_items = []\\n for thing in things:\\n new_item = '\\\"' + thing + '\\\"'\\n quoted_items.append(new_item)\\n\\n return quoted_items\",\n \"def build_commands(self):\\r\\n for tag in self.bmark.tags.keys():\\r\\n # if this tag is a command then return true\\r\\n if tag in COMMANDLIST:\\r\\n self.commands.append(tag)\",\n \"def test_CommandList():\\n from paradrop.confd.command import CommandList\\n\\n clist = CommandList()\\n clist.append(20, \\\"b\\\")\\n clist.append(20, \\\"c\\\")\\n clist.append(10, \\\"a\\\")\\n\\n commands = list(clist.commands())\\n assert commands == [\\\"a\\\", \\\"b\\\", \\\"c\\\"]\",\n \"def do_config(self, args):\\n self.config_command.cmdloop(\\\"Enter to config mode\\\")\",\n \"def extract_commands(file, out=\\\"commands.sh\\\",\\n wrappers={\\\"bash\\\": \\\"%s\\\\n\\\",\\n \\\"python\\\": \\\"python -e 'exec(\\\\\\\"\\\\\\\"\\\\\\\"%s\\\\\\\"\\\\\\\"\\\\\\\")'\\\\n\\\\n\\\"}):\\n open_tags = {\\\"```%s\\\" % lang: lang for lang in wrappers}\\n close_tag = \\\"```\\\\n\\\"\\n active = False\\n start = False\\n command = \\\"\\\"\\n lang = \\\"\\\"\\n commands = list()\\n with open(file, \\\"r\\\") as mdfile:\\n for line in mdfile:\\n start = False\\n for tag in open_tags:\\n if line.startswith(tag):\\n active = start = True\\n lang = open_tags[tag]\\n if not start and line.startswith(close_tag):\\n if active:\\n commands.append(wrappers[lang] % command)\\n command = \\\"\\\"\\n active = False\\n elif not start and active:\\n command += line\\n\\n with open(out, \\\"w\\\") as cmdfile:\\n cmdfile.write(\\\"#!/usr/bin/env bash\\\\n\\\")\\n cmdfile.write(\\\"# file: %s\\\\n\\\" % file)\\n cmdfile.write(\\\"# extracted %s\\\\n\\\\n\\\" % datetime.today())\\n for cmd in commands:\\n cmdfile.write(cmd)\\n\\n return commands\",\n \"def config(self, *args):\\n if len(args) == 1 and args[0].find('.') >= 0:\\n return self._client.execute('showconfig', args[0]).strip()\\n \\n out = self._client.execute('showconfig', args)\\n result = {}\\n\\n for line in out.splitlines():\\n ks, v = line.split('=', 1)\\n ks = ks.split('.')\\n d = result\\n for k in ks[:-1]:\\n d = d.setdefault(k, {})\\n d[ks[-1]] = v.strip()\\n\\n return result\",\n \"def commands(self):\\n if 'Commands' in self:\\n return self['Commands']\\n\\n text = self['Body']\\n commands = []\\n cmd = [\\\"\\\", \\\"\\\"]\\n isCmd = False\\n isArg = False\\n isComment = False\\n for i in range(len(text)):\\n # don't parse the commented lines\\n # ignore everyline starting with '>'\\n if text[i] == '>':\\n j = i-1\\n while text[j] in (' ', '\\\\t'):\\n j -= 1\\n if text[j] == '\\\\n':\\n isComment = True\\n elif text[i] == '\\\\n':\\n isComment = False\\n if isComment:\\n if isArg:\\n cmd[1] += text[i]\\n continue\\n\\n if text[i-1] != '\\\\\\\\' and text[i:i+2] == '._' and (isCmd or isArg):\\n isArg = False\\n commands.append(cmd)\\n cmd = [\\\"\\\", \\\"\\\"]\\n elif isCmd:\\n if text[i] == ' ':\\n isArg = True\\n isCmd = False\\n else:\\n cmd[0] += text[i]\\n elif isArg:\\n if text[i:i+3] in ('\\\\\\\\._', '\\\\\\\\_.'):\\n pass\\n else:\\n cmd[1] += text[i]\\n elif text[i-1] != '\\\\\\\\' and text[i-1:i+1] == '_.':\\n isCmd = True\\n\\n return commands\",\n \"def conf_load_par_list(par_def):\\n par_def = par_def[1:-1].split(',')\\n par_list = list()\\n for p in par_def:\\n par_list.append(p.strip())\\n return par_list\",\n \"def get_commands_dict() -> dict:\\n commands_dict = {}\\n f = open(f\\\"data/metadata/commands.dict.txt\\\", \\\"r\\\", encoding=\\\"utf-8\\\").read()\\n for command in f.split(\\\"\\\\n\\\"):\\n commands_dict[command.split(\\\":\\\")[0]] = command.split(\\\":\\\")[1]\\n return commands_dict\",\n \"def config_to_args(config):\\n result = []\\n\\n for key, value in iteritems(config):\\n if value is False:\\n continue\\n\\n key = '--{0}'.format(key.replace('_', '-'))\\n\\n if isinstance(value, (list, set, tuple)):\\n for item in value:\\n result.extend((key, smart_str(item)))\\n elif value is not True:\\n result.extend((key, smart_str(value)))\\n else:\\n result.append(key)\\n\\n return tuple(result)\",\n \"def parseInputFileList (self):\\n filelist = []\\n try:\\n with open (self.cfgName) as fIn:\\n for line in fIn:\\n line = (line.split(\\\"@@@\\\")[0]).strip()\\n if line:\\n self.lines.append(line)\\n except IOError:\\n print \\\"*** WARNING: label cfg file \\\" , self.cfgName , \\\" not found\\\"\\n return\",\n \"def config_mode(self, config_command=\\\"config\\\", pattern=\\\">config\\\"):\\n return super().config_mode(config_command=config_command, pattern=pattern)\",\n \"def get_config_list(self, section, option, default=None):\\n try:\\n r = [value.strip() for value in self.get(section,option).split(',')]\\n return r\\n except ConfigParser.NoOptionError:\\n return default\",\n \"def commands(self) -> List[Command]:\\n return []\",\n \"def read_task_list(fname):\\n tasks = []\\n ignores = []\\n \\n f = open(fname,'r')\\n lns = f.readlines()\\n f.close()\\n \\n for l in lns:\\n items = [ it.strip() for it in l.split(',') ]\\n if len(items)==3:\\n tasks.append({\\\"cwd\\\" :items[0], # the directory where the command should be ran from\\n \\\"command\\\" :items[1], # the command to be run\\n \\\"result\\\" :items[2], # the expected result file (will be used to determine whether we are done)\\n \\\"status\\\" :\\\"unknown\\\"})\\n else:\\n if len(l.strip())>0:\\n ignores.append(\\\"Ignoring line '%s' in task file, not sure what to do with that.\\\"%(l.strip()))\\n\\n return tasks,ignores\",\n \"async def module_command_config(self, ctx, parsed):\\n if parsed.invoker != ctx.owner:\\n return\\n ccs = ConfigCmdStatus\\n results = []\\n subcmd = parsed.subcmd\\n value = None\\n if subcmd.endswith(\\\"set\\\"): # set, reset\\n key = parsed.args[\\\"key_path\\\"]\\n name = parsed.args[\\\"config_file\\\"]\\n try:\\n config = self.configs[name]\\n except KeyError:\\n status = ccs.NO_SUCH_CONFIG\\n else:\\n try:\\n old = config.get(key, None) if key is not None else None\\n if subcmd.startswith(\\\"re\\\"):\\n if parsed.args[\\\"default\\\"]:\\n config.unset(key)\\n else:\\n config.reset(key)\\n status = ccs.RESET_OK\\n if key is not None:\\n new = config.get(key, None)\\n try:\\n await self.module_send_event(\\\"config_changed\\\", ctx, name, key, old, new)\\n except Exception:\\n self.logger.exception(\\\"Uncaught exception in config_changed handler\\\")\\n else:\\n try:\\n await self.module_send_event(\\\"config_reloaded\\\", ctx, name)\\n except Exception:\\n self.logger.exception(\\\"Uncaught exception in config_reloaded handler\\\")\\n else:\\n value = parsed.args[\\\"value\\\"]\\n if value:\\n config[key] = value\\n status = ccs.SET_OK\\n try:\\n await self.module_send_event(\\\"config_changed\\\", ctx, name, key, old, value)\\n except Exception:\\n self.logger.exception(\\\"Uncaught exception in config_changed handler\\\")\\n else:\\n value = config.get(key)\\n status = ccs.GET_OK\\n except KeyError:\\n status = ccs.NO_SUCH_KEY\\n results.append(ConfigCmdResult(config, status, key, value))\\n elif subcmd == \\\"save\\\":\\n pool = parsed.args[\\\"config_file\\\"]\\n if not pool:\\n pool = self.configs.values()\\n for config in pool:\\n try:\\n config = self.configs[config]\\n config.save()\\n except KeyError:\\n status = ccs.NO_SUCH_CONFIG\\n except ZeroBotConfigError as ex:\\n self.logger.exception(ex)\\n status = ccs.SAVE_FAIL\\n else:\\n status = ccs.SAVE_OK\\n results.append(ConfigCmdResult(config, status))\\n elif subcmd == \\\"savenew\\\":\\n new_path = parsed.args[\\\"new_path\\\"]\\n try:\\n config = self.configs[parsed.args[\\\"config_file\\\"]]\\n except KeyError:\\n status = ccs.NO_SUCH_CONFIG\\n else:\\n if new_path is not None:\\n Path(new_path).parent.mkdir(parents=True, exist_ok=True)\\n try:\\n config.save(new_path)\\n except ZeroBotConfigError as ex:\\n self.logger.exception(ex)\\n status = ccs.SAVE_FAIL\\n else:\\n status = ccs.SAVE_OK\\n results.append(ConfigCmdResult(config, status, None, None, new_path))\\n elif subcmd == \\\"reload\\\":\\n pool = parsed.args[\\\"config_file\\\"]\\n if not pool:\\n pool = self.configs.keys()\\n for name in pool:\\n try:\\n config = self.configs[name]\\n config.load()\\n except KeyError:\\n status = ccs.NO_SUCH_CONFIG\\n except ZeroBotConfigError as ex:\\n self.logger.exception(ex)\\n status = ccs.RELOAD_FAIL\\n else:\\n status = ccs.RELOAD_OK\\n try:\\n await self.module_send_event(\\\"config_reloaded\\\", ctx, name)\\n except Exception:\\n self.logger.exception(\\\"Uncaught exception in config_reloaded handler\\\")\\n results.append(ConfigCmdResult(config, status))\\n await ctx.core_command_config(parsed, results)\",\n \"def parse_command_line(self):\\n return self.command_line_parser.parse()\",\n \"def parse(filename, symbolDict):\\n lineNum = 0\\n commands = []\\n file = open(filename, \\\"r\\\")\\n for line in file.readlines():\\n # remove comments and spaces from line\\n line = \\\"\\\".join(line.split(\\\"//\\\")[0].split())\\n if not line:\\n continue\\n\\n cmdA = Ains(symbolDict)\\n cmdC = Cins(symbolDict)\\n label = Label(symbolDict)\\n\\n if cmdA.parse(line, lineNum):\\n lineNum += 1\\n commands.append(cmdA)\\n elif cmdC.parse(line, lineNum):\\n lineNum += 1\\n commands.append(cmdC)\\n elif not label.parse(line, lineNum):\\n file.close()\\n return []\\n\\n file.close()\\n return commands\",\n \"def __init__(self, command_line: List[str]) -> None:\\n self.command_line = list(command_line)\",\n \"def _parse(self, content):\\n os.environ['ASTER_VERSION_DIR'] = self.dirn\\n cfg = {}\\n self._content = content\\n for l in split_endlines(self._content):\\n if not re.search('^[ ]*#', l):\\n try:\\n typ, nam, ver, val = l.split('|')\\n #print '========>', typ, '//', nam, '//', ver, '//', val\\n typ = re.sub('^[ ]*', '', re.sub('[ ]*$', '', typ)).strip()\\n val = re.sub('^[ ]*', '', re.sub('[ ]*$', '', val)).strip()\\n if val != '':\\n val = osp.expandvars(val)\\n if cfg.has_key(typ):\\n cfg[typ].append(val)\\n else:\\n cfg[typ] = [val]\\n except ValueError:\\n pass\\n return cfg\",\n \"def config(*subconfig):\\n\\n with open('configure.yaml', 'r') as stream:\\n args = yaml.load(stream)\\n\\n # Parse command line arguments\\n parser = argparse.ArgumentParser(description='')\\n parser.add_argument(\\n '--node',\\n '-n',\\n help='The node ID.'\\n )\\n parser.add_argument(\\n '--processes',\\n '-p',\\n help='The total number of processes.'\\n )\\n # Store command line arguments in a dict\\n cl_args = parser.parse_args()\\n cl_args_dict = vars(cl_args)\\n # Combine\\n args.update(cl_args_dict)\\n # Find subconfig if argument is passed\\n for s in subconfig:\\n try:\\n args = args[s]\\n except:\\n pass\\n # Return\\n return args\",\n \"def default(self, line: str) -> None:\\n commands = shlex.split(line)\\n\\n self.main_function(\\n [list(command)\\n for is_pipe_operator, command in itertools.groupby(commands, lambda word: word == '|')\\n if not is_pipe_operator],\\n '&' not in commands\\n )\",\n \"def do_configure(self, line):\\n items = line.split(' ')\\n try:\\n node = self.fibbing[items[0]]\\n result = node.vtysh(*items[1:], configure=True)\\n result = result.strip(' \\\\n\\\\t')\\n if result:\\n log.info(result)\\n except KeyError:\\n log.error('Unknown node %s', items[0])\",\n \"def get_commands(steplist):\\n commands = []\\n for step in steplist:\\n if hasattr(step, 'command'):\\n cmdhash = {}\\n renderables = []\\n accumulateClassList(step.__class__, 'renderables', renderables)\\n\\n for renderable in renderables:\\n setattr(step, renderable, step.build.render(getattr(step,\\n renderable)))\\n\\n cmdhash['name'] = step.name\\n cmdhash['command'] = step.command\\n cmdhash['workdir'] = step.workdir\\n if hasattr(step, 'env'):\\n cmdhash['env'] = step.env\\n else:\\n cmdhash['env'] = {}\\n if hasattr(step, 'timeout'):\\n print \\\"yay!~\\\"\\n cmdhash['timeout'] = step.timeout\\n\\n cmdhash['description'] = step.description\\n cmdhash['descriptionDone'] = step.descriptionDone\\n commands.append(cmdhash)\\n return commands\",\n \"def newline_list(value):\\n return value.strip().splitlines()\",\n \"async def listcommands(self, ctx):\\n\\t\\twith open('custom_commands.json', 'r') as f:\\n\\t\\t\\tcommands = json.load(f)\\n\\t\\t\\toutput = \\\", \\\".join([*commands])\\n\\t\\t\\tawait ctx.send(f\\\"```List of custom commands:\\\\n{output}```\\\")\",\n \"def list_command(env: Optional[str], config: str) -> None:\\n layer = Layer.load_from_yaml(config, env)\\n amplitude_client.send_event(amplitude_client.LIST_SECRETS_EVENT)\\n gen_all(layer)\\n _raise_if_no_k8s_cluster_exists(layer)\\n\\n configure_kubectl(layer)\\n load_kube_config()\\n v1 = CoreV1Api()\\n api_response = v1.read_namespaced_secret(\\\"secret\\\", layer.name)\\n if api_response.data is None:\\n print(\\n \\\"No secrets found, you can make some by adding them in you opta file k8s service\\\"\\n )\\n return\\n for key in api_response.data:\\n print(key)\",\n \"def parse_arguments():\\n custom_config = config.read()\\n arguments = docopt(__doc__, version='Montanus %s' % __version__)\\n logger.debug(custom_config)\\n conf_file = arguments.get('--with-conf')\\n if conf_file is not None:\\n conf_config = config.read(conf_file)\\n\\n for (k, v) in conf_config.items():\\n if v is not None:\\n custom_config[k] = v\\n\\n logger.debug(arguments)\\n command_config = {\\n 'templates_path': arguments.get('<templates_path>'),\\n 'static_files_path': arguments.get('--with-static-files-path') \\\\\\n if arguments.get('-with-static-files-path') is not None \\\\\\n else arguments.get('<templates_path>'),\\n 'delete_source': arguments.get('--delete'),\\n 'protocol': arguments.get('--with-protocol'),\\n 'domains': arguments.get('--with-domains').split(',') \\\\\\n if arguments.get('--with-domains') is not None \\\\\\n else None,\\n 'md5_len': int(arguments.get('--with-md5-len')),\\n 'md5_concat_by': arguments.get('--with-md5-concat-by')\\n }\\n logger.debug(command_config)\\n\\n for (k, v) in command_config.items():\\n if v is not None:\\n custom_config[k] = v\\n\\n logger.debug(custom_config)\\n return DictWrapper(custom_config)\",\n \"def do_list_commands(self):\\n result = \\\"\\\\n\\\".join(self.commands.keys())\\n return result, True\",\n \"def commands():\",\n \"def _parse_cmds(self):\\n lst = self.inbuffer.split('\\\\n')\\n # leave trailing text (not terminated by \\\\n) in inbuffer\\n self.inbuffer = lst.pop(-1)\\n if lst:\\n for cmd in lst:\\n self.cmds.append(cmd)\",\n \"def parse_config(cmdline_opts):\\n cmdline_opts.add_argument(\\n '-p', '--port', help='Enter port number', default=8001)\\n cmdline_opts.add_argument(\\n '--host', help='Enter host name', default='localhost')\\n cmdline_opts.add_argument(\\n '-c', '--config', help='Enter config file', default='config.json')\",\n \"def process_switch_config(self, switch_list):\\n final_switch_list = []\\n for _switchentry in switch_list:\\n _switcharr = _switchentry.split(':')\\n if len(_switcharr) == 2:\\n _ports = _switcharr[1]\\n _ports = _ports.split(';')\\n else:\\n _ports = ['none']\\n _hostname = _switcharr[0]\\n final_switch_list.append({'name': _hostname,\\n \\\"ports\\\": _ports})\\n return final_switch_list\",\n \"def read_commands_from_console():\\n cmds = []\\n print 'Please provide commands for REA Robot. One command per line. An empty line finishes the input:'\\n while True:\\n line = raw_input()\\n if line:\\n cmds += [line.upper()]\\n else:\\n break\\n\\n return cmds\",\n \"def getCommands(self):\",\n \"def main_list(args):\\n return list_commands(args.directory)\",\n \"def format_commands(self, ctx, formatter):\\n commands = []\\n for subcommand in self.list_commands(ctx):\\n cmd = self.get_command(ctx, subcommand)\\n # What is this, the tool lied about a command. Ignore it\\n if cmd is None:\\n continue\\n if cmd.hidden:\\n continue\\n\\n commands.append((subcommand, cmd))\\n\\n # allow for 3 times the default spacing\\n if len(commands):\\n limit = formatter.width - 6 - max(len(cmd[0]) for cmd in commands)\\n\\n rows = []\\n for subcommand, cmd in commands:\\n help = cmd.get_short_help_str(limit)\\n rows.append((subcommand, help))\\n\\n if rows:\\n formatter.write_dl(rows)\",\n \"def _create_commands(self, data):\\n lines = []\\n idone, odone = False, False\\n for line in data.split(b'\\\\n'):\\n if line.startswith(b'@intext'):\\n if self.inputastext is None:\\n self.metadata['inputastext'] = True\\n self.inputastext = True\\n idone = True\\n elif line.startswith(b'@outtext'):\\n if self.outputastext is None:\\n self.metadata['outputastext'] = True\\n self.outputastext = True\\n odone = True\\n else:\\n # remove eventual comment\\n m = re.match(br'(.*?);', line)\\n if m:\\n line = m.group(1)\\n line = line.rstrip()\\n if line:\\n lines.append(line)\\n if not idone:\\n if self.inputastext:\\n self.metadata['inputastext'] = True\\n if not odone:\\n if self.outputastext:\\n self.metadata['outputastext'] = True\\n if not lines:\\n raise CarError('no source code')\\n min_indent = len(lines[0]) # temporary\\n for line in lines:\\n indent = len(line) - len(line.lstrip())\\n if indent == 0:\\n break\\n if indent < min_indent:\\n min_indent = indent\\n else:\\n lines = tuple(x[min_indent:] for x in lines)\\n\\n #self.raw_board = '\\\\n'.join(lines) # for an eventual curses simulator\\n\\n board = []\\n has_car, has_exit = False, False\\n y = 0\\n for line in lines:\\n row = array.array('B')\\n x = 0\\n for c in line:\\n try:\\n op = _opcode_to_const_map[c]\\n except KeyError:\\n op = NOP\\n if op == CAR:\\n if has_car:\\n raise CarError('program can only have one car')\\n has_car = True\\n car_pos = (x, y)\\n row.append(NOP)\\n else:\\n row.append(op)\\n if op == EXIT:\\n if has_exit:\\n raise CarError('program can only have one exit')\\n has_exit = True\\n x += 1\\n board.append(row)\\n y += 1\\n if not has_car:\\n raise CarError('program must have one car')\\n if not has_exit:\\n raise CarError('program must have one exit')\\n return self._board_to_commands(board, car_pos)\",\n \"def parse_cfg(cfgfile):\\n file = open(cfgfile, \\\"r\\\")\\n lines = file.read().split(\\\"\\\\n\\\") # store the lines in a list\\n lines = [x for x in lines if len(x) > 0] # get read of the empty lines \\n lines = [x for x in lines if x[0] != \\\"#\\\"] # get rid of comments\\n lines = [x.rstrip().lstrip() for x in lines] # get rid of fringe whitespaces\\n\\n block = {}\\n blocks = []\\n\\n for line in lines:\\n if line[0] == \\\"[\\\":\\n if len(block) != 0:\\n blocks.append(block)\\n block = {}\\n block[\\\"type\\\"] = line[1:-1].rstrip()\\n else:\\n key, value = line.split(\\\"=\\\")\\n block[key.rstrip()] = value.lstrip()\\n blocks.append(block)\\n return blocks\",\n \"def encode_commands(command_list: List[str]) -> List[str]:\\n return ['-'.join(x.split(' ')) for x in command_list]\",\n \"def config(self, filter_includes=False):\\n def the_filter(k):\\n if filter_includes and k is not None and k.lower() == \\\"include\\\":\\n return False\\n else:\\n return True\\n \\n return \\\"\\\\n\\\".join([x.line for x in self.lines_ if the_filter(x.key)])\",\n \"def _test_config_generator_list_wrap():\\n class Config(config.Config):\\n a = config.option_list(str, default=[\\\"abcdefghijklmnopqrstuvwxyz\\\" for _ in range(2)], help=\\\"\\\")\\n b = config.option_list(str, default=[\\\"abcdefghijklmnopqrstuvwxyz\\\" for _ in range(5)], help=\\\"\\\")\\n abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz = config.option_list(str, help=\\\"\\\")\\n\\n return Config, [\\n # Shorter than threshold, don't split\\n 'a = [\\\"abcdefghijklmnopqrstuvwxyz\\\", \\\"abcdefghijklmnopqrstuvwxyz\\\"]',\\n # Longer than threshold, split\\n 'b = [',\\n ' \\\"abcdefghijklmnopqrstuvwxyz\\\",',\\n ' \\\"abcdefghijklmnopqrstuvwxyz\\\",',\\n ' \\\"abcdefghijklmnopqrstuvwxyz\\\",',\\n ' \\\"abcdefghijklmnopqrstuvwxyz\\\",',\\n ' \\\"abcdefghijklmnopqrstuvwxyz\\\",',\\n ']',\\n # Key longer than threshold, but no items, don't split\\n 'abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz = []',\\n ]\",\n \"def gen_command_line(self, testcase):\\n found_double_at = False\\n new_args = []\\n\\n for arg in self.target_cmdline:\\n if arg == '@@':\\n found_double_at = True\\n new_args.append(testcase)\\n else:\\n new_args.append(arg)\\n\\n if found_double_at:\\n stdin = None\\n else:\\n with open(testcase, 'rb') as inf:\\n stdin = inf.read()\\n\\n return new_args, stdin\",\n \"def getCommands(self):\\r\\n return [z for x, y, z in self._log if x == 'command']\",\n \"def create_command_list(device):\\n command = XmlApiObject({})\\n command.name = \\\"test\\\"\\n device.commands[command.name] = command\",\n \"def _separate(self):\\n s = self.as_yamlstr()\\n self._config = yaml.load(s, Loader=yaml.Loader)\\n self._comments = self._extract_comments(self._yaml_config)\",\n \"def commands(self) -> typing.List[str]:\\n return self._values.get(\\\"commands\\\")\",\n \"def parse_config(path):\\n #Open the file\\n f = open(path)\\n section = None\\n\\n #for each line in file:\\n for line in f:\\n #Get rid of extra spaces and carridge-returns\\n line = line.rstrip('\\\\r\\\\n')\\n\\n #If there is a comment on the line, get rid of everything after the comment symbol and trim whitespace\\n #Example: hi there #This is a comment\\n if \\\"#\\\" in line:\\n line, comment = line.split(\\\"#\\\", 1)\\n line = line.strip()\\n\\n #If there is a section header on the line, figure out what it's name is, and save it\\n if \\\"[\\\" in line:\\n #Example: [StartupMods]\\n section = line.split(\\\"[\\\", 1)[1].split(\\\"]\\\", 1)[0]\\n parsed_config[section] = list()\\n\\n #If there is no section header, than the line must contian data, so save it under the current section\\n else:\\n if line is not \\\"\\\":\\n parsed_config[section].append(line)\\n\\n #Message the system\\n logging.info(\\\"Finished parsing \\\" + path)\\n return parsed_config\",\n \"def _command_as_list(module_name):\\n parts = module_name.split('.')\\n for part in COMMANDS_PACKAGE_NAME.split('.'):\\n if parts[0] == part:\\n parts = parts[1:]\\n return [SCRIPT_COMMAND] + parts\",\n \"def compile_commands(commands):\\n return [ord(char) for char in ''.join([c + '\\\\n' for c in commands])]\",\n \"def _parse_and_validate(raw_config_list):\\n items = []\\n for raw in raw_config_list:\\n\\n # Validation.\\n for key in CONFIGS_REQUIRED:\\n if key not in raw or raw[key] is None:\\n raise ConfigError(\\\"must specify '%s' in item config: %s\\\" % (key, raw))\\n\\n if \\\"version_string\\\" in raw and not _CONFIG_VERSION_RE.match(str(raw[\\\"version_string\\\"])):\\n raise ConfigError(\\\"invalid version string: '%s'\\\" % raw[\\\"version_string\\\"])\\n if \\\"version_string\\\" not in raw and \\\"version_hashable\\\" not in raw and \\\"version_command\\\" not in raw:\\n raise ConfigError(\\\"must specify 'version_string', 'version_hashable', or 'version_command' in item config: %s\\\" % raw)\\n\\n # Validate shell templates.\\n # For these, we don't expand environment variables here, but instead do it at once at call time.\\n for key in \\\"upload_command\\\", \\\"download_command\\\":\\n try:\\n strif.shell_expand_to_popen(raw[key], {\\\"REMOTE\\\": \\\"dummy\\\", \\\"LOCAL\\\": \\\"dummy\\\"})\\n except ValueError as e:\\n raise ConfigError(\\\"invalid command in config value for %s: %s\\\" % (key, e))\\n\\n # Normalize and expand environment variables.\\n for key in \\\"local_path\\\", \\\"remote_prefix\\\", \\\"remote_path\\\":\\n if key.startswith(\\\"/\\\"):\\n raise ConfigError(\\\"currently only support relative paths for local_path and remote_path: %s\\\" % key)\\n raw[key] = raw[key].rstrip(\\\"/\\\")\\n\\n try:\\n raw[key] = strif.expand_variables(raw[key], os.environ)\\n except ValueError as e:\\n raise ConfigError(\\\"invalid command in config value for %s: %s\\\" % (key, e))\\n\\n # Parse enums.\\n try:\\n raw[\\\"install_method\\\"] = InstallMethod[raw[\\\"install_method\\\"]]\\n except KeyError:\\n raise ConfigError(\\\"invalid install_method: %s\\\" % raw[\\\"install_method\\\"])\\n\\n # Parse booleans. Values True and False may already be converted.\\n try:\\n if (type(raw[\\\"make_backup\\\"]) is str):\\n raw[\\\"make_backup\\\"] = raw[\\\"make_backup\\\"].lower() in (\\\"on\\\", \\\"t\\\", \\\"true\\\", \\\"y\\\", \\\"yes\\\")\\n except KeyError:\\n raise ConfigError(\\\"invalid make_backup: %s\\\" % raw[\\\"make_backup\\\"])\\n\\n items.append(Config(**raw))\\n\\n log.debug(\\\"final configs: %s\\\", items)\\n return items\",\n \"def test_by_config(self):\\n # addon_executor = AddonExecutor(execute_order, stop_order)\\n # self.assertEqual(expected, addon_executor.execute_with_config(addon))\\n\\n self.run_mgr.by_default(self.cli_inst)\\n output = self._get_lines_as_list(sys.stdout)\\n\\n self.assertTrue(output[0].startswith('Start'))\\n self.assertTrue(output[1].startswith('Execute'))\\n self.assertTrue(output[2].startswith('Stop'))\",\n \"async def adding_command_list(self):\\n command_aliases=['anime','fun','mod','nekogif'] #This includes the aliases and the cog names\\n #NOTE: fun command added\\n for i in self.bot.commands:\\n self.commands.append(i.name)\\n \\n for i in command_aliases:\\n self.commands.append(i)\",\n \"def _parse_command(self, cmd):\\n if isinstance(cmd, list):\\n args = [str(x) for x in cmd]\\n assert args\\n else:\\n args = shlex.split(cmd)\\n return args\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64328206","0.6407235","0.6104706","0.6073341","0.5869535","0.5853029","0.57613","0.5759418","0.568729","0.56760406","0.5661332","0.56305355","0.5599522","0.5569513","0.55690366","0.5557906","0.55198437","0.54839694","0.5481613","0.5474146","0.5458116","0.5457289","0.54424477","0.54115736","0.54082257","0.53881675","0.53609216","0.53526855","0.53523374","0.53517026","0.53509057","0.5336889","0.5329573","0.53263384","0.53175277","0.530945","0.52918136","0.52917457","0.5291279","0.52811843","0.5278987","0.52697146","0.52550733","0.52409863","0.5235041","0.52308476","0.5223148","0.52047926","0.519174","0.5190258","0.5188652","0.51730627","0.5165714","0.51552844","0.5152197","0.5150291","0.51324975","0.5119966","0.5118141","0.51144165","0.51076275","0.5106262","0.51015794","0.5092654","0.5089233","0.5083604","0.5081089","0.50772315","0.50745046","0.5074355","0.50685143","0.50645715","0.505717","0.5046002","0.50421846","0.50320923","0.50303125","0.50225216","0.5018629","0.50165606","0.5008846","0.5002246","0.49899462","0.4989584","0.49860623","0.49860024","0.49859315","0.49816248","0.4980408","0.49789628","0.49753752","0.4973854","0.49730036","0.49684867","0.49653956","0.49601632","0.4959132","0.49587086","0.4956013","0.49481222"],"string":"[\n \"0.64328206\",\n \"0.6407235\",\n \"0.6104706\",\n \"0.6073341\",\n \"0.5869535\",\n \"0.5853029\",\n \"0.57613\",\n \"0.5759418\",\n \"0.568729\",\n \"0.56760406\",\n \"0.5661332\",\n \"0.56305355\",\n \"0.5599522\",\n \"0.5569513\",\n \"0.55690366\",\n \"0.5557906\",\n \"0.55198437\",\n \"0.54839694\",\n \"0.5481613\",\n \"0.5474146\",\n \"0.5458116\",\n \"0.5457289\",\n \"0.54424477\",\n \"0.54115736\",\n \"0.54082257\",\n \"0.53881675\",\n \"0.53609216\",\n \"0.53526855\",\n \"0.53523374\",\n \"0.53517026\",\n \"0.53509057\",\n \"0.5336889\",\n \"0.5329573\",\n \"0.53263384\",\n \"0.53175277\",\n \"0.530945\",\n \"0.52918136\",\n \"0.52917457\",\n \"0.5291279\",\n \"0.52811843\",\n \"0.5278987\",\n \"0.52697146\",\n \"0.52550733\",\n \"0.52409863\",\n \"0.5235041\",\n \"0.52308476\",\n \"0.5223148\",\n \"0.52047926\",\n \"0.519174\",\n \"0.5190258\",\n \"0.5188652\",\n \"0.51730627\",\n \"0.5165714\",\n \"0.51552844\",\n \"0.5152197\",\n \"0.5150291\",\n \"0.51324975\",\n \"0.5119966\",\n \"0.5118141\",\n \"0.51144165\",\n \"0.51076275\",\n \"0.5106262\",\n \"0.51015794\",\n \"0.5092654\",\n \"0.5089233\",\n \"0.5083604\",\n \"0.5081089\",\n \"0.50772315\",\n \"0.50745046\",\n \"0.5074355\",\n \"0.50685143\",\n \"0.50645715\",\n \"0.505717\",\n \"0.5046002\",\n \"0.50421846\",\n \"0.50320923\",\n \"0.50303125\",\n \"0.50225216\",\n \"0.5018629\",\n \"0.50165606\",\n \"0.5008846\",\n \"0.5002246\",\n \"0.49899462\",\n \"0.4989584\",\n \"0.49860623\",\n \"0.49860024\",\n \"0.49859315\",\n \"0.49816248\",\n \"0.4980408\",\n \"0.49789628\",\n \"0.49753752\",\n \"0.4973854\",\n \"0.49730036\",\n \"0.49684867\",\n \"0.49653956\",\n \"0.49601632\",\n \"0.4959132\",\n \"0.49587086\",\n \"0.4956013\",\n \"0.49481222\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7687394"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":17999,"cells":{"query":{"kind":"string","value":"atexit handler for deactivating and removing local venv even if tools crash"},"document":{"kind":"string","value":"def atexit_deactivate_venv(\n venv_name,\n cwd,\n logger=p_logging.DEFAULT_LOGGER\n): # pragma: no cover\n logger.info('Cleaning up venv post-test')\n\n logger.info('--removing venv')\n try:\n rm_log = local['rm']('-rf', path.join(cwd, venv_name))\n logger.debug(rm_log)\n except Exception:\n logger.error('Unable to remove venv files post-test', exc_info=True)\n\n # TODO: remove .egg/pycache/dist files?\n\n logger.info('venv cleanup complete!')"},"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 env_cleanup(self):\n pass","def tear_down(self):\n self.destroy_env()\n self.dut.kill_all()","def teardown(self):\n self.logger.info('Tearing down file server vm')\n self.local_env.execute('uninstall', task_retries=40,\n task_retry_interval=30)","def destroy_env(self):\n self.dut.send_expect(\"quit\", \"# \")\n time.sleep(2)","def state_failsafe_exit(cfg, app, win):","def __exit__(self, exc_type, exc_value, traceback):\n nvmlShutdown()","def pytest_unconfigure() -> None: # pragma: no cover\n if PROC.exitcode is None:\n assert PROC.pid is not None # not sure if this can happen (mypy error); if it does, be explicit\n os.kill(PROC.pid, signal.SIGINT)\n PROC.join(5)\n if PROC.exitcode is None:\n PROC.kill()\n PROC.join()\n print(\"\\nServer app terminated, logs in logs/server.log\")","def hook (self, *args, **kwargs):\n self.launch([\"--fastexit\"])","def cleanup():\n logger.critical(\"Program termination cleanup routine executing.\")\n # Using os._exit() to fix a bug in subprocess.popen that causes the\n # interpreter to hang after on regular sys.exit, exit, or quit call.\n os._exit(0)","def unload(args):\n subprocess.check_call([\"/bin/launchctl\", \"unload\"] + values.get(args))","def cli_teardown(argv):\n parser = argparse.ArgumentParser(\n prog=\"bazel_bf teardown\",\n description=\"Tear down the remote environment entirely.\")\n parser.add_argument(\"--force\", action='store_true')\n\n args = parser.parse_args(argv)\n\n lambda_config = config.read_config()\n\n if not args.force:\n print \"Configuration is: \" + json.dumps(\n lambda_config, indent=2, sort_keys=True)\n sys.stdout.write(\"Confirm tearing down the remote environment? [yes/No] \")\n choice = raw_input().lower()\n if choice == \"yes\":\n print \"Proceeding...\"\n else:\n raise CommandLineException(\"Abort!\")\n\n (next_lambda_config, err) = setup.teardown(lambda_config)\n config.write_config(next_lambda_config)\n\n if err:\n raise CommandLineException(\n \"Errors were encountered during tear down: \" +\n \"some resources might not have been properly deleted\")","def stop_and_restart():\n updater.stop()\n os.execl(sys.executable, sys.executable, *sys.argv)","def exit(self):\n self.runtime.halted = True","def shutdown(self):\n self.exit_app()","def stop_and_restart():\n updater.stop()\n os.execl(sys.executable, sys.executable, *sys.argv)","def cleanupAtExit():\n \n global client\n \n client.stop()","def cleanup_at_exit():\n \n global ifW\n \n if ifW:\n if logger: logger.info('Cleaning up at exit')\n if ifW._secondary_if and ifW._secondary_if.ifname:\n if logger: logger.debug('De-configuring interface ' + ifW._secondary_if.ifname)\n ifW.if_destroyed(ifW._secondary_if.ifname)","def on_exit(self):\n pass","def state_finish_exit(cfg, app, win):","def _clean_up():\n from tests.util import report\n report.update()\n if MAIN_RUNNER is not None:\n MAIN_RUNNER.on_exit()\n from tests.util.services import get_running_services\n for service in get_running_services():\n sys.stderr.write(\"Stopping service \")\n for c in service.cmd:\n sys.stderr.write(c + \" \")\n sys.stderr.write(\"...\\n\\r\")\n service.stop()","def cleanup():\n management.call_command('cleanup')","def graceful_exit(*args, **kwargs):\n if updater is not None:\n updater.bot.delete_webhook()\n\n sys.exit(1)","def stop():\n _with_deploy_env(['./bin/paster serve src/remix/oerpub/rhaptoslabs/production.ini --stop-daemon'])","def config_exit(self):\n self._master.destroy()\n self._config_status = False # ensure the world wouldn't be built","def DeleteEnv(self):\n if len(self.input.get()) > 0:\n VirtualEnvApp().EndEnv(self.input.get())\n self.restart_program()\n else:\n messagebox.showinfo('Error', 'Please Enter the Name of the ENV')","def local_uninstall(environment):\n environment.remove_cleanup(\n environment.cfy.local.execute,\n args=['uninstall'],\n )\n result = environment.cfy.local.execute('uninstall')\n assert result['returncode'] == 0, (\n 'Uninstall workflow failed!'\n )","def shiva_the_destroyer():\n with settings(warn_only=True):\n run('rm -Rf %(path)s' % env)\n run('rm -Rf %(log_path)s' % env)\n sudo('rm %(apache_config_path)s' % env)\n reboot()","def done(self, env):\n del env\n return False","def __exit__(self, exec_type, exec_value, traceback):\n #TODO: probably should shut down the visualization server component gracefully here","def exitprogram():\n sys.exit()","def cleanup(self):\n self.exit_config_mode()","def tearDown(self):\n tests.utils.cleanup_environment()","def tearDown(self):\n tests.utils.cleanup_environment()","def teardown_test_env():\n if not keep_tmp_dirs:\n print('\\nCleaning up temporary directories...')\n shutil.rmtree(tmp_elm_dpath, ignore_errors=True)\n shutil.rmtree(tmp_elm_examples_dpath, ignore_errors=True)\n\n print('Removing conda environment used for testing...')\n sp.call('conda env remove -y -q -n {}'.format(test_env_name), shell=True, executable='/bin/bash', stdout=sp.DEVNULL)","def stop_and_restart():\n U.stop()\n os.execl(sys.executable, sys.executable, *sys.argv)","def YumUninstall(vm):\n _Uninstall(vm)","def __exit__(self, exc_type, exc_value, traceback): \n self.shutdown()","def cleanup():\n if len(env.releases) > 3:\n directories = env.releases\n directories.reverse()\n del directories[:3]\n env.directories = ' '.join([ '%(releases_path)s/%(release)s' % { 'releases_path':env.releases_path, 'release':release } for release in directories ])\n run('rm -rf %(directories)s' % env)","def post_extract(env_name='root'):\n prefix = prefix_env(env_name)\n info_dir = join(prefix, 'info')\n with open(join(info_dir, 'index.json')) as fi:\n meta = json.load(fi)\n dist = '%(name)s-%(version)s-%(build)s' % meta\n if FORCE:\n run_script(prefix, dist, 'pre-unlink')\n link(prefix, dist, linktype=None)\n shutil.rmtree(info_dir)","def teardown(request, exec_env):\n\n def fin():\n if exec_env.get_script_state() == \"RUNNING\":\n resp = exec_env.run_oet_command(\"stop\", \"--run_abort=False\")\n assert \"Successfully stopped\" in resp\n\n request.addfinalizer(fin)","def salir_del_programa():\n import sys\n sys.exit(0)","def __exit(self, *args):\n sys.exit(0)","def OnExit(self, event):\n \n print 'Cleaning up...'\n self.Destroy()","def __exit__(self, type, value, trace):\n # Did we exit cleanly?\n if type is None:\n logger.verbose(\"Reconfiguring VM...\")\n self.vm.ReconfigVM_Task(spec=self.spec)","def exit():\n sys.exit(1)","def __exit__(self, exc_type, exc_value, exc_tb) -> None:\n self.destroy()","def __exit__(self, exc_type, exc_value, exc_tb) -> None:\n self.destroy()","def _():\n global _python_shutting_down\n _python_shutting_down = True","def cleanup():\n dist.destroy_process_group()","def teardown_scripts(test=None):\n for key, value in original_environ.iteritems():\n if value is None:\n del os.environ[key]\n else:\n os.environ[key] = value\n original_environ.clear()\n\n for path in tmp_paths:\n if os.path.isdir(path):\n shutil.rmtree(path)\n else:\n os.remove(path)\n del tmp_paths[:]","def tear_down_cleanup(self):\n self.hass.stop()","def exitProgram():\n canvas.destroy()\n tool.destroy()\n code_editor.destroy()\n sys.exit()","def stop_scripts():\n print \"*** WARNING ***: This is about to kill all python processes\"\n run(\"killall python\")","def quit_program():\n sys.exit()","def __atexit_handler():\n global _iom_shutdown\n _iom_shutdown = True\n clear_IOM()","def shutdown(bot):\n setup(bot)","def dist_cleanup():\n dist.destroy_process_group()","def undeploy(env_type):\n _setup_env()\n\n # Activate local virtual environment (for render_templates+flask?)\n local('. %s' % env.activate_path)\n\n if not os.path.exists(env.s3cmd_cfg):\n abort(\"Could not find 's3cmd.cfg' repository at '%(s3cmd_cfg)s'.\")\n\n if not env_type in _config['deploy']:\n abort('Could not find \"%s\" in \"deploy\" in config file' % env_type)\n\n if not \"bucket\" in _config['deploy'][env_type]:\n abort('Could not find \"bucket\" in deploy.%s\" in config file' % env_type)\n\n bucket = _config['deploy'][env_type]['bucket']\n\n warn('YOU ARE ABOUT TO DELETE EVERYTHING IN %s' % bucket)\n if not do(prompt(\"Are you ABSOLUTELY sure you want to do this? (y/n): \").strip()):\n abort('Aborting.')\n\n with lcd(env.sites_path):\n local('fablib/bin/s3cmd --config=%s del -r --force s3://%s/' \\\n % (env.s3cmd_cfg, bucket))","def backMain():\n rootStat.destroy()\n main()","def state_processing_exit(cfg, app, win):","def __exit__(self, type, value, tb):\n self._with_count -= 1\n if self._with_count > 0:\n return\n\n logging.info('Cleaning up Amber root: ' + self._amber_root)\n shutil.rmtree(self._amber_root)\n self._amber_root = None\n\n self._UnregisterAmberRepository()\n self._pm_serve_task.kill()\n self._pm_serve_task = None","def disintegrate():\n click.confirm('Do you really want to uninstall?', abort=True)\n if click.confirm('Do you want to remove installed AppImages?'):\n cfgmgr = ConfigManager()\n if os.path.exists(cfgmgr['bin']):\n print(fc(\"{y}Removing bin for appimages{rst}\"))\n shutil.rmtree(cfgmgr['bin'], ignore_errors=True)\n if os.path.exists(cfgmgr['storageDirectory']):\n print(fc(\"{y}Removing storageDirectory for appimages{rst}\"))\n shutil.rmtree(cfgmgr['storageDirectory'], ignore_errors=True)\n print(fc(\"{y}Removing zap binary entrypoint{rst}\"))\n for path in os.getenv('PATH').split(os.pathsep):\n zap_bin = os.path.join(path, 'zap')\n if os.path.exists(zap_bin):\n os.remove(zap_bin)\n break\n print(fc(\"{y}Removing zap AppImage {rst}\"))\n dot_zap = os.path.join(os.path.expanduser('~'), '.zap')\n if os.path.exists(dot_zap):\n shutil.rmtree(dot_zap, ignore_errors=True)","def clean_up(self):\n dist.destroy_process_group()","def __exit__(self, exc_type, exc_val, exc_tb):\n\n self.quit()","def __exit__(self, exc_type, exc_val, exc_tb) -> None: # type: ignore\n self.shutdown()","def agent_cleanup():\n\treturn","def rebuild():\n try:\n cmd = 'rm -rf %s' % VENV\n if VENVWRAPPER:\n cmd = 'rmvirtualenv %s' % VENV\n _do_virtualenvwrapper_command(cmd)\n except Exception as e:\n print(unicode(e))\n\n cmd = 'virtualenv --no-site-packages -p /usr/bin/python{major}.{minor} {v}'\\\n .format(\n major=sys.version_info[0],\n minor=sys.version_info[1],\n v=VENV,\n )\n if VENVWRAPPER:\n cmd = 'mkvirtualenv --no-site-packages -p /usr/bin/python{major}.{minor} {v}'\\\n .format(\n major=sys.version_info[0],\n minor=sys.version_info[1],\n v=VENV,\n )\n _do_virtualenvwrapper_command(cmd)\n\n # Do two things here:\n # - remove all *.pyc that exist in srcdir.\n # - remove all data/templates dirs that exist (mako caches).\n for base, dirs, files in os.walk(os.getcwd()):\n for fname in files:\n if fname.endswith(\".pyc\"):\n os.remove(os.path.sep.join([base, fname]))\n\n if base.endswith('data/templates'):\n shutil.rmtree(base)","def shutup():\n try:\n ttsEng.shutup()\n except Exception, e:\n logging.error(e)","def warn_purge_exit(info_msg, filename, exit_msg):\n floyd_logger.info(info_msg)\n rmtree(os.path.dirname(filename))\n sys.exit(exit_msg)","def AptUninstall(vm):\n _Uninstall(vm)","def run_os_startup_check_cleanup() -> None:\n if not CONTAINER_OS_STARTUP_CHECK.exists():\n return\n\n try:\n CONTAINER_OS_STARTUP_CHECK.unlink()\n except OSError as err:\n _LOGGER.warning(\"Not able to remove the startup health file: %s\", err)","def exit_program():\n quit()","def execute(self):\n teardown_verbosity = self._vars.PEX_TEARDOWN_VERBOSE\n try:\n with self.patch_sys():\n working_set = self._activate()\n TRACER.log('PYTHONPATH contains:')\n for element in sys.path:\n TRACER.log(' %c %s' % (' ' if os.path.exists(element) else '*', element))\n TRACER.log(' * - paths that do not exist or will be imported via zipimport')\n with self.patch_pkg_resources(working_set):\n self._wrap_coverage(self._wrap_profiling, self._execute)\n except Exception:\n # Allow the current sys.excepthook to handle this app exception before we tear things down in\n # finally, then reraise so that the exit status is reflected correctly.\n sys.excepthook(*sys.exc_info())\n raise\n except SystemExit as se:\n # Print a SystemExit error message, avoiding a traceback in python3.\n # This must happen here, as sys.stderr is about to be torn down\n if not isinstance(se.code, int) and se.code is not None:\n print(se.code, file=sys.stderr)\n raise\n finally:\n # squash all exceptions on interpreter teardown -- the primary type here are\n # atexit handlers failing to run because of things such as:\n # http://stackoverflow.com/questions/2572172/referencing-other-modules-in-atexit\n if not teardown_verbosity:\n sys.stderr.flush()\n sys.stderr = DevNull()\n sys.excepthook = lambda *a, **kw: None","def on_exit(self, event):\n # Close server\n if hasattr(self, 'webapp'):\n requests.get(ROOT_URL + '/shutdown')\n self.webapp = None\n\n # Close app\n sys.exit()","def exit(self, env=None):\n env = self._find_env(env)\n env.remove_agents(self)","def stop_and_restart():\n logging.info(\"Restarting eduzen_bot...\\n\")\n bot.updater.stop()\n os.execl(sys.executable, sys.executable, *sys.argv)","def exit_engine(self):\n self.stop_flag = True","def venv_backends(project: Project, request: SubRequest) -> None:\n project.project_config[\"venv.backend\"] = request.param\n project.project_config[\"venv.prompt\"] = \"{project_name}-{python_version}\"\n project.project_config[\"python.use_venv\"] = True\n shutil.rmtree(project.root / \"__pypackages__\", ignore_errors=True)","def __exit__(self, exc_type, exc_val, exc_tb):\n global task_tree\n task_tree = self.suspended_tree\n BulletWorld.current_bullet_world.restore_state(self.world_state, self.objects2attached)\n pybullet.removeAllUserDebugItems()","def halt(vm='',env=''):\n local( main_dir + '/vagrant/bin/vm.sh halt ' + str(vm) + ' ' + str(env) )","def unload(ctx):\n if not is_owner(ctx.update):\n return\n global cmds\n\n cmds.unload_ext(ctx.args[0])","def cleanup_step(self):\n self.clean_home_subdir()\n\n super(IntelBase, self).cleanup_step()","def teardown_package():\n # TODO If environment variable is set keep the workspace\n # and print out the path.\n global TEST_WORKSPACE\n\n # Removing the product through this server requires credentials.\n codechecker_cfg = env.import_test_cfg(TEST_WORKSPACE)['codechecker_cfg']\n codechecker.remove_test_package_product(TEST_WORKSPACE,\n codechecker_cfg['check_env'])\n\n __STOP_SERVER.set()\n\n # The custom server stated in a separate home needs to be waited, so it\n # can properly execute its finalizers.\n time.sleep(5)\n\n print(\"Removing: \" + TEST_WORKSPACE)\n shutil.rmtree(TEST_WORKSPACE, ignore_errors=True)","def __exit(self, exit_code=0):\r\n self._workspace_manager.stopAutoLoader()\r\n self._workspace_manager.stopReportManager()\r\n\r\n self._main_window.hide()\r\n print \"Closing Faraday...\"\r\n self._workspace_manager.saveWorkspaces()\r\n envs = [env for env in self._shell_envs.itervalues()]\r\n for env in envs:\r\n env.terminate() \r\n \r\n print \"stopping model controller thread...\"\r\n self._model_controller.stop()\r\n print \"stopping model controller thread...\"\r\n self.qapp.quit()\r\n print \"Waiting for controller threads to end...\"\r\n self._model_controller.join()\r\n \r\n return exit_code","def exit(self, *args):\n self.stop('all')\n sys.exit(1)","def __exit__(self):\n self._stop_all()","def exitexec(arguments=0):\n sys.exit(arguments)","def venv(session):\n # Install dependencies.\n session.install(\"--upgrade\", \"pip\", \"setuptools\")\n session.install(\"-r\", \"requirements-dev.txt\")\n session.install(\"-e\", \".\")\n\n # Customize the venv.\n env_dir = Path(session.bin)\n activate = env_dir / 'activate'\n with activate.open('a') as f:\n f.write(f'\\n[ -f {activate.resolve()}/postactivate ] && . {activate.resolve()}/postactivate\\n')\n\n {{ cookiecutter.project_name }}_complete = nox_file / 'contrib/{{ cookiecutter.project_name }}-complete.sh'\n postactivate = env_dir / 'postactivate'\n with postactivate.open('a') as f:\n f.write('export PYTHONBREAKPOINT=bpdb.set_trace\\n')\n f.write(f'source { {{ cookiecutter.project_name }}_complete.resolve() }\\n')\n\n predeactivate = env_dir / 'predeactivate'\n with predeactivate.open('a') as f:\n f.write('unset PYTHONBREAKPOINT\\n')","def prepareUninstall():\n pass","def acShutdown():\n # Update config if necessary\n if cfg.update_cfg:\n cfg.save()","def keystone_departed():\n with charm.provide_charm_instance() as charm_instance:\n charm_instance.remove_config()","def tearDown(self):\n test_env_teardown()","def destroy(self):\n if hasattr(self, 'vistrailsStartup'):\n self.vistrailsStartup.destroy()","def exit_program():\n print(\"Good bye\")\n sys.exit()","def cleanup(ctx):\n pass","async def __aexit__(self, exc_type, exc_val, exc_tb):\n pass","def remove(self):\n if self.exists():\n try:\n utils.run_in_bash(\n f'{CONDA_BIN} env remove -q -y -n {self.name}')\n except CalledProcessError as err:\n err_message = err.output.strip().decode('ascii')\n if 'CondaEnvironmentError:' in err_message:\n inform.info('deactivating and retry')\n utils.run_in_bash(\n 'source deactivate && '\n f'{CONDA_BIN} env remove -q -y -n {self.name}')\n else:\n inform.error('Couldn\\'t remove environment. '\n 'Following error occured:')\n print(err_message)\n inform.critical()","def after_all(context):\n if context.running_locally:\n try:\n _teardown_system(context)\n except subprocess.CalledProcessError as e:\n raise Exception('Failed to teardown system. Command \"{c}\" failed:\\n{o}'.\n format(c=' '.join(e.cmd), o=e.output))","def down():\n\n # Stop the program if no init has occurred.\n Vagrant.stop_if_not_init()\n\n # Run vagrant halt from the vagrant folder.\n command = [\"vagrant\", \"halt\"]\n cwd = Settings.devbox_folder\n try:\n result = subprocess.check_call(command, cwd=cwd)\n except subprocess.CalledProcessError:\n Utilities.log(\"Could not run 'vagrant halt'.\")\n exit(1)","def execute(helper, config, args):\n env_config = parse_env_config(config, args.environment)\n cname_prefix = env_config.get('cname_prefix', None)\n env_name = args.environment\n\n # change version\n if args.version_label:\n helper.deploy_version(env_name, args.version_label)\n if not args.dont_wait:\n helper.wait_for_environments(env_name, status='Ready', version_label=args.version_label)\n\n # update it\n env = parse_env_config(config, env_name)\n option_settings = parse_option_settings(env.get('option_settings', {}))\n helper.update_environment(env_name,\n description=env.get('description', None),\n option_settings=option_settings,\n tier_type=env.get('tier_type'),\n tier_name=env.get('tier_name'),\n tier_version=env.get('tier_version'))\n\n # wait\n if not args.dont_wait:\n helper.wait_for_environments(env_name, health='Green', status='Ready', version_label=args.version_label)\n\n # delete unused\n helper.delete_unused_versions(versions_to_keep=int( get(config, 'app.versions_to_keep', 10) ))"],"string":"[\n \"def env_cleanup(self):\\n pass\",\n \"def tear_down(self):\\n self.destroy_env()\\n self.dut.kill_all()\",\n \"def teardown(self):\\n self.logger.info('Tearing down file server vm')\\n self.local_env.execute('uninstall', task_retries=40,\\n task_retry_interval=30)\",\n \"def destroy_env(self):\\n self.dut.send_expect(\\\"quit\\\", \\\"# \\\")\\n time.sleep(2)\",\n \"def state_failsafe_exit(cfg, app, win):\",\n \"def __exit__(self, exc_type, exc_value, traceback):\\n nvmlShutdown()\",\n \"def pytest_unconfigure() -> None: # pragma: no cover\\n if PROC.exitcode is None:\\n assert PROC.pid is not None # not sure if this can happen (mypy error); if it does, be explicit\\n os.kill(PROC.pid, signal.SIGINT)\\n PROC.join(5)\\n if PROC.exitcode is None:\\n PROC.kill()\\n PROC.join()\\n print(\\\"\\\\nServer app terminated, logs in logs/server.log\\\")\",\n \"def hook (self, *args, **kwargs):\\n self.launch([\\\"--fastexit\\\"])\",\n \"def cleanup():\\n logger.critical(\\\"Program termination cleanup routine executing.\\\")\\n # Using os._exit() to fix a bug in subprocess.popen that causes the\\n # interpreter to hang after on regular sys.exit, exit, or quit call.\\n os._exit(0)\",\n \"def unload(args):\\n subprocess.check_call([\\\"/bin/launchctl\\\", \\\"unload\\\"] + values.get(args))\",\n \"def cli_teardown(argv):\\n parser = argparse.ArgumentParser(\\n prog=\\\"bazel_bf teardown\\\",\\n description=\\\"Tear down the remote environment entirely.\\\")\\n parser.add_argument(\\\"--force\\\", action='store_true')\\n\\n args = parser.parse_args(argv)\\n\\n lambda_config = config.read_config()\\n\\n if not args.force:\\n print \\\"Configuration is: \\\" + json.dumps(\\n lambda_config, indent=2, sort_keys=True)\\n sys.stdout.write(\\\"Confirm tearing down the remote environment? [yes/No] \\\")\\n choice = raw_input().lower()\\n if choice == \\\"yes\\\":\\n print \\\"Proceeding...\\\"\\n else:\\n raise CommandLineException(\\\"Abort!\\\")\\n\\n (next_lambda_config, err) = setup.teardown(lambda_config)\\n config.write_config(next_lambda_config)\\n\\n if err:\\n raise CommandLineException(\\n \\\"Errors were encountered during tear down: \\\" +\\n \\\"some resources might not have been properly deleted\\\")\",\n \"def stop_and_restart():\\n updater.stop()\\n os.execl(sys.executable, sys.executable, *sys.argv)\",\n \"def exit(self):\\n self.runtime.halted = True\",\n \"def shutdown(self):\\n self.exit_app()\",\n \"def stop_and_restart():\\n updater.stop()\\n os.execl(sys.executable, sys.executable, *sys.argv)\",\n \"def cleanupAtExit():\\n \\n global client\\n \\n client.stop()\",\n \"def cleanup_at_exit():\\n \\n global ifW\\n \\n if ifW:\\n if logger: logger.info('Cleaning up at exit')\\n if ifW._secondary_if and ifW._secondary_if.ifname:\\n if logger: logger.debug('De-configuring interface ' + ifW._secondary_if.ifname)\\n ifW.if_destroyed(ifW._secondary_if.ifname)\",\n \"def on_exit(self):\\n pass\",\n \"def state_finish_exit(cfg, app, win):\",\n \"def _clean_up():\\n from tests.util import report\\n report.update()\\n if MAIN_RUNNER is not None:\\n MAIN_RUNNER.on_exit()\\n from tests.util.services import get_running_services\\n for service in get_running_services():\\n sys.stderr.write(\\\"Stopping service \\\")\\n for c in service.cmd:\\n sys.stderr.write(c + \\\" \\\")\\n sys.stderr.write(\\\"...\\\\n\\\\r\\\")\\n service.stop()\",\n \"def cleanup():\\n management.call_command('cleanup')\",\n \"def graceful_exit(*args, **kwargs):\\n if updater is not None:\\n updater.bot.delete_webhook()\\n\\n sys.exit(1)\",\n \"def stop():\\n _with_deploy_env(['./bin/paster serve src/remix/oerpub/rhaptoslabs/production.ini --stop-daemon'])\",\n \"def config_exit(self):\\n self._master.destroy()\\n self._config_status = False # ensure the world wouldn't be built\",\n \"def DeleteEnv(self):\\n if len(self.input.get()) > 0:\\n VirtualEnvApp().EndEnv(self.input.get())\\n self.restart_program()\\n else:\\n messagebox.showinfo('Error', 'Please Enter the Name of the ENV')\",\n \"def local_uninstall(environment):\\n environment.remove_cleanup(\\n environment.cfy.local.execute,\\n args=['uninstall'],\\n )\\n result = environment.cfy.local.execute('uninstall')\\n assert result['returncode'] == 0, (\\n 'Uninstall workflow failed!'\\n )\",\n \"def shiva_the_destroyer():\\n with settings(warn_only=True):\\n run('rm -Rf %(path)s' % env)\\n run('rm -Rf %(log_path)s' % env)\\n sudo('rm %(apache_config_path)s' % env)\\n reboot()\",\n \"def done(self, env):\\n del env\\n return False\",\n \"def __exit__(self, exec_type, exec_value, traceback):\\n #TODO: probably should shut down the visualization server component gracefully here\",\n \"def exitprogram():\\n sys.exit()\",\n \"def cleanup(self):\\n self.exit_config_mode()\",\n \"def tearDown(self):\\n tests.utils.cleanup_environment()\",\n \"def tearDown(self):\\n tests.utils.cleanup_environment()\",\n \"def teardown_test_env():\\n if not keep_tmp_dirs:\\n print('\\\\nCleaning up temporary directories...')\\n shutil.rmtree(tmp_elm_dpath, ignore_errors=True)\\n shutil.rmtree(tmp_elm_examples_dpath, ignore_errors=True)\\n\\n print('Removing conda environment used for testing...')\\n sp.call('conda env remove -y -q -n {}'.format(test_env_name), shell=True, executable='/bin/bash', stdout=sp.DEVNULL)\",\n \"def stop_and_restart():\\n U.stop()\\n os.execl(sys.executable, sys.executable, *sys.argv)\",\n \"def YumUninstall(vm):\\n _Uninstall(vm)\",\n \"def __exit__(self, exc_type, exc_value, traceback): \\n self.shutdown()\",\n \"def cleanup():\\n if len(env.releases) > 3:\\n directories = env.releases\\n directories.reverse()\\n del directories[:3]\\n env.directories = ' '.join([ '%(releases_path)s/%(release)s' % { 'releases_path':env.releases_path, 'release':release } for release in directories ])\\n run('rm -rf %(directories)s' % env)\",\n \"def post_extract(env_name='root'):\\n prefix = prefix_env(env_name)\\n info_dir = join(prefix, 'info')\\n with open(join(info_dir, 'index.json')) as fi:\\n meta = json.load(fi)\\n dist = '%(name)s-%(version)s-%(build)s' % meta\\n if FORCE:\\n run_script(prefix, dist, 'pre-unlink')\\n link(prefix, dist, linktype=None)\\n shutil.rmtree(info_dir)\",\n \"def teardown(request, exec_env):\\n\\n def fin():\\n if exec_env.get_script_state() == \\\"RUNNING\\\":\\n resp = exec_env.run_oet_command(\\\"stop\\\", \\\"--run_abort=False\\\")\\n assert \\\"Successfully stopped\\\" in resp\\n\\n request.addfinalizer(fin)\",\n \"def salir_del_programa():\\n import sys\\n sys.exit(0)\",\n \"def __exit(self, *args):\\n sys.exit(0)\",\n \"def OnExit(self, event):\\n \\n print 'Cleaning up...'\\n self.Destroy()\",\n \"def __exit__(self, type, value, trace):\\n # Did we exit cleanly?\\n if type is None:\\n logger.verbose(\\\"Reconfiguring VM...\\\")\\n self.vm.ReconfigVM_Task(spec=self.spec)\",\n \"def exit():\\n sys.exit(1)\",\n \"def __exit__(self, exc_type, exc_value, exc_tb) -> None:\\n self.destroy()\",\n \"def __exit__(self, exc_type, exc_value, exc_tb) -> None:\\n self.destroy()\",\n \"def _():\\n global _python_shutting_down\\n _python_shutting_down = True\",\n \"def cleanup():\\n dist.destroy_process_group()\",\n \"def teardown_scripts(test=None):\\n for key, value in original_environ.iteritems():\\n if value is None:\\n del os.environ[key]\\n else:\\n os.environ[key] = value\\n original_environ.clear()\\n\\n for path in tmp_paths:\\n if os.path.isdir(path):\\n shutil.rmtree(path)\\n else:\\n os.remove(path)\\n del tmp_paths[:]\",\n \"def tear_down_cleanup(self):\\n self.hass.stop()\",\n \"def exitProgram():\\n canvas.destroy()\\n tool.destroy()\\n code_editor.destroy()\\n sys.exit()\",\n \"def stop_scripts():\\n print \\\"*** WARNING ***: This is about to kill all python processes\\\"\\n run(\\\"killall python\\\")\",\n \"def quit_program():\\n sys.exit()\",\n \"def __atexit_handler():\\n global _iom_shutdown\\n _iom_shutdown = True\\n clear_IOM()\",\n \"def shutdown(bot):\\n setup(bot)\",\n \"def dist_cleanup():\\n dist.destroy_process_group()\",\n \"def undeploy(env_type):\\n _setup_env()\\n\\n # Activate local virtual environment (for render_templates+flask?)\\n local('. %s' % env.activate_path)\\n\\n if not os.path.exists(env.s3cmd_cfg):\\n abort(\\\"Could not find 's3cmd.cfg' repository at '%(s3cmd_cfg)s'.\\\")\\n\\n if not env_type in _config['deploy']:\\n abort('Could not find \\\"%s\\\" in \\\"deploy\\\" in config file' % env_type)\\n\\n if not \\\"bucket\\\" in _config['deploy'][env_type]:\\n abort('Could not find \\\"bucket\\\" in deploy.%s\\\" in config file' % env_type)\\n\\n bucket = _config['deploy'][env_type]['bucket']\\n\\n warn('YOU ARE ABOUT TO DELETE EVERYTHING IN %s' % bucket)\\n if not do(prompt(\\\"Are you ABSOLUTELY sure you want to do this? (y/n): \\\").strip()):\\n abort('Aborting.')\\n\\n with lcd(env.sites_path):\\n local('fablib/bin/s3cmd --config=%s del -r --force s3://%s/' \\\\\\n % (env.s3cmd_cfg, bucket))\",\n \"def backMain():\\n rootStat.destroy()\\n main()\",\n \"def state_processing_exit(cfg, app, win):\",\n \"def __exit__(self, type, value, tb):\\n self._with_count -= 1\\n if self._with_count > 0:\\n return\\n\\n logging.info('Cleaning up Amber root: ' + self._amber_root)\\n shutil.rmtree(self._amber_root)\\n self._amber_root = None\\n\\n self._UnregisterAmberRepository()\\n self._pm_serve_task.kill()\\n self._pm_serve_task = None\",\n \"def disintegrate():\\n click.confirm('Do you really want to uninstall?', abort=True)\\n if click.confirm('Do you want to remove installed AppImages?'):\\n cfgmgr = ConfigManager()\\n if os.path.exists(cfgmgr['bin']):\\n print(fc(\\\"{y}Removing bin for appimages{rst}\\\"))\\n shutil.rmtree(cfgmgr['bin'], ignore_errors=True)\\n if os.path.exists(cfgmgr['storageDirectory']):\\n print(fc(\\\"{y}Removing storageDirectory for appimages{rst}\\\"))\\n shutil.rmtree(cfgmgr['storageDirectory'], ignore_errors=True)\\n print(fc(\\\"{y}Removing zap binary entrypoint{rst}\\\"))\\n for path in os.getenv('PATH').split(os.pathsep):\\n zap_bin = os.path.join(path, 'zap')\\n if os.path.exists(zap_bin):\\n os.remove(zap_bin)\\n break\\n print(fc(\\\"{y}Removing zap AppImage {rst}\\\"))\\n dot_zap = os.path.join(os.path.expanduser('~'), '.zap')\\n if os.path.exists(dot_zap):\\n shutil.rmtree(dot_zap, ignore_errors=True)\",\n \"def clean_up(self):\\n dist.destroy_process_group()\",\n \"def __exit__(self, exc_type, exc_val, exc_tb):\\n\\n self.quit()\",\n \"def __exit__(self, exc_type, exc_val, exc_tb) -> None: # type: ignore\\n self.shutdown()\",\n \"def agent_cleanup():\\n\\treturn\",\n \"def rebuild():\\n try:\\n cmd = 'rm -rf %s' % VENV\\n if VENVWRAPPER:\\n cmd = 'rmvirtualenv %s' % VENV\\n _do_virtualenvwrapper_command(cmd)\\n except Exception as e:\\n print(unicode(e))\\n\\n cmd = 'virtualenv --no-site-packages -p /usr/bin/python{major}.{minor} {v}'\\\\\\n .format(\\n major=sys.version_info[0],\\n minor=sys.version_info[1],\\n v=VENV,\\n )\\n if VENVWRAPPER:\\n cmd = 'mkvirtualenv --no-site-packages -p /usr/bin/python{major}.{minor} {v}'\\\\\\n .format(\\n major=sys.version_info[0],\\n minor=sys.version_info[1],\\n v=VENV,\\n )\\n _do_virtualenvwrapper_command(cmd)\\n\\n # Do two things here:\\n # - remove all *.pyc that exist in srcdir.\\n # - remove all data/templates dirs that exist (mako caches).\\n for base, dirs, files in os.walk(os.getcwd()):\\n for fname in files:\\n if fname.endswith(\\\".pyc\\\"):\\n os.remove(os.path.sep.join([base, fname]))\\n\\n if base.endswith('data/templates'):\\n shutil.rmtree(base)\",\n \"def shutup():\\n try:\\n ttsEng.shutup()\\n except Exception, e:\\n logging.error(e)\",\n \"def warn_purge_exit(info_msg, filename, exit_msg):\\n floyd_logger.info(info_msg)\\n rmtree(os.path.dirname(filename))\\n sys.exit(exit_msg)\",\n \"def AptUninstall(vm):\\n _Uninstall(vm)\",\n \"def run_os_startup_check_cleanup() -> None:\\n if not CONTAINER_OS_STARTUP_CHECK.exists():\\n return\\n\\n try:\\n CONTAINER_OS_STARTUP_CHECK.unlink()\\n except OSError as err:\\n _LOGGER.warning(\\\"Not able to remove the startup health file: %s\\\", err)\",\n \"def exit_program():\\n quit()\",\n \"def execute(self):\\n teardown_verbosity = self._vars.PEX_TEARDOWN_VERBOSE\\n try:\\n with self.patch_sys():\\n working_set = self._activate()\\n TRACER.log('PYTHONPATH contains:')\\n for element in sys.path:\\n TRACER.log(' %c %s' % (' ' if os.path.exists(element) else '*', element))\\n TRACER.log(' * - paths that do not exist or will be imported via zipimport')\\n with self.patch_pkg_resources(working_set):\\n self._wrap_coverage(self._wrap_profiling, self._execute)\\n except Exception:\\n # Allow the current sys.excepthook to handle this app exception before we tear things down in\\n # finally, then reraise so that the exit status is reflected correctly.\\n sys.excepthook(*sys.exc_info())\\n raise\\n except SystemExit as se:\\n # Print a SystemExit error message, avoiding a traceback in python3.\\n # This must happen here, as sys.stderr is about to be torn down\\n if not isinstance(se.code, int) and se.code is not None:\\n print(se.code, file=sys.stderr)\\n raise\\n finally:\\n # squash all exceptions on interpreter teardown -- the primary type here are\\n # atexit handlers failing to run because of things such as:\\n # http://stackoverflow.com/questions/2572172/referencing-other-modules-in-atexit\\n if not teardown_verbosity:\\n sys.stderr.flush()\\n sys.stderr = DevNull()\\n sys.excepthook = lambda *a, **kw: None\",\n \"def on_exit(self, event):\\n # Close server\\n if hasattr(self, 'webapp'):\\n requests.get(ROOT_URL + '/shutdown')\\n self.webapp = None\\n\\n # Close app\\n sys.exit()\",\n \"def exit(self, env=None):\\n env = self._find_env(env)\\n env.remove_agents(self)\",\n \"def stop_and_restart():\\n logging.info(\\\"Restarting eduzen_bot...\\\\n\\\")\\n bot.updater.stop()\\n os.execl(sys.executable, sys.executable, *sys.argv)\",\n \"def exit_engine(self):\\n self.stop_flag = True\",\n \"def venv_backends(project: Project, request: SubRequest) -> None:\\n project.project_config[\\\"venv.backend\\\"] = request.param\\n project.project_config[\\\"venv.prompt\\\"] = \\\"{project_name}-{python_version}\\\"\\n project.project_config[\\\"python.use_venv\\\"] = True\\n shutil.rmtree(project.root / \\\"__pypackages__\\\", ignore_errors=True)\",\n \"def __exit__(self, exc_type, exc_val, exc_tb):\\n global task_tree\\n task_tree = self.suspended_tree\\n BulletWorld.current_bullet_world.restore_state(self.world_state, self.objects2attached)\\n pybullet.removeAllUserDebugItems()\",\n \"def halt(vm='',env=''):\\n local( main_dir + '/vagrant/bin/vm.sh halt ' + str(vm) + ' ' + str(env) )\",\n \"def unload(ctx):\\n if not is_owner(ctx.update):\\n return\\n global cmds\\n\\n cmds.unload_ext(ctx.args[0])\",\n \"def cleanup_step(self):\\n self.clean_home_subdir()\\n\\n super(IntelBase, self).cleanup_step()\",\n \"def teardown_package():\\n # TODO If environment variable is set keep the workspace\\n # and print out the path.\\n global TEST_WORKSPACE\\n\\n # Removing the product through this server requires credentials.\\n codechecker_cfg = env.import_test_cfg(TEST_WORKSPACE)['codechecker_cfg']\\n codechecker.remove_test_package_product(TEST_WORKSPACE,\\n codechecker_cfg['check_env'])\\n\\n __STOP_SERVER.set()\\n\\n # The custom server stated in a separate home needs to be waited, so it\\n # can properly execute its finalizers.\\n time.sleep(5)\\n\\n print(\\\"Removing: \\\" + TEST_WORKSPACE)\\n shutil.rmtree(TEST_WORKSPACE, ignore_errors=True)\",\n \"def __exit(self, exit_code=0):\\r\\n self._workspace_manager.stopAutoLoader()\\r\\n self._workspace_manager.stopReportManager()\\r\\n\\r\\n self._main_window.hide()\\r\\n print \\\"Closing Faraday...\\\"\\r\\n self._workspace_manager.saveWorkspaces()\\r\\n envs = [env for env in self._shell_envs.itervalues()]\\r\\n for env in envs:\\r\\n env.terminate() \\r\\n \\r\\n print \\\"stopping model controller thread...\\\"\\r\\n self._model_controller.stop()\\r\\n print \\\"stopping model controller thread...\\\"\\r\\n self.qapp.quit()\\r\\n print \\\"Waiting for controller threads to end...\\\"\\r\\n self._model_controller.join()\\r\\n \\r\\n return exit_code\",\n \"def exit(self, *args):\\n self.stop('all')\\n sys.exit(1)\",\n \"def __exit__(self):\\n self._stop_all()\",\n \"def exitexec(arguments=0):\\n sys.exit(arguments)\",\n \"def venv(session):\\n # Install dependencies.\\n session.install(\\\"--upgrade\\\", \\\"pip\\\", \\\"setuptools\\\")\\n session.install(\\\"-r\\\", \\\"requirements-dev.txt\\\")\\n session.install(\\\"-e\\\", \\\".\\\")\\n\\n # Customize the venv.\\n env_dir = Path(session.bin)\\n activate = env_dir / 'activate'\\n with activate.open('a') as f:\\n f.write(f'\\\\n[ -f {activate.resolve()}/postactivate ] && . {activate.resolve()}/postactivate\\\\n')\\n\\n {{ cookiecutter.project_name }}_complete = nox_file / 'contrib/{{ cookiecutter.project_name }}-complete.sh'\\n postactivate = env_dir / 'postactivate'\\n with postactivate.open('a') as f:\\n f.write('export PYTHONBREAKPOINT=bpdb.set_trace\\\\n')\\n f.write(f'source { {{ cookiecutter.project_name }}_complete.resolve() }\\\\n')\\n\\n predeactivate = env_dir / 'predeactivate'\\n with predeactivate.open('a') as f:\\n f.write('unset PYTHONBREAKPOINT\\\\n')\",\n \"def prepareUninstall():\\n pass\",\n \"def acShutdown():\\n # Update config if necessary\\n if cfg.update_cfg:\\n cfg.save()\",\n \"def keystone_departed():\\n with charm.provide_charm_instance() as charm_instance:\\n charm_instance.remove_config()\",\n \"def tearDown(self):\\n test_env_teardown()\",\n \"def destroy(self):\\n if hasattr(self, 'vistrailsStartup'):\\n self.vistrailsStartup.destroy()\",\n \"def exit_program():\\n print(\\\"Good bye\\\")\\n sys.exit()\",\n \"def cleanup(ctx):\\n pass\",\n \"async def __aexit__(self, exc_type, exc_val, exc_tb):\\n pass\",\n \"def remove(self):\\n if self.exists():\\n try:\\n utils.run_in_bash(\\n f'{CONDA_BIN} env remove -q -y -n {self.name}')\\n except CalledProcessError as err:\\n err_message = err.output.strip().decode('ascii')\\n if 'CondaEnvironmentError:' in err_message:\\n inform.info('deactivating and retry')\\n utils.run_in_bash(\\n 'source deactivate && '\\n f'{CONDA_BIN} env remove -q -y -n {self.name}')\\n else:\\n inform.error('Couldn\\\\'t remove environment. '\\n 'Following error occured:')\\n print(err_message)\\n inform.critical()\",\n \"def after_all(context):\\n if context.running_locally:\\n try:\\n _teardown_system(context)\\n except subprocess.CalledProcessError as e:\\n raise Exception('Failed to teardown system. Command \\\"{c}\\\" failed:\\\\n{o}'.\\n format(c=' '.join(e.cmd), o=e.output))\",\n \"def down():\\n\\n # Stop the program if no init has occurred.\\n Vagrant.stop_if_not_init()\\n\\n # Run vagrant halt from the vagrant folder.\\n command = [\\\"vagrant\\\", \\\"halt\\\"]\\n cwd = Settings.devbox_folder\\n try:\\n result = subprocess.check_call(command, cwd=cwd)\\n except subprocess.CalledProcessError:\\n Utilities.log(\\\"Could not run 'vagrant halt'.\\\")\\n exit(1)\",\n \"def execute(helper, config, args):\\n env_config = parse_env_config(config, args.environment)\\n cname_prefix = env_config.get('cname_prefix', None)\\n env_name = args.environment\\n\\n # change version\\n if args.version_label:\\n helper.deploy_version(env_name, args.version_label)\\n if not args.dont_wait:\\n helper.wait_for_environments(env_name, status='Ready', version_label=args.version_label)\\n\\n # update it\\n env = parse_env_config(config, env_name)\\n option_settings = parse_option_settings(env.get('option_settings', {}))\\n helper.update_environment(env_name,\\n description=env.get('description', None),\\n option_settings=option_settings,\\n tier_type=env.get('tier_type'),\\n tier_name=env.get('tier_name'),\\n tier_version=env.get('tier_version'))\\n\\n # wait\\n if not args.dont_wait:\\n helper.wait_for_environments(env_name, health='Green', status='Ready', version_label=args.version_label)\\n\\n # delete unused\\n helper.delete_unused_versions(versions_to_keep=int( get(config, 'app.versions_to_keep', 10) ))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6747679","0.6670127","0.66516036","0.6634058","0.6194183","0.6155125","0.6096577","0.6070269","0.6064456","0.60605145","0.6057598","0.60506946","0.6045445","0.6012506","0.6011123","0.59959084","0.598898","0.5965664","0.59515667","0.5941659","0.59395814","0.5921367","0.5902089","0.58972305","0.589131","0.58656675","0.586519","0.5843614","0.5836605","0.5826082","0.58230597","0.58192587","0.58192587","0.57896256","0.5757862","0.57505786","0.5744034","0.57404673","0.57362366","0.5725679","0.5722263","0.57202494","0.57108","0.5705019","0.56985486","0.5696064","0.5696064","0.56866056","0.56839025","0.5675007","0.56733584","0.5670392","0.5662292","0.566175","0.5659987","0.56568116","0.5656346","0.56413597","0.56334114","0.5633286","0.56204957","0.5614146","0.5613328","0.5608465","0.5598071","0.55923665","0.5591191","0.5590969","0.55869627","0.5582856","0.55826896","0.5575944","0.5571755","0.5567126","0.5563304","0.5546337","0.55433774","0.55409265","0.55382174","0.55365515","0.5529815","0.55284905","0.55253553","0.5519399","0.55153435","0.55136764","0.5510856","0.55090004","0.5500723","0.55006343","0.54961544","0.5492293","0.5490596","0.54806525","0.5476307","0.5475565","0.54731834","0.5471619","0.54685014","0.54668224"],"string":"[\n \"0.6747679\",\n \"0.6670127\",\n \"0.66516036\",\n \"0.6634058\",\n \"0.6194183\",\n \"0.6155125\",\n \"0.6096577\",\n \"0.6070269\",\n \"0.6064456\",\n \"0.60605145\",\n \"0.6057598\",\n \"0.60506946\",\n \"0.6045445\",\n \"0.6012506\",\n \"0.6011123\",\n \"0.59959084\",\n \"0.598898\",\n \"0.5965664\",\n \"0.59515667\",\n \"0.5941659\",\n \"0.59395814\",\n \"0.5921367\",\n \"0.5902089\",\n \"0.58972305\",\n \"0.589131\",\n \"0.58656675\",\n \"0.586519\",\n \"0.5843614\",\n \"0.5836605\",\n \"0.5826082\",\n \"0.58230597\",\n \"0.58192587\",\n \"0.58192587\",\n \"0.57896256\",\n \"0.5757862\",\n \"0.57505786\",\n \"0.5744034\",\n \"0.57404673\",\n \"0.57362366\",\n \"0.5725679\",\n \"0.5722263\",\n \"0.57202494\",\n \"0.57108\",\n \"0.5705019\",\n \"0.56985486\",\n \"0.5696064\",\n \"0.5696064\",\n \"0.56866056\",\n \"0.56839025\",\n \"0.5675007\",\n \"0.56733584\",\n \"0.5670392\",\n \"0.5662292\",\n \"0.566175\",\n \"0.5659987\",\n \"0.56568116\",\n \"0.5656346\",\n \"0.56413597\",\n \"0.56334114\",\n \"0.5633286\",\n \"0.56204957\",\n \"0.5614146\",\n \"0.5613328\",\n \"0.5608465\",\n \"0.5598071\",\n \"0.55923665\",\n \"0.5591191\",\n \"0.5590969\",\n \"0.55869627\",\n \"0.5582856\",\n \"0.55826896\",\n \"0.5575944\",\n \"0.5571755\",\n \"0.5567126\",\n \"0.5563304\",\n \"0.5546337\",\n \"0.55433774\",\n \"0.55409265\",\n \"0.55382174\",\n \"0.55365515\",\n \"0.5529815\",\n \"0.55284905\",\n \"0.55253553\",\n \"0.5519399\",\n \"0.55153435\",\n \"0.55136764\",\n \"0.5510856\",\n \"0.55090004\",\n \"0.5500723\",\n \"0.55006343\",\n \"0.54961544\",\n \"0.5492293\",\n \"0.5490596\",\n \"0.54806525\",\n \"0.5476307\",\n \"0.5475565\",\n \"0.54731834\",\n \"0.5471619\",\n \"0.54685014\",\n \"0.54668224\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7242372"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":179,"numItemsPerPage":100,"numTotalItems":95772,"offset":17900,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjIzNTQ5NSwianRpIjoiZTQxMzA2ZmUtZmZkNC00NGZjLWIyYWItMjgwNjg5YmUxYzhlIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYyMzkwOTUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.e02zuG1_4_7JcE588h3jjLEkr8-tZDMgKdnXZ-MDKVTxFqmyLUBxM9vVf88JtI4CcOsFo2KZXU5LwOoNfImlDA","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 |
|---|---|---|---|---|---|---|
Apply given input values to simulation. | def _set_variables(self, b_input_vals: Dict[str, Any] = {}):
# Ensure model has been initialized at least once
self._model_has_been_initialized("_set_variables")
# Ensure dict is not empty
if not len(b_input_vals.items()) > 0:
#print("[_set_variables] Provided input... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply(self, inputs):\n raise NotImplementedError()",
"def compute(self, node, input_vals):\r\n raise NotImplementedError",
"def compute(self, node, input_vals):\n assert False, \"Implemented in subclass\"",
"def __call__(self, parameter_values, random_state=None):\n self.train... | [
"0.6627281",
"0.6060569",
"0.58538496",
"0.5823898",
"0.5751707",
"0.570151",
"0.56622785",
"0.56247663",
"0.5606498",
"0.5578345",
"0.5575155",
"0.5567629",
"0.5546263",
"0.55450714",
"0.5542741",
"0.55375254",
"0.54610884",
"0.5451027",
"0.54509836",
"0.5417239",
"0.5412084... | 0.0 | -1 |
Get var indices for each var name provided in list. | def _var_names_to_indices(self, var_names: List):
if type(var_names) is not type([]):
# Return empty array if input is not 'list' type
print("[_var_names_to_indices] Provided input is not of type list.")
return []
indices_array = []
names_array = []
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def indices_of_var(v):\n name = v.varName\n indices = name[2:].split(',')\n i, j = int(indices[0]), int(indices[1])\n return i, j",
"def index(self, variables):\n return [self._variables.index(v) for v in variables]",
"def vars(self):\n return [Var(i,self.dims[i]) for i in... | [
"0.74116653",
"0.6916294",
"0.61451054",
"0.611666",
"0.59596854",
"0.5946558",
"0.5905192",
"0.5892637",
"0.58531195",
"0.5848885",
"0.5842754",
"0.5840236",
"0.58368546",
"0.5804591",
"0.5756725",
"0.5740407",
"0.57103246",
"0.56983846",
"0.56811184",
"0.5670195",
"0.565843... | 0.72467065 | 1 |
Get unique id for instance name (identifier). | def _get_unique_id(self):
now = datetime.now()
u_id = now.second + 60*(now.minute + 60*(now.hour + 24*(now.day + 31*(now.month + 366*(now.year)))))
return "instance" + str(u_id) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def instance_id(self) -> str:\n return pulumi.get(self, \"instance_id\")",
"def instance_identifier(self):\n return self._instance_identifier",
"def instance_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"instance_id\")",
"def instance_id(self) -> pulumi.Output[str]:\n ... | [
"0.7969054",
"0.7793897",
"0.7737086",
"0.7737086",
"0.7737086",
"0.7737086",
"0.7737086",
"0.7737086",
"0.7641148",
"0.763706",
"0.7468007",
"0.7468007",
"0.7468007",
"0.7468007",
"0.7468007",
"0.7468007",
"0.7405071",
"0.7405071",
"0.7405071",
"0.7374773",
"0.7366122",
"0... | 0.7873312 | 1 |
Ensure model has been initialized at least once. | def _model_has_been_initialized(self, method_name: str = ""):
if not self._is_initialized:
error_log = "Please, initialize the model using 'initialize_model' method, prior "
error_log += "to calling '{}' method.".format(method_name)
raise Exception(error_log) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize_model(self):\n pass",
"def __post_init_check(self):\n try:\n t = self.time\n m = self.metadata\n except AttributeError as e:\n clsname = self.__class__.__name__\n raise TypeError(f\"Model not initialized. Please call 'SupernovaModel.... | [
"0.77975667",
"0.77463055",
"0.7591309",
"0.7468816",
"0.7323544",
"0.7186178",
"0.7042854",
"0.66940314",
"0.6631886",
"0.6612586",
"0.6558713",
"0.6518255",
"0.6508796",
"0.6459824",
"0.64515436",
"0.6401412",
"0.6394201",
"0.63834184",
"0.6379764",
"0.6347489",
"0.63283247... | 0.7517133 | 3 |
Ensure model has been initialized at least once. | def _terminate_model(self):
# Ensure model has been initialized at least once
self._model_has_been_initialized("_terminate_model")
if not self._is_initialized:
print("[_terminate_model] Model hasn't been initialized or has already been terminated. Skipping termination.")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize_model(self):\n pass",
"def __post_init_check(self):\n try:\n t = self.time\n m = self.metadata\n except AttributeError as e:\n clsname = self.__class__.__name__\n raise TypeError(f\"Model not initialized. Please call 'SupernovaModel.... | [
"0.77975667",
"0.77463055",
"0.7591309",
"0.7517133",
"0.7468816",
"0.7323544",
"0.7186178",
"0.7042854",
"0.66940314",
"0.6631886",
"0.6612586",
"0.6558713",
"0.6518255",
"0.6508796",
"0.6459824",
"0.64515436",
"0.6401412",
"0.6394201",
"0.63834184",
"0.6379764",
"0.6347489"... | 0.0 | -1 |
Returns distance between 2 threedimensional points | def distance_checker(xyz1, xyz2):
return math.sqrt((xyz1[0] - xyz2[0])**2 + (xyz1[1] - xyz2[1])**2 +
(xyz1[2] - xyz2[2])**2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __get_distance(point1: np.ndarray, point2: np.ndarray) -> float:\n return np.sqrt(np.sum(np.square(point1 - point2)))",
"def distance(pt1, pt2):\n\tx1, y1 = pt1\n\tx2, y2 = pt2\n\tx = x2 - x1\n\ty = y2 - y1\n\ts = x**2 + y**2\n\treturn np.sqrt(s)",
"def distance(point1, point2):\n return math.sqr... | [
"0.8303541",
"0.8230539",
"0.818016",
"0.81776935",
"0.817378",
"0.816805",
"0.8153026",
"0.8151497",
"0.812631",
"0.81180215",
"0.81151736",
"0.8079807",
"0.80791247",
"0.80715865",
"0.80449116",
"0.80381876",
"0.8034465",
"0.8034465",
"0.8027342",
"0.80119705",
"0.8006168",... | 0.0 | -1 |
Return the rotation matrix associated with counterclockwise rotation about the given axis by theta radians. Taken from | def rotation_matrix(axis, theta):
axis = np.asarray(axis)
axis = axis / math.sqrt(np.dot(axis, axis))
a = math.cos(theta / 2.0)
b, c, d = -axis * math.sin(theta / 2.0)
aa, bb, cc, dd = a * a, b * b, c * c, d * d
bc, ad, ac, ab, bd, cd = b * c, a * d, a * c, a * b, b * d, c * d
return np.arra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_rotation_matrix(axis, theta):\n axis = np.asarray(axis)\n axis = axis / math.sqrt(np.dot(axis, axis))\n a = math.cos(theta / 2.0)\n b, c, d = -axis * math.sin(theta / 2.0)\n aa, bb, cc, dd = a * a, b * b, c * c, d * d\n bc, ad, ac, ab, bd, cd = b * c, a * d, a * c, a * b, b * d, c * d\n ... | [
"0.8012121",
"0.80068713",
"0.79570246",
"0.77939034",
"0.77708095",
"0.7761298",
"0.7736163",
"0.772264",
"0.771542",
"0.7709953",
"0.7646859",
"0.7623367",
"0.7618973",
"0.7603185",
"0.74786633",
"0.7430578",
"0.7408576",
"0.73897994",
"0.737963",
"0.73772186",
"0.7360726",... | 0.7736297 | 8 |
Make sure all elements are in bond_len_dict, and return the value | def check_bond_len(dict, el_a, el_b):
if el_a in dict:
if el_b in dict[el_a]:
return dict[el_a][el_b]
print()
print(el_a + " and " + el_b + " bond length currently unsupported. Add value to the csv file.")
sys.exit() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bond_checker(atom, dict, bond_dict):\n bound = []\n for item, values in dict.items():\n bond_range = check_bond_len(bond_dict, atom[0], values[\"element\"]) + 0.2\n if distance_checker(atom[1:], values[\"coor\"]) <= bond_range:\n bound.append(item)\n return bound",
"def get_... | [
"0.6285508",
"0.6202662",
"0.59115434",
"0.5817686",
"0.5773312",
"0.5631281",
"0.5628951",
"0.5608762",
"0.559284",
"0.5581179",
"0.5579353",
"0.5575587",
"0.5575587",
"0.5575587",
"0.5542769",
"0.55310816",
"0.55075777",
"0.5494907",
"0.5452239",
"0.54492265",
"0.5444122",
... | 0.70560527 | 0 |
Transforms the bond_lengths.csv to a dict | def csv2dict(filename):
dis_dict = {}
with open(filename) as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
el_a = row["Element Name"]
dis_dict[el_a] = {}
for entry in row:
if entry != "Element Name":
dis_dict[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_csv_to_dict(filename):\n row_len = list()\n result = dict()\n with open(filename, 'r') as csvfile:\n reader = csv.reader(csvfile)\n for row in reader:\n key = row[0].strip()\n values = [v.strip() for v in row[1:]]\n result[key] = values\n ... | [
"0.5976831",
"0.59062386",
"0.58041346",
"0.5635251",
"0.53035337",
"0.526938",
"0.52367777",
"0.5232653",
"0.52167684",
"0.5213694",
"0.5197275",
"0.5179703",
"0.5157237",
"0.51463",
"0.51407754",
"0.5114579",
"0.5102922",
"0.50914264",
"0.5088494",
"0.5048615",
"0.50422263"... | 0.53779644 | 4 |
Check for all atoms in bonding range | def bond_checker(atom, dict, bond_dict):
bound = []
for item, values in dict.items():
bond_range = check_bond_len(bond_dict, atom[0], values["element"]) + 0.2
if distance_checker(atom[1:], values["coor"]) <= bond_range:
bound.append(item)
return bound | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def overlaps(self, atom, check_up_to, get_all_overlapping_atoms=True):\n if (check_up_to == 0):\n return True, []\n distances = self.structure.get_distances(atom, [i for i in range(0, check_up_to)], mic=True)\n minimum_percentage_allowed = 0.99\n valid = True\n overlap... | [
"0.6651107",
"0.6298358",
"0.6284692",
"0.61737514",
"0.6166369",
"0.61443436",
"0.6105336",
"0.61047226",
"0.6011335",
"0.5903171",
"0.5824142",
"0.5755893",
"0.5749033",
"0.57480836",
"0.57447016",
"0.57203454",
"0.5719759",
"0.57171327",
"0.5711364",
"0.5645471",
"0.563580... | 0.6625112 | 1 |
Builds simple dict out of .xyz file, containing just id, elements and coordinates | def file2dict(file, dict, start_id):
id = start_id
line_number = 0
file.seek(0)
for line in file:
if line_number == 0:
n_atoms = int(float(line.strip()))
if line_number >= 2 and line_number < n_atoms + 2:
values_list = line.split()
for i in range(1, 4)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_xyz(filename):\n\n config = {}\n\n with open(filename, 'r') as f:\n # number of atoms (spins)\n config['nat'] = int(re.findall('\\S+', f.readline())[0])\n\n # box parameters (type, dimension, shape, periodicity)\n sarr = re.findall('\\S+', f.readline())\n config['l... | [
"0.6741865",
"0.6446248",
"0.6438073",
"0.6401948",
"0.63958985",
"0.6354653",
"0.63371855",
"0.6229292",
"0.6175838",
"0.61544806",
"0.60554904",
"0.6042597",
"0.6027119",
"0.6022489",
"0.6022132",
"0.60192966",
"0.5980198",
"0.59645903",
"0.59530187",
"0.5934969",
"0.592913... | 0.6203149 | 8 |
Takes an atom dict and writes it to an .xyz file in foldername in /Created_QD with filename as name for the file | def dict2file(dict, filename, foldername):
if foldername:
if not os.path.exists("../Created_QD/" + foldername):
os.makedirs("../Created_QD/" + foldername)
file = open("../Created_QD/" + foldername + "/" + filename + ".xyz", "w")
else:
file = open("../Created_QD/" + filename +... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_to_xyz(self, filename): \n with open( filename, 'a' ) as F:\n F = open( filename, 'a' )\n F.write( '%d\\n'%self.num_atoms )\n F.write( \"XYZ\\n\" )\n for num,row in enumerate(self.atoms):\n try:\n F.write('%s '%self.species[num])\n except:\n F.write(... | [
"0.64304036",
"0.63667876",
"0.6360757",
"0.6177127",
"0.60185474",
"0.59346175",
"0.58930415",
"0.5840039",
"0.58249146",
"0.5794842",
"0.57787114",
"0.5749572",
"0.5735917",
"0.5710008",
"0.57033205",
"0.5697638",
"0.56691194",
"0.56664854",
"0.56631005",
"0.5657911",
"0.56... | 0.75428385 | 0 |
Finds atoms at the origin in a dict, returns its id | def base_atom(dict):
for atom, values in dict.items():
xyz = values["coor"]
if xyz[0] == xyz[1] == xyz[2] == 0:
return atom | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_demand_id(demand_dict, vn_id, fvr_id, svr, nbr):\n #print vn_id, fvr_id, svr, nbr\n for demand_id in demand_dict:\n if vn_id == demand_dict[demand_id]['vn_id'] and \\\n fvr_id == demand_dict[demand_id]['fnode_id'] and \\\n svr == demand_dict[demand_id]['svr'] and \\\n ... | [
"0.5926452",
"0.5634988",
"0.5295975",
"0.5282709",
"0.52257067",
"0.5161398",
"0.508171",
"0.5079885",
"0.5073828",
"0.5048743",
"0.5029526",
"0.50288653",
"0.5028559",
"0.5015856",
"0.5008036",
"0.49915805",
"0.49639514",
"0.4963865",
"0.49622545",
"0.4933749",
"0.4920927",... | 0.6143067 | 0 |
Converts strings y and n to boolean | def y2true(text):
while True:
if text == 'y':
return True
elif text == 'n':
return False
else:
text = input("Wrong input, try again: ") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_bool(s: str):\n if s.strip().lower() == \"y\":\n return True\n else:\n return False",
"def _get_bool(string):\n string = string.lower()\n return True if string == 'y' else False",
"def eval_y_n(self, question):\n answer = raw_input(question + \" [y/n] : \")\n retu... | [
"0.7319038",
"0.69107634",
"0.6700293",
"0.66846",
"0.6606526",
"0.6605776",
"0.65743244",
"0.65112495",
"0.65079075",
"0.62479234",
"0.62007165",
"0.61767143",
"0.6154451",
"0.6152505",
"0.61269474",
"0.61194664",
"0.611237",
"0.6106023",
"0.6097604",
"0.60594904",
"0.604145... | 0.6958512 | 1 |
Returns a matrix of map tiles | def createTiles():
Renderer.Clear()
map = []
w, h = len(testmap[0]), len(testmap)
x, y = 0, 0
for row in testmap:
for char in row:
map.append(makeTile(char, x, y))
x += 1
y += 1
x = 0
return map, w, h | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_tiles(self) -> list:\n n_rows = self.mosaic_dimensions[0]\n n_columns = self.mosaic_dimensions[1]\n return [\n self.get_tile(i_row, i_column)\n for i_row in range(n_rows)\n for i_column in range(n_columns)\n ]",
"def __init__tiles__(self):\n ... | [
"0.707192",
"0.7048794",
"0.6917319",
"0.6899672",
"0.67853016",
"0.6704365",
"0.6704365",
"0.6682728",
"0.66672593",
"0.6522762",
"0.6433973",
"0.63403666",
"0.6328379",
"0.63274586",
"0.6298421",
"0.62948275",
"0.62924397",
"0.62750506",
"0.6272464",
"0.62414765",
"0.623640... | 0.75113404 | 0 |
This method parses poetic movements as specified in the movements_to_scrape list, follows each movement link and yields a request using parse_movement method | def parse(self, response):
movements_to_scrape = ["Beat","Black Arts","Black Mountain","Conceptual Poetry","Concrete Poetry",
"Confessional Poetry","Contemporary","Dark Room Collective","Formalism","Futurism",
"Harlem Renaissance","Jazz Poetry","Lang... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_movement(self, response):\n movement_name = response.meta['movement_name']\n movement_url = response.meta['movement_url']\n\n sresponse = scrapy.Selector(response)\n\n #Because each movement page contains a table that has maximum of ten rows, we need to go to the next page\n ... | [
"0.75489324",
"0.71242",
"0.5760647",
"0.5611293",
"0.55545515",
"0.55472314",
"0.5544202",
"0.5456553",
"0.5455188",
"0.5418424",
"0.54031754",
"0.5396842",
"0.53465706",
"0.53382075",
"0.5328522",
"0.53110784",
"0.529639",
"0.52911603",
"0.52840555",
"0.5279618",
"0.5242923... | 0.74549824 | 1 |
This method looks at each movement page and creates a new PoetItem for each poet found in page's table | def parse_movement(self, response):
movement_name = response.meta['movement_name']
movement_url = response.meta['movement_url']
sresponse = scrapy.Selector(response)
#Because each movement page contains a table that has maximum of ten rows, we need to go to the next page
#in or... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_poet(self, response):\n item = response.meta['item']\n\n sresponse = scrapy.Selector(response)\n poetdata = sresponse.xpath('//div[@class=\"view-content\"]')\n\n #TODO: Clear empty strings from poet item fields\n\n item['poet_basicbio'] = poetdata[0].xpath('div/span//te... | [
"0.6383938",
"0.62331283",
"0.548556",
"0.5451658",
"0.52535385",
"0.5233169",
"0.51950914",
"0.5124749",
"0.5098735",
"0.50874716",
"0.5037494",
"0.5027248",
"0.49692222",
"0.4942993",
"0.49003536",
"0.48962796",
"0.48873606",
"0.48739573",
"0.4872106",
"0.48439267",
"0.4840... | 0.71895266 | 0 |
This method scrapes data (bio, url of all poems) from each poet page to continue creating the poet item | def parse_poet(self, response):
item = response.meta['item']
sresponse = scrapy.Selector(response)
poetdata = sresponse.xpath('//div[@class="view-content"]')
#TODO: Clear empty strings from poet item fields
item['poet_basicbio'] = poetdata[0].xpath('div/span//text()').extract(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_poet_poems(self, response):\n poet_poems_url = response.meta['poet_poems_url']\n\n sresponse = scrapy.Selector(response)\n\n #like the movement pages, this page contains a table that has maximum of ten rows, we need to go to the next\n # page in order to extract all of the poe... | [
"0.7948013",
"0.68461853",
"0.67603666",
"0.66625357",
"0.61643696",
"0.6150909",
"0.5885224",
"0.5870858",
"0.58600146",
"0.578315",
"0.5738709",
"0.57362324",
"0.57036006",
"0.5684646",
"0.5677119",
"0.5675798",
"0.56603056",
"0.565232",
"0.5634309",
"0.56316173",
"0.562194... | 0.82065254 | 0 |
This method parses the poems found in the page of all poems available for a specific poet The poet poems url is the foreign key to poets collection | def parse_poet_poems(self, response):
poet_poems_url = response.meta['poet_poems_url']
sresponse = scrapy.Selector(response)
#like the movement pages, this page contains a table that has maximum of ten rows, we need to go to the next
# page in order to extract all of the poems associat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_poet(self, response):\n item = response.meta['item']\n\n sresponse = scrapy.Selector(response)\n poetdata = sresponse.xpath('//div[@class=\"view-content\"]')\n\n #TODO: Clear empty strings from poet item fields\n\n item['poet_basicbio'] = poetdata[0].xpath('div/span//te... | [
"0.76509404",
"0.6316497",
"0.6232622",
"0.60066766",
"0.59613264",
"0.55365926",
"0.5433117",
"0.5388524",
"0.53653985",
"0.5345765",
"0.5338251",
"0.5269565",
"0.52671176",
"0.5202305",
"0.51900584",
"0.51822567",
"0.51615363",
"0.5134702",
"0.5116707",
"0.5097585",
"0.5093... | 0.80227727 | 0 |
This method parses each poem on poem pages and finally yields the poemitems | def parse_poet_poem(self, response):
poemitem = response.meta['poemitem']
sresponse = scrapy.Selector(response)
poemitem['poem_text'] = sresponse.xpath('//div[@property = "content:encoded"]//text()').extract()
poemitem['poem_copyright'] = sresponse.xpath('//div[@class = "poem-credit"]//p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_poet_poems(self, response):\n poet_poems_url = response.meta['poet_poems_url']\n\n sresponse = scrapy.Selector(response)\n\n #like the movement pages, this page contains a table that has maximum of ten rows, we need to go to the next\n # page in order to extract all of the poe... | [
"0.7213079",
"0.71406233",
"0.6475927",
"0.59090114",
"0.5766759",
"0.5761037",
"0.5740958",
"0.57350755",
"0.57176733",
"0.56667167",
"0.5645379",
"0.56218153",
"0.56191784",
"0.5588704",
"0.5571916",
"0.5538668",
"0.5532088",
"0.55089444",
"0.55086166",
"0.54917306",
"0.548... | 0.7146734 | 1 |
Coroutine wrapper around `time.sleep`. | async def time_sleep_coro(secs: float):
await asyncio.sleep(secs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def sleep(cls, delay: float) -> None:",
"def sleep(seconds):\n\n return Sleep(seconds)",
"def sleep(seconds):\n time.sleep(seconds)",
"def sleep(seconds):\n time.sleep(seconds)",
"def sleep(sleep_time=0.250):\n time.sleep(sleep_time)",
"def sleep(self, amount: float):\n time.sleep(am... | [
"0.8156352",
"0.7878079",
"0.7722192",
"0.7722192",
"0.76466715",
"0.7640406",
"0.76396054",
"0.7581276",
"0.7509755",
"0.75091183",
"0.7489297",
"0.73604864",
"0.73423356",
"0.7341434",
"0.73147935",
"0.72658235",
"0.7215652",
"0.721547",
"0.7106817",
"0.70747185",
"0.705582... | 0.74316525 | 11 |
Wrapper around `time.sleep` to match the signature of the main case below. | def sleep(secs: float) -> Coroutine[None, None, None]:
return time_sleep_coro(secs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sleep(seconds):\n\n return Sleep(seconds)",
"def sleep(secs=1.0):\n time.sleep(secs)",
"def sleep(seconds):\n time.sleep(seconds)",
"def sleep(seconds):\n time.sleep(seconds)",
"def sleep(interval):\n time.sleep(interval) # pragma: no cover",
"def sleep(sleep_time=0.250):\n time.sle... | [
"0.8015693",
"0.79522854",
"0.78925645",
"0.78925645",
"0.7880162",
"0.787606",
"0.7862382",
"0.7760143",
"0.77381194",
"0.7715846",
"0.75665635",
"0.7347547",
"0.7336346",
"0.7207538",
"0.71536756",
"0.7153226",
"0.7124681",
"0.7122617",
"0.7072964",
"0.70454055",
"0.7032891... | 0.6706254 | 39 |
Creates a coroutine that does nothing for when no sleep is needed. | async def no_sleep_coro():
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def awaitable(obj):\n yield from asyncio.sleep(0)\n return obj",
"def run_no_args(self):\n while True:\n if self.cancelled:\n return\n self.func()\n time.sleep(self.sleep_time / 1000.00)",
"def without_wait(self):\n return self.temp_implicit_w... | [
"0.62436175",
"0.6190582",
"0.61719257",
"0.6137821",
"0.5900524",
"0.58804405",
"0.5874823",
"0.58503664",
"0.58102584",
"0.57648695",
"0.57648695",
"0.5745751",
"0.5739838",
"0.57116777",
"0.5652093",
"0.5645594",
"0.5622938",
"0.56145954",
"0.5602458",
"0.55889374",
"0.558... | 0.8199025 | 0 |
A replacement sleep for Windows. Note that unlike `time.sleep` this may sleep for slightly less than the specified time. This is generally not an issue for Textual's use case. In order to create a timer that _can_ be cancelled on Windows, we need to create a timer and a separate event, and then we wait for either of th... | def sleep(secs: float) -> Coroutine[None, None, None]:
# Subtract a millisecond to account for overhead
sleep_for = max(0, secs - 0.001)
if sleep_for < 0.0005:
# Less than 0.5ms and its not worth doing the sleep
return no_sleep_coro()
timer = kernel32.CreateWait... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _sleep(self, sleep_time: float = 10) -> None:\n sleep_until_interrupt(sleep_time, lambda: self.stopped, interval=0.5)",
"def sleep(sleep_time=0.250):\n time.sleep(sleep_time)",
"def sleep(secs=1.0):\n time.sleep(secs)",
"def set_sleep_timer(self, option, time):\n params = [\n ... | [
"0.6478523",
"0.6467439",
"0.62972337",
"0.62152714",
"0.61905533",
"0.61398786",
"0.6105847",
"0.61010325",
"0.6100269",
"0.609553",
"0.6091412",
"0.6091412",
"0.6072209",
"0.60244656",
"0.6000396",
"0.59438556",
"0.59020305",
"0.5901713",
"0.5888825",
"0.58390737",
"0.58360... | 0.6513097 | 0 |
Sets the cancel event so we know we can stop waiting for the timer. | def cancel_inner():
kernel32.SetEvent(cancel_event) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _cancel(self):\n self.waiter.set_result_if_pending(None)\n \n timer = self.timer\n if (timer is not None):\n self.timer = None\n timer.cancel()",
"def cancel(self):\n self.waiter.set_result_if_pending(True)\n \n timer = self.timer\n ... | [
"0.7676816",
"0.7467314",
"0.7397475",
"0.733986",
"0.7244259",
"0.71759206",
"0.71301645",
"0.71301645",
"0.7041629",
"0.70007837",
"0.6995933",
"0.6995933",
"0.69819576",
"0.6949455",
"0.69289273",
"0.68336475",
"0.68163085",
"0.67847276",
"0.6758899",
"0.67556834",
"0.6755... | 0.7688794 | 0 |
Cancels the timer by setting the cancel event. | async def cancel():
await asyncio.get_running_loop().run_in_executor(None, cancel_inner) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cancel(self):\n if self._timer:\n self._timer.cancel()\n self._timer = None\n else:\n raise Exception('Cannot cancel timer. No timer started.')",
"def cancel_time(self, cancel_time):\n\n self._cancel_time = cancel_time",
"def cancel(self):\n self... | [
"0.7522803",
"0.749893",
"0.7431519",
"0.73576546",
"0.73336273",
"0.71443474",
"0.71443474",
"0.7121317",
"0.7092865",
"0.7011581",
"0.69738644",
"0.69738644",
"0.69659966",
"0.69072753",
"0.6883524",
"0.6879814",
"0.68764305",
"0.6869267",
"0.6869267",
"0.6869267",
"0.68427... | 0.0 | -1 |
Function responsible for waiting for the timer or the cancel event. | def wait_inner():
if (
kernel32.WaitForMultipleObjects(
2,
ctypes.pointer((HANDLE * 2)(cancel_event, timer)),
False,
INFINITE,
)
== WAIT_FAILED
):
time_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wait(self, timeoout=None, state=\"C-completed\"):",
"async def wait_for_cancel(self):\n await self._cancel",
"def _wait_for_completion(self):\n if self.do_timing:\n self.timer.start(\"Running.\")\n\n while self.state != State.COMPLETED:\n self._update_state()\n\n ... | [
"0.7174734",
"0.71252257",
"0.68507195",
"0.68419737",
"0.67769885",
"0.67605805",
"0.67037636",
"0.66891533",
"0.66845816",
"0.66050535",
"0.65404123",
"0.65313905",
"0.64974064",
"0.6473606",
"0.64717025",
"0.64504385",
"0.6397383",
"0.63804114",
"0.63804114",
"0.63766485",
... | 0.76650566 | 0 |
Wraps the actual sleeping so we can detect if the thread was cancelled. | async def wait():
try:
await asyncio.get_running_loop().run_in_executor(None, wait_inner)
except asyncio.CancelledError:
await cancel()
raise
finally:
kernel32.CloseHandle(timer)
kernel32.CloseHandle(canc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sleep(self):\n for i in range(10):\n if cancelled: return False\n time.sleep(1)\n return True",
"def _sleep(self, sleep_time: float = 10) -> None:\n sleep_until_interrupt(sleep_time, lambda: self.stopped, interval=0.5)",
"def interruptableSleep(self, seconds):\n remainingSecon... | [
"0.6566912",
"0.6495458",
"0.63694894",
"0.62619054",
"0.6237809",
"0.62232906",
"0.62187064",
"0.61902666",
"0.6129422",
"0.60156125",
"0.5976705",
"0.5935192",
"0.5897987",
"0.58867836",
"0.5874236",
"0.58713585",
"0.580062",
"0.580062",
"0.5785263",
"0.5755012",
"0.5750527... | 0.0 | -1 |
You are given weights and values of items, put these items in a knapsack of capacity weight_limit to get the maximum total value in the knapsack. | def fill_knapsack(raw_items, weight_limit):
table = [ [0]*(weight_limit+1) for _ in range(len(raw_items)) ]
# initialise first row
value_item = raw_items[0][0]
weight_item = raw_items[0][1]
for j in range(min([weight_item, weight_limit+1])):
table[0][j] = 0
for j in range(weight_item, w... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def knapsack(items, capacity):\r\n pass",
"def knapsack(items, capacity):\n if len(items) == 0 or capacity <= 0:\n return 0\n \n name, weight, value = items[0]\n val_without = knapsack(items[1:], capacity)\n\n if weight > capacity:\n return val_without\n val_with = value + knap... | [
"0.8320686",
"0.8263009",
"0.80508375",
"0.80328536",
"0.7927791",
"0.79154485",
"0.7832968",
"0.78256446",
"0.7670298",
"0.75953615",
"0.7571719",
"0.7546358",
"0.7382605",
"0.73721385",
"0.7364689",
"0.73359287",
"0.72694445",
"0.7251536",
"0.72451264",
"0.7225005",
"0.7219... | 0.7732081 | 8 |
Create sysapps test class. | def test():
zkclient = context.GLOBAL.zk.conn
cell_name = context.GLOBAL.cell
admin_cell = admin.Cell(context.GLOBAL.ldap.conn)
# get cell attribute from ldap object
cell = admin_cell.get(cell_name)
sysproid = cell['username']
running = zkclient.get_children(z.RUNNING)
# prefilter tre... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_app_is_created(app):\n assert app.name == \"myapp.app\"",
"def test_create_app():\n assert not create_app().testing\n assert create_app({'TESTING': True}).testing",
"def check_sysapps():\n return sysapps.test",
"def test_app_construction(s):\n empty_app = s['empty-app']\n simpl... | [
"0.67739576",
"0.67633355",
"0.6659141",
"0.6566691",
"0.64639604",
"0.644535",
"0.6410979",
"0.64051825",
"0.6400125",
"0.6329741",
"0.62414545",
"0.6233027",
"0.6218463",
"0.62092364",
"0.6205732",
"0.6158133",
"0.6139749",
"0.6121102",
"0.608798",
"0.60838187",
"0.60797936... | 0.6751296 | 2 |
Check {sysproid}.{appname}.{cell} is running. | def _test_app_running(self, running_set, sysproid, cell, appname):
full_app_name = '%s.%s.%s' % (sysproid, appname, cell)
self.assertIn(full_app_name, running_set) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_running(program):\n \n #cmd = [\"xdotool\", \"search\", \"--name\", program]\n cmd = [\"xdotool\", \"search\", \"--name\", \"--class\", \"--classname\", program]\n try:\n subprocess.check_output(cmd)\n return True\n except:\n return False",
"def is_sm_running() -> bool:... | [
"0.66739565",
"0.6461373",
"0.6416072",
"0.63748014",
"0.6368051",
"0.6345569",
"0.6295888",
"0.62739915",
"0.62605065",
"0.6186457",
"0.61560464",
"0.609521",
"0.60186034",
"0.6016657",
"0.6009209",
"0.6008331",
"0.6001014",
"0.59857357",
"0.5974706",
"0.595932",
"0.5954081"... | 0.6727489 | 0 |
This method is called during a move's `action_done`. It'll actually move a quant from the source location to the destination location, and unreserve if needed in the source location. This method is intended to be called on all the move lines of a move. This method is not intended to be called when editing a `done` move... | def _action_done(self):
# First, we loop over all the move lines to do a preliminary check: `qty_done` should not
# be negative and, according to the presence of a picking type or a linked inventory
# adjustment, enforce some rules on the `lot_id` field. If `qty_done` is null, we unlink
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loot_enq_move(self, item, toloc):\n itemloc = item.Location.ToLocation()\n self.pqi.enq(2, ['move', [[itemloc.X, itemloc.Y, itemloc.Z],\n item.Id, itemloc.Z,\n [toloc.X, toloc.Y, toloc.Z],\n item.Count\n ... | [
"0.6281393",
"0.6151487",
"0.6090694",
"0.60468554",
"0.6036133",
"0.5997963",
"0.5967796",
"0.59452647",
"0.59211004",
"0.58850086",
"0.5854653",
"0.5854297",
"0.58422697",
"0.5832115",
"0.5814126",
"0.5808458",
"0.5793776",
"0.5744125",
"0.57013524",
"0.569954",
"0.5652009"... | 0.6330825 | 0 |
The response iterable as writeonly stream. | def stream(self):
return ResponseStream(self) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def response_as_stream(self) -> Any:\n raise NotImplementedError # pragma: no cover",
"def stream(self, write, request):\n raise NotImplementedError(\"%s.stream\" % reflect.qual(self.__class__))",
"def getOutputStream(self):\r\n self._setHeaders()\r\n return self._response.getOutpu... | [
"0.7330909",
"0.6544413",
"0.64807034",
"0.6401678",
"0.6401678",
"0.6224532",
"0.59967285",
"0.59855986",
"0.5966709",
"0.594459",
"0.58853096",
"0.5849615",
"0.58353543",
"0.57926196",
"0.5761642",
"0.5744629",
"0.5694836",
"0.5675186",
"0.56467724",
"0.5643159",
"0.5639434... | 0.6642246 | 1 |
Modify the specified group defaults. | def config(gvar):
mandatory = []
required = []
optional = ['-cc', '-ckv', '-CSEP', '-CSV', '-g', '-H', '-h', '-NV', '-ok', '-r', '-s', '-V', '-VC', '-v', '-x509', '-xA']
if gvar['retrieve_options']:
return mandatory + required + optional
# Check for missing arguments or help required.
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_defaults(self, **kw):\n group = kw.pop('group', None)\n for o, v in kw.items():\n self.cfg_fixture.set_default(o, v, group=group)",
"def _getGroupDefaults(self):\n defaults = self.getDefaultGroupContainer(\n _name = \"defaults\",\n diff_command = self... | [
"0.7184848",
"0.6596516",
"0.6438077",
"0.6252312",
"0.6243312",
"0.6232612",
"0.62150013",
"0.59281456",
"0.59254956",
"0.59022254",
"0.589668",
"0.587396",
"0.58705354",
"0.58090675",
"0.58086026",
"0.5792662",
"0.5790622",
"0.5790524",
"0.5772414",
"0.5770209",
"0.57333934... | 0.0 | -1 |
pyc files are compiled python files | def ignore_pyc(root,names):
return [name for name in names if name.endswith('pyc')] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pyo():\n local('python -O -m compileall .')",
"def pyo():\n local('python -O -m compileall .')",
"def dump_to_pyc(co, python_version, output_dir):\n # assume Windows path information from the .exe\n pyc_basename = ntpath.basename(co.co_filename)\n pyc_name = f'{pyc_basename}.pyc'\n\n if p... | [
"0.76460916",
"0.76460916",
"0.6611577",
"0.65328807",
"0.65157396",
"0.64948845",
"0.6453072",
"0.6333553",
"0.63172144",
"0.6250905",
"0.62331843",
"0.61961657",
"0.61082584",
"0.6089736",
"0.6059642",
"0.5937924",
"0.5929911",
"0.5920827",
"0.5914817",
"0.5861231",
"0.5777... | 0.5252192 | 84 |
Sets the defaults for the application | def _set_defaults(self):
self.api_protocol = 'https'
self.api_host = 'nhl-score-api.herokuapp.com'
self.current_score = 0
self.sleep_seconds = 30 # Time to sleep after calling the API
self.desired_game_state = 'LIVE' # Desired game state is LIVE | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setdefaults(self):\n self.config = {\n 'dbuser': Infopage.DEFAULT_DBUSER,\n 'dbname': Infopage.DEFAULT_DBNAME,\n 'dbpassword': Infopage.DEFAULT_DBPASSWORD,\n 'dbhost': Infopage.DEFAULT_DBHOST\n }",
"def set_app_defaults(self):\n self.curve_rend... | [
"0.7357145",
"0.7231974",
"0.72296315",
"0.72133297",
"0.72133297",
"0.72133297",
"0.71464986",
"0.70750517",
"0.69881386",
"0.68930227",
"0.68891907",
"0.6831446",
"0.6802917",
"0.67972445",
"0.6766449",
"0.673461",
"0.67219883",
"0.6717343",
"0.66930187",
"0.6652306",
"0.66... | 0.63886625 | 37 |
Returns any live games currently happening with the API | def _get_live_games(self):
response = requests.get(self._get_score_url())
if response.status_code == 200:
return [g for g in response.json()['games'] if g['status']['state'] == self.desired_game_state] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def fetch_games(self):\n return await self.http.get_game_list()",
"def get_games_from_database (self):\n r = requests.get (self.url_endpoint)\n if (r.status_code != 200):\n print (\"Failed to get games:\\n\", r.text)\n return r\n \n games = json.load... | [
"0.7730199",
"0.7471135",
"0.7325539",
"0.7287605",
"0.7253883",
"0.71185577",
"0.71165675",
"0.69969124",
"0.68289065",
"0.6684004",
"0.6620107",
"0.65803075",
"0.6573545",
"0.6527177",
"0.6521868",
"0.6480549",
"0.6474347",
"0.6449517",
"0.6438656",
"0.64343774",
"0.6428631... | 0.84799916 | 0 |
Gets the current team's score from the API | def _get_current_teams_score(self):
for game in self._get_live_games():
teams_playing = [x['abbreviation'] for index, x in game['teams'].items()]
if self.team in teams_playing:
# Our team is playing in this game, get the score
return int(ga... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def score(self):\n return self.client.call('GET', self.name + 'score')",
"def getScore(data):\n return score",
"def get_score(self):\n return self.score",
"def get_scores(self):\n return self.score",
"def get_score(self):\n return self.score",
"def get_score(self):\n ret... | [
"0.7527059",
"0.72310585",
"0.6813954",
"0.681293",
"0.675793",
"0.675793",
"0.675793",
"0.66784096",
"0.66253316",
"0.6584562",
"0.6568987",
"0.6539687",
"0.6478145",
"0.6478145",
"0.6478145",
"0.64599675",
"0.6432476",
"0.63932824",
"0.63802594",
"0.6361858",
"0.6353685",
... | 0.7543717 | 0 |
A callback for when the score has changed | def _score_has_changed(self):
print('The score for {} has changed'.format(self.team))
self.relay_controller.activate_solenoid() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_score():\n pass",
"def set_score(self, change):\n self._score = self._score + change",
"def change_score(self, change: float=1):\n self._score += change",
"def updateScore(self, score):\n self.__score += score",
"def change_score(self, change: float = 1):\n sel... | [
"0.8341499",
"0.74432063",
"0.73771644",
"0.7372784",
"0.734759",
"0.73033684",
"0.72073954",
"0.71673465",
"0.7100169",
"0.70697486",
"0.7063373",
"0.69999087",
"0.6984844",
"0.6956813",
"0.6926817",
"0.6926514",
"0.69130313",
"0.69130313",
"0.69130313",
"0.6872642",
"0.6860... | 0.7795641 | 1 |
Run the app and watch for changes | def run(self):
try:
while True:
print('Getting score from API...')
latest_score = self._get_current_teams_score()
if latest_score is None:
print('No score available, waiting')
else:
print('Current... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\n # for running indefinitely if 'watch' is passed\n if self._arguments.watch:\n while True:\n self.watch(self.main(), int(self._arguments.watch))\n else:\n self.main()",
"def run(self):\n self.app.run()",
"def run(self):\n s... | [
"0.7283297",
"0.7230205",
"0.7230205",
"0.695691",
"0.69266194",
"0.6910289",
"0.67840403",
"0.67665446",
"0.6617058",
"0.66033804",
"0.65981317",
"0.6581717",
"0.65502757",
"0.65164596",
"0.65155524",
"0.65133655",
"0.6426817",
"0.63905853",
"0.63619006",
"0.6324085",
"0.628... | 0.0 | -1 |
Convert amber force to phenix's order | def reorder_force_amber_to_phenix(frc, new_indices):
frc = np.asarray(frc)
n_atoms = int(frc.shape[0]/3)
new_frc = frc.reshape(n_atoms, 3)[new_indices]
return new_frc.flatten() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_normalization_order(self):\n self._cache[\"input\"][\"order\"] = int(self.order.currentText())\n self.reset_input_style_defaults()\n self.fit_continuum(True)\n self.draw_continuum(True)\n return None",
"def order_ideal(self, gens):",
"def reorder(self, new_order):\... | [
"0.60155886",
"0.5705022",
"0.56526685",
"0.5433478",
"0.5433478",
"0.5353595",
"0.53525275",
"0.53117526",
"0.5296383",
"0.5288029",
"0.5170808",
"0.512681",
"0.51214826",
"0.5099078",
"0.5092627",
"0.5066978",
"0.5058092",
"0.5050407",
"0.50501",
"0.5036617",
"0.5033469",
... | 0.52579266 | 10 |
Convert phenix site_cart to amber format Paramters | def reorder_coords_phenix_to_amber(coords, new_indices):
coords_2d = np.asarray(coords)
return coords_2d[new_indices] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pol_to_cart():\n pass",
"def cart_to_pol():\n pass",
"def update_cart_args(request):\n cart = Cart(request)\n context = {}\n context['cart_total_item'] = cart.get_total_item()\n context['cart_total_price'] = cart.get_total_price()\n return context",
"def update_cart_args(request):\n ... | [
"0.62890846",
"0.5937737",
"0.5834528",
"0.5834528",
"0.5453803",
"0.51159734",
"0.50862145",
"0.5032178",
"0.49987817",
"0.4918404",
"0.48844433",
"0.48670283",
"0.48539582",
"0.47867537",
"0.47828287",
"0.4775699",
"0.47695547",
"0.47377214",
"0.47122937",
"0.47092468",
"0.... | 0.0 | -1 |
return a dict(a2p=arr0, p2a=arr1). Key "a2p" means converting amber order to phenix order Key "p2a" means converting phenix order to amber order | def get_indices_convert_dict(fn):
pdb_inp = pdb.input(file_name=fn)
pdb_hierarchy = pdb_inp.construct_hierarchy()
newids = OrderedDict((atom.id_str(), idx) for (idx, atom) in enumerate(pdb_hierarchy.atoms()))
oldids= OrderedDict((atom.id_str(), idx) for (idx, atom) in enumerate(pdb_inp.atoms()))
return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def paramz_to_dict(p):\n return dict([(k.name, np.array(k)) for k in p])",
"def convert_arrpart_to_dict(particles):\n partdict = {}\n partdict['m'] = particles[:,0]\n partdict['Z'] = particles[:,2]\n partdict['rho'] = particles[:,5]\n partdict['R'] = particles[:,7]\n partdict['vphi'] = p... | [
"0.6365707",
"0.59968275",
"0.5911731",
"0.5696765",
"0.5571321",
"0.55429137",
"0.54785323",
"0.54684395",
"0.54655355",
"0.5458638",
"0.54449743",
"0.5401446",
"0.53939253",
"0.5382905",
"0.5363385",
"0.5341607",
"0.53321666",
"0.53309155",
"0.53248113",
"0.53123164",
"0.53... | 0.6150025 | 1 |
Perform a style check on an ontology By default repairs will be performed if necessary | def lint_ontology(
oi: BasicOntologyInterface, dry_run=False, entities: Iterable[CURIE] = None
) -> Iterable[ISSUE]:
for actionable, change in _lint_ontology_dry_run(oi, entities):
if actionable and not dry_run:
if isinstance(oi, PatcherInterface):
oi.apply_patch(change)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def style(command, checkonly=False):\n black(command, checkonly=checkonly)\n isort(command, checkonly=checkonly)\n lint(command)\n # Only prints if doesn't exit from the above not failing out\n print(\n \"\"\"\nAll Style Checks Passed Successfully\n====================================\n\"\"\"... | [
"0.62346035",
"0.5760028",
"0.56449413",
"0.54283404",
"0.5408951",
"0.5408253",
"0.53761643",
"0.5217938",
"0.5173615",
"0.5134347",
"0.51237994",
"0.51134735",
"0.50752974",
"0.50604635",
"0.50281394",
"0.5015283",
"0.4996412",
"0.49574563",
"0.49012482",
"0.48945314",
"0.4... | 0.5457959 | 3 |
Decorate a test method to run it as a set of subtests. Modeled after pytest.parametrize. | def parameterize(names, value_groups):
def decorator(func):
@functools.wraps(func)
def wrapped(self):
for values in value_groups:
resolved = map(Invoked.eval, always_iterable(values))
params = dict(zip(always_iterable(names), resolved))
wi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test(self, func):\r\n @wraps(func)\r\n def wrapper():\r\n with nested(self._contexts) as context:\r\n context = [c for c in context if c is not None]\r\n argc = len(inspect.getargspec(func)[0])\r\n args = []\r\n for arg in con... | [
"0.6848636",
"0.6483684",
"0.63185793",
"0.6195601",
"0.615952",
"0.61097777",
"0.61015517",
"0.6099582",
"0.6064761",
"0.6016524",
"0.5978094",
"0.59725267",
"0.59543383",
"0.59543383",
"0.5920831",
"0.59197617",
"0.5894361",
"0.5870087",
"0.5840146",
"0.57989144",
"0.576454... | 0.5828212 | 19 |
capture image from camera | def rpi_capture_image(project, number):
import picamera
#now = datetime.datetime.now()
#now_str = now.strftime('%Y%m%d:%H:%M:%S')
#print now_str
name = project.name
#print name
if not os.path.exists(IMAGE_PATH):
call(["mkdir", IMAGE_PATH])
image_number = str(number).zfill(7)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def capture_image():\n global img_tk\n r, img_cam = cam.read()\n img_pil = Image.fromarray(cv2.cvtColor(img_cam, cv2.COLOR_BGR2RGB))\n img_tk = ImageTk.PhotoImage(img_pil)\n tk_cam.create_image(0, 0, image=img_tk, anchor='nw')\n return img_pil",
"def capture_image():\n\n endpoint = CAMERA_CA... | [
"0.7795241",
"0.7729087",
"0.757988",
"0.75707597",
"0.7435194",
"0.73699677",
"0.73294467",
"0.72867817",
"0.7243392",
"0.72147304",
"0.717186",
"0.7163452",
"0.713739",
"0.70919883",
"0.69702286",
"0.6968026",
"0.6967313",
"0.69081175",
"0.69081175",
"0.68981284",
"0.686327... | 0.690993 | 17 |
Sets the complex amplitude. | def getIntensityS(self):
return self._Esigma.intensity() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _amp_ ( self , x ) :\n v = self.amplitude ( x )\n #\n return complex( v.real () , v.imag () )",
"def amplitude(self, channel, amp):\n chan = self.channels[channel]\n\n assert abs(amp) <= 1.5, 'Amplitude has to be less than 1.5V'\n err = chan.connection.channelAmplitude(chan.chan... | [
"0.6375799",
"0.6256541",
"0.62201387",
"0.6191588",
"0.6053649",
"0.60339534",
"0.6031569",
"0.5922736",
"0.57384294",
"0.5695767",
"0.5644062",
"0.5571589",
"0.55101675",
"0.5470523",
"0.5453427",
"0.5446871",
"0.5431867",
"0.542857",
"0.5420551",
"0.54123116",
"0.5397047",... | 0.0 | -1 |
Sets the complex amplitude. | def getIntensityP(self):
return self._Epi.intensity() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _amp_ ( self , x ) :\n v = self.amplitude ( x )\n #\n return complex( v.real () , v.imag () )",
"def amplitude(self, channel, amp):\n chan = self.channels[channel]\n\n assert abs(amp) <= 1.5, 'Amplitude has to be less than 1.5V'\n err = chan.connection.channelAmplitude(chan.chan... | [
"0.6375799",
"0.6256541",
"0.62201387",
"0.6191588",
"0.6053649",
"0.60339534",
"0.6031569",
"0.5922736",
"0.57384294",
"0.5695767",
"0.5644062",
"0.5571589",
"0.55101675",
"0.5470523",
"0.5453427",
"0.5446871",
"0.5431867",
"0.542857",
"0.5420551",
"0.54123116",
"0.5397047",... | 0.0 | -1 |
Sets the complex amplitude. | def getIntensity(self):
return self.getIntensityS() + self.getIntensityP() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _amp_ ( self , x ) :\n v = self.amplitude ( x )\n #\n return complex( v.real () , v.imag () )",
"def amplitude(self, channel, amp):\n chan = self.channels[channel]\n\n assert abs(amp) <= 1.5, 'Amplitude has to be less than 1.5V'\n err = chan.connection.channelAmplitude(chan.chan... | [
"0.6375799",
"0.6256541",
"0.62201387",
"0.6191588",
"0.6053649",
"0.60339534",
"0.6031569",
"0.5922736",
"0.57384294",
"0.5695767",
"0.5644062",
"0.5571589",
"0.55101675",
"0.5470523",
"0.5453427",
"0.5446871",
"0.5431867",
"0.542857",
"0.5420551",
"0.54123116",
"0.5397047",... | 0.0 | -1 |
Determines if two polarized photons are identical (same energy, direction and polarization). | def __eq__(self, candidate):
if ((self.energy() == candidate.energy() and
self.unitDirectionVector() == candidate.unitDirectionVector()) and
self._Esigma.complexAmplitude() == candidate._Esigma.complexAmplitude() and
self._Epi.complexAmplitude() == candidate._Epi.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_similar_with(self, other):\n\n # corresponding angles are congruent\n if self.angles != other.angles:\n return False\n # corresponding sides are proportional\n proportion = self.perimeter() / other.perimeter()\n for i in range(len(self.lengths)):\n if... | [
"0.68101615",
"0.6614083",
"0.65789586",
"0.64757085",
"0.64612556",
"0.6421079",
"0.6401745",
"0.63870627",
"0.63730395",
"0.6364115",
"0.6333348",
"0.6290905",
"0.6201502",
"0.6198665",
"0.6136013",
"0.6116805",
"0.6093822",
"0.6086045",
"0.60715705",
"0.606903",
"0.6060494... | 0.5732779 | 84 |
Determines if two polarized photons are not identical (same energy, direction and polarization). | def __ne__(self, candidate):
return not (self == candidate) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_similar_with(self, other):\n\n # corresponding angles are congruent\n if self.angles != other.angles:\n return False\n # corresponding sides are proportional\n proportion = self.perimeter() / other.perimeter()\n for i in range(len(self.lengths)):\n if... | [
"0.67724645",
"0.6738176",
"0.65756047",
"0.6330637",
"0.63286847",
"0.6316591",
"0.63129854",
"0.6303219",
"0.62443715",
"0.62213105",
"0.61847687",
"0.61709136",
"0.6159082",
"0.61590666",
"0.6127881",
"0.6122283",
"0.60869306",
"0.607861",
"0.6044467",
"0.6021837",
"0.6010... | 0.0 | -1 |
Concatenate conditioning vector on feature map axis. | def conv_cond_concat(x, y):
ones_y = fluid.layers.fill_constant_batch_size_like(
x, [-1, y.shape[1], x.shape[2], x.shape[3]], "float32", 1.0)
return fluid.layers.concat([x, ones_y * y], 1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conv_cond_concat(x, y):\n return T.concatenate([x, y*T.ones((x.shape[0], y.shape[1], x.shape[2], x.shape[3], x.shape[4]))], axis=1)",
"def add_feature(x, x1):\n if x is None:\n x = x1\n else:\n x = np.concatenate((x, x1), axis=1)\n return x",
"def buildConditionalPriorTerm(self):\... | [
"0.58339125",
"0.5492559",
"0.54484504",
"0.5387228",
"0.53704846",
"0.5263228",
"0.52565724",
"0.52355707",
"0.5155966",
"0.5096469",
"0.50964016",
"0.5069878",
"0.5039265",
"0.5006411",
"0.49536952",
"0.4943956",
"0.4934806",
"0.49287412",
"0.4924495",
"0.49115935",
"0.4903... | 0.5475793 | 2 |
a network in network layer (1x1 CONV) | def nin(x, num_units, name=None, param_attr=None, act=None, reuse=False):
if name is None:
name = get_parent_function_name()
s = list(map(int, x.shape))
#print([np.prod(s[:-1]),s[-1]])
x = reshape(x, [-1, np.prod(s[2:]), s[1]])
#x = reshape(x, [np.prod(s[:-1]),s[-1]])#the position change and... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trainNet():",
"def complex_network_mapping(graph):\n vect = []\n\n n = nx.number_of_nodes(graph)\n e = nx.number_of_edges(graph)\n print n, e\n\n# adj = nx.adjacency_matrix(graph).toarray()\n# adj_bin = np.where(adj > 0, 1., 0.)\n# adj_conn = 1 - adj\n adj_bin = nx.adjacency_matrix(gr... | [
"0.64673615",
"0.6333042",
"0.62303203",
"0.62081575",
"0.6189894",
"0.6160035",
"0.61567533",
"0.6140798",
"0.6115296",
"0.61127985",
"0.61087465",
"0.6017349",
"0.5999597",
"0.59709346",
"0.59705466",
"0.5901008",
"0.5869905",
"0.5866736",
"0.5856518",
"0.58457196",
"0.5842... | 0.0 | -1 |
Emit a deprecation warning about a gnomerelated reactor. | def deprecatedGnomeReactor(name: str, version: Version) -> None:
stem = DEPRECATION_WARNING_FORMAT % {
"fqpn": "twisted.internet." + name,
"version": getVersionString(version),
}
msg = stem + ". Please use twisted.internet.gireactor instead."
warnings.warn(msg, category=DeprecationWarni... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def deprecation(self, message, *args, **kws):\n self._log(DEPRECATION, message, args, **kws)",
"def guarded_deprecation_warning(*args, **kwargs):\n if os.environ.get(\"SERVE_WARN_V1_DEPRECATIONS\", \"0\") == \"1\":\n from ray._private.utils import deprecated\n\n return deprecated(*args, **kwa... | [
"0.63709056",
"0.6337697",
"0.61615217",
"0.6083312",
"0.6040545",
"0.59742963",
"0.58868295",
"0.5778024",
"0.5695411",
"0.563647",
"0.56345797",
"0.5613319",
"0.55875045",
"0.5550916",
"0.5532492",
"0.5523634",
"0.5511823",
"0.5491791",
"0.5482633",
"0.546482",
"0.54356366"... | 0.75850695 | 0 |
reads an image file and converts it into given representation. | def read_image(file_name, representation=GRAY_SCALE):
im = np.array(imread(file_name))
img_float = im.astype(np.float32)
if representation == 1: # return grayscale image
if len(im.shape) == TWO_DIM: # image was given in grayscale
return img_float
elif len(im.shape) == THREE_DIM... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_image(filename, representation):\n img = imread(filename)\n img = int2float(img)\n if representation == GS_REP:\n img = rgb2gray(img)\n return img",
"def read_image(filename, representation):\n image = imread(filename)\n new_image = image.astype(np.float64)\n new_image /= 255... | [
"0.7694408",
"0.76537734",
"0.7615849",
"0.75888735",
"0.75616884",
"0.7551129",
"0.7456566",
"0.74403816",
"0.73565173",
"0.72619706",
"0.71915746",
"0.71527964",
"0.6961384",
"0.67848295",
"0.67825335",
"0.6656239",
"0.6641373",
"0.6592539",
"0.6588783",
"0.6508807",
"0.649... | 0.73874223 | 8 |
clears noise from given image using bilateral Filter. | def filter_image(img):
return cv2.bilateralFilter(img, 9, 50, 50) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filtering(image):\n output = np.array(image)\n for x in xrange(0,1):\n bilateralFilter_img = cv2.bilateralFilter(output,5, 75, 75)\n\n return bilateralFilter_img",
"def remove_noise(image):\n filtered = cv2.absdiff(image.astype(np.uint8), 255,\n cv2.ADAPTIVE_THRES... | [
"0.6837545",
"0.66253495",
"0.6352146",
"0.6252205",
"0.6215135",
"0.6187826",
"0.60780174",
"0.60614115",
"0.6018258",
"0.5996656",
"0.5905434",
"0.59041035",
"0.58784217",
"0.581671",
"0.5788512",
"0.57701117",
"0.5768871",
"0.5768721",
"0.57474273",
"0.57364833",
"0.568226... | 0.6760517 | 1 |
thresholds a grayscale image to a binary image. | def threshold_image(img, threshold=THRESHOLD):
return cv2.threshold(img, threshold, MAX_GRAY_SCALE, cv2.THRESH_BINARY) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def binarize(self, image, threshold):\n\n bin_img = image.copy()\n [h, w] = bin_img.shape\n opt_threshold = threshold\n print(opt_threshold)\n for row in range(h):\n for col in range(w):\n if bin_img[row, col] > opt_threshold: #greater than threshld whit... | [
"0.7555683",
"0.73864496",
"0.71793264",
"0.7158029",
"0.70775515",
"0.69993556",
"0.69715166",
"0.6928067",
"0.68441004",
"0.68359464",
"0.6771333",
"0.6745976",
"0.6704027",
"0.6582386",
"0.65818775",
"0.65701693",
"0.6550687",
"0.65359485",
"0.6466406",
"0.63850933",
"0.63... | 0.68359834 | 9 |
find contours in image, filters external (not 100%!!) | def find_contours(thresh):
thresh = thresh.astype(np.uint8)
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)
# filter outer contours
filtered_cont = []
for i in range(len(contours)):
if hierarchy[0, i, 3] == NO_PARENT:
filtered_cont.append(co... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocessing(self, img):\n [a, contours, c] = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n return contours",
"def find_contour(ctx: Context):\n cv2.copyTo(ctx.filter_image, np.ones_like(ctx.temp_image1), ctx.temp_image1)\n contours, _ = cv2.findContours(ctx.temp_image1... | [
"0.77753466",
"0.7717092",
"0.7498471",
"0.74524987",
"0.7381892",
"0.73541546",
"0.73451114",
"0.7322127",
"0.73151344",
"0.7306261",
"0.7302151",
"0.72858834",
"0.7281763",
"0.7228213",
"0.71711946",
"0.7154602",
"0.7140557",
"0.71032584",
"0.7058505",
"0.70153964",
"0.7006... | 0.68330437 | 26 |
marks the contours on the image and crops them. | def mark_contours(contour_arr, img, symmetry, _plot=False):
marg, flag = 7, 0
# fig, ax = plt.subplots()
# ax.imshow(img, cmap="gray")
sub_images = [] # init array for pictures
for contour in contour_arr:
lower_dim = contour[:, 0]
x, y = lower_dim[:, 0], lower_dim[:, 1]
min... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_contours(self, image, maskImg):\r\n # Required variables..\r\n x, y, width, height = 0, 0, 0, 0\r\n # Find contours..\r\n contours, hierarchy = cv2.findContours(image=maskImg, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_NONE) # Playable Parameters..\r\n # Draw the c... | [
"0.630481",
"0.62921685",
"0.62199384",
"0.6207988",
"0.611618",
"0.60492754",
"0.59384584",
"0.58942974",
"0.5874997",
"0.5870931",
"0.58539474",
"0.5836506",
"0.5829273",
"0.5828158",
"0.5815946",
"0.5809596",
"0.57762873",
"0.57565564",
"0.5724893",
"0.57062984",
"0.569092... | 0.5319842 | 57 |
resizes the given image to size width X height, doesnt edit the original image. | def resize_image(img, width, height):
return cv2.resize(img, (width, height)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_image(image):\n image = resize(image)\n return image",
"def resize_image(self, width=200):\n self.new_width = width\n aspect_ratio = self.original_height/float(self.original_width)\n self.new_height = int(aspect_ratio * self.new_width)\n\n resized_image = self.image.... | [
"0.7676757",
"0.74949396",
"0.74371797",
"0.73887146",
"0.73574597",
"0.73138",
"0.73090416",
"0.72722024",
"0.72504354",
"0.7237081",
"0.7225623",
"0.71851814",
"0.7157568",
"0.7135699",
"0.71342456",
"0.7129016",
"0.7115038",
"0.71092075",
"0.7105796",
"0.710538",
"0.710450... | 0.7310563 | 6 |
Receives two images to compare, img1 being the original. and a string indictating which error function to use. doesnt assume images are the same size. | def compare_img(img1, img2, err_function="ALL"):
# make sure images are the same shape #
height1, width1, height2, width2 = img1.shape[0], img1.shape[1], img2.shape[0], img2.shape[1]
if img1.shape != img2.shape:
if width1 * height1 > width2 * height2:
img1 = resize_image(img1, width2, h... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compare_images(self, img1, img2):\n if self.debug:\n cv2.imshow('img1', img1)\n cv2.imshow('img2', img2)\n cv2.waitKey(5)\n time.sleep(2)\n\n # find the mean squared difference between the images\n # http://www.pyimagesearch.com/2014/09/15/python... | [
"0.7262324",
"0.72613925",
"0.7194562",
"0.71092004",
"0.69404185",
"0.6802441",
"0.66210765",
"0.6609339",
"0.66056174",
"0.65600413",
"0.646752",
"0.6427402",
"0.6348418",
"0.63423145",
"0.6291259",
"0.62624484",
"0.6253601",
"0.6207154",
"0.6180912",
"0.6175744",
"0.613465... | 0.81464946 | 0 |
calculates the mean squared diffrence between two given images. assumes the images have the same size image | def mse(img1, img2):
err = (np.square(img1 - img2)).mean(axis=None)
# return the MSE, the lower the error, the more "similar"
# the two images are
return err | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _mean_squared_error(img1, img2):\n err = np.sum((img1.astype(\"float\") - img2.astype(\"float\")) ** 2)\n err /= float(img1.shape[0] * img1.shape[1])\n return err",
"def mse(image1: np.ndarray, image2: np.ndarray) -> np.ndarray:\n return np.sqrt(np.power((image1 - image2), 2).mean(axis=(-1, -2)))... | [
"0.77920526",
"0.7781945",
"0.744914",
"0.7409409",
"0.7259769",
"0.7251279",
"0.720005",
"0.71611667",
"0.70970553",
"0.7089986",
"0.7034388",
"0.70342225",
"0.6963611",
"0.6932556",
"0.68521976",
"0.68270266",
"0.6822264",
"0.67950255",
"0.67466533",
"0.64840686",
"0.648016... | 0.70962375 | 9 |
Initialize all valid properties. | def __init__(self, jsondict=None, strict=True):
self.abnormalCodedValueSet = None
""" Value set of abnormal coded values for the observations conforming
to this ObservationDefinition.
Type `FHIRReference` (represented as `dict` in JSON). """
self.category = None... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *properties):\n self._properties = properties",
"def _initFields(self):\n pass",
"def initProperties(self):\n self.setFoldComments(Preferences.getEditor(\"CssFoldComment\"))\n self.setFoldCompact(Preferences.getEditor(\"AllFoldCompact\"))\n try:\n ... | [
"0.69967675",
"0.6955605",
"0.68935335",
"0.6740379",
"0.67131793",
"0.67067623",
"0.66696674",
"0.6666951",
"0.66482884",
"0.66469395",
"0.6634272",
"0.66187406",
"0.6607808",
"0.6603329",
"0.6603329",
"0.6603329",
"0.6603329",
"0.6603329",
"0.6553997",
"0.6553997",
"0.65535... | 0.0 | -1 |
Initialize all valid properties. | def __init__(self, jsondict=None, strict=True):
self.age = None
""" Applicable age range, if relevant.
Type `Range` (represented as `dict` in JSON). """
self.appliesTo = None
""" Targetted population of the range.
List of `CodeableConcept` items (represe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *properties):\n self._properties = properties",
"def _initFields(self):\n pass",
"def initProperties(self):\n self.setFoldComments(Preferences.getEditor(\"CssFoldComment\"))\n self.setFoldCompact(Preferences.getEditor(\"AllFoldCompact\"))\n try:\n ... | [
"0.69967675",
"0.6955605",
"0.68935335",
"0.6740379",
"0.67131793",
"0.67067623",
"0.66696674",
"0.6666951",
"0.66482884",
"0.66469395",
"0.6634272",
"0.66187406",
"0.6607808",
"0.6603329",
"0.6603329",
"0.6603329",
"0.6603329",
"0.6603329",
"0.6553997",
"0.6553997",
"0.65535... | 0.0 | -1 |
Initialize all valid properties. | def __init__(self, jsondict=None, strict=True):
self.conversionFactor = None
""" SI to Customary unit conversion factor.
Type `float`. """
self.customaryUnit = None
""" Customary unit for quantitative results.
Type `CodeableConcept` (represented as `dict... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *properties):\n self._properties = properties",
"def _initFields(self):\n pass",
"def initProperties(self):\n self.setFoldComments(Preferences.getEditor(\"CssFoldComment\"))\n self.setFoldCompact(Preferences.getEditor(\"AllFoldCompact\"))\n try:\n ... | [
"0.69967675",
"0.6955605",
"0.68935335",
"0.6740379",
"0.67131793",
"0.67067623",
"0.66696674",
"0.6666951",
"0.66482884",
"0.66469395",
"0.6634272",
"0.66187406",
"0.6607808",
"0.6603329",
"0.6603329",
"0.6603329",
"0.6603329",
"0.6603329",
"0.6553997",
"0.6553997",
"0.65535... | 0.0 | -1 |
Function to log an event with the given key. If the ``key`` has not exceeded their allotted events, then the function returns ``False`` to indicate that no limit is being imposed. If the ``key`` has exceeded the number of events, then the function returns ``True`` indicating ratelimiting should occur. | def limit(self, key):
if self._debug:
return False
counter = self.database.List(self.name + ':' + key)
n = len(counter)
is_limited = False
if n < self._limit:
counter.prepend(str(time.time()))
else:
oldest = counter[-1]
if ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rate_limited(self, key_function=None):\n if key_function is None:\n def key_function(*args, **kwargs):\n data = pickle.dumps((args, sorted(kwargs.items())))\n return hashlib.md5(data).hexdigest()\n\n def decorator(fn):\n @wraps(fn)\n ... | [
"0.6314541",
"0.6014755",
"0.577914",
"0.5500181",
"0.54538137",
"0.5354464",
"0.5334985",
"0.5245052",
"0.5227737",
"0.5022069",
"0.4968157",
"0.49460158",
"0.49370098",
"0.49285924",
"0.49258116",
"0.48979118",
"0.48943257",
"0.48854864",
"0.4861771",
"0.48335403",
"0.47916... | 0.6515088 | 0 |
Function or method decorator that will prevent calls to the decorated function when the number of events has been exceeded for the given time period. It is probably important that you take care to choose an appropriate key function. For instance, if ratelimiting a webpage you might use the requesting user's IP as the k... | def rate_limited(self, key_function=None):
if key_function is None:
def key_function(*args, **kwargs):
data = pickle.dumps((args, sorted(kwargs.items())))
return hashlib.md5(data).hexdigest()
def decorator(fn):
@wraps(fn)
def inner(*ar... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def timed(limit):\n def decorate(func):\n def newfunc(*arg, **kw):\n start = time.time()\n func(*arg, **kw)\n end = time.time()\n if end - start > limit:\n raise TimeExpired(\"Time limit (%s) exceeded\" % limit)\n newfunc = make_decorator(... | [
"0.65584713",
"0.65495706",
"0.6525419",
"0.6494096",
"0.6299879",
"0.61791515",
"0.6172259",
"0.61206627",
"0.6065372",
"0.59967524",
"0.5996692",
"0.59204817",
"0.5900531",
"0.58844846",
"0.5834017",
"0.57783157",
"0.5757396",
"0.57387686",
"0.57096756",
"0.56504446",
"0.56... | 0.7474835 | 0 |
Delete the indicated file or directory | def delete(path, recursive=False):
fs.delete(path, recursive) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_file(path):\n return files.delete_file(path)",
"def delete(self, filename):\n pass",
"def delete(self):\n\n try:\n remove(self.file)\n except OSError:\n pass",
"def delete_file(path):\n if os.path.isfile(path):\n os.remove(path)... | [
"0.79165214",
"0.77798307",
"0.7766277",
"0.77237564",
"0.76830983",
"0.76725525",
"0.7647804",
"0.7647804",
"0.7614907",
"0.7521688",
"0.7468159",
"0.74504274",
"0.743215",
"0.7413891",
"0.74093837",
"0.7405605",
"0.73836875",
"0.7336581",
"0.7334107",
"0.7325344",
"0.732099... | 0.7445668 | 12 |
Return free space on disk, like the UNIX df command Returns | def df():
fs.df() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_free_disk_space():\n cmd = 'df -h'\n p = Popen(cmd, shell=True, stdout=PIPE)\n res = p.communicate()\n if res[0]:\n res = res[0]\n else:\n res = res[1]\n logger.warning('Disk usage statisticks:')\n logger.warning(res)",
"def get_space_used():\n fs.get_space_used()",
... | [
"0.83536917",
"0.8184584",
"0.81557757",
"0.8076139",
"0.79408926",
"0.79404783",
"0.78855693",
"0.7732318",
"0.7624371",
"0.76026833",
"0.753872",
"0.7527869",
"0.7521188",
"0.74863976",
"0.7448919",
"0.7448538",
"0.7434289",
"0.7422073",
"0.7413368",
"0.7412355",
"0.7378212... | 0.0 | -1 |
Compute bytes used by all contents under indicated path in file tree | def disk_usage(path):
fs.disk_usage(path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def size(path):",
"def _disk_usage(path: pathlib.Path):\n if path.is_file():\n return path.stat().st_size\n elif path.is_dir():\n size_bytes = 0\n for file in path.iterdir():\n size_bytes += _disk_usage(file)\n return size_bytes\n else:\n raise NotImplementedError(\"What filetype is {file}... | [
"0.7304568",
"0.6749809",
"0.66927916",
"0.6687458",
"0.6680808",
"0.6633082",
"0.65648973",
"0.6540471",
"0.6517419",
"0.6423607",
"0.63529855",
"0.6349727",
"0.6347756",
"0.63181674",
"0.62784153",
"0.625136",
"0.6243889",
"0.62026674",
"0.61959136",
"0.61555153",
"0.613638... | 0.6480013 | 9 |
Returns True if the path is known to the cluster, False if it does not (or there is an RPC error) | def exists(path):
fs.exists(path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_for_path(self, hdfs_path):\n c = self.get_conn()\n return bool(c.status(hdfs_path, strict=False))",
"def is_managed_path(self, path):\n if self._config is None:\n return False\n fields = path.split(':', 1)\n return len(fields) == 2 and fields[0] in self._co... | [
"0.7158687",
"0.68224347",
"0.6790576",
"0.6722285",
"0.65580213",
"0.65009516",
"0.6497719",
"0.6422786",
"0.64082927",
"0.6384369",
"0.63785017",
"0.6365407",
"0.6360442",
"0.6326955",
"0.63169855",
"0.6286864",
"0.62844235",
"0.62693346",
"0.6265129",
"0.62452525",
"0.6220... | 0.58613884 | 64 |
Get reported total capacity of file system Returns | def get_capacity():
fs.get_capacity() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_space_used():\n fs.get_space_used()",
"def get_space_used():\n files = jobtracker.query(\"SELECT * FROM files \" \\\n \"WHERE status IN ('added', 'downloaded', 'unverified')\")\n\n total_size = 0\n for file in files:\n total_size += int(file['size'])\n re... | [
"0.7905383",
"0.7686586",
"0.76265246",
"0.7514304",
"0.740728",
"0.7393012",
"0.73364675",
"0.73107606",
"0.72528416",
"0.72520536",
"0.71825486",
"0.71104777",
"0.7035991",
"0.70202947",
"0.7017264",
"0.6983544",
"0.6979307",
"0.6925965",
"0.6920043",
"0.6917545",
"0.689413... | 0.8695405 | 0 |
Get space used on file system Returns | def get_space_used():
fs.get_space_used() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSpaceUsage(path):\n st = os.statvfs(path)\n \n flash = { \"free\" : st.f_bavail * st.f_frsize, \"used\":(st.f_blocks - st.f_bfree) * st.f_frsize }\n \n #free = st.f_bavail * st.f_frsize\n #total = st.f_blocks * st.f_frsize\n #used = (st.f_blocks - st.f_bfree) * st.f_frsize\n return f... | [
"0.8161204",
"0.7796477",
"0.7787275",
"0.7772227",
"0.7726032",
"0.7704461",
"0.762351",
"0.7598784",
"0.7515085",
"0.74991655",
"0.7485404",
"0.7462633",
"0.7449219",
"0.7406714",
"0.73842853",
"0.73459834",
"0.73239464",
"0.72179013",
"0.720543",
"0.72001547",
"0.7185789",... | 0.9013167 | 0 |
Retrieve directory contents and metadata, if requested. | def ls(path, detail=False):
fs.ls(path, detail) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_directory(self, directory: str) -> List[Dict]:\n raise NotImplementedError",
"def read_directory(self, dirpath):\n raise NotImplementedError",
"def getDirectoryMetadata( self, path ):\n res = self.__checkArgumentFormat( path )\n if not res['OK']:\n return res\n urls = res['V... | [
"0.6451851",
"0.6447971",
"0.6434475",
"0.60306376",
"0.60244876",
"0.6013241",
"0.59675",
"0.59375036",
"0.5927382",
"0.58912545",
"0.5890785",
"0.58385384",
"0.5747953",
"0.5713665",
"0.5681259",
"0.5652997",
"0.5644693",
"0.56401676",
"0.5618892",
"0.5595484",
"0.5586005",... | 0.0 | -1 |
Create directory in HDFS | def mkdir(path, **kwargs):
fs.mkdir(path, kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dfs_mkdir(self, path):\n return self.execute_command(\"hdfs dfs -mkdir \" + path)",
"def fs_create_dir(self, path):\n\t\treturn Job(SDK.PrlSrv_FsCreateDir(self.handle, path)[0])",
"def fs_mkdir(self, dirname: str) -> None:\n self.exec_(\"import uos\\nuos.mkdir('%s')\" % dirname)",
"def mkdi... | [
"0.8143611",
"0.76000506",
"0.7166708",
"0.7083679",
"0.7044642",
"0.7024804",
"0.6985183",
"0.6893272",
"0.6882638",
"0.6849721",
"0.67279965",
"0.6700775",
"0.66672105",
"0.66664934",
"0.66499156",
"0.66083074",
"0.6599711",
"0.6597963",
"0.65964985",
"0.65955585",
"0.65940... | 0.66066265 | 16 |
Open HDFS file for reading or writing | def opens(path, mode='rb', buffer_size=None, replication=None,
default_block_size=None):
fs.open(path, mode, buffer_size, replication, default_block_size) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_hdfs(self):\n\t\traise NotImplementedError()",
"def open (self, path, mode):\r\n pass",
"def client():\n return hdfs.connect()",
"def hdfs(self, *args, **kwargs):\n return self.hadoop(*args, **kwargs)",
"def test_open_read(self, remote_mock_dir):\n\n file_path = posixpath.... | [
"0.69550383",
"0.6203255",
"0.6135038",
"0.60283446",
"0.59872985",
"0.59727913",
"0.58762646",
"0.585251",
"0.58396345",
"0.57984585",
"0.5775946",
"0.5772025",
"0.5750017",
"0.57352865",
"0.5732434",
"0.5729949",
"0.571854",
"0.56686",
"0.5661521",
"0.56384385",
"0.5623737"... | 0.6181232 | 2 |
Rename file, like UNIX mv command | def rename(path, new_path):
fs.rename(path, new_path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def RenameFile(self, oldname: str, newname: str) -> None:\n ...",
"def rename(self, src, dst):\n os.rename(src, dst)",
"def rename(oldname, newname):",
"def rename_file (self):\n\t\tassert self.__filename, \"Renaming could not complete because the new filename could not be determined, one or mo... | [
"0.7883169",
"0.776845",
"0.76150286",
"0.75697446",
"0.7554254",
"0.7393611",
"0.73767304",
"0.73767304",
"0.7201459",
"0.71401316",
"0.70594615",
"0.69519454",
"0.6929053",
"0.6919271",
"0.68715525",
"0.6865904",
"0.68450224",
"0.6837736",
"0.6837722",
"0.67226464",
"0.6715... | 0.7404169 | 5 |
Upload filelike object to HDFS path | def upload(path, stream, buffer_size=None):
fs.upload(path, stream, buffer_size) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def put_object_as_file(self, ctx):\n req = ctx.req\n\n virtual_path = urllib_parse.unquote(req.path)\n put_location_req = rpc.put_location_request(virtual_path)\n\n request_etag = req.headers.get(\"ETag\", \"\")\n hasher = hashlib.md5()\n wsgi_input = SnoopingInput(req.env... | [
"0.69630384",
"0.69315165",
"0.68763965",
"0.6768473",
"0.67281955",
"0.6682803",
"0.66771275",
"0.65934604",
"0.6584578",
"0.6503615",
"0.64935505",
"0.64916545",
"0.6434837",
"0.643003",
"0.6352392",
"0.6344959",
"0.6341716",
"0.62886834",
"0.6281264",
"0.622571",
"0.620040... | 0.67595905 | 4 |
Determine the box grid, the row 'x' and column 'y' are in and return the box grid boundaries (top left, bottom right). | def get_box_grid(x, y):
for grid in GRIDS:
if x >= grid[0][0] and y >= grid[0][1] and \
x <= grid[1][0] and y <= grid[1][1]:
return grid
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bounding_box(x: Bounds, y: Bounds, grid_spacing: int) -> (Bounds, Bounds):\n # Check if requested grid size is allowable\n if grid_spacing not in Grid._SUPPORTED_SIZES:\n raise RuntimeError(f'Grid spacing should be one of {Grid._SUPPORTED_SIZES} to keep grids of different spacing align... | [
"0.7276697",
"0.7249602",
"0.7174105",
"0.7131322",
"0.70830506",
"0.69582266",
"0.69582236",
"0.6817992",
"0.6778762",
"0.6744852",
"0.6739384",
"0.6738154",
"0.67366695",
"0.67229617",
"0.6694428",
"0.66317385",
"0.66051924",
"0.6581854",
"0.65696084",
"0.65642273",
"0.6550... | 0.82200074 | 0 |
Check through the puzzle array in the range delimited by top left (tl) and bottom right (br) for values in 'potential'. Any value found that is in 'potential' is removed so only missing values remain when it is returned. | def rm_pot(potential, puzzle, tl, br):
for y in range(tl[1], br[1]+1):
for x in range(tl[0], br[0]+1):
if puzzle[y][x] in potential:
potential.remove(puzzle[y][x])
return potential | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def searchDeadEnd(self):\n boundaries = []\n if not self.red:\n i = self.midWidth - 1\n else:\n i = self.midWidth + 1\n boudaries = [(i, j) for j in range(self.height)]\n validPositions = []\n for i in boudaries:\n if not (i[0], i[1]) in se... | [
"0.588401",
"0.5613431",
"0.5605046",
"0.5547881",
"0.544818",
"0.5424087",
"0.53872746",
"0.5362563",
"0.53606844",
"0.53606844",
"0.53370255",
"0.5326348",
"0.53133196",
"0.5296384",
"0.52813685",
"0.5255672",
"0.52168256",
"0.52042156",
"0.5199848",
"0.51857",
"0.51857",
... | 0.66826487 | 0 |
Cette fonction permet de construire une fusee | def fusee():
#Configuration de la fenetre et de la vitesse d'execution
window = Screen()
hideturtle()
window.setup(600, 600)
window.bgcolor("black")
pencolor("white")
speed("normal")
#On va utiliser un dictionnaires pour stocker les positions (simple precaution)
positions = {}
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args):\n _BRepAlgo.BRepAlgo_Fuse_swiginit(self,_BRepAlgo.new_BRepAlgo_Fuse(*args))",
"def falcon():",
"def __init__(self, use=True):\n self.use = use",
"def __init__():",
"def __init__(self, dist ,focalLength,ccdWidth, ccdHeigth):\n self.dist = dist #Distance betwee... | [
"0.64367664",
"0.5987766",
"0.59837556",
"0.5877464",
"0.5865099",
"0.58392453",
"0.5760259",
"0.57456326",
"0.57456326",
"0.57456326",
"0.571365",
"0.5706213",
"0.57004625",
"0.5689079",
"0.5668011",
"0.5656841",
"0.5654774",
"0.5635367",
"0.56317806",
"0.5621027",
"0.561996... | 0.0 | -1 |
assert that calling func(args, kwargs) triggers a DeprecationWarning. | def deprecated_call(func, *args, **kwargs):
warningmodule = py.std.warnings
l = []
oldwarn_explicit = getattr(warningmodule, 'warn_explicit')
def warn_explicit(*args, **kwargs):
l.append(args)
oldwarn_explicit(*args, **kwargs)
oldwarn = getattr(warningmodule, 'warn')
def warn(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_deprecate_args(self):\n @deprecate(arguments={\"bar\": \"use foo instead\"})\n def foo(a, foo=None, bar=None):\n return 2*a\n\n with warnings.catch_warnings(record=True) as w:\n self.assertEqual(foo(1, bar=True), 2,\n \"Decorated funct... | [
"0.76134264",
"0.7457519",
"0.69317734",
"0.68314976",
"0.6774156",
"0.67599773",
"0.6758293",
"0.6725724",
"0.67210484",
"0.6709473",
"0.66816026",
"0.6671405",
"0.6668715",
"0.66650754",
"0.65562075",
"0.6553829",
"0.6536344",
"0.6527607",
"0.6516987",
"0.6516459",
"0.64884... | 0.7718524 | 0 |
Returns all files required by some base files. | def required_files(self, args):
args_set = set(args)
edge_list = self.__transform_pre(self.__include_deps_supply.get_file_include_deps())
targets = chain((target for (source, target) in edge_list if source in args_set), args_set)
return self.__transform_post(targets) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_base_files(self):\n setup_file = path.join(self.PyCogentDirectory, 'setup.py')\n #reqs_file = path.join(self.PyCogentDirectory, 'cogent-requirements.txt')\n #return [(setup_file, 'Python'), (reqs_file, 'Properties')]\n return [(setup_file, 'Python')]",
"def gather_required_fi... | [
"0.73063654",
"0.67563796",
"0.6696825",
"0.66219485",
"0.6517494",
"0.64967936",
"0.6473607",
"0.6456208",
"0.64487964",
"0.6447214",
"0.6430212",
"0.6390996",
"0.6387727",
"0.6385078",
"0.6382932",
"0.6338609",
"0.6332042",
"0.6308531",
"0.62689346",
"0.6263379",
"0.6257691... | 0.67471623 | 2 |
Processes product data for the system. | def process_product_data(cls, pricing_info):
if 'prices' not in pricing_info or 'vat_bands' not in pricing_info:
raise PricingException('Json data does not contain required '
'product and vat band information')
product_prices = pricing_info['prices']
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def retrieve_product_infos(self):\n\n # PRODUCT NAME\n try:\n product_name = self.product['product_name'].capitalize()\n except KeyError:\n product_name = None\n\n # PRODUCT CODE\n try:\n product_code = self.product['code'].capitalize()\n e... | [
"0.6721084",
"0.6714183",
"0.65735006",
"0.6500077",
"0.6248321",
"0.60824895",
"0.6079448",
"0.6038689",
"0.5998337",
"0.599525",
"0.59744954",
"0.5959825",
"0.5957547",
"0.5954584",
"0.5899196",
"0.5898683",
"0.58757275",
"0.5869557",
"0.5860635",
"0.5835009",
"0.5780648",
... | 0.6405894 | 4 |
Guess the bean name from a WSDL type. Assume the bean name is equal to the type having the first letter capitalized. | def guessbeanname(self):
t = self.name
return t[0].upper() + t[1:] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def service_type_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"service_type_name\")",
"def get_type_name(type):\n name = type.name\n if type.is_simple:\n return _get_simple_type_mapping(name)\n elif type.is_enum:\n return _get_simple_type_mapping('str')\n ... | [
"0.6055587",
"0.59900916",
"0.5906633",
"0.5842989",
"0.5832207",
"0.57966083",
"0.5786233",
"0.5717361",
"0.56284714",
"0.56159526",
"0.54767513",
"0.5473429",
"0.5454887",
"0.5423297",
"0.5414507",
"0.5383779",
"0.5352961",
"0.5352691",
"0.5325332",
"0.5307059",
"0.52658063... | 0.6790827 | 0 |
Return the names of certain fields in the entity info. | def getfieldnames(self, relType=None):
if relType is None:
names = [str(f.name) for f in self.info.fields]
else:
names = [str(f.name) for f in self.info.fields \
if f.relType == relType]
return frozenset(names) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def field_names(self):\n ...",
"def field_names(self):\n return self.base_field_names() + list(self.data.keys())",
"def get_fields(self):\n \n return self.metadata.keys()",
"def fields(cls):\n return cls._nameToValue",
"def get_field_names(self):\n return {rv[0] fo... | [
"0.77328897",
"0.7461978",
"0.735866",
"0.72412884",
"0.72297305",
"0.71845204",
"0.7180779",
"0.7167365",
"0.71628743",
"0.71035343",
"0.7060575",
"0.70289564",
"0.70243216",
"0.7011391",
"0.6979408",
"0.6976091",
"0.6965264",
"0.6961422",
"0.69358796",
"0.69321954",
"0.6887... | 0.6067711 | 83 |
Return the attributes (relType == ATTRIBUTE). | def getattrs(self):
# ICAT 4.5.0 also lists the meta attributes as attributes in
# the entity info. Need to remove them here, as they should
# not be added to InstAttr.
return self.getfieldnames('ATTRIBUTE') - Entity.MetaAttr | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getAttributes(self):\n pass",
"def getAttributes(self):\n return self.attributes",
"def getAttributes(self):\n return self.attributes",
"def GetAttributes(self):\r\n\r\n return self._attr",
"def get_attributes(self):\n return self.attributes",
"def get_attributes(se... | [
"0.7124617",
"0.7084474",
"0.7084474",
"0.706891",
"0.70204544",
"0.6988809",
"0.6971989",
"0.68999547",
"0.6874058",
"0.6874058",
"0.6872412",
"0.6830542",
"0.68200505",
"0.68036985",
"0.6800715",
"0.673431",
"0.6647135",
"0.6600955",
"0.6600955",
"0.6600955",
"0.6571482",
... | 0.7044305 | 4 |
Return the many to one relations (relType == ONE). | def getrelations(self):
return self.getfieldnames('ONE') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _filter_related_one2one(self, rel):\n field = rel.field\n if isinstance(field, models.OneToOneField):\n if self._join_allowed(rel.parent_model, rel.model, field):\n return rel",
"def relationship(cls):\n return relationship.many_to_one(cls, 'relationship')",
"... | [
"0.67867416",
"0.6581883",
"0.60937566",
"0.6083249",
"0.6047415",
"0.603017",
"0.58113414",
"0.5705639",
"0.55900675",
"0.55657053",
"0.5440979",
"0.54282725",
"0.5387697",
"0.53740245",
"0.5348175",
"0.5317037",
"0.53037167",
"0.5272414",
"0.5238443",
"0.51848626",
"0.51807... | 0.7039067 | 0 |
Return the one to many relations (relType == MANY). | def getmanyrelations(self):
return self.getfieldnames('MANY') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getrelations(self):\n return self.getfieldnames('ONE')",
"def relations(self):\n return set(self.triples()[\"relation\"])",
"def relationships(self):",
"def get_relations(self):\n triples = list(self.get_triples())\n\n for s, p, o in triples:\n if not p.startswith(\... | [
"0.7096476",
"0.655924",
"0.6366319",
"0.61227846",
"0.60044825",
"0.5877629",
"0.58542055",
"0.5840653",
"0.5739393",
"0.5713277",
"0.56678456",
"0.56351084",
"0.56170446",
"0.55665904",
"0.54818785",
"0.5468127",
"0.5463287",
"0.5452604",
"0.54127836",
"0.53986883",
"0.5376... | 0.72177327 | 0 |
Check whether the entity is consistent with this entity info. The entity is supposed to be a subclass of Entity. Report any abnormalities as warnings to the logger. Return the number of warnings emitted. | def check(self, entity):
nwarn = 0
if entity is None:
return nwarn
if not issubclass(entity, Entity):
raise TypeError("invalid argument %s, expect subclass of Entity" %
entity)
cname = entity.__name__
beanname = self.beanna... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check(self):\n\n nwarn = 0\n\n # Check that the set of entity types is the same as in the\n # schema.\n schemanames = set(self.schema.keys())\n clientnames = set(self.client.typemap.keys())\n missing = schemanames - clientnames\n if missing:\n log.war... | [
"0.7488003",
"0.59518033",
"0.5554449",
"0.5366329",
"0.5356038",
"0.52137417",
"0.51991415",
"0.5177108",
"0.51752853",
"0.51362544",
"0.5122849",
"0.5115364",
"0.5110129",
"0.5092445",
"0.5081767",
"0.5057919",
"0.50373167",
"0.50053465",
"0.4978771",
"0.49643213",
"0.49566... | 0.7879822 | 0 |
Generate Python source code that matches this entity info. | def pythonsrc(self, baseclass=None):
classname = self.classname
baseclassname = 'object'
classcomment = getattr(self.info, 'classComment', None)
beanname = self.beanname
addbeanname = True
constraint = self.getconstraint()
attrs = self.getattrs()
rels = s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GenerateCode(self):\n print \"Generating code...\"\n for type in self.getObjectTypes():\n generator = __import__(\"codegen.Cpp\" + type, globals(), locals(), [''])\n print \"Generating code for objects of type: %s\" % type\n generator.GenerateCode(self)",
"def p... | [
"0.6679202",
"0.6412018",
"0.63619685",
"0.63239324",
"0.6240753",
"0.61866945",
"0.6157373",
"0.61450505",
"0.6134166",
"0.61248934",
"0.61220515",
"0.6111966",
"0.60819286",
"0.60318035",
"0.60003656",
"0.5964006",
"0.5953856",
"0.59330505",
"0.5929046",
"0.59027636",
"0.59... | 0.63368255 | 3 |
Return a list of the types defined in the WSDL. | def gettypes(self):
return [str(self.sd.xlate(t[0])) for t in self.sd.types] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTypesList():\n return Gw2Spidy._request('types')['results']",
"def getTypes(self):\n return self._doRequest(self.httpClient.getTypes)",
"def get_types(self):\n return self.types",
"def get_all_typedefs(self):\n results = None\n atlas_endpoint = self.endpoint_url + \"... | [
"0.78909266",
"0.7311105",
"0.6980529",
"0.69686353",
"0.6921955",
"0.67903304",
"0.67817074",
"0.64911914",
"0.6482584",
"0.64383173",
"0.6416266",
"0.6387607",
"0.6387607",
"0.63486254",
"0.63159",
"0.62426966",
"0.6187318",
"0.61764884",
"0.6115866",
"0.6105615",
"0.599553... | 0.66607785 | 7 |
Search for entities defined at the server. Return a dict with type names as keys and EntityInfo objects as values. | def getentities(self):
entities = {}
# The following will create lots of errors in suds.client, one
# for every type that is not an entity. Disable their logger
# temporarily to avoid cluttering the log.
sudslog = logging.getLogger('suds.client')
sudssav = sudslog.disab... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def readEntities(self):\r\n entities = {}\r\n \r\n # Regexes must be greedy to prevent matching outer entity and end_entity strings\r\n # Regexes have re.DOTALL to match newlines\r\n for m in re.finditer(\"ENTITY (.*?)END_ENTITY;\", self.data, re.DOTALL):\r\n entity = ... | [
"0.654492",
"0.63510257",
"0.6295548",
"0.61492395",
"0.5928663",
"0.58731294",
"0.581502",
"0.580751",
"0.579876",
"0.5771325",
"0.57671726",
"0.5759269",
"0.57302684",
"0.5673989",
"0.5636686",
"0.55597204",
"0.55591005",
"0.5551724",
"0.55411315",
"0.55391514",
"0.55371106... | 0.7634091 | 0 |
Check consistency of the ICAT client with the server schema. Report any abnormalities as warnings to the logger. Returns the number of warnings emitted. | def check(self):
nwarn = 0
# Check that the set of entity types is the same as in the
# schema.
schemanames = set(self.schema.keys())
clientnames = set(self.client.typemap.keys())
missing = schemanames - clientnames
if missing:
log.warning("missing e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def checkExceptions(self):\n\n nwarn = 0\n\n icatExceptionType = self.client.factory.create('icatExceptionType')\n schemaexceptions = set(icatExceptionType.__keylist__)\n clientexceptions = set(icat.exception.IcatExceptionTypeMap.keys())\n missing = schemaexceptions - clientexcep... | [
"0.62300956",
"0.5898869",
"0.5719125",
"0.5677171",
"0.56404877",
"0.5635841",
"0.56192327",
"0.55733836",
"0.5571429",
"0.551054",
"0.54961216",
"0.54919946",
"0.54901636",
"0.54901636",
"0.54901636",
"0.54901636",
"0.54901636",
"0.54901636",
"0.54901636",
"0.54901636",
"0.... | 0.6281774 | 0 |
Check consistency of exceptions. Check that all icatExceptionTypes defined in the WSDL have a corresponding exception class defined in icat.exception. Report missing exceptions as a warning to the logger. Return the number of warnings emitted. | def checkExceptions(self):
nwarn = 0
icatExceptionType = self.client.factory.create('icatExceptionType')
schemaexceptions = set(icatExceptionType.__keylist__)
clientexceptions = set(icat.exception.IcatExceptionTypeMap.keys())
missing = schemaexceptions - clientexceptions
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_error_types(graph: BELGraph) -> typing.Counter[str]:\n return Counter(exc.__class__.__name__ for _, exc, _ in graph.warnings)",
"def check(self):\n\n nwarn = 0\n\n # Check that the set of entity types is the same as in the\n # schema.\n schemanames = set(self.schema.keys(... | [
"0.6489571",
"0.5932624",
"0.57542944",
"0.5629398",
"0.54877156",
"0.53069246",
"0.52667695",
"0.52545625",
"0.51867276",
"0.5141248",
"0.5109995",
"0.5093013",
"0.50528795",
"0.5051258",
"0.50483483",
"0.5048305",
"0.50454915",
"0.5043633",
"0.50357765",
"0.50357765",
"0.50... | 0.8771143 | 0 |
Set up the genealogy of entity types. | def _genealogy(self, rules):
tree = { t:{'level':0, 'base':None} for t in self.schema.keys() }
for t in tree:
log.debug("checking ancestors of %s ...", t)
for r in rules:
if re.match(r[0], t):
b = r[1]
if b == t:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _initObjects(self):\n\n print \"DEBUG: Initializing Entities\"\n ObjectType.initializeObjectTypes()",
"def entity_type(self, entity_type):\n self._entity_type = entity_type",
"def init_elect_types(self):\n self.wta = WinnerTakeAll()\n self.proportional = Proportional()\n ... | [
"0.6412444",
"0.5900751",
"0.581962",
"0.5757027",
"0.5749391",
"0.57444316",
"0.57136536",
"0.5633914",
"0.55890703",
"0.5508194",
"0.54837847",
"0.5448058",
"0.54347545",
"0.54028016",
"0.53802484",
"0.5371926",
"0.53686976",
"0.5334806",
"0.5330833",
"0.5330235",
"0.532922... | 0.0 | -1 |
Generate Python source code matching the ICAT schema. Generate source code for a set of classes that match the entity info found at the server. The source code is returned as a string. The Python classes are created as a hierarchy. It is assumed that there is one abstract base type which is the root of the genealogy tr... | def pythonsrc(self, genealogyrules=None, baseclassname='Entity'):
if genealogyrules is None:
genealogyrules = [(r'','entityBaseBean')]
tree = self._genealogy(genealogyrules)
base = [t for t in tree if tree[t]['base'] is None][0]
self.schema[base].classname = baseclassname
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pythonsrc(self, baseclass=None):\n\n classname = self.classname\n baseclassname = 'object'\n classcomment = getattr(self.info, 'classComment', None)\n beanname = self.beanname\n addbeanname = True\n constraint = self.getconstraint()\n attrs = self.getattrs()\n ... | [
"0.6546843",
"0.6342097",
"0.61589974",
"0.61360514",
"0.58900464",
"0.55907094",
"0.55879545",
"0.5527749",
"0.54475427",
"0.54270315",
"0.540438",
"0.53865635",
"0.535935",
"0.52980083",
"0.52552074",
"0.5254086",
"0.5237905",
"0.5225976",
"0.5212285",
"0.5208125",
"0.51882... | 0.68348277 | 0 |
updates .coveralls.yml file to allow upload of coverage report | def update_coveralls_config(
path_to_coverage,
coveralls_token,
token_key='repo_token',
):
try:
with open(path_to_coverage, 'r') as cover_fh:
raw_file = cover_fh.read()
except FileNotFoundError:
raw_file = ''
# check if repo_token is already in .coveralls... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cover(ctx, html=False):\n header(cover.__doc__)\n extra = \"--cov-report html\" if html else \"\"\n with ctx.cd(ROOT):\n ctx.run(\n \"pytest --benchmark-skip --cov flask_restx --cov-report term --cov-report xml {0}\".format(\n extra\n ),\n pty=Tru... | [
"0.57402664",
"0.55637956",
"0.5521971",
"0.5499088",
"0.54615265",
"0.5441391",
"0.54214483",
"0.5401124",
"0.53201175",
"0.51842374",
"0.5157459",
"0.51465404",
"0.5143215",
"0.5136255",
"0.5116265",
"0.5108954",
"0.506716",
"0.49769455",
"0.49514818",
"0.49292338",
"0.4919... | 0.7289181 | 0 |
turn multiline config entry into a list of commands | def parse_command_list(config_str):
return [command for command in config_str.splitlines() if command] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def config_changes(cli):\n result = []\n in_config = False\n for line in cli.splitlines():\n if not in_config and line == 'Building configuration...':\n in_config = True\n elif in_config:\n result.append(line)\n\n return '\\n'.join(result)",
"def get_commands_list(... | [
"0.64328206",
"0.6407235",
"0.6104706",
"0.6073341",
"0.5869535",
"0.5853029",
"0.57613",
"0.5759418",
"0.568729",
"0.56760406",
"0.5661332",
"0.56305355",
"0.5599522",
"0.5569513",
"0.55690366",
"0.5557906",
"0.55198437",
"0.54839694",
"0.5481613",
"0.5474146",
"0.5458116",
... | 0.7687394 | 0 |
atexit handler for deactivating and removing local venv even if tools crash | def atexit_deactivate_venv(
venv_name,
cwd,
logger=p_logging.DEFAULT_LOGGER
): # pragma: no cover
logger.info('Cleaning up venv post-test')
logger.info('--removing venv')
try:
rm_log = local['rm']('-rf', path.join(cwd, venv_name))
logger.debug(rm_log)
except Exc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def env_cleanup(self):\n pass",
"def tear_down(self):\n self.destroy_env()\n self.dut.kill_all()",
"def teardown(self):\n self.logger.info('Tearing down file server vm')\n self.local_env.execute('uninstall', task_retries=40,\n task_retry_interval... | [
"0.6747679",
"0.6670127",
"0.66516036",
"0.6634058",
"0.6194183",
"0.6155125",
"0.6096577",
"0.6070269",
"0.6064456",
"0.60605145",
"0.6057598",
"0.60506946",
"0.6045445",
"0.6012506",
"0.6011123",
"0.59959084",
"0.598898",
"0.5965664",
"0.59515667",
"0.5941659",
"0.59395814"... | 0.7242372 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.